// reboot: Reboot the system. Return -1 on error, no return on success
int TWFunc::tw_reboot(RebootCommand command)
{
// Always force a sync before we reboot
sync();
switch (command) {
case rb_current:
case rb_system:
Update_Log_File();
Update_Intent_File("s");
sync();
check_and_run_script("/sbin/rebootsystem.sh", "reboot system");
return reboot(RB_AUTOBOOT);
case rb_recovery:
check_and_run_script("/sbin/rebootrecovery.sh", "reboot recovery");
return __reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, LINUX_REBOOT_CMD_RESTART2, (void*) "recovery");
case rb_bootloader:
check_and_run_script("/sbin/rebootbootloader.sh", "reboot bootloader");
return __reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, LINUX_REBOOT_CMD_RESTART2, (void*) "bootloader");
case rb_poweroff:
check_and_run_script("/sbin/poweroff.sh", "power off");
#ifdef ANDROID_RB_POWEROFF
android_reboot(ANDROID_RB_POWEROFF, 0, 0);
#endif
return reboot(RB_POWER_OFF);
case rb_download:
check_and_run_script("/sbin/rebootdownload.sh", "reboot download");
return __reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, LINUX_REBOOT_CMD_RESTART2, (void*) "download");
default:
return -1;
}
return -1;
}
int reboot_main(int argc, char *argv[])
{
int ret;
int nosync = 0;
int poweroff = 0;
opterr = 0;
do {
int c;
c = getopt(argc, argv, "np");
if (c == EOF) {
break;
}
switch (c) {
case 'n':
nosync = 1;
break;
case 'p':
poweroff = 1;
break;
case '?':
fprintf(stderr, "usage: %s [-n] [-p] [rebootcommand]\n", argv[0]);
exit(EXIT_FAILURE);
}
} while (1);
if(argc > optind + 1) {
fprintf(stderr, "%s: too many arguments\n", argv[0]);
exit(EXIT_FAILURE);
}
if(!nosync)
sync();
if(poweroff)
ret = __reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, LINUX_REBOOT_CMD_POWER_OFF, NULL);
else if(argc > optind) {
#ifdef RECOVERY_PRE_COMMAND
if (!strncmp(argv[optind],"recovery",8))
system( RECOVERY_PRE_COMMAND );
#endif
ret = __reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, LINUX_REBOOT_CMD_RESTART2, argv[optind]);
} else
ret = reboot(RB_AUTOBOOT);
if(ret < 0) {
perror("reboot");
exit(EXIT_FAILURE);
}
fprintf(stderr, "reboot returned\n");
return 0;
}
void powermenu()
{
static char* headers[] = { "Power Menu",
"",
NULL
};
static char* list[] = { "~~~> Go Back <~~~",
"Power Off",
"Reboot",
"Reboot Recovery",
"Download Mode",
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:
{
__reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, LINUX_REBOOT_CMD_POWER_OFF, NULL);
break;
}
case 2:
{
reboot(RB_AUTOBOOT);
break;
}
case 3:
{
__reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, LINUX_REBOOT_CMD_RESTART2, "recovery");
break;
}
case 4:
{
__system("reboot download");
break;
}
}
}
}
void reboot_service(int fd, void *arg)
{
char buf[100];
int pid, ret;
sync();
/* Attempt to unmount the SD card first.
* No need to bother checking for errors.
*/
pid = fork();
if (pid == 0) {
/* ask vdc to unmount it */
execl("/system/bin/vdc", "/system/bin/vdc", "volume", "unmount",
getenv("EXTERNAL_STORAGE"), "force", NULL);
} else if (pid > 0) {
/* wait until vdc succeeds or fails */
waitpid(pid, &ret, 0);
}
ret = __reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2,
LINUX_REBOOT_CMD_RESTART2, (char *)arg);
if (ret < 0) {
snprintf(buf, sizeof(buf), "reboot failed: %s\n", strerror(errno));
writex(fd, buf, strlen(buf));
}
free(arg);
adb_close(fd);
}
void
get_message()
{
char lbuf[20];
int i, ch;
lbuf[0] = 'R';
i = 1;
while(i < 20) {
if ( ttyE_poll() == 0) {
ch = ttyE_in();
lbuf[i] = ch;
i++;
}
if ( ch == '\n') {
break;
}
}
lbuf[9] = 0;
if ( strcmp(lbuf, "Reboot###") == 0) {
printf("Rebooting the System, Please Wait\n");
NU_Sleep(200);
DISABLE_INT;
__reboot();
}
printf("Done\n");
}
int android_reboot(int cmd, int flags, char *arg)
{
int ret;
if (!(flags & ANDROID_RB_FLAG_NO_SYNC))
sync();
if (!(flags & ANDROID_RB_FLAG_NO_REMOUNT_RO))
remount_ro();
switch (cmd) {
case ANDROID_RB_RESTART:
ret = reboot(RB_AUTOBOOT);
break;
case ANDROID_RB_POWEROFF:
ret = reboot(RB_POWER_OFF);
break;
case ANDROID_RB_RESTART2:
ret = __reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2,
LINUX_REBOOT_CMD_RESTART2, arg);
break;
default:
ret = -1;
}
return ret;
}
// reboot: Reboot the system. Return -1 on error, no return on success
int tw_reboot(RebootCommand command)
{
if (DataManager_GetIntValue(TW_BACKUP_SYSTEM_SIZE) < DataManager_GetIntValue(TW_MIN_SYSTEM_VAR)) {
update_system_details();
if (DataManager_GetIntValue(TW_BACKUP_SYSTEM_SIZE) < DataManager_GetIntValue(TW_MIN_SYSTEM_VAR)) {
LOGE("System is not installed - preventing reboot!\n");
return -1;
}
}
// Always force a sync before we reboot
sync();
ensure_path_unmounted("/sdcard");
switch (command)
{
case rb_current:
case rb_system:
finish_recovery("s");
sync();
check_and_run_script("/sbin/rebootsystem.sh", "reboot system");
return reboot(RB_AUTOBOOT);
case rb_recovery:
check_and_run_script("/sbin/rebootrecovery.sh", "reboot recovery");
return __reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, LINUX_REBOOT_CMD_RESTART2, (void*) "recovery");
case rb_bootloader:
check_and_run_script("/sbin/rebootbootloader.sh", "reboot bootloader");
return __reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, LINUX_REBOOT_CMD_RESTART2, (void*) "bootloader");
case rb_poweroff:
check_and_run_script("/sbin/poweroff.sh", "power off");
return reboot(RB_POWER_OFF);
case rb_download:
check_and_run_script("/sbin/rebootdownload.sh", "reboot download");
return __reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, LINUX_REBOOT_CMD_RESTART2, (void*) "download");
return 1;
default:
return -1;
}
return -1;
}
static void* restart_routine(void *arg) {
ALOGD("Ready to restarting system after %d seconds!", RESTART_WAITING_TIME);
usleep(RESTART_WAITING_TIME*1000*1000);
sync();
ALOGD("byebye");
//TBD: need check if we have to unmount fs.
__reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2,
LINUX_REBOOT_CMD_RESTART2, REBSTART_REASON);
return 0;
}
int reboot_main(int argc, char *argv[])
{
int ret;
int nosync = 0;
int poweroff = 0;
opterr = 0;
do {
int c;
c = getopt(argc, argv, "np");
if (c == EOF) {
break;
}
switch (c) {
case 'n':
nosync = 1;
break;
case 'p':
poweroff = 1;
break;
case '?':
fprintf(stderr, "usage: %s [-n] [-p] [rebootcommand]\n", argv[0]);
exit(EXIT_FAILURE);
}
} while (1);
if(argc > optind + 1) {
fprintf(stderr, "%s: too many arguments\n", argv[0]);
exit(EXIT_FAILURE);
}
if(!nosync)
sync();
if(poweroff)
ret = __reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, LINUX_REBOOT_CMD_POWER_OFF, NULL);
else if(argc > optind) {
ret = reboot_wrapper(argv[optind]);
} else
ret = reboot_wrapper(NULL);
if(ret < 0) {
perror("reboot");
exit(EXIT_FAILURE);
}
fprintf(stderr, "reboot returned\n");
return 0;
}
void reboot_service(int fd, void *arg)
{
char buf[100];
int ret;
sync();
ret = __reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2,
LINUX_REBOOT_CMD_RESTART2, (char *)arg);
if (ret < 0) {
snprintf(buf, sizeof(buf), "reboot failed: %s\n", strerror(errno));
writex(fd, buf, strlen(buf));
}
free(arg);
adb_close(fd);
}
int android_reboot(int cmd, int flags, char *arg)
{
int ret = 0;
int reason = -1;
#ifdef RECOVERY_PRE_COMMAND
if (cmd == (int) ANDROID_RB_RESTART2) {
if (arg && strlen(arg) > 0) {
char cmd[PATH_MAX];
sprintf(cmd, RECOVERY_PRE_COMMAND " %s", arg);
system(cmd);
}
}
#endif
sync();
remount_ro();
switch (cmd) {
case ANDROID_RB_RESTART:
reason = RB_AUTOBOOT;
break;
case ANDROID_RB_POWEROFF:
ret = reboot(RB_POWER_OFF);
return ret;
case ANDROID_RB_RESTART2:
// REBOOT_MAGIC
break;
default:
return -1;
}
#ifdef RECOVERY_PRE_COMMAND_CLEAR_REASON
reason = RB_AUTOBOOT;
#endif
if (reason != -1)
ret = reboot(reason);
else
ret = __reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2,
LINUX_REBOOT_CMD_RESTART2, arg);
return ret;
}
/**
* prompt_and_wait()
*
*/
static void prompt_and_wait() {
int select = 0;
for (;;) {
int chosen_item = get_menu_selection(main_headers, MENU_ITEMS, 0, select);
// device-specific code may take some action here. It may
// return one of the core actions handled in the switch
// statement below.
if (chosen_item >= 0 && chosen_item <= ITEM_LAST) {
switch (chosen_item) {
case ITEM_REBOOT:
sync();
reboot_wrapper(NULL);
return;
case ITEM_BOOT:
if (show_menu_boot()) return;
break;
#if STOCK_VERSION
case ITEM_SYSTEM:
if (show_menu_system()) return;
break;
#elif !defined(NO_OVERCLOCK)
case ITEM_OVERCLOCK:
if (show_menu_overclock()) return;
break;
#endif
case ITEM_RECOVERY:
if (show_menu_recovery()) return;
break;
case ITEM_TOOLS:
if (show_menu_tools()) return;
break;
case ITEM_POWEROFF:
sync();
__reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, LINUX_REBOOT_CMD_POWER_OFF, NULL);
return;
}
select = chosen_item;
}
}
}
void power_key_alarm(void *_)
{
/* Delete the timers before reboot the phone. */
alarm_cancel(screen_brightness_animation_alarm2);
alarm_cancel(screen_brightness_animation_alarm1);
alarm_cancel(animation_alarm);
/* Set powerup reason outof-charge-only to MBM. */
int ret = __reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, LINUX_REBOOT_CMD_RESTART2, "outofcharge");
ALOGD("reboot to outofcharge!\n");
if(ret < 0) {
ALOGD("reboot fail!\n");
}
else {
quit = 1;
}
}
static void android_os_Power_reboot(JNIEnv *env, jobject clazz, jstring reason)
{
sync();
#ifdef HAVE_ANDROID_OS
if (reason == NULL) {
reboot(RB_AUTOBOOT);
} else {
const char *chars = env->GetStringUTFChars(reason, NULL);
#ifdef RECOVERY_PRE_COMMAND
if (!strncmp(chars,"recovery",8))
system( RECOVERY_PRE_COMMAND );
#endif
__reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2,
LINUX_REBOOT_CMD_RESTART2, (char*) chars);
env->ReleaseStringUTFChars(reason, chars); // In case it fails.
}
jniThrowIOException(env, errno);
#endif
}
/* Remounting filesystems read-only is difficult when there are files
* opened for writing or pending deletes on the filesystem. There is
* no way to force the remount with the mount(2) syscall. The magic sysrq
* 'u' command does an emergency remount read-only on all writable filesystems
* that have a block device (i.e. not tmpfs filesystems) by calling
* emergency_remount(), which knows how to force the remount to read-only.
* Unfortunately, that is asynchronous, and just schedules the work and
* returns. The best way to determine if it is done is to read /proc/mounts
* repeatedly until there are no more writable filesystems mounted on
* block devices.
*/
static void remount_ro(void)
{
int fd, cnt = 0;
/* Trigger the remount of the filesystems as read-only,
* which also marks them clean.
*/
fd = open("/proc/sysrq-trigger", O_WRONLY);
if (fd < 0) {
return;
}
write(fd, "u", 1);
close(fd);
/* Now poll /proc/mounts till it's done */
#ifdef STE_HARDWARE
while (!remount_ro_done() && (cnt < 50)) {
#else
while (!remount_ro_done() && (cnt < 3600)) {
#endif
usleep(100000);
cnt++;
}
return;
}
int android_reboot(int cmd, int flags, char *arg)
{
int ret = 0;
int reason = -1;
#ifdef RECOVERY_PRE_COMMAND
if (cmd == (int) ANDROID_RB_RESTART2) {
if (arg && strlen(arg) > 0) {
char cmd[PATH_MAX];
sprintf(cmd, RECOVERY_PRE_COMMAND " %s", arg);
system(cmd);
}
}
#endif
sync();
remount_ro();
switch (cmd) {
case ANDROID_RB_RESTART:
reason = RB_AUTOBOOT;
break;
case ANDROID_RB_POWEROFF:
ret = reboot(RB_POWER_OFF);
return ret;
case ANDROID_RB_RESTART2:
// REBOOT_MAGIC
break;
default:
return -1;
}
#ifdef RECOVERY_PRE_COMMAND_CLEAR_REASON
reason = RB_AUTOBOOT;
#endif
if (reason != -1)
ret = reboot(reason);
else
ret = __reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2,
LINUX_REBOOT_CMD_RESTART2, arg);
return ret;
}
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;
}
}
}
}
int reboot (int mode)
{
return __reboot( LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, mode, NULL );
}
void twrp_themes_menu()
{
static char* MENU_THEMES_HEADERS[] = { "twrp Theme Chooser",
"Taste tEh Rainbow:",
NULL };
char* MENU_THEMES[] = { "[REBOOT AND APPLY THEME]",
checkTheme(TW_THEME),
checkTheme(CM_THEME),
checkTheme(RED_THEME),
checkTheme(GOOGLE_THEME),
checkTheme(JF_THEME),
checkTheme(HTC_THEME),
checkTheme(FABULOUS_THEME),
checkTheme(PURPLE_SHIFT),
checkTheme(GREYBALLER_THEME),
checkTheme(TRIPPY_THEME),
checkTheme(SHIFTY_BASTARD),
"<-- Back To twrp Settings",
NULL };
char** headers = prepend_title(MENU_THEMES_HEADERS);
inc_menu_loc(THEMES_BACK);
for (;;)
{
int chosen_item = get_menu_selection(headers, MENU_THEMES, 0, 0);
switch (chosen_item)
{
case THEME_REBOOT_RECOVERY:
ensure_path_unmounted("/sdcard");
__reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, LINUX_REBOOT_CMD_RESTART2, "recovery");
break;
case TW_THEME:
strcpy(tw_color_theme_val,"0");
break;
case CM_THEME:
strcpy(tw_color_theme_val,"1");
break;
case RED_THEME:
strcpy(tw_color_theme_val,"2");
break;
case GOOGLE_THEME:
strcpy(tw_color_theme_val,"3");
break;
case JF_THEME:
strcpy(tw_color_theme_val,"4");
break;
case HTC_THEME:
strcpy(tw_color_theme_val,"5");
break;
case FABULOUS_THEME:
strcpy(tw_color_theme_val,"6");
break;
case PURPLE_SHIFT:
strcpy(tw_color_theme_val,"7");
break;
case GREYBALLER_THEME:
strcpy(tw_color_theme_val,"8");
break;
case TRIPPY_THEME:
strcpy(tw_color_theme_val,"9");
break;
case SHIFTY_BASTARD:
strcpy(tw_color_theme_val,"10");
break;
case THEMES_BACK:
dec_menu_loc();
return;
}
if (go_home) {
dec_menu_loc();
return;
}
write_s_file();
break;
}
ui_end_menu();
dec_menu_loc();
twrp_themes_menu();
}
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;
}
}
}
}
uint8_t bootmgr_handle_key(int key)
{
if(sleep_mode)
{
bootmgr_do_sleep(0);
return 0;
}
switch(bootmgr_phase)
{
case BOOTMGR_MAIN:
{
switch(key)
{
case KEY_VOLUMEDOWN:
{
if(++bootmgr_selected == 4)
bootmgr_selected = 0;
break;
}
case KEY_VOLUMEUP:
{
if(--bootmgr_selected == -1)
bootmgr_selected = 3;
break;
}
case KEY_BACK:
bootmgr_printf(-1, 25, WHITE, "Rebooting...");
bootmgr_draw();
__reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, LINUX_REBOOT_CMD_RESTART2, "recovery");
return 1;
case KEY_END:
{
bootmgr_do_sleep(!sleep_mode);
break;
}
case KEY_POWER:
{
reboot(RB_POWER_OFF);
return 1;
}
case KEY_MENU:
{
switch(bootmgr_selected)
{
case 0: bootmgr_boot_internal(); return 1;
case 1:
if(bootmgr_show_rom_list())
return 1;
break;
case 2: bootmgr_touch_ums(); break;
case 3: bootmgr_touch_misc(); break;
}
break;
}
case KEY_SEARCH:
{
bootmgr_charger_init();
break;
}
default: break;
}
break;
}
case BOOTMGR_SD_SEL:
{
switch(key)
{
case KEY_VOLUMEDOWN:
bootmgr_touch_sd_down();
break;
case KEY_VOLUMEUP:
bootmgr_touch_sd_up();
break;
case KEY_MENU:
return bootmgr_boot_sd();
case KEY_BACK:
bootmgr_touch_sd_exit();
break;
default:break;
}
break;
}
case BOOTMGR_TETRIS:
{
tetris_key(key);
break;
}
case BOOTMGR_UMS:
{
if(key != KEY_SEARCH)
break;
bootmgr_touch_exit_ums();
break;
}
case BOOTMGR_CHARGER: return bootmgr_charger_key(key);
case BOOTMGR_MISC: return bootmgr_misc_key(key);
}
return 0;
}
void
prompt_and_wait() {
// Main Menu
#define ITEM_APPLY_SDCARD 0
#define ITEM_NANDROID_MENU 1
#define ITEM_MAIN_WIPE_MENU 2
#define ITEM_ADVANCED_MENU 3
#define ITEM_MOUNT_MENU 4
#define ITEM_USB_TOGGLE 5
#define ITEM_REBOOT 6
#define ITEM_SHUTDOWN 7
finish_recovery(NULL);
ui_reset_progress();
// buying a split second for mmc driver to load to avoid error on some devices
getLocations();
tw_set_defaults();
read_s_file();
char** headers = prepend_title((const char**)MENU_HEADERS);
char* MENU_ITEMS[] = { "Install Zip",
"Nandroid Menu",
"Wipe Menu",
"Advanced Menu",
"Mount Menu",
"USB Storage Toggle",
"Reboot system now",
"Power down system",
NULL };
for (;;) {
go_home = 0;
go_menu = 0;
menu_loc_idx = 0;
ui_reset_progress();
int chosen_item = get_menu_selection(headers, MENU_ITEMS, 0, 0);
// device-specific code may take some action here. It may
// return one of the core actions handled in the switch
// statement below.
chosen_item = device_perform_action(chosen_item);
// delay reading settings during boot due to timings issues with sdcard not being available
// read settings file once and only once after the user makes a menu selection
if (need_to_read_settings_file) {
need_to_read_settings_file = 0;
}
switch (chosen_item) {
case ITEM_APPLY_SDCARD:
install_zip_menu(0);
break;
case ITEM_NANDROID_MENU:
nandroid_menu();
break;
case ITEM_MAIN_WIPE_MENU:
main_wipe_menu();
break;
case ITEM_ADVANCED_MENU:
advanced_menu();
break;
case ITEM_MOUNT_MENU:
mount_menu(0);
break;
case ITEM_USB_TOGGLE:
usb_storage_toggle();
break;
case ITEM_REBOOT:
return;
case ITEM_SHUTDOWN:
__reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, LINUX_REBOOT_CMD_POWER_OFF, NULL);
break;
}
if (go_menu) {
advanced_menu();
}
}
}
void show_advanced_lfs_menu() {
static char* headers[] = { "ULF Settings Menu",
"",
NULL
};
static char* list[] = { "Reboot into Download",
"Install Superuser",
"Change Lagfix Settings",
"Tweak options",
"Back Light Notification",
"Set default permissions",
NULL
};
static char* headersno[] = { "Universal Lagfix Kernel Not Found",
"These options only work if ULK is used",
"",
NULL };
static char* listno[] = { "Okay", NULL };
struct stat ss;
// we check for the pre-init.log, which this kernel creates each run
if (stat("/res/pre-init.log",&ss)!=0) {
get_menu_selection(headersno,listno,0);
} else {
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, "download");
break;
case 1:
{
apply_root_menu();
break;
}
case 2:
{
lagfix_menu();
break;
}
case 3:
{
tweak_menu();
break;
}
case 4:
{
bln_menu();
break;
}
case 5:
{
if (confirm_selection("Confirm setting permissions","Yes - run fix_permissions_sgs")) {
ensure_root_path_mounted("SYSTEM:");
ensure_root_path_mounted("DATA:");
ensure_root_path_mounted("DATADATA:");
ensure_root_path_mounted("CACHE:");
ui_print("Starting fixing\n");
__system("/sbin/fix_permissions_sgs");
ui_print("Done\n");
}
}
}
}
}
}
