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

Factor out a menu class for screen ui

Browse source 
Also consolidate the duplicate codes to draw the menu in ScreenRecoveryUI
and WearRecoveryUI. This helps us to support text icons as menu in the
future.

Bug: 74397117
Test: Check the menu under recovery on bullhead and a wear device.
Change-Id: Iba9b646c3828670f0e78a7e07d1a94a44e96bb0b
Merged-In: Iba9b646c3828670f0e78a7e07d1a94a44e96bb0b
This commit is contained in:
Tianjie Xu 2018-03-20 16:07:39 -07:00 committed by Tao Bao
parent ab8d782bd4
commit 5fe5eb67ef
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