1 /*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <errno.h>
18 #include <fcntl.h>
19 #include <linux/input.h>
20 #include <pthread.h>
21 #include <stdarg.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <sys/stat.h>
26 #include <sys/time.h>
27 #include <sys/types.h>
28 #include <time.h>
29 #include <unistd.h>
30
31 #include <cutils/properties.h>
32 #include <cutils/android_reboot.h>
33
34 #include "common.h"
35 #include "roots.h"
36 #include "device.h"
37 #include "minui/minui.h"
38 #include "screen_ui.h"
39 #include "ui.h"
40
41 #define UI_WAIT_KEY_TIMEOUT_SEC 120
42
RecoveryUI()43 RecoveryUI::RecoveryUI()
44 : key_queue_len(0),
45 key_last_down(-1),
46 key_long_press(false),
47 key_down_count(0),
48 enable_reboot(true),
49 consecutive_power_keys(0),
50 last_key(-1),
51 has_power_key(false),
52 has_up_key(false),
53 has_down_key(false) {
54 pthread_mutex_init(&key_queue_mutex, nullptr);
55 pthread_cond_init(&key_queue_cond, nullptr);
56 memset(key_pressed, 0, sizeof(key_pressed));
57 }
58
OnKeyDetected(int key_code)59 void RecoveryUI::OnKeyDetected(int key_code) {
60 if (key_code == KEY_POWER) {
61 has_power_key = true;
62 } else if (key_code == KEY_DOWN || key_code == KEY_VOLUMEDOWN) {
63 has_down_key = true;
64 } else if (key_code == KEY_UP || key_code == KEY_VOLUMEUP) {
65 has_up_key = true;
66 }
67 }
68
InputCallback(int fd,uint32_t epevents,void * data)69 int RecoveryUI::InputCallback(int fd, uint32_t epevents, void* data) {
70 return reinterpret_cast<RecoveryUI*>(data)->OnInputEvent(fd, epevents);
71 }
72
73 // Reads input events, handles special hot keys, and adds to the key queue.
InputThreadLoop(void *)74 static void* InputThreadLoop(void*) {
75 while (true) {
76 if (!ev_wait(-1)) {
77 ev_dispatch();
78 }
79 }
80 return nullptr;
81 }
82
Init()83 void RecoveryUI::Init() {
84 ev_init(InputCallback, this);
85
86 ev_iterate_available_keys(std::bind(&RecoveryUI::OnKeyDetected, this, std::placeholders::_1));
87
88 pthread_create(&input_thread_, nullptr, InputThreadLoop, nullptr);
89 }
90
OnInputEvent(int fd,uint32_t epevents)91 int RecoveryUI::OnInputEvent(int fd, uint32_t epevents) {
92 struct input_event ev;
93 if (ev_get_input(fd, epevents, &ev) == -1) {
94 return -1;
95 }
96
97 if (ev.type == EV_SYN) {
98 return 0;
99 } else if (ev.type == EV_REL) {
100 if (ev.code == REL_Y) {
101 // accumulate the up or down motion reported by
102 // the trackball. When it exceeds a threshold
103 // (positive or negative), fake an up/down
104 // key event.
105 rel_sum += ev.value;
106 if (rel_sum > 3) {
107 ProcessKey(KEY_DOWN, 1); // press down key
108 ProcessKey(KEY_DOWN, 0); // and release it
109 rel_sum = 0;
110 } else if (rel_sum < -3) {
111 ProcessKey(KEY_UP, 1); // press up key
112 ProcessKey(KEY_UP, 0); // and release it
113 rel_sum = 0;
114 }
115 }
116 } else {
117 rel_sum = 0;
118 }
119
120 if (ev.type == EV_KEY && ev.code <= KEY_MAX) {
121 ProcessKey(ev.code, ev.value);
122 }
123
124 return 0;
125 }
126
127 // Process a key-up or -down event. A key is "registered" when it is
128 // pressed and then released, with no other keypresses or releases in
129 // between. Registered keys are passed to CheckKey() to see if it
130 // should trigger a visibility toggle, an immediate reboot, or be
131 // queued to be processed next time the foreground thread wants a key
132 // (eg, for the menu).
133 //
134 // We also keep track of which keys are currently down so that
135 // CheckKey can call IsKeyPressed to see what other keys are held when
136 // a key is registered.
137 //
138 // updown == 1 for key down events; 0 for key up events
ProcessKey(int key_code,int updown)139 void RecoveryUI::ProcessKey(int key_code, int updown) {
140 bool register_key = false;
141 bool long_press = false;
142 bool reboot_enabled;
143
144 pthread_mutex_lock(&key_queue_mutex);
145 key_pressed[key_code] = updown;
146 if (updown) {
147 ++key_down_count;
148 key_last_down = key_code;
149 key_long_press = false;
150 key_timer_t* info = new key_timer_t;
151 info->ui = this;
152 info->key_code = key_code;
153 info->count = key_down_count;
154 pthread_t thread;
155 pthread_create(&thread, nullptr, &RecoveryUI::time_key_helper, info);
156 pthread_detach(thread);
157 } else {
158 if (key_last_down == key_code) {
159 long_press = key_long_press;
160 register_key = true;
161 }
162 key_last_down = -1;
163 }
164 reboot_enabled = enable_reboot;
165 pthread_mutex_unlock(&key_queue_mutex);
166
167 if (register_key) {
168 switch (CheckKey(key_code, long_press)) {
169 case RecoveryUI::IGNORE:
170 break;
171
172 case RecoveryUI::TOGGLE:
173 ShowText(!IsTextVisible());
174 break;
175
176 case RecoveryUI::REBOOT:
177 if (reboot_enabled) {
178 property_set(ANDROID_RB_PROPERTY, "reboot,");
179 while (true) { pause(); }
180 }
181 break;
182
183 case RecoveryUI::ENQUEUE:
184 EnqueueKey(key_code);
185 break;
186 }
187 }
188 }
189
time_key_helper(void * cookie)190 void* RecoveryUI::time_key_helper(void* cookie) {
191 key_timer_t* info = (key_timer_t*) cookie;
192 info->ui->time_key(info->key_code, info->count);
193 delete info;
194 return nullptr;
195 }
196
time_key(int key_code,int count)197 void RecoveryUI::time_key(int key_code, int count) {
198 usleep(750000); // 750 ms == "long"
199 bool long_press = false;
200 pthread_mutex_lock(&key_queue_mutex);
201 if (key_last_down == key_code && key_down_count == count) {
202 long_press = key_long_press = true;
203 }
204 pthread_mutex_unlock(&key_queue_mutex);
205 if (long_press) KeyLongPress(key_code);
206 }
207
EnqueueKey(int key_code)208 void RecoveryUI::EnqueueKey(int key_code) {
209 pthread_mutex_lock(&key_queue_mutex);
210 const int queue_max = sizeof(key_queue) / sizeof(key_queue[0]);
211 if (key_queue_len < queue_max) {
212 key_queue[key_queue_len++] = key_code;
213 pthread_cond_signal(&key_queue_cond);
214 }
215 pthread_mutex_unlock(&key_queue_mutex);
216 }
217
WaitKey()218 int RecoveryUI::WaitKey() {
219 pthread_mutex_lock(&key_queue_mutex);
220
221 // Time out after UI_WAIT_KEY_TIMEOUT_SEC, unless a USB cable is
222 // plugged in.
223 do {
224 struct timeval now;
225 struct timespec timeout;
226 gettimeofday(&now, nullptr);
227 timeout.tv_sec = now.tv_sec;
228 timeout.tv_nsec = now.tv_usec * 1000;
229 timeout.tv_sec += UI_WAIT_KEY_TIMEOUT_SEC;
230
231 int rc = 0;
232 while (key_queue_len == 0 && rc != ETIMEDOUT) {
233 rc = pthread_cond_timedwait(&key_queue_cond, &key_queue_mutex, &timeout);
234 }
235 } while (IsUsbConnected() && key_queue_len == 0);
236
237 int key = -1;
238 if (key_queue_len > 0) {
239 key = key_queue[0];
240 memcpy(&key_queue[0], &key_queue[1], sizeof(int) * --key_queue_len);
241 }
242 pthread_mutex_unlock(&key_queue_mutex);
243 return key;
244 }
245
IsUsbConnected()246 bool RecoveryUI::IsUsbConnected() {
247 int fd = open("/sys/class/android_usb/android0/state", O_RDONLY);
248 if (fd < 0) {
249 printf("failed to open /sys/class/android_usb/android0/state: %s\n",
250 strerror(errno));
251 return 0;
252 }
253
254 char buf;
255 // USB is connected if android_usb state is CONNECTED or CONFIGURED.
256 int connected = (TEMP_FAILURE_RETRY(read(fd, &buf, 1)) == 1) && (buf == 'C');
257 if (close(fd) < 0) {
258 printf("failed to close /sys/class/android_usb/android0/state: %s\n",
259 strerror(errno));
260 }
261 return connected;
262 }
263
IsKeyPressed(int key)264 bool RecoveryUI::IsKeyPressed(int key) {
265 pthread_mutex_lock(&key_queue_mutex);
266 int pressed = key_pressed[key];
267 pthread_mutex_unlock(&key_queue_mutex);
268 return pressed;
269 }
270
IsLongPress()271 bool RecoveryUI::IsLongPress() {
272 pthread_mutex_lock(&key_queue_mutex);
273 bool result = key_long_press;
274 pthread_mutex_unlock(&key_queue_mutex);
275 return result;
276 }
277
HasThreeButtons()278 bool RecoveryUI::HasThreeButtons() {
279 return has_power_key && has_up_key && has_down_key;
280 }
281
FlushKeys()282 void RecoveryUI::FlushKeys() {
283 pthread_mutex_lock(&key_queue_mutex);
284 key_queue_len = 0;
285 pthread_mutex_unlock(&key_queue_mutex);
286 }
287
CheckKey(int key,bool is_long_press)288 RecoveryUI::KeyAction RecoveryUI::CheckKey(int key, bool is_long_press) {
289 pthread_mutex_lock(&key_queue_mutex);
290 key_long_press = false;
291 pthread_mutex_unlock(&key_queue_mutex);
292
293 // If we have power and volume up keys, that chord is the signal to toggle the text display.
294 if (HasThreeButtons()) {
295 if (key == KEY_VOLUMEUP && IsKeyPressed(KEY_POWER)) {
296 return TOGGLE;
297 }
298 } else {
299 // Otherwise long press of any button toggles to the text display,
300 // and there's no way to toggle back (but that's pretty useless anyway).
301 if (is_long_press && !IsTextVisible()) {
302 return TOGGLE;
303 }
304
305 // Also, for button-limited devices, a long press is translated to KEY_ENTER.
306 if (is_long_press && IsTextVisible()) {
307 EnqueueKey(KEY_ENTER);
308 return IGNORE;
309 }
310 }
311
312 // Press power seven times in a row to reboot.
313 if (key == KEY_POWER) {
314 pthread_mutex_lock(&key_queue_mutex);
315 bool reboot_enabled = enable_reboot;
316 pthread_mutex_unlock(&key_queue_mutex);
317
318 if (reboot_enabled) {
319 ++consecutive_power_keys;
320 if (consecutive_power_keys >= 7) {
321 return REBOOT;
322 }
323 }
324 } else {
325 consecutive_power_keys = 0;
326 }
327
328 last_key = key;
329 return IsTextVisible() ? ENQUEUE : IGNORE;
330 }
331
KeyLongPress(int)332 void RecoveryUI::KeyLongPress(int) {
333 }
334
SetEnableReboot(bool enabled)335 void RecoveryUI::SetEnableReboot(bool enabled) {
336 pthread_mutex_lock(&key_queue_mutex);
337 enable_reboot = enabled;
338 pthread_mutex_unlock(&key_queue_mutex);
339 }
340