Trait tauri::Manager

source ·
pub trait Manager<R: Runtime>: ManagerBase<R> {
Show 17 methods fn app_handle(&self) -> AppHandle<R> { ... } fn config(&self) -> Arc<Config> { ... } fn emit_all<S: Serialize + Clone>(
        &self,
        event: &str,
        payload: S
    ) -> Result<()> { ... } fn emit_to<S: Serialize + Clone>(
        &self,
        label: &str,
        event: &str,
        payload: S
    ) -> Result<()> { ... } fn listen_global<F>(
        &self,
        event: impl Into<String>,
        handler: F
    ) -> EventHandler
    where
        F: Fn(Event) + Send + 'static
, { ... } fn once_global<F>(&self, event: impl Into<String>, handler: F) -> EventHandler
    where
        F: FnOnce(Event) + Send + 'static
, { ... } fn trigger_global(&self, event: &str, data: Option<String>) { ... } fn unlisten(&self, handler_id: EventHandler) { ... } fn get_window(&self, label: &str) -> Option<Window<R>> { ... } fn windows(&self) -> HashMap<String, Window<R>> { ... } fn manage<T>(&self, state: T) -> bool
    where
        T: Send + Sync + 'static
, { ... } fn state<T>(&self) -> State<'_, T>
    where
        T: Send + Sync + 'static
, { ... } fn try_state<T>(&self) -> Option<State<'_, T>>
    where
        T: Send + Sync + 'static
, { ... } fn env(&self) -> Env { ... } fn fs_scope(&self) -> FsScope { ... } fn asset_protocol_scope(&self) -> FsScope { ... } fn shell_scope(&self) -> ShellScope { ... }
}
Expand description

Manages a running application.

Provided Methods§

The application handle associated with this manager.

The Config the manager was created with.

Emits a event to all windows.

Emits an event to a window with the specified label.

Listen to a global event.

Listen to a global event only once.

Trigger a global event.

Remove an event listener.

Fetch a single window from the manager.

Fetch all managed windows.

Add state to the state managed by the application.

This method can be called any number of times as long as each call refers to a different T. If a state for T is already managed, the function returns false and the value is ignored.

Managed state can be retrieved by any command handler via the State guard. In particular, if a value of type T is managed by Tauri, adding State<T> to the list of arguments in a command handler instructs Tauri to retrieve the managed value.

Panics

Panics if state of type T is already being managed.

Mutability

Since the managed state is global and must be Send + Sync, mutations can only happen through interior mutability:

use std::{collections::HashMap, sync::Mutex};
use tauri::State;
// here we use Mutex to achieve interior mutability
struct Storage {
  store: Mutex<HashMap<u64, String>>,
}
struct Connection;
struct DbConnection {
  db: Mutex<Option<Connection>>,
}

#[tauri::command]
fn connect(connection: State<DbConnection>) {
  // initialize the connection, mutating the state with interior mutability
  *connection.db.lock().unwrap() = Some(Connection {});
}

#[tauri::command]
fn storage_insert(key: u64, value: String, storage: State<Storage>) {
  // mutate the storage behind the Mutex
  storage.store.lock().unwrap().insert(key, value);
}

tauri::Builder::default()
  .manage(Storage { store: Default::default() })
  .manage(DbConnection { db: Default::default() })
  .invoke_handler(tauri::generate_handler![connect, storage_insert])
  // on an actual app, remove the string argument
  .run(tauri::generate_context!("test/fixture/src-tauri/tauri.conf.json"))
  .expect("error while running tauri application");
Examples
use tauri::{Manager, State};

struct MyInt(isize);
struct MyString(String);

#[tauri::command]
fn int_command(state: State<MyInt>) -> String {
    format!("The stateful int is: {}", state.0)
}

#[tauri::command]
fn string_command<'r>(state: State<'r, MyString>) {
    println!("state: {}", state.inner().0);
}

tauri::Builder::default()
  .setup(|app| {
    app.manage(MyInt(0));
    app.manage(MyString("tauri".into()));
    // `MyInt` is already managed, so `manage()` returns false
    assert!(!app.manage(MyInt(1)));
    // read the `MyInt` managed state with the turbofish syntax
    let int = app.state::<MyInt>();
    assert_eq!(int.0, 0);
    // read the `MyString` managed state with the `State` guard
    let val: State<MyString> = app.state();
    assert_eq!(val.0, "tauri");
    Ok(())
  })
  .invoke_handler(tauri::generate_handler![int_command, string_command])
  // on an actual app, remove the string argument
  .run(tauri::generate_context!("test/fixture/src-tauri/tauri.conf.json"))
  .expect("error while running tauri application");

Retrieves the managed state for the type T.

Panics

Panics if the state for the type T has not been previously managed. Use try_state for a non-panicking version.

Attempts to retrieve the managed state for the type T.

Returns Some if the state has previously been managed. Otherwise returns None.

Gets the managed Env.

Gets the scope for the filesystem APIs.

Gets the scope for the asset protocol.

Gets the scope for the shell execute APIs.

Implementors§