蓝牙4.0

网上关于蓝牙4.0的讲解：http://www.2cto.com/kf/201411/349575.html

http://blog.csdn.net/changemyself/article/details/8454633

大家贡献的demo 下载 :http://download.csdn.net/detail/lqw770737185/8116019

目前主流手机蓝牙基本已经是4.0 及以上了 , 网上对于蓝牙4.0的讲解也有不少，有的已经深入到刨祖坟的地步，虽然讲的很详细，但是我看的也是云里雾里（原谅我太蠢~~~），这里打算先理清整个工作流程，后面再贴上我封装的蓝牙4.0模块（官方demo是通过广播来写，本人喜欢用接口）。

蓝牙4.0整个工作流程：

1 . 对于需要连接蓝牙设备的移动端，首先需要判断是否具有蓝牙功能(有的话就打开蓝牙)，要不然你的设备再牛客户没办法用，也是白搭；

2 . 确认完移动端有蓝牙模块后，接着判断支持蓝牙4.0 还是2.0 ；

/**
* 打开蓝牙
* @return
*/
@SuppressLint("NewApi")
private boolean EnableBle() {
boolean enable = false;
// BluetoothManager在Android4.3以上支持(API level 18)。
BluetoothManager bluetoothManager=(BluetoothManager) context.getSystemService(Context.BLUETOOTH_SERVICE);
bluetoothadapter=bluetoothManager.getAdapter();
//开启蓝牙
if(bluetoothadapter!=null && SupportBle()){
bluetoothadapter.enable();
enable=true;
}else if(bluetoothadapter==null){
ToastMore("没有检测到蓝牙设备");
enable=false;
}else if(!SupportBle()){
ToastMore("本设备不支持蓝牙4.0");
enable=false;
}
return enable;
}
/**
* 检查设备是否支持蓝牙4.0
* @return
*/
public boolean SupportBle(){
if(context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_BLUETOOTH_LE)){
return true;
}
return false;
}

3 . 确认移动端是支持蓝牙4.0 后，打开蓝牙，开启扫描，查找指定设备 ， 查找到我们的设备后，关闭蓝牙扫描，这样可以减低功耗；

/**是否开始搜索设备
* @param
* enable ：是否搜索
* devicename： 搜索到该设备名  停止搜索 devicename==null 默认搜索1分钟
* */
public void SearchDevice(boolean enable,String devicename){
this.devicename=devicename;
if(enable){
ToastMore("开始扫描");
continue_search=true;
//查找特定设备
//bluetoothadapter.startLeScan(serviceUuids, callback);
if(devicename==null||devicename.equals("")){
new Handler().postDelayed(new Runnable() {

@Override
public void run() {
continue_search=false;
bluetoothadapter.stopLeScan(callback);
}
},60000);
}
//开始扫描
bluetoothadapter.startLeScan(callback);
}else{
ToastMore("停止扫描");
continue_search=false;
//停止扫描
bluetoothadapter.stopLeScan(callback);
}
}
/**
* Device scan callback.
4.0  callback
蓝牙搜索到设备会回调该方法
搜索时，只能搜索传统蓝牙设备或者BLE设备，两者完全独立，不可同时被搜索
*/
private BluetoothAdapter.LeScanCallback callback=new BluetoothAdapter.LeScanCallback() {

@Override
public void onLeScan(final BluetoothDevice device, int rssi, byte[] scanRecord) {
((MainActivity)context).runOnUiThread(new Runnable() {
public void run() {
//找到指定设备停止扫描
LogMore("扫描到设备："+device.getName());
if(continue_search){
if(devicename.equals(device.getName())){
LogMore("已经扫描到设备："+device.getName());
//停止扫描
SearchDevice(false, null);
}
}
}
});

}
};

4 . 查找到我们的设备后，开始连接，通过 BluetoothGattCallback 接口的onConnectionStateChange方法我们可以确认此时的连接状态（通过这个状态可以做出提示，提高友好度），连接设备之后， onServicesDiscovered(BluetoothGatt gatt, int status) 这个方法会返回两个参数，status 表示此时的连接状态，if(status==BluetoothGatt.GATT_SUCCESS )，表示连接成功，并且发现了远程设备的services，这个时候我们就可以做自己的操作了，比如可以向自己的设备写入数据，例如发出开始的命令；

5 . 发送命名，我们需要知道service所包含的某一个characteristic的uuid,因为service是一个characteristic的集合，如果不知道那么就遍历characteristic集合，给所有的characteristic发送开始的命令（这里要提醒一下：遍历写入的时候要加延迟，不然很可能写入失败，我掉过的坑啊~~），并给每一个characteristic设备添加setCharacteristicNotification，表示给当前这个characteristic设置提醒，那么当指定的这个characteristic的值发生变化后，就会回调 onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic)方法，在这里接收蓝牙回传数据，一般到了这里我们就已经可以拿到需要的数据了，接下来就是读取数据，通过bluetoothGatt.readCharacteristic(characteristic)，characteristic已经被读取后，会回调onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status)，最后把characteristic解析就是我们需要的数据了，当然，如果这还不是你需要的（可能你的设备需要进行几次交互），那么可以通过判断来决定是否再次写入

/**连接设备后回调*/
private BluetoothGattCallback Gattcallback=new BluetoothGattCallback() {
/**连接状态发生改变*/
@Override
public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
if(status==BluetoothProfile.STATE_CONNECTED){
LogMore("已经连接");
}else if(status==BluetoothProfile.STATE_CONNECTING){
LogMore("正在连接");
}else if(status==BluetoothProfile.STATE_DISCONNECTED){
LogMore("已经断开");
}else if(status==BluetoothProfile.STATE_CONNECTING){
LogMore("正在断开");
}

};
/**发现sevice*/
@Override
public void onServicesDiscovered(BluetoothGatt gatt, int status) {
//设备连接成功
if(status==BluetoothGatt.GATT_SUCCESS){
vble.WriteDatatoBle(getSupportedGattServices());
}else{
LogMore("onServicesDiscovered+"+status+"-->"+gatt);
}
}
/**读取数据*/
@Override
public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
if(status==BluetoothGatt.GATT_SUCCESS){
//解析数据
AnalysisBleData(characteristic);
}
}
/**检测用户向蓝牙写数据的状态 */
@Override
public void onCharacteristicWrite(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {

}
/**接收蓝牙回传数据*/
@Override
public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
//读取
ReadData(characteristic);
}
};

6 . 最后测量完之后，不要忘了关闭蓝牙连接

/**断开连接*/
public void disconnect(){
if(bluetoothadapter!=null &&bluetoothGatt !=null){
bluetoothGatt.disconnect();
LogMore("disconnect");
}
}
/**关闭连接*/
public void closeconnect(){
if(bluetoothadapter!=null &&bluetoothGatt !=null){
bluetoothGatt.close();
bluetoothGatt=null;
LogMore("close");
}
}

上面已经讲完了整个流程，下面贴出整个工具类：

import java.util.List;
import java.util.UUID;
import com.siheal.bledevice66b6b5.view.MainActivity;
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.content.pm.PackageManager;
import android.os.Handler;
import android.util.Log;
import android.widget.Toast;

public class BluetoothHandle {
private VBle vble;
private Context context;
private BluetoothAdapter bluetoothadapter;
/**指定要搜索的设备名*/
private String devicename;
/**记录上次连接过的蓝牙地址*/
private String exist_device_address;
private BluetoothGatt bluetoothGatt;
/**
* 蓝牙心率解析uuid
*/
private static UUID UUID_HEART_RATE_MEASUREMENT=UUID.fromString("00002a37-0000-1000-8000-00805f9b34fb");
private final String TAG = BluetoothHandle.class.getSimpleName();
/**
* 用于处理数据的接口
*/
public interface VBle {
/**设置测量结果*/
void SetMeasureData(String data,BluetoothGattCharacteristic characteristic);
/**
* 向蓝牙写入数据
* @param supportedGattServices
*/
void WriteDatatoBle(List<BluetoothGattService> supportedGattServices);
}
public BluetoothHandle(Context context) {
vble=(VBle) context;
this.context=context;
}
/**
* 打开蓝牙
* @return
*/
@SuppressLint("NewApi")
public boolean EnableBle() {
boolean enable = false;
// BluetoothManager在Android4.3以上支持(API level 18)。
BluetoothManager bluetoothManager=(BluetoothManager) context.getSystemService(Context.BLUETOOTH_SERVICE);
bluetoothadapter=bluetoothManager.getAdapter();
//开启蓝牙
if(bluetoothadapter!=null && SupportBle()){
bluetoothadapter.enable();
enable=true;
}else if(bluetoothadapter==null){
ToastMore("没有检测到蓝牙设备");
enable=false;
}else if(!SupportBle()){
ToastMore("本设备不支持蓝牙4.0");
enable=false;
}
return enable;
}
/**
* 检查设备是否支持蓝牙4.0
* @return
*/
public boolean SupportBle(){
if(context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_BLUETOOTH_LE)){
return true;
}
return false;
}
/**是否开始搜索设备
* @param
* enable ：是否搜索
* devicename： 搜索到该设备名  停止搜索 devicename==null 默认搜索1分钟
* */
public void SearchDevice(boolean enable,String devicename){
this.devicename=devicename;
if(enable){
ToastMore("开始扫描");
//bluetoothadapter.startLeScan(serviceUuids, callback);//查找特定设备
if(devicename==null||devicename.equals("")){
new Handler().postDelayed(new Runnable() {

@Override
public void run() {
bluetoothadapter.stopLeScan(callback);
}
},60000);
}
bluetoothadapter.startLeScan(callback);
}else{
ToastMore("停止扫描");
bluetoothadapter.stopLeScan(callback);
}
}
/**
* Device scan callback.
4.0  callback
蓝牙搜索到设备会回调该方法
搜索时，只能搜索传统蓝牙设备或者BLE设备，两者完全独立，不可同时被搜索
*/
private BluetoothAdapter.LeScanCallback callback=new BluetoothAdapter.LeScanCallback() {

@Override
public void onLeScan(final BluetoothDevice device, int rssi, byte[] scanRecord) {
((MainActivity)context).runOnUiThread(new Runnable() {
public void run() {
//找到指定设备停止扫描
LogMore("扫描到设备："+device.getName());
if(devicename.equals(device.getName())){
LogMore("已经扫描到设备："+device.getName());
SearchDevice(false, null);
//当查找到指定设备后 开始连接
BluetoothHandle.this.connect(device);
}
}
});

}
};

/**
* 连接设备
* @param device
* @return
*/
@SuppressWarnings("unused")
public boolean connect(BluetoothDevice device){
LogMore("正在连接设备："+device.getName());
String deviceaddress=device.getAddress();
if(exist_device_address!=null&&deviceaddress.equals(exist_device_address)&&bluetoothGatt!=null){
LogMore("Trying to use an existing mBluetoothGatt for connection.");
if(bluetoothGatt.connect()){
LogMore("connection success");
return true;
}else{
return false;
}
}
if(device!=null){
//三个参数：a Context object, autoConnect（boolean 类型的，确定 是否自动连接）
//and a reference to a BluetoothGattCallback
bluetoothGatt=device.connectGatt(context,false, Gattcallback);
}else{
LogMore("Device not found.  Unable to connect.");
return false;
}
return true;
}
/**连接设备后回调*/
private BluetoothGattCallback Gattcallback=new BluetoothGattCallback() {
/**连接状态发生改变*/
@Override
public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
if(status==BluetoothProfile.STATE_CONNECTED){
LogMore("已经连接");
}else if(status==BluetoothProfile.STATE_CONNECTING){
LogMore("正在连接");
}else if(status==BluetoothProfile.STATE_DISCONNECTED){
LogMore("已经断开");
}else if(status==BluetoothProfile.STATE_CONNECTING){
LogMore("正在断开");
}
};
/**发现sevice*/
@Override
public void onServicesDiscovered(BluetoothGatt gatt, int status) {
//设备连接成功
if(status==BluetoothGatt.GATT_SUCCESS){
vble.WriteDatatoBle(getSupportedGattServices());
}else{
LogMore("onServicesDiscovered+"+status+"-->"+gatt);
}
}
/**读取数据*/
@Override
public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
if(status==BluetoothGatt.GATT_SUCCESS){
//读取数据
LogMore("onCharacteristicRead+"+characteristic.getUuid().toString());
AnalysisBleData(characteristic);
}
}
/**检测用户向蓝牙写数据的状态 */
@Override
public void onCharacteristicWrite(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {

}
/**接收蓝牙回传数据*/
@Override
public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
ReadData(characteristic);
//AnalysisBleData(characteristic);
}
};
/**
* 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.
* <p>
* 获取远程设备所支持的services
* <p>
* services : Characteristic的集合。例如一个service叫做“Heart Rate Monitor”，
* 它可能包含多个Characteristics，其中可能包含一个叫做“heart rate measurement"的Characteristic。
*/
private List<BluetoothGattService> getSupportedGattServices() {
if (bluetoothGatt == null) return null;
return bluetoothGatt.getServices();
}

/**
* 数据解析按照蓝牙心率测量配置文件规格进行
* @param characteristic
*/
protected void AnalysisBleData(BluetoothGattCharacteristic characteristic) {
String mdata=null;
// 这是心率测量配置文件。
if (UUID_HEART_RATE_MEASUREMENT.equals(characteristic.getUuid())) {
int flag = characteristic.getProperties();
int format = -1;
if ((flag & 0x01) != 0) {
format = BluetoothGattCharacteristic.FORMAT_UINT16;
Log.d(TAG, "Heart rate format UINT16.");
} else {
format = BluetoothGattCharacteristic.FORMAT_UINT8;
Log.d(TAG, "Heart rate format UINT8.");
}
final int heartRate = characteristic.getIntValue(format, 1);
Log.d(TAG, String.format("Received heart rate: %d", heartRate));
mdata=String.valueOf(heartRate);
} else {
// 对于所有其他的配置文件，用十六进制格式写数据
final byte[] data = characteristic.getValue();
if (data != null && data.length > 0) {
final StringBuilder stringBuilder = new StringBuilder(data.length);
for(byte byteChar : data)
stringBuilder.append(String.format("%02X ", byteChar));
mdata=new String(data) + "\n" +stringBuilder.toString();
}
}
vble.SetMeasureData(mdata,characteristic);
}

/**
* 设置当指定characteristic值变化时，发出通知
* <p>
* 当 其发生变化时会使 onCharacteristicChanged()回调被触发*/
public void SetCharacteristicNotification(BluetoothGattCharacteristic characteristic, boolean enabled){
if(bluetoothadapter!=null&&bluetoothGatt!=null){
bluetoothGatt.setCharacteristicNotification(characteristic, enabled);
BluetoothGattDescriptor descriptor=characteristic.getDescriptor(UUID.fromString("00002902-0000-1000-8000-00805f9b34fb"));
if(descriptor!=null){
LogMore("set descriptor" + descriptor + descriptor.getValue());
if(enabled){
descriptor.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE);
}
else{
descriptor.setValue(BluetoothGattDescriptor.DISABLE_NOTIFICATION_VALUE);
}
bluetoothGatt.writeDescriptor(descriptor);
}
}
}
/**
* 向设备写入数据
* @param characteristic
*/
public void WriteData(BluetoothGattCharacteristic characteristic){
if(bluetoothadapter!=null&&bluetoothGatt!=null){
bluetoothGatt.writeCharacteristic(characteristic);
}
}
/**读取蓝牙数据
* @param characteristic */
public void ReadData(BluetoothGattCharacteristic characteristic){
if(bluetoothadapter!=null&&bluetoothGatt!=null){
bluetoothGatt.readCharacteristic(characteristic);
}
}
/**断开连接*/
public void disconnect(){
if(bluetoothadapter!=null &&bluetoothGatt !=null){
bluetoothGatt.disconnect();
LogMore("disconnect");
}
}
/**关闭连接*/
public void closeconnect(){
if(bluetoothadapter!=null &&bluetoothGatt !=null){
bluetoothGatt.close();
bluetoothGatt=null;
LogMore("close");
}
}
//-----------------------------------------------
private void ToastMore(String string){
Toast.makeText(context, string,Toast.LENGTH_SHORT).show();
}
private void LogMore(String string){
Log.i(TAG,string);
}
}

应用：

import java.util.List;
import com.siheal.bledevice66b6b5.R;
import com.siheal.bledevice66b6b5.presenter.BluetoothHandle;
import com.siheal.bledevice66b6b5.presenter.BluetoothHandle.VBle;
import android.os.Bundle;
import android.os.Handler;
import android.view.View;
import android.view.View.OnClickListener;
import android.app.Activity;
import android.bluetooth.BluetoothGattCharacteristic;
import android.bluetooth.BluetoothGattService;
import android.widget.TextView;

public class MainActivity extends Activity implements VBle , OnClickListener {
private TextView measureData;
/**蓝牙工具类*/
private BluetoothHandle blehandle;
/**ָ指定需要查找的设备名*/
private String assigndevicename="BT05";
/** 是否允许测量*/
private boolean allowmeasure=false;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
blehandle=new BluetoothHandle(this);
measureData=(TextView) findViewById(R.id.measureData);
findViewById(R.id.searchdevice).setOnClickListener(this);
allowmeasure=blehandle.EnableBle();
}
@Override
protected void onResume() {
super.onResume();
if(allowmeasure)
blehandle.SearchDevice(true,assigndevicename);
}
@Override
protected void onPause() {
super.onPause();
if(allowmeasure){
blehandle.SearchDevice(false, null);
blehandle.disconnect();
}
}

@Override
protected void onStop() {
super.onStop();
if(allowmeasure){
blehandle.SearchDevice(false, null);
blehandle.closeconnect();
}
}
@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.searchdevice:
if(allowmeasure){
blehandle.SearchDevice(true,assigndevicename);
}
break;
}
}
@Override
public void WriteDatatoBle(List<BluetoothGattService> supportedGattServices) {
for(BluetoothGattService getservice:supportedGattServices){
for(final BluetoothGattCharacteristic characteristic : getservice.getCharacteristics()){
new Handler().postDelayed(new Runnable() {

@Override
public void run() {
characteristic.setValue("写入数据");
blehandle.WriteData(characteristic);
}
}, 150);
}
}

}
@Override
public void SetMeasureData(String data, BluetoothGattCharacteristic characteristic) {
if(data.contains("自己设备数据的特定标识符")){
measureData.setText(data);
}else {
//如果不是我们需要的那么根据需要在向设备写入
characteristic.setValue("写入数据");
blehandle.WriteData(characteristic);
}
}
}