@tryterra/react-native 0.0.0-stage → 2.2.1

package/android/src/bridgeCore/kotlin/co/tryterra/sdk/bridge/Conversions.kt

@@ -0,0 +1,557 @@
+package co.tryterra.sdk.bridge
+
+import co.tryterra.sdk.DataCategory
+import co.tryterra.sdk.DietaryQuantity
+import co.tryterra.sdk.MealSample
+import co.tryterra.sdk.MenstruationFlowDay
+import co.tryterra.sdk.MenstruationFlowSample
+import co.tryterra.sdk.Nutrient
+import co.tryterra.sdk.EndUser
+import co.tryterra.sdk.BodyEntry
+import co.tryterra.sdk.HeartRateEntry
+import co.tryterra.sdk.NutritionEntry
+import co.tryterra.sdk.HeartRateSample
+import co.tryterra.sdk.PermissionStatus
+import co.tryterra.sdk.RecordId
+import co.tryterra.sdk.SampleInterval
+import co.tryterra.sdk.SampleSource
+import co.tryterra.sdk.SleepEntry
+import co.tryterra.sdk.SleepSegment
+import co.tryterra.sdk.SleepStage
+import co.tryterra.sdk.Source
+import co.tryterra.sdk.StepCount
+import co.tryterra.sdk.StepEntry
+import co.tryterra.sdk.TimeRange
+import co.tryterra.sdk.Workout
+import co.tryterra.sdk.WorkoutActivity
+import co.tryterra.sdk.WorkoutEntry
+import co.tryterra.sdk.WorkoutScope
+import co.tryterra.sdk.bridge.generated.BridgeInstant
+import co.tryterra.sdk.bridge.generated.BridgeError
+import co.tryterra.sdk.diagnostics.BackgroundRestrictionReason
+import co.tryterra.sdk.diagnostics.DiagnosticsState
+import co.tryterra.sdk.diagnostics.DiagnosticsWire
+import co.tryterra.sdk.diagnostics.SupportReport
+import co.tryterra.sdk.diagnostics.TerraEvent
+import co.tryterra.sdk.health.HealthAccess
+import co.tryterra.sdk.HealthChange
+import co.tryterra.sdk.store.StoredConnection
+import java.time.ZoneId
+import co.tryterra.sdk.bridge.generated.BackgroundRestrictionReason as WireRestriction
+import co.tryterra.sdk.bridge.generated.BodyEntry as WireBodyEntry
+import co.tryterra.sdk.bridge.generated.Connection as WireConnection
+import co.tryterra.sdk.bridge.generated.NutritionEntry as WireNutritionEntry
+import co.tryterra.sdk.bridge.generated.Nutrients as WireNutrients
+import co.tryterra.sdk.bridge.generated.DataCategory as WireCategory
+import co.tryterra.sdk.bridge.generated.DietaryQuantity as WireDietaryQuantity
+import co.tryterra.sdk.bridge.generated.MealType as WireMealType
+import co.tryterra.sdk.bridge.generated.MenstruationFlow as WireMenstruationFlow
+import co.tryterra.sdk.bridge.generated.MenstruationFlowDay as WireMenstruationFlowDay
+import co.tryterra.sdk.bridge.generated.Nutrient as WireNutrient
+import co.tryterra.sdk.bridge.generated.DiagnosticsState as WireDiagnosticsState
+import co.tryterra.sdk.bridge.generated.EndUser as WireEndUser
+import co.tryterra.sdk.bridge.generated.HealthAccess as WireHealthAccess
+import co.tryterra.sdk.bridge.generated.HealthChange as WireHealthChange
+import co.tryterra.sdk.bridge.generated.HeartRateEntry as WireHeartRateEntry
+import co.tryterra.sdk.bridge.generated.HeartRateSample as WireHeartRateSample
+import co.tryterra.sdk.bridge.generated.MotionContext as WireMotionContext
+import co.tryterra.sdk.bridge.generated.PermissionStatus as WirePermissionStatus
+import co.tryterra.sdk.bridge.generated.SampleSource as WireSampleSource
+import co.tryterra.sdk.bridge.generated.SleepEntry as WireSleepEntry
+import co.tryterra.sdk.bridge.generated.SleepSegment as WireSleepSegment
+import co.tryterra.sdk.bridge.generated.SleepStage as WireSleepStage
+import co.tryterra.sdk.bridge.generated.Source as WireSource
+import co.tryterra.sdk.bridge.generated.StepCount as WireStepCount
+import co.tryterra.sdk.bridge.generated.StepEntry as WireStepEntry
+import co.tryterra.sdk.bridge.generated.SupportReport as WireSupportReport
+import co.tryterra.sdk.bridge.generated.TerraEvent as WireTerraEvent
+import co.tryterra.sdk.bridge.generated.TimeRange as WireTimeRange
+import co.tryterra.sdk.bridge.generated.Workout as WireWorkout
+import co.tryterra.sdk.bridge.generated.WorkoutActivity as WireWorkoutActivity
+import co.tryterra.sdk.bridge.generated.WorkoutEntry as WireWorkoutEntry
+import co.tryterra.sdk.bridge.generated.WorkoutScope as WireWorkoutScope
+
+/**
+ * Between the SDK's types and the generated wire DTOs, in one place.
+ *
+ * Every `when` here is exhaustive over a sealed type or an enum with no `else`, which is what makes
+ * a case added to the SDK a compile error in this file rather than a value that quietly maps to
+ * something plausible. That is lock 1 of the four, and it is the lock the old wrapper did not have:
+ * `TerraReactModule.java` and `TerraReact.swift` each carried a `switch` with a fall-through, and a
+ * data type stopped travelling without anything going red.
+ *
+ * The SDK's models are deliberately not `@Serializable`. Keeping the wire shape out of the SDK's
+ * public types is the better boundary, and the price of it is this file.
+ */
+internal object Conversions {
+
+    // ---- enums ------------------------------------------------------------------------------
+
+    fun source(wire: WireSource): Source = when (wire) {
+        WireSource.HEALTH -> Source.HEALTH
+        WireSource.SAMSUNG_HEALTH -> Source.SAMSUNG_HEALTH
+    }
+
+    fun source(source: Source): WireSource = when (source) {
+        Source.HEALTH -> WireSource.HEALTH
+        Source.SAMSUNG_HEALTH -> WireSource.SAMSUNG_HEALTH
+    }
+
+    /**
+     * `ATHLETE` is HealthKit's characteristics and has no Health Connect counterpart, so a request
+     * naming it is refused as this platform lacking it rather than quietly dropped from the sheet.
+     */
+    fun category(wire: WireCategory): DataCategory = when (wire) {
+        WireCategory.ACTIVITY -> DataCategory.ACTIVITY
+        WireCategory.BODY -> DataCategory.BODY
+        WireCategory.DAILY -> DataCategory.DAILY
+        WireCategory.SLEEP -> DataCategory.SLEEP
+        WireCategory.NUTRITION -> DataCategory.NUTRITION
+        WireCategory.MENSTRUATION -> DataCategory.MENSTRUATION
+        WireCategory.ATHLETE -> throw BridgeError.UnsupportedOnPlatform("athlete")
+    }
+
+    fun category(category: DataCategory): WireCategory = when (category) {
+        DataCategory.ACTIVITY -> WireCategory.ACTIVITY
+        DataCategory.BODY -> WireCategory.BODY
+        DataCategory.DAILY -> WireCategory.DAILY
+        DataCategory.SLEEP -> WireCategory.SLEEP
+        DataCategory.NUTRITION -> WireCategory.NUTRITION
+        DataCategory.MENSTRUATION -> WireCategory.MENSTRUATION
+    }
+
+    /**
+     * `UNAVAILABLE` is Apple's and has no Android counterpart, so nothing here can produce it.
+     *
+     * The surface types it as iOS-only for exactly that reason: a caller narrowing on it is writing
+     * iOS-specific code, and the type says so rather than letting them discover it.
+     */
+    fun permissionStatus(status: PermissionStatus): WirePermissionStatus = when (status) {
+        PermissionStatus.GRANTED -> WirePermissionStatus.GRANTED
+        PermissionStatus.DENIED -> WirePermissionStatus.DENIED
+        PermissionStatus.NOT_DETERMINED -> WirePermissionStatus.NOT_DETERMINED
+        PermissionStatus.NOT_DISCLOSED -> WirePermissionStatus.NOT_DISCLOSED
+        PermissionStatus.UNSUPPORTED -> WirePermissionStatus.UNSUPPORTED
+    }
+
+    fun restriction(reason: BackgroundRestrictionReason): WireRestriction = when (reason) {
+        BackgroundRestrictionReason.OEM_RESTRICTED -> WireRestriction.OEM_RESTRICTED
+        BackgroundRestrictionReason.BACKGROUND_READ_DENIED -> WireRestriction.BACKGROUND_READ_DENIED
+        BackgroundRestrictionReason.HEALTH_CONNECT_FEATURE_UNAVAILABLE ->
+            WireRestriction.HEALTH_CONNECT_FEATURE_UNAVAILABLE
+        BackgroundRestrictionReason.STORE_FEATURE_UNAVAILABLE -> WireRestriction.STORE_FEATURE_UNAVAILABLE
+        BackgroundRestrictionReason.TICKS_NOT_RUNNING -> WireRestriction.TICKS_NOT_RUNNING
+    }
+
+    // ---- unions -----------------------------------------------------------------------------
+
+    fun endUser(wire: WireEndUser): EndUser = when (wire) {
+        is WireEndUser.Reference -> EndUser.Reference(wire.id)
+        WireEndUser.Anonymous -> EndUser.Anonymous
+    }
+
+    fun timeRange(wire: WireTimeRange): TimeRange = when (wire) {
+        is WireTimeRange.LastHours -> TimeRange.LastHours(wire.hours)
+        is WireTimeRange.LastDays -> TimeRange.LastDays(wire.days)
+        WireTimeRange.Today -> TimeRange.Today
+        is WireTimeRange.Between -> TimeRange.Between(
+            start = BridgeInstant.parse(wire.start),
+            end = BridgeInstant.parse(wire.end),
+        )
+    }
+
+    fun sleepStage(stage: SleepStage): WireSleepStage = when (stage) {
+        SleepStage.InBed -> WireSleepStage.InBed
+        SleepStage.Awake -> WireSleepStage.Awake
+        SleepStage.Asleep -> WireSleepStage.Asleep
+        SleepStage.Light -> WireSleepStage.Light
+        SleepStage.Deep -> WireSleepStage.Deep
+        SleepStage.Rem -> WireSleepStage.Rem
+        is SleepStage.Unknown -> WireSleepStage.Unknown(stage.raw)
+    }
+
+    fun sleepStage(wire: WireSleepStage): SleepStage = when (wire) {
+        WireSleepStage.InBed -> SleepStage.InBed
+        WireSleepStage.Awake -> SleepStage.Awake
+        WireSleepStage.Asleep -> SleepStage.Asleep
+        WireSleepStage.Light -> SleepStage.Light
+        WireSleepStage.Deep -> SleepStage.Deep
+        WireSleepStage.Rem -> SleepStage.Rem
+        is WireSleepStage.Unknown -> SleepStage.Unknown(wire.raw)
+    }
+
+    fun activity(activity: WorkoutActivity): WireWorkoutActivity = when (activity) {
+        WorkoutActivity.Running -> WireWorkoutActivity.Running
+        WorkoutActivity.Walking -> WireWorkoutActivity.Walking
+        WorkoutActivity.Cycling -> WireWorkoutActivity.Cycling
+        WorkoutActivity.Swimming -> WireWorkoutActivity.Swimming
+        WorkoutActivity.StrengthTraining -> WireWorkoutActivity.StrengthTraining
+        is WorkoutActivity.Other -> WireWorkoutActivity.Other(activity.label)
+    }
+
+    fun activity(wire: WireWorkoutActivity): WorkoutActivity = when (wire) {
+        WireWorkoutActivity.Running -> WorkoutActivity.Running
+        WireWorkoutActivity.Walking -> WorkoutActivity.Walking
+        WireWorkoutActivity.Cycling -> WorkoutActivity.Cycling
+        WireWorkoutActivity.Swimming -> WorkoutActivity.Swimming
+        WireWorkoutActivity.StrengthTraining -> WorkoutActivity.StrengthTraining
+        is WireWorkoutActivity.Other -> WorkoutActivity.Other(wire.label)
+    }
+
+    /**
+     * Android has no `devIDMismatch` state - it raises `dev_id_mismatch` instead - so nothing here
+     * produces that variant. The surface types it as iOS-only.
+     */
+    fun diagnosticsState(state: DiagnosticsState): WireDiagnosticsState = when (state) {
+        DiagnosticsState.Healthy -> WireDiagnosticsState.Healthy
+        is DiagnosticsState.Quiet -> WireDiagnosticsState.Quiet(BridgeInstant.format(state.since))
+        is DiagnosticsState.BackgroundRestricted ->
+            WireDiagnosticsState.BackgroundRestricted(restriction(state.reason))
+        DiagnosticsState.BackgroundRefreshUnscheduled -> WireDiagnosticsState.BackgroundRefreshUnscheduled
+        DiagnosticsState.PendingRetry -> WireDiagnosticsState.PendingRetry
+        DiagnosticsState.LinkRevoked -> WireDiagnosticsState.LinkRevoked
+    }
+
+    // ---- records ----------------------------------------------------------------------------
+
+    fun sampleSource(source: SampleSource): WireSampleSource = WireSampleSource(
+        name = source.name,
+        bundleId = source.bundleId,
+        productType = source.productType,
+        deviceType = source.deviceType,
+    )
+
+    fun connection(stored: StoredConnection): WireConnection = WireConnection(
+        source = source(stored.source),
+        userId = stored.userId,
+        providerUserId = stored.providerUserId,
+    )
+
+    fun heartRate(sample: HeartRateSample): WireHeartRateSample = WireHeartRateSample(
+        id = sample.id.value,
+        time = BridgeInstant.format(sample.time),
+        beatsPerMinute = sample.beatsPerMinute,
+        source = sampleSource(sample.source),
+        motionContext = sample.motionContext?.let {
+            when (it) {
+                co.tryterra.sdk.MotionContext.UNKNOWN -> WireMotionContext.UNKNOWN
+                co.tryterra.sdk.MotionContext.SEDENTARY -> WireMotionContext.SEDENTARY
+                co.tryterra.sdk.MotionContext.ACTIVE -> WireMotionContext.ACTIVE
+            }
+        },
+        userEntered = sample.userEntered,
+        timeZone = sample.timeZone?.id,
+    )
+
+    fun steps(sample: StepCount): WireStepCount = WireStepCount(
+        id = sample.id?.value,
+        start = BridgeInstant.format(sample.interval.start),
+        end = BridgeInstant.format(sample.interval.end),
+        steps = sample.steps,
+        source = sampleSource(sample.source),
+        userEntered = sample.userEntered,
+        timeZone = sample.timeZone?.id,
+    )
+
+    fun segment(segment: SleepSegment): WireSleepSegment = WireSleepSegment(
+        id = segment.id.value,
+        start = BridgeInstant.format(segment.interval.start),
+        end = BridgeInstant.format(segment.interval.end),
+        stage = sleepStage(segment.stage),
+        source = sampleSource(segment.source),
+        userEntered = segment.userEntered,
+        timeZone = segment.timeZone?.id,
+    )
+
+    fun nutrient(nutrient: Nutrient): WireNutrient = when (nutrient) {
+        Nutrient.ENERGY_CONSUMED -> WireNutrient.ENERGY_CONSUMED
+        Nutrient.PROTEIN -> WireNutrient.PROTEIN
+        Nutrient.CARBOHYDRATES -> WireNutrient.CARBOHYDRATES
+        Nutrient.FAT_TOTAL -> WireNutrient.FAT_TOTAL
+        Nutrient.FAT_SATURATED -> WireNutrient.FAT_SATURATED
+        Nutrient.FAT_MONOUNSATURATED -> WireNutrient.FAT_MONOUNSATURATED
+        Nutrient.FAT_POLYUNSATURATED -> WireNutrient.FAT_POLYUNSATURATED
+        Nutrient.SUGAR -> WireNutrient.SUGAR
+        Nutrient.FIBER -> WireNutrient.FIBER
+        Nutrient.CHOLESTEROL -> WireNutrient.CHOLESTEROL
+        Nutrient.SODIUM -> WireNutrient.SODIUM
+        Nutrient.POTASSIUM -> WireNutrient.POTASSIUM
+        Nutrient.CALCIUM -> WireNutrient.CALCIUM
+        Nutrient.IRON -> WireNutrient.IRON
+        Nutrient.MAGNESIUM -> WireNutrient.MAGNESIUM
+        Nutrient.ZINC -> WireNutrient.ZINC
+        Nutrient.PHOSPHORUS -> WireNutrient.PHOSPHORUS
+        Nutrient.IODINE -> WireNutrient.IODINE
+        Nutrient.MANGANESE -> WireNutrient.MANGANESE
+        Nutrient.MOLYBDENUM -> WireNutrient.MOLYBDENUM
+        Nutrient.SELENIUM -> WireNutrient.SELENIUM
+        Nutrient.COPPER -> WireNutrient.COPPER
+        Nutrient.CHROMIUM -> WireNutrient.CHROMIUM
+        Nutrient.CHLORIDE -> WireNutrient.CHLORIDE
+        Nutrient.CAFFEINE -> WireNutrient.CAFFEINE
+        Nutrient.VITAMIN_A -> WireNutrient.VITAMIN_A
+        Nutrient.VITAMIN_C -> WireNutrient.VITAMIN_C
+        Nutrient.VITAMIN_D -> WireNutrient.VITAMIN_D
+        Nutrient.VITAMIN_E -> WireNutrient.VITAMIN_E
+        Nutrient.VITAMIN_K -> WireNutrient.VITAMIN_K
+        Nutrient.VITAMIN_B6 -> WireNutrient.VITAMIN_B6
+        Nutrient.VITAMIN_B12 -> WireNutrient.VITAMIN_B12
+        Nutrient.THIAMIN -> WireNutrient.THIAMIN
+        Nutrient.RIBOFLAVIN -> WireNutrient.RIBOFLAVIN
+        Nutrient.NIACIN -> WireNutrient.NIACIN
+        Nutrient.FOLATE -> WireNutrient.FOLATE
+        Nutrient.BIOTIN -> WireNutrient.BIOTIN
+        Nutrient.PANTOTHENIC_ACID -> WireNutrient.PANTOTHENIC_ACID
+    }
+
+    fun mealType(type: MealSample.MealType): WireMealType = when (type) {
+        MealSample.MealType.BREAKFAST -> WireMealType.BREAKFAST
+        MealSample.MealType.LUNCH -> WireMealType.LUNCH
+        MealSample.MealType.DINNER -> WireMealType.DINNER
+        MealSample.MealType.SNACK -> WireMealType.SNACK
+        MealSample.MealType.UNKNOWN -> WireMealType.UNKNOWN
+    }
+
+    fun flow(flow: MenstruationFlowSample.Flow): WireMenstruationFlow = when (flow) {
+        MenstruationFlowSample.Flow.UNSPECIFIED -> WireMenstruationFlow.UNSPECIFIED
+        MenstruationFlowSample.Flow.LIGHT -> WireMenstruationFlow.LIGHT
+        MenstruationFlowSample.Flow.MEDIUM -> WireMenstruationFlow.MEDIUM
+        MenstruationFlowSample.Flow.HEAVY -> WireMenstruationFlow.HEAVY
+        MenstruationFlowSample.Flow.NONE -> WireMenstruationFlow.NO_FLOW
+    }
+
+    fun quantity(quantity: DietaryQuantity): WireDietaryQuantity = WireDietaryQuantity(
+        id = quantity.id.value,
+        nutrient = nutrient(quantity.nutrient),
+        value = quantity.value,
+        start = BridgeInstant.format(quantity.interval.start),
+        end = BridgeInstant.format(quantity.interval.end),
+        mealType = mealType(quantity.mealType),
+        name = quantity.name,
+        foodCorrelationId = quantity.foodCorrelationId?.value,
+        source = sampleSource(quantity.source),
+        userEntered = quantity.userEntered,
+        timeZone = quantity.timeZone?.id,
+    )
+
+    fun flowDay(day: MenstruationFlowDay): WireMenstruationFlowDay = WireMenstruationFlowDay(
+        id = day.id.value,
+        start = BridgeInstant.format(day.interval.start),
+        end = BridgeInstant.format(day.interval.end),
+        flow = flow(day.flow),
+        cycleStart = day.cycleStart,
+        source = sampleSource(day.source),
+        userEntered = day.userEntered,
+        timeZone = day.timeZone?.id,
+    )
+
+    fun workout(workout: Workout): WireWorkout = WireWorkout(
+        id = workout.id.value,
+        start = BridgeInstant.format(workout.interval.start),
+        end = BridgeInstant.format(workout.interval.end),
+        activity = activity(workout.activity),
+        activityTypeCode = workout.activityTypeCode,
+        indoor = workout.indoor,
+        activeEnergyKilocalories = workout.activeEnergyKilocalories,
+        distanceMeters = workout.distanceMeters,
+        source = sampleSource(workout.source),
+        userEntered = workout.userEntered,
+        timeZone = workout.timeZone?.id,
+        title = workout.title,
+    )
+
+    /**
+     * A change carries a day, not an instant.
+     *
+     * Sending the instant would make the receiving side re-derive the day in its own zone, and get
+     * a different one either side of midnight.
+     */
+    fun change(change: HealthChange, zone: ZoneId): WireHealthChange =
+        WireHealthChange(category = category(change.category), day = change.day.atZone(zone).toLocalDate().toString())
+
+    /**
+     * An event is the object `DiagnosticsWire` already produces, carried unchanged.
+     *
+     * Not reshaped into a `{kind, payload}` of the wrapper's own: that would be a hand-written
+     * second contract here and another in the Swift half, sitting between the SDK and the generated
+     * codec where no vector can reach either of them. `EventPrivacyTest` guards this object against
+     * carrying a health value, and passing it through is what keeps that guarantee the only one.
+     */
+    fun event(event: TerraEvent): WireTerraEvent = DiagnosticsWire.event(event)
+
+    fun report(report: SupportReport): WireSupportReport = WireSupportReport(
+        sdkVersion = report.sdkVersion,
+        generatedAt = BridgeInstant.format(report.generatedAt),
+        state = diagnosticsState(report.state),
+        lastDelivery = report.lastDelivery?.let { BridgeInstant.format(it) },
+        isConnected = report.isConnected,
+        requestedCategories = report.requestedCategories,
+        requestedWrites = report.requestedWrites,
+        requestedWorkouts = report.requestedWorkouts,
+        recentEvents = report.recentEvents.map(::event),
+    )
+
+    /**
+     * Sorted and merged, because a `Set` has no order and JSON has no set.
+     *
+     * Two scopes for one activity are one grant with both flags, not two entries: `HealthAccess`
+     * can hold `Running+energy` and `Running+distance` separately, and sending both would let a
+     * caller read a grant that contradicts itself depending on which it looked at first. Sorting is
+     * what makes two grants differing only in iteration order compare equal on the wire, without
+     * which the vectors would be flaky.
+     */
+    fun access(access: HealthAccess): WireHealthAccess = WireHealthAccess(
+        read = access.read.map(::category).sortedBy { it.name },
+        write = access.write.map(::category).sortedBy { it.name },
+        workouts = access.workouts
+            .groupBy { WorkoutActivity.reportName(it.activity) }
+            .toSortedMap()
+            .map { (_, scopes) ->
+                WireWorkoutScope(
+                    activity = activity(scopes.first().activity),
+                    energy = scopes.any { it.energy },
+                    distance = scopes.any { it.distance },
+                )
+            },
+    )
+
+    fun scope(scope: WorkoutScope): WireWorkoutScope = WireWorkoutScope(
+        activity = activity(scope.activity),
+        energy = scope.energy,
+        distance = scope.distance,
+    )
+
+    fun scope(wire: WireWorkoutScope): WorkoutScope = WorkoutScope(
+        activity = activity(wire.activity),
+        energy = wire.energy,
+        distance = wire.distance,
+    )
+
+    // ---- write entries ----------------------------------------------------------------------
+
+    /**
+     * A caller-supplied record id is honoured; an absent one is minted by the SDK's own default.
+     *
+     * Minting one here would use a different scheme from `RecordHandles.mint`, and `delete` only
+     * accepts handles that scheme produced.
+     */
+    fun entry(wire: WireHeartRateEntry): HeartRateEntry =
+        wire.recordId?.let { HeartRateEntry(BridgeInstant.parse(wire.time), wire.beatsPerMinute, RecordId(it)) }
+            ?: HeartRateEntry(BridgeInstant.parse(wire.time), wire.beatsPerMinute)
+
+    fun entry(wire: WireStepEntry): StepEntry {
+        val interval = SampleInterval(BridgeInstant.parse(wire.start), BridgeInstant.parse(wire.end))
+        return wire.recordId?.let { StepEntry(interval, wire.steps, RecordId(it)) }
+            ?: StepEntry(interval, wire.steps)
+    }
+
+    fun entry(wire: WireSleepEntry): SleepEntry {
+        val interval = SampleInterval(BridgeInstant.parse(wire.start), BridgeInstant.parse(wire.end))
+        val stage = sleepStage(wire.stage)
+        return wire.recordId?.let { SleepEntry(interval, stage, RecordId(it)) } ?: SleepEntry(interval, stage)
+    }
+
+    fun entry(wire: WireWorkoutEntry): WorkoutEntry {
+        val interval = SampleInterval(BridgeInstant.parse(wire.start), BridgeInstant.parse(wire.end))
+        val activity = activity(wire.activity)
+        return wire.recordId?.let {
+            WorkoutEntry(interval, activity, wire.totalEnergyKilocalories, wire.totalDistanceMeters, RecordId(it))
+        } ?: WorkoutEntry(interval, activity, wire.totalEnergyKilocalories, wire.totalDistanceMeters)
+    }
+
+    /**
+     * Ten optional measurements and a time, one for one with `BodyEntry`.
+     *
+     * Spelled out rather than reflected: a field added to `BodyEntry` should be a decision here,
+     * and reflection would carry it silently with whatever name the SDK happened to give it.
+     */
+    fun entry(wire: WireBodyEntry): BodyEntry {
+        val time = BridgeInstant.parse(wire.time)
+        return wire.recordId?.let {
+            BodyEntry(
+                time = time,
+                bodyMassKilograms = wire.bodyMassKilograms,
+                bodyFatPercent = wire.bodyFatPercent,
+                bodyMassIndex = wire.bodyMassIndex,
+                heightMeters = wire.heightMeters,
+                leanBodyMassKilograms = wire.leanBodyMassKilograms,
+                bodyTemperatureCelsius = wire.bodyTemperatureCelsius,
+                oxygenSaturationPercent = wire.oxygenSaturationPercent,
+                bloodGlucoseMilligramsPerDeciliter = wire.bloodGlucoseMilligramsPerDeciliter,
+                bloodPressureSystolicMillimetersOfMercury = wire.bloodPressureSystolicMillimetersOfMercury,
+                bloodPressureDiastolicMillimetersOfMercury = wire.bloodPressureDiastolicMillimetersOfMercury,
+                recordId = RecordId(it),
+            )
+        } ?: BodyEntry(
+            time = time,
+            bodyMassKilograms = wire.bodyMassKilograms,
+            bodyFatPercent = wire.bodyFatPercent,
+            bodyMassIndex = wire.bodyMassIndex,
+            heightMeters = wire.heightMeters,
+            leanBodyMassKilograms = wire.leanBodyMassKilograms,
+            bodyTemperatureCelsius = wire.bodyTemperatureCelsius,
+            oxygenSaturationPercent = wire.oxygenSaturationPercent,
+            bloodGlucoseMilligramsPerDeciliter = wire.bloodGlucoseMilligramsPerDeciliter,
+            bloodPressureSystolicMillimetersOfMercury = wire.bloodPressureSystolicMillimetersOfMercury,
+            bloodPressureDiastolicMillimetersOfMercury = wire.bloodPressureDiastolicMillimetersOfMercury,
+        )
+    }
+
+    fun entry(wire: WireNutritionEntry): NutritionEntry {
+        val interval = SampleInterval(BridgeInstant.parse(wire.start), BridgeInstant.parse(wire.end))
+        val nutrients = nutrients(wire.nutrients)
+        return wire.recordId?.let { NutritionEntry(interval, wire.name, nutrients, RecordId(it)) }
+            ?: NutritionEntry(interval, wire.name, nutrients)
+    }
+
+    /**
+     * All thirty-nine, by name.
+     *
+     * The unit is in every name on both sides, so a mismatched pair is a compile error rather than
+     * a value that arrives in the wrong unit - which is the class of bug that would be invisible in
+     * every test that did not know what the number should be.
+     */
+    private fun nutrients(wire: WireNutrients): NutritionEntry.Nutrients = NutritionEntry.Nutrients(
+        energyKilocalories = wire.energyKilocalories,
+        proteinGrams = wire.proteinGrams,
+        carbohydratesGrams = wire.carbohydratesGrams,
+        fiberGrams = wire.fiberGrams,
+        sugarGrams = wire.sugarGrams,
+        fatTotalGrams = wire.fatTotalGrams,
+        fatSaturatedGrams = wire.fatSaturatedGrams,
+        fatMonounsaturatedGrams = wire.fatMonounsaturatedGrams,
+        fatPolyunsaturatedGrams = wire.fatPolyunsaturatedGrams,
+        cholesterolMilligrams = wire.cholesterolMilligrams,
+        sodiumMilligrams = wire.sodiumMilligrams,
+        potassiumMilligrams = wire.potassiumMilligrams,
+        calciumMilligrams = wire.calciumMilligrams,
+        ironMilligrams = wire.ironMilligrams,
+        magnesiumMilligrams = wire.magnesiumMilligrams,
+        zincMilligrams = wire.zincMilligrams,
+        waterLiters = wire.waterLiters,
+        caffeineMilligrams = wire.caffeineMilligrams,
+        vitaminAMicrograms = wire.vitaminAMicrograms,
+        vitaminCMilligrams = wire.vitaminCMilligrams,
+        vitaminDMicrograms = wire.vitaminDMicrograms,
+        vitaminEMilligrams = wire.vitaminEMilligrams,
+        vitaminKMicrograms = wire.vitaminKMicrograms,
+        vitaminB6Milligrams = wire.vitaminB6Milligrams,
+        vitaminB12Micrograms = wire.vitaminB12Micrograms,
+        folateMicrograms = wire.folateMicrograms,
+        thiaminMilligrams = wire.thiaminMilligrams,
+        riboflavinMilligrams = wire.riboflavinMilligrams,
+        niacinMilligrams = wire.niacinMilligrams,
+        biotinMicrograms = wire.biotinMicrograms,
+        pantothenicAcidMilligrams = wire.pantothenicAcidMilligrams,
+        phosphorusMilligrams = wire.phosphorusMilligrams,
+        iodineMicrograms = wire.iodineMicrograms,
+        chromiumMicrograms = wire.chromiumMicrograms,
+        copperMilligrams = wire.copperMilligrams,
+        manganeseMilligrams = wire.manganeseMilligrams,
+        molybdenumMicrograms = wire.molybdenumMicrograms,
+        seleniumMicrograms = wire.seleniumMicrograms,
+        chlorideMilligrams = wire.chlorideMilligrams,
+    )
+
+
+}

package/android/src/bridgeCore/kotlin/co/tryterra/sdk/bridge/LauncherSlots.kt

@@ -0,0 +1,41 @@
+package co.tryterra.sdk.bridge
+
+import co.tryterra.sdk.Source
+
+/**
+ * Which activity's launcher presents a permission sheet: the most recently started one that is
+ * still started.
+ *
+ * Creation order is not that. An app with two tasks, or one that returns to an older activity,
+ * keeps a newer activity alive but stopped, and a sheet launched through it would not be seen.
+ */
+internal class LauncherSlots<A : Any, L : Any> {
+    private val made = HashMap<A, Map<Source, L>>()
+    private val started = LinkedHashSet<A>()
+
+    @Synchronized
+    fun created(activity: A, launchers: Map<Source, L>) {
+        made[activity] = launchers
+    }
+
+    @Synchronized
+    fun started(activity: A) {
+        started.remove(activity)
+        started.add(activity)
+    }
+
+    @Synchronized
+    fun stopped(activity: A) {
+        started.remove(activity)
+    }
+
+    /** Forgets [activity], answering the launchers it held so the caller can unregister them. */
+    @Synchronized
+    fun destroyed(activity: A): Map<Source, L>? {
+        started.remove(activity)
+        return made.remove(activity)
+    }
+
+    @Synchronized
+    fun current(source: Source): L? = started.toList().asReversed().firstNotNullOfOrNull { made[it]?.get(source) }
+}