fix: resolve macOS lightweight mode exit synchronization issues and improve logging levels #5241

UPDATELOG.md

@@ -33,6 +33,7 @@
 - 修复悬浮跳转导航失效
 - 修复小键盘热键映射错误
 - 修复前端无法及时刷新操作状态
+- 修复 macOS 从 Dock 栏退出轻量模式状态不同步
 
 <details>
 <summary><strong> ✨ 新增功能 </strong></summary>

src-tauri/src/core/timer.rs

@@ -155,7 +155,7 @@ impl Timer {
             .set_maximum_parallel_runnable_num(1)
             .set_frequency_count_down_by_seconds(3, 3)
             .spawn_async_routine(|| async move {
-                logging!(info, Type::Timer, "Updating tray menu");
+                logging!(debug, Type::Timer, "Updating tray menu");
                 crate::core::tray::Tray::global()
                     .update_tray_display()
                     .await

src-tauri/src/lib.rs

@@ -10,6 +10,8 @@ mod feat;
 mod module;
 mod process;
 pub mod utils;
+#[cfg(target_os = "macos")]
+use crate::module::lightweight;
 #[cfg(target_os = "linux")]
 use crate::utils::linux;
 #[cfg(target_os = "macos")]
@@ -287,6 +289,11 @@ pub fn run() {
         pub async fn handle_reopen(has_visible_windows: bool) {
             handle::Handle::global().init();
 
+            if lightweight::is_in_lightweight_mode() {
+                lightweight::exit_lightweight_mode().await;
+                return;
+            }
+
             if !has_visible_windows {
                 handle::Handle::global().set_activation_policy_regular();
                 let _ = WindowManager::show_main_window().await;

src-tauri/src/module/lightweight.rs

@@ -1,6 +1,6 @@
 use crate::{
     config::Config,
-    core::{handle, timer::Timer, tray::Tray},
+    core::{handle, timer::Timer},
     log_err, logging,
     process::AsyncHandler,
     utils::logging::Type,
@@ -43,49 +43,42 @@ impl LightweightState {
 
 static LIGHTWEIGHT_STATE: AtomicU8 = AtomicU8::new(LightweightState::Normal as u8);
 
-static WINDOW_CLOSE_HANDLER: AtomicU32 = AtomicU32::new(0);
+static WINDOW_CLOSE_HANDLER_ID: AtomicU32 = AtomicU32::new(0);
-static WEBVIEW_FOCUS_HANDLER: AtomicU32 = AtomicU32::new(0);
+static WEBVIEW_FOCUS_HANDLER_ID: AtomicU32 = AtomicU32::new(0);
-
-fn set_state(new: LightweightState) {
-    LIGHTWEIGHT_STATE.store(new.as_u8(), Ordering::Release);
-    match new {
-        LightweightState::Normal => {
-            logging!(info, Type::Lightweight, "轻量模式已关闭");
-        }
-        LightweightState::In => {
-            logging!(info, Type::Lightweight, "轻量模式已开启");
-        }
-        LightweightState::Exiting => {
-            logging!(info, Type::Lightweight, "正在退出轻量模式");
-        }
-    }
-}
 
+#[inline]
 fn get_state() -> LightweightState {
     LIGHTWEIGHT_STATE.load(Ordering::Acquire).into()
 }
 
-// 检查是否处于轻量模式
+#[inline]
+fn try_transition(from: LightweightState, to: LightweightState) -> bool {
+    LIGHTWEIGHT_STATE
+        .compare_exchange(
+            from.as_u8(),
+            to.as_u8(),
+            Ordering::AcqRel,
+            Ordering::Relaxed,
+        )
+        .is_ok()
+}
+
+#[inline]
+fn record_state_and_log(state: LightweightState) {
+    LIGHTWEIGHT_STATE.store(state.as_u8(), Ordering::Release);
+    match state {
+        LightweightState::Normal => logging!(info, Type::Lightweight, "轻量模式已关闭"),
+        LightweightState::In => logging!(info, Type::Lightweight, "轻量模式已开启"),
+        LightweightState::Exiting => logging!(info, Type::Lightweight, "正在退出轻量模式"),
+    }
+}
+
+#[inline]
 pub fn is_in_lightweight_mode() -> bool {
     get_state() == LightweightState::In
 }
 
-// 设置轻量模式状态（仅 Normal <-> In）
+pub async fn auto_lightweight_boot() -> Result<()> {
-async fn set_lightweight_mode(value: bool) {
-    let current = get_state();
-    if value && current != LightweightState::In {
-        set_state(LightweightState::In);
-    } else if !value && current != LightweightState::Normal {
-        set_state(LightweightState::Normal);
-    }
-
-    // 只有在状态可用时才触发托盘更新
-    if let Err(e) = Tray::global().update_part().await {
-        log::warn!("Failed to update tray: {e}");
-    }
-}
-
-pub async fn run_once_auto_lightweight() {
     let verge_config = Config::verge().await;
     let enable_auto = verge_config
         .data_mut()
@@ -96,39 +89,23 @@ pub async fn run_once_auto_lightweight() {
         .enable_silent_start
         .unwrap_or(false);
 
-    if !(enable_auto && is_silent_start) {
+    if is_silent_start {
-        logging!(
+        logging!(info, Type::Lightweight, "静默启动：直接进入轻量模式");
-            info,
+        let _ = entry_lightweight_mode().await;
-            Type::Lightweight,
+        return Ok(());
-            "不满足静默启动且自动进入轻量模式的条件，跳过自动进入轻量模式"
-        );
-        return;
     }
 
-    set_lightweight_mode(true).await;
+    if !enable_auto {
+        logging!(info, Type::Lightweight, "未开启自动轻量模式，跳过初始化");
+        return Ok(());
+    }
+
+    logging!(
+        info,
+        Type::Lightweight,
+        "非静默启动：注册自动轻量模式监听器"
+    );
     enable_auto_light_weight_mode().await;
-}
-
-pub async fn auto_lightweight_mode_init() -> Result<()> {
-    let is_silent_start =
-        { Config::verge().await.latest_ref().enable_silent_start }.unwrap_or(false);
-    let enable_auto = {
-        Config::verge()
-            .await
-            .latest_ref()
-            .enable_auto_light_weight_mode
-    }
-    .unwrap_or(false);
-
-    if enable_auto && !is_silent_start {
-        logging!(
-            info,
-            Type::Lightweight,
-            "非静默启动直接挂载自动进入轻量模式监听器！"
-        );
-        set_state(LightweightState::Normal);
-        enable_auto_light_weight_mode().await;
-    }
 
     Ok(())
 }
@@ -151,43 +128,18 @@ pub fn disable_auto_light_weight_mode() {
 }
 
 pub async fn entry_lightweight_mode() -> bool {
-    // 尝试从 Normal -> In
+    if !try_transition(LightweightState::Normal, LightweightState::In) {
-    if LIGHTWEIGHT_STATE
-        .compare_exchange(
-            LightweightState::Normal as u8,
-            LightweightState::In as u8,
-            Ordering::Acquire,
-            Ordering::Relaxed,
-        )
-        .is_err()
-    {
         logging!(info, Type::Lightweight, "无需进入轻量模式，跳过调用");
         return false;
     }
-
+    record_state_and_log(LightweightState::In);
     WindowManager::destroy_main_window();
-
-    set_lightweight_mode(true).await;
     let _ = cancel_light_weight_timer();
-
-    // 回到 In
-    set_state(LightweightState::In);
-
     true
 }
 
-// 添加从轻量模式恢复的函数
 pub async fn exit_lightweight_mode() -> bool {
-    // 尝试从 In -> Exiting
+    if !try_transition(LightweightState::In, LightweightState::Exiting) {
-    if LIGHTWEIGHT_STATE
-        .compare_exchange(
-            LightweightState::In as u8,
-            LightweightState::Exiting as u8,
-            Ordering::Acquire,
-            Ordering::Relaxed,
-        )
-        .is_err()
-    {
         logging!(
             info,
             Type::Lightweight,
@@ -195,16 +147,10 @@ pub async fn exit_lightweight_mode() -> bool {
         );
         return false;
     }
-
+    record_state_and_log(LightweightState::Exiting);
     WindowManager::show_main_window().await;
-
-    set_lightweight_mode(false).await;
     let _ = cancel_light_weight_timer();
-
+    record_state_and_log(LightweightState::Normal);
-    // 回到 Normal
-    set_state(LightweightState::Normal);
-
-    logging!(info, Type::Lightweight, "轻量模式退出完成");
     true
 }
 
@@ -215,7 +161,11 @@ pub async fn add_light_weight_timer() {
 
 fn setup_window_close_listener() {
     if let Some(window) = handle::Handle::get_window() {
-        let handler = window.listen("tauri://close-requested", move |_event| {
+        let old_id = WINDOW_CLOSE_HANDLER_ID.swap(0, Ordering::AcqRel);
+        if old_id != 0 {
+            window.unlisten(old_id);
+        }
+        let handler_id = window.listen("tauri://close-requested", move |_event| {
             std::mem::drop(AsyncHandler::spawn(|| async {
                 if let Err(e) = setup_light_weight_timer().await {
                     log::warn!("Failed to setup light weight timer: {e}");
@@ -223,16 +173,15 @@ fn setup_window_close_listener() {
             }));
             logging!(info, Type::Lightweight, "监听到关闭请求，开始轻量模式计时");
         });
-
+        WINDOW_CLOSE_HANDLER_ID.store(handler_id, Ordering::Release);
-        WINDOW_CLOSE_HANDLER.store(handler, Ordering::Release);
     }
 }
 
 fn cancel_window_close_listener() {
     if let Some(window) = handle::Handle::get_window() {
-        let handler = WINDOW_CLOSE_HANDLER.swap(0, Ordering::AcqRel);
+        let id = WINDOW_CLOSE_HANDLER_ID.swap(0, Ordering::AcqRel);
-        if handler != 0 {
+        if id != 0 {
-            window.unlisten(handler);
+            window.unlisten(id);
             logging!(info, Type::Lightweight, "取消了窗口关闭监听");
         }
     }
@@ -240,7 +189,11 @@ fn cancel_window_close_listener() {
 
 fn setup_webview_focus_listener() {
     if let Some(window) = handle::Handle::get_window() {
-        let handler = window.listen("tauri://focus", move |_event| {
+        let old_id = WEBVIEW_FOCUS_HANDLER_ID.swap(0, Ordering::AcqRel);
+        if old_id != 0 {
+            window.unlisten(old_id);
+        }
+        let handler_id = window.listen("tauri://focus", move |_event| {
             log_err!(cancel_light_weight_timer());
             logging!(
                 info,
@@ -248,37 +201,45 @@ fn setup_webview_focus_listener() {
                 "监听到窗口获得焦点，取消轻量模式计时"
             );
         });
-
+        WEBVIEW_FOCUS_HANDLER_ID.store(handler_id, Ordering::Release);
-        WEBVIEW_FOCUS_HANDLER.store(handler, Ordering::Release);
     }
 }
 
 fn cancel_webview_focus_listener() {
     if let Some(window) = handle::Handle::get_window() {
-        let handler = WEBVIEW_FOCUS_HANDLER.swap(0, Ordering::AcqRel);
+        let id = WEBVIEW_FOCUS_HANDLER_ID.swap(0, Ordering::AcqRel);
-        if handler != 0 {
+        if id != 0 {
-            window.unlisten(handler);
+            window.unlisten(id);
             logging!(info, Type::Lightweight, "取消了窗口焦点监听");
         }
     }
 }
 
 async fn setup_light_weight_timer() -> Result<()> {
-    Timer::global().init().await?;
+    if let Err(e) = Timer::global().init().await {
+        return Err(e).context("failed to initialize timer");
+    }
+
     let once_by_minutes = Config::verge()
         .await
         .latest_ref()
         .auto_light_weight_minutes
         .unwrap_or(10);
 
-    // 获取task_id
+    {
+        let timer_map = Timer::global().timer_map.read();
+        if timer_map.contains_key(LIGHT_WEIGHT_TASK_UID) {
+            logging!(warn, Type::Timer, "轻量模式计时器已存在，跳过创建");
+            return Ok(());
+        }
+    }
+
     let task_id = {
         Timer::global()
             .timer_count
             .fetch_add(1, std::sync::atomic::Ordering::Relaxed)
     };
 
-    // 创建任务
     let task = TaskBuilder::default()
         .set_task_id(task_id)
         .set_maximum_parallel_runnable_num(1)
@@ -289,7 +250,6 @@ async fn setup_light_weight_timer() -> Result<()> {
         })
         .context("failed to create timer task")?;
 
-    // 添加任务到定时器
     {
         let delay_timer = Timer::global().delay_timer.write();
         delay_timer
@@ -297,7 +257,6 @@ async fn setup_light_weight_timer() -> Result<()> {
             .context("failed to add timer task")?;
     }
 
-    // 更新任务映射
     {
         let mut timer_map = Timer::global().timer_map.write();
         let timer_task = crate::core::timer::TimerTask {

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

@@ -11,10 +11,7 @@ use crate::{
         tray::Tray,
     },
     logging, logging_error,
-    module::{
+    module::{lightweight::auto_lightweight_boot, signal},
-        lightweight::{auto_lightweight_mode_init, run_once_auto_lightweight},
-        signal,
-    },
     process::AsyncHandler,
     utils::{init, logging::Type, server, window_manager::WindowManager},
 };
@@ -71,8 +68,7 @@ pub fn resolve_setup_async() {
             tray_init,
             init_timer(),
             init_hotkey(),
-            init_auto_lightweight_mode(),
+            init_auto_lightweight_boot(),
-            init_once_auto_lightweight(),
         );
     });
 }
@@ -128,12 +124,8 @@ pub(super) async fn init_hotkey() {
     logging_error!(Type::Setup, Hotkey::global().init().await);
 }
 
-pub(super) async fn init_once_auto_lightweight() {
+pub(super) async fn init_auto_lightweight_boot() {
-    run_once_auto_lightweight().await;
+    logging_error!(Type::Setup, auto_lightweight_boot().await);
-}
-
-pub(super) async fn init_auto_lightweight_mode() {
-    logging_error!(Type::Setup, auto_lightweight_mode_init().await);
 }
 
 pub(super) fn init_signal() {

src-tauri/src/utils/window_manager.rs

@@ -359,7 +359,6 @@ impl WindowManager {
             }
             return WindowOperationResult::Destroyed;
         }
-        logging!(warn, Type::Window, "窗口摧毁失败");
         WindowOperationResult::Failed
     }