Doug Zongker | daefc1d | 2011-10-31 09:34:15 -0700 | [diff] [blame] | 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_DEVICE_H |
| 18 | #define _RECOVERY_DEVICE_H |
| 19 | |
Tao Bao | 1fe1afe | 2018-05-01 15:56:05 -0700 | [diff] [blame] | 20 | #include <stddef.h> |
| 21 | |
Tao Bao | 551d2c3 | 2018-05-09 20:53:13 -0700 | [diff] [blame] | 22 | #include <memory> |
Tao Bao | 1fe1afe | 2018-05-01 15:56:05 -0700 | [diff] [blame] | 23 | #include <string> |
| 24 | #include <vector> |
| 25 | |
Tao Bao | c16fd8a | 2018-04-30 17:12:03 -0700 | [diff] [blame] | 26 | // Forward declaration to avoid including "ui.h". |
| 27 | class RecoveryUI; |
Doug Zongker | daefc1d | 2011-10-31 09:34:15 -0700 | [diff] [blame] | 28 | |
| 29 | class Device { |
Tao Bao | fc5499f | 2017-02-23 19:06:53 -0800 | [diff] [blame] | 30 | public: |
Tao Bao | 1fe1afe | 2018-05-01 15:56:05 -0700 | [diff] [blame] | 31 | static constexpr const int kNoAction = -1; |
| 32 | static constexpr const int kHighlightUp = -2; |
| 33 | static constexpr const int kHighlightDown = -3; |
| 34 | static constexpr const int kInvokeItem = -4; |
| 35 | |
Tao Bao | d9cb014 | 2019-04-23 11:46:25 -0700 | [diff] [blame] | 36 | // ENTER vs REBOOT: The latter will trigger a reboot that goes through bootloader, which allows |
| 37 | // using a new bootloader / recovery image if applicable. For example, REBOOT_RESCUE goes from |
| 38 | // rescue -> bootloader -> rescue, whereas ENTER_RESCUE switches from recovery -> rescue |
| 39 | // directly. |
Tao Bao | 1fe1afe | 2018-05-01 15:56:05 -0700 | [diff] [blame] | 40 | enum BuiltinAction { |
| 41 | NO_ACTION = 0, |
| 42 | REBOOT = 1, |
| 43 | APPLY_SDCARD = 2, |
| 44 | // APPLY_CACHE was 3. |
| 45 | APPLY_ADB_SIDELOAD = 4, |
| 46 | WIPE_DATA = 5, |
| 47 | WIPE_CACHE = 6, |
| 48 | REBOOT_BOOTLOADER = 7, |
| 49 | SHUTDOWN = 8, |
| 50 | VIEW_RECOVERY_LOGS = 9, |
| 51 | MOUNT_SYSTEM = 10, |
| 52 | RUN_GRAPHICS_TEST = 11, |
| 53 | RUN_LOCALE_TEST = 12, |
Jerry Zhang | b76af93 | 2018-05-22 12:08:35 -0700 | [diff] [blame] | 54 | KEY_INTERRUPTED = 13, |
Hridya Valsaraju | 20c81b3 | 2018-07-27 22:09:12 -0700 | [diff] [blame] | 55 | ENTER_FASTBOOT = 14, |
| 56 | ENTER_RECOVERY = 15, |
Tao Bao | c6dc325 | 2019-04-16 14:22:25 -0700 | [diff] [blame] | 57 | ENTER_RESCUE = 16, |
Tao Bao | d9cb014 | 2019-04-23 11:46:25 -0700 | [diff] [blame] | 58 | REBOOT_FASTBOOT = 17, |
| 59 | REBOOT_RECOVERY = 18, |
| 60 | REBOOT_RESCUE = 19, |
Tao Bao | 1fe1afe | 2018-05-01 15:56:05 -0700 | [diff] [blame] | 61 | }; |
| 62 | |
Tao Bao | e5d2c25 | 2018-05-09 11:05:44 -0700 | [diff] [blame] | 63 | explicit Device(RecoveryUI* ui); |
Tao Bao | fc5499f | 2017-02-23 19:06:53 -0800 | [diff] [blame] | 64 | virtual ~Device() {} |
Doug Zongker | daefc1d | 2011-10-31 09:34:15 -0700 | [diff] [blame] | 65 | |
Tao Bao | 551d2c3 | 2018-05-09 20:53:13 -0700 | [diff] [blame] | 66 | // Returns a raw pointer to the RecoveryUI object. |
Tao Bao | fc5499f | 2017-02-23 19:06:53 -0800 | [diff] [blame] | 67 | virtual RecoveryUI* GetUI() { |
Tao Bao | 551d2c3 | 2018-05-09 20:53:13 -0700 | [diff] [blame] | 68 | return ui_.get(); |
Tao Bao | fc5499f | 2017-02-23 19:06:53 -0800 | [diff] [blame] | 69 | } |
Doug Zongker | daefc1d | 2011-10-31 09:34:15 -0700 | [diff] [blame] | 70 | |
Tao Bao | 551d2c3 | 2018-05-09 20:53:13 -0700 | [diff] [blame] | 71 | // Resets the UI object to the given UI. Used to override the default UI in case initialization |
| 72 | // failed, or we want a different UI for some reason. The device object will take the ownership. |
| 73 | virtual void ResetUI(RecoveryUI* ui) { |
| 74 | ui_.reset(ui); |
Jerry Zhang | 2dea53e | 2018-05-02 17:15:03 -0700 | [diff] [blame] | 75 | } |
| 76 | |
Tao Bao | fc5499f | 2017-02-23 19:06:53 -0800 | [diff] [blame] | 77 | // Called when recovery starts up (after the UI has been obtained and initialized and after the |
| 78 | // arguments have been parsed, but before anything else). |
Tianjie Xu | 8f39730 | 2018-08-20 13:40:47 -0700 | [diff] [blame] | 79 | virtual void StartRecovery() {} |
Doug Zongker | daefc1d | 2011-10-31 09:34:15 -0700 | [diff] [blame] | 80 | |
Tao Bao | fc5499f | 2017-02-23 19:06:53 -0800 | [diff] [blame] | 81 | // Called from the main thread when recovery is at the main menu and waiting for input, and a key |
| 82 | // is pressed. (Note that "at" the main menu does not necessarily mean the menu is visible; |
Tao Bao | 551d2c3 | 2018-05-09 20:53:13 -0700 | [diff] [blame] | 83 | // recovery will be at the main menu with it invisible after an unsuccessful operation, such as |
| 84 | // failed to install an OTA package, or if recovery is started with no command.) |
Tao Bao | fc5499f | 2017-02-23 19:06:53 -0800 | [diff] [blame] | 85 | // |
| 86 | // 'key' is the code of the key just pressed. (You can call IsKeyPressed() on the RecoveryUI |
Tao Bao | 551d2c3 | 2018-05-09 20:53:13 -0700 | [diff] [blame] | 87 | // object you returned from GetUI() if you want to find out if other keys are held down.) |
Tao Bao | fc5499f | 2017-02-23 19:06:53 -0800 | [diff] [blame] | 88 | // |
| 89 | // 'visible' is true if the menu is visible. |
| 90 | // |
| 91 | // Returns one of the defined constants below in order to: |
Tao Bao | 1fe1afe | 2018-05-01 15:56:05 -0700 | [diff] [blame] | 92 | // - move the menu highlight (kHighlight{Up,Down}: negative value) |
| 93 | // - invoke the highlighted item (kInvokeItem: negative value) |
| 94 | // - do nothing (kNoAction: negative value) |
| 95 | // - invoke a specific action (a menu position: non-negative value) |
Tao Bao | fc5499f | 2017-02-23 19:06:53 -0800 | [diff] [blame] | 96 | virtual int HandleMenuKey(int key, bool visible); |
Doug Zongker | daefc1d | 2011-10-31 09:34:15 -0700 | [diff] [blame] | 97 | |
Tao Bao | 1fe1afe | 2018-05-01 15:56:05 -0700 | [diff] [blame] | 98 | // Returns the list of menu items (a vector of strings). The menu_position passed to |
Tao Bao | 551d2c3 | 2018-05-09 20:53:13 -0700 | [diff] [blame] | 99 | // InvokeMenuItem() will correspond to the indexes into this array. |
Tao Bao | 1fe1afe | 2018-05-01 15:56:05 -0700 | [diff] [blame] | 100 | virtual const std::vector<std::string>& GetMenuItems(); |
Doug Zongker | daefc1d | 2011-10-31 09:34:15 -0700 | [diff] [blame] | 101 | |
Tao Bao | 1fe1afe | 2018-05-01 15:56:05 -0700 | [diff] [blame] | 102 | // Performs a recovery action selected from the menu. 'menu_position' will be the index of the |
| 103 | // selected menu item, or a non-negative value returned from HandleMenuKey(). The menu will be |
Tao Bao | bc982a4 | 2019-03-29 15:43:09 -0700 | [diff] [blame] | 104 | // hidden when this is called; implementations can call GetUI()->Print() to print information to |
| 105 | // the screen. If the menu position is one of the builtin actions, you can just return the |
Tao Bao | fc5499f | 2017-02-23 19:06:53 -0800 | [diff] [blame] | 106 | // corresponding enum value. If it is an action specific to your device, you actually perform it |
| 107 | // here and return NO_ACTION. |
Tao Bao | 1fe1afe | 2018-05-01 15:56:05 -0700 | [diff] [blame] | 108 | virtual BuiltinAction InvokeMenuItem(size_t menu_position); |
Doug Zongker | daefc1d | 2011-10-31 09:34:15 -0700 | [diff] [blame] | 109 | |
Tao Bao | e5d2c25 | 2018-05-09 11:05:44 -0700 | [diff] [blame] | 110 | // Removes the menu item for the given action. This allows tailoring the menu based on the |
| 111 | // runtime info, such as the availability of /cache or /sdcard. |
| 112 | virtual void RemoveMenuItemForAction(Device::BuiltinAction action); |
| 113 | |
Tao Bao | fc5499f | 2017-02-23 19:06:53 -0800 | [diff] [blame] | 114 | // Called before and after we do a wipe data/factory reset operation, either via a reboot from the |
| 115 | // main system with the --wipe_data flag, or when the user boots into recovery image manually and |
| 116 | // selects the option from the menu, to perform whatever device-specific wiping actions as needed. |
| 117 | // Returns true on success; returning false from PreWipeData will prevent the regular wipe, and |
| 118 | // returning false from PostWipeData will cause the wipe to be considered a failure. |
| 119 | virtual bool PreWipeData() { |
| 120 | return true; |
| 121 | } |
Doug Zongker | daefc1d | 2011-10-31 09:34:15 -0700 | [diff] [blame] | 122 | |
Tao Bao | fc5499f | 2017-02-23 19:06:53 -0800 | [diff] [blame] | 123 | virtual bool PostWipeData() { |
| 124 | return true; |
| 125 | } |
| 126 | |
| 127 | private: |
Tao Bao | 551d2c3 | 2018-05-09 20:53:13 -0700 | [diff] [blame] | 128 | // The RecoveryUI object that should be used to display the user interface for this device. |
| 129 | std::unique_ptr<RecoveryUI> ui_; |
Doug Zongker | daefc1d | 2011-10-31 09:34:15 -0700 | [diff] [blame] | 130 | }; |
| 131 | |
Tao Bao | 42c45e2 | 2018-07-31 09:37:12 -0700 | [diff] [blame] | 132 | // Disable name mangling, as this function will be loaded via dlsym(3). |
| 133 | extern "C" { |
| 134 | |
Tao Bao | fc5499f | 2017-02-23 19:06:53 -0800 | [diff] [blame] | 135 | // The device-specific library must define this function (or the default one will be used, if there |
| 136 | // is no device-specific library). It returns the Device object that recovery should use. |
Doug Zongker | daefc1d | 2011-10-31 09:34:15 -0700 | [diff] [blame] | 137 | Device* make_device(); |
Tao Bao | 42c45e2 | 2018-07-31 09:37:12 -0700 | [diff] [blame] | 138 | } |
Doug Zongker | daefc1d | 2011-10-31 09:34:15 -0700 | [diff] [blame] | 139 | |
| 140 | #endif // _DEVICE_H |