Merge pull request #203 from Universal-Debloater-Alliance/list-to-map

refactor(program): make UAD-ng list have key value pair for directly building hashmap

src/core/uad_lists.rs

@@ -10,7 +10,6 @@ use std::path::{Path, PathBuf};
 #[derive(Deserialize, Debug, Clone, PartialEq, Hash, Eq)]
 #[serde(rename_all = "camelCase")]
 pub struct Package {
-    id: String,
     pub list: UadList,
     pub description: String,
     dependencies: Vec<String>,
@@ -179,11 +178,11 @@ impl std::fmt::Display for Removal {
     }
 }
 
-type PackageHashMap = HashMap<String, Package>;
+pub type PackageHashMap = HashMap<String, Package>;
 pub fn load_debloat_lists(remote: bool) -> (Result<PackageHashMap, PackageHashMap>, bool) {
     let cached_uad_lists: PathBuf = CACHE_DIR.join("uad_lists.json");
     let mut error = false;
-    let list: Vec<Package> = if remote {
+    let list: PackageHashMap = if remote {
         retry(Fixed::from_millis(1000).take(60), || {
             match ureq::get(
                 "https://raw.githubusercontent.com/Universal-Debloater-Alliance/universal-android-debloater/\
@@ -194,36 +193,29 @@ pub fn load_debloat_lists(remote: bool) -> (Result<PackageHashMap, PackageHashMa
                 Ok(data) => {
                     let text = data.into_string().expect("response should be Ok type");
                     fs::write(cached_uad_lists.clone(), &text).expect("Unable to write file");
-                    let list = serde_json::from_str(&text).expect("Unable to parse");
+                    let list: PackageHashMap = serde_json::from_str(&text).expect("Unable to parse");
                     OperationResult::Ok(list)
                 }
                 Err(e) => {
                     warn!("Could not load remote debloat list: {}", e);
                     error = true;
-                    OperationResult::Retry(Vec::<Package>::new())
+                    OperationResult::Retry(PackageHashMap::new())
                 }
             }
         })
-        .map_or_else(|_| get_local_lists(), |list| list)
+        .unwrap_or_else(|_| get_local_lists())
     } else {
         warn!("Could not load remote debloat list");
         get_local_lists()
     };
-
-    // TODO: Do it without intermediary Vec?
-    let mut package_lists = HashMap::new();
-    for p in list {
-        let name = p.id.clone();
-        package_lists.insert(name, p);
-    }
     if error {
-        (Err(package_lists), remote)
+        (Err(list), remote)
     } else {
-        (Ok(package_lists), remote)
+        (Ok(list), remote)
     }
 }
 
-fn get_local_lists() -> Vec<Package> {
+fn get_local_lists() -> PackageHashMap {
     const DATA: &str = include_str!("../../resources/assets/uad_lists.json");
     let cached_uad_lists = CACHE_DIR.join("uad_lists.json");
 
@@ -241,6 +233,6 @@ mod tests {
     #[test]
     fn test_parse_json() {
         const DATA: &str = include_str!("../../resources/assets/uad_lists.json");
-        let _: Vec<Package> = serde_json::from_str(DATA).expect("Unable to parse");
+        let _: PackageHashMap = serde_json::from_str(DATA).expect("Unable to parse");
     }
 }

src/core/utils.rs

@@ -1,18 +1,14 @@
 use crate::core::sync::{hashset_system_packages, list_all_system_packages, User};
 use crate::core::theme::Theme;
-use crate::core::uad_lists::{Package, PackageState, Removal, UadList};
+use crate::core::uad_lists::{PackageHashMap, PackageState, Removal, UadList};
 use crate::gui::widgets::package_row::PackageRow;
 use chrono::offset::Utc;
 use chrono::DateTime;
-use std::collections::HashMap;
 use std::path::PathBuf;
 use std::process::Command;
 use std::{fmt, fs};
 
-pub fn fetch_packages(
-    uad_lists: &HashMap<String, Package>,
-    user_id: Option<&User>,
-) -> Vec<PackageRow> {
+pub fn fetch_packages(uad_lists: &PackageHashMap, user_id: Option<&User>) -> Vec<PackageRow> {
     let all_system_packages = list_all_system_packages(user_id); // installed and uninstalled packages
     let enabled_system_packages = hashset_system_packages(PackageState::Enabled, user_id);
     let disabled_system_packages = hashset_system_packages(PackageState::Disabled, user_id);

src/gui/views/list.rs

@@ -2,12 +2,11 @@ use crate::core::config::DeviceSettings;
 use crate::core::sync::{apply_pkg_state_commands, perform_adb_commands, CommandType, Phone, User};
 use crate::core::theme::Theme;
 use crate::core::uad_lists::{
-    load_debloat_lists, Opposite, Package, PackageState, Removal, UadList, UadListState,
+    load_debloat_lists, Opposite, PackageHashMap, PackageState, Removal, UadList, UadListState,
 };
 use crate::core::utils::fetch_packages;
 use crate::gui::style;
 use crate::gui::widgets::navigation_menu::ICONS;
-use std::collections::HashMap;
 use std::env;
 
 use crate::gui::views::settings::Settings;
@@ -40,7 +39,7 @@ pub enum LoadingState {
 #[derive(Default, Debug, Clone)]
 pub struct List {
     pub loading_state: LoadingState,
-    pub uad_lists: HashMap<String, Package>,
+    pub uad_lists: PackageHashMap,
     pub phone_packages: Vec<Vec<PackageRow>>, // packages of all users of the phone
     filtered_packages: Vec<usize>, // phone_packages indexes of the selected user (= what you see on screen)
     selected_packages: Vec<(usize, usize)>, // Vec of (user_index, pkg_index)
@@ -58,7 +57,7 @@ pub struct List {
 #[derive(Debug, Clone)]
 pub enum Message {
     LoadUadList(bool),
-    LoadPhonePackages((HashMap<String, Package>, UadListState)),
+    LoadPhonePackages((PackageHashMap, UadListState)),
     RestoringDevice(Result<CommandType, ()>),
     ApplyFilters(Vec<Vec<PackageRow>>),
     SearchInputChanged(String),
@@ -692,10 +691,7 @@ impl List {
             .collect();
     }
 
-    async fn load_packages(
-        uad_list: HashMap<String, Package>,
-        user_list: Vec<User>,
-    ) -> Vec<Vec<PackageRow>> {
+    async fn load_packages(uad_list: PackageHashMap, user_list: Vec<User>) -> Vec<Vec<PackageRow>> {
         let mut phone_packages = vec![];
 
         if user_list.len() <= 1 {
@@ -710,10 +706,7 @@ impl List {
         phone_packages
     }
 
-    async fn init_apps_view(
-        remote: bool,
-        phone: Phone,
-    ) -> (HashMap<String, Package>, UadListState) {
+    async fn init_apps_view(remote: bool, phone: Phone) -> (PackageHashMap, UadListState) {
         let (uad_lists, _) = load_debloat_lists(remote);
         match uad_lists {
             Ok(list) => {