dlls/windows.devices.enumeration/access.c

   1 /* WinRT Windows.Devices.Enumeration implementation
   2  *
   3  * Copyright 2022 Paul Gofman for CodeWeavers
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include "private.h"
  21
  22 #include "wine/debug.h"
  23
  24 WINE_DEFAULT_DEBUG_CHANNEL(mmdevapi);
  25
  26 struct device_access_information
  27 {
  28     IDeviceAccessInformation IDeviceAccessInformation_iface;
  29     LONG ref;
  30 };
  31
  32 static inline struct device_access_information *impl_from_IDeviceAccessInformation( IDeviceAccessInformation *iface )
  33 {
  34     return CONTAINING_RECORD( iface, struct device_access_information, IDeviceAccessInformation_iface );
  35 }
  36
  37 static HRESULT WINAPI device_access_information_QueryInterface( IDeviceAccessInformation *iface,
  38                                                                 REFIID iid, void **out )
  39 {
  40     struct device_access_information *impl = impl_from_IDeviceAccessInformation( iface );
  41
  42     TRACE( "iface %p, iid %s, out %p.\n", iface, debugstr_guid( iid ), out );
  43
  44     if (IsEqualGUID( iid, &IID_IUnknown ) ||
  45         IsEqualGUID( iid, &IID_IInspectable ) ||
  46         IsEqualGUID( iid, &IID_IAgileObject ) ||
  47         IsEqualGUID( iid, &IID_IDeviceAccessInformation ))
  48     {
  49         IInspectable_AddRef( (*out = &impl->IDeviceAccessInformation_iface) );
  50         return S_OK;
  51     }
  52
  53     FIXME( "%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid( iid ) );
  54     *out = NULL;
  55     return E_NOINTERFACE;
  56 }
  57
  58 static ULONG WINAPI device_access_information_AddRef( IDeviceAccessInformation *iface )
  59 {
  60     struct device_access_information *impl = impl_from_IDeviceAccessInformation( iface );
  61     ULONG ref = InterlockedIncrement( &impl->ref );
  62     TRACE( "iface %p increasing refcount to %lu.\n", iface, ref );
  63     return ref;
  64 }
  65
  66 static ULONG WINAPI device_access_information_Release( IDeviceAccessInformation *iface )
  67 {
  68     struct device_access_information *impl = impl_from_IDeviceAccessInformation( iface );
  69     ULONG ref = InterlockedDecrement( &impl->ref );
  70
  71     TRACE( "iface %p decreasing refcount to %lu.\n", iface, ref );
  72
  73     if (!ref)
  74         free( impl );
  75
  76     return ref;
  77 }
  78
  79 static HRESULT WINAPI device_access_information_GetIids( IDeviceAccessInformation *iface, ULONG *iid_count, IID **iids )
  80 {
  81     FIXME( "iface %p, iid_count %p, iids %p stub!\n", iface, iid_count, iids );
  82     return E_NOTIMPL;
  83 }
  84
  85 static HRESULT WINAPI device_access_information_GetRuntimeClassName( IDeviceAccessInformation *iface,
  86                                                                      HSTRING *class_name )
  87 {
  88     return WindowsCreateString( RuntimeClass_Windows_Devices_Enumeration_DeviceAccessInformation,
  89                                 ARRAY_SIZE(RuntimeClass_Windows_Devices_Enumeration_DeviceAccessInformation),
  90                                 class_name );
  91 }
  92
  93 static HRESULT WINAPI device_access_information_GetTrustLevel( IDeviceAccessInformation *iface,
  94                                                                TrustLevel *trust_level )
  95 {
  96     FIXME( "iface %p, trust_level %p stub!\n", iface, trust_level );
  97     return E_NOTIMPL;
  98 }
  99
 100 static HRESULT WINAPI device_access_information_add_AccessChanged(
 101     IDeviceAccessInformation *iface, ITypedEventHandler_DeviceAccessInformation_DeviceAccessChangedEventArgs *handler,
 102     EventRegistrationToken *cookie )
 103 {
 104     static EventRegistrationToken dummy_token = {.value = 0xdeadbeef};
 105
 106     FIXME( "iface %p, handler %p, cookie %p stub.\n", iface, handler, cookie);
 107
 108     *cookie = dummy_token;
 109     return S_OK;
 110 }
 111
 112 static HRESULT WINAPI device_access_information_remove_AccessChanged( IDeviceAccessInformation *iface,
 113                                                                       EventRegistrationToken cookie )
 114 {
 115     FIXME( "iface %p, cookie %#I64x stub.\n", iface, cookie.value);
 116
 117     return S_OK;
 118 }
 119
 120 static HRESULT WINAPI device_access_information_CurrentStatus( IDeviceAccessInformation *iface,
 121                                                                enum DeviceAccessStatus *status )
 122 {
 123     FIXME( "iface %p, status %p stub.\n", iface, status );
 124
 125     *status = DeviceAccessStatus_Allowed;
 126     return S_OK;
 127 }
 128
 129 static const struct IDeviceAccessInformationVtbl device_access_information_vtbl =
 130 {
 131     device_access_information_QueryInterface,
 132     device_access_information_AddRef,
 133     device_access_information_Release,
 134     /* IInspectable methods */
 135     device_access_information_GetIids,
 136     device_access_information_GetRuntimeClassName,
 137     device_access_information_GetTrustLevel,
 138     /* IDeviceAccessInformation methods */
 139     device_access_information_add_AccessChanged,
 140     device_access_information_remove_AccessChanged,
 141     device_access_information_CurrentStatus,
 142 };
 143
 144 static HRESULT device_access_information_create( IDeviceAccessInformation **out )
 145 {
 146     struct device_access_information *impl;
 147
 148     if (!(impl = calloc( 1, sizeof(*impl) ))) return E_OUTOFMEMORY;
 149     impl->IDeviceAccessInformation_iface.lpVtbl = &device_access_information_vtbl;
 150     impl->ref = 1;
 151
 152     *out = &impl->IDeviceAccessInformation_iface;
 153     TRACE( "created device_access_information %p.\n", *out );
 154     return S_OK;
 155 }
 156
 157 struct device_access_information_statics
 158 {
 159     IActivationFactory IActivationFactory_iface;
 160     IDeviceAccessInformationStatics IDeviceAccessInformationStatics_iface;
 161     LONG ref;
 162 };
 163
 164 static inline struct device_access_information_statics *impl_from_IActivationFactory( IActivationFactory *iface )
 165 {
 166     return CONTAINING_RECORD( iface, struct device_access_information_statics, IActivationFactory_iface );
 167 }
 168
 169 static HRESULT WINAPI factory_QueryInterface( IActivationFactory *iface, REFIID iid, void **out )
 170 {
 171     struct device_access_information_statics *impl = impl_from_IActivationFactory( iface );
 172
 173     TRACE( "iface %p, iid %s, out %p stub!\n", iface, debugstr_guid( iid ), out );
 174
 175     if (IsEqualGUID( iid, &IID_IUnknown ) ||
 176         IsEqualGUID( iid, &IID_IInspectable ) ||
 177         IsEqualGUID( iid, &IID_IActivationFactory ))
 178     {
 179         IInspectable_AddRef( (*out = &impl->IActivationFactory_iface) );
 180         return S_OK;
 181     }
 182
 183     if (IsEqualGUID( iid, &IID_IDeviceAccessInformationStatics ))
 184     {
 185         IInspectable_AddRef( (*out = &impl->IDeviceAccessInformationStatics_iface) );
 186         return S_OK;
 187     }
 188
 189     FIXME( "%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid( iid ) );
 190     *out = NULL;
 191     return E_NOINTERFACE;
 192 }
 193
 194 static ULONG WINAPI factory_AddRef( IActivationFactory *iface )
 195 {
 196     struct device_access_information_statics *impl = impl_from_IActivationFactory( iface );
 197     ULONG ref = InterlockedIncrement( &impl->ref );
 198     TRACE( "iface %p, ref %lu.\n", iface, ref );
 199     return ref;
 200 }
 201
 202 static ULONG WINAPI factory_Release( IActivationFactory *iface )
 203 {
 204     struct device_access_information_statics *impl = impl_from_IActivationFactory( iface );
 205     ULONG ref = InterlockedDecrement( &impl->ref );
 206     TRACE( "iface %p, ref %lu.\n", iface, ref );
 207     return ref;
 208 }
 209
 210 static HRESULT WINAPI factory_GetIids( IActivationFactory *iface, ULONG *iid_count, IID **iids )
 211 {
 212     FIXME( "iface %p, iid_count %p, iids %p stub!\n", iface, iid_count, iids );
 213     return E_NOTIMPL;
 214 }
 215
 216 static HRESULT WINAPI factory_GetRuntimeClassName( IActivationFactory *iface, HSTRING *class_name )
 217 {
 218     FIXME( "iface %p, class_name %p stub!\n", iface, class_name );
 219     return E_NOTIMPL;
 220 }
 221
 222 static HRESULT WINAPI factory_GetTrustLevel( IActivationFactory *iface, TrustLevel *trust_level )
 223 {
 224     FIXME( "iface %p, trust_level %p stub!\n", iface, trust_level );
 225     return E_NOTIMPL;
 226 }
 227
 228 static HRESULT WINAPI factory_ActivateInstance( IActivationFactory *iface, IInspectable **instance )
 229 {
 230     FIXME( "iface %p, instance %p stub!\n", iface, instance );
 231     return E_NOTIMPL;
 232 }
 233
 234 static const struct IActivationFactoryVtbl factory_vtbl =
 235 {
 236     factory_QueryInterface,
 237     factory_AddRef,
 238     factory_Release,
 239     /* IInspectable methods */
 240     factory_GetIids,
 241     factory_GetRuntimeClassName,
 242     factory_GetTrustLevel,
 243     /* IActivationFactory methods */
 244     factory_ActivateInstance,
 245 };
 246
 247 DEFINE_IINSPECTABLE( statics, IDeviceAccessInformationStatics, struct device_access_information_statics, IActivationFactory_iface );
 248
 249 static HRESULT WINAPI statics_CreateFromId( IDeviceAccessInformationStatics *iface,
 250                                             HSTRING device_id, IDeviceAccessInformation **value)
 251 {
 252     FIXME( "device_id %s, value %p stub.\n", debugstr_hstring( device_id ), value );
 253
 254     return device_access_information_create( value );
 255 }
 256
 257 static HRESULT WINAPI statics_CreateFromDeviceClassId( IDeviceAccessInformationStatics *iface,
 258                                                        GUID device_class_id, IDeviceAccessInformation **value)
 259 {
 260     FIXME( "device_class_id %s, value %p stub.\n", debugstr_guid( &device_class_id ), value );
 261
 262     return device_access_information_create( value );
 263 }
 264
 265 static HRESULT WINAPI statics_CreateFromDeviceClass( IDeviceAccessInformationStatics *iface,
 266                                                      enum DeviceClass device_class, IDeviceAccessInformation **value)
 267 {
 268     FIXME( "device_class %d, value %p stub.\n", device_class, value );
 269
 270     return device_access_information_create( value );
 271 }
 272
 273 static const struct IDeviceAccessInformationStaticsVtbl statics_vtbl =
 274 {
 275     statics_QueryInterface,
 276     statics_AddRef,
 277     statics_Release,
 278     /* IInspectable methods */
 279     statics_GetIids,
 280     statics_GetRuntimeClassName,
 281     statics_GetTrustLevel,
 282     /* IDeviceAccessInformationStatics methods */
 283     statics_CreateFromId,
 284     statics_CreateFromDeviceClassId,
 285     statics_CreateFromDeviceClass,
 286 };
 287
 288 static struct device_access_information_statics device_access_information_statics =
 289 {
 290     {&factory_vtbl},
 291     {&statics_vtbl},
 292     1
 293 };
 294
 295 IActivationFactory *device_access_factory = &device_access_information_statics.IActivationFactory_iface;