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

use std::ffi::CString;

use bytes::*;

pub use advertising::*;
pub use class::*;
pub use discovery::*;
pub use interact::*;
pub use load::*;
pub use oob::*;
pub use params::*;
pub use query::*;
pub use settings::*;

use tokio::sync::mpsc;

use crate::management::interface::*;
use crate::management::stream::ManagementStream;
use crate::management::{Error, Result};
use crate::Address;

mod advertising;
mod class;
mod discovery;
mod interact;
mod load;
mod oob;
mod params;
mod query;
mod settings;

async fn exec_command(
    socket: &mut ManagementStream,
    opcode: Command,
    controller: Controller,
    param: Option<Bytes>,
    mut event_tx: Option<mpsc::Sender<Response>>,
) -> Result<(Controller, Option<Bytes>)> {
    let param = param.unwrap_or(Bytes::new());

    // send request
    socket
        .send(Request {
            opcode,
            controller,
            param,
        })
        .await?;

    // loop until we receive a relevant response
    // which is either command complete or command status
    // with the same opcode as the command that we sent
    loop {
        let response = socket.receive().await?;

        match response.event {
            Event::CommandComplete {
                status,
                param,
                opcode: evt_opcode,
            } if opcode == evt_opcode => {
                return match status {
                    CommandStatus::Success => Ok((response.controller, Some(param))),
                    _ => Err(Error::CommandError { opcode, status }),
                }
            }

            Event::CommandStatus {
                status,
                opcode: evt_opcode,
            } if opcode == evt_opcode => {
                return match status {
                    CommandStatus::Success => Ok((response.controller, None)),
                    _ => Err(Error::CommandError { opcode, status }),
                }
            }

            _ => {
                if let Some(event_tx) = &mut event_tx {
                    let _ = event_tx.send(response).await;
                }
            }
        }
    }
}