Fixed a compile warning

[situare] / src / gps / gpspositionprivate.cpp

diff --git a/src/gps/gpspositionprivate.cpp b/src/gps/gpspositionprivate.cpp
index e194f56..50c9270 100644 (file)
--- a/src/gps/gpspositionprivate.cpp
+++ b/src/gps/gpspositionprivate.cpp
@@ -25,14 +25,15 @@
 #include <QDebug>
 #include <QTimer>
 
+#include "error.h"
 #include "gpscommon.h"
 #include "gpsposition.h"
 #include "gpspositionprivate.h"
-#include "liblocationwrapper.h"
 
 GPSPositionPrivate::GPSPositionPrivate(QObject *parent)
     : QObject(parent),
       m_gpsSource(0),
+      m_initialized(false),
       m_running(false),
       m_updateInterval(DEFAULT_UPDATE_INTERVAL)
 {
@@ -41,6 +42,19 @@ GPSPositionPrivate::GPSPositionPrivate(QObject *parent)
     m_parent = static_cast<GPSPosition*>(parent);
 }
 
+void GPSPositionPrivate::setPowerSave(bool enabled)
+{
+    qDebug() << __PRETTY_FUNCTION__;
+    Q_UNUSED(enabled)
+}
+
+bool GPSPositionPrivate::isInitialized() const
+{
+    qDebug() << __PRETTY_FUNCTION__;
+
+    return m_initialized;
+}
+
 void GPSPositionPrivate::setMode(GPSPosition::Mode mode, const QString &filePath)
 {
     qDebug() << __PRETTY_FUNCTION__;
@@ -51,26 +65,28 @@ void GPSPositionPrivate::setMode(GPSPosition::Mode mode, const QString &filePath
     }
 
     if (mode == GPSPosition::Default) {
-        m_gpsSource = new LiblocationWrapper(this);
+        m_gpsSource = QGeoPositionInfoSource::createDefaultSource(this);
 
         if (!m_gpsSource) {
-            emit m_parent->error(tr("Unable to use GPS"));
+            m_initialized = false;
+            emit m_parent->error(ErrorContext::SITUARE, SituareError::GPS_INITIALIZATION_FAILED);
             return;
         }
     }
     else if (mode == GPSPosition::Simulation) {
-//        QNmeaPositionInfoSource *nmeaSource = new QNmeaPositionInfoSource(
-//                QNmeaPositionInfoSource::SimulationMode, this);
-//        QFile *logFile = new QFile(filePath, this);
+        QNmeaPositionInfoSource *nmeaSource = new QNmeaPositionInfoSource(
+                QNmeaPositionInfoSource::SimulationMode, this);
+        QFile *logFile = new QFile(filePath, this);
 
-//        nmeaSource->setDevice(logFile);
-//        m_gpsSource = nmeaSource;
+        nmeaSource->setDevice(logFile);
+        m_gpsSource = nmeaSource;
     }
 
     if (m_gpsSource) {
-        connect(m_gpsSource, SIGNAL(positionUpdated(const GeoPositionInfo &)),
-                this, SLOT(positionUpdated(const GeoPositionInfo &)));
-        //connect(m_gpsSource, SIGNAL(updateTimeout()), this, SLOT(updateTimeout()));
+        m_initialized = true;
+        connect(m_gpsSource, SIGNAL(positionUpdated(const QGeoPositionInfo &)),
+                this, SLOT(positionUpdated(const QGeoPositionInfo &)));
+        connect(m_gpsSource, SIGNAL(updateTimeout()), this, SLOT(updateTimeout()));
 
         m_gpsSource->setUpdateInterval(m_updateInterval);
     }
@@ -80,7 +96,7 @@ void GPSPositionPrivate::start()
 {
     qDebug() << __PRETTY_FUNCTION__;
 
-    if (m_gpsSource && !isRunning()) {
+    if (m_initialized && !isRunning()) {
         m_gpsSource->startUpdates();
         m_running = true;
     }
@@ -90,46 +106,56 @@ void GPSPositionPrivate::stop()
 {
     qDebug() << __PRETTY_FUNCTION__;
 
-    if (m_gpsSource && isRunning()) {
+    if (m_initialized && isRunning()) {
         m_gpsSource->stopUpdates();
         m_running = false;
     }
 }
 
-bool GPSPositionPrivate::isRunning()
+bool GPSPositionPrivate::isRunning() const
 {
     qDebug() << __PRETTY_FUNCTION__;
 
     return m_running;
 }
 
-QPointF GPSPositionPrivate::lastPosition()
+GeoCoordinate GPSPositionPrivate::lastPosition() const
 {
-    GeoPositionInfo positionInfo = m_gpsSource->lastKnownPosition();
-
-    return QPointF(positionInfo.longitude(), positionInfo.latitude());
+    QGeoCoordinate coordinate = m_gpsSource->lastKnownPosition().coordinate();
+    return GeoCoordinate(coordinate.latitude(), coordinate.longitude());
 }
 
 void GPSPositionPrivate::requestLastPosition()
 {
     qDebug() << __PRETTY_FUNCTION__;
 
-    GeoPositionInfo positionInfo = m_gpsSource->lastKnownPosition();
+    QGeoCoordinate coordinate = m_gpsSource->lastKnownPosition().coordinate();
 
-    if (positionInfo.isValid()) {
-        emit m_parent->position(QPointF(positionInfo.longitude(), positionInfo.latitude()),
-                      accuracy(m_gpsSource->lastKnownPosition()));
+    if (coordinate.isValid()) {
+        emit m_parent->position(GeoCoordinate(coordinate.latitude(), coordinate.longitude()),
+                                accuracy(m_gpsSource->lastKnownPosition()));
     }
 }
 
-void GPSPositionPrivate::positionUpdated(const GeoPositionInfo &positionInfo)
+void GPSPositionPrivate::requestUpdate()
+{
+    qDebug() << __PRETTY_FUNCTION__;
+
+    if (!isRunning())
+        start();
+
+    m_gpsSource->requestUpdate();
+}
+
+void GPSPositionPrivate::positionUpdated(const QGeoPositionInfo &positionInfo)
 {
     qDebug() << __PRETTY_FUNCTION__ << positionInfo;
 
-    if (positionInfo.coordinate().isValid()) {
-        emit m_parent->position(QPointF(positionInfo.longitude(),
-                              positionInfo.latitude()),
-                      accuracy(positionInfo));
+    const QGeoCoordinate &coordinate = positionInfo.coordinate();
+
+    if (coordinate.isValid()) {
+        emit m_parent->position(GeoCoordinate(coordinate.latitude(), coordinate.longitude()),
+                                accuracy(positionInfo));
     }
 }
 
@@ -150,15 +176,12 @@ void GPSPositionPrivate::setUpdateInterval(int interval)
     }
 }
 
-qreal GPSPositionPrivate::accuracy(const GeoPositionInfo &positionInfo)
+qreal GPSPositionPrivate::accuracy(const QGeoPositionInfo &positionInfo)
 {
     qDebug() << __PRETTY_FUNCTION__;
 
-    if (!positionInfo.timestamp().isValid())
-        return GPS_ACCURACY_UNDEFINED;
-
-    if (positionInfo.hasAttribute(GeoPositionInfo::HorizontalAccuracy))
-        return positionInfo.attribute(GeoPositionInfo::HorizontalAccuracy);
+    if (positionInfo.hasAttribute(QGeoPositionInfo::HorizontalAccuracy))
+        return positionInfo.attribute(QGeoPositionInfo::HorizontalAccuracy);
     else
         return GPS_ACCURACY_UNDEFINED;
 }