refactor(async): migrate from sync-blocking async execution to true async with unified AsyncHandler::spawn (#4502)

* feat: replace all tokio::spawn with unified AsyncHandler::spawn

- 🚀 Core Improvements:
  * Replace all tokio::spawn calls with AsyncHandler::spawn for unified Tauri async task management
  * Prioritize converting sync functions to async functions to reduce spawn usage
  * Use .await directly in async contexts instead of spawn

- 🔧 Major Changes:
  * core/hotkey.rs: Use AsyncHandler::spawn for hotkey callback functions
  * module/lightweight.rs: Async lightweight mode switching
  * feat/window.rs: Convert window operation functions to async, use .await internally
  * feat/proxy.rs, feat/clash.rs: Async proxy and mode switching functions
  * lib.rs: Window focus handling with AsyncHandler::spawn
  * core/tray/mod.rs: Complete async tray event handling

- ✨ Technical Advantages:
  * Unified task tracking and debugging capabilities (via tokio-trace feature)
  * Better error handling and task management
  * Consistency with Tauri runtime
  * Reduced async boundaries for better performance

- 🧪 Verification:
  * Compilation successful with 0 errors, 0 warnings
  * Maintains complete original functionality
  * Optimized async execution flow

* feat: complete tokio fs migration and replace tokio::spawn with AsyncHandler

🚀 Major achievements:
- Migrate 8 core modules from std::fs to tokio::fs
- Create 6 Send-safe wrapper functions using spawn_blocking pattern
- Replace all tokio::spawn calls with AsyncHandler::spawn for unified async task management
- Solve all 19 Send trait compilation errors through innovative spawn_blocking architecture

🔧 Core changes:
- config/profiles.rs: Add profiles_*_safe functions to handle Send trait constraints
- cmd/profile.rs: Update all Tauri commands to use Send-safe operations
- config/prfitem.rs: Replace append_item calls with profiles_append_item_safe
- utils/help.rs: Convert YAML operations to async (read_yaml, save_yaml)
- Multiple modules: Replace tokio::task::spawn_blocking with AsyncHandler::spawn_blocking

✅ Technical innovations:
- spawn_blocking wrapper pattern resolves parking_lot RwLock Send trait conflicts
- Maintain parking_lot performance while achieving Tauri async command compatibility
- Preserve backwards compatibility with gradual migration strategy

🎯 Results:
- Zero compilation errors
- Zero warnings
- All async file operations working correctly
- Complete Send trait compliance for Tauri commands

* feat: refactor app handle and command functions to use async/await for improved performance

* feat: update async handling in profiles and logging functions for improved error handling and performance

* fix: update TRACE_MINI_SIZE constant to improve task logging threshold

* fix(windows): convert service management functions to async for improved performance

* fix: convert service management functions to async for improved responsiveness

* fix(ubuntu): convert install and reinstall service functions to async for improved performance

* fix(linux): convert uninstall_service function to async for improved performance

* fix: convert uninstall_service call to async for improved performance

* fix: convert file and directory creation calls to async for improved performance

* fix: convert hotkey functions to async for improved responsiveness

* chore: update UPDATELOG.md for v2.4.1 with major improvements and performance optimizations

src-tauri/src/utils/notification.rs

@@ -1,4 +1,4 @@
-use std::sync::Arc;
+use crate::utils::i18n::t;
 
 use tauri::AppHandle;
 use tauri_plugin_notification::NotificationExt;
@@ -16,7 +16,7 @@ pub enum NotificationEvent<'a> {
     AppHidden,
 }
 
-fn notify(app: Arc<AppHandle>, title: &str, body: &str) {
+fn notify(app: &AppHandle, title: &str, body: &str) {
     app.notification()
         .builder()
         .title(title)
@@ -25,48 +25,54 @@ fn notify(app: Arc<AppHandle>, title: &str, body: &str) {
         .ok();
 }
 
-pub fn notify_event(app: Arc<AppHandle>, event: NotificationEvent) {
-    use crate::utils::i18n::t;
+pub async fn notify_event<'a>(app: AppHandle, event: NotificationEvent<'a>) {
     match event {
         NotificationEvent::DashboardToggled => {
-            notify(app, &t("DashboardToggledTitle"), &t("DashboardToggledBody"));
+            notify(
+                &app,
+                &t("DashboardToggledTitle").await,
+                &t("DashboardToggledBody").await,
+            );
         }
         NotificationEvent::ClashModeChanged { mode } => {
             notify(
-                app,
-                &t("ClashModeChangedTitle"),
-                &t_with_args("ClashModeChangedBody", mode),
+                &app,
+                &t("ClashModeChangedTitle").await,
+                &t_with_args("ClashModeChangedBody", mode).await,
             );
         }
         NotificationEvent::SystemProxyToggled => {
             notify(
-                app,
-                &t("SystemProxyToggledTitle"),
-                &t("SystemProxyToggledBody"),
+                &app,
+                &t("SystemProxyToggledTitle").await,
+                &t("SystemProxyToggledBody").await,
             );
         }
         NotificationEvent::TunModeToggled => {
-            notify(app, &t("TunModeToggledTitle"), &t("TunModeToggledBody"));
+            notify(
+                &app,
+                &t("TunModeToggledTitle").await,
+                &t("TunModeToggledBody").await,
+            );
         }
         NotificationEvent::LightweightModeEntered => {
             notify(
-                app,
-                &t("LightweightModeEnteredTitle"),
-                &t("LightweightModeEnteredBody"),
+                &app,
+                &t("LightweightModeEnteredTitle").await,
+                &t("LightweightModeEnteredBody").await,
             );
         }
         NotificationEvent::AppQuit => {
-            notify(app, &t("AppQuitTitle"), &t("AppQuitBody"));
+            notify(&app, &t("AppQuitTitle").await, &t("AppQuitBody").await);
         }
         #[cfg(target_os = "macos")]
         NotificationEvent::AppHidden => {
-            notify(app, &t("AppHiddenTitle"), &t("AppHiddenBody"));
+            notify(&app, &t("AppHiddenTitle").await, &t("AppHiddenBody").await);
         }
     }
 }
 
 // 辅助函数，带参数的i18n
-fn t_with_args(key: &str, mode: &str) -> String {
-    use crate::utils::i18n::t;
-    t(key).replace("{mode}", mode)
+async fn t_with_args(key: &str, mode: &str) -> String {
+    t(key).await.replace("{mode}", mode)
 }