refactor backend

src-tauri/src/lib.rs

@@ -1,89 +1,102 @@
-mod cleaner;
-use tauri::State;
 use std::collections::HashMap;
 use std::sync::Mutex;
+use tauri::State;
+
+mod backend;
 
 #[tauri::command]
-async fn start_fast_scan() -> cleaner::FastScanResult {
-    cleaner::run_fast_scan().await
+async fn start_fast_scan() -> backend::models::FastScanResult {
+    backend::fast_clean::run_fast_scan().await
 }
 
 #[tauri::command]
-async fn start_fast_clean(selected_paths: Vec<String>) -> Result<cleaner::CleanResult, String> {
-    cleaner::run_fast_clean(selected_paths).await
+async fn start_fast_clean(selected_paths: Vec<String>) -> Result<backend::models::CleanResult, String> {
+    backend::fast_clean::run_fast_clean(selected_paths).await
 }
 
 #[tauri::command]
-async fn start_full_disk_scan(state: State<'_, cleaner::DiskState>, app_handle: tauri::AppHandle) -> Result<(), String> {
-    cleaner::run_full_scan("C:\\".to_string(), &state, app_handle).await;
+async fn start_full_disk_scan(
+    state: State<'_, backend::state::DiskState>,
+    app_handle: tauri::AppHandle,
+) -> Result<(), String> {
+    backend::disk_analysis::run_full_scan("C:\\".to_string(), &state, app_handle).await;
     Ok(())
 }
 
 #[tauri::command]
-async fn get_tree_children(path: String, state: State<'_, cleaner::DiskState>) -> Result<Vec<cleaner::FileTreeNode>, String> {
-    Ok(cleaner::get_children(path, &state))
+async fn get_tree_children(
+    path: String,
+    state: State<'_, backend::state::DiskState>,
+) -> Result<Vec<backend::models::FileTreeNode>, String> {
+    Ok(backend::disk_analysis::get_children(path, &state))
 }
 
 #[tauri::command]
 async fn open_in_explorer(path: String) -> Result<(), String> {
-    cleaner::open_explorer(path).await
+    backend::disk_analysis::open_explorer(path).await
 }
 
-// --- 高级清理命令 ---
-
 #[tauri::command]
 async fn clean_system_components() -> Result<String, String> {
-    cleaner::run_dism_cleanup().await
+    backend::advanced_clean::run_dism_cleanup().await
 }
 
 #[tauri::command]
 async fn clean_thumbnails() -> Result<String, String> {
-    cleaner::clean_thumbnails().await
+    backend::advanced_clean::clean_thumbnails().await
 }
 
 #[tauri::command]
 async fn disable_hibernation() -> Result<String, String> {
-    cleaner::disable_hibernation().await
-}
-
-// --- 浏览器清理命令 ---
-
-#[tauri::command]
-async fn start_browser_scan(browser: String) -> Result<cleaner::BrowserScanResult, String> {
-    let b_type = if browser == "chrome" { cleaner::BrowserType::Chrome } else { cleaner::BrowserType::Edge };
-    cleaner::run_browser_scan(b_type).await
+    backend::advanced_clean::disable_hibernation().await
 }
 
 #[tauri::command]
-async fn start_browser_clean(browser: String, profiles: Vec<String>) -> Result<cleaner::CleanResult, String> {
-    let b_type = if browser == "chrome" { cleaner::BrowserType::Chrome } else { cleaner::BrowserType::Edge };
-    cleaner::run_browser_clean(b_type, profiles).await
+async fn start_browser_scan(browser: String) -> Result<backend::models::BrowserScanResult, String> {
+    let browser_type = if browser == "chrome" {
+        backend::models::BrowserType::Chrome
+    } else {
+        backend::models::BrowserType::Edge
+    };
+
+    backend::browser_clean::run_browser_scan(browser_type).await
 }
 
-// --- 内存清理命令 ---
+#[tauri::command]
+async fn start_browser_clean(
+    browser: String,
+    profiles: Vec<String>,
+) -> Result<backend::models::CleanResult, String> {
+    let browser_type = if browser == "chrome" {
+        backend::models::BrowserType::Chrome
+    } else {
+        backend::models::BrowserType::Edge
+    };
+
+    backend::browser_clean::run_browser_clean(browser_type, profiles).await
+}
 
 #[tauri::command]
-async fn get_memory_stats() -> cleaner::MemoryStats {
-    cleaner::get_memory_stats()
+async fn get_memory_stats() -> backend::models::MemoryStats {
+    backend::memory_clean::get_memory_stats()
 }
 
 #[tauri::command]
 async fn run_memory_clean() -> Result<u64, String> {
-    cleaner::run_memory_clean().await
+    backend::memory_clean::run_memory_clean().await
 }
 
 #[tauri::command]
 async fn run_deep_memory_clean() -> Result<u64, String> {
-    cleaner::run_deep_memory_clean().await
+    backend::memory_clean::run_deep_memory_clean().await
 }
 
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
     tauri::Builder::default()
         .plugin(tauri_plugin_opener::init())
-        .manage(cleaner::DiskState {
+        .manage(backend::state::DiskState {
             dir_sizes: Mutex::new(HashMap::new()),
-            // file_info: Mutex::new(HashMap::new()),
         })
         .invoke_handler(tauri::generate_handler![
             start_fast_scan,