@kingstinct/react-native-healthkit 8.7.2 → 9.0.1

package/README.md

@@ -64,60 +64,60 @@ During runtime check and request permissions with `requestAuthorization`. Failin
 
 Some hook examples:
 ```TypeScript
-import { HKQuantityTypeIdentifier, useHealthkitAuthorization } from '@kingstinct/react-native-healthkit';
+import { useHealthkitAuthorization, saveQuantitySample } from '@kingstinct/react-native-healthkit';
 
-const [authorizationStatus, requestAuthorization] = useHealthkitAuthorization([HKQuantityTypeIdentifier.bloodGlucose])
+const [authorizationStatus, requestAuthorization] = useHealthkitAuthorization(['HKQuantityTypeIdentifierBloodGlucose'])
 
 // make sure that you've requested authorization before requesting data, otherwise your app will crash
 import { useMostRecentQuantitySample, HKQuantityTypeIdentifier, useMostRecentCategorySample } from '@kingstinct/react-native-healthkit';
 
-const mostRecentBloodGlucoseSample = useMostRecentQuantitySample(HKQuantityTypeIdentifier.bloodGlucose)
-const lastBodyFatSample = useMostRecentQuantitySample(HKQuantityTypeIdentifier.bodyFatPercentage)
-const lastMindfulSession = useMostRecentCategorySample(HKCategoryTypeIdentifier.mindfulSession)
+const mostRecentBloodGlucoseSample = useMostRecentQuantitySample('HKQuantityTypeIdentifierBloodGlucose')
+const lastBodyFatSample = useMostRecentQuantitySample('HKQuantityTypeIdentifierBodyFatPercentage')
+const lastMindfulSession = useMostRecentCategorySample('HKCategoryTypeIdentifierMindfulSession')
 const lastWorkout = useMostRecentWorkout()
 ```
 
 Some imperative examples:
 ```TypeScript
-  import HealthKit, { HKUnit, HKQuantityTypeIdentifier, HKInsulinDeliveryReason, HKCategoryTypeIdentifier } from '@kingstinct/react-native-healthkit';
+  import { isHealthDataAvailable, requestAuthorization, subscribeToChanges, saveQuantitySample, getMostRecentQuantitySample } from '@kingstinct/react-native-healthkit';
 
-  const isAvailable = await HealthKit.isHealthDataAvailable();
+  const isAvailable = await isHealthDataAvailable();
 
   /* Read latest sample of any data */
-  await HealthKit.requestAuthorization([HKQuantityTypeIdentifier.bodyFatPercentage]); // request read permission for bodyFatPercentage
+  await requestAuthorization(['HKQuantityTypeIdentifierBodyFatPercentage']); // request read permission for bodyFatPercentage
 
-  const { quantity, unit, startDate, endDate } = await HealthKit.getMostRecentQuantitySample(HKQuantityTypeIdentifier.bodyFatPercentage); // read latest sample
+  const { quantity, unit, startDate, endDate } = await getMostRecentQuantitySample('HKQuantityTypeIdentifierBodyFatPercentage'); // read latest sample
   
   console.log(quantity) // 17.5
   console.log(unit) // %
 
-  await HealthKit.requestAuthorization([HKQuantityTypeIdentifier.heartRate]); // request read permission for heart rate
+  await requestAuthorization(['HKQuantityTypeIdentifierHeartRate']); // request read permission for heart rate
 
   /* Subscribe to data (Make sure to request permissions before subscribing to changes) */
   const [hasRequestedAuthorization, setHasRequestedAuthorization] = useState(false);
   
   useEffect(() => {
-    HealthKit.requestAuthorization([HKQuantityTypeIdentifier.heartRate]).then(() => {
+    requestAuthorization(['HKQuantityTypeIdentifierHeartRate']).then(() => {
       setHasRequestedAuthorization(true);
     });
   }, []);
   
   useEffect(() => {
     if (hasRequestedAuthorization) {
-      const unsubscribe = HealthKit.subscribeToChanges(HKQuantityTypeIdentifier.heartRate, () => {
+      const unsubscribe = subscribeToChanges(HKQuantityTypeIdentifier.heartRate, () => {
         // refetch data as needed
       });
-    }
 
-    return () => unsubscribe();
+      return () => unsubscribe();
+    }
   }, [hasRequestedAuthorization]);
 
   /* write data */
-  await HealthKit.requestAuthorization([], [HKQuantityTypeIdentifier.insulinDelivery]); // request write permission for insulin delivery
+  await requestAuthorization([], [HKQuantityTypeIdentifier.insulinDelivery]); // request write permission for insulin delivery
 
-  ReactNativeHealthkit.saveQuantitySample(
-      HKQuantityTypeIdentifier.insulinDelivery,
-      HKUnit.InternationalUnit,
+  saveQuantitySample(
+      'HKQuantityTypeIdentifierInsulinDelivery',
+      'IU',
       5.5,
       {
         metadata: {
@@ -130,7 +130,7 @@ Some imperative examples:
     );
 ```
 
-### HealthKit Anchors (breaking change in 6.0)
+### HealthKit Anchors
 In 6.0 you can use HealthKit anchors to get changes and deleted items which is very useful for syncing. This is a breaking change - but a very easy one to handle that TypeScript should help you with. Most queries now return an object containing samples which is what was returned as only an array before. 
 
 ```newAnchor``` is a base64-encoded string returned from HealthKit that contain sync information.  After each successful sync, store the anchor for the next time your anchor query is called to only return the values that have changed.
@@ -140,11 +140,11 @@ In 6.0 you can use HealthKit anchors to get changes and deleted items which is v
 Example:
 
 ```TypeScript
-  const { newAnchor, samples, deletedSamples } = await queryQuantitySamplesWithAnchor(HKQuantityTypeIdentifier.stepCount, {
+  const { newAnchor, samples, deletedSamples } = await queryQuantitySamplesWithAnchor('HKQuantityTypeIdentifierStepCount', {
     limit: 2,
   })
 
-  const nextResult = await queryQuantitySamplesWithAnchor(HKQuantityTypeIdentifier.stepCount, {
+  const nextResult = await queryQuantitySamplesWithAnchor('HKQuantityTypeIdentifierStepCount', {
     limit: 2,
     anchor: newAnchor,
   })
@@ -152,6 +152,18 @@ Example:
   // etc..
 ```
 
+## Migration to 9.0.0
+
+There are a lot of under-the-hood changes in version 9.0.0, some of them are breaking (although I've tried to reduce it as much as possible).
+- Most of all - the library has been migrated to use react-native-nitro-modules. This improves performance, type-safety and gets rid of a lot of boilerplate code that made it harder to maintain and add features to the library.
+- Naming conventions have changed - most of the HK-prefixed stuff has been removed to avoid conflicts on the native side and also make the library more beautiful to look at. As an example the type previously called HKQuantityTypeIdentifier is not just QuantityTypeIdentifier on the library level.
+- Less required params by default - making it easier to start using the library, for example calling `queryQuantitySamples('HKQuantityTypeIdentifierStepCount')` will simply return the last 20 samples.
+- Flexible filters that map closer to the native constructs. This can easily be extended.
+- `deleteObjects` replaces all previous deletion methods, using the new flexible filters.
+- Workouts are returned as proxies containing not only data but also functions, for example `getWorkoutRoutes`.
+- Identifiers are now just strings, and more strictly typed.
+- Units are now just strings.
+
 ## A note on Apple Documentation
 
 We're striving to do as straight a mapping as possible to the Native Libraries. This means that in most cases the Apple Documentation makes sense. However, when it comes to the Healthkit [Metadata Keys](https://developer.apple.com/documentation/healthkit/samples/metadata_keys) the documentation doesn't actually reflect the serialized values. For example HKMetadataKeyExternalUUID in the documentation serializes to HKExternalUUID - which is what we use.
@@ -177,3 +189,4 @@ At Kingstinct we're also able to provide enterprise-grade support for this packa
 ## License
 
 MIT
+

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