refactor(tauri): Webview traits (#1183)

Author: lucasfernog

.changes/webview-traits.md

@@ -0,0 +1,5 @@
+---
+"tauri": minor
+---
+
+The Tauri integration with Webview was refactored to use traits, which allows custom implementations by developers and simplifies changes on the webview implementation.

cli/tauri.js/templates/src-tauri/src/main.rs

@@ -6,7 +6,7 @@
 mod cmd;
 
 fn main() {
-  tauri::AppBuilder::new()
+  tauri::AppBuilder::<tauri::flavors::Official>::new()
     .invoke_handler(|_webview, arg| async move {
       use cmd::Cmd::*;
       match serde_json::from_str(&arg) {

tauri/Cargo.toml

@@ -20,7 +20,7 @@ features = [ "all-api" ]
 [dependencies]
 serde_json = "1.0"
 serde = { version = "1.0", features = [ "derive" ] }
-webview_official = "0.1.1"
+webview_official = "0.2.0"
 tauri_includedir = "0.6.0"
 phf = "0.8.0"
 base64 = "0.13.0"

tauri/examples/communication/src-tauri/Cargo.lock

@@ -13,7 +13,7 @@ struct Reply {
 }
 
 fn main() {
-  tauri::AppBuilder::new()
+  tauri::AppBuilder::<tauri::flavors::Official>::new()
     .setup(|webview, _source| async move {
       let mut webview = webview.clone();
       tauri::event::listen(String::from("js-event"), move |msg| {

tauri/examples/communication/src-tauri/src/main.rs

@@ -1,23 +1,22 @@
+use crate::Webview;
 use futures::future::BoxFuture;
-use webview_official::WebviewMut;
 
 mod runner;
 
-type InvokeHandler =
-  dyn Fn(WebviewMut, String) -> BoxFuture<'static, Result<(), String>> + Send + Sync;
-type Setup = dyn Fn(WebviewMut, String) -> BoxFuture<'static, ()> + Send + Sync;
+type InvokeHandler<W> = dyn Fn(W, String) -> BoxFuture<'static, Result<(), String>> + Send + Sync;
+type Setup<W> = dyn Fn(W, String) -> BoxFuture<'static, ()> + Send + Sync;
 
 /// The application runner.
-pub struct App {
+pub struct App<W: Webview> {
   /// The JS message handler.
-  invoke_handler: Option<Box<InvokeHandler>>,
+  invoke_handler: Option<Box<InvokeHandler<W>>>,
   /// The setup callback, invoked when the webview is ready.
-  setup: Option<Box<Setup>>,
+  setup: Option<Box<Setup<W>>>,
   /// The HTML of the splashscreen to render.
   splashscreen_html: Option<String>,
 }
 
-impl App {
+impl<W: Webview + 'static> App<W> {
   /// Runs the app until it finishes.
   pub fn run(self) {
     runner::run(self).expect("Failed to build webview");
@@ -28,7 +27,7 @@ impl App {
   /// The message is considered consumed if the handler exists and returns an Ok Result.
   pub(crate) async fn run_invoke_handler(
     &self,
-    webview: &mut WebviewMut,
+    webview: &mut W,
     arg: &str,
   ) -> Result<bool, String> {
     if let Some(ref invoke_handler) = self.invoke_handler {
@@ -40,7 +39,7 @@ impl App {
   }
 
   /// Runs the setup callback if defined.
-  pub(crate) async fn run_setup(&self, webview: &mut WebviewMut, source: String) {
+  pub(crate) async fn run_setup(&self, webview: &mut W, source: String) {
     if let Some(ref setup) = self.setup {
       let fut = setup(webview.clone(), source);
       fut.await;
@@ -55,16 +54,16 @@ impl App {
 
 /// The App builder.
 #[derive(Default)]
-pub struct AppBuilder {
+pub struct AppBuilder<W: Webview> {
   /// The JS message handler.
-  invoke_handler: Option<Box<InvokeHandler>>,
+  invoke_handler: Option<Box<InvokeHandler<W>>>,
   /// The setup callback, invoked when the webview is ready.
-  setup: Option<Box<Setup>>,
+  setup: Option<Box<Setup<W>>>,
   /// The HTML of the splashscreen to render.
   splashscreen_html: Option<String>,
 }
 
-impl AppBuilder {
+impl<W: Webview + 'static> AppBuilder<W> {
   /// Creates a new App builder.
   pub fn new() -> Self {
     Self {
@@ -77,7 +76,7 @@ impl AppBuilder {
   /// Defines the JS message handler callback.
   pub fn invoke_handler<
     T: futures::Future<Output = Result<(), String>> + Send + Sync + 'static,
-    F: Fn(WebviewMut, String) -> T + Send + Sync + 'static,
+    F: Fn(W, String) -> T + Send + Sync + 'static,
   >(
     mut self,
     invoke_handler: F,
@@ -91,7 +90,7 @@ impl AppBuilder {
   /// Defines the setup callback.
   pub fn setup<
     T: futures::Future<Output = ()> + Send + Sync + 'static,
-    F: Fn(WebviewMut, String) -> T + Send + Sync + 'static,
+    F: Fn(W, String) -> T + Send + Sync + 'static,
   >(
     mut self,
     setup: F,
@@ -109,13 +108,16 @@ impl AppBuilder {
   }
 
   /// Adds a plugin to the runtime.
-  pub fn plugin(self, plugin: impl crate::plugin::Plugin + Send + Sync + Sync + 'static) -> Self {
-    crate::async_runtime::block_on(crate::plugin::register(plugin));
+  pub fn plugin(
+    self,
+    plugin: impl crate::plugin::Plugin<W> + Send + Sync + Sync + 'static,
+  ) -> Self {
+    crate::async_runtime::block_on(crate::plugin::register(W::plugin_store(), plugin));
     self
   }
 
   /// Builds the App.
-  pub fn build(self) -> App {
+  pub fn build(self) -> App<W> {
     App {
       invoke_handler: self.invoke_handler,
       setup: self.setup,

tauri/src/app.rs

@@ -6,7 +6,7 @@ use std::{
   },
 };
 
-use webview_official::{SizeHint, Webview, WebviewBuilder};
+use crate::{SizeHint, Webview, WebviewBuilder};
 
 use super::App;
 #[cfg(embedded_server)]
@@ -20,7 +20,7 @@ enum Content<T> {
 }
 
 /// Main entry point for running the Webview
-pub(crate) fn run(application: App) -> crate::Result<()> {
+pub(crate) fn run<W: Webview + 'static>(application: App<W>) -> crate::Result<()> {
   // setup the content using the config struct depending on the compile target
   let main_content = setup_content()?;
 
@@ -48,8 +48,10 @@ pub(crate) fn run(application: App) -> crate::Result<()> {
   // build the webview
   let mut webview = build_webview(application, main_content, splashscreen_content)?;
 
-  let mut webview_ = webview.as_mut();
-  crate::async_runtime::spawn(async move { crate::plugin::created(&mut webview_).await });
+  let mut webview_ = webview.clone();
+  crate::async_runtime::spawn(async move {
+    crate::plugin::created(W::plugin_store(), &mut webview_).await
+  });
 
   // spawn the embedded server on our server url
   #[cfg(embedded_server)]
@@ -238,11 +240,11 @@ pub fn init() -> String {
 }
 
 // build the webview struct
-fn build_webview<'a>(
-  application: App,
+fn build_webview<W: Webview + 'static>(
+  application: App<W>,
   content: Content<String>,
   splashscreen_content: Option<Content<String>>,
-) -> crate::Result<Webview<'a>> {
+) -> crate::Result<W> {
   let config = get()?;
   let debug = cfg!(debug_assertions);
   // get properties from config struct
@@ -254,7 +256,7 @@ fn build_webview<'a>(
     SizeHint::FIXED
   };
   // let fullscreen = config.tauri.window.fullscreen;
-  let title = config.tauri.window.title.clone().into_boxed_str();
+  let title = config.tauri.window.title.clone();
 
   let has_splashscreen = splashscreen_content.is_some();
   let initialized_splashscreen = Arc::new(AtomicBool::new(false));
@@ -281,18 +283,18 @@ fn build_webview<'a>(
       {plugin_init}
     "#,
     event_init = init(),
-    plugin_init = crate::async_runtime::block_on(crate::plugin::init_script())
+    plugin_init = crate::async_runtime::block_on(crate::plugin::init_script(W::plugin_store()))
   );
 
-  let mut webview = WebviewBuilder::new()
-    .init(Box::leak(init.into_boxed_str()))
-    .title(Box::leak(title))
+  let mut webview = W::Builder::new()
+    .init(&init)
+    .title(&title)
     .width(width as usize)
     .height(height as usize)
-    .resize(resizable)
+    .resizable(resizable)
     .debug(debug)
-    .url(Box::leak(url.into_boxed_str()))
-    .build();
+    .url(&url)
+    .finish();
   // TODO waiting for webview window API
   // webview.set_fullscreen(fullscreen);
 
@@ -304,7 +306,7 @@ fn build_webview<'a>(
     webview.dispatch(move |_webview| _webview.eval(&contents));
   }
 
-  let w = webview.as_mut();
+  let w = webview.clone();
   let application = Arc::new(application);
 
   webview.bind("__TAURI_INVOKE_HANDLER__", move |_, arg| {
@@ -326,13 +328,12 @@ fn build_webview<'a>(
         };
         application.run_setup(&mut w, source.to_string()).await;
         if source == "window-1" {
-          crate::plugin::ready(&mut w).await;
+          crate::plugin::ready(W::plugin_store(), &mut w).await;
         }
       } else if arg == r#"{"cmd":"closeSplashscreen"}"# {
         w.dispatch(move |w| {
           w.eval(&format!(r#"window.location.href = "{}""#, content_url));
-        })
-        .unwrap();
+        });
       } else {
         let mut endpoint_handle = crate::endpoints::handle(&mut w, &arg)
           .await
@@ -354,7 +355,7 @@ fn build_webview<'a>(
         }
         if let Err(ref app_handle_error) = endpoint_handle {
           if app_handle_error.contains("unknown variant") {
-            let error = match crate::plugin::extend_api(&mut w, &arg).await {
+            let error = match crate::plugin::extend_api(W::plugin_store(), &mut w, &arg).await {
               Ok(handled) => {
                 if handled {
                   String::from("")

tauri/src/app/runner.rs

@@ -16,10 +16,10 @@ mod http;
 #[cfg(notification)]
 mod notification;
 
-use webview_official::WebviewMut;
+use crate::Webview;
 
 #[allow(unused_variables)]
-pub(crate) async fn handle(webview: &mut WebviewMut, arg: &str) -> crate::Result<()> {
+pub(crate) async fn handle<W: Webview + 'static>(webview: &mut W, arg: &str) -> crate::Result<()> {
   use cmd::Cmd::*;
   match serde_json::from_str(arg) {
     Err(e) => Err(e.into()),
@@ -154,7 +154,7 @@ pub(crate) async fn handle(webview: &mut WebviewMut, arg: &str) -> crate::Result
           #[cfg(set_title)]
           webview.dispatch(move |w| {
             w.set_title(&title);
-          })?;
+          });
           #[cfg(not(set_title))]
           throw_allowlist_error(webview, "title");
         }
@@ -192,7 +192,7 @@ pub(crate) async fn handle(webview: &mut WebviewMut, arg: &str) -> crate::Result
             let js_string = event::listen_fn(event, handler, once)?;
             webview.dispatch(move |w| {
               w.eval(&js_string);
-            })?;
+            });
           }
           #[cfg(not(event))]
           throw_allowlist_error(webview, "event");
@@ -323,15 +323,15 @@ pub(crate) async fn handle(webview: &mut WebviewMut, arg: &str) -> crate::Result
 }
 
 #[allow(dead_code)]
-fn api_error(webview: &mut WebviewMut, error_fn: String, message: &str) {
+fn api_error<W: Webview>(webview: &mut W, error_fn: String, message: &str) {
   let reject_code = tauri_api::rpc::format_callback(error_fn, message);
   let _ = webview.dispatch(move |w| {
     w.eval(&reject_code);
   });
 }
 
 #[allow(dead_code)]
-fn allowlist_error(webview: &mut WebviewMut, error_fn: String, allowlist_key: &str) {
+fn allowlist_error<W: Webview>(webview: &mut W, error_fn: String, allowlist_key: &str) {
   api_error(
     webview,
     error_fn,
@@ -343,7 +343,7 @@ fn allowlist_error(webview: &mut WebviewMut, error_fn: String, allowlist_key: &s
 }
 
 #[allow(dead_code)]
-fn throw_allowlist_error(webview: &mut WebviewMut, allowlist_key: &str) {
+fn throw_allowlist_error<W: Webview>(webview: &mut W, allowlist_key: &str) {
   let reject_code = format!(
     r#"throw new Error("'{}' not on the allowlist")"#,
     allowlist_key

tauri/src/endpoints.rs

@@ -1,9 +1,9 @@
+use crate::Webview;
 use std::path::PathBuf;
-use webview_official::WebviewMut;
 
 #[allow(clippy::option_env_unwrap)]
-pub async fn load(
-  webview: &mut WebviewMut,
+pub async fn load<W: Webview + 'static>(
+  webview: &mut W,
   asset: String,
   asset_type: String,
   callback: String,
@@ -90,7 +90,7 @@ pub async fn load(
           } else {
             webview_ref.eval(asset_str);
           }
-        })?;
+        });
         Ok("Asset loaded successfully".to_string())
       }
     },