@appeeky/expo-healthkit 0.1.0

package/android/src/main/java/expo/modules/healthkit/ExpoHealthKitModule.kt

@@ -0,0 +1,228 @@
+package expo.modules.healthkit
+
+import android.app.Activity
+import android.content.Intent
+import androidx.activity.result.contract.ActivityResultContracts.RequestMultiplePermissions
+import androidx.health.connect.client.PermissionController
+import expo.modules.interfaces.permissions.PermissionsStatus
+import expo.modules.kotlin.functions.Coroutine
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import kotlinx.coroutines.CancellableContinuation
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlinx.coroutines.withContext
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
+
+class ExpoHealthKitModule : Module() {
+  private lateinit var service: HealthConnectService
+  private var permissionContinuation: CancellableContinuation<Set<String>>? = null
+  private val permissionContract = PermissionController.createRequestPermissionResultContract()
+
+  override fun definition() = ModuleDefinition {
+    Name("ExpoHealthKit")
+
+    Events("onUpdate")
+
+    OnCreate {
+      val context = appContext.reactContext ?: appContext.throwingActivity.applicationContext
+      service = HealthConnectService(context) { permissions ->
+        requestHealthPermissions(permissions)
+      }
+    }
+
+    OnActivityResult { _, payload ->
+      if (payload.requestCode != REQUEST_PERMISSIONS) {
+        return@OnActivityResult
+      }
+      val granted = permissionContract.parseResult(payload.resultCode, payload.data)
+      val continuation = permissionContinuation
+      permissionContinuation = null
+      continuation?.resume(granted)
+    }
+
+    Function("isHealthDataAvailable") {
+      HealthConnectService.isAvailable(appContext.reactContext)
+    }
+
+    AsyncFunction("requestAuthorization") Coroutine { options: Map<String, Any?> ->
+      service.requestAuthorization(options)
+    }
+
+    AsyncFunction("getAuthorizationStatus") Coroutine { identifier: String ->
+      service.authorizationStatus(identifier)
+    }
+
+    AsyncFunction("getRequestStatusForAuthorization") Coroutine { options: Map<String, Any?> ->
+      service.requestStatusForAuthorization(options)
+    }
+
+    AsyncFunction("queryQuantitySamples") Coroutine { options: Map<String, Any?> ->
+      service.queryQuantitySamples(options)
+    }
+
+    AsyncFunction("queryCategorySamples") Coroutine { options: Map<String, Any?> ->
+      service.queryCategorySamples(options)
+    }
+
+    AsyncFunction("queryWorkouts") Coroutine { options: Map<String, Any?> ->
+      service.queryWorkouts(options)
+    }
+
+    AsyncFunction("queryElectrocardiograms") { _: Map<String, Any?> ->
+      service.unsupported("Electrocardiograms")
+    }
+
+    AsyncFunction("queryActivitySummaries") { _: Map<String, Any?> ->
+      service.unsupported("Activity rings")
+    }
+
+    AsyncFunction("queryClinicalRecords") { _: Map<String, Any?> ->
+      service.unsupported("Clinical records")
+    }
+
+    AsyncFunction("queryAudiograms") { _: Map<String, Any?> ->
+      service.unsupported("Audiograms")
+    }
+
+    AsyncFunction("queryWorkoutRoute") { _: Map<String, Any?> ->
+      service.unsupported("Workout GPS routes")
+    }
+
+    AsyncFunction("queryCorrelations") Coroutine { options: Map<String, Any?> ->
+      service.queryCorrelations(options)
+    }
+
+    AsyncFunction("queryHeartbeatSeries") { _: Map<String, Any?> ->
+      service.unsupported("Heartbeat series")
+    }
+
+    AsyncFunction("queryStatistics") Coroutine { options: Map<String, Any?> ->
+      service.queryStatistics(options)
+    }
+
+    AsyncFunction("queryStatisticsCollection") Coroutine { options: Map<String, Any?> ->
+      service.queryStatisticsCollection(options)
+    }
+
+    AsyncFunction("queryAnchored") Coroutine { options: Map<String, Any?> ->
+      service.queryAnchored(options)
+    }
+
+    AsyncFunction("saveQuantitySample") Coroutine { sample: Map<String, Any?> ->
+      service.saveQuantitySample(sample)
+    }
+
+    AsyncFunction("saveCategorySample") Coroutine { sample: Map<String, Any?> ->
+      service.saveCategorySample(sample)
+    }
+
+    AsyncFunction("saveWorkout") Coroutine { workout: Map<String, Any?> ->
+      service.saveWorkout(workout)
+    }
+
+    AsyncFunction("saveCorrelation") Coroutine { correlation: Map<String, Any?> ->
+      service.saveCorrelation(correlation)
+    }
+
+    AsyncFunction("deleteObjects") Coroutine { options: Map<String, Any?> ->
+      service.deleteObjects(options)
+    }
+
+    AsyncFunction("getBiologicalSex") {
+      service.unsupported("Biological sex")
+    }
+
+    AsyncFunction("getBloodType") {
+      service.unsupported("Blood type")
+    }
+
+    AsyncFunction("getDateOfBirth") {
+      service.unsupported("Date of birth")
+    }
+
+    AsyncFunction("getFitzpatrickSkinType") {
+      service.unsupported("Fitzpatrick skin type")
+    }
+
+    AsyncFunction("getWheelchairUse") {
+      service.unsupported("Wheelchair use")
+    }
+
+    AsyncFunction("enableBackgroundDelivery") { _: String, _: Int ->
+      service.unsupported("Background delivery")
+    }
+
+    AsyncFunction("disableBackgroundDelivery") { _: String ->
+      service.unsupported("Background delivery")
+    }
+
+    AsyncFunction("disableAllBackgroundDelivery") {
+      service.unsupported("Background delivery")
+    }
+
+    AsyncFunction("observeTypes") { _: List<String> ->
+      service.unsupported("Observer queries")
+    }
+
+    AsyncFunction("clearObserverQueries") {
+      Unit
+    }
+  }
+
+  private suspend fun requestHealthPermissions(permissions: Set<String>): Set<String> {
+    val activity: Activity = appContext.throwingActivity
+    val intent = permissionContract.createIntent(activity, permissions)
+    return withContext(Dispatchers.Main) {
+      if (intent.action == RequestMultiplePermissions.ACTION_REQUEST_PERMISSIONS) {
+        val platformPermissions =
+          intent.getStringArrayExtra(RequestMultiplePermissions.EXTRA_PERMISSIONS)?.toSet()
+            ?: permissions
+        requestPlatformPermissions(platformPermissions)
+      } else {
+        requestHealthConnectActivityPermissions(activity, intent)
+      }
+    }
+  }
+
+  private suspend fun requestPlatformPermissions(permissions: Set<String>): Set<String> {
+    val manager = appContext.permissions ?: throw HealthKitUnavailableException()
+    return suspendCancellableCoroutine { continuation ->
+      manager.askForPermissions(
+        { responses ->
+          if (continuation.isActive) {
+            continuation.resume(
+              responses.filter { it.value.status == PermissionsStatus.GRANTED }.keys.toSet()
+            )
+          }
+        },
+        *permissions.toTypedArray()
+      )
+    }
+  }
+
+  private suspend fun requestHealthConnectActivityPermissions(
+    activity: Activity,
+    intent: Intent
+  ): Set<String> =
+    suspendCancellableCoroutine { continuation ->
+      permissionContinuation?.cancel()
+      permissionContinuation = continuation
+      continuation.invokeOnCancellation {
+        if (permissionContinuation === continuation) {
+          permissionContinuation = null
+        }
+      }
+      try {
+        activity.startActivityForResult(intent, REQUEST_PERMISSIONS)
+      } catch (error: Exception) {
+        permissionContinuation = null
+        continuation.resumeWithException(error)
+      }
+    }
+
+  companion object {
+    private const val REQUEST_PERMISSIONS = 0x484B
+  }
+}

package/android/src/main/java/expo/modules/healthkit/HealthConnectMapping.kt

@@ -0,0 +1,129 @@
+package expo.modules.healthkit
+
+import androidx.health.connect.client.permission.HealthPermission
+import androidx.health.connect.client.records.ActiveCaloriesBurnedRecord
+import androidx.health.connect.client.records.BloodGlucoseRecord
+import androidx.health.connect.client.records.BloodPressureRecord
+import androidx.health.connect.client.records.BodyFatRecord
+import androidx.health.connect.client.records.BodyTemperatureRecord
+import androidx.health.connect.client.records.DistanceRecord
+import androidx.health.connect.client.records.ExerciseSessionRecord
+import androidx.health.connect.client.records.FloorsClimbedRecord
+import androidx.health.connect.client.records.HeartRateRecord
+import androidx.health.connect.client.records.HeartRateVariabilityRmssdRecord
+import androidx.health.connect.client.records.HeightRecord
+import androidx.health.connect.client.records.HydrationRecord
+import androidx.health.connect.client.records.LeanBodyMassRecord
+import androidx.health.connect.client.records.NutritionRecord
+import androidx.health.connect.client.records.OxygenSaturationRecord
+import androidx.health.connect.client.records.Record
+import androidx.health.connect.client.records.RespiratoryRateRecord
+import androidx.health.connect.client.records.RestingHeartRateRecord
+import androidx.health.connect.client.records.SleepSessionRecord
+import androidx.health.connect.client.records.StepsRecord
+import androidx.health.connect.client.records.TotalCaloriesBurnedRecord
+import androidx.health.connect.client.records.Vo2MaxRecord
+import androidx.health.connect.client.records.WeightRecord
+import androidx.health.connect.client.records.WheelchairPushesRecord
+import kotlin.reflect.KClass
+
+internal object HealthConnectMapping {
+  const val STEPS = "HKQuantityTypeIdentifierStepCount"
+  const val DISTANCE_WALKING = "HKQuantityTypeIdentifierDistanceWalkingRunning"
+  const val DISTANCE_CYCLING = "HKQuantityTypeIdentifierDistanceCycling"
+  const val DISTANCE_SWIMMING = "HKQuantityTypeIdentifierDistanceSwimming"
+  const val DISTANCE_WHEELCHAIR = "HKQuantityTypeIdentifierDistanceWheelchair"
+  const val ACTIVE_ENERGY = "HKQuantityTypeIdentifierActiveEnergyBurned"
+  const val BASAL_ENERGY = "HKQuantityTypeIdentifierBasalEnergyBurned"
+  const val FLOORS = "HKQuantityTypeIdentifierFlightsClimbed"
+  const val PUSH_COUNT = "HKQuantityTypeIdentifierPushCount"
+  const val VO2_MAX = "HKQuantityTypeIdentifierVO2Max"
+  const val HEART_RATE = "HKQuantityTypeIdentifierHeartRate"
+  const val RESTING_HEART_RATE = "HKQuantityTypeIdentifierRestingHeartRate"
+  const val HRV = "HKQuantityTypeIdentifierHeartRateVariabilitySDNN"
+  const val OXYGEN = "HKQuantityTypeIdentifierOxygenSaturation"
+  const val RESPIRATORY = "HKQuantityTypeIdentifierRespiratoryRate"
+  const val BODY_TEMP = "HKQuantityTypeIdentifierBodyTemperature"
+  const val GLUCOSE = "HKQuantityTypeIdentifierBloodGlucose"
+  const val SYSTOLIC = "HKQuantityTypeIdentifierBloodPressureSystolic"
+  const val DIASTOLIC = "HKQuantityTypeIdentifierBloodPressureDiastolic"
+  const val HEIGHT = "HKQuantityTypeIdentifierHeight"
+  const val WEIGHT = "HKQuantityTypeIdentifierBodyMass"
+  const val LEAN_MASS = "HKQuantityTypeIdentifierLeanBodyMass"
+  const val BODY_FAT = "HKQuantityTypeIdentifierBodyFatPercentage"
+  const val WATER = "HKQuantityTypeIdentifierDietaryWater"
+  const val SLEEP = "HKCategoryTypeIdentifierSleepAnalysis"
+  const val WORKOUT = "HKWorkoutTypeIdentifier"
+  const val BLOOD_PRESSURE = "HKCorrelationTypeIdentifierBloodPressure"
+  const val FOOD = "HKCorrelationTypeIdentifierFood"
+
+  fun recordClass(identifier: String): KClass<out Record>? = when (identifier) {
+    STEPS -> StepsRecord::class
+    DISTANCE_WALKING, DISTANCE_CYCLING, DISTANCE_SWIMMING, DISTANCE_WHEELCHAIR -> DistanceRecord::class
+    ACTIVE_ENERGY -> ActiveCaloriesBurnedRecord::class
+    BASAL_ENERGY -> TotalCaloriesBurnedRecord::class
+    FLOORS -> FloorsClimbedRecord::class
+    PUSH_COUNT -> WheelchairPushesRecord::class
+    VO2_MAX -> Vo2MaxRecord::class
+    HEART_RATE -> HeartRateRecord::class
+    RESTING_HEART_RATE -> RestingHeartRateRecord::class
+    HRV -> HeartRateVariabilityRmssdRecord::class
+    OXYGEN -> OxygenSaturationRecord::class
+    RESPIRATORY -> RespiratoryRateRecord::class
+    BODY_TEMP -> BodyTemperatureRecord::class
+    GLUCOSE -> BloodGlucoseRecord::class
+    SYSTOLIC, DIASTOLIC, BLOOD_PRESSURE -> BloodPressureRecord::class
+    HEIGHT -> HeightRecord::class
+    WEIGHT -> WeightRecord::class
+    LEAN_MASS -> LeanBodyMassRecord::class
+    BODY_FAT -> BodyFatRecord::class
+    WATER -> HydrationRecord::class
+    SLEEP -> SleepSessionRecord::class
+    WORKOUT -> ExerciseSessionRecord::class
+    FOOD -> NutritionRecord::class
+    else -> if (isDietary(identifier)) NutritionRecord::class else null
+  }
+
+  fun extraRecordClasses(identifier: String): List<KClass<out Record>> =
+    if (identifier == BASAL_ENERGY) listOf(ActiveCaloriesBurnedRecord::class) else emptyList()
+
+  fun permissions(identifiers: List<String>, write: Boolean): Set<String> {
+    val classes = linkedSetOf<KClass<out Record>>()
+    for (identifier in identifiers) {
+      val primary = recordClass(identifier) ?: continue
+      classes += primary
+      classes += extraRecordClasses(identifier)
+    }
+    return classes.mapTo(mutableSetOf()) { record ->
+      if (write) HealthPermission.getWritePermission(record) else HealthPermission.getReadPermission(record)
+    }
+  }
+
+  fun quantityKind(identifier: String): QuantityKind = when (identifier) {
+    STEPS, PUSH_COUNT, FLOORS -> if (identifier == FLOORS) QuantityKind.FLOORS else QuantityKind.COUNT
+    HEART_RATE, RESTING_HEART_RATE -> QuantityKind.BPM
+    HRV -> QuantityKind.HRV
+    VO2_MAX -> QuantityKind.VO2
+    ACTIVE_ENERGY, BASAL_ENERGY, DIETARY_ENERGY -> QuantityKind.ENERGY
+    OXYGEN, BODY_FAT -> QuantityKind.PERCENT
+    RESPIRATORY -> QuantityKind.COUNT
+    BODY_TEMP -> QuantityKind.TEMPERATURE
+    GLUCOSE -> QuantityKind.GLUCOSE
+    SYSTOLIC, DIASTOLIC -> QuantityKind.PRESSURE
+    HEIGHT, DISTANCE_WALKING, DISTANCE_CYCLING, DISTANCE_SWIMMING, DISTANCE_WHEELCHAIR -> QuantityKind.LENGTH
+    WEIGHT, LEAN_MASS -> QuantityKind.MASS
+    WATER -> QuantityKind.VOLUME
+    else -> if (identifier == DIETARY_ENERGY) QuantityKind.ENERGY else if (isDietary(identifier)) QuantityKind.MASS else QuantityKind.COUNT
+  }
+
+  fun isCumulative(identifier: String): Boolean = when (identifier) {
+    STEPS, DISTANCE_WALKING, DISTANCE_CYCLING, DISTANCE_SWIMMING, DISTANCE_WHEELCHAIR,
+    ACTIVE_ENERGY, BASAL_ENERGY, FLOORS, PUSH_COUNT, WATER -> true
+    else -> isDietary(identifier)
+  }
+
+  fun isDietary(identifier: String): Boolean =
+    identifier.startsWith("HKQuantityTypeIdentifierDietary")
+
+  const val DIETARY_ENERGY = "HKQuantityTypeIdentifierDietaryEnergyConsumed"
+}

package/android/src/main/java/expo/modules/healthkit/HealthConnectNutrition.kt

@@ -0,0 +1,152 @@
+package expo.modules.healthkit
+
+import androidx.health.connect.client.records.NutritionRecord
+import androidx.health.connect.client.records.metadata.Metadata
+import androidx.health.connect.client.units.Energy
+import androidx.health.connect.client.units.Mass
+import java.time.Instant
+import java.time.ZoneOffset
+
+internal object HealthConnectNutrition {
+  fun canonicalValue(record: NutritionRecord, identifier: String): Double? = when (identifier) {
+    HealthConnectMapping.DIETARY_ENERGY -> record.energy?.inKilocalories
+    "HKQuantityTypeIdentifierDietaryProtein" -> record.protein?.inKilograms
+    "HKQuantityTypeIdentifierDietaryCarbohydrates" -> record.totalCarbohydrate?.inKilograms
+    "HKQuantityTypeIdentifierDietaryFatTotal" -> record.totalFat?.inKilograms
+    "HKQuantityTypeIdentifierDietaryFatSaturated" -> record.saturatedFat?.inKilograms
+    "HKQuantityTypeIdentifierDietaryFatMonounsaturated" -> record.monounsaturatedFat?.inKilograms
+    "HKQuantityTypeIdentifierDietaryFatPolyunsaturated" -> record.polyunsaturatedFat?.inKilograms
+    "HKQuantityTypeIdentifierDietaryCholesterol" -> record.cholesterol?.inKilograms
+    "HKQuantityTypeIdentifierDietarySodium" -> record.sodium?.inKilograms
+    "HKQuantityTypeIdentifierDietarySugar" -> record.sugar?.inKilograms
+    "HKQuantityTypeIdentifierDietaryFiber" -> record.dietaryFiber?.inKilograms
+    "HKQuantityTypeIdentifierDietaryCaffeine" -> record.caffeine?.inKilograms
+    "HKQuantityTypeIdentifierDietaryCalcium" -> record.calcium?.inKilograms
+    "HKQuantityTypeIdentifierDietaryIron" -> record.iron?.inKilograms
+    "HKQuantityTypeIdentifierDietaryPotassium" -> record.potassium?.inKilograms
+    "HKQuantityTypeIdentifierDietaryVitaminA" -> record.vitaminA?.inKilograms
+    "HKQuantityTypeIdentifierDietaryVitaminC" -> record.vitaminC?.inKilograms
+    "HKQuantityTypeIdentifierDietaryVitaminD" -> record.vitaminD?.inKilograms
+    "HKQuantityTypeIdentifierDietaryVitaminE" -> record.vitaminE?.inKilograms
+    "HKQuantityTypeIdentifierDietaryVitaminK" -> record.vitaminK?.inKilograms
+    "HKQuantityTypeIdentifierDietaryVitaminB6" -> record.vitaminB6?.inKilograms
+    "HKQuantityTypeIdentifierDietaryVitaminB12" -> record.vitaminB12?.inKilograms
+    "HKQuantityTypeIdentifierDietaryFolate" -> record.folate?.inKilograms
+    "HKQuantityTypeIdentifierDietaryNiacin" -> record.niacin?.inKilograms
+    "HKQuantityTypeIdentifierDietaryRiboflavin" -> record.riboflavin?.inKilograms
+    "HKQuantityTypeIdentifierDietaryThiamin" -> record.thiamin?.inKilograms
+    "HKQuantityTypeIdentifierDietaryMagnesium" -> record.magnesium?.inKilograms
+    "HKQuantityTypeIdentifierDietaryManganese" -> record.manganese?.inKilograms
+    "HKQuantityTypeIdentifierDietaryPhosphorus" -> record.phosphorus?.inKilograms
+    "HKQuantityTypeIdentifierDietarySelenium" -> record.selenium?.inKilograms
+    "HKQuantityTypeIdentifierDietaryZinc" -> record.zinc?.inKilograms
+    "HKQuantityTypeIdentifierDietaryIodine" -> record.iodine?.inKilograms
+    "HKQuantityTypeIdentifierDietaryChloride" -> record.chloride?.inKilograms
+    "HKQuantityTypeIdentifierDietaryBiotin" -> record.biotin?.inKilograms
+    "HKQuantityTypeIdentifierDietaryPantothenicAcid" -> record.pantothenicAcid?.inKilograms
+    "HKQuantityTypeIdentifierDietaryMolybdenum" -> record.molybdenum?.inKilograms
+    "HKQuantityTypeIdentifierDietaryCopper" -> record.copper?.inKilograms
+    "HKQuantityTypeIdentifierDietaryChromium" -> record.chromium?.inKilograms
+    else -> null
+  }
+
+  fun presentFields(record: NutritionRecord): List<Pair<String, Double>> {
+    val identifiers = listOf(
+      HealthConnectMapping.DIETARY_ENERGY,
+      "HKQuantityTypeIdentifierDietaryProtein",
+      "HKQuantityTypeIdentifierDietaryCarbohydrates",
+      "HKQuantityTypeIdentifierDietaryFatTotal",
+      "HKQuantityTypeIdentifierDietaryFatSaturated",
+      "HKQuantityTypeIdentifierDietaryFatMonounsaturated",
+      "HKQuantityTypeIdentifierDietaryFatPolyunsaturated",
+      "HKQuantityTypeIdentifierDietaryCholesterol",
+      "HKQuantityTypeIdentifierDietarySodium",
+      "HKQuantityTypeIdentifierDietarySugar",
+      "HKQuantityTypeIdentifierDietaryFiber",
+      "HKQuantityTypeIdentifierDietaryCaffeine",
+      "HKQuantityTypeIdentifierDietaryCalcium",
+      "HKQuantityTypeIdentifierDietaryIron",
+      "HKQuantityTypeIdentifierDietaryPotassium",
+      "HKQuantityTypeIdentifierDietaryVitaminA",
+      "HKQuantityTypeIdentifierDietaryVitaminC",
+      "HKQuantityTypeIdentifierDietaryVitaminD",
+      "HKQuantityTypeIdentifierDietaryVitaminE",
+      "HKQuantityTypeIdentifierDietaryVitaminK",
+      "HKQuantityTypeIdentifierDietaryVitaminB6",
+      "HKQuantityTypeIdentifierDietaryVitaminB12",
+      "HKQuantityTypeIdentifierDietaryFolate",
+      "HKQuantityTypeIdentifierDietaryNiacin",
+      "HKQuantityTypeIdentifierDietaryRiboflavin",
+      "HKQuantityTypeIdentifierDietaryThiamin",
+      "HKQuantityTypeIdentifierDietaryMagnesium",
+      "HKQuantityTypeIdentifierDietaryManganese",
+      "HKQuantityTypeIdentifierDietaryPhosphorus",
+      "HKQuantityTypeIdentifierDietarySelenium",
+      "HKQuantityTypeIdentifierDietaryZinc",
+      "HKQuantityTypeIdentifierDietaryIodine",
+      "HKQuantityTypeIdentifierDietaryChloride",
+      "HKQuantityTypeIdentifierDietaryBiotin",
+      "HKQuantityTypeIdentifierDietaryPantothenicAcid",
+      "HKQuantityTypeIdentifierDietaryMolybdenum",
+      "HKQuantityTypeIdentifierDietaryCopper",
+      "HKQuantityTypeIdentifierDietaryChromium"
+    )
+    return identifiers.mapNotNull { id -> canonicalValue(record, id)?.let { id to it } }
+  }
+
+  fun build(
+    start: Instant,
+    end: Instant,
+    startOffset: ZoneOffset?,
+    endOffset: ZoneOffset?,
+    metadata: Metadata,
+    values: Map<String, Double>
+  ): NutritionRecord {
+    fun mass(id: String) = values[id]?.let { Mass.kilograms(it) }
+    return NutritionRecord(
+      startTime = start,
+      startZoneOffset = startOffset,
+      endTime = end,
+      endZoneOffset = endOffset,
+      energy = values[HealthConnectMapping.DIETARY_ENERGY]?.let { Energy.kilocalories(it) },
+      protein = mass("HKQuantityTypeIdentifierDietaryProtein"),
+      totalCarbohydrate = mass("HKQuantityTypeIdentifierDietaryCarbohydrates"),
+      totalFat = mass("HKQuantityTypeIdentifierDietaryFatTotal"),
+      saturatedFat = mass("HKQuantityTypeIdentifierDietaryFatSaturated"),
+      monounsaturatedFat = mass("HKQuantityTypeIdentifierDietaryFatMonounsaturated"),
+      polyunsaturatedFat = mass("HKQuantityTypeIdentifierDietaryFatPolyunsaturated"),
+      cholesterol = mass("HKQuantityTypeIdentifierDietaryCholesterol"),
+      sodium = mass("HKQuantityTypeIdentifierDietarySodium"),
+      sugar = mass("HKQuantityTypeIdentifierDietarySugar"),
+      dietaryFiber = mass("HKQuantityTypeIdentifierDietaryFiber"),
+      caffeine = mass("HKQuantityTypeIdentifierDietaryCaffeine"),
+      calcium = mass("HKQuantityTypeIdentifierDietaryCalcium"),
+      iron = mass("HKQuantityTypeIdentifierDietaryIron"),
+      potassium = mass("HKQuantityTypeIdentifierDietaryPotassium"),
+      vitaminA = mass("HKQuantityTypeIdentifierDietaryVitaminA"),
+      vitaminC = mass("HKQuantityTypeIdentifierDietaryVitaminC"),
+      vitaminD = mass("HKQuantityTypeIdentifierDietaryVitaminD"),
+      vitaminE = mass("HKQuantityTypeIdentifierDietaryVitaminE"),
+      vitaminK = mass("HKQuantityTypeIdentifierDietaryVitaminK"),
+      vitaminB6 = mass("HKQuantityTypeIdentifierDietaryVitaminB6"),
+      vitaminB12 = mass("HKQuantityTypeIdentifierDietaryVitaminB12"),
+      folate = mass("HKQuantityTypeIdentifierDietaryFolate"),
+      niacin = mass("HKQuantityTypeIdentifierDietaryNiacin"),
+      riboflavin = mass("HKQuantityTypeIdentifierDietaryRiboflavin"),
+      thiamin = mass("HKQuantityTypeIdentifierDietaryThiamin"),
+      magnesium = mass("HKQuantityTypeIdentifierDietaryMagnesium"),
+      manganese = mass("HKQuantityTypeIdentifierDietaryManganese"),
+      phosphorus = mass("HKQuantityTypeIdentifierDietaryPhosphorus"),
+      selenium = mass("HKQuantityTypeIdentifierDietarySelenium"),
+      zinc = mass("HKQuantityTypeIdentifierDietaryZinc"),
+      iodine = mass("HKQuantityTypeIdentifierDietaryIodine"),
+      chloride = mass("HKQuantityTypeIdentifierDietaryChloride"),
+      biotin = mass("HKQuantityTypeIdentifierDietaryBiotin"),
+      pantothenicAcid = mass("HKQuantityTypeIdentifierDietaryPantothenicAcid"),
+      molybdenum = mass("HKQuantityTypeIdentifierDietaryMolybdenum"),
+      copper = mass("HKQuantityTypeIdentifierDietaryCopper"),
+      chromium = mass("HKQuantityTypeIdentifierDietaryChromium"),
+      metadata = metadata
+    )
+  }
+}

package/android/src/main/java/expo/modules/healthkit/HealthConnectRationaleActivity.kt

@@ -0,0 +1,62 @@
+package expo.modules.healthkit
+
+import android.app.Activity
+import android.content.Intent
+import android.net.Uri
+import android.os.Bundle
+import android.widget.Button
+import android.widget.LinearLayout
+import android.widget.TextView
+
+class HealthConnectRationaleActivity : Activity() {
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+
+    val padding = (20 * resources.displayMetrics.density).toInt()
+    val layout = LinearLayout(this).apply {
+      orientation = LinearLayout.VERTICAL
+      setPadding(padding, padding, padding, padding)
+    }
+
+    val title = TextView(this).apply {
+      text = "Health Connect"
+      textSize = 20f
+    }
+    val body = TextView(this).apply {
+      text =
+        "This app reads and writes the health types you approve on the Health Connect permission screen. Data stays on the device unless the app uploads it."
+      textSize = 16f
+    }
+    layout.addView(title)
+    layout.addView(body)
+
+    val privacyUrl = privacyPolicyUrl()
+    if (!privacyUrl.isNullOrBlank()) {
+      val privacy = Button(this).apply {
+        text = "Privacy policy"
+        setOnClickListener {
+          startActivity(Intent(Intent.ACTION_VIEW, Uri.parse(privacyUrl)))
+        }
+      }
+      layout.addView(privacy)
+    }
+
+    val close = Button(this).apply {
+      text = "Close"
+      setOnClickListener { finish() }
+    }
+    layout.addView(close)
+    setContentView(layout)
+  }
+
+  private fun privacyPolicyUrl(): String? = try {
+    val appInfo = packageManager.getApplicationInfo(packageName, android.content.pm.PackageManager.GET_META_DATA)
+    appInfo.metaData?.getString(META_PRIVACY_POLICY)
+  } catch (_: Exception) {
+    null
+  }
+
+  companion object {
+    const val META_PRIVACY_POLICY = "expo.modules.healthkit.HEALTH_CONNECT_PRIVACY_POLICY_URL"
+  }
+}