Downloader.cpp

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// -                        CloudViewer: www.cloudViewer.org                  -
// ----------------------------------------------------------------------------
// Copyright (c) 2018-2024 www.cloudViewer.org
// SPDX-License-Identifier: MIT
// ----------------------------------------------------------------------------
 
#include <QDir>
#include <QFile>
#include <QProcess>
#include <QDateTime>
#include <QMessageBox>
#include <QNetworkReply>
#include <QDesktopServices>
#include <QNetworkAccessManager>
 
#include <math.h>
 
#include "QSimpleUpdater/include/Downloader.h"
 
static const QString PARTIAL_DOWN(".part");
 
Downloader::Downloader(QWidget *parent)
   : QWidget(parent)
{
   m_ui = new Ui::Downloader;
   m_ui->setupUi(this);
 
   /* Initialize private members */
   m_manager = new QNetworkAccessManager();
 
   /* Initialize internal values */
   m_url = "";
   m_fileName = "";
   m_startTime = 0;
   m_useCustomProcedures = false;
   m_mandatoryUpdate = false;
 
   /* Set download directory */
   m_downloadDir.setPath(QDir::homePath() + "/Downloads/");
 
   /* Make the window look like a modal dialog */
   setWindowIcon(QIcon());
   setWindowFlags(Qt::Dialog | Qt::CustomizeWindowHint | Qt::WindowTitleHint);
 
   /* Configure the appearance and behavior of the buttons */
   m_ui->openButton->setEnabled(false);
   m_ui->openButton->setVisible(false);
   connect(m_ui->stopButton, SIGNAL(clicked()), this, SLOT(cancelDownload()));
   connect(m_ui->openButton, SIGNAL(clicked()), this, SLOT(installUpdate()));
 
   /* Resize to fit */
   setFixedSize(minimumSizeHint());
}
 
Downloader::~Downloader()
{
   delete m_ui;
   delete m_reply;
   delete m_manager;
}
 
bool Downloader::useCustomInstallProcedures() const
{
   return m_useCustomProcedures;
}
 
void Downloader::setUrlId(const QString &url)
{
   m_url = url;
}
 
void Downloader::startDownload(const QUrl &url)
{
   /* reset UI */
   m_ui->progressBar->setValue(0);
   m_ui->stopButton->setText(tr("Stop"));
   m_ui->downloadLabel->setText(tr("Downloading updates"));
   m_ui->timeLabel->setText(tr("Time remaining") + ": " + tr("unknown"));
 
   /* Configure the network request */
   QNetworkRequest request(url);
   if (!m_userAgentString.isEmpty())
      request.setRawHeader("User-Agent", m_userAgentString.toUtf8());
 
   /* Start download */
   m_reply = m_manager->get(request);
   m_startTime = QDateTime::currentDateTime().toSecsSinceEpoch();
 
   /* Ensure that downloads directory exists */
   if (!m_downloadDir.exists())
      m_downloadDir.mkpath(".");
 
   /* Remove old downloads */
   QFile::remove(m_downloadDir.filePath(m_fileName));
   QFile::remove(m_downloadDir.filePath(m_fileName + PARTIAL_DOWN));
 
   /* Update UI when download progress changes or download finishes */
   connect(m_reply, SIGNAL(downloadProgress(qint64, qint64)), this, SLOT(updateProgress(qint64, qint64)));
   connect(m_reply, SIGNAL(finished()), this, SLOT(finished()));
   connect(m_reply, SIGNAL(redirected(QUrl)), this, SLOT(startDownload(QUrl)));
 
   showNormal();
}
 
void Downloader::setFileName(const QString &file)
{
   m_fileName = file;
 
   if (m_fileName.isEmpty())
      m_fileName = "QSU_Update.bin";
}
 
void Downloader::setUserAgentString(const QString &agent)
{
   m_userAgentString = agent;
}
 
void Downloader::finished()
{
   /* Rename file */
   QFile::rename(m_downloadDir.filePath(m_fileName + PARTIAL_DOWN), m_downloadDir.filePath(m_fileName));
 
   /* Notify application */
   emit downloadFinished(m_url, m_downloadDir.filePath(m_fileName));
 
   /* Install the update */
   m_reply->close();
   installUpdate();
   setVisible(false);
}
 
void Downloader::openDownload()
{
   if (!m_fileName.isEmpty())
   {
      QDesktopServices::openUrl(QUrl::fromLocalFile(m_downloadDir.filePath(m_fileName)));
   }
   else
   {
      QMessageBox::critical(this, tr("Error"), tr("Cannot find downloaded update!"), QMessageBox::Close);
   }
}
 
void Downloader::installUpdate()
{
   if (useCustomInstallProcedures())
      return;
 
   /* Update labels */
   m_ui->stopButton->setText(tr("Close"));
   m_ui->downloadLabel->setText(tr("Download complete!"));
   m_ui->timeLabel->setText(tr("The installer will open separately") + "...");
 
   /* Ask the user to install the download */
   QMessageBox box;
   box.setIcon(QMessageBox::Question);
   box.setDefaultButton(QMessageBox::Ok);
   box.setStandardButtons(QMessageBox::Ok | QMessageBox::Cancel);
   box.setInformativeText(tr("Click \"OK\" to begin installing the update"));
 
   QString text = tr("In order to install the update, you may need to "
                     "quit the application.");
 
   if (m_mandatoryUpdate)
      text = tr("In order to install the update, you may need to "
                "quit the application. This is a mandatory update, exiting now will close the application");
 
   box.setText("<h3>" + text + "</h3>");
 
   /* User wants to install the download */
   if (box.exec() == QMessageBox::Ok)
   {
      if (!useCustomInstallProcedures())
         openDownload();
   }
   /* Wait */
   else
   {
      if (m_mandatoryUpdate)
      {
         QString installerFile = m_downloadDir.filePath(m_fileName);
         QMessageBox::information(this, "", tr("Please install from <i>%1</i> mannually!").arg(installerFile));
         QApplication::quit();
      }
 
      m_ui->openButton->setEnabled(true);
      m_ui->openButton->setVisible(true);
      m_ui->timeLabel->setText(tr("Click the \"Open\" button to "
                                  "apply the update"));
   }
}
 
void Downloader::cancelDownload()
{
   if (!m_reply->isFinished())
   {
      QMessageBox box;
      box.setWindowTitle(tr("Updater"));
      box.setIcon(QMessageBox::Question);
      box.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
 
      QString text = tr("Are you sure you want to cancel the download?");
      if (m_mandatoryUpdate)
      {
         text = tr("Are you sure you want to cancel the download? This is a mandatory update, exiting now will close "
                   "the application");
      }
      box.setText(text);
 
      if (box.exec() == QMessageBox::Yes)
      {
         hide();
         m_reply->abort();
         if (m_mandatoryUpdate)
            QApplication::quit();
      }
   }
   else
   {
      if (m_mandatoryUpdate)
         QApplication::quit();
 
      hide();
   }
}
 
void Downloader::saveFile(qint64 received, qint64 total)
{
   Q_UNUSED(received);
   Q_UNUSED(total);
 
   /* Check if we need to redirect */
   QUrl url = m_reply->attribute(QNetworkRequest::RedirectionTargetAttribute).toUrl();
   if (!url.isEmpty())
   {
      startDownload(url);
      return;
   }
 
   /* Save downloaded data to disk */
   QFile file(m_downloadDir.filePath(m_fileName + PARTIAL_DOWN));
   if (file.open(QIODevice::WriteOnly | QIODevice::Append))
   {
      file.write(m_reply->readAll());
      file.close();
   }
}
 
void Downloader::calculateSizes(qint64 received, qint64 total)
{
   QString totalSize;
   QString receivedSize;
 
   if (total < 1024)
      totalSize = tr("%1 bytes").arg(total);
 
   else if (total < 1048576)
      totalSize = tr("%1 KB").arg(round(total / 1024));
 
   else
      totalSize = tr("%1 MB").arg(round(total / 1048576));
 
   if (received < 1024)
      receivedSize = tr("%1 bytes").arg(received);
 
   else if (received < 1048576)
      receivedSize = tr("%1 KB").arg(received / 1024);
 
   else
      receivedSize = tr("%1 MB").arg(received / 1048576);
 
   m_ui->downloadLabel->setText(tr("Downloading updates") + " (" + receivedSize + " " + tr("of") + " " + totalSize
                                + ")");
}
 
void Downloader::updateProgress(qint64 received, qint64 total)
{
   if (total > 0)
   {
      m_ui->progressBar->setMinimum(0);
      m_ui->progressBar->setMaximum(100);
      m_ui->progressBar->setValue((received * 100) / total);
 
      calculateSizes(received, total);
      calculateTimeRemaining(received, total);
      saveFile(received, total);
   }
 
   else
   {
      m_ui->progressBar->setMinimum(0);
      m_ui->progressBar->setMaximum(0);
      m_ui->progressBar->setValue(-1);
      m_ui->downloadLabel->setText(tr("Downloading Updates") + "...");
      m_ui->timeLabel->setText(QString("%1: %2").arg(tr("Time Remaining")).arg(tr("Unknown")));
   }
}
 
void Downloader::calculateTimeRemaining(qint64 received, qint64 total)
{
   uint difference = QDateTime::currentDateTime().toSecsSinceEpoch() - m_startTime;
 
   if (difference > 0)
   {
      QString timeString;
      qreal timeRemaining = (total - received) / (received / difference);
 
      if (timeRemaining > 7200)
      {
         timeRemaining /= 3600;
         int hours = int(timeRemaining + 0.5);
 
         if (hours > 1)
            timeString = tr("about %1 hours").arg(hours);
         else
            timeString = tr("about one hour");
      }
 
      else if (timeRemaining > 60)
      {
         timeRemaining /= 60;
         int minutes = int(timeRemaining + 0.5);
 
         if (minutes > 1)
            timeString = tr("%1 minutes").arg(minutes);
         else
            timeString = tr("1 minute");
      }
 
      else if (timeRemaining <= 60)
      {
         int seconds = int(timeRemaining + 0.5);
 
         if (seconds > 1)
            timeString = tr("%1 seconds").arg(seconds);
         else
            timeString = tr("1 second");
      }
 
      m_ui->timeLabel->setText(tr("Time remaining") + ": " + timeString);
   }
}
 
qreal Downloader::round(const qreal &input)
{
   return static_cast<qreal>(roundf(static_cast<float>(input) * 100) / 100);
}
 
QString Downloader::downloadDir() const
{
   return m_downloadDir.absolutePath();
}
 
void Downloader::setDownloadDir(const QString &downloadDir)
{
   if (m_downloadDir.absolutePath() != downloadDir)
      m_downloadDir.setPath(downloadDir);
}
 
void Downloader::setMandatoryUpdate(const bool mandatory_update)
{
   m_mandatoryUpdate = mandatory_update;
}
 
void Downloader::setUseCustomInstallProcedures(const bool custom)
{
   m_useCustomProcedures = custom;
}