1 /*
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>
19 #include <stdarg.h>
20 #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"
32 #include "wear_ui.h"
33 #include "cutils/properties.h"
34 #include "android-base/strings.h"
35 #include "android-base/stringprintf.h"
36
37 // 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.
40 static WearRecoveryUI* self = NULL;
41
42 // Return the current time as a double (including fractions of a second).
now()43 static double now() {
44 struct timeval tv;
45 gettimeofday(&tv, NULL);
46 return tv.tv_sec + tv.tv_usec / 1000000.0;
47 }
48
WearRecoveryUI()49 WearRecoveryUI::WearRecoveryUI() :
50 progress_bar_y(259),
51 outer_height(0),
52 outer_width(0),
53 menu_unusable_rows(0) {
54 intro_frames = 22;
55 loop_frames = 60;
56 animation_fps = 30;
57
58 for (size_t i = 0; i < 5; i++)
59 backgroundIcon[i] = NULL;
60
61 self = this;
62 }
63
GetProgressBaseline()64 int WearRecoveryUI::GetProgressBaseline() {
65 return progress_bar_y;
66 }
67
68 // Draw background frame on the screen. Does not flip pages.
69 // Should only be called with updateMutex locked.
70 // TODO merge drawing routines with screen_ui
draw_background_locked()71 void WearRecoveryUI::draw_background_locked()
72 {
73 pagesIdentical = false;
74 gr_color(0, 0, 0, 255);
75 gr_fill(0, 0, gr_fb_width(), gr_fb_height());
76
77 if (currentIcon != NONE) {
78 GRSurface* surface;
79 if (currentIcon == INSTALLING_UPDATE || currentIcon == ERASING) {
80 if (!intro_done) {
81 surface = introFrames[current_frame];
82 } else {
83 surface = loopFrames[current_frame];
84 }
85 }
86 else {
87 surface = backgroundIcon[currentIcon];
88 }
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
100 static const char* HEADERS[] = {
101 "Swipe up/down to move.",
102 "Swipe left/right to select.",
103 "",
104 NULL
105 };
106
107 // TODO merge drawing routines with screen_ui
draw_screen_locked()108 void WearRecoveryUI::draw_screen_locked()
109 {
110 char cur_selection_str[50];
111
112 draw_background_locked();
113 if (!show_text) {
114 draw_foreground_locked();
115 } else {
116 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) {
122 char recovery_fingerprint[PROPERTY_VALUE_MAX];
123 property_get("ro.bootimage.build.fingerprint", recovery_fingerprint, "");
124 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);
139 gr_text(gr_sys_font(), x+4, y, cur_selection_str, 1);
140 y += char_height_+4;
141 }
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);
151 gr_fill(x, y-2, gr_fb_width()-x, y+char_height_+2);
152 // white text of selected item
153 SetColor(MENU_SEL_FG);
154 if (menu_[i][0]) {
155 gr_text(gr_sys_font(), x + 4, y, menu_[i], 1);
156 }
157 SetColor(MENU);
158 } else if (menu_[i][0]) {
159 gr_text(gr_sys_font(), x + 4, y, menu_[i], 0);
160 }
161 y += char_height_+4;
162 }
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;
175 int row = (text_top_ + text_rows_ - 1) % text_rows_;
176 size_t count = 0;
177 for (int ty = gr_fb_height() - char_height_ - outer_height;
178 ty > y + 2 && count < text_rows_;
179 ty -= char_height_, ++count) {
180 gr_text(gr_sys_font(), x+4, ty, text_[row], 0);
181 --row;
182 if (row < 0) row = text_rows_ - 1;
183 }
184 }
185 }
186
187 // TODO merge drawing routines with screen_ui
update_progress_locked()188 void WearRecoveryUI::update_progress_locked() {
189 draw_screen_locked();
190 gr_flip();
191 }
192
InitTextParams()193 void WearRecoveryUI::InitTextParams() {
194 ScreenRecoveryUI::InitTextParams();
195
196 text_cols_ = (gr_fb_width() - (outer_width * 2)) / char_width_;
197
198 if (text_rows_ > kMaxRows) text_rows_ = kMaxRows;
199 if (text_cols_ > kMaxCols) text_cols_ = kMaxCols;
200
201 visible_text_rows = (gr_fb_height() - (outer_height * 2)) / char_height_;
202 }
203
Init()204 void WearRecoveryUI::Init() {
205 ScreenRecoveryUI::Init();
206
207 LoadBitmap("icon_error", &backgroundIcon[ERROR]);
208 backgroundIcon[NO_COMMAND] = backgroundIcon[ERROR];
209
210 // This leaves backgroundIcon[INSTALLING_UPDATE] and backgroundIcon[ERASING]
211 // as NULL which is fine since draw_background_locked() doesn't use them.
212 }
213
SetStage(int current,int max)214 void WearRecoveryUI::SetStage(int current, int max)
215 {
216 }
217
Print(const char * fmt,...)218 void WearRecoveryUI::Print(const char *fmt, ...)
219 {
220 char buf[256];
221 va_list ap;
222 va_start(ap, fmt);
223 vsnprintf(buf, 256, fmt, ap);
224 va_end(ap);
225
226 fputs(buf, stdout);
227
228 // This can get called before ui_init(), so be careful.
229 pthread_mutex_lock(&updateMutex);
230 if (text_rows_ > 0 && text_cols_ > 0) {
231 char *ptr;
232 for (ptr = buf; *ptr != '\0'; ++ptr) {
233 if (*ptr == '\n' || text_col_ >= text_cols_) {
234 text_[text_row_][text_col_] = '\0';
235 text_col_ = 0;
236 text_row_ = (text_row_ + 1) % text_rows_;
237 if (text_row_ == text_top_) text_top_ = (text_top_ + 1) % text_rows_;
238 }
239 if (*ptr != '\n') text_[text_row_][text_col_++] = *ptr;
240 }
241 text_[text_row_][text_col_] = '\0';
242 update_screen_locked();
243 }
244 pthread_mutex_unlock(&updateMutex);
245 }
246
StartMenu(const char * const * headers,const char * const * items,int initial_selection)247 void WearRecoveryUI::StartMenu(const char* const * headers, const char* const * items,
248 int initial_selection) {
249 pthread_mutex_lock(&updateMutex);
250 if (text_rows_ > 0 && text_cols_ > 0) {
251 menu_headers_ = headers;
252 size_t i = 0;
253 // "i < text_rows_" is removed from the loop termination condition,
254 // which is different from the one in ScreenRecoveryUI::StartMenu().
255 // Because WearRecoveryUI supports scrollable menu, it's fine to have
256 // more entries than text_rows_. The menu may be truncated otherwise.
257 // Bug: 23752519
258 for (; items[i] != nullptr; i++) {
259 strncpy(menu_[i], items[i], text_cols_ - 1);
260 menu_[i][text_cols_ - 1] = '\0';
261 }
262 menu_items = i;
263 show_menu = true;
264 menu_sel = initial_selection;
265 menu_start = 0;
266 menu_end = visible_text_rows - 1 - menu_unusable_rows;
267 if (menu_items <= menu_end)
268 menu_end = menu_items;
269 update_screen_locked();
270 }
271 pthread_mutex_unlock(&updateMutex);
272 }
273
SelectMenu(int sel)274 int WearRecoveryUI::SelectMenu(int sel) {
275 int old_sel;
276 pthread_mutex_lock(&updateMutex);
277 if (show_menu) {
278 old_sel = menu_sel;
279 menu_sel = sel;
280 if (menu_sel < 0) menu_sel = 0;
281 if (menu_sel >= menu_items) menu_sel = menu_items-1;
282 if (menu_sel < menu_start) {
283 menu_start--;
284 menu_end--;
285 } else if (menu_sel >= menu_end && menu_sel < menu_items) {
286 menu_end++;
287 menu_start++;
288 }
289 sel = menu_sel;
290 if (menu_sel != old_sel) update_screen_locked();
291 }
292 pthread_mutex_unlock(&updateMutex);
293 return sel;
294 }
295
ShowFile(FILE * fp)296 void WearRecoveryUI::ShowFile(FILE* fp) {
297 std::vector<long> offsets;
298 offsets.push_back(ftell(fp));
299 ClearText();
300
301 struct stat sb;
302 fstat(fileno(fp), &sb);
303
304 bool show_prompt = false;
305 while (true) {
306 if (show_prompt) {
307 Print("--(%d%% of %d bytes)--",
308 static_cast<int>(100 * (double(ftell(fp)) / double(sb.st_size))),
309 static_cast<int>(sb.st_size));
310 Redraw();
311 while (show_prompt) {
312 show_prompt = false;
313 int key = WaitKey();
314 if (key == KEY_POWER || key == KEY_ENTER) {
315 return;
316 } else if (key == KEY_UP || key == KEY_VOLUMEUP) {
317 if (offsets.size() <= 1) {
318 show_prompt = true;
319 } else {
320 offsets.pop_back();
321 fseek(fp, offsets.back(), SEEK_SET);
322 }
323 } else {
324 if (feof(fp)) {
325 return;
326 }
327 offsets.push_back(ftell(fp));
328 }
329 }
330 ClearText();
331 }
332
333 int ch = getc(fp);
334 if (ch == EOF) {
335 text_row_ = text_top_ = text_rows_ - 2;
336 show_prompt = true;
337 } else {
338 PutChar(ch);
339 if (text_col_ == 0 && text_row_ >= text_rows_ - 2) {
340 text_top_ = text_row_;
341 show_prompt = true;
342 }
343 }
344 }
345 }
346
PutChar(char ch)347 void WearRecoveryUI::PutChar(char ch) {
348 pthread_mutex_lock(&updateMutex);
349 if (ch != '\n') text_[text_row_][text_col_++] = ch;
350 if (ch == '\n' || text_col_ >= text_cols_) {
351 text_col_ = 0;
352 ++text_row_;
353 }
354 pthread_mutex_unlock(&updateMutex);
355 }
356
ShowFile(const char * filename)357 void WearRecoveryUI::ShowFile(const char* filename) {
358 FILE* fp = fopen_path(filename, "re");
359 if (fp == nullptr) {
360 Print(" Unable to open %s: %s\n", filename, strerror(errno));
361 return;
362 }
363 ShowFile(fp);
364 fclose(fp);
365 }
366
ClearText()367 void WearRecoveryUI::ClearText() {
368 pthread_mutex_lock(&updateMutex);
369 text_col_ = 0;
370 text_row_ = 0;
371 text_top_ = 1;
372 for (size_t i = 0; i < text_rows_; ++i) {
373 memset(text_[i], 0, text_cols_ + 1);
374 }
375 pthread_mutex_unlock(&updateMutex);
376 }
377
PrintOnScreenOnly(const char * fmt,...)378 void WearRecoveryUI::PrintOnScreenOnly(const char *fmt, ...) {
379 va_list ap;
380 va_start(ap, fmt);
381 PrintV(fmt, false, ap);
382 va_end(ap);
383 }
384
PrintV(const char * fmt,bool copy_to_stdout,va_list ap)385 void WearRecoveryUI::PrintV(const char* fmt, bool copy_to_stdout, va_list ap) {
386 std::string str;
387 android::base::StringAppendV(&str, fmt, ap);
388
389 if (copy_to_stdout) {
390 fputs(str.c_str(), stdout);
391 }
392
393 pthread_mutex_lock(&updateMutex);
394 if (text_rows_ > 0 && text_cols_ > 0) {
395 for (const char* ptr = str.c_str(); *ptr != '\0'; ++ptr) {
396 if (*ptr == '\n' || text_col_ >= text_cols_) {
397 text_[text_row_][text_col_] = '\0';
398 text_col_ = 0;
399 text_row_ = (text_row_ + 1) % text_rows_;
400 if (text_row_ == text_top_) text_top_ = (text_top_ + 1) % text_rows_;
401 }
402 if (*ptr != '\n') text_[text_row_][text_col_++] = *ptr;
403 }
404 text_[text_row_][text_col_] = '\0';
405 update_screen_locked();
406 }
407 pthread_mutex_unlock(&updateMutex);
408 }
409