diff --git a/ThingHK/HardwareManager.cs b/ThingHK/HardwareManager.cs index 96a7e13..0ba7735 100644 --- a/ThingHK/HardwareManager.cs +++ b/ThingHK/HardwareManager.cs @@ -24,6 +24,9 @@ internal sealed class HardwareManager : IDisposable private readonly bool _isAdmin; private readonly double _coldStartMs; private readonly Stopwatch _startupSw; + // 传感器 ID 缓存：避免每秒为每个传感器重复拼接字符串（减少 GC 压力） + private readonly Dictionary _sensorIdCache = new(); + private bool _coldStartSent; private bool _ready; private bool _closed; private HardwareConfig _config; @@ -84,7 +87,7 @@ internal sealed class HardwareManager : IDisposable /// /// 全量 Update 所有硬件。 - /// 由 SamplingScheduler 按通道分频调用。 + /// 仅用于构造函数首轮填充，运行期由调度器分频调用 UpdateFastOnly/UpdateSlowOnly。 /// public void UpdateAll() { @@ -94,9 +97,24 @@ internal sealed class HardwareManager : IDisposable } } + /// + /// 仅 Update 快通道硬件（CPU/GPU/Memory/Network 等）。 + /// 由调度器快通道 tick 高频调用，避免 SMART 等重查询拖慢采样节奏。 + /// + public void UpdateFastOnly() + { + foreach (var hw in _visitor.AllHardware) + { + if (!IsSlowHardware(hw.HardwareType)) + { + try { hw.Update(); } catch { /* 单个硬件 Update 失败不影响整体 */ } + } + } + } + /// /// 仅 Update 慢通道硬件（Storage/PSU/Battery 等）。 - /// 快通道硬件（CPU/GPU/Memory/Network）由调度器更高频调用 UpdateAll。 + /// 快通道硬件（CPU/GPU/Memory/Network）由调度器更高频调用 UpdateFastOnly。 /// public void UpdateSlowOnly() { @@ -123,10 +141,11 @@ internal sealed class HardwareManager : IDisposable Ready = _ready, }; - // 首个快照带上冷启动耗时，后续为 0 - if (_coldStartMs > 0 && snap.Timestamp > 0) + // 首个快照带上冷启动耗时，后续为 0（修复：此前每个快照都携带 ColdStartMs） + if (_coldStartMs > 0 && !_coldStartSent) { snap.ColdStartMs = Math.Round(_coldStartMs, 1); + _coldStartSent = true; } // 重新遍历以读取最新传感器值（visitor 缓存的是 hardware 引用，sensor 值实时） @@ -156,7 +175,7 @@ internal sealed class HardwareManager : IDisposable g.Sensors.Add(new SensorEntry { - Id = $"{groupId}/{hw.Name}/{s.SensorType}/{s.Name}".Replace(' ', '_').ToLowerInvariant(), + Id = GetSensorId(s, groupId, hw.Name), Name = s.Name, Type = sensorType, Value = s.Value, @@ -169,6 +188,21 @@ internal sealed class HardwareManager : IDisposable return snap; } + /// + /// 获取传感器稳定 ID（带缓存）。 + /// ID 格式：{groupId}/{hwName}/{sensorType}/{sensorName}，空格转下划线、小写化。 + /// 缓存命中直接返回，未命中（新传感器）计算后入缓存。 + /// + private string GetSensorId(ISensor s, string groupId, string hwName) + { + if (!_sensorIdCache.TryGetValue(s, out var id)) + { + id = $"{groupId}/{hwName}/{s.SensorType}/{s.Name}".Replace(' ', '_').ToLowerInvariant(); + _sensorIdCache[s] = id; + } + return id; + } + /// /// 为已启用但 LHB 未枚举到的硬件类型预创建空分组。 /// 场景：用户在设置中勾选了主板/电池/电源等，但 LHB 在当前权限或机型下检测不到对应硬件， @@ -290,14 +324,14 @@ internal sealed class SnapshotVisitor : IVisitor } /// -/// 采样调度器：按快/慢通道分频驱动 HardwareManager.UpdateAll。 +/// 采样调度器：按快/慢通道分频驱动 HardwareManager 的分层 Update。 /// 使用 Channel 向 SSE 推送层广播快照（解耦：调度器不关心有几个订阅者）。 /// /// 调度策略： -/// - 快通道 tick：UpdateAll（含慢通道硬件，因 UpdateAll 成本主要在 SMART，已通过慢通道分频减少调用频率） -/// 实际优化：快通道 tick 只 Update 快通道硬件（UpdateFastOnly），慢通道单独按慢节奏 Update +/// - 快通道 tick：UpdateFastOnly（仅 CPU/GPU/Memory/Network 等轻量硬件）， +/// 避免 SMART 等重查询每秒执行拖慢采样节奏 /// - 慢通道 tick：UpdateSlowOnly（仅 Storage/PSU/Motherboard 等） -/// - 每个 tick 结束后构建快照并广播 +/// - 快通道每个 tick 结束后构建快照并广播（慢通道更新后的值随下一帧带出） /// internal sealed class SamplingScheduler : IDisposable { @@ -352,7 +386,7 @@ internal sealed class SamplingScheduler : IDisposable { try { - _hw.UpdateAll(); + _hw.UpdateFastOnly(); var snap = _hw.BuildSnapshot(); _cache.Update(snap); _broadcast.Writer.TryWrite(snap); diff --git a/package.json b/package.json index d5e18a6..9387469 100644 --- a/package.json +++ b/package.json @@ -1,7 +1,7 @@ { "name": "thing", "private": true, - "version": "26.8.1", + "version": "26.8.2", "type": "module", "scripts": { "dev": "vite", diff --git a/src-tauri/Cargo.lock b/src-tauri/Cargo.lock index adbdd83..e139eaf 100644 --- a/src-tauri/Cargo.lock +++ b/src-tauri/Cargo.lock @@ -4743,7 +4743,7 @@ dependencies = [ [[package]] name = "thing" -version = "26.8.1" +version = "26.8.2" dependencies = [ "axum", "base64 0.22.1", diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.toml index d181b0c..5e7a998 100644 --- a/src-tauri/Cargo.toml +++ b/src-tauri/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "thing" -version = "26.8.1" +version = "26.8.2" description = "A Tauri App" authors = ["you"] edition = "2021" @@ -57,6 +57,7 @@ windows-sys = { version = "0.52", features = [ "Win32_System_Ole", "Win32_System_Memory", "Win32_System_DataExchange", + "Win32_System_SystemInformation", "Win32_UI_WindowsAndMessaging", "Win32_UI_Shell", "Win32_UI_HiDpi", @@ -66,7 +67,7 @@ windows-sys = { version = "0.52", features = [ "Win32_Storage_Xps", "Win32_Storage_FileSystem", ] } -# Explorer 前台目录检测（IShellWindows COM）：仅引入用到的 feature，控制编译体积 +# Explorer 蜑榊床逶ｮ蠖墓｣€豬具ｼ・ShellWindows COM・会ｼ壻ｻ・ｼ募・逕ｨ蛻ｰ逧・feature・梧而蛻ｶ郛冶ｯ台ｽ鍋ｧｯ windows = { version = "0.52", features = [ "Win32_Foundation", "Win32_System_Com", diff --git a/src-tauri/binaries/ThingHK.exe b/src-tauri/binaries/ThingHK.exe index 1f39336..91bd0c6 100644 Binary files a/src-tauri/binaries/ThingHK.exe and b/src-tauri/binaries/ThingHK.exe differ diff --git a/src-tauri/capabilities/clipboard-preview.json b/src-tauri/capabilities/clipboard-preview.json new file mode 100644 index 0000000..5bb5616 --- /dev/null +++ b/src-tauri/capabilities/clipboard-preview.json @@ -0,0 +1,19 @@ +{ + "$schema": "../gen/schemas/desktop-schema.json", + "identifier": "clipboard-preview", + "description": "Capability for clipboard independent preview window", + "windows": ["clipboard-preview"], + "permissions": [ + "core:default", + "core:window:allow-hide", + "core:window:allow-show", + "core:window:allow-set-focus", + "core:window:allow-close", + "core:window:allow-set-theme", + "core:window:allow-set-effects", + "core:window:allow-set-background-color", + "core:event:allow-listen", + "core:event:allow-emit", + "snap-layout:default" + ] +} diff --git a/src-tauri/resources/thing-extension/background.js b/src-tauri/resources/thing-extension/background.js index 0ce0917..0f89417 100644 --- a/src-tauri/resources/thing-extension/background.js +++ b/src-tauri/resources/thing-extension/background.js @@ -358,6 +358,11 @@ async function addDownload(url, filename, referer, cookies, headers) { } // ===== 下载拦截 ===== +// 处理中的 URL（防止同一 URL 并发/重入，也避免与引擎去重检查竞态） +const processingUrls = new Set() +// 我们自己用 chrome.downloads.download 回退创建的下载 URL（短时间内跳过，防止再次被拦截形成死循环） +const fallbackUrls = new Map() // url -> 过期时间戳 + async function shouldIntercept(downloadItem) { const config = await getConfig() if (!config.interceptDownload) return false @@ -373,27 +378,94 @@ async function shouldIntercept(downloadItem) { return true } -async function handleDownloadCreated(downloadItem) { - if (!await shouldIntercept(downloadItem)) return - +/** + * 判断是否为"历史下载"（安装插件之前就已存在、随后被浏览器恢复的旧下载） + * 这类下载一律不接管，交给浏览器原生处理，实现"只接管以后的下载，历史都不管" + */ +async function isHistoricalDownload(item) { + // 1) canResume=true 表示已存在有效的部分文件，说明浏览器在恢复旧下载 + if (item.canResume) return true + // 2) 开始时间早于插件首次安装时间（浏览器重启后恢复的旧下载会保留原来的开始时间） try { - await chrome.downloads.cancel(downloadItem.id) - await chrome.downloads.erase({ id: downloadItem.id }) + const start = item.startTime ? new Date(item.startTime).getTime() : 0 + if (start > 0) { + const stored = await chrome.storage.local.get('installTime') + const installTime = stored.installTime || 0 + if (installTime > 0 && start < installTime) return true + } } catch { /* ignore */ } + return false +} - const url = downloadItem.finalUrl || downloadItem.url - const filename = downloadItem.filename || '' - +/** + * 查询引擎是否已有同 URL 的非终态任务（活跃/排队/暂停） + * 用于防止同一下载被重复转发、重复下载 + */ +async function hasExistingTask(url) { try { - await addDownload(url, filename, downloadItem.referrer, '') - } catch (e) { - // 添加失败：回退到浏览器自带下载，不弹通知 - try { await chrome.downloads.download({ url }) } catch { /* ignore */ } + const tasks = await apiRequest('/api/downloads') + return tasks.some(t => { + const s = t.status + if (s === 'complete' || s === 'error') return false + return t.url === url + }) + } catch { + return false } } -// ===== 右键菜单 ===== -chrome.runtime.onInstalled.addListener(() => { +async function handleDownloadCreated(downloadItem) { + const url = downloadItem.finalUrl || downloadItem.url + + // 回退下载：我们自己用 chrome.downloads.download 创建的，直接跳过，避免无限循环 + const fbExp = fallbackUrls.get(url) + if (fbExp && Date.now() < fbExp) { + fallbackUrls.delete(url) + return + } + + // 历史下载（安装前的旧下载被浏览器恢复）一律不接管 + if (await isHistoricalDownload(downloadItem)) return + + if (!await shouldIntercept(downloadItem)) return + + // 同一 URL 已在处理中，跳过（防并发/防重复转发） + if (processingUrls.has(url)) return + + // 引擎不可达时不接管（保留浏览器原生下载），避免取消后下载无处可去 + let connected = false + try { connected = await testConnection() } catch { connected = false } + if (!connected) return + + // 引擎已有同 URL 的非终态任务，不重复转发 + if (await hasExistingTask(url)) return + + processingUrls.add(url) + try { + try { + await chrome.downloads.cancel(downloadItem.id) + await chrome.downloads.erase({ id: downloadItem.id }) + } catch { /* ignore */ } + + const filename = downloadItem.filename || '' + try { + await addDownload(url, filename, downloadItem.referrer, '') + } catch (e) { + // 添加失败：回退为浏览器自带下载，并标记该 URL 短时间内跳过，防止再次被拦截形成死循环 + fallbackUrls.set(url, Date.now() + 3000) + try { await chrome.downloads.download({ url }) } catch { /* ignore */ } + } + } finally { + processingUrls.delete(url) + } +} + +// ===== 右键菜单 & 安装标记 ===== +chrome.runtime.onInstalled.addListener(async (details) => { + // 记录首次安装时间：用于区分"安装前的历史下载"（被浏览器恢复的旧下载）与"安装后的新下载" + if (details.reason === 'install') { + await chrome.storage.local.set({ installTime: Date.now() }) + } chrome.contextMenus.create({ id: 'thing-download-link', title: '使用 Thing 下载此链接', diff --git a/src-tauri/resources/thing-extension/manifest.json b/src-tauri/resources/thing-extension/manifest.json index 39bd603..5c52d51 100644 --- a/src-tauri/resources/thing-extension/manifest.json +++ b/src-tauri/resources/thing-extension/manifest.json @@ -1,7 +1,7 @@ { "manifest_version": 3, "name": "Thing Extension", - "version": "0.2.0", + "version": "0.30", "description": "发送浏览器下载到 Thing 下载引擎，嗅探网页资源。", "icons": { "16": "icons/icon-16.png", diff --git a/src-tauri/resources/thing-extension/thing-extension.zip b/src-tauri/resources/thing-extension/thing-extension.zip index 951b759..ec1f80d 100644 Binary files a/src-tauri/resources/thing-extension/thing-extension.zip and b/src-tauri/resources/thing-extension/thing-extension.zip differ diff --git a/src-tauri/src/clipboard/commands.rs b/src-tauri/src/clipboard/commands.rs index 4acaa03..185f38d 100644 --- a/src-tauri/src/clipboard/commands.rs +++ b/src-tauri/src/clipboard/commands.rs @@ -7,7 +7,7 @@ use specta::Type; use tauri::{AppHandle, State}; use super::manager::{ClipboardManager, ClipboardSettings}; -use super::reader::dib_to_png; +use super::reader::{dib_to_png, dib_to_thumbnail}; use super::storage::{ClipboardItem, ClipboardItemDetail}; #[derive(Serialize, Type)] @@ -95,6 +95,21 @@ pub async fn clipboard_get_item( .map_err(|e| format!("查询任务失败: {}", e)) } +/// 获取图片缩略图 PNG base64（弹窗悬停预览用，避免加载全尺寸图片） +#[tauri::command] +#[specta::specta] +pub async fn clipboard_get_thumb( + id: i64, + manager: State<'_, ClipboardManager>, +) -> Result, String> { + let storage = manager.storage().clone(); + tauri::async_runtime::spawn_blocking(move || { + storage.get_thumb(id, |dib| dib_to_thumbnail(dib, 256)) + }) + .await + .map_err(|e| format!("查询任务失败: {}", e)) +} + #[tauri::command] #[specta::specta] pub async fn clipboard_set_pinned( @@ -162,25 +177,44 @@ pub async fn clipboard_save_settings( app: AppHandle, manager: State<'_, ClipboardManager>, ) -> Result<(), String> { - let prev_enabled = manager.get_settings().enabled; - let prev_shortcut = manager.get_settings().shortcut.clone(); + let prev = manager.get_settings(); + let prev_enabled = prev.enabled; + let prev_shortcut = prev.shortcut.clone(); + + // 快捷键变化且新值非空：先注册（原子化 + 冲突检测），成功后才保存设置。 + // 注册失败时恢复旧快捷键并中止保存，避免设置被写入无法生效的组合键、旧键丢失。 + if settings.shortcut != prev_shortcut && !settings.shortcut.trim().is_empty() { + if let Err(e) = crate::shortcut::register_shortcut(&app, "剪贴板", &settings.shortcut, |a| { + super::popup::show_popup(a) + }) { + // register_shortcut 内部已注销旧快捷键，失败时需重新注册旧键以恢复 + if !prev_shortcut.trim().is_empty() { + let _ = crate::shortcut::register_shortcut(&app, "剪贴板", &prev_shortcut, |a| { + super::popup::show_popup(a) + }); + } + return Err(e); + } + // 新快捷键非空时确保弹窗/预览窗口已预创建 + super::popup::ensure_popup_window(&app); + super::popup::ensure_preview_window(&app); + } + + // 保存设置 manager.save_settings(settings.clone()); + // 监听开关变化时联动启停 if settings.enabled && !prev_enabled { manager.start(&app); } else if !settings.enabled && prev_enabled { manager.stop(); } - // 快捷键变化时重新注册（共享工具模块，原子化 + 冲突检测） - if settings.shortcut != prev_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); - } + + // 快捷键改为空字符串（禁用）：注销旧快捷键 + if settings.shortcut.trim().is_empty() && settings.shortcut != prev_shortcut { + crate::shortcut::unregister_shortcut(&app, "剪贴板"); } + Ok(()) } @@ -262,3 +296,52 @@ pub async fn clipboard_paste_to_target(app: AppHandle) -> Result<(), String> { super::popup::paste_to_target(&app); Ok(()) } + +/// 在弹窗旁显示独立预览窗口（悬停/键盘选中时调用） +#[tauri::command] +#[specta::specta] +pub async fn clipboard_show_preview(app: AppHandle, id: i64) -> Result<(), String> { + super::popup::show_preview(&app, id); + Ok(()) +} + +/// 隐藏独立预览窗口 +#[tauri::command] +#[specta::specta] +pub async fn clipboard_hide_preview(app: AppHandle) -> Result<(), String> { + super::popup::hide_preview(&app); + Ok(()) +} + +/// 按内容自适应调整预览窗大小（逻辑像素）。前端加载内容（文本测高、图片按宽高比）后调用， +/// 窗口贴合内容消除留白；后端按弹窗所在屏工作区钳制并重新对齐弹窗。 +/// allow_flip：初始落位为 true（优先侧放不下可换侧）；放大/还原为 false（保持原侧）。 +#[tauri::command] +#[specta::specta] +pub async fn clipboard_resize_preview( + app: AppHandle, + width: f64, + height: f64, + allow_flip: bool, +) -> Result<(), String> { + super::popup::resize_preview(&app, width, height, allow_flip); + Ok(()) +} + +/// 显示已就绪的预览窗口。前端完成内容加载与 resize 后调用，窗口以最终尺寸出现， +/// 消除"先以上次尺寸（可能是放大态大窗）显示再缩回"的闪烁。 +#[tauri::command] +#[specta::specta] +pub async fn clipboard_reveal_preview(app: AppHandle) -> Result<(), String> { + super::popup::reveal_preview(&app); + Ok(()) +} + +/// 预览窗交互锁定：前端预览窗收到 mousedown（放大/缩小、复制、选择文本）时调用。 +/// 此后弹窗+预览不因失焦/鼠标离开而关闭，仅当点击外部或弹窗重新聚焦时退出锁定。 +#[tauri::command] +#[specta::specta] +pub async fn clipboard_preview_interacted(app: AppHandle) -> Result<(), String> { + super::popup::preview_interacted(&app); + Ok(()) +} diff --git a/src-tauri/src/clipboard/manager.rs b/src-tauri/src/clipboard/manager.rs index 5b808ce..b208728 100644 --- a/src-tauri/src/clipboard/manager.rs +++ b/src-tauri/src/clipboard/manager.rs @@ -12,6 +12,7 @@ use specta::Type; use super::monitor::start_monitor; use super::reader::{write_dib, write_files, write_text}; use super::storage::Storage; +use windows_sys::Win32::System::DataExchange::GetClipboardSequenceNumber; /// 剪贴板设置（持久化到 clipboard/settings.json） #[derive(Clone, Serialize, Deserialize, Type)] @@ -55,7 +56,8 @@ impl Default for ClipboardSettings { pub struct ClipboardManager { storage: Arc, settings: Arc>, - suppress: Arc, + /// 本应用 copy_back 写入后的剪贴板序列号，用于跳过自身写入产生的记录 + suppress: Arc>>, monitor_stop: Arc, monitor_handle: Mutex>>, settings_path: PathBuf, @@ -73,7 +75,7 @@ impl ClipboardManager { }; let settings_path = clip_dir.join("settings.json"); let settings = Arc::new(Mutex::new(load_settings(&settings_path))); - let suppress = Arc::new(AtomicBool::new(false)); + let suppress = Arc::new(Mutex::new(None)); let monitor_stop = Arc::new(AtomicBool::new(true)); Self { storage, @@ -139,13 +141,12 @@ impl ClipboardManager { save_settings(&self.settings_path, &s); } - /// 将某条历史写回剪贴板。写回前置 suppress 标志以避免再次记录。 + /// 将某条历史写回剪贴板。写回成功后记录剪贴板序列号，供监听跳过自身写入。 pub fn copy_back(&self, id: i64) -> Result<(), String> { let (kind, content, blob) = self .storage .get_raw_for_copy(id) .ok_or_else(|| "条目不存在".to_string())?; - self.suppress.store(true, Ordering::SeqCst); let ok = match kind.as_str() { "text" => content.as_deref().map(write_text).unwrap_or(false), "image" => blob.as_deref().map(write_dib).unwrap_or(false), @@ -163,10 +164,12 @@ impl ClipboardManager { _ => false, }; if ok { + // 绑定到写入完成后的剪贴板序列号：仅跳过本次写入产生的记录， + // 用户后续复制（序列号不同）不会被误吞。 + let seq = unsafe { GetClipboardSequenceNumber() }; + *self.suppress.lock().unwrap_or_else(|e| e.into_inner()) = Some(seq); Ok(()) } else { - // 写入失败也清除 suppress，避免误吞下次复制 - self.suppress.store(false, Ordering::SeqCst); Err("写回剪贴板失败".into()) } } diff --git a/src-tauri/src/clipboard/mod.rs b/src-tauri/src/clipboard/mod.rs index c362dea..2c09589 100644 --- a/src-tauri/src/clipboard/mod.rs +++ b/src-tauri/src/clipboard/mod.rs @@ -9,9 +9,12 @@ pub mod storage; pub use commands::{ clipboard_clear, clipboard_copy_back, clipboard_count, clipboard_delete, clipboard_get_history, - clipboard_get_item, clipboard_get_pinned, clipboard_get_settings, clipboard_hide_popup, - clipboard_paste_to_target, clipboard_register_shortcut, clipboard_save_settings, clipboard_search, - clipboard_set_pinned, clipboard_show_popup, clipboard_show_window, clipboard_start, + clipboard_get_item, clipboard_get_pinned, clipboard_get_settings, clipboard_get_thumb, + clipboard_hide_popup, clipboard_hide_preview, clipboard_paste_to_target, + clipboard_preview_interacted, clipboard_register_shortcut, + clipboard_reveal_preview, + clipboard_save_settings, clipboard_search, clipboard_set_pinned, clipboard_resize_preview, + clipboard_show_popup, clipboard_show_preview, clipboard_show_window, clipboard_start, clipboard_status, clipboard_stop, clipboard_unregister_shortcut, }; pub use manager::ClipboardManager; diff --git a/src-tauri/src/clipboard/monitor.rs b/src-tauri/src/clipboard/monitor.rs index b83b337..948b855 100644 --- a/src-tauri/src/clipboard/monitor.rs +++ b/src-tauri/src/clipboard/monitor.rs @@ -1,7 +1,7 @@ //! 剪贴板监听线程：基于 GetClipboardSequenceNumber 轮询 //! //! 选用轮询而非 AddClipboardFormatListener 消息窗口：实现更简单、无需消息循环， -//! 800ms 间隔对剪贴板场景延迟可接受，且 GetClipboardSequenceNumber 不需要 OpenClipboard，开销极小。 +//! 250ms 间隔兼顾响应速度与开销，且 GetClipboardSequenceNumber 不需要 OpenClipboard，开销极小。 use std::sync::atomic::{AtomicBool, Ordering}; use std::sync::{Arc, Mutex}; @@ -15,18 +15,19 @@ use super::storage::{NewItem, Storage}; use windows_sys::Win32::System::DataExchange::GetClipboardSequenceNumber; /// 启动监听线程，返回 JoinHandle。 +/// `suppress` 记录本应用 copy_back 写入后的剪贴板序列号，用于跳过自身写入产生的记录。 pub fn start_monitor( storage: Arc, app: AppHandle, settings: Arc>, - suppress: Arc, + suppress: Arc>>, stop: Arc, ) -> thread::JoinHandle<()> { thread::spawn(move || loop { if stop.load(Ordering::SeqCst) { break; } - thread::sleep(Duration::from_millis(800)); + thread::sleep(Duration::from_millis(250)); if stop.load(Ordering::SeqCst) { break; } @@ -40,10 +41,13 @@ pub fn start_monitor( if seq == last { continue; } - // 序列号变化，处理一次 - if suppress.swap(false, Ordering::SeqCst) { - // 由本应用 copy_back 触发，跳过记录 - continue; + // 序列号变化：仅当变化来自本应用 copy_back（序列号精确匹配）时跳过， + // 避免旧布尔标志在用户后续复制时被误吞。 + if let Ok(mut s) = suppress.lock() { + if *s == Some(seq) { + *s = None; + continue; + } } let (rec_text, rec_image, rec_files, max_items, max_image_kb, dedup) = { let s = settings.lock().unwrap_or_else(|e| e.into_inner()); @@ -99,6 +103,7 @@ fn build_text_item(t: &str) -> NewItem { kind: "text".into(), content: Some(t.to_string()), blob: None, + thumb: None, preview: make_preview(t, 200), size: t.len() as i64, hash: hash_str(t), @@ -110,6 +115,7 @@ fn build_image_item(dib: &[u8], w: u32, h: u32) -> NewItem { kind: "image".into(), content: None, blob: Some(dib.to_vec()), + thumb: super::reader::dib_to_thumbnail(dib, 256), preview: format!("图片 {}×{}", w, h), size: dib.len() as i64, hash: hash_bytes(dib), @@ -132,6 +138,7 @@ fn build_files_item(files: &[String]) -> NewItem { kind: "files".into(), content: Some(content), blob: None, + thumb: None, preview, size: files.iter().map(|f| f.len()).sum::() as i64, hash, diff --git a/src-tauri/src/clipboard/popup.rs b/src-tauri/src/clipboard/popup.rs index 1c0b571..2f27ead 100644 --- a/src-tauri/src/clipboard/popup.rs +++ b/src-tauri/src/clipboard/popup.rs @@ -10,12 +10,27 @@ use std::sync::Mutex; use std::sync::atomic::{AtomicBool, Ordering}; +use std::time::{Duration, Instant}; use tauri::{AppHandle, Manager, WebviewUrl, WebviewWindowBuilder, Emitter}; use tauri::window::{Effect, EffectsBuilder}; /// 弹窗窗口标签 pub const POPUP_LABEL: &str = "clipboard-popup"; +/// 预览窗口标签（悬停/键盘选中条目时在弹窗旁显示内容） +pub const PREVIEW_LABEL: &str = "clipboard-preview"; + +/// 预览窗口初始逻辑尺寸（后续由前端按内容自适应调整，见 resize_preview） +const PREVIEW_W: f64 = 340.0; +const PREVIEW_H: f64 = 300.0; + +/// 预览窗口最小逻辑尺寸（防止内容过小时窗口退化） +const PREVIEW_MIN_W: f64 = 240.0; +const PREVIEW_MIN_H: f64 = 160.0; + +/// 弹窗与预览窗之间的可视间距（逻辑像素，左右对称） +const PREVIEW_GAP: f64 = 12.0; + /// 标志：show_popup 兜底创建路径设为 true，前端 onMounted 回调 show_window 时据此判断是否显示。 /// 预创建路径不设置，避免应用启动时弹窗自动弹出。 static POPUP_PENDING_SHOW: AtomicBool = AtomicBool::new(false); @@ -24,6 +39,50 @@ static POPUP_PENDING_SHOW: AtomicBool = AtomicBool::new(false); /// 避免窗口重建后仍停留在屏幕外 (-10000, -10000)。 static PENDING_POS: Mutex> = Mutex::new(None); +/// 弹窗当前是否可见（同步单一事实来源）。 +/// show_preview 用它代替 popup.is_visible()：后者在 hide 异步在途时可能返回过期 true， +/// 导致"弹窗已隐藏但残留的悬停/键盘请求重新弹出孤立预览窗"。该标志在隐藏路径 +/// 同步置 false，任何在途请求都会直接拒绝。 +static POPUP_VISIBLE: AtomicBool = AtomicBool::new(false); + +/// 预览窗当前是否可见（同步标志，与 POPUP_VISIBLE 同理：预览窗以原生 +/// SW_SHOWNOACTIVATE 显示，Tauri 的 is_visible() 可能与其真实状态不同步， +/// 故用该标志代替 is_visible 判断预览交互状态）。 +static PREVIEW_VISIBLE: AtomicBool = AtomicBool::new(false); + +/// 弹窗因预览交互（光标位于预览窗内）而推迟隐藏的标记： +/// 点击预览窗（选择/复制文本、放大图片）时，弹窗会收到 Focused(false)，但用户正在 +/// 预览窗内交互，此时不应隐藏弹窗。置该标记后保持弹窗显示，待用户离开预览窗 +/// （hide_preview）时再连同弹窗一起隐藏，避免"点击预览即关闭弹窗"导致无法交互。 +static POPUP_DEFER_HIDE: AtomicBool = AtomicBool::new(false); + +/// 失焦隐藏的宽限期：WebView2 透明窗口在 show 后激活期间焦点可能短暂弹跳 +/// （与快速面板同因），导致 Focused(false) 紧跟在 show 之后触发并立即隐藏刚显示的弹窗。 +const SHOW_GRACE: Duration = Duration::from_millis(500); + +/// 最近一次 show 的时间，用于失焦宽限期判断。 +static LAST_SHOWN: Mutex> = Mutex::new(None); + +/// 标记"已发起显示"，并记录时间供失焦宽限期使用。 +fn mark_shown() { + if let Ok(mut t) = LAST_SHOWN.lock() { + *t = Some(Instant::now()); + } + POPUP_VISIBLE.store(true, Ordering::SeqCst); + // 重新显示弹窗时复位推迟隐藏标记（上一轮预览交互的遗留状态不应影响本轮） + POPUP_DEFER_HIDE.store(false, Ordering::SeqCst); +} + +/// 判断距上次 show 是否仍在宽限期内（是则忽略失焦自动隐藏）。 +fn within_show_grace() -> bool { + LAST_SHOWN + .lock() + .ok() + .and_then(|t| *t) + .map(|t| t.elapsed() < SHOW_GRACE) + .unwrap_or(false) +} + /// 创建弹窗窗口（隐藏状态）并注册失焦监听。 /// 位置默认在屏幕外，show_popup 时会重新定位。 /// 预创建后首次按快捷键走"窗口已存在"分支直接 show，避免首次创建的时序问题。 @@ -54,13 +113,41 @@ fn create_popup_window(app: &AppHandle) { } }; - // 监听窗口失焦：自动隐藏 + // 监听窗口失焦：自动隐藏（同时隐藏预览窗） let app_handle = app.clone(); let win_handle = win.clone(); win.on_window_event(move |event| { - if let tauri::WindowEvent::Focused(false) = event { - let _ = win_handle.hide(); - let _ = app_handle.emit(crate::constants::events::CLIPBOARD_POPUP_HIDE, ()); + match event { + tauri::WindowEvent::Focused(false) => { + // 失焦宽限期：show 后激活期间的焦点弹跳不隐藏弹窗，避免弹窗刚显示就被隐藏 + if within_show_grace() { + return; + } + // 交互锁定模式（点击过预览窗）：弹窗与预览保持显示，仅由看护线程在 + // "点击外部"时关闭；此处的失焦是点击预览窗（NoActivate）所致，不隐藏。 + if POPUP_INTERACTED.load(Ordering::SeqCst) { + return; + } + // 鼠标当前位于预览窗或弹窗内（用户正在交互：选择/复制文本、放大图片、或 + // 已移回弹窗准备继续浏览）：弹窗失焦是点击预览窗或焦点反弹所致，不应隐藏弹窗。 + // 置推迟标记保持弹窗显示，待用户离开整个区域（hide_preview / 再次失焦）再隐藏。 + if is_cursor_in_preview(&app_handle) || is_cursor_in_popup(&app_handle) { + POPUP_DEFER_HIDE.store(true, Ordering::SeqCst); + return; + } + // 先同步标记弹窗不可见，再隐藏窗口/预览：异步 hide 在途时，残留的 + // show_preview 请求会因该标志为 false 而拒绝，预览窗不会孤立残留。 + POPUP_VISIBLE.store(false, Ordering::SeqCst); + POPUP_DEFER_HIDE.store(false, Ordering::SeqCst); + let _ = win_handle.hide(); + hide_preview(&app_handle); + let _ = app_handle.emit(crate::constants::events::CLIPBOARD_POPUP_HIDE, ()); + } + tauri::WindowEvent::Focused(true) => { + // 弹窗重新获得焦点（用户点击/移回弹窗）：取消推迟隐藏状态 + POPUP_DEFER_HIDE.store(false, Ordering::SeqCst); + } + _ => {} } }); @@ -112,6 +199,7 @@ pub fn show_popup(app: &AppHandle) { y: y as i32, })); let _ = win.show(); + mark_shown(); let _ = win.set_focus(); // 通知前端刷新数据 let _ = app.emit(crate::constants::events::CLIPBOARD_POPUP_SHOW, ()); @@ -143,17 +231,27 @@ pub fn show_window(app: &AppHandle) { })); } let _ = win.show(); + mark_shown(); let _ = win.set_focus(); // 通知前端刷新数据 let _ = app.emit(crate::constants::events::CLIPBOARD_POPUP_SHOW, ()); } } -/// 隐藏弹窗（不销毁，保留复用） +/// 隐藏弹窗（不销毁，保留复用），并通知前端清理悬停定时器/预览。 pub fn hide_popup(app: &AppHandle) { + // 复位推迟隐藏标记（先于 hide_preview，避免 hide_preview 重入 hide_popup 形成递归） + POPUP_DEFER_HIDE.store(false, Ordering::SeqCst); + // 复位交互锁定：弹窗关闭后下次呼出恢复"失焦即隐藏"的常规模式 + POPUP_INTERACTED.store(false, Ordering::SeqCst); + // 同步标记弹窗不可见，拒绝此后在途的 show_preview 请求 + POPUP_VISIBLE.store(false, Ordering::SeqCst); + hide_preview(app); if let Some(win) = app.get_webview_window(POPUP_LABEL) { let _ = win.hide(); } + // 通知前端：取消悬停定时器并隐藏预览，避免弹窗隐藏后残留定时器重新弹出预览窗 + let _ = app.emit(crate::constants::events::CLIPBOARD_POPUP_HIDE, ()); } /// 隐藏弹窗后延迟模拟 Ctrl+V 粘贴到之前聚焦的窗口。 @@ -207,6 +305,434 @@ fn simulate_paste() { // 非 Windows 平台暂不支持自动粘贴 } +// ===== 独立预览窗口 ===== + +/// 创建预览窗口（隐藏状态），应用 NoActivate 样式避免抢焦点。 +fn create_preview_window(app: &AppHandle) { + let win = match WebviewWindowBuilder::new( + app, + PREVIEW_LABEL, + WebviewUrl::App("index.html#clipboard-preview".into()), + ) + .title("预览") + .inner_size(PREVIEW_W, PREVIEW_H) + .position(-10000.0, -10000.0) // 屏幕外，避免隐藏时一闪 + .decorations(false) + .transparent(true) + .shadow(true) + .always_on_top(true) + .skip_taskbar(true) + .resizable(false) + .visible(false) + .focused(false) // 不抢占焦点 + .effects(EffectsBuilder::new().effects(vec![Effect::Mica]).build()) + .build() + { + Ok(w) => w, + Err(e) => { + crate::logger::log_error("clipboard", &format!("创建预览窗失败: {}", e)); + return; + } + }; + + // NoActivate：预览窗可交互但不激活，弹窗保持前台（键盘导航/粘贴不受影响） + // 圆角：NoActivate 悬浮窗系统不自动圆角，显式指定 DWMWCP_ROUND 与弹窗外观统一 + #[cfg(windows)] + if let Ok(hwnd) = win.hwnd() { + crate::win32_util::apply_no_activate(hwnd.0 as isize); + crate::win32_util::apply_rounded_corners(hwnd.0 as isize); + } + + crate::logger::log_info("clipboard", "预览窗口已预创建（隐藏状态）"); +} + +/// 应用启动时预创建预览窗口（隐藏），随弹窗一起就绪。 +pub fn ensure_preview_window(app: &AppHandle) { + if app.get_webview_window(PREVIEW_LABEL).is_some() { + return; + } + create_preview_window(app); +} + +/// 预览当前所在侧（default=右，left=左），供放大/还原重定位沿用同侧。 +#[derive(Clone, Copy, PartialEq)] +enum PreviewSide { + Right, + Left, +} + +static PREVIEW_SIDE: Mutex> = Mutex::new(None); + +/// 最近一次显示预览时的鼠标 Y 锚点（物理像素）。预览窗垂直中线对齐该位置 +/// （贴近鼠标所悬停的条目），resize（切换条目/放大还原）时沿用，保持中线稳定不跳变。 +static PREVIEW_ANCHOR_Y: Mutex> = Mutex::new(None); + +/// 弹窗离开看护线程是否已在运行（防重入，见 spawn_popup_leave_watch）。 +static POPUP_LEAVE_WATCH: AtomicBool = AtomicBool::new(false); + +/// 交互锁定模式：用户点击过预览窗（放大/缩小、复制文本等）后置位。 +/// 该模式下弹窗与预览不因失焦/鼠标离开而关闭，仅当点击弹窗+预览之外的 +/// 区域（看护线程检测鼠标按下沿）或弹窗重新聚焦（恢复正常模式）时才复位。 +static POPUP_INTERACTED: AtomicBool = AtomicBool::new(false); + +/// 重新定位预览窗口（物理像素）。preferred 指定优先放置侧，返回实际落位侧。 +/// anchor_y 为鼠标 Y 锚点：预览窗垂直中线对齐该位置（贴近悬停条目）， +/// 上下 clamp 到工作区；None 时退回弹窗顶部对齐。 +/// +/// 无边框+阴影窗口（tao 实现）的外框矩形在客户区四周各留一条不可见边框 +/// （SM_CXSIZEFRAME+SM_CXPADDEDBORDER，典型 8px）：outer_position/outer_size 均含该边框， +/// 而可视内容仅占客户区。若直接用外框尺寸计算右侧落位，右侧可视间距会比左侧多出 +/// 两侧边框之和（约 16px）。这里以"可视边缘"对齐：frame = (外框宽 - 客户区宽) / 2， +/// 左右两侧使用同一 GAP，保证两侧可视间距一致。 +fn reposition_preview( + popup: &tauri::WebviewWindow, + win: &tauri::WebviewWindow, + vw: i32, + vh: i32, + preferred: PreviewSide, + anchor_y: Option, + allow_flip: bool, +) -> PreviewSide { + // 弹窗当前物理位置与尺寸（外框，含不可见边框） + let Ok(pos) = popup.outer_position() else { return preferred }; + let Ok(osz) = popup.outer_size() else { return preferred }; + let Ok(isz) = popup.inner_size() else { return preferred }; + let (px, py) = (pos.x, pos.y); + let pw = osz.width as i32; + // 不可见边框宽度（外框与客户区之差的一半；无阴影窗口为 0） + let frame = ((osz.width.saturating_sub(isz.width)) / 2) as i32; + + // 弹窗所在显示器工作区 + let (wa_left, wa_top, wa_right, wa_bottom) = get_work_area_at_point(px, py) + .unwrap_or((0, 0, 1920, 1040)); + + let gap = (PREVIEW_GAP * popup.scale_factor().unwrap_or(1.0)).round() as i32; + + // 可视边缘对齐： + // 右侧落位 = 弹窗可视右缘(px+pw-frame) + GAP - 预览窗自身左边框(frame) + // 左侧落位 = 弹窗可视左缘(px+frame) - GAP - 预览可视宽(vw) - 预览窗左边框(frame) + // （frame 两两抵消，与旧公式一致） + let right_x = px + pw - 2 * frame + gap; + let left_x = px - gap - vw; + // 可视区域（含预览窗自身边框偏移）不越工作区 + let fits_right = right_x + frame + vw <= wa_right; + let fits_left = left_x + frame >= wa_left; + let mut x = match preferred { + PreviewSide::Right => right_x, + PreviewSide::Left => left_x, + }; + // 仅初始落位（allow_flip=true）允许换侧：优先侧放不下时切到另一侧。 + // 内容尺寸变化（放大/还原，allow_flip=false）不允许换侧：窗口跳到另一侧会使 + // 鼠标瞬间落在窗外，误触发 mouseleave 而关闭预览/弹窗；此时保持原侧并靠 + // 工作区 clamp（大图可能覆盖弹窗边缘，属合理取舍，鼠标仍在预览窗内可交互）。 + if allow_flip { + match preferred { + PreviewSide::Right => { + if !fits_right { + x = left_x; + } + } + PreviewSide::Left => { + if !fits_left { + x = right_x; + } + } + } + } + x = (x + frame).max(wa_left).min(wa_right - vw) - frame; + // 仅初始落位（allow_flip）按最终位置更新所在侧（换侧时位置在弹窗另一侧，判定正确）； + // 放大/还原（不允许换侧）时即使被工作区 clamp 覆盖到弹窗上方，语义上仍属原侧， + // 必须沿用 preferred——否则 clamp 后按位置误判为另一侧并存档，缩小后会跳侧。 + let side = if allow_flip { + if x + vw <= px { PreviewSide::Left } else { PreviewSide::Right } + } else { + preferred + }; + // 垂直定位：预览窗中线对齐鼠标 Y 锚点（贴近悬停条目），上下 clamp 到工作区； + // 无锚点时退回弹窗顶部对齐 + let y = match anchor_y { + Some(ay) => (ay - vh / 2).max(wa_top).min(wa_bottom - vh), + None => py.max(wa_top).min(wa_bottom - vh), + }; + + let _ = win.set_position(tauri::Position::Physical(tauri::PhysicalPosition { x, y })); + if let Ok(mut s) = PREVIEW_SIDE.lock() { + *s = Some(side); + } + side +} + +/// 通知预览前端加载指定条目。窗口此时保持隐藏：前端测得内容尺寸后先调用 +/// resize_preview（隐藏状态下完成尺寸/位置调整）再 reveal_preview 显示， +/// 避免"先以上次尺寸（可能是放大态大窗）显示再缩回"的闪烁。 +pub fn show_preview(app: &AppHandle, id: i64) { + // 弹窗已隐藏（或隐藏中）时拒绝显示预览：同步标志消除 is_visible() 的异步时序竞态， + // 保证"弹窗失焦消失后预览窗不会孤立残留"。 + if !POPUP_VISIBLE.load(Ordering::SeqCst) { + return; + } + if app.get_webview_window(PREVIEW_LABEL).is_none() { + return; + } + let Some(popup) = app.get_webview_window(POPUP_LABEL) else { + return; + }; + // 弹窗不可见时不显示预览：避免弹窗隐藏后仍在途的悬停请求重新弹出孤立的预览窗 + if !popup.is_visible().unwrap_or(false) { + return; + } + + // 记录鼠标 Y 锚点：预览窗中线对齐鼠标所悬停的条目位置；resize 时沿用 + if let Some((_, y)) = get_cursor_pos() { + if let Ok(mut a) = PREVIEW_ANCHOR_Y.lock() { + *a = Some(y); + } + } + + // 通知前端加载条目内容（前端完成后自行 resize + reveal） + let _ = app.emit(crate::constants::events::CLIPBOARD_PREVIEW_SHOW, id); +} + +/// 显示已就绪的预览窗口（前端完成内容加载与 resize 后调用）。 +/// 显示前重查弹窗可见性，消除内容加载期间弹窗已隐藏的竞态。 +pub fn reveal_preview(app: &AppHandle) { + // 弹窗已隐藏：在途请求作废 + if !POPUP_VISIBLE.load(Ordering::SeqCst) { + return; + } + // 已可见则跳过（放大/还原触发的重复 reveal） + if PREVIEW_VISIBLE.load(Ordering::SeqCst) { + return; + } + let Some(win) = app.get_webview_window(PREVIEW_LABEL) else { + return; + }; + + // 同步标记预览窗可见（以原生方式显示，Tauri 的 is_visible 可能不同步） + PREVIEW_VISIBLE.store(true, Ordering::SeqCst); + // 不激活显示（SW_SHOWNOACTIVATE），弹窗保持前台 + #[cfg(windows)] + if let Ok(hwnd) = win.hwnd() { + crate::win32_util::show_no_activate(hwnd.0 as isize); + } + #[cfg(not(windows))] + let _ = win.show(); + + // 显示期间弹窗可能已被隐藏（失焦/关闭）：立即收回预览。 + // 关闭初次检查与真正 show 之间的竞态——失焦处理器先置 POPUP_VISIBLE=false + // 再隐藏，这里 show 之后重查一次，若已被隐藏则收回预览，避免孤立残留。 + if !POPUP_VISIBLE.load(Ordering::SeqCst) { + PREVIEW_VISIBLE.store(false, Ordering::SeqCst); + let _ = win.hide(); + } +} + +/// 按内容自适应调整预览窗大小（逻辑像素），位置沿用当前所在侧并重新对齐弹窗。 +/// 前端加载/切换内容（文本测高、图片按宽高比）后调用，窗口贴合内容消除留白。 +/// allow_flip：初始落位为 true（优先侧放不下可换侧）；放大/还原为 false +/// （保持原侧靠工作区 clamp，避免窗口跳侧使鼠标落在窗外误触发隐藏）。 +pub fn resize_preview(app: &AppHandle, width: f64, height: f64, allow_flip: bool) { + // 弹窗不可见时忽略（无对齐基准） + if !POPUP_VISIBLE.load(Ordering::SeqCst) { + return; + } + let Some(win) = app.get_webview_window(PREVIEW_LABEL) else { + return; + }; + let Some(popup) = app.get_webview_window(POPUP_LABEL) else { + return; + }; + + let scale = popup.scale_factor().unwrap_or(1.0); + // 以弹窗所在屏工作区为上限钳制（逻辑像素），并保证不小于最小可视尺寸 + let (wa_left, wa_top, wa_right, wa_bottom) = popup + .outer_position() + .ok() + .and_then(|p| get_work_area_at_point(p.x, p.y)) + .unwrap_or((0, 0, 1920, 1040)); + let max_w = ((wa_right - wa_left).max(0) as f64 / scale).floor().max(PREVIEW_MIN_W); + let max_h = ((wa_bottom - wa_top).max(0) as f64 / scale).floor().max(PREVIEW_MIN_H); + let w = width.clamp(PREVIEW_MIN_W, max_w); + let h = height.clamp(PREVIEW_MIN_H, max_h); + let vw = (w * scale).round() as i32; + let vh = (h * scale).round() as i32; + + let side = PREVIEW_SIDE.lock().ok().and_then(|s| *s).unwrap_or(PreviewSide::Right); + // 沿用最近一次的鼠标 Y 锚点：高度变化时中线保持对齐悬停条目，不产生跳变 + let anchor_y = PREVIEW_ANCHOR_Y.lock().ok().and_then(|a| *a); + reposition_preview(&popup, &win, vw, vh, side, anchor_y, allow_flip); + let _ = win.set_size(tauri::Size::Physical(tauri::PhysicalSize { width: vw as u32, height: vh as u32 })); +} + +/// 交互锁定模式入口：前端预览窗收到 mousedown（放大/缩小、复制、选择文本）时调用。 +/// 置位锁定标志并启动看护线程：此后弹窗+预览不因失焦/鼠标离开而关闭， +/// 仅当点击弹窗+预览之外的区域或弹窗重新聚焦时退出锁定。 +pub fn preview_interacted(app: &AppHandle) { + POPUP_INTERACTED.store(true, Ordering::SeqCst); + // 交互锁定取代推迟隐藏模式：清除可能残留的 DEFER 标记， + // 避免后续取消钉住时 hide_preview 走 DEFER 分支误关弹窗 + POPUP_DEFER_HIDE.store(false, Ordering::SeqCst); + spawn_popup_leave_watch(app.clone()); +} + +/// 隐藏预览窗口（保留复用），并通知前端清空内容。 +pub fn hide_preview(app: &AppHandle) { + // 交互锁定模式：弹窗仍显示时预览保持（生命周期由看护线程管理，点击外部才 + // 随弹窗一起关闭），忽略常规隐藏请求（条目离开、键盘切换等）。 + if POPUP_INTERACTED.load(Ordering::SeqCst) && POPUP_VISIBLE.load(Ordering::SeqCst) { + return; + } + POPUP_INTERACTED.store(false, Ordering::SeqCst); + // 若此前因预览交互推迟了弹窗隐藏（弹窗已失焦但保持显示），现在用户离开预览窗， + // 需判断去向：光标已回到弹窗内（继续浏览弹窗）→ 仅隐藏预览、保持弹窗显示； + // 光标在弹窗之外（离开整个区域）→ 连同弹窗一起隐藏。 + // （hide_popup 会先复位该标记，故此处 swap(false) 后调用不会递归重入） + if POPUP_DEFER_HIDE.swap(false, Ordering::SeqCst) { + if !is_cursor_in_popup(app) { + hide_popup(app); + return; + } + // 光标已回到弹窗内。若弹窗仍持有焦点（曾点击弹窗重新激活），仅隐藏预览即可， + // 后续失焦仍走 Focused(false) 正常关闭；若弹窗已失焦（点击预览窗所致）， + // 它不会再收到 Focused(false) 事件——光标一旦离开弹窗区域，弹窗将永远 + // 无法关闭（无焦点残留窗口）。启动看护线程兜底关闭。 + let focused = app + .get_webview_window(POPUP_LABEL) + .map(|w| w.is_focused().unwrap_or(false)) + .unwrap_or(false); + if !focused { + spawn_popup_leave_watch(app.clone()); + } + } + PREVIEW_VISIBLE.store(false, Ordering::SeqCst); + if let Some(win) = app.get_webview_window(PREVIEW_LABEL) { + let _ = win.hide(); + // 预览窗以原生 SW_SHOWNOACTIVATE 方式显示，Tauri 内部可见性状态可能与其 + // 不同步；补一次原生 SW_HIDE，确保任何路径下都被可靠隐藏。 + #[cfg(windows)] + if let Ok(hwnd) = win.hwnd() { + crate::win32_util::hide_window(hwnd.0 as isize); + } + } + let _ = app.emit(crate::constants::events::CLIPBOARD_PREVIEW_HIDE, ()); +} + +/// 弹窗失焦但保持显示时的看护线程（防重入单例）。 +/// +/// 两种工作模式（每轮动态读取 POPUP_INTERACTED，可中途切换）： +/// - 常规模式（未点击过预览窗）：光标连续 ~300ms 既不在弹窗也不在预览窗内 +/// （连续计数防"穿越弹窗-预览间隙"时的瞬时离开误判）→ 关闭弹窗； +/// - 交互锁定模式（点击过预览窗的放大/缩小/复制等）：弹窗已失焦不会再收到 +/// Focused(false)，检测"鼠标按下沿且按下位置在弹窗+预览之外"→ 点击外部，关闭弹窗。 +/// +/// 公共退出条件：弹窗已隐藏/销毁（其他路径关闭）；弹窗重新获得焦点（用户点击 +/// 弹窗，恢复正常失焦关闭路径，并复位交互锁定）；超时兜底防线程泄漏 +/// （常规 30s；交互锁定为事件驱动，放宽至 10min）。 +fn spawn_popup_leave_watch(app: AppHandle) { + // 防重入：已有看护在运行则跳过 + if POPUP_LEAVE_WATCH.swap(true, Ordering::SeqCst) { + return; + } + std::thread::spawn(move || { + let start = Instant::now(); + let mut outside = 0u32; + let mut was_down = false; + loop { + std::thread::sleep(Duration::from_millis(30)); + // 弹窗已隐藏或被销毁：看护结束 + if !POPUP_VISIBLE.load(Ordering::SeqCst) + || app.get_webview_window(POPUP_LABEL).is_none() + { + break; + } + // 弹窗重新获得焦点（用户点击弹窗）：恢复正常失焦关闭路径，复位交互锁定 + if app + .get_webview_window(POPUP_LABEL) + .map(|w| w.is_focused().unwrap_or(false)) + .unwrap_or(false) + { + POPUP_INTERACTED.store(false, Ordering::SeqCst); + break; + } + let interacted = POPUP_INTERACTED.load(Ordering::SeqCst); + // 超长兜底：避免异常路径下看护线程无限轮询 + let timeout = if interacted { + Duration::from_secs(600) + } else { + Duration::from_secs(30) + }; + if start.elapsed() > timeout { + hide_popup(&app); + break; + } + let cursor_in = is_cursor_in_popup(&app) || is_cursor_in_preview(&app); + if interacted { + // 交互锁定：左键按下沿发生在弹窗+预览之外 → 点击外部，关闭弹窗+预览。 + // 按下沿判定（上一轮未按下、本轮按下）配合 30ms 轮询，可捕获常规点击； + // 在弹窗/预览内按下后拖出再松开不算外部点击（以按下位置为准）。 + let down = crate::win32_util::is_left_button_down(); + if down && !was_down && !cursor_in { + hide_popup(&app); + break; + } + was_down = down; + } else if cursor_in { + outside = 0; + } else { + outside += 1; + // 连续 ~300ms 不在弹窗/预览区域（排除穿越间隙的瞬时状态）才关闭 + if outside >= 10 { + hide_popup(&app); + break; + } + } + } + POPUP_LEAVE_WATCH.store(false, Ordering::SeqCst); + }); +} + +/// 鼠标当前是否位于弹窗矩形内（弹窗可见且光标在其窗口范围内）。 +/// 用于 hide_preview 判断"用户是回到弹窗继续浏览，还是离开整个区域"。 +fn is_cursor_in_popup(app: &AppHandle) -> bool { + if !POPUP_VISIBLE.load(Ordering::SeqCst) { + return false; + } + let Some(win) = app.get_webview_window(POPUP_LABEL) else { + return false; + }; + let Ok(pos) = win.outer_position() else { return false }; + let Ok(size) = win.outer_size() else { return false }; + let Some((cx, cy)) = crate::win32_util::get_cursor_pos() else { + return false; + }; + let x = pos.x; + let y = pos.y; + let w = size.width as i32; + let h = size.height as i32; + cx >= x && cx <= x + w && cy >= y && cy <= y + h +} + +/// 鼠标当前是否位于预览窗矩形内（预览窗可见且光标在其窗口范围内）。 +/// 用于弹窗失焦时判断是否因预览交互所致，决定是否推迟隐藏弹窗。 +fn is_cursor_in_preview(app: &AppHandle) -> bool { + if !PREVIEW_VISIBLE.load(Ordering::SeqCst) { + return false; + } + let Some(win) = app.get_webview_window(PREVIEW_LABEL) else { + return false; + }; + let Ok(pos) = win.outer_position() else { return false }; + let Ok(size) = win.outer_size() else { return false }; + let Some((cx, cy)) = crate::win32_util::get_cursor_pos() else { + return false; + }; + let x = pos.x; + let y = pos.y; + let w = size.width as i32; + let h = size.height as i32; + cx >= x && cx <= x + w && cy >= y && cy <= y + h +} + // ===== 屏幕/光标/DPI 工具已迁移至 crate::win32_util（跨模块共享） ===== use crate::win32_util::{get_cursor_pos, get_work_area_at_point, get_dpi_for_point}; diff --git a/src-tauri/src/clipboard/reader.rs b/src-tauri/src/clipboard/reader.rs index f90acc5..0833a5e 100644 --- a/src-tauri/src/clipboard/reader.rs +++ b/src-tauri/src/clipboard/reader.rs @@ -295,3 +295,29 @@ pub fn dib_to_png(dib: &[u8]) -> Option> { .ok()?; Some(buf) } + +/// 生成缩略图 PNG（最长边不超过 max_dim 像素）。 +/// 小图直接复用 `dib_to_png` 结果；大图降采样后重新编码，供弹窗悬停预览使用。 +pub fn dib_to_thumbnail(dib: &[u8], max_dim: u32) -> Option> { + use image::codecs::png::PngEncoder; + use image::GenericImageView; + use image::ImageEncoder; + + let png = dib_to_png(dib)?; + let img = image::load_from_memory(&png).ok()?; + let (w, h) = img.dimensions(); + if w.max(h) <= max_dim { + return Some(png); // 小图直接使用，避免重复编码 + } + // 让 image 库在 max_dim×max_dim 边界内自动等比缩放，避免手算 nw/nh 与库内部 + // resize_dimensions 的取整不一致（如手算 256x10 而库实际输出 250x10）， + // 否则 write_image 的缓冲区长度断言会失败。 + let resized = img.resize(max_dim, max_dim, image::imageops::FilterType::Triangle); + let (rw, rh) = resized.dimensions(); + let rgba = resized.to_rgba8(); + let mut buf = Vec::new(); + let enc = PngEncoder::new(&mut buf); + enc.write_image(rgba.as_raw(), rw, rh, image::ExtendedColorType::Rgba8) + .ok()?; + Some(buf) +} diff --git a/src-tauri/src/clipboard/storage.rs b/src-tauri/src/clipboard/storage.rs index 95b2546..16e5286 100644 --- a/src-tauri/src/clipboard/storage.rs +++ b/src-tauri/src/clipboard/storage.rs @@ -2,6 +2,7 @@ //! //! 表结构见 `init_db`。所有方法线程安全（内部 Mutex 包裹 Connection）。 +use base64::Engine as _; use rusqlite::{params, Connection, OptionalExtension}; use specta::Type; use std::fs; @@ -38,6 +39,8 @@ pub struct NewItem { pub kind: String, pub content: Option, pub blob: Option>, + /// 图片缩略图 PNG（仅 image 类型，供弹窗悬停预览） + pub thumb: Option>, pub preview: String, pub size: i64, pub hash: String, @@ -88,6 +91,19 @@ impl Storage { CREATE INDEX IF NOT EXISTS idx_hash ON clipboard_history(hash); CREATE INDEX IF NOT EXISTS idx_kind ON clipboard_history(kind);", ); + // 迁移：老库无 thumb 列（图片缩略图，供弹窗悬停预览），补列 + let has_thumb = conn + .prepare("PRAGMA table_info(clipboard_history)") + .ok() + .map(|mut stmt| { + stmt.query_map([], |r| r.get::<_, String>(1)) + .map(|rows| rows.filter_map(|c| c.ok()).any(|c| c == "thumb")) + .unwrap_or(false) + }) + .unwrap_or(false); + if !has_thumb { + let _ = conn.execute("ALTER TABLE clipboard_history ADD COLUMN thumb BLOB", []); + } } /// 插入新条目；若 dedup 为 true 且 hash 已存在则仅更新 created_at，返回条目 id。 @@ -120,12 +136,13 @@ impl Storage { let now = now_ms(); let res = conn.execute( "INSERT INTO clipboard_history - (kind, content, blob, preview, size, hash, pinned, pinned_order, created_at) - VALUES (?1, ?2, ?3, ?4, ?5, ?6, 0, NULL, ?7)", + (kind, content, blob, thumb, preview, size, hash, pinned, pinned_order, created_at) + VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, 0, NULL, ?8)", params![ item.kind, item.content, item.blob.as_deref(), + item.thumb.as_deref(), item.preview, item.size, item.hash, @@ -249,6 +266,26 @@ impl Storage { }) } + /// 获取图片缩略图 PNG base64（弹窗悬停预览用）。 + /// 老数据无缩略图时回退为 `thumb_from_dib` 现场生成。 + pub fn get_thumb(&self, id: i64, thumb_from_dib: impl Fn(&[u8]) -> Option>) -> Option { + let (thumb, blob) = { + let conn = self.conn.lock().ok()?; + conn.query_row( + "SELECT thumb, blob FROM clipboard_history WHERE id = ?1 AND kind = 'image'", + params![id], + |r| Ok((r.get::<_, Option>>(0)?, r.get::<_, Option>>(1)?)), + ) + .ok()? + }; + // conn 已在此处释放 + let png = match thumb { + Some(t) if !t.is_empty() => Some(t), + _ => blob.as_deref().and_then(|b| thumb_from_dib(b)), + }; + png.map(|p| base64::engine::general_purpose::STANDARD.encode(&p)) + } + /// 获取原始字段供 copy_back 写回（避免 base64 转换开销） pub fn get_raw_for_copy(&self, id: i64) -> Option<(String, Option, Option>)> { let conn = self.conn.lock().ok()?; diff --git a/src-tauri/src/constants.rs b/src-tauri/src/constants.rs index 98ce74a..291e80c 100644 --- a/src-tauri/src/constants.rs +++ b/src-tauri/src/constants.rs @@ -26,10 +26,14 @@ pub mod events { 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 CLIPBOARD_PREVIEW_SHOW: &str = "clipboard-preview-show"; + pub const CLIPBOARD_PREVIEW_HIDE: &str = "clipboard-preview-hide"; // 快速面板 pub const QUICKPANEL_SHOW: &str = "quickpanel-show"; pub const QUICKPANEL_HIDE: &str = "quickpanel-hide"; pub const QUICKPANEL_EXTRACT_PROGRESS: &str = "quickpanel-extract-progress"; + /// 文件索引构建完成（闲时自动建立/重建、手动构建），负载为条目数 + pub const QUICKPANEL_INDEX_UPDATED: &str = "quickpanel-index-updated"; // 监控 pub const MONITOR_DATA: &str = "monitor-data"; pub const MONITOR_NETWORK: &str = "monitor-network"; @@ -47,11 +51,15 @@ pub mod events { pub const SCREENSHOT_PIN_SHORTCUT: &str = "screenshot-pin-shortcut"; // 内核安装进度 pub const KERNEL_INSTALL_PROGRESS: &str = "kernel-install-progress"; + // 后端自动切换节点完成（前端据以刷新节点列表并提示） + pub const PROXY_AUTO_SWITCH: &str = "proxy-auto-switch"; // 应用更新进度 pub const UPDATE_PROGRESS: &str = "update-progress"; // 进程与下载 pub const PROCESS_STATUS_CHANGED: &str = "process-status-changed"; pub const DOWNLOAD_ADDED: &str = "download-added"; + /// 任务被删除（浏览器扩展通过 HTTP API 删除任务时发出，前端据此刷新任务列表） + pub const DOWNLOAD_REMOVED: &str = "download-removed"; /// 浏览器扩展通过 HTTP API 新增下载（前端需置前主窗口并跳到下载画面） pub const DOWNLOAD_EXTENSION_ADDED: &str = "download-extension-added"; } diff --git a/src-tauri/src/download_engine/engine.rs b/src-tauri/src/download_engine/engine.rs index 9a48abf..a83303f 100644 --- a/src-tauri/src/download_engine/engine.rs +++ b/src-tauri/src/download_engine/engine.rs @@ -64,6 +64,8 @@ pub struct ProgressPayload { pub total_size: u64, pub speed: u64, pub status: TaskStatus, + /// 每个分段的已下载字节（与任务 segments 一一对应，供前端详情弹窗实时展示） + pub segments: Vec, } /// 完成事件载荷（发给前端 download-complete 事件） @@ -107,6 +109,9 @@ struct EngineInner { global_limiter: Arc, /// HTTP 下载器 http: HttpDownloader, + /// 下载是否使用代理（true=尊重系统代理，false=强制直连） + /// 独立于 settings 存储，避免下载过程中反复锁 settings；save_settings 时同步更新 + use_proxy: AtomicBool, /// Tauri 应用句柄（用于发事件） app_handle: AppHandle, /// 引擎是否已启动 @@ -144,6 +149,8 @@ impl DownloadEngine { 0 }; let global_limiter = Arc::new(RateLimiter::new(global_limit)); + // 在 settings 移入 Mutex 前读取代理开关 + let use_proxy = settings.use_proxy; let engine = Self { inner: Arc::new(EngineInner { @@ -153,6 +160,7 @@ impl DownloadEngine { settings: Mutex::new(settings), global_limiter, http: HttpDownloader::new(), + use_proxy: AtomicBool::new(use_proxy), app_handle, started: AtomicBool::new(false), next_gen: AtomicU64::new(0), @@ -188,7 +196,8 @@ impl DownloadEngine { dir: Option<&str>, headers: &HashMap, ) -> (Result, DuplicateKind, Option) { - let probe = self.inner.http.probe(url, headers).await; + let use_proxy = self.inner.use_proxy.load(Ordering::SeqCst); + let probe = self.inner.http.probe(url, headers, use_proxy).await; 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()); @@ -250,11 +259,30 @@ impl DownloadEngine { } /// 生成不冲突的文件名（同名时追加 (1)、(2)...） + /// 冲突来源：磁盘已有同名最终文件、已存在同名临时文件（其他任务正在下载该名）、 + /// 以及任务列表中已有任务占用同名（即使最终文件尚未落盘，避免共用同一 .thingdl 临时文件） fn generate_unique_filename(&self, dir: &str, filename: &str) -> String { - let path = PathBuf::from(dir).join(filename); - if !path.exists() { + // 任务列表中已占用的文件名（同一目录下） + let taken: std::collections::HashSet = { + let tasks = self.inner.tasks.lock().unwrap_or_else(|e| e.into_inner()); + tasks + .values() + .filter(|t| t.dir == dir) + .map(|t| t.filename.clone()) + .collect() + }; + + // 磁盘最终文件 / 临时文件 / 任务占用，三者任一冲突即视为被占用 + let used = |name: &str| { + taken.contains(name) + || PathBuf::from(dir).join(name).exists() + || PathBuf::from(dir).join(format!("{}.thingdl", name)).exists() + }; + + if !used(filename) { return filename.to_string(); } + let path = PathBuf::from(dir).join(filename); let stem = path.file_stem().and_then(|s| s.to_str()).unwrap_or("download"); let ext = path.extension().and_then(|s| s.to_str()); for i in 1..1000 { @@ -262,8 +290,7 @@ impl DownloadEngine { Some(e) => format!("{} ({}).{}", stem, i, e), None => format!("{} ({})", stem, i), }; - let new_path = PathBuf::from(dir).join(&new_name); - if !new_path.exists() { + if !used(&new_name) { return new_name; } } @@ -285,7 +312,8 @@ impl DownloadEngine { auto_rename: bool, ) -> Result { // 探测资源信息 - let probe = self.inner.http.probe(&url, &headers).await; + let use_proxy = self.inner.use_proxy.load(Ordering::SeqCst); + let probe = self.inner.http.probe(&url, &headers, use_proxy).await; 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()); @@ -419,8 +447,8 @@ impl DownloadEngine { if task.status != TaskStatus::Paused && task.status != TaskStatus::Error { return Err("任务不在可恢复状态".to_string()); } - // 如果不支持断点续传，从头开始 - if !task.supports_resume { + // 如果不支持断点续传，或文件大小未知（无法定位续传起点，需从头下载），从头开始 + if !task.supports_resume || task.total_size == 0 { task.completed_size = 0; for seg in &mut task.segments { seg.completed = 0; @@ -491,6 +519,11 @@ impl DownloadEngine { }; self.inner.global_limiter.set_limit(new_limit); + // 同步代理开关（新任务/探测立即生效，正在下载的任务不受影响） + self.inner + .use_proxy + .store(settings.use_proxy, Ordering::SeqCst); + { let mut s = self.inner.settings.lock().unwrap_or_else(|e| e.into_inner()); *s = settings; @@ -613,11 +646,12 @@ impl DownloadEngine { let temp_file_path = task.temp_file_path(); let final_file_path = task.file_path(); let http = self.inner.http.clone(); + let use_proxy = self.inner.use_proxy.load(Ordering::SeqCst); 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) + .download(&url, &headers, &segments, &temp_file_path, cancel_clone, &progress_clone, limiter, use_proxy) .await; // 代际守卫：仅最新代际的任务能更新状态 / 移除句柄 / 发完成事件。 @@ -748,6 +782,11 @@ impl DownloadEngine { .iter() .map(|p| p.load(Ordering::Relaxed)) .sum(); + // 各分段实时进度（供前端详情弹窗分段条展示） + let segment_completed: Vec = progress_monitor + .iter() + .map(|p| p.load(Ordering::Relaxed)) + .collect(); // 计算速度 let now = Instant::now(); @@ -788,6 +827,7 @@ impl DownloadEngine { total_size, speed, status: live_status, + segments: segment_completed, }, ); } diff --git a/src-tauri/src/download_engine/http_dl.rs b/src-tauri/src/download_engine/http_dl.rs index 8310f78..8184733 100644 --- a/src-tauri/src/download_engine/http_dl.rs +++ b/src-tauri/src/download_engine/http_dl.rs @@ -21,15 +21,35 @@ const READ_STALL_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(3 /// HTTP/HTTPS 下载器 #[derive(Clone)] pub struct HttpDownloader { - client: Client, + /// 默认客户端：尊重系统代理（reqwest 默认行为，mihomo 开启系统代理时经其转发） + system_client: Client, + /// 直连客户端：强制禁用系统代理（no_proxy） + direct_client: Client, } impl HttpDownloader { pub fn new() -> Self { - let client = Client::builder() + let system_client = Client::builder() .build() .unwrap_or_else(|_| Client::new()); - Self { client } + let direct_client = Client::builder() + // 强制直连：即使系统代理已开启，下载也不经过代理 + .no_proxy() + .build() + .unwrap_or_else(|_| Client::new()); + Self { + system_client, + direct_client, + } + } + + /// 根据 use_proxy 选择客户端 + fn client(&self, use_proxy: bool) -> &Client { + if use_proxy { + &self.system_client + } else { + &self.direct_client + } } /// 探测下载资源信息（大小、是否支持 Range、文件名） @@ -38,10 +58,11 @@ impl HttpDownloader { &self, url: &str, headers: &HashMap, + use_proxy: bool, ) -> Result { + let client = self.client(use_proxy); // 先尝试 Range 请求（能同时判断 Accept-Ranges 和获取大小） - let mut req = self - .client + let mut req = client .get(url) .header("Range", "bytes=0-0") .header("User-Agent", "Thing-Download-Engine/1.0"); @@ -97,7 +118,7 @@ impl HttpDownloader { } Err(_) => { // GET 失败，尝试 HEAD 作为回退 - let mut head_req = self.client.head(url); + let mut head_req = client.head(url); for (k, v) in headers { head_req = head_req.header(k, v); } @@ -132,6 +153,7 @@ impl HttpDownloader { /// - `cancel`: 取消标志 /// - `progress`: 每个分段的已下载字节（AtomicU64，与 segments 一一对应） /// - `limiter`: 全局限速器 + /// - `use_proxy`: 是否使用系统代理（false=强制直连） pub async fn download( &self, url: &str, @@ -141,7 +163,9 @@ impl HttpDownloader { cancel: Arc, progress: &[Arc], limiter: Arc, + use_proxy: bool, ) -> Result<(), String> { + let client = self.client(use_proxy); let total_size = segments.iter().map(|s| s.len()).sum(); // 预分配文件（若已知大小） @@ -167,7 +191,7 @@ impl HttpDownloader { // 单线程下载（不支持 Range 或文件太小） let seg = &segments[0]; let prog = &progress[0]; - self.download_segment(url, headers, seg, file_path, cancel.clone(), prog.clone(), limiter) + self.download_segment(url, headers, seg, file_path, cancel.clone(), prog.clone(), limiter, client) .await?; return Ok(()); } @@ -187,7 +211,7 @@ impl HttpDownloader { .unwrap_or_default(); let limiter = limiter.clone(); let file_path = file_path.to_path_buf(); - let client = self.client.clone(); + let client = client.clone(); join_set.spawn(async move { download_segment_with_client( @@ -241,9 +265,10 @@ impl HttpDownloader { cancel: Arc, progress: Arc, limiter: Arc, + client: &Client, ) -> Result<(), String> { download_segment_with_client( - &self.client, + client, url, headers, seg, @@ -366,6 +391,15 @@ async fn download_segment_with_client( limiter.consume(buf.len() as u64).await; buf.clear(); } + // 校验：已知大小的分段若流提前结束（收到的字节数不足分段长度）， + // 说明服务器提前断开或返回不完整内容，不能标记为完成，否则文件会被截断 + if !unknown_size && local_completed < seg.len() { + return Err(format!( + "文件不完整：已接收 {} / {} 字节，服务器提前结束连接", + local_completed, + seg.len() + )); + } break; } Err(_) => { diff --git a/src-tauri/src/download_engine/server.rs b/src-tauri/src/download_engine/server.rs index 8f5d536..1181a8e 100644 --- a/src-tauri/src/download_engine/server.rs +++ b/src-tauri/src/download_engine/server.rs @@ -9,10 +9,10 @@ use axum::{ Router, }; use serde::{Deserialize, Serialize}; -use tauri::{AppHandle, Emitter, Manager}; +use tauri::{AppHandle, Emitter}; use super::engine::DownloadEngine; -use super::task::DownloadTask; +use super::task::{DownloadTask, TaskStatus}; /// 扩展 HTTP API 服务器 pub struct ExtensionServer; @@ -114,6 +114,14 @@ async fn create_download( return Err((StatusCode::UNAUTHORIZED, Json(ErrorResponse { error: "未授权".into() }))); } + // 去重：同 URL 已有非终态任务（活跃/排队/暂停）时直接返回既有任务， + // 避免浏览器重复转发同一下载造成重复下载 + if let Some(existing) = state.engine.get_tasks().into_iter().find(|t| { + matches!(t.status, TaskStatus::Active | TaskStatus::Queued | TaskStatus::Paused) && t.url == req.url + }) { + return Ok(Json(CreateDownloadResponse { id: existing.id })); + } + match state.engine.add_task(req.url, req.filename, req.dir, req.headers, true).await { Ok(id) => { // 浏览器扩展发起下载：置前主窗口并通知前端跳到下载画面（替代原桌面通知） @@ -146,7 +154,11 @@ async fn remove_download( return Err((StatusCode::UNAUTHORIZED, Json(ErrorResponse { error: "未授权".into() }))); } match state.engine.remove_task(&id, false) { - Ok(()) => Ok(StatusCode::NO_CONTENT), + Ok(()) => { + // 通知前端刷新任务列表（扩展删除时前端无从感知，否则列表残留已删除任务） + let _ = state.app_handle.emit(crate::constants::events::DOWNLOAD_REMOVED, serde_json::json!({ "id": id })); + Ok(StatusCode::NO_CONTENT) + } Err(e) => Err((StatusCode::NOT_FOUND, Json(ErrorResponse { error: e }))), } } diff --git a/src-tauri/src/download_engine/task.rs b/src-tauri/src/download_engine/task.rs index 59acea1..4b59e52 100644 --- a/src-tauri/src/download_engine/task.rs +++ b/src-tauri/src/download_engine/task.rs @@ -37,8 +37,17 @@ impl Segment { pub fn len(&self) -> u64 { self.end.saturating_sub(self.start) + 1 } + /// 是否为未知大小哨兵段（start=0, end=0，表示不支持 Range 或未探测到大小） + pub fn is_unknown_size(&self) -> bool { + self.start == 0 && self.end == 0 + } /// 是否已完成 pub fn is_done(&self) -> bool { + // 未知大小段无法用长度判断是否完成，由流结束（Ok(None)）判定； + // 若按 len()=1 判断，暂停/恢复后 completed>=1 会误判为已完成，导致文件被截断 + if self.is_unknown_size() { + return false; + } self.completed >= self.len() } } @@ -129,6 +138,9 @@ pub struct DownloaderSettings { /// 添加下载前检查重复（URL 或文件名重复时询问） #[serde(default = "default_true")] pub check_duplicate: bool, + /// 下载是否使用代理：true=尊重系统代理（mihomo 开启系统代理时经其转发），false=强制直连 + #[serde(default = "default_true")] + pub use_proxy: bool, } fn default_max_concurrent() -> u32 { @@ -167,6 +179,7 @@ impl Default for DownloaderSettings { extension_secret: String::new(), delete_files_on_remove: false, check_duplicate: true, + use_proxy: true, } } } diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs index 545b6c0..d36abe5 100644 --- a/src-tauri/src/lib.rs +++ b/src-tauri/src/lib.rs @@ -28,11 +28,11 @@ use logger::{ 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, - 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_activate_profile, proxy_apply_kernel_update, proxy_cancel_kernel_install, proxy_check_kernel_update, proxy_clear_system_proxy, + proxy_close_connection, proxy_confirm_install, proxy_delete_profile, proxy_get_connections, proxy_get_proxies, proxy_get_settings, proxy_get_system_proxy, + proxy_import_profile, 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, MihomoManager, + proxy_test_delay, proxy_update_profile, proxy_version, MihomoManager, }; use monitor_kernel::{ monitor_elevate_self, monitor_get_auto_start, monitor_get_elevate_on_launch, @@ -42,8 +42,8 @@ use monitor_kernel::{ }; 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, + osd_apply_overlay_style, osd_begin_drag, osd_set_bounds, osd_set_click_through, + osd_set_topmost, osd_start_drag_watch, osd_start_topmost_watch, osd_stop_watch, }; use process_manager::{ process_all_status, process_start, process_status, @@ -55,16 +55,21 @@ use screenshot::commands::{ 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_pin_shortcut, screenshot_register_shortcut, screenshot_save_cache, - screenshot_save_png, screenshot_set_editor_image, screenshot_unregister_pin_shortcut, - screenshot_unregister_shortcut, screenshot_window_from_point, + screenshot_load_cache_raw, screenshot_pick_list, screenshot_register_pin_shortcut, + screenshot_register_shortcut, + screenshot_save_cache, screenshot_save_png, screenshot_set_editor_image, + screenshot_show_overlay, screenshot_unregister_pin_shortcut, + screenshot_unregister_shortcut, }; use clipboard::{ ClipboardManager, clipboard_clear, clipboard_copy_back, clipboard_count, clipboard_delete, clipboard_get_history, - clipboard_get_item, clipboard_get_pinned, clipboard_get_settings, clipboard_hide_popup, - clipboard_paste_to_target, clipboard_register_shortcut, clipboard_save_settings, clipboard_search, - clipboard_set_pinned, clipboard_show_popup, clipboard_show_window, clipboard_start, + clipboard_get_item, clipboard_get_pinned, clipboard_get_settings, clipboard_get_thumb, + clipboard_hide_popup, clipboard_hide_preview, clipboard_paste_to_target, + clipboard_preview_interacted, clipboard_register_shortcut, + clipboard_reveal_preview, + clipboard_save_settings, clipboard_search, clipboard_set_pinned, clipboard_resize_preview, + clipboard_show_popup, clipboard_show_preview, clipboard_show_window, clipboard_start, clipboard_status, clipboard_stop, clipboard_unregister_shortcut, }; use quickpanel::{ @@ -107,12 +112,12 @@ fn export_bindings() { // 应用更新（4） app_version, update_check, update_install, update_thinghk, // 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_activate_profile, proxy_apply_kernel_update, proxy_cancel_kernel_install, proxy_check_kernel_update, proxy_clear_system_proxy, + proxy_close_connection, proxy_confirm_install, proxy_delete_profile, proxy_get_settings, + proxy_get_system_proxy, proxy_import_profile, 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, + proxy_test_delay, proxy_update_profile, // quickpanel（22） quickpanel_get_settings, quickpanel_save_settings, quickpanel_register_shortcut, quickpanel_unregister_shortcut, quickpanel_show_popup, quickpanel_hide_popup, @@ -124,23 +129,25 @@ fn export_bindings() { quickpanel_run_system_command, quickpanel_list_archives, quickpanel_list_dir, quickpanel_batch_extract, quickpanel_preview_rename, quickpanel_apply_rename, quickpanel_delete_files, quickpanel_focus_main_window, - // clipboard（20） + // clipboard（23） 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_get_thumb, 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, + clipboard_show_window, clipboard_paste_to_target, clipboard_show_preview, + clipboard_hide_preview, clipboard_resize_preview, clipboard_reveal_preview, + clipboard_preview_interacted, // 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（21，豁免 2：get_fullscreen_bmp 返回 ipc::Response、compose_copy 接收 ipc::Request） - screenshot_disable_transitions, screenshot_register_shortcut, + // screenshot（22，豁免 3：get_fullscreen_bmp / load_cache_raw 返回 ipc::Response、compose_copy 接收 ipc::Request） + screenshot_disable_transitions, screenshot_show_overlay, screenshot_register_shortcut, screenshot_unregister_shortcut, screenshot_register_pin_shortcut, screenshot_unregister_pin_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_crop_copy_stored, screenshot_pick_list, 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, @@ -187,8 +194,9 @@ pub fn run() { proxy_save_settings, proxy_kernel_info, proxy_check_kernel_update, - proxy_update_kernel, - proxy_install_kernel, + proxy_apply_kernel_update, + proxy_cancel_kernel_install, + proxy_confirm_install, proxy_status, proxy_start, proxy_stop, @@ -224,6 +232,7 @@ pub fn run() { network_status, osd_apply_overlay_style, osd_begin_drag, + osd_set_bounds, osd_set_click_through, osd_set_topmost, osd_start_drag_watch, @@ -245,6 +254,7 @@ pub fn run() { clipboard_get_pinned, clipboard_search, clipboard_get_item, + clipboard_get_thumb, clipboard_set_pinned, clipboard_delete, clipboard_clear, @@ -261,6 +271,11 @@ pub fn run() { clipboard_show_window, clipboard_hide_popup, clipboard_paste_to_target, + clipboard_show_preview, + clipboard_hide_preview, + clipboard_resize_preview, + clipboard_reveal_preview, + clipboard_preview_interacted, quickpanel_get_settings, quickpanel_save_settings, quickpanel_register_shortcut, @@ -300,7 +315,8 @@ pub fn run() { screenshot_clear_fullscreen, screenshot_crop_stored, screenshot_crop_copy_stored, - screenshot_window_from_point, + screenshot_pick_list, + screenshot_show_overlay, screenshot_cursor_pos, screenshot_enum_windows, screenshot_capture_window, @@ -310,6 +326,7 @@ pub fn run() { screenshot_save_png, screenshot_save_cache, screenshot_load_cache, + screenshot_load_cache_raw, screenshot_delete_cache, screenshot_register_shortcut, screenshot_unregister_shortcut, @@ -320,9 +337,13 @@ pub fn run() { ]) .setup(setup::init) .on_window_event(|window, event| { - if let tauri::WindowEvent::CloseRequested { api, .. } = event { - window.hide().ok(); - api.prevent_close(); + // 仅主窗口拦截关闭（隐藏到托盘）。其他窗口（截图编辑器/OSD 等） + // 调用 close() 是真实销毁语义，全局拦截会导致隐藏窗口累积泄漏。 + if window.label() == constants::windows::MAIN { + if let tauri::WindowEvent::CloseRequested { api, .. } = event { + window.hide().ok(); + api.prevent_close(); + } } }) .build(tauri::generate_context!()) @@ -337,16 +358,18 @@ pub fn run() { } if let Some(monitor) = app.try_state::() { // cleanup_on_exit 是 async；在事件循环回调中直接 block_on 有 panic 风险且阻塞退出， - // 放到独立 OS 线程执行并限时等待（与托盘旧实现同模式）。 + // 放到独立 OS 线程执行并通过 channel 限时等待 3s，超时放弃等待直接退出 + // （进程终止时 OS 回收残留资源），避免清理挂起导致退出卡死。 let app_clone = app.clone(); let monitor_clone = monitor.inner().clone(); + let (tx, rx) = std::sync::mpsc::channel::<()>(); std::thread::spawn(move || { tauri::async_runtime::block_on(async move { monitor_clone.cleanup_on_exit(&app_clone).await; }); - }) - .join() - .ok(); + let _ = tx.send(()); + }); + let _ = rx.recv_timeout(std::time::Duration::from_secs(3)); } if let Some(clip) = app.try_state::() { clip.stop(); diff --git a/src-tauri/src/mihomo_manager/autoswitch.rs b/src-tauri/src/mihomo_manager/autoswitch.rs new file mode 100644 index 0000000..58fb3e9 --- /dev/null +++ b/src-tauri/src/mihomo_manager/autoswitch.rs @@ -0,0 +1,192 @@ +//! 自动切换节点：后端调度，独立于前端模块是否处于激活状态。 +//! 应用启动后由 `setup.rs` 启动后台任务，按用户设置的间隔周期性测速并切换到当前最优节点， +//! 切换完成后通过 `proxy-auto-switch` 事件通知前端刷新界面。 +//! 节点候选（目标组 + 地区筛选 + 伪节点过滤）与择优逻辑对前端、后台调度、托盘三处保持一致。 + +use futures_util::future::join_all; +use serde_json::{Map, Value}; +use std::time::{Duration, Instant}; +use tauri::{AppHandle, Emitter, Manager, State}; + +use super::{MihomoManager, ProxySettings}; +use crate::constants::events::PROXY_AUTO_SWITCH; +use crate::process_manager::{ProcessManager, ProcessStatus}; + +/// 测速目标（同前端/托盘），用于判断节点可用性 +const TEST_URL: &str = "http://www.gstatic.com/generate_204"; +/// 单节点测速超时（毫秒） +const TEST_TIMEOUT: u32 = 5000; +/// 调度轮询粒度（秒） +const CHECK_INTERVAL: u64 = 30; + +/// 后端启动自动切换调度任务（幂等，可安全多次调用）。 +/// 仅在用户开启「自动切换节点」且 mihomo 运行时才会真正执行测速与切换。 +pub fn start_auto_switch_loop(app: AppHandle) { + tauri::async_runtime::spawn(async move { + let mut last_run: Option = None; + loop { + tokio::time::sleep(Duration::from_secs(CHECK_INTERVAL)).await; + + let enabled = app + .try_state::() + .map(|m: State<'_, MihomoManager>| m.load_settings().auto_switch_enabled) + .unwrap_or(false); + if !enabled { + last_run = None; + continue; + } + + let interval_secs = app + .try_state::() + .map(|m: State<'_, MihomoManager>| m.load_settings().auto_switch_interval.max(1) as u64) + .unwrap_or(5) + * 60; + + let due = match last_run { + Some(t) => t.elapsed().as_secs() >= interval_secs, + None => true, + }; + if !due { + continue; + } + + if let Some((group, name, delay)) = perform_auto_switch(&app).await { + let _ = app.emit( + PROXY_AUTO_SWITCH, + serde_json::json!({ + "switched": true, + "group": group, + "name": name, + "delay": delay, + }), + ); + } + last_run = Some(Instant::now()); + } + }); +} + +/// 执行一次自动切换：若当前不是最优节点则切换并返回 `(组名, 节点名, 延迟)`，否则返回 `None`。 +/// 供后台调度任务使用（模块内私有）。 +async fn perform_auto_switch(app: &AppHandle) -> Option<(String, String, u32)> { + let mihomo = app.state::(); + let pm = app.state::(); + + // 仅在 mihomo 运行时执行 + let running = matches!( + pm.get_status("proxy").map(|p| p.status), + Some(ProcessStatus::Running) + ); + if !running { + return None; + } + + let settings = mihomo.load_settings(); + if !settings.auto_switch_enabled { + return None; + } + + let (group, name, delay, now) = pick_best(&mihomo, &settings).await.ok()??; + + if name != now && mihomo.select_proxy(&group, &name).await.is_ok() { + return Some((group, name, delay)); + } + None +} + +/// 按自动切换设置确定候选组与地区，并发测速并返回当前最优节点（不执行切换）。 +/// `Some((组名, 最优节点, 延迟, 当前节点))`；无候选或全部超时返回 `Ok(None)`。 +/// 当自动切换关闭时自动切换目标组为空、地区为空，故退化为「主组 + 全部节点」全量择优， +/// 托盘「开启代理」与调度任务复用此函数保证行为一致。 +pub async fn pick_best( + mihomo: &MihomoManager, + settings: &ProxySettings, +) -> Result, String> { + let proxies = mihomo.get_proxies().await?; + let map = proxies + .get("proxies") + .and_then(|v| v.as_object()) + .cloned() + .ok_or_else(|| "无法解析代理数据".to_string())?; + + let group_name = if !settings.auto_switch_group.is_empty() { + settings.auto_switch_group.clone() + } else { + match main_selector_group(&map) { + Some(g) => g, + None => return Ok(None), + } + }; + + let group = match map.get(&group_name) { + Some(g) => g, + None => return Ok(None), + }; + let now = group + .get("now") + .and_then(|v| v.as_str()) + .unwrap_or("") + .to_string(); + + let mut nodes: Vec = group + .get("all") + .and_then(|v| v.as_array()) + .map(|arr| arr.iter().filter_map(|n| n.as_str().map(|s| s.to_string())).collect()) + .unwrap_or_default(); + if nodes.is_empty() { + return Ok(None); + } + + // 过滤伪节点（DIRECT、REJECT、流量、套餐等） + nodes.retain(|n| !super::is_pseudo_node(n)); + // 地区筛选 + if !settings.auto_switch_region.is_empty() { + let region = settings.auto_switch_region.clone(); + nodes.retain(|n| extract_region(n) == region); + } + if nodes.is_empty() { + return Ok(None); + } + + // 并发测速 + let futures = nodes.iter().map(|name| async move { + let d = mihomo.test_delay(name, TEST_URL, TEST_TIMEOUT).await.ok(); + (name.clone(), d) + }).collect::>(); + let results = join_all(futures).await; + let best = results + .into_iter() + .filter_map(|(n, d)| d.filter(|x| *x > 0).map(|x| (n, x))) + .min_by_key(|(_, d)| *d); + + Ok(best.map(|(name, delay)| (group_name, name, delay, now))) +} + +/// 主选择分组：选取名为 PROXY/Proxy/节点选择/代理 的 Selector 组；找不到时回退到第一个 Selector 组 +fn main_selector_group(map: &Map) -> Option { + let mut preferred: Option = None; + let mut first_selector: Option = None; + for (name, val) in map { + let kind = val.get("type").and_then(|v| v.as_str()).unwrap_or(""); + if kind != "Selector" { + continue; + } + if first_selector.is_none() { + first_selector = Some(name.clone()); + } + if preferred.is_none() && ["PROXY", "Proxy", "节点选择", "代理"].contains(&name.as_str()) { + preferred = Some(name.clone()); + } + } + preferred.or(first_selector) +} + +/// 提取节点地区（与前端 extractRegion 保持一致）：取名称中第一个数字/符号分隔符之前的文本 +fn extract_region(name: &str) -> String { + for (idx, ch) in name.char_indices() { + if ch.is_ascii_digit() || matches!(ch, '|' | '-' | '－' | '—' | '（' | '(' | '【') { + return name[..idx].trim().to_string(); + } + } + name.trim().to_string() +} \ No newline at end of file diff --git a/src-tauri/src/mihomo_manager/commands.rs b/src-tauri/src/mihomo_manager/commands.rs index 6b88d14..c222192 100644 --- a/src-tauri/src/mihomo_manager/commands.rs +++ b/src-tauri/src/mihomo_manager/commands.rs @@ -7,7 +7,15 @@ use super::{ KernelInfo, KernelUpdateInfo, MihomoManager, ProfileMeta, ProxySettings, ProxyStatus, }; -use crate::process_manager::{ProcessInfo, ProcessManager}; +use crate::process_manager::{ProcessInfo, ProcessManager, ProcessStatus}; + +/// 判断 mihomo 进程是否处于运行状态 +fn mihomo_running(pm: &ProcessManager) -> bool { + matches!( + pm.get_status("proxy").map(|p| p.status), + Some(ProcessStatus::Running) + ) +} #[tauri::command] #[specta::specta] @@ -41,25 +49,33 @@ pub async fn proxy_check_kernel_update( state.check_kernel_update().await } +/// 取消内核下载/安装（设置取消标志，下载循环轮询后中止） #[tauri::command] #[specta::specta] -pub async fn proxy_update_kernel( - state: State<'_, MihomoManager>, - app: AppHandle, - mirror_prefix: Option, -) -> Result { - state.install_kernel(&app, mirror_prefix.unwrap_or_default()).await +pub fn proxy_cancel_kernel_install(state: State<'_, MihomoManager>) -> Result<(), String> { + state.cancel_kernel_install(); + Ok(()) } -/// 首次安装内核（与 update_kernel 共用 install_kernel 实现，语义独立便于前端区分场景） +/// 前端确认 mihomo 已停止，唤醒等待中的安装流程继续解压替换。 +/// （下载阶段允许 mihomo 运行以便走系统代理，解压替换前必须停止 mihomo，否则 exe 被占用） #[tauri::command] #[specta::specta] -pub async fn proxy_install_kernel( +pub fn proxy_confirm_install(state: State<'_, MihomoManager>) -> Result<(), String> { + state.confirm_install(); + Ok(()) +} + +/// 应用内核更新：下载阶段已由下载模块完成，本方法仅做 need_stop → 解压 → 替换。 +#[tauri::command] +#[specta::specta] +pub async fn proxy_apply_kernel_update( state: State<'_, MihomoManager>, app: AppHandle, - mirror_prefix: Option, + zip_path: String, ) -> Result { - state.install_kernel(&app, mirror_prefix.unwrap_or_default()).await + let path = std::path::PathBuf::from(zip_path); + state.apply_kernel_update(&app, path).await } #[tauri::command] @@ -87,12 +103,19 @@ pub fn proxy_start( app: AppHandle, ) -> Result { let params = state.prepare_for_start(&app)?; - pm.start(params) + let info = pm.start(params)?; + // 手动启动也遵循「启动时自动开启系统代理」设置 + state.apply_auto_system_proxy(); + Ok(info) } #[tauri::command] #[specta::specta] -pub fn proxy_stop(pm: State<'_, ProcessManager>) -> Result<(), String> { +pub fn proxy_stop(state: State<'_, MihomoManager>, pm: State<'_, ProcessManager>) -> Result<(), String> { + // 关闭 mihomo 时同步关闭系统代理（若开启），避免系统代理指向已停止的端口导致断网 + if get_system_proxy_windows() { + let _ = state.disable_system_proxy(); + } pm.stop("proxy") } @@ -110,8 +133,65 @@ pub async fn proxy_restart( }) .await .map_err(|e| format!("sleep 失败: {}", e))?; - let params = state.prepare_for_start(&app)?; - pm.start(params) + + // 启动并等待 API 就绪，带有限重试（共 3 次）： + // - 冷加载大订阅（首次解析 + geo 下载）可能远超过前端 waitForApi 的 10s 预算， + // 这里在命令内等满就绪，避免重启成功后仍被前端误判为「重启失败」导致节点不刷新。 + // - 偶发的端口未及时释放 / 启动瞬间退出，通过重试自愈。 + let mut last_err = "mihomo 启动失败".to_string(); + for _ in 0..3 { + match start_and_wait(state.inner(), pm.inner(), &app).await { + Ok(info) => return Ok(info), + Err(e) => { + last_err = e; + // 上个实例刚退出，多等一会儿释放端口再重试 + tauri::async_runtime::spawn_blocking(|| { + std::thread::sleep(std::time::Duration::from_millis(1200)); + }) + .await + .map_err(|x| format!("sleep 失败: {}", x))?; + } + } + } + // 所有启动尝试均失败：mihomo 已停止，同步关闭系统代理（若开启），避免代理指向已停止端口导致断网 + if get_system_proxy_windows() { + let _ = state.disable_system_proxy(); + } + Err(last_err) +} + +/// 启动 mihomo 并等待其 HTTP API 就绪（最多 20s）。 +/// - 若启动后进程立即退出，快速返回（不白等满预算），便于外层尽早重试。 +/// - 若 pm.start 返回「已在运行中」，说明崩溃监控已抢先拉起进程，同样等待其 API 就绪即可。 +async fn start_and_wait( + state: &MihomoManager, + pm: &ProcessManager, + app: &AppHandle, +) -> Result { + let params = state.prepare_for_start(app)?; + if let Err(e) = pm.start(params) { + // "已在运行中" = 崩溃监控已拉起，不算失败；其余为上抛 + if !e.contains("运行中") { + return Err(e); + } + } + + let deadline = tokio::time::Instant::now() + std::time::Duration::from_secs(20); + loop { + // 进程已退出且 API 未就绪 → 启动失败（快速失败，交外层重试） + if let Some(st) = pm.get_status("proxy") { + if !matches!(st.status, ProcessStatus::Running) { + return Err("mihomo 启动后立即退出".to_string()); + } + } + if state.get_version().await.is_ok() { + return pm.get_status("proxy").ok_or_else(|| "mihomo 进程不存在".to_string()); + } + if tokio::time::Instant::now() >= deadline { + return Err("mihomo 启动超时，API 无响应".to_string()); + } + tokio::time::sleep(std::time::Duration::from_millis(500)).await; + } } #[tauri::command] @@ -220,7 +300,12 @@ pub fn proxy_activate_profile( #[specta::specta] pub fn proxy_set_system_proxy( state: State<'_, MihomoManager>, + pm: State<'_, ProcessManager>, ) -> Result<(), String> { + // 停机时禁止开启系统代理：否则系统代理指向已停止的端口，会导致所有网络请求失败 + if !mihomo_running(&pm) { + return Err("mihomo 未运行，无法开启系统代理".into()); + } let settings = state.load_settings(); let addr = format!("127.0.0.1:{}", settings.mixed_port); set_system_proxy_windows(&addr)?; diff --git a/src-tauri/src/mihomo_manager/kernel.rs b/src-tauri/src/mihomo_manager/kernel.rs index d9e7ef4..87e1b8c 100644 --- a/src-tauri/src/mihomo_manager/kernel.rs +++ b/src-tauri/src/mihomo_manager/kernel.rs @@ -1,15 +1,18 @@ //! 内核（mihomo.exe）安装 / 更新 / 版本查询。 //! 子模块通过 `impl super::MihomoManager` 为管理器追加方法，可访问父模块私有字段。 -use futures_util::StreamExt; use std::fs; use std::io::{Read, Write}; use std::path::PathBuf; +use std::sync::atomic::Ordering; use tauri::{AppHandle, Emitter, Manager}; use crate::constants::events::KERNEL_INSTALL_PROGRESS; use super::{InstallProgress, KernelInfo, KernelUpdateInfo, MihomoManager}; +/// 用户主动取消下载的标记错误信息（前端据此静默处理，不弹错误 toast） +const KERNEL_CANCELLED: &str = "下载已取消"; + impl MihomoManager { // ---------- 内核 ---------- pub fn kernel_info(&self) -> KernelInfo { @@ -203,57 +206,15 @@ impl MihomoManager { } } - /// 下载并安装内核（首次安装与更新共用此方法） - /// - mirror_prefix: 用户选择的镜像源前缀（空串=直连 GitHub） - /// - 流式下载：实时推送下载进度到前端 - /// - zip crate 解压：替代 PowerShell，避免执行策略问题 - /// - 备份旧内核：替换前备份为 .bak - /// 任何阶段失败都会 emit error 事件，避免前端进度卡在初始状态 - pub async fn install_kernel(&self, app: &AppHandle, mirror_prefix: String) -> Result { - let result = self.install_kernel_inner(app, mirror_prefix).await; + /// 应用内核更新：下载阶段已由下载模块完成，本方法仅做 need_stop → 解压 → 替换。 + /// zip_path: 下载模块下载完成的 zip 文件路径。 + /// 任何阶段失败都会 emit error 事件，避免前端进度卡住。 + pub async fn apply_kernel_update(&self, app: &AppHandle, zip_path: PathBuf) -> Result { + self.kernel_cancel.store(false, Ordering::SeqCst); + let _ = self.kernel_cancel_tx.send(false); + let result = self.apply_kernel_inner(app, zip_path).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 { - 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); + if e != KERNEL_CANCELLED { let _ = app.emit( KERNEL_INSTALL_PROGRESS, InstallProgress { @@ -261,11 +222,50 @@ impl MihomoManager { percent: 0, downloaded_bytes: 0, total_bytes: None, - message: msg.clone(), + message: e.clone(), }, ); - let _ = fs::remove_file(&zip_path); - return Err(msg); + } + } + self.kernel_cancel.store(false, Ordering::SeqCst); + let _ = self.kernel_cancel_tx.send(false); + result + } + + async fn apply_kernel_inner(&self, app: &AppHandle, zip_path: PathBuf) -> Result { + let extract_dir = self.cores_dir().join("mihomo-update-tmp"); + + // 检查 zip 文件是否存在 + if !zip_path.exists() { + return Err(format!("下载文件不存在: {}", zip_path.display())); + } + + // 解压替换前需要等待前端确认 mihomo 已停止（否则 exe 文件被占用） + if self.kernel_cancel.load(Ordering::SeqCst) { + return Err(KERNEL_CANCELLED.to_string()); + } + let _ = app.emit( + KERNEL_INSTALL_PROGRESS, + InstallProgress { + stage: "need_stop".into(), + percent: 90, + downloaded_bytes: 0, + total_bytes: None, + message: "需要停止 mihomo 才能继续安装".into(), + }, + ); + // 创建 oneshot 通道等待前端确认 + let (tx, mut rx) = tokio::sync::oneshot::channel::<()>(); + *self.install_confirm.lock().unwrap() = Some(tx); + let mut cancel_rx = self.kernel_cancel_tx.subscribe(); + loop { + if self.kernel_cancel.load(Ordering::SeqCst) { + *self.install_confirm.lock().unwrap() = None; + return Err(KERNEL_CANCELLED.to_string()); + } + tokio::select! { + _ = &mut rx => break, + _ = cancel_rx.changed() => {} } } @@ -299,8 +299,6 @@ impl MihomoManager { } // 在解压目录中递归查找 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())?; @@ -313,7 +311,7 @@ impl MihomoManager { percent: 96, downloaded_bytes: 0, total_bytes: None, - message: "正在安装...".into(), + message: "正在替换内核...".into(), }, ); let kernel = self.kernel_path(); @@ -345,57 +343,6 @@ impl MihomoManager { 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))?; diff --git a/src-tauri/src/mihomo_manager/mod.rs b/src-tauri/src/mihomo_manager/mod.rs index de0fa0a..930e384 100644 --- a/src-tauri/src/mihomo_manager/mod.rs +++ b/src-tauri/src/mihomo_manager/mod.rs @@ -6,6 +6,7 @@ //! - [`system_proxy`]：Windows 系统代理开关 //! - [`commands`]：Tauri 命令层 +mod autoswitch; mod commands; mod kernel; mod profiles; @@ -13,22 +14,24 @@ mod pseudo; mod system_proxy; mod types; +pub use autoswitch::{pick_best, start_auto_switch_loop}; pub use pseudo::is_pseudo_node; pub use system_proxy::get_system_proxy_windows; 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, + proxy_activate_profile, proxy_apply_kernel_update, proxy_cancel_kernel_install, proxy_check_kernel_update, proxy_clear_system_proxy, + proxy_close_connection, proxy_confirm_install, proxy_delete_profile, proxy_get_connections, proxy_get_proxies, + proxy_get_settings, proxy_get_system_proxy, proxy_import_profile, 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_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::sync::atomic::{AtomicBool, Ordering}; +use std::sync::{Arc, Mutex}; use std::time::{Duration, Instant}; use tauri::AppHandle; @@ -46,6 +49,16 @@ pub struct MihomoManager { root: PathBuf, client: Client, settings_cache: Mutex>, + /// 内核安装/更新的取消标志（前端「停止下载」置位，下载循环轮询后中止） + kernel_cancel: Arc, + /// 取消唤醒通道：让停滞在流式读取（stream.next 最多等 30s）中的下载立即感知取消， + /// 否则旧任务会残留最长 30s，期间可能与新任务并发写临时文件/互相重置取消标志 + kernel_cancel_tx: tokio::sync::watch::Sender, + /// 下载完成后解压替换前的确认通道：mihomo 运行时下载不受影响，但解压替换前 + /// 必须等前端确认已停止 mihomo（否则 exe 文件被占用）。前端确认后通过 + /// proxy_confirm_install 命令发送信号唤醒等待。 + /// 用 std Mutex 而非 tokio Mutex：锁只短暂存取 sender，不跨 await 持有。 + install_confirm: std::sync::Mutex>>, } impl MihomoManager { @@ -62,6 +75,23 @@ impl MihomoManager { .build() .unwrap_or_else(|_| Client::new()), settings_cache: Mutex::new(None), + kernel_cancel: Arc::new(AtomicBool::new(false)), + kernel_cancel_tx: tokio::sync::watch::channel(false).0, + install_confirm: std::sync::Mutex::new(None), + } + } + + /// 请求取消内核安装/更新（由 proxy_cancel_kernel_install 命令调用） + pub fn cancel_kernel_install(&self) { + self.kernel_cancel.store(true, Ordering::SeqCst); + // 唤醒停滞的流式下载循环，使其立即中止而不是等 30s 超时 + let _ = self.kernel_cancel_tx.send(true); + } + + /// 前端确认 mihomo 已停止，唤醒等待中的安装流程继续解压替换（由 proxy_confirm_install 命令调用） + pub fn confirm_install(&self) { + if let Some(tx) = self.install_confirm.lock().unwrap().take() { + let _ = tx.send(()); } } @@ -274,6 +304,22 @@ impl MihomoManager { }) } + /// mihomo 启动成功后，若配置了「启动时自动开启系统代理」且当前未开，则开启系统代理。 + /// 手动启动与 App 自启共用，保证设置语义一致（mihomo 运行期间自动跟随系统代理）。 + pub fn apply_auto_system_proxy(&self) { + let settings = self.load_settings(); + if settings.auto_system_proxy && !settings.system_proxy && !system_proxy::get_system_proxy_windows() { + let addr = format!("127.0.0.1:{}", settings.mixed_port); + if let Err(e) = system_proxy::set_system_proxy_windows(&addr) { + crate::logger::log_warn("mihomo", &format!("自动开启系统代理失败: {}", e)); + return; + } + let mut s = settings; + s.system_proxy = true; + let _ = self.save_settings(&s); + } + } + /// 应用启动时检查是否需要自动启动 mihomo 和系统代理 pub fn auto_start_on_launch(&self, app: &AppHandle, pm: &ProcessManager) { let settings = self.load_settings(); @@ -284,13 +330,9 @@ impl MihomoManager { 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); + } else { + // 启动成功后按「启动时自动开启系统代理」设置决定是否开启系统代理 + self.apply_auto_system_proxy(); } } Err(e) => { diff --git a/src-tauri/src/osd_window.rs b/src-tauri/src/osd_window.rs index 2a39e62..b6a0a07 100644 --- a/src-tauri/src/osd_window.rs +++ b/src-tauri/src/osd_window.rs @@ -60,8 +60,8 @@ mod win_api { GetClassNameW, GetCursorPos, GetForegroundWindow, GetWindowLongPtrW, GetWindowRect, SendMessageW, SetWindowLongPtrW, SetWindowPos, GWL_EXSTYLE, HTCAPTION, HWND_NOTOPMOST, HWND_TOPMOST, SWP_NOACTIVATE, SWP_NOMOVE, - SWP_NOSIZE, SWP_SHOWWINDOW, WM_NCLBUTTONDOWN, WS_EX_NOACTIVATE, WS_EX_TOOLWINDOW, - WS_EX_TRANSPARENT, + SWP_NOSIZE, SWP_NOZORDER, SWP_SHOWWINDOW, WM_NCLBUTTONDOWN, WS_EX_NOACTIVATE, + WS_EX_TOOLWINDOW, WS_EX_TRANSPARENT, }; /// windows-sys 的 HWND 类型别名（isize） @@ -190,6 +190,24 @@ mod win_api { } } + /// 原子设置窗口位置与尺寸（物理像素） + /// + /// 一次 SetWindowPos 调用同时更新 x/y/w/h，避免 setSize + setPosition + /// 两次调用之间出现"宽度已变、位置未动"的中间帧（视觉闪烁）。 + pub fn set_bounds(hwnd: Hwnd, x: i32, y: i32, w: i32, h: i32) { + unsafe { + SetWindowPos( + hwnd, + 0, // 不改 Z 序 + x, + y, + w, + h, + SWP_NOACTIVATE | SWP_NOZORDER, + ); + } + } + /// 判断窗口类名是否为系统 UI（任务栏、开始菜单、通知区域等） pub fn is_system_ui_class(class_name: &str) -> bool { matches!( @@ -378,6 +396,28 @@ pub fn osd_set_topmost(label: String, topmost: bool, app: AppHandle) -> Result<( Ok(()) } +/// 原子设置窗口位置与尺寸（物理像素） +/// +/// 一次调用同时更新位置和尺寸，避免 setSize + setPosition 两次 IPC 之间的 +/// 中间帧（宽度已变、位置未动 → 视觉闪烁）。前端传入物理像素坐标。 +#[tauri::command] +pub fn osd_set_bounds( + label: String, + x: i32, + y: i32, + w: i32, + h: i32, + app: AppHandle, +) -> Result<(), String> { + #[cfg(windows)] + { + let hwnd = win_api::get_hwnd(&label, &app) + .ok_or_else(|| format!("窗口 {} 不存在", label))?; + win_api::set_bounds(hwnd, x, y, w, h); + } + Ok(()) +} + /// 启动原生拖动（右键长按触发） /// /// 同步关闭点击穿透（WS_EX_TRANSPARENT），然后在独立线程中调用 diff --git a/src-tauri/src/quickpanel/commands.rs b/src-tauri/src/quickpanel/commands.rs index 9d32d49..91edc26 100644 --- a/src-tauri/src/quickpanel/commands.rs +++ b/src-tauri/src/quickpanel/commands.rs @@ -1,6 +1,6 @@ //! Tauri 命令：快速面板模块 -use tauri::{AppHandle, Manager}; +use tauri::{AppHandle, Emitter, Manager}; use super::popup::{self, QuickPanelSettings}; use super::{file_index, app_scanner, icon_extractor}; @@ -22,14 +22,17 @@ pub async fn quickpanel_get_settings(app: AppHandle) -> Result Result<(), String> { - let prev_shortcut = popup::load_settings(&app).shortcut; + let prev = popup::load_settings(&app); + let prev_shortcut = prev.shortcut.clone(); + let dirs_changed = prev.index_dirs != settings.index_dirs; popup::save_settings(&app, &settings)?; // 快捷键变化时重新注册（共享工具模块，原子化 + 冲突检测） if settings.shortcut != prev_shortcut { @@ -41,6 +44,10 @@ pub async fn quickpanel_save_settings( popup::ensure_window(&app); } } + // 索引目录变更：闲时自动重建（新增/移除路径后无需手动点"构建索引"） + if dirs_changed { + schedule_auto_build(app, true); + } Ok(()) } @@ -125,33 +132,98 @@ pub fn quickpanel_lock_screen() -> Result<(), String> { Ok(()) } +/// 闲时自动建立索引的启动延迟（秒）：避开应用启动/模块加载的 IO 高峰 +const AUTO_BUILD_START_DELAY: u64 = 6; +/// 判定"系统空闲"的阈值（毫秒）：用户停止输入超过该时长才执行构建 +const AUTO_BUILD_IDLE_MS: u64 = 3000; +/// 等待系统空闲的最长轮询次数（每次间隔 2s，约 60s 上限，超时后不再等待直接构建） +const AUTO_BUILD_MAX_WAIT_ITERS: u32 = 30; + +/// 解析要索引的目录：设置为空时用默认（桌面/文档/下载） +fn resolve_index_dirs(app: &AppHandle) -> Vec { + let settings = popup::load_settings(app); + if settings.index_dirs.is_empty() { + popup::QuickPanelSettings::default().index_dirs + } else { + settings.index_dirs + } +} + +/// 闲时自动建立/重建文件索引。 +/// - `force=false`：仅首次（从未构建过）自动建立 +/// - `force=true`：忽略是否已构建，直接重建（索引目录变更后调用） +/// +/// 流程：先延迟避开启动 IO 高峰，再轮询等待系统空闲（用户停止输入）， +/// 空闲后才开始构建，避免与应用运行/用户操作抢 IO 导致卡顿。 +/// 构建完成后向前端广播 `quickpanel-index-updated` 事件（负载为条目数）， +/// 供设置页刷新统计、弹窗启用文件搜索。 +fn schedule_auto_build(app: AppHandle, force: bool) { + tauri::async_runtime::spawn(async move { + // 1. 启动延迟：避开应用启动、模块加载等 IO 高峰 + tokio::time::sleep(std::time::Duration::from_secs(AUTO_BUILD_START_DELAY)).await; + // 2. 轮询等待系统空闲（判定阈值见 AUTO_BUILD_IDLE_MS） + for _ in 0..AUTO_BUILD_MAX_WAIT_ITERS { + if crate::win32_util::get_idle_time_ms() >= AUTO_BUILD_IDLE_MS { + break; + } + tokio::time::sleep(std::time::Duration::from_secs(2)).await; + } + // 3. 非强制模式：已构建过则跳过（幂等，避免每次启动重建） + if !force { + file_index::ensure_initialized(&app); + let stats = file_index::stats(); + if stats.last_built_at > 0 && !stats.last_built_dirs.is_empty() { + return; + } + } + // 4. 构建（build_index 内部有并发保护，重复调度/手动构建并发时幂等跳过） + let dirs = resolve_index_dirs(&app); + match tauri::async_runtime::spawn_blocking(move || file_index::build_index(&dirs)).await { + Ok(Ok(count)) => { + crate::logger::log_info( + "quickpanel", + &format!("闲时自动索引完成，共 {} 条", count), + ); + let _ = app.emit(crate::constants::events::QUICKPANEL_INDEX_UPDATED, count); + } + _ => { + crate::logger::log_error("quickpanel", "闲时自动索引失败"); + } + } + }); +} + /// 初始化文件索引数据库（应用启动时调用）。 /// 若存在上次构建的索引（last_built_dirs 非空），自动恢复 notify 增量监听， /// 无需重建即可继续自动同步文件变更。 +/// 若从未构建过（首次运行），闲时自动建立索引，无需用户手动点"构建索引"。 #[tauri::command] #[specta::specta] pub async fn quickpanel_init_file_index(app: AppHandle) -> Result<(), String> { - tauri::async_runtime::spawn_blocking(move || { - file_index::init(&app); + let app_for_build = app.clone(); + let need_auto_build = tauri::async_runtime::spawn_blocking(move || { + file_index::init(&app_for_build); let stats = file_index::stats(); if stats.last_built_at > 0 && !stats.last_built_dirs.is_empty() { file_index::start_watcher(&stats.last_built_dirs); } + // 从未构建过索引 → 需要闲时自动建立 + stats.last_built_at == 0 || stats.last_built_dirs.is_empty() }) .await - .map_err(|e| format!("索引初始化任务失败: {}", e)) + .map_err(|e| format!("索引初始化任务失败: {}", e))?; + + if need_auto_build { + schedule_auto_build(app, false); + } + Ok(()) } /// 构建文件索引（全量重建，阻塞操作建议在 spawn_blocking 调用） #[tauri::command] #[specta::specta] pub async fn quickpanel_build_file_index(app: AppHandle) -> Result { - let settings = popup::load_settings(&app); - let dirs = if settings.index_dirs.is_empty() { - popup::QuickPanelSettings::default().index_dirs - } else { - settings.index_dirs - }; + let dirs = resolve_index_dirs(&app); // 懒加载：首次构建时自动初始化 DB 连接 file_index::ensure_initialized(&app); // 阻塞操作放到 spawn_blocking diff --git a/src-tauri/src/quickpanel/file_index.rs b/src-tauri/src/quickpanel/file_index.rs index ff735e4..925398e 100644 --- a/src-tauri/src/quickpanel/file_index.rs +++ b/src-tauri/src/quickpanel/file_index.rs @@ -6,6 +6,7 @@ use std::path::{Path, PathBuf}; use std::sync::Mutex; +use std::sync::atomic::{AtomicBool, Ordering}; use std::time::UNIX_EPOCH; use rusqlite::{params, Connection}; @@ -118,10 +119,37 @@ where None } +/// 构建锁：防止手动构建与闲时自动构建并发执行（全量重建含 DELETE+INSERT， +/// 两个构建交错会互相清空对方刚写入的数据，导致索引残缺）。 +static BUILDING: AtomicBool = AtomicBool::new(false); + +/// 尝试开始构建；已在构建中则返回 false。 +pub fn try_begin_build() -> bool { + BUILDING + .compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst) + .is_ok() +} + +/// 构建结束（成功/失败）后调用，释放构建锁。 +pub fn end_build() { + BUILDING.store(false, Ordering::SeqCst); +} + /// 遍历指定目录列表建立索引（全量重建）。 /// 返回索引条目数。在 spawn_blocking 中调用。 /// 重建完成后自动启动 notify 监听器做增量更新。 +/// 若已有构建正在进行（手动/自动并发），直接返回 Ok(0)，由进行中的构建负责更新索引。 pub fn build_index(dirs: &[String]) -> Result { + if !try_begin_build() { + crate::logger::log_info("quickpanel", "索引构建已在进行中，跳过本次请求"); + return Ok(0); + } + let result = build_index_inner(dirs); + end_build(); + result +} + +fn build_index_inner(dirs: &[String]) -> Result { // 清空旧数据 let cleared = with_conn(|conn| { conn.execute("DELETE FROM files", []).ok() diff --git a/src-tauri/src/quickpanel/popup.rs b/src-tauri/src/quickpanel/popup.rs index 8c5d9e1..f4d0662 100644 --- a/src-tauri/src/quickpanel/popup.rs +++ b/src-tauri/src/quickpanel/popup.rs @@ -13,6 +13,7 @@ use std::sync::Mutex; use std::sync::atomic::{AtomicBool, Ordering}; use std::path::PathBuf; +use std::time::{Duration, Instant}; use serde::{Deserialize, Serialize}; use tauri::{AppHandle, Emitter, Manager, WebviewUrl, WebviewWindowBuilder}; @@ -57,6 +58,48 @@ static POPUP_PENDING_SHOW: AtomicBool = AtomicBool::new(false); /// 避免窗口重建后仍停留在屏幕外 (-10000, -10000)。 static PENDING_POS: Mutex> = Mutex::new(None); +/// 失焦隐藏的宽限期：show 后窗口激活期间焦点可能短暂弹跳（透明 + focus:false 的 +/// WebView2 窗口在透明激活时尤其容易出现），导致 Focused(false) 紧跟在 show 之后 +/// 触发并把刚显示的窗口立即隐藏。距上次 show 不足该时长的失焦事件直接忽略。 +const SHOW_GRACE: Duration = Duration::from_millis(500); + +/// 最近一次 show 的时间，用于失焦宽限期判断。 +static LAST_SHOWN: Mutex> = Mutex::new(None); + +/// 标记"已发起显示"，并记录时间供失焦宽限期使用。 +fn mark_shown() { + if let Ok(mut t) = LAST_SHOWN.lock() { + *t = Some(Instant::now()); + } +} + +/// 判断距上次 show 是否仍在宽限期内（是则忽略失焦自动隐藏）。 +fn within_show_grace() -> bool { + LAST_SHOWN + .lock() + .ok() + .and_then(|t| *t) + .map(|t| t.elapsed() < SHOW_GRACE) + .unwrap_or(false) +} + +/// 显示窗口并确保其到达前台。 +/// set_focus 受 Windows 前台锁定限制，可能静默失败；此时用 win32_util::force_foreground +/// （模拟 Alt 释放重置前台锁定 + SetForegroundWindow + BringWindowToTop）兜底。 +fn show_and_focus(win: &tauri::WebviewWindow) { + if let Err(e) = win.show() { + crate::logger::log_error("quickpanel", &format!("show popup failed: {}", e)); + } + mark_shown(); + let focused = win.set_focus(); + if focused.is_err() { + // set_focus 被前台锁定拒绝时，退回到强制置前（与主窗口焦点命令同法） + if let Ok(hwnd) = win.hwnd() { + crate::win32_util::force_foreground(hwnd.0 as isize); + } + } +} + /// 自定义命令 #[derive(Clone, Serialize, Deserialize, Type)] #[serde(rename_all = "camelCase")] @@ -184,10 +227,14 @@ fn create_popup_window(app: &AppHandle) { }; // 监听窗口失焦：自动隐藏 + // 距上次 show 不足宽限期（激活中焦点弹跳）的失焦事件忽略，避免弹窗刚显示就被隐藏 let app_handle = app.clone(); let win_handle = win.clone(); win.on_window_event(move |event| { if let tauri::WindowEvent::Focused(false) = event { + if within_show_grace() { + return; + } let _ = win_handle.hide(); let _ = app_handle.emit(crate::constants::events::QUICKPANEL_HIDE, ()); } @@ -209,6 +256,7 @@ pub fn ensure_window(app: &AppHandle) { /// popup_position = "cursor" 时在鼠标位置附近显示，否则在鼠标所在显示器中央显示。 /// 窗口不存在则创建（隐藏状态，等前端挂载后调用 show_window 显示）。 pub fn show_popup(app: &AppHandle) { + crate::logger::log_info("quickpanel", "show_popup triggered"); let settings = load_settings(app); let cursor_mode = settings.popup_position == "cursor"; @@ -253,8 +301,7 @@ pub fn show_popup(app: &AppHandle) { x: x as i32, y: y as i32, })); - let _ = win.show(); - let _ = win.set_focus(); + show_and_focus(&win); return; } @@ -267,12 +314,24 @@ pub fn show_popup(app: &AppHandle) { } /// 显示已创建的弹窗窗口（由前端 onMounted 后调用）。 -/// 预创建路径下前端 onMounted 也会调用此函数，但 POPUP_PENDING_SHOW 为 false 时直接跳过， -/// 避免应用启动时弹窗自动弹出。仅 show_popup 兜底创建路径才真正显示。 +/// +/// 两个路径： +/// 1. 预创建路径（POPUP_PENDING_SHOW = false）：show_popup 已调用 show_and_focus 显示窗口， +/// 但若 Vue 尚未挂载，quickpanel-show 事件可能丢失。检查窗口是否可见，若可见则重新发送事件。 +/// 2. 兜底创建路径（POPUP_PENDING_SHOW = true）：窗口尚未显示，位置为 PENDING_POS， +/// 先定位再发事件最后显示+聚焦。 pub fn show_window(app: &AppHandle) { if !POPUP_PENDING_SHOW.swap(false, Ordering::SeqCst) { + // 预创建路径：窗口已由 show_popup 显示，但事件可能因前端未挂载而丢失。 + // 窗口可见时重新发送事件，让刚注册的监听器处理（清空输入、聚焦、刷新等）。 + if let Some(win) = app.get_webview_window(POPUP_LABEL) { + if win.is_visible().unwrap_or(false) { + emit_show(app); + } + } return; } + // 兜底创建路径：show_popup 兜底重建，窗口尚未显示 if let Some(win) = app.get_webview_window(POPUP_LABEL) { // 应用 show_popup 计算的兜底位置（物理坐标），避免停留在屏幕外 let pos = PENDING_POS.lock().ok().and_then(|p| *p); @@ -284,8 +343,7 @@ pub fn show_window(app: &AppHandle) { } // 同样先检测 Explorer 目录再显示，避免面板抢焦点导致检测失败。 emit_show(app); - let _ = win.show(); - let _ = win.set_focus(); + show_and_focus(&win); } } diff --git a/src-tauri/src/screenshot/capture.rs b/src-tauri/src/screenshot/capture.rs index 0ce2755..c38223d 100644 --- a/src-tauri/src/screenshot/capture.rs +++ b/src-tauri/src/screenshot/capture.rs @@ -3,7 +3,8 @@ //! 实现： //! - 全屏（虚拟屏）捕获：BitBlt 从屏幕 DC 拷贝到兼容位图，GetDIBits 取像素 //! - 窗口捕获：PrintWindow(PW_RENDERFULLCONTENT) 捕获 DWM 内容（覆盖硬件加速窗口） -//! - 窗口拾取：EnumWindows 按 Z 序命中测试（排除本进程窗口，避免命中覆盖层自身） +//! - 窗口拾取：pick_windows 枚举 Z 序窗口列表（排除本进程，避免命中覆盖层自身）， +//! 前端缓存列表后本地命中测试 //! - 顶层窗口枚举：EnumWindows //! - 像素 → PNG / CF_DIB 转换 //! @@ -276,18 +277,16 @@ pub fn capture_window(hwnd: isize) -> Result { } } -/// 获取指定屏幕坐标下的顶层窗口（窗口拾取） +/// 枚举可拾取的顶层窗口（Z 序顶→底） /// -/// 入参 x/y 为物理屏幕坐标（前端需按显示器 scaleFactor 从逻辑坐标换算）。 -/// -/// 不能直接用 WindowFromPoint：覆盖层是 alwaysOnTop 全屏窗口，会命中覆盖层自身。 -/// 改为 EnumWindows 按 Z 序（顶→底）枚举顶层窗口做命中测试，并排除本进程 -/// （覆盖层/主窗口/编辑器）的窗口，从而取到覆盖层下面的目标窗口。 -pub fn window_from_point(x: i32, y: i32) -> Option { +/// 与逐点拾取同语义：排除本进程窗口（覆盖层/主窗口/编辑器）、不可见窗口、工具窗口。 +/// 前端在截图开始时缓存该列表，鼠标移动时在 JS 侧做命中测试（rect 包含点，取 Z 序 +/// 最顶的第一个命中），消除逐帧 window_from_point 的 IPC 往返；且列表与冻结底图 +/// 同一时刻生成，命中结果与画面严格一致。 +pub fn pick_windows() -> Vec { struct PickContext { my_pid: u32, - pt: POINT, - found: Option, + out: Vec, } extern "system" fn enum_proc(hwnd: HWND, lparam: isize) -> i32 { @@ -311,30 +310,24 @@ pub fn window_from_point(x: i32, y: i32) -> Option { if GetWindowRect(hwnd, &mut rect) == 0 { return 1; } - // 命中测试（物理坐标），Z 序最顶层的第一个命中即为目标 - let pt = ctx.pt; - if pt.x >= rect.left && pt.x < rect.right && pt.y >= rect.top && pt.y < rect.bottom { - ctx.found = Some(WindowInfo { - hwnd, - title: get_window_title(hwnd), - rect: ScreenRect::from(rect), - visual_rect: extended_frame_bounds(hwnd), - }); - return 0; // 停止枚举 - } + ctx.out.push(WindowInfo { + hwnd, + title: get_window_title(hwnd), + rect: ScreenRect::from(rect), + visual_rect: extended_frame_bounds(hwnd), + }); } 1 } let mut ctx = PickContext { my_pid: std::process::id(), - pt: POINT { x, y }, - found: None, + out: Vec::new(), }; unsafe { EnumWindows(Some(enum_proc), &mut ctx as *mut _ as isize); } - ctx.found + ctx.out } /// 获取当前鼠标物理屏幕坐标（覆盖层打开时定位初始悬停窗口） diff --git a/src-tauri/src/screenshot/commands.rs b/src-tauri/src/screenshot/commands.rs index ecc19ec..3a250fb 100644 --- a/src-tauri/src/screenshot/commands.rs +++ b/src-tauri/src/screenshot/commands.rs @@ -1,12 +1,13 @@ //! Tauri 命令：截图模块 //! //! 命令清单： -//! - screenshot_capture_fullscreen：捕获虚拟屏并存入静态（不做 PNG 编码） +//! - screenshot_capture_fullscreen：捕获虚拟屏并存入静态（不做 PNG 编码），返回捕获时刻光标坐标 //! - screenshot_get_fullscreen_bmp：取出全屏捕获的 BMP 原始字节（raw IPC，覆盖层显示用，不移除） //! - screenshot_fullscreen_png：全屏捕获编码 PNG base64 并清除（全屏截图进编辑器用） //! - screenshot_clear_fullscreen：清除静态全屏捕获（覆盖层关闭时） //! - screenshot_crop_stored：按物理像素裁剪已存储的全屏捕获 -//! - screenshot_window_from_point：拾取指定屏幕坐标下的顶层窗口 +//! - screenshot_pick_list：枚举可拾取顶层窗口（Z 序，前端缓存后本地命中测试） +//! - screenshot_show_overlay：一次 IPC 完成覆盖层 show + focus（关键路径减少往返） //! - screenshot_enum_windows：枚举可见顶层窗口 //! - screenshot_capture_window：按 hwnd 捕获指定窗口 //! - screenshot_set_editor_image / screenshot_get_editor_image：编辑器图片传递 @@ -14,7 +15,7 @@ //! - screenshot_save_png：写入文件 //! - screenshot_disable_transitions：禁用窗口显示/隐藏过渡动画（消除覆盖层缩放动画） -use super::{CaptureData, WindowInfo}; +use super::{CaptureData, CaptureStart, WindowInfo}; use tauri::{Emitter, Manager}; /// 禁用指定窗口（按 label 查找）的显示/隐藏过渡动画，消除覆盖层出现/消失时的缩放动画 @@ -88,16 +89,19 @@ pub async fn screenshot_unregister_pin_shortcut(app: tauri::AppHandle) -> Result Ok(()) } -/// 捕获整个虚拟屏（多显示器拼接）存入静态，不做 PNG 编码 +/// 捕获整个虚拟屏（多显示器拼接）存入静态，不做 PNG 编码。 +/// 同时返回捕获时刻的光标物理坐标（覆盖层据此做初始窗口拾取，省一次 IPC 往返）。 #[tauri::command] #[specta::specta] -pub async fn screenshot_capture_fullscreen() -> Result<(), String> { +pub async fn screenshot_capture_fullscreen() -> Result { #[cfg(windows)] { // 屏幕捕获涉及 GDI 调用，放线程池避免阻塞 async 调度 tauri::async_runtime::spawn_blocking(|| { let img = super::capture::capture_virtual_screen()?; - super::capture::store_fullscreen(img) + super::capture::store_fullscreen(img)?; + let (cursor_x, cursor_y) = super::capture::cursor_pos().unwrap_or((0, 0)); + Ok(CaptureStart { cursor_x, cursor_y }) }) .await .map_err(|e| format!("捕获任务失败: {}", e))? @@ -205,29 +209,39 @@ pub async fn screenshot_crop_copy_stored( } } -/// 拾取指定物理屏幕坐标下的顶层窗口 +/// 枚举可拾取的顶层窗口（Z 序顶→底，排除本进程/不可见/工具窗口）。 +/// 前端在截图开始时缓存列表，鼠标移动时在 JS 侧本地命中测试，消除逐帧 IPC 往返。 #[tauri::command] #[specta::specta] -pub async fn screenshot_window_from_point( - x: i32, - y: i32, -) -> Result, String> { +pub async fn screenshot_pick_list() -> Result, String> { #[cfg(windows)] { - tauri::async_runtime::spawn_blocking(move || { - Ok(super::capture::window_from_point(x, y)) - }) - .await - .map_err(|e| format!("查询失败: {}", e))? + tauri::async_runtime::spawn_blocking(super::capture::pick_windows) + .await + .map_err(|e| format!("枚举失败: {}", e)) } #[cfg(not(windows))] { - let _ = (x, y); - Ok(None) + Ok(vec![]) } } -/// 获取当前鼠标物理屏幕坐标（覆盖层打开时定位初始悬停窗口） +/// 一次 IPC 完成指定窗口的显示与聚焦（截图覆盖层显示关键路径，减少串行往返） +#[tauri::command] +#[specta::specta] +pub async fn screenshot_show_overlay( + app: tauri::AppHandle, + label: String, +) -> Result<(), String> { + let win = app + .get_webview_window(&label) + .ok_or_else(|| format!("窗口不存在: {}", label))?; + win.show().map_err(|e| format!("显示窗口失败: {}", e))?; + win.set_focus().map_err(|e| format!("聚焦窗口失败: {}", e))?; + Ok(()) +} + +/// 获取当前鼠标物理屏幕坐标（贴图窗口拖动跟随等场景使用） #[tauri::command] #[specta::specta] pub async fn screenshot_cursor_pos() -> Result<(i32, i32), String> { @@ -433,6 +447,22 @@ pub async fn screenshot_load_cache( .map_err(|e| format!("读取缓存任务失败: {}", e))? } +/// 读取历史缓存 PNG 原始字节（raw IPC → 前端 ArrayBuffer，贴图窗口显示用： +/// 跳过 base64 编码，IPC 传输与前端内存占用均省 ~33%；同 get_fullscreen_bmp 豁免 specta） +#[tauri::command] +pub async fn screenshot_load_cache_raw( + app: tauri::AppHandle, + path: String, +) -> Result { + 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))?; + Ok(tauri::ipc::Response::new(bytes)) + }) + .await + .map_err(|e| format!("读取缓存任务失败: {}", e))? +} + /// 删除历史缓存文件（历史项移除/清空时调用，静默忽略不存在文件） #[tauri::command] #[specta::specta] diff --git a/src-tauri/src/screenshot/mod.rs b/src-tauri/src/screenshot/mod.rs index 0ce9bc5..3cbb41b 100644 --- a/src-tauri/src/screenshot/mod.rs +++ b/src-tauri/src/screenshot/mod.rs @@ -20,6 +20,14 @@ pub struct CaptureData { pub height: i32, } +/// 截图启动信息：捕获时刻的光标物理坐标（覆盖层据此做初始窗口拾取，省一次 IPC 往返） +#[derive(serde::Serialize, Type)] +#[serde(rename_all = "camelCase")] +pub struct CaptureStart { + pub cursor_x: i32, + pub cursor_y: i32, +} + /// 窗口信息（窗口拾取 / 枚举） #[derive(serde::Serialize, Type)] #[serde(rename_all = "camelCase")] diff --git a/src-tauri/src/setup.rs b/src-tauri/src/setup.rs index b747e93..386eea1 100644 --- a/src-tauri/src/setup.rs +++ b/src-tauri/src/setup.rs @@ -88,6 +88,8 @@ pub fn init(app: &mut App) -> Result<(), Box> { } // 预创建弹窗窗口（隐藏），首次按快捷键时直接 show，避免首次创建时序问题 crate::clipboard::popup::ensure_popup_window(&app_handle); + // 同时预创建独立预览窗口（隐藏），弹窗悬停条目时直接显示 + crate::clipboard::popup::ensure_preview_window(&app_handle); } app.manage(clipboard); @@ -116,6 +118,9 @@ pub fn init(app: &mut App) -> Result<(), Box> { // ===== 进程监控线程 ===== start_monitoring_thread(app.handle().clone()); + // ===== 代理：自动切换节点后台调度（独立于模块激活状态） ===== + crate::mihomo_manager::start_auto_switch_loop(app.handle().clone()); + // ===== 自动启动（随应用启动，不依赖模块启用） ===== // mihomo：用户在设置中开启"自动启动"时随应用启动 if let Some(mihomo) = app.try_state::() { diff --git a/src-tauri/src/tray_menu.rs b/src-tauri/src/tray_menu.rs index a2ef9bb..be8d044 100644 --- a/src-tauri/src/tray_menu.rs +++ b/src-tauri/src/tray_menu.rs @@ -308,21 +308,26 @@ pub fn show_tray_menu(app: &AppHandle, cursor_pos: (f64, f64)) { precreate_tray_menu_window(app); } - // 发送状态给前端（前端测量内容高度后调用 tray_menu_ready 显示窗口）。 - // 代理节点拉取默认最长 10s；这里用 1.5s 短超时兜底，避免 mihomo API 卡死时 - // 菜单迟迟不出现（超时则退回基础状态，节点区留空，后续 refresh 可补）。 + // 1) 立即发送基础状态（不含代理节点，纯本地查询），菜单秒开—— + // 前端测量内容高度后调用 tray_menu_ready 显示窗口。 + let base = get_base_tray_state(app); + let _ = app.emit(crate::constants::events::TRAY_MENU_SHOW, base); + + // 2) 异步拉取完整状态（含 mihomo /proxies 节点），到达后经 TRAY_MENU_STATE_UPDATED + // 补充给前端（前端在窗口可见时重新测量调整尺寸）。 + // mihomo API 慢/挂起时不再阻塞菜单显示；超时 5s 放弃（保持基础状态）。 let app_clone = app.clone(); tauri::async_runtime::spawn(async move { let state = match tokio::time::timeout( - Duration::from_millis(1500), + Duration::from_millis(5000), get_full_tray_state(&app_clone), ) .await { Ok(s) => s, - Err(_) => get_base_tray_state(&app_clone), + Err(_) => return, }; - let _ = app_clone.emit(crate::constants::events::TRAY_MENU_SHOW, state); + let _ = app_clone.emit(crate::constants::events::TRAY_MENU_STATE_UPDATED, state); }); } @@ -432,9 +437,20 @@ pub async fn tray_menu_action( _ => {} } - // 刷新状态并发送给前端（quit 除外，quit 后进程已退出） - if action != "quit" { - refresh_and_emit_state(&app).await; + // 按动作类型选择性刷新，避免无关动作（OSD 开关/跳转设置）也全量请求 mihomo API： + // - 代理相关动作：全量刷新（节点列表/延迟可能已变化） + // - Kernel/OSD：仅刷新本地基础状态（monitor 运行状态） + // - 跳转/退出：不刷新（quit 后进程已退出） + match action.as_str() { + "proxy_enable" | "proxy_disable" | "proxy_refresh" | "proxy_select_node" + | "system_proxy_toggle" => { + refresh_and_emit_state(&app).await; + } + "kernel_restart" | "osd_toggle" => { + let state = get_base_tray_state(&app); + let _ = app.emit(crate::constants::events::TRAY_MENU_STATE_UPDATED, state); + } + _ => {} } Ok(()) @@ -480,6 +496,12 @@ pub async fn tray_menu_ready(content_height: f64, app: AppHandle) -> Result<(), y: y as i32, }); let _ = win.set_position(pos); + // 以实际显示时刻重置失焦防抖起点：右键到此处可能间隔较久（前端测量 + 基础状态）， + // 若沿用右键时刻，WebView2 显示瞬间的焦点抖动会被误判为失焦而立即隐藏菜单。 + { + let mut t = LAST_SHOW_TIME.lock().unwrap_or_else(|e| e.into_inner()); + *t = Some(Instant::now()); + } let _ = win.show(); let _ = win.set_focus(); @@ -510,33 +532,57 @@ async fn enable_proxy(app: &AppHandle) -> Result<(), String> { } } - // 2. 获取节点列表 - let proxies = mihomo.get_proxies().await?; - let (group, nodes, _now) = parse_main_group(&proxies) - .ok_or_else(|| "无法解析代理组".to_string())?; + // 2. 获取节点并择优：遵循自动切换的目标组与地区筛选（关闭自动切换时退化为主组 + 全量节点） + let settings = mihomo.load_settings(); - if !nodes.is_empty() { - // 3. 并行测试所有节点延迟 - let best = test_and_select_best(&mihomo, &group, &nodes).await; - - // 4. 发送通知 - match &best { - Some((name, delay)) => { - send_notification( - app, - "代理已开启", - &format!("当前节点: {} ({}ms)", name, delay), - ); + match crate::mihomo_manager::pick_best(&mihomo, &settings).await { + Ok(Some((group, name, delay, now))) => { + // 与自动切换一样，仅当当前节点不是最优时才切换 + if name != now { + let _ = mihomo.select_proxy(&group, &name).await; } - None => { - send_notification(app, "代理已开启", "所有节点均超时，未自动选择"); + send_notification(app, "代理已开启", &format!("当前节点: {} ({}ms)", name, delay)); + } + Ok(None) | Err(_) => { + // 区分「无可用节点」与「全部超时」两种情况 + let unavailable = { + let proxies = mihomo.get_proxies().await.ok(); + let group_name: Option = if !settings.auto_switch_group.is_empty() { + Some(settings.auto_switch_group.clone()) + } else { + proxies + .as_ref() + .and_then(|p| p.get("proxies")) + .and_then(|m| m.as_object()) + .and_then(|map| { + let mut names = map.iter().filter(|(_, v)| { + v.get("type").and_then(|t| t.as_str()) == Some("Selector") + }); + names.next().map(|(n, _)| n.clone()) + }) + }; + let empty = group_name.map(|g| { + proxies + .as_ref() + .and_then(|p| p.get("proxies")) + .and_then(|m| m.as_object()) + .and_then(|map| map.get(&g)) + .and_then(|v| v.get("all")) + .and_then(|v| v.as_array()) + .map(|a| a.is_empty()) + .unwrap_or(true) + }).unwrap_or(true); + empty + }; + if unavailable { + send_notification(app, "代理已开启", "无可用节点"); + } else { + send_notification(app, "代理已开启", "所有候选节点均超时，未自动选择"); } } - } else { - send_notification(app, "代理已开启", "无可用节点"); } - // 5. 开启系统代理 + // 3. 开启系统代理 mihomo.enable_system_proxy()?; Ok(()) @@ -559,40 +605,6 @@ async fn disable_proxy(app: &AppHandle) -> Result<(), String> { // ===== 择优选择节点 ===== -/// 并行测试所有节点延迟，选择最低延迟节点 -async fn test_and_select_best( - mihomo: &MihomoManager, - group: &str, - nodes: &[String], -) -> Option<(String, u32)> { - use futures_util::future::join_all; - - let futures: Vec<_> = nodes - .iter() - .map(|name| async move { - let delay = mihomo - .test_delay(name, "https://www.gstatic.com/generate_204", 5000) - .await - .ok(); - (name.clone(), delay) - }) - .collect(); - - let results = join_all(futures).await; - - let best = results - .into_iter() - .filter_map(|(name, delay)| delay.map(|d| (name, d))) - .filter(|(_, d)| *d > 0) - .min_by_key(|(_, d)| *d); - - if let Some((ref name, _)) = best { - let _ = mihomo.select_proxy(group, name).await; - } - - best -} - /// 并行测试所有节点延迟（更新 mihomo 内部 history） async fn test_all_delays(app: &AppHandle) { let mihomo = app.state::(); diff --git a/src-tauri/src/updater/mod.rs b/src-tauri/src/updater/mod.rs index 3d675dd..c2d1356 100644 --- a/src-tauri/src/updater/mod.rs +++ b/src-tauri/src/updater/mod.rs @@ -129,11 +129,18 @@ async fn fetch_latest_release() -> Result { /// 下载文件到 dest，期间通过 UPDATE_PROGRESS 事件上报进度 async fn download_with_progress(app: &AppHandle, url: &str, dest: &Path) -> Result<(), String> { - let client = reqwest::Client::new(); + // 注意：reqwest 的 timeout 是"从连接到响应体读完"的总超时。大文件（如 + // thing.exe 10+MB）在慢速网络下 30s 内读不完会被掐断流导致下载到一半失败 + // （此前 bug：更新包总在 ~50% 处中断）。这里只限制连接建立 15s， + // 总超时放宽到 10 分钟兜底防止永久悬挂。 + let client = reqwest::Client::builder() + .connect_timeout(std::time::Duration::from_secs(15)) + .timeout(std::time::Duration::from_secs(600)) + .build() + .map_err(|e| format!("创建 HTTP 客户端失败: {}", e))?; let resp = client .get(url) .header("User-Agent", "thing-app") - .timeout(std::time::Duration::from_secs(30)) .send() .await .map_err(|e| format!("下载请求失败: {}", e))?; @@ -324,34 +331,31 @@ pub async fn update_check(app: AppHandle) -> Result { }) } -/// 更新应用本体。 -/// 便携版：下载 thing_{v}_x64.exe → update.bat 覆盖重启； -/// 安装版：下载 thing_{v}_x64-setup.exe → 提权静默安装 /S。 -/// 下载进度通过 UPDATE_PROGRESS 事件上报，调用方返回前会触发应用退出。 +/// 更新应用本体（安装阶段）。下载由前端下载模块完成，本命令接收已下载的 +/// 安装包路径（便携版 thing_{v}_x64.exe / 安装版 thing_{v}_x64-setup.exe）。 +/// 便携版：copy 到临时目录 → update.bat 覆盖重启； +/// 安装版：copy 到临时目录 → 提权静默安装 /S。 +/// 调用返回前会触发应用退出。 #[tauri::command] #[specta::specta] -pub async fn update_install(app: AppHandle) -> Result<(), String> { - let latest = fetch_latest_release().await?; +pub async fn update_install(app: AppHandle, downloaded_path: String) -> Result<(), String> { + let src = PathBuf::from(&downloaded_path); + if !src.exists() { + return Err(format!("下载文件不存在: {}", downloaded_path)); + } let installed = is_installed_version(); - let (target_name, target_url) = if installed { - latest - .assets - .iter() - .find(|a| a.name.ends_with("-setup.exe")) - .map(|a| (a.name.clone(), a.browser_download_url.clone())) - .ok_or("未在 release 中找到安装包 (setup.exe)".to_string())? - } else { - latest - .assets - .iter() - .find(|a| a.name.ends_with(".exe") && !a.name.contains("setup")) - .map(|a| (a.name.clone(), a.browser_download_url.clone())) - .ok_or("未在 release 中找到便携版程序 (thing.exe)".to_string())? - }; + // copy 到临时目录：与 update.bat / 安装器解耦，随后即可删除下载目录中的源文件 let temp_dir = std::env::temp_dir().join("thing-update"); fs::create_dir_all(&temp_dir).map_err(|e| format!("创建临时目录失败: {}", e))?; - let dest = temp_dir.join(&target_name); - download_with_progress(&app, &target_url, &dest).await?; + let file_name = src + .file_name() + .map(|n| n.to_string_lossy().to_string()) + .unwrap_or_else(|| "thing_update.exe".into()); + let dest = temp_dir.join(&file_name); + fs::copy(&src, &dest).map_err(|e| format!("复制安装包到临时目录失败: {}", e))?; + // 临时副本就绪后清理下载目录中的源文件（失败不影响更新流程） + let _ = fs::remove_file(&src); + let _ = app.emit( UPDATE_PROGRESS, UpdateProgress { @@ -377,6 +381,24 @@ pub async fn update_install(app: AppHandle) -> Result<(), String> { #[tauri::command] #[specta::specta] pub async fn update_thinghk(app: AppHandle) -> Result<(), String> { + let result = update_thinghk_inner(&app).await; + if let Err(ref e) = result { + // 失败时 emit error 阶段，避免前端进度卡在最后状态无提示 + let _ = app.emit( + UPDATE_PROGRESS, + UpdateProgress { + stage: "error".into(), + percent: 0, + downloaded_bytes: 0, + total_bytes: None, + message: e.clone(), + }, + ); + } + result +} + +async fn update_thinghk_inner(app: &AppHandle) -> Result<(), String> { let latest = fetch_latest_release().await?; let asset = latest .assets @@ -385,7 +407,7 @@ pub async fn update_thinghk(app: AppHandle) -> Result<(), String> { .ok_or("未在 release 中找到 ThingHK 内核包".to_string())?; // 停止监控内核（含提权模式的 /shutdown 兜底由前端先停模块），避免 exe 被占用 if let Some(monitor) = app.try_state::() { - monitor.stop_subscription(&app).await; + monitor.stop_subscription(app).await; } if let Some(pm) = app.try_state::() { let _ = pm.stop("monitor"); @@ -395,7 +417,7 @@ pub async fn update_thinghk(app: AppHandle) -> Result<(), String> { let temp_dir = std::env::temp_dir().join("thing-update"); fs::create_dir_all(&temp_dir).map_err(|e| format!("创建临时目录失败: {}", e))?; let zip_path = temp_dir.join(&asset.name); - download_with_progress(&app, &asset.browser_download_url, &zip_path).await?; + download_with_progress(app, &asset.browser_download_url, &zip_path).await?; let _ = app.emit( UPDATE_PROGRESS, UpdateProgress { diff --git a/src-tauri/src/win32_util.rs b/src-tauri/src/win32_util.rs index 8ddbbf9..5d40851 100644 --- a/src-tauri/src/win32_util.rs +++ b/src-tauri/src/win32_util.rs @@ -123,6 +123,97 @@ pub fn force_foreground(hwnd: isize) { } } +/// 应用 WS_EX_NOACTIVATE | WS_EX_TOOLWINDOW 扩展样式到指定窗口。 +/// 用于预览窗等不抢焦点的悬浮窗：窗口可接收鼠标交互但不激活、不进 Alt-Tab。 +#[cfg(windows)] +pub fn apply_no_activate(hwnd: isize) { + use windows_sys::Win32::UI::WindowsAndMessaging::{ + GetWindowLongPtrW, SetWindowLongPtrW, GWL_EXSTYLE, WS_EX_NOACTIVATE, WS_EX_TOOLWINDOW, + }; + unsafe { + let ex = GetWindowLongPtrW(hwnd, GWL_EXSTYLE); + let new_ex = ex | (WS_EX_NOACTIVATE as isize) | (WS_EX_TOOLWINDOW as isize); + SetWindowLongPtrW(hwnd, GWL_EXSTYLE, new_ex); + } +} + +/// 鼠标左键当前是否按下（GetAsyncKeyState，全局异步状态，无需窗口焦点）。 +/// 供看护线程轮询检测"点击外部"（配合按下沿判定）。 +#[cfg(windows)] +pub fn is_left_button_down() -> bool { + use windows_sys::Win32::UI::Input::KeyboardAndMouse::GetAsyncKeyState; + + const VK_LBUTTON: i32 = 0x01; + ((unsafe { GetAsyncKeyState(VK_LBUTTON) } as u32) & 0x8000) != 0 +} + +#[cfg(not(windows))] +pub fn is_left_button_down() -> bool { + false +} + +/// 强制窗口应用系统圆角（DWMWCP_ROUND，Win11 约 8px）。 +/// 带 WS_EX_NOACTIVATE 等扩展样式的悬浮窗系统不会自动圆角（呈现直角）， +/// 与常规弹窗外观不一致；通过 DWMWA_WINDOW_CORNER_PREFERENCE 显式指定圆角偏好。 +#[cfg(windows)] +pub fn apply_rounded_corners(hwnd: isize) { + use windows_sys::Win32::Graphics::Dwm::{ + DwmSetWindowAttribute, DWMWA_WINDOW_CORNER_PREFERENCE, DWMWCP_ROUND, + }; + + unsafe { + let pref: i32 = DWMWCP_ROUND; + let _ = DwmSetWindowAttribute( + hwnd, + DWMWA_WINDOW_CORNER_PREFERENCE as u32, + &pref as *const i32 as *const core::ffi::c_void, + std::mem::size_of::() as u32, + ); + } +} + +/// 以不激活方式显示窗口（SW_SHOWNOACTIVATE），避免抢走弹窗等前台窗口的焦点。 +#[cfg(windows)] +pub fn show_no_activate(hwnd: isize) { + use windows_sys::Win32::UI::WindowsAndMessaging::{ShowWindow, SW_SHOWNOACTIVATE}; + unsafe { + ShowWindow(hwnd, SW_SHOWNOACTIVATE); + } +} + +/// 隐藏窗口（SW_HIDE）。供以原生方式显示（SW_SHOWNOACTIVATE）的悬浮窗兜底隐藏， +/// 与 Tauri 的 hide() 并存以确保任何路径下都被可靠隐藏。 +#[cfg(windows)] +pub fn hide_window(hwnd: isize) { + use windows_sys::Win32::UI::WindowsAndMessaging::{ShowWindow, SW_HIDE}; + unsafe { + ShowWindow(hwnd, SW_HIDE); + } +} + +/// 系统自上次用户输入（鼠标/键盘）以来的空闲时长（毫秒）。 +/// 用于闲时执行耗时后台任务（如文件索引构建），避免与应用运行/用户操作抢 IO。 +/// GetLastInputInfo 的 dwTime 与 GetTickCount 同为系统启动后毫秒数，用 wrapping 减法防回绕。 +#[cfg(windows)] +pub fn get_idle_time_ms() -> u64 { + use windows_sys::Win32::System::SystemInformation::GetTickCount; + use windows_sys::Win32::UI::Input::KeyboardAndMouse::{ + GetLastInputInfo, LASTINPUTINFO, + }; + use std::mem::size_of; + + let mut lii = LASTINPUTINFO { + cbSize: size_of::() as u32, + dwTime: 0, + }; + unsafe { + if GetLastInputInfo(&mut lii) != 0 { + return GetTickCount().wrapping_sub(lii.dwTime) as u64; + } + } + 0 +} + // ===== 非 Windows 平台空实现 ===== #[cfg(not(windows))] @@ -142,3 +233,18 @@ pub fn get_monitor_bounds_at_point(_x: i32, _y: i32) -> Option<(i32, i32, i32, i #[cfg(not(windows))] pub fn force_foreground(_hwnd: isize) {} + +#[cfg(not(windows))] +pub fn apply_no_activate(_hwnd: isize) {} + +#[cfg(not(windows))] +pub fn apply_rounded_corners(_hwnd: isize) {} + +#[cfg(not(windows))] +pub fn show_no_activate(_hwnd: isize) {} + +#[cfg(not(windows))] +pub fn hide_window(_hwnd: isize) {} + +#[cfg(not(windows))] +pub fn get_idle_time_ms() -> u64 { 0 } diff --git a/src-tauri/tauri.conf.json b/src-tauri/tauri.conf.json index f0b9a1b..2630260 100644 --- a/src-tauri/tauri.conf.json +++ b/src-tauri/tauri.conf.json @@ -1,7 +1,7 @@ { "$schema": "https://schema.tauri.app/config/2", "productName": "thing", - "version": "26.8.1", + "version": "26.8.2", "identifier": "thing.lfeng.me", "build": { "beforeDevCommand": "bun run dev", @@ -19,7 +19,7 @@ "transparent": true, "visible": false, "windowEffects": { - "effects": ["acrylic", "mica"] + "effects": ["mica", "acrylic"] } } ], diff --git a/src/App.vue b/src/App.vue index 9d5e3c5..be4f537 100644 --- a/src/App.vue +++ b/src/App.vue @@ -87,6 +87,9 @@ const loadModule = async (moduleId: string) => { } const handleModuleChange = (moduleId: string) => { + // 同模块不重新加载（保留组件状态）；搜索/托盘跳转到当前模块时仅触发 tab 导航 + if (activeModule.value === moduleId) return + // 调用上一个模块的 onDeactivate 钩子 const prevConfig = moduleRegistry.getConfig(activeModule.value) prevConfig?.lifecycle?.onDeactivate?.() @@ -96,10 +99,9 @@ const handleModuleChange = (moduleId: string) => { loadModule(moduleId) } +// 搜索跳转与普通切换同路径：补齐 onDeactivate 钩子，避免旧模块资源泄漏 const handleSearch = (moduleId: string) => { - activeModule.value = moduleId - localStorage.setItem(LAST_MODULE_KEY, moduleId) - loadModule(moduleId) + handleModuleChange(moduleId) } const getFallbackModule = () => { @@ -110,14 +112,14 @@ const getFallbackModule = () => { return fallback?.id || 'settings' } -watch(() => appStore.enabledModules.length, () => { +// 按 id 列表监听（而非 length）：同时禁用一个 + 启用另一个时 length 不变，会漏检回退 +watch(() => appStore.enabledModules.map(m => m.id).join(','), () => { // 启动期间 activeModule 尚未确定，跳过 if (!activeModule.value) return const enabledIds = appStore.enabledModules.map(m => m.id) if (activeModule.value !== 'settings' && !enabledIds.includes(activeModule.value)) { const fallback = getFallbackModule() - activeModule.value = fallback - loadModule(fallback) + handleModuleChange(fallback) } // 模块启用/禁用变化时重新同步快速面板命令缓存 quickpanelStore.syncCommands() diff --git a/src/components/layout/TitleBar.vue b/src/components/layout/TitleBar.vue index de5c8c7..aee1046 100644 --- a/src/components/layout/TitleBar.vue +++ b/src/components/layout/TitleBar.vue @@ -1,5 +1,5 @@ + + + + diff --git a/src/modules/downloader/DownloaderModule.vue b/src/modules/downloader/DownloaderModule.vue index 61049e8..064c2c6 100644 --- a/src/modules/downloader/DownloaderModule.vue +++ b/src/modules/downloader/DownloaderModule.vue @@ -12,7 +12,7 @@ import { toast } from 'vue-sonner' import { open as openDialog } from '@tauri-apps/plugin-dialog' // Rust 端通过 tauri-specta 生成的命令绑定（bindings.ts） import { commands } from '@/lib/bindings' -import { useDownloaderStore, type DownloadTask, type TaskStatus, type CheckUrlResult } from '@/stores/downloaderStore' +import { useDownloaderStore, type DownloadTask, type DownloaderSettings, type TaskStatus, type CheckUrlResult } from '@/stores/downloaderStore' import { useModuleTabs } from '@/lib/use-module-tabs' import { useModuleTabsStore } from '@/stores/moduleTabsStore' import { createLogger } from '@/lib/logger' @@ -63,6 +63,18 @@ const showSecret = ref(false) // 下载设置快捷弹窗（任务页工具栏入口） const downloadSettingsOpen = ref(false) +// ===== 设置草案 ===== +// 设置页/快捷弹窗编辑的是本地草案，点击"保存"才写入 store.settings（生效值）并持久化； +// 避免未保存的编辑污染全应用读取的生效值（主页代理开关、添加任务默认值等） +const settingsDraft = ref(null) +watch( + () => store.settings, + (s) => { + settingsDraft.value = s ? { ...s } : null + }, + { immediate: true, deep: true } +) + // ===== 任务列表：筛选 / 排序 / 搜索 / 分页 ===== type StatusFilter = 'all' | TaskStatus type SortField = 'id' | 'name' | 'size' @@ -108,6 +120,12 @@ const formatSpeed = (bytesPerSec: number): string => { return `${formatSize(bytesPerSec)}/s` } +/** 总大小显示：0 表示未知大小（未探测到或服务器未返回），显示"未知"避免误导 */ +const formatTotalSize = (bytes: number): string => { + if (!bytes || bytes === 0) return '未知' + return formatSize(bytes) +} + /** 格式化剩余时间（秒）为易读形式 */ const formatEta = (seconds: number): string => { if (!isFinite(seconds) || seconds <= 0) return '' @@ -253,6 +271,8 @@ const formatTime = (ts: number): string => { // 分段详情 const segmentProgress = (seg: { completed: number; start: number; end: number }): number => { + // 未知大小段（start=0, end=0）无长度可计算进度，返回 0 避免误显示 100% + if (seg.start === 0 && seg.end === 0) return 0 const len = seg.end - seg.start + 1 if (len <= 0) return 0 return Math.min(100, Math.round((seg.completed / len) * 100)) @@ -297,6 +317,7 @@ const handleAddDownload = async () => { const checkEnabled = store.settings?.checkDuplicate ?? true if (checkEnabled) { // 逐个检查重复 + duplicateSuccessCount.value = 0 await processUrlsWithCheck(uris, dir) } else { // 直接添加 @@ -319,8 +340,8 @@ const handleAddDownload = async () => { } /** 逐个检查 URL 重复性，发现重复时弹出确认对话框 */ -async function processUrlsWithCheck(urls: string[], dir: string | undefined) { - let successCount = 0 +async function processUrlsWithCheck(urls: string[], dir: string | undefined, initialCount = 0) { + let successCount = initialCount for (let i = 0; i < urls.length; i++) { const uri = urls[i] try { @@ -345,7 +366,8 @@ async function processUrlsWithCheck(urls: string[], dir: string | undefined) { } continue } - // 发现重复：弹出确认对话框，暂停处理 + // 发现重复：先保存已成功数量，再弹出确认对话框，暂停处理 + duplicateSuccessCount.value = successCount duplicateDialogState.value = { open: true, url: uri, @@ -366,6 +388,7 @@ async function processUrlsWithCheck(urls: string[], dir: string | undefined) { } } finishAdd(successCount) + duplicateSuccessCount.value = 0 } /** 完成添加：显示提示并关闭对话框 */ @@ -387,7 +410,8 @@ const onDuplicateConfirm = async () => { const dir = addDir.value.trim() || undefined duplicateDialogState.value.open = false - let successCount = 0 + // 从累积计数开始（包含弹出本对话框之前已成功添加的数量） + let successCount = duplicateSuccessCount.value try { await store.addTask(url, undefined, dir, undefined, true) // autoRename=true successCount++ @@ -396,24 +420,28 @@ const onDuplicateConfirm = async () => { } // 继续处理剩余 URL - const remaining = pendingUrls.slice(currentIndex + 1) - for (const uri of remaining) { + for (let i = currentIndex + 1; i < pendingUrls.length; i++) { + const uri = pendingUrls[i] + let result: CheckUrlResult | null = null try { - const result = await store.checkUrl(uri, dir) - if (result.ok && result.duplicate !== 'none') { - // 又发现重复，再次弹出确认 - duplicateDialogState.value = { - open: true, - url: uri, - result, - pendingUrls, - currentIndex: pendingUrls.indexOf(uri), - } - // 已添加的成功数通过闭包传递不太方便，直接在这里 finish 后再继续 - // 简化处理：保存 successCount 到 state，下一次确认时累加 - duplicateSuccessCount.value = successCount - return + result = await store.checkUrl(uri, dir) + } catch (e) { + logger.error(`检查 ${uri} 失败: ` + e) + } + if (result && result.ok && result.duplicate !== 'none') { + // 又发现重复：保存已成功数量，再次弹出确认 + duplicateSuccessCount.value = successCount + duplicateDialogState.value = { + open: true, + url: uri, + result, + pendingUrls, + currentIndex: i, } + return + } + // 检查失败（result 为 null）或无重复：直接添加（自动重命名以防磁盘文件冲突） + try { await store.addTask(uri, undefined, dir, undefined, true) successCount++ } catch (e) { @@ -421,6 +449,7 @@ const onDuplicateConfirm = async () => { } } finishAdd(successCount) + duplicateSuccessCount.value = 0 } /** 累积的成功计数（跨多次重复确认） */ @@ -432,9 +461,9 @@ const onDuplicateSkip = () => { duplicateDialogState.value.open = false const remaining = pendingUrls.slice(currentIndex + 1) if (remaining.length > 0) { - // 继续处理剩余 URL（不添加当前这个） + // 继续处理剩余 URL（不添加当前这个），并带上此前已累积的成功数量 const dir = addDir.value.trim() || undefined - processUrlsWithCheck(remaining, dir).then(() => {}) + processUrlsWithCheck(remaining, dir, duplicateSuccessCount.value) } else { finishAdd(duplicateSuccessCount.value) duplicateSuccessCount.value = 0 @@ -472,8 +501,8 @@ const handleSelectDir = async () => { const handleSelectSettingsDir = async () => { try { const selected = await openDialog({ directory: true, multiple: false }) - if (typeof selected === 'string' && store.settings) { - await store.saveSettings({ ...store.settings, downloadDir: selected }) + if (typeof selected === 'string' && settingsDraft.value) { + await store.saveSettings({ ...settingsDraft.value, downloadDir: selected }) toast.success('下载目录已更新') } } catch (e) { @@ -483,9 +512,9 @@ const handleSelectSettingsDir = async () => { // ===== 设置保存 ===== const handleSaveSettings = async (): Promise => { - if (!store.settings) return false + if (!settingsDraft.value) return false try { - await store.saveSettings(store.settings) + await store.saveSettings({ ...settingsDraft.value }) toast.success('设置已保存') return true } catch (e) { @@ -494,6 +523,18 @@ const handleSaveSettings = async (): Promise => { } } +/** 切换代理开关并立即保存（新任务/探测立即生效，正在下载的任务不受影响） */ +const toggleProxy = async () => { + if (!store.settings) return + const next = !store.settings.useProxy + try { + await store.saveSettings({ ...store.settings, useProxy: next }) + toast.success(next ? '已启用系统代理下载' : '已切换为直连下载') + } catch (e) { + toast.error('切换失败: ' + e) + } +} + // 注册保存处理函数到标签栏 store（TitleBar 保存按钮调用） tabsStore.registerSave(handleSaveSettings) @@ -504,7 +545,8 @@ const handleDialogSave = async () => { } // ===== 扩展 ===== -const EXTENSION_STORE_URL = 'https://chromewebstore.google.com/' +// Thing Extension 已发布到 Microsoft Edge 加载项商店，暂定优先 Edge；后续如需支持 Chrome 商店再补充入口 +const EXTENSION_STORE_URL = 'https://microsoftedge.microsoft.com/addons/detail/thing-extension/fpcffdkeemoibkhldghjbkgbgbdpofbo' const handleInstallExtensionOnline = async () => { try { await commands.downloaderOpenUrl(EXTENSION_STORE_URL) @@ -529,9 +571,24 @@ const handleCopy = async (text: string, label: string) => { // ===== 生命周期 ===== +// 托盘/扩展触发的标志位：模块已挂载时由 watcher 即时消费 +// （App.vue 同模块切换不再重新挂载组件，onMounted 不会重新执行） +watch(pendingNewDownload, (v) => { + if (v) { + pendingNewDownload.value = false + addDialogOpen.value = true + } +}) +watch(pendingShowDownloadTasks, (v) => { + if (v) { + pendingShowDownloadTasks.value = false + activeTab.value = 'tasks' + } +}) + onMounted(async () => { await store.init() - // 消费托盘菜单"新建下载"标志位 + // 消费托盘菜单"新建下载"标志位（挂载前设置的场景，watcher 尚未生效） if (pendingNewDownload.value) { pendingNewDownload.value = false addDialogOpen.value = true @@ -747,7 +804,7 @@ const toggleSortOrder = () => { -
+
{ />
+ + + + + + + {{ store.settings?.useProxy ? '使用系统代理（mihomo 开启系统代理时经其转发）' : '直连模式' }} + + +
- {{ formatSize(task.completedSize) }} / {{ formatSize(task.totalSize) }} + {{ formatSize(task.completedSize) }} / {{ formatTotalSize(task.totalSize) }} @@ -987,9 +1064,9 @@ const toggleSortOrder = () => {
@@ -1005,39 +1082,39 @@ const toggleSortOrder = () => {
@@ -1047,8 +1124,8 @@ const toggleSortOrder = () => {
@@ -1058,8 +1135,19 @@ const toggleSortOrder = () => {
+ +
+
+ + 下载时尊重系统代理设置（mihomo 开启系统代理时经其转发），关闭则强制直连 +
+
@@ -1078,20 +1166,20 @@ const toggleSortOrder = () => {
@@ -1118,7 +1206,7 @@ const toggleSortOrder = () => {

Thing Extension 是一个浏览器扩展，可接管浏览器下载，将下载任务发送到内置下载引擎。 - 支持 Chrome、Edge 等基于 Chromium 的浏览器。 + 已上架 Microsoft Edge 加载项商店，暂定优先使用 Edge；同时支持其他基于 Chromium 的浏览器（需手动加载）。

@@ -1202,16 +1290,42 @@ const toggleSortOrder = () => {
-

+

- 配置说明 + 安装与认证说明

-
    -
  1. 在扩展设置中填入 API 地址：{{ store.extensionInfo?.url || 'http://127.0.0.1:16800/' }}
    2. -
  2. 若设置了认证密钥，请在扩展中填入相同的密钥
    3. -
  3. 浏览器访问 chrome://extensions（Edge 为 edge://extensions）
    4. -
  4. 开启"开发者模式"，加载已解压的扩展程序
    5. -
+
+
+

一、安装扩展

+
    +
  1. 点击上方"在线安装"，跳转至 Microsoft Edge 加载项商店安装 Thing Extension
    2. +
  2. 安装后点击浏览器工具栏右侧的拼图图标，将扩展固定到工具栏以便操作
    3. +
+
+
+

二、配置连接与认证

+
    +
  1. 打开扩展弹窗，在"服务器地址"中填入上方 API 地址：{{ store.extensionInfo?.url || 'http://127.0.0.1:16800/' }}
    2. +
  2. 若本页设置了认证密钥，请在扩展"认证密钥"中填入相同的密钥；未设置则留空
    3. +
  3. 点击"测试连接"，提示"已连接 · Thing 下载引擎"即表示认证成功
    4. +
+
+
+

三、安全提示

+
    +
  • 密钥为空时仅允许本机访问，局域网内其他设备无法调用下载引擎
    • +
  • 设置密钥可防止未授权设备向下载引擎提交任务，请妥善保管
    • +
  • 修改端口或密钥后需在"设置"中保存并重启应用，再同步更新扩展
    • +
+
+
+

四、其他 Chromium 浏览器（手动加载）

+
    +
  1. 浏览器访问 edge://extensions（Chrome 为 chrome://extensions），开启"开发者模式"
    2. +
  2. 点击"加载已解压的扩展程序"，选择扩展所在目录
    3. +
+
+
@@ -1233,15 +1347,15 @@ const toggleSortOrder = () => { -
+
@@ -1259,21 +1373,21 @@ const toggleSortOrder = () => {
@@ -1282,10 +1396,10 @@ const toggleSortOrder = () => {
@@ -1294,8 +1408,21 @@ const toggleSortOrder = () => { +
+ + +
+
+ + 关闭则强制直连 +
+
@@ -1307,8 +1434,8 @@ const toggleSortOrder = () => {
@@ -1542,7 +1669,7 @@ const toggleSortOrder = () => {
文件总大小 - {{ formatSize(detailTask.totalSize) }} + {{ formatTotalSize(detailTask.totalSize) }}
已下载 @@ -1550,7 +1677,7 @@ const toggleSortOrder = () => {
下载进度 - {{ getProgress(detailTask) }}% + {{ detailTask.totalSize ? getProgress(detailTask) + '%' : '未知' }}
当前速度 diff --git a/src/modules/monitor/MonitorModule.vue b/src/modules/monitor/MonitorModule.vue index 510c144..76dd026 100644 --- a/src/modules/monitor/MonitorModule.vue +++ b/src/modules/monitor/MonitorModule.vue @@ -5,8 +5,10 @@ import { ShieldCheck, ShieldOff, Zap, Thermometer, Clock, ChevronDown, ArrowDown, ArrowUp, Wifi, FolderOpen, Copy, ListChecks, Monitor as MonitorIcon, GripVertical, SlidersHorizontal, - Eye, EyeOff, MousePointerClick, + Eye, EyeOff, MousePointerClick, Plus, PencilLine, + CircuitBoard, BatteryFull, } from '@lucide/vue' +import type { LucideIcon } from '@lucide/vue' import { computed, onMounted, onUnmounted, ref, watch } from 'vue' import { toast } from 'vue-sonner' import { VueDraggable } from 'vue-draggable-plus' @@ -23,8 +25,10 @@ import { type AlertConfig, DEFAULT_COLOR_THEME, } from '@/stores/monitorStore' +import { STORAGE_KEYS } from '@/lib/constants' import { useModuleTabs } from '@/lib/use-module-tabs' -import { fmt, tempColor, loadColor, fmtSpeed, typeLabel, groupDisplayName, groupIcon } from './format' +import { fmt, tempColor, fmtSpeed, typeLabel, groupDisplayName, groupIcon } from './format' +import OverviewCard, { type OverviewCardView } from './OverviewCard.vue' import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card' import { Button } from '@/components/ui/button' import { Badge } from '@/components/ui/badge' @@ -193,6 +197,183 @@ const storageDrives = computed(() => { const downSpeed = computed(() => fmtSpeed(store.networkSpeed?.downloadBps ?? null)) const upSpeed = computed(() => fmtSpeed(store.networkSpeed?.uploadBps ?? null)) +// ===== 概览页卡片化布局（模板化卡片 + 自由添加/排序） ===== + +/** 概览卡片类型 id */ +type OverviewCardId = 'cpu' | 'gpu' | 'memory' | 'network' | 'storage' | 'motherboard' | 'battery' | 'psu' + +/** 卡片目录：可添加的全部硬件卡片 */ +const OVERVIEW_CARD_CATALOG: { id: OverviewCardId; name: string; desc: string; icon: LucideIcon }[] = [ + { id: 'cpu', name: 'CPU', desc: '温度 / 功耗 / 负载', icon: Cpu }, + { id: 'gpu', name: 'GPU', desc: '温度 / 功耗 / 负载', icon: Gauge }, + { id: 'memory', name: '内存', desc: '用量 / 负载', icon: MemoryStick }, + { id: 'network', name: '网络', desc: '下载 / 上传速率', icon: Wifi }, + { id: 'storage', name: '存储', desc: '各硬盘温度 / 容量 / 使用率', icon: HardDrive }, + { id: 'motherboard', name: '主板', desc: '温度 / 风扇', icon: CircuitBoard }, + { id: 'battery', name: '电池', desc: '电量 / 充放电功率', icon: BatteryFull }, + { id: 'psu', name: '电源', desc: '输出功率', icon: Zap }, +] + +const OVERVIEW_CARDS_VERSION = 1 +/** 默认显示的卡片（用户需求：cpu/gpu/内存/网络） */ +const DEFAULT_OVERVIEW_CARDS: OverviewCardId[] = ['cpu', 'gpu', 'memory', 'network'] + +/** 加载持久化的卡片列表（过滤未知 id，空则回退默认） */ +function loadOverviewCards(): OverviewCardId[] { + try { + const saved = localStorage.getItem(STORAGE_KEYS.monitorOverviewCards) + if (!saved) return [...DEFAULT_OVERVIEW_CARDS] + const parsed = JSON.parse(saved) + if (parsed?.version !== OVERVIEW_CARDS_VERSION) return [...DEFAULT_OVERVIEW_CARDS] + const ids: string[] = Array.isArray(parsed.cards) ? parsed.cards : [] + const valid = ids.filter(id => OVERVIEW_CARD_CATALOG.some(c => c.id === id)) as OverviewCardId[] + return valid.length ? valid : [...DEFAULT_OVERVIEW_CARDS] + } catch { + return [...DEFAULT_OVERVIEW_CARDS] + } +} + +/** 当前显示的卡片列表（顺序即显示顺序） */ +const overviewCards = ref(loadOverviewCards()) + +function saveOverviewCards() { + try { + localStorage.setItem(STORAGE_KEYS.monitorOverviewCards, JSON.stringify({ + version: OVERVIEW_CARDS_VERSION, + cards: overviewCards.value, + })) + } catch { /* 忽略 localStorage 写入失败 */ } +} + +/** 编辑模式：显示拖拽把手/移除按钮，启用拖拽排序 */ +const overviewEditing = ref(false) +/** 添加卡片 Popover 开关 */ +const overviewAddOpen = ref(false) + +/** 尚未添加的卡片（添加菜单内容） */ +const addableOverviewCards = computed(() => + OVERVIEW_CARD_CATALOG.filter(c => !overviewCards.value.includes(c.id)) +) + +function addOverviewCard(id: OverviewCardId) { + if (overviewCards.value.includes(id)) return + overviewCards.value.push(id) + saveOverviewCards() + overviewAddOpen.value = false +} + +function removeOverviewCard(id: string) { + overviewCards.value = overviewCards.value.filter(c => c !== id) + saveOverviewCards() +} + +/** 拖拽排序结束：持久化新顺序 */ +function onOverviewDragEnd() { + saveOverviewCards() +} + +// --- 主板/电池/电源数据提取（卡片用） --- + +/** 主板分组（motherboard 为空时回退 superio / embeddedcontroller） */ +const boardGroup = computed(() => + store.groupById['motherboard'] ?? store.groupById['superio'] ?? store.groupById['embeddedcontroller'] ?? null +) +const boardName = computed(() => boardGroup.value?.sensors[0]?.hardwareName ?? null) +const boardTemp = computed(() => + boardGroup.value?.sensors.find(s => s.type === 'temperature' && s.value != null)?.value ?? null +) +const boardFan = computed(() => + boardGroup.value?.sensors.find(s => s.type === 'fan' && s.value != null)?.value ?? null +) + +const batteryLevel = computed(() => { + const g = store.groupById['battery'] + if (!g) return null + return g.sensors.find(s => s.name === 'Battery Level' && s.type === 'level')?.value + ?? g.sensors.find(s => s.type === 'level')?.value + ?? null +}) +const batteryCharge = computed(() => store.findSensorValue('battery', { name: 'Battery Charge', type: 'power' })) +const batteryDischarge = computed(() => store.findSensorValue('battery', { name: 'Battery Discharge', type: 'power' })) +const batteryName = computed(() => store.groupById['battery']?.sensors[0]?.hardwareName ?? null) + +const psuPower = computed(() => store.findSensorValue('psu', { type: 'power' })) +const psuName = computed(() => store.groupById['psu']?.sensors[0]?.hardwareName ?? null) + +/** 构建各卡片视图数据（从上面的 computed 提取值并格式化） */ +function buildOverviewCardView(id: OverviewCardId): OverviewCardView { + switch (id) { + case 'cpu': + return { + id, title: 'CPU', icon: Cpu, subtitle: cpuModel.value, + main: { label: '封装温度', labelIcon: Thermometer, text: fmt(cpuTemp.value, 0), unit: '°C', colorClass: tempColor(cpuTemp.value) }, + subs: [{ label: '功耗', labelIcon: Zap, text: fmt(cpuPower.value, 1), unit: 'W' }], + load: { label: '总负载', value: cpuLoad.value }, + } + case 'gpu': + return { + id, title: 'GPU', icon: Gauge, subtitle: gpuModel.value, + main: { label: '核心温度', labelIcon: Thermometer, text: fmt(gpuTemp.value, 0), unit: '°C', colorClass: tempColor(gpuTemp.value) }, + subs: [{ label: '功耗', labelIcon: Zap, text: fmt(gpuPower.value, 1), unit: 'W' }], + load: { label: '3D 负载', value: gpuLoad.value }, + } + case 'memory': + return { + id, title: '内存', icon: MemoryStick, + subtitle: memTotalGB.value != null ? `${fmt(memTotalGB.value, 0)} GB` : null, + subtitleFull: memModuleModels.value.join(', ') || null, + main: { label: '已使用', labelIcon: MemoryStick, text: fmt(memUsedGB.value, 1), unit: ` / ${fmt(memTotalGB.value, 1)} GB` }, + subs: [], + load: { label: '负载', value: memLoad.value }, + } + case 'network': + return { + id, title: '网络', icon: Wifi, + main: { label: '下载', labelIcon: ArrowDown, text: downSpeed.value.value, unit: downSpeed.value.unit, colorClass: 'text-sky-500' }, + subs: [{ label: '上传', labelIcon: ArrowUp, text: upSpeed.value.value, unit: upSpeed.value.unit, colorClass: 'text-violet-500' }], + load: null, + } + case 'storage': + return { + id, title: '存储', icon: HardDrive, + subtitle: storageDrives.value.length ? `${storageDrives.value.length} 个设备` : null, + main: { label: '', text: '' }, + subs: [], + load: null, + wide: true, + } + case 'motherboard': + return { + id, title: '主板', icon: CircuitBoard, subtitle: boardName.value, + main: { label: '温度', labelIcon: Thermometer, text: fmt(boardTemp.value, 0), unit: '°C', colorClass: tempColor(boardTemp.value) }, + subs: [{ label: '风扇', text: fmt(boardFan.value, 0), unit: 'RPM' }], + load: null, + } + case 'battery': + return { + id, title: '电池', icon: BatteryFull, subtitle: batteryName.value, + main: { label: '电量', labelIcon: BatteryFull, text: fmt(batteryLevel.value, 0), unit: '%' }, + subs: [ + { label: '充电', labelIcon: Zap, text: fmt(batteryCharge.value, 1), unit: 'W' }, + { label: '放电', labelIcon: Zap, text: fmt(batteryDischarge.value, 1), unit: 'W' }, + ], + load: null, + } + case 'psu': + return { + id, title: '电源', icon: Zap, subtitle: psuName.value, + main: { label: '输出功率', labelIcon: Zap, text: fmt(psuPower.value, 1), unit: 'W' }, + subs: [], + load: null, + } + } +} + +/** 当前卡片视图列表（与 overviewCards 顺序一一对应） */ +const overviewCardViews = computed(() => + overviewCards.value.map(buildOverviewCardView) +) + // ===== 连接状态徽章 ===== const stateMeta: Record = { idle: { text: '未启动', class: 'bg-muted text-muted-foreground' }, @@ -1139,249 +1320,155 @@ watch(() => store.status?.ready, (ready, prev) => {

正在加载...

- -
- - - - - CPU - + diff --git a/src/modules/monitor/OsdWindow.vue b/src/modules/monitor/OsdWindow.vue index 31d9832..d3c4e40 100644 --- a/src/modules/monitor/OsdWindow.vue +++ b/src/modules/monitor/OsdWindow.vue @@ -77,31 +77,19 @@ interface OsdConfig { overlayY?: number | null } -interface SensorEntry { - name: string - type: string - hardwareName: string - value: number | null - unit: string -} - -interface SensorGroup { - id: string - sensors: SensorEntry[] -} - -interface SensorSnapshot { - groups: SensorGroup[] -} - interface NetworkSpeed { downloadBps: number uploadBps: number } +/** 配置通道载荷（低频：配置变化时推送） */ interface OsdStatePayload { config: OsdConfig - snapshot: SensorSnapshot | null +} + +/** 数据通道载荷（高频：仅显示项 key→value 映射 + 网速） */ +interface OsdDataPayload { + data: Record networkSpeed: NetworkSpeed | null } @@ -333,7 +321,8 @@ function fmtFixedUnit(item: OsdItem): string { // ===== 状态 ===== const config = ref(null) -const snapshot = ref(null) +/** 数据通道：显示项 key→value 映射（由主窗口每秒推送，替代全量快照） */ +const dataMap = ref>({}) const networkSpeed = ref(null) let unlistenFns: UnlistenFn[] = [] @@ -341,15 +330,7 @@ let unlistenFns: UnlistenFn[] = [] function getOsdItemValue(item: OsdItem): number | null { if (item.special === 'net-up') return networkSpeed.value?.uploadBps ?? null if (item.special === 'net-down') return networkSpeed.value?.downloadBps ?? null - if (!snapshot.value) return null - for (const g of snapshot.value.groups) { - if (g.id !== item.groupId) continue - const s = g.sensors.find(s => - s.hardwareName === item.hardwareName && s.name === item.sensorName && s.type === item.type - ) - if (s) return s.value ?? null - } - return null + return dataMap.value[item.key] ?? null } // ===== 颜色主题 ===== @@ -514,15 +495,19 @@ onMounted(async () => { console.error('[OSD] 启动置顶监视失败:', e) } - // 监听主窗口推送的 OSD 状态 - unlistenFns.push(await listen('osd-state-update', (e) => { + // 监听主窗口推送的 OSD 配置（低频通道） + unlistenFns.push(await listen(EVENTS.osdStateUpdate, (e) => { config.value = e.payload.config - snapshot.value = e.payload.snapshot - networkSpeed.value = e.payload.networkSpeed - // 数据/配置变化后重新测量尺寸 + // 配置变化（字号/布局/显示项）后重新测量尺寸 scheduleMeasure() })) + // 监听主窗口推送的 OSD 数据（高频通道：key→value 映射 + 网速） + unlistenFns.push(await listen(EVENTS.osdDataUpdate, (e) => { + dataMap.value = e.payload.data + networkSpeed.value = e.payload.networkSpeed + })) + // 监听系统 UI 覆盖事件 unlistenFns.push(await listen(EVENTS.osdSystemUiActive, async () => { await applyTopmost(false) @@ -531,6 +516,10 @@ onMounted(async () => { unlistenFns.push(await listen(EVENTS.osdSystemUiInactive, async () => { await applyTopmost(true) })) + + // 监听注册完成后，主动请求主窗口补发配置+数据 + // （数据通道不含配置；若窗口加载慢错过创建时的首推，需主动请求，否则会一直空白） + await emit(EVENTS.osdConfigRequest) }) /** 鼠标按下：仅在关闭穿透时响应左键拖动 */ @@ -652,6 +641,13 @@ onUnmounted(() => { display: inline-flex; flex-wrap: nowrap; align-items: stretch; + /* 文本永不换行：配置变更（如中英文切换）到窗口 resize 之间存在异步窗口期， + 若允许换行，中文标签（内存/网络）会在旧窗口宽度内竖排；禁止后仅临时溢出， + 随内容测量上报触发 setSize 立即恢复 */ + white-space: nowrap; + /* 不被 osd-root（100vw 旧窗口宽度）压缩：否则 getBoundingClientRect 测到的是 + 被旧窗口钳制的宽度而非真实内容宽度，上报后 setSize 不变，窗口永远无法变宽 */ + flex-shrink: 0; backdrop-filter: blur(8px); padding: 3px 4px; gap: 0; diff --git a/src/modules/monitor/OverviewCard.vue b/src/modules/monitor/OverviewCard.vue new file mode 100644 index 0000000..468b53f --- /dev/null +++ b/src/modules/monitor/OverviewCard.vue @@ -0,0 +1,179 @@ + + + diff --git a/src/modules/proxy/ProxyModule.vue b/src/modules/proxy/ProxyModule.vue index f48a323..3e8ac94 100644 --- a/src/modules/proxy/ProxyModule.vue +++ b/src/modules/proxy/ProxyModule.vue @@ -7,12 +7,14 @@ import { import { computed, onMounted, onUnmounted, ref, watch } from 'vue' import { toast } from 'vue-sonner' import { invoke } from '@tauri-apps/api/core' +import { listen, type UnlistenFn } from '@tauri-apps/api/event' import { appDataDir } from '@tauri-apps/api/path' import { revealItemInDir } from '@tauri-apps/plugin-opener' import { useProxyStore, type ProxyNode } from '@/stores/proxyStore' import { useModuleTabs } from '@/lib/use-module-tabs' import { useModuleTabsStore } from '@/stores/moduleTabsStore' import { createLogger } from '@/lib/logger' +import { EVENTS } from '@/lib/constants' import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card' import { Button } from '@/components/ui/button' import { Badge } from '@/components/ui/badge' @@ -66,7 +68,14 @@ const onConfirmCancel = () => { confirmState.value.resolve?.(false) } const onConfirmOpenChange = (open: boolean) => { - if (!open) onConfirmCancel() + // reka-ui 的 AlertDialogAction/Cancel 点击时会先触发 update:open(false)（自动关闭）， + // 再触发各自的 @click。若关闭事件立即按「取消」处理，会把确认误判为取消（确认按钮点了没反应）。 + // 因此关闭时的取消判定推迟到当前事件循环的 click 处理器执行完毕后再进行。 + if (!open && !confirmState.value.resolved) { + setTimeout(() => { + if (!confirmState.value.resolved) onConfirmCancel() + }, 0) + } confirmState.value.open = open } @@ -90,16 +99,13 @@ const testingGroups = ref>(new Set()) const loadingProxies = ref(false) const checkingUpdate = ref(false) const updatingKernel = ref(false) -const kernelUpdateInfo = ref<{ latestVersion: string; hasUpdate: boolean } | null>(null) +const kernelUpdateInfo = ref<{ latestVersion: string; hasUpdate: boolean; downloadUrl: string } | null>(null) -// 自动切换节点（从 settings 持久化） +// 自动切换节点（从 settings 持久化；执行由后端调度） const autoSwitchEnabled = ref(false) const autoSwitchInterval = ref(5) // 分钟 const autoSwitchTargetGroup = ref('') // 目标代理组 const autoSwitchRegion = ref('') // 空=全部，否则按地区过滤 -let autoSwitchTimer: ReturnType | null = null -/** 自动切换执行中标志（防重入：测速超时时上一轮未结束，间隔触发会重叠） */ -let autoSwitchRunning = false // 从 store.settings 同步自动切换设置 const syncAutoSwitchSettings = () => { @@ -127,6 +133,9 @@ const saveAutoSwitchSettings = async () => { } } +// 后端自动切换事件监听句柄（模块卸载时关闭） +let autoSwitchUnlisten: UnlistenFn[] = [] + // 手风琴展开项 const accordionValue = ref('') @@ -328,10 +337,6 @@ const init = async () => { await store.waitForApi() store.refreshVersion() loadProxiesWithError() - // 若自动切换已开启，恢复定时器（静默，不弹通知、不立即执行） - if (autoSwitchEnabled.value) { - startAutoSwitch(false, false) - } } } finally { // 无论初始化链路是否出错，都结束"加载中"占位，避免模块永久卡死 @@ -350,12 +355,17 @@ onMounted(() => { }, 3000) // 页面重新可见时立即刷新一次系统代理状态（切回标签页/从托盘返回主窗口） document.addEventListener('visibilitychange', onVisibilityChange) + // 监听后端自动切换节点完成事件（后台执行，不依赖模块激活） + listen<{ switched?: boolean; group?: string; name?: string; delay?: number }>(EVENTS.proxyAutoSwitch, onProxyAutoSwitch) + .then(fn => autoSwitchUnlisten.push(fn)) + .catch(err => logger.error('注册自动切换事件监听失败: ' + err)) }) onUnmounted(() => { if (statusTimer) clearInterval(statusTimer) document.removeEventListener('visibilitychange', onVisibilityChange) - stopAutoSwitch() + autoSwitchUnlisten.forEach(fn => fn()) + autoSwitchUnlisten = [] }) /** 页面可见性变化时刷新系统代理状态（低成本感知外部修改） */ @@ -370,11 +380,6 @@ watch(running, async (val, old) => { await store.waitForApi() await store.refreshVersion() await loadProxiesWithError() - // 自动切换若已开启，mihomo 启动/重启后恢复定时器（静默，不弹通知） - // （handleStop 会停掉旧定时器，此处统一接管启动路径，避免开关显示开但功能静默失效） - if (autoSwitchEnabled.value) { - startAutoSwitch(false) - } } }) @@ -417,7 +422,6 @@ const handleStart = async () => { const handleStop = async () => { stopping.value = true try { - stopAutoSwitch() await store.stop() toast.success('mihomo 已停止') } catch (e) { @@ -448,6 +452,12 @@ const handleRestart = async () => { // ===== 系统代理 ===== const onToggleSystemProxy = async (on: boolean) => { + // 停机时禁止开启（正常情况下开关已禁用，此处兜底防止外部调用） + if (on && !running.value) { + toast.warning('请先启动 mihomo 再开启系统代理') + store.refreshSystemProxy() + return + } sysProxyLoading.value = true try { await store.toggleSystemProxy(on) @@ -485,46 +495,26 @@ const quickSwitchNode = async (name: string) => { try { await store.selectProxy(mainGroupName.value, name) toast.success('节点已切换', { description: name }) - // 测速新节点 - store.testDelay(name).then(delay => { - toast.success(`${name}`, { description: `延迟 ${delay}ms` }) + // 测速新节点：用 testDelayBatch 以更新 history，保证节点 Badge 显示与结果一致 + store.testDelayBatch([name]).then(() => { + const delay = store.proxies[name]?.history?.[0]?.delay + if (delay && delay > 0) { + toast.success(`${name}`, { description: `延迟 ${delay}ms` }) + } }).catch(() => {}) } catch (e) { toast.error('切换节点失败', { description: String(e) }) } } -// ===== 自动切换节点 ===== -const startAutoSwitch = (notify = true, immediate = true) => { - stopAutoSwitch() - if (!autoSwitchEnabled.value) return - const ms = autoSwitchInterval.value * 60 * 1000 - autoSwitchTimer = setInterval(runAutoSwitch, ms) - // 仅用户主动开启时提示；模块挂载/内核重启恢复定时器时静默，避免每次切换都弹通知 - if (notify) { - toast.success('自动切换已开启', { - description: `每 ${autoSwitchInterval.value} 分钟测试并切换至最优节点` - }) - } - // 立即执行一次（用户主动开启/调整时立即生效；进入模块恢复时跳过，避免每次进入都测速切换） - if (immediate) { - runAutoSwitch() - } -} - -const stopAutoSwitch = () => { - if (autoSwitchTimer) { - clearInterval(autoSwitchTimer) - autoSwitchTimer = null - } -} - +// ===== 自动切换节点（执行由后端调度，前端仅负责维护设置并刷新/提示） ===== const onToggleAutoSwitch = (on: boolean) => { autoSwitchEnabled.value = on if (on) { - startAutoSwitch() + toast.success('自动切换已开启', { + description: `每 ${autoSwitchInterval.value} 分钟测试并切换至最优节点` + }) } else { - stopAutoSwitch() toast.info('自动切换已关闭') } saveAutoSwitchSettings() @@ -532,52 +522,21 @@ const onToggleAutoSwitch = (on: boolean) => { const onAutoSwitchIntervalChange = (val: unknown) => { autoSwitchInterval.value = Number(val) || 5 - if (autoSwitchEnabled.value) { - startAutoSwitch() - } saveAutoSwitchSettings() } -const runAutoSwitch = async () => { - if (autoSwitchRunning) return - autoSwitchRunning = true +/** 后端自动切换完成后刷新节点列表并提示（后台亦可运行，不依赖模块激活） */ +const onProxyAutoSwitch = async (e: { payload: { switched?: boolean; group?: string; name?: string; delay?: number } }) => { + const p = e.payload try { - const groupName = autoSwitchTargetGroup.value || mainGroupName.value - if (!groupName || !running.value) return - const nodes = filteredNodes.value - if (!nodes.length) return - - // 使用 testDelayBatch 测速，它会更新 store.proxies[name].history， - // 确保 UI 显示的延迟与选优结果一致 - await store.testDelayBatch(nodes) - - // 从更新后的 history 读取最新延迟 - const results = nodes.map(name => ({ - name, - delay: store.proxies[name]?.history?.[0]?.delay ?? 0 - })) - - // 找到有效延迟中最低的 - const valid = results.filter(r => r.delay > 0) - if (!valid.length) { - toast.warning('所有节点均超时，未切换') - return - } - valid.sort((a, b) => a.delay - b.delay) - const best = valid[0] - - // 如果当前节点不是最优，则切换 - const currentNow = store.proxies[groupName]?.now ?? '' - if (currentNow !== best.name) { - await store.selectProxy(groupName, best.name) - toast.success('已自动切换到最优节点', { - description: `${best.name} (${best.delay}ms)` - }) - } - } catch (e) { - logger.error('自动切换失败: ' + e) - } finally { - autoSwitchRunning = false + await store.loadProxies() + } catch (err) { + logger.error('自动切换后刷新节点失败: ' + err) + } + if (p?.switched && p.name && p.delay) { + toast.success('已自动切换到最优节点', { + description: `${p.name} (${p.delay}ms)` + }) } } @@ -586,7 +545,7 @@ const handleCheckUpdate = async () => { checkingUpdate.value = true try { const info = await store.checkKernelUpdate() - kernelUpdateInfo.value = { latestVersion: info.latestVersion, hasUpdate: info.hasUpdate } + kernelUpdateInfo.value = { latestVersion: info.latestVersion, hasUpdate: info.hasUpdate, downloadUrl: info.downloadUrl } if (info.hasUpdate) { toast.info('发现新版本', { description: `最新: ${info.latestVersion}` }) } else { @@ -607,31 +566,26 @@ const handleUpdateKernel = async () => { /** 是否展开"更新内核"区块（下载源 + 进度） */ const updateExpanded = ref(false) -/** 开始更新：停止 mihomo → 调用 updateKernel（复用 installProgress 进度机制） */ +/** 开始更新：确保有下载 URL → 调用 updateKernel（复用 installProgress 进度机制）。 + * 下载阶段允许 mihomo 运行（可通过当前系统代理下载）， + * 解压替换前由 need_stop 阶段弹窗要求停止 mihomo */ const handleStartUpdate = async () => { if (store.installing) return - // 确认停止 mihomo - if (running.value) { - const ok = await showConfirm({ - title: '更新内核', - description: '更新内核需要先停止 mihomo，确认继续？', - confirmText: '继续更新' - }) - if (!ok) return - updatingKernel.value = true + // 使用检查更新时获取的下载 URL（缺失时先补查一次，避免后端二次请求 GitHub） + let url = kernelUpdateInfo.value?.downloadUrl ?? '' + if (!url) { try { - await store.stop() + const info = await store.checkKernelUpdate() + url = info.downloadUrl + kernelUpdateInfo.value = { latestVersion: info.latestVersion, hasUpdate: info.hasUpdate, downloadUrl: info.downloadUrl } } catch (e) { - toast.error('停止 mihomo 失败', { description: String(e) }) - updatingKernel.value = false + toast.error('获取更新信息失败', { description: String(e) }) return - } finally { - updatingKernel.value = false } } toast.info('开始下载更新...') try { - await store.updateKernel(selectedMirrorPrefix.value) + await store.updateKernel(selectedMirrorPrefix.value, url) } catch (e) { toast.error('内核更新失败', { description: String(e) }) } @@ -641,7 +595,9 @@ const handleStartUpdate = async () => { const installStageText = computed(() => { const stage = store.installProgress?.stage switch (stage) { + case 'checking': return '正在检查' case 'downloading': return '正在下载' + case 'need_stop': return '等待停止 mihomo' case 'extracting': return '正在解压' case 'replacing': return '正在安装' case 'done': return '安装完成' @@ -654,6 +610,7 @@ const installStageColor = computed(() => { const stage = store.installProgress?.stage if (stage === 'done') return 'text-emerald-500' if (stage === 'error') return 'text-destructive' + if (stage === 'need_stop') return 'text-amber-500' return 'text-primary' }) @@ -672,6 +629,25 @@ const installPercentDisplay = computed(() => { const installHasTotal = computed(() => store.installProgress?.totalBytes != null) +/** 停止下载进行中标记（防止重复点击） */ +const stoppingDownload = ref(false) + +/** 停止下载：通知后端中止，并立即回退到下载方式卡片（保留 updateExpanded 供重新选择） */ +const handleStopDownload = async () => { + if (stoppingDownload.value || !store.installing) return + stoppingDownload.value = true + try { + await store.cancelKernelInstall() + // 立即复位 UI 状态回退到下载方式卡片；后端下载循环稍后中止，updateKernel 会静默结束 + store.installing = false + store.clearInstallProgress() + } catch (e) { + toast.error('停止下载失败', { description: String(e) }) + } finally { + stoppingDownload.value = false + } +} + const formatMB = (bytes: number) => `${(bytes / 1024 / 1024).toFixed(2)} MB` // ===== 首次安装内核 ===== @@ -709,12 +685,55 @@ const handleInstallKernel = async () => { } } +/** need_stop 弹窗处理中标记（防止重复触发） */ +let handlingNeedStop = false + +/** + * 下载完成、解压替换前：弹窗提示用户停止 mihomo，确认后停止 mihomo 并唤醒后端继续安装。 + * 取消则中止整个安装流程（后端正在等待确认，通过取消唤醒）。 + */ +const handleNeedStop = async () => { + if (handlingNeedStop) return + handlingNeedStop = true + try { + const wasRunning = running.value + const ok = await showConfirm({ + title: '停止 mihomo 后继续', + description: wasRunning + ? '下载已完成。安装新内核前需要停止 mihomo，点击「停止并继续」将自动停止 mihomo 并完成安装。' + : '下载已完成。即将安装新内核，点击「继续」完成安装。', + confirmText: wasRunning ? '停止并继续' : '继续' + }) + if (!ok) { + // 用户取消：中止安装（后端在等待确认，置取消标志唤醒其返回） + await store.cancelKernelInstall() + return + } + if (wasRunning) { + await store.stop() + } + await store.confirmInstall() + } catch (e) { + toast.error('停止 mihomo 失败', { description: String(e) }) + // 停止失败则中止安装，避免替换阶段因 exe 占用而报错 + try { + await store.cancelKernelInstall() + } catch { + // 忽略：cancelKernelInstall 内部已记录日志 + } + } finally { + handlingNeedStop = false + } +} + // 监听安装/更新进度终态，弹 toast 并延时清空进度 // 同时处理更新场景下的 updateExpanded 清理（与 installProgress 同步清除，避免更新区块闪烁） watch( () => store.installProgress?.stage, (stage) => { - if (stage === 'done') { + if (stage === 'need_stop') { + handleNeedStop() + } else if (stage === 'done') { toast.success('内核安装完成', { description: store.installProgress?.message }) @@ -899,12 +918,35 @@ watch(() => store.settings, syncLocalSettings, { immediate: true }) const saveSettingsForm = async () => { if (!store.settings) return + const prev = store.settings try { await store.saveSettings({ ...store.settings, ...localSettings.value }) - toast.success('设置已保存') + + // 网络相关字段（端口/接口/密钥）变更需重启 mihomo 才生效，运行实例仍在旧值上； + // 提示用户重启，避免后续代理 API 调用打到新地址而失败 + const networkChanged = + localSettings.value.mixedPort !== prev.mixedPort || + localSettings.value.externalController !== prev.externalController || + localSettings.value.secret !== prev.secret + if (networkChanged && running.value) { + toast.warning('端口/接口/密钥已保存，重启 mihomo 后生效（期间代理 API 使用新地址可能暂时不可用）') + } else { + toast.success('设置已保存') + } + + // 纯模式变更（网络字段未变）在运行中即时生效，与概览页行为一致， + // 避免「UI 显示新模式、运行实例仍是旧模式」的不一致 + if (!networkChanged && localSettings.value.mode !== prev.mode && running.value) { + try { + await invokePatchConfigs({ mode: localSettings.value.mode }) + await store.loadProxies() + } catch (modeErr) { + logger.error('运行中应用模式失败，重启后生效: ' + modeErr) + } + } } catch (e) { toast.error('保存失败', { description: String(e) }) } @@ -1128,12 +1170,12 @@ tabsStore.registerSave(saveSettingsForm)
- + {{ installStageText }} @@ -1141,7 +1183,7 @@ tabsStore.registerSave(saveSettingsForm)

+ +
+ +
@@ -1371,7 +1427,7 @@ tabsStore.registerSave(saveSettingsForm)
@@ -1627,7 +1683,7 @@ tabsStore.registerSave(saveSettingsForm) - + {{ confirmState.opts.title }} diff --git a/src/modules/quickpanel/QuickPanel.vue b/src/modules/quickpanel/QuickPanel.vue index fb87ed7..636ff28 100644 --- a/src/modules/quickpanel/QuickPanel.vue +++ b/src/modules/quickpanel/QuickPanel.vue @@ -34,6 +34,8 @@ const explorerDir = ref('') const actionMode = ref<'none' | 'extract' | 'rename' | 'delete'>('none') // 面板模式下的窗口高度（比搜索态更高，容纳列表+输入） const ACTION_HEIGHT = 620 +// 跳过下一次 query 变更触发的防抖搜索（面板 show/hide 重置输入时使用，避免重复搜索） +let skipNextSearch = false // 批量解压进度事件负载：specta 不导出事件类型，需在此与 Rust 端 actions.rs 同名结构体保持同步 interface ExtractProgress { @@ -190,7 +192,8 @@ async function doSearch() { const seq = ++searchSeq const q = query.value.trim() if (!q) { - // 空查询：当前目录文件操作（若检测到 Explorer 目录）+ 命令快捷入口 + 历史 + // 空查询：当前目录文件操作（若检测到 Explorer 目录）+ 历史置顶 + 系统相关条目 + // （程序相关设置不参与默认展示；所有 Provider 空查询零 IPC，首屏即时） const items = await aggregateSearch('') if (seq !== searchSeq) return // 过期请求丢弃 const dirItems = getExplorerActions() @@ -227,9 +230,14 @@ async function doSearch() { // 防抖搜索 watch(query, () => { - // 面板模式下输入搜索词：先退出面板，恢复窗口高度 + // show/hide 重置输入时跳过（由事件处理器显式搜索/清空） + if (skipNextSearch) { + skipNextSearch = false + return + } + // 面板模式下输入搜索词：先退出面板，恢复窗口高度（不立即搜索，由下方防抖统一触发） if (actionMode.value !== 'none') { - exitMode() + exitMode(true) } if (searchTimer) clearTimeout(searchTimer) collapseSubActions() @@ -309,14 +317,15 @@ async function enterDeleteMode() { document.querySelector('.qp-fa-delete-filter')?.focus() } -async function exitMode() { +async function exitMode(skipSearch = false) { if (actionMode.value === 'none') return actionMode.value = 'none' extractReset() renameReset() deleteReset() await setWindowHeight(420) - await doSearch() + // watch(query) 路径跳过：稍后防抖会用新 query 搜索，避免双重搜索 + if (!skipSearch) await doSearch() } function extractReset() { @@ -804,7 +813,7 @@ function onSubActionHover(idx: number) { /** 应用类条目（含历史中的应用）不显示 subtitle（路径），让布局更紧凑 */ const isAppLike = (item: QPItem) => !!item.iconPath const groupIcon = (group: string) => { - if (group === '命令') return Command + if (group === '设置') return Settings if (group === '计算') return Calculator if (group === '网页') return Globe if (group === '系统') return Lock @@ -818,7 +827,7 @@ const groupIcon = (group: string) => { /** 类型 badge 颜色映射（柔和色块风格，跟随亮/暗主题） */ const GROUP_COLORS: Record = { - 命令: 'bg-indigo-500/15 text-indigo-600 dark:text-indigo-400', + 设置: 'bg-indigo-500/15 text-indigo-600 dark:text-indigo-400', 计算: 'bg-amber-500/15 text-amber-600 dark:text-amber-400', 网页: 'bg-rose-500/15 text-rose-600 dark:text-rose-400', 系统: 'bg-slate-500/15 text-slate-600 dark:text-slate-400', @@ -910,6 +919,16 @@ async function applyTheme() { } } +/** 检查文件索引状态（后台自动构建完成后启用文件搜索）。首次调用需打开 SQLite，宜后台执行 */ +async function refreshIndexReady() { + try { + const stats = await commands.quickpanelFileIndexStats() + setFileIndexReady((stats?.total ?? 0) > 0) + } catch { + /* 索引未初始化，忽略 */ + } +} + onMounted(async () => { await applyTheme() @@ -929,10 +948,12 @@ onMounted(async () => { window.addEventListener('storage', onStorage) unlistenFns.push(() => window.removeEventListener('storage', onStorage)) - // 监听弹窗显示事件：同步主题 + 更新 Explorer 当前目录 + 清空输入 + 加载初始结果 + // 监听弹窗显示事件：更新 Explorer 当前目录 + 清空输入 + 加载初始结果。 + // 主题同步与索引状态检查均不阻塞首屏结果（索引首次查询需打开 SQLite） unlistenFns.push(await listen<{ dir: string | null }>(EVENTS.quickpanelShow, async (e) => { - await applyTheme() explorerDir.value = e.payload?.dir ?? '' + void applyTheme() + void refreshIndexReady() // 若上次关闭时停留在面板模式，恢复搜索态和窗口高度 if (actionMode.value !== 'none') { actionMode.value = 'none' @@ -941,7 +962,15 @@ onMounted(async () => { deleteReset() await setWindowHeight(420) } - query.value = '' + // 丢弃残留的防抖搜索；重置输入不触发新搜索（下方显式搜索） + if (searchTimer) { + clearTimeout(searchTimer) + searchTimer = null + } + if (query.value !== '') { + skipNextSearch = true + query.value = '' + } await doSearch() await nextTick() inputRef.value?.focus() @@ -953,27 +982,32 @@ onMounted(async () => { })) unlistenFns.push(await listen(EVENTS.quickpanelHide, () => { - query.value = '' + // 取消未触发的防抖搜索；重置输入时跳过搜索（面板已隐藏，避免无效搜索） + if (searchTimer) { + clearTimeout(searchTimer) + searchTimer = null + } + if (query.value !== '') { + skipNextSearch = true + query.value = '' + } results.value = [] })) - // 初始加载（空查询显示快捷入口） - // 独立窗口需自行检查文件索引状态（主窗口的 setFileIndexReady 不共享到此上下文） - try { - const stats = await commands.quickpanelFileIndexStats() - setFileIndexReady((stats?.total ?? 0) > 0) - } catch { - /* 索引未初始化，忽略 */ - } - await doSearch() - await nextTick() - inputRef.value?.focus() - + // 先显示窗口（兜底重建路径依赖此调用才真正显示）：让面板尽快出现， + // 后续数据加载（索引统计/初始搜索）不阻塞显示，避免 dev 下首屏渲染慢导致"唤不出"。 try { await commands.quickpanelShowWindow() } catch { /* 忽略 */ } + + // 初始加载（空查询显示历史置顶 + 系统条目；Provider 空查询零 IPC，即时渲染） + // 独立窗口需自行检查文件索引状态（主窗口的 setFileIndexReady 不共享到此上下文） + void refreshIndexReady() + await doSearch() + await nextTick() + inputRef.value?.focus() }) onUnmounted(() => { @@ -992,7 +1026,7 @@ onUnmounted(() => { ref="inputRef" v-model="query" class="qp-input" - placeholder="搜索命令、应用、文件…" + placeholder="搜索应用、文件、系统命令…" spellcheck="false" autocomplete="off" /> @@ -1007,7 +1041,7 @@ onUnmounted(() => {