Allow to enable/disable suspend & lock event handling

2025-03-01 10:33:28 +00:00 · 2023-11-02 20:23:04 +01:00
parent f57c4f84ac
commit 7d3f13c7b5
15 changed files with 604 additions and 115 deletions
--- a/src/hyperiond/SuspendHandler.cpp
+++ b/src/hyperiond/SuspendHandler.cpp
@@ -1,36 +1,195 @@
 #include "SuspendHandler.h"

 #include <QtGlobal>
+#include <QJsonDocument>
+#include <QJsonObject>

 #include <hyperion/HyperionIManager.h>
 #include <iostream>

 SuspendHandlerBase::SuspendHandlerBase()
-	: _isSuspended(false)
+	: _isSuspendEnabled(false)
+	, _isLockEnabled(false)
+	, _isSuspendOnLock(false)
+	, _isSuspendRegistered(false)
+	, _isLockRegistered(false)
+	, _isSuspended(false)
 	, _isIdle(false)
 	, _isLocked (false)
+
 {
-	// Trigger suspend/resume/idle scenarios to be executed by Instance mMnager
-	connect(this, &SuspendHandlerBase::suspendEvent, HyperionIManager::getInstance(), &HyperionIManager::suspend);
-	connect(this, &SuspendHandlerBase::resumeEvent, HyperionIManager::getInstance(), &HyperionIManager::resume);
-	connect(this, &SuspendHandlerBase::lockedEvent, HyperionIManager::getInstance(), &HyperionIManager::toggleIdle);
-	connect(this, &SuspendHandlerBase::idleEvent, HyperionIManager::getInstance(), &HyperionIManager::toggleIdle);
-
-
-	// Listen to suspend/resume/idle events received by the Instance Manager via API
-	connect(HyperionIManager::getInstance(), &HyperionIManager::triggerSuspend, this, QOverload<bool>::of(&SuspendHandler::suspend));
-	connect(HyperionIManager::getInstance(), &HyperionIManager::triggerToggleSuspend, this, &SuspendHandler::toggleSuspend);
-	connect(HyperionIManager::getInstance(), &HyperionIManager::triggerIdle, this, &SuspendHandler::idle);
-	connect(HyperionIManager::getInstance(), &HyperionIManager::triggerToggleIdle, this, &SuspendHandler::toggleIdle);
+	_log = Logger::getInstance("EVENTS");
 }

 SuspendHandlerBase::~SuspendHandlerBase()
 {
+	unregisterLockHandler();
+	unregisterSuspendHandler();
+
+	unregisterIdleApiHandler();
+	unregisterSuspendApiHandler();
+}
+
+void SuspendHandlerBase::handleSettingsUpdate(settings::type type, const QJsonDocument& config)
+{
+	if(type == settings::SYSTEMEVENTS)
+	{
+		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
+			registerSuspendHandler();
+		}
+		else
+		{
+			unregisterSuspendHandler();
+		}
+
+		_isLockEnabled = obj["lockEnable"].toBool(true);
+		if (_isLockEnabled || _isSuspendOnLock != prevIsSuspendOnLock)
+		{
+			// Listen to lock/screensaver events received by the OS
+			registerLockHandler();
+		}
+		else
+		{
+			unregisterLockHandler();
+		}
+
+		//Handle API event related configurations
+		_isSuspendApiEnabled = obj["suspendApiEnable"].toBool(true);
+		if (_isSuspendApiEnabled)
+		{
+			// Listen to suspend/resume/idle events received by the OS
+			registerSuspendApiHandler();
+		}
+		else
+		{
+			unregisterSuspendApiHandler();
+		}
+
+		_isIdleApiEnabled = obj["idleApiEnable"].toBool(true);
+		if (_isIdleApiEnabled)
+		{
+			// Listen to lock/screensaver events received by the OS
+			registerIdleApiHandler();
+		}
+		else
+		{
+			unregisterIdleApiHandler();
+		}
+	}
+}
+
+bool SuspendHandlerBase::registerSuspendHandler()
+{
+	Debug(_log, "_isSuspendRegistered: %d", _isSuspendRegistered);
+	if (!_isSuspendRegistered)
+	{
+		connect(this, &SuspendHandlerBase::suspendEvent, HyperionIManager::getInstance(), &HyperionIManager::suspend);
+		connect(this, &SuspendHandlerBase::resumeEvent, HyperionIManager::getInstance(), &HyperionIManager::resume);
+		Info(_log, "Registered for suspend/resume events.");
+		_isSuspendRegistered = true;
+	}
+	return true;
+}
+
+void SuspendHandlerBase::unregisterSuspendHandler()
+{
+	if (_isSuspendRegistered)
+	{
+		disconnect(this, &SuspendHandlerBase::suspendEvent, HyperionIManager::getInstance(), &HyperionIManager::suspend);
+		disconnect(this, &SuspendHandlerBase::resumeEvent, HyperionIManager::getInstance(), &HyperionIManager::resume);
+		Info(_log, "Unregistered for suspend/resume events.");
+		_isSuspendRegistered = false;
+	}
+}
+
+bool SuspendHandlerBase::registerLockHandler()
+{
+	disconnect(this, &SuspendHandlerBase::lockedEvent,nullptr, nullptr);
+	if (_isSuspendOnLock)
+	{
+		connect(this, &SuspendHandlerBase::lockedEvent, HyperionIManager::getInstance(), &HyperionIManager::toggleSuspend);
+	}
+	else
+	{
+		connect(this, &SuspendHandlerBase::lockedEvent, HyperionIManager::getInstance(), &HyperionIManager::toggleIdle);
+	}
+	connect(this, &SuspendHandlerBase::idleEvent, HyperionIManager::getInstance(), &HyperionIManager::toggleIdle);
+	Info(_log, "Registered for lock/unlock events. %s on lock event.", _isSuspendOnLock ? "Suspend" : "Idle");
+	_isLockRegistered = true;
+	return true;
+}
+
+void SuspendHandlerBase::unregisterLockHandler()
+{
+	if (_isLockRegistered)
+	{
+		disconnect(this, &SuspendHandlerBase::lockedEvent, HyperionIManager::getInstance(), &HyperionIManager::toggleSuspend);
+		disconnect(this, &SuspendHandlerBase::lockedEvent, HyperionIManager::getInstance(), &HyperionIManager::toggleIdle);
+		disconnect(this, &SuspendHandlerBase::idleEvent, HyperionIManager::getInstance(), &HyperionIManager::toggleIdle);
+		Info(_log, "Unregistered for lock/unlock events.");
+		_isLockRegistered = false;
+	}
+}
+
+
+bool SuspendHandlerBase::registerSuspendApiHandler()
+{
+	if (!_isSuspendApiRegistered)
+	{
+		connect(HyperionIManager::getInstance(), &HyperionIManager::triggerSuspend, this, QOverload<bool>::of(&SuspendHandler::suspend));
+		connect(HyperionIManager::getInstance(), &HyperionIManager::triggerToggleSuspend, this, &SuspendHandler::toggleSuspend);
+		Info(_log, "Registered for suspend/resume API events.");
+		_isSuspendApiRegistered = true;
+	}
+	return true;
+}
+
+void SuspendHandlerBase::unregisterSuspendApiHandler()
+{
+	if (_isSuspendApiRegistered)
+	{
+		disconnect(HyperionIManager::getInstance(), &HyperionIManager::triggerSuspend, this, QOverload<bool>::of(&SuspendHandler::suspend));
+		disconnect(HyperionIManager::getInstance(), &HyperionIManager::triggerToggleSuspend, this, &SuspendHandler::toggleSuspend);
+		Info(_log, "Unregistered for suspend/resume API events.");
+		_isSuspendApiRegistered = false;
+	}
+}
+
+bool SuspendHandlerBase::registerIdleApiHandler()
+{
+	if (!_isIdleApiRegistered)
+	{
+		connect(HyperionIManager::getInstance(), &HyperionIManager::triggerIdle, this, &SuspendHandler::idle);
+		connect(HyperionIManager::getInstance(), &HyperionIManager::triggerToggleIdle, this, &SuspendHandler::toggleIdle);
+		Info(_log, "Registered for idle API events.");
+		_isIdleApiRegistered = true;
+	}
+	return true;
+}
+
+void SuspendHandlerBase::unregisterIdleApiHandler()
+{
+	if (_isIdleApiRegistered)
+	{
+		disconnect(HyperionIManager::getInstance(), &HyperionIManager::triggerIdle, this, &SuspendHandler::idle);
+		disconnect(HyperionIManager::getInstance(), &HyperionIManager::triggerToggleIdle, this, &SuspendHandler::toggleIdle);
+		Info(_log, "Unregistered for idle API events.");
+		_isIdleApiRegistered = false;
+	}
 }

 void SuspendHandlerBase::suspend()
 {
-	Debug(Logger::getInstance("DAEMON"), "");
 	suspend(true);
 }

@@ -41,39 +200,38 @@ void SuspendHandlerBase::suspend(bool sleep)
 		if (!_isSuspended)
 		{
 			_isSuspended = true;
-			Info(Logger::getInstance("DAEMON"), "Suspend event received - Hyperion is going to sleep");
+			Info(_log, "Suspend event received - Hyperion is going to sleep");
 			emit suspendEvent();
 		}
 		else
 		{
-			Debug(Logger::getInstance("DAEMON"), "Suspend event ignored - already suspended");
+			Debug(_log, "Suspend event ignored - already suspended");
 		}
 	}
 	else
 	{
 		if (_isSuspended || _isIdle)
 		{
-			Info(Logger::getInstance("DAEMON"), "Resume event received - Hyperion is going into working mode");
+			Info(_log, "Resume event received - Hyperion is going into working mode");
 			emit resumeEvent();
 			_isSuspended = false;
 			_isIdle = false;
 		}
 		else
 		{
-			Debug(Logger::getInstance("DAEMON"), "Resume event ignored - not in suspend nor idle mode");
+			Debug(_log, "Resume event ignored - not in suspend nor idle mode");
 		}
 	}
 }

 void SuspendHandlerBase::resume()
 {
-	Debug(Logger::getInstance("DAEMON"), "");
 	suspend(false);
 }

 void SuspendHandlerBase::toggleSuspend()
 {
-	Debug(Logger::getInstance("DAEMON"), "Toggle suspend event received");
+	Debug(_log, "Toggle suspend event received");
 	if (!_isSuspended)
 	{
 		suspend(true);
@@ -93,7 +251,7 @@ void SuspendHandlerBase::idle(bool isIdle)
 			if (!_isIdle)
 			{
 				_isIdle = true;
-				Info(Logger::getInstance("DAEMON"), "Idle event received");
+				Info(_log, "Idle event received");
 				emit idleEvent(isIdle);
 			}
 		}
@@ -101,7 +259,7 @@ void SuspendHandlerBase::idle(bool isIdle)
 		{
 			if (_isIdle)
 			{
-				Info(Logger::getInstance("DAEMON"), "Resume from idle event recevied");
+				Info(_log, "Resume from idle event recevied");
 				emit idleEvent(isIdle);
 				_isIdle = false;
 			}
@@ -109,13 +267,13 @@ void SuspendHandlerBase::idle(bool isIdle)
 	}
 	else
 	{
-		Debug(Logger::getInstance("DAEMON"), "Idle event ignored - Hyperion is suspended");
+		Debug(_log, "Idle event ignored - Hyperion is suspended");
 	}
 }

 void SuspendHandlerBase::toggleIdle()
 {
-	Debug(Logger::getInstance("DAEMON"), "Toggle idle event received");
+	Debug(_log, "Toggle idle event received");
 	if (!_isIdle)
 	{
 		idle(true);
@@ -135,7 +293,7 @@ void SuspendHandlerBase::lock(bool isLocked)
 			if (!_isLocked)
 			{
 				_isLocked = true;
-				Info(Logger::getInstance("DAEMON"), "Screen lock event received");
+				Info(_log, "Screen lock event received");
 				emit lockedEvent(isLocked);
 			}
 		}
@@ -143,7 +301,7 @@ void SuspendHandlerBase::lock(bool isLocked)
 		{
 			if (_isLocked)
 			{
-				Info(Logger::getInstance("DAEMON"), "Screen unlock event received");
+				Info(_log, "Screen unlock event received");
 				emit lockedEvent(isLocked);
 				_isLocked = false;
 			}
@@ -151,7 +309,7 @@ void SuspendHandlerBase::lock(bool isLocked)
 	}
 	else
 	{
-		Debug(Logger::getInstance("DAEMON"), "Screen lock event ignored - Hyperion is suspended");
+		Debug(_log, "Screen lock event ignored - Hyperion is suspended");
 	}
 }

@@ -165,36 +323,12 @@ void SuspendHandlerBase::lock(bool isLocked)

 SuspendHandlerWindows::SuspendHandlerWindows()
 {
-	auto handle = reinterpret_cast<HWND> (_widget.winId());
-
-	_notifyHandle = RegisterSuspendResumeNotification(handle, DEVICE_NOTIFY_WINDOW_HANDLE);
-	if (_notifyHandle != NULL)
-	{
-		QCoreApplication::instance()->installNativeEventFilter(this);
-	}
-	else
-	{
-		Error(Logger::getInstance("DAEMON"), "Could not register for suspend/resume events!");
-	}
-
-	if (!WTSRegisterSessionNotification(handle, NOTIFY_FOR_THIS_SESSION))
-	{
-		Error(Logger::getInstance("DAEMON"), "Could not register for lock/unlock events!");
-	}
 }

 SuspendHandlerWindows::~SuspendHandlerWindows()
 {
-	if (_notifyHandle != NULL)
-	{
-		QCoreApplication::instance()->removeNativeEventFilter(this);
-
-		UnregisterSuspendResumeNotification(_notifyHandle);
-
-		auto handle = reinterpret_cast<HWND> (_widget.winId());
-		WTSUnRegisterSessionNotification(handle);
-	}
-	_notifyHandle = NULL;
+	unregisterLockHandler();
+	unregisterSuspendHandler();
 }

 #if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
@@ -238,6 +372,68 @@ bool SuspendHandlerWindows::nativeEventFilter(const QByteArray& eventType, void*
 	return false;
 }

+bool SuspendHandlerWindows::registerSuspendHandler()
+{
+	bool isRegistered {false};
+	if (!_isSuspendRegistered)
+	{
+		auto handle = reinterpret_cast<HWND> (_widget.winId());
+		_notifyHandle = RegisterSuspendResumeNotification(handle, DEVICE_NOTIFY_WINDOW_HANDLE);
+		if (_notifyHandle != NULL)
+		{
+			QCoreApplication::instance()->installNativeEventFilter(this);
+			isRegistered = SuspendHandlerBase::registerSuspendHandler();
+		}
+		else
+		{
+			Error(_log, "Could not register for suspend/resume events!");
+		}
+	}
+	return isRegistered;
+}
+
+void SuspendHandlerWindows::unregisterSuspendHandler()
+{
+	if (_isSuspendRegistered)
+	{
+		if (_notifyHandle != NULL)
+		{
+			QCoreApplication::instance()->removeNativeEventFilter(this);
+			UnregisterSuspendResumeNotification(_notifyHandle);
+		}
+		_notifyHandle = NULL;
+		SuspendHandlerBase::unregisterSuspendHandler();
+	}
+}
+
+bool SuspendHandlerWindows::registerLockHandler()
+{
+	bool isRegistered {false};
+	if (!_isLockRegistered)
+	{
+		auto handle = reinterpret_cast<HWND> (_widget.winId());
+		if (WTSRegisterSessionNotification(handle, NOTIFY_FOR_THIS_SESSION))
+		{
+			isRegistered = SuspendHandlerBase::registerLockHandler();
+		}
+		else
+		{
+			Error(_log, "Could not register for lock/unlock events!");
+		}
+	}
+	return isRegistered;
+}
+
+void SuspendHandlerWindows::unregisterLockHandler()
+{
+	if (_isLockRegistered)
+	{
+		auto handle = reinterpret_cast<HWND> (_widget.winId());
+		WTSUnRegisterSessionNotification(handle);
+		SuspendHandlerBase::unregisterLockHandler();
+	}
+}
+
 #elif defined(__linux__) && defined(HYPERION_HAS_DBUS)
 #include <QDBusConnection>

@@ -265,48 +461,158 @@ const DbusSignalsMap dbusSignals = {

 SuspendHandlerLinux::SuspendHandlerLinux()
 {
-	QDBusConnection systemBus = QDBusConnection::systemBus();
-	if (!systemBus.isConnected())
+}
+
+bool SuspendHandlerLinux::registerSuspendHandler()
+{
+	bool isRegistered {_isSuspendRegistered};
+	if (!_isSuspendRegistered)
 	{
-		Info(Logger::getInstance("DAEMON"), "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))))
-			Error(Logger::getInstance("DAEMON"), "Could not register for suspend/resume events [%s]!", QSTRING_CSTR(service));
+		QDBusConnection systemBus = QDBusConnection::systemBus();
+		if (!systemBus.isConnected())
+		{
+			Info(_log, "The suspend/resume feature is not supported by your system configuration");
+		}
 		else
 		{
-			Debug(Logger::getInstance("DAEMON"), "Registered for suspend/resume events [%s].", QSTRING_CSTR(service));
-		}
-	}
-
-	QDBusConnection sessionBus = QDBusConnection::sessionBus();
-	if (!sessionBus.isConnected())
-	{
-		Info(Logger::getInstance("DAEMON"), "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))))
-				Error(Logger::getInstance("DAEMON"), "Could not register for lock/unlock events [%s]!", QSTRING_CSTR(service));
+			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
 			{
-				Debug(Logger::getInstance("DAEMON"), "Registered for lock/unlock events [%s].", QSTRING_CSTR(service));
+				Error(_log, "Could not register for suspend/resume events via service: %s", QSTRING_CSTR(service));
+			}
+		}
+
+		if (isRegistered)
+		{
+			isRegistered = SuspendHandlerBase::registerSuspendHandler();
+		}
+
+	}
+	return isRegistered;
+}
+
+void SuspendHandlerLinux::unregisterSuspendHandler()
+{
+	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));
+				SuspendHandlerBase::unregisterSuspendHandler();
+			}
+			else
+			{
+				Error(_log, "Could not unregister for suspend/resume events via service: %s", QSTRING_CSTR(service));
 			}
-			++iter;
 		}
 	}
 }
+
+bool SuspendHandlerLinux::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)
+	{
+		isRegistered = SuspendHandlerBase::registerLockHandler();
+	}
+
+	return isRegistered;
+}
+
+void SuspendHandlerLinux::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)
+			{
+				SuspendHandlerBase::unregisterLockHandler();
+			}
+		}
+	}
+}
+
+
 #endif
--- a/src/hyperiond/SuspendHandler.h
+++ b/src/hyperiond/SuspendHandler.h
@@ -1,6 +1,11 @@
 #ifndef SUSPENDHANDLER_H
 #define SUSPENDHANDLER_H
 #include <QObject>
+#include <QJsonDocument>
+
+#include <utils/settings.h>
+
+class Logger;

 class SuspendHandlerBase : public QObject {
 	Q_OBJECT
@@ -22,6 +27,8 @@ public slots:

 	void lock(bool isLocked);

+	virtual void handleSettingsUpdate(settings::type type, const QJsonDocument& config);
+
 signals:

 	void suspendEvent();
@@ -29,6 +36,31 @@ signals:
 	void lockedEvent(bool);
 	void idleEvent(bool);

+protected:
+
+	virtual bool registerSuspendHandler();
+	virtual void unregisterSuspendHandler();
+	virtual bool registerLockHandler();
+	virtual void unregisterLockHandler();
+
+	virtual bool registerSuspendApiHandler();
+	virtual void unregisterSuspendApiHandler();
+	virtual bool registerIdleApiHandler();
+	virtual void unregisterIdleApiHandler();
+
+	bool _isSuspendEnabled;
+	bool _isLockEnabled;
+	bool _isSuspendApiEnabled;
+	bool _isIdleApiEnabled;
+	bool _isSuspendOnLock;
+
+	bool _isSuspendRegistered;
+	bool _isLockRegistered;
+	bool _isSuspendApiRegistered;
+	bool _isIdleApiRegistered;
+
+	Logger * _log {};
+
 private:

 	bool _isSuspended;
@@ -56,6 +88,12 @@ protected:
 #endif

 private:
+
+	bool registerSuspendHandler() override;
+	bool unregisterSuspendHandler() override;
+	void registerLockHandler() override;
+	void unregisterLockHandler() override;
+
 	QWidget			_widget;
 	HPOWERNOTIFY	_notifyHandle;
 };
@@ -65,9 +103,16 @@ using SuspendHandler = SuspendHandlerWindows;
 #elif defined(__linux__) && defined(HYPERION_HAS_DBUS)

 class SuspendHandlerLinux : public SuspendHandlerBase {
+	Q_OBJECT

 public:
 	SuspendHandlerLinux();
+
+private:
+	bool registerSuspendHandler() override;
+	void unregisterSuspendHandler() override;
+	bool registerLockHandler() override;
+	void unregisterLockHandler() override;
 };

 using SuspendHandler = SuspendHandlerLinux;
--- a/src/hyperiond/hyperiond.cpp
+++ b/src/hyperiond/hyperiond.cpp
@@ -92,8 +92,8 @@ HyperionDaemon::HyperionDaemon(const QString& rootPath, QObject* parent, bool lo
 	, _osxGrabber(nullptr)
 	, _qtGrabber(nullptr)
 	, _dxGrabber(nullptr)
-	, _ssdp(nullptr)
 	, _audioGrabber(nullptr)
+	, _ssdp(nullptr)
 #ifdef ENABLE_CEC
 	, _cecHandler(nullptr)
 #endif
@@ -177,7 +177,8 @@ HyperionDaemon::HyperionDaemon(const QString& rootPath, QObject* parent, bool lo
 	// ---- network services -----
 	startNetworkServices();

-	_suspendHandler = new SuspendHandler();
+	// init events services
+	handleSettingsUpdate(settings::SYSTEMEVENTS, getSetting(settings::SYSTEMEVENTS));
 }

 HyperionDaemon::~HyperionDaemon()
@@ -742,6 +743,19 @@ void HyperionDaemon::handleSettingsUpdate(settings::type settingsType, const QJs
 		Debug(_log, "Audio capture not supported on this platform");
 #endif
 	}
+	else if (settingsType == settings::SYSTEMEVENTS)
+	{
+		// Create suspend handler
+		if (_suspendHandler == nullptr)
+		{
+			_suspendHandler = new SuspendHandler();
+			_suspendHandler->handleSettingsUpdate(settings::SYSTEMEVENTS, getSetting(settings::SYSTEMEVENTS));
+
+			connect(this, &HyperionDaemon::settingsChanged, _suspendHandler, &SuspendHandler::handleSettingsUpdate);
+
+			Debug(_log, "SuspendHandler created");
+		}
+	}
 }

 void HyperionDaemon::createGrabberDispmanx(const QJsonObject& /*grabberConfig*/)