updater.h

#ifndef QTAUTOUPDATER_UPDATER_H
#define QTAUTOUPDATER_UPDATER_H
 
#include <chrono>
 
#include <QtCore/qobject.h>
#include <QtCore/qstring.h>
#include <QtCore/qlist.h>
#include <QtCore/qstringlist.h>
#include <QtCore/qdatetime.h>
 
#include "QtAutoUpdaterCore/qtautoupdatercore_global.h"
#include "QtAutoUpdaterCore/updateinfo.h"
#include "QtAutoUpdaterCore/adminauthoriser.h"
#include "QtAutoUpdaterCore/updaterbackend.h"
 
class QSettings;
 
namespace QtAutoUpdater
{
 
class UpdateInstaller;
 
class UpdaterPrivate;
class Q_AUTOUPDATERCORE_EXPORT Updater : public QObject
{
    Q_OBJECT
 
    Q_PROPERTY(QtAutoUpdater::UpdaterBackend::Features features READ features CONSTANT)
    Q_PROPERTY(QtAutoUpdater::Updater::State state READ state NOTIFY stateChanged)
    Q_PROPERTY(bool running READ isRunning NOTIFY runningChanged)
    Q_PROPERTY(QList<QtAutoUpdater::UpdateInfo> updateInfo READ updateInfo NOTIFY updateInfoChanged)
    Q_PROPERTY(bool runOnExit READ willRunOnExit RESET cancelExitRun NOTIFY runOnExitChanged)
 
public:
    enum class State {
        NoUpdates = 0,  
        Checking,  
        Canceling,  
        NewUpdates,  
        Installing,  
 
        Error = -1  
    };
    Q_ENUM(State)
 
    
    enum class InstallModeFlag {
        Parallel = 0x00,  
        OnExit = 0x01,  
 
        Force = 0x02, 
 
        ForceOnExit = (OnExit | Force) 
    };
    Q_DECLARE_FLAGS(InstallMode, InstallModeFlag)
    Q_FLAG(InstallMode)
 
    
    enum class InstallScope {
        PreferInternal,  
        PreferExternal  
    };
    Q_ENUM(InstallScope)
 
    
    static QStringList supportedUpdaterBackends();
 
    static Updater *create(QObject *parent = nullptr);
    static Updater *create(const QString &configPath,
                           QObject *parent = nullptr);
    static Updater *create(QSettings *config,
                           QObject *parent = nullptr);
    static Updater *create(QString key,
                           QVariantMap configuration,
                           QObject *parent = nullptr);
    static Updater *create(UpdaterBackend::IConfigReader *configReader,
                           QObject *parent = nullptr);
 
    ~Updater() override;
 
    Q_INVOKABLE QtAutoUpdater::UpdaterBackend *backend() const;
 
    UpdaterBackend::Features features() const;
    State state() const;
    bool isRunning() const;
    QList<UpdateInfo> updateInfo() const;
    bool willRunOnExit() const;
 
    int scheduleUpdate(std::chrono::seconds delaySeconds, bool repeated = false);
    Q_INVOKABLE int scheduleUpdate(int delaySeconds, bool repeated = false);
    template <typename TRep, typename TPeriod>
    int scheduleUpdate(const std::chrono::duration<TRep, TPeriod> &delaySeconds, bool repeated = false);
    Q_INVOKABLE int scheduleUpdate(const QDateTime &when);
    template <typename TClock, typename TDur>
    int scheduleUpdate(const std::chrono::time_point<TClock, TDur> &when);
 
    Q_INVOKABLE bool runUpdater(InstallMode mode = InstallModeFlag::Parallel,
                                InstallScope scope = InstallScope::PreferInternal);
 
public Q_SLOTS:
    void checkForUpdates();
    void abortUpdateCheck(int killDelay = 5000);
 
    void cancelScheduledUpdate(int taskId);
 
    void cancelExitRun();
 
Q_SIGNALS:
    void checkUpdatesDone(QtAutoUpdater::Updater::State result, QPrivateSignal);
    void progressChanged(double progress, const QString &status, QPrivateSignal);
    void showInstaller(QtAutoUpdater::UpdateInstaller *installer, QPrivateSignal);
    void installDone(bool success, QPrivateSignal);
 
    void stateChanged(QtAutoUpdater::Updater::State state, QPrivateSignal);
    void runningChanged(bool running, QPrivateSignal);
    void updateInfoChanged(QList<QtAutoUpdater::UpdateInfo> updateInfo, QPrivateSignal);
    void runOnExitChanged(bool runOnExit, QPrivateSignal);
 
protected:
    explicit Updater(QObject *parent = nullptr);
    explicit Updater(UpdaterPrivate &dd, QObject *parent = nullptr);
 
private:
    Q_DECLARE_PRIVATE(Updater)
    Q_DISABLE_COPY(Updater)
 
    Q_PRIVATE_SLOT(d_func(), void _q_appAboutToExit())
    Q_PRIVATE_SLOT(d_func(), void _q_checkDone(bool, QList<UpdateInfo>))
    Q_PRIVATE_SLOT(d_func(), void _q_triggerInstallDone(bool))
};
 
template<typename TRep, typename TPeriod>
int Updater::scheduleUpdate(const std::chrono::duration<TRep, TPeriod> &delaySeconds, bool repeated)
{
    using namespace std::chrono;
    return scheduleUpdate(duration_cast<seconds>(delaySeconds), repeated);
}
 
template<typename TClock, typename TDur>
int Updater::scheduleUpdate(const std::chrono::time_point<TClock, TDur> &when)
{
    using namespace std::chrono;
    return scheduleUpdate(QDateTime::fromSecsSinceEpoch(duration_cast<seconds>(
                                                            time_point_cast<system_clock>(when)
                                                            .time_since_epoch())));
}
 
}
 
Q_DECLARE_METATYPE(QtAutoUpdater::Updater::State)
Q_DECLARE_OPERATORS_FOR_FLAGS(QtAutoUpdater::Updater::InstallMode)
 
#endif // QTAUTOUPDATER_UPDATER_H