LFeng/Thing
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 6 Wiki Activity

性能优化

Browse Source
This commit is contained in:
zhongluofeng
2026-08-06 10:33:16 +08:00
parent c7578a2e6b
commit e66c53e66d
105 changed files with 7273 additions and 5002 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src-tauri/Cargo.lock
Generated
+85
View File
@@ -2,6 +2,12 @@
# It is not intended for manual editing.
version = 4
[[package]]
name = "Inflector"
version = "0.11.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fe438c63458706e03479442743baae6c88256498e6431708f6dfc520a26515d3"
[[package]]
name = "adler2"
version = "2.0.1"
@@ -3019,6 +3025,12 @@ dependencies = [
"windows-link 0.2.1",
]
[[package]]
name = "paste"
version = "1.0.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
[[package]]
name = "pbkdf2"
version = "0.12.2"
@@ -4070,6 +4082,58 @@ dependencies = [
"system-deps",
]
[[package]]
name = "specta"
version = "2.0.0-rc.25"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "38f9a30cbcbb7011f1da7d73483983bf838af123883e45f2b36ed76328df9c50"
dependencies = [
"paste",
"rustc_version",
"serde_json",
"specta-macros",
]
[[package]]
name = "specta-macros"
version = "2.0.0-rc.25"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2ce14957ecc2897f1f848b8255b6531d13ddf49cbcf506b7c2c9fb1d005593bb"
dependencies = [
"Inflector",
"proc-macro2",
"quote",
"syn 2.0.118",
]
[[package]]
name = "specta-serde"
version = "0.0.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ee8a72b755ddb8949fd8f17c5db43f0e8a806ea587d9bc602ee3f73240c00029"
dependencies = [
"specta",
"specta-macros",
]
[[package]]
name = "specta-typescript"
version = "0.0.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "639404ee95557f2f8b7e4cb773ffefd45304c7ab8ba21ac83b69051595e083c0"
dependencies = [
"specta",
]
[[package]]
name = "specta-util"
version = "0.0.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "29b1fc02b446f7244a92924fe68c0555921209f1d342990cd1539e9138e69502"
dependencies = [
"specta",
]
[[package]]
name = "stable_deref_trait"
version = "1.2.1"
@@ -4304,6 +4368,7 @@ dependencies = [
"serde_json",
"serde_repr",
"serialize-to-javascript",
"specta",
"swift-rs",
"tauri-build",
"tauri-macros",
@@ -4577,6 +4642,23 @@ dependencies = [
"wry",
]
[[package]]
name = "tauri-specta"
version = "2.0.0-rc.25"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ee080f36d2ac17ce2f3a82fb53f02d664e8345457de51b56dad3c394dacc41a2"
dependencies = [
"heck 0.5.0",
"serde",
"serde_json",
"specta",
"specta-serde",
"specta-typescript",
"specta-util",
"tauri",
"thiserror 2.0.18",
]
[[package]]
name = "tauri-utils"
version = "2.9.3"
@@ -4676,6 +4758,8 @@ dependencies = [
"serde",
"serde_json",
"serde_yaml",
"specta",
"specta-typescript",
"sysinfo",
"tauri",
"tauri-build",
@@ -4685,6 +4769,7 @@ dependencies = [
"tauri-plugin-notification",
"tauri-plugin-opener",
"tauri-plugin-snap-layout",
"tauri-specta",
"tokio",
"url",
"walkdir",
src-tauri/Cargo.toml
+3
View File
@@ -27,6 +27,9 @@ tauri-plugin-notification = "2"
serde = { version = "1", features = ["derive"] }
serde_json = "1"
serde_yaml = "0.9"
specta = { version = "=2.0.0-rc.25", features = ["derive", "function", "serde_json"] }
specta-typescript = "0.0.12"
tauri-specta = { version = "=2.0.0-rc.25", features = ["typescript"] }
chrono = "0.4"
reqwest = { version = "0.12", features = ["json", "stream"] }
futures-util = "0.3"
src-tauri/src/clipboard/commands.rs
+79 -24
View File
@@ -3,13 +3,14 @@
use base64::engine::general_purpose::STANDARD;
use base64::Engine as _;
use serde::Serialize;
use specta::Type;
use tauri::{AppHandle, State};
use super::manager::{ClipboardManager, ClipboardSettings};
use super::reader::dib_to_png;
use super::storage::{ClipboardItem, ClipboardItemDetail};
#[derive(Serialize)]
#[derive(Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct ClipboardStatus {
pub running: bool,
@@ -21,7 +22,7 @@ fn img_to_base64(b: &[u8]) -> Option<String> {
}
/// 历史查询结果（含总数，用于分页）
#[derive(Serialize)]
#[derive(Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct HistoryPage {
pub items: Vec<ClipboardItem>,
@@ -29,74 +30,107 @@ pub struct HistoryPage {
}
#[tauri::command]
#[specta::specta]
pub async fn clipboard_get_history(
limit: Option<i64>,
offset: Option<i64>,
kind: Option<String>,
manager: State<'_, ClipboardManager>,
) -> Result<HistoryPage, String> {
let storage = manager.storage();
let storage = manager.storage().clone();
let kind = kind.unwrap_or_else(|| "all".into());
let limit = limit.unwrap_or(50);
let offset = offset.unwrap_or(0);
let items = storage.get_history(limit, offset, &kind);
let total = storage.count_kind(&kind);
Ok(HistoryPage { items, total })
// SQLite 查询移出 async runtime 线程
tauri::async_runtime::spawn_blocking(move || {
let items = storage.get_history(limit, offset, &kind);
let total = storage.count_kind(&kind);
HistoryPage { items, total }
})
.await
.map_err(|e| format!("查询任务失败: {}", e))
}
#[tauri::command]
#[specta::specta]
pub async fn clipboard_get_pinned(
manager: State<'_, ClipboardManager>,
) -> Result<Vec<ClipboardItem>, String> {
Ok(manager.storage().get_pinned())
let storage = manager.storage().clone();
tauri::async_runtime::spawn_blocking(move || storage.get_pinned())
.await
.map_err(|e| format!("查询任务失败: {}", e))
}
#[tauri::command]
#[specta::specta]
pub async fn clipboard_search(
query: String,
limit: Option<i64>,
offset: Option<i64>,
manager: State<'_, ClipboardManager>,
) -> Result<HistoryPage, String> {
let storage = manager.storage();
let storage = manager.storage().clone();
let limit = limit.unwrap_or(50);
let offset = offset.unwrap_or(0);
let items = storage.search(&query, limit, offset);
let total = storage.count_search(&query);
Ok(HistoryPage { items, total })
tauri::async_runtime::spawn_blocking(move || {
let items = storage.search(&query, limit, offset);
let total = storage.count_search(&query);
HistoryPage { items, total }
})
.await
.map_err(|e| format!("查询任务失败: {}", e))
}
#[tauri::command]
#[specta::specta]
pub async fn clipboard_get_item(
id: i64,
manager: State<'_, ClipboardManager>,
) -> Result<Option<ClipboardItemDetail>, String> {
Ok(manager.storage().get_detail(id, img_to_base64))
let storage = manager.storage().clone();
// get_detail 内部：锁内取数 + 锁外 base64 编码，整体移出主线程
tauri::async_runtime::spawn_blocking(move || storage.get_detail(id, img_to_base64))
.await
.map_err(|e| format!("查询任务失败: {}", e))
}
#[tauri::command]
#[specta::specta]
pub async fn clipboard_set_pinned(
id: i64,
pinned: bool,
manager: State<'_, ClipboardManager>,
) -> Result<bool, String> {
Ok(manager.storage().set_pinned(id, pinned))
let storage = manager.storage().clone();
tauri::async_runtime::spawn_blocking(move || storage.set_pinned(id, pinned))
.await
.map_err(|e| format!("操作任务失败: {}", e))
}
#[tauri::command]
#[specta::specta]
pub async fn clipboard_delete(
id: i64,
manager: State<'_, ClipboardManager>,
) -> Result<bool, String> {
Ok(manager.storage().delete(id))
let storage = manager.storage().clone();
tauri::async_runtime::spawn_blocking(move || storage.delete(id))
.await
.map_err(|e| format!("删除任务失败: {}", e))
}
#[tauri::command]
#[specta::specta]
pub async fn clipboard_clear(manager: State<'_, ClipboardManager>) -> Result<bool, String> {
Ok(manager.storage().clear_non_pinned())
let storage = manager.storage().clone();
tauri::async_runtime::spawn_blocking(move || storage.clear_non_pinned())
.await
.map_err(|e| format!("清空任务失败: {}", e))
}
#[tauri::command]
#[specta::specta]
pub async fn clipboard_copy_back(
id: i64,
manager: State<'_, ClipboardManager>,
@@ -105,11 +139,16 @@ pub async fn clipboard_copy_back(
}
#[tauri::command]
#[specta::specta]
pub async fn clipboard_count(manager: State<'_, ClipboardManager>) -> Result<i64, String> {
Ok(manager.storage().count())
let storage = manager.storage().clone();
tauri::async_runtime::spawn_blocking(move || storage.count())
.await
.map_err(|e| format!("查询任务失败: {}", e))
}
#[tauri::command]
#[specta::specta]
pub async fn clipboard_get_settings(
manager: State<'_, ClipboardManager>,
) -> Result<ClipboardSettings, String> {
@@ -117,6 +156,7 @@ pub async fn clipboard_get_settings(
}
#[tauri::command]
#[specta::specta]
pub async fn clipboard_save_settings(
settings: ClipboardSettings,
app: AppHandle,
@@ -131,9 +171,11 @@ pub async fn clipboard_save_settings(
} else if !settings.enabled && prev_enabled {
manager.stop();
}
// 快捷键变化时重新注册
// 快捷键变化时重新注册（共享工具模块，原子化 + 冲突检测）
if settings.shortcut != prev_shortcut {
super::popup::register_shortcut(&app, &settings.shortcut)?;
crate::shortcut::register_shortcut(&app, "剪贴板", &settings.shortcut, |a| {
super::popup::show_popup(a)
})?;
// 新快捷键非空时确保弹窗窗口已预创建
if !settings.shortcut.trim().is_empty() {
super::popup::ensure_popup_window(&app);
@@ -143,22 +185,27 @@ pub async fn clipboard_save_settings(
}
#[tauri::command]
#[specta::specta]
pub async fn clipboard_status(
manager: State<'_, ClipboardManager>,
) -> Result<ClipboardStatus, String> {
Ok(ClipboardStatus {
running: manager.is_running(),
count: manager.storage().count(),
})
let storage = manager.storage().clone();
let running = manager.is_running();
let count = tauri::async_runtime::spawn_blocking(move || storage.count())
.await
.map_err(|e| format!("查询任务失败: {}", e))?;
Ok(ClipboardStatus { running, count })
}
#[tauri::command]
#[specta::specta]
pub async fn clipboard_start(app: AppHandle, manager: State<'_, ClipboardManager>) -> Result<(), String> {
manager.start(&app);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub async fn clipboard_stop(manager: State<'_, ClipboardManager>) -> Result<(), String> {
manager.stop();
Ok(())
@@ -166,22 +213,27 @@ pub async fn clipboard_stop(manager: State<'_, ClipboardManager>) -> Result<(),
/// 注册（或切换）快捷弹窗全局快捷键
#[tauri::command]
#[specta::specta]
pub async fn clipboard_register_shortcut(
shortcut: String,
app: AppHandle,
) -> Result<(), String> {
super::popup::register_shortcut(&app, &shortcut)
crate::shortcut::register_shortcut(&app, "剪贴板", &shortcut, |a| {
super::popup::show_popup(a)
})
}
/// 注销快捷弹窗全局快捷键
#[tauri::command]
#[specta::specta]
pub async fn clipboard_unregister_shortcut(app: AppHandle) -> Result<(), String> {
super::popup::unregister_shortcut(&app);
crate::shortcut::unregister_shortcut(&app, "剪贴板");
Ok(())
}
/// 手动触发显示快捷弹窗（供 UI 按钮调用）
#[tauri::command]
#[specta::specta]
pub async fn clipboard_show_popup(app: AppHandle) -> Result<(), String> {
super::popup::show_popup(&app);
Ok(())
@@ -189,6 +241,7 @@ pub async fn clipboard_show_popup(app: AppHandle) -> Result<(), String> {
/// 隐藏快捷弹窗
#[tauri::command]
#[specta::specta]
pub async fn clipboard_hide_popup(app: AppHandle) -> Result<(), String> {
super::popup::hide_popup(&app);
Ok(())
@@ -196,6 +249,7 @@ pub async fn clipboard_hide_popup(app: AppHandle) -> Result<(), String> {
/// 显示已创建的弹窗窗口（前端 onMounted 后调用）
#[tauri::command]
#[specta::specta]
pub async fn clipboard_show_window(app: AppHandle) -> Result<(), String> {
super::popup::show_window(&app);
Ok(())
@@ -203,6 +257,7 @@ pub async fn clipboard_show_window(app: AppHandle) -> Result<(), String> {
/// 隐藏弹窗并模拟 Ctrl+V 粘贴到原窗口
#[tauri::command]
#[specta::specta]
pub async fn clipboard_paste_to_target(app: AppHandle) -> Result<(), String> {
super::popup::paste_to_target(&app);
Ok(())
src-tauri/src/clipboard/manager.rs
+23 -11
View File
@@ -7,13 +7,14 @@ use std::sync::{Arc, Mutex};
use std::thread::JoinHandle;
use serde::{Deserialize, Serialize};
use specta::Type;
use super::monitor::start_monitor;
use super::reader::{write_dib, write_files, write_text};
use super::storage::Storage;
/// 剪贴板设置（持久化到 clipboard/settings.json）
#[derive(Clone, Serialize, Deserialize)]
#[derive(Clone, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase", default)]
pub struct ClipboardSettings {
/// 监听是否启用
@@ -66,7 +67,7 @@ impl ClipboardManager {
let storage = match Storage::new(&clip_dir) {
Ok(s) => Arc::new(s),
Err(e) => {
eprintln!("[clipboard] 磁盘存储初始化失败，回退内存: {}", e);
crate::logger::log_warn("clipboard", &format!("磁盘存储初始化失败，回退内存: {}", e));
Arc::new(Storage::new_in_memory())
}
};
@@ -86,7 +87,7 @@ impl ClipboardManager {
/// 启动监听（若已运行则跳过）
pub fn start(&self, app: &tauri::AppHandle) {
let mut handle = self.monitor_handle.lock().unwrap();
let mut handle = self.monitor_handle.lock().unwrap_or_else(|e| e.into_inner());
if handle.is_some() {
return;
}
@@ -99,30 +100,41 @@ impl ClipboardManager {
self.monitor_stop.clone(),
);
*handle = Some(h);
eprintln!("[clipboard] 监听已启动");
crate::logger::log_info("clipboard", "监听已启动");
}
/// 停止监听
pub fn stop(&self) {
self.monitor_stop.store(true, Ordering::SeqCst);
if let Some(h) = self.monitor_handle.lock().unwrap().take() {
// 不阻塞等待；轮询线程最迟 800ms 后退出
let _ = h.join();
if let Some(h) = self
.monitor_handle
.lock()
.unwrap_or_else(|e| e.into_inner())
.take()
{
// 后台等待监听线程退出（最迟 800ms），不阻塞调用者。
// 剪贴板 stop 命令跑在 async runtime 线程上，直接 join 会卡住 tokio worker。
std::thread::spawn(move || {
let _ = h.join();
});
}
eprintln!("[clipboard] 监听已停止");
crate::logger::log_info("clipboard", "监听已停止");
}
pub fn is_running(&self) -> bool {
self.monitor_handle.lock().unwrap().is_some()
self.monitor_handle
.lock()
.unwrap_or_else(|e| e.into_inner())
.is_some()
}
pub fn get_settings(&self) -> ClipboardSettings {
self.settings.lock().unwrap().clone()
self.settings.lock().unwrap_or_else(|e| e.into_inner()).clone()
}
pub fn save_settings(&self, s: ClipboardSettings) {
{
*self.settings.lock().unwrap() = s.clone();
*self.settings.lock().unwrap_or_else(|e| e.into_inner()) = s.clone();
}
save_settings(&self.settings_path, &s);
}
src-tauri/src/clipboard/monitor.rs
+2 -2
View File
@@ -46,7 +46,7 @@ pub fn start_monitor(
continue;
}
let (rec_text, rec_image, rec_files, max_items, max_image_kb, dedup) = {
let s = settings.lock().unwrap();
let s = settings.lock().unwrap_or_else(|e| e.into_inner());
(
s.record_text,
s.record_image,
@@ -85,7 +85,7 @@ pub fn start_monitor(
};
if let Some(_id) = storage.insert_or_touch(item, dedup) {
storage.prune_to_max(max_items);
let _ = app.emit("clipboard-changed", ());
let _ = app.emit(crate::constants::events::CLIPBOARD_CHANGED, ());
}
})
}
src-tauri/src/clipboard/popup.rs
+32 -152
View File
@@ -12,67 +12,17 @@ use std::sync::Mutex;
use std::sync::atomic::{AtomicBool, Ordering};
use tauri::{AppHandle, Manager, WebviewUrl, WebviewWindowBuilder, Emitter};
use tauri::window::{Effect, EffectsBuilder};
use tauri_plugin_global_shortcut::{GlobalShortcutExt, Shortcut, ShortcutState};
/// 弹窗窗口标签
pub const POPUP_LABEL: &str = "clipboard-popup";
/// 当前注册的快捷键（用于注销旧快捷键）
static CURRENT_SHORTCUT: Mutex<Option<String>> = Mutex::new(None);
/// 标志：show_popup 兜底创建路径设为 true，前端 onMounted 回调 show_window 时据此判断是否显示。
/// 预创建路径不设置，避免应用启动时弹窗自动弹出。
static POPUP_PENDING_SHOW: AtomicBool = AtomicBool::new(false);
/// 解析快捷键字符串为 Shortcut（格式如 "Alt+V"、"Ctrl+Shift+V"）
/// 失败返回 None。
pub fn parse_shortcut(s: &str) -> Option<Shortcut> {
s.trim().parse::<Shortcut>().ok()
}
/// 注册全局快捷键。重复调用会先注销旧快捷键。
/// 传入空字符串则仅注销不注册。
pub fn register_shortcut(app: &AppHandle, shortcut_str: &str) -> Result<(), String> {
// 先注销旧快捷键
unregister_shortcut(app);
if shortcut_str.trim().is_empty() {
return Ok(());
}
let shortcut = parse_shortcut(shortcut_str)
.ok_or_else(|| format!("无效的快捷键: {}", shortcut_str))?;
let app_handle = app.clone();
app.global_shortcut()
.on_shortcut(shortcut, move |_app, _shortcut, event| {
// 仅在按下时触发（松开不触发）
if event.state == ShortcutState::Pressed {
show_popup(&app_handle);
}
})
.map_err(|e| format!("注册快捷键失败: {}", e))?;
if let Ok(mut cur) = CURRENT_SHORTCUT.lock() {
*cur = Some(shortcut_str.to_string());
}
eprintln!("[clipboard] 已注册快捷键: {}", shortcut_str);
Ok(())
}
/// 注销当前快捷键
pub fn unregister_shortcut(app: &AppHandle) {
if let Ok(cur) = CURRENT_SHORTCUT.lock() {
if let Some(ref s) = *cur {
if let Some(shortcut) = parse_shortcut(s) {
let _ = app.global_shortcut().unregister(shortcut);
}
}
}
if let Ok(mut cur) = CURRENT_SHORTCUT.lock() {
*cur = None;
}
}
/// 兜底创建路径下 show_popup 计算出的待显示位置（物理坐标），供 show_window 应用，
/// 避免窗口重建后仍停留在屏幕外 (-10000, -10000)。
static PENDING_POS: Mutex<Option<(f64, f64)>> = Mutex::new(None);
/// 创建弹窗窗口（隐藏状态）并注册失焦监听。
/// 位置默认在屏幕外，show_popup 时会重新定位。
@@ -99,7 +49,7 @@ fn create_popup_window(app: &AppHandle) {
{
Ok(w) => w,
Err(e) => {
eprintln!("[clipboard] 创建弹窗失败: {}", e);
crate::logger::log_error("clipboard", &format!("创建弹窗失败: {}", e));
return;
}
};
@@ -110,11 +60,11 @@ fn create_popup_window(app: &AppHandle) {
win.on_window_event(move |event| {
if let tauri::WindowEvent::Focused(false) = event {
let _ = win_handle.hide();
let _ = app_handle.emit("clipboard-popup-hide", ());
let _ = app_handle.emit(crate::constants::events::CLIPBOARD_POPUP_HIDE, ());
}
});
eprintln!("[clipboard] 弹窗窗口已预创建（隐藏状态）");
crate::logger::log_info("clipboard", "弹窗窗口已预创建（隐藏状态）");
}
/// 应用启动时预创建弹窗窗口（隐藏）。
@@ -136,7 +86,7 @@ pub fn show_popup(app: &AppHandle) {
None => return,
};
// 窗口尺寸（逻辑像素）
// 窗口尺寸（物理像素，由光标所在屏 DPI 换算）
let w = 380.0_f64;
let h = 460.0_f64;
@@ -144,36 +94,35 @@ pub fn show_popup(app: &AppHandle) {
let (wa_left, wa_top, wa_right, wa_bottom) = get_work_area_at_point(mx, my)
.unwrap_or((0, 0, 1920, 1040));
// 获取光标所在显示器的 DPI，将物理坐标转为逻辑坐标（DIP）
// 光标所在显示器的 DPI：窗口尺寸需按物理像素放大
let dpi = get_dpi_for_point(mx, my).unwrap_or(96);
let scale = dpi as f64 / 96.0;
let w_px = w * scale;
let h_px = h * scale;
let mx_l = mx as f64 / scale;
let my_l = my as f64 / scale;
let wa_left_l = wa_left as f64 / scale;
let wa_top_l = wa_top as f64 / scale;
let wa_right_l = wa_right as f64 / scale;
let wa_bottom_l = wa_bottom as f64 / scale;
// 逻辑坐标 clamping（窗口尺寸 w/h 也是逻辑像素）
let x = mx_l.max(wa_left_l).min(wa_right_l - w);
let y = my_l.max(wa_top_l).min(wa_bottom_l - h);
// 直接以物理坐标 clamping（光标位置 + 工作区均为物理像素，避免混合 DPI 下
// 手动"物理→逻辑"换算后 Tauri 再按窗口所在屏解释导致的定位偏移）
let x = (mx as f64).max(wa_left as f64).min(wa_right as f64 - w_px);
let y = (my as f64).max(wa_top as f64).min(wa_bottom as f64 - h_px);
// 窗口已存在：移动 + 显示 + 请求焦点
if let Some(win) = app.get_webview_window(POPUP_LABEL) {
let _ = win.set_position(tauri::Position::Logical(tauri::LogicalPosition {
x,
y,
let _ = win.set_position(tauri::Position::Physical(tauri::PhysicalPosition {
x: x as i32,
y: y as i32,
}));
let _ = win.show();
let _ = win.set_focus();
// 通知前端刷新数据
let _ = app.emit("clipboard-popup-show", ());
let _ = app.emit(crate::constants::events::CLIPBOARD_POPUP_SHOW, ());
return;
}
// 兜底：窗口被销毁时重新创建（隐藏），等前端 onMounted 回调 show_window
POPUP_PENDING_SHOW.store(true, Ordering::SeqCst);
if let Ok(mut pos) = PENDING_POS.lock() {
*pos = Some((x, y));
}
create_popup_window(app);
}
@@ -185,10 +134,18 @@ pub fn show_window(app: &AppHandle) {
return;
}
if let Some(win) = app.get_webview_window(POPUP_LABEL) {
// 应用 show_popup 计算的兜底位置（物理坐标），避免停留在屏幕外
let pos = PENDING_POS.lock().ok().and_then(|p| *p);
if let Some((x, y)) = pos {
let _ = win.set_position(tauri::Position::Physical(tauri::PhysicalPosition {
x: x as i32,
y: y as i32,
}));
}
let _ = win.show();
let _ = win.set_focus();
// 通知前端刷新数据
let _ = app.emit("clipboard-popup-show", ());
let _ = app.emit(crate::constants::events::CLIPBOARD_POPUP_SHOW, ());
}
}
@@ -250,83 +207,6 @@ fn simulate_paste() {
// 非 Windows 平台暂不支持自动粘贴
}
// ===== Win32 API：获取鼠标位置和工作区 =====
// ===== 屏幕/光标/DPI 工具已迁移至 crate::win32_util（跨模块共享） =====
#[cfg(windows)]
mod win_api {
use windows_sys::Win32::Foundation::POINT;
use windows_sys::Win32::UI::WindowsAndMessaging::{GetCursorPos, SystemParametersInfoW, SPI_GETWORKAREA};
/// 获取鼠标位置（屏幕坐标，物理像素）
pub fn get_cursor_pos() -> Option<(i32, i32)> {
let mut pt = POINT { x: 0, y: 0 };
unsafe {
if GetCursorPos(&mut pt) != 0 {
Some((pt.x, pt.y))
} else {
None
}
}
}
/// 获取主屏工作区尺寸（排除任务栏，物理像素）
pub fn get_work_area() -> Option<(f64, f64)> {
use windows_sys::Win32::Foundation::RECT;
let mut rect = RECT { left: 0, top: 0, right: 0, bottom: 0 };
unsafe {
if SystemParametersInfoW(SPI_GETWORKAREA, 0, &mut rect as *mut _ as *mut _, 0) != 0 {
Some(((rect.right - rect.left) as f64, (rect.bottom - rect.top) as f64))
} else {
None
}
}
}
/// 获取指定点所在显示器的工作区（排除任务栏），返回 (left, top, right, bottom) 物理像素。
/// 使用 MonitorFromPoint 支持多显示器环境。
pub fn get_work_area_at_point(x: i32, y: i32) -> Option<(i32, i32, i32, i32)> {
use windows_sys::Win32::Graphics::Gdi::{
GetMonitorInfoW, MonitorFromPoint, MONITORINFO, MONITOR_DEFAULTTONEAREST,
};
let pt = POINT { x, y };
let hmon = unsafe { MonitorFromPoint(pt, MONITOR_DEFAULTTONEAREST) };
let mut mi: MONITORINFO = unsafe { std::mem::zeroed() };
mi.cbSize = std::mem::size_of::<MONITORINFO>() as u32;
unsafe {
if GetMonitorInfoW(hmon, &mut mi) != 0 {
let rc = mi.rcWork;
Some((rc.left, rc.top, rc.right, rc.bottom))
} else {
None
}
}
}
/// 获取指定点所在显示器的有效 DPI。
/// scale factor = dpi / 96。
pub fn get_dpi_for_point(x: i32, y: i32) -> Option<u32> {
use windows_sys::Win32::Graphics::Gdi::{MonitorFromPoint, MONITOR_DEFAULTTONEAREST};
use windows_sys::Win32::UI::HiDpi::{GetDpiForMonitor, MDT_EFFECTIVE_DPI};
let pt = POINT { x, y };
let hmon = unsafe { MonitorFromPoint(pt, MONITOR_DEFAULTTONEAREST) };
let mut dpi_x: u32 = 0;
let mut dpi_y: u32 = 0;
unsafe {
if GetDpiForMonitor(hmon, MDT_EFFECTIVE_DPI, &mut dpi_x, &mut dpi_y) == 0 {
Some(dpi_x)
} else {
None
}
}
}
}
#[cfg(not(windows))]
mod win_api {
pub fn get_cursor_pos() -> Option<(i32, i32)> { None }
pub fn get_work_area() -> Option<(f64, f64)> { None }
pub fn get_work_area_at_point(_x: i32, _y: i32) -> Option<(i32, i32, i32, i32)> { None }
pub fn get_dpi_for_point(_x: i32, _y: i32) -> Option<u32> { None }
}
pub use win_api::{get_cursor_pos, get_work_area, get_work_area_at_point, get_dpi_for_point};
use crate::win32_util::{get_cursor_pos, get_work_area_at_point, get_dpi_for_point};
src-tauri/src/clipboard/storage.rs
+13 -8
View File
@@ -3,12 +3,13 @@
//! 表结构见 `init_db`。所有方法线程安全（内部 Mutex 包裹 Connection）。
use rusqlite::{params, Connection, OptionalExtension};
use specta::Type;
use std::fs;
use std::path::PathBuf;
use std::sync::Mutex;
/// 列表项（不含大字段，用于历史/搜索结果）
#[derive(Debug, Clone, serde::Serialize)]
#[derive(Debug, Clone, serde::Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct ClipboardItem {
pub id: i64,
@@ -21,7 +22,7 @@ pub struct ClipboardItem {
}
/// 详情（含文本内容或图片 base64）
#[derive(Debug, Clone, serde::Serialize)]
#[derive(Debug, Clone, serde::Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct ClipboardItemDetail {
#[serde(flatten)]
@@ -206,10 +207,11 @@ impl Storage {
}
/// 获取详情（含文本/图片预览 base64）
/// 先锁内查询数据，释放锁后再执行耗时编码（DIB→PNG + base64），避免长时间占用连接锁
pub fn get_detail(&self, id: i64, image_to_base64: impl Fn(&[u8]) -> Option<String>) -> Option<ClipboardItemDetail> {
let conn = self.conn.lock().ok()?;
let row = conn
.query_row(
let (item, content, blob) = {
let conn = self.conn.lock().ok()?;
conn.query_row(
"SELECT id, kind, preview, size, pinned, pinned_order, created_at, content, blob
FROM clipboard_history WHERE id = ?1",
params![id],
@@ -232,8 +234,9 @@ impl Storage {
))
},
)
.ok()?;
let (item, content, blob) = row;
.ok()?
};
// conn 已在此处释放，以下编码不占用连接锁
let image_base64 = if item.kind == "image" {
blob.as_deref().and_then(|b| image_to_base64(b))
} else {
@@ -342,6 +345,7 @@ impl Storage {
}
/// 按搜索关键词统计匹配的非固定条目总数
/// 与 `search` 保持一致的匹配字段（preview + content），避免分页总数错误
pub fn count_search(&self, query: &str) -> i64 {
let conn = match self.conn.lock() {
Ok(c) => c,
@@ -349,7 +353,8 @@ impl Storage {
};
let pattern = format!("%{}%", query);
conn.query_row(
"SELECT COUNT(*) FROM clipboard_history WHERE pinned = 0 AND preview LIKE ?1",
"SELECT COUNT(*) FROM clipboard_history
WHERE pinned = 0 AND (preview LIKE ?1 OR content LIKE ?1)",
params![pattern],
|r| r.get(0),
)
src-tauri/src/constants.rs
+49
View File
@@ -0,0 +1,49 @@
//! 全局常量集中定义。
//! 窗口 label / Tauri 事件名，避免魔法字符串散布各处。
//! 与前端 `src/lib/constants.ts` 保持对应。
/// 窗口 label（对应 capabilities/*.json 与前端 constants::WINDOWS）
pub mod windows {
pub const MAIN: &str = "main";
// 以下窗口由前端创建，Rust 侧仅作双端对应声明（无直接引用）
#[allow(dead_code)]
pub const OSD_OVERLAY: &str = "osd-overlay";
#[allow(dead_code)]
pub const SCREENSHOT_OVERLAY: &str = "screenshot-overlay";
}
/// Tauri 事件名（与前端 constants::EVENTS 对应）
pub mod events {
// 托盘菜单
pub const TRAY_MENU_SHOW: &str = "tray-menu-show";
pub const TRAY_MENU_STATE_UPDATED: &str = "tray-menu-state-updated";
pub const TRAY_TOGGLE_OSD: &str = "tray:toggle-osd";
pub const TRAY_NEW_DOWNLOAD: &str = "tray:new-download";
pub const TRAY_OPEN_SETTINGS: &str = "tray:open-settings";
// 剪贴板
pub const CLIPBOARD_CHANGED: &str = "clipboard-changed";
pub const CLIPBOARD_POPUP_SHOW: &str = "clipboard-popup-show";
pub const CLIPBOARD_POPUP_HIDE: &str = "clipboard-popup-hide";
// 快速面板
pub const QUICKPANEL_SHOW: &str = "quickpanel-show";
pub const QUICKPANEL_HIDE: &str = "quickpanel-hide";
// 监控
pub const MONITOR_DATA: &str = "monitor-data";
pub const MONITOR_NETWORK: &str = "monitor-network";
pub const MONITOR_ERROR: &str = "monitor-error";
pub const MONITOR_LOADING: &str = "monitor-loading";
pub const MONITOR_READY: &str = "monitor-ready";
pub const MONITOR_DISCONNECTED: &str = "monitor-disconnected";
// OSD 窗口
pub const OSD_SYSTEM_UI_ACTIVE: &str = "osd-system-ui-active";
pub const OSD_SYSTEM_UI_INACTIVE: &str = "osd-system-ui-inactive";
pub const OSD_START_DRAG: &str = "osd-start-drag";
pub const OSD_END_DRAG: &str = "osd-end-drag";
// 截图
pub const SCREENSHOT_SHORTCUT: &str = "screenshot-shortcut";
// 内核安装进度
pub const KERNEL_INSTALL_PROGRESS: &str = "kernel-install-progress";
// 进程与下载
pub const PROCESS_STATUS_CHANGED: &str = "process-status-changed";
pub const DOWNLOAD_ADDED: &str = "download-added";
}
src-tauri/src/download_engine/commands.rs
+10
View File
@@ -8,12 +8,14 @@ use super::task::{DownloadTask, DownloaderSettings};
/// 获取所有任务
#[tauri::command]
#[specta::specta]
pub fn downloader_get_tasks(engine: State<'_, DownloadEngine>) -> Vec<DownloadTask> {
engine.get_tasks()
}
/// 检查 URL 重复性并探测文件信息（添加下载前调用）
#[tauri::command]
#[specta::specta]
pub async fn downloader_check_url(
engine: State<'_, DownloadEngine>,
url: String,
@@ -47,6 +49,7 @@ pub async fn downloader_check_url(
/// 添加下载任务
#[tauri::command]
#[specta::specta]
pub async fn downloader_add_task(
engine: State<'_, DownloadEngine>,
url: String,
@@ -60,18 +63,21 @@ pub async fn downloader_add_task(
/// 暂停任务
#[tauri::command]
#[specta::specta]
pub fn downloader_pause_task(engine: State<'_, DownloadEngine>, id: String) -> Result<(), String> {
engine.pause_task(&id)
}
/// 恢复任务
#[tauri::command]
#[specta::specta]
pub fn downloader_resume_task(engine: State<'_, DownloadEngine>, id: String) -> Result<(), String> {
engine.resume_task(&id)
}
/// 移除任务
#[tauri::command]
#[specta::specta]
pub fn downloader_remove_task(
engine: State<'_, DownloadEngine>,
id: String,
@@ -82,12 +88,14 @@ pub fn downloader_remove_task(
/// 获取设置
#[tauri::command]
#[specta::specta]
pub fn downloader_get_settings(engine: State<'_, DownloadEngine>) -> DownloaderSettings {
engine.get_settings()
}
/// 保存设置
#[tauri::command]
#[specta::specta]
pub fn downloader_save_settings(
engine: State<'_, DownloadEngine>,
settings: DownloaderSettings,
@@ -118,6 +126,7 @@ pub fn downloader_get_extension_info(engine: State<'_, DownloadEngine>) -> serde
/// 用系统资源管理器打开目录
#[tauri::command]
#[specta::specta]
pub fn downloader_open_dir(app: AppHandle, path: String) -> Result<(), String> {
app.opener()
.open_path(path, None::<&str>)
@@ -126,6 +135,7 @@ pub fn downloader_open_dir(app: AppHandle, path: String) -> Result<(), String> {
/// 用系统默认浏览器打开 URL
#[tauri::command]
#[specta::specta]
pub fn downloader_open_url(app: AppHandle, url: String) -> Result<(), String> {
app.opener()
.open_url(url, None::<&str>)
src-tauri/src/download_engine/engine.rs
+152 -88
View File
@@ -1,6 +1,6 @@
use std::collections::HashMap;
use std::path::PathBuf;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};
@@ -10,9 +10,10 @@ use super::http_dl::{HttpDownloader, split_segments};
use super::rate_limit::RateLimiter;
use super::storage::{EngineState, Storage};
use super::task::{DownloadTask, DownloaderSettings, ProbeResult, Segment, TaskStatus};
use specta::Type;
/// 重复类型
#[derive(Debug, Clone, PartialEq, serde::Serialize)]
#[derive(Debug, Clone, PartialEq, serde::Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum DuplicateKind {
/// 无重复
@@ -26,7 +27,7 @@ pub enum DuplicateKind {
}
/// 已存在的任务信息（用于前端展示）
#[derive(Debug, Clone, serde::Serialize)]
#[derive(Debug, Clone, serde::Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct ExistingTaskInfo {
pub id: String,
@@ -35,7 +36,7 @@ pub struct ExistingTaskInfo {
}
/// check_url 命令返回的结果
#[derive(Debug, Clone, serde::Serialize)]
#[derive(Debug, Clone, serde::Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct CheckUrlResult {
/// 探测是否成功
@@ -77,6 +78,9 @@ pub struct CompletePayload {
/// 活跃下载句柄
struct TaskHandle {
/// 代际号：同一任务每次 start_download 递增。
/// 旧代际任务完成时不删除新任务句柄、不覆盖新任务状态（防 pause→resume 竞态）
gen: u64,
cancel: Arc<AtomicBool>,
/// 每个分段的已下载字节（与 segments 一一对应）
progress: Vec<Arc<std::sync::atomic::AtomicU64>>,
@@ -107,6 +111,8 @@ struct EngineInner {
app_handle: AppHandle,
/// 引擎是否已启动
started: AtomicBool,
/// 任务代际计数器（每次 start_download 递增，分配给新句柄）
next_gen: AtomicU64,
/// 持久化节流：上次保存时间
last_save: Mutex<Instant>,
}
@@ -149,6 +155,7 @@ impl DownloadEngine {
http: HttpDownloader::new(),
app_handle,
started: AtomicBool::new(false),
next_gen: AtomicU64::new(0),
last_save: Mutex::new(Instant::now()),
}),
};
@@ -182,7 +189,7 @@ impl DownloadEngine {
headers: &HashMap<String, String>,
) -> (Result<ProbeResult, String>, DuplicateKind, Option<ExistingTaskInfo>) {
let probe = self.inner.http.probe(url, headers).await;
let settings = self.inner.settings.lock().unwrap().clone();
let settings = self.inner.settings.lock().unwrap_or_else(|e| e.into_inner()).clone();
let task_dir = dir.map(|d| d.to_string()).unwrap_or_else(|| settings.download_dir.clone());
let filename = probe.as_ref().ok()
@@ -199,7 +206,7 @@ impl DownloadEngine {
let mut existing: Option<ExistingTaskInfo> = None;
{
let tasks = self.inner.tasks.lock().unwrap();
let tasks = self.inner.tasks.lock().unwrap_or_else(|e| e.into_inner());
for t in tasks.values() {
// URL 完全相同
if t.url == url {
@@ -280,7 +287,7 @@ impl DownloadEngine {
// 探测资源信息
let probe = self.inner.http.probe(&url, &headers).await;
let settings = self.inner.settings.lock().unwrap().clone();
let settings = self.inner.settings.lock().unwrap_or_else(|e| e.into_inner()).clone();
let task_dir = dir.unwrap_or_else(|| settings.download_dir.clone());
// 确定文件名
@@ -347,14 +354,14 @@ impl DownloadEngine {
};
{
let mut tasks = self.inner.tasks.lock().unwrap();
let mut tasks = self.inner.tasks.lock().unwrap_or_else(|e| e.into_inner());
tasks.insert(id.clone(), task);
}
self.persist_now();
// 如果探测成功，尝试调度
let should_schedule = {
let tasks = self.inner.tasks.lock().unwrap();
let tasks = self.inner.tasks.lock().unwrap_or_else(|e| e.into_inner());
tasks.get(&id).map(|t| t.status == TaskStatus::Queued).unwrap_or(false)
};
if should_schedule {
@@ -362,7 +369,7 @@ impl DownloadEngine {
}
// 通知前端有新任务加入（扩展通过 HTTP API 添加时，前端需要刷新）
let _ = self.inner.app_handle.emit("download-added", serde_json::json!({ "id": id }));
let _ = self.inner.app_handle.emit(crate::constants::events::DOWNLOAD_ADDED, serde_json::json!({ "id": id }));
Ok(id)
}
@@ -371,7 +378,7 @@ impl DownloadEngine {
pub fn pause_task(&self, id: &str) -> Result<(), String> {
// 1. 设置取消标志 + 读取进度（锁 handles）
let progress_values: Vec<u64> = {
let handles = self.inner.handles.lock().unwrap();
let handles = self.inner.handles.lock().unwrap_or_else(|e| e.into_inner());
if let Some(handle) = handles.get(id) {
handle.cancel.store(true, Ordering::SeqCst);
handle.progress.iter().map(|p| p.load(Ordering::Relaxed)).collect()
@@ -382,7 +389,7 @@ impl DownloadEngine {
// 2. 更新任务状态 + 同步进度（锁 tasks，不嵌套锁 handles）
{
let mut tasks = self.inner.tasks.lock().unwrap();
let mut tasks = self.inner.tasks.lock().unwrap_or_else(|e| e.into_inner());
if let Some(task) = tasks.get_mut(id) {
if task.status == TaskStatus::Active || task.status == TaskStatus::Queued {
task.status = TaskStatus::Paused;
@@ -407,7 +414,7 @@ impl DownloadEngine {
/// 恢复任务
pub fn resume_task(&self, id: &str) -> Result<(), String> {
{
let mut tasks = self.inner.tasks.lock().unwrap();
let mut tasks = self.inner.tasks.lock().unwrap_or_else(|e| e.into_inner());
if let Some(task) = tasks.get_mut(id) {
if task.status != TaskStatus::Paused && task.status != TaskStatus::Error {
return Err("任务不在可恢复状态".to_string());
@@ -434,7 +441,7 @@ impl DownloadEngine {
pub fn remove_task(&self, id: &str, delete_files: bool) -> Result<(), String> {
// 1. 设置取消标志 + abort join handle（锁 handles）
{
let mut handles = self.inner.handles.lock().unwrap();
let mut handles = self.inner.handles.lock().unwrap_or_else(|e| e.into_inner());
if let Some(handle) = handles.remove(id) {
handle.cancel.store(true, Ordering::SeqCst);
if let Ok(mut join) = handle.join.lock() {
@@ -447,7 +454,7 @@ impl DownloadEngine {
// 2. 从任务列表移除（锁 tasks）
let task = {
let mut tasks = self.inner.tasks.lock().unwrap();
let mut tasks = self.inner.tasks.lock().unwrap_or_else(|e| e.into_inner());
tasks.remove(id)
};
@@ -466,12 +473,12 @@ impl DownloadEngine {
/// 获取所有任务
pub fn get_tasks(&self) -> Vec<DownloadTask> {
self.inner.tasks.lock().unwrap().values().cloned().collect()
self.inner.tasks.lock().unwrap_or_else(|e| e.into_inner()).values().cloned().collect()
}
/// 获取设置
pub fn get_settings(&self) -> DownloaderSettings {
self.inner.settings.lock().unwrap().clone()
self.inner.settings.lock().unwrap_or_else(|e| e.into_inner()).clone()
}
/// 保存设置
@@ -485,7 +492,7 @@ impl DownloadEngine {
self.inner.global_limiter.set_limit(new_limit);
{
let mut s = self.inner.settings.lock().unwrap();
let mut s = self.inner.settings.lock().unwrap_or_else(|e| e.into_inner());
*s = settings;
}
self.persist_now();
@@ -500,7 +507,7 @@ impl DownloadEngine {
pub fn cleanup_on_exit(&self) {
// 取消所有活跃下载
{
let handles = self.inner.handles.lock().unwrap();
let handles = self.inner.handles.lock().unwrap_or_else(|e| e.into_inner());
for handle in handles.values() {
handle.cancel.store(true, Ordering::SeqCst);
}
@@ -508,7 +515,7 @@ impl DownloadEngine {
// 将 Active 任务标记为 Paused
{
let mut tasks = self.inner.tasks.lock().unwrap();
let mut tasks = self.inner.tasks.lock().unwrap_or_else(|e| e.into_inner());
for task in tasks.values_mut() {
if task.status == TaskStatus::Active {
task.status = TaskStatus::Paused;
@@ -528,10 +535,10 @@ impl DownloadEngine {
/// 调度：如果活跃任务数 < max_concurrent，启动排队任务
fn schedule(&self) {
let max_concurrent = self.inner.settings.lock().unwrap().max_concurrent as usize;
let max_concurrent = self.inner.settings.lock().unwrap_or_else(|e| e.into_inner()).max_concurrent as usize;
let (active_count, queued_ids) = {
let tasks = self.inner.tasks.lock().unwrap();
let tasks = self.inner.tasks.lock().unwrap_or_else(|e| e.into_inner());
let active = tasks.values().filter(|t| t.status == TaskStatus::Active).count();
let mut queued: Vec<_> = tasks
.values()
@@ -554,7 +561,7 @@ impl DownloadEngine {
/// 启动单个下载任务
fn start_download(&self, id: String) {
let task = {
let mut tasks = self.inner.tasks.lock().unwrap();
let mut tasks = self.inner.tasks.lock().unwrap_or_else(|e| e.into_inner());
match tasks.get_mut(&id) {
Some(task) if task.status == TaskStatus::Queued => {
task.status = TaskStatus::Active;
@@ -565,6 +572,9 @@ impl DownloadEngine {
}
};
// 分配代际号（同一任务每次重启递增）
let gen = self.inner.next_gen.fetch_add(1, Ordering::SeqCst) + 1;
// 创建取消标志和进度计数器
let cancel = Arc::new(AtomicBool::new(false));
let progress: Vec<Arc<std::sync::atomic::AtomicU64>> = task
@@ -573,13 +583,22 @@ impl DownloadEngine {
.map(|s| Arc::new(std::sync::atomic::AtomicU64::new(s.completed)))
.collect();
// 存储句柄
let handle = TaskHandle {
cancel: cancel.clone(),
progress: progress.iter().map(|p| p.clone()).collect(),
join: Mutex::new(None),
};
self.inner.handles.lock().unwrap().insert(id.clone(), handle);
// 存储句柄：先取消旧代际（若存在），确保旧任务尽快退出，避免新旧并发写同一临时文件
{
let mut handles = self.inner.handles.lock().unwrap_or_else(|e| e.into_inner());
if let Some(old) = handles.get(&id) {
old.cancel.store(true, Ordering::SeqCst);
}
handles.insert(
id.clone(),
TaskHandle {
gen,
cancel: cancel.clone(),
progress: progress.iter().map(|p| p.clone()).collect(),
join: Mutex::new(None),
},
);
}
// 生成下载 future
let engine = self.clone();
@@ -596,69 +615,94 @@ impl DownloadEngine {
let http = self.inner.http.clone();
let join = tauri::async_runtime::spawn(async move {
let my_gen = gen;
let result = http
.download(&url, &headers, &segments, &temp_file_path, cancel_clone, &progress_clone, limiter)
.await;
// 下载结束，更新任务状态
let final_status = match &result {
Ok(()) => TaskStatus::Complete,
Err(e) if e == "已取消" => TaskStatus::Paused,
Err(_) => TaskStatus::Error,
// 代际守卫：仅最新代际的任务能更新状态 / 移除句柄 / 发完成事件。
// pause→resume 后旧代际任务才退出，此时句柄已被新代际替换，
// 若仍按旧逻辑执行会覆盖新任务状态并误删新句柄（pause/remove 失效）
let is_current = {
let handles = engine.inner.handles.lock().unwrap_or_else(|e| e.into_inner());
handles.get(&id_clone).map(|h| h.gen == my_gen).unwrap_or(false)
};
// 下载成功后，将临时文件重命名为最终文件名
if final_status == TaskStatus::Complete {
let _ = tokio::fs::rename(&temp_file_path, &final_file_path).await;
}
if is_current {
// 下载结束，更新任务状态
let mut final_status = match &result {
Ok(()) => TaskStatus::Complete,
Err(e) if e == "已取消" => TaskStatus::Paused,
Err(_) => TaskStatus::Error,
};
let mut final_error: Option<String> = match &result {
Err(e) if e != "已取消" => Some(e.clone()),
_ => None,
};
// 同步最终进度到任务
{
let mut tasks = engine.inner.tasks.lock().unwrap();
if let Some(task) = tasks.get_mut(&id_clone) {
for (i, prog) in progress_clone.iter().enumerate() {
if let Some(seg) = task.segments.get_mut(i) {
seg.completed = prog.load(Ordering::Relaxed);
}
}
task.recalc_completed();
task.speed = 0;
task.status = final_status.clone();
if let Err(e) = &result {
if e != "已取消" {
task.error = Some(e.clone());
}
}
if final_status == TaskStatus::Complete {
task.completed_size = task.total_size.max(task.completed_size);
// 下载成功后，将临时文件重命名为最终文件名
if final_status == TaskStatus::Complete {
if let Err(e) = tokio::fs::rename(&temp_file_path, &final_file_path).await {
// 重命名失败（如目标被占用/路径不可写）→ 置 Error，
// 避免"标记完成但文件缺失"的状态不一致
final_status = TaskStatus::Error;
final_error = Some(format!("移动文件到最终路径失败: {}", e));
}
}
// 同步最终进度到任务
{
let mut tasks = engine.inner.tasks.lock().unwrap_or_else(|e| e.into_inner());
if let Some(task) = tasks.get_mut(&id_clone) {
for (i, prog) in progress_clone.iter().enumerate() {
if let Some(seg) = task.segments.get_mut(i) {
seg.completed = prog.load(Ordering::Relaxed);
}
}
task.recalc_completed();
task.speed = 0;
task.status = final_status.clone();
if let Some(e) = final_error {
task.error = Some(e);
}
if final_status == TaskStatus::Complete {
task.completed_size = task.total_size.max(task.completed_size);
}
}
}
// 从活跃句柄中移除（仅移除自己代际的句柄）
{
let mut handles = engine.inner.handles.lock().unwrap_or_else(|e| e.into_inner());
if let Some(h) = handles.get(&id_clone) {
if h.gen == my_gen {
handles.remove(&id_clone);
}
}
}
// 发送完成事件
let task = engine.inner.tasks.lock().unwrap_or_else(|e| e.into_inner()).get(&id_clone).cloned();
if let Some(task) = task {
let _ = engine.inner.app_handle.emit(
"download-complete",
CompletePayload {
id: id_clone.clone(),
filename: task.filename.clone(),
status: task.status.clone(),
error: task.error.clone(),
},
);
}
// 持久化 + 调度下一个
engine.persist_now();
engine.schedule();
}
// 从活跃句柄中移除
engine.inner.handles.lock().unwrap().remove(&id_clone);
// 发送完成事件
let task = engine.inner.tasks.lock().unwrap().get(&id_clone).cloned();
if let Some(task) = task {
let _ = engine.inner.app_handle.emit(
"download-complete",
CompletePayload {
id: id_clone.clone(),
filename: task.filename.clone(),
status: task.status.clone(),
error: task.error.clone(),
},
);
}
// 持久化 + 调度下一个
engine.persist_now();
engine.schedule();
});
// 存储 JoinHandle
if let Some(h) = self.inner.handles.lock().unwrap().get_mut(&id) {
if let Some(h) = self.inner.handles.lock().unwrap_or_else(|e| e.into_inner()).get_mut(&id) {
if let Ok(mut join_guard) = h.join.lock() {
*join_guard = Some(join);
}
@@ -670,6 +714,7 @@ impl DownloadEngine {
let progress_monitor = progress;
let cancel_monitor = cancel;
tauri::async_runtime::spawn(async move {
let my_gen = gen;
// 初始化为当前已下载量，避免恢复下载时首次计算速度异常
let mut last_completed: u64 = progress_monitor
.iter()
@@ -681,9 +726,17 @@ impl DownloadEngine {
loop {
interval.tick().await;
// 代际守卫：pause→resume 后旧监控立即退出，避免用过期进度覆盖新任务
let is_current = {
let handles = engine.inner.handles.lock().unwrap_or_else(|e| e.into_inner());
handles.get(&id_monitor).map(|h| h.gen == my_gen).unwrap_or(false)
};
if !is_current {
break;
}
// 如果任务已不在活跃状态，停止监控
let is_active = {
let tasks = engine.inner.tasks.lock().unwrap();
let tasks = engine.inner.tasks.lock().unwrap_or_else(|e| e.into_inner());
tasks.get(&id_monitor).map(|t| t.status == TaskStatus::Active).unwrap_or(false)
};
if !is_active || cancel_monitor.load(Ordering::SeqCst) {
@@ -709,7 +762,7 @@ impl DownloadEngine {
// 更新任务状态 + 发送进度事件
let total_size = {
let mut tasks = engine.inner.tasks.lock().unwrap();
let mut tasks = engine.inner.tasks.lock().unwrap_or_else(|e| e.into_inner());
if let Some(task) = tasks.get_mut(&id_monitor) {
task.completed_size = completed;
task.speed = speed;
@@ -743,7 +796,7 @@ impl DownloadEngine {
/// 节流持久化（至少间隔 3 秒）
fn persist_throttled(&self) {
let should_save = {
let last = self.inner.last_save.lock().unwrap();
let last = self.inner.last_save.lock().unwrap_or_else(|e| e.into_inner());
last.elapsed() >= Duration::from_secs(3)
};
if should_save {
@@ -751,19 +804,30 @@ impl DownloadEngine {
}
}
/// 立即持久化
/// 立即持久化。
/// 保存失败（磁盘不可写/rename 失败）时把进行中任务标记为 Error，
/// 防止用户误以为任务已持久化而关闭应用导致数据丢失。
fn persist_now(&self) {
let tasks: Vec<DownloadTask> = {
let tasks = self.inner.tasks.lock().unwrap();
let tasks = self.inner.tasks.lock().unwrap_or_else(|e| e.into_inner());
tasks.values().cloned().collect()
};
let settings = self.inner.settings.lock().unwrap().clone();
let settings = self.inner.settings.lock().unwrap_or_else(|e| e.into_inner()).clone();
let state = EngineState {
tasks,
settings,
next_id: 0, // storage.save 会从 id_counter 读取
};
self.inner.storage.save(state);
*self.inner.last_save.lock().unwrap() = Instant::now();
if let Err(e) = self.inner.storage.save(state) {
crate::logger::log_error("download", &format!("状态持久化失败，进行中任务标记为 Error: {}", e));
let mut tasks = self.inner.tasks.lock().unwrap_or_else(|e| e.into_inner());
for task in tasks.values_mut() {
if task.status == TaskStatus::Active {
task.status = TaskStatus::Error;
}
}
return; // 不更新 last_save，下次定时器会重试
}
*self.inner.last_save.lock().unwrap_or_else(|e| e.into_inner()) = Instant::now();
}
}
src-tauri/src/download_engine/http_dl.rs
+121 -12
View File
@@ -12,6 +12,12 @@ use tokio::task::JoinSet;
use super::rate_limit::RateLimiter;
use super::task::{ProbeResult, Segment};
/// 请求超时：连接 + 响应头必须在 30s 内就绪（分段请求若无超时，
/// 服务器挂死时任务将永久卡在 Active，pause→resume 会出现新旧任务并发写同一临时文件）
const REQUEST_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(30);
/// 分块读取停滞超时：30s 内无任何数据视为连接挂死，主动中断（配合取消标志及时退出）
const READ_STALL_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(30);
/// HTTP/HTTPS 下载器
#[derive(Clone)]
pub struct HttpDownloader {
@@ -43,7 +49,10 @@ impl HttpDownloader {
req = req.header(k, v);
}
match req.send().await {
match tokio::time::timeout(REQUEST_TIMEOUT, req.send())
.await
.map_err(|_| "探测超时（30s 内未收到响应头）".to_string())?
{
Ok(resp) => {
let status = resp.status();
let headers_map = resp.headers().clone();
@@ -92,9 +101,9 @@ impl HttpDownloader {
for (k, v) in headers {
head_req = head_req.header(k, v);
}
let resp = head_req
.send()
let resp = tokio::time::timeout(REQUEST_TIMEOUT, head_req.send())
.await
.map_err(|_| "探测超时（HEAD 30s 内未收到响应头）".to_string())?
.map_err(|e| format!("探测失败（GET 和 HEAD 均失败）: {}", e))?;
let headers_map = resp.headers().clone();
let total_size = headers_map
@@ -295,14 +304,26 @@ async fn download_segment_with_client(
req = req.header(k, v);
}
let resp = req
.send()
let resp = tokio::time::timeout(REQUEST_TIMEOUT, req.send())
.await
.map_err(|_| "请求超时（30s 内未收到响应头）".to_string())?
.map_err(|e| format!("请求失败: {}", e))?;
let status = resp.status();
if !status.is_success() && status.as_u16() != 206 {
return Err(format!("服务器返回 HTTP {}", status));
if unknown_size {
// 未知大小：未发送 Range 头，接受任意 2xx
if !status.is_success() {
return Err(format!("服务器返回 HTTP {}", status));
}
} else {
// 已发送 Range 头：必须返回 206。若服务器忽略 Range 返回 200 全文，
// 按 range_start 偏移写入会错位 → 静默损坏文件；此处直接中断。
if status.as_u16() != 206 {
return Err(format!(
"服务器未按分段请求响应（期望 206，实际 {}），已中断以避免文件损坏",
status
));
}
}
// 流式读取并写入文件
@@ -315,8 +336,9 @@ async fn download_segment_with_client(
return Err("已取消".to_string());
}
match stream.next().await {
Some(Ok(chunk)) => {
// 停滞超时：30s 无数据即中断，确保 cancel 标志能及时被感知（配合代际句柄防并发写）
match tokio::time::timeout(READ_STALL_TIMEOUT, stream.next()).await {
Ok(Some(Ok(chunk))) => {
buf.extend_from_slice(&chunk);
// 接收到数据立即更新进度（避免监控周期内进度无变化导致速度显示为 0）
local_completed += chunk.len() as u64;
@@ -331,10 +353,10 @@ async fn download_segment_with_client(
buf.clear();
}
}
Some(Err(e)) => {
Ok(Some(Err(e))) => {
return Err(format!("读取数据失败: {}", e));
}
None => {
Ok(None) => {
// 流结束，写入剩余数据
if !buf.is_empty() {
file.write_all(&buf)
@@ -346,6 +368,9 @@ async fn download_segment_with_client(
}
break;
}
Err(_) => {
return Err("读取超时（30s 无数据，已中断下载）".to_string());
}
}
}
@@ -436,10 +461,11 @@ fn percent_decode(s: &str) -> String {
/// 将文件大小划分为 N 个分段
pub fn split_segments(total_size: u64, num_connections: u32) -> Vec<Segment> {
if total_size == 0 || num_connections == 0 {
// 空文件或未指定连接数：单段覆盖整个文件（end 按 total_size 推导，不能硬编码 0）
return vec![Segment {
index: 0,
start: 0,
end: 0,
end: total_size.saturating_sub(1),
completed: 0,
}];
}
@@ -473,3 +499,86 @@ pub fn split_segments(total_size: u64, num_connections: u32) -> Vec<Segment> {
segments
}
#[cfg(test)]
mod split_segments_tests {
use super::*;
/// 分段必须完整覆盖 [0, total_size)，且相互连续无重叠
fn assert_contiguous(segments: &[Segment], total_size: u64) {
assert!(!segments.is_empty());
let mut prev_end: i64 = -1;
for seg in segments {
assert_eq!(seg.start as i64, prev_end + 1, "分段不连续");
assert!(seg.end >= seg.start, "分段 start > end");
prev_end = seg.end as i64;
}
assert_eq!(
segments.last().unwrap().end,
total_size - 1,
"末段未覆盖文件末尾"
);
}
#[test]
fn zero_size_returns_single_segment() {
let segs = split_segments(0, 4);
assert_eq!(segs.len(), 1);
assert_eq!(segs[0].start, 0);
assert_eq!(segs[0].end, 0);
}
#[test]
fn zero_connections_covers_whole_file() {
let segs = split_segments(1024, 0);
assert_eq!(segs.len(), 1);
assert_eq!(segs[0].start, 0);
assert_eq!(segs[0].end, 1023);
}
#[test]
fn divides_evenly_with_contiguous_coverage() {
// 10MB / 4 连接 → 4 段完整覆盖
let total = 10 * 1024 * 1024;
let segs = split_segments(total, 4);
assert_eq!(segs.len(), 4);
assert_contiguous(&segs, total);
}
#[test]
fn clamps_connections_by_min_segment_size() {
// 2MB 文件请求 8 连接 → 受 1MB 最小分段限制，实际 ≤ 2 段
let total = 2 * 1024 * 1024;
let segs = split_segments(total, 8);
assert!(segs.len() <= 2, "连接数未按最小分段收敛: {}", segs.len());
assert_contiguous(&segs, total);
}
#[test]
fn respects_requested_connection_count() {
// 大文件按请求连接数切分
let total = 100 * 1024 * 1024;
let segs = split_segments(total, 3);
assert_eq!(segs.len(), 3);
assert_contiguous(&segs, total);
// 每段大小均匀
for seg in &segs {
let seg_len = seg.end - seg.start + 1;
assert!(
seg_len >= total / 3,
"分段大小不均: {} 段只有 {} 字节",
seg.index,
seg_len
);
}
}
#[test]
fn tiny_file_single_segment() {
// 小于 1MB 的文件始终单段
let total = 100;
let segs = split_segments(total, 4);
assert_eq!(segs.len(), 1);
assert_contiguous(&segs, total);
}
}
src-tauri/src/download_engine/rate_limit.rs
+62 -1
View File
@@ -38,7 +38,7 @@ impl RateLimiter {
// 尝试在当前窗口消费（用作用域确保 MutexGuard 在 await 前释放）
let over_limit = {
let now = std::time::Instant::now();
let mut start = self.window_start.lock().unwrap();
let mut start = self.window_start.lock().unwrap_or_else(|e| e.into_inner());
let elapsed = now.duration_since(*start);
// 窗口过期，重置
@@ -72,3 +72,64 @@ impl Clone for RateLimiter {
Self::new(self.limit.load(Ordering::Relaxed))
}
}
#[cfg(test)]
mod rate_limiter_tests {
use super::*;
use std::time::Instant;
#[tokio::test]
async fn zero_limit_never_blocks() {
let limiter = RateLimiter::new(0);
let start = Instant::now();
limiter.consume(1024 * 1024).await;
limiter.consume(u64::MAX).await;
assert!(start.elapsed() < Duration::from_millis(50));
}
#[tokio::test]
async fn under_limit_returns_immediately() {
let limiter = RateLimiter::new(100_000); // 100KB/s
let start = Instant::now();
limiter.consume(1024).await;
assert!(start.elapsed() < Duration::from_millis(50));
}
#[tokio::test]
async fn exceeding_limit_waits_proportionally() {
// 限速 200 B/s：先消耗 100 未超限，再消耗 150 → 超限 50 → 等待约 250ms
let limiter = RateLimiter::new(200);
limiter.consume(100).await;
let start = Instant::now();
limiter.consume(150).await;
let elapsed = start.elapsed();
assert!(
elapsed >= Duration::from_millis(200),
"等待时间不足: {:?}",
elapsed
);
assert!(elapsed < Duration::from_millis(1100));
}
#[tokio::test]
async fn window_resets_after_one_second() {
// 限速 100 B/s：第一窗口耗尽后，1.1s 窗口重置，再消耗 100 不应阻塞
let limiter = RateLimiter::new(100);
limiter.consume(100).await;
tokio::time::sleep(Duration::from_millis(1100)).await;
let start = Instant::now();
limiter.consume(100).await;
assert!(start.elapsed() < Duration::from_millis(100));
}
#[tokio::test]
async fn set_limit_takes_effect_dynamically() {
let limiter = RateLimiter::new(0);
limiter.consume(1024).await; // 不限速
limiter.set_limit(100);
limiter.consume(100).await;
let start = Instant::now();
limiter.consume(100).await; // 累计 200 > 100 → 等待 1000ms
assert!(start.elapsed() >= Duration::from_millis(900));
}
}
src-tauri/src/download_engine/server.rs
+3 -3
View File
@@ -57,15 +57,15 @@ impl ExtensionServer {
let listener = match tokio::net::TcpListener::bind(&addr).await {
Ok(l) => l,
Err(e) => {
eprintln!("[download_engine] 扩展 HTTP 服务启动失败 ({}): {}", addr, e);
crate::logger::log_error("download", &format!("扩展 HTTP 服务启动失败 ({}): {}", addr, e));
return;
}
};
eprintln!("[download_engine] 扩展 HTTP 服务已启动: http://{}", addr);
crate::logger::log_info("download", &format!("扩展 HTTP 服务已启动: http://{}", addr));
if let Err(e) = axum::serve(listener, app).await {
eprintln!("[download_engine] 扩展 HTTP 服务异常: {}", e);
crate::logger::log_error("download", &format!("扩展 HTTP 服务异常: {}", e));
}
}
}
src-tauri/src/download_engine/storage.rs
+17 -16
View File
@@ -40,7 +40,7 @@ impl Storage {
pub fn new(data_dir: PathBuf) -> Self {
// 确保数据目录存在（首次启动或目录被删除时自动创建）
if let Err(e) = fs::create_dir_all(&data_dir) {
eprintln!("[download_engine] 创建数据目录失败: {} ({})", data_dir.display(), e);
crate::logger::log_error("download", &format!("创建数据目录失败: {} ({})", data_dir.display(), e));
}
let state_path = data_dir.join("engine_state.json");
let existing = Self::load_raw(&state_path);
@@ -68,23 +68,24 @@ impl Storage {
Self::load_raw(&self.state_path).unwrap_or_default()
}
/// 保存状态到磁盘
pub fn save(&self, mut state: EngineState) {
/// 保存状态到磁盘（原子写：先写 .tmp 再 rename 覆盖，
/// 避免进程崩溃时产生半写/截断的状态文件导致任务列表丢失）
/// 失败返回 Err，由调用方决定是否将任务置为 Error（防止"看似已保存"的假象）。
pub fn save(&self, mut state: EngineState) -> Result<(), String> {
// 同步 ID 计数器
state.next_id = self.id_counter.load(Ordering::SeqCst);
match serde_json::to_string_pretty(&state) {
Ok(json) => {
// 兜底：若父目录被外部删除则在写入前重建
if let Some(parent) = self.state_path.parent() {
let _ = fs::create_dir_all(parent);
}
if let Err(e) = fs::write(&self.state_path, json) {
eprintln!("[download_engine] 保存状态失败: {}", e);
}
}
Err(e) => {
eprintln!("[download_engine] 序列化状态失败: {}", e);
}
let json = serde_json::to_string_pretty(&state)
.map_err(|e| format!("序列化状态失败: {}", e))?;
// 兜底：若父目录被外部删除则在写入前重建
if let Some(parent) = self.state_path.parent() {
let _ = fs::create_dir_all(parent);
}
let tmp_path = PathBuf::from(format!("{}.tmp", self.state_path.display()));
fs::write(&tmp_path, json).map_err(|e| format!("保存状态失败: {}", e))?;
fs::rename(&tmp_path, &self.state_path).map_err(|e| {
let _ = fs::remove_file(&tmp_path);
format!("替换状态文件失败: {}", e)
})?;
Ok(())
}
}
src-tauri/src/download_engine/task.rs
+5 -4
View File
@@ -1,8 +1,9 @@
use serde::{Deserialize, Serialize};
use specta::Type;
use std::collections::HashMap;
/// 任务状态
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Type)]
#[serde(rename_all = "lowercase")]
pub enum TaskStatus {
/// 排队等待（并发数已满）
@@ -18,7 +19,7 @@ pub enum TaskStatus {
}
/// 下载分段（多线程 Range 下载 / 断点续传用）
#[derive(Debug, Clone, Serialize, Deserialize)]
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct Segment {
/// 分段索引
@@ -43,7 +44,7 @@ impl Segment {
}
/// 下载任务
#[derive(Debug, Clone, Serialize, Deserialize)]
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DownloadTask {
/// 任务 ID（自增 hex 字符串）
@@ -98,7 +99,7 @@ impl DownloadTask {
}
/// 下载设置
#[derive(Debug, Clone, Serialize, Deserialize)]
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DownloaderSettings {
/// 下载目录
src-tauri/src/lib.rs
+98 -156
View File
@@ -1,8 +1,7 @@
use std::sync::Arc;
use tauri::Emitter;
use tauri::Manager;
mod clipboard;
mod constants;
mod download_engine;
mod logger;
mod mihomo_manager;
@@ -12,17 +11,20 @@ mod osd_window;
mod process_manager;
mod quickpanel;
mod screenshot;
mod setup;
mod shortcut;
mod snap_fix;
mod tray_menu;
mod win32_util;
use download_engine::{
DownloadEngine, ExtensionServer,
DownloadEngine,
downloader_add_task, downloader_check_url, downloader_get_extension_info, downloader_get_settings, downloader_get_tasks,
downloader_open_dir, downloader_open_url, downloader_pause_task, downloader_remove_task,
downloader_resume_task, downloader_save_settings, downloader_status,
};
use logger::{
clear_logs, get_log_info, get_logs, log_message, LogManager,
log_clear, log_info_state, log_list, log_message,
};
use mihomo_manager::{
proxy_activate_profile, proxy_check_kernel_update, proxy_clear_system_proxy, proxy_close_connection, proxy_delete_profile,
@@ -37,21 +39,22 @@ use monitor_kernel::{
monitor_set_hardware_config, monitor_start, monitor_start_elevated, monitor_status,
monitor_stop, MonitorKernel,
};
use network_monitor::{network_monitor_status, NetworkMonitor};
use network_monitor::network_status;
use osd_window::{
osd_apply_overlay_style, osd_begin_drag, osd_set_click_through, osd_set_topmost,
osd_start_drag_watch, osd_start_topmost_watch, osd_stop_watch,
};
use process_manager::{
get_all_process_status, get_process_status, start_monitoring_thread, start_process,
stop_all_processes, stop_process, ProcessManager,
process_all_status, process_start, process_status,
process_stop, process_stop_all, ProcessManager,
};
use screenshot::commands::{
screenshot_capture_fullscreen, screenshot_capture_window, screenshot_clear_fullscreen,
screenshot_compose_copy, screenshot_copy_image, screenshot_crop_copy_stored,
screenshot_crop_stored, screenshot_cursor_pos, screenshot_disable_transitions,
screenshot_enum_windows, screenshot_fullscreen_png, screenshot_get_editor_image,
screenshot_get_fullscreen_bmp, screenshot_register_shortcut, screenshot_save_png,
screenshot_crop_stored, screenshot_cursor_pos, screenshot_delete_cache,
screenshot_disable_transitions, screenshot_enum_windows, screenshot_fullscreen_png,
screenshot_get_editor_image, screenshot_get_fullscreen_bmp, screenshot_load_cache,
screenshot_register_shortcut, screenshot_save_cache, screenshot_save_png,
screenshot_set_editor_image, screenshot_unregister_shortcut, screenshot_window_from_point,
};
use clipboard::{
@@ -75,35 +78,73 @@ use quickpanel::{
use tray_menu::{tray_menu_action, tray_menu_hide, tray_menu_ready};
#[tauri::command]
fn greet(name: &str) -> String {
format!("Hello, {}! You've been greeted from Rust!", name)
fn quit_app(app: tauri::AppHandle) {
// 资源清理统一收敛到 RunEvent::ExitRequested（覆盖所有退出路径），此处仅请求退出
app.exit(0);
}
#[tauri::command]
fn quit_app(
state: tauri::State<'_, ProcessManager>,
mihomo: tauri::State<'_, MihomoManager>,
engine: tauri::State<'_, DownloadEngine>,
monitor: tauri::State<'_, MonitorKernel>,
clipboard: tauri::State<'_, ClipboardManager>,
app: tauri::AppHandle,
) {
// 退出前清理系统代理，避免遗留导致网络问题
mihomo.cleanup_on_exit();
// 退出前保存下载引擎状态
engine.cleanup_on_exit();
// 停止提权 Kernel（普通权限由 stop_all 统一清理，提权 Kernel 需通过 /shutdown）
tauri::async_runtime::block_on(monitor.cleanup_on_exit(&app));
// 停止剪贴板监听线程
clipboard.stop();
// 停止所有子进程（同步 kill + 带超时的 wait，确保进程真正终止）
state.stop_all();
// 通过 app.exit 触发 RunEvent::ExitRequested，统一退出路径
app.exit(0);
/// 导出 tauri-specta 生成的 TypeScript 类型与命令绑定（仅 debug 构建，开发时自动刷新）。
/// 覆盖 proxy / quickpanel / clipboard / download_engine / screenshot 五个模块；
/// 豁免清单（返回 serde_json::Value 或 tauri::ipc::Response/Request，specta 无法生成）：
/// proxy_version / proxy_get_proxies / proxy_get_connections / proxy_patch_configs、
/// downloader_status / downloader_get_extension_info、
/// screenshot_get_fullscreen_bmp（返回 ipc::Response）/ screenshot_compose_copy（接收 ipc::Request）。
#[cfg(debug_assertions)]
fn export_bindings() {
use specta_typescript::Typescript;
use tauri_specta::{Builder, ErrorHandlingMode, collect_commands};
Builder::<tauri::Wry>::new()
// 全局把 u64/i64 映射为 number（项目取值均在 JS 安全整数范围：大小/时间戳/limit）
.dangerously_cast_bigints_to_number()
// 生成命令失败时直接 throw，与原生 invoke 一致，前端无需解包 helper
.error_handling(ErrorHandlingMode::Throw)
.commands(collect_commands![
// proxy（20）
proxy_activate_profile, proxy_check_kernel_update, proxy_clear_system_proxy,
proxy_close_connection, proxy_delete_profile, proxy_get_settings,
proxy_get_system_proxy, proxy_import_profile, proxy_install_kernel,
proxy_kernel_info, proxy_restart, proxy_save_settings,
proxy_select_proxy, proxy_set_system_proxy, proxy_start, proxy_status, proxy_stop,
proxy_test_delay, proxy_update_kernel, proxy_update_profile,
// quickpanel（22）
quickpanel_get_settings, quickpanel_save_settings, quickpanel_register_shortcut,
quickpanel_unregister_shortcut, quickpanel_show_popup, quickpanel_hide_popup,
quickpanel_show_window, quickpanel_lock_screen, quickpanel_init_file_index,
quickpanel_build_file_index, quickpanel_search_files, quickpanel_file_index_stats,
quickpanel_scan_apps, quickpanel_get_app_icon, quickpanel_clear_app_icon_cache,
quickpanel_reveal_in_explorer, quickpanel_open_file, quickpanel_get_special_locations,
quickpanel_open_special, quickpanel_delete_file, quickpanel_run_custom_command,
quickpanel_run_system_command,
// clipboard（20）
clipboard_get_history, clipboard_get_pinned, clipboard_search, clipboard_get_item,
clipboard_set_pinned, clipboard_delete, clipboard_clear, clipboard_copy_back,
clipboard_count, clipboard_get_settings, clipboard_save_settings, clipboard_status,
clipboard_start, clipboard_stop, clipboard_register_shortcut,
clipboard_unregister_shortcut, clipboard_show_popup, clipboard_hide_popup,
clipboard_show_window, clipboard_paste_to_target,
// download_engine（10，豁免 2）
downloader_get_tasks, downloader_check_url, downloader_add_task, downloader_pause_task,
downloader_resume_task, downloader_remove_task, downloader_get_settings,
downloader_save_settings, downloader_open_dir, downloader_open_url,
// screenshot（19，豁免 2：get_fullscreen_bmp 返回 ipc::Response、compose_copy 接收 ipc::Request）
screenshot_disable_transitions, screenshot_register_shortcut,
screenshot_unregister_shortcut, screenshot_capture_fullscreen, screenshot_fullscreen_png,
screenshot_clear_fullscreen, screenshot_crop_stored, screenshot_crop_copy_stored,
screenshot_window_from_point, screenshot_cursor_pos, screenshot_enum_windows,
screenshot_capture_window, screenshot_set_editor_image, screenshot_get_editor_image,
screenshot_copy_image, screenshot_save_png,
screenshot_save_cache, screenshot_load_cache, screenshot_delete_cache,
])
.export(Typescript::default(), "../src/lib/bindings.ts")
.expect("failed to export bindings");
}
#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
#[cfg(debug_assertions)]
export_bindings();
tauri::Builder::default()
.plugin(tauri_plugin_autostart::Builder::new().build())
.plugin(tauri_plugin_opener::init())
@@ -119,17 +160,16 @@ pub fn run() {
)
.manage(ProcessManager::new())
.invoke_handler(tauri::generate_handler![
greet,
quit_app,
start_process,
stop_process,
get_process_status,
get_all_process_status,
stop_all_processes,
process_start,
process_stop,
process_status,
process_all_status,
process_stop_all,
log_message,
get_logs,
clear_logs,
get_log_info,
log_list,
log_clear,
log_info_state,
proxy_get_settings,
proxy_save_settings,
proxy_kernel_info,
@@ -166,7 +206,7 @@ pub fn run() {
monitor_set_elevate_on_launch,
monitor_get_hardware_config,
monitor_set_hardware_config,
network_monitor_status,
network_status,
osd_apply_overlay_style,
osd_begin_drag,
osd_set_click_through,
@@ -246,123 +286,15 @@ pub fn run() {
screenshot_get_editor_image,
screenshot_copy_image,
screenshot_save_png,
screenshot_save_cache,
screenshot_load_cache,
screenshot_delete_cache,
screenshot_register_shortcut,
screenshot_unregister_shortcut,
screenshot_disable_transitions,
screenshot_compose_copy
])
.setup(|app| {
// 初始化日志系统，日志目录: {app_data_dir}/logs/
let log_dir = app
.path()
.app_data_dir()
.unwrap_or_else(|_| std::path::PathBuf::from("."))
.join("logs");
app.manage(LogManager::new(log_dir));
// 初始化 MihomoManager，数据目录: {app_data_dir}/proxy/
let app_data_dir = app
.path()
.app_data_dir()
.unwrap_or_else(|_| std::path::PathBuf::from("."));
// 永久提权检查：如果标志已设置且当前非管理员，以管理员权限重启自身并退出
// 必须在所有模块初始化之前执行（此时无资源需要清理）
if monitor_kernel::check_and_relaunch_if_needed(&app_data_dir) {
std::process::exit(0);
}
let mihomo = MihomoManager::new(app_data_dir.clone());
app.manage(mihomo);
// 初始化 MonitorKernel，数据目录: {app_data_dir}/monitor/
let monitor = MonitorKernel::new(app_data_dir.clone());
app.manage(monitor);
// 初始化 NetworkMonitor（网速监控，独立于 ThingHK Kernel）
// 网速采样不依赖提权，应用启动即开始
let network_monitor = Arc::new(NetworkMonitor::new());
app.manage(network_monitor.clone());
network_monitor.start(app.handle().clone());
// 初始化 DownloadEngine，数据目录: {app_data_dir}/downloader/
let engine = DownloadEngine::new(
app_data_dir.join("downloader"),
app.handle().clone(),
);
let settings = engine.get_settings();
app.manage(engine.clone());
// 启动扩展 HTTP API 服务器
let server_engine = engine.clone();
let server_port = settings.extension_port;
let server_secret = settings.extension_secret.clone();
tauri::async_runtime::spawn(async move {
ExtensionServer::start(server_engine, server_port, server_secret).await;
});
// 初始化 ClipboardManager，数据目录: {app_data_dir}/clipboard/
let clipboard = ClipboardManager::new(app_data_dir.clone());
// 应用启动时若已启用则自动开始监听
if clipboard.get_settings().enabled {
clipboard.start(&app.handle());
}
// 应用启动时注册快捷弹窗全局快捷键
let shortcut = clipboard.get_settings().shortcut.clone();
if !shortcut.trim().is_empty() {
let app_handle = app.handle().clone();
if let Err(e) = clipboard::popup::register_shortcut(&app_handle, &shortcut) {
eprintln!("[clipboard] 快捷键注册失败: {}", e);
}
// 预创建弹窗窗口（隐藏），首次按快捷键时直接 show，避免首次创建时序问题
clipboard::popup::ensure_popup_window(&app_handle);
}
app.manage(clipboard);
// 快速面板：应用启动时注册全局快捷键 + 预创建隐藏窗口。
// defaultEnabled:true 假设启用；用户在设置页禁用模块时由前端 onDisable 钩子注销快捷键。
let qp_settings = quickpanel::load_settings(&app.handle());
if !qp_settings.shortcut.trim().is_empty() {
let app_handle = app.handle().clone();
if let Err(e) = quickpanel::register_shortcut(&app_handle, &qp_settings.shortcut) {
eprintln!("[quickpanel] 快捷键注册失败: {}", e);
}
// 预创建弹窗窗口（隐藏），首次按快捷键时直接 show，避免首次创建时序问题
quickpanel::ensure_window(&app_handle);
}
// 初始化文件索引数据库（不立即构建，由前端设置页或首次唤起时触发）
quickpanel::file_index::init(&app.handle());
// 自定义托盘菜单（代理/OSD/Kernel/下载/设置/退出）
tray_menu::create_tray_menu(app.handle())?;
// 启动进程监控线程
start_monitoring_thread(app.handle().clone());
// 应用启动时自动启动 mihomo（如果用户在设置中开启了自动启动）
if let Some(mihomo) = app.try_state::<MihomoManager>() {
if let Some(pm) = app.try_state::<ProcessManager>() {
mihomo.auto_start_on_launch(app.handle(), &pm);
}
}
// 应用启动时自动启动 monitor Kernel（硬件监控默认启用，被动读取无副作用）
if let Some(monitor) = app.try_state::<MonitorKernel>() {
let monitor = monitor.inner().clone();
let app_handle = app.handle().clone();
tauri::async_runtime::spawn(async move {
match monitor.start_with_subscription(&app_handle).await {
Ok(info) => eprintln!("[monitor] 自动启动成功, pid={:?}", info.pid),
Err(e) => eprintln!("[monitor] 自动启动跳过: {}", e),
}
});
}
// 截图快捷键由前端 screenshotStore 启动时调用 screenshot_register_shortcut 注册
// （支持自定义，默认 Ctrl+Alt+A），此处不再硬编码注册
Ok(())
})
.setup(setup::init)
.on_window_event(|window, event| {
if let tauri::WindowEvent::CloseRequested { api, .. } = event {
window.hide().ok();
@@ -380,7 +312,17 @@ pub fn run() {
engine.cleanup_on_exit();
}
if let Some(monitor) = app.try_state::<MonitorKernel>() {
tauri::async_runtime::block_on(monitor.cleanup_on_exit(app));
// cleanup_on_exit 是 async；在事件循环回调中直接 block_on 有 panic 风险且阻塞退出，
// 放到独立 OS 线程执行并限时等待（与托盘旧实现同模式）。
let app_clone = app.clone();
let monitor_clone = monitor.inner().clone();
std::thread::spawn(move || {
tauri::async_runtime::block_on(async move {
monitor_clone.cleanup_on_exit(&app_clone).await;
});
})
.join()
.ok();
}
if let Some(clip) = app.try_state::<ClipboardManager>() {
clip.stop();
src-tauri/src/logger.rs
+286 -33
View File
@@ -1,8 +1,9 @@
use chrono::Local;
use serde::{Deserialize, Serialize};
use std::fs::{self, File, OpenOptions};
use std::io::{BufRead, BufReader, Write};
use std::path::PathBuf;
use std::io::{Read, Seek, SeekFrom, Write};
use std::path::{Path, PathBuf};
use std::sync::{Arc, Mutex, OnceLock};
/// 日志级别
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
@@ -34,11 +35,14 @@ pub struct LogInfo {
}
/// 日志管理器 —— 负责文件轮转、写入、查询
/// 所有写/轮转/读操作通过 write_lock 串行化，防止并发写交错与轮转竞争
#[derive(Clone)]
pub struct LogManager {
log_dir: PathBuf,
max_file_size: u64,
max_files: u32,
base_name: String,
write_lock: Arc<Mutex<()>>,
}
impl LogManager {
@@ -48,12 +52,14 @@ impl LogManager {
log_dir,
max_file_size: 5 * 1024 * 1024,
max_files: 5,
base_name: "thing".to_string(),
base_name: "Thing".to_string(),
write_lock: Arc::new(Mutex::new(())),
}
}
/// 写入一条日志
/// 写入一条日志（写 + 轮转在锁内串行执行）
pub fn log(&self, level: LogLevel, module: &str, message: &str) {
let _guard = self.write_lock.lock().unwrap_or_else(|e| e.into_inner());
let timestamp = Local::now().format("%Y-%m-%d %H:%M:%S").to_string();
let level_str = match level {
LogLevel::Debug => "DEBUG",
@@ -114,56 +120,57 @@ impl LogManager {
}
/// 读取日志（支持按模块/级别过滤、条数限制）
/// 从最新文件向旧文件倒序遍历，每个文件从末尾向前读取，达到 limit 即停止，
/// 避免将全部日志读入内存后再排序截断
pub fn get_logs(
&self,
module: Option<&str>,
level: Option<LogLevel>,
limit: Option<usize>,
) -> Vec<LogEntry> {
let limit = limit.unwrap_or(100);
// 与写入共用同一把锁，避免读到轮转半途/写入半行的状态
let _guard = self.write_lock.lock().unwrap_or_else(|e| e.into_inner());
let mut entries: Vec<LogEntry> = Vec::new();
// 收集所有日志文件（包括轮转文件）
let mut log_files: Vec<PathBuf> = Vec::new();
// 收集日志文件（最新在前：thing.log → thing.1.log → …）
let mut paths: Vec<PathBuf> = Vec::new();
let current = self.log_dir.join(format!("{}.log", self.base_name));
if current.exists() {
log_files.push(current);
paths.push(current);
}
for i in 1..=self.max_files {
let rotated = self
.log_dir
.join(format!("{}.{}.log", self.base_name, i));
if rotated.exists() {
log_files.push(rotated);
paths.push(rotated);
}
}
for path in &log_files {
if let Ok(file) = File::open(path) {
for line in BufReader::new(file).lines().flatten() {
if let Some(entry) = Self::parse_line(&line) {
if let Some(ref m) = module {
if entry.module != *m {
continue;
}
'outer: for path in &paths {
// 每文件返回最近 limit 行（从新到旧），收集满即整体停止
for line in read_tail_lines(path, limit) {
if let Some(entry) = Self::parse_line(&line) {
if let Some(ref m) = module {
if entry.module != *m {
continue;
}
if let Some(ref l) = level {
if entry.level != *l {
continue;
}
}
if let Some(ref l) = level {
if entry.level != *l {
continue;
}
entries.push(entry);
}
entries.push(entry);
if entries.len() >= limit {
break 'outer;
}
}
}
}
// 按时间戳降序（最新在前）
entries.sort_by(|a, b| b.timestamp.cmp(&a.timestamp));
if let Some(n) = limit {
entries.truncate(n);
}
entries
}
@@ -212,6 +219,7 @@ impl LogManager {
/// 清空所有日志文件
pub fn clear_logs(&self) -> Result<(), String> {
let _guard = self.write_lock.lock().unwrap_or_else(|e| e.into_inner());
let current = self.log_dir.join(format!("{}.log", self.base_name));
fs::remove_file(&current).map_err(|e| e.to_string())?;
for i in 1..=self.max_files {
@@ -259,6 +267,63 @@ impl LogManager {
// ===== Tauri 命令 =====
/// 从文件末尾向前读取日志行（返回时间从新到旧的最近 max_lines 行）。
/// 按 8KB 块向前 seek 读取并拼接跨块半行，只读取文件尾部，避免全量读入
fn read_tail_lines(path: &Path, max_lines: usize) -> Vec<String> {
let mut file = match File::open(path) {
Ok(f) => f,
Err(_) => return Vec::new(),
};
let file_len = match file.metadata() {
Ok(m) => m.len(),
Err(_) => return Vec::new(),
};
const CHUNK: u64 = 8192;
// tail 保存"当前块更靠后的半行"，下一轮（更早的块）拼在其前
let mut tail = String::new();
let mut lines: Vec<String> = Vec::new();
let mut pos = file_len;
while pos > 0 && lines.len() < max_lines {
let start = pos.saturating_sub(CHUNK);
let len = (pos - start) as usize;
let mut bytes = vec![0u8; len];
if file.seek(SeekFrom::Start(start)).is_err() || file.read_exact(&mut bytes).is_err() {
break;
}
pos = start;
let mut text = String::from_utf8_lossy(&bytes).into_owned();
text.push_str(&tail);
// 最后一段未以 \n 结尾 → 半行，作为下一轮 tail（与本块之前的内容拼接）
let mut parts: Vec<&str> = text.split('\n').collect();
tail = parts.pop().unwrap_or("").to_string();
// 从后往前（新到旧）取完整行
for part in parts.iter().rev() {
let trimmed = part.trim();
if !trimmed.is_empty() {
lines.push(trimmed.to_string());
if lines.len() >= max_lines {
break;
}
}
}
}
// 文件头残余（pos == 0 时 tail 里可能是文件第一行）
if pos == 0 {
let trimmed = tail.trim();
if !trimmed.is_empty() && lines.len() < max_lines {
lines.push(trimmed.to_string());
}
}
lines
}
#[tauri::command]
pub fn log_message(
state: tauri::State<'_, LogManager>,
@@ -278,12 +343,12 @@ pub fn log_message(
}
#[tauri::command]
pub fn get_logs(
pub async fn log_list(
state: tauri::State<'_, LogManager>,
module: Option<String>,
level: Option<String>,
limit: Option<usize>,
) -> Vec<LogEntry> {
) -> Result<Vec<LogEntry>, String> {
let level = level.and_then(|l| match l.as_str() {
"debug" => Some(LogLevel::Debug),
"info" => Some(LogLevel::Info),
@@ -291,15 +356,203 @@ pub fn get_logs(
"error" => Some(LogLevel::Error),
_ => None,
});
state.get_logs(module.as_deref(), level, limit)
// 文件读取（含 seek 尾部扫描）移出 async runtime 线程
let manager = state.inner().clone();
tauri::async_runtime::spawn_blocking(move || manager.get_logs(module.as_deref(), level, limit))
.await
.map_err(|e| format!("读取日志任务失败: {}", e))
}
#[tauri::command]
pub fn clear_logs(state: tauri::State<'_, LogManager>) -> Result<(), String> {
pub fn log_clear(state: tauri::State<'_, LogManager>) -> Result<(), String> {
state.clear_logs()
}
#[tauri::command]
pub fn get_log_info(state: tauri::State<'_, LogManager>) -> LogInfo {
pub fn log_info_state(state: tauri::State<'_, LogManager>) -> LogInfo {
state.get_info()
}
// ===== 进程级全局日志器 =====
// 后端模块（无 AppHandle 上下文）通过 log_line 写入统一的日志文件，
// 与 Tauri 命令 log_message 共用同一 LogManager（write_lock 串行化），
// 消除 eprintln!/println! 双轨并行问题。
static GLOBAL_LOGGER: OnceLock<LogManager> = OnceLock::new();
/// 在 setup 中注册全局日志器（与 app.manage 注册的实例共享同一把 write_lock）
pub fn install_global(manager: LogManager) {
let _ = GLOBAL_LOGGER.set(manager);
}
/// 写一条后端模块日志。未注册全局日志器时回退到 stderr（如测试环境）。
pub fn log_line(module: &str, level: LogLevel, message: &str) {
match GLOBAL_LOGGER.get() {
Some(m) => m.log(level, module, message),
None => eprintln!("[{}] {}", module, message),
}
}
/// 便捷：INFO 级别
pub fn log_info(module: &str, message: &str) {
log_line(module, LogLevel::Info, message);
}
/// 便捷：WARN 级别
pub fn log_warn(module: &str, message: &str) {
log_line(module, LogLevel::Warn, message);
}
/// 便捷：ERROR 级别
pub fn log_error(module: &str, message: &str) {
log_line(module, LogLevel::Error, message);
}
#[cfg(test)]
mod logger_tests {
use super::*;
use std::sync::atomic::{AtomicU32, Ordering};
use std::time::{SystemTime, UNIX_EPOCH};
static TEST_COUNTER: AtomicU32 = AtomicU32::new(0);
/// 创建唯一临时目录（进程内多次调用不冲突），测试结束自动清理
fn temp_dir(tag: &str) -> PathBuf {
let nanos = SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap()
.as_nanos();
let pid = std::process::id();
let seq = TEST_COUNTER.fetch_add(1, Ordering::SeqCst);
let dir = std::env::temp_dir().join(format!(
"thing_log_test_{}_{}_{}_{}",
tag, pid, nanos, seq
));
fs::create_dir_all(&dir).unwrap();
dir
}
struct TempGuard(PathBuf);
impl Drop for TempGuard {
fn drop(&mut self) {
let _ = fs::remove_dir_all(&self.0);
}
}
#[test]
fn parse_line_roundtrip() {
let line = "[2026-08-05 10:00:00] [INFO] [downloader] 下载完成";
let entry = LogManager::parse_line(line).expect("标准行应能解析");
assert_eq!(entry.timestamp, "2026-08-05 10:00:00");
assert_eq!(entry.level, LogLevel::Info);
assert_eq!(entry.module, "downloader");
assert_eq!(entry.message, "下载完成");
// 非法行返回 None
assert!(LogManager::parse_line("not a log line").is_none());
assert!(LogManager::parse_line("").is_none());
assert!(LogManager::parse_line("[bad] [INFO] [m] msg").is_none());
assert!(LogManager::parse_line("[2026-08-05 10:00:00] [NOPE] [m] msg").is_none());
// 时间戳不做格式校验：仅按方括号切分，日期形式同样可解析
assert!(LogManager::parse_line("[2026-08-05] [INFO] [m] msg").is_some());
}
#[test]
fn rotate_shifts_files_and_caps_count() {
let dir = temp_dir("rotate");
let _guard = TempGuard(dir.clone());
let mgr = LogManager::new(dir.clone());
let current = dir.join("thing.log");
fs::write(&current, "content-0").unwrap();
mgr.rotate();
// thing.log → thing.1.log
assert!(!current.exists());
assert_eq!(
fs::read_to_string(dir.join("thing.1.log")).unwrap(),
"content-0"
);
// 第二次轮转：thing.1.log → thing.2.log，新 thing.log → thing.1.log
fs::write(&current, "content-1").unwrap();
mgr.rotate();
assert_eq!(
fs::read_to_string(dir.join("thing.2.log")).unwrap(),
"content-0"
);
assert_eq!(
fs::read_to_string(dir.join("thing.1.log")).unwrap(),
"content-1"
);
// 轮转超过 max_files(5) 后最旧文件被删除，文件数量不超上限
for i in 0..6 {
fs::write(&current, format!("content-{}", i)).unwrap();
mgr.rotate();
}
let files: Vec<String> = fs::read_dir(&dir)
.unwrap()
.filter_map(|e| e.ok().map(|e| e.file_name().to_string_lossy().into_owned()))
.filter(|n| n.ends_with(".log"))
.collect();
assert!(files.len() <= 5, "轮转文件数量超上限: {:?}", files);
assert!(dir.join("thing.1.log").exists(), "最新的旋转文件应存在");
}
#[test]
fn log_writes_and_get_logs_filters() {
let dir = temp_dir("query");
let _guard = TempGuard(dir.clone());
let mgr = LogManager::new(dir.clone());
mgr.log(LogLevel::Info, "downloader", "任务开始");
mgr.log(LogLevel::Error, "downloader", "任务失败");
mgr.log(LogLevel::Info, "proxy", "节点切换");
// 全部（新到旧）
let all = mgr.get_logs(None, None, None);
assert_eq!(all.len(), 3);
assert_eq!(all[0].message, "节点切换");
assert_eq!(all[2].message, "任务开始");
// 按模块过滤
let dl = mgr.get_logs(Some("downloader"), None, None);
assert_eq!(dl.len(), 2);
assert!(dl.iter().all(|e| e.module == "downloader"));
// 按级别过滤
let errs = mgr.get_logs(None, Some(LogLevel::Error), None);
assert_eq!(errs.len(), 1);
assert_eq!(errs[0].message, "任务失败");
// 条数限制
let limited = mgr.get_logs(None, None, Some(2));
assert_eq!(limited.len(), 2);
}
#[test]
fn auto_rotate_triggers_on_size() {
let dir = temp_dir("auto");
let _guard = TempGuard(dir.clone());
let mgr = LogManager::new(dir.clone());
// 写满 5MB 触发自动轮转（meta.len() >= max_file_size）
let current = dir.join("thing.log");
let mut f = OpenOptions::new()
.create(true)
.append(true)
.open(&current)
.unwrap();
let big = "x".repeat(5 * 1024 * 1024);
f.write_all(big.as_bytes()).unwrap();
drop(f);
mgr.log(LogLevel::Info, "test", "触发轮转");
assert!(dir.join("thing.1.log").exists(), "应自动轮转出 thing.1.log");
// 轮转后旧文件（5MB）被重命名为 thing.1.log，当前文件只含新追加的一行
let rotated_len = fs::metadata(dir.join("thing.1.log")).unwrap().len();
assert_eq!(rotated_len, 5 * 1024 * 1024, "轮转出的文件应保留完整旧内容");
let cur_len = fs::metadata(&current).unwrap().len();
assert!(cur_len < 100, "轮转后的当前文件应只含新行: {}", cur_len);
}
}
src-tauri/src/mihomo_manager.rs
-1354
View File
File diff suppressed because it is too large Load Diff
src-tauri/src/mihomo_manager/commands.rs
+247
View File
@@ -0,0 +1,247 @@
//! 代理模块 Tauri 命令层。
use tauri::{AppHandle, State};
use super::system_proxy::{clear_system_proxy_windows, get_system_proxy_windows, set_system_proxy_windows};
use super::{
KernelInfo, KernelUpdateInfo, MihomoManager, ProfileMeta, ProxySettings, ProxyStatus,
};
use crate::process_manager::{ProcessInfo, ProcessManager};
#[tauri::command]
#[specta::specta]
pub fn proxy_get_settings(state: State<'_, MihomoManager>) -> ProxySettings {
state.load_settings()
}
#[tauri::command]
#[specta::specta]
pub fn proxy_save_settings(
state: State<'_, MihomoManager>,
settings: ProxySettings,
) -> Result<(), String> {
state.save_settings(&settings)
}
#[tauri::command]
#[specta::specta]
pub fn proxy_kernel_info(
state: State<'_, MihomoManager>,
app: AppHandle,
) -> Result<KernelInfo, String> {
state.prepare_kernel(&app)
}
#[tauri::command]
#[specta::specta]
pub async fn proxy_check_kernel_update(
state: State<'_, MihomoManager>,
) -> Result<KernelUpdateInfo, String> {
state.check_kernel_update().await
}
#[tauri::command]
#[specta::specta]
pub async fn proxy_update_kernel(
state: State<'_, MihomoManager>,
app: AppHandle,
mirror_prefix: Option<String>,
) -> Result<KernelInfo, String> {
state.install_kernel(&app, mirror_prefix.unwrap_or_default()).await
}
/// 首次安装内核（与 update_kernel 共用 install_kernel 实现，语义独立便于前端区分场景）
#[tauri::command]
#[specta::specta]
pub async fn proxy_install_kernel(
state: State<'_, MihomoManager>,
app: AppHandle,
mirror_prefix: Option<String>,
) -> Result<KernelInfo, String> {
state.install_kernel(&app, mirror_prefix.unwrap_or_default()).await
}
#[tauri::command]
#[specta::specta]
pub fn proxy_status(pm: State<'_, ProcessManager>) -> ProxyStatus {
match pm.get_status("proxy") {
Some(p) => ProxyStatus {
running: matches!(p.status, crate::process_manager::ProcessStatus::Running),
pid: p.pid,
restart_count: p.restart_count,
},
None => ProxyStatus {
running: false,
pid: None,
restart_count: 0,
},
}
}
#[tauri::command]
#[specta::specta]
pub fn proxy_start(
state: State<'_, MihomoManager>,
pm: State<'_, ProcessManager>,
app: AppHandle,
) -> Result<ProcessInfo, String> {
let params = state.prepare_for_start(&app)?;
pm.start(params)
}
#[tauri::command]
#[specta::specta]
pub fn proxy_stop(pm: State<'_, ProcessManager>) -> Result<(), String> {
pm.stop("proxy")
}
#[tauri::command]
#[specta::specta]
pub async fn proxy_restart(
state: State<'_, MihomoManager>,
pm: State<'_, ProcessManager>,
app: AppHandle,
) -> Result<ProcessInfo, String> {
let _ = pm.stop("proxy");
// 等待 TCP 端口释放（Windows 上 kill 后端口释放有延迟），在阻塞线程池中 sleep 避免阻塞主线程
tauri::async_runtime::spawn_blocking(|| {
std::thread::sleep(std::time::Duration::from_millis(800));
})
.await
.map_err(|e| format!("sleep 失败: {}", e))?;
let params = state.prepare_for_start(&app)?;
pm.start(params)
}
#[tauri::command]
pub async fn proxy_version(state: State<'_, MihomoManager>) -> Result<serde_json::Value, String> {
state.get_version().await
}
#[tauri::command]
pub async fn proxy_get_proxies(state: State<'_, MihomoManager>) -> Result<serde_json::Value, String> {
state.get_proxies().await
}
#[tauri::command]
#[specta::specta]
pub async fn proxy_select_proxy(
state: State<'_, MihomoManager>,
group: String,
name: String,
) -> Result<(), String> {
state.select_proxy(&group, &name).await
}
#[tauri::command]
#[specta::specta]
pub async fn proxy_test_delay(
state: State<'_, MihomoManager>,
name: String,
url: Option<String>,
timeout: Option<u32>,
) -> Result<u32, String> {
state
.test_delay(
&name,
url.as_deref().unwrap_or("https://www.gstatic.com/generate_204"),
timeout.unwrap_or(5000),
)
.await
}
#[tauri::command]
pub async fn proxy_get_connections(
state: State<'_, MihomoManager>,
) -> Result<serde_json::Value, String> {
state.get_connections().await
}
#[tauri::command]
#[specta::specta]
pub async fn proxy_close_connection(
state: State<'_, MihomoManager>,
id: String,
) -> Result<(), String> {
state.close_connection(&id).await
}
#[tauri::command]
pub async fn proxy_patch_configs(
state: State<'_, MihomoManager>,
body: serde_json::Value,
) -> Result<(), String> {
state.patch_configs(body).await
}
// ---------- 订阅 ----------
#[tauri::command]
#[specta::specta]
pub async fn proxy_import_profile(
state: State<'_, MihomoManager>,
url: String,
name: String,
) -> Result<ProfileMeta, String> {
state.import_profile(&url, &name).await
}
#[tauri::command]
#[specta::specta]
pub async fn proxy_update_profile(
state: State<'_, MihomoManager>,
id: String,
) -> Result<ProfileMeta, String> {
state.update_profile(&id).await
}
#[tauri::command]
#[specta::specta]
pub fn proxy_delete_profile(
state: State<'_, MihomoManager>,
id: String,
) -> Result<(), String> {
state.delete_profile(&id)
}
#[tauri::command]
#[specta::specta]
pub fn proxy_activate_profile(
state: State<'_, MihomoManager>,
id: String,
) -> Result<(), String> {
state.activate_profile(&id)
}
// ---------- 系统代理 ----------
#[tauri::command]
#[specta::specta]
pub fn proxy_set_system_proxy(
state: State<'_, MihomoManager>,
) -> Result<(), String> {
let settings = state.load_settings();
let addr = format!("127.0.0.1:{}", settings.mixed_port);
set_system_proxy_windows(&addr)?;
let mut settings = settings;
settings.system_proxy = true;
state.save_settings(&settings)
}
#[tauri::command]
#[specta::specta]
pub fn proxy_clear_system_proxy(
state: State<'_, MihomoManager>,
) -> Result<(), String> {
clear_system_proxy_windows()?;
let mut settings = state.load_settings();
settings.system_proxy = false;
state.save_settings(&settings)
}
#[tauri::command]
#[specta::specta]
pub fn proxy_get_system_proxy() -> bool {
get_system_proxy_windows()
}
src-tauri/src/mihomo_manager/kernel.rs
+459
View File
@@ -0,0 +1,459 @@
//! 内核（mihomo.exe）安装 / 更新 / 版本查询。
//! 子模块通过 `impl super::MihomoManager` 为管理器追加方法，可访问父模块私有字段。
use futures_util::StreamExt;
use std::fs;
use std::io::{Read, Write};
use std::path::PathBuf;
use tauri::{AppHandle, Emitter, Manager};
use crate::constants::events::KERNEL_INSTALL_PROGRESS;
use super::{InstallProgress, KernelInfo, KernelUpdateInfo, MihomoManager};
impl MihomoManager {
// ---------- 内核 ----------
pub fn kernel_info(&self) -> KernelInfo {
let path = self.kernel_path();
let exists = path.exists();
let version = if exists {
let mut cmd = std::process::Command::new(&path);
cmd.arg("-v");
// 隐藏控制台窗口（mihomo.exe -v 也会弹窗）
crate::process_manager::setup_creation_flags(&mut cmd);
// 重定向 stdio，避免继承主进程控制台
cmd.stdout(std::process::Stdio::piped())
.stderr(std::process::Stdio::null())
.stdin(std::process::Stdio::null());
cmd.output()
.ok()
.and_then(|o| String::from_utf8(o.stdout).ok())
.and_then(|s| {
s.lines()
.find(|l| l.contains("Mihomo Meta") || l.contains("mihomo"))
.map(|l| l.trim().to_string())
})
} else {
None
};
KernelInfo {
path: path.to_string_lossy().to_string(),
exists,
version,
}
}
/// 确保内核就位：若 cores/ 无内核，尝试从 resource 目录复制
pub fn prepare_kernel(&self, app: &AppHandle) -> Result<KernelInfo, String> {
let kernel = self.kernel_path();
if !kernel.exists() {
if let Ok(res) = app.path().resolve("binaries/mihomo.exe", tauri::path::BaseDirectory::Resource) {
if res.exists() {
fs::copy(&res, &kernel).map_err(|e| format!("复制内核失败: {}", e))?;
}
}
}
Ok(self.kernel_info())
}
/// 检查 GitHub 上的最新 mihomo 版本
/// 策略：优先用 API（能拿到完整资产列表，命名变化时更健壮），
/// 失败时回退到重定向解析（不受 API rate limit 限制）
pub async fn check_kernel_update(&self) -> Result<KernelUpdateInfo, String> {
match self.fetch_latest_via_api().await {
Ok(info) => Ok(info),
Err(api_err) => {
crate::logger::log_warn("mihomo", &format!("API 查询失败，回退到重定向解析: {}", api_err));
self.fetch_latest_via_redirect().await
}
}
}
/// 通过 GitHub API 查询最新版本（受 rate limit 限制：未认证 60次/小时/IP）
async fn fetch_latest_via_api(&self) -> Result<KernelUpdateInfo, String> {
let resp = self
.client
.get("https://api.github.com/repos/MetaCubeX/mihomo/releases/latest")
.header("User-Agent", "thing-app")
.timeout(std::time::Duration::from_secs(15))
.send()
.await
.map_err(|e| format!("请求 GitHub API 失败: {}", e))?;
let status = resp.status();
if !status.is_success() {
let body = resp.text().await.unwrap_or_default();
// 按字符边界截断，避免切在多字节字符中间导致 panic
let preview: String = body.chars().take(300).collect();
return Err(format!(
"GitHub API 返回 HTTP {}：{}{}",
status.as_u16(),
preview,
if body.chars().count() > 300 { "..." } else { "" }
));
}
let resp: serde_json::Value = resp
.json()
.await
.map_err(|e| format!("解析 GitHub 响应失败: {}", e))?;
let latest_version = resp
.get("tag_name")
.and_then(|v| v.as_str())
.unwrap_or("unknown")
.to_string();
let assets_arr = resp.get("assets").and_then(|a| a.as_array());
// 收集所有 windows amd64 zip 候选资产（排除 compatible/arm64/386）
let candidates: Vec<(String, String)> = assets_arr
.map(|assets| {
assets.iter().filter_map(|asset| {
let name = asset.get("name")?.as_str()?;
let url = asset.get("browser_download_url")?.as_str()?;
if name.starts_with("mihomo-windows-amd64-")
&& name.ends_with(".zip")
&& !name.contains("compatible")
&& !name.contains("arm64")
&& !name.contains("386")
{
Some((name.to_string(), url.to_string()))
} else {
None
}
}).collect()
})
.unwrap_or_default();
// 按优先级匹配：v3 标准 > v3-go124 > v3-go123 > v3 其他 > v2 > v1 > 旧命名
let download_url = candidates
.iter().find(|(n, _)| n.contains("-v3-v") && !n.contains("-go"))
.or_else(|| candidates.iter().find(|(n, _)| n.contains("-v3-go124-")))
.or_else(|| candidates.iter().find(|(n, _)| n.contains("-v3-go123-")))
.or_else(|| candidates.iter().find(|(n, _)| n.contains("-v3-go")))
.or_else(|| candidates.iter().find(|(n, _)| n.contains("-v2-v")))
.or_else(|| candidates.iter().find(|(n, _)| n.contains("-v1-v")))
.or_else(|| candidates.iter().find(|(n, _)| {
!n.contains("-v1-") && !n.contains("-v2-") && !n.contains("-v3-")
}))
.map(|(_, u)| u.clone())
.ok_or_else(|| {
let candidates_str = candidates.iter()
.map(|(n, _)| n.as_str())
.collect::<Vec<_>>()
.join(", ");
format!("API 未找到适用的 Windows amd64 内核资产。候选：[{}]", candidates_str)
})?;
Ok(self.build_update_info(latest_version, download_url))
}
/// 通过 releases/latest 重定向解析版本号（不受 API rate limit 限制）
/// 访问 https://github.com/MetaCubeX/mihomo/releases/latest 会 302 到
/// https://github.com/MetaCubeX/mihomo/releases/tag/v1.19.13
/// 从最终 URL 提取版本号后，按 v1.19+ 稳定命名规则构造下载 URL
async fn fetch_latest_via_redirect(&self) -> Result<KernelUpdateInfo, String> {
let resp = self
.client
.get("https://github.com/MetaCubeX/mihomo/releases/latest")
.header("User-Agent", "thing-app")
.timeout(std::time::Duration::from_secs(15))
.send()
.await
.map_err(|e| format!("请求 GitHub releases 页面失败: {}", e))?;
// 从重定向后的最终 URL 提取版本号
let final_url = resp.url().to_string();
let latest_version = final_url
.rsplit('/')
.next()
.filter(|s| s.starts_with('v') && s.chars().any(|c| c == '.'))
.ok_or_else(|| format!("无法从重定向 URL 提取版本号: {}", final_url))?
.to_string();
// 构造下载 URL：mihomo v1.19+ 稳定使用 -v3-vX.X.X.zip 命名（CPU level v3）
let download_url = format!(
"https://github.com/MetaCubeX/mihomo/releases/download/{}/mihomo-windows-amd64-v3-{}.zip",
latest_version, latest_version
);
crate::logger::log_info(
"mihomo",
&format!("重定向解析成功: version={}, url={}", latest_version, download_url),
);
Ok(self.build_update_info(latest_version, download_url))
}
/// 根据最新版本和下载 URL 构造更新信息（含当前版本比较）
fn build_update_info(&self, latest_version: String, download_url: String) -> KernelUpdateInfo {
let current = self.kernel_info().version;
let has_update = match &current {
Some(c) => {
let cur_ver = c
.split_whitespace()
.find(|s| s.starts_with('v') && s.chars().filter(|c| *c == '.').count() >= 2)
.unwrap_or("");
cur_ver != latest_version && !latest_version.is_empty()
}
None => true,
};
KernelUpdateInfo {
current_version: current,
latest_version,
download_url,
has_update,
}
}
/// 下载并安装内核（首次安装与更新共用此方法）
/// - mirror_prefix: 用户选择的镜像源前缀（空串=直连 GitHub）
/// - 流式下载：实时推送下载进度到前端
/// - zip crate 解压：替代 PowerShell，避免执行策略问题
/// - 备份旧内核：替换前备份为 .bak
/// 任何阶段失败都会 emit error 事件，避免前端进度卡在初始状态
pub async fn install_kernel(&self, app: &AppHandle, mirror_prefix: String) -> Result<KernelInfo, String> {
let result = self.install_kernel_inner(app, mirror_prefix).await;
if let Err(ref e) = result {
let _ = app.emit(
KERNEL_INSTALL_PROGRESS,
InstallProgress {
stage: "error".into(),
percent: 0,
downloaded_bytes: 0,
total_bytes: None,
message: e.clone(),
},
);
}
result
}
async fn install_kernel_inner(&self, app: &AppHandle, mirror_prefix: String) -> Result<KernelInfo, String> {
let info = self.check_kernel_update().await?;
let zip_path = self.cores_dir().join("mihomo-update.zip");
let extract_dir = self.cores_dir().join("mihomo-update-tmp");
// 拼接用户选择的镜像源 URL
let url = if mirror_prefix.is_empty() {
info.download_url.clone()
} else {
format!("{}{}", mirror_prefix, info.download_url)
};
let label = if mirror_prefix.is_empty() { "GitHub 直连".to_string() } else { mirror_prefix.clone() };
let _ = app.emit(
KERNEL_INSTALL_PROGRESS,
InstallProgress {
stage: "downloading".into(),
percent: 0,
downloaded_bytes: 0,
total_bytes: None,
message: format!("正在下载：{}", label),
},
);
// 单源下载（用户已选择）
match self.download_with_progress(app, &url, &zip_path).await {
Ok(()) => {}
Err(e) => {
let msg = format!("下载失败（{}）：{}", label, e);
let _ = app.emit(
KERNEL_INSTALL_PROGRESS,
InstallProgress {
stage: "error".into(),
percent: 0,
downloaded_bytes: 0,
total_bytes: None,
message: msg.clone(),
},
);
let _ = fs::remove_file(&zip_path);
return Err(msg);
}
}
// 解压阶段
let _ = app.emit(
KERNEL_INSTALL_PROGRESS,
InstallProgress {
stage: "extracting".into(),
percent: 92,
downloaded_bytes: 0,
total_bytes: None,
message: "正在解压...".into(),
},
);
if extract_dir.exists() {
fs::remove_dir_all(&extract_dir).ok();
}
fs::create_dir_all(&extract_dir).map_err(|e| e.to_string())?;
if let Err(e) = self.extract_zip(&zip_path, &extract_dir) {
let _ = app.emit(
KERNEL_INSTALL_PROGRESS,
InstallProgress {
stage: "error".into(),
percent: 0,
downloaded_bytes: 0,
total_bytes: None,
message: format!("解压失败：{}", e),
},
);
return Err(e);
}
// 在解压目录中递归查找 exe 文件
// mihomo zip 内的 exe 名字通常与 zip 同名（如 mihomo-windows-amd64-v3-v1.19.13.exe），
// 不是固定的 mihomo.exe，所以查找唯一的 .exe 文件即可
let new_exe = self
.find_exe_in_dir(&extract_dir)
.ok_or_else(|| "解压后未找到任何 .exe 文件".to_string())?;
// 替换阶段
let _ = app.emit(
KERNEL_INSTALL_PROGRESS,
InstallProgress {
stage: "replacing".into(),
percent: 96,
downloaded_bytes: 0,
total_bytes: None,
message: "正在安装...".into(),
},
);
let kernel = self.kernel_path();
if kernel.exists() {
let bak = self.cores_dir().join("mihomo.exe.bak");
fs::remove_file(&bak).ok();
fs::rename(&kernel, &bak).map_err(|e| format!("备份旧内核失败: {}", e))?;
}
fs::rename(&new_exe, &kernel).map_err(|e| format!("替换内核失败: {}", e))?;
// 清理临时文件
fs::remove_file(&zip_path).ok();
fs::remove_dir_all(&extract_dir).ok();
let final_info = self.kernel_info();
let _ = app.emit(
KERNEL_INSTALL_PROGRESS,
InstallProgress {
stage: "done".into(),
percent: 100,
downloaded_bytes: 0,
total_bytes: None,
message: format!(
"安装完成 ({})",
final_info.version.as_deref().unwrap_or("unknown")
),
},
);
Ok(final_info)
}
/// 流式下载并实时推送进度事件
async fn download_with_progress(
&self,
app: &AppHandle,
url: &str,
dest: &PathBuf,
) -> Result<(), String> {
let resp = self
.client
.get(url)
.header("User-Agent", "thing-app")
.timeout(std::time::Duration::from_secs(30))
.send()
.await
.map_err(|e| format!("请求失败: {}", e))?;
if !resp.status().is_success() {
return Err(format!("HTTP {}", resp.status()));
}
let total = resp.content_length();
let mut stream = resp.bytes_stream();
let mut file = fs::File::create(dest).map_err(|e| format!("创建文件失败: {}", e))?;
let mut downloaded: u64 = 0;
let mut last_percent: u8 = 0;
while let Some(chunk) = stream.next().await {
let chunk = chunk.map_err(|e| format!("读取流失败: {}", e))?;
file.write_all(&chunk).map_err(|e| format!("写入文件失败: {}", e))?;
downloaded += chunk.len() as u64;
// 下载占总进度的 0-90%
let percent = match total {
Some(t) if t > 0 => ((downloaded as f64 / t as f64) * 90.0) as u8,
_ => 0,
};
// 仅在变化超过 1% 时 emit，避免事件轰炸
if percent >= last_percent + 1 {
last_percent = percent;
let _ = app.emit(
KERNEL_INSTALL_PROGRESS,
InstallProgress {
stage: "downloading".into(),
percent,
downloaded_bytes: downloaded,
total_bytes: total,
message: format!("已下载 {:.2} MB", downloaded as f64 / 1024.0 / 1024.0),
},
);
}
}
file.flush().map_err(|e| format!("flush 失败: {}", e))?;
Ok(())
}
/// 用 zip crate 解压（纯 Rust，避免 PowerShell 执行策略问题）
fn extract_zip(&self, zip_path: &PathBuf, dest: &PathBuf) -> Result<(), String> {
let file = fs::File::open(zip_path).map_err(|e| format!("打开 zip 失败: {}", e))?;
let mut archive = zip::ZipArchive::new(file).map_err(|e| format!("读取 zip 失败: {}", e))?;
for i in 0..archive.len() {
let mut entry = archive
.by_index(i)
.map_err(|e| format!("读取条目失败: {}", e))?;
let outpath = match entry.enclosed_name() {
Some(p) => dest.join(p),
None => continue,
};
if entry.is_dir() {
fs::create_dir_all(&outpath).map_err(|e| e.to_string())?;
} else {
if let Some(parent) = outpath.parent() {
fs::create_dir_all(parent).map_err(|e| e.to_string())?;
}
let mut outfile = fs::File::create(&outpath).map_err(|e| e.to_string())?;
let mut buf = [0u8; 8192];
loop {
let n = entry.read(&mut buf).map_err(|e| e.to_string())?;
if n == 0 {
break;
}
outfile.write_all(&buf[..n]).map_err(|e| e.to_string())?;
}
}
}
Ok(())
}
/// 递归查找目录中的 .exe 文件
/// mihomo zip 内的 exe 名字不固定（可能含版本号、CPU level 等），
/// 策略：收集所有 .exe，优先返回名字含 "mihomo" 的，否则返回第一个
fn find_exe_in_dir(&self, dir: &PathBuf) -> Option<PathBuf> {
let mut exes: Vec<PathBuf> = Vec::new();
self.collect_exes(dir, &mut exes);
if exes.is_empty() {
return None;
}
// 优先选名字含 mihomo 的
exes.iter()
.find(|p| p.file_name().and_then(|n| n.to_str()).map(|s| s.to_lowercase().contains("mihomo")).unwrap_or(false))
.or_else(|| exes.first())
.cloned()
}
fn collect_exes(&self, dir: &PathBuf, out: &mut Vec<PathBuf>) {
if let Ok(entries) = fs::read_dir(dir) {
for entry in entries.flatten() {
let path = entry.path();
if path.is_dir() {
self.collect_exes(&path, out);
} else if path.extension().and_then(|e| e.to_str()).map(|s| s.eq_ignore_ascii_case("exe")).unwrap_or(false) {
out.push(path);
}
}
}
}
}
src-tauri/src/mihomo_manager/mod.rs
+436
View File
@@ -0,0 +1,436 @@
//! 代理模块（mihomo 管理器）：按功能域拆分子模块。
//!
//! - [`MihomoManager`]：核心状态与目录/设置/配置/API 方法
//! - [`kernel`]：内核安装与更新
//! - [`profiles`]：订阅管理
//! - [`system_proxy`]：Windows 系统代理开关
//! - [`commands`]：Tauri 命令层
mod commands;
mod kernel;
mod profiles;
mod pseudo;
mod system_proxy;
mod types;
pub use pseudo::is_pseudo_node;
pub use types::{InstallProgress, KernelInfo, KernelUpdateInfo, ProfileMeta, ProxySettings, ProxyStatus};
pub use commands::{
proxy_activate_profile, proxy_check_kernel_update, proxy_clear_system_proxy, proxy_close_connection,
proxy_delete_profile, proxy_get_connections, proxy_get_proxies, proxy_get_settings, proxy_get_system_proxy,
proxy_import_profile, proxy_install_kernel, proxy_kernel_info, proxy_patch_configs, proxy_restart,
proxy_save_settings, proxy_select_proxy, proxy_set_system_proxy, proxy_start, proxy_status, proxy_stop,
proxy_test_delay, proxy_update_kernel, proxy_update_profile, proxy_version,
};
use reqwest::Client;
use serde_yaml::Value as YamlValue;
use std::fs;
use std::path::PathBuf;
use std::sync::Mutex;
use std::time::{Duration, Instant};
use tauri::AppHandle;
use crate::process_manager::{ProcessManager, StartProcessParams};
// ===================== MihomoManager =====================
/// settings 内存缓存条目（短时复用，避免高频状态轮询反复读盘）
struct SettingsCacheEntry {
read_at: Instant,
settings: ProxySettings,
}
pub struct MihomoManager {
root: PathBuf,
client: Client,
settings_cache: Mutex<Option<SettingsCacheEntry>>,
}
impl MihomoManager {
pub fn new(app_data_dir: PathBuf) -> Self {
let root = app_data_dir.join("proxy");
for d in ["cores", "mihomo", "profiles", "logs"] {
fs::create_dir_all(root.join(d)).ok();
}
Self {
root,
client: Client::builder()
// 默认 30s 兜底超时，防止遗漏显式 timeout 的请求永久悬挂
.timeout(std::time::Duration::from_secs(30))
.build()
.unwrap_or_else(|_| Client::new()),
settings_cache: Mutex::new(None),
}
}
fn cores_dir(&self) -> PathBuf {
self.root.join("cores")
}
pub fn kernel_path(&self) -> PathBuf {
self.cores_dir().join("mihomo.exe")
}
fn mihomo_dir(&self) -> PathBuf {
self.root.join("mihomo")
}
fn config_path(&self) -> PathBuf {
self.mihomo_dir().join("config.yaml")
}
fn profiles_dir(&self) -> PathBuf {
self.root.join("profiles")
}
#[allow(dead_code)]
fn logs_dir(&self) -> PathBuf {
self.root.join("logs")
}
fn settings_path(&self) -> PathBuf {
self.root.join("settings.json")
}
// ---------- 设置 ----------
pub fn load_settings(&self) -> ProxySettings {
// 内存缓存：500ms 内复用（高频调用如状态轮询/测速避免反复读盘）
if let Ok(cache) = self.settings_cache.lock() {
if let Some(entry) = cache.as_ref() {
if entry.read_at.elapsed() < Duration::from_millis(500) {
return entry.settings.clone();
}
}
}
let mut settings = fs::read_to_string(self.settings_path())
.ok()
.and_then(|s| serde_json::from_str::<ProxySettings>(&s).ok())
.unwrap_or_default();
// 恢复机制：扫描磁盘 profile 文件，补全 settings.profiles
// 防止 settings.json 损坏（如反序列化失败被 default 覆盖）导致订阅丢失
if self.reconcile_profiles(&mut settings) {
let _ = self.save_settings(&settings);
}
// 刷新缓存
if let Ok(mut cache) = self.settings_cache.lock() {
*cache = Some(SettingsCacheEntry {
read_at: Instant::now(),
settings: settings.clone(),
});
}
settings
}
/// 扫描磁盘 profile 文件，补全 settings.profiles 中缺失的条目。
/// 返回 true 表示有变化需要保存。
fn reconcile_profiles(&self, settings: &mut ProxySettings) -> bool {
let mut changed = false;
let existing_ids: std::collections::HashSet<String> =
settings.profiles.iter().map(|p| p.id.clone()).collect();
if let Ok(entries) = fs::read_dir(self.profiles_dir()) {
for entry in entries.flatten() {
let path = entry.path();
if path.extension().and_then(|e| e.to_str()) != Some("yaml") {
continue;
}
let Some(id) = path
.file_stem()
.and_then(|s| s.to_str())
.map(|s| s.to_string())
else {
continue;
};
if existing_ids.contains(&id) {
continue;
}
let size = fs::metadata(&path).map(|m| m.len()).unwrap_or(0);
let updated_at = fs::metadata(&path)
.and_then(|m| m.modified())
.ok()
.and_then(|t| t.duration_since(std::time::UNIX_EPOCH).ok())
.and_then(|d| chrono::DateTime::from_timestamp(d.as_secs() as i64, 0))
.map(|dt| dt.format("%Y-%m-%d %H:%M:%S").to_string())
.unwrap_or_default();
settings.profiles.push(ProfileMeta {
added_at: updated_at.clone(),
id: id.clone(),
name: id,
url: String::new(),
updated_at,
size,
});
changed = true;
}
}
// 如果 currentProfile 为 null 但有 profile，设置为第一个
if settings.current_profile.is_none() && !settings.profiles.is_empty() {
settings.current_profile = Some(settings.profiles[0].id.clone());
changed = true;
}
changed
}
pub fn save_settings(&self, settings: &ProxySettings) -> Result<(), String> {
let s = serde_json::to_string_pretty(settings).map_err(|e| e.to_string())?;
fs::write(self.settings_path(), s).map_err(|e| e.to_string())?;
// 写盘成功后同步刷新内存缓存（避免旧缓存被后续 load_settings 复用）
if let Ok(mut cache) = self.settings_cache.lock() {
*cache = Some(SettingsCacheEntry {
read_at: Instant::now(),
settings: settings.clone(),
});
}
Ok(())
}
// ---------- 配置生成 ----------
/// 合并 profile + 控制器设置，生成运行时 config.yaml
pub fn generate_config(&self) -> Result<(), String> {
let settings = self.load_settings();
let mut value: YamlValue = if let Some(id) = &settings.current_profile {
let path = self.profiles_dir().join(format!("{}.yaml", id));
if path.exists() {
let content = fs::read_to_string(&path).map_err(|e| e.to_string())?;
serde_yaml::from_str(&content).unwrap_or(YamlValue::Mapping(serde_yaml::Mapping::new()))
} else {
YamlValue::Mapping(serde_yaml::Mapping::new())
}
} else {
YamlValue::Mapping(serde_yaml::Mapping::new())
};
if !value.is_mapping() {
value = YamlValue::Mapping(serde_yaml::Mapping::new());
}
let m = value.as_mapping_mut().unwrap();
m.insert(YamlValue::String("mixed-port".into()), YamlValue::Number(settings.mixed_port.into()));
m.insert(
YamlValue::String("external-controller".into()),
YamlValue::String(settings.external_controller.clone()),
);
if !settings.secret.is_empty() {
m.insert(YamlValue::String("secret".into()), YamlValue::String(settings.secret.clone()));
}
m.insert(YamlValue::String("mode".into()), YamlValue::String(settings.mode.clone()));
m.insert(
YamlValue::String("log-level".into()),
YamlValue::String(settings.log_level.clone()),
);
m.insert(YamlValue::String("allow-lan".into()), YamlValue::Bool(settings.allow_lan));
// 日志写入文件，便于排查问题
let log_file = self.logs_dir().join("mihomo.log");
m.insert(
YamlValue::String("log-file".into()),
YamlValue::String(log_file.to_string_lossy().to_string()),
);
// Geo 数据库下载源（使用 jsdelivr 国内可访问镜像，避免无代理时 GitHub 超时）
let mut geox = serde_yaml::Mapping::new();
geox.insert(
YamlValue::String("mmdb".into()),
YamlValue::String("https://cdn.jsdelivr.net/gh/MetaCubeX/meta-rules-dat@release/country.mmdb".into()),
);
geox.insert(
YamlValue::String("geosite".into()),
YamlValue::String("https://cdn.jsdelivr.net/gh/MetaCubeX/meta-rules-dat@release/geosite.dat".into()),
);
geox.insert(
YamlValue::String("asn".into()),
YamlValue::String("https://cdn.jsdelivr.net/gh/xishang0128/bdg@master/GeoLite2-ASN.mmdb".into()),
);
m.insert(YamlValue::String("geox-url".into()), YamlValue::Mapping(geox));
let yaml = serde_yaml::to_string(&value).map_err(|e| e.to_string())?;
fs::write(self.config_path(), yaml).map_err(|e| e.to_string())?;
Ok(())
}
/// 构建启动 mihomo 所需的进程参数（含 prepare + config 生成）
pub fn prepare_for_start(&self, app: &AppHandle) -> Result<StartProcessParams, String> {
let info = self.prepare_kernel(app)?;
if !info.exists {
return Err(format!(
"mihomo 内核未安装。请将 mihomo.exe 放置到 src-tauri/binaries/ 后重新运行，或直接放到：\n{}",
self.cores_dir().to_string_lossy()
));
}
self.generate_config()?;
Ok(StartProcessParams {
id: "proxy".into(),
executable: self.kernel_path().to_string_lossy().to_string(),
args: vec![
"-d".into(),
self.mihomo_dir().to_string_lossy().to_string(),
"-f".into(),
self.config_path().to_string_lossy().to_string(),
],
cwd: Some(self.mihomo_dir().to_string_lossy().to_string()),
name: "mihomo".into(),
restart_on_crash: true,
max_restarts: 3,
})
}
/// 应用启动时检查是否需要自动启动 mihomo 和系统代理
pub fn auto_start_on_launch(&self, app: &AppHandle, pm: &ProcessManager) {
let settings = self.load_settings();
if !settings.auto_start {
return;
}
match self.prepare_for_start(app) {
Ok(params) => {
if let Err(e) = pm.start(params) {
crate::logger::log_error("mihomo", &format!("自动启动失败: {}", e));
} else if settings.auto_system_proxy {
// 启动成功后开启系统代理
let addr = format!("127.0.0.1:{}", settings.mixed_port);
let _ = system_proxy::set_system_proxy_windows(&addr);
let mut s = settings;
s.system_proxy = true;
let _ = self.save_settings(&s);
}
}
Err(e) => {
crate::logger::log_warn("mihomo", &format!("自动启动跳过: {}", e));
}
}
}
/// 应用退出时清理：关闭系统代理
pub fn cleanup_on_exit(&self) {
let settings = self.load_settings();
if settings.system_proxy || settings.auto_system_proxy {
let _ = system_proxy::clear_system_proxy_windows();
}
}
// ---------- mihomo API ----------
fn api_url(&self, path: &str) -> String {
let s = self.load_settings();
format!("http://{}{}", s.external_controller, path)
}
fn api_bearer(&self) -> Option<String> {
let s = self.load_settings();
if s.secret.is_empty() {
None
} else {
Some(format!("Bearer {}", s.secret))
}
}
async fn api_get(&self, path: &str) -> Result<serde_json::Value, String> {
let mut req = self.client.get(self.api_url(path));
if let Some(b) = self.api_bearer() {
req = req.header("Authorization", b);
}
// 显式超时：mihomo 卡死/未响应时命令立即返回，避免前端按钮永久转圈
let resp = req
.timeout(std::time::Duration::from_secs(10))
.send()
.await
.map_err(|e| format!("请求 mihomo 失败: {}", e))?;
if !resp.status().is_success() {
return Err(format!("mihomo API 错误: {}", resp.status()));
}
resp.json().await.map_err(|e| e.to_string())
}
async fn api_request(
&self,
method: reqwest::Method,
path: &str,
body: Option<serde_json::Value>,
) -> Result<(), String> {
let mut req = self.client.request(method, self.api_url(path));
if let Some(b) = self.api_bearer() {
req = req.header("Authorization", b);
}
if let Some(b) = body {
req = req.json(&b);
}
let resp = req
.timeout(std::time::Duration::from_secs(10))
.send()
.await
.map_err(|e| format!("请求 mihomo 失败: {}", e))?;
if !resp.status().is_success() {
return Err(format!("mihomo API 错误: {}", resp.status()));
}
Ok(())
}
pub async fn get_version(&self) -> Result<serde_json::Value, String> {
self.api_get("/version").await
}
pub async fn get_proxies(&self) -> Result<serde_json::Value, String> {
self.api_get("/proxies").await
}
pub async fn select_proxy(&self, group: &str, name: &str) -> Result<(), String> {
self.api_request(
reqwest::Method::PUT,
&format!("/proxies/{}", url_encode(group)),
Some(serde_json::json!({ "name": name })),
)
.await
}
pub async fn test_delay(&self, name: &str, url: &str, timeout: u32) -> Result<u32, String> {
let path = format!(
"/proxies/{}/delay?timeout={}&url={}",
url_encode(name),
timeout,
url_encode(url)
);
let v = self.api_get(&path).await?;
v.get("delay")
.and_then(|d| d.as_u64())
.map(|d| d as u32)
.ok_or_else(|| {
v.get("message")
.and_then(|m| m.as_str())
.map(|s| s.to_string())
.unwrap_or_else(|| "测速失败".into())
})
}
#[allow(dead_code)]
pub async fn get_rules(&self) -> Result<serde_json::Value, String> {
self.api_get("/rules").await
}
pub async fn get_connections(&self) -> Result<serde_json::Value, String> {
self.api_get("/connections").await
}
pub async fn close_connection(&self, id: &str) -> Result<(), String> {
self.api_request(
reqwest::Method::DELETE,
&format!("/connections/{}", url_encode(id)),
None,
)
.await
}
pub async fn patch_configs(&self, body: serde_json::Value) -> Result<(), String> {
self.api_request(reqwest::Method::PATCH, "/configs", Some(body)).await
}
}
fn url_encode(s: &str) -> String {
// 仅对路径段做最小编码，避免引入额外依赖
let mut out = String::with_capacity(s.len());
for b in s.bytes() {
match b {
b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' | b'~' => {
out.push(b as char);
}
_ => out.push_str(&format!("%{:02X}", b)),
}
}
out
}
src-tauri/src/mihomo_manager/profiles.rs
+112
View File
@@ -0,0 +1,112 @@
//! 订阅（profile）管理：导入 / 更新 / 删除 / 激活。
use chrono::Local;
use std::fs;
use super::{MihomoManager, ProfileMeta};
impl MihomoManager {
// ---------- 订阅管理 ----------
pub async fn import_profile(&self, url: &str, name: &str) -> Result<ProfileMeta, String> {
// 先读取当前 settings（此时新 profile 文件还未写入，reconcile 不会误添加）
let mut settings = self.load_settings();
let resp = self
.client
.get(url)
.header("User-Agent", "clash.meta/thing")
.timeout(std::time::Duration::from_secs(30))
.send()
.await
.map_err(|e| format!("下载订阅失败: {}", e))?;
if !resp.status().is_success() {
return Err(format!("订阅下载失败: HTTP {}", resp.status()));
}
let content = resp.text().await.map_err(|e| e.to_string())?;
if !content.contains("proxies") && !content.contains("Proxy") {
return Err("订阅内容不像有效的 Clash/mihomo 配置".into());
}
let id = format!("profile-{}", Local::now().format("%Y%m%d%H%M%S"));
let path = self.profiles_dir().join(format!("{}.yaml", id));
fs::write(&path, &content).map_err(|e| e.to_string())?;
let now = Local::now().format("%Y-%m-%d %H:%M:%S").to_string();
let meta = ProfileMeta {
id: id.clone(),
name: name.to_string(),
url: url.to_string(),
added_at: now.clone(),
updated_at: now,
size: content.len() as u64,
};
// 去重保护：避免 reconcile 已添加同 id（理论上不会，因为文件刚写入）
if !settings.profiles.iter().any(|p| p.id == id) {
settings.profiles.push(meta.clone());
}
if settings.current_profile.is_none() {
settings.current_profile = Some(id);
}
self.save_settings(&settings)?;
Ok(meta)
}
pub async fn update_profile(&self, id: &str) -> Result<ProfileMeta, String> {
let mut settings = self.load_settings();
let meta = settings
.profiles
.iter()
.find(|p| p.id == id)
.cloned()
.ok_or_else(|| "订阅不存在".to_string())?;
let resp = self
.client
.get(&meta.url)
.header("User-Agent", "clash.meta/thing")
.timeout(std::time::Duration::from_secs(30))
.send()
.await
.map_err(|e| format!("更新订阅失败: {}", e))?;
if !resp.status().is_success() {
return Err(format!("更新订阅失败: HTTP {}", resp.status()));
}
let content = resp.text().await.map_err(|e| e.to_string())?;
let path = self.profiles_dir().join(format!("{}.yaml", id));
fs::write(&path, &content).map_err(|e| e.to_string())?;
let now = Local::now().format("%Y-%m-%d %H:%M:%S").to_string();
let size = content.len() as u64;
if let Some(p) = settings.profiles.iter_mut().find(|p| p.id == id) {
p.updated_at = now.clone();
p.size = size;
}
self.save_settings(&settings)?;
Ok(ProfileMeta {
id: id.to_string(),
name: meta.name,
url: meta.url,
added_at: meta.added_at,
updated_at: now,
size,
})
}
pub fn delete_profile(&self, id: &str) -> Result<(), String> {
let path = self.profiles_dir().join(format!("{}.yaml", id));
fs::remove_file(&path).ok();
let mut settings = self.load_settings();
settings.profiles.retain(|p| p.id != id);
if settings.current_profile.as_deref() == Some(id) {
settings.current_profile = settings.profiles.first().map(|p| p.id.clone());
}
self.save_settings(&settings)?;
Ok(())
}
pub fn activate_profile(&self, id: &str) -> Result<(), String> {
let mut settings = self.load_settings();
if !settings.profiles.iter().any(|p| p.id == id) {
return Err("订阅不存在".into());
}
settings.current_profile = Some(id.to_string());
self.save_settings(&settings)?;
self.generate_config()
}
}
src-tauri/src/mihomo_manager/pseudo.rs
+71
View File
@@ -0,0 +1,71 @@
// ===================== 伪节点过滤 =====================
// 单点定义：托盘菜单、自动切换、前端显示过滤（ProxyModule.vue 的 PSEUDO_NODE_KEYWORDS
// 与之对应）统一引用此处，避免多份关键词列表漂移。
/// 订阅节点名中常见的营销/占位关键词（订阅页插入的非真实节点）
const PSEUDO_KEYWORDS: &[&str] = &[
"DIRECT",
"REJECT",
"PASS",
"COMPATIBLE",
"流量",
"套餐",
"到期",
"续费",
"官网",
"网站",
"刷新",
"更新",
"⭐",
"★",
"☆",
"✕",
"✖",
"×",
];
/// 判断节点名是否为伪节点（DIRECT/REJECT 等内置策略或订阅营销占位）
pub fn is_pseudo_node(name: &str) -> bool {
let upper = name.trim().to_uppercase();
if upper == "DIRECT" || upper == "REJECT" || upper == "PASS" || upper == "GLOBAL" {
return true;
}
PSEUDO_KEYWORDS.iter().any(|kw| name.contains(kw))
}
#[cfg(test)]
mod pseudo_node_tests {
use super::*;
#[test]
fn builtin_policies_are_pseudo() {
assert!(is_pseudo_node("DIRECT"));
assert!(is_pseudo_node("REJECT"));
assert!(is_pseudo_node("PASS"));
assert!(is_pseudo_node("GLOBAL"));
}
#[test]
fn case_insensitive_and_trims_whitespace() {
assert!(is_pseudo_node("direct"));
assert!(is_pseudo_node(" Reject "));
}
#[test]
fn marketing_keywords_are_pseudo() {
assert!(is_pseudo_node("香港流量套餐"));
assert!(is_pseudo_node("官网专线"));
assert!(is_pseudo_node("VIP到期续费"));
assert!(is_pseudo_node("每月更新"));
assert!(is_pseudo_node("★香港节点"));
}
#[test]
fn real_nodes_are_not_pseudo() {
assert!(!is_pseudo_node("HK-01"));
assert!(!is_pseudo_node("美国洛杉矶 01"));
assert!(!is_pseudo_node("JP Tokyo 2G"));
assert!(!is_pseudo_node(""));
assert!(!is_pseudo_node("Node-2024"));
}
}
src-tauri/src/mihomo_manager/system_proxy.rs
+92
View File
@@ -0,0 +1,92 @@
//! Windows 系统代理开关。
use super::MihomoManager;
// ===================== 系统代理（Windows） =====================
#[cfg(windows)]
pub(crate) fn set_system_proxy_windows(addr: &str) -> Result<(), String> {
use winreg::enums::*;
use winreg::RegKey;
let hkcu = RegKey::predef(HKEY_CURRENT_USER);
let (settings, _) = hkcu
.create_subkey("Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings")
.map_err(|e| e.to_string())?;
settings
.set_value("ProxyEnable", &1u32)
.map_err(|e| e.to_string())?;
settings
.set_value("ProxyServer", &addr)
.map_err(|e| e.to_string())?;
notify_wininet();
Ok(())
}
#[cfg(windows)]
pub(crate) fn clear_system_proxy_windows() -> Result<(), String> {
use winreg::enums::*;
use winreg::RegKey;
let hkcu = RegKey::predef(HKEY_CURRENT_USER);
let (settings, _) = hkcu
.create_subkey("Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings")
.map_err(|e| e.to_string())?;
settings
.set_value("ProxyEnable", &0u32)
.map_err(|e| e.to_string())?;
notify_wininet();
Ok(())
}
#[cfg(windows)]
pub(crate) fn get_system_proxy_windows() -> bool {
use winreg::enums::*;
use winreg::RegKey;
let hkcu = RegKey::predef(HKEY_CURRENT_USER);
hkcu.open_subkey("Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings")
.ok()
.and_then(|s| s.get_value::<u32, _>("ProxyEnable").ok())
.map(|v| v != 0)
.unwrap_or(false)
}
#[cfg(windows)]
fn notify_wininet() {
unsafe {
use windows_sys::Win32::Networking::WinInet::*;
InternetSetOptionW(std::ptr::null(), INTERNET_OPTION_SETTINGS_CHANGED, std::ptr::null(), 0);
InternetSetOptionW(std::ptr::null(), INTERNET_OPTION_REFRESH, std::ptr::null(), 0);
}
}
#[cfg(not(windows))]
pub(crate) fn set_system_proxy_windows(_addr: &str) -> Result<(), String> {
Err("系统代理仅支持 Windows".into())
}
#[cfg(not(windows))]
pub(crate) fn clear_system_proxy_windows() -> Result<(), String> {
Err("系统代理仅支持 Windows".into())
}
#[cfg(not(windows))]
pub(crate) fn get_system_proxy_windows() -> bool {
false
}
impl MihomoManager {
/// 开启系统代理（托盘菜单调用）
pub fn enable_system_proxy(&self) -> Result<(), String> {
let settings = self.load_settings();
let addr = format!("127.0.0.1:{}", settings.mixed_port);
set_system_proxy_windows(&addr)?;
let mut s = settings;
s.system_proxy = true;
self.save_settings(&s)
}
/// 关闭系统代理（托盘菜单调用）
pub fn disable_system_proxy(&self) -> Result<(), String> {
clear_system_proxy_windows()?;
let mut s = self.load_settings();
s.system_proxy = false;
self.save_settings(&s)
}
}
src-tauri/src/mihomo_manager/types.rs
+140
View File
@@ -0,0 +1,140 @@
// ===================== 数据结构 =====================
// 代理模块的设置 / 订阅元信息 / 内核信息 / 安装进度等共享类型。
use serde::{Deserialize, Serialize};
use specta::Type;
#[derive(Serialize, Deserialize, Clone, Type)]
#[serde(rename_all = "camelCase")]
pub struct ProxySettings {
#[serde(default = "default_mixed_port")]
pub mixed_port: u16,
#[serde(default = "default_external_controller")]
pub external_controller: String,
#[serde(default)]
pub secret: String,
#[serde(default = "default_mode")]
pub mode: String,
#[serde(default = "default_log_level")]
pub log_level: String,
#[serde(default)]
pub allow_lan: bool,
#[serde(default)]
pub system_proxy: bool,
#[serde(default)]
pub auto_start: bool,
#[serde(default)]
pub auto_system_proxy: bool,
#[serde(default)]
pub current_profile: Option<String>,
#[serde(default)]
pub profiles: Vec<ProfileMeta>,
#[serde(default)]
pub auto_switch_enabled: bool,
#[serde(default = "default_auto_switch_interval")]
pub auto_switch_interval: u32,
#[serde(default)]
pub auto_switch_group: String,
#[serde(default)]
pub auto_switch_region: String,
/// 内核下载镜像源列表（前缀拼接到 GitHub URL 前）。
/// 空字符串 = 直连 GitHub，其余为镜像站前缀（含尾斜杠）。
#[serde(default = "default_kernel_mirrors")]
pub kernel_mirrors: Vec<String>,
}
fn default_mixed_port() -> u16 { 7890 }
fn default_external_controller() -> String { "127.0.0.1:9090".into() }
fn default_mode() -> String { "rule".into() }
fn default_log_level() -> String { "info".into() }
fn default_auto_switch_interval() -> u32 { 5 }
/// 默认镜像源：空串=直连 GitHub 优先，后续为公益镜像（按稳定性排序）
fn default_kernel_mirrors() -> Vec<String> {
vec![
String::new(),
"https://ghproxy.net/".into(),
"https://gh-proxy.com/".into(),
"https://ghfast.top/".into(),
]
}
impl Default for ProxySettings {
fn default() -> Self {
Self {
mixed_port: 7890,
external_controller: "127.0.0.1:9090".into(),
secret: String::new(),
mode: "rule".into(),
log_level: "info".into(),
allow_lan: false,
system_proxy: false,
auto_start: false,
auto_system_proxy: false,
current_profile: None,
profiles: Vec::new(),
auto_switch_enabled: false,
auto_switch_interval: 5,
auto_switch_group: String::new(),
auto_switch_region: String::new(),
kernel_mirrors: default_kernel_mirrors(),
}
}
}
#[derive(Serialize, Deserialize, Clone, Type)]
#[serde(rename_all = "camelCase")]
pub struct ProfileMeta {
#[serde(default)]
pub id: String,
#[serde(default)]
pub name: String,
#[serde(default)]
pub url: String,
#[serde(default)]
pub added_at: String,
#[serde(default)]
pub updated_at: String,
#[serde(default)]
#[specta(type = f64)]
pub size: u64,
}
#[derive(Serialize, Clone, Type)]
#[serde(rename_all = "camelCase")]
pub struct KernelInfo {
pub path: String,
pub exists: bool,
pub version: Option<String>,
}
#[derive(Serialize, Clone, Type)]
#[serde(rename_all = "camelCase")]
pub struct KernelUpdateInfo {
pub current_version: Option<String>,
pub latest_version: String,
pub download_url: String,
pub has_update: bool,
}
#[derive(Serialize, Clone, Type)]
#[serde(rename_all = "camelCase")]
pub struct ProxyStatus {
pub running: bool,
pub pid: Option<u32>,
pub restart_count: u32,
}
/// 内核安装进度事件载荷
/// - stage: downloading | extracting | replacing | done | error
/// - percent: 0-100（无 total_bytes 时为 0，前端按 downloadedBytes 显示）
#[derive(Serialize, Clone, Type)]
#[serde(rename_all = "camelCase")]
pub struct InstallProgress {
pub stage: String,
pub percent: u8,
#[specta(type = f64)]
pub downloaded_bytes: u64,
#[specta(type = Option<f64>)]
pub total_bytes: Option<u64>,
pub message: String,
}
src-tauri/src/monitor_kernel.rs
+70 -37
View File
@@ -175,11 +175,11 @@ pub fn check_and_relaunch_if_needed(app_data_dir: &std::path::Path) -> bool {
Ok(e) => e,
Err(_) => return false,
};
eprintln!("[monitor] 检测到永久提权标志，以管理员权限重启 Thing");
crate::logger::log_info("monitor", "检测到永久提权标志，以管理员权限重启 Thing");
match shell_execute_elevated(&exe.to_string_lossy(), "", None) {
Ok(()) => true,
Err(e) => {
eprintln!("[monitor] 永久提权重启失败（用户可能取消了 UAC）: {}", e);
crate::logger::log_warn("monitor", &format!("永久提权重启失败（用户可能取消了 UAC）: {}", e));
false
}
}
@@ -247,6 +247,17 @@ pub struct MonitorKernel {
listener_ids: Arc<Mutex<Vec<tauri::EventId>>>,
/// 是否以管理员权限运行（提权模式下进程不受 ProcessManager 管控，停止走 /shutdown）
elevated: Arc<AtomicBool>,
/// SSE 订阅循环活跃标志（重入守卫，防止并发/重复订阅导致双 emit monitor-data）
subscribing: Arc<AtomicBool>,
}
/// SSE 订阅循环标志守卫：Drop 时复位 subscribing，覆盖所有 return / abort 路径
struct SubGuard(Arc<AtomicBool>);
impl Drop for SubGuard {
fn drop(&mut self) {
self.0.store(false, Ordering::SeqCst);
}
}
impl MonitorKernel {
@@ -265,6 +276,7 @@ impl MonitorKernel {
sub_handle: Arc::new(Mutex::new(None)),
listener_ids: Arc::new(Mutex::new(Vec::new())),
elevated: Arc::new(AtomicBool::new(false)),
subscribing: Arc::new(AtomicBool::new(false)),
}
}
@@ -381,10 +393,18 @@ impl MonitorKernel {
/// 流程：轮询 /status 等 ready → 订阅 /stream → 解析 SSE 事件 → emit "monitor-data"
/// 写入熔断：SSE 断开后停止 emit，等待外部调用 reconnect 或 process-status-changed 触发重连
pub async fn start_subscription(self: Self, app: AppHandle) {
// 重入守卫：已有订阅循环在运行则跳过，防止并发/重复订阅（双 emit monitor-data）
if self.subscribing.swap(true, Ordering::SeqCst) {
crate::logger::log_warn("monitor", "已有 SSE 订阅循环运行中，跳过重复订阅");
return;
}
// Drop 时复位标志，覆盖所有 return 路径（含 stop 时 abort 取消）
let _guard = SubGuard(self.subscribing.clone());
// 1. 轮询等待 Kernel ready（冷启动约 5s）
if let Err(e) = self.wait_for_ready(&app).await {
eprintln!("[monitor] 等待 Kernel ready 失败，订阅不启动: {}", e);
let _ = app.emit("monitor-error", serde_json::json!({ "stage": "ready", "message": e }));
crate::logger::log_warn("monitor", &format!("等待 Kernel ready 失败，订阅不启动: {}", e));
let _ = app.emit(crate::constants::events::MONITOR_ERROR, serde_json::json!({ "stage": "ready", "message": e }));
return;
}
@@ -409,7 +429,7 @@ impl MonitorKernel {
match resp.json::<KernelStatus>().await {
Ok(s) if s.ready => {
let _ = app.emit(
"monitor-ready",
crate::constants::events::MONITOR_READY,
serde_json::json!({
"isAdmin": s.is_admin,
"sensorCount": s.sensor_count,
@@ -426,8 +446,10 @@ impl MonitorKernel {
Err(e) => last_err = e.to_string(),
}
// 通知前端正在加载（前端可显示 "Kernel 启动中..."）
let elapsed = READY_TIMEOUT_MS.saturating_sub(deadline.duration_since(std::time::Instant::now()).as_millis() as u64);
let _ = app.emit("monitor-loading", serde_json::json!({ "elapsedMs": elapsed }));
// 用 saturating_duration_since：now 超过 deadline 时返回 0，避免 duration_since panic
let remaining = deadline.saturating_duration_since(std::time::Instant::now()).as_millis() as u64;
let elapsed = READY_TIMEOUT_MS.saturating_sub(remaining);
let _ = app.emit(crate::constants::events::MONITOR_LOADING, serde_json::json!({ "elapsedMs": elapsed }));
tokio::time::sleep(Duration::from_millis(READY_POLL_INTERVAL_MS)).await;
}
Err(format!("Kernel 在 {}ms 内未就绪: {}", READY_TIMEOUT_MS, last_err))
@@ -441,24 +463,24 @@ impl MonitorKernel {
match self.subscribe_once(&url, &app).await {
// 正常结束（客户端取消或服务端关闭）
Ok(()) => {
eprintln!("[monitor] SSE 流正常结束");
crate::logger::log_info("monitor", "SSE 流正常结束");
break;
}
Err(e) => {
eprintln!("[monitor] SSE 流异常断开: {}，3s 后重试", e);
crate::logger::log_warn("monitor", &format!("SSE 流异常断开: {}，3s 后重试", e));
let _ = app.emit(
"monitor-disconnected",
crate::constants::events::MONITOR_DISCONNECTED,
serde_json::json!({ "message": e }),
);
tokio::time::sleep(Duration::from_secs(3)).await;
// 重连前先确认 Kernel 是否还活着（可能已被 stop）
if !self.is_kernel_alive().await {
eprintln!("[monitor] Kernel 已停止，退出 SSE 循环");
crate::logger::log_info("monitor", "Kernel 已停止，退出 SSE 循环");
// 提权模式下 Kernel 崩溃/退出后重置 elevated 标志，
// 否则 monitor_status 会一直认为提权模式但 Kernel 已死，用户无法重启
if self.is_elevated() {
self.elevated.store(false, Ordering::SeqCst);
eprintln!("[monitor] 提权 Kernel 已退出，重置 elevated 标志");
crate::logger::log_info("monitor", "提权 Kernel 已退出，重置 elevated 标志");
}
break;
}
@@ -497,7 +519,7 @@ impl MonitorKernel {
if let Some(json_str) = parse_sse_data(&event_str) {
if let Ok(snap) = serde_json::from_str::<SensorSnapshot>(&json_str) {
let _ = app.emit("monitor-data", snap);
let _ = app.emit(crate::constants::events::MONITOR_DATA, snap);
}
}
}
@@ -519,9 +541,11 @@ impl MonitorKernel {
/// 停止 SSE 订阅（进程由 ProcessManager.stop 负责）
pub async fn stop_subscription(&self, app: &AppHandle) {
// 取消 SSE 任务
// 取消 SSE 任务并等待其退出，确保 subscribing 重入守卫复位。
// 否则 stop 后立即 start 时旧任务仍在 Drop，新订阅会被守卫误跳过。
if let Some(handle) = self.sub_handle.lock().await.take() {
handle.abort();
let _ = handle.await;
}
// 取消 process-status-changed 监听
let ids = self.listener_ids.lock().await.drain(..).collect::<Vec<_>>();
@@ -552,7 +576,7 @@ impl MonitorKernel {
let this = this.clone();
let app = app_clone.clone();
tauri::async_runtime::spawn(async move {
eprintln!("[monitor] 检测到 Kernel 重启恢复，重新订阅 SSE");
crate::logger::log_info("monitor", "检测到 Kernel 重启恢复，重新订阅 SSE");
// 重启后需要重新等待 ready（冷启动约 5s）
this.clone().start_subscription(app).await;
});
@@ -585,20 +609,23 @@ impl MonitorKernel {
if status.ready {
if thing_elevated {
// Thing 是管理员：停止已有 Kernel（无论什么权限），用 ProcessManager 重启以继承权限
eprintln!("[monitor] Thing 已提权，重启 ThingHK 以继承管理员权限");
crate::logger::log_info("monitor", "Thing 已提权，重启 ThingHK 以继承管理员权限");
let _ = self.shutdown_kernel().await;
tokio::time::sleep(Duration::from_millis(500)).await;
} else if status.is_admin {
// Thing 非管理员，但已有提权 Kernel：直接接管
eprintln!("[monitor] 检测到已有提权 Kernel 运行中，直接接管");
crate::logger::log_info("monitor", "检测到已有提权 Kernel 运行中，直接接管");
self.elevated.store(true, Ordering::SeqCst);
let kernel = self.clone();
kernel.clone().register_auto_reconnect(app.clone()).await;
let app_clone = app.clone();
let handle = tauri::async_runtime::spawn(async move {
kernel.start_subscription(app_clone).await;
});
*self.sub_handle.lock().await = Some(handle);
// 已有订阅循环在运行则不覆盖句柄（否则旧任务句柄丢失，stop 无法取消）
if !kernel.subscribing.load(Ordering::SeqCst) {
let app_clone = app.clone();
let handle = tauri::async_runtime::spawn(async move {
kernel.start_subscription(app_clone).await;
});
*self.sub_handle.lock().await = Some(handle);
}
// 提权模式下无 ProcessInfo，返回一个占位的
return Ok(crate::process_manager::ProcessInfo {
id: PROCESS_ID.into(),
@@ -609,7 +636,7 @@ impl MonitorKernel {
});
} else {
// Thing 非管理员，已有普通 Kernel：先停止
eprintln!("[monitor] 检测到已有普通权限 Kernel 运行中，先停止再重启");
crate::logger::log_info("monitor", "检测到已有普通权限 Kernel 运行中，先停止再重启");
let _ = self.shutdown_kernel().await;
tokio::time::sleep(Duration::from_millis(500)).await;
}
@@ -623,7 +650,7 @@ impl MonitorKernel {
// Thing 是管理员时，ThingHK 继承权限，标记 elevated（仍由 ProcessManager 管理）
if thing_elevated {
self.elevated.store(true, Ordering::SeqCst);
eprintln!("[monitor] ThingHK 已以管理员权限启动（继承自 Thing）");
crate::logger::log_info("monitor", "ThingHK 已以管理员权限启动（继承自 Thing）");
}
// 用 self 的 clone（共享 Arc<Mutex> 状态）启动订阅，
@@ -631,11 +658,14 @@ impl MonitorKernel {
// stop_subscription 时才能正确清理 listener。
let kernel = self.clone();
kernel.clone().register_auto_reconnect(app.clone()).await;
let app_clone = app.clone();
let handle = tauri::async_runtime::spawn(async move {
kernel.start_subscription(app_clone).await;
});
*self.sub_handle.lock().await = Some(handle);
// 已有订阅循环在运行则不覆盖句柄（否则旧任务句柄丢失，stop 无法取消）
if !kernel.subscribing.load(Ordering::SeqCst) {
let app_clone = app.clone();
let handle = tauri::async_runtime::spawn(async move {
kernel.start_subscription(app_clone).await;
});
*self.sub_handle.lock().await = Some(handle);
}
Ok(info)
}
@@ -703,17 +733,20 @@ impl MonitorKernel {
}
self.elevated.store(true, Ordering::SeqCst);
eprintln!("[monitor] 提权启动已发起，等待 Kernel ready");
crate::logger::log_info("monitor", "提权启动已发起，等待 Kernel ready");
// 5. 启动 SSE 订阅（提权模式不注册 register_auto_reconnect：
// 提权进程不归 ProcessManager 管，process-status-changed 事件不会触发，
// 注册了反而可能在其他进程状态变化时误触发 SSE 重连）
let kernel = self.clone();
let app_clone = app.clone();
let handle = tauri::async_runtime::spawn(async move {
kernel.start_subscription(app_clone).await;
});
*self.sub_handle.lock().await = Some(handle);
// 已有订阅循环在运行则不覆盖句柄（否则旧任务句柄丢失，stop 无法取消）
if !kernel.subscribing.load(Ordering::SeqCst) {
let handle = tauri::async_runtime::spawn(async move {
kernel.start_subscription(app_clone).await;
});
*self.sub_handle.lock().await = Some(handle);
}
Ok(())
}
@@ -745,7 +778,7 @@ impl MonitorKernel {
self.stop_subscription(app).await;
// 仅当 ThingHK 提权但 Thing 未提权时才需要 /shutdown（ProcessManager 无法 kill 管理员进程）
if self.is_elevated() && !is_thing_elevated() {
eprintln!("[monitor] 退出清理：停止提权 Kernel（/shutdown）");
crate::logger::log_info("monitor", "退出清理：停止提权 Kernel（/shutdown）");
let _ = self.shutdown_kernel().await;
self.elevated.store(false, Ordering::SeqCst);
}
@@ -852,13 +885,13 @@ pub async fn monitor_elevate_self(
if is_thing_elevated() {
// 已是管理员，只需设置标志，无需重启
eprintln!("[monitor] Thing 已是管理员，仅设置永久提权标志");
crate::logger::log_info("monitor", "Thing 已是管理员，仅设置永久提权标志");
return Ok(());
}
let exe = std::env::current_exe().map_err(|e| format!("获取当前路径失败: {}", e))?;
let exe_str = exe.to_string_lossy().to_string();
eprintln!("[monitor] 永久提权：以管理员权限重启 Thing");
crate::logger::log_info("monitor", "永久提权：以管理员权限重启 Thing");
shell_execute_elevated(&exe_str, "", None)?;
// 退出当前进程（非提权），新的提权进程会接管
app.exit(0);
src-tauri/src/network_monitor.rs
+3 -3
View File
@@ -95,9 +95,9 @@ impl NetworkMonitor {
};
// emit 给前端（失败忽略：窗口可能未就绪）
let _ = app.emit("monitor-network", &speed);
let _ = app.emit(crate::constants::events::MONITOR_NETWORK, &speed);
}
eprintln!("[network] 网速采样任务已退出");
crate::logger::log_info("network", "网速采样任务已退出");
});
}
@@ -116,7 +116,7 @@ impl Default for NetworkMonitor {
/// Tauri 命令：获取网速监控是否运行
#[tauri::command]
pub fn network_monitor_status(
pub fn network_status(
state: tauri::State<'_, NetworkMonitor>,
) -> bool {
state.running.load(Ordering::SeqCst)
src-tauri/src/osd_window.rs
+51 -17
View File
@@ -6,8 +6,8 @@
//! - 任务栏覆盖检测：轮询 GetForegroundWindow，检测系统 UI 出现时暂时取消置顶
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, OnceLock};
use std::thread;
use std::sync::{Arc, Mutex, OnceLock};
use std::thread::{self, JoinHandle};
use std::time::{Duration, Instant};
use tauri::{AppHandle, Emitter};
@@ -15,6 +15,9 @@ use tauri::{AppHandle, Emitter};
static DRAG_STOP: OnceLock<Arc<AtomicBool>> = OnceLock::new();
/// 任务栏覆盖监视线程停止标志
static TOPMOST_STOP: OnceLock<Arc<AtomicBool>> = OnceLock::new();
/// 监视线程句柄（用于停止时 join，避免 sleep 猜测式等待 + 线程泄漏）
static DRAG_HANDLE: Mutex<Option<JoinHandle<()>>> = Mutex::new(None);
static TOPMOST_HANDLE: Mutex<Option<JoinHandle<()>>> = Mutex::new(None);
fn drag_stop() -> &'static Arc<AtomicBool> {
DRAG_STOP.get_or_init(|| Arc::new(AtomicBool::new(true)))
@@ -24,6 +27,30 @@ fn topmost_stop() -> &'static Arc<AtomicBool> {
TOPMOST_STOP.get_or_init(|| Arc::new(AtomicBool::new(true)))
}
/// 停止右键拖动监视线程并等待其退出（标志置位后线程最迟一个轮询周期退出）
fn stop_drag_thread() {
drag_stop().store(true, Ordering::SeqCst);
if let Some(h) = DRAG_HANDLE
.lock()
.unwrap_or_else(|e| e.into_inner())
.take()
{
let _ = h.join();
}
}
/// 停止任务栏覆盖监视线程并等待其退出
fn stop_topmost_thread() {
topmost_stop().store(true, Ordering::SeqCst);
if let Some(h) = TOPMOST_HANDLE
.lock()
.unwrap_or_else(|e| e.into_inner())
.take()
{
let _ = h.join();
}
}
#[cfg(windows)]
mod win_api {
use tauri::{AppHandle, Manager};
@@ -186,7 +213,7 @@ pub fn osd_apply_overlay_style(label: String, app: AppHandle) -> Result<(), Stri
let hwnd = win_api::get_hwnd(&label, &app)
.ok_or_else(|| format!("窗口 {} 不存在", label))?;
win_api::apply_no_activate(hwnd);
eprintln!("[osd] 已应用 NoActivate 样式到窗口 {}", label);
crate::logger::log_info("osd", &format!("已应用 NoActivate 样式到窗口 {}", label));
}
Ok(())
}
@@ -198,15 +225,14 @@ pub fn osd_apply_overlay_style(label: String, app: AppHandle) -> Result<(), Stri
/// 右键释放后发出 `osd-end-drag` 事件。
#[tauri::command]
pub fn osd_start_drag_watch(label: String, app: AppHandle) -> Result<(), String> {
// 停止旧线程，等待退出
drag_stop().store(true, Ordering::SeqCst);
thread::sleep(Duration::from_millis(50));
// 停止旧线程，等待其退出后再启动新线程（避免新旧线程并存）
stop_drag_thread();
let stop_flag = drag_stop().clone();
stop_flag.store(false, Ordering::SeqCst);
let app_handle = app.clone();
thread::spawn(move || {
let handle = thread::spawn(move || {
let mut rbutton_was_down = false;
let mut press_start: Option<Instant> = None;
let mut drag_emitted = false;
@@ -234,7 +260,7 @@ pub fn osd_start_drag_watch(label: String, app: AppHandle) -> Result<(), String>
(win_api::get_cursor_pos(), win_api::get_window_rect(hwnd))
{
if win_api::point_in_rect(pt, rect) {
let _ = app_handle.emit("osd-start-drag", ());
let _ = app_handle.emit(crate::constants::events::OSD_START_DRAG, ());
drag_emitted = true;
}
}
@@ -245,7 +271,7 @@ pub fn osd_start_drag_watch(label: String, app: AppHandle) -> Result<(), String>
} else if !rbutton_down && rbutton_was_down {
// 右键释放
if drag_emitted {
let _ = app_handle.emit("osd-end-drag", ());
let _ = app_handle.emit(crate::constants::events::OSD_END_DRAG, ());
}
press_start = None;
drag_emitted = false;
@@ -258,6 +284,10 @@ pub fn osd_start_drag_watch(label: String, app: AppHandle) -> Result<(), String>
}
});
if let Ok(mut guard) = DRAG_HANDLE.lock() {
*guard = Some(handle);
}
Ok(())
}
@@ -268,14 +298,14 @@ pub fn osd_start_drag_watch(label: String, app: AppHandle) -> Result<(), String>
/// 系统 UI 关闭后发出 `osd-system-ui-inactive` 事件恢复置顶。
#[tauri::command]
pub fn osd_start_topmost_watch(app: AppHandle) -> Result<(), String> {
topmost_stop().store(true, Ordering::SeqCst);
thread::sleep(Duration::from_millis(50));
// 停止旧线程，等待其退出后再启动新线程
stop_topmost_thread();
let stop_flag = topmost_stop().clone();
stop_flag.store(false, Ordering::SeqCst);
let app_handle = app.clone();
thread::spawn(move || {
let handle = thread::spawn(move || {
let mut last_foreground: isize = 0;
let mut system_ui_active = false;
@@ -293,15 +323,15 @@ pub fn osd_start_topmost_watch(app: AppHandle) -> Result<(), String> {
if win_api::is_system_ui_class(&class) {
if !system_ui_active {
system_ui_active = true;
let _ = app_handle.emit("osd-system-ui-active", ());
let _ = app_handle.emit(crate::constants::events::OSD_SYSTEM_UI_ACTIVE, ());
}
} else if system_ui_active {
system_ui_active = false;
let _ = app_handle.emit("osd-system-ui-inactive", ());
let _ = app_handle.emit(crate::constants::events::OSD_SYSTEM_UI_INACTIVE, ());
}
} else if system_ui_active {
system_ui_active = false;
let _ = app_handle.emit("osd-system-ui-inactive", ());
let _ = app_handle.emit(crate::constants::events::OSD_SYSTEM_UI_INACTIVE, ());
}
}
}
@@ -310,14 +340,18 @@ pub fn osd_start_topmost_watch(app: AppHandle) -> Result<(), String> {
}
});
if let Ok(mut guard) = TOPMOST_HANDLE.lock() {
*guard = Some(handle);
}
Ok(())
}
/// 停止所有 OSD 监视线程
#[tauri::command]
pub fn osd_stop_watch() {
drag_stop().store(true, Ordering::SeqCst);
topmost_stop().store(true, Ordering::SeqCst);
stop_drag_thread();
stop_topmost_thread();
}
/// 设置点击穿透（Rust 侧原生 WS_EX_TRANSPARENT，比 JS setIgnoreCursorEvents 更可靠）
src-tauri/src/process_manager.rs
+83 -71
View File
@@ -1,4 +1,5 @@
use serde::Serialize;
use specta::Type;
use std::collections::HashMap;
use std::process::{Child, Command, Stdio};
use std::sync::Mutex;
@@ -80,7 +81,7 @@ fn get_job_handle() -> Option<winapi::HANDLE> {
unsafe {
let h = winapi::CreateJobObjectW(std::ptr::null_mut(), std::ptr::null());
if h.is_null() {
eprintln!("[ProcessManager] CreateJobObjectW 失败，异常退出时子进程可能残留");
crate::logger::log_error("process", "CreateJobObjectW 失败，异常退出时子进程可能残留");
return 0;
}
// 设置 KILL_ON_JOB_CLOSE：主进程退出时自动终止所有子进程
@@ -93,7 +94,7 @@ fn get_job_handle() -> Option<winapi::HANDLE> {
std::mem::size_of::<winapi::JOBOBJECT_EXTENDED_LIMIT_INFORMATION>() as u32,
);
if ok == 0 {
eprintln!("[ProcessManager] SetInformationJobObject 失败");
crate::logger::log_error("process", "SetInformationJobObject 失败");
return 0;
}
h as usize
@@ -136,7 +137,7 @@ fn assign_to_job(child: &Child) {
fn assign_to_job(_child: &Child) {}
/// 进程状态枚举
#[derive(Serialize, Clone, Debug)]
#[derive(Serialize, Clone, Debug, Type)]
#[serde(rename_all = "lowercase")]
pub enum ProcessStatus {
Running,
@@ -147,7 +148,8 @@ pub enum ProcessStatus {
}
/// 进程信息（返回给前端）
#[derive(Serialize, Clone)]
#[derive(Serialize, Clone, Type)]
#[serde(rename_all = "camelCase")]
pub struct ProcessInfo {
pub id: String,
pub name: String,
@@ -291,7 +293,7 @@ impl ProcessManager {
Ok(Some(_)) => break,
Ok(None) => {
if std::time::Instant::now() >= deadline {
println!("[ProcessManager] 进程 {} 等待退出超时（3s），放弃等待", id);
crate::logger::log_warn("process", &format!("进程 {} 等待退出超时（3s），放弃等待", id));
break;
}
std::thread::sleep(Duration::from_millis(50));
@@ -299,7 +301,7 @@ impl ProcessManager {
Err(_) => break,
}
}
println!("[ProcessManager] 已停止进程: {}", id);
crate::logger::log_info("process", &format!("已停止进程: {}", id));
}
}
}
@@ -351,18 +353,24 @@ impl ProcessManager {
/// 检查所有进程，处理崩溃的进程（自动重启或移除）
/// 返回状态发生变化的进程列表
/// 注意：kill/wait/sleep(800ms) 等阻塞操作一律在锁外执行，
/// 锁内仅做非阻塞的 try_wait 判定，避免阻塞其他进程的状态查询
pub fn check_and_cleanup(&self) -> Vec<ProcessInfo> {
let mut changes = Vec::new();
// 需要重启的条目（锁外执行 kill + sleep + spawn）
let mut restarts: Vec<(String, ProcessEntry)> = Vec::new();
let mut processes = match self.processes.lock() {
Ok(p) => p,
Err(_) => return changes,
};
// 阶段 1：锁内快速判定（仅非阻塞 try_wait），收集重启/移除决策
{
let mut processes = match self.processes.lock() {
Ok(p) => p,
Err(_) => return changes,
};
let ids: Vec<String> = processes.keys().cloned().collect();
let ids: Vec<String> = processes.keys().cloned().collect();
for id in ids {
if let Some(entry) = processes.get_mut(&id) {
for id in ids {
let Some(entry) = processes.get_mut(&id) else { continue };
match entry.child.try_wait() {
Ok(None) => {
// 仍在运行，无需处理
@@ -373,58 +381,10 @@ impl ProcessManager {
&& (entry.max_restarts == 0
|| entry.restart_count < entry.max_restarts)
{
// 自动重启
let restart_count = entry.restart_count + 1;
let executable = entry.executable.clone();
let args = entry.args.clone();
let cwd = entry.cwd.clone();
let name = entry.name.clone();
// 先终止旧进程
let _ = entry.child.kill();
let _ = entry.child.wait();
// 等待 TCP 端口释放（Windows 上 kill 后端口释放有延迟）
std::thread::sleep(std::time::Duration::from_millis(800));
// 重新启动
let mut cmd = Command::new(&executable);
cmd.args(&args);
if let Some(ref dir) = cwd {
cmd.current_dir(dir);
}
cmd.stdout(Stdio::null())
.stderr(Stdio::null())
.stdin(Stdio::null());
setup_creation_flags(&mut cmd);
match cmd.spawn() {
Ok(new_child) => {
let pid = new_child.id();
entry.child = new_child;
entry.restart_count = restart_count;
changes.push(ProcessInfo {
id: id.clone(),
name: name.clone(),
status: ProcessStatus::Running,
pid: Some(pid),
restart_count,
});
}
Err(e) => {
eprintln!(
"[ProcessManager] 重启进程 '{}' 失败: {}",
id, e
);
processes.remove(&id);
changes.push(ProcessInfo {
id: id.clone(),
name,
status: ProcessStatus::Crashed,
pid: None,
restart_count,
});
}
// 需要自动重启：从 map 移除，锁外执行
if let Some(mut e) = processes.remove(&id) {
e.restart_count += 1;
restarts.push((id.clone(), e));
}
} else {
// 不自动重启，移除记录
@@ -455,6 +415,58 @@ impl ProcessManager {
}
}
}
} // 锁在此释放
// 阶段 2：锁外执行重启（kill + wait + 端口释放等待 + spawn，不阻塞进程状态查询）
for (id, mut entry) in restarts {
// 先终止旧进程
let _ = entry.child.kill();
let _ = entry.child.wait();
// 等待 TCP 端口释放（Windows 上 kill 后端口释放有延迟）
std::thread::sleep(std::time::Duration::from_millis(800));
// 重新启动
let mut cmd = Command::new(&entry.executable);
cmd.args(&entry.args);
if let Some(ref dir) = entry.cwd {
cmd.current_dir(dir);
}
cmd.stdout(Stdio::null())
.stderr(Stdio::null())
.stdin(Stdio::null());
setup_creation_flags(&mut cmd);
let name = entry.name.clone();
let restart_count = entry.restart_count;
match cmd.spawn() {
Ok(new_child) => {
let pid = new_child.id();
entry.child = new_child;
if let Ok(mut processes) = self.processes.lock() {
processes.insert(id.clone(), entry);
}
changes.push(ProcessInfo {
id: id.clone(),
name,
status: ProcessStatus::Running,
pid: Some(pid),
restart_count,
});
}
Err(e) => {
crate::logger::log_error(
"process",
&format!("重启进程 '{}' 失败: {}", id, e),
);
changes.push(ProcessInfo {
id: id.clone(),
name,
status: ProcessStatus::Crashed,
pid: None,
restart_count,
});
}
}
}
changes
@@ -464,7 +476,7 @@ impl ProcessManager {
// ===== Tauri 命令 =====
#[tauri::command]
pub fn start_process(
pub fn process_start(
state: tauri::State<'_, ProcessManager>,
params: StartProcessParams,
) -> Result<ProcessInfo, String> {
@@ -472,7 +484,7 @@ pub fn start_process(
}
#[tauri::command]
pub fn stop_process(
pub fn process_stop(
state: tauri::State<'_, ProcessManager>,
id: String,
) -> Result<(), String> {
@@ -480,7 +492,7 @@ pub fn stop_process(
}
#[tauri::command]
pub fn get_process_status(
pub fn process_status(
state: tauri::State<'_, ProcessManager>,
id: String,
) -> Option<ProcessInfo> {
@@ -488,14 +500,14 @@ pub fn get_process_status(
}
#[tauri::command]
pub fn get_all_process_status(
pub fn process_all_status(
state: tauri::State<'_, ProcessManager>,
) -> Vec<ProcessInfo> {
state.get_all_status()
}
#[tauri::command]
pub fn stop_all_processes(state: tauri::State<'_, ProcessManager>) {
pub fn process_stop_all(state: tauri::State<'_, ProcessManager>) {
state.stop_all()
}
@@ -509,7 +521,7 @@ pub fn start_monitoring_thread(app: AppHandle) {
let changes = state.check_and_cleanup();
for change in changes {
let _ = app.emit("process-status-changed", &change);
let _ = app.emit(crate::constants::events::PROCESS_STATUS_CHANGED, &change);
}
}
});
src-tauri/src/quickpanel/app_scanner.rs
+3 -1
View File
@@ -8,7 +8,9 @@ use std::path::PathBuf;
use serde::Serialize;
use walkdir::WalkDir;
#[derive(Debug, Clone, Serialize)]
use specta::Type;
#[derive(Debug, Clone, Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct AppRecord {
pub name: String,
src-tauri/src/quickpanel/commands.rs
+63 -18
View File
@@ -7,21 +7,25 @@ use super::{file_index, app_scanner, icon_extractor};
/// 读取快速面板设置（快捷键等）
#[tauri::command]
#[specta::specta]
pub async fn quickpanel_get_settings(app: AppHandle) -> Result<QuickPanelSettings, String> {
Ok(popup::load_settings(&app))
}
/// 保存快速面板设置；快捷键变化时自动重新注册 + 预创建窗口
#[tauri::command]
#[specta::specta]
pub async fn quickpanel_save_settings(
settings: QuickPanelSettings,
app: AppHandle,
) -> Result<(), String> {
let prev_shortcut = popup::load_settings(&app).shortcut;
popup::save_settings(&app, &settings)?;
// 快捷键变化时重新注册
// 快捷键变化时重新注册（共享工具模块，原子化 + 冲突检测）
if settings.shortcut != prev_shortcut {
popup::register_shortcut(&app, &settings.shortcut)?;
crate::shortcut::register_shortcut(&app, "快速面板", &settings.shortcut, |a| {
popup::show_popup(a)
})?;
// 新快捷键非空时确保弹窗窗口已预创建
if !settings.shortcut.trim().is_empty() {
popup::ensure_window(&app);
@@ -32,22 +36,25 @@ pub async fn quickpanel_save_settings(
/// 注册（或切换）快速面板全局快捷键
#[tauri::command]
#[specta::specta]
pub async fn quickpanel_register_shortcut(
shortcut: String,
app: AppHandle,
) -> Result<(), String> {
popup::register_shortcut(&app, &shortcut)
crate::shortcut::register_shortcut(&app, "快速面板", &shortcut, |a| popup::show_popup(a))
}
/// 注销快速面板全局快捷键
#[tauri::command]
#[specta::specta]
pub async fn quickpanel_unregister_shortcut(app: AppHandle) -> Result<(), String> {
popup::unregister_shortcut(&app);
crate::shortcut::unregister_shortcut(&app, "快速面板");
Ok(())
}
/// 手动触发显示快速面板（供 UI 按钮调用）
#[tauri::command]
#[specta::specta]
pub async fn quickpanel_show_popup(app: AppHandle) -> Result<(), String> {
popup::show_popup(&app);
Ok(())
@@ -55,6 +62,7 @@ pub async fn quickpanel_show_popup(app: AppHandle) -> Result<(), String> {
/// 隐藏快速面板
#[tauri::command]
#[specta::specta]
pub async fn quickpanel_hide_popup(app: AppHandle) -> Result<(), String> {
popup::hide_popup(&app);
Ok(())
@@ -62,6 +70,7 @@ pub async fn quickpanel_hide_popup(app: AppHandle) -> Result<(), String> {
/// 显示已创建的弹窗窗口（前端 onMounted 后调用）
#[tauri::command]
#[specta::specta]
pub async fn quickpanel_show_window(app: AppHandle) -> Result<(), String> {
popup::show_window(&app);
Ok(())
@@ -69,6 +78,7 @@ pub async fn quickpanel_show_window(app: AppHandle) -> Result<(), String> {
/// 锁定屏幕（Windows: rundll32 user32.dll,LockWorkStation，CREATE_NO_WINDOW 避免黑窗）
#[tauri::command]
#[specta::specta]
pub fn quickpanel_lock_screen() -> Result<(), String> {
#[cfg(windows)]
{
@@ -87,13 +97,16 @@ pub fn quickpanel_lock_screen() -> Result<(), String> {
/// 初始化文件索引数据库（应用启动时调用）
#[tauri::command]
pub fn quickpanel_init_file_index(app: AppHandle) -> Result<(), String> {
file_index::init(&app);
Ok(())
#[specta::specta]
pub async fn quickpanel_init_file_index(app: AppHandle) -> Result<(), String> {
tauri::async_runtime::spawn_blocking(move || file_index::init(&app))
.await
.map_err(|e| format!("索引初始化任务失败: {}", e))
}
/// 构建文件索引（全量重建，阻塞操作建议在 spawn_blocking 调用）
#[tauri::command]
#[specta::specta]
pub async fn quickpanel_build_file_index(app: AppHandle) -> Result<i64, String> {
let settings = popup::load_settings(&app);
let dirs = if settings.index_dirs.is_empty() {
@@ -107,33 +120,51 @@ pub async fn quickpanel_build_file_index(app: AppHandle) -> Result<i64, String>
.map_err(|e| format!("索引任务失败: {}", e))?
}
/// 搜索文件索引
/// 搜索文件索引（SQLite 查询移出主线程）
#[tauri::command]
pub fn quickpanel_search_files(query: String, limit: Option<i64>) -> Vec<file_index::FileRecord> {
file_index::search(&query, limit.unwrap_or(50))
#[specta::specta]
pub async fn quickpanel_search_files(
query: String,
limit: Option<i64>,
) -> Result<Vec<file_index::FileRecord>, String> {
tauri::async_runtime::spawn_blocking(move || file_index::search(&query, limit.unwrap_or(50)))
.await
.map_err(|e| format!("搜索任务失败: {}", e))
}
/// 获取索引状态
#[tauri::command]
#[specta::specta]
pub fn quickpanel_file_index_stats() -> file_index::IndexStats {
file_index::stats()
}
/// 扫描已安装应用
/// 扫描已安装应用（遍历开始菜单/桌面/磁盘，移出主线程）
#[tauri::command]
pub fn quickpanel_scan_apps() -> Vec<app_scanner::AppRecord> {
app_scanner::scan_apps()
#[specta::specta]
pub async fn quickpanel_scan_apps() -> Result<Vec<app_scanner::AppRecord>, String> {
tauri::async_runtime::spawn_blocking(app_scanner::scan_apps)
.await
.map_err(|e| format!("扫描应用任务失败: {}", e))
}
/// 获取应用图标（data URL）。命中内存/磁盘缓存时零 Windows API 调用。
/// 前端按需为可见项调用，避免一次性加载全部图标。
/// 未命中缓存时 SHGetFileInfoW + 编码 + 落盘为阻塞操作，移出主线程。
#[tauri::command]
pub fn quickpanel_get_app_icon(app: AppHandle, path: String) -> Option<String> {
icon_extractor::get_icon_data_url(&app, &path)
#[specta::specta]
pub async fn quickpanel_get_app_icon(
app: AppHandle,
path: String,
) -> Result<Option<String>, String> {
tauri::async_runtime::spawn_blocking(move || icon_extractor::get_icon_data_url(&app, &path))
.await
.map_err(|e| format!("图标提取任务失败: {}", e))
}
/// 清理图标缓存（磁盘 + 内存）
#[tauri::command]
#[specta::specta]
pub fn quickpanel_clear_app_icon_cache(app: AppHandle) -> Result<(), String> {
icon_extractor::clear_cache(&app);
Ok(())
@@ -141,6 +172,7 @@ pub fn quickpanel_clear_app_icon_cache(app: AppHandle) -> Result<(), String> {
/// 在资源管理器中显示文件（选中）
#[tauri::command]
#[specta::specta]
pub fn quickpanel_reveal_in_explorer(path: String) -> Result<(), String> {
#[cfg(windows)]
{
@@ -192,18 +224,21 @@ pub fn quickpanel_reveal_in_explorer(path: String) -> Result<(), String> {
/// - 目录：explorer.exe 直接打开（修复索引目录点击后未打开的问题）
/// - 文件：ShellExecuteW open，无关联应用时自动 fallback 到「打开方式」对话框（verb: openas）
#[tauri::command]
#[specta::specta]
pub fn quickpanel_open_file(path: String) -> Result<(), String> {
super::special_locations::open_path(&path)
}
/// 获取 Windows 常用快捷位置（hosts、回收站、此电脑、用户目录、系统管理工具等）
#[tauri::command]
#[specta::specta]
pub fn quickpanel_get_special_locations() -> Vec<super::special_locations::SpecialLocation> {
super::special_locations::get_special_locations()
}
/// 打开快捷位置（kind: file | shell | cmd）
#[tauri::command]
#[specta::specta]
pub fn quickpanel_open_special(
kind: String,
target: String,
@@ -216,13 +251,21 @@ pub fn quickpanel_open_special(
}
}
/// 删除文件（移到回收站）
/// 删除文件（移到回收站，PowerShell 阻塞等待移出主线程）
#[tauri::command]
pub fn quickpanel_delete_file(path: String) -> Result<(), String> {
#[specta::specta]
pub async fn quickpanel_delete_file(path: String) -> Result<(), String> {
tauri::async_runtime::spawn_blocking(move || delete_file_impl(&path))
.await
.map_err(|e| format!("删除任务失败: {}", e))?
}
/// 删除文件实现：PowerShell + Microsoft.VisualBasic 移到回收站
fn delete_file_impl(path: &str) -> Result<(), String> {
#[cfg(windows)]
{
use crate::process_manager::setup_creation_flags;
let p = std::path::Path::new(&path);
let p = std::path::Path::new(path);
let is_dir = p.is_dir();
// 用 PowerShell + Microsoft.VisualBasic 移到回收站
let script = if is_dir {
@@ -258,6 +301,7 @@ pub fn quickpanel_delete_file(path: String) -> Result<(), String> {
/// 运行自定义命令（执行可执行文件 + 参数）
/// .lnk 快捷方式不能直接 spawn（os error 193），需通过 cmd /C 启动
#[tauri::command]
#[specta::specta]
pub fn quickpanel_run_custom_command(command: String, args: Vec<String>) -> Result<(), String> {
use crate::process_manager::setup_creation_flags;
let is_lnk = command
@@ -282,6 +326,7 @@ pub fn quickpanel_run_custom_command(command: String, args: Vec<String>) -> Resu
/// 运行系统命令（不设置 CREATE_NO_WINDOW，使 cmd/powershell/regedit 等显示自身窗口）
/// 适用于内置系统工具：regedit、shutdown、cmd、powershell、taskmgr 等。
#[tauri::command]
#[specta::specta]
pub fn quickpanel_run_system_command(command: String, args: Vec<String>) -> Result<(), String> {
let mut cmd = std::process::Command::new(&command);
cmd.args(&args);
src-tauri/src/quickpanel/file_index.rs
+19 -20
View File
@@ -13,8 +13,10 @@ use serde::Serialize;
use tauri::{AppHandle, Manager};
use walkdir::WalkDir;
use specta::Type;
/// 单个文件记录（返回给前端）
#[derive(Debug, Clone, Serialize)]
#[derive(Debug, Clone, Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct FileRecord {
pub path: String,
@@ -25,7 +27,7 @@ pub struct FileRecord {
}
/// 索引状态（返回给前端）
#[derive(Debug, Clone, Serialize)]
#[derive(Debug, Clone, Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct IndexStats {
pub total: i64,
@@ -61,7 +63,7 @@ pub fn init(app: &AppHandle) {
let conn = match Connection::open(&path) {
Ok(c) => c,
Err(e) => {
eprintln!("[quickpanel] 文件索引 DB 初始化失败: {}", e);
crate::logger::log_error("quickpanel", &format!("文件索引 DB 初始化失败: {}", e));
return;
}
};
@@ -84,11 +86,11 @@ pub fn init(app: &AppHandle) {
);",
);
let mut guard = index_slot().lock().unwrap();
let mut guard = index_slot().lock().unwrap_or_else(|e| e.into_inner());
*guard = Some(Inner {
conn: Mutex::new(conn),
});
eprintln!("[quickpanel] 文件索引 DB 已就绪: {}", path.display());
crate::logger::log_info("quickpanel", &format!("文件索引 DB 已就绪: {}", path.display()));
}
/// 判断索引是否已初始化
@@ -96,7 +98,7 @@ fn with_conn<F, R>(f: F) -> Option<R>
where
F: FnOnce(&Connection) -> R,
{
let guard = index_slot().lock().unwrap();
let guard = index_slot().lock().unwrap_or_else(|e| e.into_inner());
if let Some(inner) = guard.as_ref() {
if let Ok(conn) = inner.conn.lock() {
return Some(f(&conn));
@@ -140,7 +142,7 @@ pub fn build_index(dirs: &[String]) -> Result<i64, String> {
// 启动/刷新 notify 监听器
start_watcher(dirs);
eprintln!("[quickpanel] 文件索引完成，共 {} 条", count);
crate::logger::log_info("quickpanel", &format!("文件索引完成，共 {} 条", count));
Ok(count)
}
@@ -203,10 +205,13 @@ fn upsert_path(p: &Path) -> bool {
fn remove_path(p: &Path) {
let path_str = p.to_string_lossy().to_string();
let _ = with_conn(|conn| {
// 删除该路径及其子项（目录被删除时，子文件也失效）
// 删除该路径本身及其直接子项（目录被删除时，子文件也失效）。
// 用"路径 + 分隔符"的前缀匹配（而非裸前缀），避免误删 dir2/directory 等兄弟目录。
let backslash_prefix = format!("{}\\{}", path_str, "%");
let slash_prefix = format!("{}/{}", path_str, "%");
conn.execute(
"DELETE FROM files WHERE path = ?1 OR path LIKE ?2",
params![path_str, format!("{}%", path_str)],
"DELETE FROM files WHERE path = ?1 OR path LIKE ?2 OR path LIKE ?3",
params![path_str, backslash_prefix, slash_prefix],
)
});
}
@@ -306,7 +311,7 @@ pub fn start_watcher(dirs: &[String]) {
) {
Ok(w) => w,
Err(e) => {
eprintln!("[quickpanel] notify watcher 创建失败: {}", e);
crate::logger::log_error("quickpanel", &format!("notify watcher 创建失败: {}", e));
return;
}
};
@@ -318,14 +323,14 @@ pub fn start_watcher(dirs: &[String]) {
continue;
}
if let Err(e) = watcher.watch(path, RecursiveMode::Recursive) {
eprintln!("[quickpanel] watch {} 失败: {}", dir, e);
crate::logger::log_error("quickpanel", &format!("watch {} 失败: {}", dir, e));
}
}
// 替换旧 watcher（drop 时自动 unwatch）
let mut guard = watcher_slot().lock().unwrap();
let mut guard = watcher_slot().lock().unwrap_or_else(|e| e.into_inner());
*guard = Some(watcher);
eprintln!("[quickpanel] notify 监听已启动，监听 {} 个目录", dirs.len());
crate::logger::log_info("quickpanel", &format!("notify 监听已启动，监听 {} 个目录", dirs.len()));
}
/// 处理文件系统事件：创建/修改 → upsert，删除 → remove，重命名 → remove + upsert
@@ -348,9 +353,3 @@ fn handle_fs_event(event: &notify::Event) {
}
}
}
/// 停止 notify 监听器
pub fn stop_watcher() {
let mut guard = watcher_slot().lock().unwrap();
*guard = None;
}
src-tauri/src/quickpanel/icon_extractor.rs
+16 -10
View File
@@ -10,7 +10,7 @@
//! - 返回 base64 data URL 而非文件路径，避免独立弹窗窗口的 asset 协议配置问题
//! - 磁盘缓存避免重复 Windows API 调用（昂贵），内存缓存避免重复磁盘读取 + 编码
use std::collections::HashMap;
use std::collections::{HashMap, VecDeque};
use std::path::PathBuf;
use std::sync::Mutex;
@@ -18,26 +18,32 @@ use base64::Engine as _;
use tauri::{AppHandle, Manager};
// ===== 内存缓存 =====
static MEM_CACHE: Mutex<Option<HashMap<String, String>>> = Mutex::new(None);
/// (path → data URL) + FIFO 淘汰队列（队头最旧，超限时先淘汰）
static MEM_CACHE: Mutex<Option<(HashMap<String, String>, VecDeque<String>)>> = Mutex::new(None);
const MEM_CACHE_MAX: usize = 512;
fn mem_get(path: &str) -> Option<String> {
let cache = MEM_CACHE.lock().ok()?;
cache.as_ref()?.get(path).cloned()
cache.as_ref()?.0.get(path).cloned()
}
fn mem_put(path: String, url: String) {
if let Ok(mut guard) = MEM_CACHE.lock() {
let map = guard.get_or_insert_with(HashMap::new);
let slot = guard.get_or_insert_with(|| (HashMap::new(), VecDeque::new()));
let (map, order) = &mut *slot;
if map.contains_key(&path) {
// 已存在：仅更新值，不重复入队
map.insert(path, url);
return;
}
if map.len() >= MEM_CACHE_MAX {
// 简单清理：丢弃一半（最早插入的，HashMap 无序，近似随机）
let keep = map.len() / 2;
let keys: Vec<String> = map.keys().cloned().collect();
for k in keys.iter().skip(keep) {
map.remove(k);
// FIFO 淘汰最旧条目（O(1)），避免无序淘汰把刚插入的常用图标清掉
if let Some(oldest) = order.pop_front() {
map.remove(&oldest);
}
}
map.insert(path, url);
map.insert(path.clone(), url);
order.push_back(path);
}
}
src-tauri/src/quickpanel/mod.rs
+1 -1
View File
@@ -21,4 +21,4 @@ pub use commands::{
quickpanel_search_files, quickpanel_show_popup, quickpanel_show_window,
quickpanel_unregister_shortcut,
};
pub use popup::{ensure_window, load_settings, register_shortcut};
pub use popup::{ensure_window, load_settings};
src-tauri/src/quickpanel/popup.rs
+41 -76
View File
@@ -17,9 +17,10 @@ use std::path::PathBuf;
use serde::{Deserialize, Serialize};
use tauri::{AppHandle, Emitter, Manager, WebviewUrl, WebviewWindowBuilder};
use tauri::window::{Effect, EffectsBuilder};
use tauri_plugin_global_shortcut::{GlobalShortcutExt, Shortcut, ShortcutState};
use crate::clipboard::popup::{get_cursor_pos, get_work_area_at_point, get_dpi_for_point};
use crate::win32_util::{get_cursor_pos, get_work_area_at_point, get_dpi_for_point};
use specta::Type;
/// 弹窗窗口标签
pub const POPUP_LABEL: &str = "quick-panel";
@@ -28,15 +29,16 @@ pub const POPUP_LABEL: &str = "quick-panel";
const WIN_W: f64 = 600.0;
const WIN_H: f64 = 420.0;
/// 当前注册的快捷键（用于注销旧快捷键）
static CURRENT_SHORTCUT: Mutex<Option<String>> = Mutex::new(None);
/// 标志：show_popup 兜底创建路径设为 true，前端 onMounted 回调 show_window 时据此判断是否显示。
/// 预创建路径不设置，避免应用启动时弹窗自动弹出。
static POPUP_PENDING_SHOW: AtomicBool = AtomicBool::new(false);
/// 兜底创建路径下 show_popup 计算出的待显示位置（物理坐标），供 show_window 应用，
/// 避免窗口重建后仍停留在屏幕外 (-10000, -10000)。
static PENDING_POS: Mutex<Option<(f64, f64)>> = Mutex::new(None);
/// 自定义命令
#[derive(Clone, Serialize, Deserialize)]
#[derive(Clone, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct CustomCommand {
pub id: String,
@@ -47,7 +49,7 @@ pub struct CustomCommand {
}
/// 快速面板设置
#[derive(Clone, Serialize, Deserialize)]
#[derive(Clone, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct QuickPanelSettings {
/// 全局快捷键（如 "Alt+Space"），空字符串表示不注册。
@@ -131,56 +133,6 @@ pub fn save_settings(app: &AppHandle, settings: &QuickPanelSettings) -> Result<(
std::fs::write(&path, json).map_err(|e| format!("写入设置文件失败: {}", e))
}
/// 解析快捷键字符串为 Shortcut（格式如 "Alt+Space"、"Ctrl+Shift+P"）
/// 失败返回 None。
pub fn parse_shortcut(s: &str) -> Option<Shortcut> {
s.trim().parse::<Shortcut>().ok()
}
/// 注册全局快捷键。重复调用会先注销旧快捷键。
/// 传入空字符串则仅注销不注册。
pub fn register_shortcut(app: &AppHandle, shortcut_str: &str) -> Result<(), String> {
// 先注销旧快捷键
unregister_shortcut(app);
if shortcut_str.trim().is_empty() {
return Ok(());
}
let shortcut = parse_shortcut(shortcut_str)
.ok_or_else(|| format!("无效的快捷键: {}", shortcut_str))?;
let app_handle = app.clone();
app.global_shortcut()
.on_shortcut(shortcut, move |_app, _shortcut, event| {
// 仅在按下时触发（松开不触发）
if event.state == ShortcutState::Pressed {
show_popup(&app_handle);
}
})
.map_err(|e| format!("注册快捷键失败: {}", e))?;
if let Ok(mut cur) = CURRENT_SHORTCUT.lock() {
*cur = Some(shortcut_str.to_string());
}
eprintln!("[quickpanel] 已注册快捷键: {}", shortcut_str);
Ok(())
}
/// 注销当前快捷键
pub fn unregister_shortcut(app: &AppHandle) {
if let Ok(cur) = CURRENT_SHORTCUT.lock() {
if let Some(ref s) = *cur {
if let Some(shortcut) = parse_shortcut(s) {
let _ = app.global_shortcut().unregister(shortcut);
}
}
}
if let Ok(mut cur) = CURRENT_SHORTCUT.lock() {
*cur = None;
}
}
/// 创建弹窗窗口（隐藏状态）并注册失焦监听。
/// 位置默认在屏幕外，show_popup 时会重新定位到鼠标所在显示器中央。
/// 预创建后首次按快捷键走"窗口已存在"分支直接 show，避免首次创建的时序问题。
@@ -206,7 +158,7 @@ fn create_popup_window(app: &AppHandle) {
{
Ok(w) => w,
Err(e) => {
eprintln!("[quickpanel] 创建弹窗失败: {}", e);
crate::logger::log_error("quickpanel", &format!("创建弹窗失败: {}", e));
return;
}
};
@@ -217,11 +169,11 @@ fn create_popup_window(app: &AppHandle) {
win.on_window_event(move |event| {
if let tauri::WindowEvent::Focused(false) = event {
let _ = win_handle.hide();
let _ = app_handle.emit("quickpanel-hide", ());
let _ = app_handle.emit(crate::constants::events::QUICKPANEL_HIDE, ());
}
});
eprintln!("[quickpanel] 弹窗窗口已预创建（隐藏状态）");
crate::logger::log_info("quickpanel", "弹窗窗口已预创建（隐藏状态）");
}
/// 应用启动时预创建弹窗窗口（隐藏）。
@@ -250,41 +202,46 @@ pub fn show_popup(app: &AppHandle) {
let (wa_left, wa_top, wa_right, wa_bottom) = get_work_area_at_point(mx, my)
.unwrap_or((0, 0, 1920, 1040));
// 获取光标所在显示器的 DPI，将物理坐标转为逻辑坐标（DIP）
// 光标所在显示器的 DPI：窗口尺寸需按物理像素换算
let dpi = get_dpi_for_point(mx, my).unwrap_or(96);
let scale = dpi as f64 / 96.0;
let win_w_px = WIN_W * scale;
let win_h_px = WIN_H * scale;
let wa_left_l = wa_left as f64 / scale;
let wa_top_l = wa_top as f64 / scale;
let wa_right_l = wa_right as f64 / scale;
let wa_bottom_l = wa_bottom as f64 / scale;
// 直接以物理坐标计算（光标 + 工作区均为物理像素，避免混合 DPI 下换算偏移）
let (x, y) = if cursor_mode {
// 鼠标位置模式：以鼠标为基准偏移，clamp 到工作区内
let mx_l = mx as f64 / scale;
let my_l = my as f64 / scale;
let x = (mx_l + 12.0).min(wa_right_l - WIN_W).max(wa_left_l);
let y = (my_l + 12.0).min(wa_bottom_l - WIN_H).max(wa_top_l);
let x = (mx as f64 + 12.0 * scale).min(wa_right as f64 - win_w_px).max(wa_left as f64);
let y = (my as f64 + 12.0 * scale).min(wa_bottom as f64 - win_h_px).max(wa_top as f64);
(x, y)
} else {
// 中央模式：窗口居中于鼠标所在显示器工作区
let wa_w = wa_right_l - wa_left_l;
let wa_h = wa_bottom_l - wa_top_l;
(wa_left_l + (wa_w - WIN_W) / 2.0, wa_top_l + (wa_h - WIN_H) / 2.0)
let wa_w = (wa_right - wa_left) as f64;
let wa_h = (wa_bottom - wa_top) as f64;
(
wa_left as f64 + (wa_w - win_w_px) / 2.0,
wa_top as f64 + (wa_h - win_h_px) / 2.0,
)
};
// 窗口已存在：移动 + 显示 + 请求焦点
if let Some(win) = app.get_webview_window(POPUP_LABEL) {
let _ = win.set_position(tauri::Position::Logical(tauri::LogicalPosition { x, y }));
let _ = win.set_position(tauri::Position::Physical(tauri::PhysicalPosition {
x: x as i32,
y: y as i32,
}));
let _ = win.show();
let _ = win.set_focus();
// 通知前端刷新数据
let _ = app.emit("quickpanel-show", ());
let _ = app.emit(crate::constants::events::QUICKPANEL_SHOW, ());
return;
}
// 兜底：窗口被销毁时重新创建（隐藏），等前端 onMounted 回调 show_window
POPUP_PENDING_SHOW.store(true, Ordering::SeqCst);
if let Ok(mut pos) = PENDING_POS.lock() {
*pos = Some((x, y));
}
create_popup_window(app);
}
@@ -296,10 +253,18 @@ pub fn show_window(app: &AppHandle) {
return;
}
if let Some(win) = app.get_webview_window(POPUP_LABEL) {
// 应用 show_popup 计算的兜底位置（物理坐标），避免停留在屏幕外
let pos = PENDING_POS.lock().ok().and_then(|p| *p);
if let Some((x, y)) = pos {
let _ = win.set_position(tauri::Position::Physical(tauri::PhysicalPosition {
x: x as i32,
y: y as i32,
}));
}
let _ = win.show();
let _ = win.set_focus();
// 通知前端刷新数据
let _ = app.emit("quickpanel-show", ());
let _ = app.emit(crate::constants::events::QUICKPANEL_SHOW, ());
}
}
src-tauri/src/quickpanel/special_locations.rs
+3 -1
View File
@@ -9,8 +9,10 @@
use std::path::PathBuf;
use serde::Serialize;
use specta::Type;
/// 快捷位置条目
#[derive(Debug, Clone, Serialize)]
#[derive(Debug, Clone, Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct SpecialLocation {
pub id: String,
src-tauri/src/screenshot/commands.rs
+99 -3
View File
@@ -15,10 +15,11 @@
//! - screenshot_disable_transitions：禁用窗口显示/隐藏过渡动画（消除覆盖层缩放动画）
use super::{CaptureData, WindowInfo};
use tauri::Manager;
use tauri::{Emitter, Manager};
/// 禁用指定窗口（按 label 查找）的显示/隐藏过渡动画，消除覆盖层出现/消失时的缩放动画
#[tauri::command]
#[specta::specta]
pub async fn screenshot_disable_transitions(
app: tauri::AppHandle,
label: String,
@@ -48,22 +49,27 @@ pub async fn screenshot_disable_transitions(
/// 注册（或切换）截图全局快捷键。传入空字符串则禁用快捷键。
#[tauri::command]
#[specta::specta]
pub async fn screenshot_register_shortcut(
app: tauri::AppHandle,
shortcut: String,
) -> Result<(), String> {
super::shortcut::register_shortcut(&app, &shortcut)
crate::shortcut::register_shortcut(&app, "截图", &shortcut, |a| {
let _ = a.emit(crate::constants::events::SCREENSHOT_SHORTCUT, ());
})
}
/// 注销截图全局快捷键
#[tauri::command]
#[specta::specta]
pub async fn screenshot_unregister_shortcut(app: tauri::AppHandle) -> Result<(), String> {
super::shortcut::unregister_shortcut(&app);
crate::shortcut::unregister_shortcut(&app, "截图");
Ok(())
}
/// 捕获整个虚拟屏（多显示器拼接）存入静态，不做 PNG 编码
#[tauri::command]
#[specta::specta]
pub async fn screenshot_capture_fullscreen() -> Result<(), String> {
#[cfg(windows)]
{
@@ -101,6 +107,7 @@ pub async fn screenshot_get_fullscreen_bmp() -> Result<tauri::ipc::Response, Str
/// 全屏捕获编码为 PNG base64 并清除（全屏截图直接进编辑器）
#[tauri::command]
#[specta::specta]
pub async fn screenshot_fullscreen_png() -> Result<CaptureData, String> {
#[cfg(windows)]
{
@@ -116,6 +123,7 @@ pub async fn screenshot_fullscreen_png() -> Result<CaptureData, String> {
/// 清除静态全屏捕获（覆盖层关闭/取消时释放内存）
#[tauri::command]
#[specta::specta]
pub async fn screenshot_clear_fullscreen() -> Result<(), String> {
#[cfg(windows)]
{
@@ -130,6 +138,7 @@ pub async fn screenshot_clear_fullscreen() -> Result<(), String> {
/// 按物理像素坐标裁剪已存储的全屏捕获
#[tauri::command]
#[specta::specta]
pub async fn screenshot_crop_stored(
x: i32,
y: i32,
@@ -153,6 +162,7 @@ pub async fn screenshot_crop_stored(
/// 裁剪已存储的全屏捕获并直接写入剪贴板（一次 IPC 完成"裁剪+复制"）
#[tauri::command]
#[specta::specta]
pub async fn screenshot_crop_copy_stored(
x: i32,
y: i32,
@@ -176,6 +186,7 @@ pub async fn screenshot_crop_copy_stored(
/// 拾取指定物理屏幕坐标下的顶层窗口
#[tauri::command]
#[specta::specta]
pub async fn screenshot_window_from_point(
x: i32,
y: i32,
@@ -197,6 +208,7 @@ pub async fn screenshot_window_from_point(
/// 获取当前鼠标物理屏幕坐标（覆盖层打开时定位初始悬停窗口）
#[tauri::command]
#[specta::specta]
pub async fn screenshot_cursor_pos() -> Result<(i32, i32), String> {
#[cfg(windows)]
{
@@ -212,6 +224,7 @@ pub async fn screenshot_cursor_pos() -> Result<(i32, i32), String> {
/// 枚举所有可见顶层窗口
#[tauri::command]
#[specta::specta]
pub async fn screenshot_enum_windows() -> Result<Vec<WindowInfo>, String> {
#[cfg(windows)]
{
@@ -227,6 +240,7 @@ pub async fn screenshot_enum_windows() -> Result<Vec<WindowInfo>, String> {
/// 按 hwnd 捕获指定窗口
#[tauri::command]
#[specta::specta]
pub async fn screenshot_capture_window(hwnd: isize) -> Result<CaptureData, String> {
#[cfg(windows)]
{
@@ -250,6 +264,7 @@ pub async fn screenshot_capture_window(hwnd: isize) -> Result<CaptureData, Strin
/// 存入编辑器图片（base64 PNG）
#[tauri::command]
#[specta::specta]
pub async fn screenshot_set_editor_image(png_base64: String) -> Result<(), String> {
super::set_editor_image(png_base64);
Ok(())
@@ -257,12 +272,14 @@ pub async fn screenshot_set_editor_image(png_base64: String) -> Result<(), Strin
/// 取出编辑器图片（编辑器窗口加载时调用，取出即清除）
#[tauri::command]
#[specta::specta]
pub async fn screenshot_get_editor_image() -> Result<Option<String>, String> {
Ok(super::take_editor_image())
}
/// 将 PNG base64 写入系统剪贴板（转 CF_DIB）
#[tauri::command]
#[specta::specta]
pub async fn screenshot_copy_image(png_base64: String) -> Result<(), String> {
#[cfg(windows)]
{
@@ -283,6 +300,7 @@ pub async fn screenshot_copy_image(png_base64: String) -> Result<(), String> {
///
/// 省去前端 toDataURL(PNG 编码+base64) → Rust base64 解码 → PNG 解码 三次往返。
/// body 格式：前 8 字节 = width(i32 LE) + height(i32 LE)，之后为 raw RGBA 像素。
/// 注：参数为 tauri::ipc::Request（原始 body），specta 无法生成，豁免标注。
#[tauri::command]
pub async fn screenshot_compose_copy(
request: tauri::ipc::Request<'_>,
@@ -314,6 +332,7 @@ pub async fn screenshot_compose_copy(
/// 将 PNG base64 写入文件
#[tauri::command]
#[specta::specta]
pub async fn screenshot_save_png(png_base64: String, path: String) -> Result<(), String> {
tauri::async_runtime::spawn_blocking(move || {
#[cfg(windows)]
@@ -329,3 +348,80 @@ pub async fn screenshot_save_png(png_base64: String, path: String) -> Result<(),
.await
.map_err(|e| format!("保存任务失败: {}", e))?
}
// ===== 截图历史缓存：完整 PNG 落盘缓存目录，内存只保留缩略图 =====
/// 历史缓存根目录（app_cache_dir/screenshot/history）
fn history_cache_dir(app: &tauri::AppHandle) -> Result<std::path::PathBuf, String> {
let dir = app
.path()
.app_cache_dir()
.map_err(|e| format!("获取缓存目录失败: {}", e))?
.join("screenshot")
.join("history");
std::fs::create_dir_all(&dir).map_err(|e| format!("创建缓存目录失败: {}", e))?;
Ok(dir)
}
/// 校验 path 属于历史缓存目录（防止路径穿越/任意文件读写）
fn ensure_in_history_dir(app: &tauri::AppHandle, path: &str) -> Result<std::path::PathBuf, String> {
let dir = history_cache_dir(app)?;
let p = std::path::PathBuf::from(path);
if !p.starts_with(&dir) {
return Err("非法路径：不在截图历史缓存目录内".into());
}
Ok(p)
}
/// 将完整 PNG 写入历史缓存目录，返回文件路径
#[tauri::command]
#[specta::specta]
pub async fn screenshot_save_cache(
app: tauri::AppHandle,
png_base64: String,
) -> Result<String, String> {
tauri::async_runtime::spawn_blocking(move || {
let dir = history_cache_dir(&app)?;
// 时间戳微秒命名（避免引入额外依赖；并发截图的同微秒碰撞可忽略）
let ts = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_micros())
.unwrap_or(0);
let path = dir.join(format!("{}.png", ts));
super::capture::save_png_to_file(&png_base64, &path.to_string_lossy())?;
Ok(path.to_string_lossy().into_owned())
})
.await
.map_err(|e| format!("缓存任务失败: {}", e))?
}
/// 从历史缓存目录读取 PNG 并返回 base64（点击历史项复制/保存时一次性加载，不常驻内存）
#[tauri::command]
#[specta::specta]
pub async fn screenshot_load_cache(
app: tauri::AppHandle,
path: String,
) -> Result<String, String> {
tauri::async_runtime::spawn_blocking(move || {
let p = ensure_in_history_dir(&app, &path)?;
let bytes = std::fs::read(&p).map_err(|e| format!("读取缓存失败: {}", e))?;
use base64::Engine as _;
Ok(base64::engine::general_purpose::STANDARD.encode(bytes))
})
.await
.map_err(|e| format!("读取缓存任务失败: {}", e))?
}
/// 删除历史缓存文件（历史项移除/清空时调用，静默忽略不存在文件）
#[tauri::command]
#[specta::specta]
pub async fn screenshot_delete_cache(app: tauri::AppHandle, path: String) -> Result<(), String> {
tauri::async_runtime::spawn_blocking(move || {
if let Ok(p) = ensure_in_history_dir(&app, &path) {
let _ = std::fs::remove_file(p);
}
Ok(())
})
.await
.map_err(|e| format!("删除缓存任务失败: {}", e))?
}
src-tauri/src/screenshot/mod.rs
+5 -4
View File
@@ -5,13 +5,14 @@
use std::sync::Mutex;
use specta::Type;
#[cfg(windows)]
pub mod capture;
pub mod commands;
pub mod shortcut;
/// 前端可见的捕获数据
#[derive(serde::Serialize)]
#[derive(serde::Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct CaptureData {
pub png_base64: String,
@@ -20,7 +21,7 @@ pub struct CaptureData {
}
/// 窗口信息（窗口拾取 / 枚举）
#[derive(serde::Serialize)]
#[derive(serde::Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct WindowInfo {
pub hwnd: isize,
@@ -30,7 +31,7 @@ pub struct WindowInfo {
pub visual_rect: Option<ScreenRect>,
}
#[derive(serde::Serialize, Clone, Copy)]
#[derive(serde::Serialize, Clone, Copy, Type)]
#[serde(rename_all = "camelCase")]
pub struct ScreenRect {
pub x: i32,
src-tauri/src/screenshot/shortcut.rs
-60
View File
@@ -1,60 +0,0 @@
//! 截图全局快捷键：可自定义注册/注销（默认 Ctrl+Alt+A）。
//!
//! 与剪贴板快捷弹窗（clipboard::popup）的实现一致：
//! 用 `on_shortcut` 为每个快捷键绑定独立处理器，切换时先注销旧的再注册新的。
//! 按下时 emit `screenshot-shortcut` 事件，前端 store 监听后触发 startCapture。
use std::sync::Mutex;
use tauri::{AppHandle, Emitter};
use tauri_plugin_global_shortcut::{GlobalShortcutExt, Shortcut, ShortcutState};
/// 当前已注册的快捷键字符串（用于切换时注销旧快捷键）
static CURRENT_SHORTCUT: Mutex<Option<String>> = Mutex::new(None);
/// 解析快捷键字符串为 Shortcut（格式如 "Ctrl+Alt+A"、"Shift+PrintScreen"）
pub fn parse_shortcut(s: &str) -> Option<Shortcut> {
s.trim().parse::<Shortcut>().ok()
}
/// 注册全局快捷键。重复调用会先注销旧快捷键。
/// 传入空字符串则仅注销不注册（禁用快捷键）。
pub fn register_shortcut(app: &AppHandle, shortcut_str: &str) -> Result<(), String> {
unregister_shortcut(app);
if shortcut_str.trim().is_empty() {
return Ok(());
}
let shortcut = parse_shortcut(shortcut_str)
.ok_or_else(|| format!("无效的快捷键: {}", shortcut_str))?;
let app_handle = app.clone();
app.global_shortcut()
.on_shortcut(shortcut, move |_app, _shortcut, event| {
// 仅在按下时触发（松开不触发）
if event.state == ShortcutState::Pressed {
let _ = app_handle.emit("screenshot-shortcut", ());
}
})
.map_err(|e| format!("注册快捷键失败: {}", e))?;
if let Ok(mut cur) = CURRENT_SHORTCUT.lock() {
*cur = Some(shortcut_str.to_string());
}
eprintln!("[screenshot] 已注册快捷键: {}", shortcut_str);
Ok(())
}
/// 注销当前快捷键
pub fn unregister_shortcut(app: &AppHandle) {
if let Ok(cur) = CURRENT_SHORTCUT.lock() {
if let Some(ref s) = *cur {
if let Some(shortcut) = parse_shortcut(s) {
let _ = app.global_shortcut().unregister(shortcut);
}
}
}
if let Ok(mut cur) = CURRENT_SHORTCUT.lock() {
*cur = None;
}
}
src-tauri/src/setup.rs
+142
View File
@@ -0,0 +1,142 @@
//! 应用启动初始化 —— 从 lib.rs 的 setup 闭包拆出，按子系统分组。
//!
//! 各子系统职责边界：
//! - 日志：LogManager（全局日志）
//! - 代理：MihomoManager + 自动启动
//! - 监控：MonitorKernel + NetworkMonitor + 自动启动
//! - 下载：DownloadEngine + 扩展 HTTP API 服务
//! - 剪贴板：ClipboardManager + 快捷键 + 预创建弹窗
//! - 快速面板：快捷键 + 预创建弹窗 + 文件索引
//! - 托盘：自定义菜单窗口
//! - 进程：监控线程
use std::sync::Arc;
use tauri::{App, Manager, Wry};
use crate::download_engine::{DownloadEngine, ExtensionServer};
use crate::logger::LogManager;
use crate::mihomo_manager::MihomoManager;
use crate::monitor_kernel::{MonitorKernel, check_and_relaunch_if_needed};
use crate::network_monitor::NetworkMonitor;
use crate::process_manager::{ProcessManager, start_monitoring_thread};
/// 应用启动初始化入口（setup 闭包调用）。
/// 初始化顺序即依赖顺序：日志 → 数据目录 → 各管理器 → 托盘 → 进程监控 → 自动启动。
pub fn init(app: &mut App<Wry>) -> Result<(), Box<dyn std::error::Error>> {
// ===== 日志系统：{app_data_dir}/logs/ =====
let log_dir = app
.path()
.app_data_dir()
.unwrap_or_else(|_| std::path::PathBuf::from("."))
.join("logs");
let log_manager = LogManager::new(log_dir);
// 注册为 Tauri State（供 log_* 命令），同时安装进程级全局日志器（供后端模块 log_line 使用）
crate::logger::install_global(log_manager.clone());
app.manage(log_manager);
// ===== 数据目录：{app_data_dir}/ =====
let app_data_dir = app
.path()
.app_data_dir()
.unwrap_or_else(|_| std::path::PathBuf::from("."));
// 永久提权检查：如果标志已设置且当前非管理员，以管理员权限重启自身并退出
// 必须在所有模块初始化之前执行（此时无资源需要清理）
if check_and_relaunch_if_needed(&app_data_dir) {
std::process::exit(0);
}
// ===== 代理模块：MihomoManager =====
let mihomo = MihomoManager::new(app_data_dir.clone());
app.manage(mihomo);
// ===== 监控模块：MonitorKernel（硬件）+ NetworkMonitor（网速） =====
let monitor = MonitorKernel::new(app_data_dir.clone());
app.manage(monitor);
// 网速采样不依赖提权，应用启动即开始
let network_monitor = Arc::new(NetworkMonitor::new());
app.manage(network_monitor.clone());
network_monitor.start(app.handle().clone());
// ===== 下载模块：DownloadEngine + 扩展 HTTP API 服务 =====
let engine = DownloadEngine::new(app_data_dir.join("downloader"), app.handle().clone());
let settings = engine.get_settings();
app.manage(engine.clone());
let server_engine = engine.clone();
let server_port = settings.extension_port;
let server_secret = settings.extension_secret.clone();
tauri::async_runtime::spawn(async move {
ExtensionServer::start(server_engine, server_port, server_secret).await;
});
// ===== 剪贴板模块：监听 + 快捷键 + 预创建弹窗 =====
let clipboard = crate::clipboard::ClipboardManager::new(app_data_dir.clone());
// 应用启动时若已启用则自动开始监听
if clipboard.get_settings().enabled {
clipboard.start(&app.handle());
}
// 应用启动时注册快捷弹窗全局快捷键（共享工具模块）
let shortcut = clipboard.get_settings().shortcut.clone();
if !shortcut.trim().is_empty() {
let app_handle = app.handle().clone();
if let Err(e) = crate::shortcut::register_shortcut(&app_handle, "剪贴板", &shortcut, |a| {
crate::clipboard::popup::show_popup(a)
}) {
crate::logger::log_error("clipboard", &format!("快捷键注册失败: {}", e));
}
// 预创建弹窗窗口（隐藏），首次按快捷键时直接 show，避免首次创建时序问题
crate::clipboard::popup::ensure_popup_window(&app_handle);
}
app.manage(clipboard);
// ===== 快速面板：快捷键 + 预创建弹窗 + 文件索引 =====
// defaultEnabled:true 假设启用；用户在设置页禁用模块时由前端 onDisable 钩子注销快捷键。
let qp_settings = crate::quickpanel::load_settings(&app.handle());
if !qp_settings.shortcut.trim().is_empty() {
let app_handle = app.handle().clone();
if let Err(e) = crate::shortcut::register_shortcut(
&app_handle,
"快速面板",
&qp_settings.shortcut,
|a| crate::quickpanel::popup::show_popup(a),
) {
crate::logger::log_error("quickpanel", &format!("快捷键注册失败: {}", e));
}
// 预创建弹窗窗口（隐藏），首次按快捷键时直接 show，避免首次创建时序问题
crate::quickpanel::ensure_window(&app_handle);
}
// 初始化文件索引数据库（不立即构建，由前端设置页或首次唤起时触发）
crate::quickpanel::file_index::init(&app.handle());
// ===== 托盘菜单 =====
crate::tray_menu::create_tray_menu(app.handle())?;
// ===== 进程监控线程 =====
start_monitoring_thread(app.handle().clone());
// ===== 自动启动（随应用启动，不依赖模块启用） =====
// mihomo：用户在设置中开启"自动启动"时随应用启动
if let Some(mihomo) = app.try_state::<MihomoManager>() {
if let Some(pm) = app.try_state::<ProcessManager>() {
mihomo.auto_start_on_launch(app.handle(), &pm);
}
}
// monitor Kernel：硬件监控默认启用，被动读取无副作用
if let Some(monitor) = app.try_state::<MonitorKernel>() {
let monitor = monitor.inner().clone();
let app_handle = app.handle().clone();
tauri::async_runtime::spawn(async move {
match monitor.start_with_subscription(&app_handle).await {
Ok(info) => crate::logger::log_info("monitor", &format!("自动启动成功, pid={:?}", info.pid)),
Err(e) => crate::logger::log_warn("monitor", &format!("自动启动跳过: {}", e)),
}
});
}
// 截图快捷键由前端 screenshotStore 启动时调用 screenshot_register_shortcut 注册
// （支持自定义，默认 Ctrl+Alt+A），此处不再硬编码注册
Ok(())
}
src-tauri/src/shortcut.rs
+87
View File
@@ -0,0 +1,87 @@
//! 全局快捷键共享工具：剪贴板 / 快速面板 / 截图三处复用的注册逻辑。
//!
//! 提供：
//! - 原子化注册：先注销本模块旧快捷键，冲突检测通过后再注册新的，
//! 注册失败返回错误（快捷键被系统或其他应用占用时前端可提示用户）。
//! - 应用内冲突检测：同一组合键不允许被两个模块同时占用，
//! 避免后注册的 `on_shortcut` 静默覆盖先注册的处理器。
use std::collections::HashMap;
use std::sync::{Mutex, OnceLock};
use tauri::AppHandle;
use tauri_plugin_global_shortcut::{GlobalShortcutExt, Shortcut, ShortcutState};
/// 快捷键占用表：模块名（中文，用于错误提示）→ 快捷键字符串
static REGISTRY: OnceLock<Mutex<HashMap<String, String>>> = OnceLock::new();
fn registry() -> &'static Mutex<HashMap<String, String>> {
REGISTRY.get_or_init(|| Mutex::new(HashMap::new()))
}
/// 解析快捷键字符串为 Shortcut（格式如 "Alt+V"、"Ctrl+Shift+V"）
/// 失败返回 None。
pub fn parse_shortcut(s: &str) -> Option<Shortcut> {
s.trim().parse::<Shortcut>().ok()
}
/// 原子化注册全局快捷键。
///
/// - 先注销 `module` 已注册的旧快捷键（空字符串则仅注销，用于禁用）。
/// - 注册前做应用内冲突检测：同一组合键被其他模块占用时返回错误。
/// - 注册成功后登记占用表；失败则返回错误且不登记（此时本模块快捷键为未注册状态）。
pub fn register_shortcut<F>(
app: &AppHandle,
module: &str,
shortcut_str: &str,
handler: F,
) -> Result<(), String>
where
F: Fn(&AppHandle) + Send + Sync + 'static,
{
// 1. 注销本模块旧快捷键（释放占用条目）
unregister_shortcut(app, module);
let key = shortcut_str.trim().to_string();
if key.is_empty() {
return Ok(());
}
// 2. 应用内冲突检测
if let Ok(reg) = registry().lock() {
if let Some(owner) = reg.values().find(|v| **v == key) {
return Err(format!("快捷键 {} 已被「{}」模块占用，请更换", key, owner));
}
}
let shortcut = parse_shortcut(&key).ok_or_else(|| format!("无效的快捷键: {}", key))?;
let app_handle = app.clone();
app.global_shortcut()
.on_shortcut(shortcut, move |_a, _s, event| {
// 仅在按下时触发（松开不触发）
if event.state == ShortcutState::Pressed {
handler(&app_handle);
}
})
.map_err(|e| format!("注册快捷键 {} 失败: {}", key, e))?;
// 3. 登记占用
if let Ok(mut reg) = registry().lock() {
reg.insert(module.to_string(), key.clone());
}
crate::logger::log_info(module, &format!("已注册快捷键: {}", shortcut_str));
Ok(())
}
/// 注销 `module` 的全局快捷键并释放占用条目
pub fn unregister_shortcut(app: &AppHandle, module: &str) {
let old = registry()
.lock()
.unwrap_or_else(|e| e.into_inner())
.remove(module);
if let Some(s) = old {
if let Some(shortcut) = parse_shortcut(&s) {
let _ = app.global_shortcut().unregister(shortcut);
}
}
}
src-tauri/src/snap_fix.rs
+1 -1
View File
@@ -63,7 +63,7 @@ unsafe extern "system" fn fix_subclass_proc(
#[tauri::command]
pub async fn fix_snap_background(app: AppHandle) -> Result<(), String> {
let main_window = app
.get_webview_window("main")
.get_webview_window(crate::constants::windows::MAIN)
.ok_or("main window not found")?;
let hwnd_isize: isize = {
src-tauri/src/tray_menu.rs
+46 -102
View File
@@ -20,14 +20,12 @@ use tauri::{
/// 记录窗口最后显示时间，用于失焦防抖（避免显示瞬间因焦点未稳定而被立即隐藏）
static LAST_SHOW_TIME: Mutex<Option<Instant>> = Mutex::new(None);
/// 保存最近一次右键时计算出的定位参数（逻辑坐标），供 `tray_menu_ready` 使用
/// (x, tray_top_l, wa_top_l, wa_bottom_l, scale)
/// 保存最近一次右键时计算出的定位参数（物理坐标），供 `tray_menu_ready` 使用
/// (x, tray_top, wa_top, wa_bottom, scale)
static LAST_MENU_LAYOUT: Mutex<Option<(f64, f64, f64, f64, f64)>> = Mutex::new(None);
use crate::clipboard::popup::{get_work_area, get_work_area_at_point, get_dpi_for_point};
use crate::clipboard::ClipboardManager;
use crate::download_engine::DownloadEngine;
use crate::mihomo_manager::MihomoManager;
use crate::win32_util::{get_work_area, get_work_area_at_point, get_dpi_for_point};
use crate::mihomo_manager::{MihomoManager, is_pseudo_node};
use crate::monitor_kernel::MonitorKernel;
use crate::process_manager::{ProcessManager, ProcessStatus};
@@ -54,37 +52,6 @@ pub struct TrayMenuState {
pub proxy_current: Option<String>,
}
// ===== 伪节点过滤（与前端 ProxyModule 保持一致） =====
const PSEUDO_KEYWORDS: &[&str] = &[
"DIRECT",
"REJECT",
"PASS",
"COMPATIBLE",
"流量",
"套餐",
"到期",
"续费",
"官网",
"网站",
"刷新",
"更新",
"⭐",
"★",
"☆",
"✕",
"✖",
"×",
];
fn is_pseudo_node(name: &str) -> bool {
let upper = name.trim().to_uppercase();
if upper == "DIRECT" || upper == "REJECT" || upper == "PASS" || upper == "GLOBAL" {
return true;
}
PSEUDO_KEYWORDS.iter().any(|kw| name.contains(kw))
}
// ===== 状态查询 =====
fn is_proxy_running(app: &AppHandle) -> bool {
@@ -252,7 +219,7 @@ pub fn precreate_tray_menu_window(app: &AppHandle) {
{
Ok(w) => w,
Err(e) => {
eprintln!("[tray-menu] 预创建菜单窗口失败: {}", e);
crate::logger::log_error("tray", &format!("预创建菜单窗口失败: {}", e));
return;
}
};
@@ -262,7 +229,7 @@ pub fn precreate_tray_menu_window(app: &AppHandle) {
win.on_window_event(move |event| {
if let tauri::WindowEvent::Focused(false) = event {
let should_hide = {
let t = LAST_SHOW_TIME.lock().unwrap();
let t = LAST_SHOW_TIME.lock().unwrap_or_else(|e| e.into_inner());
match *t {
Some(time) => time.elapsed() > Duration::from_millis(300),
None => true,
@@ -274,7 +241,7 @@ pub fn precreate_tray_menu_window(app: &AppHandle) {
}
});
eprintln!("[tray-menu] 菜单窗口已预创建（隐藏渲染）");
crate::logger::log_info("tray", "菜单窗口已预创建（隐藏渲染）");
}
/// 右键托盘时调用：计算定位参数、发送状态给前端，但不立即显示窗口。
@@ -289,29 +256,23 @@ pub fn show_tray_menu(app: &AppHandle, cursor_pos: (f64, f64), tray_rect: (f64,
let (wa_left, wa_top, wa_right, wa_bottom) = get_work_area_at_point(mx as i32, my as i32)
.unwrap_or((0, 0, 1920, 1040));
// 获取光标所在显示器的 DPI，将物理坐标转为逻辑坐标（DIP）
// 光标所在显示器的 DPI：菜单宽度按物理像素换算
let dpi = get_dpi_for_point(mx as i32, my as i32).unwrap_or(96);
let scale = dpi as f64 / 96.0;
let menu_w_px = MENU_W * scale;
let mx_l = mx / scale;
let tray_top_l = tray_top / scale;
let wa_left_l = wa_left as f64 / scale;
let wa_right_l = wa_right as f64 / scale;
let wa_top_l = wa_top as f64 / scale;
let wa_bottom_l = wa_bottom as f64 / scale;
// 水平：菜单左边缘对齐鼠标 X（向右延伸），超出右边界则左移（物理坐标）
let x = mx.max(wa_left as f64).min(wa_right as f64 - menu_w_px);
// 水平：菜单左边缘对齐鼠标 X（向右延伸），超出右边界则左移
let x = mx_l.max(wa_left_l).min(wa_right_l - MENU_W);
// 保存布局参数，供 tray_menu_ready 使用
// 保存布局参数（全部物理坐标 + scale，供 tray_menu_ready 换算前端上报的逻辑高度）
{
let mut layout = LAST_MENU_LAYOUT.lock().unwrap();
*layout = Some((x, tray_top_l, wa_top_l, wa_bottom_l, scale));
let mut layout = LAST_MENU_LAYOUT.lock().unwrap_or_else(|e| e.into_inner());
*layout = Some((x, tray_top, wa_top as f64, wa_bottom as f64, scale));
}
// 记录显示时间，用于失焦防抖
{
let mut t = LAST_SHOW_TIME.lock().unwrap();
let mut t = LAST_SHOW_TIME.lock().unwrap_or_else(|e| e.into_inner());
*t = Some(Instant::now());
}
@@ -324,7 +285,7 @@ pub fn show_tray_menu(app: &AppHandle, cursor_pos: (f64, f64), tray_rect: (f64,
let app_clone = app.clone();
tauri::async_runtime::spawn(async move {
let state = get_tray_menu_state(&app_clone).await;
let _ = app_clone.emit("tray-menu-show", state);
let _ = app_clone.emit(crate::constants::events::TRAY_MENU_SHOW, state);
});
}
@@ -338,7 +299,7 @@ pub fn hide_tray_menu(app: &AppHandle) {
/// 刷新菜单状态并发送给前端
async fn refresh_and_emit_state(app: &AppHandle) {
let state = get_tray_menu_state(app).await;
let _ = app.emit("tray-menu-state-updated", state);
let _ = app.emit(crate::constants::events::TRAY_MENU_STATE_UPDATED, state);
}
// ===== Tauri 命令 =====
@@ -353,13 +314,13 @@ pub async fn tray_menu_action(
match action.as_str() {
"proxy_enable" => {
if let Err(e) = enable_proxy(&app).await {
eprintln!("[tray] 开启代理失败: {}", e);
crate::logger::log_error("tray", &format!("开启代理失败: {}", e));
send_notification(&app, "代理启动失败", &e);
}
}
"proxy_disable" => {
if let Err(e) = disable_proxy(&app).await {
eprintln!("[tray] 关闭代理失败: {}", e);
crate::logger::log_error("tray", &format!("关闭代理失败: {}", e));
send_notification(&app, "代理关闭失败", &e);
}
}
@@ -378,28 +339,28 @@ pub async fn tray_menu_action(
}
}
"osd_toggle" => {
let _ = app.emit("tray:toggle-osd", ());
let _ = app.emit(crate::constants::events::TRAY_TOGGLE_OSD, ());
}
"kernel_restart" => {
if let Err(e) = restart_kernel(&app).await {
eprintln!("[tray] 重启 Kernel 失败: {}", e);
crate::logger::log_error("tray", &format!("重启 Kernel 失败: {}", e));
send_notification(&app, "Kernel 重启失败", &e);
}
}
"download_new" => {
if let Some(window) = app.get_webview_window("main") {
if let Some(window) = app.get_webview_window(crate::constants::windows::MAIN) {
window.show().ok();
window.set_focus().ok();
}
let _ = app.emit("tray:new-download", ());
let _ = app.emit(crate::constants::events::TRAY_NEW_DOWNLOAD, ());
hide_tray_menu(&app);
}
"settings" => {
if let Some(window) = app.get_webview_window("main") {
if let Some(window) = app.get_webview_window(crate::constants::windows::MAIN) {
window.show().ok();
window.set_focus().ok();
}
let _ = app.emit("tray:open-settings", ());
let _ = app.emit(crate::constants::events::TRAY_OPEN_SETTINGS, ());
hide_tray_menu(&app);
}
"quit" => {
@@ -431,24 +392,29 @@ pub async fn tray_menu_ready(content_height: f64, app: AppHandle) -> Result<(),
let win = app.get_webview_window(TRAY_MENU_LABEL)
.ok_or("tray-menu window not found")?;
let (x, tray_top_l, wa_top_l, wa_bottom_l, _scale) = {
let layout = LAST_MENU_LAYOUT.lock().unwrap();
let (x, tray_top, wa_top, wa_bottom, scale) = {
let layout = LAST_MENU_LAYOUT.lock().unwrap_or_else(|e| e.into_inner());
layout.unwrap_or((0.0, 1040.0, 0.0, 1040.0, 1.0))
};
// 将内容高度限制在合理范围内
// 将内容高度限制在合理范围内（前端上报为逻辑像素）
let h = content_height.max(100.0).min(520.0);
// 调整窗口尺寸
let _ = win.set_size(tauri::Size::Logical(tauri::LogicalSize {
width: MENU_W,
height: h,
// 调整窗口尺寸（物理像素，与物理坐标定位保持一致，避免混合 DPI 换算偏移）
let win_w_px = MENU_W * scale;
let win_h_px = h * scale;
let _ = win.set_size(tauri::Size::Physical(tauri::PhysicalSize {
width: win_w_px as u32,
height: win_h_px as u32,
}));
// 垂直：菜单下边缘紧贴托盘图标顶部（向上弹出）
let y = (tray_top_l - h).max(wa_top_l).min(wa_bottom_l - h);
// 垂直：菜单下边缘紧贴托盘图标顶部（向上弹出，物理坐标）
let y = (tray_top - win_h_px).max(wa_top).min(wa_bottom - win_h_px);
let pos = tauri::Position::Logical(tauri::LogicalPosition { x, y });
let pos = tauri::Position::Physical(tauri::PhysicalPosition {
x: x as i32,
y: y as i32,
});
let _ = win.set_position(pos);
let _ = win.show();
let _ = win.set_focus();
@@ -605,7 +571,7 @@ async fn select_proxy_node(app: &AppHandle, group: &str, name: &str) {
send_notification(app, "节点已切换", &format!("{}\n延迟: {}", name, delay_text));
}
Err(e) => {
eprintln!("[tray] 切换节点失败: {}", e);
crate::logger::log_error("tray", &format!("切换节点失败: {}", e));
send_notification(app, "切换节点失败", &e);
}
}
@@ -657,34 +623,12 @@ fn send_notification(app: &AppHandle, title: &str, message: &str) {
.show();
}
// ===== 退出清理 =====
// ===== 退出入口 =====
/// 托盘菜单"退出"调用。
/// 资源清理统一收敛到 RunEvent::ExitRequested（覆盖所有退出路径），此处仅请求退出，
/// 避免清理逻辑双份执行（monitor 的 cleanup 涉及子进程/网络，重复执行有竞态风险）。
pub fn quit_cleanup(app: &AppHandle) {
if let Some(mihomo) = app.try_state::<MihomoManager>() {
mihomo.cleanup_on_exit();
}
if let Some(engine) = app.try_state::<DownloadEngine>() {
engine.cleanup_on_exit();
}
// monitor.cleanup_on_exit 是 async，在 tokio worker 线程中直接 block_on 会 panic，
// 放到独立 OS 线程执行 block_on，避免嵌套 runtime。
if let Some(monitor) = app.try_state::<MonitorKernel>() {
let app_clone = app.clone();
let monitor_clone = monitor.inner().clone();
std::thread::spawn(move || {
tauri::async_runtime::block_on(async move {
monitor_clone.cleanup_on_exit(&app_clone).await;
});
})
.join()
.ok();
}
if let Some(clip) = app.try_state::<ClipboardManager>() {
clip.stop();
}
if let Some(pm) = app.try_state::<ProcessManager>() {
pm.stop_all();
}
app.exit(0);
}
@@ -704,7 +648,7 @@ pub fn create_tray_menu(app: &AppHandle) -> Result<(), tauri::Error> {
..
} => {
// 左键：显示主窗口
if let Some(window) = app.get_webview_window("main") {
if let Some(window) = app.get_webview_window(crate::constants::windows::MAIN) {
window.show().ok();
window.set_focus().ok();
}
src-tauri/src/win32_util.rs
+96
View File
@@ -0,0 +1,96 @@
//! Win32 屏幕/光标/DPI 工具 —— 跨模块共享的平台封装。
//!
//! 从 `clipboard::popup` 迁出，供剪贴板弹窗、快速面板、托盘菜单等多窗口模块统一引用，
//! 避免其他模块反向依赖剪贴板模块。
/// 获取鼠标位置（屏幕坐标，物理像素）
#[cfg(windows)]
pub fn get_cursor_pos() -> Option<(i32, i32)> {
use windows_sys::Win32::Foundation::POINT;
use windows_sys::Win32::UI::WindowsAndMessaging::GetCursorPos;
let mut pt = POINT { x: 0, y: 0 };
unsafe {
if GetCursorPos(&mut pt) != 0 {
Some((pt.x, pt.y))
} else {
None
}
}
}
/// 获取主屏工作区尺寸（排除任务栏，物理像素）
#[cfg(windows)]
pub fn get_work_area() -> Option<(f64, f64)> {
use windows_sys::Win32::Foundation::RECT;
use windows_sys::Win32::UI::WindowsAndMessaging::{
SystemParametersInfoW, SPI_GETWORKAREA,
};
let mut rect = RECT { left: 0, top: 0, right: 0, bottom: 0 };
unsafe {
if SystemParametersInfoW(SPI_GETWORKAREA, 0, &mut rect as *mut _ as *mut _, 0) != 0 {
Some(((rect.right - rect.left) as f64, (rect.bottom - rect.top) as f64))
} else {
None
}
}
}
/// 获取指定点所在显示器的工作区（排除任务栏），返回 (left, top, right, bottom) 物理像素。
/// 使用 MonitorFromPoint 支持多显示器环境。
#[cfg(windows)]
pub fn get_work_area_at_point(x: i32, y: i32) -> Option<(i32, i32, i32, i32)> {
use windows_sys::Win32::Foundation::POINT;
use windows_sys::Win32::Graphics::Gdi::{
GetMonitorInfoW, MonitorFromPoint, MONITORINFO, MONITOR_DEFAULTTONEAREST,
};
let pt = POINT { x, y };
let hmon = unsafe { MonitorFromPoint(pt, MONITOR_DEFAULTTONEAREST) };
let mut mi: MONITORINFO = unsafe { std::mem::zeroed() };
mi.cbSize = std::mem::size_of::<MONITORINFO>() as u32;
unsafe {
if GetMonitorInfoW(hmon, &mut mi) != 0 {
let rc = mi.rcWork;
Some((rc.left, rc.top, rc.right, rc.bottom))
} else {
None
}
}
}
/// 获取指定点所在显示器的有效 DPI。
/// scale factor = dpi / 96。
#[cfg(windows)]
pub fn get_dpi_for_point(x: i32, y: i32) -> Option<u32> {
use windows_sys::Win32::Foundation::POINT;
use windows_sys::Win32::Graphics::Gdi::{MonitorFromPoint, MONITOR_DEFAULTTONEAREST};
use windows_sys::Win32::UI::HiDpi::{GetDpiForMonitor, MDT_EFFECTIVE_DPI};
let pt = POINT { x, y };
let hmon = unsafe { MonitorFromPoint(pt, MONITOR_DEFAULTTONEAREST) };
let mut dpi_x: u32 = 0;
let mut dpi_y: u32 = 0;
unsafe {
if GetDpiForMonitor(hmon, MDT_EFFECTIVE_DPI, &mut dpi_x, &mut dpi_y) == 0 {
Some(dpi_x)
} else {
None
}
}
}
// ===== 非 Windows 平台空实现 =====
#[cfg(not(windows))]
pub fn get_cursor_pos() -> Option<(i32, i32)> { None }
#[cfg(not(windows))]
pub fn get_work_area() -> Option<(f64, f64)> { None }
#[cfg(not(windows))]
pub fn get_work_area_at_point(_x: i32, _y: i32) -> Option<(i32, i32, i32, i32)> { None }
#[cfg(not(windows))]
pub fn get_dpi_for_point(_x: i32, _y: i32) -> Option<u32> { None }
src-tauri/tauri.conf.json
+2 -2
View File
@@ -12,7 +12,7 @@
"app": {
"windows": [
{
"title": "thing",
"title": "Thing",
"width": 1000,
"height": 700,
"decorations": false,
@@ -24,7 +24,7 @@
}
],
"security": {
"csp": null
"csp": "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data: blob: asset: http://asset.localhost; font-src 'self' data:; connect-src ipc: http://ipc.localhost; media-src 'self' data: blob:"
}
},
"bundle": {