refactor: moved from using ScreenSaver to using custom dbus channel org.quickshell.SessionLock

Author: saltnpepper97

src/dbus/CMakeLists.txt

@@ -1,37 +1,45 @@
 set_source_files_properties(org.freedesktop.DBus.Properties.xml PROPERTIES
 	CLASSNAME DBusPropertiesInterface
 )
+
 set_source_files_properties(org.freedesktop.DBus.ObjectManager.xml PROPERTIES
 	CLASSNAME DBusObjectManagerInterface
 	INCLUDE ${CMAKE_CURRENT_SOURCE_DIR}/dbus_objectmanager_types.hpp
 )
-set_source_files_properties(org.freedesktop.ScreenSaver.xml PROPERTIES
-	CLASSNAME ScreenSaverAdaptor
-	INCLUDE screensaver_dbus.hpp
+
+set_source_files_properties(org.quickshell.SessionLock.xml PROPERTIES
+	CLASSNAME SessionLockAdaptor
+	INCLUDE session_lock_dbus.hpp
 )
+
 qt_add_dbus_interface(DBUS_INTERFACES
 	org.freedesktop.DBus.Properties.xml
 	dbus_properties
 )
+
 qt_add_dbus_interface(DBUS_INTERFACES
 	org.freedesktop.DBus.ObjectManager.xml
 	dbus_objectmanager
 )
+
 qt_add_dbus_adaptor(DBUS_INTERFACES
-	org.freedesktop.ScreenSaver.xml
-	${CMAKE_CURRENT_SOURCE_DIR}/screensaver_dbus.hpp
-	qs::dbus::ScreenSaverAdaptor
+	org.quickshell.SessionLock.xml
+	${CMAKE_CURRENT_SOURCE_DIR}/session_lock_dbus.hpp
+	qs::dbus::SessionLockAdaptor
 )
+
 qt_add_library(quickshell-dbus STATIC
 	properties.cpp
 	objectmanager.cpp
 	bus.cpp
-	screensaver_dbus.cpp
+	session_lock_dbus.cpp
 	${DBUS_INTERFACES}
 )
+
 # dbus headers
 target_include_directories(quickshell-dbus PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
 target_link_libraries(quickshell-dbus PRIVATE Qt::Core Qt::DBus)
+
 # todo: link dbus to quickshell here instead of in modules that use it directly
 # linker does not like this as is
 qs_add_pchset(dbus
@@ -41,5 +49,7 @@ qs_add_pchset(dbus
 		<qdebug.h>
 		<qdbusargument.h>
 )
+
 qs_pch(quickshell-dbus SET dbus)
+
 add_subdirectory(dbusmenu)

src/dbus/org.freedesktop.ScreenSaver.xml

@@ -0,0 +1,23 @@
+<node>
+	<interface name="org.quickshell.SessionLock">
+		<!-- Get the current lock state -->
+		<method name="GetLocked">
+			<arg name="locked" direction="out" type="b"/>
+		</method>
+		
+		<!-- Signal emitted when lock state changes -->
+		<signal name="LockedChanged">
+			<arg name="locked" type="b"/>
+		</signal>
+		
+		<!-- Get whether the compositor has confirmed the lock (secure state) -->
+		<method name="GetSecure">
+			<arg name="secure" direction="out" type="b"/>
+		</method>
+		
+		<!-- Signal emitted when secure state changes -->
+		<signal name="SecureChanged">
+			<arg name="secure" type="b"/>
+		</signal>
+	</interface>
+</node>

src/dbus/org.quickshell.SessionLock.xml

@@ -0,0 +1,66 @@
+#include "session_lock_dbus.hpp"
+
+#include <qdbusabstractadaptor.h>
+#include <qdbusconnection.h>
+#include <qdbuserror.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qtmetamacros.h>
+
+#include "../core/logcat.hpp"
+
+namespace {
+QS_LOGGING_CATEGORY(logDbusSessionLock, "quickshell.dbus.sessionlock", QtWarningMsg);
+}
+
+namespace qs::dbus {
+
+SessionLockAdaptor::SessionLockAdaptor(QObject* parent): QDBusAbstractAdaptor(parent) {
+	// Register on session bus
+	auto connection = QDBusConnection::sessionBus();
+
+	if (!connection.registerService("org.quickshell.SessionLock")) {
+		qCWarning(logDbusSessionLock) << "Failed to register DBus service org.quickshell.SessionLock:"
+		                              << connection.lastError().message();
+	} else {
+		qCInfo(logDbusSessionLock) << "Registered DBus service org.quickshell.SessionLock";
+	}
+
+	if (!connection
+	         .registerObject("/org/quickshell/SessionLock", parent, QDBusConnection::ExportAdaptors))
+	{
+		qCWarning(logDbusSessionLock) << "Failed to register DBus object /org/quickshell/SessionLock:"
+		                              << connection.lastError().message();
+	} else {
+		qCInfo(logDbusSessionLock) << "Registered DBus object /org/quickshell/SessionLock";
+	}
+}
+
+void SessionLockAdaptor::setLocked(bool locked) {
+	if (this->mLocked != locked) {
+		this->mLocked = locked;
+		qCDebug(logDbusSessionLock) << "Lock state changed to:" << locked;
+		emit this->LockedChanged(locked);
+	}
+}
+
+void SessionLockAdaptor::setSecure(bool secure) {
+	if (this->mSecure != secure) {
+		this->mSecure = secure;
+		qCDebug(logDbusSessionLock) << "Secure state changed to:" << secure;
+		emit this->SecureChanged(secure);
+	}
+}
+
+bool SessionLockAdaptor::GetLocked() const {
+	qCDebug(logDbusSessionLock) << "GetLocked called, returning:" << this->mLocked;
+	return this->mLocked;
+}
+
+bool SessionLockAdaptor::GetSecure() const {
+	qCDebug(logDbusSessionLock) << "GetSecure called, returning:" << this->mSecure;
+	return this->mSecure;
+}
+
+} // namespace qs::dbus

src/dbus/screensaver_dbus.cpp

@@ -0,0 +1,33 @@
+#pragma once
+#include <qdbusabstractadaptor.h>
+#include <qobject.h>
+#include <qtmetamacros.h>
+
+namespace qs::dbus {
+
+class SessionLockAdaptor: public QDBusAbstractAdaptor {
+	Q_OBJECT;
+	Q_CLASSINFO("D-Bus Interface", "org.quickshell.SessionLock")
+
+public:
+	explicit SessionLockAdaptor(QObject* parent);
+	~SessionLockAdaptor() override = default;
+	Q_DISABLE_COPY_MOVE(SessionLockAdaptor);
+
+	void setLocked(bool locked);
+	void setSecure(bool secure);
+
+public slots:
+	[[nodiscard]] bool GetLocked() const; // NOLINT(readability-identifier-naming)
+	[[nodiscard]] bool GetSecure() const; // NOLINT(readability-identifier-naming)
+
+signals:
+	void LockedChanged(bool locked); // NOLINT(readability-identifier-naming)
+	void SecureChanged(bool secure); // NOLINT(readability-identifier-naming)
+
+private:
+	bool mLocked = false;
+	bool mSecure = false;
+};
+
+} // namespace qs::dbus

src/dbus/screensaver_dbus.hpp

@@ -6,7 +6,7 @@
 #include <qtmetamacros.h>
 #include <qwindow.h>
 
-#include "../../dbus/screensaver_dbus.hpp"
+#include "../../dbus/session_lock_dbus.hpp"
 #include "lock.hpp"
 #include "manager.hpp"
 #include "shell_integration.hpp"
@@ -16,14 +16,22 @@ namespace {
 
 QSWaylandSessionLockManager* manager() {
 	static QSWaylandSessionLockManager* manager = nullptr; // NOLINT
+
 	if (manager == nullptr) {
 		manager = new QSWaylandSessionLockManager();
 	}
+
 	return manager;
 }
 
 } // namespace
 
+SessionLockManager::SessionLockManager(QObject* parent)
+    : QObject(parent)
+    , mDbusAdaptor(new qs::dbus::SessionLockAdaptor(this)) {
+	// DBus adaptor initialized in member initializer list so the service is always available
+}
+
 bool SessionLockManager::lockAvailable() { return manager()->isActive(); }
 
 bool SessionLockManager::lock() {
@@ -32,23 +40,18 @@ bool SessionLockManager::lock() {
 	this->mLock = manager()->acquireLock();
 	this->mLock->setParent(this);
 
-	// Initialize DBus adaptor if not already created
-	if (this->mDbusAdaptor == nullptr) {
-		this->mDbusAdaptor = new qs::dbus::ScreenSaverAdaptor(this);
-	}
-
 	// Notify DBus that we're attempting to lock (not yet secure)
-	this->mDbusAdaptor->setActive(true);
+	this->mDbusAdaptor->setLocked(true);
 	this->mDbusAdaptor->setSecure(false);
 
 	// clang-format off
 	QObject::connect(this->mLock, &QSWaylandSessionLock::compositorLocked, this, [this]() {
 		this->mDbusAdaptor->setSecure(true);
 		emit this->locked();
 	});
-
+	
 	QObject::connect(this->mLock, &QSWaylandSessionLock::unlocked, this, [this]() {
-		this->mDbusAdaptor->setActive(false);
+		this->mDbusAdaptor->setLocked(false);
 		this->mDbusAdaptor->setSecure(false);
 		emit this->unlocked();
 	});
@@ -61,6 +64,7 @@ bool SessionLockManager::unlock() {
 	if (!this->isLocked()) return false;
 
 	this->mLock->unlock();
+
 	auto* lock = this->mLock;
 	this->mLock = nullptr;
 	delete lock;
@@ -82,6 +86,7 @@ LockWindowExtension::~LockWindowExtension() {
 
 LockWindowExtension* LockWindowExtension::get(QWindow* window) {
 	auto v = window->property("sessionlock_ext");
+
 	if (v.canConvert<LockWindowExtension*>()) {
 		return v.value<LockWindowExtension*>();
 	} else {
@@ -107,14 +112,17 @@ bool LockWindowExtension::attach(QWindow* window, SessionLockManager* manager) {
 		window->setScreen(screen);
 
 		waylandWindow = dynamic_cast<QtWaylandClient::QWaylandWindow*>(window->handle());
+
 		if (waylandWindow == nullptr) {
 			qWarning() << window << "is not a wayland window. Cannot create lock surface.";
 			return false;
 		}
 
 		static QSWaylandSessionLockIntegration* lockIntegration = nullptr; // NOLINT
+
 		if (lockIntegration == nullptr) {
 			lockIntegration = new QSWaylandSessionLockIntegration();
+
 			if (!lockIntegration->initialize(waylandWindow->display())) {
 				delete lockIntegration;
 				lockIntegration = nullptr;