Connecting to Multiple Devices

Example: stream Respiration from two devices at once.

1. Turn on devices and wait for the pulsating green LED (ready to connect).
2. Run the routine below.
3. Wait for both connections to establish.

Examples

Flutter

import 'package:aidlab_sdk/aidlab_sdk.dart';

const firstAddress = '<FIRST DEVICE ADDRESS>';
const secondAddress = '<SECOND DEVICE ADDRESS>';

final class MultiDeviceController
    implements AidlabManagerDelegate, DeviceDelegate {
  MultiDeviceController() : manager = AidlabManager(null) {
    manager.delegate = this;
  }

  final AidlabManager manager;
  final Set<String> connecting = <String>{};

  Future<void> run() async {
    await manager.scan(ScanMode.aggressive);
  }

  @override
  void didDiscover(Device device, int rssi) {
    final bool isTarget =
        device.address == firstAddress || device.address == secondAddress;
    if (!isTarget || !connecting.add(device.address)) {
      return;
    }
    device.connect(this);
  }

  @override
  Future<void> didConnect(Device device) async {
    await device.collect([DataType.respiration], []);
  }

  @override
  void didDisconnect(Device device, DisconnectReason reason) {
    connecting.remove(device.address);
    print('Disconnected from: ${device.address}');
  }

  @override
  void didReceiveRespiration(Device device, int timestamp, double value) {
    print('Respiration: $value from ${device.address}');
  }
}

Python

import asyncio
from aidlab import AidlabManager, DataType, DeviceDelegate, DisconnectReason

FIRST_ADDRESS = "<FIRST DEVICE ADDRESS>"
SECOND_ADDRESS = "<SECOND DEVICE ADDRESS>"

class MainManager(DeviceDelegate):
    async def run(self):
        devices = await AidlabManager().scan()
        first = next((d for d in devices if d.address == FIRST_ADDRESS), None)
        second = next((d for d in devices if d.address == SECOND_ADDRESS), None)
        if first:
            await first.connect(self)
        if second:
            await second.connect(self)
        while True:
            await asyncio.sleep(1)

    async def did_connect(self, device):
        await device.collect([DataType.RESPIRATION], [])

    def did_disconnect(self, device, reason: DisconnectReason):
        print("Disconnected from:", device.address, reason)

    def did_receive_respiration(self, device, _, value):
        print("Respiration:", value, device.address)

asyncio.run(MainManager().run())

Apple Platforms

let firstDeviceAddress = "<FIRST DEVICE UUID>"
let secondDeviceAddress = "<SECOND DEVICE UUID>"

@MainActor
final class MainManager: AidlabManagerDelegate, DeviceDelegate {
    private let aidlabManager: AidlabManager
    private var connected: Set<UUID> = []

    init() {
        aidlabManager = AidlabManager(delegate: self)
    }

    func run() { aidlabManager.scan() }

    func didDiscover(_ device: Device) {
        let addr = device.address.uuidString
        guard addr == firstDeviceAddress || addr == secondDeviceAddress else { return }
        guard connected.insert(device.address).inserted else { return }
        device.connect(delegate: self) // errors via didReceiveError / didDisconnect
    }

    func didConnect(_ device: Device) {
        Task {
            try await device.collect(dataTypes: [.respiration], dataTypesToStore: [])
        }
    }

    func didDisconnect(_ device: Device, reason _: DisconnectReason) {
        connected.remove(device.address)
        print("Disconnected from: \(device.address.uuidString)")
    }

    func didReceiveRespiration(_ device: Device, timestamp: UInt64, value: Float) {
        print("Respiration: \(value) from \(device.address.uuidString)")
    }
}

Unity

// The current Unity wrapper does not expose a multi-device manager.
// Desktop/iOS creates a singleton AidlabSDK object, and the Android bridge
// keeps one active IAidlab connection. Use one of the platform SDKs above
// when your app must stream from multiple supported devices in parallel.

Unity

The current Unity wrapper is designed around one active device connection per SDK instance. Desktop/iOS uses a singleton AidlabSDK object and a target device name, while the Android bridge keeps one active IAidlab connection. Use Python, Android, Apple Platforms, or Flutter when your app must manage multiple supported devices in parallel.

Tip: filter by address to avoid connecting to unintended devices when many are nearby.

Troubleshooting

Connection limits depend on the Bluetooth adapter, operating system, and signal conditions. Validate the required number of simultaneous connections on your target hardware.