Android BLE - 连接到多个设备似乎失败，两个连接的 GATT 响应是否相同？

Question

我正在开发一个连接到 BLE 设备并读取我需要检查的特定 GATT 特性和服务的 Android 应用程序。我使用 Android Dev 站点中的 BluetoothLeGATT 示例作为引用。我可以毫无问题地连接到预定义地址并读取 GATT 属性更新。

我接下来要做的是能够同时连接到两个 BLE 设备。然而，这似乎是一个挑战。

我所做的基本上是复制连接到单个 BLE 设备所需的代码。我有 2 个 BluetoothLeServices、2 个用于 GattCharacteristics 和 Gatt 服务数据的 ArrayLists，以及 2 个服务连接和 2 个用于 GattCallbacks 的广播接收器。

但是，在我的 GattCallback 函数中，我得到了相同的消息——就好像它们连接到同一个区域一样。这是我的代码:

public class MainActivity extends AppCompatActivity {

        /*
        UUIDs
            Dog Block - 20:CD:39:87:DC:AA
            Cat Block - 20:CD:39:87:DF:82
     */

    private final String TAG = this.getClass().getSimpleName();

    private BluetoothAdapter mBluetoothAdapter;
    private Handler mHandler;

    private static final int REQUEST_ENABLE_BT = 1;
    private static final long SCAN_PERIOD = 10000;

    private ArrayList<String> addressID = new ArrayList<>();
    private ArrayList<BluetoothDevice> deviceList = new ArrayList<>();

    private boolean mScanning = false;
    private boolean mConnected = false;

    private BluetoothLeService mBluetoothLeService;
    private BluetoothLeService mBluetoothLeService1;

    private ArrayList<ArrayList<BluetoothGattCharacteristic>> mGattCharacteristics =
            new ArrayList<ArrayList<BluetoothGattCharacteristic>>();
    private ArrayList<ArrayList<BluetoothGattCharacteristic>> mGattCharacteristics1 =
            new ArrayList<ArrayList<BluetoothGattCharacteristic>>();


    private final String LIST_NAME = "NAME";
    private final String LIST_UUID = "UUID";

    ArrayList<HashMap<String, String>> gattServiceData = new ArrayList<HashMap<String, String>>();
    ArrayList<ArrayList<HashMap<String, String>>> gattCharacteristicData
            = new ArrayList<ArrayList<HashMap<String, String>>>();
    ArrayList<HashMap<String, String>> gattServiceData1 = new ArrayList<HashMap<String, String>>();
    ArrayList<ArrayList<HashMap<String, String>>> gattCharacteristicData1
            = new ArrayList<ArrayList<HashMap<String, String>>>();

    private BluetoothGattCharacteristic mNotifyCharacteristic;
    private BluetoothGattCharacteristic mNotifyCharacteristic1;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mHandler = new Handler();

        // Use this check to determine whether BLE is supported on the device.  Then you can
        // selectively disable BLE-related features.
        if (!getPackageManager().hasSystemFeature(PackageManager.FEATURE_BLUETOOTH_LE)) {
            Toast.makeText(this, R.string.ble_not_supported, Toast.LENGTH_SHORT).show();
            finish();
        }

        // Initializes a Bluetooth adapter.  For API level 18 and above, get a reference to
        // BluetoothAdapter through BluetoothManager.
        final BluetoothManager bluetoothManager =
                (BluetoothManager) getSystemService(Context.BLUETOOTH_SERVICE);
        mBluetoothAdapter = bluetoothManager.getAdapter();

        // Checks if Bluetooth is supported on the device.
        if (mBluetoothAdapter == null) {
            Toast.makeText(this, R.string.error_bluetooth_not_supported, Toast.LENGTH_SHORT).show();
            finish();
            return;
        }

        addressID.add("20:CD:39:87:DC:AA");
        addressID.add("20:CD:39:87:DF:82");
    }



    @Override
    protected void onResume() {
        super.onResume();

        Log.e(TAG, "onResume");

        // Ensures Bluetooth is enabled on the device.  If Bluetooth is not currently enabled,
        // fire an intent to display a dialog asking the user to grant permission to enable it.
        if (!mBluetoothAdapter.isEnabled()) {
            if (!mBluetoothAdapter.isEnabled()) {
                Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
                startActivityForResult(enableBtIntent, REQUEST_ENABLE_BT);
            }
        }
        scanLeDevice(true);

        if (mBluetoothLeService != null) {

        }

    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        // User chose not to enable Bluetooth.
        if (requestCode == REQUEST_ENABLE_BT && resultCode == Activity.RESULT_CANCELED) {
            finish();
            return;
        }
        super.onActivityResult(requestCode, resultCode, data);
    }

    @Override
    protected void onPause() {
        super.onPause();
        scanLeDevice(false);
        unregisterReceiver(mGattUpdateReceiver);
        unregisterReceiver(mGattUpdateReceiver1);

    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        unbindService(mServiceConnection);
        mBluetoothLeService = null;
        mBluetoothLeService1 = null;
    }

    private void scanLeDevice(final boolean enable) {
        if (enable) {
            Log.e(TAG, "scanLeDevice true");
            // Stops scanning after a pre-defined scan period.
            mHandler.postDelayed(new Runnable() {
                @Override
                public void run() {
                    mScanning = false;
                    mBluetoothAdapter.stopLeScan(mLeScanCallback);
                    invalidateOptionsMenu();
                }
            }, SCAN_PERIOD);

            mScanning = true;
            mBluetoothAdapter.startLeScan(mLeScanCallback);
        } else {
            Log.e(TAG, "scanLeDevice false");
            mScanning = false;
            mBluetoothAdapter.stopLeScan(mLeScanCallback);
        }
        invalidateOptionsMenu();
    }

    // Device scan callback.
    private BluetoothAdapter.LeScanCallback mLeScanCallback =
            new BluetoothAdapter.LeScanCallback() {

                @Override
                public void onLeScan(final BluetoothDevice device, int rssi, byte[] scanRecord) {
                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {

                            deviceList.add(device);

                            Log.e(TAG, "deviceList count = " + deviceList.size());

                            if(deviceList.size() >= 2){
                                checkDevices();
                            }
                        }
                    });
                }
            };

    private void checkDevices() {

        Intent gattServiceIntent = new Intent(this, BluetoothLeService.class);
        bindService(gattServiceIntent, mServiceConnection, BIND_AUTO_CREATE);

        Intent gattServiceIntent1 = new Intent(this, BluetoothLeService.class);
        bindService(gattServiceIntent1, mServiceConnection1, BIND_AUTO_CREATE);

        registerReceiver(mGattUpdateReceiver, makeGattUpdateIntentFilter());
        registerReceiver(mGattUpdateReceiver1, makeGattUpdateIntentFilter());
    }

    //TODO -- connect functions here
    private static IntentFilter makeGattUpdateIntentFilter() {
        final IntentFilter intentFilter = new IntentFilter();
        intentFilter.addAction(BluetoothLeService.ACTION_GATT_CONNECTED);
        intentFilter.addAction(BluetoothLeService.ACTION_GATT_DISCONNECTED);
        intentFilter.addAction(BluetoothLeService.ACTION_GATT_SERVICES_DISCOVERED);
        intentFilter.addAction(BluetoothLeService.ACTION_DATA_AVAILABLE);
        return intentFilter;
    }

    // Code to manage Service lifecycle.
    private final ServiceConnection mServiceConnection = new ServiceConnection() {

        @Override
        public void onServiceConnected(ComponentName componentName, IBinder service) {
            mBluetoothLeService = ((BluetoothLeService.LocalBinder) service).getService();
            if (!mBluetoothLeService.initialize()) {
                Log.e(TAG, "Unable to initialize Bluetooth");
                finish();
            }
            Log.e(TAG, "connecting to " + deviceList.get(0).getAddress());
            mBluetoothLeService.connect("20:CD:39:87:DC:AA");
        }
        @Override
        public void onServiceDisconnected(ComponentName componentName) {
            mBluetoothLeService = null;
        }
    };
    private final ServiceConnection mServiceConnection1 = new ServiceConnection() {

        @Override
        public void onServiceConnected(ComponentName componentName, IBinder service) {
            mBluetoothLeService1 = ((BluetoothLeService.LocalBinder) service).getService();

            if (!mBluetoothLeService1.initialize()) {
                Log.e(TAG, "1Unable to initialize Bluetooth");
                finish();
            }
            // Automatically connects to the device upon successful start-up initialization.
            Log.e(TAG, "1connecting to " + deviceList.get(1).getAddress());
            mBluetoothLeService1.connect("20:CD:39:87:DF:82");
        }

        @Override
        public void onServiceDisconnected(ComponentName componentName) {
            mBluetoothLeService = null;
        }
    };

    private final BroadcastReceiver mGattUpdateReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            final String action = intent.getAction();
            if (BluetoothLeService.ACTION_GATT_CONNECTED.equals(action)) {
                Log.e(TAG, "connected");
            } else if (BluetoothLeService.ACTION_GATT_DISCONNECTED.equals(action)) {
                Log.e(TAG, "disconnected");
                mConnected = false;
            } else if (BluetoothLeService.ACTION_GATT_SERVICES_DISCOVERED.equals(action)) {
                // Show all the supported services and characteristics on the user interface.
                Log.e(TAG, "gatt services discovered");
                displayGattServices(mBluetoothLeService.getSupportedGattServices());
            } else if (BluetoothLeService.ACTION_DATA_AVAILABLE.equals(action)) {
                Log.e(TAG, "data available");
                String data = intent.getStringExtra(BluetoothLeService.EXTRA_DATA);
                Log.e(TAG, "data is = " + data);
            }
        }
    };

    private final BroadcastReceiver mGattUpdateReceiver1 = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            final String action = intent.getAction();
            if (BluetoothLeService.ACTION_GATT_CONNECTED.equals(action)) {
                Log.e(TAG, "1connected");
            } else if (BluetoothLeService.ACTION_GATT_DISCONNECTED.equals(action)) {
                Log.e(TAG, "1disconnected");
                mConnected = false;
            } else if (BluetoothLeService.ACTION_GATT_SERVICES_DISCOVERED.equals(action)) {
                // Show all the supported services and characteristics on the user interface.
                Log.e(TAG, "1gatt services discovered");
                displayGattServices1(mBluetoothLeService1.getSupportedGattServices());
            } else if (BluetoothLeService.ACTION_DATA_AVAILABLE.equals(action)) {
                Log.e(TAG, "1data available");
                String data = intent.getStringExtra(BluetoothLeService.EXTRA_DATA);
                Log.e(TAG, "1data is = " + data);
            }
        }
    };

    private void displayGattServices(List<BluetoothGattService> gattServices) {
        if (gattServices == null) return;
        Log.e(TAG, "display gatt services not null.");
        String uuid = null;
        String unknownServiceString = getResources().getString(R.string.unknown_service);
        String unknownCharaString = getResources().getString(R.string.unknown_characteristic);

        mGattCharacteristics = new ArrayList<ArrayList<BluetoothGattCharacteristic>>();

        // Loops through available GATT Services.
        for (BluetoothGattService gattService : gattServices) {
            HashMap<String, String> currentServiceData = new HashMap<String, String>();
            uuid = gattService.getUuid().toString();
            currentServiceData.put(
                    LIST_NAME, SampleGattAttributes.lookup(uuid, unknownServiceString));
            currentServiceData.put(LIST_UUID, uuid);
            gattServiceData.add(currentServiceData);

            ArrayList<HashMap<String, String>> gattCharacteristicGroupData =
                    new ArrayList<HashMap<String, String>>();
            List<BluetoothGattCharacteristic> gattCharacteristics =
                    gattService.getCharacteristics();
            ArrayList<BluetoothGattCharacteristic> charas =
                    new ArrayList<BluetoothGattCharacteristic>();

            // Loops through available Characteristics.
            for (BluetoothGattCharacteristic gattCharacteristic : gattCharacteristics) {
                charas.add(gattCharacteristic);
                HashMap<String, String> currentCharaData = new HashMap<String, String>();
                uuid = gattCharacteristic.getUuid().toString();
                currentCharaData.put(
                        LIST_NAME, SampleGattAttributes.lookup(uuid, unknownCharaString));
                currentCharaData.put(LIST_UUID, uuid);
                gattCharacteristicGroupData.add(currentCharaData);

                if(uuid.equals(SampleGattAttributes.DOG_CHARACTERISTIC_CONFIG)){
                    Log.e(TAG, "uuid characteristic detected");

                    final int charaProp = gattCharacteristic.getProperties();
                    if ((charaProp | BluetoothGattCharacteristic.PROPERTY_READ) > 0) {
                        Log.e(TAG, "gatt characteristics read!");
                        // If there is an active notification on a characteristic, clear
                        // it first so it doesn't update the data field on the user interface.
                        if (mNotifyCharacteristic != null) {
                            mBluetoothLeService.setCharacteristicNotification(
                                    mNotifyCharacteristic, false);
                            mNotifyCharacteristic = null;
                        }
                        mBluetoothLeService.readCharacteristic(gattCharacteristic);

                    }
                    if ((charaProp | BluetoothGattCharacteristic.PROPERTY_NOTIFY) > 0) {
                        Log.e(TAG, "gatt characteristics notify!");
                        mNotifyCharacteristic = gattCharacteristic;
                        mBluetoothLeService.setCharacteristicNotification(
                                gattCharacteristic, true);

                    }
                }

            }
            mGattCharacteristics.add(charas);
            gattCharacteristicData.add(gattCharacteristicGroupData);
        }

    }

    private void displayGattServices1(List<BluetoothGattService> gattServices) {
        if (gattServices == null) return;
        Log.e(TAG, "1display gatt services not null.");
        String uuid = null;
        String unknownServiceString = getResources().getString(R.string.unknown_service);
        String unknownCharaString = getResources().getString(R.string.unknown_characteristic);

        mGattCharacteristics1 = new ArrayList<ArrayList<BluetoothGattCharacteristic>>();

        // Loops through available GATT Services.
        for (BluetoothGattService gattService : gattServices) {
            HashMap<String, String> currentServiceData = new HashMap<String, String>();
            uuid = gattService.getUuid().toString();
            currentServiceData.put(
                    LIST_NAME, SampleGattAttributes.lookup(uuid, unknownServiceString));
            currentServiceData.put(LIST_UUID, uuid);
            gattServiceData1.add(currentServiceData);

            ArrayList<HashMap<String, String>> gattCharacteristicGroupData =
                    new ArrayList<HashMap<String, String>>();
            List<BluetoothGattCharacteristic> gattCharacteristics =
                    gattService.getCharacteristics();
            ArrayList<BluetoothGattCharacteristic> charas =
                    new ArrayList<BluetoothGattCharacteristic>();

            // Loops through available Characteristics.
            for (BluetoothGattCharacteristic gattCharacteristic : gattCharacteristics) {
                charas.add(gattCharacteristic);
                HashMap<String, String> currentCharaData = new HashMap<String, String>();
                uuid = gattCharacteristic.getUuid().toString();
                currentCharaData.put(
                        LIST_NAME, SampleGattAttributes.lookup(uuid, unknownCharaString));
                currentCharaData.put(LIST_UUID, uuid);
                gattCharacteristicGroupData.add(currentCharaData);

                if (uuid.equals(SampleGattAttributes.DOG_CHARACTERISTIC_CONFIG)) {
                    Log.e(TAG, "1uuid characteristic detected");

                    final int charaProp = gattCharacteristic.getProperties();
                    if ((charaProp | BluetoothGattCharacteristic.PROPERTY_READ) > 0) {
                        Log.e(TAG, "1gatt characteristics read!");
                        // If there is an active notification on a characteristic, clear
                        // it first so it doesn't update the data field on the user interface.
                        if (mNotifyCharacteristic1 != null) {
                            mBluetoothLeService1.setCharacteristicNotification(
                                    mNotifyCharacteristic1, false);
                            mNotifyCharacteristic1 = null;
                        }
                        mBluetoothLeService1.readCharacteristic(gattCharacteristic);

                    }
                    if ((charaProp | BluetoothGattCharacteristic.PROPERTY_NOTIFY) > 0) {
                        Log.e(TAG, "1gatt characteristics notify!");
                        mNotifyCharacteristic1 = gattCharacteristic;
                        mBluetoothLeService1.setCharacteristicNotification(
                                gattCharacteristic, true);

                    }
                }

            }
            mGattCharacteristics1.add(charas);
            gattCharacteristicData1.add(gattCharacteristicGroupData);
        }

    }
}

我所做的是，一旦获得我想要连接的 2 个地址，我就会初始化所有必要的连接、服务和广播接收器。但是，我收到的 bluetoothLeGatt 消息是一样的。根据它连接到 Dog 或 Cat block ，我会得到以下几行:

data = dog
1data = dog

来自 LogCat。似乎它们连接到同一台设备。

我检查了我的代码，我什至硬编码了地址，但无济于事。

Answer 1

我已经与多台设备建立了连接并且工作正常。我还制作了一项用于扫描的服务和一项用于每次 ble 通信的服务。

请确保不要在通信部分使用绑定(bind)服务，因为断开连接可能是个问题(在我的情况下)。

对于扫描部分，我制作了一个字符串列表，其中包含 Mac 地址。当我在我的扫描仪中找到一个设备时，我通过 broadcastreceiver 将该设备发送到我的主要 Activity ，然后我将它传输到它的服务。所以每个连接都在自己的服务中运行，有自己的广播接收器和过滤器设置。

为确保这不是您的广播接收器的问题，请在您立即显示输出的每个服务中创建一个控制台日志。我怀疑您的设备与同一服务器有两个连接。