Flutter蓝牙设备管理插件gk_ble_device_flutter的使用

本库允许用户通过低功耗蓝牙（BLE）连接到GK Concept设备，发现附近的设备，并订阅设备的报告流，以通知应用程序设备的活动。

目前，该库仅支持带有固件版本0.8.0及以上的Dropper设备。

该库使用Bloc库将业务逻辑与用户界面分离。

开始使用

在使用此库时，请务必遵循FlutterBluePlus指南，特别是有关应用程序所需权限的部分。

使用方法

所有核心功能都在BleDeviceCubit类中实现。

完整的示例代码及其用户界面可以在这里找到。

示例演示

这是Android上示例的外观：

Dropper报告消息格式

从Dropper设备的报告流订阅中获得的消息具有以下格式：

{
  "#": 27,
  "date": "20-02-14",
  "time": "16:05:04",
  "timestamp": 1644854704,
  "report": true,
  "cycles": 2445,
  "doses": 35,
  "event": 2
}

字段说明如下：

macOS权限设置

对于macOS，需要在Info.plist文件中添加以下内容：

<key>NSBluetoothAlwaysUsageDescription</key>
<string>该应用使用蓝牙来查找、连接和传输不同设备之间的数据</string>
<key>NSBluetoothPeripheralUsageDescription</key>
<string>该应用使用蓝牙来查找、连接和传输不同设备之间的数据</string>

此外，还需要在DebugProfile.entitlements和Release.entitlements中添加以下内容：

<key>com.apple.security.device.bluetooth</key>
<true/>

示例代码

以下是完整的示例代码：

import 'dart:async';

import 'package:flutter/material.dart';

import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:flutter_blue_plus/flutter_blue_plus.dart';
import 'package:logging/logging.dart';

import 'package:gk_ble_device_flutter/ble_device_ext.dart';
import 'package:gk_ble_device_flutter/ble_device_cubit.dart';

void main() {
  FlutterBluePlus.setLogLevel(LogLevel.info);
  Logger.root.level = Level.ALL;
  Logger.root.onRecord.listen((record) {
    // 忽略打印日志
    print('${record.loggerName}: ${record.level.name}: ${record.time}: ${record.message}');
  });
  runApp(BlocProvider(
      create: (_) => BleDeviceCubit(),
      child: const MaterialApp(home: DropperDemoApp())));
}

class DropperDemoApp extends StatefulWidget {
  const DropperDemoApp({super.key});

  [@override](/user/override)
  State<DropperDemoApp> createState() => _DropperDemoAppState();
}

// 定义状态消息映射
final Map<Type, Function(BleDeviceState state)> _stateMessages = {
  BleDeviceAuthorizing: (state) => '授权蓝牙...',
  BleDeviceConnecting: (state) =>
      '连接到${(state as BleDeviceConnecting).device.platformName}...',
  BleDeviceGettingServices: (state) =>
      '从${(state as BleDeviceGettingServices).device.platformName}检索服务...',
  BleDeviceGettingCharacteristics: (state) =>
      '从${(state as BleDeviceGettingCharacteristics).device.platformName}检索特征...',
  BleDeviceDisconnected: (state) =>
      '从${(state as BleDeviceDisconnected).device.platformName}断开连接',
  BleDeviceFailedToConnect: (state) =>
      '无法连接到${(state as BleDeviceFailedToConnect).device.platformName}',
};

// 定义状态符号映射
final Map<Type, Function(BleDeviceState state)> _stateSymbols = {
  BleDeviceAuthorizing: (state) => const CircularProgressIndicator(),
  BleDeviceConnecting: (state) => const CircularProgressIndicator(),
  BleDeviceGettingServices: (state) => const CircularProgressIndicator(),
  BleDeviceGettingCharacteristics: (state) => const CircularProgressIndicator(),
  BleDeviceDisconnected: (state) => const Icon(Icons.error),
  BleDeviceFailedToConnect: (state) => const Icon(Icons.error),
};

class _DropperDemoAppState extends State<DropperDemoApp> {
  List<BluetoothDevice> _devices = [];
  StreamSubscription? _reportSubscription;

  [@override](/user/override)
  void initState() {
    super.initState();
  }

  [@override](/user/override)
  void dispose() {
    _reportSubscription?.cancel();
    super.dispose();
  }

  [@override](/user/override)
  Widget build(BuildContext context) {
    return BlocConsumer<BleDeviceCubit, BleDeviceState>(
      listener: _listener,
      builder: (context, state) {
        return Scaffold(
          appBar: AppBar(
            title: const Text("Dropper Demo"),
          ),
          body: _buildScreen(context, state),
        );
      },
    );
  }

  // 状态监听器
  void _listener(BuildContext context, BleDeviceState state) {
    final cubit = context.read<BleDeviceCubit>();
    if (state is BleDeviceAuthorizing && state.status == BluetoothAdapterState.on) {
      cubit.startScanning();
    } else if (state is BleDeviceScanning) {
      setState(() {
        _devices = state.discoveredDevices;
      });
    } else if (state is BleDeviceDisconnected) {
      if (_reportSubscription != null) {
        _reportSubscription!.cancel();
      }
      Future.delayed(const Duration(seconds: 1), () {
        cubit.startScanning();
      });
    } else if (state is BleDeviceConnected &&
        state.characteristicStreams.containsKey(GKCharId.report)) {
      if (_reportSubscription != null) {
        _reportSubscription!.cancel();
      }
      _reportSubscription = state.characteristicStreams[GKCharId.report]!
          .listen((List<int> report) {
        if (context.mounted) {
          ScaffoldMessenger.of(context).hideCurrentSnackBar();
          ScaffoldMessenger.of(context).showSnackBar(SnackBar(
              content: Text('报告: ${String.fromCharCodes(report)}')));
        }
      });
    }
  }

  // 构建屏幕
  Widget _buildScreen(BuildContext context, BleDeviceState state) {
    if (state is BleDeviceScanning) {
      return _scanScreen(context, state);
    }
    if (state is BleDeviceConnected) {
      return _connectedScreen(context, state);
    }

    return Center(
      child: Column(
        children: [
          const SizedBox(height: 20),
          if (_stateSymbols.containsKey(state.runtimeType))
            _stateSymbols[state.runtimeType]!(state)
          else
            const SizedBox.shrink(),
          const SizedBox(height: 20),
          Text(_stateMessages.containsKey(state.runtimeType)
              ? _stateMessages[state.runtimeType]!(state)
              : ''),
        ],
      ),
    );
  }

  // 扫描屏幕
  Widget _scanScreen(BuildContext context, BleDeviceState state) {
    return Center(
        child: Column(children: [
      if (state is BleDeviceScanning && state.scanIsInProgress)
        const Column(children: [
          SizedBox(
            height: 20,
          ),
          CircularProgressIndicator(),
          SizedBox(
            height: 20,
          ),
          Text('正在扫描设备...'),
        ]),
      if (state is BleDeviceScanning && !state.scanIsInProgress)
        ElevatedButton(
            onPressed: () {
              context.read<BleDeviceCubit>().startScanning();
            },
            child: const Text('扫描设备')),
      if (_devices.isEmpty)
        const Text('未发现设备')
      else
        Expanded(
            child: ListView.builder(
                itemCount: _devices.length,
                itemBuilder: (context, index) {
                  return ListTile(
                      title: Row(children: [
                        BluetoothSignal(
                            strength: context
                                .read<BleDeviceCubit>()
                                .getRssi(_devices[index])),
                        const SizedBox(width: 10),
                        Text(_devices[index].platformName)
                      ]),
                      onTap: () {
                        context.read<BleDeviceCubit>().connect(_devices[index]);
                      });
                }))
    ]));
  }

  // 已连接屏幕
  Widget _connectedScreen(BuildContext context, BleDeviceConnected state) {
    return Center(
        child: Column(children: [
      const SizedBox(height: 20),
      const Icon(Icons.check),
      const SizedBox(height: 20),
      Text('已连接到${state.device.platformName}'),
      const SizedBox(height: 20),
      if (state.characteristics.containsKey(GKCharId.firmwareVersion)) ...[
        Text(
            '固件版本: ${state.characteristics[GKCharId.firmwareVersion]!.stringValue}'),
        const SizedBox(height: 20)
      ],
      if (!state.characteristicStreams.containsKey(GKCharId.report)) ...[
        const Text(
            '未找到报告特征。您是否使用的是固件版本0.8.0或更高的Dropper设备？'),
        const SizedBox(height: 20)
      ],
      ElevatedButton(
          onPressed: () async {
            final cubit = context.read<BleDeviceCubit>();
            await cubit.disconnect();
            await cubit.startScanning();
          },
          child: const Text("断开连接"))
    ]));
  }
}