openrazer 0.1.0

Asynchronous bindings to the OpenRazer daemon.
Documentation 
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

use crate::{
    devices::{Device, GenericDevice},
    Error,
};
use dbus_async::DBus;
use dbus_message_parser::{Message, Value};
use std::{collections::HashMap, io};

mod sync_effects;
mod turn_off_on_screensaver;

pub use sync_effects::SyncEffects;
pub use turn_off_on_screensaver::TurnOffOnScreensaver;

const PATH: &str = "/org/razer";
const DAEMON_INTERFACE: &str = "razer.daemon";
const DEVICES_INTERFACE: &str = "razer.devices";

/// Manages Razer devices.
#[derive(Debug)]
pub struct DeviceManager {
    dbus: DBus,
}

fn daemon_message(method: &'static str) -> Message {
    Message::method_call(crate::DESTINATION, PATH, DAEMON_INTERFACE, method)
}

fn devices_message(method: &'static str) -> Message {
    Message::method_call(crate::DESTINATION, PATH, DEVICES_INTERFACE, method)
}

impl DeviceManager {
    /// Constructs a `DeviceManager`.
    pub async fn new() -> io::Result<Self> {
        let (dbus, _) = DBus::session(true).await?;

        Ok(Self { dbus })
    }

    /// Fetches the daemon's version.
    pub async fn daemon_version(&self) -> Result<String, Error> {
        let (_, body) = self.dbus.call(daemon_message("version")).await?.split();

        match body.into_iter().next() {
            Some(Value::String(version)) => Ok(version),
            _ => Err(Error::InvalidResponse),
        }
    }

    /// Stops the daemon.
    pub async fn stop_daemon(&self) -> Result<(), Error> {
        self.dbus.call(daemon_message("stop")).await?;
        Ok(())
    }

    /// Fetches supported devices.
    pub async fn supported_devices(&self) -> Result<HashMap<String, [u16; 2]>, Error> {
        let response = self.dbus.call(devices_message("supportedDevices")).await?;

        match response.get_body() {
            [Value::String(json)] => serde_json::from_str(json).or(Err(Error::InvalidResponse)),
            _ => Err(Error::InvalidResponse),
        }
    }

    /// Fetches connected devices.
    pub async fn devices(&self) -> Result<Vec<Device>, Error> {
        let (_, body) = self.dbus.call(devices_message("getDevices")).await?.split();

        let serials = match body.into_iter().next() {
            Some(Value::Array(serials, _)) => serials,
            _ => return Err(Error::InvalidResponse),
        };

        let mut devices = Vec::new();

        for serial in serials {
            let serial = match serial {
                Value::String(serial) => serial,
                _ => return Err(Error::InvalidResponse),
            };

            let generic = GenericDevice::new(self.dbus.clone(), serial).await?;
            devices.push(generic.into_device().await?);
        }

        Ok(devices)
    }

    /// Controls whether devices' lighting is disabled on lockscreen.
    pub fn turn_off_on_screensaver(&self) -> TurnOffOnScreensaver {
        TurnOffOnScreensaver {
            dbus: self.dbus.clone(),
        }
    }

    /// Conrols whether applied effects are synchronized across all devices.
    pub fn sync_effects(&self) -> SyncEffects {
        SyncEffects {
            dbus: self.dbus.clone(),
        }
    }
}