首页 > 解决方案 > android 10 在 BLE 蓝牙连接上不起作用

问题描述

用于BLE蓝牙连接的android 10未连接,我也会设置所有权限但我得到连接状态133问题,如何解决这个问题,这里我声明扫描和回调代码,请检查并给出你的想法

但低于 android 10 版本工作正常,只有 android 10 设备上的问题,给出解决问题的想法

private void scanLeDevice(final boolean enable) {
           if (scanner == null) {
               scanner = btAdapter.getBluetoothLeScanner();
           }
           if (scanCallback == null) setScanCallback(null);
       scanner.startScan(createScanFilters(),createScanSettings(),scanCallback);
          isScanning = true;
       }


        ScanCallback scanCallback = new ScanCallback() {
               @RequiresApi(api = Build.VERSION_CODES.M)
               @Override
               public void onScanResult(int callbackType, @NonNull ScanResult scanResult) {
                  if (connectedDevices.containsKey(scanResult.getDevice().getAddress())) {
                      return;
                   }
                   if (connectingDevices.contains(scanResult.getDevice().getAddress())) {
                       // If we're already connected, forget it
                       //Timber.d("Denied connection. Already connecting to  " + scanResult.getDevice().getAddress());
                       return;
                   }
                   if (connectionGovernor != null && !connectionGovernor.shouldConnectToAddress(scanResult.getDevice().getAddress())) {
                       // If the BLEConnectionGovernor says we should not bother connecting to this peer, don't

                       return;
                   }

                   final BluetoothDevice device = btAdapter.getRemoteDevice(scanResult.getDevice().getAddress());
                   if (device == null) {
                       Log.e(TAG, "Device not found.  Unable to connect.");
                   }
                   connectingDevices.add(scanResult.getDevice().getAddress());
                   // connectToDevice(device);
                   Timber.d("Initiating connection to " + scanResult.getDevice().getAddress());

                   device.connectGatt(context, false, mGattCallback, BluetoothDevice.TRANSPORT_LE );

               }

               @Override
               public void onScanFailed(int i) {
                   Timber.e("Scan failed with code " + i);
               }
           }; 



      @NonNull
       BluetoothGattCallback mGattCallback = new BluetoothGattCallback() {
           @Override
           public void onConnectionStateChange(@NonNull BluetoothGatt gatt, int status, int newState) {
               synchronized (connectedDevices) {
                  // It appears that certain events (like disconnection) won't have a GATT_SUCCESS status
                   // even when they proceed as expected, at least with the Motorola bluetooth stack
                   if (status != BluetoothGatt.GATT_SUCCESS)
                       Timber.w("onConnectionStateChange with newState %d and non-success status %s", newState,    gatt.getDevice().getAddress());

                   Set<BluetoothGattCharacteristic> characteristicSet;

                   switch (newState) {
                       case BluetoothProfile.STATE_DISCONNECTING:
                           Timber.d("Disconnecting from " + gatt.getDevice().getAddress());

                           characteristicSet = discoveredCharacteristics.get(gatt.getDevice().getAddress());
                           for (BluetoothGattCharacteristic characteristic : characteristicSet) {
                               if (notifyUUIDs.contains(characteristic.getUuid())) {
                                   Timber.d("Attempting to unsubscribe on disconneting");
                                   setIndictaionSubscription(gatt, characteristic, false);
                               }
                           }
                           discoveredCharacteristics.remove(gatt.getDevice().getAddress());

                           break;

                       case BluetoothProfile.STATE_DISCONNECTED:
                           Timber.d("Disconnected from " + gatt.getDevice().getAddress());
                           connectedDevices.remove(gatt.getDevice().getAddress());
                           connectingDevices.remove(gatt.getDevice().getAddress());
                           if (transportCallback != null)
                               transportCallback.identifierUpdated(BLETransportCallback.DeviceType.CENTRAL,
                                       gatt.getDevice().getAddress(),
                                       Transport.ConnectionStatus.DISCONNECTED,
                                       null);

                           characteristicSet = discoveredCharacteristics.get(gatt.getDevice().getAddress());
                           if (characteristicSet != null) { // Have we handled unsubscription on DISCONNECTING?
                               for (BluetoothGattCharacteristic characteristic : characteristicSet) {
                                   if (notifyUUIDs.contains(characteristic.getUuid())) {
                                       Timber.d("Attempting to unsubscribe before disconnet");
                                       setIndictaionSubscription(gatt, characteristic, false);
                                   }
                               }
                           } else
                           if ( status != BluetoothGatt.GATT_SUCCESS ) {

                               if ( status == 133) {
                                   refreshDeviceCache(gatt);

                               }

                           }
                           gatt.close();                         discoveredCharacteristics.remove(gatt.getDevice().getAddress());
                           break;
                       case BluetoothProfile.STATE_CONNECTED:
                           boolean mtuSuccess = gatt.requestMtu(BLETransport.DEFAULT_MTU_BYTES);

                           Timber.d("Connected to %s. Requested MTU success %b", gatt.getDevice().getAddress(),
                                   mtuSuccess);
                           break;
                   }

                   super.onConnectionStateChange(gatt, status, newState);
               }
           }

           @Override
           public void onMtuChanged(@NonNull BluetoothGatt gatt, int mtu, int status) {
               Timber.d("Got MTU (%d bytes) for device %s. Was changed successfully: %b",
                       mtu,
                       gatt.getDevice().getAddress(),
                       status == BluetoothGatt.GATT_SUCCESS);

               mtus.put(gatt.getDevice().getAddress(), mtu);

               // TODO: Can we craft characteristics and avoid discovery step?
               boolean discovering = gatt.discoverServices();
               Timber.d("Discovering services : " + discovering);
           }

           @Override
           public void onServicesDiscovered(@NonNull BluetoothGatt gatt, int status) {
               if (status == BluetoothGatt.GATT_SUCCESS)
                   Timber.d("Discovered services");
               else
                   Timber.d("Discovered services appears unsuccessful with code " + status);
               // TODO: Keep this here to examine characteristics
               // eventually we should get rid of the discoverServices step
               boolean foundService = false;
               try {
                   List<BluetoothGattService> serviceList = gatt.getServices();
                   for (BluetoothGattService service : serviceList) {
                       if (service.getUuid().equals(serviceUUID)) {
                           Timber.d("Discovered Service");
                           foundService = true;
                           HashSet<BluetoothGattCharacteristic> characteristicSet = new HashSet<>();
                           characteristicSet.addAll(service.getCharacteristics());
                           discoveredCharacteristics.put(gatt.getDevice().getAddress(),    characteristicSet);

                           for (BluetoothGattCharacteristic characteristic : characteristicSet) {
                               if (notifyUUIDs.contains(characteristic.getUuid())) {
                                   setIndictaionSubscription(gatt, characteristic, true);
                               }
                           }
                       }
                   }

                   if (foundService) {
                       synchronized (connectedDevices) {
                           connectedDevices.put(gatt.getDevice().getAddress(), gatt);
                       }
                       connectingDevices.remove(gatt.getDevice().getAddress());
                   }
               } catch (Exception e) {
                   Timber.d("Exception analyzing discovered services " + e.getLocalizedMessage());
                   e.printStackTrace();
               }
               if (!foundService)
                   Timber.d("Could not discover chat service!");
               super.onServicesDiscovered(gatt, status);
           }

           /**
            * Subscribe or Unsubscribe to/from indication of a peripheral's characteristic.
            *
            * After calling this method you must await the result via
            * {@link #onDescriptorWrite(BluetoothGatt, BluetoothGattDescriptor, int)}
            * before performing any other peripheral actions.
            */
           private void setIndictaionSubscription(@NonNull BluetoothGatt peripheral,
                                                  @NonNull BluetoothGattCharacteristic characteristic,
                                                  boolean enable) {

               boolean success = peripheral.setCharacteristicNotification(characteristic, enable);
               Timber.d("Request notification %s %s with sucess %b", enable ? "set" : "unset", characteristic.getUuid().toString(),    success);
               BluetoothGattDescriptor desc = characteristic.getDescriptor(CLIENT_CHARACTERISTIC_CONFIG);
               desc.setValue(enable ? BluetoothGattDescriptor.ENABLE_INDICATION_VALUE :    BluetoothGattDescriptor.DISABLE_NOTIFICATION_VALUE);
               boolean desSuccess = peripheral.writeDescriptor(desc);
               Timber.d("Wrote descriptor with success %b", desSuccess);
           }

           @Override
           public void onDescriptorWrite(@NonNull BluetoothGatt gatt, @NonNull BluetoothGattDescriptor descriptor,
                                         int status) {

               Timber.d("onDescriptorWrite");
               if (status == BluetoothGatt.GATT_SUCCESS && transportCallback != null) {

                   if (Arrays.equals(descriptor.getValue(), BluetoothGattDescriptor.ENABLE_INDICATION_VALUE)) {
                       transportCallback.identifierUpdated(BLETransportCallback.DeviceType.CENTRAL,
                               gatt.getDevice().getAddress(),
                               Transport.ConnectionStatus.CONNECTED,
                               null);

                   } else if (Arrays.equals(descriptor.getValue(), BluetoothGattDescriptor.DISABLE_NOTIFICATION_VALUE)) {
                       Timber.d("disabled indications successfully. Closing gatt");
                       gatt.close();
                   }
               }
           }

           @Override
           public void onCharacteristicChanged(@NonNull BluetoothGatt gatt, @NonNull BluetoothGattCharacteristic characteristic) {
               Timber.d("onCharacteristicChanged %s with %d bytes", characteristic.getUuid().toString().substring(0,5),
                       characteristic.getValue().length);

               if (transportCallback != null)
                   transportCallback.dataReceivedFromIdentifier(BLETransportCallback.DeviceType.CENTRAL,
                           characteristic.getValue(),
                           gatt.getDevice().getAddress());

               super.onCharacteristicChanged(gatt, characteristic);
           }

           @Override
           public void onCharacteristicWrite(@NonNull BluetoothGatt gatt,
                                             @NonNull BluetoothGattCharacteristic characteristic, int status) {

               Timber.d("onCharacteristicWrite with %d bytes", characteristic.getValue().length);
               Exception exception = null;
               if (status != BluetoothGatt.GATT_SUCCESS) {
                   String msg = "Write was not successful with code " + status;
                   Timber.w(msg);
                   exception = new UnknownServiceException(msg);
               }

               if (transportCallback != null)
                   transportCallback.dataSentToIdentifier(BLETransportCallback.DeviceType.CENTRAL,
                           characteristic.getValue(),
                           gatt.getDevice().getAddress(),
                           exception);
           }

           @Override
           public void onReadRemoteRssi(@NonNull BluetoothGatt gatt, int rssi, int status) {
               super.onReadRemoteRssi(gatt, rssi, status);
           }

       };

标签: android

解决方案


现在该应用程序正在更改蓝牙设备支持类型

            device.connectGatt(context, false, mGattCallback, BluetoothDevice.DEVICE_TYPE_LE);

但是现在该应用程序无法在华为设备上运行,如果有任何关于此问题的设备华为的想法


推荐阅读