protocols: add hyprland_lock_notify_v1 implementation (#9092)

3 files changed, 142 insertions, 0 deletions

diff --git a/src/protocols/LockNotify.cpp b/src/protocols/LockNotify.cpp
new file mode 100644
index 00000000..adcd0b2d
--- /dev/null
+++ b/src/protocols/LockNotify.cpp
@@ -0,0 +1,88 @@
+#include "LockNotify.hpp"
+
+CHyprlandLockNotification::CHyprlandLockNotification(SP<CHyprlandLockNotificationV1> resource_) : m_resource(resource_) {
+    if UNLIKELY (!m_resource->resource())
+        return;
+
+    m_resource->setDestroy([this](CHyprlandLockNotificationV1* r) { PROTO::lockNotify->destroyNotification(this); });
+    m_resource->setOnDestroy([this](CHyprlandLockNotificationV1* r) { PROTO::lockNotify->destroyNotification(this); });
+}
+
+bool CHyprlandLockNotification::good() {
+    return m_resource->resource();
+}
+
+void CHyprlandLockNotification::onLocked() {
+    if LIKELY (!m_locked)
+        m_resource->sendLocked();
+
+    m_locked = true;
+}
+
+void CHyprlandLockNotification::onUnlocked() {
+    if LIKELY (m_locked)
+        m_resource->sendUnlocked();
+
+    m_locked = false;
+}
+
+CLockNotifyProtocol::CLockNotifyProtocol(const wl_interface* iface, const int& ver, const std::string& name) : IWaylandProtocol(iface, ver, name) {
+    ;
+}
+
+void CLockNotifyProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) {
+    const auto RESOURCE = m_managers.emplace_back(std::make_unique<CHyprlandLockNotifierV1>(client, ver, id)).get();
+    RESOURCE->setOnDestroy([this](CHyprlandLockNotifierV1* p) { this->onManagerResourceDestroy(p->resource()); });
+
+    RESOURCE->setDestroy([this](CHyprlandLockNotifierV1* pMgr) { this->onManagerResourceDestroy(pMgr->resource()); });
+    RESOURCE->setGetLockNotification([this](CHyprlandLockNotifierV1* pMgr, uint32_t id) { this->onGetNotification(pMgr, id); });
+}
+
+void CLockNotifyProtocol::onManagerResourceDestroy(wl_resource* res) {
+    std::erase_if(m_managers, [&](const auto& other) { return other->resource() == res; });
+}
+
+void CLockNotifyProtocol::destroyNotification(CHyprlandLockNotification* notif) {
+    std::erase_if(m_notifications, [&](const auto& other) { return other.get() == notif; });
+}
+
+void CLockNotifyProtocol::onGetNotification(CHyprlandLockNotifierV1* pMgr, uint32_t id) {
+    const auto CLIENT   = pMgr->client();
+    const auto RESOURCE = m_notifications.emplace_back(makeShared<CHyprlandLockNotification>(makeShared<CHyprlandLockNotificationV1>(CLIENT, pMgr->version(), id))).get();
+
+    if UNLIKELY (!RESOURCE->good()) {
+        pMgr->noMemory();
+        m_notifications.pop_back();
+        return;
+    }
+
+    // Already locked?? Send locked right away
+    if UNLIKELY (m_isLocked)
+        m_notifications.back()->onLocked();
+}
+
+void CLockNotifyProtocol::onLocked() {
+    if UNLIKELY (m_isLocked) {
+        LOGM(ERR, "Not sending lock notification. Already locked!");
+        return;
+    }
+
+    for (auto const& n : m_notifications) {
+        n->onLocked();
+    }
+
+    m_isLocked = true;
+}
+
+void CLockNotifyProtocol::onUnlocked() {
+    if UNLIKELY (!m_isLocked) {
+        LOGM(ERR, "Not sending unlock notification. Not locked!");
+        return;
+    }
+
+    for (auto const& n : m_notifications) {
+        n->onUnlocked();
+    }
+
+    m_isLocked = false;
+}
diff --git a/src/protocols/LockNotify.hpp b/src/protocols/LockNotify.hpp
new file mode 100644
index 00000000..ec71034b
--- /dev/null
+++ b/src/protocols/LockNotify.hpp
@@ -0,0 +1,50 @@
+#pragma once
+
+#include <memory>
+#include <vector>
+#include <unordered_map>
+#include "WaylandProtocol.hpp"
+#include "hyprland-lock-notify-v1.hpp"
+
+class CEventLoopTimer;
+
+class CHyprlandLockNotification {
+  public:
+    CHyprlandLockNotification(SP<CHyprlandLockNotificationV1> resource_);
+    ~CHyprlandLockNotification() = default;
+
+    bool good();
+    void onLocked();
+    void onUnlocked();
+
+  private:
+    SP<CHyprlandLockNotificationV1> m_resource;
+    bool                            m_locked = false;
+};
+
+class CLockNotifyProtocol : public IWaylandProtocol {
+  public:
+    CLockNotifyProtocol(const wl_interface* iface, const int& ver, const std::string& name);
+
+    virtual void bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id);
+
+    void         onLocked();
+    void         onUnlocked();
+
+  private:
+    void onManagerResourceDestroy(wl_resource* res);
+    void destroyNotification(CHyprlandLockNotification* notif);
+    void onGetNotification(CHyprlandLockNotifierV1* pMgr, uint32_t id);
+
+    bool m_isLocked = false;
+
+    //
+    std::vector<UP<CHyprlandLockNotifierV1>>   m_managers;
+    std::vector<SP<CHyprlandLockNotification>> m_notifications;
+
+    friend class CHyprlandLockNotification;
+};
+
+namespace PROTO {
+    inline UP<CLockNotifyProtocol> lockNotify;
+};
diff --git a/src/protocols/SessionLock.cpp b/src/protocols/SessionLock.cpp
index db65ee5f..8e215ffa 100644
--- a/src/protocols/SessionLock.cpp
+++ b/src/protocols/SessionLock.cpp
@@ -2,6 +2,7 @@
 #include "../Compositor.hpp"
 #include "../managers/SeatManager.hpp"
 #include "FractionalScale.hpp"
+#include "LockNotify.hpp"
 #include "core/Compositor.hpp"
 #include "core/Output.hpp"
 #include "../helpers/Monitor.hpp"
@@ -115,6 +116,8 @@ CSessionLock::CSessionLock(SP<CExtSessionLockV1> resource_) : resource(resource_
 
         PROTO::sessionLock->locked = false;
 
+        PROTO::lockNotify->onUnlocked();
+
         events.unlockAndDestroy.emit();
 
         inert = true;
@@ -128,6 +131,7 @@ CSessionLock::~CSessionLock() {
 
 void CSessionLock::sendLocked() {
     resource->sendLocked();
+    PROTO::lockNotify->onLocked();
 }
 
 bool CSessionLock::good() {