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/api/JsonAPI.h

@@ -2,6 +2,7 @@
 
 // parent class
 #include <api/API.h>
+#include <events/EventEnum.h>
 
 // hyperion includes
 #include <utils/Components.h>
@@ -105,24 +106,9 @@ signals:
 	void forwardJsonMessage(QJsonObject);
 
 	///
-	/// Signal emits whenever a suspend/resume request for all instances should be forwarded
+	/// Signal emits whenever a hyperion event request for all instances should be forwarded
 	///
-	void suspendAll(bool isSuspend);
-
-	///
-	/// Signal emits whenever a toggle suspend/resume request for all instances should be forwarded
-	///
-	void toggleSuspendAll();
-
-	///
-	/// Signal emits whenever a idle mode request for all instances should be forwarded
-	///
-	void idleAll(bool isIdle);
-
-	///
-	/// Signal emits whenever a toggle idle/working mode request for all instances should be forwarded
-	///
-	void toggleIdleAll();
+	void signalEvent(Event event);
 
 private:
 	// true if further callbacks are forbidden (http)

include/cec/CECEvent.h

@@ -1,8 +0,0 @@
-#pragma once
-
-enum class CECEvent
-{
-        On,
-        Off
-};
-

include/cec/CECHandler.h

@@ -2,12 +2,14 @@
 
 #include <QObject>
 #include <QVector>
+#include <QMap>
 
 #include <iostream>
 
 #include <libcec/cec.h>
 
-#include <cec/CECEvent.h>
+#include <utils/settings.h>
+#include <events/EventEnum.h>
 
 using CECCallbacks         = CEC::ICECCallbacks;
 using CECAdapter           = CEC::ICECAdapter;
@@ -30,19 +32,28 @@ class CECHandler : public QObject
 {
 	Q_OBJECT
 public:
-	CECHandler();
+	CECHandler(const QJsonDocument& config, QObject * parent = nullptr);
 	~CECHandler() override;
 
 	QString scan() const;
 
 public slots:
+
 	bool start();
 	void stop();
 
-signals:
-	void cecEvent(CECEvent event);
+	virtual void handleSettingsUpdate(settings::type type, const QJsonDocument& config);
 
 private:
+
+signals:
+	void signalEvent(Event event);
+
+private:
+
+	bool enable();
+	void disable();
+
 	/* CEC Callbacks */
 	static void onCecLogMessage           (void * context, const CECLogMessage * message);
 	static void onCecKeyPress             (void * context, const CECKeyPress * key);
@@ -57,6 +68,11 @@ private:
 	bool openAdapter(const CECAdapterDescriptor & descriptor);
 	void printAdapter(const CECAdapterDescriptor & descriptor) const;
 
+	// CEC Event Strings per https://github.com/Pulse-Eight/libcec/blob/master/src/libcec/CECTypeUtils.h
+	void triggerAction(const QString& cecEvent);
+
+	QJsonDocument _config;
+
 	/* CEC Helpers */
 	CECCallbacks getCallbacks() const;
 	CECConfig getConfig() const;
@@ -65,5 +81,14 @@ private:
 	CECCallbacks _cecCallbacks {};
 	CECConfig    _cecConfig    {};
 
+	bool _isInitialised;
+	bool _isEnabled;
+
+	int _buttonReleaseDelayMs;
+	int _buttonRepeatRateMs;
+	int _doubleTapTimeoutMs;
+
+	QMap<QString,Event> _cecEventActionMap;
+
 	Logger * _logger {};
 };

include/db/SettingsTable.h

@@ -112,6 +112,8 @@ public:
 		list << "jsonServer" << "protoServer" << "flatbufServer" << "forwarder" << "webConfig" << "network"
 		// capture
 		<< "framegrabber" << "grabberV4L2" << "grabberAudio"
+		//Events
+		 << "osEvents" << "cecEvents" << "schedEvents"
 		// other
 		<< "logger" << "general";
 

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

include/grabber/video/VideoWrapper.h

@@ -9,10 +9,6 @@
 	#include <grabber/video/v4l2/V4L2Grabber.h>
 #endif
 
-#if defined(ENABLE_CEC)
-	#include <cec/CECEvent.h>
-#endif
-
 class VideoWrapper : public GrabberWrapper
 {
 	Q_OBJECT
@@ -25,10 +21,6 @@ public slots:
 	bool start() override;
 	void stop() override;
 
-#if defined(ENABLE_CEC)
-	void handleCecEvent(CECEvent event);
-#endif
-
 	void handleSettingsUpdate(settings::type type, const QJsonDocument& config) override;
 
 private slots:

include/grabber/video/v4l2/V4L2Grabber.h

@@ -24,9 +24,7 @@
 // Determine the cmake options
 #include <HyperionConfig.h>
 
-#if defined(ENABLE_CEC)
-	#include <cec/CECEvent.h>
-#endif
+#include <events/EventEnum.h>
 
 ///
 /// Capture class for V4L2 devices
@@ -77,13 +75,10 @@ public:
 	void setSignalThreshold(double redSignalThreshold, double greenSignalThreshold, double blueSignalThreshold, int noSignalCounterThreshold = 50);
 	void setSignalDetectionOffset( double verticalMin, double horizontalMin, double verticalMax, double horizontalMax);
 	void setSignalDetectionEnable(bool enable);
-	void setCecDetectionEnable(bool enable);
 	bool reload(bool force = false);
 
 	QRectF getSignalDetectionOffset() const { return QRectF(_x_frac_min, _y_frac_min, _x_frac_max, _y_frac_max); } //used from hyperion-v4l2
 
-
-
 	///
 	/// @brief Discover available V4L2 USB devices (for configuration).
 	/// @param[in] params Parameters used to overwrite discovery default behaviour
@@ -97,10 +92,6 @@ public slots:
 	void stop();
 	void newThreadFrame(Image<ColorRgb> image);
 
-#if defined(ENABLE_CEC)
-	void handleCecEvent(CECEvent event);
-#endif
-
 signals:
 	void newFrame(const Image<ColorRgb> & image);
 	void readError(const char* err);
@@ -167,7 +158,7 @@ private:
 	// signal detection
 	int      _noSignalCounterThreshold;
 	ColorRgb _noSignalThresholdColor;
-	bool     _cecDetectionEnabled, _cecStandbyActivated, _signalDetectionEnabled, _noSignalDetected;
+	bool     _standbyActivated, _signalDetectionEnabled, _noSignalDetected;
 	int      _noSignalCounter;
 	int		_brightness, _contrast, _saturation, _hue;
 	double   _x_frac_min;

include/hyperion/Grabber.h

@@ -11,6 +11,8 @@
 #include <utils/Logger.h>
 #include <utils/Components.h>
 
+#include <events/EventEnum.h>
+
 ///
 /// @brief The Grabber class is responsible to apply image resizes (with or without ImageResampler)
 
@@ -111,6 +113,10 @@ public:
 
 	QString getGrabberName() const { return _grabberName; }
 
+public slots:
+
+	virtual void handleEvent(Event event) {}
+
 protected slots:
 	///
 	/// @brief Set device in error state

include/hyperion/GrabberWrapper.h

@@ -18,6 +18,8 @@
 
 #include <grabber/GrabberType.h>
 
+#include <events/EventEnum.h>
+
 class Grabber;
 class GlobalSignals;
 class QTimer;
@@ -139,6 +141,8 @@ public slots:
 	///
 	virtual void handleSettingsUpdate(settings::type type, const QJsonDocument& config);
 
+	void handleEvent(Event event);
+
 signals:
 	///
 	/// @brief Emit the final processed image

include/hyperion/HyperionIManager.h

@@ -5,6 +5,7 @@
 #include <utils/VideoMode.h>
 #include <utils/settings.h>
 #include <utils/Components.h>
+#include <events/EventEnum.h>
 
 // qt
 #include <QMap>
@@ -74,20 +75,10 @@ public slots:
 	bool stopInstance(quint8 inst);
 
 	///
-	/// @brief Suspend (disable) all Hyperion instances
+	/// @brief Handle an Hyperion Event
+	/// @param event Event to be processed
 	///
-	void suspend();
-
-	///
-	/// @brief Resume (resume) all Hyperion instances
-	///
-	void resume();
-
-	///
-	/// @brief Toggle the state of all Hyperion instances for an idle sceanrio (user is not interacting with the system
-	/// @param isIdle, If true all instances toggle to idle, else to resume
-	///
-	void toggleIdle(bool isIdle);
+	void handleEvent(Event event);
 
 	///
 	/// @brief Toggle the state of all Hyperion instances
@@ -141,10 +132,6 @@ signals:
 	///
 	void startInstanceResponse(QObject *caller, const int &tan);
 
-	void triggerSuspend(bool isSuspend);
-	void triggerToggleSuspend();
-	void triggerIdle(bool isIdle);
-	void triggerToggleIdle();
 
 signals:
 	///////////////////////////////////////
@@ -186,6 +173,18 @@ private slots:
 	///
 	void handleFinished();
 
+	///
+	/// @brief Toggle the state of all Hyperion instances for a suspend sceanrio (user is not interacting with the system)
+	/// @param isSuspend, If true all instances toggle to suspend, else to resume
+	///
+	void toggleSuspend(bool isSuspend);
+
+	///
+	/// @brief Toggle the state of all Hyperion instances for an idle sceanrio
+	/// @param isIdle, If true all instances toggle to idle, else to resume
+	///
+	void toggleIdle(bool isIdle);
+
 private:
 	friend class HyperionDaemon;
 	///

include/utils/settings.h

@@ -30,6 +30,9 @@ namespace settings {
 		NETWORK,
 		FLATBUFSERVER,
 		PROTOSERVER,
+		OSEVENTS,
+		CECEVENTS,
+		SCHEDEVENTS,
 		INVALID
 	};
 
@@ -42,29 +45,32 @@ namespace settings {
 	{
 		switch (type)
 		{
-			case BGEFFECT:      return "backgroundEffect";
-			case FGEFFECT:      return "foregroundEffect";
-			case BLACKBORDER:   return "blackborderdetector";
-			case BOBLSERVER:    return "boblightServer";
-			case COLOR:         return "color";
-			case DEVICE:        return "device";
-			case EFFECTS:       return "effects";
-			case NETFORWARD:    return "forwarder";
-			case SYSTEMCAPTURE: return "framegrabber";
-			case GENERAL:       return "general";
-			case V4L2:          return "grabberV4L2";
-			case AUDIO:			return "grabberAudio";
-			case JSONSERVER:    return "jsonServer";
-			case LEDCONFIG:     return "ledConfig";
-			case LEDS:          return "leds";
-			case LOGGER:        return "logger";
-			case SMOOTHING:     return "smoothing";
-			case WEBSERVER:     return "webConfig";
-			case INSTCAPTURE:   return "instCapture";
-			case NETWORK:       return "network";
-			case FLATBUFSERVER: return "flatbufServer";
-			case PROTOSERVER:   return "protoServer";
-			default:            return "invalid";
+		case BGEFFECT:      return "backgroundEffect";
+		case FGEFFECT:      return "foregroundEffect";
+		case BLACKBORDER:   return "blackborderdetector";
+		case BOBLSERVER:    return "boblightServer";
+		case COLOR:         return "color";
+		case DEVICE:        return "device";
+		case EFFECTS:       return "effects";
+		case NETFORWARD:    return "forwarder";
+		case SYSTEMCAPTURE: return "framegrabber";
+		case GENERAL:       return "general";
+		case V4L2:          return "grabberV4L2";
+		case AUDIO:			return "grabberAudio";
+		case JSONSERVER:    return "jsonServer";
+		case LEDCONFIG:     return "ledConfig";
+		case LEDS:          return "leds";
+		case LOGGER:        return "logger";
+		case SMOOTHING:     return "smoothing";
+		case WEBSERVER:     return "webConfig";
+		case INSTCAPTURE:   return "instCapture";
+		case NETWORK:       return "network";
+		case FLATBUFSERVER: return "flatbufServer";
+		case PROTOSERVER:   return "protoServer";
+		case OSEVENTS:      return "osEvents";
+		case CECEVENTS:     return "cecEvents";
+		case SCHEDEVENTS:   return "schedEvents";
+		default:            return "invalid";
 		}
 	}
 
@@ -97,6 +103,9 @@ namespace settings {
 		else if (type == "network")              return NETWORK;
 		else if (type == "flatbufServer")        return FLATBUFSERVER;
 		else if (type == "protoServer")          return PROTOSERVER;
+		else if (type == "osEvents")             return OSEVENTS;
+		else if (type == "cecEvents")            return CECEVENTS;
+		else if (type == "schedEvents")          return SCHEDEVENTS;
 		else                                     return INVALID;
 	}
 }