Query Property Wrappers, HealthChart, and Other Refactoring

Package.swift

@@ -22,22 +22,28 @@ let package = Package(
         .library(name: "SpeziHealthKit", targets: ["SpeziHealthKit"])
     ],
     dependencies: [
-        .package(url: "https://github.com/StanfordSpezi/Spezi", from: "1.8.0")
+        .package(path: "../Spezi"),
+        .package(path: "../SpeziFoundation"),
+        .package(url: "https://github.com/pointfreeco/swift-snapshot-testing", from: "1.17.7")
     ] + swiftLintPackage(),
     targets: [
         .target(
             name: "SpeziHealthKit",
             dependencies: [
-                .product(name: "Spezi", package: "Spezi")
+                .product(name: "Spezi", package: "Spezi"),
+                .product(name: "SpeziFoundation", package: "SpeziFoundation")
             ],
+            swiftSettings: [.enableUpcomingFeature("ExistentialAny")],
             plugins: [] + swiftLintPlugin()
         ),
         .testTarget(
             name: "SpeziHealthKitTests",
             dependencies: [
                 .product(name: "XCTSpezi", package: "Spezi"),
-                .target(name: "SpeziHealthKit")
+                .target(name: "SpeziHealthKit"),
+                .product(name: "SnapshotTesting", package: "swift-snapshot-testing")
             ],
+            swiftSettings: [.enableUpcomingFeature("ExistentialAny")],
             plugins: [] + swiftLintPlugin()
         )
     ]

Sources/SpeziHealthKit/CollectSample/CollectSample.swift

@@ -10,11 +10,14 @@ import HealthKit
 import Spezi
 
 
-/// Collects a specified `HKSampleType`  in the ``HealthKit`` module.
+/// Collects a specified ``HealthKitSampleType``  via the ``HealthKit`` module.
 ///
-/// This structure define what and how the ``HealthKit`` samples are collected. By default, all samples of the provided `HKSampleType` will be collected. The collection starts on calling ``HealthKit/triggerDataSourceCollection()`` if you configure the `deliverySetting` as    ``HealthKitDeliverySetting/manual(safeAnchor:)`` or automatic once the application is launched when you configure anything else than manual, i.e.  ``HealthKitDeliverySetting/anchorQuery(_:saveAnchor:)`` or ``HealthKitDeliverySetting/background(_:saveAnchor:)``.
+/// This structure define what and how the ``HealthKit`` samples are collected. By default, all samples of the provided ``HealthKitSampleType`` will be collected.
+/// The collection starts on calling ``HealthKit/triggerDataSourceCollection()`` if you configure the `deliverySetting` as    ``HealthKitDeliverySetting/manual(saveAnchor:)`` or automatic once the application is launched when you configure anything else than manual, i.e.  ``HealthKitDeliverySetting/anchorQuery(_:saveAnchor:)`` or ``HealthKitDeliverySetting/background(_:saveAnchor:)``.
 ///
-/// Your can filter the HealthKit samples to collect by specifying the `predicate`. For example, you can define an  `NSPredicate` to only collect the data collected at a time within the given start and end date. Below is an example to create a `NSPredicate` restricting the data collected in the previous month.
+/// Your can filter the HealthKit samples to collect via an `NSPredicate`.
+/// For example, you can define a predicate to only collect the data collected at a time within the given start and end date.
+/// Below is an example to create a `NSPredicate` restricting the data collected in the previous month.
 /// ```swift
 /// private var predicateOneMonth: NSPredicate {
 ///     // Define the start and end time for the predicate. In this example,
@@ -38,39 +41,55 @@ import Spezi
 ///
 /// ```swift
 /// CollectSample(
-///     HKQuantityType(.stepCount),
+///     .stepCount,
 ///     predicate: predicateOneMonth,
 ///     deliverySetting: .background(.automatic)
 /// )
 /// ```
-public struct CollectSample: HealthKitDataSourceDescription {
-    private let collectSamples: CollectSamples
+public struct CollectSample: HealthKitConfigurationComponent {
+    private let sampleType: HKSampleType
+    private let predicate: NSPredicate?
+    private let deliverySetting: HealthKitDeliverySetting
 
-
-    public var sampleTypes: Set<HKSampleType> {
-        collectSamples.sampleTypes
+    public var dataAccessRequirements: HealthKitDataAccessRequirements {
+        .init(read: [sampleType])
     }
 
 
     /// - Parameters:
-    ///   - sampleType: The `HKSampleType` that should be collected
+    ///   - sampleType: The ``HealthKitSampleType`` that should be collected
     ///   - predicate: A custom predicate that should be passed to the HealthKit query.
     ///                The default predicate collects all samples that have been collected from the first time that the user
     ///                provided the application authorization to collect the samples.
     ///   - deliverySetting: The ``HealthKitDeliverySetting`` that should be used to collect the sample type. `.manual` is the default argument used.
-    public init<S: HKSampleType>(
-        _ sampleType: S,
+    public init(
+        _ sampleType: HealthKitSampleType<some Any>,
+        predicate: NSPredicate? = nil,
+        delivery: HealthKitDeliverySetting = .manual() // TODO Question @Paul : why does it default to manual?
+    ) {
+        self.sampleType = sampleType.hkSampleType
+        self.predicate = predicate
+        self.deliverySetting = delivery
+    }
+
+    @available(*, deprecated, renamed: "init(_:predicate:delivery:)")
+    public init(
+        _ sampleType: HealthKitSampleType<some Any>,
         predicate: NSPredicate? = nil,
         deliverySetting: HealthKitDeliverySetting = .manual()
     ) {
-        self.collectSamples = CollectSamples([sampleType], predicate: predicate, deliverySetting: deliverySetting)
+        self.init(sampleType, predicate: predicate, delivery: deliverySetting)
     }
 
 
-    public func dataSources(
-        healthStore: HKHealthStore,
-        standard: any HealthKitConstraint
-    ) -> [any HealthKitDataSource] {
-        collectSamples.dataSources(healthStore: healthStore, standard: standard)
+    public func configure(for healthKit: HealthKit, on standard: any HealthKitConstraint) async {
+        let dataSource = HealthKitSampleDataSource(
+            healthKit: healthKit,
+            standard: standard,
+            sampleType: sampleType,
+            predicate: predicate,
+            deliverySetting: deliverySetting
+        )
+        await healthKit.addBackgroundHealthDataSource(dataSource)
     }
 }

Sources/SpeziHealthKit/HealthKitDataSource/HealthKitDataSource.swift → Sources/SpeziHealthKit/CollectSample/HealthKitDataSource.swift

@@ -13,32 +13,22 @@ import SwiftUI
 
 /// Requirement for every HealthKit Data Source.
 public protocol HealthKitDataSource {
+    /// The data source's sample type
+    var sampleType: HKSampleType { get }
+
+    /// Whether the data source is currently active.
+    @MainActor
+    var isActive: Bool { get }
+
     /// Called after the used was asked for authorization.
     @MainActor
     func askedForAuthorization() async
-    /// Called to trigger the manual data collection.
-    @MainActor
-    func triggerManualDataSourceCollection() async
+
     /// Called to start the automatic data collection.
     @MainActor
     func startAutomaticDataCollection() async
-}
-
-
-extension HealthKitDataSource {
-    func askedForAuthorization(for sampleType: HKSampleType) -> Bool {
-        HealthKit.didAskForAuthorization(for: sampleType)
-    }
-}
-
-
-extension UserDefaults {
-    var alreadyRequestedSampleTypes: Set<String> {
-        get {
-            Set(stringArray(forKey: UserDefaults.Keys.healthKitRequestedSampleTypes) ?? [])
-        }
-        set {
-            set(Array(newValue), forKey: UserDefaults.Keys.healthKitRequestedSampleTypes)
-        }
-    }
+
+    /// Called to trigger the manual data collection.
+    @MainActor
+    func triggerManualDataSourceCollection() async
 }

Sources/SpeziHealthKit/CollectSample/HealthKitSampleDataSource.swift

@@ -13,29 +13,33 @@ import SwiftUI
 
 
 final class HealthKitSampleDataSource: HealthKitDataSource {
-    let healthStore: HKHealthStore
-    let standard: any HealthKitConstraint
+    // This needs to be unowned since the HealthKit module will establish a strong reference to the data source.
+    private unowned let healthKit: HealthKit
+    private let standard: any HealthKitConstraint
 
     let sampleType: HKSampleType
-    let predicate: NSPredicate?
-    let deliverySetting: HealthKitDeliverySetting
-    @MainActor var active = false
-
+    private let predicate: NSPredicate?
+    private let deliverySetting: HealthKitDeliverySetting
+    @MainActor private(set) var isActive = false
+    
     @MainActor private lazy var anchorUserDefaultsKey = UserDefaults.Keys.healthKitAnchorPrefix.appending(sampleType.identifier)
     @MainActor private lazy var anchor: HKQueryAnchor? = loadAnchor() {
         didSet {
             saveAnchor()
         }
     }
+
+    private var healthStore: HKHealthStore { healthKit.healthStore }
+
 
     required init(
-        healthStore: HKHealthStore,
+        healthKit: HealthKit,
         standard: any HealthKitConstraint,
         sampleType: HKSampleType,
-        predicate: NSPredicate? = nil,  // swiftlint:disable:this function_default_parameter_at_end
+        predicate: NSPredicate? = nil, // swiftlint:disable:this function_default_parameter_at_end
         deliverySetting: HealthKitDeliverySetting
     ) {
-        self.healthStore = healthStore
+        self.healthKit = healthKit
         self.standard = standard
         self.sampleType = sampleType
         self.deliverySetting = deliverySetting
@@ -61,62 +65,55 @@ final class HealthKitSampleDataSource: HealthKitDataSource {
             components.setValue(0, for: .second)
             components.setValue(0, for: .nanosecond)
             let defaultQueryDate = components.date ?? .now
-
             UserDefaults.standard.set(defaultQueryDate, forKey: defaultPredicateDateUserDefaultsKey)
-
             return defaultQueryDate
         }
         return date
     }
 
 
     func askedForAuthorization() async {
-        guard askedForAuthorization(for: sampleType) && !deliverySetting.isManual && !active else {
+        guard await healthKit.askedForAuthorization(toRead: sampleType) && !deliverySetting.isManual && !isActive else {
             return
         }
-
         await triggerManualDataSourceCollection()
     }
-
+
+
     func startAutomaticDataCollection() async {
-        guard askedForAuthorization(for: sampleType) else {
+        guard await healthKit.askedForAuthorization(toRead: sampleType) else {
             return
         }
-
         switch deliverySetting {
-        case let .anchorQuery(startSetting, _) where startSetting == .automatic,
-            let .background(startSetting, _) where startSetting == .automatic:
+        case .anchorQuery(.automatic, _), .background(.automatic, _):
             await triggerManualDataSourceCollection()
         default:
             break
         }
     }
 
     func triggerManualDataSourceCollection() async {
-        guard !active else {
+        guard !isActive else {
             return
         }
-
         do {
             switch deliverySetting {
             case .manual:
                 try await anchoredSingleObjectQuery()
             case .anchorQuery:
-                active = true
+                isActive = true
                 try await anchoredContinuousObjectQuery()
             case .background:
-                active = true
+                isActive = true
                 try await healthStore.startBackgroundDelivery(for: [sampleType]) { result in
                     guard case let .success((sampleTypes, completionHandler)) = result else {
                         return
                     }
-
                     guard sampleTypes.contains(self.sampleType) else {
                         Logger.healthKit.warning("Received Observation query types (\(sampleTypes)) are not corresponding to the CollectSample type \(self.sampleType)")
                         completionHandler()
                         return
                     }
-
                     do {
                         try await self.anchoredSingleObjectQuery()
                         Logger.healthKit.debug("Successfully processed background update for \(self.sampleType)")
@@ -145,14 +142,12 @@ final class HealthKitSampleDataSource: HealthKitDataSource {
         self.anchor = resultsAnchor
     }
 
+
     @MainActor
     private func anchoredContinuousObjectQuery() async throws {
-        try await healthStore.requestAuthorization(toShare: [], read: [sampleType])
-
+        print("ANCHOR", anchor)
         let anchorDescriptor = healthStore.anchorDescriptor(sampleType: sampleType, predicate: predicate, anchor: anchor)
-
         let updateQueue = anchorDescriptor.results(for: healthStore)
-
         Task {
             for try await results in updateQueue {
                 for deletedObject in results.deletedObjects {
@@ -162,31 +157,32 @@ final class HealthKitSampleDataSource: HealthKitDataSource {
                 for addedSample in results.addedSamples {
                     await standard.add(sample: addedSample)
                 }
+                print("NEW ANCHOR", results.newAnchor)
                 self.anchor = results.newAnchor
             }
         }
     }
 
+
     @MainActor
     private func saveAnchor() {
         if deliverySetting.saveAnchor {
             guard let anchor,
                   let data = try? NSKeyedArchiver.archivedData(withRootObject: anchor, requiringSecureCoding: true) else {
                 return
             }
-
             UserDefaults.standard.set(data, forKey: anchorUserDefaultsKey)
         }
     }
 
+
     @MainActor
     private func loadAnchor() -> HKQueryAnchor? {
         guard deliverySetting.saveAnchor,
               let userDefaultsData = UserDefaults.standard.data(forKey: anchorUserDefaultsKey),
               let loadedAnchor = try? NSKeyedUnarchiver.unarchivedObject(ofClass: HKQueryAnchor.self, from: userDefaultsData) else {
             return nil
         }
-
         return loadedAnchor
     }
 }