Bluetooth Device Pairing Infrastructure and Health Measurements

Package.swift

@@ -13,9 +13,9 @@ import PackageDescription
 
 
 #if swift(<6)
-let swiftConcurrency: SwiftSetting = .enableExperimentalFeature("SwiftConcurrency")
+let swiftConcurrency: SwiftSetting = .enableExperimentalFeature("StrictConcurrency")
 #else
-let swiftConcurrency: SwiftSetting = .enableUpcomingFeature("SwiftConcurrency")
+let swiftConcurrency: SwiftSetting = .enableUpcomingFeature("StrictConcurrency")
 #endif
 
 
@@ -37,7 +37,7 @@ let package = Package(
         .package(url: "https://github.com/StanfordSpezi/Spezi.git", from: "1.4.0"),
         .package(url: "https://github.com/StanfordSpezi/SpeziViews.git", from: "1.5.0"),
         .package(url: "https://github.com/StanfordSpezi/SpeziBluetooth", from: "2.0.0"),
-        .package(url: "https://github.com/StanfordSpezi/SpeziNetworking", branch: "feature/raw-representable"),
+        .package(url: "https://github.com/StanfordSpezi/SpeziNetworking", from: "2.1.1"),
         .package(url: "https://github.com/StanfordBDHG/XCTestExtensions.git", .upToNextMinor(from: "0.4.11"))
     ] + swiftLintPackage(),
     targets: [

Sources/SpeziDevices/Devices/GenericDevice.swift

@@ -14,7 +14,7 @@ import SpeziBluetoothServices
 /// A generic Bluetooth device.
 ///
 /// A generic Bluetooth device that provides access to basic device information.
-public protocol GenericDevice: BluetoothDevice, GenericBluetoothPeripheral, Identifiable {
+public protocol GenericDevice: BluetoothDevice, GenericBluetoothPeripheral, Identifiable, Sendable {
     /// An icon that is used to visually present the device to the user.
     static var icon: ImageReference? { get }
 

Sources/SpeziDevices/HealthMeasurements.swift

@@ -6,8 +6,7 @@
 // SPDX-License-Identifier: MIT
 //
 
-import OrderedCollections
-import HealthKit
+@preconcurrency import HealthKit
 import OSLog
 import Spezi
 import SpeziBluetooth
@@ -84,7 +83,7 @@ import SwiftUI
 /// - ``pendingMeasurements``
 /// - ``discardMeasurement(_:)``
 @Observable
-public class HealthMeasurements {
+public final class HealthMeasurements: @unchecked Sendable {
     private let logger = Logger(subsystem: "ENGAGEHF", category: "HealthMeasurements")
 
     /// Determine if UI components displaying pending measurements should be displayed.
@@ -185,7 +184,7 @@ public class HealthMeasurements {
         }
 
         if let modelContainer {
-            let storeMeasurement = StoredMeasurement(associatedMeasurement: id, measurement: .init(from: measurement), device: source)
+            let storeMeasurement = StoredMeasurement(associatedMeasurement: id, measurement: measurement, device: source)
             modelContainer.mainContext.insert(storeMeasurement)
         } else {
             logger.warning("Measurement \(id) could not be persisted on disk due to missing ModelContainer!")
@@ -273,8 +272,10 @@ extension HealthMeasurements {
             return
         }
 
-        var fetchAll = FetchDescriptor<StoredMeasurement>()
-        // TODO: fetchAll.includePendingChanges = true
+        var fetchAll = FetchDescriptor<StoredMeasurement>(
+            sortBy: [SortDescriptor(\.storageDate)]
+        )
+        fetchAll.includePendingChanges = true
 
         let context = modelContainer.mainContext
         let storedMeasurements: [StoredMeasurement]
@@ -285,16 +286,8 @@ extension HealthMeasurements {
             return
         }
 
-        print("hasChanges1: \(context.hasChanges == true)")
-        try? context.save()
-
         for storedMeasurement in storedMeasurements {
-            print("Looking at \(storedMeasurement)")
-            print("checking id \(storedMeasurement.associatedMeasurement)")
-            print("Otherwise asdf: \(storedMeasurement.device)")
-            print("Sample: \(storedMeasurement.measurement)")
-
-            guard let id = loadMeasurement(storedMeasurement.measurement.measurement, form: storedMeasurement.device) else {
+            guard let id = loadMeasurement(storedMeasurement.healthMeasurement, form: storedMeasurement.device) else {
                 context.delete(storedMeasurement)
                 continue
             }
@@ -303,10 +296,15 @@ extension HealthMeasurements {
             // However, when we redo the conversion, the identifier changes.
             // Therefore, we need to make sure to update all associated ids after loading.
             storedMeasurement.associatedMeasurement = id
-            print("hasChanges1: \(context.hasChanges == true)")
-            try? context.save()
         }
-        // TODO: save all?
+
+        if context.hasChanges {
+            do {
+                try context.save()
+            } catch {
+                logger.error("Failed to save updated measurement id associations: \(error)")
+            }
+        }
     }
 }
 

Sources/SpeziDevices/Measurements/BluetoothHealthMeasurement.swift

@@ -17,191 +17,6 @@ public enum BluetoothHealthMeasurement {
     case weight(WeightMeasurement, WeightScaleFeature)
     /// A blood pressure measurement and its context.
     case bloodPressure(BloodPressureMeasurement, BloodPressureFeature)
-
-    private var type: SwiftDataBluetoothHealthMeasurementWorkaroundContainer.MeasurementType {
-        switch self {
-        case .weight:
-            .weight
-        case .bloodPressure:
-            .bloodPressure
-        }
-    }
-}
-
-import SpeziNumerics
-import SpeziBluetoothServices
-private struct BloodPressureMeasurementCopy: Codable {
-    /// The systolic value of the blood pressure measurement.
-    ///
-    /// The unit of this value is defined by the ``unit-swift.property`` property.
-    public let systolicValue: MedFloat16
-    /// The diastolic value of the blood pressure measurement.
-    ///
-    /// The unit of this value is defined by the ``unit-swift.property`` property.
-    public let diastolicValue: MedFloat16
-    /// The Mean Arterial Pressure (MAP)
-    ///
-    /// The unit of this value is defined by the ``unit-swift.property`` property.
-    public let meanArterialPressure: MedFloat16
-    /// The unit of the blood pressure measurement values.
-    ///
-    /// This property defines the unit of the ``systolicValue``, ``diastolicValue`` and ``meanArterialPressure`` properties.
-    public let unit: String
-
-    /// The timestamp of the measurement.
-    public let timeStamp: DateTime?
-
-    /// The pulse rate in beats per minute.
-    public let pulseRate: MedFloat16?
-
-    /// The associated user of the blood pressure measurement.
-    ///
-    /// This value can be used to differentiate users if the device supports multiple users.
-    /// - Note: The special value of `0xFF` (`UInt8.max`) is used to represent an unknown user.
-    ///
-    /// The values are left to the implementation but should be unique per device.
-    public let userId: UInt8?
-
-    /// Additional metadata information of a blood pressure measurement.
-    public let measurementStatus: UInt16?
-
-
-    var measurement: BloodPressureMeasurement {
-        .init(
-            systolic: systolicValue,
-            diastolic: diastolicValue,
-            meanArterialPressure: meanArterialPressure,
-            unit: .init(rawValue: unit) ?? .mmHg,
-            timeStamp: timeStamp,
-            pulseRate: pulseRate,
-            userId: userId,
-            measurementStatus: measurementStatus.map { .init(rawValue: $0) }
-        )
-    }
-
-    init(from measurement: BloodPressureMeasurement) {
-        self.systolicValue = measurement.systolicValue
-        self.diastolicValue = measurement.diastolicValue
-        self.meanArterialPressure = measurement.meanArterialPressure
-        self.unit = measurement.unit.rawValue
-        self.timeStamp = measurement.timeStamp
-        self.pulseRate = measurement.pulseRate
-        self.userId = measurement.userId
-        self.measurementStatus = measurement.measurementStatus?.rawValue
-    }
-
-    func encode(to encoder: any Encoder) throws {
-        var container = encoder.container(keyedBy: CodingKeys.self)
-        try container.encode(self.systolicValue, forKey: .systolicValue)
-        try container.encode(self.diastolicValue, forKey: .diastolicValue)
-        try container.encode(self.meanArterialPressure, forKey: .meanArterialPressure)
-        try container.encode(self.unit, forKey: .unit)
-        try container.encodeIfPresent(self.timeStamp, forKey: .timeStamp)
-        try container.encodeIfPresent(self.pulseRate, forKey: .pulseRate)
-        try container.encodeIfPresent(self.userId, forKey: .userId)
-        try container.encodeIfPresent(self.measurementStatus, forKey: .measurementStatus)
-    }
-
-    enum CodingKeys: CodingKey {
-        case systolicValue
-        case diastolicValue
-        case meanArterialPressure
-        case unit
-        case timeStamp
-        case pulseRate
-        case userId
-        case measurementStatus
-    }
-
-    init(from decoder: any Decoder) throws {
-        let container = try decoder.container(keyedBy: CodingKeys.self)
-        self.systolicValue = try container.decode(MedFloat16.self, forKey: .systolicValue)
-        self.diastolicValue = try container.decode(MedFloat16.self, forKey: .diastolicValue)
-        self.meanArterialPressure = try container.decode(MedFloat16.self, forKey: .meanArterialPressure)
-        self.unit = try container.decode(String.self, forKey: .unit)
-        self.timeStamp = try container.decodeIfPresent(DateTime.self, forKey: .timeStamp)
-        self.pulseRate = try container.decodeIfPresent(MedFloat16.self, forKey: .pulseRate)
-        self.userId = try container.decodeIfPresent(UInt8.self, forKey: .userId)
-        self.measurementStatus = try container.decodeIfPresent(UInt16.self, forKey: .measurementStatus)
-    }
-}
-
-struct SwiftDataBluetoothHealthMeasurementWorkaroundContainer: Codable {
-    enum MeasurementType: String, Codable {
-        case weight
-        case bloodPressure
-    }
-
-    private let type: MeasurementType
-
-    private var bloodPressureMeasurement: BloodPressureMeasurementCopy?
-    private var bloodPressureFeatures: BloodPressureFeature.RawValue?
-
-    private var weightMeasurement: WeightMeasurement?
-    private var weightScaleFeatures: WeightScaleFeature.RawValue?
-
-    var measurement: BluetoothHealthMeasurement {
-        switch type {
-        case .bloodPressure:
-            guard let bloodPressureMeasurement, let bloodPressureFeatures else {
-                preconditionFailure("Inconsistent type")
-            }
-            return .bloodPressure(bloodPressureMeasurement.measurement, .init(rawValue: bloodPressureFeatures))
-        case .weight:
-            guard let weightMeasurement, let weightScaleFeatures else {
-                preconditionFailure("Inconsistent type")
-            }
-            return .weight(weightMeasurement, .init(rawValue: weightScaleFeatures))
-        }
-    }
-
-    init(from measurement: BluetoothHealthMeasurement) {
-        switch measurement {
-        case let .bloodPressure(measurement, feature):
-            type = .bloodPressure
-            bloodPressureMeasurement = .init(from: measurement)
-            bloodPressureFeatures = feature.rawValue
-            weightMeasurement = nil
-            weightScaleFeatures = nil
-        case let .weight(measurement, features):
-            type = .weight
-            bloodPressureMeasurement = nil
-            bloodPressureFeatures = nil
-            // bloodPressureMeasurement2 = BloodPressureMeasurementCopy(from: .mock())
-            weightMeasurement = measurement
-            weightScaleFeatures = features.rawValue
-        }
-    }
-
-    func encode(to encoder: any Encoder) throws {
-        var container = encoder.container(keyedBy: CodingKeys.self)
-        try container.encode(self.type, forKey: .type)
-        try container.encodeIfPresent(self.bloodPressureMeasurement, forKey: .bloodPressureMeasurement)
-        try container.encodeIfPresent(self.bloodPressureFeatures, forKey: .bloodPressureFeatures)
-        try container.encodeIfPresent(self.weightMeasurement, forKey: .weightMeasurement)
-        try container.encodeIfPresent(self.weightScaleFeatures, forKey: .weightScaleFeatures)
-    }
-
-    enum CodingKeys: CodingKey {
-        case type
-        case bloodPressureMeasurement
-        case bloodPressureFeatures
-        case weightMeasurement
-        case weightScaleFeatures
-    }
-
-    init(from decoder: any Decoder) throws {
-        let container = try decoder.container(keyedBy: CodingKeys.self)
-        self.type = try container.decode(SwiftDataBluetoothHealthMeasurementWorkaroundContainer.MeasurementType.self, forKey: .type)
-        switch type {
-        case .bloodPressure:
-            self.bloodPressureMeasurement = try container.decodeIfPresent(BloodPressureMeasurementCopy.self, forKey: .bloodPressureMeasurement)
-            self.bloodPressureFeatures = try container.decodeIfPresent(BloodPressureFeature.RawValue.self, forKey: .bloodPressureFeatures)
-        case .weight:
-            self.weightMeasurement = try container.decodeIfPresent(WeightMeasurement.self, forKey: .weightMeasurement)
-            self.weightScaleFeatures = try container.decodeIfPresent(WeightScaleFeature.RawValue.self, forKey: .weightScaleFeatures)
-        }
-    }
 }
 
 
@@ -216,48 +31,38 @@ extension BluetoothHealthMeasurement: Codable {
 
     private enum CodingKeys: String, CodingKey {
         case type
-        case bloodPressure
-        case bloodPressureFeatures
-
-        case weight
-        case weightScaleFeatures
+        case measurement
+        case features
     }
 
     public init(from decoder: any Decoder) throws {
-        do {
-            print("Decoding \(Self.self)")
-            let container = try decoder.container(keyedBy: CodingKeys.self)
+        let container = try decoder.container(keyedBy: CodingKeys.self)
 
-            let type = try container.decode(MeasurementType.self, forKey: .type)
-            switch type {
-            case .weight:
-                let measurement = try container.decode(WeightMeasurement.self, forKey: .bloodPressure)
-                let features = try container.decode(WeightScaleFeature.self, forKey: .bloodPressureFeatures)
-                self = .weight(measurement, features)
-            case .bloodPressure:
-                let measurement = try container.decode(BloodPressureMeasurement.self, forKey: .weight)
-                let features = try container.decode(BloodPressureFeature.self, forKey: .weightScaleFeatures)
-                self = .bloodPressure(measurement, features)
-            }
-        } catch {
-            print("FAILED TO DECODE: \(error)")
-            throw error
+        let type = try container.decode(MeasurementType.self, forKey: .type)
+        switch type {
+        case .weight:
+            let measurement = try container.decode(WeightMeasurement.self, forKey: .measurement)
+            let features = try container.decode(WeightScaleFeature.self, forKey: .features)
+            self = .weight(measurement, features)
+        case .bloodPressure:
+            let measurement = try container.decode(BloodPressureMeasurement.self, forKey: .measurement)
+            let features = try container.decode(BloodPressureFeature.self, forKey: .features)
+            self = .bloodPressure(measurement, features)
         }
     }
 
     public func encode(to encoder: any Encoder) throws {
-        print("encoding \(Self.self)")
         var container = encoder.container(keyedBy: CodingKeys.self)
 
         switch self {
         case let .weight(measurement, feature):
             try container.encode(MeasurementType.weight, forKey: .type)
-            try container.encode(measurement, forKey: .bloodPressure)
-            try container.encode(feature, forKey: .bloodPressureFeatures)
+            try container.encode(measurement, forKey: .measurement)
+            try container.encode(feature, forKey: .features)
         case let .bloodPressure(measurement, feature):
             try container.encode(MeasurementType.bloodPressure, forKey: .type)
-            try container.encode(measurement, forKey: .weight)
-            try container.encode(feature, forKey: .weightScaleFeatures)
+            try container.encode(measurement, forKey: .measurement)
+            try container.encode(feature, forKey: .features)
         }
     }
 }