int ui_handle_key(int key, int visible) {
#ifdef BOARD_TOUCH_RECOVERY
return touch_handle_key(key, visible);
#else
return device_handle_key(key, visible);
#endif
}
int ui_handle_key(int key, int visible) {
#if defined(BOARD_TOUCH_RECOVERY) || defined(PHILZ_TOUCH_RECOVERY)
return touch_handle_key(key, visible);
#else
return device_handle_key(key, visible);
#endif
}
static int menu_get_selection(Menu* thiz)
{
ui_clear_key_queue();
menu_update_screen(thiz);
int chosen_item = -1;
while (chosen_item < 0) {
int key = ui_wait_key();
int action = device_handle_key(key);
if (action < 0) {
switch (action) {
case HIGHLIGHT_UP:
menu_ui_select_up(thiz);
break;
case HIGHLIGHT_DOWN:
//LOGE("**HIGHLIGHT_DOWN");
menu_ui_select_down(thiz);
break;
case SELECT_ITEM:
chosen_item = thiz->menu_sel;
break;
case NO_ACTION:
break;
}
}
}
return chosen_item;
}
void show_recovery_debugging_menu()
{
static char* headers[] = { "Recovery Debugging",
"",
NULL
};
static char* list[] = { "Report Error",
"Key Test",
"Show log",
"Toggle UI Debugging",
NULL
};
for (;;)
{
int chosen_item = get_menu_selection(headers, list, 0, 0);
if(chosen_item == GO_BACK)
break;
switch(chosen_item)
{
case 0:
handle_failure(1);
break;
case 1:
{
ui_print("Outputting key codes.\n");
ui_print("Go back to end debugging.\n");
struct keyStruct{
int code;
int x;
int y;
}*key;
int action;
do
{
key = ui_wait_key();
if(key->code == ABS_MT_POSITION_X)
{
action = device_handle_mouse(key, 1);
ui_print("Touch: X: %d\tY: %d\n", key->x, key->y);
}
else
{
action = device_handle_key(key->code, 1);
ui_print("Key: %x\n", key->code);
}
}
while (action != GO_BACK);
break;
}
case 2:
ui_printlogtail(12);
break;
case 3:
toggle_ui_debugging();
break;
}
}
}
/**
* get_menu_selection()
*
*/
int get_menu_selection(char** headers, char** items, int menu_only,
int initial_selection) {
// throw away keys pressed previously, so user doesn't
// accidentally trigger menu items.
ui_clear_key_queue();
ui_start_menu(headers, items, initial_selection);
int selected = initial_selection;
int chosen_item = -1;
while (chosen_item < 0) {
#ifdef BOARD_WITH_CPCAP
int level = battery_level();
if (level > 0) {
if ((50 * progress_value) != level / 2) {
progress_value = level / 100.0;
if (level < 20)
ui_print("Low battery ! %3d %%\n", level);
ui_reset_progress();
ui_show_progress(progress_value, 1);
ui_set_progress(1.0);
}
}
#endif
int key = ui_wait_key();
int visible = ui_text_visible();
int action = device_handle_key(key, visible);
if (action < 0) {
switch (action) {
case HIGHLIGHT_UP:
--selected;
selected = ui_menu_select(selected);
break;
case HIGHLIGHT_DOWN:
++selected;
selected = ui_menu_select(selected);
break;
case SELECT_ITEM:
chosen_item = selected;
break;
case ACTION_CANCEL:
chosen_item = GO_BACK;
break;
case NO_ACTION:
break;
}
} else if (!menu_only) {
chosen_item = action;
}
}
ui_end_menu();
return chosen_item;
}
static int
get_menu_selection(char** headers, char** items, int menu_only,
int initial_selection) {
// throw away keys pressed previously, so user doesn't
// accidentally trigger menu items.
ui_clear_key_queue();
ui_start_menu(headers, items, initial_selection);
int selected = initial_selection;
int chosen_item = -1;
while (chosen_item < 0) {
int key = ui_wait_key();
int visible = ui_text_visible();
if (key == -1) { // ui_wait_key() timed out
if (ui_text_ever_visible()) {
continue;
} else {
LOGI("timed out waiting for key input; rebooting.\n");
ui_end_menu();
return ITEM_REBOOT;
}
}
int action = device_handle_key(key, visible);
if (action < 0) {
switch (action) {
case HIGHLIGHT_UP:
--selected;
selected = ui_menu_select(selected);
break;
case HIGHLIGHT_DOWN:
++selected;
selected = ui_menu_select(selected);
break;
case SELECT_ITEM:
chosen_item = selected;
break;
case NO_ACTION:
break;
}
} else if (!menu_only) {
chosen_item = action;
}
}
ui_end_menu();
return chosen_item;
}
int get_menu_selection(char** headers, char** items, int menu_only, int selected) {
// throw away keys pressed previously, so user doesn't
// accidentally trigger menu items.
ui_clear_key_queue();
ui_start_menu(headers, items,selected);
int chosen_item = -1;
while (chosen_item < 0) {
int key = ui_wait_key();
/* char* key_str = calloc(18,sizeof(char));
sprintf(key_str, "Key %d pressed.\n", key);
ui_print(key_str);*/
if (key == KEY_BACKSPACE || key == KEY_END) {
return(ITEM_BACK);
}
int visible = ui_text_visible();
int action = device_handle_key(key, visible);
if (action < 0) {
switch (action) {
case ITEM_BACK:
return(ITEM_BACK);
break;
case HIGHLIGHT_UP:
--selected;
selected = ui_menu_select(selected);
break;
case HIGHLIGHT_DOWN:
++selected;
selected = ui_menu_select(selected);
break;
case SELECT_ITEM:
chosen_item = selected;
break;
case NO_ACTION:
break;
}
} else if (!menu_only) {
chosen_item = action;
}
}
ui_end_menu();
return chosen_item;
}
int get_menu_selection(char** headers, char** items, int menu_only) {
// throw away keys pressed previously, so user doesn't
// accidentally trigger menu items.
ui_clear_key_queue();
ui_start_menu(headers, items);
int selected = 0;
int chosen_item = -1;
while (chosen_item < 0) {
int key = ui_wait_key();
int visible = ui_text_visible();
int action = device_handle_key(key, visible);
if (action < 0) {
switch (action) {
case HIGHLIGHT_UP:
--selected;
selected = ui_menu_select(selected);
break;
case HIGHLIGHT_DOWN:
++selected;
selected = ui_menu_select(selected);
break;
case SELECT_ITEM:
chosen_item = selected;
break;
case NO_ACTION:
break;
}
if(action == SELECT_BACK)
{
chosen_item = action;
break;
}
} else if (!menu_only) {
chosen_item = action;
}
}
ui_end_menu();
return chosen_item;
}
void show_advanced_menu()
{
static char* headers[] = { "Advanced Menu",
"",
NULL
};
static char* list[] = { "reboot recovery",
"reboot to bootloader",
"power off",
"wipe dalvik cache",
"report error",
"key test",
"show log",
"partition sdcard",
"partition external sdcard",
"partition internal sdcard",
NULL
};
char bootloader_mode[PROPERTY_VALUE_MAX];
property_get("ro.bootloader.mode", bootloader_mode, "");
if (!strcmp(bootloader_mode, "download")) {
list[1] = "reboot to download mode";
}
if (!can_partition("/sdcard")) {
list[7] = NULL;
}
if (!can_partition("/external_sd")) {
list[8] = NULL;
}
if (!can_partition("/emmc")) {
list[9] = NULL;
}
for (;;)
{
int chosen_item = get_filtered_menu_selection(headers, list, 0, 0, sizeof(list) / sizeof(char*));
if (chosen_item == GO_BACK)
break;
switch (chosen_item)
{
case 0:
{
ui_print("Rebooting recovery...\n");
reboot_main_system(ANDROID_RB_RESTART2, 0, "recovery");
break;
}
case 1:
{
if (!strcmp(bootloader_mode, "download")) {
ui_print("Rebooting to download mode...\n");
reboot_main_system(ANDROID_RB_RESTART2, 0, "download");
} else {
ui_print("Rebooting to bootloader...\n");
reboot_main_system(ANDROID_RB_RESTART2, 0, "bootloader");
}
break;
}
case 2:
{
ui_print("Shutting down...\n");
reboot_main_system(ANDROID_RB_POWEROFF, 0, 0);
break;
}
case 3:
if (0 != ensure_path_mounted("/data"))
break;
ensure_path_mounted("/sd-ext");
ensure_path_mounted("/cache");
if (confirm_selection( "Confirm wipe?", "Yes - Wipe Dalvik Cache")) {
__system("rm -r /data/dalvik-cache");
__system("rm -r /cache/dalvik-cache");
__system("rm -r /sd-ext/dalvik-cache");
ui_print("Dalvik Cache wiped.\n");
}
ensure_path_unmounted("/data");
break;
case 4:
handle_failure(1);
break;
case 5:
{
ui_print("Outputting key codes.\n");
ui_print("Go back to end debugging.\n");
int key;
int action;
do
{
key = ui_wait_key();
action = device_handle_key(key, 1);
ui_print("Key: %d\n", key);
}
while (action != GO_BACK);
break;
}
case 6:
ui_printlogtail(12);
break;
case 7:
partition_sdcard("/sdcard");
break;
case 8:
partition_sdcard("/external_sd");
break;
case 9:
partition_sdcard("/emmc");
break;
}
}
}
int
get_menu_selection(char** headers, char** items, int menu_only,
int initial_selection) {
// throw away keys pressed previously, so user doesn't
// accidentally trigger menu items.
ui_clear_key_queue();
ui_start_menu(headers, items, initial_selection);
int selected = initial_selection;
int chosen_item = -1;
while (chosen_item < 0) {
int key = ui_wait_key();
int visible = ui_text_visible();
int action = device_handle_key(key, visible);
if (action < 0) {
switch (action) {
case HIGHLIGHT_UP:
--selected;
selected = ui_menu_select(selected);
break;
case HIGHLIGHT_DOWN:
++selected;
selected = ui_menu_select(selected);
break;
case KEY_POWER:
case SELECT_ITEM:
chosen_item = selected;
break;
case UP_A_LEVEL:
if (menu_loc_idx != 0)
{
chosen_item = menu_loc[menu_loc_idx];
}
break;
case HOME_MENU:
if (menu_loc_idx != 0)
{
go_home = 1;
chosen_item = menu_loc[menu_loc_idx];
}
break;
case MENU_MENU:
if (menu_loc_idx == 0)
{
return 3;
} else
{
go_home = 1;
go_menu = 1;
chosen_item = menu_loc[menu_loc_idx];
}
break;
case NO_ACTION:
break;
}
} else if (!menu_only) {
chosen_item = action;
}
}
ui_end_menu();
return chosen_item;
}
int
get_menu_selection(char** headers, char** items, int menu_only,
int initial_selection) {
// throw away keys pressed previously, so user doesn't
// accidentally trigger menu items.
ui_clear_key_queue();
int item_count = ui_start_menu(headers, items, initial_selection);
int selected = initial_selection;
int chosen_item = -1;
// Some users with dead enter keys need a way to turn on power to select.
// Jiggering across the wrapping menu is one "secret" way to enable it.
// We can't rely on /cache or /sdcard since they may not be available.
int wrap_count = 0;
while (chosen_item < 0 && chosen_item != GO_BACK) {
int key = ui_wait_key();
int visible = ui_text_visible();
int action = device_handle_key(key, visible);
int old_selected = selected;
if (action < 0) {
switch (action) {
case HIGHLIGHT_UP:
--selected;
selected = ui_menu_select(selected);
break;
case HIGHLIGHT_DOWN:
++selected;
selected = ui_menu_select(selected);
break;
case SELECT_ITEM:
chosen_item = selected;
if (ui_get_showing_back_button()) {
if (chosen_item == item_count) {
chosen_item = GO_BACK;
}
}
break;
case NO_ACTION:
break;
case GO_BACK:
chosen_item = GO_BACK;
break;
}
} else if (!menu_only) {
chosen_item = action;
}
if (abs(selected - old_selected) > 1) {
wrap_count++;
if (wrap_count == 3) {
wrap_count = 0;
if (ui_get_showing_back_button()) {
ui_print("Back menu button disabled.\n");
ui_set_showing_back_button(0);
}
else {
ui_print("Back menu button enabled.\n");
ui_set_showing_back_button(1);
}
}
}
}
ui_end_menu();
ui_clear_key_queue();
return chosen_item;
}
void show_advanced_menu()
{
static char* headers[] = { "Advanced and Debugging Menu",
"",
NULL
};
static char* list[] = { "Reboot Recovery",
"Wipe Dalvik Cache",
"Wipe Battery Stats",
"Report Error",
"Key Test",
#ifndef BOARD_HAS_SMALL_RECOVERY
"Partition SD Card",
"Fix Permissions",
#ifdef BOARD_HAS_SDCARD_INTERNAL
"Partition Internal SD Card",
#endif
#endif
NULL
};
for (;;)
{
int chosen_item = get_menu_selection(headers, list, 0, 0);
if (chosen_item == GO_BACK)
break;
switch (chosen_item)
{
case 0:
__reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, LINUX_REBOOT_CMD_RESTART2, "recovery");
break;
case 1:
{
if (0 != ensure_path_mounted("/data"))
break;
ensure_path_mounted("/sd-ext");
ensure_path_mounted("/cache");
if (confirm_selection( "Confirm wipe?", "Yes - Wipe Dalvik Cache")) {
__system("rm -r /data/dalvik-cache");
__system("rm -r /cache/dalvik-cache");
__system("rm -r /sd-ext/dalvik-cache");
}
ensure_path_unmounted("/data");
ui_print("Dalvik Cache wiped.\n");
break;
}
case 2:
{
if (confirm_selection( "Confirm wipe?", "Yes - Wipe Battery Stats"))
wipe_battery_stats();
break;
}
case 3:
handle_failure(1);
break;
case 4:
{
ui_print("Outputting key codes.\n");
ui_print("Go back to end debugging.\n");
int key;
int action;
do
{
key = ui_wait_key();
action = device_handle_key(key, 1);
ui_print("Key: %d\n", key);
}
while (action != GO_BACK);
break;
}
case 5:
{
static char* ext_sizes[] = { "128M",
"256M",
"512M",
"1024M",
"2048M",
"4096M",
NULL };
static char* swap_sizes[] = { "0M",
"32M",
"64M",
"128M",
"256M",
NULL };
static char* ext_headers[] = { "Ext Size", "", NULL };
static char* swap_headers[] = { "Swap Size", "", NULL };
int ext_size = get_menu_selection(ext_headers, ext_sizes, 0, 0);
if (ext_size == GO_BACK)
continue;
int swap_size = get_menu_selection(swap_headers, swap_sizes, 0, 0);
if (swap_size == GO_BACK)
continue;
char sddevice[256];
Volume *vol = volume_for_path("/sdcard");
strcpy(sddevice, vol->device);
// we only want the mmcblk, not the partition
sddevice[strlen("/dev/block/mmcblkX")] = NULL;
char cmd[PATH_MAX];
setenv("SDPATH", sddevice, 1);
sprintf(cmd, "sdparted -es %s -ss %s -efs ext3 -s", ext_sizes[ext_size], swap_sizes[swap_size]);
ui_print("Partitioning SD Card... please wait...\n");
if (0 == __system(cmd))
ui_print("Done!\n");
else
ui_print("An error occured while partitioning your SD Card. Please see /tmp/recovery.log for more details.\n");
break;
}
case 6:
{
ensure_path_mounted("/system");
ensure_path_mounted("/data");
ui_print("Fixing permissions...\n");
__system("fix_permissions");
ui_print("Done!\n");
break;
}
case 7:
{
static char* ext_sizes[] = { "128M",
"256M",
"512M",
"1024M",
"2048M",
"4096M",
NULL };
static char* swap_sizes[] = { "0M",
"32M",
"64M",
"128M",
"256M",
NULL };
static char* ext_headers[] = { "Data Size", "", NULL };
static char* swap_headers[] = { "Swap Size", "", NULL };
int ext_size = get_menu_selection(ext_headers, ext_sizes, 0, 0);
if (ext_size == GO_BACK)
continue;
int swap_size = 0;
if (swap_size == GO_BACK)
continue;
char sddevice[256];
Volume *vol = volume_for_path("/emmc");
strcpy(sddevice, vol->device);
// we only want the mmcblk, not the partition
sddevice[strlen("/dev/block/mmcblkX")] = NULL;
char cmd[PATH_MAX];
setenv("SDPATH", sddevice, 1);
sprintf(cmd, "sdparted -es %s -ss %s -efs ext3 -s", ext_sizes[ext_size], swap_sizes[swap_size]);
ui_print("Partitioning Internal SD Card... please wait...\n");
if (0 == __system(cmd))
ui_print("Done!\n");
else
ui_print("An error occured while partitioning your Internal SD Card. Please see /tmp/recovery.log for more details.\n");
break;
}
}
}
}
void show_advanced_menu()
{
static char* headers[] = { "Advanced and Debugging Menu",
"",
NULL
};
static char* list[] = { "Reboot Recovery",
"Wipe Dalvik Cache",
"Wipe Battery Stats",
"Wipe /data/userinit script",
"Report Error",
"Key Test",
#ifndef BOARD_HAS_SMALL_RECOVERY
"Partition SD Card",
"Fix Permissions",
#endif
"Create image for Odin",
"---Flash Kernel------",
"---Flash Recovery----",
"Unlock Kernel 4 Flash",
"Unlock Recovery 4 Flash",
NULL
};
for (;;)
{
int chosen_item = get_menu_selection(headers, list, 0);
if (chosen_item == GO_BACK)
break;
switch (chosen_item)
{
case 0:
__reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, LINUX_REBOOT_CMD_RESTART2, "recovery");
break;
case 1:
{
if (0 != ensure_root_path_mounted("DATA:"))
break;
ensure_root_path_mounted("SDEXT:");
ensure_root_path_mounted("CACHE:");
if (confirm_selection( "Confirm wipe?", "Yes - Wipe Dalvik Cache")) {
__system("rm -r /data/dalvik-cache");
__system("rm -r /cache/dalvik-cache");
__system("rm -r /sd-ext/dalvik-cache");
}
ensure_root_path_unmounted("DATA:");
ui_print("Dalvik Cache wiped.\n");
break;
}
case 2:
{
if (confirm_selection( "Confirm wipe?", "Yes - Wipe Battery Stats"))
wipe_battery_stats();
break;
}
case 3:
ui_print("Wiping /data/userinit.sh...\n");
ensure_root_path_mounted("DATA:");
remove("/data/userinit.sh");
ensure_root_path_unmounted("DATA:");
ui_print("Done.\n");
break;
case 4:
handle_failure(1);
break;
case 5:
{
ui_print("Outputting key codes.\n");
ui_print("Go back to end debugging.\n");
int key;
int action;
do
{
key = ui_wait_key();
action = device_handle_key(key, 1);
ui_print("Key: %d\n", key);
}
while (action != GO_BACK);
break;
}
case 6:
{
static char* ext_sizes[] = { "128M",
"256M",
"512M",
"1024M",
"2048M",
"4096M",
"8192M",
"16384M",
NULL };
static char* swap_sizes[] = { "0M",
"32M",
"64M",
"128M",
"256M",
NULL };
static char* ext_headers[] = { "Ext Size", "", NULL };
static char* swap_headers[] = { "Swap Size", "", NULL };
int ext_size = get_menu_selection(ext_headers, ext_sizes, 0);
if (ext_size == GO_BACK)
continue;
int swap_size = get_menu_selection(swap_headers, swap_sizes, 0);
if (swap_size == GO_BACK)
continue;
char sddevice[256];
const RootInfo *ri = get_root_info_for_path("SDCARD:");
strcpy(sddevice, ri->device);
// we only want the mmcblk, not the partition
sddevice[strlen("/dev/block/mmcblkX")] = NULL;
char cmd[PATH_MAX];
setenv("SDPATH", sddevice, 1);
sprintf(cmd, "sdparted -es %s -ss %s -efs ext3 -s", ext_sizes[ext_size], swap_sizes[swap_size]);
ui_print("Partitioning SD Card... please wait...\n");
if (0 == __system(cmd))
ui_print("Done!\n");
else
ui_print("An error occured while partitioning your SD Card. Please see /tmp/recovery.log for more details.\n");
break;
}
case 7:
{
ensure_root_path_mounted("SYSTEM:");
ensure_root_path_mounted("DATA:");
ui_print("Fixing permissions...\n");
__system("fix_permissions");
ui_print("Done!\n");
break;
}
case 8:
{
// create image for Odin
dump_odin_image();
break;
}
case 9:
{
ui_print("Flashing kernel...\n");
__system("flash_kernel");
ui_print("Done!\n");
break;
}
case 10:
{
ui_print("Flashing recovery...\n");
__system("flash_recovery");
ui_print("Done!\n");
break;
}
case 11:
{
ui_print("Unlocking Kernel...\n");
__system("unlock_kernel");
ui_print("Done!\n");
break;
}
case 12:
{
ui_print("Unlocking Recovery...\n");
__system("unlock_recovery");
ui_print("Done!\n");
break;
}
}
}
}
void show_advanced_menu()
{
static char* headers[] = { "Advanced Menu",
"",
NULL
};
static char* list[] = { "reboot recovery",
"wipe dalvik cache",
"wipe battery stats",
"report error",
"key test",
"show log",
"fix permissions",
"partition sdcard",
"partition external sdcard",
"partition internal sdcard",
NULL
};
if (!can_partition("/sdcard")) {
list[7] = NULL;
}
if (!can_partition("/external_sd")) {
list[8] = NULL;
}
if (!can_partition("/emmc")) {
list[9] = NULL;
}
for (;;)
{
int chosen_item = get_filtered_menu_selection(headers, list, 0, 0, sizeof(list) / sizeof(char*));
if (chosen_item == GO_BACK)
break;
switch (chosen_item)
{
case 0:
android_reboot(ANDROID_RB_RESTART2, 0, "recovery");
break;
case 1:
if (0 != ensure_path_mounted("/data"))
break;
ensure_path_mounted("/sd-ext");
ensure_path_mounted("/cache");
if (confirm_selection( "Confirm wipe?", "Yes - Wipe Dalvik Cache")) {
__system("rm -r /data/dalvik-cache");
__system("rm -r /cache/dalvik-cache");
__system("rm -r /sd-ext/dalvik-cache");
ui_print("Dalvik Cache wiped.\n");
}
ensure_path_unmounted("/data");
break;
case 2:
if (confirm_selection( "Confirm wipe?", "Yes - Wipe Battery Stats"))
wipe_battery_stats();
break;
case 3:
handle_failure(1);
break;
case 4:
{
ui_print("Outputting key codes.\n");
ui_print("Go back to end debugging.\n");
int key;
int action;
do
{
key = ui_wait_key();
action = device_handle_key(key, 1);
ui_print("Key: %d\n", key);
}
while (action != GO_BACK);
break;
}
case 5:
ui_printlogtail(12);
break;
case 6:
ensure_path_mounted("/system");
ensure_path_mounted("/data");
ui_print("Fixing permissions...\n");
__system("fix_permissions");
ui_print("Done!\n");
break;
case 7:
partition_sdcard("/sdcard");
break;
case 8:
partition_sdcard("/external_sd");
break;
case 9:
partition_sdcard("/emmc");
break;
}
}
}
void show_advanced_menu()
{
static char* headers[] = { "Advanced and Debugging Menu",
"",
NULL
};
static char* list[] = { "~~~> Go Back <~~~",
"Report Error",
"Key Test",
#ifndef BOARD_HAS_SMALL_RECOVERY
"Partition SD Card",
"Fix Permissions",
#ifdef BOARD_HAS_SDCARD_INTERNAL
"Partition Internal SD Card",
#endif
#endif
NULL
};
for (;;)
{
int chosen_item = get_menu_selection(headers, list, 0);
if (chosen_item == GO_BACK)
break;
switch (chosen_item)
{
case 0:
{
return;
break;
}
case 1:
handle_failure(1);
break;
case 2:
{
ui_print("Outputting key codes.\n");
ui_print("Go back to end debugging.\n");
int key;
int action;
do
{
key = ui_wait_key();
action = device_handle_key(key, 1);
ui_print("Key: %d\n", key);
}
while (action != GO_BACK);
break;
}
case 3:
{
static char* ext_sizes[] = { "128M",
"256M",
"512M",
"1024M",
"2048M",
"4096M",
NULL };
static char* swap_sizes[] = { "0M",
"32M",
"64M",
"128M",
"256M",
NULL };
static char* ext_headers[] = { "Ext Size", "", NULL };
static char* swap_headers[] = { "Swap Size", "", NULL };
int ext_size = get_menu_selection(ext_headers, ext_sizes, 0);
if (ext_size == GO_BACK)
continue;
int swap_size = get_menu_selection(swap_headers, swap_sizes, 0);
if (swap_size == GO_BACK)
continue;
char sddevice[256];
const RootInfo *ri = get_root_info_for_path("SDCARD:");
strcpy(sddevice, ri->device);
// we only want the mmcblk, not the partition
sddevice[strlen("/dev/block/mmcblkX")] = NULL;
char cmd[PATH_MAX];
setenv("SDPATH", sddevice, 1);
sprintf(cmd, "sdparted -es %s -ss %s -efs ext3 -s", ext_sizes[ext_size], swap_sizes[swap_size]);
ui_print("Partitioning SD Card... please wait...\n");
if (0 == __system(cmd))
ui_print("Done!\n");
else
ui_print("An error occured while partitioning your SD Card. Please see /tmp/recovery.log for more details.\n");
break;
}
case 4:
{
ensure_root_path_mounted("SYSTEM:");
ensure_root_path_mounted("DATA:");
ui_print("Fixing permissions...\n");
__system("fix_permissions");
ui_print("Done!\n");
break;
}
case 5:
{
static char* ext_sizes[] = { "128M",
"256M",
"512M",
"1024M",
"2048M",
"4096M",
NULL };
static char* swap_sizes[] = { "0M",
"32M",
"64M",
"128M",
"256M",
NULL };
static char* ext_headers[] = { "Data Size", "", NULL };
static char* swap_headers[] = { "Swap Size", "", NULL };
int ext_size = get_menu_selection(ext_headers, ext_sizes, 0);
if (ext_size == GO_BACK)
continue;
int swap_size = 0;
if (swap_size == GO_BACK)
continue;
char sddevice[256];
const RootInfo *ri = get_root_info_for_path("SDINTERNAL:");
strcpy(sddevice, ri->device);
// we only want the mmcblk, not the partition
sddevice[strlen("/dev/block/mmcblkX")] = NULL;
char cmd[PATH_MAX];
setenv("SDPATH", sddevice, 1);
sprintf(cmd, "sdparted -es %s -ss %s -efs ext3 -s", ext_sizes[ext_size], swap_sizes[swap_size]);
ui_print("Partitioning Internal SD Card... please wait...\n");
if (0 == __system(cmd))
ui_print("Done!\n");
else
ui_print("An error occured while partitioning your Internal SD Card. Please see /tmp/recovery.log for more details.\n");
break;
}
}
}
}
static int
get_menu_selection(char** headers, char** items, unsigned char* selectability, int title_length, int start_sel, int menu_only)
{
// throw away keys pressed previously, so user doesn't
// accidentally trigger menu items.
ui_clear_key_queue();
//get no items
int num_items = 0;
while (items[num_items] != NULL)
num_items++;
if (start_sel >= num_items)
start_sel = num_items - 1;
if (start_sel < 0)
start_sel = 0;
ui_start_menu(headers, items, title_length, start_sel);
int selected = start_sel;
int chosen_item = -1;
while (chosen_item < 0)
{
int key = ui_wait_key();
int visible = ui_text_visible();
int action = device_handle_key(key, visible);
if (action < 0)
{
switch (action)
{
case HIGHLIGHT_UP:
while(1)
{
--selected;
//wrap
if (selected < 0)
selected = num_items - 1;
if (selectability[selected])
break;
}
selected = ui_menu_select(selected);
break;
case HIGHLIGHT_DOWN:
while(1)
{
++selected;
//wrap
if (selected >= num_items)
selected = 0;
if (selectability[selected])
break;
}
selected = ui_menu_select(selected);
break;
case SELECT_ITEM:
chosen_item = selected;
break;
case NO_ACTION:
break;
}
}
else if (!menu_only)
chosen_item = action;
}
//check first if to hide menu (don't do on menu changes or tags),
//because the flicker is annoying
//that is implemented elsewhere
//ui_end_menu();
return chosen_item;
}
void show_advanced_menu()
{
static char* headers[] = { "高级设置",
"",
NULL
};
static char* list[] = { "清空Dalvik Cache",
"发送错误报告",
"按键测试",
"显示日志",
"对SD卡进行分区",
"对外置SD卡进行分区",
"对内置SD卡进行分区",
NULL
};
if (!can_partition("/sdcard")) {
list[4] = NULL;
}
if (!can_partition("/external_sd")) {
list[5] = NULL;
}
if (!can_partition("/emmc")) {
list[6] = NULL;
}
for (;;)
{
int chosen_item = get_filtered_menu_selection(headers, list, 0, 0, sizeof(list) / sizeof(char*));
if (chosen_item == GO_BACK)
break;
switch (chosen_item)
{
case 0:
if (0 != ensure_path_mounted("/data"))
break;
ensure_path_mounted("/sd-ext");
ensure_path_mounted("/cache");
if (confirm_selection( "确定清空？", "是 - 清空Dalvik Cache")) {
__system("rm -r /data/dalvik-cache");
__system("rm -r /cache/dalvik-cache");
__system("rm -r /sd-ext/dalvik-cache");
ui_print("Dalvik Cache 已经清空！\n");
}
ensure_path_unmounted("/data");
break;
case 1:
handle_failure(1);
break;
case 2:
{
ui_print("正在进行键位测试\n");
ui_print("按返回结束测试.\n");
int key;
int action;
do
{
key = ui_wait_key();
action = device_handle_key(key, 1);
ui_print("键值: %d\n", key);
}
while (action != GO_BACK);
break;
}
case 3:
ui_printlogtail(12);
break;
case 4:
partition_sdcard("/sdcard");
break;
case 5:
partition_sdcard("/external_sd");
break;
case 6:
partition_sdcard("/emmc");
break;
}
}
}
int ui_handle_key(int key, int visible) {
return device_handle_key(key, visible);
}
