Tauri v2 Schnellreferenz: Komplettüberblick für Entwickler

Tauri v2 hat die Entwicklung plattformübergreifender Desktop-Anwendungen mit Rust und Webtechnologien revolutioniert. Doch selbst erfahrene Entwickler müssen immer wieder dieselben Code-Snippets nachschlagen. Diese Schnellreferenz bündelt die wichtigsten Konzepte – von Befehlen über Events bis zu Berechtigungen – in einem praktischen Leitfaden.

Befehle zwischen Rust-Backend und Web-Frontend

Tauri v2 ermöglicht die Kommunikation zwischen Rust und der JavaScript-Frontend über benutzerdefinierte Befehle. Diese werden als öffentliche Funktionen markiert und können von der Frontend aufgerufen werden.

Ein einfaches Beispiel zeigt, wie ein Befehl definiert und aufgerufen wird:

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

Für robustere Anwendungen empfiehlt sich die Integration von Fehlerbehandlungen:

#[tauri::command]
fn read_file(path: String) -> Result<String, String> {
    std::fs::read_to_string(path).map_err(|e| e.to_string())
}

Asynchrone Operationen lassen sich ebenfalls einfach umsetzen:

#[tauri::command]
async fn fetch_data(url: String) -> Result<String, String> {
    // Asynchrone Logik hier
    Ok("Daten erfolgreich geladen".to_string())
}

Die Befehle werden im Tauri-Builder registriert:

tauri::Builder::default()
    .invoke_handler(tauri::generate_handler![greet, read_file, fetch_data])

Der Aufruf aus der Frontend erfolgt über die invoke-Methode:

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

const result = await invoke('greet', { name: 'Welt' });
const data = await invoke('fetch_data', { url: ' });

Events: Bidirektionale Kommunikation

Tauri unterstützt Events, um Daten zwischen Rust und JavaScript auszutauschen. Ein Event kann von Rust ausgelöst und in der Frontend empfangen werden – oder umgekehrt.

Ein Rust-Event wird wie folgt ausgelöst:

window.emit("mein-event", serde_json::json!({"schlüssel": "wert"})).unwrap();

Für globale Events verwendet man stattdessen app.emit:

app.emit("globales-event", payload).unwrap();

In der Frontend wird ein Event mit listen registriert:

import { listen } from '@tauri-apps/api/event';

const unlisten = await listen('mein-event', (event) => {
    console.log(event.payload);
});

// Event-Listener später entfernen
unlisten();

Events können auch Rust-Befehle auslösen, indem sie Daten an die Frontend senden, die dann invoke aufruft.

Zustandsverwaltung mit Rust-State

Tauri v2 bietet eine integrierte Lösung zur Verwaltung von Anwendungszuständen. Ein State wird als Rust-Struktur definiert und im Tauri-Builder registriert.

Beispiel für einen einfachen Zähler-State:

pub struct AppState {
    pub counter: Mutex<u32>,
}

Der State wird im Tauri-Builder initialisiert:

tauri::Builder::default()
    .manage(AppState {
        counter: Mutex::new(0),
    })

Ein Befehl kann den State lesen und verändern:

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

Berechtigungen und Sicherheitskonfiguration in Tauri v2

Tauri v2 führt ein neues Berechtigungssystem ein, das über Capabilities in einer JSON-Datei definiert wird. Diese Datei legt fest, welche Systemfunktionen die Anwendung nutzen darf.

Ein Beispiel für eine Capability-Datei:

{
  "identifier": "main-capability",
  "windows": ["main"],
  "permissions": [
    "core:default",
    "shell:allow-execute",
    "shell:allow-stdin",
    "fs:allow-read-files",
    "fs:allow-write-files",
    "fs:allow-app-cache-write",
    "dialog:allow-open",
    "dialog:allow-save",
    "notification:default"
  ]
}

Die wichtigsten Berechtigungen umfassen:

• core:default: Grundlegende Tauri-Funktionen
• shell:*: Shell-Befehle ausführen
• fs:*: Dateisystemoperationen
• dialog:*: Dateidialoge öffnen/speichern
• notification:*: Benachrichtigungen anzeigen

Fensterkonfiguration und System Tray

Die Konfiguration der Anwendungsfenster erfolgt in der tauri.conf.json. Hier lassen sich Aussehen, Verhalten und Plattform-spezifische Einstellungen vornehmen.

Ein Beispiel für die Fensterkonfiguration:

{
  "app": {
    "windows": [{
      "label": "main",
      "title": "Meine App",
      "width": 800,
      "height": 600,
      "resizable": true,
      "decorations": true,
      "transparent": false,
      "alwaysOnTop": false,
      "fullscreen": false,
      "visible": true
    }],
    "macOS": {
      "activationPolicy": "regular"
    }
  }
}

Für Menüleistenanwendungen wird activationPolicy auf accessory gesetzt. Die System Tray-Integration erfolgt über Rust-Code:

use tauri::tray::{TrayIconBuilder, TrayIconEvent};

TrayIconBuilder::new()
    .icon(app.default_window_icon().unwrap().clone())
    .on_tray_icon_event(|tray, event| {
        if let TrayIconEvent::Click { .. } = event {
            let app = tray.app_handle();
            if let Some(window) = app.get_webview_window("main") {
                window.show().unwrap();
                window.set_focus().unwrap();
            }
        }
    })
    .build(app)?;

Wichtige Plugins und Build-Prozess

Tauri v2 unterstützt eine Vielzahl von Plugins, die die Funktionalität erweitern. Diese werden im Cargo.toml deklariert und im Tauri-Builder eingebunden.

Typische Plugin-Abhängigkeiten:

[dependencies]
tauri-plugin-store = "2"
tauri-plugin-global-shortcut = "2"
tauri-plugin-notification = "2"
tauri-plugin-dialog = "2"
tauri-plugin-fs = "2"
tauri-plugin-shell = "2"

Die Plugins werden im Tauri-Builder initialisiert:

tauri::Builder::default()
    .plugin(tauri_plugin_store::Builder::new().build())
    .plugin(tauri_plugin_global_shortcut::Builder::new().build())
    .plugin(tauri_plugin_notification::init())
    .plugin(tauri_plugin_dialog::init())
    .plugin(tauri_plugin_fs::init())
    .plugin(tauri_plugin_shell::init())

Der Build-Prozess erfolgt über Cargo-Befehle:

• Entwicklungsmodus starten: cargo tauri dev
• Anwendung für die aktuelle Architektur bauen: cargo tauri build
• Universal-Binary für Intel und Apple Silicon: cargo tauri build --target universal-apple-darwin
• iOS-Build: cargo tauri ios build
• Android-Build: cargo tauri android build

Tauri v2 vereinfacht die Entwicklung plattformübergreifender Anwendungen erheblich. Mit dieser Schnellreferenz lassen sich die wichtigsten Konzepte effizient umsetzen – ohne ständiges Nachschlagen in der Dokumentation. Die modulare Architektur und die klare Trennung zwischen Frontend und Backend machen Tauri zu einer robusten Wahl für moderne Desktop-Anwendungen.