pub struct Builder<R: Runtime, C: DeserializeOwned = ()> { /* private fields */ }
Expand description
Builds a TauriPlugin
.
This Builder offers a more concise way to construct Tauri plugins than implementing the Plugin trait directly.
Conventions
When using the Builder Pattern it is encouraged to export a function called init
that constructs and returns the plugin.
While plugin authors can provide every possible way to construct a plugin,
sticking to the init
function convention helps users to quickly identify the correct function to call.
use tauri::{plugin::{Builder, TauriPlugin}, Runtime};
pub fn init<R: Runtime>() -> TauriPlugin<R> {
Builder::new("example")
.build()
}
When plugins expose more complex configuration options, it can be helpful to provide a Builder instead:
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| {
// use the options here to do stuff
println!("a: {}, b: {}, c: {}", self.option_a, self.option_b, self.option_c);
Ok(())
})
.build()
}
}
Implementations
sourceimpl<R: Runtime, C: DeserializeOwned> Builder<R, C>
impl<R: Runtime, C: DeserializeOwned> Builder<R, C>
sourcepub fn invoke_handler<F>(self, invoke_handler: F) -> Self where
F: Fn(Invoke<R>) + Send + Sync + 'static,
pub fn invoke_handler<F>(self, invoke_handler: F) -> Self where
F: Fn(Invoke<R>) + Send + Sync + 'static,
Defines the JS message handler callback. It is recommended you use the tauri::generate_handler to generate the input to this method, as the input type is not considered stable yet.
Examples
use tauri::{plugin::{Builder, TauriPlugin}, Runtime};
#[tauri::command]
async fn foobar<R: Runtime>(app: tauri::AppHandle<R>, window: tauri::Window<R>) -> Result<(), String> {
println!("foobar");
Ok(())
}
fn init<R: Runtime>() -> TauriPlugin<R> {
Builder::new("example")
.invoke_handler(tauri::generate_handler![foobar])
.build()
}
sourcepub fn js_init_script(self, js_init_script: String) -> Self
pub fn js_init_script(self, js_init_script: String) -> Self
The JS script to evaluate on webview initialization.
The script is wrapped into its own context with (function () { /* your script here */ })();
,
so global variables must be assigned to window
instead of implicity declared.
It’s guaranteed that this script is executed before the page is loaded.
Examples
use tauri::{plugin::{Builder, TauriPlugin}, Runtime};
const INIT_SCRIPT: &str = r#"
console.log("hello world from js init script");
window.__MY_CUSTOM_PROPERTY__ = { foo: 'bar' }
"#;
fn init<R: Runtime>() -> TauriPlugin<R> {
Builder::new("example")
.js_init_script(INIT_SCRIPT.to_string())
.build()
}
sourcepub fn setup<F>(self, setup: F) -> Self where
F: FnOnce(&AppHandle<R>) -> Result<()> + Send + 'static,
pub fn setup<F>(self, setup: F) -> Self where
F: FnOnce(&AppHandle<R>) -> Result<()> + Send + 'static,
Define a closure that runs when the plugin is registered.
This is a convenience function around setup_with_config, without the need to specify a configuration object.
The closure gets called before the setup_with_config closure.
Examples
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_handle| {
app_handle.manage(PluginState::default());
Ok(())
})
.build()
}
sourcepub fn setup_with_config<F>(self, setup_with_config: F) -> Self where
F: FnOnce(&AppHandle<R>, C) -> Result<()> + Send + 'static,
pub fn setup_with_config<F>(self, setup_with_config: F) -> Self where
F: FnOnce(&AppHandle<R>, C) -> Result<()> + Send + 'static,
Define a closure that runs when the plugin is registered, accepting a configuration object set on tauri.conf.json > plugins > yourPluginName
.
If your plugin is not pulling a configuration object from tauri.conf.json
, use setup.
The closure gets called after the setup closure.
Examples
#[derive(serde::Deserialize)]
struct Config {
api_url: String,
}
fn init<R: tauri::Runtime>() -> tauri::plugin::TauriPlugin<R, Config> {
tauri::plugin::Builder::<R, Config>::new("api")
.setup_with_config(|_app_handle, config| {
println!("config: {:?}", config.api_url);
Ok(())
})
.build()
}
tauri::Builder::default().plugin(init());
sourcepub fn on_page_load<F>(self, on_page_load: F) -> Self where
F: FnMut(Window<R>, PageLoadPayload) + Send + 'static,
pub fn on_page_load<F>(self, on_page_load: F) -> Self where
F: FnMut(Window<R>, PageLoadPayload) + Send + 'static,
Callback invoked when the webview performs a navigation to a page.
Examples
use tauri::{plugin::{Builder, TauriPlugin}, Runtime};
fn init<R: Runtime>() -> TauriPlugin<R> {
Builder::new("example")
.on_page_load(|window, payload| {
println!("Loaded URL {} in window {}", payload.url(), window.label());
})
.build()
}
sourcepub fn on_webview_ready<F>(self, on_webview_ready: F) -> Self where
F: FnMut(Window<R>) + Send + 'static,
pub fn on_webview_ready<F>(self, on_webview_ready: F) -> Self where
F: FnMut(Window<R>) + Send + 'static,
Callback invoked when the webview is created.
Examples
use tauri::{plugin::{Builder, TauriPlugin}, Runtime};
fn init<R: Runtime>() -> TauriPlugin<R> {
Builder::new("example")
.on_webview_ready(|window| {
println!("created window {}", window.label());
})
.build()
}
sourcepub fn on_event<F>(self, on_event: F) -> Self where
F: FnMut(&AppHandle<R>, &RunEvent) + Send + 'static,
pub fn on_event<F>(self, on_event: F) -> Self where
F: FnMut(&AppHandle<R>, &RunEvent) + Send + 'static,
Callback invoked when the event loop receives a new event.
Examples
use tauri::{plugin::{Builder, TauriPlugin}, RunEvent, Runtime};
fn init<R: Runtime>() -> TauriPlugin<R> {
Builder::new("example")
.on_event(|app_handle, event| {
match event {
RunEvent::ExitRequested { api, .. } => {
// Prevents the app from exiting.
// This will cause the core thread to continue running in the background even without any open windows.
api.prevent_exit();
}
// Ignore all other cases.
_ => {}
}
})
.build()
}
sourcepub fn on_drop<F>(self, on_drop: F) -> Self where
F: FnOnce(AppHandle<R>) + Send + 'static,
pub fn on_drop<F>(self, on_drop: F) -> Self where
F: FnOnce(AppHandle<R>) + Send + 'static,
Callback invoked when the plugin is dropped.
Examples
use tauri::{plugin::{Builder, TauriPlugin}, Runtime};
fn init<R: Runtime>() -> TauriPlugin<R> {
Builder::new("example")
.on_drop(|app| {
println!("plugin has been dropped and is no longer running");
// you can run cleanup logic here
})
.build()
}
sourcepub fn build(self) -> TauriPlugin<R, C>
pub fn build(self) -> TauriPlugin<R, C>
Builds the TauriPlugin.
Auto Trait Implementations
impl<R, C = ()> !RefUnwindSafe for Builder<R, C>
impl<R, C> Send for Builder<R, C>
impl<R, C = ()> !Sync for Builder<R, C>
impl<R, C> Unpin for Builder<R, C>
impl<R, C = ()> !UnwindSafe for Builder<R, C>
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more