chore: update

src-tauri/src/core/core.rs

@@ -2,19 +2,22 @@ use crate::config::*;
 use crate::core::{clash_api, handle, logger::Logger, service};
 use crate::log_err;
 use crate::utils::dirs;
-use anyhow::{bail, Result};
+use anyhow::{bail, Context, Result};
 use once_cell::sync::OnceCell;
 use parking_lot::Mutex;
 use serde_yaml::Mapping;
-use std::{sync::Arc, time::Duration};
+use std::{fs, io::Write, sync::Arc, time::Duration};
 use sysinfo::{ProcessRefreshKind, RefreshKind, System};
-use tauri::api::process::{Command, CommandChild, CommandEvent};
+use tauri::AppHandle;
+use tauri_plugin_shell::process::{CommandChild, CommandEvent};
+use tauri_plugin_shell::ShellExt;
+
 use tokio::time::sleep;
 
 #[derive(Debug)]
 pub struct CoreManager {
+    app_handle: Arc<Mutex<Option<AppHandle>>>,
     sidecar: Arc<Mutex<Option<CommandChild>>>,
-
     #[allow(unused)]
     use_service_mode: Arc<Mutex<bool>>,
 }
@@ -24,12 +27,14 @@ impl CoreManager {
         static CORE_MANAGER: OnceCell<CoreManager> = OnceCell::new();
 
         CORE_MANAGER.get_or_init(|| CoreManager {
+            app_handle: Arc::new(Mutex::new(None)),
             sidecar: Arc::new(Mutex::new(None)),
             use_service_mode: Arc::new(Mutex::new(false)),
         })
     }
 
-    pub fn init(&self) -> Result<()> {
+    pub fn init(&self, app_handle: &AppHandle) -> Result<()> {
+        *self.app_handle.lock() = Some(app_handle.clone());
         tauri::async_runtime::spawn(async {
             // 启动clash
             log_err!(Self::global().run_core().await);
@@ -39,7 +44,7 @@ impl CoreManager {
     }
 
     /// 检查订阅是否正确
-    pub fn check_config(&self) -> Result<()> {
+    pub async fn check_config(&self) -> Result<()> {
         let config_path = Config::generate_file(ConfigType::Check)?;
         let config_path = dirs::path_to_str(&config_path)?;
 
@@ -62,19 +67,29 @@ impl CoreManager {
 
         let test_dir = dirs::app_home_dir()?.join("test");
         let test_dir = dirs::path_to_str(&test_dir)?;
+        let app_handle_option = {
+            let lock = self.app_handle.lock();
+            lock.as_ref().cloned() 
+        };
+    
+        if let Some(app_handle) = app_handle_option {
+            let output = app_handle
+                .shell()
+                .sidecar(clash_core)?
+                .args(["-t", "-d", test_dir, "-f", config_path])
+                .output()
+                .await?;
 
-        let output = Command::new_sidecar(clash_core)?
-            .args(["-t", "-d", test_dir, "-f", config_path])
-            .output()?;
-
-        if !output.status.success() {
-            let error = clash_api::parse_check_output(output.stdout.clone());
-            let error = match !error.is_empty() {
-                true => error,
-                false => output.stdout.clone(),
-            };
-            Logger::global().set_log(output.stdout);
-            bail!("{error}");
+            if !output.status.success() {
+                let stdout = String::from_utf8(output.stdout).unwrap_or_default();
+                let error = clash_api::parse_check_output(stdout.clone());
+                let error = match !error.is_empty() {
+                    true => error,
+                    false => stdout.clone(),
+                };
+                Logger::global().set_log(stdout.clone());
+                bail!("{error}");
+            }
         }
 
         Ok(())
@@ -156,37 +171,54 @@ impl CoreManager {
 
         let args = vec!["-d", app_dir, "-f", config_path];
 
-        let cmd = Command::new_sidecar(clash_core)?;
-        let (mut rx, cmd_child) = cmd.args(args).spawn()?;
+        let app_handle = self.app_handle.lock();
 
-        let mut sidecar = self.sidecar.lock();
-        *sidecar = Some(cmd_child);
-        drop(sidecar);
+        if let Some(app_handle) = app_handle.as_ref() {
+            let cmd = app_handle.shell().sidecar(clash_core)?;
+            let (mut rx, cmd_child) = cmd.args(args).spawn()?;
 
-        tauri::async_runtime::spawn(async move {
-            while let Some(event) = rx.recv().await {
-                match event {
-                    CommandEvent::Stdout(line) => {
-                        log::info!(target: "app", "[mihomo]: {line}");
-                        Logger::global().set_log(line);
+            // 将pid写入文件中
+            crate::log_err!((|| {
+                let pid = cmd_child.pid();
+                let path = dirs::clash_pid_path()?;
+                fs::File::create(path)
+                    .context("failed to create the pid file")?
+                    .write(format!("{pid}").as_bytes())
+                    .context("failed to write pid to the file")?;
+                <Result<()>>::Ok(())
+            })());
+
+            let mut sidecar = self.sidecar.lock();
+            *sidecar = Some(cmd_child);
+            drop(sidecar);
+
+            tauri::async_runtime::spawn(async move {
+                while let Some(event) = rx.recv().await {
+                    match event {
+                        CommandEvent::Stdout(line) => {
+                            let line = String::from_utf8(line).unwrap_or_default();
+                            log::info!(target: "app", "[mihomo]: {line}");
+                            Logger::global().set_log(line);
+                        }
+                        CommandEvent::Stderr(err) => {
+                            let err = String::from_utf8(err).unwrap_or_default();
+                            log::error!(target: "app", "[mihomo]: {err}");
+                            Logger::global().set_log(err);
+                        }
+                        CommandEvent::Error(err) => {
+                            log::error!(target: "app", "[mihomo]: {err}");
+                            Logger::global().set_log(err);
+                        }
+                        CommandEvent::Terminated(_) => {
+                            log::info!(target: "app", "mihomo core terminated");
+                            let _ = CoreManager::global().recover_core();
+                            break;
+                        }
+                        _ => {}
                     }
-                    CommandEvent::Stderr(err) => {
-                        log::error!(target: "app", "[mihomo]: {err}");
-                        Logger::global().set_log(err);
-                    }
-                    CommandEvent::Error(err) => {
-                        log::error!(target: "app", "[mihomo]: {err}");
-                        Logger::global().set_log(err);
-                    }
-                    CommandEvent::Terminated(_) => {
-                        log::info!(target: "app", "mihomo core terminated");
-                        let _ = CoreManager::global().recover_core();
-                        break;
-                    }
-                    _ => {}
                 }
-            }
-        });
+            });
+        }
 
         Ok(())
     }
@@ -268,7 +300,7 @@ impl CoreManager {
         // 更新订阅
         Config::generate().await?;
 
-        self.check_config()?;
+        self.check_config().await?;
 
         // 清掉旧日志
         Logger::global().clear_log();
@@ -296,7 +328,7 @@ impl CoreManager {
         Config::generate().await?;
 
         // 检查订阅是否正常
-        self.check_config()?;
+        self.check_config().await?;
 
         // 更新运行时订阅
         let path = Config::generate_file(ConfigType::Run)?;

src-tauri/src/core/handle.rs

@@ -4,7 +4,7 @@ use anyhow::{bail, Result};
 use once_cell::sync::OnceCell;
 use parking_lot::Mutex;
 use std::sync::Arc;
-use tauri::{AppHandle, Manager, Window};
+use tauri::{AppHandle, WebviewWindow, Manager, Emitter};
 
 #[derive(Debug, Default, Clone)]
 pub struct Handle {
@@ -20,15 +20,15 @@ impl Handle {
         })
     }
 
-    pub fn init(&self, app_handle: AppHandle) {
-        *self.app_handle.lock() = Some(app_handle);
+    pub fn init(&self, app_handle: &AppHandle) {
+        *self.app_handle.lock() = Some(app_handle.clone());
     }
 
-    pub fn get_window(&self) -> Option<Window> {
+    pub fn get_window(&self) -> Option<WebviewWindow> {
         self.app_handle
             .lock()
             .as_ref()
-            .and_then(|a| a.get_window("main"))
+            .and_then(|a| a.get_webview_window("main"))
     }
 
     pub fn refresh_clash() {

src-tauri/src/core/hotkey.rs

@@ -3,11 +3,11 @@ use anyhow::{bail, Result};
 use once_cell::sync::OnceCell;
 use parking_lot::Mutex;
 use std::{collections::HashMap, sync::Arc};
-use tauri::{AppHandle, GlobalShortcutManager};
+use tauri::AppHandle;
+use tauri_plugin_global_shortcut::GlobalShortcutExt;
 
 pub struct Hotkey {
     current: Arc<Mutex<Vec<String>>>, // 保存当前的热键设置
-
     app_handle: Arc<Mutex<Option<AppHandle>>>,
 }
 
@@ -21,9 +21,8 @@ impl Hotkey {
         })
     }
 
-    pub fn init(&self, app_handle: AppHandle) -> Result<()> {
-        *self.app_handle.lock() = Some(app_handle);
-
+    pub fn init(&self, app_handle: &AppHandle) -> Result<()> {
+        *self.app_handle.lock() = Some(app_handle.clone());
         let verge = Config::verge();
 
         if let Some(hotkeys) = verge.latest().hotkeys.as_ref() {
@@ -49,18 +48,14 @@ impl Hotkey {
         Ok(())
     }
 
-    fn get_manager(&self) -> Result<impl GlobalShortcutManager> {
+    fn register(&self, hotkey: &str, func: &str) -> Result<()> {
         let app_handle = self.app_handle.lock();
         if app_handle.is_none() {
             bail!("failed to get the hotkey manager");
         }
-        Ok(app_handle.as_ref().unwrap().global_shortcut_manager())
-    }
+        let manager = app_handle.as_ref().unwrap().global_shortcut();
 
-    fn register(&self, hotkey: &str, func: &str) -> Result<()> {
-        let mut manager = self.get_manager()?;
-
-        if manager.is_registered(hotkey)? {
+        if manager.is_registered(hotkey) {
             manager.unregister(hotkey)?;
         }
 
@@ -71,17 +66,22 @@ impl Hotkey {
             "clash_mode_direct" => || feat::change_clash_mode("direct".into()),
             "toggle_system_proxy" => feat::toggle_system_proxy,
             "toggle_tun_mode" => feat::toggle_tun_mode,
-
             _ => bail!("invalid function \"{func}\""),
         };
 
-        manager.register(hotkey, f)?;
+        let _ = manager.on_shortcut(hotkey, move |_, _, _| f());
         log::info!(target: "app", "register hotkey {hotkey} {func}");
         Ok(())
     }
 
     fn unregister(&self, hotkey: &str) -> Result<()> {
-        self.get_manager()?.unregister(hotkey)?;
+        let app_handle = self.app_handle.lock();
+        if app_handle.is_none() {
+            bail!("failed to get the hotkey manager");
+        }
+        let manager = app_handle.as_ref().unwrap().global_shortcut();
+        manager.unregister(hotkey)?;
+
         log::info!(target: "app", "unregister hotkey {hotkey}");
         Ok(())
     }
@@ -153,8 +153,10 @@ impl Hotkey {
 
 impl Drop for Hotkey {
     fn drop(&mut self) {
-        if let Ok(mut manager) = self.get_manager() {
-            let _ = manager.unregister_all();
+        if let Some(app_handle) = self.app_handle.lock().as_ref() {
+            if let Err(e) = app_handle.global_shortcut().unregister_all() {
+                log::error!("Error unregistering all hotkeys: {:?}", e);
+            }
         }
     }
 }

src-tauri/src/core/tray.rs

@@ -5,19 +5,14 @@ use crate::{
     utils::{dirs, resolve},
 };
 use anyhow::Result;
-use tauri::{
-    api, AppHandle, CustomMenuItem, Manager, SystemTrayEvent, SystemTrayMenu, SystemTrayMenuItem,
-    SystemTraySubmenu,
-};
-
+use tauri::menu::{MenuBuilder, MenuEvent, MenuItemBuilder, PredefinedMenuItem, SubmenuBuilder};
+use tauri::tray::{MouseButton, MouseButtonState, TrayIcon, TrayIconBuilder, TrayIconEvent};
+use tauri::{AppHandle, Manager};
 pub struct Tray {}
 
 impl Tray {
-    pub fn tray_menu(app_handle: &AppHandle) -> SystemTrayMenu {
+    pub fn update_systray(app_handle: &AppHandle) -> Result<()> {
         let zh = { Config::verge().latest().language == Some("zh".into()) };
-
-        let version = app_handle.package_info().version.to_string();
-
         macro_rules! t {
             ($en: expr, $zh: expr) => {
                 if zh {
@@ -28,80 +23,92 @@ impl Tray {
             };
         }
 
-        SystemTrayMenu::new()
-            .add_item(CustomMenuItem::new(
-                "open_window",
-                t!("Dashboard", "打开面板"),
-            ))
-            .add_native_item(SystemTrayMenuItem::Separator)
-            .add_item(CustomMenuItem::new(
-                "rule_mode",
-                t!("Rule Mode", "规则模式"),
-            ))
-            .add_item(CustomMenuItem::new(
-                "global_mode",
-                t!("Global Mode", "全局模式"),
-            ))
-            .add_item(CustomMenuItem::new(
-                "direct_mode",
-                t!("Direct Mode", "直连模式"),
-            ))
-            .add_native_item(SystemTrayMenuItem::Separator)
-            .add_item(CustomMenuItem::new(
-                "system_proxy",
-                t!("System Proxy", "系统代理"),
-            ))
-            .add_item(CustomMenuItem::new("tun_mode", t!("TUN Mode", "Tun 模式")))
-            .add_item(CustomMenuItem::new(
-                "copy_env",
-                t!("Copy Env", "复制环境变量"),
-            ))
-            .add_submenu(SystemTraySubmenu::new(
-                t!("Open Dir", "打开目录"),
-                SystemTrayMenu::new()
-                    .add_item(CustomMenuItem::new(
-                        "open_app_dir",
-                        t!("App Dir", "应用目录"),
-                    ))
-                    .add_item(CustomMenuItem::new(
-                        "open_core_dir",
-                        t!("Core Dir", "内核目录"),
-                    ))
-                    .add_item(CustomMenuItem::new(
-                        "open_logs_dir",
-                        t!("Logs Dir", "日志目录"),
-                    )),
-            ))
-            .add_submenu(SystemTraySubmenu::new(
-                t!("More", "更多"),
-                SystemTrayMenu::new()
-                    .add_item(CustomMenuItem::new(
-                        "restart_clash",
-                        t!("Restart Clash", "重启 Clash"),
-                    ))
-                    .add_item(CustomMenuItem::new(
-                        "restart_app",
-                        t!("Restart App", "重启应用"),
-                    ))
-                    .add_item(
-                        CustomMenuItem::new("app_version", format!("Version {version}")).disabled(),
-                    ),
-            ))
-            .add_native_item(SystemTrayMenuItem::Separator)
-            .add_item(CustomMenuItem::new("quit", t!("Quit", "退出")))
-    }
+        let version = app_handle.package_info().version.to_string();
+
+        let open_window = MenuItemBuilder::with_id("open_window", t!("Dashboard", "打开面板"))
+            .build(app_handle)?;
+        let rule_mode =
+            MenuItemBuilder::with_id("rule_mode", t!("Rule Mode", "规则模式")).build(app_handle)?;
+        let global_mode = MenuItemBuilder::with_id("global_mode", t!("Global Mode", "全局模式"))
+            .build(app_handle)?;
+        let direct_mode = MenuItemBuilder::with_id("direct_mode", t!("Direct Mode", "直连模式"))
+            .build(app_handle)?;
+        let system_proxy = MenuItemBuilder::with_id("system_proxy", t!("System Proxy", "系统代理"))
+            .build(app_handle)?;
+        let tun_mode =
+            MenuItemBuilder::with_id("tun_mode", t!("TUN Mode", "Tun 模式")).build(app_handle)?;
+        let copy_env = MenuItemBuilder::with_id("copy_env", t!("Copy Env", "复制环境变量"))
+            .build(app_handle)?;
+        let open_app_dir = MenuItemBuilder::with_id("open_app_dir", t!("App Dir", "应用目录"))
+            .build(app_handle)?;
+        let open_core_dir = MenuItemBuilder::with_id("open_core_dir", t!("Core Dir", "内核目录"))
+            .build(app_handle)?;
+        let open_logs_dir = MenuItemBuilder::with_id("open_logs_dir", t!("Logs Dir", "日志目录"))
+            .build(app_handle)?;
+        let open_dir = SubmenuBuilder::with_id(app_handle, "open_dir", t!("Open Dir", "打开目录"))
+            .items(&[&open_app_dir, &open_core_dir, &open_logs_dir])
+            .build()?;
+        let restart_clash =
+            MenuItemBuilder::with_id("restart_clash", t!("Restart Clash", "重启 Clash"))
+                .build(app_handle)?;
+        let restart_app = MenuItemBuilder::with_id("restart_app", t!("Restart App", "重启应用"))
+            .build(app_handle)?;
+        let app_version = MenuItemBuilder::with_id("app_version", format!("Version {version}"))
+            .build(app_handle)?;
+        let more = SubmenuBuilder::with_id(app_handle, "more", t!("More", "更多"))
+            .items(&[&restart_clash, &restart_app, &app_version])
+            .build()?;
+        let quit = MenuItemBuilder::with_id("quit", t!("Quit", "退出"))
+            .accelerator("CmdOrControl+Q")
+            .build(app_handle)?;
+        let separator = PredefinedMenuItem::separator(app_handle)?;
+        let menu = MenuBuilder::new(app_handle)
+            .items(&[
+                &open_window,
+                &separator,
+                &rule_mode,
+                &global_mode,
+                &direct_mode,
+                &separator,
+                &system_proxy,
+                &tun_mode,
+                &copy_env,
+                &open_dir,
+                &more,
+                &separator,
+                &quit,
+            ])
+            .build()?;
+
+        let _ = TrayIconBuilder::with_id("verge_tray")
+            .menu(&menu)
+            .on_menu_event(Self::on_menu_event)
+            .on_tray_icon_event(|tray, event| {
+                let tray_event = { Config::verge().latest().tray_event.clone() };
+                let tray_event: String = tray_event.unwrap_or("main_window".into());
+                if let TrayIconEvent::Click {
+                    button: MouseButton::Left,
+                    button_state: MouseButtonState::Up,
+                    ..
+                } = event
+                {
+                    let app = tray.app_handle();
+                    match tray_event.as_str() {
+                        "system_proxy" => feat::toggle_system_proxy(),
+                        "tun_mode" => feat::toggle_tun_mode(),
+                        "main_window" => resolve::create_window(app),
+                        _ => {}
+                    }
+                }
+            })
+            .build(app_handle);
 
-    pub fn update_systray(app_handle: &AppHandle) -> Result<()> {
-        app_handle
-            .tray_handle()
-            .set_menu(Tray::tray_menu(app_handle))?;
         Tray::update_part(app_handle)?;
         Ok(())
     }
 
     pub fn update_part(app_handle: &AppHandle) -> Result<()> {
         let zh = { Config::verge().latest().language == Some("zh".into()) };
-
         let version = app_handle.package_info().version.to_string();
 
         macro_rules! t {
@@ -124,225 +131,263 @@ impl Tray {
                 .to_owned()
         };
 
-        let tray = app_handle.tray_handle();
+        if let Some(menu) = app_handle.menu() {
+            if let Some(item) = menu.get("rule_mode") {
+                let item = item.as_check_menuitem().unwrap();
+                let _ = item.set_checked(mode == "rule");
+            }
+            if let Some(item) = menu.get("global_mode") {
+                let item = item.as_check_menuitem().unwrap();
+                let _ = item.set_checked(mode == "global");
+            }
+            if let Some(item) = menu.get("direct_mode") {
+                let item = item.as_check_menuitem().unwrap();
+                let _ = item.set_checked(mode == "direct");
+            }
 
-        let _ = tray.get_item("rule_mode").set_selected(mode == "rule");
-        let _ = tray.get_item("global_mode").set_selected(mode == "global");
-        let _ = tray.get_item("direct_mode").set_selected(mode == "direct");
+            #[cfg(target_os = "linux")]
+            match mode.as_str() {
+                "rule" => {
+                    if let Some(item) = menu.get("rule_mode") {
+                        let _ = item
+                            .as_menuitem()
+                            .unwrap()
+                            .set_text(t!("Rule Mode  ✔", "规则模式  ✔"));
+                    }
 
-        #[cfg(target_os = "linux")]
-        match mode.as_str() {
-            "rule" => {
-                let _ = tray
-                    .get_item("rule_mode")
-                    .set_title(t!("Rule Mode  ✔", "规则模式  ✔"));
-                let _ = tray
-                    .get_item("global_mode")
-                    .set_title(t!("Global Mode", "全局模式"));
-                let _ = tray
-                    .get_item("direct_mode")
-                    .set_title(t!("Direct Mode", "直连模式"));
-            }
-            "global" => {
-                let _ = tray
-                    .get_item("rule_mode")
-                    .set_title(t!("Rule Mode", "规则模式"));
-                let _ = tray
-                    .get_item("global_mode")
-                    .set_title(t!("Global Mode  ✔", "全局模式  ✔"));
-                let _ = tray
-                    .get_item("direct_mode")
-                    .set_title(t!("Direct Mode", "直连模式"));
-            }
-            "direct" => {
-                let _ = tray
-                    .get_item("rule_mode")
-                    .set_title(t!("Rule Mode", "规则模式"));
-                let _ = tray
-                    .get_item("global_mode")
-                    .set_title(t!("Global Mode", "全局模式"));
-                let _ = tray
-                    .get_item("direct_mode")
-                    .set_title(t!("Direct Mode  ✔", "直连模式  ✔"));
-            }
-            _ => {}
-        }
+                    if let Some(item) = menu.get("global_mode") {
+                        let _ = item
+                            .as_menuitem()
+                            .unwrap()
+                            .set_text(t!("Global Mode", "全局模式"));
+                    }
 
-        let verge = Config::verge();
-        let verge = verge.latest();
-        let system_proxy = verge.enable_system_proxy.as_ref().unwrap_or(&false);
-        let tun_mode = verge.enable_tun_mode.as_ref().unwrap_or(&false);
-        #[cfg(target_os = "macos")]
-        let tray_icon = verge.tray_icon.clone().unwrap_or("monochrome".to_string());
-        let common_tray_icon = verge.common_tray_icon.as_ref().unwrap_or(&false);
-        let sysproxy_tray_icon = verge.sysproxy_tray_icon.as_ref().unwrap_or(&false);
-        let tun_tray_icon = verge.tun_tray_icon.as_ref().unwrap_or(&false);
-        #[cfg(target_os = "macos")]
-        match tray_icon.as_str() {
-            "monochrome" => {
-                let _ = tray.set_icon_as_template(true);
-            }
-            "colorful" => {
-                let _ = tray.set_icon_as_template(false);
-            }
-            _ => {}
-        }
-        let mut indication_icon = if *system_proxy {
-            #[cfg(target_os = "macos")]
-            let mut icon = match tray_icon.as_str() {
-                "monochrome" => include_bytes!("../../icons/tray-icon-sys-mono.ico").to_vec(),
-                "colorful" => include_bytes!("../../icons/tray-icon-sys.ico").to_vec(),
-                _ => include_bytes!("../../icons/tray-icon-sys-mono.ico").to_vec(),
-            };
-            #[cfg(not(target_os = "macos"))]
-            let mut icon = include_bytes!("../../icons/tray-icon-sys.ico").to_vec();
-
-            if *sysproxy_tray_icon {
-                let icon_dir_path = dirs::app_home_dir()?.join("icons");
-                let png_path = icon_dir_path.join("sysproxy.png");
-                let ico_path = icon_dir_path.join("sysproxy.ico");
-                if ico_path.exists() {
-                    icon = std::fs::read(ico_path).unwrap();
-                } else if png_path.exists() {
-                    icon = std::fs::read(png_path).unwrap();
+                    if let Some(item) = menu.get("direct_mode") {
+                        let _ = item
+                            .as_menuitem()
+                            .unwrap()
+                            .set_text(t!("Direct Mode", "直连模式"));
+                    }
                 }
-            }
-            icon
-        } else {
-            #[cfg(target_os = "macos")]
-            let mut icon = match tray_icon.as_str() {
-                "monochrome" => include_bytes!("../../icons/tray-icon-mono.ico").to_vec(),
-                "colorful" => include_bytes!("../../icons/tray-icon.ico").to_vec(),
-                _ => include_bytes!("../../icons/tray-icon-mono.ico").to_vec(),
-            };
-            #[cfg(not(target_os = "macos"))]
-            let mut icon = include_bytes!("../../icons/tray-icon.ico").to_vec();
-            if *common_tray_icon {
-                let icon_dir_path = dirs::app_home_dir()?.join("icons");
-                let png_path = icon_dir_path.join("common.png");
-                let ico_path = icon_dir_path.join("common.ico");
-                if ico_path.exists() {
-                    icon = std::fs::read(ico_path).unwrap();
-                } else if png_path.exists() {
-                    icon = std::fs::read(png_path).unwrap();
+                "global" => {
+                    if let Some(item) = menu.get("rule_mode") {
+                        let _ = item
+                            .as_menuitem()
+                            .unwrap()
+                            .set_text(t!("Rule Mode", "规则模式"));
+                    }
+
+                    if let Some(item) = menu.get("global_mode") {
+                        let _ = item
+                            .as_menuitem()
+                            .unwrap()
+                            .set_text(t!("Global Mode  ✔", "全局模式  ✔"));
+                    }
+
+                    if let Some(item) = menu.get("direct_mode") {
+                        let _ = item
+                            .as_menuitem()
+                            .unwrap()
+                            .set_text(t!("Direct Mode", "直连模式"));
+                    }
                 }
-            }
-            icon
-        };
-
-        if *tun_mode {
-            #[cfg(target_os = "macos")]
-            let mut icon = match tray_icon.as_str() {
-                "monochrome" => include_bytes!("../../icons/tray-icon-tun-mono.ico").to_vec(),
-                "colorful" => include_bytes!("../../icons/tray-icon-tun.ico").to_vec(),
-                _ => include_bytes!("../../icons/tray-icon-tun-mono.ico").to_vec(),
-            };
-            #[cfg(not(target_os = "macos"))]
-            let mut icon = include_bytes!("../../icons/tray-icon-tun.ico").to_vec();
-            if *tun_tray_icon {
-                let icon_dir_path = dirs::app_home_dir()?.join("icons");
-                let png_path = icon_dir_path.join("tun.png");
-                let ico_path = icon_dir_path.join("tun.ico");
-                if ico_path.exists() {
-                    icon = std::fs::read(ico_path).unwrap();
-                } else if png_path.exists() {
-                    icon = std::fs::read(png_path).unwrap();
+                "direct" => {
+                    if let Some(item) = menu.get("rule_mode") {
+                        let _ = item
+                            .as_menuitem()
+                            .unwrap()
+                            .set_text(t!("Rule Mode", "规则模式"));
+                    }
+                    if let Some(item) = menu.get("global_mode") {
+                        let _ = item
+                            .as_menuitem()
+                            .unwrap()
+                            .set_text(t!("Global Mode", "全局模式"));
+                    }
+                    if let Some(item) = menu.get("direct_mode") {
+                        let _ = item
+                            .as_menuitem()
+                            .unwrap()
+                            .set_text(t!("Direct Mode  ✔", "直连模式  ✔"));
+                    }
                 }
+                _ => {}
             }
-            indication_icon = icon
-        }
 
-        let _ = tray.set_icon(tauri::Icon::Raw(indication_icon));
+            let verge = Config::verge();
+            let verge = verge.latest();
+            let system_proxy = verge.enable_system_proxy.as_ref().unwrap_or(&false);
+            let tun_mode = verge.enable_tun_mode.as_ref().unwrap_or(&false);
+            #[cfg(target_os = "macos")]
+            let tray_icon = verge.tray_icon.clone().unwrap_or("monochrome".to_string());
+            let common_tray_icon = verge.common_tray_icon.as_ref().unwrap_or(&false);
+            let sysproxy_tray_icon = verge.sysproxy_tray_icon.as_ref().unwrap_or(&false);
+            let tun_tray_icon = verge.tun_tray_icon.as_ref().unwrap_or(&false);
+            let tray: TrayIcon = app_handle.tray_by_id("verge_tray").unwrap();
 
-        let _ = tray.get_item("system_proxy").set_selected(*system_proxy);
-        let _ = tray.get_item("tun_mode").set_selected(*tun_mode);
-        #[cfg(target_os = "linux")]
-        {
-            if *system_proxy {
-                let _ = tray
-                    .get_item("system_proxy")
-                    .set_title(t!("System Proxy  ✔", "系统代理  ✔"));
+            #[cfg(target_os = "macos")]
+            match tray_icon.as_str() {
+                "monochrome" => {
+                    let _ = tray.set_icon_as_template(true);
+                }
+                "colorful" => {
+                    let _ = tray.set_icon_as_template(false);
+                }
+                _ => {}
+            }
+            let mut indication_icon = if *system_proxy {
+                #[cfg(target_os = "macos")]
+                let mut icon = match tray_icon.as_str() {
+                    "monochrome" => include_bytes!("../../icons/tray-icon-sys-mono.ico").to_vec(),
+                    "colorful" => include_bytes!("../../icons/tray-icon-sys.ico").to_vec(),
+                    _ => include_bytes!("../../icons/tray-icon-sys-mono.ico").to_vec(),
+                };
+                #[cfg(not(target_os = "macos"))]
+                let mut icon = include_bytes!("../../icons/tray-icon-sys.ico").to_vec();
+
+                if *sysproxy_tray_icon {
+                    let icon_dir_path = dirs::app_home_dir()?.join("icons");
+                    let png_path = icon_dir_path.join("sysproxy.png");
+                    let ico_path = icon_dir_path.join("sysproxy.ico");
+                    if ico_path.exists() {
+                        icon = std::fs::read(ico_path).unwrap();
+                    } else if png_path.exists() {
+                        icon = std::fs::read(png_path).unwrap();
+                    }
+                }
+                icon
             } else {
-                let _ = tray
-                    .get_item("system_proxy")
-                    .set_title(t!("System Proxy", "系统代理"));
-            }
+                #[cfg(target_os = "macos")]
+                let mut icon = match tray_icon.as_str() {
+                    "monochrome" => include_bytes!("../../icons/tray-icon-mono.ico").to_vec(),
+                    "colorful" => include_bytes!("../../icons/tray-icon.ico").to_vec(),
+                    _ => include_bytes!("../../icons/tray-icon-mono.ico").to_vec(),
+                };
+                #[cfg(not(target_os = "macos"))]
+                let mut icon = include_bytes!("../../icons/tray-icon.ico").to_vec();
+                if *common_tray_icon {
+                    let icon_dir_path = dirs::app_home_dir()?.join("icons");
+                    let png_path = icon_dir_path.join("common.png");
+                    let ico_path = icon_dir_path.join("common.ico");
+                    if ico_path.exists() {
+                        icon = std::fs::read(ico_path).unwrap();
+                    } else if png_path.exists() {
+                        icon = std::fs::read(png_path).unwrap();
+                    }
+                }
+                icon
+            };
             if *tun_mode {
-                let _ = tray
-                    .get_item("tun_mode")
-                    .set_title(t!("TUN Mode  ✔", "Tun 模式  ✔"));
-            } else {
-                let _ = tray
-                    .get_item("tun_mode")
-                    .set_title(t!("TUN Mode", "Tun 模式"));
+                #[cfg(target_os = "macos")]
+                let mut icon = match tray_icon.as_str() {
+                    "monochrome" => include_bytes!("../../icons/tray-icon-tun-mono.ico").to_vec(),
+                    "colorful" => include_bytes!("../../icons/tray-icon-tun.ico").to_vec(),
+                    _ => include_bytes!("../../icons/tray-icon-tun-mono.ico").to_vec(),
+                };
+                #[cfg(not(target_os = "macos"))]
+                let mut icon = include_bytes!("../../icons/tray-icon-tun.ico").to_vec();
+                if *tun_tray_icon {
+                    let icon_dir_path = dirs::app_home_dir()?.join("icons");
+                    let png_path = icon_dir_path.join("tun.png");
+                    let ico_path = icon_dir_path.join("tun.ico");
+                    if ico_path.exists() {
+                        icon = std::fs::read(ico_path).unwrap();
+                    } else if png_path.exists() {
+                        icon = std::fs::read(png_path).unwrap();
+                    }
+                }
+                indication_icon = icon
             }
-        }
 
-        let switch_map = {
-            let mut map = std::collections::HashMap::new();
-            map.insert(true, "on");
-            map.insert(false, "off");
-            map
-        };
+            let _ = tray.set_icon(Some(tauri::image::Image::from_bytes(&indication_icon)?));
+            if let Some(item) = menu.get("system_proxy") {
+                let item = item.as_check_menuitem().unwrap();
+                let _ = item.set_checked(mode == "system_proxy");
+            }
+            if let Some(item) = menu.get("tun_mode") {
+                let item = item.as_check_menuitem().unwrap();
+                let _ = item.set_checked(mode == "tun_mode");
+            }
 
-        let mut current_profile_name = "None".to_string();
-        let profiles = Config::profiles();
-        let profiles = profiles.latest();
-        if let Some(current_profile_uid) = profiles.get_current() {
-            let current_profile = profiles.get_item(&current_profile_uid);
-            current_profile_name = match &current_profile.unwrap().name {
-                Some(profile_name) => profile_name.to_string(),
-                None => current_profile_name,
+            #[cfg(target_os = "linux")]
+            {
+                if let Some(item) = menu.get("system_proxy") {
+                    if *system_proxy {
+                        let _ = item
+                            .as_menuitem()
+                            .unwrap()
+                            .set_text(t!("System Proxy  ✔", "系统代理  ✔"));
+                    } else {
+                        let _ = item
+                            .as_menuitem()
+                            .unwrap()
+                            .set_text(t!("System Proxy", "系统代理"));
+                    }
+                }
+
+                if let Some(item) = menu.get("tun_mode") {
+                    if *tun_mode {
+                        let _ = item
+                            .as_menuitem()
+                            .unwrap()
+                            .set_text(t!("TUN Mode  ✔", "Tun 模式  ✔"));
+                    } else {
+                        let _ = item
+                            .as_menuitem()
+                            .unwrap()
+                            .set_text(t!("TUN Mode", "Tun 模式"));
+                    }
+                }
+            }
+
+            let switch_map = {
+                let mut map = std::collections::HashMap::new();
+                map.insert(true, "on");
+                map.insert(false, "off");
+                map
             };
-        };
-        let _ = tray.set_tooltip(&format!(
-            "Clash Verge {version}\n{}: {}\n{}: {}\n{}: {}",
-            t!("SysProxy", "系统代理"),
-            switch_map[system_proxy],
-            t!("TUN", "Tun模式"),
-            switch_map[tun_mode],
-            t!("Profile", "当前订阅"),
-            current_profile_name
-        ));
+
+            let mut current_profile_name = "None".to_string();
+            let profiles = Config::profiles();
+            let profiles = profiles.latest();
+            if let Some(current_profile_uid) = profiles.get_current() {
+                let current_profile = profiles.get_item(&current_profile_uid);
+                current_profile_name = match &current_profile.unwrap().name {
+                    Some(profile_name) => profile_name.to_string(),
+                    None => current_profile_name,
+                };
+            };
+
+            let _ = tray.set_tooltip(Some(&format!(
+                "Clash Verge {version}\n{}: {}\n{}: {}\n{}: {}",
+                t!("SysProxy", "系统代理"),
+                switch_map[system_proxy],
+                t!("TUN", "Tun模式"),
+                switch_map[tun_mode],
+                t!("Profile", "当前订阅"),
+                current_profile_name
+            )));
+        }
 
         Ok(())
     }
 
-    pub fn on_click(app_handle: &AppHandle) {
-        let tray_event = { Config::verge().latest().tray_event.clone() };
-        let tray_event = tray_event.unwrap_or("main_window".into());
-        match tray_event.as_str() {
+    pub fn on_menu_event(app_handle: &AppHandle, event: MenuEvent) {
+        match event.id.as_ref() {
+            mode @ ("rule_mode" | "global_mode" | "direct_mode") => {
+                let mode = &mode[0..mode.len() - 5];
+                feat::change_clash_mode(mode.into());
+            }
+            "open_window" => resolve::create_window(app_handle),
             "system_proxy" => feat::toggle_system_proxy(),
             "tun_mode" => feat::toggle_tun_mode(),
-            "main_window" => resolve::create_window(app_handle),
-            _ => {}
-        }
-    }
-
-    pub fn on_system_tray_event(app_handle: &AppHandle, event: SystemTrayEvent) {
-        match event {
-            #[cfg(not(target_os = "macos"))]
-            SystemTrayEvent::LeftClick { .. } => Tray::on_click(app_handle),
-            #[cfg(target_os = "macos")]
-            SystemTrayEvent::RightClick { .. } => Tray::on_click(app_handle),
-            SystemTrayEvent::MenuItemClick { id, .. } => match id.as_str() {
-                mode @ ("rule_mode" | "global_mode" | "direct_mode") => {
-                    let mode = &mode[0..mode.len() - 5];
-                    feat::change_clash_mode(mode.into());
-                }
-                "open_window" => resolve::create_window(app_handle),
-                "system_proxy" => feat::toggle_system_proxy(),
-                "tun_mode" => feat::toggle_tun_mode(),
-                "copy_env" => feat::copy_clash_env(app_handle),
-                "open_app_dir" => crate::log_err!(cmds::open_app_dir()),
-                "open_core_dir" => crate::log_err!(cmds::open_core_dir()),
-                "open_logs_dir" => crate::log_err!(cmds::open_logs_dir()),
-                "restart_clash" => feat::restart_clash_core(),
-                "restart_app" => api::process::restart(&app_handle.env()),
-                "quit" => cmds::exit_app(app_handle.clone()),
-
-                _ => {}
-            },
+            "copy_env" => feat::copy_clash_env(app_handle),
+            "open_app_dir" => crate::log_err!(cmds::open_app_dir()),
+            "open_core_dir" => crate::log_err!(cmds::open_core_dir()),
+            "open_logs_dir" => crate::log_err!(cmds::open_logs_dir()),
+            "restart_clash" => feat::restart_clash_core(),
+            "restart_app" => tauri::process::restart(&app_handle.env()),
+            "quit" => cmds::exit_app(app_handle.clone()),
             _ => {}
         }
     }