Android蓝牙周边设备开发

本文只讲述实际开发中的最基本的概念、用法及代码，不过多深入概念及源码。

什么是周边设备

  • BLE（蓝牙4.0+） 有两种状态模式：中心（center）及peripheral（周边）。
  • 大多数中心设备的扮演者是手机、电脑等能主动去连接别人的设备，而大多数周边设备就等着这些中心设备连接，如手环、血糖仪等。
  • Android从 Lolipop 开始支持了BLE Peripheral（周边设备）开发。
  • 如果你希望使Android设备开启为周边设备模式，请往下看。

配置

在 AndroidManifest.xml 中 添加以下权限：

1
2
3
4
5
6
7
8
9
10
<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
<!-- 6.0之后蓝牙还需要地理位置权限 -->
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<!-- 只扫描ble设备 -->
<uses-feature
	android:name="android.hardware.bluetooth_le"
	android:required="true" />

开启蓝牙

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
// 是否支持ble
if (!mContext.getPackageManager().hasSystemFeature(PackageManager.FEATURE_BLUETOOTH_LE)) {
	Toast.makeText(mContext, "hasSystemFeature == false", Toast.LENGTH_SHORT).show();
	return false;
}
// 是否能获取到蓝牙服务
mBluetoothManager = (BluetoothManager) mContext.getSystemService(Context.BLUETOOTH_SERVICE);
if (mBluetoothManager == null) {
	Toast.makeText(mContext, "mBluetoothManager == null", Toast.LENGTH_LONG).show();
	return false;
}
// 获取蓝牙适配器
mBluetoothAdapter = mBluetoothManager.getAdapter();
if (mBluetoothAdapter == null) {
	Toast.makeText(mContext, "BluetoothAdapter == null", Toast.LENGTH_LONG).show();
	return false;
}
// 蓝牙是否打开
if (!mBluetoothAdapter.isEnabled()) {
	Toast.makeText(mContext, "BluetoothAdapter.isEnabled == false", Toast.LENGTH_LONG).show();
	return false;
}
// 获取广播者
mBluetoothLeAdvertiser = mBluetoothAdapter.getBluetoothLeAdvertiser();
	if (mBluetoothLeAdvertiser == null) {
	Toast.makeText(mContext, "BluetoothLeAdvertiser == null ", Toast.LENGTH_LONG).show();
	return false;
}

到这里如果 mBluetoothLeAdvertiser 为空，请换设备再继续（国内部分机型不支持）

建立服务

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
// 给个风骚的广播名称，默认是手机设置里蓝牙的名称
mBluetoothAdapter.setName("Bleoo");
// 这个Callback 是设备广播成功后所有状态的回调，包括读写等
mGattServerCallback = new PeriServerCallBack();
// 打开GattServer
mGattServer = mBluetoothManager.openGattServer(mContext, mGattServerCallback);
// 创建一个特征通道用来写
mWriteCharacter = new BluetoothGattCharacteristic(
		UUID.fromString(Constants.CHARACTERISTIC_WRITEABLE),
		BluetoothGattCharacteristic.PROPERTY_WRITE | BluetoothGattCharacteristic.PROPERTY_READ,
		BluetoothGattCharacteristic.PERMISSION_WRITE | BluetoothGattCharacteristic.PERMISSION_READ);
// 创建一个特征通道用来读
mReadCharacter = new BluetoothGattCharacteristic(
		UUID.fromString(Constants.CHARACTERISTIC_READABLE),
		BluetoothGattCharacteristic.PROPERTY_WRITE | BluetoothGattCharacteristic.PROPERTY_READ,
		BluetoothGattCharacteristic.PERMISSION_WRITE | BluetoothGattCharacteristic.PERMISSION_READ);
// 创建一个Gatt服务
mGattService = new BluetoothGattService(
		UUID.fromString(Constants.GATT_SERVICE_PRIMARY),
		BluetoothGattService.SERVICE_TYPE_PRIMARY);
// 添加读写通道
mGattService.addCharacteristic(mWriteCharacter);
mGattService.addCharacteristic(mReadCharacter);
// 添加服务
if (mGattServer != null && mGattService != null)
	mGattServer.addService(mGattService);

开启广播

成功开启广播后，中心设备能够扫描到你的设备，当然前提是中心设备支持ble设备，并且在扫描ble设备。
中心设备能获取到你ble设备的所有信息，包括 GattService 及其 BluetoothGattCharacteristic。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public void startAdvertising() {
	// 这里的Callback是是否开启成功的回调
	mBluetoothLeAdvertiser.startAdvertising(createAdvSettings(true, 0), createAdvertiseData(), mAdvCallback);
}
private AdvertiseSettings createAdvSettings(boolean connectable, int timeoutMillis) {
	AdvertiseSettings.Builder builder = new AdvertiseSettings.Builder();
	//设置广播的模式,跟功耗相关
	builder.setAdvertiseMode(AdvertiseSettings.ADVERTISE_MODE_BALANCED);
	builder.setTxPowerLevel(AdvertiseSettings.ADVERTISE_TX_POWER_HIGH);
	builder.setConnectable(connectable);
	builder.setTimeout(timeoutMillis);
	return builder.build();
}
//设置广播数据（可以携带广播数据，这里没有携带）
private AdvertiseData createAdvertiseData() {
	AdvertiseData.Builder builder = new AdvertiseData.Builder();
	builder.setIncludeDeviceName(true);
	return builder.build();
}

广播回调

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//发送广播的回调
private AdvertiseCallback mAdvCallback = new AdvertiseCallback() {
	public void onStartSuccess(AdvertiseSettings settingsInEffect) {
		mOnCallBackListener.advertisingStatus(true);
		if (settingsInEffect != null) {
			LogUtil.e("onStartSuccess TxPowerLv=" + settingsInEffect.getTxPowerLevel()
					+ " mode=" + settingsInEffect.getMode() + " timeout=" + settingsInEffect.getTimeout());
		} else {
			LogUtil.e("onStartSuccess, settingInEffect is null");
		}
	}
	public void onStartFailure(int errorCode) {
		mOnCallBackListener.advertisingStatus(false);
		LogUtil.e("onStartFailure errorCode=" + errorCode);
	}
};

Gatt服务回调

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
private class PeriServerCallBack extends BluetoothGattServerCallback {
	//当添加一个GattService成功后会回调改接口。
	@Override
	public void onServiceAdded(int status, BluetoothGattService service) {
		if (status == BluetoothGatt.GATT_SUCCESS) {
			LogUtil.e("onServiceAdded status=GATT_SUCCESS service=" + service.getUuid().toString());
		} else {
			LogUtil.e("onServiceAdded status!=GATT_SUCCESS");
		}
	}
	
	//BLE连接状态改变后回调的接口
	@Override
	public void onConnectionStateChange(android.bluetooth.BluetoothDevice device, int status, int newState) {
		mClientDevice = device;
		LogUtil.e("BLE连接状态改变 status=" + status + "->" + newState + " ==== Address: " + device.getAddress());
	}
	
	//当有客户端来读数据时回调的接口
	@Override
	public void onCharacteristicReadRequest(android.bluetooth.BluetoothDevice device,
				int requestId, int offset, BluetoothGattCharacteristic characteristic) {
		mClientDevice = device;
		LogUtil.e("客户端读数据 requestId=" + requestId + " offset=" + offset);
		mGattServer.sendResponse(device, requestId, BluetoothGatt.GATT_SUCCESS, offset, characteristic.getValue());
	}
	
	//当有客户端来写数据时回调的接口
	@Override
	public void onCharacteristicWriteRequest(android.bluetooth.BluetoothDevice device, int requestId,
				BluetoothGattCharacteristic characteristic, boolean preparedWrite,
				boolean responseNeeded, int offset, byte[] value) {
		mClientDevice = device;
		try {
			String msg = new String(value, "UTF-8");
			mOnCallBackListener.writeRequest(msg);
			LogUtil.e("客户端写数据 + message= " + msg + " requestId= " + requestId + " offset= " + offset);
			} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		// 必须sendResponse用于响应（具体原因也不清楚，似乎是为了保持连接）
		mGattServer.sendResponse(device, requestId, BluetoothGatt.GATT_SUCCESS, offset, null);
	}
	//当有客户端来写Descriptor时回调的接口
	@Override
	public void onDescriptorWriteRequest(BluetoothDevice device, int requestId, BluetoothGattDescriptor descriptor,
				boolean preparedWrite, boolean responseNeeded, int offset, byte[] value) {
		mClientDevice = device;
		LogUtil.e("onDescriptorWriteRequest === ");
		// now tell the connected device that this was all successfull
		mGattServer.sendResponse(device, requestId, BluetoothGatt.GATT_SUCCESS, offset, value);
	}
}

写出数据

与中心设备的写出方法不同，周边设备通过 notifyCharacteristicChanged 方法，类似通知的方法写出数据。
当然，sendResponse 也能用于返回数据。

1
2
3
4
5
6
7
8
public boolean write(byte[] value) {
    if (mWriteCharacter == null)
        return false;
    if (mGattServer == null)
        return false;
    mWriteCharacter.setValue(value);
    return mGattServer.notifyCharacteristicChanged(mClientDevice, mWriteCharacter, false);
}

扫一扫，分享到微信

微信分享二维码