bluer 0.17.4

BlueR: official Rust interface to the Linux Bluetooth protocol stack (BlueZ)
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

//! Implements Node bluetooth mesh interface

use dbus::{
    arg::{RefArg, Variant},
    nonblock::{Proxy, SyncConnection},
    Path,
};
use std::{collections::HashMap, sync::Arc};

use super::{
    application::ApplicationInner,
    element::{ElementConfigs, ElementRef},
};
use crate::{
    mesh::{management::Management, SERVICE_NAME, TIMEOUT},
    Result, SessionInner,
};

pub(crate) const INTERFACE: &str = "org.bluez.mesh.Node1";

/// Interface to a Bluetooth mesh node.
#[derive(Clone)]
pub struct Node {
    inner: Arc<SessionInner>,
    app_inner: Arc<ApplicationInner>,
    path: Path<'static>,
    // TODO: translate element_config into proper Rust type
    _element_config: Arc<ElementConfigs>,
}

impl Node {
    pub(crate) async fn new(
        inner: Arc<SessionInner>, app_inner: Arc<ApplicationInner>, path: Path<'static>,
        element_config: ElementConfigs,
    ) -> Result<Self> {
        Ok(Self { inner, app_inner, path, _element_config: Arc::new(element_config) })
    }

    /// Management interface for the node.
    pub fn management(&self) -> Management {
        Management::new(self.inner.clone(), self.app_inner.clone(), self.path.clone())
    }

    /// Send a publication originated by a local model.
    ///
    /// Since only one Publish record may exist per element-model, the
    /// destination and key_index are obtained from the Publication
    /// record cached by the daemon.
    pub async fn publish(&self, element_ref: &ElementRef, model_id: u16, data: &[u8]) -> Result<()> {
        let path = element_ref.path()?;
        let options: HashMap<&'static str, Variant<Box<dyn RefArg>>> = HashMap::new();

        log::trace!(
            "Publishing message: path={:?} model_id={:?} options={:?} data={:?}",
            &path,
            model_id,
            &options,
            data
        );
        let () = self.call_method("Publish", (path, model_id, options, data.to_vec())).await?;

        Ok(())
    }

    /// Send a message originated by a local model.
    pub async fn send(
        &self, element_ref: &ElementRef, destination: u16, key_index: u16, data: &[u8],
    ) -> Result<()> {
        let path = element_ref.path()?;
        let options: HashMap<&'static str, Variant<Box<dyn RefArg>>> = HashMap::new();

        log::trace!(
            "Sending message: path={:?} destination={:?} key_index={:?} options={:?} data={:?}",
            &path,
            destination,
            key_index,
            &options,
            data
        );
        let () = self.call_method("Send", (path, destination, key_index, options, data.to_vec())).await?;

        Ok(())
    }

    /// Send a message originated by a local model encoded with the device key of the remote node.
    pub async fn dev_key_send(
        &self, element_ref: &ElementRef, destination: u16, remote: bool, net_index: u16, data: &[u8],
    ) -> Result<()> {
        let path = element_ref.path()?;
        let options: HashMap<&'static str, Variant<Box<dyn RefArg>>> = HashMap::new();

        log::trace!(
            "Sending device key encoded message: path={:?} destination={:?} remote={:?} net_index={:?} options={:?} \
            data={:?}",
            &path,
            destination,
            remote,
            net_index,
            &options,
            data
        );
        let () = self
            .call_method("DevKeySend", (path, destination, remote, net_index, options, data.to_vec()))
            .await?;

        Ok(())
    }

    /// Send add or update network key originated by the local configuration client to a remote configuration server.
    pub async fn add_app_key(
        &self, element_ref: &ElementRef, destination: u16, app_key: u16, net_index: u16, update: bool,
    ) -> Result<()> {
        let path = element_ref.path()?;

        log::trace!(
            "Adding app key: path={:?} destination={:?} app_key={:?} net_index={:?} update={:?}",
            path,
            destination,
            app_key,
            net_index,
            update
        );
        let () = self.call_method("AddAppKey", (path, destination, app_key, net_index, update)).await?;

        Ok(())
    }

    fn proxy(&self) -> Proxy<'_, &SyncConnection> {
        Proxy::new(SERVICE_NAME, self.path.clone(), TIMEOUT, &*self.inner.connection)
    }

    dbus_interface!();
    dbus_default_interface!(INTERFACE);
}