tequilaOS/platform_bootable_recovery
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Merge "ui: Read custom recovery UI values via system property."

Browse source 
am: 2117b4bd07

Change-Id: Ia9e2d805f2e90b9be8426010581a32d0b27fe8e6
This commit is contained in:
Tao Bao 2018-08-03 16:02:17 -07:00 committed by android-build-merger
commit 17bf8d0518
9 changed files with 83 additions and 107 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

48
Android.mk
View file

@ -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

37
screen_ui.cpp
View file

@ -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;
}

8
screen_ui.h
View file

@ -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();

33
ui.cpp
View file

@ -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;
}

4
ui.h
View file

@ -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);

39
vr_ui.cpp
View file

@ -16,9 +16,15 @@
#include "vr_ui.h"
#include <minui/minui.h>
#include <android-base/properties.h>
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);
}

2
vr_ui.h
View file

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

15
wear_ui.cpp
View file

@ -25,17 +25,22 @@
#include <android-base/strings.h>
#include <minui/minui.h>
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<std::string>& headers,
const std::vector<std::string>& items, size_t initial_selection) {
std::lock_guard<std::mutex> lg(updateMutex);
if (text_rows_ > 0 && text_cols_ > 0) {
menu_ = std::make_unique<Menu>(scrollable_menu_, text_rows_ - kMenuUnusableRows - 1,
menu_ = std::make_unique<Menu>(scrollable_menu_, text_rows_ - menu_unusable_rows_ - 1,
text_cols_ - 1, headers, items, initial_selection);
update_screen_locked();
}

4
wear_ui.h
View file

@ -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<std::string>& headers, const std::vector<std::string>& items,
size_t initial_selection) override;