QGCFileDownload.h

Go to the documentation of this file.

#pragma once
 
 
#include "QGCNetworkHelper.h"
 
#include <QtCore/QObject>
#include <QtCore/QUrl>
#include <QtNetwork/QNetworkReply>
#include <QtNetwork/QNetworkRequest>
 
class QNetworkAccessManager;
class QAbstractNetworkCache;
class QGCCompressionJob;
class QFile;
 
class QGCFileDownload : public QObject
{
    Q_OBJECT
    Q_DISABLE_COPY_MOVE(QGCFileDownload)
 
    
    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(qint64 totalBytes READ totalBytes NOTIFY totalBytesChanged FINAL)
 
    
    Q_PROPERTY(qint64 bytesReceived READ bytesReceived NOTIFY bytesReceivedChanged FINAL)
 
    
    Q_PROPERTY(bool autoDecompress READ autoDecompress WRITE setAutoDecompress NOTIFY autoDecompressChanged FINAL)
 
    
    Q_PROPERTY(QString outputPath READ outputPath WRITE setOutputPath NOTIFY outputPathChanged FINAL)
 
    
    Q_PROPERTY(QString expectedHash READ expectedHash WRITE setExpectedHash NOTIFY expectedHashChanged FINAL)
 
public:
    enum class State {
        Idle,           
        Downloading,    
        Decompressing,  
        Verifying,      
        Completed,      
        Failed,         
        Cancelled       
    };
    Q_ENUM(State)
 
    explicit QGCFileDownload(QObject *parent = nullptr);
    ~QGCFileDownload() override;
 
    // Property getters
    qreal progress() const { return _progress; }
    bool isRunning() const {
        return _state == State::Downloading || _state == State::Decompressing
               || _state == State::Verifying;
    }
    QString errorString() const { return _errorString; }
    QUrl url() const { return _url; }
    QString localPath() const { return _localPath; }
    qint64 totalBytes() const { return _totalBytes; }
    qint64 bytesReceived() const { return _bytesReceived; }
    bool autoDecompress() const { return _autoDecompress; }
    QString outputPath() const { return _outputPath; }
    QString expectedHash() const { return _expectedHash; }
    State state() const { return _state; }
    bool lastResultFromCache() const { return _lastResultFromCache; }
 
    // Property setters
    void setAutoDecompress(bool enabled);
    void setOutputPath(const QString &path);
    void setExpectedHash(const QString &hash);
 
    void setCache(QAbstractNetworkCache *cache);
 
    void setTimeout(int timeoutMs);
 
    QNetworkAccessManager *networkManager() const { return _networkManager; }
 
public slots:
    bool start(const QString &remoteUrl);
 
    bool start(const QString &remoteUrl, const QGCNetworkHelper::RequestConfig &config);
 
    void cancel();
 
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 totalBytesChanged(qint64 totalBytes);
 
    void bytesReceivedChanged(qint64 bytesReceived);
 
    void autoDecompressChanged(bool autoDecompress);
 
    void outputPathChanged(const QString &outputPath);
 
    void expectedHashChanged(const QString &expectedHash);
 
    void stateChanged(State state);
 
    void finished(bool success, const QString &localPath, const QString &errorMessage);
 
    void downloadProgress(qint64 bytesReceived, qint64 totalBytes);
 
    void decompressionProgress(qreal progress);
 
private slots:
    void _onDownloadProgress(qint64 bytesReceived, qint64 totalBytes);
    void _onDownloadFinished();
    void _onDownloadError(QNetworkReply::NetworkError code);
    void _onDecompressionFinished(bool success);
    void _onReadyRead();
 
private:
    void _setState(State newState);
    void _setProgress(qreal progress);
    void _setErrorString(const QString &error);
    void _cleanup();
    void _emitFinished(bool success, const QString &localPath, const QString &errorMessage);
    bool _writeReplyData(const QByteArray &data);
    bool _failForWriteError(const QString &context);
    QString _generateOutputPath(const QString &remoteUrl) const;
    bool _verifyHash();
    void _startDecompression();
 
    QNetworkAccessManager *_networkManager = nullptr;
    QNetworkReply *_currentReply = nullptr;
    QGCCompressionJob *_decompressionJob = nullptr;
    QFile *_outputFile = nullptr;
 
    QUrl _url;
    QString _localPath;
    QString _outputPath;
    QString _expectedHash;
    QString _errorString;
    QString _compressedFilePath;
 
    qreal _progress = 0.0;
    qint64 _totalBytes = -1;
    qint64 _bytesReceived = 0;
    int _timeoutMs = QGCNetworkHelper::kDefaultTimeoutMs;
 
    State _state = State::Idle;
    bool _autoDecompress = false;
    bool _finishEmitted = false;
    bool _lastResultFromCache = false;
};