@kingstinct/react-native-healthkit 14.1.0 → 16.0.0

package/ios/MemoryEstimation.swift

@@ -0,0 +1,84 @@
+//
+//  MemoryEstimation.swift
+//  Pods
+//
+//  Rough estimates of the native heap kept alive by HybridObject proxies,
+//  reported to Nitro via `memorySize` so the JS garbage collector can account
+//  for memory it cannot see. Precision is not the goal; the right order of
+//  magnitude per object is.
+//
+
+import HealthKit
+import ReactNativeHealthkitCore
+
+/// Approximate per-object bridging overhead of a Nitro HybridObject that Nitro
+/// does not account for itself. The generated `*Spec_cxx.swift` adds the Swift
+/// implementation instance via `MemoryHelper.getSizeOf`; this covers the rest:
+/// the Swift `_cxx` bridge class, the C++ `HybridObject` with its per-runtime
+/// cache map, the `shared_ptr` control block and the reference-state records
+/// behind the JS weak reference. Add it once, in each proxy's `memorySize`.
+let nitroHybridObjectOverheadBytes = 512
+
+/// Rough size of an `NSString` on the heap, including its object header.
+func estimateStringMemorySize(_ value: String?) -> Int {
+  guard let value = value else {
+    return 0
+  }
+  return 32 + value.utf16.count * 2
+}
+
+/// Rough size of a `metadata` dictionary as HealthKit keeps it in memory.
+func estimateMetadataMemorySize(_ metadata: [String: Any]?) -> Int {
+  guard let metadata = metadata, !metadata.isEmpty else {
+    return 0
+  }
+  // NSDictionary header plus one bucket per entry.
+  var total = 64 + metadata.count * 48
+  for (key, value) in metadata {
+    total += estimateStringMemorySize(key)
+    if let string = value as? String {
+      total += estimateStringMemorySize(string)
+    } else if value is HKQuantity {
+      // HKQuantity: object header, unit object, double.
+      total += 128
+    } else {
+      // NSNumber, NSDate and friends are small tagged or boxed objects.
+      total += 32
+    }
+  }
+  return total
+}
+
+/// Rough size of one `HKStatistics` entry: the object itself plus the
+/// sum/min/max/average/most-recent quantities and their date interval.
+let estimatedStatisticsEntryMemorySize = 512
+
+/// Estimate of the `HKWorkout` object graph only; the proxy adds Nitro's
+/// bridging overhead on top.
+func estimateWorkoutMemorySize(_ workout: HKWorkout) -> Int {
+  // HKWorkout object, uuid, dates, HKSourceRevision (+HKSource), HKDevice,
+  // and the four total quantities.
+  var total = 1_024
+  total += estimateMetadataMemorySize(workout.metadata)
+
+  if let events = workout.workoutEvents {
+    for event in events {
+      // HKWorkoutEvent: object header, type, NSDateInterval.
+      total += 128 + estimateMetadataMemorySize(event.metadata)
+    }
+  }
+
+  if #available(iOS 16.0, *) {
+    total += workout.allStatistics.count * estimatedStatisticsEntryMemorySize
+
+    for activity in workout.workoutActivities {
+      // HKWorkoutActivity: object header, uuid, dates, HKWorkoutConfiguration.
+      total += 512
+      total += estimateMetadataMemorySize(activity.metadata)
+      total += activity.workoutEvents.count * 128
+      total += activity.allStatistics.count * estimatedStatisticsEntryMemorySize
+    }
+  }
+
+  return total
+}

package/ios/PredicateHelpers.swift

@@ -6,6 +6,7 @@
 //
 
 import HealthKit
+import ReactNativeHealthkitCore
 
 func createSourcePredicate(_ sources: [HybridSourceProxySpec]?) -> NSPredicate? {
   if let sources = sources {
@@ -147,103 +148,32 @@ func createPredicateForWorkout(_ filter: FilterForWorkouts?) -> NSPredicate? {
   return nil
 }
 
-func createDatePredicate(_ dateFilter: DateFilter?) -> NSPredicate? {
-  if let dateFilter = dateFilter {
-    let strictStartDate = dateFilter.strictStartDate ?? false
-    let strictEndDate = dateFilter.strictEndDate ?? false
-
-    let options: HKQueryOptions =
-      strictStartDate && strictEndDate
-      ? [.strictStartDate, .strictEndDate]
-      : strictEndDate
-        ? .strictEndDate
-        : strictStartDate
-          ? .strictStartDate
-          : []
-
-    return HKQuery.predicateForSamples(
-      withStart: dateFilter.startDate,
-      end: dateFilter.endDate,
-      options: options
-    )
-  }
-  return nil
-}
-
-func createUUIDsPredicate(uuids: [String]?) -> NSPredicate? {
-  if let uuids = uuids {
-    let uuids = uuids.compactMap { uuidStr -> UUID? in
-      do {
-        let uuid = try initializeUUID(uuidStr)
-        return uuid
-      } catch {
-        warnWithPrefix(error.localizedDescription)
-        return nil
-      }
-    }
-    return HKQuery.predicateForObjects(with: Set(uuids))
-  }
-  return nil
-}
+// The generated filter structs adopt the core protocols so the shared
+// predicate builders in ReactNativeHealthkitCore can read them.
+extension DateFilter: DateFilterConvertible {}
 
-func createUUIDPredicate(_ uuid: String?) -> NSPredicate? {
-  if let uuidStr = uuid {
-    do {
-      let uuid = try initializeUUID(uuidStr)
-      return HKQuery.predicateForObject(with: uuid)
-    } catch {
-      warnWithPrefix("createUUIDPredicate: \(error.localizedDescription)")
+extension PredicateWithMetadataKey: MetadataPredicateConvertible {
+  public var operatorRawValue: Int? {
+    guard let operatorType = operatorType else {
       return nil
     }
+    return Int(operatorType.rawValue)
   }
-  return nil
-}
-
-func getComparisonPredicateOperator(_ op: ComparisonPredicateOperator?) -> NSComparisonPredicate
-  .Operator? {
-  if let rawValue = op?.rawValue {
-    if let op = NSComparisonPredicate.Operator.init(rawValue: UInt(rawValue)) {
-      return op
-    } else {
-      warnWithPrefix(
-        "getComparisonPredicateOperator: Unsupported operator in metadata filter: \(rawValue)")
-    }
-  }
-  return nil
-}
-
-func createMetadataPredicate(_ metadata: PredicateWithMetadataKey?) -> NSPredicate? {
-  if let metadata = metadata {
-
-    guard let valueVariant = metadata.value else {
-      return HKQuery.predicateForObjects(withMetadataKey: metadata.withMetadataKey)
-    }
-
-    let actualValue: Any
 
-    switch valueVariant {
+  public var metadataValue: Any? {
+    switch value {
     case .first(let boolValue):
-      actualValue = NSNumber(value: boolValue ? 1 : 0)
+      return NSNumber(value: boolValue ? 1 : 0)
     case .second(let stringValue):
-      actualValue = stringValue
+      return stringValue
     case .third(let doubleValue):
-      actualValue = NSNumber(value: doubleValue)
+      return NSNumber(value: doubleValue)
     case .fourth(let dateValue):
-      actualValue = dateValue
-    }
-
-    if let operatorType = metadata.operatorType != nil
-      ? getComparisonPredicateOperator(metadata.operatorType)
-      : .equalTo {
-      return HKQuery.predicateForObjects(
-        withMetadataKey: metadata.withMetadataKey,
-        operatorType: operatorType,
-        value: actualValue
-      )
+      return dateValue
+    case nil:
+      return nil
     }
-
   }
-  return nil
 }
 
 func createPredicateForSamplesBase(_ filter: FilterForSamplesBase?) -> NSPredicate? {

package/ios/QuantityTypeModule.swift

@@ -1,5 +1,6 @@
 import HealthKit
 import NitroModules
+import ReactNativeHealthkitCore
 
 func emptyStatisticsResponse(from: Date?, to: Date?) -> QueryStatisticsResponse {
   return QueryStatisticsResponse(
@@ -47,13 +48,13 @@ func queryStatisticsForQuantityInternal(
       }
     }
 
-    store.execute(query)
+    healthStore.execute(query)
   }
 }
 
 func serializeStatistics(gottenStats: HKStatistics, unit: HKUnit) -> QueryStatisticsResponse {
   let sources = gottenStats.sources?.map { source in
-    return serializeSource(source)
+    return serializeSourceStruct(source)
   } ?? []
 
   var averageQuantity: Quantity?
@@ -178,7 +179,7 @@ func queryStatisticsCollectionForQuantityInternal(
       }
     }
 
-    store.execute(query)
+    healthStore.execute(query)
   }
 }
 
@@ -244,7 +245,7 @@ func serializeStatisticsPerSource(gottenStats: HKStatistics, unit: HKUnit)
       }
 
       return QueryStatisticsResponseFromSingleSource(
-        source: serializeSource(source),
+        source: serializeSourceStruct(source),
         startDate: gottenStats.startDate,
         endDate: gottenStats.endDate,
         duration: duration,
@@ -313,11 +314,13 @@ class QuantityTypeModule: HybridQuantityTypeModuleSpec {
     return Promise.async {
       let quantityType = try initializeQuantityType(identifier.stringValue)
 
-      if let gottenStats = try await queryStatisticsForQuantityInternal(
-        quantityType: quantityType,
-        statistics: statistics,
-        options: options
-      ) {
+      if let gottenStats = try await retryingWhileStoreReopens({
+        try await queryStatisticsForQuantityInternal(
+          quantityType: quantityType,
+          statistics: statistics,
+          options: options
+        )
+      }) {
         let unit = try await getUnitToUse(
           unitOverride: options?.unit,
           quantityType: quantityType
@@ -336,13 +339,15 @@ class QuantityTypeModule: HybridQuantityTypeModuleSpec {
     return Promise.async {
       let quantityType = try initializeQuantityType(identifier.stringValue)
 
-      if let statistics = try await queryStatisticsCollectionForQuantityInternal(
-        quantityType: quantityType,
-        statistics: statistics,
-        anchorDate: anchorDate,
-        intervalComponents: intervalComponents,
-        options: options
-      ) {
+      if let statistics = try await retryingWhileStoreReopens({
+        try await queryStatisticsCollectionForQuantityInternal(
+          quantityType: quantityType,
+          statistics: statistics,
+          anchorDate: anchorDate,
+          intervalComponents: intervalComponents,
+          options: options
+        )
+      }) {
 
         let unit = try await getUnitToUse(
           unitOverride: options?.unit,
@@ -385,11 +390,13 @@ class QuantityTypeModule: HybridQuantityTypeModuleSpec {
     return Promise.async {
       let quantityType = try initializeQuantityType(identifier.stringValue)
 
-      if let gottenStats = try await queryStatisticsForQuantityInternal(
-        quantityType: quantityType,
-        statistics: statistics,
-        options: options
-      ) {
+      if let gottenStats = try await retryingWhileStoreReopens({
+        try await queryStatisticsForQuantityInternal(
+          quantityType: quantityType,
+          statistics: statistics,
+          options: options
+        )
+      }) {
         let unit = try await getUnitToUse(
           unitOverride: options?.unit,
           quantityType: quantityType
@@ -412,13 +419,15 @@ class QuantityTypeModule: HybridQuantityTypeModuleSpec {
     return Promise.async {
       let quantityType = try initializeQuantityType(identifier.stringValue)
 
-      if let statistics = try await queryStatisticsCollectionForQuantityInternal(
-        quantityType: quantityType,
-        statistics: statistics,
-        anchorDate: anchorDate,
-        intervalComponents: intervalComponents,
-        options: options
-      ) {
+      if let statistics = try await retryingWhileStoreReopens({
+        try await queryStatisticsCollectionForQuantityInternal(
+          quantityType: quantityType,
+          statistics: statistics,
+          anchorDate: anchorDate,
+          intervalComponents: intervalComponents,
+          options: options
+        )
+      }) {
         let unit = try await getUnitToUse(
           unitOverride: options?.unit,
           quantityType: quantityType

package/ios/Serializers.swift

@@ -8,12 +8,7 @@
 import Foundation
 import HealthKit
 import NitroModules
-
-private let metadataDateFormatter: ISO8601DateFormatter = {
-  let formatter = ISO8601DateFormatter()
-  formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
-  return formatter
-}()
+import ReactNativeHealthkitCore
 
 func serializeQuantityTyped(unit: HKUnit, quantityNullable: HKQuantity?) -> Quantity? {
   guard let q = quantityNullable else {
@@ -43,10 +38,10 @@ func serializeQuantitySample(sample: HKQuantitySample, unit: HKUnit) throws -> Q
       startDate: sample.startDate,
       endDate: sample.endDate,
       hasUndeterminedDuration: sample.hasUndeterminedDuration,
-      metadata: serializeMetadata(sample.metadata),
       uuid: sample.uuid.uuidString,
       sourceRevision: serializeSourceRevision(sample.sourceRevision),
-      device: serializeDevice(hkDevice: sample.device)
+      device: serializeDevice(hkDevice: sample.device),
+      metadata: serializeMetadata(sample.metadata)
     )
   }
   throw runtimeErrorWithPrefix(
@@ -62,25 +57,38 @@ func serializeDeletedSample(sample: HKDeletedObject) -> DeletedSample {
 
 func serializeCategorySample(sample: HKCategorySample) -> CategorySample {
   return CategorySample(
-    categoryType: CategoryTypeIdentifier(fromString: sample.categoryType.identifier)!,
+    categoryType: CategoryTypeIdentifier(
+      fromString: categoryTypeIdentifierName(
+        fromHealthKitIdentifier: sample.categoryType.identifier))!,
     value: Double(sample.value),
     sampleType: serializeSampleType(sample.sampleType),
     startDate: sample.startDate,
     endDate: sample.endDate,
     hasUndeterminedDuration: sample.hasUndeterminedDuration,
-    metadata: serializeMetadata(sample.metadata),
     uuid: sample.uuid.uuidString,
     sourceRevision: serializeSourceRevision(sample.sourceRevision),
-    device: serializeDevice(hkDevice: sample.device)
+    device: serializeDevice(hkDevice: sample.device),
+    metadata: serializeMetadata(sample.metadata)
   )
 }
 
+/// Wraps an `HKSource` in a proxy HybridObject. Only use this where the
+/// caller explicitly asks for a source handle (`querySources`,
+/// `currentAppSource`); everything embedded in serialized values should use
+/// `serializeSourceStruct` so that no per-sample native object is allocated.
 func serializeSource(_ source: HKSource) -> SourceProxy {
   return SourceProxy(
     source: source
   )
 }
 
+func serializeSourceStruct(_ source: HKSource) -> Source {
+  return Source(
+    name: source.name,
+    bundleIdentifier: source.bundleIdentifier
+  )
+}
+
 func serializeUnknownQuantityTyped(quantity: HKQuantity?) -> Quantity? {
   guard let quantity = quantity else {
     return nil
@@ -210,59 +218,19 @@ func serializeUnknownQuantity(quantity: HKQuantity) -> [String: AnyValue]? {
   return nil
 }
 
-func serializeMetadata(_ metadata: [String: Any]?) -> AnyMap {
-  let serialized = AnyMap()
-  if let m = metadata {
-    for item in m {
-      if let number = item.value as? NSNumber {
-        if isKnownBooleanMetadataKey(item.key) {
-          serialized.setBoolean(key: item.key, value: number.boolValue)
-        } else if isKnownNumericMetadataKey(item.key) {
-          serialized.setDouble(key: item.key, value: number.doubleValue)
-        } else if CFGetTypeID(number) == CFBooleanGetTypeID() {
-          serialized.setBoolean(key: item.key, value: number.boolValue)
-        } else {
-          serialized.setDouble(key: item.key, value: number.doubleValue)
-        }
-        continue
-      }
-
-      if let bool = item.value as? Bool {
-        serialized.setBoolean(key: item.key, value: bool)
-        continue
-      }
-
-      if let str = item.value as? String {
-        serialized.setString(key: item.key, value: str)
-        continue
-      }
-
-      if let double = item.value as? Double {
-        serialized.setDouble(key: item.key, value: double)
-        continue
-      }
-
-      if let date = item.value as? Date {
-        serialized.setString(
-          key: item.key,
-          value: metadataDateFormatter.string(from: date)
-        )
-        continue
-      }
-
-      if let quantity = item.value as? HKQuantity {
-        if let s = serializeUnknownQuantity(quantity: quantity) {
-          serialized.setObject(key: item.key, value: s)
-        }
-        continue
-      }
-
-      if let dict = item.value as? [String: AnyValue] {
-        serialized.setObject(key: item.key, value: dict)
-      }
+private let metadataSerializationOptions = MetadataSerializationOptions(
+  isBooleanKey: isKnownBooleanMetadataKey,
+  isNumericKey: isKnownNumericMetadataKey,
+  serializeQuantity: { quantity in
+    if let serialized = serializeUnknownQuantity(quantity: quantity) {
+      return .object(serialized)
     }
+    return nil
   }
-  return serialized
+)
+
+func serializeMetadata(_ metadata: [String: Any]?) -> AnyMap {
+  return ReactNativeHealthkitCore.serializeMetadata(metadata, options: metadataSerializationOptions)
 }
 
 func serializeDevice(hkDevice: HKDevice?) -> Device? {
@@ -282,15 +250,9 @@ func serializeDevice(hkDevice: HKDevice?) -> Device? {
   )
 }
 
-func serializeOperatingSystemVersion(_ version: OperatingSystemVersion) -> String {
-  let versionString = "\(version.majorVersion).\(version.minorVersion).\(version.patchVersion)"
-
-  return versionString
-}
-
 func serializeSourceRevision(_ hkSourceRevision: HKSourceRevision) -> SourceRevision {
   return SourceRevision(
-    source: serializeSource(hkSourceRevision.source),
+    source: serializeSourceStruct(hkSourceRevision.source),
     version: hkSourceRevision.version,
     operatingSystemVersion: serializeOperatingSystemVersion(
       hkSourceRevision.operatingSystemVersion),
@@ -300,7 +262,9 @@ func serializeSourceRevision(_ hkSourceRevision: HKSourceRevision) -> SourceRevi
 
 func serializeSampleType(_ sampleType: HKSampleType) -> SampleType {
   return SampleType(
-    identifier: sampleType.identifier,
+    identifier: sampleType is HKCategoryType
+      ? categoryTypeIdentifierName(fromHealthKitIdentifier: sampleType.identifier)
+      : sampleType.identifier,
     allowsRecalibrationForEstimates: sampleType.allowsRecalibrationForEstimates,
     isMinimumDurationRestricted: sampleType.isMinimumDurationRestricted,
     isMaximumDurationRestricted: sampleType.isMaximumDurationRestricted

package/ios/SourceProxy.swift

@@ -7,6 +7,7 @@
 
 import HealthKit
 import NitroModules
+import ReactNativeHealthkitCore
 
 class SourceProxy: HybridSourceProxySpec {
   func toJSON(key: String?) throws -> Source {
@@ -14,11 +15,7 @@ class SourceProxy: HybridSourceProxySpec {
       warnWithPrefix("SourceProxy does not support toJSON with key: \(key!)")
     }
 
-    return Source(
-      name: self.name,
-      bundleIdentifier: self.bundleIdentifier
-    )
-
+    return serializeSourceStruct(source)
   }
 
   let source: HKSource
@@ -31,5 +28,18 @@ class SourceProxy: HybridSourceProxySpec {
     self.source = source
     self.name = source.name
     self.bundleIdentifier = source.bundleIdentifier
+    // HKSource object with its own name and bundle identifier strings, plus
+    // the Swift copies of those strings. Computed once; Nitro reads it on
+    // every conversion to JS.
+    self.memorySize =
+      128
+      + 2 * estimateStringMemorySize(source.name)
+      + 2 * estimateStringMemorySize(source.bundleIdentifier)
+      + nitroHybridObjectOverheadBytes
   }
+
+  /// Estimated heap footprint of the wrapped `HKSource`, reported to Nitro so
+  /// the JS garbage collector accounts for the native memory held by each
+  /// proxy. Nitro adds the Swift instance's own size on top.
+  let memorySize: Int
 }

package/ios/StateOfMindModule.swift

@@ -1,5 +1,6 @@
 import HealthKit
 import NitroModules
+import ReactNativeHealthkitCore
 
 #if compiler(>=6)
 
@@ -40,10 +41,10 @@ import NitroModules
       startDate: sample.startDate,
       endDate: sample.endDate,
       hasUndeterminedDuration: sample.hasUndeterminedDuration,
-      metadata: serializeMetadata(sample.metadata),
       uuid: sample.uuid.uuidString,
       sourceRevision: serializeSourceRevision(sample.sourceRevision),
-      device: serializeDevice(hkDevice: sample.device)
+      device: serializeDevice(hkDevice: sample.device),
+      metadata: serializeMetadata(sample.metadata)
     )
   }
 

package/ios/WorkoutProxy.swift

@@ -8,6 +8,7 @@
 import CoreLocation
 import HealthKit
 import NitroModules
+import ReactNativeHealthkitCore
 
 @available(iOS 17.0.0, *)
 func getWorkoutPlanInternal(workout: HKWorkout) async throws -> WorkoutPlan? {
@@ -49,38 +50,43 @@ func getWorkoutRoutesInternal(
 
 func getRouteLocations(
   route: HKWorkoutRoute
-) async -> [CLLocation] {
-  let locations = try! await withCheckedThrowingContinuation {
+) async throws -> [CLLocation] {
+  return try await withCheckedThrowingContinuation {
     (continuation: CheckedContinuation<[CLLocation], Error>) in
     var allLocations: [CLLocation] = []
+    // HealthKit streams locations in batches through the same handler; make
+    // sure the continuation is resumed exactly once whatever the sequence.
+    var hasFinished = false
+    let finish = { (result: Result<[CLLocation], Error>) in
+      guard !hasFinished else {
+        return
+      }
+      hasFinished = true
+      continuation.resume(with: result)
+    }
 
     let query = HKWorkoutRouteQuery(route: route) {
       (_, locationsOrNil, done, errorOrNil) in
 
       DispatchQueue.main.async {
         if let error = errorOrNil {
-          continuation.resume(throwing: error)
-          return
+          return finish(.failure(error))
         }
 
         guard let currentLocationBatch = locationsOrNil else {
-          return continuation.resume(
-            throwing: runtimeErrorWithPrefix("Unexpected empty response")
-          )
+          return finish(.failure(runtimeErrorWithPrefix("Unexpected empty response")))
         }
 
         allLocations.append(contentsOf: currentLocationBatch)
 
         if done {
-          continuation.resume(returning: allLocations)
+          finish(.success(allLocations))
         }
       }
     }
 
-    store.execute(query)
+    healthStore.execute(query)
   }
-
-  return locations
 }
 
 func serializeLocation(location: CLLocation, previousLocation: CLLocation?)
@@ -122,7 +128,7 @@ func getSerializedWorkoutLocations(
       route.metadata
     )
 
-    let routeCLLocations = await getRouteLocations(
+    let routeCLLocations = try await getRouteLocations(
       route: route
     )
 
@@ -161,7 +167,7 @@ func saveWorkoutRouteInternal(
         // create CLLocations and return if locations are empty
         let clLocations = mapLocations(from: locations)
         let routeBuilder = HKWorkoutRouteBuilder(
-          healthStore: store,
+          healthStore: healthStore,
           device: nil
         )
         try await routeBuilder.insertRouteData(clLocations)
@@ -397,8 +403,20 @@ class WorkoutProxy: HybridWorkoutProxySpec {
 
   init(workout: HKWorkout) {
     self.workout = workout
+    // Computed here rather than lazily: proxies are created inside
+    // `Promise.async` on a background executor, while Nitro reads `memorySize`
+    // on the JS thread every time the proxy is converted to a JS object.
+    self.memorySize = estimateWorkoutMemorySize(workout) + nitroHybridObjectOverheadBytes
   }
 
+  /// Estimated heap footprint of the wrapped `HKWorkout` graph (events,
+  /// activities, statistics, metadata), reported to Nitro so the JS garbage
+  /// collector sees the native memory kept alive by each proxy. Nitro adds
+  /// the Swift instance's own size on top. Rough by design: the goal is the
+  /// right order of magnitude per workout, so hundreds of proxies from a query
+  /// do not look like hundreds of empty objects.
+  let memorySize: Int
+
   func getWorkoutPlan() throws -> Promise<WorkoutPlan?> {
     return Promise.async {
       if #available(iOS 17.0.0, *) {