iwdrs 0.2.7

Rust crate for iwd
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 std::collections::HashMap;
use zvariant::{OwnedObjectPath, Value};

use zbus::{Connection, Proxy};

use crate::{
    error::{
        Result as IWDResult,
        access_point::{AccessPointStartError, AccessPointStopError, ScanError, StartProfileError},
    },
    iwd_interface::iwd_interface_impl,
};

iwd_interface_impl!(AccessPoint, "net.connman.iwd.AccessPoint");

impl AccessPoint {
    // Methods
    pub async fn start(&self, ssid: &str, psk: &str) -> IWDResult<(), AccessPointStartError> {
        self.proxy.call_method("Start", &(ssid, psk)).await?;
        Ok(())
    }

    pub async fn stop(&self) -> IWDResult<(), AccessPointStopError> {
        self.proxy.call_method("Stop", &()).await?;
        Ok(())
    }

    pub async fn start_profile(&self, ssid: &str) -> IWDResult<(), StartProfileError> {
        self.proxy.call_method("StartProfile", &(ssid)).await?;
        Ok(())
    }

    pub async fn scan(&self) -> IWDResult<(), ScanError> {
        self.proxy.call_method("Scan", &()).await?;
        Ok(())
    }

    pub async fn networks(&self) -> zbus::Result<Vec<HashMap<String, String>>> {
        let networks = self.proxy.call_method("GetOrderedNetworks", &()).await?;
        let body = networks.body();
        let body: Vec<HashMap<String, Value>> = body.deserialize()?;
        let body = body
            .into_iter()
            .map(|map| {
                map.into_iter()
                    .map(|(k, v)| (k, v.to_string()))
                    .collect::<HashMap<String, String>>()
            })
            .collect::<Vec<HashMap<String, String>>>();

        Ok(body)
    }

    // Proprieties
    pub async fn has_started(&self) -> zbus::Result<bool> {
        let has_started: bool = self.proxy.get_property("Started").await?;
        Ok(has_started)
    }

    pub async fn frequency(&self) -> zbus::Result<Option<u32>> {
        Ok(self.proxy.get_property("Frequency").await.ok())
    }

    pub async fn is_scanning(&self) -> zbus::Result<bool> {
        let is_scanning: bool = self.proxy.get_property("Scanning").await?;
        Ok(is_scanning)
    }

    pub async fn name(&self) -> zbus::Result<Option<String>> {
        Ok(self.proxy.get_property("Name").await.ok())
    }

    pub async fn pairwise_ciphers(&self) -> zbus::Result<Option<Vec<String>>> {
        Ok(self.proxy.get_property("PairwiseCiphers").await.ok())
    }

    pub async fn group_cipher(&self) -> zbus::Result<Option<String>> {
        Ok(self.proxy.get_property("GroupCipher").await.ok())
    }
}

iwd_interface_impl!(
    AccessPointDiagnostics,
    "net.connman.iwd.AccessPointDiagnostic"
);

impl AccessPointDiagnostics {
    pub async fn get(&self) -> zbus::Result<Vec<HashMap<String, String>>> {
        let diagnostic = self.proxy.call_method("GetDiagnostics", &()).await?;

        let body = diagnostic.body();
        let body: Vec<HashMap<String, Value>> = body.deserialize()?;
        let body = body
            .into_iter()
            .map(|map| {
                map.into_iter()
                    .map(|(k, v)| (k, v.to_string()))
                    .collect::<HashMap<String, String>>()
            })
            .collect::<Vec<HashMap<String, String>>>();

        Ok(body)
    }
}