updated internal schedule handling

Author: Skycoder42

AutoUpdaterCore/AutoUpdaterCore.pro

@@ -13,12 +13,14 @@ CONFIG += staticlib
 
 SOURCES += \
     updater.cpp \
-    updater_p.cpp
+    updater_p.cpp \
+    simplescheduler.cpp
 
 HEADERS += \
     updater.h \
     updater_p.h \
-	adminauthoriser.h
+	adminauthoriser.h \
+    simplescheduler.h
 
 DISTFILES += \
     adminauthoriser.dox \

AutoUpdaterCore/simplescheduler.cpp

@@ -0,0 +1,47 @@
+#include "simplescheduler.h"
+#include <QTimerEvent>
+#include "updater.h"
+
+SimpleScheduler::SimpleScheduler(QObject *parent) :
+	QObject(parent),
+	timerHash()
+{}
+
+int SimpleScheduler::startSchedule(int msecs, bool repeated, const QVariant &parameter)
+{
+	if(msecs < 0) {
+		qCWarning(logQtAutoUpdater, "Cannot schedule update tasks for the past!");
+		return 0;
+	}
+
+	const int id = this->startTimer(msecs, Qt::VeryCoarseTimer);
+	if(id != 0)
+		this->timerHash.insert(id, {repeated, parameter});
+	return id;
+}
+
+int SimpleScheduler::startSchedule(const QDateTime &when, const QVariant &parameter)
+{
+	const qint64 delta = QDateTime::currentDateTime().msecsTo(when);
+	if(delta > INT_MAX) {
+		qCWarning(logQtAutoUpdater, "Time interval to big, timepoint to far in the future.");
+		return 0;
+	} else
+		return this->startSchedule((int)delta, false, parameter);
+}
+
+void SimpleScheduler::cancelSchedule(int id)
+{
+	this->killTimer(id);
+	this->timerHash.remove(id);
+}
+
+void SimpleScheduler::timerEvent(QTimerEvent *event)
+{
+	const int id = event->timerId();
+	TimerInfo info = this->timerHash.value(id, {false, QVariant()});
+	if(!info.first)
+		this->cancelSchedule(id);
+	emit scheduleTriggered(id, info.second);
+	event->accept();
+}

AutoUpdaterCore/simplescheduler.h

@@ -0,0 +1,33 @@
+#ifndef SIMPLESCHEDULER_H
+#define SIMPLESCHEDULER_H
+
+#include <QObject>
+#include <QVariant>
+#include <QDateTime>
+#include <QPair>
+#include <QHash>
+
+class SimpleScheduler : public QObject
+{
+	Q_OBJECT
+public:
+	explicit SimpleScheduler(QObject *parent = 0);
+
+public slots:
+	int startSchedule(int msecs, bool repeated = false, const QVariant &parameter = QVariant());
+	int startSchedule(const QDateTime &when, const QVariant &parameter = QVariant());
+	void cancelSchedule(int id);
+
+signals:
+	void scheduleTriggered(int id, const QVariant &parameter);
+
+protected:
+	void timerEvent(QTimerEvent *event) override;
+
+private:
+	typedef QPair<bool, QVariant> TimerInfo;
+
+	QHash<int, TimerInfo> timerHash;
+};
+
+#endif // SIMPLESCHEDULER_H

AutoUpdaterCore/updater.cpp

@@ -84,33 +84,24 @@ void Updater::abortUpdateCheck(int maxDelay, bool async)
 
 int Updater::scheduleUpdate(int delaySeconds, bool repeated)
 {
-	if(delaySeconds < 0) {
-		qCWarning(logQtAutoUpdater, "Cannot schedule update tasks for the past!");
+	if((((qint64)delaySeconds) * 1000) > INT_MAX) {
+		qCWarning(logQtAutoUpdater) << "delaySeconds to big to be converted to msecs";
 		return 0;
 	}
-
 	Q_D(Updater);
-	int id = d->startTimer(delaySeconds * 1000, Qt::VeryCoarseTimer);
-	if(repeated && id != 0)
-		d->repeatTasks.insert(id);
-	return id;
+	return d->scheduler->startSchedule(delaySeconds * 1000, repeated);
 }
 
 int Updater::scheduleUpdate(const QDateTime &when)
 {
-	qint64 delta = QDateTime::currentDateTime().secsTo(when);
-	if(delta > INT_MAX) {
-		qCWarning(logQtAutoUpdater, "Time interval to big, timepoint to far in the future.");
-		return 0;
-	} else
-		return this->scheduleUpdate((int)delta, false);
+	Q_D(Updater);
+	return d->scheduler->startSchedule(when);
 }
 
 void Updater::cancelScheduledUpdate(int taskId)
 {
 	Q_D(Updater);
-	d->killTimer(taskId);
-	d->repeatTasks.remove(taskId);
+	d->scheduler->cancelSchedule(taskId);
 }
 
 void Updater::runUpdaterOnExit(const QStringList &arguments, AdminAuthoriser *authoriser)

AutoUpdaterCore/updater_p.cpp

@@ -5,7 +5,7 @@
 #include <QFileInfo>
 #include <QDir>
 #include <QXmlStreamReader>
-#include <QTimerEvent>
+#include <QTimer>
 using namespace QtAutoUpdater;
 
 UpdaterPrivate::UpdaterPrivate(Updater *q_ptr) :
@@ -18,13 +18,15 @@ UpdaterPrivate::UpdaterPrivate(Updater *q_ptr) :
 	lastErrorLog(),
 	running(false),
 	mainProcess(nullptr),
-	repeatTasks(),
+	scheduler(new SimpleScheduler(this)),
 	runOnExit(false),
 	runArguments(),
 	adminAuth(nullptr)
 {
 	connect(qApp, &QCoreApplication::aboutToQuit,
 			this, &UpdaterPrivate::appAboutToExit);
+	connect(this->scheduler, &SimpleScheduler::scheduleTriggered,
+			this, &UpdaterPrivate::startUpdateCheck);
 }
 
 UpdaterPrivate::~UpdaterPrivate()
@@ -223,12 +225,3 @@ void UpdaterPrivate::appAboutToExit()
 		this->runOnExit = false;//prevent warning
 	}
 }
-
-void UpdaterPrivate::timerEvent(QTimerEvent *event)
-{
-	if(!this->repeatTasks.contains(event->timerId()))
-		this->killTimer(event->timerId());
-	event->accept();
-
-	this->startUpdateCheck();
-}

AutoUpdaterCore/updater_p.h

@@ -2,10 +2,10 @@
 #define UPDATER_P_H
 
 #include "updater.h"
-#include <QTimer>
 #include <QProcess>
 #include <QScopedPointer>
 #include <exception>
+#include "simplescheduler.h"
 
 template<typename... Args> struct SELECT {
 	template<typename C, typename R>
@@ -45,7 +45,7 @@ namespace QtAutoUpdater
 		bool running;
 		QProcess *mainProcess;
 
-		QSet<int> repeatTasks;
+		SimpleScheduler *scheduler;
 
 		bool runOnExit;
 		QStringList runArguments;
@@ -65,9 +65,6 @@ namespace QtAutoUpdater
 		void updaterError(QProcess::ProcessError error);
 
 		void appAboutToExit();
-
-	protected:
-		void timerEvent(QTimerEvent *event) Q_DECL_OVERRIDE;
 	};
 }
 

AutoUpdaterGui/updatecontroller.cpp

@@ -4,7 +4,6 @@
 #include <QCoreApplication>
 #include <QDir>
 #include <QFileInfo>
-#include <QTimerEvent>
 #include <dialogmaster.h>
 #include "adminauthorization.h"
 #include "updatebutton.h"
@@ -205,47 +204,24 @@ bool UpdateController::cancelUpdate(int maxDelay)
 
 int UpdateController::scheduleUpdate(int delaySeconds, bool repeated, UpdateController::DisplayLevel displayLevel)
 {
+	if((((qint64)delaySeconds) * 1000) > INT_MAX) {
+		qCWarning(logQtAutoUpdater) << "delaySeconds to big to be converted to msecs";
+		return 0;
+	}
 	Q_D(UpdateController);
-	int id = this->startTimer(delaySeconds * 1000, Qt::VeryCoarseTimer);
-	if(id != 0)
-		d->updateTasks.insert(id, {displayLevel, repeated});
-	return id;
+	return d->scheduler->startSchedule(delaySeconds * 1000, repeated, QVariant::fromValue(displayLevel));
 }
 
 int UpdateController::scheduleUpdate(const QDateTime &when, UpdateController::DisplayLevel displayLevel)
-{
-	qint64 delta = QDateTime::currentDateTime().secsTo(when);
-	if(delta > INT_MAX) {
-		qCWarning(logQtAutoUpdater, "Time interval to big, timepoint to far in the future.");
-		return 0;
-	} else
-		return this->scheduleUpdate((int)delta, false, displayLevel);
-}
-
-void UpdateController::cancelScheduledUpdate(int taskId)
 {
 	Q_D(UpdateController);
-	this->killTimer(taskId);
-	d->updateTasks.remove(taskId);
+	return d->scheduler->startSchedule(when, QVariant::fromValue(displayLevel));
 }
 
-void UpdateController::timerEvent(QTimerEvent *event)
+void UpdateController::cancelScheduledUpdate(int taskId)
 {
 	Q_D(UpdateController);
-	int tId = event->timerId();
-	if(d->updateTasks.contains(tId)) {
-		UpdateControllerPrivate::UpdateTask task = d->updateTasks[tId];
-		if(!task.second) {
-			d->updateTasks.remove(tId);
-			this->killTimer(tId);
-		}
-		event->accept();
-
-		this->start(task.first);
-	} else {
-		this->killTimer(tId);
-		event->ignore();
-	}
+	d->scheduler->cancelSchedule(taskId);
 }
 
 void UpdateController::checkUpdatesDone(bool hasUpdates, bool hasError)
@@ -336,13 +312,18 @@ void UpdateController::checkUpdatesDone(bool hasUpdates, bool hasError)
 	emit runningChanged(false);
 }
 
+void UpdateController::timerTriggered(int, const QVariant &parameter)
+{
+	if(parameter.canConvert<DisplayLevel>())
+		this->start(parameter.value<DisplayLevel>());
+}
+
 //-----------------PRIVATE IMPLEMENTATION-----------------
 
 UpdateControllerPrivate::UpdateControllerPrivate(UpdateController *q_ptr, QWidget *window) :
 	UpdateControllerPrivate(q_ptr, QString(), window)
 {}
 
-#include <QDebug>
 UpdateControllerPrivate::UpdateControllerPrivate(UpdateController *q_ptr, const QString &toolPath, QWidget *window) :
 	q_ptr(q_ptr),
 	window(window),
@@ -355,11 +336,13 @@ UpdateControllerPrivate::UpdateControllerPrivate(UpdateController *q_ptr, const
 	detailedInfo(true),
 	checkUpdatesProgress(nullptr),
 	wasCanceled(false),
-	updateTasks()
+	scheduler(new SimpleScheduler(q_ptr))
 {
 	QObject::connect(this->mainUpdater, &Updater::checkUpdatesDone,
 					 q_ptr, &UpdateController::checkUpdatesDone,
 					 Qt::QueuedConnection);
+	QObject::connect(this->scheduler, &SimpleScheduler::scheduleTriggered,
+					 q_ptr, &UpdateController::timerTriggered);
 
 #ifdef Q_OS_UNIX
 	//TODO test

AutoUpdaterGui/updatecontroller.h

@@ -103,12 +103,9 @@ namespace QtAutoUpdater
 		//! NOTIFY-Accessor for UpdateController::runAsAdmin
 		void runAsAdminChanged(bool runAsAdmin);
 
-	protected:
-		//! Reimplemented to allow update scheduling
-		void timerEvent(QTimerEvent *event) Q_DECL_FINAL;
-
 	private slots:
 		void checkUpdatesDone(bool hasUpdates, bool hasError);
+		void timerTriggered(int, const QVariant &parameter);
 
 	private:
 		UpdateControllerPrivate *d_ptr;

AutoUpdaterGui/updatecontroller_p.h

@@ -6,6 +6,7 @@
 #include "updatecontroller.h"
 #include "progressdialog.h"
 #include "updateinfodialog.h"
+#include "simplescheduler.h"
 
 namespace QtAutoUpdater
 {
@@ -29,7 +30,7 @@ namespace QtAutoUpdater
 		QPointer<ProgressDialog> checkUpdatesProgress;
 		bool wasCanceled;
 
-		QHash<int, UpdateTask> updateTasks;
+		SimpleScheduler *scheduler;
 
 		UpdateControllerPrivate(UpdateController *q_ptr, QWidget *window);
 		UpdateControllerPrivate(UpdateController *q_ptr, const QString &toolPath, QWidget *window);