feat(windows): Add the implementation and examples of the host object for the Windows system.

examples/host_object.rs

@@ -0,0 +1,196 @@
+// Copyright 2020-2023 Tauri Programme within The Commons Conservancy
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: MIT
+
+use tao::{
+  event::{Event, WindowEvent},
+  event_loop::{ControlFlow, EventLoop},
+  window::WindowBuilder,
+};
+use wry::WebViewBuilder;
+
+#[cfg(target_os = "windows")]
+fn main() -> wry::Result<()> {
+  let event_loop = EventLoop::new();
+  let window = WindowBuilder::new().build(&event_loop).unwrap();
+
+  use std::mem::ManuallyDrop;
+  use windows::{
+    core::{w, BSTR},
+    Win32::System::{
+      Com::{IDispatch, IDispatch_Impl, ITypeInfo, DISPATCH_FLAGS, DISPPARAMS, EXCEPINFO},
+      Variant::{
+        VARENUM, VARIANT, VARIANT_0, VARIANT_0_0, VARIANT_0_0_0, VT_BSTR, VT_DISPATCH, VT_I4,
+      },
+    },
+  };
+  use wry::WebViewExtWindows;
+
+  // This is a simple usage example. add_host_object_to_script is a mapping of the native [addHostObjectToScript](https://learn.microsoft.com/en-us/microsoft-edge/webview2/reference/win32/icorewebview2#addhostobjecttoscript) method of webview2. It requires manual creation of hostobject and memory management. Please use it with caution.
+  struct Variant(VARIANT);
+  impl Variant {
+    pub fn new(num: VARENUM, contents: VARIANT_0_0_0) -> Variant {
+      Variant {
+        0: VARIANT {
+          Anonymous: VARIANT_0 {
+            Anonymous: ManuallyDrop::new(VARIANT_0_0 {
+              vt: num,
+              wReserved1: 0,
+              wReserved2: 0,
+              wReserved3: 0,
+              Anonymous: contents,
+            }),
+          },
+        },
+      }
+    }
+  }
+  impl From<String> for Variant {
+    fn from(value: String) -> Variant {
+      Variant::new(
+        VT_BSTR,
+        VARIANT_0_0_0 {
+          bstrVal: ManuallyDrop::new(BSTR::from(value)),
+        },
+      )
+    }
+  }
+  impl From<&str> for Variant {
+    fn from(value: &str) -> Variant {
+      Variant::from(value.to_string())
+    }
+  }
+  impl From<i32> for Variant {
+    fn from(value: i32) -> Variant {
+      Variant::new(VT_I4, VARIANT_0_0_0 { lVal: value })
+    }
+  }
+  impl From<std::mem::ManuallyDrop<::core::option::Option<IDispatch>>> for Variant {
+    fn from(value: std::mem::ManuallyDrop<::core::option::Option<IDispatch>>) -> Variant {
+      Variant::new(VT_DISPATCH, VARIANT_0_0_0 { pdispVal: value })
+    }
+  }
+  impl Drop for Variant {
+    fn drop(&mut self) {
+      match VARENUM(unsafe { self.0.Anonymous.Anonymous.vt.0 }) {
+        VT_BSTR => unsafe { drop(&mut &self.0.Anonymous.Anonymous.Anonymous.bstrVal) },
+        _ => {}
+      }
+      unsafe { drop(&mut self.0.Anonymous.Anonymous) }
+    }
+  }
+  #[windows::core::implement(IDispatch)]
+  struct FunctionWithStringArgument;
+  impl IDispatch_Impl for FunctionWithStringArgument {
+    #![allow(non_snake_case)]
+    fn GetTypeInfoCount(&self) -> windows::core::Result<u32> {
+      Ok(0)
+    }
+    fn GetTypeInfo(&self, _itinfo: u32, _lcid: u32) -> windows::core::Result<ITypeInfo> {
+      Err(windows::core::Error::new(
+        windows::Win32::Foundation::E_FAIL,
+        "GetTypeInfo Error \t\n\r".into(),
+      ))
+    }
+    fn GetIDsOfNames(
+      &self,
+      _riid: *const ::windows::core::GUID,
+      _rgsznames: *const ::windows::core::PCWSTR,
+      _cnames: u32,
+      _lcid: u32,
+      _rgdispid: *mut i32,
+    ) -> windows::core::Result<()> {
+      Ok(())
+    }
+    fn Invoke(
+      &self,
+      _dispidmember: i32,
+      _riid: *const windows::core::GUID,
+      _lcid: u32,
+      _wflags: DISPATCH_FLAGS,
+      pdispparams: *const DISPPARAMS,
+      pvarresult: *mut VARIANT,
+      _pexcepinfo: *mut EXCEPINFO,
+      _puargerr: *mut u32,
+    ) -> windows::core::Result<()> {
+      let pdispparams = unsafe { *pdispparams };
+      let rgvarg = unsafe { &*(pdispparams.rgvarg) };
+      let rgvarg_0_0 = unsafe { &rgvarg.Anonymous.Anonymous };
+      unsafe {
+        dbg!(&rgvarg_0_0.Anonymous.bstrVal);
+      }
+      let b_str_val = unsafe { &rgvarg_0_0.Anonymous.bstrVal.to_string() };
+      dbg!(b_str_val);
+
+      let pvarresult_0_0 = unsafe { &mut (*pvarresult).Anonymous.Anonymous };
+      pvarresult_0_0.vt = VT_BSTR;
+      pvarresult_0_0.Anonymous.bstrVal = ManuallyDrop::new(BSTR::from(
+        format!(
+          r#"Successful sync call functionWithStringArgument, and the argument is "{}"."#,
+          b_str_val
+        )
+        .to_string(),
+      ));
+      Ok(())
+    }
+  }
+  let mut i32_variant = Variant::from(1234);
+  let mut string_variant = Variant::from("string variant");
+  let mut function_with_string_argument_variant = Variant::from(ManuallyDrop::new(Some(
+    IDispatch::from(FunctionWithStringArgument),
+  )));
+
+  let webview = WebViewBuilder::new(&window)
+    .with_url("https://tauri.app")?
+    .with_initialization_script(
+      r#"
+      alert(chrome.webview.hostObjects.sync.i32)
+      alert(chrome.webview.hostObjects.sync.string)
+      alert(chrome.webview.hostObjects.sync.functionWithStringArgument("hi"))
+    "#,
+    )
+    .build()?;
+
+  unsafe {
+    let _ = webview.add_host_object_to_script(w!("i32"), &mut i32_variant.0);
+    let _ = webview.add_host_object_to_script(w!("string"), &mut string_variant.0);
+    let _ = webview.add_host_object_to_script(
+      w!("functionWithStringArgument"),
+      &mut function_with_string_argument_variant.0,
+    );
+  }
+
+  event_loop.run(move |event, _, control_flow| {
+    *control_flow = ControlFlow::Wait;
+
+    if let Event::WindowEvent {
+      event: WindowEvent::CloseRequested,
+      ..
+    } = event
+    {
+      *control_flow = ControlFlow::Exit
+    }
+  });
+}
+
+#[cfg(not(target_os = "windows"))]
+fn main() -> wry::Result<()> {
+  let event_loop = EventLoop::new();
+  let window = WindowBuilder::new().build(&event_loop).unwrap();
+
+  let webview = WebViewBuilder::new(&window)
+    .with_url("https://tauri.app")?
+    .build()?;
+
+  event_loop.run(move |event, _, control_flow| {
+    *control_flow = ControlFlow::Wait;
+
+    if let Event::WindowEvent {
+      event: WindowEvent::CloseRequested,
+      ..
+    } = event
+    {
+      *control_flow = ControlFlow::Exit
+    }
+  });
+}

src/lib.rs

@@ -1404,6 +1404,14 @@ pub trait WebViewExtWindows {
   /// [1]: https://learn.microsoft.com/en-us/dotnet/api/microsoft.web.webview2.core.corewebview2memoryusagetargetlevel
   /// [2]: https://learn.microsoft.com/en-us/dotnet/api/microsoft.web.webview2.core.corewebview2.memoryusagetargetlevel?view=webview2-dotnet-1.0.2088.41#remarks
   fn set_memory_usage_level(&self, level: MemoryUsageLevel);
+
+  unsafe fn add_host_object_to_script<P0>(
+    &self,
+    name: P0,
+    object: *mut ::windows::Win32::System::Variant::VARIANT,
+  ) -> ::windows::core::Result<()>
+  where
+    P0: ::windows::core::IntoParam<::windows::core::PCWSTR>;
 }
 
 #[cfg(target_os = "windows")]
@@ -1419,6 +1427,17 @@ impl WebViewExtWindows for WebView {
   fn set_memory_usage_level(&self, level: MemoryUsageLevel) {
     self.webview.set_memory_usage_level(level);
   }
+
+  unsafe fn add_host_object_to_script<P0>(
+    &self,
+    name: P0,
+    object: *mut ::windows::Win32::System::Variant::VARIANT,
+  ) -> ::windows::core::Result<()>
+  where
+    P0: ::windows::core::IntoParam<::windows::core::PCWSTR>,
+  {
+    self.webview.add_host_object_to_script(name, object)
+  }
 }
 
 /// Additional methods on `WebView` that are specific to Linux.

src/webview2/mod.rs

@@ -1092,6 +1092,20 @@ impl InnerWebView {
     let level = COREWEBVIEW2_MEMORY_USAGE_TARGET_LEVEL(level);
     let _ = unsafe { webview.SetMemoryUsageTargetLevel(level) };
   }
+
+  pub unsafe fn add_host_object_to_script<P0>(
+    &self,
+    name: P0,
+    object: *mut ::windows::Win32::System::Variant::VARIANT,
+  ) -> ::windows::core::Result<()>
+  where
+    P0: ::windows::core::IntoParam<::windows::core::PCWSTR>,
+  {
+    match self.webview.cast::<ICoreWebView2_19>() {
+      Ok(webview) => webview.AddHostObjectToScript(name, object),
+      Err(error) => Err(error),
+    }
+  }
 }
 
 unsafe fn prepare_web_request_response(