Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 0bc88de7 authored by Tao Bao's avatar Tao Bao
Browse files

ui: Read custom recovery UI values via system property. 

The matching change to build system now writes these values as build
properties for recovery image. This allows us dropping the dependency on
Android.mk (as well as having more flexibility to do UI customization).

Also rename a few constant names, as the naming doesn't fully follow the
style guide (which reads "whose value is fixed for the duration of the
program").

Bug: 110380063
Test: Build and flash recovery image on taimen, which uses custom margin
      height. Check the UI and choose `Run graphics test`.
Change-Id: I2c50326123639cb36022f51b62cdeed925d77ba7
parent 561ee936

Android.mk

+0 −48
Original line number Diff line number Diff line
@@ -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)



librecovery_static_libraries := \

screen_ui.cpp

+22 −15
Original line number Diff line number Diff line
@@ -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<float>(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<float>(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::vector<std::string 
  gr_color(0, 0, 0, 255);

  gr_clear();



  int text_y = kMarginHeight;

  int text_x = kMarginWidth;

  int text_y = margin_height_;

  int text_x = margin_width_;

  int line_spacing = gr_sys_font()->char_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<std::string>& 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;

}

screen_ui.h

+4 −4
Original line number Diff line number Diff line
@@ -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();

ui.cpp

+19 −14
Original line number Diff line number Diff line
@@ -34,6 +34,7 @@ 
#include <android-base/file.h>

#include <android-base/logging.h>

#include <android-base/parseint.h>

#include <android-base/properties.h>

#include <android-base/strings.h>



#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;

  }

ui.h

+2 −2
Original line number Diff line number Diff line
@@ -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);