qgeopositioninfosource_winrt.cpp

++ // Copyright (C) 2015 The Qt Company Ltd.

++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only

++ // Qt-Security score:significant reason:default

++

++ #include "qgeopositioninfosource_winrt_p.h"

++

++ #include <QtCore/qcoreapplication.h>

++ #include <QtCore/qdatetime.h>

++ #include <QtCore/private/qfunctions_winrt_p.h>

++ #include <QtCore/qloggingcategory.h>

++ #include <QtCore/qmutex.h>

++ #include <QtCore/qtimezone.h>

++

++ #include <functional>

++ #include <windows.system.h>

++ #include <windows.devices.geolocation.h>

++ #include <windows.foundation.h>

++ #include <windows.foundation.collections.h>

++

++ using namespace Microsoft::WRL;

++ using namespace Microsoft::WRL::Wrappers;

++ using namespace ABI::Windows::Devices::Geolocation;

++ using namespace ABI::Windows::Foundation;

++ using namespace ABI::Windows::Foundation::Collections;

++

++ typedef ITypedEventHandler<Geolocator *, PositionChangedEventArgs *> GeoLocatorPositionHandler;

++ typedef ITypedEventHandler<Geolocator *, StatusChangedEventArgs *> GeoLocatorStatusHandler;

++ typedef IAsyncOperationCompletedHandler<Geoposition*> PositionHandler;

++ typedef IAsyncOperationCompletedHandler<GeolocationAccessStatus> AccessHandler;

++

++ Q_DECLARE_LOGGING_CATEGORY(lcPositioningWinRT)

++

++ QT_BEGIN_NAMESPACE

++

++ static inline HRESULT await(const ComPtr<IAsyncOperation<GeolocationAccessStatus>> &asyncOp,

++                             GeolocationAccessStatus *result)

++ {

++     ComPtr<IAsyncInfo> asyncInfo;

++     HRESULT hr = asyncOp.As(&asyncInfo);

++     if (FAILED(hr))

++         return hr;

++

++     AsyncStatus status;

++     while (SUCCEEDED(hr = asyncInfo->get_Status(&status)) && status == AsyncStatus::Started)

++         QThread::yieldCurrentThread();

++

++     if (FAILED(hr) || status != AsyncStatus::Completed) {

++         HRESULT ec;

++         hr = asyncInfo->get_ErrorCode(&ec);

++         if (FAILED(hr))

++             return hr;

++         hr = asyncInfo->Close();

++         if (FAILED(hr))

++             return hr;

++         return ec;

++     }

++

++     if (FAILED(hr))

++         return hr;

++

++     return asyncOp->GetResults(result);

++ }

++

++ enum class InitializationState {

++     Uninitialized,

++     Initializing,

++     Initialized

++ };

++

++ class QGeoPositionInfoSourceWinRTPrivate {

++ public:

++     ComPtr<IGeolocator> locator;

++     mutable ComPtr<IGeolocatorStatics> statics;

++     QTimer periodicTimer;

++     QTimer singleUpdateTimer;

++     QGeoPositionInfo lastPosition;

++     QGeoPositionInfoSource::Error positionError = QGeoPositionInfoSource::NoError;

++     EventRegistrationToken statusToken;

++     EventRegistrationToken positionToken;

++     QMutex mutex;

++     bool updatesOngoing = false;

++     int minimumUpdateInterval = -1;

++     int updateInterval = -1;

++     InitializationState initState = InitializationState::Uninitialized;

++

++     PositionStatus positionStatus = PositionStatus_NotInitialized;

++ };

++

++ QGeoPositionInfoSourceWinRT::QGeoPositionInfoSourceWinRT(QObject *parent)

++     : QGeoPositionInfoSource(parent)

++     , d_ptr(new QGeoPositionInfoSourceWinRTPrivate)

++ {

++     qRegisterMetaType<QGeoPositionInfoSource::Error>();

++     qCDebug(lcPositioningWinRT) << __FUNCTION__;

++     CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED);

++     Q_D(QGeoPositionInfoSourceWinRT);

++     d->positionError = QGeoPositionInfoSource::NoError;

++     d->updatesOngoing = false;

++     d->positionToken.value = 0;

++     d->statusToken.value = 0;

++ }

++

++ QGeoPositionInfoSourceWinRT::~QGeoPositionInfoSourceWinRT()

++ {

++     qCDebug(lcPositioningWinRT) << __FUNCTION__;

++     CoUninitialize();

++ }

++

++ int QGeoPositionInfoSourceWinRT::init()

++ {

++     Q_D(QGeoPositionInfoSourceWinRT);

++     Q_ASSERT(d->initState != InitializationState::Initializing);

++     if (d->initState == InitializationState::Initialized)

++         return 0;

++

++     qCDebug(lcPositioningWinRT) << __FUNCTION__;

++     d->initState = InitializationState::Initializing;

++     if (!requestAccess()) {

++         d->initState = InitializationState::Uninitialized;

++         setError(QGeoPositionInfoSource::AccessError);

++         qWarning ("Location access failed.");

++         return -1;

++     }

++     HRESULT hr = [this, d]() {

++         HRESULT hr = RoActivateInstance(HString::MakeReference(RuntimeClass_Windows_Devices_Geolocation_Geolocator).Get(),

++                                         &d->locator);

++         RETURN_HR_IF_FAILED("Could not initialize native location services.");

++

++         if (d->minimumUpdateInterval == -1) {

++             UINT32 interval;

++             hr = d->locator->get_ReportInterval(&interval);

++             RETURN_HR_IF_FAILED("Could not retrieve report interval.");

++             d->minimumUpdateInterval = static_cast<int>(interval);

++         }

++         if (d->updateInterval == -1)

++             d->updateInterval = d->minimumUpdateInterval;

++         setUpdateInterval(d->updateInterval);

++

++         return hr;

++     }();

++     if (FAILED(hr)) {

++         d->initState = InitializationState::Uninitialized;

++         setError(QGeoPositionInfoSource::UnknownSourceError);

++         return -1;

++     }

++

++     d->periodicTimer.setSingleShot(true);

++     connect(&d->periodicTimer, &QTimer::timeout, this, &QGeoPositionInfoSourceWinRT::virtualPositionUpdate);

++

++     d->singleUpdateTimer.setSingleShot(true);

++     connect(&d->singleUpdateTimer, &QTimer::timeout, this, &QGeoPositionInfoSourceWinRT::singleUpdateTimeOut);

++

++     QGeoPositionInfoSource::PositioningMethods preferredMethods = preferredPositioningMethods();

++     if (preferredMethods == QGeoPositionInfoSource::NoPositioningMethods)

++         preferredMethods = QGeoPositionInfoSource::AllPositioningMethods;

++     setPreferredPositioningMethods(preferredMethods);

++

++     connect(this, &QGeoPositionInfoSourceWinRT::nativePositionUpdate, this, &QGeoPositionInfoSourceWinRT::updateSynchronized);

++     d->initState = InitializationState::Initialized;

++     return 0;

++ }

++

++ QGeoPositionInfo QGeoPositionInfoSourceWinRT::lastKnownPosition(bool fromSatellitePositioningMethodsOnly) const

++ {

++     qCDebug(lcPositioningWinRT) << __FUNCTION__;

++     Q_D(const QGeoPositionInfoSourceWinRT);

++     Q_UNUSED(fromSatellitePositioningMethodsOnly);

++     return d->lastPosition;

++ }

++

++ QGeoPositionInfoSource::PositioningMethods QGeoPositionInfoSourceWinRT::supportedPositioningMethods() const

++ {

++     return requestAccess() ? QGeoPositionInfoSource::AllPositioningMethods

++                            : QGeoPositionInfoSource::NoPositioningMethods;

++ }

++

++ void QGeoPositionInfoSourceWinRT::setPreferredPositioningMethods(QGeoPositionInfoSource::PositioningMethods methods)

++ {

++     qCDebug(lcPositioningWinRT) << __FUNCTION__ << methods;

++     Q_D(QGeoPositionInfoSourceWinRT);

++

++     PositioningMethods previousPreferredPositioningMethods = preferredPositioningMethods();

++     QGeoPositionInfoSource::setPreferredPositioningMethods(methods);

++     if (previousPreferredPositioningMethods == preferredPositioningMethods()

++             || d->initState == InitializationState::Uninitialized) {

++         return;

++     }

++

++     const bool needsRestart = d->positionToken.value != 0 || d->statusToken.value != 0;

++

++     if (needsRestart)

++         stopHandler();

++

++     PositionAccuracy acc = methods & PositioningMethod::SatellitePositioningMethods ?

++                 PositionAccuracy::PositionAccuracy_High :

++                 PositionAccuracy::PositionAccuracy_Default;

++     HRESULT hr = [d, acc]() {

++         return d->locator->put_DesiredAccuracy(acc);

++     }();

++     RETURN_VOID_IF_FAILED("Could not set positioning accuracy.");

++

++     if (needsRestart)

++         startHandler();

++ }

++

++ void QGeoPositionInfoSourceWinRT::setUpdateInterval(int msec)

++ {

++     qCDebug(lcPositioningWinRT) << __FUNCTION__ << msec;

++     Q_D(QGeoPositionInfoSourceWinRT);

++     if (d->initState == InitializationState::Uninitialized) {

++         d->updateInterval = msec;

++         return;

++     }

++

++     // minimumUpdateInterval is initialized to the lowest possible update interval in init().

++     // Passing 0 will cause an error on Windows 10.

++     // See https://docs.microsoft.com/en-us/uwp/api/windows.devices.geolocation.geolocator.reportinterval

++     if (msec < minimumUpdateInterval())

++         msec = minimumUpdateInterval();

++

++     const bool needsRestart = d->positionToken.value != 0 || d->statusToken.value != 0;

++

++     if (needsRestart)

++         stopHandler();

++

++     HRESULT hr = d->locator->put_ReportInterval(static_cast<UINT32>(msec));

++     if (FAILED(hr)) {

++         setError(QGeoPositionInfoSource::UnknownSourceError);

++         qErrnoWarning(hr, "Failed to set update interval");

++         return;

++     }

++

++     d->updateInterval = msec;

++     d->periodicTimer.setInterval(d->updateInterval);

++

++     QGeoPositionInfoSource::setUpdateInterval(d->updateInterval);

++

++     if (needsRestart)

++         startHandler();

++ }

++

++ int QGeoPositionInfoSourceWinRT::minimumUpdateInterval() const

++ {

++     Q_D(const QGeoPositionInfoSourceWinRT);

++     return d->minimumUpdateInterval == -1 ? 1000 : d->minimumUpdateInterval;

++ }

++

++ void QGeoPositionInfoSourceWinRT::startUpdates()

++ {

++     qCDebug(lcPositioningWinRT) << __FUNCTION__;

++     Q_D(QGeoPositionInfoSourceWinRT);

++

++     setError(QGeoPositionInfoSource::NoError);

++     if (init() < 0)

++         return;

++

++     if (d->updatesOngoing)

++         return;

++

++     if (!startHandler())

++         return;

++     d->updatesOngoing = true;

++     d->periodicTimer.start();

++ }

++

++ void QGeoPositionInfoSourceWinRT::stopUpdates()

++ {

++     qCDebug(lcPositioningWinRT) << __FUNCTION__;

++     Q_D(QGeoPositionInfoSourceWinRT);

++

++     if (init() < 0)

++         return;

++

++     stopHandler();

++     d->updatesOngoing = false;

++     d->periodicTimer.stop();

++ }

++

++ bool QGeoPositionInfoSourceWinRT::startHandler()

++ {

++     qCDebug(lcPositioningWinRT) << __FUNCTION__;

++     Q_D(QGeoPositionInfoSourceWinRT);

++

++     // Check if already attached

++     if (d->positionToken.value != 0)

++         return true;

++

++     if (preferredPositioningMethods() == QGeoPositionInfoSource::NoPositioningMethods) {

++         setError(QGeoPositionInfoSource::UnknownSourceError);

++         return false;

++     }

++

++     if (!requestAccess()) {

++         setError(QGeoPositionInfoSource::AccessError);

++         return false;

++     }

++

++     HRESULT hr = [this, d]() {

++         HRESULT hr;

++

++         // We need to call this at least once on Windows 10 Mobile.

++         // Unfortunately this operation does not have a completion handler

++         // registered. That could have helped in the single update case

++         ComPtr<IAsyncOperation<Geoposition*>> op;

++         hr = d->locator->GetGeopositionAsync(&op);

++         RETURN_HR_IF_FAILED("Could not start position operation");

++

++         hr = d->locator->add_PositionChanged(Callback<GeoLocatorPositionHandler>(this,

++                                                                                  &QGeoPositionInfoSourceWinRT::onPositionChanged).Get(),

++                                              &d->positionToken);

++         RETURN_HR_IF_FAILED("Could not add position handler");

++

++         hr = d->locator->add_StatusChanged(Callback<GeoLocatorStatusHandler>(this,

++                                                                                  &QGeoPositionInfoSourceWinRT::onStatusChanged).Get(),

++                                              &d->statusToken);

++         RETURN_HR_IF_FAILED("Could not add status handler");

++         return hr;

++     }();

++     if (FAILED(hr)) {

++         setError(QGeoPositionInfoSource::UnknownSourceError);

++         return false;

++     }

++

++     return true;

++ }

++

++ void QGeoPositionInfoSourceWinRT::stopHandler()

++ {

++     qCDebug(lcPositioningWinRT) << __FUNCTION__;

++     Q_D(QGeoPositionInfoSourceWinRT);

++

++     if (!d->positionToken.value)

++         return;

++     d->locator->remove_PositionChanged(d->positionToken);

++     d->locator->remove_StatusChanged(d->statusToken);

++     d->positionToken.value = 0;

++     d->statusToken.value = 0;

++ }

++

++ void QGeoPositionInfoSourceWinRT::requestUpdate(int timeout)

++ {

++     qCDebug(lcPositioningWinRT) << __FUNCTION__ << timeout;

++     Q_D(QGeoPositionInfoSourceWinRT);

++

++     if (init() < 0)

++         return;

++

++     setError(QGeoPositionInfoSource::NoError);

++     if (timeout != 0 && timeout < minimumUpdateInterval()) {

++         d->positionError = QGeoPositionInfoSource::UpdateTimeoutError;

++         emit QGeoPositionInfoSource::errorOccurred(d->positionError);

++         return;

++     }

++

++     if (timeout == 0)

++         timeout = 2*60*1000; // Maximum time for cold start (see Android)

++

++     if (startHandler())

++         d->singleUpdateTimer.start(timeout);

++ }

++

++ void QGeoPositionInfoSourceWinRT::virtualPositionUpdate()

++ {

++     qCDebug(lcPositioningWinRT) << __FUNCTION__;

++     Q_D(QGeoPositionInfoSourceWinRT);

++     QMutexLocker locker(&d->mutex);

++

++     // The operating system did not provide information in time

++     // Hence we send a virtual position update to keep same behavior

++     // between backends.

++     // This only applies to the periodic timer, not for single requests

++     // We can only do this if we received a valid position before

++     if (d->lastPosition.isValid()) {

++         QGeoPositionInfo sent = d->lastPosition;

++         sent.setTimestamp(sent.timestamp().addMSecs(updateInterval()));

++         d->lastPosition = sent;

++         emit positionUpdated(sent);

++     }

++     d->periodicTimer.start();

++ }

++

++ void QGeoPositionInfoSourceWinRT::singleUpdateTimeOut()

++ {

++     Q_D(QGeoPositionInfoSourceWinRT);

++     QMutexLocker locker(&d->mutex);

++

++     if (d->singleUpdateTimer.isActive()) {

++         d->positionError = QGeoPositionInfoSource::UpdateTimeoutError;

++         emit QGeoPositionInfoSource::errorOccurred(d->positionError);

++         if (!d->updatesOngoing)

++             stopHandler();

++     }

++ }

++

++ void QGeoPositionInfoSourceWinRT::updateSynchronized(QGeoPositionInfo currentInfo)

++ {

++     qCDebug(lcPositioningWinRT) << __FUNCTION__ << currentInfo;

++     Q_D(QGeoPositionInfoSourceWinRT);

++     QMutexLocker locker(&d->mutex);

++

++     d->periodicTimer.stop();

++     d->lastPosition = currentInfo;

++

++     if (d->updatesOngoing)

++         d->periodicTimer.start();

++

++     if (d->singleUpdateTimer.isActive()) {

++         d->singleUpdateTimer.stop();

++         if (!d->updatesOngoing)

++         stopHandler();

++     }

++

++     emit positionUpdated(currentInfo);

++ }

++

++ QGeoPositionInfoSource::Error QGeoPositionInfoSourceWinRT::error() const

++ {

++     Q_D(const QGeoPositionInfoSourceWinRT);

++     qCDebug(lcPositioningWinRT) << __FUNCTION__ << d->positionError;

++

++     // If the last encountered error was "Access denied", it is possible that the location service

++     // has been enabled by now so that we are clear again.

++     if ((d->positionError == QGeoPositionInfoSource::AccessError

++          || d->positionError == QGeoPositionInfoSource::UnknownSourceError) && requestAccess())

++         return QGeoPositionInfoSource::NoError;

++

++     return d->positionError;

++ }

++

++ void QGeoPositionInfoSourceWinRT::setError(QGeoPositionInfoSource::Error positionError)

++ {

++     Q_D(QGeoPositionInfoSourceWinRT);

++

++     if (positionError == d->positionError)

++         return;

++

++     qCDebug(lcPositioningWinRT) << __FUNCTION__ << positionError;

++     d->positionError = positionError;

++     if (positionError != QGeoPositionInfoSource::NoError)

++         emit QGeoPositionInfoSource::errorOccurred(positionError);

++ }

++

++ void QGeoPositionInfoSourceWinRT::reactOnError(QGeoPositionInfoSource::Error positionError)

++ {

++     setError(positionError);

++     stopUpdates();

++ }

++

++ HRESULT QGeoPositionInfoSourceWinRT::onPositionChanged(IGeolocator *locator, IPositionChangedEventArgs *args)

++ {

++     qCDebug(lcPositioningWinRT) << __FUNCTION__;

++     Q_UNUSED(locator);

++

++     HRESULT hr;

++     ComPtr<IGeoposition> position;

++     hr = args->get_Position(&position);

++     RETURN_HR_IF_FAILED("Could not access position object.");

++

++     QGeoPositionInfo currentInfo;

++

++     ComPtr<IGeocoordinate> coord;

++     hr = position->get_Coordinate(&coord);

++     if (FAILED(hr))

++         qErrnoWarning(hr, "Could not access coordinate");

++

++     ComPtr<IGeocoordinateWithPoint> pointCoordinate;

++     hr = coord.As(&pointCoordinate);

++     if (FAILED(hr))

++         qErrnoWarning(hr, "Could not cast coordinate.");

++

++     ComPtr<IGeopoint> point;

++     hr = pointCoordinate->get_Point(&point);

++     if (FAILED(hr))

++         qErrnoWarning(hr, "Could not obtain coordinate's point.");

++

++     BasicGeoposition pos;

++     hr = point->get_Position(&pos);

++     if (FAILED(hr))

++         qErrnoWarning(hr, "Could not obtain point's position.");

++

++     DOUBLE lat = pos.Latitude;

++     DOUBLE lon = pos.Longitude;

++     DOUBLE alt = pos.Altitude;

++

++     bool altitudeAvailable = false;

++     ComPtr<IGeoshape> shape;

++     hr = point.As(&shape);

++     if (SUCCEEDED(hr) && shape) {

++         AltitudeReferenceSystem altitudeSystem;

++         hr = shape->get_AltitudeReferenceSystem(&altitudeSystem);

++         if (SUCCEEDED(hr) && altitudeSystem == AltitudeReferenceSystem_Geoid)

++             altitudeAvailable = true;

++     }

++     if (altitudeAvailable)

++         currentInfo.setCoordinate(QGeoCoordinate(lat, lon, alt));

++     else

++         currentInfo.setCoordinate(QGeoCoordinate(lat, lon));

++

++     DOUBLE accuracy;

++     hr = coord->get_Accuracy(&accuracy);

++     if (SUCCEEDED(hr))

++         currentInfo.setAttribute(QGeoPositionInfo::HorizontalAccuracy, accuracy);

++

++     IReference<double> *altAccuracy;

++     hr = coord->get_AltitudeAccuracy(&altAccuracy);

++     if (SUCCEEDED(hr) && altAccuracy) {

++         double value;

++         hr = altAccuracy->get_Value(&value);

++         currentInfo.setAttribute(QGeoPositionInfo::VerticalAccuracy, value);

++     }

++

++     IReference<double> *speed;

++     hr = coord->get_Speed(&speed);

++     if (SUCCEEDED(hr) && speed) {

++         double value;

++         hr = speed->get_Value(&value);

++         currentInfo.setAttribute(QGeoPositionInfo::GroundSpeed, value);

++     }

++

++     IReference<double> *heading;

++     hr = coord->get_Heading(&heading);

++     if (SUCCEEDED(hr) && heading) {

++         double value;

++         hr = heading->get_Value(&value);

++         double mod = 0;

++         value = modf(value, &mod);

++         value += static_cast<int>(mod) % 360;

++         if (value >=0 && value <= 359) // get_Value might return nan/-nan

++             currentInfo.setAttribute(QGeoPositionInfo::Direction, value);

++     }

++

++     DateTime dateTime;

++     hr = coord->get_Timestamp(&dateTime);

++

++     if (dateTime.UniversalTime > 0) {

++         ULARGE_INTEGER uLarge;

++         uLarge.QuadPart = dateTime.UniversalTime;

++         FILETIME fileTime;

++         fileTime.dwHighDateTime = uLarge.HighPart;

++         fileTime.dwLowDateTime = uLarge.LowPart;

++         SYSTEMTIME systemTime;

++         if (FileTimeToSystemTime(&fileTime, &systemTime)) {

++             currentInfo.setTimestamp(QDateTime(QDate(systemTime.wYear, systemTime.wMonth,

++                                                      systemTime.wDay),

++                                                QTime(systemTime.wHour, systemTime.wMinute,

++                                                      systemTime.wSecond, systemTime.wMilliseconds),

++                                                QTimeZone::UTC));

++         }

++     }

++

++     emit nativePositionUpdate(currentInfo);

++

++     return S_OK;

++ }

++

++ static inline bool isDisabledStatus(PositionStatus status)

++ {

++     return status == PositionStatus_NoData || status == PositionStatus_Disabled

++             || status == PositionStatus_NotAvailable;

++ }

++

++ HRESULT QGeoPositionInfoSourceWinRT::onStatusChanged(IGeolocator *, IStatusChangedEventArgs *args)

++ {

++     Q_D(QGeoPositionInfoSourceWinRT);

++

++     const PositionStatus oldStatus = d->positionStatus;

++     HRESULT hr = args->get_Status(&d->positionStatus);

++     RETURN_HR_IF_FAILED("Could not obtain position status");

++     qCDebug(lcPositioningWinRT) << __FUNCTION__ << d->positionStatus;

++     QGeoPositionInfoSource::Error error = QGeoPositionInfoSource::NoError;

++     switch (d->positionStatus) {

++     case PositionStatus::PositionStatus_NotAvailable:

++         error = QGeoPositionInfoSource::UnknownSourceError;

++         break;

++     case PositionStatus::PositionStatus_Disabled:

++         error = QGeoPositionInfoSource::AccessError;

++         break;

++     case PositionStatus::PositionStatus_NoData:

++         error = QGeoPositionInfoSource::ClosedError;

++         break;

++     }

++     if (error != QGeoPositionInfoSource::NoError) {

++         QMetaObject::invokeMethod(this, "reactOnError", Qt::QueuedConnection,

++                                   Q_ARG(QGeoPositionInfoSource::Error,

++                                         QGeoPositionInfoSource::UnknownSourceError));

++     }

++

++     if (isDisabledStatus(oldStatus) != isDisabledStatus(d->positionStatus))

++         emit supportedPositioningMethodsChanged();

++

++     return S_OK;

++ }

++

++ bool QGeoPositionInfoSourceWinRT::requestAccess() const

++ {

++     Q_D(const QGeoPositionInfoSourceWinRT);

++     qCDebug(lcPositioningWinRT) << __FUNCTION__;

++     GeolocationAccessStatus accessStatus;

++

++     ComPtr<IAsyncOperation<GeolocationAccessStatus>> op;

++     HRESULT hr = [&op, d]() {

++         HRESULT hr;

++         if (!d->statics) {

++             hr = RoGetActivationFactory(HString::MakeReference(RuntimeClass_Windows_Devices_Geolocation_Geolocator).Get(),

++                                         IID_PPV_ARGS(&d->statics));

++             RETURN_HR_IF_FAILED("Could not access Geolocation Statics.");

++         }

++

++         hr = d->statics->RequestAccessAsync(&op);

++         return hr;

++     }();

++     if (FAILED(hr)) {

++         qCDebug(lcPositioningWinRT) << __FUNCTION__ << "Requesting access from Xaml thread failed";

++         return false;

++     }

++

++     await(op, &accessStatus);

++     return accessStatus == GeolocationAccessStatus_Allowed;

++ }

++

++ QT_END_NAMESPACE

Revision control