diff options
Diffstat (limited to '')
| -rw-r--r-- | gui/action.cpp | 1134 |
1 files changed, 1134 insertions, 0 deletions
diff --git a/gui/action.cpp b/gui/action.cpp new file mode 100644 index 000000000..6ca607b34 --- /dev/null +++ b/gui/action.cpp @@ -0,0 +1,1134 @@ +// image.cpp - GUIImage object + +#include <stdarg.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <fcntl.h> +#include <sys/stat.h> +#include <sys/time.h> +#include <sys/mman.h> +#include <sys/types.h> +#include <sys/ioctl.h> +#include <linux/input.h> +#include <time.h> +#include <unistd.h> +#include <stdlib.h> + +#include <string> +#include <sstream> +#include "../partitions.hpp" + +extern "C" { +#include "../common.h" +#include "../roots.h" +#include "../tw_reboot.h" +#include "../minuitwrp/minui.h" +#include "../recovery_ui.h" +#include "../extra-functions.h" +#include "../variables.h" + +int install_zip_package(const char* zip_path_filename); +void fix_perms(); +void wipe_dalvik_cache(void); +int check_backup_name(int show_error); +void wipe_battery_stats(void); +void wipe_rotate_data(void); +int usb_storage_enable(void); +int usb_storage_disable(void); +int __system(const char *command); +FILE * __popen(const char *program, const char *type); +int __pclose(FILE *iop); +void run_script(const char *str1, const char *str2, const char *str3, const char *str4, const char *str5, const char *str6, const char *str7, int request_confirm); +void update_tz_environment_variables(); +void install_htc_dumlock(void); +void htc_dumlock_restore_original_boot(void); +void htc_dumlock_reflash_recovery_to_boot(void); +int check_for_script_file(void); +int gui_console_only(); +int run_script_file(void); +int gui_start(); +}; + +#include "rapidxml.hpp" +#include "objects.hpp" + + +void curtainClose(void); + +GUIAction::GUIAction(xml_node<>* node) + : Conditional(node) +{ + xml_node<>* child; + xml_node<>* actions; + xml_attribute<>* attr; + + mKey = 0; + + if (!node) return; + + // First, get the action + actions = node->first_node("actions"); + if (actions) child = actions->first_node("action"); + else child = node->first_node("action"); + + if (!child) return; + + while (child) + { + Action action; + + attr = child->first_attribute("function"); + if (!attr) return; + + action.mFunction = attr->value(); + action.mArg = child->value(); + mActions.push_back(action); + + child = child->next_sibling("action"); + } + + // Now, let's get either the key or region + child = node->first_node("touch"); + if (child) + { + attr = child->first_attribute("key"); + if (attr) + { + std::string key = attr->value(); + + mKey = getKeyByName(key); + } + else + { + attr = child->first_attribute("x"); + if (!attr) return; + mActionX = atol(attr->value()); + attr = child->first_attribute("y"); + if (!attr) return; + mActionY = atol(attr->value()); + attr = child->first_attribute("w"); + if (!attr) return; + mActionW = atol(attr->value()); + attr = child->first_attribute("h"); + if (!attr) return; + mActionH = atol(attr->value()); + } + } +} + +int GUIAction::NotifyTouch(TOUCH_STATE state, int x, int y) +{ + if (state == TOUCH_RELEASE) + doActions(); + + return 0; +} + +int GUIAction::NotifyKey(int key) +{ + if (!mKey || key != mKey) + return 1; + + doActions(); + return 0; +} + +int GUIAction::NotifyVarChange(std::string varName, std::string value) +{ + if (varName.empty() && !isConditionValid() && !mKey && !mActionW) + doActions(); + + // This handles notifying the condition system of page start + if (varName.empty() && isConditionValid()) + NotifyPageSet(); + + if ((varName.empty() || IsConditionVariable(varName)) && isConditionValid() && isConditionTrue()) + doActions(); + + return 0; +} + +void GUIAction::simulate_progress_bar(void) +{ + ui_print("Simulating actions...\n"); + for (int i = 0; i < 5; i++) + { + usleep(500000); + DataManager::SetValue("ui_progress", i * 20); + } +} + +int GUIAction::flash_zip(std::string filename, std::string pageName, const int simulate) +{ + int ret_val = 0; + + DataManager::SetValue("ui_progress", 0); + + if (filename.empty()) + { + LOGE("No file specified.\n"); + return -1; + } + + // We're going to jump to this page first, like a loading page + gui_changePage(pageName); + + int fd = -1; + ZipArchive zip; + + if (mzOpenZipArchive(filename.c_str(), &zip)) + { + LOGE("Unable to open zip file.\n"); + return -1; + } + + // Check the zip to see if it has a custom installer theme + const ZipEntry* twrp = mzFindZipEntry(&zip, "META-INF/teamwin/twrp.zip"); + if (twrp != NULL) + { + unlink("/tmp/twrp.zip"); + fd = creat("/tmp/twrp.zip", 0666); + } + if (fd >= 0 && twrp != NULL && + mzExtractZipEntryToFile(&zip, twrp, fd) && + !PageManager::LoadPackage("install", "/tmp/twrp.zip", "main")) + { + mzCloseZipArchive(&zip); + PageManager::SelectPackage("install"); + gui_changePage("main"); + } + else + { + // In this case, we just use the default page + mzCloseZipArchive(&zip); + gui_changePage(pageName); + } + if (fd >= 0) + close(fd); + + if (simulate) { + simulate_progress_bar(); + } else { + ret_val = install_zip_package(filename.c_str()); + + // Now, check if we need to ensure TWRP remains installed... + struct stat st; + if (stat("/sbin/installTwrp", &st) == 0) + { + DataManager::SetValue("tw_operation", "Configuring TWRP"); + DataManager::SetValue("tw_partition", ""); + ui_print("Configuring TWRP...\n"); + if (__system("/sbin/installTwrp reinstall") < 0) + { + ui_print("Unable to configure TWRP with this kernel.\n"); + } + } + } + + // Done + DataManager::SetValue("ui_progress", 100); + DataManager::SetValue("ui_progress", 0); + return ret_val; +} + +int GUIAction::doActions() +{ + if (mActions.size() < 1) return -1; + if (mActions.size() == 1) + return doAction(mActions.at(0), 0); + + // For multi-action, we always use a thread + pthread_t t; + pthread_create(&t, NULL, thread_start, this); + + return 0; +} + +void* GUIAction::thread_start(void *cookie) +{ + GUIAction* ourThis = (GUIAction*) cookie; + + DataManager::SetValue(TW_ACTION_BUSY, 1); + + if (ourThis->mActions.size() > 1) + { + std::vector<Action>::iterator iter; + for (iter = ourThis->mActions.begin(); iter != ourThis->mActions.end(); iter++) + ourThis->doAction(*iter, 1); + } + else + { + ourThis->doAction(ourThis->mActions.at(0), 1); + } + int check = 0; + DataManager::GetValue("tw_background_thread_running", check); + if (check == 0) + DataManager::SetValue(TW_ACTION_BUSY, 0); + return NULL; +} + +void GUIAction::operation_start(const string operation_name) +{ + DataManager::SetValue(TW_ACTION_BUSY, 1); + DataManager::SetValue("ui_progress", 0); + DataManager::SetValue("tw_operation", operation_name); + DataManager::SetValue("tw_operation_status", 0); + DataManager::SetValue("tw_operation_state", 0); +} + +void GUIAction::operation_end(const int operation_status, const int simulate) +{ + int simulate_fail; + + DataManager::SetValue("ui_progress", 100); + if (simulate) { + DataManager::GetValue(TW_SIMULATE_FAIL, simulate_fail); + if (simulate_fail != 0) + DataManager::SetValue("tw_operation_status", 1); + else + DataManager::SetValue("tw_operation_status", 0); + } else { + if (operation_status != 0) + DataManager::SetValue("tw_operation_status", 1); + else + DataManager::SetValue("tw_operation_status", 0); + } + DataManager::SetValue("tw_operation_state", 1); + DataManager::SetValue(TW_ACTION_BUSY, 0); +} + +int GUIAction::doAction(Action action, int isThreaded /* = 0 */) +{ + static string zip_queue[10]; + static int zip_queue_index; + static pthread_t terminal_command; + int simulate; + + std::string arg = gui_parse_text(action.mArg); + + std::string function = gui_parse_text(action.mFunction); + + DataManager::GetValue(TW_SIMULATE_ACTIONS, simulate); + + if (function == "reboot") + { + //curtainClose(); this sometimes causes a crash + + sync(); + + if (arg == "recovery") + tw_reboot(rb_recovery); + else if (arg == "poweroff") + tw_reboot(rb_poweroff); + else if (arg == "bootloader") + tw_reboot(rb_bootloader); + else if (arg == "download") + tw_reboot(rb_download); + else + tw_reboot(rb_system); + + // This should never occur + return -1; + } + if (function == "home") + { + PageManager::SelectPackage("TWRP"); + gui_changePage("main"); + return 0; + } + + if (function == "key") + { + PageManager::NotifyKey(getKeyByName(arg)); + return 0; + } + + if (function == "page") { + std::string page_name = gui_parse_text(arg); + return gui_changePage(page_name); + } + + if (function == "reload") { + int check = 0, ret_val = 0; + std::string theme_path; + + operation_start("Reload Theme"); + theme_path = DataManager::GetSettingsStoragePath(); + if (TWPartitionManager::Mount_By_Path(theme_path.c_str(), 1) < 0) { + LOGE("Unable to mount %s during reload function startup.\n", theme_path.c_str()); + check = 1; + } + + theme_path += "/TWRP/theme/ui.zip"; + if (check != 0 || PageManager::ReloadPackage("TWRP", theme_path) != 0) + { + // Loading the custom theme failed - try loading the stock theme + LOGI("Attempting to reload stock theme...\n"); + if (PageManager::ReloadPackage("TWRP", "/res/ui.xml")) + { + LOGE("Failed to load base packages.\n"); + ret_val = 1; + } + } + operation_end(ret_val, simulate); + } + + if (function == "readBackup") + { + string Restore_Name; + DataManager::GetValue("tw_restore", Restore_Name); + TWPartitionManager::Set_Restore_Files(Restore_Name); + return 0; + } + + if (function == "set") + { + if (arg.find('=') != string::npos) + { + string varName = arg.substr(0, arg.find('=')); + string value = arg.substr(arg.find('=') + 1, string::npos); + + DataManager::GetValue(value, value); + DataManager::SetValue(varName, value); + } + else + DataManager::SetValue(arg, "1"); + return 0; + } + if (function == "clear") + { + DataManager::SetValue(arg, "0"); + return 0; + } + + if (function == "mount") + { + if (arg == "usb") + { + DataManager::SetValue(TW_ACTION_BUSY, 1); + if (!simulate) + usb_storage_enable(); + else + ui_print("Simulating actions...\n"); + } + else if (!simulate) + { + string cmd; + if (arg == "EXTERNAL") + cmd = "mount " + DataManager::GetStrValue(TW_EXTERNAL_MOUNT); + else if (arg == "INTERNAL") + cmd = "mount " + DataManager::GetStrValue(TW_INTERNAL_MOUNT); + else + cmd = "mount " + arg; + __system(cmd.c_str()); + if (arg == "/data" && DataManager::GetIntValue(TW_HAS_DATADATA) == 1) + __system("mount /datadata"); + } else + ui_print("Simulating actions...\n"); + return 0; + } + + if (function == "umount" || function == "unmount") + { + if (arg == "usb") + { + if (!simulate) + usb_storage_disable(); + else + ui_print("Simulating actions...\n"); + DataManager::SetValue(TW_ACTION_BUSY, 0); + } + else if (!simulate) + { + string cmd; + if (arg == "EXTERNAL") + cmd = "umount " + DataManager::GetStrValue(TW_EXTERNAL_MOUNT); + else if (arg == "INTERNAL") + cmd = "umount " + DataManager::GetStrValue(TW_INTERNAL_MOUNT); + else if (DataManager::GetIntValue(TW_DONT_UNMOUNT_SYSTEM) == 1 && (arg == "system" || arg == "/system")) + return 0; + else + cmd = "umount " + arg; + __system(cmd.c_str()); + if (arg == "/data" && DataManager::GetIntValue(TW_HAS_DATADATA) == 1) + __system("umount /datadata"); + } else + ui_print("Simulating actions...\n"); + return 0; + } + + if (function == "restoredefaultsettings") + { + operation_start("Restore Defaults"); + if (simulate) // Simulated so that people don't accidently wipe out the "simulation is on" setting + ui_print("Simulating actions...\n"); + else { + DataManager::ResetDefaults(); + TWPartitionManager::Update_System_Details(); + TWPartitionManager::Mount_Current_Storage(); + } + operation_end(0, simulate); + } + + if (function == "copylog") + { + operation_start("Copy Log"); + if (!simulate) + { + char command[255]; + + TWPartitionManager::Mount_Current_Storage(); + sprintf(command, "cp /tmp/recovery.log %s", DataManager::GetCurrentStoragePath().c_str()); + __system(command); + sync(); + ui_print("Copied recovery log to %s.\n", DataManager::GetCurrentStoragePath().c_str()); + } else + simulate_progress_bar(); + operation_end(0, simulate); + return 0; + } + + if (function == "compute" || function == "addsubtract") + { + if (arg.find("+") != string::npos) + { + string varName = arg.substr(0, arg.find('+')); + string string_to_add = arg.substr(arg.find('+') + 1, string::npos); + int amount_to_add = atoi(string_to_add.c_str()); + int value; + + DataManager::GetValue(varName, value); + DataManager::SetValue(varName, value + amount_to_add); + return 0; + } + if (arg.find("-") != string::npos) + { + string varName = arg.substr(0, arg.find('-')); + string string_to_subtract = arg.substr(arg.find('-') + 1, string::npos); + int amount_to_subtract = atoi(string_to_subtract.c_str()); + int value; + + DataManager::GetValue(varName, value); + value -= amount_to_subtract; + if (value <= 0) + value = 0; + DataManager::SetValue(varName, value); + return 0; + } + } + + if (function == "setguitimezone") + { + string SelectedZone; + DataManager::GetValue(TW_TIME_ZONE_GUISEL, SelectedZone); // read the selected time zone into SelectedZone + string Zone = SelectedZone.substr(0, SelectedZone.find(';')); // parse to get time zone + string DSTZone = SelectedZone.substr(SelectedZone.find(';') + 1, string::npos); // parse to get DST component + + int dst; + DataManager::GetValue(TW_TIME_ZONE_GUIDST, dst); // check wether user chose to use DST + + string offset; + DataManager::GetValue(TW_TIME_ZONE_GUIOFFSET, offset); // pull in offset + + string NewTimeZone = Zone; + if (offset != "0") + NewTimeZone += ":" + offset; + + if (dst != 0) + NewTimeZone += DSTZone; + + DataManager::SetValue(TW_TIME_ZONE_VAR, NewTimeZone); + update_tz_environment_variables(); + return 0; + } + + if (function == "togglestorage") { + if (arg == "internal") { + DataManager::SetValue(TW_USE_EXTERNAL_STORAGE, 0); + } else if (arg == "external") { + DataManager::SetValue(TW_USE_EXTERNAL_STORAGE, 1); + } + if (TWPartitionManager::Mount_Current_Storage() == 0) { + if (arg == "internal") { + // Save the current zip location to the external variable + DataManager::SetValue(TW_ZIP_EXTERNAL_VAR, DataManager::GetStrValue(TW_ZIP_LOCATION_VAR)); + // Change the current zip location to the internal variable + DataManager::SetValue(TW_ZIP_LOCATION_VAR, DataManager::GetStrValue(TW_ZIP_INTERNAL_VAR)); + } else if (arg == "external") { + // Save the current zip location to the internal variable + DataManager::SetValue(TW_ZIP_INTERNAL_VAR, DataManager::GetStrValue(TW_ZIP_LOCATION_VAR)); + // Change the current zip location to the external variable + DataManager::SetValue(TW_ZIP_LOCATION_VAR, DataManager::GetStrValue(TW_ZIP_EXTERNAL_VAR)); + } + } else { + // We weren't able to toggle for some reason, restore original setting + if (arg == "internal") { + DataManager::SetValue(TW_USE_EXTERNAL_STORAGE, 1); + } else if (arg == "external") { + DataManager::SetValue(TW_USE_EXTERNAL_STORAGE, 0); + } + } + return 0; + } + + if (function == "overlay") + return gui_changeOverlay(arg); + + if (function == "queuezip") + { + if (zip_queue_index >= 10) { + ui_print("Maximum zip queue reached!\n"); + return 0; + } + DataManager::GetValue("tw_filename", zip_queue[zip_queue_index]); + if (strlen(zip_queue[zip_queue_index].c_str()) > 0) { + zip_queue_index++; + DataManager::SetValue(TW_ZIP_QUEUE_COUNT, zip_queue_index); + } + return 0; + } + + if (function == "cancelzip") + { + if (zip_queue_index <= 0) { + ui_print("Minimum zip queue reached!\n"); + return 0; + } else { + zip_queue_index--; + DataManager::SetValue(TW_ZIP_QUEUE_COUNT, zip_queue_index); + } + return 0; + } + + if (function == "queueclear") + { + zip_queue_index = 0; + DataManager::SetValue(TW_ZIP_QUEUE_COUNT, zip_queue_index); + return 0; + } + + if (function == "sleep") + { + operation_start("Sleep"); + usleep(atoi(arg.c_str())); + operation_end(0, simulate); + return 0; + } + + if (isThreaded) + { + if (function == "fileexists") + { + struct stat st; + string newpath = arg + "/."; + + operation_start("FileExists"); + if (stat(arg.c_str(), &st) == 0 || stat(newpath.c_str(), &st) == 0) + operation_end(0, simulate); + else + operation_end(1, simulate); + } + + if (function == "flash") + { + int i, ret_val = 0; + + for (i=0; i<zip_queue_index; i++) { + operation_start("Flashing"); + DataManager::SetValue("tw_filename", zip_queue[i]); + DataManager::SetValue(TW_ZIP_INDEX, (i + 1)); + + ret_val = flash_zip(zip_queue[i], arg, simulate); + if (ret_val != 0) { + ui_print("Error flashing zip '%s'\n", zip_queue[i].c_str()); + i = 10; // Error flashing zip - exit queue + ret_val = 1; + } + } + zip_queue_index = 0; + DataManager::SetValue(TW_ZIP_QUEUE_COUNT, zip_queue_index); + + if (DataManager::GetIntValue(TW_HAS_INJECTTWRP) == 1 && DataManager::GetIntValue(TW_INJECT_AFTER_ZIP) == 1) { + operation_start("ReinjectTWRP"); + ui_print("Injecting TWRP into boot image...\n"); + if (simulate) { + simulate_progress_bar(); + } else { + __system("injecttwrp --dump /tmp/backup_recovery_ramdisk.img /tmp/injected_boot.img --flash"); + ui_print("TWRP injection complete.\n"); + } + } + operation_end(ret_val, simulate); + return 0; + } + if (function == "wipe") + { + operation_start("Format"); + DataManager::SetValue("tw_partition", arg); + + int ret_val = 0; + + if (simulate) { + simulate_progress_bar(); + } else { + if (arg == "data") + TWPartitionManager::Factory_Reset(); + else if (arg == "battery") + wipe_battery_stats(); + else if (arg == "rotate") + wipe_rotate_data(); + else if (arg == "dalvik") + wipe_dalvik_cache(); + else if (arg == "DATAMEDIA") { + LOGE("TODO: Implement formatting of datamedia device!\n"); + ret_val = 1; //format_data_media(); + int has_datamedia, dual_storage; + + DataManager::GetValue(TW_HAS_DATA_MEDIA, has_datamedia); + DataManager::GetValue(TW_HAS_DUAL_STORAGE, dual_storage); + if (has_datamedia && !dual_storage) { + system("umount /sdcard"); + system("mount /data/media /sdcard"); + } + } else if (arg == "INTERNAL") { + int has_datamedia, dual_storage; + + DataManager::GetValue(TW_HAS_DATA_MEDIA, has_datamedia); + if (has_datamedia) { + TWPartitionManager::Mount_By_Path("/data", 1); + __system("rm -rf /data/media"); + __system("cd /data && mkdir media && chmod 775 media"); + DataManager::GetValue(TW_HAS_DUAL_STORAGE, dual_storage); + if (!dual_storage) { + system("umount /sdcard"); + system("mount /data/media /sdcard"); + } + } else { + ret_val = 0; + LOGE("Wipe not implemented yet!\n"); + } + } else if (arg == "EXTERNAL") { + ret_val = 0; + LOGE("Wipe not implemented yet!\n"); + } else + TWPartitionManager::Wipe_By_Path(arg); + + if (arg == "/sdcard") { + TWPartitionManager::Mount_By_Path("/sdcard", 1); + mkdir("/sdcard/TWRP", 0777); + DataManager::Flush(); + } + } + TWPartitionManager::Update_System_Details(); + if (ret_val != 0) + ret_val = 1; + operation_end(ret_val, simulate); + return 0; + } + if (function == "refreshsizes") + { + operation_start("Refreshing Sizes"); + if (simulate) { + simulate_progress_bar(); + } else + TWPartitionManager::Update_System_Details(); + operation_end(0, simulate); + } + if (function == "nandroid") + { + operation_start("Nandroid"); + + if (simulate) { + DataManager::SetValue("tw_partition", "Simulation"); + simulate_progress_bar(); + } else { + if (arg == "backup") { + string Backup_Name; + DataManager::GetValue(TW_BACKUP_NAME, Backup_Name); + if (Backup_Name == "(Current Date)" || Backup_Name == "0" || Backup_Name == "(" || check_backup_name(1)) + TWPartitionManager::Run_Backup(Backup_Name); + else + return -1; + DataManager::SetValue(TW_BACKUP_NAME, "(Current Date)"); + } else if (arg == "restore") { + string Restore_Name; + DataManager::GetValue("tw_restore", Restore_Name); + TWPartitionManager::Run_Restore(Restore_Name); + } else { + operation_end(1, simulate); + return -1; + } + } + operation_end(0, simulate); + return 0; + } + if (function == "fixpermissions") + { + operation_start("Fix Permissions"); + LOGI("fix permissions started!\n"); + if (simulate) { + simulate_progress_bar(); + } else + fix_perms(); + + LOGI("fix permissions DONE!\n"); + operation_end(0, simulate); + return 0; + } + if (function == "dd") + { + operation_start("imaging"); + + if (simulate) { + simulate_progress_bar(); + } else { + char cmd[512]; + sprintf(cmd, "dd %s", arg.c_str()); + __system(cmd); + } + operation_end(0, simulate); + return 0; + } + if (function == "partitionsd") + { + operation_start("Partition SD Card"); + + if (simulate) { + simulate_progress_bar(); + } else { + int allow_partition; + DataManager::GetValue(TW_ALLOW_PARTITION_SDCARD, allow_partition); + if (allow_partition == 0) { + ui_print("This device does not have a real SD Card!\nAborting!\n"); + } else { + // Below seen in Koush's recovery + char sddevice[256]; + char mkdir_path[255]; + Volume *vol = volume_for_path("/sdcard"); + strcpy(sddevice, vol->device); + // Just need block not whole partition + sddevice[strlen("/dev/block/mmcblkX")] = NULL; + + char es[64]; + std::string ext_format, sd_path; + int ext, swap; + DataManager::GetValue("tw_sdext_size", ext); + DataManager::GetValue("tw_swap_size", swap); + DataManager::GetValue("tw_sdpart_file_system", ext_format); + sprintf(es, "/sbin/sdparted -es %dM -ss %dM -efs ext3 -s > /cache/part.log",ext,swap); + LOGI("\nrunning script: %s\n", es); + run_script("\nContinue partitioning?", + "\nPartitioning sdcard : ", + es, + "\nunable to execute parted!\n(%s)\n", + "\nOops... something went wrong!\nPlease check the recovery log!\n", + "\nPartitioning complete!\n\n", + "\nPartitioning aborted!\n\n", 0); + + // recreate TWRP folder and rewrite settings - these will be gone after sdcard is partitioned +#ifdef TW_EXTERNAL_STORAGE_PATH + TWPartitionManager::Mount_By_Path(EXPAND(TW_EXTERNAL_STORAGE_PATH)); + DataManager::GetValue(TW_EXTERNAL_PATH, sd_path); + memset(mkdir_path, 0, sizeof(mkdir_path)); + sprintf(mkdir_path, "%s/TWRP", sd_path.c_str()); +#else + TWPartitionManager::Mount_By_Path("/sdcard", 1); + strcpy(mkdir_path, "/sdcard/TWRP"); +#endif + mkdir(mkdir_path, 0777); + DataManager::Flush(); +#ifdef TW_EXTERNAL_STORAGE_PATH + DataManager::SetValue(TW_ZIP_EXTERNAL_VAR, EXPAND(TW_EXTERNAL_STORAGE_PATH)); + if (DataManager::GetIntValue(TW_USE_EXTERNAL_STORAGE) == 1) + DataManager::SetValue(TW_ZIP_LOCATION_VAR, EXPAND(TW_EXTERNAL_STORAGE_PATH)); +#else + DataManager::SetValue(TW_ZIP_EXTERNAL_VAR, "/sdcard"); + if (DataManager::GetIntValue(TW_USE_EXTERNAL_STORAGE) == 1) + DataManager::SetValue(TW_ZIP_LOCATION_VAR, "/sdcard"); +#endif + // This is sometimes needed to make a healthy ext4 partition + if (ext > 0 && strcmp(ext_format.c_str(), "ext4") == 0) { + char command[256]; + LOGE("Fix this format command!\n"); + //sprintf(command, "mke2fs -t ext4 -m 0 %s", sde.blk); + ui_print("Formatting sd-ext as ext4...\n"); + LOGI("Formatting sd-ext after partitioning, command: '%s'\n", command); + __system(command); + ui_print("DONE\n"); + } + + TWPartitionManager::Update_System_Details(); + } + } + operation_end(0, simulate); + return 0; + } + if (function == "installhtcdumlock") + { + operation_start("Install HTC Dumlock"); + if (simulate) { + simulate_progress_bar(); + } else + install_htc_dumlock(); + + operation_end(0, simulate); + return 0; + } + if (function == "htcdumlockrestoreboot") + { + operation_start("HTC Dumlock Restore Boot"); + if (simulate) { + simulate_progress_bar(); + } else + htc_dumlock_restore_original_boot(); + + operation_end(0, simulate); + return 0; + } + if (function == "htcdumlockreflashrecovery") + { + operation_start("HTC Dumlock Reflash Recovery"); + if (simulate) { + simulate_progress_bar(); + } else + htc_dumlock_reflash_recovery_to_boot(); + + operation_end(0, simulate); + return 0; + } + if (function == "cmd") + { + int op_status = 0; + + operation_start("Command"); + LOGI("Running command: '%s'\n", arg.c_str()); + if (simulate) { + simulate_progress_bar(); + } else { + op_status = __system(arg.c_str()); + if (op_status != 0) + op_status = 1; + } + + operation_end(op_status, simulate); + return 0; + } + if (function == "terminalcommand") + { + int op_status = 0; + string cmdpath, command; + + DataManager::GetValue("tw_terminal_location", cmdpath); + operation_start("CommandOutput"); + ui_print("%s # %s\n", cmdpath.c_str(), arg.c_str()); + if (simulate) { + simulate_progress_bar(); + operation_end(op_status, simulate); + } else { + command = "cd \""; + command += cmdpath; + command += "\" && "; + command += arg; + LOGI("Actual command is: '%s'\n", command.c_str()); + DataManager::SetValue("tw_terminal_command_thread", command); + DataManager::SetValue("tw_terminal_state", 1); + DataManager::SetValue("tw_background_thread_running", 1); + op_status = pthread_create(&terminal_command, NULL, command_thread, NULL); + if (op_status != 0) { + LOGE("Error starting terminal command thread, %i.\n", op_status); + DataManager::SetValue("tw_terminal_state", 0); + DataManager::SetValue("tw_background_thread_running", 0); + operation_end(1, simulate); + } + } + return 0; + } + if (function == "killterminal") + { + int op_status = 0; + + LOGI("Sending kill command...\n"); + operation_start("KillCommand"); + DataManager::SetValue("tw_operation_status", 0); + DataManager::SetValue("tw_operation_state", 1); + DataManager::SetValue("tw_terminal_state", 0); + DataManager::SetValue("tw_background_thread_running", 0); + DataManager::SetValue(TW_ACTION_BUSY, 0); + return 0; + } + if (function == "reinjecttwrp") + { + int op_status = 0; + + operation_start("ReinjectTWRP"); + ui_print("Injecting TWRP into boot image...\n"); + if (simulate) { + simulate_progress_bar(); + } else { + __system("injecttwrp --dump /tmp/backup_recovery_ramdisk.img /tmp/injected_boot.img --flash"); + ui_print("TWRP injection complete.\n"); + } + + operation_end(op_status, simulate); + return 0; + } + if (function == "checkbackupname") + { + int op_status = 0; + + operation_start("CheckBackupName"); + if (simulate) { + simulate_progress_bar(); + } else { + op_status = check_backup_name(1); + if (op_status != 0) + op_status = 1; + } + + operation_end(op_status, simulate); + return 0; + } + if (function == "decrypt") + { + int op_status = 0; + + operation_start("Decrypt"); + if (simulate) { + simulate_progress_bar(); + } else { + string Password; + DataManager::GetValue("tw_crypto_password", Password); + op_status = TWPartitionManager::Decrypt_Device(Password); + if (op_status != 0) + op_status = 1; + else { + int load_theme = 1; + + DataManager::SetValue(TW_IS_ENCRYPTED, 0); + DataManager::ReadSettingsFile(); + + if (check_for_script_file()) { + ui_print("Processing OpenRecoveryScript file...\n"); + if (run_script_file() == 0) { + usleep(2000000); // Sleep for 2 seconds before rebooting + tw_reboot(rb_system); + load_theme = 0; + } + } + + if (load_theme) { + int has_datamedia; + + // Check for a custom theme and load it if exists + DataManager::GetValue(TW_HAS_DATA_MEDIA, has_datamedia); + if (has_datamedia != 0) { + struct stat st; + int check = 0; + std::string theme_path; + + theme_path = DataManager::GetSettingsStoragePath(); + if (TWPartitionManager::Mount_By_Path(theme_path.c_str(), 1) < 0) { + LOGE("Unable to mount %s during reload function startup.\n", theme_path.c_str()); + check = 1; + } + + theme_path += "/TWRP/theme/ui.zip"; + if (check == 0 && stat(theme_path.c_str(), &st) == 0) { + if (PageManager::ReloadPackage("TWRP", theme_path) != 0) + { + // Loading the custom theme failed - try loading the stock theme + LOGI("Attempting to reload stock theme...\n"); + if (PageManager::ReloadPackage("TWRP", "/res/ui.xml")) + { + LOGE("Failed to load base packages.\n"); + } + } + } + } + } + } + } + + operation_end(op_status, simulate); + return 0; + } + } + else + { + pthread_t t; + pthread_create(&t, NULL, thread_start, this); + return 0; + } + return -1; +} + +int GUIAction::getKeyByName(std::string key) +{ + if (key == "home") return KEY_HOME; + else if (key == "menu") return KEY_MENU; + else if (key == "back") return KEY_BACK; + else if (key == "search") return KEY_SEARCH; + else if (key == "voldown") return KEY_VOLUMEDOWN; + else if (key == "volup") return KEY_VOLUMEUP; + else if (key == "power") { + int ret_val; + DataManager::GetValue(TW_POWER_BUTTON, ret_val); + if (!ret_val) + return KEY_POWER; + else + return ret_val; + } + + return atol(key.c_str()); +} + +void* GUIAction::command_thread(void *cookie) +{ + string command; + FILE* fp; + char line[512]; + + DataManager::GetValue("tw_terminal_command_thread", command); + fp = __popen(command.c_str(), "r"); + if (fp == NULL) { + LOGE("Error opening command to run.\n"); + } else { + int fd = fileno(fp), has_data = 0, check = 0, keep_going = -1, bytes_read = 0; + struct timeval timeout; + fd_set fdset; + + while(keep_going) + { + FD_ZERO(&fdset); + FD_SET(fd, &fdset); + timeout.tv_sec = 0; + timeout.tv_usec = 400000; + has_data = select(fd+1, &fdset, NULL, NULL, &timeout); + if (has_data == 0) { + // Timeout reached + DataManager::GetValue("tw_terminal_state", check); + if (check == 0) { + keep_going = 0; + } + } else if (has_data < 0) { + // End of execution + keep_going = 0; + } else { + // Try to read output + bytes_read = read(fd, line, sizeof(line)); + if (bytes_read > 0) + ui_print("%s", line); // Display output + else + keep_going = 0; // Done executing + } + } + fclose(fp); + } + DataManager::SetValue("tw_operation_status", 0); + DataManager::SetValue("tw_operation_state", 1); + DataManager::SetValue("tw_terminal_state", 0); + DataManager::SetValue("tw_background_thread_running", 0); + DataManager::SetValue(TW_ACTION_BUSY, 0); + return NULL; +} |