Commit d296182

@@ -0,0 +1,6 @@
+{
+    "recommendations": [
+        "dart-code.flutter",
+        "dart-code.dart-code"
+    ]
+}
\ No newline at end of file

@@ -0,0 +1,18 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "blood-pressure-monitor",
+            "type": "dart",
+            "request": "launch",
+            "cwd": "${workspaceFolder}/app",
+            "program": "lib/main.dart",
+            "args": [
+                "--flavor", "github"
+            ]
+        }
+    ]
+}
\ No newline at end of file

@@ -3,4 +3,4 @@ distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
 distributionUrl=https\://services.gradle.org/distributions/gradle-8.10.2-all.zip
-distributionSha256Sum=2ab88d6de2c23e6adae7363ae6e29cbdd2a709e992929b48b6530fd0c7133bd6
+distributionSha256Sum=2ab88d6de2c23e6adae7363ae6e29cbdd2a709e992929b48b6530fd0c7133bd6
\ No newline at end of file

@@ -55,7 +55,7 @@ extension EntryUtils on BuildContext {
         }
       }
     } on ProviderNotFoundException {
-      Log.err('createEntry($initial) was called from a context without Provider.');
+      log.severe('[extension.EntryUtils] createEntry($initial) was called from a context without Provider.');
     } catch (e, stack) {
       await ErrorReporting.reportCriticalError('Error opening add measurement dialoge', '$e\n$stack',);
     }
@@ -93,7 +93,7 @@ extension EntryUtils on BuildContext {
         ),);
       }
     } on ProviderNotFoundException {
-      Log.err('deleteEntry($entry) was called from a context without Provider.');
+      log.severe('[extension.EntryUtils] deleteEntry($entry) was called from a context without Provider.');
     }
   }
 }

@@ -0,0 +1,124 @@
+import 'dart:async';
+import 'dart:typed_data';
+
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_connection.dart';
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_device.dart';
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_low_energy/ble_manager.dart';
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_low_energy/ble_service.dart';
+import 'package:bluetooth_low_energy/bluetooth_low_energy.dart' show CentralManager, ConnectionState, DiscoveredEventArgs, PeripheralConnectionStateChangedEventArgs;
+
+/// BluetoothDevice implementation for the 'bluetooth_low_energy' package
+final class BluetoothLowEnergyDevice
+  extends BluetoothDevice<
+    BluetoothLowEnergyManager,
+    BluetoothLowEnergyService,
+    BluetoothLowEnergyCharacteristic,
+    DiscoveredEventArgs
+  > with CharacteristicValueListener<
+    BluetoothLowEnergyManager,
+    BluetoothLowEnergyService,
+    BluetoothLowEnergyCharacteristic,
+    DiscoveredEventArgs
+  >
+{
+  /// Init BluetoothDevice implementation for the 'bluetooth_low_energy' package
+  BluetoothLowEnergyDevice(super.manager, super.source);
+
+  @override
+  String get deviceId => source.peripheral.uuid.toString();
+
+  @override
+  String get name => source.advertisement.name ?? deviceId;
+
+  CentralManager get _cm => manager.backend;
+
+  @override
+  Stream<BluetoothConnectionState> get connectionStream => _cm.connectionStateChanged
+    .map((PeripheralConnectionStateChangedEventArgs rawState) => switch (rawState.state) {
+      ConnectionState.connected => BluetoothConnectionState.connected,
+      ConnectionState.disconnected => BluetoothConnectionState.disconnected,
+    });
+
+  @override
+  Future<void> backendConnect() => _cm.connect(source.peripheral);
+
+  @override
+  Future<void> backendDisconnect() => _cm.disconnect(source.peripheral);
+
+  @override
+  Future<void> dispose() => disposeCharacteristics();
+
+  @override
+  Future<List<BluetoothLowEnergyService>?> discoverServices() async {
+    if (!isConnected) {
+      logger.finer('discoverServices: device not connect. Call device.connect() first');
+      return null;
+    }
+
+    // Query actual services supported by the device. While they must be
+    // rediscovered when a disconnect happens, this object is also recreated.
+    try {
+      final rawServices = await _cm.discoverGATT(source.peripheral);
+      logger.finer('discoverServices: $rawServices');
+      return rawServices.map(BluetoothLowEnergyService.fromSource).toList();
+    } catch (e) {
+      logger.shout('discoverServices: error:', [source.peripheral, e]);
+      return null;
+    }
+  }
+  
+  @override
+  Future<bool> triggerCharacteristicValue(BluetoothLowEnergyCharacteristic characteristic, [bool state = true]) async {
+    await _cm.setCharacteristicNotifyState(source.peripheral, characteristic.source, state: state);
+    return true;
+  }
+
+  @override
+  Future<bool> getCharacteristicValue(
+    BluetoothLowEnergyCharacteristic characteristic,
+    void Function(Uint8List value, [void Function(bool success)? complete]) onValue,
+  ) async {
+    if (!isConnected) {
+      assert(false, 'getCharacteristicValue: device not connected. Call device.connect() first');
+      logger.finer('getCharacteristicValue: device not connected.');
+      return false;
+    }
+
+    if (characteristic.canRead) { // Read characteristic value if supported
+      try {
+        final data = await _cm.readCharacteristic(
+          source.peripheral,
+          characteristic.source,
+        );
+
+        onValue(data);
+        return true;
+      } catch (err) {
+        logger.warning('getCharacteristicValue: ble readCharacteristic failed', err);
+        return false;
+      }
+    }
+
+    else if (characteristic.canIndicate) { // Listen for characteristic value and trigger the device to send it
+      return listenCharacteristicValue(
+        characteristic,
+        _cm.characteristicNotified.map((eventArgs) {
+          if (characteristic.source != eventArgs.characteristic) {
+            /// characteristicNotified is a generic stream which ble does not
+            /// pre-filter for just the current requested characteristic
+            logger.finer('    data is for a different characteristic');
+            logger.finest('    ${eventArgs.characteristic.uuid} == ${characteristic.source.uuid} => ${eventArgs.characteristic == characteristic.source}');
+            logger.finest('    ${eventArgs.characteristic} == ${characteristic.source} => ${eventArgs.characteristic == characteristic.source}');
+            return null;
+          }
+
+          return eventArgs.value;
+        }),
+        onValue
+      );
+    }
+
+    logger.severe("Can't read or indicate characteristic: $characteristic");
+    return false;
+  }
+}

@@ -0,0 +1,31 @@
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_device.dart';
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_discovery.dart';
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_low_energy/ble_manager.dart';
+import 'package:bluetooth_low_energy/bluetooth_low_energy.dart' show UUID;
+
+/// BluetoothDeviceDiscovery implementation for the 'bluetooth_low_energy' package
+final class BluetoothLowEnergyDiscovery extends BluetoothDeviceDiscovery<BluetoothLowEnergyManager> {
+  /// Construct BluetoothDeviceDiscovery implementation for the 'bluetooth_low_energy' package
+  BluetoothLowEnergyDiscovery(super.manager);
+
+  @override
+  Stream<List<BluetoothDevice>> get discoverStream => manager.backend.discovered.map(
+    (device) => [manager.createDevice(device)]
+  );
+
+  @override
+  Future<void> backendStart(String serviceUuid) async {
+    try {
+      await manager.backend.startDiscovery(
+        // no timeout, the user knows best how long scanning is needed
+        serviceUUIDs: [UUID.fromString(serviceUuid)],
+        // Not all devices might be found using this configuration
+      );
+    } catch (e) {
+      onDiscoveryError(e);
+    }
+  }
+
+  @override
+  Future<void> backendStop() => manager.backend.stopDiscovery();
+}

@@ -0,0 +1,64 @@
+import 'dart:async';
+import 'dart:io';
+
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_low_energy/ble_device.dart';
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_low_energy/ble_discovery.dart';
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_low_energy/ble_service.dart';
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_low_energy/ble_state.dart';
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_manager.dart';
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_state.dart';
+import 'package:bluetooth_low_energy/bluetooth_low_energy.dart';
+
+/// Bluetooth manager for the 'bluetooth_low_energy' package
+final class BluetoothLowEnergyManager extends BluetoothManager<DiscoveredEventArgs, UUID, GATTService, GATTCharacteristic> {
+  /// constructor
+  BluetoothLowEnergyManager() {
+    logger.fine('init');
+
+    // Sync current adapter state
+    _adapterStateParser.parseAndCache(BluetoothLowEnergyStateChangedEventArgs(backend.state));
+  }
+
+  @override
+  Future<bool?> enable() async {
+    if (!Platform.isAndroid) {
+      return null;
+    }
+
+    return backend.authorize();
+  }
+
+  /// The actual backend implementation
+  final CentralManager backend = CentralManager();
+
+  final BluetoothLowEnergyStateParser _adapterStateParser = BluetoothLowEnergyStateParser();
+
+  @override
+  BluetoothAdapterState get lastKnownAdapterState => _adapterStateParser.lastKnownState;
+
+  @override
+  Stream<BluetoothAdapterState> get stateStream => backend.stateChanged.map(_adapterStateParser.parse);
+
+  BluetoothLowEnergyDiscovery? _discovery;
+
+  @override
+  BluetoothLowEnergyDiscovery get discovery {
+    _discovery ??= BluetoothLowEnergyDiscovery(this);
+    return _discovery!;
+  }
+
+  @override
+  BluetoothLowEnergyDevice createDevice(DiscoveredEventArgs device) => BluetoothLowEnergyDevice(this, device);
+
+  @override
+  BluetoothLowEnergyUUID createUuid(UUID uuid) => BluetoothLowEnergyUUID(uuid);
+
+  @override
+  BluetoothLowEnergyUUID createUuidFromString(String uuid) => BluetoothLowEnergyUUID.fromString(uuid);
+
+  @override
+  BluetoothLowEnergyService createService(GATTService service) => BluetoothLowEnergyService.fromSource(service);
+
+  @override
+  BluetoothLowEnergyCharacteristic createCharacteristic(GATTCharacteristic characteristic) => BluetoothLowEnergyCharacteristic.fromSource(characteristic);
+}

@@ -0,0 +1,45 @@
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_service.dart';
+import 'package:bluetooth_low_energy/bluetooth_low_energy.dart';
+
+/// UUID wrapper for BluetoothLowEnergy
+final class BluetoothLowEnergyUUID extends BluetoothUuid<UUID> {
+  /// Create a [BluetoothLowEnergyUUID] from a [UUID]
+  BluetoothLowEnergyUUID(UUID uuid): super(uuid: uuid.toString(), source: uuid);
+
+  /// Create a [BluetoothLowEnergyUUID] from a [String]
+  factory BluetoothLowEnergyUUID.fromString(String uuid) => BluetoothLowEnergyUUID(UUID.fromString(uuid));
+}
+
+/// Wrapper class with generic interface for a [GATTService]
+final class BluetoothLowEnergyService
+    extends BluetoothService<GATTService, BluetoothLowEnergyCharacteristic> {
+
+   /// Create a [BluetoothLowEnergyService] from a [GATTService]
+  BluetoothLowEnergyService.fromSource(GATTService service):
+    super(uuid: BluetoothLowEnergyUUID(service.uuid), source: service);
+
+  @override
+  List<BluetoothLowEnergyCharacteristic> get characteristics => source.characteristics.map(BluetoothLowEnergyCharacteristic.fromSource).toList();
+}
+
+/// Wrapper class with generic interface for a [GATTCharacteristic]
+final class BluetoothLowEnergyCharacteristic extends BluetoothCharacteristic<GATTCharacteristic> {
+  /// Create a [BluetoothLowEnergyCharacteristic] from the backend specific source
+  BluetoothLowEnergyCharacteristic.fromSource(GATTCharacteristic source):
+    super(uuid: BluetoothLowEnergyUUID(source.uuid), source: source);
+
+  @override
+  bool get canRead => source.properties.contains(GATTCharacteristicProperty.read);
+
+  @override
+  bool get canWrite => source.properties.contains(GATTCharacteristicProperty.write);
+
+  @override
+  bool get canWriteWithoutResponse => source.properties.contains(GATTCharacteristicProperty.writeWithoutResponse);
+
+  @override
+  bool get canNotify => source.properties.contains(GATTCharacteristicProperty.notify);
+
+  @override
+  bool get canIndicate => source.properties.contains(GATTCharacteristicProperty.indicate);
+}

@@ -0,0 +1,17 @@
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_state.dart';
+import 'package:bluetooth_low_energy/bluetooth_low_energy.dart';
+
+/// Bluetooth adapter state parser for the 'bluetooth_low_energy' package
+final class BluetoothLowEnergyStateParser extends BluetoothAdapterStateParser<BluetoothLowEnergyStateChangedEventArgs> {
+  @override
+  BluetoothAdapterState parse(BluetoothLowEnergyStateChangedEventArgs rawState) => switch (rawState.state) {
+    BluetoothLowEnergyState.unsupported => BluetoothAdapterState.unfeasible,
+    // Bluetooth permissions should always be granted on normal android
+    // devices. Users on non-standard android devices will know how to
+    // enable them. If this is not the case there will be bug reports.
+    BluetoothLowEnergyState.unauthorized => BluetoothAdapterState.unauthorized,
+    BluetoothLowEnergyState.poweredOn => BluetoothAdapterState.ready,
+    BluetoothLowEnergyState.poweredOff => BluetoothAdapterState.disabled,
+    BluetoothLowEnergyState.unknown => BluetoothAdapterState.initial,
+  };
+}

@@ -0,0 +1,109 @@
+import 'dart:async';
+
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_connection.dart';
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_device.dart';
+import 'package:blood_pressure_app/features/bluetooth/backend/flutter_blue_plus/fbp_manager.dart';
+import 'package:blood_pressure_app/features/bluetooth/backend/flutter_blue_plus/fbp_service.dart';
+import 'package:flutter/foundation.dart';
+import 'package:flutter_blue_plus/flutter_blue_plus.dart' as fbp;
+
+/// BluetoothDevice implementation for the 'flutter_blue_plus' package
+final class FlutterBluePlusDevice
+  extends BluetoothDevice<
+    FlutterBluePlusManager,
+    FlutterBluePlusService,
+    FlutterBluePlusCharacteristic,
+    fbp.ScanResult
+  >
+  with CharacteristicValueListener<
+    FlutterBluePlusManager,
+    FlutterBluePlusService,
+    FlutterBluePlusCharacteristic,
+    fbp.ScanResult
+  >
+{
+  /// Initialize BluetoothDevice implementation for the 'flutter_blue_plus' package
+  FlutterBluePlusDevice(super.manager, super.source);
+
+  @override
+  String get deviceId => source.device.remoteId.str;
+
+  @override
+  String get name => source.device.platformName;
+
+  @override
+  Stream<BluetoothConnectionState> get connectionStream => source.device.connectionState
+    .map((fbp.BluetoothConnectionState rawState) => switch (rawState) {
+      fbp.BluetoothConnectionState.connected => BluetoothConnectionState.connected,
+      fbp.BluetoothConnectionState.disconnected => BluetoothConnectionState.disconnected,
+      // code should never reach here
+      fbp.BluetoothConnectionState.connecting || fbp.BluetoothConnectionState.disconnecting
+        => throw ErrorDescription('Unsupported connection state: $rawState'),
+    });
+
+  @override
+  Future<void> backendConnect() => source.device.connect();
+
+  @override
+  Future<void> backendDisconnect() => source.device.disconnect();
+
+  @override
+  Future<void> dispose() => disposeCharacteristics();
+
+  @override
+  Future<List<FlutterBluePlusService>?> discoverServices() async {
+    if (!isConnected) {
+      logger.finer('Device not connected, cannot discover services');
+      return null;
+    }
+
+    // Query actual services supported by the device. While they must be
+    // rediscovered when a disconnect happens, this object is also recreated.
+    try {
+      final allServices = await source.device.discoverServices();
+      logger.finer('fbp.discoverServices: $allServices');
+
+      return allServices.map(FlutterBluePlusService.fromSource).toList();
+    } catch (e) {
+      logger.shout('Error on service discovery', [source.device, e]);
+      return null;
+    }
+  }
+
+  @override
+  Future<bool> triggerCharacteristicValue(FlutterBluePlusCharacteristic characteristic, [bool state = true]) => characteristic.source.setNotifyValue(state);
+
+  @override
+  Future<bool> getCharacteristicValue(
+    FlutterBluePlusCharacteristic characteristic,
+    void Function(Uint8List value, [void Function(bool success)? complete]) onValue
+  ) async {
+    if (!isConnected) {
+      assert(false, 'getCharacteristicValue: device not connected. Call device.connect() first');
+      logger.finer('getCharacteristicValue: device not connected.');
+      return false;
+    }
+
+    if (characteristic.canRead) { // Read characteristic value if supported
+      try {
+        final data = await characteristic.source.read();
+        onValue(Uint8List.fromList(data));
+        return true;
+      } catch (err) {
+        logger.severe('getCharacteristicValue(read error)', err);
+        return false;
+      }
+    }
+
+    if (characteristic.canIndicate) { // Listen for characteristic value and trigger the device to send it
+      return listenCharacteristicValue(
+        characteristic,
+        characteristic.source.onValueReceived.map(Uint8List.fromList),
+        onValue
+      );
+    }
+
+    logger.severe("Can't read or indicate characteristic: $characteristic");
+    return false;
+  }
+}

@@ -0,0 +1,31 @@
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_device.dart';
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_discovery.dart';
+import 'package:blood_pressure_app/features/bluetooth/backend/flutter_blue_plus/fbp_manager.dart';
+import 'package:flutter_blue_plus/flutter_blue_plus.dart' show Guid;
+
+/// BluetoothDeviceDiscovery implementation for the 'flutter_blue_plus' package
+final class FlutterBluePlusDiscovery extends BluetoothDeviceDiscovery<FlutterBluePlusManager> {
+  /// constructor
+  FlutterBluePlusDiscovery(super.manager);
+
+  @override
+  Stream<List<BluetoothDevice>> get discoverStream => manager.backend.scanResults.map(
+    (devices) => devices.map(manager.createDevice).toList()
+  );
+
+  @override
+  Future<void> backendStart(String serviceUuid) async {
+    try {
+      await manager.backend.startScan(
+        // no timeout, the user knows best how long scanning is needed
+        withServices: [ Guid(serviceUuid) ],
+        // Not all devices are found using this configuration (https://pub.dev/packages/flutter_blue_plus#scanning-does-not-find-my-device).
+      );
+    } catch (e) {
+      onDiscoveryError(e);
+    }
+  }
+
+  @override
+  Future<void> backendStop() => manager.backend.stopScan();
+}

@@ -0,0 +1,68 @@
+
+
+import 'dart:io';
+
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_manager.dart';
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_state.dart';
+import 'package:blood_pressure_app/features/bluetooth/backend/flutter_blue_plus/fbp_device.dart';
+import 'package:blood_pressure_app/features/bluetooth/backend/flutter_blue_plus/fbp_discovery.dart';
+import 'package:blood_pressure_app/features/bluetooth/backend/flutter_blue_plus/fbp_service.dart';
+import 'package:blood_pressure_app/features/bluetooth/backend/flutter_blue_plus/fbp_state.dart';
+import 'package:blood_pressure_app/features/bluetooth/backend/flutter_blue_plus/flutter_blue_plus_mockable.dart';
+import 'package:flutter_blue_plus/flutter_blue_plus.dart' as fbp;
+import 'package:flutter_blue_plus/flutter_blue_plus.dart' show Guid, ScanResult;
+
+/// Bluetooth manager for the 'flutter_blue_plus' package
+class FlutterBluePlusManager extends BluetoothManager<ScanResult, Guid, fbp.BluetoothService, fbp.BluetoothCharacteristic> {
+  /// constructor
+  FlutterBluePlusManager([FlutterBluePlusMockable? backend]): backend = (backend ?? FlutterBluePlusMockable()) {
+    logger.finer('init');
+  }
+
+  /// backend implementation
+  final FlutterBluePlusMockable backend;
+
+  @override
+  Future<bool?> enable() async {
+    if (Platform.isAndroid) {
+      await backend.turnOn();
+      return true;
+    }
+    return null;
+  }
+
+  @override
+  BluetoothAdapterState get lastKnownAdapterState {
+    // Check whether our lastKnownState is the same as FlutterBluePlus's
+    assert(_adapterStateParser.parse(backend.adapterStateNow) == _adapterStateParser.lastKnownState);
+    return _adapterStateParser.lastKnownState;
+  }
+
+  final FlutterBluePlusStateParser _adapterStateParser = FlutterBluePlusStateParser();
+
+  @override
+  Stream<BluetoothAdapterState> get stateStream => backend.adapterState.map(_adapterStateParser.parse);
+
+  FlutterBluePlusDiscovery? _discovery;
+
+  @override
+  FlutterBluePlusDiscovery get discovery {
+    _discovery ??= FlutterBluePlusDiscovery(this);
+    return _discovery!;
+  }
+
+  @override
+  FlutterBluePlusDevice createDevice(ScanResult device) => FlutterBluePlusDevice(this, device);
+
+  @override
+  FlutterBluePlusUUID createUuid(Guid uuid) => FlutterBluePlusUUID(uuid);
+
+  @override
+  FlutterBluePlusUUID createUuidFromString(String uuid) => FlutterBluePlusUUID.fromString(uuid);
+
+  @override
+  FlutterBluePlusService createService(fbp.BluetoothService service) => FlutterBluePlusService.fromSource(service);
+
+  @override
+  FlutterBluePlusCharacteristic createCharacteristic(fbp.BluetoothCharacteristic characteristic) => FlutterBluePlusCharacteristic.fromSource(characteristic);
+}

@@ -0,0 +1,50 @@
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_service.dart';
+import 'package:flutter_blue_plus/flutter_blue_plus.dart' as fbp;
+import 'package:flutter_blue_plus/flutter_blue_plus.dart' show Guid;
+
+/// UUID wrapper for FlutterBluePlus
+final class FlutterBluePlusUUID extends BluetoothUuid<Guid> {
+  /// Create a [FlutterBluePlusUUID] from a [Guid]
+  FlutterBluePlusUUID(Guid uuid): super(uuid: uuid.str128, source: uuid);
+
+  /// Create a [FlutterBluePlusUUID] from a [String]
+  factory FlutterBluePlusUUID.fromString(String uuid) => FlutterBluePlusUUID(Guid(uuid));
+}
+
+/// [BluetoothService] implementation wrapping [fbp.BluetoothService]
+final class FlutterBluePlusService extends BluetoothService<fbp.BluetoothService, FlutterBluePlusCharacteristic> {
+  /// Create [BluetoothService] implementation wrapping [fbp.BluetoothService]
+  FlutterBluePlusService({ required super.uuid, required super.source });
+
+  /// Create a [FlutterBluePlusService] from a [fbp.BluetoothService]
+  factory FlutterBluePlusService.fromSource(fbp.BluetoothService service) {
+    final uuid = FlutterBluePlusUUID(service.serviceUuid);
+    return FlutterBluePlusService(uuid: uuid, source: service);
+  }
+
+  @override
+  List<FlutterBluePlusCharacteristic> get characteristics => source.characteristics
+    .map(FlutterBluePlusCharacteristic.fromSource).toList();
+}
+
+/// Wrapper class with generic interface for a [fbp.BluetoothCharacteristic]
+final class FlutterBluePlusCharacteristic extends BluetoothCharacteristic<fbp.BluetoothCharacteristic> {
+  /// Initialize a [FlutterBluePlusCharacteristic] from the backend specific source
+  FlutterBluePlusCharacteristic.fromSource(fbp.BluetoothCharacteristic source):
+    super(uuid: FlutterBluePlusUUID(source.characteristicUuid), source: source);
+
+  @override
+  bool get canRead => source.properties.read;
+  
+  @override
+  bool get canWrite => source.properties.write;
+  
+  @override
+  bool get canWriteWithoutResponse => source.properties.writeWithoutResponse;
+  
+  @override
+  bool get canNotify => source.properties.notify;
+  
+  @override
+  bool get canIndicate => source.properties.indicate;
+}

@@ -0,0 +1,19 @@
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_state.dart';
+import 'package:flutter_blue_plus/flutter_blue_plus.dart' as fbp;
+
+/// Bluetooth adapter state parser for the 'flutter_blue_plus' package
+final class FlutterBluePlusStateParser extends BluetoothAdapterStateParser<fbp.BluetoothAdapterState> {
+  @override
+  BluetoothAdapterState parse(fbp.BluetoothAdapterState rawState) => switch (rawState) {
+    fbp.BluetoothAdapterState.unavailable => BluetoothAdapterState.unfeasible,
+    // Bluetooth permissions should always be granted on normal android
+    // devices. Users on non-standard android devices will know how to
+    // enable them. If this is not the case there will be bug reports.
+    fbp.BluetoothAdapterState.unauthorized => BluetoothAdapterState.unauthorized,
+    fbp.BluetoothAdapterState.on => BluetoothAdapterState.ready,
+    fbp.BluetoothAdapterState.off
+      || fbp.BluetoothAdapterState.turningOn
+      || fbp.BluetoothAdapterState.turningOff => BluetoothAdapterState.disabled,
+    fbp.BluetoothAdapterState.unknown => BluetoothAdapterState.initial,
+  };
+}

@@ -2,8 +2,7 @@ import 'dart:async';
 
 import 'package:flutter_blue_plus/flutter_blue_plus.dart';
 
-/// Wrapper for FlutterBluePlus in order to easily mock it
-/// Wraps all calls for testing purposes
+/// Wrapper for FlutterBluePlus in allowing easy mocking during testing
 class FlutterBluePlusMockable {
   LogLevel get logLevel => FlutterBluePlus.logLevel;
 
@@ -136,4 +135,4 @@ class FlutterBluePlusMockable {
 
   /// Request Bluetooth PHY support
   Future<PhySupport> getPhySupport() => FlutterBluePlus.getPhySupport();
-}
\ No newline at end of file
+}

@@ -0,0 +1,38 @@
+import 'dart:typed_data';
+
+import 'package:blood_pressure_app/config.dart';
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_connection.dart';
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_device.dart';
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_manager.dart';
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_service.dart';
+
+/// Placeholder [BluetoothDevice] implementation that can f.e. be used for testing
+final class MockBluetoothDevice extends BluetoothDevice<BluetoothManager, BluetoothService, BluetoothCharacteristic, String> {
+  /// Initialize Placeholder [BluetoothDevice] implementation that can f.e. be used for testing
+  MockBluetoothDevice(super.manager, super.source): assert(isTestingEnvironment, 'consider whether a blanket implementation is appropriate');
+
+  @override
+  String get deviceId => super.source;
+
+  @override
+  String get name => super.source;
+
+  @override
+  Stream<BluetoothConnectionState> get connectionStream => const Stream<BluetoothConnectionState>.empty();
+
+  @override
+  Future<void> backendConnect() async {}
+
+  @override
+  Future<void> backendDisconnect() async {}
+
+  @override
+  Future<void> dispose() async {}
+
+  @override
+  Future<List<BluetoothService<dynamic, BluetoothCharacteristic>>?> discoverServices() =>
+    Future.value(<BluetoothService<dynamic, BluetoothCharacteristic>>[]);
+
+  @override
+  Future<bool> getCharacteristicValue(BluetoothCharacteristic characteristic, void Function(Uint8List value) onValue) async => true;
+}

@@ -0,0 +1,23 @@
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_device.dart';
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_discovery.dart';
+import 'package:blood_pressure_app/features/bluetooth/backend/mock/mock_manager.dart';
+
+/// Placeholder [BluetoothDeviceDiscovery] implementation that can f.e. be used for testing
+final class MockBluetoothDiscovery extends BluetoothDeviceDiscovery<MockBluetoothManager> {
+  /// constructor
+  MockBluetoothDiscovery(super.manager);
+  
+  @override
+  Future<void> backendStart(String serviceUuid) {
+    throw UnimplementedError();
+  }
+  
+  @override
+  Future<void> backendStop() {
+    throw UnimplementedError();
+  }
+  
+  @override
+  Stream<List<BluetoothDevice>> get discoverStream => throw UnimplementedError();
+
+}

@@ -0,0 +1,46 @@
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_device.dart';
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_discovery.dart';
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_manager.dart';
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_service.dart';
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_state.dart';
+import 'package:blood_pressure_app/features/bluetooth/backend/mock/mock_service.dart';
+
+/// Placeholder [BluetoothManager] implementation that can f.e. be used for testing
+final class MockBluetoothManager extends BluetoothManager<String, String, MockedService, MockedCharacteristic> {
+  @override
+  BluetoothDeviceDiscovery<BluetoothManager> get discovery => throw UnimplementedError();
+
+  @override
+  Future<bool?> enable() async => null;
+  
+  @override
+  BluetoothAdapterState get lastKnownAdapterState => BluetoothAdapterState.initial;
+  
+  @override
+  Stream<BluetoothAdapterState> get stateStream => const Stream.empty();
+
+  @override
+  BluetoothUuid createUuid(String uuid) {
+    throw UnimplementedError();
+  }
+
+  @override
+  BluetoothUuid createUuidFromString(String uuid) {
+    throw UnimplementedError();
+  }
+
+  @override
+  BluetoothDevice<BluetoothManager, BluetoothService<dynamic, BluetoothCharacteristic>, BluetoothCharacteristic, dynamic> createDevice(String device) {
+    throw UnimplementedError();
+  }
+
+  @override
+  BluetoothService<dynamic, BluetoothCharacteristic> createService(MockedService service) {
+    throw UnimplementedError();
+  }
+
+  @override
+  BluetoothCharacteristic createCharacteristic(MockedCharacteristic characteristic) {
+    throw UnimplementedError();
+  }
+}

@@ -0,0 +1,68 @@
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_service.dart';
+
+/// Backend implementation for MockBluetoothService
+final class MockedService {
+  /// constructor
+  MockedService({ required this.uuid, required this.characteristics });
+
+  String uuid;
+  List<MockedCharacteristic> characteristics;
+}
+
+/// Backend implementation for MockBluetoothCharacteristic
+final class MockedCharacteristic {
+  /// constructor
+  MockedCharacteristic({
+    required this.uuid,
+    this.canRead = false,
+    this.canWrite = false,
+    this.canWriteWithoutResponse = false,
+    this.canNotify = false,
+    this.canIndicate = false,
+  });
+
+  String uuid;
+  bool canRead;
+  bool canWrite;
+  bool canWriteWithoutResponse;
+  bool canNotify;
+  bool canIndicate;
+}
+
+/// String wrapper for Bluetooth
+final class MockBluetoothString extends BluetoothUuid<String> {
+  /// Create a BluetoothString from a String
+  MockBluetoothString(String uuid): super(uuid: uuid, source: uuid);
+  /// Create a BluetoothString from a string
+  MockBluetoothString.fromString(String uuid): super(uuid: uuid, source: uuid);
+}
+
+/// Wrapper class with generic interface for a [MockedService]
+final class MockBluetoothService extends BluetoothService<MockedService, BluetoothCharacteristic> {
+   /// Create a FlutterBlueService from a [MockedService]
+  MockBluetoothService.fromSource(MockedService service): super(uuid: MockBluetoothString(service.uuid), source: service);
+
+  @override
+  List<BluetoothCharacteristic> get characteristics => source.characteristics.map(MockBluetoothCharacteristic.fromSource).toList();
+}
+
+/// Wrapper class with generic interface for a [MockedCharacteristic]
+final class MockBluetoothCharacteristic extends BluetoothCharacteristic<MockedCharacteristic> {
+  /// Create a BluetoothCharacteristic from the backend specific source
+  MockBluetoothCharacteristic.fromSource(MockedCharacteristic source): super(uuid: MockBluetoothString(source.uuid), source: source);
+
+  @override
+  bool get canRead => source.canRead;
+
+  @override
+  bool get canWrite => source.canWrite;
+
+  @override
+  bool get canWriteWithoutResponse => source.canWriteWithoutResponse;
+
+  @override
+  bool get canNotify => source.canNotify;
+
+  @override
+  bool get canIndicate => source.canIndicate;
+}

@@ -0,0 +1,16 @@
+/// Utility import that only exposes the bluetooth backend services that should be used.
+library;
+
+export 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_device.dart' show BluetoothDevice;
+export 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_manager.dart' show BluetoothManager;
+export 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_state.dart' show BluetoothAdapterState;
+
+/// All available bluetooth backends
+enum BluetoothBackend {
+  /// Bluetooth Low Energy backend
+  bluetoothLowEnergy,
+  /// Flutter Blue Plus backend
+  flutterBluePlus,
+  /// Mock backend
+  mock;
+}

@@ -0,0 +1,8 @@
+/// State of the bluetooth connection of a device
+enum BluetoothConnectionState {
+  /// Device is connected
+  connected,
+  /// Device is disconnect
+  disconnected;
+}
+

@@ -0,0 +1,392 @@
+import 'dart:async';
+import 'dart:math';
+
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_connection.dart';
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_manager.dart';
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_service.dart';
+import 'package:blood_pressure_app/logging.dart';
+import 'package:collection/collection.dart';
+import 'package:flutter/foundation.dart';
+
+/// Current state of the bluetooth device
+enum BluetoothDeviceState {
+  /// Started connecting to the device
+  connecting,
+  /// Started disconnecting the device
+  disconnecting,
+  /// Device is connected (f.e. it send a connected event)
+  connected,
+  /// Device is disconnected (f.e. it send a disconnected event)
+  disconnected;
+}
+
+/// Wrapper class for bluetooth implementations to generically expose required functionality
+abstract class BluetoothDevice<
+  BM extends BluetoothManager,
+  BS extends BluetoothService,
+  BC extends BluetoothCharacteristic,
+  BackendDevice
+> with TypeLogger {
+  /// Create a new BluetoothDevice.
+  ///
+  /// * [manager] Manager the device belongs to
+  /// * [source] Device implementation of the current backend
+  BluetoothDevice(this.manager, this.source) {
+    logger.finer('init device: $this');
+  }
+
+  /// [BluetoothManager] this device belongs to
+  final BM manager;
+
+  /// Original source device as returned by the backend
+  final BackendDevice source;
+
+  BluetoothDeviceState _state = BluetoothDeviceState.disconnected;
+
+  /// (Unique?) id of the device
+  String get deviceId;
+
+  /// Name of the device
+  String get name;
+
+  /// Memoized service list for the device
+  List<BS>? _services;
+
+  StreamSubscription<BluetoothConnectionState>? _connectionListener;
+
+  /// Whether the device is connected
+  bool get isConnected => _state == BluetoothDeviceState.connected;
+
+  /// Stream to listen to for connection state changes after connecting to a device
+  Stream<BluetoothConnectionState> get connectionStream;
+
+  /// Backend implementation to connect to the device
+  Future<void> backendConnect();
+  /// Backend implementation to disconnect to the device
+  Future<void> backendDisconnect();
+
+  /// Require backends to implement a dispose method to cleanup any resources
+  Future<void> dispose();
+
+  /// Array of disconnect callbacks
+  ///
+  /// Disconnect callbacks are processed in reverse order, i.e. the latest added callback is executed as first. Callbacks
+  /// can return true to indicate they have fully handled the disconnect. This will then also stop executing any remaining
+  /// callbacks.
+  final List<bool Function()> disconnectCallbacks = [];
+
+  /// Wait for the device state to change to a different value then disconnecting
+  ///
+  /// [timeout] - How long to wait before timeout occurs. A value of -1 disables waiting, a value of 0 waits indefinitely
+  Future<void> _waitForDisconnectingStateChange({ int timeout = 300000 }) async {
+    if (timeout < 0) {
+      return;
+    }
+
+    // Futures within an any still always resolve, it's just that the results
+    // are disregard for futures that do not finish first. Use this bool to
+    // keep track whether the futures are already completed or not
+    bool futuresCompleted = false;
+
+    /// Waits and calls itself recursively as long as the current device [_state] equals [BluetoothDeviceState.disconnecting]
+    Future<void> checkDeviceState() async {
+      while (!futuresCompleted && _state == BluetoothDeviceState.disconnecting) {
+        logger.finest('Waiting because device is still disconnecting');
+        await Future.delayed(const Duration(milliseconds: 10));
+      }
+    }
+
+    final futures = [checkDeviceState()];
+    if (timeout > 0) {
+      futures.add(
+        Future.delayed(Duration(milliseconds: min(timeout, 300000))).then((_) {
+          if (!futuresCompleted) {
+            logger.finest('connect: Wait for state change timed out after $timeout ms');
+          }
+        })
+      );
+    }
+
+    await Future.any(futures);
+    futuresCompleted = true;
+  }
+
+  /// Connect to the device
+  ///
+  /// Always call [disconnect] when ready after calling connect
+  /// [onConnect] Called after device is connected
+  /// [onDisconnect] Called after device is disconnected, see [disconnectCallbacks]
+  /// [onError] Called when an error occurs
+  /// [waitForDisconnectingStateChangeTimeout] If connect is called while the device is still disconnecting, wait
+  ///   for the device to change it's state. A value of -1 means don't ever wait, a value of 0 means wait indefinitely
+  ///   Setting this timeout ensures correct state management of the device so users only have to call disconnect()/connect() 
+  Future<bool> connect({
+    VoidCallback? onConnect,
+    bool Function()? onDisconnect,
+    ValueSetter<Object>? onError,
+    int waitForDisconnectingStateChangeTimeout = 3000
+  }) async {
+    if (_state == BluetoothDeviceState.disconnecting) {
+      await _waitForDisconnectingStateChange(timeout: waitForDisconnectingStateChangeTimeout);
+    }
+
+    if (_state != BluetoothDeviceState.disconnected) {
+      return false;
+    }
+
+    _state = BluetoothDeviceState.connecting;
+
+    final completer = Completer<bool>();
+    logger.finer('connect: start connecting');
+
+    if (onDisconnect != null) {
+      disconnectCallbacks.add(onDisconnect);
+    }
+
+    await _connectionListener?.cancel();
+    _connectionListener = connectionStream.listen((BluetoothConnectionState state) {
+      logger.finest('connectionStream.listen[_state: $_state]: $state');
+
+      // Note: in this abstraction we want the device state to be singular. Unfortunately
+      // not all libraries on all platforms send only a single connection state event. F.e.
+      // flutter_blue_plus can send 3 disconnect events the very first time you try to connect
+      // with a device. These multiple similar events for the same device will break our logic
+      // so we need to filter the states.
+      switch (state) {
+        case BluetoothConnectionState.connected:
+          if (_state != BluetoothDeviceState.connecting) {
+            // Ignore status update if the current device state was not connecting. Cause then
+            // the library probably send multiple state update events.
+            logger.finest('Ignoring state update because device was not connecting: $_state');
+            return;
+          }
+
+          onConnect?.call();
+          if (!completer.isCompleted) completer.complete(true);
+          _state = BluetoothDeviceState.connected;
+          return;
+        case BluetoothConnectionState.disconnected:
+          if ([BluetoothDeviceState.connecting, BluetoothDeviceState.disconnected].any((s) => s == _state)) {
+            // Ignore status update if the state was connecting or already disconnected
+            logger.finest('Ignoring state update because device was already disconnected: $_state');
+            return;
+          }
+
+          for (final fn in disconnectCallbacks.reversed) {
+            if (fn()) {
+              // ignore other disconnect callbacks
+              break;
+            }
+          }
+
+          disconnectCallbacks.clear();
+          if (!completer.isCompleted) completer.complete(false);
+          _state = BluetoothDeviceState.disconnected;
+      }
+    }, onError: onError);
+
+    try {
+      await backendConnect();
+    } catch (e) {
+      logger.severe('Failed to connect to device', e);
+      if (!completer.isCompleted) completer.complete(false);
+      _state = BluetoothDeviceState.disconnected;
+    }
+
+    return completer.future.then((res) {
+      logger.finer('connect: completer.resolved($res)');
+      return res;
+    });
+  }
+
+  /// Disconnect & dispose the device
+  ///
+  /// Always call [disconnect] after calling [connect] to ensure all resources are disposed
+  /// Optionally specify [waitForStateChangeTimeout] in milliseconds to indicate how long we
+  /// should wait for the device to send a disconnect event. Specifying a value of -1 disables
+  /// waiting for the state change, a value of 0 means wait indefinitely.
+  Future<bool> disconnect({ int waitForStateChangeTimeout = 3000 }) async {
+    _state = BluetoothDeviceState.disconnecting;
+    await backendDisconnect();
+
+    if (waitForStateChangeTimeout > -1) {
+      await _waitForDisconnectingStateChange(timeout: waitForStateChangeTimeout);
+
+      assert(
+        _state == BluetoothDeviceState.disconnecting || _state == BluetoothDeviceState.disconnected,
+        'Expected state either to be disconnecting (due to timeout) or disconnected. Got $_state instead'
+      );
+    }
+
+    await _connectionListener?.cancel();
+    await dispose();
+    return true;
+  }
+
+  /// Discover all available services on the device
+  ///
+  /// It's recommended to use [getServices] instead
+  Future<List<BS>?> discoverServices();
+
+  /// Return all available services for this device
+  ///
+  /// Difference with [discoverServices] is that [getServices] memoizes the results
+  Future<List<BS>?> getServices() async {
+    final logServices = _services == null; // only log services on the first call
+    _services ??= await discoverServices();
+    if (_services == null) {
+      logger.finer('Failed to discoverServices on: $this');
+    }
+
+    if (logServices) {
+      logger.finest(_services
+        ?.map((s) => 'Found services\n$s:\n  - ${s.characteristics.join('\n  - ')}]')
+        .join('\n'));
+    }
+
+    return _services;
+  }
+
+  /// Returns the service with requested [uuid] or null if requested service is not available
+  Future<BS?> getServiceByUuid(BluetoothUuid uuid) async {
+    final services = await getServices();
+    return services?.firstWhereOrNull((service) => service.uuid == uuid);
+  }
+
+  /// Retrieves the value of [characteristic] from the device and calls [onValue] for all received values
+  /// 
+  /// This method provides a generic implementation for async reading of data, regardless whether the
+  /// characteristic can be read directly or through a notification or indication. In case the value
+  /// is being read using an indication, then the [onValue] callback receives a second argument [complete] with
+  /// which you can stop reading the data.
+  ///
+  /// Note that a [characteristic] could have multiple values, so [onValue] can be called more then once.
+  /// TODO: implement reading values for characteristics with [canNotify]
+  Future<bool> getCharacteristicValue(BC characteristic, void Function(Uint8List value, [void Function(bool success)? complete]) onValue);
+
+  @override
+  String toString() => 'BluetoothDevice{name: $name, deviceId: $deviceId}';
+
+  @override
+  /// Compare devices, only checking hashCode is not sufficient during tests as hashCode
+  /// of mocked classes seems to be always 0 hence why also comparing by deviceId
+  /// TODO: Understand why the mocked devices in the device_scan_cubit_test have the same hashCode=0 and are therefore not all added to the set
+  bool operator == (Object other) => other is BluetoothDevice && hashCode == other.hashCode && deviceId == other.deviceId;
+
+  @override
+  int get hashCode => deviceId.hashCode ^ name.hashCode;
+}
+
+/// Generic logic to implement an indication stream to read characteristic values
+mixin CharacteristicValueListener<
+  BM extends BluetoothManager,
+  BS extends BluetoothService,
+  BC extends BluetoothCharacteristic,
+  BackendDevice
+> on BluetoothDevice<BM, BS, BC, BackendDevice> {
+  /// List of read characteristic completers, used for cleanup on device disconnect
+  final List<Completer<bool>> _readCharacteristicCompleters = [];
+  /// List of read characteristic subscriptions, used for cleanup on device disconnect
+  final List<StreamSubscription<Uint8List?>> _readCharacteristicListeners = [];
+
+  /// Dispose of all resources used to read characteristics
+  ///
+  /// Internal method, should not be used by users
+  @protected
+  Future<void> disposeCharacteristics() async {
+    for (final completer in _readCharacteristicCompleters) {
+      // completing the completer also cancels the listener
+      completer.complete(false);
+    }
+
+    _readCharacteristicCompleters.clear();
+    _readCharacteristicListeners.clear();
+  }
+
+  /// Trigger notifications or indications for the [characteristic]
+  @protected
+  Future<bool> triggerCharacteristicValue(BC characteristic, [bool state = true]);
+
+  /// Read characteristic values from a stream
+  ///
+  /// It's not recommended to use this method directly, use [BluetoothDevice.getCharacteristicValue] instead
+  @protected
+  Future<bool> listenCharacteristicValue(
+    BC characteristic,
+    Stream<Uint8List?> characteristicValueStream,
+    void Function(Uint8List value, [void Function(bool success)? complete]) onValue
+  ) async {
+    if (!characteristic.canIndicate) {
+      return false;
+    }
+
+    final completer = Completer<bool>();
+    bool receivedSomeData = false;
+
+    bool disconnectCallback() {
+      logger.finer('listenCharacteristicValue(receivedSomeData: $receivedSomeData): onDisconnect called');
+      if (!receivedSomeData) {
+        return false;
+      }
+
+      completer.complete(true);
+      return true;
+    }
+
+    disconnectCallbacks.add(disconnectCallback);
+
+    final listener = characteristicValueStream.listen(
+      (value) {
+        if (value == null) {
+          // ignore null values
+          return;
+        }
+
+        logger.finer('listenCharacteristicValue[${value.length}] $value');
+
+        receivedSomeData = true;
+        onValue(value, completer.complete);
+      },
+      cancelOnError: true,
+      onDone: () {
+        logger.finer('listenCharacteristicValue: onDone called');
+        completer.complete(receivedSomeData);
+      },
+      onError: (Object err) {
+        logger.shout('listenCharacteristicValue: Error while reading characteristic', err);
+        completer.complete(false);
+      }
+    );
+
+    // track completer & listener so we can clean them up
+    // when the device unexpectedly disconnects (ie before
+    // any data has been received yet)
+    _readCharacteristicCompleters.add(completer);
+    _readCharacteristicListeners.add(listener);
+
+    try {
+      logger.finest('listenCharacteristicValue: triggering characteristic value');
+      final bool triggerSuccess = await triggerCharacteristicValue(characteristic);
+      if (!triggerSuccess) {
+        logger.warning('listenCharacteristicValue: triggerCharacteristicValue returned $triggerSuccess');
+      }
+    } catch (e) {
+      logger.severe('Error occured while triggering characteristic', e);
+    }
+
+    return completer.future.then((res) {
+      // Ensure listener is always cancelled when completer resolves
+      listener.cancel().then((_) => _readCharacteristicListeners.remove(listener));
+
+      // Remove stored completer reference
+      _readCharacteristicCompleters.remove(completer);
+
+      // Remove disconnect callback in case the connection was not automatically disconnected
+      if (disconnectCallbacks.remove(disconnectCallback)) {
+        logger.finer('listenCharacteristicValue: device was not automatically disconnected after completer finished, removing disconnect callback');
+      }
+
+      return res;
+    });
+  }
+}

@@ -0,0 +1,99 @@
+import 'dart:async';
+
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_device.dart';
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_manager.dart';
+import 'package:blood_pressure_app/logging.dart';
+import 'package:flutter/foundation.dart';
+
+/// Base class for backend device discovery implementations
+abstract class BluetoothDeviceDiscovery<BM extends BluetoothManager> with TypeLogger {
+  /// Initialize base class for device discovery implementations.
+  BluetoothDeviceDiscovery(this.manager) {
+    logger.finer('init device discovery: $this');
+  }
+
+  /// Corresponding BluetoothManager
+  final BM manager;
+
+  /// List of discovered devices
+  final Set<BluetoothDevice> _devices = {};
+
+  /// A stream that returns the discovered devices when discovering
+  Stream<List<BluetoothDevice>> get discoverStream;
+
+  StreamSubscription<List<BluetoothDevice>>? _discoverSubscription;
+
+  /// Backend implementation to start discovering
+  @protected
+  Future<void> backendStart(String serviceUuid);
+
+  /// Backend implementation to stop discovering
+  @protected
+  Future<void> backendStop();
+
+  /// Whether device discovery is running or not
+  bool _discovering = false;
+
+  /// True when already discovering devices
+  bool get isDiscovering => _discovering;
+
+  /// Start discovering for new devices
+  ///
+  /// - [serviceUuid] The service uuid to filter on when discovering devices
+  /// - [onDevices] Callback for when devices have been discovered. The
+  ///   [onDevices] callback can be called multiple times, it is also always
+  ///   called with the list of all discovered devices from the start of discovering
+  Future<void> start(String serviceUuid, ValueSetter<List<BluetoothDevice>> onDevices) async {
+    if (_discovering) {
+      logger.warning('Already discovering, not starting discovery again');
+      return;
+    }
+
+    // Do not remove this if, otherwise the device_scan_cubit_test will 'hang'
+    // Not sure why, it seems during testing this would close the mocked stream
+    // immediately so when adding devices through mock.sink.add they never reach
+    // the device_scan_cubit component
+    // TODO: figure out why test fails without this if
+    if (_discoverSubscription != null) {
+      await _discoverSubscription?.cancel();
+    }
+
+    _discovering = true;
+    _devices.clear();
+
+    _discoverSubscription = discoverStream.listen((newDevices) {
+      logger.finest('New devices discovered: $newDevices');
+      assert(_discovering);
+
+      // Note that there are major differences in how backends return discovered devices,
+      // f.e. FlutterBluePlus batches results itself while BluetoothLowEnergy will always
+      // return one device per listen callback.
+      // The _devices type [Set] makes sure sure we are not adding duplicate devices.
+      _devices.addAll(newDevices);
+
+      onDevices(_devices.toList());
+    }, onError: onDiscoveryError);
+
+    logger.fine('Starting discovery for devices with service: $serviceUuid');
+    await backendStart(serviceUuid);
+  }
+
+  /// Called when an error occurs during discovery
+  void onDiscoveryError(Object error) {
+    logger.severe('Starting device scan failed', error);
+    _discovering = false;
+  }
+
+  /// Stop discovering for new devices
+  Future<void> stop() async {
+    if (!_discovering) {
+      return;
+    }
+
+    logger.finer('Stopping discovery');
+    await _discoverSubscription?.cancel();
+    await backendStop();
+    _devices.clear();
+    _discovering = false;
+  }
+}

@@ -0,0 +1,57 @@
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_backend.dart';
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_discovery.dart';
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_low_energy/ble_manager.dart';
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_service.dart';
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_state.dart';
+import 'package:blood_pressure_app/features/bluetooth/backend/flutter_blue_plus/fbp_manager.dart';
+import 'package:blood_pressure_app/features/bluetooth/backend/mock/mock_manager.dart';
+import 'package:blood_pressure_app/logging.dart';
+
+/// Base class for a bluetooth manager
+abstract class BluetoothManager<BackendDevice, BackendUuid, BackendService, BackendCharacteristic> with TypeLogger {
+  /// Instantiate the correct [BluetoothManager] implementation.
+  static BluetoothManager create([BluetoothBackend? backend]) {
+    switch (backend) {
+      case BluetoothBackend.mock:
+        return MockBluetoothManager();
+      case BluetoothBackend.flutterBluePlus:
+        return FlutterBluePlusManager();
+      case BluetoothBackend.bluetoothLowEnergy:
+      default:
+        return BluetoothLowEnergyManager();
+    }
+  }
+
+  /// Trigger the device to request the user for bluetooth ermissions
+  ///
+  /// Returns null if no permissions were requested (ie because its not needed on a platform)
+  /// or true/false to indicate whether requesting permissions succeeded (not if it was granted)
+  Future<bool?> enable(); // TODO: use task specific plugin/native code
+
+  /// Last known adapter state
+  ///
+  /// For convenience [BluetoothAdapterStateParser] instances already track the last known state,
+  /// so that state only needs to be returned in a backend's manager implementation
+  BluetoothAdapterState get lastKnownAdapterState;
+
+  /// Getter for the state stream
+  Stream<BluetoothAdapterState> get stateStream;
+
+  /// Device discovery implementation
+  BluetoothDeviceDiscovery get discovery;
+
+  /// Convert a BackendDevice into a BluetoothDevice
+  BluetoothDevice createDevice(BackendDevice device);
+
+  /// Convert a BackendUuid into a BluetoothUuid
+  BluetoothUuid createUuid(BackendUuid uuid);
+
+  /// Create a BluetoothUuid from a String
+  BluetoothUuid createUuidFromString(String uuid);
+
+  /// Convert a BackendService into a BluetoothService
+  BluetoothService createService(BackendService service);
+
+  /// Convert a BackendCharacteristic into a BluetoothCharacteristic
+  BluetoothCharacteristic createCharacteristic(BackendCharacteristic characteristic);
+}

@@ -0,0 +1,136 @@
+import 'package:collection/collection.dart';
+
+/// Bluetooth Base UUID from Bluetooth Core Spec
+///
+/// The full 128-bit value of a 16-bit or 32-bit UUID may be computed by a simple arithmetic
+/// operation.
+/// 128_bit_value = 16_bit_value × 296 + Bluetooth_Base_UUID
+/// 128_bit_value = 32_bit_value × 296 + Bluetooth_Base_UUID
+const bluetoothBaseUuid = '00000000-0000-1000-8000-00805F9B34FB';
+
+/// Generic BluetoothUuid representation
+abstract class BluetoothUuid<BackendUuid> {
+  /// constructor
+  BluetoothUuid({ required this.uuid, required this.source }): assert(uuid.length == 36, 'Expected uuid to have a length of 36, got uuid=$uuid');
+
+  /// Create a BluetoothUuid from a string
+  BluetoothUuid.fromString(this.uuid):
+    assert(uuid.isNotEmpty, 'This static method is abstract'),
+    source = bluetoothBaseUuid as BackendUuid // satisfy linter
+    {
+      throw AssertionError('This static method is abstract');
+    }
+
+  /// 128-bit string representation of uuid
+  final String uuid;
+
+  /// The backend specific uuid
+  final BackendUuid source;
+
+  /// Whether this uuid is an official bluetooth core spec uuid
+  bool get isBluetoothUuid => uuid.toUpperCase().endsWith(bluetoothBaseUuid.substring(8));
+
+  @override
+  String toString() => uuid;
+
+  /// Returns the 16 bit value of the UUID if uuid is from bluetooth core spec, otherwise full id
+  ///
+  /// The 16-bit Attribute UUID replaces the x’s in the following:
+  ///   0000xxxx-0000-1000-8000-00805F9B34FB
+  String get shortId {
+    final uuid = toString();
+    assert(uuid.length == 36);
+
+    if (isBluetoothUuid) {
+      return '0x${uuid.substring(4, 8)}';
+    }
+
+    return uuid;
+  }
+
+  @override
+  bool operator == (Object other) {
+    if (other is BluetoothUuid) {
+      return toString() == other.toString();
+    }
+
+    if (other is BluetoothService) {
+      return toString() == other.uuid.toString();
+    }
+
+    if (other is BluetoothCharacteristic) {
+      return toString() == other.uuid.toString();
+    }
+
+    return false;
+  }
+
+  @override
+  int get hashCode => super.hashCode * 17;
+}
+
+/// Generic BluetoothService representation
+abstract class BluetoothService<BackendService, BC extends BluetoothCharacteristic> {
+  /// Initialize bluetooth service wrapper class
+  BluetoothService({ required this.uuid, required this.source });
+
+  /// UUID of the service
+  final BluetoothUuid uuid;
+  /// Backend source for the service
+  final BackendService source;
+
+  /// Get all characteristics for this service
+  List<BC> get characteristics;
+
+  /// Returns the characteristic with requested [uuid], returns null if
+  /// requested [uuid] was not found
+  Future<BC?> getCharacteristicByUuid(BluetoothUuid uuid) async => characteristics.firstWhereOrNull((service) => service.uuid == uuid);
+
+  @override
+  String toString() => 'BluetoothService{uuid: ${uuid.shortId}, source: ${source.runtimeType}}';
+
+  @override
+  bool operator ==(Object other) => (other is BluetoothService)
+    && toString() == other.toString();
+
+  @override
+  int get hashCode => super.hashCode * 17;
+}
+
+/// Characteristic representation
+abstract class BluetoothCharacteristic<BackendCharacteristic> {
+  /// Initialize bluetooth characteristic wrapper class
+  BluetoothCharacteristic({ required this.uuid, required this.source });
+
+  /// UUID of the characteristic
+  final BluetoothUuid uuid;
+  /// Backend source for the characteristic
+  final BackendCharacteristic source;
+
+  /// Whether the characteristic can be read
+  bool get canRead;
+
+  /// Whether the characteristic can be written to
+  bool get canWrite;
+
+  /// Whether the characteristic can be written to without a response
+  bool get canWriteWithoutResponse;
+
+  /// Whether the characteristic permits notifications for it's value, without a response to indicate receipt of the notification.
+  bool get canNotify;
+
+  /// Whether the characteristic permits notifications for it's value, with a response to indicate receipt of the notification
+  bool get canIndicate;
+
+  @override
+  String toString() => 'BluetoothCharacteristic{uuid: ${uuid.shortId}, source: ${source.runtimeType}, '
+    'canRead: $canRead, canWrite: $canWrite, canWriteWithoutResponse: $canWriteWithoutResponse, '
+    'canNotify: $canNotify, canIndicate: $canIndicate}';
+
+  @override
+  bool operator ==(Object other) => (other is BluetoothCharacteristic)
+    && toString() == other.toString();
+
+  @override
+  int get hashCode => super.hashCode * 17;
+}

@@ -0,0 +1,21 @@
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_utils.dart';
+
+/// Current state of bluetooth adapter/sensor
+enum BluetoothAdapterState {
+  /// Use of bluetooth adapter not authorized
+  unauthorized,
+  /// Use of bluetooth adapter not possible, f.e. because there is none
+  unfeasible,
+  /// Use of bluetooth adapter disabled
+  disabled,
+  /// Use of bluetooth adapter unknown
+  initial,
+  /// Bluetooth adapter ready to be used
+  ready;
+}
+
+/// Util to parse backend adapter states to [BluetoothAdapterState]
+abstract class BluetoothAdapterStateParser<BackendState> extends StreamDataParserCached<BackendState, BluetoothAdapterState> {
+  @override
+  BluetoothAdapterState get initialState => BluetoothAdapterState.initial;
+}

@@ -0,0 +1,117 @@
+import 'dart:async';
+
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_state.dart';
+import 'package:blood_pressure_app/logging.dart';
+
+/// Generic stream data parser base class
+abstract class StreamDataParser<StreamData, ParsedData> {
+  /// Method to be implemented by backend that converts the raw bluetooth adapter state to our BluetoothState
+  ParsedData parse(StreamData rawState);
+}
+
+/// Generic stream data parser base class that caches the last known state returned by the stream
+abstract class StreamDataParserCached<StreamData, ParsedData> extends StreamDataParser<StreamData, ParsedData> {
+  /// Initial state when it's unknown, f.e. when stream didn't return any data yet
+  ParsedData get initialState;
+  ParsedData? _lastKnownState;
+
+  /// The last known adapter state
+  ParsedData get lastKnownState => _lastKnownState ?? initialState;
+
+  /// Internal method to cache the last adapter state value, backends should only implement parse not this method
+  ParsedData parseAndCache(StreamData rawState) {
+    _lastKnownState = parse(rawState);
+    return lastKnownState;
+  }
+}
+
+/// Transforms the backend's bluetooth adapter state stream to emit [BluetoothAdapterState]'s
+///
+/// Can normally be used directly, backends should only inject a customized BluetoothStateParser
+class StreamDataParserTransformer<StreamData, ParsedData, SD extends StreamDataParser<StreamData, ParsedData>>
+  extends StreamDataTransformer<StreamData, ParsedData> {
+  /// Create a BluetoothAdapterStateStreamTransformer
+  ///
+  /// [stateParser] The BluetoothStateParser that provides the backend logic to convert BackendState to BluetoothAdapterState
+  StreamDataParserTransformer({ required SD stateParser, super.sync, super.cancelOnError }) {
+    _stateParser = stateParser;
+  }
+
+  late SD _stateParser;
+
+  @override
+  void onData(StreamData streamData) {
+    late ParsedData data;
+    if (_stateParser is StreamDataParserCached) {
+      data = (_stateParser as StreamDataParserCached).parseAndCache(streamData);
+    } else {
+      data = _stateParser.parse(streamData);
+    }
+
+    sendData(data);
+  }
+}
+
+
+/// Generic stream transformer util that should support cancelling & pausing etc
+///
+/// Implementations should only need to worry about transforming the data by overriding
+/// the onData method and sending the transformed data using sendData
+///
+/// TODO: move outside bluetooth logic
+abstract class StreamDataTransformer<S,T> with TypeLogger implements StreamTransformer<S,T> {
+  /// Create a BluetoothStreamTransformer
+  ///
+  /// - [sync] Passed to [StreamController]
+  /// - [cancelOnError] Passed to [Stream]
+  StreamDataTransformer({ bool sync = false, bool cancelOnError = false }) {
+    _cancelOnError = cancelOnError;
+
+    _controller = StreamController<T>(
+      onListen: _onListen,
+      onCancel: _onCancel,
+      onPause: () => _subscription?.pause(),
+      onResume: () => _subscription?.resume(),
+      sync: sync,
+    );
+  }
+
+  late StreamController<T> _controller;
+  StreamSubscription? _subscription;
+  Stream<S>? _stream;
+  bool _cancelOnError = false;
+
+  void _onListen() {
+    logger.finest('_onListen');
+    _subscription = _stream?.listen(
+      onData,
+      onError: _controller.addError,
+      onDone: _controller.close,
+      cancelOnError: _cancelOnError);
+  }
+
+  void _onCancel() {
+    logger.finest('_onCancel');
+    _subscription?.cancel();
+    _subscription = null;
+  }
+
+  /// Method that actually transforms the data being passed through this stream
+  void onData(S streamData);
+
+  /// Send data to the listening stream, should f.e. be called from within the
+  /// onData call to forward the transformed data
+  void sendData(T data) {
+    _controller.add(data);
+  }
+
+  @override
+  Stream<T> bind(Stream<S> stream) {
+    logger.finest('bind');
+    _stream = stream;
+    return _controller.stream;
+  }
+
+  @override
+  StreamTransformer<RS, RT> cast<RS, RT>() => StreamTransformer.castFrom(this);
+}

@@ -1,30 +1,49 @@
-import 'package:blood_pressure_app/logging.dart';
+import 'dart:typed_data';
 
-import 'ble_date_time.dart';
-import 'ble_measurement_status.dart';
-import 'decoding_util.dart';
+import 'package:blood_pressure_app/features/bluetooth/logic/characteristics/ble_date_time.dart';
+import 'package:blood_pressure_app/features/bluetooth/logic/characteristics/ble_measurement_status.dart';
+import 'package:blood_pressure_app/features/bluetooth/logic/characteristics/decoding_util.dart';
+import 'package:blood_pressure_app/logging.dart';
+import 'package:health_data_store/health_data_store.dart';
 
+/// Result of a single bp measurement as by ble spec.
+///
 /// https://developer.nordicsemi.com/nRF51_SDK/nRF51_SDK_v4.x.x/doc/html/structble__bps__meas__s.html
 /// https://github.com/NordicSemiconductor/Kotlin-BLE-Library/blob/6b565e59de21dfa53ef80ff8351ac4a4550e8d58/profile/src/main/java/no/nordicsemi/android/kotlin/ble/profile/bps/BloodPressureMeasurementParser.kt
 class BleMeasurementData {
+  /// Initialize result of a single bp measurement.
   BleMeasurementData({
     required this.systolic,
     required this.diastolic,
     required this.meanArterialPressure,
     required this.isMMHG,
-    required this.pulse,
-    required this.userID,
-    required this.status,
-    required this.timestamp,
+    this.pulse,
+    this.userID,
+    this.status,
+    this.timestamp,
   });
 
-  static BleMeasurementData? decode(List<int> data, int offset) {
+  /// Return BleMeasurementData as a BloodPressureRecord
+  BloodPressureRecord asBloodPressureRecord() =>
+    BloodPressureRecord(
+      time: timestamp ?? DateTime.now(),
+      sys: isMMHG
+        ? Pressure.mmHg(systolic.toInt())
+        : Pressure.kPa(systolic),
+      dia: isMMHG
+        ? Pressure.mmHg(diastolic.toInt())
+        : Pressure.kPa(diastolic),
+      pul: pulse?.toInt(),
+    );
+
+  /// Decode bytes read from the characteristic into a [BleMeasurementData]
+  static BleMeasurementData? decode(Uint8List data, int offset) {
     // https://github.com/NordicSemiconductor/Kotlin-BLE-Library/blob/6b565e59de21dfa53ef80ff8351ac4a4550e8d58/profile/src/main/java/no/nordicsemi/android/kotlin/ble/profile/bps/BloodPressureMeasurementParser.kt
 
     // Reading specific bits: `(byte & (1 << bitIdx))`
 
     if (data.length < 7) {
-      Log.trace('BleMeasurementData decodeMeasurement: Not enough data, $data has less than 7 bytes.');
+      log.warning('BleMeasurementData decodeMeasurement: Not enough data, $data has less than 7 bytes.');
       return null;
     }
 
@@ -45,7 +64,7 @@ class BleMeasurementData {
       + (userIdPresent ? 1 : 0)
       + (measurementStatusPresent ? 2 : 0)
     )) {
-      Log.trace("BleMeasurementData decodeMeasurement: Flags don't match, $data has less bytes than expected.");
+      log.warning("BleMeasurementData decodeMeasurement: Flags don't match, $data has less bytes than expected.");
       return null;
     }
 
@@ -57,7 +76,7 @@ class BleMeasurementData {
     offset += 2;
 
     if (systolic == null || diastolic == null || meanArterialPressure == null) {
-      Log.trace('BleMeasurementData decodeMeasurement: Unable to decode required values sys, dia, and meanArterialPressure, $data.');
+      log.warning('BleMeasurementData decodeMeasurement: Unable to decode required values sys, dia, and meanArterialPressure, $data.');
       return null;
     }
 
@@ -96,13 +115,21 @@ class BleMeasurementData {
     );
   }
 
+  /// Systolic pressure
   final double systolic;
+  /// Diatolic pressure
   final double diastolic;
+  /// Mean arterial pressure
   final double meanArterialPressure;
+  /// True if pressure values are in mmHg, False if in kPa
   final bool isMMHG; // mmhg or kpa
+  /// Pulse rate (of heart)
   final double? pulse;
+  /// User id
   final int? userID;
+  /// [BleMeasurementStatus] status
   final BleMeasurementStatus? status;
+  /// Timestamp of measurement
   final DateTime? timestamp;
 
   @override

@@ -1,11 +1,10 @@
 import 'dart:async';
 
+import 'package:blood_pressure_app/features/bluetooth/backend/bluetooth_backend.dart';
 import 'package:blood_pressure_app/features/bluetooth/logic/characteristics/ble_measurement_data.dart';
 import 'package:blood_pressure_app/logging.dart';
-import 'package:collection/collection.dart';
 import 'package:flutter/foundation.dart';
 import 'package:flutter_bloc/flutter_bloc.dart';
-import 'package:flutter_blue_plus/flutter_blue_plus.dart';
 
 part 'ble_read_state.dart';
 
@@ -25,162 +24,127 @@ part 'ble_read_state.dart';
 /// 3. If the searched characteristic is found read its value
 /// 4. If binary data is read decode it to object
 /// 5. Emit decoded object
-class BleReadCubit extends Cubit<BleReadState> {
+class BleReadCubit extends Cubit<BleReadState> with TypeLogger {
   /// Start reading a characteristic from a device.
   BleReadCubit(this._device, {
     required this.serviceUUID,
     required this.characteristicUUID,
   }) : super(BleReadInProgress())
   {
-    _subscription = _device.connectionState
-      .listen(_onConnectionStateChanged);
-    // timeout
+    takeMeasurement();
+
+    // start read timeout
     _timeoutTimer = Timer(const Duration(minutes: 2), () {
       if (state is BleReadInProgress) {
-        Log.trace('BleReadCubit timeout reached and still running');
-        emit(BleReadFailure());
+        logger.finer('BleReadCubit timeout reached and still running');
+        emit(BleReadFailure('Timed out after 2 minutes'));
       } else {
-        Log.trace('BleReadCubit timeout reached with state: $state, ${state is BleReadInProgress}');
+        logger.finer('BleReadCubit timeout reached with state: $state, ${state is BleReadInProgress}');
       }
     });
   }
 
-  /// UUID of the service to read.
-  final Guid serviceUUID;
-
-  /// UUID of the characteristic to read.
-  final Guid characteristicUUID;
-
   /// Bluetooth device to connect to.
   ///
-  /// Must have an active established connection and support the measurement
-  /// characteristic.
+  /// Must have an active established connection and support the measurement characteristic.
   final BluetoothDevice _device;
+
+  /// UUID of the service to read.
+  final String serviceUUID;
+
+  /// UUID of the characteristic to read.
+  final String characteristicUUID;
   
-  late final StreamSubscription<BluetoothConnectionState> _subscription;
   late final Timer _timeoutTimer;
-  StreamSubscription<List<int>>? _indicationListener;
 
-  @override
-  Future<void> close() async {
-    Log.trace('BleReadCubit close');
-    await _subscription.cancel();
-    _timeoutTimer.cancel();
+  int _retryCount = 0;
+  final int _maxRetries = 3;
 
-    if (_device.isConnected) {
-      try {
-        Log.trace('BleReadCubit close: Attempting disconnect from ${_device.advName}');
-        await _device.disconnect();
-        assert(_device.isDisconnected);
-      } catch (e) {
-        Log.err('unable to disconnect', [e, _device]);
+  /// Take a 'measurement', i.e. read the blood pressure values from the given characteristicUUID
+  /// TODO: make this generic by accepting a data decoder argument?
+  Future<void> takeMeasurement() async {
+    final success = await _device.connect(
+      onDisconnect: () {
+        if (_retryCount < _maxRetries) {
+          _retryCount++;
+          takeMeasurement();
+
+          logger.finer('BleReadCubit: retrying after device.onDisconnect called');
+          return true;
+        }
+
+        logger.finer('BleReadCubit: device.onDisconnect called');
+        emit(BleReadFailure('Device unexpectedly disconnected'));
+        return true;
+      },
+      onError: (Object err) => emit(BleReadFailure(err.toString()))
+    );
+    if (success) {
+      final uuidService = _device.manager.createUuidFromString(serviceUUID);
+      final service = await _device.getServiceByUuid(uuidService);
+      logger.finer('BleReadCubit: Found service: $service');
+      if (service == null) {
+        // TODO: add a BleReadUnsupported state
+        emit(BleReadFailure('Device does not provide the expected service with uuid $serviceUUID'));
+        return;
       }
-    }
 
-    await super.close();
-  }
+      final uuidCharacteristic = _device.manager.createUuidFromString(characteristicUUID);
+      final characteristic = await service.getCharacteristicByUuid(uuidCharacteristic);
+      logger.finer('BleReadCubit: Found characteristic: $characteristic');
+      if (characteristic == null) {
+        emit(BleReadFailure('Device does not provide the expected characteristic with uuid $characteristicUUID'));
+        return;
+      }
 
-  bool _ensureConnectionInProgress = false;
-  Future<void> _ensureConnection([int attemptCount = 0]) async {
-    Log.trace('BleReadCubit _ensureConnection');
-    if (_ensureConnectionInProgress) return;
-    _ensureConnectionInProgress = true;
-    
-    if (_device.isAutoConnectEnabled) {
-      Log.trace('BleReadCubit Waiting for auto connect...');
-      _ensureConnectionInProgress = false;
-      return;
-    }
-    
-    if (_device.isDisconnected) {
-      Log.trace('BleReadCubit _ensureConnection: Attempting to connect with ${_device.advName}');
-      try {
-        await _device.connect();
-      } on FlutterBluePlusException catch (e) {
-        Log.err('BleReadCubit _device.connect failed:', [_device, e]);
+      final List<Uint8List> data = [];
+      final success = await _device.getCharacteristicValue(characteristic, (Uint8List value, [_]) => data.add(value));
+
+      logger.finer('BleReadCubit(success: $success): Got data: $data');
+      if (!success) {
+        emit(BleReadFailure('Could not retrieve characteristic value'));
+        return;
       }
-      
-      if (_device.isDisconnected) {
-        Log.trace('BleReadCubit _ensureConnection: Device not connected');
-        _ensureConnectionInProgress = false;
-        if (attemptCount >= 5) {
-          emit(BleReadFailure());
+
+      final List<BleMeasurementData> measurements = [];
+
+      for (final item in data) {
+        final decodedData = BleMeasurementData.decode(item, 0);
+        if (decodedData == null) {
+          logger.severe('BleReadCubit decoding failed', item);
+          emit(BleReadFailure('Could not decode data'));
           return;
-        } else {
-          return _ensureConnection(attemptCount + 1);
         }
+
+        measurements.add(decodedData);
+      }
+
+      if (measurements.length > 1) {
+        logger.finer('BleReadMultiple decoded ${measurements.length} measurements');
+        emit(BleReadMultiple(measurements));
       } else {
-        Log.trace('BleReadCubit Connection successful');
+        logger.finer('BleReadCubit decoded: ${measurements.first}');
+        emit(BleReadSuccess(measurements.first));
       }
     }
-    assert(_device.isConnected);
-    _ensureConnectionInProgress = false;
   }
 
-  Future<void> _onConnectionStateChanged(BluetoothConnectionState state) async {
-    Log.trace('BleReadCubit _onConnectionStateChanged: $state');
-    if (super.state is BleReadSuccess) return;
-    if (state == BluetoothConnectionState.disconnected) {
-      Log.trace('BleReadCubit _onConnectionStateChanged disconnected: '
-        '${_device.disconnectReason} Attempting reconnect');
-      await _ensureConnection();
-      return;
-    }
-    assert(state == BluetoothConnectionState.connected, 'state should be '
-      'connected as connecting and disconnecting are not streamed by android');
-    assert(_device.isConnected);
-
-    // Query actual services supported by the device. While they must be
-    // rediscovered when a disconnect happens, this object is also recreated.
-    late final List<BluetoothService> allServices;
-    try {
-      allServices = await _device.discoverServices();
-      Log.trace('BleReadCubit allServices: $allServices');
-    } catch (e) {
-      Log.err('service discovery', [_device, e]);
-      emit(BleReadFailure());
-      return;
-    }
-
-    // [Guid.str] trims standard parts from the uuid. 0x1810 is the blood
-    // pressure uuid. https://developer.nordicsemi.com/nRF51_SDK/nRF51_SDK_v4.x.x/doc/html/group___u_u_i_d___s_e_r_v_i_c_e_s.html
-    final BluetoothService? service = allServices
-      .firstWhereOrNull((BluetoothService s) => s.uuid == serviceUUID);
-    if (service == null) {
-      Log.err('unsupported service', [_device, allServices]);
-      emit(BleReadFailure());
-      return;
-    }
+  @override
+  Future<void> close() async {
+    logger.finer('BleReadCubit close');
+    _timeoutTimer.cancel();
 
-    // https://developer.nordicsemi.com/nRF51_SDK/nRF51_SDK_v4.x.x/doc/html/group___u_u_i_d___c_h_a_r_a_c_t_e_r_i_s_t_i_c_s.html#ga95fc99c7a99cf9d991c81027e4866936
-    final List<BluetoothCharacteristic> allCharacteristics = service.characteristics;
-    Log.trace('BleReadCubit allCharacteristics: $allCharacteristics');
-    final BluetoothCharacteristic? characteristic = allCharacteristics
-      .firstWhereOrNull((c) => c.uuid == characteristicUUID,);
-    if (characteristic == null) {
-      Log.err('no characteristic', [_device, allServices, allCharacteristics]);
-      emit(BleReadFailure());
-      return;
+    if (_device.isConnected) {
+      await _device.disconnect();
     }
 
-    // This characteristic only supports indication so we need to listen to values.
-    await _indicationListener?.cancel();
-    _indicationListener = characteristic
-      .onValueReceived.listen((rawData) {
-        Log.trace('BleReadCubit data received: $rawData');
-        final decodedData = BleMeasurementData.decode(rawData, 0);
-        if (decodedData == null) {
-          Log.err('BleReadCubit decoding failed', [ rawData ]);
-          emit(BleReadFailure());
-        } else {
-          Log.trace('BleReadCubit decoded: $decodedData');
-          emit(BleReadSuccess(decodedData));
-        }
-        _indicationListener?.cancel();
-        _indicationListener = null;
-      });
+    await super.close();
+  }
 
-    final bool indicationsSet = await characteristic.setNotifyValue(true);
-    Log.trace('BleReadCubit indicationsSet: $indicationsSet');
+  /// Called after reading from a device returned multiple measurements and the
+  /// user chose which measurement they wanted to add.
+  Future<void> useMeasurement(BleMeasurementData data) async {
+    assert(state is! BleReadSuccess);
+    emit(BleReadSuccess(data));
   }
 }