Android BLE蓝牙详细解读

比眉伴天荒 2022-03-09 11:48 821阅读 0赞

代码地址如下：
http://www.demodashi.com/demo/15062.html

1626170261b439a1_w_540_h_304_f_jpeg_s_13037
随着物联网时代的到来，越来越多的智能硬件设备开始流行起来，比如智能手环、心率检测仪、以及各式各样的智能家具和玩具类产品。安卓4.3(API 18)为BLE的核心功能提供平台支持和API，App可以利用它来发现设备、查询服务和读写特性。相比传统的蓝牙，BLE更显著的特点是低功耗。本文主要讲解Android低功耗蓝牙的api使用以及蓝牙扫描、连接、发送数据、接收数据等一系列操作，并主要介绍本人封装的BleLib蓝牙库，非常适合蓝牙初学者使用，只需要一行代码注入就OK了，而且用法也极其简单，下面会专门讲解BleLib库的使用。

目录

  • 原生API的详细讲解

  • BleLib库的优点

  • 如何使用该库

  • BleLib库的详细分析

废话不说，先来看下Demo中的效果图：

Demo预览图.gif

一、原生API的详细讲解

在BLE协议中，有两个角色，周边（Periphery）和中央（Central）；周边是数据提供者，中央是数据使用/处理者，一个中央可以同时连接多个周边，但是一个周边某一时刻只能连接一个中央。
首先使用蓝牙就不得不说BluetoothGatt和BluetoothGattCallback这两个类，该类继承自BluetoothProfile，BluetoothGatt作为中央来使用和处理数据，通过BluetoothGatt可以连接设备（connect）,发现服务（discoverServices），并把相应地属性返回到BluetoothGattCallback，BluetoothGattCallback返回中央的状态和周边提供的数据。

1. 蓝牙开发流程：

我们蓝牙操作的主要目的就是为了拿到中央BluetoothGatt这个对象，进而进行接下来的所有一系列操作，如下：

  1. 1.BluetoothManager bluetoothManager 
  2.         = (BluetoothManager) getSystemService(Context.BLUETOOTH_SERVICE);
  4. 2.BluetoothAdapt btAdapter = bluetoothManager.getAdapter();
  6. 3.btAdapter.startLeScan( BluetoothAdapter.LeScanCallback);
  8. 4.从LeScanCallback中得到BluetoothDevice 
  9. public void onLeScan(BluetoothDevice device, int rssi, byte[] scanRecord) {…..}
  11. 5.用BluetoothDevice得到BluetoothGatt：         gatt = device.connectGatt(this, true, gattCallback);

这时总算拿到中央BluetoothGatt了，它有很多的方法，调用这些方法，你就可以通过BluetoothGattCallback和周边BluetoothGattServer交互了。

2. 主要类的大致理解：
  • BluetoothProfile： 一个通用的规范，按照这个规范来收发数据。

  • BluetoothManager：通过BluetoothManager来获取BluetoothAdapter

    1. 如：BluetoothManager bluetoothManager = (BluetoothManager) getSystemService(Context.BLUETOOTH_SERVICE);

  • BluetoothAdapter：一个Android系统只有一个BluetoothAdapter ，通过BluetoothManager 获取

    1. BluetoothAdapter mBluetoothAdapter = bluetoothManager.getAdapter();
  • BluetoothGattDescriptor：可以看成是描述符，对Characteristic的描述，包括范围、计量单位等。
  • BluetoothGattService：服务，Characteristic的集合。

  • BluetoothGattCallback：已经连接上设备，对设备的某些操作后返回的结果。这里必须提醒下，已经连接上设备后的才可以返回，没有返回的认真看看有没有连接上设备。

    1. private BluetoothGattCallback GattCallback = new BluetoothGattCallback() {
    3.   // 这里有9个要实现的方法，看情况要实现那些，用到那些就实现那些
    5.   public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState){};
    7.   public void onCharacteristicWrite(BluetoothGatt gatt, 
    8.                       BluetoothGattCharacteristic characteristic, int status){
    10.                       };            
    12.           };
    13.  BluetoothDevice device = mBluetoothAdapter.getRemoteDevice(address);
    15.  BluetoothGatt gatt = device.connectGatt(this, false, mGattCallback);
3. 上面所说的9个要实现的方法，所对应蓝牙交互的主要对应关系：

162617026206538d_w_200_h_180_f_jpeg_s_5906

(1) notification对应onCharacteristicChanged;

  1. gatt.setCharacteristicNotification(characteristic, true);

该方法一般是在发现服务后，进行设置的，设置该方法的目的是让硬件在数据改变的时候，发送数据给app，app则通过onCharacteristicChanged方法回调给用户，从参数中可获取到回调回来的数据。

(2) readCharacteristic对应onCharacteristicRead;

  1. gatt.readCharacteristic(characteristic);

(3) writeCharacteristic对应onCharacteristicWrite;

  1. gatt.wirteCharacteristic(mCurrentcharacteristic);

(4) 连接蓝牙或者断开蓝牙 对应 onConnectionStateChange;

  1. bluetoothDevice.connectGatt(this, false, mGattCallback);
  2. 或
  3. gatt.disconnect();(断开连接后务必记得gatt.close();)

(5) readDescriptor对应onDescriptorRead;

  1. gatt.readDescriptor(descriptor);

(6) writeDescriptor对应onDescriptorWrite;

  1. gatt.writeDescriptor(descriptor);

(7) readRemoteRssi对应onReadRemoteRssi;

  1. gatt.readRemoteRssi();

(8) executeReliableWrite对应onReliableWriteCompleted;

  1. gatt.executeReliableWrite();

(9) discoverServices对应onServicesDiscovered

  1. gatt.discoverServices();
开启蓝牙所具备的权限：
  1. <uses-permission android:name="android.permission.BLUETOOTH"/>
  2. <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
  3. <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>
  4. <uses-permission android:name="android.permission.BLUETOOTH_ADMIN"/>
  5. <uses-feature android:name="android.hardware.bluetooth_le" android:required="true"/>

如果 android.hardware.bluetooth_le设置为false,可以安装在不支持的设备上使用，判断是否支持蓝牙4.0用以下代码就可以了，如：

  1. if (!getPackageManager().hasSystemFeature(PackageManager.FEATURE_BLUETOOTH_LE)) {
  2.           Toast.makeText(this, “设备不支持蓝牙4.0”, Toast.LENGTH_SHORT).show();
  3.           finish();
  4.     }

对蓝牙的启动关闭操作：

1、利用系统默认开启蓝牙对话框

  1. if (mBluetoothAdapter == null || !mBluetoothAdapter.isEnabled()) {
  2.     Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
  3.     startActivityForResult(enableBtIntent, REQUEST_ENABLE_BT);
  4.   }

2、后台打开蓝牙，不做任何提示，这个也可以用来自定义打开蓝牙对话框啦

  1. mBluetoothAdapter.enable();

3、后台关闭蓝牙

  1. mBluetoothAdapter.disable();

二、BleLib库的优点

  • 最简洁的植入（近乎一行代码）

16261702635cc307_w_140_h_181_f_jpeg_s_6228

  1. private void initBle() {
  2.     mBle = Ble.options()
  3.             .setLogBleExceptions(true)//是否打印蓝牙日志（非正式打包设置true，便于调试）
  4.             .setThrowBleException(true)//是否抛出蓝牙异常
  5.             .setAutoConnect(true)//是否自动连接
  6.             .setConnectFailedRetryCount(3)
  7.             .setConnectTimeout(10 * 1000)//连接超时时长（默认10*1000 ms）
  8.             .setScanPeriod(12 * 1000)//扫描时长（默认10*1000 ms）
  9.             .setUuid_service(UUID.fromString("0000fee9-0000-1000-8000-00805f9b34fb"))//主服务的uuid
  10.             .setUuid_write_cha(UUID.fromString("d44bc439-abfd-45a2-b575-925416129600"))//可写特征的uuid
  11.             .create(getApplicationContext());
  12.  }
  • 最大程度简化了代码量

16261702636b3403_w_140_h_128_f_jpeg_s_4460

有对比才有伤害，那就来看下原生api调用蓝牙流程和该库之间的对比：

例如扫描设备
原生API写法：
  1. private void scanLeDevice(final boolean enable) {  
  2.         if (enable) {  
  3.         // 经过预定扫描期后停止扫描  
  4.         mHandler.postDelayed(new Runnable() {  
  5.             @Override  
  6.             public void run() {  
  7.                 mScanning = false;  
  8.                 mBluetoothAdapter.stopLeScan(mLeScanCallback);  
  9.             }  
  10.         }, SCAN_PERIOD);  
  11.             mScanning = true;  
  12.             mBluetoothAdapter.startLeScan(mLeScanCallback);  
  13.         } else {  
  14.         mScanning = false;  
  15.         mBluetoothAdapter.stopLeScan(mLeScanCallback);  
  16.         }  
  17.         ...  
  18.     }  
  20. 然后在mLeScanCallback的回调中拿到扫描结果：
  22.     // Device scan callback.  
  23.     private BluetoothAdapter.LeScanCallback mLeScanCallback =  
  24.         new BluetoothAdapter.LeScanCallback() {  
  25.     @Override  
  26.     public void onLeScan(final BluetoothDevice device, int rssi,  
  27.             byte[] scanRecord) {  
  28.         runOnUiThread(new Runnable() {  
  29.            @Override  
  30.            public void run() {  
  31.                ...
  32.            }  
  33.        });  
  34.     }
BleLib中扫描的写法：
  1. mBle.startScan(scanCallback);
  2. 回调结果：
  3. BleScanCallback<BleDevice> scanCallback = new BleScanCallback<BleDevice>() {
  4.         @Override
  5.         public void onLeScan(final BleDevice device, int rssi, byte[] scanRecord) {
  6.                 ...
  7.             }
  8.         }
  9.     };
  • 提供了独一无二的OTA升级接口（即蓝牙硬件进行更新升级的接口）

    这绝对是其他蓝牙库所没有的，具体API请看下面的库使用步骤

三、如何使用该库

1. 初始化蓝牙（动态授权蓝牙操作权限、打开蓝牙、判断设备是否支持蓝牙等操作请看DEMO）
  1. private void initBle() {
  2.         mBle = Ble.options()
  3.                 .setLogBleExceptions(true)//是否打印蓝牙日志（非正式打包设置true，便于调试）
  4.                 .setThrowBleException(true)//是否抛出蓝牙异常
  5.                 .setAutoConnect(true)//是否自动连接
  6.                 .setConnectFailedRetryCount(3)//连接失败的重试次数
  7.                 .setConnectTimeout(10 * 1000)//连接超时时长（默认10*1000 ms）
  8.                 .setScanPeriod(12 * 1000)//扫描时长（默认10*1000 ms）
  9.                 .setUuid_service(UUID.fromString("0000fee9-0000-1000-8000-00805f9b34fb"))//主服务的uuid
  10.                 .setUuid_write_cha(UUID.fromString("d44bc439-abfd-45a2-b575-925416129600"))//可写特征的uuid
  11.                 .create(getApplicationContext());
  12.      }
2. 扫描周边设备
  1. mBle.startScan(scanCallback);
  2. //扫描回调
  3. BleScanCallback<BleDevice> scanCallback = new BleScanCallback<BleDevice>() {
  4.         @Override
  5.         public void onLeScan(final BleDevice device, int rssi, byte[] scanRecord) {
  6.             ...
  7.             //获取到蓝牙设备对象，根据自身需求进行操作（库中已进行相同设备的过滤）
  8.         }
  9.     };
3.开始连接
  1. mBle.connect(device, connectCallback);               
  2. //连接回调
  3. private BleConnCallback<BleDevice> connectCallback = new BleConnCallback<BleDevice>() {
  4.         @Override
  5.         public void onConnectionChanged(BleDevice device) {
  6.             if (device.isConnected()) {
  7.                 //连接成功之后设置通知（切记，很重要）
  8.                 setNotify(device);
  9.             }
  10.             Log.e(TAG, "onConnectionChanged: " + device.isConnected());
  11.         }
  13.         @Override
  14.         public void onConnectException(BleDevice device, int errorCode) {
  15.             super.onConnectException(device, errorCode);
  16.             Toast.makeText(BleActivity.this, "连接异常，异常状态码:" + errorCode, Toast.LENGTH_SHORT).show();
  17.         }
  18.     };

连接异常状态码可参阅该项目的[wiki]

4.设置通知及回调
  1. private void setNotify(BleDevice device) {
  2.          /*连接成功后，设置通知*/
  3.         mBle.startNotify(device, new BleNotiftCallback<BleDevice>() {
  4.             @Override
  5.             public void onChanged(BleDevice device, BluetoothGattCharacteristic characteristic) {
  6.                 Log.e(TAG, "onChanged: 表示返回硬件MCU发来的数据"+Arrays.toString(characteristic.getValue()));
  7.             }
  9.             @Override
  10.             public void onReady(BleDevice device) {
  11.                 Log.e(TAG, "onReady: 表示一切准备就绪，可以进行读写(发送数据或者读取数据)的标志");
  12.             }
  14.             @Override
  15.             public void onServicesDiscovered(BluetoothGatt gatt) {
  16.                 Log.e(TAG, "onServicesDiscovered is success ");
  17.             }
  19.             @Override
  20.             public void onNotifySuccess(BluetoothGatt gatt) {
  21.                 Log.e(TAG, "onNotifySuccess is success ");
  22.             }
  23.         });
  24.     }

当收到onChanged(BluetoothGattCharacteristic characteristic)回调时,则说明蓝牙设备的数据发生改变了，通知程序作出改变。还有很多回调，他们对应的情况不懂得可以参考上面的原生API的详细讲解。

5.读取远程Rssi
  1. mBle.readRssi(mBle.getConnetedDevices().get(0), new BleReadRssiCallback<BleDevice>() {
  2.                     @Override
  3.                     public void onReadRssiSuccess(int rssi) {
  4.                         super.onReadRssiSuccess(rssi);
  5.                         Log.e(TAG, "onReadRssiSuccess: " + rssi);
  6.                         Toast.makeText(BleActivity.this, "onReadRssiSuccess:"+ rssi, Toast.LENGTH_SHORT).show();
  7.                     }
  8.                 });
6.主动读取数据
  1. public void read(BleDevice device) {
  2.         boolean result = mBle.read(device, new BleReadCallback<BleDevice>() {
  3.             @Override
  4.             public void onReadSuccess(BluetoothGattCharacteristic characteristic) {
  5.                 super.onReadSuccess(characteristic);
  6.                 byte[] data = characteristic.getValue();
  7.                 Log.w(TAG, "onReadSuccess: " + Arrays.toString(data));
  8.             }
  9.         });
  10.         if (!result) {
  11.             Log.d(TAG, "读取数据失败!");
  12.         }
7.写入数据
  1. boolean result = mBle.write(device, changeLevelInner(), new BleWriteCallback<BleDevice>() {
  2.             @Override
  3.             public void onWriteSuccess(BluetoothGattCharacteristic characteristic) {
  4.                 Toast.makeText(BleActivity.this, "发送数据成功", Toast.LENGTH_SHORT).show();
  5.             }
  6.         });
  7.         if (!result) {
  8.             Log.e(TAG, "changeLevelInner: " + "发送数据失败!");
  9.         }
8.发送大数据包（如：文件等）
  1. try {
  2.         //获取整个文件的总字节
  3.         byte[]data = toByteArray(getAssets().open("WhiteChristmas.bin"));
  4.         //发送大数据量的包(参数请查阅Demo Code)
  5.         mBle.writeEntity(mBle.getConnetedDevices().get(0), data, 20, 50, new BleWriteEntityCallback<BleDevice>() {
  6.             @Override
  7.             public void onWriteSuccess() {
  8.                 L.e("writeEntity", "onWriteSuccess");
  9.             }
  11.             @Override
  12.             public void onWriteFailed() {
  13.                 L.e("writeEntity", "onWriteFailed");
  14.             }
  15.         });
  16.     } catch (IOException e) {
  17.         e.printStackTrace();
  18.     }
9.设置MTU(BLE4.2)
  1. if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP){
  2.         //此处第二个参数  不是特定的   比如你也可以设置500   但是如果设备不支持500个字节则会返回最大支持数
  3.         mBle.setMTU(mBle.getConnetedDevices().get(0).getBleAddress(), 250, new BleMtuCallback<BleDevice>() {
  4.             @Override
  5.             public void onMtuChanged(BleDevice device, int mtu, int status) {
  6.                 super.onMtuChanged(device, mtu, status);
  7.                 ToastUtil.showToast("最大支持MTU："+mtu);
  8.             }
  9.         });
  10.     }else {
  11.         ToastUtil.showToast("设备不支持MTU");
  12.     }
10.OTA升级
  1. //找到你需要升级文件的路径(一般情况都是保存再服务器上，一旦有更新会自动提示，然后APP下载并保存到本地，生成对应的file对象)
  2. File file = new File(...);
  3. //读写SD卡权限，此处略（6.0及以上需添加)
  4. OtaManager mOtaManager = new OtaManager(BleActivity.this);
  5. boolean result = mOtaManager.startOtaUpdate(file, (BleDevice) mBle.getConnetedDevices().get(0), mBle);
  6. Log.e("OTA升级结果:", result + "");

四、BleLib库封装的详细分析

分析之前先来张BleLib库API的结构图供大家参考（下图是1.x库的结构，API名称部分与当前有点不同）：

BleLib库结构图.png

16261702848c7a3c_w_240_h_180_f_jpeg_s_6319

1、我们先来看一下该库的结构，以及每个类的作用。如下图：

结构.png

Ble：

该类提供了几乎所有你需要用到的方法，包括蓝牙扫描、连接、断开、蓝牙当前连接状态等等，管理了蓝牙操作的所有接口和方法。

BleDevice：

该类的主要是来描述并记录蓝牙的属性和状态，如记录蓝牙名称、蓝牙MAC地址、蓝牙别名（即修改之后的名称）、蓝牙连接状态等。

162617028ea700f0_w_200_h_200_f_jpeg_s_7042

BleStatus：

该类是蓝牙状态类，定义了蓝牙扫描、连接、通知使能、发送、接收等状态的常量值（连接异常等状态码可参考该类）

BluetoothLeService：

该类是最重要的一个核心蓝牙处理类，主要是蓝牙操作中用到的各个方法的实现类，是整个蓝牙的核心功能实现，Ble是对外提供所有蓝牙操作接口的管理类。

在此要注意一些细节，比如大多数设备扫描的时候会重复扫描到相同蓝牙设备，必须要进行过滤，开发应用时，必须还要进行产品过滤，比如通过设备的广播包过滤，或者通过设备名过滤都是可以的，如下（注意：要根据自己产品提供的广播包进行过滤，下图是我们自己产品的）：

  1. /**
  2.  * Verify the product broadcast parameters
  3.  * @param data Parameter data
  4.  * @return Whether the match
  5.  */
  6. public static boolean matchProduct(byte[] data) {
  7.     if (data == null || data.length <= 0) {
  8.         return false;
  9.     }
  10.     int i = 0;
  11.     do {
  12.         // Read packet size
  13.         int len = data[i++] & 0xff;
  14.         if (len > 0) {
  15.             // Read packet data
  16.             byte[] d = new byte[len];
  17.             int j = 0;
  18.             do {
  19.                 d[j++] = data[i++];
  20.             } while (j < len);
  21.             // Authentication Type and Length
  22.             if (d.length > BROADCAST_SPECIFIC_PRODUCT.length && (d[0] & 0xFF) == BLE_GAP_AD_TYPE_MANUFACTURER_SPECIFIC_DATA) {
  23.                 // Matching product parameters
  24.                 boolean passed = true;
  25.                 for (int x = 0; x < BROADCAST_SPECIFIC_PRODUCT.length; x++) {
  26.                     passed = passed && d[x + 1] == BROADCAST_SPECIFIC_PRODUCT[x];
  27.                 }
  28.                 //Match successful
  29.                 if (passed) {
  30.                     return true;
  31.                 }
  32.             }
  33.         }
  35.     } while (i < data.length);
  36.     return false;
  37. }

OK，要注意的细节问题已经介绍的差不多了，如果感兴趣的朋友可以去应用该库到自己的项目中。
Android BLE蓝牙详细解读

代码地址如下：
http://www.demodashi.com/demo/15062.html

注：本文著作权归作者，由demo大师发表，拒绝转载，转载需要作者授权

发表评论

表情：
评论列表 （有 0 条评论，821人围观）

还没有评论，来说两句吧...

相关阅读

    相关 android 蓝牙BLE

    直接上代码吧，完整的程序代码如下： 首先是MainActivity，本段代码完成了子模转换和保存数据的功能，并将要发送的数据整理成了和作者的小伙伴说好的格式。需要注意的是，

    ゞ 浴缸里的玫瑰ゞ 浴缸里的玫瑰/ 0 赞/ 424 阅读

    相关 Android Ble蓝牙开发（客户端）

    最近项目里面需要集成一个蓝牙的连接功能，作为一枚刚刚毕业不久的新生，大学几年又白过的。只好在几天内搜搜百度，脑补一下。文章部分内容摘至各大Blog，加上本dust的见解，写了一

    野性酷女野性酷女/ 0 赞/ 654 阅读