dlls/windows.devices.enumeration/main.c

   1 /* WinRT Windows.Devices.Enumeration implementation
   2  *
   3  * Copyright 2021 Gijs Vermeulen
   4  * Copyright 2022 Julian Klemann for CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "initguid.h"
  22 #include "private.h"
  23
  24 #include "wine/debug.h"
  25
  26 WINE_DEFAULT_DEBUG_CHANNEL(enumeration);
  27
  28 static const char *debugstr_hstring( HSTRING hstr )
  29 {
  30     const WCHAR *str;
  31     UINT32 len;
  32     if (hstr && !((ULONG_PTR)hstr >> 16)) return "(invalid)";
  33     str = WindowsGetStringRawBuffer( hstr, &len );
  34     return wine_dbgstr_wn( str, len );
  35 }
  36
  37 struct device_information_statics
  38 {
  39     IActivationFactory IActivationFactory_iface;
  40     IDeviceInformationStatics2 IDeviceInformationStatics2_iface;
  41     LONG ref;
  42 };
  43
  44 static inline struct device_information_statics *impl_from_IActivationFactory( IActivationFactory *iface )
  45 {
  46     return CONTAINING_RECORD( iface, struct device_information_statics, IActivationFactory_iface );
  47 }
  48
  49 static HRESULT WINAPI activation_factory_QueryInterface( IActivationFactory *iface, REFIID iid, void **out )
  50 {
  51     struct device_information_statics *impl = impl_from_IActivationFactory( iface );
  52
  53     TRACE( "iface %p, iid %s, out %p stub!\n", iface, debugstr_guid( iid ), out );
  54
  55     if (IsEqualGUID( iid, &IID_IUnknown ) ||
  56         IsEqualGUID( iid, &IID_IInspectable ) ||
  57         IsEqualGUID( iid, &IID_IActivationFactory ))
  58     {
  59         IInspectable_AddRef( (*out = &impl->IActivationFactory_iface) );
  60         return S_OK;
  61     }
  62
  63     if (IsEqualGUID( iid, &IID_IDeviceInformationStatics2 ))
  64     {
  65         IInspectable_AddRef( (*out = &impl->IDeviceInformationStatics2_iface) );
  66         return S_OK;
  67     }
  68
  69     FIXME( "%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid( iid ) );
  70     *out = NULL;
  71     return E_NOINTERFACE;
  72 }
  73
  74 static ULONG WINAPI activation_factory_AddRef( IActivationFactory *iface )
  75 {
  76     struct device_information_statics *impl = impl_from_IActivationFactory( iface );
  77     ULONG ref = InterlockedIncrement( &impl->ref );
  78     TRACE( "iface %p, ref %lu.\n", iface, ref );
  79     return ref;
  80 }
  81
  82 static ULONG WINAPI activation_factory_Release( IActivationFactory *iface )
  83 {
  84     struct device_information_statics *impl = impl_from_IActivationFactory( iface );
  85     ULONG ref = InterlockedDecrement( &impl->ref );
  86     TRACE( "iface %p, ref %lu.\n", iface, ref );
  87     return ref;
  88 }
  89
  90 static HRESULT WINAPI activation_factory_GetIids( IActivationFactory *iface, ULONG *iid_count, IID **iids )
  91 {
  92     FIXME( "iface %p, iid_count %p, iids %p stub!\n", iface, iid_count, iids );
  93     return E_NOTIMPL;
  94 }
  95
  96 static HRESULT WINAPI activation_factory_GetRuntimeClassName( IActivationFactory *iface, HSTRING *class_name )
  97 {
  98     FIXME( "iface %p, class_name %p stub!\n", iface, class_name );
  99     return E_NOTIMPL;
 100 }
 101
 102 static HRESULT WINAPI activation_factory_GetTrustLevel( IActivationFactory *iface, TrustLevel *trust_level )
 103 {
 104     FIXME( "iface %p, trust_level %p stub!\n", iface, trust_level );
 105     return E_NOTIMPL;
 106 }
 107
 108 static HRESULT WINAPI activation_factory_ActivateInstance( IActivationFactory *iface, IInspectable **instance )
 109 {
 110     FIXME( "iface %p, instance %p stub!\n", iface, instance );
 111     return E_NOTIMPL;
 112 }
 113
 114 static const struct IActivationFactoryVtbl activation_factory_vtbl =
 115 {
 116     activation_factory_QueryInterface,
 117     activation_factory_AddRef,
 118     activation_factory_Release,
 119     /* IInspectable methods */
 120     activation_factory_GetIids,
 121     activation_factory_GetRuntimeClassName,
 122     activation_factory_GetTrustLevel,
 123     /* IActivationFactory methods */
 124     activation_factory_ActivateInstance,
 125 };
 126
 127 DEFINE_IINSPECTABLE( device_statics2, IDeviceInformationStatics2, struct device_information_statics, IActivationFactory_iface );
 128
 129 static HRESULT WINAPI device_statics2_GetAqsFilterFromDeviceClass( IDeviceInformationStatics2 *iface, DeviceClass device_class,
 130                                                                    HSTRING *filter )
 131 {
 132     FIXME( "iface %p, device_class %u, filter %p stub!\n", iface, device_class, filter );
 133     return E_NOTIMPL;
 134 }
 135
 136 static HRESULT WINAPI device_statics2_CreateFromIdAsync( IDeviceInformationStatics2 *iface, HSTRING device_id,
 137                                                          IIterable_HSTRING *additional_properties, DeviceInformationKind kind,
 138                                                          IAsyncOperation_DeviceInformation **async_operation )
 139 {
 140     FIXME( "iface %p, device_id %s, additional_properties %p, kind %u, async_operation %p stub!\n",
 141             iface, debugstr_hstring( device_id ), additional_properties, kind, async_operation );
 142     return E_NOTIMPL;
 143 }
 144
 145 static HRESULT WINAPI device_statics2_FindAllAsync( IDeviceInformationStatics2 *iface, HSTRING filter,
 146                                                     IIterable_HSTRING *additional_properties, DeviceInformationKind kind,
 147                                                     IAsyncOperation_DeviceInformationCollection **async_operation )
 148 {
 149     FIXME( "iface %p, filter %s, additional_properties %p, kind %u, async_operation %p stub!\n",
 150             iface, debugstr_hstring( filter ), additional_properties, kind, async_operation );
 151     return E_NOTIMPL;
 152 }
 153
 154 static HRESULT WINAPI device_statics2_CreateWatcher( IDeviceInformationStatics2 *iface, HSTRING filter,
 155                                                      IIterable_HSTRING *additional_properties, DeviceInformationKind kind,
 156                                                      IDeviceWatcher **watcher )
 157 {
 158     FIXME( "iface %p, filter %s, additional_properties %p, kind %u, watcher %p stub!\n",
 159             iface, debugstr_hstring( filter ), additional_properties, kind, watcher );
 160     return E_NOTIMPL;
 161 }
 162
 163 static const struct IDeviceInformationStatics2Vtbl device_statics2_vtbl =
 164 {
 165     device_statics2_QueryInterface,
 166     device_statics2_AddRef,
 167     device_statics2_Release,
 168     /* IInspectable methods */
 169     device_statics2_GetIids,
 170     device_statics2_GetRuntimeClassName,
 171     device_statics2_GetTrustLevel,
 172     /* IDeviceInformationStatics2 methods */
 173     device_statics2_GetAqsFilterFromDeviceClass,
 174     device_statics2_CreateFromIdAsync,
 175     device_statics2_FindAllAsync,
 176     device_statics2_CreateWatcher
 177 };
 178
 179 static struct device_information_statics device_information_statics =
 180 {
 181     {&activation_factory_vtbl},
 182     {&device_statics2_vtbl},
 183     1
 184 };
 185
 186 HRESULT WINAPI DllGetClassObject( REFCLSID clsid, REFIID riid, void **out )
 187 {
 188     FIXME( "clsid %s, riid %s, out %p stub!\n", debugstr_guid( clsid ), debugstr_guid( riid ), out );
 189     return CLASS_E_CLASSNOTAVAILABLE;
 190 }
 191
 192 HRESULT WINAPI DllGetActivationFactory( HSTRING classid, IActivationFactory **factory )
 193 {
 194     TRACE( "classid %s, factory %p.\n", debugstr_hstring( classid ), factory );
 195     *factory = &device_information_statics.IActivationFactory_iface;
 196     IUnknown_AddRef( *factory );
 197     return S_OK;
 198 }