From a13d74fc95324c4318fcc95956b07fe593669412 Mon Sep 17 00:00:00 2001 From: Dees_Troy Date: Sun, 24 Mar 2013 08:54:55 -0500 Subject: Add partition list GUI element Add partition list GUI element and update backup, restore, mount, storage selection, and wipe sections of GUI and partition manager code to reflect the new GUI element. Update ORS engine to handle new backup and restore setup. Fix a bug with decrypt. Add 1080x1920 layout. Change-Id: Iaa2f44cb707167e66f935452f076ba00e68a2aa4 --- partitionmanager.cpp | 639 ++++++++++++++++++++------------------------------- 1 file changed, 249 insertions(+), 390 deletions(-) (limited to 'partitionmanager.cpp') diff --git a/partitionmanager.cpp b/partitionmanager.cpp index 4364a2252..f40b35eeb 100644 --- a/partitionmanager.cpp +++ b/partitionmanager.cpp @@ -56,6 +56,7 @@ extern RecoveryUI* ui; int TWPartitionManager::Process_Fstab(string Fstab_Filename, bool Display_Error) { FILE *fstabFile; char fstab_line[MAX_FSTAB_LINE_LENGTH]; + bool Found_Settings_Storage = false; fstabFile = fopen(Fstab_Filename.c_str(), "rt"); if (fstabFile == NULL) { @@ -75,12 +76,36 @@ int TWPartitionManager::Process_Fstab(string Fstab_Filename, bool Display_Error) memset(fstab_line, 0, sizeof(fstab_line)); if (partition->Process_Fstab_Line(line, Display_Error)) { - Partitions.push_back(partition); + if (!Found_Settings_Storage && partition->Is_Settings_Storage) { + Found_Settings_Storage = true; + Partitions.push_back(partition); + DataManager::SetValue("tw_settings_path", partition->Storage_Path); + DataManager::SetValue("tw_storage_path", partition->Storage_Path); + LOGI("Settings storage is '%s'\n", partition->Storage_Path.c_str()); + } else { + partition->Is_Settings_Storage = false; + Partitions.push_back(partition); + } } else { delete partition; } } fclose(fstabFile); + if (!Found_Settings_Storage) { + std::vector::iterator iter; + for (iter = Partitions.begin(); iter != Partitions.end(); iter++) { + if ((*iter)->Is_Storage) { + (*iter)->Is_Settings_Storage = true; + Found_Settings_Storage = true; + DataManager::SetValue("tw_settings_path", (*iter)->Storage_Path); + DataManager::SetValue("tw_storage_path", (*iter)->Storage_Path); + LOGI("Settings storage is '%s'\n", (*iter)->Storage_Path.c_str()); + break; + } + } + if (!Found_Settings_Storage) + LOGE("Unable to locate storage partition for storing settings file.\n"); + } if (!Write_Fstab()) { if (Display_Error) LOGE("Error creating fstab\n"); @@ -136,8 +161,12 @@ void TWPartitionManager::Output_Partition(TWPartition* Part) { printf(" Used: %iMB Free: %iMB Backup Size: %iMB", (int)(Part->Used / mb), (int)(Part->Free / mb), (int)(Part->Backup_Size / mb)); } printf("\n Flags: "); + if (Part->Can_Be_Mounted) + printf("Can_Be_Mounted "); if (Part->Can_Be_Wiped) printf("Can_Be_Wiped "); + if (Part->Can_Be_Backed_Up) + printf("Can_Be_Backed_Up "); if (Part->Wipe_During_Factory_Reset) printf("Wipe_During_Factory_Reset "); if (Part->Wipe_Available_in_GUI) @@ -162,6 +191,8 @@ void TWPartitionManager::Output_Partition(TWPartition* Part) { printf("Has_Android_Secure "); if (Part->Is_Storage) printf("Is_Storage "); + if (Part->Is_Settings_Storage) + printf("Is_Settings_Storage "); if (Part->Ignore_Blkid) printf("Ignore_Blkid "); if (Part->Retain_Layout_Version) @@ -183,10 +214,14 @@ void TWPartitionManager::Output_Partition(TWPartition* Part) { printf(" Length: %i\n", Part->Length); if (!Part->Display_Name.empty()) printf(" Display_Name: %s\n", Part->Display_Name.c_str()); + if (!Part->Storage_Name.empty()) + printf(" Storage_Name: %s\n", Part->Storage_Name.c_str()); if (!Part->Backup_Path.empty()) printf(" Backup_Path: %s\n", Part->Backup_Path.c_str()); if (!Part->Backup_Name.empty()) printf(" Backup_Name: %s\n", Part->Backup_Name.c_str()); + if (!Part->Backup_Display_Name.empty()) + printf(" Backup_Display_Name: %s\n", Part->Backup_Display_Name.c_str()); if (!Part->Backup_FileName.empty()) printf(" Backup_FileName: %s\n", Part->Backup_FileName.c_str()); if (!Part->Storage_Path.empty()) @@ -441,7 +476,7 @@ int TWPartitionManager::Check_Backup_Name(bool Display_Error) { // Check each character strncpy(backup_name, Backup_Name.c_str(), copy_size); - if (strcmp(backup_name, "0") == 0) + if (copy_size == 1 && strncmp(backup_name, "0", 1) == 0) return 0; // A "0" (zero) means to use the current timestamp for the backup name for (index=0; index::iterator subpart; for (subpart = Partitions.begin(); subpart != Partitions.end(); subpart++) { - if ((*subpart)->Is_SubPartition && (*subpart)->SubPartition_Of == Part->Mount_Point) { + if ((*subpart)->Can_Be_Backed_Up && (*subpart)->Is_SubPartition && (*subpart)->SubPartition_Of == Part->Mount_Point) { if (!(*subpart)->Backup(Backup_Folder)) return false; if (!Make_MD5(generate_md5, Backup_Folder, (*subpart)->Backup_FileName)) @@ -602,23 +636,15 @@ bool TWPartitionManager::Backup_Partition(TWPartition* Part, string Backup_Folde int TWPartitionManager::Run_Backup(void) { int check, do_md5, partition_count = 0; - string Backup_Folder, Backup_Name, Full_Backup_Path; + string Backup_Folder, Backup_Name, Full_Backup_Path, Backup_List, backup_path; unsigned long long total_bytes = 0, file_bytes = 0, img_bytes = 0, free_space = 0, img_bytes_remaining, file_bytes_remaining, subpart_size; unsigned long img_time = 0, file_time = 0; - TWPartition* backup_sys = NULL; - TWPartition* backup_data = NULL; - TWPartition* backup_cache = NULL; - TWPartition* backup_recovery = NULL; - TWPartition* backup_boot = NULL; - TWPartition* backup_andsec = NULL; - TWPartition* backup_sdext = NULL; - TWPartition* backup_sp1 = NULL; - TWPartition* backup_sp2 = NULL; - TWPartition* backup_sp3 = NULL; + TWPartition* backup_part = NULL; TWPartition* storage = NULL; std::vector::iterator subpart; struct tm *t; time_t start, stop, seconds, total_start, total_stop; + size_t start_pos = 0, end_pos = 0; seconds = time(0); t = localtime(&seconds); @@ -647,162 +673,38 @@ int TWPartitionManager::Run_Backup(void) { LOGI("Full_Backup_Path is: '%s'\n", Full_Backup_Path.c_str()); LOGI("Calculating backup details...\n"); - DataManager::GetValue(TW_BACKUP_SYSTEM_VAR, check); - if (check) { - backup_sys = Find_Partition_By_Path("/system"); - if (backup_sys != NULL) { - partition_count++; - if (backup_sys->Backup_Method == 1) { - file_bytes += backup_sys->Backup_Size; - } - else - img_bytes += backup_sys->Backup_Size; - } else { - LOGE("Unable to locate system partition.\n"); - DataManager::SetValue(TW_BACKUP_SYSTEM_VAR, 0); - } - } - DataManager::GetValue(TW_BACKUP_DATA_VAR, check); - if (check) { - backup_data = Find_Partition_By_Path("/data"); - if (backup_data != NULL) { - partition_count++; - subpart_size = 0; - if (backup_data->Has_SubPartition) { - for (subpart = Partitions.begin(); subpart != Partitions.end(); subpart++) { - if ((*subpart)->Is_SubPartition && (*subpart)->SubPartition_Of == backup_data->Mount_Point) - subpart_size += (*subpart)->Backup_Size; + DataManager::GetValue("tw_backup_list", Backup_List); + if (!Backup_List.empty()) { + end_pos = Backup_List.find(";", start_pos); + while (end_pos != string::npos && start_pos < Backup_List.size()) { + backup_path = Backup_List.substr(start_pos, end_pos - start_pos); + backup_part = Find_Partition_By_Path(backup_path); + if (backup_part != NULL) { + partition_count++; + if (backup_part->Backup_Method == 1) + file_bytes += backup_part->Backup_Size; + else + img_bytes += backup_part->Backup_Size; + if (backup_part->Has_SubPartition) { + std::vector::iterator subpart; + + for (subpart = Partitions.begin(); subpart != Partitions.end(); subpart++) { + if ((*subpart)->Can_Be_Backed_Up && (*subpart)->Is_SubPartition && (*subpart)->SubPartition_Of == backup_part->Mount_Point) { + partition_count++; + if ((*subpart)->Backup_Method == 1) + file_bytes += (*subpart)->Backup_Size; + else + img_bytes += (*subpart)->Backup_Size; + } + } } + } else { + LOGE("Unable to locate '%s' partition for backup calculations.\n", backup_path.c_str()); } - if (backup_data->Backup_Method == 1) - file_bytes += backup_data->Backup_Size + subpart_size; - else - img_bytes += backup_data->Backup_Size + subpart_size; - } else { - LOGE("Unable to locate data partition.\n"); - DataManager::SetValue(TW_BACKUP_DATA_VAR, 0); - } - } - DataManager::GetValue(TW_BACKUP_CACHE_VAR, check); - if (check) { - backup_cache = Find_Partition_By_Path("/cache"); - if (backup_cache != NULL) { - partition_count++; - if (backup_cache->Backup_Method == 1) - file_bytes += backup_cache->Backup_Size; - else - img_bytes += backup_cache->Backup_Size; - } else { - LOGE("Unable to locate cache partition.\n"); - DataManager::SetValue(TW_BACKUP_CACHE_VAR, 0); - } - } - DataManager::GetValue(TW_BACKUP_RECOVERY_VAR, check); - if (check) { - backup_recovery = Find_Partition_By_Path("/recovery"); - if (backup_recovery != NULL) { - partition_count++; - if (backup_recovery->Backup_Method == 1) - file_bytes += backup_recovery->Backup_Size; - else - img_bytes += backup_recovery->Backup_Size; - } else { - LOGE("Unable to locate recovery partition.\n"); - DataManager::SetValue(TW_BACKUP_RECOVERY_VAR, 0); - } - } -#ifndef TW_HAS_NO_BOOT_PARTITION - DataManager::GetValue(TW_BACKUP_BOOT_VAR, check); - if (check) { - backup_boot = Find_Partition_By_Path("/boot"); - if (backup_boot != NULL) { - partition_count++; - if (backup_boot->Backup_Method == 1) - file_bytes += backup_boot->Backup_Size; - else - img_bytes += backup_boot->Backup_Size; - } else { - LOGE("Unable to locate boot partition.\n"); - DataManager::SetValue(TW_BACKUP_BOOT_VAR, 0); + start_pos = end_pos + 1; + end_pos = Backup_List.find(";", start_pos); } } -#endif - DataManager::GetValue(TW_BACKUP_ANDSEC_VAR, check); - if (check) { - backup_andsec = Find_Partition_By_Path("/and-sec"); - if (backup_andsec != NULL) { - partition_count++; - if (backup_andsec->Backup_Method == 1) - file_bytes += backup_andsec->Backup_Size; - else - img_bytes += backup_andsec->Backup_Size; - } else { - LOGE("Unable to locate android secure partition.\n"); - DataManager::SetValue(TW_BACKUP_ANDSEC_VAR, 0); - } - } - DataManager::GetValue(TW_BACKUP_SDEXT_VAR, check); - if (check) { - backup_sdext = Find_Partition_By_Path("/sd-ext"); - if (backup_sdext != NULL) { - partition_count++; - if (backup_sdext->Backup_Method == 1) - file_bytes += backup_sdext->Backup_Size; - else - img_bytes += backup_sdext->Backup_Size; - } else { - LOGE("Unable to locate sd-ext partition.\n"); - DataManager::SetValue(TW_BACKUP_SDEXT_VAR, 0); - } - } -#ifdef SP1_NAME - DataManager::GetValue(TW_BACKUP_SP1_VAR, check); - if (check) { - backup_sp1 = Find_Partition_By_Path(EXPAND(SP1_NAME)); - if (backup_sp1 != NULL) { - partition_count++; - if (backup_sp1->Backup_Method == 1) - file_bytes += backup_sp1->Backup_Size; - else - img_bytes += backup_sp1->Backup_Size; - } else { - LOGE("Unable to locate %s partition.\n", EXPAND(SP1_NAME)); - DataManager::SetValue(TW_BACKUP_SP1_VAR, 0); - } - } -#endif -#ifdef SP2_NAME - DataManager::GetValue(TW_BACKUP_SP2_VAR, check); - if (check) { - backup_sp2 = Find_Partition_By_Path(EXPAND(SP2_NAME)); - if (backup_sp2 != NULL) { - partition_count++; - if (backup_sp2->Backup_Method == 1) - file_bytes += backup_sp2->Backup_Size; - else - img_bytes += backup_sp2->Backup_Size; - } else { - LOGE("Unable to locate %s partition.\n", EXPAND(SP2_NAME)); - DataManager::SetValue(TW_BACKUP_SP2_VAR, 0); - } - } -#endif -#ifdef SP3_NAME - DataManager::GetValue(TW_BACKUP_SP3_VAR, check); - if (check) { - backup_sp3 = Find_Partition_By_Path(EXPAND(SP3_NAME)); - if (backup_sp3 != NULL) { - partition_count++; - if (backup_sp3->Backup_Method == 1) - file_bytes += backup_sp3->Backup_Size; - else - img_bytes += backup_sp3->Backup_Size; - } else { - LOGE("Unable to locate %s partition.\n", EXPAND(SP3_NAME)); - DataManager::SetValue(TW_BACKUP_SP3_VAR, 0); - } - } -#endif if (partition_count == 0) { ui_print("No partitions selected for backup.\n"); @@ -836,26 +738,20 @@ int TWPartitionManager::Run_Backup(void) { ui->SetProgress(0.0); - if (!Backup_Partition(backup_sys, Full_Backup_Path, do_md5, &img_bytes_remaining, &file_bytes_remaining, &img_time, &file_time, &img_bytes, &file_bytes)) - return false; - if (!Backup_Partition(backup_data, Full_Backup_Path, do_md5, &img_bytes_remaining, &file_bytes_remaining, &img_time, &file_time, &img_bytes, &file_bytes)) - return false; - if (!Backup_Partition(backup_cache, Full_Backup_Path, do_md5, &img_bytes_remaining, &file_bytes_remaining, &img_time, &file_time, &img_bytes, &file_bytes)) - return false; - if (!Backup_Partition(backup_recovery, Full_Backup_Path, do_md5, &img_bytes_remaining, &file_bytes_remaining, &img_time, &file_time, &img_bytes, &file_bytes)) - return false; - if (!Backup_Partition(backup_boot, Full_Backup_Path, do_md5, &img_bytes_remaining, &file_bytes_remaining, &img_time, &file_time, &img_bytes, &file_bytes)) - return false; - if (!Backup_Partition(backup_andsec, Full_Backup_Path, do_md5, &img_bytes_remaining, &file_bytes_remaining, &img_time, &file_time, &img_bytes, &file_bytes)) - return false; - if (!Backup_Partition(backup_sdext, Full_Backup_Path, do_md5, &img_bytes_remaining, &file_bytes_remaining, &img_time, &file_time, &img_bytes, &file_bytes)) - return false; - if (!Backup_Partition(backup_sp1, Full_Backup_Path, do_md5, &img_bytes_remaining, &file_bytes_remaining, &img_time, &file_time, &img_bytes, &file_bytes)) - return false; - if (!Backup_Partition(backup_sp2, Full_Backup_Path, do_md5, &img_bytes_remaining, &file_bytes_remaining, &img_time, &file_time, &img_bytes, &file_bytes)) - return false; - if (!Backup_Partition(backup_sp3, Full_Backup_Path, do_md5, &img_bytes_remaining, &file_bytes_remaining, &img_time, &file_time, &img_bytes, &file_bytes)) - return false; + start_pos = 0; + end_pos = Backup_List.find(";", start_pos); + while (end_pos != string::npos && start_pos < Backup_List.size()) { + backup_path = Backup_List.substr(start_pos, end_pos - start_pos); + backup_part = Find_Partition_By_Path(backup_path); + if (backup_part != NULL) { + if (!Backup_Partition(backup_part, Full_Backup_Path, do_md5, &img_bytes_remaining, &file_bytes_remaining, &img_time, &file_time, &img_bytes, &file_bytes)) + return false; + } else { + LOGE("Unable to locate '%s' partition for backup process.\n", backup_path.c_str()); + } + start_pos = end_pos + 1; + end_pos = Backup_List.find(";", start_pos); + } // Average BPS if (img_time == 0) @@ -919,23 +815,17 @@ bool TWPartitionManager::Restore_Partition(TWPartition* Part, string Restore_Nam } } time(&Stop); - ui_print("[%s done (%d seconds)]\n\n", Part->Display_Name.c_str(), (int)difftime(Stop, Start)); + ui_print("[%s done (%d seconds)]\n\n", Part->Backup_Display_Name.c_str(), (int)difftime(Stop, Start)); return true; } int TWPartitionManager::Run_Restore(string Restore_Name) { int check_md5, check, partition_count = 0; - TWPartition* restore_sys = NULL; - TWPartition* restore_data = NULL; - TWPartition* restore_cache = NULL; - TWPartition* restore_boot = NULL; - TWPartition* restore_andsec = NULL; - TWPartition* restore_sdext = NULL; - TWPartition* restore_sp1 = NULL; - TWPartition* restore_sp2 = NULL; - TWPartition* restore_sp3 = NULL; + TWPartition* restore_part = NULL; time_t rStart, rStop; time(&rStart); + string Restore_List, restore_path; + size_t start_pos = 0, end_pos; ui_print("\n[RESTORE STARTED]\n\n"); ui_print("Restore folder: '%s'\n", Restore_Name.c_str()); @@ -944,157 +834,65 @@ int TWPartitionManager::Run_Restore(string Restore_Name) { return false; DataManager::GetValue(TW_SKIP_MD5_CHECK_VAR, check_md5); - DataManager::GetValue(TW_RESTORE_SYSTEM_VAR, check); - if (check > 0) { - restore_sys = Find_Partition_By_Path("/system"); - if (restore_sys == NULL) { - LOGE("Unable to locate system partition.\n"); - } else { - partition_count++; - } - } - DataManager::GetValue(TW_RESTORE_DATA_VAR, check); - if (check > 0) { - restore_data = Find_Partition_By_Path("/data"); - if (restore_data == NULL) { - LOGE("Unable to locate data partition.\n"); - } else { - partition_count++; - } - } - DataManager::GetValue(TW_RESTORE_CACHE_VAR, check); - if (check > 0) { - restore_cache = Find_Partition_By_Path("/cache"); - if (restore_cache == NULL) { - LOGE("Unable to locate cache partition.\n"); - } else { - partition_count++; - } - } -#ifndef TW_HAS_NO_BOOT_PARTITION - DataManager::GetValue(TW_RESTORE_BOOT_VAR, check); - if (check > 0) { - restore_boot = Find_Partition_By_Path("/boot"); - if (restore_boot == NULL) { - LOGE("Unable to locate boot partition.\n"); - } else { - partition_count++; - } - } -#endif - DataManager::GetValue(TW_RESTORE_ANDSEC_VAR, check); - if (check > 0) { - restore_andsec = Find_Partition_By_Path("/and-sec"); - if (restore_andsec == NULL) { - LOGE("Unable to locate android secure partition.\n"); - } else { - partition_count++; - } - } - DataManager::GetValue(TW_RESTORE_SDEXT_VAR, check); - if (check > 0) { - restore_sdext = Find_Partition_By_Path("/sd-ext"); - if (restore_sdext == NULL) { - LOGE("Unable to locate sd-ext partition.\n"); - } else { - partition_count++; - } - } -#ifdef SP1_NAME - DataManager::GetValue(TW_RESTORE_SP1_VAR, check); - if (check > 0) { - restore_sp1 = Find_Partition_By_Path(EXPAND(SP1_NAME)); - if (restore_sp1 == NULL) { - LOGE("Unable to locate %s partition.\n", EXPAND(SP1_NAME)); - } else { - partition_count++; - } - } -#endif -#ifdef SP2_NAME - DataManager::GetValue(TW_RESTORE_SP2_VAR, check); - if (check > 0) { - restore_sp2 = Find_Partition_By_Path(EXPAND(SP2_NAME)); - if (restore_sp2 == NULL) { - LOGE("Unable to locate %s partition.\n", EXPAND(SP2_NAME)); - } else { - partition_count++; - } - } -#endif -#ifdef SP3_NAME - DataManager::GetValue(TW_RESTORE_SP3_VAR, check); - if (check > 0) { - restore_sp3 = Find_Partition_By_Path(EXPAND(SP3_NAME)); - if (restore_sp3 == NULL) { - LOGE("Unable to locate %s partition.\n", EXPAND(SP3_NAME)); - } else { - partition_count++; - } - } -#endif - - if (partition_count == 0) { - LOGE("No partitions selected for restore.\n"); - return false; - } - if (check_md5 > 0) { // Check MD5 files first before restoring to ensure that all of them match before starting a restore TWFunc::GUI_Operation_Text(TW_VERIFY_MD5_TEXT, "Verifying MD5"); ui_print("Verifying MD5...\n"); - if (restore_sys != NULL && !restore_sys->Check_MD5(Restore_Name)) - return false; - if (restore_data != NULL && !restore_data->Check_MD5(Restore_Name)) - return false; - if (restore_data != NULL && restore_data->Has_SubPartition) { - std::vector::iterator subpart; - - for (subpart = Partitions.begin(); subpart != Partitions.end(); subpart++) { - if ((*subpart)->Is_SubPartition && (*subpart)->SubPartition_Of == restore_data->Mount_Point) { - if (!(*subpart)->Check_MD5(Restore_Name)) - return false; + } else { + ui_print("Skipping MD5 check based on user setting.\n"); + } + DataManager::GetValue("tw_restore_selected", Restore_List); + if (!Restore_List.empty()) { + end_pos = Restore_List.find(";", start_pos); + while (end_pos != string::npos && start_pos < Restore_List.size()) { + restore_path = Restore_List.substr(start_pos, end_pos - start_pos); + restore_part = Find_Partition_By_Path(restore_path); + if (restore_part != NULL) { + partition_count++; + if (check_md5 > 0 && !restore_part->Check_MD5(Restore_Name)) + return false; + if (restore_part->Has_SubPartition) { + std::vector::iterator subpart; + + for (subpart = Partitions.begin(); subpart != Partitions.end(); subpart++) { + if ((*subpart)->Is_SubPartition && (*subpart)->SubPartition_Of == restore_part->Mount_Point) { + if (!(*subpart)->Check_MD5(Restore_Name)) + return false; + } + } } + } else { + LOGE("Unable to locate '%s' partition for restoring.\n", restore_path.c_str()); } + start_pos = end_pos + 1; + end_pos = Restore_List.find(";", start_pos); } - if (restore_cache != NULL && !restore_cache->Check_MD5(Restore_Name)) - return false; - if (restore_boot != NULL && !restore_boot->Check_MD5(Restore_Name)) - return false; - if (restore_andsec != NULL && !restore_andsec->Check_MD5(Restore_Name)) - return false; - if (restore_sdext != NULL && !restore_sdext->Check_MD5(Restore_Name)) - return false; - if (restore_sp1 != NULL && !restore_sp1->Check_MD5(Restore_Name)) - return false; - if (restore_sp2 != NULL && !restore_sp2->Check_MD5(Restore_Name)) - return false; - if (restore_sp3 != NULL && !restore_sp3->Check_MD5(Restore_Name)) - return false; - ui_print("Done verifying MD5.\n"); - } else - ui_print("Skipping MD5 check based on user setting.\n"); + } + + if (partition_count == 0) { + LOGE("No partitions selected for restore.\n"); + return false; + } ui_print("Restoring %i partitions...\n", partition_count); ui->SetProgress(0.0); - if (restore_sys != NULL && !Restore_Partition(restore_sys, Restore_Name, partition_count)) - return false; - if (restore_data != NULL && !Restore_Partition(restore_data, Restore_Name, partition_count)) - return false; - if (restore_cache != NULL && !Restore_Partition(restore_cache, Restore_Name, partition_count)) - return false; - if (restore_boot != NULL && !Restore_Partition(restore_boot, Restore_Name, partition_count)) - return false; - if (restore_andsec != NULL && !Restore_Partition(restore_andsec, Restore_Name, partition_count)) - return false; - if (restore_sdext != NULL && !Restore_Partition(restore_sdext, Restore_Name, partition_count)) - return false; - if (restore_sp1 != NULL && !Restore_Partition(restore_sp1, Restore_Name, partition_count)) - return false; - if (restore_sp2 != NULL && !Restore_Partition(restore_sp2, Restore_Name, partition_count)) - return false; - if (restore_sp3 != NULL && !Restore_Partition(restore_sp3, Restore_Name, partition_count)) - return false; + start_pos = 0; + if (!Restore_List.empty()) { + end_pos = Restore_List.find(";", start_pos); + while (end_pos != string::npos && start_pos < Restore_List.size()) { + restore_path = Restore_List.substr(start_pos, end_pos - start_pos); + restore_part = Find_Partition_By_Path(restore_path); + if (restore_part != NULL) { + partition_count++; + if (!Restore_Partition(restore_part, Restore_Name, partition_count)) + return false; + } else { + LOGE("Unable to locate '%s' partition for restoring.\n", restore_path.c_str()); + } + start_pos = end_pos + 1; + end_pos = Restore_List.find(";", start_pos); + } + } TWFunc::GUI_Operation_Text(TW_UPDATE_SYSTEM_DETAILS_TEXT, "Updating System Details"); Update_System_Details(); @@ -1106,16 +904,7 @@ int TWPartitionManager::Run_Restore(string Restore_Name) { void TWPartitionManager::Set_Restore_Files(string Restore_Name) { // Start with the default values - int tw_restore_system = -1; - int tw_restore_data = -1; - int tw_restore_cache = -1; - int tw_restore_recovery = -1; - int tw_restore_boot = -1; - int tw_restore_andsec = -1; - int tw_restore_sdext = -1; - int tw_restore_sp1 = -1; - int tw_restore_sp2 = -1; - int tw_restore_sp3 = -1; + string Restore_List; bool get_date = true; DIR* d; @@ -1170,7 +959,11 @@ void TWPartitionManager::Set_Restore_Files(string Restore_Name) { extn = ptr; } - if (extn == NULL || (strlen(extn) >= 3 && strncmp(extn, "win", 3) != 0)) continue; + if (strcmp(fstype, "log") == 0) continue; + int extnlength = strlen(extn); + if (extn == NULL || (extnlength != 3 && extnlength != 6)) continue; + if (extnlength == 3 && strncmp(extn, "win", 3) != 0) continue; + if (extnlength == 6 && strncmp(extn, "win000", 6) != 0) continue; TWPartition* Part = Find_Partition_By_Path(label); if (Part == NULL) @@ -1184,48 +977,13 @@ void TWPartitionManager::Set_Restore_Files(string Restore_Name) { Part->Backup_FileName.resize(Part->Backup_FileName.size() - strlen(extn) + 3); } - // Now, we just need to find the correct label - if (Part->Backup_Path == "/system") - tw_restore_system = 1; - if (Part->Backup_Path == "/data") - tw_restore_data = 1; - if (Part->Backup_Path == "/cache") - tw_restore_cache = 1; - if (Part->Backup_Path == "/recovery") - tw_restore_recovery = 1; - if (Part->Backup_Path == "/boot") - tw_restore_boot = 1; - if (Part->Backup_Path == "/and-sec") - tw_restore_andsec = 1; - if (Part->Backup_Path == "/sd-ext") - tw_restore_sdext = 1; -#ifdef SP1_NAME - if (Part->Backup_Path == TWFunc::Get_Root_Path(EXPAND(SP1_NAME))) - tw_restore_sp1 = 1; -#endif -#ifdef SP2_NAME - if (Part->Backup_Path == TWFunc::Get_Root_Path(EXPAND(SP2_NAME))) - tw_restore_sp2 = 1; -#endif -#ifdef SP3_NAME - if (Part->Backup_Path == TWFunc::Get_Root_Path(EXPAND(SP3_NAME))) - tw_restore_sp3 = 1; -#endif + Restore_List += Part->Backup_Path + ";"; } closedir(d); - // Set the final values - DataManager::SetValue(TW_RESTORE_SYSTEM_VAR, tw_restore_system); - DataManager::SetValue(TW_RESTORE_DATA_VAR, tw_restore_data); - DataManager::SetValue(TW_RESTORE_CACHE_VAR, tw_restore_cache); - DataManager::SetValue(TW_RESTORE_RECOVERY_VAR, tw_restore_recovery); - DataManager::SetValue(TW_RESTORE_BOOT_VAR, tw_restore_boot); - DataManager::SetValue(TW_RESTORE_ANDSEC_VAR, tw_restore_andsec); - DataManager::SetValue(TW_RESTORE_SDEXT_VAR, tw_restore_sdext); - DataManager::SetValue(TW_RESTORE_SP1_VAR, tw_restore_sp1); - DataManager::SetValue(TW_RESTORE_SP2_VAR, tw_restore_sp2); - DataManager::SetValue(TW_RESTORE_SP3_VAR, tw_restore_sp3); - + // Set the final value + DataManager::SetValue("tw_restore_list", Restore_List); + DataManager::SetValue("tw_restore_selected", Restore_List); return; } @@ -1322,7 +1080,7 @@ int TWPartitionManager::Wipe_Dalvik_Cache(void) { dir.push_back("/cache/dalvik-cache"); dir.push_back("/cache/dc"); ui_print("\nWiping Dalvik Cache Directories...\n"); - for (int i = 0; i < dir.size(); ++i) { + for (unsigned i = 0; i < dir.size(); ++i) { if (stat(dir.at(i).c_str(), &st) == 0) { TWFunc::removeDir(dir.at(i), false); ui_print("Cleaned: %s...\n", dir.at(i).c_str()); @@ -1993,3 +1751,104 @@ int TWPartitionManager::Partition_SDCard(void) { ui_print("Partitioning complete.\n"); return true; } + +void TWPartitionManager::Get_Partition_List(string ListType, std::vector *Partition_List) { + std::vector::iterator iter; + if (ListType == "mount") { + for (iter = Partitions.begin(); iter != Partitions.end(); iter++) { + if ((*iter)->Can_Be_Mounted && !(*iter)->Is_SubPartition) { + struct PartitionList part; + part.Display_Name = (*iter)->Display_Name; + part.Mount_Point = (*iter)->Mount_Point; + part.selected = (*iter)->Is_Mounted(); + Partition_List->push_back(part); + } + } + } else if (ListType == "storage") { + char free_space[255]; + string Current_Storage = DataManager::GetCurrentStoragePath(); + for (iter = Partitions.begin(); iter != Partitions.end(); iter++) { + if ((*iter)->Is_Storage) { + struct PartitionList part; + sprintf(free_space, "%llu", (*iter)->Free / 1024 / 1024); + part.Display_Name = (*iter)->Storage_Name + " ("; + part.Display_Name += free_space; + part.Display_Name += "MB)"; + part.Mount_Point = (*iter)->Storage_Path; + if ((*iter)->Storage_Path == Current_Storage) + part.selected = 1; + else + part.selected = 0; + Partition_List->push_back(part); + } + } + } else if (ListType == "backup") { + char backup_size[255]; + for (iter = Partitions.begin(); iter != Partitions.end(); iter++) { + if ((*iter)->Can_Be_Backed_Up && !(*iter)->Is_SubPartition) { + struct PartitionList part; + sprintf(backup_size, "%llu", (*iter)->Backup_Size / 1024 / 1024); + part.Display_Name = (*iter)->Backup_Display_Name + " ("; + part.Display_Name += backup_size; + part.Display_Name += "MB)"; + part.Mount_Point = (*iter)->Backup_Path; + part.selected = 0; + Partition_List->push_back(part); + } + } + } else if (ListType == "restore") { + string Restore_List, restore_path; + TWPartition* restore_part = NULL; + + DataManager::GetValue("tw_restore_list", Restore_List); + if (!Restore_List.empty()) { + size_t start_pos = 0, end_pos = Restore_List.find(";", start_pos); + while (end_pos != string::npos && start_pos < Restore_List.size()) { + restore_path = Restore_List.substr(start_pos, end_pos - start_pos); + if ((restore_part = Find_Partition_By_Path(restore_path)) != NULL && !restore_part->Is_SubPartition) { + if (restore_part->Backup_Name == "recovery") { + // Don't allow restore of recovery (causes problems on some devices) + } else { + struct PartitionList part; + part.Display_Name = restore_part->Backup_Display_Name; + part.Mount_Point = restore_part->Backup_Path; + part.selected = 1; + Partition_List->push_back(part); + } + } else { + LOGE("Unable to locate '%s' partition for restore.\n", restore_path.c_str()); + } + start_pos = end_pos + 1; + end_pos = Restore_List.find(";", start_pos); + } + } + } else if (ListType == "wipe") { + struct PartitionList dalvik; + dalvik.Display_Name = "Dalvik Cache"; + dalvik.Mount_Point = "DALVIK"; + dalvik.selected = 0; + Partition_List->push_back(dalvik); + for (iter = Partitions.begin(); iter != Partitions.end(); iter++) { + if ((*iter)->Wipe_Available_in_GUI && !(*iter)->Is_SubPartition) { + struct PartitionList part; + part.Display_Name = (*iter)->Display_Name; + part.Mount_Point = (*iter)->Mount_Point; + part.selected = 0; + Partition_List->push_back(part); + } + if ((*iter)->Has_Android_Secure) { + struct PartitionList part; + part.Display_Name = (*iter)->Backup_Display_Name; + part.Mount_Point = (*iter)->Backup_Path; + part.selected = 0; + Partition_List->push_back(part); + } + } + } else { + LOGE("Unknown list type '%s' requested for TWPartitionManager::Get_Partition_List\n", ListType.c_str()); + } +} + +int TWPartitionManager::Fstab_Processed(void) { + return Partitions.size(); +} -- cgit v1.2.3