@kingstinct/react-native-healthkit 8.7.2 → 9.0.0

package/ios/Serializers.swift

@@ -7,174 +7,281 @@
 
 import Foundation
 import HealthKit
+import NitroModules
 
-let _dateFormatter = ISO8601DateFormatter()
-
-func serializeQuantity(unit: HKUnit, quantity: HKQuantity?) -> [String: Any]? {
-    guard let q = quantity else {
+func serializeQuantityTyped(unit: HKUnit, quantityNullable: HKQuantity?) -> Quantity? {
+    guard let q = quantityNullable else {
         return nil
     }
+    
+    return Quantity(
+        unit: unit.unitString,
+        quantity: q.doubleValue(for: unit)
+    )
+}
+
+func serializeQuantityTyped(unit: HKUnit, quantity: HKQuantity) -> Quantity {
+    return Quantity(
+        unit: unit.unitString,
+        quantity: quantity.doubleValue(for: unit)
+    )
+}
 
-    return [
-        "quantity": q.doubleValue(for: unit),
-        "unit": unit.unitString
-    ]
+func serializeQuantitySample(sample: HKQuantitySample, unit: HKUnit) throws -> QuantitySample {
+    if let quantityType = QuantityTypeIdentifier(fromString: sample.quantityType.identifier) {
+        return QuantitySample(
+            uuid: sample.uuid.uuidString,
+            device: serializeDevice(hkDevice: sample.device),
+            quantityType: quantityType,
+            startDate: sample.startDate,
+            endDate: sample.endDate,
+            quantity: sample.quantity.doubleValue(for: unit),
+            unit: unit.unitString,
+            metadata: serializeMetadata(sample.metadata),
+            sourceRevision: serializeSourceRevision(sample.sourceRevision),
+        )
+    }
+    throw RuntimeError.error(withMessage: "[react-native-healthkit] Unable to recognize quantityType: \(sample.quantityType.identifier)")
 }
 
-func serializeQuantitySample(sample: HKQuantitySample, unit: HKUnit) -> NSDictionary {
-    let endDate = _dateFormatter.string(from: sample.endDate)
-    let startDate = _dateFormatter.string(from: sample.startDate)
-
-    let quantity = sample.quantity.doubleValue(for: unit)
-
-    return [
-        "uuid": sample.uuid.uuidString,
-        "device": serializeDevice(_device: sample.device) as Any,
-        "quantityType": sample.quantityType.identifier,
-        "endDate": endDate,
-        "startDate": startDate,
-        "quantity": quantity,
-        "unit": unit.unitString,
-        "metadata": serializeMetadata(metadata: sample.metadata),
-        "sourceRevision": serializeSourceRevision(_sourceRevision: sample.sourceRevision) as Any
-    ]
+func serializeDeletedSample(sample: HKDeletedObject) -> DeletedSample {
+  return DeletedSample(
+    uuid: sample.uuid.uuidString,
+    metadata: serializeMetadata(sample.metadata)
+  )
 }
 
-func serializeDeletedSample(sample: HKDeletedObject) -> NSDictionary {
-  return [
-      "uuid": sample.uuid.uuidString,
-      "metadata": serializeMetadata(metadata: sample.metadata)
-  ]
+
+func serializeCategorySample(sample: HKCategorySample) -> CategorySample {
+    return CategorySample(
+        uuid: sample.uuid.uuidString,
+        device: serializeDevice(hkDevice: sample.device),
+        categoryType: CategoryTypeIdentifier(fromString: sample.categoryType.identifier)!,
+        startDate: sample.startDate,
+        endDate: sample.endDate,
+        value: Double(sample.value),
+        metadata: serializeMetadata(sample.metadata),
+        sourceRevision: serializeSourceRevision(sample.sourceRevision)
+    )
 }
 
-func serializeCategorySample(sample: HKCategorySample) -> NSDictionary {
-    let endDate = _dateFormatter.string(from: sample.endDate)
-    let startDate = _dateFormatter.string(from: sample.startDate)
-
-    return [
-        "uuid": sample.uuid.uuidString,
-        "device": serializeDevice(_device: sample.device) as Any,
-        "categoryType": sample.categoryType.identifier,
-        "endDate": endDate,
-        "startDate": startDate,
-        "value": sample.value,
-        "metadata": serializeMetadata(metadata: sample.metadata),
-        "sourceRevision": serializeSourceRevision(_sourceRevision: sample.sourceRevision) as Any
-    ]
+func serializeSource(_ source: HKSource) -> SourceProxy {
+    return SourceProxy(
+        source: source
+    )
 }
 
-func serializeSource(source: HKSource) -> NSDictionary {
 
-    return [
-        "bundleIdentifier": source.bundleIdentifier,
-        "name": source.name
-    ]
+func getUnitForQuantityType(quantityType: HKQuantityType) -> HKUnit? {
+    if quantityType.is(compatibleWith: HKUnit.percent()) {
+        return HKUnit.percent()
+    }
+
+    if quantityType.is(compatibleWith: HKUnit.second()) {
+        return HKUnit.second()
+    }
+
+    if quantityType.is(compatibleWith: HKUnit.kilocalorie()) {
+        return HKUnit.kilocalorie()
+    }
+
+    if quantityType.is(compatibleWith: HKUnit.count()) {
+        return HKUnit.count()
+    }
+
+    if quantityType.is(compatibleWith: HKUnit.meter()) {
+        return HKUnit.meter()
+    }
+    
+    if quantityType.is(compatibleWith: SpeedUnit) {
+        return SpeedUnit
+    }
+
+    if quantityType.is(compatibleWith: METUnit) {
+        return METUnit
+    }
+
+    if #available(iOS 11, *) {
+        if quantityType.is(compatibleWith: HKUnit.internationalUnit()) {
+            return HKUnit.internationalUnit()
+        }
+    }
+
+    if #available(iOS 13, *) {
+        if quantityType.is(compatibleWith: HKUnit.hertz()) {
+            return HKUnit.hertz()
+        }
+        if quantityType.is(compatibleWith: HKUnit.decibelHearingLevel()) {
+            return HKUnit.decibelHearingLevel()
+        }
+    }
+
+    if #available(iOS 17.0, *) {
+        if quantityType.is(compatibleWith: HKUnit.lux()) {
+            return HKUnit.lux()
+        }
+    }
+
+#if compiler(>=6)
+    if #available(iOS 18.0, *) {
+        if quantityType.is(compatibleWith: HKUnit.appleEffortScore()) {
+            return HKUnit.appleEffortScore()
+        }
+    }
+#endif
+
+
+    return nil
 }
 
-func serializeUnknownQuantity(quantity: HKQuantity) -> [String: Any]? {
+func serializeUnknownQuantityTyped(quantity: HKQuantity?) -> Quantity? {
+    guard let quantity = quantity else {
+        return nil
+    }
+    
     if quantity.is(compatibleWith: HKUnit.percent()) {
-        return serializeQuantity(unit: HKUnit.percent(), quantity: quantity)
+        return serializeQuantityTyped(unit: HKUnit.percent(), quantity: quantity)
     }
 
     if quantity.is(compatibleWith: HKUnit.second()) {
-        return serializeQuantity(unit: HKUnit.second(), quantity: quantity)
+        return serializeQuantityTyped(unit: HKUnit.second(), quantity: quantity)
     }
 
     if quantity.is(compatibleWith: HKUnit.kilocalorie()) {
-        return serializeQuantity(unit: HKUnit.kilocalorie(), quantity: quantity)
+        return serializeQuantityTyped(unit: HKUnit.kilocalorie(), quantity: quantity)
     }
 
     if quantity.is(compatibleWith: HKUnit.count()) {
-        return serializeQuantity(unit: HKUnit.count(), quantity: quantity)
+        return serializeQuantityTyped(unit: HKUnit.count(), quantity: quantity)
     }
 
     if quantity.is(compatibleWith: HKUnit.meter()) {
-        return serializeQuantity(unit: HKUnit.meter(), quantity: quantity)
+        return serializeQuantityTyped(unit: HKUnit.meter(), quantity: quantity)
     }
 
     if #available(iOS 11, *) {
         if quantity.is(compatibleWith: HKUnit.internationalUnit()) {
-            return serializeQuantity(unit: HKUnit.internationalUnit(), quantity: quantity)
+            return serializeQuantityTyped(unit: HKUnit.internationalUnit(), quantity: quantity)
         }
     }
 
     if #available(iOS 13, *) {
         if quantity.is(compatibleWith: HKUnit.hertz()) {
-            return serializeQuantity(unit: HKUnit.hertz(), quantity: quantity)
+            return serializeQuantityTyped(unit: HKUnit.hertz(), quantity: quantity)
         }
         if quantity.is(compatibleWith: HKUnit.decibelHearingLevel()) {
-            return serializeQuantity(unit: HKUnit.decibelHearingLevel(), quantity: quantity)
+            return serializeQuantityTyped(unit: HKUnit.decibelHearingLevel(), quantity: quantity)
         }
     }
 
     if #available(iOS 17.0, *) {
         if quantity.is(compatibleWith: HKUnit.lux()) {
-            return serializeQuantity(unit: HKUnit.lux(), quantity: quantity)
+            return serializeQuantityTyped(unit: HKUnit.lux(), quantity: quantity)
         }
     }
 
 #if compiler(>=6)
     if #available(iOS 18.0, *) {
         if quantity.is(compatibleWith: HKUnit.appleEffortScore()) {
-            return serializeQuantity(unit: HKUnit.appleEffortScore(), quantity: quantity)
+            return serializeQuantityTyped(unit: HKUnit.appleEffortScore(), quantity: quantity)
         }
     }
 #endif
 
     if quantity.is(compatibleWith: SpeedUnit) {
-        return serializeQuantity(unit: SpeedUnit, quantity: quantity)
+        return serializeQuantityTyped(unit: SpeedUnit, quantity: quantity)
     }
 
     if quantity.is(compatibleWith: METUnit) {
-        return serializeQuantity(unit: METUnit, quantity: quantity)
+        return serializeQuantityTyped(unit: METUnit, quantity: quantity)
     }
 
     return nil
 }
 
-func serializeMetadata(metadata: [String: Any]?) -> NSDictionary {
-    let serialized: NSMutableDictionary = [:]
+func serializeUnknownQuantity(quantity: HKQuantity) -> Dictionary<String, AnyValue>? {
+    if let quantityTyped = serializeUnknownQuantityTyped(quantity: quantity) {
+        return [
+            "quantity": AnyValue.number(quantityTyped.quantity),
+            "unit": AnyValue.string(quantityTyped.unit)
+        ]
+    }
+    
+    return nil
+}
+
+func serializeMetadata(_ metadata: [String: Any]?) -> AnyMapHolder {
+    let serialized = AnyMapHolder()
     if let m = metadata {
         for item in m {
             if let bool = item.value as? Bool {
-                serialized.setValue(bool, forKey: item.key)
+                serialized.setBoolean(key: item.key, value: bool)
             }
+            
             if let str = item.value as? String {
-                serialized.setValue(str, forKey: item.key)
+                serialized.setString(key: item.key, value: str)
             }
 
             if let double = item.value as? Double {
-                serialized.setValue(double, forKey: item.key)
+                serialized.setDouble(key: item.key, value: double)
             }
+            
             if let quantity = item.value as? HKQuantity {
                 if let s = serializeUnknownQuantity(quantity: quantity) {
-                    serialized.setValue(s, forKey: item.key)
+                    serialized.setObject(key: item.key, value: s)
                 }
             }
+            
+            if let dict = item.value as? Dictionary<String, AnyValue> {
+                serialized.setObject(key: item.key, value: dict)
+            }
         }
     }
     return serialized
 }
 
-func serializeDevice(_device: HKDevice?) -> [String: String?]? {
-    guard let device = _device else {
-        return nil
+/*func serializeGenericMetadata(_ metadata: [String: Any]?) -> GenericMetadata? {
+    if let metadata = metadata {
+        return GenericMetadata(
+            HKExternalUUID: metadata["HKExternalUUID"] as? String,
+            HKTimeZone: metadata["HKTimeZone"] as? String,
+            HKWasUserEntered: metadata["HKWasUserEntered"] as? Bool,
+            HKDeviceSerialNumber: metadata["HKDeviceSerialNumber"] as? String,
+            HKUDIDeviceIdentifier: metadata["HKUDIDeviceIdentifier"] as? String,
+            HKUDIProductionIdentifier: metadata["HKUDIProductionIdentifier"] as? String,
+            HKDigitalSignature: metadata["HKDigitalSignature"] as? String,
+            HKDeviceName: metadata["HKDeviceName"] as? String,
+            HKDeviceManufacturerName: metadata["HKDeviceManufacturerName"] as? String,
+            HKSyncIdentifier: metadata["HKSyncIdentifier"] as? String,
+            HKSyncVersion: metadata["HKSyncVersion"] as? Double,
+            HKWasTakenInLab: metadata["HKWasTakenInLab"] as? Bool,
+            HKReferenceRangeLowerLimit: metadata["HKReferenceRangeLowerLimit"] as? Double,
+            HKReferenceRangeUpperLimit: metadata["HKReferenceRangeUpperLimit"] as? Double,
+            allMetadata: serializeAllMetadata(metadata)
+        )
     }
+    return nil
+}*/
 
-    return [
-        "name": device.name,
-        "firmwareVersion": device.firmwareVersion,
-        "hardwareVersion": device.hardwareVersion,
-        "localIdentifier": device.localIdentifier,
-        "manufacturer": device.manufacturer,
-        "model": device.model,
-        "softwareVersion": device.softwareVersion,
-        "udiDeviceIdentifier": device.udiDeviceIdentifier
-    ]
+func serializeDevice(hkDevice: HKDevice?) -> Device? {
+    guard let hkDevice = hkDevice else {
+        return nil
+    }
+    
+    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
+    )
 }
 
-func serializeOperatingSystemVersion(_version: OperatingSystemVersion?) -> String? {
-    guard let version = _version else {
+func serializeOperatingSystemVersion(_ version: OperatingSystemVersion?) -> String? {
+    guard let version = version else {
         return nil
     }
 
@@ -183,56 +290,36 @@ func serializeOperatingSystemVersion(_version: OperatingSystemVersion?) -> Strin
     return versionString
 }
 
-func serializeSourceRevision(_sourceRevision: HKSourceRevision?) -> [String: Any?]? {
-    guard let sourceRevision = _sourceRevision else {
+func serializeSourceRevision(_ hkSourceRevision: HKSourceRevision?) -> SourceRevision? {
+    guard let hkSourceRevision = hkSourceRevision else {
         return nil
     }
 
-    var dict = [
-        "source": [
-            "name": sourceRevision.source.name,
-            "bundleIdentifier": sourceRevision.source.bundleIdentifier
-        ],
-        "version": sourceRevision.version as Any
-    ] as [String: Any]
-
+    
     if #available(iOS 11, *) {
-        dict["operatingSystemVersion"] = serializeOperatingSystemVersion(_version: sourceRevision.operatingSystemVersion)
-        dict["productType"] = sourceRevision.productType
+        return SourceRevision(
+            source: serializeSource(hkSourceRevision.source),
+            version: hkSourceRevision.version,
+            operatingSystemVersion: serializeOperatingSystemVersion( hkSourceRevision.operatingSystemVersion),
+            productType: hkSourceRevision.productType
+        )
     }
-
-    return dict
-}
-
-func deserializeHKQueryAnchor(anchor: String) -> HKQueryAnchor? {
-    return anchor.isEmpty ? nil : base64StringToHKQueryAnchor(base64String: anchor)
+    
+    return SourceRevision(
+        source: serializeSource(hkSourceRevision.source),
+        version: hkSourceRevision.version,
+        operatingSystemVersion: nil,
+        productType: nil
+    )
 }
 
 func serializeAnchor(anchor: HKQueryAnchor?) -> String? {
-  guard let anch = anchor else {
-    return nil
-  }
+    if let anchor = anchor {
+      let data = NSKeyedArchiver.archivedData(withRootObject: anchor)
+      let encoded = data.base64EncodedString()
 
-  let data = NSKeyedArchiver.archivedData(withRootObject: anch)
-  let encoded = data.base64EncodedString()
-
-  return encoded
-}
-
-func serializeStatistic(unit: HKUnit, quantity: HKQuantity?, stats: HKStatistics?) -> [String: Any]? {
-    guard let q = quantity, let stats = stats else {
+      return encoded
+    } else {
         return nil
     }
-
-    let endDate = _dateFormatter.string(from: stats.endDate)
-    let startDate = _dateFormatter.string(from: stats.startDate)
-    let quantityType = stats.quantityType.identifier
-
-    return [
-        "quantityType": quantityType,
-        "startDate": startDate,
-        "endDate": endDate,
-        "quantity": q.doubleValue(for: unit),
-        "unit": unit.unitString
-    ]
 }

package/ios/SourceProxy.swift

@@ -0,0 +1,35 @@
+//
+//  SourceProxy.swift
+//  Pods
+//
+//  Created by Robert Herber on 2025-06-16.
+//
+
+import HealthKit
+import NitroModules
+
+class SourceProxy: HybridSourceProxySpec {
+  func toJSON(key: String?) throws -> Source {
+    if key != nil && key?.isEmpty != true {
+      print("SourceProxy does not support toJSON with key: \(key!)")
+    }
+
+    return Source(
+      name: self.name,
+      bundleIdentifier: self.bundleIdentifier
+    )
+
+  }
+
+  private let source: HKSource
+
+  let name: String
+
+  let bundleIdentifier: String
+
+  init(source: HKSource) {
+    self.source = source
+    self.name = source.name
+    self.bundleIdentifier = source.bundleIdentifier
+  }
+}

package/ios/StateOfMindModule.swift

@@ -0,0 +1,160 @@
+import HealthKit
+import NitroModules
+
+@available(iOS 18.0, *)
+func serializeStateOfMindSample(sample: HKStateOfMind) -> StateOfMindSample {
+    // todo: warn if we get unknown labels??
+    let associations = sample.associations.compactMap { association in
+        if let association = StateOfMindAssociation(rawValue: Int32(association.rawValue)) {
+            return association
+        }
+        print("[react-native-healthkit] Unknown StateOfMindAssociation raw value: \(association.rawValue)")
+        
+        return nil
+    }
+    
+    // todo: warn if we get unknown labels??
+    let labels = sample.labels.compactMap { label in
+        if let label = StateOfMindLabel(rawValue: Int32(label.rawValue)){
+            return label
+        }
+        
+        print("[react-native-healthkit] Unknown StateOfMindLabel raw value: \(label.rawValue)")
+        return nil
+    }
+    
+    return StateOfMindSample(
+        uuid: sample.uuid.uuidString,
+        device: serializeDevice(hkDevice: sample.device),
+        startDate: sample.startDate,
+        endDate: sample.endDate,
+        metadata: serializeMetadata(sample.metadata),
+        sourceRevision: serializeSourceRevision(sample.sourceRevision),
+        valence: sample.valence,
+        // todo: handle better?
+        kind: StateOfMindKind(rawValue: Int32(sample.kind.rawValue))!,
+        // todo: handle better?
+        valenceClassification: StateOfMindValenceClassification(rawValue: Int32(sample.valenceClassification.rawValue))!,
+        associations: associations,
+        labels: labels
+    )
+}
+
+#if compiler(>=6)
+class StateOfMindModule : HybridStateOfMindModuleSpec {    
+    func queryStateOfMindSamples(
+        options: QueryOptionsWithSortOrder?
+    ) throws -> Promise<[StateOfMindSample]> {
+        if #available(iOS 18.0, *) {
+            let predicate = try createPredicate(filter: options?.filter)
+            let queryLimit = getQueryLimit(options?.limit)
+            
+            return Promise.async {
+                try await withCheckedThrowingContinuation { continuation in
+                    let type = HKStateOfMindType.stateOfMindType()
+                    
+                    let query = HKSampleQuery(
+                        sampleType: type,
+                        predicate: predicate,
+                        limit: queryLimit,
+                        sortDescriptors: [
+                            NSSortDescriptor(key: HKSampleSortIdentifierStartDate, ascending: options?.ascending ?? false)
+                        ]
+                    ) { (_: HKSampleQuery, samples: [HKSample]?, error: Error?) in
+                        if let error = error {
+                            continuation.resume(throwing: error)
+                            return
+                        }
+                        
+                        guard let samples = samples as? [HKStateOfMind] else {
+                            return continuation.resume(throwing: RuntimeError.error(withMessage: "[react-native-healthkit] Unexpected empty response"))
+                        }
+                        
+                        let serializedSamples = samples.map { sample -> StateOfMindSample in
+                            return serializeStateOfMindSample(sample: sample)
+                        }
+                        
+                        continuation.resume(returning: serializedSamples)
+                    }
+                    
+                    store.execute(query)
+                }
+            }
+        } else {
+            throw RuntimeError.error(withMessage: "StateOfMind is only available on iOS 18 and later")
+        }
+    }
+    
+    func saveStateOfMindSample(
+        date: Date,
+        kind: StateOfMindKind,
+        valence: Double,
+        labels: [StateOfMindLabel],
+        associations: [StateOfMindAssociation],
+        metadata: AnyMapHolder?
+    ) throws -> Promise<Bool> {
+        if #available(iOS 18, *) {
+            return Promise.async {
+                try await withCheckedThrowingContinuation { continuation in
+                    // Convert enum values to HKStateOfMind types
+                    if let hkKind = HKStateOfMind.Kind.init(rawValue: Int(kind.rawValue)) {
+                        let hkLabels = labels.compactMap {
+                            if let label = HKStateOfMind.Label.init(rawValue: Int($0.rawValue)) {
+                                return label
+                            }
+                            print("[react-native-healthkit] Unknown StateOfMindLabel raw value: \($0.rawValue)")
+                            return nil
+                        }
+                        let hkAssociations = associations.compactMap {
+                            if let association = HKStateOfMind.Association.init(rawValue: Int($0.rawValue)) {
+                                return association
+                            }
+                            print("[react-native-healthkit] Unknown StateOfMindAssociation raw value: \($0.rawValue)")
+                            return nil
+                        }
+                        
+                        let sample = HKStateOfMind(
+                            date: date,
+                            kind: hkKind,
+                            valence: valence,
+                            labels: hkLabels,
+                            associations: hkAssociations,
+                            metadata: anyMapToDictionary(metadata ?? AnyMapHolder())
+                        )
+                        
+                        store.save(sample) { (success: Bool, error: Error?) in
+                            if let error = error {
+                                continuation.resume(throwing: error)
+                            } else {
+                                continuation.resume(returning: success)
+                            }
+                        }
+                    }
+                }
+            }
+        } else {
+            throw RuntimeError.error(withMessage: "StateOfMind is only available on iOS 18 and later")
+        }
+    }
+}
+#else
+// Fallback for older Xcode versions
+class StateOfMind : HybridStateOfMindModuleSpec {
+    func queryStateOfMindSamples(
+        options: QueryOptionsWithSortOrder?
+    ) throws -> Promise<[StateOfMindSample]> {
+        throw RuntimeError.error(withMessage: "State of Mind features require iOS 18.0 or later and Xcode 16 or later to compile")
+    }
+    
+    func saveStateOfMindSample(
+        date: Date,
+        kind: StateOfMindKind,
+        valence: Double,
+        labels: [StateOfMindLabel],
+        associations: [StateOfMindAssociation],
+        metadata: [String: Any]?
+    ) throws -> Promise<Bool> {
+        throw RuntimeError.error(withMessage: "State of Mind features require iOS 18.0 or later and Xcode 16 or later to compile")
+    }
+}
+#endif