Пример #1
0
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;
}
Пример #2
0
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;
}
Пример #3
0
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;
}
Пример #4
0
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;
}
Пример #5
0
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;
}
Пример #6
0
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;
}
Пример #7
0
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;
}
Пример #8
0
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;
}
Пример #9
0
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;   
}
Пример #10
0
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);
}
Пример #11
0
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
}
Пример #12
0
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;
}
Пример #13
0
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;
}
Пример #14
0
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;
}
Пример #15
0
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;
}
Пример #16
0
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;

}
Пример #17
0
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;
}
Пример #18
0
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;
}
Пример #19
0
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;
}
Пример #20
0
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;

}
Пример #21
0
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;

}
Пример #22
0
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;
}
Пример #23
0
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;
}
Пример #24
0
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;
}