open_ecc 0.0.3

Unofficial Elgato Command Centre API
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
105
106
107
108
109
110

use crate::{
    contracts::{
        AccessoryInfoGet, AccessoryInfoPut, LightsGet, LightsPut, LightsSettingsGet,
        LightsSettingsPut, Wifi,
    },
    helpers::encrypt_wifi_payload,
    serialization::deser_response,
};
use anyhow::Result;
use reqwest::{
    Client,
    header::{CONTENT_TYPE, HeaderValue},
};

pub struct Ecc {
    client: Client,
    protocol: &'static str,
    port: u16,
    namespace: String,
}

impl Default for Ecc {
    fn default() -> Self {
        Self {
            client: Client::new(),
            protocol: "http",
            port: 9123,
            namespace: "/elgato".to_string(),
        }
    }
}

impl Ecc {
    fn format_url(&self, endpoint: &str) -> String {
        format!(
            "{}://{}:{}{}",
            self.protocol, endpoint, self.port, self.namespace
        )
    }

    pub async fn wifi_put(&self, endpoint: &str, payload: &Wifi) -> Result<()> {
        let accessory_info = self.accessory_info_get(endpoint).await?;
        let encrypted_bytes = encrypt_wifi_payload(&accessory_info, payload)?;
        let url = format!("{}/wifi-info", self.format_url(endpoint));
        self.client
            .put(&url)
            .header(
                CONTENT_TYPE,
                HeaderValue::from_static("application/octet-stream"),
            )
            .body(encrypted_bytes)
            .send()
            .await?;
        Ok(())
    }

    pub async fn identify(&self, endpoint: &str) -> Result<()> {
        let url = format!("{}/identify", self.format_url(endpoint));
        self.client.post(&url).send().await?;
        Ok(())
    }

    pub async fn lights_get(&self, endpoint: &str) -> Result<LightsGet> {
        let url = format!("{}/lights", self.format_url(endpoint));
        let response = self.client.get(&url).send().await?;
        let result = deser_response::<LightsGet>(response).await?;
        Ok(result)
    }

    pub async fn lights_put(&self, endpoint: &str, payload: &LightsPut) -> Result<LightsGet> {
        let url = format!("{}/lights", self.format_url(endpoint));
        let response = self.client.put(&url).json(payload).send().await?;
        let result = deser_response::<LightsGet>(response).await?;
        Ok(result)
    }

    pub async fn lights_settings_get(&self, endpoint: &str) -> Result<LightsSettingsGet> {
        let url = format!("{}/lights/settings", self.format_url(endpoint));
        let response = self.client.get(&url).send().await?;
        let result = deser_response::<LightsSettingsGet>(response).await?;
        Ok(result)
    }

    pub async fn lights_settings_put(
        &self,
        endpoint: &str,
        payload: &LightsSettingsPut,
    ) -> Result<()> {
        let url = format!("{}/lights", self.format_url(endpoint));
        self.client.put(&url).json(payload).send().await?;
        Ok(())
    }

    pub async fn accessory_info_get(&self, endpoint: &str) -> Result<AccessoryInfoGet> {
        let url = format!("{}/accessory-info", self.format_url(endpoint));
        let response = self.client.get(&url).send().await?;
        let result = deser_response::<AccessoryInfoGet>(response).await?;
        Ok(result)
    }

    pub async fn accessory_info_put(
        &self,
        endpoint: &str,
        payload: &AccessoryInfoPut,
    ) -> Result<()> {
        let url = format!("{}/accessory-info", self.format_url(endpoint));
        self.client.put(&url).json(payload).send().await?;
        Ok(())
    }
}