fix: simplify conditional checks and improve async handler usage across multiple files (#5156)

* fix: simplify conditional checks and improve async handler usage across multiple files

* fix: add missing AsyncHandler import in find_processes_by_name function

* fix: remove redundant AsyncHandler import in find_processes_by_name function

src-tauri/src/core/handle.rs

@@ -39,14 +39,15 @@ impl Handle {
         }
 
         let mut system_opt = self.notification_system.write();
-        if let Some(system) = system_opt.as_mut() {
+        if let Some(system) = system_opt.as_mut()
-            if !system.is_running {
+            && !system.is_running
-                system.start();
+        {
-            }
+            system.start();
         }
     }
 
     pub fn app_handle() -> &'static AppHandle {
+        #[allow(clippy::expect_used)]
         APP_HANDLE.get().expect("App handle not initialized")
     }
 

src-tauri/src/core/manager/config.rs

@@ -50,10 +50,10 @@ impl CoreManager {
         let now = Instant::now();
         let mut last = self.last_update.lock();
 
-        if let Some(last_time) = *last {
+        if let Some(last_time) = *last
-            if now.duration_since(last_time) < timing::CONFIG_UPDATE_DEBOUNCE {
+            && now.duration_since(last_time) < timing::CONFIG_UPDATE_DEBOUNCE
-                return Ok(false);
+        {
-            }
+            return Ok(false);
         }
 
         *last = Some(now);

src-tauri/src/core/manager/lifecycle.rs

@@ -65,6 +65,7 @@ impl CoreManager {
     }
 
     async fn prepare_startup(&self) -> Result<()> {
+        #[cfg(target_os = "windows")]
         self.wait_for_service_if_needed().await;
 
         let mode = match SERVICE_MANAGER.lock().await.current() {
@@ -121,7 +122,4 @@ impl CoreManager {
 
         let _ = backoff::future::retry(backoff, operation).await;
     }
-
-    #[cfg(not(target_os = "windows"))]
-    async fn wait_for_service_if_needed(&self) {}
 }

src-tauri/src/core/manager/process.rs

@@ -1,11 +1,14 @@
 use super::CoreManager;
+#[cfg(windows)]
+use crate::process::AsyncHandler;
 use crate::{
-    AsyncHandler,
     constants::{process, timing},
     logging,
     utils::logging::Type,
 };
-use anyhow::{Result, anyhow};
+use anyhow::Result;
+#[cfg(windows)]
+use anyhow::anyhow;
 
 impl CoreManager {
     pub async fn cleanup_orphaned_processes(&self) -> Result<()> {

src-tauri/src/core/notification.rs

@@ -96,9 +96,9 @@ impl NotificationSystem {
 
         while !handle.is_exiting() {
             match rx.recv_timeout(std::time::Duration::from_millis(100)) {
-                Ok(event) => Self::process_event(&handle, event),
+                Ok(event) => Self::process_event(handle, event),
                 Err(mpsc::RecvTimeoutError::Disconnected) => break,
-                Err(mpsc::RecvTimeoutError::Timeout) => continue,
+                Err(mpsc::RecvTimeoutError::Timeout) => break,
             }
         }
     }

src-tauri/src/lib.rs

@@ -85,7 +85,7 @@ mod app_init {
         app.deep_link().on_open_url(|event| {
             let url = event.urls().first().map(|u| u.to_string());
             if let Some(url) = url {
-                let _ = AsyncHandler::spawn(|| async {
+                AsyncHandler::spawn(|| async {
                     if let Err(e) = resolve::resolve_scheme(url).await {
                         logging!(error, Type::Setup, "Failed to resolve scheme: {}", e);
                     }
@@ -300,7 +300,7 @@ pub fn run() {
         }
 
         pub fn handle_window_focus(focused: bool) {
-            let _ = AsyncHandler::spawn(move || async move {
+            AsyncHandler::spawn(move || async move {
                 let is_enable_global_hotkey = Config::verge()
                     .await
                     .latest_ref()
@@ -339,7 +339,7 @@ pub fn run() {
         }
 
         pub fn handle_window_destroyed() {
-            let _ = AsyncHandler::spawn(|| async {
+            AsyncHandler::spawn(|| async {
                 let _ = handle::Handle::mihomo()
                     .await
                     .clear_all_ws_connections()
@@ -396,7 +396,7 @@ pub fn run() {
             if core::handle::Handle::global().is_exiting() {
                 return;
             }
-            let _ = AsyncHandler::spawn(move || async move {
+            AsyncHandler::spawn(move || async move {
                 event_handlers::handle_reopen(has_visible_windows).await;
             });
         }

src-tauri/src/utils/resolve/mod.rs

@@ -26,14 +26,14 @@ pub fn resolve_setup_handle() {
 }
 
 pub fn resolve_setup_sync() {
-    let _ = AsyncHandler::spawn(|| async {
+    AsyncHandler::spawn(|| async {
-        let _ = AsyncHandler::spawn_blocking(init_scheme);
+        AsyncHandler::spawn_blocking(init_scheme);
-        let _ = AsyncHandler::spawn_blocking(init_embed_server);
+        AsyncHandler::spawn_blocking(init_embed_server);
     });
 }
 
 pub fn resolve_setup_async() {
-    let _ = AsyncHandler::spawn(|| async {
+    AsyncHandler::spawn(|| async {
         #[cfg(not(feature = "tauri-dev"))]
         resolve_setup_logger().await;
         logging!(
@@ -53,7 +53,7 @@ pub fn resolve_setup_async() {
             init_service_manager().await;
             init_core_manager().await;
             init_system_proxy().await;
-            let _ = AsyncHandler::spawn_blocking(init_system_proxy_guard);
+            AsyncHandler::spawn_blocking(init_system_proxy_guard);
         });
 
         let tray_init = async {

src-tauri/src/utils/server.rs

@@ -67,7 +67,7 @@ pub fn embed_server() {
         .expect("failed to set shutdown signal for embedded server");
     let port = IVerge::get_singleton_port();
 
-    let _ = AsyncHandler::spawn(move || async move {
+    AsyncHandler::spawn(move || async move {
         let visible = warp::path!("commands" / "visible").and_then(|| async {
             logging!(info, Type::Window, "检测到从单例模式恢复应用窗口");
             if !lightweight::exit_lightweight_mode().await {
@@ -108,7 +108,7 @@ pub fn embed_server() {
             .and(warp::query::<QueryParam>())
             .map(|query: QueryParam| {
                 let param = query.param.clone();
-                let _ = tokio::task::spawn_local(async move {
+                tokio::task::spawn_local(async move {
                     logging_error!(Type::Setup, resolve::resolve_scheme(param).await);
                 });
                 warp::reply::with_status::<String>("ok".into(), warp::http::StatusCode::OK)