qgstiledownloadmanager.h

Go to the documentation of this file.

/***************************************************************************
                         qgstiledownloadmanager.h
                         ------------------------
    begin                : January 2021
    copyright            : (C) 2021 by Martin Dobias
    email                : wonder dot sk at gmail dot com
 ***************************************************************************/
 
/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 
#ifndef QGSTILEDOWNLOADMANAGER_H
#define QGSTILEDOWNLOADMANAGER_H
 
 
#include "qgis_core.h"
 
#include <QMutex>
#include <QNetworkAccessManager>
#include <QNetworkReply>
#include <QThread>
#include <QTimer>
 
#define SIP_NO_FILE
 
class QgsTileDownloadManager;
class QgsRangeRequestCache;

class CORE_EXPORT QgsTileDownloadManagerReply : public QObject
{
    Q_OBJECT
  public:
    ~QgsTileDownloadManagerReply() override;

    bool hasFinished() const { return mHasFinished; }
    QByteArray data() const { return mData; }
    QUrl url() const { return mUrl; }
    QVariant attribute( QNetworkRequest::Attribute code );
    QVariant header( QNetworkRequest::KnownHeaders header );
    const QList<QNetworkReply::RawHeaderPair> rawHeaderPairs() const { return mRawHeaderPairs; }
    QNetworkReply::NetworkError error() const { return mError; }
    QString errorString() const { return mErrorString; }
    QNetworkRequest request() const { return mRequest; }
 
  signals:
    void finished();
 
  private slots:
    void requestFinished(
      QByteArray data,
      QUrl url,
      const QMap<QNetworkRequest::Attribute, QVariant> &attributes,
      const QMap<QNetworkRequest::KnownHeaders, QVariant> &headers,
      const QList<QNetworkReply::RawHeaderPair> rawHeaderPairs,
      QNetworkReply::NetworkError error,
      const QString &errorString
    );
    void cachedRangeRequestFinished();
 
  private:
    QgsTileDownloadManagerReply( QgsTileDownloadManager *manager, const QNetworkRequest &request );
 
    friend class QgsTileDownloadManager; // allows creation of new instances from the manager
 
  private:
    QgsTileDownloadManager *mManager = nullptr;
    QNetworkRequest mRequest;
    bool mHasFinished = false;
    QByteArray mData;
    QNetworkReply::NetworkError mError = QNetworkReply::NoError;
    QString mErrorString;
    QUrl mUrl;
    QMap<QNetworkRequest::Attribute, QVariant> mAttributes;
    QMap<QNetworkRequest::KnownHeaders, QVariant> mHeaders;
    QList<QNetworkReply::RawHeaderPair> mRawHeaderPairs;
};
 


class QgsTileDownloadManagerReplyWorkerObject : public QObject
{
    Q_OBJECT
  public:
    QgsTileDownloadManagerReplyWorkerObject( QgsTileDownloadManager *manager, const QNetworkRequest &request )
      : mManager( manager )
      , mRequest( request )
    {}
 
  public slots:
    void replyFinished();
 
  signals:
    void finished(
      QByteArray data,
      QUrl url,
      const QMap<QNetworkRequest::Attribute, QVariant> &attributes,
      const QMap<QNetworkRequest::KnownHeaders, QVariant> &headers,
      const QList<QNetworkReply::RawHeaderPair> rawHeaderPairs,
      QNetworkReply::NetworkError error,
      const QString &errorString
    );
 
  private:
    QgsTileDownloadManager *mManager = nullptr;
    QNetworkRequest mRequest;
};
 

class QgsTileDownloadManagerWorker : public QObject
{
    Q_OBJECT
 
  public:
    QgsTileDownloadManagerWorker( QgsTileDownloadManager *manager, QObject *parent = nullptr );
 
    void startIdleTimer();
 
  public slots:
    void queueUpdated();
    void idleTimerTimeout();
 
  signals:
    void requestFinished( QString url, QByteArray data );
 
  private:
    void quitThread();
 
  private:
    QgsTileDownloadManager *mManager = nullptr;
    QTimer mIdleTimer;
};

 

class CORE_EXPORT QgsTileDownloadManager
{
    class QueueEntry
    {
      public:
        bool isValid() const { return !request.url().isEmpty(); }

        QNetworkRequest request;
        QgsTileDownloadManagerReplyWorkerObject *objWorker = nullptr;
        QNetworkReply *networkReply = nullptr;
    };
 
  public:
    class Stats
    {
      public:
        int requestsTotal = 0;
        int requestsMerged = 0;
        int requestsEarlyDeleted = 0;

        int networkRequestsStarted = 0;
        int networkRequestsOk = 0;
        int networkRequestsFailed = 0;
    };
 
    QgsTileDownloadManager();
    ~QgsTileDownloadManager();

    QgsTileDownloadManagerReply *get( const QNetworkRequest &request );

    bool hasPendingRequests() const;

    bool waitForPendingRequests( int msec = -1 ) const;

    void shutdown();

    bool hasWorkerThreadRunning() const;

    void setIdleThreadTimeout( int timeoutMs ) { mIdleThreadTimeoutMs = timeoutMs; }

    Stats statistics() const { return mStats; }

    void resetStatistics();
 
    friend class QgsTileDownloadManagerWorker;
    friend class QgsTileDownloadManagerReply;
    friend class QgsTileDownloadManagerReplyWorkerObject;
 
  private:
    // these can be only used with mutex locked!
    QueueEntry findEntryForRequest( const QNetworkRequest &request );
    void addEntry( const QueueEntry &entry );
    void updateEntry( const QueueEntry &entry );
    void removeEntry( const QNetworkRequest &request );
    void processStagedEntryRemovals();
 
    void signalQueueModified();
 
    bool isRangeRequest( const QNetworkRequest &request );
    bool isCachedRangeRequest( const QNetworkRequest &request );
 
  private:
    std::vector<QueueEntry> mQueue;
 
    bool mStageQueueRemovals = false;
    std::vector< QNetworkRequest > mStagedQueueRemovals;
 
    bool mShuttingDown = false;
    mutable QRecursiveMutex mMutex;
 
    QThread *mWorkerThread = nullptr;
    QgsTileDownloadManagerWorker *mWorker = nullptr;
    Stats mStats;
 
    int mIdleThreadTimeoutMs = 10000;
 
    std::unique_ptr<QgsRangeRequestCache> mRangesCache;
};
 
#endif // QGSTILEDOWNLOADMANAGER_H