Tauri 学习笔记#

// src-tauri/src/lib.rs
#[tauri::command]
fn greet(name: &str) -> String {
    format!("Hello, {}!", name)
}

#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
    tauri::Builder::default()
        .plugin(tauri_plugin_shell::init())
        .invoke_handler(tauri::generate_handler![greet])
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

// src-tauri/src/main.rs
fn main() {
    my_tauri_app_lib::run()
}

use serde::{Deserialize, Serialize};

#[tauri::command]
fn greet(name: &str) -> String {
    format!("Hello, {}!", name)
}

#[derive(Serialize, Deserialize)]
struct User { id: u32, name: String }

#[derive(Serialize)]
struct UserResponse { success: bool, user: User }

#[tauri::command]
fn get_user(user_id: u32) -> Result<UserResponse, String> {
    if user_id == 1 {
        Ok(UserResponse { success: true, user: User { id: 1, name: "张三".into() } })
    } else {
        Err("用户不存在".into())
    }
}

// 异步命令
#[tauri::command]
async fn fetch_data(url: String) -> Result<String, String> {
    tokio::time::sleep(std::time::Duration::from_secs(1)).await;
    Ok(format!("从 {} 获取的数据", url))
}

tauri::Builder::default()
    .invoke_handler(tauri::generate_handler![greet, get_user, fetch_data])
    .run(tauri::generate_context!())
    .expect("error");

use tauri::{Emitter, Manager};

#[tauri::command]
async fn start_download(app: tauri::AppHandle) -> Result<(), String> {
    for i in 1..=100 {
        tokio::time::sleep(std::time::Duration::from_millis(50)).await;
        app.emit("download-progress", i).map_err(|e| e.to_string())?;
    }
    app.emit("download-complete", "文件已下载").map_err(|e| e.to_string())?;
    Ok(())
}

use tauri::Listener;

// 后端监听
.setup(|app| {
    app.listen("frontend-event", |event| {
        println!("收到前端事件: {:?}", event.payload());
    });
    Ok(())
})

use tauri::{AppHandle, State, Window};

// 普通参数：从前端 invoke 的 args 对象中提取
#[tauri::command]
fn add(a: i32, b: i32) -> i32 { a + b }

// 注入 AppHandle：操作应用级能力
#[tauri::command]
fn notify(app: AppHandle, msg: String) {
    app.emit("notification", msg).unwrap();
}

// 注入 Window：操作当前窗口
#[tauri::command]
fn set_title(window: Window, title: String) {
    window.set_title(&title).unwrap();
}

// 注入 State：访问全局共享状态
#[tauri::command]
fn get_value(state: State<'_, MyState>) -> String {
    state.inner().value.clone()
}

#[derive(Debug, Serialize)]
enum AppError {
    NotFound(String),
    PermissionDenied,
    InternalError(String),
}

impl From<std::io::Error> for AppError {
    fn from(e: std::io::Error) -> Self {
        AppError::InternalError(e.to_string())
    }
}

#[tauri::command]
fn read_config(path: String) -> Result<String, AppError> {
    let content = std::fs::read_to_string(&path)?;
    if content.is_empty() {
        return Err(AppError::NotFound("配置为空".into()));
    }
    Ok(content)
}

// async 命令在异步运行时上执行，不阻塞 UI 线程
#[tauri::command]
async fn long_task() -> Result<String, String> {
    // CPU 密集型任务用 spawn_blocking
    let result = tokio::task::spawn_blocking(|| {
        std::thread::sleep(std::time::Duration::from_secs(2));
        "计算完成".to_string()
    }).await.map_err(|e| e.to_string())?;
    Ok(result)
}

// 并发执行多个异步操作
#[tauri::command]
async fn fetch_all() -> Result<Vec<String>, String> {
    let (a, b) = tokio::join!(
        fetch_api("https://api.a.com"),
        fetch_api("https://api.b.com"),
    );
    Ok(vec![a, b])
}

// 大文件通过 IPC 返回：Base64 编码后体积翻倍
#[tauri::command]
fn read_file(path: String) -> Result<Vec<u8>, String> {
    std::fs::read(&path).map_err(|e| e.to_string())
}

// 大文件用 tauri-plugin-fs 让前端直接读
// 前端: const data = await readFile('/path/to/file');

use tauri::{WebviewWindowBuilder, WebviewUrl, Manager};

#[tauri::command]
async fn open_settings(app: AppHandle) -> Result<(), String> {
    if app.get_webview_window("settings").is_some() {
        app.get_webview_window("settings").unwrap().set_focus().ok();
        return Ok(());
    }
    WebviewWindowBuilder::new(&app, "settings", WebviewUrl::App("settings.html".into()))
        .title("设置")
        .inner_size(600.0, 400.0)
        .resizable(false)
        .center()
        .build()
        .map_err(|e| e.to_string())?;
    Ok(())
}

use std::sync::Mutex;
use tauri::State;

struct AppState {
    counter: Mutex<i32>,
}

#[tauri::command]
fn get_counter(state: State<'_, AppState>) -> i32 {
    *state.counter.lock().unwrap()
}

#[tauri::command]
fn increment(state: State<'_, AppState>) -> i32 {
    let mut c = state.counter.lock().unwrap();
    *c += 1;
    *c
}

// 注册
tauri::Builder::default()
    .manage(AppState { counter: Mutex::new(0) })
    .invoke_handler(tauri::generate_handler![get_counter, increment])
    .run(tauri::generate_context!()).unwrap();

#[tauri::command]
async fn update_theme(app: AppHandle, state: State<'_, AppState>, theme: String) -> Result<(), String> {
    { let mut config = state.config.lock().unwrap(); config.theme = theme.clone(); }
    app.emit("theme-changed", &theme).map_err(|e| e.to_string())?;
    Ok(())
}

// 3. 注册插件
tauri::Builder::default()
    .plugin(tauri_plugin_dialog::init())
    .run(tauri::generate_context!()).expect("error");

mod my_plugin {
    pub fn init<R: tauri::Runtime>() -> tauri::plugin::TauriPlugin<R> {
        tauri::plugin::Builder::new("my-plugin")
            .invoke_handler(tauri::generate_handler![ping])
            .setup(|_app, _api| {
                println!("my-plugin 初始化");
                Ok(())
            })
            .build()
    }

    #[tauri::command]
    fn ping() -> String { "pong".to_string() }
}

// 注册
tauri::Builder::default()
    .plugin(my_plugin::init())
    .run(tauri::generate_context!()).expect("error");

use tauri::Manager;

#[tauri::command]
fn get_paths(app: AppHandle) -> Result<serde_json::Value, String> {
    Ok(serde_json::json!({
        "appData": app.path().app_data_dir().map_err(|e| e.to_string())?,
        "appConfig": app.path().app_config_dir().map_err(|e| e.to_string())?,
        "appCache": app.path().app_cache_dir().map_err(|e| e.to_string())?,
        "appLog": app.path().app_log_dir().map_err(|e| e.to_string())?,
    }))
}

use tauri::path::BaseDirectory;

#[tauri::command]
fn read_resource(app: AppHandle) -> Result<String, String> {
    let path = app.path()
        .resolve("resources/config.json", BaseDirectory::Resource)
        .map_err(|e| e.to_string())?;
    std::fs::read_to_string(path).map_err(|e| e.to_string())
}

use tauri_plugin_sql::{Migration, MigrationKind};

let migrations = vec![
    Migration {
        version: 1,
        description: "create users table",
        sql: "CREATE TABLE IF NOT EXISTS users (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            name TEXT NOT NULL,
            email TEXT UNIQUE NOT NULL
        );",
        kind: MigrationKind::Up,
    },
];

tauri::Builder::default()
    .plugin(
        tauri_plugin_sql::Builder::default()
            .add_migrations("sqlite:app.db", migrations)
            .build(),
    )
    .run(tauri::generate_context!()).expect("error");

use tauri::tray::{TrayIconBuilder, MouseButton, MouseButtonState, TrayIconEvent};
use tauri::menu::{Menu, MenuItem, PredefinedMenuItem};

tauri::Builder::default()
    .setup(|app| {
        let quit = MenuItem::with_id(app, "quit", "退出", true, None::<&str>)?;
        let show = MenuItem::with_id(app, "show", "显示主窗口", true, None::<&str>)?;
        let separator = PredefinedMenuItem::separator(app)?;
        let menu = Menu::with_items(app, &[&show, &separator, &quit])?;

        let _tray = TrayIconBuilder::new()
            .icon(app.default_window_icon().unwrap().clone())
            .tooltip("我的应用")
            .menu(&menu)
            .on_menu_event(|app, event| {
                match event.id.as_ref() {
                    "quit" => app.exit(0),
                    "show" => {
                        if let Some(w) = app.get_webview_window("main") {
                            w.show().ok(); w.set_focus().ok();
                        }
                    }
                    _ => {}
                }
            })
            .on_tray_icon_event(|tray, event| {
                if let TrayIconEvent::Click {
                    button: MouseButton::Left,
                    button_state: MouseButtonState::Up, ..
                } = event {
                    if let Some(w) = tray.app_handle().get_webview_window("main") {
                        w.show().ok(); w.set_focus().ok();
                    }
                }
            })
            .build(app)?;
        Ok(())
    })
    .run(tauri::generate_context!()).expect("error");

use tauri_plugin_global_shortcut::{Code, Modifiers, Shortcut, ShortcutState};

tauri::Builder::default()
    .plugin(
        tauri_plugin_global_shortcut::Builder::new()
            .with_handler(|app, shortcut, event| {
                if event.state == ShortcutState::Pressed {
                    if shortcut.mods == Modifiers::CONTROL | Modifiers::SHIFT
                        && shortcut.key == Code::KeyD
                    {
                        if let Some(w) = app.get_webview_window("main") {
                            if w.is_visible().unwrap_or(false) { w.hide().ok(); }
                            else { w.show().ok(); w.set_focus().ok(); }
                        }
                    }
                }
            })
            .build(),
    )
    .setup(|app| {
        let shortcut = Shortcut::new(
            Some(Modifiers::CONTROL | Modifiers::SHIFT), Code::KeyD
        );
        app.global_shortcut().register(shortcut)?;
        Ok(())
    })
    .run(tauri::generate_context!()).expect("error");