//! 翻译模块 Tauri 命令层。 //! //! 这一层刻意保持"薄":只做参数整形、校验与错误归类,业务编排都在 //! [`super::TranslateManager`]、各引擎实现与 [`super::popup`] 里。 //! //! 两条安全约定: //! - **不存在读取 API Key 明文的命令**。列表接口只回传「是否已配置」与掩码字符串, //! 写入走 `translate_secret_set`,删除走 `translate_secret_clear`。 //! - **写剪贴板走 Rust**(`translate_copy_text`),不让前端用 `navigator.clipboard`: //! 取词悬浮窗是 NOACTIVATE 窗口,浏览器对「无用户激活」的剪贴板写入会拒绝, //! 走 Rust 既可靠,也顺带把这次写入登记进抑制表、不污染剪贴板历史。 use serde::{Deserialize, Serialize}; use specta::Type; use tauri::{AppHandle, Manager, State}; use super::engines::{EngineRequest, ErrorKind, TranslateError, TranslateMode, TranslateResult}; use super::history::HistoryItem; use super::settings::TranslateEngineConfig; use super::{engine_secret_key, popup, TranslateManager, TranslateSettings}; /// 引擎实例的前端视图:配置 + 派生状态(密钥是否已配、是否可用)。 /// /// 拆成「config + 派生」而不是直接回传配置,是为了让前端保存时能原样回传 /// `view.config`,不必自己去拼装结构,也不会误把派生字段写回配置。 #[derive(Debug, Clone, Serialize, Type)] #[serde(rename_all = "camelCase")] pub struct EngineView { pub config: TranslateEngineConfig, /// 是否已在系统凭据管理器中配置密钥 pub has_api_key: bool, /// 密钥掩码(未配置时为空串) pub api_key_masked: String, /// 是否已具备发起翻译的完整配置 pub ready: bool, /// 不可用原因(ready 为 true 时为空) pub issue: Option, } /// 引擎连通性自检结果。 /// /// 与其它命令不同,这里**失败也返回 Ok**:测试失败是「数据」而不是「命令异常」, /// 前端要显示具体原因,不该走 try/catch 分支。 #[derive(Debug, Clone, Serialize, Type)] #[serde(rename_all = "camelCase")] pub struct EngineTestResult { pub ok: bool, pub latency_ms: u64, pub message: String, /// 失败时的错误分类(成功时为 None) pub error_kind: Option, /// 上游原始响应片段(已截断) pub detail: Option, } /// 单次翻译请求参数。 #[derive(Debug, Clone, Deserialize, Type)] #[serde(rename_all = "camelCase")] pub struct TranslateRunParams { pub text: String, /// 源语言代码,"auto" 或省略表示自动检测 #[serde(default)] pub from: Option, /// 目标语言代码(如 zh-Hans) #[serde(default)] pub to: Option, /// 目标语言自然语言全称(如 简体中文),提示词用 #[serde(default)] pub to_label: Option, /// 源语言自然语言全称,仅显式指定源语言时有意义 #[serde(default)] pub from_label: Option, /// 指定引擎实例 id;省略或 "auto" 表示按优先级自动(含降级) #[serde(default)] pub engine_id: Option, /// 模式:"translate"(默认)| "polish" | "explain" | "summarize" #[serde(default)] pub mode: Option, /// 记入历史时的来源:"manual"(主面板)| "selection" | "clipboard" | "screenshot" #[serde(default)] pub via: Option, /// 是否写入历史。默认 true;**多引擎对比与预览必须传 false**。 #[serde(default)] pub record: Option, } // ===== 设置 ===== /// 读取翻译设置 #[tauri::command] #[specta::specta] pub fn translate_get_settings(state: State<'_, TranslateManager>) -> Result { Ok(state.load_settings()) } /// 保存翻译设置。 /// /// 保存后立即重新应用全局快捷键:快捷键改动若不能即时生效,用户会以为「设置没保存」, /// 而重新注册本身是幂等的(内部先注销旧的)。快捷键注册失败**不当作保存失败**—— /// 设置已经落盘了,把失败原因作为返回的错误信息告知即可。 #[tauri::command] #[specta::specta] pub fn translate_save_settings( app: AppHandle, state: State<'_, TranslateManager>, settings: TranslateSettings, ) -> Result<(), String> { // 容量上限现在由设置页暴露,调小之后必须立刻生效:否则用户设成 500、 // 回到历史页看到的仍是 2000 条,只会以为设置没保存。只在**调小**时淘汰—— // 调大或与历史无关的设置改动不需要跑这次索引扫描。 let previous_max = state.load_settings().history.max_items; state.save_settings(&settings)?; if settings.history.max_items < previous_max { if let Some(history) = state.history() { history.prune_to_max(settings.history.max_items as i64); } } match popup::apply_shortcuts(&app) { Ok(()) => Ok(()), Err(e) => { crate::logger::log_warn("translate", &format!("快捷键应用失败: {e}")); Err(format!("设置已保存,但快捷键注册失败:{e}")) } } } /// 按当前设置重新注册全局快捷键(设置页改动后或启动时调用) #[tauri::command] #[specta::specta] pub fn translate_apply_shortcuts(app: AppHandle) -> Result<(), String> { popup::apply_shortcuts(&app) } /// 记住划词悬浮窗里选的语言(源 / 目标)。 /// /// 弹窗是独立窗口且**收不到键盘事件**(非激活窗口不持有焦点),所有交互只能用鼠标, /// 因此语言切换做成了循环按钮而不是下拉;切换结果必须落盘,否则用户每次划词都要重选一遍 /// ——对「MyMemory 必须显式源语言」这类源来说,等于每次都得手动指定。 /// /// 刻意不重新注册快捷键:这里只改弹窗外观相关的字段,走一遍快捷键注册是白费功夫, /// 还可能在注册失败时把一个无关的错误抛给前端。 #[tauri::command] #[specta::specta] pub fn translate_popup_prefs_set( state: State<'_, TranslateManager>, source_lang: String, target_lang: String, ) -> Result<(), String> { let mut settings = state.load_settings(); settings.popup.source_lang = source_lang.trim().to_string(); settings.popup.target_lang = target_lang.trim().to_string(); state.save_settings(&settings) } // ===== 引擎管理 ===== /// 列出引擎实例(含密钥状态与可用性)。 /// /// 返回**本模块 free/cloud 引擎 + 全局 AI 供应商**(AI 转换为 kind = "ai"), /// 供工作台选择与「默认引擎」下拉使用。AI 的增删改走主设置 → AI 服务。 #[tauri::command] #[specta::specta] pub async fn translate_engines_list( state: State<'_, TranslateManager>, ) -> Result, String> { Ok(state.all_engines().iter().map(to_view).collect()) } /// 新增或更新一个**非 AI** 引擎实例(按 id upsert)。 /// /// AI 引擎(kind = "ai")由主设置 → AI 服务管理,这里显式拒绝, /// 避免出现「翻译设置里改了一份、主设置里还是旧的」的双源分裂。 /// /// 校验 id:它会进入凭据键(`translate-engine-`),含特殊字符会让键名难以排查, /// 因此限定为字母/数字/下划线/短横线。 #[tauri::command] #[specta::specta] pub fn translate_engine_save( state: State<'_, TranslateManager>, config: TranslateEngineConfig, ) -> Result<(), String> { if config.kind == "ai" { return Err( "AI 引擎已移至「常规设置 → AI 服务」统一管理,请到主设置中修改".to_string(), ); } // 先把 id 取成自有值:下面要整体移动 config,不能再持有对 config.id 的借用 let id = config.id.trim().to_string(); if id.is_empty() { return Err("引擎标识不能为空".to_string()); } if !id .chars() .all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '-') { return Err("引擎标识只能包含字母、数字、下划线和短横线".to_string()); } if config.name.trim().is_empty() { return Err("引擎名称不能为空".to_string()); } let mut settings = state.load_settings(); let mut next = config; next.id = id; match settings.engines.iter_mut().find(|e| e.id == next.id) { Some(slot) => *slot = next, None => settings.engines.push(next), } settings.engines.sort_by_key(|e| e.priority); state.save_settings(&settings) } /// 删除引擎实例(连同它在系统凭据管理器中的密钥)。 /// AI 引擎请到主设置 → AI 服务删除。 #[tauri::command] #[specta::specta] pub fn translate_engine_delete(state: State<'_, TranslateManager>, id: String) -> Result<(), String> { if state.all_engines().iter().any(|e| e.id == id && e.kind == "ai") { return Err("AI 引擎请在「常规设置 → AI 服务」中删除".to_string()); } let mut settings = state.load_settings(); let before = settings.engines.len(); settings.engines.retain(|e| e.id != id); if settings.engines.len() == before { return Err(format!("找不到引擎实例「{id}」")); } // 默认引擎指向被删除的实例时改为「自动」,比静默改写为别的实例更符合预期 if settings.default_engine_id == id { settings.default_engine_id = "auto".to_string(); } state.save_settings(&settings)?; // 凭据删除失败只记日志:引擎已从配置里移除,残留一条孤儿凭据不影响使用 if let Err(e) = crate::secrets::secret_delete(&engine_secret_key(&id)) { crate::logger::log_error("translate", &format!("删除引擎「{id}」的密钥失败: {e}")); } Ok(()) } /// 写入引擎的 API Key(明文只在此处进入系统凭据管理器,永不回写配置文件)。 /// /// AI 供应商的 Key 写 `ai-provider-*`;free/cloud 写 `translate-engine-*`。 #[tauri::command] #[specta::specta] pub fn translate_secret_set( state: State<'_, TranslateManager>, id: String, api_key: String, ) -> Result<(), String> { let engines = state.all_engines(); let cfg = engines .iter() .find(|e| e.id == id) .ok_or_else(|| format!("找不到引擎实例「{id}」"))?; let key = if cfg.kind == "ai" { crate::ai::provider_secret_key(&id) } else { engine_secret_key(&id) }; let value = api_key.trim(); if value.is_empty() { return crate::secrets::secret_delete(&key); } crate::secrets::secret_write(&key, value) } /// 清除引擎的 API Key(按 kind 选凭据键,与 write 对称)。 #[tauri::command] #[specta::specta] pub fn translate_secret_clear( state: State<'_, TranslateManager>, id: String, ) -> Result<(), String> { let engines = state.all_engines(); let is_ai = engines.iter().any(|e| e.id == id && e.kind == "ai"); let key = if is_ai { crate::ai::provider_secret_key(&id) } else { engine_secret_key(&id) }; crate::secrets::secret_delete(&key) } /// 把某个全局 AI 供应商加入翻译候选,或更新它的**翻译场景参数**(启用 / 优先级 / 超时 / 提示词)。 /// /// 连接配置(Base URL、模型、密钥)在主设置 → AI 服务;这里只写 translate 自己的编排语义。 /// 首次调用即「加入」——`ai_params` 有记录就代表该供应商参与翻译候选。 #[tauri::command] #[specta::specta] pub fn translate_ai_params_save( state: State<'_, TranslateManager>, params: super::TranslateAiParams, ) -> Result<(), String> { let id = params.provider_id.trim().to_string(); if id.is_empty() { return Err("供应商标识不能为空".to_string()); } let ai = crate::ai::AiManager::load_settings_sync(&state.data_dir); if ai.provider(&id).is_none() { return Err(format!( "全局 AI 供应商「{id}」不存在,请先在主设置 → AI 服务中配置" )); } let mut settings = state.load_settings(); let next = super::TranslateAiParams { provider_id: id, enabled: params.enabled, priority: params.priority, timeout_ms: params.timeout_ms.max(1_000), system_prompt: params.system_prompt, }; match settings.ai_params_mut(&next.provider_id) { Some(slot) => *slot = next, None => settings.ai_params.push(next), } settings.ai_params.sort_by_key(|p| p.priority); state.save_settings(&settings) } /// 把某个全局 AI 供应商**移出翻译候选**(供应商本身与它的密钥都不动)。 /// /// 只删 `ai_params` 里的这条记录。默认引擎指向它时改为「自动」——否则默认引擎会指向 /// 一个已经不在候选里的 id,用户看到的是「设置对了但翻译报找不到引擎」。 #[tauri::command] #[specta::specta] pub fn translate_ai_engine_remove( state: State<'_, TranslateManager>, provider_id: String, ) -> Result<(), String> { let id = provider_id.trim().to_string(); if id.is_empty() { return Err("供应商标识不能为空".to_string()); } let mut settings = state.load_settings(); let before = settings.ai_params.len(); settings.ai_params.retain(|p| p.provider_id != id); if settings.ai_params.len() == before { return Err(format!("供应商「{id}」不在翻译候选里")); } if settings.default_engine_id == id { settings.default_engine_id = "auto".to_string(); } state.save_settings(&settings) } /// 连通性自检:用前端传入的配置测试(**不落盘**)。 /// /// 与「按 id 测已保存配置」的区别:编辑草稿里的 Base URL / 模型改动还没保存时, /// 按 id 测的是旧配置——用户改完地址立刻点「测试」会得到「未配置服务地址」, /// 让人以为自己的输入没生效。这里直接收草稿配置,让「改完立刻测」成立; /// API Key 仍按 `config.id` 从系统凭据管理器读取(引擎需先保存过一次才能配 Key)。 #[tauri::command] #[specta::specta] pub async fn translate_engine_test_config( state: State<'_, TranslateManager>, config: TranslateEngineConfig, ) -> Result { if config.id.trim().is_empty() || config.name.trim().is_empty() { return Ok(failure( TranslateError::config("引擎标识或名称不能为空,请先保存一次引擎"), 0, )); } let engine = match state.build(&config).await { Ok(e) => e, Err(e) => return Ok(failure(e, 0)), }; let started = std::time::Instant::now(); match engine.test().await { Ok(message) => Ok(EngineTestResult { ok: true, latency_ms: started.elapsed().as_millis() as u64, message, error_kind: None, detail: None, }), Err(e) => Ok(failure(e, started.elapsed().as_millis() as u64)), } } /// 拉取上游模型列表(应对「上游改名」导致预设失效的自救入口)。 /// 免密钥源没有模型概念,返回空列表。AI 供应商从全局列表按 id 查找。 #[tauri::command] #[specta::specta] pub async fn translate_engine_models( state: State<'_, TranslateManager>, id: String, ) -> Result, String> { let cfg = state .all_engines() .into_iter() .find(|e| e.id == id) .ok_or_else(|| format!("找不到引擎实例「{id}」"))?; let engine = state.build(&cfg).await.map_err(|e| e.message)?; engine.list_models().await.map_err(|e| e.message) } // ===== 翻译 ===== /// 执行一次翻译。 /// /// 错误以结构化的 [`TranslateError`] 返回,前端按 `kind` 分支给出不同提示 /// (改 Key / 查网络 / 稍后重试是三件不同的事)。 #[tauri::command] #[specta::specta] pub async fn translate_run( state: State<'_, TranslateManager>, params: TranslateRunParams, ) -> Result { let req = EngineRequest { text: params.text, from: normalize(params.from, "auto"), to: normalize(params.to, String::new()), to_label: normalize(params.to_label, String::new()), from_label: normalize(params.from_label, String::new()), mode: TranslateMode::parse(params.mode.as_deref()), image_png: None, via: normalize( params.via, "manual", ) .replace(|c: char| !c.is_ascii_alphanumeric(), ""), }; let record = params.record.unwrap_or(true); state.run(req, params.engine_id.as_deref(), record).await } /// 把文本写入系统剪贴板(供主面板与取词悬浮窗复制译文)。 /// 写入会登记进剪贴板抑制表,因此不会在剪贴板历史里留下一条「自己复制自己」的记录。 #[tauri::command] #[specta::specta] pub fn translate_copy_text(app: AppHandle, text: String) -> Result<(), String> { if text.is_empty() { return Err("没有可复制的内容".to_string()); } if !crate::clipboard::reader::write_text(&text) { return Err("写入剪贴板失败".to_string()); } if let Some(manager) = app.try_state::() { manager.suppress_current_sequence(); } Ok(()) } // ===== 划词取词与悬浮窗 ===== /// 预览取词悬浮窗:用固定样例文本走一遍完整链路(窗口定位、非激活显示、翻译)。 /// /// 为什么不提供「测试取词」按钮:从应用内触发取词必然失败——前台窗口是本应用自己, /// Ctrl+C 会落到一个没有选区的窗口上。要验证取词只能去别的应用里按快捷键。 #[tauri::command] #[specta::specta] pub fn translate_preview_popup(app: AppHandle, state: State<'_, TranslateManager>) { let settings = state.load_settings(); popup::show(&app, popup::preview_payload(&settings)); } /// 悬浮窗挂载完成(仅兜底创建路径真正显示) #[tauri::command] #[specta::specta] pub fn translate_popup_ready(app: AppHandle) { popup::ready(&app); } /// 译文回填:把译文写入剪贴板并模拟 Ctrl+V 粘贴回原窗口,替换原选区。 /// /// 只对划词来源有意义——剪贴板/截图来源没有「原处」可回填。 /// 能成立的前提是**悬浮窗从不抢焦点**(非激活窗口),因此原窗口的键盘焦点与选区 /// 在翻译期间一直保持原样。回填前校验原窗口仍然存活,避免粘贴进毫不相干的窗口。 #[tauri::command] #[specta::specta] pub fn translate_paste_back(app: AppHandle, text: String, hwnd: i64) -> Result<(), String> { if text.trim().is_empty() { return Err("没有可回填的译文".to_string()); } #[cfg(windows)] { use windows_sys::Win32::UI::WindowsAndMessaging::IsWindow; if hwnd == 0 || unsafe { IsWindow(hwnd as _) } == 0 { return Err("原窗口已关闭或不可用,无法回填".to_string()); } } #[cfg(not(windows))] let _ = hwnd; if !crate::clipboard::reader::write_text(&text) { return Err("写入剪贴板失败".to_string()); } if let Some(manager) = app.try_state::() { manager.suppress_current_sequence(); } super::popup::hide(&app); // 延迟粘贴:等悬浮窗隐藏完成、焦点回到原窗口 std::thread::spawn(move || { std::thread::sleep(std::time::Duration::from_millis(200)); super::capture::send_ctrl_v(); }); Ok(()) } /// 隐藏悬浮窗 #[tauri::command] #[specta::specta] pub fn translate_popup_hide(app: AppHandle) { popup::hide(&app); } /// 弹窗编辑模式开关(原文编辑框 / 译文选中复制需要键盘焦点)。 /// /// 弹窗平时是 NOACTIVATE 的(不抢焦点、收不到键盘事件);用户点击原文编辑区时 /// 前端请求 `enable=true`,临时移除 NOACTIVATE 并把弹窗推到前台。隐藏与下次显示 /// 时由后端自动恢复,不依赖前端记得关。 #[tauri::command] #[specta::specta] pub fn translate_popup_edit_mode(app: AppHandle, enable: bool) -> Result<(), String> { popup::set_edit_mode(&app, enable) } /// 钉住弹窗:钉住后点击外部与长时间停留都不再自动收起,只能手动关闭。 /// 弹窗收起时后端自动复位钉住状态。 #[tauri::command] #[specta::specta] pub fn translate_popup_set_pinned(pinned: bool) { popup::set_pinned(pinned); } /// 按内容自适应悬浮窗尺寸(前端测高后调用)。 /// /// 返回前端根节点应使用的 max-height(逻辑像素,来自工作区而非窗口自身—— /// 用 100vh 会形成收缩反馈循环,见 `popup::resize` 的注释);0 表示不限制。 #[tauri::command] #[specta::specta] pub fn translate_popup_resize(app: AppHandle, width: f64, height: f64) -> f64 { popup::resize(&app, width, height) } // ===== 截图翻译 ===== /// 截图翻译的结果摘要(展示交给悬浮窗,这里供调用方与历史记录使用) #[derive(Debug, Clone, Serialize, Type)] #[serde(rename_all = "camelCase")] pub struct ScreenshotOutcome { /// 本地 OCR 的识别文本(视觉直译模式为空) pub ocr_text: String, /// OCR 使用的语言(BCP-47,本地模式) pub ocr_lang: String, pub engine_name: String, pub translated: bool, } /// 翻译一个已框选的屏幕区域。 /// /// 由截图覆盖层的「翻译」按钮调用(选区确认后)。流程: /// 本地模式 → 裁剪 → 本地 OCR → 识别文本交给悬浮窗(弹窗自己走翻译引擎,语言表在前端); /// 视觉模式 → 裁剪 → 图像直接交给支持图像输入的模型,识别与翻译一步完成。 /// /// 识别/翻译失败**也弹窗**:用户视线就在选区那里,失败原因出现在视线里 /// 比回到主界面看 toast 有用得多。OCR 在阻塞线程池执行(WinRT 的 `get()` 会阻塞)。 #[tauri::command] #[specta::specta] pub async fn translate_screenshot_region( app: AppHandle, state: State<'_, TranslateManager>, x: i32, y: i32, w: i32, h: i32, to_label: Option, ) -> Result { if w < 2 || h < 2 { return Err(TranslateError::empty()); } let settings = state.load_settings(); let sc = settings.screenshot.clone(); // 结果贴在选区右下角;工作区放不下时由悬浮窗自动翻侧/钳制 let (anchor_x, anchor_y) = (x + w, y + h); // ===== 视觉直译:跳过本地 OCR,识别 + 翻译一步完成 ===== if sc.ocr_mode == "vision" { // 配置类失败也弹窗:覆盖层已隐藏,静默早退会让用户点了按钮毫无反应 let cfg = match pick_vision_engine(&state, &settings) { Ok(c) => c, Err(e) => { popup::show_screenshot_error( &app, &settings, e.message.clone(), anchor_x, anchor_y, ); return Err(e); } }; let engine = match state.build(&cfg).await { Ok(e) => e, Err(e) => { popup::show_screenshot_error( &app, &settings, e.message.clone(), anchor_x, anchor_y, ); return Err(e); } }; let png = match tauri::async_runtime::spawn_blocking(move || { crop_region_png_blocking(x, y, w, h) }) .await { Ok(Ok(bytes)) => bytes, Ok(Err(e)) => { popup::show_screenshot_error( &app, &settings, e.message.clone(), anchor_x, anchor_y, ); return Err(e); } Err(e) => { let err = TranslateError::new(ErrorKind::Unknown, format!("裁剪任务失败: {e}")); popup::show_screenshot_error( &app, &settings, err.message.clone(), anchor_x, anchor_y, ); return Err(err); } }; let image_png = { use base64::Engine as _; base64::engine::general_purpose::STANDARD.encode(&png) }; let req = EngineRequest { text: String::new(), from: "auto".to_string(), to: settings.default_target.clone(), to_label: normalize(to_label, settings.default_target.clone()), from_label: String::new(), mode: TranslateMode::Translate, image_png: Some(image_png), via: "screenshot".to_string(), }; let result = engine.translate(&req).await.map_err(|e| { popup::show_screenshot_error(&app, &settings, e.message.clone(), anchor_x, anchor_y); e })?; // 视觉直译绕过了 state.run(),历史必须在这里补记(原文以占位说明来源) if settings.history.enabled { if let Some(h) = state.history() { let _ = h.record( "auto", &settings.default_target, &cfg.id, &result.engine_name, "(屏幕截图)", &result.text, "screenshot", result.latency_ms as i64, ); h.prune_to_max(settings.history.max_items as i64); } } let engine_name = cfg.name.clone(); popup::show_screenshot_result( &app, &settings, String::new(), Some(format!("图片已上传至 {engine_name}")), Some(result), true, anchor_x, anchor_y, ); return Ok(ScreenshotOutcome { ocr_text: String::new(), ocr_lang: String::new(), engine_name, translated: true, }); } // ===== 本地 OCR:识别文本交给悬浮窗,翻译由弹窗(持有语言表)完成 ===== let ocr_lang = sc.ocr_lang.clone(); let ocr = tauri::async_runtime::spawn_blocking(move || { crop_region_png_blocking(x, y, w, h).and_then(|png| { let lang = if ocr_lang.trim().is_empty() || ocr_lang.trim() == "auto" { None } else { Some(ocr_lang.as_str()) }; super::ocr::ocr_png(&png, lang) }) }) .await .map_err(|e| TranslateError::new(ErrorKind::Unknown, format!("OCR 任务失败: {e}")))? .map_err(|e| { popup::show_screenshot_error(&app, &settings, e.message.clone(), anchor_x, anchor_y); e })?; let ocr_text = ocr .lines .iter() .map(|l| l.text.as_str()) .collect::>() .join("\n"); if ocr_text.trim().is_empty() { popup::show_screenshot_error( &app, &settings, "未识别到文字:截图里可能没有文本,或当前识别语言对这种字体效果不佳".to_string(), anchor_x, anchor_y, ); return Ok(ScreenshotOutcome { ocr_text: String::new(), ocr_lang: ocr.lang, engine_name: "本地 OCR".to_string(), translated: false, }); } let note = format!("本地识别 · {}", ocr.lang); popup::show_screenshot_result( &app, &settings, ocr_text.clone(), Some(note), None, sc.auto_translate, anchor_x, anchor_y, ); Ok(ScreenshotOutcome { ocr_text, ocr_lang: ocr.lang, engine_name: "本地 OCR".to_string(), translated: sc.auto_translate, }) } /// 列出系统可用的 OCR 语言(设置页据此提示语言包缺失)。 /// /// **必须带超时**:`OcrEngine.AvailableRecognizerLanguages` 在部分机器上会卡住不返回 /// (WinRT 激活失败时既不成功也不报错)。直接在阻塞线程池上等它,设置页的按钮就会 /// 永远转圈——用户只能重启应用。这里改为在**独立线程**上执行并用 `recv_timeout` 兜底: /// 超时就当失败,让前端显示可重试的错误,而不是把一个线程永远挂在 WinRT 里。 #[tauri::command] #[specta::specta] pub async fn translate_ocr_languages() -> Result, String> { const OCR_LANG_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(8); let outcome = tauri::async_runtime::spawn_blocking(move || { let (tx, rx) = std::sync::mpsc::channel(); std::thread::spawn(move || { let _ = tx.send(super::ocr::available_languages()); }); match rx.recv_timeout(OCR_LANG_TIMEOUT) { Ok(result) => result.map_err(|e| e.to_string()), Err(_) => Err( "读取系统 OCR 语言超时:Windows OCR 无响应。\ 识别语言可填 auto(跟随系统语言),或稍后重试。" .to_string(), ), } }) .await .map_err(|e| format!("读取 OCR 语言失败: {e}"))?; outcome } /// 裁剪选区并解码为 PNG 字节(阻塞,须在阻塞线程池调用) fn crop_region_png_blocking(x: i32, y: i32, w: i32, h: i32) -> Result, TranslateError> { use base64::Engine as _; let cropped = crate::screenshot::capture::crop_stored(x, y, w, h) .map_err(|e| TranslateError::new(ErrorKind::Unknown, format!("裁剪选区失败: {e}")))?; base64::engine::general_purpose::STANDARD .decode(cropped.png_base64.as_bytes()) .map_err(|e| TranslateError::parse(format!("解码截图失败: {e}"))) } /// 视觉直译的引擎选择:优先默认引擎(若它声明支持图像输入),否则按优先级取第一个支持的。 /// 候选来自「本模块引擎 + 已加入翻译候选的 AI 供应商」。 fn pick_vision_engine( state: &TranslateManager, settings: &TranslateSettings, ) -> Result { let all = state.all_engines(); if let Some(cfg) = all.iter().find(|e| e.id == settings.default_engine_id) { if cfg.supports_vision && cfg.kind == "ai" { return Ok(cfg.clone()); } } all.into_iter() .filter(|c| c.supports_vision && c.kind == "ai" && c.enabled) .min_by_key(|c| c.priority) .ok_or_else(|| { TranslateError::config( "视觉直译需要一个支持图像输入的引擎:请在主设置 → AI 服务中勾选「图像输入」,\ 再在翻译设置里把它加入翻译候选", ) }) } // ===== 流式输出 ===== /// 流式请求自增序号(配合毫秒时间戳生成唯一 requestId) static STREAM_SEQ: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1); /// 在途流式请求的停止标志 static ACTIVE_STREAMS: std::sync::OnceLock>>> = std::sync::OnceLock::new(); fn active_streams() -> &'static std::sync::Mutex< std::collections::HashMap>, > { ACTIVE_STREAMS.get_or_init(|| std::sync::Mutex::new(std::collections::HashMap::new())) } /// 启动一次流式翻译,返回 requestId;增量与结果经事件下发。 /// /// 与 `translate_run` 的差异(刻意为之): /// - **降级只在「还没吐出任何内容」时发生**。降级发生在请求被拒绝的瞬间才有意义; /// 一旦已经输出了一半再换引擎重译,用户只会看到内容跳变。所以这里用 /// `produced` 标记首个 chunk 是否已下发:没产出且还有候选 → 静默换下一个源; /// 已产出或已是最后一个候选 → 把错误交给前端。 /// 这一条正是「MyMemory 需要显式源语言」这类配置类失败能在划词场景自动落到 /// DeepSeek 上的原因。 /// - **不透传 thinking**:翻译场景要低延迟,流式下更是如此。 /// /// **requestId 由前端在发请求前生成并经 `request_id` 参数传入**:本命令要等翻译 /// 结束才返回,chunk/done 事件全部先于 Promise 到达;若前端等返回值才知道 /// requestId,所有事件都会因对不上号被过滤(表现为「历史里有译文、界面空白」)。 /// 该参数为空时(旧调用方)回退到本地生成,行为兼容。 /// /// 停止:`translate_abort(requestId)` 置位停止标志 → 命令层放弃转发并 drop 引擎 future /// → HTTP 流随之取消(而不是等下一块数据到来才发现被放弃)。 #[tauri::command] #[specta::specta] pub async fn translate_stream_start( app: AppHandle, state: State<'_, TranslateManager>, params: TranslateRunParams, request_id: Option, ) -> Result { use std::sync::atomic::{AtomicBool, Ordering}; use tauri::Emitter; let request_id = request_id .map(|s| s.trim().to_string()) .filter(|s| !s.is_empty() && s.chars().count() <= 64) .unwrap_or_else(|| { format!( "t{}-{}", chrono::Utc::now().timestamp_millis(), STREAM_SEQ.fetch_add(1, Ordering::Relaxed) ) }); let abort = std::sync::Arc::new(AtomicBool::new(false)); active_streams() .lock() .unwrap_or_else(|e| e.into_inner()) .insert(request_id.clone(), abort.clone()); let settings = state.load_settings(); let req = EngineRequest { text: params.text, from: normalize(params.from, "auto"), to: normalize(params.to, String::new()), to_label: normalize(params.to_label, String::new()), from_label: normalize(params.from_label, String::new()), mode: TranslateMode::parse(params.mode.as_deref()), image_png: None, via: normalize(params.via, "manual").replace(|c: char| !c.is_ascii_alphanumeric(), ""), }; let record = params.record.unwrap_or(true); let history = state.history(); let history_enabled = settings.history.enabled; let history_max = settings.history.max_items as i64; let candidates = state.resolve_candidates(params.engine_id.as_deref())?; let last_index = candidates.len().saturating_sub(1); let mut last_error: Option = None; for (index, cfg) in candidates.into_iter().enumerate() { let engine = match state.build(&cfg).await { Ok(e) => e, Err(e) => { // 装配失败(未接入的引擎类型等)直接换下一个候选 last_error = Some(e); continue; } }; let (tx, mut rx) = tokio::sync::mpsc::channel::(64); // 本次尝试是否已向前端吐出过内容(决定是否还能安全降级) let produced = std::sync::Arc::new(AtomicBool::new(false)); // 转发任务:事件 → 前端;Done 时记历史(需要 Arc 克隆,State 本身无法跨任务) let forward_app = app.clone(); let forward_history = history.clone(); let (req_text, from_lang, to_lang, via) = ( req.text.clone(), req.from.clone(), req.to.clone(), req.via.clone(), ); let forward_produced = produced.clone(); let forwarder = tauri::async_runtime::spawn(async move { while let Some(ev) = rx.recv().await { use super::engines::StreamEvent; let event = match &ev { StreamEvent::Chunk { .. } => { crate::constants::events::TRANSLATE_STREAM_CHUNK } StreamEvent::Done { .. } => crate::constants::events::TRANSLATE_STREAM_DONE, StreamEvent::Error { .. } => crate::constants::events::TRANSLATE_STREAM_ERROR, }; let _ = forward_app.emit(event, &ev); match ev { StreamEvent::Chunk { .. } => { forward_produced.store(true, Ordering::SeqCst); } StreamEvent::Done { result, .. } => { forward_produced.store(true, Ordering::SeqCst); if let (true, Some(h)) = (history_enabled && record, forward_history.as_ref()) { let _ = h.record( &from_lang, &to_lang, &result.engine_id, &result.engine_name, &req_text, &result.text, &via, result.latency_ms as i64, ); h.prune_to_max(history_max); } break; } StreamEvent::Error { .. } => break, } } }); // 引擎执行与「停止」信号竞争:select 败者被 drop,HTTP 流随之取消 let engine_fut = engine.translate_stream(&req, request_id.clone(), tx); let outcome = tokio::select! { res = engine_fut => res, _ = wait_for_abort(abort.clone()) => { forwarder.abort(); active_streams().lock().unwrap_or_else(|e| e.into_inner()).remove(&request_id); return Ok(request_id); } }; // 等转发任务收尾:Done 事件可能还排在通道里,提前返回会让前端的 // Promise 先于结果事件到达(表现为「已返回但没有译文」) let _ = forwarder.await; match outcome { Ok(()) => { active_streams() .lock() .unwrap_or_else(|e| e.into_inner()) .remove(&request_id); return Ok(request_id); } Err(e) => { crate::logger::log_warn( "translate", &format!( "流式翻译:引擎「{}」失败:{}(kind={:?})", cfg.name, e.message, e.kind ), ); let can_fallback = !produced.load(Ordering::SeqCst) && index < last_index && e.retryable(); if !can_fallback { active_streams() .lock() .unwrap_or_else(|e| e.into_inner()) .remove(&request_id); // 兜底通道:Promise 也会 reject,这里额外发事件是为了让「已发出 // requestId 之后才失败」的路径也有可靠出口 let _ = app.emit( crate::constants::events::TRANSLATE_STREAM_ERROR, super::engines::StreamEvent::Error { request_id: request_id.clone(), error: e.clone(), }, ); return Err(e); } last_error = Some(e); } } } active_streams() .lock() .unwrap_or_else(|e| e.into_inner()) .remove(&request_id); let err = last_error.unwrap_or_else(|| { TranslateError::config("没有已启用的翻译引擎,请先在翻译设置中启用至少一个") }); Err(err) } async fn wait_for_abort(flag: std::sync::Arc) { use std::sync::atomic::Ordering; loop { if flag.load(Ordering::SeqCst) { return; } tokio::time::sleep(std::time::Duration::from_millis(50)).await; } } /// 停止一次流式请求(requestId 不存在时静默成功) #[tauri::command] #[specta::specta] pub fn translate_abort(request_id: String) { use std::sync::atomic::Ordering; if let Some(flag) = active_streams() .lock() .unwrap_or_else(|e| e.into_inner()) .remove(&request_id) { flag.store(true, Ordering::SeqCst); } } // ===== 历史 ===== /// 分页列出历史(按时间倒序) #[tauri::command] #[specta::specta] pub fn translate_history_list( state: State<'_, TranslateManager>, offset: Option, limit: Option, query: Option, favorited_only: Option, ) -> Result, String> { let history = state.history().ok_or_else(|| "历史记录不可用".to_string())?; history.list( offset.unwrap_or(0).max(0), limit.unwrap_or(50).clamp(1, 200), query.as_deref(), favorited_only.unwrap_or(false), ) } #[tauri::command] #[specta::specta] pub fn translate_history_delete(state: State<'_, TranslateManager>, id: i64) -> Result<(), String> { let history = state.history().ok_or_else(|| "历史记录不可用".to_string())?; history.delete(id) } /// 清空全部历史(含收藏)。破坏性操作,前端需二次确认后调用。 #[tauri::command] #[specta::specta] pub fn translate_history_clear(state: State<'_, TranslateManager>) -> Result<(), String> { let history = state.history().ok_or_else(|| "历史记录不可用".to_string())?; history.clear() } #[tauri::command] #[specta::specta] pub fn translate_history_set_favorited( state: State<'_, TranslateManager>, id: i64, favorited: bool, ) -> Result<(), String> { let history = state.history().ok_or_else(|| "历史记录不可用".to_string())?; history.set_favorited(id, favorited) } // ===== 内部工具 ===== fn normalize(value: Option, fallback: impl Into) -> String { value .map(|v| v.trim().to_string()) .filter(|v| !v.is_empty()) .unwrap_or_else(|| fallback.into()) } fn failure(e: TranslateError, latency_ms: u64) -> EngineTestResult { EngineTestResult { ok: false, latency_ms, message: e.message.clone(), error_kind: Some(e.kind), detail: e.detail.clone(), } } /// 构造引擎视图并给出「是否可用」的判断。 /// /// 判断放在后端而不是前端:可用性取决于密钥是否存在、服务地址是否填了 /// (只有后端知道)。与其让前端根据 `hasApiKey` + `baseUrl` + `model` + `useProxy` /// 自己拼规则,不如只回答一个问题。 fn to_view( cfg: &TranslateEngineConfig, ) -> EngineView { let raw_key = super::engine_api_key_with_kind(&cfg.id, Some(cfg.kind.as_str())); let has_api_key = !raw_key.trim().is_empty(); let issue = match cfg.kind.as_str() { "ai" => { if cfg.base_url.trim().is_empty() { Some("未配置 Base URL".to_string()) } else if cfg.model.trim().is_empty() { Some("未选择模型".to_string()) } else if !has_api_key { Some("未配置 API Key".to_string()) } else { None } } "free" => match cfg.preset.as_str() { // LibreTranslate 是用户自部署的服务,地址是唯一硬性要求; // API Key 可选(部署启用 LT_API_KEYS 校验时才需要) "libretranslate" => { if cfg.base_url.trim().is_empty() { Some("未配置服务地址(自建 LibreTranslate 的 Base URL)".to_string()) } else { None } } "mymemory" => None, other => Some(format!("未接入的免密钥源「{other}」")), }, "cloud" => match cfg.preset.as_str() { "deepl" => None, other => Some(format!("未接入的云厂商源「{other}」")), }, other => Some(format!("未知的引擎类型「{other}」")), }; EngineView { config: cfg.clone(), has_api_key, api_key_masked: crate::secrets::mask(&raw_key), ready: issue.is_none() && cfg.enabled, issue, } }