blob: 0918ac45799ea51913396e1a1db759efc093fadf [file] [log] [blame]
Tao Bao337db142015-08-20 14:52:57 -07001/*
2 * Copyright (C) 2014 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#include <errno.h>
18#include <fcntl.h>
Tao Bao337db142015-08-20 14:52:57 -070019#include <stdarg.h>
Tao Bao337db142015-08-20 14:52:57 -070020#include <stdlib.h>
21#include <string.h>
22#include <sys/stat.h>
23#include <sys/time.h>
24#include <sys/types.h>
25#include <time.h>
26#include <unistd.h>
27
28#include <vector>
29
30#include "common.h"
31#include "device.h"
Tao Bao337db142015-08-20 14:52:57 -070032#include "wear_ui.h"
Elliott Hughescb220402016-09-23 15:30:55 -070033#include "android-base/properties.h"
Elliott Hughes4b166f02015-12-04 15:30:20 -080034#include "android-base/strings.h"
Prashant Malani0eb41c32016-02-25 18:27:03 -080035#include "android-base/stringprintf.h"
Tao Bao337db142015-08-20 14:52:57 -070036
Tao Bao337db142015-08-20 14:52:57 -070037// There's only (at most) one of these objects, and global callbacks
38// (for pthread_create, and the input event system) need to find it,
39// so use a global variable.
40static WearRecoveryUI* self = NULL;
41
42// Return the current time as a double (including fractions of a second).
43static double now() {
44 struct timeval tv;
45 gettimeofday(&tv, NULL);
46 return tv.tv_sec + tv.tv_usec / 1000000.0;
47}
48
49WearRecoveryUI::WearRecoveryUI() :
Tao Bao337db142015-08-20 14:52:57 -070050 progress_bar_y(259),
51 outer_height(0),
52 outer_width(0),
Damien Bargiacchi5e7cfb92016-08-24 18:28:43 -070053 menu_unusable_rows(0) {
54 intro_frames = 22;
55 loop_frames = 60;
56 animation_fps = 30;
Tao Bao337db142015-08-20 14:52:57 -070057
58 for (size_t i = 0; i < 5; i++)
59 backgroundIcon[i] = NULL;
60
Tao Bao337db142015-08-20 14:52:57 -070061 self = this;
62}
63
Damien Bargiacchi5e7cfb92016-08-24 18:28:43 -070064int WearRecoveryUI::GetProgressBaseline() {
65 return progress_bar_y;
66}
67
Tao Bao337db142015-08-20 14:52:57 -070068// Draw background frame on the screen. Does not flip pages.
69// Should only be called with updateMutex locked.
Damien Bargiacchi5e7cfb92016-08-24 18:28:43 -070070// TODO merge drawing routines with screen_ui
71void WearRecoveryUI::draw_background_locked()
Tao Bao337db142015-08-20 14:52:57 -070072{
Damien Bargiacchi5e7cfb92016-08-24 18:28:43 -070073 pagesIdentical = false;
Tao Bao337db142015-08-20 14:52:57 -070074 gr_color(0, 0, 0, 255);
75 gr_fill(0, 0, gr_fb_width(), gr_fb_height());
76
Damien Bargiacchi5e7cfb92016-08-24 18:28:43 -070077 if (currentIcon != NONE) {
Tao Bao337db142015-08-20 14:52:57 -070078 GRSurface* surface;
Damien Bargiacchi5e7cfb92016-08-24 18:28:43 -070079 if (currentIcon == INSTALLING_UPDATE || currentIcon == ERASING) {
Tao Bao337db142015-08-20 14:52:57 -070080 if (!intro_done) {
81 surface = introFrames[current_frame];
82 } else {
83 surface = loopFrames[current_frame];
84 }
85 }
86 else {
Damien Bargiacchi5e7cfb92016-08-24 18:28:43 -070087 surface = backgroundIcon[currentIcon];
Tao Bao337db142015-08-20 14:52:57 -070088 }
89
90 int width = gr_get_width(surface);
91 int height = gr_get_height(surface);
92
93 int x = (gr_fb_width() - width) / 2;
94 int y = (gr_fb_height() - height) / 2;
95
96 gr_blit(surface, 0, 0, width, height, x, y);
97 }
98}
99
Tao Bao337db142015-08-20 14:52:57 -0700100static const char* HEADERS[] = {
101 "Swipe up/down to move.",
102 "Swipe left/right to select.",
103 "",
104 NULL
105};
106
Damien Bargiacchi5e7cfb92016-08-24 18:28:43 -0700107// TODO merge drawing routines with screen_ui
Tao Bao337db142015-08-20 14:52:57 -0700108void WearRecoveryUI::draw_screen_locked()
109{
Tao Bao337db142015-08-20 14:52:57 -0700110 char cur_selection_str[50];
111
Damien Bargiacchi5e7cfb92016-08-24 18:28:43 -0700112 draw_background_locked();
113 if (!show_text) {
114 draw_foreground_locked();
115 } else {
Tao Bao337db142015-08-20 14:52:57 -0700116 SetColor(TEXT_FILL);
117 gr_fill(0, 0, gr_fb_width(), gr_fb_height());
118
119 int y = outer_height;
120 int x = outer_width;
121 if (show_menu) {
Elliott Hughescb220402016-09-23 15:30:55 -0700122 std::string recovery_fingerprint =
123 android::base::GetProperty("ro.bootimage.build.fingerprint", "");
Tao Bao337db142015-08-20 14:52:57 -0700124 SetColor(HEADER);
125 DrawTextLine(x + 4, &y, "Android Recovery", true);
126 for (auto& chunk: android::base::Split(recovery_fingerprint, ":")) {
127 DrawTextLine(x +4, &y, chunk.c_str(), false);
128 }
129
130 // This is actually the help strings.
131 DrawTextLines(x + 4, &y, HEADERS);
132 SetColor(HEADER);
133 DrawTextLines(x + 4, &y, menu_headers_);
134
135 // Show the current menu item number in relation to total number if
136 // items don't fit on the screen.
137 if (menu_items > menu_end - menu_start) {
138 sprintf(cur_selection_str, "Current item: %d/%d", menu_sel + 1, menu_items);
Damien Bargiacchi35fff612016-08-11 15:57:03 -0700139 gr_text(gr_sys_font(), x+4, y, cur_selection_str, 1);
Prashant Malani7a491222016-03-11 10:00:55 -0800140 y += char_height_+4;
Tao Bao337db142015-08-20 14:52:57 -0700141 }
142
143 // Menu begins here
144 SetColor(MENU);
145
146 for (int i = menu_start; i < menu_end; ++i) {
147
148 if (i == menu_sel) {
149 // draw the highlight bar
150 SetColor(MENU_SEL_BG);
Prashant Malani7a491222016-03-11 10:00:55 -0800151 gr_fill(x, y-2, gr_fb_width()-x, y+char_height_+2);
Tao Bao337db142015-08-20 14:52:57 -0700152 // white text of selected item
153 SetColor(MENU_SEL_FG);
Damien Bargiacchi5e7cfb92016-08-24 18:28:43 -0700154 if (menu_[i][0]) {
155 gr_text(gr_sys_font(), x + 4, y, menu_[i], 1);
156 }
Tao Bao337db142015-08-20 14:52:57 -0700157 SetColor(MENU);
Damien Bargiacchi5e7cfb92016-08-24 18:28:43 -0700158 } else if (menu_[i][0]) {
159 gr_text(gr_sys_font(), x + 4, y, menu_[i], 0);
Tao Bao337db142015-08-20 14:52:57 -0700160 }
Prashant Malani7a491222016-03-11 10:00:55 -0800161 y += char_height_+4;
Tao Bao337db142015-08-20 14:52:57 -0700162 }
163 SetColor(MENU);
164 y += 4;
165 gr_fill(0, y, gr_fb_width(), y+2);
166 y += 4;
167 }
168
169 SetColor(LOG);
170
171 // display from the bottom up, until we hit the top of the
172 // screen, the bottom of the menu, or we've displayed the
173 // entire text buffer.
174 int ty;
Damien Bargiacchi5e7cfb92016-08-24 18:28:43 -0700175 int row = (text_top_ + text_rows_ - 1) % text_rows_;
Tao Bao337db142015-08-20 14:52:57 -0700176 size_t count = 0;
Prashant Malani7a491222016-03-11 10:00:55 -0800177 for (int ty = gr_fb_height() - char_height_ - outer_height;
Damien Bargiacchi5e7cfb92016-08-24 18:28:43 -0700178 ty > y + 2 && count < text_rows_;
Prashant Malani7a491222016-03-11 10:00:55 -0800179 ty -= char_height_, ++count) {
Damien Bargiacchi5e7cfb92016-08-24 18:28:43 -0700180 gr_text(gr_sys_font(), x+4, ty, text_[row], 0);
Tao Bao337db142015-08-20 14:52:57 -0700181 --row;
Damien Bargiacchi5e7cfb92016-08-24 18:28:43 -0700182 if (row < 0) row = text_rows_ - 1;
Tao Bao337db142015-08-20 14:52:57 -0700183 }
184 }
185}
186
Damien Bargiacchiad8b5a62016-09-09 08:18:06 -0700187// TODO merge drawing routines with screen_ui
188void WearRecoveryUI::update_progress_locked() {
189 draw_screen_locked();
190 gr_flip();
Tao Bao337db142015-08-20 14:52:57 -0700191}
192
Damien Bargiacchi5e7cfb92016-08-24 18:28:43 -0700193void WearRecoveryUI::InitTextParams() {
194 ScreenRecoveryUI::InitTextParams();
Tao Bao337db142015-08-20 14:52:57 -0700195
Damien Bargiacchi5e7cfb92016-08-24 18:28:43 -0700196 text_cols_ = (gr_fb_width() - (outer_width * 2)) / char_width_;
Tao Bao337db142015-08-20 14:52:57 -0700197
Damien Bargiacchi5e7cfb92016-08-24 18:28:43 -0700198 if (text_rows_ > kMaxRows) text_rows_ = kMaxRows;
199 if (text_cols_ > kMaxCols) text_cols_ = kMaxCols;
200
Prashant Malani7a491222016-03-11 10:00:55 -0800201 visible_text_rows = (gr_fb_height() - (outer_height * 2)) / char_height_;
Damien Bargiacchi5e7cfb92016-08-24 18:28:43 -0700202}
Tao Bao337db142015-08-20 14:52:57 -0700203
Damien Bargiacchi5e7cfb92016-08-24 18:28:43 -0700204void WearRecoveryUI::Init() {
205 ScreenRecoveryUI::Init();
Tao Bao337db142015-08-20 14:52:57 -0700206
207 LoadBitmap("icon_installing", &backgroundIcon[INSTALLING_UPDATE]);
208 backgroundIcon[ERASING] = backgroundIcon[INSTALLING_UPDATE];
209 LoadBitmap("icon_error", &backgroundIcon[ERROR]);
210 backgroundIcon[NO_COMMAND] = backgroundIcon[ERROR];
Prashant Malanif7f9e502016-03-10 03:40:20 +0000211}
212
Tao Bao337db142015-08-20 14:52:57 -0700213void WearRecoveryUI::SetStage(int current, int max)
214{
215}
216
217void WearRecoveryUI::Print(const char *fmt, ...)
218{
219 char buf[256];
220 va_list ap;
221 va_start(ap, fmt);
222 vsnprintf(buf, 256, fmt, ap);
223 va_end(ap);
224
225 fputs(buf, stdout);
226
227 // This can get called before ui_init(), so be careful.
228 pthread_mutex_lock(&updateMutex);
Damien Bargiacchi5e7cfb92016-08-24 18:28:43 -0700229 if (text_rows_ > 0 && text_cols_ > 0) {
Tao Bao337db142015-08-20 14:52:57 -0700230 char *ptr;
231 for (ptr = buf; *ptr != '\0'; ++ptr) {
Damien Bargiacchi5e7cfb92016-08-24 18:28:43 -0700232 if (*ptr == '\n' || text_col_ >= text_cols_) {
233 text_[text_row_][text_col_] = '\0';
234 text_col_ = 0;
235 text_row_ = (text_row_ + 1) % text_rows_;
236 if (text_row_ == text_top_) text_top_ = (text_top_ + 1) % text_rows_;
Tao Bao337db142015-08-20 14:52:57 -0700237 }
Damien Bargiacchi5e7cfb92016-08-24 18:28:43 -0700238 if (*ptr != '\n') text_[text_row_][text_col_++] = *ptr;
Tao Bao337db142015-08-20 14:52:57 -0700239 }
Damien Bargiacchi5e7cfb92016-08-24 18:28:43 -0700240 text_[text_row_][text_col_] = '\0';
Tao Bao337db142015-08-20 14:52:57 -0700241 update_screen_locked();
242 }
243 pthread_mutex_unlock(&updateMutex);
244}
245
246void WearRecoveryUI::StartMenu(const char* const * headers, const char* const * items,
Damien Bargiacchi5e7cfb92016-08-24 18:28:43 -0700247 int initial_selection) {
Tao Bao337db142015-08-20 14:52:57 -0700248 pthread_mutex_lock(&updateMutex);
Damien Bargiacchi5e7cfb92016-08-24 18:28:43 -0700249 if (text_rows_ > 0 && text_cols_ > 0) {
Tao Bao337db142015-08-20 14:52:57 -0700250 menu_headers_ = headers;
251 size_t i = 0;
Damien Bargiacchi5e7cfb92016-08-24 18:28:43 -0700252 // "i < text_rows_" is removed from the loop termination condition,
Tao Bao8e9c6802015-09-02 11:20:30 -0700253 // which is different from the one in ScreenRecoveryUI::StartMenu().
254 // Because WearRecoveryUI supports scrollable menu, it's fine to have
Damien Bargiacchi5e7cfb92016-08-24 18:28:43 -0700255 // more entries than text_rows_. The menu may be truncated otherwise.
Tao Bao8e9c6802015-09-02 11:20:30 -0700256 // Bug: 23752519
257 for (; items[i] != nullptr; i++) {
Damien Bargiacchi5e7cfb92016-08-24 18:28:43 -0700258 strncpy(menu_[i], items[i], text_cols_ - 1);
259 menu_[i][text_cols_ - 1] = '\0';
Tao Bao337db142015-08-20 14:52:57 -0700260 }
261 menu_items = i;
Damien Bargiacchi5e7cfb92016-08-24 18:28:43 -0700262 show_menu = true;
Tao Bao337db142015-08-20 14:52:57 -0700263 menu_sel = initial_selection;
264 menu_start = 0;
265 menu_end = visible_text_rows - 1 - menu_unusable_rows;
266 if (menu_items <= menu_end)
267 menu_end = menu_items;
268 update_screen_locked();
269 }
270 pthread_mutex_unlock(&updateMutex);
271}
272
273int WearRecoveryUI::SelectMenu(int sel) {
274 int old_sel;
275 pthread_mutex_lock(&updateMutex);
Damien Bargiacchi5e7cfb92016-08-24 18:28:43 -0700276 if (show_menu) {
Tao Bao337db142015-08-20 14:52:57 -0700277 old_sel = menu_sel;
278 menu_sel = sel;
279 if (menu_sel < 0) menu_sel = 0;
280 if (menu_sel >= menu_items) menu_sel = menu_items-1;
281 if (menu_sel < menu_start) {
282 menu_start--;
283 menu_end--;
284 } else if (menu_sel >= menu_end && menu_sel < menu_items) {
285 menu_end++;
286 menu_start++;
287 }
288 sel = menu_sel;
289 if (menu_sel != old_sel) update_screen_locked();
290 }
291 pthread_mutex_unlock(&updateMutex);
292 return sel;
293}
294
Tao Bao337db142015-08-20 14:52:57 -0700295void WearRecoveryUI::ShowFile(FILE* fp) {
Chih-Hung Hsieh54a27472016-04-18 11:30:55 -0700296 std::vector<off_t> offsets;
297 offsets.push_back(ftello(fp));
Tao Bao337db142015-08-20 14:52:57 -0700298 ClearText();
299
300 struct stat sb;
301 fstat(fileno(fp), &sb);
302
303 bool show_prompt = false;
304 while (true) {
305 if (show_prompt) {
306 Print("--(%d%% of %d bytes)--",
Chih-Hung Hsieh54a27472016-04-18 11:30:55 -0700307 static_cast<int>(100 * (double(ftello(fp)) / double(sb.st_size))),
Tao Bao337db142015-08-20 14:52:57 -0700308 static_cast<int>(sb.st_size));
309 Redraw();
310 while (show_prompt) {
311 show_prompt = false;
312 int key = WaitKey();
313 if (key == KEY_POWER || key == KEY_ENTER) {
314 return;
315 } else if (key == KEY_UP || key == KEY_VOLUMEUP) {
316 if (offsets.size() <= 1) {
317 show_prompt = true;
318 } else {
319 offsets.pop_back();
320 fseek(fp, offsets.back(), SEEK_SET);
321 }
322 } else {
323 if (feof(fp)) {
324 return;
325 }
Chih-Hung Hsieh54a27472016-04-18 11:30:55 -0700326 offsets.push_back(ftello(fp));
Tao Bao337db142015-08-20 14:52:57 -0700327 }
328 }
329 ClearText();
330 }
331
332 int ch = getc(fp);
333 if (ch == EOF) {
Damien Bargiacchi5e7cfb92016-08-24 18:28:43 -0700334 text_row_ = text_top_ = text_rows_ - 2;
Tao Bao337db142015-08-20 14:52:57 -0700335 show_prompt = true;
336 } else {
337 PutChar(ch);
Damien Bargiacchi5e7cfb92016-08-24 18:28:43 -0700338 if (text_col_ == 0 && text_row_ >= text_rows_ - 2) {
339 text_top_ = text_row_;
Tao Bao337db142015-08-20 14:52:57 -0700340 show_prompt = true;
341 }
342 }
343 }
344}
345
346void WearRecoveryUI::PutChar(char ch) {
347 pthread_mutex_lock(&updateMutex);
Damien Bargiacchi5e7cfb92016-08-24 18:28:43 -0700348 if (ch != '\n') text_[text_row_][text_col_++] = ch;
349 if (ch == '\n' || text_col_ >= text_cols_) {
350 text_col_ = 0;
351 ++text_row_;
Tao Bao337db142015-08-20 14:52:57 -0700352 }
353 pthread_mutex_unlock(&updateMutex);
354}
355
356void WearRecoveryUI::ShowFile(const char* filename) {
357 FILE* fp = fopen_path(filename, "re");
358 if (fp == nullptr) {
359 Print(" Unable to open %s: %s\n", filename, strerror(errno));
360 return;
361 }
362 ShowFile(fp);
363 fclose(fp);
364}
365
366void WearRecoveryUI::ClearText() {
367 pthread_mutex_lock(&updateMutex);
Damien Bargiacchi5e7cfb92016-08-24 18:28:43 -0700368 text_col_ = 0;
369 text_row_ = 0;
370 text_top_ = 1;
371 for (size_t i = 0; i < text_rows_; ++i) {
372 memset(text_[i], 0, text_cols_ + 1);
Tao Bao337db142015-08-20 14:52:57 -0700373 }
374 pthread_mutex_unlock(&updateMutex);
375}
Prashant Malani0eb41c32016-02-25 18:27:03 -0800376
377void WearRecoveryUI::PrintOnScreenOnly(const char *fmt, ...) {
378 va_list ap;
379 va_start(ap, fmt);
380 PrintV(fmt, false, ap);
381 va_end(ap);
382}
383
384void WearRecoveryUI::PrintV(const char* fmt, bool copy_to_stdout, va_list ap) {
385 std::string str;
386 android::base::StringAppendV(&str, fmt, ap);
387
388 if (copy_to_stdout) {
389 fputs(str.c_str(), stdout);
390 }
391
392 pthread_mutex_lock(&updateMutex);
Damien Bargiacchi5e7cfb92016-08-24 18:28:43 -0700393 if (text_rows_ > 0 && text_cols_ > 0) {
Prashant Malani0eb41c32016-02-25 18:27:03 -0800394 for (const char* ptr = str.c_str(); *ptr != '\0'; ++ptr) {
Damien Bargiacchi5e7cfb92016-08-24 18:28:43 -0700395 if (*ptr == '\n' || text_col_ >= text_cols_) {
396 text_[text_row_][text_col_] = '\0';
397 text_col_ = 0;
398 text_row_ = (text_row_ + 1) % text_rows_;
399 if (text_row_ == text_top_) text_top_ = (text_top_ + 1) % text_rows_;
Prashant Malani0eb41c32016-02-25 18:27:03 -0800400 }
Damien Bargiacchi5e7cfb92016-08-24 18:28:43 -0700401 if (*ptr != '\n') text_[text_row_][text_col_++] = *ptr;
Prashant Malani0eb41c32016-02-25 18:27:03 -0800402 }
Damien Bargiacchi5e7cfb92016-08-24 18:28:43 -0700403 text_[text_row_][text_col_] = '\0';
Prashant Malani0eb41c32016-02-25 18:27:03 -0800404 update_screen_locked();
405 }
406 pthread_mutex_unlock(&updateMutex);
407}