Flutter蓝牙框架-flutter_blue_plus使用及源码解析
前言
前段时间有朋友拜托我研究下flutter利用蓝牙与硬件交互的功能，我查阅了很多资料，目前市面上比较流行的第三方库有两个，一个是flutter_blue_plus，一个是flutter_reactive_ble，前一个比较轻量级，能满足大部分场景，后一个比较复杂，支持多个蓝牙设备同时连接。那么这一次我们先来研究下flutter_blue_plus，剩下的flutter_reactive_ble下次有机会再来看。
低功耗蓝牙（BLE）原理
博主好几年前还做Android原生开发时就接触并研究过BLE在Android平台上的使用与原理，写过一篇文章，大家感兴趣可以去看看。本次主要研究flutter_blue_plus(v1.6.1)，对BLE原理不做过多描述。
使用及源码解析
要搞清楚如何使用flutter_blue_plus，最好的办法就是查阅文档或者查看flutter_reactive_ble的代码。这一次，我们就从flutter_reactive_ble库中example目录下的示例代码开始，一步一步看看如何使用flutter_blue_plus。
- 首先，我们打开main.dart文件。能够看到runApp里创建了我们示例的根组件-FlutterBlueApp。
runApp(const FlutterBlueApp());我们来看看FlutterBlueApp是怎么写的：
class FlutterBlueApp extends StatelessWidget { const FlutterBlueApp({Key? key}) : super(key: key); Widget build(BuildContext context) { return MaterialApp( color: Colors.lightBlue, home: StreamBuilder<BluetoothState>( stream: FlutterBluePlus.instance.state, initialData: BluetoothState.unknown, builder: (c, snapshot) { final state = snapshot.data; if (state == BluetoothState.on) { return const FindDevicesScreen(); } return BluetoothOffScreen(state: state); }), ); }}我们看到，这里利用了一个StreamBuilder去监听Stream的变化，主要是BluetoothState。蓝牙设备的状态，然后根据实时状态去变化展示的内容。
BluetoothState是一个枚举类，定义了几种可能的状态：
/// State of the bluetooth adapter.enum BluetoothState{ unknown, unavailable, unauthorized, turningOn, on, turningOff, off}initialData是StreamBuilder中绘制第一帧的数据，由于是BluetoothState.unknown，所以第一帧应该显示BluetoothOffScreen。之后的状态由stream中的异步数据提供，即FlutterBluePlus.instance.state，我们看看FlutterBluePlus这个类：
class FlutterBluePlus{ static final FlutterBluePlus _instance = FlutterBluePlus._(); static FlutterBluePlus get instance => _instance; .... /// Singleton boilerplate FlutterBluePlus._() { .... }....} 可以看到，FlutterBluePlus是一个利用dart getter操作符实现的一个单例类，通过FlutterBluePlus.instance获取全局唯一的一个实例。
接着我们看下FlutterBluePlus.instance.state，这个state也是一个getter方法：
/// Gets the current state of the Bluetooth module Stream<BluetoothState> get state async* { BluetoothState initialState = await _channel .invokeMethod('state') .then((buffer) => protos.BluetoothState.fromBuffer(buffer)) .then((s) => BluetoothState.values[s.state.value]); yield initialState; _stateStream ??= _stateChannel .receiveBroadcastStream() .map((buffer) => protos.BluetoothState.fromBuffer(buffer)) .map((s) => BluetoothState.values[s.state.value]) .doOnCancel(() => _stateStream = null); yield* _stateStream!; }可以看到，由于蓝牙涉及到原生操作系统底层的功能，所以需要利用平台通道（platform channel）机制，实现 Dart 代码与原生代码的交互，间接调用Android/IOS SDK的Api。
final MethodChannel _channel = const MethodChannel('flutter_blue_plus/methods'); final EventChannel _stateChannel = const EventChannel('flutter_blue_plus/state');在FlutterBluePlus这个类中，首先构造一个方法通道（method channel）与一个事件通道（event channel），通道的客户端(flutter方)和宿主端(原生方)通过传递给通道构造函数的通道名称进行连接，这个名称必须是唯一的。之后就可以通过_channel.invokeMethod调用原生的方法了，当然前提是原生平台有对应的实现。接下来，我们看下state这个方法，原生端是如何实现的(以Android为例)：
在flutter_blue_plus库的android目录下，能看到一个FlutterBluePlusPlugin.java文件：
public class FlutterBluePlusPlugin implements FlutterPlugin, MethodCallHandler,.... @Override public void onAttachedToEngine(@NonNull FlutterPluginBinding flutterPluginBinding) { setup(pluginBinding.getBinaryMessenger(), (Application) pluginBinding.getApplicationContext()); }.... private void setup(final BinaryMessenger messenger, final Application application) { .... channel = new MethodChannel(messenger, NAMESPACE + "/methods"); channel.setMethodCallHandler(this); stateChannel = new EventChannel(messenger, NAMESPACE + "/state"); stateChannel.setStreamHandler(stateHandler); .... } @Override public void onDetachedFromEngine(@NonNull FlutterPluginBinding binding) { .... tearDown(); } private void tearDown() { .... channel.setMethodCallHandler(null); channel = null; stateChannel.setStreamHandler(null); stateChannel = null; .... } }可以看到，FlutterBluePlusPlugin实现了FlutterPlugin与MethodCallHandler两个接口，实现FlutterPlugin的onAttachedToEngine与onDetachedFromEngine两个方法后，就可以将插件与flutter的engine关联起来。在这两个方法中，主要是构造了MethodChannel与EventChannel并在最后置为空，作用是在一开始注册通道并在最后销毁掉。
而实现MethodCallHandler的onMethodCall方法，即在原生端实现相应的功能方便flutter通道调用：
@Override public void onMethodCall(@NonNull MethodCall call, @NonNull Result result) { .... switch (call.method) { .... case "state": { try { // get state, if we can int state = -1; try { state = mBluetoothAdapter.getState(); } catch (Exception e) {} // convert to protobuf enum Protos.BluetoothState.State pbs; switch(state) { case BluetoothAdapter.STATE_OFF: pbs = Protos.BluetoothState.State.OFF; break; case BluetoothAdapter.STATE_ON: pbs = Protos.BluetoothState.State.ON; break; case BluetoothAdapter.STATE_TURNING_OFF: pbs = Protos.BluetoothState.State.TURNING_OFF; break; case BluetoothAdapter.STATE_TURNING_ON: pbs = Protos.BluetoothState.State.TURNING_ON; break; default: pbs = Protos.BluetoothState.State.UNKNOWN; break; } Protos.BluetoothState.Builder p = Protos.BluetoothState.newBuilder(); p.setState(pbs); result.success(p.build().toByteArray()); } catch(Exception e) { result.error("state", e.getMessage(), e); } break; } ....可以看到，Android端拿到蓝牙状态后通过result.success返回结果。
state方法只能获取初始状态，后面状态的变化我们看到是通过EventChannel监听广播获取的，我们看看在原生端是怎么处理的。
在创建EventChannel时，首先将它的StreamHandler设置为我们自定义的StreamHandler函数:
private class MyStreamHandler implements StreamHandler { private final int STATE_UNAUTHORIZED = -1; private EventSink sink; public EventSink getSink() { return sink; } private int cachedBluetoothState; public void setCachedBluetoothState(int value) { cachedBluetoothState = value; } public void setCachedBluetoothStateUnauthorized() { cachedBluetoothState = STATE_UNAUTHORIZED; } @Override public void onListen(Object o, EventChannel.EventSink eventSink) { sink = eventSink; if (cachedBluetoothState != 0) { // convert to Protobuf enum Protos.BluetoothState.State pbs; switch (cachedBluetoothState) { case BluetoothAdapter.STATE_OFF: pbs = Protos.BluetoothState.State.OFF; break; case BluetoothAdapter.STATE_ON: pbs = Protos.BluetoothState.State.ON; break; case BluetoothAdapter.STATE_TURNING_OFF: pbs = Protos.BluetoothState.State.TURNING_OFF; break; case BluetoothAdapter.STATE_TURNING_ON: pbs = Protos.BluetoothState.State.TURNING_ON; break; case STATE_UNAUTHORIZED: pbs = Protos.BluetoothState.State.OFF; break; default: pbs = Protos.BluetoothState.State.UNKNOWN; break; } Protos.BluetoothState.Builder p = Protos.BluetoothState.newBuilder(); p.setState(pbs); sink.success(p.build().toByteArray()); } } @Override public void onCancel(Object o) { sink = null; } };在MyStreamHandler的onListen方法里，我们拿到EventSink引用并保存，并查看是否有缓存未发送的蓝牙状态，有的话就利用EventSink发送给Stream。
之后，我们注册一个监听蓝牙状态变化的广播，将当前蓝牙状态设置为MyStreamHandler的缓存状态cachedBluetoothState：
IntentFilter filter = new IntentFilter(BluetoothAdapter.ACTION_STATE_CHANGED);context.registerReceiver(mBluetoothStateReceiver, filter);try { stateHandler.setCachedBluetoothState(mBluetoothAdapter.getState()); } catch (SecurityException e) { stateHandler.setCachedBluetoothStateUnauthorized(); }注册的广播代码如下：
private final BroadcastReceiver mBluetoothStateReceiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { final String action = intent.getAction(); // no change? if (BluetoothAdapter.ACTION_STATE_CHANGED.equals(action) == false) { return; } final int state = intent.getIntExtra(BluetoothAdapter.EXTRA_STATE, BluetoothAdapter.ERROR); EventSink sink = stateHandler.getSink(); if (sink == null) { stateHandler.setCachedBluetoothState(state); return; } // convert to Protobuf enum Protos.BluetoothState.State pbs; switch (state) { case BluetoothAdapter.STATE_OFF: pbs = Protos.BluetoothState.State.OFF; break; case BluetoothAdapter.STATE_ON: pbs = Protos.BluetoothState.State.ON; break; case BluetoothAdapter.STATE_TURNING_OFF: pbs = Protos.BluetoothState.State.TURNING_OFF; break; case BluetoothAdapter.STATE_TURNING_ON: pbs = Protos.BluetoothState.State.TURNING_ON; break; default: pbs = Protos.BluetoothState.State.UNKNOWN; break; } Protos.BluetoothState.Builder p = Protos.BluetoothState.newBuilder(); p.setState(pbs); sink.success(p); } };广播接收到蓝牙状态变化后，根据是否能获取到EventSink，看是缓存还是发送。
至此，蓝牙状态相关代码就分析完了。
- 之后，我们来看下BluetoothOffScreen，这个界面比较简单，除了展示蓝牙的状态之外，还提供了一个打开蓝牙的开关（只针对Android）。
onPressed: Platform.isAndroid ? () => FlutterBluePlus.instance.turnOn() : null,看看turnOn这个方法，也是通过MethodChannel实现的：
Future<bool> turnOn() { return _channel.invokeMethod('turnOn').then<bool>((d) => d); }我们再来FlutterPlugin的onMethodCall方法下找找原生对应的实现：
case "turnOn": { try { if (mBluetoothAdapter.isEnabled()) { result.success(true); // no work to do } Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE); activityBinding.getActivity().startActivityForResult(enableBtIntent, enableBluetoothRequestCode); result.success(true); } catch(Exception e) { result.error("turnOn", e.getMessage(), e); } break; }原生是通过Intent去打开系统服务蓝牙的，那么这里为了从插件中获取Activity用到的activityBinding是从哪里来的?
也是FlutterBluePlusPlugin通过实现ActivityAware这个接口，然后在onAttachedToActivity这个方法时获取到的ActivityPluginBinding引用，通过它我们就可以在插件中获取到FlutterActivity里的context和Activity了。
- 最后，我们看看FindDevicesScreen：
1）首先看看右下角的按钮
floatingActionButton: StreamBuilder<bool>( stream: FlutterBluePlus.instance.isScanning, initialData: false, builder: (c, snapshot) { if (snapshot.data!) { return FloatingActionButton( child: const Icon(Icons.stop), onPressed: () => FlutterBluePlus.instance.stopScan(), backgroundColor: Colors.red, ); } else { return FloatingActionButton( child: const Icon(Icons.search), onPressed: () => FlutterBluePlus.instance .startScan(timeout: const Duration(seconds: 4))); } }, ),这个按钮根据当前蓝牙是否在扫描，会展示开始搜索/停止搜索按钮。
先来看看startScan这个方法：
/// Starts a scan and returns a future that will complete once the scan has finished. /// Once a scan is started, call [stopScan] to stop the scan and complete the returned future. /// timeout automatically stops the scan after a specified [Duration]. /// To observe the results while the scan is in progress, listen to the [scanResults] stream, /// or call [scan] instead. Future startScan({ ScanMode scanMode = ScanMode.lowLatency, List<Guid> withServices = const [], List<Guid> withDevices = const [], List<String> macAddresses = const [], Duration? timeout, bool allowDuplicates = false, }) async { await scan( scanMode: scanMode, withServices: withServices, withDevices: withDevices, macAddresses: macAddresses, timeout: timeout, allowDuplicates: allowDuplicates) .drain(); return _scanResults.value; }再来看scan方法
/// Starts a scan for Bluetooth Low Energy devices and returns a stream /// of the [ScanResult] results as they are received. /// timeout calls stopStream after a specified [Duration]. /// You can also get a list of ongoing results in the [scanResults] stream. /// If scanning is already in progress, this will throw an [Exception]. Stream<ScanResult> scan({ ScanMode scanMode = ScanMode.lowLatency, List<Guid> withServices = const [], List<Guid> withDevices = const [], List<String> macAddresses = const [], Duration? timeout, bool allowDuplicates = false, }) async* { var settings = protos.ScanSettings.create() ..androidScanMode = scanMode.value ..allowDuplicates = allowDuplicates ..macAddresses.addAll(macAddresses) ..serviceUuids.addAll(withServices.map((g) => g.toString()).toList()); if (_isScanning.value == true) { throw Exception('Another scan is already in progress.'); } // push to isScanning stream _isScanning.add(true); // Clear scan results list _scanResults.add(<ScanResult>[]); Stream<ScanResult> scanResultsStream = FlutterBluePlus.instance._methodStream .where((m) => m.method == "ScanResult") .map((m) => m.arguments) .map((buffer) => protos.ScanResult.fromBuffer(buffer)) .map((p) => ScanResult.fromProto(p)) .takeWhile((element) => _isScanning.value) .doOnDone(stopScan); // Start listening now, before invokeMethod, to ensure we don't miss any results _scanResultsBuffer = _BufferStream.listen(scanResultsStream); // Start timer *after* stream is being listened to, to make sure we don't miss the timeout if (timeout != null) { _scanTimeout = Timer(timeout, () { _scanResultsBuffer?.close(); _isScanning.add(false); _channel.invokeMethod('stopScan'); }); } try { await _channel.invokeMethod('startScan', settings.writeToBuffer()); } catch (e) { print('Error starting scan.'); _isScanning.add(false); rethrow; } await for (ScanResult item in _scanResultsBuffer!.stream) { // update list of devices List<ScanResult> list = List<ScanResult>.from(_scanResults.value); if (list.contains(item)) { int index = list.indexOf(item); list[index] = item; } else { list.add(item); } _scanResults.add(list); yield item; } } final StreamController<MethodCall> _methodStreamController = StreamController.broadcast(); final _BehaviorSubject<bool> _isScanning = _BehaviorSubject(false); final _BehaviorSubject<List<ScanResult>> _scanResults = _BehaviorSubject([]);Stream<bool> get isScanning => _isScanning.stream; /// Returns a stream that is a list of [ScanResult] results while a scan is in progress. /// The list emitted is all the scanned results as of the last initiated scan. When a scan is /// first started, an empty list is emitted. The returned stream is never closed. /// One use for [scanResults] is as the stream in a StreamBuilder to display the /// results of a scan in real time while the scan is in progress. Stream<List<ScanResult>> get scanResults => _scanResults.stream; // Used internally to dispatch methods from platform. Stream<MethodCall> get _methodStream => _methodStreamController.stream;_isScanning是对StreamController的一个封装，FlutterBluePlus.instance.isScanning就是通过getter 拿到它的stream，_isScanning.add是往stream中添加一个布尔值，即当前是否正在扫描，然后_isScanning.value就可以拿到当前的状态。
_scanResults与_isScanning类似，但是它是放置扫描结果的。
_methodStream是用来监听MethodCall即通道方法调用的。
大概流程是先将扫描状态设置为true，然后清空扫描结果，接着监听一个叫ScanResult的通道方法调用(后面我们知道这个就是开始扫描后原生侧返回扫描结果的回调方法)，然后设置一个定时器，如果有设置超时时间的话就停止扫描并还原状态，最后调用通道方法startScan开始扫描，并遍历我们监听的扫描结果的stream，将数据添加到_scanResults中去。
stopScan比较简单，就不解释了：
/// Stops a scan for Bluetooth Low Energy devices Future stopScan() async { await _channel.invokeMethod('stopScan'); _scanResultsBuffer?.close(); _scanTimeout?.cancel(); _isScanning.add(false); }接着，我们看下原生侧是如何实现扫描的：
case "startScan": { byte[] data = call.arguments(); Protos.ScanSettings p = Protos.ScanSettings.newBuilder().mergeFrom(data).build(); macDeviceScanned.clear(); BluetoothLeScanner scanner = mBluetoothAdapter.getBluetoothLeScanner(); if(scanner == null) {throw new Exception("getBluetoothLeScanner() is null. Is the Adapter on?"); } int scanMode = p.getAndroidScanMode(); List<ScanFilter> filters = fetchFilters(p); // scan settings ScanSettings settings; if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {settings = new ScanSettings.Builder() .setPhy(ScanSettings.PHY_LE_ALL_SUPPORTED) .setLegacy(false) .setScanMode(scanMode) .build(); } else {settings = new ScanSettings.Builder() .setScanMode(scanMode).build(); } scanner.startScan(filters, settings, getScanCallback()); result.success(null); } catch(Exception e) { result.error("startScan", e.getMessage(), e); } break; }通过传入的参数对mac地址和uuid对扫描对象进行过滤，然后在getScanCallback里面返回：
private ScanCallback scanCallback; @TargetApi(21) private ScanCallback getScanCallback() { if(scanCallback == null) { scanCallback = new ScanCallback() { @Override public void onScanResult(int callbackType, ScanResult result) { super.onScanResult(callbackType, result); if(result != null){ if (!allowDuplicates && result.getDevice() != null && result.getDevice().getAddress() != null) {if (macDeviceScanned.contains(result.getDevice().getAddress())) { return;}macDeviceScanned.add(result.getDevice().getAddress()); } Protos.ScanResult scanResult = ProtoMaker.from(result.getDevice(), result); invokeMethodUIThread("ScanResult", scanResult.toByteArray()); } } @Override public void onBatchScanResults(List<ScanResult> results) { super.onBatchScanResults(results); } @Override public void onScanFailed(int errorCode) { super.onScanFailed(errorCode); } }; } return scanCallback; }每次扫描到结果都会调用onScanResult方法，然后通过macDeviceScanned记录已经扫描到的数据，去重。invokeMethodUIThread这个方法是通过handler做线程切换，保证在主线程返回结果。
2) 接着，我们看下FindDevicesScreen里面的扫描结果列表：
StreamBuilder<List<ScanResult>>( stream: FlutterBluePlus.instance.scanResults, initialData: const [], builder: (c, snapshot) => Column( children: snapshot.data! .map( (r) => ScanResultTile( result: r, onTap: () => Navigator.of(context) .push(MaterialPageRoute(builder: (context) {r.device.connect();return DeviceScreen(device: r.device); })), ), ) .toList(), ), ),ScanResultTile是显示的item组件，从左到右，依次是：rssi(信号强度)，BluetoothDevice(设备数据)的name与id，根据AdvertisementData(广告数据)connectable(是否可连接)判断能否点击的按钮。
点击后展开的内容，从上到下，依次是：Complete Local Name(完整的本地名称)，Tx Power Level(发射功率电平)，Manufacturer Data(制造商数据)，Service UUIDs，Service Data
点击Connect按钮逻辑：
onTap: () => Navigator.of(context).push(MaterialPageRoute( builder: (context) { r.device.connect(); return DeviceScreen(device: r.device); })),一起看下BluetoothDevice的connect方法
/// Establishes a connection to the Bluetooth Device. Future<void> connect({ Duration? timeout, bool autoConnect = true, bool shouldClearGattCache = true, }) async { if (Platform.isAndroid && shouldClearGattCache) { clearGattCache(); } var request = protos.ConnectRequest.create() ..remoteId = id.toString() ..androidAutoConnect = autoConnect; var responseStream = state.where((s) => s == BluetoothDeviceState.connected); // Start listening now, before invokeMethod, to ensure we don't miss the response Future<BluetoothDeviceState> futureState = responseStream.first; await FlutterBluePlus.instance._channel .invokeMethod('connect', request.writeToBuffer()); // wait for connection if (timeout != null) { await futureState.timeout(timeout, onTimeout: () { throw TimeoutException('Failed to connect in time.', timeout); }); } else { await futureState; } }首先看一下这个state，也是一个getter方法：
/// The current connection state of the device Stream<BluetoothDeviceState> get state async* { BluetoothDeviceState initialState = await FlutterBluePlus.instance._channel .invokeMethod('deviceState', id.toString()) .then((buffer) => protos.DeviceStateResponse.fromBuffer(buffer)) .then((p) => BluetoothDeviceState.values[p.state.value]); yield initialState; yield* FlutterBluePlus.instance._methodStream .where((m) => m.method == "DeviceState") .map((m) => m.arguments) .map((buffer) => protos.DeviceStateResponse.fromBuffer(buffer)) .where((p) => p.remoteId == id.toString()) .map((p) => BluetoothDeviceState.values[p.state.value]); }可以看到，依然是类似的逻辑，通过通道方法deviceState拿到设备连接初始状态，然后在回调方法里通过DeviceState方法将状态变化通知到flutter:
case "deviceState": { try { String deviceId = (String)call.arguments; BluetoothDevice device = mBluetoothAdapter.getRemoteDevice(deviceId); int state = mBluetoothManager.getConnectionState(device, BluetoothProfile.GATT); result.success(ProtoMaker.from(device, state).toByteArray()); } catch(Exception e) { result.error("deviceState", e.getMessage(), e); } break; } private final BluetoothGattCallback mGattCallback = new BluetoothGattCallback() { @Override public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) { if(newState == BluetoothProfile.STATE_DISCONNECTED) { if(!mDevices.containsKey(gatt.getDevice().getAddress())) { gatt.close(); } } invokeMethodUIThread("DeviceState", ProtoMaker.from(gatt.getDevice(), newState).toByteArray()); } .... }看下原生实现的connect：
case "connect": { byte[] data = call.arguments(); Protos.ConnectRequest options = Protos.ConnectRequest.newBuilder().mergeFrom(data).build(); String deviceId = options.getRemoteId(); BluetoothDevice device = mBluetoothAdapter.getRemoteDevice(deviceId); boolean isConnected = mBluetoothManager.getConnectedDevices(BluetoothProfile.GATT).contains(device); // If device is already connected, return error if(mDevices.containsKey(deviceId) && isConnected) {result.error("connect", "connection with device already exists", null);return; } // If device was connected to previously but // is now disconnected, attempt a reconnect BluetoothDeviceCache bluetoothDeviceCache = mDevices.get(deviceId); if(bluetoothDeviceCache != null && !isConnected) {if(bluetoothDeviceCache.gatt.connect() == false) { result.error("connect", "error when reconnecting to device", null);}result.success(null);return; } // New request, connect and add gattServer to Map BluetoothGatt gattServer; if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {gattServer = device.connectGatt(context, options.getAndroidAutoConnect(), mGattCallback, BluetoothDevice.TRANSPORT_LE); } else {gattServer = device.connectGatt(context, options.getAndroidAutoConnect(), mGattCallback); } mDevices.put(deviceId, new BluetoothDeviceCache(gattServer)); result.success(null); } catch(Exception e) { result.error("connect", e.getMessage(), e); } }); break; }检查是否已经正在连接其他设备，是则报错，否则继续。接着看是否之前连过这个设备，是则发起重连。否则发起一个新的连接请求。mDevices为连接过设备的Cache数据，根据deviceId记录，后面获取Gatt时提高效率。
接着我们看下点击按钮后跳转的DeviceScreen页面：
首先右上角会根据当前设备的连接状态显示连接/断开，连接看过了，看下断开：
/// Cancels connection to the Bluetooth Device Future<void> disconnect() async { await FlutterBluePlus.instance._channel .invokeMethod('disconnect', id.toString()); } case "disconnect": { try { String deviceId = (String)call.arguments; BluetoothDevice device = mBluetoothAdapter.getRemoteDevice(deviceId); BluetoothDeviceCache cache = mDevices.remove(deviceId); if(cache != null) { BluetoothGatt gattServer = cache.gatt; gattServer.disconnect(); int state = mBluetoothManager.getConnectionState(device, BluetoothProfile.GATT); if(state == BluetoothProfile.STATE_DISCONNECTED) {gattServer.close(); } } result.success(null); } catch(Exception e) { result.error("disconnect", e.getMessage(), e); } break; }第一行最后边有一个刷新按钮：
trailing: StreamBuilder<bool>( stream: device.isDiscoveringServices, initialData: false, builder: (c, snapshot) => IndexedStack( index: snapshot.data! ? 1 : 0, children: <Widget>[ IconButton( icon: const Icon(Icons.refresh), onPressed: () => device.discoverServices(), ), .... ], ), ),这个按钮是在当前连接设备上搜索所有的Service。
BluetoothDevice的discoverServices方法：
/// Discovers services offered by the remote device /// as well as their characteristics and descriptors Future<List<BluetoothService>> discoverServices() async { final s = await state.first; if (s != BluetoothDeviceState.connected) { return Future.error(Exception('Cannot discoverServices while' 'device is not connected. State == $s')); } // signal that we have started _isDiscoveringServices.add(true); var responseStream = FlutterBluePlus.instance._methodStream .where((m) => m.method == "DiscoverServicesResult") .map((m) => m.arguments) .map((buffer) => protos.DiscoverServicesResult.fromBuffer(buffer)) .where((p) => p.remoteId == id.toString()) .map((p) => p.services) .map((s) => s.map((p) => BluetoothService.fromProto(p)).toList()); // Start listening now, before invokeMethod, to ensure we don't miss the response Future<List<BluetoothService>> futureResponse = responseStream.first; await FlutterBluePlus.instance._channel .invokeMethod('discoverServices', id.toString()); // wait for response List<BluetoothService> services = await futureResponse; _isDiscoveringServices.add(false); _services.add(services); return services; }根据推断，DiscoverServicesResult是在回调方法里返回结果，discoverServices发起搜索服务：
@Override public void onServicesDiscovered(BluetoothGatt gatt, int status) { Protos.DiscoverServicesResult.Builder p = Protos.DiscoverServicesResult.newBuilder(); p.setRemoteId(gatt.getDevice().getAddress()); for(BluetoothGattService s : gatt.getServices()) { p.addServices(ProtoMaker.from(gatt.getDevice(), s, gatt)); } invokeMethodUIThread("DiscoverServicesResult", p.build().toByteArray()); } case "discoverServices": { try { String deviceId = (String)call.arguments; BluetoothGatt gatt = locateGatt(deviceId); if(gatt.discoverServices() == false) { result.error("discoverServices", "unknown reason", null); break; } result.success(null); } catch(Exception e) { result.error("discoverServices", e.getMessage(), e); } break; }搜索完成后会展示服务列表：
StreamBuilder<List<BluetoothService>>( stream: device.services, initialData: const [], builder: (c, snapshot) { return Column( children: _buildServiceTiles(snapshot.data!), ); }, ),BluetoothDevice的services方法：
/// Returns a list of Bluetooth GATT services offered by the remote device /// This function requires that discoverServices has been completed for this device Stream<List<BluetoothService>> get services async* { List<BluetoothService> initialServices = await FlutterBluePlus.instance._channel .invokeMethod('services', id.toString()) .then((buffer) => protos.DiscoverServicesResult.fromBuffer(buffer).services) .then((i) => i.map((s) => BluetoothService.fromProto(s)).toList()); yield initialServices; yield* _services.stream; }原生端实现
case "services": { try { String deviceId = (String)call.arguments; BluetoothGatt gatt = locateGatt(deviceId); Protos.DiscoverServicesResult.Builder p = Protos.DiscoverServicesResult.newBuilder(); p.setRemoteId(deviceId); for(BluetoothGattService s : gatt.getServices()){ p.addServices(ProtoMaker.from(gatt.getDevice(), s, gatt)); } result.success(p.build().toByteArray()); } catch(Exception e) { result.error("services", e.getMessage(), e); } break; }接着我们来看下Service的内容：
每个Service都有一个uuid，若干characteristics数据，每个characteristic也有一个uuid，此外characteristic还支持读，写，通知等操作：
先来看读：BluetoothCharacteristic.read
/// Retrieves the value of the characteristic Future<List<int>> read() async { List<int> responseValue = []; // Only allow a single read or write operation // at a time, to prevent race conditions. await _readWriteMutex.synchronized(() async { var request = protos.ReadCharacteristicRequest.create() ..remoteId = deviceId.toString() ..characteristicUuid = uuid.toString() ..serviceUuid = serviceUuid.toString(); FlutterBluePlus.instance._log(LogLevel.info, 'remoteId: ${deviceId.toString()}' 'characteristicUuid: ${uuid.toString()}' 'serviceUuid: ${serviceUuid.toString()}'); var responseStream = FlutterBluePlus.instance._methodStream .where((m) => m.method == "ReadCharacteristicResponse") .map((m) => m.arguments) .map((buffer) => protos.ReadCharacteristicResponse.fromBuffer(buffer)) .where((p) => (p.remoteId == request.remoteId) && (p.characteristic.uuid == request.characteristicUuid) && (p.characteristic.serviceUuid == request.serviceUuid)) .map((p) => p.characteristic.value); // Start listening now, before invokeMethod, to ensure we don't miss the response Future<List<int>> futureResponse = responseStream.first; await FlutterBluePlus.instance._channel .invokeMethod('readCharacteristic', request.writeToBuffer()); responseValue = await futureResponse; // push to stream _readValueController.add(responseValue); // cache latest value lastValue = responseValue; }).catchError((e, stacktrace) { throw Exception("$e $stacktrace"); }); return responseValue; } @Override public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) { Protos.ReadCharacteristicResponse.Builder p = Protos.ReadCharacteristicResponse.newBuilder(); p.setRemoteId(gatt.getDevice().getAddress()); p.setCharacteristic(ProtoMaker.from(gatt.getDevice(), characteristic, gatt)); invokeMethodUIThread("ReadCharacteristicResponse", p.build().toByteArray()); } case "readCharacteristic": { try { byte[] data = call.arguments(); Protos.ReadCharacteristicRequest request = Protos.ReadCharacteristicRequest.newBuilder().mergeFrom(data).build(); BluetoothGatt gattServer = locateGatt(request.getRemoteId()); BluetoothGattCharacteristic characteristic = locateCharacteristic(gattServer, request.getServiceUuid(), request.getSecondaryServiceUuid(), request.getCharacteristicUuid()); if(gattServer.readCharacteristic(characteristic) == false) { result.error("read_characteristic_error", "unknown reason, may occur if readCharacteristic was called before last read finished.", null); break; } result.success(null); } catch(Exception e) { result.error("read_characteristic_error", e.getMessage(), null); } break; }再来看写操作：BluetoothCharacteristic.write
/// Writes the value of a characteristic. /// [CharacteristicWriteType.withoutResponse]: the write is not /// guaranteed and will return immediately with success. /// [CharacteristicWriteType.withResponse]: the method will return after the /// write operation has either passed or failed. Future<void> write(List<int> value, {bool withoutResponse = false}) async { // Only allow a single read or write operation // at a time, to prevent race conditions. await _readWriteMutex.synchronized(() async { final type = withoutResponse ? CharacteristicWriteType.withoutResponse : CharacteristicWriteType.withResponse; var request = protos.WriteCharacteristicRequest.create() ..remoteId = deviceId.toString() ..characteristicUuid = uuid.toString() ..serviceUuid = serviceUuid.toString() ..writeType = protos.WriteCharacteristicRequest_WriteType.valueOf(type.index)! ..value = value; if (type == CharacteristicWriteType.withResponse) { var responseStream = FlutterBluePlus.instance._methodStream .where((m) => m.method == "WriteCharacteristicResponse") .map((m) => m.arguments) .map((buffer) => protos.WriteCharacteristicResponse.fromBuffer(buffer)) .where((p) => (p.request.remoteId == request.remoteId) && (p.request.characteristicUuid == request.characteristicUuid) && (p.request.serviceUuid == request.serviceUuid)); // Start listening now, before invokeMethod, to ensure we don't miss the response Future<protos.WriteCharacteristicResponse> futureResponse = responseStream.first; await FlutterBluePlus.instance._channel .invokeMethod('writeCharacteristic', request.writeToBuffer()); // wait for response, so that we can check for success protos.WriteCharacteristicResponse response = await futureResponse; if (!response.success) { throw Exception('Failed to write the characteristic'); } return Future.value(); } else { // invoke without waiting for reply return FlutterBluePlus.instance._channel .invokeMethod('writeCharacteristic', request.writeToBuffer()); } }).catchError((e, stacktrace) { throw Exception("$e $stacktrace"); }); } @Override public void onCharacteristicWrite(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) { Protos.WriteCharacteristicRequest.Builder request = Protos.WriteCharacteristicRequest.newBuilder(); request.setRemoteId(gatt.getDevice().getAddress()); request.setCharacteristicUuid(characteristic.getUuid().toString()); request.setServiceUuid(characteristic.getService().getUuid().toString()); Protos.WriteCharacteristicResponse.Builder p = Protos.WriteCharacteristicResponse.newBuilder(); p.setRequest(request); p.setSuccess(status == BluetoothGatt.GATT_SUCCESS); invokeMethodUIThread("WriteCharacteristicResponse", p.build().toByteArray()); } case "writeCharacteristic": { try { byte[] data = call.arguments(); Protos.WriteCharacteristicRequest request = Protos.WriteCharacteristicRequest.newBuilder().mergeFrom(data).build(); BluetoothGatt gattServer = locateGatt(request.getRemoteId()); BluetoothGattCharacteristic characteristic = locateCharacteristic(gattServer, request.getServiceUuid(), request.getSecondaryServiceUuid(), request.getCharacteristicUuid()); // Set Value if(!characteristic.setValue(request.getValue().toByteArray())){ result.error("writeCharacteristic", "could not set the local value of characteristic", null); } // Write type if(request.getWriteType() == Protos.WriteCharacteristicRequest.WriteType.WITHOUT_RESPONSE) { characteristic.setWriteType(BluetoothGattCharacteristic.WRITE_TYPE_NO_RESPONSE); } else { characteristic.setWriteType(BluetoothGattCharacteristic.WRITE_TYPE_DEFAULT); } // Write Char if(!gattServer.writeCharacteristic(characteristic)){ result.error("writeCharacteristic", "writeCharacteristic failed", null); break; } result.success(null); } catch(Exception e) { result.error("writeCharacteristic", e.getMessage(), null); } break; }通知操作：
/// Sets notifications or indications for the value of a specified characteristic Future<bool> setNotifyValue(bool notify) async { var request = protos.SetNotificationRequest.create() ..remoteId = deviceId.toString() ..serviceUuid = serviceUuid.toString() ..characteristicUuid = uuid.toString() ..enable = notify; Stream<protos.SetNotificationResponse> responseStream = FlutterBluePlus.instance._methodStream .where((m) => m.method == "SetNotificationResponse") .map((m) => m.arguments) .map((buffer) => protos.SetNotificationResponse.fromBuffer(buffer)) .where((p) => (p.remoteId == request.remoteId) && (p.characteristic.uuid == request.characteristicUuid) && (p.characteristic.serviceUuid == request.serviceUuid)); // Start listening now, before invokeMethod, to ensure we don't miss the response Future<protos.SetNotificationResponse> futureResponse = responseStream.first; await FlutterBluePlus.instance._channel .invokeMethod('setNotification', request.writeToBuffer()); // wait for response, so that we can check for success protos.SetNotificationResponse response = await futureResponse; if (!response.success) { throw Exception('setNotifyValue failed'); } BluetoothCharacteristic c = BluetoothCharacteristic.fromProto(response.characteristic); _updateDescriptors(c.descriptors); return c.isNotifying == notify; } @Override public void onDescriptorWrite(BluetoothGatt gatt, BluetoothGattDescriptor descriptor, int status) { .... if(descriptor.getUuid().compareTo(CCCD_ID) == 0) { // SetNotificationResponse Protos.SetNotificationResponse.Builder q = Protos.SetNotificationResponse.newBuilder(); q.setRemoteId(gatt.getDevice().getAddress()); q.setCharacteristic(ProtoMaker.from(gatt.getDevice(), descriptor.getCharacteristic(), gatt)); q.setSuccess(status == BluetoothGatt.GATT_SUCCESS); invokeMethodUIThread("SetNotificationResponse", q.build().toByteArray()); } } case "setNotification": { try { byte[] data = call.arguments(); Protos.SetNotificationRequest request = Protos.SetNotificationRequest.newBuilder().mergeFrom(data).build(); BluetoothGatt gattServer = locateGatt(request.getRemoteId()); BluetoothGattCharacteristic characteristic = locateCharacteristic(gattServer, request.getServiceUuid(), request.getSecondaryServiceUuid(), request.getCharacteristicUuid()); BluetoothGattDescriptor cccDescriptor = characteristic.getDescriptor(CCCD_ID); if(cccDescriptor == null) { //Some devices - including the widely used Bluno do not actually set the CCCD_ID. //thus setNotifications works perfectly (tested on Bluno) without cccDescriptor log(LogLevel.INFO, "could not locate CCCD descriptor for characteristic: " + characteristic.getUuid().toString()); } // start notifications if(!gattServer.setCharacteristicNotification(characteristic, request.getEnable())){ result.error("setNotification", "could not set characteristic notifications to :" + request.getEnable(), null); break; } // update descriptor value if(cccDescriptor != null) { byte[] value = null; // determine value if(request.getEnable()) {boolean canNotify = (characteristic.getProperties() & BluetoothGattCharacteristic.PROPERTY_NOTIFY) > 0;boolean canIndicate = (characteristic.getProperties() & BluetoothGattCharacteristic.PROPERTY_INDICATE) > 0;if(!canIndicate && !canNotify) { result.error("setNotification", "characteristic cannot notify or indicate", null); break;}if(canIndicate) {value = BluetoothGattDescriptor.ENABLE_INDICATION_VALUE;}if(canNotify) {value = BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE;} } else {value = BluetoothGattDescriptor.DISABLE_NOTIFICATION_VALUE; } if (!cccDescriptor.setValue(value)) {result.error("setNotification", "error setting descriptor value to: " + Arrays.toString(value), null);break; } if (!gattServer.writeDescriptor(cccDescriptor)) {result.error("setNotification", "error writing descriptor", null);break; } } result.success(null); } catch(Exception e) { result.error("setNotification", e.getMessage(), null); } break; }可以看到，设置通知有两部，第一步是调用方法设置通知，第二部是获取CCCD类型的descriptor，识别出是Notify(没有应答)或是Indicate(需要应答)类型后写入descriptor，然后在onDescriptorWrite接收应答。
每个characteristic下面还有若干descriptor，也可以进行读写操作，与characteristic类似，就不重复说明了。
除此以外，还有MtuSize(设置最大传输单元)，requestConnectionPriority(设置蓝牙设备请求连接的优先级)，setPreferredPhy(设置接收和发送的速率)，pair(配对)等等api，在此就不一一赘述了。
