Tauri

https://docs.rs/tauri/2.9.3/
Admin
Tauri is a framework for building tiny, blazing fast desktop binaries for all major platforms by...
Tokens:633,954
Snippets:6,150
Trust Score:9.7
Update:5 hours ago
Show doc for...
Tokens:
Raw
### setup hook example

Source: https://docs.rs/tauri/2.9.3/tauri/struct.Builder.html

Shows how to define a setup hook that runs after the app is created. The example gets the main webview window and sets its title.

```rust
use tauri::Manager;
tauri::Builder::default()
  .setup(|app| {
    let main_window = app.get_webview_window("main").unwrap();
    main_window.set_title("Tauri!")?;
    Ok(())
  });
```

--------------------------------

### Setup callback with plugin state management

Source: https://docs.rs/tauri/2.9.3/src/tauri/plugin.rs.html

Registers a setup closure that runs when the plugin is registered. The example manages a PluginState struct using app.manage(). The closure receives the app handle and plugin API, and must return Ok(()) on success.

```rust
use tauri::{plugin::{Builder, TauriPlugin}, Runtime, Manager};
use std::path::PathBuf;

#[derive(Debug, Default)]
struct PluginState {
   dir: Option<PathBuf>
}

fn init<R: Runtime>() -> TauriPlugin<R> {
Builder::new("example")
  .setup(|app, api| {
    app.manage(PluginState::default());

    Ok(())
  })
  .build()
}
```

--------------------------------

### Setup hook example using tauri::Builder::setup

Source: https://docs.rs/tauri/2.9.3/src/tauri/app.rs.html

Shows how to use the setup hook to access the main webview window and set its title. The closure returns a Result with Box<dyn Error>.

```rust
use tauri::Manager;
tauri::Builder::default()
  .setup(|app| {
    let main_window = app.get_webview_window("main").unwrap();
    main_window.set_title("Tauri!")?;
    Ok(())
  });
```

--------------------------------

### Example: dynamically register plugin from a thread

Source: https://docs.rs/tauri/2.9.3/src/tauri/app.rs.html

Shows how to use AppHandle::plugin to register a plugin from a spawned thread inside the setup hook.

```rust
use tauri::{plugin::{Builder as PluginBuilder, TauriPlugin}, Runtime};

fn init_plugin<R: Runtime>() -> TauriPlugin<R> {
  PluginBuilder::new("dummy").build()
}

tauri::Builder::default()
  .setup(move |app| {
    let handle = app.handle().clone();
    std::thread::spawn(move || {
      handle.plugin(init_plugin());
    });

    Ok(())
  });
```

--------------------------------

### Run the application with run method

Source: https://docs.rs/tauri/2.9.3/src/tauri/app.rs.html

Example for the run method. It builds a Tauri app and runs it with a callback that prevents exit on ExitRequested. This function never returns and panics if setup fails.

```rust
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();
  }
  _ => {}
});
```

--------------------------------

### Listen to an event on the app

Source: https://docs.rs/tauri/2.9.3/src/tauri/app.rs.html

Example from the Listener trait documentation showing how to listen for an event named 'component-loaded' during app setup.

```rust
use tauri::Listener;

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

    Ok(())
  });
```

--------------------------------

### Listen to any event (Rust)

Source: https://docs.rs/tauri/2.9.3/src/tauri/lib.rs.html

Shows how to listen to an emitted event to any target using `listen_any`. The example defines a `synchronize` command that emits a 'synchronized' event, and then listens for it in the setup hook.

```rust
use tauri::{Manager, Emitter, Listener};

#[tauri::command]
fn synchronize(window: tauri::Window) {
  // emits the synchronized event to all windows
  window.emit("synchronized", ());
}

tauri::Builder::default()
  .setup(|app| {
    app.listen_any("synchronized", |event| {
      println!("app is in sync");
    });
    Ok(())
  })
  .invoke_handler(tauri::generate_handler![synchronize]);
```

--------------------------------

### invoke_system initialization script example

Source: https://docs.rs/tauri/2.9.3/src/tauri/app.rs.html

Example JavaScript initialization script that sets up a custom invoke system using __INVOKE_KEY__ and fetch to send IPC messages.

```javascript
const invokeKey = __INVOKE_KEY__;
fetch('my-impl://command', {
  headers: {
    'Tauri-Invoke-Key': invokeKey,
  }
})
```

--------------------------------

### initialization_script example

Source: https://docs.rs/tauri/2.9.3/src/tauri/webview/webview_window.rs.html

Adds a JavaScript initialization script that runs before the HTML document is parsed, only on the main frame. The example defines a constant script and uses it in a Tauri builder setup.

```rust
const INIT_SCRIPT: &str = r#"
  console.log("hello world from js init script");

  window.__MY_CUSTOM_PROPERTY__ = { foo: 'bar' };
"#;

fn main() {
  tauri::Builder::default()
    .setup(|app| {
      let webview = tauri::WebviewWindowBuilder::new(app, "label", tauri::WebviewUrl::App("index.html".into()))
        .initialization_script(INIT_SCRIPT)
        .build()?;
      Ok(())
    });
}
```

--------------------------------

### run example

Source: https://docs.rs/tauri/2.9.3/tauri/struct.App.html

Builds a Tauri app and runs it, preventing exit when an exit request is made. This function never returns and panics if the setup function fails.

```rust
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();
  }
  _ => {}
});
```

--------------------------------

### Example: Using restart in Tauri setup

Source: https://docs.rs/tauri/2.9.3/tauri/process/fn.restart.html

Shows how to call `restart` within a Tauri app's setup hook, passing the app's environment via `app.env()`. The function restarts the current binary and never returns.

```rust
use tauri::{process::restart, Env, Manager};

tauri::Builder::default()
  .setup(|app| {
    restart(&app.env());
    Ok(())
  });
```

--------------------------------

### Rust: Custom Builder with options and setup hook

Source: https://docs.rs/tauri/2.9.3/src/tauri/plugin.rs.html

Shows a more complex Builder pattern for plugins with configuration options. It defines a Builder struct with option fields, implements Default and builder methods, and uses PluginBuilder::new("example").setup(...) to use the options in the setup hook.

```rust
use tauri::{plugin::{Builder as PluginBuilder, TauriPlugin}, Runtime};

pub struct Builder {
  option_a: String,
  option_b: String,
  option_c: bool
}

impl Default for Builder {
  fn default() -> Self {
    Self {
      option_a: "foo".to_string(),
      option_b: "bar".to_string(),
      option_c: false
    }
  }
}

impl Builder {
  pub fn new() -> Self {
    Default::default()
  }

  pub fn option_a(mut self, option_a: String) -> Self {
    self.option_a = option_a;
    self
  }

  pub fn option_b(mut self, option_b: String) -> Self {
    self.option_b = option_b;
    self
  }

  pub fn option_c(mut self, option_c: bool) -> Self {
    self.option_c = option_c;
    self
  }

  pub fn build<R: Runtime>(self) -> TauriPlugin<R> {
    PluginBuilder::new("example")
      .setup(move |app_handle, api| {
        // use the options here to do stuff
        println!("a: {}, b: {}, c: {}", self.option_a, self.option_b, self.option_c);

        Ok(())
      })
      .build()
  }
}
```

--------------------------------

### Manage state with setup and State guard in Tauri commands

Source: https://docs.rs/tauri/2.9.3/src/tauri/lib.rs.html

Shows how to manage state in the setup hook and access it in commands using State and turbofish syntax. Includes assertions to verify state.

```rust
/// 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");
```

--------------------------------

### Listen to an event (Rust)

Source: https://docs.rs/tauri/2.9.3/src/tauri/lib.rs.html

Shows how to listen to an emitted event on the app. The example defines a `synchronize` command that emits a 'synchronized' event, and then listens for it in the setup hook. Panics if the event name contains characters other than alphanumeric, '-', '/', ':' and '_'.

```rust
use tauri::{Manager, Listener, Emitter};

#[tauri::command]
fn synchronize(window: tauri::Window) {
  // emits the synchronized event to all windows
  window.emit("synchronized", ());
}

tauri::Builder::default()
  .setup(|app| {
    app.listen("synchronized", |event| {
      println!("app is in sync");
    });
    Ok(())
  })
  .invoke_handler(tauri::generate_handler![synchronize]);
```

--------------------------------

### Builder::default().run() example

Source: https://docs.rs/tauri/2.9.3/src/tauri/app.rs.html

Example from the Builder documentation showing how to build and run a Tauri application. The comment notes that on an actual app, the string argument should be removed.

```rust
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");
```

--------------------------------

### Plugin registration example with tauri::Builder::plugin

Source: https://docs.rs/tauri/2.9.3/src/tauri/app.rs.html

Defines a Tauri plugin module with a command, setup, event handling, and invoke handler, then registers it with the builder. The command is callable from the frontend via invoke('plugin:window|do_something').

```rust
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, api| {
        // 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());
```

--------------------------------

### MenuBuilder usage example

Source: https://docs.rs/tauri/2.9.3/src/tauri/menu/builders/menu.rs.html

Example of using MenuBuilder to create a menu with various items, separators, and standard actions, then setting it on the app.

```rust
use tauri::menu::*;
tauri::Builder::default()
  .setup(move |app| {
    let handle = app.handle();
    # let icon1 = tauri::image::Image::new(&[], 0, 0);
    let menu = MenuBuilder::new(handle)
      .item(&MenuItem::new(handle, "MenuItem 1", true, None::<&str>)?)
      .items(&[
        &CheckMenuItem::new(handle, "CheckMenuItem 1", true, true, None::<&str>)?,
        &IconMenuItem::new(handle, "IconMenuItem 1", true, Some(icon1), None::<&str>)?,
      ])
      .separator()
      .cut()
      .copy()
      .paste()
      .separator()
      .text("item2", "MenuItem 2")
      .check("checkitem2", "CheckMenuItem 2")
      .icon("iconitem2", "IconMenuItem 2", app.default_window_icon().cloned().unwrap())
      .build()?;
    app.set_menu(menu);
    Ok(())
  });
```

--------------------------------

### with_webview platform-specific setup example

Source: https://docs.rs/tauri/2.9.3/src/tauri/webview/mod.rs.html

Shows how to use `with_webview` in a Tauri setup hook to access the platform webview and apply platform-specific operations like zoom, script removal, and background color. Includes conditional compilation for Linux, Windows, macOS, and Android. Note that `webview2-com`, `webkit2gtk`, `objc2_web_kit` and similar crates may be updated in minor releases of Tauri, so pin Tauri to at least a minor version when using `with_webview`.

```rust
use tauri::Manager;

tauri::Builder::default()
  .setup(|app| {
    let main_webview = app.get_webview("main").unwrap();
    main_webview.with_webview(|webview| {
      #[cfg(target_os = "linux")]
      {
        // see <https://docs.rs/webkit2gtk/2.0.0/webkit2gtk/struct.WebView.html>
        // and <https://docs.rs/webkit2gtk/2.0.0/webkit2gtk/trait.WebViewExt.html>
        use webkit2gtk::WebViewExt;
        webview.inner().set_zoom_level(4.);
      }

      #[cfg(windows)]
      unsafe {
        // see https://docs.rs/webview2-com/0.19.1/webview2_com/Microsoft/Web/WebView2/Win32/struct.ICoreWebView2Controller.html
        webview.controller().SetZoomFactor(4.).unwrap();
      }

      #[cfg(target_os = "macos")]
      unsafe {
        let view: &objc2_web_kit::WKWebView = &*webview.inner().cast();
        let controller: &objc2_web_kit::WKUserContentController = &*webview.controller().cast();
        let window: &objc2_app_kit::NSWindow = &*webview.ns_window().cast();

        view.setPageZoom(4.);
        controller.removeAllUserScripts();
        let bg_color = objc2_app_kit::NSColor::colorWithDeviceRed_green_blue_alpha(0.5, 0.2, 0.4, 1.);
        window.setBackgroundColor(Some(&bg_color));
      }

      #[cfg(target_os = "android")]
      {
        use jni::objects::JValue;
        webview.jni_handle().exec(|env, _, webview| {
          env.call_method(webview, "zoomBy", "(F)V", &[JValue::Float(4.)]).unwrap();
        })
      }
    });
    Ok(())
});
```

--------------------------------

### Initialize plugins and return app

Source: https://docs.rs/tauri/2.9.3/src/tauri/app.rs.html

Initializes all plugins with the app handle and returns the built App instance.

```rust
app.manager.initialize_plugins(handle)?;

Ok(app)
```

--------------------------------

### PathResolver::parse method with example

Source: https://docs.rs/tauri/2.9.3/src/tauri/path/mod.rs.html

Parses a path, resolving a BaseDirectory variable if the path starts with one. The example shows usage in a Tauri setup hook, asserting the parsed path.

```rust
pub fn parse<P: AsRef<Path>>(&self, path: P) -> Result<PathBuf> {
  let mut p = PathBuf::new();
  let mut components = path.as_ref().components();
  match components.next() {
    Some(Component::Normal(str)) => {
```

```rust
use tauri::Manager;
tauri::Builder::default()
  .setup(|app| {
    let path = app.path().parse("$HOME/.bashrc")?;
    assert_eq!(path.to_str().unwrap(), "/home/${whoami}/.bashrc");
    Ok(())
  });
```

--------------------------------

### Resolving command scope in setup

Source: https://docs.rs/tauri/2.9.3/src/tauri/webview/mod.rs.html

Example of resolving a command scope for a webview in the setup hook. Uses Manager to get the webview window and calls resolve_command_scope.

```rust
use tauri::Manager;

#[derive(Debug, serde::Deserialize)]
struct ScopeType {
  some_value: String,
}

tauri::Builder::default()
  .setup(|app| {
    let webview = app.get_webview_window("main").unwrap();
    let scope = webview.resolve_command_scope::<ScopeType>("my-plugin", "read");
    Ok(())
  });
```

--------------------------------

### set_dock_visibility example

Source: https://docs.rs/tauri/2.9.3/src/tauri/app.rs.html

Example usage of set_dock_visibility in a Tauri setup hook, hiding the dock icon on macOS.

```rust
tauri::Builder::default()
  .setup(move |app| {
    #[cfg(target_os = "macos")]
    app.handle().set_dock_visibility(false);
    Ok(())
  });
```

--------------------------------

### set_activation_policy example

Source: https://docs.rs/tauri/2.9.3/src/tauri/app.rs.html

Example usage of set_activation_policy in a Tauri setup hook, setting the activation policy to Accessory on macOS.

```rust
tauri::Builder::default()
  .setup(move |app| {
    #[cfg(target_os = "macos")]
    app.handle().set_activation_policy(tauri::ActivationPolicy::Accessory);
    Ok(())
  });
```

--------------------------------

### PredefinedMenuItem::show_all

Source: https://docs.rs/tauri/2.9.3/src/tauri/menu/predefined.rs.html

Creates a show all app windows menu item. Unsupported on Windows and Linux.

```APIDOC
## PredefinedMenuItem::show_all

### Description
Creates a show all app windows menu item. Unsupported on Windows and Linux.

### Method
`pub fn show_all<M: Manager<R>>(manager: &M, text: Option<&str>) -> crate::Result<Self>`

### Parameters
- **manager** (`&M`) - Required - The manager instance (e.g., AppHandle) used to get the app handle.
- **text** (`Option<&str>`) - Optional - The text for the menu item.

### Returns
- `crate::Result<Self>` - The created PredefinedMenuItem or an error.

### Platform-specific
- **Windows / Linux:** Unsupported.
```

--------------------------------

### PathResolver::resolve method with example

Source: https://docs.rs/tauri/2.9.3/src/tauri/path/mod.rs.html

Resolves a path relative to a base directory. The example shows usage in a Tauri setup hook, asserting the resolved path.

```rust
pub fn resolve<P: AsRef<Path>>(&self, path: P, base_directory: BaseDirectory) -> Result<PathBuf> {
  resolve_path::<R>(self, base_directory, Some(path.as_ref().to_path_buf()))
}
```

```rust
use tauri::{path::BaseDirectory, Manager};
tauri::Builder::default()
  .setup(|app| {
    let path = app.path().resolve("path/to/something", BaseDirectory::Config)?;
    assert_eq!(path.to_str().unwrap(), "/home/${whoami}/.config/path/to/something");
    Ok(())
  });
```

--------------------------------

### Using current_binary in Tauri setup

Source: https://docs.rs/tauri/2.9.3/tauri/process/fn.current_binary.html

Shows two ways to call current_binary: directly with Env::default() and within the Tauri setup hook using app.env(). The setup example uses the ? operator to propagate errors.

```rust
use tauri::{process::current_binary, Env, Manager};
let current_binary_path = current_binary(&Env::default()).unwrap();

tauri::Builder::default()
  .setup(|app| {
    let current_binary_path = current_binary(&app.env())?;
    Ok(())
  });
```

--------------------------------

### Builder::setup

Source: https://docs.rs/tauri/2.9.3/src/tauri/app.rs.html

Defines the setup hook that runs once when the application is initialized. The closure receives a mutable reference to the App and can return an error to abort startup.

```APIDOC
## Builder::setup

### Description
Defines the setup hook that runs once when the application is initialized. The closure receives a mutable reference to the App and can return an error to abort startup.

### Method
setup

### Signature
pub fn setup<F>(mut self, setup: F) -> Self
where
    F: FnOnce(&mut App<R>) -> std::result::Result<(), Box<dyn std::error::Error>> + Send + 'static,

### Parameters
- **setup** (FnOnce(&mut App<R>) -> Result<(), Box<dyn Error>>) - Required - The setup closure.

### Example
```rust
use tauri::Manager;
tauri::Builder::default()
  .setup(|app| {
    let main_window = app.get_webview_window("main").unwrap();
    main_window.set_title("Tauri!")?;
    Ok(())
  });
```
```

--------------------------------

### with_config(config: &WindowConfig)

Source: https://docs.rs/tauri/2.9.3/tauri/test/struct.MockWindowBuilder.html

Initializes a new window builder from a `WindowConfig`.

```APIDOC
## with_config(config: &WindowConfig)

### Description
Initializes a new window builder from a `WindowConfig`.

### Method
with_config

### Signature
`fn with_config(config: &WindowConfig) -> Self`

### Parameters
- **config** (`&WindowConfig`) - Required - The configuration to initialize the builder from.

### Returns
- **Self** - A new `MockWindowBuilder` instance.
```

--------------------------------

### initialization_script_for_all_frames example

Source: https://docs.rs/tauri/2.9.3/src/tauri/webview/webview_window.rs.html

Adds a JavaScript initialization script that runs on all frames (main and subframes) before the HTML document is parsed. The example guards execution by checking the window origin and uses the method in a Tauri builder setup.

```rust
const INIT_SCRIPT: &str = r#"
  if (window.location.origin === 'https://tauri.app') {
    console.log("hello world from js init script");

    window.__MY_CUSTOM_PROPERTY__ = { foo: 'bar' };
  }
"#;

fn main() {
  tauri::Builder::default()
    .setup(|app| {
      let webview = tauri::WebviewWindowBuilder::new(app, "label", tauri::WebviewUrl::App("index.html".into()))
        .initialization_script_for_all_frames(INIT_SCRIPT)
        .build()?;
      Ok(())
    });
}
```

--------------------------------

### start_resize_dragging(&self, direction: ResizeDirection) -> Result<()>

Source: https://docs.rs/tauri/2.9.3/tauri/test/struct.MockWindowDispatcher.html

Starts resize-dragging the window.

```APIDOC
## start_resize_dragging(&self, direction: ResizeDirection) -> Result<()>

### Description
Starts resize-dragging the window.

### Method
start_resize_dragging

### Parameters
- **direction** (ResizeDirection) - Required - The resize direction.

### Return
Result<()>
```

--------------------------------

### Example: Using tauri::test utilities to test a command

Source: https://docs.rs/tauri/2.9.3/src/tauri/test/mod.rs.html

Shows how to build a Tauri app with a mock builder, create a webview, and invoke a command to assert its response. Uses mock_builder() instead of the default runtime, and get_ipc_response to run the 'ping' command. The comment notes to remove the string argument to use your app's config file.

```rust
use tauri::test::{mock_builder, mock_context, noop_assets};

#[tauri::command]
fn ping() -> &'static str {
    "pong"
}

fn create_app<R: tauri::Runtime>(builder: tauri::Builder<R>) -> tauri::App<R> {
    builder
        .invoke_handler(tauri::generate_handler![ping])
        // remove the string argument to use your app's config file
        .build(tauri::generate_context!("test/fixture/src-tauri/tauri.conf.json"))
        .expect("failed to build app")
}

fn main() {
    // Use `tauri::Builder::default()` to use the default runtime rather than the `MockRuntime`;
    // let app = create_app(tauri::Builder::default());
    let app = create_app(mock_builder());
    let webview = tauri::WebviewWindowBuilder::new(&app, "main", Default::default()).build().unwrap();

    // run the `ping` command and assert it returns `pong`
    let res = tauri::test::get_ipc_response(
        &webview,
        tauri::webview::InvokeRequest {
            cmd: "ping".into(),
            callback: tauri::ipc::CallbackFn(0),
            error: tauri::ipc::CallbackFn(1),
            // alternatively use "tauri://localhost"
            url: "http://tauri.localhost".parse().unwrap(),
            body: tauri::ipc::InvokeBody::default(),
            headers: Default::default(),
            invoke_key: tauri::test::INVOKE_KEY.to_string(),
        },
    ).map(|b| b.deserialize::<String>().unwrap());
}
```

--------------------------------

### show_all

Source: https://docs.rs/tauri/2.9.3/src/tauri/menu/builders/menu.rs.html

Adds a Show all app windows menu item to the menu. Unsupported on Windows and Linux.

```APIDOC
## show_all

### Description
Adds a Show all app windows menu item to the menu. Unsupported on Windows and Linux.

### Method
show_all()

### Parameters
None

### Platform-specific
- **Windows / Linux:** Unsupported.

### Returns
Self (builder pattern)

```

--------------------------------

### NoopAsset::setup

Source: https://docs.rs/tauri/2.9.3/tauri/test/struct.NoopAsset.html

Initializes the asset provider.

```APIDOC
## [POST] NoopAsset::setup

### Description
Initialize the asset provider.

### Method
`fn setup(&self, app: &App<R>)`

### Parameters
- **app** (`&App<R>`) - Required - The application instance.

### Returns
- `()` - No return value.

```

--------------------------------

### listen example: synchronize event

Source: https://docs.rs/tauri/2.9.3/tauri/trait.Listener.html

Shows how to use the listen method to react to an emitted event. The example emits a 'synchronized' event from a command and listens for it in the setup hook. Panics if the event name contains characters other than alphanumeric, '-', '/', ':' and '_'.

```rust
use tauri::{Manager, Listener, Emitter};

#[tauri::command]
fn synchronize(window: tauri::Window) {
  // emits the synchronized event to all windows
  window.emit("synchronized", ());
}

tauri::Builder::default()
  .setup(|app| {
    app.listen("synchronized", |event| {
      println!("app is in sync");
    });
    Ok(())
  })
  .invoke_handler(tauri::generate_handler![synchronize]);
```

--------------------------------

### Set menu with tauri::Builder::menu

Source: https://docs.rs/tauri/2.9.3/src/tauri/app.rs.html

Demonstrates setting a menu on all windows using the menu method. The example creates a File submenu with a close window predefined item and, on macOS, a custom Hello menu item.

```rust
use tauri::menu::{Menu, MenuItem, PredefinedMenuItem, Submenu};

tauri::Builder::default()
  .menu(|handle| Menu::with_items(handle, &[
    &Submenu::with_items(
      handle,
      "File",
      true,
      &[
        &PredefinedMenuItem::close_window(handle, None)?,
        #[cfg(target_os = "macos")]
        &MenuItem::new(handle, "Hello", true, None::<&str>)?,
      ],
    )?
  ]));
```

--------------------------------

### MenuBuilder usage example

Source: https://docs.rs/tauri/2.9.3/tauri/menu/struct.MenuBuilder.html

This example shows how to use MenuBuilder to create a menu with various items and set it as the application menu. It is used in the setup hook of the Tauri builder. Note that on macOS, if used for the global menubar, it can only contain Submenus.

```rust
use tauri::menu::*;
tauri::Builder::default()
  .setup(move |app| {
    let handle = app.handle();
    let menu = MenuBuilder::new(handle)
      .item(&MenuItem::new(handle, "MenuItem 1", true, None::<&str>)?)
      .items(&[
        &CheckMenuItem::new(handle, "CheckMenuItem 1", true, true, None::<&str>)?,
        &IconMenuItem::new(handle, "IconMenuItem 1", true, Some(icon1), None::<&str>)?,
      ])
      .separator()
      .cut()
      .copy()
      .paste()
      .separator()
      .text("item2", "MenuItem 2")
      .check("checkitem2", "CheckMenuItem 2")
      .icon("iconitem2", "IconMenuItem 2", app.default_window_icon().cloned().unwrap())
      .build()?;
    app.set_menu(menu);
    Ok(())
  });
```

--------------------------------

### listen_any example: listen to any target

Source: https://docs.rs/tauri/2.9.3/tauri/trait.Listener.html

Shows how to use the listen_any method to listen to an emitted event to any target. The example emits a 'synchronized' event from a command and listens for it in the setup hook. Panics if the event name contains characters other than alphanumeric, '-', '/', ':' and '_'.

```rust
use tauri::{Manager, Emitter, Listener};

#[tauri::command]
fn synchronize(window: tauri::Window) {
  // emits the synchronized event to all windows
  window.emit("synchronized", ());
}

tauri::Builder::default()
  .setup(|app| {
    app.listen_any("synchronized", |event| {
      println!("app is in sync");
    });
    Ok(())
  })
  .invoke_handler(tauri::generate_handler![synchronize]);
```

--------------------------------

### PathResolver::parse

Source: https://docs.rs/tauri/2.9.3/src/tauri/path/mod.rs.html

Parses a path string, resolving a BaseDirectory variable if the path starts with one. For example, "$HOME/.bashrc" is resolved to the home directory path.

```APIDOC
## PathResolver::parse

### Description
Parses a path string, resolving a BaseDirectory variable if the path starts with one. For example, "$HOME/.bashrc" is resolved to the home directory path.

### Method
`pub fn parse<P: AsRef<Path>>(&self, path: P) -> Result<PathBuf>`

### Parameters
- `path` (P) - The path string to parse.

### Returns
- `Result<PathBuf>` - The resolved path.

### Example
```rust
use tauri::Manager;
tauri::Builder::default()
  .setup(|app| {
    let path = app.path().parse("$HOME/.bashrc")?;
    assert_eq!(path.to_str().unwrap(), "/home/${whoami}/.bashrc");
    Ok(())
  });
```
```

--------------------------------

### start_resize_dragging

Source: https://docs.rs/tauri/2.9.3/src/tauri/window/mod.rs.html

Starts resize-dragging the window.

```APIDOC
## start_resize_dragging

### Description
Starts resize-dragging the window.

### Method
Function call

### Signature
`pub fn start_resize_dragging(&self, direction: tauri_runtime::ResizeDirection) -> crate::Result<()>`

### Parameters
- **direction** (tauri_runtime::ResizeDirection) - Required - The direction for resizing.

### Return Value
- `crate::Result<()>` - Returns `Ok(())` on success, or an error.
```

--------------------------------

### Builder::setup

Source: https://docs.rs/tauri/2.9.3/src/tauri/plugin.rs.html

Defines a closure that runs when the plugin is registered. The closure receives the app handle and plugin API, and can be used to manage state or perform setup tasks.

```APIDOC
## Builder::setup

### Description
Defines a closure that runs when the plugin is registered. The closure receives the app handle and plugin API, and can be used to manage state or perform setup tasks.

### Method
Builder method

### Signature
pub fn setup<F>(mut self, setup: F) -> Self
where
    F: FnOnce(&AppHandle<R>, PluginApi<R, C>) -> Result<(), Box<dyn std::error::Error>> + Send + 'static,

### Parameters
- **setup** (F) - Required - A closure that takes the app handle and plugin API and returns a Result.

### Returns
- **Self** - The builder instance for chaining.

### Example
```rust
use tauri::{plugin::{Builder, TauriPlugin}, Runtime, Manager};
use std::path::PathBuf;

#[derive(Debug, Default)]
struct PluginState {
   dir: Option<PathBuf>
}

fn init<R: Runtime>() -> TauriPlugin<R> {
  Builder::new("example")
    .setup(|app, api| {
      app.manage(PluginState::default());
      Ok(())
    })
    .build()
}
```
```

--------------------------------

### path: Return percent-encoded path

Source: https://docs.rs/tauri/2.9.3/tauri/struct.Url.html

Returns the URL's path as a percent-encoded ASCII string. For cannot-be-a-base URLs it is an arbitrary string not starting with '/'; otherwise it starts with '/' and contains slash-separated segments. The example shows paths for URLs with and without a path, and percent-encoding of non-ASCII characters.

```rust
use url::{Url, ParseError};

let url = Url::parse("https://example.com/api/versions?page=2")?;
assert_eq!(url.path(), "/api/versions");

let url = Url::parse("https://example.com")?;
assert_eq!(url.path(), "/");

let url = Url::parse("https://example.com/countries/việt nam")?;
assert_eq!(url.path(), "/countries/vi%E1%BB%87t%20nam");
```

--------------------------------

### path() Example

Source: https://docs.rs/tauri/2.9.3/tauri/webview/struct.Cookie.html

Shows how to use Cookie::path() to get the Path attribute of a cookie. Returns None when no Path is specified, and Some(&str) when present.

```rust
use cookie::Cookie;

let c = Cookie::parse("name=value").unwrap();
assert_eq!(c.path(), None);

let c = Cookie::parse("name=value; Path=/").unwrap();
assert_eq!(c.path(), Some("/"));

let c = Cookie::parse("name=value; path=/sub").unwrap();
assert_eq!(c.path(), Some("/sub"));
```

--------------------------------

### mock_builder example: build with custom config

Source: https://docs.rs/tauri/2.9.3/src/tauri/test/mod.rs.html

Shows how to create a mock builder and build an app using a custom config file path. The comment notes to remove the string argument to use the app's config file.

```rust
let app = tauri::test::mock_builder()
  // remove the string argument to use your app's config file
  .build(tauri::generate_context!("test/fixture/src-tauri/tauri.conf.json"))
  .unwrap();
```

--------------------------------

### Builder::setup

Source: https://docs.rs/tauri/2.9.3/tauri/struct.Builder.html

Defines the setup hook.

```APIDOC
## Builder::setup

### Description
Defines the setup hook.

### Method
`pub fn setup<F>(self, setup: F) -> Self`

### Parameters
- **setup** (F) - Required - A closure that takes a `&mut App<R>` and returns a `Result<(), Box<dyn Error>>`. Must be `Send + 'static`.

### Returns
`Self` - The builder instance for chaining.

### Example
```rust
use tauri::Manager;
tauri::Builder::default()
  .setup(|app| {
    let main_window = app.get_webview_window("main").unwrap();
    main_window.set_title("Tauri!")?;
    Ok(())
  });
```
```

--------------------------------

### max_age() Example

Source: https://docs.rs/tauri/2.9.3/tauri/webview/struct.Cookie.html

Shows how to use Cookie::max_age() to get the max-age of a cookie. Returns None when no Max-Age attribute is specified, and Some(Duration) when present.

```rust
use cookie::Cookie;

let c = Cookie::parse("name=value").unwrap();
assert_eq!(c.max_age(), None);

let c = Cookie::parse("name=value; Max-Age=3600").unwrap();
assert_eq!(c.max_age().map(|age| age.whole_hours()), Some(1));
```

--------------------------------

### append_invoke_initialization_script example

Source: https://docs.rs/tauri/2.9.3/src/tauri/app.rs.html

Shows how to append a custom initialization script that builds on the Tauri invoke system, using a custom invoke function that logs calls and arguments.

```rust
let custom_script = r#"
// A custom call system bridge build on top of tauri invoke system.
async function invoke(cmd, args = {}) {
  if (!args) args = {};

  let prefix = "";

  if (args?.__module) {
    prefix = `plugin:hybridcall.${args.__module}|`;
  }

  const command = `${prefix}tauri_${cmd}`;

  const invoke = window.__TAURI_INTERNALS__.invoke;

  return invoke(command, args).then(result => {
    if (window.build.debug) {
      console.log(`call: ${command}`);
      console.log(`args: ${JSON.stringify(args)}`);
      console.log(`return: ${JSON.stringify(result)}`);
    }

    return result;
  });
}
"#;

tauri::Builder::default()
  .append_invoke_initialization_script(custom_script);
```

--------------------------------

### webview_windows

Source: https://docs.rs/tauri/2.9.3/tauri/struct.AppHandle.html

Fetch all managed webview windows.

```APIDOC
## webview_windows

### Description
Fetch all managed webview windows.

### Method
webview_windows

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

### Return Value
- **HashMap<String, WebviewWindow<R>>** - A map of webview window labels to webview windows.
```

--------------------------------

### Set dock visibility on macOS

Source: https://docs.rs/tauri/2.9.3/src/tauri/app.rs.html

Sets the dock visibility to `false` on macOS using `app.set_dock_visibility`. The example is wrapped in a `#[cfg(target_os = "macos")]` attribute and runs in the setup closure.

```rust
tauri::Builder::default()
  .setup(move |app| {
    #[cfg(target_os = "macos")]
    app.set_dock_visibility(false);
    Ok(())
  });
```

--------------------------------

### Set activation policy on macOS

Source: https://docs.rs/tauri/2.9.3/src/tauri/app.rs.html

Sets the activation policy to `Accessory` on macOS using `app.set_activation_policy`. The example is wrapped in a `#[cfg(target_os = "macos")]` attribute and runs in the setup closure.

```rust
tauri::Builder::default()
  .setup(move |app| {
    #[cfg(target_os = "macos")]
    app.set_activation_policy(tauri::ActivationPolicy::Accessory);
    Ok(())
  });
```

--------------------------------

### App::run

Source: https://docs.rs/tauri/2.9.3/src/tauri/app.rs.html

Runs the application event loop. This function never returns; when the application finishes, the process exits directly. It panics if the setup function fails.

```APIDOC
## App::run

### Description
Runs the application event loop. This function never returns; when the application finishes, the process exits directly using `std::process::exit`. See `run_return` if you need to run code after the event loop exits.

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

### Parameters
- `callback` (FnMut(&AppHandle<R>, RunEvent)) - Required - A callback that receives the app handle and run events.

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

### Examples
```rust,no_run
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();
  }
  _ => {}
});
```
```

--------------------------------

### show

Source: https://docs.rs/tauri/2.9.3/tauri/test/struct.MockWebviewDispatcher.html

Shows the webview.

```APIDOC
## show

### Description
Shows the webview.

### Method
Function

### Signature
`fn show(&self) -> Result<()>`

### Parameters
None

### Returns
- `Result<()>` - Ok if the webview was shown, Err otherwise.
```

--------------------------------

### Listen to an event on the app

Source: https://docs.rs/tauri/2.9.3/tauri/struct.App.html

Registers a listener for an event on the app. The handler is called whenever the event is emitted. The example shows using `app.listen` inside the setup hook.

```rust
use tauri::Listener;

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

    Ok(())
  });
```

--------------------------------

### Create a webview in the setup hook

Source: https://docs.rs/tauri/2.9.3/src/tauri/webview/mod.rs.html

Shows how to create a webview in the setup hook using WebviewBuilder::new and window.add_child. On Windows, this function deadlocks when used in a synchronous command or event handlers; use async commands and separate threads instead.

```rust
tauri::Builder::default()
  .setup(|app| {
    let window = tauri::window::WindowBuilder::new(app, "label").build()?;
    let webview_builder = tauri::webview::WebviewBuilder::new("label", tauri::WebviewUrl::App("index.html".into()));
    let webview = window.add_child(webview_builder, tauri::LogicalPosition::new(0, 0), window.inner_size().unwrap());
    Ok(())
  });
```

--------------------------------

### Creation from task::spawn

Source: https://docs.rs/tauri/2.9.3/tauri/async_runtime/struct.TokioJoinHandle.html

Creates a TokioJoinHandle by spawning an asynchronous task with tokio::task::spawn. The task starts running immediately. The handle can be awaited to get the task's output.

```rust
use tokio::task;

let join_handle: task::JoinHandle<_> = task::spawn(async {
    // some work here
});
```

--------------------------------

### PredefinedMenuItem::show_all

Source: https://docs.rs/tauri/2.9.3/tauri/menu/struct.PredefinedMenuItem.html

Creates a show all app windows menu item with optional custom text. Not supported on Windows and Linux.

```APIDOC
## PredefinedMenuItem::show_all

### Description
Creates a show all app windows menu item with optional custom text. Not supported on Windows and Linux.

### Method
`pub fn show_all<M: Manager<R>>(manager: &M, text: Option<&str>) -> Result<Self>`

### Parameters
- **manager** (`&M`) - Required - The manager instance.
- **text** (`Option<&str>`) - Optional - The text for the menu item.

### Returns
- `Result<Self>` - The created `PredefinedMenuItem` or an error.

### Platform-specific
- **Windows / Linux:** Unsupported.
```

--------------------------------

### Listen to window event with tauri::Listener

Source: https://docs.rs/tauri/2.9.3/src/tauri/window/mod.rs.html

Registers a listener for the 'component-loaded' event on the 'main' window inside the Tauri setup hook. Requires the `unstable` feature to render this documentation example.

```rust
use tauri::{Manager, Listener};

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

    Ok(())
  });
```

--------------------------------

### navigate

Source: https://docs.rs/tauri/2.9.3/tauri/test/struct.MockWebviewDispatcher.html

Navigates to the given URL.

```APIDOC
## navigate

### Description
Navigates to the given URL.

### Method
Function

### Signature
`fn navigate(&self, url: Url) -> Result<()>`

### Parameters
- **url** (Url) - Required - The URL to navigate to.

### Returns
- `Result<()>` - Ok if navigation succeeded, Err otherwise.
```

--------------------------------

### Register plugin dynamically with handle.plugin

Source: https://docs.rs/tauri/2.9.3/tauri/struct.AppHandle.html

Shows how to register a Tauri plugin dynamically after the app starts, e.g., from a background thread. The plugin is created with PluginBuilder and added via handle.plugin in the setup hook.

```rust
use tauri::{plugin::{Builder as PluginBuilder, TauriPlugin}, Runtime};

fn init_plugin<R: Runtime>() -> TauriPlugin<R> {
  PluginBuilder::new("dummy").build()
}

tauri::Builder::default()
  .setup(move |app| {
    let handle = app.handle().clone();
    std::thread::spawn(move || {
      handle.plugin(init_plugin());
    });

    Ok(())
  });
```

--------------------------------

### start_dragging

Source: https://docs.rs/tauri/2.9.3/src/tauri/window/mod.rs.html

Starts dragging the window.

```APIDOC
## start_dragging

### Description
Starts dragging the window.

### Method
Function call

### Signature
`pub fn start_dragging(&self) -> crate::Result<()>`

### Return Value
- `crate::Result<()>` - Returns `Ok(())` on success, or an error.
```

--------------------------------

### expires_datetime() Example

Source: https://docs.rs/tauri/2.9.3/tauri/webview/struct.Cookie.html

Shows how to use Cookie::expires_datetime() to get the expiration date-time of a cookie. Returns None when no expiration is set, even when expires() returns Some(Expiration::Session), and Some(OffsetDateTime) when an Expires attribute is present.

```rust
use cookie::Cookie;

let c = Cookie::parse("name=value").unwrap();
assert_eq!(c.expires_datetime(), None);

// Here, `cookie.expires()` returns `Some`.
let c = Cookie::build(("name", "value")).expires(None).build();
assert_eq!(c.expires_datetime(), None);

let expire_time = "Wed, 21 Oct 2017 07:28:00 GMT";
let cookie_str = format!("name=value; Expires={}", expire_time);
let c = Cookie::parse(cookie_str).unwrap();
assert_eq!(c.expires_datetime().map(|t| t.year()), Some(2017));
```
Tokens:
Raw