C++ confirm_selection函数代码示例

void show_nandroid_advanced_backup_menu()
{
    if (ensure_root_path_mounted("SDCARD:") != 0) {
        LOGE ("Can't mount /sdcard\n");
        return;
    }

    static char* headers[] = {  "Nandroid Advanced Backup",
                                "",
                                NULL
    };

    static char* list[] = { "Backup boot",
                            "Backup system",
                            "Backup data",
                            "Backup cache",
                            "Backup sd-ext",
                            NULL
    };

    char backup_path[PATH_MAX];
                time_t t = time(NULL);
                struct tm *tmp = localtime(&t);
                if (tmp == NULL)
                {
                    struct timeval tp;
                    gettimeofday(&tp, NULL);
                    sprintf(backup_path, "/sdcard/clockworkmod/backup/%d", tp.tv_sec);
                }
                else
                {
                    strftime(backup_path, sizeof(backup_path), "/sdcard/clockworkmod/backup/%F.%H.%M.%S", tmp);
                }
    static char* confirm_restore  = "Confirm backup?";

    int chosen_item = get_menu_selection(headers, list, 0);
    switch (chosen_item)
    {
        case 0:
            if (confirm_selection(confirm_restore, "Yes - Backup boot"))
                nandroid_backup_boot(backup_path);
            break;
        case 1:
            if (confirm_selection(confirm_restore, "Yes - Backup system"))
                nandroid_backup_system(backup_path);
            break;
        case 2:
            if (confirm_selection(confirm_restore, "Yes - Backup data"))
                nandroid_backup_data(backup_path);
            break;
        case 3:
            if (confirm_selection(confirm_restore, "Yes - Backup cache"))
                nandroid_backup_cache(backup_path);
            break;
        case 4:
            if (confirm_selection(confirm_restore, "Yes - Backup sd-ext"))
                nandroid_backup_sd(backup_path);;
            break;
    }
}

void erase_cache(int orscallback) {
	if(orscallback) {
		if(orswipeprompt && !confirm_selection("Confirm wipe?","Yes - Wipe Cache")) {
			ui_print("Skipping cache wipe...\n");
			return;
		}
    } else if (!confirm_selection("Confirm wipe?","Yes - Wipe Cache")) {
		return;
	}
    ui_print("\n-- Wiping cache...\n");
    erase_volume("/cache");
    ui_print("%s\n", cachewipecomplete);
    if (!ui_text_visible()) return;
    return;
}

void show_nandroid_restore_menu()
{
    const char* sdcard_path;
    char* backup_path[PATH_MAX];

    if (target_sdcard == TARGET_INTERNAL_SDCARD) {
        sdcard_path = INTERNAL_SDCARD_PATH;
    } else {
        sdcard_path = EXTERNAL_SDCARD_PATH;
    }

    if (ensure_path_mounted(sdcard_path) != 0) {
        LOGE ("Can't mount %s\n", sdcard_path);
        return;
    }

    static char* headers[] = {  "Choose an image to restore",
                                "",
                                NULL
    };

    sprintf(backup_path, "%s/clockworkmod/backup/", sdcard_path);
    char* file = choose_file_menu(backup_path, NULL, headers);
    if (file == NULL)
        return;

    if (confirm_selection("Confirm restore?", "Yes - Restore"))
        nandroid_restore(file, 1, 1, 1, 1, 1, 0);
}

void show_install_update_menu()
{
    static char* headers[] = {  "Apply update from .zip file on SD card",
                                "",
                                NULL
    };
    for (;;)
    {
        int chosen_item = get_menu_selection(headers, INSTALL_MENU_ITEMS, 0, 0);
        switch (chosen_item)
        {
            case ITEM_ASSERTS:
                toggle_script_asserts();
                break;
            case ITEM_SIG_CHECK:
                toggle_signature_check();
                break;
            case ITEM_APPLY_SDCARD:
            {
                if (confirm_selection("Confirm install?", "Yes - Install /sdcard/update.zip"))
                    install_zip(SDCARD_UPDATE_FILE);
                break;
            }
            case ITEM_CHOOSE_ZIP:
                show_choose_zip_menu();
                break;
            default:
                return;
        }

    }
}

static void
prompt_and_wait() {
    char** headers = prepend_title((const char**)MENU_HEADERS);

    for (;;) {
        finish_recovery(NULL);
        ui_reset_progress();

        allow_display_toggle = 1;
        int chosen_item = get_menu_selection(headers, MENU_ITEMS, 0, 0);
        allow_display_toggle = 0;

        // device-specific code may take some action here.  It may
        // return one of the core actions handled in the switch
        // statement below.
        chosen_item = device_perform_action(chosen_item);

        int status;
        switch (chosen_item) {
            case ITEM_REBOOT:
                poweroff=0;
                return;

            case ITEM_WIPE_DATA:
                wipe_data(ui_text_visible());
                if (!ui_text_visible()) return;
                break;

            case ITEM_WIPE_CACHE:
                if (confirm_selection("Confirm wipe?", "Yes - Wipe Cache"))
                {
                    ui_print("\n-- Wiping cache...\n");
                    erase_volume("/cache");
                    ui_print("Cache wipe complete.\n");
                    if (!ui_text_visible()) return;
                }
                break;

            case ITEM_APPLY_SDCARD:
                show_install_update_menu();
                break;

            case ITEM_NANDROID:
                show_nandroid_menu();
                break;

            case ITEM_PARTITION:
                show_partition_menu();
                break;

            case ITEM_ADVANCED:
                show_advanced_menu();
                break;
                
            case ITEM_POWEROFF:
                poweroff = 1;
                return;
        }
    }
}

void wipe_all(int orscallback) {
	if(orscallback) {
		if(orswipeprompt && !confirm_selection("Confirm wipe all?","Yes - Wipe All")) {
			ui_print("Skipping full wipe...\n");
			return;
		}
	} else if (!confirm_selection("Confirm wipe all?", "Yes - Wipe All")) {
		return;
	}
	ui_print("\n-- Wiping system, data, cache...\n");
	erase_volume("/system");
	erase_volume("/data");
	erase_volume("/cache");
	ui_print("\nFull wipe complete!\n");
	if (!ui_text_visible()) return;
	return;
}

static int
really_install_package(const char *path)
{
    ui_set_background(BACKGROUND_ICON_INSTALLING);
    ui_print("正在查找升级包...\n");
    ui_show_indeterminate_progress();
    LOGI("Update location: %s\n", path);

    if (ensure_path_mounted(path) != 0) {
        LOGE("Can't mount %s\n", path);
        return INSTALL_CORRUPT;
    }

    ui_print("正在打开升级包...\n");

    int err;

    if (signature_check_enabled) {
        int numKeys;
        RSAPublicKey* loadedKeys = load_keys(PUBLIC_KEYS_FILE, &numKeys);
        if (loadedKeys == NULL) {
            LOGE("Failed to load keys\n");
            return INSTALL_CORRUPT;
        }
        LOGI("%d key(s) loaded from %s\n", numKeys, PUBLIC_KEYS_FILE);

        // Give verification half the progress bar...
        ui_print("正在校验升级包...\n");
        ui_show_progress(
                VERIFICATION_PROGRESS_FRACTION,
                VERIFICATION_PROGRESS_TIME);

        err = verify_file(path, loadedKeys, numKeys);
        free(loadedKeys);
        LOGI("verify_file returned %d\n", err);
        if (err != VERIFY_SUCCESS) {
            LOGE("signature verification failed\n");
            ui_show_text(1);
            if (!confirm_selection("Install Untrusted Package?", "确认 - 安装不严格的zip卡刷包"))
                return INSTALL_CORRUPT;
        }
    }

    /* Try to open the package.
     */
    ZipArchive zip;
    err = mzOpenZipArchive(path, &zip);
    if (err != 0) {
        LOGE("Can't open %s\n(%s)\n", path, err != -1 ? strerror(err) : "bad");
        return INSTALL_CORRUPT;
    }

    /* Verify and install the contents of the package.
     */
    ui_print("正在安装更新...\n");
    return try_update_binary(path, &zip);
}

static void
wipe_data(int confirm) {
    if (confirm && !confirm_selection( "Confirm wipe of all user data?", "Yes - Wipe all user data"))
        return;
    ui_print("\n-- Wiping data...\n");
    erase_volume("/cache");
    ensure_path_mounted("/cache");
    write_string_to_file(UBUNTU_COMMAND_FILE, "format data\n");
    reboot_main_system(ANDROID_RB_RESTART2, 0, "recovery");
}

int verify_root_and_recovery() {
    if (ensure_path_mounted("/system") != 0)
        return 0;

    int ret = 0;
    struct stat st;
    if (0 == lstat("/system/etc/install-recovery.sh", &st)) {
        if (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)) {
            ui_show_text(1);
            ret = 1;
            if (confirm_selection("ROM may flash stock recovery on boot. Fix?", "Yes - Disable recovery flash")) {
                __system("chmod -x /system/etc/install-recovery.sh");
            }
        }
    }

    if (0 == lstat("/system/bin/su", &st)) {
        if (S_ISREG(st.st_mode)) {
            if ((st.st_mode & (S_ISUID | S_ISGID)) != (S_ISUID | S_ISGID)) {
                ui_show_text(1);
                ret = 1;
                if (confirm_selection("Root access possibly lost. Fix?", "Yes - Fix root (/system/bin/su)")) {
                    __system("chmod 6755 /system/bin/su");
                }
            }
        }
    }

    if (0 == lstat("/system/xbin/su", &st)) {
        if (S_ISREG(st.st_mode)) {
            if ((st.st_mode & (S_ISUID | S_ISGID)) != (S_ISUID | S_ISGID)) {
                ui_show_text(1);
                ret = 1;
                if (confirm_selection("Root access possibly lost. Fix?", "Yes - Fix root (/system/xbin/su)")) {
                    __system("chmod 6755 /system/xbin/su");
                }
            }
        }
    }

    ensure_path_unmounted("/system");
    return ret;
}

void show_install_update_menu()
{
    static char* headers[] = {  "从SD卡选择ZIP格式文件进行刷机",
                                "",
                                NULL
    };
    
    char* install_menu_items[] = {  "从SD卡中选择一个ZIP格式刷机包",
                                    "从电脑用ADB载入刷机包",
                                    "直接应用/sdcard/update.zip刷机",
                                    "启用/禁用签名校验",
                                    NULL,
                                    NULL };

    char *other_sd = NULL;
    if (volume_for_path("/emmc") != NULL) {
        other_sd = "/emmc/";
        install_menu_items[4] = "从内置SD卡选择ZIP文件";
    }
    else if (volume_for_path("/external_sd") != NULL) {
        other_sd = "/external_sd/";
        install_menu_items[4] = "从外置SD卡选择ZIP文件";
    }
    
    for (;;)
    {
        int chosen_item = get_menu_selection(headers, install_menu_items, 0, 0);
        switch (chosen_item)
        {
            case ITEM_SIG_CHECK:
                toggle_signature_check();
                break;
            case ITEM_APPLY_UPDATE:
            {
                if (confirm_selection("确认安装?", "是-直接刷入/sdcard/update.zip"))
                    install_zip(SDCARD_UPDATE_FILE);
                break;
            }
            case ITEM_CHOOSE_ZIP:
                show_choose_zip_menu("/sdcard/");
                write_recovery_version();
                break;
            case ITEM_APPLY_SIDELOAD:
                apply_from_adb();
                break;
            case ITEM_CHOOSE_ZIP_INT:
                if (other_sd != NULL)
                    show_choose_zip_menu(other_sd);
                break;
            default:
                return;
        }

    }
}

void apply_root_menu() {
    static char* headers[] = {  "Install superuser",
                                "",
                                NULL
    };

    static char* list[] = { "Simple: install busybox+su",
                            "Adv: also rm some toolbox cmds",
                            "Ext: also rm most toolbox cmds",
                            NULL
    };

    for (;;)
    {
        int chosen_item = get_menu_selection(headers, list, 0);
        if (chosen_item == GO_BACK)
            break;
        switch (chosen_item)
        {
            case 0:
              if (confirm_selection("Confirm root","Yes - apply root to device")) {
                apply_root_to_device(0);
              }
              break;
            case 1:
              if (confirm_selection("Confirm root","Yes - apply root to device")) {
                apply_root_to_device(1);
              }
              break;
            case 2:
              if (confirm_selection("Confirm root","Yes - apply root to device")) {
                apply_root_to_device(2);
              }
              break;
        }
    }

}

void updatemenu()
{

static char* headers[] = {  "Update Menu",
                                "",
                                NULL
    };

 static char* list[] = { "~~~> Go Back <~~~",
			 "Update.zip from Sdcard",
                         "Select .zip from Sdcard",
                         "Toggle Signature Verification",
                         "Toggle Script Asserts",
                            NULL
};

for (;;)
    {
        int chosen_item = get_menu_selection(headers, list, 0);
	if (chosen_item == GO_BACK)
            break;
	switch (chosen_item)
	{
		case 0:
		{
		return;
		break;
		}
		case 1:
		 {
                if (confirm_selection("Confirm install?", "Yes - Install /sdcard/update.zip"))
                    install_zip(SDCARD_PACKAGE_FILE);
                break;
            }
		case 2:
		{
		show_choose_zip_menu();
                break;
		}
		case 3:
		 toggle_signature_check();
                break;
		case 4:
		toggle_script_asserts();
		break;
	}
     }
}

static void
wipe_data(int confirm) {
    if (confirm && !confirm_selection( "Confirm wipe of all user data?", "Yes - Wipe all user data"))
        return;

    ui_print("\n-- Wiping data...\n");
    device_wipe_data();
    erase_volume("/data");
    erase_volume("/cache");
    if (has_datadata()) {
        erase_volume("/datadata");
    }
    erase_volume("/sd-ext");
    erase_volume("/sdcard/.android_secure");
    ui_print("Data wipe complete.\n");
}

/* On recovery exit, check if there is a settings file (PHILZ_SETTINGS_FILE)
   if not, try to restore the copy we do on primary storage (PHILZ_SETTINGS_FILE2)
 * Also, if no copy is found, always create it if there is a settings file
   we shouldn't always copy settings file on exit to avoid loosing user config after a wipe if he just change brightness by error for exp...

 Function is called when rebooting
 After success install of a new rom, before reboot, it will preserve settings if they were wiped by installed ROM
*/
void verify_settings_file() {
    char settings_copy[PATH_MAX];
    sprintf(settings_copy, "%s/%s", get_primary_storage_path(), PHILZ_SETTINGS_FILE2);

    // always have a copy of settings file in primary storage
    if (file_found(PHILZ_SETTINGS_FILE) && !file_found(settings_copy))
        copy_a_file(PHILZ_SETTINGS_FILE, settings_copy);

    // restore settings from the copy if needed (after a wipe)
    if (!file_found(PHILZ_SETTINGS_FILE) && file_found(settings_copy)) {
        ui_SetShowText(true);
        if (!auto_restore_settings.value && !confirm_selection("Restore recovery settings?", "Yes - Restore from sdcard"))
            return;
        if (copy_a_file(settings_copy, PHILZ_SETTINGS_FILE) == 0)
            ui_print("Recovery settings restored.\n");
    }
}

void show_nandroid_restore_menu(const char* volume)
{
    if (ensure_path_mounted(volume) != 0) {
        LOGE ("Can't mount %s\n", volume);
        return;
    }

    int restore_webtop = 1;
    static char* headers[] = {  "Choose an image to restore",
                                "",
                                NULL
    };

    char backup_path[PATH_MAX];
    sprintf(backup_path, "%s/clockworkmod/backup/", volume);
    char* file = choose_file_menu(backup_path, NULL, headers);
    if (file == NULL)
        return;

#ifdef BOARD_HAS_WEBTOP
    static char* header[] = {  "Include webtop in restore?",
                               "",
                               NULL
    };

    static char* list[] = {  "Yes",
                             "No",
                             NULL
    };

    switch (get_menu_selection(header, list, 0, 0))
    {
        case 0:
            restore_webtop = 1;
            break;
        case 1:
            restore_webtop = 0;
            break;
        default:
            return;
    }
#endif

    if (confirm_selection("Confirm restore?", "Yes - Restore"))
        nandroid_restore(file, 1, 1, 1, 1, restore_webtop, 0, restore_webtop, 0);
}