fix: manage setup Mutex crash (#3995)

* Revert "Revert "refactor: Replace std::sync::Mutex with parking_lot::Mutex for improved performance and consistency in multiple files" (#3990)"

This reverts commit 667844aa12.

* refactor: Manage lightweight state in the app setup and clean up unused proxy client code

* refactor: Move macOS-specific Manager import under conditional compilation

src-tauri/src/utils/network.rs

@@ -1,8 +1,9 @@
 use anyhow::Result;
 use lazy_static::lazy_static;
+use parking_lot::Mutex;
 use reqwest::{Client, ClientBuilder, Proxy, RequestBuilder, Response};
 use std::{
-    sync::{Arc, Mutex, Once},
+    sync::{Arc, Once},
     time::{Duration, Instant},
 };
 use tokio::runtime::{Builder, Runtime};
@@ -78,7 +79,7 @@ impl NetworkManager {
                     .build()
                     .expect("Failed to build no_proxy client");
 
-                let mut no_proxy_guard = NETWORK_MANAGER.no_proxy_client.lock().unwrap();
+                let mut no_proxy_guard = NETWORK_MANAGER.no_proxy_client.lock();
                 *no_proxy_guard = Some(no_proxy_client);
 
                 logging!(info, Type::Network, true, "网络管理器初始化完成");
@@ -87,16 +88,16 @@ impl NetworkManager {
     }
 
     fn record_connection_error(&self, error: &str) {
-        let mut last_error = self.last_connection_error.lock().unwrap();
+        let mut last_error = self.last_connection_error.lock();
         *last_error = Some((Instant::now(), error.to_string()));
 
-        let mut error_count = self.connection_error_count.lock().unwrap();
+        let mut error_count = self.connection_error_count.lock();
         *error_count += 1;
     }
 
     fn should_reset_clients(&self) -> bool {
-        let error_count = *self.connection_error_count.lock().unwrap();
-        let last_error = self.last_connection_error.lock().unwrap();
+        let error_count = *self.connection_error_count.lock();
+        let last_error = self.last_connection_error.lock();
 
         if error_count > 5 {
             return true;
@@ -114,132 +115,23 @@ impl NetworkManager {
     pub fn reset_clients(&self) {
         logging!(info, Type::Network, true, "正在重置所有HTTP客户端");
         {
-            let mut client = self.self_proxy_client.lock().unwrap();
+            let mut client = self.self_proxy_client.lock();
             *client = None;
         }
         {
-            let mut client = self.system_proxy_client.lock().unwrap();
+            let mut client = self.system_proxy_client.lock();
             *client = None;
         }
         {
-            let mut client = self.no_proxy_client.lock().unwrap();
+            let mut client = self.no_proxy_client.lock();
             *client = None;
         }
         {
-            let mut error_count = self.connection_error_count.lock().unwrap();
+            let mut error_count = self.connection_error_count.lock();
             *error_count = 0;
         }
     }
-    /*
-       /// 获取或创建自代理客户端
-       fn get_or_create_self_proxy_client(&self) -> Client {
-           if self.should_reset_clients() {
-               self.reset_clients();
-           }
 
-           let mut client_guard = self.self_proxy_client.lock().unwrap();
-
-           if client_guard.is_none() {
-               let port = Config::verge()
-                   .latest_ref()
-                   .verge_mixed_port
-                   .unwrap_or(Config::clash().latest_ref().get_mixed_port());
-
-               let proxy_scheme = format!("http://127.0.0.1:{port}");
-
-               let mut builder = ClientBuilder::new()
-                   .use_rustls_tls()
-                   .pool_max_idle_per_host(POOL_MAX_IDLE_PER_HOST)
-                   .pool_idle_timeout(POOL_IDLE_TIMEOUT)
-                   .connect_timeout(DEFAULT_CONNECT_TIMEOUT)
-                   .timeout(DEFAULT_REQUEST_TIMEOUT)
-                   .http2_initial_stream_window_size(H2_STREAM_WINDOW_SIZE)
-                   .http2_initial_connection_window_size(H2_CONNECTION_WINDOW_SIZE)
-                   .http2_adaptive_window(true)
-                   .http2_keep_alive_interval(Some(H2_KEEP_ALIVE_INTERVAL))
-                   .http2_keep_alive_timeout(H2_KEEP_ALIVE_TIMEOUT)
-                   .http2_max_frame_size(H2_MAX_FRAME_SIZE)
-                   .tcp_keepalive(Some(Duration::from_secs(10)))
-                   .http2_max_header_list_size(16 * 1024);
-
-               if let Ok(proxy) = Proxy::http(&proxy_scheme) {
-                   builder = builder.proxy(proxy);
-               }
-               if let Ok(proxy) = Proxy::https(&proxy_scheme) {
-                   builder = builder.proxy(proxy);
-               }
-               if let Ok(proxy) = Proxy::all(&proxy_scheme) {
-                   builder = builder.proxy(proxy);
-               }
-
-               let client = builder.build().expect("Failed to build self_proxy client");
-               *client_guard = Some(client);
-           }
-
-           client_guard.as_ref().unwrap().clone()
-       }
-
-       /// 获取或创建系统代理客户端
-       fn get_or_create_system_proxy_client(&self) -> Client {
-           if self.should_reset_clients() {
-               self.reset_clients();
-           }
-
-           let mut client_guard = self.system_proxy_client.lock().unwrap();
-
-           if client_guard.is_none() {
-               use sysproxy::Sysproxy;
-
-               let mut builder = ClientBuilder::new()
-                   .use_rustls_tls()
-                   .pool_max_idle_per_host(POOL_MAX_IDLE_PER_HOST)
-                   .pool_idle_timeout(POOL_IDLE_TIMEOUT)
-                   .connect_timeout(DEFAULT_CONNECT_TIMEOUT)
-                   .timeout(DEFAULT_REQUEST_TIMEOUT)
-                   .http2_initial_stream_window_size(H2_STREAM_WINDOW_SIZE)
-                   .http2_initial_connection_window_size(H2_CONNECTION_WINDOW_SIZE)
-                   .http2_adaptive_window(true)
-                   .http2_keep_alive_interval(Some(H2_KEEP_ALIVE_INTERVAL))
-                   .http2_keep_alive_timeout(H2_KEEP_ALIVE_TIMEOUT)
-                   .http2_max_frame_size(H2_MAX_FRAME_SIZE)
-                   .tcp_keepalive(Some(Duration::from_secs(10)))
-                   .http2_max_header_list_size(16 * 1024);
-
-               if let Ok(p @ Sysproxy { enable: true, .. }) = Sysproxy::get_system_proxy() {
-                   let proxy_scheme = format!("http://{}:{}", p.host, p.port);
-
-                   if let Ok(proxy) = Proxy::http(&proxy_scheme) {
-                       builder = builder.proxy(proxy);
-                   }
-                   if let Ok(proxy) = Proxy::https(&proxy_scheme) {
-                       builder = builder.proxy(proxy);
-                   }
-                   if let Ok(proxy) = Proxy::all(&proxy_scheme) {
-                       builder = builder.proxy(proxy);
-                   }
-               }
-
-               let client = builder
-                   .build()
-                   .expect("Failed to build system_proxy client");
-               *client_guard = Some(client);
-           }
-
-           client_guard.as_ref().unwrap().clone()
-       }
-
-       /// 根据代理设置选择合适的客户端
-       pub fn get_client(&self, proxy_type: ProxyType) -> Client {
-           match proxy_type {
-               ProxyType::NoProxy => {
-                   let client_guard = self.no_proxy_client.lock().unwrap();
-                   client_guard.as_ref().unwrap().clone()
-               }
-               ProxyType::SelfProxy => self.get_or_create_self_proxy_client(),
-               ProxyType::SystemProxy => self.get_or_create_system_proxy_client(),
-           }
-       }
-    */
     /// 创建带有自定义选项的HTTP请求
     pub fn create_request(
         &self,