summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--Android.mk79
-rw-r--r--screen_ui.cpp183
-rw-r--r--screen_ui.h73
-rw-r--r--tests/Android.mk4
-rw-r--r--tests/unit/screen_ui_test.cpp198
-rw-r--r--wear_ui.cpp116
-rw-r--r--wear_ui.h4
7 files changed, 472 insertions, 185 deletions
diff --git a/Android.mk b/Android.mk
index c8a21e084..b28929604 100644
--- a/Android.mk
+++ b/Android.mk
@@ -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 \
-
-LOCAL_MODULE := recovery
-
-LOCAL_FORCE_STATIC_EXECUTABLE := true
-
-LOCAL_REQUIRED_MODULES := e2fsdroid_static mke2fs_static mke2fs.conf
+ wear_ui.cpp
-ifeq ($(TARGET_USERIMAGES_USE_F2FS),true)
-ifeq ($(HOST_OS),linux)
-LOCAL_REQUIRED_MODULES += sload.f2fs mkfs.f2fs
-endif
-endif
+LOCAL_CFLAGS := -Wall -Werror
-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
diff --git a/screen_ui.cpp b/screen_ui.cpp
index c8fb5aa75..317e5529c 100644
--- a/screen_ui.cpp
+++ b/screen_ui.cpp
@@ -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;
-
- // Wrap at top and bottom.
- if (menu_sel < 0) menu_sel = menu_items - 1;
- if (menu_sel >= menu_items) menu_sel = 0;
+ if (menu_) {
+ int old_sel = menu_->selection();
+ sel = menu_->Select(sel);
- 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);
diff --git a/screen_ui.h b/screen_ui.h
index f05761c42..c1222a576 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 @@ 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_;
diff --git a/tests/Android.mk b/tests/Android.mk
index b3584fe87..9a71371fa 100644
--- a/tests/Android.mk
+++ b/tests/Android.mk
@@ -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
diff --git a/tests/unit/screen_ui_test.cpp b/tests/unit/screen_ui_test.cpp
new file mode 100644
index 000000000..be6799f2e
--- /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 ca6b1b102..118e43508 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 @@ 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;
- update_screen_locked();
- }
- pthread_mutex_unlock(&updateMutex);
-}
+ menu_ = std::make_unique<Menu>(scrollable_menu_, text_rows_ - kMenuUnusableRows - 1,
+ text_cols_ - 1);
+ menu_->Start(headers, items, initial_selection);
-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();
+ 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 739b4cb1d..8b24cb73e 100644
--- a/wear_ui.h
+++ b/wear_ui.h
@@ -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