screen_ui.h

   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 #ifndef RECOVERY_SCREEN_UI_H
  18 #define RECOVERY_SCREEN_UI_H
  19
  20 #include <pthread.h>
  21 #include <stdio.h>
  22
  23 #include <string>
  24 #include <vector>
  25
  26 #include "ui.h"
  27
  28 // From minui/minui.h.
  29 struct GRSurface;
  30
  31 // Implementation of RecoveryUI appropriate for devices with a screen
  32 // (shows an icon + a progress bar, text logging, menu, etc.)
  33 class ScreenRecoveryUI : public RecoveryUI {
  34  public:
  35   enum UIElement {
  36     HEADER,
  37     MENU,
  38     MENU_SEL_BG,
  39     MENU_SEL_BG_ACTIVE,
  40     MENU_SEL_FG,
  41     LOG,
  42     TEXT_FILL,
  43     INFO
  44   };
  45
  46   ScreenRecoveryUI();
  47
  48   bool Init(const std::string& locale) override;
  49
  50   // overall recovery state ("background image")
  51   void SetBackground(Icon icon) override;
  52   void SetSystemUpdateText(bool security_update) override;
  53
  54   // progress indicator
  55   void SetProgressType(ProgressType type) override;
  56   void ShowProgress(float portion, float seconds) override;
  57   void SetProgress(float fraction) override;
  58
  59   void SetStage(int current, int max) override;
  60
  61   // text log
  62   void ShowText(bool visible) override;
  63   bool IsTextVisible() override;
  64   bool WasTextEverVisible() override;
  65
  66   // printing messages
  67   void Print(const char* fmt, ...) override __printflike(2, 3);
  68   void PrintOnScreenOnly(const char* fmt, ...) override __printflike(2, 3);
  69   void ShowFile(const char* filename) override;
  70
  71   // menu display
  72   void StartMenu(const char* const* headers, const char* const* items,
  73                  int initial_selection) override;
  74   int SelectMenu(int sel) override;
  75   void EndMenu() override;
  76
  77   void KeyLongPress(int) override;
  78
  79   void Redraw();
  80
  81   void SetColor(UIElement e) const;
  82
  83   // Check the background text image. Use volume up/down button to cycle through the locales
  84   // embedded in the png file, and power button to go back to recovery main menu.
  85   void CheckBackgroundTextImages(const std::string& saved_locale);
  86
  87  protected:
  88   // The margin that we don't want to use for showing texts (e.g. round screen, or screen with
  89   // rounded corners).
  90   const int kMarginWidth;
  91   const int kMarginHeight;
  92
  93   // Number of frames per sec (default: 30) for both parts of the animation.
  94   const int kAnimationFps;
  95
  96   // The scale factor from dp to pixels. 1.0 for mdpi, 4.0 for xxxhdpi.
  97   const float kDensity;
  98
  99   virtual bool InitTextParams();
 100
 101   virtual void draw_background_locked();
 102   virtual void draw_foreground_locked();
 103   virtual void draw_screen_locked();
 104   virtual void update_screen_locked();
 105   virtual void update_progress_locked();
 106
 107   GRSurface* GetCurrentFrame() const;
 108   GRSurface* GetCurrentText() const;
 109
 110   static void* ProgressThreadStartRoutine(void* data);
 111   void ProgressThreadLoop();
 112
 113   virtual void ShowFile(FILE*);
 114   virtual void PrintV(const char*, bool, va_list);
 115   void PutChar(char);
 116   void ClearText();
 117
 118   void LoadAnimation();
 119   void LoadBitmap(const char* filename, GRSurface** surface);
 120   void LoadLocalizedBitmap(const char* filename, GRSurface** surface);
 121
 122   int PixelsFromDp(int dp) const;
 123   virtual int GetAnimationBaseline() const;
 124   virtual int GetProgressBaseline() const;
 125   virtual int GetTextBaseline() const;
 126
 127   // Returns pixel width of draw buffer.
 128   virtual int ScreenWidth() const;
 129   // Returns pixel height of draw buffer.
 130   virtual int ScreenHeight() const;
 131
 132   // Draws a highlight bar at (x, y) - (x + width, y + height).
 133   virtual void DrawHighlightBar(int x, int y, int width, int height) const;
 134   // Draws a horizontal rule at Y. Returns the offset it should be moving along Y-axis.
 135   virtual int DrawHorizontalRule(int y) const;
 136   // Draws a line of text. Returns the offset it should be moving along Y-axis.
 137   virtual int DrawTextLine(int x, int y, const char* line, bool bold) const;
 138   // Draws surface portion (sx, sy, w, h) at screen location (dx, dy).
 139   virtual void DrawSurface(GRSurface* surface, int sx, int sy, int w, int h, int dx, int dy) const;
 140   // Draws rectangle at (x, y) - (x + w, y + h).
 141   virtual void DrawFill(int x, int y, int w, int h) const;
 142   // Draws given surface (surface->pixel_bytes = 1) as text at (x, y).
 143   virtual void DrawTextIcon(int x, int y, GRSurface* surface) const;
 144   // Draws multiple text lines. Returns the offset it should be moving along Y-axis.
 145   int DrawTextLines(int x, int y, const char* const* lines) const;
 146   // Similar to DrawTextLines() to draw multiple text lines, but additionally wraps long lines.
 147   // Returns the offset it should be moving along Y-axis.
 148   int DrawWrappedTextLines(int x, int y, const char* const* lines) const;
 149
 150   Icon currentIcon;
 151
 152   // The layout to use.
 153   int layout_;
 154
 155   GRSurface* error_icon;
 156
 157   GRSurface* erasing_text;
 158   GRSurface* error_text;
 159   GRSurface* installing_text;
 160   GRSurface* no_command_text;
 161
 162   GRSurface** introFrames;
 163   GRSurface** loopFrames;
 164
 165   GRSurface* progressBarEmpty;
 166   GRSurface* progressBarFill;
 167   GRSurface* stageMarkerEmpty;
 168   GRSurface* stageMarkerFill;
 169
 170   ProgressType progressBarType;
 171
 172   float progressScopeStart, progressScopeSize, progress;
 173   double progressScopeTime, progressScopeDuration;
 174
 175   // true when both graphics pages are the same (except for the progress bar).
 176   bool pagesIdentical;
 177
 178   size_t text_cols_, text_rows_;
 179
 180   // Log text overlay, displayed when a magic key is pressed.
 181   char** text_;
 182   size_t text_col_, text_row_;
 183
 184   bool show_text;
 185   bool show_text_ever;  // has show_text ever been true?
 186
 187   std::vector<std::string> menu_;
 188   const char* const* menu_headers_;
 189   bool show_menu;
 190   int menu_items, menu_sel;
 191
 192   // An alternate text screen, swapped with 'text_' when we're viewing a log file.
 193   char** file_viewer_text_;
 194
 195   pthread_t progress_thread_;
 196
 197   // Number of intro frames and loop frames in the animation.
 198   size_t intro_frames;
 199   size_t loop_frames;
 200
 201   size_t current_frame;
 202   bool intro_done;
 203
 204   int stage, max_stage;
 205
 206   int char_width_;
 207   int char_height_;
 208
 209   // The locale that's used to show the rendered texts.
 210   std::string locale_;
 211   bool rtl_locale_;
 212
 213   pthread_mutex_t updateMutex;
 214
 215  private:
 216   void SetLocale(const std::string&);
 217
 218   // Display the background texts for "erasing", "error", "no_command" and "installing" for the
 219   // selected locale.
 220   void SelectAndShowBackgroundText(const std::vector<std::string>& locales_entries, size_t sel);
 221 };
 222
 223 #endif  // RECOVERY_UI_H