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     locale(NULL),
56     rtl_locale(false),
57     progressBarType(EMPTY),
58     progressScopeStart(0),
59     progressScopeSize(0),
60     progress(0),
61     pagesIdentical(false),
62     text_cols(0),
63     text_rows(0),
64     text_col(0),
65     text_row(0),
66     text_top(0),
67     show_text(false),
68     show_text_ever(false),
69     show_menu(false),
70     menu_top(0),
71     menu_items(0),
72     menu_sel(0),
73     animation_fps(20),
74     installing_frames(-1),
75     stage(-1),
76     max_stage(-1) {
77 
78     for (int i = 0; i < 5; i++)
79         backgroundIcon[i] = NULL;
80 
81     memset(text, 0, sizeof(text));
82 
83     pthread_mutex_init(&updateMutex, NULL);
84     self = this;
85 }
86 
87 // Clear the screen and draw the currently selected background icon (if any).
88 // Should only be called with updateMutex locked.
draw_background_locked(Icon icon)89 void ScreenRecoveryUI::draw_background_locked(Icon icon)
90 {
91     pagesIdentical = false;
92     gr_color(0, 0, 0, 255);
93     gr_clear();
94 
95     if (icon) {
96         gr_surface surface = backgroundIcon[icon];
97         if (icon == INSTALLING_UPDATE || icon == ERASING) {
98             surface = installation[installingFrame];
99         }
100         gr_surface text_surface = backgroundText[icon];
101 
102         int iconWidth = gr_get_width(surface);
103         int iconHeight = gr_get_height(surface);
104         int textWidth = gr_get_width(text_surface);
105         int textHeight = gr_get_height(text_surface);
106         int stageHeight = gr_get_height(stageMarkerEmpty);
107 
108         int sh = (max_stage >= 0) ? stageHeight : 0;
109 
110         iconX = (gr_fb_width() - iconWidth) / 2;
111         iconY = (gr_fb_height() - (iconHeight+textHeight+40+sh)) / 2;
112 
113         int textX = (gr_fb_width() - textWidth) / 2;
114         int textY = ((gr_fb_height() - (iconHeight+textHeight+40+sh)) / 2) + iconHeight + 40;
115 
116         gr_blit(surface, 0, 0, iconWidth, iconHeight, iconX, iconY);
117         if (stageHeight > 0) {
118             int sw = gr_get_width(stageMarkerEmpty);
119             int x = (gr_fb_width() - max_stage * gr_get_width(stageMarkerEmpty)) / 2;
120             int y = iconY + iconHeight + 20;
121             for (int i = 0; i < max_stage; ++i) {
122                 gr_blit((i < stage) ? stageMarkerFill : stageMarkerEmpty,
123                         0, 0, sw, stageHeight, x, y);
124                 x += sw;
125             }
126         }
127 
128         gr_color(255, 255, 255, 255);
129         gr_texticon(textX, textY, text_surface);
130     }
131 }
132 
133 // Draw the progress bar (if any) on the screen.  Does not flip pages.
134 // Should only be called with updateMutex locked.
draw_progress_locked()135 void ScreenRecoveryUI::draw_progress_locked()
136 {
137     if (currentIcon == ERROR) return;
138 
139     if (currentIcon == INSTALLING_UPDATE || currentIcon == ERASING) {
140         gr_surface icon = installation[installingFrame];
141         gr_blit(icon, 0, 0, gr_get_width(icon), gr_get_height(icon), iconX, iconY);
142     }
143 
144     if (progressBarType != EMPTY) {
145         int iconHeight = gr_get_height(backgroundIcon[INSTALLING_UPDATE]);
146         int width = gr_get_width(progressBarEmpty);
147         int height = gr_get_height(progressBarEmpty);
148 
149         int dx = (gr_fb_width() - width)/2;
150         int dy = (3*gr_fb_height() + iconHeight - 2*height)/4;
151 
152         // Erase behind the progress bar (in case this was a progress-only update)
153         gr_color(0, 0, 0, 255);
154         gr_fill(dx, dy, width, height);
155 
156         if (progressBarType == DETERMINATE) {
157             float p = progressScopeStart + progress * progressScopeSize;
158             int pos = (int) (p * width);
159 
160             if (rtl_locale) {
161                 // Fill the progress bar from right to left.
162                 if (pos > 0) {
163                     gr_blit(progressBarFill, width-pos, 0, pos, height, dx+width-pos, dy);
164                 }
165                 if (pos < width-1) {
166                     gr_blit(progressBarEmpty, 0, 0, width-pos, height, dx, dy);
167                 }
168             } else {
169                 // Fill the progress bar from left to right.
170                 if (pos > 0) {
171                     gr_blit(progressBarFill, 0, 0, pos, height, dx, dy);
172                 }
173                 if (pos < width-1) {
174                     gr_blit(progressBarEmpty, pos, 0, width-pos, height, dx+pos, dy);
175                 }
176             }
177         }
178     }
179 }
180 
SetColor(UIElement e)181 void ScreenRecoveryUI::SetColor(UIElement e) {
182     switch (e) {
183         case HEADER:
184             gr_color(247, 0, 6, 255);
185             break;
186         case MENU:
187         case MENU_SEL_BG:
188             gr_color(0, 106, 157, 255);
189             break;
190         case MENU_SEL_FG:
191             gr_color(255, 255, 255, 255);
192             break;
193         case LOG:
194             gr_color(249, 194, 0, 255);
195             break;
196         case TEXT_FILL:
197             gr_color(0, 0, 0, 160);
198             break;
199         default:
200             gr_color(255, 255, 255, 255);
201             break;
202     }
203 }
204 
205 // Redraw everything on the screen.  Does not flip pages.
206 // Should only be called with updateMutex locked.
draw_screen_locked()207 void ScreenRecoveryUI::draw_screen_locked()
208 {
209     if (!show_text) {
210         draw_background_locked(currentIcon);
211         draw_progress_locked();
212     } else {
213         gr_color(0, 0, 0, 255);
214         gr_clear();
215 
216         int y = 0;
217         int i = 0;
218         if (show_menu) {
219             SetColor(HEADER);
220 
221             for (; i < menu_top + menu_items; ++i) {
222                 if (i == menu_top) SetColor(MENU);
223 
224                 if (i == menu_top + menu_sel) {
225                     // draw the highlight bar
226                     SetColor(MENU_SEL_BG);
227                     gr_fill(0, y-2, gr_fb_width(), y+char_height+2);
228                     // white text of selected item
229                     SetColor(MENU_SEL_FG);
230                     if (menu[i][0]) gr_text(4, y, menu[i], 1);
231                     SetColor(MENU);
232                 } else {
233                     if (menu[i][0]) gr_text(4, y, menu[i], i < menu_top);
234                 }
235                 y += char_height+4;
236             }
237             SetColor(MENU);
238             y += 4;
239             gr_fill(0, y, gr_fb_width(), y+2);
240             y += 4;
241             ++i;
242         }
243 
244         SetColor(LOG);
245 
246         // display from the bottom up, until we hit the top of the
247         // screen, the bottom of the menu, or we've displayed the
248         // entire text buffer.
249         int ty;
250         int row = (text_top+text_rows-1) % text_rows;
251         for (int ty = gr_fb_height() - char_height, count = 0;
252              ty > y+2 && count < text_rows;
253              ty -= char_height, ++count) {
254             gr_text(4, ty, text[row], 0);
255             --row;
256             if (row < 0) row = text_rows-1;
257         }
258     }
259 }
260 
261 // Redraw everything on the screen and flip the screen (make it visible).
262 // Should only be called with updateMutex locked.
update_screen_locked()263 void ScreenRecoveryUI::update_screen_locked()
264 {
265     draw_screen_locked();
266     gr_flip();
267 }
268 
269 // Updates only the progress bar, if possible, otherwise redraws the screen.
270 // Should only be called with updateMutex locked.
update_progress_locked()271 void ScreenRecoveryUI::update_progress_locked()
272 {
273     if (show_text || !pagesIdentical) {
274         draw_screen_locked();    // Must redraw the whole screen
275         pagesIdentical = true;
276     } else {
277         draw_progress_locked();  // Draw only the progress bar and overlays
278     }
279     gr_flip();
280 }
281 
282 // Keeps the progress bar updated, even when the process is otherwise busy.
progress_thread(void * cookie)283 void* ScreenRecoveryUI::progress_thread(void *cookie) {
284     self->progress_loop();
285     return NULL;
286 }
287 
progress_loop()288 void ScreenRecoveryUI::progress_loop() {
289     double interval = 1.0 / animation_fps;
290     for (;;) {
291         double start = now();
292         pthread_mutex_lock(&updateMutex);
293 
294         int redraw = 0;
295 
296         // update the installation animation, if active
297         // skip this if we have a text overlay (too expensive to update)
298         if ((currentIcon == INSTALLING_UPDATE || currentIcon == ERASING) &&
299             installing_frames > 0 && !show_text) {
300             installingFrame = (installingFrame + 1) % installing_frames;
301             redraw = 1;
302         }
303 
304         // move the progress bar forward on timed intervals, if configured
305         int duration = progressScopeDuration;
306         if (progressBarType == DETERMINATE && duration > 0) {
307             double elapsed = now() - progressScopeTime;
308             float p = 1.0 * elapsed / duration;
309             if (p > 1.0) p = 1.0;
310             if (p > progress) {
311                 progress = p;
312                 redraw = 1;
313             }
314         }
315 
316         if (redraw) update_progress_locked();
317 
318         pthread_mutex_unlock(&updateMutex);
319         double end = now();
320         // minimum of 20ms delay between frames
321         double delay = interval - (end-start);
322         if (delay < 0.02) delay = 0.02;
323         usleep((long)(delay * 1000000));
324     }
325 }
326 
LoadBitmap(const char * filename,gr_surface * surface)327 void ScreenRecoveryUI::LoadBitmap(const char* filename, gr_surface* surface) {
328     int result = res_create_display_surface(filename, surface);
329     if (result < 0) {
330         LOGE("missing bitmap %s\n(Code %d)\n", filename, result);
331     }
332 }
333 
LoadBitmapArray(const char * filename,int * frames,gr_surface ** surface)334 void ScreenRecoveryUI::LoadBitmapArray(const char* filename, int* frames, gr_surface** surface) {
335     int result = res_create_multi_display_surface(filename, frames, surface);
336     if (result < 0) {
337         LOGE("missing bitmap %s\n(Code %d)\n", filename, result);
338     }
339 }
340 
LoadLocalizedBitmap(const char * filename,gr_surface * surface)341 void ScreenRecoveryUI::LoadLocalizedBitmap(const char* filename, gr_surface* surface) {
342     int result = res_create_localized_alpha_surface(filename, locale, surface);
343     if (result < 0) {
344         LOGE("missing bitmap %s\n(Code %d)\n", filename, result);
345     }
346 }
347 
Init()348 void ScreenRecoveryUI::Init()
349 {
350     gr_init();
351 
352     gr_font_size(&char_width, &char_height);
353 
354     text_col = text_row = 0;
355     text_rows = gr_fb_height() / char_height;
356     if (text_rows > kMaxRows) text_rows = kMaxRows;
357     text_top = 1;
358 
359     text_cols = gr_fb_width() / char_width;
360     if (text_cols > kMaxCols - 1) text_cols = kMaxCols - 1;
361 
362     backgroundIcon[NONE] = NULL;
363     LoadBitmapArray("icon_installing", &installing_frames, &installation);
364     backgroundIcon[INSTALLING_UPDATE] = installing_frames ? installation[0] : NULL;
365     backgroundIcon[ERASING] = backgroundIcon[INSTALLING_UPDATE];
366     LoadBitmap("icon_error", &backgroundIcon[ERROR]);
367     backgroundIcon[NO_COMMAND] = backgroundIcon[ERROR];
368 
369     LoadBitmap("progress_empty", &progressBarEmpty);
370     LoadBitmap("progress_fill", &progressBarFill);
371     LoadBitmap("stage_empty", &stageMarkerEmpty);
372     LoadBitmap("stage_fill", &stageMarkerFill);
373 
374     LoadLocalizedBitmap("installing_text", &backgroundText[INSTALLING_UPDATE]);
375     LoadLocalizedBitmap("erasing_text", &backgroundText[ERASING]);
376     LoadLocalizedBitmap("no_command_text", &backgroundText[NO_COMMAND]);
377     LoadLocalizedBitmap("error_text", &backgroundText[ERROR]);
378 
379     pthread_create(&progress_t, NULL, progress_thread, NULL);
380 
381     RecoveryUI::Init();
382 }
383 
SetLocale(const char * new_locale)384 void ScreenRecoveryUI::SetLocale(const char* new_locale) {
385     if (new_locale) {
386         this->locale = new_locale;
387         char* lang = strdup(locale);
388         for (char* p = lang; *p; ++p) {
389             if (*p == '_') {
390                 *p = '\0';
391                 break;
392             }
393         }
394 
395         // A bit cheesy: keep an explicit list of supported languages
396         // that are RTL.
397         if (strcmp(lang, "ar") == 0 ||   // Arabic
398             strcmp(lang, "fa") == 0 ||   // Persian (Farsi)
399             strcmp(lang, "he") == 0 ||   // Hebrew (new language code)
400             strcmp(lang, "iw") == 0 ||   // Hebrew (old language code)
401             strcmp(lang, "ur") == 0) {   // Urdu
402             rtl_locale = true;
403         }
404         free(lang);
405     } else {
406         new_locale = NULL;
407     }
408 }
409 
SetBackground(Icon icon)410 void ScreenRecoveryUI::SetBackground(Icon icon)
411 {
412     pthread_mutex_lock(&updateMutex);
413 
414     currentIcon = icon;
415     update_screen_locked();
416 
417     pthread_mutex_unlock(&updateMutex);
418 }
419 
SetProgressType(ProgressType type)420 void ScreenRecoveryUI::SetProgressType(ProgressType type)
421 {
422     pthread_mutex_lock(&updateMutex);
423     if (progressBarType != type) {
424         progressBarType = type;
425     }
426     progressScopeStart = 0;
427     progressScopeSize = 0;
428     progress = 0;
429     update_progress_locked();
430     pthread_mutex_unlock(&updateMutex);
431 }
432 
ShowProgress(float portion,float seconds)433 void ScreenRecoveryUI::ShowProgress(float portion, float seconds)
434 {
435     pthread_mutex_lock(&updateMutex);
436     progressBarType = DETERMINATE;
437     progressScopeStart += progressScopeSize;
438     progressScopeSize = portion;
439     progressScopeTime = now();
440     progressScopeDuration = seconds;
441     progress = 0;
442     update_progress_locked();
443     pthread_mutex_unlock(&updateMutex);
444 }
445 
SetProgress(float fraction)446 void ScreenRecoveryUI::SetProgress(float fraction)
447 {
448     pthread_mutex_lock(&updateMutex);
449     if (fraction < 0.0) fraction = 0.0;
450     if (fraction > 1.0) fraction = 1.0;
451     if (progressBarType == DETERMINATE && fraction > progress) {
452         // Skip updates that aren't visibly different.
453         int width = gr_get_width(progressBarEmpty);
454         float scale = width * progressScopeSize;
455         if ((int) (progress * scale) != (int) (fraction * scale)) {
456             progress = fraction;
457             update_progress_locked();
458         }
459     }
460     pthread_mutex_unlock(&updateMutex);
461 }
462 
SetStage(int current,int max)463 void ScreenRecoveryUI::SetStage(int current, int max) {
464     pthread_mutex_lock(&updateMutex);
465     stage = current;
466     max_stage = max;
467     pthread_mutex_unlock(&updateMutex);
468 }
469 
Print(const char * fmt,...)470 void ScreenRecoveryUI::Print(const char *fmt, ...)
471 {
472     char buf[256];
473     va_list ap;
474     va_start(ap, fmt);
475     vsnprintf(buf, 256, fmt, ap);
476     va_end(ap);
477 
478     fputs(buf, stdout);
479 
480     // This can get called before ui_init(), so be careful.
481     pthread_mutex_lock(&updateMutex);
482     if (text_rows > 0 && text_cols > 0) {
483         char *ptr;
484         for (ptr = buf; *ptr != '\0'; ++ptr) {
485             if (*ptr == '\n' || text_col >= text_cols) {
486                 text[text_row][text_col] = '\0';
487                 text_col = 0;
488                 text_row = (text_row + 1) % text_rows;
489                 if (text_row == text_top) text_top = (text_top + 1) % text_rows;
490             }
491             if (*ptr != '\n') text[text_row][text_col++] = *ptr;
492         }
493         text[text_row][text_col] = '\0';
494         update_screen_locked();
495     }
496     pthread_mutex_unlock(&updateMutex);
497 }
498 
StartMenu(const char * const * headers,const char * const * items,int initial_selection)499 void ScreenRecoveryUI::StartMenu(const char* const * headers, const char* const * items,
500                                  int initial_selection) {
501     int i;
502     pthread_mutex_lock(&updateMutex);
503     if (text_rows > 0 && text_cols > 0) {
504         for (i = 0; i < text_rows; ++i) {
505             if (headers[i] == NULL) break;
506             strncpy(menu[i], headers[i], text_cols-1);
507             menu[i][text_cols-1] = '\0';
508         }
509         menu_top = i;
510         for (; i < text_rows; ++i) {
511             if (items[i-menu_top] == NULL) break;
512             strncpy(menu[i], items[i-menu_top], text_cols-1);
513             menu[i][text_cols-1] = '\0';
514         }
515         menu_items = i - menu_top;
516         show_menu = 1;
517         menu_sel = initial_selection;
518         update_screen_locked();
519     }
520     pthread_mutex_unlock(&updateMutex);
521 }
522 
SelectMenu(int sel)523 int ScreenRecoveryUI::SelectMenu(int sel) {
524     int old_sel;
525     pthread_mutex_lock(&updateMutex);
526     if (show_menu > 0) {
527         old_sel = menu_sel;
528         menu_sel = sel;
529         if (menu_sel < 0) menu_sel = 0;
530         if (menu_sel >= menu_items) menu_sel = menu_items-1;
531         sel = menu_sel;
532         if (menu_sel != old_sel) update_screen_locked();
533     }
534     pthread_mutex_unlock(&updateMutex);
535     return sel;
536 }
537 
EndMenu()538 void ScreenRecoveryUI::EndMenu() {
539     int i;
540     pthread_mutex_lock(&updateMutex);
541     if (show_menu > 0 && text_rows > 0 && text_cols > 0) {
542         show_menu = 0;
543         update_screen_locked();
544     }
545     pthread_mutex_unlock(&updateMutex);
546 }
547 
IsTextVisible()548 bool ScreenRecoveryUI::IsTextVisible()
549 {
550     pthread_mutex_lock(&updateMutex);
551     int visible = show_text;
552     pthread_mutex_unlock(&updateMutex);
553     return visible;
554 }
555 
WasTextEverVisible()556 bool ScreenRecoveryUI::WasTextEverVisible()
557 {
558     pthread_mutex_lock(&updateMutex);
559     int ever_visible = show_text_ever;
560     pthread_mutex_unlock(&updateMutex);
561     return ever_visible;
562 }
563 
ShowText(bool visible)564 void ScreenRecoveryUI::ShowText(bool visible)
565 {
566     pthread_mutex_lock(&updateMutex);
567     show_text = visible;
568     if (show_text) show_text_ever = 1;
569     update_screen_locked();
570     pthread_mutex_unlock(&updateMutex);
571 }
572 
Redraw()573 void ScreenRecoveryUI::Redraw()
574 {
575     pthread_mutex_lock(&updateMutex);
576     update_screen_locked();
577     pthread_mutex_unlock(&updateMutex);
578 }
579