chore: Optimize service path

src-tauri/src/config/prfitem.rs

@@ -190,7 +190,7 @@ impl PrfItem {
         let self_proxy = opt_ref.map_or(false, |o| o.self_proxy.unwrap_or(false));
         let user_agent = opt_ref.map_or(None, |o| o.user_agent.clone());
 
-        let mut builder = reqwest::ClientBuilder::new().no_proxy();
+        let mut builder = reqwest::ClientBuilder::new().use_rustls_tls().no_proxy();
 
         // 使用软件自己的代理
         if self_proxy {
@@ -231,8 +231,7 @@ impl PrfItem {
             };
         }
 
-        let version = unsafe { dirs::APP_VERSION };
-        let version = format!("clash-verge/{version}");
+        let version = format!("clash-verge-rev");
         builder = builder.user_agent(user_agent.unwrap_or(version));
 
         let resp = builder.build()?.get(url).send().await?;

src-tauri/src/core/win_uwp.rs

@@ -7,8 +7,8 @@ use runas::Command as RunasCommand;
 use std::process::Command as StdCommand;
 
 pub async fn invoke_uwptools() -> Result<()> {
-    let binary_path = dirs::service_path()?;
-    let tool_path = binary_path.with_file_name("enableLoopback.exe");
+    let resource_dir = dirs::app_resources_dir()?;
+    let tool_path = resource_dir.join("enableLoopback.exe");
 
     if !tool_path.exists() {
         bail!("enableLoopback exe not found");
@@ -17,10 +17,9 @@ pub async fn invoke_uwptools() -> Result<()> {
     let token = Token::with_current_process()?;
     let level = token.privilege_level()?;
 
-   match level {
+    match level {
         PrivilegeLevel::NotPrivileged => RunasCommand::new(tool_path).status()?,
-        _ => StdCommand::new(tool_path)
-            .status()?,
+        _ => StdCommand::new(tool_path).status()?,
     };
 
     Ok(())

src-tauri/src/utils/dirs.rs

@@ -1,8 +1,9 @@
+use crate::core::handle;
 use anyhow::Result;
 use std::path::PathBuf;
 use tauri::{
     api::path::{data_dir, resource_dir},
-    Env, PackageInfo,
+    Env,
 };
 
 #[cfg(not(feature = "verge-dev"))]
@@ -14,73 +15,38 @@ static CLASH_CONFIG: &str = "config.yaml";
 static VERGE_CONFIG: &str = "verge.yaml";
 static PROFILE_YAML: &str = "profiles.yaml";
 
-static mut RESOURCE_DIR: Option<PathBuf> = None;
-
-/// portable flag
-#[allow(unused)]
-static mut PORTABLE_FLAG: bool = false;
-
-pub static mut APP_VERSION: &str = "v1.2.0";
-
-/// initialize portable flag
-#[cfg(target_os = "windows")]
-pub unsafe fn init_portable_flag() -> Result<()> {
+/// get the verge app home dir
+pub fn app_home_dir() -> Result<PathBuf> {
     use tauri::utils::platform::current_exe;
 
-    let exe = current_exe()?;
-
-    if let Some(dir) = exe.parent() {
+    let app_exe = current_exe()?;
+    if let Some(dir) = app_exe.parent() {
         let dir = PathBuf::from(dir).join(".config/PORTABLE");
 
         if dir.exists() {
-            PORTABLE_FLAG = true;
-        }
-    }
-
-    Ok(())
-}
-
-/// get the verge app home dir
-pub fn app_home_dir() -> Result<PathBuf> {
-    #[cfg(target_os = "windows")]
-    unsafe {
-        use tauri::utils::platform::current_exe;
-
-        if !PORTABLE_FLAG {
-            Ok(data_dir()
-                .ok_or(anyhow::anyhow!("failed to get app home dir"))?
-                .join(APP_ID))
-        } else {
-            let app_exe = current_exe()?;
             let app_exe = dunce::canonicalize(app_exe)?;
             let app_dir = app_exe
                 .parent()
                 .ok_or(anyhow::anyhow!("failed to get the portable app dir"))?;
-            Ok(PathBuf::from(app_dir).join(".config").join(APP_ID))
+            return Ok(PathBuf::from(app_dir).join(".config").join(APP_ID));
         }
     }
-
-    #[cfg(not(target_os = "windows"))]
     Ok(data_dir()
         .ok_or(anyhow::anyhow!("failed to get app home dir"))?
         .join(APP_ID))
 }
 
 /// get the resources dir
-pub fn app_resources_dir(package_info: &PackageInfo) -> Result<PathBuf> {
-    let res_dir = resource_dir(package_info, &Env::default())
-        .ok_or(anyhow::anyhow!("failed to get the resource dir"))?
-        .join("resources");
-
-    unsafe {
-        RESOURCE_DIR = Some(res_dir.clone());
-
-        let ver = package_info.version.to_string();
-        let ver_str = format!("v{ver}");
-        APP_VERSION = Box::leak(Box::new(ver_str));
-    }
-
-    Ok(res_dir)
+pub fn app_resources_dir() -> Result<PathBuf> {
+    let handle = handle::Handle::global();
+    let app_handle = handle.app_handle.lock();
+    if let Some(app_handle) = app_handle.as_ref() {
+        let res_dir = resource_dir(app_handle.package_info(), &Env::default())
+            .ok_or(anyhow::anyhow!("failed to get the resource dir"))?
+            .join("resources");
+        return Ok(res_dir);
+    };
+    Err(anyhow::anyhow!("failed to get the resource dir"))
 }
 
 /// profiles dir
@@ -105,22 +71,18 @@ pub fn profiles_path() -> Result<PathBuf> {
     Ok(app_home_dir()?.join(PROFILE_YAML))
 }
 
-#[allow(unused)]
-pub fn app_res_dir() -> Result<PathBuf> {
-    unsafe {
-        Ok(RESOURCE_DIR
-            .clone()
-            .ok_or(anyhow::anyhow!("failed to get the resource dir"))?)
-    }
-}
-
 pub fn clash_pid_path() -> Result<PathBuf> {
     Ok(app_home_dir()?.join("clash.pid"))
 }
 
+#[cfg(windows)]
+pub fn service_dir() -> Result<PathBuf> {
+    Ok(app_home_dir()?.join("service"))
+}
+
 #[cfg(windows)]
 pub fn service_path() -> Result<PathBuf> {
-    Ok(app_home_dir()?.join("clash-verge-service.exe"))
+    Ok(service_dir()?.join("clash-verge-service.exe"))
 }
 
 #[cfg(windows)]

src-tauri/src/utils/init.rs

@@ -9,7 +9,6 @@ use log4rs::config::{Appender, Logger, Root};
 use log4rs::encode::pattern::PatternEncoder;
 use std::fs::{self, DirEntry};
 use std::str::FromStr;
-use tauri::PackageInfo;
 
 /// initialize this instance's log file
 fn init_log() -> Result<()> {
@@ -142,11 +141,6 @@ pub fn delete_log() -> Result<()> {
 /// Initialize all the config files
 /// before tauri setup
 pub fn init_config() -> Result<()> {
-    #[cfg(target_os = "windows")]
-    unsafe {
-        let _ = dirs::init_portable_flag();
-    }
-
     let _ = init_log();
     let _ = delete_log();
 
@@ -188,9 +182,9 @@ pub fn init_config() -> Result<()> {
 
 /// initialize app resources
 /// after tauri setup
-pub fn init_resources(package_info: &PackageInfo) -> Result<()> {
+pub fn init_resources() -> Result<()> {
     let app_dir = dirs::app_home_dir()?;
-    let res_dir = dirs::app_resources_dir(package_info)?;
+    let res_dir = dirs::app_resources_dir()?;
 
     if !app_dir.exists() {
         let _ = fs::create_dir_all(&app_dir);
@@ -200,14 +194,7 @@ pub fn init_resources(package_info: &PackageInfo) -> Result<()> {
     }
 
     #[cfg(target_os = "windows")]
-    let file_list = [
-        "Country.mmdb",
-        "geoip.dat",
-        "geosite.dat",
-        "clash-verge-service.exe",
-        "install-service.exe",
-        "uninstall-service.exe",
-    ];
+    let file_list = ["Country.mmdb", "geoip.dat", "geosite.dat"];
     #[cfg(not(target_os = "windows"))]
     let file_list = ["Country.mmdb", "geoip.dat", "geosite.dat"];
 
@@ -251,3 +238,64 @@ pub fn init_resources(package_info: &PackageInfo) -> Result<()> {
 
     Ok(())
 }
+
+/// initialize service resources
+/// after tauri setup
+#[cfg(target_os = "windows")]
+pub fn init_service() -> Result<()> {
+    let service_dir = dirs::service_dir()?;
+    let res_dir = dirs::app_resources_dir()?;
+
+    if !service_dir.exists() {
+        let _ = fs::create_dir_all(&service_dir);
+    }
+    if !res_dir.exists() {
+        let _ = fs::create_dir_all(&res_dir);
+    }
+
+    let file_list = [
+        "clash-verge-service.exe",
+        "install-service.exe",
+        "uninstall-service.exe",
+    ];
+
+    // copy the resource file
+    // if the source file is newer than the destination file, copy it over
+    for file in file_list.iter() {
+        let src_path = res_dir.join(file);
+        let dest_path = service_dir.join(file);
+
+        let handle_copy = || {
+            match fs::copy(&src_path, &dest_path) {
+                Ok(_) => log::debug!(target: "app", "resources copied '{file}'"),
+                Err(err) => {
+                    log::error!(target: "app", "failed to copy resources '{file}', {err}")
+                }
+            };
+        };
+
+        if src_path.exists() && !dest_path.exists() {
+            handle_copy();
+            continue;
+        }
+
+        let src_modified = fs::metadata(&src_path).and_then(|m| m.modified());
+        let dest_modified = fs::metadata(&dest_path).and_then(|m| m.modified());
+
+        match (src_modified, dest_modified) {
+            (Ok(src_modified), Ok(dest_modified)) => {
+                if src_modified > dest_modified {
+                    handle_copy();
+                } else {
+                    log::debug!(target: "app", "skipping resource copy '{file}'");
+                }
+            }
+            _ => {
+                log::debug!(target: "app", "failed to get modified '{file}'");
+                handle_copy();
+            }
+        };
+    }
+
+    Ok(())
+}

src-tauri/src/utils/resolve.rs

@@ -30,8 +30,9 @@ pub fn resolve_setup(app: &mut App) {
 
     handle::Handle::global().init(app.app_handle());
 
-    log_err!(init::init_resources(app.package_info()));
-
+    log_err!(init::init_resources());
+    #[cfg(target_os = "windows")]
+    log_err!(init::init_service());
     // 处理随机端口
     let enable_random_port = Config::verge().latest().enable_random_port.unwrap_or(false);