@kingstinct/react-native-healthkit 8.7.1 → 9.0.0

package/ReactNativeHealthkit.podspec

@@ -0,0 +1,36 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "ReactNativeHealthkit"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported, :visionos => 1.0 }
+  s.source       = { :git => "https://github.com/kingstinct/react-native-healthkit.git", :tag => "#{s.version}" }
+
+  s.source_files = [
+    # Implementation (Swift)
+    "ios/**/*.{swift}",
+    # Autolinking/Registration (Objective-C++)
+    "ios/**/*.{m,mm}",
+    # Implementation (C++ objects)
+    "cpp/**/*.{hpp,cpp}",
+  ]
+
+  s.pod_target_xcconfig = {
+    # C++ compiler flags, mainly for folly.
+    "GCC_PREPROCESSOR_DEFINITIONS" => "$(inherited) FOLLY_NO_CONFIG FOLLY_CFG_NO_COROUTINES"
+  }
+
+  load 'nitrogen/generated/ios/ReactNativeHealthkit+autolinking.rb'
+  add_nitrogen_files(s)
+
+  s.dependency 'React-jsi'
+  s.dependency 'React-callinvoker'
+  install_modules_dependencies(s)
+end

package/app.plugin.js

@@ -10,7 +10,7 @@ const {
  * @typedef ConfigPlugin
  * @type {import('@expo/config-plugins').ConfigPlugin<T>}
  * @template T = void
-*/
+ */
 
 // please note that the BackgroundConfig currently doesn't actually enable background delivery for any types, but you
 // can set it to false if you don't want the entitlement
@@ -18,8 +18,8 @@ const {
 /**
  * @typedef BackgroundConfig
  * @type {false | Partial<Record<
- *  import('./src/native-types').HKSampleTypeIdentifier,
- *  import('./src/native-types').HKUpdateFrequency
+ *  import('./src/native-types').SampleTypeIdentifier,
+ *  import('./src/native-types').UpdateFrequency
  * >>}
 
 /**
@@ -33,59 +33,69 @@ const {
 /**
  * @typedef AppPluginConfig
  * @type {InfoPlistConfig & { background?: BackgroundConfig }}
-*/
+ */
 
 /**
-   * @type {ConfigPlugin<{background: BackgroundConfig}>}
-   */
+ * @type {ConfigPlugin<{background: BackgroundConfig}>}
+ */
 const withEntitlementsPlugin = (
   config,
   /**
    * @type {{background: BackgroundConfig} | undefined}
    * */
   props,
-) => withEntitlementsPlist(config, (config) => {
-  config.modResults['com.apple.developer.healthkit'] = true
+) =>
+  withEntitlementsPlist(config, (config) => {
+    config.modResults['com.apple.developer.healthkit'] = true
 
-  // background is enabled by default, but possible to opt-out from
-  // (haven't seen any drawbacks from having it enabled)
-  if (props?.background !== false) {
-    config.modResults['com.apple.developer.healthkit.background-delivery'] = true
-  }
+    // background is enabled by default, but possible to opt-out from
+    // (haven't seen any drawbacks from having it enabled)
+    if (props?.background !== false) {
+      config.modResults['com.apple.developer.healthkit.background-delivery'] =
+        true
+    }
 
-  return config
-})
+    return config
+  })
 
 /**
  * @type {ConfigPlugin<InfoPlistConfig>}
  */
-const withInfoPlistPlugin = (config,
+const withInfoPlistPlugin = (
+  config,
   /**
-  * @type {{NSHealthShareUsageDescription: string | boolean, NSHealthUpdateUsageDescription: string | boolean} | undefined}
-  * */
-  props) => withInfoPlist(config, (config) => {
-  if (props?.NSHealthShareUsageDescription !== false) {
-    config.modResults.NSHealthShareUsageDescription = props.NSHealthShareUsageDescription ?? `${config.name} wants to read your health data`
-  }
+   * @type {{NSHealthShareUsageDescription: string | boolean, NSHealthUpdateUsageDescription: string | boolean} | undefined}
+   * */
+  props,
+) =>
+  withInfoPlist(config, (config) => {
+    if (props?.NSHealthShareUsageDescription !== false) {
+      config.modResults.NSHealthShareUsageDescription =
+        props.NSHealthShareUsageDescription ??
+        `${config.name} wants to read your health data`
+    }
 
-  if (props?.NSHealthUpdateUsageDescription !== false) {
-    config.modResults.NSHealthUpdateUsageDescription = props.NSHealthUpdateUsageDescription ?? `${config.name} wants to update your health data`
-  }
+    if (props?.NSHealthUpdateUsageDescription !== false) {
+      config.modResults.NSHealthUpdateUsageDescription =
+        props.NSHealthUpdateUsageDescription ??
+        `${config.name} wants to update your health data`
+    }
 
-  return config
-})
+    return config
+  })
 
 const pkg = require('./package.json')
 
 /**
  * @type {ConfigPlugin<AppPluginConfig>}
-*/
-const healthkitAppPlugin = (config, props) => withPlugins(config, [
-  [withEntitlementsPlugin, props],
-  [withInfoPlistPlugin, props],
-])
+ */
+const healthkitAppPlugin = (config, props) =>
+  withPlugins(config, [
+    [withEntitlementsPlugin, props],
+    [withInfoPlistPlugin, props],
+  ])
 
 /**
  * @type {ConfigPlugin<AppPluginConfig>}
-*/
+ */
 module.exports = createRunOncePlugin(healthkitAppPlugin, pkg.name, pkg.version)

package/ios/Bridge.h

@@ -0,0 +1,8 @@
+//
+//  Bridge.h
+//  ReactNativeHealthkit
+//
+//  Created by Marc Rousavy on 22.07.24.
+//
+
+#pragma once

package/ios/CategoryTypeModule.swift

@@ -0,0 +1,128 @@
+import HealthKit
+import NitroModules
+
+
+
+class CategoryTypeModule : HybridCategoryTypeModuleSpec {
+    func saveCategorySample(
+        identifier: CategoryTypeIdentifier,
+        value: Double,
+        startDate: Date,
+        endDate: Date,
+        metadata: AnyMapHolder
+    ) throws -> Promise<Bool> {
+        let type = try initializeCategoryType(identifier.stringValue)
+        
+        let sample = HKCategorySample(
+            type: type,
+            value: Int(value),
+            start: startDate,
+            end: endDate,
+            metadata: anyMapToDictionary(metadata)
+        )
+        
+        return Promise.async {
+            try await withCheckedThrowingContinuation { continuation in
+                store.save(sample) { (success: Bool, error: Error?) in
+                    if let error = error {
+                        continuation.resume(throwing: error)
+                    } else {
+                        continuation.resume(returning: success)
+                    }
+                }
+            }
+        }
+    }
+    
+    func queryCategorySamples(
+        identifier: CategoryTypeIdentifier,
+        options: QueryOptionsWithSortOrder?,
+    ) throws -> Promise<[CategorySample]> {
+        let sampleType = try initializeCategoryType(identifier.stringValue)
+        let predicate = try createPredicate(filter: options?.filter)
+        let queryLimit = getQueryLimit(options?.limit)
+        
+        return Promise.async {
+            try await withCheckedThrowingContinuation { continuation in
+                let query = HKSampleQuery(
+                    sampleType: sampleType,
+                    predicate: predicate,
+                    limit: queryLimit,
+                    sortDescriptors: getSortDescriptors(ascending: options?.ascending)
+                ) { (_: HKSampleQuery, samples: [HKSample]?, error: Error?) in
+                    if let error = error {
+                        continuation.resume(throwing: error)
+                        return
+                    }
+                    
+                    guard let samples = samples else {
+                        continuation.resume(returning: [])
+                        return
+                    }
+                    
+                    let categorySamples = samples.compactMap { sample -> CategorySample? in
+                        guard let categorySample = sample as? HKCategorySample else { return nil }
+                        return serializeCategorySample(sample: categorySample)
+                    }
+                    
+                    continuation.resume(returning: categorySamples)
+                }
+                
+                store.execute(query)
+            }
+        }
+    }
+    
+    
+    func queryCategorySamplesWithAnchor(
+        identifier: CategoryTypeIdentifier,
+        options: QueryOptionsWithAnchor
+    ) throws -> Promise<CategorySamplesWithAnchorResponse> {
+        let sampleType = try initializeCategoryType(identifier.stringValue)
+        
+        let predicate = try createPredicate(filter: options.filter)
+        let queryLimit = getQueryLimit(options.limit)
+        let queryAnchor = try deserializeHKQueryAnchor(base64String: options.anchor)
+        
+        return Promise.async {
+            try await withCheckedThrowingContinuation { continuation in
+                let query = HKAnchoredObjectQuery(
+                    type: sampleType,
+                    predicate: predicate,
+                    anchor: queryAnchor,
+                    limit: queryLimit
+                ) { (_: HKAnchoredObjectQuery, samples: [HKSample]?, deletedSamples: [HKDeletedObject]?, newAnchor: HKQueryAnchor?, error: Error?) in
+                    if let error = error {
+                        continuation.resume(throwing: error)
+                        return
+                    }
+                    
+                    guard let samples = samples else {
+                        let response = CategorySamplesWithAnchorResponse(
+                            samples: [],
+                            deletedSamples: deletedSamples?.map { serializeDeletedSample(sample: $0) } ?? [],
+                            newAnchor: serializeAnchor(anchor: newAnchor) ?? ""
+                        )
+                        continuation.resume(returning: response)
+                        return
+                    }
+                    
+                    let categorySamples = samples.compactMap { sample -> CategorySample? in
+                        guard let categorySample = sample as? HKCategorySample else { return nil }
+                        return serializeCategorySample(sample: categorySample)
+                    }
+                    
+                    let response = CategorySamplesWithAnchorResponse(
+                        samples: categorySamples,
+                        deletedSamples: deletedSamples?.map { serializeDeletedSample(sample: $0) } ?? [],
+                        newAnchor: serializeAnchor(anchor: newAnchor) ?? ""
+                    )
+                    
+                    continuation.resume(returning: response)
+                }
+                
+                store.execute(query)
+            }
+        }
+    }
+}

package/ios/CharacteristicTypeModule.swift

@@ -0,0 +1,78 @@
+
+import HealthKit
+import NitroModules
+
+class CharacteristicTypeModule: HybridCharacteristicTypeModuleSpec {
+    func getBloodTypeAsync() throws -> Promise<BloodType> {
+        return Promise.resolved(withResult: try self.getBloodType())
+    }
+    
+    func getDateOfBirthAsync() throws -> Promise<Date> {
+        return Promise.resolved(withResult: try self.getDateOfBirth())
+    }
+    
+    func getBiologicalSexAsync() throws -> Promise<BiologicalSex> {
+        return Promise.resolved(withResult: try self.getBiologicalSex())
+    }
+    
+    func getFitzpatrickSkinTypeAsync() throws -> Promise<FitzpatrickSkinType> {
+        return Promise.resolved(withResult: try self.getFitzpatrickSkinType())
+    }
+    
+    func getWheelchairUseAsync() throws -> Promise<WheelchairUse> {
+        return Promise.resolved(withResult: try self.getWheelchairUse())
+    }
+    
+    // Using the global 'store' instance defined in Auth.swift
+
+    func getBiologicalSex() throws -> BiologicalSex {
+        let biologicalSexObject = try store.biologicalSex()
+        if let biologicalSex = BiologicalSex(rawValue: Int32(biologicalSexObject.biologicalSex.rawValue)) {
+            return biologicalSex
+        }
+        throw RuntimeError.error(withMessage: "[react-native-healthkit] Got unknown biological sex value: \(biologicalSexObject.biologicalSex.rawValue)")
+    }
+
+    func getDateOfBirth() throws -> Date {
+        let dateOfBirthComponents = try store.dateOfBirthComponents()
+        
+        if let date = dateOfBirthComponents.date {
+            return date
+        }
+        
+        throw RuntimeError.error(withMessage: "[react-native-healthkit] Date of birth is not available or not set")
+    }
+
+    func getBloodType() throws -> BloodType {
+        let bloodTypeObject = try store.bloodType()
+        
+        if let bloodType = BloodType(rawValue: Int32(bloodTypeObject.bloodType.rawValue)){
+            return bloodType
+        }
+        
+        throw RuntimeError.error(withMessage: "[react-native-healthkit] Got unknown blood type value: \(bloodTypeObject.bloodType.rawValue)")
+    }
+
+    func getFitzpatrickSkinType() throws -> FitzpatrickSkinType {
+        if #available(iOS 9.0, *) {
+            let skinTypeObject = try store.fitzpatrickSkinType()
+            
+            if let skinType = FitzpatrickSkinType(rawValue: Int32(skinTypeObject.skinType.rawValue)) {
+                return skinType
+            }
+            
+            throw RuntimeError.error(withMessage: "[react-native-healthkit] Got unknown Fitzpatrick skin type value: \(skinTypeObject.skinType.rawValue)")
+        } else {
+            throw RuntimeError.error(withMessage: "Fitzpatrick skin type is not available before iOS 9.0")
+        }
+    }
+
+    @available(iOS 10.0, *)
+    func getWheelchairUse() throws -> WheelchairUse {
+        let wheelchairUseObject = try store.wheelchairUse()
+        if let wheelChairUse = WheelchairUse(rawValue: Int32(wheelchairUseObject.wheelchairUse.rawValue)) {
+            return wheelChairUse
+        }
+        throw RuntimeError.error(withMessage: "[react-native-healthkit] Got unknown wheelchair use value: \(wheelchairUseObject.wheelchairUse.rawValue)")
+    }
+}

package/ios/Constants.swift

@@ -31,3 +31,5 @@ let HKWorkoutSessionLocationTypePropertyName = "locationType"
 let SpeedUnit =  HKUnit(from: "m/s") // HKUnit.meter().unitDivided(by: HKUnit.second())
 // Support for MET data: HKAverageMETs 8.24046 kcal/hr·kg
 let METUnit = HKUnit(from: "kcal/hr·kg")
+
+let DEFAULT_QUERY_LIMIT = 20