Struct DeviceManager

pub struct DeviceManager { /* private fields */ }

Manager for multiple Aranet devices.

Implementations

impl DeviceManager

pub fn new() -> Self

Create a new device manager.

pub fn with_event_capacity(capacity: usize) -> Self

Create a manager with custom event capacity.

pub fn with_config(config: ManagerConfig) -> Self

Create a manager with full configuration.

pub fn events(&self) -> &EventDispatcher

Get the event dispatcher for subscribing to events.

pub fn config(&self) -> &ManagerConfig

Get the manager configuration.

pub async fn scan(&self) -> Result<Vec<DiscoveredDevice>>

Scan for available devices.

pub async fn scan_with_options( &self, options: ScanOptions, ) -> Result<Vec<DiscoveredDevice>>

Scan with custom options.

pub async fn add_device(&self, identifier: &str) -> Result<()>

Add a device to the manager by identifier.

pub async fn add_device_with_options( &self, identifier: &str, reconnect_options: ReconnectOptions, ) -> Result<()>

Add a device with custom reconnect options.

pub async fn connect(&self, identifier: &str) -> Result<()>

Connect to a device.

This method performs an atomic connect-or-skip operation:

• If the device doesn’t exist, it’s added and connected
• If the device exists but is not connected, it’s connected
• If the device is already connected, this is a no-op

The lock is held during the device entry update to prevent race conditions, but released during the actual BLE connection to avoid blocking other operations.

pub async fn disconnect(&self, identifier: &str) -> Result<()>

Disconnect from a device.

pub async fn remove_device(&self, identifier: &str) -> Result<()>

Remove a device from the manager.

pub async fn device_ids(&self) -> Vec<String>

Get a list of all managed device IDs.

pub async fn device_count(&self) -> usize

Get the number of managed devices.

pub async fn connected_count(&self) -> usize

Get the number of connected devices (fast, doesn’t query BLE).

This returns the number of devices that have an active device handle, without querying the BLE stack. Use connected_count_verified for an accurate count that queries each device.

pub async fn connected_count_verified(&self) -> usize

Get the number of connected devices (verified via BLE).

This method queries each device to verify its connection status. The lock is released before making BLE calls to avoid contention.

pub async fn read_current(&self, identifier: &str) -> Result<CurrentReading>

Read current values from a specific device.

pub async fn read_all(&self) -> HashMap<String, Result<CurrentReading>>

Read current values from all connected devices (in parallel).

This method releases the lock before performing async BLE operations, allowing other tasks to add/remove devices while reads are in progress. All reads are performed in parallel for maximum performance.

pub async fn connect_all(&self) -> HashMap<String, Result<()>>

Connect to all known devices (in parallel).

Returns a map of device IDs to connection results.

pub async fn disconnect_all(&self) -> HashMap<String, Result<()>>

Disconnect from all devices (in parallel).

Returns a map of device IDs to disconnection results.

pub fn try_is_connected(&self, identifier: &str) -> Option<bool>

Check if a specific device is connected (fast, doesn’t query BLE).

This method attempts to check if a device has an active connection handle without blocking. Returns None if the lock couldn’t be acquired immediately, or Some(bool) indicating whether the device has a connection handle.

Note: This only checks if we have a device handle, not whether the actual BLE connection is still alive. Use is_connected for a verified check.

pub async fn is_connected(&self, identifier: &str) -> bool

Check if a specific device is connected (verified via BLE).

The lock is released before making the BLE call.

pub async fn get_device_info(&self, identifier: &str) -> Option<DeviceInfo>

Get device info for a specific device.

pub async fn get_last_reading(&self, identifier: &str) -> Option<CurrentReading>

Get the last cached reading for a device.

pub fn start_health_monitor( self: &Arc<Self>, cancel_token: CancellationToken, ) -> JoinHandle<()>

Start a background health check task that monitors connection status.

This spawns a task that periodically checks device connections and attempts to reconnect devices that have auto_reconnect enabled.

The task will run until the provided cancellation token is cancelled.

Example

use tokio_util::sync::CancellationToken;

let manager = Arc::new(DeviceManager::new());
let cancel = CancellationToken::new();
let handle = manager.start_health_monitor(cancel.clone());

// Later, to stop the health monitor:
cancel.cancel();
handle.await.unwrap();

Trait Implementations

impl Default for DeviceManager

fn default() -> Self

Returns the “default value” for a type.