Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 0f18ef7b authored by Abhishek Nigam's avatar Abhishek Nigam Committed by Automerger Merge Worker
Browse files

Merge "Wear Recovery UI: Adjust for round screens" am: a7d1d025 am: 2b4e47be 

Original change: https://android-review.googlesource.com/c/platform/bootable/recovery/+/2623222



Change-Id: Ia77ece295576cd3c5542b6a5200cd1e185d67b1c
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents fcd9af03 2b4e47be

fastboot/fastboot.cpp

+28 −4
Original line number Diff line number Diff line
@@ -36,10 +36,8 @@ static const std::vector<std::pair<std::string, Device::BuiltinAction>> kFastboo 
  { "Power off", Device::SHUTDOWN_FROM_FASTBOOT },

};



Device::BuiltinAction StartFastboot(Device* device, const std::vector<std::string>& /* args */) {

  RecoveryUI* ui = device->GetUI();



  std::vector<std::string> title_lines = { "Android Fastboot" };

void FillDefaultFastbootLines(std::vector<std::string>& title_lines) {

  title_lines.push_back("Android Fastboot");

  title_lines.push_back("Product name - " + android::base::GetProperty("ro.product.device", ""));

  title_lines.push_back("Bootloader version - " + android::base::GetProperty("ro.bootloader", ""));

  title_lines.push_back("Baseband version - " +
@@ -48,6 +46,32 @@ Device::BuiltinAction StartFastboot(Device* device, const std::vector<std::strin 
  title_lines.push_back(std::string("Secure boot - ") +

                        ((android::base::GetProperty("ro.secure", "") == "1") ? "yes" : "no"));

  title_lines.push_back("HW version - " + android::base::GetProperty("ro.revision", ""));

}



void FillWearableFastbootLines(std::vector<std::string>& title_lines) {

  title_lines.push_back("Android Fastboot");

  title_lines.push_back(android::base::GetProperty("ro.product.device", "") + " - " +

                        android::base::GetProperty("ro.revision", ""));

  title_lines.push_back(android::base::GetProperty("ro.bootloader", ""));



  const size_t max_baseband_len = 24;

  const std::string& baseband = android::base::GetProperty("ro.build.expect.baseband", "");

  title_lines.push_back(baseband.length() > max_baseband_len

                            ? baseband.substr(0, max_baseband_len - 3) + "..."

                            : baseband);



  title_lines.push_back("Serial #: " + android::base::GetProperty("ro.serialno", ""));

}



Device::BuiltinAction StartFastboot(Device* device, const std::vector<std::string>& /* args */) {

  RecoveryUI* ui = device->GetUI();

  std::vector<std::string> title_lines;



  if (ui->IsWearable()) {

    FillWearableFastbootLines(title_lines);

  } else {

    FillDefaultFastbootLines(title_lines);

  }



  ui->ResetKeyInterruptStatus();

  ui->SetTitle(title_lines);

recovery_ui/include/recovery_ui/screen_ui.h

+2 −1
Original line number Diff line number Diff line
@@ -309,7 +309,7 @@ class ScreenRecoveryUI : public RecoveryUI, public DrawInterface { 
  void PutChar(char);

  void ClearText();



  void LoadAnimation();

  virtual void LoadAnimation();

  std::unique_ptr<GRSurface> LoadBitmap(const std::string& filename);

  std::unique_ptr<GRSurface> LoadLocalizedBitmap(const std::string& filename);
@@ -416,6 +416,7 @@ class ScreenRecoveryUI : public RecoveryUI, public DrawInterface { 
  // Display the background texts for "erasing", "error", "no_command" and "installing" for the

  // selected locale.

  void SelectAndShowBackgroundText(const std::vector<std::string>& locales_entries, size_t sel);



};



#endif  // RECOVERY_UI_H

recovery_ui/include/recovery_ui/ui.h

+4 −0
Original line number Diff line number Diff line
@@ -177,6 +177,10 @@ class RecoveryUI { 
      const std::vector<std::string>& backup_headers, const std::vector<std::string>& backup_items,

      const std::function<int(int, bool)>& key_handler) = 0;



  virtual bool IsWearable() {

    return false;

  }



  // Set whether or not the fastbootd logo is displayed.

  void SetEnableFastbootdLogo(bool enable) {

    fastbootd_logo_enabled_ = enable;

recovery_ui/include/recovery_ui/wear_ui.h

+17 −0
Original line number Diff line number Diff line
@@ -29,6 +29,10 @@ class WearRecoveryUI : public ScreenRecoveryUI { 
  void SetStage(int current, int max) override;



 protected:

  // curved progress bar frames for round screens

  std::vector<std::unique_ptr<GRSurface>> progress_frames_;

  std::vector<std::unique_ptr<GRSurface>> rtl_progress_frames_;



  // progress bar vertical position, it's centered horizontally

  const int progress_bar_baseline_;
@@ -36,17 +40,30 @@ class WearRecoveryUI : public ScreenRecoveryUI { 
  // Recovery, build id and etc) and the bottom lines that may otherwise go out of the screen.

  const int menu_unusable_rows_;



  const bool is_screen_circle_;



  std::unique_ptr<Menu> CreateMenu(const std::vector<std::string>& text_headers,

                                   const std::vector<std::string>& text_items,

                                   size_t initial_selection) const override;



  int GetProgressBaseline() const override;



  int GetTextBaseline() const override;



  void update_progress_locked() override;



  void LoadAnimation() override;



  bool IsWearable() override;



  void SetProgress(float fraction) override;



 private:

  void draw_background_locked() override;

  void draw_screen_locked() override;

  void draw_circle_foreground_locked();

  size_t GetProgressFrameIndex(float fraction) const;



};



#endif  // RECOVERY_WEAR_UI_H

recovery_ui/wear_ui.cpp

+140 −22
Original line number Diff line number Diff line
@@ -14,6 +14,7 @@ 
 * limitations under the License.

 */



#include "otautil/paths.h"

#include "recovery_ui/wear_ui.h"



#include <string.h>
@@ -23,24 +24,25 @@ 


#include <android-base/properties.h>

#include <android-base/strings.h>



#include <minui/minui.h>



constexpr int kDefaultProgressBarBaseline = 259;

constexpr int kDefaultMenuUnusableRows = 9;

constexpr int kProgressBarVerticalOffsetDp = 72;

constexpr bool kDefaultIsScreenCircle = true;



WearRecoveryUI::WearRecoveryUI()

    : ScreenRecoveryUI(true),

      progress_bar_baseline_(android::base::GetIntProperty("ro.recovery.ui.progress_bar_baseline",

                                                           kDefaultProgressBarBaseline)),

      menu_unusable_rows_(android::base::GetIntProperty("ro.recovery.ui.menu_unusable_rows",

                                                        kDefaultMenuUnusableRows)) {

                                                        kDefaultMenuUnusableRows)),

      is_screen_circle_(android::base::GetBoolProperty("ro.recovery.ui.is_screen_circle",

                                                             kDefaultIsScreenCircle)) {

  // TODO: menu_unusable_rows_ should be computed based on the lines in draw_screen_locked().



  touch_screen_allowed_ = true;

}



int WearRecoveryUI::GetProgressBaseline() const {

  return progress_bar_baseline_;

  SetEnableFastbootdLogo(false); // logo not required on Wear

}



// Draw background frame on the screen.  Does not flip pages.
@@ -51,30 +53,38 @@ void WearRecoveryUI::draw_background_locked() { 
  gr_color(0, 0, 0, 255);

  gr_fill(0, 0, gr_fb_width(), gr_fb_height());



  if (current_icon_ != NONE) {

  if (current_icon_ == ERROR) {

    const auto& frame = GetCurrentFrame();

    int frame_width = gr_get_width(frame);

    int frame_height = gr_get_height(frame);

    int frame_x = (gr_fb_width() - frame_width) / 2;

    int frame_y = (gr_fb_height() - frame_height) / 2;

    gr_blit(frame, 0, 0, frame_width, frame_height, frame_x, frame_y);

  }



    // Draw recovery text on screen above progress bar.

  if (current_icon_ != NONE) {

    // Draw recovery text on screen centered

    const auto& text = GetCurrentText();

    int text_x = (ScreenWidth() - gr_get_width(text)) / 2;

    int text_y = GetProgressBaseline() - gr_get_height(text) - 10;

    int text_y = (ScreenHeight() - gr_get_height(text)) / 2;

    gr_color(255, 255, 255, 255);

    gr_texticon(text_x, text_y, text);

  }

}



void WearRecoveryUI::draw_screen_locked() {

  draw_background_locked();

  if (!show_text) {

    draw_foreground_locked();

    draw_background_locked();

    if (is_screen_circle_) {

        draw_circle_foreground_locked();

    } else {

        draw_foreground_locked();

    }

    return;

  }



  SetColor(UIElement::TEXT_FILL);

    gr_fill(0, 0, gr_fb_width(), gr_fb_height());

  gr_clear();



  // clang-format off

  static std::vector<std::string> SWIPE_HELP = {
@@ -85,6 +95,110 @@ void WearRecoveryUI::draw_screen_locked() { 
  // clang-format on

  draw_menu_and_text_buffer_locked(SWIPE_HELP);

}



void WearRecoveryUI::draw_circle_foreground_locked() {

    if (current_icon_ != NONE) {

        const auto& frame = GetCurrentFrame();

        int frame_width = gr_get_width(frame);

        int frame_height = gr_get_height(frame);

        int frame_x = (ScreenWidth() - frame_width) / 2;

        int frame_y = GetAnimationBaseline();

        DrawSurface(frame, 0, 0, frame_width, frame_height, frame_x, frame_y);

      }



    if (progressBarType == DETERMINATE) {

        const auto& first_progress_frame = rtl_locale_ ? rtl_progress_frames_[0].get()

                                                        :progress_frames_[0].get();

        int width = gr_get_width(first_progress_frame);

        int height = gr_get_height(first_progress_frame);



        int progress_x = (ScreenWidth() - width) / 2;

        int progress_y = GetProgressBaseline();



        const auto index = GetProgressFrameIndex(progress);

        const auto& frame = rtl_locale_ ? rtl_progress_frames_[index].get()

                                        : progress_frames_[index].get();



        DrawSurface(frame, 0, 0, width, height, progress_x, progress_y);

    }

}



void WearRecoveryUI::LoadAnimation() {

  ScreenRecoveryUI::LoadAnimation();

  std::unique_ptr<DIR, decltype(&closedir)> dir(opendir(Paths::Get().resource_dir().c_str()),

                                                closedir);

  dirent* de;

  std::vector<std::string> progress_frame_names;

  std::vector<std::string> rtl_progress_frame_names;



  if(dir.get() == nullptr) abort();



  while ((de = readdir(dir.get())) != nullptr) {

    int value, num_chars;

    if (sscanf(de->d_name, "progress%d%n.png", &value, &num_chars) == 1) {

      progress_frame_names.emplace_back(de->d_name, num_chars);

    } else if (sscanf(de->d_name, "rtl_progress%d%n.png", &value, &num_chars) == 1) {

      rtl_progress_frame_names.emplace_back(de->d_name, num_chars);

    }

  }



  size_t progress_frames = progress_frame_names.size();

  size_t rtl_progress_frames = rtl_progress_frame_names.size();



  // You must have an animation.

  if (progress_frames == 0 || rtl_progress_frames == 0) abort();



  std::sort(progress_frame_names.begin(), progress_frame_names.end());

  std::sort(rtl_progress_frame_names.begin(), rtl_progress_frame_names.end());



  progress_frames_.clear();

  progress_frames_.reserve(progress_frames);

  for (const auto& frame_name : progress_frame_names) {

    progress_frames_.emplace_back(LoadBitmap(frame_name));

  }



  rtl_progress_frames_.clear();

    rtl_progress_frames_.reserve(rtl_progress_frames);

    for (const auto& frame_name : rtl_progress_frame_names) {

      rtl_progress_frames_.emplace_back(LoadBitmap(frame_name));

  }

}



void WearRecoveryUI::SetProgress(float fraction) {

    if (is_screen_circle_) {

       std::lock_guard<std::mutex> lg(updateMutex);

       if (fraction < 0.0) fraction = 0.0;

       if (fraction > 1.0) fraction = 1.0;

       if (progressBarType == DETERMINATE && fraction > progress) {

          // Skip updates that aren't visibly different.

          if (GetProgressFrameIndex(fraction) != GetProgressFrameIndex(progress)) {

              // circular display

              progress = fraction;

              update_progress_locked();

          }

       }

    } else {

        // rectangular display

        ScreenRecoveryUI::SetProgress(fraction);

    }

}



int WearRecoveryUI::GetProgressBaseline() const {

  int progress_height = gr_get_height(progress_frames_[0].get());

  return (ScreenHeight() - progress_height) / 2 + PixelsFromDp(kProgressBarVerticalOffsetDp);

}



int WearRecoveryUI::GetTextBaseline() const {

  if (is_screen_circle_) {

        return GetProgressBaseline() - PixelsFromDp(kProgressBarVerticalOffsetDp) -

                                    gr_get_height(installing_text_.get());

  } else {

       return ScreenRecoveryUI::GetTextBaseline();

  }

}



size_t WearRecoveryUI::GetProgressFrameIndex(float fraction) const {

  return static_cast<size_t>(fraction * (progress_frames_.size() - 1));

}



// TODO merge drawing routines with screen_ui
@@ -93,6 +207,10 @@ void WearRecoveryUI::update_progress_locked() { 
  gr_flip();

}



bool WearRecoveryUI::IsWearable() {

  return true;

}



void WearRecoveryUI::SetStage(int /* current */, int /* max */) {}



std::unique_ptr<Menu> WearRecoveryUI::CreateMenu(const std::vector<std::string>& text_headers,