Refactor event handling incl.CEC

libsrc/events/CMakeLists.txt

@@ -0,0 +1,25 @@
+# Define the current source/header locations
+SET(CURRENT_HEADER_DIR ${CMAKE_SOURCE_DIR}/include/events)
+SET(CURRENT_SOURCE_DIR ${CMAKE_SOURCE_DIR}/libsrc/events)
+
+add_library(events
+	${CURRENT_HEADER_DIR}/Event.h
+	${CURRENT_HEADER_DIR}/EventHandler.h
+	${CURRENT_SOURCE_DIR}/EventHandler.cpp
+	${CURRENT_HEADER_DIR}/OsEventHandler.h
+	${CURRENT_SOURCE_DIR}/OsEventHandler.cpp
+)
+
+if (UNIX)
+	find_package(Qt${QT_VERSION_MAJOR} COMPONENTS DBus QUIET )
+	if (Qt${QT_VERSION_MAJOR}DBus_FOUND)
+		target_link_libraries(events Qt${QT_VERSION_MAJOR}::DBus)
+		if (NOT APPLE)
+			target_compile_definitions(events PUBLIC HYPERION_HAS_DBUS)
+		endif()
+	endif()
+endif(UNIX)
+
+target_include_directories(events PUBLIC
+	${CURRENT_HEADER_DIR}
+)

libsrc/events/EventHandler.cpp

@@ -0,0 +1,186 @@
+#include <events/EventHandler.h>
+
+#include <QJsonDocument>
+#include <QJsonObject>
+
+#include <events/Event.h>
+
+#include <utils/Logger.h>
+#include <utils/Process.h>
+#include <hyperion/HyperionIManager.h>
+
+EventHandler::EventHandler()
+	: _isSuspended(false)
+	, _isIdle(false)
+{
+	qRegisterMetaType<Event>("Event");
+	_log = Logger::getInstance("EVENTS");
+
+	QObject::connect(this, &EventHandler::signalEvent, HyperionIManager::getInstance(), &HyperionIManager::handleEvent);
+}
+
+EventHandler::~EventHandler()
+{
+	QObject::disconnect(this, &EventHandler::signalEvent, HyperionIManager::getInstance(), &HyperionIManager::handleEvent);
+}
+
+EventHandler* EventHandler::getInstance()
+{
+	static EventHandler instance;
+	return &instance;
+}
+
+void EventHandler::handleSettingsUpdate(settings::type type, const QJsonDocument& config)
+{
+    if(type == settings::OSEVENTS)
+	{
+		const QJsonObject& obj = config.object();
+	}
+}
+
+void EventHandler::suspend()
+{
+	suspend(true);
+}
+
+void EventHandler::suspend(bool sleep)
+{
+	if (sleep)
+	{
+		if (!_isSuspended)
+		{
+			_isSuspended = true;
+			Info(_log, "Suspend event received - Hyperion is going to sleep");
+			emit signalEvent(Event::Suspend);
+		}
+		else
+		{
+			Debug(_log, "Suspend event ignored - already suspended");
+		}
+	}
+	else
+	{
+		if (_isSuspended || _isIdle)
+		{
+			Info(_log, "Resume event received - Hyperion is going into working mode");
+			emit signalEvent(Event::Resume);
+			_isSuspended = false;
+			_isIdle = false;
+		}
+		else
+		{
+			Debug(_log, "Resume event ignored - not in suspend nor idle mode");
+		}
+	}
+}
+
+void EventHandler::resume()
+{
+	suspend(false);
+}
+
+void EventHandler::toggleSuspend()
+{
+	Debug(_log, "Toggle suspend event received");
+	if (!_isSuspended)
+	{
+		suspend(true);
+	}
+	else
+	{
+		suspend(false);
+	}
+}
+
+void EventHandler::idle()
+{
+	idle(true);
+}
+
+void EventHandler::idle(bool isIdle)
+{
+	if (!_isSuspended)
+	{
+		if (isIdle)
+		{
+			if (!_isIdle)
+			{
+				_isIdle = true;
+				Info(_log, "Idle event received");
+				emit signalEvent(Event::Idle);
+			}
+		}
+		else
+		{
+			if (_isIdle)
+			{
+				Info(_log, "Resume from idle event recevied");
+				emit signalEvent(Event::ResumeIdle);
+				_isIdle = false;
+			}
+		}
+	}
+	else
+	{
+		Debug(_log, "Idle event ignored - Hyperion is suspended");
+	}
+}
+void EventHandler::resumeIdle()
+{
+	idle(false);
+}
+
+void EventHandler::toggleIdle()
+{
+	Debug(_log, "Toggle idle event received");
+	if (!_isIdle)
+	{
+		idle(true);
+	}
+	else
+	{
+		idle(false);
+	}
+}
+
+void EventHandler::handleEvent(Event event)
+{
+	Debug(_log,"%s Event [%d] received", eventToString(event), event);
+	switch (event) {
+	case Event::Suspend:
+		suspend();
+		break;
+
+	case Event::Resume:
+		resume();
+		break;
+
+	case Event::ToggleSuspend:
+		suspend();
+		break;
+
+	case Event::Idle:
+		idle(true);
+		break;
+
+	case Event::ResumeIdle:
+		idle(false);
+		break;
+
+	case Event::ToggleIdle:
+		toggleIdle();
+		break;
+
+	case Event::Reload:
+		Process::restartHyperion(10);
+		break;
+
+	case Event::Restart:
+		Process::restartHyperion(11);
+		break;
+
+	default:
+		Error(_log,"Unkonwn Event '%d' received", event);
+		break;
+	}
+}

libsrc/events/OsEventHandler.cpp

@@ -0,0 +1,448 @@
+#include "OsEventHandler.h"
+
+#include <QtGlobal>
+#include <QJsonDocument>
+#include <QJsonObject>
+
+#include <events/EventHandler.h>
+#include <utils/Logger.h>
+
+#include <iostream>
+
+#if defined(_WIN32)
+#include <QCoreApplication>
+#include <QWidget>
+#include <windows.h>
+#include <wtsapi32.h>
+
+#pragma comment( lib, "wtsapi32.lib" )
+#endif
+
+OsEventHandlerBase::OsEventHandlerBase()
+	: _isSuspendEnabled(false)
+	, _isLockEnabled(false)
+	, _isSuspendOnLock(false)
+	, _isSuspendRegistered(false)
+	, _isLockRegistered(false)
+{
+	qRegisterMetaType<Event>("Event");
+	_log = Logger::getInstance("EVENTS");
+
+	QObject::connect(this, &OsEventHandlerBase::signalEvent, EventHandler::getInstance(), &EventHandler::handleEvent);
+}
+
+OsEventHandlerBase::~OsEventHandlerBase()
+{
+	QObject::disconnect(this, &OsEventHandlerBase::signalEvent, EventHandler::getInstance(), &EventHandler::handleEvent);
+
+	unregisterLockHandler();
+	unregisterOsEventHandler();
+}
+
+void OsEventHandlerBase::handleSettingsUpdate(settings::type type, const QJsonDocument& config)
+{
+	if(type == settings::OSEVENTS)
+	{
+		const QJsonObject& obj = config.object();
+
+		//Suspend on lock or go into idle mode
+		bool prevIsSuspendOnLock = _isSuspendOnLock;
+		_isSuspendOnLock = obj["suspendOnLockEnable"].toBool(false);
+
+		//Handle OS event related configurations
+		_isSuspendEnabled = obj["suspendEnable"].toBool(true);
+		if (_isSuspendEnabled)
+		{
+			// Listen to suspend/resume/idle events received by the OS
+			registerOsEventHandler();
+		}
+		else
+		{
+			unregisterOsEventHandler();
+		}
+
+		_isLockEnabled = obj["lockEnable"].toBool(true);
+		if (_isLockEnabled || _isSuspendOnLock != prevIsSuspendOnLock)
+		{
+			// Listen to lock/screensaver events received by the OS
+			registerLockHandler();
+		}
+		else
+		{
+			unregisterLockHandler();
+		}
+	}
+}
+
+void OsEventHandlerBase::suspend(bool sleep)
+{
+	if (sleep)
+	{
+		emit signalEvent(Event::Suspend);
+	}
+	else
+	{
+		emit signalEvent(Event::Resume);
+	}
+}
+
+void OsEventHandlerBase::lock(bool isLocked)
+{
+	if (isLocked)
+	{
+		if (_isSuspendOnLock)
+		{
+			emit signalEvent(Event::Suspend);
+		}
+		else
+		{
+			emit signalEvent(Event::Idle);
+		}
+	}
+	else
+	{
+		if (_isSuspendOnLock)
+		{
+			emit signalEvent(Event::Resume);
+		}
+		else
+		{
+			emit signalEvent(Event::ResumeIdle);
+		}
+	}
+}
+
+#if defined(_WIN32)
+
+OsEventHandlerWindows::OsEventHandlerWindows()
+	: _notifyHandle(NULL)
+{
+}
+
+OsEventHandlerWindows::~OsEventHandlerWindows()
+{
+	unregisterLockHandler();
+	unregisterOsEventHandler();
+}
+
+#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
+bool OsEventHandlerWindows::nativeEventFilter(const QByteArray& eventType, void* message, qintptr* /*result*/)
+#else
+bool OsEventHandlerWindows::nativeEventFilter(const QByteArray& eventType, void* message, long int* /*result*/)
+#endif
+{
+	MSG* msg = static_cast<MSG*>(message);
+
+	switch (msg->message)
+	{
+	case WM_WTSSESSION_CHANGE:
+		switch (msg->wParam)
+		{
+		case WTS_SESSION_LOCK:
+			emit lock(true);
+			return true;
+			break;
+		case WTS_SESSION_UNLOCK:
+			emit lock(false);
+			return true;
+			break;
+		}
+		break;
+
+	case WM_POWERBROADCAST:
+		switch (msg->wParam)
+		{
+		case PBT_APMRESUMESUSPEND:
+			emit suspend(false);
+			return true;
+			break;
+		case PBT_APMSUSPEND:
+			emit suspend(true);
+			return true;
+			break;
+		}
+		break;
+	}
+	return false;
+}
+
+bool OsEventHandlerWindows::registerOsEventHandler()
+{
+	bool isRegistered{ _isSuspendRegistered };
+	if (!_isSuspendRegistered)
+	{
+		auto handle = reinterpret_cast<HWND> (_widget.winId());
+		_notifyHandle = RegisterSuspendResumeNotification(handle, DEVICE_NOTIFY_WINDOW_HANDLE);
+		if (_notifyHandle != NULL)
+		{
+			QCoreApplication::instance()->installNativeEventFilter(this);
+		}
+		else
+		{
+			Error(_log, "Could not register for suspend/resume events!");
+		}
+
+		if (isRegistered)
+		{
+			_isSuspendRegistered = true;
+		}
+	}
+	return isRegistered;
+}
+
+void OsEventHandlerWindows::unregisterOsEventHandler()
+{
+	if (_isSuspendRegistered)
+	{
+		if (_notifyHandle != NULL)
+		{
+			QCoreApplication::instance()->removeNativeEventFilter(this);
+			UnregisterSuspendResumeNotification(_notifyHandle);
+		}
+		_notifyHandle = NULL;
+		_isSuspendRegistered = false;
+	}
+}
+
+bool OsEventHandlerWindows::registerLockHandler()
+{
+	bool isRegistered{ _isLockRegistered };
+	if (!_isLockRegistered)
+	{
+		auto handle = reinterpret_cast<HWND> (_widget.winId());
+		if (WTSRegisterSessionNotification(handle, NOTIFY_FOR_THIS_SESSION))
+		{
+			isRegistered = true;
+		}
+		else
+		{
+			Error(_log, "Could not register for lock/unlock events!");
+		}
+
+
+	}
+
+	if (isRegistered)
+	{
+		_isLockRegistered = true;
+	}
+	return isRegistered;
+}
+
+void OsEventHandlerWindows::unregisterLockHandler()
+{
+	if (_isLockRegistered)
+	{
+		auto handle = reinterpret_cast<HWND> (_widget.winId());
+		WTSUnRegisterSessionNotification(handle);
+		_isLockRegistered = false;
+	}
+}
+
+#elif defined(__linux__)
+
+#include <csignal>
+
+OsEventHandlerLinux* OsEventHandlerLinux::getInstance()
+{
+	static OsEventHandlerLinux instance;
+	return &instance;
+}
+
+OsEventHandlerLinux::OsEventHandlerLinux()
+{
+	signal(SIGUSR1, static_signaleHandler);
+	signal(SIGUSR2, static_signaleHandler);
+}
+
+void OsEventHandlerLinux::handleSignal (int signum)
+{
+	if (signum == SIGUSR1)
+	{
+		suspend(true);
+	}
+	else if (signum == SIGUSR2)
+	{
+		suspend(false);
+	}
+}
+
+#if defined(HYPERION_HAS_DBUS)
+#include <QDBusConnection>
+
+struct dBusSignals
+{
+	QString service;
+	QString path;
+	QString interface;
+	QString name;
+};
+
+typedef QMultiMap<QString, dBusSignals> DbusSignalsMap;
+
+// Constants
+namespace {
+const DbusSignalsMap dbusSignals = {
+	//system signals
+	{"Suspend", {"org.freedesktop.login1","/org/freedesktop/login1","org.freedesktop.login1.Manager","PrepareForSleep"}},
+
+	//Session signals
+	{"ScreenSaver", {"org.freedesktop.ScreenSaver","/org/freedesktop/ScreenSaver","org.freedesktop.ScreenSaver","ActiveChanged"}},
+	{"ScreenSaver", {"org.gnome.ScreenSaver","/org/gnome/ScreenSaver","org.gnome.ScreenSaver","ActiveChanged"}},
+};
+} //End of constants
+
+bool OsEventHandlerLinux::registerOsEventHandler()
+{
+
+	bool isRegistered {_isSuspendRegistered};
+	if (!_isSuspendRegistered)
+	{
+		QDBusConnection systemBus = QDBusConnection::systemBus();
+		if (!systemBus.isConnected())
+		{
+			Info(_log, "The suspend/resume feature is not supported by your system configuration");
+		}
+		else
+		{
+			QString service = dbusSignals.find("Suspend").value().service;
+			if (systemBus.connect(service,
+								  dbusSignals.find("Suspend").value().path,
+								  dbusSignals.find("Suspend").value().interface,
+								  dbusSignals.find("Suspend").value().name,
+								  this, SLOT(suspend(bool))))
+			{
+				Debug(_log, "Registered for suspend/resume events via service: %s", QSTRING_CSTR(service));
+				isRegistered = true;
+			}
+			else
+			{
+				Error(_log, "Could not register for suspend/resume events via service: %s", QSTRING_CSTR(service));
+			}
+		}
+
+		if (isRegistered)
+		{
+			_isSuspendRegistered = true;
+		}
+
+	}
+	return isRegistered;
+}
+
+void OsEventHandlerLinux::unregisterOsEventHandler()
+{
+	if (_isSuspendRegistered)
+	{
+		QDBusConnection systemBus = QDBusConnection::systemBus();
+		if (!systemBus.isConnected())
+		{
+			Info(_log, "The suspend/resume feature is not supported by your system configuration");
+		}
+		else
+		{
+			QString service = dbusSignals.find("Suspend").value().service;
+			if (systemBus.disconnect(service,
+								  dbusSignals.find("Suspend").value().path,
+								  dbusSignals.find("Suspend").value().interface,
+								  dbusSignals.find("Suspend").value().name,
+								  this, SLOT(suspend(bool))))
+			{
+				Debug(_log, "Unregistered for suspend/resume events via service: %s", QSTRING_CSTR(service));
+				_isSuspendRegistered = false;
+			}
+			else
+			{
+				Error(_log, "Could not unregister for suspend/resume events via service: %s", QSTRING_CSTR(service));
+			}
+		}
+	}
+}
+
+bool OsEventHandlerLinux::registerLockHandler()
+{
+	bool isRegistered {_isLockRegistered};
+
+	if (!_isLockRegistered)
+	{
+		QDBusConnection sessionBus = QDBusConnection::sessionBus();
+		if (!sessionBus.isConnected())
+		{
+			Info(_log, "The lock/unlock feature is not supported by your system configuration");
+		}
+		else
+		{
+			DbusSignalsMap::const_iterator iter = dbusSignals.find("ScreenSaver");
+			while (iter != dbusSignals.end() && iter.key() == "ScreenSaver") {
+				QString service = iter.value().service;
+				if (sessionBus.connect(service,
+									   iter.value().path,
+									   iter.value().interface,
+									   iter.value().name,
+									   this, SLOT(lock(bool))))
+				{
+					Debug(_log, "Registered for lock/unlock events via service: %s", QSTRING_CSTR(service));
+					isRegistered = true;
+				}
+				else
+				{
+					Error(_log, "Could not register for lock/unlock events via service: %s", QSTRING_CSTR(service));
+
+				}
+				++iter;
+			}
+
+		}
+	}
+
+	if (isRegistered)
+	{
+		_isLockRegistered = true;
+	}
+
+	return isRegistered;
+}
+
+void OsEventHandlerLinux::unregisterLockHandler()
+{
+	bool isUnregistered {false};
+
+	if (_isLockRegistered)
+	{
+		QDBusConnection sessionBus = QDBusConnection::sessionBus();
+		if (!sessionBus.isConnected())
+		{
+			Info(_log, "The lock/unlock feature is not supported by your system configuration");
+		}
+		else
+		{
+			DbusSignalsMap::const_iterator iter = dbusSignals.find("ScreenSaver");
+			while (iter != dbusSignals.end() && iter.key() == "ScreenSaver") {
+				QString service = iter.value().service;
+				if (sessionBus.disconnect(service,
+									   iter.value().path,
+									   iter.value().interface,
+									   iter.value().name,
+									   this, SLOT(lock(bool))))
+				{
+					Debug(_log, "Unregistered for lock/unlock events via service: %s", QSTRING_CSTR(service));
+					isUnregistered = true;
+				}
+				else
+				{
+					Error(_log, "Could not unregister for lock/unlock events via service: %s", QSTRING_CSTR(service));
+
+				}
+				++iter;
+			}
+
+			if (isUnregistered)
+			{
+				_isLockRegistered = false;
+			}
+		}
+	}
+}
+#endif // HYPERION_HAS_DBUS
+
+#endif // __linux__