Refresh lid observations before rendering after resume

compositor/src/resume.rs

@@ -0,0 +1,57 @@
+//! System wake is shared by hardware reconciliation and time-dependent UI state.
+use std::error::Error;
+use std::time::Duration;
+
+use calloop::EventLoop;
+use calloop::channel::{Event, channel};
+
+use crate::Ferese;
+
+pub(crate) fn init(event_loop: &mut EventLoop<Ferese>) -> Result<(), Box<dyn Error>> {
+    let (sender, receiver) = channel();
+    event_loop.handle().insert_source(receiver, |event, _, state| {
+        if let Event::Msg(()) = event {
+            crate::backends::direct::system_resumed(state);
+            state.refresh_theme();
+        }
+    })?;
+
+    std::thread::Builder::new()
+        .name("ferese-system-resume".into())
+        .spawn(move || {
+            let mut warned = false;
+            loop {
+                let monitor = || -> zbus::Result<bool> {
+                    let connection = zbus::blocking::connection::Builder::system()?
+                        .method_timeout(Duration::from_secs(2))
+                        .build()?;
+                    let proxy = zbus::blocking::Proxy::new(
+                        &connection,
+                        "org.freedesktop.login1",
+                        "/org/freedesktop/login1",
+                        "org.freedesktop.login1.Manager",
+                    )?;
+                    for message in proxy.receive_signal("PrepareForSleep")? {
+                        let (sleeping,): (bool,) = message.body().deserialize()?;
+                        if !sleeping && sender.send(()).is_err() {
+                            return Ok(false);
+                        }
+                    }
+                    Ok(true)
+                };
+
+                match monitor() {
+                    Ok(false) => break,
+                    Ok(true) => warned = false,
+                    Err(error) if !warned => {
+                        tracing::warn!(%error, "system resume monitor unavailable; retrying connection");
+                        warned = true;
+                    }
+                    Err(_) => {}
+                }
+                // Recovery only: a healthy listener blocks on DBus signals.
+                std::thread::sleep(Duration::from_secs(5));
+            }
+        })?;
+    Ok(())
+}