refactor: remove unused UI notification functions and streamline initialization logic

src-tauri/src/cmd/app.rs

@@ -1,8 +1,6 @@
 use super::CmdResult;
-use crate::core::{autostart, handle};
+use crate::core::autostart;
-use crate::utils::resolve::ui::{self, UiReadyStage};
 use crate::{cmd::StringifyErr as _, feat, utils::dirs};
-use clash_verge_logging::{Type, logging};
 use smartstring::alias::String;
 use tauri::{AppHandle, Manager as _};
 
@@ -109,22 +107,3 @@ pub async fn download_icon_cache(url: String, name: String) -> CmdResult<String>
 pub async fn copy_icon_file(path: String, icon_info: feat::IconInfo) -> CmdResult<String> {
     feat::copy_icon_file(path, icon_info).await
 }
-
-/// 通知UI已准备就绪
-#[tauri::command]
-pub async fn notify_ui_ready() {
-    logging!(info, Type::Cmd, "前端UI已准备就绪");
-    ui::mark_ui_ready();
-
-    handle::Handle::refresh_clash();
-    let delayed_refresh_delay = std::time::Duration::from_millis(1500);
-    tokio::time::sleep(delayed_refresh_delay).await;
-    handle::Handle::refresh_clash();
-}
-
-/// UI加载阶段
-#[tauri::command]
-pub fn update_ui_stage(stage: UiReadyStage) {
-    logging!(info, Type::Cmd, "UI加载阶段更新: {:?}", &stage);
-    ui::update_ui_ready_stage(stage);
-}

src-tauri/src/lib.rs

@@ -149,8 +149,6 @@ mod app_init {
             cmd::start_core,
             cmd::stop_core,
             cmd::restart_core,
-            cmd::notify_ui_ready,
-            cmd::update_ui_stage,
             cmd::get_running_mode,
             cmd::get_auto_launch_status,
             cmd::entry_lightweight_mode,

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

@@ -6,6 +6,7 @@ use crate::{
     config::Config,
     core::{
         CoreManager, Timer,
+        handle::Handle,
         hotkey::Hotkey,
         logger::Logger,
         service::{SERVICE_MANAGER, ServiceManager, is_service_ipc_path_exists},
@@ -22,7 +23,6 @@ use clash_verge_signal;
 
 pub mod dns;
 pub mod scheme;
-pub mod ui;
 pub mod window;
 pub mod window_script;
 
@@ -77,6 +77,7 @@ pub fn resolve_setup_async() {
             init_silent_updater(),
         );
 
+        Handle::refresh_clash();
         refresh_tray_menu().await;
     });
 }

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

@@ -1,57 +0,0 @@
-use once_cell::sync::OnceCell;
-use serde::{Deserialize, Serialize};
-use std::sync::{
-    Arc,
-    atomic::{AtomicBool, AtomicU8, Ordering},
-};
-use tokio::sync::Notify;
-
-use clash_verge_logging::{Type, logging};
-
-// 获取 UI 是否准备就绪的全局状态
-static UI_READY: AtomicBool = AtomicBool::new(false);
-// 获取UI就绪状态细节
-static UI_READY_STATE: AtomicU8 = AtomicU8::new(0);
-// 添加通知机制，用于事件驱动的 UI 就绪检测
-static UI_READY_NOTIFY: OnceCell<Arc<Notify>> = OnceCell::new();
-
-// UI就绪阶段状态枚举
-#[repr(u8)]
-#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
-pub enum UiReadyStage {
-    NotStarted = 0,
-    Loading,
-    DomReady,
-    ResourcesLoaded,
-    Ready,
-}
-
-pub fn get_ui_ready() -> &'static AtomicBool {
-    &UI_READY
-}
-
-fn get_ui_ready_state() -> &'static AtomicU8 {
-    &UI_READY_STATE
-}
-
-fn get_ui_ready_notify() -> &'static Arc<Notify> {
-    UI_READY_NOTIFY.get_or_init(|| Arc::new(Notify::new()))
-}
-
-// 更新UI准备阶段
-pub fn update_ui_ready_stage(stage: UiReadyStage) {
-    get_ui_ready_state().store(stage as u8, Ordering::Release);
-    // 如果是最终阶段，标记UI完全就绪
-    if stage == UiReadyStage::Ready {
-        mark_ui_ready();
-    }
-}
-
-// 标记UI已准备就绪
-pub fn mark_ui_ready() {
-    get_ui_ready().store(true, Ordering::Release);
-    logging!(info, Type::Window, "UI已标记为完全就绪");
-
-    // 通知所有等待的任务
-    get_ui_ready_notify().notify_waiters();
-}

src/pages/_layout/hooks/use-app-initialization.ts

@@ -1,4 +1,3 @@
-import { invoke } from '@tauri-apps/api/core'
 import { useEffect, useRef } from 'react'
 
 import { hideInitialOverlay } from '../utils'
@@ -10,7 +9,6 @@ export const useAppInitialization = () => {
     if (initRef.current) return
     initRef.current = true
 
-    let isInitialized = false
     let isCancelled = false
     const timers = new Set<number>()
 
@@ -26,76 +24,17 @@ export const useAppInitialization = () => {
       return id
     }
 
-    const notifyBackend = async (stage?: string) => {
-      if (isCancelled) return
-
-      try {
-        if (stage) {
-          await invoke('update_ui_stage', { stage })
-        } else {
-          await invoke('notify_ui_ready')
-        }
-      } catch (err) {
-        console.error(`[Initialization] Failed to notify backend:`, err)
-      }
-    }
-
     const removeLoadingOverlay = () => {
       hideInitialOverlay({ schedule: scheduleTimeout })
     }
 
-    const performInitialization = async () => {
+    const performInitialization = () => {
-      if (isCancelled || isInitialized) return
-      isInitialized = true
-
-      try {
-        removeLoadingOverlay()
-        await notifyBackend('Loading')
-
-        await new Promise<void>((resolve) => {
-          const check = () => {
-            const root = document.getElementById('root')
-            if (root && root.children.length > 0) {
-              resolve()
-            } else {
-              scheduleTimeout(check, 50)
-            }
-          }
-          check()
-          scheduleTimeout(resolve, 2000)
-        })
-
-        await notifyBackend('DomReady')
-        await new Promise((resolve) => requestAnimationFrame(resolve))
-        await notifyBackend('ResourcesLoaded')
-        await notifyBackend()
-      } catch (error) {
-        if (!isCancelled) {
-          console.error('[Initialization] Failed:', error)
-          removeLoadingOverlay()
-          notifyBackend().catch(console.error)
-        }
-      }
-    }
-
-    const checkBackendReady = async () => {
-      try {
       if (isCancelled) return
-
-        await invoke('update_ui_stage', { stage: 'Loading' })
-        performInitialization()
-      } catch {
-        scheduleTimeout(performInitialization, 1500)
-      }
-    }
-
-    scheduleTimeout(checkBackendReady, 100)
-    scheduleTimeout(() => {
-      if (!isInitialized) {
       removeLoadingOverlay()
-        notifyBackend().catch(console.error)
     }
-    }, 5000)
+
+    scheduleTimeout(performInitialization, 100)
+    scheduleTimeout(performInitialization, 5000)
 
     return () => {
       isCancelled = true