diff --git a/internal/platform/implementation/linux/login_manager_client_glue.h b/internal/platform/implementation/linux/login_manager_client_glue.h new file mode 100644 index 00000000..4de655b9 --- /dev/null +++ b/internal/platform/implementation/linux/login_manager_client_glue.h @@ -0,0 +1,631 @@ + +/* + * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT! + */ + +#ifndef __sdbuscpp__login_manager_client_glue_h__proxy__H__ +#define __sdbuscpp__login_manager_client_glue_h__proxy__H__ + +#include +#include +#include + +namespace org { +namespace freedesktop { +namespace login1 { + +class Manager_proxy +{ +public: + static constexpr const char* INTERFACE_NAME = "org.freedesktop.login1.Manager"; + +protected: + Manager_proxy(sdbus::IProxy& proxy) + : proxy_(proxy) + { + proxy_.uponSignal("SessionNew").onInterface(INTERFACE_NAME).call([this](const std::string& session_id, const sdbus::ObjectPath& object_path){ this->onSessionNew(session_id, object_path); }); + proxy_.uponSignal("SessionRemoved").onInterface(INTERFACE_NAME).call([this](const std::string& session_id, const sdbus::ObjectPath& object_path){ this->onSessionRemoved(session_id, object_path); }); + proxy_.uponSignal("UserNew").onInterface(INTERFACE_NAME).call([this](const uint32_t& uid, const sdbus::ObjectPath& object_path){ this->onUserNew(uid, object_path); }); + proxy_.uponSignal("UserRemoved").onInterface(INTERFACE_NAME).call([this](const uint32_t& uid, const sdbus::ObjectPath& object_path){ this->onUserRemoved(uid, object_path); }); + proxy_.uponSignal("SeatNew").onInterface(INTERFACE_NAME).call([this](const std::string& seat_id, const sdbus::ObjectPath& object_path){ this->onSeatNew(seat_id, object_path); }); + proxy_.uponSignal("SeatRemoved").onInterface(INTERFACE_NAME).call([this](const std::string& seat_id, const sdbus::ObjectPath& object_path){ this->onSeatRemoved(seat_id, object_path); }); + proxy_.uponSignal("PrepareForShutdown").onInterface(INTERFACE_NAME).call([this](const bool& start){ this->onPrepareForShutdown(start); }); + proxy_.uponSignal("PrepareForSleep").onInterface(INTERFACE_NAME).call([this](const bool& start){ this->onPrepareForSleep(start); }); + } + + ~Manager_proxy() = default; + + virtual void onSessionNew(const std::string& session_id, const sdbus::ObjectPath& object_path) = 0; + virtual void onSessionRemoved(const std::string& session_id, const sdbus::ObjectPath& object_path) = 0; + virtual void onUserNew(const uint32_t& uid, const sdbus::ObjectPath& object_path) = 0; + virtual void onUserRemoved(const uint32_t& uid, const sdbus::ObjectPath& object_path) = 0; + virtual void onSeatNew(const std::string& seat_id, const sdbus::ObjectPath& object_path) = 0; + virtual void onSeatRemoved(const std::string& seat_id, const sdbus::ObjectPath& object_path) = 0; + virtual void onPrepareForShutdown(const bool& start) = 0; + virtual void onPrepareForSleep(const bool& start) = 0; + +public: + sdbus::ObjectPath GetSession(const std::string& session_id) + { + sdbus::ObjectPath result; + proxy_.callMethod("GetSession").onInterface(INTERFACE_NAME).withArguments(session_id).storeResultsTo(result); + return result; + } + + sdbus::ObjectPath GetSessionByPID(const uint32_t& pid) + { + sdbus::ObjectPath result; + proxy_.callMethod("GetSessionByPID").onInterface(INTERFACE_NAME).withArguments(pid).storeResultsTo(result); + return result; + } + + sdbus::ObjectPath GetUser(const uint32_t& uid) + { + sdbus::ObjectPath result; + proxy_.callMethod("GetUser").onInterface(INTERFACE_NAME).withArguments(uid).storeResultsTo(result); + return result; + } + + sdbus::ObjectPath GetUserByPID(const uint32_t& pid) + { + sdbus::ObjectPath result; + proxy_.callMethod("GetUserByPID").onInterface(INTERFACE_NAME).withArguments(pid).storeResultsTo(result); + return result; + } + + sdbus::ObjectPath GetSeat(const std::string& seat_id) + { + sdbus::ObjectPath result; + proxy_.callMethod("GetSeat").onInterface(INTERFACE_NAME).withArguments(seat_id).storeResultsTo(result); + return result; + } + + std::vector> ListSessions() + { + std::vector> result; + proxy_.callMethod("ListSessions").onInterface(INTERFACE_NAME).storeResultsTo(result); + return result; + } + + std::vector> ListUsers() + { + std::vector> result; + proxy_.callMethod("ListUsers").onInterface(INTERFACE_NAME).storeResultsTo(result); + return result; + } + + std::vector> ListSeats() + { + std::vector> result; + proxy_.callMethod("ListSeats").onInterface(INTERFACE_NAME).storeResultsTo(result); + return result; + } + + std::vector> ListInhibitors() + { + std::vector> result; + proxy_.callMethod("ListInhibitors").onInterface(INTERFACE_NAME).storeResultsTo(result); + return result; + } + + std::tuple CreateSession(const uint32_t& uid, const uint32_t& pid, const std::string& service, const std::string& type, const std::string& class_, const std::string& desktop, const std::string& seat_id, const uint32_t& vtnr, const std::string& tty, const std::string& display, const bool& remote, const std::string& remote_user, const std::string& remote_host, const std::vector>& properties) + { + std::tuple result; + proxy_.callMethod("CreateSession").onInterface(INTERFACE_NAME).withArguments(uid, pid, service, type, class_, desktop, seat_id, vtnr, tty, display, remote, remote_user, remote_host, properties).storeResultsTo(result); + return result; + } + + void ReleaseSession(const std::string& session_id) + { + proxy_.callMethod("ReleaseSession").onInterface(INTERFACE_NAME).withArguments(session_id); + } + + void ActivateSession(const std::string& session_id) + { + proxy_.callMethod("ActivateSession").onInterface(INTERFACE_NAME).withArguments(session_id); + } + + void ActivateSessionOnSeat(const std::string& session_id, const std::string& seat_id) + { + proxy_.callMethod("ActivateSessionOnSeat").onInterface(INTERFACE_NAME).withArguments(session_id, seat_id); + } + + void LockSession(const std::string& session_id) + { + proxy_.callMethod("LockSession").onInterface(INTERFACE_NAME).withArguments(session_id); + } + + void UnlockSession(const std::string& session_id) + { + proxy_.callMethod("UnlockSession").onInterface(INTERFACE_NAME).withArguments(session_id); + } + + void LockSessions() + { + proxy_.callMethod("LockSessions").onInterface(INTERFACE_NAME); + } + + void UnlockSessions() + { + proxy_.callMethod("UnlockSessions").onInterface(INTERFACE_NAME); + } + + void KillSession(const std::string& session_id, const std::string& who, const int32_t& signal_number) + { + proxy_.callMethod("KillSession").onInterface(INTERFACE_NAME).withArguments(session_id, who, signal_number); + } + + void KillUser(const uint32_t& uid, const int32_t& signal_number) + { + proxy_.callMethod("KillUser").onInterface(INTERFACE_NAME).withArguments(uid, signal_number); + } + + void TerminateSession(const std::string& session_id) + { + proxy_.callMethod("TerminateSession").onInterface(INTERFACE_NAME).withArguments(session_id); + } + + void TerminateUser(const uint32_t& uid) + { + proxy_.callMethod("TerminateUser").onInterface(INTERFACE_NAME).withArguments(uid); + } + + void TerminateSeat(const std::string& seat_id) + { + proxy_.callMethod("TerminateSeat").onInterface(INTERFACE_NAME).withArguments(seat_id); + } + + void SetUserLinger(const uint32_t& uid, const bool& enable, const bool& interactive) + { + proxy_.callMethod("SetUserLinger").onInterface(INTERFACE_NAME).withArguments(uid, enable, interactive); + } + + void AttachDevice(const std::string& seat_id, const std::string& sysfs_path, const bool& interactive) + { + proxy_.callMethod("AttachDevice").onInterface(INTERFACE_NAME).withArguments(seat_id, sysfs_path, interactive); + } + + void FlushDevices(const bool& interactive) + { + proxy_.callMethod("FlushDevices").onInterface(INTERFACE_NAME).withArguments(interactive); + } + + void PowerOff(const bool& interactive) + { + proxy_.callMethod("PowerOff").onInterface(INTERFACE_NAME).withArguments(interactive); + } + + void PowerOffWithFlags(const uint64_t& flags) + { + proxy_.callMethod("PowerOffWithFlags").onInterface(INTERFACE_NAME).withArguments(flags); + } + + void Reboot(const bool& interactive) + { + proxy_.callMethod("Reboot").onInterface(INTERFACE_NAME).withArguments(interactive); + } + + void RebootWithFlags(const uint64_t& flags) + { + proxy_.callMethod("RebootWithFlags").onInterface(INTERFACE_NAME).withArguments(flags); + } + + void Halt(const bool& interactive) + { + proxy_.callMethod("Halt").onInterface(INTERFACE_NAME).withArguments(interactive); + } + + void HaltWithFlags(const uint64_t& flags) + { + proxy_.callMethod("HaltWithFlags").onInterface(INTERFACE_NAME).withArguments(flags); + } + + void Suspend(const bool& interactive) + { + proxy_.callMethod("Suspend").onInterface(INTERFACE_NAME).withArguments(interactive); + } + + void SuspendWithFlags(const uint64_t& flags) + { + proxy_.callMethod("SuspendWithFlags").onInterface(INTERFACE_NAME).withArguments(flags); + } + + void Hibernate(const bool& interactive) + { + proxy_.callMethod("Hibernate").onInterface(INTERFACE_NAME).withArguments(interactive); + } + + void HibernateWithFlags(const uint64_t& flags) + { + proxy_.callMethod("HibernateWithFlags").onInterface(INTERFACE_NAME).withArguments(flags); + } + + void HybridSleep(const bool& interactive) + { + proxy_.callMethod("HybridSleep").onInterface(INTERFACE_NAME).withArguments(interactive); + } + + void HybridSleepWithFlags(const uint64_t& flags) + { + proxy_.callMethod("HybridSleepWithFlags").onInterface(INTERFACE_NAME).withArguments(flags); + } + + void SuspendThenHibernate(const bool& interactive) + { + proxy_.callMethod("SuspendThenHibernate").onInterface(INTERFACE_NAME).withArguments(interactive); + } + + void SuspendThenHibernateWithFlags(const uint64_t& flags) + { + proxy_.callMethod("SuspendThenHibernateWithFlags").onInterface(INTERFACE_NAME).withArguments(flags); + } + + std::string CanPowerOff() + { + std::string result; + proxy_.callMethod("CanPowerOff").onInterface(INTERFACE_NAME).storeResultsTo(result); + return result; + } + + std::string CanReboot() + { + std::string result; + proxy_.callMethod("CanReboot").onInterface(INTERFACE_NAME).storeResultsTo(result); + return result; + } + + std::string CanHalt() + { + std::string result; + proxy_.callMethod("CanHalt").onInterface(INTERFACE_NAME).storeResultsTo(result); + return result; + } + + std::string CanSuspend() + { + std::string result; + proxy_.callMethod("CanSuspend").onInterface(INTERFACE_NAME).storeResultsTo(result); + return result; + } + + std::string CanHibernate() + { + std::string result; + proxy_.callMethod("CanHibernate").onInterface(INTERFACE_NAME).storeResultsTo(result); + return result; + } + + std::string CanHybridSleep() + { + std::string result; + proxy_.callMethod("CanHybridSleep").onInterface(INTERFACE_NAME).storeResultsTo(result); + return result; + } + + std::string CanSuspendThenHibernate() + { + std::string result; + proxy_.callMethod("CanSuspendThenHibernate").onInterface(INTERFACE_NAME).storeResultsTo(result); + return result; + } + + void ScheduleShutdown(const std::string& type, const uint64_t& usec) + { + proxy_.callMethod("ScheduleShutdown").onInterface(INTERFACE_NAME).withArguments(type, usec); + } + + bool CancelScheduledShutdown() + { + bool result; + proxy_.callMethod("CancelScheduledShutdown").onInterface(INTERFACE_NAME).storeResultsTo(result); + return result; + } + + sdbus::UnixFd Inhibit(const std::string& what, const std::string& who, const std::string& why, const std::string& mode) + { + sdbus::UnixFd result; + proxy_.callMethod("Inhibit").onInterface(INTERFACE_NAME).withArguments(what, who, why, mode).storeResultsTo(result); + return result; + } + + std::string CanRebootParameter() + { + std::string result; + proxy_.callMethod("CanRebootParameter").onInterface(INTERFACE_NAME).storeResultsTo(result); + return result; + } + + void SetRebootParameter(const std::string& parameter) + { + proxy_.callMethod("SetRebootParameter").onInterface(INTERFACE_NAME).withArguments(parameter); + } + + std::string CanRebootToFirmwareSetup() + { + std::string result; + proxy_.callMethod("CanRebootToFirmwareSetup").onInterface(INTERFACE_NAME).storeResultsTo(result); + return result; + } + + void SetRebootToFirmwareSetup(const bool& enable) + { + proxy_.callMethod("SetRebootToFirmwareSetup").onInterface(INTERFACE_NAME).withArguments(enable); + } + + std::string CanRebootToBootLoaderMenu() + { + std::string result; + proxy_.callMethod("CanRebootToBootLoaderMenu").onInterface(INTERFACE_NAME).storeResultsTo(result); + return result; + } + + void SetRebootToBootLoaderMenu(const uint64_t& timeout) + { + proxy_.callMethod("SetRebootToBootLoaderMenu").onInterface(INTERFACE_NAME).withArguments(timeout); + } + + std::string CanRebootToBootLoaderEntry() + { + std::string result; + proxy_.callMethod("CanRebootToBootLoaderEntry").onInterface(INTERFACE_NAME).storeResultsTo(result); + return result; + } + + void SetRebootToBootLoaderEntry(const std::string& boot_loader_entry) + { + proxy_.callMethod("SetRebootToBootLoaderEntry").onInterface(INTERFACE_NAME).withArguments(boot_loader_entry); + } + + void SetWallMessage(const std::string& wall_message, const bool& enable) + { + proxy_.callMethod("SetWallMessage").onInterface(INTERFACE_NAME).withArguments(wall_message, enable); + } + +public: + bool EnableWallMessages() + { + return proxy_.getProperty("EnableWallMessages").onInterface(INTERFACE_NAME); + } + + void EnableWallMessages(const bool& value) + { + proxy_.setProperty("EnableWallMessages").onInterface(INTERFACE_NAME).toValue(value); + } + + std::string WallMessage() + { + return proxy_.getProperty("WallMessage").onInterface(INTERFACE_NAME); + } + + void WallMessage(const std::string& value) + { + proxy_.setProperty("WallMessage").onInterface(INTERFACE_NAME).toValue(value); + } + + uint32_t NAutoVTs() + { + return proxy_.getProperty("NAutoVTs").onInterface(INTERFACE_NAME); + } + + std::vector KillOnlyUsers() + { + return proxy_.getProperty("KillOnlyUsers").onInterface(INTERFACE_NAME); + } + + std::vector KillExcludeUsers() + { + return proxy_.getProperty("KillExcludeUsers").onInterface(INTERFACE_NAME); + } + + bool KillUserProcesses() + { + return proxy_.getProperty("KillUserProcesses").onInterface(INTERFACE_NAME); + } + + std::string RebootParameter() + { + return proxy_.getProperty("RebootParameter").onInterface(INTERFACE_NAME); + } + + bool RebootToFirmwareSetup() + { + return proxy_.getProperty("RebootToFirmwareSetup").onInterface(INTERFACE_NAME); + } + + uint64_t RebootToBootLoaderMenu() + { + return proxy_.getProperty("RebootToBootLoaderMenu").onInterface(INTERFACE_NAME); + } + + std::string RebootToBootLoaderEntry() + { + return proxy_.getProperty("RebootToBootLoaderEntry").onInterface(INTERFACE_NAME); + } + + std::vector BootLoaderEntries() + { + return proxy_.getProperty("BootLoaderEntries").onInterface(INTERFACE_NAME); + } + + bool IdleHint() + { + return proxy_.getProperty("IdleHint").onInterface(INTERFACE_NAME); + } + + uint64_t IdleSinceHint() + { + return proxy_.getProperty("IdleSinceHint").onInterface(INTERFACE_NAME); + } + + uint64_t IdleSinceHintMonotonic() + { + return proxy_.getProperty("IdleSinceHintMonotonic").onInterface(INTERFACE_NAME); + } + + std::string BlockInhibited() + { + return proxy_.getProperty("BlockInhibited").onInterface(INTERFACE_NAME); + } + + std::string DelayInhibited() + { + return proxy_.getProperty("DelayInhibited").onInterface(INTERFACE_NAME); + } + + uint64_t InhibitDelayMaxUSec() + { + return proxy_.getProperty("InhibitDelayMaxUSec").onInterface(INTERFACE_NAME); + } + + uint64_t UserStopDelayUSec() + { + return proxy_.getProperty("UserStopDelayUSec").onInterface(INTERFACE_NAME); + } + + std::string HandlePowerKey() + { + return proxy_.getProperty("HandlePowerKey").onInterface(INTERFACE_NAME); + } + + std::string HandlePowerKeyLongPress() + { + return proxy_.getProperty("HandlePowerKeyLongPress").onInterface(INTERFACE_NAME); + } + + std::string HandleRebootKey() + { + return proxy_.getProperty("HandleRebootKey").onInterface(INTERFACE_NAME); + } + + std::string HandleRebootKeyLongPress() + { + return proxy_.getProperty("HandleRebootKeyLongPress").onInterface(INTERFACE_NAME); + } + + std::string HandleSuspendKey() + { + return proxy_.getProperty("HandleSuspendKey").onInterface(INTERFACE_NAME); + } + + std::string HandleSuspendKeyLongPress() + { + return proxy_.getProperty("HandleSuspendKeyLongPress").onInterface(INTERFACE_NAME); + } + + std::string HandleHibernateKey() + { + return proxy_.getProperty("HandleHibernateKey").onInterface(INTERFACE_NAME); + } + + std::string HandleHibernateKeyLongPress() + { + return proxy_.getProperty("HandleHibernateKeyLongPress").onInterface(INTERFACE_NAME); + } + + std::string HandleLidSwitch() + { + return proxy_.getProperty("HandleLidSwitch").onInterface(INTERFACE_NAME); + } + + std::string HandleLidSwitchExternalPower() + { + return proxy_.getProperty("HandleLidSwitchExternalPower").onInterface(INTERFACE_NAME); + } + + std::string HandleLidSwitchDocked() + { + return proxy_.getProperty("HandleLidSwitchDocked").onInterface(INTERFACE_NAME); + } + + uint64_t HoldoffTimeoutUSec() + { + return proxy_.getProperty("HoldoffTimeoutUSec").onInterface(INTERFACE_NAME); + } + + std::string IdleAction() + { + return proxy_.getProperty("IdleAction").onInterface(INTERFACE_NAME); + } + + uint64_t IdleActionUSec() + { + return proxy_.getProperty("IdleActionUSec").onInterface(INTERFACE_NAME); + } + + bool PreparingForShutdown() + { + return proxy_.getProperty("PreparingForShutdown").onInterface(INTERFACE_NAME); + } + + bool PreparingForSleep() + { + return proxy_.getProperty("PreparingForSleep").onInterface(INTERFACE_NAME); + } + + sdbus::Struct ScheduledShutdown() + { + return proxy_.getProperty("ScheduledShutdown").onInterface(INTERFACE_NAME); + } + + bool Docked() + { + return proxy_.getProperty("Docked").onInterface(INTERFACE_NAME); + } + + bool LidClosed() + { + return proxy_.getProperty("LidClosed").onInterface(INTERFACE_NAME); + } + + bool OnExternalPower() + { + return proxy_.getProperty("OnExternalPower").onInterface(INTERFACE_NAME); + } + + bool RemoveIPC() + { + return proxy_.getProperty("RemoveIPC").onInterface(INTERFACE_NAME); + } + + uint64_t RuntimeDirectorySize() + { + return proxy_.getProperty("RuntimeDirectorySize").onInterface(INTERFACE_NAME); + } + + uint64_t RuntimeDirectoryInodesMax() + { + return proxy_.getProperty("RuntimeDirectoryInodesMax").onInterface(INTERFACE_NAME); + } + + uint64_t InhibitorsMax() + { + return proxy_.getProperty("InhibitorsMax").onInterface(INTERFACE_NAME); + } + + uint64_t NCurrentInhibitors() + { + return proxy_.getProperty("NCurrentInhibitors").onInterface(INTERFACE_NAME); + } + + uint64_t SessionsMax() + { + return proxy_.getProperty("SessionsMax").onInterface(INTERFACE_NAME); + } + + uint64_t NCurrentSessions() + { + return proxy_.getProperty("NCurrentSessions").onInterface(INTERFACE_NAME); + } + + uint64_t StopIdleSessionUSec() + { + return proxy_.getProperty("StopIdleSessionUSec").onInterface(INTERFACE_NAME); + } + +private: + sdbus::IProxy& proxy_; +}; + +}}} // namespaces + +#endif diff --git a/internal/platform/implementation/linux/org.freedesktop.login1.Manager.xml b/internal/platform/implementation/linux/org.freedesktop.login1.Manager.xml new file mode 100644 index 00000000..52417e27 --- /dev/null +++ b/internal/platform/implementation/linux/org.freedesktop.login1.Manager.xml @@ -0,0 +1,388 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +