分享Android 蓝牙4.0(ble)开发的解决方案

来源：互联网发布：虚拟机ubuntu怎样重置编辑：程序博客网时间：2024/04/30 14:15

http://www.jb51.net/article/80756.htm

这篇文章主要为大家分享了Android 蓝牙4.0(ble)开发的解决方案，感兴趣的小伙伴们可以参考一下

最近，随着智能穿戴式设备、智能医疗以及智能家居的普及，蓝牙开发在移动开中显得非常的重要。由于公司需要，研究了一下，蓝牙4.0在Android中的应用。

以下是我的一些总结。

1.先介绍一下关于蓝牙4.0中的一些名词吧：
(1)、GATT(Gneric Attibute Profile)

通过ble连接，读写属性类小数据Profile通用的规范。现在所有的ble应用Profile 都是基于GATT
(2)、ATT(Attribute Protocal)
GATT是基于ATT Potocal的ATT针对BLE设备专门做的具体就是传输过程中使用尽量少的数据，每个属性都有个唯一的UUID，属性chartcteristics and Service的形式传输。

(3)、Service是Characteristic的集合。
(4)、Characteristic 特征类型。

比如，有个蓝牙ble的血压计。他可能包括多个Servvice，每个Service有包括多个Characteristic

注意：蓝牙ble只能支持Android 4.3以上的系统 SDK>=18

2.以下是开发的步骤：
2.1首先获取BluetoothManager

复制代码代码如下:

BluetoothManager bluetoothManager = (BluetoothManager) getSystemService(Context.BLUETOOTH_SERVICE); 

2.2获取BluetoothAdapter

复制代码代码如下:

BluetoothAdapter mBluetoothAdapter = bluetoothManager.getAdapter();

2.3创建BluetoothAdapter.LeScanCallback

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
privateBluetoothAdapter.LeScanCallback mLeScanCallback = newBluetoothAdapter.LeScanCallback() { 
  
  @Override
  publicvoid onLeScan(finalBluetoothDevice device, intrssi, finalbyte[] scanRecord) { 
  
   runOnUiThread(newRunnable() { 
    @Override
    publicvoid run() { 
     try{ 
      String struuid = NumberUtils.bytes2HexString(NumberUtils.reverseBytes(scanRecord)).replace("-","").toLowerCase();
      if(device!=null&& struuid.contains(DEVICE_UUID_PREFIX.toLowerCase())) { 
       mBluetoothDevices.add(device);
      }
     }catch(Exception e) { 
      e.printStackTrace();
     }
    }
   });
  }
 };

2.4.开始搜索设备。

复制代码代码如下:

mBluetoothAdapter.startLeScan(mLeScanCallback);

2.5.BluetoothDevice 描述了一个蓝牙设备提供了getAddress()设备Mac地址,getName()设备的名称。
2.6开始连接设备

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
/**
 * Connects to the GATT server hosted on the Bluetooth LE device. 
 *
 * @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. 
 */
publicboolean connect(finalString address) { 
 if(mBluetoothAdapter == null|| address == null) { 
  Log.w(TAG,"BluetoothAdapter not initialized or unspecified address.");
  returnfalse;
 }
 
 // Previously connected device. Try to reconnect. (先前连接的设备。 尝试重新连接) 
 if(mBluetoothDeviceAddress != null&& address.equals(mBluetoothDeviceAddress) && mBluetoothGatt != null) { 
  Log.d(TAG,"Trying to use an existing mBluetoothGatt for connection.");
  if(mBluetoothGatt.connect()) { 
   mConnectionState = STATE_CONNECTING; 
   returntrue;
  }else{ 
   returnfalse;
  }
 }
 
 finalBluetoothDevice device = mBluetoothAdapter.getRemoteDevice(address); 
 if(device == null) { 
  Log.w(TAG,"Device not found. Unable to connect.");
  returnfalse;
 }
 // We want to directly connect to the device, so we are setting the 
 // autoConnect 
 // parameter to false. 
 mBluetoothGatt = device.connectGatt(this,false, mGattCallback); 
 Log.d(TAG,"Trying to create a new connection.");
 mBluetoothDeviceAddress = address; 
 mConnectionState = STATE_CONNECTING; 
 returntrue;
}

2.7连接到设备之后获取设备的服务(Service)和服务对应的Characteristic。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
// Demonstrates how to iterate through the supported GATT 
// Services/Characteristics. 
// In this sample, we populate the data structure that is bound to the 
// ExpandableListView 
// on the UI. 
privatevoid displayGattServices(List<BluetoothGattService> gattServices) { 
 if(gattServices == null)
  return;
 String uuid = null;
 ArrayList<HashMap<String, String>> gattServiceData = newArrayList<>(); 
 ArrayList<ArrayList<HashMap<String, String>>> gattCharacteristicData = newArrayList<>(); 
  
 mGattCharacteristics = newArrayList<>(); 
  
 // Loops through available GATT Services. 
 for(BluetoothGattService gattService : gattServices) { 
  HashMap<String, String> currentServiceData = newHashMap<>(); 
  uuid = gattService.getUuid().toString(); 
  if(uuid.contains("ba11f08c-5f14-0b0d-1080")) {//服务的uuid
   //System.out.println("this gattService UUID is:" + gattService.getUuid().toString()); 
   currentServiceData.put(LIST_NAME,"Service_OX100");
   currentServiceData.put(LIST_UUID, uuid); 
   gattServiceData.add(currentServiceData);
   ArrayList<HashMap<String, String>> gattCharacteristicGroupData = newArrayList<>(); 
   List<BluetoothGattCharacteristic> gattCharacteristics = gattService.getCharacteristics(); 
   ArrayList<BluetoothGattCharacteristic> charas = newArrayList<>(); 
  
   // Loops through available Characteristics. 
   for(BluetoothGattCharacteristic gattCharacteristic : gattCharacteristics) { 
    charas.add(gattCharacteristic);
    HashMap<String, String> currentCharaData = newHashMap<>(); 
    uuid = gattCharacteristic.getUuid().toString(); 
    if(uuid.toLowerCase().contains("cd01")) { 
     currentCharaData.put(LIST_NAME,"cd01");
    }elseif (uuid.toLowerCase().contains("cd02")) { 
     currentCharaData.put(LIST_NAME,"cd02");
    }elseif (uuid.toLowerCase().contains("cd03")) { 
     currentCharaData.put(LIST_NAME,"cd03");
    }elseif (uuid.toLowerCase().contains("cd04")) { 
     currentCharaData.put(LIST_NAME,"cd04");
    }else{ 
     currentCharaData.put(LIST_NAME,"write");
    }
  
    currentCharaData.put(LIST_UUID, uuid); 
    gattCharacteristicGroupData.add(currentCharaData);
   }
  
   mGattCharacteristics.add(charas);
  
   gattCharacteristicData.add(gattCharacteristicGroupData);
  
   mCharacteristicCD01 = gattService.getCharacteristic(UUID.fromString("0000cd01-0000-1000-8000-00805f9b34fb"));
   mCharacteristicCD02 = gattService.getCharacteristic(UUID.fromString("0000cd02-0000-1000-8000-00805f9b34fb"));
   mCharacteristicCD03 = gattService.getCharacteristic(UUID.fromString("0000cd03-0000-1000-8000-00805f9b34fb"));
   mCharacteristicCD04 = gattService.getCharacteristic(UUID.fromString("0000cd04-0000-1000-8000-00805f9b34fb"));
   mCharacteristicWrite = gattService.getCharacteristic(UUID.fromString("0000cd20-0000-1000-8000-00805f9b34fb"));
  
   //System.out.println("=======================Set Notification=========================="); 
   // 开始顺序监听，第一个：CD01 
   mBluetoothLeService.setCharacteristicNotification(mCharacteristicCD01,true);
   mBluetoothLeService.setCharacteristicNotification(mCharacteristicCD02,true);
   mBluetoothLeService.setCharacteristicNotification(mCharacteristicCD03,true);
   mBluetoothLeService.setCharacteristicNotification(mCharacteristicCD04,true);
  }
 }
}

2.8获取到特征之后，找到服务中可以向下位机写指令的特征，向该特征写入指令。

?
1
2
3
4
5
6
7
8
9
10
publicvoid wirteCharacteristic(BluetoothGattCharacteristic characteristic) { 
  
  if(mBluetoothAdapter == null|| mBluetoothGatt == null) { 
   Log.w(TAG,"BluetoothAdapter not initialized");
   return;
  }
  
  mBluetoothGatt.writeCharacteristic(characteristic);
  
 }

2.9写入成功之后，开始读取设备返回来的数据。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
privatefinal BluetoothGattCallback mGattCallback = newBluetoothGattCallback() { 
  @Override
  publicvoid onConnectionStateChange(BluetoothGatt gatt, intstatus, intnewState) { 
   String intentAction; 
   //System.out.println("=======status:" + status); 
   if(newState == BluetoothProfile.STATE_CONNECTED) { 
    intentAction = ACTION_GATT_CONNECTED; 
    mConnectionState = STATE_CONNECTED; 
    broadcastUpdate(intentAction);
    Log.i(TAG,"Connected to GATT server.");
    // Attempts to discover services after successful connection. 
    Log.i(TAG,"Attempting to start service discovery:" + mBluetoothGatt.discoverServices()); 
  
   }elseif (newState == BluetoothProfile.STATE_DISCONNECTED) { 
    intentAction = ACTION_GATT_DISCONNECTED; 
    mConnectionState = STATE_DISCONNECTED; 
    Log.i(TAG,"Disconnected from GATT server.");
    broadcastUpdate(intentAction);
   }
  }
  
  @Override
  publicvoid onServicesDiscovered(BluetoothGatt gatt, intstatus) { 
   if(status == BluetoothGatt.GATT_SUCCESS) { 
    broadcastUpdate(ACTION_GATT_SERVICES_DISCOVERED);
   }else{ 
    Log.w(TAG,"onServicesDiscovered received: " + status); 
   }
  }
  //从特征中读取数据
  @Override
  publicvoid onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic,intstatus) { 
   //System.out.println("onCharacteristicRead");
   if(status == BluetoothGatt.GATT_SUCCESS) { 
    broadcastUpdate(ACTION_DATA_AVAILABLE, characteristic); 
   }
  }
  //向特征中写入数据
  @Override
  publicvoid onCharacteristicWrite(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic,intstatus) { 
   //System.out.println("--------write success----- status:" + status); 
  }
  
  /*
   * when connected successfully will callback this method this method can 
   * dealwith send password or data analyze 
    
   *当连接成功将回调该方法
   */
  @Override
  publicvoid onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
   broadcastUpdate(ACTION_DATA_AVAILABLE, characteristic); 
   if(characteristic.getValue() != null) { 
  
    //System.out.println(characteristic.getStringValue(0));
   }
   //System.out.println("--------onCharacteristicChanged-----");
  }
  
  @Override
  publicvoid onDescriptorWrite(BluetoothGatt gatt, BluetoothGattDescriptor descriptor, intstatus) { 
  
   //System.out.println("onDescriptorWriteonDescriptorWrite = " + status + ", descriptor =" + descriptor.getUuid().toString()); 
  
   UUID uuid = descriptor.getCharacteristic().getUuid(); 
   if(uuid.equals(UUID.fromString("0000cd01-0000-1000-8000-00805f9b34fb"))) { 
    broadcastUpdate(ACTION_CD01NOTIDIED);
   }elseif (uuid.equals(UUID.fromString("0000cd02-0000-1000-8000-00805f9b34fb"))) { 
    broadcastUpdate(ACTION_CD02NOTIDIED);
   }elseif (uuid.equals(UUID.fromString("0000cd03-0000-1000-8000-00805f9b34fb"))) { 
    broadcastUpdate(ACTION_CD03NOTIDIED);
   }elseif (uuid.equals(UUID.fromString("0000cd04-0000-1000-8000-00805f9b34fb"))) { 
    broadcastUpdate(ACTION_CD04NOTIDIED);
   }
  }
  
  @Override
  publicvoid onReadRemoteRssi(BluetoothGatt gatt, intrssi, intstatus) { 
   //System.out.println("rssi = " + rssi); 
  }
 };
   
 ----------------------------------------------
  //从特征中读取数据
  @Override
  publicvoid onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic,intstatus) { 
   //System.out.println("onCharacteristicRead");
   if(status == BluetoothGatt.GATT_SUCCESS) { 
    broadcastUpdate(ACTION_DATA_AVAILABLE, characteristic); 
   }
  }

2.10、断开连接

?
1
2
3
4
5
6
7
8
9
10
11
12
13
/**
  * 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. 
  */
 publicvoid disconnect() { 
  if(mBluetoothAdapter == null|| mBluetoothGatt == null) { 
   Log.w(TAG,"BluetoothAdapter not initialized");
   return;
  }
  mBluetoothGatt.disconnect();
 }

2.11、数据的转换方法

?
1
2
3
4
5
6
7
8
9
10
11
12
// byte转十六进制字符串 
 publicstatic String bytes2HexString(byte[] bytes) { 
  String ret = "";
  for(byteaByte : bytes) { 
   String hex = Integer.toHexString(aByte & 0xFF);
   if(hex.length() == 1) { 
    hex = '0'+ hex; 
   }
   ret += hex.toUpperCase(Locale.CHINA); 
  }
  returnret; 
 }

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/**
  * 将16进制的字符串转换为字节数组 
  *
  * @param message 
  * @return 字节数组 
  */
 publicstatic byte[] getHexBytes(String message) { 
  intlen = message.length() / 2;
  char[] chars = message.toCharArray(); 
  String[] hexStr = newString[len]; 
  byte[] bytes = newbyte[len];
  for(inti = 0, j = 0; j < len; i += 2, j++) { 
   hexStr[j] = ""+ chars[i] + chars[i + 1];
   bytes[j] = (byte) Integer.parseInt(hexStr[j], 16);
  }
  returnbytes; 
 }

大概整体就是如上的步骤，但是也是要具体根据厂家的协议来实现通信的过程。

就拿一个我们项目中的demo说一下。
一个蓝牙ble的血压计。上位机---手机下位机 -- 血压计
1.血压计与手机连接蓝牙之后。
2.上位机主动向下位机发送一个身份验证指令，下位机收到指令后开始给上位做应答，
3.应答成功，下位机会将测量的血压数据传送到上位机。
4.最后断开连接。

希望本文对大家学习Android蓝牙技术有所帮助。

0 0