Merge "recovery: Move a few int to bool."

  return menu_position < 0 ? NO_ACTION : MENU_ACTIONS[menu_position];

}

int Device::HandleMenuKey(int key, int visible) {

int Device::HandleMenuKey(int key, bool visible) {

  if (!visible) {

    return kNoAction;

  }

  explicit Device(RecoveryUI* ui) : ui_(ui) {}

  virtual ~Device() {}

    // Called to obtain the UI object that should be used to display

    // the recovery user interface for this device.  You should not

    // have called Init() on the UI object already, the caller will do

  // Called to obtain the UI object that should be used to display the recovery user interface for

  // this device. You should not have called Init() on the UI object already, the caller will do

  // that after this method returns.

    virtual RecoveryUI* GetUI() { return ui_; }

  virtual RecoveryUI* GetUI() {

    return ui_;

  }

    // Called when recovery starts up (after the UI has been obtained

    // and initialized and after the arguments have been parsed, but

    // before anything else).

  // Called when recovery starts up (after the UI has been obtained and initialized and after the

  // arguments have been parsed, but before anything else).

  virtual void StartRecovery() {};

    // Called from the main thread when recovery is at the main menu

    // and waiting for input, and a key is pressed.  (Note that "at"

    // the main menu does not necessarily mean the menu is visible;

    // recovery will be at the main menu with it invisible after an

    // unsuccessful operation [ie OTA package failure], or if recovery

    // is started with no command.)

  // Called from the main thread when recovery is at the main menu and waiting for input, and a key

  // is pressed. (Note that "at" the main menu does not necessarily mean the menu is visible;

  // recovery will be at the main menu with it invisible after an unsuccessful operation [ie OTA

  // package failure], or if recovery is started with no command.)

  //

    // key is the code of the key just pressed.  (You can call

    // IsKeyPressed() on the RecoveryUI object you returned from GetUI

    // if you want to find out if other keys are held down.)

  // 'key' is the code of the key just pressed. (You can call IsKeyPressed() on the RecoveryUI

  // object you returned from GetUI if you want to find out if other keys are held down.)

  //

    // visible is true if the menu is visible.

  // 'visible' is true if the menu is visible.

  //

    // Return one of the defined constants below in order to:

  // Returns one of the defined constants below in order to:

  //

  //   - move the menu highlight (kHighlight{Up,Down})

  //   - invoke the highlighted item (kInvokeItem)

  //   - do nothing (kNoAction)

  //   - invoke a specific action (a menu position: any non-negative number)

    virtual int HandleMenuKey(int key, int visible);

  virtual int HandleMenuKey(int key, bool visible);

  enum BuiltinAction {

    NO_ACTION = 0,

    RUN_GRAPHICS_TEST = 11,

  };

    // Return the list of menu items (an array of strings,

    // NULL-terminated).  The menu_position passed to InvokeMenuItem

    // will correspond to the indexes into this array.

  // Return the list of menu items (an array of strings, NULL-terminated). The menu_position passed

  // to InvokeMenuItem will correspond to the indexes into this array.

  virtual const char* const* GetMenuItems();

    // Perform a recovery action selected from the menu.

    // 'menu_position' will be the item number of the selected menu

    // item, or a non-negative number returned from

    // device_handle_key().  The menu will be hidden when this is

    // called; implementations can call ui_print() to print

    // information to the screen.  If the menu position is one of the

    // builtin actions, you can just return the corresponding enum

    // value.  If it is an action specific to your device, you

    // actually perform it here and return NO_ACTION.

  // Perform a recovery action selected from the menu. 'menu_position' will be the item number of

  // the selected menu item, or a non-negative number returned from HandleMenuKey(). The menu will

  // be hidden when this is called; implementations can call ui_print() to print information to the

  // screen. If the menu position is one of the builtin actions, you can just return the

  // corresponding enum value. If it is an action specific to your device, you actually perform it

  // here and return NO_ACTION.

  virtual BuiltinAction InvokeMenuItem(int menu_position);

  static const int kNoAction = -1;

  static const int kHighlightDown = -3;

  static const int kInvokeItem = -4;

    // Called before and after we do a wipe data/factory reset operation,

    // either via a reboot from the main system with the --wipe_data flag,

    // or when the user boots into recovery image manually and selects the

    // option from the menu, to perform whatever device-specific wiping

    // actions are needed.

    // Return true on success; returning false from PreWipeData will prevent

    // the regular wipe, and returning false from PostWipeData will cause

    // the wipe to be considered a failure.

    virtual bool PreWipeData() { return true; }

    virtual bool PostWipeData() { return true; }

  // Called before and after we do a wipe data/factory reset operation, either via a reboot from the

  // main system with the --wipe_data flag, or when the user boots into recovery image manually and

  // selects the option from the menu, to perform whatever device-specific wiping actions as needed.

  // Returns true on success; returning false from PreWipeData will prevent the regular wipe, and

  // returning false from PostWipeData will cause the wipe to be considered a failure.

  virtual bool PreWipeData() {

    return true;

  }

  virtual bool PostWipeData() {

    return true;

  }

 private:

  RecoveryUI* ui_;

};

// The device-specific library must define this function (or the

// default one will be used, if there is no device-specific library).

// It returns the Device object that recovery should use.

// The device-specific library must define this function (or the default one will be used, if there

// is no device-specific library). It returns the Device object that recovery should use.

Device* make_device();

#endif  // _DEVICE_H

  return (result == 0);

}

static int

get_menu_selection(const char* const * headers, const char* const * items,

                   int menu_only, int initial_selection, Device* device) {

    // throw away keys pressed previously, so user doesn't

    // accidentally trigger menu items.

// Display a menu with the specified 'headers' and 'items'. Device specific HandleMenuKey() may

// return a positive number beyond the given range. Caller sets 'menu_only' to true to ensure only

// a menu item gets selected. 'initial_selection' controls the initial cursor location.

static int get_menu_selection(const char* const* headers, const char* const* items, bool menu_only,

                              int initial_selection, Device* device) {

  // Throw away keys pressed previously, so user doesn't accidentally trigger menu items.

  ui->FlushKeys();

  ui->StartMenu(headers, items, initial_selection);

  while (chosen_item < 0) {

    int key = ui->WaitKey();

        int visible = ui->IsTextVisible();

    if (key == -1) {  // ui_wait_key() timed out

      if (ui->WasTextEverVisible()) {

      }

    }

    bool visible = ui->IsTextVisible();

    int action = device->HandleMenuKey(key, visible);

    if (action < 0) {

  int chosen_item = 0;

  while (true) {

    chosen_item = get_menu_selection(headers, entries, 1, chosen_item, device);

    chosen_item = get_menu_selection(headers, entries, true, chosen_item, device);

    const std::string& item = zips[chosen_item];

    if (chosen_item == 0) {

    const char* headers[] = { question1, question2, NULL };

    const char* items[] = { " No", " Yes", NULL };

    int chosen_item = get_menu_selection(headers, items, 1, 0, device);

    int chosen_item = get_menu_selection(headers, items, true, 0, device);

    return (chosen_item == 1);

}

    NULL

  };

  for (;;) {

        int chosen_item = get_menu_selection(headers, items, 1, 0, device);

    int chosen_item = get_menu_selection(headers, items, true, 0, device);

    if (chosen_item != 1) {

      return true;  // Just reboot, no wipe; not a failure, user asked for it

    }

  int chosen_item = 0;

  while (true) {

    chosen_item = get_menu_selection(headers, menu_entries.data(), 1, chosen_item, device);

    chosen_item = get_menu_selection(headers, menu_entries.data(), true, chosen_item, device);

    if (entries[chosen_item] == "Back") break;

    ui->ShowFile(entries[chosen_item].c_str());

        }

        ui->SetProgressType(RecoveryUI::EMPTY);

        int chosen_item = get_menu_selection(nullptr, device->GetMenuItems(), 0, 0, device);

        int chosen_item = get_menu_selection(nullptr, device->GetMenuItems(), false, 0, device);

        // device-specific code may take some action here.  It may

        // return one of the core actions handled in the switch