qgeopositioninfosource_winrt.cpp

Go to the documentation of this file.

// 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