@kingstinct/react-native-healthkit 10.0.0 → 11.0.0

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,
@@ -134,6 +139,7 @@ class CorrelationTypeModule: HybridCorrelationTypeModuleSpec {
                             }
 
                             return CorrelationSample(
+                                uuid: correlation.uuid.uuidString,
                                 correlationType: CorrelationTypeIdentifier(fromString: correlation.correlationType.identifier)!,
                                 objects: objects,
                                 metadata: serializeMetadata(correlation.metadata),

package/ios/Helpers.swift

@@ -39,7 +39,7 @@ func createPredicateForWorkout(filter: PredicateForWorkouts) throws -> NSPredica
         case .second(let uuidsWrapper):
             return createUUIDsPredicate(uuidsWrapper: uuidsWrapper)
         case .third(let metadataKey):
-            return HKQuery.predicateForObjects(withMetadataKey: metadataKey.withMetadataKey)
+            return try createMetadataPredicate(metadataKey: metadataKey)
         case .fourth(let dateFilter):
             return createDatePredicate(dateFilter: dateFilter)
         case .fifth(let w):
@@ -69,7 +69,7 @@ func createPredicateForWorkout(filter: Variant_PredicateWithUUID_PredicateWithUU
         case .second(let uuidsWrapper):
             return createUUIDsPredicate(uuidsWrapper: uuidsWrapper)
         case .third(let metadataKey):
-            return HKQuery.predicateForObjects(withMetadataKey: metadataKey.withMetadataKey)
+            return try createMetadataPredicate(metadataKey: metadataKey)
         case .fourth(let dateFilter):
             return createDatePredicate(dateFilter: dateFilter)
         case .fifth(let w):
@@ -136,6 +136,50 @@ func createUUIDsPredicate(uuidsWrapper: PredicateWithUUIDs) -> NSPredicate {
     return HKQuery.predicateForObjects(with: Set(uuids))
 }
 
+func createMetadataPredicate(metadataKey: PredicateWithMetadataKey) throws -> NSPredicate {
+    guard let valueVariant = metadataKey.value else {
+        return HKQuery.predicateForObjects(withMetadataKey: metadataKey.withMetadataKey)
+    }
+
+    let actualValue: Any
+
+    switch valueVariant {
+      case .first(let stringValue):
+          actualValue = stringValue
+      case .second(let doubleValue):
+          actualValue = NSNumber(value: doubleValue)
+      case .third(let boolValue):
+          actualValue = NSNumber(value: boolValue ? 1 : 0)
+      case .fourth(let dateValue):
+          actualValue = dateValue
+    }
+
+    let operatorType: NSComparisonPredicate.Operator
+
+    if let operatorTypeValue = metadataKey.operatorType {
+        switch operatorTypeValue {
+          case PredicateWithMetadataOperator.equalto:
+              operatorType = .equalTo
+          case PredicateWithMetadataOperator.notequalto:
+              operatorType = .notEqualTo
+          case PredicateWithMetadataOperator.greaterthan:
+              operatorType = .greaterThan
+          case PredicateWithMetadataOperator.lessthan:
+              operatorType = .lessThan
+          default:
+              throw RuntimeError.error(withMessage: "Unsupported operator: \(operatorTypeValue)")
+        }
+    } else {
+        operatorType = .equalTo
+    }
+
+    return HKQuery.predicateForObjects(
+        withMetadataKey: metadataKey.withMetadataKey,
+        operatorType: operatorType,
+        value: actualValue
+    )
+}
+
 func createPredicate(filter: Variant_PredicateWithUUID_PredicateWithUUIDs_PredicateWithMetadataKey_PredicateWithStartAndEnd_PredicateFromWorkout_FilterForSamplesAnd_FilterForSamplesOr?) throws -> NSPredicate? {
     if let filter = filter {
         switch filter {
@@ -144,7 +188,7 @@ func createPredicate(filter: Variant_PredicateWithUUID_PredicateWithUUIDs_Predic
             case .second(let uuidsWrapper):
                 return createUUIDsPredicate(uuidsWrapper: uuidsWrapper)
             case .third(let metadataKey):
-                return HKQuery.predicateForObjects(withMetadataKey: metadataKey.withMetadataKey)
+                return try createMetadataPredicate(metadataKey: metadataKey)
             case .fourth(let dateFilter):
                 return createDatePredicate(dateFilter: dateFilter)
             case .fifth(let w):
@@ -173,7 +217,7 @@ func createPredicateForSamples(filter: PredicateForSamples) throws -> NSPredicat
         case .second(let uuidsWrapper):
             return createUUIDsPredicate(uuidsWrapper: uuidsWrapper)
         case .third(let metadataKey):
-            return HKQuery.predicateForObjects(withMetadataKey: metadataKey.withMetadataKey)
+            return try createMetadataPredicate(metadataKey: metadataKey)
         case .fourth(let dateFilter):
             return createDatePredicate(dateFilter: dateFilter)
         case .fifth(let w):
@@ -191,7 +235,7 @@ func createPredicateForSamples(filter: FilterForSamples) throws -> NSPredicate {
     case .second(let uuidsWrapper):
         return createUUIDsPredicate(uuidsWrapper: uuidsWrapper)
     case .third(let metadataKey):
-        return HKQuery.predicateForObjects(withMetadataKey: metadataKey.withMetadataKey)
+        return try createMetadataPredicate(metadataKey: metadataKey)
     case .fourth(let dateFilter):
         return createDatePredicate(dateFilter: dateFilter)
     case .fifth(let w):
@@ -218,7 +262,7 @@ func createPredicateForSamples(filter: Variant_PredicateWithUUID_PredicateWithUU
     case .second(let uuidsWrapper):
         return createUUIDsPredicate(uuidsWrapper: uuidsWrapper)
     case .third(let metadataKey):
-        return HKQuery.predicateForObjects(withMetadataKey: metadataKey.withMetadataKey)
+        return try createMetadataPredicate(metadataKey: metadataKey)
     case .fourth(let dateFilter):
         return createDatePredicate(dateFilter: dateFilter)
     case .fifth(let w):

package/ios/QuantityTypeModule.swift

@@ -49,6 +49,66 @@ func queryQuantitySamplesInternal(
 
 }
 
+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,
@@ -178,71 +238,22 @@ class QuantityTypeModule: HybridQuantityTypeModuleSpec {
                     quantitySamplePredicate: predicate,
                     options: buildStatisticsOptions(statistics: statistics)
                 ) { (_, stats: HKStatistics?, error: Error?) in
-                    if let error = error {
-                        continuation.resume(throwing: error)
-                        return
-                    }
-
-                    guard let gottenStats = stats else {
-                        let emptyResponse = QueryStatisticsResponse()
-                        continuation.resume(returning: emptyResponse)
-                        return
-                    }
-
-                    var response = QueryStatisticsResponse()
-
-                    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)
-                            )
+                    DispatchQueue.main.async {
+                        if let error = error {
+                            continuation.resume(throwing: error)
+                            return
                         }
 
-                        if let mostRecentDateInterval = gottenStats.mostRecentQuantityDateInterval() {
-                            response.mostRecentQuantityDateInterval = QuantityDateInterval(
-                                from: mostRecentDateInterval.start,
-                                to: mostRecentDateInterval.end
-                            )
+                        guard let gottenStats = stats else {
+                            let emptyResponse = QueryStatisticsResponse()
+                            continuation.resume(returning: emptyResponse)
+                            return
                         }
-                    }
 
-                    if #available(iOS 13, *) {
-                        if let duration = gottenStats.duration() {
-                            let durationUnit = HKUnit.second()
-                            response.duration = Quantity(
-                                unit: durationUnit.unitString,
-                                quantity: duration.doubleValue(for: durationUnit)
-                            )
-                        }
-                    }
+                        var response = serializeStatistics(gottenStats: gottenStats, unit: unit)
 
-                    continuation.resume(returning: response)
+                        continuation.resume(returning: response)
+                    }
                 }
 
                 store.execute(query)
@@ -321,58 +332,7 @@ class QuantityTypeModule: HybridQuantityTypeModuleSpec {
                     }
 
                     statistics.enumerateStatistics(from: enumerateFrom, to: enumerateTo) { stats, _ in
-                        var response = QueryStatisticsResponse()
-
-                        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)
                     }

package/ios/Serializers.swift

@@ -70,90 +70,61 @@ func serializeSource(_ source: HKSource) -> SourceProxy {
     )
 }
 
-func getUnitForQuantityType(quantityType: HKQuantityType) -> HKUnit? {
-    if quantityType.is(compatibleWith: HKUnit.percent()) {
-        return HKUnit.percent()
+func serializeUnknownQuantityTyped(quantity: HKQuantity?) -> Quantity? {
+    guard let quantity = quantity else {
+        return nil
     }
 
-    if quantityType.is(compatibleWith: HKUnit.second()) {
-        return HKUnit.second()
+    if quantity.is(compatibleWith: HKUnit.percent()) {
+        return serializeQuantityTyped(unit: HKUnit.percent(), quantity: quantity)
     }
 
-    if quantityType.is(compatibleWith: HKUnit.kilocalorie()) {
-        return HKUnit.kilocalorie()
+    if quantity.is(compatibleWith: HKUnit.second()) {
+        return serializeQuantityTyped(unit: HKUnit.second(), quantity: quantity)
     }
 
-    if quantityType.is(compatibleWith: HKUnit.count()) {
-        return HKUnit.count()
+    if quantity.is(compatibleWith: HKUnit.kilocalorie()) {
+        return serializeQuantityTyped(unit: HKUnit.kilocalorie(), quantity: quantity)
     }
 
-    if quantityType.is(compatibleWith: HKUnit.meter()) {
-        return HKUnit.meter()
+    if quantity.is(compatibleWith: HKUnit.count()) {
+        return serializeQuantityTyped(unit: HKUnit.count(), quantity: quantity)
     }
 
-    if quantityType.is(compatibleWith: SpeedUnit) {
-        return SpeedUnit
+    if quantity.is(compatibleWith: HKUnit.meter()) {
+        return serializeQuantityTyped(unit: HKUnit.meter(), quantity: quantity)
     }
 
-    if quantityType.is(compatibleWith: METUnit) {
-        return METUnit
+    if quantity.is(compatibleWith: HKUnit.degreeCelsius()) {
+        return serializeQuantityTyped(unit: HKUnit.degreeCelsius(), quantity: quantity)
     }
 
-    if #available(iOS 11, *) {
-        if quantityType.is(compatibleWith: HKUnit.internationalUnit()) {
-            return HKUnit.internationalUnit()
-        }
+    if quantity.is(compatibleWith: HKUnit.atmosphere()) {
+        return serializeQuantityTyped(unit: HKUnit.atmosphere(), quantity: quantity)
     }
 
-    if #available(iOS 13, *) {
-        if quantityType.is(compatibleWith: HKUnit.hertz()) {
-            return HKUnit.hertz()
-        }
-        if quantityType.is(compatibleWith: HKUnit.decibelHearingLevel()) {
-            return HKUnit.decibelHearingLevel()
-        }
+    if quantity.is(compatibleWith: HKUnit.gram()) {
+        return serializeQuantityTyped(unit: HKUnit.gram(), quantity: quantity)
     }
 
-    if #available(iOS 17.0, *) {
-        if quantityType.is(compatibleWith: HKUnit.lux()) {
-            return HKUnit.lux()
-        }
+    if quantity.is(compatibleWith: HKUnit.liter()) {
+        return serializeQuantityTyped(unit: HKUnit.liter(), quantity: quantity)
     }
 
-#if compiler(>=6)
-    if #available(iOS 18.0, *) {
-        if quantityType.is(compatibleWith: HKUnit.appleEffortScore()) {
-            return HKUnit.appleEffortScore()
-        }
+    if quantity.is(compatibleWith: HKUnit.volt()) {
+        return serializeQuantityTyped(unit: HKUnit.volt(), quantity: quantity)
     }
-#endif
 
-    return nil
-}
-
-func serializeUnknownQuantityTyped(quantity: HKQuantity?) -> Quantity? {
-    guard let quantity = quantity else {
-        return nil
+    if quantity.is(compatibleWith: HKUnit.hertz()) {
+        return serializeQuantityTyped(unit: HKUnit.hertz(), quantity: quantity)
     }
 
-    if quantity.is(compatibleWith: HKUnit.percent()) {
-        return serializeQuantityTyped(unit: HKUnit.percent(), quantity: quantity)
-    }
-
-    if quantity.is(compatibleWith: HKUnit.second()) {
-        return serializeQuantityTyped(unit: HKUnit.second(), quantity: quantity)
-    }
-
-    if quantity.is(compatibleWith: HKUnit.kilocalorie()) {
-        return serializeQuantityTyped(unit: HKUnit.kilocalorie(), quantity: quantity)
-    }
-
-    if quantity.is(compatibleWith: HKUnit.count()) {
-        return serializeQuantityTyped(unit: HKUnit.count(), quantity: quantity)
+    if quantity.is(compatibleWith: SpeedUnit) {
+        return serializeQuantityTyped(unit: SpeedUnit, quantity: quantity)
     }
 
-    if quantity.is(compatibleWith: HKUnit.meter()) {
-        return serializeQuantityTyped(unit: HKUnit.meter(), quantity: quantity)
+    if quantity.is(compatibleWith: METUnit) {
+        return serializeQuantityTyped(unit: METUnit, quantity: quantity)
     }
 
     if #available(iOS 11, *) {
@@ -171,6 +142,16 @@ func serializeUnknownQuantityTyped(quantity: HKQuantity?) -> Quantity? {
         }
     }
 
+    if #available(iOS 16.0, *) {
+      if quantity.is(compatibleWith: HKUnit.watt()) {
+          return serializeQuantityTyped(unit: HKUnit.watt(), quantity: quantity)
+      }
+
+      if quantity.is(compatibleWith: HKUnit.degreeAngle()) {
+        return serializeQuantityTyped(unit: HKUnit.degreeAngle(), quantity: quantity)
+      }
+    }
+
     if #available(iOS 17.0, *) {
         if quantity.is(compatibleWith: HKUnit.lux()) {
             return serializeQuantityTyped(unit: HKUnit.lux(), quantity: quantity)
@@ -185,14 +166,6 @@ func serializeUnknownQuantityTyped(quantity: HKQuantity?) -> Quantity? {
     }
 #endif
 
-    if quantity.is(compatibleWith: SpeedUnit) {
-        return serializeQuantityTyped(unit: SpeedUnit, quantity: quantity)
-    }
-
-    if quantity.is(compatibleWith: METUnit) {
-        return serializeQuantityTyped(unit: METUnit, quantity: quantity)
-    }
-
     return nil
 }
 

package/ios/WorkoutProxy.swift

@@ -149,17 +149,16 @@ func getSerializedWorkoutLocations(
         previousLocation: i == 0 ? nil : routeCLLocations[i - 1]
       )
     }
-    // let routeInfos: WorkoutRoute = ["locations": routeLocations]
 
     allRoutes.append(
       WorkoutRoute(
         locations: routeLocations,
-        HKMetadataKeySyncIdentifier: routeMetadata.getString(
+        HKMetadataKeySyncIdentifier: routeMetadata.isString(key: "HKMetadataKeySyncIdentifier") ?  routeMetadata.getString(
           key: "HKMetadataKeySyncIdentifier"
-        ),
-        HKMetadataKeySyncVersion: routeMetadata.getDouble(
+        ) : nil,
+        HKMetadataKeySyncVersion: routeMetadata.isDouble(key: "HKMetadataKeySyncVersion") ? routeMetadata.getDouble(
           key: "HKMetadataKeySyncVersion"
-        )
+        ) : nil
       )
     )
   }
@@ -194,9 +193,39 @@ func saveWorkoutRouteInternal(
 }
 
 class WorkoutProxy: HybridWorkoutProxySpec {
+
+  // Return a Promise instead of directly returning the value; wrap async logic.
+  func getStatistic(quantityType: QuantityTypeIdentifier, unitOverride: String?) throws -> Promise<QueryStatisticsResponse?> {
+    return Promise.async {
+      if #available(iOS 16.0, *) {
+        let type = try initializeQuantityType(quantityType.stringValue)
+        if let stats = self.workout.statistics(for: type) {
+          let unit = try await getUnitToUse(unitOverride: unitOverride, quantityType: type)
+          return serializeStatistics(gottenStats: stats, unit: unit)
+        }
+      }
+      return nil
+    }
+  }
+
+  func getAllStatistics() throws -> Promise<[String: QueryStatisticsResponse]> {
+    return Promise.async {
+      var result: [String: QueryStatisticsResponse] = [:]
+      if #available(iOS 16.0, *) {
+        let statsMap = self.workout.allStatistics
+        for (quantityType, stats) in statsMap {
+          let unit = try await getUnitToUse(unitOverride: nil, quantityType: quantityType)
+          let serialized = serializeStatistics(gottenStats: stats, unit: unit)
+          result[quantityType.identifier] = serialized
+        }
+      }
+      return result
+    }
+  }
+
   func toJSON(key: String?) throws -> WorkoutSample {
-    if key != nil && key?.isEmpty != true {
-      print("WorkoutProxy does not support toJSON with key: \(key!)")
+    if let key = key, !key.isEmpty {
+      print("WorkoutProxy does not support toJSON with key: \(key)")
     }
 
     return WorkoutSample(
@@ -204,10 +233,6 @@ class WorkoutProxy: HybridWorkoutProxySpec {
       device: self.device,
       workoutActivityType: self.workoutActivityType,
       duration: self.duration,
-      totalDistance: self.totalDistance,
-      totalEnergyBurned: self.totalEnergyBurned,
-      totalSwimmingStrokeCount: self.totalSwimmingStrokeCount,
-      totalFlightsClimbed: self.totalFlightsClimbed,
       startDate: self.startDate,
       endDate: self.endDate,
       metadata: self.metadata,
@@ -286,7 +311,7 @@ class WorkoutProxy: HybridWorkoutProxySpec {
   var totalEnergyBurned: Quantity? {
     get {
       return serializeQuantityTyped(
-        unit: energyUnit,
+        unit: HKUnit.kilocalorie(),
         quantityNullable: workout.totalEnergyBurned
       )
     }
@@ -314,8 +339,6 @@ class WorkoutProxy: HybridWorkoutProxySpec {
     return nil
   }
 
-  var energyUnit: HKUnit
-
   var startDate: Date {
     get {
       return workout.startDate
@@ -377,14 +400,9 @@ class WorkoutProxy: HybridWorkoutProxySpec {
     return nil
   }
 
-  let distanceUnit: HKUnit
-
   private let workout: HKWorkout
 
-  init(workout: HKWorkout, distanceUnit: HKUnit, energyUnit: HKUnit) {
-    self.energyUnit = energyUnit
-    self.distanceUnit = distanceUnit
-
+  init(workout: HKWorkout) {
     self.workout = workout
   }