From 407453166ce2a52433c7b0b4ee92a41e47ef8f6d Mon Sep 17 00:00:00 2001 From: Maximilian Seidler <78690852+PaideiaDilemma@users.noreply.github.com> Date: Sun, 19 Jan 2025 18:21:36 +0000 Subject: protocols: add hyprland_lock_notify_v1 implementation (#9092) --- src/managers/ProtocolManager.cpp | 5 ++- src/protocols/LockNotify.cpp | 88 ++++++++++++++++++++++++++++++++++++++++ src/protocols/LockNotify.hpp | 50 +++++++++++++++++++++++ src/protocols/SessionLock.cpp | 4 ++ 4 files changed, 146 insertions(+), 1 deletion(-) create mode 100644 src/protocols/LockNotify.cpp create mode 100644 src/protocols/LockNotify.hpp (limited to 'src') diff --git a/src/managers/ProtocolManager.cpp b/src/managers/ProtocolManager.cpp index b7d61f67..8e32bdec 100644 --- a/src/managers/ProtocolManager.cpp +++ b/src/managers/ProtocolManager.cpp @@ -20,6 +20,7 @@ #include "../protocols/OutputPower.hpp" #include "../protocols/XDGActivation.hpp" #include "../protocols/IdleNotify.hpp" +#include "../protocols/LockNotify.hpp" #include "../protocols/SessionLock.hpp" #include "../protocols/InputMethodV2.hpp" #include "../protocols/VirtualKeyboard.hpp" @@ -145,6 +146,7 @@ CProtocolManager::CProtocolManager() { PROTO::outputPower = std::make_unique(&zwlr_output_power_manager_v1_interface, 1, "OutputPower"); PROTO::activation = std::make_unique(&xdg_activation_v1_interface, 1, "XDGActivation"); PROTO::idle = std::make_unique(&ext_idle_notifier_v1_interface, 1, "IdleNotify"); + PROTO::lockNotify = std::make_unique(&hyprland_lock_notifier_v1_interface, 1, "IdleNotify"); PROTO::sessionLock = std::make_unique(&ext_session_lock_manager_v1_interface, 1, "SessionLock"); PROTO::ime = std::make_unique(&zwp_input_method_manager_v2_interface, 1, "IMEv2"); PROTO::virtualKeyboard = std::make_unique(&zwp_virtual_keyboard_manager_v1_interface, 1, "VirtualKeyboard"); @@ -224,6 +226,7 @@ CProtocolManager::~CProtocolManager() { PROTO::outputPower.reset(); PROTO::activation.reset(); PROTO::idle.reset(); + PROTO::lockNotify.reset(); PROTO::sessionLock.reset(); PROTO::ime.reset(); PROTO::virtualKeyboard.reset(); @@ -296,7 +299,7 @@ bool CProtocolManager::isGlobalPrivileged(const wl_global* global) { PROTO::xdgDialog->getGlobal(), PROTO::singlePixel->getGlobal(), PROTO::primarySelection->getGlobal(), - PROTO::hyprlandSurface->getGlobal(), + PROTO::hyprlandSurface->getGlobal(), PROTO::sync ? PROTO::sync->getGlobal() : nullptr, PROTO::mesaDRM ? PROTO::mesaDRM->getGlobal() : nullptr, PROTO::linuxDma ? PROTO::linuxDma->getGlobal() : nullptr, 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 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(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(makeShared(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 +#include +#include +#include "WaylandProtocol.hpp" +#include "hyprland-lock-notify-v1.hpp" + +class CEventLoopTimer; + +class CHyprlandLockNotification { + public: + CHyprlandLockNotification(SP resource_); + ~CHyprlandLockNotification() = default; + + bool good(); + void onLocked(); + void onUnlocked(); + + private: + SP 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> m_managers; + std::vector> m_notifications; + + friend class CHyprlandLockNotification; +}; + +namespace PROTO { + inline UP 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 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() { -- cgit v1.2.3