blob: 98c654ddb15dd3fb877d8207c8fd6da7eacf72ce [file] [log] [blame]
Doug Zongker32a0a472011-11-01 11:00:20 -07001/*
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
Tianjie Xu8f397302018-08-20 13:40:47 -070017#include "recovery_ui/ui.h"
Tao Bao736d59c2017-01-03 10:15:33 -080018
Doug Zongker32a0a472011-11-01 11:00:20 -070019#include <errno.h>
20#include <fcntl.h>
Doug Zongker32a0a472011-11-01 11:00:20 -070021#include <stdio.h>
22#include <stdlib.h>
23#include <string.h>
Doug Zongker32a0a472011-11-01 11:00:20 -070024#include <sys/time.h>
25#include <sys/types.h>
26#include <time.h>
27#include <unistd.h>
28
Tao Bao26ea9592018-05-09 16:32:02 -070029#include <chrono>
Tao Bao9468fc02017-03-17 00:57:37 -070030#include <functional>
Tao Bao736d59c2017-01-03 10:15:33 -080031#include <string>
Tao Bao26ea9592018-05-09 16:32:02 -070032#include <thread>
Tao Bao736d59c2017-01-03 10:15:33 -080033
Tao Bao6278bdf2017-01-16 17:38:18 -080034#include <android-base/file.h>
35#include <android-base/logging.h>
36#include <android-base/parseint.h>
Tao Bao0bc88de2018-07-31 14:53:16 -070037#include <android-base/properties.h>
Tao Bao6278bdf2017-01-16 17:38:18 -080038#include <android-base/strings.h>
Doug Zongker32a0a472011-11-01 11:00:20 -070039
Tao Bao26ea9592018-05-09 16:32:02 -070040#include "minui/minui.h"
Tao Bao2c526392018-05-03 23:01:13 -070041#include "otautil/sysutil.h"
Doug Zongker32a0a472011-11-01 11:00:20 -070042
Tao Bao26ea9592018-05-09 16:32:02 -070043using namespace std::chrono_literals;
44
Tao Bao0bc88de2018-07-31 14:53:16 -070045constexpr int UI_WAIT_KEY_TIMEOUT_SEC = 120;
46constexpr const char* BRIGHTNESS_FILE = "/sys/class/leds/lcd-backlight/brightness";
47constexpr const char* MAX_BRIGHTNESS_FILE = "/sys/class/leds/lcd-backlight/max_brightness";
48constexpr const char* BRIGHTNESS_FILE_SDM = "/sys/class/backlight/panel0-backlight/brightness";
49constexpr const char* MAX_BRIGHTNESS_FILE_SDM =
kataoc35c1b02017-12-08 11:02:43 +080050 "/sys/class/backlight/panel0-backlight/max_brightness";
Doug Zongker32a0a472011-11-01 11:00:20 -070051
Tao Bao0bc88de2018-07-31 14:53:16 -070052constexpr int kDefaultTouchLowThreshold = 50;
53constexpr int kDefaultTouchHighThreshold = 90;
54
Elliott Hughesec283402015-04-10 10:01:53 -070055RecoveryUI::RecoveryUI()
Tao Baoefb49ad2017-01-31 23:03:10 -080056 : brightness_normal_(50),
Tao Bao6278bdf2017-01-16 17:38:18 -080057 brightness_dimmed_(25),
kataoc35c1b02017-12-08 11:02:43 +080058 brightness_file_(BRIGHTNESS_FILE),
59 max_brightness_file_(MAX_BRIGHTNESS_FILE),
Tao Bao5f8dd992017-07-28 00:05:40 -070060 touch_screen_allowed_(false),
David Anderson983e2d52019-01-02 11:35:38 -080061 fastbootd_logo_enabled_(false),
Tao Bao0bc88de2018-07-31 14:53:16 -070062 touch_low_threshold_(android::base::GetIntProperty("ro.recovery.ui.touch_low_threshold",
63 kDefaultTouchLowThreshold)),
64 touch_high_threshold_(android::base::GetIntProperty("ro.recovery.ui.touch_high_threshold",
65 kDefaultTouchHighThreshold)),
Jerry Zhangb76af932018-05-22 12:08:35 -070066 key_interrupted_(false),
Tao Bao736d59c2017-01-03 10:15:33 -080067 key_queue_len(0),
68 key_last_down(-1),
69 key_long_press(false),
70 key_down_count(0),
71 enable_reboot(true),
72 consecutive_power_keys(0),
Tao Bao736d59c2017-01-03 10:15:33 -080073 has_power_key(false),
74 has_up_key(false),
Tao Bao6278bdf2017-01-16 17:38:18 -080075 has_down_key(false),
Tao Bao5f8dd992017-07-28 00:05:40 -070076 has_touch_screen(false),
77 touch_slot_(0),
Tao Bao046aae22017-07-31 23:15:09 -070078 is_bootreason_recovery_ui_(false),
Tao Bao6278bdf2017-01-16 17:38:18 -080079 screensaver_state_(ScreensaverState::DISABLED) {
Tao Bao736d59c2017-01-03 10:15:33 -080080 memset(key_pressed, 0, sizeof(key_pressed));
Doug Zongker32a0a472011-11-01 11:00:20 -070081}
82
Tao Bao26ea9592018-05-09 16:32:02 -070083RecoveryUI::~RecoveryUI() {
84 ev_exit();
85 input_thread_stopped_ = true;
Tao Bao94371fd2018-06-06 07:38:54 -070086 if (input_thread_.joinable()) {
87 input_thread_.join();
88 }
Tao Bao26ea9592018-05-09 16:32:02 -070089}
90
Elliott Hughes642aaa72015-04-10 12:47:46 -070091void RecoveryUI::OnKeyDetected(int key_code) {
Tao Bao5d2e3bd2017-06-23 22:23:50 -070092 if (key_code == KEY_POWER) {
93 has_power_key = true;
94 } else if (key_code == KEY_DOWN || key_code == KEY_VOLUMEDOWN) {
95 has_down_key = true;
96 } else if (key_code == KEY_UP || key_code == KEY_VOLUMEUP) {
97 has_up_key = true;
Tao Bao5f8dd992017-07-28 00:05:40 -070098 } else if (key_code == ABS_MT_POSITION_X || key_code == ABS_MT_POSITION_Y) {
99 has_touch_screen = true;
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700100 }
Elliott Hughes642aaa72015-04-10 12:47:46 -0700101}
102
Tao Bao6278bdf2017-01-16 17:38:18 -0800103bool RecoveryUI::InitScreensaver() {
104 // Disabled.
105 if (brightness_normal_ == 0 || brightness_dimmed_ > brightness_normal_) {
106 return false;
107 }
kataoc35c1b02017-12-08 11:02:43 +0800108 if (access(brightness_file_.c_str(), R_OK | W_OK)) {
109 brightness_file_ = BRIGHTNESS_FILE_SDM;
110 }
111 if (access(max_brightness_file_.c_str(), R_OK)) {
112 max_brightness_file_ = MAX_BRIGHTNESS_FILE_SDM;
113 }
Tao Bao6278bdf2017-01-16 17:38:18 -0800114 // Set the initial brightness level based on the max brightness. Note that reading the initial
115 // value from BRIGHTNESS_FILE doesn't give the actual brightness value (bullhead, sailfish), so
116 // we don't have a good way to query the default value.
117 std::string content;
kataoc35c1b02017-12-08 11:02:43 +0800118 if (!android::base::ReadFileToString(max_brightness_file_, &content)) {
Tao Bao8eec3732017-01-31 21:24:16 -0800119 PLOG(WARNING) << "Failed to read max brightness";
Tao Bao6278bdf2017-01-16 17:38:18 -0800120 return false;
121 }
122
123 unsigned int max_value;
124 if (!android::base::ParseUint(android::base::Trim(content), &max_value)) {
125 LOG(WARNING) << "Failed to parse max brightness: " << content;
126 return false;
127 }
128
129 brightness_normal_value_ = max_value * brightness_normal_ / 100.0;
130 brightness_dimmed_value_ = max_value * brightness_dimmed_ / 100.0;
131 if (!android::base::WriteStringToFile(std::to_string(brightness_normal_value_),
kataoc35c1b02017-12-08 11:02:43 +0800132 brightness_file_)) {
Tao Bao6278bdf2017-01-16 17:38:18 -0800133 PLOG(WARNING) << "Failed to set brightness";
134 return false;
135 }
136
137 LOG(INFO) << "Brightness: " << brightness_normal_value_ << " (" << brightness_normal_ << "%)";
138 screensaver_state_ = ScreensaverState::NORMAL;
139 return true;
140}
141
Tao Baoefb49ad2017-01-31 23:03:10 -0800142bool RecoveryUI::Init(const std::string& /* locale */) {
Tao Bao5f8dd992017-07-28 00:05:40 -0700143 ev_init(std::bind(&RecoveryUI::OnInputEvent, this, std::placeholders::_1, std::placeholders::_2),
144 touch_screen_allowed_);
Elliott Hughes985022a2015-04-13 13:04:32 -0700145
Tao Bao736d59c2017-01-03 10:15:33 -0800146 ev_iterate_available_keys(std::bind(&RecoveryUI::OnKeyDetected, this, std::placeholders::_1));
147
Tao Bao5f8dd992017-07-28 00:05:40 -0700148 if (touch_screen_allowed_) {
149 ev_iterate_touch_inputs(std::bind(&RecoveryUI::OnKeyDetected, this, std::placeholders::_1));
Tao Bao046aae22017-07-31 23:15:09 -0700150
151 // Parse /proc/cmdline to determine if it's booting into recovery with a bootreason of
152 // "recovery_ui". This specific reason is set by some (wear) bootloaders, to allow an easier way
153 // to turn on text mode. It will only be set if the recovery boot is triggered from fastboot, or
154 // with 'adb reboot recovery'. Note that this applies to all build variants. Otherwise the text
155 // mode will be turned on automatically on debuggable builds, even without a swipe.
156 std::string cmdline;
157 if (android::base::ReadFileToString("/proc/cmdline", &cmdline)) {
158 is_bootreason_recovery_ui_ = cmdline.find("bootreason=recovery_ui") != std::string::npos;
159 } else {
160 // Non-fatal, and won't affect Init() result.
161 PLOG(WARNING) << "Failed to read /proc/cmdline";
162 }
Tao Bao5f8dd992017-07-28 00:05:40 -0700163 }
164
Tao Bao6278bdf2017-01-16 17:38:18 -0800165 if (!InitScreensaver()) {
166 LOG(INFO) << "Screensaver disabled";
167 }
168
Tao Bao26ea9592018-05-09 16:32:02 -0700169 // Create a separate thread that handles input events.
170 input_thread_ = std::thread([this]() {
171 while (!this->input_thread_stopped_) {
172 if (!ev_wait(500)) {
173 ev_dispatch();
174 }
175 }
176 });
177
Tao Bao736d59c2017-01-03 10:15:33 -0800178 return true;
Elliott Hughes985022a2015-04-13 13:04:32 -0700179}
180
Tao Bao5f8dd992017-07-28 00:05:40 -0700181void RecoveryUI::OnTouchDetected(int dx, int dy) {
182 enum SwipeDirection { UP, DOWN, RIGHT, LEFT } direction;
183
184 // We only consider a valid swipe if:
Tao Bao0bc88de2018-07-31 14:53:16 -0700185 // - the delta along one axis is below touch_low_threshold_;
186 // - and the delta along the other axis is beyond touch_high_threshold_.
187 if (abs(dy) < touch_low_threshold_ && abs(dx) > touch_high_threshold_) {
Tao Bao5f8dd992017-07-28 00:05:40 -0700188 direction = dx < 0 ? SwipeDirection::LEFT : SwipeDirection::RIGHT;
Tao Bao0bc88de2018-07-31 14:53:16 -0700189 } else if (abs(dx) < touch_low_threshold_ && abs(dy) > touch_high_threshold_) {
Tao Bao5f8dd992017-07-28 00:05:40 -0700190 direction = dy < 0 ? SwipeDirection::UP : SwipeDirection::DOWN;
191 } else {
Tao Bao0bc88de2018-07-31 14:53:16 -0700192 LOG(DEBUG) << "Ignored " << dx << " " << dy << " (low: " << touch_low_threshold_
193 << ", high: " << touch_high_threshold_ << ")";
Tao Bao5f8dd992017-07-28 00:05:40 -0700194 return;
195 }
196
Tao Bao046aae22017-07-31 23:15:09 -0700197 // Allow turning on text mode with any swipe, if bootloader has set a bootreason of recovery_ui.
198 if (is_bootreason_recovery_ui_ && !IsTextVisible()) {
199 ShowText(true);
200 return;
201 }
202
Tao Bao5f8dd992017-07-28 00:05:40 -0700203 LOG(DEBUG) << "Swipe direction=" << direction;
204 switch (direction) {
205 case SwipeDirection::UP:
206 ProcessKey(KEY_UP, 1); // press up key
207 ProcessKey(KEY_UP, 0); // and release it
208 break;
209
210 case SwipeDirection::DOWN:
211 ProcessKey(KEY_DOWN, 1); // press down key
212 ProcessKey(KEY_DOWN, 0); // and release it
213 break;
214
215 case SwipeDirection::LEFT:
216 case SwipeDirection::RIGHT:
217 ProcessKey(KEY_POWER, 1); // press power key
218 ProcessKey(KEY_POWER, 0); // and release it
219 break;
220 };
221}
222
Elliott Hughes985022a2015-04-13 13:04:32 -0700223int RecoveryUI::OnInputEvent(int fd, uint32_t epevents) {
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700224 struct input_event ev;
225 if (ev_get_input(fd, epevents, &ev) == -1) {
226 return -1;
227 }
Doug Zongker32a0a472011-11-01 11:00:20 -0700228
Tao Bao5f8dd992017-07-28 00:05:40 -0700229 // Touch inputs handling.
230 //
231 // We handle the touch inputs by tracking the position changes between initial contacting and
232 // upon lifting. touch_start_X/Y record the initial positions, with touch_finger_down set. Upon
233 // detecting the lift, we unset touch_finger_down and detect a swipe based on position changes.
234 //
235 // Per the doc Multi-touch Protocol at below, there are two protocols.
236 // https://www.kernel.org/doc/Documentation/input/multi-touch-protocol.txt
237 //
238 // The main difference between the stateless type A protocol and the stateful type B slot protocol
239 // lies in the usage of identifiable contacts to reduce the amount of data sent to userspace. The
240 // slot protocol (i.e. type B) sends ABS_MT_TRACKING_ID with a unique id on initial contact, and
241 // sends ABS_MT_TRACKING_ID -1 upon lifting the contact. Protocol A doesn't send
242 // ABS_MT_TRACKING_ID -1 on lifting, but the driver may additionally report BTN_TOUCH event.
243 //
244 // For protocol A, we rely on BTN_TOUCH to recognize lifting, while for protocol B we look for
245 // ABS_MT_TRACKING_ID being -1.
246 //
247 // Touch input events will only be available if touch_screen_allowed_ is set.
248
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700249 if (ev.type == EV_SYN) {
Tao Bao5f8dd992017-07-28 00:05:40 -0700250 if (touch_screen_allowed_ && ev.code == SYN_REPORT) {
251 // There might be multiple SYN_REPORT events. We should only detect a swipe after lifting the
252 // contact.
253 if (touch_finger_down_ && !touch_swiping_) {
254 touch_start_X_ = touch_X_;
255 touch_start_Y_ = touch_Y_;
256 touch_swiping_ = true;
257 } else if (!touch_finger_down_ && touch_swiping_) {
258 touch_swiping_ = false;
259 OnTouchDetected(touch_X_ - touch_start_X_, touch_Y_ - touch_start_Y_);
260 }
261 }
Doug Zongker32a0a472011-11-01 11:00:20 -0700262 return 0;
Tao Bao5f8dd992017-07-28 00:05:40 -0700263 }
264
265 if (ev.type == EV_REL) {
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700266 if (ev.code == REL_Y) {
267 // accumulate the up or down motion reported by
268 // the trackball. When it exceeds a threshold
269 // (positive or negative), fake an up/down
270 // key event.
271 rel_sum += ev.value;
272 if (rel_sum > 3) {
273 ProcessKey(KEY_DOWN, 1); // press down key
274 ProcessKey(KEY_DOWN, 0); // and release it
275 rel_sum = 0;
276 } else if (rel_sum < -3) {
277 ProcessKey(KEY_UP, 1); // press up key
278 ProcessKey(KEY_UP, 0); // and release it
279 rel_sum = 0;
280 }
281 }
282 } else {
283 rel_sum = 0;
284 }
285
Tao Bao5f8dd992017-07-28 00:05:40 -0700286 if (touch_screen_allowed_ && ev.type == EV_ABS) {
287 if (ev.code == ABS_MT_SLOT) {
288 touch_slot_ = ev.value;
289 }
290 // Ignore other fingers.
291 if (touch_slot_ > 0) return 0;
292
293 switch (ev.code) {
294 case ABS_MT_POSITION_X:
295 touch_X_ = ev.value;
296 touch_finger_down_ = true;
297 break;
298
299 case ABS_MT_POSITION_Y:
300 touch_Y_ = ev.value;
301 touch_finger_down_ = true;
302 break;
303
304 case ABS_MT_TRACKING_ID:
305 // Protocol B: -1 marks lifting the contact.
306 if (ev.value < 0) touch_finger_down_ = false;
307 break;
308 }
309 return 0;
310 }
311
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700312 if (ev.type == EV_KEY && ev.code <= KEY_MAX) {
Tao Bao5f8dd992017-07-28 00:05:40 -0700313 if (touch_screen_allowed_) {
314 if (ev.code == BTN_TOUCH) {
315 // A BTN_TOUCH with value 1 indicates the start of contact (protocol A), with 0 means
316 // lifting the contact.
317 touch_finger_down_ = (ev.value == 1);
318 }
319
320 // Intentionally ignore BTN_TOUCH and BTN_TOOL_FINGER, which would otherwise trigger
321 // additional scrolling (because in ScreenRecoveryUI::ShowFile(), we consider keys other than
322 // KEY_POWER and KEY_UP as KEY_DOWN).
323 if (ev.code == BTN_TOUCH || ev.code == BTN_TOOL_FINGER) {
324 return 0;
325 }
326 }
327
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700328 ProcessKey(ev.code, ev.value);
329 }
330
331 return 0;
Doug Zongker32a0a472011-11-01 11:00:20 -0700332}
333
Tao Bao26ea9592018-05-09 16:32:02 -0700334// Processes a key-up or -down event. A key is "registered" when it is pressed and then released,
335// with no other keypresses or releases in between. Registered keys are passed to CheckKey() to
336// see if it should trigger a visibility toggle, an immediate reboot, or be queued to be processed
337// next time the foreground thread wants a key (eg, for the menu).
Doug Zongker32a0a472011-11-01 11:00:20 -0700338//
Tao Bao26ea9592018-05-09 16:32:02 -0700339// We also keep track of which keys are currently down so that CheckKey() can call IsKeyPressed()
340// to see what other keys are held when a key is registered.
Doug Zongker32a0a472011-11-01 11:00:20 -0700341//
342// updown == 1 for key down events; 0 for key up events
Elliott Hughes985022a2015-04-13 13:04:32 -0700343void RecoveryUI::ProcessKey(int key_code, int updown) {
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700344 bool register_key = false;
345 bool long_press = false;
Doug Zongkerbb01d0c2012-12-17 10:52:58 -0800346
Jerry Zhangb31f9ce2018-05-21 16:04:57 -0700347 {
Tianjie Xub8a959b2019-06-14 15:35:31 -0700348 std::lock_guard<std::mutex> lg(key_press_mutex);
Jerry Zhangb31f9ce2018-05-21 16:04:57 -0700349 key_pressed[key_code] = updown;
350 if (updown) {
351 ++key_down_count;
352 key_last_down = key_code;
353 key_long_press = false;
354 std::thread time_key_thread(&RecoveryUI::TimeKey, this, key_code, key_down_count);
355 time_key_thread.detach();
356 } else {
357 if (key_last_down == key_code) {
358 long_press = key_long_press;
359 register_key = true;
360 }
361 key_last_down = -1;
Doug Zongker32a0a472011-11-01 11:00:20 -0700362 }
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700363 }
Doug Zongker32a0a472011-11-01 11:00:20 -0700364
Jerry Zhangb31f9ce2018-05-21 16:04:57 -0700365 bool reboot_enabled = enable_reboot;
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700366 if (register_key) {
367 switch (CheckKey(key_code, long_press)) {
368 case RecoveryUI::IGNORE:
369 break;
Doug Zongker48b5b072012-01-18 13:46:26 -0800370
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700371 case RecoveryUI::TOGGLE:
372 ShowText(!IsTextVisible());
373 break;
Doug Zongker32a0a472011-11-01 11:00:20 -0700374
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700375 case RecoveryUI::REBOOT:
376 if (reboot_enabled) {
Mark Salyzyn488cc052019-05-20 10:36:16 -0700377 Reboot("userrequested,recovery,ui");
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700378 while (true) {
379 pause();
380 }
Doug Zongker32a0a472011-11-01 11:00:20 -0700381 }
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700382 break;
383
384 case RecoveryUI::ENQUEUE:
385 EnqueueKey(key_code);
386 break;
Doug Zongker32a0a472011-11-01 11:00:20 -0700387 }
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700388 }
Doug Zongker32a0a472011-11-01 11:00:20 -0700389}
390
Tao Bao26ea9592018-05-09 16:32:02 -0700391void RecoveryUI::TimeKey(int key_code, int count) {
392 std::this_thread::sleep_for(750ms); // 750 ms == "long"
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700393 bool long_press = false;
Jerry Zhangb31f9ce2018-05-21 16:04:57 -0700394 {
Tianjie Xub8a959b2019-06-14 15:35:31 -0700395 std::lock_guard<std::mutex> lg(key_press_mutex);
Jerry Zhangb31f9ce2018-05-21 16:04:57 -0700396 if (key_last_down == key_code && key_down_count == count) {
397 long_press = key_long_press = true;
398 }
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700399 }
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700400 if (long_press) KeyLongPress(key_code);
Doug Zongkerc0441d12013-07-31 11:28:24 -0700401}
402
Doug Zongkerbb01d0c2012-12-17 10:52:58 -0800403void RecoveryUI::EnqueueKey(int key_code) {
Jerry Zhangb31f9ce2018-05-21 16:04:57 -0700404 std::lock_guard<std::mutex> lg(key_queue_mutex);
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700405 const int queue_max = sizeof(key_queue) / sizeof(key_queue[0]);
406 if (key_queue_len < queue_max) {
407 key_queue[key_queue_len++] = key_code;
Jerry Zhangb31f9ce2018-05-21 16:04:57 -0700408 key_queue_cond.notify_one();
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700409 }
Doug Zongkerbb01d0c2012-12-17 10:52:58 -0800410}
411
Jerry Zhangb76af932018-05-22 12:08:35 -0700412void RecoveryUI::SetScreensaverState(ScreensaverState state) {
413 switch (state) {
414 case ScreensaverState::NORMAL:
415 if (android::base::WriteStringToFile(std::to_string(brightness_normal_value_),
416 brightness_file_)) {
417 screensaver_state_ = ScreensaverState::NORMAL;
418 LOG(INFO) << "Brightness: " << brightness_normal_value_ << " (" << brightness_normal_
419 << "%)";
420 } else {
Zhang, GaofengX852d9fe2019-06-11 11:16:30 +0800421 LOG(WARNING) << "Unable to set brightness to normal";
Jerry Zhangb76af932018-05-22 12:08:35 -0700422 }
423 break;
424 case ScreensaverState::DIMMED:
425 if (android::base::WriteStringToFile(std::to_string(brightness_dimmed_value_),
426 brightness_file_)) {
427 LOG(INFO) << "Brightness: " << brightness_dimmed_value_ << " (" << brightness_dimmed_
428 << "%)";
429 screensaver_state_ = ScreensaverState::DIMMED;
430 } else {
Zhang, GaofengX852d9fe2019-06-11 11:16:30 +0800431 LOG(WARNING) << "Unable to set brightness to dim";
Jerry Zhangb76af932018-05-22 12:08:35 -0700432 }
433 break;
434 case ScreensaverState::OFF:
435 if (android::base::WriteStringToFile("0", brightness_file_)) {
436 LOG(INFO) << "Brightness: 0 (off)";
437 screensaver_state_ = ScreensaverState::OFF;
438 } else {
Zhang, GaofengX852d9fe2019-06-11 11:16:30 +0800439 LOG(WARNING) << "Unable to set brightness to off";
Jerry Zhangb76af932018-05-22 12:08:35 -0700440 }
441 break;
442 default:
443 LOG(ERROR) << "Invalid screensaver state";
444 }
445}
446
Elliott Hughesec283402015-04-10 10:01:53 -0700447int RecoveryUI::WaitKey() {
Jerry Zhangb31f9ce2018-05-21 16:04:57 -0700448 std::unique_lock<std::mutex> lk(key_queue_mutex);
Doug Zongker32a0a472011-11-01 11:00:20 -0700449
Jerry Zhangb76af932018-05-22 12:08:35 -0700450 // Check for a saved key queue interruption.
451 if (key_interrupted_) {
452 SetScreensaverState(ScreensaverState::NORMAL);
453 return static_cast<int>(KeyError::INTERRUPTED);
454 }
455
Tao Bao53be3322018-08-16 11:48:50 -0700456 // Time out after UI_WAIT_KEY_TIMEOUT_SEC, unless a USB cable is plugged in.
Tao Bao6278bdf2017-01-16 17:38:18 -0800457 do {
Jerry Zhangb76af932018-05-22 12:08:35 -0700458 bool rc = key_queue_cond.wait_for(lk, std::chrono::seconds(UI_WAIT_KEY_TIMEOUT_SEC), [this] {
459 return this->key_queue_len != 0 || key_interrupted_;
460 });
461 if (key_interrupted_) {
462 SetScreensaverState(ScreensaverState::NORMAL);
463 return static_cast<int>(KeyError::INTERRUPTED);
Doug Zongker32a0a472011-11-01 11:00:20 -0700464 }
Tao Bao6278bdf2017-01-16 17:38:18 -0800465 if (screensaver_state_ != ScreensaverState::DISABLED) {
Jerry Zhangb76af932018-05-22 12:08:35 -0700466 if (!rc) {
Tao Bao53be3322018-08-16 11:48:50 -0700467 // Must be after a timeout. Lower the brightness level: NORMAL -> DIMMED; DIMMED -> OFF.
Tao Bao6278bdf2017-01-16 17:38:18 -0800468 if (screensaver_state_ == ScreensaverState::NORMAL) {
Jerry Zhangb76af932018-05-22 12:08:35 -0700469 SetScreensaverState(ScreensaverState::DIMMED);
Tao Bao6278bdf2017-01-16 17:38:18 -0800470 } else if (screensaver_state_ == ScreensaverState::DIMMED) {
Jerry Zhangb76af932018-05-22 12:08:35 -0700471 SetScreensaverState(ScreensaverState::OFF);
Tao Bao6278bdf2017-01-16 17:38:18 -0800472 }
Tao Bao53be3322018-08-16 11:48:50 -0700473 } else if (screensaver_state_ != ScreensaverState::NORMAL) {
Tao Bao6278bdf2017-01-16 17:38:18 -0800474 // Drop the first key if it's changing from OFF to NORMAL.
475 if (screensaver_state_ == ScreensaverState::OFF) {
476 if (key_queue_len > 0) {
477 memcpy(&key_queue[0], &key_queue[1], sizeof(int) * --key_queue_len);
478 }
479 }
480
481 // Reset the brightness to normal.
Jerry Zhangb76af932018-05-22 12:08:35 -0700482 SetScreensaverState(ScreensaverState::NORMAL);
Tao Bao6278bdf2017-01-16 17:38:18 -0800483 }
484 }
485 } while (IsUsbConnected() && key_queue_len == 0);
486
Jerry Zhangb76af932018-05-22 12:08:35 -0700487 int key = static_cast<int>(KeyError::TIMED_OUT);
Tao Bao6278bdf2017-01-16 17:38:18 -0800488 if (key_queue_len > 0) {
489 key = key_queue[0];
490 memcpy(&key_queue[0], &key_queue[1], sizeof(int) * --key_queue_len);
491 }
Tao Bao6278bdf2017-01-16 17:38:18 -0800492 return key;
Doug Zongker32a0a472011-11-01 11:00:20 -0700493}
494
Jerry Zhangb76af932018-05-22 12:08:35 -0700495void RecoveryUI::InterruptKey() {
496 {
497 std::lock_guard<std::mutex> lg(key_queue_mutex);
498 key_interrupted_ = true;
499 }
500 key_queue_cond.notify_one();
501}
502
Elliott Hughes985022a2015-04-13 13:04:32 -0700503bool RecoveryUI::IsUsbConnected() {
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700504 int fd = open("/sys/class/android_usb/android0/state", O_RDONLY);
505 if (fd < 0) {
506 printf("failed to open /sys/class/android_usb/android0/state: %s\n", strerror(errno));
507 return 0;
508 }
Doug Zongker32a0a472011-11-01 11:00:20 -0700509
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700510 char buf;
511 // USB is connected if android_usb state is CONNECTED or CONFIGURED.
512 int connected = (TEMP_FAILURE_RETRY(read(fd, &buf, 1)) == 1) && (buf == 'C');
513 if (close(fd) < 0) {
514 printf("failed to close /sys/class/android_usb/android0/state: %s\n", strerror(errno));
515 }
516 return connected;
Doug Zongker32a0a472011-11-01 11:00:20 -0700517}
518
Elliott Hughesec283402015-04-10 10:01:53 -0700519bool RecoveryUI::IsKeyPressed(int key) {
Tianjie Xub8a959b2019-06-14 15:35:31 -0700520 std::lock_guard<std::mutex> lg(key_press_mutex);
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700521 int pressed = key_pressed[key];
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700522 return pressed;
Doug Zongker32a0a472011-11-01 11:00:20 -0700523}
524
Elliott Hughes642aaa72015-04-10 12:47:46 -0700525bool RecoveryUI::IsLongPress() {
Tianjie Xub8a959b2019-06-14 15:35:31 -0700526 std::lock_guard<std::mutex> lg(key_press_mutex);
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700527 bool result = key_long_press;
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700528 return result;
Elliott Hughes642aaa72015-04-10 12:47:46 -0700529}
530
Elliott Hughes4af215b2015-04-10 15:00:34 -0700531bool RecoveryUI::HasThreeButtons() {
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700532 return has_power_key && has_up_key && has_down_key;
Elliott Hughes4af215b2015-04-10 15:00:34 -0700533}
534
Tao Bao5f8dd992017-07-28 00:05:40 -0700535bool RecoveryUI::HasPowerKey() const {
536 return has_power_key;
537}
538
539bool RecoveryUI::HasTouchScreen() const {
540 return has_touch_screen;
541}
542
Doug Zongker32a0a472011-11-01 11:00:20 -0700543void RecoveryUI::FlushKeys() {
Jerry Zhangb31f9ce2018-05-21 16:04:57 -0700544 std::lock_guard<std::mutex> lg(key_queue_mutex);
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700545 key_queue_len = 0;
Doug Zongker32a0a472011-11-01 11:00:20 -0700546}
547
Elliott Hughes642aaa72015-04-10 12:47:46 -0700548RecoveryUI::KeyAction RecoveryUI::CheckKey(int key, bool is_long_press) {
Jerry Zhangb31f9ce2018-05-21 16:04:57 -0700549 {
Tianjie Xub8a959b2019-06-14 15:35:31 -0700550 std::lock_guard<std::mutex> lg(key_press_mutex);
Jerry Zhangb31f9ce2018-05-21 16:04:57 -0700551 key_long_press = false;
552 }
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700553
554 // If we have power and volume up keys, that chord is the signal to toggle the text display.
Tao Bao5f8dd992017-07-28 00:05:40 -0700555 if (HasThreeButtons() || (HasPowerKey() && HasTouchScreen() && touch_screen_allowed_)) {
556 if ((key == KEY_VOLUMEUP || key == KEY_UP) && IsKeyPressed(KEY_POWER)) {
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700557 return TOGGLE;
558 }
559 } else {
560 // Otherwise long press of any button toggles to the text display,
561 // and there's no way to toggle back (but that's pretty useless anyway).
562 if (is_long_press && !IsTextVisible()) {
563 return TOGGLE;
564 }
565
566 // Also, for button-limited devices, a long press is translated to KEY_ENTER.
567 if (is_long_press && IsTextVisible()) {
568 EnqueueKey(KEY_ENTER);
569 return IGNORE;
570 }
571 }
572
573 // Press power seven times in a row to reboot.
574 if (key == KEY_POWER) {
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700575 bool reboot_enabled = enable_reboot;
Elliott Hughes642aaa72015-04-10 12:47:46 -0700576
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700577 if (reboot_enabled) {
578 ++consecutive_power_keys;
579 if (consecutive_power_keys >= 7) {
580 return REBOOT;
581 }
Doug Zongker9e805d62013-09-04 13:44:38 -0700582 }
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700583 } else {
584 consecutive_power_keys = 0;
585 }
Doug Zongker9e805d62013-09-04 13:44:38 -0700586
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700587 return (IsTextVisible() || screensaver_state_ == ScreensaverState::OFF) ? ENQUEUE : IGNORE;
Doug Zongker32a0a472011-11-01 11:00:20 -0700588}
Doug Zongkerbb01d0c2012-12-17 10:52:58 -0800589
Tianjie Xu8f397302018-08-20 13:40:47 -0700590void RecoveryUI::KeyLongPress(int) {}
Doug Zongkerc704e062014-05-23 08:40:35 -0700591
592void RecoveryUI::SetEnableReboot(bool enabled) {
Tianjie Xub8a959b2019-06-14 15:35:31 -0700593 std::lock_guard<std::mutex> lg(key_press_mutex);
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700594 enable_reboot = enabled;
Doug Zongkerc704e062014-05-23 08:40:35 -0700595}