pub struct Builder<R: Runtime> { /* private fields */ }
Expand description
Builds a Tauri application.
Examples
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");
Implementations§
source§impl<R: Runtime> Builder<R>
impl<R: Runtime> Builder<R>
sourcepub fn any_thread(self) -> Self
Available on Windows or Linux only.
pub fn any_thread(self) -> Self
Builds a new Tauri application running on any thread, bypassing the main thread requirement.
Platform-specific
- macOS: on macOS the application must be executed on the main thread, so this function is not exposed.
sourcepub fn invoke_handler<F>(self, invoke_handler: F) -> Selfwhere
F: Fn(Invoke<R>) -> bool + Send + Sync + 'static,
pub fn invoke_handler<F>(self, invoke_handler: F) -> Selfwhere F: Fn(Invoke<R>) -> bool + Send + Sync + 'static,
Defines the JS message handler callback.
Examples
#[tauri::command]
fn command_1() -> String {
return "hello world".to_string();
}
tauri::Builder::default()
.invoke_handler(tauri::generate_handler![
command_1,
// etc...
]);
sourcepub fn invoke_system<F>(
self,
initialization_script: String,
responder: F
) -> Selfwhere
F: Fn(&Window<R>, &str, &InvokeResponse, CallbackFn, CallbackFn) + Send + Sync + 'static,
pub fn invoke_system<F>( self, initialization_script: String, responder: F ) -> Selfwhere F: Fn(&Window<R>, &str, &InvokeResponse, CallbackFn, CallbackFn) + Send + Sync + 'static,
Defines a custom JS message system.
The responder
is a function that will be called when a command has been executed and must send a response to the JS layer.
The initialization_script
is a script that initializes window.__TAURI_POST_MESSAGE__
.
That function must take the (message: object, options: object)
arguments and send it to the backend.
sourcepub fn setup<F>(self, setup: F) -> Selfwhere
F: FnOnce(&mut App<R>) -> Result<(), Box<dyn Error>> + Send + 'static,
pub fn setup<F>(self, setup: F) -> Selfwhere F: FnOnce(&mut App<R>) -> Result<(), Box<dyn Error>> + Send + 'static,
Defines the setup hook.
Examples
use tauri::Manager;
tauri::Builder::default()
.setup(|app| {
let main_window = app.get_window("main").unwrap();
main_window.set_title("Tauri!");
Ok(())
});
sourcepub fn on_page_load<F>(self, on_page_load: F) -> Selfwhere
F: Fn(Window<R>, PageLoadPayload) + Send + Sync + 'static,
pub fn on_page_load<F>(self, on_page_load: F) -> Selfwhere F: Fn(Window<R>, PageLoadPayload) + Send + Sync + 'static,
Defines the page load hook.
sourcepub fn plugin<P: Plugin<R> + 'static>(self, plugin: P) -> Self
pub fn plugin<P: Plugin<R> + 'static>(self, plugin: P) -> Self
Adds a Tauri application plugin.
A plugin is created using the crate::plugin::Builder
struct.Check its documentation for more information.
Examples
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());
sourcepub fn manage<T>(self, state: T) -> Selfwhere
T: Send + Sync + 'static,
pub fn manage<T>(self, state: T) -> Selfwhere T: Send + Sync + 'static,
Add state
to the state managed by the application.
This method can be called any number of times as long as each call
refers to a different T
.
Managed state can be retrieved by any command handler via the
State
guard. In particular, if a value of type T
is managed by Tauri, adding State<T>
to the list of arguments in a
command handler instructs Tauri to retrieve the managed value.
Additionally, state
can be used to retrieve the value manually.
Panics
Panics if state of type T
is already being managed.
Mutability
Since the managed state is global and must be Send
+ Sync
, mutations can only happen through interior mutability:
use std::{collections::HashMap, sync::Mutex};
use tauri::State;
// here we use Mutex to achieve interior mutability
struct Storage {
store: Mutex<HashMap<u64, String>>,
}
struct Connection;
struct DbConnection {
db: Mutex<Option<Connection>>,
}
#[tauri::command]
fn connect(connection: State<DbConnection>) {
// initialize the connection, mutating the state with interior mutability
*connection.db.lock().unwrap() = Some(Connection {});
}
#[tauri::command]
fn storage_insert(key: u64, value: String, storage: State<Storage>) {
// mutate the storage behind the Mutex
storage.store.lock().unwrap().insert(key, value);
}
tauri::Builder::default()
.manage(Storage { store: Default::default() })
.manage(DbConnection { db: Default::default() })
.invoke_handler(tauri::generate_handler![connect, storage_insert])
// 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");
Examples
use tauri::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()
.manage(MyInt(10))
.manage(MyString("Hello, managed state!".to_string()))
.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");
Sets the menu to use on all windows.
Examples
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),
],
)?
]));
Enable or disable the default menu on macOS. Enabled by default.
Examples
tauri::Builder::default()
.enable_macos_default_menu(false);
sourcepub fn on_window_event<F: Fn(GlobalWindowEvent<R>) + Send + Sync + 'static>(
self,
handler: F
) -> Self
pub fn on_window_event<F: Fn(GlobalWindowEvent<R>) + Send + Sync + 'static>( self, handler: F ) -> Self
Registers a window event handler for all windows.
Examples
tauri::Builder::default()
.on_window_event(|event| match event.event() {
tauri::WindowEvent::Focused(focused) => {
// hide window whenever it loses focus
if !focused {
event.window().hide().unwrap();
}
}
_ => {}
});
sourcepub fn register_uri_scheme_protocol<N: Into<String>, T: Into<Cow<'static, [u8]>>, H: Fn(&AppHandle<R>, HttpRequest<Vec<u8>>) -> HttpResponse<T> + Send + Sync + 'static>(
self,
uri_scheme: N,
protocol: H
) -> Self
pub fn register_uri_scheme_protocol<N: Into<String>, T: Into<Cow<'static, [u8]>>, H: Fn(&AppHandle<R>, HttpRequest<Vec<u8>>) -> HttpResponse<T> + Send + Sync + 'static>( self, uri_scheme: N, protocol: H ) -> Self
Registers a URI scheme protocol available to all webviews. Leverages setURLSchemeHandler on macOS, AddWebResourceRequestedFilter on Windows and webkit-web-context-register-uri-scheme on Linux.
Arguments
uri_scheme
The URI scheme to register, such asexample
.protocol
the protocol associated with the given URI scheme. It’s a function that takes a request and returns a response.
Examples
tauri::Builder::default()
.register_uri_scheme_protocol("app-files", |_app, request| {
let path = request.uri().path().trim_start_matches('/');
if let Ok(data) = std::fs::read(path) {
http::Response::builder()
.body(data)
.unwrap()
} else {
http::Response::builder()
.status(http::StatusCode::BAD_REQUEST)
.header(http::header::CONTENT_TYPE, mime::TEXT_PLAIN.essence_str())
.body("failed to read file".as_bytes().to_vec())
.unwrap()
}
});
sourcepub fn register_asynchronous_uri_scheme_protocol<N: Into<String>, H: Fn(&AppHandle<R>, HttpRequest<Vec<u8>>, UriSchemeResponder) + Send + Sync + 'static>(
self,
uri_scheme: N,
protocol: H
) -> Self
pub fn register_asynchronous_uri_scheme_protocol<N: Into<String>, H: Fn(&AppHandle<R>, HttpRequest<Vec<u8>>, UriSchemeResponder) + Send + Sync + 'static>( self, uri_scheme: N, protocol: H ) -> Self
Similar to Self::register_uri_scheme_protocol
but with an asynchronous responder that allows you
to process the request in a separate thread and respond asynchronously.
Examples
tauri::Builder::default()
.register_asynchronous_uri_scheme_protocol("app-files", |_app, request, responder| {
let path = request.uri().path().trim_start_matches('/').to_string();
std::thread::spawn(move || {
if let Ok(data) = std::fs::read(path) {
responder.respond(
http::Response::builder()
.body(data)
.unwrap()
);
} else {
responder.respond(
http::Response::builder()
.status(http::StatusCode::BAD_REQUEST)
.header(http::header::CONTENT_TYPE, mime::TEXT_PLAIN.essence_str())
.body("failed to read file".as_bytes().to_vec())
.unwrap()
);
}
});
});
sourcepub fn device_event_filter(self, filter: DeviceEventFilter) -> Self
pub fn device_event_filter(self, filter: DeviceEventFilter) -> Self
Change the device event filter mode.
Since the DeviceEvent capture can lead to high CPU usage for unfocused windows, tao
will ignore them by default for unfocused windows on Windows. This method allows changing
the filter to explicitly capture them again.
Platform-specific
- ** Linux / macOS / iOS / Android**: Unsupported.
Examples
tauri::Builder::default()
.device_event_filter(tauri::DeviceEventFilter::Always);