[PATCH v5 0/4] MR6874: windows.devices.enumeration: Add a basic implementation for DeviceInformationStatics::FindAllAsync().
The basic `FindAllAsync()` method returns a collection of `DeviceInformation` objects representing all device interfaces on the system. This MR adds a basic implementation of this method, and the associated `IDeviceInformation` and `DeviceInformationCollection` objects it returns. For `IDeviceInformation`, this MR only implements the `Id()` method, which returns the symbolic link for the registered interface. A basic working `DeviceInformation` and `FindAll` implementations are needed to implement `DeviceWatcher`'s `Added`, `Removed` events, which in turn is required for basic device discovery in `Windows.Devices.Bluetooth`. -- v5: windows.devices.enumeration: Create IDeviceInformation objects from all present device interfaces. windows.devices.enumeration: Add a stubbed IDeviceInformation implementation for device interfaces. windows.devices.enumeration: Add a stubbed implementation for FindAllAsync() and DeviceInformationCollection. windows.devices.enumeration/tests: Add conformance tests for FindAllAsync(). https://gitlab.winehq.org/wine/wine/-/merge_requests/6874
From: Vibhav Pant <vibhavp(a)gmail.com> --- .../tests/devices.c | 227 ++++++++++++++++++ 1 file changed, 227 insertions(+) diff --git a/dlls/windows.devices.enumeration/tests/devices.c b/dlls/windows.devices.enumeration/tests/devices.c index ae76e5d754a..e411a6b901f 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,199 @@ static void device_watcher_handler_create( struct device_watcher_handler *impl ) impl->ref = 1; } +struct deviceinformationcollection_async_handler +{ + IAsyncOperationCompletedHandler_DeviceInformationCollection iface; + + IAsyncOperation_DeviceInformationCollection *async; + AsyncStatus status; + BOOL invoked; + HANDLE event; + LONG ref; +}; + +static inline struct deviceinformationcollection_async_handler * +impl_from_IAsyncOperationCompletedHandler_DeviceInformationCollection( + IAsyncOperationCompletedHandler_DeviceInformationCollection *iface ) +{ + return CONTAINING_RECORD( iface, struct deviceinformationcollection_async_handler, iface ); +} + +static HRESULT WINAPI deviceinformationcollection_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 deviceinformationcollection_async_handler_AddRef( + IAsyncOperationCompletedHandler_DeviceInformationCollection *iface ) +{ + struct deviceinformationcollection_async_handler *impl; + impl = impl_from_IAsyncOperationCompletedHandler_DeviceInformationCollection( iface ); + return InterlockedIncrement( &impl->ref ); +} + +static ULONG WINAPI deviceinformationcollection_async_handler_Release( + IAsyncOperationCompletedHandler_DeviceInformationCollection *iface ) +{ + struct deviceinformationcollection_async_handler *impl; + ULONG ref; + + impl = impl_from_IAsyncOperationCompletedHandler_DeviceInformationCollection( iface ); + ref = InterlockedDecrement( &impl->ref ); + if (!ref) + free( impl ); + return ref; +} + +static HRESULT WINAPI deviceinformationcollection_async_handler_Invoke( + IAsyncOperationCompletedHandler_DeviceInformationCollection *iface, + IAsyncOperation_DeviceInformationCollection *async, AsyncStatus status ) +{ + struct deviceinformationcollection_async_handler *impl; + + 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 deviceinformationcollection_async_handler_vtbl = +{ + /* IUnknown */ + deviceinformationcollection_async_handler_QueryInterface, + deviceinformationcollection_async_handler_AddRef, + deviceinformationcollection_async_handler_Release, + /* IAsyncOperationCompletedHandler<DeviceInformationCollection> */ + deviceinformationcollection_async_handler_Invoke, +}; + +static IAsyncOperationCompletedHandler_DeviceInformationCollection * +deviceinformationcollection_async_handler_create( HANDLE event ) +{ + struct deviceinformationcollection_async_handler *impl; + + impl = calloc( 1, sizeof( *impl ) ); + if (!impl) + return NULL; + impl->iface.lpVtbl = &deviceinformationcollection_async_handler_vtbl; + impl->event = event; + impl->ref = 1; + + return &impl->iface; +} + +#define await_deviceinformationcollection( a ) await_deviceinformationcollection_( __LINE__, ( a ) ) +static void await_deviceinformationcollection_( 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 = deviceinformationcollection_async_handler_create( event ); + ok_(__FILE__, line)( !!handler, "deviceinformationcollection_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_deviceinformationcollection_async( a, b, c, d, e ) check_deviceinformationcollection_async_( __LINE__, a, b, c, d, e ) +static void check_deviceinformationcollection_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 ); + trace_(__FILE__, line)( "id: %s\n", debugstr_hstring( str ) ); + WindowsDeleteString( str ); + str = NULL; + hr = IDeviceInformation_get_Name( info, &str ); + todo_wine ok_(__FILE__, line)( hr == S_OK, "got hr %#lx\n", hr ); + trace_(__FILE__, line)( " name: %s\n", debugstr_hstring( str ) ); + WindowsDeleteString( str ); + hr = IDeviceInformation_get_IsEnabled( info, &bool_val ); + todo_wine ok_(__FILE__, line)( hr == S_OK, "got hr %#lx\n", hr ); + trace_(__FILE__, line)( " enabled: %d\n", bool_val ); + hr = IDeviceInformation_get_IsDefault( info, &bool_val ); + todo_wine ok_(__FILE__, line)( hr == S_OK, "got hr %#lx\n", hr ); + trace_(__FILE__, line)( " default: %d\n", bool_val ); +} + static void test_DeviceInformation( void ) { static const WCHAR *device_info_name = L"Windows.Devices.Enumeration.DeviceInformation"; @@ -147,6 +341,8 @@ static void test_DeviceInformation( void ) IDeviceInformationStatics *device_info_statics; IDeviceWatcher *device_watcher; DeviceWatcherStatus status = 0xdeadbeef; + IAsyncOperation_DeviceInformationCollection *infocollection_async = NULL; + IVectorView_DeviceInformation *info_collection = NULL; ULONG ref; HSTRING str; HRESULT hr; @@ -273,6 +469,37 @@ 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, &infocollection_async ); + todo_wine ok( hr == S_OK, "got %#lx\n", hr ); + if (infocollection_async) + { + todo_wine await_deviceinformationcollection( infocollection_async ); + todo_wine check_deviceinformationcollection_async( infocollection_async, 1, Completed, S_OK, &info_collection ); + IAsyncOperation_DeviceInformationCollection_Release( infocollection_async ); + } + if (info_collection) + { + UINT32 idx = 0, size = 0; + + hr = IVectorView_DeviceInformation_get_Size( info_collection, &size ); + todo_wine ok( hr == S_OK, "got %#lx\n", hr ); + for (idx = 0; idx < size ;idx++) + { + IDeviceInformation *info; + winetest_push_context( "info_collection %u", idx ); + hr = IVectorView_DeviceInformation_GetAt( info_collection, idx, &info ); + ok( hr == S_OK, "got %#lx\n", hr ); + if (SUCCEEDED( hr )) + { + todo_wine 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 ); -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/6874
From: Vibhav Pant <vibhavp(a)gmail.com> --- dlls/windows.devices.enumeration/Makefile.in | 5 +- dlls/windows.devices.enumeration/async.c | 507 +++++++++++++ dlls/windows.devices.enumeration/async.idl | 44 ++ dlls/windows.devices.enumeration/collection.c | 675 ++++++++++++++++++ dlls/windows.devices.enumeration/main.c | 28 +- dlls/windows.devices.enumeration/private.h | 13 + .../tests/devices.c | 6 +- 7 files changed, 1272 insertions(+), 6 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/collection.c diff --git a/dlls/windows.devices.enumeration/Makefile.in b/dlls/windows.devices.enumeration/Makefile.in index 93c15dfcc64..e6c1ef8ddfe 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 \ + collection.c \ event_handlers.c \ - main.c + main.c \ diff --git a/dlls/windows.devices.enumeration/async.c b/dlls/windows.devices.enumeration/async.c new file mode 100644 index 00000000000..a172dccaffc --- /dev/null +++ b/dlls/windows.devices.enumeration/async.c @@ -0,0 +1,507 @@ +/* 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/collection.c b/dlls/windows.devices.enumeration/collection.c new file mode 100644 index 00000000000..5053b1c10bb --- /dev/null +++ b/dlls/windows.devices.enumeration/collection.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; +} diff --git a/dlls/windows.devices.enumeration/main.c b/dlls/windows.devices.enumeration/main.c index 5c930dba121..0e34fafe3af 100644 --- a/dlls/windows.devices.enumeration/main.c +++ b/dlls/windows.devices.enumeration/main.c @@ -333,11 +333,35 @@ static HRESULT WINAPI device_statics_CreateFromIdAsyncAdditionalProperties( IDev return E_NOTIMPL; } +static HRESULT WINAPI findall_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; + IVectorView_DeviceInformation *view; + + FIXME( "invoker %p, param %p, result %p semi-stub!\n", invoker, param, result ); + + hr = vector_create( &iids, (void *)&view ); + + if (SUCCEEDED( 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, findall_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..f9e4f571a97 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,11 @@ 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 e411a6b901f..e8b34e84ae3 100644 --- a/dlls/windows.devices.enumeration/tests/devices.c +++ b/dlls/windows.devices.enumeration/tests/devices.c @@ -471,11 +471,11 @@ static void test_DeviceInformation( void ) IDeviceWatcher_Release( device_watcher ); hr = IDeviceInformationStatics_FindAllAsync( device_info_statics, &infocollection_async ); - todo_wine ok( hr == S_OK, "got %#lx\n", hr ); + ok( hr == S_OK, "got %#lx\n", hr ); if (infocollection_async) { - todo_wine await_deviceinformationcollection( infocollection_async ); - todo_wine check_deviceinformationcollection_async( infocollection_async, 1, Completed, S_OK, &info_collection ); + await_deviceinformationcollection( infocollection_async ); + check_deviceinformationcollection_async( infocollection_async, 1, Completed, S_OK, &info_collection ); IAsyncOperation_DeviceInformationCollection_Release( infocollection_async ); } if (info_collection) -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/6874
From: Vibhav Pant <vibhavp(a)gmail.com> --- dlls/windows.devices.enumeration/Makefile.in | 1 + .../windows.devices.enumeration/information.c | 201 ++++++++++++++++++ dlls/windows.devices.enumeration/main.c | 31 ++- dlls/windows.devices.enumeration/private.h | 2 + .../tests/devices.c | 2 +- 5 files changed, 231 insertions(+), 6 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 e6c1ef8ddfe..062a914e322 100644 --- a/dlls/windows.devices.enumeration/Makefile.in +++ b/dlls/windows.devices.enumeration/Makefile.in @@ -8,4 +8,5 @@ SOURCES = \ classes.idl \ collection.c \ event_handlers.c \ + information.c \ main.c \ diff --git a/dlls/windows.devices.enumeration/information.c b/dlls/windows.devices.enumeration/information.c new file mode 100644 index 00000000000..afff96c9894 --- /dev/null +++ b/dlls/windows.devices.enumeration/information.c @@ -0,0 +1,201 @@ +/* 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); + +/* DeviceInformation implementation for objects with kind DeviceInformationKind_DeviceInterface. */ +struct devinfo_DeviceInterface +{ + IDeviceInformation IDeviceInformation_iface; + LONG ref; +}; + +static inline struct devinfo_DeviceInterface *impl_DeviceInterface_from_IDeviceInformation( IDeviceInformation *iface ) +{ + return CONTAINING_RECORD( iface, struct devinfo_DeviceInterface, IDeviceInformation_iface ); +} + +static HRESULT STDMETHODCALLTYPE devinfo_DeviceInterface_QueryInterface( IDeviceInformation *iface, REFIID iid, + void **out ) +{ + TRACE( "(%p, %s, %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 STDMETHODCALLTYPE devinfo_DeviceInterface_AddRef( IDeviceInformation *iface ) +{ + struct devinfo_DeviceInterface *impl; + + TRACE( "(%p)\n", iface ); + + impl = impl_DeviceInterface_from_IDeviceInformation( iface ); + return InterlockedIncrement( &impl->ref ); +} + +static ULONG STDMETHODCALLTYPE devinfo_DeviceInterface_Release( IDeviceInformation *iface ) +{ + struct devinfo_DeviceInterface *impl; + ULONG ref; + + TRACE( "(%p)\n", iface ); + + impl = impl_DeviceInterface_from_IDeviceInformation( iface ); + ref = InterlockedDecrement( &impl->ref ); + if (!ref) + free( impl ); + + return ref; +} + +static HRESULT STDMETHODCALLTYPE devinfo_DeviceInterface_GetIids( IDeviceInformation *iface, + ULONG *iid_count, IID **iids ) +{ + FIXME( "(%p, %p, %p) stub!\n", iface, iid_count, iids ); + return E_NOTIMPL; +} + +static HRESULT WINAPI devinfo_DeviceInterface_GetRuntimeClassName( IDeviceInformation *iface, HSTRING *class_name ) +{ + const static WCHAR *name = RuntimeClass_Windows_Devices_Enumeration_DeviceInformation; + + TRACE( "(%p, %p)\n", iface, class_name ); + + return WindowsCreateString( name, wcslen( name ), class_name ); +} + +static HRESULT STDMETHODCALLTYPE device_information_GetTrustLevel( + IDeviceInformation *iface, TrustLevel *trust_level) +{ + FIXME("(%p, %p) stub!\n", iface, trust_level); + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE devinfo_DeviceInterface_get_Id( IDeviceInformation *iface, HSTRING *id ) +{ + FIXME( "(%p, %p) stub!\n", iface, id ); + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE devinfo_DeviceInterface_get_Name( IDeviceInformation *iface, HSTRING *name ) +{ + FIXME( "(%p, %p) stub!\n", iface, name ); + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE devinfo_DeviceInterface_get_IsEnabled( IDeviceInformation *iface, boolean *value ) +{ + FIXME( "(%p, %p) stub!\n", iface, value ); + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE devinfo_DeviceInterface_IsDefault( IDeviceInformation *iface, boolean *value ) +{ + FIXME( "(%p, %p) stub!\n", iface, value ); + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE devinfo_DeviceInterface_get_EnclosureLocation( IDeviceInformation *iface, + IEnclosureLocation **location ) +{ + FIXME( "(%p, %p) stub!\n", iface, location ); + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE devinfo_DeviceInterface_get_Properties( IDeviceInformation *iface, + IMapView_HSTRING_IInspectable **properties ) +{ + FIXME( "(%p, %p) stub!\n", iface, properties ); + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE devinfo_DeviceInterface_Update( IDeviceInformation *iface, + IDeviceInformationUpdate *update ) +{ + FIXME( "(%p, %p) stub!\n", iface, update ); + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE devinfo_DeviceInterface_GetThumbnailAsync( IDeviceInformation *iface, + IAsyncOperation_DeviceThumbnail **async ) +{ + FIXME( "(%p, %p) stub!\n", iface, async ); + return E_NOTIMPL; +} + +static HRESULT STDMETHODCALLTYPE +devinfo_DeviceInterface_GetGlyphThumbnailAsync( IDeviceInformation *iface, IAsyncOperation_DeviceThumbnail **async ) +{ + FIXME( "(%p, %p) stub!\n", iface, async ); + return E_NOTIMPL; +} + +static const struct IDeviceInformationVtbl devinfo_DeviceInterface_vtbl = { + /* IUnknown */ + devinfo_DeviceInterface_QueryInterface, + devinfo_DeviceInterface_AddRef, + devinfo_DeviceInterface_Release, + /* IInspectable */ + devinfo_DeviceInterface_GetIids, + devinfo_DeviceInterface_GetRuntimeClassName, + device_information_GetTrustLevel, + /* IDeviceInformation */ + devinfo_DeviceInterface_get_Id, + devinfo_DeviceInterface_get_Name, + devinfo_DeviceInterface_get_IsEnabled, + devinfo_DeviceInterface_IsDefault, + devinfo_DeviceInterface_get_EnclosureLocation, + devinfo_DeviceInterface_get_Properties, + devinfo_DeviceInterface_Update, + devinfo_DeviceInterface_GetThumbnailAsync, + devinfo_DeviceInterface_GetGlyphThumbnailAsync, +}; + +HRESULT deviceinformation_iface_create( IDeviceInformation **info ) +{ + struct devinfo_DeviceInterface *impl; + + impl = calloc( 1, sizeof( *impl ) ); + if (!impl) + return E_OUTOFMEMORY; + + impl->IDeviceInformation_iface.lpVtbl = &devinfo_DeviceInterface_vtbl; + impl->ref = 1; + *info = &impl->IDeviceInformation_iface; + return S_OK; +} diff --git a/dlls/windows.devices.enumeration/main.c b/dlls/windows.devices.enumeration/main.c index 0e34fafe3af..4ea1555c8fc 100644 --- a/dlls/windows.devices.enumeration/main.c +++ b/dlls/windows.devices.enumeration/main.c @@ -342,18 +342,39 @@ static HRESULT WINAPI findall_async( IUnknown *invoker, IUnknown *param, PROPVAR .iterable = &IID_IIterable_DeviceInformation, .iterator = &IID_IIterator_DeviceInformation, }; - HRESULT hr; IVectorView_DeviceInformation *view; + IDeviceInformation *device; + IVector_IInspectable *vector; + HRESULT hr = S_OK; FIXME( "invoker %p, param %p, result %p semi-stub!\n", invoker, param, result ); - hr = vector_create( &iids, (void *)&view ); + hr = deviceinformation_iface_create( &device ); + if (FAILED( hr )) + return hr; + + hr = vector_create( &iids, (void *)&vector ); + if (FAILED( hr )) + { + IDeviceInformation_Release( device ); + return hr; + } - if (SUCCEEDED( hr )) + hr = IVector_IInspectable_Append( vector, (IInspectable *)device ); + IDeviceInformation_Release( device ); + if (FAILED( hr )) { - result->vt = VT_UNKNOWN; - result->punkVal = (IUnknown *)view; + IVector_IInspectable_Release( 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; } diff --git a/dlls/windows.devices.enumeration/private.h b/dlls/windows.devices.enumeration/private.h index f9e4f571a97..802163a2027 100644 --- a/dlls/windows.devices.enumeration/private.h +++ b/dlls/windows.devices.enumeration/private.h @@ -59,6 +59,8 @@ 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 deviceinformation_iface_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 e8b34e84ae3..64733cc5096 100644 --- a/dlls/windows.devices.enumeration/tests/devices.c +++ b/dlls/windows.devices.enumeration/tests/devices.c @@ -483,7 +483,7 @@ static void test_DeviceInformation( void ) UINT32 idx = 0, size = 0; hr = IVectorView_DeviceInformation_get_Size( info_collection, &size ); - todo_wine ok( hr == S_OK, "got %#lx\n", hr ); + ok( hr == S_OK, "got %#lx\n", hr ); for (idx = 0; idx < size ;idx++) { IDeviceInformation *info; -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/6874
From: Vibhav Pant <vibhavp(a)gmail.com> --- dlls/windows.devices.enumeration/Makefile.in | 2 +- .../windows.devices.enumeration/information.c | 26 +++- dlls/windows.devices.enumeration/main.c | 129 +++++++++++++++--- dlls/windows.devices.enumeration/private.h | 4 +- .../tests/devices.c | 2 +- 5 files changed, 137 insertions(+), 26 deletions(-) diff --git a/dlls/windows.devices.enumeration/Makefile.in b/dlls/windows.devices.enumeration/Makefile.in index 062a914e322..ba3bc7a4b6c 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 afff96c9894..6673f954025 100644 --- a/dlls/windows.devices.enumeration/information.c +++ b/dlls/windows.devices.enumeration/information.c @@ -20,6 +20,8 @@ #include "private.h" #include <roapi.h> +#include <setupapi.h> +#include <cfgmgr32.h> #include <wine/debug.h> #include <wine/rbtree.h> @@ -30,6 +32,8 @@ WINE_DEFAULT_DEBUG_CHANNEL(enumeration); struct devinfo_DeviceInterface { IDeviceInformation IDeviceInformation_iface; + + HSTRING path; LONG ref; }; @@ -78,7 +82,10 @@ static ULONG STDMETHODCALLTYPE devinfo_DeviceInterface_Release( IDeviceInformati impl = impl_DeviceInterface_from_IDeviceInformation( iface ); ref = InterlockedDecrement( &impl->ref ); if (!ref) + { + WindowsDeleteString( impl->path ); free( impl ); + } return ref; } @@ -108,8 +115,12 @@ static HRESULT STDMETHODCALLTYPE device_information_GetTrustLevel( static HRESULT STDMETHODCALLTYPE devinfo_DeviceInterface_get_Id( IDeviceInformation *iface, HSTRING *id ) { - FIXME( "(%p, %p) stub!\n", iface, id ); - return E_NOTIMPL; + struct devinfo_DeviceInterface *impl; + + TRACE( "(%p, %p)\n", iface, id ); + + impl = impl_DeviceInterface_from_IDeviceInformation( iface ); + return WindowsDuplicateString( impl->path, id ); } static HRESULT STDMETHODCALLTYPE devinfo_DeviceInterface_get_Name( IDeviceInformation *iface, HSTRING *name ) @@ -186,15 +197,24 @@ static const struct IDeviceInformationVtbl devinfo_DeviceInterface_vtbl = { devinfo_DeviceInterface_GetGlyphThumbnailAsync, }; -HRESULT deviceinformation_iface_create( IDeviceInformation **info ) +HRESULT deviceinformation_iface_create( const SP_DEVICE_INTERFACE_DETAIL_DATA_W *iface_detail, + IDeviceInformation **info ) { struct devinfo_DeviceInterface *impl; + HRESULT res; impl = calloc( 1, sizeof( *impl ) ); if (!impl) return E_OUTOFMEMORY; impl->IDeviceInformation_iface.lpVtbl = &devinfo_DeviceInterface_vtbl; + res = WindowsCreateString( iface_detail->DevicePath, wcslen( iface_detail->DevicePath ), + &impl->path ); + if (FAILED( res )) + { + free( impl ); + return res; + } impl->ref = 1; *info = &impl->IDeviceInformation_iface; return S_OK; diff --git a/dlls/windows.devices.enumeration/main.c b/dlls/windows.devices.enumeration/main.c index 4ea1555c8fc..73130a28f87 100644 --- a/dlls/windows.devices.enumeration/main.c +++ b/dlls/windows.devices.enumeration/main.c @@ -342,39 +342,128 @@ static HRESULT WINAPI findall_async( IUnknown *invoker, IUnknown *param, PROPVAR .iterable = &IID_IIterable_DeviceInformation, .iterator = &IID_IIterator_DeviceInformation, }; - IVectorView_DeviceInformation *view; - IDeviceInformation *device; IVector_IInspectable *vector; + HKEY iface_key; HRESULT hr = S_OK; + 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 ); - hr = deviceinformation_iface_create( &device ); + hr = vector_create( &iids, (void *)&vector ); if (FAILED( hr )) return hr; - hr = vector_create( &iids, (void *)&vector ); - if (FAILED( hr )) + iface_key = + SetupDiOpenClassRegKeyExW( NULL, KEY_ENUMERATE_SUB_KEYS, DIOCR_INTERFACE, NULL, NULL ); + if (!iface_key) + return HRESULT_FROM_WIN32( GetLastError() ); + for (i = 0; SUCCEEDED( hr ); i++) { - IDeviceInformation_Release( device ); - return hr; + WCHAR keyName[40]; + DWORD keylen = 40; + GUID iface_class; + LSTATUS ret; + HDEVINFO devinfo; + DWORD j; + + ret = RegEnumKeyExW( iface_key, i, keyName, &keylen, NULL, NULL, NULL, NULL ); + if (ret == ERROR_NO_MORE_ITEMS) + break; + else if (ret) + { + hr = HRESULT_FROM_WIN32( ret ); + break; + } + hr = CLSIDFromString( keyName, &iface_class ); + if (FAILED( hr )) + { + ERR( "Could not parse interface GUID string %s: %#lx\n", debugstr_w( keyName ), hr ); + continue; + } + + devinfo = SetupDiGetClassDevsW( &iface_class, NULL, NULL, DIGCF_DEVICEINTERFACE ); + if (devinfo == INVALID_HANDLE_VALUE) + { + DWORD err = GetLastError(); + ERR( "Could not get device list for interface %s: %lu\n", debugstr_guid( &iface_class ), err ); + hr = HRESULT_FROM_WIN32( err ); + break; + } + + for (j = 0; ;j++) + { + + SP_DEVICE_INTERFACE_DATA iface_data = {0}; + SP_DEVICE_INTERFACE_DETAIL_DATA_W *iface_detail_data; + SIZE_T size = + offsetof( SP_DEVICE_INTERFACE_DETAIL_DATA_W, DevicePath[MAX_PATH + 1] ); + BOOL success; + IDeviceInformation *info; + + iface_data.cbSize = sizeof( iface_data ); + iface_detail_data = malloc( size ); + if (!iface_detail_data) + { + + hr = E_OUTOFMEMORY; + break; + } + iface_detail_data->cbSize = sizeof( *iface_detail_data ); + + success = SetupDiEnumDeviceInterfaces( devinfo, NULL, &iface_class, j, + &iface_data ); + if (!success) + { + + DWORD err = GetLastError(); + free( iface_detail_data ); + + if (err == ERROR_NO_MORE_ITEMS) + break; + ERR( "Could not enumerate device interfaces: %lu\n", err ); + hr = HRESULT_FROM_WIN32( err ); + break; + } + + success = SetupDiGetDeviceInterfaceDetailW( devinfo, &iface_data, iface_detail_data, + size, NULL, NULL ); + if (!success) + { + + DWORD err = GetLastError(); + free( iface_detail_data ); + ERR( "Could not get interface details for %s: %lu\n", + debugstr_guid( &iface_class ), err ); + hr = HRESULT_FROM_WIN32( err ); + break; + } + + hr = deviceinformation_iface_create( iface_detail_data, &info ); + free( iface_detail_data ); + if (FAILED( hr )) + break; + + hr = IVector_IInspectable_Append( vector, (IInspectable *)info ); + if (FAILED( hr )) + { + IVector_IInspectable_Release( vector ); + break; + } + } } - hr = IVector_IInspectable_Append( vector, (IInspectable *)device ); - IDeviceInformation_Release( device ); - if (FAILED( hr )) + if (SUCCEEDED( hr )) { + IVectorView_DeviceInformation *view; + hr = IVector_IInspectable_GetView( vector, (void *)&view ); IVector_IInspectable_Release( vector ); - return hr; + if (SUCCEEDED( hr )) + { + result->vt = VT_UNKNOWN; + result->punkVal = (IUnknown *)view; + } } - - hr = IVector_IInspectable_GetView( vector, (void *)&view ); - IVector_IInspectable_Release( vector ); - if (FAILED( hr )) - return hr; - - result->vt = VT_UNKNOWN; - result->punkVal = (IUnknown *)view; + RegCloseKey( iface_key ); return hr; } diff --git a/dlls/windows.devices.enumeration/private.h b/dlls/windows.devices.enumeration/private.h index 802163a2027..c7a8191e02c 100644 --- a/dlls/windows.devices.enumeration/private.h +++ b/dlls/windows.devices.enumeration/private.h @@ -28,6 +28,7 @@ #include "winbase.h" #include "winstring.h" #include "objbase.h" +#include "setupapi.h" #include "activation.h" @@ -59,7 +60,8 @@ 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 deviceinformation_iface_create( IDeviceInformation **info ); +extern HRESULT deviceinformation_iface_create( const SP_DEVICE_INTERFACE_DETAIL_DATA_W *iface_detail, + 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 64733cc5096..0954cc9cd44 100644 --- a/dlls/windows.devices.enumeration/tests/devices.c +++ b/dlls/windows.devices.enumeration/tests/devices.c @@ -492,7 +492,7 @@ static void test_DeviceInformation( void ) ok( hr == S_OK, "got %#lx\n", hr ); if (SUCCEEDED( hr )) { - todo_wine test_DeviceInformation_obj(__LINE__, info); + test_DeviceInformation_obj(__LINE__, info); IDeviceInformation_Release( info ); } winetest_pop_context(); -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/6874
On Mon May 5 17:40:55 2025 +0000, Rémi Bernon wrote:
(Have only quickly looked up to https://gitlab.winehq.org/wine/wine/-/merge_requests/6874/diffs?commit_id=e5... so far) Well, most of that code doesn't exist anymore, apologies :P
-- https://gitlab.winehq.org/wine/wine/-/merge_requests/6874#note_102593
participants (2)
-
Vibhav Pant -
Vibhav Pant (＠vibhavp)