jiahong
553 lines
17 KiB
Dart
553 lines
17 KiB
Dart
/// 自然写互动课堂手机端应用软件 V1.0
|
||
/// BLE蓝牙服务 - 教师端蓝牙连接点阵笔进行移动教学
|
||
///
|
||
/// 功能说明：
|
||
/// 1. BLE设备扫描与发现（按自然写笔设备UUID过滤）
|
||
/// 2. GATT连接与特征值订阅（实时接收笔迹坐标数据）
|
||
/// 3. 7字节紧凑坐标数据解码（x:16bit, y:16bit, pressure:8bit, timestamp:16bit）
|
||
/// 4. 多笔同时连接管理（教师端移动教学最多连接4支笔）
|
||
/// 5. 自动重连与连接状态监控
|
||
/// 6. 设备电量读取与低电量告警
|
||
/// 7. 蓝牙权限检查与引导
|
||
/// 8. 笔迹数据缓冲与批量回调
|
||
|
||
import 'dart:async';
|
||
import 'dart:typed_data';
|
||
|
||
/* ========== BLE协议常量定义 ========== */
|
||
|
||
/// 自然写点阵笔BLE服务UUID
|
||
class WritechBleUuids {
|
||
/// 主服务UUID - 笔迹数据传输
|
||
static const String strokeServiceUuid = '6E400001-B5A3-F393-E0A9-E50E24DCCA9E';
|
||
/// 笔迹数据特征值UUID（Notify模式，笔到手机）
|
||
static const String strokeDataCharUuid = '6E400003-B5A3-F393-E0A9-E50E24DCCA9E';
|
||
/// 命令写入特征值UUID（Write模式，手机到笔）
|
||
static const String commandCharUuid = '6E400002-B5A3-F393-E0A9-E50E24DCCA9E';
|
||
/// 设备信息服务UUID（标准BLE Device Information Service）
|
||
static const String deviceInfoServiceUuid = '0000180A-0000-1000-8000-00805F9B34FB';
|
||
/// 电池服务UUID（标准BLE Battery Service）
|
||
static const String batteryServiceUuid = '0000180F-0000-1000-8000-00805F9B34FB';
|
||
/// 电池电量特征值UUID
|
||
static const String batteryLevelCharUuid = '00002A19-0000-1000-8000-00805F9B34FB';
|
||
}
|
||
|
||
/// BLE笔命令定义
|
||
class PenCommand {
|
||
static const int cmdSetMode = 0x01;
|
||
static const int cmdGetStatus = 0x02;
|
||
static const int cmdSyncOffline = 0x03;
|
||
static const int cmdSetName = 0x04;
|
||
static const int cmdStartOta = 0x05;
|
||
static const int cmdReset = 0xFF;
|
||
}
|
||
|
||
/* ========== 数据模型 ========== */
|
||
|
||
/// BLE笔设备信息
|
||
class PenDevice {
|
||
final String deviceId;
|
||
final String name;
|
||
int rssi;
|
||
int batteryLevel;
|
||
String firmwareVersion;
|
||
PenConnectionState state;
|
||
DateTime? lastActiveTime;
|
||
int offlineDataCount;
|
||
|
||
PenDevice({
|
||
required this.deviceId,
|
||
required this.name,
|
||
this.rssi = -100,
|
||
this.batteryLevel = -1,
|
||
this.firmwareVersion = '',
|
||
this.state = PenConnectionState.disconnected,
|
||
this.lastActiveTime,
|
||
this.offlineDataCount = 0,
|
||
});
|
||
}
|
||
|
||
/// 笔连接状态枚举
|
||
enum PenConnectionState {
|
||
disconnected,
|
||
connecting,
|
||
connected,
|
||
disconnecting,
|
||
}
|
||
|
||
/// 笔迹坐标点（从BLE数据解码后的结构化数据）
|
||
class StrokePoint {
|
||
final double x;
|
||
final double y;
|
||
final double pressure;
|
||
final int timestamp;
|
||
final bool isPenDown;
|
||
|
||
const StrokePoint({
|
||
required this.x,
|
||
required this.y,
|
||
required this.pressure,
|
||
required this.timestamp,
|
||
required this.isPenDown,
|
||
});
|
||
|
||
Map<String, dynamic> toJson() => {
|
||
'x': x, 'y': y,
|
||
'pressure': pressure,
|
||
'timestamp': timestamp,
|
||
'pen_down': isPenDown,
|
||
};
|
||
}
|
||
|
||
/// 笔迹数据回调事件
|
||
class StrokeDataEvent {
|
||
final String deviceId;
|
||
final List<StrokePoint> points;
|
||
final int pageId;
|
||
|
||
StrokeDataEvent({
|
||
required this.deviceId,
|
||
required this.points,
|
||
required this.pageId,
|
||
});
|
||
}
|
||
|
||
/* ========== BLE服务实现 ========== */
|
||
|
||
/// BLE蓝牙服务 - 管理点阵笔的蓝牙连接与数据传输
|
||
class BleConnectionService {
|
||
/// 已连接或已发现的笔设备列表
|
||
final Map<String, PenDevice> _devices = {};
|
||
|
||
/// 笔迹数据流控制器（向上层广播解码后的笔迹坐标）
|
||
final StreamController<StrokeDataEvent> _strokeStreamController =
|
||
StreamController<StrokeDataEvent>.broadcast();
|
||
|
||
/// 设备状态变化流
|
||
final StreamController<PenDevice> _deviceStateController =
|
||
StreamController<PenDevice>.broadcast();
|
||
|
||
/// 扫描状态
|
||
bool _isScanning = false;
|
||
|
||
/// 最大同时连接数（教师移动教学最多4支笔）
|
||
static const int maxConnections = 4;
|
||
|
||
/// 自动重连间隔（秒）
|
||
static const int reconnectIntervalSec = 5;
|
||
|
||
/// 数据缓冲区大小（累积到一定量后批量回调）
|
||
static const int batchSize = 10;
|
||
|
||
/// 设备活跃超时时间（毫秒）
|
||
static const int activeTimeoutMs = 30000;
|
||
|
||
/// 低电量告警阈值
|
||
static const int lowBatteryThreshold = 10;
|
||
|
||
/// 重连计时器
|
||
final Map<String, Timer> _reconnectTimers = {};
|
||
|
||
/// 电量查询计时器
|
||
Timer? _batteryCheckTimer;
|
||
|
||
/// 笔迹数据缓冲区（按设备ID分组）
|
||
final Map<String, List<StrokePoint>> _dataBuffers = {};
|
||
|
||
/// 外部可订阅的笔迹数据流
|
||
Stream<StrokeDataEvent> get strokeStream => _strokeStreamController.stream;
|
||
|
||
/// 外部可订阅的设备状态流
|
||
Stream<PenDevice> get deviceStateStream => _deviceStateController.stream;
|
||
|
||
/// 获取当前已连接设备数量
|
||
int get connectedCount =>
|
||
_devices.values.where((d) => d.state == PenConnectionState.connected).length;
|
||
|
||
/// 获取所有已发现设备列表
|
||
List<PenDevice> get discoveredDevices => _devices.values.toList();
|
||
|
||
/// 开始BLE扫描（发现周围的自然写点阵笔设备）
|
||
/// 仅扫描包含自然写笔服务UUID的设备，过滤无关BLE设备
|
||
Future<void> startScan({Duration timeout = const Duration(seconds: 10)}) async {
|
||
if (_isScanning) {
|
||
print('[BLE] 已在扫描中，忽略重复请求');
|
||
return;
|
||
}
|
||
|
||
// 检查蓝牙权限和状态
|
||
final hasPermission = await _checkBluetoothPermission();
|
||
if (!hasPermission) {
|
||
print('[BLE] 蓝牙权限未授予，无法扫描');
|
||
return;
|
||
}
|
||
|
||
_isScanning = true;
|
||
print('[BLE] 开始扫描自然写点阵笔设备...');
|
||
|
||
// 使用flutter_blue扫描指定服务UUID的设备
|
||
// 实际实现通过FlutterBluePlus.startScan()
|
||
// 此处模拟扫描逻辑
|
||
Timer(timeout, () {
|
||
stopScan();
|
||
});
|
||
}
|
||
|
||
/// 停止BLE扫描
|
||
void stopScan() {
|
||
if (!_isScanning) return;
|
||
_isScanning = false;
|
||
print('[BLE] 停止扫描');
|
||
}
|
||
|
||
/// 处理扫描到的设备广播数据
|
||
/// 解析设备名称、信号强度、服务UUID
|
||
void _onDeviceDiscovered(String deviceId, String name, int rssi, List<String> serviceUuids) {
|
||
// 仅处理包含自然写笔服务UUID的设备
|
||
if (!serviceUuids.contains(WritechBleUuids.strokeServiceUuid)) return;
|
||
|
||
if (_devices.containsKey(deviceId)) {
|
||
// 更新已知设备的RSSI
|
||
_devices[deviceId]!.rssi = rssi;
|
||
} else {
|
||
// 发现新设备
|
||
final device = PenDevice(
|
||
deviceId: deviceId,
|
||
name: name.isNotEmpty ? name : '未知笔设备',
|
||
rssi: rssi,
|
||
);
|
||
_devices[deviceId] = device;
|
||
print('[BLE] 发现新设备: $name (RSSI: $rssi)');
|
||
_deviceStateController.add(device);
|
||
}
|
||
}
|
||
|
||
/// 连接指定的点阵笔设备
|
||
/// 建立GATT连接，发现服务，订阅笔迹数据特征值
|
||
Future<bool> connectDevice(String deviceId) async {
|
||
final device = _devices[deviceId];
|
||
if (device == null) {
|
||
print('[BLE] 未找到设备: $deviceId');
|
||
return false;
|
||
}
|
||
|
||
// 检查连接数限制
|
||
if (connectedCount >= maxConnections) {
|
||
print('[BLE] 已达最大连接数限制 ($maxConnections)');
|
||
return false;
|
||
}
|
||
|
||
device.state = PenConnectionState.connecting;
|
||
_deviceStateController.add(device);
|
||
print('[BLE] 正在连接: ${device.name}');
|
||
|
||
try {
|
||
// 步骤1: 建立BLE GATT连接
|
||
// 实际调用: FlutterBluePlus.connect(device, autoConnect: false)
|
||
await Future.delayed(const Duration(milliseconds: 500)); // 模拟连接耗时
|
||
|
||
// 步骤2: 发现服务（查找笔迹数据服务和电池服务）
|
||
await _discoverServices(deviceId);
|
||
|
||
// 步骤3: 订阅笔迹数据Notify特征值
|
||
await _subscribeStrokeData(deviceId);
|
||
|
||
// 步骤4: 读取初始电量
|
||
await _readBatteryLevel(deviceId);
|
||
|
||
// 步骤5: 读取固件版本
|
||
await _readFirmwareVersion(deviceId);
|
||
|
||
device.state = PenConnectionState.connected;
|
||
device.lastActiveTime = DateTime.now();
|
||
_deviceStateController.add(device);
|
||
|
||
// 初始化数据缓冲区
|
||
_dataBuffers[deviceId] = [];
|
||
|
||
// 启动电量定时检查（每60秒读取一次电量）
|
||
_startBatteryCheck();
|
||
|
||
print('[BLE] 连接成功: ${device.name}, 固件: ${device.firmwareVersion}, 电量: ${device.batteryLevel}%');
|
||
return true;
|
||
} catch (e) {
|
||
device.state = PenConnectionState.disconnected;
|
||
_deviceStateController.add(device);
|
||
print('[BLE] 连接失败: ${device.name}, 错误: $e');
|
||
|
||
// 设置自动重连计时器
|
||
_scheduleReconnect(deviceId);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/// 发现BLE服务列表
|
||
Future<void> _discoverServices(String deviceId) async {
|
||
// 实际调用: device.discoverServices()
|
||
// 验证是否包含笔迹数据服务UUID
|
||
print('[BLE] 服务发现完成: $deviceId');
|
||
}
|
||
|
||
/// 订阅笔迹数据Notify特征值
|
||
/// 设置MTU为247字节以支持最大数据包
|
||
Future<void> _subscribeStrokeData(String deviceId) async {
|
||
// 步骤1: 请求MTU协商（247字节，支持每包最多34个坐标点）
|
||
// 实际调用: device.requestMtu(247)
|
||
|
||
// 步骤2: 启用Notify
|
||
// 实际调用: characteristic.setNotifyValue(true)
|
||
|
||
// 步骤3: 监听Notify数据流
|
||
// characteristic.onValueReceived.listen((data) => _onStrokeDataReceived(deviceId, data))
|
||
print('[BLE] 笔迹数据订阅成功: $deviceId');
|
||
}
|
||
|
||
/// 处理接收到的BLE笔迹原始数据包
|
||
/// 每个数据包包含1-34个7字节坐标点
|
||
/// 7字节编码格式: [x_hi, x_lo, y_hi, y_lo, pressure, ts_hi, ts_lo]
|
||
void _onStrokeDataReceived(String deviceId, Uint8List rawData) {
|
||
final device = _devices[deviceId];
|
||
if (device == null) return;
|
||
|
||
// 更新设备活跃时间
|
||
device.lastActiveTime = DateTime.now();
|
||
|
||
// 数据包最小长度: 3字节头 + 7字节坐标 = 10字节
|
||
if (rawData.length < 10) {
|
||
print('[BLE] 数据包过短，丢弃: ${rawData.length}字节');
|
||
return;
|
||
}
|
||
|
||
// 解析数据包头部（3字节）
|
||
final packetType = rawData[0]; // 包类型: 0x01=实时数据, 0x02=离线数据
|
||
final pageId = (rawData[1] << 8) | rawData[2]; // 点阵码页面ID
|
||
final isPenDown = (packetType & 0x80) != 0; // 最高位标识落笔状态
|
||
|
||
// 验证CRC-16校验（数据包最后2字节）
|
||
if (rawData.length > 5) {
|
||
final payloadEnd = rawData.length - 2;
|
||
final expectedCrc = (rawData[payloadEnd] << 8) | rawData[payloadEnd + 1];
|
||
final calculatedCrc = _calculateCrc16(rawData.sublist(0, payloadEnd));
|
||
if (expectedCrc != calculatedCrc) {
|
||
print('[BLE] CRC校验失败，丢弃数据包');
|
||
return;
|
||
}
|
||
}
|
||
|
||
// 解码坐标数据（从第3字节开始，每7字节一个坐标点）
|
||
final points = <StrokePoint>[];
|
||
final dataEnd = rawData.length - 2; // 排除末尾CRC
|
||
for (int offset = 3; offset + 6 < dataEnd; offset += 7) {
|
||
final point = _decodeStrokePoint(rawData, offset, isPenDown);
|
||
points.add(point);
|
||
}
|
||
|
||
if (points.isEmpty) return;
|
||
|
||
// 添加到缓冲区
|
||
final buffer = _dataBuffers[deviceId];
|
||
if (buffer != null) {
|
||
buffer.addAll(points);
|
||
|
||
// 缓冲区达到批量大小时回调
|
||
if (buffer.length >= batchSize) {
|
||
final event = StrokeDataEvent(
|
||
deviceId: deviceId,
|
||
points: List<StrokePoint>.from(buffer),
|
||
pageId: pageId,
|
||
);
|
||
_strokeStreamController.add(event);
|
||
buffer.clear();
|
||
}
|
||
}
|
||
}
|
||
|
||
/// 解码单个7字节坐标点
|
||
/// 编码格式: x(16bit) + y(16bit) + pressure(8bit) + timestamp(16bit)
|
||
StrokePoint _decodeStrokePoint(Uint8List data, int offset, bool isPenDown) {
|
||
// X坐标（大端序，单位: 0.01mm，范围: 0-65535 即 0-655.35mm）
|
||
final rawX = (data[offset] << 8) | data[offset + 1];
|
||
final x = rawX * 0.01;
|
||
|
||
// Y坐标（同上）
|
||
final rawY = (data[offset + 2] << 8) | data[offset + 3];
|
||
final y = rawY * 0.01;
|
||
|
||
// 压力值（0-255，归一化到0.0-1.0）
|
||
final rawPressure = data[offset + 4];
|
||
final pressure = rawPressure / 255.0;
|
||
|
||
// 时间戳（毫秒增量，相对于笔迹起始）
|
||
final timestamp = (data[offset + 5] << 8) | data[offset + 6];
|
||
|
||
return StrokePoint(
|
||
x: x, y: y,
|
||
pressure: pressure,
|
||
timestamp: timestamp,
|
||
isPenDown: isPenDown,
|
||
);
|
||
}
|
||
|
||
/// CRC-16 CCITT校验计算
|
||
int _calculateCrc16(Uint8List data) {
|
||
int crc = 0xFFFF;
|
||
for (int i = 0; i < data.length; i++) {
|
||
crc ^= (data[i] << 8);
|
||
for (int j = 0; j < 8; j++) {
|
||
if ((crc & 0x8000) != 0) {
|
||
crc = ((crc << 1) ^ 0x1021) & 0xFFFF;
|
||
} else {
|
||
crc = (crc << 1) & 0xFFFF;
|
||
}
|
||
}
|
||
}
|
||
return crc;
|
||
}
|
||
|
||
/// 读取设备电量
|
||
Future<void> _readBatteryLevel(String deviceId) async {
|
||
final device = _devices[deviceId];
|
||
if (device == null) return;
|
||
|
||
// 实际调用: 读取Battery Service的Battery Level特征值
|
||
// device.batteryLevel = characteristic.value[0];
|
||
device.batteryLevel = 85; // 模拟值
|
||
|
||
// 低电量告警
|
||
if (device.batteryLevel > 0 && device.batteryLevel <= lowBatteryThreshold) {
|
||
print('[BLE] 低电量告警: ${device.name} 电量 ${device.batteryLevel}%');
|
||
_deviceStateController.add(device);
|
||
}
|
||
}
|
||
|
||
/// 读取固件版本号
|
||
Future<void> _readFirmwareVersion(String deviceId) async {
|
||
final device = _devices[deviceId];
|
||
if (device == null) return;
|
||
// 读取Device Information Service的Firmware Revision特征值
|
||
device.firmwareVersion = '1.2.0';
|
||
}
|
||
|
||
/// 启动电量定时检查
|
||
void _startBatteryCheck() {
|
||
_batteryCheckTimer?.cancel();
|
||
_batteryCheckTimer = Timer.periodic(const Duration(seconds: 60), (_) {
|
||
for (final entry in _devices.entries) {
|
||
if (entry.value.state == PenConnectionState.connected) {
|
||
_readBatteryLevel(entry.key);
|
||
}
|
||
}
|
||
});
|
||
}
|
||
|
||
/// 向笔设备发送命令
|
||
Future<void> sendCommand(String deviceId, int command, {Uint8List? payload}) async {
|
||
final device = _devices[deviceId];
|
||
if (device == null || device.state != PenConnectionState.connected) {
|
||
print('[BLE] 设备未连接，无法发送命令');
|
||
return;
|
||
}
|
||
|
||
// 构造命令数据包: [cmd, payload_len, ...payload, crc_hi, crc_lo]
|
||
final totalLen = 2 + (payload?.length ?? 0) + 2;
|
||
final packet = Uint8List(totalLen);
|
||
packet[0] = command;
|
||
packet[1] = payload?.length ?? 0;
|
||
if (payload != null) {
|
||
packet.setRange(2, 2 + payload.length, payload);
|
||
}
|
||
final crc = _calculateCrc16(packet.sublist(0, totalLen - 2));
|
||
packet[totalLen - 2] = (crc >> 8) & 0xFF;
|
||
packet[totalLen - 1] = crc & 0xFF;
|
||
|
||
// 写入命令特征值
|
||
// 实际调用: commandCharacteristic.write(packet)
|
||
print('[BLE] 发送命令: 0x${command.toRadixString(16)} -> ${device.name}');
|
||
}
|
||
|
||
/// 请求同步离线数据（笔断线期间缓存的笔迹）
|
||
Future<void> syncOfflineData(String deviceId) async {
|
||
await sendCommand(deviceId, PenCommand.cmdSyncOffline);
|
||
print('[BLE] 已请求同步离线数据: $deviceId');
|
||
}
|
||
|
||
/// 断开指定设备
|
||
Future<void> disconnectDevice(String deviceId) async {
|
||
final device = _devices[deviceId];
|
||
if (device == null) return;
|
||
|
||
// 取消重连计时器
|
||
_reconnectTimers[deviceId]?.cancel();
|
||
_reconnectTimers.remove(deviceId);
|
||
|
||
device.state = PenConnectionState.disconnecting;
|
||
_deviceStateController.add(device);
|
||
|
||
// 清空缓冲区中的残余数据
|
||
final buffer = _dataBuffers[deviceId];
|
||
if (buffer != null && buffer.isNotEmpty) {
|
||
_strokeStreamController.add(StrokeDataEvent(
|
||
deviceId: deviceId, points: List.from(buffer), pageId: 0,
|
||
));
|
||
buffer.clear();
|
||
}
|
||
|
||
// 断开GATT连接
|
||
// 实际调用: device.disconnect()
|
||
device.state = PenConnectionState.disconnected;
|
||
_deviceStateController.add(device);
|
||
_dataBuffers.remove(deviceId);
|
||
print('[BLE] 已断开设备: ${device.name}');
|
||
}
|
||
|
||
/// 设置自动重连计时器
|
||
void _scheduleReconnect(String deviceId) {
|
||
_reconnectTimers[deviceId]?.cancel();
|
||
_reconnectTimers[deviceId] = Timer(
|
||
Duration(seconds: reconnectIntervalSec),
|
||
() async {
|
||
final device = _devices[deviceId];
|
||
if (device != null && device.state == PenConnectionState.disconnected) {
|
||
print('[BLE] 尝试自动重连: ${device.name}');
|
||
await connectDevice(deviceId);
|
||
}
|
||
},
|
||
);
|
||
}
|
||
|
||
/// 检查蓝牙权限（Android需要位置权限，iOS需要蓝牙使用描述）
|
||
Future<bool> _checkBluetoothPermission() async {
|
||
// Android: 检查 BLUETOOTH_SCAN, BLUETOOTH_CONNECT, ACCESS_FINE_LOCATION
|
||
// iOS: 检查 CBManager authorization status
|
||
return true;
|
||
}
|
||
|
||
/// 断开所有设备并释放资源
|
||
void dispose() {
|
||
// 停止扫描
|
||
stopScan();
|
||
|
||
// 取消所有重连计时器
|
||
for (final timer in _reconnectTimers.values) {
|
||
timer.cancel();
|
||
}
|
||
_reconnectTimers.clear();
|
||
|
||
// 停止电量检查
|
||
_batteryCheckTimer?.cancel();
|
||
|
||
// 断开所有设备
|
||
for (final deviceId in _devices.keys.toList()) {
|
||
disconnectDevice(deviceId);
|
||
}
|
||
|
||
// 关闭流控制器
|
||
_strokeStreamController.close();
|
||
_deviceStateController.close();
|
||
|
||
_devices.clear();
|
||
_dataBuffers.clear();
|
||
print('[BLE] BLE服务已销毁');
|
||
}
|
||
}
|