1161 lines
44 KiB
Rust
1161 lines
44 KiB
Rust
//! 翻译模块 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,
|
||
}
|
||
}
|