fix: auto launch does not worki

src-tauri/src/core/sysopt.rs

@@ -1,22 +1,22 @@
+use crate::core::handle::Handle;
 use crate::{
     config::{Config, IVerge},
     log_err,
 };
-use anyhow::{anyhow, Result};
-use auto_launch::{AutoLaunch, AutoLaunchBuilder};
+use anyhow::Result;
 use once_cell::sync::OnceCell;
 use parking_lot::Mutex;
-use std::env::current_exe;
 use std::sync::Arc;
 use sysproxy::{Autoproxy, Sysproxy};
 use tauri::async_runtime::Mutex as TokioMutex;
+use tauri_plugin_autostart::ManagerExt;
 use tokio::time::{sleep, Duration};
 
 pub struct Sysopt {
     update_sysproxy: Arc<TokioMutex<bool>>,
     reset_sysproxy: Arc<TokioMutex<bool>>,
     /// helps to auto launch the app
-    auto_launch: Arc<Mutex<Option<AutoLaunch>>>,
+    auto_launch: Arc<Mutex<bool>>,
     /// record whether the guard async is running or not
     guard_state: Arc<Mutex<bool>>,
 }
@@ -56,7 +56,7 @@ impl Sysopt {
         SYSOPT.get_or_init(|| Sysopt {
             update_sysproxy: Arc::new(TokioMutex::new(false)),
             reset_sysproxy: Arc::new(TokioMutex::new(false)),
-            auto_launch: Arc::new(Mutex::new(None)),
+            auto_launch: Arc::new(Mutex::new(false)),
             guard_state: Arc::new(false.into()),
         })
     }
@@ -214,76 +214,17 @@ impl Sysopt {
         Ok(())
     }
 
-    /// init the auto launch
-    pub fn init_launch(&self) -> Result<()> {
-        let app_exe = current_exe()?;
-        // let app_exe = dunce::canonicalize(app_exe)?;
-        let app_name = app_exe
-            .file_stem()
-            .and_then(|f| f.to_str())
-            .ok_or(anyhow!("failed to get file stem"))?;
-
-        let app_path = app_exe
-            .as_os_str()
-            .to_str()
-            .ok_or(anyhow!("failed to get app_path"))?
-            .to_string();
-
-        // fix issue #26
-        #[cfg(target_os = "windows")]
-        let app_path = format!("\"{app_path}\"");
-
-        // use the /Applications/Clash Verge.app path
-        #[cfg(target_os = "macos")]
-        let app_path = (|| -> Option<String> {
-            let path = std::path::PathBuf::from(&app_path);
-            let path = path.parent()?.parent()?.parent()?;
-            let extension = path.extension()?.to_str()?;
-            match extension == "app" {
-                true => Some(path.as_os_str().to_str()?.to_string()),
-                false => None,
-            }
-        })()
-        .unwrap_or(app_path);
-
-        #[cfg(target_os = "linux")]
-        let app_path = {
-            use crate::core::handle::Handle;
-            use tauri::Manager;
-
-            let app_handle = Handle::global().app_handle();
-            match app_handle {
-                Some(app_handle) => {
-                    let appimage = app_handle.env().appimage;
-                    appimage
-                        .and_then(|p| p.to_str().map(|s| s.to_string()))
-                        .unwrap_or(app_path)
-                }
-                None => app_path,
-            }
-        };
-
-        let auto = AutoLaunchBuilder::new()
-            .set_app_name(app_name)
-            .set_app_path(&app_path)
-            .build()?;
-
-        *self.auto_launch.lock() = Some(auto);
-
-        Ok(())
-    }
-
     /// update the startup
     pub fn update_launch(&self) -> Result<()> {
-        let auto_launch = self.auto_launch.lock();
-
+        let _lock = self.auto_launch.lock();
         let enable = { Config::verge().latest().enable_auto_launch };
         let enable = enable.unwrap_or(false);
-        let auto_launch = auto_launch.as_ref().unwrap();
-
+        let app_handle = Handle::global().app_handle().unwrap();
+        let autostart_manager = app_handle.autolaunch();
+        println!("enable: {}", enable);
         match enable {
-            true => auto_launch.enable()?,
-            false => log_err!(auto_launch.disable()), // 忽略关闭的错误
+            true => log_err!(autostart_manager.enable()),
+            false => log_err!(autostart_manager.disable()),
         };
 
         Ok(())