@kingstinct/react-native-healthkit 12.1.2 → 12.2.0

package/ios/WorkoutProxy.swift

@@ -32,33 +32,15 @@ func getWorkoutRoutesInternal(
   workout: HKWorkout
 ) async throws -> [HKWorkoutRoute]? {
   let workoutPredicate = HKQuery.predicateForObjects(from: workout)
-  let samples = try await withCheckedThrowingContinuation {
-    (continuation: CheckedContinuation<[HKSample], Error>) in
-    let query = HKAnchoredObjectQuery(
-      type: HKSeriesType.workoutRoute(),
-      predicate: workoutPredicate,
-      anchor: nil,
-      limit: HKObjectQueryNoLimit
-    ) {
-      (_, samples, _, _, error) in
-
-      if let hasError = error {
-        return continuation.resume(throwing: hasError)
-
-      }
-
-      guard let samples = samples else {
-        return continuation.resume(
-          throwing: RuntimeError.error(withMessage: "Empty response")
-        )
-      }
 
-      continuation.resume(returning: samples)
-    }
-    store.execute(query)
-  }
+  let response = try await sampleAnchoredQueryAsync(
+    sampleType: HKSeriesType.workoutRoute(),
+    limit: Double(HKObjectQueryNoLimit),
+    queryAnchor: nil,
+    predicate: workoutPredicate
+  )
 
-  guard let routes = samples as? [HKWorkoutRoute] else {
+  guard let routes = response.samples as? [HKWorkoutRoute] else {
     return nil
   }
 
@@ -82,7 +64,7 @@ func getRouteLocations(
 
       guard let currentLocationBatch = locationsOrNil else {
         return continuation.resume(
-          throwing: RuntimeError.error(withMessage: "Empty response")
+          throwing: runtimeErrorWithPrefix("Unexpected empty response")
         )
       }
 
@@ -131,7 +113,7 @@ func getSerializedWorkoutLocations(
 
   var allRoutes: [WorkoutRoute] = []
   guard let _routes = routes else {
-    throw RuntimeError.error(withMessage: "Unexpected empty response")
+    throw runtimeErrorWithPrefix("Unexpected empty response")
   }
   for route in _routes {
     let routeMetadata = serializeMetadata(
@@ -153,12 +135,14 @@ func getSerializedWorkoutLocations(
     allRoutes.append(
       WorkoutRoute(
         locations: routeLocations,
-        HKMetadataKeySyncIdentifier: routeMetadata.isString(key: "HKMetadataKeySyncIdentifier") ?  routeMetadata.getString(
-          key: "HKMetadataKeySyncIdentifier"
-        ) : nil,
-        HKMetadataKeySyncVersion: routeMetadata.isDouble(key: "HKMetadataKeySyncVersion") ? routeMetadata.getDouble(
-          key: "HKMetadataKeySyncVersion"
-        ) : nil
+        HKMetadataKeySyncIdentifier: routeMetadata.isString(key: "HKMetadataKeySyncIdentifier")
+          ? routeMetadata.getString(
+            key: "HKMetadataKeySyncIdentifier"
+          ) : nil,
+        HKMetadataKeySyncVersion: routeMetadata.isDouble(key: "HKMetadataKeySyncVersion")
+          ? routeMetadata.getDouble(
+            key: "HKMetadataKeySyncVersion"
+          ) : nil
       )
     )
   }
@@ -168,34 +152,33 @@ func getSerializedWorkoutLocations(
 func saveWorkoutRouteInternal(
   workout: HKWorkout,
   locations: [LocationForSaving]
-) -> Promise<Bool> {
-  return Promise.async {
-    try await withCheckedThrowingContinuation { continuation in
-      Task {
-        do {
-          // create CLLocations and return if locations are empty
-          let clLocations = mapLocations(from: locations)
-          let routeBuilder = HKWorkoutRouteBuilder(
-            healthStore: store,
-            device: nil
-          )
-          try await routeBuilder.insertRouteData(clLocations)
-          try await routeBuilder.finishRoute(with: workout, metadata: nil)
+) async throws -> Bool {
+  try await withCheckedThrowingContinuation { continuation in
+    Task {
+      do {
+        // create CLLocations and return if locations are empty
+        let clLocations = mapLocations(from: locations)
+        let routeBuilder = HKWorkoutRouteBuilder(
+          healthStore: store,
+          device: nil
+        )
+        try await routeBuilder.insertRouteData(clLocations)
+        try await routeBuilder.finishRoute(with: workout, metadata: nil)
 
-          return continuation.resume(returning: true)
-        } catch {
-          return continuation.resume(throwing: error)
-        }
+        return continuation.resume(returning: true)
+      } catch {
+        return continuation.resume(throwing: error)
       }
-
     }
+
   }
 }
 
 class WorkoutProxy: HybridWorkoutProxySpec {
-
   // Return a Promise instead of directly returning the value; wrap async logic.
-  func getStatistic(quantityType: QuantityTypeIdentifier, unitOverride: String?) throws -> Promise<QueryStatisticsResponse?> {
+  func getStatistic(quantityType: QuantityTypeIdentifier, unitOverride: String?) throws -> Promise<
+    QueryStatisticsResponse?
+  > {
     return Promise.async {
       if #available(iOS 16.0, *) {
         let type = try initializeQuantityType(quantityType.stringValue)
@@ -208,7 +191,7 @@ class WorkoutProxy: HybridWorkoutProxySpec {
     }
   }
 
-  func getAllStatistics() throws -> Promise<[String: QueryStatisticsResponse]> {
+  func getAllStatistics() -> Promise<[String: QueryStatisticsResponse]> {
     return Promise.async {
       var result: [String: QueryStatisticsResponse] = [:]
       if #available(iOS 16.0, *) {
@@ -225,34 +208,58 @@ class WorkoutProxy: HybridWorkoutProxySpec {
 
   func toJSON(key: String?) throws -> WorkoutSample {
     if let key = key, !key.isEmpty {
-      print("WorkoutProxy does not support toJSON with key: \(key)")
+      warnWithPrefix("WorkoutProxy does not support toJSON with key: \(key)")
     }
 
     return WorkoutSample(
-      uuid: self.uuid,
-      device: self.device,
       workoutActivityType: self.workoutActivityType,
       duration: self.duration,
+      events: self.events,
+      activities: self.activities,
+      metadataAverageMETs: self.metadataAverageMETs,
+      metadataElevationAscended: self.metadataElevationAscended,
+      metadataElevationDescended: self.metadataElevationDescended,
+      metadataIndoorWorkout: self.metadataIndoorWorkout,
+      metadataAverageSpeed: self.metadataAverageSpeed,
+      metadataMaximumSpeed: self.metadataMaximumSpeed,
+      sampleType: self.sampleType,
       startDate: self.startDate,
       endDate: self.endDate,
-      metadata: self.metadata,
+      hasUndeterminedDuration: self.hasUndeterminedDuration,
+      metadataWeatherCondition: self.metadataWeatherCondition,
+      metadataWeatherHumidity: self.metadataWeatherHumidity,
+      metadataWeatherTemperature: self.metadataWeatherTemperature,
+      metadataInsulinDeliveryReason: self.metadataInsulinDeliveryReason,
+      metadataHeartRateMotionContext: self.metadataHeartRateMotionContext,
+      uuid: self.uuid,
       sourceRevision: self.sourceRevision,
-      events: self.events,
-      activities: self.activities
+      device: self.device,
+      metadata: self.metadata,
+      metadataExternalUUID: self.metadataExternalUUID,
+      metadataTimeZone: self.metadataTimeZone,
+      metadataWasUserEntered: self.metadataWasUserEntered,
+      metadataDeviceSerialNumber: self.metadataDeviceSerialNumber,
+      metadataUdiDeviceIdentifier: self.metadataUdiDeviceIdentifier,
+      metadataUdiProductionIdentifier: self.metadataUdiProductionIdentifier,
+      metadataDigitalSignature: self.metadataDigitalSignature,
+      metadataDeviceName: self.metadataDeviceName,
+      metadataDeviceManufacturerName: self.metadataDeviceManufacturerName,
+      metadataSyncIdentifier: self.metadataSyncIdentifier,
+      metadataSyncVersion: self.metadataSyncVersion,
+      metadataWasTakenInLab: self.metadataWasTakenInLab,
+      metadataReferenceRangeLowerLimit: self.metadataReferenceRangeLowerLimit,
+      metadataReferenceRangeUpperLimit: self.metadataReferenceRangeUpperLimit,
+      metadataAlgorithmVersion: self.metadataAlgorithmVersion
     )
   }
 
   var workoutPredicate: NSPredicate {
-    get {
-      let predicate = HKQuery.predicateForObjects(from: self.workout)
-      return predicate
-    }
+    let predicate = HKQuery.predicateForObjects(from: self.workout)
+    return predicate
   }
 
   var uuid: String {
-    get {
-      return workout.uuid.uuidString
-    }
+    return workout.uuid.uuidString
   }
 
   var device: Device? {
@@ -272,30 +279,28 @@ class WorkoutProxy: HybridWorkoutProxySpec {
   }
 
   var workoutActivityType: WorkoutActivityType {
-    get {
-      if let activityType = WorkoutActivityType.init(
-        rawValue: Int32(workout.workoutActivityType.rawValue)
-      ) {
-        return activityType
-      }
+    if let activityType = WorkoutActivityType.init(
+      rawValue: Int32(workout.workoutActivityType.rawValue)
+    ) {
+      return activityType
+    }
 
-      print("Unknown workout activity type: \(workout.workoutActivityType.rawValue), falling back to 'other'")
+    warnWithPrefix(
+      "Unknown workoutActivityType with rawValue: \(workout.workoutActivityType.rawValue), falling back to 'other'"
+    )
 
-      return WorkoutActivityType.other
-    }
+    return WorkoutActivityType.other
   }
 
   var duration: Quantity {
-    get {
-      let quantity = HKQuantity(unit: .second(), doubleValue: workout.duration)
+    let quantity = HKQuantity(unit: .second(), doubleValue: workout.duration)
 
-      let duration = serializeQuantityTyped(
-        unit: .second(),
-        quantity: quantity
-      )
+    let duration = serializeQuantityTyped(
+      unit: .second(),
+      quantity: quantity
+    )
 
-      return duration
-    }
+    return duration
   }
 
   var totalDistance: Quantity? {
@@ -309,21 +314,17 @@ class WorkoutProxy: HybridWorkoutProxySpec {
   }
 
   var totalEnergyBurned: Quantity? {
-    get {
-      return serializeQuantityTyped(
-        unit: HKUnit.kilocalorie(),
-        quantityNullable: workout.totalEnergyBurned
-      )
-    }
+    return serializeQuantityTyped(
+      unit: HKUnit.kilocalorie(),
+      quantityNullable: workout.totalEnergyBurned
+    )
   }
 
   var totalSwimmingStrokeCount: Quantity? {
-    get {
     return serializeQuantityTyped(
       unit: .count(),
       quantityNullable: workout.totalSwimmingStrokeCount
     )
-    }
 
   }
 
@@ -340,27 +341,148 @@ class WorkoutProxy: HybridWorkoutProxySpec {
   }
 
   var startDate: Date {
-    get {
-      return workout.startDate
-    }
+    return workout.startDate
   }
 
   var endDate: Date {
-    get {
-      return workout.endDate
-    }
+    return workout.endDate
   }
 
-  var metadata: AnyMap? {
-    get {
-      return serializeMetadata(workout.metadata)
-    }
+  var metadata: AnyMap {
+    return serializeMetadata(workout.metadata)
   }
 
-  var sourceRevision: SourceRevision? {
-    get {
-      return serializeSourceRevision(workout.sourceRevision)
+  var sourceRevision: SourceRevision {
+    return serializeSourceRevision(workout.sourceRevision)
+  }
+
+  // BaseSample properties
+  var sampleType: SampleType {
+    return serializeSampleType(workout.sampleType)
+  }
+
+  var hasUndeterminedDuration: Bool {
+    return workout.hasUndeterminedDuration
+  }
+
+  // Weather metadata
+  var metadataWeatherCondition: WeatherCondition? {
+    return serializeWeatherCondition(
+      workout.metadata?[HKMetadataKeyWeatherCondition] as? HKWeatherCondition)
+  }
+
+  var metadataWeatherHumidity: Quantity? {
+    return serializeUnknownQuantityTyped(
+      quantity: workout.metadata?[HKMetadataKeyWeatherHumidity] as? HKQuantity)
+  }
+
+  var metadataWeatherTemperature: Quantity? {
+    return serializeUnknownQuantityTyped(
+      quantity: workout.metadata?[HKMetadataKeyWeatherTemperature] as? HKQuantity)
+  }
+
+  var metadataInsulinDeliveryReason: InsulinDeliveryReason? {
+    return serializeInsulinDeliveryReason(
+      workout.metadata?[HKMetadataKeyInsulinDeliveryReason] as? HKInsulinDeliveryReason)
+  }
+
+  var metadataHeartRateMotionContext: HeartRateMotionContext? {
+    return serializeHeartRateMotionContext(
+      workout.metadata?[HKMetadataKeyHeartRateMotionContext] as? HKHeartRateMotionContext)
+  }
+
+  // Workout-specific metadata
+  var metadataAverageMETs: Quantity? {
+    return serializeUnknownQuantityTyped(
+      quantity: workout.metadata?[HKMetadataKeyAverageMETs] as? HKQuantity)
+  }
+
+  var metadataElevationAscended: Quantity? {
+    return serializeUnknownQuantityTyped(
+      quantity: workout.metadata?[HKMetadataKeyElevationAscended] as? HKQuantity)
+  }
+
+  var metadataElevationDescended: Quantity? {
+    if #available(iOS 18.0, *) {
+      return serializeUnknownQuantityTyped(
+        quantity: workout.metadata?[HKMetadataKeyElevationDescended] as? HKQuantity)
     }
+    return nil
+  }
+
+  var metadataIndoorWorkout: Bool? {
+    return workout.metadata?[HKMetadataKeyIndoorWorkout] as? Bool
+  }
+
+  var metadataAverageSpeed: Quantity? {
+    return serializeUnknownQuantityTyped(
+      quantity: workout.metadata?[HKMetadataKeyAverageSpeed] as? HKQuantity)
+  }
+
+  var metadataMaximumSpeed: Quantity? {
+    return serializeUnknownQuantityTyped(
+      quantity: workout.metadata?[HKMetadataKeyMaximumSpeed] as? HKQuantity)
+  }
+
+  // BaseObject metadata
+  var metadataExternalUUID: String? {
+    return workout.metadata?[HKMetadataKeyExternalUUID] as? String
+  }
+
+  var metadataTimeZone: String? {
+    return workout.metadata?[HKMetadataKeyTimeZone] as? String
+  }
+
+  var metadataWasUserEntered: Bool? {
+    return workout.metadata?[HKMetadataKeyWasUserEntered] as? Bool
+  }
+
+  var metadataDeviceSerialNumber: String? {
+    return workout.metadata?[HKMetadataKeyDeviceSerialNumber] as? String
+  }
+
+  var metadataUdiDeviceIdentifier: String? {
+    return workout.metadata?[HKMetadataKeyUDIDeviceIdentifier] as? String
+  }
+
+  var metadataUdiProductionIdentifier: String? {
+    return workout.metadata?[HKMetadataKeyUDIProductionIdentifier] as? String
+  }
+
+  var metadataDigitalSignature: String? {
+    return workout.metadata?[HKMetadataKeyDigitalSignature] as? String
+  }
+
+  var metadataDeviceName: String? {
+    return workout.metadata?[HKMetadataKeyDeviceName] as? String
+  }
+
+  var metadataDeviceManufacturerName: String? {
+    return workout.metadata?[HKMetadataKeyDeviceManufacturerName] as? String
+  }
+
+  var metadataSyncIdentifier: String? {
+    return workout.metadata?[HKMetadataKeySyncIdentifier] as? String
+  }
+
+  var metadataSyncVersion: Double? {
+    return workout.metadata?[HKMetadataKeySyncVersion] as? Double
+  }
+
+  var metadataWasTakenInLab: Bool? {
+    return workout.metadata?[HKMetadataKeyWasTakenInLab] as? Bool
+  }
+
+  var metadataReferenceRangeLowerLimit: Double? {
+    return workout.metadata?[HKMetadataKeyReferenceRangeLowerLimit] as? Double
+  }
+
+  var metadataReferenceRangeUpperLimit: Double? {
+    return workout.metadata?[HKMetadataKeyReferenceRangeUpperLimit] as? Double
+  }
+
+  var metadataAlgorithmVersion: Double? {
+    return workout.metadata?[HKMetadataKeyAlgorithmVersion] as? Double
   }
 
   var events: [WorkoutEvent]? {
@@ -375,7 +497,7 @@ class WorkoutProxy: HybridWorkoutProxySpec {
             endDate: event.dateInterval.end
           )
         }
-        print(
+        warnWithPrefix(
           "Failed to initialize WorkoutEventType with rawValue: \(event.type.rawValue)"
         )
         return nil
@@ -411,18 +533,19 @@ class WorkoutProxy: HybridWorkoutProxySpec {
       if #available(iOS 17.0.0, *) {
         return try await getWorkoutPlanInternal(workout: self.workout)
       } else {
-        throw RuntimeError.error(
-          withMessage: "Workout plans are only available on iOS 17.0 or later"
-        )
+        warnWithPrefix("Workout plans are only available on iOS 17.0 or later")
+        return nil
       }
     }
   }
 
-  func saveWorkoutRoute(locations: [LocationForSaving]) throws -> Promise<Bool> {
-    return saveWorkoutRouteInternal(workout: self.workout, locations: locations)
+  func saveWorkoutRoute(locations: [LocationForSaving]) -> Promise<Bool> {
+    return Promise.async {
+      return try await saveWorkoutRouteInternal(workout: self.workout, locations: locations)
+    }
   }
 
-  func getWorkoutRoutes() throws -> Promise<[WorkoutRoute]> {
+  func getWorkoutRoutes() -> Promise<[WorkoutRoute]> {
     return Promise.async {
       return try await getSerializedWorkoutLocations(workout: self.workout)
     }