Android中的实现
1. 扫描广播包
- 首先获取 BluetoothManager 和 BluetoothAdapter
private BluetoothAdapter mBluetoothAdapter;
BluetoothManager bluetoothManager = (BluetoothManager) context.getSystemService(Context.BLUETOOTH_SERVICE);
mBluetoothAdapter= bluetoothManager.getAdapter();
- 开始扫描
/**
* 开始扫描，扫描结果在 BluetoothAdapter.LeScanCallback 中返回
* @param deviceName 扫描的设备名
*/
public void startScan(String deviceName) {
if (mBluetoothAdapter == null) {
// error
return;
}
BluetoothLeScanner scanner = mBluetoothAdapter.getBluetoothLeScanner();
this.mScanning = true;
List<ScanFilter> filters = new ArrayList<>();
ScanFilter filter = new ScanFilter.Builder()
.setDeviceName(deviceName)
.build();
filters.add(filter);
scanner.startScan(filters, new ScanSettings.Builder().setScanMode(ScanSettings.SCAN_MODE_LOW_LATENCY).build(), mScanCallback);
}
这里的扫描设置了过滤的参数，只返回设备名为传入参数的广播。如果要扫描特定的设备，也可以根据设备的Mac地址过滤。或者也可以用不过滤方式扫描，过滤逻辑可以在扫描结果中处理。
private ScanCallback mScanCallback = new ScanCallback() {
@Override
public void onScanResult(int callbackType, ScanResult result) {
// 广播的信息，可以在result中获取
Log.e(TAG, "onScanResult: name: " + result.getDevice().getName() +
", address: " + result.getDevice().getAddress() +
", rssi: " + result.getRssi() + ", scanRecord: " + result.getScanRecord());
}
};
开启蓝牙扫描会增加手机功耗，Android官方也不建议一直进行扫描，因此无论有没有扫描到目标设备，都应该设置一个超时时间，避免长时间扫描。停止扫描指令如下：
public void stopScan() {
BluetoothLeScanner scanner = mBluetoothAdapter.getBluetoothLeScanner();
scanner.stopScan(mScanCallback);
}
2. 建立蓝牙连接
如果发现需要进行蓝牙连接的设备，就可以发起建立蓝牙连接请求：
/**
* 建立蓝牙连接
* @param address 设备的Mac地址
* @result 连接请求是否成功
*/
public boolean connect(Context context, String address) {
if (mBluetoothAdapter == null || address == null) {
Log.w(TAG, "BluetoothAdapter not initialized or unspecified address.");
error();
return false;
}
Log.i(TAG, "connecting ");
// Previously connected device. Try to reconnect.
if (mBluetoothDeviceAddress != null && address.equals(mBluetoothDeviceAddress)
&& mBluetoothGatt != null) {
Log.i(TAG, "尝试使用已有的GATT连接");
if (mBluetoothGatt.connect()) {
return true;
} else {
return false;
}
}
final BluetoothDevice device = mBluetoothAdapter.getRemoteDevice(address);
if (device == null) {
Log.i(TAG, "Device not found. Unable to connect.");
return false;
}
// 连接的核心代码
mBluetoothGatt = device.connectGatt(context, false, mGattCallback);
Log.d(TAG, "Trying to create a new connection.");
return true;
}
连接是否成功可以在回调函数中获取：
private final BluetoothGattCallback mGattCallback = new BluetoothGattCallback() {
@Override
public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
if (newState == BluetoothProfile.STATE_CONNECTED) {
mConnectionState = STATE_CONNECTED;
Log.i(TAG, "Connected to GATT server.");
// 连接成功
...
} else if (newState == BluetoothProfile.STATE_DISCONNECTED) {
mConnectionState = STATE_DISCONNECTED;
// 断开连接
...
} else {
// 其他错误情况
}
}
};
onConnectionStateChange方法在连接状态改变后被调用，status是之前状态，newState是改变后的状态。类BluetoothGattCallback 除了得到连接状态的变化，还可以得到其他信息。稍后会逐步介绍。
3. 发现服务
如果蓝牙连接成功，就可以通过GATT协议进行通讯。前面介绍过，蓝牙的信息是通过特征值（characteristics）和服务（services）的传输。因此首先得获取设备的服务：
public void discoverServices() {
mBluetoothGatt.discoverServices();
}
发现服务的结果在BluetoothGattCallback的另一个方法中返回：
private BleDeviceService mBleDeviceService ;
private final BluetoothGattCallback mGattCallback = new BluetoothGattCallback() {
@Override
public void onServicesDiscovered(BluetoothGatt gatt, int status) {
if (status == BluetoothGatt.GATT_SUCCESS) {
//获取服务成功
//可用gatt.getServices()获取Service，并用BleDeviceService缓存起来，供访问使用。
mBleDeviceService = new BleDeviceService(gatt.getServices());
} else {
//获取服务失败
}
}
};
其中BleDeviceService 用List缓存了相关的Service，并提供了用UUID查询的方法：
public class BleDeviceService {
private final List<BluetoothGattService> bluetoothGattServices;
public BleDeviceService(List<BluetoothGattService> bluetoothGattServices) {
this.bluetoothGattServices = bluetoothGattServices;
}
/**
* 获取全部 BluetoothGattService
*/
public List<BluetoothGattService> getBluetoothGattServices() {
return bluetoothGattServices;
}
/**
* 获取特定 BluetoothGattService
* @param serviceUuid UUID service的标识
* @return BluetoothGattService 查找不到返回null
*/
public BluetoothGattService getService(@NonNull final UUID serviceUuid){
for (BluetoothGattService bluetoothGattService : bluetoothGattServices) {
if (bluetoothGattService.getUuid().equals(serviceUuid)){
return bluetoothGattService;
}
}
return null;
}
/**
* 获取特定特征值
* @param characteristicUuid 特征值UUID
* @return BluetoothGattCharacteristic 特征值，查找不到返回null
*/
public BluetoothGattCharacteristic getCharacteristic(@NonNull UUID serviceUuid,@NonNull UUID characteristicUuid) {
BluetoothGattService bluetoothGattService = getService(serviceUuid);
if (bluetoothGattService != null){
BluetoothGattCharacteristic characteristic = bluetoothGattService.getCharacteristic(characteristicUuid);
if (characteristic != null){
return characteristic;
}
}
return null;
}
}
4. 读写特征值
有了Service的信息，就可以进行读写特征值了，读特征值是获取设备的信息，写特征值是，发送信息给设备。
读特征值：
/**
* 读特征值
*
* @param serviceUUID 服务 UUID
* @param characteristicUUID 特征值 UUID
*/
public void readCharacteristic(String serviceUUID, String characteristicUUID) {
if (mBluetoothAdapter == null || mBluetoothGatt == null) {
Log.w(TAG, "BluetoothAdapter not initialized");
return;
}
boolean isError = false;
if (mBleDeviceService != null) {
BluetoothGattCharacteristic characteristic = mBleDeviceService.getCharacteristic(UUID.fromString(serviceUUID),
UUID.fromString(characteristicUUID));
if (characteristic != null) {
int permission = characteristic.getProperties();
if ((permission & BleConstants.AT_BLE_PERMISSION_CHAR_READ)
== BleConstants.AT_BLE_PERMISSION_CHAR_READ) {
Log.i(TAG, "reading characteristic");
mBluetoothGatt.readCharacteristic(characteristic);
} else {
Log.i(TAG, "read permission denied");
isError = true;
}
} else {
Log.i(TAG, "characteristic is null");
isError = true;
}
} else {
Log.i(TAG, "mBleDeviceService is null");
isError = true;
}
if (isError) {
// 处理错误
}
}
写特征值：
private void write(String serviceUUID, String characteristicUUID, byte[] data) {
if (mBluetoothAdapter == null || mBluetoothGatt == null) {
//错误
return;
}
if (mBleDeviceService != null) {
BluetoothGattCharacteristic characteristic = mBleDeviceService.getCharacteristic(UUID.fromString(serviceUUID),
UUID.fromString(characteristicUUID));
if (characteristic != null) {
int permission = (byte) characteristic.getProperties();
if ((permission & BleConstants.AT_BLE_PERMISSION_CHAR_WRITE)
== BleConstants.AT_BLE_PERMISSION_CHAR_WRITE ||
(permission & BleConstants.AT_BLE_PERMISSION_CHAR_SIGNED_WRITE)
== BleConstants.AT_BLE_PERMISSION_CHAR_SIGNED_WRITE ||
(permission & BleConstants.AT_BLE_PERMISSION_CHAR_WRITE_WITHOUT_RESPONSE)
== BleConstants.AT_BLE_PERMISSION_CHAR_WRITE_WITHOUT_RESPONSE ||
(permission & BleConstants.AT_BLE_PERMISSION_CHAR_RELIABLE_WRITE)
== BleConstants.AT_BLE_PERMISSION_CHAR_RELIABLE_WRITE) {
//可以设置特征值的类型，默认为有应答。
//characteristic.setWriteType(BluetoothGattCharacteristic.WRITE_TYPE_NO_RESPONSE);
characteristic.setValue(data);
mBluetoothGatt.writeCharacteristic(characteristic);
Log.i(TAG, "writing characteristic done");
} else {
Log.i(TAG, "writing permission denied");
//error
}
} else {
Log.i(TAG, "null characteristic");
//error
}
}
}
这里注释的这一行（characteristic.setWriteType(BluetoothGattCharacteristic.WRITE_TYPE_NO_RESPONSE);）需要说明一下，如果不设置，默认的写特征值类型是有应答的。有无应答体现在底层通信上，不会影响到写特征值的回调函数的调用。目前发现区别是：对某些蓝牙芯片，无应答的通讯速率会略快，而且对调大的最大MTU(Maximum Transmission Unit,传输单元)，也会减少出错的几率。
读写是否成功的结果同样也是在回调函数中获得：
private final BluetoothGattCallback mGattCallback = new BluetoothGattCallback() {
@Override
public void onCharacteristicRead(BluetoothGatt gatt,
BluetoothGattCharacteristic characteristic,
int status) {
if (status == BluetoothGatt.GATT_SUCCESS) {
Log.i(TAG, "read characteristic success");
// 通过characteristic.getValue()获取信息
...
} else {
Log.i(TAG, "read characteristic fail " + status);
}
}
@Override
public void onCharacteristicWrite(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
super.onCharacteristicWrite(gatt, characteristic, status);
if (status == BluetoothGatt.GATT_SUCCESS) {
Log.i(TAG, "characteristic write success ");
...
} else {
Log.i(TAG, "characteristic write fail " + status);
...
}
}
};
5. 使能和接收通知
读特征值的方式只能是手机去读取设备的信息，而不能设备主动发送信息过来。如果想要实现设备主动发送信息给手机，必须手机端先使能一个特征值，之后设备就可以通过这个特征值发送信息。
使能的方法：
/**
* 使能通知
*
* @param serviceUUID 服务UUID
* @param characteristicUUID 特征值UUID
* @param notificationFlag 是否开启
*/
public void toggleNotification(String serviceUUID, String characteristicUUID, boolean notificationFlag) {
if ( mBluetoothAdapter == null || mBluetoothGatt == null) {
Log.w(TAG, "BluetoothAdapter not initialized");
// error
return;
}
if (mBleDeviceService != null) {
BluetoothGattCharacteristic characteristic = mBleDeviceService.getCharacteristic(UUID.fromString(serviceUUID),
UUID.fromString(characteristicUUID));
if (characteristic != null) {
int permission = (byte) characteristic.getProperties();
if ((permission & BluetoothGattCharacteristic.PROPERTY_NOTIFY) == BluetoothGattCharacteristic.PROPERTY_NOTIFY) {
UUID CCC = UUID.fromString(BleConstants.CONFIG_DESCRIPTOR);
mBluetoothGatt.setCharacteristicNotification(characteristic, notificationFlag); //Enabled locally
BluetoothGattDescriptor config = characteristic.getDescriptor(CCC);
config.setValue(notificationFlag ? BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE :
BluetoothGattDescriptor.DISABLE_NOTIFICATION_VALUE);
mBluetoothGatt.writeDescriptor(config); //Enabled remotely
} else {
Log.i(TAG, "characteristic has no notification property");
// error
}
} else {
Log.i(TAG, "null characteristic");
// error
}
}
}
获取使能是否成功的结果以及接收设备发送来的信息的回调方法：
private final BluetoothGattCallback mGattCallback = new BluetoothGattCallback() {
@Override
public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
super.onCharacteristicChanged(gatt, characteristic);
Log.i(TAG, "onCharacteristicChanged: " + Arrays.toString(characteristic.getValue()) + " " +
characteristic.getUuid().toString());
// 可以用characteristic.getValue()读取信息。
}
@Override
public void onDescriptorWrite(BluetoothGatt gatt, BluetoothGattDescriptor descriptor, int status) {
super.onDescriptorWrite(gatt, descriptor, status);
if (status == BluetoothGatt.GATT_SUCCESS) {
Log.i(TAG, "Notification/indication enabled successfully");
...
} else {
Log.i(TAG, "Notification/indication enabled failed");
// error
}
}
};
代码中用的是Notification，还有另一个方法是关于Indication的（将toggleNotification方法内的BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE替换为BluetoothGattDescriptor.ENABLE_INDICATION_VALUE），二者的区别也是前者类似TCP后者类似UDP。
5. 断开连接
最后，就是通讯结束后断开连接的方法：
public void disconnect() {
if (mBluetoothAdapter == null || mBluetoothGatt == null) {
Log.i(TAG, "BluetoothAdapter not initialized");
return;
}
mBluetoothGatt.disconnect();
}
