zoukankan      html  css  js  c++  java

  • Android5.0 Recovery源代码分析与定制(一)【转】

    本文转载自：http://blog.csdn.net/morixinguan/article/details/72858346

    版权声明：本文为博主原创文章，如有需要，请注明转载地址:http://blog.csdn.net/morixinguan。若是侵权用于商业用途，请联系博主，否则将追究责任

    在Tiny4412的Android5.0源代码中:

    bootable/recovery/recovery.cpp是recovery程序的主文件。

    仔细一看，对比了其它平台的recovery源代码，除了MTK对Recovery做了相应的定制外，其它的平台几乎没有看到，关于MTK平台，后续再分析。

    关于Android5.0的recovery，有什么功能，在recovery.cpp中开头就已经做了详细的说明，我们来看看:

    [plain] view plain copy
     
     print?
    1. /*  
    2.  * The recovery tool communicates with the main system through /cache files.  
    3.  *   /cache/recovery/command - INPUT - command line for tool, one arg per line  
    4.  *   /cache/recovery/log - OUTPUT - combined log file from recovery run(s)  
    5.  *   /cache/recovery/intent - OUTPUT - intent that was passed in  
    6.  *  
    7.  * The arguments which may be supplied in the recovery.command file:  
    8.  *   --send_intent=anystring - write the text out to recovery.intent  
    9.  *   --update_package=path - verify install an OTA package file  
    10.  *   --wipe_data - erase user data (and cache), then reboot  
    11.  *   --wipe_cache - wipe cache (but not user data), then reboot  
    12.  *   --set_encrypted_filesystem=on|off - enables / diasables encrypted fs  
    13.  *   --just_exit - do nothing; exit and reboot  
    14.  *  
    15.  * After completing, we remove /cache/recovery/command and reboot.  
    16.  * Arguments may also be supplied in the bootloader control block (BCB).  
    17.  * These important scenarios must be safely restartable at any point:  
    18.  *  
    19.  * FACTORY RESET  
    20.  * 1. user selects "factory reset"  
    21.  * 2. main system writes "--wipe_data" to /cache/recovery/command  
    22.  * 3. main system reboots into recovery  
    23.  * 4. get_args() writes BCB with "boot-recovery" and "--wipe_data"  
    24.  *    -- after this, rebooting will restart the erase --  
    25.  * 5. erase_volume() reformats /data  
    26.  * 6. erase_volume() reformats /cache  
    27.  * 7. finish_recovery() erases BCB  
    28.  *    -- after this, rebooting will restart the main system --  
    29.  * 8. main() calls reboot() to boot main system  
    30.  *  
    31.  * OTA INSTALL  
    32.  * 1. main system downloads OTA package to /cache/some-filename.zip  
    33.  * 2. main system writes "--update_package=/cache/some-filename.zip"  
    34.  * 3. main system reboots into recovery  
    35.  * 4. get_args() writes BCB with "boot-recovery" and "--update_package=..."  
    36.  *    -- after this, rebooting will attempt to reinstall the update --  
    37.  * 5. install_package() attempts to install the update  
    38.  *    NOTE: the package install must itself be restartable from any point  
    39.  * 6. finish_recovery() erases BCB  
    40.  *    -- after this, rebooting will (try to) restart the main system --  
    41.  * 7. ** if install failed **  
    42.  *    7a. prompt_and_wait() shows an error icon and waits for the user  
    43.  *    7b; the user reboots (pulling the battery, etc) into the main system  
    44.  * 8. main() calls maybe_install_firmware_update()  
    45.  *    ** if the update contained radio/hboot firmware **:  
    46.  *    8a. m_i_f_u() writes BCB with "boot-recovery" and "--wipe_cache"  
    47.  *        -- after this, rebooting will reformat cache & restart main system --  
    48.  *    8b. m_i_f_u() writes firmware image into raw cache partition  
    49.  *    8c. m_i_f_u() writes BCB with "update-radio/hboot" and "--wipe_cache"  
    50.  *        -- after this, rebooting will attempt to reinstall firmware --  
    51.  *    8d. bootloader tries to flash firmware  
    52.  *    8e. bootloader writes BCB with "boot-recovery" (keeping "--wipe_cache")  
    53.  *        -- after this, rebooting will reformat cache & restart main system --  
    54.  *    8f. erase_volume() reformats /cache  
    55.  *    8g. finish_recovery() erases BCB  
    56.  *        -- after this, rebooting will (try to) restart the main system --  
    57.  * 9. main() calls reboot() to boot main system  
    58.  */  
    在这段英文注释里，详细的说明了factory_reset(Android的恢复出厂设置功能)的流程以及OTA系统更新的流程。

    在这段注释得最前面说得很明白，我们只要往/cache/recovery/command中写入相应的命令：

    [plain] view plain copy
     
     print?
    1. * The arguments which may be supplied in the recovery.command file:  
    2. *   --send_intent=anystring - write the text out to recovery.intent  
    3. *   --update_package=path - verify install an OTA package file  
    4. *   --wipe_data - erase user data (and cache), then reboot  
    5. *   --wipe_cache - wipe cache (but not user data), then reboot  
    6. *   --set_encrypted_filesystem=on|off - enables / diasables encrypted fs  
    7. *   --just_exit - do nothing; exit and reboot  
    比如写入: 

    --update_package=path(对应的OTA更新的路径)

    例如:

    --update_package=/mnt/external_sd/xxx.zip

    将这条命令写入后，再重启Android系统，recovery检测到有这个命令存在，就会去搜索这个路径，然后将这个路径做路径转换，接下来获取转换后的路径后，就挂载这个路径，然后挂载这个路径，获取OTA包，解包，校验，然后最后实现真正的更新。

    如果我们往这个文件写入: --wipe_data

    那么就会做出厂设置，格式化/data分区的内容。

    接下来，我们来看看代码，从main函数开始分析:

    进入main函数后，会将recovery产生的log信息重定向到/tmp/recovery.log这个文件里，具体代码实现如下：

    [cpp] view plain copy
     
     print?
    1. //重定向标准输出和标准出错到/tmp/recovery.log 这个文件里  
    2.     //static const char *TEMPORARY_LOG_FILE = "/tmp/recovery.log";  
    3.     redirect_stdio(TEMPORARY_LOG_FILE);  
    redirect_stdio函数源代码:
    [cpp] view plain copy
     
     print?
    1. static void redirect_stdio(const char* filename) {  
    2.     // If these fail, there's not really anywhere to complain...  
    3.     freopen(filename, "a", stdout); setbuf(stdout, NULL);  
    4.     freopen(filename, "a", stderr); setbuf(stderr, NULL);  
    5. }  
    我们看到，所有产生来自stdout和stderr的信息会使用freopen这个函数重定向到/tmp/recovery.log这个文件里。

    stdout就是标准输出，stdout就是标准出错。标准输出就是我们平时使用的printf输出的信息。

    当然也可以使用fprintf(stdout,"hello world ");也是一样的

    标准出错就是fprintf(stderr,"hello world! ");类似的代码。

    接下下来，将会判断是否使用adb的sideload来传入，通过参数--adbd来判断：

    [cpp] view plain copy
     
     print?
    1. // If this binary is started with the single argument "--adbd",  
    2. // instead of being the normal recovery binary, it turns into kind  
    3. // of a stripped-down version of adbd that only supports the  
    4. // 'sideload' command.  Note this must be a real argument, not  
    5. // anything in the command file or bootloader control block; the  
    6. // only way recovery should be run with this argument is when it  
    7. // starts a copy of itself from the apply_from_adb() function.  
    8. if (argc == 2 && strcmp(argv[1], "--adbd") == 0) {  
    9.     adb_main();  
    10.     return 0;  
    11. }  
    做完这些步骤以后，会初始化并装载recovery的分区表recovery.fstab，然后挂载/cache/recovery/last_log这个文件，用来输出log。
    [cpp] view plain copy
     
     print?
    1.    printf("Starting recovery (pid %d) on %s", getpid(), ctime(&start));  
    2. //装载recovery的分区表recovery.fstab  
    3.    load_volume_table();  
    4. //在recovery中挂载/cache/recovery/last_log这个文件  
    5. //#define LAST_LOG_FILE "/cache/recovery/last_log"  
    6.    ensure_path_mounted(LAST_LOG_FILE);  
    7.    rotate_last_logs(KEEP_LOG_COUNT);  
    这里主要看如何装载分区表的流程,先来看看recovery.fstab
    [cpp] view plain copy
     
     print?
    1. /dev/block/by-name/boot         /boot         emmc     defaults                                                                defaults  
    2. /dev/block/by-name/recovery     /recovery     emmc     defaults                                                                defaults  
    3. /dev/block/by-name/splashscreen /splashscreen emmc     defaults                                                                defaults  
    4. /dev/block/by-name/fastboot     /fastboot     emmc     defaults                                                                defaults  
    5. /dev/block/by-name/misc         /misc         emmc     defaults                                                                defaults  
    6. /dev/block/by-name/system       /system       ext4     ro,noatime                                                              wait  
    7. /dev/block/by-name/cache        /cache        ext4     nosuid,nodev,noatime,barrier=1,data=ordered                             wait,check  
    8. /dev/block/by-name/userdata     /data         ext4     nosuid,nodev,noatime,discard,barrier=1,data=ordered,noauto_da_alloc     wait,check  
    9. /dev/block/by-name/factory      /factory      ext4     nosuid,nodev,noatime,barrier=1,data=ordered                             wait  

    接下来看是如果挂载的：

    [cpp] view plain copy
     
     print?
    1. void load_volume_table()  
    2. {  
    3.     int i;  
    4.     int ret;  
    5.     //读recovery.fstab 这个分区表  
    6.     fstab = fs_mgr_read_fstab("/etc/recovery.fstab");  
    7.     if (!fstab) {  
    8.         LOGE("failed to read /etc/recovery.fstab ");  
    9.         return;  
    10.     }  
    11.     //将对应的信息加入到一条链表中  
    12.     ret = fs_mgr_add_entry(fstab, "/tmp", "ramdisk", "ramdisk");  
    13.     //如果load到的分区表为空，后面做释放操作  
    14.     if (ret < 0 ) {  
    15.         LOGE("failed to add /tmp entry to fstab ");  
    16.         fs_mgr_free_fstab(fstab);  
    17.         fstab = NULL;  
    18.         return;  
    19.     }  
    20.   
    21.     printf("recovery filesystem table ");  
    22.     printf("========================= ");  
    23.     //到这一步，打印分区表信息，这类信息在  
    24.     //recovery启动的时候的log可以看到  
    25.     //分别是以下  
    26.     //编号|   挂载节点|  文件系统类型|  块设备|   长度  
    27.     for (i = 0; i < fstab->num_entries; ++i) {  
    28.         Volume* v = &fstab->recs[i];  
    29.         printf("  %d %s %s %s %lld ", i, v->mount_point, v->fs_type,  
    30.                v->blk_device, v->length);  
    31.     }  
    32.     printf(" ");  
    33. }  

    挂载完相应的分区以后，就需要获取命令参数，因为只有挂载了对应的分区，才能访问到前面要写入command的这个文件，这样我们才能正确的打开文件，如果分区都没找到，那么当然就找不到分区上的文件，上面这个步骤是至关重要的。

    [cpp] view plain copy
     
     print?
    1. //获取参数  
    2.     //这个参数也可能是从/cache/recovery/command文件中得到相应的命令  
    3.     //也就是可以往command这个文件写入对应的格式的命令即可  
    4.     get_args(&argc, &argv);  
    5.   
    6.     const char *send_intent = NULL;  
    7.     const char *update_package = NULL;  
    8.     int wipe_data = 0, wipe_cache = 0, show_text = 0;  
    9.     bool just_exit = false;  
    10.     bool shutdown_after = false;  
    11.   
    12.     int arg;  
    13.     //参数有擦除分区，OTA更新等  
    14.     while ((arg = getopt_long(argc, argv, "", OPTIONS, NULL)) != -1) {  
    15.         switch (arg) {  
    16.         case 's': send_intent = optarg; break;  
    17.         case 'u': update_package = optarg; break;  
    18.         case 'w': wipe_data = wipe_cache = 1; break;  
    19.         case 'c': wipe_cache = 1; break;  
    20.         case 't': show_text = 1; break;  
    21.         case 'x': just_exit = true; break;  
    22.         case 'l': locale = optarg; break;  
    23.         case 'g': {  
    24.             if (stage == NULL || *stage == '') {  
    25.                 char buffer[20] = "1/";  
    26.                 strncat(buffer, optarg, sizeof(buffer)-3);  
    27.                 stage = strdup(buffer);  
    28.             }  
    29.             break;  
    30.         }  
    31.         case 'p': shutdown_after = true; break;  
    32.         case 'r': reason = optarg; break;  
    33.         case '?':  
    34.             LOGE("Invalid command argument ");  
    35.             continue;  
    36.         }  
    37.     }  
    获取到对应的命令，就会执行对应的标志，后面会根据标志来执行对应的操作。

    做完以上的流程后，下面就是创建设备，设置语言信息，初始化recovery的UI界面，设置Selinux权限，代码如下：

    [cpp] view plain copy
     
     print?
    1. //设置语言  
    2.     if (locale == NULL) {  
    3.         load_locale_from_cache();  
    4.     }  
    5.     printf("locale is [%s] ", locale);  
    6.     printf("stage is [%s] ", stage);  
    7.     printf("reason is [%s] ", reason);  
    8.     //创建设备  
    9.     Device* device = make_device();  
    10.     //获取UI  
    11.     ui = device->GetUI();  
    12.     //设置当前的UI  
    13.     gCurrentUI = ui;  
    14.     //设置UI的语言信息  
    15.     ui->SetLocale(locale);  
    16.     //UI初始化  
    17.     ui->Init();  
    18.   
    19.     int st_cur, st_max;  
    20.     if (stage != NULL && sscanf(stage, "%d/%d", &st_cur, &st_max) == 2) {  
    21.         ui->SetStage(st_cur, st_max);  
    22.     }  
    23.     //设置recovery的背景图  
    24.     ui->SetBackground(RecoveryUI::NONE);  
    25.     //设置界面上是否能够显示字符，使能ui->print函数开关  
    26.     if (show_text) ui->ShowText(true);  
    27.     //设置selinux权限，一般我会把selinux 给disabled  
    28.     struct selinux_opt seopts[] = {  
    29.       { SELABEL_OPT_PATH, "/file_contexts" }  
    30.     };  
    31.   
    32.     sehandle = selabel_open(SELABEL_CTX_FILE, seopts, 1);  
    33.   
    34.     if (!sehandle) {  
    35.         ui->Print("Warning: No file_contexts ");  
    36.     }  
    37.     //虚函数，没有做什么流程  
    38.     device->StartRecovery();  
    39.   
    40.     printf("Command:");  
    41.     for (arg = 0; arg < argc; arg++) {  
    42.         printf(" "%s"", argv[arg]);  
    43.     }  
    44.     printf(" ");  
    接下来是重要的环节，这个环节将会根据上面命令参数来做真正的事情了，比如恢复出厂设置，OTA更新等。
    [cpp] view plain copy
     
     print?
    1. //如果update_package(也就是要升级的OTA包)不为空的情况下  
    2.     //这里要对升级包的路径做一下路径转换，这里可以自由定制自己升级包的路径  
    3.     if (update_package) {  
    4.         // For backwards compatibility on the cache partition only, if  
    5.         // we're given an old 'root' path "CACHE:foo", change it to  
    6.         // "/cache/foo".  
    7.   
    8.     //这里就是做转换的方法  
    9.     //先比较传进来的recovery参数的前6个byte是否是CACHE  
    10.     //如果是将其路径转化为/cache/CACHE: ......  
    11.         if (strncmp(update_package, "CACHE:", 6) == 0) {  
    12.             int len = strlen(update_package) + 10;  
    13.             char* modified_path = (char*)malloc(len);  
    14.             strlcpy(modified_path, "/cache/", len);  
    15.             strlcat(modified_path, update_package+6, len);  
    16.             printf("(replacing path "%s" with "%s") ",  
    17.                    update_package, modified_path);  
    18.             //这个update_package就是转换后的路径  
    19.             update_package = modified_path;  
    20.         }  
    21.     }  
    22.     printf(" ");  
    23.     property_list(print_property, NULL);  
    24.     //获取属性，这里应该是从一个文件中找到ro.build.display.id  
    25.     //获取recovery的版本信息  
    26.     property_get("ro.build.display.id", recovery_version, "");  
    27.     printf(" ");  
    28.   
    29.     //定义一个安装成功的标志位INSTALL_SUCCESS  ----> 其实是个枚举，值为0  
    30.     int status = INSTALL_SUCCESS;  
    31.     //判断转换后的OTA升级包的路径是否不为空，如果不为空  
    32.     //执行install_package 函数进行升级  
    33.     if (update_package != NULL) {  
    34.         status = install_package(update_package, &wipe_cache, TEMPORARY_INSTALL_FILE, true);  
    35.         //判断是否升级成功  
    36.         if (status == INSTALL_SUCCESS && wipe_cache) {  
    37.             //擦除这个路径，相当于删除了这个路径下的OTA升级包  
    38.             if (erase_volume("/cache")) {  
    39.                 LOGE("Cache wipe (requested by package) failed.");  
    40.             }  
    41.         }  
    42.         //如果安装不成功  
    43.         if (status != INSTALL_SUCCESS) {  
    44.             ui->Print("Installation aborted. ");  
    45.   
    46.             // If this is an eng or userdebug build, then automatically  
    47.             // turn the text display on if the script fails so the error  
    48.             // message is visible.  
    49.             char buffer[PROPERTY_VALUE_MAX+1];  
    50.             property_get("ro.build.fingerprint", buffer, "");  
    51.             if (strstr(buffer, ":userdebug/") || strstr(buffer, ":eng/")) {  
    52.                 ui->ShowText(true);  
    53.             }  
    54.         }  
    55.     }  
    56.     //如果跑的是格式化数据区，那么就走这个流程  
    57.     else if (wipe_data) {  
    58.         if (device->WipeData()) status = INSTALL_ERROR;  
    59.         //格式化/data分区  
    60.         if (erase_volume("/data")) status = INSTALL_ERROR;  
    61.         if (wipe_cache && erase_volume("/cache")) status = INSTALL_ERROR;  
    62.         if (erase_persistent_partition() == -1 ) status = INSTALL_ERROR;  
    63.         if (status != INSTALL_SUCCESS) ui->Print("Data wipe failed. ");  
    64.     }   
    65.     //格式化cache分区  
    66.     else if (wipe_cache) {  
    67.         if (wipe_cache && erase_volume("/cache")) status = INSTALL_ERROR;  
    68.         if (status != INSTALL_SUCCESS) ui->Print("Cache wipe failed. ");  
    69.     }   
    70.     else if (!just_exit) {  
    71.         status = INSTALL_NONE;  // No command specified  
    72.         ui->SetBackground(RecoveryUI::NO_COMMAND);  
    73.     }  
    74.     //如果安装失败或者。。。  
    75.     if (status == INSTALL_ERROR || status == INSTALL_CORRUPT) {  
    76.         copy_logs();  
    77.         //显示错误的LOGO  
    78.         ui->SetBackground(RecoveryUI::ERROR);  
    79.     }  
    80.     Device::BuiltinAction after = shutdown_after ? Device::SHUTDOWN : Device::REBOOT;  
    81.     if (status != INSTALL_SUCCESS || ui->IsTextVisible()) {  
    82.         Device::BuiltinAction temp = prompt_and_wait(device, status);  
    83.         if (temp != Device::NO_ACTION) after = temp;  
    84.     }  
    85.       
    86.     // Save logs and clean up before rebooting or shutting down.  
    87.     //完成recovery升级  
    88.     finish_recovery(send_intent);  
    89.   
    90.     switch (after) {  
    91.         case Device::SHUTDOWN:  
    92.             ui->Print("Shutting down... ");  
    93.             property_set(ANDROID_RB_PROPERTY, "shutdown,");  
    94.             break;  
    95.   
    96.         case Device::REBOOT_BOOTLOADER:  
    97.             ui->Print("Rebooting to bootloader... ");  
    98.             property_set(ANDROID_RB_PROPERTY, "reboot,bootloader");  
    99.             break;  
    100.   
    101.         default:  
    102.             ui->Print("Rebooting... ");  
    103.             property_set(ANDROID_RB_PROPERTY, "reboot,");  
    104.             break;  
    105.     }  
    106.     sleep(5); // should reboot before this finishes  
    107.     return EXIT_SUCCESS;  
    在这里面，我们最常用的即是OTA更新和恢复出厂设置，先来说说恢复出厂设置，这个功能就是所谓的手机双清，众所周知，Android手机在使用很久后，由于垃圾数据，以及其它的因素会导致手机的反应越来越慢，这让人烦恼不已，所以就需要双清，双清一般就是清除

    /data分区和/cache分区，代码流程很详细，有兴趣可以自己去分析。

    接下来看看OTA是如何实现更新的，我们看到install_ota_package这个函数，执行到这个函数，看到源码：

    [cpp] view plain copy
     
     print?
    1. //安装更新包  
    2. int  
    3. install_package(const char* path, int* wipe_cache, const char* install_file,  
    4.                 bool needs_mount)  
    5. {  
    6.     FILE* install_log = fopen_path(install_file, "w");  
    7.     if (install_log) {  
    8.         fputs(path, install_log);  
    9.         fputc(' ', install_log);  
    10.     } else {  
    11.         LOGE("failed to open last_install: %s ", strerror(errno));  
    12.     }  
    13.     int result;  
    14.     //设置安装挂载对应的节点  
    15.     //这一步是关键  
    16.     if (setup_install_mounts() != 0) {  
    17.         LOGE("failed to set up expected mounts for install; aborting ");  
    18.         result = INSTALL_ERROR;  
    19.     } else {  
    20.         //到这里才是真正的去安装OTA包  
    21.         result = really_install_package(path, wipe_cache, needs_mount);  
    22.     }  
    23.     //如果返回结果为0，那么安装就成功了  
    24.     if (install_log) {  
    25.         fputc(result == INSTALL_SUCCESS ? '1' : '0', install_log);  
    26.         fputc(' ', install_log);  
    27.         fclose(install_log);  
    28.     }  
    29.     return result;  
    30. }  
    其实到了really_install_package这一步，才是真正做到OTA更新，但是在OTA更新之前至关重要的一步就是设置安装挂载对应的节点了，我曾经掉入此坑，现在拿出来分析一下，我们来看看setup_install_mounts这个函数:
    [cpp] view plain copy
     
     print?
    1. //设置安装挂载的节点  
    2. int setup_install_mounts() {  
    3.     if (fstab == NULL) {  
    4.         LOGE("can't set up install mounts: no fstab loaded ");  
    5.         return -1;  
    6.     }  
    7.     for (int i = 0; i < fstab->num_entries; ++i) {  
    8.         Volume* v = fstab->recs + i;  
    9.     //如果判断挂载的路径是/tmp 或者/cache  
    10.     //那么就挂载对应的节点，而其它的节点都不会去挂载  
    11.         if (strcmp(v->mount_point, "/tmp") == 0 ||  
    12.             strcmp(v->mount_point, "/cache") == 0) {  
    13.             if (ensure_path_mounted(v->mount_point) != 0) {  
    14.                 LOGE("failed to mount %s ", v->mount_point);  
    15.                 return -1;  
    16.             }  
    17.   
    18.         }  
    19.         //如果不是/tmp或者/cache这两个节点，则默认就会卸载所有的挂载节点  
    20.         else {  
    21.             //卸载所有的挂载节点  
    22.             if (ensure_path_unmounted(v->mount_point) != 0) {  
    23.                 LOGE("failed to unmount %s ", v->mount_point);  
    24.                 return -1;  
    25.             }  
    26.         }  
    27.     }  
    28.     return 0;  
    29. }  
    如果在安装更新的时候，OTA包经过路径转换后不是放在/tmp和/cache这个路径下的时候，那么就会走else分支，从而卸载所有的挂载节点，这样就会导致，传的路径正确，却OTA更新不成功，如果是做自己定制的路径，这一步一定要小心，我们可以在这里继续添加定制的挂载点。

    那么，执行完设置挂载节点的函数后，接下来就是执行真正的OTA更新了，我们来看看：

    [cpp] view plain copy
     
     print?
    1. static int  
    2. really_install_package(const char *path, int* wipe_cache, bool needs_mount)  
    3. {  
    4.     //设置更新时的背景  
    5.     ui->SetBackground(RecoveryUI::INSTALLING_UPDATE);  
    6.     ui->Print("Finding update package... ");  
    7.     // Give verification half the progress bar...  
    8.     //设置进度条的类型  
    9.     ui->SetProgressType(RecoveryUI::DETERMINATE);  
    10.     //显示进度条  
    11.     ui->ShowProgress(VERIFICATION_PROGRESS_FRACTION, VERIFICATION_PROGRESS_TIME);  
    12.     LOGI("Update location: %s ", path);  
    13.     //在屏幕上打印 Opening update package..  
    14.     // Map the update package into memory.  
    15.     ui->Print("Opening update package... ");  
    16.     //patch是OTA的路径,need_mount参数表示是否需要挂载，1挂载，0，不挂载  
    17.     if (path && needs_mount) {  
    18.         if (path[0] == '@') {  
    19.             ensure_path_mounted(path+1);  
    20.         } else {  
    21.             //挂载OTA升级包的路径------> 一般是执行这个流程  
    22.             ensure_path_mounted(path);  
    23.         }  
    24.     }  
    25.   
    26.     MemMapping map;  
    27.     if (sysMapFile(path, &map) != 0) {  
    28.         LOGE("failed to map file ");  
    29.         return INSTALL_CORRUPT;  
    30.     }  
    31.   
    32.     int numKeys;  
    33.     //获取校验公钥文件  
    34.     Certificate* loadedKeys = load_keys(PUBLIC_KEYS_FILE, &numKeys);  
    35.     if (loadedKeys == NULL) {  
    36.         LOGE("Failed to load keys ");  
    37.         return INSTALL_CORRUPT;  
    38.     }  
    39.     LOGI("%d key(s) loaded from %s ", numKeys, PUBLIC_KEYS_FILE);  
    40.   
    41.     ui->Print("Verifying update package... ");  
    42.   
    43.     int err;  
    44.     //校验文件  
    45.     err = verify_file(map.addr, map.length, loadedKeys, numKeys);  
    46.     free(loadedKeys);  
    47.     LOGI("verify_file returned %d ", err);  
    48.     //如果校验不成功  
    49.     if (err != VERIFY_SUCCESS) {  
    50.         //打印签名失败  
    51.         LOGE("signature verification failed ");  
    52.         sysReleaseMap(&map);  
    53.         return INSTALL_CORRUPT;  
    54.     }  
    55.   
    56.     /* Try to open the package. 
    57.      */  
    58.     //尝试去打开ota压缩包  
    59.     ZipArchive zip;  
    60.     err = mzOpenZipArchive(map.addr, map.length, &zip);  
    61.     if (err != 0) {  
    62.         LOGE("Can't open %s (%s) ", path, err != -1 ? strerror(err) : "bad");  
    63.         sysReleaseMap(&map);  
    64.         return INSTALL_CORRUPT;  
    65.     }  
    66.   
    67.     /* Verify and install the contents of the package. 
    68.      */  
    69.     //开始安装升级包  
    70.     ui->Print("Installing update... ");  
    71.     ui->SetEnableReboot(false);  
    72.     int result = try_update_binary(path, &zip, wipe_cache);  
    73.     //安装成功后自动重启  
    74.     ui->SetEnableReboot(true);  
    75.     ui->Print(" ");  
    76.   
    77.     sysReleaseMap(&map);  
    78.     //返回结果  
    79.     return result;  
    80. }  
    关于recovery的大致流程，我们分析至此，关于如何像MTK平台一样，定制recovery，这就需要读者能够读懂recovery的流程，然后加入自己的代码进行定制，当然我们也会看到，一些recovery花样百出，很多UI做了自己的，而不是用安卓系统原生态的，安卓系统recovery原生态的UI如下：




    如何定制相应的UI，后续我们会对recovery源代码中的UI显示做进一步的分析。。。。

    接下来，贴出Android5.0的recovery.cpp代码和注释：

    [cpp] view plain copy
     
     print?
    1. /* 
    2.  * Copyright (C) 2007 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 <ctype.h>  
    18. #include <dirent.h>  
    19. #include <errno.h>  
    20. #include <fcntl.h>  
    21. #include <getopt.h>  
    22. #include <limits.h>  
    23. #include <linux/input.h>  
    24. #include <stdarg.h>  
    25. #include <stdio.h>  
    26. #include <stdlib.h>  
    27. #include <string.h>  
    28. #include <sys/stat.h>  
    29. #include <sys/types.h>  
    30. #include <time.h>  
    31. #include <unistd.h>  
    32.   
    33. #include "bootloader.h"  
    34. #include "common.h"  
    35. #include "cutils/properties.h"  
    36. #include "cutils/android_reboot.h"  
    37. #include "install.h"  
    38. #include "minui/minui.h"  
    39. #include "minzip/DirUtil.h"  
    40. #include "roots.h"  
    41. #include "ui.h"  
    42. #include "screen_ui.h"  
    43. #include "device.h"  
    44. #include "adb_install.h"  
    45. extern "C" {  
    46. #include "minadbd/adb.h"  
    47. #include "fuse_sideload.h"  
    48. #include "fuse_sdcard_provider.h"  
    49. }  
    50.   
    51. struct selabel_handle *sehandle;  
    52.   
    53. static const struct option OPTIONS[] = {  
    54.   { "send_intent", required_argument, NULL, 's' },  
    55.   { "update_package", required_argument, NULL, 'u' },  
    56.   { "wipe_data", no_argument, NULL, 'w' },  
    57.   { "wipe_cache", no_argument, NULL, 'c' },  
    58.   { "show_text", no_argument, NULL, 't' },  
    59.   { "just_exit", no_argument, NULL, 'x' },  
    60.   { "locale", required_argument, NULL, 'l' },  
    61.   { "stages", required_argument, NULL, 'g' },  
    62.   { "shutdown_after", no_argument, NULL, 'p' },  
    63.   { "reason", required_argument, NULL, 'r' },  
    64.   { NULL, 0, NULL, 0 },  
    65. };  
    66.   
    67. #define LAST_LOG_FILE "/cache/recovery/last_log"  
    68.   
    69. static const char *CACHE_LOG_DIR = "/cache/recovery";  
    70. static const char *COMMAND_FILE = "/cache/recovery/command";  
    71. static const char *INTENT_FILE = "/cache/recovery/intent";  
    72. static const char *LOG_FILE = "/cache/recovery/log";  
    73. static const char *LAST_INSTALL_FILE = "/cache/recovery/last_install";  
    74. static const char *LOCALE_FILE = "/cache/recovery/last_locale";  
    75. static const char *CACHE_ROOT = "/cache";  
    76. static const char *SDCARD_ROOT = "/sdcard";  
    77. static const char *TEMPORARY_LOG_FILE = "/tmp/recovery.log";  
    78. static const char *TEMPORARY_INSTALL_FILE = "/tmp/last_install";  
    79.   
    80. #define KEEP_LOG_COUNT 10  
    81.   
    82. RecoveryUI* ui = NULL;  
    83. char* locale = NULL;  
    84. char recovery_version[PROPERTY_VALUE_MAX+1];  
    85. char* stage = NULL;  
    86. char* reason = NULL;  
    87.   
    88. /* 
    89.  * The recovery tool communicates with the main system through /cache files. 
    90.  *   /cache/recovery/command - INPUT - command line for tool, one arg per line 
    91.  *   /cache/recovery/log - OUTPUT - combined log file from recovery run(s) 
    92.  *   /cache/recovery/intent - OUTPUT - intent that was passed in 
    93.  * 
    94.  * The arguments which may be supplied in the recovery.command file: 
    95.  *   --send_intent=anystring - write the text out to recovery.intent 
    96.  *   --update_package=path - verify install an OTA package file 
    97.  *   --wipe_data - erase user data (and cache), then reboot 
    98.  *   --wipe_cache - wipe cache (but not user data), then reboot 
    99.  *   --set_encrypted_filesystem=on|off - enables / diasables encrypted fs 
    100.  *   --just_exit - do nothing; exit and reboot 
    101.  * 
    102.  * After completing, we remove /cache/recovery/command and reboot. 
    103.  * Arguments may also be supplied in the bootloader control block (BCB). 
    104.  * These important scenarios must be safely restartable at any point: 
    105.  * 
    106.  * FACTORY RESET 
    107.  * 1. user selects "factory reset" 
    108.  * 2. main system writes "--wipe_data" to /cache/recovery/command 
    109.  * 3. main system reboots into recovery 
    110.  * 4. get_args() writes BCB with "boot-recovery" and "--wipe_data" 
    111.  *    -- after this, rebooting will restart the erase -- 
    112.  * 5. erase_volume() reformats /data 
    113.  * 6. erase_volume() reformats /cache 
    114.  * 7. finish_recovery() erases BCB 
    115.  *    -- after this, rebooting will restart the main system -- 
    116.  * 8. main() calls reboot() to boot main system 
    117.  * 
    118.  * OTA INSTALL 
    119.  * 1. main system downloads OTA package to /cache/some-filename.zip 
    120.  * 2. main system writes "--update_package=/cache/some-filename.zip" 
    121.  * 3. main system reboots into recovery 
    122.  * 4. get_args() writes BCB with "boot-recovery" and "--update_package=..." 
    123.  *    -- after this, rebooting will attempt to reinstall the update -- 
    124.  * 5. install_package() attempts to install the update 
    125.  *    NOTE: the package install must itself be restartable from any point 
    126.  * 6. finish_recovery() erases BCB 
    127.  *    -- after this, rebooting will (try to) restart the main system -- 
    128.  * 7. ** if install failed ** 
    129.  *    7a. prompt_and_wait() shows an error icon and waits for the user 
    130.  *    7b; the user reboots (pulling the battery, etc) into the main system 
    131.  * 8. main() calls maybe_install_firmware_update() 
    132.  *    ** if the update contained radio/hboot firmware **: 
    133.  *    8a. m_i_f_u() writes BCB with "boot-recovery" and "--wipe_cache" 
    134.  *        -- after this, rebooting will reformat cache & restart main system -- 
    135.  *    8b. m_i_f_u() writes firmware image into raw cache partition 
    136.  *    8c. m_i_f_u() writes BCB with "update-radio/hboot" and "--wipe_cache" 
    137.  *        -- after this, rebooting will attempt to reinstall firmware -- 
    138.  *    8d. bootloader tries to flash firmware 
    139.  *    8e. bootloader writes BCB with "boot-recovery" (keeping "--wipe_cache") 
    140.  *        -- after this, rebooting will reformat cache & restart main system -- 
    141.  *    8f. erase_volume() reformats /cache 
    142.  *    8g. finish_recovery() erases BCB 
    143.  *        -- after this, rebooting will (try to) restart the main system -- 
    144.  * 9. main() calls reboot() to boot main system 
    145.  */  
    146.   
    147. static const int MAX_ARG_LENGTH = 4096;  
    148. static const int MAX_ARGS = 100;  
    149.   
    150. // open a given path, mounting partitions as necessary  
    151. FILE*  
    152. fopen_path(const char *path, const char *mode) {  
    153.     if (ensure_path_mounted(path) != 0) {  
    154.         LOGE("Can't mount %s ", path);  
    155.         return NULL;  
    156.     }  
    157.   
    158.     // When writing, try to create the containing directory, if necessary.  
    159.     // Use generous permissions, the system (init.rc) will reset them.  
    160.     if (strchr("wa", mode[0])) dirCreateHierarchy(path, 0777, NULL, 1, sehandle);  
    161.   
    162.     FILE *fp = fopen(path, mode);  
    163.     return fp;  
    164. }  
    165.   
    166. static void redirect_stdio(const char* filename) {  
    167.     // If these fail, there's not really anywhere to complain...  
    168.     freopen(filename, "a", stdout); setbuf(stdout, NULL);  
    169.     freopen(filename, "a", stderr); setbuf(stderr, NULL);  
    170. }  
    171.   
    172. // close a file, log an error if the error indicator is set  
    173. static void  
    174. check_and_fclose(FILE *fp, const char *name) {  
    175.     fflush(fp);  
    176.     if (ferror(fp)) LOGE("Error in %s (%s) ", name, strerror(errno));  
    177.     fclose(fp);  
    178. }  
    179.   
    180. // command line args come from, in decreasing precedence:  
    181. //   - the actual command line  
    182. //   - the bootloader control block (one per line, after "recovery")  
    183. //   - the contents of COMMAND_FILE (one per line)  
    184. static void  
    185. get_args(int *argc, char ***argv) {  
    186.     struct bootloader_message boot;  
    187.     memset(&boot, 0, sizeof(boot));  
    188.     get_bootloader_message(&boot);  // this may fail, leaving a zeroed structure  
    189.     stage = strndup(boot.stage, sizeof(boot.stage));  
    190.   
    191.     if (boot.command[0] != 0 && boot.command[0] != 255) {  
    192.         LOGI("Boot command: %.*s ", (int)sizeof(boot.command), boot.command);  
    193.     }  
    194.   
    195.     if (boot.status[0] != 0 && boot.status[0] != 255) {  
    196.         LOGI("Boot status: %.*s ", (int)sizeof(boot.status), boot.status);  
    197.     }  
    198.   
    199.     // --- if arguments weren't supplied, look in the bootloader control block  
    200.     if (*argc <= 1) {  
    201.         boot.recovery[sizeof(boot.recovery) - 1] = '';  // Ensure termination  
    202.         const char *arg = strtok(boot.recovery, " ");  
    203.         if (arg != NULL && !strcmp(arg, "recovery")) {  
    204.             *argv = (char **) malloc(sizeof(char *) * MAX_ARGS);  
    205.             (*argv)[0] = strdup(arg);  
    206.             for (*argc = 1; *argc < MAX_ARGS; ++*argc) {  
    207.                 if ((arg = strtok(NULL, " ")) == NULL) break;  
    208.                 (*argv)[*argc] = strdup(arg);  
    209.             }  
    210.             LOGI("Got arguments from boot message ");  
    211.         } else if (boot.recovery[0] != 0 && boot.recovery[0] != 255) {  
    212.             LOGE("Bad boot message "%.20s" ", boot.recovery);  
    213.         }  
    214.     }  
    215.   
    216.     // --- if that doesn't work, try the command file  
    217.     if (*argc <= 1) {  
    218.         FILE *fp = fopen_path(COMMAND_FILE, "r");  
    219.         if (fp != NULL) {  
    220.             char *token;  
    221.             char *argv0 = (*argv)[0];  
    222.             *argv = (char **) malloc(sizeof(char *) * MAX_ARGS);  
    223.             (*argv)[0] = argv0;  // use the same program name  
    224.   
    225.             char buf[MAX_ARG_LENGTH];  
    226.             for (*argc = 1; *argc < MAX_ARGS; ++*argc) {  
    227.                 if (!fgets(buf, sizeof(buf), fp)) break;  
    228.                 token = strtok(buf, " ");  
    229.                 if (token != NULL) {  
    230.                     (*argv)[*argc] = strdup(token);  // Strip newline.  
    231.                 } else {  
    232.                     --*argc;  
    233.                 }  
    234.             }  
    235.   
    236.             check_and_fclose(fp, COMMAND_FILE);  
    237.             LOGI("Got arguments from %s ", COMMAND_FILE);  
    238.         }  
    239.     }  
    240.   
    241.     // --> write the arguments we have back into the bootloader control block  
    242.     // always boot into recovery after this (until finish_recovery() is called)  
    243.     strlcpy(boot.command, "boot-recovery", sizeof(boot.command));  
    244.     strlcpy(boot.recovery, "recovery ", sizeof(boot.recovery));  
    245.     int i;  
    246.     for (i = 1; i < *argc; ++i) {  
    247.         strlcat(boot.recovery, (*argv)[i], sizeof(boot.recovery));  
    248.         strlcat(boot.recovery, " ", sizeof(boot.recovery));  
    249.     }  
    250.     set_bootloader_message(&boot);  
    251. }  
    252.   
    253. static void  
    254. set_sdcard_update_bootloader_message() {  
    255.     struct bootloader_message boot;  
    256.     memset(&boot, 0, sizeof(boot));  
    257.     strlcpy(boot.command, "boot-recovery", sizeof(boot.command));  
    258.     strlcpy(boot.recovery, "recovery ", sizeof(boot.recovery));  
    259.     set_bootloader_message(&boot);  
    260. }  
    261.   
    262. // How much of the temp log we have copied to the copy in cache.  
    263. static long tmplog_offset = 0;  
    264.   
    265. static void  
    266. copy_log_file(const char* source, const char* destination, int append) {  
    267.     FILE *log = fopen_path(destination, append ? "a" : "w");  
    268.     if (log == NULL) {  
    269.         LOGE("Can't open %s ", destination);  
    270.     } else {  
    271.         FILE *tmplog = fopen(source, "r");  
    272.         if (tmplog != NULL) {  
    273.             if (append) {  
    274.                 fseek(tmplog, tmplog_offset, SEEK_SET);  // Since last write  
    275.             }  
    276.             char buf[4096];  
    277.             while (fgets(buf, sizeof(buf), tmplog)) fputs(buf, log);  
    278.             if (append) {  
    279.                 tmplog_offset = ftell(tmplog);  
    280.             }  
    281.             check_and_fclose(tmplog, source);  
    282.         }  
    283.         check_and_fclose(log, destination);  
    284.     }  
    285. }  
    286.   
    287. // Rename last_log -> last_log.1 -> last_log.2 -> ... -> last_log.$max  
    288. // Overwrites any existing last_log.$max.  
    289. static void  
    290. rotate_last_logs(int max) {  
    291.     char oldfn[256];  
    292.     char newfn[256];  
    293.   
    294.     int i;  
    295.     for (i = max-1; i >= 0; --i) {  
    296.         snprintf(oldfn, sizeof(oldfn), (i==0) ? LAST_LOG_FILE : (LAST_LOG_FILE ".%d"), i);  
    297.         snprintf(newfn, sizeof(newfn), LAST_LOG_FILE ".%d", i+1);  
    298.         // ignore errors  
    299.         rename(oldfn, newfn);  
    300.     }  
    301. }  
    302.   
    303. static void  
    304. copy_logs() {  
    305.     // Copy logs to cache so the system can find out what happened.  
    306.     copy_log_file(TEMPORARY_LOG_FILE, LOG_FILE, true);  
    307.     copy_log_file(TEMPORARY_LOG_FILE, LAST_LOG_FILE, false);  
    308.     copy_log_file(TEMPORARY_INSTALL_FILE, LAST_INSTALL_FILE, false);  
    309.     chmod(LOG_FILE, 0600);  
    310.     chown(LOG_FILE, 1000, 1000);   // system user  
    311.     chmod(LAST_LOG_FILE, 0640);  
    312.     chmod(LAST_INSTALL_FILE, 0644);  
    313.     sync();  
    314. }  
    315.   
    316. // clear the recovery command and prepare to boot a (hopefully working) system,  
    317. // copy our log file to cache as well (for the system to read), and  
    318. // record any intent we were asked to communicate back to the system.  
    319. // this function is idempotent: call it as many times as you like.  
    320. static void  
    321. finish_recovery(const char *send_intent) {  
    322.     // By this point, we're ready to return to the main system...  
    323.     if (send_intent != NULL) {  
    324.         FILE *fp = fopen_path(INTENT_FILE, "w");  
    325.         if (fp == NULL) {  
    326.             LOGE("Can't open %s ", INTENT_FILE);  
    327.         } else {  
    328.             fputs(send_intent, fp);  
    329.             check_and_fclose(fp, INTENT_FILE);  
    330.         }  
    331.     }  
    332.   
    333.     // Save the locale to cache, so if recovery is next started up  
    334.     // without a --locale argument (eg, directly from the bootloader)  
    335.     // it will use the last-known locale.  
    336.     if (locale != NULL) {  
    337.         LOGI("Saving locale "%s" ", locale);  
    338.         FILE* fp = fopen_path(LOCALE_FILE, "w");  
    339.         fwrite(locale, 1, strlen(locale), fp);  
    340.         fflush(fp);  
    341.         fsync(fileno(fp));  
    342.         check_and_fclose(fp, LOCALE_FILE);  
    343.     }  
    344.   
    345.     copy_logs();  
    346.   
    347.     // Reset to normal system boot so recovery won't cycle indefinitely.  
    348.     struct bootloader_message boot;  
    349.     memset(&boot, 0, sizeof(boot));  
    350.     set_bootloader_message(&boot);  
    351.   
    352.     // Remove the command file, so recovery won't repeat indefinitely.  
    353.     if (ensure_path_mounted(COMMAND_FILE) != 0 ||  
    354.         (unlink(COMMAND_FILE) && errno != ENOENT)) {  
    355.         LOGW("Can't unlink %s ", COMMAND_FILE);  
    356.     }  
    357.   
    358.     ensure_path_unmounted(CACHE_ROOT);  
    359.     sync();  // For good measure.  
    360. }  
    361.   
    362. typedef struct _saved_log_file {  
    363.     char* name;  
    364.     struct stat st;  
    365.     unsigned char* data;  
    366.     struct _saved_log_file* next;  
    367. } saved_log_file;  
    368.   
    369. static int  
    370. erase_volume(const char *volume) {  
    371.     bool is_cache = (strcmp(volume, CACHE_ROOT) == 0);  
    372.   
    373.     ui->SetBackground(RecoveryUI::ERASING);  
    374.     ui->SetProgressType(RecoveryUI::INDETERMINATE);  
    375.   
    376.     saved_log_file* head = NULL;  
    377.   
    378.     if (is_cache) {  
    379.         // If we're reformatting /cache, we load any  
    380.         // "/cache/recovery/last*" files into memory, so we can restore  
    381.         // them after the reformat.  
    382.   
    383.         ensure_path_mounted(volume);  
    384.   
    385.         DIR* d;  
    386.         struct dirent* de;  
    387.         d = opendir(CACHE_LOG_DIR);  
    388.         if (d) {  
    389.             char path[PATH_MAX];  
    390.             strcpy(path, CACHE_LOG_DIR);  
    391.             strcat(path, "/");  
    392.             int path_len = strlen(path);  
    393.             while ((de = readdir(d)) != NULL) {  
    394.                 if (strncmp(de->d_name, "last", 4) == 0) {  
    395.                     saved_log_file* p = (saved_log_file*) malloc(sizeof(saved_log_file));  
    396.                     strcpy(path+path_len, de->d_name);  
    397.                     p->name = strdup(path);  
    398.                     if (stat(path, &(p->st)) == 0) {  
    399.                         // truncate files to 512kb  
    400.                         if (p->st.st_size > (1 << 19)) {  
    401.                             p->st.st_size = 1 << 19;  
    402.                         }  
    403.                         p->data = (unsigned char*) malloc(p->st.st_size);  
    404.                         FILE* f = fopen(path, "rb");  
    405.                         fread(p->data, 1, p->st.st_size, f);  
    406.                         fclose(f);  
    407.                         p->next = head;  
    408.                         head = p;  
    409.                     } else {  
    410.                         free(p);  
    411.                     }  
    412.                 }  
    413.             }  
    414.             closedir(d);  
    415.         } else {  
    416.             if (errno != ENOENT) {  
    417.                 printf("opendir failed: %s ", strerror(errno));  
    418.             }  
    419.         }  
    420.     }  
    421.   
    422.     ui->Print("Formatting %s... ", volume);  
    423.   
    424.     ensure_path_unmounted(volume);  
    425.     int result = format_volume(volume);  
    426.   
    427.     if (is_cache) {  
    428.         while (head) {  
    429.             FILE* f = fopen_path(head->name, "wb");  
    430.             if (f) {  
    431.                 fwrite(head->data, 1, head->st.st_size, f);  
    432.                 fclose(f);  
    433.                 chmod(head->name, head->st.st_mode);  
    434.                 chown(head->name, head->st.st_uid, head->st.st_gid);  
    435.             }  
    436.             free(head->name);  
    437.             free(head->data);  
    438.             saved_log_file* temp = head->next;  
    439.             free(head);  
    440.             head = temp;  
    441.         }  
    442.   
    443.         // Any part of the log we'd copied to cache is now gone.  
    444.         // Reset the pointer so we copy from the beginning of the temp  
    445.         // log.  
    446.         tmplog_offset = 0;  
    447.         copy_logs();  
    448.     }  
    449.   
    450.     return result;  
    451. }  
    452.   
    453. static const char**  
    454. prepend_title(const char* const* headers) {  
    455.     // count the number of lines in our title, plus the  
    456.     // caller-provided headers.  
    457.     int count = 3;   // our title has 3 lines  
    458.     const char* const* p;  
    459.     for (p = headers; *p; ++p, ++count);  
    460.   
    461.     const char** new_headers = (const char**)malloc((count+1) * sizeof(char*));  
    462.     const char** h = new_headers;  
    463.     *(h++) = "Android system recovery <" EXPAND(RECOVERY_API_VERSION) "e>";  
    464.     *(h++) = recovery_version;  
    465.     *(h++) = "";  
    466.     for (p = headers; *p; ++p, ++h) *h = *p;  
    467.     *h = NULL;  
    468.   
    469.     return new_headers;  
    470. }  
    471.   
    472. static int  
    473. get_menu_selection(const char* const * headers, const char* const * items,  
    474.                    int menu_only, int initial_selection, Device* device) {  
    475.     // throw away keys pressed previously, so user doesn't  
    476.     // accidentally trigger menu items.  
    477.     ui->FlushKeys();  
    478.   
    479.     ui->StartMenu(headers, items, initial_selection);  
    480.     int selected = initial_selection;  
    481.     int chosen_item = -1;  
    482.   
    483.     while (chosen_item < 0) {  
    484.         int key = ui->WaitKey();  
    485.         int visible = ui->IsTextVisible();  
    486.   
    487.         if (key == -1) {   // ui_wait_key() timed out  
    488.             if (ui->WasTextEverVisible()) {  
    489.                 continue;  
    490.             } else {  
    491.                 LOGI("timed out waiting for key input; rebooting. ");  
    492.                 ui->EndMenu();  
    493.                 return 0; // XXX fixme  
    494.             }  
    495.         }  
    496.   
    497.         int action = device->HandleMenuKey(key, visible);  
    498.   
    499.         if (action < 0) {  
    500.             switch (action) {  
    501.                 case Device::kHighlightUp:  
    502.                     --selected;  
    503.                     selected = ui->SelectMenu(selected);  
    504.                     break;  
    505.                 case Device::kHighlightDown:  
    506.                     ++selected;  
    507.                     selected = ui->SelectMenu(selected);  
    508.                     break;  
    509.                 case Device::kInvokeItem:  
    510.                     chosen_item = selected;  
    511.                     break;  
    512.                 case Device::kNoAction:  
    513.                     break;  
    514.             }  
    515.         } else if (!menu_only) {  
    516.             chosen_item = action;  
    517.         }  
    518.     }  
    519.   
    520.     ui->EndMenu();  
    521.     return chosen_item;  
    522. }  
    523.   
    524. static int compare_string(const void* a, const void* b) {  
    525.     return strcmp(*(const char**)a, *(const char**)b);  
    526. }  
    527.   
    528. // Returns a malloc'd path, or NULL.  
    529. static char*  
    530. browse_directory(const char* path, Device* device) {  
    531.     ensure_path_mounted(path);  
    532.   
    533.     const char* MENU_HEADERS[] = { "Choose a package to install:",  
    534.                                    path,  
    535.                                    "",  
    536.                                    NULL };  
    537.     DIR* d;  
    538.     struct dirent* de;  
    539.     d = opendir(path);  
    540.     if (d == NULL) {  
    541.         LOGE("error opening %s: %s ", path, strerror(errno));  
    542.         return NULL;  
    543.     }  
    544.   
    545.     const char** headers = prepend_title(MENU_HEADERS);  
    546.   
    547.     int d_size = 0;  
    548.     int d_alloc = 10;  
    549.     char** dirs = (char**)malloc(d_alloc * sizeof(char*));  
    550.     int z_size = 1;  
    551.     int z_alloc = 10;  
    552.     char** zips = (char**)malloc(z_alloc * sizeof(char*));  
    553.     zips[0] = strdup("../");  
    554.   
    555.     while ((de = readdir(d)) != NULL) {  
    556.         int name_len = strlen(de->d_name);  
    557.   
    558.         if (de->d_type == DT_DIR) {  
    559.             // skip "." and ".." entries  
    560.             if (name_len == 1 && de->d_name[0] == '.') continue;  
    561.             if (name_len == 2 && de->d_name[0] == '.' &&  
    562.                 de->d_name[1] == '.') continue;  
    563.   
    564.             if (d_size >= d_alloc) {  
    565.                 d_alloc *= 2;  
    566.                 dirs = (char**)realloc(dirs, d_alloc * sizeof(char*));  
    567.             }  
    568.             dirs[d_size] = (char*)malloc(name_len + 2);  
    569.             strcpy(dirs[d_size], de->d_name);  
    570.             dirs[d_size][name_len] = '/';  
    571.             dirs[d_size][name_len+1] = '';  
    572.             ++d_size;  
    573.         } else if (de->d_type == DT_REG &&  
    574.                    name_len >= 4 &&  
    575.                    strncasecmp(de->d_name + (name_len-4), ".zip", 4) == 0) {  
    576.             if (z_size >= z_alloc) {  
    577.                 z_alloc *= 2;  
    578.                 zips = (char**)realloc(zips, z_alloc * sizeof(char*));  
    579.             }  
    580.             zips[z_size++] = strdup(de->d_name);  
    581.         }  
    582.     }  
    583.     closedir(d);  
    584.   
    585.     qsort(dirs, d_size, sizeof(char*), compare_string);  
    586.     qsort(zips, z_size, sizeof(char*), compare_string);  
    587.   
    588.     // append dirs to the zips list  
    589.     if (d_size + z_size + 1 > z_alloc) {  
    590.         z_alloc = d_size + z_size + 1;  
    591.         zips = (char**)realloc(zips, z_alloc * sizeof(char*));  
    592.     }  
    593.     memcpy(zips + z_size, dirs, d_size * sizeof(char*));  
    594.     free(dirs);  
    595.     z_size += d_size;  
    596.     zips[z_size] = NULL;  
    597.   
    598.     char* result;  
    599.     int chosen_item = 0;  
    600.     while (true) {  
    601.         chosen_item = get_menu_selection(headers, zips, 1, chosen_item, device);  
    602.   
    603.         char* item = zips[chosen_item];  
    604.         int item_len = strlen(item);  
    605.         if (chosen_item == 0) {          // item 0 is always "../"  
    606.             // go up but continue browsing (if the caller is update_directory)  
    607.             result = NULL;  
    608.             break;  
    609.         }  
    610.   
    611.         char new_path[PATH_MAX];  
    612.         strlcpy(new_path, path, PATH_MAX);  
    613.         strlcat(new_path, "/", PATH_MAX);  
    614.         strlcat(new_path, item, PATH_MAX);  
    615.   
    616.         if (item[item_len-1] == '/') {  
    617.             // recurse down into a subdirectory  
    618.             new_path[strlen(new_path)-1] = '';  // truncate the trailing '/'  
    619.             result = browse_directory(new_path, device);  
    620.             if (result) break;  
    621.         } else {  
    622.             // selected a zip file: return the malloc'd path to the caller.  
    623.             result = strdup(new_path);  
    624.             break;  
    625.         }  
    626.     }  
    627.   
    628.     int i;  
    629.     for (i = 0; i < z_size; ++i) free(zips[i]);  
    630.     free(zips);  
    631.     free(headers);  
    632.   
    633.     return result;  
    634. }  
    635.   
    636. static void  
    637. wipe_data(int confirm, Device* device) {  
    638.     if (confirm) {  
    639.         static const char** title_headers = NULL;  
    640.   
    641.         if (title_headers == NULL) {  
    642.             const char* headers[] = { "Confirm wipe of all user data?",  
    643.                                       "  THIS CAN NOT BE UNDONE.",  
    644.                                       "",  
    645.                                       NULL };  
    646.             title_headers = prepend_title((const char**)headers);  
    647.         }  
    648.   
    649.         const char* items[] = { " No",  
    650.                                 " No",  
    651.                                 " No",  
    652.                                 " No",  
    653.                                 " No",  
    654.                                 " No",  
    655.                                 " No",  
    656.                                 " Yes -- delete all user data",   // [7]  
    657.                                 " No",  
    658.                                 " No",  
    659.                                 " No",  
    660.                                 NULL };  
    661.   
    662.         int chosen_item = get_menu_selection(title_headers, items, 1, 0, device);  
    663.         if (chosen_item != 7) {  
    664.             return;  
    665.         }  
    666.     }  
    667.   
    668.     ui->Print(" -- Wiping data... ");  
    669.     device->WipeData();  
    670.     erase_volume("/data");  
    671.     erase_volume("/cache");  
    672.     erase_persistent_partition();  
    673.     ui->Print("Data wipe complete. ");  
    674. }  
    675.   
    676. static void file_to_ui(const char* fn) {  
    677.     FILE *fp = fopen_path(fn, "re");  
    678.     if (fp == NULL) {  
    679.         ui->Print("  Unable to open %s: %s ", fn, strerror(errno));  
    680.         return;  
    681.     }  
    682.     char line[1024];  
    683.     int ct = 0;  
    684.     redirect_stdio("/dev/null");  
    685.     while(fgets(line, sizeof(line), fp) != NULL) {  
    686.         ui->Print("%s", line);  
    687.         ct++;  
    688.         if (ct % 30 == 0) {  
    689.             // give the user time to glance at the entries  
    690.             ui->WaitKey();  
    691.         }  
    692.     }  
    693.     redirect_stdio(TEMPORARY_LOG_FILE);  
    694.     fclose(fp);  
    695. }  
    696.   
    697. static void choose_recovery_file(Device* device) {  
    698.     int i;  
    699.     static const char** title_headers = NULL;  
    700.     char *filename;  
    701.     const char* headers[] = { "Select file to view",  
    702.                               "",  
    703.                               NULL };  
    704.     char* entries[KEEP_LOG_COUNT + 2];  
    705.     memset(entries, 0, sizeof(entries));  
    706.   
    707.     for (i = 0; i < KEEP_LOG_COUNT; i++) {  
    708.         char *filename;  
    709.         if (asprintf(&filename, (i==0) ? LAST_LOG_FILE : (LAST_LOG_FILE ".%d"), i) == -1) {  
    710.             // memory allocation failure - return early. Should never happen.  
    711.             return;  
    712.         }  
    713.         if ((ensure_path_mounted(filename) != 0) || (access(filename, R_OK) == -1)) {  
    714.             free(filename);  
    715.             entries[i+1] = NULL;  
    716.             break;  
    717.         }  
    718.         entries[i+1] = filename;  
    719.     }  
    720.   
    721.     entries[0] = strdup("Go back");  
    722.     title_headers = prepend_title((const char**)headers);  
    723.   
    724.     while(1) {  
    725.         int chosen_item = get_menu_selection(title_headers, entries, 1, 0, device);  
    726.         if (chosen_item == 0) break;  
    727.         file_to_ui(entries[chosen_item]);  
    728.     }  
    729.   
    730.     for (i = 0; i < KEEP_LOG_COUNT + 1; i++) {  
    731.         free(entries[i]);  
    732.     }  
    733. }  
    734.   
    735. // Return REBOOT, SHUTDOWN, or REBOOT_BOOTLOADER.  Returning NO_ACTION  
    736. // means to take the default, which is to reboot or shutdown depending  
    737. // on if the --shutdown_after flag was passed to recovery.  
    738. static Device::BuiltinAction  
    739. prompt_and_wait(Device* device, int status) {  
    740.     const char* const* headers = prepend_title(device->GetMenuHeaders());  
    741.   
    742.     for (;;) {  
    743.         finish_recovery(NULL);  
    744.         switch (status) {  
    745.             case INSTALL_SUCCESS:  
    746.             case INSTALL_NONE:  
    747.                 ui->SetBackground(RecoveryUI::NO_COMMAND);  
    748.                 break;  
    749.   
    750.             case INSTALL_ERROR:  
    751.             case INSTALL_CORRUPT:  
    752.                 ui->SetBackground(RecoveryUI::ERROR);  
    753.                 break;  
    754.         }  
    755.         ui->SetProgressType(RecoveryUI::EMPTY);  
    756.   
    757.         int chosen_item = get_menu_selection(headers, device->GetMenuItems(), 0, 0, device);  
    758.   
    759.         // device-specific code may take some action here.  It may  
    760.         // return one of the core actions handled in the switch  
    761.         // statement below.  
    762.         Device::BuiltinAction chosen_action = device->InvokeMenuItem(chosen_item);  
    763.   
    764.         int wipe_cache = 0;  
    765.         switch (chosen_action) {  
    766.             case Device::NO_ACTION:  
    767.                 break;  
    768.   
    769.             case Device::REBOOT:  
    770.             case Device::SHUTDOWN:  
    771.             case Device::REBOOT_BOOTLOADER:  
    772.                 return chosen_action;  
    773.   
    774.             case Device::WIPE_DATA:  
    775.                 wipe_data(ui->IsTextVisible(), device);  
    776.                 if (!ui->IsTextVisible()) return Device::NO_ACTION;  
    777.                 break;  
    778.   
    779.             case Device::WIPE_CACHE:  
    780.                 ui->Print(" -- Wiping cache... ");  
    781.                 erase_volume("/cache");  
    782.                 ui->Print("Cache wipe complete. ");  
    783.                 if (!ui->IsTextVisible()) return Device::NO_ACTION;  
    784.                 break;  
    785.   
    786.             case Device::APPLY_EXT: {  
    787.                 ensure_path_mounted(SDCARD_ROOT);  
    788.                 char* path = browse_directory(SDCARD_ROOT, device);  
    789.                 if (path == NULL) {  
    790.                     ui->Print(" -- No package file selected. ", path);  
    791.                     break;  
    792.                 }  
    793.   
    794.                 ui->Print(" -- Install %s ... ", path);  
    795.                 set_sdcard_update_bootloader_message();  
    796.                 void* token = start_sdcard_fuse(path);  
    797.   
    798.                 int status = install_package(FUSE_SIDELOAD_HOST_PATHNAME, &wipe_cache,  
    799.                                              TEMPORARY_INSTALL_FILE, false);  
    800.   
    801.                 finish_sdcard_fuse(token);  
    802.                 ensure_path_unmounted(SDCARD_ROOT);  
    803.   
    804.                 if (status == INSTALL_SUCCESS && wipe_cache) {  
    805.                     ui->Print(" -- Wiping cache (at package request)... ");  
    806.                     if (erase_volume("/cache")) {  
    807.                         ui->Print("Cache wipe failed. ");  
    808.                     } else {  
    809.                         ui->Print("Cache wipe complete. ");  
    810.                     }  
    811.                 }  
    812.   
    813.                 if (status >= 0) {  
    814.                     if (status != INSTALL_SUCCESS) {  
    815.                         ui->SetBackground(RecoveryUI::ERROR);  
    816.                         ui->Print("Installation aborted. ");  
    817.                     } else if (!ui->IsTextVisible()) {  
    818.                         return Device::NO_ACTION;  // reboot if logs aren't visible  
    819.                     } else {  
    820.                         ui->Print(" Install from sdcard complete. ");  
    821.                     }  
    822.                 }  
    823.                 break;  
    824.             }  
    825.   
    826.             case Device::APPLY_CACHE:  
    827.                 ui->Print(" APPLY_CACHE is deprecated. ");  
    828.                 break;  
    829.   
    830.             case Device::READ_RECOVERY_LASTLOG:  
    831.                 choose_recovery_file(device);  
    832.                 break;  
    833.   
    834.             case Device::APPLY_ADB_SIDELOAD:  
    835.                 status = apply_from_adb(ui, &wipe_cache, TEMPORARY_INSTALL_FILE);  
    836.                 if (status >= 0) {  
    837.                     if (status != INSTALL_SUCCESS) {  
    838.                         ui->SetBackground(RecoveryUI::ERROR);  
    839.                         ui->Print("Installation aborted. ");  
    840.                         copy_logs();  
    841.                     } else if (!ui->IsTextVisible()) {  
    842.                         return Device::NO_ACTION;  // reboot if logs aren't visible  
    843.                     } else {  
    844.                         ui->Print(" Install from ADB complete. ");  
    845.                     }  
    846.                 }  
    847.                 break;  
    848.         }  
    849.     }  
    850. }  
    851.   
    852. static void  
    853. print_property(const char *key, const char *name, void *cookie) {  
    854.     printf("%s=%s ", key, name);  
    855. }  
    856.   
    857. static void  
    858. load_locale_from_cache() {  
    859.     FILE* fp = fopen_path(LOCALE_FILE, "r");  
    860.     char buffer[80];  
    861.     if (fp != NULL) {  
    862.         fgets(buffer, sizeof(buffer), fp);  
    863.         int j = 0;  
    864.         unsigned int i;  
    865.         for (i = 0; i < sizeof(buffer) && buffer[i]; ++i) {  
    866.             if (!isspace(buffer[i])) {  
    867.                 buffer[j++] = buffer[i];  
    868.             }  
    869.         }  
    870.         buffer[j] = 0;  
    871.         locale = strdup(buffer);  
    872.         check_and_fclose(fp, LOCALE_FILE);  
    873.     }  
    874. }  
    875.   
    876. static RecoveryUI* gCurrentUI = NULL;  
    877.   
    878. void  
    879. ui_print(const char* format, ...) {  
    880.     char buffer[256];  
    881.   
    882.     va_list ap;  
    883.     va_start(ap, format);  
    884.     vsnprintf(buffer, sizeof(buffer), format, ap);  
    885.     va_end(ap);  
    886.   
    887.     if (gCurrentUI != NULL) {  
    888.         gCurrentUI->Print("%s", buffer);  
    889.     } else {  
    890.         fputs(buffer, stdout);  
    891.     }  
    892. }  
    893.   
    894. int  
    895. main(int argc, char **argv) {  
    896.     time_t start = time(NULL);  
    897.   
    898.     //重定向标准输出和标准出错到/tmp/recovery.log 这个文件里  
    899.     //static const char *TEMPORARY_LOG_FILE = "/tmp/recovery.log";  
    900.     redirect_stdio(TEMPORARY_LOG_FILE);  
    901.   
    902.     // If this binary is started with the single argument "--adbd",  
    903.     // instead of being the normal recovery binary, it turns into kind  
    904.     // of a stripped-down version of adbd that only supports the  
    905.     // 'sideload' command.  Note this must be a real argument, not  
    906.     // anything in the command file or bootloader control block; the  
    907.     // only way recovery should be run with this argument is when it  
    908.     // starts a copy of itself from the apply_from_adb() function.  
    909.     if (argc == 2 && strcmp(argv[1], "--adbd") == 0) {  
    910.         adb_main();  
    911.         return 0;  
    912.     }  
    913.   
    914.     printf("Starting recovery (pid %d) on %s", getpid(), ctime(&start));  
    915.     //装载recovery的分区表recovery.fstab  
    916.     load_volume_table();  
    917.     //在recovery中挂载/cache/recovery/last_log这个文件  
    918.     //#define LAST_LOG_FILE "/cache/recovery/last_log"  
    919.     ensure_path_mounted(LAST_LOG_FILE);  
    920.     rotate_last_logs(KEEP_LOG_COUNT);  
    921.     //获取参数  
    922.     //这个参数也可能是从/cache/recovery/command文件中得到相应的命令  
    923.     //也就是可以往command这个文件写入对应的格式的命令即可  
    924.     get_args(&argc, &argv);  
    925.   
    926.     const char *send_intent = NULL;  
    927.     const char *update_package = NULL;  
    928.     int wipe_data = 0, wipe_cache = 0, show_text = 0;  
    929.     bool just_exit = false;  
    930.     bool shutdown_after = false;  
    931.   
    932.     int arg;  
    933.     //参数有擦除分区，OTA更新等  
    934.     while ((arg = getopt_long(argc, argv, "", OPTIONS, NULL)) != -1) {  
    935.         switch (arg) {  
    936.         case 's': send_intent = optarg; break;  
    937.         case 'u': update_package = optarg; break;  
    938.         case 'w': wipe_data = wipe_cache = 1; break;  
    939.         case 'c': wipe_cache = 1; break;  
    940.         case 't': show_text = 1; break;  
    941.         case 'x': just_exit = true; break;  
    942.         case 'l': locale = optarg; break;  
    943.         case 'g': {  
    944.             if (stage == NULL || *stage == '') {  
    945.                 char buffer[20] = "1/";  
    946.                 strncat(buffer, optarg, sizeof(buffer)-3);  
    947.                 stage = strdup(buffer);  
    948.             }  
    949.             break;  
    950.         }  
    951.         case 'p': shutdown_after = true; break;  
    952.         case 'r': reason = optarg; break;  
    953.         case '?':  
    954.             LOGE("Invalid command argument ");  
    955.             continue;  
    956.         }  
    957.     }  
    958.     //设置语言  
    959.     if (locale == NULL) {  
    960.         load_locale_from_cache();  
    961.     }  
    962.     printf("locale is [%s] ", locale);  
    963.     printf("stage is [%s] ", stage);  
    964.     printf("reason is [%s] ", reason);  
    965.     //创建设备  
    966.     Device* device = make_device();  
    967.     //获取UI  
    968.     ui = device->GetUI();  
    969.     //设置当前的UI  
    970.     gCurrentUI = ui;  
    971.     //设置UI的语言信息  
    972.     ui->SetLocale(locale);  
    973.     //UI初始化  
    974.     ui->Init();  
    975.   
    976.     int st_cur, st_max;  
    977.     if (stage != NULL && sscanf(stage, "%d/%d", &st_cur, &st_max) == 2) {  
    978.         ui->SetStage(st_cur, st_max);  
    979.     }  
    980.     //设置recovery的背景图  
    981.     ui->SetBackground(RecoveryUI::NONE);  
    982.     //设置界面上是否能够显示字符，使能ui->print函数开关  
    983.     if (show_text) ui->ShowText(true);  
    984.     //设置selinux权限，一般我会把selinux 给disabled  
    985.     struct selinux_opt seopts[] = {  
    986.       { SELABEL_OPT_PATH, "/file_contexts" }  
    987.     };  
    988.   
    989.     sehandle = selabel_open(SELABEL_CTX_FILE, seopts, 1);  
    990.   
    991.     if (!sehandle) {  
    992.         ui->Print("Warning: No file_contexts ");  
    993.     }  
    994.     //虚函数，没有做什么流程  
    995.     device->StartRecovery();  
    996.   
    997.     printf("Command:");  
    998.     for (arg = 0; arg < argc; arg++) {  
    999.         printf(" "%s"", argv[arg]);  
    1000.     }  
    1001.     printf(" ");  
    1002.     //如果update_package(也就是要升级的OTA包)不为空的情况下  
    1003.     //这里要对升级包的路径做一下路径转换，这里可以自由定制自己升级包的路径  
    1004.     if (update_package) {  
    1005.         // For backwards compatibility on the cache partition only, if  
    1006.         // we're given an old 'root' path "CACHE:foo", change it to  
    1007.         // "/cache/foo".  
    1008.   
    1009.         //这里就是做转换的方法  
    1010.         //先比较传进来的recovery参数的前6个byte是否是CACHE  
    1011.         //如果是将其路径转化为/cache/CACHE: ......  
    1012.         if (strncmp(update_package, "CACHE:", 6) == 0) {  
    1013.             int len = strlen(update_package) + 10;  
    1014.             char* modified_path = (char*)malloc(len);  
    1015.             strlcpy(modified_path, "/cache/", len);  
    1016.             strlcat(modified_path, update_package+6, len);  
    1017.             printf("(replacing path "%s" with "%s") ",  
    1018.                    update_package, modified_path);  
    1019.             //这个update_package就是转换后的路径  
    1020.             update_package = modified_path;  
    1021.         }  
    1022.     }  
    1023.     printf(" ");  
    1024.     property_list(print_property, NULL);  
    1025.     //获取属性，这里应该是从一个文件中找到ro.build.display.id  
    1026.     //获取recovery的版本信息  
    1027.     property_get("ro.build.display.id", recovery_version, "");  
    1028.     printf(" ");  
    1029.   
    1030.     //定义一个安装成功的标志位INSTALL_SUCCESS  ----> 其实是个枚举，值为0  
    1031.     int status = INSTALL_SUCCESS;  
    1032.     //判断转换后的OTA升级包的路径是否不为空，如果不为空  
    1033.     //执行install_package 函数进行升级  
    1034.     if (update_package != NULL) {  
    1035.         status = install_package(update_package, &wipe_cache, TEMPORARY_INSTALL_FILE, true);  
    1036.         //判断是否升级成功  
    1037.         if (status == INSTALL_SUCCESS && wipe_cache) {  
    1038.             //擦除这个路径，相当于删除了这个路径下的OTA升级包  
    1039.             if (erase_volume("/cache")) {  
    1040.                 LOGE("Cache wipe (requested by package) failed.");  
    1041.             }  
    1042.         }  
    1043.         //如果安装不成功  
    1044.         if (status != INSTALL_SUCCESS) {  
    1045.             ui->Print("Installation aborted. ");  
    1046.   
    1047.             // If this is an eng or userdebug build, then automatically  
    1048.             // turn the text display on if the script fails so the error  
    1049.             // message is visible.  
    1050.             char buffer[PROPERTY_VALUE_MAX+1];  
    1051.             property_get("ro.build.fingerprint", buffer, "");  
    1052.             if (strstr(buffer, ":userdebug/") || strstr(buffer, ":eng/")) {  
    1053.                 ui->ShowText(true);  
    1054.             }  
    1055.         }  
    1056.     }  
    1057.     //如果跑的是格式化数据区，那么就走这个流程  
    1058.     else if (wipe_data) {  
    1059.         if (device->WipeData()) status = INSTALL_ERROR;  
    1060.         //格式化/data分区  
    1061.         if (erase_volume("/data")) status = INSTALL_ERROR;  
    1062.         if (wipe_cache && erase_volume("/cache")) status = INSTALL_ERROR;  
    1063.         if (erase_persistent_partition() == -1 ) status = INSTALL_ERROR;  
    1064.         if (status != INSTALL_SUCCESS) ui->Print("Data wipe failed. ");  
    1065.     }   
    1066.     //格式化cache分区  
    1067.     else if (wipe_cache) {  
    1068.         if (wipe_cache && erase_volume("/cache")) status = INSTALL_ERROR;  
    1069.         if (status != INSTALL_SUCCESS) ui->Print("Cache wipe failed. ");  
    1070.     }   
    1071.     else if (!just_exit) {  
    1072.         status = INSTALL_NONE;  // No command specified  
    1073.         ui->SetBackground(RecoveryUI::NO_COMMAND);  
    1074.     }  
    1075.     //如果安装失败或者。。。  
    1076.     if (status == INSTALL_ERROR || status == INSTALL_CORRUPT) {  
    1077.         copy_logs();  
    1078.         //显示错误的LOGO  
    1079.         ui->SetBackground(RecoveryUI::ERROR);  
    1080.     }  
    1081.     Device::BuiltinAction after = shutdown_after ? Device::SHUTDOWN : Device::REBOOT;  
    1082.     if (status != INSTALL_SUCCESS || ui->IsTextVisible()) {  
    1083.         Device::BuiltinAction temp = prompt_and_wait(device, status);  
    1084.         if (temp != Device::NO_ACTION) after = temp;  
    1085.     }  
    1086.       
    1087.     // Save logs and clean up before rebooting or shutting down.  
    1088.     //完成recovery升级  
    1089.     finish_recovery(send_intent);  
    1090.   
    1091.     switch (after) {  
    1092.         case Device::SHUTDOWN:  
    1093.             ui->Print("Shutting down... ");  
    1094.             property_set(ANDROID_RB_PROPERTY, "shutdown,");  
    1095.             break;  
    1096.   
    1097.         case Device::REBOOT_BOOTLOADER:  
    1098.             ui->Print("Rebooting to bootloader... ");  
    1099.             property_set(ANDROID_RB_PROPERTY, "reboot,bootloader");  
    1100.             break;  
    1101.   
    1102.         default:  
    1103.             ui->Print("Rebooting... ");  
    1104.             property_set(ANDROID_RB_PROPERTY, "reboot,");  
    1105.             break;  
    1106.     }  
    1107.     sleep(5); // should reboot before this finishes  
    1108.     return EXIT_SUCCESS;  
    1109. }  
  • 相关阅读:
    elk2
    elk
    skywalking学习ppt
    Spring Boot]SpringBoot四大神器之Actuator
    黑马程序员spring data jpa 2019年第一版本
    css总结7：盒子模型理解
    css总结5：px、em、rem区别介绍
    css总结4：input 去掉外边框,placeholder的字体颜色、字号
    css总结3：Flex 布局教程：Flex-demos（转）
    css总结2：Flex 布局教程：Flex 语法（转）
  • 原文地址：https://www.cnblogs.com/zzb-Dream-90Time/p/7300790.html
Copyright © 2011-2022 走看看