mpris-notifier 0.1.0

Generates XDG desktop notifications for MPRIS status changes (track changes)
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

use rustbus::message_builder::MarshalledMessage;
use rustbus::DuplexConn;
use thiserror::Error;

#[derive(Debug, Error)]
pub enum DBusError {
    #[error("error connecting to D-Bus")]
    Connection(rustbus::connection::Error),

    #[error("Unexpected D-Bus message format")]
    Invalid(String),

    #[error("D-Bus generic error")]
    Generic(String),

    #[error("error unmarshalling D-Bus message")]
    Unmarshal(rustbus::wire::unmarshal::Error),

    #[error("error marshalling D-Bus message")]
    Marshal(rustbus::wire::marshal::Error),

    #[error("rustbus message error")]
    Message(rustbus::Error)
}

pub struct DBusConnection {
    connection: DuplexConn,
}

impl From<rustbus::connection::Error> for DBusError {
    fn from(err: rustbus::connection::Error) -> Self {
        DBusError::Connection(err)
    }
}

impl From<rustbus::wire::unmarshal::Error> for DBusError {
    fn from(err: rustbus::wire::unmarshal::Error) -> Self {
        DBusError::Unmarshal(err)
    }
}

impl From<rustbus::Error> for DBusError {
    fn from(err: rustbus::Error) -> Self {
        DBusError::Message(err)
    }
}



impl DBusConnection {
    pub fn new() -> Result<Self, DBusError> {
        let (connection, _) = Self::connect()?;
        Ok(Self { connection })
    }

    /// Blocks, awaiting the next signal from D-Bus, which is processed and
    /// returned. No-op messages (messages from which no useful result is
    /// derived) are silently acknowledged, and `next_message` will continue to
    /// block until a message that yields a result is received.
    pub fn next_signal(&mut self) -> Result<MarshalledMessage, DBusError> {
        use rustbus::{connection::Timeout, MessageType};

        loop {
            let message = self.connection.recv.get_next_message(Timeout::Infinite)?;
            match message.typ {
                MessageType::Signal => return Ok(message),
                MessageType::Error => {
                    let body = self.message_body_string(&message)?;
                    return Err(DBusError::Generic(body.to_string()));
                }
                MessageType::Invalid => {
                    let body = self.message_body_string(&message)?.to_string();
                    return Err(DBusError::Invalid(body));
                }
                _ => {}
            }
        }
    }

    pub fn send_message(&mut self, message: &MarshalledMessage) -> Result<(), DBusError> {
        self.connection
            .send
            .send_message_write_all(message)
            .map(|_| ())
            .map_err(DBusError::Connection)
    }

    fn message_body_string<'a>(
        &self,
        message: &'a MarshalledMessage,
    ) -> Result<&'a str, DBusError> {
        Ok(message.body.parser().get::<&str>()?)
    }

    fn connect() -> Result<(DuplexConn, String), DBusError> {
        use rustbus::{connection::Timeout, get_session_bus_path};

        let session_path = get_session_bus_path()?;
        let mut connection = DuplexConn::connect_to_bus(session_path, true)?;
        let connection_id = connection.send_hello(Timeout::Infinite)?;

        Ok((connection, connection_id))
    }

    pub fn subscribe(
        &mut self,
        interface: &str,
        member: &str,
        path: &str,
    ) -> Result<(), DBusError> {
        use rustbus::standard_messages::add_match;
        let match_str = format!(
            "interface='{}',member='{}',path='{}'",
            interface, member, path
        );
        self.connection
            .send
            .send_message_write_all(&add_match(&match_str))?;
        Ok(())
    }
}