1 /*
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 #include <errno.h>
18 #include <fcntl.h>
19 #include <linux/input.h>
20 #include <pthread.h>
21 #include <stdarg.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <sys/stat.h>
26 #include <sys/time.h>
27 #include <sys/types.h>
28 #include <time.h>
29 #include <unistd.h>
30
31 #include "common.h"
32 #include "device.h"
33 #include "minui/minui.h"
34 #include "screen_ui.h"
35 #include "ui.h"
36
37 static int char_width;
38 static int char_height;
39
40 // There's only (at most) one of these objects, and global callbacks
41 // (for pthread_create, and the input event system) need to find it,
42 // so use a global variable.
43 static ScreenRecoveryUI* self = NULL;
44
45 // Return the current time as a double (including fractions of a second).
now()46 static double now() {
47 struct timeval tv;
48 gettimeofday(&tv, NULL);
49 return tv.tv_sec + tv.tv_usec / 1000000.0;
50 }
51
ScreenRecoveryUI()52 ScreenRecoveryUI::ScreenRecoveryUI() :
53 currentIcon(NONE),
54 installingFrame(0),
55 rtl_locale(false),
56 progressBarType(EMPTY),
57 progressScopeStart(0),
58 progressScopeSize(0),
59 progress(0),
60 pagesIdentical(false),
61 text_cols(0),
62 text_rows(0),
63 text_col(0),
64 text_row(0),
65 text_top(0),
66 show_text(false),
67 show_text_ever(false),
68 show_menu(false),
69 menu_top(0),
70 menu_items(0),
71 menu_sel(0),
72
73 // These values are correct for the default image resources
74 // provided with the android platform. Devices which use
75 // different resources should have a subclass of ScreenRecoveryUI
76 // that overrides Init() to set these values appropriately and
77 // then call the superclass Init().
78 animation_fps(20),
79 indeterminate_frames(6),
80 installing_frames(7),
81 install_overlay_offset_x(13),
82 install_overlay_offset_y(190),
83 overlay_offset_x(-1),
84 overlay_offset_y(-1),
85 stage(-1),
86 max_stage(-1) {
87
88 for (int i = 0; i < 5; i++)
89 backgroundIcon[i] = NULL;
90
91 pthread_mutex_init(&updateMutex, NULL);
92 self = this;
93 }
94
95 // Draw the given frame over the installation overlay animation. The
96 // background is not cleared or draw with the base icon first; we
97 // assume that the frame already contains some other frame of the
98 // animation. Does nothing if no overlay animation is defined.
99 // Should only be called with updateMutex locked.
draw_install_overlay_locked(int frame)100 void ScreenRecoveryUI::draw_install_overlay_locked(int frame) {
101 if (installationOverlay == NULL || overlay_offset_x < 0) return;
102 gr_surface surface = installationOverlay[frame];
103 int iconWidth = gr_get_width(surface);
104 int iconHeight = gr_get_height(surface);
105 gr_blit(surface, 0, 0, iconWidth, iconHeight,
106 overlay_offset_x, overlay_offset_y);
107 }
108
109 // Clear the screen and draw the currently selected background icon (if any).
110 // Should only be called with updateMutex locked.
draw_background_locked(Icon icon)111 void ScreenRecoveryUI::draw_background_locked(Icon icon)
112 {
113 pagesIdentical = false;
114 gr_color(0, 0, 0, 255);
115 gr_fill(0, 0, gr_fb_width(), gr_fb_height());
116
117 if (icon) {
118 gr_surface surface = backgroundIcon[icon];
119 gr_surface text_surface = backgroundText[icon];
120
121 int iconWidth = gr_get_width(surface);
122 int iconHeight = gr_get_height(surface);
123 int textWidth = gr_get_width(text_surface);
124 int textHeight = gr_get_height(text_surface);
125 int stageHeight = gr_get_height(stageMarkerEmpty);
126
127 int sh = (max_stage >= 0) ? stageHeight : 0;
128
129 int iconX = (gr_fb_width() - iconWidth) / 2;
130 int iconY = (gr_fb_height() - (iconHeight+textHeight+40+sh)) / 2;
131
132 int textX = (gr_fb_width() - textWidth) / 2;
133 int textY = ((gr_fb_height() - (iconHeight+textHeight+40+sh)) / 2) + iconHeight + 40;
134
135 gr_blit(surface, 0, 0, iconWidth, iconHeight, iconX, iconY);
136 if (stageHeight > 0) {
137 int sw = gr_get_width(stageMarkerEmpty);
138 int x = (gr_fb_width() - max_stage * gr_get_width(stageMarkerEmpty)) / 2;
139 int y = iconY + iconHeight + 20;
140 for (int i = 0; i < max_stage; ++i) {
141 gr_blit((i < stage) ? stageMarkerFill : stageMarkerEmpty,
142 0, 0, sw, stageHeight, x, y);
143 x += sw;
144 }
145 }
146
147 if (icon == INSTALLING_UPDATE || icon == ERASING) {
148 draw_install_overlay_locked(installingFrame);
149 }
150
151 gr_color(255, 255, 255, 255);
152 gr_texticon(textX, textY, text_surface);
153 }
154 }
155
156 // Draw the progress bar (if any) on the screen. Does not flip pages.
157 // Should only be called with updateMutex locked.
draw_progress_locked()158 void ScreenRecoveryUI::draw_progress_locked()
159 {
160 if (currentIcon == ERROR) return;
161
162 if (currentIcon == INSTALLING_UPDATE || currentIcon == ERASING) {
163 draw_install_overlay_locked(installingFrame);
164 }
165
166 if (progressBarType != EMPTY) {
167 int iconHeight = gr_get_height(backgroundIcon[INSTALLING_UPDATE]);
168 int width = gr_get_width(progressBarEmpty);
169 int height = gr_get_height(progressBarEmpty);
170
171 int dx = (gr_fb_width() - width)/2;
172 int dy = (3*gr_fb_height() + iconHeight - 2*height)/4;
173
174 // Erase behind the progress bar (in case this was a progress-only update)
175 gr_color(0, 0, 0, 255);
176 gr_fill(dx, dy, width, height);
177
178 if (progressBarType == DETERMINATE) {
179 float p = progressScopeStart + progress * progressScopeSize;
180 int pos = (int) (p * width);
181
182 if (rtl_locale) {
183 // Fill the progress bar from right to left.
184 if (pos > 0) {
185 gr_blit(progressBarFill, width-pos, 0, pos, height, dx+width-pos, dy);
186 }
187 if (pos < width-1) {
188 gr_blit(progressBarEmpty, 0, 0, width-pos, height, dx, dy);
189 }
190 } else {
191 // Fill the progress bar from left to right.
192 if (pos > 0) {
193 gr_blit(progressBarFill, 0, 0, pos, height, dx, dy);
194 }
195 if (pos < width-1) {
196 gr_blit(progressBarEmpty, pos, 0, width-pos, height, dx+pos, dy);
197 }
198 }
199 }
200
201 if (progressBarType == INDETERMINATE) {
202 static int frame = 0;
203 gr_blit(progressBarIndeterminate[frame], 0, 0, width, height, dx, dy);
204 // in RTL locales, we run the animation backwards, which
205 // makes the spinner spin the other way.
206 if (rtl_locale) {
207 frame = (frame + indeterminate_frames - 1) % indeterminate_frames;
208 } else {
209 frame = (frame + 1) % indeterminate_frames;
210 }
211 }
212 }
213 }
214
SetColor(UIElement e)215 void ScreenRecoveryUI::SetColor(UIElement e) {
216 switch (e) {
217 case HEADER:
218 gr_color(247, 0, 6, 255);
219 break;
220 case MENU:
221 case MENU_SEL_BG:
222 gr_color(0, 106, 157, 255);
223 break;
224 case MENU_SEL_FG:
225 gr_color(255, 255, 255, 255);
226 break;
227 case LOG:
228 gr_color(249, 194, 0, 255);
229 break;
230 case TEXT_FILL:
231 gr_color(0, 0, 0, 160);
232 break;
233 default:
234 gr_color(255, 255, 255, 255);
235 break;
236 }
237 }
238
239 // Redraw everything on the screen. Does not flip pages.
240 // Should only be called with updateMutex locked.
draw_screen_locked()241 void ScreenRecoveryUI::draw_screen_locked()
242 {
243 draw_background_locked(currentIcon);
244 draw_progress_locked();
245
246 if (show_text) {
247 SetColor(TEXT_FILL);
248 gr_fill(0, 0, gr_fb_width(), gr_fb_height());
249
250 int y = 0;
251 int i = 0;
252 if (show_menu) {
253 SetColor(HEADER);
254
255 for (; i < menu_top + menu_items; ++i) {
256 if (i == menu_top) SetColor(MENU);
257
258 if (i == menu_top + menu_sel) {
259 // draw the highlight bar
260 SetColor(MENU_SEL_BG);
261 gr_fill(0, y-2, gr_fb_width(), y+char_height+2);
262 // white text of selected item
263 SetColor(MENU_SEL_FG);
264 if (menu[i][0]) gr_text(4, y, menu[i], 1);
265 SetColor(MENU);
266 } else {
267 if (menu[i][0]) gr_text(4, y, menu[i], i < menu_top);
268 }
269 y += char_height+4;
270 }
271 SetColor(MENU);
272 y += 4;
273 gr_fill(0, y, gr_fb_width(), y+2);
274 y += 4;
275 ++i;
276 }
277
278 SetColor(LOG);
279
280 // display from the bottom up, until we hit the top of the
281 // screen, the bottom of the menu, or we've displayed the
282 // entire text buffer.
283 int ty;
284 int row = (text_top+text_rows-1) % text_rows;
285 for (int ty = gr_fb_height() - char_height, count = 0;
286 ty > y+2 && count < text_rows;
287 ty -= char_height, ++count) {
288 gr_text(4, ty, text[row], 0);
289 --row;
290 if (row < 0) row = text_rows-1;
291 }
292 }
293 }
294
295 // Redraw everything on the screen and flip the screen (make it visible).
296 // Should only be called with updateMutex locked.
update_screen_locked()297 void ScreenRecoveryUI::update_screen_locked()
298 {
299 draw_screen_locked();
300 gr_flip();
301 }
302
303 // Updates only the progress bar, if possible, otherwise redraws the screen.
304 // Should only be called with updateMutex locked.
update_progress_locked()305 void ScreenRecoveryUI::update_progress_locked()
306 {
307 if (show_text || !pagesIdentical) {
308 draw_screen_locked(); // Must redraw the whole screen
309 pagesIdentical = true;
310 } else {
311 draw_progress_locked(); // Draw only the progress bar and overlays
312 }
313 gr_flip();
314 }
315
316 // Keeps the progress bar updated, even when the process is otherwise busy.
progress_thread(void * cookie)317 void* ScreenRecoveryUI::progress_thread(void *cookie) {
318 self->progress_loop();
319 return NULL;
320 }
321
progress_loop()322 void ScreenRecoveryUI::progress_loop() {
323 double interval = 1.0 / animation_fps;
324 for (;;) {
325 double start = now();
326 pthread_mutex_lock(&updateMutex);
327
328 int redraw = 0;
329
330 // update the installation animation, if active
331 // skip this if we have a text overlay (too expensive to update)
332 if ((currentIcon == INSTALLING_UPDATE || currentIcon == ERASING) &&
333 installing_frames > 0 && !show_text) {
334 installingFrame = (installingFrame + 1) % installing_frames;
335 redraw = 1;
336 }
337
338 // update the progress bar animation, if active
339 // skip this if we have a text overlay (too expensive to update)
340 if (progressBarType == INDETERMINATE && !show_text) {
341 redraw = 1;
342 }
343
344 // move the progress bar forward on timed intervals, if configured
345 int duration = progressScopeDuration;
346 if (progressBarType == DETERMINATE && duration > 0) {
347 double elapsed = now() - progressScopeTime;
348 float p = 1.0 * elapsed / duration;
349 if (p > 1.0) p = 1.0;
350 if (p > progress) {
351 progress = p;
352 redraw = 1;
353 }
354 }
355
356 if (redraw) update_progress_locked();
357
358 pthread_mutex_unlock(&updateMutex);
359 double end = now();
360 // minimum of 20ms delay between frames
361 double delay = interval - (end-start);
362 if (delay < 0.02) delay = 0.02;
363 usleep((long)(delay * 1000000));
364 }
365 }
366
LoadBitmap(const char * filename,gr_surface * surface)367 void ScreenRecoveryUI::LoadBitmap(const char* filename, gr_surface* surface) {
368 int result = res_create_surface(filename, surface);
369 if (result < 0) {
370 LOGE("missing bitmap %s\n(Code %d)\n", filename, result);
371 }
372 }
373
LoadLocalizedBitmap(const char * filename,gr_surface * surface)374 void ScreenRecoveryUI::LoadLocalizedBitmap(const char* filename, gr_surface* surface) {
375 int result = res_create_localized_surface(filename, surface);
376 if (result < 0) {
377 LOGE("missing bitmap %s\n(Code %d)\n", filename, result);
378 }
379 }
380
Init()381 void ScreenRecoveryUI::Init()
382 {
383 gr_init();
384
385 gr_font_size(&char_width, &char_height);
386
387 text_col = text_row = 0;
388 text_rows = gr_fb_height() / char_height;
389 if (text_rows > kMaxRows) text_rows = kMaxRows;
390 text_top = 1;
391
392 text_cols = gr_fb_width() / char_width;
393 if (text_cols > kMaxCols - 1) text_cols = kMaxCols - 1;
394
395 LoadBitmap("icon_installing", &backgroundIcon[INSTALLING_UPDATE]);
396 backgroundIcon[ERASING] = backgroundIcon[INSTALLING_UPDATE];
397 LoadBitmap("icon_error", &backgroundIcon[ERROR]);
398 backgroundIcon[NO_COMMAND] = backgroundIcon[ERROR];
399
400 LoadBitmap("progress_empty", &progressBarEmpty);
401 LoadBitmap("progress_fill", &progressBarFill);
402 LoadBitmap("stage_empty", &stageMarkerEmpty);
403 LoadBitmap("stage_fill", &stageMarkerFill);
404
405 LoadLocalizedBitmap("installing_text", &backgroundText[INSTALLING_UPDATE]);
406 LoadLocalizedBitmap("erasing_text", &backgroundText[ERASING]);
407 LoadLocalizedBitmap("no_command_text", &backgroundText[NO_COMMAND]);
408 LoadLocalizedBitmap("error_text", &backgroundText[ERROR]);
409
410 int i;
411
412 progressBarIndeterminate = (gr_surface*)malloc(indeterminate_frames *
413 sizeof(gr_surface));
414 for (i = 0; i < indeterminate_frames; ++i) {
415 char filename[40];
416 // "indeterminate01.png", "indeterminate02.png", ...
417 sprintf(filename, "indeterminate%02d", i+1);
418 LoadBitmap(filename, progressBarIndeterminate+i);
419 }
420
421 if (installing_frames > 0) {
422 installationOverlay = (gr_surface*)malloc(installing_frames *
423 sizeof(gr_surface));
424 for (i = 0; i < installing_frames; ++i) {
425 char filename[40];
426 // "icon_installing_overlay01.png",
427 // "icon_installing_overlay02.png", ...
428 sprintf(filename, "icon_installing_overlay%02d", i+1);
429 LoadBitmap(filename, installationOverlay+i);
430 }
431 } else {
432 installationOverlay = NULL;
433 }
434
435 pthread_create(&progress_t, NULL, progress_thread, NULL);
436
437 RecoveryUI::Init();
438 }
439
SetLocale(const char * locale)440 void ScreenRecoveryUI::SetLocale(const char* locale) {
441 if (locale) {
442 char* lang = strdup(locale);
443 for (char* p = lang; *p; ++p) {
444 if (*p == '_') {
445 *p = '\0';
446 break;
447 }
448 }
449
450 // A bit cheesy: keep an explicit list of supported languages
451 // that are RTL.
452 if (strcmp(lang, "ar") == 0 || // Arabic
453 strcmp(lang, "fa") == 0 || // Persian (Farsi)
454 strcmp(lang, "he") == 0 || // Hebrew (new language code)
455 strcmp(lang, "iw") == 0 || // Hebrew (old language code)
456 strcmp(lang, "ur") == 0) { // Urdu
457 rtl_locale = true;
458 }
459 free(lang);
460 }
461 }
462
SetBackground(Icon icon)463 void ScreenRecoveryUI::SetBackground(Icon icon)
464 {
465 pthread_mutex_lock(&updateMutex);
466
467 // Adjust the offset to account for the positioning of the
468 // base image on the screen.
469 if (backgroundIcon[icon] != NULL) {
470 gr_surface bg = backgroundIcon[icon];
471 gr_surface text = backgroundText[icon];
472 overlay_offset_x = install_overlay_offset_x + (gr_fb_width() - gr_get_width(bg)) / 2;
473 overlay_offset_y = install_overlay_offset_y +
474 (gr_fb_height() - (gr_get_height(bg) +
475 gr_get_height(text) +
476 40 +
477 ((max_stage >= 0) ? gr_get_height(stageMarkerEmpty) : 0))) / 2;
478 }
479
480 currentIcon = icon;
481 update_screen_locked();
482
483 pthread_mutex_unlock(&updateMutex);
484 }
485
SetProgressType(ProgressType type)486 void ScreenRecoveryUI::SetProgressType(ProgressType type)
487 {
488 pthread_mutex_lock(&updateMutex);
489 if (progressBarType != type) {
490 progressBarType = type;
491 }
492 progressScopeStart = 0;
493 progressScopeSize = 0;
494 progress = 0;
495 update_progress_locked();
496 pthread_mutex_unlock(&updateMutex);
497 }
498
ShowProgress(float portion,float seconds)499 void ScreenRecoveryUI::ShowProgress(float portion, float seconds)
500 {
501 pthread_mutex_lock(&updateMutex);
502 progressBarType = DETERMINATE;
503 progressScopeStart += progressScopeSize;
504 progressScopeSize = portion;
505 progressScopeTime = now();
506 progressScopeDuration = seconds;
507 progress = 0;
508 update_progress_locked();
509 pthread_mutex_unlock(&updateMutex);
510 }
511
SetProgress(float fraction)512 void ScreenRecoveryUI::SetProgress(float fraction)
513 {
514 pthread_mutex_lock(&updateMutex);
515 if (fraction < 0.0) fraction = 0.0;
516 if (fraction > 1.0) fraction = 1.0;
517 if (progressBarType == DETERMINATE && fraction > progress) {
518 // Skip updates that aren't visibly different.
519 int width = gr_get_width(progressBarIndeterminate[0]);
520 float scale = width * progressScopeSize;
521 if ((int) (progress * scale) != (int) (fraction * scale)) {
522 progress = fraction;
523 update_progress_locked();
524 }
525 }
526 pthread_mutex_unlock(&updateMutex);
527 }
528
SetStage(int current,int max)529 void ScreenRecoveryUI::SetStage(int current, int max) {
530 pthread_mutex_lock(&updateMutex);
531 stage = current;
532 max_stage = max;
533 pthread_mutex_unlock(&updateMutex);
534 }
535
Print(const char * fmt,...)536 void ScreenRecoveryUI::Print(const char *fmt, ...)
537 {
538 char buf[256];
539 va_list ap;
540 va_start(ap, fmt);
541 vsnprintf(buf, 256, fmt, ap);
542 va_end(ap);
543
544 fputs(buf, stdout);
545
546 // This can get called before ui_init(), so be careful.
547 pthread_mutex_lock(&updateMutex);
548 if (text_rows > 0 && text_cols > 0) {
549 char *ptr;
550 for (ptr = buf; *ptr != '\0'; ++ptr) {
551 if (*ptr == '\n' || text_col >= text_cols) {
552 text[text_row][text_col] = '\0';
553 text_col = 0;
554 text_row = (text_row + 1) % text_rows;
555 if (text_row == text_top) text_top = (text_top + 1) % text_rows;
556 }
557 if (*ptr != '\n') text[text_row][text_col++] = *ptr;
558 }
559 text[text_row][text_col] = '\0';
560 update_screen_locked();
561 }
562 pthread_mutex_unlock(&updateMutex);
563 }
564
StartMenu(const char * const * headers,const char * const * items,int initial_selection)565 void ScreenRecoveryUI::StartMenu(const char* const * headers, const char* const * items,
566 int initial_selection) {
567 int i;
568 pthread_mutex_lock(&updateMutex);
569 if (text_rows > 0 && text_cols > 0) {
570 for (i = 0; i < text_rows; ++i) {
571 if (headers[i] == NULL) break;
572 strncpy(menu[i], headers[i], text_cols-1);
573 menu[i][text_cols-1] = '\0';
574 }
575 menu_top = i;
576 for (; i < text_rows; ++i) {
577 if (items[i-menu_top] == NULL) break;
578 strncpy(menu[i], items[i-menu_top], text_cols-1);
579 menu[i][text_cols-1] = '\0';
580 }
581 menu_items = i - menu_top;
582 show_menu = 1;
583 menu_sel = initial_selection;
584 update_screen_locked();
585 }
586 pthread_mutex_unlock(&updateMutex);
587 }
588
SelectMenu(int sel)589 int ScreenRecoveryUI::SelectMenu(int sel) {
590 int old_sel;
591 pthread_mutex_lock(&updateMutex);
592 if (show_menu > 0) {
593 old_sel = menu_sel;
594 menu_sel = sel;
595 if (menu_sel < 0) menu_sel = 0;
596 if (menu_sel >= menu_items) menu_sel = menu_items-1;
597 sel = menu_sel;
598 if (menu_sel != old_sel) update_screen_locked();
599 }
600 pthread_mutex_unlock(&updateMutex);
601 return sel;
602 }
603
EndMenu()604 void ScreenRecoveryUI::EndMenu() {
605 int i;
606 pthread_mutex_lock(&updateMutex);
607 if (show_menu > 0 && text_rows > 0 && text_cols > 0) {
608 show_menu = 0;
609 update_screen_locked();
610 }
611 pthread_mutex_unlock(&updateMutex);
612 }
613
IsTextVisible()614 bool ScreenRecoveryUI::IsTextVisible()
615 {
616 pthread_mutex_lock(&updateMutex);
617 int visible = show_text;
618 pthread_mutex_unlock(&updateMutex);
619 return visible;
620 }
621
WasTextEverVisible()622 bool ScreenRecoveryUI::WasTextEverVisible()
623 {
624 pthread_mutex_lock(&updateMutex);
625 int ever_visible = show_text_ever;
626 pthread_mutex_unlock(&updateMutex);
627 return ever_visible;
628 }
629
ShowText(bool visible)630 void ScreenRecoveryUI::ShowText(bool visible)
631 {
632 pthread_mutex_lock(&updateMutex);
633 show_text = visible;
634 if (show_text) show_text_ever = 1;
635 update_screen_locked();
636 pthread_mutex_unlock(&updateMutex);
637 }
638
Redraw()639 void ScreenRecoveryUI::Redraw()
640 {
641 pthread_mutex_lock(&updateMutex);
642 update_screen_locked();
643 pthread_mutex_unlock(&updateMutex);
644 }
645