android - 如何检测 BLE 设备何时不在范围内？

Question

我使用 LeScanCallback(不能使用较新的扫描方法，因为我正在为 api 18 开发。没关系，因为 android 5.0+ api 也不提供此功能)来检测附近的 BLE 设备何时被检测到:

private BluetoothAdapter.LeScanCallback bleCallback = new BluetoothAdapter.LeScanCallback() {

    @Override
    public void onLeScan(BluetoothDevice bluetoothDevice, int i, byte[] bytes) {
        discoveredDevices.add(bluetoothDevice);
    }
};

我没有与设备配对或连接，因为这不是必需的，我只是想看看附近有哪些设备。

我正在尝试创建一项服务，每 5 分钟左右调用一次网络服务器以更新当时附近的设备。

棘手的部分是安卓设备会移动，所以现在附近的蓝牙设备可能不会在 5 分钟内出现。在这种情况下，我需要将其从 discoveredDevices 中删除。

理想情况下，我希望在蓝牙设备之前在范围内时收到回调，但现在不在了。但是这个回调并不存在。

(我知道 android.bluetooth.device.action.ACL_CONNECTED 和 android.bluetooth.device.action.ACL_DISCONNECTED 广播，但这些是用于何时你连接到我不想要的蓝牙设备。)

一个选项是每 5 分钟重新扫描一次，但您无法判断何时发现附近的所有设备，因此您必须进行定时扫描，例如扫描5秒，然后将收集到的数据发送到webservice。
这听起来既肮脏又冒险，因为您永远无法确定所有附近的设备都在规定的时间内被发现，所以我非常希望避免这样做。

还有其他方法吗？

---

编辑
一些设备不断报告附近蓝牙设备的发现，即使它们之前已经被发现。如果该功能是通用的，我可以解决我的问题，但是这是特定于设备的。

例如，我手机的蓝牙适配器只会发现附近的设备一次。我测试过的其他一些设备会不断报告附近的相同设备，但并非所有设备都如此，所以很遗憾我不能依赖它。

Answer 1

This sounds dirty and risky because you can never know for sure all nearby devices were discovered within the allotted time, so I would very much like to avoid doing it like that.

这听起来像是一个合理的假设，但它是错误的。

低功耗蓝牙以特定方式工作，BLE 设备有一些限制。例如，它们具有固定范围的可能广告频率，范围从 20 毫秒到 10.24 秒，步长为 0.625 毫秒。见 here和 here了解更多详细信息。

这意味着在设备广播新的广告包之前可能需要最多 10.24 秒。 BLE 设备通常(如果不是总是)为其所有者提供了一种调整其广告频率的方法，因此频率当然可以变化。

如果您定期收集附近设备(例如您的设备)的数据，则可以使用具有固定时间限制的扫描，将数据保存在某处，重新开始扫描，收集新数据，与旧数据进行比较 --> 得到结果。

例如，如果在扫描 1 中找到了一个设备，但在扫描 2 中没有找到，您可以断定该设备在范围内，但不再存在。
反之亦然:如果在扫描 4 中找到了设备，但在扫描 3 中没有找到，则它是新发现的设备。
最后，如果在扫描 5 中找到设备，但在扫描 6 中未找到，但在扫描 7 中再次找到，则会重新发现该设备，并且可以在需要时进行处理。

---

因为我在这里回答我自己的问题，所以我将添加我用来实现它的代码。

我在后台服务中完成扫描，并使用广播接收器与应用程序的其他部分通信。 Asset 是我的一个自定义类，其中包含一些数据。 DataManager 是我的一个自定义类 - 你怎么猜到 - 管理数据。

public class BLEDiscoveryService extends Service {

    // Broadcast identifiers.
    public static final String EVENT_NEW_ASSET = "EVENT_NEW_ASSET ";
    public static final String EVENT_LOST_ASSET = "EVENT_LOST_ASSET ";

    private static Handler handler;
    private static final int BLE_SCAN_TIMEOUT = 11000; // 11 seconds

    // Lists to keep track of current and previous detected devices.
    // Used to determine which are in range and which are not anymore.
    private List<Asset> previouslyDiscoveredAssets;
    private List<Asset> currentlyDiscoveredAssets;

    private BluetoothAdapter bluetoothAdapter;

    private BluetoothAdapter.LeScanCallback BLECallback = new BluetoothAdapter.LeScanCallback() {

        @Override
        public void onLeScan(BluetoothDevice bluetoothDevice, int i, byte[] bytes) {

            Asset asset = DataManager.getAssetForMACAddress(bluetoothDevice.getAddress());
            handleDiscoveredAsset(asset);
        }
    };

    @Override
    public void onCreate() {
        super.onCreate();

        BluetoothManager manager = (BluetoothManager) getSystemService(BLUETOOTH_SERVICE);
        bluetoothAdapter = manager.getAdapter();

        previouslyDiscoveredAssets = new ArrayList<>();
        currentlyDiscoveredAssets = new ArrayList<>();

        handler = new Handler();
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        // Start scanning.
        startBLEScan();

        // After a period of time, stop the current scan and start a new one.
        // This is used to detect when assets are not in range anymore.
        handler.postDelayed(new Runnable() {
            @Override
            public void run() {
                performRepeatingTask();

                // Repeat.
                handler.postDelayed(this, BLE_SCAN_TIMEOUT);
            }
        }, BLE_SCAN_TIMEOUT);

        // Service is not restarted if it gets terminated.
        return Service.START_NOT_STICKY;
    }

    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    @Override
    public void onDestroy() {
        handler.removeCallbacksAndMessages(null);
        stopBLEScan();

        super.onDestroy();
    }

    private void startBLEScan() {
        bluetoothAdapter.startLeScan(BLECallback);
    }

    private void stopBLEScan() {
        bluetoothAdapter.stopLeScan(BLECallback);
    }

    private void handleDiscoveredAsset(Asset asset) {
        currentlyDiscoveredAssets.add(asset);

        // Notify observers that we have a new asset discovered, but only if it was not
        // discovered previously.
        if (currentlyDiscoveredAssets.contains(asset) &&
                !previouslyDiscoveredAssets.contains(asset)) {
            notifyObserversOfNewAsset(asset);
        }
    }

    private void performRepeatingTask() {
        // Check if a previously discovered asset is not discovered this scan round,
        // meaning it's not in range anymore.
        for (Asset asset : previouslyDiscoveredAssets) {
            if (!currentlyDiscoveredAssets.contains(asset)) {
                notifyObserversOfLostAsset(asset);
            }
        }

        // Update lists for a new round of scanning.
        previouslyDiscoveredAssets.clear();
        previouslyDiscoveredAssets.addAll(currentlyDiscoveredAssets);
        currentlyDiscoveredAssets.clear();

        // Reset the scan.
        stopBLEScan();
        startBLEScan();
    }

    private void notifyObserversOfNewAsset(Asset asset) {
        Intent intent = new Intent();
        intent.putExtra("macAddress", asset.MAC_address);
        intent.setAction(EVENT_NEW_ASSET);

        sendBroadcast(intent);
    }

    private void notifyObserversOfLostAsset(Asset asset) {
        Intent intent = new Intent();
        intent.putExtra("macAddress", asset.MAC_address);
        intent.setAction(EVENT_LOST_ASSET);      

        sendBroadcast(intent);
    }
}

这段代码并不完美，甚至可能有错误，但它至少会给你一个想法或示例，说明如何实现。