From 5d2e3bd109539282d1829e3579c1f762a9486382 Mon Sep 17 00:00:00 2001 From: Tao Bao Date: Fri, 23 Jun 2017 22:23:50 -0700 Subject: Formatting RecoveryUI related files. All cosmetic changes about indentation reformatting in this CL. Test: mmma bootable/recovery Change-Id: I4539e6244697d1f356b7eb10b961b52d7db561f7 --- ui.h | 296 +++++++++++++++++++++++++++++++++---------------------------------- 1 file changed, 148 insertions(+), 148 deletions(-) (limited to 'ui.h') diff --git a/ui.h b/ui.h index 823eb6574..ef63e1d70 100644 --- a/ui.h +++ b/ui.h @@ -25,163 +25,163 @@ // Abstract class for controlling the user interface during recovery. class RecoveryUI { - public: - RecoveryUI(); + public: + RecoveryUI(); - virtual ~RecoveryUI() { } + virtual ~RecoveryUI() {} - // Initialize the object; called before anything else. UI texts will be - // initialized according to the given locale. Returns true on success. - virtual bool Init(const std::string& locale); + // Initialize the object; called before anything else. UI texts will be + // initialized according to the given locale. Returns true on success. + virtual bool Init(const std::string& locale); - // Show a stage indicator. Call immediately after Init(). - virtual void SetStage(int current, int max) = 0; + // Show a stage indicator. Call immediately after Init(). + virtual void SetStage(int current, int max) = 0; - // Set the overall recovery state ("background image"). - enum Icon { NONE, INSTALLING_UPDATE, ERASING, NO_COMMAND, ERROR }; - virtual void SetBackground(Icon icon) = 0; - virtual void SetSystemUpdateText(bool security_update) = 0; + // Set the overall recovery state ("background image"). + enum Icon { NONE, INSTALLING_UPDATE, ERASING, NO_COMMAND, ERROR }; + virtual void SetBackground(Icon icon) = 0; + virtual void SetSystemUpdateText(bool security_update) = 0; - // --- progress indicator --- - enum ProgressType { EMPTY, INDETERMINATE, DETERMINATE }; - virtual void SetProgressType(ProgressType determinate) = 0; - - // Show a progress bar and define the scope of the next operation: - // portion - fraction of the progress bar the next operation will use - // seconds - expected time interval (progress bar moves at this minimum rate) - virtual void ShowProgress(float portion, float seconds) = 0; - - // Set progress bar position (0.0 - 1.0 within the scope defined - // by the last call to ShowProgress). - virtual void SetProgress(float fraction) = 0; - - // --- text log --- - - virtual void ShowText(bool visible) = 0; - - virtual bool IsTextVisible() = 0; - - virtual bool WasTextEverVisible() = 0; - - // Write a message to the on-screen log (shown if the user has - // toggled on the text display). Print() will also dump the message - // to stdout / log file, while PrintOnScreenOnly() not. - virtual void Print(const char* fmt, ...) __printflike(2, 3) = 0; - virtual void PrintOnScreenOnly(const char* fmt, ...) __printflike(2, 3) = 0; - - virtual void ShowFile(const char* filename) = 0; + // --- progress indicator --- + enum ProgressType { EMPTY, INDETERMINATE, DETERMINATE }; + virtual void SetProgressType(ProgressType determinate) = 0; + + // Show a progress bar and define the scope of the next operation: + // portion - fraction of the progress bar the next operation will use + // seconds - expected time interval (progress bar moves at this minimum rate) + virtual void ShowProgress(float portion, float seconds) = 0; + + // Set progress bar position (0.0 - 1.0 within the scope defined + // by the last call to ShowProgress). + virtual void SetProgress(float fraction) = 0; + + // --- text log --- + + virtual void ShowText(bool visible) = 0; + + virtual bool IsTextVisible() = 0; + + virtual bool WasTextEverVisible() = 0; + + // Write a message to the on-screen log (shown if the user has + // toggled on the text display). Print() will also dump the message + // to stdout / log file, while PrintOnScreenOnly() not. + virtual void Print(const char* fmt, ...) __printflike(2, 3) = 0; + virtual void PrintOnScreenOnly(const char* fmt, ...) __printflike(2, 3) = 0; + + virtual void ShowFile(const char* filename) = 0; - // --- key handling --- + // --- key handling --- - // Wait for a key and return it. May return -1 after timeout. - virtual int WaitKey(); + // Wait for a key and return it. May return -1 after timeout. + virtual int WaitKey(); - virtual bool IsKeyPressed(int key); - virtual bool IsLongPress(); + virtual bool IsKeyPressed(int key); + virtual bool IsLongPress(); - // Returns true if you have the volume up/down and power trio typical - // of phones and tablets, false otherwise. - virtual bool HasThreeButtons(); - - // Erase any queued-up keys. - virtual void FlushKeys(); - - // Called on each key press, even while operations are in progress. - // Return value indicates whether an immediate operation should be - // triggered (toggling the display, rebooting the device), or if - // the key should be enqueued for use by the main thread. - enum KeyAction { ENQUEUE, TOGGLE, REBOOT, IGNORE }; - virtual KeyAction CheckKey(int key, bool is_long_press); - - // Called when a key is held down long enough to have been a - // long-press (but before the key is released). This means that - // if the key is eventually registered (released without any other - // keys being pressed in the meantime), CheckKey will be called with - // 'is_long_press' true. - virtual void KeyLongPress(int key); - - // Normally in recovery there's a key sequence that triggers - // immediate reboot of the device, regardless of what recovery is - // doing (with the default CheckKey implementation, it's pressing - // the power button 7 times in row). Call this to enable or - // disable that feature. It is enabled by default. - virtual void SetEnableReboot(bool enabled); - - // --- menu display --- - - // Display some header text followed by a menu of items, which appears - // at the top of the screen (in place of any scrolling ui_print() - // output, if necessary). - virtual void StartMenu(const char* const * headers, const char* const * items, - int initial_selection) = 0; - - // Set the menu highlight to the given index, wrapping if necessary. - // Returns the actual item selected. - virtual int SelectMenu(int sel) = 0; - - // End menu mode, resetting the text overlay so that ui_print() - // statements will be displayed. - virtual void EndMenu() = 0; - - protected: - void EnqueueKey(int key_code); - - // The locale that's used to show the rendered texts. - std::string locale_; - bool rtl_locale_; - - // The normal and dimmed brightness percentages (default: 50 and 25, which means 50% and 25% - // of the max_brightness). Because the absolute values may vary across devices. These two - // values can be configured via subclassing. Setting brightness_normal_ to 0 to disable - // screensaver. - unsigned int brightness_normal_; - unsigned int brightness_dimmed_; - - private: - // Key event input queue - pthread_mutex_t key_queue_mutex; - pthread_cond_t key_queue_cond; - int key_queue[256], key_queue_len; - char key_pressed[KEY_MAX + 1]; // under key_queue_mutex - int key_last_down; // under key_queue_mutex - bool key_long_press; // under key_queue_mutex - int key_down_count; // under key_queue_mutex - bool enable_reboot; // under key_queue_mutex - int rel_sum; - - int consecutive_power_keys; - int last_key; - - bool has_power_key; - bool has_up_key; - bool has_down_key; - - struct key_timer_t { - RecoveryUI* ui; - int key_code; - int count; - }; - - pthread_t input_thread_; - - void OnKeyDetected(int key_code); - int OnInputEvent(int fd, uint32_t epevents); - void ProcessKey(int key_code, int updown); - - bool IsUsbConnected(); - - static void* time_key_helper(void* cookie); - void time_key(int key_code, int count); - - void SetLocale(const std::string&); - - enum class ScreensaverState { DISABLED, NORMAL, DIMMED, OFF }; - ScreensaverState screensaver_state_; - // The following two contain the absolute values computed from brightness_normal_ and - // brightness_dimmed_ respectively. - unsigned int brightness_normal_value_; - unsigned int brightness_dimmed_value_; - bool InitScreensaver(); + // Returns true if you have the volume up/down and power trio typical + // of phones and tablets, false otherwise. + virtual bool HasThreeButtons(); + + // Erase any queued-up keys. + virtual void FlushKeys(); + + // Called on each key press, even while operations are in progress. + // Return value indicates whether an immediate operation should be + // triggered (toggling the display, rebooting the device), or if + // the key should be enqueued for use by the main thread. + enum KeyAction { ENQUEUE, TOGGLE, REBOOT, IGNORE }; + virtual KeyAction CheckKey(int key, bool is_long_press); + + // Called when a key is held down long enough to have been a + // long-press (but before the key is released). This means that + // if the key is eventually registered (released without any other + // keys being pressed in the meantime), CheckKey will be called with + // 'is_long_press' true. + virtual void KeyLongPress(int key); + + // Normally in recovery there's a key sequence that triggers + // immediate reboot of the device, regardless of what recovery is + // doing (with the default CheckKey implementation, it's pressing + // the power button 7 times in row). Call this to enable or + // disable that feature. It is enabled by default. + virtual void SetEnableReboot(bool enabled); + + // --- menu display --- + + // Display some header text followed by a menu of items, which appears + // at the top of the screen (in place of any scrolling ui_print() + // output, if necessary). + virtual void StartMenu(const char* const* headers, const char* const* items, + int initial_selection) = 0; + + // Set the menu highlight to the given index, wrapping if necessary. + // Returns the actual item selected. + virtual int SelectMenu(int sel) = 0; + + // End menu mode, resetting the text overlay so that ui_print() + // statements will be displayed. + virtual void EndMenu() = 0; + + protected: + void EnqueueKey(int key_code); + + // The locale that's used to show the rendered texts. + std::string locale_; + bool rtl_locale_; + + // The normal and dimmed brightness percentages (default: 50 and 25, which means 50% and 25% + // of the max_brightness). Because the absolute values may vary across devices. These two + // values can be configured via subclassing. Setting brightness_normal_ to 0 to disable + // screensaver. + unsigned int brightness_normal_; + unsigned int brightness_dimmed_; + + private: + // Key event input queue + pthread_mutex_t key_queue_mutex; + pthread_cond_t key_queue_cond; + int key_queue[256], key_queue_len; + char key_pressed[KEY_MAX + 1]; // under key_queue_mutex + int key_last_down; // under key_queue_mutex + bool key_long_press; // under key_queue_mutex + int key_down_count; // under key_queue_mutex + bool enable_reboot; // under key_queue_mutex + int rel_sum; + + int consecutive_power_keys; + int last_key; + + bool has_power_key; + bool has_up_key; + bool has_down_key; + + struct key_timer_t { + RecoveryUI* ui; + int key_code; + int count; + }; + + pthread_t input_thread_; + + void OnKeyDetected(int key_code); + int OnInputEvent(int fd, uint32_t epevents); + void ProcessKey(int key_code, int updown); + + bool IsUsbConnected(); + + static void* time_key_helper(void* cookie); + void time_key(int key_code, int count); + + void SetLocale(const std::string&); + + enum class ScreensaverState { DISABLED, NORMAL, DIMMED, OFF }; + ScreensaverState screensaver_state_; + // The following two contain the absolute values computed from brightness_normal_ and + // brightness_dimmed_ respectively. + unsigned int brightness_normal_value_; + unsigned int brightness_dimmed_value_; + bool InitScreensaver(); }; #endif // RECOVERY_UI_H -- cgit v1.2.3 From 99b2d774751041a5cfb5a48ac93292bb92acef98 Mon Sep 17 00:00:00 2001 From: Tao Bao Date: Fri, 23 Jun 2017 22:47:03 -0700 Subject: Add override specifier and member constness to RecoveryUI classes. Test: mmma bootable/recovery Change-Id: I66e328614423488a4027d7878f4569fbf3a3721e --- ui.h | 68 ++++++++++++++++++++++++++++++-------------------------------------- 1 file changed, 30 insertions(+), 38 deletions(-) (limited to 'ui.h') diff --git a/ui.h b/ui.h index ef63e1d70..7eb04aec8 100644 --- a/ui.h +++ b/ui.h @@ -30,14 +30,14 @@ class RecoveryUI { virtual ~RecoveryUI() {} - // Initialize the object; called before anything else. UI texts will be - // initialized according to the given locale. Returns true on success. + // Initializes the object; called before anything else. UI texts will be initialized according to + // the given locale. Returns true on success. virtual bool Init(const std::string& locale); - // Show a stage indicator. Call immediately after Init(). + // Shows a stage indicator. Called immediately after Init(). virtual void SetStage(int current, int max) = 0; - // Set the overall recovery state ("background image"). + // Sets the overall recovery state ("background image"). enum Icon { NONE, INSTALLING_UPDATE, ERASING, NO_COMMAND, ERROR }; virtual void SetBackground(Icon icon) = 0; virtual void SetSystemUpdateText(bool security_update) = 0; @@ -46,13 +46,13 @@ class RecoveryUI { enum ProgressType { EMPTY, INDETERMINATE, DETERMINATE }; virtual void SetProgressType(ProgressType determinate) = 0; - // Show a progress bar and define the scope of the next operation: + // Shows a progress bar and define the scope of the next operation: // portion - fraction of the progress bar the next operation will use // seconds - expected time interval (progress bar moves at this minimum rate) virtual void ShowProgress(float portion, float seconds) = 0; - // Set progress bar position (0.0 - 1.0 within the scope defined - // by the last call to ShowProgress). + // Sets progress bar position (0.0 - 1.0 within the scope defined by the last call to + // ShowProgress). virtual void SetProgress(float fraction) = 0; // --- text log --- @@ -63,9 +63,8 @@ class RecoveryUI { virtual bool WasTextEverVisible() = 0; - // Write a message to the on-screen log (shown if the user has - // toggled on the text display). Print() will also dump the message - // to stdout / log file, while PrintOnScreenOnly() not. + // Writes a message to the on-screen log (shown if the user has toggled on the text display). + // Print() will also dump the message to stdout / log file, while PrintOnScreenOnly() not. virtual void Print(const char* fmt, ...) __printflike(2, 3) = 0; virtual void PrintOnScreenOnly(const char* fmt, ...) __printflike(2, 3) = 0; @@ -73,54 +72,48 @@ class RecoveryUI { // --- key handling --- - // Wait for a key and return it. May return -1 after timeout. + // Waits for a key and return it. May return -1 after timeout. virtual int WaitKey(); virtual bool IsKeyPressed(int key); virtual bool IsLongPress(); - // Returns true if you have the volume up/down and power trio typical - // of phones and tablets, false otherwise. + // Returns true if you have the volume up/down and power trio typical of phones and tablets, false + // otherwise. virtual bool HasThreeButtons(); - // Erase any queued-up keys. + // Erases any queued-up keys. virtual void FlushKeys(); - // Called on each key press, even while operations are in progress. - // Return value indicates whether an immediate operation should be - // triggered (toggling the display, rebooting the device), or if + // Called on each key press, even while operations are in progress. Return value indicates whether + // an immediate operation should be triggered (toggling the display, rebooting the device), or if // the key should be enqueued for use by the main thread. enum KeyAction { ENQUEUE, TOGGLE, REBOOT, IGNORE }; virtual KeyAction CheckKey(int key, bool is_long_press); - // Called when a key is held down long enough to have been a - // long-press (but before the key is released). This means that - // if the key is eventually registered (released without any other - // keys being pressed in the meantime), CheckKey will be called with - // 'is_long_press' true. + // Called when a key is held down long enough to have been a long-press (but before the key is + // released). This means that if the key is eventually registered (released without any other keys + // being pressed in the meantime), CheckKey will be called with 'is_long_press' true. virtual void KeyLongPress(int key); - // Normally in recovery there's a key sequence that triggers - // immediate reboot of the device, regardless of what recovery is - // doing (with the default CheckKey implementation, it's pressing - // the power button 7 times in row). Call this to enable or - // disable that feature. It is enabled by default. + // Normally in recovery there's a key sequence that triggers immediate reboot of the device, + // regardless of what recovery is doing (with the default CheckKey implementation, it's pressing + // the power button 7 times in row). Call this to enable or disable that feature. It is enabled by + // default. virtual void SetEnableReboot(bool enabled); // --- menu display --- - // Display some header text followed by a menu of items, which appears - // at the top of the screen (in place of any scrolling ui_print() - // output, if necessary). + // Display some header text followed by a menu of items, which appears at the top of the screen + // (in place of any scrolling ui_print() output, if necessary). virtual void StartMenu(const char* const* headers, const char* const* items, int initial_selection) = 0; - // Set the menu highlight to the given index, wrapping if necessary. - // Returns the actual item selected. + // Sets the menu highlight to the given index, wrapping if necessary. Returns the actual item + // selected. virtual int SelectMenu(int sel) = 0; - // End menu mode, resetting the text overlay so that ui_print() - // statements will be displayed. + // Ends menu mode, resetting the text overlay so that ui_print() statements will be displayed. virtual void EndMenu() = 0; protected: @@ -130,10 +123,9 @@ class RecoveryUI { std::string locale_; bool rtl_locale_; - // The normal and dimmed brightness percentages (default: 50 and 25, which means 50% and 25% - // of the max_brightness). Because the absolute values may vary across devices. These two - // values can be configured via subclassing. Setting brightness_normal_ to 0 to disable - // screensaver. + // The normal and dimmed brightness percentages (default: 50 and 25, which means 50% and 25% of + // the max_brightness). Because the absolute values may vary across devices. These two values can + // be configured via subclassing. Setting brightness_normal_ to 0 to disable screensaver. unsigned int brightness_normal_; unsigned int brightness_dimmed_; -- cgit v1.2.3 From af9f8b4d97af56b5abcb622aaecebce59179bc0b Mon Sep 17 00:00:00 2001 From: Tao Bao Date: Fri, 28 Jul 2017 00:05:40 -0700 Subject: ui: Move the support for touch inputs into RecoveryUI. - Added detection for EV_ABS events in minui/events.cpp, if it's allowed; - Added listening and processing touch inputs in ui.cpp; - Fixed an issue in recognizing swipe with multi-touch protocol A; - Changed the logic in RecoveryUI::ProcessKey() to be swipe-aware. It now allows turning on text mode with + . The last change also fixed an issue on devices with protocol A: prior to this CL, user may accidentally toggle the text mode during an OTA. Because it was considered as a single-button device, a long tap that sent BTN_TOUCH event would turn on text mode. Test: Allow detecting touch inputs. Swiping (up, down, enter) works on angler, angelfish, dorado respectively. Bug: 36169090 Bug: 64307776 Change-Id: I4bc882b99114ce4ab414f8bdb8f4f7a525b8a8fd (cherry picked from commit 5f8dd9951d986b65d98d6a9ea38003427e9e46df) --- ui.h | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) (limited to 'ui.h') diff --git a/ui.h b/ui.h index 7eb04aec8..5cda7af0f 100644 --- a/ui.h +++ b/ui.h @@ -82,6 +82,12 @@ class RecoveryUI { // otherwise. virtual bool HasThreeButtons(); + // Returns true if it has a power key. + virtual bool HasPowerKey() const; + + // Returns true if it supports touch inputs. + virtual bool HasTouchScreen() const; + // Erases any queued-up keys. virtual void FlushKeys(); @@ -129,7 +135,14 @@ class RecoveryUI { unsigned int brightness_normal_; unsigned int brightness_dimmed_; + // Whether we should listen for touch inputs (default: false). + bool touch_screen_allowed_; + private: + // The sensitivity when detecting a swipe. + const int kTouchLowThreshold; + const int kTouchHighThreshold; + // Key event input queue pthread_mutex_t key_queue_mutex; pthread_cond_t key_queue_cond; @@ -147,6 +160,16 @@ class RecoveryUI { bool has_power_key; bool has_up_key; bool has_down_key; + bool has_touch_screen; + + // Touch event related variables. See the comments in RecoveryUI::OnInputEvent(). + int touch_slot_; + int touch_X_; + int touch_Y_; + int touch_start_X_; + int touch_start_Y_; + bool touch_finger_down_; + bool touch_swiping_; struct key_timer_t { RecoveryUI* ui; @@ -157,6 +180,7 @@ class RecoveryUI { pthread_t input_thread_; void OnKeyDetected(int key_code); + void OnTouchDetected(int dx, int dy); int OnInputEvent(int fd, uint32_t epevents); void ProcessKey(int key_code, int updown); -- cgit v1.2.3 From 937e884ca113a5e775a3cb37a3f9dbe2174d3376 Mon Sep 17 00:00:00 2001 From: Tao Bao Date: Mon, 31 Jul 2017 23:15:09 -0700 Subject: ui: Check for bootreason=recovery_ui. Some wear bootloaders are passing bootreason=recovery_ui when booting into recovery from fastboot, or via 'adb reboot recovery'. Allow turning on text mode with a swipe for such a bootreason. Since we will turn on text mode automatically for debuggable builds, this bootreason mainly handles the case for user builds. Note this change only applies to devices that allow touch screen inputs. Bug: 36169090 Bug: 64307776 Test: Build and boot into user build recovery image. Toggle on text mode with a swipe. Change-Id: I55f19aed7b210352f8370de19935b4772cc12095 (cherry picked from commit 046aae29d9b0d2cdf24ad0567146991c3864c140) --- ui.h | 1 + 1 file changed, 1 insertion(+) (limited to 'ui.h') diff --git a/ui.h b/ui.h index 5cda7af0f..3d9afece0 100644 --- a/ui.h +++ b/ui.h @@ -170,6 +170,7 @@ class RecoveryUI { int touch_start_Y_; bool touch_finger_down_; bool touch_swiping_; + bool is_bootreason_recovery_ui_; struct key_timer_t { RecoveryUI* ui; -- cgit v1.2.3