Revisions for async/await

PAWS/ECGRecordings/ECGRecording.swift

@@ -8,13 +8,12 @@
 
 import HealthKit
 import SwiftUI
-import Foundation
 
 
 struct ECGRecording: View {
     let hkElectrocardiogram: HKElectrocardiogram
     @State var symptoms: HKElectrocardiogram.Symptoms = [:]
-    @State var precedingPulseRates: [HKSample] = []
+
 
     var body: some View {
         PAWSCard {
@@ -31,24 +30,13 @@ struct ECGRecording: View {
                     Text("Recorded \(symptoms.count) symptoms.")
                 }
             }
-
-            ForEach(precedingPulseRates) { sample in
-                //Text(sample.sampleType.identifier)
-                if let sample = sample as? HKQuantitySample {
-                    Text("\(60 * sample.quantity.doubleValue(for: .hertz())) beats per minute")
-                }
-            }
         }
         .task {
             guard let symptoms = try? await hkElectrocardiogram.symptoms(from: HKHealthStore()) else {
                 return
             }
 
             self.symptoms = symptoms
-            hkElectrocardiogram.precedingPulseRates { samples in
-                print(samples)
-                precedingPulseRates = samples
-            }
         }
     }
 }
@@ -62,74 +50,83 @@ extension HKElectrocardiogram {
         HKQuery.predicateForSamples(withStart: self.fiveMinutesBefore, end: self.startDate, options: .strictStartDate)
     }
 
-    /// To actually get the heart rate (BPM) from one of the samples:
-    /// ```
-    /// let heartRate = sample.quantity.doubleValue(for: HKUnit(from: "count/min"))
-    /// ```
-    func precedingPulseRates(completion: @escaping (_ samples: [HKSample]) -> Void) {
-        precedingSamples(forType: HKQuantityType(.heartRate)) { samples in
-            completion(samples)
+    var precedingPulseRates: [HKSample] {
+        get async throws {
+            try await precedingSamples(forType: HKQuantityType(.heartRate))
         }
     }
 
-//    var precedingVo2Max: HKSample? {
-//        precedingSamples(forType: HKQuantityType(.vo2Max), limit: 1, ascending: false).first
-//    }
-//
-//    var precedingPhysicalEffort: HKQuantity? {
-//        fiveMinuteSum(forType: HKQuantityType(.physicalEffort))
-//    }
-//    
-//    var precedingStepCount: HKQuantity? {
-//        fiveMinuteSum(forType: HKQuantityType(.stepCount))
-//    }
-//    
-//    var precedingActiveEnergy: HKQuantity? {
-//        fiveMinuteSum(forType: HKQuantityType(.activeEnergyBurned))
-//    }
+    var precedingVo2Max: HKSample? {
+        get async {
+            try? await precedingSamples(forType: HKQuantityType(.vo2Max), limit: 1, ascending: false).first
+        }
+    }
+
+    var precedingPhysicalEffort: HKQuantity? {
+        get async {
+            try? await fiveMinuteSum(forType: HKQuantityType(.physicalEffort))
+        }
+    }
+
+    var precedingStepCount: HKQuantity? {
+        get async {
+            try? await fiveMinuteSum(forType: HKQuantityType(.stepCount))
+        }
+    }
 
-    private func precedingSamples(
+    var precedingActiveEnergy: HKQuantity? {
+        get async {
+            try? await fiveMinuteSum(forType: HKQuantityType(.activeEnergyBurned))
+        }
+    }
+
+    /// To actually get the heart rate (BPM) from one of the samples:
+    /// ```
+    /// let heartRate = sample.quantity.doubleValue(for: HKUnit(from: "count/min"))
+    /// ```
+    func precedingSamples(
         forType type: HKSampleType,
         limit: Int? = nil,
-        ascending: Bool = true,
-        completion: @escaping (_ samples: [HKSample]) -> Void
-    ) -> [HKSample] {
+        ascending: Bool = true
+    ) async throws -> [HKSample] {
         let healthStore = HKHealthStore()
         let sortDescriptor = NSSortDescriptor(key: HKSampleSortIdentifierEndDate, ascending: ascending)
         let queryLimit = limit ?? HKObjectQueryNoLimit
-        var result: [HKSample] = []
 
-        let query = HKSampleQuery(
-            sampleType: type,
-            predicate: self.fiveMinutePredicate,
-            limit: queryLimit,
-            sortDescriptors: [sortDescriptor]
-        ) { _, samples, error in
-            if error == nil, let samples {
-                completion(samples)
+        return try await withCheckedThrowingContinuation { continuation in
+            let query = HKSampleQuery(
+                sampleType: type,
+                predicate: self.fiveMinutePredicate,
+                limit: queryLimit,
+                sortDescriptors: [sortDescriptor]
+            ) { _, samples, error in
+                if let error {
+                    continuation.resume(throwing: error)
+                } else {
+                    continuation.resume(returning: samples ?? [])
+                }
             }
+
+            healthStore.execute(query)
         }
-
-        healthStore.execute(query)
-
-        return result
     }
 
-    private func fiveMinuteSum(forType type: HKQuantityType) -> HKQuantity? {
+    private func fiveMinuteSum(forType type: HKQuantityType) async throws -> HKQuantity? {
         let healthStore = HKHealthStore()
-        var result: HKQuantity?
 
-        let query = HKStatisticsQuery(
-            quantityType: type,
-            quantitySamplePredicate: self.fiveMinutePredicate
-        ) { _, statistics, error in
-            if error != nil {
-                result = statistics?.sumQuantity()
+        return try await withCheckedThrowingContinuation { continuation in
+            let query = HKStatisticsQuery(
+                quantityType: type,
+                quantitySamplePredicate: self.fiveMinutePredicate
+            ) { _, statistics, error in
+                if let error {
+                    continuation.resume(throwing: error)
+                } else {
+                    continuation.resume(returning: statistics?.sumQuantity())
+                }
             }
+
+            healthStore.execute(query)
         }
-
-        healthStore.execute(query)
-
-        return result
     }
 }