bleak-rs 0.1.10

High-level BLE communication library
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

use std::time::Duration;
use uuid::Uuid;

#[derive(Debug, Clone, Hash, Eq, PartialEq)]
pub enum Filter {
    Address(String),
    Characteristic(Uuid),
    Name(String),
    Rssi(i16),
    Service(Uuid),
}

#[derive(Default)]
pub struct ScanConfig {
    /// Index of the Bluetooth adapter to use. The first found adapter is used by default.
    pub(crate) adapter_index: usize,
    /// Filters objects
    pub(crate) filters: Vec<Filter>,
    /// Filters the found devices based on device address.
    pub(crate) address_filter: Option<Box<dyn Fn(&str, &str) -> bool + Send + Sync>>,
    /// Filters the found devices based on local name.
    pub(crate) name_filter: Option<Box<dyn Fn(&str, &str) -> bool + Send + Sync>>,
    /// Filters the found devices based on rssi.
    pub(crate) rssi_filter: Option<Box<dyn Fn(i16, i16) -> bool + Send + Sync>>,
    /// Filters the found devices based on service's uuid.
    pub(crate) service_filter: Option<Box<dyn Fn(&Vec<Uuid>, &Uuid) -> bool + Send + Sync>>,
    /// Filters the found devices based on characteristics. Requires a connection to the device.
    pub(crate) characteristics_filter: Option<Box<dyn Fn(&Vec<Uuid>, &Uuid) -> bool + Send + Sync>>,
    /// Maximum results before the scan is stopped.
    pub(crate) max_results: Option<usize>,
    /// The scan is stopped when timeout duration is reached.
    pub(crate) timeout: Option<Duration>,
    /// Force disconnect when listen the device is connected.
    pub(crate) force_disconnect: bool,
}

impl ScanConfig {
    /// Index of bluetooth adapter to use
    #[inline]
    pub fn adapter_index(mut self, index: usize) -> Self {
        self.adapter_index = index;
        self
    }

    #[inline]
    pub fn with_filters(mut self, filters: &[Filter]) -> Self {
        self.filters.extend_from_slice(filters);
        self
    }

    /// Filter scanned devices based on the device address
    #[inline]
    pub fn filter_by_address(
        mut self,
        func: impl Fn(&str, &str) -> bool + Send + Sync + 'static,
    ) -> Self {
        self.address_filter = Some(Box::new(func));
        self
    }

    /// Filter scanned devices based on the device name
    #[inline]
    pub fn filter_by_name(
        mut self,
        func: impl Fn(&str, &str) -> bool + Send + Sync + 'static,
    ) -> Self {
        self.name_filter = Some(Box::new(func));
        self
    }

    #[inline]
    pub fn filter_by_rssi(
        mut self,
        func: impl Fn(i16, i16) -> bool + Send + Sync + 'static,
    ) -> Self {
        self.rssi_filter = Some(Box::new(func));
        self
    }

    #[inline]
    pub fn filter_by_service(
        mut self,
        func: impl Fn(&Vec<Uuid>, &Uuid) -> bool + Send + Sync + 'static,
    ) -> Self {
        self.service_filter = Some(Box::new(func));
        self
    }

    /// Filter scanned devices based on available characteristics
    #[inline]
    pub fn filter_by_characteristics(
        mut self,
        func: impl Fn(&Vec<Uuid>, &Uuid) -> bool + Send + Sync + 'static,
    ) -> Self {
        self.characteristics_filter = Some(Box::new(func));
        self
    }

    /// Stop the scan after given number of matches
    #[inline]
    pub fn stop_after_matches(mut self, max_results: usize) -> Self {
        self.max_results = Some(max_results);
        self
    }

    /// Stop the scan after the first match
    #[inline]
    pub fn stop_after_first_match(self) -> Self {
        self.stop_after_matches(1)
    }

    /// Stop the scan after given duration
    #[inline]
    pub fn stop_after_timeout(mut self, timeout: Duration) -> Self {
        self.timeout = Some(timeout);
        self
    }

    #[inline]
    pub fn force_disconnect(mut self, force_disconnect: bool) -> Self {
        self.force_disconnect = force_disconnect;
        self
    }

    /// Require that the scanned devices have a name
    #[inline]
    pub fn require_name(self) -> Self {
        if self.name_filter.is_none() {
            self.filter_by_name(|src, _| !src.is_empty())
        } else {
            self
        }
    }
}