rs-matter-stack 0.2.0

Utility for configuring and running rs-matter
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

use core::future::Future;

use rs_matter::error::Error;
use rs_matter::transport::network::btp::{AdvData, Btp};

#[cfg(all(feature = "os", target_os = "linux", feature = "bluer"))]
pub use bluer::*;
#[cfg(feature = "zbus")]
pub use bluez::*;

/// A trait modeling a platform-specific / BLE-stack specific GATT peripheral.
///
/// Running the peripheral means it would advertise the Matter BTP service
/// and then - once a peer connects - will drive the passed `Btp` instance
/// via write requests and indications to the Matter C1 and C2 characteristics.
pub trait GattPeripheral {
    /// Run the Matter GATT app
    ///
    /// # Arguments
    /// - `btp`: the BTP instance to drive with the GATT app
    /// - `service_name`: the name to advertise for the BTP service
    /// - `service_adv`: the advertisement data to use for the BTP service
    async fn run(
        &mut self,
        btp: &Btp,
        service_name: &str,
        service_adv: &AdvData,
    ) -> Result<(), Error>;
}

impl<T> GattPeripheral for &mut T
where
    T: GattPeripheral,
{
    fn run(
        &mut self,
        btp: &Btp,
        service_name: &str,
        service_adv: &AdvData,
    ) -> impl Future<Output = Result<(), Error>> {
        (*self).run(btp, service_name, service_adv)
    }
}

#[cfg(all(feature = "os", target_os = "linux", feature = "bluer"))]
#[allow(clippy::large_futures)]
mod bluer {
    use rs_matter::error::Error;
    use rs_matter::transport::network::btp::{AdvData, Btp};

    pub struct BluerGattPeripheral<'a>(Option<&'a str>);

    impl<'a> BluerGattPeripheral<'a> {
        /// Create a new `BluerGattPeripheral` that will use the Bluetooth adapter with the given name.
        /// If `adapter_name` is `None`, the default adapter will be used.
        pub const fn new(adapter_name: Option<&'a str>) -> Self {
            Self(adapter_name)
        }
    }

    impl super::GattPeripheral for BluerGattPeripheral<'_> {
        async fn run(
            &mut self,
            btp: &Btp,
            service_name: &str,
            service_adv: &AdvData,
        ) -> Result<(), Error> {
            rs_matter::transport::network::btp::bluer::run_peripheral(
                self.0,
                service_name,
                service_adv,
                btp,
            )
            .await
        }
    }
}

#[cfg(feature = "zbus")]
#[allow(clippy::large_futures)]
mod bluez {
    use rs_matter::error::Error;
    use rs_matter::transport::network::btp::{AdvData, Btp};
    use rs_matter::utils::zbus::Connection;

    pub struct BluezGattPeripheral<'a> {
        connection: &'a Connection,
        adapter_name: Option<&'a str>,
    }

    impl<'a> BluezGattPeripheral<'a> {
        /// Create a new `BluezGattPeripheral` that will use the Bluetooth adapter with the given name.
        /// If `adapter_name` is `None`, the default adapter will be used.
        pub const fn new(connection: &'a Connection, adapter_name: Option<&'a str>) -> Self {
            Self {
                connection,
                adapter_name,
            }
        }
    }

    impl super::GattPeripheral for BluezGattPeripheral<'_> {
        async fn run(
            &mut self,
            btp: &Btp,
            service_name: &str,
            service_adv: &AdvData,
        ) -> Result<(), Error> {
            rs_matter::transport::network::btp::bluez::run_peripheral(
                self.connection,
                self.adapter_name,
                service_name,
                service_adv,
                btp,
            )
            .await
        }
    }
}