static STATUS backup_restore(char* path)
{
return_val_if_fail(p_current != NULL, RET_FAIL);
miui_busy_process();
switch(p_current->result) {
case RESTORE_ALL:
miuiIntent_send(INTENT_RESTORE, 7, path, "1", "1", "1", "1", "0", "0");
break;
case RESTORE_CACHE:
miuiIntent_send(INTENT_RESTORE, 7, path, "0", "0", "0", "1", "0", "0");
break;
case RESTORE_DATA:
miuiIntent_send(INTENT_RESTORE, 7, path, "0", "0", "1", "0", "0", "0");
break;
case RESTORE_SYSTEM:
miuiIntent_send(INTENT_RESTORE, 7, path, "0", "1", "0", "0", "0", "0");
break;
case RESTORE_BOOT:
miuiIntent_send(INTENT_RESTORE, 7, path, "1", "0", "0", "0", "0", "0");
break;
default:
miui_error("p->resulte %d should not be the value\n", p_current->result);
break;
}
return RET_OK;
}
//callback function , success return 0, non-zero fail
int file_install(char *file_name, int file_len, void *data)
{
return_val_if_fail(file_name != NULL, RET_FAIL);
return_val_if_fail(strlen(file_name) <= file_len, RET_INVALID_ARG);
return_val_if_fail(data != NULL, RET_FAIL);
#ifdef DUALSYSTEM_PARTITIONS
int choose_system_num;
if (is_tdb_enabled()) {
if (RET_YES == miui_confirm(5, "<~choose.system.title>", "<~choose.system.text>", "@alert", "<~choice.system0.name>", "<~choice.system1.name>")) {
miuiIntent_send(INTENT_SETSYSTEM,1,"1");
} else {
miuiIntent_send(INTENT_SETSYSTEM,1,"2");
}
}
#endif
struct _menuUnit *p = (pmenuUnit)data;
if (RET_YES == miui_confirm(3, p->name, p->desc, p->icon)) {
miuiIntent_send(INTENT_INSTALL, 3, file_name, "0", "1");
#ifdef DUALSYSTEM_PARTITIONS
miuiIntent_send(INTENT_SETSYSTEM,1,"0");
#endif
return 0;
}
else {
#ifdef DUALSYSTEM_PARTITIONS
miuiIntent_send(INTENT_SETSYSTEM,1,"0");
#endif
return -1;
}
}
static STATUS sd_update_show(menuUnit *p)
{
char new_path[SD_MAX_PATH];
snprintf(new_path, SD_MAX_PATH, "%s", "/sdcard/update.zip");
int wipe_cache = 0;
struct _intentResult* result = miuiIntent_send(INTENT_INSTALL, 2, new_path, &wipe_cache);
if (strstr(miuiIntent_result_get_string(), "cache") != NULL)
miuiIntent_send(INTENT_WIPE, 1, "/cache");
miui_install(p->name, p->icon);
return MENU_BACK;
}
STATUS info_mount_show(struct _menuUnit* p)
{
miuiIntent_send(INTENT_MOUNT, 1, "/data");
miuiIntent_send(INTENT_MOUNT, 1, "/cache");
miuiIntent_send(INTENT_MOUNT, 1, "/system");
miuiIntent_send(INTENT_MOUNT, 1, "/sdcard");
char command[256];
snprintf(command, 256, "df -hP > %s", MOUNT_LOG);
miuiIntent_send(INTENT_SYSTEM, 1, command);
snprintf(command, 256, "%s", MOUNT_LOG);
miui_textbox(p->name, p->title_name, p->icon, miui_readfromfs(command));
return MENU_BACK;
}
//SET DEFAULT BACKUP FORMAT
static STATUS set_default_backup_format(struct _menuUnit* p) {
switch (p->result) {
case TAR_FORMAT:
miuiIntent_send(INTENT_MOUNT, 1, "/sdcard");
miuiIntent_send(INTENT_BACKUP_FORMAT, 1, "tar");
break;
case DUP_FORMAT:
miuiIntent_send(INTENT_MOUNT, 1, "/sdcard");
miuiIntent_send(INTENT_BACKUP_FORMAT, 1, "dup");
break;
default:
//we should never get here!
break;
}
return MENU_BACK;
}
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_update_show(menuUnit *p)
{
char new_path[SD_MAX_PATH] = "/sdcard/update.zip";
int wipe_cache = 0;
if (RET_YES == miui_confirm(3, p->name, p->desc, p->icon)) {
miuiIntent_send(INTENT_INSTALL, 3, new_path, "0", "1");
}
return MENU_BACK;
}
static STATUS sdext_menu_show(menuUnit *p)
{
//ensure_mounte sd path
struct _intentResult* result = miuiIntent_send(INTENT_MOUNT, 1, "/external_sd");
//whatever wether sdd is mounted, scan sdcard and go on
//assert_if_fail(miuiIntent_result_get_int() == 0);
int ret ;
ret = file_scan("/external_sd", sizeof("/external_sd"), p->name, strlen(p->name), &file_install, (void *)p, &file_filter);
if (ret == -1) return MENU_BACK;
return ret;
}
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 sd_update_show(menuUnit *p)
{
char new_path[SD_MAX_PATH] = "/sdcard/update.zip";
int wipe_cache = 0;
#ifdef DUALSYSTEM_PARTITIONS
int choose_system_num;
if (is_tdb_enabled()) {
if (RET_YES == miui_confirm(5, "<~choose.system.title>", "<~choose.system.text>", "@alert", "<~choice.system0.name>", "<~choice.system1.name>")) {
miuiIntent_send(INTENT_SETSYSTEM,1,"1");
} else {
miuiIntent_send(INTENT_SETSYSTEM,1,"2");
}
}
#endif
if (RET_YES == miui_confirm(3, p->name, p->desc, p->icon)) {
miuiIntent_send(INTENT_INSTALL, 3, new_path, "0", "1");
}
miuiIntent_send(INTENT_SETSYSTEM,1,"0");
return MENU_BACK;
}
//callback function , success return 0, non-zero fail
int file_install(char *file_name, int file_len, void *data)
{
return_val_if_fail(file_name != NULL, RET_FAIL);
return_val_if_fail(strlen(file_name) <= file_len, RET_INVALID_ARG);
return_val_if_fail(data != NULL, RET_FAIL);
struct _menuUnit *p = (pmenuUnit)data;
if (RET_YES == miui_confirm(3, p->name, p->desc, p->icon)) {
miuiIntent_send(INTENT_INSTALL, 3, file_name, "0", "1");
return 0;
}
else return -1;
}
static STATUS mount_child_show(menuUnit *p)
{
return_val_if_fail(p != NULL, MENU_BACK);
intentType intent_type = (p->desc[0] == '0')?INTENT_MOUNT : INTENT_UNMOUNT;
switch(p->result)
{
case MOUNT_CACHE:
miuiIntent_send(intent_type, 1, "/cache");
break;
case MOUNT_DATA:
miuiIntent_send(intent_type, 1, "/data");
break;
case MOUNT_SYSTEM:
miuiIntent_send(intent_type, 1, "/system");
break;
case MOUNT_SDCARD:
miuiIntent_send(intent_type, 1, "/sdcard");
break;
case MOUNT_SDEXT:
miuiIntent_send(intent_type, 1, "/internal_sd");
break;
case MOUNT_TOGGLE:
{
if (intent_type == INTENT_MOUNT)
//mount
miuiIntent_send(INTENT_TOGGLE, 1, "1");
else
//untoggle
miuiIntent_send(INTENT_TOGGLE, 1, "0");
break;
}
default:
break;
}
if(strstr(miuiIntent_result_get_string(), "mounted") != NULL)
{
menuUnit_set_icon(p, ICON_ENABLE);
menuUnit_set_desc(p, MOUNT_DESC_MOUNT);
}
else if(strstr(miuiIntent_result_get_string(), "ok") != NULL)
{
menuUnit_set_icon(p, ICON_DISABLE);
menuUnit_set_desc(p, MOUNT_DESC_UNMOUNT);
}
else
{
assert_ui_if_fail(0);
}
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;
}
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 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_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;
}
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;
}
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;
}
