QGCCachedFileDownload.h

Go to the documentation of this file.

#pragma once
 
 
#include <QtCore/QDateTime>
#include <QtCore/QObject>
#include <QtCore/QString>
#include <QtCore/QUrl>
 
class QGCFileDownload;
class QNetworkDiskCache;
 
class QGCCachedFileDownload : public QObject
{
    Q_OBJECT
    Q_DISABLE_COPY_MOVE(QGCCachedFileDownload)
 
    
    Q_PROPERTY(qreal progress READ progress NOTIFY progressChanged FINAL)
 
    
    Q_PROPERTY(bool running READ isRunning NOTIFY runningChanged FINAL)
 
    
    Q_PROPERTY(QString errorString READ errorString NOTIFY errorStringChanged FINAL)
 
    
    Q_PROPERTY(QUrl url READ url NOTIFY urlChanged FINAL)
 
    
    Q_PROPERTY(QString localPath READ localPath NOTIFY localPathChanged FINAL)
 
    
    Q_PROPERTY(bool fromCache READ isFromCache NOTIFY fromCacheChanged FINAL)
 
    
    Q_PROPERTY(QString cacheDirectory READ cacheDirectory WRITE setCacheDirectory
               NOTIFY cacheDirectoryChanged FINAL)
 
    
    Q_PROPERTY(qint64 maxCacheSize READ maxCacheSize WRITE setMaxCacheSize
               NOTIFY maxCacheSizeChanged FINAL)
 
    
    Q_PROPERTY(qint64 cacheSize READ cacheSize NOTIFY cacheSizeChanged FINAL)
 
public:
    explicit QGCCachedFileDownload(const QString &cacheDirectory, QObject *parent = nullptr);
 
    explicit QGCCachedFileDownload(QObject *parent = nullptr);
 
    ~QGCCachedFileDownload() override;
 
    // Property getters
    qreal progress() const { return _progress; }
    bool isRunning() const { return _running; }
    QString errorString() const { return _errorString; }
    QUrl url() const { return _url; }
    QString localPath() const { return _localPath; }
    bool isFromCache() const { return _fromCache; }
    QString cacheDirectory() const;
    qint64 maxCacheSize() const;
    qint64 cacheSize() const;
 
    // Property setters
    void setCacheDirectory(const QString &directory);
    void setMaxCacheSize(qint64 bytes);
 
    Q_INVOKABLE bool isCached(const QString &url, int maxAgeSec = 0) const;
 
    Q_INVOKABLE QString cachedPath(const QString &url) const;
 
    Q_INVOKABLE int cacheAge(const QString &url) const;
 
    QGCFileDownload *fileDownloader() const { return _fileDownload; }
 
    QNetworkDiskCache *diskCache() const { return _diskCache; }
 
public slots:
    bool download(const QString &url, int maxCacheAgeSec);
 
    bool downloadPreferCache(const QString &url);
 
    bool downloadNoCache(const QString &url);
 
    void cancel();
 
    void clearCache();
 
    bool removeFromCache(const QString &url);
 
signals:
    void progressChanged(qreal progress);
 
    void runningChanged(bool running);
 
    void errorStringChanged(const QString &errorString);
 
    void urlChanged(const QUrl &url);
 
    void localPathChanged(const QString &localPath);
 
    void fromCacheChanged(bool fromCache);
 
    void cacheDirectoryChanged(const QString &directory);
 
    void maxCacheSizeChanged(qint64 bytes);
 
    void cacheSizeChanged(qint64 bytes);
 
    void finished(bool success, const QString &localPath,
                  const QString &errorMessage, bool fromCache);
 
    void downloadProgress(qint64 bytesReceived, qint64 totalBytes);
 
private slots:
    void _onDownloadFinished(bool success, const QString &localPath, const QString &errorMessage);
    void _onDownloadProgress(qint64 bytesReceived, qint64 totalBytes);
 
private:
    void _initializeCache(const QString &directory);
    void _setRunning(bool running);
    void _setProgress(qreal progress);
    void _setErrorString(const QString &error);
    void _setFromCache(bool fromCache);
    void _updateCacheTimestamp(const QString &url);
    QDateTime _getCacheTimestamp(const QString &url) const;
    bool _startDownload(const QString &url, bool forceNetwork, bool preferCache);
    void _emitFinished(bool success, const QString &path, const QString &error);
 
    QGCFileDownload *_fileDownload = nullptr;
    QNetworkDiskCache *_diskCache = nullptr;
 
    QUrl _url;
    QString _localPath;
    QString _errorString;
    QString _pendingUrl;
 
    qreal _progress = 0.0;
    int _maxCacheAgeSec = 0;
    bool _running = false;
    bool _fromCache = false;
    bool _networkAttemptFailed = false;
    bool _forceNetwork = false;
    bool _cancelRequested = false;
};