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

Merge "Factor out a menu class for screen ui"

Browse source 
am: 549695ae65

Change-Id: I926b85b2fecec7e7d21e30b5f21aa7996b641c7f
This commit is contained in:
Tianjie Xu 2018-03-24 17:06:47 +00:00 committed by android-build-merger
commit baf619c21c
7 changed files with 472 additions and 185 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

79
Android.mk
View file

@ -53,36 +53,21 @@ LOCAL_STATIC_LIBRARIES := \
include $(BUILD_STATIC_LIBRARY)
# recovery (static executable)
# librecovery_ui (static library)
# ===============================
include $(CLEAR_VARS)
LOCAL_SRC_FILES := \
adb_install.cpp \
device.cpp \
fuse_sdcard_provider.cpp \
recovery.cpp \
roots.cpp \
rotate_logs.cpp \
screen_ui.cpp \
ui.cpp \
vr_ui.cpp \
wear_ui.cpp \
wear_ui.cpp
LOCAL_MODULE := recovery
LOCAL_CFLAGS := -Wall -Werror
LOCAL_FORCE_STATIC_EXECUTABLE := true
LOCAL_REQUIRED_MODULES := e2fsdroid_static mke2fs_static mke2fs.conf
ifeq ($(TARGET_USERIMAGES_USE_F2FS),true)
ifeq ($(HOST_OS),linux)
LOCAL_REQUIRED_MODULES += sload.f2fs mkfs.f2fs
endif
endif
LOCAL_CFLAGS += -DRECOVERY_API_VERSION=$(RECOVERY_API_VERSION)
LOCAL_CFLAGS += -Wall -Werror
LOCAL_MODULE := librecovery_ui
LOCAL_STATIC_LIBRARIES := \
libminui \
libbase
ifneq ($(TARGET_RECOVERY_UI_MARGIN_HEIGHT),)
LOCAL_CFLAGS += -DRECOVERY_UI_MARGIN_HEIGHT=$(TARGET_RECOVERY_UI_MARGIN_HEIGHT)
@ -132,11 +117,50 @@ else
LOCAL_CFLAGS += -DRECOVERY_UI_VR_STEREO_OFFSET=0
endif
include $(BUILD_STATIC_LIBRARY)
# recovery (static executable)
# ===============================
include $(CLEAR_VARS)
LOCAL_SRC_FILES := \
adb_install.cpp \
device.cpp \
fuse_sdcard_provider.cpp \
recovery.cpp \
roots.cpp \
rotate_logs.cpp \
LOCAL_MODULE := recovery
LOCAL_FORCE_STATIC_EXECUTABLE := true
LOCAL_REQUIRED_MODULES := e2fsdroid_static mke2fs_static mke2fs.conf
ifeq ($(TARGET_USERIMAGES_USE_F2FS),true)
ifeq ($(HOST_OS),linux)
LOCAL_REQUIRED_MODULES += sload.f2fs mkfs.f2fs
endif
endif
LOCAL_CFLAGS += -DRECOVERY_API_VERSION=$(RECOVERY_API_VERSION)
LOCAL_CFLAGS += -Wall -Werror
LOCAL_C_INCLUDES += \
system/vold \
LOCAL_STATIC_LIBRARIES := \
librecovery \
LOCAL_STATIC_LIBRARIES := librecovery
# If $(TARGET_RECOVERY_UI_LIB) is defined, the recovery calls make_device() from the
# $(TARGET_RECOVERY_UI_LIB), which depends on the librecovery_ui.
ifeq ($(TARGET_RECOVERY_UI_LIB),)
LOCAL_SRC_FILES += default_device.cpp
else
LOCAL_STATIC_LIBRARIES += $(TARGET_RECOVERY_UI_LIB)
endif
LOCAL_STATIC_LIBRARIES += \
libverifier \
libbatterymonitor \
libbootloader_message \
@ -149,6 +173,7 @@ LOCAL_STATIC_LIBRARIES := \
libminadbd \
libasyncio \
libfusesideload \
librecovery_ui \
libminui \
libpng \
libcrypto_utils \
@ -172,12 +197,6 @@ endif
LOCAL_MODULE_PATH := $(TARGET_RECOVERY_ROOT_OUT)/sbin
ifeq ($(TARGET_RECOVERY_UI_LIB),)
LOCAL_SRC_FILES += default_device.cpp
else
LOCAL_STATIC_LIBRARIES += $(TARGET_RECOVERY_UI_LIB)
endif
ifeq ($(BOARD_CACHEIMAGE_PARTITION_SIZE),)
LOCAL_REQUIRED_MODULES += recovery-persist recovery-refresh
endif

183
screen_ui.cpp
View file

@ -53,7 +53,98 @@ static double now() {
return tv.tv_sec + tv.tv_usec / 1000000.0;
}
ScreenRecoveryUI::ScreenRecoveryUI()
Menu::Menu(bool scrollable, size_t max_items, size_t max_length)
: scrollable_(scrollable),
max_display_items_(max_items),
max_item_length_(max_length),
text_headers_(nullptr),
menu_start_(0),
selection_(0) {
CHECK_LE(max_items, static_cast<size_t>(std::numeric_limits<int>::max()));
}
const char* const* Menu::text_headers() const {
return text_headers_;
}
std::string Menu::TextItem(size_t index) const {
CHECK_LT(index, text_items_.size());
return text_items_[index];
}
size_t Menu::MenuStart() const {
return menu_start_;
}
size_t Menu::MenuEnd() const {
return std::min(ItemsCount(), menu_start_ + max_display_items_);
}
size_t Menu::ItemsCount() const {
return text_items_.size();
}
bool Menu::ItemsOverflow(std::string* cur_selection_str) const {
if (!scrollable_ || static_cast<size_t>(ItemsCount()) <= max_display_items_) {
return false;
}
*cur_selection_str =
android::base::StringPrintf("Current item: %d/%zu", selection_ + 1, ItemsCount());
return true;
}
void Menu::Start(const char* const* headers, const char* const* items, int initial_selection) {
text_headers_ = headers;
// It's fine to have more entries than text_rows_ if scrollable menu is supported.
size_t max_items_count = scrollable_ ? std::numeric_limits<int>::max() : max_display_items_;
for (size_t i = 0; i < max_items_count && items[i] != nullptr; ++i) {
text_items_.emplace_back(items[i], strnlen(items[i], max_item_length_));
}
CHECK(!text_items_.empty());
selection_ = initial_selection;
}
// TODO(xunchang) modify the function parameters to button up & down.
int Menu::Select(int sel) {
CHECK_LE(ItemsCount(), static_cast<size_t>(std::numeric_limits<int>::max()));
int count = ItemsCount();
// Wraps the selection at boundary if the menu is not scrollable.
if (!scrollable_) {
if (sel < 0) {
selection_ = count - 1;
} else if (sel >= count) {
selection_ = 0;
} else {
selection_ = sel;
}
return selection_;
}
if (sel < 0) {
selection_ = 0;
} else if (sel >= count) {
selection_ = count - 1;
} else {
if (static_cast<size_t>(sel) < menu_start_) {
menu_start_--;
} else if (static_cast<size_t>(sel) >= MenuEnd()) {
menu_start_++;
}
selection_ = sel;
}
return selection_;
}
ScreenRecoveryUI::ScreenRecoveryUI() : ScreenRecoveryUI(false) {}
ScreenRecoveryUI::ScreenRecoveryUI(bool scrollable_menu)
: kMarginWidth(RECOVERY_UI_MARGIN_WIDTH),
kMarginHeight(RECOVERY_UI_MARGIN_HEIGHT),
kAnimationFps(RECOVERY_UI_ANIMATION_FPS),
@ -71,10 +162,7 @@ ScreenRecoveryUI::ScreenRecoveryUI()
text_row_(0),
show_text(false),
show_text_ever(false),
menu_headers_(nullptr),
show_menu(false),
menu_items(0),
menu_sel(0),
scrollable_menu_(scrollable_menu),
file_viewer_text_(nullptr),
intro_frames(0),
loop_frames(0),
@ -407,13 +495,13 @@ int ScreenRecoveryUI::DrawWrappedTextLines(int x, int y, const char* const* line
static const char* REGULAR_HELP[] = {
"Use volume up/down and power.",
NULL
nullptr,
};
static const char* LONG_PRESS_HELP[] = {
"Any button cycles highlight.",
"Long-press activates.",
NULL
nullptr,
};
// Redraws everything on the screen. Does not flip pages. Should only be called with updateMutex
@ -428,8 +516,13 @@ void ScreenRecoveryUI::draw_screen_locked() {
gr_color(0, 0, 0, 255);
gr_clear();
draw_menu_and_text_buffer_locked(HasThreeButtons() ? REGULAR_HELP : LONG_PRESS_HELP);
}
// 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 char* const* help_message) {
int y = kMarginHeight;
if (show_menu) {
if (menu_) {
static constexpr int kMenuIndent = 4;
int x = kMarginWidth + kMenuIndent;
@ -440,26 +533,46 @@ void ScreenRecoveryUI::draw_screen_locked() {
for (const auto& chunk : android::base::Split(recovery_fingerprint, ":")) {
y += DrawTextLine(x, y, chunk.c_str(), false);
}
y += DrawTextLines(x, y, HasThreeButtons() ? REGULAR_HELP : LONG_PRESS_HELP);
y += DrawTextLines(x, y, help_message);
// Draw menu header.
SetColor(HEADER);
// Ignore kMenuIndent, which is not taken into account by text_cols_.
y += DrawWrappedTextLines(kMarginWidth, y, menu_headers_);
if (!menu_->scrollable()) {
y += DrawWrappedTextLines(x, y, menu_->text_headers());
} else {
y += DrawTextLines(x, y, menu_->text_headers());
// Show the current menu item number in relation to total number if items don't fit on the
// screen.
std::string cur_selection_str;
if (menu_->ItemsOverflow(&cur_selection_str)) {
y += DrawTextLine(x, y, cur_selection_str.c_str(), true);
}
}
// Draw menu items.
SetColor(MENU);
y += DrawHorizontalRule(y) + 4;
for (int i = 0; i < menu_items; ++i) {
if (i == menu_sel) {
// Do not draw the horizontal rule for wear devices.
if (!menu_->scrollable()) {
y += DrawHorizontalRule(y) + 4;
}
for (size_t i = menu_->MenuStart(); i < menu_->MenuEnd(); ++i) {
bool bold = false;
if (i == static_cast<size_t>(menu_->selection())) {
// Draw the highlight bar.
SetColor(IsLongPress() ? MENU_SEL_BG_ACTIVE : MENU_SEL_BG);
DrawHighlightBar(0, y - 2, ScreenWidth(), char_height_ + 4);
int bar_height = char_height_ + 4;
DrawHighlightBar(0, y - 2, ScreenWidth(), bar_height);
// Bold white text for the selected item.
SetColor(MENU_SEL_FG);
y += DrawTextLine(x, y, menu_[i].c_str(), true);
SetColor(MENU);
} else {
y += DrawTextLine(x, y, menu_[i].c_str(), false);
bold = true;
}
y += DrawTextLine(x, y, menu_->TextItem(i).c_str(), bold);
SetColor(MENU);
}
y += DrawHorizontalRule(y);
}
@ -864,15 +977,10 @@ void ScreenRecoveryUI::ShowFile(const char* filename) {
void ScreenRecoveryUI::StartMenu(const char* const* headers, const char* const* items,
int initial_selection) {
pthread_mutex_lock(&updateMutex);
if (text_rows_ > 0 && text_cols_ > 0) {
menu_headers_ = headers;
menu_.clear();
for (size_t i = 0; i < text_rows_ && items[i] != nullptr; ++i) {
menu_.emplace_back(std::string(items[i], strnlen(items[i], text_cols_ - 1)));
}
menu_items = static_cast<int>(menu_.size());
show_menu = true;
menu_sel = initial_selection;
if (text_rows_ > 0 && text_cols_ > 1) {
menu_ = std::make_unique<Menu>(scrollable_menu_, text_rows_, text_cols_ - 1);
menu_->Start(headers, items, initial_selection);
update_screen_locked();
}
pthread_mutex_unlock(&updateMutex);
@ -880,16 +988,13 @@ void ScreenRecoveryUI::StartMenu(const char* const* headers, const char* const*
int ScreenRecoveryUI::SelectMenu(int sel) {
pthread_mutex_lock(&updateMutex);
if (show_menu) {
int old_sel = menu_sel;
menu_sel = sel;
if (menu_) {
int old_sel = menu_->selection();
sel = menu_->Select(sel);
// Wrap at top and bottom.
if (menu_sel < 0) menu_sel = menu_items - 1;
if (menu_sel >= menu_items) menu_sel = 0;
sel = menu_sel;
if (menu_sel != old_sel) update_screen_locked();
if (sel != old_sel) {
update_screen_locked();
}
}
pthread_mutex_unlock(&updateMutex);
return sel;
@ -897,8 +1002,8 @@ int ScreenRecoveryUI::SelectMenu(int sel) {
void ScreenRecoveryUI::EndMenu() {
pthread_mutex_lock(&updateMutex);
if (show_menu && text_rows_ > 0 && text_cols_ > 0) {
show_menu = false;
if (menu_) {
menu_.reset();
update_screen_locked();
}
pthread_mutex_unlock(&updateMutex);

73
screen_ui.h
View file

@ -20,6 +20,7 @@
#include <pthread.h>
#include <stdio.h>
#include <memory>
#include <string>
#include <vector>
@ -28,6 +29,70 @@
// From minui/minui.h.
struct GRSurface;
// This class maintains the menu selection and display of the screen ui.
class Menu {
public:
Menu(bool scrollable, size_t max_items, size_t max_length);
bool scrollable() const {
return scrollable_;
}
int selection() const {
return selection_;
}
// Returns count of menu items.
size_t ItemsCount() const;
// Returns the index of the first menu item.
size_t MenuStart() const;
// Returns the index of the last menu item + 1.
size_t MenuEnd() const;
// Menu example:
// info: Android Recovery
// ....
// help messages: Swipe up/down to move
// Swipe left/right to select
// empty line (horizontal rule):
// menu headers: Select file to view
// menu items: /cache/recovery/last_log
// /cache/recovery/last_log.1
// /cache/recovery/last_log.2
// ...
const char* const* text_headers() const;
std::string TextItem(size_t index) const;
// Checks if the menu items fit vertically on the screen. Returns true and set the
// |cur_selection_str| if the items exceed the screen limit.
bool ItemsOverflow(std::string* cur_selection_str) const;
// Starts the menu with |headers| and |items| in text. Sets the default selection to
// |initial_selection|.
void Start(const char* const* headers, const char* const* items, int initial_selection);
// Sets the current selection to |sel|. Handle the overflow cases depending on if the menu is
// scrollable.
int Select(int sel);
private:
// The menu is scrollable to display more items. Used on wear devices who have smaller screens.
const bool scrollable_;
// The max number of menu items to fit vertically on a screen.
const size_t max_display_items_;
// The length of each item to fit horizontally on a screen.
const size_t max_item_length_;
// Internal storage for the menu headers and items in text.
const char* const* text_headers_;
std::vector<std::string> text_items_;
// The first item to display on the screen.
size_t menu_start_;
// Current menu selection.
int selection_;
};
// Implementation of RecoveryUI appropriate for devices with a screen
// (shows an icon + a progress bar, text logging, menu, etc.)
class ScreenRecoveryUI : public RecoveryUI {
@ -44,6 +109,7 @@ class ScreenRecoveryUI : public RecoveryUI {
};
ScreenRecoveryUI();
explicit ScreenRecoveryUI(bool scrollable_menu);
bool Init(const std::string& locale) override;
@ -101,6 +167,7 @@ class ScreenRecoveryUI : public RecoveryUI {
virtual void draw_background_locked();
virtual void draw_foreground_locked();
virtual void draw_screen_locked();
virtual void draw_menu_and_text_buffer_locked(const char* const* help_message);
virtual void update_screen_locked();
virtual void update_progress_locked();
@ -184,10 +251,8 @@ class ScreenRecoveryUI : public RecoveryUI {
bool show_text;
bool show_text_ever; // has show_text ever been true?
std::vector<std::string> menu_;
const char* const* menu_headers_;
bool show_menu;
int menu_items, menu_sel;
bool scrollable_menu_;
std::unique_ptr<Menu> menu_;
// An alternate text screen, swapped with 'text_' when we're viewing a log file.
char** file_viewer_text_;

4
tests/Android.mk
View file

@ -23,6 +23,7 @@ LOCAL_MODULE := recovery_unit_test
LOCAL_COMPATIBILITY_SUITE := device-tests
LOCAL_STATIC_LIBRARIES := \
libverifier \
librecovery_ui \
libminui \
libotautil \
libupdater \
@ -38,8 +39,9 @@ LOCAL_SRC_FILES := \
unit/dirutil_test.cpp \
unit/locale_test.cpp \
unit/rangeset_test.cpp \
unit/screen_ui_test.cpp \
unit/sysutil_test.cpp \
unit/zip_test.cpp \
unit/zip_test.cpp
LOCAL_C_INCLUDES := bootable/recovery
LOCAL_SHARED_LIBRARIES := liblog

198
tests/unit/screen_ui_test.cpp Normal file
View file

@ -0,0 +1,198 @@
/*
* Copyright (C) 2018 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "screen_ui.h"
#include <string>
#include <gtest/gtest.h>
constexpr const char* HEADER[] = { "header", nullptr };
constexpr const char* ITEMS[] = { "items1", "items2", "items3", "items4", "1234567890", nullptr };
TEST(ScreenUITest, StartPhoneMenuSmoke) {
Menu menu(false, 10, 20);
ASSERT_FALSE(menu.scrollable());
menu.Start(HEADER, ITEMS, 0);
ASSERT_EQ(HEADER[0], menu.text_headers()[0]);
ASSERT_EQ(5u, menu.ItemsCount());
std::string message;
ASSERT_FALSE(menu.ItemsOverflow(&message));
for (size_t i = 0; i < menu.ItemsCount(); i++) {
ASSERT_EQ(ITEMS[i], menu.TextItem(i));
}
ASSERT_EQ(0, menu.selection());
}
TEST(ScreenUITest, StartWearMenuSmoke) {
Menu menu(true, 10, 8);
ASSERT_TRUE(menu.scrollable());
menu.Start(HEADER, ITEMS, 1);
ASSERT_EQ(HEADER[0], menu.text_headers()[0]);
ASSERT_EQ(5u, menu.ItemsCount());
std::string message;
ASSERT_FALSE(menu.ItemsOverflow(&message));
for (size_t i = 0; i < menu.ItemsCount() - 1; i++) {
ASSERT_EQ(ITEMS[i], menu.TextItem(i));
}
// Test of the last item is truncated
ASSERT_EQ("12345678", menu.TextItem(4));
ASSERT_EQ(1, menu.selection());
}
TEST(ScreenUITest, StartPhoneMenuItemsOverflow) {
Menu menu(false, 1, 20);
ASSERT_FALSE(menu.scrollable());
menu.Start(HEADER, ITEMS, 0);
ASSERT_EQ(1u, menu.ItemsCount());
std::string message;
ASSERT_FALSE(menu.ItemsOverflow(&message));
for (size_t i = 0; i < menu.ItemsCount(); i++) {
ASSERT_EQ(ITEMS[i], menu.TextItem(i));
}
ASSERT_EQ(0u, menu.MenuStart());
ASSERT_EQ(1u, menu.MenuEnd());
}
TEST(ScreenUITest, StartWearMenuItemsOverflow) {
Menu menu(true, 1, 20);
ASSERT_TRUE(menu.scrollable());
menu.Start(HEADER, ITEMS, 0);
ASSERT_EQ(5u, menu.ItemsCount());
std::string message;
ASSERT_TRUE(menu.ItemsOverflow(&message));
ASSERT_EQ("Current item: 1/5", message);
for (size_t i = 0; i < menu.ItemsCount(); i++) {
ASSERT_EQ(ITEMS[i], menu.TextItem(i));
}
ASSERT_EQ(0u, menu.MenuStart());
ASSERT_EQ(1u, menu.MenuEnd());
}
TEST(ScreenUITest, PhoneMenuSelectSmoke) {
Menu menu(false, 10, 20);
int sel = 0;
menu.Start(HEADER, ITEMS, sel);
// Mimic down button 10 times (2 * items size)
for (int i = 0; i < 10; i++) {
sel = menu.Select(++sel);
ASSERT_EQ(sel, menu.selection());
// Wraps the selection for unscrollable menu when it reaches the boundary.
int expected = (i + 1) % 5;
ASSERT_EQ(expected, menu.selection());
ASSERT_EQ(0u, menu.MenuStart());
ASSERT_EQ(5u, menu.MenuEnd());
}
// Mimic up button 10 times
for (int i = 0; i < 10; i++) {
sel = menu.Select(--sel);
ASSERT_EQ(sel, menu.selection());
int expected = (9 - i) % 5;
ASSERT_EQ(expected, menu.selection());
ASSERT_EQ(0u, menu.MenuStart());
ASSERT_EQ(5u, menu.MenuEnd());
}
}
TEST(ScreenUITest, WearMenuSelectSmoke) {
Menu menu(true, 10, 20);
int sel = 0;
menu.Start(HEADER, ITEMS, sel);
// Mimic pressing down button 10 times (2 * items size)
for (int i = 0; i < 10; i++) {
sel = menu.Select(++sel);
ASSERT_EQ(sel, menu.selection());
// Stops the selection at the boundary if the menu is scrollable.
int expected = std::min(i + 1, 4);
ASSERT_EQ(expected, menu.selection());
ASSERT_EQ(0u, menu.MenuStart());
ASSERT_EQ(5u, menu.MenuEnd());
}
// Mimic pressing up button 10 times
for (int i = 0; i < 10; i++) {
sel = menu.Select(--sel);
ASSERT_EQ(sel, menu.selection());
int expected = std::max(3 - i, 0);
ASSERT_EQ(expected, menu.selection());
ASSERT_EQ(0u, menu.MenuStart());
ASSERT_EQ(5u, menu.MenuEnd());
}
}
TEST(ScreenUITest, WearMenuSelectItemsOverflow) {
Menu menu(true, 3, 20);
int sel = 1;
menu.Start(HEADER, ITEMS, sel);
ASSERT_EQ(5u, menu.ItemsCount());
// Scroll the menu to the end, and check the start & end of menu.
for (int i = 0; i < 3; i++) {
sel = menu.Select(++sel);
ASSERT_EQ(i + 2, sel);
ASSERT_EQ(static_cast<size_t>(i), menu.MenuStart());
ASSERT_EQ(static_cast<size_t>(i + 3), menu.MenuEnd());
}
// Press down button one more time won't change the MenuStart() and MenuEnd().
sel = menu.Select(++sel);
ASSERT_EQ(4, sel);
ASSERT_EQ(2u, menu.MenuStart());
ASSERT_EQ(5u, menu.MenuEnd());
// Scroll the menu to the top.
// The expected menu sel, start & ends are:
// sel 3, start 2, end 5
// sel 2, start 2, end 5
// sel 1, start 1, end 4
// sel 0, start 0, end 3
for (int i = 0; i < 4; i++) {
sel = menu.Select(--sel);
ASSERT_EQ(3 - i, sel);
ASSERT_EQ(static_cast<size_t>(std::min(3 - i, 2)), menu.MenuStart());
ASSERT_EQ(static_cast<size_t>(std::min(6 - i, 5)), menu.MenuEnd());
}
// Press up button one more time won't change the MenuStart() and MenuEnd().
sel = menu.Select(--sel);
ASSERT_EQ(0, sel);
ASSERT_EQ(0u, menu.MenuStart());
ASSERT_EQ(3u, menu.MenuEnd());
}

116
wear_ui.cpp
View file

@ -17,7 +17,6 @@
#include "wear_ui.h"
#include <pthread.h>
#include <stdio.h> // TODO: Remove after killing the call to sprintf().
#include <string.h>
#include <string>
@ -27,7 +26,8 @@
#include <minui/minui.h>
WearRecoveryUI::WearRecoveryUI()
: kProgressBarBaseline(RECOVERY_UI_PROGRESS_BAR_BASELINE),
: 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().
@ -65,13 +65,10 @@ static const char* SWIPE_HELP[] = {
"Swipe up/down to move.",
"Swipe left/right to select.",
"",
NULL
nullptr,
};
// TODO merge drawing routines with screen_ui
void WearRecoveryUI::draw_screen_locked() {
char cur_selection_str[50];
draw_background_locked();
if (!show_text) {
draw_foreground_locked();
@ -79,68 +76,7 @@ void WearRecoveryUI::draw_screen_locked() {
SetColor(TEXT_FILL);
gr_fill(0, 0, gr_fb_width(), gr_fb_height());
int y = kMarginHeight;
int x = kMarginWidth;
if (show_menu) {
std::string recovery_fingerprint =
android::base::GetProperty("ro.bootimage.build.fingerprint", "");
SetColor(HEADER);
y += DrawTextLine(x + 4, y, "Android Recovery", true);
for (auto& chunk : android::base::Split(recovery_fingerprint, ":")) {
y += DrawTextLine(x + 4, y, chunk.c_str(), false);
}
// This is actually the help strings.
y += DrawTextLines(x + 4, y, SWIPE_HELP);
SetColor(HEADER);
y += DrawTextLines(x + 4, y, menu_headers_);
// Show the current menu item number in relation to total number if
// items don't fit on the screen.
if (menu_items > menu_end - menu_start) {
sprintf(cur_selection_str, "Current item: %d/%d", menu_sel + 1, menu_items);
gr_text(gr_sys_font(), x + 4, y, cur_selection_str, 1);
y += char_height_ + 4;
}
// Menu begins here
SetColor(MENU);
for (int i = menu_start; i < menu_end; ++i) {
if (i == menu_sel) {
// draw the highlight bar
SetColor(MENU_SEL_BG);
gr_fill(x, y - 2, gr_fb_width() - x, y + char_height_ + 2);
// white text of selected item
SetColor(MENU_SEL_FG);
if (menu_[i][0]) {
gr_text(gr_sys_font(), x + 4, y, menu_[i].c_str(), 1);
}
SetColor(MENU);
} else if (menu_[i][0]) {
gr_text(gr_sys_font(), x + 4, y, menu_[i].c_str(), 0);
}
y += char_height_ + 4;
}
SetColor(MENU);
y += 4;
gr_fill(0, y, gr_fb_width(), y + 2);
y += 4;
}
SetColor(LOG);
// display from the bottom up, until we hit the top of the
// screen, the bottom of the menu, or we've displayed the
// entire text buffer.
int row = text_row_;
size_t count = 0;
for (int ty = gr_fb_height() - char_height_ - kMarginHeight; ty > y + 2 && count < text_rows_;
ty -= char_height_, ++count) {
gr_text(gr_sys_font(), x + 4, ty, text_[row], 0);
--row;
if (row < 0) row = text_rows_ - 1;
}
draw_menu_and_text_buffer_locked(SWIPE_HELP);
}
}
@ -156,45 +92,11 @@ void WearRecoveryUI::StartMenu(const char* const* headers, const char* const* it
int initial_selection) {
pthread_mutex_lock(&updateMutex);
if (text_rows_ > 0 && text_cols_ > 0) {
menu_headers_ = headers;
menu_.clear();
// "i < text_rows_" is removed from the loop termination condition,
// which is different from the one in ScreenRecoveryUI::StartMenu().
// Because WearRecoveryUI supports scrollable menu, it's fine to have
// more entries than text_rows_. The menu may be truncated otherwise.
// Bug: 23752519
for (size_t i = 0; items[i] != nullptr; i++) {
menu_.emplace_back(std::string(items[i], strnlen(items[i], text_cols_ - 1)));
}
menu_items = static_cast<int>(menu_.size());
show_menu = true;
menu_sel = initial_selection;
menu_start = 0;
menu_end = text_rows_ - 1 - kMenuUnusableRows;
if (menu_items <= menu_end) menu_end = menu_items;
menu_ = std::make_unique<Menu>(scrollable_menu_, text_rows_ - kMenuUnusableRows - 1,
text_cols_ - 1);
menu_->Start(headers, items, initial_selection);
update_screen_locked();
}
pthread_mutex_unlock(&updateMutex);
}
int WearRecoveryUI::SelectMenu(int sel) {
int old_sel;
pthread_mutex_lock(&updateMutex);
if (show_menu) {
old_sel = menu_sel;
menu_sel = sel;
if (menu_sel < 0) menu_sel = 0;
if (menu_sel >= menu_items) menu_sel = menu_items - 1;
if (menu_sel < menu_start) {
menu_start--;
menu_end--;
} else if (menu_sel >= menu_end && menu_sel < menu_items) {
menu_end++;
menu_start++;
}
sel = menu_sel;
if (menu_sel != old_sel) update_screen_locked();
}
pthread_mutex_unlock(&updateMutex);
return sel;
}
}

4
wear_ui.h
View file

@ -25,10 +25,8 @@ class WearRecoveryUI : public ScreenRecoveryUI {
void SetStage(int current, int max) override;
// menu display
void StartMenu(const char* const* headers, const char* const* items,
int initial_selection) override;
int SelectMenu(int sel) override;
protected:
// progress bar vertical position, it's centered horizontally
@ -45,8 +43,6 @@ class WearRecoveryUI : public ScreenRecoveryUI {
private:
void draw_background_locked() override;
void draw_screen_locked() override;
int menu_start, menu_end;
};
#endif // RECOVERY_WEAR_UI_H