Qt/C++ Tutorial 080. Downloading large files with QNetworkAccessManager

QNetworkRequest, Qt, QNetworkAccessManager, QNetworkReply

After the question appeared on the forum about downloading large files using the Qt library, I raised some of my projects and prepared a more detailed manual using this functionality. Moreover, the problem with downloading files was related to redirects. By default, QNetworkAccessManager does not switch to redirects for downloading files and retrieving pages, so you need to set the appropriate attribute in the request, then everything will work, but let's take a closer look.

The application will have the following functionality.

• QLineEdit for entering the destination URL for downloading
  QLineEdit to enter the target directory for download in readOnly mode. We will fill it with QFileDialog.
  QProgressBar, which will show the progress of the download
  Button to cancel download

Look our downloader will be so

Project Structure

The project consists of

• FileDownloader.pro - project profile
• Downloader.h - Header file for downloading files
• Downloader.cpp - Class implementation file for downloading files
• Widget.h - Application window header file
• Widget.cpp - Application window implementation file
• Widget.ui - Graphical form of the application window
• main.cpp - The file with the main application function

FileDownloader.pro, main.cpp, Widget.ui will not be considered, the first two are created by default, the latter is created through the Qt Designer graphic editor, look at it in the project itself, which is attached to the article at the very end.

Widget.h

In the header file, all the unimaginable slots for processing the interface buttons are declared and also the class for downloading files is declared on the stack

#ifndef WIDGET_H
#define WIDGET_H
 
#include "Downloader.h"
 
#include <QWidget>
 
namespace Ui {
class Widget;
}
 
class Widget : public QWidget
{
    Q_OBJECT
 
public:
    explicit Widget(QWidget *parent = nullptr);
    ~Widget();
 
private slots:
    // Slot for download start
    void onDownloadButtonClicked();
 
    // Slot for selecting the download directory
    void onSelectTargetFolderButtonClicked();
 
    // Slot for canceling the download
    void onCancelButtonClicked();
 
    // Slot for updating download progress
    void onUpdateProgress(qint64 bytesReceived, qint64 bytesTotal);
 
private:
    Ui::Widget *ui;
    Downloader m_downloader; // Download Class
};
 
#endif // WIDGET_H

Widget.cpp

#include "Widget.h"
#include "ui_Widget.h"
 
#include <QFileDialog>
#include <QStandardPaths>
 
Widget::Widget(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::Widget)
{
    ui->setupUi(this);
    // Connect to slots
    connect(ui->downloadPushButton, &QPushButton::clicked, this, &Widget::onDownloadButtonClicked);
    connect(ui->selectTargetFolderPushButton, &QPushButton::clicked, this, &Widget::onSelectTargetFolderButtonClicked);
    connect(ui->cancelPushButton, &QPushButton::clicked, this, &Widget::onCancelButtonClicked);
    connect(&m_downloader, &Downloader::updateDownloadProgress, this, &Widget::onUpdateProgress);
}
 
Widget::~Widget()
{
    delete ui;
}
 
void Widget::onDownloadButtonClicked()
{
    // We start downloading the file by passing the 
    // path to the directory where we will upload files, 
    // url, where the file is located
    m_downloader.get(ui->targetFolderLineEdit->text(), ui->urlLineEdit->text());
}
 
void Widget::onSelectTargetFolderButtonClicked()
{
    // Selecting the destination directory for downloading
    QString targetFolder = QFileDialog::getExistingDirectory(this,
                                                             tr("Select folder"),
                                                             QStandardPaths::writableLocation(QStandardPaths::DownloadLocation),
                                                             QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);
    ui->targetFolderLineEdit->setText(targetFolder);
}
 
void Widget::onCancelButtonClicked()
{
    // Cancel upload
    m_downloader.cancelDownload();
    ui->downloadProgressBar->setMaximum(100);
    ui->downloadProgressBar->setValue(0);
}
 
void Widget::onUpdateProgress(qint64 bytesReceived, qint64 bytesTotal)
{
    // Updating upload progress
    ui->downloadProgressBar->setMaximum(bytesTotal);
    ui->downloadProgressBar->setValue(bytesReceived);
}

Downloader.h

And now look at the class for downloading files, taking into account the progress of the download.

An important point is that large files need to be processed gradually, they can not be read by one query. Therefore, you need to handle the QNetworkReply::readyRead signal from the object of the current response to the request. This signal is emitted when the buffer contains data that we can assume.

And only after the download is completed QNetworkAccessManager will issue a finished signal, which will close the file and complete the connection with the removal of the object of the current response to the request.

#ifndef DOWNLOADER_H
#define DOWNLOADER_H
 
#include <QNetworkAccessManager>
 
class QNetworkReply;
class QFile;
 
class Downloader : public QObject
{
    Q_OBJECT
    using BaseClass = QObject;
 
public:
    explicit Downloader(QObject* parent = nullptr);
 
    // Method for starting the download
    bool get(const QString& targetFolder, const QUrl& url);
 
public slots:
    // Method of canceling the load
    void cancelDownload();
 
signals:
    // A signal that sends information about the progress of the download
    void updateDownloadProgress(qint64 bytesReceived, qint64 bytesTotal);
 
private slots:
    // Slot for gradual reading of downloaded data
    void onReadyRead();
    // Slot for processing request completion
    void onReply(QNetworkReply* reply);
 
private:
    QNetworkReply* m_currentReply {nullptr};    // Current request being processed
    QFile* m_file                 {nullptr};    // The current file to which the entry is being written
    QNetworkAccessManager m_manager;            // Network manager for downloading files
};
 
#endif // DOWNLOADER_H

Downloader.cpp

#include "Downloader.h"
 
#include <QNetworkReply>
#include <QNetworkRequest>
#include <QFile>
#include <QDir>
 
Downloader::Downloader(QObject* parent) :
    BaseClass(parent)
{
    // Connect to the finished signal
    connect(&m_manager, &QNetworkAccessManager::finished, this, &Downloader::onReply);
}
 
bool Downloader::get(const QString& targetFolder, const QUrl& url)
{
    if (targetFolder.isEmpty() || url.isEmpty())
    {
        return false;
    }
 
    // Create object of file class for download
    // Here there is a target directory and the name of the file that is allocated from the URL
    m_file = new QFile(targetFolder + QDir::separator() + url.fileName());
    // Trying to open the file
    if (!m_file->open(QIODevice::WriteOnly))
    {
        delete m_file;
        m_file = nullptr;
        return false;
    }
 
    // Creating a request
    QNetworkRequest request(url);
    // Allow to go on redirects
    request.setAttribute(QNetworkRequest::FollowRedirectsAttribute, true);
    // Running the download
    m_currentReply = m_manager.get(request);
 
    // After that, we immediately connect to signals about readiness of data to read and update the progress of downloading
    connect(m_currentReply, &QNetworkReply::readyRead, this, &Downloader::onReadyRead);
    connect(m_currentReply, &QNetworkReply::downloadProgress, this, &Downloader::updateDownloadProgress);
    return true;
}
 
void Downloader::onReadyRead()
{
    // If there is data and the file is open
    if (m_file)
    {
        // write them to a file
        m_file->write(m_currentReply->readAll());
    }
}
 
void Downloader::cancelDownload()
{
    // Cancel request
    if (m_currentReply)
    {
        m_currentReply->abort();
    }
}
 
void Downloader::onReply(QNetworkReply* reply)
{
    // by completion of the request
    if (reply->error() == QNetworkReply::NoError)
    {
        // save file
        m_file->flush();
        m_file->close();
    }
    else
    {
        // Or delete it in case of error
        m_file->remove();
    }
 
    delete m_file;
    m_file = nullptr;
    reply->deleteLater();
}

Conclusion

Thus, we have an application that can download the required file for a given URL and place it in the target directory.

Link to download the project Downloader