bluez 0.4.0

Control Bluetooth on Linux.
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
135
136
137
138
139
140
141
142
143
144
145
146
147
148

//! Utilities and structures used in communicating with other Bluetooth devices.
//! This includes using L2CAP/RFCOMM directly via [`stream::BluetoothStream`],
//! or performing service discovery using [`discovery::ServiceDiscoveryClient`].

use std::fmt::Debug;

pub mod discovery;
pub mod stream;

pub use stream::*;

/// A unique ID. This can be 16, 32, or 128 bits.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Uuid {
    Uuid16(Uuid16),
    Uuid32(Uuid32),
    Uuid128(Uuid128),
}

impl From<u16> for Uuid {
    fn from(u: u16) -> Self {
        Self::Uuid16(u.into())
    }
}

impl From<u32> for Uuid {
    fn from(u: u32) -> Self {
        Self::Uuid32(u.into())
    }
}

impl From<u128> for Uuid {
    fn from(u: u128) -> Self {
        Self::Uuid128(u.into())
    }
}

impl From<Uuid16> for Uuid {
    fn from(u: Uuid16) -> Self {
        Self::Uuid16(u)
    }
}

impl From<Uuid32> for Uuid {
    fn from(u: Uuid32) -> Self {
        Self::Uuid32(u)
    }
}

impl From<Uuid128> for Uuid {
    fn from(u: Uuid128) -> Self {
        Self::Uuid128(u)
    }
}

/// A 16-bit unique ID.
#[derive(Clone, Copy, PartialEq, Eq)]
pub struct Uuid16(pub u16);

impl From<u16> for Uuid16 {
    fn from(u: u16) -> Self {
        Self(u)
    }
}

/// A 32-bit unique ID.
#[derive(Clone, Copy, PartialEq, Eq)]
pub struct Uuid32(pub u32);

impl From<u32> for Uuid32 {
    fn from(u: u32) -> Self {
        Self(u)
    }
}

/// A 128-bit unique ID.
#[derive(Clone, Copy, PartialEq, Eq)]
pub struct Uuid128(pub u128);

impl From<u16> for Uuid128 {
    fn from(u: u16) -> Self {
        Self::from(Uuid16::from(u))
    }
}

impl From<u32> for Uuid128 {
    fn from(u: u32) -> Self {
        Self::from(Uuid32::from(u))
    }
}

impl From<u128> for Uuid128 {
    fn from(u: u128) -> Self {
        Self(u)
    }
}

impl From<Uuid16> for Uuid32 {
    fn from(u: Uuid16) -> Self {
        Self(u.0 as u32)
    }
}

impl From<Uuid16> for Uuid128 {
    fn from(u: Uuid16) -> Self {
        Self((u.0 as u128) * BASE_UUID_FACTOR + BASE_UUID)
    }
}

impl From<Uuid32> for Uuid128 {
    fn from(u: Uuid32) -> Self {
        Self((u.0 as u128) * BASE_UUID_FACTOR + BASE_UUID)
    }
}

impl Debug for Uuid16 {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{:04x}", self.0)
    }
}

impl Debug for Uuid32 {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let bytes = u32::to_le_bytes(self.0);
        write!(
            f,
            "{:02x}{:02x}-{:02x}{:02x}",
            bytes[3], bytes[2], bytes[1], bytes[0]
        )
    }
}

impl Debug for Uuid128 {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let bytes = u128::to_le_bytes(self.0);
        write!(
            f,
            "{:02x}{:02x}{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}",
            bytes[15], bytes[14], bytes[13], bytes[12], bytes[11], bytes[10], bytes[9], bytes[8],
            bytes[7], bytes[6], bytes[5], bytes[4], bytes[3], bytes[2], bytes[1], bytes[0]
        )
    }
}

/// The base UUID that is used when converting from 16-bit and 32-bit UUIDs to 128-bit UUIDs.
pub const BASE_UUID: u128 = 0x00000000_0000_1000_8000_00805F9B34FB;

const BASE_UUID_FACTOR: u128 = 2 ^ 96;