GVKun编程网logo

IOS 与 OSX BLE：实例化 CBCentralManager - 为 iOS 编码

2

对于IOS与OSXBLE：实例化CBCentralManager-为iOS编码感兴趣的读者，本文将提供您所需要的所有信息，并且为您提供关于AndroidBLEApp只能订阅1个BLE设备的特性通知、A

对于IOS 与 OSX BLE：实例化 CBCentralManager - 为 iOS 编码感兴趣的读者，本文将提供您所需要的所有信息，并且为您提供关于Android BLE App 只能订阅 1 个 BLE 设备的特性通知、Android BLE：连接和订阅 2 个 BLE 外围设备的特征通知、BLE 设备在通过 iOS 上的免提配置文件呼叫时断开连接，原因为 722 步骤系统诊断日志、bleManager.startDeviceScan 不适用于 iOS react-native-ble-plx的宝贵知识。

本文目录一览：

IOS 与 OSX BLE：实例化 CBCentralManager - 为 iOS 编码

IOS 与 OSX BLE：实例化 CBCentralManager - 为 iOS 编码

如何解决IOS 与 OSX BLE：实例化 CBCentralManager - 为 iOS 编码

我正在学习 iOS 与 OSX BLE。
我注意到我无法在 iOS 中实例化 CBCentralManager 因为：

[CoreBluetooth] xpc connection invalid
Unsupported

与通过 OSX 相比，因为 iOS 平台没有“应用沙盒”特性，我可以在其中设置为 BLE 使用。

这是我的 iOS 代码：

import SwiftUI

struct ContentView: View {
    @Observedobject var bleManager = BLEManager()

    var body: some View {
        ZStack {
            Color("Background")
            Text("Hello")
        }
    }
}


class BLEManager: NSObject,ObservableObject,CBCentralManagerDelegate {
    var centralManager: CBCentralManager!

    override init() {
        super.init()
        centralManager = CBCentralManager(delegate: self,queue: nil)
    }

    public func centralManagerDidUpdateState(_ central: CBCentralManager) {
        switch central.state {
        case .poweredOn:
            print("power is on")

        case .resetting:
            print("Resetting")
        case .unsupported:
            print("Unsupported")
        case .unauthorized:
            print("UnAuthorized")
        case .unkNown:
            print("UnKNown")
        case .poweredOff:
            print("Powered OFF")
        @unkNown default:
            print("**** Default ****")
        }
    }
}

这是必需的 .plist 条目：

enter image description here

我知道 iPhone 可以是 BLE 中心或外围设备。

简单问题：如何为真正的 iOS CBCentralMaster 编码？

我只是在这里采取一些小步骤：为外围检测编码。
...然后从那里继续。

解决方法

您是在模拟器上运行（不受支持）而不是在设备上运行？

,

查看主要的 Core Bluetooth 文档：

如果它的 Info.plist 不包含它需要访问的数据类型的使用说明键，你的应用就会崩溃。要访问 iOS 13 或之后链接的应用程序上的核心蓝牙 API，请包含 NSBluetoothAlwaysUsageDescription 键。在 iOS 12 及更早版本中，包含 NSBluetoothPeripheralUsageDescription 以访问蓝牙外设数据。

Android BLE App 只能订阅 1 个 BLE 设备的特性通知

Android BLE App 只能订阅 1 个 BLE 设备的特性通知

如何解决Android BLE App 只能订阅 1 个 BLE 设备的特性通知

我是 Android 新手。我正在尝试从 2 个 BLE 设备订阅特征通知。现在，我的应用程序只能从第一个设备接收 BLE 数据。 我知道 BLE 是串行通信，所以我必须等到 onDescriptorWrite() 回调被调用，然后才能为第二个设备启用通知。我们每次只能有 1 个 GATT 操作。 我的问题是：

  1. 如何修改onDescriptorWrite()？ Thread.sleep() 延迟方法没有帮助。

  2. 有些人提到使用队列来添加/删除某些东西？

    1.  public void setCharacteristicNotification(BluetoothGattCharacteristic characteristic,boolean enabled,int device) {
    2.  if (mBluetoothAdapter == null || mBluetoothGatt == null || mBluetoothGatt1 == null) {
    3.      Log.e(TAG,"BluetoothAdapter not initialized");
    4.      return;
    5.  }
    6.  if(device == 0) {
    7.      mBluetoothGatt.setCharacteristicNotification(characteristic,enabled);
    8.      BluetoothGattDescriptor descriptor = characteristic.getDescriptor(UUID.fromString(SampleGattAttributes.CLIENT_CHaraCTERISTIC_CONfig));
    9.      descriptor.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE);
    10.      mBluetoothGatt.writeDescriptor(descriptor);
    11.      try {
    12.          Thread.sleep(100);
    13.      } catch (InterruptedException e) {
    14.          e.printstacktrace();
    15.      }
    16.      Log.e(TAG,"Device #0 is done for notification!");
    17.  }
    18.  else if(device == 1){
    19.      mBluetoothGatt1.setCharacteristicNotification(characteristic,"Device #1 is done for notification!");
    20.  }

    }

    1.  private final BluetoothGattCallback mGattCallback = new BluetoothGattCallback() {
    2.  @Override
    3.  public void onConnectionStateChange(BluetoothGatt gatt,int status,int newState) {
    4.      String intentAction;
    5.      if (newState == BluetoothProfile.STATE_CONNECTED) {
    6.          intentAction = ACTION_GATT_CONNECTED;
    7.          mConnectionState = STATE_CONNECTED;
    8.          broadcastUpdate(intentAction);
    9.          Log.e(TAG,"Connected to GATT server #0.");
    10.          // Attempts to discover services after successful connection.
    11.          Log.e(TAG,"Attempting to start service discovery #0:" + mBluetoothGatt.discoverServices());
    13.      } else if (newState == BluetoothProfile.STATE_disCONNECTED) {
    14.          intentAction = ACTION_GATT_disCONNECTED;
    15.          mConnectionState = STATE_disCONNECTED;
    16.          Log.e(TAG,"disconnected from GATT server #0.");
    17.          broadcastUpdate(intentAction);
    18.      }
    19.  }
    21.  @Override
    22.  public void onServicesdiscovered(BluetoothGatt gatt,int status) {
    23.      if (status == BluetoothGatt.GATT_SUCCESS) {
    24.          broadcastUpdate(ACTION_GATT_SERVICES_disCOVERED);
    25.      } else {
    26.          Log.e(TAG,"onServicesdiscovered received: " + status);
    27.      }
    28.  }
    30.  @Override
    31.  public void onCharacteristicRead(BluetoothGatt gatt,BluetoothGattCharacteristic characteristic,int status) {
    32.      if (status == BluetoothGatt.GATT_SUCCESS) {
    33.          broadcastUpdate(ACTION_DATA_AVAILABLE,characteristic,0);
    34.      }
    35.      try {
    36.          Thread.sleep(700);
    37.      }catch(InterruptedException ex) {
    38.          Thread.currentThread().interrupt();
    39.      }
    40.      Log.e(TAG,"onCHAR READ");
    41.  }
    43.  @Override
    44.  public void onCharacteristicChanged(BluetoothGatt gatt,BluetoothGattCharacteristic characteristic) {
    45.      broadcastUpdate(ACTION_DATA_AVAILABLE,0);
    46.      try {
    47.          Thread.sleep(700);
    48.      }catch(InterruptedException ex) {
    49.          Thread.currentThread().interrupt();
    50.      }
    51.      Log.e(TAG,"onCharacteristicChanged #0 = ACTION_DATA_AVAILABLE,Done! ");
    52.  }
    54.  @Override
    55.  public void onDescriptorWrite(BluetoothGatt gatt,BluetoothGattDescriptor descriptor,int status) {
    56.      super.onDescriptorWrite(gatt,descriptor,status);
    58.      // Do something here ????????????
    60.      // Thread.sleep() delay method doesn''t help
    61.      try {
    62.          Thread.sleep(700);
    63.      }catch(InterruptedException ex) {
    64.          Thread.currentThread().interrupt();
    65.      }
    66.      Log.e(TAG,"onDescriptorWrite #0,Done! ");
    67.  }

    };

解决方法

  1.  mBluetoothGatt1.setCharacteristicNotification(characteristic,enabled);
  2.  BluetoothGattDescriptor descriptor = characteristic.getDescriptor(UUID.fromString(SampleGattAttributes.CLIENT_CHARACTERISTIC_CONFIG));
  3.  descriptor.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE);
  4.  mBluetoothGatt.writeDescriptor(descriptor);

我认为应该是：

  1.  mBluetoothGatt1.setCharacteristicNotification(characteristic,enabled);
  2.  BluetoothGattDescriptor descriptor = characteristic.getDescriptor(UUID.fromString(SampleGattAttributes.CLIENT_CHARACTERISTIC_CONFIG));
  3.  descriptor.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE);
  4.  mBluetoothGatt1.writeDescriptor(descriptor);

Android BLE：连接和订阅 2 个 BLE 外围设备的特征通知

Android BLE：连接和订阅 2 个 BLE 外围设备的特征通知

如何解决Android BLE：连接和订阅 2 个 BLE 外围设备的特征通知

我使用了两个 BLE 外围传感器和 1 个手机（中央）。每个 BLE 外围设备都运行良好（单独测试）。

我遵循了 BluetoothLeGatt> 示例。我的手机是HUAWEI Mate 10，使用Android 10版本，支持BLE 4.2。

在我的 Android BLE 应用程序中，按下第一页上的连接按钮后，应用程序将自动连接到名称为“BC805M BLE ADC1”和“BC805M BLE ADC2”的 2 个 BLE 设备。

该应用程序似乎可以成功连接 2 个 BLE 设备。但是，没有收到数据（订阅特征通知失败）。 BluetoothGattCallback.onCharacteristicChanged() 方法永远不会被触发。因此，该操作永远不会变为“ACTION_DATA_AVAILABLE”。

BLE App screenshot 1

BLE App screenshot 2

我知道 BLE 通信是串行的。有些人建议在 BluetoothGattCallback() 中使用“onDescriptorWrite()”。但是，我不完全了解如何做到这一点。我在这里附上了我的 Android Studio 项目。如果有人能找到问题，我们将不胜感激。

  1. public class DeviceControlActivity extends Activity {
  2. private final static String TAG = DeviceControlActivity.class.getSimpleName();
  3. public static final String EXTRAS_DEVICE_NAME = "DEVICE_NAME";
  4. public static final String EXTRAS_DEVICE_ADDRESS = "DEVICE_ADDRESS";
  5. public static final String NUMBER_OF_DEVICE = "NUMBER OF DEVICE";
  6. public static final String EXTRAS_DEVICE_NAME_1 = "DEVICE_NAME1";
  7. public static final String EXTRAS_DEVICE_ADDRESS_1 = "DEVICE_ADDRESS1";
  8. public static final String NUMBER_OF_DEVICE_1 = "NUMBER OF DEVICE1";
  10. private TextView mConnectionState;
  11. private TextView mdatafield;
  12. private TextView mThumb;
  13. private TextView mIndex;
  14. private TextView mThumb1;
  15. private TextView mIndex1;
  17. private String mDeviceName;
  18. private String mDeviceAddress;
  19. private String mDeviceName1;
  20. private String mDeviceAddress1;
  22. private int DEVICE_NUMBER;
  23. private int DEVICE_NUMBER1;
  24. private int TOTAL_DEVICE;
  26. private BluetoothLeService mBluetoothLeService;
  28. private ArrayList<ArrayList<BluetoothGattCharacteristic>> mGattcharacteristics =
  29.         new ArrayList<ArrayList<BluetoothGattCharacteristic>>();
  30. private ArrayList<ArrayList<BluetoothGattCharacteristic>> mGattcharacteristics1 =
  31.         new ArrayList<ArrayList<BluetoothGattCharacteristic>>();
  33. private boolean mConnected = false;
  34. private BluetoothGattCharacteristic mNotifyCharacteristic;
  35. private BluetoothGattCharacteristic mNotifyCharacteristic1;
  37. private final String ServiceUUID = "6e400001-b5a3-f393-e0a9-e50e24dcca9e";     
  38. private final String CharUUID    = "6e400003-b5a3-f393-e0a9-e50e24dcca9e";      
  39. private final String LIST_NAME   = "NAME";
  40. private final String LIST_UUID   = "UUID";
  43. // Code to manage Service lifecycle.
  44. private final ServiceConnection mServiceConnection = new ServiceConnection() {
  46.     @Override
  47.     public void onServiceConnected(ComponentName componentName,IBinder service) {
  48.         Log.d(TAG,"Service Connected Called");
  49.         mBluetoothLeService = ((BluetoothLeService.LocalBinder) service).getService();
  50.         if (!mBluetoothLeService.initialize()) {
  51.             finish();
  52.         }
  53.         mBluetoothLeService.connect(mDeviceAddress,0);
  54.         mBluetoothLeService.connect(mDeviceAddress1,1);
  55.     }
  57.     @Override
  58.     public void onServicedisconnected(ComponentName componentName) {
  59.         Log.d(TAG,"Service disConnected Called");
  60.         mBluetoothLeService = null;
  61.     }
  62. };
  65. private final broadcastReceiver mGattUpdateReceiver = new broadcastReceiver() {
  66.     @Override
  67.     public void onReceive(Context context,Intent intent) {
  68.         final String action = intent.getAction();
  69.         if (BluetoothLeService.ACTION_GATT_CONNECTED.equals(action)) {
  70.             mConnected = true;
  71.             updateConnectionState(R.string.connected);
  72.             invalidateOptionsMenu();
  73.             Log.e(TAG,"ACTION_GATT_CONNECTED ");
  74.         } else if (BluetoothLeService.ACTION_GATT_disCONNECTED.equals(action)) {
  75.             Log.e(TAG,"WHEN IS ACTION GATT disCONNECTED");
  76.             mConnected = false;
  77.             updateConnectionState(R.string.disconnected);
  78.             invalidateOptionsMenu();
  79.             Log.e(TAG,"ACTION_GATT_disCONNECTED ");
  80.             clearUI();
  81.         } else if (BluetoothLeService.ACTION_GATT_SERVICES_disCOVERED.equals(action)) {
  82.             Log.e(TAG,"ACTION_GATT_SERVICE_disCOVERED ");
  83.             updateGattServices(mBluetoothLeService.getSupportedGattServices(0),0);
  84.             try {
  85.                 Thread.sleep(700);
  86.             }catch(InterruptedException ex) {
  87.                 Thread.currentThread().interrupt();
  88.             }
  89.             Log.e(TAG,"getSupportedGattServices() is done for device #0");
  90.             updateGattServices(mBluetoothLeService.getSupportedGattServices(1),1);
  91.             try {
  92.                 Thread.sleep(700);
  93.             }catch(InterruptedException ex) {
  94.                 Thread.currentThread().interrupt();
  95.             }
  96.             Log.e(TAG,"getSupportedGattServices() is done for device #1");
  97.             updateDATA();
  98.         } else if (BluetoothLeService.ACTION_DATA_AVAILABLE.equals(action)) {
  99.             Log.d(TAG,"ACTION_DATA_AVAILABLE ");
  100.             mBluetoothLeService.readCharacteristic(mNotifyCharacteristic,0);
  101.             displayData(intent.getStringExtra(BluetoothLeService.EXTRA_DATA),0);
  102.             mBluetoothLeService.readCharacteristic(mNotifyCharacteristic1,1);
  103.             displayData(intent.getStringExtra(BluetoothLeService.EXTRA_DATA1),1);
  104.         }
  105.     }
  106. };
  108. private final boolean updateDATA(){
  109.     int servicePos = 0;
  110.     int charPos = 0;
  112.     if(mGattcharacteristics!=null&&mGattcharacteristics.size()!=0){
  113.         final BluetoothGattCharacteristic characteristic = mGattcharacteristics.get(servicePos).get(charPos);
  114.         final int charPro = characteristic.getProperties();
  115.         if((charPro|BluetoothGattCharacteristic.PROPERTY_READ)>0){
  116.             if(mNotifyCharacteristic!= null){
  117.                 mBluetoothLeService.setCharacteristicNotification(mNotifyCharacteristic,false,0);
  118.             }
  119.         }
  120.         mBluetoothLeService.readCharacteristic(characteristic,0);
  121.         if ((charPro | BluetoothGattCharacteristic.PROPERTY_NOTIFY) > 0) {
  122.             Log.d(TAG,"PROPER_NOTIFY > 0");
  123.             Log.d(TAG," ");
  124.         }
  125.         return true;
  126.     }
  127.     return false;
  128. }
  130. private void clearUI() {
  131.     mdatafield.setText(R.string.no_data);
  132. }
  134. @Override
  135. public void onCreate(Bundle savedInstanceState) {
  136.     Log.e(TAG,"2.2 onCreate() starts! ");
  137.     super.onCreate(savedInstanceState);
  138.     setContentView(R.layout.gatt_services_characteristics);
  140.     final Intent intent = getIntent();
  141.     mDeviceName = intent.getStringExtra(EXTRAS_DEVICE_NAME);
  142.     mDeviceAddress = intent.getStringExtra(EXTRAS_DEVICE_ADDRESS);
  143.     mDeviceName1 = intent.getStringExtra(EXTRAS_DEVICE_NAME_1);
  144.     mDeviceAddress1=intent.getStringExtra(EXTRAS_DEVICE_ADDRESS_1);
  145.     DEVICE_NUMBER=intent.getIntExtra(NUMBER_OF_DEVICE,0);
  146.     DEVICE_NUMBER1=intent.getIntExtra(NUMBER_OF_DEVICE_1,0);
  149.     ((TextView) findViewById(R.id.device_address)).setText(mDeviceAddress+" AND "+mDeviceAddress1);
  150.     mConnectionState = (TextView) findViewById(R.id.connection_state);
  151.     mdatafield = (TextView) findViewById(R.id.data_value);
  152.     mThumb = (TextView) findViewById(R.id.Thumb);
  153.     mIndex = (TextView) findViewById(R.id.Index);
  154.     mThumb1 = (TextView) findViewById(R.id.Thumb1);
  155.     mIndex1 = (TextView) findViewById(R.id.Index1);
  157.     Log.d(TAG,"MY DEVICE NAME "+mDeviceName);
  158.     Log.d(TAG,"MY DEVICE ADDRESS "+mDeviceAddress);
  159.     Log.d(TAG,"MY DEVICE NUMBER "+DEVICE_NUMBER);
  160.     Log.d(TAG,"MY DEVICE NAME1 "+mDeviceName1);
  161.     Log.d(TAG,"MY DEVICE ADDRESS1 "+mDeviceAddress1);
  162.     Log.d(TAG,"MY DEVICE NUMBER1 "+DEVICE_NUMBER1);
  163.     getActionBar().setTitle(mDeviceName+" "+mDeviceName1);
  164.     getActionBar().setdisplayHomeAsUpEnabled(true);
  165.     Intent gattServiceIntent = new Intent(this,BluetoothLeService.class);
  166.     bindService(gattServiceIntent,mServiceConnection,BIND_AUTO_CREATE);
  167. }
  169. @Override
  170. protected void onResume() {
  171.     Log.e(TAG,"2.2 onResume is Called");
  172.     super.onResume();
  173.     registerReceiver(mGattUpdateReceiver,makeGattUpdateIntentFilter());
  174.     if (mBluetoothLeService != null) {
  175.         boolean result = mBluetoothLeService.connect(mDeviceAddress,0);
  176.         boolean result1 = mBluetoothLeService.connect(mDeviceAddress1,1);
  177.         Log.d(TAG,"Connect request result = " + result+" "+result1);
  178.     }
  179. }
  181. @Override
  182. protected void onPause() {
  183.     Log.d(TAG,"onPause is called");
  184.     super.onPause();
  185.     unregisterReceiver(mGattUpdateReceiver);
  186. }
  188. @Override
  189. protected void onDestroy() {
  190.     Log.d(TAG,"onDestroy is Called");
  191.     super.onDestroy();
  192.     unbindService(mServiceConnection);
  193.     mBluetoothLeService = null;
  194. }
  196. @Override
  197. public boolean onCreateOptionsMenu(Menu menu) {
  198.     getMenuInflater().inflate(R.menu.gatt_services,menu);
  199.     if (mConnected) {
  200.         menu.findItem(R.id.menu_connect).setVisible(false);
  201.         menu.findItem(R.id.menu_disconnect).setVisible(true);
  202.     } else {
  203.         menu.findItem(R.id.menu_connect).setVisible(true);
  204.         menu.findItem(R.id.menu_disconnect).setVisible(false);
  205.     }
  206.     return true;
  207. }
  209. @Override
  210. public boolean onoptionsItemSelected(MenuItem item) {
  211.     switch(item.getItemId()) {
  212.         case R.id.menu_connect:
  213.             mBluetoothLeService.connect(mDeviceAddress,0);
  214.             mBluetoothLeService.connect(mDeviceAddress1,1);
  215.             return true;
  216.         case R.id.menu_disconnect:
  217.             Log.d(TAG,"FirsT DEVICE"+DEVICE_NUMBER);
  218.             mBluetoothLeService.disconnect();
  219.             return true;
  220.         case android.R.id.home:
  221.             Log.d(TAG,"HOME IS pressed");
  222.             onBackpressed();
  223.             return true;
  224.     }
  225.     return super.onoptionsItemSelected(item);
  226. }
  228. private void updateConnectionState(final int resourceId) {
  229.     runOnUiThread(new Runnable() {
  230.         @Override
  231.         public void run() {
  232.             mConnectionState.setText(resourceId);
  233.         }
  234.     });
  235. }
  237. private void displayData(String data,int device) {
  238.     if (data != null && device ==0) {
  239.         mThumb1.setText(data.substring(1,4));
  240.         mIndex1.setText(data.substring(5,8));
  241.     }
  242.     else if(data != null && device == 1) {
  243.         mThumb.setText(data.substring(1,4));
  244.         mIndex.setText(data.substring(5,8));
  245.     }
  246. }
  248. private void updateGattServices(List<BluetoothGattService> gattServices,int device) {
  249.     if (gattServices == null) return;
  250.     String uuid = null;
  251.     String unkNownServiceString = getResources().getString(R.string.unkNown_service);
  252.     String unkNownCharaString = getResources().getString(R.string.unkNown_characteristic);
  253.     ArrayList<HashMap<String,String>> gattServiceData = new ArrayList<HashMap<String,String>>();
  255.     if(device ==0) {
  256.         mGattcharacteristics = new ArrayList<ArrayList<BluetoothGattCharacteristic>>();
  257.         Log.e(TAG,"mGattcharacteristics is created for device #0");
  258.     }
  259.     else if(device ==1) {
  260.         mGattcharacteristics1 = new ArrayList<ArrayList<BluetoothGattCharacteristic>>();
  261.         Log.e(TAG,"mGattcharacteristics is created for device #1");
  262.     }
  264.     int i=0;
  265.     int j=0;
  266.     // Loops through available GATT Services.
  267.     Log.e(TAG,"Start For Loop");
  268.     for (BluetoothGattService gattService : gattServices) {
  269.         Log.e(TAG,"Service index = " + i);
  270.         HashMap<String,String> currentServiceData = new HashMap<String,String>();
  271.         uuid = gattService.getUuid().toString();
  272.         if(uuid.equals(ServiceUUID)) {
  273.             Log.e(TAG,"Selected Service index = " + i);
  274.             currentServiceData.put(LIST_NAME,SampleGattAttributes.lookup(uuid,unkNownServiceString));
  275.             currentServiceData.put(LIST_UUID,"");
  276.             gattServiceData.add(currentServiceData);
  277.             ArrayList<HashMap<String,String>> gattCharacteristicGroupData = new ArrayList<HashMap<String,String>>();
  278.             List<BluetoothGattCharacteristic> gattcharacteristics = gattService.getcharacteristics();
  279.             ArrayList<BluetoothGattCharacteristic> charas = new ArrayList<BluetoothGattCharacteristic>();
  281.             // Loops through available characteristics.
  282.             for (BluetoothGattCharacteristic gattCharacteristic : gattcharacteristics) {
  283.                 Log.e(TAG,"Characteristic index = " + j);
  284.                 charas.add(gattCharacteristic);
  285.                 HashMap<String,String> currentCharaData = new HashMap<String,String>();
  286.                 uuid = gattCharacteristic.getUuid().toString();
  287.                 if(uuid.equals(CharUUID)) {
  288.                     Log.e(TAG,"Selected Characteristic index = " + j);
  289.                     currentCharaData.put(
  290.                             LIST_NAME,unkNownCharaString));
  291.                     currentCharaData.put(LIST_UUID,"");
  292.                     gattCharacteristicGroupData.add(currentCharaData);
  293.                     if(device ==0){
  294.                         mNotifyCharacteristic=gattCharacteristic;
  295.                     }
  296.                     else if(device ==1){
  297.                         mNotifyCharacteristic1=gattCharacteristic;
  298.                     }
  299.                 }
  300.                 j = j +1;
  301.             }
  302.             if(device ==0){
  303.                 mGattcharacteristics.add(charas);
  304.             }
  305.             else if(device ==1){
  306.                 mGattcharacteristics1.add(charas);
  307.             }
  308.         }
  309.         i = i + 1 ;
  310.     }
  312. }
  314. private static IntentFilter makeGattUpdateIntentFilter() {
  315.     final IntentFilter intentFilter = new IntentFilter();
  316.     intentFilter.addAction(BluetoothLeService.ACTION_GATT_CONNECTED);
  317.     intentFilter.addAction(BluetoothLeService.ACTION_GATT_disCONNECTED);
  318.     intentFilter.addAction(BluetoothLeService.ACTION_GATT_SERVICES_disCOVERED);
  319.     intentFilter.addAction(BluetoothLeService.ACTION_DATA_AVAILABLE);
  320.     return intentFilter;
  321. }

}

  1. public class BluetoothLeService extends Service {
  2. private final static String TAG = BluetoothLeService.class.getSimpleName();
  4. private BluetoothManager mBluetoothManager;
  5. private BluetoothAdapter mBluetoothAdapter;
  6. private String mBluetoothDeviceAddress;
  7. private String mBluetoothDeviceAddress1;
  8. private BluetoothGatt mBluetoothGatt;
  9. private BluetoothGatt mBluetoothGatt1;
  10. private int mConnectionState = STATE_disCONNECTED;
  12. private static final int STATE_disCONNECTED = 0;
  13. private static final int STATE_CONNECTING = 1;
  14. private static final int STATE_CONNECTED = 2;
  16. public final static String ACTION_GATT_CONNECTED =
  17.         "com.example.bluetooth.le.ACTION_GATT_CONNECTED";
  18. public final static String ACTION_GATT_disCONNECTED =
  19.         "com.example.bluetooth.le.ACTION_GATT_disCONNECTED";
  20. public final static String ACTION_GATT_SERVICES_disCOVERED =
  21.         "com.example.bluetooth.le.ACTION_GATT_SERVICES_disCOVERED";
  22. public final static String ACTION_DATA_AVAILABLE =
  23.         "com.example.bluetooth.le.ACTION_DATA_AVAILABLE";
  24. public final static String EXTRA_DATA =
  25.         "com.example.bluetooth.le.EXTRA_DATA";
  26. public final static String EXTRA_DATA1 =
  27.         "com.example.bluetooth.le.EXTRA_DATA1";
  29. public final static UUID ServiceUUID2 = UUID.fromString("6e400001-b5a3-f393-e0a9-e50e24dcca9e");
  30. public final static UUID CharUUID2    = UUID.fromString("6e400003-b5a3-f393-e0a9-e50e24dcca9e");
  32. // Implements callback methods for GATT events that the app cares about.  For example,// connection change and services discovered.
  33. private final BluetoothGattCallback mGattCallback = new BluetoothGattCallback() {
  34.     @Override
  35.     public void onConnectionStateChange(BluetoothGatt gatt,int status,int newState) {
  36.         String intentAction;
  37.         if (newState == BluetoothProfile.STATE_CONNECTED) {
  38.             intentAction = ACTION_GATT_CONNECTED;
  39.             mConnectionState = STATE_CONNECTED;
  40.             broadcastUpdate(intentAction);
  41.             Log.e(TAG,"Connected to GATT server.");
  42.             // Attempts to discover services after successful connection.
  43.             Log.e(TAG,"Attempting to start service discovery:" + mBluetoothGatt.discoverServices());
  45.         } else if (newState == BluetoothProfile.STATE_disCONNECTED) {
  46.             intentAction = ACTION_GATT_disCONNECTED;
  47.             mConnectionState = STATE_disCONNECTED;
  48.             Log.e(TAG,"disconnected from GATT server.");
  49.             broadcastUpdate(intentAction);
  50.         }
  51.     }
  53.     @Override
  54.     public void onServicesdiscovered(BluetoothGatt gatt,int status) {
  55.         if (status == BluetoothGatt.GATT_SUCCESS) {
  56.             broadcastUpdate(ACTION_GATT_SERVICES_disCOVERED);
  57.         } else {
  58.             Log.e(TAG,"onServicesdiscovered received: " + status);
  59.         }
  60.     }
  62.     @Override
  63.     public void onCharacteristicRead(BluetoothGatt gatt,BluetoothGattCharacteristic characteristic,int status) {
  64.         if (status == BluetoothGatt.GATT_SUCCESS) {
  65.             broadcastUpdate(ACTION_DATA_AVAILABLE,characteristic,0);
  66.         }
  67.         Log.e(TAG,"onCHAR READ");
  68.     }
  70.     @Override
  71.     public void onCharacteristicChanged(BluetoothGatt gatt,BluetoothGattCharacteristic characteristic) {
  72.         broadcastUpdate(ACTION_DATA_AVAILABLE,0);
  73.         Log.e(TAG,"onCharacteristicChanged #0 = ACTION_DATA_AVAILABLE,Done! ");
  74.     }
  76.     @Override
  77.     public void onDescriptorWrite(BluetoothGatt gatt,BluetoothGattDescriptor descriptor,int status) {
  78.         super.onDescriptorWrite(gatt,descriptor,status);
  79.         Log.e(TAG,"onDescriptorWrite #0,Done! ");
  80.     }
  83. };
  85. private final BluetoothGattCallback mGattCallback1 = new BluetoothGattCallback() {
  86.     @Override
  87.     public void onConnectionStateChange(BluetoothGatt gatt,"Connected to GATT server.");
  88.             Log.e(TAG,"Attempting to start service discovery:" +
  89.                     mBluetoothGatt1.discoverServices());
  90.         } else if (newState == BluetoothProfile.STATE_disCONNECTED) {
  91.             intentAction = ACTION_GATT_disCONNECTED;
  92.             mConnectionState = STATE_disCONNECTED;
  93.             Log.e(TAG,1);
  94.         }
  95.         Log.e(TAG,"onCHAR READ in callback 1");
  96.     }
  98.     @Override
  99.     public void onCharacteristicChanged(BluetoothGatt gatt,1);
  100.         Log.e(TAG,int status) {
  101.         Log.e(TAG,"onDescriptorWrite starts");
  102.         if (descriptor.getUuid().equals(SampleGattAttributes.CLIENT_CHaraCTERISTIC_CONfig)) {
  103.             BluetoothGattCharacteristic characteristic = gatt
  104.                     .getService(ServiceUUID2)
  105.                     .getCharacteristic(CharUUID2);
  106.             gatt.readCharacteristic(characteristic);
  107.         }
  108.         Log.e(TAG,"onDescriptorWrite #1,Done!");
  109.     }
  110. };
  112. private void broadcastUpdate(final String action) {
  113.     final Intent intent = new Intent(action);
  114.     sendbroadcast(intent);
  115. }
  117. private void broadcastUpdate(final String action,final BluetoothGattCharacteristic characteristic,int device) {
  118.     final Intent intent = new Intent(action);
  120.     final byte[] data = characteristic.getValue();
  122.     if (data != null && data.length > 0&&device ==0) {
  123.         final StringBuilder stringBuilder = new StringBuilder(data.length);
  124.         for(byte byteChar : data)
  125.             stringBuilder.append(String.format("%02X ",byteChar));
  126.         String DATA = stringBuilder.toString();
  127.         Log.d(TAG,"MY DATA IN HEX " + DATA);
  128.         String DecData =HexAsciiConverter.HexAscii2Decimal(DATA);
  129.         Log.d(TAG,"MY DATA IN DECIMAL "+ DecData);
  130.         intent.putExtra(EXTRA_DATA," " + DecData);
  131.     }
  132.     else if( data != null && data.length > 0 && device ==1 ){
  133.         final StringBuilder stringBuilder = new StringBuilder(data.length);
  134.         for(byte byteChar : data)
  135.             stringBuilder.append(String.format("%02X ","MY DATA IN DECIMAL "+ DecData);
  136.         intent.putExtra(EXTRA_DATA1," " + DecData);
  137.     }
  138.     sendbroadcast(intent);
  139. }
  141. public class LocalBinder extends Binder {
  142.     BluetoothLeService getService() {
  143.         return BluetoothLeService.this;
  144.     }
  145. }
  147. @Override
  148. public IBinder onBind(Intent intent) {
  149.     return mBinder;
  150. }
  152. @Override
  153. public boolean onUnbind(Intent intent) {
  154.     close();
  155.     return super.onUnbind(intent);
  156. }
  158. private final IBinder mBinder = new LocalBinder();
  160. public boolean initialize() {
  161.     // For API level 18 and above,get a reference to BluetoothAdapter through
  162.     // BluetoothManager.
  163.     if (mBluetoothManager == null) {
  164.         mBluetoothManager = (BluetoothManager) getSystemService(Context.BLUetoOTH_SERVICE);
  165.         if (mBluetoothManager == null) {
  166.             Log.e(TAG,"Unable to initialize BluetoothManager.");
  167.             return false;
  168.         }
  169.     }
  171.     mBluetoothAdapter = mBluetoothManager.getAdapter();
  172.     if (mBluetoothAdapter == null) {
  173.         Log.e(TAG,"Unable to obtain a BluetoothAdapter.");
  174.         return false;
  175.     }
  177.     return true;
  178. }
  180. public boolean connect(final String address,int devicenum) {
  181.     if (mBluetoothAdapter == null || address == null) {
  182.         Log.e(TAG,"BluetoothAdapter not initialized or unspecified address.");
  183.         return false;
  184.     }
  186.     // PrevIoUsly connected device.  Try to reconnect.
  187.     if ((mBluetoothDeviceAddress != null && address.equals(mBluetoothDeviceAddress))
  188.             || (mBluetoothDeviceAddress1!=null && address.equals(mBluetoothDeviceAddress1))) {
  189.         Log.e(TAG,"Trying to use an existing mBluetoothGatt for connection.");
  190.         if (devicenum==0&&mBluetoothGatt.connect()) {
  191.             mConnectionState = STATE_CONNECTING;
  192.             return true;
  193.         }
  194.         else if(devicenum==1 && mBluetoothGatt1.connect()) {
  195.             mConnectionState = STATE_CONNECTING;
  196.             return true;
  197.         }
  198.         else{
  199.             return false;
  200.         }
  201.     }
  203.     final BluetoothDevice device = mBluetoothAdapter.getRemoteDevice(address);
  204.     if (device == null) {
  205.         Log.e(TAG,"Device not found.  Unable to connect.");
  206.         return false;
  207.     }
  208.     if(devicenum==0){
  209.         mBluetoothGatt1 = device.connectGatt(this,mGattCallback);
  210.         mBluetoothDeviceAddress= address;
  211.         mConnectionState = STATE_CONNECTING;
  212.         Log.e(TAG,"GATT CALLBACK #0 !  "+address);
  213.     }
  214.     else if(devicenum ==1){
  215.         mBluetoothGatt = device.connectGatt(this,mGattCallback1);
  216.         mBluetoothDeviceAddress1=address;
  217.         mConnectionState = STATE_CONNECTING;
  218.         Log.e(TAG,"GATT CALLBACK #1 !  "+address);
  219.     }
  220.     Log.e(TAG,"Trying to create a new connection.");
  221.     return true;
  222. }
  225. public void disconnect() {
  226.     if (mBluetoothAdapter == null || mBluetoothGatt == null) {
  227.         Log.e(TAG,"BluetoothAdapter not initialized");
  228.         return;
  229.     }
  230.     mBluetoothGatt.disconnect();
  232.     if(mBluetoothGatt1!=null){
  233.         mBluetoothGatt1.disconnect();
  234.     }
  235. }
  238. public void close() {
  239.     if (mBluetoothGatt == null) {
  240.         return;
  241.     }
  242.     mBluetoothGatt.close();
  243.     mBluetoothGatt1.close();
  244.     mBluetoothGatt1 = null;
  245.     mBluetoothGatt = null;
  246. }
  248. public void readCharacteristic(BluetoothGattCharacteristic characteristic,int device) {
  249.     if (mBluetoothAdapter == null || mBluetoothGatt == null) {
  250.         Log.e(TAG,"BluetoothAdapter not initialized");
  251.         return;
  252.     }
  253.     if (device == 0) {
  254.         mBluetoothGatt.readCharacteristic(characteristic);
  255.     }
  256.     else if(device ==1){
  257.         mBluetoothGatt1.readCharacteristic(characteristic);
  258.     }
  261. }
  263. public void setCharacteristicNotification(BluetoothGattCharacteristic characteristic,boolean enabled,"BluetoothAdapter not initialized");
  264.         return;
  265.     }
  266.     if(device == 0) {
  267.         mBluetoothGatt.setCharacteristicNotification(characteristic,enabled);
  269.         BluetoothGattDescriptor descriptor = characteristic.getDescriptor(UUID.fromString(SampleGattAttributes.CLIENT_CHaraCTERISTIC_CONfig));
  270.         descriptor.setValue(BluetoothGattDescriptor.ENABLE_INDICATION_VALUE);
  271.         mBluetoothGatt.writeDescriptor(descriptor);
  272.         try {
  273.             Thread.sleep(100);
  274.         } catch (InterruptedException e) {
  275.             e.printstacktrace();
  276.         }
  277.         Log.e(TAG,"Device #0 is done for notification!");
  278.     }
  279.     else if(device == 1){
  280.         mBluetoothGatt1.setCharacteristicNotification(characteristic,"Device #1 is done for notification!");
  281.     }
  284. }
  286. public List<BluetoothGattService> getSupportedGattServices(int device) {
  287.     if (mBluetoothGatt == null) return null;
  288.     if(device ==0) {
  289.         return mBluetoothGatt.getServices();
  290.     }
  291.     else {
  292.         return mBluetoothGatt1.getServices();
  293.     }
  294. }

}

enter image description here

enter image description here

BLE 设备在通过 iOS 上的免提配置文件呼叫时断开连接，原因为 722 步骤系统诊断日志

BLE 设备在通过 iOS 上的免提配置文件呼叫时断开连接，原因为 722 步骤系统诊断日志

如何解决BLE 设备在通过 iOS 上的免提配置文件呼叫时断开连接，原因为 722 步骤系统诊断日志

我们开发了自己的 BLE 设备并连接到 iPhone。我们发现通过 HFP 进行并行呼叫时，它会在 2 到 3 分钟后断开连接的问题。 （例如：使用汽车音响系统、信息娱乐 HUD 等）。

有谁知道 722 代表什么状态。我们如何解决这个问题？ 谢谢。

步骤

  1. iPhone 连接到 Our Device（在后台模式下持续收集数据。）
  2. iPhone 连接到 Car Audio Systems
  3. iPhone 使用 IM 应用（通过 HFP）拨打电话。
  4. 2 ~ 3 分钟后，iPhone 和Our Device 之间的连接因722 原因断开。

系统诊断日志

default 2021-02-09 17:04:57.813721 +0800    bluetoothd  Server.LE.Connection    LE Link disconnected for handle 0x14c804720 address <private> with reason 722 encryptionPending 0
default 2021-02-09 17:04:57.813774 +0800    bluetoothd  Server.LE.Connection    LE ConnManager disconnection complete reason 722 address=<private> localRole=Master
default 2021-02-09 17:04:57.816296 +0800    bluetoothd  Stack.GATT   _GATT_LE_disconnectedCB on handle 0x000000014C804720 with reason  STATUS 722
default 2021-02-09 17:04:57.816977 +0800    bluetoothd  Server.LE   Device "E2278A91-B7B6-2122-696C-BE887487C8D7" set last connected time to 1612890297
default 2021-02-09 17:04:57.820707 +0800    bluetoothd  Stack.CL     Removing peer ID 0 for handle 0x000000014C804720
default 2021-02-09 17:04:57.820869 +0800    bluetoothd  Stack.HCI    Releasing LE connection 0x0041
default 2021-02-09 17:04:57.822551 +0800    bluetoothd  Server.LE.Connection    Device "E2278A91-B7B6-2122-696C-BE887487C8D7" does not require low latency
default 2021-02-09 17:04:57.822580 +0800    bluetoothd  Server.LE.Connection    Found link-ready device calling disconnection notification
default 2021-02-09 17:04:57.822582 +0800    bluetoothd  Server.LE.Connection    disconnected from device "E2278A91-B7B6-2122-696C-BE887487C8D7" successfully (locally-initiated)
default 2021-02-09 17:04:57.822585 +0800    bluetoothd  Server.LE.Connection    linkReady:1 disconnectDevice:0 localRole:0 reason:722 result:0
default 2021-02-09 17:04:57.824928 +0800    bluetoothd  Server.LE.Security  Removing temporary security keys for device <private>

bleManager.startDeviceScan 不适用于 iOS react-native-ble-plx

bleManager.startDeviceScan 不适用于 iOS react-native-ble-plx

如何解决bleManager.startDeviceScan 不适用于 iOS react-native-ble-plx

我正在尝试使用 react-native-ble-plx 将网关与 React 本机应用程序配对。 下面的源代码在 Android 中运行良好，而在 iOS 中，bleManager.startDeviceScan() 不会被触发。这一步之后什么都没有发生。

非常感谢任何帮助！

源代码：

  1. const connectBLE = () => {
  2.     const subscription = bleManager.onStateChange(async (state) => {
  3.       if (state === ''PoweredOn'') {
  4.           subscription.remove();
  5.           scanAndConnect();
  6.       } 
  7.   };
  8. }
  9.   const scanAndConnect = () => {
  10.     bleManager.startDeviceScan(null,null,async (error,device) => {
  11.       if (error) {
  12.         showToast(error,''error'');
  13.         console.log(''Handle error - scanning will be stopped automatically'');
  14.         return;
  15.       }
  16.       console.log(''Devices'');
  17.       console.log(device.name);
  18.       // Check if it is a device you are looking for based on device name
  19.       if (device.name === "BLE_0006") {
  20.         // Stop scanning as we have found the device.
  21.         bleManager.stopDeviceScan();
  22.         // Establish Device connection.
  23.         device
  24.           .connect()
  25.           .then((deviceData) => {
  26.             /** Show Toast on Device disconnect */
  27.             bleManager.onDevicedisconnected(
  28.               deviceData.id,(connectionError,connectionData) => {
  29.                 if (connectionError) {
  30.                   console.log(connectionError);
  31.                 }
  32.                 console.log(''Device is disconnected'');
  33.                 console.log(connectionData);
  34.               },);
  35.             /** discover All Services and characteristics */
  36.             return device.discoverAllServicesAndcharacteristics();
  37.           })
  38.           .then(async (deviceObject) => {
  39.             console.log(''deviceObject'');
  40.             console.log(deviceObject);
  41.             /** Subscribe for the Readable service */
  42.             device.monitorCharacteristicForService(
  43.               Enum.bleConnectionInfo.customServiceUUID,Enum.bleConnectionInfo.readCharacteristicUUID,(error,characteristic) => {
  44.                 if (error) {
  45.                   console.log(''Error in monitorCharacteristicForService'');
  46.                   console.log(error.message);
  47.                   return;
  48.                 }
  49.                 console.log(characteristic.uuid,characteristic.value);
  50.                 ]);
  51.               },);
  52.           })
  53.           .catch((error) => {
  54.             console.warn(error);
  55.             showToast(error,''error'');
  56.           });
  57.       }
  58.     });
  59.   }

解决方法

这可能对某人有帮助！

通过将 bleManager() 初始化移到功能组件之外解决了该问题。

关于IOS 与 OSX BLE：实例化 CBCentralManager - 为 iOS 编码的介绍现已完结，谢谢您的耐心阅读，如果想了解更多关于Android BLE App 只能订阅 1 个 BLE 设备的特性通知、Android BLE：连接和订阅 2 个 BLE 外围设备的特征通知、BLE 设备在通过 iOS 上的免提配置文件呼叫时断开连接，原因为 722 步骤系统诊断日志、bleManager.startDeviceScan 不适用于 iOS react-native-ble-plx的相关知识，请在本站寻找。

本文标签：

上一篇php – WordPress：如何在任何管理页面上显示元数据？（wordpress管理页面地址）

下一篇Xcode 12.5，为 iOS-armv7 构建，但尝试链接为 iOS-arm64 问题构建的文件

相关文章