命令系统 #

┌─────────────┐     invoke()     ┌─────────────┐
│   前端      │ ───────────────► │   后端      │
│ JavaScript  │                  │   Rust      │
│             │ ◄─────────────── │  Command    │
│             │     Result       │             │
└─────────────┘                  └─────────────┘

// 使用 #[tauri::command] 宏定义命令
#[tauri::command]
fn greet(name: &str) -> String {
    format!("Hello, {}!", name)
}

// 注册命令
.invoke_handler(tauri::generate_handler![greet])

import { invoke } from '@tauri-apps/api/core';

const result = await invoke<string>('greet', { name: 'World' });
console.log(result); // "Hello, World!"

#[tauri::command]
fn basic_types(
    string_param: String,
    int_param: i32,
    float_param: f64,
    bool_param: bool,
) -> String {
    format!("string: {}, int: {}, float: {}, bool: {}",
        string_param, int_param, float_param, bool_param)
}

await invoke('basic_types', {
    stringParam: 'hello',
    intParam: 42,
    floatParam: 3.14,
    boolParam: true
});

#[tauri::command]
fn optional_param(name: Option<String>) -> String {
    match name {
        Some(n) => format!("Hello, {}!", n),
        None => "Hello, stranger!".to_string(),
    }
}

// 传递参数
await invoke('optional_param', { name: 'World' }); // "Hello, World!"

// 不传递参数
await invoke('optional_param', {}); // "Hello, stranger!"

use serde::Deserialize;

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

#[tauri::command]
fn create_user(user: User) -> String {
    format!("Created user: {} ({} years old)", user.name, user.age)
}

await invoke('create_user', {
    user: {
        name: 'Alice',
        age: 25,
        email: 'alice@example.com'
    }
});

#[tauri::command]
fn process_list(items: Vec<String>) -> usize {
    items.len()
}

#[tauri::command]
fn process_map(data: std::collections::HashMap<String, i32>) -> i32 {
    data.values().sum()
}

// 列表
await invoke('process_list', { items: ['a', 'b', 'c'] });

// Map
await invoke('process_map', { data: { a: 1, b: 2, c: 3 } });

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

#[tauri::command]
fn return_number() -> i32 {
    42
}

#[tauri::command]
fn return_bool() -> bool {
    true
}

#[tauri::command]
fn return_option() -> Option<String> {
    Some("value".to_string())
}

use serde::Serialize;

#[derive(Serialize)]
struct UserInfo {
    id: u32,
    name: String,
    active: bool,
}

#[tauri::command]
fn get_user() -> UserInfo {
    UserInfo {
        id: 1,
        name: "Alice".to_string(),
        active: true,
    }
}

interface UserInfo {
    id: number;
    name: string;
    active: boolean;
}

const user = await invoke<UserInfo>('get_user');
console.log(user.name); // "Alice"

#[tauri::command]
fn get_users() -> Vec<UserInfo> {
    vec![
        UserInfo { id: 1, name: "Alice".to_string(), active: true },
        UserInfo { id: 2, name: "Bob".to_string(), active: false },
    ]
}

#[tauri::command]
fn get_config() -> std::collections::HashMap<String, String> {
    let mut config = std::collections::HashMap::new();
    config.insert("theme".to_string(), "dark".to_string());
    config.insert("lang".to_string(), "en".to_string());
    config
}

#[tauri::command]
fn divide(a: f64, b: f64) -> Result<f64, String> {
    if b == 0.0 {
        Err("Division by zero".to_string())
    } else {
        Ok(a / b)
    }
}

try {
    const result = await invoke<number>('divide', { a: 10, b: 2 });
    console.log(result); // 5
} catch (error) {
    console.error(error); // "Division by zero"
}

use serde::Serialize;

#[derive(Debug, Serialize)]
struct AppError {
    code: String,
    message: String,
}

impl From<std::io::Error> for AppError {
    fn from(error: std::io::Error) -> Self {
        AppError {
            code: "IO_ERROR".to_string(),
            message: error.to_string(),
        }
    }
}

#[tauri::command]
fn read_config() -> Result<String, AppError> {
    std::fs::read_to_string("config.json")?;
    Ok("success".to_string())
}

use anyhow::Result;

#[tauri::command]
fn complex_operation() -> Result<String> {
    // 使用 ? 操作符自动转换错误
    let content = std::fs::read_to_string("file.txt")?;
    Ok(content)
}

#[tauri::command]
async fn async_greet(name: String) -> String {
    // 模拟异步操作
    tokio::time::sleep(std::time::Duration::from_secs(1)).await;
    format!("Hello, {}!", name)
}

#[tauri::command]
async fn read_file_async(path: String) -> Result<String, String> {
    tokio::fs::read_to_string(&path)
        .await
        .map_err(|e| e.to_string())
}

#[tauri::command]
async fn fetch_data(url: String) -> Result<String, String> {
    let response = reqwest::get(&url)
        .await
        .map_err(|e| e.to_string())?;
    
    let body = response.text()
        .await
        .map_err(|e| e.to_string())?;
    
    Ok(body)
}

use std::sync::Mutex;

struct AppState {
    counter: Mutex<i32>,
}

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

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

// 注册状态
tauri::Builder::default()
    .manage(AppState {
        counter: Mutex::new(0),
    })
    .invoke_handler(tauri::generate_handler![increment, get_counter])
    .run(tauri::generate_context!())
    .expect("error while running tauri application");

struct Database {
    connection: Mutex<String>,
}

struct Cache {
    data: Mutex<std::collections::HashMap<String, String>>,
}

#[tauri::command]
fn use_multiple_states(
    db: tauri::State<Database>,
    cache: tauri::State<Cache>,
) -> String {
    // 使用多个状态
    "ok".to_string()
}

// 注册多个状态
tauri::Builder::default()
    .manage(Database { connection: Mutex::new("connection".to_string()) })
    .manage(Cache { data: Mutex::new(std::collections::HashMap::new()) })
    .invoke_handler(tauri::generate_handler![use_multiple_states])
    .run(tauri::generate_context!())
    .expect("error while running tauri application");

#[tauri::command]
async fn close_window(window: tauri::Window) {
    window.close().await.unwrap();
}

#[tauri::command]
async fn set_title(window: tauri::Window, title: String) {
    window.set_title(&title).await.unwrap();
}

#[tauri::command]
fn get_app_info(app: tauri::AppHandle) -> String {
    format!("{} - {}",
        app.config().product_name.clone().unwrap_or_default(),
        app.config().version.clone().unwrap_or_default()
    )
}

.invoke_handler(tauri::generate_handler![
    greet,
    increment,
    get_counter,
])

mod commands {
    pub mod file {
        #[tauri::command]
        pub fn read() -> String { "read".to_string() }
        
        #[tauri::command]
        pub fn write() -> String { "write".to_string() }
    }
    
    pub mod system {
        #[tauri::command]
        pub fn info() -> String { "info".to_string() }
    }
}

.invoke_handler(tauri::generate_handler![
    commands::file::read,
    commands::file::write,
    commands::system::info,
])

// types/commands.ts
export interface User {
    id: number;
    name: string;
    email: string;
}

export interface AppError {
    code: string;
    message: string;
}

export interface Commands {
    greet: (name: string) => Promise<string>;
    getUser: () => Promise<User>;
    create_user: (user: User) => Promise<void>;
}

// utils/tauri.ts
import { invoke } from '@tauri-apps/api/core';

export async function invokeTyped<T>(cmd: string, args?: Record<string, unknown>): Promise<T> {
    return invoke<T>(cmd, args);
}

// 使用
const user = await invokeTyped<User>('get_user');

// 推荐：动词开头，清晰描述功能
#[tauri::command]
fn get_user() -> User { /* ... */ }

#[tauri::command]
fn create_user() -> User { /* ... */ }

#[tauri::command]
fn delete_user() -> bool { /* ... */ }

// 不推荐：模糊命名
#[tauri::command]
fn user() -> User { /* ... */ }

#[tauri::command]
fn create_user(name: String, email: String) -> Result<User, String> {
    if name.is_empty() {
        return Err("Name cannot be empty".to_string());
    }
    
    if !email.contains('@') {
        return Err("Invalid email format".to_string());
    }
    
    Ok(User { name, email })
}

// 不推荐：多次调用
#[tauri::command]
fn get_user(id: u32) -> User { /* ... */ }

// 推荐：批量获取
#[tauri::command]
fn get_users(ids: Vec<u32>) -> Vec<User> { /* ... */ }

#[tauri::command]
fn debug_command(param: String) -> String {
    println!("Received param: {}", param);
    format!("Processed: {}", param)
}

#[tauri::command]
fn tracked_operation() -> Result<String, String> {
    std::fs::read_to_string("file.txt")
        .map_err(|e| {
            eprintln!("Error reading file: {}", e);
            format!("Failed to read file: {}", e)
        })
}