struct _menuUnit* backup_ui_init() { struct _menuUnit *p = common_ui_init(); return_null_if_fail(p != NULL); menuUnit_set_name(p, "<~backup.name>"); menuUnit_set_title(p, "<~backup.title>"); menuUnit_set_icon(p, "@backup"); menuUnit_set_show(p, &common_menu_show); return_null_if_fail(menuNode_init(p) != NULL); backup_menu = p; //set backup default format struct _menuUnit* temp = set_backup_fromat_init(); assert_if_fail(menuNode_add(p, temp) == RET_OK); //backup temp = common_ui_init(); assert_if_fail(menuNode_add(p, temp) == RET_OK); menuUnit_set_name(temp, "<~backup.backup.name>"); menuUnit_set_result(temp, BACKUP_ALL); menuUnit_set_show(temp, &backup_child_show); //restore temp = common_ui_init(); assert_if_fail(menuNode_add(p, temp) == RET_OK); menuUnit_set_name(temp, "<~backup.restore.name>"); menuUnit_set_result(temp, RESTORE_ALL); menuUnit_set_show(temp, &restore_child_show); //advanced backup temp = advanced_backup_ui_init(); assert_if_fail(menuNode_add(p, temp) == RET_OK); //advanced restore temp = advanced_restore_ui_init(); assert_if_fail(menuNode_add(p, temp) == RET_OK); return p; }
STATUS common_ui_show(menuUnit *p) { oppo_debug("start .....\n"); return_val_if_fail(p != NULL, RET_FAIL); int n = p->get_child_count(p); if (n == 0) return common_ui_show_node(p);//show node 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 = oppo_mainmenu(p->name, menu_item, icon_item, NULL, 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); oppo_debug("end .....\n"); return p->result; }
struct _menuUnit * sd_ui_init() { struct _menuUnit *p = common_ui_init(); return_null_if_fail(p != NULL); strncpy(p->name, "<~sd.name>", MENU_LEN); strncpy(p->title_name, "<~sd.title_name>", MENU_LEN); strncpy(p->icon, "@sd", MENU_LEN); p->result = 0; return_null_if_fail(menuNode_init(p) != NULL); //install from sd struct _menuUnit *temp = common_ui_init(); return_null_if_fail(temp != NULL); menuUnit_set_icon(temp, "@sd.choose"); strncpy(temp->name, "<~sd.install.name>", MENU_LEN); temp->show = &sd_menu_show; assert_if_fail(menuNode_add(p, temp) == RET_OK); //install update.bin from sd temp = common_ui_init(); menuUnit_set_icon(temp, "@sd.install"); strncpy(temp->name,"<~sd.update.name>", MENU_LEN); temp->show = &sd_update_show; assert_if_fail(menuNode_add(p, temp) == RET_OK); if (acfg()->sd_ext == 1) { //install from external_sd struct _menuUnit *temp = common_ui_init(); return_null_if_fail(temp != NULL); menuUnit_set_icon(temp, "@sd.choose"); strncpy(temp->name, "<~sdext.install.name>", MENU_LEN); temp->show = &sdext_menu_show; assert_if_fail(menuNode_add(p, temp) == RET_OK); } return p; }
struct _menuUnit* info_ui_init() { struct _menuUnit *p = common_ui_init(); return_null_if_fail(p != NULL); menuUnit_set_name(p, "<~info.name>"); menuUnit_set_title(p, "<~info.title>"); menuUnit_set_icon(p, "@info"); assert_if_fail(menuNode_init(p) != NULL); //mount struct _menuUnit *temp = common_ui_init(); menuUnit_set_name(temp, "<~info.mount.name>"); menuUnit_set_icon(temp, "@info.mount"); menuUnit_set_show(temp, &info_mount_show); assert_if_fail(menuNode_add(p, temp) == RET_OK); //log temp = common_ui_init(); menuUnit_set_name(temp, "<~info.log.name>"); menuUnit_set_icon(temp, "@info.log"); menuUnit_set_show(temp, &info_log_show); assert_if_fail(menuNode_add(p, temp) == RET_OK); //about temp = common_ui_init(); menuUnit_set_name(temp, "<~info.about.name>"); menuUnit_set_icon(temp, "@info.about"); menuUnit_set_show(temp, &info_about_show); assert_if_fail(menuNode_add(p, temp) == RET_OK); return p; }
struct _menuUnit* advanced_restore_ui_init() { struct _menuUnit *p = common_ui_init(); return_null_if_fail(p != NULL); menuUnit_set_name(p, "<~advanced_restore.name>"); menuUnit_set_show(p, &common_menu_show); return_null_if_fail(menuNode_init(p) != NULL); //restore boot struct _menuUnit* temp = common_ui_init(); assert_if_fail(menuNode_add(p, temp) == RET_OK); menuUnit_set_name(temp, "<~advanced_restore.boot.name>"); menuUnit_set_result(temp, RESTORE_BOOT); menuUnit_set_show(temp, &restore_child_show); //restore system temp = common_ui_init(); assert_if_fail(menuNode_add(p, temp) == RET_OK); menuUnit_set_name(temp, "<~advanced_restore.system.name>"); menuUnit_set_result(temp, RESTORE_SYSTEM); menuUnit_set_show(temp, &restore_child_show); //restore data temp = common_ui_init(); assert_if_fail(menuNode_add(p, temp) == RET_OK); menuUnit_set_name(temp, "<~advanced_restore.data.name>"); menuUnit_set_result(temp, RESTORE_DATA); menuUnit_set_show(temp, &restore_child_show); //restore cache temp = common_ui_init(); assert_if_fail(menuNode_add(p, temp) == RET_OK); menuUnit_set_name(temp, "<~advanced_restore.cache.name>"); menuUnit_set_result(temp, RESTORE_CACHE); menuUnit_set_show(temp, &restore_child_show); return p; }
STATUS common_menu_show(menuUnit *p) { return_val_if_fail(p != NULL, RET_FAIL); int n = p->get_child_count(p); if (n == 0) return common_ui_show_node(p);//show node 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 = oppo_menubox(p->name, menu_item, n); /* OPPO 2013-02-18 jizhengkang azx Add begin for reason */ selectedItem[selectedCount] = selindex - 1; selindex?selectedCount++:selectedCount--; /* OPPO 2013-02-18 jizhengkang azx Add end */ 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; }
struct _menuUnit* advanced_backup_ui_init() { struct _menuUnit *p = common_ui_init(); return_null_if_fail(p != NULL); menuUnit_set_name(p, "<~advanced_backup.name>"); menuUnit_set_show(p, &common_menu_show); return_null_if_fail(menuNode_init(p) != NULL); //backup boot struct _menuUnit* temp = common_ui_init(); assert_if_fail(menuNode_add(p, temp) == RET_OK); menuUnit_set_name(temp, "<~advanced_backup.boot.name>"); menuUnit_set_result(temp, BACKUP_BOOT); menuUnit_set_show(temp, &backup_child_show); //backup system temp = common_ui_init(); assert_if_fail(menuNode_add(p, temp) == RET_OK); menuUnit_set_name(temp, "<~advanced_backup.system.name>"); menuUnit_set_result(temp, BACKUP_SYSTEM); menuUnit_set_show(temp, &backup_child_show); //backup data temp = common_ui_init(); assert_if_fail(menuNode_add(p, temp) == RET_OK); menuUnit_set_name(temp, "<~advanced_backup.data.name>"); menuUnit_set_result(temp, BACKUP_DATA); menuUnit_set_show(temp, &backup_child_show); //backup cache temp = common_ui_init(); assert_if_fail(menuNode_add(p, temp) == RET_OK); menuUnit_set_name(temp, "<~advanced_backup.cache.name>"); menuUnit_set_result(temp, BACKUP_CACHE); menuUnit_set_show(temp, &backup_child_show); return p; }
STATUS wipe_result_confirm(menuUnit *p, int wipe_result) { char name[MENU_LEN], desc[MENU_LEN]; oppo_debug("start .....\n"); // strncpy(name, "<~wipe.result.title>", MENU_LEN); switch(wipe_result) { case WIPE_ALL_OK: strncpy(desc, "<~wipe.result.factory.ok>", MENU_LEN); break; case WIPE_ALL_FAILED: strncpy(desc, "<~wipe.result.factory.failed>", MENU_LEN); break; case WIPE_CACHE_OK: strncpy(desc, "<~wipe.result.cache.ok>", MENU_LEN); break; case WIPE_CACHE_FAILED: strncpy(desc, "<~wipe.result.cache.failed>", MENU_LEN); break; case WIPE_DATA_OK: strncpy(desc, "<~wipe.result.data.ok>", MENU_LEN); break; case WIPE_DATA_FAILED: strncpy(desc, "<~wipe.result.data.failed>", MENU_LEN); break; default: assert_if_fail(0); break; } // ag_draw(NULL,&canvas_wipemenu,0,0); ag_draw(NULL,&canvas_mainmenu,0,0); oppo_notice(3, p->title_name, desc, p->icon); oppo_debug("end .....\n"); return MENU_BACK; }
static int oppo_wipe_items(int item) { intentResult*result1; int ret1; int ret2; int wipe_result = WIPE_IGNORE; switch(item) { case WIPE_FACTORY: oppo_debug("WIPE_FACTORY\n"); wipe_thread_start("<~wipe.factory.name>"); set_sdcard_update_bootloader_message("--wipe_data", NULL); LOGW("Erase data and cache write bcb...\n"); result1 = oppoIntent_send(INTENT_WIPE, 1, "/data"); ret1 = result1->ret; set_wipe_process(50); result1 = oppoIntent_send(INTENT_WIPE, 1, "/cache"); ret2 = result1->ret; oppo_debug("result1=%d, result2=%d\n", ret1, ret2); if ((ret1 == 0) && (ret2 == 0)) { wipe_result = WIPE_ALL_OK; } else { wipe_result = WIPE_ALL_FAILED; } break; case WIPE_DATA: oppo_debug("WIPE_DATA\n"); wipe_thread_start("<~wipe.data.name>"); set_sdcard_update_bootloader_message("--wipe_data_only", NULL); LOGW("Erase data write bcb...\n"); result1 = oppoIntent_send(INTENT_WIPE, 1, "/data"); if (result1->ret == 0) { wipe_result = WIPE_DATA_OK; } else { wipe_result = WIPE_DATA_FAILED; } break; case WIPE_CACHE: oppo_debug("WIPE_CACHE\n"); wipe_thread_start("<~wipe.cache.name>"); set_sdcard_update_bootloader_message("--wipe_cache", NULL); LOGW("Erase cache write bcb...\n"); result1 = oppoIntent_send(INTENT_WIPE, 1, "/cache"); if (result1->ret == 0) { wipe_result = WIPE_CACHE_OK; } else { wipe_result = WIPE_CACHE_FAILED; } break; default: assert_if_fail(0); break; } set_wipe_process(100); wipe_thread_close(); return wipe_result; }
static intentResult* intent_system(int argc, char* argv[]) { return_intent_result_if_fail(argc == 1); return_intent_result_if_fail(argv != NULL); int result = __system(argv[0]); assert_if_fail(result == 0); return miuiIntent_result_set(result, NULL); }
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 }
struct _menuUnit* set_backup_fromat_init() { struct _menuUnit* p = common_ui_init(); return_null_if_fail(p != NULL); menuUnit_set_name(p, "<~root.set.backup.format>"); menuUnit_set_title(p, "set backup format"); menuUnit_set_icon(p, "@root"); assert_if_fail(menuNode_init(p) != NULL); //tar backup format struct _menuUnit* temp = common_ui_init(); menuUnit_set_name(temp, "tar backup format(default)"); menuUnit_set_show(temp, &set_default_backup_format); temp->result = TAR_FORMAT; assert_if_fail(menuNode_add(p, temp) == RET_OK); //dup backup format temp = common_ui_init(); menuUnit_set_name(temp, "dup backup format"); menuUnit_set_show(temp, &set_default_backup_format); temp->result = DUP_FORMAT; assert_if_fail(menuNode_add(p, temp) == RET_OK); return p; }
STATUS wipe_menu_show(menuUnit *p) { oppo_debug("start...\n"); if (wipe_item_show_end) { wipe_item_show_end = 0; return MENU_BACK; } return_val_if_fail(p != NULL, RET_FAIL); int n = p->get_child_count(p); 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); int i = 0; for (i = 0; i < n; i++) { menu_item[i] = temp->name; icon_item[i] = temp->icon; temp = temp->nextSilbing; } selindex = wipe_menu(p->name, menu_item, icon_item, NULL, n); /* OPPO 2013-02-18 jizhengkang azx Add begin for reason */ selectedItem[selectedCount] = selindex - 1; selindex?selectedCount++:selectedCount--; /* OPPO 2013-02-18 jizhengkang azx Add end */ p->result = selindex; if (menu_item != NULL) free(menu_item); oppo_debug("end...p->result=%d\n", p->result); return p->result; }
struct _menuUnit * sd_ui_init() { struct _menuUnit *p = common_ui_init(); return_null_if_fail(p != NULL); strncpy(p->name, "<~sd.name>", MENU_LEN); strncpy(p->title_name, "<~sd.title_name>", MENU_LEN); strncpy(p->icon, "@sd", MENU_LEN); p->result = 0; sd_menu = p; return_null_if_fail(menuNode_init(p) != NULL); struct _menuUnit *temp = common_ui_init(); return_null_if_fail(temp != NULL); menuUnit_set_icon(temp, "@sd.choose"); strncpy(temp->name, "<~sd.install.name>", MENU_LEN); temp->show = &sd_menu_show; assert_if_fail(menuNode_add(p, temp) == RET_OK); temp = common_ui_init(); menuUnit_set_icon(temp, "@sd.install"); strncpy(temp->name,"<~sd.update.name>", MENU_LEN); temp->show = &sd_update_show; assert_if_fail(menuNode_add(p, temp) == RET_OK); return p; }
struct _menuUnit* wipe_ui_init() { ag_canvas(&canvas_wipemenu,agw(),agh()); struct _menuUnit* p = common_ui_init(); return_null_if_fail(p != NULL); return_null_if_fail(menuUnit_set_name(p, "<~wipe.name>") == RET_OK); return_null_if_fail(menuUnit_set_title(p, "<~wipe.title>") == RET_OK); return_null_if_fail(menuUnit_set_icon(p, "@wipe") == RET_OK); return_null_if_fail(RET_OK == menuUnit_set_show(p, &wipe_menu_show)); return_null_if_fail(menuNode_init(p) != NULL); //wipe_data/factory reset struct _menuUnit* temp = common_ui_init(); assert_if_fail(menuNode_add(p, temp) == RET_OK); return_null_if_fail(menuUnit_set_name(temp, "<~wipe.factory.name>") == RET_OK); return_null_if_fail(menuUnit_set_result(temp, WIPE_FACTORY) == RET_OK); return_null_if_fail(menuUnit_set_desc(temp, "<~wipe.factory.desc>") == RET_OK); return_null_if_fail(menuUnit_set_icon(temp, "@wipe.all") == RET_OK); return_null_if_fail(RET_OK == menuUnit_set_show(temp, &wipe_item_show)); //wipe_data temp = common_ui_init(); assert_if_fail(menuNode_add(p, temp) == RET_OK); return_null_if_fail(menuUnit_set_name(temp, "<~wipe.data.name>") == RET_OK); return_null_if_fail(menuUnit_set_result(temp, WIPE_DATA) == RET_OK); return_null_if_fail(menuUnit_set_desc(temp, "<~wipe.data.desc>") == RET_OK); return_null_if_fail(menuUnit_set_icon(temp, "@wipe.data") == RET_OK); return_null_if_fail(RET_OK == menuUnit_set_show(temp, &wipe_item_show)); //wipe_cache temp = common_ui_init(); assert_if_fail(menuNode_add(p, temp) == RET_OK); return_null_if_fail(menuUnit_set_name(temp, "<~wipe.cache.name>") == RET_OK); return_null_if_fail(menuUnit_set_result(temp, WIPE_CACHE) == RET_OK); return_null_if_fail(menuUnit_set_desc(temp, "<~wipe.cache.desc>") == RET_OK); return_null_if_fail(menuUnit_set_icon(temp, "@wipe.cache") == RET_OK); return_null_if_fail(RET_OK == menuUnit_set_show(temp, &wipe_item_show)); return p; }
STATUS wipe_item_show(menuUnit *p) { if (RET_YES == miui_confirm(3, p->name, p->desc, p->icon)) { miui_busy_process(); switch(p->result) { case WIPE_FACTORY: miuiIntent_send(INTENT_WIPE, 1, "/cache"); miuiIntent_send(INTENT_WIPE, 1, "/data"); break; case WIPE_DATA: miuiIntent_send(INTENT_WIPE, 1, "/data"); break; case WIPE_CACHE: miuiIntent_send(INTENT_WIPE, 1, "/cache"); break; case WIPE_DALVIK: miuiIntent_send(INTENT_WIPE, 1, "dalvik-cache"); break; case FORMAT_SYSTEM: miuiIntent_send(INTENT_FORMAT, 1, "/system"); break; case FORMAT_DATA: miuiIntent_send(INTENT_FORMAT, 1, "/data"); break; case FORMAT_CACHE: miuiIntent_send(INTENT_FORMAT, 1, "/cache"); break; case FORMAT_BOOT: miuiIntent_send(INTENT_FORMAT, 1, "/boot"); break; case FORMAT_SDCARD: miuiIntent_send(INTENT_FORMAT, 1, "/sdcard"); break; case FORMAT_ALL: miuiIntent_send(INTENT_FORMAT, 1, "/system"); miuiIntent_send(INTENT_FORMAT, 1, "/data"); miuiIntent_send(INTENT_FORMAT, 1, "/cache"); break; default: assert_if_fail(0); break; } } return MENU_BACK; }
STATUS wipe_menu_show(menuUnit *p) { return_val_if_fail(p != NULL, RET_FAIL); int n = p->get_child_count(p); 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); int i = 0; for (i = 0; i < n; i++) { menu_item[i] = temp->name; temp = temp->nextSilbing; } selindex = miui_mainmenu(p->name, menu_item, NULL, NULL, n); p->result = selindex; if (menu_item != NULL) free(menu_item); return p->result; }
struct _menuUnit* wipe_ui_init() { struct _menuUnit* p = common_ui_init(); return_null_if_fail(p != NULL); return_null_if_fail(menuUnit_set_name(p, "<~wipe.name>") == RET_OK); return_null_if_fail(menuUnit_set_title(p, "<~wipe.title>") == RET_OK); return_null_if_fail(menuUnit_set_icon(p, "@wipe") == RET_OK); return_null_if_fail(RET_OK == menuUnit_set_show(p, &wipe_menu_show)); return_null_if_fail(menuNode_init(p) != NULL); //wipe_data/factory reset struct _menuUnit* temp = common_ui_init(); assert_if_fail(menuNode_add(p, temp) == RET_OK); return_null_if_fail(menuUnit_set_name(temp, "<~wipe.factory.name>") == RET_OK); return_null_if_fail(menuUnit_set_result(temp, WIPE_FACTORY) == RET_OK); return_null_if_fail(RET_OK == menuUnit_set_show(temp, &wipe_item_show)); //wipe_data temp = common_ui_init(); assert_if_fail(menuNode_add(p, temp) == RET_OK); return_null_if_fail(menuUnit_set_name(temp, "<~wipe.data.name>") == RET_OK); return_null_if_fail(menuUnit_set_result(temp, WIPE_DATA) == RET_OK); return_null_if_fail(RET_OK == menuUnit_set_show(temp, &wipe_item_show)); //wipe_cache temp = common_ui_init(); assert_if_fail(menuNode_add(p, temp) == RET_OK); return_null_if_fail(menuUnit_set_name(temp, "<~wipe.cache.name>") == RET_OK); return_null_if_fail(menuUnit_set_result(temp, WIPE_CACHE) == RET_OK); return_null_if_fail(RET_OK == menuUnit_set_show(temp, &wipe_item_show)); //format system temp = common_ui_init(); assert_if_fail(menuNode_add(p, temp) == RET_OK); return_null_if_fail(menuUnit_set_name(temp, "<~format.system.name>") == RET_OK); return_null_if_fail(menuUnit_set_result(temp, FORMAT_SYSTEM) == RET_OK); return_null_if_fail(RET_OK == menuUnit_set_show(temp, &wipe_item_show)); //format data temp = common_ui_init(); assert_if_fail(menuNode_add(p, temp) == RET_OK); return_null_if_fail(menuUnit_set_name(temp, "<~format.data.name>") == RET_OK); return_null_if_fail(menuUnit_set_result(temp, FORMAT_DATA) == RET_OK); return_null_if_fail(RET_OK == menuUnit_set_show(temp, &wipe_item_show)); //format cache temp = common_ui_init(); assert_if_fail(menuNode_add(p, temp) == RET_OK); return_null_if_fail(menuUnit_set_name(temp, "<~format.cache.name>") == RET_OK); return_null_if_fail(menuUnit_set_result(temp, FORMAT_CACHE) == RET_OK); return_null_if_fail(RET_OK == menuUnit_set_show(temp, &wipe_item_show)); //format BOOT temp = common_ui_init(); assert_if_fail(menuNode_add(p, temp) == RET_OK); return_null_if_fail(menuUnit_set_name(temp, "<~format.boot.name>") == RET_OK); return_null_if_fail(menuUnit_set_result(temp, FORMAT_BOOT) == RET_OK); return_null_if_fail(RET_OK == menuUnit_set_show(temp, &wipe_item_show)); //format SDCARD temp = common_ui_init(); assert_if_fail(menuNode_add(p, temp) == RET_OK); return_null_if_fail(menuUnit_set_name(temp, "<~format.sdcard.name>") == RET_OK); return_null_if_fail(menuUnit_set_result(temp, FORMAT_SDCARD) == RET_OK); return_null_if_fail(RET_OK == menuUnit_set_show(temp, &wipe_item_show)); //format ALL temp = common_ui_init(); assert_if_fail(menuNode_add(p, temp) == RET_OK); return_null_if_fail(menuUnit_set_name(temp, "<~format.all.name>") == RET_OK); return_null_if_fail(menuUnit_set_result(temp, FORMAT_ALL) == RET_OK); return_null_if_fail(RET_OK == menuUnit_set_show(temp, &wipe_item_show)); return p; }
static STATUS _file_scan(char *path, int path_len) { return_val_if_fail(path != NULL, RET_FAIL); return_val_if_fail(strlen(path) <= path_len, RET_INVALID_ARG); DIR* d = NULL; struct dirent* de = NULL; int i = 0; int result = 0; d = opendir(path); return_val_if_fail(d != NULL, RET_FAIL); int d_size = 0; int d_alloc = 10; char** dirs = (char **)malloc(d_alloc * sizeof(char*)); char** dirs_desc = (char **)malloc(d_alloc * sizeof(char*)); return_val_if_fail(dirs != NULL, RET_FAIL); return_val_if_fail(dirs_desc != NULL, RET_FAIL); int z_size = 0; int z_alloc = 10; char** zips = (char **)malloc(z_alloc * sizeof(char*)); char** zips_desc=(char **)malloc(z_alloc * sizeof(char*)); return_val_if_fail(zips != NULL, RET_FAIL); return_val_if_fail(zips_desc != NULL, RET_FAIL); // zips[0] = strdup("../"); // zips_desc[0]=strdup("../"); while ((de = readdir(d)) != NULL) { int name_len = strlen(de->d_name); if (name_len <= 0) continue; char de_path[PATH_MAX]; snprintf(de_path, PATH_MAX, "%s/%s", path, de->d_name); struct stat st ; assert_if_fail(stat(de_path, &st) == 0); if (de->d_type == DT_DIR) { //skip "." and ".." entries if (name_len == 1 && de->d_name[0] == '.') continue; if (name_len == 2 && de->d_name[0] == '.' && de->d_name[1] == '.') continue; if (d_size >= d_alloc) { d_alloc *= 2; dirs = (char **)realloc(dirs, d_alloc * sizeof(char*)); assert_if_fail(dirs != NULL); dirs_desc = (char **)realloc(dirs_desc, d_alloc * sizeof(char*)); assert_if_fail(dirs_desc != NULL); } dirs[d_size] = (char *)malloc(name_len + 2); assert_if_fail(dirs[d_size] != NULL); dirs_desc[d_size] = (char *)malloc(64); assert_if_fail(dirs_desc[d_size] != NULL); strncpy(dirs[d_size], de->d_name, name_len); dirs[d_size][name_len] = '/'; dirs[d_size][name_len + 1] = '\0'; snprintf(dirs_desc[d_size], 63, "%s" ,ctime(&st.st_mtime)); dirs_desc[d_size][63] = '\0'; ++d_size; } else if (de->d_type == DT_REG) { if (g_file_filter_fun == NULL || g_file_filter_fun(de->d_name, name_len) == 0) { if (z_size >= z_alloc) { z_alloc *= 2; zips = (char **) realloc(zips, z_alloc * sizeof(char*)); assert_if_fail(zips != NULL); zips_desc = (char **) realloc(zips_desc, z_alloc * sizeof(char*)); assert_if_fail(zips_desc != NULL); } zips[z_size] = strdup(de->d_name); assert_if_fail(zips[z_size] != NULL); zips_desc[z_size] = (char*)malloc(64); assert_if_fail(zips_desc[z_size] != NULL); snprintf(zips_desc[z_size], 63, "%s %lldbytes" ,ctime(&st.st_mtime), st.st_size); zips_desc[z_size][63] = '\0'; z_size++; } } } closedir(d); // append dirs to the zips list if (d_size + z_size + 1 > z_alloc) { z_alloc = d_size + z_size + 1; zips = (char **)realloc(zips, z_alloc * sizeof(char*)); assert_if_fail(zips != NULL); zips_desc = (char **)realloc(zips_desc, z_alloc * sizeof(char*)); assert_if_fail(zips_desc != NULL); } for (i = 0; i < d_size; i++) { zips[z_size + i] = dirs[i]; zips_desc[z_size + i] = dirs_desc[i]; } free(dirs); z_size += d_size; zips[z_size] = NULL; zips_desc[z_size] = NULL; int chosen_item = 0; do { if (NULL == g_title_name) { oppo_error("g_title_name is NULL \n"); result = -1; goto finish_done; } #if DEBUG sd_file_dump_array(zips, zips_desc, z_size); #endif chosen_item = oppo_sdmenu(g_title_name, zips, zips_desc, z_size); /* OPPO 2013-02-18 jizhengkang azx Add begin for reason */ selectedItem[selectedCount] = chosen_item; /* OPPO 2013-02-23 jizhengkang azx Modify begin for reason */ #if 0 if (chosen_item == -1) {//huanggd for exit explorer when select "return" option result = 1; if (result_inter_sd || result_external_sd) { selectedCount = 1; memset(selectedItem + 2, 0, 1022); } else { selectedCount = 2; memset(selectedItem + 3, 0, 1021); } break; } #endif /* OPPO 2013-02-23 jizhengkang azx Modify end */ if (chosen_item == -1) { result = -1; memset(selectedItem + selectedCount, 0, 1024 - selectedCount - 1); selectedCount--; break; } return_val_if_fail(chosen_item >= 0, RET_FAIL); char * item = zips[chosen_item]; return_val_if_fail(item != NULL, RET_FAIL); int item_len = strlen(item); // ((chosen_item > 0)&&(item[item_len - 1] == '/'))?selectedCount++:selectedCount--; // (chosen_item == 0)?selectedCount--:((item[item_len - 1] == '/')?selectedCount++:NULL); /* OPPO 2013-02-18 jizhengkang azx Add end */ /* OPPO 2013-02-23 jizhengkang azx Delete begin for reason */ #if 0 if ( chosen_item == 0) { //go up but continue browsing result = -1; break; } else #endif /* OPPO 2013-02-23 jizhengkang azx Delete end */ if (item[item_len - 1] == '/') { selectedCount++; char new_path[PATH_MAX]; strlcpy(new_path, path, PATH_MAX); strlcat(new_path, "/", PATH_MAX); strlcat(new_path, item, PATH_MAX); new_path[strlen(new_path) - 1] = '\0'; result = _file_scan(new_path, PATH_MAX); if (result > 0) break; } else { // select a zipfile // the status to the caller char new_path[PATH_MAX]; strlcpy(new_path, path, PATH_MAX); strlcat(new_path, "/", PATH_MAX); strlcat(new_path, item, PATH_MAX); int wipe_cache = 0; //if third parameter is 1, echo sucess dialog if (NULL == g_fun) { oppo_error("g_fun is NULL in fun\n"); result = -1; goto finish_done; } if (oppo_get_battery_capacity() < 15) { if (!oppo_is_ac_usb_online()) { oppo_notice(3, "<~sd.install.notice>", "<~sd.install.caplow.desc>", "@sd"); continue; } } if (canvas_sdfile_inited == 0) { canvas_sdfile_inited = 1; ag_canvas(&canvas_sdfile,agw(),agh()); } ag_draw(&canvas_sdfile,agc(),0,0); int ret = g_fun(new_path, PATH_MAX, (void *)g_data); if (0 == ret)//execute callback fun success { //back to up layer //result = -1;//huanggd for exit explorer when install successfully selectedCount = 1; memset(selectedItem + 2, 0, 1022); result = 1; feed_back("2"); } else if(1 == ret){ continue;//cacel install } else { oppo_error("g_fun execute fail\n"); result = 0; feed_back("3"); ag_draw(NULL,&canvas_sdfile,0,0); oppo_notice(3, "<~sd.install.failed.name>", "<~sd.install.failed.desc>", "@sd"); continue; } break; } } while(1); finish_done: for (i = 0; i < z_size; ++i) { free(zips[i]); free(zips_desc[i]); } free(zips); return result; }
struct _menuUnit *mount_ui_init() { struct _menuUnit* p = common_ui_init(); return_null_if_fail(p != NULL); strncpy(p->name, "<~mount.name>", MENU_LEN); menuUnit_set_title(p, "<~mount.title>"); menuUnit_set_icon(p, "@mount"); menuUnit_set_show(p, &mount_menu_show); return_null_if_fail(menuNode_init(p) != NULL); //mount cache? struct _menuUnit* temp = common_ui_init(); assert_if_fail(menuNode_add(p, temp) == RET_OK); return_null_if_fail(menuUnit_set_name(temp, "<~mount.cache.name>") == RET_OK); return_null_if_fail(menuUnit_set_icon(temp, ICON_DISABLE) == RET_OK); return_null_if_fail(menuUnit_set_result(temp, MOUNT_CACHE) == RET_OK); return_null_if_fail(menuUnit_set_desc(temp, MOUNT_DESC_UNMOUNT) == RET_OK); return_null_if_fail(RET_OK == menuUnit_set_show(temp, &mount_child_show)); mount_cache_node = temp; //mount data temp = common_ui_init(); assert_if_fail(menuNode_add(p, temp) == RET_OK); return_null_if_fail(menuUnit_set_name(temp, "<~mount.data.name>") == RET_OK); return_null_if_fail(menuUnit_set_result(temp, MOUNT_DATA) == RET_OK); return_null_if_fail(menuUnit_set_icon(temp, ICON_DISABLE) == RET_OK); return_null_if_fail(menuUnit_set_desc(temp, MOUNT_DESC_UNMOUNT) == RET_OK); return_null_if_fail(RET_OK == menuUnit_set_show(temp, &mount_child_show)); mount_data_node = temp; //mount system temp = common_ui_init(); assert_if_fail(menuNode_add(p, temp) == RET_OK); return_null_if_fail(menuUnit_set_name(temp, "<~mount.system.name>") == RET_OK); return_null_if_fail(menuUnit_set_result(temp, MOUNT_SYSTEM) == RET_OK); return_null_if_fail(menuUnit_set_icon(temp, ICON_DISABLE) == RET_OK); return_null_if_fail(menuUnit_set_desc(temp, MOUNT_DESC_UNMOUNT) == RET_OK); return_null_if_fail(RET_OK == menuUnit_set_show(temp, &mount_child_show)); mount_system_node = temp; //mount sdcard temp = common_ui_init(); assert_if_fail(menuNode_add(p, temp) == RET_OK); return_null_if_fail(menuUnit_set_name(temp, "<~mount.sdcard.name>") == RET_OK); return_null_if_fail(menuUnit_set_result(temp, MOUNT_SDCARD) == RET_OK); return_null_if_fail(menuUnit_set_icon(temp, ICON_DISABLE) == RET_OK); return_null_if_fail(menuUnit_set_desc(temp, MOUNT_DESC_UNMOUNT) == RET_OK); return_null_if_fail(RET_OK == menuUnit_set_show(temp, &mount_child_show)); mount_sd_node = temp; if (acfg()->sd_ext == 1) { //mount internal_sd temp = common_ui_init(); assert_if_fail(menuNode_add(p, temp) == RET_OK); return_null_if_fail(menuUnit_set_name(temp, "<~mount.sdext.name>") == RET_OK); return_null_if_fail(menuUnit_set_result(temp, MOUNT_SDEXT) == RET_OK); return_null_if_fail(menuUnit_set_icon(temp, ICON_DISABLE) == RET_OK); return_null_if_fail(menuUnit_set_desc(temp, MOUNT_DESC_UNMOUNT) == RET_OK); return_null_if_fail(RET_OK == menuUnit_set_show(temp, &mount_child_show)); mount_sd_ext_node = temp; } //toggle usb stroage if (acfg()->lun_file[0] != 0) { temp = common_ui_init(); assert_if_fail(menuNode_add(p, temp) == RET_OK); return_null_if_fail(menuUnit_set_name(temp, "<~mount.toggle.name>") == RET_OK); return_null_if_fail(menuUnit_set_result(temp, MOUNT_TOGGLE) == RET_OK); return_null_if_fail(menuUnit_set_icon(temp, ICON_DISABLE) == RET_OK); return_null_if_fail(menuUnit_set_desc(temp, MOUNT_DESC_UNMOUNT) == RET_OK); return_null_if_fail(RET_OK == menuUnit_set_show(temp, &mount_child_show)); } mount_node = p; return p; }
STATUS wipe_item_show(menuUnit *p) { #ifdef DUALSYSTEM_PARTITIONS int wipe_system_num; if (is_tdb_enabled()) { if (p->result == WIPE_FACTORY) { if (RET_YES == miui_confirm(5, "<~choose.system.title>", "<~choose.system.text>", "@alert", "<~choice.system0.name>", "<~choice.system1.name>")) { wipe_system_num = 0; } else { wipe_system_num = 1; } } } #endif if (RET_YES == miui_confirm(3, p->name, p->desc, p->icon)) { miui_busy_process(); switch(p->result) { case WIPE_FACTORY: #ifdef DUALSYSTEM_PARTITIONS if (is_tdb_enabled()) { miuiIntent_send(INTENT_MOUNT, 1, "/data"); if (wipe_system_num == 0) { __system("rm -rf /data/system0"); } else { __system("rm -rf /data/system1"); } } else { miuiIntent_send(INTENT_WIPE, 1, "/cache"); miuiIntent_send(INTENT_WIPE, 1, "/data"); } #else miuiIntent_send(INTENT_WIPE, 1, "/cache"); miuiIntent_send(INTENT_WIPE, 1, "/data"); #endif break; case WIPE_DATA: miuiIntent_send(INTENT_WIPE, 1, "/data"); break; case WIPE_CACHE: miuiIntent_send(INTENT_WIPE, 1, "/cache"); break; case WIPE_DALVIK: miuiIntent_send(INTENT_WIPE, 1, "dalvik-cache"); break; case FORMAT_SYSTEM: miuiIntent_send(INTENT_FORMAT, 1, "/system"); break; #ifdef DUALSYSTEM_PARTITIONS case FORMAT_SYSTEM1: miuiIntent_send(INTENT_FORMAT, 1, "/system1"); break; #endif case FORMAT_DATA: miuiIntent_send(INTENT_FORMAT, 1, "/data"); break; case FORMAT_CACHE: miuiIntent_send(INTENT_FORMAT, 1, "/cache"); break; case FORMAT_BOOT: miuiIntent_send(INTENT_FORMAT, 1, "/boot"); break; #ifdef DUALSYSTEM_PARTITIONS case FORMAT_BOOT1: miuiIntent_send(INTENT_FORMAT, 1, "/boot1"); break; #endif case FORMAT_SDCARD: miuiIntent_send(INTENT_FORMAT, 1, "/sdcard"); break; case FORMAT_ALL: miuiIntent_send(INTENT_FORMAT, 1, "/system"); miuiIntent_send(INTENT_FORMAT, 1, "/data"); miuiIntent_send(INTENT_FORMAT, 1, "/cache"); break; default: assert_if_fail(0); break; } } return MENU_BACK; }
static STATUS _sd_dir_show(struct _menuUnit *p, char *path) { DIR* d; struct dirent* de; d = opendir(path); return_val_if_fail(d != NULL, RET_FAIL); int d_size = 0; int d_alloc = 10; return_val_if_fail(sd_menu != NULL, RET_FAIL); char** dirs = malloc(d_alloc * sizeof(char*)); char** dirs_desc = malloc(d_alloc * sizeof(char*)); return_val_if_fail(dirs != NULL, RET_FAIL); return_val_if_fail(dirs_desc != NULL, RET_FAIL); int z_size = 1; int z_alloc = 10; char** zips = malloc(z_alloc * sizeof(char*)); char** zips_desc=malloc(z_alloc * sizeof(char*)); return_val_if_fail(zips != NULL, RET_FAIL); return_val_if_fail(zips_desc != NULL, RET_FAIL); zips[0] = strdup("../"); zips_desc[0]=strdup("../"); while ((de = readdir(d)) != NULL) { int name_len = strlen(de->d_name); char de_path[SD_MAX_PATH]; snprintf(de_path, SD_MAX_PATH, "%s/%s", path, de->d_name); struct stat st ; assert_if_fail(stat(de_path, &st) == 0); if (de->d_type == DT_DIR) { //skip "." and ".." entries if (name_len == 1 && de->d_name[0] == '.') continue; if (name_len == 2 && de->d_name[0] == '.' && de->d_name[1] == '.') continue; if (d_size >= d_alloc) { d_alloc *= 2; dirs = realloc(dirs, d_alloc * sizeof(char*)); dirs_desc = realloc(dirs_desc, d_alloc * sizeof(char*)); } dirs[d_size] = malloc(name_len + 2); dirs_desc[d_size] = malloc(64); strcpy(dirs[d_size], de->d_name); dirs[d_size][name_len] = '/'; dirs[d_size][name_len + 1] = '\0'; snprintf(dirs_desc[d_size], 64, "%s" ,ctime(&st.st_mtime)); ++d_size; } else if (de->d_type == DT_REG && name_len >= 4 && strncasecmp(de->d_name + (name_len - 4), ".zip", 4) == 0) { if (z_size >= z_alloc) { z_alloc *= 2; zips = realloc(zips, z_alloc * sizeof(char*)); zips_desc = realloc(zips_desc, z_alloc * sizeof(char*)); } zips[z_size] = strdup(de->d_name); zips_desc[z_size] = malloc(64); snprintf(zips_desc[z_size], 64, "%s %lldbytes" ,ctime(&st.st_mtime), st.st_size); z_size++; } } closedir(d); // append dirs to the zips list if (d_size + z_size + 1 > z_alloc) { z_alloc = d_size + z_size + 1; zips = realloc(zips, z_alloc * sizeof(char*)); zips_desc = realloc(zips_desc, z_alloc * sizeof(char*)); } memcpy(zips + z_size, dirs, d_size * sizeof(char *)); memcpy(zips_desc + z_size, dirs_desc, d_size * sizeof(char*)); free(dirs); z_size += d_size; zips[z_size] = NULL; zips_desc[z_size] = NULL; int result; int chosen_item = 0; do { chosen_item = miui_sdmenu(sd_menu->name, zips, zips_desc, z_size); return_val_if_fail(chosen_item >= 0, RET_FAIL); char * item = zips[chosen_item]; return_val_if_fail(item != NULL, RET_FAIL); int item_len = strlen(item); if ( chosen_item == 0) { //go up but continue browsing result = -1; break; } else if (item[item_len - 1] == '/') { char new_path[SD_MAX_PATH]; strlcpy(new_path, path, SD_MAX_PATH); strlcat(new_path, "/", SD_MAX_PATH); strlcat(new_path, item, SD_MAX_PATH); new_path[strlen(new_path) - 1] = '\0'; result = _sd_dir_show(p, new_path); if (result > 0) break; } else { // select a zipfile // the status to the caller char new_path[SD_MAX_PATH]; strlcpy(new_path, path, SD_MAX_PATH); strlcat(new_path, "/", SD_MAX_PATH); strlcat(new_path, item, SD_MAX_PATH); int wipe_cache = 0; struct _intentResult* result = miuiIntent_send(INTENT_INSTALL, 2, new_path, &wipe_cache); miui_install(p->name, p->icon); break; } } while(1); int i; for (i = 0; i < z_size; ++i) { free(zips[i]); free(zips_desc[i]); } free(zips); return result; }
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; }
static STATUS _backup_dir_show(char *path) { DIR* d; struct dirent* de; d = opendir(path); return_val_if_fail(d != NULL, RET_FAIL); int d_size = 0; int d_alloc = 10; return_val_if_fail(backup_menu != NULL, RET_FAIL); char** dirs = malloc(d_alloc * sizeof(char*)); char** dirs_desc = malloc(d_alloc * sizeof(char*)); return_val_if_fail(dirs != NULL, RET_FAIL); return_val_if_fail(dirs_desc != NULL, RET_FAIL); int z_size = 1; int z_alloc = 10; char** zips = malloc(z_alloc * sizeof(char*)); char** zips_desc=malloc(z_alloc * sizeof(char*)); return_val_if_fail(zips != NULL, RET_FAIL); return_val_if_fail(zips_desc != NULL, RET_FAIL); zips[0] = strdup("../"); zips_desc[0]=strdup("../"); while ((de = readdir(d)) != NULL) { int name_len = strlen(de->d_name); char de_path[PATH_MAX]; snprintf(de_path, PATH_MAX, "%s/%s", path, de->d_name); struct stat st ; assert_if_fail(stat(de_path, &st) == 0); if (de->d_type == DT_DIR) { //skip "." and ".." entries if (name_len == 1 && de->d_name[0] == '.') continue; if (name_len == 2 && de->d_name[0] == '.' && de->d_name[1] == '.') continue; if (d_size >= d_alloc) { d_alloc *= 2; dirs = realloc(dirs, d_alloc * sizeof(char*)); dirs_desc = realloc(dirs_desc, d_alloc * sizeof(char*)); } dirs[d_size] = malloc(name_len + 2); dirs_desc[d_size] = malloc(64); strcpy(dirs[d_size], de->d_name); dirs[d_size][name_len ] = '\0'; snprintf(dirs_desc[d_size], 64, "%s" ,ctime(&st.st_mtime)); ++d_size; } else if (de->d_type == DT_REG && name_len >= 4 && strncasecmp(de->d_name + (name_len - 4), ".zip", 4) == 0) { if (z_size >= z_alloc) { z_alloc *= 2; zips = realloc(zips, z_alloc * sizeof(char*)); zips_desc = realloc(zips_desc, z_alloc * sizeof(char*)); } zips[z_size] = strdup(de->d_name); zips_desc[z_size] = malloc(64); snprintf(zips_desc[z_size], 64, "%s %lldbytes" ,ctime(&st.st_mtime), st.st_size); z_size++; } } closedir(d); // append dirs to the zips list if (d_size + z_size + 1 > z_alloc) { z_alloc = d_size + z_size + 1; zips = realloc(zips, z_alloc * sizeof(char*)); zips_desc = realloc(zips_desc, z_alloc * sizeof(char*)); } memcpy(zips + z_size, dirs, d_size * sizeof(char *)); memcpy(zips_desc + z_size, dirs_desc, d_size * sizeof(char*)); free(dirs); z_size += d_size; zips[z_size] = NULL; zips_desc[z_size] = NULL; int result; int chosen_item = 0; do { chosen_item = miui_sdmenu(backup_menu->name, zips, zips_desc, z_size); return_val_if_fail(chosen_item >= 0, RET_FAIL); char * item = zips[chosen_item]; int item_len = strlen(item); if ( chosen_item == 0) { //go up but continue browsing result = -1; break; } else { // select a zipfile // the status to the caller char new_path[PATH_MAX]; strlcpy(new_path, path, PATH_MAX); strlcat(new_path, "/", PATH_MAX); strlcat(new_path, item, PATH_MAX); /* *nandroid_restore(backup_path, restore_boot, system, data, chache , sdext, wimax) */ if (p_current != NULL && RET_YES == miui_confirm(3, p_current->name, p_current->desc, p_current->icon)) { backup_restore(new_path); } break; } } while(1); int i; for (i = 0; i < z_size; ++i) { free(zips[i]); free(zips_desc[i]); } free(zips); return result; }