Introduce Event Services (#1653)

* Allow to enable/disable suspend & lock event handling

* Fix Windows

* Refactor event handling incl.CEC

* Revert "Auxiliary commit to revert individual files from 0d9a8b8a3a4a09609a339f54c7d8a9384c561282"

This reverts commit 80737d926ad151a07b2493dd1685ed502975cb2e.

* Support Events for Grabbers generically

* Have CECEvent to actions configurable, further clean-ups

* Remove handleEvent from V4L2grabber, as grabber will be stopped on suspend

* Validate that one CEC Event can only trigger one action

* MacOS lock/unlock added

* fast windows fix

* Corrections

* Fix CodeQL findings

* add macos lock/unlock handler

* Migration of CEC-config and have default actions

* Correct target_link_libraries

* Include Foundation

* macOS include AppKit

* Support Scheduled Events, cleanups.

* Fix destructing

* Fix coredump during free

* Consider additional error sceanrio

* Fix missing code

* install desktop icons

* correct bash logic

---------

Co-authored-by: Paulchen-Panther <16664240+Paulchen-Panther@users.noreply.github.com>

include/events/EventEnum.h

@@ -0,0 +1,50 @@
+#ifndef EVENTENUM_H
+#define EVENTENUM_H
+
+#include <QString>
+
+enum class Event
+{
+	Unknown,
+	Suspend,
+	Resume,
+	ToggleSuspend,
+	Idle,
+	ResumeIdle,
+	ToggleIdle,
+	Reload,
+	Restart
+};
+
+inline const char* eventToString(Event event)
+{
+	switch (event)
+	{
+	case Event::Suspend:       return "Suspend";
+	case Event::Resume:        return "Resume";
+	case Event::ToggleSuspend: return "ToggleSuspend";
+	case Event::Idle:          return "Idle";
+	case Event::ResumeIdle:    return "ResumeIdle";
+	case Event::ToggleIdle:    return "ToggleIdle";
+	case Event::Reload:        return "Reload";
+	case Event::Restart:       return "Restart";
+	case Event::Unknown:
+	default:                   return "Unknown";
+	}
+}
+
+inline Event stringToEvent(const QString& event)
+{
+	if (event.compare("Suspend")==0)       return Event::Suspend;
+	if (event.compare("Resume")==0)        return Event::Resume;
+	if (event.compare("ToggleSuspend")==0) return Event::ToggleSuspend;
+	if (event.compare("Idle")==0)          return Event::Idle;
+	if (event.compare("ResumeIdle")==0)    return Event::ResumeIdle;
+	if (event.compare("ToggleIdle")==0)    return Event::ToggleIdle;
+	if (event.compare("Reload")==0)        return Event::Reload;
+	if (event.compare("Restart")==0)       return Event::Restart;
+	return Event::Unknown;
+}
+
+
+#endif // EVENTENUM_H

include/events/EventHandler.h

@@ -0,0 +1,49 @@
+#ifndef EVENTHANDLER_H
+#define EVENTHANDLER_H
+
+#include <utils/settings.h>
+#include <events/EventEnum.h>
+
+#include <QObject>
+
+class Logger;
+
+class EventHandler : public QObject
+{
+	Q_OBJECT
+
+public:
+	EventHandler();
+	~EventHandler() override;
+
+	static EventHandler* getInstance();
+
+public slots:
+
+	void suspend(bool sleep);
+
+	void suspend();
+	void resume();
+	void toggleSuspend();
+
+	void idle(bool isIdle);
+	void idle();
+	void resumeIdle();
+	void toggleIdle();
+
+	void handleEvent(Event event);
+
+signals:
+	void signalEvent(Event event);
+
+protected:
+	Logger * _log {};
+
+private:
+	bool _isSuspended;
+	bool _isIdle;
+};
+
+
+#endif // EVENTHANDLER_H
+

include/events/EventScheduler.h

@@ -0,0 +1,55 @@
+#ifndef EVENTSCHEDULER_H
+#define EVENTSCHEDULER_H
+#include <QObject>
+#include <QJsonDocument>
+#include <QTime>
+#include <QTimer>
+
+#include <events/EventEnum.h>
+#include <utils/settings.h>
+
+class Logger;
+
+class EventScheduler : public QObject
+{
+	Q_OBJECT
+
+public:
+	EventScheduler();
+	~EventScheduler() override;
+
+	virtual void handleSettingsUpdate(settings::type type, const QJsonDocument& config);
+
+signals:
+	void signalEvent(Event event);
+
+private slots:
+
+	void handleEvent(int timerIndex);
+
+private:
+
+	struct timeEvent
+	{
+		QTime time;
+		Event action;
+	};
+
+	bool enable();
+	void disable();
+
+	int getMillisecondsToNextScheduledTime(const QTime& time);
+
+	void clearTimers();
+
+	QJsonDocument _config;
+
+	bool _isEnabled;
+
+	QList<timeEvent> _scheduledEvents;
+	QList<QTimer*> _timers;
+
+	Logger * _log {};
+};
+
+#endif // EVENTSCHEDULER_H

include/events/OsEventHandler.h

@@ -0,0 +1,132 @@
+#ifndef OSEVENTHANDLER_H
+#define OSEVENTHANDLER_H
+#include <QObject>
+#include <QJsonDocument>
+
+#include <events/EventEnum.h>
+
+#if defined(_WIN32)
+#include <QAbstractNativeEventFilter>
+#include <QAbstractEventDispatcher>
+#include <QWidget>
+#include <windows.h>
+#endif
+
+#include <utils/settings.h>
+
+class Logger;
+
+class OsEventHandlerBase : public QObject
+{
+	Q_OBJECT
+
+public:
+	OsEventHandlerBase();
+	~OsEventHandlerBase() override;
+
+public slots:
+	void suspend(bool sleep);
+	void lock(bool isLocked);
+
+	virtual void handleSettingsUpdate(settings::type type, const QJsonDocument& config);
+
+signals:
+	void signalEvent(Event event);
+
+protected:
+	virtual bool registerOsEventHandler() { return true; }
+	virtual void unregisterOsEventHandler() {}
+	virtual bool registerLockHandler() { return true; }
+	virtual void unregisterLockHandler() {}
+
+	bool _isSuspendEnabled;
+	bool _isLockEnabled;
+	bool _isSuspendOnLock;
+
+	bool _isSuspendRegistered;
+	bool _isLockRegistered;
+
+	Logger * _log {};
+};
+
+#if defined(_WIN32)
+
+class OsEventHandlerWindows : public OsEventHandlerBase, public QAbstractNativeEventFilter
+{
+
+public:
+	OsEventHandlerWindows();
+	~OsEventHandlerWindows() override;
+
+protected:
+#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
+	bool nativeEventFilter(const QByteArray& eventType, void* message, qintptr* result) override;
+#else
+	bool nativeEventFilter(const QByteArray& eventType, void* message, long int* result) override;
+#endif
+
+private:
+	bool registerOsEventHandler() override;
+	void unregisterOsEventHandler() override;
+	bool registerLockHandler() override;
+	void unregisterLockHandler() override;
+
+	QWidget			_widget;
+	HPOWERNOTIFY	_notifyHandle;
+};
+
+using OsEventHandler = OsEventHandlerWindows;
+
+#elif defined(__linux__)
+class OsEventHandlerLinux : public OsEventHandlerBase
+{
+	Q_OBJECT
+
+	static void static_signaleHandler(int signum)
+	{
+		OsEventHandlerLinux::getInstance()->handleSignal(signum);
+	}
+
+public:
+	OsEventHandlerLinux();
+
+	void handleSignal (int signum);
+
+private:
+	static OsEventHandlerLinux* getInstance();
+
+#if defined(HYPERION_HAS_DBUS)
+	bool registerOsEventHandler() override;
+	void unregisterOsEventHandler() override;
+	bool registerLockHandler() override;
+	void unregisterLockHandler() override;
+#endif
+};
+
+using OsEventHandler = OsEventHandlerLinux;
+
+#elif defined(__APPLE__)
+class OsEventHandlerMacOS : public OsEventHandlerBase
+{
+	Q_OBJECT
+
+public:
+	OsEventHandlerMacOS();
+
+private:
+	bool registerOsEventHandler() override;
+	void unregisterOsEventHandler() override;
+	bool registerLockHandler() override;
+	void unregisterLockHandler() override;
+
+	void *_sleepEventHandler;
+	void *_lockEventHandler;
+};
+
+using OsEventHandler = OsEventHandlerMacOS;
+
+#else
+using OsEventHandler = OsEventHandlerBase;
+#endif
+
+#endif // OSEVENTHANDLER_H