From ccda0ec5e288140899bd14955b078563387b63df Mon Sep 17 00:00:00 2001 From: Maurice Kalinowski Date: Thu, 27 Mar 2014 13:24:24 +0100 Subject: Implement WinRT plugin for positioning [ChangeLog][QtPositioning][QGeoPositionInfoSource] WinRT backend added. Change-Id: I00e7725a082aa485c3ab5afcaebd20344b48e07d Reviewed-by: Alex Blasche --- src/plugins/position/position.pro | 1 + src/plugins/position/winrt/plugin.json | 8 + .../winrt/qgeopositioninfosource_winrt.cpp | 392 +++++++++++++++++++++ .../winrt/qgeopositioninfosource_winrt_p.h | 117 ++++++ .../winrt/qgeopositioninfosourcefactory_winrt.cpp | 60 ++++ .../winrt/qgeopositioninfosourcefactory_winrt.h | 64 ++++ src/plugins/position/winrt/winrt.pro | 15 + 7 files changed, 657 insertions(+) create mode 100644 src/plugins/position/winrt/plugin.json create mode 100644 src/plugins/position/winrt/qgeopositioninfosource_winrt.cpp create mode 100644 src/plugins/position/winrt/qgeopositioninfosource_winrt_p.h create mode 100644 src/plugins/position/winrt/qgeopositioninfosourcefactory_winrt.cpp create mode 100644 src/plugins/position/winrt/qgeopositioninfosourcefactory_winrt.h create mode 100644 src/plugins/position/winrt/winrt.pro diff --git a/src/plugins/position/position.pro b/src/plugins/position/position.pro index 0e2f9a5d..636bcc54 100644 --- a/src/plugins/position/position.pro +++ b/src/plugins/position/position.pro @@ -6,6 +6,7 @@ qtHaveModule(simulator):SUBDIRS += simulator blackberry:SUBDIRS += blackberry ios:SUBDIRS += corelocation android:!android-no-sdk:SUBDIRS += android +winrt:SUBDIRS += winrt SUBDIRS += \ positionpoll diff --git a/src/plugins/position/winrt/plugin.json b/src/plugins/position/winrt/plugin.json new file mode 100644 index 00000000..5bb21702 --- /dev/null +++ b/src/plugins/position/winrt/plugin.json @@ -0,0 +1,8 @@ +{ + "Keys": ["winrt"], + "Provider": "winrt", + "Position": true, + "Satellite": false, + "Monitor" : false, + "Priority": 1000 +} diff --git a/src/plugins/position/winrt/qgeopositioninfosource_winrt.cpp b/src/plugins/position/winrt/qgeopositioninfosource_winrt.cpp new file mode 100644 index 00000000..f979a9df --- /dev/null +++ b/src/plugins/position/winrt/qgeopositioninfosource_winrt.cpp @@ -0,0 +1,392 @@ +/**************************************************************************** +** +** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/legal +** +** This file is part of the QtPositioning module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and Digia. For licensing terms and +** conditions see http://qt.digia.com/licensing. For further information +** use the contact form at http://qt.digia.com/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Digia gives you certain additional +** rights. These rights are described in the Digia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qgeopositioninfosource_winrt_p.h" + +#include + +#include +#include +#include + +using namespace Microsoft::WRL; +using namespace Microsoft::WRL::Wrappers; +using namespace ABI::Windows::Devices::Geolocation; +using namespace ABI::Windows::Foundation; +using namespace ABI::Windows::System; + +typedef ITypedEventHandler GeoLocatorPositionHandler; +typedef ITypedEventHandler GeoLocatorStatusHandler; + +QT_BEGIN_NAMESPACE + +QGeoPositionInfoSourceWinrt::QGeoPositionInfoSourceWinrt(QObject *parent) + : QGeoPositionInfoSource(parent) + , m_positionError(QGeoPositionInfoSource::NoError) + , m_updatesOngoing(false) +{ + HRESULT hr = RoActivateInstance(HString::MakeReference(RuntimeClass_Windows_Devices_Geolocation_Geolocator).Get(), + &m_locator); + + if (FAILED(hr)) { + setError(QGeoPositionInfoSource::UnknownSourceError); + qErrnoWarning(hr, "Could not initialize native location services"); + return; + } + + hr = m_locator->put_ReportInterval(minimumUpdateInterval()); + if (FAILED(hr)) { + setError(QGeoPositionInfoSource::UnknownSourceError); + qErrnoWarning(hr, "Could not initialize report interval"); + return; + } + hr = m_locator->put_DesiredAccuracy(PositionAccuracy::PositionAccuracy_High); + if (FAILED(hr)) { + setError(QGeoPositionInfoSource::UnknownSourceError); + qErrnoWarning(hr, "Could not initialize desired accuracy"); + return; + } + + m_positionToken.value = 0; + + m_periodicTimer.setSingleShot(true); + m_periodicTimer.setInterval(minimumUpdateInterval()); + connect(&m_periodicTimer, SIGNAL(timeout()), this, SLOT(virtualPositionUpdate())); + + m_singleUpdateTimer.setSingleShot(true); + connect(&m_singleUpdateTimer, SIGNAL(timeout()), this, SLOT(singleUpdateTimeOut())); + + setPreferredPositioningMethods(QGeoPositionInfoSource::AllPositioningMethods); +} + +QGeoPositionInfoSourceWinrt::~QGeoPositionInfoSourceWinrt() +{ +} + +QGeoPositionInfo QGeoPositionInfoSourceWinrt::lastKnownPosition(bool fromSatellitePositioningMethodsOnly) const +{ + Q_UNUSED(fromSatellitePositioningMethodsOnly) + return m_lastPosition; +} + +QGeoPositionInfoSource::PositioningMethods QGeoPositionInfoSourceWinrt::supportedPositioningMethods() const +{ + PositionStatus status; + HRESULT hr = m_locator->get_LocationStatus(&status); + if (FAILED(hr)) + return QGeoPositionInfoSource::NoPositioningMethods; + + switch (status) { + case PositionStatus::PositionStatus_NoData: + case PositionStatus::PositionStatus_Disabled: + case PositionStatus::PositionStatus_NotAvailable: + return QGeoPositionInfoSource::NoPositioningMethods; + } + + return QGeoPositionInfoSource::AllPositioningMethods; +} + +void QGeoPositionInfoSourceWinrt::setPreferredPositioningMethods(QGeoPositionInfoSource::PositioningMethods methods) +{ + PositioningMethods previousPreferredPositioningMethods = preferredPositioningMethods(); + QGeoPositionInfoSource::setPreferredPositioningMethods(methods); + if (previousPreferredPositioningMethods == preferredPositioningMethods()) + return; + + bool needsRestart = m_positionToken.value != 0; + + if (needsRestart) + stopHandler(); + + HRESULT hr; + if (methods & PositioningMethod::SatellitePositioningMethods) + hr = m_locator->put_DesiredAccuracy(PositionAccuracy::PositionAccuracy_High); + else + hr = m_locator->put_DesiredAccuracy(PositionAccuracy::PositionAccuracy_Default); + + if (FAILED(hr)) { + qErrnoWarning(hr, "Could not set positioning accuracy"); + return; + } + + if (needsRestart) + startHandler(); +} + +void QGeoPositionInfoSourceWinrt::setUpdateInterval(int msec) +{ + // If msec is 0 we send updates as data becomes available, otherwise we force msec to be equal + // to or larger than the minimum update interval. + if (msec != 0 && msec < minimumUpdateInterval()) + msec = minimumUpdateInterval(); + + HRESULT hr = m_locator->put_ReportInterval(msec); + if (FAILED(hr)) { + setError(QGeoPositionInfoSource::UnknownSourceError); + qErrnoWarning(hr, "Failed to set update interval"); + return; + } + if (msec != 0) + m_periodicTimer.setInterval(msec); + else + m_periodicTimer.setInterval(minimumUpdateInterval()); + + QGeoPositionInfoSource::setUpdateInterval(msec); +} + +int QGeoPositionInfoSourceWinrt::minimumUpdateInterval() const +{ + // We use one second to reduce potential timer events + // in case the platform itself stops reporting + return 1000; +} + +void QGeoPositionInfoSourceWinrt::startUpdates() +{ + if (m_updatesOngoing) + return; + + if (!startHandler()) + return; + m_updatesOngoing = true; + m_periodicTimer.start(); +} + +void QGeoPositionInfoSourceWinrt::stopUpdates() +{ + stopHandler(); + m_updatesOngoing = false; + m_periodicTimer.stop(); +} + +bool QGeoPositionInfoSourceWinrt::startHandler() +{ + // Check if already attached + if (m_positionToken.value != 0) + return true; + + if (preferredPositioningMethods() == QGeoPositionInfoSource::NoPositioningMethods) { + setError(QGeoPositionInfoSource::UnknownSourceError); + return false; + } + + if (!checkNativeState()) + return false; + + HRESULT hr = m_locator->add_PositionChanged(Callback(this, + &QGeoPositionInfoSourceWinrt::onPositionChanged).Get(), + &m_positionToken); + + if (FAILED(hr)) { + setError(QGeoPositionInfoSource::UnknownSourceError); + qErrnoWarning(hr, "Could not add position handler"); + return false; + } + return true; +} + +void QGeoPositionInfoSourceWinrt::stopHandler() +{ + if (!m_positionToken.value) + return; + m_locator->remove_PositionChanged(m_positionToken); + m_positionToken.value = 0; +} + +void QGeoPositionInfoSourceWinrt::requestUpdate(int timeout) +{ + if (timeout < minimumUpdateInterval()) { + emit updateTimeout(); + return; + } + startHandler(); + m_singleUpdateTimer.start(timeout); +} + +void QGeoPositionInfoSourceWinrt::virtualPositionUpdate() +{ + // Need to check if services are still running and ok + if (!checkNativeState()) { + stopUpdates(); + return; + } + + // 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 (m_lastPosition.isValid()) { + QGeoPositionInfo sent = m_lastPosition; + sent.setTimestamp(QDateTime::currentDateTime()); + m_lastPosition = sent; + emit positionUpdated(sent); + } + m_periodicTimer.start(); +} + +void QGeoPositionInfoSourceWinrt::singleUpdateTimeOut() +{ + emit updateTimeout(); + if (!m_updatesOngoing) + stopHandler(); +} + +QGeoPositionInfoSource::Error QGeoPositionInfoSourceWinrt::error() const +{ + return m_positionError; +} + +void QGeoPositionInfoSourceWinrt::setError(QGeoPositionInfoSource::Error positionError) +{ + if (positionError == m_positionError) + return; + m_positionError = positionError; + emit QGeoPositionInfoSource::error(positionError); +} + +bool QGeoPositionInfoSourceWinrt::checkNativeState() +{ + PositionStatus status; + HRESULT hr = m_locator->get_LocationStatus(&status); + if (FAILED(hr)) { + setError(QGeoPositionInfoSource::UnknownSourceError); + qErrnoWarning(hr, "Could not query status"); + return false; + } + + bool result = false; + switch (status) { + case PositionStatus::PositionStatus_NotAvailable: + setError(QGeoPositionInfoSource::UnknownSourceError); + break; + case PositionStatus::PositionStatus_Disabled: + case PositionStatus::PositionStatus_NoData: + setError(QGeoPositionInfoSource::ClosedError); + break; + default: + setError(QGeoPositionInfoSource::NoError); + result = true; + break; + } + return result; +} + +HRESULT QGeoPositionInfoSourceWinrt::onPositionChanged(IGeolocator *locator, IPositionChangedEventArgs *args) +{ + Q_UNUSED(locator); + + m_periodicTimer.stop(); + + HRESULT hr; + ComPtr pos; + hr = args->get_Position(&pos); + if (FAILED(hr)) + qErrnoWarning(hr, "Could not access position object"); + + QGeoPositionInfo currentInfo; + + ComPtr coord; + hr = pos->get_Coordinate(&coord); + if (FAILED(hr)) + qErrnoWarning(hr, "Could not access coordinate"); + + DOUBLE lat; + hr = coord->get_Latitude(&lat); + if (FAILED(hr)) + qErrnoWarning(hr, "Could not access latitude"); + + DOUBLE lon; + hr = coord->get_Longitude(&lon); + if (FAILED(hr)) + qErrnoWarning(hr, "Could not access longitude"); + + // Depending on data source altitude can + // be identified or not + IReference *alt; + hr = coord->get_Altitude(&alt); + if (SUCCEEDED(hr) && alt) { + double altd; + hr = alt->get_Value(&altd); + currentInfo.setCoordinate(QGeoCoordinate(lat, lon, altd)); + } else { + currentInfo.setCoordinate(QGeoCoordinate(lat, lon)); + } + + DOUBLE accuracy; + hr = coord->get_Accuracy(&accuracy); + if (SUCCEEDED(hr)) + currentInfo.setAttribute(QGeoPositionInfo::HorizontalAccuracy, accuracy); + + IReference *altAccuracy; + hr = coord->get_AltitudeAccuracy(&altAccuracy); + if (SUCCEEDED(hr) && altAccuracy) { + double value; + hr = alt->get_Value(&value); + currentInfo.setAttribute(QGeoPositionInfo::VerticalAccuracy, value); + } + + IReference *speed; + hr = coord->get_Speed(&speed); + if (SUCCEEDED(hr) && speed) { + double value; + hr = speed->get_Value(&value); + currentInfo.setAttribute(QGeoPositionInfo::GroundSpeed, value); + } + + currentInfo.setTimestamp(QDateTime::currentDateTime()); + + m_lastPosition = currentInfo; + + if (m_updatesOngoing) + m_periodicTimer.start(); + + if (m_singleUpdateTimer.isActive()) { + m_singleUpdateTimer.stop(); + if (!m_updatesOngoing) + stopHandler(); + } + + emit positionUpdated(currentInfo); + return S_OK; +} + +QT_END_NAMESPACE diff --git a/src/plugins/position/winrt/qgeopositioninfosource_winrt_p.h b/src/plugins/position/winrt/qgeopositioninfosource_winrt_p.h new file mode 100644 index 00000000..9f67a990 --- /dev/null +++ b/src/plugins/position/winrt/qgeopositioninfosource_winrt_p.h @@ -0,0 +1,117 @@ +/**************************************************************************** +** +** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/legal +** +** This file is part of the QtPositioning module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and Digia. For licensing terms and +** conditions see http://qt.digia.com/licensing. For further information +** use the contact form at http://qt.digia.com/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Digia gives you certain additional +** rights. These rights are described in the Digia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QGEOPOSITIONINFOSOURCEWINRT_H +#define QGEOPOSITIONINFOSOURCEWINRT_H + +#include "qgeopositioninfosource.h" +#include "qgeopositioninfo.h" + +#include + +#include +#include + +namespace ABI { + namespace Windows { + namespace Devices { + namespace Geolocation{ + struct IGeolocator; + struct IPositionChangedEventArgs; + struct IStatusChangedEventArgs; + } + } + } +} + +QT_BEGIN_NAMESPACE + +class QGeoPositionInfoSourceWinrt : public QGeoPositionInfoSource +{ + Q_OBJECT +public: + QGeoPositionInfoSourceWinrt(QObject *parent = 0); + ~QGeoPositionInfoSourceWinrt(); + + QGeoPositionInfo lastKnownPosition(bool fromSatellitePositioningMethodsOnly = false) const; + PositioningMethods supportedPositioningMethods() const; + + void setPreferredPositioningMethods(PositioningMethods methods); + + void setUpdateInterval(int msec); + int minimumUpdateInterval() const; + Error error() const; + + HRESULT onPositionChanged(ABI::Windows::Devices::Geolocation::IGeolocator *locator, + ABI::Windows::Devices::Geolocation::IPositionChangedEventArgs *args); + +public slots: + void startUpdates(); + void stopUpdates(); + + void requestUpdate(int timeout = 0); + +private slots: + void stopHandler(); + void virtualPositionUpdate(); + void singleUpdateTimeOut(); +private: + bool startHandler(); + + Q_DISABLE_COPY(QGeoPositionInfoSourceWinrt) + void setError(QGeoPositionInfoSource::Error positionError); + bool checkNativeState(); + + Microsoft::WRL::ComPtr m_locator; + EventRegistrationToken m_positionToken; + + QGeoPositionInfo m_lastPosition; + QGeoPositionInfoSource::Error m_positionError; + + //EventRegistrationToken m_StatusToken; + QTimer m_periodicTimer; + QTimer m_singleUpdateTimer; + bool m_updatesOngoing; +}; + +QT_END_NAMESPACE + +#endif // QGEOPOSITIONINFOSOURCEWINRT_H diff --git a/src/plugins/position/winrt/qgeopositioninfosourcefactory_winrt.cpp b/src/plugins/position/winrt/qgeopositioninfosourcefactory_winrt.cpp new file mode 100644 index 00000000..be51cd20 --- /dev/null +++ b/src/plugins/position/winrt/qgeopositioninfosourcefactory_winrt.cpp @@ -0,0 +1,60 @@ +/**************************************************************************** +** +** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/legal +** +** This file is part of the QtPositioning module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and Digia. For licensing terms and +** conditions see http://qt.digia.com/licensing. For further information +** use the contact form at http://qt.digia.com/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Digia gives you certain additional +** rights. These rights are described in the Digia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qgeopositioninfosourcefactory_winrt.h" +#include "qgeopositioninfosource_winrt_p.h" + +QGeoPositionInfoSource *QGeoPositionInfoSourceFactoryWinrt::positionInfoSource(QObject *parent) +{ + return new QGeoPositionInfoSourceWinrt(parent); +} + +QGeoSatelliteInfoSource *QGeoPositionInfoSourceFactoryWinrt::satelliteInfoSource(QObject *parent) +{ + Q_UNUSED(parent); + return 0; +} + +QGeoAreaMonitorSource *QGeoPositionInfoSourceFactoryWinrt::areaMonitor(QObject *parent) +{ + Q_UNUSED(parent); + return 0; +} diff --git a/src/plugins/position/winrt/qgeopositioninfosourcefactory_winrt.h b/src/plugins/position/winrt/qgeopositioninfosourcefactory_winrt.h new file mode 100644 index 00000000..41ba1d16 --- /dev/null +++ b/src/plugins/position/winrt/qgeopositioninfosourcefactory_winrt.h @@ -0,0 +1,64 @@ +/**************************************************************************** +** +** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/legal +** +** This file is part of the QtPositioning module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and Digia. For licensing terms and +** conditions see http://qt.digia.com/licensing. For further information +** use the contact form at http://qt.digia.com/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Digia gives you certain additional +** rights. These rights are described in the Digia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QGEOPOSITIONINFOSOURCEFACTORY_WINRT_H +#define QGEOPOSITIONINFOSOURCEFACTORY_WINRT_H + +#include +#include + +QT_BEGIN_NAMESPACE + +class QGeoPositionInfoSourceFactoryWinrt : public QObject, public QGeoPositionInfoSourceFactory +{ + Q_OBJECT + Q_PLUGIN_METADATA(IID "org.qt-project.qt.position.sourcefactory/5.0" + FILE "plugin.json") + Q_INTERFACES(QGeoPositionInfoSourceFactory) +public: + QGeoPositionInfoSource *positionInfoSource(QObject *parent); + QGeoSatelliteInfoSource *satelliteInfoSource(QObject *parent); + QGeoAreaMonitorSource *areaMonitor(QObject *parent); +}; + +QT_END_NAMESPACE + +#endif // QGEOPOSITIONINFOSOURCEFACTORY_WINRT_H diff --git a/src/plugins/position/winrt/winrt.pro b/src/plugins/position/winrt/winrt.pro new file mode 100644 index 00000000..2632d4f8 --- /dev/null +++ b/src/plugins/position/winrt/winrt.pro @@ -0,0 +1,15 @@ +TARGET = qtposition_winrt +QT = core positioning + +PLUGIN_TYPE = position +load(qt_plugin) + +INCLUDEPATH += $$QT.location.includes + +SOURCES += qgeopositioninfosource_winrt.cpp \ + qgeopositioninfosourcefactory_winrt.cpp +HEADERS += qgeopositioninfosource_winrt_p.h \ + qgeopositioninfosourcefactory_winrt.h + +OTHER_FILES += \ + plugin.json -- cgit v1.2.3