@kingstinct/react-native-healthkit 8.7.2 → 9.0.1

package/ios/WorkoutProxy.swift

@@ -0,0 +1,412 @@
+//
+//  WorkoutProxy.swift
+//  Pods
+//
+//  Created by Robert Herber on 2025-06-07.
+//
+
+import CoreLocation
+import HealthKit
+import NitroModules
+
+@available(iOS 17.0.0, *)
+func getWorkoutPlanInternal(workout: HKWorkout) async throws -> WorkoutPlan? {
+  let workoutPlan = try await workout.workoutPlan
+  if let id = workoutPlan?.id.uuidString {
+    if let activityType = workoutPlan?.workout.activity {
+      let workoutPlan = WorkoutPlan(
+        id: id,
+        activityType: WorkoutActivityType.init(
+          rawValue: Int32(activityType.rawValue)
+        )!
+      )
+
+      return workoutPlan
+    }
+  }
+
+  return nil
+}
+
+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)
+  }
+
+  guard let routes = samples as? [HKWorkoutRoute] else {
+    return nil
+  }
+
+  return routes
+}
+
+func getRouteLocations(
+  route: HKWorkoutRoute
+) async -> [CLLocation] {
+  let locations = try! await withCheckedThrowingContinuation {
+    (continuation: CheckedContinuation<[CLLocation], Error>) in
+    var allLocations: [CLLocation] = []
+
+    let query = HKWorkoutRouteQuery(route: route) {
+      (_, locationsOrNil, done, errorOrNil) in
+
+      if let error = errorOrNil {
+        continuation.resume(throwing: error)
+        return
+      }
+
+      guard let currentLocationBatch = locationsOrNil else {
+        return continuation.resume(
+          throwing: RuntimeError.error(withMessage: "Empty response")
+        )
+      }
+
+      allLocations.append(contentsOf: currentLocationBatch)
+
+      if done {
+        continuation.resume(returning: allLocations)
+      }
+    }
+
+    store.execute(query)
+  }
+
+  return locations
+}
+
+func serializeLocation(location: CLLocation, previousLocation: CLLocation?)
+  -> WorkoutRouteLocation {
+  var distance: CLLocationDistance?
+  if let previousLocation = previousLocation {
+    distance = location.distance(from: previousLocation)
+  } else {
+    distance = nil
+  }
+
+  return WorkoutRouteLocation(
+    altitude: location.altitude,
+    course: location.course,
+    date: location.timestamp,
+    distance: distance,
+    horizontalAccuracy: location.horizontalAccuracy,
+    latitude: location.coordinate.latitude,
+    longitude: location.coordinate.longitude,
+    speed: location.speed,
+    speedAccuracy: location.speedAccuracy,
+    verticalAccuracy: location.verticalAccuracy
+  )
+}
+
+func getSerializedWorkoutLocations(
+  workout: HKWorkout
+) async throws -> [WorkoutRoute] {
+  let routes = try await getWorkoutRoutesInternal(
+    workout: workout
+  )
+
+  var allRoutes: [WorkoutRoute] = []
+  guard let _routes = routes else {
+    throw RuntimeError.error(withMessage: "Unexpected empty response")
+  }
+  for route in _routes {
+    let routeMetadata = serializeMetadata(
+      route.metadata
+    )
+
+    let routeCLLocations = await getRouteLocations(
+      route: route
+    )
+
+    let routeLocations = routeCLLocations.enumerated().map {
+      (i, loc) in
+      serializeLocation(
+        location: loc,
+        previousLocation: i == 0 ? nil : routeCLLocations[i - 1]
+      )
+    }
+    // let routeInfos: WorkoutRoute = ["locations": routeLocations]
+
+    allRoutes.append(
+      WorkoutRoute(
+        locations: routeLocations,
+        HKMetadataKeySyncIdentifier: routeMetadata.getString(
+          key: "HKMetadataKeySyncIdentifier"
+        ),
+        HKMetadataKeySyncVersion: routeMetadata.getDouble(
+          key: "HKMetadataKeySyncVersion"
+        )
+      )
+    )
+  }
+  return allRoutes
+}
+
+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)
+
+          return continuation.resume(returning: true)
+        } catch {
+          return continuation.resume(throwing: error)
+        }
+      }
+
+    }
+  }
+}
+
+class WorkoutProxy: HybridWorkoutProxySpec {
+  func toJSON(key: String?) throws -> WorkoutSample {
+    if key != nil && key?.isEmpty != true {
+      print("WorkoutProxy does not support toJSON with key: \(key!)")
+    }
+
+    return WorkoutSample(
+      uuid: self.uuid,
+      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,
+      sourceRevision: self.sourceRevision,
+      events: self.events,
+      activities: self.activities
+    )
+  }
+
+  var workoutPredicate: NSPredicate {
+    get {
+      let predicate = HKQuery.predicateForObjects(from: self.workout)
+      return predicate
+    }
+  }
+
+  var uuid: String {
+    get {
+      return workout.uuid.uuidString
+    }
+  }
+
+  var device: Device? {
+    if let hkDevice = workout.device {
+      return Device(
+        name: hkDevice.name,
+        firmwareVersion: hkDevice.firmwareVersion,
+        hardwareVersion: hkDevice.hardwareVersion,
+        localIdentifier: hkDevice.localIdentifier,
+        manufacturer: hkDevice.manufacturer,
+        model: hkDevice.model,
+        softwareVersion: hkDevice.softwareVersion,
+        udiDeviceIdentifier: hkDevice.udiDeviceIdentifier
+      )
+    }
+    return nil
+  }
+
+  var workoutActivityType: WorkoutActivityType {
+    get {
+      if let activityType = WorkoutActivityType.init(
+        rawValue: Int32(workout.workoutActivityType.rawValue)
+      ) {
+        return activityType
+      }
+
+      print("Unknown workout activity type: \(workout.workoutActivityType.rawValue), falling back to 'other'")
+
+      return WorkoutActivityType.other
+    }
+  }
+
+  var duration: Quantity {
+    get {
+      let quantity = HKQuantity(unit: .second(), doubleValue: workout.duration)
+
+      let duration = serializeQuantityTyped(
+        unit: .second(),
+        quantity: quantity
+      )
+
+      return duration
+    }
+  }
+
+  var totalDistance: Quantity? {
+    if let hkTotalDistance = workout.totalDistance {
+      return Quantity(
+        unit: "meters",
+        quantity: hkTotalDistance.doubleValue(for: HKUnit.meter())
+      )
+    }
+    return nil
+  }
+
+  var totalEnergyBurned: Quantity? {
+    get {
+      return serializeQuantityTyped(
+        unit: energyUnit,
+        quantityNullable: workout.totalEnergyBurned
+      )
+    }
+  }
+
+  var totalSwimmingStrokeCount: Quantity? {
+    get {
+    return serializeQuantityTyped(
+      unit: .count(),
+      quantityNullable: workout.totalSwimmingStrokeCount
+    )
+    }
+
+  }
+
+  var totalFlightsClimbed: Quantity? {
+    if #available(iOS 11, *) {
+      if let hkTotalFlightsClimbed = workout.totalFlightsClimbed {
+        return Quantity(
+          unit: "count",
+          quantity: hkTotalFlightsClimbed.doubleValue(for: HKUnit.count())
+        )
+      }
+    }
+    return nil
+  }
+
+  var energyUnit: HKUnit
+
+  var startDate: Date {
+    get {
+      return workout.startDate
+    }
+  }
+
+  var endDate: Date {
+    get {
+      return workout.endDate
+    }
+  }
+
+  var metadata: AnyMapHolder? {
+    get {
+      return serializeMetadata(workout.metadata)
+    }
+  }
+
+  var sourceRevision: SourceRevision? {
+    get {
+      return serializeSourceRevision(workout.sourceRevision)
+    }
+  }
+
+  var events: [WorkoutEvent]? {
+    if let hkWorkoutEvents = workout.workoutEvents {
+      return hkWorkoutEvents.compactMap { event in
+        if let type = WorkoutEventType.init(
+          rawValue: Int32(event.type.rawValue)
+        ) {
+          return WorkoutEvent(
+            type: type,
+            startDate: event.dateInterval.start,
+            endDate: event.dateInterval.end
+          )
+        }
+        print(
+          "Failed to initialize WorkoutEventType with rawValue: \(event.type.rawValue)"
+        )
+        return nil
+      }
+    }
+    return nil
+  }
+
+  var activities: [WorkoutActivity]? {
+    if #available(iOS 16.0, *) {
+      let hkActivities = workout.workoutActivities
+
+      return hkActivities.map { activity in
+        return WorkoutActivity(
+          startDate: activity.startDate,
+          endDate: activity.endDate ?? activity.startDate,
+          uuid: activity.uuid.uuidString,
+          duration: activity.duration
+        )
+      }
+    }
+    return nil
+  }
+
+  let distanceUnit: HKUnit
+
+  private let workout: HKWorkout
+
+  init(workout: HKWorkout, distanceUnit: HKUnit, energyUnit: HKUnit) {
+    self.energyUnit = energyUnit
+    self.distanceUnit = distanceUnit
+
+    self.workout = workout
+  }
+
+  func getWorkoutPlan() throws -> Promise<WorkoutPlan?> {
+    return Promise.async {
+      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"
+        )
+      }
+    }
+  }
+
+  func saveWorkoutRoute(locations: [LocationForSaving]) throws -> Promise<Bool> {
+    return saveWorkoutRouteInternal(workout: self.workout, locations: locations)
+  }
+
+  func getWorkoutRoutes() throws -> Promise<[WorkoutRoute]> {
+    return Promise.async {
+      return try await getSerializedWorkoutLocations(workout: self.workout)
+    }
+  }
+}

package/ios/WorkoutSessionModule.swift

@@ -0,0 +1,182 @@
+//
+//  Workout.swift
+//  Pods
+//
+//  Created by Robert Herber on 2025-06-13.
+//
+
+import WorkoutKit
+import NitroModules
+import HealthKit
+
+
+@available(iOS 17.0, *)
+class WorkoutSessionDelegate: NSObject, HKWorkoutSessionDelegate {
+    func workoutSession(_ workoutSession: HKWorkoutSession, didChangeTo toState: HKWorkoutSessionState, from fromState: HKWorkoutSessionState, date: Date) {
+        
+    }
+    
+    func workoutSession(_ workoutSession: HKWorkoutSession, didFailWithError error: any Error) {
+        
+    }
+    
+    
+    
+    // var options: WorkoutSessionMirroringStartHandlerOptions? = nil
+    /*var onStateChange: ((_ event: WorkoutStateChangeEvent) -> Void)?
+    var onError: ((_ event: WorkoutErrorEvent) -> Void)?
+    var onDataReceived: ((_ event: WorkoutDataReceivedEvent) -> Void)?
+    var onEventReceived: ((_ event: WorkoutEventReceivedEvent) -> Void)?*/
+    // var options: WorkoutSessionMirroringStartHandlerOptions? = nil
+    
+
+    /*func workoutSession(
+    _ workoutSession: HKWorkoutSession,
+    didChangeTo toState: HKWorkoutSessionState,
+    from fromState: HKWorkoutSessionState,
+    date: Date
+  ) {
+    Task { @MainActor [weak self] in
+      guard let self = self else { return }
+        
+        _listeners.onStateChange(
+            WorkoutStateChangeEvent(
+                toState: WorkoutSessionState(rawValue: Int32(toState.rawValue))!,
+                fromState: WorkoutSessionState(rawValue: Int32(fromState.rawValue))!,
+                date: date
+            )
+        )
+    }
+  }
+
+  func workoutSession(_ workoutSession: HKWorkoutSession, didFailWithError error: any Error) {
+    Task { @MainActor [weak self] in
+      guard let self = self else { return }
+
+        self._listeners.onError(
+            WorkoutErrorEvent(error: error.localizedDescription)
+        )
+    }
+  }
+
+  func workoutSession(
+    _ workoutSession: HKWorkoutSession,
+    didReceiveDataFromRemoteWorkoutSession data: [Data]
+  ) {
+    Task { [weak self] in
+      guard let self = self else { return }
+
+      do {
+        let serializedData = data.compactMap { dataItem -> RemoteSessionSharableData? in
+          guard let json = try? JSONSerialization.jsonObject(with: dataItem) as? [String: Any] else {
+            return nil
+          }
+            if let type = json["type"] as? String,
+               let payload = json["payload"] as? [String: Any] {
+                
+                return RemoteSessionSharableData(
+                    type: type,
+                    payload: serializeMetadata(payload)
+                )
+            }
+            return nil
+        }
+         
+        await MainActor.run { [weak self] in
+          guard let self = self else { return }
+            
+            self._listeners.onDataReceived(
+                WorkoutDataReceivedEvent(data: serializedData)
+            )
+        }
+      }
+    }
+  }
+
+  
+    func workoutSession(_ workoutSession: HKWorkoutSession, didGenerate event: HKWorkoutEvent) {
+        
+        self._listeners.onEventReceived(
+            WorkoutEventReceivedEvent(
+                type: WorkoutEventType(rawValue: Int32(event.type.rawValue))!,
+            )
+        )
+  }*/
+}
+
+class WorkoutSessionModule:  HybridWorkoutSessionModuleSpec {
+    // var options: WorkoutSessionMirroringStartHandlerOptions? = nil
+    func workoutSessionMirroringStartHandler(options: WorkoutSessionMirroringStartHandlerOptions) throws -> Bool {
+        // self.options = options
+        if #available(iOS 17.0, *) {
+            store.workoutSessionMirroringStartHandler = { [weak self] mirroringSession in
+                let workoutSessionDelegate = WorkoutSessionDelegate()
+                // workoutSessionDelegate.options = options
+                /*workoutSessionDelegate.onStateChange = { event in
+                    // if let options = self?.options {
+                        // options.onStateChange(event)
+                    // }
+                    
+                    
+                    options.onStateChange(event)
+                }*/
+                mirroringSession.delegate = workoutSessionDelegate
+                self?._workoutSession = mirroringSession
+                self?._workoutSessionDelegate = workoutSessionDelegate
+            }
+        }
+        
+        return true
+    }
+    
+    /*func workoutSessionMirroringStartHandler(onError: @escaping (WorkoutErrorEvent) -> Void, onStateChange: @escaping (WorkoutStateChangeEvent) -> Void, onDataReceived: @escaping (WorkoutDataReceivedEvent) -> Void, onEventReceived: @escaping (WorkoutEventReceivedEvent) -> Void) throws -> Bool {
+        if #available(iOS 17.0, *) {
+            /*store.workoutSessionMirroringStartHandler = { [weak self] mirroringSession in
+                let workoutSessionDelegate = WorkoutSessionDelegate()
+                // workoutSessionDelegate.onStateChange = onStateChange
+                mirroringSession.delegate = workoutSessionDelegate
+                self?._workoutSession = mirroringSession
+                self?._workoutSessionDelegate = workoutSessionDelegate
+            }*/
+        }
+        
+        return true
+    }*/
+    
+    // var workoutSession: HKWorkoutSession? = nil
+    // var workoutSessionDelegate: WorkoutSessionDelegate? = nil
+    
+    func startWatchAppWithWorkoutConfiguration(workoutConfiguration: WorkoutConfiguration) throws -> Promise<Bool> {
+        let configuration = parseWorkoutConfiguration(workoutConfiguration)
+        
+        return Promise.async {
+            try await withCheckedThrowingContinuation { continuation in
+                store.startWatchApp(with: configuration) { success, error in
+                  if let error {
+                      continuation.resume(throwing: RuntimeError.error(withMessage: error.localizedDescription))
+                  }
+
+                  continuation.resume(returning: success)
+                }
+            }
+        }
+    }
+    
+    var _workoutSession: Any? = nil
+    var _workoutSessionDelegate: Any? = nil
+    
+    /*func workoutSessionMirroringStartHandler(options: StartWatchAppWithWorkoutConfigurationOptions) throws -> Bool {
+        if #available(iOS 17.0, *) {
+            store.workoutSessionMirroringStartHandler = { [weak self] mirroringSession in
+                let workoutSessionDelegate = WorkoutSessionDelegate()
+                workoutSessionDelegate.onStateChange = options.onStateChange
+                mirroringSession.delegate = workoutSessionDelegate
+                self?._workoutSession = mirroringSession
+                self?._workoutSessionDelegate = workoutSessionDelegate
+            }
+        }
+        
+        return true
+    }*/
+
+}