pub struct Session { /* private fields */ }
bluetoothd
only.Expand description
Bluetooth session.
Encapsulates a connection to the system Bluetooth daemon.
Implementations
sourceimpl Session
impl Session
sourcepub async fn new() -> Result<Self>
pub async fn new() -> Result<Self>
Create a new Bluetooth session.
This establishes a connection to the system Bluetooth daemon over D-Bus.
Examples found in repository
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
fn main() -> bluer::Result<()> {
env_logger::init();
let session = bluer::Session::new().await?;
let adapter = session.default_adapter().await?;
adapter.set_powered(true).await?;
println!("Advertising on Bluetooth adapter {} with address {}", adapter.name(), adapter.address().await?);
let le_advertisement = Advertisement {
advertisement_type: bluer::adv::Type::Peripheral,
service_uuids: vec!["123e4567-e89b-12d3-a456-426614174000".parse().unwrap()].into_iter().collect(),
discoverable: Some(true),
local_name: Some("le_advertise".to_string()),
..Default::default()
};
println!("{:?}", &le_advertisement);
let handle = adapter.advertise(le_advertisement).await?;
println!("Press enter to quit");
let stdin = BufReader::new(tokio::io::stdin());
let mut lines = stdin.lines();
let _ = lines.next_line().await;
println!("Removing advertisement");
drop(handle);
sleep(Duration::from_secs(1)).await;
Ok(())
}
More examples
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
fn main() -> bluer::Result<()> {
let session = bluer::Session::new().await?;
let adapter_names = session.adapter_names().await?;
for adapter_name in adapter_names {
println!("Bluetooth adapater {}:", &adapter_name);
let adapter = session.adapter(&adapter_name)?;
println!(" Address: {}", adapter.address().await?);
println!(" Address type: {}", adapter.address_type().await?);
println!(" Friendly name: {}", adapter.alias().await?);
println!(" Modalias: {:?}", adapter.modalias().await?);
println!(" Powered: {:?}", adapter.is_powered().await?);
println!(" Discoverabe: {:?}", adapter.is_discoverable().await?);
println!(" Pairable: {:?}", adapter.is_pairable().await?);
println!(" UUIDs: {:?}", adapter.uuids().await?);
println!();
println!(" Active adv. instances: {}", adapter.active_advertising_instances().await?);
println!(" Supp. adv. instances: {}", adapter.supported_advertising_instances().await?);
println!(" Supp. adv. includes: {:?}", adapter.supported_advertising_system_includes().await?);
println!(" Adv. capabilites: {:?}", adapter.supported_advertising_capabilities().await?);
println!(" Adv. features: {:?}", adapter.supported_advertising_features().await?);
println!();
}
Ok(())
}
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
fn main() -> bluer::Result<()> {
let with_changes = env::args().any(|arg| arg == "--changes");
let filter_addr: HashSet<_> = env::args().filter_map(|arg| arg.parse::<Address>().ok()).collect();
env_logger::init();
let session = bluer::Session::new().await?;
let adapter = session.default_adapter().await?;
println!("Discovering devices using Bluetooth adapater {}\n", adapter.name());
adapter.set_powered(true).await?;
let device_events = adapter.discover_devices().await?;
pin_mut!(device_events);
let mut all_change_events = SelectAll::new();
loop {
tokio::select! {
Some(device_event) = device_events.next() => {
match device_event {
AdapterEvent::DeviceAdded(addr) => {
if !filter_addr.is_empty() && !filter_addr.contains(&addr) {
continue;
}
println!("Device added: {}", addr);
if let Err(err) = query_device(&adapter, addr).await {
println!(" Error: {}", &err);
}
if with_changes {
let device = adapter.device(addr)?;
let change_events = device.events().await?.map(move |evt| (addr, evt));
all_change_events.push(change_events);
}
}
AdapterEvent::DeviceRemoved(addr) => {
println!("Device removed: {}", addr);
}
_ => (),
}
println!();
}
Some((addr, DeviceEvent::PropertyChanged(property))) = all_change_events.next() => {
println!("Device changed: {}", addr);
println!(" {:?}", property);
}
else => break
}
}
Ok(())
}
144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199
fn main() -> bluer::Result<()> {
env_logger::init();
let session = bluer::Session::new().await?;
let adapter = session.default_adapter().await?;
adapter.set_powered(true).await?;
{
println!(
"Discovering on Bluetooth adapter {} with address {}\n",
adapter.name(),
adapter.address().await?
);
let discover = adapter.discover_devices().await?;
pin_mut!(discover);
let mut done = false;
while let Some(evt) = discover.next().await {
match evt {
AdapterEvent::DeviceAdded(addr) => {
let device = adapter.device(addr)?;
match find_our_characteristic(&device).await {
Ok(Some(char)) => match exercise_characteristic(&char).await {
Ok(()) => {
println!(" Characteristic exercise completed");
done = true;
}
Err(err) => {
println!(" Characteristic exercise failed: {}", &err);
}
},
Ok(None) => (),
Err(err) => {
println!(" Device failed: {}", &err);
let _ = adapter.remove_device(device.address()).await;
}
}
match device.disconnect().await {
Ok(()) => println!(" Device disconnected"),
Err(err) => println!(" Device disconnection failed: {}", &err),
}
println!();
}
AdapterEvent::DeviceRemoved(addr) => {
println!("Device removed {}", addr);
}
_ => (),
}
if done {
break;
}
}
println!("Stopping discovery");
}
sleep(Duration::from_secs(1)).await;
Ok(())
}
146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201
fn main() -> bluer::Result<()> {
env_logger::init();
let session = bluer::Session::new().await?;
let adapter = session.default_adapter().await?;
adapter.set_powered(true).await?;
{
println!(
"Discovering on Bluetooth adapter {} with address {}\n",
adapter.name(),
adapter.address().await?
);
let discover = adapter.discover_devices().await?;
pin_mut!(discover);
let mut done = false;
while let Some(evt) = discover.next().await {
match evt {
AdapterEvent::DeviceAdded(addr) => {
let device = adapter.device(addr)?;
match find_our_characteristic(&device).await {
Ok(Some(char)) => match exercise_characteristic(&char).await {
Ok(()) => {
println!(" Characteristic exercise completed");
done = true;
}
Err(err) => {
println!(" Characteristic exercise failed: {}", &err);
}
},
Ok(None) => (),
Err(err) => {
println!(" Device failed: {}", &err);
let _ = adapter.remove_device(device.address()).await;
}
}
match device.disconnect().await {
Ok(()) => println!(" Device disconnected"),
Err(err) => println!(" Device disconnection failed: {}", &err),
}
println!();
}
AdapterEvent::DeviceRemoved(addr) => {
println!("Device removed {}", addr);
}
_ => (),
}
if done {
break;
}
}
println!("Stopping discovery");
}
sleep(Duration::from_secs(1)).await;
Ok(())
}
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
fn main() -> bluer::Result<()> {
env_logger::init();
let session = bluer::Session::new().await?;
let adapter = session.default_adapter().await?;
adapter.set_powered(true).await?;
let args: Vec<_> = env::args().collect();
if args.len() != 2 {
eprintln!("Specify target Bluetooth address as argment");
exit(1);
}
let target_addr: Address = args[1].parse().expect("invalid address");
let target_sa = SocketAddr::new(target_addr, AddressType::LePublic, PSM);
println!("Connecting to {:?}", &target_sa);
let mut stream = Stream::connect(target_sa).await.expect("connection failed");
println!("Local address: {:?}", stream.as_ref().local_addr()?);
println!("Remote address: {:?}", stream.peer_addr()?);
println!("Send MTU: {:?}", stream.as_ref().send_mtu());
println!("Recv MTU: {}", stream.as_ref().recv_mtu()?);
println!("Security: {:?}", stream.as_ref().security()?);
println!("Flow control: {:?}", stream.as_ref().flow_control());
println!("\nReceiving hello");
let mut hello_buf = [0u8; HELLO_MSG.len()];
stream.read_exact(&mut hello_buf).await.expect("read failed");
println!("Received: {}", String::from_utf8_lossy(&hello_buf));
if hello_buf != HELLO_MSG {
panic!("Wrong hello message");
}
let (mut rh, mut wh) = stream.into_split();
let mut rng = rand::thread_rng();
for i in 0..15 {
let len = rng.gen_range(0..50000);
let data: Vec<u8> = (0..len).map(|_| rng.gen()).collect();
println!("\nTest iteration {} with data size {}", i, len);
// We must read back the data while sending, otherwise the connection
// buffer will overrun and we will lose data.
let read_task = tokio::spawn(async move {
let mut echo_buf = vec![0u8; len];
let res = match rh.read_exact(&mut echo_buf).await {
Ok(_) => Ok(echo_buf),
Err(err) => Err(err),
};
(rh, res)
});
// Note that write_all will automatically split the buffer into
// multiple writes of MTU size.
wh.write_all(&data).await.expect("write failed");
println!("Waiting for echo");
let (rh_back, res) = read_task.await.unwrap();
rh = rh_back;
let echo_buf = res.expect("read failed");
if echo_buf != data {
panic!("Echoed data does not match sent data");
}
println!("Data matches");
}
println!("Done");
Ok(())
}
sourcepub async fn default_adapter(&self) -> Result<Adapter>
pub async fn default_adapter(&self) -> Result<Adapter>
Create an interface to the default Bluetooth adapter.
If hci0
is present it is used as the default adapter.
Otherwise the adapter that is first by lexicographic sorting is used as default.
If the system has no Bluetooth adapter an error with ErrorKind::NotFound is returned.
Examples found in repository
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
fn main() -> bluer::Result<()> {
env_logger::init();
let session = bluer::Session::new().await?;
let adapter = session.default_adapter().await?;
adapter.set_powered(true).await?;
println!("Advertising on Bluetooth adapter {} with address {}", adapter.name(), adapter.address().await?);
let le_advertisement = Advertisement {
advertisement_type: bluer::adv::Type::Peripheral,
service_uuids: vec!["123e4567-e89b-12d3-a456-426614174000".parse().unwrap()].into_iter().collect(),
discoverable: Some(true),
local_name: Some("le_advertise".to_string()),
..Default::default()
};
println!("{:?}", &le_advertisement);
let handle = adapter.advertise(le_advertisement).await?;
println!("Press enter to quit");
let stdin = BufReader::new(tokio::io::stdin());
let mut lines = stdin.lines();
let _ = lines.next_line().await;
println!("Removing advertisement");
drop(handle);
sleep(Duration::from_secs(1)).await;
Ok(())
}
More examples
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
fn main() -> bluer::Result<()> {
let with_changes = env::args().any(|arg| arg == "--changes");
let filter_addr: HashSet<_> = env::args().filter_map(|arg| arg.parse::<Address>().ok()).collect();
env_logger::init();
let session = bluer::Session::new().await?;
let adapter = session.default_adapter().await?;
println!("Discovering devices using Bluetooth adapater {}\n", adapter.name());
adapter.set_powered(true).await?;
let device_events = adapter.discover_devices().await?;
pin_mut!(device_events);
let mut all_change_events = SelectAll::new();
loop {
tokio::select! {
Some(device_event) = device_events.next() => {
match device_event {
AdapterEvent::DeviceAdded(addr) => {
if !filter_addr.is_empty() && !filter_addr.contains(&addr) {
continue;
}
println!("Device added: {}", addr);
if let Err(err) = query_device(&adapter, addr).await {
println!(" Error: {}", &err);
}
if with_changes {
let device = adapter.device(addr)?;
let change_events = device.events().await?.map(move |evt| (addr, evt));
all_change_events.push(change_events);
}
}
AdapterEvent::DeviceRemoved(addr) => {
println!("Device removed: {}", addr);
}
_ => (),
}
println!();
}
Some((addr, DeviceEvent::PropertyChanged(property))) = all_change_events.next() => {
println!("Device changed: {}", addr);
println!(" {:?}", property);
}
else => break
}
}
Ok(())
}
144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199
fn main() -> bluer::Result<()> {
env_logger::init();
let session = bluer::Session::new().await?;
let adapter = session.default_adapter().await?;
adapter.set_powered(true).await?;
{
println!(
"Discovering on Bluetooth adapter {} with address {}\n",
adapter.name(),
adapter.address().await?
);
let discover = adapter.discover_devices().await?;
pin_mut!(discover);
let mut done = false;
while let Some(evt) = discover.next().await {
match evt {
AdapterEvent::DeviceAdded(addr) => {
let device = adapter.device(addr)?;
match find_our_characteristic(&device).await {
Ok(Some(char)) => match exercise_characteristic(&char).await {
Ok(()) => {
println!(" Characteristic exercise completed");
done = true;
}
Err(err) => {
println!(" Characteristic exercise failed: {}", &err);
}
},
Ok(None) => (),
Err(err) => {
println!(" Device failed: {}", &err);
let _ = adapter.remove_device(device.address()).await;
}
}
match device.disconnect().await {
Ok(()) => println!(" Device disconnected"),
Err(err) => println!(" Device disconnection failed: {}", &err),
}
println!();
}
AdapterEvent::DeviceRemoved(addr) => {
println!("Device removed {}", addr);
}
_ => (),
}
if done {
break;
}
}
println!("Stopping discovery");
}
sleep(Duration::from_secs(1)).await;
Ok(())
}
146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201
fn main() -> bluer::Result<()> {
env_logger::init();
let session = bluer::Session::new().await?;
let adapter = session.default_adapter().await?;
adapter.set_powered(true).await?;
{
println!(
"Discovering on Bluetooth adapter {} with address {}\n",
adapter.name(),
adapter.address().await?
);
let discover = adapter.discover_devices().await?;
pin_mut!(discover);
let mut done = false;
while let Some(evt) = discover.next().await {
match evt {
AdapterEvent::DeviceAdded(addr) => {
let device = adapter.device(addr)?;
match find_our_characteristic(&device).await {
Ok(Some(char)) => match exercise_characteristic(&char).await {
Ok(()) => {
println!(" Characteristic exercise completed");
done = true;
}
Err(err) => {
println!(" Characteristic exercise failed: {}", &err);
}
},
Ok(None) => (),
Err(err) => {
println!(" Device failed: {}", &err);
let _ = adapter.remove_device(device.address()).await;
}
}
match device.disconnect().await {
Ok(()) => println!(" Device disconnected"),
Err(err) => println!(" Device disconnection failed: {}", &err),
}
println!();
}
AdapterEvent::DeviceRemoved(addr) => {
println!("Device removed {}", addr);
}
_ => (),
}
if done {
break;
}
}
println!("Stopping discovery");
}
sleep(Duration::from_secs(1)).await;
Ok(())
}
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
fn main() -> bluer::Result<()> {
env_logger::init();
let session = bluer::Session::new().await?;
let adapter = session.default_adapter().await?;
adapter.set_powered(true).await?;
let args: Vec<_> = env::args().collect();
if args.len() != 2 {
eprintln!("Specify target Bluetooth address as argment");
exit(1);
}
let target_addr: Address = args[1].parse().expect("invalid address");
let target_sa = SocketAddr::new(target_addr, AddressType::LePublic, PSM);
println!("Connecting to {:?}", &target_sa);
let mut stream = Stream::connect(target_sa).await.expect("connection failed");
println!("Local address: {:?}", stream.as_ref().local_addr()?);
println!("Remote address: {:?}", stream.peer_addr()?);
println!("Send MTU: {:?}", stream.as_ref().send_mtu());
println!("Recv MTU: {}", stream.as_ref().recv_mtu()?);
println!("Security: {:?}", stream.as_ref().security()?);
println!("Flow control: {:?}", stream.as_ref().flow_control());
println!("\nReceiving hello");
let mut hello_buf = [0u8; HELLO_MSG.len()];
stream.read_exact(&mut hello_buf).await.expect("read failed");
println!("Received: {}", String::from_utf8_lossy(&hello_buf));
if hello_buf != HELLO_MSG {
panic!("Wrong hello message");
}
let (mut rh, mut wh) = stream.into_split();
let mut rng = rand::thread_rng();
for i in 0..15 {
let len = rng.gen_range(0..50000);
let data: Vec<u8> = (0..len).map(|_| rng.gen()).collect();
println!("\nTest iteration {} with data size {}", i, len);
// We must read back the data while sending, otherwise the connection
// buffer will overrun and we will lose data.
let read_task = tokio::spawn(async move {
let mut echo_buf = vec![0u8; len];
let res = match rh.read_exact(&mut echo_buf).await {
Ok(_) => Ok(echo_buf),
Err(err) => Err(err),
};
(rh, res)
});
// Note that write_all will automatically split the buffer into
// multiple writes of MTU size.
wh.write_all(&data).await.expect("write failed");
println!("Waiting for echo");
let (rh_back, res) = read_task.await.unwrap();
rh = rh_back;
let echo_buf = res.expect("read failed");
if echo_buf != data {
panic!("Echoed data does not match sent data");
}
println!("Data matches");
}
println!("Done");
Ok(())
}
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
fn main() -> bluer::Result<()> {
env_logger::init();
let session = bluer::Session::new().await?;
let adapter = session.default_adapter().await?;
adapter.set_powered(true).await?;
let adapter_addr = adapter.address().await?;
let adapter_addr_type = adapter.address_type().await?;
// Advertising is necessary for device to be connectable.
println!(
"Advertising on Bluetooth adapter {} with {} address {}",
adapter.name(),
&adapter_addr_type,
&adapter_addr
);
let le_advertisement = Advertisement {
service_uuids: vec![SERVICE_UUID].into_iter().collect(),
discoverable: Some(true),
local_name: Some("l2cap_server".to_string()),
..Default::default()
};
let adv_handle = adapter.advertise(le_advertisement).await?;
let local_sa = SocketAddr::new(adapter_addr, adapter_addr_type, PSM);
let listener = StreamListener::bind(local_sa).await?;
println!("Listening on PSM {}. Press enter to quit.", listener.as_ref().local_addr()?.psm);
let stdin = BufReader::new(tokio::io::stdin());
let mut lines = stdin.lines();
loop {
println!("\nWaiting for connection...");
let (mut stream, sa) = tokio::select! {
l = listener.accept() => {
match l {
Ok(v) => v,
Err(err) => {
println!("Accepting connection failed: {}", &err);
continue;
}}
},
_ = lines.next_line() => break,
};
let recv_mtu = stream.as_ref().recv_mtu()?;
println!("Accepted connection from {:?} with receive MTU {} bytes", &sa, &recv_mtu);
println!("Sending hello");
if let Err(err) = stream.write_all(HELLO_MSG).await {
println!("Write failed: {}", &err);
continue;
}
let mut n = 0;
loop {
n += 1;
// Vary buffer size between MTU and smaller value to test
// partial reads.
let buf_size = if n % 5 == 0 { recv_mtu - 70 } else { recv_mtu };
let mut buf = vec![0; buf_size as _];
let n = match stream.read(&mut buf).await {
Ok(0) => {
println!("Stream ended");
break;
}
Ok(n) => n,
Err(err) => {
println!("Read failed: {}", &err);
continue;
}
};
let buf = &buf[..n];
println!("Echoing {} bytes", buf.len());
if let Err(err) = stream.write_all(buf).await {
println!("Write failed: {}", &err);
continue;
}
}
}
println!("Removing advertisement");
drop(adv_handle);
sleep(Duration::from_secs(1)).await;
Ok(())
}
sourcepub async fn adapter_names(&self) -> Result<Vec<String>>
pub async fn adapter_names(&self) -> Result<Vec<String>>
Enumerate connected Bluetooth adapters and return their names.
Examples found in repository
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
fn main() -> bluer::Result<()> {
let session = bluer::Session::new().await?;
let adapter_names = session.adapter_names().await?;
for adapter_name in adapter_names {
println!("Bluetooth adapater {}:", &adapter_name);
let adapter = session.adapter(&adapter_name)?;
println!(" Address: {}", adapter.address().await?);
println!(" Address type: {}", adapter.address_type().await?);
println!(" Friendly name: {}", adapter.alias().await?);
println!(" Modalias: {:?}", adapter.modalias().await?);
println!(" Powered: {:?}", adapter.is_powered().await?);
println!(" Discoverabe: {:?}", adapter.is_discoverable().await?);
println!(" Pairable: {:?}", adapter.is_pairable().await?);
println!(" UUIDs: {:?}", adapter.uuids().await?);
println!();
println!(" Active adv. instances: {}", adapter.active_advertising_instances().await?);
println!(" Supp. adv. instances: {}", adapter.supported_advertising_instances().await?);
println!(" Supp. adv. includes: {:?}", adapter.supported_advertising_system_includes().await?);
println!(" Adv. capabilites: {:?}", adapter.supported_advertising_capabilities().await?);
println!(" Adv. features: {:?}", adapter.supported_advertising_features().await?);
println!();
}
Ok(())
}
sourcepub fn adapter(&self, adapter_name: &str) -> Result<Adapter>
pub fn adapter(&self, adapter_name: &str) -> Result<Adapter>
Create an interface to the Bluetooth adapter with the specified name.
Examples found in repository
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
fn main() -> bluer::Result<()> {
let session = bluer::Session::new().await?;
let adapter_names = session.adapter_names().await?;
for adapter_name in adapter_names {
println!("Bluetooth adapater {}:", &adapter_name);
let adapter = session.adapter(&adapter_name)?;
println!(" Address: {}", adapter.address().await?);
println!(" Address type: {}", adapter.address_type().await?);
println!(" Friendly name: {}", adapter.alias().await?);
println!(" Modalias: {:?}", adapter.modalias().await?);
println!(" Powered: {:?}", adapter.is_powered().await?);
println!(" Discoverabe: {:?}", adapter.is_discoverable().await?);
println!(" Pairable: {:?}", adapter.is_pairable().await?);
println!(" UUIDs: {:?}", adapter.uuids().await?);
println!();
println!(" Active adv. instances: {}", adapter.active_advertising_instances().await?);
println!(" Supp. adv. instances: {}", adapter.supported_advertising_instances().await?);
println!(" Supp. adv. includes: {:?}", adapter.supported_advertising_system_includes().await?);
println!(" Adv. capabilites: {:?}", adapter.supported_advertising_capabilities().await?);
println!(" Adv. features: {:?}", adapter.supported_advertising_features().await?);
println!();
}
Ok(())
}
sourcepub async fn register_agent(&self, agent: Agent) -> Result<AgentHandle>
pub async fn register_agent(&self, agent: Agent) -> Result<AgentHandle>
This registers a Bluetooth authorization agent handler.
Every application can register its own agent and for all actions triggered by that application its agent is used.
It is not required by an application to register an agent. If an application does chooses to not register an agent, the default agent is used. This is on most cases a good idea. Only application like a pairing wizard should register their own agent.
An application can only register one agent. Multiple agents per application is not supported.
Drop the returned AgentHandle to unregister the agent.
sourcepub async fn register_profile(&self, profile: Profile) -> Result<ProfileHandle>
pub async fn register_profile(&self, profile: Profile) -> Result<ProfileHandle>
This registers a Bluetooth profile implementation for RFCOMM connections.
The returned ProfileHandle provides a stream of connection requests.
Drop the handle to unregister the profile.
sourcepub async fn events(&self) -> Result<impl Stream<Item = SessionEvent>>
pub async fn events(&self) -> Result<impl Stream<Item = SessionEvent>>
Stream adapter added and removed events.
Trait Implementations
Auto Trait Implementations
impl !RefUnwindSafe for Session
impl Send for Session
impl Sync for Session
impl Unpin for Session
impl !UnwindSafe for Session
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcepub fn borrow_mut(&mut self) -> &mut T
pub fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> ToOwned for T where
T: Clone,
impl<T> ToOwned for T where
T: Clone,
type Owned = T
type Owned = T
The resulting type after obtaining ownership.
sourcepub fn to_owned(&self) -> T
pub fn to_owned(&self) -> T
Creates owned data from borrowed data, usually by cloning. Read more
sourcepub fn clone_into(&self, target: &mut T)
pub fn clone_into(&self, target: &mut T)
toowned_clone_into
)Uses borrowed data to replace owned data, usually by cloning. Read more