feat: working connection, conn setting, and gear ratio setting for universal shifters
This commit is contained in:
@ -1,131 +1,358 @@
|
||||
import 'dart:async';
|
||||
import 'dart:io';
|
||||
|
||||
import 'package:anyhow/anyhow.dart';
|
||||
import 'package:flutter/foundation.dart';
|
||||
import 'package:flutter_blue_plus/flutter_blue_plus.dart';
|
||||
import 'package:flutter_riverpod/flutter_riverpod.dart';
|
||||
import 'package:flutter_reactive_ble/flutter_reactive_ble.dart'
|
||||
hide ConnectionStatus, Result, Logger;
|
||||
import 'package:logging/logging.dart';
|
||||
import 'package:rxdart/rxdart.dart';
|
||||
import 'package:riverpod_annotation/riverpod_annotation.dart';
|
||||
|
||||
part 'bluetooth.g.dart';
|
||||
|
||||
final log = Logger('BluetoothController');
|
||||
|
||||
@riverpod
|
||||
@Riverpod(keepAlive: true)
|
||||
FlutterReactiveBle reactiveBle(Ref ref) {
|
||||
ref.keepAlive();
|
||||
return FlutterReactiveBle();
|
||||
}
|
||||
|
||||
@Riverpod(keepAlive: true)
|
||||
Future<BluetoothController> bluetooth(Ref ref) async {
|
||||
final controller = BluetoothController();
|
||||
log.info(await controller.init());
|
||||
ref.keepAlive();
|
||||
final controller = BluetoothController(ref.read(reactiveBleProvider));
|
||||
await controller.init();
|
||||
return controller;
|
||||
}
|
||||
|
||||
@Riverpod(keepAlive: true)
|
||||
Stream<(ConnectionStatus, String?)> connectionStatus(Ref ref) {
|
||||
final asyncController = ref.watch(bluetoothProvider);
|
||||
return asyncController.when(
|
||||
data: (controller) => controller.connectionStateStream,
|
||||
loading: () => Stream.value((ConnectionStatus.disconnected, null)),
|
||||
error: (_, __) => Stream.value((ConnectionStatus.disconnected, null)),
|
||||
);
|
||||
}
|
||||
|
||||
/// Represents the connection status of the Bluetooth device.
|
||||
enum ConnectionStatus { disconnected, connecting, connected, disconnecting }
|
||||
|
||||
class BluetoothController {
|
||||
StreamSubscription<BluetoothAdapterState>? _btStateSubscription;
|
||||
StreamSubscription<List<ScanResult>>? _scanResultsSubscription;
|
||||
List<ScanResult> _latestScanResults = [];
|
||||
BluetoothController(this._ble);
|
||||
|
||||
static const int defaultMtu = 64;
|
||||
|
||||
final FlutterReactiveBle _ble;
|
||||
|
||||
StreamSubscription<BleStatus>? _bleStatusSubscription;
|
||||
StreamSubscription<DiscoveredDevice>? _scanResultsSubscription;
|
||||
Timer? _scanTimeout;
|
||||
final Map<String, DiscoveredDevice> _scanResultsById = {};
|
||||
final _scanResultsSubject =
|
||||
BehaviorSubject<List<DiscoveredDevice>>.seeded(const []);
|
||||
final _isScanningSubject = BehaviorSubject<bool>.seeded(false);
|
||||
|
||||
String? _connectedDeviceId;
|
||||
StreamSubscription<ConnectionStateUpdate>? _connectionStateSubscription;
|
||||
final _connectionStateSubject =
|
||||
BehaviorSubject<(ConnectionStatus, String?)>.seeded(
|
||||
(ConnectionStatus.disconnected, null));
|
||||
|
||||
Stream<(ConnectionStatus, String?)> get connectionStateStream =>
|
||||
_connectionStateSubject.stream;
|
||||
|
||||
(ConnectionStatus, String?) get currentConnectionState =>
|
||||
_connectionStateSubject.value;
|
||||
|
||||
Stream<List<DiscoveredDevice>> get scanResultsStream =>
|
||||
_scanResultsSubject.stream;
|
||||
|
||||
Stream<bool> get isScanningStream => _isScanningSubject.stream;
|
||||
|
||||
List<DiscoveredDevice> get scanResults => _scanResultsSubject.value;
|
||||
|
||||
Future<Result<void>> init() async {
|
||||
if (await FlutterBluePlus.isSupported == false) {
|
||||
log.severe("Bluetooth is not supported on this device!");
|
||||
return bail("Bluetooth is not supported on this device!");
|
||||
}
|
||||
|
||||
_btStateSubscription =
|
||||
FlutterBluePlus.adapterState.listen((BluetoothAdapterState state) {
|
||||
if (state == BluetoothAdapterState.on) {
|
||||
log.info("Bluetooth is on!");
|
||||
// usually start scanning, connecting, etc
|
||||
} else {
|
||||
log.info("Bluetooth is off!");
|
||||
// show an error to the user, etc
|
||||
}
|
||||
_bleStatusSubscription ??= _ble.statusStream.listen((status) {
|
||||
log.info('BLE status: $status');
|
||||
});
|
||||
|
||||
if (!kIsWeb && Platform.isAndroid) {
|
||||
await FlutterBluePlus.turnOn();
|
||||
}
|
||||
|
||||
return Ok(null);
|
||||
}
|
||||
|
||||
/// Start scanning for Bluetooth devices
|
||||
///
|
||||
/// [withServices] - Optional list of service UUIDs to filter devices by
|
||||
/// [withNames] - Optional list of device names to filter by
|
||||
/// [timeout] - Optional duration after which scanning will automatically stop
|
||||
Future<Result<void>> startScan({
|
||||
List<Guid>? withServices,
|
||||
List<String>? withNames,
|
||||
List<Uuid>? withServices,
|
||||
Duration? timeout,
|
||||
ScanMode scanMode = ScanMode.lowLatency,
|
||||
bool requireLocationServicesEnabled = true,
|
||||
}) async {
|
||||
if (_isScanningSubject.value) {
|
||||
return Ok(null);
|
||||
}
|
||||
|
||||
try {
|
||||
// Wait for Bluetooth to be enabled
|
||||
await FlutterBluePlus.adapterState
|
||||
.where((val) => val == BluetoothAdapterState.on)
|
||||
.first;
|
||||
final status = _ble.status;
|
||||
if (status != BleStatus.ready) {
|
||||
await _ble.statusStream
|
||||
.where((value) => value == BleStatus.ready)
|
||||
.first;
|
||||
}
|
||||
|
||||
// Set up scan results listener
|
||||
_scanResultsSubscription = FlutterBluePlus.onScanResults.listen(
|
||||
(results) {
|
||||
if (results.isNotEmpty) {
|
||||
_latestScanResults = results;
|
||||
ScanResult latestResult = results.last;
|
||||
log.info(
|
||||
'${latestResult.device.remoteId}: "${latestResult.advertisementData.advName}" found!');
|
||||
}
|
||||
},
|
||||
onError: (e) {
|
||||
log.severe('Scan error: $e');
|
||||
},
|
||||
);
|
||||
_scanTimeout?.cancel();
|
||||
_scanResultsById.clear();
|
||||
_scanResultsSubject.add(const []);
|
||||
_isScanningSubject.add(true);
|
||||
|
||||
// Clean up subscription when scanning completes
|
||||
FlutterBluePlus.cancelWhenScanComplete(_scanResultsSubscription!);
|
||||
_scanResultsSubscription = _ble
|
||||
.scanForDevices(
|
||||
withServices: withServices ?? const [],
|
||||
scanMode: scanMode,
|
||||
requireLocationServicesEnabled: requireLocationServicesEnabled,
|
||||
)
|
||||
.listen((device) {
|
||||
_scanResultsById[device.id] = device;
|
||||
_scanResultsSubject
|
||||
.add(_scanResultsById.values.toList(growable: false));
|
||||
}, onError: (Object error, StackTrace st) {
|
||||
log.severe('Scan error: $error', error, st);
|
||||
_isScanningSubject.add(false);
|
||||
});
|
||||
|
||||
// Start scanning with optional parameters
|
||||
await FlutterBluePlus.startScan(
|
||||
withServices: withServices ?? [],
|
||||
withNames: withNames ?? [],
|
||||
timeout: timeout,
|
||||
);
|
||||
if (timeout != null) {
|
||||
_scanTimeout = Timer(timeout, () {
|
||||
unawaited(stopScan());
|
||||
});
|
||||
}
|
||||
|
||||
return Ok(null);
|
||||
} catch (e) {
|
||||
_isScanningSubject.add(false);
|
||||
return bail('Failed to start Bluetooth scan: $e');
|
||||
}
|
||||
}
|
||||
|
||||
/// Stop an ongoing Bluetooth scan
|
||||
Future<Result<void>> stopScan() async {
|
||||
try {
|
||||
await FlutterBluePlus.stopScan();
|
||||
_scanTimeout?.cancel();
|
||||
_scanTimeout = null;
|
||||
await _scanResultsSubscription?.cancel();
|
||||
_scanResultsSubscription = null;
|
||||
_isScanningSubject.add(false);
|
||||
return Ok(null);
|
||||
} catch (e) {
|
||||
_isScanningSubject.add(false);
|
||||
return bail('Failed to stop Bluetooth scan: $e');
|
||||
}
|
||||
}
|
||||
|
||||
/// Get the latest scan results
|
||||
List<ScanResult> get scanResults => _latestScanResults;
|
||||
|
||||
/// Wait for the current scan to complete
|
||||
Future<Result<void>> waitForScanToComplete() async {
|
||||
try {
|
||||
await FlutterBluePlus.isScanning.where((val) => val == false).first;
|
||||
await isScanningStream.where((val) => val == false).first;
|
||||
return Ok(null);
|
||||
} catch (e) {
|
||||
return bail('Error waiting for scan to complete: $e');
|
||||
}
|
||||
}
|
||||
|
||||
/// Check if currently scanning
|
||||
Future<bool> get isScanning async {
|
||||
return await FlutterBluePlus.isScanning.first;
|
||||
Future<bool> get isScanning async => isScanningStream.first;
|
||||
|
||||
Future<Result<void>> connect(DiscoveredDevice device,
|
||||
{Duration? timeout}) async {
|
||||
return connectById(device.id, timeout: timeout ?? Duration(seconds: 10));
|
||||
}
|
||||
|
||||
Future<Result<void>> connectById(
|
||||
String deviceId, {
|
||||
Duration timeout = const Duration(seconds: 10),
|
||||
Map<Uuid, List<Uuid>>? servicesWithCharacteristicsToDiscover,
|
||||
}) async {
|
||||
final currentState = currentConnectionState;
|
||||
final currentDeviceId = currentState.$2;
|
||||
|
||||
if (deviceId == currentDeviceId &&
|
||||
(currentState.$1 == ConnectionStatus.connected ||
|
||||
currentState.$1 == ConnectionStatus.connecting)) {
|
||||
log.info('Already connected or connecting to $deviceId.');
|
||||
if (currentState.$1 == ConnectionStatus.connected) {
|
||||
unawaited(_requestMtuOnConnect(deviceId));
|
||||
}
|
||||
return Ok(null);
|
||||
}
|
||||
|
||||
if (currentDeviceId != null && deviceId != currentDeviceId) {
|
||||
final disconnectResult = await disconnect();
|
||||
if (disconnectResult.isErr()) {
|
||||
return disconnectResult
|
||||
.context('Failed to disconnect from previous device');
|
||||
}
|
||||
await Future.delayed(const Duration(milliseconds: 300));
|
||||
}
|
||||
|
||||
try {
|
||||
await _connectionStateSubscription?.cancel();
|
||||
_updateConnectionState(ConnectionStatus.connecting, deviceId);
|
||||
|
||||
_connectionStateSubscription = _ble
|
||||
.connectToDevice(
|
||||
id: deviceId,
|
||||
connectionTimeout: timeout,
|
||||
servicesWithCharacteristicsToDiscover:
|
||||
servicesWithCharacteristicsToDiscover,
|
||||
)
|
||||
.listen((update) {
|
||||
switch (update.connectionState) {
|
||||
case DeviceConnectionState.connected:
|
||||
_connectedDeviceId = deviceId;
|
||||
_updateConnectionState(ConnectionStatus.connected, deviceId);
|
||||
unawaited(_requestMtuOnConnect(deviceId));
|
||||
break;
|
||||
case DeviceConnectionState.connecting:
|
||||
_updateConnectionState(ConnectionStatus.connecting, deviceId);
|
||||
break;
|
||||
case DeviceConnectionState.disconnecting:
|
||||
_updateConnectionState(ConnectionStatus.disconnecting, deviceId);
|
||||
break;
|
||||
case DeviceConnectionState.disconnected:
|
||||
_cleanUpConnection();
|
||||
break;
|
||||
}
|
||||
}, onError: (Object error, StackTrace st) {
|
||||
log.severe('Failed to connect to $deviceId: $error', error, st);
|
||||
_cleanUpConnection();
|
||||
});
|
||||
|
||||
return Ok(null);
|
||||
} catch (e) {
|
||||
_cleanUpConnection();
|
||||
return bail('Failed to connect to $deviceId: $e');
|
||||
}
|
||||
}
|
||||
|
||||
Future<Result<void>> disconnect() async {
|
||||
final deviceIdToDisconnect =
|
||||
_connectedDeviceId ?? _connectionStateSubject.value.$2;
|
||||
if (deviceIdToDisconnect == null) {
|
||||
_cleanUpConnection();
|
||||
return Ok(null);
|
||||
}
|
||||
|
||||
_updateConnectionState(
|
||||
ConnectionStatus.disconnecting, deviceIdToDisconnect);
|
||||
try {
|
||||
await _connectionStateSubscription?.cancel();
|
||||
_connectionStateSubscription = null;
|
||||
_cleanUpConnection();
|
||||
return Ok(null);
|
||||
} catch (e) {
|
||||
_cleanUpConnection();
|
||||
return bail('Failed to disconnect from $deviceIdToDisconnect: $e');
|
||||
}
|
||||
}
|
||||
|
||||
Future<Result<List<int>>> readCharacteristic(
|
||||
String deviceId,
|
||||
String serviceUuid,
|
||||
String characteristicUuid,
|
||||
) async {
|
||||
try {
|
||||
final characteristic = QualifiedCharacteristic(
|
||||
serviceId: Uuid.parse(serviceUuid),
|
||||
characteristicId: Uuid.parse(characteristicUuid),
|
||||
deviceId: deviceId,
|
||||
);
|
||||
final value = await _ble.readCharacteristic(characteristic);
|
||||
return Ok(value);
|
||||
} catch (e) {
|
||||
return bail('Error reading characteristic: $e');
|
||||
}
|
||||
}
|
||||
|
||||
Future<Result<void>> writeCharacteristic(
|
||||
String deviceId,
|
||||
String serviceUuid,
|
||||
String characteristicUuid,
|
||||
List<int> value, {
|
||||
bool withResponse = true,
|
||||
}) async {
|
||||
try {
|
||||
final characteristic = QualifiedCharacteristic(
|
||||
serviceId: Uuid.parse(serviceUuid),
|
||||
characteristicId: Uuid.parse(characteristicUuid),
|
||||
deviceId: deviceId,
|
||||
);
|
||||
if (withResponse) {
|
||||
await _ble.writeCharacteristicWithResponse(
|
||||
characteristic,
|
||||
value: value,
|
||||
);
|
||||
} else {
|
||||
await _ble.writeCharacteristicWithoutResponse(
|
||||
characteristic,
|
||||
value: value,
|
||||
);
|
||||
}
|
||||
return Ok(null);
|
||||
} catch (e) {
|
||||
return bail('Error writing characteristic: $e');
|
||||
}
|
||||
}
|
||||
|
||||
Future<Result<void>> requestMtu(String deviceId,
|
||||
{int mtu = defaultMtu}) async {
|
||||
try {
|
||||
final negotiatedMtu = await _ble.requestMtu(deviceId: deviceId, mtu: mtu);
|
||||
log.info(
|
||||
'MTU negotiated for $deviceId: requested $mtu, got $negotiatedMtu');
|
||||
return Ok(null);
|
||||
} catch (e) {
|
||||
return bail('Error requesting MTU $mtu for $deviceId: $e');
|
||||
}
|
||||
}
|
||||
|
||||
Future<void> _requestMtuOnConnect(String deviceId) async {
|
||||
final mtuResult = await requestMtu(deviceId, mtu: defaultMtu);
|
||||
if (mtuResult.isErr()) {
|
||||
log.warning(
|
||||
'MTU request after connect failed for $deviceId: ${mtuResult.unwrapErr()}');
|
||||
}
|
||||
}
|
||||
|
||||
Stream<List<int>> subscribeToCharacteristic(
|
||||
String deviceId,
|
||||
String serviceUuid,
|
||||
String characteristicUuid,
|
||||
) {
|
||||
final characteristic = QualifiedCharacteristic(
|
||||
serviceId: Uuid.parse(serviceUuid),
|
||||
characteristicId: Uuid.parse(characteristicUuid),
|
||||
deviceId: deviceId,
|
||||
);
|
||||
return _ble.subscribeToCharacteristic(characteristic);
|
||||
}
|
||||
|
||||
void _updateConnectionState(ConnectionStatus status, String? deviceId) {
|
||||
if (_connectionStateSubject.value.$1 == status &&
|
||||
_connectionStateSubject.value.$2 == deviceId) {
|
||||
return;
|
||||
}
|
||||
_connectionStateSubject.add((status, deviceId));
|
||||
log.fine(
|
||||
'Connection state updated: $status, device: ${deviceId ?? 'none'}');
|
||||
}
|
||||
|
||||
void _cleanUpConnection() {
|
||||
_connectedDeviceId = null;
|
||||
_updateConnectionState(ConnectionStatus.disconnected, null);
|
||||
}
|
||||
|
||||
Future<Result<void>> dispose() async {
|
||||
_scanTimeout?.cancel();
|
||||
await _scanResultsSubscription?.cancel();
|
||||
await _btStateSubscription?.cancel();
|
||||
await _bleStatusSubscription?.cancel();
|
||||
await disconnect();
|
||||
await _scanResultsSubject.close();
|
||||
await _isScanningSubject.close();
|
||||
await _connectionStateSubject.close();
|
||||
return Ok(null);
|
||||
}
|
||||
}
|
||||
|
||||
@ -6,7 +6,24 @@ part of 'bluetooth.dart';
|
||||
// RiverpodGenerator
|
||||
// **************************************************************************
|
||||
|
||||
String _$bluetoothHash() => r'5e9c37c57e723b84dd08fd8763e7c445b3a4dbf3';
|
||||
String _$bluetoothHash() => r'f1fb75c72a7a473fc545baea6bedfdf4a21ab26b';
|
||||
|
||||
String _$reactiveBleHash() => r'9c4d4f37f7a0da1741b42d6a4c3f0f00c2c07f3c';
|
||||
|
||||
/// See also [reactiveBle].
|
||||
@ProviderFor(reactiveBle)
|
||||
final reactiveBleProvider = AutoDisposeProvider<FlutterReactiveBle>.internal(
|
||||
reactiveBle,
|
||||
name: r'reactiveBleProvider',
|
||||
debugGetCreateSourceHash:
|
||||
const bool.fromEnvironment('dart.vm.product') ? null : _$reactiveBleHash,
|
||||
dependencies: null,
|
||||
allTransitiveDependencies: null,
|
||||
);
|
||||
|
||||
@Deprecated('Will be removed in 3.0. Use Ref instead')
|
||||
// ignore: unused_element
|
||||
typedef ReactiveBleRef = AutoDisposeProviderRef<FlutterReactiveBle>;
|
||||
|
||||
/// See also [bluetooth].
|
||||
@ProviderFor(bluetooth)
|
||||
@ -23,5 +40,24 @@ final bluetoothProvider =
|
||||
@Deprecated('Will be removed in 3.0. Use Ref instead')
|
||||
// ignore: unused_element
|
||||
typedef BluetoothRef = AutoDisposeFutureProviderRef<BluetoothController>;
|
||||
String _$connectionStatusHash() => r'4dba587ef7703dabca4b2b9800e0798decfe2977';
|
||||
|
||||
/// See also [connectionStatus].
|
||||
@ProviderFor(connectionStatus)
|
||||
final connectionStatusProvider =
|
||||
AutoDisposeStreamProvider<(ConnectionStatus, String?)>.internal(
|
||||
connectionStatus,
|
||||
name: r'connectionStatusProvider',
|
||||
debugGetCreateSourceHash: const bool.fromEnvironment('dart.vm.product')
|
||||
? null
|
||||
: _$connectionStatusHash,
|
||||
dependencies: null,
|
||||
allTransitiveDependencies: null,
|
||||
);
|
||||
|
||||
@Deprecated('Will be removed in 3.0. Use Ref instead')
|
||||
// ignore: unused_element
|
||||
typedef ConnectionStatusRef
|
||||
= AutoDisposeStreamProviderRef<(ConnectionStatus, String?)>;
|
||||
// ignore_for_file: type=lint
|
||||
// ignore_for_file: subtype_of_sealed_class, invalid_use_of_internal_member, invalid_use_of_visible_for_testing_member, deprecated_member_use_from_same_package
|
||||
|
||||
627
lib/controller/bluetooth.old.dart
Normal file
627
lib/controller/bluetooth.old.dart
Normal file
@ -0,0 +1,627 @@
|
||||
import 'dart:async';
|
||||
import 'dart:io';
|
||||
|
||||
import 'package:anyhow/anyhow.dart';
|
||||
import 'package:flutter/foundation.dart';
|
||||
import 'package:flutter_blue_plus/flutter_blue_plus.dart';
|
||||
import 'package:flutter_riverpod/flutter_riverpod.dart';
|
||||
import 'package:logging/logging.dart';
|
||||
import 'package:rxdart/rxdart.dart';
|
||||
import 'package:riverpod_annotation/riverpod_annotation.dart';
|
||||
|
||||
part 'bluetooth.g.dart';
|
||||
|
||||
final log = Logger('BluetoothController');
|
||||
|
||||
@Riverpod(keepAlive: true)
|
||||
Future<BluetoothController> bluetooth(Ref ref) async {
|
||||
ref.keepAlive();
|
||||
final controller = BluetoothController();
|
||||
log.info(await controller.init());
|
||||
return controller;
|
||||
}
|
||||
|
||||
@Riverpod(keepAlive: true)
|
||||
Stream<(ConnectionStatus, BluetoothDevice?)> connectionStatus(Ref ref) {
|
||||
// Get the (potentially still loading) BluetoothController
|
||||
final asyncController = ref.watch(bluetoothProvider);
|
||||
|
||||
// If the controller is ready, return its stream. Otherwise, return an empty stream.
|
||||
// The provider will automatically update when the controller becomes ready.
|
||||
return asyncController.when(
|
||||
data: (controller) => controller.connectionStateStream,
|
||||
loading: () => Stream.value((ConnectionStatus.disconnected, null)),
|
||||
error: (_, __) => Stream.value((ConnectionStatus.disconnected, null)),
|
||||
);
|
||||
}
|
||||
|
||||
/// Represents the connection status of the Bluetooth device.
|
||||
enum ConnectionStatus { disconnected, connecting, connected, disconnecting }
|
||||
|
||||
class BluetoothController {
|
||||
StreamSubscription<BluetoothAdapterState>? _btStateSubscription;
|
||||
StreamSubscription<List<ScanResult>>? _scanResultsSubscription;
|
||||
List<ScanResult> _latestScanResults = [];
|
||||
StreamSubscription<void>? _servicesResetSubscription;
|
||||
final Map<String, Map<Guid, BluetoothService>> _servicesByDevice = {};
|
||||
final Map<String, Map<String, BluetoothCharacteristic>>
|
||||
_characteristicsByDevice = {};
|
||||
// Connection State
|
||||
BluetoothDevice? _connectedDevice;
|
||||
StreamSubscription<BluetoothConnectionState>? _connectionStateSubscription;
|
||||
final _connectionStateSubject =
|
||||
BehaviorSubject<(ConnectionStatus, BluetoothDevice?)>.seeded(
|
||||
(ConnectionStatus.disconnected, null));
|
||||
|
||||
/// Stream providing the current connection status and the connected device (if any).
|
||||
Stream<(ConnectionStatus, BluetoothDevice?)> get connectionStateStream =>
|
||||
_connectionStateSubject.stream;
|
||||
|
||||
/// Gets the latest connection status and device.
|
||||
(ConnectionStatus, BluetoothDevice?) get currentConnectionState =>
|
||||
_connectionStateSubject.value;
|
||||
|
||||
Future<Result<void>> init() async {
|
||||
log.severe("CALLED FBPON!");
|
||||
if (await FlutterBluePlus.isSupported == false) {
|
||||
log.severe("Bluetooth is not supported on this device!");
|
||||
return bail("Bluetooth is not supported on this device!");
|
||||
}
|
||||
|
||||
_btStateSubscription =
|
||||
FlutterBluePlus.adapterState.listen((BluetoothAdapterState state) {
|
||||
if (state == BluetoothAdapterState.on) {
|
||||
log.info("Bluetooth is on!");
|
||||
// usually start scanning, connecting, etc
|
||||
} else {
|
||||
log.info("Bluetooth is off!");
|
||||
// show an error to the user, etc
|
||||
}
|
||||
});
|
||||
|
||||
if (!kIsWeb && Platform.isAndroid) {
|
||||
await FlutterBluePlus.turnOn();
|
||||
}
|
||||
|
||||
connectionStateStream.listen((state) {
|
||||
log.info('Connection state changed: $state');
|
||||
});
|
||||
|
||||
return Ok(null);
|
||||
}
|
||||
|
||||
/// Start scanning for Bluetooth devices
|
||||
///
|
||||
/// [withServices] - Optional list of service UUIDs to filter devices by
|
||||
/// [withNames] - Optional list of device names to filter by
|
||||
/// [timeout] - Optional duration after which scanning will automatically stop
|
||||
Future<Result<void>> startScan({
|
||||
List<Guid>? withServices,
|
||||
List<String>? withNames,
|
||||
Duration? timeout,
|
||||
}) async {
|
||||
try {
|
||||
// Wait for Bluetooth to be enabled
|
||||
await FlutterBluePlus.adapterState
|
||||
.where((val) => val == BluetoothAdapterState.on)
|
||||
.first;
|
||||
|
||||
// Set up scan results listener
|
||||
_scanResultsSubscription = FlutterBluePlus.onScanResults.listen(
|
||||
(results) {
|
||||
if (results.isNotEmpty) {
|
||||
_latestScanResults = results;
|
||||
ScanResult latestResult = results.last;
|
||||
log.info(
|
||||
'${latestResult.device.remoteId}: "${latestResult.advertisementData.advName}" found!');
|
||||
}
|
||||
},
|
||||
onError: (e) {
|
||||
log.severe('Scan error: $e');
|
||||
},
|
||||
);
|
||||
|
||||
// Clean up subscription when scanning completes
|
||||
FlutterBluePlus.cancelWhenScanComplete(_scanResultsSubscription!);
|
||||
|
||||
// Start scanning with optional parameters
|
||||
await FlutterBluePlus.startScan(
|
||||
withServices: withServices ?? [],
|
||||
withNames: withNames ?? [],
|
||||
timeout: timeout,
|
||||
);
|
||||
|
||||
return Ok(null);
|
||||
} catch (e) {
|
||||
return bail('Failed to start Bluetooth scan: $e');
|
||||
}
|
||||
}
|
||||
|
||||
/// Stop an ongoing Bluetooth scan
|
||||
Future<Result<void>> stopScan() async {
|
||||
try {
|
||||
await FlutterBluePlus.stopScan();
|
||||
return Ok(null);
|
||||
} catch (e) {
|
||||
return bail('Failed to stop Bluetooth scan: $e');
|
||||
}
|
||||
}
|
||||
|
||||
/// Get the latest scan results
|
||||
List<ScanResult> get scanResults => _latestScanResults;
|
||||
|
||||
/// Wait for the current scan to complete
|
||||
Future<Result<void>> waitForScanToComplete() async {
|
||||
try {
|
||||
await FlutterBluePlus.isScanning.where((val) => val == false).first;
|
||||
return Ok(null);
|
||||
} catch (e) {
|
||||
return bail('Error waiting for scan to complete: $e');
|
||||
}
|
||||
}
|
||||
|
||||
/// Check if currently scanning
|
||||
Future<bool> get isScanning async {
|
||||
return await FlutterBluePlus.isScanning.first;
|
||||
}
|
||||
|
||||
/// Connects to a specific Bluetooth device.
|
||||
///
|
||||
/// Ensures that only one device is connected at a time. If another device
|
||||
/// is already connected or connecting, it will be disconnected first.
|
||||
Future<Result<void>> connect(BluetoothDevice device,
|
||||
{Duration? timeout}) async {
|
||||
final currentState = currentConnectionState;
|
||||
final currentDevice = currentState.$2;
|
||||
|
||||
// Prevent connecting if already connected/connecting to the *same* device
|
||||
if (device.remoteId == currentDevice?.remoteId &&
|
||||
(currentState.$1 == ConnectionStatus.connected ||
|
||||
currentState.$1 == ConnectionStatus.connecting)) {
|
||||
log.info('Currently connected device: ${currentState.$2}');
|
||||
log.info('Already connected or connecting to ${device.remoteId}.');
|
||||
return Ok(null); // Or potentially an error/different status?
|
||||
}
|
||||
|
||||
log.info('Attempting to connect to ${device.remoteId}...');
|
||||
|
||||
// If connecting or connected to a *different* device, disconnect it first.
|
||||
if (currentDevice != null && device.remoteId != currentDevice.remoteId) {
|
||||
log.info(
|
||||
'Disconnecting from previous device ${currentDevice.remoteId} first.');
|
||||
final disconnectResult = await disconnect();
|
||||
if (disconnectResult.isErr()) {
|
||||
return disconnectResult
|
||||
.context('Failed to disconnect from previous device');
|
||||
}
|
||||
// Wait a moment for the disconnection to fully process
|
||||
await Future.delayed(const Duration(milliseconds: 500));
|
||||
}
|
||||
|
||||
try {
|
||||
// Cancel any previous connection state listener before starting a new one
|
||||
await _connectionStateSubscription?.cancel();
|
||||
_connectionStateSubscription =
|
||||
device.connectionState.listen((BluetoothConnectionState state) async {
|
||||
log.info('[${device.remoteId}] Connection state changed: $state');
|
||||
switch (state) {
|
||||
case BluetoothConnectionState.connected:
|
||||
_connectedDevice = device;
|
||||
_updateConnectionState(ConnectionStatus.connected, device);
|
||||
// IMPORTANT: Discover services after connecting
|
||||
try {
|
||||
_attachServicesResetListener(device);
|
||||
final servicesResult =
|
||||
await _discoverAndCacheServices(device, force: true);
|
||||
if (servicesResult.isErr()) {
|
||||
throw servicesResult.unwrapErr();
|
||||
}
|
||||
log.info(
|
||||
'[${device.remoteId}] Services discovered: \n${servicesResult.unwrap().map((e) => e.uuid.toString()).join('\n')}');
|
||||
} catch (e) {
|
||||
log.severe(
|
||||
'[${device.remoteId}] Error discovering services: $e. Disconnecting.');
|
||||
// Disconnect if service discovery fails, as the connection might be unusable
|
||||
await disconnect();
|
||||
}
|
||||
break;
|
||||
case BluetoothConnectionState.disconnected:
|
||||
if (_connectionStateSubject.value.$1 !=
|
||||
ConnectionStatus.connected) {
|
||||
log.warning(
|
||||
'[${device.remoteId}] Disconnected WITHOUT being connected! Reason: ${device.disconnectReason?.code} ${device.disconnectReason?.description}\nDoing nothing');
|
||||
break;
|
||||
} else {
|
||||
log.warning(
|
||||
'[${device.remoteId}] Disconnected. Reason: ${device.disconnectReason?.code} ${device.disconnectReason?.description}');
|
||||
// Only clean up if this is the device we were connected/connecting to
|
||||
if (_connectionStateSubject.value.$2?.remoteId ==
|
||||
device.remoteId) {
|
||||
// Clean up connection state, handling disconnection.
|
||||
// In general, reconnection is better, but this is how it's handled here.
|
||||
// App behavior would be to go back to the homepage on disconnection
|
||||
_cleanUpConnection();
|
||||
} else {
|
||||
log.info(
|
||||
'[${device.remoteId}] Received disconnect for a device we were not tracking.');
|
||||
}
|
||||
break;
|
||||
}
|
||||
case BluetoothConnectionState.connecting:
|
||||
case BluetoothConnectionState.disconnecting:
|
||||
// deprecated states
|
||||
log.warning(
|
||||
'Received unexpected connection state: ${device.connectionState}. This should not happen.');
|
||||
break;
|
||||
}
|
||||
});
|
||||
|
||||
await device.connect(
|
||||
license: License.free,
|
||||
timeout: timeout ?? const Duration(seconds: 15),
|
||||
mtu: 512,
|
||||
);
|
||||
|
||||
// Note: Success is primarily handled by the connectionState listener
|
||||
log.info(
|
||||
'Connection initiated for ${device.remoteId}. Waiting for state change.');
|
||||
_connectionStateSubject.add((ConnectionStatus.connected, device));
|
||||
return Ok(null);
|
||||
} catch (e) {
|
||||
log.severe('Failed to connect to ${device.remoteId}: $e');
|
||||
_cleanUpConnection(); // Clean up state on connection failure
|
||||
return bail('Failed to connect to ${device.remoteId}: $e');
|
||||
}
|
||||
}
|
||||
|
||||
/// Connects to a device using its remote ID string with a specific timeout.
|
||||
Future<Result<void>> connectById(String remoteId,
|
||||
{Duration timeout = const Duration(seconds: 10)}) async {
|
||||
log.info('Attempting to connect by ID: $remoteId with timeout: $timeout');
|
||||
try {
|
||||
// Get the BluetoothDevice object from the ID
|
||||
final device = BluetoothDevice.fromId(remoteId);
|
||||
|
||||
// Call the existing connect method, passing the device and timeout
|
||||
// Assumes the 'connect' method below is modified to accept the timeout.
|
||||
return await connect(device, timeout: timeout); // Pass timeout here
|
||||
} catch (e, st) {
|
||||
// Catch potential errors from fromId or during connection setup before connect() is called
|
||||
log.severe('Error connecting by ID $remoteId: $e');
|
||||
_cleanUpConnection(); // Ensure state is cleaned up
|
||||
return bail('Failed to initiate connection for ID $remoteId: $e', st);
|
||||
}
|
||||
}
|
||||
|
||||
/// Disconnects from the currently connected device.
|
||||
Future<Result<void>> disconnect() async {
|
||||
final deviceToDisconnect =
|
||||
_connectedDevice ?? _connectionStateSubject.value.$2;
|
||||
if (deviceToDisconnect == null) {
|
||||
log.info('No device is currently connected or connecting.');
|
||||
// Ensure state is definitely disconnected if called unnecessarily
|
||||
_cleanUpConnection();
|
||||
return Ok(null);
|
||||
}
|
||||
|
||||
log.info('Disconnecting from ${deviceToDisconnect.remoteId}...');
|
||||
_updateConnectionState(ConnectionStatus.disconnecting, deviceToDisconnect);
|
||||
|
||||
try {
|
||||
await deviceToDisconnect.disconnect();
|
||||
log.info('Disconnect command sent to ${deviceToDisconnect.remoteId}.');
|
||||
// State update to disconnected is handled by the connectionState listener
|
||||
// but we call cleanup here as a safety measure in case the listener fails
|
||||
_cleanUpConnection();
|
||||
return Ok(null);
|
||||
} catch (e) {
|
||||
log.severe(
|
||||
'Failed to disconnect from ${deviceToDisconnect.remoteId}: $e');
|
||||
// Even on error, try to clean up the state
|
||||
_cleanUpConnection();
|
||||
return bail(
|
||||
'Failed to disconnect from ${deviceToDisconnect.remoteId}: $e');
|
||||
}
|
||||
}
|
||||
|
||||
void _updateConnectionState(
|
||||
ConnectionStatus status, BluetoothDevice? device) {
|
||||
// Avoid emitting redundant states
|
||||
if (_connectionStateSubject.value.$1 == status &&
|
||||
_connectionStateSubject.value.$2?.remoteId == device?.remoteId) {
|
||||
return;
|
||||
}
|
||||
_connectionStateSubject.add((status, device));
|
||||
log.fine(
|
||||
'Connection state updated: $status, Device: ${device?.remoteId ?? 'none'}');
|
||||
}
|
||||
|
||||
Future<Result<List<BluetoothService>>> discoverServices(
|
||||
BluetoothDevice device, {
|
||||
bool force = false,
|
||||
}) async {
|
||||
return _discoverAndCacheServices(device, force: force);
|
||||
}
|
||||
|
||||
Future<Result<void>> writeCharacteristic(
|
||||
BluetoothDevice device,
|
||||
String serviceUuid,
|
||||
String characteristicUuid,
|
||||
List<int> value, {
|
||||
bool withoutResponse = false,
|
||||
bool allowLongWrite = false,
|
||||
int timeout = 15,
|
||||
}) async {
|
||||
final serviceGuid = Guid(serviceUuid);
|
||||
final characteristicGuid = Guid(characteristicUuid);
|
||||
final chrResult =
|
||||
await _getCharacteristic(device, serviceGuid, characteristicGuid);
|
||||
if (chrResult.isErr()) {
|
||||
return chrResult.context('Failed to resolve characteristic for write');
|
||||
}
|
||||
|
||||
try {
|
||||
await chrResult.unwrap().write(
|
||||
value,
|
||||
withoutResponse: withoutResponse,
|
||||
allowLongWrite: allowLongWrite,
|
||||
timeout: timeout,
|
||||
);
|
||||
return Ok(null);
|
||||
} catch (e) {
|
||||
return bail('Error writing characteristic $characteristicUuid: $e');
|
||||
}
|
||||
}
|
||||
|
||||
Future<Result<StreamSubscription<List<int>>>> subscribeToNotifications(
|
||||
BluetoothDevice device,
|
||||
String serviceUuid,
|
||||
String characteristicUuid, {
|
||||
void Function(List<int>)? onValue,
|
||||
bool useLastValueStream = false,
|
||||
int timeout = 15,
|
||||
}) async {
|
||||
return _subscribeToCharacteristic(
|
||||
device,
|
||||
serviceUuid,
|
||||
characteristicUuid,
|
||||
useLastValueStream: useLastValueStream,
|
||||
timeout: timeout,
|
||||
forceIndications: false,
|
||||
onValue: onValue,
|
||||
);
|
||||
}
|
||||
|
||||
Future<Result<StreamSubscription<List<int>>>> subscribeToIndications(
|
||||
BluetoothDevice device,
|
||||
String serviceUuid,
|
||||
String characteristicUuid, {
|
||||
void Function(List<int>)? onValue,
|
||||
bool useLastValueStream = false,
|
||||
int timeout = 15,
|
||||
}) async {
|
||||
return _subscribeToCharacteristic(
|
||||
device,
|
||||
serviceUuid,
|
||||
characteristicUuid,
|
||||
useLastValueStream: useLastValueStream,
|
||||
timeout: timeout,
|
||||
forceIndications: true,
|
||||
onValue: onValue,
|
||||
);
|
||||
}
|
||||
|
||||
Future<Result<void>> unsubscribeFromCharacteristic(
|
||||
BluetoothDevice device,
|
||||
String serviceUuid,
|
||||
String characteristicUuid, {
|
||||
int timeout = 15,
|
||||
}) async {
|
||||
final serviceGuid = Guid(serviceUuid);
|
||||
final characteristicGuid = Guid(characteristicUuid);
|
||||
final chrResult =
|
||||
await _getCharacteristic(device, serviceGuid, characteristicGuid);
|
||||
if (chrResult.isErr()) {
|
||||
return chrResult
|
||||
.context('Failed to resolve characteristic to unsubscribe');
|
||||
}
|
||||
|
||||
try {
|
||||
await chrResult.unwrap().setNotifyValue(false, timeout: timeout);
|
||||
return Ok(null);
|
||||
} catch (e) {
|
||||
return bail('Error disabling notifications for $characteristicUuid: $e');
|
||||
}
|
||||
}
|
||||
|
||||
/// Helper function to clean up connection resources and state.
|
||||
Future<void> _cleanUpConnection() async {
|
||||
log.fine('Cleaning up connection state and subscriptions.');
|
||||
_connectedDevice = null;
|
||||
await _servicesResetSubscription?.cancel();
|
||||
_servicesResetSubscription = null;
|
||||
_servicesByDevice.clear();
|
||||
_characteristicsByDevice.clear();
|
||||
await _connectionStateSubscription?.cancel();
|
||||
_connectionStateSubscription = null;
|
||||
_updateConnectionState(ConnectionStatus.disconnected, null);
|
||||
}
|
||||
|
||||
Future<Result<void>> dispose() async {
|
||||
await _scanResultsSubscription?.cancel();
|
||||
await _btStateSubscription?.cancel();
|
||||
await disconnect(); // Ensure disconnection on dispose
|
||||
await _connectionStateSubject.close();
|
||||
return Ok(null);
|
||||
}
|
||||
|
||||
Future<Result<List<int>>> readCharacteristic(
|
||||
BluetoothDevice device, String svcUuid, String characteristic) async {
|
||||
// Implement reading characteristic logic here
|
||||
// This is a placeholder implementation
|
||||
log.info(
|
||||
'Reading characteristic from device: $device, characteristic: $characteristic');
|
||||
final serviceUUID = Guid(svcUuid);
|
||||
final characteristicUUID = Guid(characteristic);
|
||||
|
||||
if (!device.servicesList.map((e) => e.uuid).contains(serviceUUID)) {
|
||||
return bail('Service $svcUuid not found on device ${device.remoteId}');
|
||||
}
|
||||
|
||||
final BluetoothService service =
|
||||
(device.servicesList).firstWhere((s) => s.uuid == serviceUUID);
|
||||
|
||||
if (service.characteristics.isEmpty ||
|
||||
!service.characteristics
|
||||
.map((c) => c.uuid)
|
||||
.contains(characteristicUUID)) {
|
||||
return bail(
|
||||
'Characteristic $characteristic not found on device ${device.remoteId}');
|
||||
}
|
||||
|
||||
try {
|
||||
final val = await service.characteristics
|
||||
.firstWhere((c) => c.uuid == characteristicUUID)
|
||||
.read();
|
||||
return Ok(val);
|
||||
} catch (e) {
|
||||
return bail('Error reading characteristic: $e');
|
||||
}
|
||||
}
|
||||
|
||||
String _deviceKey(BluetoothDevice device) => device.remoteId.str;
|
||||
|
||||
String _characteristicKey(Guid serviceUuid, Guid characteristicUuid) =>
|
||||
'${serviceUuid.toString()}|${characteristicUuid.toString()}';
|
||||
|
||||
void _cacheServices(BluetoothDevice device, List<BluetoothService> services) {
|
||||
final serviceMap = <Guid, BluetoothService>{};
|
||||
final characteristicMap = <String, BluetoothCharacteristic>{};
|
||||
|
||||
for (final service in services) {
|
||||
serviceMap[service.uuid] = service;
|
||||
for (final chr in service.characteristics) {
|
||||
characteristicMap[_characteristicKey(service.uuid, chr.uuid)] = chr;
|
||||
}
|
||||
}
|
||||
|
||||
_servicesByDevice[_deviceKey(device)] = serviceMap;
|
||||
_characteristicsByDevice[_deviceKey(device)] = characteristicMap;
|
||||
}
|
||||
|
||||
void _attachServicesResetListener(BluetoothDevice device) {
|
||||
_servicesResetSubscription?.cancel();
|
||||
_servicesResetSubscription = device.onServicesReset.listen((_) async {
|
||||
log.info('[${device.remoteId}] Services reset. Re-discovering.');
|
||||
final res = await _discoverAndCacheServices(device, force: true);
|
||||
if (res.isErr()) {
|
||||
log.severe(
|
||||
'[${device.remoteId}] Failed to re-discover services: ${res.unwrapErr()}');
|
||||
}
|
||||
});
|
||||
device.cancelWhenDisconnected(_servicesResetSubscription!);
|
||||
}
|
||||
|
||||
Future<Result<List<BluetoothService>>> _discoverAndCacheServices(
|
||||
BluetoothDevice device, {
|
||||
bool force = false,
|
||||
}) async {
|
||||
try {
|
||||
if (!force) {
|
||||
final cached = _servicesByDevice[_deviceKey(device)];
|
||||
if (cached != null && cached.isNotEmpty) {
|
||||
return Ok(cached.values.toList());
|
||||
}
|
||||
}
|
||||
if (!force && device.servicesList.isNotEmpty) {
|
||||
_cacheServices(device, device.servicesList);
|
||||
return Ok(device.servicesList);
|
||||
}
|
||||
|
||||
final services = await device.discoverServices();
|
||||
_cacheServices(device, services);
|
||||
return Ok(services);
|
||||
} catch (e) {
|
||||
return bail('Failed to discover services for ${device.remoteId}: $e');
|
||||
}
|
||||
}
|
||||
|
||||
Future<Result<BluetoothCharacteristic>> _getCharacteristic(
|
||||
BluetoothDevice device,
|
||||
Guid serviceUuid,
|
||||
Guid characteristicUuid,
|
||||
) async {
|
||||
final deviceKey = _deviceKey(device);
|
||||
final cached = _characteristicsByDevice[deviceKey]
|
||||
?[_characteristicKey(serviceUuid, characteristicUuid)];
|
||||
if (cached != null) {
|
||||
return Ok(cached);
|
||||
}
|
||||
|
||||
final discoverResult = await _discoverAndCacheServices(device);
|
||||
if (discoverResult.isErr()) {
|
||||
return bail(discoverResult.unwrapErr().toString());
|
||||
}
|
||||
|
||||
final refreshed = _characteristicsByDevice[deviceKey]
|
||||
?[_characteristicKey(serviceUuid, characteristicUuid)];
|
||||
if (refreshed == null) {
|
||||
return bail(
|
||||
'Characteristic $characteristicUuid not found on service $serviceUuid for device ${device.remoteId}');
|
||||
}
|
||||
|
||||
return Ok(refreshed);
|
||||
}
|
||||
|
||||
Future<Result<StreamSubscription<List<int>>>> _subscribeToCharacteristic(
|
||||
BluetoothDevice device,
|
||||
String serviceUuid,
|
||||
String characteristicUuid, {
|
||||
required bool forceIndications,
|
||||
required bool useLastValueStream,
|
||||
required int timeout,
|
||||
void Function(List<int>)? onValue,
|
||||
}) async {
|
||||
final serviceGuid = Guid(serviceUuid);
|
||||
final characteristicGuid = Guid(characteristicUuid);
|
||||
final chrResult =
|
||||
await _getCharacteristic(device, serviceGuid, characteristicGuid);
|
||||
if (chrResult.isErr()) {
|
||||
return bail('Failed to resolve characteristic subscription: '
|
||||
'${chrResult.unwrapErr()}');
|
||||
}
|
||||
|
||||
final characteristic = chrResult.unwrap();
|
||||
final properties = characteristic.properties;
|
||||
if (forceIndications && !properties.indicate) {
|
||||
return bail(
|
||||
'Characteristic $characteristicUuid does not support indications');
|
||||
}
|
||||
if (!forceIndications && !properties.notify && !properties.indicate) {
|
||||
return bail(
|
||||
'Characteristic $characteristicUuid does not support notifications');
|
||||
}
|
||||
if (forceIndications && !kIsWeb && !Platform.isAndroid) {
|
||||
return bail('Indications can only be forced on Android.');
|
||||
}
|
||||
|
||||
try {
|
||||
final stream = useLastValueStream
|
||||
? characteristic.lastValueStream
|
||||
: characteristic.onValueReceived;
|
||||
final subscription = stream.listen(onValue ?? (_) {});
|
||||
device.cancelWhenDisconnected(subscription);
|
||||
|
||||
await characteristic.setNotifyValue(
|
||||
true,
|
||||
timeout: timeout,
|
||||
forceIndications: forceIndications,
|
||||
);
|
||||
|
||||
return Ok(subscription);
|
||||
} catch (e) {
|
||||
return bail(
|
||||
'Error subscribing to characteristic $characteristicUuid: $e');
|
||||
}
|
||||
}
|
||||
}
|
||||
1
lib/controller/connected_device.dart
Normal file
1
lib/controller/connected_device.dart
Normal file
@ -0,0 +1 @@
|
||||
|
||||
Reference in New Issue
Block a user