Add Electron Windows Hello sample

bindings/js/__test__/index.spec.ts

@@ -171,6 +171,7 @@ test('WinRT root facade exposes usable native primitives', (t) => {
 
 test('Classic COM raw ABI access requires the explicit unsafe entrypoint', (t) => {
   const iid = WinGuid.parse('00000000-0000-0000-c000-000000000046')
+  t.is(typeof DynCom.projectWinRtAsync, 'function')
   const raw = DynComUnsafe.registerIUnknownInterface('Unsafe.IUnknown', iid).addMethodAt(
     3,
     'Raw',
@@ -192,6 +193,33 @@ test('Classic COM raw ABI access requires the explicit unsafe entrypoint', (t) =
   )
 })
 
+test('DynCom rejects invalid WinRT async result signatures', (t) => {
+  const invalidAsyncType = DynWinRtType.iAsyncOperation(
+    DynWinRtType.arrayType(DynWinRtType.i32()),
+  )
+
+  const error = t.throws(() =>
+    DynCom.projectWinRtAsync(DynWinRtValue.nullValue(), invalidAsyncType),
+  )
+  t.regex(error.message, /valid WinRT signature/)
+})
+
+test('DynCom verifies the projected WinRT async interface IID', (t) => {
+  roInitialize(1)
+  const factory = DynWinRtValue.activationFactory('Windows.Foundation.Uri')
+  try {
+    const error = t.throws(() =>
+      DynCom.projectWinRtAsync(
+        factory,
+        DynWinRtType.iAsyncOperation(DynWinRtType.i32()),
+      ),
+    )
+    t.regex(error.message, /0x80004002|interface/i)
+  } finally {
+    factory.release()
+  }
+})
+
 test('DynCom rejects pointers after their TypedArray backing store is detached', (t) => {
   const bytes = new Uint8Array(16)
   const pointer = DynCom.pointer(bytes)

bindings/js/src/com.rs

@@ -6,7 +6,7 @@ use napi::JsValue;
 use napi_derive::napi;
 use windows::core::{IUnknown, Interface as _, GUID};
 
-use super::{DynWinRTValue, WinGUID, TABLE};
+use super::{DynWinRTType, DynWinRTValue, WinGUID, TABLE};
 
 #[allow(dead_code)]
 pub(super) enum NativePointerOwner {
@@ -881,6 +881,15 @@ fn adopt_com_pointer(
   }
 }
 
+fn project_winrt_async(
+  value: &DynWinRTValue,
+  async_type: &DynWinRTType,
+) -> napi::Result<DynWinRTValue> {
+  dynwinrt::com::project_winrt_async(&value.0, async_type.type_handle())
+    .map(DynWinRTValue::new)
+    .map_err(|error| napi::Error::from_reason(error.message()))
+}
+
 fn explicit_raw_com_pointer(
   value: Unknown,
   operation: &str,
@@ -4525,6 +4534,14 @@ impl DynCom {
     self::adopt_com_pointer(value, iid)
   }
 
+  #[napi]
+  pub fn project_win_rt_async(
+    value: &DynWinRTValue,
+    async_type: &DynWinRTType,
+  ) -> napi::Result<DynWinRTValue> {
+    self::project_winrt_async(value, async_type)
+  }
+
   #[napi]
   pub fn adopt_co_task_mem_pointer(value: &mut DynWinRTValue) -> napi::Result<DynWinRTValue> {
     self::adopt_co_task_mem_pointer(value)

bindings/js/src/lib.rs

@@ -135,6 +135,12 @@ pub(crate) fn set_winui_dispatcher_loop_active(active: bool) {
 #[napi]
 pub struct DynWinRTType(dynwinrt::TypeHandle);
 
+impl DynWinRTType {
+  pub(crate) fn type_handle(&self) -> dynwinrt::TypeHandle {
+    self.0.clone()
+  }
+}
+
 #[napi]
 impl DynWinRTType {
   #[napi]

crates/dynwinrt/src/com.rs

@@ -4377,6 +4377,33 @@ pub unsafe fn adopt_com_pointer(ptr: *mut c_void) -> WinRTValue {
     }
 }
 
+/// Project a managed COM object as a typed WinRT async operation.
+///
+/// The input remains owned by the caller. The returned `Async` value holds a
+/// separate `IAsyncInfo` reference and can be awaited independently.
+pub fn project_winrt_async(
+    value: &WinRTValue,
+    async_type: TypeHandle,
+) -> result::Result<WinRTValue> {
+    let async_type = async_type.normalized_async_type()?;
+    let object = value
+        .as_object()
+        .ok_or_else(|| invalid_argument("project_winrt_async requires a COM object"))?;
+    let iid = async_type
+        .iid()
+        .ok_or_else(|| invalid_argument("project_winrt_async requires a closed async IID"))?;
+    let mut concrete_ptr = std::ptr::null_mut();
+    unsafe { object.query(&iid, &mut concrete_ptr) }
+        .ok()
+        .map_err(result::Error::WindowsError)?;
+    let concrete = unsafe { IUnknown::from_raw(concrete_ptr) };
+    let info: windows_future::IAsyncInfo = concrete.cast().map_err(result::Error::WindowsError)?;
+    Ok(WinRTValue::Async(crate::value::AsyncInfo {
+        info,
+        async_type,
+    }))
+}
+
 #[cfg(test)]
 fn call_method(
     vtable_index: usize,
@@ -4439,8 +4466,10 @@ mod tests {
     use std::sync::atomic::{AtomicU32, Ordering};
     use windows::{
         ApplicationModel::DataTransfer::DataTransferManager,
+        System::Threading::{ThreadPool, WorkItemHandler},
         Win32::{
             System::Com::{CoGetMalloc, IMalloc, IPersistFile, IStream},
+            System::WinRT::{RO_INIT_MULTITHREADED, RoInitialize},
             UI::Shell::{IDataTransferManagerInterop, SHCreateMemStream},
             UI::WindowsAndMessaging::{
                 CreateWindowExW, DestroyWindow, WINDOW_EX_STYLE, WS_OVERLAPPED,
@@ -9168,6 +9197,156 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn project_winrt_async_borrows_managed_object() -> result::Result<()> {
+        let _ = unsafe { RoInitialize(RO_INIT_MULTITHREADED) };
+        let handler = WorkItemHandler::new(|_| Ok(()));
+        let operation = ThreadPool::RunAsync(&handler).map_err(result::Error::WindowsError)?;
+        let object: IUnknown = operation.cast().map_err(result::Error::WindowsError)?;
+        let source = WinRTValue::Object(object);
+
+        let projected = project_winrt_async(&source, MetadataTable::new().async_action())?;
+        assert!(matches!(projected, WinRTValue::Async(_)));
+        assert!(matches!(source, WinRTValue::Object(_)));
+
+        Ok(())
+    }
+
+    #[test]
+    fn project_winrt_async_rejects_malformed_parameterized_type() {
+        let table = MetadataTable::new();
+        let generic = table.generic(crate::metadata_table::IASYNC_OPERATION, 1);
+        let malformed = table.parameterized(&generic, &[]);
+
+        assert!(project_winrt_async(&WinRTValue::Null, malformed).is_err());
+    }
+
+    #[test]
+    fn project_winrt_async_rejects_invalid_result_signature() {
+        let table = MetadataTable::new();
+        let array = table.array(&table.i32_type());
+        let invalid = table.async_operation(&array);
+
+        assert!(project_winrt_async(&WinRTValue::Null, invalid).is_err());
+    }
+
+    #[test]
+    fn project_winrt_async_rejects_mismatched_interface_iid() -> result::Result<()> {
+        use windows::Storage::Streams::{Buffer, IOutputStream, InMemoryRandomAccessStream};
+
+        let _ = unsafe { RoInitialize(RO_INIT_MULTITHREADED) };
+        let stream = InMemoryRandomAccessStream::new().map_err(result::Error::WindowsError)?;
+        let output: IOutputStream = stream.cast().map_err(result::Error::WindowsError)?;
+        let buffer = Buffer::Create(16).map_err(result::Error::WindowsError)?;
+        buffer.SetLength(16).map_err(result::Error::WindowsError)?;
+        let operation = output
+            .WriteAsync(&buffer)
+            .map_err(result::Error::WindowsError)?;
+        let object: IUnknown = operation.cast().map_err(result::Error::WindowsError)?;
+        let source = WinRTValue::Object(object);
+
+        let table = MetadataTable::new();
+        let wrong_result = table.make(TypeKind::U64);
+        let wrong_progress = table.make(TypeKind::U64);
+        let wrong_type = table.async_operation_with_progress(&wrong_result, &wrong_progress);
+
+        assert!(project_winrt_async(&source, wrong_type).is_err());
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn project_winrt_async_normalizes_parameterized_operation() -> result::Result<()> {
+        use windows::Storage::{IStorageFile, StorageFile};
+
+        let _ = unsafe { RoInitialize(RO_INIT_MULTITHREADED) };
+        let path = std::env::current_exe().map_err(|error| invalid_argument(error.to_string()))?;
+        let operation =
+            StorageFile::GetFileFromPathAsync(&HSTRING::from(path.to_string_lossy().as_ref()))
+                .map_err(result::Error::WindowsError)?;
+        let object: IUnknown = operation.cast().map_err(result::Error::WindowsError)?;
+        let source = WinRTValue::Object(object);
+
+        let table = MetadataTable::new();
+        let storage_file_interface = table.interface(IStorageFile::IID);
+        let storage_file_type = table.runtime_class(
+            "Windows.Storage.StorageFile".to_string(),
+            &storage_file_interface,
+        );
+        let generic = table.generic(crate::metadata_table::IASYNC_OPERATION, 1);
+        let parameterized = table.parameterized(&generic, &[storage_file_type]);
+        let projected = project_winrt_async(&source, parameterized)?;
+
+        let async_info = match &projected {
+            WinRTValue::Async(info) => info,
+            other => panic!("expected Async, got {other:?}"),
+        };
+        assert!(matches!(
+            async_info.async_type.kind(),
+            TypeKind::IAsyncOperation(_)
+        ));
+        let _ = async_info.handler_iid();
+        assert!(matches!(projected.await?, WinRTValue::Object(_)));
+
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn project_winrt_async_preserves_progress_contract() -> result::Result<()> {
+        use std::sync::{Arc, atomic::Ordering};
+        use windows::Storage::Streams::{Buffer, IOutputStream, InMemoryRandomAccessStream};
+
+        let _ = unsafe { RoInitialize(RO_INIT_MULTITHREADED) };
+        let stream = InMemoryRandomAccessStream::new().map_err(result::Error::WindowsError)?;
+        let output: IOutputStream = stream.cast().map_err(result::Error::WindowsError)?;
+        let buffer = Buffer::Create(1234).map_err(result::Error::WindowsError)?;
+        buffer
+            .SetLength(1234)
+            .map_err(result::Error::WindowsError)?;
+        let operation = output
+            .WriteAsync(&buffer)
+            .map_err(result::Error::WindowsError)?;
+        let object: IUnknown = operation.cast().map_err(result::Error::WindowsError)?;
+        let source = WinRTValue::Object(object);
+
+        let table = MetadataTable::new();
+        let result_type = table.make(TypeKind::U32);
+        let progress_type = table.make(TypeKind::U32);
+        let generic = table.generic(crate::metadata_table::IASYNC_OPERATION_WITH_PROGRESS, 2);
+        let async_type =
+            table.parameterized(&generic, &[result_type.clone(), progress_type.clone()]);
+        let projected = project_winrt_async(&source, async_type)?;
+
+        let async_info = match &projected {
+            WinRTValue::Async(info) => info,
+            other => panic!("expected Async, got {other:?}"),
+        };
+        assert!(matches!(
+            async_info.async_type.kind(),
+            TypeKind::IAsyncOperationWithProgress(_)
+        ));
+        let _ = async_info.handler_iid();
+        assert_eq!(async_info.result_type().unwrap().kind(), TypeKind::U32);
+        assert_eq!(async_info.progress_type().unwrap().kind(), TypeKind::U32);
+
+        let progress_count = Arc::new(AtomicU32::new(0));
+        let callback_count = progress_count.clone();
+        let handler = crate::create_progress_handler(
+            async_info.progress_handler_iid().unwrap(),
+            async_info.progress_type().unwrap(),
+            Box::new(move |value| {
+                assert!(matches!(value, WinRTValue::U32(_)));
+                callback_count.fetch_add(1, Ordering::SeqCst);
+            }),
+        );
+        async_info.set_progress_handler(&handler)?;
+
+        let result = projected.await?;
+        assert!(matches!(result, WinRTValue::U32(1234)));
+        assert!(matches!(source, WinRTValue::Object(_)));
+
+        Ok(())
+    }
+
     #[test]
     fn co_create_instance_with_bogus_clsid_returns_error() -> result::Result<()> {
         initialize_apartment(ApartmentType::MultiThreaded)?;