@kingstinct/react-native-healthkit 12.1.2 → 12.2.0

package/ios/HeartbeatSeriesModule.swift

@@ -1,189 +1,141 @@
 import HealthKit
 import NitroModules
 
-func getHeartbeatSeriesByID(
-    seriesUUID: UUID
-) async -> HKHeartbeatSeriesSample? {
-    let seriesPredicate = HKQuery.predicateForObject(with: seriesUUID)
-
-    let samples = try! await withCheckedThrowingContinuation {
-        (continuation: CheckedContinuation<[HKSample], Error>) in
-        let query = HKSampleQuery(
-            sampleType: HKSeriesType.heartbeat(),
-            predicate: seriesPredicate,
-            limit: 1,
-            sortDescriptors: nil
-        ) { (_, results, error) in
-
-            if let hasError = error {
-                continuation.resume(throwing: hasError)
-                return
-            }
-
-            guard let samples = results else {
-                return continuation.resume(throwing: RuntimeError.error(withMessage: "Empty response"))
-            }
-
-            continuation.resume(returning: samples)
-        }
-        store.execute(query)
-    }
+func serializeHeartbeatSeriesSample(sample: HKHeartbeatSeriesSample) async throws
+  -> HeartbeatSeriesSample {
+  let heartbeats = try await getHeartbeatSeriesHeartbeats(sample: sample)
+
+  return HeartbeatSeriesSample(
+    heartbeats: heartbeats,
+    sampleType: serializeSampleType(sample.sampleType),
+    startDate: sample.startDate,
+    endDate: sample.endDate,
+    hasUndeterminedDuration: sample.hasUndeterminedDuration,
+
+    metadataWeatherCondition: serializeWeatherCondition(
+      sample.metadata?[HKMetadataKeyWeatherCondition] as? HKWeatherCondition),
+    metadataWeatherHumidity: serializeUnknownQuantityTyped(
+      quantity: sample.metadata?[HKMetadataKeyWeatherHumidity] as? HKQuantity),
+    metadataWeatherTemperature: serializeUnknownQuantityTyped(
+      quantity: sample.metadata?[HKMetadataKeyWeatherTemperature] as? HKQuantity),
+    metadataInsulinDeliveryReason: serializeInsulinDeliveryReason(
+      sample.metadata?[HKMetadataKeyInsulinDeliveryReason] as? HKInsulinDeliveryReason),
+    metadataHeartRateMotionContext: serializeHeartRateMotionContext(
+      sample.metadata?[HKMetadataKeyHeartRateMotionContext] as? HKHeartRateMotionContext),
+
+    uuid: sample.uuid.uuidString,
+    sourceRevision: serializeSourceRevision(sample.sourceRevision),
+    device: serializeDevice(hkDevice: sample.device),
+    metadata: serializeMetadata(sample.metadata),
+
+    metadataExternalUUID: sample.metadata?[HKMetadataKeyExternalUUID] as? String,
+    metadataTimeZone: sample.metadata?[HKMetadataKeyTimeZone] as? String,
+    metadataWasUserEntered: sample.metadata?[HKMetadataKeyWasUserEntered] as? Bool,
+    metadataDeviceSerialNumber: sample.metadata?[HKMetadataKeyDeviceSerialNumber] as? String,
+    metadataUdiDeviceIdentifier: sample.metadata?[HKMetadataKeyUDIDeviceIdentifier] as? String,
+    metadataUdiProductionIdentifier: sample.metadata?[HKMetadataKeyUDIProductionIdentifier]
+      as? String,
+    metadataDigitalSignature: sample.metadata?[HKMetadataKeyDigitalSignature] as? String,
+    metadataDeviceName: sample.metadata?[HKMetadataKeyDeviceName] as? String,
+    metadataDeviceManufacturerName: sample.metadata?[HKMetadataKeyDeviceManufacturerName]
+      as? String,
+    metadataSyncIdentifier: sample.metadata?[HKMetadataKeySyncIdentifier] as? String,
+    metadataSyncVersion: sample.metadata?[HKMetadataKeySyncVersion] as? Double,
+    metadataWasTakenInLab: sample.metadata?[HKMetadataKeyWasTakenInLab] as? Bool,
+    metadataReferenceRangeLowerLimit: sample.metadata?[HKMetadataKeyReferenceRangeLowerLimit]
+      as? Double,
+    metadataReferenceRangeUpperLimit: sample.metadata?[HKMetadataKeyReferenceRangeUpperLimit]
+      as? Double,
+    metadataAlgorithmVersion: sample.metadata?[HKMetadataKeyAlgorithmVersion] as? Double
+  )
+}
 
-    guard let heartbeatSeries = samples as? [HKHeartbeatSeriesSample] else {
-        return nil
-    }
+func getHeartbeatSeriesHeartbeats(sample: HKHeartbeatSeriesSample) async throws -> [Heartbeat] {
+  return try await withCheckedThrowingContinuation { continuation in
+    var allBeats: [Heartbeat] = []
 
-    return heartbeatSeries.first ?? nil
-}
+    let query = HKHeartbeatSeriesQuery(heartbeatSeries: sample) {
+      (
+        _: HKHeartbeatSeriesQuery, timeSinceSeriesStart: TimeInterval, precededByGap: Bool,
+        done: Bool, error: Error?
+      ) in
 
-@available(iOS 13.0.0, *)
-class HeartbeatSeriesModule: HybridHeartbeatSeriesModuleSpec {
-    func queryHeartbeatSeriesSamples(
-        options: QueryOptionsWithSortOrder?
-    ) throws -> Promise<[HeartbeatSeriesSample]> {
-        let predicate = try createPredicate(filter: options?.filter)
-        let queryLimit = getQueryLimit(options?.limit)
-
-        return Promise.async {
-            try await withCheckedThrowingContinuation { continuation in
-                let query = HKSampleQuery(
-                    sampleType: HKSeriesType.heartbeat(),
-                    predicate: predicate,
-                    limit: queryLimit,
-                    sortDescriptors: [
-                        NSSortDescriptor(key: HKSampleSortIdentifierStartDate, ascending: options?.ascending ?? false)
-                    ]
-                ) { (_: HKSampleQuery, samples: [HKSample]?, error: Error?) in
-                    if let error = error {
-                        continuation.resume(throwing: error)
-                        return
-                    }
-
-                    guard let samples = samples else {
-                        continuation.resume(returning: [])
-                        return
-                    }
-
-                    Task {
-                        do {
-                            var serializedSamples: [HeartbeatSeriesSample] = []
-
-                            for sample in samples {
-                                guard let heartbeatSample = sample as? HKHeartbeatSeriesSample else { continue }
-
-                                let serialized = try await self.serializeHeartbeatSeriesSample(sample: heartbeatSample)
-                                serializedSamples.append(serialized)
-                            }
-
-                            continuation.resume(returning: serializedSamples)
-                        } catch {
-                            continuation.resume(throwing: error)
-                        }
-                    }
-                }
-
-                store.execute(query)
-            }
-        }
-    }
+      if let error = error {
+        continuation.resume(throwing: error)
+        return
+      }
 
-    func queryHeartbeatSeriesSamplesWithAnchor(
-        options: QueryOptionsWithAnchor
-    ) throws -> Promise<HeartbeatSeriesSamplesWithAnchorResponse> {
-        let predicate = try createPredicate(filter: options.filter)
-        let queryLimit = getQueryLimit(options.limit)
-        let queryAnchor = try deserializeHKQueryAnchor(base64String: options.anchor)
-
-        return Promise.async {
-            try await withCheckedThrowingContinuation { continuation in
-                let query = HKAnchoredObjectQuery(
-                    type: HKSeriesType.heartbeat(),
-                    predicate: predicate,
-                    anchor: queryAnchor,
-                    limit: queryLimit
-                ) { (_: HKAnchoredObjectQuery, samples: [HKSample]?, deletedSamples: [HKDeletedObject]?, newAnchor: HKQueryAnchor?, error: Error?) in
-                    if let error = error {
-                        continuation.resume(throwing: error)
-                        return
-                    }
-
-                    guard let samples = samples else {
-                        let response = HeartbeatSeriesSamplesWithAnchorResponse(
-                            samples: [],
-                            deletedSamples: deletedSamples?.map { serializeDeletedSample(sample: $0) } ?? [],
-                            newAnchor: serializeAnchor(anchor: newAnchor) ?? ""
-                        )
-                        continuation.resume(returning: response)
-                        return
-                    }
-
-                    Task {
-                        do {
-                            var serializedSamples: [HeartbeatSeriesSample] = []
-
-                            for sample in samples {
-                                guard let heartbeatSample = sample as? HKHeartbeatSeriesSample else { continue }
-                                let serialized = try await self.serializeHeartbeatSeriesSample(sample: heartbeatSample)
-                                serializedSamples.append(serialized)
-                            }
-
-                            let response = HeartbeatSeriesSamplesWithAnchorResponse(
-                                samples: serializedSamples,
-                                deletedSamples: deletedSamples?.map { serializeDeletedSample(sample: $0) } ?? [],
-                                newAnchor: serializeAnchor(anchor: newAnchor) ?? ""
-                            )
-
-                            continuation.resume(returning: response)
-                        } catch {
-                            continuation.resume(throwing: error)
-                        }
-                    }
-                }
-
-                store.execute(query)
-            }
-        }
-    }
+      let heartbeat = Heartbeat(
+        timeSinceSeriesStart: timeSinceSeriesStart,
+        precededByGap: precededByGap
+      )
+
+      allBeats.append(heartbeat)
 
-    private func serializeHeartbeatSeriesSample(sample: HKHeartbeatSeriesSample) async throws -> HeartbeatSeriesSample {
-        let heartbeats = try await getHeartbeatSeriesHeartbeats(sample: sample)
-
-        return HeartbeatSeriesSample(
-            uuid: sample.uuid.uuidString,
-            device: serializeDevice(hkDevice: sample.device),
-            startDate: sample.startDate,
-            endDate: sample.endDate,
-            heartbeats: heartbeats,
-            metadata: serializeMetadata(sample.metadata),
-            sourceRevision: serializeSourceRevision(sample.sourceRevision)
-        )
+      if done {
+        continuation.resume(returning: allBeats)
+      }
     }
 
-    private func getHeartbeatSeriesHeartbeats(sample: HKHeartbeatSeriesSample) async throws -> [Heartbeat] {
-        return try await withCheckedThrowingContinuation { continuation in
-            var allBeats: [Heartbeat] = []
+    store.execute(query)
+  }
+}
 
-            let query = HKHeartbeatSeriesQuery(heartbeatSeries: sample) {
-                (_: HKHeartbeatSeriesQuery, timeSinceSeriesStart: TimeInterval, precededByGap: Bool, done: Bool, error: Error?) in
+@available(iOS 13.0.0, *)
+class HeartbeatSeriesModule: HybridHeartbeatSeriesModuleSpec {
+  func queryHeartbeatSeriesSamples(
+    options: QueryOptionsWithSortOrder
+  ) -> Promise<[HeartbeatSeriesSample]> {
 
-                if let error = error {
-                    continuation.resume(throwing: error)
-                    return
-                }
+    return Promise.async {
+      let predicate = createPredicateForSamples(options.filter)
 
-                let heartbeat = Heartbeat(
-                    timeSinceSeriesStart: timeSinceSeriesStart,
-                    precededByGap: precededByGap
-                )
+      let samples = try await sampleQueryAsync(
+        sampleType: HKSeriesType.heartbeat(),
+        limit: options.limit,
+        predicate: predicate,
+        sortDescriptors: getSortDescriptors(ascending: options.ascending)
+      )
+      var serializedSamples: [HeartbeatSeriesSample] = []
 
-                allBeats.append(heartbeat)
+      for sample in samples {
+        guard let heartbeatSample = sample as? HKHeartbeatSeriesSample else { continue }
 
-                if done {
-                    continuation.resume(returning: allBeats)
-                }
-            }
+        let serialized = try await serializeHeartbeatSeriesSample(sample: heartbeatSample)
+        serializedSamples.append(serialized)
+      }
 
-            store.execute(query)
-        }
+      return serializedSamples
+    }
+  }
+
+  func queryHeartbeatSeriesSamplesWithAnchor(
+    options: QueryOptionsWithAnchor
+  ) -> Promise<HeartbeatSeriesSamplesWithAnchorResponse> {
+    return Promise.async {
+      let predicate = createPredicateForSamples(options.filter)
+
+      let response = try await sampleAnchoredQueryAsync(
+        sampleType: HKSeriesType.heartbeat(),
+        limit: options.limit,
+        queryAnchor: options.anchor,
+        predicate: predicate
+      )
+
+      var serializedSamples: [HeartbeatSeriesSample] = []
+
+      for sample in response.samples {
+        guard let heartbeatSample = sample as? HKHeartbeatSeriesSample else { continue }
+        let serialized = try await serializeHeartbeatSeriesSample(sample: heartbeatSample)
+        serializedSamples.append(serialized)
+      }
+
+      return HeartbeatSeriesSamplesWithAnchorResponse(
+        samples: serializedSamples,
+        deletedSamples: response.deletedSamples,
+        newAnchor: response.newAnchor
+      )
     }
+  }
+
 }