Tauri

https://docs.rs/tauri/2.9.2/
Admin
Tauri is a framework for building tiny, blazing fast binaries for all major desktop platforms,...
Tokens:601,689
Snippets:5,973
Trust Score:9.7
Update:5 hours ago
Show doc for...
Tokens:
Raw
### Setup hook with get_webview_window and set_title

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

Use the setup hook to run code after the app is created. This example retrieves the main webview window and sets its title, returning Ok(()) on success.

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

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

### initialization_script example

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

Adds a JavaScript initialization script that runs before any other script on the page. The example defines a constant INIT_SCRIPT and uses it in a Tauri setup closure.

```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(INIT_SCRIPT)
        .build()?;
      Ok(())
    });
}
```

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

### Create a WebviewWindow in the setup hook

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

Use this example to create a webview window during the Tauri setup hook. The builder is initialized with the app manager, a label, and a WebviewUrl pointing to an app page. On Windows, avoid using this in synchronous commands or event handlers due to a known deadlock issue.

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

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

### initialization_script_for_all_frames example

Source: https://docs.rs/tauri/2.9.2/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 defines a constant INIT_SCRIPT and uses it in a Tauri setup closure.

```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(())
    });
}
```

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

### plugin method with example

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

Adds a Tauri application plugin dynamically, e.g., after login. Prefer Builder::plugin for plugins created at app start. The example shows registering a plugin from a spawned thread.

```rust
pub fn plugin<P: Plugin<R> + 'static>(&self, plugin: P) -> crate::Result<()> {
  self.plugin_boxed(Box::new(plugin))
}
```

```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(())
  });
```

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

### Listen to an event on any target with listen_any

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

Registers a listener for an event emitted to any target using the `listen_any` method. The example defines a `synchronize` command that emits the 'synchronized' event to all windows, and sets up a listener in the app setup that prints a message when the event is received. 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]);
```

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

### Example tauri.config.json file

Source: https://docs.rs/tauri/2.9.2/tauri/struct.Config.html

Example JSON configuration file for a Tauri application, showing productName, version, build commands, devUrl, frontendDist, app security and window settings, bundle, and plugins.

```json
{
  "productName": "tauri-app",
  "version": "0.1.0",
  "build": {
    "beforeBuildCommand": "",
    "beforeDevCommand": "",
    "devUrl": "http://localhost:3000",
    "frontendDist": "../dist"
  },
  "app": {
    "security": {
      "csp": null
    },
    "windows": [
      {
        "fullscreen": false,
        "height": 600,
        "resizable": true,
        "title": "Tauri App",
        "width": 800
      }
    ]
  },
  "bundle": {},
  "plugins": {}
}
```

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

### Builder::setup

Source: https://docs.rs/tauri/2.9.2/tauri/plugin/struct.Builder.html

Sets up a setup hook for the plugin. This method is used to configure the plugin's setup behavior.

```APIDOC
## Builder::setup

### Description
Sets up a setup hook for the plugin.

### Method
`setup`

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

### Parameters
- **setup** (`F`) - Required - A closure that receives the app handle and API, and returns a result.

### Example
```rust
Builder::new("example")
  .setup(|app_handle, api| {
    // setup logic
    Ok(())
  })
  .build()
```
```

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

### Run Tauri App with Builder and generate_context

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

Shows the minimal setup to run a Tauri application using the Builder. The string argument in generate_context is a placeholder; on an actual app, remove it and provide the correct path to the tauri.conf.json file. The run method returns a Result, and the example expects success, panicking on error.

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

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

### start_dragging

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

Starts dragging the window.

```APIDOC
## start_dragging

### Description
Starts dragging the window.

### Method
Rust method

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

### Returns
`crate::Result<()>` - Ok on success, Err on failure.
```

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

### Get URL path with path()

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

Returns the percent-encoded ASCII path of the URL. For cannot-be-a-base URLs it returns an arbitrary string not starting with '/', otherwise it starts with '/' and contains slash-separated segments. The example shows paths for various URLs, including 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");
```

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

### setup_events function with listener macro

Source: https://docs.rs/tauri/2.9.2/src/tauri/manager/mod.rs.html

Builds a mock app, window, webview, and webview_window, then sets up listeners for TEST_EVENT_NAME using a macro. If setup_any is true, also registers listen_any listeners. Returns an EventSetup with the channel for receiving events.

```rust
fn setup_events(setup_any: bool) -> EventSetup {
  let app = mock_app();

  let window = WindowBuilder::new(&app, "main-window").build().unwrap();

  let webview = window
    .add_child(
      WebviewBuilder::new("main-webview", Default::default()),
      crate::LogicalPosition::new(0, 0),
      window.inner_size().unwrap(),
    )
    .unwrap();

  let webview_window = WebviewWindowBuilder::new(&app, "main-webview-window", Default::default())
    .build()
    .unwrap();

  let (tx, rx) = channel();

  macro_rules! setup_listener {
    ($type:ident, $id:ident, $any_id:ident) => {
      let tx_ = tx.clone();
      $type.listen(TEST_EVENT_NAME, move |evt| {
        tx_
          .send(($id, serde_json::from_str::<String>(evt.payload()).unwrap()))
          .unwrap();
      });

      if setup_any {
        let tx_ = tx.clone();
        $type.listen_any(TEST_EVENT_NAME, move |evt| {
          tx_
            .send((
              $any_id,
              serde_json::from_str::<String>(evt.payload()).unwrap(),
            ))
            .unwrap();
        });
      }
    };
  }

  setup_listener!(app, APP_LISTEN_ID, APP_LISTEN_ANY_ID);
  setup_listener!(window, WINDOW_LISTEN_ID, WINDOW_LISTEN_ANY_ID);
  setup_listener!(webview, WEBVIEW_LISTEN_ID, WEBVIEW_LISTEN_ANY_ID);
  setup_listener!(
    webview_window,
    WEBVIEW_WINDOW_LISTEN_ID,
    WEBVIEW_WINDOW_LISTEN_ANY_ID
  );

  EventSetup {
    app,
    window,
    webview,
    webview_window,
    tx,
    rx,
  }
}
```

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

### Parse a path with a BaseDirectory variable

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

Uses PathResolver::parse to resolve a path that starts with a BaseDirectory variable, here '$HOME/.bashrc'. The example asserts the resolved path equals '/home/${whoami}/.bashrc'. Requires the Manager trait and a Tauri setup hook.

```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(())
  });
```

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

### Builder::setup()

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

Defines the setup hook.

```APIDOC
## Builder::setup()

### Description
Defines the setup hook.

### Method
Method

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

### Parameters
- **setup** (F) - Required - The setup hook function.

### 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(())
  });
```
```

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

### show_all

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

Creates a predefined menu item that shows all app windows. This method is unsupported on Windows and Linux.

```APIDOC
## show_all

### Description
Creates a predefined menu item that shows all app windows. This method is unsupported on Windows and Linux.

### Method
show_all

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

### Returns
`crate::Result<Self>`
```

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

### Initialize plugins and return app

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

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

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

Ok(app)
```

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

### Builder::setup

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

Defines the setup hook that is called once when the application is ready. 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 is called once when the application is ready. 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** (closure) - Required - The setup hook 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(())
  });
```
```

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

### Resolve Command Scope Example

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

Shows how to resolve a command scope for a webview window in a setup hook.

```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(())
  });
```

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

### MenuBuilder usage example

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

Shows how to build a menu with MenuBuilder in a Tauri setup hook. On macOS, the global menubar 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(())
  });
```

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

### Create a WebviewWindow in a command

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

Use this example to create a webview window from an async Tauri command. The command takes an AppHandle and uses it to build the window. On Windows, this is safe because the command is async, avoiding the deadlock issue.

```rust
#[tauri::command]
async fn create_window(app: tauri::AppHandle) {
  let webview_window = tauri::WebviewWindowBuilder::new(&app, "label", tauri::WebviewUrl::App("index.html".into()))
    .build()
    .unwrap();
}
```

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

### Setup closure with plugin state

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

Defines a closure that runs when the plugin is registered. The example manages a custom PluginState struct via app.manage().

```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()
}
```

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

### stripped() example: print only name and value

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

Shows how to use Cookie::stripped() to get a Display wrapper that prints only the name and value, ignoring other attributes like secure and path. The example builds a cookie with secure and path set, then asserts the stripped string is "key?=value".

```rust
use cookie::Cookie;

let mut c = Cookie::build(("key?", "value")).secure(true).path("/").build();
assert_eq!(&c.stripped().to_string(), "key?=value");
```

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

### Initialize menu and register core plugins

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

On desktop, builds the menu, stores it, and initializes the app menu on macOS. Then registers core plugins and manages environment and scopes.

```rust
#[cfg(desktop)]
if let Some(menu) = self.menu {
  let menu = menu(&app.handle)?;
  app
    .manager
    .menu
    .menus_stash_lock()
    .insert(menu.id().clone(), menu.clone());

  #[cfg(target_os = "macos")]
  init_app_menu(&menu)?;

  app.manager.menu.menu_lock().replace(menu);
}

app.register_core_plugins()?;

let env = Env::default();
app.manage(env);

app.manage(Scopes {
  #[cfg(feature = "protocol-asset")]
  asset_protocol: crate::scope::fs::Scope::new(
    &app,
    &app.config().app.security.asset_protocol.scope,
  )?,
});

app.manage(ChannelDataIpcQueue::default());
app.handle.plugin(crate::ipc::channel::plugin())?;

let handle = app.handle();
```

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

### Unlisten to an event on this webview

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

Removes a previously registered event listener using its `EventId`. The example shows how to listen for a 'component-loaded' event and then unlisten inside the handler or after setup.

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

tauri::Builder::default()
  .setup(|app| {
    let webview = app.get_webview("main").unwrap();
    let webview_ = webview.clone();
    let handler = webview.listen("component-loaded", move |event| {
      println!("webview just loaded a component");

      // we no longer need to listen to the event
      // we also could have used `webview.once` instead
      webview_.unlisten(event.id());
    });

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

    Ok(())
  });
```

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

### start_resize_dragging

Source: https://docs.rs/tauri/2.9.2/tauri/window/struct.Window.html

Starts resize-dragging the window. Available on desktop only.

```APIDOC
## start_resize_dragging

### Description
Starts resize-dragging the window.

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

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

### Availability
Desktop only.

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

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

### Example: Using tauri::test utilities

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

Shows how to use mock_builder, mock_context, and noop_assets to test a Tauri command. It builds an app with a mock runtime, creates a webview, and invokes the 'ping' command to assert the response is 'pong'.

```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());
}
```

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

### Assets<R> trait

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

Represents a container of file assets that are retrievable during runtime. Implementors must provide a `get` method to retrieve asset content by key, and may optionally implement `setup` for initialization.

```APIDOC
## Assets<R> trait

### Description
Represents a container of file assets that are retrievable during runtime. Implementors must provide a `get` method to retrieve asset content by key, and may optionally implement `setup` for initialization.

### Methods

#### setup(&self, app: &App<R>)
- **Description**: Initialize the asset provider.
- **Parameters**:
  - **app** (`&App<R>`) - The application instance.

#### get(&self, key: &AssetKey) -> Option<Cow<'_, [u8]>>
- **Description**: Get the content of the passed [`AssetKey`].
- **Parameters**:
  - **key** (`&AssetKey`) - The asset key to retrieve.
- **Returns**: `Option<Cow<'_, [u8]>>` - The asset content if found, otherwise `None`.
```

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

### build

Source: https://docs.rs/tauri/2.9.2/tauri/webview/struct.WebviewWindowBuilder.html

Creates a new window.

```APIDOC
## build

### Description
Creates a new window.

### Method
Builder method

### Signature
`pub fn build(self) -> Result<WebviewWindow<R>>`

### Returns
- `Result<WebviewWindow<R>>` - The created webview window.
```

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

### Set dock visibility on macOS with app.set_dock_visibility

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

Sets the dock visibility to false on macOS. This example is guarded with #[cfg(target_os = "macos")] and should be used in the setup hook.

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

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

### Url::options - Get default ParseOptions

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

Returns a default ParseOptions that can fully configure the URL parser. The example shows setting a base URL and parsing a relative path.

```rust
use url::Url;
let options = Url::options();
let api = Url::parse("https://api.example.com")?;
let base_url = options.base_url(Some(&api));
let version_url = base_url.parse("version.json")?;
assert_eq!(version_url.as_str(), "https://api.example.com/version.json");
```

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

### start_resize_dragging

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

Starts resize-dragging the window.

```APIDOC
## start_resize_dragging

### Description
Starts resize-dragging the window.

### Method
`start_resize_dragging`

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

### Returns
`crate::Result<()>` - Result indicating success or failure.
```

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

### show

Source: https://docs.rs/tauri/2.9.2/tauri/webview/struct.WebviewWindow.html

Show this window.

```APIDOC
## show

### Description
Show this window.

### Method
pub fn show(&self) -> Result<()>

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

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

### Create WebviewWindow from WindowConfig with random label

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

Shows how to build a WebviewWindow from a WindowConfig, using getrandom to generate a unique label for multi-window setups. The example is from the from_config documentation and includes error handling with unwrap.

```rust
///   let mut buf = [0u8; 1];
///   assert_eq!(getrandom::fill(&mut buf), Ok(()));
///   conf.label = format!("my-multiwindow-{}", buf[0]);
///   let webview_window = tauri::WebviewWindowBuilder::from_config(&app, &conf)
///     .unwrap()
///     .build()
///     .unwrap();
/// }
```

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

### Register plugin dynamically with handle.plugin

Source: https://docs.rs/tauri/2.9.2/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(())
  });
```

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

### Builder::setup

Source: https://docs.rs/tauri/2.9.2/tauri/plugin/struct.Builder.html

Define a closure that runs when the plugin is registered.

```APIDOC
## Builder::setup

### Description
Define a closure that runs when the plugin is registered.

### Method
Method

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

### Parameters
- **setup** (`F`) - Required - The closure to run when the plugin is registered.

### 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()
}
```
```

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

### Get fragment with fragment()

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

Returns the URL's fragment identifier (the part after '#') if present. The parser does not percent-encode this component, but the input may have been percent-encoded already. The example shows extracting fragments from URLs.

```rust
use url::Url;

let url = Url::parse("https://example.com/data.csv#row=4")?;

assert_eq!(url.fragment(), Some("row=4"));

let url = Url::parse("https://example.com/data.csv#cell=4,1-6,2")?;

assert_eq!(url.fragment(), Some("cell=4,1-6,2"));
```

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

### start_dragging

Source: https://docs.rs/tauri/2.9.2/tauri/webview/struct.WebviewWindow.html

Starts dragging the window. Available on desktop only.

```APIDOC
## start_dragging

### Description
Starts dragging the window. Available on desktop only.

### Method
Rust method

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

### Parameters
None

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

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

### Set activation policy on macOS with app.set_activation_policy

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

Sets the application activation policy to Accessory on macOS. The default is NSApplicationActivationPolicyRegular. This example is guarded with #[cfg(target_os = "macos")] and should be used in the setup hook.

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

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

### Example for Receiver::capacity

Source: https://docs.rs/tauri/2.9.2/tauri/async_runtime/struct.Receiver.html

Shows how the current channel capacity changes with reservations, sends, and receives. The capacity starts at the initial buffer size, drops by one on reservation or direct send, and increases by one after receiving a message.

```rust
use tokio::sync::mpsc;

let (tx, mut rx) = mpsc::channel::<()>(5);

assert_eq!(rx.capacity(), 5);

// Making a reservation drops the capacity by one.
let permit = tx.reserve().await.unwrap();
assert_eq!(rx.capacity(), 4);
assert_eq!(rx.len(), 0);

// Sending and receiving a value increases the capacity by one.
permit.send(());
assert_eq!(rx.len(), 1);
rx.recv().await.unwrap();
assert_eq!(rx.capacity(), 5);

// Directly sending a message drops the capacity by one.
tx.send(()).await.unwrap();
assert_eq!(rx.capacity(), 4);
assert_eq!(rx.len(), 1);

// Receiving the message increases the capacity by one.
rx.recv().await.unwrap();
assert_eq!(rx.capacity(), 5);
assert_eq!(rx.len(), 0);
```

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

### Reopen a window from config

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

Shows how to create a window from a WindowConfig using tauri::window::WindowBuilder::from_config. The example uses the first window config from app.config().app.windows.

```rust
#[tauri::command]
async fn reopen_window(app: tauri::AppHandle) {
  let window = tauri::window::WindowBuilder::from_config(&app, &app.config().app.windows.get(0).unwrap().clone())
    .unwrap()
    .build()
    .unwrap();
}
```

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

### Handle page load events with on_page_load

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

Defines a closure to be executed when a page load event is triggered. The event can be either PageLoadEvent::Started or PageLoadEvent::Finished. The example logs the URL when the page starts and finishes loading.

```rust
use tauri::{
  utils::config::{Csp, CspDirectiveSources, WebviewUrl},
  window::WindowBuilder,
  webview::{PageLoadEvent, WebviewBuilder},
};
use http::header::HeaderValue;
use std::collections::HashMap;
tauri::Builder::default()
  .setup(|app| {
    let window = tauri::window::WindowBuilder::new(app, "label").build()?;
    let webview_builder = WebviewBuilder::new("core", WebviewUrl::App("index.html".into()))
      .on_page_load(|webview, payload| {
        match payload.event() {
          PageLoadEvent::Started => {
            println!("{} finished loading", payload.url());
          }
          PageLoadEvent::Finished => {
            println!("{} finished loading", payload.url());
          }
        }
      });
    let webview = window.add_child(webview_builder, tauri::LogicalPosition::new(0, 0), window.inner_size().unwrap())?;
    Ok(())
  });
```

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

### Create a window in the setup hook using tauri::window::WindowBuilder

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

Use this snippet to create a Tauri window during the application setup hook. The WindowBuilder::new method takes the app handle and a window label, then builds the window. Note that on Windows, this function can deadlock when used in synchronous commands or event handlers; prefer async commands or separate threads.

```rust
tauri::Builder::default()
  .setup(|app| {
    let window = tauri::window::WindowBuilder::new(app, "label")
      .build()?;
    Ok(())
  });
```

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

### Resolve a path with BaseDirectory::Config

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

Uses PathResolver::resolve with BaseDirectory::Config to resolve a relative path. The example asserts the resolved path equals '/home/${whoami}/.config/path/to/something'. Requires the Manager trait and a Tauri setup hook.

```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(())
  });
```

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

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

Source: https://docs.rs/tauri/2.9.2/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 direction for resizing.

### Returns
Result<()>
```

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

### Get query string with query()

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

Returns the URL's query string as a percent-encoded ASCII string, or None if absent. The example shows query extraction for URLs with and without query parameters, including percent-encoding of non-ASCII characters.

```rust
use url::Url;

fn run() -> Result<(), ParseError> {
let url = Url::parse("https://example.com/products?page=2")?;
let query = url.query();
assert_eq!(query, Some("page=2"));

let url = Url::parse("https://example.com/products")?;
let query = url.query();
assert!(query.is_none());

let url = Url::parse("https://example.com/?country=español")?;
let query = url.query();
assert_eq!(query, Some("country=espa%C3%B1ol"));
```

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

### Manager::webview_windows

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

Fetches all managed webview windows.

```APIDOC
## Manager::webview_windows

### Description
Fetches all managed webview windows.

### Method
`webview_windows(&self) -> HashMap<String, WebviewWindow<R>>`

### Parameters
None

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

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

### on_window_ready

Source: https://docs.rs/tauri/2.9.2/tauri/plugin/struct.Builder.html

Registers a callback invoked when the window is created. The callback receives a Window<R> instance.

```APIDOC
## on_window_ready

### Description
Registers a callback invoked when the window is created.

### Method
Builder method

### Signature
`pub fn on_window_ready<F>(self, on_window_ready: F) -> Self`

### Parameters
- **on_window_ready** (F) - Required - Callback function `FnMut(Window<R>) + Send + 'static`

### Example
```rust
use tauri::{plugin::{Builder, TauriPlugin}, Runtime};

fn init<R: Runtime>() -> TauriPlugin<R> {
  Builder::new("example")
    .on_window_ready(|window| {
      println!("created window {}", window.label());
    })
    .build()
}
```
```

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

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

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

Use the `listen` method from the `tauri::Listener` trait to register an event handler on the app. The example sets up a listener for the "component-loaded" event inside the builder's setup closure, printing a message when the event fires.

```rust
use tauri::Listener;

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

    Ok(())
  });
```

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

### Rust example: current_binary usage

Source: https://docs.rs/tauri/2.9.2/src/tauri/process.rs.html

Shows how to get the current binary path using tauri::process::current_binary. The function caches the path and on Linux attempts to detect an AppImage. On macOS it returns an error if the original path contained symlinks unless the process-relaunch-dangerous-allow-symlink-macos feature is enabled.

```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(())
  });
```

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

### Run Tauri app with run() and prevent exit on ExitRequested

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

Use `App::run` to start the application event loop; it never returns and exits the process directly when finished. The callback handles `RunEvent::ExitRequested` by calling `api.prevent_exit()` to keep the app running. 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();
  }
  _ => {}
});
```

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

### start_dragging

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

Starts dragging the window.

```APIDOC
## start_dragging

### Description
Starts dragging the window.

### Method
`start_dragging`

### Parameters
None.

### Returns
`crate::Result<()>` - Result indicating success or failure.
```

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

### Use with_webview to access platform-specific webview APIs

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

Shows how to use `with_webview` in a Tauri setup hook to access the platform-specific webview handle. Includes conditional compilation for Linux, Windows, macOS, and Android, each performing platform-specific operations like setting zoom level, background color, or calling a method. Requires the `unstable` feature for this documentation example and pinning 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(())
});
```

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

### start_dragging(&self) -> Result<()>

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

Starts dragging the window.

```APIDOC
## start_dragging(&self) -> Result<()>

### Description
Starts dragging the window.

### Method
start_dragging

### Returns
Result<()>
```

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

### into_inner example

Source: https://docs.rs/tauri/2.9.2/tauri/async_runtime/struct.Mutex.html

Consumes the mutex and returns the underlying data. The example shows the returned value being asserted to equal the original value.

```rust
use tokio::sync::Mutex;

let mutex = Mutex::new(1);

let n = mutex.into_inner();
assert_eq!(n, 1);
```

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

### Reopen a window from config in a command

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

Use this example to create a webview window from a WindowConfig in tauri.conf.json within an async command. It retrieves the first window config and builds the window. On Windows, avoid synchronous commands due to a known deadlock issue.

```rust
#[tauri::command]
async fn reopen_window(app: tauri::AppHandle) {
  let webview_window = tauri::WebviewWindowBuilder::from_config(&app, &app.config().app.windows.get(0).unwrap())
    .unwrap()
    .build()
    .unwrap();
}
```

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

### Example for unlisten method

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

Demonstrates removing an event listener using unlisten. The example also shows using listen_any and unlisten inside the handler.

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

tauri::Builder::default()
  .setup(|app| {
    let handle = app.handle().clone();
    let handler = app.listen_any("ready", move |event| {
      println!("app is ready");

      // we no longer need to listen to the event
      // we also could have used `app.once_global` instead
      handle.unlisten(event.id());
    });

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


    Ok(())
  });
```

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

### Run method shorthand

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

Builds the app and runs it with an empty run callback, returning a Result.

```rust
pub fn run(self, context: Context<R>) -> crate::Result<()> {
  self.build(context)?.run(|_, _| {});
  Ok(())
}
```

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

### Create a webview in the setup hook

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

Shows how to create a webview inside the Tauri setup hook using WebviewBuilder::new. On Windows, this function deadlocks when used in synchronous commands 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(())
  });
```

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

### set_secure() example

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

Shows how Cookie::set_secure() sets the secure flag. The example demonstrates setting it to true, false, and None, and asserts the resulting values.

```rust
use cookie::Cookie;

let mut c = Cookie::new("name", "value");
assert_eq!(c.secure(), None);

c.set_secure(true);
assert_eq!(c.secure(), Some(true));

c.set_secure(false);
assert_eq!(c.secure(), Some(false));

c.set_secure(None);
assert_eq!(c.secure(), None);
```

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

### set_http_only() example

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

Shows how Cookie::set_http_only() sets the http_only flag. The example demonstrates setting it to true, false, and None, and asserts the resulting values.

```rust
use cookie::Cookie;

let mut c = Cookie::new("name", "value");
assert_eq!(c.http_only(), None);

c.set_http_only(true);
assert_eq!(c.http_only(), Some(true));

c.set_http_only(false);
assert_eq!(c.http_only(), Some(false));

c.set_http_only(None);
assert_eq!(c.http_only(), None);
```

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

### get_webview_window

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

Fetch a single webview window from the manager.

```APIDOC
## get_webview_window

### Description
Fetch a single webview window from the manager.

### Method
N/A (Rust method)

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

### Parameters
- `label` (`&str`) - Required - The label of the webview window.

### Returns
- `Option<WebviewWindow<R>>` - The webview window if found, otherwise `None`.
```

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

### Example usage of generate_handler! with commands

Source: https://docs.rs/tauri/2.9.2/tauri/macro.generate_handler.html

Example demonstrating how to define commands with #[command] and pass them to generate_handler! in main. Commands can be annotated with #![plugin(your_plugin_name)] for removeUnusedCommands support.

```rust
use tauri_macros::{command, generate_handler};
#[command]
fn command_one() {
  println!("command one called");
}
#[command]
fn command_two() {
  println!("command two called");
}
fn main() {
  let _handler = generate_handler![command_one, command_two];
}
```

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

### Example: max_capacity and capacity with reservation

Source: https://docs.rs/tauri/2.9.2/tauri/async_runtime/struct.Sender.html

Shows that max_capacity remains constant while capacity decreases by one after reserving a permit. Requires an async context for reserve().await.

```rust
use tokio::sync::mpsc;

let (tx, _rx) = mpsc::channel::<()>(5);

// both max capacity and capacity are the same at first
assert_eq!(tx.max_capacity(), 5);
assert_eq!(tx.capacity(), 5);

// Making a reservation doesn't change the max capacity.
let permit = tx.reserve().await.unwrap();
assert_eq!(tx.max_capacity(), 5);
// but drops the capacity by one
assert_eq!(tx.capacity(), 4);
```
Tokens:
Raw