diff --git a/Android.mk b/Android.mk index 73a31999..67ad9ec0 100644 --- a/Android.mk +++ b/Android.mk @@ -47,54 +47,6 @@ LOCAL_STATIC_LIBRARIES := \ LOCAL_CFLAGS := $(recovery_common_cflags) -ifneq ($(TARGET_RECOVERY_UI_MARGIN_HEIGHT),) -LOCAL_CFLAGS += -DRECOVERY_UI_MARGIN_HEIGHT=$(TARGET_RECOVERY_UI_MARGIN_HEIGHT) -else -LOCAL_CFLAGS += -DRECOVERY_UI_MARGIN_HEIGHT=0 -endif - -ifneq ($(TARGET_RECOVERY_UI_MARGIN_WIDTH),) -LOCAL_CFLAGS += -DRECOVERY_UI_MARGIN_WIDTH=$(TARGET_RECOVERY_UI_MARGIN_WIDTH) -else -LOCAL_CFLAGS += -DRECOVERY_UI_MARGIN_WIDTH=0 -endif - -ifneq ($(TARGET_RECOVERY_UI_TOUCH_LOW_THRESHOLD),) -LOCAL_CFLAGS += -DRECOVERY_UI_TOUCH_LOW_THRESHOLD=$(TARGET_RECOVERY_UI_TOUCH_LOW_THRESHOLD) -else -LOCAL_CFLAGS += -DRECOVERY_UI_TOUCH_LOW_THRESHOLD=50 -endif - -ifneq ($(TARGET_RECOVERY_UI_TOUCH_HIGH_THRESHOLD),) -LOCAL_CFLAGS += -DRECOVERY_UI_TOUCH_HIGH_THRESHOLD=$(TARGET_RECOVERY_UI_TOUCH_HIGH_THRESHOLD) -else -LOCAL_CFLAGS += -DRECOVERY_UI_TOUCH_HIGH_THRESHOLD=90 -endif - -ifneq ($(TARGET_RECOVERY_UI_PROGRESS_BAR_BASELINE),) -LOCAL_CFLAGS += -DRECOVERY_UI_PROGRESS_BAR_BASELINE=$(TARGET_RECOVERY_UI_PROGRESS_BAR_BASELINE) -else -LOCAL_CFLAGS += -DRECOVERY_UI_PROGRESS_BAR_BASELINE=259 -endif - -ifneq ($(TARGET_RECOVERY_UI_ANIMATION_FPS),) -LOCAL_CFLAGS += -DRECOVERY_UI_ANIMATION_FPS=$(TARGET_RECOVERY_UI_ANIMATION_FPS) -else -LOCAL_CFLAGS += -DRECOVERY_UI_ANIMATION_FPS=30 -endif - -ifneq ($(TARGET_RECOVERY_UI_MENU_UNUSABLE_ROWS),) -LOCAL_CFLAGS += -DRECOVERY_UI_MENU_UNUSABLE_ROWS=$(TARGET_RECOVERY_UI_MENU_UNUSABLE_ROWS) -else -LOCAL_CFLAGS += -DRECOVERY_UI_MENU_UNUSABLE_ROWS=9 -endif - -ifneq ($(TARGET_RECOVERY_UI_VR_STEREO_OFFSET),) -LOCAL_CFLAGS += -DRECOVERY_UI_VR_STEREO_OFFSET=$(TARGET_RECOVERY_UI_VR_STEREO_OFFSET) -else -LOCAL_CFLAGS += -DRECOVERY_UI_VR_STEREO_OFFSET=0 -endif - include $(BUILD_STATIC_LIBRARY) # Health HAL dependency diff --git a/screen_ui.cpp b/screen_ui.cpp index c14f29d4..391dedb0 100644 --- a/screen_ui.cpp +++ b/screen_ui.cpp @@ -142,11 +142,18 @@ int Menu::Select(int sel) { ScreenRecoveryUI::ScreenRecoveryUI() : ScreenRecoveryUI(false) {} +constexpr int kDefaultMarginHeight = 0; +constexpr int kDefaultMarginWidth = 0; +constexpr int kDefaultAnimationFps = 30; + ScreenRecoveryUI::ScreenRecoveryUI(bool scrollable_menu) - : kMarginWidth(RECOVERY_UI_MARGIN_WIDTH), - kMarginHeight(RECOVERY_UI_MARGIN_HEIGHT), - kAnimationFps(RECOVERY_UI_ANIMATION_FPS), - kDensity(static_cast(android::base::GetIntProperty("ro.sf.lcd_density", 160)) / 160.f), + : margin_width_( + android::base::GetIntProperty("ro.recovery.ui.margin_width", kDefaultMarginWidth)), + margin_height_( + android::base::GetIntProperty("ro.recovery.ui.margin_height", kDefaultMarginHeight)), + animation_fps_( + android::base::GetIntProperty("ro.recovery.ui.animation_fps", kDefaultAnimationFps)), + density_(static_cast(android::base::GetIntProperty("ro.sf.lcd_density", 160)) / 160.f), currentIcon(NONE), progressBarType(EMPTY), progressScopeStart(0), @@ -203,7 +210,7 @@ GRSurface* ScreenRecoveryUI::GetCurrentText() const { } int ScreenRecoveryUI::PixelsFromDp(int dp) const { - return dp * kDensity; + return dp * density_; } // Here's the intended layout: @@ -258,7 +265,7 @@ void ScreenRecoveryUI::draw_background_locked() { int stage_height = gr_get_height(stageMarkerEmpty); int stage_width = gr_get_width(stageMarkerEmpty); int x = (ScreenWidth() - max_stage * gr_get_width(stageMarkerEmpty)) / 2; - int y = ScreenHeight() - stage_height - kMarginHeight; + int y = ScreenHeight() - stage_height - margin_height_; for (int i = 0; i < max_stage; ++i) { GRSurface* stage_surface = (i < stage) ? stageMarkerFill : stageMarkerEmpty; DrawSurface(stage_surface, 0, 0, stage_width, stage_height, x, y); @@ -373,8 +380,8 @@ void ScreenRecoveryUI::SelectAndShowBackgroundText(const std::vectorchar_height; // Put some extra space between images. // Write the header and descriptive texts. SetColor(INFO); @@ -535,10 +542,10 @@ void ScreenRecoveryUI::draw_screen_locked() { // Draws the menu and text buffer on the screen. Should only be called with updateMutex locked. void ScreenRecoveryUI::draw_menu_and_text_buffer_locked( const std::vector& help_message) { - int y = kMarginHeight; + int y = margin_height_; if (menu_) { static constexpr int kMenuIndent = 4; - int x = kMarginWidth + kMenuIndent; + int x = margin_width_ + kMenuIndent; SetColor(INFO); @@ -594,9 +601,9 @@ void ScreenRecoveryUI::draw_menu_and_text_buffer_locked( SetColor(LOG); int row = text_row_; size_t count = 0; - for (int ty = ScreenHeight() - kMarginHeight - char_height_; ty >= y && count < text_rows_; + for (int ty = ScreenHeight() - margin_height_ - char_height_; ty >= y && count < text_rows_; ty -= char_height_, ++count) { - DrawTextLine(kMarginWidth, ty, text_[row], false); + DrawTextLine(margin_width_, ty, text_[row], false); --row; if (row < 0) row = text_rows_ - 1; } @@ -622,7 +629,7 @@ void ScreenRecoveryUI::update_progress_locked() { } void ScreenRecoveryUI::ProgressThreadLoop() { - double interval = 1.0 / kAnimationFps; + double interval = 1.0 / animation_fps_; while (!progress_thread_stopped_) { double start = now(); bool redraw = false; @@ -708,8 +715,8 @@ bool ScreenRecoveryUI::InitTextParams() { return false; } gr_font_size(gr_sys_font(), &char_width_, &char_height_); - text_rows_ = (ScreenHeight() - kMarginHeight * 2) / char_height_; - text_cols_ = (ScreenWidth() - kMarginWidth * 2) / char_width_; + text_rows_ = (ScreenHeight() - margin_height_ * 2) / char_height_; + text_cols_ = (ScreenWidth() - margin_width_ * 2) / char_width_; return true; } diff --git a/screen_ui.h b/screen_ui.h index b76d4706..f08f4f4f 100644 --- a/screen_ui.h +++ b/screen_ui.h @@ -158,14 +158,14 @@ class ScreenRecoveryUI : public RecoveryUI { protected: // The margin that we don't want to use for showing texts (e.g. round screen, or screen with // rounded corners). - const int kMarginWidth; - const int kMarginHeight; + const int margin_width_; + const int margin_height_; // Number of frames per sec (default: 30) for both parts of the animation. - const int kAnimationFps; + const int animation_fps_; // The scale factor from dp to pixels. 1.0 for mdpi, 4.0 for xxxhdpi. - const float kDensity; + const float density_; virtual bool InitTextParams(); diff --git a/ui.cpp b/ui.cpp index a2c160f7..f1e30f50 100644 --- a/ui.cpp +++ b/ui.cpp @@ -34,6 +34,7 @@ #include #include #include +#include #include #include "minui/minui.h" @@ -42,22 +43,26 @@ using namespace std::chrono_literals; -static constexpr int UI_WAIT_KEY_TIMEOUT_SEC = 120; -static constexpr const char* BRIGHTNESS_FILE = "/sys/class/leds/lcd-backlight/brightness"; -static constexpr const char* MAX_BRIGHTNESS_FILE = "/sys/class/leds/lcd-backlight/max_brightness"; -static constexpr const char* BRIGHTNESS_FILE_SDM = - "/sys/class/backlight/panel0-backlight/brightness"; -static constexpr const char* MAX_BRIGHTNESS_FILE_SDM = +constexpr int UI_WAIT_KEY_TIMEOUT_SEC = 120; +constexpr const char* BRIGHTNESS_FILE = "/sys/class/leds/lcd-backlight/brightness"; +constexpr const char* MAX_BRIGHTNESS_FILE = "/sys/class/leds/lcd-backlight/max_brightness"; +constexpr const char* BRIGHTNESS_FILE_SDM = "/sys/class/backlight/panel0-backlight/brightness"; +constexpr const char* MAX_BRIGHTNESS_FILE_SDM = "/sys/class/backlight/panel0-backlight/max_brightness"; +constexpr int kDefaultTouchLowThreshold = 50; +constexpr int kDefaultTouchHighThreshold = 90; + RecoveryUI::RecoveryUI() : brightness_normal_(50), brightness_dimmed_(25), brightness_file_(BRIGHTNESS_FILE), max_brightness_file_(MAX_BRIGHTNESS_FILE), touch_screen_allowed_(false), - kTouchLowThreshold(RECOVERY_UI_TOUCH_LOW_THRESHOLD), - kTouchHighThreshold(RECOVERY_UI_TOUCH_HIGH_THRESHOLD), + touch_low_threshold_(android::base::GetIntProperty("ro.recovery.ui.touch_low_threshold", + kDefaultTouchLowThreshold)), + touch_high_threshold_(android::base::GetIntProperty("ro.recovery.ui.touch_high_threshold", + kDefaultTouchHighThreshold)), key_interrupted_(false), key_queue_len(0), key_last_down(-1), @@ -178,15 +183,15 @@ void RecoveryUI::OnTouchDetected(int dx, int dy) { enum SwipeDirection { UP, DOWN, RIGHT, LEFT } direction; // We only consider a valid swipe if: - // - the delta along one axis is below kTouchLowThreshold; - // - and the delta along the other axis is beyond kTouchHighThreshold. - if (abs(dy) < kTouchLowThreshold && abs(dx) > kTouchHighThreshold) { + // - the delta along one axis is below touch_low_threshold_; + // - and the delta along the other axis is beyond touch_high_threshold_. + if (abs(dy) < touch_low_threshold_ && abs(dx) > touch_high_threshold_) { direction = dx < 0 ? SwipeDirection::LEFT : SwipeDirection::RIGHT; - } else if (abs(dx) < kTouchLowThreshold && abs(dy) > kTouchHighThreshold) { + } else if (abs(dx) < touch_low_threshold_ && abs(dy) > touch_high_threshold_) { direction = dy < 0 ? SwipeDirection::UP : SwipeDirection::DOWN; } else { - LOG(DEBUG) << "Ignored " << dx << " " << dy << " (low: " << kTouchLowThreshold - << ", high: " << kTouchHighThreshold << ")"; + LOG(DEBUG) << "Ignored " << dx << " " << dy << " (low: " << touch_low_threshold_ + << ", high: " << touch_high_threshold_ << ")"; return; } diff --git a/ui.h b/ui.h index a1e18cc1..e0fb13e4 100644 --- a/ui.h +++ b/ui.h @@ -195,8 +195,8 @@ class RecoveryUI { }; // The sensitivity when detecting a swipe. - const int kTouchLowThreshold; - const int kTouchHighThreshold; + const int touch_low_threshold_; + const int touch_high_threshold_; void OnKeyDetected(int key_code); void OnTouchDetected(int dx, int dy); diff --git a/vr_ui.cpp b/vr_ui.cpp index b1ef646c..a131a27a 100644 --- a/vr_ui.cpp +++ b/vr_ui.cpp @@ -16,9 +16,15 @@ #include "vr_ui.h" -#include +#include -VrRecoveryUI::VrRecoveryUI() : kStereoOffset(RECOVERY_UI_VR_STEREO_OFFSET) {} +#include "minui/minui.h" + +constexpr int kDefaultStereoOffset = 0; + +VrRecoveryUI::VrRecoveryUI() + : stereo_offset_( + android::base::GetIntProperty("ro.recovery.ui.stereo_offset", kDefaultStereoOffset)) {} int VrRecoveryUI::ScreenWidth() const { return gr_fb_width() / 2; @@ -30,36 +36,37 @@ int VrRecoveryUI::ScreenHeight() const { void VrRecoveryUI::DrawSurface(GRSurface* surface, int sx, int sy, int w, int h, int dx, int dy) const { - gr_blit(surface, sx, sy, w, h, dx + kStereoOffset, dy); - gr_blit(surface, sx, sy, w, h, dx - kStereoOffset + ScreenWidth(), dy); + gr_blit(surface, sx, sy, w, h, dx + stereo_offset_, dy); + gr_blit(surface, sx, sy, w, h, dx - stereo_offset_ + ScreenWidth(), dy); } void VrRecoveryUI::DrawTextIcon(int x, int y, GRSurface* surface) const { - gr_texticon(x + kStereoOffset, y, surface); - gr_texticon(x - kStereoOffset + ScreenWidth(), y, surface); + gr_texticon(x + stereo_offset_, y, surface); + gr_texticon(x - stereo_offset_ + ScreenWidth(), y, surface); } int VrRecoveryUI::DrawTextLine(int x, int y, const std::string& line, bool bold) const { - gr_text(gr_sys_font(), x + kStereoOffset, y, line.c_str(), bold); - gr_text(gr_sys_font(), x - kStereoOffset + ScreenWidth(), y, line.c_str(), bold); + gr_text(gr_sys_font(), x + stereo_offset_, y, line.c_str(), bold); + gr_text(gr_sys_font(), x - stereo_offset_ + ScreenWidth(), y, line.c_str(), bold); return char_height_ + 4; } int VrRecoveryUI::DrawHorizontalRule(int y) const { y += 4; - gr_fill(kMarginWidth + kStereoOffset, y, ScreenWidth() - kMarginWidth + kStereoOffset, y + 2); - gr_fill(ScreenWidth() + kMarginWidth - kStereoOffset, y, - gr_fb_width() - kMarginWidth - kStereoOffset, y + 2); + gr_fill(margin_width_ + stereo_offset_, y, ScreenWidth() - margin_width_ + stereo_offset_, y + 2); + gr_fill(ScreenWidth() + margin_width_ - stereo_offset_, y, + gr_fb_width() - margin_width_ - stereo_offset_, y + 2); return y + 4; } void VrRecoveryUI::DrawHighlightBar(int /* x */, int y, int /* width */, int height) const { - gr_fill(kMarginWidth + kStereoOffset, y, ScreenWidth() - kMarginWidth + kStereoOffset, y + height); - gr_fill(ScreenWidth() + kMarginWidth - kStereoOffset, y, - gr_fb_width() - kMarginWidth - kStereoOffset, y + height); + gr_fill(margin_width_ + stereo_offset_, y, ScreenWidth() - margin_width_ + stereo_offset_, + y + height); + gr_fill(ScreenWidth() + margin_width_ - stereo_offset_, y, + gr_fb_width() - margin_width_ - stereo_offset_, y + height); } void VrRecoveryUI::DrawFill(int x, int y, int w, int h) const { - gr_fill(x + kStereoOffset, y, w, h); - gr_fill(x - kStereoOffset + ScreenWidth(), y, w, h); + gr_fill(x + stereo_offset_, y, w, h); + gr_fill(x - stereo_offset_ + ScreenWidth(), y, w, h); } diff --git a/vr_ui.h b/vr_ui.h index 08384ce9..63c0f246 100644 --- a/vr_ui.h +++ b/vr_ui.h @@ -28,7 +28,7 @@ class VrRecoveryUI : public ScreenRecoveryUI { protected: // Pixel offsets to move drawing functions to visible range. // Can vary per device depending on screen size and lens distortion. - const int kStereoOffset; + const int stereo_offset_; int ScreenWidth() const override; int ScreenHeight() const override; diff --git a/wear_ui.cpp b/wear_ui.cpp index f5082368..3b057b76 100644 --- a/wear_ui.cpp +++ b/wear_ui.cpp @@ -25,17 +25,22 @@ #include #include +constexpr int kDefaultProgressBarBaseline = 259; +constexpr int kDefaultMenuUnusableRows = 9; + WearRecoveryUI::WearRecoveryUI() : ScreenRecoveryUI(true), - kProgressBarBaseline(RECOVERY_UI_PROGRESS_BAR_BASELINE), - kMenuUnusableRows(RECOVERY_UI_MENU_UNUSABLE_ROWS) { - // TODO: kMenuUnusableRows should be computed based on the lines in draw_screen_locked(). + progress_bar_baseline_(android::base::GetIntProperty("ro.recovery.ui.progress_bar_baseline", + kDefaultProgressBarBaseline)), + menu_unusable_rows_(android::base::GetIntProperty("ro.recovery.ui.menu_unusable_rows", + kDefaultMenuUnusableRows)) { + // TODO: menu_unusable_rows_ should be computed based on the lines in draw_screen_locked(). touch_screen_allowed_ = true; } int WearRecoveryUI::GetProgressBaseline() const { - return kProgressBarBaseline; + return progress_bar_baseline_; } // Draw background frame on the screen. Does not flip pages. @@ -94,7 +99,7 @@ void WearRecoveryUI::StartMenu(const std::vector& headers, const std::vector& items, size_t initial_selection) { std::lock_guard lg(updateMutex); if (text_rows_ > 0 && text_cols_ > 0) { - menu_ = std::make_unique(scrollable_menu_, text_rows_ - kMenuUnusableRows - 1, + menu_ = std::make_unique(scrollable_menu_, text_rows_ - menu_unusable_rows_ - 1, text_cols_ - 1, headers, items, initial_selection); update_screen_locked(); } diff --git a/wear_ui.h b/wear_ui.h index c9a9f0e1..b80cfd75 100644 --- a/wear_ui.h +++ b/wear_ui.h @@ -30,11 +30,11 @@ class WearRecoveryUI : public ScreenRecoveryUI { protected: // progress bar vertical position, it's centered horizontally - const int kProgressBarBaseline; + const int progress_bar_baseline_; // Unusable rows when displaying the recovery menu, including the lines for headers (Android // Recovery, build id and etc) and the bottom lines that may otherwise go out of the screen. - const int kMenuUnusableRows; + const int menu_unusable_rows_; void StartMenu(const std::vector& headers, const std::vector& items, size_t initial_selection) override;