Android 蓝牙4.0 Ble通讯问题小汇总
由于公司前段时间有一个项目要用到蓝牙BLE技术，才开始研究Ble技术，在网上也找了很多文章查看，基本的蓝牙连接通讯都有，就是出现的问题解答比较少，在这里说说个人遇到的问题。
- 129错误
- 133错误
- 分包发送数据
- 自定义数据交互格式
- 首次连接速度慢
- 蓝牙防丢器原理
- Ble连接数据交互整个流程
129错误
在网上找了许多，基本都没有说明129错误在BLE中代表什么。个人测试后，猜测129类似于连接蓝牙，获取服务超时的返回值，一般存在于蓝牙信号比较弱或者蓝牙附近存在电池，变压器等设备影响到蓝牙信号时
代码块
//连接蓝牙成功后，获取服务
mBluetoothGatt.discoverServices()
// 发现新服务
@Override
public void onServicesDiscovered(BluetoothGatt gatt, int status) {
try {
if (status == BluetoothGatt.GATT_SUCCESS
&& mOnServiceDiscoverListener != null) {
mOnServiceDiscoverListener.onServiceDiscover(gatt);
} else {
LogUtil.i(TAG, System.currentTimeMillis() + "发现新服务端失败"
+ status);
close();
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
133错误
跟129错误类似，表示获取服务失败的返回值
代码块
//连接蓝牙成功后，获取服务
mBluetoothGatt.discoverServices()
// 发现新服务
@Override
public void onServicesDiscovered(BluetoothGatt gatt, int status) {
try {
if (status == BluetoothGatt.GATT_SUCCESS
&& mOnServiceDiscoverListener != null) {
mOnServiceDiscoverListener.onServiceDiscover(gatt);
} else {
LogUtil.i(TAG, System.currentTimeMillis() + "发现新服务端失败"
+ status);
close();
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
分包发送数据
蓝牙BLE支持的数据发送每包只能20字节，所以想要发送比较大的数据包只能通过分包发送。注意：如果你在要发送数据的地方直接一个for循环把所有分包的数据发完，蓝牙设备那边也只会收到一包数据而已，再此有两种方法解决：
1、在for循环中每发一包数据加一个20毫秒的休眠时间，缺点：时间不可控，容易导致丢包。
2、每发完一包数据，成功发送后系统会进入onCharacteristicWrite回调里面，在这里进行发送第二包和第二包之后的数据（代码如下）。
代码块
// 发送大于20字节的包（第一包数据）
public void sendPackFromOut20(BluetoothGatt gatt) {
sendLength = con.length;
sendtabLength = 20;
byte[] c = new byte[20];
for (int i = 0; i < 20; i++) {
c[i] = con[i];
}
BluetoothGattService RxService = gatt.getService(UUID
.fromString(BluetoothLeClass.UUID_KEY_Data));
BluetoothGattCharacteristic TxChar = RxService.getCharacteristic(UUID
.fromString(BluetoothLeClass.UUID_KEY_Write));
TxChar.setValue(c);
mBLE.writeCharacteristic(TxChar);
}
//超过第一包的数据在上一包数据发送成功后系统回调里面发
/**
* 写入BLE终端数据成功回调
*/
@Override
public void onCharacteristicWrite(BluetoothGatt gatt,
BluetoothGattCharacteristic characteristic) {
try {
LogUtil.i(TAG, new String(characteristic.getValue()));
int s = sendLength - sendtabLength;
if (s > 0) {
// 发送con未发送完的数据
byte[] c;
if (s > 20) {
c = new byte[20];
for (int i = 0; i < 20; i++) {
c[i] = con[i + sendtabLength];
}
sendtabLength += 20;
} else {
c = new byte[s];
for (int i = 0; i < s; i++) {
c[i] = con[i + sendtabLength];
}
sendtabLength += s;
}
BluetoothGattService RxService = gatt.getService(UUID
.fromString(BluetoothLeClass.UUID_KEY_Data));
BluetoothGattCharacteristic TxChar = RxService
.getCharacteristic(UUID
.fromString(BluetoothLeClass.UUID_KEY_Write));
TxChar.setValue(c);
mBLE.writeCharacteristic(TxChar);
} else {
sendLength = -1;
sendtabLength = -1;
LogUtil.i(TAG, "所有包已发完！");
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
自定义数据交互格式
这个类似于android跟http数据交互的格式，无非就是定义一些样式让android和蓝牙模块两边都能识别，为了安全起见可以对数据进行加密处理。由于我这边是跟蓝牙单片机进行交互的，蓝牙单片机不支持String,只能通过byte[]数组按位去组装数据交互。（结构如下）
数据格式：[起始码][长度码] [命令码] [数据码] [校验码]
起始码 ：固定为 0XAA
长度码 ：命令码+数据码+校验码
命令码，数据码（自定义数据接口）
校验码 ：一个字节，前面所有数据值相加之和
加密：self加密和DES加密对整个数据码进行加密
首次连接速度慢
由于蓝牙首次连接要配置缓冲所有广播的服务，所以一般第一次连接都比较慢，如果想要加快第一次连接速度，只能让蓝牙模块关闭部分不必要的广播。
蓝牙防丢器原理
蓝牙防丢器的原理其实很简单，就是通过手机app定时去扫描你配置好的蓝牙单片机，如果扫描到该蓝牙单片机返回的rssi值（蓝牙的信号值）超出app设定的值，则app将会报警；或者扫不到该单片机app也会报警。（代码如下）
代码块
// 初始化蓝牙
private void initBLE() {
// TODO Auto-generated method stub
// 检查当前手机是否支持ble 蓝牙,如果不支持退出程序
if (!mContext.getPackageManager().hasSystemFeature(
PackageManager.FEATURE_BLUETOOTH_LE)) {
Toast.makeText(mContext, "手机不支持ble蓝牙", Toast.LENGTH_SHORT)
.show();
}
// 初始化 Bluetooth adapter,
// 通过蓝牙管理器得到一个参考蓝牙适配器(API必须在以上android4.3或以上和版本)
final BluetoothManager bluetoothManager = (BluetoothManager) mContext
.getSystemService(Context.BLUETOOTH_SERVICE);
mBluetoothAdapter = bluetoothManager.getAdapter();
// 检查设备上是否支持蓝牙
if (mBluetoothAdapter == null) {
Toast.makeText(mContext, "手机不支持蓝牙", Toast.LENGTH_SHORT).show();
return;
}
// 打开蓝牙
if (!mBluetoothAdapter.isEnabled()) {
mBluetoothAdapter.enable();
}
// 开始扫描
if (dAddress.size() > 0) {
dAddress.clear();
}
if (rssiDistance.size() > 0) {
rssiDistance.clear();
}
if (!mScanning) {
mScanning = true;
scanLeDevice(true);
}
}
// 扫描
private void scanLeDevice(final boolean enable) {
if (enable) {
// Stops scanning after a pre-defined scan period.
mHandler.postDelayed(new Runnable() {
@Override
public void run() {
mScanning = false;
mBluetoothAdapter.stopLeScan(mLeScanCallback);
}
}, SCAN_PERIOD);
mScanning = true;
boolean scan = mBluetoothAdapter.startLeScan(mLeScanCallback);
} else {
mScanning = false;
mBluetoothAdapter.stopLeScan(mLeScanCallback);
}
}
// 设备扫描
private BluetoothAdapter.LeScanCallback mLeScanCallback = new BluetoothAdapter.LeScanCallback() {
@Override
public void onLeScan(final BluetoothDevice device, int rssi,
byte[] scanRecord) {
LogUtil.i(
TAG,
device.getAddress() + ","
+ (int) BLEUtil.RssiToDistance(rssi));
if (!dAddress.contains(device.getAddress())) {
//对比获取到的设备的mac地址和rssi值进行处理
dAddress.add(device.getAddress());
rssiDistance.put(device.getAddress(),
(int) BLEUtil.RssiToDistance(rssi));
}
}
};
Ble连接数据交互整个流程
蓝牙Ble连接跟蓝牙防丢器的原理其实是一样的，先启动蓝牙，然后扫面附近的蓝牙（只有android5.0+的手机的蓝牙才会被扫描到，或支持ble的蓝牙单片机），拿到所有扫描的蓝牙进行筛选匹配到你想要连接的蓝牙，然后连接。（代码如下）
代码块
// 初始化蓝牙
private void initBLE() {
// TODO Auto-generated method stub
// 检查当前手机是否支持ble 蓝牙,如果不支持退出程序
if (!mContext.getPackageManager().hasSystemFeature(
PackageManager.FEATURE_BLUETOOTH_LE)) {
Toast.makeText(mContext, "手机不支持ble蓝牙", Toast.LENGTH_SHORT)
.show();
}
// 初始化 Bluetooth adapter,
// 通过蓝牙管理器得到一个参考蓝牙适配器(API必须在以上android4.3或以上和版本)
final BluetoothManager bluetoothManager = (BluetoothManager) mContext
.getSystemService(Context.BLUETOOTH_SERVICE);
mBluetoothAdapter = bluetoothManager.getAdapter();
// 检查设备上是否支持蓝牙
if (mBluetoothAdapter == null) {
Toast.makeText(mContext, "手机不支持蓝牙", Toast.LENGTH_SHORT).show();
return;
}
// 打开蓝牙
if (!mBluetoothAdapter.isEnabled()) {
mBluetoothAdapter.enable();
}
// 开始扫描
if (dAddress.size() > 0) {
dAddress.clear();
}
if (rssiDistance.size() > 0) {
rssiDistance.clear();
}
if (!mScanning) {
mScanning = true;
scanLeDevice(true);
}
}
// 扫描
private void scanLeDevice(final boolean enable) {
if (enable) {
// Stops scanning after a pre-defined scan period.
mHandler.postDelayed(new Runnable() {
@Override
public void run() {
mScanning = false;
mBluetoothAdapter.stopLeScan(mLeScanCallback);
// 开始连接，筛选后的蓝牙的mac地址
mBLE.connect(mac)
}
}, SCAN_PERIOD);
mScanning = true;
boolean scan = mBluetoothAdapter.startLeScan(mLeScanCallback);
} else {
mScanning = false;
mBluetoothAdapter.stopLeScan(mLeScanCallback);
}
}
// 设备扫描
private BluetoothAdapter.LeScanCallback mLeScanCallback = new BluetoothAdapter.LeScanCallback() {
@Override
public void onLeScan(final BluetoothDevice device, int rssi,
byte[] scanRecord) {
LogUtil.i(
TAG,
device.getAddress() + ","
+ (int) BLEUtil.RssiToDistance(rssi));
if (!dAddress.contains(device.getAddress())) {
//对比获取到的设备的mac地址和rssi值进行处理
dAddress.add(device.getAddress());
rssiDistance.put(device.getAddress(),
(int) BLEUtil.RssiToDistance(rssi));
}
}
};
附上封装好的BluetoothLeClass，主要封装好：连接，收发数据的回调，断开蓝牙。调用mBLE.connect(mac)连接蓝牙后进入public boolean connect(final String address) {｝方法，根据你是否是二次连接进行处理，如果是首次连接将创建mGattCallback ，方法private final BluetoothGattCallback mGattCallback = new BluetoothGattCallback() {｝里面封装了蓝牙状态改变（连接/断开）回调onConnectionStateChange；连接成功后调mBluetoothGatt.discoverServices()获取收发数据的服务，在onServicesDiscovered中获取到服务，我这边在前台mOnServiceDiscoverListener.onServiceDiscover(gatt);回调中进行数据收发（代码如下）
代码块
package com.etclients.util;
import java.util.List;
import java.util.UUID;
import com.etclients.activity.MainActivity;
import com.etclients.receiver.AlarmRecevier;
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.content.Intent;
import android.os.Bundle;
import android.util.Log;
/**
* Service for managing connection and data communication with a GATT server
* hosted on a given Bluetooth LE device.
*/
public class BluetoothLeClass { private final static String TAG = BluetoothLeClass.class.getSimpleName(); private BluetoothManager mBluetoothManager; private BluetoothAdapter mBluetoothAdapter; private String mBluetoothDeviceAddress; private BluetoothGatt mBluetoothGatt; // BLE回调得到的蓝牙RSSI值 private static int BLERSSI = 0; public final static String UUID_KEY_Write = "6e400002-b5a3-f393-e0a9-e50e24dcca9e";// 手机发送数据给设备 public final static String UUID_KEY_Read = "6e400003-b5a3-f393-e0a9-e50e24dcca9e";// 设备发送数据给手机 public final static String UUID_KEY_Data = "6e400001-b5a3-f393-e0a9-e50e24dcca9e";// public static final UUID CCCD = UUID .fromString("00002902-0000-1000-8000-00805f9b34fb"); private byte[] c; private boolean is = false; public interface OnConnectListener { public void onConnect(BluetoothGatt gatt); } public interface OnDisconnectListener { public void onDisconnect(BluetoothGatt gatt); } public interface OnServiceDiscoverListener { public void onServiceDiscover(BluetoothGatt gatt); } public interface OnDataAvailableListener { public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status); public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic); public void onCharacteristicWrite(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic); public void onDescriptorWrite(BluetoothGatt gatt, BluetoothGattDescriptor descriptor); } private OnConnectListener mOnConnectListener; private OnDisconnectListener mOnDisconnectListener; private OnServiceDiscoverListener mOnServiceDiscoverListener; private OnDataAvailableListener mOnDataAvailableListener; private Context mContext; public void setOnConnectListener(OnConnectListener l) { mOnConnectListener = l; } public void setOnDisconnectListener(OnDisconnectListener l) { mOnDisconnectListener = l; } public void setOnServiceDiscoverListener(OnServiceDiscoverListener l) { mOnServiceDiscoverListener = l; } public void setOnDataAvailableListener(OnDataAvailableListener l) { mOnDataAvailableListener = l; } public BluetoothLeClass(Context c) { mContext = c; } // Implements callback methods for GATT events that the app cares about. For // example, // connection change and services discovered. private final BluetoothGattCallback mGattCallback = new BluetoothGattCallback() { @Override public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) { // 当蓝牙设备已经连接 if (newState == BluetoothProfile.STATE_CONNECTED) { if (mOnConnectListener != null) mOnConnectListener.onConnect(gatt); LogUtil.i(TAG, "已连接 to GATT server." + System.currentTimeMillis()); // 成功连接后发现服务的尝试。 try { Thread.sleep(100); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } LogUtil.i(TAG, System.currentTimeMillis() / 1000 + "发现服务的尝试" + mBluetoothGatt.discoverServices()); } else if (newState == BluetoothProfile.STATE_DISCONNECTED) { try { // 当设备无法连接 if (mOnDisconnectListener != null) mOnDisconnectListener.onDisconnect(gatt); LogUtil.i(TAG, "断开 GATT server."); close2(); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); close(); } } } // 发现新服务 @Override public void onServicesDiscovered(BluetoothGatt gatt, int status) { try { if (status == BluetoothGatt.GATT_SUCCESS && mOnServiceDiscoverListener != null) { mOnServiceDiscoverListener.onServiceDiscover(gatt); } else { LogUtil.i(TAG, System.currentTimeMillis() + "发现新服务端失败" + status); close(); Intent intent = new Intent(); intent.setAction(MainActivity.ACTION_UPDATEUI); Bundle bundle = new Bundle(); bundle.putString("msg", "发现服务129失败,请重新开门！"); intent.putExtras(bundle); mContext.sendBroadcast(intent); } } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } } // 读取特征值 @Override public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) { LogUtil.i(TAG, "onCharacteristicRead"); if (mOnDataAvailableListener != null) mOnDataAvailableListener.onCharacteristicRead(gatt, characteristic, status); } @Override public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) { LogUtil.i(TAG, "onCharacteristicChanged"); if (mOnDataAvailableListener != null) mOnDataAvailableListener.onCharacteristicChanged(gatt, characteristic); } @Override public void onCharacteristicWrite(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) { // TODO Auto-generated method stub super.onCharacteristicWrite(gatt, characteristic, status); LogUtil.i(TAG, "onCharacteristicWrite"); if (status == BluetoothGatt.GATT_SUCCESS && mOnDataAvailableListener != null) mOnDataAvailableListener.onCharacteristicWrite(gatt, characteristic); } @Override public void onDescriptorWrite(BluetoothGatt gatt, BluetoothGattDescriptor descriptor, int status) { // TODO Auto-generated method stub super.onDescriptorWrite(gatt, descriptor, status); if (status == BluetoothGatt.GATT_SUCCESS && mOnDataAvailableListener != null) { mOnDataAvailableListener.onDescriptorWrite(gatt, descriptor); LogUtil.i(TAG, "onDescriptorWrite"); } else { // 重新连接 if (mBluetoothGatt != null) { // disconnect(); close(); } System.out .println("onDescriptorWrite重新连接mBluetoothGatt== null"); mBluetoothGatt = mBluetoothAdapter.getRemoteDevice( AlarmRecevier.mac).connectGatt(mContext, false, mGattCallback); mBluetoothDeviceAddress = AlarmRecevier.mac; } } @Override public void onReadRemoteRssi(BluetoothGatt gatt, int rssi, int status) { // TODO Auto-generated method stub super.onReadRemoteRssi(gatt, rssi, status); // 将回调的RSSI值赋值 BLERSSI = rssi; LogUtil.i(TAG, "rssi = " + rssi); } }; /** * Initializes a reference to the local Bluetooth adapter. * * @return Return true if the initialization is successful. */ public boolean initialize() { // For API level 18 and above, get a reference to BluetoothAdapter // through // BluetoothManager. if (mBluetoothManager == null) { mBluetoothManager = (BluetoothManager) mContext .getSystemService(Context.BLUETOOTH_SERVICE); if (mBluetoothManager == null) { Log.e(TAG, "Unable to initialize BluetoothManager."); return false; } } mBluetoothAdapter = mBluetoothManager.getAdapter(); if (mBluetoothAdapter == null) { Log.e(TAG, "Unable to obtain a BluetoothAdapter."); return false; } return true; } /** * 开始连接蓝牙 * * @param address * The device address of the destination device. * * @return Return true if the connection is initiated successfully. The * connection result is reported asynchronously through the * {@code BluetoothGattCallback#onConnectionStateChange(android.bluetooth.BluetoothGatt, int, int)} * callback. */ public boolean connect(final String address) { if (mBluetoothAdapter == null || address == null) { LogUtil.i(TAG, "你没有初始化或未指定的地址。"); return false; } // Previously connected device. Try to reconnect. if (mBluetoothDeviceAddress != null && address.equals(mBluetoothDeviceAddress) && mBluetoothGatt != null) { LogUtil.i(TAG, "mBluetoothGatt连接已存在"); close(); } final BluetoothDevice device = mBluetoothAdapter .getRemoteDevice(address); if (device == null) { return false; } //创建一个BluetoothGattCallback（蓝牙连接状态，收发数据的回调） mBluetoothGatt = device.connectGatt(mContext, false, mGattCallback); LogUtil.i(TAG, "试图创建一个新的连接。"); mBluetoothDeviceAddress = address; return true; } /** * Disconnects an existing connection or cancel a pending connection. The * disconnection result is reported asynchronously through the * {@code BluetoothGattCallback#onConnectionStateChange(android.bluetooth.BluetoothGatt, int, int)} * callback. */ public void disconnect() { if (mBluetoothAdapter == null || mBluetoothGatt == null) { return; } mBluetoothGatt.disconnect(); try { Thread.sleep(20); close(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } /** * After using a given BLE device, the app must call this method to ensure * resources are released properly. */ public void close() { if (mBluetoothGatt == null) { return; } mBluetoothGatt.close(); mBluetoothGatt = null; LogUtil.i(TAG, "释放资源！"); } public void close2() { if (mBluetoothGatt == null) { return; } mBluetoothGatt.close(); mBluetoothGatt = null; try { DialogUtil.dismissAnimationDialog(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } LogUtil.i(TAG, "释放资源，关闭加载动画！"); } /** * Request a read on a given {@code BluetoothGattCharacteristic}. The read * result is reported asynchronously through the * {@code BluetoothGattCallback#onCharacteristicRead(android.bluetooth.BluetoothGatt, android.bluetooth.BluetoothGattCharacteristic, int)} * callback. * * @param characteristic * The characteristic to read from. */ public void readCharacteristic(BluetoothGattCharacteristic characteristic) { if (mBluetoothAdapter == null || mBluetoothGatt == null) { Log.w(TAG, "BluetoothAdapter not initialized"); return; } boolean is = mBluetoothGatt.readCharacteristic(characteristic); LogUtil.i(TAG, "开始回调！" + is); } /** * Enables or disables notification on a give characteristic. * * @param characteristic * Characteristic to act on. * @param enabled * If true, enable notification. False otherwise. */ public void setCharacteristicNotification( BluetoothGattCharacteristic characteristic, boolean enabled) { if (mBluetoothAdapter == null || mBluetoothGatt == null) { LogUtil.i(TAG, "BluetoothAdapter not initialized"); return; } try { LogUtil.i(TAG, characteristic + "," + enabled); boolean is = mBluetoothGatt.setCharacteristicNotification( characteristic, enabled); LogUtil.i(TAG, "setCharacteristicNotification = " + is); BluetoothGattDescriptor descriptor = characteristic .getDescriptor(CCCD); descriptor .setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE); mBluetoothGatt.writeDescriptor(descriptor); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } } public void writeCharacteristic(BluetoothGattCharacteristic characteristic) { if (mBluetoothGatt != null) { boolean is = mBluetoothGatt.writeCharacteristic(characteristic); LogUtil.i(TAG, "writeCharacteristic = " + is); } } /** * Retrieves a list of supported GATT services on the connected device. This * should be invoked only after {@code BluetoothGatt#discoverServices()} * completes successfully. * * @return A {@code List} of supported services. */ public List<BluetoothGattService> getSupportedGattServices() { if (mBluetoothGatt == null) return null; return mBluetoothGatt.getServices(); } // 获取已经得到的RSSI值 public static int getBLERSSI() { return BLERSSI; } // 是都能读取到已连接设备的RSSI值 // 执行该方法一次，获得蓝牙回调onReadRemoteRssi（）一次 /** * Read the RSSI for a connected remote device. * */ public boolean getRssiVal() { if (mBluetoothGatt == null) return false; return mBluetoothGatt.readRemoteRssi(); } }
前台private BluetoothLeClass.OnServiceDiscoverListener mOnServiceDiscover = new OnServiceDiscoverListener() {｝中通过获取的服务绑定数据改变后发送通知 mBLE.setCharacteristicNotification(RxChar, true);然后在调mBluetoothGatt.writeDescriptor(descriptor);在onDescriptorWrite(连接首次发送数据)回调中开始向BLE终端写入数据，蓝牙单片机收到数据后向手机返回数据，数据从onCharacteristicChanged方法回调到前端，前端收到数据后进行二次发送数据，具体数据发送流程见代码 （代码如下）
代码块
/**
* 搜索到BLE终端服务的事件
*/
private BluetoothLeClass.OnServiceDiscoverListener mOnServiceDiscover = new OnServiceDiscoverListener() {
@Override
public void onServiceDiscover(BluetoothGatt gatt) {
if (gatt != null) {
// 设置UUID_KEY_Read字服务数据改变监听
try {
LogUtil.i(TAG, System.currentTimeMillis() / 1000
+ "onServiceDiscover");
BluetoothGattService RxService = gatt.getService(UUID
.fromString(BluetoothLeClass.UUID_KEY_Data));
if (RxService != null) {
BluetoothGattCharacteristic RxChar = RxService
.getCharacteristic(UUID
.fromString(BluetoothLeClass.UUID_KEY_Read));
if (RxChar != null) {
//绑定数据改变后发送通知
mBLE.setCharacteristicNotification(RxChar, true);
} else {
//获取服务失败，关闭蓝牙
mBLE.close();
}
} else {
//获取服务失败，关闭蓝牙
mBLE.close();
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
};
/**
* 收到BLE终端数据交互的事件
*/
private BluetoothLeClass.OnDataAvailableListener mOnDataAvailable = new OnDataAvailableListener() {
/**
* 读取BLE终端数据回调
*/
@Override
public void onCharacteristicRead(BluetoothGatt gatt,
BluetoothGattCharacteristic characteristic, int status) {
if (status == BluetoothGatt.GATT_SUCCESS)
LogUtil.i(TAG, "读取BLE终端数据回调");
}
/**
* BLE终端数据改变通知回调
*/
@Override
public void onCharacteristicChanged(BluetoothGatt gatt,
BluetoothGattCharacteristic characteristic) {
byte[] value = characteristic.getValue();
LogUtil.i(TAG, "BLE终端数据改变通知回调" + new String(value));
//在这里接受蓝牙单片机的数据
//进行处理后
//发送二次数据
byte[] content = BLEParams.sendReturnCode(commandcode);//封装好的数据
BluetoothGattService RxService = gatt.getService(UUID
.fromString(BluetoothLeClass.UUID_KEY_Data));
BluetoothGattCharacteristic TxChar = RxService
.getCharacteristic(UUID
.fromString(BluetoothLeClass.UUID_KEY_Write));
TxChar.setValue(content);
mBLE.writeCharacteristic(TxChar);
}
/**
* 写入BLE终端数据成功回调
*/
@Override
public void onCharacteristicWrite(BluetoothGatt gatt,
BluetoothGattCharacteristic characteristic) {
//二次发送数据成功后在此返回发送的数据
LogUtil.i(TAG, new String(characteristic.getValue()));
//可以在此进行分包发送数据
}
/**
* 写入BLE终端通知数据成功回调
*/
@Override
public void onDescriptorWrite(BluetoothGatt gatt,
BluetoothGattDescriptor descriptor) {
// TODO Auto-generated method stub
// 开始向BLE终端写入数据(连接首次发送数据)
// 查询版本号
sendGetConnectId(0x01, gatt);
}
};
// 倒数
/* 定义一个倒计时的内部类 */
class TimeCount extends CountDownTimer { public TimeCount(long millisInFuture, long countDownInterval) { super(millisInFuture, countDownInterval);// 参数依次为总时长,和计时的时间间隔 } @Override public void onFinish() {// 计时完毕时触发 if (isTimeout) { // 超时 mBLE.close(); } } @Override public void onTick(long millisUntilFinished) {// 计时过程显示 } }