[PATCH 0/4] MR7974: windows.devices.enumeration: Add a basic implementation for DeviceInformationStatics::FindAllAsync().

[Rémi Bernon (＠rbernon)]

Supersedes https://gitlab.winehq.org/wine/wine/-/merge_requests/6874

@vibhavp made various changes to simplify and make the code more consistent with other similar Wine areas.

[PATCH 1/4] windows.devices.enumeration/tests: Add conformance tests for FindAllAsync().

[Vibhav Pant]

From: Vibhav Pant

---
 .../tests/devices.c                           | 227 ++++++++++++++++--
 1 file changed, 212 insertions(+), 15 deletions(-)

diff --git a/dlls/windows.devices.enumeration/tests/devices.c b/dlls/windows.devices.enumeration/tests/devices.c
index ae76e5d754a..d9095b23f80 100644
--- a/dlls/windows.devices.enumeration/tests/devices.c
+++ b/dlls/windows.devices.enumeration/tests/devices.c
@@ -1,5 +1,6 @@
 /*
  * Copyright 2022 Julian Klemann for CodeWeavers
+ * Copyright 2025 Vibhav Pant
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -135,6 +136,184 @@ static void device_watcher_handler_create( struct device_watcher_handler *impl )
     impl->ref = 1;
 }

+struct device_information_collection_async_handler
+{
+    IAsyncOperationCompletedHandler_DeviceInformationCollection iface;
+
+    IAsyncOperation_DeviceInformationCollection *async;
+    AsyncStatus status;
+    BOOL invoked;
+    HANDLE event;
+    LONG ref;
+};
+
+static inline struct device_information_collection_async_handler *impl_from_IAsyncOperationCompletedHandler_DeviceInformationCollection( IAsyncOperationCompletedHandler_DeviceInformationCollection *iface )
+{
+    return CONTAINING_RECORD( iface, struct device_information_collection_async_handler, iface );
+}
+
+static HRESULT WINAPI device_information_collection_async_handler_QueryInterface( IAsyncOperationCompletedHandler_DeviceInformationCollection *iface,
+                                                                                  REFIID iid, void **out )
+{
+    if (IsEqualGUID( iid, &IID_IUnknown ) || IsEqualGUID( iid, &IID_IAgileObject ) ||
+        IsEqualGUID( iid, &IID_IAsyncOperationCompletedHandler_DeviceInformationCollection ))
+    {
+        IUnknown_AddRef( iface );
+        *out = iface;
+        return S_OK;
+    }
+
+    if (winetest_debug > 1)
+        trace( "%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid( iid ) );
+    *out = NULL;
+    return E_NOINTERFACE;
+}
+
+static ULONG WINAPI device_information_collection_async_handler_AddRef( IAsyncOperationCompletedHandler_DeviceInformationCollection *iface )
+{
+    struct device_information_collection_async_handler *impl = impl_from_IAsyncOperationCompletedHandler_DeviceInformationCollection( iface );
+    return InterlockedIncrement( &impl->ref );
+}
+
+static ULONG WINAPI device_information_collection_async_handler_Release( IAsyncOperationCompletedHandler_DeviceInformationCollection *iface )
+{
+    struct device_information_collection_async_handler *impl = impl_from_IAsyncOperationCompletedHandler_DeviceInformationCollection( iface );
+    ULONG ref;
+
+    ref = InterlockedDecrement( &impl->ref );
+    if (!ref) free( impl );
+    return ref;
+}
+
+static HRESULT WINAPI device_information_collection_async_handler_Invoke( IAsyncOperationCompletedHandler_DeviceInformationCollection *iface,
+                                                                          IAsyncOperation_DeviceInformationCollection *async, AsyncStatus status )
+{
+    struct device_information_collection_async_handler *impl = impl_from_IAsyncOperationCompletedHandler_DeviceInformationCollection( iface );
+
+    ok( !impl->invoked, "invoked twice\n" );
+    impl->invoked = TRUE;
+    impl->async = async;
+    impl->status = status;
+    if (impl->event) SetEvent( impl->event );
+
+    return S_OK;
+}
+
+static IAsyncOperationCompletedHandler_DeviceInformationCollectionVtbl device_information_collection_async_handler_vtbl =
+{
+    /* IUnknown */
+    device_information_collection_async_handler_QueryInterface,
+    device_information_collection_async_handler_AddRef,
+    device_information_collection_async_handler_Release,
+    /* IAsyncOperationCompletedHandler<DeviceInformationCollection> */
+    device_information_collection_async_handler_Invoke,
+};
+
+static IAsyncOperationCompletedHandler_DeviceInformationCollection *device_information_collection_async_handler_create( HANDLE event )
+{
+    struct device_information_collection_async_handler *impl;
+
+    if (!(impl = calloc( 1, sizeof(*impl) ))) return NULL;
+    impl->iface.lpVtbl = &device_information_collection_async_handler_vtbl;
+    impl->event = event;
+    impl->ref = 1;
+
+    return &impl->iface;
+}
+
+#define await_device_information_collection( a ) await_device_information_collection_( __LINE__, (a) )
+static void await_device_information_collection_( int line, IAsyncOperation_DeviceInformationCollection *async )
+{
+    IAsyncOperationCompletedHandler_DeviceInformationCollection *handler;
+    HANDLE event;
+    HRESULT hr;
+    DWORD ret;
+
+    event = CreateEventW( NULL, FALSE, FALSE, NULL );
+    ok_(__FILE__, line)( !!event, "CreateEventW failed, error %lu\n", GetLastError() );
+
+    handler = device_information_collection_async_handler_create( event );
+    ok_(__FILE__, line)( !!handler, "device_information_collection_async_handler_create failed\n" );
+    hr = IAsyncOperation_DeviceInformationCollection_put_Completed( async, handler );
+    ok_(__FILE__, line)( hr == S_OK, "put_Completed returned %#lx\n", hr );
+    IAsyncOperationCompletedHandler_DeviceInformationCollection_Release( handler );
+
+    ret = WaitForSingleObject( event, 5000 );
+    ok_(__FILE__, line)( !ret, "WaitForSingleObject returned %#lx\n", ret );
+    ret = CloseHandle( event );
+    ok_(__FILE__, line)( ret, "CloseHandle failed, error %lu\n", GetLastError() );
+}
+
+#define check_device_information_collection_async( a, b, c, d, e ) check_device_information_collection_async_( __LINE__, a, b, c, d, e )
+static void check_device_information_collection_async_( int line, IAsyncOperation_DeviceInformationCollection *async,
+                                                        UINT32 expect_id, AsyncStatus expect_status,
+                                                        HRESULT expect_hr, IVectorView_DeviceInformation **result )
+{
+    AsyncStatus async_status;
+    IAsyncInfo *async_info;
+    HRESULT hr, async_hr;
+    UINT32 async_id;
+
+    hr = IAsyncOperation_DeviceInformationCollection_QueryInterface( async, &IID_IAsyncInfo, (void **)&async_info );
+    ok_(__FILE__, line)( hr == S_OK, "QueryInterface returned %#lx\n", hr );
+
+    async_id = 0xdeadbeef;
+    hr = IAsyncInfo_get_Id( async_info, &async_id );
+    if (expect_status < 4) ok_(__FILE__, line)( hr == S_OK, "get_Id returned %#lx\n", hr );
+    else ok_(__FILE__, line)( hr == E_ILLEGAL_METHOD_CALL, "get_Id returned %#lx\n", hr );
+    ok_(__FILE__, line)( async_id == expect_id, "got id %u\n", async_id );
+
+    async_status = 0xdeadbeef;
+    hr = IAsyncInfo_get_Status( async_info, &async_status );
+    if (expect_status < 4) ok_(__FILE__, line)( hr == S_OK, "get_Status returned %#lx\n", hr );
+    else ok_(__FILE__, line)( hr == E_ILLEGAL_METHOD_CALL, "get_Status returned %#lx\n", hr );
+    ok_(__FILE__, line)( async_status == expect_status, "got status %u\n", async_status );
+
+    async_hr = 0xdeadbeef;
+    hr = IAsyncInfo_get_ErrorCode( async_info, &async_hr );
+    if (expect_status < 4) ok_(__FILE__, line)( hr == S_OK, "get_ErrorCode returned %#lx\n", hr );
+    else ok_(__FILE__, line)( hr == E_ILLEGAL_METHOD_CALL, "get_ErrorCode returned %#lx\n", hr );
+    if (expect_status < 4) todo_wine_if( FAILED(expect_hr))
+    ok_(__FILE__, line)( async_hr == expect_hr, "got error %#lx\n", async_hr );
+    else ok_(__FILE__, line)( async_hr == E_ILLEGAL_METHOD_CALL, "got error %#lx\n", async_hr );
+
+        IAsyncInfo_Release( async_info );
+
+    hr = IAsyncOperation_DeviceInformationCollection_GetResults( async, result );
+    switch (expect_status)
+    {
+    case Completed:
+    case Error:
+        todo_wine_if( FAILED(expect_hr))
+        ok_(__FILE__, line)( hr == expect_hr, "GetResults returned %#lx\n", hr );
+        break;
+    case Canceled:
+    case Started:
+    default:
+        ok_(__FILE__, line)( hr == E_ILLEGAL_METHOD_CALL, "GetResults returned %#lx\n", hr );
+        break;
+    }
+}
+
+static void test_DeviceInformation_obj( int line, IDeviceInformation *info )
+{
+    HRESULT hr;
+    HSTRING str;
+    boolean bool_val;
+
+    hr = IDeviceInformation_get_Id( info, &str );
+    ok_(__FILE__, line)( hr == S_OK, "got hr %#lx\n", hr );
+    WindowsDeleteString( str );
+    str = NULL;
+    hr = IDeviceInformation_get_Name( info, &str );
+    todo_wine ok_(__FILE__, line)( hr == S_OK, "got hr %#lx\n", hr );
+    WindowsDeleteString( str );
+    hr = IDeviceInformation_get_IsEnabled( info, &bool_val );
+    todo_wine ok_(__FILE__, line)( hr == S_OK, "got hr %#lx\n", hr );
+    hr = IDeviceInformation_get_IsDefault( info, &bool_val );
+    todo_wine ok_(__FILE__, line)( hr == S_OK, "got hr %#lx\n", hr );
+}
+
 static void test_DeviceInformation( void )
 {
     static const WCHAR *device_info_name = L"Windows.Devices.Enumeration.DeviceInformation";
@@ -147,9 +326,13 @@ static void test_DeviceInformation( void )
     IDeviceInformationStatics *device_info_statics;
     IDeviceWatcher *device_watcher;
     DeviceWatcherStatus status = 0xdeadbeef;
-    ULONG ref;
+    IAsyncOperation_DeviceInformationCollection *info_collection_async = NULL;
+    IVectorView_DeviceInformation *info_collection = NULL;
+    IDeviceInformation *info;
+    UINT32 i, size;
     HSTRING str;
     HRESULT hr;
+    ULONG ref;

device_watcher_handler_create( &added_handler );
     device_watcher_handler_create( &stopped_handler );
@@ -188,14 +371,9 @@ static void test_DeviceInformation( void )
     check_interface( device_watcher, &IID_IAgileObject, TRUE );
     check_interface( device_watcher, &IID_IDeviceWatcher, TRUE );

-    hr = IDeviceWatcher_add_Added(
-            device_watcher,
-            (ITypedEventHandler_DeviceWatcher_DeviceInformation *)&added_handler.ITypedEventHandler_DeviceWatcher_IInspectable_iface,
-            &added_token );
+    hr = IDeviceWatcher_add_Added( device_watcher, (void *)&added_handler.ITypedEventHandler_DeviceWatcher_IInspectable_iface, &added_token );
     ok( hr == S_OK, "got hr %#lx\n", hr );
-    hr = IDeviceWatcher_add_Stopped(
-            device_watcher, &stopped_handler.ITypedEventHandler_DeviceWatcher_IInspectable_iface,
-            &stopped_token );
+    hr = IDeviceWatcher_add_Stopped( device_watcher, &stopped_handler.ITypedEventHandler_DeviceWatcher_IInspectable_iface, &stopped_token );
     ok( hr == S_OK, "got hr %#lx\n", hr );

hr = IDeviceWatcher_get_Status( device_watcher, &status );
@@ -240,14 +418,9 @@ static void test_DeviceInformation( void )
     check_interface( device_watcher, &IID_IAgileObject, TRUE );
     check_interface( device_watcher, &IID_IDeviceWatcher, TRUE );

-    hr = IDeviceWatcher_add_Added(
-            device_watcher,
-            (ITypedEventHandler_DeviceWatcher_DeviceInformation *)&added_handler.ITypedEventHandler_DeviceWatcher_IInspectable_iface,
-            &added_token );
+    hr = IDeviceWatcher_add_Added( device_watcher, (void *)&added_handler.ITypedEventHandler_DeviceWatcher_IInspectable_iface, &added_token );
     ok( hr == S_OK, "got hr %#lx\n", hr );
-    hr = IDeviceWatcher_add_Stopped(
-            device_watcher, &stopped_handler.ITypedEventHandler_DeviceWatcher_IInspectable_iface,
-            &stopped_token );
+    hr = IDeviceWatcher_add_Stopped( device_watcher, &stopped_handler.ITypedEventHandler_DeviceWatcher_IInspectable_iface, &stopped_token );
     ok( hr == S_OK, "got hr %#lx\n", hr );

hr = IDeviceWatcher_get_Status( device_watcher, &status );
@@ -273,7 +446,31 @@ static void test_DeviceInformation( void )
     ok( stopped_handler.args == NULL, "stopped_handler not invoked\n" );

IDeviceWatcher_Release( device_watcher );
+
+    hr = IDeviceInformationStatics_FindAllAsync( device_info_statics, &info_collection_async );
+    todo_wine ok( hr == S_OK, "got %#lx\n", hr );
+    if (hr == S_OK)
+    {
+    await_device_information_collection( info_collection_async );
+    check_device_information_collection_async( info_collection_async, 1, Completed, S_OK, &info_collection );
+    IAsyncOperation_DeviceInformationCollection_Release( info_collection_async );
+
+    hr = IVectorView_DeviceInformation_get_Size( info_collection, &size );
+    ok( hr == S_OK, "got %#lx\n", hr );
+    for (i = 0; i < size; i++)
+    {
+        winetest_push_context( "info_collection %u", i );
+        hr = IVectorView_DeviceInformation_GetAt( info_collection, i, &info );
+        ok( hr == S_OK, "got %#lx\n", hr );
+        test_DeviceInformation_obj( __LINE__, info );
+        IDeviceInformation_Release( info );
+        winetest_pop_context();
+    }
+    IVectorView_DeviceInformation_Release( info_collection );
+    }
+
     IDeviceInformationStatics_Release( device_info_statics );
+
 skip_device_statics:
     IInspectable_Release( inspectable );
     ref = IActivationFactory_Release( factory );

[PATCH 2/4] windows.devices.enumeration: Add a stubbed implementation for FindAllAsync() and DeviceInformationCollection.

[Vibhav Pant]

From: Vibhav Pant

---
 dlls/windows.devices.enumeration/Makefile.in  |   5 +-
 dlls/windows.devices.enumeration/async.c      | 506 +++++++++++++
 dlls/windows.devices.enumeration/async.idl    |  44 ++
 dlls/windows.devices.enumeration/main.c       |  29 +-
 dlls/windows.devices.enumeration/private.h    |  12 +
 .../tests/devices.c                           |   6 +-
 dlls/windows.devices.enumeration/vector.c     | 675 ++++++++++++++++++
 7 files changed, 1270 insertions(+), 7 deletions(-)
 create mode 100644 dlls/windows.devices.enumeration/async.c
 create mode 100644 dlls/windows.devices.enumeration/async.idl
 create mode 100644 dlls/windows.devices.enumeration/vector.c

diff --git a/dlls/windows.devices.enumeration/Makefile.in b/dlls/windows.devices.enumeration/Makefile.in
index 93c15dfcc64..68110328964 100644
--- a/dlls/windows.devices.enumeration/Makefile.in
+++ b/dlls/windows.devices.enumeration/Makefile.in
@@ -3,6 +3,9 @@ IMPORTS = combase uuid

SOURCES = \
    access.c \
+	async.c \
+	async.idl \
    classes.idl \
    event_handlers.c \
-	main.c
+	main.c \
+	vector.c
diff --git a/dlls/windows.devices.enumeration/async.c b/dlls/windows.devices.enumeration/async.c
new file mode 100644
index 00000000000..ffb05d6c004
--- /dev/null
+++ b/dlls/windows.devices.enumeration/async.c
@@ -0,0 +1,506 @@
+/* Copyright 2022 Bernhard Kölbl for CodeWeavers
+ * Copyright 2022 Rémi Bernon for CodeWeavers
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include "private.h"
+#include <initguid.h>
+#include "async.h"
+
+#include <wine/debug.h>
+
+WINE_DEFAULT_DEBUG_CHANNEL(enumeration);
+
+#define Closed 4
+#define HANDLER_NOT_SET ((void *)~(ULONG_PTR)0)
+
+struct async_info
+{
+    IWineAsyncInfoImpl IWineAsyncInfoImpl_iface;
+    IAsyncInfo IAsyncInfo_iface;
+    IInspectable *IInspectable_outer;
+    LONG ref;
+
+    async_operation_callback callback;
+    TP_WORK *async_run_work;
+    IUnknown *invoker;
+    IUnknown *param;
+
+    CRITICAL_SECTION cs;
+    IWineAsyncOperationCompletedHandler *handler;
+    PROPVARIANT result;
+    AsyncStatus status;
+    HRESULT hr;
+};
+
+static inline struct async_info *impl_from_IWineAsyncInfoImpl( IWineAsyncInfoImpl *iface )
+{
+    return CONTAINING_RECORD( iface, struct async_info, IWineAsyncInfoImpl_iface );
+}
+
+static HRESULT WINAPI async_impl_QueryInterface( IWineAsyncInfoImpl *iface, REFIID iid, void **out )
+{
+    struct async_info *impl = impl_from_IWineAsyncInfoImpl( iface );
+
+    TRACE( "iface %p, iid %s, out %p.\n", iface, debugstr_guid( iid ), out );
+
+    if (IsEqualGUID( iid, &IID_IUnknown ) ||
+        IsEqualGUID( iid, &IID_IInspectable ) ||
+        IsEqualGUID( iid, &IID_IAgileObject ) ||
+        IsEqualGUID( iid, &IID_IWineAsyncInfoImpl ))
+    {
+        IInspectable_AddRef( (*out = &impl->IWineAsyncInfoImpl_iface) );
+        return S_OK;
+    }
+
+    if (IsEqualGUID( iid, &IID_IAsyncInfo ))
+    {
+        IInspectable_AddRef( (*out = &impl->IAsyncInfo_iface) );
+        return S_OK;
+    }
+
+    FIXME( "%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid( iid ) );
+    *out = NULL;
+    return E_NOINTERFACE;
+}
+
+static ULONG WINAPI async_impl_AddRef( IWineAsyncInfoImpl *iface )
+{
+    struct async_info *impl = impl_from_IWineAsyncInfoImpl( iface );
+    ULONG ref = InterlockedIncrement( &impl->ref );
+    TRACE( "iface %p, ref %lu.\n", iface, ref );
+    return ref;
+}
+
+static ULONG WINAPI async_impl_Release( IWineAsyncInfoImpl *iface )
+{
+    struct async_info *impl = impl_from_IWineAsyncInfoImpl( iface );
+    ULONG ref = InterlockedDecrement( &impl->ref );
+    TRACE( "iface %p, ref %lu.\n", iface, ref );
+
+    if (!ref)
+    {
+        if (impl->handler && impl->handler != HANDLER_NOT_SET) IWineAsyncOperationCompletedHandler_Release( impl->handler );
+        IAsyncInfo_Close( &impl->IAsyncInfo_iface );
+        if (impl->param) IUnknown_Release( impl->param );
+        if (impl->invoker) IUnknown_Release( impl->invoker );
+        impl->cs.DebugInfo->Spare[0] = 0;
+        DeleteCriticalSection( &impl->cs );
+        free( impl );
+    }
+
+    return ref;
+}
+
+static HRESULT WINAPI async_impl_put_Completed( IWineAsyncInfoImpl *iface, IWineAsyncOperationCompletedHandler *handler )
+{
+    struct async_info *impl = impl_from_IWineAsyncInfoImpl( iface );
+    HRESULT hr = S_OK;
+
+    TRACE( "iface %p, handler %p.\n", iface, handler );
+
+    EnterCriticalSection( &impl->cs );
+    if (impl->status == Closed) hr = E_ILLEGAL_METHOD_CALL;
+    else if (impl->handler != HANDLER_NOT_SET) hr = E_ILLEGAL_DELEGATE_ASSIGNMENT;
+    else if ((impl->handler = handler))
+    {
+        IWineAsyncOperationCompletedHandler_AddRef( impl->handler );
+
+        if (impl->status > Started)
+        {
+            IInspectable *operation = impl->IInspectable_outer;
+            AsyncStatus status = impl->status;
+            impl->handler = NULL; /* Prevent concurrent invoke. */
+            LeaveCriticalSection( &impl->cs );
+
+            IWineAsyncOperationCompletedHandler_Invoke( handler, operation, status );
+            IWineAsyncOperationCompletedHandler_Release( handler );
+
+            return S_OK;
+        }
+    }
+    LeaveCriticalSection( &impl->cs );
+
+    return hr;
+}
+
+static HRESULT WINAPI async_impl_get_Completed( IWineAsyncInfoImpl *iface, IWineAsyncOperationCompletedHandler **handler )
+{
+    struct async_info *impl = impl_from_IWineAsyncInfoImpl( iface );
+    HRESULT hr = S_OK;
+
+    TRACE( "iface %p, handler %p.\n", iface, handler );
+
+    EnterCriticalSection( &impl->cs );
+    if (impl->status == Closed) hr = E_ILLEGAL_METHOD_CALL;
+    if (impl->handler == NULL || impl->handler == HANDLER_NOT_SET) *handler = NULL;
+    else IWineAsyncOperationCompletedHandler_AddRef( (*handler = impl->handler) );
+    LeaveCriticalSection( &impl->cs );
+
+    return hr;
+}
+
+static HRESULT WINAPI async_impl_get_Result( IWineAsyncInfoImpl *iface, PROPVARIANT *result )
+{
+    struct async_info *impl = impl_from_IWineAsyncInfoImpl( iface );
+    HRESULT hr = E_ILLEGAL_METHOD_CALL;
+
+    TRACE( "iface %p, result %p.\n", iface, result );
+
+    EnterCriticalSection( &impl->cs );
+    if (impl->status == Completed || impl->status == Error)
+    {
+        PropVariantCopy( result, &impl->result );
+        hr = impl->hr;
+    }
+    LeaveCriticalSection( &impl->cs );
+
+    return hr;
+}
+
+static HRESULT WINAPI async_impl_Start( IWineAsyncInfoImpl *iface )
+{
+    struct async_info *impl = impl_from_IWineAsyncInfoImpl( iface );
+
+    TRACE( "iface %p.\n", iface );
+
+    /* keep the async alive in the callback */
+    IInspectable_AddRef( impl->IInspectable_outer );
+    SubmitThreadpoolWork( impl->async_run_work );
+
+    return S_OK;
+}
+
+static const struct IWineAsyncInfoImplVtbl async_impl_vtbl =
+{
+    /* IUnknown methods */
+    async_impl_QueryInterface,
+    async_impl_AddRef,
+    async_impl_Release,
+    /* IWineAsyncInfoImpl */
+    async_impl_put_Completed,
+    async_impl_get_Completed,
+    async_impl_get_Result,
+    async_impl_Start,
+};
+
+DEFINE_IINSPECTABLE_OUTER( async_info, IAsyncInfo, struct async_info, IInspectable_outer )
+
+static HRESULT WINAPI async_info_get_Id( IAsyncInfo *iface, UINT32 *id )
+{
+    struct async_info *impl = impl_from_IAsyncInfo( iface );
+    HRESULT hr = S_OK;
+
+    TRACE( "iface %p, id %p.\n", iface, id );
+
+    EnterCriticalSection( &impl->cs );
+    if (impl->status == Closed) hr = E_ILLEGAL_METHOD_CALL;
+    *id = 1;
+    LeaveCriticalSection( &impl->cs );
+
+    return hr;
+}
+
+static HRESULT WINAPI async_info_get_Status( IAsyncInfo *iface, AsyncStatus *status )
+{
+    struct async_info *impl = impl_from_IAsyncInfo( iface );
+    HRESULT hr = S_OK;
+
+    TRACE( "iface %p, status %p.\n", iface, status );
+
+    EnterCriticalSection( &impl->cs );
+    if (impl->status == Closed) hr = E_ILLEGAL_METHOD_CALL;
+    *status = impl->status;
+    LeaveCriticalSection( &impl->cs );
+
+    return hr;
+}
+
+static HRESULT WINAPI async_info_get_ErrorCode( IAsyncInfo *iface, HRESULT *error_code )
+{
+    struct async_info *impl = impl_from_IAsyncInfo( iface );
+    HRESULT hr = S_OK;
+
+    TRACE( "iface %p, error_code %p.\n", iface, error_code );
+
+    EnterCriticalSection( &impl->cs );
+    if (impl->status == Closed) *error_code = hr = E_ILLEGAL_METHOD_CALL;
+    else *error_code = impl->hr;
+    LeaveCriticalSection( &impl->cs );
+
+    return hr;
+}
+
+static HRESULT WINAPI async_info_Cancel( IAsyncInfo *iface )
+{
+    struct async_info *impl = impl_from_IAsyncInfo( iface );
+    HRESULT hr = S_OK;
+
+    TRACE( "iface %p.\n", iface );
+
+    EnterCriticalSection( &impl->cs );
+    if (impl->status == Closed) hr = E_ILLEGAL_METHOD_CALL;
+    else if (impl->status == Started) impl->status = Canceled;
+    LeaveCriticalSection( &impl->cs );
+
+    return hr;
+}
+
+static HRESULT WINAPI async_info_Close( IAsyncInfo *iface )
+{
+    struct async_info *impl = impl_from_IAsyncInfo( iface );
+    HRESULT hr = S_OK;
+
+    TRACE( "iface %p.\n", iface );
+
+    EnterCriticalSection( &impl->cs );
+    if (impl->status == Started)
+        hr = E_ILLEGAL_STATE_CHANGE;
+    else if (impl->status != Closed)
+    {
+        CloseThreadpoolWork( impl->async_run_work );
+        impl->async_run_work = NULL;
+        impl->status = Closed;
+    }
+    LeaveCriticalSection( &impl->cs );
+
+    return hr;
+}
+
+static const struct IAsyncInfoVtbl async_info_vtbl =
+{
+    /* IUnknown methods */
+    async_info_QueryInterface,
+    async_info_AddRef,
+    async_info_Release,
+    /* IInspectable methods */
+    async_info_GetIids,
+    async_info_GetRuntimeClassName,
+    async_info_GetTrustLevel,
+    /* IAsyncInfo */
+    async_info_get_Id,
+    async_info_get_Status,
+    async_info_get_ErrorCode,
+    async_info_Cancel,
+    async_info_Close,
+};
+
+static void CALLBACK async_info_callback( TP_CALLBACK_INSTANCE *instance, void *iface, TP_WORK *work )
+{
+    struct async_info *impl = impl_from_IWineAsyncInfoImpl( iface );
+    IInspectable *operation = impl->IInspectable_outer;
+    PROPVARIANT result;
+    HRESULT hr;
+
+    hr = impl->callback( impl->invoker, impl->param, &result );
+
+    EnterCriticalSection( &impl->cs );
+    if (impl->status != Closed) impl->status = FAILED(hr) ? Error : Completed;
+    PropVariantCopy( &impl->result, &result );
+    impl->hr = hr;
+
+    if (impl->handler != NULL && impl->handler != HANDLER_NOT_SET)
+    {
+        IWineAsyncOperationCompletedHandler *handler = impl->handler;
+        AsyncStatus status = impl->status;
+        impl->handler = NULL; /* Prevent concurrent invoke. */
+        LeaveCriticalSection( &impl->cs );
+
+        IWineAsyncOperationCompletedHandler_Invoke( handler, operation, status );
+        IWineAsyncOperationCompletedHandler_Release( handler );
+    }
+    else LeaveCriticalSection( &impl->cs );
+
+    /* release refcount acquired in Start */
+    IInspectable_Release( operation );
+
+    PropVariantClear( &result );
+}
+
+static HRESULT async_info_create( IUnknown *invoker, IUnknown *param, async_operation_callback callback,
+                                  IInspectable *outer, IWineAsyncInfoImpl **out )
+{
+    struct async_info *impl;
+    HRESULT hr;
+
+    if (!(impl = calloc( 1, sizeof(struct async_info) ))) return E_OUTOFMEMORY;
+    impl->IWineAsyncInfoImpl_iface.lpVtbl = &async_impl_vtbl;
+    impl->IAsyncInfo_iface.lpVtbl = &async_info_vtbl;
+    impl->IInspectable_outer = outer;
+    impl->ref = 1;
+
+    impl->callback = callback;
+    impl->handler = HANDLER_NOT_SET;
+    impl->status = Started;
+    if (!(impl->async_run_work = CreateThreadpoolWork( async_info_callback, &impl->IWineAsyncInfoImpl_iface, NULL )))
+    {
+        hr = HRESULT_FROM_WIN32( GetLastError() );
+        free( impl );
+        return hr;
+    }
+
+    if ((impl->invoker = invoker)) IUnknown_AddRef( impl->invoker );
+    if ((impl->param = param)) IUnknown_AddRef( impl->param );
+
+    InitializeCriticalSectionEx( &impl->cs, 0, RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO );
+    impl->cs.DebugInfo->Spare[0] = (DWORD_PTR)( __FILE__ ": async_info.cs" );
+
+    *out = &impl->IWineAsyncInfoImpl_iface;
+    return S_OK;
+}
+
+struct async_result
+{
+    IAsyncOperation_DeviceInformationCollection IAsyncOperation_DeviceInformationCollection_iface;
+    IWineAsyncInfoImpl *IWineAsyncInfoImpl_inner;
+    LONG ref;
+};
+
+static inline struct async_result *impl_from_IAsyncOperation_DeviceInformationCollection( IAsyncOperation_DeviceInformationCollection *iface )
+{
+    return CONTAINING_RECORD( iface, struct async_result, IAsyncOperation_DeviceInformationCollection_iface );
+}
+
+static HRESULT WINAPI async_result_QueryInterface( IAsyncOperation_DeviceInformationCollection *iface, REFIID iid, void **out )
+{
+    struct async_result *impl = impl_from_IAsyncOperation_DeviceInformationCollection( iface );
+
+    TRACE( "iface %p, iid %s, out %p.\n", iface, debugstr_guid( iid ), out );
+
+    if (IsEqualGUID( iid, &IID_IUnknown ) ||
+        IsEqualGUID( iid, &IID_IInspectable ) ||
+        IsEqualGUID( iid, &IID_IAgileObject ) ||
+        IsEqualGUID( iid, &IID_IAsyncOperation_DeviceInformationCollection ))
+    {
+        IInspectable_AddRef( (*out = &impl->IAsyncOperation_DeviceInformationCollection_iface) );
+        return S_OK;
+    }
+
+    return IWineAsyncInfoImpl_QueryInterface( impl->IWineAsyncInfoImpl_inner, iid, out );
+}
+
+static ULONG WINAPI async_result_AddRef( IAsyncOperation_DeviceInformationCollection *iface )
+{
+    struct async_result *impl = impl_from_IAsyncOperation_DeviceInformationCollection( iface );
+    ULONG ref = InterlockedIncrement( &impl->ref );
+    TRACE( "iface %p, ref %lu.\n", iface, ref );
+    return ref;
+}
+
+static ULONG WINAPI async_result_Release( IAsyncOperation_DeviceInformationCollection *iface )
+{
+    struct async_result *impl = impl_from_IAsyncOperation_DeviceInformationCollection( iface );
+    ULONG ref = InterlockedDecrement( &impl->ref );
+    TRACE( "iface %p, ref %lu.\n", iface, ref );
+
+    if (!ref)
+    {
+        /* guard against re-entry if inner releases an outer iface */
+        InterlockedIncrement( &impl->ref );
+        IWineAsyncInfoImpl_Release( impl->IWineAsyncInfoImpl_inner );
+        free( impl );
+    }
+
+    return ref;
+}
+
+static HRESULT WINAPI async_result_GetIids( IAsyncOperation_DeviceInformationCollection *iface, ULONG *iid_count, IID **iids )
+{
+    FIXME( "iface %p, iid_count %p, iids %p stub!\n", iface, iid_count, iids );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI async_result_GetRuntimeClassName( IAsyncOperation_DeviceInformationCollection *iface, HSTRING *class_name )
+{
+    return WindowsCreateString( L"Windows.Foundation.IAsyncOperation`1<Windows.Devices.Enumeration.DeviceInformationCollection>",
+                                ARRAY_SIZE(L"Windows.Foundation.IAsyncOperation`1<Windows.Devices.Enumeration.DeviceInformationCollection>"),
+                                class_name );
+}
+
+static HRESULT WINAPI async_result_GetTrustLevel( IAsyncOperation_DeviceInformationCollection *iface, TrustLevel *trust_level )
+{
+    FIXME( "iface %p, trust_level %p stub!\n", iface, trust_level );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI async_result_put_Completed( IAsyncOperation_DeviceInformationCollection *iface, IAsyncOperationCompletedHandler_DeviceInformationCollection *handler )
+{
+    struct async_result *impl = impl_from_IAsyncOperation_DeviceInformationCollection( iface );
+    TRACE( "iface %p, handler %p.\n", iface, handler );
+    return IWineAsyncInfoImpl_put_Completed( impl->IWineAsyncInfoImpl_inner, (IWineAsyncOperationCompletedHandler *)handler );
+}
+
+static HRESULT WINAPI async_result_get_Completed( IAsyncOperation_DeviceInformationCollection *iface, IAsyncOperationCompletedHandler_DeviceInformationCollection **handler )
+{
+    struct async_result *impl = impl_from_IAsyncOperation_DeviceInformationCollection( iface );
+    TRACE( "iface %p, handler %p.\n", iface, handler );
+    return IWineAsyncInfoImpl_get_Completed( impl->IWineAsyncInfoImpl_inner, (IWineAsyncOperationCompletedHandler **)handler );
+}
+
+static HRESULT WINAPI async_result_GetResults( IAsyncOperation_DeviceInformationCollection *iface, IVectorView_DeviceInformation **results )
+{
+    struct async_result *impl = impl_from_IAsyncOperation_DeviceInformationCollection( iface );
+    PROPVARIANT result = {.vt = VT_UNKNOWN};
+    HRESULT hr;
+
+    TRACE( "iface %p, results %p.\n", iface, results );
+
+    hr = IWineAsyncInfoImpl_get_Result( impl->IWineAsyncInfoImpl_inner, &result );
+    if (SUCCEEDED( hr ))
+        hr = IUnknown_QueryInterface( result.punkVal, &IID_IVectorView_DeviceInformation, (void **)results );
+    PropVariantClear( &result );
+    return hr;
+}
+
+static const struct IAsyncOperation_DeviceInformationCollectionVtbl async_result_vtbl =
+{
+    /* IUnknown methods */
+    async_result_QueryInterface,
+    async_result_AddRef,
+    async_result_Release,
+    /* IInspectable methods */
+    async_result_GetIids,
+    async_result_GetRuntimeClassName,
+    async_result_GetTrustLevel,
+    /* IAsyncOperation<DeviceInformationCollection> */
+    async_result_put_Completed,
+    async_result_get_Completed,
+    async_result_GetResults,
+};
+
+HRESULT async_operation_device_info_collection_result_create( IUnknown *invoker, IUnknown *param, async_operation_callback callback,
+                                                              IAsyncOperation_DeviceInformationCollection **out )
+{
+    struct async_result *impl;
+    HRESULT hr;
+
+    *out = NULL;
+    if (!(impl = calloc( 1, sizeof(*impl) ))) return E_OUTOFMEMORY;
+    impl->IAsyncOperation_DeviceInformationCollection_iface.lpVtbl = &async_result_vtbl;
+    impl->ref = 1;
+
+    if (FAILED(hr = async_info_create( invoker, param, callback, (IInspectable *)&impl->IAsyncOperation_DeviceInformationCollection_iface, &impl->IWineAsyncInfoImpl_inner )) ||
+        FAILED(hr = IWineAsyncInfoImpl_Start( impl->IWineAsyncInfoImpl_inner )))
+    {
+        if (impl->IWineAsyncInfoImpl_inner) IWineAsyncInfoImpl_Release( impl->IWineAsyncInfoImpl_inner );
+        free( impl );
+        return hr;
+    }
+
+    *out = &impl->IAsyncOperation_DeviceInformationCollection_iface;
+    TRACE( "created IAsyncOperation_DeviceInformationCollection %p\n", *out );
+    return S_OK;
+}
diff --git a/dlls/windows.devices.enumeration/async.idl b/dlls/windows.devices.enumeration/async.idl
new file mode 100644
index 00000000000..88e1a76f547
--- /dev/null
+++ b/dlls/windows.devices.enumeration/async.idl
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2022 Rémi Bernon for CodeWeavers
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#pragma makedep header
+
+#ifdef __WIDL__
+#pragma winrt ns_prefix
+#endif
+
+import "propidl.idl";
+import "inspectable.idl";
+import "asyncinfo.idl";
+import "windowscontracts.idl";
+
+namespace Windows.Devices.Enumeration {
+    /* type-pruning version of AsyncOperationCompletedHandler<T> */
+    delegate HRESULT WineAsyncOperationCompletedHandler([in] IInspectable *async, [in] AsyncStatus status);
+
+    [
+        uuid(d81ab70d-82e0-481c-983d-401225d98a2c)
+    ]
+    interface IWineAsyncInfoImpl : IUnknown
+    {
+        [propput] HRESULT Completed([in] WineAsyncOperationCompletedHandler *handler);
+        [propget] HRESULT Completed([out, retval] WineAsyncOperationCompletedHandler **handler);
+        [propget] HRESULT Result([out, retval] PROPVARIANT *result);
+        HRESULT Start();
+    }
+}
diff --git a/dlls/windows.devices.enumeration/main.c b/dlls/windows.devices.enumeration/main.c
index 5c930dba121..48c49a50125 100644
--- a/dlls/windows.devices.enumeration/main.c
+++ b/dlls/windows.devices.enumeration/main.c
@@ -333,11 +333,36 @@ static HRESULT WINAPI device_statics_CreateFromIdAsyncAdditionalProperties( IDev
     return E_NOTIMPL;
 }

+static HRESULT WINAPI find_all_async( IUnknown *invoker, IUnknown *param, PROPVARIANT *result )
+{
+    static const struct vector_iids iids =
+    {
+        .vector = &IID_IVector_IInspectable,
+        .view = &IID_IVectorView_DeviceInformation,
+        .iterable = &IID_IIterable_DeviceInformation,
+        .iterator = &IID_IIterator_DeviceInformation,
+    };
+    HRESULT hr;
+    IVector_IInspectable *vector;
+    IVectorView_DeviceInformation *view;
+
+    FIXME( "invoker %p, param %p, result %p semi-stub!\n", invoker, param, result );
+
+    if (FAILED(hr = vector_create( &iids, (void *)&vector ))) return hr;
+    hr = IVector_IInspectable_GetView( vector, (void *)&view );
+    IVector_IInspectable_Release( vector );
+    if (FAILED(hr)) return hr;
+
+    result->vt = VT_UNKNOWN;
+    result->punkVal = (IUnknown *)view;
+    return hr;
+}
+
 static HRESULT WINAPI device_statics_FindAllAsync( IDeviceInformationStatics *iface,
                                                    IAsyncOperation_DeviceInformationCollection **op )
 {
-    FIXME( "iface %p, op %p stub!\n", iface, op );
-    return E_NOTIMPL;
+    TRACE( "iface %p, op %p\n", iface, op );
+    return async_operation_device_info_collection_result_create( (IUnknown *)iface, NULL, find_all_async, op );
 }

static HRESULT WINAPI device_statics_FindAllAsyncDeviceClass( IDeviceInformationStatics *iface, DeviceClass class,
diff --git a/dlls/windows.devices.enumeration/private.h b/dlls/windows.devices.enumeration/private.h
index 06234e984e0..4063b0465f5 100644
--- a/dlls/windows.devices.enumeration/private.h
+++ b/dlls/windows.devices.enumeration/private.h
@@ -39,6 +39,14 @@

#include "wine/list.h"

+struct vector_iids
+{
+    const GUID *vector;
+    const GUID *view;
+    const GUID *iterable;
+    const GUID *iterator;
+};
+
 extern IActivationFactory *device_access_factory;

HRESULT typed_event_handlers_append( struct list *list, ITypedEventHandler_IInspectable_IInspectable *handler, EventRegistrationToken *token );
@@ -46,6 +54,10 @@ HRESULT typed_event_handlers_remove( struct list *list, EventRegistrationToken *
 HRESULT typed_event_handlers_notify( struct list *list, IInspectable *sender, IInspectable *args );
 HRESULT typed_event_handlers_clear( struct list *list );

+typedef HRESULT (WINAPI *async_operation_callback)( IUnknown *invoker, IUnknown *param, PROPVARIANT *result );
+extern HRESULT async_operation_device_info_collection_result_create( IUnknown *invoker, IUnknown *param, async_operation_callback callback,
+                                                                     IAsyncOperation_DeviceInformationCollection **out );
+extern HRESULT vector_create( const struct vector_iids *iids, void **out );
 #define DEFINE_IINSPECTABLE_( pfx, iface_type, impl_type, impl_from, iface_mem, expr )             \
     static inline impl_type *impl_from( iface_type *iface )                                        \
     {                                                                                              \
diff --git a/dlls/windows.devices.enumeration/tests/devices.c b/dlls/windows.devices.enumeration/tests/devices.c
index d9095b23f80..a6c0ce0fe03 100644
--- a/dlls/windows.devices.enumeration/tests/devices.c
+++ b/dlls/windows.devices.enumeration/tests/devices.c
@@ -448,9 +448,8 @@ static void test_DeviceInformation( void )
     IDeviceWatcher_Release( device_watcher );

hr = IDeviceInformationStatics_FindAllAsync( device_info_statics, &info_collection_async );
-    todo_wine ok( hr == S_OK, "got %#lx\n", hr );
-    if (hr == S_OK)
-    {
+    ok( hr == S_OK, "got %#lx\n", hr );
+
     await_device_information_collection( info_collection_async );
     check_device_information_collection_async( info_collection_async, 1, Completed, S_OK, &info_collection );
     IAsyncOperation_DeviceInformationCollection_Release( info_collection_async );
@@ -467,7 +466,6 @@ static void test_DeviceInformation( void )
         winetest_pop_context();
     }
     IVectorView_DeviceInformation_Release( info_collection );
-    }

IDeviceInformationStatics_Release( device_info_statics );

diff --git a/dlls/windows.devices.enumeration/vector.c b/dlls/windows.devices.enumeration/vector.c
new file mode 100644
index 00000000000..5053b1c10bb
--- /dev/null
+++ b/dlls/windows.devices.enumeration/vector.c
@@ -0,0 +1,675 @@
+/* DeviceInformationCollection implementation
+ *
+ * Copyright 2021 Rémi Bernon for CodeWeavers
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include "private.h"
+
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(combase);
+
+struct iterator
+{
+    IIterator_IInspectable IIterator_IInspectable_iface;
+    const GUID *iid;
+    LONG ref;
+
+    IVectorView_IInspectable *view;
+    UINT32 index;
+    UINT32 size;
+};
+
+static inline struct iterator *impl_from_IIterator_IInspectable( IIterator_IInspectable *iface )
+{
+    return CONTAINING_RECORD( iface, struct iterator, IIterator_IInspectable_iface );
+}
+
+static HRESULT WINAPI iterator_QueryInterface( IIterator_IInspectable *iface, REFIID iid, void **out )
+{
+    struct iterator *impl = impl_from_IIterator_IInspectable( iface );
+
+    TRACE( "iface %p, iid %s, out %p.\n", iface, debugstr_guid( iid ), out );
+
+    if (IsEqualGUID( iid, &IID_IUnknown ) ||
+        IsEqualGUID( iid, &IID_IInspectable ) ||
+        IsEqualGUID( iid, &IID_IAgileObject ) ||
+        IsEqualGUID( iid, impl->iid ))
+    {
+        IInspectable_AddRef( (*out = &impl->IIterator_IInspectable_iface) );
+        return S_OK;
+    }
+
+    FIXME( "%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid( iid ) );
+    *out = NULL;
+    return E_NOINTERFACE;
+}
+
+static ULONG WINAPI iterator_AddRef( IIterator_IInspectable *iface )
+{
+    struct iterator *impl = impl_from_IIterator_IInspectable( iface );
+    ULONG ref = InterlockedIncrement( &impl->ref );
+    TRACE( "iface %p increasing refcount to %lu.\n", iface, ref );
+    return ref;
+}
+
+static ULONG WINAPI iterator_Release( IIterator_IInspectable *iface )
+{
+    struct iterator *impl = impl_from_IIterator_IInspectable( iface );
+    ULONG ref = InterlockedDecrement( &impl->ref );
+
+    TRACE( "iface %p decreasing refcount to %lu.\n", iface, ref );
+
+    if (!ref)
+    {
+        IVectorView_IInspectable_Release( impl->view );
+        free( impl );
+    }
+
+    return ref;
+}
+
+static HRESULT WINAPI iterator_GetIids( IIterator_IInspectable *iface, ULONG *iid_count, IID **iids )
+{
+    FIXME( "iface %p, iid_count %p, iids %p stub!\n", iface, iid_count, iids );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI iterator_GetRuntimeClassName( IIterator_IInspectable *iface, HSTRING *class_name )
+{
+    FIXME( "iface %p, class_name %p stub!\n", iface, class_name );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI iterator_GetTrustLevel( IIterator_IInspectable *iface, TrustLevel *trust_level )
+{
+    FIXME( "iface %p, trust_level %p stub!\n", iface, trust_level );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI iterator_get_Current( IIterator_IInspectable *iface, IInspectable **value )
+{
+    struct iterator *impl = impl_from_IIterator_IInspectable( iface );
+    TRACE( "iface %p, value %p.\n", iface, value );
+    return IVectorView_IInspectable_GetAt( impl->view, impl->index, value );
+}
+
+static HRESULT WINAPI iterator_get_HasCurrent( IIterator_IInspectable *iface, boolean *value )
+{
+    struct iterator *impl = impl_from_IIterator_IInspectable( iface );
+
+    TRACE( "iface %p, value %p.\n", iface, value );
+
+    *value = impl->index < impl->size;
+    return S_OK;
+}
+
+static HRESULT WINAPI iterator_MoveNext( IIterator_IInspectable *iface, boolean *value )
+{
+    struct iterator *impl = impl_from_IIterator_IInspectable( iface );
+
+    TRACE( "iface %p, value %p.\n", iface, value );
+
+    if (impl->index < impl->size) impl->index++;
+    return IIterator_IInspectable_get_HasCurrent( iface, value );
+}
+
+static HRESULT WINAPI iterator_GetMany( IIterator_IInspectable *iface, UINT32 items_size,
+                                        IInspectable **items, UINT *count )
+{
+    struct iterator *impl = impl_from_IIterator_IInspectable( iface );
+    TRACE( "iface %p, items_size %u, items %p, count %p.\n", iface, items_size, items, count );
+    return IVectorView_IInspectable_GetMany( impl->view, impl->index, items_size, items, count );
+}
+
+static const IIterator_IInspectableVtbl iterator_vtbl =
+{
+    iterator_QueryInterface,
+    iterator_AddRef,
+    iterator_Release,
+    /* IInspectable methods */
+    iterator_GetIids,
+    iterator_GetRuntimeClassName,
+    iterator_GetTrustLevel,
+    /* IIterator<IInspectable*> methods */
+    iterator_get_Current,
+    iterator_get_HasCurrent,
+    iterator_MoveNext,
+    iterator_GetMany,
+};
+
+struct vector_view
+{
+    IVectorView_IInspectable IVectorView_IInspectable_iface;
+    IIterable_IInspectable IIterable_IInspectable_iface;
+    struct vector_iids iids;
+    LONG ref;
+
+    UINT32 size;
+    IInspectable *elements[1];
+};
+
+static inline struct vector_view *impl_from_IVectorView_IInspectable( IVectorView_IInspectable *iface )
+{
+    return CONTAINING_RECORD( iface, struct vector_view, IVectorView_IInspectable_iface );
+}
+
+static HRESULT WINAPI vector_view_QueryInterface( IVectorView_IInspectable *iface, REFIID iid, void **out )
+{
+    struct vector_view *impl = impl_from_IVectorView_IInspectable( iface );
+
+    TRACE( "iface %p, iid %s, out %p.\n", iface, debugstr_guid( iid ), out );
+
+    if (IsEqualGUID( iid, &IID_IUnknown ) ||
+        IsEqualGUID( iid, &IID_IInspectable ) ||
+        IsEqualGUID( iid, &IID_IAgileObject ) ||
+        IsEqualGUID( iid, impl->iids.view ))
+    {
+        IInspectable_AddRef( (*out = &impl->IVectorView_IInspectable_iface) );
+        return S_OK;
+    }
+
+    if (IsEqualGUID( iid, impl->iids.iterable ))
+    {
+        IInspectable_AddRef( (*out = &impl->IIterable_IInspectable_iface) );
+        return S_OK;
+    }
+
+    FIXME( "%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid( iid ) );
+    *out = NULL;
+    return E_NOINTERFACE;
+}
+
+static ULONG WINAPI vector_view_AddRef( IVectorView_IInspectable *iface )
+{
+    struct vector_view *impl = impl_from_IVectorView_IInspectable( iface );
+    ULONG ref = InterlockedIncrement( &impl->ref );
+    TRACE( "iface %p increasing refcount to %lu.\n", iface, ref );
+    return ref;
+}
+
+static ULONG WINAPI vector_view_Release( IVectorView_IInspectable *iface )
+{
+    struct vector_view *impl = impl_from_IVectorView_IInspectable( iface );
+    ULONG i, ref = InterlockedDecrement( &impl->ref );
+
+    TRACE( "iface %p decreasing refcount to %lu.\n", iface, ref );
+
+    if (!ref)
+    {
+        for (i = 0; i < impl->size; ++i) IInspectable_Release( impl->elements[i] );
+        free( impl );
+    }
+
+    return ref;
+}
+
+static HRESULT WINAPI vector_view_GetIids( IVectorView_IInspectable *iface, ULONG *iid_count, IID **iids )
+{
+    FIXME( "iface %p, iid_count %p, iids %p stub!\n", iface, iid_count, iids );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI vector_view_GetRuntimeClassName( IVectorView_IInspectable *iface, HSTRING *class_name )
+{
+    FIXME( "iface %p, class_name %p stub!\n", iface, class_name );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI vector_view_GetTrustLevel( IVectorView_IInspectable *iface, TrustLevel *trust_level )
+{
+    FIXME( "iface %p, trust_level %p stub!\n", iface, trust_level );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI vector_view_GetAt( IVectorView_IInspectable *iface, UINT32 index, IInspectable **value )
+{
+    struct vector_view *impl = impl_from_IVectorView_IInspectable( iface );
+
+    TRACE( "iface %p, index %u, value %p.\n", iface, index, value );
+
+    *value = NULL;
+    if (index >= impl->size) return E_BOUNDS;
+
+    IInspectable_AddRef( (*value = impl->elements[index]) );
+    return S_OK;
+}
+
+static HRESULT WINAPI vector_view_get_Size( IVectorView_IInspectable *iface, UINT32 *value )
+{
+    struct vector_view *impl = impl_from_IVectorView_IInspectable( iface );
+
+    TRACE( "iface %p, value %p.\n", iface, value );
+
+    *value = impl->size;
+    return S_OK;
+}
+
+static HRESULT WINAPI vector_view_IndexOf( IVectorView_IInspectable *iface, IInspectable *element,
+                                           UINT32 *index, BOOLEAN *found )
+{
+    struct vector_view *impl = impl_from_IVectorView_IInspectable( iface );
+    ULONG i;
+
+    TRACE( "iface %p, element %p, index %p, found %p.\n", iface, element, index, found );
+
+    for (i = 0; i < impl->size; ++i) if (impl->elements[i] == element) break;
+    if ((*found = (i < impl->size))) *index = i;
+    else *index = 0;
+
+    return S_OK;
+}
+
+static HRESULT WINAPI vector_view_GetMany( IVectorView_IInspectable *iface, UINT32 start_index,
+                                           UINT32 items_size, IInspectable **items, UINT *count )
+{
+    struct vector_view *impl = impl_from_IVectorView_IInspectable( iface );
+    UINT32 i;
+
+    TRACE( "iface %p, start_index %u, items_size %u, items %p, count %p.\n",
+           iface, start_index, items_size, items, count );
+
+    if (start_index >= impl->size) return E_BOUNDS;
+
+    for (i = start_index; i < impl->size; ++i)
+    {
+        if (i - start_index >= items_size) break;
+        IInspectable_AddRef( (items[i - start_index] = impl->elements[i]) );
+    }
+    *count = i - start_index;
+
+    return S_OK;
+}
+
+static const struct IVectorView_IInspectableVtbl vector_view_vtbl =
+{
+    vector_view_QueryInterface,
+    vector_view_AddRef,
+    vector_view_Release,
+    /* IInspectable methods */
+    vector_view_GetIids,
+    vector_view_GetRuntimeClassName,
+    vector_view_GetTrustLevel,
+    /* IVectorView<IInspectable*> methods */
+    vector_view_GetAt,
+    vector_view_get_Size,
+    vector_view_IndexOf,
+    vector_view_GetMany,
+};
+
+DEFINE_IINSPECTABLE_( iterable_view, IIterable_IInspectable, struct vector_view, view_impl_from_IIterable_IInspectable,
+                      IIterable_IInspectable_iface, &impl->IVectorView_IInspectable_iface )
+
+static HRESULT WINAPI iterable_view_First( IIterable_IInspectable *iface, IIterator_IInspectable **value )
+{
+    struct vector_view *impl = view_impl_from_IIterable_IInspectable( iface );
+    struct iterator *iter;
+
+    TRACE( "iface %p, value %p.\n", iface, value );
+
+    if (!(iter = calloc( 1, sizeof(struct iterator) ))) return E_OUTOFMEMORY;
+    iter->IIterator_IInspectable_iface.lpVtbl = &iterator_vtbl;
+    iter->iid = impl->iids.iterator;
+    iter->ref = 1;
+
+    IVectorView_IInspectable_AddRef( (iter->view = &impl->IVectorView_IInspectable_iface) );
+    iter->size = impl->size;
+
+    *value = &iter->IIterator_IInspectable_iface;
+    return S_OK;
+}
+
+static const struct IIterable_IInspectableVtbl iterable_view_vtbl =
+{
+    iterable_view_QueryInterface,
+    iterable_view_AddRef,
+    iterable_view_Release,
+    /* IInspectable methods */
+    iterable_view_GetIids,
+    iterable_view_GetRuntimeClassName,
+    iterable_view_GetTrustLevel,
+    /* IIterable<T> methods */
+    iterable_view_First,
+};
+
+struct vector
+{
+    IVector_IInspectable IVector_IInspectable_iface;
+    IIterable_IInspectable IIterable_IInspectable_iface;
+    struct vector_iids iids;
+    LONG ref;
+
+    UINT32 size;
+    UINT32 capacity;
+    IInspectable **elements;
+};
+
+static inline struct vector *impl_from_IVector_IInspectable( IVector_IInspectable *iface )
+{
+    return CONTAINING_RECORD( iface, struct vector, IVector_IInspectable_iface );
+}
+
+static HRESULT WINAPI vector_QueryInterface( IVector_IInspectable *iface, REFIID iid, void **out )
+{
+    struct vector *impl = impl_from_IVector_IInspectable( iface );
+
+    TRACE( "iface %p, iid %s, out %p.\n", iface, debugstr_guid( iid ), out );
+
+    if (IsEqualGUID( iid, &IID_IUnknown ) ||
+        IsEqualGUID( iid, &IID_IInspectable ) ||
+        IsEqualGUID( iid, &IID_IAgileObject ) ||
+        IsEqualGUID( iid, impl->iids.vector ))
+    {
+        IInspectable_AddRef( (*out = &impl->IVector_IInspectable_iface) );
+        return S_OK;
+    }
+
+    if (IsEqualGUID( iid, impl->iids.iterable ))
+    {
+        IInspectable_AddRef( (*out = &impl->IIterable_IInspectable_iface) );
+        return S_OK;
+    }
+
+    FIXME( "%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid( iid ) );
+    *out = NULL;
+    return E_NOINTERFACE;
+}
+
+static ULONG WINAPI vector_AddRef( IVector_IInspectable *iface )
+{
+    struct vector *impl = impl_from_IVector_IInspectable( iface );
+    ULONG ref = InterlockedIncrement( &impl->ref );
+    TRACE( "iface %p increasing refcount to %lu.\n", iface, ref );
+    return ref;
+}
+
+static ULONG WINAPI vector_Release( IVector_IInspectable *iface )
+{
+    struct vector *impl = impl_from_IVector_IInspectable( iface );
+    ULONG ref = InterlockedDecrement( &impl->ref );
+
+    TRACE( "iface %p decreasing refcount to %lu.\n", iface, ref );
+
+    if (!ref)
+    {
+        IVector_IInspectable_Clear( iface );
+        free( impl );
+    }
+
+    return ref;
+}
+
+static HRESULT WINAPI vector_GetIids( IVector_IInspectable *iface, ULONG *iid_count, IID **iids )
+{
+    FIXME( "iface %p, iid_count %p, iids %p stub!\n", iface, iid_count, iids );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI vector_GetRuntimeClassName( IVector_IInspectable *iface, HSTRING *class_name )
+{
+    FIXME( "iface %p, class_name %p stub!\n", iface, class_name );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI vector_GetTrustLevel( IVector_IInspectable *iface, TrustLevel *trust_level )
+{
+    FIXME( "iface %p, trust_level %p stub!\n", iface, trust_level );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI vector_GetAt( IVector_IInspectable *iface, UINT32 index, IInspectable **value )
+{
+    struct vector *impl = impl_from_IVector_IInspectable( iface );
+
+    TRACE( "iface %p, index %u, value %p.\n", iface, index, value );
+
+    *value = NULL;
+    if (index >= impl->size) return E_BOUNDS;
+
+    IInspectable_AddRef( (*value = impl->elements[index]) );
+    return S_OK;
+}
+
+static HRESULT WINAPI vector_get_Size( IVector_IInspectable *iface, UINT32 *value )
+{
+    struct vector *impl = impl_from_IVector_IInspectable( iface );
+    TRACE( "iface %p, value %p.\n", iface, value );
+    *value = impl->size;
+    return S_OK;
+}
+
+static HRESULT WINAPI vector_GetView( IVector_IInspectable *iface, IVectorView_IInspectable **value )
+{
+    struct vector *impl = impl_from_IVector_IInspectable( iface );
+    struct vector_view *view;
+    ULONG i;
+
+    TRACE( "iface %p, value %p.\n", iface, value );
+
+    if (!(view = calloc( 1, offsetof( struct vector_view, elements[impl->size] ) ))) return E_OUTOFMEMORY;
+    view->IVectorView_IInspectable_iface.lpVtbl = &vector_view_vtbl;
+    view->IIterable_IInspectable_iface.lpVtbl = &iterable_view_vtbl;
+    view->iids = impl->iids;
+    view->ref = 1;
+
+    for (i = 0; i < impl->size; ++i) IInspectable_AddRef( (view->elements[view->size++] = impl->elements[i]) );
+
+    *value = &view->IVectorView_IInspectable_iface;
+    return S_OK;
+}
+
+static HRESULT WINAPI vector_IndexOf( IVector_IInspectable *iface, IInspectable *element, UINT32 *index, BOOLEAN *found )
+{
+    struct vector *impl = impl_from_IVector_IInspectable( iface );
+    ULONG i;
+
+    TRACE( "iface %p, element %p, index %p, found %p.\n", iface, element, index, found );
+
+    for (i = 0; i < impl->size; ++i) if (impl->elements[i] == element) break;
+    if ((*found = (i < impl->size))) *index = i;
+    else *index = 0;
+
+    return S_OK;
+}
+
+static HRESULT WINAPI vector_SetAt( IVector_IInspectable *iface, UINT32 index, IInspectable *value )
+{
+    struct vector *impl = impl_from_IVector_IInspectable( iface );
+
+    TRACE( "iface %p, index %u, value %p.\n", iface, index, value );
+
+    if (index >= impl->size) return E_BOUNDS;
+    IInspectable_Release( impl->elements[index] );
+    IInspectable_AddRef( (impl->elements[index] = value) );
+    return S_OK;
+}
+
+static HRESULT WINAPI vector_InsertAt( IVector_IInspectable *iface, UINT32 index, IInspectable *value )
+{
+    struct vector *impl = impl_from_IVector_IInspectable( iface );
+    IInspectable **tmp = impl->elements;
+
+    TRACE( "iface %p, index %u, value %p.\n", iface, index, value );
+
+    if (impl->size == impl->capacity)
+    {
+        impl->capacity = max( 32, impl->capacity * 3 / 2 );
+        if (!(impl->elements = realloc( impl->elements, impl->capacity * sizeof(*impl->elements) )))
+        {
+            impl->elements = tmp;
+            return E_OUTOFMEMORY;
+        }
+    }
+
+    memmove( impl->elements + index + 1, impl->elements + index, (impl->size++ - index) * sizeof(*impl->elements) );
+    IInspectable_AddRef( (impl->elements[index] = value) );
+    return S_OK;
+}
+
+static HRESULT WINAPI vector_RemoveAt( IVector_IInspectable *iface, UINT32 index )
+{
+    struct vector *impl = impl_from_IVector_IInspectable( iface );
+
+    TRACE( "iface %p, index %u.\n", iface, index );
+
+    if (index >= impl->size) return E_BOUNDS;
+    IInspectable_Release( impl->elements[index] );
+    memmove( impl->elements + index, impl->elements + index + 1, (--impl->size - index) * sizeof(*impl->elements) );
+    return S_OK;
+}
+
+static HRESULT WINAPI vector_Append( IVector_IInspectable *iface, IInspectable *value )
+{
+    struct vector *impl = impl_from_IVector_IInspectable( iface );
+
+    TRACE( "iface %p, value %p.\n", iface, value );
+
+    return IVector_IInspectable_InsertAt( iface, impl->size, value );
+}
+
+static HRESULT WINAPI vector_RemoveAtEnd( IVector_IInspectable *iface )
+{
+    struct vector *impl = impl_from_IVector_IInspectable( iface );
+
+    TRACE( "iface %p.\n", iface );
+
+    if (impl->size) IInspectable_Release( impl->elements[--impl->size] );
+    return S_OK;
+}
+
+static HRESULT WINAPI vector_Clear( IVector_IInspectable *iface )
+{
+    struct vector *impl = impl_from_IVector_IInspectable( iface );
+
+    TRACE( "iface %p.\n", iface );
+
+    while (impl->size) IVector_IInspectable_RemoveAtEnd( iface );
+    free( impl->elements );
+    impl->capacity = 0;
+    impl->elements = NULL;
+
+    return S_OK;
+}
+
+static HRESULT WINAPI vector_GetMany( IVector_IInspectable *iface, UINT32 start_index,
+                                      UINT32 items_size, IInspectable **items, UINT *count )
+{
+    struct vector *impl = impl_from_IVector_IInspectable( iface );
+    UINT32 i;
+
+    TRACE( "iface %p, start_index %u, items_size %u, items %p, count %p.\n",
+           iface, start_index, items_size, items, count );
+
+    if (start_index >= impl->size) return E_BOUNDS;
+
+    for (i = start_index; i < impl->size; ++i)
+    {
+        if (i - start_index >= items_size) break;
+        IInspectable_AddRef( (items[i - start_index] = impl->elements[i]) );
+    }
+    *count = i - start_index;
+
+    return S_OK;
+}
+
+static HRESULT WINAPI vector_ReplaceAll( IVector_IInspectable *iface, UINT32 count, IInspectable **items )
+{
+    HRESULT hr;
+    ULONG i;
+
+    TRACE( "iface %p, count %u, items %p.\n", iface, count, items );
+
+    hr = IVector_IInspectable_Clear( iface );
+    for (i = 0; i < count && SUCCEEDED(hr); ++i) hr = IVector_IInspectable_Append( iface, items[i] );
+    return hr;
+}
+
+static const struct IVector_IInspectableVtbl vector_vtbl =
+{
+    vector_QueryInterface,
+    vector_AddRef,
+    vector_Release,
+    /* IInspectable methods */
+    vector_GetIids,
+    vector_GetRuntimeClassName,
+    vector_GetTrustLevel,
+    /* IVector<IInspectable*> methods */
+    vector_GetAt,
+    vector_get_Size,
+    vector_GetView,
+    vector_IndexOf,
+    vector_SetAt,
+    vector_InsertAt,
+    vector_RemoveAt,
+    vector_Append,
+    vector_RemoveAtEnd,
+    vector_Clear,
+    vector_GetMany,
+    vector_ReplaceAll,
+};
+
+DEFINE_IINSPECTABLE( iterable, IIterable_IInspectable, struct vector, IVector_IInspectable_iface )
+
+static HRESULT WINAPI iterable_First( IIterable_IInspectable *iface, IIterator_IInspectable **value )
+{
+    struct vector *impl = impl_from_IIterable_IInspectable( iface );
+    IIterable_IInspectable *iterable;
+    IVectorView_IInspectable *view;
+    HRESULT hr;
+
+    TRACE( "iface %p, value %p.\n", iface, value );
+
+    if (FAILED(hr = IVector_IInspectable_GetView( &impl->IVector_IInspectable_iface, &view ))) return hr;
+
+    hr = IVectorView_IInspectable_QueryInterface( view, impl->iids.iterable, (void **)&iterable );
+    IVectorView_IInspectable_Release( view );
+    if (FAILED(hr)) return hr;
+
+    hr = IIterable_IInspectable_First( iterable, value );
+    IIterable_IInspectable_Release( iterable );
+    return hr;
+}
+
+static const struct IIterable_IInspectableVtbl iterable_vtbl =
+{
+    iterable_QueryInterface,
+    iterable_AddRef,
+    iterable_Release,
+    /* IInspectable methods */
+    iterable_GetIids,
+    iterable_GetRuntimeClassName,
+    iterable_GetTrustLevel,
+    /* IIterable<T> methods */
+    iterable_First,
+};
+
+HRESULT vector_create( const struct vector_iids *iids, void **out )
+{
+    struct vector *impl;
+
+    TRACE( "iid %s, out %p.\n", debugstr_guid( iids->vector ), out );
+
+    if (!(impl = calloc( 1, sizeof(*impl) ))) return E_OUTOFMEMORY;
+    impl->IVector_IInspectable_iface.lpVtbl = &vector_vtbl;
+    impl->IIterable_IInspectable_iface.lpVtbl = &iterable_vtbl;
+    impl->iids = *iids;
+    impl->ref = 1;
+
+    *out = &impl->IVector_IInspectable_iface;
+    TRACE( "created %p\n", *out );
+    return S_OK;
+}

[PATCH 3/4] windows.devices.enumeration: Add a stubbed IDeviceInformation implementation for device interfaces.

[Vibhav Pant]

From: Vibhav Pant

---
 dlls/windows.devices.enumeration/Makefile.in  |   1 +
 .../windows.devices.enumeration/information.c | 186 ++++++++++++++++++
 dlls/windows.devices.enumeration/main.c       |  14 +-
 dlls/windows.devices.enumeration/private.h    |   2 +
 .../tests/devices.c                           |   2 +-
 5 files changed, 201 insertions(+), 4 deletions(-)
 create mode 100644 dlls/windows.devices.enumeration/information.c

diff --git a/dlls/windows.devices.enumeration/Makefile.in b/dlls/windows.devices.enumeration/Makefile.in
index 68110328964..dc4c60a05e7 100644
--- a/dlls/windows.devices.enumeration/Makefile.in
+++ b/dlls/windows.devices.enumeration/Makefile.in
@@ -7,5 +7,6 @@ SOURCES = \
    async.idl \
    classes.idl \
    event_handlers.c \
+	information.c \
    main.c \
    vector.c
diff --git a/dlls/windows.devices.enumeration/information.c b/dlls/windows.devices.enumeration/information.c
new file mode 100644
index 00000000000..d65d63795bb
--- /dev/null
+++ b/dlls/windows.devices.enumeration/information.c
@@ -0,0 +1,186 @@
+/* DeviceInformation implementation.
+ *
+ * Copyright 2025 Vibhav Pant
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include "private.h"
+
+#include <roapi.h>
+
+#include <wine/debug.h>
+#include <wine/rbtree.h>
+
+WINE_DEFAULT_DEBUG_CHANNEL(enumeration);
+
+struct device_information
+{
+    IDeviceInformation IDeviceInformation_iface;
+    LONG ref;
+};
+
+static inline struct device_information *impl_DeviceInterface_from_IDeviceInformation( IDeviceInformation *iface )
+{
+    return CONTAINING_RECORD( iface, struct device_information, IDeviceInformation_iface );
+}
+
+static HRESULT WINAPI device_information_QueryInterface( IDeviceInformation *iface, REFIID iid, void **out )
+{
+    TRACE( "iface %p, iid %s, out %p\n", iface, debugstr_guid( iid ), out );
+
+    if (IsEqualGUID( iid, &IID_IUnknown ) ||
+        IsEqualGUID( iid, &IID_IInspectable ) ||
+        IsEqualGUID( iid, &IID_IAgileObject ) ||
+        IsEqualGUID( iid, &IID_IDeviceInformation ))
+    {
+        IUnknown_AddRef( iface );
+        *out = iface;
+        return S_OK;
+    }
+
+    FIXME( "%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid( iid ) );
+    *out = NULL;
+    return E_NOINTERFACE;
+}
+
+static ULONG WINAPI device_information_AddRef( IDeviceInformation *iface )
+{
+    struct device_information *impl = impl_DeviceInterface_from_IDeviceInformation( iface );
+    ULONG ref = InterlockedIncrement( &impl->ref );
+    TRACE( "iface %p, ref %lu.\n", iface, ref );
+    return ref;
+}
+
+static ULONG WINAPI device_information_Release( IDeviceInformation *iface )
+{
+    struct device_information *impl = impl_DeviceInterface_from_IDeviceInformation( iface );
+    ULONG ref = InterlockedDecrement( &impl->ref );
+    TRACE( "iface %p, ref %lu.\n", iface, ref );
+
+    if (!ref) free( impl );
+    return ref;
+}
+
+static HRESULT WINAPI device_information_GetIids( IDeviceInformation *iface, ULONG *iid_count, IID **iids )
+{
+    FIXME( "iface %p, iid_count %p, iids %p stub!\n", iface, iid_count, iids );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI device_information_GetRuntimeClassName( IDeviceInformation *iface, HSTRING *class_name )
+{
+    const static WCHAR *name = RuntimeClass_Windows_Devices_Enumeration_DeviceInformation;
+    TRACE( "iface %p, class_name %p\n", iface, class_name );
+    return WindowsCreateString( name, wcslen( name ), class_name );
+}
+
+static HRESULT WINAPI device_information_GetTrustLevel( IDeviceInformation *iface, TrustLevel *trust_level )
+{
+    FIXME( "iface %p, trust_level %p stub!\n", iface, trust_level );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI device_information_get_Id( IDeviceInformation *iface, HSTRING *id )
+{
+    FIXME( "iface %p, id %p stub!\n", iface, id );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI device_information_get_Name( IDeviceInformation *iface, HSTRING *name )
+{
+    FIXME( "iface %p, name %p stub!\n", iface, name );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI device_information_get_IsEnabled( IDeviceInformation *iface, boolean *value )
+{
+    FIXME( "iface %p, value %p stub!\n", iface, value );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI device_information_IsDefault( IDeviceInformation *iface, boolean *value )
+{
+    FIXME( "iface %p, value %p stub!\n", iface, value );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI device_information_get_EnclosureLocation( IDeviceInformation *iface, IEnclosureLocation **location )
+{
+    FIXME( "iface %p, location %p stub!\n", iface, location );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI device_information_get_Properties( IDeviceInformation *iface, IMapView_HSTRING_IInspectable **properties )
+{
+    FIXME( "iface %p, properties %p stub!\n", iface, properties );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI device_information_Update( IDeviceInformation *iface, IDeviceInformationUpdate *update )
+{
+    FIXME( "iface %p, update %p stub!\n", iface, update );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI device_information_GetThumbnailAsync( IDeviceInformation *iface, IAsyncOperation_DeviceThumbnail **async )
+{
+    FIXME( "iface %p, async %p stub!\n", iface, async );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI device_information_GetGlyphThumbnailAsync( IDeviceInformation *iface,
+                                                                 IAsyncOperation_DeviceThumbnail **async )
+{
+    FIXME( "iface %p, async %p stub!\n", iface, async );
+    return E_NOTIMPL;
+}
+
+static const struct IDeviceInformationVtbl device_information_vtbl =
+{
+    /* IUnknown */
+    device_information_QueryInterface,
+    device_information_AddRef,
+    device_information_Release,
+    /* IInspectable */
+    device_information_GetIids,
+    device_information_GetRuntimeClassName,
+    device_information_GetTrustLevel,
+    /* IDeviceInformation */
+    device_information_get_Id,
+    device_information_get_Name,
+    device_information_get_IsEnabled,
+    device_information_IsDefault,
+    device_information_get_EnclosureLocation,
+    device_information_get_Properties,
+    device_information_Update,
+    device_information_GetThumbnailAsync,
+    device_information_GetGlyphThumbnailAsync,
+};
+
+HRESULT device_information_create( IDeviceInformation **info )
+{
+    struct device_information *impl;
+
+    TRACE( "info %p\n", info );
+
+    if (!(impl = calloc( 1, sizeof(*impl) ))) return E_OUTOFMEMORY;
+    impl->IDeviceInformation_iface.lpVtbl = &device_information_vtbl;
+    impl->ref = 1;
+
+    *info = &impl->IDeviceInformation_iface;
+    TRACE( "created DeviceInformation %p\n", impl );
+    return S_OK;
+}
diff --git a/dlls/windows.devices.enumeration/main.c b/dlls/windows.devices.enumeration/main.c
index 48c49a50125..9d36147a974 100644
--- a/dlls/windows.devices.enumeration/main.c
+++ b/dlls/windows.devices.enumeration/main.c
@@ -342,14 +342,22 @@ static HRESULT WINAPI find_all_async( IUnknown *invoker, IUnknown *param, PROPVA
         .iterable = &IID_IIterable_DeviceInformation,
         .iterator = &IID_IIterator_DeviceInformation,
     };
-    HRESULT hr;
-    IVector_IInspectable *vector;
     IVectorView_DeviceInformation *view;
+    IDeviceInformation *device;
+    IVector_IInspectable *vector;
+    HRESULT hr;

FIXME( "invoker %p, param %p, result %p semi-stub!\n", invoker, param, result );

if (FAILED(hr = vector_create( &iids, (void *)&vector ))) return hr;
-    hr = IVector_IInspectable_GetView( vector, (void *)&view );
+
+    if (SUCCEEDED(hr = device_information_create( &device )))
+    {
+        hr = IVector_IInspectable_Append( vector, (IInspectable *)device );
+        IDeviceInformation_Release( device );
+    }
+
+    if (SUCCEEDED(hr)) hr = IVector_IInspectable_GetView( vector, (void *)&view );
     IVector_IInspectable_Release( vector );
     if (FAILED(hr)) return hr;

diff --git a/dlls/windows.devices.enumeration/private.h b/dlls/windows.devices.enumeration/private.h
index 4063b0465f5..f0fa09a923a 100644
--- a/dlls/windows.devices.enumeration/private.h
+++ b/dlls/windows.devices.enumeration/private.h
@@ -58,6 +58,8 @@ typedef HRESULT (WINAPI *async_operation_callback)( IUnknown *invoker, IUnknown
 extern HRESULT async_operation_device_info_collection_result_create( IUnknown *invoker, IUnknown *param, async_operation_callback callback,
                                                                      IAsyncOperation_DeviceInformationCollection **out );
 extern HRESULT vector_create( const struct vector_iids *iids, void **out );
+extern HRESULT device_information_create( IDeviceInformation **info );
+
 #define DEFINE_IINSPECTABLE_( pfx, iface_type, impl_type, impl_from, iface_mem, expr )             \
     static inline impl_type *impl_from( iface_type *iface )                                        \
     {                                                                                              \
diff --git a/dlls/windows.devices.enumeration/tests/devices.c b/dlls/windows.devices.enumeration/tests/devices.c
index a6c0ce0fe03..6617f71a611 100644
--- a/dlls/windows.devices.enumeration/tests/devices.c
+++ b/dlls/windows.devices.enumeration/tests/devices.c
@@ -302,7 +302,7 @@ static void test_DeviceInformation_obj( int line, IDeviceInformation *info )
     boolean bool_val;

hr = IDeviceInformation_get_Id( info, &str );
-    ok_(__FILE__, line)( hr == S_OK, "got hr %#lx\n", hr );
+    todo_wine ok_(__FILE__, line)( hr == S_OK, "got hr %#lx\n", hr );
     WindowsDeleteString( str );
     str = NULL;
     hr = IDeviceInformation_get_Name( info, &str );

[PATCH 4/4] windows.devices.enumeration: Create IDeviceInformation objects from all present device interfaces.

[Vibhav Pant]

From: Vibhav Pant

---
 dlls/windows.devices.enumeration/Makefile.in  |  2 +-
 .../windows.devices.enumeration/information.c | 31 +++++++----
 dlls/windows.devices.enumeration/main.c       | 51 +++++++++++++++++--
 dlls/windows.devices.enumeration/private.h    |  2 +-
 .../tests/devices.c                           |  2 +-
 5 files changed, 71 insertions(+), 17 deletions(-)

diff --git a/dlls/windows.devices.enumeration/Makefile.in b/dlls/windows.devices.enumeration/Makefile.in
index dc4c60a05e7..1d3bf5a69a3 100644
--- a/dlls/windows.devices.enumeration/Makefile.in
+++ b/dlls/windows.devices.enumeration/Makefile.in
@@ -1,5 +1,5 @@
 MODULE = windows.devices.enumeration.dll
-IMPORTS = combase uuid
+IMPORTS = advapi32 combase setupapi uuid

SOURCES = \
    access.c \
diff --git a/dlls/windows.devices.enumeration/information.c b/dlls/windows.devices.enumeration/information.c
index d65d63795bb..c09a9ea37ef 100644
--- a/dlls/windows.devices.enumeration/information.c
+++ b/dlls/windows.devices.enumeration/information.c
@@ -19,10 +19,7 @@

#include "private.h"

-#include <roapi.h>
-
-#include <wine/debug.h>
-#include <wine/rbtree.h>
+#include "wine/debug.h"

WINE_DEFAULT_DEBUG_CHANNEL(enumeration);

@@ -30,6 +27,8 @@ struct device_information
 {
     IDeviceInformation IDeviceInformation_iface;
     LONG ref;
+
+    HSTRING path;
 };

static inline struct device_information *impl_DeviceInterface_from_IDeviceInformation( IDeviceInformation *iface )
@@ -68,9 +67,15 @@ static ULONG WINAPI device_information_Release( IDeviceInformation *iface )
 {
     struct device_information *impl = impl_DeviceInterface_from_IDeviceInformation( iface );
     ULONG ref = InterlockedDecrement( &impl->ref );
+
     TRACE( "iface %p, ref %lu.\n", iface, ref );

-    if (!ref) free( impl );
+    if (!ref)
+    {
+        WindowsDeleteString( impl->path );
+        free( impl );
+    }
+
     return ref;
 }

@@ -95,8 +100,9 @@ static HRESULT WINAPI device_information_GetTrustLevel( IDeviceInformation *ifac

static HRESULT WINAPI device_information_get_Id( IDeviceInformation *iface, HSTRING *id )
 {
-    FIXME( "iface %p, id %p stub!\n", iface, id );
-    return E_NOTIMPL;
+    struct device_information *impl = impl_DeviceInterface_from_IDeviceInformation( iface );
+    TRACE( "iface %p, id %p\n", iface, id );
+    return WindowsDuplicateString( impl->path, id );
 }

static HRESULT WINAPI device_information_get_Name( IDeviceInformation *iface, HSTRING *name )
@@ -170,16 +176,23 @@ static const struct IDeviceInformationVtbl device_information_vtbl =
     device_information_GetGlyphThumbnailAsync,
 };

-HRESULT device_information_create( IDeviceInformation **info )
+HRESULT device_information_create( const WCHAR *path, IDeviceInformation **info )
 {
     struct device_information *impl;
+    HRESULT hr;

-    TRACE( "info %p\n", info );
+    TRACE( "path %s, info %p\n", debugstr_w(path), info );

if (!(impl = calloc( 1, sizeof(*impl) ))) return E_OUTOFMEMORY;
     impl->IDeviceInformation_iface.lpVtbl = &device_information_vtbl;
     impl->ref = 1;

+    if (FAILED(hr = WindowsCreateString( path, wcslen( path ), &impl->path )))
+    {
+        free( impl );
+        return hr;
+    }
+
     *info = &impl->IDeviceInformation_iface;
     TRACE( "created DeviceInformation %p\n", impl );
     return S_OK;
diff --git a/dlls/windows.devices.enumeration/main.c b/dlls/windows.devices.enumeration/main.c
index 9d36147a974..ba7edaa5199 100644
--- a/dlls/windows.devices.enumeration/main.c
+++ b/dlls/windows.devices.enumeration/main.c
@@ -20,6 +20,7 @@

#include "initguid.h"
 #include "private.h"
+#include "setupapi.h"

#include "wine/debug.h"

@@ -343,20 +344,60 @@ static HRESULT WINAPI find_all_async( IUnknown *invoker, IUnknown *param, PROPVA
         .iterator = &IID_IIterator_DeviceInformation,
     };
     IVectorView_DeviceInformation *view;
-    IDeviceInformation *device;
     IVector_IInspectable *vector;
+    HKEY iface_key;
     HRESULT hr;
+    DWORD i;

-    FIXME( "invoker %p, param %p, result %p semi-stub!\n", invoker, param, result );
+    TRACE( "invoker %p, param %p, result %p\n", invoker, param, result );

if (FAILED(hr = vector_create( &iids, (void *)&vector ))) return hr;

-    if (SUCCEEDED(hr = device_information_create( &device )))
+    if (!(iface_key = SetupDiOpenClassRegKeyExW( NULL, KEY_ENUMERATE_SUB_KEYS, DIOCR_INTERFACE, NULL, NULL )))
     {
-        hr = IVector_IInspectable_Append( vector, (IInspectable *)device );
-        IDeviceInformation_Release( device );
+        IVector_IInspectable_Release( vector );
+        return HRESULT_FROM_WIN32( GetLastError() );
     }

+    for (i = 0; SUCCEEDED(hr); i++)
+    {
+        char buffer[sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_W) + MAX_PATH * sizeof(WCHAR)];
+        SP_DEVICE_INTERFACE_DETAIL_DATA_W *detail = (void *)buffer;
+        SP_DEVICE_INTERFACE_DATA iface = {.cbSize = sizeof(iface)};
+        HDEVINFO set = INVALID_HANDLE_VALUE;
+        GUID iface_class;
+        WCHAR name[40];
+        DWORD j, len;
+        LSTATUS ret;
+
+        len = ARRAY_SIZE(name);
+        ret = RegEnumKeyExW( iface_key, i, name, &len, NULL, NULL, NULL, NULL );
+        if (ret == ERROR_NO_MORE_ITEMS) break;
+        if (ret) hr = HRESULT_FROM_WIN32( ret );
+
+        if (SUCCEEDED(hr) && SUCCEEDED(hr = CLSIDFromString( name, &iface_class )))
+        {
+            set = SetupDiGetClassDevsW( &iface_class, NULL, NULL, DIGCF_DEVICEINTERFACE );
+            if (set == INVALID_HANDLE_VALUE) hr = HRESULT_FROM_WIN32( GetLastError() );
+        }
+
+        for (j = 0; SUCCEEDED(hr) && SetupDiEnumDeviceInterfaces( set, NULL, &iface_class, j, &iface ); j++)
+        {
+            IDeviceInformation *info;
+
+            detail->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_W);
+            if (!SetupDiGetDeviceInterfaceDetailW( set, &iface, detail, sizeof(buffer), NULL, NULL )) continue;
+
+            if (SUCCEEDED(hr = device_information_create( detail->DevicePath, &info )))
+            {
+                hr = IVector_IInspectable_Append( vector, (IInspectable *)info );
+                IDeviceInformation_Release( info );
+            }
+        }
+    }
+
+    RegCloseKey( iface_key );
+
     if (SUCCEEDED(hr)) hr = IVector_IInspectable_GetView( vector, (void *)&view );
     IVector_IInspectable_Release( vector );
     if (FAILED(hr)) return hr;
diff --git a/dlls/windows.devices.enumeration/private.h b/dlls/windows.devices.enumeration/private.h
index f0fa09a923a..f9a866d5f59 100644
--- a/dlls/windows.devices.enumeration/private.h
+++ b/dlls/windows.devices.enumeration/private.h
@@ -58,7 +58,7 @@ typedef HRESULT (WINAPI *async_operation_callback)( IUnknown *invoker, IUnknown
 extern HRESULT async_operation_device_info_collection_result_create( IUnknown *invoker, IUnknown *param, async_operation_callback callback,
                                                                      IAsyncOperation_DeviceInformationCollection **out );
 extern HRESULT vector_create( const struct vector_iids *iids, void **out );
-extern HRESULT device_information_create( IDeviceInformation **info );
+extern HRESULT device_information_create( const WCHAR *path, IDeviceInformation **info );

#define DEFINE_IINSPECTABLE_( pfx, iface_type, impl_type, impl_from, iface_mem, expr )             \
     static inline impl_type *impl_from( iface_type *iface )                                        \
diff --git a/dlls/windows.devices.enumeration/tests/devices.c b/dlls/windows.devices.enumeration/tests/devices.c
index 6617f71a611..a6c0ce0fe03 100644
--- a/dlls/windows.devices.enumeration/tests/devices.c
+++ b/dlls/windows.devices.enumeration/tests/devices.c
@@ -302,7 +302,7 @@ static void test_DeviceInformation_obj( int line, IDeviceInformation *info )
     boolean bool_val;

hr = IDeviceInformation_get_Id( info, &str );
-    todo_wine ok_(__FILE__, line)( hr == S_OK, "got hr %#lx\n", hr );
+    ok_(__FILE__, line)( hr == S_OK, "got hr %#lx\n", hr );
     WindowsDeleteString( str );
     str = NULL;
     hr = IDeviceInformation_get_Name( info, &str );

[PATCH 0/4] MR7974: windows.devices.enumeration: Add a basic implementation for DeviceInformationStatics::FindAllAsync(). - approved

[Rémi Bernon (＠rbernon)]

This merge request was approved by Rémi Bernon.

[Vibhav Pant (＠vibhavp)]

Thank you!

[PATCH 0/4] MR7974: windows.devices.enumeration: Add a basic implementation for DeviceInformationStatics::FindAllAsync(). - approved

[Vibhav Pant (＠vibhavp)]

This merge request was approved by Vibhav Pant.