mirror of
https://github.com/hyperion-project/hyperion.ng.git
synced 2025-03-01 10:33:28 +00:00
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>
This commit is contained in:
LordGrey
GitHub
27
libsrc/events/CMakeLists.txt
Normal file
27
libsrc/events/CMakeLists.txt
Normal file
@@ -0,0 +1,27 @@
|
||||
add_library(events
|
||||
${CMAKE_SOURCE_DIR}/include/events/EventEnum.h
|
||||
${CMAKE_SOURCE_DIR}/include/events/EventHandler.h
|
||||
${CMAKE_SOURCE_DIR}/include/events/OsEventHandler.h
|
||||
${CMAKE_SOURCE_DIR}/include/events/EventScheduler.h
|
||||
${CMAKE_SOURCE_DIR}/libsrc/events/EventHandler.cpp
|
||||
${CMAKE_SOURCE_DIR}/libsrc/events/OsEventHandler.cpp
|
||||
${CMAKE_SOURCE_DIR}/libsrc/events/EventScheduler.cpp
|
||||
)
|
||||
|
||||
if(UNIX AND NOT APPLE)
|
||||
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)
|
||||
target_compile_definitions(events PRIVATE HYPERION_HAS_DBUS)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
target_link_libraries(events
|
||||
hyperion-utils
|
||||
Qt${QT_VERSION_MAJOR}::Widgets
|
||||
)
|
||||
|
||||
if(APPLE)
|
||||
set_source_files_properties(OsEventHandler.cpp PROPERTIES COMPILE_FLAGS "-x objective-c++")
|
||||
target_link_libraries(events "-framework AppKit")
|
||||
endif()
|
||||
186
libsrc/events/EventHandler.cpp
Normal file
186
libsrc/events/EventHandler.cpp
Normal file
@@ -0,0 +1,186 @@
|
||||
#include <events/EventHandler.h>
|
||||
|
||||
#include <QJsonDocument>
|
||||
#include <QJsonObject>
|
||||
|
||||
#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::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)
|
||||
{
|
||||
QObject *senderObj = QObject::sender();
|
||||
QString senderObjectClass;
|
||||
if (senderObj)
|
||||
{
|
||||
senderObjectClass = senderObj->metaObject()->className();
|
||||
} else
|
||||
{
|
||||
senderObjectClass = "unknown sender";
|
||||
}
|
||||
Debug(_log,"%s Event [%d] received from %s", eventToString(event), event, QSTRING_CSTR(senderObjectClass));
|
||||
|
||||
switch (event) {
|
||||
case Event::Suspend:
|
||||
suspend();
|
||||
break;
|
||||
|
||||
case Event::Resume:
|
||||
resume();
|
||||
break;
|
||||
|
||||
case Event::ToggleSuspend:
|
||||
toggleSuspend();
|
||||
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;
|
||||
}
|
||||
}
|
||||
153
libsrc/events/EventScheduler.cpp
Normal file
153
libsrc/events/EventScheduler.cpp
Normal file
@@ -0,0 +1,153 @@
|
||||
#include "events/EventScheduler.h"
|
||||
|
||||
#include <QtGlobal>
|
||||
#include <QJsonDocument>
|
||||
#include <QJsonObject>
|
||||
#include <QJsonArray>
|
||||
#include <QDateTime>
|
||||
|
||||
#include <events/EventHandler.h>
|
||||
#include <utils/Logger.h>
|
||||
|
||||
EventScheduler::EventScheduler()
|
||||
: _isEnabled(false)
|
||||
{
|
||||
qRegisterMetaType<Event>("Event");
|
||||
_log = Logger::getInstance("EVENTS-SCHED");
|
||||
|
||||
QObject::connect(this, &EventScheduler::signalEvent, EventHandler::getInstance(), &EventHandler::handleEvent);
|
||||
}
|
||||
|
||||
EventScheduler::~EventScheduler()
|
||||
{
|
||||
QObject::disconnect(this, &EventScheduler::signalEvent, EventHandler::getInstance(), &EventHandler::handleEvent);
|
||||
clearTimers();
|
||||
Info(_log, "Event scheduler stopped");
|
||||
}
|
||||
|
||||
void EventScheduler::handleSettingsUpdate(settings::type type, const QJsonDocument& config)
|
||||
{
|
||||
if(type == settings::SCHEDEVENTS)
|
||||
{
|
||||
const QJsonObject& obj = config.object();
|
||||
|
||||
_isEnabled = obj["enable"].toBool(false);
|
||||
Debug(_log, "Event scheduler is %s", _isEnabled? "enabled" : "disabled");
|
||||
|
||||
if (_isEnabled)
|
||||
{
|
||||
_scheduledEvents.clear();
|
||||
|
||||
const QJsonArray actionItems = obj["actions"].toArray();
|
||||
if (!actionItems.isEmpty())
|
||||
{
|
||||
timeEvent timeEvent;
|
||||
for (const QJsonValue &item : actionItems)
|
||||
{
|
||||
QString action = item.toObject().value("action").toString();
|
||||
timeEvent.action = stringToEvent(action);
|
||||
|
||||
QString event = item.toObject().value("event").toString();
|
||||
timeEvent.time = QTime::fromString(event,"hh:mm");
|
||||
if (timeEvent.time.isValid())
|
||||
{
|
||||
_scheduledEvents.append(timeEvent);
|
||||
Debug(_log, "Time-Event : \"%s\" linked to action \"%s\"", QSTRING_CSTR(event), QSTRING_CSTR(action));
|
||||
}
|
||||
else
|
||||
{
|
||||
Error(_log, "Error in configured time : \"%s\" linked to action \"%s\"", QSTRING_CSTR(event), QSTRING_CSTR(action));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!_scheduledEvents.isEmpty())
|
||||
{
|
||||
enable();
|
||||
}
|
||||
else
|
||||
{
|
||||
Warning(_log, "No scheduled events to listen to are configured currently.");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
disable();
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
bool EventScheduler::enable()
|
||||
{
|
||||
bool enabled {false};
|
||||
|
||||
clearTimers();
|
||||
for (int i = 0; i < _scheduledEvents.size(); ++i)
|
||||
{
|
||||
QTimer* timer = new QTimer(this);
|
||||
timer->setTimerType(Qt::PreciseTimer);
|
||||
_timers.append(timer);
|
||||
|
||||
// Calculate the milliseconds until the next occurrence of the scheduled time
|
||||
int milliseconds = getMillisecondsToNextScheduledTime(_scheduledEvents.at(i).time);
|
||||
timer->start(milliseconds);
|
||||
|
||||
QObject::connect(timer, &QTimer::timeout, this, [this, i]() { handleEvent(i); });
|
||||
}
|
||||
|
||||
enabled = true;
|
||||
Info(_log, "Event scheduler started");
|
||||
|
||||
return enabled;
|
||||
}
|
||||
|
||||
void EventScheduler::disable()
|
||||
{
|
||||
Info(_log, "Disabling event scheduler");
|
||||
clearTimers();
|
||||
}
|
||||
|
||||
void EventScheduler::clearTimers()
|
||||
{
|
||||
for (QTimer *timer : std::as_const(_timers)) {
|
||||
timer->disconnect();
|
||||
timer->stop();
|
||||
delete timer;
|
||||
}
|
||||
_timers.clear();
|
||||
}
|
||||
|
||||
void EventScheduler::handleEvent(int timerIndex)
|
||||
{
|
||||
QTime time = _scheduledEvents.at(timerIndex).time;
|
||||
Event action = _scheduledEvents.at(timerIndex).action;
|
||||
Debug(_log, "Event : \"%s\" triggers action \"%s\"", QSTRING_CSTR(time.toString()), eventToString(action) );
|
||||
if ( action != Event::Unknown )
|
||||
{
|
||||
emit signalEvent(action);
|
||||
}
|
||||
|
||||
// Retrigger the timer for the next occurrence
|
||||
QTimer* timer = _timers.at(timerIndex);
|
||||
int milliseconds = getMillisecondsToNextScheduledTime(time);
|
||||
timer->start(milliseconds);
|
||||
}
|
||||
|
||||
int EventScheduler::getMillisecondsToNextScheduledTime(const QTime& scheduledTime)
|
||||
{
|
||||
QDateTime currentDateTime = QDateTime::currentDateTime();
|
||||
QTime currentTime = currentDateTime.time();
|
||||
|
||||
QDateTime nextOccurrence = currentDateTime;
|
||||
nextOccurrence.setTime(scheduledTime);
|
||||
|
||||
// If the scheduled time has already passed for today, schedule it for tomorrow
|
||||
if (currentTime > scheduledTime)
|
||||
{
|
||||
nextOccurrence = nextOccurrence.addDays(1);
|
||||
}
|
||||
|
||||
int milliseconds = currentDateTime.msecsTo(nextOccurrence);
|
||||
return (milliseconds > 0) ? milliseconds : 0;
|
||||
}
|
||||
626
libsrc/events/OsEventHandler.cpp
Normal file
626
libsrc/events/OsEventHandler.cpp
Normal file
@@ -0,0 +1,626 @@
|
||||
#include "events/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" )
|
||||
#elif defined(__APPLE__)
|
||||
#include <AppKit/AppKit.h>
|
||||
#endif
|
||||
|
||||
OsEventHandlerBase::OsEventHandlerBase()
|
||||
: _isSuspendEnabled(false)
|
||||
, _isLockEnabled(false)
|
||||
, _isSuspendOnLock(false)
|
||||
, _isSuspendRegistered(false)
|
||||
, _isLockRegistered(false)
|
||||
{
|
||||
qRegisterMetaType<Event>("Event");
|
||||
_log = Logger::getInstance("EVENTS-OS");
|
||||
|
||||
QObject::connect(this, &OsEventHandlerBase::signalEvent, EventHandler::getInstance(), &EventHandler::handleEvent);
|
||||
}
|
||||
|
||||
OsEventHandlerBase::~OsEventHandlerBase()
|
||||
{
|
||||
QObject::disconnect(this, &OsEventHandlerBase::signalEvent, EventHandler::getInstance(), &EventHandler::handleEvent);
|
||||
|
||||
OsEventHandlerBase::unregisterLockHandler();
|
||||
OsEventHandlerBase::unregisterOsEventHandler();
|
||||
|
||||
Info(_log, "Operating System event handler stopped");
|
||||
}
|
||||
|
||||
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
|
||||
|
||||
#elif defined(__APPLE__)
|
||||
|
||||
OsEventHandlerMacOS::OsEventHandlerMacOS()
|
||||
: _sleepEventHandler(nullptr)
|
||||
, _lockEventHandler(nullptr)
|
||||
{
|
||||
}
|
||||
|
||||
@interface SleepEvents : NSObject
|
||||
{
|
||||
OsEventHandlerMacOS *_eventHandler;
|
||||
}
|
||||
- (id)initSleepEvents:(OsEventHandlerMacOS *)osEventHandler;
|
||||
@end
|
||||
|
||||
@implementation SleepEvents
|
||||
- (id)initSleepEvents:(OsEventHandlerMacOS *)osEventHandler
|
||||
{
|
||||
if ((self = [super init]))
|
||||
{
|
||||
_eventHandler = osEventHandler;
|
||||
id notifCenter = [[NSWorkspace sharedWorkspace] notificationCenter];
|
||||
[notifCenter addObserver:self selector:@selector(receiveSleepWake:) name:NSWorkspaceWillSleepNotification object:nil];
|
||||
[notifCenter addObserver:self selector:@selector(receiveSleepWake:) name:NSWorkspaceDidWakeNotification object:nil];
|
||||
}
|
||||
|
||||
return self;
|
||||
}
|
||||
|
||||
- (void)dealloc
|
||||
{
|
||||
[[[NSWorkspace sharedWorkspace] notificationCenter] removeObserver:self];
|
||||
_eventHandler = nullptr;
|
||||
[super dealloc];
|
||||
}
|
||||
|
||||
- (void) receiveSleepWake:(NSNotification*)notification
|
||||
{
|
||||
if (!_eventHandler) return;
|
||||
if (notification.name == NSWorkspaceWillSleepNotification)
|
||||
{
|
||||
_eventHandler->suspend(true);
|
||||
}
|
||||
else if (notification.name == NSWorkspaceDidWakeNotification)
|
||||
{
|
||||
_eventHandler->suspend(false);
|
||||
}
|
||||
}
|
||||
@end
|
||||
|
||||
bool OsEventHandlerMacOS::registerOsEventHandler()
|
||||
{
|
||||
bool isRegistered {_isSuspendRegistered};
|
||||
if (!_isSuspendRegistered)
|
||||
{
|
||||
_sleepEventHandler = [[SleepEvents alloc] initSleepEvents:this];
|
||||
if (_sleepEventHandler)
|
||||
{
|
||||
Debug(_log, "Registered for suspend/resume events");
|
||||
isRegistered = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
Error(_log, "Could not register for suspend/resume events");
|
||||
}
|
||||
|
||||
if (isRegistered)
|
||||
{
|
||||
_isSuspendRegistered = true;
|
||||
}
|
||||
}
|
||||
return isRegistered;
|
||||
}
|
||||
|
||||
void OsEventHandlerMacOS::unregisterOsEventHandler()
|
||||
{
|
||||
if (_isSuspendRegistered && _sleepEventHandler)
|
||||
{
|
||||
[(SleepEvents *)_sleepEventHandler release], _sleepEventHandler = nil;
|
||||
if (!_sleepEventHandler)
|
||||
{
|
||||
Debug(_log, "Unregistered for suspend/resume events");
|
||||
_isSuspendRegistered = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
Error(_log, "Could not unregister for suspend/resume events");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@interface LockEvents : NSObject
|
||||
{
|
||||
OsEventHandlerMacOS *_eventHandler;
|
||||
}
|
||||
- (id)initLockEvents:(OsEventHandlerMacOS *)osEventHandler;
|
||||
@end
|
||||
|
||||
@implementation LockEvents
|
||||
- (id)initLockEvents:(OsEventHandlerMacOS *)osEventHandler
|
||||
{
|
||||
if ((self = [super init]))
|
||||
{
|
||||
_eventHandler = osEventHandler;
|
||||
id defCenter = [NSDistributedNotificationCenter defaultCenter];
|
||||
[defCenter addObserver:self selector:@selector(receiveLockUnlock:) name:@"com.apple.screenIsLocked" object:nil];
|
||||
[defCenter addObserver:self selector:@selector(receiveLockUnlock:) name:@"com.apple.screenIsUnlocked" object:nil];
|
||||
}
|
||||
|
||||
return self;
|
||||
}
|
||||
|
||||
- (void)dealloc
|
||||
{
|
||||
[[[NSWorkspace sharedWorkspace] notificationCenter] removeObserver:self];
|
||||
_eventHandler = nullptr;
|
||||
[super dealloc];
|
||||
}
|
||||
|
||||
- (void) receiveLockUnlock:(NSNotification*)notification
|
||||
{
|
||||
if (!_eventHandler) return;
|
||||
if (CFEqual(notification.name, CFSTR("com.apple.screenIsLocked")))
|
||||
{
|
||||
_eventHandler->lock(true);
|
||||
}
|
||||
else if (CFEqual(notification.name, CFSTR("com.apple.screenIsUnlocked")))
|
||||
{
|
||||
_eventHandler->lock(false);
|
||||
}
|
||||
}
|
||||
@end
|
||||
|
||||
bool OsEventHandlerMacOS::registerLockHandler()
|
||||
{
|
||||
bool isRegistered{ _isLockRegistered };
|
||||
if (!_isLockRegistered)
|
||||
{
|
||||
_lockEventHandler = [[LockEvents alloc] initLockEvents:this];
|
||||
if (_lockEventHandler)
|
||||
{
|
||||
Debug(_log, "Registered for lock/unlock events");
|
||||
isRegistered = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
Error(_log, "Could not register for lock/unlock events!");
|
||||
}
|
||||
}
|
||||
|
||||
if (isRegistered)
|
||||
{
|
||||
_isLockRegistered = true;
|
||||
}
|
||||
return isRegistered;
|
||||
}
|
||||
|
||||
void OsEventHandlerMacOS::unregisterLockHandler()
|
||||
{
|
||||
if (_isLockRegistered && _lockEventHandler)
|
||||
{
|
||||
[(LockEvents *)_lockEventHandler release], _lockEventHandler = nil;
|
||||
if (!_lockEventHandler)
|
||||
{
|
||||
Debug(_log, "Unregistered for lock/unlock events");
|
||||
_isLockRegistered = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
Error(_log, "Could not unregister for lock/unlock events");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user