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
135
136
137
138
139
140
141
142
143
144
145

//! Safe wrapper around [Core Bluetooth framework](https://developer.apple.com/documentation/corebluetooth)
//! used to communicate with Bluetooth-equipped low energy (LE) and Basic Rate / Enhanced Data Rate
//! (BR/EDR) wireless technology.
//!
//! The API closely resembles to the native API with some changes for consistency sake.
//! The main difference is that this API lacks most of the functions for accessing retained
//! state, for thread-safety reasons. If needed users can maintain the retained state via
//! information from events.
//!
//! # Central role
//!
//! Central role is when application acts as "central" and initiates discovery of and connections
//! to peripherals. The [`central`](central/index.html) package contains all the needed objects for
//! central role.
//!
//! ## Example
//!
//! The following example shows how to discover peripherals, services and characteristics,
//! connect to peripherals and subscribe to characteristics.
//!
//! ```no_run
//! use core_bluetooth::*;
//! use core_bluetooth::central::*;
//!
//! let (central, receiver) = CentralManager::new();
//!
//! let handle_event = |event| {
//!     match event {
//!         CentralEvent::ManagerStateChanged { new_state } => {
//!             match new_state {
//!                 // Must be in PoweredOn state.
//!                 ManagerState::PoweredOn => central.scan(),
//!                 _ => panic!("no bluetooth available"),
//!             }
//!         }
//!         CentralEvent::PeripheralDiscovered { peripheral, advertisement_data, .. } => {
//!             if advertisement_data.is_connectable() != Some(false) {
//!                 central.connect(&peripheral);
//!             }
//!         }
//!         CentralEvent::PeripheralConnected { peripheral } => {
//!             peripheral.discover_services_with_uuids(&[
//!                 "ebe0ccb0-7a0a-4b0c-8a1a-6ff2997da3a6".parse().unwrap()]);
//!         }
//!         CentralEvent::ServicesDiscovered { peripheral, services } => {
//!             if let Ok(services) = services {
//!                 for service in services {
//!                     peripheral.discover_characteristics_with_uuids(&service, &[
//!                         "ebe0ccc1-7a0a-4b0c-8a1a-6ff2997da3a6".parse().unwrap()]);
//!                 }
//!             }
//!         }
//!         CentralEvent::CharacteristicsDiscovered { peripheral, characteristics, .. } => {
//!             if let Ok(chars) = characteristics {
//!                 peripheral.subscribe(&chars[0]);
//!             }
//!         }
//!         CentralEvent::CharacteristicValue { peripheral, value, .. } => {
//!             if let Ok(value) = value {
//!                 // Decode the value.
//!                 // In this example the value comes from a Xiaomi temperature sensor.
//!                 let t = i16::from_le_bytes([value[0], value[1]]) as f64 / 100.0;
//!                 let rh = value[2];
//!                 println!("t = {} C, rh = {}%", t, rh);
//!             }
//!         }
//!         _ => {}
//!     }
//! };
#![cfg_attr(not(feature = "async_std_unstable"), doc =r#"
while let Ok(event) = receiver.recv() {
    handle_event(event);
}
"#)]
#![cfg_attr(feature = "async_std_unstable", doc =r#"
async_std::task::block_on(async move {
    while let Some(event) = receiver.recv().await {
        handle_event(event);
    }
})
"#)]
//! ```
//!
//! You can find more examples in the `examples` directory.
#![deny(dead_code)]
#![deny(non_snake_case)]
#![deny(unused_imports)]
#![deny(unused_must_use)]

#[macro_use]
mod macros;

pub mod central;
pub mod error;
mod platform;
mod sync;
pub mod uuid;
mod util;

use static_assertions::*;

pub use sync::Receiver;

/// Arbitrary data to associate with asynchronous API call.
pub type Tag = Box<dyn std::any::Any + Send>;

assert_impl_all!(Tag: Send);
assert_not_impl_any!(Tag: Sync);

/// The possible states of a Core Bluetooth manager.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[non_exhaustive]
pub enum ManagerState {
    /// The manager’s state is unknown.
    Unknown = 0,

    /// A state that indicates the connection with the system service was momentarily lost.
    Resetting = 1,

    /// A state that indicates this device doesn’t support the Bluetooth low energy central or client role.
    Unsupported = 2,

    /// A state that indicates the application isn’t authorized to use the Bluetooth low energy role.
    Unauthorized = 3,

    /// A state that indicates Bluetooth is currently powered off.
    PoweredOff = 4,

    /// A state that indicates Bluetooth is currently powered on and available to use.
    PoweredOn = 5,
}

impl ManagerState {
    fn from_u8(v: u8) -> Option<Self> {
        Some(match v {
            0 => Self::Unknown,
            1 => Self::Resetting,
            2 => Self::Unsupported,
            3 => Self::Unauthorized,
            4 => Self::PoweredOff,
            5 => Self::PoweredOn,
            _ => return None,
        })
    }
}