rainmaker-components 0.1.0

Component abstractions for rainmaker
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

use std::cell::Cell;

use uuid::Uuid;

use crate::{
    ble::{ApplicationHandle, Characteristic, Descriptor, GattApplication, Service},
    protocomm::{protocomm_req_handler, ProtocommCallbackType},
    utils::wrap_in_arc_mutex,
};

const USER_CHARACTERISTIC_DESCRIPTOR: u128 = 0x290100001000800000805f9b34fb;

#[derive(Default)]
pub(crate) struct TransportGatt {
    app_handle: Option<ApplicationHandle>,
    characteristics: Cell<Vec<Characteristic>>,
    service_uuid: Uuid,
}

impl TransportGatt {
    pub(crate) fn new(service_uuid: Uuid) -> Self {
        Self {
            service_uuid,
            ..Default::default()
        }
    }

    pub(crate) fn add_endpoint(
        &mut self,
        uuid: Uuid,
        ep_name: &str,
        cb: ProtocommCallbackType,
        ep_type: crate::protocomm::EndpointType,
        sec: std::sync::Arc<crate::protocomm::ProtocommSecurity>,
    ) {
        let ep_name = ep_name.to_string();
        let ep_name_2 = ep_name.clone();
        let value_mutex = wrap_in_arc_mutex(vec![]);
        let value_mutex_2 = value_mutex.clone();
        let new_characteristic = Characteristic {
            uuid,
            read: Some(Box::new(move || {
                let val = value_mutex.lock().unwrap();
                protocomm_req_handler(&ep_name, &val, &cb, &ep_type, &sec)
            })),
            write: Some(Box::new(move |data| {
                let mut val = value_mutex_2.lock().unwrap();
                *val = data;
            })),
            descriptors: vec![Descriptor {
                uuid: Uuid::from_u128(USER_CHARACTERISTIC_DESCRIPTOR),
                value: ep_name_2.into(),
            }],
        };

        let chrs = self.characteristics.get_mut();
        chrs.push(new_characteristic);
    }

    pub(crate) fn start(&mut self) {
        let app = GattApplication {
            services: vec![Service {
                uuid: self.service_uuid,
                primary: true,
                characteristics: self.characteristics.take(), // will work but not desirable
            }],
        };

        self.app_handle = Some(app.serve().unwrap());
    }
}