Struct 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> + Send + 'static>( &mut self, plugin: P, )

where <P as PluginBuilder<EventLoopMessage>>::Plugin: Send,

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

Stability

This API is unstable.

impl<R: Runtime> App<R>

pub fn on_menu_event<F: Fn(&AppHandle<R>, MenuEvent) + Send + Sync + 'static>( &self, handler: F, )

Registers a global menu event listener.

pub fn on_tray_icon_event<F: Fn(&AppHandle<R>, TrayIconEvent) + Send + Sync + 'static>( &self, handler: F, )

Available on desktop and crate feature tray-icon only.

Registers a global tray icon menu event listener.

pub fn tray_by_id<'a, I>(&self, id: &'a I) -> Option<TrayIcon<R>>

where I: ?Sized, TrayIconId: PartialEq<&'a I>,

Available on desktop and crate feature tray-icon only.

Gets a tray icon using the provided id.

pub fn remove_tray_by_id<'a, I>(&self, id: &'a I) -> Option<TrayIcon<R>>

where I: ?Sized, TrayIconId: PartialEq<&'a I>,

Available on desktop and crate feature tray-icon only.

Removes a tray icon using the provided id from tauri’s internal state and returns it.

Note that dropping the returned icon, may cause the tray icon to disappear if it wasn’t cloned somewhere else or referenced by JS.

pub fn config(&self) -> &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.

pub fn primary_monitor(&self) -> Result<Option<Monitor>>

Returns the primary monitor of the system.

Returns None if it can’t identify any monitor as a primary one.

pub fn monitor_from_point(&self, x: f64, y: f64) -> Result<Option<Monitor>>

Returns the monitor that contains the given point.

pub fn available_monitors(&self) -> Result<Vec<Monitor>>

Returns the list of all the monitors available on the system.

pub fn cursor_position(&self) -> Result<PhysicalPosition<f64>>

Get the cursor position relative to the top-left hand corner of the desktop.

Note that the top-left hand corner of the desktop is not necessarily the same as the screen. If the user uses a desktop with multiple monitors, the top-left hand corner of the desktop is the top-left hand corner of the main monitor on Windows and macOS or the top-left of the leftmost monitor on X11.

The coordinates can be negative if the top-left hand corner of the window is outside of the visible screen region.

pub fn set_theme(&self, theme: Option<Theme>)

Set the app theme.

pub fn default_window_icon(&self) -> Option<&Image<'_>>

Returns the default window icon.

pub fn menu(&self) -> Option<Menu<R>>

Returns the app-wide menu.

pub fn set_menu(&self, menu: Menu<R>) -> Result<Option<Menu<R>>>

Sets the app-wide menu and returns the previous one.

If a window was not created with an explicit menu or had one set explicitly, this menu will be assigned to it.

pub fn remove_menu(&self) -> Result<Option<Menu<R>>>

Remove the app-wide menu and returns it.

If a window was not created with an explicit menu or had one set explicitly, this will remove the menu from it.

pub fn hide_menu(&self) -> Result<()>

Hides the app-wide menu from windows that have it.

If a window was not created with an explicit menu or had one set explicitly, this will hide the menu from it.

pub fn show_menu(&self) -> Result<()>

Shows the app-wide menu for windows that have it.

If a window was not created with an explicit menu or had one set explicitly, this will show the menu for it.

pub fn cleanup_before_exit(&self)

Runs necessary cleanup tasks before exiting the process. You should always exit the tauri app immediately after this function returns and not use any tauri-related APIs.

pub fn invoke_key(&self) -> &str

Gets the invoke key that must be referenced when using crate::webview::InvokeRequest.

Security

DO NOT expose this key to third party scripts as might grant access to the backend from external URLs and iframes.

impl<R: Runtime> App<R>

pub fn run_on_main_thread<F: FnOnce() + Send + 'static>( &self, f: F, ) -> Result<()>

Runs the given closure on the main thread.

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 run<F: FnMut(&AppHandle<R>, RunEvent) + 'static>(self, callback: F)

Runs the application.

This function never returns. When the application finishes, the process is exited directly using std::process::exit. See run_return if you need to run code after the application event loop exits.

Panics

This function will panic if the setup-function supplied in Builder::setup fails.

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_return<F: FnMut(&AppHandle<R>, RunEvent) + 'static>( self, callback: F, ) -> i32

Runs the application, returning its intended exit code.

Note when using AppHandle::restart and AppHandle::request_restart, this function will handle the restart request, exit and restart the app without returning

Platform-specific

• iOS: Unsupported. The application will fallback to run.

Panics

This function will panic if the setup-function supplied in Builder::setup fails.

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");
let exit_code = app
  .run_return(|_app_handle, event| match event {
    tauri::RunEvent::ExitRequested { api, .. } => {
     api.prevent_exit();
    }
     _ => {}
  });

std::process::exit(exit_code);

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

👎Deprecated: When called in a loop (as suggested by the name), this function will busy-loop. To re-gain control of control flow after the app has exited, use App::run_return instead.

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

Note that when using this API, app cleanup is not automatically done. The cleanup calls App::cleanup_before_exit so you may want to call that function before exiting the application.

Examples

use tauri::Manager;

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 {
  app.run_iteration(|_app, _event| {});
  if app.webview_windows().is_empty() {
    app.cleanup_before_exit();
    break;
  }
}

Trait Implementations

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

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

Formats the value using the given formatter.

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

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

Emits an event to all targets.

fn emit_str(&self, event: &str, payload: String) -> Result<()>

Similar to Emitter::emit but the payload is json serialized.

fn emit_to<I, S>(&self, target: I, event: &str, payload: S) -> Result<()>

where I: Into<EventTarget>, S: Serialize + Clone,

Emits an event to all targets matching the given target.

fn emit_str_to<I>(&self, target: I, event: &str, payload: String) -> Result<()>

where I: Into<EventTarget>,

Similar to Emitter::emit_to but the payload is json serialized.

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

where S: Serialize + Clone, F: Fn(&EventTarget) -> bool,

Emits an event to all targets based on the given filter.

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

where F: Fn(&EventTarget) -> bool,

Similar to Emitter::emit_filter but the payload is json serialized.

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

fn display_handle(&self) -> Result<DisplayHandle<'_>, HandleError>

Get a handle to the display controller of the windowing system.

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

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

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

Listen to an event on this app.

Examples

use tauri::Listener;

tauri::Builder::default()
  .setup(|app| {
    app.listen("component-loaded", move |event| {
      println!("window just loaded a component");
    });

    Ok(())
  });

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

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

Listen to an event on this app only once.

See Self::listen for more information.

fn unlisten(&self, id: EventId)

Unlisten to an event on this app.

Examples

use tauri::Listener;

tauri::Builder::default()
  .setup(|app| {
    let handler = app.listen("component-loaded", move |event| {
      println!("app just loaded a component");
    });

    // stop listening to the event when you do not need it anymore
    app.unlisten(handler);

    Ok(())
  });

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

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

Listen to an emitted event to any target.

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

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

Listens once to an emitted event to any target .

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

fn resources_table(&self) -> MutexGuard<'_, ResourceTable>

Get a reference to the resources table of this manager.

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

The application handle associated with this manager.

fn config(&self) -> &Config

The Config the manager was created with.

fn package_info(&self) -> &PackageInfo

The PackageInfo the manager was created with.

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

Available on crate feature unstable only.

Fetch a single window from the manager.

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

Available on crate feature unstable only.

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

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

Available on crate feature unstable only.

Fetch all managed windows.

fn get_webview(&self, label: &str) -> Option<Webview<R>>

Available on crate feature unstable only.

Fetch a single webview from the manager.

fn webviews(&self) -> HashMap<String, Webview<R>>

Available on crate feature unstable only.

Fetch all managed webviews.

fn get_webview_window(&self, label: &str) -> Option<WebviewWindow<R>>

Fetch a single webview window from the manager.

fn webview_windows(&self) -> HashMap<String, WebviewWindow<R>>

Fetch all managed webview windows.

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

where T: Send + Sync + 'static,

Add state to the state managed by the application.

fn unmanage<T>(&self) -> Option<T>

where T: Send + Sync + 'static,

👎Deprecated since 2.3.0: This method is unsafe, since it can cause dangling references.

Removes the state managed by the application for T. Returns the state if it was actually removed.

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 asset_protocol_scope(&self) -> Scope

Gets the scope for the asset protocol.

fn path(&self) -> &PathResolver<R>

The path resolver.

fn add_capability(&self, capability: impl RuntimeCapability) -> Result<()>

Adds a capability to the app.