Struct tauri::App

pub struct App<R: Runtime = Wry> { /* private fields */ }

The instance of the currently running application.

This type implements Manager which allows for manipulation of global application items.

Implementations

impl App<Wry>

APIs specific to the wry runtime.

pub fn wry_plugin<P: PluginBuilder<EventLoopMessage> + 'static>( &mut self, plugin: P )

Adds a tauri_runtime_wry::Plugin using its tauri_runtime_wry::PluginBuilder.

Stability

This API is unstable.

impl<R: Runtime> App<R>

pub fn updater(&self) -> UpdateBuilder<R>

Available on crate feature updater only.

Gets the updater builder to manually check if an update is available.

Examples

tauri::Builder::default()
  .setup(|app| {
    let handle = app.handle();
    tauri::async_runtime::spawn(async move {
     let response = handle.updater().check().await;
    });
    Ok(())
  });

pub fn tray_handle(&self) -> SystemTrayHandle<R>

Available on crate feature system-tray only.

Gets a handle to the first system tray.

Prefer Self::tray_handle_by_id when multiple system trays are created.

Examples

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

tauri::Builder::default()
  .setup(|app| {
    let app_handle = app.handle();
    SystemTray::new()
      .with_menu(
        SystemTrayMenu::new()
          .add_item(CustomMenuItem::new("quit", "Quit"))
          .add_item(CustomMenuItem::new("open", "Open"))
      )
      .on_event(move |event| {
        let tray_handle = app_handle.tray_handle();
      })
      .build(app)?;
    Ok(())
  });

pub fn tray_handle_by_id(&self, id: &str) -> Option<SystemTrayHandle<R>>

Available on crate feature system-tray only.

Gets a handle to a system tray by its id.

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

tauri::Builder::default()
  .setup(|app| {
    let app_handle = app.handle();
    let tray_id = "my-tray";
    SystemTray::new()
      .with_id(tray_id)
      .with_menu(
        SystemTrayMenu::new()
          .add_item(CustomMenuItem::new("quit", "Quit"))
          .add_item(CustomMenuItem::new("open", "Open"))
      )
      .on_event(move |event| {
        let tray_handle = app_handle.tray_handle_by_id(tray_id).unwrap();
      })
      .build(app)?;
    Ok(())
  });

pub fn path_resolver(&self) -> PathResolver

The path resolver for the application.

pub fn global_shortcut_manager(&self) -> R::GlobalShortcutManager

Available on crate feature global-shortcut only.

Gets a copy of the global shortcut manager instance.

pub fn config(&self) -> Arc<Config>

Gets the app’s configuration, defined on the tauri.conf.json file.

pub fn package_info(&self) -> &PackageInfo

Gets the app’s package information.

pub fn asset_resolver(&self) -> AssetResolver<R>

The application’s asset resolver.

impl<R: Runtime> App<R>

pub fn handle(&self) -> AppHandle<R>

Gets a handle to the application instance.

pub fn set_device_event_filter(&mut self, filter: DeviceEventFilter)

Change the device event filter mode.

Since the DeviceEvent capture can lead to high CPU usage for unfocused windows, tao will ignore them by default for unfocused windows on Windows. This method allows changing the filter to explicitly capture them again.

Platform-specific

• ** Linux / macOS / iOS / Android**: Unsupported.

Examples

let mut app = tauri::Builder::default()
  // on an actual app, remove the string argument
  .build(tauri::generate_context!("test/fixture/src-tauri/tauri.conf.json"))
  .expect("error while building tauri application");
app.set_device_event_filter(tauri::DeviceEventFilter::Always);
app.run(|_app_handle, _event| {});

pub fn get_cli_matches(&self) -> Result<Matches>

Gets the argument matches of the CLI definition configured in tauri.conf.json.

Examples

tauri::Builder::default()
  .setup(|app| {
    let matches = app.get_cli_matches()?;
    Ok(())
  });

pub fn run<F: FnMut(&AppHandle<R>, RunEvent) + 'static>(self, callback: F)

Runs the application.

Examples

let app = tauri::Builder::default()
  // on an actual app, remove the string argument
  .build(tauri::generate_context!("test/fixture/src-tauri/tauri.conf.json"))
  .expect("error while building tauri application");
app.run(|_app_handle, event| match event {
  tauri::RunEvent::ExitRequested { api, .. } => {
    api.prevent_exit();
  }
  _ => {}
});

pub fn run_iteration(&mut self) -> RunIteration

Runs a iteration of the runtime event loop and immediately return.

Note that when using this API, app cleanup is not automatically done. The cleanup calls crate::api::process::kill_children so you may want to call that function before exiting the application. Additionally, the cleanup calls AppHandle#remove_system_tray (Windows only).

Examples

let mut app = tauri::Builder::default()
  // on an actual app, remove the string argument
  .build(tauri::generate_context!("test/fixture/src-tauri/tauri.conf.json"))
  .expect("error while building tauri application");
loop {
  let iteration = app.run_iteration();
  if iteration.window_count == 0 {
    break;
  }
}

Trait Implementations

impl<R: Debug + Runtime> Debug for App<R>

where R::GlobalShortcutManager: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<R: Runtime> HasRawDisplayHandle for App<R>

fn raw_display_handle(&self) -> RawDisplayHandle

impl<R: Runtime> Manager<R> for App<R>

fn app_handle(&self) -> AppHandle<R>

The application handle associated with this manager.

fn config(&self) -> Arc<Config>

The Config the manager was created with.

fn emit_all<S: Serialize + Clone>(&self, event: &str, payload: S) -> Result<()>

Emits an event to all windows.

fn emit_filter<S, F>(&self, event: &str, payload: S, filter: F) -> Result<()>

where S: Serialize + Clone, F: Fn(&Window<R>) -> bool,

Emits an event to windows matching the filter critera.

fn emit_to<S: Serialize + Clone>( &self, label: &str, event: &str, payload: S ) -> Result<()>

Emits an event to the window with the specified label.

fn listen_global<F>(&self, event: impl Into<String>, handler: F) -> EventHandler

where F: Fn(Event) + Send + 'static,

Listen to a event triggered on any window (Window::trigger or Window::emit_and_trigger) or with Self::trigger_global.

fn once_global<F>(&self, event: impl Into<String>, handler: F) -> EventHandler

where F: FnOnce(Event) + Send + 'static,

Listen to a global event only once.

fn trigger_global(&self, event: &str, data: Option<String>)

Trigger a global event to Rust listeners. To send the events to the webview, see Self::emit_all and Self::emit_to. To trigger listeners registed on an specific window, see Window::trigger. To trigger all listeners, see Window::emit_and_trigger.

fn unlisten(&self, handler_id: EventHandler)

Remove an event listener.

fn get_window(&self, label: &str) -> Option<Window<R>>

Fetch a single window from the manager.

fn get_focused_window(&self) -> Option<Window<R>>

Fetch the focused window. Returns None if there is not any focused window.

fn windows(&self) -> HashMap<String, Window<R>>

Fetch all managed windows.

fn manage<T>(&self, state: T) -> bool

where T: Send + Sync + 'static,

Add state to the state managed by the application.

fn state<T>(&self) -> State<'_, T>

where T: Send + Sync + 'static,

Retrieves the managed state for the type T.

fn try_state<T>(&self) -> Option<State<'_, T>>

where T: Send + Sync + 'static,

Attempts to retrieve the managed state for the type T.

fn env(&self) -> Env

Gets the managed Env.

fn fs_scope(&self) -> FsScope

Gets the scope for the filesystem APIs.

fn ipc_scope(&self) -> IpcScope

Gets the scope for the IPC.

fn asset_protocol_scope(&self) -> FsScope

Gets the scope for the asset protocol.

fn shell_scope(&self) -> ShellScope

Gets the scope for the shell execute APIs.