UpdateController.cpp

Go to the documentation of this file.

// Copyright 2015 - 2026, GIBIS-UNIFESP and the wiRedPanda contributors
// SPDX-License-Identifier: GPL-3.0-or-later
 
#include "App/UI/UpdateController.h"
 
#include <QCheckBox>
#include <QDebug>
#include <QDesktopServices>
#include <QDialog>
#include <QDialogButtonBox>
#include <QDir>
#include <QFile>
#include <QLabel>
#include <QMessageBox>
#include <QNetworkAccessManager>
#include <QNetworkReply>
#include <QNetworkRequest>
#include <QPointer>
#include <QProgressDialog>
#include <QPushButton>
#include <QSslError>
#include <QStandardPaths>
#include <QVBoxLayout>
 
#include "App/Core/Application.h"
#include "App/Core/Settings.h"
#include "App/Core/UpdateChecker.h"
#include "App/Versions.h"
 
UpdateController::UpdateController(QWidget *parent)
    : QObject(parent)
    , m_parent(parent)
{
}
 
void UpdateController::checkForUpdates()
{
    if (!Application::interactiveMode) {
        return;
    }
 
    auto *updateChecker = new UpdateChecker(this);
    connect(updateChecker, &UpdateChecker::updateAvailable, this, &UpdateController::showUpdateDialog);
    updateChecker->checkForUpdates();
}
 
void UpdateController::showUpdateDialog(const QString &latestVersion, const QUrl &downloadUrl, const QUrl &releaseUrl)
{
    QDialog dialog(m_parent);
    dialog.setWindowTitle(tr("Update Available"));
    dialog.setWindowModality(Qt::WindowModal);
 
    auto *layout = new QVBoxLayout(&dialog);
 
    const bool hasDirectDownload = downloadUrl.isValid() && !downloadUrl.isEmpty();
    auto *label = new QLabel(
        (hasDirectDownload
             ? tr("<b>wiRedPanda %1 is available.</b><br><br>"
                  "You are currently running version %2.<br>"
                  "Click <b>Download</b> to save the new version to your computer.")
             : tr("<b>wiRedPanda %1 is available.</b><br><br>"
                  "You are currently running version %2.<br>"
                  "Visit the release page to download the new version."))
            .arg(latestVersion, APP_VERSION),
        &dialog);
    label->setTextFormat(Qt::RichText);
    label->setWordWrap(true);
    layout->addWidget(label);
 
    auto *skipCheckBox = new QCheckBox(tr("Don't notify me about this version again"), &dialog);
    layout->addWidget(skipCheckBox);
 
    auto *buttonBox = new QDialogButtonBox(QDialogButtonBox::Close, &dialog);
    auto *downloadButton = buttonBox->addButton(tr("Download"), QDialogButtonBox::AcceptRole);
    connect(downloadButton, &QPushButton::clicked, &dialog, [&dialog] { dialog.accept(); });
    connect(buttonBox, &QDialogButtonBox::rejected, &dialog, &QDialog::reject);
    layout->addWidget(buttonBox);
 
    const bool accepted = dialog.exec() == QDialog::Accepted;
 
    if (skipCheckBox->isChecked()) {
        Settings::setUpdateCheckSkippedVersion(latestVersion);
    }
 
    // The check date is recorded by UpdateChecker::onReplyFinished — the
    // single writer — so no dialog outcome needs to touch it here.
    if (accepted) {
        if (hasDirectDownload) {
            downloadUpdate(latestVersion, downloadUrl);
        } else {
            QDesktopServices::openUrl(releaseUrl);
        }
    }
}
 
void UpdateController::downloadUpdate(const QString &latestVersion, const QUrl &url)
{
    const QString fileName = url.fileName();
    const QString downloadDir = QStandardPaths::writableLocation(QStandardPaths::DownloadLocation);
    // Not guaranteed to already exist -- e.g. a minimal/headless environment with no
    // pre-populated XDG user-dirs -- and QFile::open(WriteOnly) doesn't create missing
    // parent directories.
    QDir().mkpath(downloadDir);
    const QString savePath = QDir(downloadDir).filePath(fileName);
 
    // The progress dialog below is not window-modal, so the main window stays interactive and
    // Check for Updates can be triggered again mid-download. Raise the existing download
    // rather than starting a second one onto the same path.
    if (m_progressDialog) {
        m_progressDialog->raise();
        m_progressDialog->activateWindow();
        return;
    }
 
    auto *progress = new QProgressDialog(tr("Downloading wiRedPanda %1…").arg(latestVersion), tr("Cancel"), 0, 100, m_parent);
    progress->setWindowTitle(tr("Downloading Update"));
    // Deliberately NOT window-modal. QProgressDialog::setValue() calls processEvents() when the
    // dialog is modal, so driving it from downloadProgress re-enters the event loop: that nested
    // pump delivers finished(), which tears this dialog down, and setValue() then resumes on its
    // own freed QProgressBar. Cancel still works -- it is a button on this dialog, not something
    // modality provides.
    progress->setMinimumDuration(0);
    progress->setValue(0);
 
    auto *network = new QNetworkAccessManager(this);
    // QNetworkAccessManager::sslErrors doesn't exist at all when Qt is built with QT_NO_SSL --
    // the case for every Qt-for-WebAssembly build, since WASM has no native TLS backend and
    // routes network access through the browser instead (any TLS failure there surfaces as a
    // generic QNetworkReply error, not through this signal).
#ifndef QT_NO_SSL
    connect(network, &QNetworkAccessManager::sslErrors, this, [](QNetworkReply *reply, const QList<QSslError> &errors) {
        qWarning() << "MainWindow::downloadUpdate: SSL errors, aborting reply:" << errors;
        reply->abort();
    });
#endif
 
    QNetworkRequest request(url);
    request.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::NoLessSafeRedirectPolicy);
    request.setTransferTimeout(60000);
    QNetworkReply *reply = network->get(request);
 
    // Belt and braces around the non-modality above: the connection is severed the moment the
    // download finishes, and the dialog is reached through a QPointer so a delivery after its
    // destruction is skipped rather than fatal. Neither is sufficient on its own -- a guard
    // cannot help once the object dies inside the very setValue() call the guard permitted,
    // which is exactly what modality caused.
    const QPointer<QProgressDialog> progressGuard(progress);
    m_progressDialog = progress;
    const QMetaObject::Connection progressConnection =
        connect(reply, &QNetworkReply::downloadProgress, progress, [progressGuard](qint64 received, qint64 total) {
            if (total > 0 && progressGuard) {
                progressGuard->setValue(static_cast<int>(received * 100 / total));
            }
        });
 
    connect(progress, &QProgressDialog::canceled, reply, &QNetworkReply::abort);
 
    connect(reply, &QNetworkReply::finished, this, [this, reply, progressGuard, progressConnection, savePath] {
        // Before the dialog goes away, and before any modal box below opens a nested loop.
        disconnect(progressConnection);
        if (progressGuard) {
            progressGuard->close();
            progressGuard->deleteLater();
        }
 
        if (reply->error() != QNetworkReply::NoError) {
            if (reply->error() != QNetworkReply::OperationCanceledError) {
                QMessageBox::warning(m_parent, tr("Download Failed"), tr("Could not download the update:\n%1").arg(reply->errorString()));
            }
            reply->deleteLater();
            return;
        }
 
        QFile file(savePath);
        if (!file.open(QIODevice::WriteOnly)) {
            QMessageBox::warning(m_parent, tr("Download Failed"), tr("Could not save the file:\n%1").arg(savePath));
            reply->deleteLater();
            return;
        }
        const QByteArray payload = reply->readAll();
        if (file.write(payload) != payload.size()) {
            QMessageBox::warning(m_parent, tr("Download Failed"), tr("Could not write the file:\n%1").arg(savePath));
            reply->deleteLater();
            return;
        }
        file.close();
        reply->deleteLater();
 
        QMessageBox::information(m_parent, tr("Download Complete"),
            tr("wiRedPanda has been downloaded to:\n%1").arg(savePath));
    });
}