Files
Thing/src-tauri/src/translate/commands.rs
T
2026-09-25 18:23:56 +08:00

1161 lines
44 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.
//! 翻译模块 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<String>,
}
/// 引擎连通性自检结果。
///
/// 与其它命令不同,这里**失败也返回 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<ErrorKind>,
/// 上游原始响应片段(已截断)
pub detail: Option<String>,
}
/// 单次翻译请求参数。
#[derive(Debug, Clone, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct TranslateRunParams {
pub text: String,
/// 源语言代码,"auto" 或省略表示自动检测
#[serde(default)]
pub from: Option<String>,
/// 目标语言代码(如 zh-Hans)
#[serde(default)]
pub to: Option<String>,
/// 目标语言自然语言全称(如 简体中文),提示词用
#[serde(default)]
pub to_label: Option<String>,
/// 源语言自然语言全称,仅显式指定源语言时有意义
#[serde(default)]
pub from_label: Option<String>,
/// 指定引擎实例 id;省略或 "auto" 表示按优先级自动(含降级)
#[serde(default)]
pub engine_id: Option<String>,
/// 模式:"translate"(默认)| "polish" | "explain" | "summarize"
#[serde(default)]
pub mode: Option<String>,
/// 记入历史时的来源:"manual"(主面板)| "selection" | "clipboard" | "screenshot"
#[serde(default)]
pub via: Option<String>,
/// 是否写入历史。默认 true;**多引擎对比与预览必须传 false**。
#[serde(default)]
pub record: Option<bool>,
}
// ===== 设置 =====
/// 读取翻译设置
#[tauri::command]
#[specta::specta]
pub fn translate_get_settings(state: State<'_, TranslateManager>) -> Result<TranslateSettings, String> {
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<Vec<EngineView>, String> {
Ok(state.all_engines().iter().map(to_view).collect())
}
/// 新增或更新一个**非 AI** 引擎实例(按 id upsert)。
///
/// AI 引擎(kind = "ai")由主设置 → AI 服务管理,这里显式拒绝,
/// 避免出现「翻译设置里改了一份、主设置里还是旧的」的双源分裂。
///
/// 校验 id:它会进入凭据键(`translate-engine-<id>`),含特殊字符会让键名难以排查,
/// 因此限定为字母/数字/下划线/短横线。
#[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<EngineTestResult, String> {
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<Vec<String>, 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<TranslateResult, TranslateError> {
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::<crate::clipboard::ClipboardManager>() {
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::<crate::clipboard::ClipboardManager>() {
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<String>,
) -> Result<ScreenshotOutcome, TranslateError> {
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::<Vec<_>>()
.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<Vec<String>, 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<Vec<u8>, 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<TranslateEngineConfig, TranslateError> {
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::Mutex<std::collections::HashMap<String, std::sync::Arc<std::sync::atomic::AtomicBool>>>> =
std::sync::OnceLock::new();
fn active_streams() -> &'static std::sync::Mutex<
std::collections::HashMap<String, std::sync::Arc<std::sync::atomic::AtomicBool>>,
> {
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<String>,
) -> Result<String, TranslateError> {
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<TranslateError> = 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::<super::engines::StreamEvent>(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<std::sync::atomic::AtomicBool>) {
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<i64>,
limit: Option<i64>,
query: Option<String>,
favorited_only: Option<bool>,
) -> Result<Vec<HistoryItem>, 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<String>, fallback: impl Into<String>) -> 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,
}
}