@kingstinct/react-native-healthkit 10.1.0 → 11.1.0

package/README.md

@@ -104,7 +104,7 @@ Some imperative examples:
   
   useEffect(() => {
     if (hasRequestedAuthorization) {
-      const unsubscribe = subscribeToChanges(HKQuantityTypeIdentifier.heartRate, () => {
+      const unsubscribe = subscribeToChanges('HKQuantityTypeIdentifierHeartRate', () => {
         // refetch data as needed
       });
 
@@ -113,7 +113,7 @@ Some imperative examples:
   }, [hasRequestedAuthorization]);
 
   /* write data */
-  await requestAuthorization([], [HKQuantityTypeIdentifier.insulinDelivery]); // request write permission for insulin delivery
+  await requestAuthorization([], ['HKQuantityTypeIdentifierInsulinDelivery']); // request write permission for insulin delivery
 
   saveQuantitySample(
       'HKQuantityTypeIdentifierInsulinDelivery',

package/ios/CoreModule.swift

@@ -304,25 +304,17 @@ class CoreModule: HybridCoreModuleSpec {
 
         let queryId = UUID().uuidString
 
-        func responder(
-            query: HKObserverQuery,
-            handler: @escaping HKObserverQueryCompletionHandler,
-            error: Error?
-        ) {
-            DispatchQueue.main.async {
-                callback(OnChangeCallbackArgs(typeIdentifier: typeIdentifier, errorMessage: error?.localizedDescription))
-                handler()
-            }
-        }
-
         let query = HKObserverQuery(
             sampleType: sampleType,
             predicate: predicate
         ) {
-            (query: HKObserverQuery, handler: @escaping HKObserverQueryCompletionHandler, error: Error?)
+            (_: HKObserverQuery, handler: @escaping HKObserverQueryCompletionHandler, error: Error?)
             in
 
-            return responder(query: query, handler: handler, error: error)
+            DispatchQueue.main.async {
+                callback(OnChangeCallbackArgs(typeIdentifier: typeIdentifier, errorMessage: error?.localizedDescription))
+                handler()
+            }
 
         }
 
@@ -330,8 +322,6 @@ class CoreModule: HybridCoreModuleSpec {
 
         self._runningQueries.updateValue(query, forKey: queryId)
 
-        // resolve(queryId)
-
         return queryId
     }
 

package/ios/CorrelationTypeModule.swift

@@ -14,7 +14,8 @@ class CorrelationTypeModule: HybridCorrelationTypeModuleSpec {
         var initializedSamples = Set<HKSample>()
 
         for sample in samples {
-            if let quantitySample = sample as? QuantitySampleForSaving {
+            switch sample {
+            case .second(let quantitySample):
                 let quantityTypeId = HKQuantityTypeIdentifier(rawValue: quantitySample.quantityType.stringValue)
                 guard let quantityType = HKSampleType.quantityType(forIdentifier: quantityTypeId) else {
                     continue
@@ -31,7 +32,7 @@ class CorrelationTypeModule: HybridCorrelationTypeModuleSpec {
                 )
                 initializedSamples.insert(hkQuantitySample)
 
-            } else if let categorySample = sample as? CategorySampleForSaving {
+            case .first(let categorySample):
                 let categoryType = try initializeCategoryType(categorySample.categoryType.stringValue)
 
                 let hkCategorySample = HKCategorySample(
@@ -45,6 +46,10 @@ class CorrelationTypeModule: HybridCorrelationTypeModuleSpec {
             }
         }
 
+      if initializedSamples.isEmpty {
+          throw RuntimeError.error(withMessage: "[react-native-healthkit] No valid samples to create correlation sample")
+      }
+
         let correlation = HKCorrelation(
             type: correlationType,
             start: start,

package/ios/ElectrocardiogramModule.swift

@@ -0,0 +1,210 @@
+import HealthKit
+import NitroModules
+
+// MARK: - Helpers
+
+func getElectrocardiogramByID(
+    seriesUUID: UUID
+) async -> HKElectrocardiogram? {
+    let predicate = HKQuery.predicateForObject(with: seriesUUID)
+
+    let samples = try? await withCheckedThrowingContinuation { (continuation: CheckedContinuation<[HKSample], Error>) in
+        let query = HKSampleQuery(
+            sampleType: HKObjectType.electrocardiogramType(),
+            predicate: predicate,
+            limit: 1,
+            sortDescriptors: nil
+        ) { _, results, error in
+            if let error { continuation.resume(throwing: error); return }
+            guard let results else {
+                continuation.resume(throwing: RuntimeError.error(withMessage: "Empty response"))
+                return
+            }
+            continuation.resume(returning: results)
+        }
+        store.execute(query)
+    }
+
+    return (samples as? [HKElectrocardiogram])?.first
+}
+
+@available(iOS 14.0, *)
+class ElectrocardiogramModule: HybridElectrocardiogramModuleSpec {
+
+    // Query (simple)
+    func queryElectrocardiogramSamples(
+        options: ECGQueryOptionsWithSortOrder?
+    ) throws -> Promise<[ElectrocardiogramSample]> {
+        let predicate = try createPredicate(filter: options?.filter)
+        let queryLimit = getQueryLimit(options?.limit)
+        let ascending = options?.ascending ?? false
+        let includeVoltages = options?.includeVoltages ?? false
+
+        return Promise.async {
+            try await withCheckedThrowingContinuation { continuation in
+                let query = HKSampleQuery(
+                    sampleType: HKObjectType.electrocardiogramType(),
+                    predicate: predicate,
+                    limit: queryLimit,
+                    sortDescriptors: [
+                        NSSortDescriptor(key: HKSampleSortIdentifierStartDate, ascending: ascending)
+                    ]
+                ) { _, samples, error in
+                    if let error { continuation.resume(throwing: error); return }
+                    guard let samples = samples as? [HKElectrocardiogram], !samples.isEmpty else {
+                        continuation.resume(returning: [])
+                        return
+                    }
+
+                    Task {
+                        do {
+                            var out: [ElectrocardiogramSample] = []
+                            out.reserveCapacity(samples.count)
+                            for s in samples {
+                                let serialized = try await self.serializeECGSample(sample: s, includeVoltages: includeVoltages)
+                                out.append(serialized)
+                            }
+                            continuation.resume(returning: out)
+                        } catch {
+                            continuation.resume(throwing: error)
+                        }
+                    }
+                }
+                store.execute(query)
+            }
+        }
+    }
+
+    // Query (anchored)
+    func queryElectrocardiogramSamplesWithAnchor(
+        options: ECGQueryOptionsWithAnchor
+    ) throws -> Promise<ElectrocardiogramSamplesWithAnchorResponse> {
+        let predicate = try createPredicate(filter: options.filter)
+        let queryLimit = getQueryLimit(options.limit)
+        let queryAnchor = try deserializeHKQueryAnchor(base64String: options.anchor)
+        let includeVoltages = options.includeVoltages
+
+        return Promise.async {
+            try await withCheckedThrowingContinuation { continuation in
+                let query = HKAnchoredObjectQuery(
+                    type: HKObjectType.electrocardiogramType(),
+                    predicate: predicate,
+                    anchor: queryAnchor,
+                    limit: queryLimit
+                ) { _, samples, deleted, newAnchor, error in
+                    if let error { continuation.resume(throwing: error); return }
+
+                    Task {
+                        do {
+                            let typed = (samples as? [HKElectrocardiogram]) ?? []
+                            var out: [ElectrocardiogramSample] = []
+                            out.reserveCapacity(typed.count)
+                            for s in typed {
+                                let serialized = try await self.serializeECGSample(sample: s, includeVoltages: includeVoltages)
+                                out.append(serialized)
+                            }
+
+                            let response = ElectrocardiogramSamplesWithAnchorResponse(
+                                samples: out,
+                                deletedSamples: (deleted ?? []).map { serializeDeletedSample(sample: $0) },
+                                newAnchor: serializeAnchor(anchor: newAnchor) ?? ""
+                            )
+                            continuation.resume(returning: response)
+                        } catch {
+                            continuation.resume(throwing: error)
+                        }
+                    }
+                }
+                store.execute(query)
+            }
+        }
+    }
+
+    // MARK: - Serialization
+
+    private func serializeECGSample(sample: HKElectrocardiogram, includeVoltages: Bool) async throws -> ElectrocardiogramSample {
+        // Convert quantities
+        let bpmUnit = HKUnit.count().unitDivided(by: .minute())
+        let hzUnit  = HKUnit.hertz()
+        let avgHR   = sample.averageHeartRate?.doubleValue(for: bpmUnit)
+        let freqHz  = sample.samplingFrequency?.doubleValue(for: hzUnit)
+
+        // Optional: waveform
+        let voltages: [ElectrocardiogramVoltage]? = includeVoltages
+            ? try await getECGVoltages(sample: sample)
+            : nil
+
+        // Algorithm version is stored in metadata under HKAppleECGAlgorithmVersion
+        let algorithmVersion = sample.metadata?[HKMetadataKeyAlgorithmVersion] as? String
+
+        return ElectrocardiogramSample(
+            uuid: sample.uuid.uuidString,
+            device: serializeDevice(hkDevice: sample.device),
+            startDate: sample.startDate,
+            endDate: sample.endDate,
+            classification: serializeClassification(sample.classification),
+            symptomsStatus: serializeSymptomsStatus(sample.symptomsStatus),
+            averageHeartRateBpm: avgHR,
+            samplingFrequencyHz: freqHz,
+            numberOfVoltageMeasurements: sample.numberOfVoltageMeasurements,
+            algorithmVersion: algorithmVersion,
+            voltages: voltages,
+            metadata: serializeMetadata(sample.metadata),
+            sourceRevision: serializeSourceRevision(sample.sourceRevision)
+        )
+    }
+
+    private func getECGVoltages(sample: HKElectrocardiogram) async throws -> [ElectrocardiogramVoltage] {
+        try await withCheckedThrowingContinuation { continuation in
+            var all: [ElectrocardiogramVoltage] = []
+            all.reserveCapacity(sample.numberOfVoltageMeasurements)
+
+            // Stream measurements
+            let q = HKElectrocardiogramQuery(sample) { _, result in
+                switch result {
+                case .error(let error):
+                    continuation.resume(throwing: error)
+
+                case .measurement(let m):
+                    // Lead I-like from Apple Watch
+                    if let v = m.quantity(for: .appleWatchSimilarToLeadI)?.doubleValue(for: .volt()) {
+                        let item = ElectrocardiogramVoltage(
+                            timeSinceSampleStart: m.timeSinceSampleStart,
+                            voltage: v,
+                            lead: ElectrocardiogramLead(fromString: "appleWatchSimilarToLeadI")!
+                        )
+                        all.append(item)
+                    }
+
+                case .done:
+                    continuation.resume(returning: all)
+                }
+            }
+            store.execute(q)
+        }
+    }
+
+    // MARK: - Enum mappers
+
+    private func serializeClassification(_ classification: HKElectrocardiogram.Classification) -> ElectrocardiogramClassification {
+        switch classification {
+            case .notSet:                      return ElectrocardiogramClassification(fromString: "notSet")!
+            case .sinusRhythm:                 return ElectrocardiogramClassification(fromString: "sinusRhythm")!
+            case .atrialFibrillation:          return ElectrocardiogramClassification(fromString: "atrialFibrillation")!
+            case .inconclusiveLowHeartRate:    return ElectrocardiogramClassification(fromString: "inconclusiveLowHeartRate")!
+            case .inconclusiveHighHeartRate:   return ElectrocardiogramClassification(fromString: "inconclusiveHighHeartRate")!
+            case .inconclusivePoorReading:     return ElectrocardiogramClassification(fromString: "inconclusivePoorReading")!
+            case .inconclusiveOther:           return ElectrocardiogramClassification(fromString: "inconclusiveOther")!
+            @unknown default:                  return ElectrocardiogramClassification(fromString: "inconclusiveOther")!
+        }
+    }
+
+    private func serializeSymptomsStatus(_ symptoms: HKElectrocardiogram.SymptomsStatus) -> ElectrocardiogramSymptomsStatus {
+        switch symptoms {
+            case .notSet:  return ElectrocardiogramSymptomsStatus(fromString: "notSet")!
+            case .none:    return ElectrocardiogramSymptomsStatus(fromString: "none")!
+            case .present: return ElectrocardiogramSymptomsStatus(fromString: "present")!
+            @unknown default: return ElectrocardiogramSymptomsStatus(fromString: "notSet")!
+        }
+    }
+}

package/ios/QuantityTypeModule.swift

@@ -49,6 +49,75 @@ func queryQuantitySamplesInternal(
 
 }
 
+func emptyStatisticsResponse(from: Date, to: Date) -> QueryStatisticsResponse {
+    var response = QueryStatisticsResponse()
+
+    response.startDate = from
+    response.endDate = to
+
+    return response
+}
+
+func serializeStatistics(gottenStats: HKStatistics, unit: HKUnit) -> QueryStatisticsResponse {
+  var response = QueryStatisticsResponse()
+
+  response.startDate = gottenStats.startDate
+  response.endDate = gottenStats.endDate
+
+  if let averageQuantity = gottenStats.averageQuantity() {
+      response.averageQuantity = Quantity(
+          unit: unit.unitString,
+          quantity: averageQuantity.doubleValue(for: unit)
+      )
+  }
+  if let maximumQuantity = gottenStats.maximumQuantity() {
+      response.maximumQuantity = Quantity(
+          unit: unit.unitString,
+          quantity: maximumQuantity.doubleValue(for: unit)
+      )
+  }
+  if let minimumQuantity = gottenStats.minimumQuantity() {
+      response.minimumQuantity = Quantity(
+          unit: unit.unitString,
+          quantity: minimumQuantity.doubleValue(for: unit)
+      )
+  }
+  if let sumQuantity = gottenStats.sumQuantity() {
+      response.sumQuantity = Quantity(
+          unit: unit.unitString,
+          quantity: sumQuantity.doubleValue(for: unit)
+      )
+  }
+
+  if #available(iOS 12, *) {
+      if let mostRecent = gottenStats.mostRecentQuantity() {
+          response.mostRecentQuantity = Quantity(
+              unit: unit.unitString,
+              quantity: mostRecent.doubleValue(for: unit)
+          )
+      }
+
+      if let mostRecentDateInterval = gottenStats.mostRecentQuantityDateInterval() {
+          response.mostRecentQuantityDateInterval = QuantityDateInterval(
+              from: mostRecentDateInterval.start,
+              to: mostRecentDateInterval.end
+          )
+      }
+  }
+
+  if #available(iOS 13, *) {
+      if let duration = gottenStats.duration() {
+          let durationUnit = HKUnit.second()
+          response.duration = Quantity(
+              unit: durationUnit.unitString,
+              quantity: duration.doubleValue(for: durationUnit)
+          )
+      }
+  }
+
+  return response
+}
+
 func saveQuantitySampleInternal(
   typeIdentifier: HKQuantityType,
   unitString: String,
@@ -140,6 +209,26 @@ func buildStatisticsOptions(statistics: [StatisticsOptions]) -> HKStatisticsOpti
     return opts
 }
 
+/// Handles HealthKit's `errorNoData` by resuming the continuation with a fallback value if provided,
+/// otherwise resumes with `nil` for Optional result types. For other errors, resumes by throwing.
+/// - Parameters:
+///   - error: The error returned by HealthKit.
+///   - continuation: The continuation to resume.
+///   - noDataFallback: Optional closure producing a fallback value to use when the error is `errorNoData`.
+func handleHKNoDataOrThrow<T>(
+    error: Error,
+    continuation: CheckedContinuation<T, Error>,
+    noDataFallback: (() -> T)
+) {
+    let nsError = error as NSError
+    if nsError.domain == HKError.errorDomain,
+       nsError.code == HKError.Code.errorNoData.rawValue {
+       continuation.resume(returning: noDataFallback())
+    } else {
+        continuation.resume(throwing: error)
+    }
+}
+
 class QuantityTypeModule: HybridQuantityTypeModuleSpec {
     func deleteQuantitySamples(identifier: QuantityTypeIdentifier, filter: FilterForSamples) throws -> Promise<Bool> {
         let sampleType = try initializeQuantityType(identifier.stringValue)
@@ -180,71 +269,17 @@ class QuantityTypeModule: HybridQuantityTypeModuleSpec {
                 ) { (_, stats: HKStatistics?, error: Error?) in
                     DispatchQueue.main.async {
                         if let error = error {
-                            continuation.resume(throwing: error)
-                            return
+                            return handleHKNoDataOrThrow(error: error, continuation: continuation) {
+                                QueryStatisticsResponse()
+                            }
                         }
 
                         guard let gottenStats = stats else {
                             let emptyResponse = QueryStatisticsResponse()
-                            continuation.resume(returning: emptyResponse)
-                            return
+                            return continuation.resume(returning: emptyResponse)
                         }
 
-                        var response = QueryStatisticsResponse()
-
-                        response.startDate = gottenStats.startDate
-                        response.endDate = gottenStats.endDate
-
-                        if let averageQuantity = gottenStats.averageQuantity() {
-                            response.averageQuantity = Quantity(
-                                unit: unit.unitString,
-                                quantity: averageQuantity.doubleValue(for: unit)
-                            )
-                        }
-                        if let maximumQuantity = gottenStats.maximumQuantity() {
-                            response.maximumQuantity = Quantity(
-                                unit: unit.unitString,
-                                quantity: maximumQuantity.doubleValue(for: unit)
-                            )
-                        }
-                        if let minimumQuantity = gottenStats.minimumQuantity() {
-                            response.minimumQuantity = Quantity(
-                                unit: unit.unitString,
-                                quantity: minimumQuantity.doubleValue(for: unit)
-                            )
-                        }
-                        if let sumQuantity = gottenStats.sumQuantity() {
-                            response.sumQuantity = Quantity(
-                                unit: unit.unitString,
-                                quantity: sumQuantity.doubleValue(for: unit)
-                            )
-                        }
-
-                        if #available(iOS 12, *) {
-                            if let mostRecent = gottenStats.mostRecentQuantity() {
-                                response.mostRecentQuantity = Quantity(
-                                    unit: unit.unitString,
-                                    quantity: mostRecent.doubleValue(for: unit)
-                                )
-                            }
-
-                            if let mostRecentDateInterval = gottenStats.mostRecentQuantityDateInterval() {
-                                response.mostRecentQuantityDateInterval = QuantityDateInterval(
-                                    from: mostRecentDateInterval.start,
-                                    to: mostRecentDateInterval.end
-                                )
-                            }
-                        }
-
-                        if #available(iOS 13, *) {
-                            if let duration = gottenStats.duration() {
-                                let durationUnit = HKUnit.second()
-                                response.duration = Quantity(
-                                    unit: durationUnit.unitString,
-                                    quantity: duration.doubleValue(for: durationUnit)
-                                )
-                            }
-                        }
+                        let response = serializeStatistics(gottenStats: gottenStats, unit: unit)
 
                         continuation.resume(returning: response)
                     }
@@ -300,8 +335,9 @@ class QuantityTypeModule: HybridQuantityTypeModuleSpec {
 
                 query.initialResultsHandler = { (_, results: HKStatisticsCollection?, error: Error?) in
                     if let error = error {
-                        continuation.resume(throwing: error)
-                        return
+                        return handleHKNoDataOrThrow(error: error, continuation: continuation) {
+                            []
+                        }
                     }
 
                     guard let statistics = results else {
@@ -326,61 +362,7 @@ class QuantityTypeModule: HybridQuantityTypeModuleSpec {
                     }
 
                     statistics.enumerateStatistics(from: enumerateFrom, to: enumerateTo) { stats, _ in
-                        var response = QueryStatisticsResponse()
-
-                        response.startDate = stats.startDate
-                        response.endDate = stats.endDate
-
-                        if let averageQuantity = stats.averageQuantity() {
-                            response.averageQuantity = Quantity(
-                                unit: unit.unitString,
-                                quantity: averageQuantity.doubleValue(for: unit)
-                            )
-                        }
-                        if let maximumQuantity = stats.maximumQuantity() {
-                            response.maximumQuantity = Quantity(
-                                unit: unit.unitString,
-                                quantity: maximumQuantity.doubleValue(for: unit)
-                            )
-                        }
-                        if let minimumQuantity = stats.minimumQuantity() {
-                            response.minimumQuantity = Quantity(
-                                unit: unit.unitString,
-                                quantity: minimumQuantity.doubleValue(for: unit)
-                            )
-                        }
-                        if let sumQuantity = stats.sumQuantity() {
-                            response.sumQuantity = Quantity(
-                                unit: unit.unitString,
-                                quantity: sumQuantity.doubleValue(for: unit)
-                            )
-                        }
-
-                        if #available(iOS 12, *) {
-                            if let mostRecent = stats.mostRecentQuantity() {
-                                response.mostRecentQuantity = Quantity(
-                                    unit: unit.unitString,
-                                    quantity: mostRecent.doubleValue(for: unit)
-                                )
-                            }
-
-                            if let mostRecentDateInterval = stats.mostRecentQuantityDateInterval() {
-                                response.mostRecentQuantityDateInterval = QuantityDateInterval(
-                                    from: mostRecentDateInterval.start,
-                                    to: mostRecentDateInterval.end
-                                )
-                            }
-                        }
-
-                        if #available(iOS 13, *) {
-                            if let duration = stats.duration() {
-                                let durationUnit = HKUnit.second()
-                                response.duration = Quantity(
-                                    unit: durationUnit.unitString,
-                                    quantity: duration.doubleValue(for: durationUnit)
-                                )
-                            }
-                        }
+                        var response = serializeStatistics(gottenStats: stats, unit: unit)
 
                         responseArray.append(response)
                     }
@@ -419,18 +401,25 @@ class QuantityTypeModule: HybridQuantityTypeModuleSpec {
                     error: Error?
                 ) in
                     if let error = error {
-                        continuation.resume(throwing: error)
-                        return
+                        return handleHKNoDataOrThrow(error: error, continuation: continuation) {
+                            QuantitySamplesWithAnchorResponse(
+                                samples: [],
+                                deletedSamples: [],
+                                newAnchor: ""
+                            )
+                        }
                     }
 
+                    let deletedSamples = deletedSamples?.map { serializeDeletedSample(sample: $0) } ?? []
+                    let newAnchor = serializeAnchor(anchor: newAnchor) ?? ""
+
                     guard let samples = samples else {
                         let response = QuantitySamplesWithAnchorResponse(
                             samples: [],
-                            deletedSamples: deletedSamples?.map { serializeDeletedSample(sample: $0) } ?? [],
-                            newAnchor: serializeAnchor(anchor: newAnchor) ?? ""
+                            deletedSamples: deletedSamples,
+                            newAnchor: newAnchor
                         )
-                        continuation.resume(returning: response)
-                        return
+                        return continuation.resume(returning: response)
                     }
 
                     let quantitySamples = samples.compactMap { sample in
@@ -449,8 +438,8 @@ class QuantityTypeModule: HybridQuantityTypeModuleSpec {
 
                     let response = QuantitySamplesWithAnchorResponse(
                         samples: quantitySamples,
-                        deletedSamples: deletedSamples?.map { serializeDeletedSample(sample: $0) } ?? [],
-                        newAnchor: serializeAnchor(anchor: newAnchor) ?? ""
+                        deletedSamples: deletedSamples,
+                        newAnchor: newAnchor,
                     )
 
                     continuation.resume(returning: response)