root/clash-verge-rev
1
0
Fork 0
mirror of https://github.com/clash-verge-rev/clash-verge-rev.git synced 2026-01-29 17:15:38 +08:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
* 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
This commit is contained in:
Tunglies
2025-08-26 01:49:51 +08:00
committed by GitHub
parent 4598c805eb
commit 355a18e5eb
47 changed files with 2127 additions and 1809 deletions
Download Patch File Download Diff File Expand all files Collapse all files

174
src-tauri/src/lib.rs
View File

@@ -17,7 +17,6 @@ use crate::{
};
use config::Config;
use parking_lot::Mutex;
use std::sync::Arc;
use tauri::AppHandle;
#[cfg(target_os = "macos")]
use tauri::Manager;
@@ -29,7 +28,7 @@ use utils::logging::Type;
/// A global singleton handle to the application.
pub struct AppHandleManager {
handle: Mutex<Option<Arc<AppHandle>>>,
handle: Mutex<Option<AppHandle>>,
}
impl AppHandleManager {
@@ -41,7 +40,7 @@ impl AppHandleManager {
}
/// Initialize the app handle manager with an app handle.
pub fn init(&self, handle: Arc<AppHandle>) {
pub fn init(&self, handle: AppHandle) {
let mut app_handle = self.handle.lock();
if app_handle.is_none() {
*app_handle = Some(handle);
@@ -55,12 +54,12 @@ impl AppHandleManager {
}
/// Get the app handle if it has been initialized.
fn get(&self) -> Option<Arc<AppHandle>> {
fn get(&self) -> Option<AppHandle> {
self.handle.lock().clone()
}
/// Get the app handle, panics if it hasn't been initialized.
pub fn get_handle(&self) -> Arc<AppHandle> {
pub fn get_handle(&self) -> AppHandle {
if let Some(handle) = self.get() {
handle
} else {
@@ -203,16 +202,14 @@ mod app_init {
}
app.deep_link().on_open_url(|event| {
AsyncHandler::spawn(move || {
let url = event.urls().first().map(|u| u.to_string());
async move {
if let Some(url) = url {
if let Err(e) = resolve_scheme(url).await {
logging!(error, Type::Setup, true, "Failed to resolve scheme: {}", e);
}
let url = event.urls().first().map(|u| u.to_string());
if let Some(url) = url {
tokio::task::spawn_local(async move {
if let Err(e) = resolve_scheme(url).await {
logging!(error, Type::Setup, true, "Failed to resolve scheme: {}", e);
}
}
});
});
}
});
Ok(())
@@ -247,12 +244,13 @@ mod app_init {
}
/// Initialize core components asynchronously
pub fn init_core_async(app_handle: Arc<AppHandle>) {
pub fn init_core_async(app_handle: &AppHandle) {
let app_handle = app_handle.clone();
AsyncHandler::spawn(move || async move {
logging!(info, Type::Setup, true, "异步执行应用设置...");
match timeout(
Duration::from_secs(30),
resolve::resolve_setup_async(app_handle),
resolve::resolve_setup_async(&app_handle),
)
.await
{
@@ -272,18 +270,18 @@ mod app_init {
}
/// Initialize core components synchronously
pub fn init_core_sync(app_handle: Arc<AppHandle>) -> Result<(), Box<dyn std::error::Error>> {
pub async fn init_core_sync(app_handle: &AppHandle) -> Result<(), Box<dyn std::error::Error>> {
logging!(info, Type::Setup, true, "初始化AppHandleManager...");
AppHandleManager::global().init(Arc::clone(&app_handle));
AppHandleManager::global().init(app_handle.clone());
logging!(info, Type::Setup, true, "初始化核心句柄...");
core::handle::Handle::global().init(Arc::clone(&app_handle));
core::handle::Handle::global().init(app_handle.clone());
logging!(info, Type::Setup, true, "初始化配置...");
utils::init::init_config()?;
utils::init::init_config().await?;
logging!(info, Type::Setup, true, "初始化资源...");
utils::init::init_resources()?;
utils::init::init_resources().await?;
logging!(info, Type::Setup, true, "核心组件初始化完成");
Ok(())
@@ -484,24 +482,24 @@ pub fn run() {
}
let app_handle = app.handle().clone();
let app_handle = Arc::new(app_handle);
// Initialize core components asynchronously
app_init::init_core_async(Arc::clone(&app_handle));
app_init::init_core_async(&app_handle);
logging!(info, Type::Setup, true, "执行主要设置操作...");
// Initialize core components synchronously
if let Err(e) = app_init::init_core_sync(Arc::clone(&app_handle)) {
logging!(
error,
Type::Setup,
true,
"Failed to initialize core components: {}",
e
);
return Err(e);
}
AsyncHandler::spawn(move || async move {
if let Err(e) = app_init::init_core_sync(&app_handle).await {
logging!(
error,
Type::Setup,
true,
"Failed to initialize core components: {}",
e
);
}
});
logging!(info, Type::Setup, true, "初始化完成，继续执行");
Ok(())
@@ -513,9 +511,9 @@ pub fn run() {
use super::*;
/// Handle application ready/resumed events
pub fn handle_ready_resumed(app_handle: Arc<AppHandle>) {
pub fn handle_ready_resumed(app_handle: &AppHandle) {
logging!(info, Type::System, true, "应用就绪或恢复");
AppHandleManager::global().init(Arc::clone(&app_handle));
AppHandleManager::global().init(app_handle.clone());
#[cfg(target_os = "macos")]
{
@@ -528,7 +526,7 @@ pub fn run() {
/// Handle application reopen events (macOS)
#[cfg(target_os = "macos")]
pub fn handle_reopen(app_handle: Arc<AppHandle>, has_visible_windows: bool) {
pub fn handle_reopen(app_handle: &AppHandle, has_visible_windows: bool) {
logging!(
info,
Type::System,
@@ -537,7 +535,7 @@ pub fn run() {
has_visible_windows
);
AppHandleManager::global().init(Arc::clone(&app_handle));
AppHandleManager::global().init(app_handle.clone());
if !has_visible_windows {
// 当没有可见窗口时，设置为 regular 模式并显示主窗口
@@ -580,68 +578,73 @@ pub fn run() {
/// Handle window focus events
pub fn handle_window_focus(focused: bool) {
let is_enable_global_hotkey = Config::verge()
.latest_ref()
.enable_global_hotkey
.unwrap_or(true);
AsyncHandler::spawn(move || async move {
let is_enable_global_hotkey = Config::verge()
.await
.latest_ref()
.enable_global_hotkey
.unwrap_or(true);
if focused {
if focused {
#[cfg(target_os = "macos")]
{
use crate::core::hotkey::SystemHotkey;
if let Err(e) = hotkey::Hotkey::global()
.register_system_hotkey(SystemHotkey::CmdQ)
.await
{
logging!(error, Type::Hotkey, true, "Failed to register CMD+Q: {}", e);
}
if let Err(e) = hotkey::Hotkey::global()
.register_system_hotkey(SystemHotkey::CmdW)
.await
{
logging!(error, Type::Hotkey, true, "Failed to register CMD+W: {}", e);
}
}
if !is_enable_global_hotkey {
if let Err(e) = hotkey::Hotkey::global().init().await {
logging!(error, Type::Hotkey, true, "Failed to init hotkeys: {}", e);
}
}
return;
}
// Handle unfocused state
#[cfg(target_os = "macos")]
{
use crate::core::hotkey::SystemHotkey;
if let Err(e) =
hotkey::Hotkey::global().register_system_hotkey(SystemHotkey::CmdQ)
hotkey::Hotkey::global().unregister_system_hotkey(SystemHotkey::CmdQ)
{
logging!(error, Type::Hotkey, true, "Failed to register CMD+Q: {}", e);
logging!(
error,
Type::Hotkey,
true,
"Failed to unregister CMD+Q: {}",
e
);
}
if let Err(e) =
hotkey::Hotkey::global().register_system_hotkey(SystemHotkey::CmdW)
hotkey::Hotkey::global().unregister_system_hotkey(SystemHotkey::CmdW)
{
logging!(error, Type::Hotkey, true, "Failed to register CMD+W: {}", e);
logging!(
error,
Type::Hotkey,
true,
"Failed to unregister CMD+W: {}",
e
);
}
}
if !is_enable_global_hotkey {
if let Err(e) = hotkey::Hotkey::global().init() {
logging!(error, Type::Hotkey, true, "Failed to init hotkeys: {}", e);
if let Err(e) = hotkey::Hotkey::global().reset() {
logging!(error, Type::Hotkey, true, "Failed to reset hotkeys: {}", e);
}
}
return;
}
// Handle unfocused state
#[cfg(target_os = "macos")]
{
use crate::core::hotkey::SystemHotkey;
if let Err(e) =
hotkey::Hotkey::global().unregister_system_hotkey(SystemHotkey::CmdQ)
{
logging!(
error,
Type::Hotkey,
true,
"Failed to unregister CMD+Q: {}",
e
);
}
if let Err(e) =
hotkey::Hotkey::global().unregister_system_hotkey(SystemHotkey::CmdW)
{
logging!(
error,
Type::Hotkey,
true,
"Failed to unregister CMD+W: {}",
e
);
}
}
if !is_enable_global_hotkey {
if let Err(e) = hotkey::Hotkey::global().reset() {
logging!(error, Type::Hotkey, true, "Failed to reset hotkeys: {}", e);
}
}
});
}
/// Handle window destroyed events
@@ -690,10 +693,9 @@ pub fn run() {
});
app.run(|app_handle, e| {
let app_handle = Arc::new(app_handle.clone());
match e {
tauri::RunEvent::Ready | tauri::RunEvent::Resumed => {
event_handlers::handle_ready_resumed(Arc::clone(&app_handle));
event_handlers::handle_ready_resumed(app_handle);
}
#[cfg(target_os = "macos")]
tauri::RunEvent::Reopen {