Files
Thing/src-tauri/src/tray_menu.rs
T

879 lines
32 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! tray_menu.rs — 自定义系统托盘菜单(WebviewWindow 弹窗)
//!
//! 使用独立 WebviewWindow 替代原生菜单,实现与应用一致的视觉风格(Mica/Acrylic + 深色主题)。
//! - 右键托盘:显示自定义菜单窗口(在鼠标位置弹出)
//! - 左键托盘:显示主窗口
//! - 菜单窗口失焦:自动隐藏
//!
//! 前端通过监听 `tray-menu-show` 事件获取菜单状态并渲染,
//! 点击菜单项时调用 `tray_menu_action` 命令执行对应操作。
use serde::Serialize;
use std::sync::Mutex;
use std::time::{Duration, Instant};
use tauri::{
AppHandle, Emitter, Manager, WebviewUrl, WebviewWindowBuilder,
tray::{MouseButton, TrayIconBuilder, TrayIconEvent},
window::{Effect, EffectsBuilder},
};
/// 记录窗口最后显示时间,用于失焦防抖(避免显示瞬间因焦点未稳定而被立即隐藏)
static LAST_SHOW_TIME: Mutex<Option<Instant>> = Mutex::new(None);
/// 保存最近一次右键时计算出的定位参数(物理坐标),供 `tray_menu_ready` 使用
/// (x, cursor_y, screen_top, screen_bottom, scale)
static LAST_MENU_LAYOUT: Mutex<Option<(f64, f64, f64, f64, f64)>> = Mutex::new(None);
use crate::win32_util::{get_work_area, get_monitor_bounds_at_point, get_dpi_for_point};
use crate::mihomo_manager::{MihomoManager, is_pseudo_node};
use crate::monitor_kernel::MonitorKernel;
use crate::music::{AudioEngine, SmtcMetaCache, SMTC_BUTTON_EVENT};
use crate::process_manager::{ProcessManager, ProcessStatus};
/// 托盘菜单窗口标签
pub const TRAY_MENU_LABEL: &str = "tray-menu";
// ===== 状态数据结构(发送给前端) =====
#[derive(Serialize, Clone, Debug)]
#[serde(rename_all = "camelCase")]
pub struct ProxyNodeInfo {
pub name: String,
pub delay: Option<u32>,
pub is_current: bool,
}
#[derive(Serialize, Clone, Debug)]
#[serde(rename_all = "camelCase")]
pub struct TrayMenuState {
pub proxy_running: bool,
pub system_proxy: bool,
pub monitor_running: bool,
pub proxy_group: Option<String>,
pub proxy_nodes: Vec<ProxyNodeInfo>,
pub proxy_current: Option<String>,
}
/// 托盘音乐控制条状态。
///
/// 曲目信息取自 [`SmtcMetaCache`](前端推给 SMTC 的元数据回填),
/// 播放态取自 [`AudioEngine`]:两者都在 Rust 侧,托盘菜单只需一次拉取。
#[derive(Serialize, Clone, Debug)]
#[serde(rename_all = "camelCase")]
pub struct MusicState {
pub playing: bool,
pub title: String,
pub artist: String,
/// 当前音量(0.0~1.0)
pub volume: f32,
pub muted: bool,
}
/// 托盘调音量 / 静音后广播给主窗口前端的权威值(前端据此更新 ref 并落盘)。
///
/// 为什么不走 [`SMTC_BUTTON_EVENT`]:那条通道是「无负载字符串动作」,音量要带数值。
pub const TRAY_MUSIC_VOLUME_EVENT: &str = "tray-music-volume";
#[derive(Serialize, Clone, Debug)]
#[serde(rename_all = "camelCase")]
pub struct TrayVolumeState {
pub volume: f32,
pub muted: bool,
}
fn get_music_state(app: &AppHandle) -> MusicState {
let playing = app
.try_state::<AudioEngine>()
.map(|e| e.state().playing)
.unwrap_or(false);
// 音量/静音取自引擎:托盘拖动滑块直接改的就是它,这里读到的是真实生效值
let (volume, muted) = app
.try_state::<AudioEngine>()
.map(|e| e.volume())
.unwrap_or((1.0, false));
let (title, artist) = app
.try_state::<SmtcMetaCache>()
.and_then(|c| c.0.lock().ok().map(|g| (g.title.clone(), g.artist.clone())))
.unwrap_or_default();
MusicState {
playing,
title,
artist,
volume,
muted,
}
}
// ===== 状态查询 =====
fn is_proxy_running(app: &AppHandle) -> bool {
if let Some(pm) = app.try_state::<ProcessManager>() {
if let Some(info) = pm.get_status("proxy") {
return matches!(info.status, ProcessStatus::Running);
}
}
false
}
fn is_monitor_running(app: &AppHandle) -> bool {
if let Some(pm) = app.try_state::<ProcessManager>() {
if let Some(info) = pm.get_status("monitor") {
if matches!(info.status, ProcessStatus::Running) {
return true;
}
}
}
if let Some(monitor) = app.try_state::<MonitorKernel>() {
if monitor.is_elevated() {
return true;
}
}
false
}
// ===== 从 mihomo /proxies 响应中提取主选择组及其节点 =====
/// 返回 (组名, 有效节点列表, 当前节点)
fn parse_main_group(proxies_response: &serde_json::Value) -> Option<(String, Vec<String>, String)> {
let proxies = proxies_response.get("proxies")?.as_object()?;
let selector_groups: Vec<&str> = proxies
.iter()
.filter(|(_, v)| {
v.get("type").and_then(|t| t.as_str()).map(|t| t == "Selector").unwrap_or(false)
})
.map(|(k, _)| k.as_str())
.collect();
if selector_groups.is_empty() {
return None;
}
let preferred = selector_groups
.iter()
.find(|name| matches!(**name, "PROXY" | "Proxy" | "节点选择" | "代理"))
.copied();
let group_name = preferred.unwrap_or(selector_groups[0]);
let group = &proxies[group_name];
let now = group.get("now").and_then(|n| n.as_str()).unwrap_or("").to_string();
let all: Vec<String> = group
.get("all")
.and_then(|a| a.as_array())
.map(|arr| {
arr.iter()
.filter_map(|v| v.as_str().map(String::from))
.filter(|n| !is_pseudo_node(n))
.collect()
})
.unwrap_or_default();
Some((group_name.to_string(), all, now))
}
/// 从 /proxies 响应中读取某节点最近一次延迟
fn parse_node_delay(proxies_response: &serde_json::Value, name: &str) -> Option<u32> {
proxies_response
.get("proxies")
.and_then(|p| p.get(name))
.and_then(|n| n.get("history"))
.and_then(|h| h.as_array())
.and_then(|arr| arr.first())
.and_then(|first| first.get("delay"))
.and_then(|d| d.as_u64())
.map(|d| d as u32)
}
// ===== 获取代理节点数据(异步,调用 mihomo API) =====
async fn fetch_proxy_nodes(app: &AppHandle) -> Option<(String, Vec<(String, Option<u32>)>, String)> {
let mihomo = app.state::<MihomoManager>();
let proxies = mihomo.get_proxies().await.ok()?;
let (group, nodes, now) = parse_main_group(&proxies)?;
let node_delays: Vec<(String, Option<u32>)> = nodes
.iter()
.map(|name| (name.clone(), parse_node_delay(&proxies, name)))
.collect();
Some((group, node_delays, now))
}
// ===== 获取菜单状态 =====
/// 基础状态(不含代理节点)。托盘菜单显示不应受 mihomo API 慢/卡死影响,
/// 因此先秒发基础状态让菜单立即出现,代理节点随后异步补充。
fn get_base_tray_state(app: &AppHandle) -> TrayMenuState {
let proxy_running = is_proxy_running(app);
let monitor_running = is_monitor_running(app);
// 读取 Windows 注册表中的真实系统代理状态(不依赖 settings.json 缓存)
let system_proxy = crate::mihomo_manager::get_system_proxy_windows();
TrayMenuState {
proxy_running,
system_proxy,
monitor_running,
proxy_group: None,
proxy_nodes: vec![],
proxy_current: None,
}
}
/// 完整状态(含代理节点)。可能因调用 mihomo /proxies 而耗时(最长 10s)。
async fn get_full_tray_state(app: &AppHandle) -> TrayMenuState {
let proxy_running = is_proxy_running(app);
let monitor_running = is_monitor_running(app);
// 读取 Windows 注册表中的真实系统代理状态(不依赖 settings.json 缓存)
let system_proxy = crate::mihomo_manager::get_system_proxy_windows();
let (proxy_group, proxy_nodes, proxy_current) = if proxy_running {
match fetch_proxy_nodes(app).await {
Some((group, nodes, now)) => {
let node_infos: Vec<ProxyNodeInfo> = nodes
.iter()
.map(|(name, delay)| ProxyNodeInfo {
name: name.clone(),
delay: *delay,
is_current: name == &now,
})
.collect();
(Some(group), node_infos, if now.is_empty() { None } else { Some(now) })
}
None => (None, vec![], None),
}
} else {
(None, vec![], None)
};
TrayMenuState {
proxy_running,
system_proxy,
monitor_running,
proxy_group,
proxy_nodes,
proxy_current,
}
}
pub async fn get_tray_menu_state(app: &AppHandle) -> TrayMenuState {
get_full_tray_state(app).await
}
// ===== 显示/隐藏托盘菜单窗口 =====
/// 托盘菜单窗口尺寸(逻辑像素)
/// 宽度需与前端 TrayMenu.vue 的 MENU_WIDTH 保持一致,避免 resize 时右对齐错位
const MENU_W: f64 = 220.0;
const MENU_H: f64 = 420.0;
/// 预创建隐藏的托盘菜单窗口(在应用启动时调用)。
/// 窗口隐藏渲染,前端 onMounted 应用主题后保持隐藏状态,右键托盘时直接 show 即无延迟。
pub fn precreate_tray_menu_window(app: &AppHandle) {
if app.get_webview_window(TRAY_MENU_LABEL).is_some() {
return;
}
// 默认放在屏幕右下角(托盘常见位置附近),首次显示时会重新定位
let (screen_w, screen_h) = get_work_area().unwrap_or((1920.0, 1080.0));
let x = (screen_w as f64) - MENU_W - 20.0;
let y = (screen_h as f64) - MENU_H - 60.0;
let win = match WebviewWindowBuilder::new(
app,
TRAY_MENU_LABEL,
WebviewUrl::App("index.html#tray-menu".into()),
)
.title("Thing 菜单")
.inner_size(MENU_W, MENU_H)
.position(x, y)
.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("tray", &format!("预创建菜单窗口失败: {}", e));
return;
}
};
// 监听窗口失焦:自动隐藏(带 300ms 防抖,避免显示瞬间焦点未稳定而被立即隐藏)
let win_handle = win.clone();
win.on_window_event(move |event| {
if let tauri::WindowEvent::Focused(false) = event {
let should_hide = {
let t = LAST_SHOW_TIME.lock().unwrap_or_else(|e| e.into_inner());
match *t {
Some(time) => time.elapsed() > Duration::from_millis(300),
None => true,
}
};
if should_hide {
let _ = win_handle.hide();
}
}
});
crate::logger::log_info("tray", "菜单窗口已预创建(隐藏渲染)");
}
/// 右键托盘时调用:计算定位参数、发送状态给前端,但不立即显示窗口。
/// 窗口等待前端测量内容高度后调用 `tray_menu_ready` 才显示,确保底部对齐鼠标点击位置。
///
/// `cursor_pos`: 事件报告的鼠标物理坐标。
pub fn show_tray_menu(app: &AppHandle, cursor_pos: (f64, f64)) {
let (mx, my) = (cursor_pos.0, cursor_pos.1);
// 获取光标所在显示器的完整边界(含任务栏,物理像素)。
// 托盘图标位于任务栏上,菜单需在鼠标位置弹出,因此用屏幕边界而非工作区做 clamp,
// 否则会被工作区底部(任务栏顶部)截断,导致菜单整体被推到任务栏上方。
let (scr_left, scr_top, scr_right, scr_bottom) = get_monitor_bounds_at_point(mx as i32, my as i32)
.unwrap_or((0, 0, 1920, 1080));
// 光标所在显示器的 DPI:菜单宽度按物理像素换算
let dpi = get_dpi_for_point(mx as i32, my as i32).unwrap_or(96);
let scale = dpi as f64 / 96.0;
let menu_w_px = MENU_W * scale;
// 水平:菜单左边缘对齐鼠标 X(向右延伸),超出屏幕右边界则左移(物理坐标)
let x = mx.max(scr_left as f64).min(scr_right as f64 - menu_w_px);
// 保存布局参数(全部物理坐标 + scale,供 tray_menu_ready 换算前端上报的逻辑高度)
{
let mut layout = LAST_MENU_LAYOUT.lock().unwrap_or_else(|e| e.into_inner());
*layout = Some((x, my, scr_top as f64, scr_bottom as f64, scale));
}
// 记录显示时间,用于失焦防抖
{
let mut t = LAST_SHOW_TIME.lock().unwrap_or_else(|e| e.into_inner());
*t = Some(Instant::now());
}
// 确保窗口存在(兖底)
if app.get_webview_window(TRAY_MENU_LABEL).is_none() {
precreate_tray_menu_window(app);
}
// 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(5000),
get_full_tray_state(&app_clone),
)
.await
{
Ok(s) => s,
Err(_) => return,
};
let _ = app_clone.emit(crate::constants::events::TRAY_MENU_STATE_UPDATED, state);
});
}
/// 隐藏托盘菜单窗口(不销毁,保留复用)
pub fn hide_tray_menu(app: &AppHandle) {
if let Some(win) = app.get_webview_window(TRAY_MENU_LABEL) {
let _ = win.hide();
}
}
/// 刷新菜单状态并发送给前端
async fn refresh_and_emit_state(app: &AppHandle) {
let state = get_tray_menu_state(app).await;
let _ = app.emit(crate::constants::events::TRAY_MENU_STATE_UPDATED, state);
}
/// 显示主窗口并强制置为前台。
/// Tauri 的 set_focus 在 Windows 上受前台锁定限制,主窗口被其他应用遮挡时无法到前台;
/// 改用原生 SetForegroundWindow + BringWindowToTop(模拟 Alt 键重置前台锁定)。
pub fn focus_main_window(app: &AppHandle) {
if let Some(window) = app.get_webview_window(crate::constants::windows::MAIN) {
let _ = window.show();
let _ = window.unminimize();
match window.hwnd() {
Ok(hwnd) => crate::win32_util::force_foreground(hwnd.0 as isize),
Err(_) => {
window.set_focus().ok();
}
}
}
}
// ===== Tauri 命令 =====
/// 执行菜单项动作(统一入口)
#[tauri::command]
pub async fn tray_menu_action(
action: String,
payload: Option<serde_json::Value>,
app: AppHandle,
) -> Result<(), String> {
match action.as_str() {
"proxy_enable" => {
if let Err(e) = enable_proxy(&app).await {
crate::logger::log_error("tray", &format!("开启代理失败: {}", e));
send_notification(&app, "代理启动失败", &e);
}
}
"proxy_disable" => {
if let Err(e) = disable_proxy(&app).await {
crate::logger::log_error("tray", &format!("关闭代理失败: {}", e));
send_notification(&app, "代理关闭失败", &e);
}
}
"proxy_refresh" => {
test_all_delays(&app).await;
}
"proxy_select_node" => {
if let Some(name) = payload
.as_ref()
.and_then(|p| p.get("name"))
.and_then(|n| n.as_str())
{
if let Some(group) = get_proxy_group(&app).await {
select_proxy_node(&app, &group, name).await;
}
}
}
"system_proxy_toggle" => {
// 根据注册表当前真实状态切换(不依赖 settings.json 缓存,避免与主界面不同步)
let mihomo = app.state::<MihomoManager>();
if crate::mihomo_manager::get_system_proxy_windows() {
if let Err(e) = mihomo.disable_system_proxy() {
crate::logger::log_error("tray", &format!("关闭系统代理失败: {}", e));
send_notification(&app, "系统代理关闭失败", &e);
}
} else {
if let Err(e) = mihomo.enable_system_proxy() {
crate::logger::log_error("tray", &format!("开启系统代理失败: {}", e));
send_notification(&app, "系统代理开启失败", &e);
}
}
}
"osd_toggle" => {
let _ = app.emit(crate::constants::events::TRAY_TOGGLE_OSD, ());
}
"kernel_restart" => {
if let Err(e) = restart_kernel(&app).await {
crate::logger::log_error("tray", &format!("重启 Kernel 失败: {}", e));
send_notification(&app, "Kernel 重启失败", &e);
}
}
"terminal" => {
// 新建终端选择窗口由前端创建(label 需命中 terminal-window-* 授权)
let _ = app.emit(crate::constants::events::TRAY_OPEN_TERMINAL, ());
hide_tray_menu(&app);
}
"dsh" => {
// 未启动时前端会先开进度窗口并同步拉起服务
let _ = app.emit(crate::constants::events::TRAY_OPEN_DSH, ());
hide_tray_menu(&app);
}
"editor" => {
let _ = app.emit(crate::constants::events::TRAY_OPEN_EDITOR, ());
hide_tray_menu(&app);
}
"quit" => {
hide_tray_menu(&app);
quit_cleanup(&app);
}
_ => {}
}
// 按动作类型选择性刷新,避免无关动作(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(())
}
/// 隐藏托盘菜单窗口(前端调用)
#[tauri::command]
pub async fn tray_menu_hide(app: AppHandle) -> Result<(), String> {
hide_tray_menu(&app);
Ok(())
}
/// 读取音乐控制条状态(托盘菜单显示时 / 可见期间轮询)。
#[tauri::command]
pub fn tray_music_state(app: AppHandle) -> MusicState {
get_music_state(&app)
}
/// 托盘音乐控制条动作。
///
/// 播放语义(队列、洗牌、单曲循环等)都在前端,托盘只负责转发:
/// - 播放/暂停/上下首/切换播放顺序 → [`SMTC_BUTTON_EVENT`] 转给主窗口前端(`feiniuStore`)执行;
/// - 音量与静音**直接改 Rust 侧引擎**(拖动滑块要即时出声,不能等一轮事件往返),
/// 改完把权威值经 [`TRAY_MUSIC_VOLUME_EVENT`] 广播给前端,由它更新 ref 并落盘。
///
/// `action`:`toggle` | `play` | `pause` | `next` | `prev` | `toggle-mode` | `volume` | `toggle-mute`。
/// `level`:仅 `volume` 需要(0.0~1.0)。
#[tauri::command]
pub fn tray_music_control(
app: AppHandle,
action: String,
level: Option<f32>,
) -> Result<(), String> {
if action == "volume" || action == "toggle-mute" {
let engine = app.try_state::<AudioEngine>().ok_or("播放引擎未初始化")?;
let (cur, muted) = engine.volume();
if action == "volume" {
let v = level.ok_or("volume 动作缺少 level")?.clamp(0.0, 1.0);
// 调到非零即解除静音(与手机遥控的音量语义一致)
engine.set_volume(v, if v > 0.0 { false } else { muted });
} else {
engine.set_volume(cur, !muted);
}
let (volume, muted) = engine.volume();
return app
.emit(TRAY_MUSIC_VOLUME_EVENT, TrayVolumeState { volume, muted })
.map_err(|e| e.to_string());
}
let name = match action.as_str() {
"play" => "play",
"pause" => "pause",
// 无当前会话时按下「播放/暂停」应重新起播,故按引擎真实态决定
"toggle" => {
if get_music_state(&app).playing {
"pause"
} else {
"play"
}
}
"next" => "next",
"prev" => "prev",
// 播放顺序(列表循环 / 单曲循环 / 随机)由前端维护,这里只转发
"toggle-mode" => "toggle-mode",
other => return Err(format!("未知的音乐控制动作: {other}")),
};
app.emit(SMTC_BUTTON_EVENT, name).map_err(|e| e.to_string())
}
/// 前端测量内容高度后调用:调整窗口大小、精确定位、然后显示。
/// 这样窗口从一开始就是正确尺寸和位置,不会出现间隙。
#[tauri::command]
pub async fn tray_menu_ready(content_height: f64, app: AppHandle) -> Result<(), String> {
let win = app.get_webview_window(TRAY_MENU_LABEL)
.ok_or("tray-menu window not found")?;
let (x, cursor_y, scr_top, scr_bottom, scale) = {
let layout = LAST_MENU_LAYOUT.lock().unwrap_or_else(|e| e.into_inner());
layout.unwrap_or((0.0, 1040.0, 0.0, 1080.0, 1.0))
};
// 可用高度:光标所在位置到屏幕顶部的空间(菜单底部对齐光标向上展开)。
// 不再用固定上限,内容多时窗口按内容完整撑开;仅当内容超过可用空间时才收窄
// (此时前端 .tray-menu-scroll 退化为滚动)。
let avail_logical = (cursor_y - scr_top).max(0.0) / scale;
let h = content_height.max(100.0).min(avail_logical.max(100.0));
// 调整窗口尺寸(物理像素,与物理坐标定位保持一致,避免混合 DPI 换算偏移)
let win_w_px = MENU_W * scale;
let win_h_px = h * scale;
let _ = win.set_size(tauri::Size::Physical(tauri::PhysicalSize {
width: win_w_px as u32,
height: win_h_px as u32,
}));
// 垂直:菜单底部对齐鼠标点击位置(向上弹出,物理坐标)。
// 用屏幕边界而非工作区 clamp,使菜单贴近/覆盖任务栏上的鼠标位置,
// 而不是被工作区底部(任务栏顶部)截断后整体出现在任务栏上方。
let y = (cursor_y - win_h_px).max(scr_top).min(scr_bottom - win_h_px);
let pos = tauri::Position::Physical(tauri::PhysicalPosition {
x: x as i32,
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());
}
// 位置与尺寸先交给一次原生 SetWindowPos 落位:窗口隐藏时,上面的 set_size/set_position
// 不保证在紧随其后的 show 之前生效,首次弹出会沿用预创建时的旧高度——表现为
// 「第一次高度不对、收起后再开正常」。原生调用同步返回,窗口已处于目标位置与尺寸。
// 显示仍走 Tauri 的 show():它才会做 tao 的可见性/激活/Z 序处理(直接 SWP_SHOWWINDOW
// 会让菜单掉到任务栏后面,且窗口拿不到焦点,失焦自动关闭随之失效)。
#[cfg(windows)]
if let Ok(hwnd) = win.hwnd() {
crate::win32_util::set_bounds(
hwnd.0 as isize,
x as i32,
y as i32,
win_w_px as i32,
win_h_px as i32,
);
}
let _ = win.show();
let _ = win.set_focus();
Ok(())
}
/// 获取当前代理组名
async fn get_proxy_group(app: &AppHandle) -> Option<String> {
let mihomo = app.state::<MihomoManager>();
let proxies = mihomo.get_proxies().await.ok()?;
let (group, _, _) = parse_main_group(&proxies)?;
Some(group)
}
// ===== 代理开启/关闭 =====
async fn enable_proxy(app: &AppHandle) -> Result<(), String> {
let mihomo = app.state::<MihomoManager>();
let pm = app.state::<ProcessManager>();
// 1. 启动 mihomo(如果未运行)
if !is_proxy_running(app) {
let params = mihomo.prepare_for_start(app)?;
pm.start(params)?;
// 等待 API 就绪
if !wait_for_mihomo_api(&mihomo, 10_000).await {
return Err("mihomo API 启动超时".into());
}
}
// 2. 获取节点并择优:遵循自动切换的目标组与地区筛选(关闭自动切换时退化为主组 + 全量节点)
let settings = mihomo.load_settings();
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;
}
send_notification(app, "代理已开启", &format!("当前节点: {} ({}ms)", name, delay));
}
Ok(None) | Err(_) => {
// 区分「无可用节点」与「全部超时」两种情况
let unavailable = {
let proxies = mihomo.get_proxies().await.ok();
let group_name: Option<String> = 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, "代理已开启", "所有候选节点均超时,未自动选择");
}
}
}
// 3. 开启系统代理
mihomo.enable_system_proxy()?;
Ok(())
}
async fn disable_proxy(app: &AppHandle) -> Result<(), String> {
let mihomo = app.state::<MihomoManager>();
let pm = app.state::<ProcessManager>();
// 关闭系统代理
mihomo.disable_system_proxy()?;
// 停止 mihomo
pm.stop("proxy")?;
send_notification(app, "代理已关闭", "mihomo 已停止,系统代理已清除");
Ok(())
}
// ===== 择优选择节点 =====
/// 并行测试所有节点延迟(更新 mihomo 内部 history)
async fn test_all_delays(app: &AppHandle) {
let mihomo = app.state::<MihomoManager>();
let proxies = match mihomo.get_proxies().await {
Ok(p) => p,
Err(_) => return,
};
let (_group, nodes, _now) = match parse_main_group(&proxies) {
Some(g) => g,
None => return,
};
use futures_util::future::join_all;
let futures: Vec<_> = nodes
.iter()
.map(|name| async {
let _ = mihomo
.test_delay(name, "https://www.gstatic.com/generate_204", 5000)
.await;
})
.collect();
join_all(futures).await;
}
// ===== 选择代理节点并测试延迟 =====
async fn select_proxy_node(app: &AppHandle, group: &str, name: &str) {
let mihomo = app.state::<MihomoManager>();
match mihomo.select_proxy(group, name).await {
Ok(()) => {
let delay = mihomo
.test_delay(name, "https://www.gstatic.com/generate_204", 5000)
.await
.ok();
let delay_text = match delay {
Some(0) => "超时".to_string(),
Some(d) => format!("{}ms", d),
None => "未测速".to_string(),
};
send_notification(app, "节点已切换", &format!("{}\n延迟: {}", name, delay_text));
}
Err(e) => {
crate::logger::log_error("tray", &format!("切换节点失败: {}", e));
send_notification(app, "切换节点失败", &e);
}
}
}
// ===== 等待 mihomo API 就绪 =====
async fn wait_for_mihomo_api(mihomo: &MihomoManager, timeout_ms: u64) -> bool {
let start = std::time::Instant::now();
while start.elapsed().as_millis() < timeout_ms as u128 {
if mihomo.get_version().await.is_ok() {
return true;
}
tokio::time::sleep(std::time::Duration::from_millis(500)).await;
}
false
}
// ===== 重启 Kernel =====
async fn restart_kernel(app: &AppHandle) -> Result<(), String> {
let monitor = app.state::<MonitorKernel>();
let pm = app.state::<ProcessManager>();
// 停止当前 Kernel
monitor.stop_subscription(app).await;
let _ = pm.stop("monitor");
// 等待端口释放
tokio::time::sleep(std::time::Duration::from_millis(800)).await;
// 重新启动
monitor.start_with_subscription(app).await?;
send_notification(app, "Kernel 已重启", "ThingHK 监控内核已重新启动");
Ok(())
}
// ===== Windows 通知 =====
fn send_notification(app: &AppHandle, title: &str, message: &str) {
use tauri_plugin_notification::NotificationExt;
let _ = app
.notification()
.builder()
.title(title)
.body(message)
.show();
}
// ===== 退出入口 =====
/// 托盘菜单"退出"调用。
/// 资源清理统一收敛到 RunEvent::ExitRequested(覆盖所有退出路径),此处仅请求退出,
/// 避免清理逻辑双份执行(monitor 的 cleanup 涉及子进程/网络,重复执行有竞态风险)。
pub fn quit_cleanup(app: &AppHandle) {
app.exit(0);
}
// ===== 创建托盘 =====
/// 创建自定义托盘(在 setup 中调用)
/// 不使用原生菜单,改用 WebviewWindow 弹窗实现自定义风格。
pub fn create_tray_menu(app: &AppHandle) -> Result<(), tauri::Error> {
let _tray = TrayIconBuilder::with_id("main")
.icon(app.default_window_icon().unwrap().clone())
.tooltip("Thing")
.on_tray_icon_event(|tray, event| {
let app = tray.app_handle().clone();
match event {
TrayIconEvent::Click {
button: MouseButton::Left,
..
} => {
// 左键:显示主窗口(强制置前,绕过前台锁定)
focus_main_window(&app);
}
TrayIconEvent::Click {
button: MouseButton::Right,
position,
..
} => {
// 右键:显示自定义菜单窗口(使用事件中的鼠标坐标)
let cursor = (position.x, position.y);
show_tray_menu(&app, cursor);
}
_ => {}
}
})
.build(app)?;
// 预创建隐藏的菜单窗口,让前端提前渲染主题和内容,右键时直接 show 无延迟
precreate_tray_menu_window(app);
Ok(())
}