Struct bluest::Descriptor

pub struct Descriptor(/* private fields */);

A Bluetooth GATT descriptor

Implementations

impl Descriptor

pub fn uuid(&self) -> Uuid

The Uuid identifying the type of this GATT descriptor

Panics

On Linux, this method will panic if there is a current Tokio runtime and it is single-threaded, if there is no current Tokio runtime and creating one fails, or if the underlying Descriptor::uuid_async() method fails.

pub async fn uuid_async(&self) -> Result<Uuid>

The Uuid identifying the type of this GATT descriptor

pub async fn value(&self) -> Result<Vec<u8>>

The cached value of this descriptor

If the value has not yet been read, this method may either return an error or perform a read of the value.

pub async fn read(&self) -> Result<Vec<u8>>

Read the value of this descriptor from the device

Examples found in repository

examples/connected.rs (line 46)

async fn main() -> Result<(), Box<dyn Error>> {
    use tracing_subscriber::prelude::*;
    use tracing_subscriber::{fmt, EnvFilter};

    tracing_subscriber::registry()
        .with(fmt::layer())
        .with(
            EnvFilter::builder()
                .with_default_directive(LevelFilter::INFO.into())
                .from_env_lossy(),
        )
        .init();

    let adapter = Adapter::default().await.ok_or("Bluetooth adapter not found")?;
    adapter.wait_available().await?;

    info!("getting connected devices");
    let devices = adapter.connected_devices().await?;
    for device in devices {
        info!("found {:?}", device);
        adapter.connect_device(&device).await?;
        let services = device.services().await?;
        for service in services {
            info!("  {:?}", service);
            let characteristics = service.characteristics().await?;
            for characteristic in characteristics {
                info!("    {:?}", characteristic);
                let props = characteristic.properties().await?;
                info!("      props: {:?}", props);
                if props.read {
                    info!("      value: {:?}", characteristic.read().await);
                }
                if props.write_without_response {
                    info!("      max_write_len: {:?}", characteristic.max_write_len());
                }

                let descriptors = characteristic.descriptors().await?;
                for descriptor in descriptors {
                    info!("      {:?}: {:?}", descriptor, descriptor.read().await);
                }
            }
        }
    }
    info!("done");

    Ok(())
}

pub async fn write(&self, value: &[u8]) -> Result<()>

Write the value of this descriptor on the device to value

Trait Implementations

impl Clone for Descriptor

fn clone(&self) -> Descriptor

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Descriptor

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for Descriptor

fn eq(&self, other: &Descriptor) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Descriptor

impl StructuralEq for Descriptor

impl StructuralPartialEq for Descriptor