roguauto 1.0.2

A lightweight power menu for Wayland compositors supporting wlr-layer-shell.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

// Copyright (C) 2026 ac5307
// SPDX-License-Identifier: GPL-3.0-or-later

use zbus::{proxy, Result as ZRslt, Connection};
use tokio::runtime::Handle;
use smithay_client_toolkit::reexports::calloop::channel::Sender;

use crate::{async_event::AppEvent};

#[proxy(
  interface = "org.freedesktop.login1.Session",
  default_service = "org.freedesktop.login1",
  default_path = "/org/freedesktop/login1/session/auto"
)]
trait Session {
  fn lock(&self) -> ZRslt<()>;
  fn terminate(&self) -> ZRslt<()>;
}

#[proxy(
  interface = "org.freedesktop.login1.Manager",
  default_service = "org.freedesktop.login1",
  default_path = "/org/freedesktop/login1"
)]
trait Manager {
  fn suspend(&self, interactive: bool) -> ZRslt<()>;
  fn hibernate(&self, interactive: bool) -> ZRslt<()>;
  fn reboot(&self, interactive: bool) -> ZRslt<()>;
  fn power_off(&self, interactive: bool) -> ZRslt<()>;
}

#[derive(Debug, Clone, Copy)]
pub enum PowerAction {
  Lock,
  Logout,
  Suspend,
  Hibernate,
  Reboot,
  Shutdown,
}

const _: () = assert!(!PowerAction::ALL.is_empty());

impl PowerAction {
  pub const ALL: [Self; 6] = [
    Self::Lock,
    Self::Logout,
    Self::Suspend,
    Self::Hibernate,
    Self::Reboot,
    Self::Shutdown,
  ];

  pub const fn label(self) -> &'static str {
    match self {
      Self::Lock => "Lock",
      Self::Logout => "Log out",
      Self::Suspend => "Suspend",
      Self::Hibernate => "Hibernate",
      Self::Reboot => "Reboot",
      Self::Shutdown => "Shut down",
    }
  }

  pub const fn icon(self) -> &'static [u8] {
    match self {
      Self::Lock => include_bytes!("../assets/icons/lock.svg"),
      Self::Logout => include_bytes!("../assets/icons/logout.svg"),
      Self::Suspend => include_bytes!("../assets/icons/suspend.svg"),
      Self::Hibernate => include_bytes!("../assets/icons/hibernate.svg"),
      Self::Reboot => include_bytes!("../assets/icons/reboot.svg"),
      Self::Shutdown => include_bytes!("../assets/icons/shutdown.svg"),
    }
  }
}

#[derive(Clone)]
#[repr(transparent)]
pub struct PowerConnection(Connection);

impl PowerConnection {
  pub async fn new() -> ZRslt<Self> {
    Ok(Self(Connection::system().await?))
  }

  pub async fn lock(&self) -> ZRslt<()> {
    let proxy = SessionProxy::new(&self.0).await?;
    proxy.lock().await
  }

  pub async fn logout(&self) -> ZRslt<()> {
    let proxy = SessionProxy::new(&self.0).await?;
    proxy.terminate().await
  }

  pub async fn suspend(&self) -> ZRslt<()> {
    let proxy = ManagerProxy::new(&self.0).await?;
    proxy.suspend(true).await
  }

  pub async fn hibernate(&self) -> ZRslt<()> {
    let proxy = ManagerProxy::new(&self.0).await?;
    proxy.hibernate(true).await
  }

  pub async fn reboot(&self) -> ZRslt<()> {
    let proxy = ManagerProxy::new(&self.0).await?;
    proxy.reboot(true).await
  }

  pub async fn shutdown(&self) -> ZRslt<()> {
    let proxy = ManagerProxy::new(&self.0).await?;
    proxy.power_off(true).await
  }
}

pub struct PowerHandler {
  pwr_conn: PowerConnection,
  runtime: Handle,
  sender: Sender<AppEvent>,
}

impl PowerHandler {
  pub async fn new(
    runtime: Handle,
    sender: Sender<AppEvent>,
  ) -> ZRslt<Self> {
    Ok(Self {
      pwr_conn: PowerConnection::new().await?,
      runtime,
      sender,
    })
  }

  pub fn execute(&self, action: PowerAction) {
    let pwr_conn = self.pwr_conn.clone();
    let sender = self.sender.clone();

    self.runtime.spawn(async move {
      let result = match action {
        PowerAction::Lock => pwr_conn.lock().await,
        PowerAction::Logout => pwr_conn.logout().await,
        PowerAction::Suspend => pwr_conn.suspend().await,
        PowerAction::Hibernate => pwr_conn.hibernate().await,
        PowerAction::Reboot => pwr_conn.reboot().await,
        PowerAction::Shutdown => pwr_conn.shutdown().await,
      }
      .map_err(|err| Box::from(err.to_string()));

      let _ = sender.send(AppEvent::PowerActionFinished { action, result });
    });
  }
}