QtLocationPlugin: Split CacheWorker & CacheDatabase

Author: HTRamsey

src/QGCApplication.h

@@ -101,6 +101,9 @@ class QGCApplication : public QApplication
     /// Although public, these methods are internal and should only be called by UnitTest code
     QQmlApplicationEngine *qmlAppEngine() const { return _qmlAppEngine; }
 
+    /// Get current language
+    QLocale getCurrentLanguage() const { return _locale; }
+
 signals:
     void languageChanged(const QLocale locale);
 
@@ -109,9 +112,6 @@ public slots:
 
     void qmlAttemptWindowClose();
 
-    /// Get current language
-    QLocale getCurrentLanguage() const { return _locale; }
-
     /// Show non-modal vehicle message to the user
     void showCriticalVehicleMessage(const QString &message);
 

src/QtLocationPlugin/CMakeLists.txt

@@ -27,6 +27,8 @@ qt_add_plugin(QGCLocation
     QGCMapUrlEngine.cpp
     QGCMapUrlEngine.h
     QGCTile.h
+    QGCTileCacheDatabase.cpp
+    QGCTileCacheDatabase.h
     QGCTileCacheWorker.cpp
     QGCTileCacheWorker.h
     QGCTileSet.h

src/QtLocationPlugin/QGCCacheTile.h

@@ -9,37 +9,29 @@
 
 #pragma once
 
-#include <QtCore/QString>
 #include <QtCore/QByteArray>
 #include <QtCore/QMetaType>
+#include <QtCore/QString>
 
-class QGCCacheTile
+struct QGCCacheTile
 {
-public:
-    QGCCacheTile(const QString &hash, const QByteArray &img, const QString &format, const QString &type, quint64 tileSet = UINT64_MAX)
-        : m_tileSet(tileSet)
-        , m_hash(hash)
-        , m_img(img)
-        , m_format(format)
-        , m_type(type)
+    QGCCacheTile(const QString &hash_, const QByteArray &img_, const QString &format_, const QString &type_, quint64 tileSet_ = UINT64_MAX)
+        : tileSet(tileSet_)
+        , hash(hash_)
+        , img(img_)
+        , format(format_)
+        , type(type_)
     {}
-    QGCCacheTile(const QString &hash, quint64 tileSet)
-        : m_tileSet(tileSet)
-        , m_hash(hash)
+    QGCCacheTile(const QString &hash_, quint64 tileSet_)
+        : tileSet(tileSet_)
+        , hash(hash_)
     {}
-    ~QGCCacheTile() = default;
-
-    quint64 tileSet() const { return m_tileSet; }
-    const QString &hash() const { return m_hash; }
-    const QByteArray &img() const { return m_img; }
-    const QString &format() const { return m_format; }
-    const QString &type() const { return m_type; }
 
-private:
-    const quint64 m_tileSet = 0;
-    const QString m_hash;
-    const QByteArray m_img;
-    const QString m_format;
-    const QString m_type;
+    const quint64 tileSet = 0;
+    const QString hash;
+    const QByteArray img;
+    const QString format;
+    const QString type;
 };
 Q_DECLARE_METATYPE(QGCCacheTile)
+Q_DECLARE_METATYPE(QGCCacheTile*)

src/QtLocationPlugin/QGCCachedTileSet.cpp

@@ -7,42 +7,34 @@
  *
  ****************************************************************************/
 
-/**
- * @file
- *   @brief Map Tile Set
- *
- *   @author Gus Grubba <[email protected]>
- *
- */
-
 #include "QGCCachedTileSet.h"
 
+#include <QtNetwork/QNetworkProxy>
+
 #include "ElevationMapProvider.h"
+#include <QGCApplication.h>
+#include <QGCFileDownload.h>
+#include <QGCLoggingCategory.h>
 #include "QGCMapEngine.h"
 #include "QGCMapEngineManager.h"
 #include "QGCMapTasks.h"
 #include "QGCMapUrlEngine.h"
 #include "QGeoFileTileCacheQGC.h"
 #include "QGeoTileFetcherQGC.h"
 
-#include <QGCApplication.h>
-#include <QGCFileDownload.h>
-#include <QGCLoggingCategory.h>
-
-#include <QtNetwork/QNetworkProxy>
 
 QGC_LOGGING_CATEGORY(QGCCachedTileSetLog, "qgc.qtlocation.qgccachedtileset")
 
 QGCCachedTileSet::QGCCachedTileSet(const QString &name, QObject *parent)
     : QObject(parent)
     , _name(name)
 {
-    // qCDebug(QGCCachedTileSetLog) << Q_FUNC_INFO << this;
+    qCDebug(QGCCachedTileSetLog) << this;
 }
 
 QGCCachedTileSet::~QGCCachedTileSet()
 {
-    // qCDebug(QGCCachedTileSetLog) << Q_FUNC_INFO << this;
+    qCDebug(QGCCachedTileSetLog) << this;
 }
 
 QString QGCCachedTileSet::downloadStatus() const
@@ -118,7 +110,7 @@ void QGCCachedTileSet::_tileListFetched(const QQueue<QGCTile*> &tiles)
 #endif
     }
 
-    (void) _tilesToDownload.append(tiles);
+    _tilesToDownload.append(tiles);
     _prepareDownload();
 }
 
@@ -132,7 +124,7 @@ void QGCCachedTileSet::_doneWithDownload()
         if (_savedTileSize != 0) {
             avg = _savedTileSize / _savedTileCount;
         } else {
-            qCWarning(QGCCachedTileSetLog) << Q_FUNC_INFO << "_savedTileSize=0";
+            qCWarning(QGCCachedTileSetLog) << "_savedTileSize=0";
         }
 
         setUniqueTileSize(_uniqueTileCount * avg);
@@ -160,17 +152,17 @@ void QGCCachedTileSet::_prepareDownload()
         }
 
         QGCTile* const tile = _tilesToDownload.dequeue();
-        const int mapId = UrlFactory::getQtMapIdFromProviderType(tile->type());
-        QNetworkRequest request = QGeoTileFetcherQGC::getNetworkRequest(mapId, tile->x(), tile->y(), tile->z());
+        const int mapId = UrlFactory::getQtMapIdFromProviderType(tile->type);
+        QNetworkRequest request = QGeoTileFetcherQGC::getNetworkRequest(mapId, tile->x, tile->y, tile->z);
         request.setOriginatingObject(this);
-        request.setAttribute(QNetworkRequest::User, tile->hash());
+        request.setAttribute(QNetworkRequest::User, tile->hash);
 
         QNetworkReply* const reply = _networkManager->get(request);
         reply->setParent(this);
         QGCFileDownload::setIgnoreSSLErrorsIfNeeded(*reply);
         (void) connect(reply, &QNetworkReply::finished, this, &QGCCachedTileSet::_networkReplyFinished);
         (void) connect(reply, &QNetworkReply::errorOccurred, this, &QGCCachedTileSet::_networkReplyError);
-        (void) _replies.insert(tile->hash(), reply);
+        (void) _replies.insert(tile->hash, reply);
 
         delete tile;
         if (!_batchRequested && !_noMoreTiles && (_tilesToDownload.count() < (QGeoTileFetcherQGC::concurrentDownloads(_type) * 10))) {
@@ -183,7 +175,7 @@ void QGCCachedTileSet::_networkReplyFinished()
 {
     QNetworkReply* const reply = qobject_cast<QNetworkReply*>(QObject::sender());
     if (!reply) {
-        qCWarning(QGCCachedTileSetLog) << Q_FUNC_INFO << "NULL Reply";
+        qCWarning(QGCCachedTileSetLog) << "NULL Reply";
         return;
     }
     reply->deleteLater();
@@ -193,26 +185,26 @@ void QGCCachedTileSet::_networkReplyFinished()
     }
 
     if (!reply->isOpen()) {
-        qCWarning(QGCCachedTileSetLog) << Q_FUNC_INFO << "Empty Reply";
+        qCWarning(QGCCachedTileSetLog) << "Empty Reply";
         return;
     }
 
     const QString hash = reply->request().attribute(QNetworkRequest::User).toString();
     if (hash.isEmpty()) {
-        qCWarning(QGCCachedTileSetLog) << Q_FUNC_INFO << "Empty Hash";
+        qCWarning(QGCCachedTileSetLog) << "Empty Hash";
         return;
     }
 
     if (_replies.contains(hash)) {
         (void) _replies.remove(hash);
     } else {
-        qCWarning(QGCCachedTileSetLog) << Q_FUNC_INFO << "Reply not in list: " << hash;
+        qCWarning(QGCCachedTileSetLog) << "Reply not in list: " << hash;
     }
     qCDebug(QGCCachedTileSetLog) << "Tile fetched:" << hash;
 
     QByteArray image = reply->readAll();
     if (image.isEmpty()) {
-        qCWarning(QGCCachedTileSetLog) << Q_FUNC_INFO << "Empty Image";
+        qCWarning(QGCCachedTileSetLog) << "Empty Image";
         return;
     }
 
@@ -224,14 +216,14 @@ void QGCCachedTileSet::_networkReplyFinished()
         const SharedElevationProvider elevationProvider = std::dynamic_pointer_cast<const ElevationProvider>(mapProvider);
         image = elevationProvider->serialize(image);
         if (image.isEmpty()) {
-            qCWarning(QGCCachedTileSetLog) << Q_FUNC_INFO << "Failed to Serialize Terrain Tile";
+            qCWarning(QGCCachedTileSetLog) << "Failed to Serialize Terrain Tile";
             return;
         }
     }
 
     const QString format = mapProvider->getImageFormat(image);
     if (format.isEmpty()) {
-        qCWarning(QGCCachedTileSetLog) << Q_FUNC_INFO << "Empty Format";
+        qCWarning(QGCCachedTileSetLog) << "Empty Format";
         return;
     }
 
@@ -258,24 +250,24 @@ void QGCCachedTileSet::_networkReplyError(QNetworkReply::NetworkError error)
     if (!reply) {
         return;
     }
-    qCDebug(QGCCachedTileSetLog) << Q_FUNC_INFO << "Error fetching tile" << reply->errorString();
+    qCDebug(QGCCachedTileSetLog) << "Error fetching tile" << reply->errorString();
 
     setErrorCount(_errorCount + 1);
 
     const QString hash = reply->request().attribute(QNetworkRequest::User).toString();
     if (hash.isEmpty()) {
-        qCWarning(QGCCachedTileSetLog) << Q_FUNC_INFO << "Empty Hash";
+        qCWarning(QGCCachedTileSetLog) << "Empty Hash";
         return;
     }
 
     if (_replies.contains(hash)) {
         (void) _replies.remove(hash);
     } else {
-        qCWarning(QGCCachedTileSetLog) << Q_FUNC_INFO << "Reply not in list:" << hash;
+        qCWarning(QGCCachedTileSetLog) << "Reply not in list:" << hash;
     }
 
     if (error != QNetworkReply::OperationCanceledError) {
-        qCWarning(QGCCachedTileSetLog) << Q_FUNC_INFO << "Error:" << reply->errorString();
+        qCWarning(QGCCachedTileSetLog) << "Error:" << reply->errorString();
     }
 
     QGCUpdateTileDownloadStateTask* const task = new QGCUpdateTileDownloadStateTask(_id, QGCTile::StateError, hash);

src/QtLocationPlugin/QGCCachedTileSet.h

@@ -7,15 +7,6 @@
  *
  ****************************************************************************/
 
-
-/**
- * @file
- *   @brief Map Tile Set
- *
- *   @author Gus Grubba <[email protected]>
- *
- */
-
 #pragma once
 
 #include <QtCore/QDateTime>

src/QtLocationPlugin/QGCMapEngine.cpp

@@ -7,31 +7,21 @@
  *
  ****************************************************************************/
 
+#include "QGCMapEngine.h"
 
-/**
- * @file
- *   @brief Map Tile Cache
- *
- *   @author Gus Grubba <[email protected]>
- *
- */
+#include <QtCore/QApplicationStatic>
 
-#include "QGCMapEngine.h"
 #include "QGCCachedTileSet.h"
-#include "QGCTileCacheWorker.h"
-#include "QGeoFileTileCacheQGC.h"
+#include "QGCCacheTile.h"
+#include "QGCLoggingCategory.h"
 #include "QGCMapTasks.h"
-#include "QGCTileSet.h"
 #include "QGCTile.h"
-#include "QGCCacheTile.h"
-#include <QGCLoggingCategory.h>
-
-#include <QtCore/QApplicationStatic>
+#include "QGCTileCacheWorker.h"
+#include "QGCTileSet.h"
+#include "QGeoFileTileCacheQGC.h"
 
 QGC_LOGGING_CATEGORY(QGCMapEngineLog, "qgc.qtlocationplugin.qgcmapengine")
 
-Q_DECLARE_METATYPE(QList<QGCTile*>)
-
 Q_APPLICATION_STATIC(QGCMapEngine, _mapEngine);
 
 QGCMapEngine *getQGCMapEngine()
@@ -41,26 +31,26 @@ QGCMapEngine *getQGCMapEngine()
 
 QGCMapEngine::QGCMapEngine(QObject *parent)
     : QObject(parent)
-    , m_worker(new QGCCacheWorker(this))
 {
-    // qCDebug(QGCMapEngineLog) << Q_FUNC_INFO << this;
+    qCDebug(QGCMapEngineLog) << this;
 
-    (void) qRegisterMetaType<QGCMapTask::TaskType>("TaskType");
+    (void) qRegisterMetaType<QGCMapTask::TaskType>("QGCMapTask::TaskType");
     (void) qRegisterMetaType<QGCTile>("QGCTile");
+    (void) qRegisterMetaType<QGCTile*>("QGCTile*");
     (void) qRegisterMetaType<QList<QGCTile*>>("QList<QGCTile*>");
     (void) qRegisterMetaType<QGCTileSet>("QGCTileSet");
+    (void) qRegisterMetaType<QGCTileSet*>("QGCTileSet*");
     (void) qRegisterMetaType<QGCCacheTile>("QGCCacheTile");
-
-    (void) connect(m_worker, &QGCCacheWorker::updateTotals, this, &QGCMapEngine::_updateTotals);
+    (void) qRegisterMetaType<QGCCacheTile*>("QGCCacheTile*");
 }
 
 QGCMapEngine::~QGCMapEngine()
 {
     (void) disconnect(m_worker);
     m_worker->stop();
-    m_worker->wait();
+    (void) m_worker->wait();
 
-    // qCDebug(QGCMapEngineLog) << Q_FUNC_INFO << this;
+    qCDebug(QGCMapEngineLog) << this;
 }
 
 QGCMapEngine *QGCMapEngine::instance()
@@ -70,10 +60,18 @@ QGCMapEngine *QGCMapEngine::instance()
 
 void QGCMapEngine::init(const QString &databasePath)
 {
+    if (m_initialized) {
+        return;
+    }
+
+    m_worker = new QGCCacheWorker(this);
     m_worker->setDatabaseFile(databasePath);
+    (void) connect(m_worker, &QGCCacheWorker::updateTotals, this, &QGCMapEngine::_updateTotals);
 
-    QGCMapTask* const task = new QGCMapTask(QGCMapTask::taskInit);
+    QGCMapTask *task = new QGCMapTask(QGCMapTask::TaskType::taskInit);
     (void) addTask(task);
+
+    m_initialized = true;
 }
 
 bool QGCMapEngine::addTask(QGCMapTask *task)
@@ -85,13 +83,16 @@ void QGCMapEngine::_updateTotals(quint32 totaltiles, quint64 totalsize, quint32
 {
     emit updateTotals(totaltiles, totalsize, defaulttiles, defaultsize);
 
-    const quint64 maxSize = static_cast<quint64>(QGeoFileTileCacheQGC::getMaxDiskCacheSetting()) * pow(1024, 2);
-    if (!m_prunning && (defaultsize > maxSize)) {
-        m_prunning = true;
+    const quint64 maxSize = static_cast<quint64>(QGeoFileTileCacheQGC::getMaxDiskCacheSetting()) * qPow(1024, 2);
+    if (!m_pruning && (defaultsize > maxSize)) {
+        m_pruning = true;
 
         const quint64 amountToPrune = defaultsize - maxSize;
-        QGCPruneCacheTask* const task = new QGCPruneCacheTask(amountToPrune);
+        QGCPruneCacheTask *task = new QGCPruneCacheTask(amountToPrune);
         (void) connect(task, &QGCPruneCacheTask::pruned, this, &QGCMapEngine::_pruned);
-        (void) addTask(task);
+        if (!addTask(task)) {
+            task->deleteLater();
+            m_pruning = false;
+        }
     }
 }