635 lines
21 KiB
Rust
635 lines
21 KiB
Rust
//! Tauri 命令：截图模块
|
||
//!
|
||
//! 命令清单：
|
||
//! - screenshot_capture_fullscreen：捕获虚拟屏并存入静态（不做 PNG 编码），返回捕获时刻光标坐标
|
||
//! - screenshot_get_fullscreen_bmp：取出全屏捕获的 BMP 原始字节（raw IPC，覆盖层显示用，不移除）
|
||
//! - screenshot_fullscreen_png：全屏捕获编码 PNG base64 并清除（全屏截图进编辑器用）
|
||
//! - screenshot_clear_fullscreen：清除静态全屏捕获（覆盖层关闭时）
|
||
//! - screenshot_crop_stored：按物理像素裁剪已存储的全屏捕获
|
||
//! - screenshot_pick_list：枚举可拾取顶层窗口（Z 序，前端缓存后本地命中测试）
|
||
//! - screenshot_show_overlay：一次 IPC 完成覆盖层 show + focus（关键路径减少往返）
|
||
//! - screenshot_enum_windows：枚举可见顶层窗口
|
||
//! - screenshot_capture_window：按 hwnd 捕获指定窗口
|
||
//! - screenshot_scroll_capture / screenshot_scroll_start / screenshot_scroll_finish /
|
||
//! screenshot_scroll_cancel：滚动截图（同步一次调用 / 会话式：启动、完成、取消）
|
||
//! - screenshot_set_scroll_hole：滚动模式遮罩挖孔（防 Chromium 遮挡检测冻结目标窗口）
|
||
//! - screenshot_take_editor_image_raw：取出编辑器图片（raw IPC，滚动截图会话直接写入）
|
||
//! - screenshot_compose_png / screenshot_compose_copy：raw RGBA → PNG（仅编码 / 剪贴板+编码）
|
||
//! - screenshot_copy_image：写入剪贴板（CF_DIB）
|
||
//! - screenshot_save_png：写入文件
|
||
//! - screenshot_disable_transitions：禁用窗口显示/隐藏过渡动画（消除覆盖层缩放动画）
|
||
|
||
use super::{CaptureData, CaptureStart, WindowInfo};
|
||
use tauri::{AppHandle, Emitter, Manager};
|
||
|
||
/// 禁用指定窗口（按 label 查找）的显示/隐藏过渡动画，消除覆盖层出现/消失时的缩放动画
|
||
#[tauri::command]
|
||
#[specta::specta]
|
||
pub async fn screenshot_disable_transitions(
|
||
app: tauri::AppHandle,
|
||
label: String,
|
||
) -> Result<(), String> {
|
||
#[cfg(windows)]
|
||
{
|
||
use raw_window_handle::HasWindowHandle;
|
||
let win = app
|
||
.get_webview_window(&label)
|
||
.ok_or_else(|| format!("窗口不存在: {}", label))?;
|
||
let handle = win
|
||
.window_handle()
|
||
.map_err(|e| format!("获取窗口句柄失败: {}", e))?;
|
||
match handle.as_raw() {
|
||
raw_window_handle::RawWindowHandle::Win32(h) => {
|
||
super::capture::disable_window_transitions(h.hwnd.get() as isize)
|
||
}
|
||
_ => Ok(()),
|
||
}
|
||
}
|
||
#[cfg(not(windows))]
|
||
{
|
||
let _ = (app, label);
|
||
Ok(())
|
||
}
|
||
}
|
||
|
||
/// 注册（或切换）截图全局快捷键。传入空字符串则禁用快捷键。
|
||
#[tauri::command]
|
||
#[specta::specta]
|
||
pub async fn screenshot_register_shortcut(
|
||
app: tauri::AppHandle,
|
||
shortcut: String,
|
||
) -> Result<(), String> {
|
||
crate::shortcut::register_shortcut(&app, "截图", &shortcut, |a| {
|
||
let _ = a.emit(crate::constants::events::SCREENSHOT_SHORTCUT, ());
|
||
})
|
||
}
|
||
|
||
/// 注销截图全局快捷键
|
||
#[tauri::command]
|
||
#[specta::specta]
|
||
pub async fn screenshot_unregister_shortcut(app: tauri::AppHandle) -> Result<(), String> {
|
||
crate::shortcut::unregister_shortcut(&app, "截图");
|
||
Ok(())
|
||
}
|
||
|
||
/// 注册（或切换）贴图全局快捷键。传入空字符串则禁用快捷键。
|
||
/// 按下时 emit 'screenshot-pin-shortcut'，由前端切换贴图窗口显示/隐藏。
|
||
#[tauri::command]
|
||
#[specta::specta]
|
||
pub async fn screenshot_register_pin_shortcut(
|
||
app: tauri::AppHandle,
|
||
shortcut: String,
|
||
) -> Result<(), String> {
|
||
crate::shortcut::register_shortcut(&app, "贴图", &shortcut, |a| {
|
||
let _ = a.emit(crate::constants::events::SCREENSHOT_PIN_SHORTCUT, ());
|
||
})
|
||
}
|
||
|
||
/// 注销贴图全局快捷键
|
||
#[tauri::command]
|
||
#[specta::specta]
|
||
pub async fn screenshot_unregister_pin_shortcut(app: tauri::AppHandle) -> Result<(), String> {
|
||
crate::shortcut::unregister_shortcut(&app, "贴图");
|
||
Ok(())
|
||
}
|
||
|
||
/// 捕获整个虚拟屏（多显示器拼接）存入静态，不做 PNG 编码。
|
||
/// 同时返回捕获时刻的光标物理坐标（覆盖层据此做初始窗口拾取，省一次 IPC 往返）。
|
||
#[tauri::command]
|
||
#[specta::specta]
|
||
pub async fn screenshot_capture_fullscreen() -> Result<CaptureStart, String> {
|
||
#[cfg(windows)]
|
||
{
|
||
// 屏幕捕获涉及 GDI 调用，放线程池避免阻塞 async 调度
|
||
tauri::async_runtime::spawn_blocking(|| {
|
||
let img = super::capture::capture_virtual_screen()?;
|
||
super::capture::store_fullscreen(img)?;
|
||
let (cursor_x, cursor_y) = super::capture::cursor_pos().unwrap_or((0, 0));
|
||
Ok(CaptureStart { cursor_x, cursor_y })
|
||
})
|
||
.await
|
||
.map_err(|e| format!("捕获任务失败: {}", e))?
|
||
}
|
||
#[cfg(not(windows))]
|
||
{
|
||
Err("截图仅支持 Windows".into())
|
||
}
|
||
}
|
||
|
||
/// 取出全屏捕获的 BMP 原始字节（raw IPC → 前端 ArrayBuffer），不移除
|
||
#[tauri::command]
|
||
pub async fn screenshot_get_fullscreen_bmp() -> Result<tauri::ipc::Response, String> {
|
||
#[cfg(windows)]
|
||
{
|
||
tauri::async_runtime::spawn_blocking(|| {
|
||
let bmp = super::capture::fullscreen_bmp()?;
|
||
Ok(tauri::ipc::Response::new(bmp))
|
||
})
|
||
.await
|
||
.map_err(|e| format!("读取捕获失败: {}", e))?
|
||
}
|
||
#[cfg(not(windows))]
|
||
{
|
||
Err("截图仅支持 Windows".into())
|
||
}
|
||
}
|
||
|
||
/// 全屏捕获编码为 PNG base64 并清除（全屏截图直接进编辑器）
|
||
#[tauri::command]
|
||
#[specta::specta]
|
||
pub async fn screenshot_fullscreen_png() -> Result<CaptureData, String> {
|
||
#[cfg(windows)]
|
||
{
|
||
tauri::async_runtime::spawn_blocking(|| super::capture::fullscreen_png())
|
||
.await
|
||
.map_err(|e| format!("编码任务失败: {}", e))?
|
||
}
|
||
#[cfg(not(windows))]
|
||
{
|
||
Err("截图仅支持 Windows".into())
|
||
}
|
||
}
|
||
|
||
/// 清除静态全屏捕获（覆盖层关闭/取消时释放内存）
|
||
#[tauri::command]
|
||
#[specta::specta]
|
||
pub async fn screenshot_clear_fullscreen() -> Result<(), String> {
|
||
#[cfg(windows)]
|
||
{
|
||
super::capture::clear_fullscreen();
|
||
Ok(())
|
||
}
|
||
#[cfg(not(windows))]
|
||
{
|
||
Ok(())
|
||
}
|
||
}
|
||
|
||
/// 按物理像素坐标裁剪已存储的全屏捕获
|
||
#[tauri::command]
|
||
#[specta::specta]
|
||
pub async fn screenshot_crop_stored(
|
||
x: i32,
|
||
y: i32,
|
||
w: i32,
|
||
h: i32,
|
||
) -> Result<CaptureData, String> {
|
||
#[cfg(windows)]
|
||
{
|
||
tauri::async_runtime::spawn_blocking(move || {
|
||
super::capture::crop_stored(x, y, w, h)
|
||
})
|
||
.await
|
||
.map_err(|e| format!("裁剪任务失败: {}", e))?
|
||
}
|
||
#[cfg(not(windows))]
|
||
{
|
||
let _ = (x, y, w, h);
|
||
Err("截图仅支持 Windows".into())
|
||
}
|
||
}
|
||
|
||
/// 裁剪已存储的全屏捕获并直接写入剪贴板（一次 IPC 完成"裁剪+复制"）
|
||
#[tauri::command]
|
||
#[specta::specta]
|
||
pub async fn screenshot_crop_copy_stored(
|
||
x: i32,
|
||
y: i32,
|
||
w: i32,
|
||
h: i32,
|
||
) -> Result<CaptureData, String> {
|
||
#[cfg(windows)]
|
||
{
|
||
tauri::async_runtime::spawn_blocking(move || {
|
||
super::capture::crop_copy_stored(x, y, w, h)
|
||
})
|
||
.await
|
||
.map_err(|e| format!("裁剪复制任务失败: {}", e))?
|
||
}
|
||
#[cfg(not(windows))]
|
||
{
|
||
let _ = (x, y, w, h);
|
||
Err("截图仅支持 Windows".into())
|
||
}
|
||
}
|
||
|
||
/// 枚举可拾取的顶层窗口（Z 序顶→底，排除本进程/不可见/工具窗口）。
|
||
/// 前端在截图开始时缓存列表，鼠标移动时在 JS 侧本地命中测试，消除逐帧 IPC 往返。
|
||
#[tauri::command]
|
||
#[specta::specta]
|
||
pub async fn screenshot_pick_list() -> Result<Vec<WindowInfo>, String> {
|
||
#[cfg(windows)]
|
||
{
|
||
tauri::async_runtime::spawn_blocking(super::capture::pick_windows)
|
||
.await
|
||
.map_err(|e| format!("枚举失败: {}", e))
|
||
}
|
||
#[cfg(not(windows))]
|
||
{
|
||
Ok(vec![])
|
||
}
|
||
}
|
||
|
||
/// 一次 IPC 完成指定窗口的显示与聚焦（截图覆盖层显示关键路径，减少串行往返）
|
||
#[tauri::command]
|
||
#[specta::specta]
|
||
pub async fn screenshot_show_overlay(
|
||
app: tauri::AppHandle,
|
||
label: String,
|
||
) -> Result<(), String> {
|
||
let win = app
|
||
.get_webview_window(&label)
|
||
.ok_or_else(|| format!("窗口不存在: {}", label))?;
|
||
win.show().map_err(|e| format!("显示窗口失败: {}", e))?;
|
||
win.set_focus().map_err(|e| format!("聚焦窗口失败: {}", e))?;
|
||
Ok(())
|
||
}
|
||
|
||
/// 获取当前鼠标物理屏幕坐标（贴图窗口拖动跟随等场景使用）
|
||
#[tauri::command]
|
||
#[specta::specta]
|
||
pub async fn screenshot_cursor_pos() -> Result<(i32, i32), String> {
|
||
#[cfg(windows)]
|
||
{
|
||
tauri::async_runtime::spawn_blocking(super::capture::cursor_pos)
|
||
.await
|
||
.map_err(|e| format!("查询任务失败: {}", e))?
|
||
}
|
||
#[cfg(not(windows))]
|
||
{
|
||
Err("截图仅支持 Windows".into())
|
||
}
|
||
}
|
||
|
||
/// 枚举所有可见顶层窗口
|
||
#[tauri::command]
|
||
#[specta::specta]
|
||
pub async fn screenshot_enum_windows() -> Result<Vec<WindowInfo>, String> {
|
||
#[cfg(windows)]
|
||
{
|
||
tauri::async_runtime::spawn_blocking(|| super::capture::enum_visible_windows())
|
||
.await
|
||
.map_err(|e| format!("枚举失败: {}", e))
|
||
}
|
||
#[cfg(not(windows))]
|
||
{
|
||
Ok(vec![])
|
||
}
|
||
}
|
||
|
||
/// 按 hwnd 捕获指定窗口
|
||
#[tauri::command]
|
||
#[specta::specta]
|
||
pub async fn screenshot_capture_window(hwnd: isize) -> Result<CaptureData, String> {
|
||
#[cfg(windows)]
|
||
{
|
||
tauri::async_runtime::spawn_blocking(move || {
|
||
let img = super::capture::capture_window(hwnd)?;
|
||
Ok(super::CaptureData {
|
||
png_base64: super::capture::base64_encode(&img.png),
|
||
width: img.width,
|
||
height: img.height,
|
||
})
|
||
})
|
||
.await
|
||
.map_err(|e| format!("捕获任务失败: {}", e))?
|
||
}
|
||
#[cfg(not(windows))]
|
||
{
|
||
let _ = hwnd;
|
||
Err("截图仅支持 Windows".into())
|
||
}
|
||
}
|
||
|
||
/// 滚动截图：从窗口当前滚动位置向下拼接到底部，返回超长 PNG。
|
||
/// `region` 为 Some 时仅在框选区域（屏幕物理坐标）内捕捉，宽 = 选区宽；
|
||
/// 为 None 时捕捉整个客户区。结束后会把窗口滚回起始位置，不打扰用户。
|
||
#[tauri::command]
|
||
#[specta::specta]
|
||
pub async fn screenshot_scroll_capture(
|
||
hwnd: isize,
|
||
region: Option<super::ScrollRegion>,
|
||
) -> Result<CaptureData, String> {
|
||
#[cfg(windows)]
|
||
{
|
||
tauri::async_runtime::spawn_blocking(move || {
|
||
super::scroll_capture::scroll_capture(hwnd, region)
|
||
})
|
||
.await
|
||
.map_err(|e| format!("滚动截图任务失败: {}", e))?
|
||
}
|
||
#[cfg(not(windows))]
|
||
{
|
||
let _ = hwnd;
|
||
let _ = region;
|
||
Err("截图仅支持 Windows".into())
|
||
}
|
||
}
|
||
|
||
/// 启动滚动截图会话（后台线程持续捕捉拼接，实时推进度事件）。
|
||
/// `auto = true` 为自动滚动（线程主动下滚拼到底部）；`false` 为手动（等用户滚动窗口）。
|
||
#[tauri::command]
|
||
#[specta::specta]
|
||
pub fn screenshot_scroll_start(
|
||
app: AppHandle,
|
||
hwnd: isize,
|
||
region: Option<super::ScrollRegion>,
|
||
auto: bool,
|
||
) -> Result<(), String> {
|
||
#[cfg(windows)]
|
||
{
|
||
super::scroll_session::start(app, hwnd, region, auto)
|
||
}
|
||
#[cfg(not(windows))]
|
||
{
|
||
let _ = (app, hwnd, region, auto);
|
||
Err("截图仅支持 Windows".into())
|
||
}
|
||
}
|
||
|
||
/// 结束滚动截图会话并导出结果。
|
||
#[tauri::command]
|
||
#[specta::specta]
|
||
pub fn screenshot_scroll_finish() -> Result<(), String> {
|
||
#[cfg(windows)]
|
||
{
|
||
super::scroll_session::finish()
|
||
}
|
||
#[cfg(not(windows))]
|
||
{
|
||
Err("截图仅支持 Windows".into())
|
||
}
|
||
}
|
||
|
||
/// 取消滚动截图会话（不导出）。
|
||
#[tauri::command]
|
||
#[specta::specta]
|
||
pub fn screenshot_scroll_cancel() -> Result<(), String> {
|
||
#[cfg(windows)]
|
||
{
|
||
super::scroll_session::cancel_now()
|
||
}
|
||
#[cfg(not(windows))]
|
||
{
|
||
Err("截图仅支持 Windows".into())
|
||
}
|
||
}
|
||
|
||
/// 滚动模式遮罩挖孔：在截图覆盖层窗口上挖出选区带的真孔（region = None 时复位整窗）。
|
||
///
|
||
/// Chromium 系浏览器（Edge/Chrome）的窗口遮挡检测会把被完全覆盖的窗口标记为
|
||
/// occluded 并暂停渲染——滚动截图时覆盖层铺满全屏，网页"看起来完全不滚动"。
|
||
/// 挖孔后目标窗口仅部分被覆盖，恢复渲染与滚轮响应（详见 capture::set_scroll_hole）。
|
||
/// 进入滚动模式时带选区调用，会话结束/新一轮截图开始时必须传 None 复位。
|
||
#[tauri::command]
|
||
#[specta::specta]
|
||
pub fn screenshot_set_scroll_hole(
|
||
app: AppHandle,
|
||
region: Option<super::ScrollRegion>,
|
||
) -> Result<(), String> {
|
||
#[cfg(windows)]
|
||
{
|
||
use raw_window_handle::HasWindowHandle;
|
||
|
||
let mut hwnds: Vec<isize> = Vec::new();
|
||
for (label, win) in app.webview_windows() {
|
||
if label.starts_with(crate::constants::windows::SCREENSHOT_OVERLAY) {
|
||
let hwnd = win
|
||
.window_handle()
|
||
.ok()
|
||
.and_then(|h| match h.as_raw() {
|
||
raw_window_handle::RawWindowHandle::Win32(w) => {
|
||
Some(w.hwnd.get() as isize)
|
||
}
|
||
_ => None,
|
||
});
|
||
if let Some(h) = hwnd {
|
||
hwnds.push(h);
|
||
}
|
||
}
|
||
}
|
||
if hwnds.is_empty() {
|
||
return Err("截图覆盖层窗口不存在".into());
|
||
}
|
||
for h in hwnds {
|
||
super::capture::set_scroll_hole(h, region)?;
|
||
}
|
||
Ok(())
|
||
}
|
||
#[cfg(not(windows))]
|
||
{
|
||
let _ = (app, region);
|
||
Ok(())
|
||
}
|
||
}
|
||
|
||
/// 取出编辑器图片（原始 PNG 字节，raw IPC → 前端 ArrayBuffer → Blob URL，取出即清除）
|
||
///
|
||
/// 长图（滚动截图）可达数十 MB：raw IPC 相比 base64 JSON 事件传输省 ~33% 体积，
|
||
/// 且避免 JSON 序列化/多次广播。注：返回 ipc::Response，specta 无法生成，豁免标注。
|
||
#[tauri::command]
|
||
pub async fn screenshot_take_editor_image_raw() -> Result<tauri::ipc::Response, String> {
|
||
match super::take_editor_image_raw() {
|
||
Some(bytes) => Ok(tauri::ipc::Response::new(bytes)),
|
||
None => Err("无待编辑的截图".into()),
|
||
}
|
||
}
|
||
|
||
/// 将 PNG base64 写入系统剪贴板（转 CF_DIB）
|
||
#[tauri::command]
|
||
#[specta::specta]
|
||
pub async fn screenshot_copy_image(png_base64: String) -> Result<(), String> {
|
||
#[cfg(windows)]
|
||
{
|
||
tauri::async_runtime::spawn_blocking(move || {
|
||
super::capture::copy_png_to_clipboard(&png_base64)
|
||
})
|
||
.await
|
||
.map_err(|e| format!("剪贴板任务失败: {}", e))?
|
||
}
|
||
#[cfg(not(windows))]
|
||
{
|
||
let _ = png_base64;
|
||
Err("剪贴板仅支持 Windows".into())
|
||
}
|
||
}
|
||
|
||
/// 有标注导出：接收 raw RGBA（前端 canvas.getImageData 直传），一次完成 剪贴板+PNG base64。
|
||
///
|
||
/// 省去前端 toDataURL(PNG 编码+base64) → Rust base64 解码 → PNG 解码 三次往返。
|
||
/// body 格式：前 8 字节 = width(i32 LE) + height(i32 LE)，之后为 raw RGBA 像素。
|
||
/// 注：参数为 tauri::ipc::Request（原始 body），specta 无法生成，豁免标注。
|
||
#[tauri::command]
|
||
pub async fn screenshot_compose_copy(
|
||
request: tauri::ipc::Request<'_>,
|
||
) -> Result<super::CaptureData, String> {
|
||
#[cfg(windows)]
|
||
{
|
||
let body = match request.body() {
|
||
tauri::ipc::InvokeBody::Raw(data) => data.clone(),
|
||
_ => return Err("需要 raw body（ArrayBuffer）".into()),
|
||
};
|
||
if body.len() < 8 {
|
||
return Err("数据不足：缺少尺寸头".into());
|
||
}
|
||
let width = i32::from_le_bytes([body[0], body[1], body[2], body[3]]);
|
||
let height = i32::from_le_bytes([body[4], body[5], body[6], body[7]]);
|
||
let rgba = body[8..].to_vec();
|
||
tauri::async_runtime::spawn_blocking(move || {
|
||
super::capture::compose_copy_rgba(&rgba, width, height)
|
||
})
|
||
.await
|
||
.map_err(|e| format!("合成复制任务失败: {}", e))?
|
||
}
|
||
#[cfg(not(windows))]
|
||
{
|
||
let _ = request;
|
||
Err("截图仅支持 Windows".into())
|
||
}
|
||
}
|
||
|
||
/// 有标注导出（仅编码）：接收 raw RGBA（前端 canvas.getImageData 直传），一次完成 PNG 编码。
|
||
/// 与 screenshot_compose_copy 的区别：不写剪贴板（编辑器「保存到文件」用）。
|
||
/// body 格式：前 8 字节 = width(i32 LE) + height(i32 LE)，之后为 raw RGBA 像素。
|
||
/// 注：参数为 tauri::ipc::Request（原始 body），specta 无法生成，豁免标注。
|
||
#[tauri::command]
|
||
pub async fn screenshot_compose_png(
|
||
request: tauri::ipc::Request<'_>,
|
||
) -> Result<super::CaptureData, String> {
|
||
#[cfg(windows)]
|
||
{
|
||
let body = match request.body() {
|
||
tauri::ipc::InvokeBody::Raw(data) => data.clone(),
|
||
_ => return Err("需要 raw body（ArrayBuffer）".into()),
|
||
};
|
||
if body.len() < 8 {
|
||
return Err("数据不足：缺少尺寸头".into());
|
||
}
|
||
let width = i32::from_le_bytes([body[0], body[1], body[2], body[3]]);
|
||
let height = i32::from_le_bytes([body[4], body[5], body[6], body[7]]);
|
||
let rgba = body[8..].to_vec();
|
||
tauri::async_runtime::spawn_blocking(move || {
|
||
super::capture::compose_png_rgba(&rgba, width, height)
|
||
})
|
||
.await
|
||
.map_err(|e| format!("合成编码任务失败: {}", e))?
|
||
}
|
||
#[cfg(not(windows))]
|
||
{
|
||
let _ = request;
|
||
Err("截图仅支持 Windows".into())
|
||
}
|
||
}
|
||
|
||
/// 将 PNG base64 写入文件
|
||
#[tauri::command]
|
||
#[specta::specta]
|
||
pub async fn screenshot_save_png(png_base64: String, path: String) -> Result<(), String> {
|
||
tauri::async_runtime::spawn_blocking(move || {
|
||
#[cfg(windows)]
|
||
{
|
||
super::capture::save_png_to_file(&png_base64, &path)
|
||
}
|
||
#[cfg(not(windows))]
|
||
{
|
||
let _ = (png_base64, path);
|
||
Err("文件写入仅支持 Windows".to_string())
|
||
}
|
||
})
|
||
.await
|
||
.map_err(|e| format!("保存任务失败: {}", e))?
|
||
}
|
||
|
||
// ===== 截图历史缓存：完整 PNG 落盘到应用数据目录（持久化，随历史保留数量清理），内存只保留缩略图 =====
|
||
|
||
/// 历史根目录（app_data_dir/screenshot/history）
|
||
fn history_cache_dir(app: &tauri::AppHandle) -> Result<std::path::PathBuf, String> {
|
||
let dir = app
|
||
.path()
|
||
.app_data_dir()
|
||
.map_err(|e| format!("获取应用数据目录失败: {}", e))?
|
||
.join("screenshot")
|
||
.join("history");
|
||
std::fs::create_dir_all(&dir).map_err(|e| format!("创建历史目录失败: {}", e))?;
|
||
Ok(dir)
|
||
}
|
||
|
||
/// 校验 path 属于历史缓存目录（防止路径穿越/任意文件读写）
|
||
fn ensure_in_history_dir(app: &tauri::AppHandle, path: &str) -> Result<std::path::PathBuf, String> {
|
||
let dir = history_cache_dir(app)?;
|
||
let p = std::path::PathBuf::from(path);
|
||
if !p.starts_with(&dir) {
|
||
return Err("非法路径：不在截图历史缓存目录内".into());
|
||
}
|
||
Ok(p)
|
||
}
|
||
|
||
/// 将完整 PNG 写入历史缓存目录，返回文件路径
|
||
#[tauri::command]
|
||
#[specta::specta]
|
||
pub async fn screenshot_save_cache(
|
||
app: tauri::AppHandle,
|
||
png_base64: String,
|
||
) -> Result<String, String> {
|
||
tauri::async_runtime::spawn_blocking(move || {
|
||
let dir = history_cache_dir(&app)?;
|
||
// 时间戳微秒命名（避免引入额外依赖；并发截图的同微秒碰撞可忽略）
|
||
let ts = std::time::SystemTime::now()
|
||
.duration_since(std::time::UNIX_EPOCH)
|
||
.map(|d| d.as_micros())
|
||
.unwrap_or(0);
|
||
let path = dir.join(format!("{}.png", ts));
|
||
super::capture::save_png_to_file(&png_base64, &path.to_string_lossy())?;
|
||
Ok(path.to_string_lossy().into_owned())
|
||
})
|
||
.await
|
||
.map_err(|e| format!("缓存任务失败: {}", e))?
|
||
}
|
||
|
||
/// 从历史缓存目录读取 PNG 并返回 base64（点击历史项复制/保存时一次性加载，不常驻内存）
|
||
#[tauri::command]
|
||
#[specta::specta]
|
||
pub async fn screenshot_load_cache(
|
||
app: tauri::AppHandle,
|
||
path: String,
|
||
) -> Result<String, String> {
|
||
tauri::async_runtime::spawn_blocking(move || {
|
||
let p = ensure_in_history_dir(&app, &path)?;
|
||
let bytes = std::fs::read(&p).map_err(|e| format!("读取缓存失败: {}", e))?;
|
||
use base64::Engine as _;
|
||
Ok(base64::engine::general_purpose::STANDARD.encode(bytes))
|
||
})
|
||
.await
|
||
.map_err(|e| format!("读取缓存任务失败: {}", e))?
|
||
}
|
||
|
||
/// 读取历史缓存 PNG 原始字节（raw IPC → 前端 ArrayBuffer，贴图窗口显示用：
|
||
/// 跳过 base64 编码，IPC 传输与前端内存占用均省 ~33%；同 get_fullscreen_bmp 豁免 specta）
|
||
#[tauri::command]
|
||
pub async fn screenshot_load_cache_raw(
|
||
app: tauri::AppHandle,
|
||
path: String,
|
||
) -> Result<tauri::ipc::Response, String> {
|
||
tauri::async_runtime::spawn_blocking(move || {
|
||
let p = ensure_in_history_dir(&app, &path)?;
|
||
let bytes = std::fs::read(&p).map_err(|e| format!("读取缓存失败: {}", e))?;
|
||
Ok(tauri::ipc::Response::new(bytes))
|
||
})
|
||
.await
|
||
.map_err(|e| format!("读取缓存任务失败: {}", e))?
|
||
}
|
||
|
||
/// 删除历史缓存文件（历史项移除/清空时调用，静默忽略不存在文件）
|
||
#[tauri::command]
|
||
#[specta::specta]
|
||
pub async fn screenshot_delete_cache(app: tauri::AppHandle, path: String) -> Result<(), String> {
|
||
tauri::async_runtime::spawn_blocking(move || {
|
||
if let Ok(p) = ensure_in_history_dir(&app, &path) {
|
||
let _ = std::fs::remove_file(p);
|
||
}
|
||
Ok(())
|
||
})
|
||
.await
|
||
.map_err(|e| format!("删除缓存任务失败: {}", e))?
|
||
}
|