[release] solved slow loading permision per apps

Author: n3kosempai

pnpm-lock.yaml

@@ -128,7 +128,6 @@ fn get_app_permissions(app_id: &str, is_flatpak: bool) -> Option<Vec<String>> {
     };
 
     if !output.status.success() {
-        println!("[DEBUG] Failed to get permissions for {}: command failed", app_id);
         return None;
     }
 
@@ -138,39 +137,30 @@ fn get_app_permissions(app_id: &str, is_flatpak: bool) -> Option<Vec<String>> {
     let mut has_files = false;
     let mut has_storage = false;
 
-    println!("[DEBUG] Parsing permissions for {}:", app_id);
-
     for line in stdout.lines() {
         let line = line.trim();
         if line.is_empty() || line.starts_with('[') {
             continue;
         }
 
-        println!("[DEBUG]   Line: {}", line);
-
         // Look for specific permissions we care about
         // Camera: devices=all (full device access) or specific video devices
         if !has_camera && line.contains("devices=") {
             let devices_part = line.split("devices=").nth(1).unwrap_or("");
-            let devices_value = devices_part.split(';').next().unwrap_or("").trim();
-            println!("[DEBUG]     Found devices: '{}'", devices_value);
-            // Only consider "all" as camera permission (dri is just GPU acceleration)
-            if devices_value == "all" {
+            // Check if "all" is in the devices list (e.g., "dri;all;" or "all;")
+            if devices_part.split(';').any(|d| d.trim() == "all") {
                 permissions.push("camera".to_string());
                 has_camera = true;
-                println!("[DEBUG]     Added camera permission");
             }
         }
 
         // Files: filesystems= with any value
         if !has_files && line.contains("filesystems=") {
             let filesystems_part = line.split("filesystems=").nth(1).unwrap_or("");
             let filesystems_value = filesystems_part.split(';').next().unwrap_or("").trim();
-            println!("[DEBUG]     Found filesystems: '{}'", filesystems_value);
             if !filesystems_value.is_empty() {
                 permissions.push("files".to_string());
                 has_files = true;
-                println!("[DEBUG]     Added files permission");
             }
         }
 
@@ -179,24 +169,19 @@ fn get_app_permissions(app_id: &str, is_flatpak: bool) -> Option<Vec<String>> {
             if line.contains("persist=") {
                 let persist_part = line.split("persist=").nth(1).unwrap_or("");
                 let persist_value = persist_part.split(';').next().unwrap_or("").trim();
-                println!("[DEBUG]     Found persist: '{}'", persist_value);
                 if !persist_value.is_empty() {
                     permissions.push("storage".to_string());
                     has_storage = true;
-                    println!("[DEBUG]     Added storage permission (persist)");
                 }
             } else if line.contains("filesystems=") {
                 if line.contains("home") || line.contains("host") || line.contains("xdg-download") {
                     permissions.push("storage".to_string());
                     has_storage = true;
-                    println!("[DEBUG]     Added storage permission (filesystems with home/host/xdg-download)");
                 }
             }
         }
     }
 
-    println!("[DEBUG] Final permissions for {}: {:?}", app_id, permissions);
-
     if permissions.is_empty() {
         None
     } else {
@@ -252,21 +237,47 @@ struct SystemInfo {
 // Get system analytics data
 #[tauri::command]
 async fn get_app_permissions_batch(
-    app: tauri::AppHandle,
+    _app: tauri::AppHandle,
     app_ids: Vec<String>,
 ) -> Result<std::collections::HashMap<String, Vec<String>>, String> {
     use std::collections::HashMap;
+    use std::sync::{Arc, Mutex};
+    use std::thread;
 
     let is_flatpak = std::env::var("FLATPAK_ID").is_ok();
-    let mut result = HashMap::new();
+    let result = Arc::new(Mutex::new(HashMap::new()));
+
+    // Parallelize permission fetching using native threads
+    // Limit concurrent threads to avoid overwhelming the system
+    let chunk_size = 10; // Process 10 apps at a time
+    let mut app_id_chunks: Vec<Vec<String>> = Vec::new();
+
+    for chunk in app_ids.chunks(chunk_size) {
+        app_id_chunks.push(chunk.to_vec());
+    }
 
-    for app_id in app_ids {
-        if let Some(perms) = get_app_permissions(&app_id, is_flatpak) {
-            result.insert(app_id, perms);
+    for chunk in app_id_chunks.iter() {
+        let mut handles = Vec::new();
+
+        for app_id in chunk {
+            let result_clone = Arc::clone(&result);
+            let app_id_clone = app_id.clone();
+            let handle = thread::spawn(move || {
+                if let Some(perms) = get_app_permissions(&app_id_clone, is_flatpak) {
+                    result_clone.lock().unwrap().insert(app_id_clone, perms);
+                }
+            });
+            handles.push(handle);
+        }
+
+        // Wait for this chunk to complete
+        for handle in handles {
+            let _ = handle.join();
         }
     }
 
-    Ok(result)
+    let final_result = result.lock().unwrap().clone();
+    Ok(final_result)
 }
 
 #[tauri::command]
@@ -296,7 +307,6 @@ async fn get_system_analytics(
 
     // Get system info
     let system_info = get_system_info().await?;
-
     Ok(SystemAnalytics {
         disk_usage,
         flatpak_stats,

src-tauri/src/lib.rs

@@ -42,25 +42,9 @@ export const useInstalledApps = () => {
           "get_installed_flatpaks",
         );
 
-        // Preload permissions for all apps in batch to avoid separate calls later
-        let permissionsMap: Record<string, string[]> = {};
-        if (response.apps.length > 0) {
-          const appIds = response.apps.map((app) => app.app_id);
-          try {
-            permissionsMap = await invoke<Record<string, string[]>>(
-              "get_app_permissions_batch",
-              { appIds },
-            );
-          } catch (permError) {
-            console.error(
-              "[useInstalledApps] Error loading permissions:",
-              permError,
-            );
-          }
-        }
-
-        // Convert apps from Rust format to TypeScript format with permissions
+        // Convert apps from Rust format to TypeScript format
         // Generate unique instanceId for each app to handle duplicates
+        // Permissions will be loaded on-demand when needed (e.g., in Analytics page)
         const installedAppsInfo: InstalledAppInfo[] = response.apps.map(
           (app) => ({
             instanceId: uuidv4(),
@@ -70,7 +54,7 @@ export const useInstalledApps = () => {
             summary: app.summary,
             developer: app.developer,
             installedSize: app.installed_size,
-            permissions: permissionsMap[app.app_id] || [],
+            permissions: [], // Loaded on-demand
           }),
         );
 

src/hooks/useInstalledApps.ts

@@ -1,5 +1,6 @@
 import { useCallback, useState } from "react";
 import type { InstalledAppInfo } from "../store/installedAppsStore";
+import { dbCacheManager } from "../utils/dbCache";
 import {
 	updateFlatpakApp,
 	updateSystemFlatpaks,
@@ -58,6 +59,7 @@ export function useUpdateAll(onComplete?: () => void): UseUpdateAllReturn {
 			});
 
 			let errorCount = 0;
+			const successfullyUpdatedAppIds: string[] = [];
 
 			// ===== PHASE 1: Update user apps =====
 			for (let i = 0; i < appsToUpdate.length; i++) {
@@ -95,6 +97,7 @@ export function useUpdateAll(onComplete?: () => void): UseUpdateAllReturn {
 							"",
 							`✓ ${app.name} actualizado exitosamente`,
 						]);
+						successfullyUpdatedAppIds.push(app.appId);
 					} else {
 						errorCount++;
 						setUpdateAllOutput((prev) => [
@@ -201,6 +204,20 @@ export function useUpdateAll(onComplete?: () => void): UseUpdateAllReturn {
 				}
 			}
 
+			// Mark permissions as outdated for successfully updated apps
+			if (successfullyUpdatedAppIds.length > 0) {
+				try {
+					await dbCacheManager.markPermissionsAsOutdatedBatch(
+						successfullyUpdatedAppIds,
+					);
+				} catch (error) {
+					console.error(
+						"Error marking permissions as outdated after batch update:",
+						error,
+					);
+				}
+			}
+
 			// ===== PHASE 3: Complete =====
 			setIsUpdatingAll(false);
 			if (errorCount === 0) {

src/hooks/useUpdateAll.ts

@@ -1,4 +1,5 @@
 import { useCallback, useState } from "react";
+import { dbCacheManager } from "../utils/dbCache";
 import { updateFlatpakApp } from "../utils/flatpakOperations";
 
 interface UseUpdateAppReturn {
@@ -43,6 +44,13 @@ export function useUpdateApp(): UseUpdateAppReturn {
 					"✓ Actualización completada exitosamente",
 				]);
 				setUpdateProgress(100);
+
+				// Mark permissions as outdated since the app was updated
+				try {
+					await dbCacheManager.markPermissionsAsOutdated(appId);
+				} catch (error) {
+					console.error("Error marking permissions as outdated:", error);
+				}
 			} else {
 				setUpdateOutput((prev) => [
 					...prev,

src/hooks/useUpdateApp.ts

@@ -5,6 +5,7 @@ import { useCallback, useEffect, useState } from "react";
 import { useTranslation } from "react-i18next";
 import type { InstalledAppInfo } from "../../store/installedAppsStore";
 import { useInstalledAppsStore } from "../../store/installedAppsStore";
+import { dbCacheManager } from "../../utils/dbCache";
 import { DataCube } from "./components/DataCube";
 import { SystemTerminal } from "./components/SystemTerminal";
 
@@ -32,11 +33,15 @@ export const Analytics = ({ onBack }: AnalyticsProps) => {
   const [loading, setLoading] = useState(true);
   const [selectedApp, setSelectedApp] = useState<InstalledAppInfo | null>(null);
   const [permissionFilter, setPermissionFilter] = useState<string | null>(null);
+  const [loadingPermissions, setLoadingPermissions] = useState(false);
 
-  // Get installed apps from store (permissions are preloaded by useInstalledApps)
+  // Get installed apps from store
   const installedAppsInfo = useInstalledAppsStore(
     (state) => state.installedAppsInfo,
   );
+  const setInstalledAppsInfo = useInstalledAppsStore(
+    (state) => state.setInstalledAppsInfo,
+  );
   const installedRuntimes = useInstalledAppsStore(
     (state) => state.installedRuntimes,
   );
@@ -54,10 +59,10 @@ export const Analytics = ({ onBack }: AnalyticsProps) => {
       const updateCount = Object.keys(availableUpdates).length;
 
       const data = await invoke<SystemAnalytics>("get_system_analytics", {
-        totalApps: installedAppsInfo.length || undefined,
-        totalRuntimes: installedRuntimes.size || undefined,
-        totalExtensions: extensionCount || undefined,
-        appsWithUpdates: updateCount || undefined,
+        totalApps: installedAppsInfo.length,
+        totalRuntimes: installedRuntimes.size,
+        totalExtensions: extensionCount,
+        appsWithUpdates: updateCount,
       });
       setAnalytics(data);
     } catch (error) {
@@ -67,9 +72,93 @@ export const Analytics = ({ onBack }: AnalyticsProps) => {
     }
   }, [installedAppsInfo.length, installedRuntimes.size, availableUpdates]);
 
+  // Load permissions on-demand when Analytics page opens
+  const loadPermissions = useCallback(async () => {
+    // Check if permissions are already loaded in store
+    const hasPermissions = installedAppsInfo.some(
+      (app) => app.permissions && app.permissions.length > 0,
+    );
+
+    if (hasPermissions || installedAppsInfo.length === 0) {
+      return; // Already loaded or no apps
+    }
+
+    try {
+      setLoadingPermissions(true);
+
+      // Step 1: Try to get cached permissions from SQLite
+      const cachedPermissions = await dbCacheManager.getCachedPermissionsBatch(
+        installedAppsInfo.map((app) => ({
+          appId: app.appId,
+          version: app.version,
+        })),
+      );
+
+      // Step 2: Find apps that need permissions fetched
+      const appsNeedingPermissions = installedAppsInfo.filter(
+        (app) => !cachedPermissions[app.appId],
+      );
+
+      let freshPermissions: Record<string, string[]> = {};
+
+      // Step 3: Fetch missing permissions from flatpak
+      if (appsNeedingPermissions.length > 0) {
+        const appIds = appsNeedingPermissions.map((app) => app.appId);
+        freshPermissions = await invoke<Record<string, string[]>>(
+          "get_app_permissions_batch",
+          { appIds },
+        );
+
+        // Step 4: Cache the newly fetched permissions
+        const permissionsToCache: Record<
+          string,
+          { version: string; permissions: string[] }
+        > = {};
+        for (const app of appsNeedingPermissions) {
+          if (freshPermissions[app.appId]) {
+            permissionsToCache[app.appId] = {
+              version: app.version,
+              permissions: freshPermissions[app.appId],
+            };
+          }
+        }
+        await dbCacheManager.cachePermissionsBatch(permissionsToCache);
+      }
+
+      // Step 5: Merge cached and fresh permissions
+      const allPermissions = { ...cachedPermissions, ...freshPermissions };
+
+      // Step 6: Update apps with permissions
+      const updatedApps = installedAppsInfo.map((app) => ({
+        ...app,
+        permissions: allPermissions[app.appId] || [],
+      }));
+      setInstalledAppsInfo(updatedApps);
+
+      // Step 7: Clean old versions from cache (keep only current versions)
+      // This prevents database from growing indefinitely
+      try {
+        await dbCacheManager.cleanOldPermissionsBatch(
+          installedAppsInfo.map((app) => ({
+            appId: app.appId,
+            version: app.version,
+          })),
+        );
+      } catch (error) {
+        console.error("Error cleaning old permissions:", error);
+      }
+    } catch (error) {
+      console.error("Error loading permissions:", error);
+    } finally {
+      setLoadingPermissions(false);
+    }
+  }, [installedAppsInfo, setInstalledAppsInfo]);
+
   useEffect(() => {
     loadAnalytics();
-  }, [loadAnalytics]);
+    loadPermissions();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []); // Solo ejecutar una vez al montar el componente
 
   return (
     <Box

src/pages/analytics/Analytics.tsx

@@ -204,7 +204,7 @@ const CubeScene = ({
   isGridView,
   permissionFilter,
   selectedApp,
-}: Omit<DataCubeProps, "loading"> & {
+}: Omit<DataCubeProps, "loading" | "onPermissionFilterChange"> & {
   isGridView: boolean;
   permissionFilter: PermissionFilter;
   selectedApp: InstalledAppInfo | null;
@@ -306,9 +306,6 @@ const CubeScene = ({
 
       // Calcular filas necesarias para cada grupo
       const withPermRows = Math.ceil(appsWithPermission.length / maxCols);
-      const _withoutPermRows = Math.ceil(
-        appsWithoutPermission.length / maxCols,
-      );
 
       // Espacio vertical entre grupos (fila vacía)
       const groupSeparation = 2.0;

src/pages/analytics/components/DataCube.tsx

@@ -186,6 +186,7 @@ export const MyApps = ({ onBack, onDeveloperSelect }: MyAppsProps) => {
       // Convert from Rust format to TypeScript format
       const installedAppsInfo: InstalledAppInfo[] = response.apps.map(
         (app) => ({
+          instanceId: `${app.app_id}-${app.version}`,
           appId: app.app_id,
           name: app.name,
           version: app.version,