blob: c1222a5768ac94ae0d679a79fcaf6c503f3c34f9 [file] [log] [blame]
Doug Zongker211aebc2011-10-28 15:13:10 -07001/*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#ifndef RECOVERY_SCREEN_UI_H
18#define RECOVERY_SCREEN_UI_H
19
20#include <pthread.h>
Elliott Hughes95fc63e2015-04-10 19:12:01 -070021#include <stdio.h>
Doug Zongker211aebc2011-10-28 15:13:10 -070022
Tianjie Xu2b3f8002018-03-20 16:07:39 -070023#include <memory>
Tao Bao736d59c2017-01-03 10:15:33 -080024#include <string>
Tao Baoe15d7a52017-09-07 13:38:51 -070025#include <vector>
Tao Bao736d59c2017-01-03 10:15:33 -080026
Doug Zongker211aebc2011-10-28 15:13:10 -070027#include "ui.h"
Tao Bao0ecbd762017-01-16 21:16:58 -080028
29// From minui/minui.h.
30struct GRSurface;
Doug Zongker211aebc2011-10-28 15:13:10 -070031
Tianjie Xu2b3f8002018-03-20 16:07:39 -070032// This class maintains the menu selection and display of the screen ui.
33class Menu {
34 public:
35 Menu(bool scrollable, size_t max_items, size_t max_length);
36
37 bool scrollable() const {
38 return scrollable_;
39 }
40
41 int selection() const {
42 return selection_;
43 }
44
45 // Returns count of menu items.
46 size_t ItemsCount() const;
47 // Returns the index of the first menu item.
48 size_t MenuStart() const;
49 // Returns the index of the last menu item + 1.
50 size_t MenuEnd() const;
51
52 // Menu example:
53 // info: Android Recovery
54 // ....
55 // help messages: Swipe up/down to move
56 // Swipe left/right to select
57 // empty line (horizontal rule):
58 // menu headers: Select file to view
59 // menu items: /cache/recovery/last_log
60 // /cache/recovery/last_log.1
61 // /cache/recovery/last_log.2
62 // ...
63 const char* const* text_headers() const;
64 std::string TextItem(size_t index) const;
65
66 // Checks if the menu items fit vertically on the screen. Returns true and set the
67 // |cur_selection_str| if the items exceed the screen limit.
68 bool ItemsOverflow(std::string* cur_selection_str) const;
69
70 // Starts the menu with |headers| and |items| in text. Sets the default selection to
71 // |initial_selection|.
72 void Start(const char* const* headers, const char* const* items, int initial_selection);
73
74 // Sets the current selection to |sel|. Handle the overflow cases depending on if the menu is
75 // scrollable.
76 int Select(int sel);
77
78 private:
79 // The menu is scrollable to display more items. Used on wear devices who have smaller screens.
80 const bool scrollable_;
81 // The max number of menu items to fit vertically on a screen.
82 const size_t max_display_items_;
83 // The length of each item to fit horizontally on a screen.
84 const size_t max_item_length_;
85
86 // Internal storage for the menu headers and items in text.
87 const char* const* text_headers_;
88 std::vector<std::string> text_items_;
89
90 // The first item to display on the screen.
91 size_t menu_start_;
92 // Current menu selection.
93 int selection_;
94};
95
Doug Zongker211aebc2011-10-28 15:13:10 -070096// Implementation of RecoveryUI appropriate for devices with a screen
97// (shows an icon + a progress bar, text logging, menu, etc.)
98class ScreenRecoveryUI : public RecoveryUI {
Tao Bao5d2e3bd2017-06-23 22:23:50 -070099 public:
Tao Bao75779652017-09-10 11:28:32 -0700100 enum UIElement {
101 HEADER,
102 MENU,
103 MENU_SEL_BG,
104 MENU_SEL_BG_ACTIVE,
105 MENU_SEL_FG,
106 LOG,
107 TEXT_FILL,
108 INFO
109 };
110
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700111 ScreenRecoveryUI();
Tianjie Xu2b3f8002018-03-20 16:07:39 -0700112 explicit ScreenRecoveryUI(bool scrollable_menu);
Doug Zongker211aebc2011-10-28 15:13:10 -0700113
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700114 bool Init(const std::string& locale) override;
Doug Zongker211aebc2011-10-28 15:13:10 -0700115
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700116 // overall recovery state ("background image")
Tao Bao99b2d772017-06-23 22:47:03 -0700117 void SetBackground(Icon icon) override;
118 void SetSystemUpdateText(bool security_update) override;
Doug Zongker211aebc2011-10-28 15:13:10 -0700119
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700120 // progress indicator
121 void SetProgressType(ProgressType type) override;
122 void ShowProgress(float portion, float seconds) override;
123 void SetProgress(float fraction) override;
Doug Zongker211aebc2011-10-28 15:13:10 -0700124
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700125 void SetStage(int current, int max) override;
Doug Zongkerc87bab12013-11-25 13:53:25 -0800126
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700127 // text log
128 void ShowText(bool visible) override;
129 bool IsTextVisible() override;
130 bool WasTextEverVisible() override;
Doug Zongker211aebc2011-10-28 15:13:10 -0700131
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700132 // printing messages
Tao Bao99b2d772017-06-23 22:47:03 -0700133 void Print(const char* fmt, ...) override __printflike(2, 3);
134 void PrintOnScreenOnly(const char* fmt, ...) override __printflike(2, 3);
135 void ShowFile(const char* filename) override;
Doug Zongker211aebc2011-10-28 15:13:10 -0700136
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700137 // menu display
Tao Bao99b2d772017-06-23 22:47:03 -0700138 void StartMenu(const char* const* headers, const char* const* items,
139 int initial_selection) override;
140 int SelectMenu(int sel) override;
141 void EndMenu() override;
Doug Zongker211aebc2011-10-28 15:13:10 -0700142
Tao Bao99b2d772017-06-23 22:47:03 -0700143 void KeyLongPress(int) override;
Elliott Hughes642aaa72015-04-10 12:47:46 -0700144
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700145 void Redraw();
Doug Zongkerc0441d12013-07-31 11:28:24 -0700146
Tao Bao99b2d772017-06-23 22:47:03 -0700147 void SetColor(UIElement e) const;
Doug Zongkerc0441d12013-07-31 11:28:24 -0700148
Tianjie Xu29d55752017-09-20 17:53:46 -0700149 // Check the background text image. Use volume up/down button to cycle through the locales
150 // embedded in the png file, and power button to go back to recovery main menu.
151 void CheckBackgroundTextImages(const std::string& saved_locale);
152
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700153 protected:
154 // The margin that we don't want to use for showing texts (e.g. round screen, or screen with
155 // rounded corners).
156 const int kMarginWidth;
157 const int kMarginHeight;
Tao Bao4521b702017-06-20 18:11:21 -0700158
Tao Bao0470cee2017-08-02 17:11:04 -0700159 // Number of frames per sec (default: 30) for both parts of the animation.
160 const int kAnimationFps;
161
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700162 // The scale factor from dp to pixels. 1.0 for mdpi, 4.0 for xxxhdpi.
Tao Bao75779652017-09-10 11:28:32 -0700163 const float kDensity;
164
165 virtual bool InitTextParams();
166
167 virtual void draw_background_locked();
168 virtual void draw_foreground_locked();
169 virtual void draw_screen_locked();
Tianjie Xu2b3f8002018-03-20 16:07:39 -0700170 virtual void draw_menu_and_text_buffer_locked(const char* const* help_message);
Tao Bao75779652017-09-10 11:28:32 -0700171 virtual void update_screen_locked();
172 virtual void update_progress_locked();
173
174 GRSurface* GetCurrentFrame() const;
175 GRSurface* GetCurrentText() const;
176
177 static void* ProgressThreadStartRoutine(void* data);
178 void ProgressThreadLoop();
179
180 virtual void ShowFile(FILE*);
181 virtual void PrintV(const char*, bool, va_list);
182 void PutChar(char);
183 void ClearText();
184
185 void LoadAnimation();
186 void LoadBitmap(const char* filename, GRSurface** surface);
187 void LoadLocalizedBitmap(const char* filename, GRSurface** surface);
188
189 int PixelsFromDp(int dp) const;
190 virtual int GetAnimationBaseline() const;
191 virtual int GetProgressBaseline() const;
192 virtual int GetTextBaseline() const;
193
Luke Song92eda4d2017-09-19 10:51:35 -0700194 // Returns pixel width of draw buffer.
195 virtual int ScreenWidth() const;
196 // Returns pixel height of draw buffer.
197 virtual int ScreenHeight() const;
198
Tao Bao75779652017-09-10 11:28:32 -0700199 // Draws a highlight bar at (x, y) - (x + width, y + height).
200 virtual void DrawHighlightBar(int x, int y, int width, int height) const;
201 // Draws a horizontal rule at Y. Returns the offset it should be moving along Y-axis.
202 virtual int DrawHorizontalRule(int y) const;
203 // Draws a line of text. Returns the offset it should be moving along Y-axis.
204 virtual int DrawTextLine(int x, int y, const char* line, bool bold) const;
Luke Song92eda4d2017-09-19 10:51:35 -0700205 // Draws surface portion (sx, sy, w, h) at screen location (dx, dy).
206 virtual void DrawSurface(GRSurface* surface, int sx, int sy, int w, int h, int dx, int dy) const;
207 // Draws rectangle at (x, y) - (x + w, y + h).
208 virtual void DrawFill(int x, int y, int w, int h) const;
209 // Draws given surface (surface->pixel_bytes = 1) as text at (x, y).
210 virtual void DrawTextIcon(int x, int y, GRSurface* surface) const;
Tao Bao75779652017-09-10 11:28:32 -0700211 // Draws multiple text lines. Returns the offset it should be moving along Y-axis.
212 int DrawTextLines(int x, int y, const char* const* lines) const;
213 // Similar to DrawTextLines() to draw multiple text lines, but additionally wraps long lines.
214 // Returns the offset it should be moving along Y-axis.
215 int DrawWrappedTextLines(int x, int y, const char* const* lines) const;
Tao Bao171b4c42017-06-19 23:10:44 -0700216
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700217 Icon currentIcon;
Doug Zongker211aebc2011-10-28 15:13:10 -0700218
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700219 // The layout to use.
220 int layout_;
Elliott Hughesfaf36e02016-04-20 17:22:16 -0700221
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700222 GRSurface* error_icon;
Elliott Hughes498cda62016-04-14 16:49:04 -0700223
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700224 GRSurface* erasing_text;
225 GRSurface* error_text;
226 GRSurface* installing_text;
227 GRSurface* no_command_text;
Elliott Hughes498cda62016-04-14 16:49:04 -0700228
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700229 GRSurface** introFrames;
230 GRSurface** loopFrames;
Elliott Hughes498cda62016-04-14 16:49:04 -0700231
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700232 GRSurface* progressBarEmpty;
233 GRSurface* progressBarFill;
234 GRSurface* stageMarkerEmpty;
235 GRSurface* stageMarkerFill;
Doug Zongker211aebc2011-10-28 15:13:10 -0700236
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700237 ProgressType progressBarType;
Doug Zongker211aebc2011-10-28 15:13:10 -0700238
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700239 float progressScopeStart, progressScopeSize, progress;
240 double progressScopeTime, progressScopeDuration;
Doug Zongker211aebc2011-10-28 15:13:10 -0700241
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700242 // true when both graphics pages are the same (except for the progress bar).
243 bool pagesIdentical;
Doug Zongker211aebc2011-10-28 15:13:10 -0700244
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700245 size_t text_cols_, text_rows_;
Elliott Hughesc0491632015-05-06 12:40:05 -0700246
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700247 // Log text overlay, displayed when a magic key is pressed.
248 char** text_;
Tao Baocb5524c2017-09-08 21:25:32 -0700249 size_t text_col_, text_row_;
Elliott Hughesc0491632015-05-06 12:40:05 -0700250
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700251 bool show_text;
252 bool show_text_ever; // has show_text ever been true?
Doug Zongker211aebc2011-10-28 15:13:10 -0700253
Tianjie Xu2b3f8002018-03-20 16:07:39 -0700254 bool scrollable_menu_;
255 std::unique_ptr<Menu> menu_;
Doug Zongker211aebc2011-10-28 15:13:10 -0700256
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700257 // An alternate text screen, swapped with 'text_' when we're viewing a log file.
258 char** file_viewer_text_;
Elliott Hughesc0491632015-05-06 12:40:05 -0700259
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700260 pthread_t progress_thread_;
Doug Zongker32a0a472011-11-01 11:00:20 -0700261
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700262 // Number of intro frames and loop frames in the animation.
263 size_t intro_frames;
264 size_t loop_frames;
Damien Bargiacchi5e7cfb92016-08-24 18:28:43 -0700265
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700266 size_t current_frame;
267 bool intro_done;
Elliott Hughes498cda62016-04-14 16:49:04 -0700268
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700269 int stage, max_stage;
Doug Zongkerc87bab12013-11-25 13:53:25 -0800270
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700271 int char_width_;
272 int char_height_;
Tao Bao171b4c42017-06-19 23:10:44 -0700273
Tao Baoefb49ad2017-01-31 23:03:10 -0800274 // The locale that's used to show the rendered texts.
275 std::string locale_;
276 bool rtl_locale_;
277
Tao Bao5d2e3bd2017-06-23 22:23:50 -0700278 pthread_mutex_t updateMutex;
Tao Baoefb49ad2017-01-31 23:03:10 -0800279
280 private:
281 void SetLocale(const std::string&);
Tianjie Xu29d55752017-09-20 17:53:46 -0700282
283 // Display the background texts for "erasing", "error", "no_command" and "installing" for the
284 // selected locale.
285 void SelectAndShowBackgroundText(const std::vector<std::string>& locales_entries, size_t sel);
Doug Zongker211aebc2011-10-28 15:13:10 -0700286};
287
288#endif // RECOVERY_UI_H