feat: add config log type and improve window logging

src-tauri/src/config/config.rs

@@ -2,8 +2,8 @@ use super::{Draft, IClashTemp, IProfiles, IRuntime, IVerge};
 use crate::{
     config::PrfItem,
     core::{handle, CoreManager},
-    enhance,
+    enhance, logging,
-    utils::{dirs, help},
+    utils::{dirs, help, logging::Type},
 };
 use anyhow::{anyhow, Result};
 use once_cell::sync::OnceCell;
@@ -75,12 +75,15 @@ impl Config {
 
         let validation_result = if config_result.is_ok() {
             // 验证配置文件
-            println!("[首次启动] 开始验证配置");
+            logging!(info, Type::Config, true, "开始验证配置");
 
             match CoreManager::global().validate_config().await {
                 Ok((is_valid, error_msg)) => {
                     if !is_valid {
-                        println!(
+                        logging!(
+                            warn,
+                            Type::Config,
+                            true,
                             "[首次启动] 配置验证失败，使用默认最小配置启动: {}",
                             error_msg
                         );
@@ -89,12 +92,12 @@ impl Config {
                             .await?;
                         Some(("config_validate::boot_error", error_msg))
                     } else {
-                        println!("[首次启动] 配置验证成功");
+                        logging!(info, Type::Config, true, "配置验证成功");
                         Some(("config_validate::success", String::new()))
                     }
                 }
                 Err(err) => {
-                    println!("[首次启动] 验证进程执行失败: {}", err);
+                    logging!(warn, Type::Config, true, "验证进程执行失败: {}", err);
                     CoreManager::global()
                         .use_default_config("config_validate::process_terminated", "")
                         .await?;
@@ -102,7 +105,7 @@ impl Config {
                 }
             }
         } else {
-            println!("[首次启动] 生成配置文件失败，使用默认配置");
+            logging!(warn, Type::Config, true, "生成配置文件失败，使用默认配置");
             CoreManager::global()
                 .use_default_config("config_validate::error", "")
                 .await?;

src-tauri/src/core/core.rs

@@ -188,16 +188,22 @@ impl CoreManager {
             return Ok((true, String::new()));
         }
 
-        logging!(info, Type::Core, true, "开始验证配置文件: {}", config_path);
+        logging!(
+            info,
+            Type::Config,
+            true,
+            "开始验证配置文件: {}",
+            config_path
+        );
 
         let clash_core = { Config::verge().latest().clash_core.clone() };
         let clash_core = clash_core.unwrap_or("verge-mihomo".into());
-        logging!(info, Type::Core, true, "使用内核: {}", clash_core);
+        logging!(info, Type::Config, true, "使用内核: {}", clash_core);
 
         let app_handle = handle::Handle::global().app_handle().unwrap();
         let test_dir = dirs::app_home_dir()?.join("test");
         let test_dir = dirs::path_to_str(&test_dir)?;
-        logging!(info, Type::Core, true, "测试目录: {}", test_dir);
+        logging!(info, Type::Config, true, "测试目录: {}", test_dir);
 
         // 使用子进程运行clash验证配置
         let output = app_handle
@@ -215,14 +221,14 @@ impl CoreManager {
         let has_error =
             !output.status.success() || error_keywords.iter().any(|&kw| stderr.contains(kw));
 
-        logging!(info, Type::Core, true, "-------- 验证结果 --------");
+        logging!(info, Type::Config, true, "-------- 验证结果 --------");
 
         if !stderr.is_empty() {
             logging!(info, Type::Core, true, "stderr输出:\n{}", stderr);
         }
 
         if has_error {
-            logging!(info, Type::Core, true, "发现错误，开始处理错误信息");
+            logging!(info, Type::Config, true, "发现错误，开始处理错误信息");
             let error_msg = if !stdout.is_empty() {
                 stdout.to_string()
             } else if !stderr.is_empty() {
@@ -233,11 +239,11 @@ impl CoreManager {
                 "验证进程被终止".to_string()
             };
 
-            logging!(info, Type::Core, true, "-------- 验证结束 --------\n");
+            logging!(info, Type::Config, true, "-------- 验证结束 --------");
             Ok((false, error_msg)) // 返回错误消息给调用者处理
         } else {
-            logging!(info, Type::Core, true, "验证成功");
+            logging!(info, Type::Config, true, "验证成功");
-            logging!(info, Type::Core, true, "-------- 验证结束 --------\n");
+            logging!(info, Type::Config, true, "-------- 验证结束 --------");
             Ok((true, String::new()))
         }
     }

src-tauri/src/feat/proxy.rs

@@ -1,12 +1,6 @@
 use crate::{
     config::{Config, IVerge},
-    core::{
+    core::handle,
-        handle,
-        service::{install_service, is_service_available, reinstall_service},
-        CoreManager,
-    },
-    logging, logging_error,
-    utils::logging::Type,
 };
 use std::env;
 use tauri_plugin_clipboard_manager::ClipboardExt;

src-tauri/src/utils/logging.rs

@@ -6,6 +6,7 @@ pub enum Type {
     Service,
     Hotkey,
     Window,
+    Config,
 }
 
 impl fmt::Display for Type {
@@ -15,6 +16,7 @@ impl fmt::Display for Type {
             Type::Service => write!(f, "[Service]"),
             Type::Hotkey => write!(f, "[Hotkey]"),
             Type::Window => write!(f, "[Window]"),
+            Type::Config => write!(f, "[Config]"),
         }
     }
 }

src-tauri/src/utils/resolve.rs

@@ -3,9 +3,9 @@ use crate::AppHandleManager;
 use crate::{
     config::{Config, IVerge, PrfItem},
     core::*,
-    log_err,
+    log_err, logging,
     module::lightweight,
-    utils::{error, init, server},
+    utils::{error, init, logging::Type, server},
     wrap_err,
 };
 use anyhow::{bail, Result};
@@ -62,34 +62,34 @@ pub async fn resolve_setup(app: &mut App) {
     log::trace!(target:"app", "init config");
     log_err!(Config::init_config().await);
 
-    if service::check_service().await.is_err() {
+    // if service::check_service().await.is_err() {
-        match service::install_service().await {
+    //     match service::install_service().await {
-            Ok(_) => {
+    //         Ok(_) => {
-                log::info!(target:"app", "install service susccess.");
+    //             log::info!(target:"app", "install service susccess.");
-                #[cfg(not(target_os = "macos"))]
+    //             #[cfg(not(target_os = "macos"))]
-                std::thread::sleep(std::time::Duration::from_millis(1000));
+    //             std::thread::sleep(std::time::Duration::from_millis(1000));
-                #[cfg(target_os = "macos")]
+    //             #[cfg(target_os = "macos")]
-                {
+    //             {
-                    let mut service_runing = false;
+    //                 let mut service_runing = false;
-                    for _ in 0..40 {
+    //                 for _ in 0..40 {
-                        if service::check_service().await.is_ok() {
+    //                     if service::check_service().await.is_ok() {
-                            service_runing = true;
+    //                         service_runing = true;
-                            break;
+    //                         break;
-                        } else {
+    //                     } else {
-                            log::warn!(target: "app", "service not runing, sleep 500ms and check again.");
+    //                         log::warn!(target: "app", "service not runing, sleep 500ms and check again.");
-                            std::thread::sleep(std::time::Duration::from_millis(500));
+    //                         std::thread::sleep(std::time::Duration::from_millis(500));
-                        }
+    //                     }
-                    }
+    //                 }
-                    if !service_runing {
+    //                 if !service_runing {
-                        log::warn!(target: "app", "service not running, will fallback to user mode");
+    //                     log::warn!(target: "app", "service not running, will fallback to user mode");
-                    }
+    //                 }
-                }
+    //             }
-            }
+    //         }
-            Err(e) => {
+    //         Err(e) => {
-                log::warn!(target: "app", "failed to install service: {e:?}, will fallback to user mode");
+    //             log::warn!(target: "app", "failed to install service: {e:?}, will fallback to user mode");
-            }
+    //         }
-        }
+    //     }
-    }
+    // }
 
     log::trace!(target: "app", "launch core");
     log_err!(CoreManager::global().init().await);
@@ -138,20 +138,27 @@ pub fn resolve_reset() {
 
 /// create main window
 pub fn create_window() {
-    println!("Starting to create window");
+    logging!(info, Type::Window, true, "Creating window");
-    log::info!(target: "app", "Starting to create window");
 
     let app_handle = handle::Handle::global().app_handle().unwrap();
     #[cfg(target_os = "macos")]
     AppHandleManager::global().set_activation_policy_regular();
 
     if let Some(window) = handle::Handle::global().get_window() {
-        println!("Found existing window, trying to show it");
+        logging!(
-        log::info!(target: "app", "Found existing window, trying to show it");
+            info,
+            Type::Window,
+            true,
+            "Found existing window, attempting to restore visibility"
+        );
 
         if window.is_minimized().unwrap_or(false) {
-            println!("Window is minimized, unminimizing");
+            logging!(
-            log::info!(target: "app", "Window is minimized, unminimizing");
+                info,
+                Type::Window,
+                true,
+                "Window is minimized, restoring window state"
+            );
             let _ = window.unminimize();
         }
         let _ = window.show();
@@ -159,8 +166,7 @@ pub fn create_window() {
         return;
     }
 
-    println!("Creating new window");
+    logging!(info, Type::Window, true, "Creating new application window");
-    log::info!(target: "app", "Creating new window");
 
     #[cfg(target_os = "windows")]
     let window = tauri::WebviewWindowBuilder::new(
@@ -206,8 +212,12 @@ pub fn create_window() {
 
     match window {
         Ok(window) => {
-            println!("Window created successfully, attempting to show");
+            logging!(
-            log::info!(target: "app", "Window created successfully, attempting to show");
+                info,
+                Type::Window,
+                true,
+                "Window created successfully, making window visible"
+            );
             let _ = window.show();
             let _ = window.set_focus();
 
@@ -215,8 +225,13 @@ pub fn create_window() {
             crate::feat::setup_window_state_monitor(&app_handle);
         }
         Err(e) => {
-            println!("Failed to create window: {:?}", e);
+            logging!(
-            log::error!(target: "app", "Failed to create window: {:?}", e);
+                error,
+                Type::Window,
+                true,
+                "Failed to create window: {:?}",
+                e
+            );
         }
     }
 }