feat: option to enable global hotkey (#2665)

src-tauri/src/config/verge.rs

@@ -98,6 +98,9 @@ pub struct IVerge {
     /// hotkey map
     /// format: {func},{key}
     pub hotkeys: Option<Vec<String>>,
+    
+    /// enable global hotkey
+    pub enable_global_hotkey: Option<bool>,
 
     /// 切换代理时自动关闭连接
     pub auto_close_connection: Option<bool>,
@@ -279,6 +282,7 @@ impl IVerge {
             webdav_username: None,
             webdav_password: None,
             enable_tray_speed: Some(true),
+            enable_global_hotkey: Some(true),
             ..Self::default()
         }
     }
@@ -345,6 +349,7 @@ impl IVerge {
         patch!(web_ui_list);
         patch!(clash_core);
         patch!(hotkeys);
+        patch!(enable_global_hotkey);
 
         patch!(auto_close_connection);
         patch!(auto_check_update);
@@ -411,6 +416,7 @@ pub struct IVergeResponse {
     pub enable_silent_start: Option<bool>,
     pub enable_system_proxy: Option<bool>,
     pub enable_proxy_guard: Option<bool>,
+    pub enable_global_hotkey: Option<bool>,
     pub use_default_bypass: Option<bool>,
     pub system_proxy_bypass: Option<String>,
     pub proxy_guard_duration: Option<u64>,
@@ -472,6 +478,7 @@ impl From<IVerge> for IVergeResponse {
             enable_silent_start: verge.enable_silent_start,
             enable_system_proxy: verge.enable_system_proxy,
             enable_proxy_guard: verge.enable_proxy_guard,
+            enable_global_hotkey: verge.enable_global_hotkey,
             use_default_bypass: verge.use_default_bypass,
             system_proxy_bypass: verge.system_proxy_bypass,
             proxy_guard_duration: verge.proxy_guard_duration,

src-tauri/src/core/hotkey.rs

@@ -45,6 +45,13 @@ impl Hotkey {
         Ok(())
     }
 
+    pub fn reset(&self) -> Result<()> {
+        let app_handle = handle::Handle::global().app_handle().unwrap();
+        let manager = app_handle.global_shortcut();
+        manager.unregister_all()?;
+        Ok(())
+    }
+
     pub fn register(&self, hotkey: &str, func: &str) -> Result<()> {
         let app_handle = handle::Handle::global().app_handle().unwrap();
         let manager = app_handle.global_shortcut();
@@ -76,7 +83,17 @@ impl Hotkey {
                         }
                     }
                 } else {
-                    f();
+                    if let Some(window) = app_handle.get_webview_window("main") {
+                        let is_enable_global_hotkey = { Config::verge().latest().enable_global_hotkey} .unwrap();
+                        let is_visible = window.is_visible().unwrap_or(false);
+                        let is_focused = window.is_focused().unwrap_or(false);
+
+                        if is_enable_global_hotkey {
+                            f();
+                        } else if is_focused && is_visible {
+                            f();
+                        }
+                    }
                 }
             }
         });
@@ -89,7 +106,6 @@ impl Hotkey {
         let app_handle = handle::Handle::global().app_handle().unwrap();
         let manager = app_handle.global_shortcut();
         manager.unregister(hotkey)?;
-
         log::debug!(target: "app", "unregister hotkey {hotkey}");
         Ok(())
     }

src-tauri/src/feat.rs

@@ -209,10 +209,12 @@ pub async fn patch_verge(patch: IVerge) -> Result<()> {
     let http_enabled = patch.verge_http_enabled;
     let http_port = patch.verge_port;
     let enable_tray_speed = patch.enable_tray_speed;
+    let enable_global_hotkey = patch.enable_global_hotkey;
 
     let res: std::result::Result<(), anyhow::Error> = {
         let mut should_restart_core = false;
         let mut should_update_clash_config = false;
+        let mut should_update_verge_config = false;
         let mut should_update_launch = false;
         let mut should_update_sysproxy = false;
         let mut should_update_systray_icon = false;
@@ -226,12 +228,13 @@ pub async fn patch_verge(patch: IVerge) -> Result<()> {
             should_update_systray_tooltip = true;
             should_update_systray_icon = true;
         }
-
+        if enable_global_hotkey.is_some() {
+            should_update_verge_config = true;
+        }
         #[cfg(not(target_os = "windows"))]
         if redir_enabled.is_some() || redir_port.is_some() {
             should_restart_core = true;
         }
-
         #[cfg(target_os = "linux")]
         if tproxy_enabled.is_some() || tproxy_port.is_some() {
             should_restart_core = true;
@@ -286,6 +289,10 @@ pub async fn patch_verge(patch: IVerge) -> Result<()> {
             CoreManager::global().update_config().await?;
             handle::Handle::refresh_clash();
         }
+        if should_update_verge_config {
+            Config::verge().draft().enable_global_hotkey = enable_global_hotkey;
+            handle::Handle::refresh_verge();
+        }
         if should_update_launch {
             sysopt::Sysopt::global().update_launch()?;
         }

src-tauri/src/lib.rs

@@ -6,6 +6,7 @@ mod feat;
 mod utils;
 use crate::core::hotkey;
 use crate::utils::{resolve, resolve::resolve_scheme, server};
+use config::Config;
 use tauri_plugin_autostart::MacosLauncher;
 use tauri_plugin_deep_link::DeepLinkExt;
 
@@ -159,6 +160,12 @@ pub fn run() {
                         {
                             log_err!(hotkey::Hotkey::global().register("Control+Q", "quit"));
                         };
+                        {   
+                            let is_enable_global_hotkey = { Config::verge().draft().enable_global_hotkey }.unwrap();
+                            if !is_enable_global_hotkey {
+                                log_err!(hotkey::Hotkey::global().init())
+                            }
+                        }
                     }
                     tauri::WindowEvent::Focused(false) => {
                         #[cfg(target_os = "macos")]
@@ -169,6 +176,14 @@ pub fn run() {
                         {
                             log_err!(hotkey::Hotkey::global().unregister("Control+Q"));
                         };
+                        {   
+                            let is_enable_global_hotkey = { Config::verge().draft().enable_global_hotkey }.unwrap();
+                            if !is_enable_global_hotkey {
+                                log_err!(hotkey::Hotkey::global().reset())
+                            } else {
+                                log_err!(hotkey::Hotkey::global().init())
+                            }
+                        }
                     }
                     tauri::WindowEvent::Destroyed => {
                         #[cfg(target_os = "macos")]