Struct tauri::Builder

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

Builds a Tauri application.

Examples

tauri::Builder::default()
  // 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");

Implementations

impl<R: Runtime> Builder<R>

pub fn new() -> Self

Creates a new App builder.

pub fn any_thread(self) -> Self

Available on Windows or Linux only.

Builds a new Tauri application running on any thread, bypassing the main thread requirement.

Platform-specific

• macOS: on macOS the application must be executed on the main thread, so this function is not exposed.

pub fn invoke_handler<F>(self, invoke_handler: F) -> Selfwhere
    F: Fn(Invoke<R>) + Send + Sync + 'static,

Defines the JS message handler callback.

Examples

#[tauri::command]
fn command_1() -> String {
  return "hello world".to_string();
}
tauri::Builder::default()
  .invoke_handler(tauri::generate_handler![
    command_1,
    // etc...
  ]);

pub fn invoke_system<F>(self, initialization_script: String, responder: F) -> Selfwhere
    F: Fn(Window<R>, InvokeResponse, CallbackFn, CallbackFn) + Send + Sync + 'static,

Defines a custom JS message system.

The responder is a function that will be called when a command has been executed and must send a response to the JS layer.

The initialization_script is a script that initializes window.__TAURI_POST_MESSAGE__. That function must take the message: object argument and send it to the backend.

pub fn setup<F>(self, setup: F) -> Selfwhere
    F: FnOnce(&mut App<R>) -> Result<(), Box<dyn Error>> + Send + 'static,

Defines the setup hook.

Examples

use tauri::Manager;
tauri::Builder::default()
  .setup(|app| {
    let main_window = app.get_window("main").unwrap();
     tauri::api::dialog::blocking::message(Some(&main_window), "Hello", "Welcome back!");
    Ok(())
  });

pub fn on_page_load<F>(self, on_page_load: F) -> Selfwhere
    F: Fn(Window<R>, PageLoadPayload) + Send + Sync + 'static,

Defines the page load hook.

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

Adds a Tauri application plugin.

A plugin is created using the crate::plugin::Builder struct.Check its documentation for more information.

Examples

mod plugin {
  use tauri::{plugin::{Builder as PluginBuilder, TauriPlugin}, RunEvent, Runtime};

  // this command can be called in the frontend using `invoke('plugin:window|do_something')`.
  #[tauri::command]
  async fn do_something<R: Runtime>(app: tauri::AppHandle<R>, window: tauri::Window<R>) -> Result<(), String> {
    println!("command called");
    Ok(())
  }
  pub fn init<R: Runtime>() -> TauriPlugin<R> {
    PluginBuilder::new("window")
      .setup(|app| {
        // initialize the plugin here
        Ok(())
      })
      .on_event(|app, event| {
        match event {
          RunEvent::Ready => {
            println!("app is ready");
          }
          RunEvent::WindowEvent { label, event, .. } => {
            println!("window {} received an event: {:?}", label, event);
          }
          _ => (),
        }
      })
      .invoke_handler(tauri::generate_handler![do_something])
      .build()
  }
}

tauri::Builder::default()
  .plugin(plugin::init());

pub fn manage<T>(self, state: T) -> Selfwhere
    T: Send + Sync + 'static,

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 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::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()
  .manage(MyInt(10))
  .manage(MyString("Hello, managed state!".to_string()))
  .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");

pub fn system_tray(self, system_tray: SystemTray) -> Self

Available on crate feature system-tray only.

Sets the given system tray to be built before the app runs.

Prefer the SystemTray#method.build method to create the tray at runtime instead.

Examples

use tauri::{CustomMenuItem, SystemTray, SystemTrayMenu};

tauri::Builder::default()
  .system_tray(SystemTray::new().with_menu(
    SystemTrayMenu::new()
      .add_item(CustomMenuItem::new("quit", "Quit"))
      .add_item(CustomMenuItem::new("open", "Open"))
  ));

pub fn menu(self, menu: Menu) -> Self

Sets the menu to use on all windows.

Examples

use tauri::{MenuEntry, Submenu, MenuItem, Menu, CustomMenuItem};

tauri::Builder::default()
  .menu(Menu::with_items([
    MenuEntry::Submenu(Submenu::new(
      "File",
      Menu::with_items([
        MenuItem::CloseWindow.into(),
        #[cfg(target_os = "macos")]
        CustomMenuItem::new("hello", "Hello").into(),
      ]),
    )),
  ]));

pub fn enable_macos_default_menu(self, enable: bool) -> Self

Enable or disable the default menu on macOS. Enabled by default.

Examples

use tauri::{MenuEntry, Submenu, MenuItem, Menu, CustomMenuItem};

tauri::Builder::default()
  .enable_macos_default_menu(false);

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

Registers a menu event handler for all windows.

Examples

use tauri::{Menu, MenuEntry, Submenu, CustomMenuItem, api, Manager};
tauri::Builder::default()
  .menu(Menu::with_items([
    MenuEntry::Submenu(Submenu::new(
      "File",
      Menu::with_items([
        CustomMenuItem::new("New", "New").into(),
        CustomMenuItem::new("Learn More", "Learn More").into(),
      ]),
    )),
  ]))
  .on_menu_event(|event| {
    match event.menu_item_id() {
      "Learn More" => {
        // open in browser (requires the `shell-open-api` feature)
         api::shell::open(&event.window().shell_scope(), "https://github.com/tauri-apps/tauri".to_string(), None).unwrap();
      }
      id => {
        // do something with other events
        println!("got menu event: {}", id);
      }
    }
  });

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

Registers a window event handler for all windows.

Examples

tauri::Builder::default()
  .on_window_event(|event| match event.event() {
    tauri::WindowEvent::Focused(focused) => {
      // hide window whenever it loses focus
      if !focused {
        event.window().hide().unwrap();
      }
    }
    _ => {}
  });

pub fn on_system_tray_event<F: Fn(&AppHandle<R>, SystemTrayEvent) + Send + Sync + 'static>(
    self,
    handler: F
) -> Self

Available on crate feature system-tray only.

Registers a system tray event handler.

Prefer the SystemTray#method.on_event method when creating a tray at runtime instead.

Examples

use tauri::{Manager, SystemTrayEvent};
tauri::Builder::default()
  .on_system_tray_event(|app, event| match event {
    // show window with id "main" when the tray is left clicked
    SystemTrayEvent::LeftClick { .. } => {
      let window = app.get_window("main").unwrap();
      window.show().unwrap();
      window.set_focus().unwrap();
    }
    _ => {}
  });

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

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 updater_target<T: Into<String>>(self, target: T) -> Self

Sets the current platform’s target name for the updater.

See UpdateBuilder::target for more information.

Examples

• Use a macOS Universal binary target name:

let mut builder = tauri::Builder::default();
#[cfg(target_os = "macos")]
{
  builder = builder.updater_target("darwin-universal");
}

• Append debug information to the target:

let kind = if cfg!(debug_assertions) { "debug" } else { "release" };
tauri::Builder::default()
  .updater_target(format!("{}-{}", tauri::updater::target().unwrap(), kind));

• Use the platform’s target triple:

tauri::Builder::default()
  .updater_target(tauri::utils::platform::target_triple().unwrap());

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

Builds the application.

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

Runs the configured Tauri application.

Trait Implementations

impl Default for Builder<Wry>

Available on crate feature wry only.

Make Wry the default Runtime for Builder

fn default() -> Self

Returns the “default value” for a type.