dlls/geolocation/main.c

   1 /* WinRT Windows.Devices.Geolocation.Geolocator Implementation
   2  *
   3  * Copyright 2023 Fabian Maurer
   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 "initguid.h"
  21 #include "private.h"
  22
  23 #include "wine/debug.h"
  24
  25 WINE_DEFAULT_DEBUG_CHANNEL(geolocator);
  26
  27 struct geolocator_statics
  28 {
  29     IActivationFactory IActivationFactory_iface;
  30     LONG ref;
  31 };
  32
  33 struct geolocator
  34 {
  35     IGeolocator IGeolocator_iface;
  36     IWeakReferenceSource IWeakReferenceSource_iface;
  37     IWeakReference IWeakReference_iface;
  38     LONG ref_public;
  39     LONG ref_weak;
  40 };
  41
  42 static inline struct geolocator *impl_from_IGeolocator(IGeolocator *iface)
  43 {
  44     return CONTAINING_RECORD(iface, struct geolocator, IGeolocator_iface);
  45 }
  46
  47 static HRESULT WINAPI geolocator_QueryInterface(IGeolocator *iface, REFIID iid, void **out)
  48 {
  49     struct geolocator *impl = impl_from_IGeolocator(iface);
  50
  51     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
  52
  53     if (IsEqualGUID(iid, &IID_IUnknown) ||
  54         IsEqualGUID(iid, &IID_IInspectable) ||
  55         IsEqualGUID(iid, &IID_IAgileObject) ||
  56         IsEqualGUID(iid, &IID_IGeolocator))
  57     {
  58         *out = &impl->IGeolocator_iface;
  59         IInspectable_AddRef(*out);
  60         return S_OK;
  61     }
  62
  63     if (IsEqualGUID(iid, &IID_IWeakReferenceSource))
  64     {
  65         *out = &impl->IWeakReferenceSource_iface;
  66         IInspectable_AddRef(*out);
  67         return S_OK;
  68     }
  69
  70     FIXME("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
  71     *out = NULL;
  72     return E_NOINTERFACE;
  73 }
  74
  75 static ULONG WINAPI geolocator_AddRef(IGeolocator *iface)
  76 {
  77     struct geolocator *impl = impl_from_IGeolocator(iface);
  78     ULONG ref = InterlockedIncrement(&impl->ref_public);
  79     TRACE("iface %p increasing refcount to %lu.\n", iface, ref);
  80     IWeakReference_AddRef(&impl->IWeakReference_iface);
  81     return ref;
  82 }
  83
  84 static ULONG WINAPI geolocator_Release(IGeolocator *iface)
  85 {
  86     struct geolocator *impl = impl_from_IGeolocator(iface);
  87     ULONG ref = InterlockedDecrement(&impl->ref_public);
  88     TRACE("iface %p decreasing refcount to %lu.\n", iface, ref);
  89     IWeakReference_Release(&impl->IWeakReference_iface);
  90     return ref;
  91 }
  92
  93 static HRESULT WINAPI geolocator_GetIids(IGeolocator *iface, ULONG *iid_count, IID **iids)
  94 {
  95     FIXME("iface %p, iid_count %p, iids %p stub!\n", iface, iid_count, iids);
  96     return E_NOTIMPL;
  97 }
  98
  99 static HRESULT WINAPI geolocator_GetRuntimeClassName(IGeolocator *iface, HSTRING *class_name)
 100 {
 101     FIXME("iface %p, class_name %p stub!\n", iface, class_name);
 102     return E_NOTIMPL;
 103 }
 104
 105 static HRESULT WINAPI geolocator_GetTrustLevel(IGeolocator *iface, TrustLevel *trust_level)
 106 {
 107     FIXME("iface %p, trust_level %p stub!\n", iface, trust_level);
 108     return E_NOTIMPL;
 109 }
 110
 111 HRESULT WINAPI geolocator_get_DesiredAccuracy(IGeolocator *iface, PositionAccuracy *value)
 112 {
 113     FIXME("iface %p, value %p stub.\n", iface, value);
 114     return E_NOTIMPL;
 115 }
 116
 117 HRESULT WINAPI geolocator_set_DesiredAccuracy(IGeolocator *iface, PositionAccuracy value)
 118 {
 119     FIXME("iface %p, value %d stub.\n", iface, value);
 120     return E_NOTIMPL;
 121 }
 122
 123 HRESULT WINAPI geolocator_get_MovementThreshold(IGeolocator *iface, DOUBLE *value)
 124 {
 125     FIXME("iface %p, value %p stub.\n", iface, value);
 126     return E_NOTIMPL;
 127 }
 128
 129 HRESULT WINAPI geolocator_set_MovementThreshold(IGeolocator *iface, DOUBLE value)
 130 {
 131     FIXME("iface %p, value %f stub.\n", iface, value);
 132     return E_NOTIMPL;
 133 }
 134
 135 HRESULT WINAPI geolocator_get_ReportInterval(IGeolocator *iface, UINT32 *value)
 136 {
 137     FIXME("iface %p, value %p stub.\n", iface, value);
 138     return E_NOTIMPL;
 139 }
 140
 141 HRESULT WINAPI geolocator_set_ReportInterval(IGeolocator *iface, UINT32 value)
 142 {
 143     FIXME("iface %p, value %u stub.\n", iface, value);
 144     return E_NOTIMPL;
 145 }
 146
 147 HRESULT WINAPI geolocator_LocationStatus(IGeolocator *iface, PositionStatus *value)
 148 {
 149     FIXME("iface %p, value %p stub.\n", iface, value);
 150     return E_NOTIMPL;
 151 }
 152
 153 HRESULT WINAPI geolocator_GetGeopositionAsync(IGeolocator *iface, IAsyncOperation_Geoposition **value)
 154 {
 155     FIXME("iface %p, value %p stub.\n", iface, value);
 156     return E_NOTIMPL;
 157 }
 158
 159 HRESULT WINAPI geolocator_GetGeopositionAsyncWithAgeAndTimeout(IGeolocator *iface, TimeSpan maximum_age, TimeSpan timeout, IAsyncOperation_Geoposition **value)
 160 {
 161     FIXME("iface %p, maximum_age %#I64x, timeout %#I64x, value %p stub.\n", iface, maximum_age.Duration, timeout.Duration, value);
 162     return E_NOTIMPL;
 163 }
 164
 165 HRESULT WINAPI geolocator_add_PositionChanged(IGeolocator *iface, ITypedEventHandler_Geolocator_PositionChangedEventArgs *handler, EventRegistrationToken *token)
 166 {
 167     FIXME("iface %p, handler %p, token %p stub.\n", iface, handler, token);
 168     return S_OK;
 169 }
 170
 171 HRESULT WINAPI geolocator_remove_PositionChanged(IGeolocator *iface, EventRegistrationToken token)
 172 {
 173    FIXME("iface %p, token %#I64x stub.\n", iface, token.value);
 174    return E_NOTIMPL;
 175 }
 176
 177 HRESULT WINAPI geolocator_add_StatusChanged(IGeolocator *iface, ITypedEventHandler_Geolocator_StatusChangedEventArgs *handler, EventRegistrationToken *token)
 178 {
 179     FIXME("iface %p, handler %p, token %p stub.\n", iface, handler, token);
 180     return E_NOTIMPL;
 181 }
 182
 183 HRESULT WINAPI geolocator_remove_StatusChanged(IGeolocator *iface, EventRegistrationToken token)
 184 {
 185     FIXME("iface %p, token %#I64x stub.\n", iface, token.value);
 186     return E_NOTIMPL;
 187 }
 188
 189 static const struct IGeolocatorVtbl geolocator_vtbl =
 190 {
 191     geolocator_QueryInterface,
 192     geolocator_AddRef,
 193     geolocator_Release,
 194     /* IInspectable methods */
 195     geolocator_GetIids,
 196     geolocator_GetRuntimeClassName,
 197     geolocator_GetTrustLevel,
 198     /* IGeolocator methods */
 199     geolocator_get_DesiredAccuracy,
 200     geolocator_set_DesiredAccuracy,
 201     geolocator_get_MovementThreshold,
 202     geolocator_set_MovementThreshold,
 203     geolocator_get_ReportInterval,
 204     geolocator_set_ReportInterval,
 205     geolocator_LocationStatus,
 206     geolocator_GetGeopositionAsync,
 207     geolocator_GetGeopositionAsyncWithAgeAndTimeout,
 208     geolocator_add_PositionChanged,
 209     geolocator_remove_PositionChanged,
 210     geolocator_add_StatusChanged,
 211     geolocator_remove_StatusChanged,
 212 };
 213
 214 static inline struct geolocator *impl_from_IWeakReference(IWeakReference *iface)
 215 {
 216     return CONTAINING_RECORD(iface, struct geolocator, IWeakReference_iface);
 217 }
 218
 219 static HRESULT WINAPI weak_reference_QueryInterface(IWeakReference *iface, REFIID iid, void **out)
 220 {
 221     struct geolocator *impl = impl_from_IWeakReference(iface);
 222
 223     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 224
 225     if (IsEqualGUID(iid, &IID_IUnknown) ||
 226         IsEqualGUID(iid, &IID_IWeakReference))
 227     {
 228         *out = &impl->IWeakReference_iface;
 229         IInspectable_AddRef(*out);
 230         return S_OK;
 231     }
 232
 233     FIXME("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
 234     *out = NULL;
 235     return E_NOINTERFACE;
 236 }
 237
 238 static ULONG WINAPI weak_reference_AddRef(IWeakReference *iface)
 239 {
 240     struct geolocator *impl = impl_from_IWeakReference(iface);
 241     ULONG ref = InterlockedIncrement(&impl->ref_weak);
 242     TRACE("iface %p increasing refcount to %lu.\n", iface, ref);
 243     return ref;
 244 }
 245
 246 static ULONG WINAPI weak_reference_Release(IWeakReference *iface)
 247 {
 248     struct geolocator *impl = impl_from_IWeakReference(iface);
 249     ULONG ref = InterlockedDecrement(&impl->ref_weak);
 250     if (!ref)
 251         free(impl);
 252     return ref;
 253 }
 254
 255 static HRESULT WINAPI weak_reference_Resolve(IWeakReference *iface, REFIID iid, IInspectable **out)
 256 {
 257     struct geolocator *impl = impl_from_IWeakReference(iface);
 258     HRESULT hr;
 259     LONG ref;
 260
 261     TRACE("iface %p, iid %s, out %p stub.\n", iface, debugstr_guid(iid), out);
 262
 263     *out = NULL;
 264
 265     do
 266     {
 267         if (!(ref = ReadNoFence(&impl->ref_public)))
 268             return S_OK;
 269     } while (ref != InterlockedCompareExchange(&impl->ref_public, ref + 1, ref));
 270
 271     hr = IGeolocator_QueryInterface(&impl->IGeolocator_iface, iid, (void **)out);
 272     InterlockedDecrement(&impl->ref_public);
 273     return hr;
 274 }
 275
 276 static const struct IWeakReferenceVtbl weak_reference_vtbl =
 277 {
 278     weak_reference_QueryInterface,
 279     weak_reference_AddRef,
 280     weak_reference_Release,
 281     /* IWeakReference methods */
 282     weak_reference_Resolve,
 283 };
 284
 285 static inline struct geolocator *impl_from_IWeakReferenceSource(IWeakReferenceSource *iface)
 286 {
 287     return CONTAINING_RECORD(iface, struct geolocator, IWeakReferenceSource_iface);
 288 }
 289
 290 static HRESULT WINAPI weak_reference_source_QueryInterface(IWeakReferenceSource *iface, REFIID iid, void **out)
 291 {
 292     struct geolocator *impl = impl_from_IWeakReferenceSource(iface);
 293     return geolocator_QueryInterface(&impl->IGeolocator_iface, iid, out);
 294 }
 295
 296 static ULONG WINAPI weak_reference_source_AddRef(IWeakReferenceSource *iface)
 297 {
 298     struct geolocator *impl = impl_from_IWeakReferenceSource(iface);
 299     return geolocator_AddRef(&impl->IGeolocator_iface);
 300 }
 301
 302 static ULONG WINAPI weak_reference_source_Release(IWeakReferenceSource *iface)
 303 {
 304     struct geolocator *impl = impl_from_IWeakReferenceSource(iface);
 305     return geolocator_Release(&impl->IGeolocator_iface);
 306 }
 307
 308 static HRESULT WINAPI weak_reference_source_GetWeakReference(IWeakReferenceSource *iface, IWeakReference **ref)
 309 {
 310     struct geolocator *impl = impl_from_IWeakReferenceSource(iface);
 311
 312     TRACE("iface %p, ref %p stub.\n", iface, ref);
 313     *ref = &impl->IWeakReference_iface;
 314     IWeakReference_AddRef(*ref);
 315     return S_OK;
 316 }
 317
 318 static const struct IWeakReferenceSourceVtbl weak_reference_source_vtbl =
 319 {
 320     weak_reference_source_QueryInterface,
 321     weak_reference_source_AddRef,
 322     weak_reference_source_Release,
 323     /* IWeakReferenceSource methods */
 324     weak_reference_source_GetWeakReference,
 325 };
 326
 327 static inline struct geolocator_statics *impl_from_IActivationFactory(IActivationFactory *iface)
 328 {
 329     return CONTAINING_RECORD(iface, struct geolocator_statics, IActivationFactory_iface);
 330 }
 331
 332 static HRESULT WINAPI factory_QueryInterface(IActivationFactory *iface, REFIID iid, void **out)
 333 {
 334     struct geolocator_statics *impl = impl_from_IActivationFactory(iface);
 335
 336     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 337
 338     if (IsEqualGUID(iid, &IID_IUnknown) ||
 339         IsEqualGUID(iid, &IID_IInspectable) ||
 340         IsEqualGUID(iid, &IID_IAgileObject) ||
 341         IsEqualGUID(iid, &IID_IActivationFactory))
 342     {
 343         *out = &impl->IActivationFactory_iface;
 344         IInspectable_AddRef(*out);
 345         return S_OK;
 346     }
 347
 348     FIXME("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
 349     *out = NULL;
 350     return E_NOINTERFACE;
 351 }
 352
 353 static ULONG WINAPI factory_AddRef(IActivationFactory *iface)
 354 {
 355     struct geolocator_statics *impl = impl_from_IActivationFactory(iface);
 356     ULONG ref = InterlockedIncrement(&impl->ref);
 357     TRACE("iface %p increasing refcount to %lu.\n", iface, ref);
 358     return ref;
 359 }
 360
 361 static ULONG WINAPI factory_Release(IActivationFactory *iface)
 362 {
 363     struct geolocator_statics *impl = impl_from_IActivationFactory(iface);
 364     ULONG ref = InterlockedDecrement(&impl->ref);
 365     TRACE("iface %p decreasing refcount to %lu.\n", iface, ref);
 366     return ref;
 367 }
 368
 369 static HRESULT WINAPI factory_GetIids(IActivationFactory *iface, ULONG *iid_count, IID **iids)
 370 {
 371     FIXME("iface %p, iid_count %p, iids %p stub!\n", iface, iid_count, iids);
 372     return E_NOTIMPL;
 373 }
 374
 375 static HRESULT WINAPI factory_GetRuntimeClassName(IActivationFactory *iface, HSTRING *class_name)
 376 {
 377     FIXME("iface %p, class_name %p stub!\n", iface, class_name);
 378     return E_NOTIMPL;
 379 }
 380
 381 static HRESULT WINAPI factory_GetTrustLevel(IActivationFactory *iface, TrustLevel *trust_level)
 382 {
 383     FIXME("iface %p, trust_level %p stub!\n", iface, trust_level);
 384     return E_NOTIMPL;
 385 }
 386
 387 static const struct IActivationFactoryVtbl factory_vtbl;
 388
 389 static HRESULT WINAPI factory_ActivateInstance(IActivationFactory *iface, IInspectable **instance)
 390 {
 391     struct geolocator *impl;
 392
 393     TRACE("iface %p, instance %p.\n", iface, instance);
 394
 395     if (!(impl = calloc(1, sizeof(*impl))))
 396     {
 397         *instance = NULL;
 398         return E_OUTOFMEMORY;
 399     }
 400
 401     impl->IGeolocator_iface.lpVtbl = &geolocator_vtbl;
 402     impl->IWeakReferenceSource_iface.lpVtbl = &weak_reference_source_vtbl;
 403     impl->IWeakReference_iface.lpVtbl = &weak_reference_vtbl;
 404     impl->ref_public = 1;
 405     impl->ref_weak = 1;
 406
 407     *instance = (IInspectable *)&impl->IGeolocator_iface;
 408     return S_OK;
 409 }
 410
 411 static const struct IActivationFactoryVtbl factory_vtbl =
 412 {
 413     factory_QueryInterface,
 414     factory_AddRef,
 415     factory_Release,
 416     /* IInspectable methods */
 417     factory_GetIids,
 418     factory_GetRuntimeClassName,
 419     factory_GetTrustLevel,
 420     /* IActivationFactory methods */
 421     factory_ActivateInstance,
 422 };
 423
 424 static struct geolocator_statics geolocator_statics =
 425 {
 426     {&factory_vtbl},
 427     1,
 428 };
 429
 430 static IActivationFactory *geolocator_factory = &geolocator_statics.IActivationFactory_iface;
 431
 432 HRESULT WINAPI DllGetClassObject(REFCLSID clsid, REFIID riid, void **out)
 433 {
 434     FIXME("clsid %s, riid %s, out %p stub!\n", debugstr_guid(clsid), debugstr_guid(riid), out);
 435     return CLASS_E_CLASSNOTAVAILABLE;
 436 }
 437
 438 HRESULT WINAPI DllGetActivationFactory(HSTRING classid, IActivationFactory **factory)
 439 {
 440     const WCHAR *name = WindowsGetStringRawBuffer(classid, NULL);
 441
 442     TRACE("classid %s, factory %p.\n", debugstr_hstring(classid), factory);
 443
 444     *factory = NULL;
 445
 446     if (!wcscmp(name, RuntimeClass_Windows_Devices_Geolocation_Geolocator))
 447         IActivationFactory_QueryInterface(geolocator_factory, &IID_IActivationFactory, (void **)factory);
 448
 449     if (*factory) return S_OK;
 450     return CLASS_E_CLASSNOTAVAILABLE;
 451 }