static STATUS restore_child_show(menuUnit* p)
{
p_current = p;
miuiIntent_send(INTENT_MOUNT, 1, "/sdcard");
return_val_if_fail(miuiIntent_result_get_int() == 0, MENU_BACK);
char path_name[PATH_MAX];
switch(p->result) {
case RESTORE_ALL:
snprintf(path_name,PATH_MAX, "%s/backup/backup", RECOVERY_PATH);
break;
case RESTORE_CACHE:
snprintf(path_name,PATH_MAX, "%s/backup/cache", RECOVERY_PATH);
break;
case RESTORE_DATA:
snprintf(path_name,PATH_MAX, "%s/backup/data", RECOVERY_PATH);
break;
case RESTORE_SYSTEM:
snprintf(path_name,PATH_MAX, "%s/backup/system", RECOVERY_PATH);
break;
case RESTORE_BOOT:
snprintf(path_name,PATH_MAX, "%s/backup/boot", RECOVERY_PATH);
break;
default:
miui_error("p->resulte %d should not be the value\n", p->result);
return MENU_BACK;
}
_backup_dir_show(path_name);
return MENU_BACK;
}
static STATUS sd_menu_show(menuUnit *p)
{
//ensure_mounte sd path
struct _intentResult* result = miuiIntent_send(INTENT_MOUNT, 1, "/sdcard");
assert_if_fail(miuiIntent_result_get_int() == 0);
int ret ;
ret = _sd_dir_show(p, "/sdcard");
if (ret == -1) return MENU_BACK;
return ret;
//_sd_dir_show(path);
//if return -1 , return MENU_BACK
}
static STATUS backup_child_show(menuUnit* p)
{
p_current = p;
miuiIntent_send(INTENT_MOUNT, 1, "/sdcard");
char path_name[PATH_MAX];
static time_t timep;
static struct tm *time_tm;
time(&timep);
time_tm = gmtime(&timep);
return_val_if_fail(miuiIntent_result_get_int() == 0, MENU_BACK);
if (RET_YES == miui_confirm(3, p->name, p->desc, p->icon)) {
miui_busy_process();
switch(p->result) {
case BACKUP_ALL:
snprintf(path_name,PATH_MAX, "%s/backup/backup/%02d%02d%02d-%02d%02d",
RECOVERY_PATH, time_tm->tm_year,
time_tm->tm_mon + 1, time_tm->tm_mday, time_tm->tm_hour, time_tm->tm_min);
miuiIntent_send(INTENT_BACKUP, 1, path_name);
break;
case BACKUP_CACHE:
snprintf(path_name,PATH_MAX, "%s/backup/cache/%02d%02d%02d-%02d%02d",
RECOVERY_PATH, time_tm->tm_year,
time_tm->tm_mon + 1, time_tm->tm_mday, time_tm->tm_hour, time_tm->tm_min);
miuiIntent_send(INTENT_ADVANCED_BACKUP, 2 , path_name, "/cache");
break;
case BACKUP_DATA:
snprintf(path_name,PATH_MAX, "%s/backup/data/%02d%02d%02d-%02d%02d",
RECOVERY_PATH, time_tm->tm_year,
time_tm->tm_mon + 1, time_tm->tm_mday, time_tm->tm_hour, time_tm->tm_min);
miuiIntent_send(INTENT_ADVANCED_BACKUP, 2 , path_name, "/data");
break;
case BACKUP_SYSTEM:
snprintf(path_name,PATH_MAX, "%s/backup/system/%02d%02d%02d-%02d%02d",
RECOVERY_PATH, time_tm->tm_year,
time_tm->tm_mon + 1, time_tm->tm_mday, time_tm->tm_hour, time_tm->tm_min);
miuiIntent_send(INTENT_ADVANCED_BACKUP, 2 , path_name, "/system");
break;
case BACKUP_BOOT:
snprintf(path_name,PATH_MAX, "%s/backup/boot/%02d%02d%02d-%02d%02d",
RECOVERY_PATH, time_tm->tm_year,
time_tm->tm_mon + 1, time_tm->tm_mday, time_tm->tm_hour, time_tm->tm_min);
miuiIntent_send(INTENT_ADVANCED_BACKUP, 2 , path_name, "/boot");
break;
default:
miui_error("p->resulte %d should not be the value\n", p->result);
break;
}
}
return MENU_BACK;
}
static STATUS mount_menu_show(menuUnit *p)
{
//traverse all mount files
//ensure cache
miuiIntent_send(INTENT_ISMOUNT, 1, "/cache");
if (miuiIntent_result_get_int() == 1)
{
menuUnit_set_icon(mount_cache_node, ICON_ENABLE);
menuUnit_set_desc(mount_cache_node, MOUNT_DESC_MOUNT);
}
else
{
menuUnit_set_icon(mount_cache_node, ICON_DISABLE);
menuUnit_set_desc(mount_cache_node, MOUNT_DESC_UNMOUNT);
}
//ensure data
miuiIntent_send(INTENT_ISMOUNT, 1, "/data");
if (miuiIntent_result_get_int() == 1)
{
menuUnit_set_icon(mount_data_node, ICON_ENABLE);
menuUnit_set_desc(mount_data_node, MOUNT_DESC_MOUNT);
}
else
{
menuUnit_set_icon(mount_data_node, ICON_DISABLE);
menuUnit_set_desc(mount_data_node, MOUNT_DESC_UNMOUNT);
}
//ensure system
miuiIntent_send(INTENT_ISMOUNT, 1, "/system");
if (miuiIntent_result_get_int() == 1)
{
menuUnit_set_icon(mount_system_node, ICON_ENABLE);
menuUnit_set_desc(mount_system_node, MOUNT_DESC_MOUNT);
}
else
{
menuUnit_set_icon(mount_system_node, ICON_DISABLE);
menuUnit_set_desc(mount_system_node, MOUNT_DESC_UNMOUNT);
}
//ensure sdcard
miuiIntent_send(INTENT_ISMOUNT, 1, "/sdcard");
if (miuiIntent_result_get_int() == 1)
{
menuUnit_set_icon(mount_sd_node, ICON_ENABLE);
menuUnit_set_desc(mount_sd_node, MOUNT_DESC_MOUNT);
}
else
{
menuUnit_set_icon(mount_sd_node, ICON_DISABLE);
menuUnit_set_desc(mount_sd_node, MOUNT_DESC_UNMOUNT);
}
if (acfg()->sd_ext == 1)
{
//ensure sd-ext
miuiIntent_send(INTENT_ISMOUNT, 1, "/internal_sd");
if (miuiIntent_result_get_int() == 1)
{
menuUnit_set_icon(mount_sd_ext_node, ICON_ENABLE);
menuUnit_set_desc(mount_sd_ext_node, MOUNT_DESC_MOUNT);
}
else
{
menuUnit_set_icon(mount_sd_ext_node, ICON_DISABLE);
menuUnit_set_desc(mount_sd_ext_node, MOUNT_DESC_UNMOUNT);
}
}
//show menu
return_val_if_fail(p != NULL, RET_FAIL);
int n = p->get_child_count(p);
return_val_if_fail(n > 0, RET_FAIL);
int selindex = 0;
return_val_if_fail(n >= 1, RET_FAIL);
return_val_if_fail(n < ITEM_COUNT, RET_FAIL);
struct _menuUnit *temp = p->child;
return_val_if_fail(temp != NULL, RET_FAIL);
char **menu_item = malloc(n * sizeof(char *));
assert_if_fail(menu_item != NULL);
char **icon_item=malloc(n * sizeof(char *));
assert_if_fail(icon_item != NULL);
char **title_item= malloc(n * sizeof(char *));
assert_if_fail(title_item != NULL);
int i = 0;
for (i = 0; i < n; i++)
{
menu_item[i] = temp->name;
title_item[i] = temp->title_name;
icon_item[i] = temp->icon;
temp = temp->nextSilbing;
}
selindex = miui_mainmenu(p->name, menu_item, NULL, icon_item, n);
p->result = selindex;
if (menu_item != NULL) free(menu_item);
if (title_item != NULL) free(title_item);
if (icon_item != NULL) free(icon_item);
return p->result;
}
int
main(int argc, char **argv) {
if (strcmp(basename(argv[0]), "recovery") != 0)
{
if (strstr(argv[0], "flash_image") != NULL)
return flash_image_main(argc, argv);
if (strstr(argv[0], "dump_image") != NULL)
return dump_image_main(argc, argv);
if (strstr(argv[0], "erase_image") != NULL)
return erase_image_main(argc, argv);
if (strstr(argv[0], "mkyaffs2image") != NULL)
return mkyaffs2image_main(argc, argv);
if (strstr(argv[0], "unyaffs") != NULL)
return unyaffs_main(argc, argv);
if (strstr(argv[0], "nandroid"))
return nandroid_main(argc, argv);
if (strstr(argv[0], "reboot"))
return reboot_main(argc, argv);
#ifdef BOARD_RECOVERY_HANDLES_MOUNT
if (strstr(argv[0], "mount") && argc == 2 && !strstr(argv[0], "umount"))
{
load_volume_table();
return ensure_path_mounted(argv[1]);
}
#endif
if (strstr(argv[0], "poweroff")){
return reboot_main(argc, argv);
}
}
__system("/sbin/postrecoveryboot.sh");
time_t start = time(NULL);
// If these fail, there's not really anywhere to complain...
#ifndef DEBUG
unlink(TEMPORARY_LOG_FILE);
#endif
freopen(TEMPORARY_LOG_FILE, "a", stdout); setbuf(stdout, NULL);
freopen(TEMPORARY_LOG_FILE, "a", stderr); setbuf(stderr, NULL);
printf("Starting recovery on %s", ctime(&start));
//miuiIntent init
miuiIntent_init(10);
miuiIntent_register(INTENT_MOUNT, &intent_mount);
miuiIntent_register(INTENT_ISMOUNT, &intent_ismount);
miuiIntent_register(INTENT_UNMOUNT, &intent_unmount);
miuiIntent_register(INTENT_REBOOT, &intent_reboot);
miuiIntent_register(INTENT_INSTALL, &intent_install);
miuiIntent_register(INTENT_WIPE, &intent_wipe);
miuiIntent_register(INTENT_TOGGLE, &intent_toggle);
miuiIntent_register(INTENT_FORMAT, &intent_format);
miuiIntent_register(INTENT_RESTORE, &intent_restore);
miuiIntent_register(INTENT_BACKUP, &intent_backup);
miuiIntent_register(INTENT_ADVANCED_BACKUP, &intent_advanced_backup);
miuiIntent_register(INTENT_SYSTEM, &intent_system);
miuiIntent_register(INTENT_COPY, &intent_copy);
device_ui_init();
load_volume_table();
get_args(&argc, &argv);
struct bootloader_message boot;
memset(&boot, 0, sizeof(boot));
set_bootloader_message(&boot);
create_fstab();
int previous_runs = 0;
const char *send_intent = NULL;
const char *update_package = NULL;
int wipe_data = 0, wipe_cache = 0;
int arg;
while ((arg = getopt_long(argc, argv, "", OPTIONS, NULL)) != -1) {
switch (arg) {
case 'p': previous_runs = atoi(optarg); break;
case 's': send_intent = optarg; break;
case 'u': update_package = optarg; break;
case 'w': wipe_data = wipe_cache = 1; break;
case 'c': wipe_cache = 1; break;
//case 't': ui_show_text(1); break;
case '?':
LOGE("Invalid command argument\n");
continue;
}
}
device_recovery_start();
printf("Command:");
for (arg = 0; arg < argc; arg++) {
printf(" \"%s\"", argv[arg]);
}
printf("\n");
if (update_package) {
// For backwards compatibility on the cache partition only, if
// we're given an old 'root' path "CACHE:foo", change it to
// "/cache/foo".
if (strncmp(update_package, "CACHE:", 6) == 0) {
int len = strlen(update_package) + 10;
char* modified_path = malloc(len);
strlcpy(modified_path, "/cache/", len);
strlcat(modified_path, update_package+6, len);
printf("(replacing path \"%s\" with \"%s\")\n",
update_package, modified_path);
update_package = modified_path;
}
}
printf("\n");
property_list(print_property, NULL);
printf("\n");
int status = INSTALL_SUCCESS;
if (update_package != NULL) {
if (wipe_cache) erase_volume("/cache");
miuiIntent_send(INTENT_INSTALL, 3, update_package,"0", "0");
//if echo 0 ,don't print success dialog
status = miuiIntent_result_get_int();
if (status != INSTALL_SUCCESS) ui_print("Installation aborted.\n");
} else if (wipe_data) {
if (device_wipe_data()) status = INSTALL_ERROR;
if (erase_volume("/data")) status = INSTALL_ERROR;
if (wipe_cache && erase_volume("/cache")) status = INSTALL_ERROR;
if (status != INSTALL_SUCCESS) ui_print("Data wipe failed.\n");
} else if (wipe_cache) {
if (wipe_cache && erase_volume("/cache")) status = INSTALL_ERROR;
if (status != INSTALL_SUCCESS) ui_print("Cache wipe failed.\n");
} else {
status = INSTALL_ERROR; // No command specified
}
if (status != INSTALL_SUCCESS) device_main_ui_show();//show menu
device_main_ui_release();
// Otherwise, get ready to boot the main system...
finish_recovery(send_intent);
ui_print("Rebooting...\n");
android_reboot(ANDROID_RB_RESTART, 0, 0);
return EXIT_SUCCESS;
}
