Skip to main content

Struct tauri::Builder

pub struct Builder<R: Runtime> { /* fields omitted */ }

Expand description

Builds a Tauri application.

Implementations#

impl<R: Runtime> Builder<R>[src]#

pub fn new() -> Self[src]#

Creates a new App builder.

pub fn invoke_handler<F>(self, invoke_handler: F) -> Self where F: Fn(Invoke<R>) + Send + Sync + 'static,[src]#

Defines the JS message handler callback.

pub fn setup<F>(self, setup: F) -> Self where F: Fn(&mut App<R>) -> Result<(), Box<dyn Error + Send>> + Send + 'static,[src]#

Defines the setup hook.

pub fn on_page_load<F>(self, on_page_load: F) -> Self where F: Fn(Window<R>, PageLoadPayload) + Send + Sync + 'static,[src]#

Defines the page load hook.

pub fn plugin<P: Plugin<R> + 'static>(self, plugin: P) -> Self[src]#

Adds a plugin to the runtime.

pub fn manage<T>(self, state: T) -> Self where T: Send + Sync + 'static,[src]#

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.

Managed state can be retrieved by any request handler via the State request guard. In particular, if a value of type T is managed by Tauri, adding State<T> to the list of arguments in a request 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(Mutex<HashMap<u64, String>>);
struct Connection;
struct DbConnection(Mutex<Option<Connection>>);

#[tauri::command]

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

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

fn main() {
  Builder::default()
    .manage(Storage(Default::default()))
    .manage(DbConnection(Default::default()))
    .invoke_handler(tauri::generate_handler&#33;[connect, storage_insert])
    .run(tauri::generate_context!())
    .expect("error while running tauri application");
}

Example#

ⓘ

use tauri::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);
}

fn main() {
    tauri::Builder::default()
        .manage(MyInt(10))
        .manage(MyString("Hello, managed state!".to_string()))
        .invoke_handler(tauri::generate_handler&#33;[int_command, string_command])
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

pub fn create_window<F>( self, label: impl Into<String>, url: WindowUrl, setup: F ) -> Self where F: FnOnce(<R::Dispatcher as Dispatch>::WindowBuilder, WebviewAttributes) -> (<R::Dispatcher as Dispatch>::WindowBuilder, WebviewAttributes),[src]#

Creates a new webview window.

pub fn menu(self, menu: Menu) -> Self[src]#

Sets the menu to use on all windows.

pub fn on_menu_event<F: Fn(WindowMenuEvent<R>) + Send + Sync + 'static>( self, handler: F ) -> Self[src]#

Registers a menu event handler for all windows.

pub fn on_window_event<F: Fn(GlobalWindowEvent<R>) + Send + Sync + 'static>( self, handler: F ) -> Self[src]#

Registers a window event handler for all windows.

pub fn register_uri_scheme_protocol<N: Into<String>, H: Fn(&AppHandle<R>, &HttpRequest) -> Result<HttpResponse, Box<dyn Error>> + Send + Sync + 'static>( self, uri_scheme: N, protocol: H ) -> Self[src]#

Registers a URI scheme protocol available to all webviews. Leverages setURLSchemeHandler on macOS, AddWebResourceRequestedFilter on Windows and webkit-web-context-register-uri-scheme on Linux.

Arguments#

  • uri_scheme The URI scheme to register, such as example.
  • protocol the protocol associated with the given URI scheme. It’s a function that takes an URL such as example://localhost/asset.css.

pub fn build<A: Assets>(self, context: Context<A>) -> Result<App<R>>[src]#

Builds the application.

pub fn run<A: Assets>(self, context: Context<A>) -> Result<()>[src]#

Runs the configured Tauri application.

Trait Implementations#

impl Default for Builder<Wry>[src]#

Make Wry the default Runtime for Builder

fn default() -> Self[src]#

Returns the “default value” for a type. Read more

Auto Trait Implementations#

impl<R> \!RefUnwindSafe for Builder<R>#

impl<R> Send for Builder<R> where <<R as Runtime>::Dispatcher as Dispatch>::WindowBuilder: Send,#

impl<R> \!Sync for Builder<R>#

impl<R> Unpin for Builder<R> where <<R as Runtime>::Dispatcher as Dispatch>::WindowBuilder: Unpin,#

impl<R> \!UnwindSafe for Builder<R>#

Blanket Implementations#

impl<T> Any for T where T: 'static + ?Sized,[src]#

pub fn type_id(&self) -> TypeId[src]#

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T where T: ?Sized,[src]#

pub fn borrow(&self) -> &T[src]#

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T where T: ?Sized,[src]#

pub fn borrow_mut(&mut self) -> &mutT[src]#

Mutably borrows from an owned value. Read more

impl<T> From<T> for T[src]#

pub fn from(t: T) -> T[src]#

Performs the conversion.

impl<T, U> Into<U> for T where U: From<T>,[src]#

pub fn into(self) -> U[src]#

Performs the conversion.

impl<T, U> TryFrom<U> for T where U: Into<T>,[src]#

type Error = Infallible#

The type returned in the event of a conversion error.

pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]#

Performs the conversion.

impl<T, U> TryInto<U> for T where U: TryFrom<T>,[src]#

type Error = <U as TryFrom<T>>::Error#

The type returned in the event of a conversion error.

pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>[src]#

Performs the conversion.

impl<V, T> VZip<V> for T where V: MultiLane<T>,#

pub fn vzip(self) -> V#