@cariva-dev/exercise-sdk 2.0.0

package/android/src/main/java/com/carivaexercisesdk/application/exercise/handler/GetExerciseDataHandler.kt

@@ -0,0 +1,346 @@
+package com.carivaexercisesdk.application.exercise.handler
+
+import com.carivaexercisesdk.domain.exercise.services.HealthConnectModuleInternals
+import com.carivaexercisesdk.application.exercise.dto.BasalReadResultDto
+import com.carivaexercisesdk.application.exercise.dto.ExerciseDataDto
+import com.carivaexercisesdk.application.exercise.dto.ExerciseDebugDto
+import com.carivaexercisesdk.application.exercise.dto.ExerciseDiagnosticsDto
+import com.carivaexercisesdk.application.exercise.port.ExerciseRecordPort
+import com.carivaexercisesdk.application.exercise.query.GetExerciseDataQuery
+import com.carivaexercisesdk.domain.connection.valueobject.HealthConnectStatus
+import com.carivaexercisesdk.domain.exercise.services.ExerciseDomainService
+import java.time.Instant
+import java.time.ZoneId
+import kotlinx.coroutines.async
+import kotlinx.coroutines.coroutineScope
+
+internal class GetExerciseDataHandler(private val exerciseRecordPort: ExerciseRecordPort) {
+  suspend fun handle(query: GetExerciseDataQuery): ExerciseDataDto {
+    val healthConnectStatus = exerciseRecordPort.getHealthConnectStatus()
+    if (healthConnectStatus != HealthConnectStatus.AVAILABLE) {
+      throw ExerciseDataException(
+              code = "E_HEALTH_CONNECT_UNAVAILABLE",
+              detail = "Health Connect SDK status is not available: $healthConnectStatus"
+      )
+    }
+
+    val startInstant = Instant.ofEpochMilli(query.sinceMillis)
+    val endInstant = Instant.ofEpochMilli(query.untilMillis)
+
+    if (!ExerciseDomainService.isValidPeriod(startInstant, endInstant)) {
+      throw ExerciseDataException(
+              code = "E_INVALID_PERIOD",
+              detail = "Maximum period is 90 days and start must be <= end."
+      )
+    }
+
+    if (!ExerciseDomainService.isSupportedBucketPeriod(query.bucketPeriod)) {
+      throw ExerciseDataException(
+              code = "E_UNSUPPORTED_BUCKET_PERIOD",
+              detail =
+                      "Unsupported bucketPeriod '${query.bucketPeriod}'. Supported values: hourly, daily."
+      )
+    }
+
+    val normalizedBucketPeriod = ExerciseDomainService.normalizeBucketPeriod(query.bucketPeriod)
+    val zoneId = ZoneId.systemDefault()
+
+    val includeSteps = query.type == "steps" || query.type == "all"
+    val includeActiveTimes = query.type == "activetimes" || query.type == "all"
+    val includeCalories = query.type == "calories" || query.type == "all"
+    val includeDistances = query.type == "distances" || query.type == "all"
+
+    if (!includeSteps && !includeActiveTimes && !includeCalories && !includeDistances) {
+      throw ExerciseDataException(
+              code = "E_UNSUPPORTED_TYPE",
+              detail =
+                      "Unsupported type '${query.type}'. Supported values: steps, activetimes, calories, distances, all."
+      )
+    }
+
+    val normalizedSteps =
+            if (includeSteps) {
+              ExerciseDomainService.normalizeOverlaps(
+                      metricType = HealthConnectModuleInternals.MetricType.STEPS,
+                      rawIntervals = exerciseRecordPort.readStepsIntervals(startInstant, endInstant),
+                      sinceMs = query.sinceMillis,
+                      untilMs = query.untilMillis,
+                      bucketPeriod = normalizedBucketPeriod,
+                      zoneId = zoneId
+              )
+            } else {
+              ExerciseDomainService.emptyNormalizationResult("source_priority")
+            }
+
+    val normalizedActiveTimes =
+            if (includeActiveTimes) {
+              ExerciseDomainService.normalizeOverlaps(
+                      metricType = HealthConnectModuleInternals.MetricType.ACTIVE_TIME,
+                      rawIntervals =
+                              exerciseRecordPort.readActiveTimeIntervals(startInstant, endInstant),
+                      sinceMs = query.sinceMillis,
+                      untilMs = query.untilMillis,
+                      bucketPeriod = normalizedBucketPeriod,
+                      zoneId = zoneId
+              )
+            } else {
+              ExerciseDomainService.emptyNormalizationResult("proportional")
+            }
+
+    val normalizedDistances =
+            if (includeDistances) {
+              ExerciseDomainService.normalizeOverlaps(
+                      metricType = HealthConnectModuleInternals.MetricType.DISTANCE,
+                      rawIntervals = exerciseRecordPort.readDistanceIntervals(startInstant, endInstant),
+                      sinceMs = query.sinceMillis,
+                      untilMs = query.untilMillis,
+                      bucketPeriod = normalizedBucketPeriod,
+                      zoneId = zoneId
+              )
+            } else {
+              ExerciseDomainService.emptyNormalizationResult("proportional")
+            }
+
+    val caloriesFallbackEvidence =
+            if (includeCalories && query.type == "calories") {
+              loadCaloriesFallbackEvidence(
+                      startInstant = startInstant,
+                      endInstant = endInstant,
+                      sinceMs = query.sinceMillis,
+                      untilMs = query.untilMillis,
+                      bucketPeriod = normalizedBucketPeriod,
+                      zoneId = zoneId
+              )
+            } else {
+              CaloriesFallbackEvidenceDto(
+                      stepsSegments = normalizedSteps.segments,
+                      activeTimeSegments = normalizedActiveTimes.segments,
+                      distanceSegments = normalizedDistances.segments
+              )
+            }
+
+    var basalReadResult = BasalReadResultDto(intervals = emptyList(), basalSeedApplied = false)
+    val normalizedCalories =
+            if (includeCalories) {
+              val normalizedActiveCalories =
+                      ExerciseDomainService.normalizeOverlaps(
+                              metricType = HealthConnectModuleInternals.MetricType.CALORIES,
+                              rawIntervals = exerciseRecordPort.readCaloriesIntervals(startInstant, endInstant),
+                              sinceMs = query.sinceMillis,
+                              untilMs = query.untilMillis,
+                              bucketPeriod = normalizedBucketPeriod,
+                              zoneId = zoneId
+                      )
+              val normalizedTotalCalories =
+                      ExerciseDomainService.normalizeOverlaps(
+                              metricType = HealthConnectModuleInternals.MetricType.CALORIES,
+                              rawIntervals =
+                                      exerciseRecordPort.readTotalCaloriesIntervals(
+                                              startInstant,
+                                              endInstant
+                                      ),
+                              sinceMs = query.sinceMillis,
+                              untilMs = query.untilMillis,
+                              bucketPeriod = normalizedBucketPeriod,
+                              zoneId = zoneId
+                      )
+              basalReadResult = exerciseRecordPort.readBasalCaloriesIntervals(startInstant, endInstant)
+              val normalizedBasalCalories =
+                      ExerciseDomainService.normalizeOverlaps(
+                              metricType = HealthConnectModuleInternals.MetricType.CALORIES,
+                              rawIntervals = basalReadResult.intervals,
+                              sinceMs = query.sinceMillis,
+                              untilMs = query.untilMillis,
+                              bucketPeriod = normalizedBucketPeriod,
+                              zoneId = zoneId
+                      )
+
+              ExerciseDomainService.mergeCaloriesWithFallback(
+                      primaryActiveCalories = normalizedActiveCalories,
+                      totalCalories = normalizedTotalCalories,
+                      basalCalories = normalizedBasalCalories,
+                      stepsEvidenceSegments = caloriesFallbackEvidence.stepsSegments,
+                      activeTimeEvidenceSegments = caloriesFallbackEvidence.activeTimeSegments,
+                      distanceEvidenceSegments = caloriesFallbackEvidence.distanceSegments,
+                      basalSeedApplied = basalReadResult.basalSeedApplied,
+                      seededFromBeforeSince = basalReadResult.seededFromBeforeSince,
+                      basalSeedAgeHours = basalReadResult.basalSeedAgeHours
+              )
+            } else {
+              ExerciseDomainService.emptyNormalizationResult("proportional")
+            }
+
+    val unifiedRecordsResult =
+            ExerciseDomainService.buildUnifiedRecordsResult(
+                    stepsSegments = normalizedSteps.segments,
+                    activeTimeSegments = normalizedActiveTimes.segments,
+                    caloriesSegments = normalizedCalories.segments,
+                    distanceSegments = normalizedDistances.segments,
+                    zoneId = zoneId,
+                    roundingScale = 5
+            )
+
+    val warnings =
+            linkedSetOf<String>().apply {
+              addAll(normalizedSteps.warnings)
+              addAll(normalizedActiveTimes.warnings)
+              addAll(normalizedCalories.warnings)
+              addAll(normalizedDistances.warnings)
+              addAll(basalReadResult.warnings)
+              addAll(caloriesFallbackEvidence.warnings)
+              addAll(unifiedRecordsResult.warnings)
+            }
+
+    val diagnosticsDto =
+            normalizedCalories.diagnostics?.let { diagnostics ->
+              ExerciseDiagnosticsDto(
+                      fallbackUsedSegments = diagnostics.fallbackUsedSegments,
+                      fallbackSuppressedSegments = diagnostics.fallbackSuppressedSegments,
+                      idleGateSuppressedSegments = diagnostics.idleGateSuppressedSegments,
+                      basalSeedApplied = diagnostics.basalSeedApplied,
+                      seededFromBeforeSince = basalReadResult.seededFromBeforeSince,
+                      basalSeedAgeHours = diagnostics.basalSeedAgeHours
+              )
+            }
+
+    val debugDto =
+            if (query.debug) {
+              normalizedCalories.diagnostics?.let { diagnostics ->
+                ExerciseDebugDto(
+                        directActiveCaloriesKcal = diagnostics.directActiveCaloriesKcal,
+                        totalCaloriesKcal = diagnostics.totalCaloriesKcal,
+                        basalCaloriesKcal = diagnostics.basalCaloriesKcal,
+                        mergedActiveCaloriesKcal = diagnostics.mergedActiveCaloriesKcal,
+                        fallbackContributionKcal = diagnostics.fallbackContributionKcal,
+                        fallbackUsedSegments = diagnostics.fallbackUsedSegments,
+                        fallbackSuppressedSegments = diagnostics.fallbackSuppressedSegments,
+                        idleGateSuppressedSegments = diagnostics.idleGateSuppressedSegments,
+                        basalSeedApplied = diagnostics.basalSeedApplied,
+                        seededFromBeforeSince = basalReadResult.seededFromBeforeSince,
+                        basalSeedAgeHours = diagnostics.basalSeedAgeHours,
+                        basalIntervalsCount = basalReadResult.intervals.size
+                )
+              }
+            } else {
+              null
+            }
+
+    return ExerciseDataDto(
+            totalKcal = normalizedCalories.segments.sumOf { it.value },
+            totalSteps = normalizedSteps.segments.sumOf { it.value },
+            totalActiveTimeMillis = normalizedActiveTimes.segments.sumOf { it.value },
+            totalDistanceMeters = normalizedDistances.segments.sumOf { it.value },
+            timeZone = zoneId.id,
+            records = unifiedRecordsResult.records,
+            warnings = warnings.toList(),
+            integrityProjectionPreserved = unifiedRecordsResult.projectionPreserved,
+            integrityRoundingScale = unifiedRecordsResult.roundingScale,
+            diagnostics = diagnosticsDto,
+            debug = debugDto
+    )
+  }
+
+  private suspend fun loadCaloriesFallbackEvidence(
+          startInstant: Instant,
+          endInstant: Instant,
+          sinceMs: Long,
+          untilMs: Long,
+          bucketPeriod: String,
+          zoneId: ZoneId
+  ): CaloriesFallbackEvidenceDto = coroutineScope {
+    val warnings = linkedSetOf<String>()
+
+    val stepsDeferred = async {
+      runCatching {
+        ExerciseDomainService.normalizeOverlaps(
+                        metricType = HealthConnectModuleInternals.MetricType.STEPS,
+                        rawIntervals =
+                                exerciseRecordPort.readStepsIntervals(
+                                        startInstant = startInstant,
+                                        endInstant = endInstant,
+                                        includeManualWithDevice = false
+                                ),
+                        sinceMs = sinceMs,
+                        untilMs = untilMs,
+                        bucketPeriod = bucketPeriod,
+                        zoneId = zoneId
+                )
+                .segments
+      }
+    }
+    val activeTimeDeferred = async {
+      runCatching {
+        ExerciseDomainService.normalizeOverlaps(
+                        metricType = HealthConnectModuleInternals.MetricType.ACTIVE_TIME,
+                        rawIntervals =
+                                exerciseRecordPort.readActiveTimeIntervals(
+                                        startInstant = startInstant,
+                                        endInstant = endInstant,
+                                        includeManualWithDevice = false
+                                ),
+                        sinceMs = sinceMs,
+                        untilMs = untilMs,
+                        bucketPeriod = bucketPeriod,
+                        zoneId = zoneId
+                )
+                .segments
+      }
+    }
+    val distanceDeferred = async {
+      runCatching {
+        ExerciseDomainService.normalizeOverlaps(
+                        metricType = HealthConnectModuleInternals.MetricType.DISTANCE,
+                        rawIntervals =
+                                exerciseRecordPort.readDistanceIntervals(
+                                        startInstant = startInstant,
+                                        endInstant = endInstant,
+                                        includeManualWithDevice = false
+                                ),
+                        sinceMs = sinceMs,
+                        untilMs = untilMs,
+                        bucketPeriod = bucketPeriod,
+                        zoneId = zoneId
+                )
+                .segments
+      }
+    }
+
+    val stepsSegments =
+            stepsDeferred.await().getOrElse {
+              warnings.add(WARNING_MOVEMENT_EVIDENCE_PARTIALLY_UNAVAILABLE_FOR_FALLBACK_GATE)
+              emptyList()
+            }
+    val activeTimeSegments =
+            activeTimeDeferred.await().getOrElse {
+              warnings.add(WARNING_MOVEMENT_EVIDENCE_PARTIALLY_UNAVAILABLE_FOR_FALLBACK_GATE)
+              emptyList()
+            }
+    val distanceSegments =
+            distanceDeferred.await().getOrElse {
+              warnings.add(WARNING_MOVEMENT_EVIDENCE_PARTIALLY_UNAVAILABLE_FOR_FALLBACK_GATE)
+              emptyList()
+            }
+
+    CaloriesFallbackEvidenceDto(
+            stepsSegments = stepsSegments,
+            activeTimeSegments = activeTimeSegments,
+            distanceSegments = distanceSegments,
+            warnings = warnings
+    )
+  }
+
+  private data class CaloriesFallbackEvidenceDto(
+          val stepsSegments: List<HealthConnectModuleInternals.NormalizedSegment>,
+          val activeTimeSegments: List<HealthConnectModuleInternals.NormalizedSegment>,
+          val distanceSegments: List<HealthConnectModuleInternals.NormalizedSegment>,
+          val warnings: Set<String> = emptySet()
+  )
+
+  private companion object {
+    private const val WARNING_MOVEMENT_EVIDENCE_PARTIALLY_UNAVAILABLE_FOR_FALLBACK_GATE =
+            "movement_evidence_partially_unavailable_for_fallback_gate"
+  }
+}
+
+internal class ExerciseDataException(val code: String, val detail: String) :
+        IllegalArgumentException(detail)

package/android/src/main/java/com/carivaexercisesdk/application/exercise/port/ExerciseRecordPort.kt

@@ -0,0 +1,45 @@
+package com.carivaexercisesdk.application.exercise.port
+
+import com.carivaexercisesdk.domain.exercise.services.HealthConnectModuleInternals
+import com.carivaexercisesdk.application.exercise.dto.BasalReadResultDto
+import com.carivaexercisesdk.domain.connection.valueobject.HealthConnectStatus
+import java.time.Instant
+
+internal interface ExerciseRecordPort {
+  suspend fun getHealthConnectStatus(): HealthConnectStatus
+
+  suspend fun readStepsIntervals(
+          startInstant: Instant,
+          endInstant: Instant,
+          includeManualWithDevice: Boolean = true
+  ): List<HealthConnectModuleInternals.IntervalInput>
+
+  suspend fun readActiveTimeIntervals(
+          startInstant: Instant,
+          endInstant: Instant,
+          includeManualWithDevice: Boolean = true
+  ): List<HealthConnectModuleInternals.IntervalInput>
+
+  suspend fun readCaloriesIntervals(
+          startInstant: Instant,
+          endInstant: Instant,
+          includeManualWithDevice: Boolean = true
+  ): List<HealthConnectModuleInternals.IntervalInput>
+
+  suspend fun readDistanceIntervals(
+          startInstant: Instant,
+          endInstant: Instant,
+          includeManualWithDevice: Boolean = true
+  ): List<HealthConnectModuleInternals.IntervalInput>
+
+  suspend fun readTotalCaloriesIntervals(
+          startInstant: Instant,
+          endInstant: Instant,
+          includeManualWithDevice: Boolean = true
+  ): List<HealthConnectModuleInternals.IntervalInput>
+
+  suspend fun readBasalCaloriesIntervals(
+          startInstant: Instant,
+          endInstant: Instant
+  ): BasalReadResultDto
+}

package/android/src/main/java/com/carivaexercisesdk/application/exercise/query/GetExerciseDataQuery.kt

@@ -0,0 +1,9 @@
+package com.carivaexercisesdk.application.exercise.query
+
+data class GetExerciseDataQuery(
+        val sinceMillis: Long,
+        val untilMillis: Long,
+        val type: String,
+        val bucketPeriod: String,
+        val debug: Boolean
+)

package/android/src/main/java/com/carivaexercisesdk/domain/connection/entity/ConnectionAggregate.kt

@@ -0,0 +1,13 @@
+package com.carivaexercisesdk.domain.connection.entity
+
+import com.carivaexercisesdk.domain.connection.valueobject.ConnectionNextAction
+import com.carivaexercisesdk.domain.connection.valueobject.HealthConnectStatus
+
+data class ConnectionAggregate(
+        val ready: Boolean,
+        val healthConnectInstalled: Boolean,
+        val healthConnectStatus: HealthConnectStatus,
+        val hasPermissions: Boolean,
+        val nextAction: ConnectionNextAction,
+        val requestedPermissions: Set<String>
+)

package/android/src/main/java/com/carivaexercisesdk/domain/connection/service/ConnectionDecisionService.kt

@@ -0,0 +1,37 @@
+package com.carivaexercisesdk.domain.connection.service
+
+import com.carivaexercisesdk.domain.connection.entity.ConnectionAggregate
+import com.carivaexercisesdk.domain.connection.valueobject.ConnectionNextAction
+import com.carivaexercisesdk.domain.connection.valueobject.HealthConnectStatus
+
+class ConnectionDecisionService {
+  fun decide(
+          healthConnectInstalled: Boolean,
+          healthConnectStatus: HealthConnectStatus,
+          hasPermissions: Boolean,
+          requestedPermissions: Set<String>
+  ): ConnectionAggregate {
+    val nextAction =
+            when {
+              !healthConnectInstalled -> ConnectionNextAction.INSTALL_HEALTH_CONNECT
+              healthConnectStatus != HealthConnectStatus.AVAILABLE ->
+                      ConnectionNextAction.UPDATE_HEALTH_CONNECT
+              !hasPermissions -> ConnectionNextAction.REQUEST_PERMISSION
+              else -> ConnectionNextAction.NONE
+            }
+
+    val ready =
+            healthConnectInstalled &&
+                    healthConnectStatus == HealthConnectStatus.AVAILABLE &&
+                    hasPermissions
+
+    return ConnectionAggregate(
+            ready = ready,
+            healthConnectInstalled = healthConnectInstalled,
+            healthConnectStatus = healthConnectStatus,
+            hasPermissions = hasPermissions,
+            nextAction = nextAction,
+            requestedPermissions = requestedPermissions
+    )
+  }
+}

package/android/src/main/java/com/carivaexercisesdk/domain/connection/valueobject/ConnectionNextAction.kt

@@ -0,0 +1,8 @@
+package com.carivaexercisesdk.domain.connection.valueobject
+
+enum class ConnectionNextAction(val wireValue: String) {
+  INSTALL_HEALTH_CONNECT("INSTALL_HEALTH_CONNECT"),
+  UPDATE_HEALTH_CONNECT("UPDATE_HEALTH_CONNECT"),
+  REQUEST_PERMISSION("REQUEST_PERMISSION"),
+  NONE("NONE")
+}

package/android/src/main/java/com/carivaexercisesdk/domain/connection/valueobject/HealthConnectStatus.kt

@@ -0,0 +1,8 @@
+package com.carivaexercisesdk.domain.connection.valueobject
+
+enum class HealthConnectStatus {
+  AVAILABLE,
+  PROVIDER_UPDATE_REQUIRED,
+  UNAVAILABLE,
+  UNKNOWN
+}

package/android/src/main/java/com/carivaexercisesdk/domain/connection/valueobject/PermissionScope.kt

@@ -0,0 +1,36 @@
+package com.carivaexercisesdk.domain.connection.valueobject
+
+enum class PermissionScope(val wireValue: String) {
+  STEPS("steps"),
+  ACTIVETIMES("activetimes"),
+  CALORIES("calories"),
+  DISTANCES("distances");
+
+  companion object {
+    fun normalize(scopeValue: String): PermissionScope? {
+      return entries.firstOrNull { it.wireValue == scopeValue.trim().lowercase() }
+    }
+
+    fun normalizeAll(scopeValues: List<String>?): Set<PermissionScope> {
+      if (scopeValues.isNullOrEmpty()) {
+        return emptySet()
+      }
+      return scopeValues.mapNotNull(::normalize).toSet()
+    }
+
+    fun findUnsupported(scopeValues: List<String>?): Set<String> {
+      if (scopeValues.isNullOrEmpty()) {
+        return emptySet()
+      }
+
+      return scopeValues
+              .map { it.trim() }
+              .filter { normalize(it) == null }
+              .toSet()
+    }
+
+    fun defaults(): Set<PermissionScope> {
+      return entries.toSet()
+    }
+  }
+}

package/android/src/main/java/com/carivaexercisesdk/domain/datasource/entity/DatasourcePolicy.kt

@@ -0,0 +1,8 @@
+package com.carivaexercisesdk.domain.datasource.entity
+
+import com.carivaexercisesdk.domain.datasource.valueobject.DatasourceType
+
+data class DatasourcePolicy(
+        val allowlist: Set<DatasourceType>,
+        val packageAllowlist: Set<String>
+)

package/android/src/main/java/com/carivaexercisesdk/domain/datasource/valueobject/DatasourceType.kt

@@ -0,0 +1,14 @@
+package com.carivaexercisesdk.domain.datasource.valueobject
+
+enum class DatasourceType(val wireValue: String) {
+  MANUAL_INPUT("manual_input"),
+  DEVICE("device"),
+  APP("app"),
+  UNKNOWN("unknown");
+
+  companion object {
+    fun fromWireValue(value: String): DatasourceType? {
+      return entries.firstOrNull { it.wireValue == value.trim().lowercase() }
+    }
+  }
+}

package/android/src/main/java/com/carivaexercisesdk/domain/exercise/services/ExerciseDomainService.kt

@@ -0,0 +1,89 @@
+package com.carivaexercisesdk.domain.exercise.services
+
+import java.time.Instant
+import java.time.ZoneId
+
+internal object ExerciseDomainService {
+  fun isValidPeriod(startInstant: Instant, endInstant: Instant): Boolean {
+    return HealthConnectModuleInternals.isValidPeriod(startInstant, endInstant)
+  }
+
+  fun isSupportedBucketPeriod(bucketPeriod: String): Boolean {
+    return HealthConnectModuleInternals.isSupportedBucketPeriod(bucketPeriod)
+  }
+
+  fun normalizeBucketPeriod(bucketPeriod: String): String {
+    return HealthConnectModuleInternals.normalizeBucketPeriod(bucketPeriod)
+  }
+
+  fun normalizeOverlaps(
+          metricType: HealthConnectModuleInternals.MetricType,
+          rawIntervals: List<HealthConnectModuleInternals.IntervalInput>,
+          sinceMs: Long,
+          untilMs: Long,
+          bucketPeriod: String,
+          zoneId: ZoneId
+  ): HealthConnectModuleInternals.NormalizationResult {
+    return HealthConnectModuleInternals.normalizeOverlaps(
+            metricType = metricType,
+            rawIntervals = rawIntervals,
+            sinceMs = sinceMs,
+            untilMs = untilMs,
+            bucketPeriod = bucketPeriod,
+            zoneId = zoneId
+    )
+  }
+
+  fun mergeCaloriesWithFallback(
+          primaryActiveCalories: HealthConnectModuleInternals.NormalizationResult,
+          totalCalories: HealthConnectModuleInternals.NormalizationResult,
+          basalCalories: HealthConnectModuleInternals.NormalizationResult,
+          stepsEvidenceSegments: List<HealthConnectModuleInternals.NormalizedSegment>,
+          activeTimeEvidenceSegments: List<HealthConnectModuleInternals.NormalizedSegment>,
+          distanceEvidenceSegments: List<HealthConnectModuleInternals.NormalizedSegment>,
+          basalSeedApplied: Boolean,
+          seededFromBeforeSince: Boolean,
+          basalSeedAgeHours: Double?
+  ): HealthConnectModuleInternals.NormalizationResult {
+    return HealthConnectModuleInternals.mergeCaloriesWithFallback(
+            primaryActiveCalories = primaryActiveCalories,
+            totalCalories = totalCalories,
+            basalCalories = basalCalories,
+            stepsEvidenceSegments = stepsEvidenceSegments,
+            activeTimeEvidenceSegments = activeTimeEvidenceSegments,
+            distanceEvidenceSegments = distanceEvidenceSegments,
+            basalSeedApplied = basalSeedApplied,
+            seededFromBeforeSince = seededFromBeforeSince,
+            basalSeedAgeHours = basalSeedAgeHours
+    )
+  }
+
+  fun buildUnifiedRecordsResult(
+          stepsSegments: List<HealthConnectModuleInternals.NormalizedSegment>,
+          activeTimeSegments: List<HealthConnectModuleInternals.NormalizedSegment>,
+          caloriesSegments: List<HealthConnectModuleInternals.NormalizedSegment>,
+          distanceSegments: List<HealthConnectModuleInternals.NormalizedSegment>,
+          zoneId: ZoneId,
+          roundingScale: Int
+  ): HealthConnectModuleInternals.UnifiedRecordsBuildResult {
+    return HealthConnectModuleInternals.buildUnifiedRecordsResult(
+            stepsSegments = stepsSegments,
+            activeTimeSegments = activeTimeSegments,
+            caloriesSegments = caloriesSegments,
+            distanceSegments = distanceSegments,
+            zoneId = zoneId,
+            roundingScale = roundingScale
+    )
+  }
+
+  fun emptyNormalizationResult(
+          overlapStrategy: String
+  ): HealthConnectModuleInternals.NormalizationResult {
+    return HealthConnectModuleInternals.NormalizationResult(
+            segments = emptyList(),
+            stats = HealthConnectModuleInternals.NormalizationStats(),
+            overlapStrategy = overlapStrategy,
+            warnings = emptyList()
+    )
+  }
+}