Factor out a menu class for screen ui
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
diff --git a/Android.mk b/Android.mk
index c8a21e0..b289296 100644
--- a/Android.mk
+++ b/Android.mk
@@ -53,36 +53,21 @@
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 @@
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 @@
libminadbd \
libasyncio \
libfusesideload \
+ librecovery_ui \
libminui \
libpng \
libcrypto_utils \
@@ -172,12 +197,6 @@
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
diff --git a/screen_ui.cpp b/screen_ui.cpp
index c8fb5aa..317e552 100644
--- a/screen_ui.cpp
+++ b/screen_ui.cpp
@@ -53,7 +53,98 @@
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 @@
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 @@
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 @@
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 @@
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::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 @@
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 @@
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);
diff --git a/screen_ui.h b/screen_ui.h
index f05761c..c1222a5 100644
--- a/screen_ui.h
+++ b/screen_ui.h
@@ -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 @@
};
ScreenRecoveryUI();
+ explicit ScreenRecoveryUI(bool scrollable_menu);
bool Init(const std::string& locale) override;
@@ -101,6 +167,7 @@
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 @@
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_;
diff --git a/tests/Android.mk b/tests/Android.mk
index b3584fe..9a71371 100644
--- a/tests/Android.mk
+++ b/tests/Android.mk
@@ -23,6 +23,7 @@
LOCAL_COMPATIBILITY_SUITE := device-tests
LOCAL_STATIC_LIBRARIES := \
libverifier \
+ librecovery_ui \
libminui \
libotautil \
libupdater \
@@ -38,8 +39,9 @@
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
diff --git a/tests/unit/screen_ui_test.cpp b/tests/unit/screen_ui_test.cpp
new file mode 100644
index 0000000..be6799f
--- /dev/null
+++ b/tests/unit/screen_ui_test.cpp
@@ -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());
+}
diff --git a/wear_ui.cpp b/wear_ui.cpp
index ca6b1b1..118e435 100644
--- a/wear_ui.cpp
+++ b/wear_ui.cpp
@@ -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 @@
"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 @@
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 @@
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;
-}
+}
\ No newline at end of file
diff --git a/wear_ui.h b/wear_ui.h
index 739b4cb..8b24cb7 100644
--- a/wear_ui.h
+++ b/wear_ui.h
@@ -25,10 +25,8 @@
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 @@
private:
void draw_background_locked() override;
void draw_screen_locked() override;
-
- int menu_start, menu_end;
};
#endif // RECOVERY_WEAR_UI_H