quickgui 0.1.5

A damage-driven, GPU-accelerated desktop GUI foundation
Documentation
use std::{
    sync::mpsc,
    thread::{self, JoinHandle},
};

use winit::event_loop::EventLoopProxy;
use zbus::{
    MatchRule,
    blocking::{Connection, MessageIterator, Proxy},
    message::Type,
    zvariant::OwnedObjectPath,
};

use super::{PowerEvent, RuntimeEvent};

pub(crate) struct LinuxPowerMonitor {
    sleep_connection: Option<Connection>,
    sleep_thread: Option<JoinHandle<()>>,
    session_connection: Option<Connection>,
    session_thread: Option<JoinHandle<()>>,
}

impl LinuxPowerMonitor {
    pub(crate) fn start(proxy: EventLoopProxy<RuntimeEvent>) -> Result<Self, String> {
        let connection = Connection::system().map_err(|error| error.to_string())?;
        let thread_connection = connection.clone();
        let (sender, receiver) = mpsc::sync_channel(1);
        let sleep_proxy = proxy.clone();
        let thread = thread::Builder::new()
            .name("quickgui-power-monitor".to_owned())
            .spawn(move || monitor_logind(thread_connection, sleep_proxy, sender))
            .map_err(|error| error.to_string())?;
        let (sleep_connection, sleep_thread) = match receiver.recv() {
            Ok(Ok(())) => (connection, thread),
            Ok(Err(error)) => {
                let _ = connection.close();
                let _ = thread.join();
                return Err(error);
            }
            Err(error) => {
                let _ = connection.close();
                let _ = thread.join();
                return Err(error.to_string());
            }
        };

        let (session_connection, session_thread) = match start_session_monitor(proxy) {
            Ok((connection, thread)) => (Some(connection), Some(thread)),
            Err(error) => {
                tracing::warn!(%error, "Linux session lock monitoring is unavailable");
                (None, None)
            }
        };
        Ok(Self {
            sleep_connection: Some(sleep_connection),
            sleep_thread: Some(sleep_thread),
            session_connection,
            session_thread,
        })
    }
}

fn start_session_monitor(
    proxy: EventLoopProxy<RuntimeEvent>,
) -> Result<(Connection, JoinHandle<()>), String> {
    let connection = Connection::system().map_err(|error| error.to_string())?;
    let thread_connection = connection.clone();
    let (sender, receiver) = mpsc::sync_channel(1);
    let thread = thread::Builder::new()
        .name("quickgui-session-monitor".to_owned())
        .spawn(move || monitor_logind_session(thread_connection, proxy, sender))
        .map_err(|error| error.to_string())?;
    match receiver.recv() {
        Ok(Ok(())) => Ok((connection, thread)),
        Ok(Err(error)) => {
            let _ = connection.close();
            let _ = thread.join();
            Err(error)
        }
        Err(error) => {
            let _ = connection.close();
            let _ = thread.join();
            Err(error.to_string())
        }
    }
}

impl Drop for LinuxPowerMonitor {
    fn drop(&mut self) {
        if let Some(connection) = self.sleep_connection.take() {
            let _ = connection.close();
        }
        if let Some(connection) = self.session_connection.take() {
            let _ = connection.close();
        }
        if let Some(thread) = self.sleep_thread.take() {
            let _ = thread.join();
        }
        if let Some(thread) = self.session_thread.take() {
            let _ = thread.join();
        }
    }
}

fn monitor_logind(
    connection: Connection,
    event_proxy: EventLoopProxy<RuntimeEvent>,
    ready: mpsc::SyncSender<Result<(), String>>,
) {
    let rule = match MatchRule::builder()
        .msg_type(Type::Signal)
        .sender("org.freedesktop.login1")
        .and_then(|builder| builder.interface("org.freedesktop.login1.Manager"))
        .and_then(|builder| builder.path("/org/freedesktop/login1"))
    {
        Ok(builder) => builder.build(),
        Err(error) => {
            let _ = ready.send(Err(error.to_string()));
            return;
        }
    };
    let mut signals = match MessageIterator::for_match_rule(rule, &connection, Some(16)) {
        Ok(signals) => signals,
        Err(error) => {
            let _ = ready.send(Err(error.to_string()));
            return;
        }
    };
    if ready.send(Ok(())).is_err() {
        return;
    }
    let mut suspended = false;
    for message in &mut signals {
        let Ok(message) = message else {
            break;
        };
        let header = message.header();
        let member = header.member().map(|member| member.as_str());
        let Ok(value) = message.body().deserialize::<bool>() else {
            continue;
        };
        let event = match member {
            Some("PrepareForSleep") if value && !suspended => {
                suspended = true;
                Some(PowerEvent::Suspend)
            }
            Some("PrepareForSleep") if !value && suspended => {
                suspended = false;
                Some(PowerEvent::Resume)
            }
            Some("PrepareForShutdown") if value => Some(PowerEvent::ShutdownRequested),
            _ => None,
        };
        if let Some(event) = event
            && event_proxy.send_event(RuntimeEvent::Power(event)).is_err()
        {
            break;
        }
    }
}

fn monitor_logind_session(
    connection: Connection,
    event_proxy: EventLoopProxy<RuntimeEvent>,
    ready: mpsc::SyncSender<Result<(), String>>,
) {
    let manager = match Proxy::new(
        &connection,
        "org.freedesktop.login1",
        "/org/freedesktop/login1",
        "org.freedesktop.login1.Manager",
    ) {
        Ok(manager) => manager,
        Err(error) => {
            let _ = ready.send(Err(error.to_string()));
            return;
        }
    };
    let session_path: OwnedObjectPath =
        match manager.call("GetSessionByPID", &(std::process::id(),)) {
            Ok(path) => path,
            Err(error) => {
                let _ = ready.send(Err(error.to_string()));
                return;
            }
        };
    let rule = match MatchRule::builder()
        .msg_type(Type::Signal)
        .sender("org.freedesktop.login1")
        .and_then(|builder| builder.interface("org.freedesktop.login1.Session"))
        .and_then(|builder| builder.path(session_path))
    {
        Ok(builder) => builder.build(),
        Err(error) => {
            let _ = ready.send(Err(error.to_string()));
            return;
        }
    };
    let mut signals = match MessageIterator::for_match_rule(rule, &connection, Some(16)) {
        Ok(signals) => signals,
        Err(error) => {
            let _ = ready.send(Err(error.to_string()));
            return;
        }
    };
    if ready.send(Ok(())).is_err() {
        return;
    }
    let mut locked = false;
    for message in &mut signals {
        let Ok(message) = message else {
            break;
        };
        let event = match message.header().member().map(|member| member.as_str()) {
            Some("Lock") if !locked => {
                locked = true;
                Some(PowerEvent::LockScreen)
            }
            Some("Unlock") if locked => {
                locked = false;
                Some(PowerEvent::UnlockScreen)
            }
            _ => None,
        };
        if let Some(event) = event
            && event_proxy.send_event(RuntimeEvent::Power(event)).is_err()
        {
            break;
        }
    }
}