Android蓝牙4.0 Ble读写数据详解 -2
上一篇说了如何扫描与链接蓝牙 这篇文章讲讲与蓝牙的数据传输，与一些踩到的坑。
先介绍一款调试工具，专门调试Ble蓝牙的app。名字叫:nRF-Connect 谷歌应用商店也能下载到。
这里我先连接一个蓝牙设备 贴几个截图。
UUID的话 就相当于钥匙，蓝牙设备当中有通道，那么通道是需要UUID进行匹配的
当连接上设备之后，可以看到UUID的通道 接下来，按照设备厂商提供的文档，找到我们需要的UUID通道
比如说我这里需要的是0x6a的Service通道 然后点开最后一个Service通道查看
展开Service后 可以看到有两个Characteristic通道
我们看Properties属性 一个是NOTIFY 一个是WRITE 也有可能会有READ这个属性的通道
可以拿这个app输出写出指令给蓝牙，在不清楚是蓝牙的问题还是自己的问题的时候，这个工具还是挺好使的。
Notify的话，需要注意这个Descriptors的UUID 这个在注册Notify的时候，需要用到，这里虽然看不全，但是之后可以通过打印得到。
简单说一下这三种属性的通道的用途
WRITE:顾名思义，写的意思，该通道是用来向蓝牙设备写出数据的通道
READ:向蓝牙设备进行读取数据的通道 这个通道有一个坑 后续会详细写上
Notify:该通道需要注册监听，这是一个通知的通道，蓝牙向你传输数据的话，就能直接收到监听。
我这边的话 因为一些原因，所以没有使用READ通道获取数据 只用了Notify通道 当然 也会讲讲怎么使用READ
准备工作
先将UUID管理起来，我这里的话 采用静态常量的形式保存起来了。
public class UUIDManager {
/**
* 服务的UUID
*/
public static final String SERVICE_UUID = "00006a00-0000-1000-8000-00805f9b34fb";
/**
* 订阅通知的UUID
*/
public static final String NOTIFY_UUID = "00006a02-0000-1000-8000-00805f9b34fb";
/**
* 写出数据的UUID
*/
public static final String WRITE_UUID = "00006a02-0000-1000-8000-00805f9b34fb";
/**
* NOTIFY里面的Descriptor UUID
*/
public static final String NOTIFY_DESCRIPTOR = "00002902-0000-1000-8000-00805f9b34fb";
}
处理通知回调接口
蓝牙的数据回调，其实并不是回调到主线程当中，所以如果接收到数据之后，就进行视图操作的话，是会失败的。
所以我打算切换到主线程进行回调，当然，也可以使用EventBus，不过我不喜欢这东西就没去用。
回调接口的话，打算使用list集合存储起来，然后回调到各个需要数据的地方。 创建以下三个类
/**
* Created by Pencilso on 2017/4/20.
* 蓝牙数据回调监听接口
*/
public interface BlueNotifyListener {
public void onNotify(Message notify);
}
/**
* Created by Pencilso on 2017/4/25.
* 处理回调所有接口
*/
public class NotifyThread implements Runnable {
private List listeners;
private Message notify;
@Override
public void run() {
if (notify == null || listeners==null)
return;
try {
Iterator iterator = listeners.iterator();
while (iterator.hasNext()) {
BlueNotifyListener next = iterator.next();
if (next == null)
iterator.remove();
else
next.onNotify(notify);
}
} catch (Exception e) {
e.printStackTrace();
}
}
public void setListeners(List listeners) {
this.listeners = listeners;
}
public void setNotify(Message notify) {
this.notify = notify;
}
}
/**
* Created by Pencilso on 2017/4/26.
* 蓝牙的Code类 用来自定义回调的标识
*/
public class BlueCodeUtils {
/**
* 蓝牙状态 已连接
*/
public static final int BLUETOOTH_STATE_CONNECT = 0x1;
/**
* 蓝牙状态 已断开
*/
public static final int BLUETOOTH_STATE_DISCONNECT = 0x2;
//*******这些只是自定义的code 就不复制太多了
}
编写蓝牙的功能
新建BluetoothBinder类 继承自BluetoothGattCallback
然后把蓝牙的功能模块写在这里面。
主要的功能都在这个类里面，我把这个放到了服务里面，所以在创建BluetoothBinder的时候需要传递一个Service对象
import android.annotation.SuppressLint;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothGatt;
import android.bluetooth.BluetoothGattCallback;
import android.bluetooth.BluetoothGattCharacteristic;
import android.bluetooth.BluetoothGattDescriptor;
import android.bluetooth.BluetoothGattService;
import android.bluetooth.BluetoothManager;
import android.bluetooth.BluetoothProfile;
import android.content.Context;
import android.os.Build;
import android.os.Message;
import android.support.annotation.RequiresApi;
import android.util.Log;
import java.util.List;
import java.util.UUID;
import cc.petnet.trenmotion.Interface.IBluetoothInterface;
import cc.petnet.trenmotion.utils.HandleUtils;
import cc.petnet.trenmotion.utils.LogUtils;
/**
* Created by Pencilso on 2017/4/20.
* 蓝牙操作的Binder
*/
@RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN_MR2)
public class BluetoothBinder extends BluetoothGattCallback implements IBluetoothInterface {
private static BluetoothBinder bluetoothBinder;
private final Service bluetoothService;//service服务
private final BluetoothAdapter adapter;//蓝牙的适配器
private List notifyList;//监听的集合
private BluetoothManager bluetoothManager;//蓝牙管理者
private BluetoothGattService gattService;//通道服务
private BluetoothGatt bluetoothGatt;
public static IBluetoothInterface getInstace() {
return bluetoothBinder;
}
@RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN_MR2)
protected BluetoothBinder(BluetoothService bluetoothService) {
bluetoothBinder = this;
this.bluetoothService = bluetoothService;
bluetoothManager = (BluetoothManager) bluetoothService.getSystemService(Context.BLUETOOTH_SERVICE);
adapter = bluetoothManager.getAdapter();
}
@Override
public void onDestroy() {
bluetoothBinder = null;
}
@Override
public void addNotifyListener(T notifyListener) {
if (notifyListener != null)
notifyList.add(notifyListener);
}
@Override
public void removeNotifyListener(BlueNotifyListener notifyListener) {
if (notifyListener != null)
notifyList.remove(notifyListener);
}
/**
* 广播蓝牙监听消息
* 因为蓝牙发送过来的消息 并不是处于主线程当中的
* 所以如果直接对蓝牙的数据展示视图的话 会展示不了的 这里的话 封装到主线程当中遍历回调数据
*
* @param notify
*/
public void traverseListener(Message notify) {
NotifyThread notifyThread = new NotifyThread();//创建一个遍历线程
notifyThread.setListeners(notifyList);
notifyThread.setNotify(notify);
HandleUtils.getInstace().post(notifyThread);
}
/**
* 系统的蓝牙是否已经打开
*
* @return
*/
@Override
public boolean isEnable() {
return adapter.isEnabled();
}
@Override
public void enableBluetooth(boolean enable) {
if (enable)
adapter.enable();
else
adapter.disable();
}
@SuppressWarnings("deprecation")
@SuppressLint("NewApi")
@Override
public void startScanner(BluetoothAdapter.LeScanCallback callback) {
adapter.startLeScan(callback);
}
@SuppressLint("NewApi")
@SuppressWarnings("deprecation")
@Override
public void stopScanner(BluetoothAdapter.LeScanCallback callback) {
adapter.stopLeScan(callback);
}
@RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN_MR2)
@Override
public void connectDevices(String address) {
BluetoothDevice remoteDevice = adapter.getRemoteDevice(address);
BluetoothGatt bluetoothGatt = remoteDevice.connectGatt(bluetoothService, false, this);
}
/**
* 蓝牙设备状态的监听
*
* @param gatt
* @param status
* @param newState 蓝牙的状态被改变
*/
@Override
public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
super.onConnectionStateChange(gatt, status, newState);
Message message = new Message();
switch (newState) {//对蓝牙反馈的状态进行判断
case BluetoothProfile.STATE_CONNECTED://已链接
message.what = BlueCodeUtils.BLUETOOTH_STATE_CONNECT;
gatt.discoverServices();
break;
case BluetoothProfile.STATE_DISCONNECTED://已断开
message.what = BlueCodeUtils.BLUETOOTH_STATE_DISCONNECT;
break;
}
traverseListener(message);
/**
* 这里还有一个需要注意的，比如说蓝牙设备上有一些通道是一些参数之类的信息，比如最常见的版本号。
* 一般这种情况 版本号都是定死在某一个通道上，直接读取，也不需要发送指令的。
* 如果遇到这种情况，一定要在发现服务之后 再去读取这种数据 不要一连接成功就去获取
*/
}
/**
* 发现服务
*
* @param gatt
* @param status
*/
@Override
public void onServicesDiscovered(BluetoothGatt gatt, int status) {
super.onServicesDiscovered(gatt, status);
gattService = gatt.getService(UUID.fromString(UUIDManager.SERVICE_UUID));// 获取到服务的通道
bluetoothGatt = gatt;
//获取到Notify的Characteristic通道 这个根据协议来定 如果设备厂家给的协议不是Notify的话 就不用做以下操作了
BluetoothGattCharacteristic notifyCharacteristic = gattService.getCharacteristic(UUID.fromString(UUIDManager.NOTIFY_UUID));
BluetoothUtils.enableNotification(gatt, true, notifyCharacteristic);//注册Notify通知
}
/**
* 向蓝牙写入数据
*
* @param data
*/
@SuppressLint("NewApi")
@Override
public boolean writeBuletoothData(String data) {
if (bluetoothService == null) {
return false;
}
BluetoothGattCharacteristic writeCharact = gattService.getCharacteristic(UUID.fromString(UUIDManager.WRITE_UUID));
bluetoothGatt.setCharacteristicNotification(writeCharact, true); // 设置监听
// 当数据传递到蓝牙之后
// 会回调BluetoothGattCallback里面的write方法
writeCharact.setWriteType(BluetoothGattCharacteristic.WRITE_TYPE_DEFAULT);
// 将需要传递的数据 打碎成16进制
writeCharact.setValue(BluetoothUtils.getHexBytes(data));
return bluetoothGatt.writeCharacteristic(writeCharact);
}
/**
* 蓝牙Notify推送过来的数据
*
* @param gatt
* @param characteristic
*/
@Override
public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
super.onCharacteristicChanged(gatt, characteristic);
//如果推送的是十六进制的数据的写法
String data = BluetoothUtils.bytesToHexString(characteristic.getValue()); // 将字节转化为String字符串
Message message = new Message();
message.what = BlueCodeUtils.BLUETOOTH_PUSH_MESSAGE;
message.obj = data;
traverseListener(message);//回调数据
// String data = characteristic.getStringValue(0); // 使用场景 例如某个通道里面静态的定死了某一个值，就用这种写法获取 直接获取到String类型的数据
}
/**
* 这里有一个坑 一定要注意，如果设备返回数据用的不是Notify的话 一定要注意这个问题
* 这个方法是 向蓝牙设备写出数据成功之后回调的方法，写出成功之后干嘛呢？ 主动去蓝牙获取数据，没错，自己主动去READ通道获取蓝牙数据
* 如果用的是Notify的话 不用理会该方法 写出到蓝牙之后 等待Notify的监听 即onCharacteristicChanged方法回调。
*
* @param gatt
* @param characteristic
* @param status
*/
@Override
public void onCharacteristicWrite(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
super.onCharacteristicWrite(gatt, characteristic, status);
if (status == BluetoothGatt.GATT_SUCCESS) { //写出成功 接下来 该去读取蓝牙设备的数据了
//这里的READUUID 应该是READ通道的UUID 不过我这边的设备没有用到READ通道 所以我这里就注释了 具体使用 视情况而定
// BluetoothGattCharacteristic readCharact = gattService.getCharacteristic(UUID.fromString(READUUID));
// gatt.readCharacteristic(readCharact);
}
}
/**
* 调用读取READ通道后返回的数据回调
* 比如说 在onCharacteristicWrite里面调用 gatt.readCharacteristic(readCharact);之后 会回调该方法
*
* @param gatt
* @param characteristic
* @param status
*/
@Override
public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
super.onCharacteristicRead(gatt, characteristic, status);
//如果推送的是十六进制的数据的写法
String data = BluetoothUtils.bytesToHexString(characteristic.getValue()); // 将字节转化为String字符串
Message message = new Message();
message.what = BlueCodeUtils.BLUETOOTH_PUSH_MESSAGE;
message.obj = data;
traverseListener(message);//回调数据
// String data = characteristic.getStringValue(0); // 使用场景 例如某个通道里面静态的定死了某一个值，就用这种写法获取 直接获取到String类型的数据
}
}
其实这个BluetoothBinder还定义了一个接口IBluetoothInterface，然后让BluetoothBinder实现，并且将BluetoothBinder设置单利，暴露方法，提供返回IBluetoothInterface对象
import android.bluetooth.BluetoothAdapter;
import cc.petnet.trenmotion.service.bluetooth.BlueNotifyListener;
/**
* Created by Pencilso on 2017/4/20.
*/
public interface IBluetoothInterface {
/**
*
* @param notifyListener 添加监听事件
* @param BlueNotifyListener监听回调接口
*/
void addNotifyListener(T notifyListener);
/**
*
* @param notifyListener 删除监听接口
*/
void removeNotifyListener(BlueNotifyListener notifyListener);
/**
* 系统是否开启了蓝牙
*
* @return
*/
boolean isEnable();
/**
* 打开或者关闭系统蓝牙
*
* @param enable
*/
void enableBluetooth(boolean enable);
/**
* 启动扫描
*
* @param callback
*/
void startScanner(BluetoothAdapter.LeScanCallback callback);
/**
* 停止扫描
*
* @param callback
*/
void stopScanner(BluetoothAdapter.LeScanCallback callback);
void onDestroy();
/**
* 连接设备
*
* @param address
*/
void connectDevices(String address);
/**
* 向蓝牙写出数据
* @param data
* @return
*/
public boolean writeBuletoothData(String data);
}
Handler工具 主要用来切换到主线程当中
public class HandleUtils {
private static Handler handler = null;
public static Handler getInstace() {
if (handler == null)
handler = new Handler();
return handler;
}
}
BluetoothUtils
public class BluetoothUtils {
/**
* 是否开启蓝牙的通知
*
* @param enable
* @param characteristic
* @return
*/
@SuppressLint("NewApi")
public static boolean enableNotification(BluetoothGatt bluetoothGatt, boolean enable, BluetoothGattCharacteristic characteristic) {
if (bluetoothGatt == null || characteristic == null) {
return false;
}
if (!bluetoothGatt.setCharacteristicNotification(characteristic, enable)) {
return false;
}
//获取到Notify当中的Descriptor通道 然后再进行注册
BluetoothGattDescriptor clientConfig = characteristic.getDescriptor(UUID.fromString(UUIDManager.NOTIFY_DESCRIPTOR));
if (clientConfig == null) {
return false;
}
if (enable) {
clientConfig.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE);
} else {
clientConfig.setValue(BluetoothGattDescriptor.DISABLE_NOTIFICATION_VALUE);
}
return bluetoothGatt.writeDescriptor(clientConfig);
}
/**
* 将字节 转换为字符串
*
* @param src 需要转换的字节数组
* @return 返回转换完之后的数据
*/
public static String bytesToHexString(byte[] src) {
StringBuilder stringBuilder = new StringBuilder("");
if (src == null || src.length <= 0) {
return null;
}
for (int i = 0; i < src.length; i++) {
int v = src[i] & 0xFF;
String hv = Integer.toHexString(v);
if (hv.length() < 2) {
stringBuilder.append(0);
}
stringBuilder.append(hv);
}
return stringBuilder.toString();
}
/**
* 将字符串转化为16进制的字节
*
* @param message
* 需要被转换的字符
* @return
*/
public static byte[] getHexBytes(String message) {
int len = message.length() / 2;
char[] chars = message.toCharArray();
String[] hexStr = new String[len];
byte[] bytes = new byte[len];
for (int i = 0, j = 0; j < len; i += 2, j++) {
hexStr[j] = "" + chars[i] + chars[i + 1];
bytes[j] = (byte) Integer.parseInt(hexStr[j], 16);
}
return bytes;
}
}
蓝牙基本上到这已经结束了。
.doc...)
)