有什么方法可以在不连接的情况下监控发现的BLE外设？

Question

Is there any way of being notified if a discovered BLE peripheral moves out of range or otherwise drops out of sight? I'm using rxBleClient.scanBleDevices() to build a list of devices in the area that are advertising, but before shipping this list to the main application I'd like to be sure that all the devices are still reachable. What's the best way of doing this?

Answer 1

The vanilla Android Scan API allows for scanning BLE devices with callback types of:

/**
 * A result callback is only triggered for the first advertisement packet received that matches
 * the filter criteria.
 */
public static final int CALLBACK_TYPE_FIRST_MATCH = 2;

/**
 * Receive a callback when advertisements are no longer received from a device that has been
 * previously reported by a first match callback.
 */
public static final int CALLBACK_TYPE_MATCH_LOST = 4;

The same API is available via RxBleClient.scanBleDevices(ScanSettings, ScanFilter...)

The CALLBACK_TYPE_FIRST_MATCH and CALLBACK_TYPE_MATCH_LOST are flags that can be put into ScanSettings .

The timeout after which the CALLBACK_TYPE_MATCH_LOST is triggered is somewhere around 10 seconds. This may be an indication that a particular device is no longer in range/available.

Answer 2

您可以创建一个Transformer ，该Transformer将收集扫描的设备并发出一个列表，该列表保持最新状态，具体取决于最近看到该设备的时间。

Answer 3

Robert, that may not be exactly what you expect but treat it as an example. My Transformer is emitting a list of items whenever it has been changed, either because an update from the scanner or the eviction happened (checked every second).

class RollingPairableDeviceReducer(
        private val systemTime: SystemTime,
        private val evictionTimeSeconds: Long,
        private val pairableDeviceFactory: PairableDeviceFactory
) : Observable.Transformer<ScannedDevice, List<PairableDevice>> {
    override fun call(source: Observable<ScannedDevice>): Observable<List<PairableDevice>> {
        val accumulator: MutableSet<PairableDevice> = Collections.synchronizedSet(mutableSetOf())
        return source
                .map { createPairableDevice(it) }
                .map { pairableDevice ->
                    val added = updateOrAddDevice(accumulator, pairableDevice)
                    val removed = removeOldDevices(accumulator)
                    added || removed
                }
                .mergeWith(checkEvictionEverySecond(accumulator))
                .filter { addedOrRemoved -> addedOrRemoved == true }
                .map { accumulator.toList() }
    }

    private fun createPairableDevice(scannedDevice: ScannedDevice)
            = pairableDeviceFactory.create(scannedDevice)

    private fun updateOrAddDevice(accumulator: MutableSet<PairableDevice>, emittedItem: PairableDevice): Boolean {
        val existingPairableDevice = accumulator.find { it.deviceIdentifier.hardwareId == emittedItem.deviceIdentifier.hardwareId }
        return if (existingPairableDevice != null) {
            accumulator.remove(existingPairableDevice)
            existingPairableDevice.updateWith(emittedItem)
            accumulator.add(existingPairableDevice)
            false
        } else {
            accumulator.add(emittedItem)
            true
        }
    }

    private fun checkEvictionEverySecond(collector: MutableSet<PairableDevice>): Observable<Boolean>
            = Observable.interval(1, TimeUnit.SECONDS)
            .map { removeOldDevices(collector) }

    private fun removeOldDevices(accumulator: MutableSet<PairableDevice>): Boolean {
        val currentTimeInMillis = systemTime.currentTimeInMillis()
        val evictionTimeMillis = TimeUnit.SECONDS.toMillis(evictionTimeSeconds)
        return accumulator.removeAll { (currentTimeInMillis - it.lastSeenTime) >= evictionTimeMillis }
    }
}