remote-id 0.1.2

Remote ID Implementation as Specified in ASTM F3411 - 22a
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

#![cfg(feature = "linux")]

use bluer::{DeviceEvent, DeviceProperty, DiscoveryFilter};
use futures::stream::StreamExt;
use remote_id::codec::decode;
use uuid::Uuid;

const REMOTE_ID_SERVICE_UUID: Uuid = Uuid::from_u128(remote_id::REMOTE_ID_SERVICE_UUID);

/// Receive Example Using bluer
///
/// Will scan for bluetooth devices and listen to their broadcast messages,
/// printing parsable remote id messages
#[tokio::main]
async fn main() {
    let session = bluer::Session::new()
        .await
        .expect("failed to initiate bluetooth session");

    let adapter = session
        .adapter("hci0")
        .expect("failed to find bluetooth adapter");

    adapter
        .set_powered(true)
        .await
        .expect("failed to power bluetooth device");

    println!("ADAPTER NAME:    {}", adapter.name());
    println!(
        "ADAPTER ADDRESS: {}",
        adapter
            .address()
            .await
            .expect("failed to get device address")
    );

    adapter
        .set_discovery_filter(DiscoveryFilter {
            // required to receive service data
            duplicate_data: true,
            ..Default::default()
        })
        .await
        .expect("failed to set discovery filter");

    let mut discovery = adapter
        .discover_devices()
        .await
        .expect("failed to start device discovery session");
    println!("Scanning for BLE advertisements...\n");

    while let Some(event_result) = discovery.next().await {
        if let bluer::AdapterEvent::DeviceAdded(address) = event_result {
            if let Ok(device) = adapter.device(address) {
                println!("Device Discovered: {} {:?}", address, device.alias().await);
                tokio::spawn(handle_device(device));
            }
        }
    }
}

async fn handle_device(device: bluer::Device) {
    let mut events = device.events().await.expect("failed to get events");
    let mac_addr = device.address();
    while let Some(ev) = events.next().await {
        if let DeviceEvent::PropertyChanged(DeviceProperty::ServiceData(service_data)) = ev {
            if let Some(service_data) = service_data.get(&REMOTE_ID_SERVICE_UUID) {
                if let Some(rid_msg) = decode::from_service_data(&service_data) {
                    println!("{mac_addr}: {rid_msg:?}");
                }
            }
        }
    }
}