@cariva-dev/exercise-sdk 2.0.0

package/android/src/main/java/com/carivaexercisesdk/infrastructure/reactnative/ExerciseDataMapper.kt

@@ -0,0 +1,99 @@
+package com.carivaexercisesdk.infrastructure.reactnative
+
+import com.carivaexercisesdk.application.exercise.dto.ExerciseDataDto
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+
+internal object ExerciseDataMapper {
+  fun toWritableMap(data: ExerciseDataDto): WritableMap {
+    return Arguments.createMap().apply {
+      putDouble("totalSteps", data.totalSteps)
+      putDouble("totalActiveTimeMillis", data.totalActiveTimeMillis)
+      // Backward-compatible alias retained for one release cycle.
+      putDouble("totalActiveTime", data.totalActiveTimeMillis)
+      putDouble("totalKcal", data.totalKcal)
+      putDouble("totalDistanceMeters", data.totalDistanceMeters)
+      putString("timeZone", data.timeZone)
+      putArray("records", toRecordArray(data))
+
+      if (data.warnings.isNotEmpty()) {
+        putArray(
+                "warnings",
+                Arguments.createArray().apply {
+                  data.warnings.forEach { warning -> pushString(warning) }
+                }
+        )
+      }
+
+      putMap(
+              "integrity",
+              Arguments.createMap().apply {
+                putBoolean("projectionPreserved", data.integrityProjectionPreserved)
+                putInt("roundingScale", data.integrityRoundingScale)
+              }
+      )
+
+      data.diagnostics?.let { diagnostics ->
+        putMap(
+                "diagnostics",
+                Arguments.createMap().apply {
+                  putInt("fallbackUsedSegments", diagnostics.fallbackUsedSegments)
+                  putInt("fallbackSuppressedSegments", diagnostics.fallbackSuppressedSegments)
+                  putInt("idleGateSuppressedSegments", diagnostics.idleGateSuppressedSegments)
+                  putBoolean("basalSeedApplied", diagnostics.basalSeedApplied)
+                  putBoolean("seededFromBeforeSince", diagnostics.seededFromBeforeSince)
+                  diagnostics.basalSeedAgeHours?.let { putDouble("basalSeedAgeHours", it) }
+                }
+        )
+      }
+
+      data.debug?.let { debug ->
+        putMap(
+                "debug",
+                Arguments.createMap().apply {
+                  putDouble("directActiveCaloriesKcal", debug.directActiveCaloriesKcal)
+                  putDouble("totalCaloriesKcal", debug.totalCaloriesKcal)
+                  putDouble("basalCaloriesKcal", debug.basalCaloriesKcal)
+                  putDouble("mergedActiveCaloriesKcal", debug.mergedActiveCaloriesKcal)
+                  putDouble("fallbackContributionKcal", debug.fallbackContributionKcal)
+                  putInt("fallbackUsedSegments", debug.fallbackUsedSegments)
+                  putInt("fallbackSuppressedSegments", debug.fallbackSuppressedSegments)
+                  putInt("idleGateSuppressedSegments", debug.idleGateSuppressedSegments)
+                  putBoolean("basalSeedApplied", debug.basalSeedApplied)
+                  putBoolean("seededFromBeforeSince", debug.seededFromBeforeSince)
+                  debug.basalSeedAgeHours?.let { putDouble("basalSeedAgeHours", it) }
+                  putInt("basalIntervalsCount", debug.basalIntervalsCount)
+                }
+        )
+      }
+    }
+  }
+
+  private fun toRecordArray(data: ExerciseDataDto) =
+          Arguments.createArray().apply {
+            data.records.forEach { record ->
+              pushMap(
+                      Arguments.createMap().apply {
+                        putDouble("steps", record.steps)
+                        putDouble("activeCalories", record.activeCalories)
+                        putString("activeCaloriesUnit", record.activeCaloriesUnit)
+                        putDouble("distance", record.distance)
+                        putString("distanceUnit", record.distanceUnit)
+                        putDouble("activeTime", record.activeTime)
+                        putString("activeTimeUnit", record.activeTimeUnit)
+                        putString("startDate", record.startDate)
+                        putString("endDate", record.endDate)
+                        putMap(
+                                "meta",
+                                Arguments.createMap().apply {
+                                  putString("source", record.meta.source)
+                                  putString("device", record.meta.device)
+                                  putString("deviceModel", record.meta.deviceModel)
+                                  putString("trustLevel", record.meta.trustLevel)
+                                }
+                        )
+                      }
+              )
+            }
+          }
+}

package/android/src/test/java/com/carivaexercisesdk/ArchitectureDependencyRuleTest.kt

@@ -0,0 +1,60 @@
+package com.carivaexercisesdk
+
+import java.io.File
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class ArchitectureDependencyRuleTest {
+
+  @Test
+  fun domainLayer_hasNoAndroidOrReactImports() {
+    val violations =
+            findForbiddenImports(
+                    layerPath = "src/main/java/com/carivaexercisesdk/domain",
+                    forbiddenPrefixes = listOf("android.", "androidx.", "com.facebook.react.")
+            )
+
+    assertTrue("Domain layer import violations:\n${violations.joinToString("\n")}", violations.isEmpty())
+  }
+
+  @Test
+  fun applicationLayer_hasNoAndroidOrReactImports() {
+    val violations =
+            findForbiddenImports(
+                    layerPath = "src/main/java/com/carivaexercisesdk/application",
+                    forbiddenPrefixes = listOf("android.", "androidx.", "com.facebook.react.")
+            )
+
+    assertTrue(
+            "Application layer import violations:\n${violations.joinToString("\n")}",
+            violations.isEmpty()
+    )
+  }
+
+  private fun findForbiddenImports(
+          layerPath: String,
+          forbiddenPrefixes: List<String>
+  ): List<String> {
+    val layerDir = File(layerPath)
+    if (!layerDir.exists()) {
+      return emptyList()
+    }
+
+    val violations = mutableListOf<String>()
+    layerDir.walkTopDown().filter { it.isFile && it.extension == "kt" }.forEach { file ->
+      file.readLines().forEachIndexed { index, line ->
+        val trimmed = line.trim()
+        if (!trimmed.startsWith("import ")) {
+          return@forEachIndexed
+        }
+
+        val importValue = trimmed.removePrefix("import ").trim()
+        if (forbiddenPrefixes.any(importValue::startsWith)) {
+          violations += "${file.path}:${index + 1} -> $importValue"
+        }
+      }
+    }
+
+    return violations
+  }
+}

package/android/src/test/java/com/carivaexercisesdk/HealthConnectModuleDatasourceParserTest.kt

@@ -0,0 +1,69 @@
+package com.carivaexercisesdk
+
+import com.carivaexercisesdk.domain.datasource.valueobject.DatasourceType
+import com.carivaexercisesdk.infrastructure.reactnative.DatasourcePolicyJsonParser
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class HealthConnectModuleDatasourceParserTest {
+  @Test
+  fun resolveAllowlist_defaultsToAllSources_whenKeyMissing() {
+    val parsed =
+            DatasourcePolicyJsonParser.resolveAllowlist(
+                    hasAllowlistKey = false,
+                    parsedAllowlist = emptyList()
+            )
+
+    assertEquals(
+            DatasourceType.entries.map { it.wireValue }.toSet(),
+            parsed.toSet()
+    )
+  }
+
+  @Test
+  fun resolveAllowlist_keepsExplicitEmptyArray() {
+    val parsed =
+            DatasourcePolicyJsonParser.resolveAllowlist(
+                    hasAllowlistKey = true,
+                    parsedAllowlist = emptyList()
+            )
+
+    assertEquals(emptyList<String>(), parsed)
+  }
+
+  @Test
+  fun resolveScopePackages_keepsProvidedValues() {
+    val parsed =
+            DatasourcePolicyJsonParser.resolveScopePackages(
+                    listOf(" com.fit.app ", "com.google.fit")
+            )
+
+    assertEquals(listOf(" com.fit.app ", "com.google.fit"), parsed)
+  }
+
+  @Test
+  fun resolveScopePackages_returnsEmpty_whenScopeMissing() {
+    val parsed = DatasourcePolicyJsonParser.resolveScopePackages(null)
+    assertEquals(emptyList<String>(), parsed)
+  }
+
+  @Test
+  fun resolveAllowlist_keepsRawValuesForDownstreamNormalization() {
+    val parsed =
+            DatasourcePolicyJsonParser.resolveAllowlist(
+                    hasAllowlistKey = true,
+                    parsedAllowlist = listOf("device", " app ", "unknown_token")
+            )
+
+    assertEquals(listOf("device", " app ", "unknown_token"), parsed)
+  }
+
+  @Test
+  fun resolveScopePackages_readsScopePackageValues() {
+    val parsed =
+            DatasourcePolicyJsonParser.resolveScopePackages(
+                    listOf(" com.fit.app ", "com.google.fit")
+            )
+    assertEquals(listOf(" com.fit.app ", "com.google.fit"), parsed)
+  }
+}

package/android/src/test/java/com/carivaexercisesdk/HealthConnectModuleInternalsTest.kt

@@ -0,0 +1,406 @@
+package com.carivaexercisesdk
+
+import com.carivaexercisesdk.domain.exercise.services.HealthConnectModuleInternals
+import java.time.ZoneId
+import kotlin.random.Random
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class HealthConnectModuleInternalsTest {
+  private val utc = ZoneId.of("UTC")
+
+  @Test
+  fun evaluateRecordTrust_manualWithDevice_allowedAsLowConfidence() {
+    val trust =
+            HealthConnectModuleInternals.evaluateRecordTrust(
+                    FakeMetadata(recordingMethod = 3, device = FakeDevice(manufacturer = "ACME"))
+            )
+
+    assertTrue(trust.allowed)
+    assertEquals("manual_input", trust.sourceType)
+    assertEquals("low_confidence", trust.trustLevel)
+  }
+
+  @Test
+  fun evaluateRecordTrust_manualWithoutDevice_rejected() {
+    val trust =
+            HealthConnectModuleInternals.evaluateRecordTrust(
+                    FakeMetadata(recordingMethod = 3, device = null)
+            )
+
+    assertFalse(trust.allowed)
+    assertEquals("manual_input", trust.sourceType)
+    assertEquals("rejected", trust.trustLevel)
+  }
+
+  @Test
+  fun evaluateRecordTrust_unknownWithDevice_allowedAsLowConfidence() {
+    val trust =
+            HealthConnectModuleInternals.evaluateRecordTrust(
+                    FakeMetadata(recordingMethod = 99, device = FakeDevice(model = "Tracker"))
+            )
+
+    assertTrue(trust.allowed)
+    assertEquals("unknown", trust.sourceType)
+    assertEquals("low_confidence", trust.trustLevel)
+  }
+
+  @Test
+  fun normalizeOverlaps_stepsSamePriority_isDeterministicAndNoDoubleCount() {
+    val intervalA =
+            HealthConnectModuleInternals.IntervalInput(
+                    startMs = 0,
+                    endMs = 2_000,
+                    totalValue = 100.0,
+                    sourceType = "device",
+                    packageName = "a.pkg",
+                    deviceModel = "A"
+            )
+    val intervalB =
+            HealthConnectModuleInternals.IntervalInput(
+                    startMs = 1_000,
+                    endMs = 3_000,
+                    totalValue = 120.0,
+                    sourceType = "device",
+                    packageName = "b.pkg",
+                    deviceModel = "B"
+            )
+
+    val resultForward =
+            HealthConnectModuleInternals.normalizeOverlaps(
+                    metricType = HealthConnectModuleInternals.MetricType.STEPS,
+                    rawIntervals = listOf(intervalA, intervalB),
+                    sinceMs = 0,
+                    untilMs = 3_000,
+                    bucketPeriod = "hourly",
+                    zoneId = utc
+            )
+    val resultReversed =
+            HealthConnectModuleInternals.normalizeOverlaps(
+                    metricType = HealthConnectModuleInternals.MetricType.STEPS,
+                    rawIntervals = listOf(intervalB, intervalA),
+                    sinceMs = 0,
+                    untilMs = 3_000,
+                    bucketPeriod = "hourly",
+                    zoneId = utc
+            )
+
+    assertEquals(160.0, resultForward.segments.sumOf { it.value }, 1e-6)
+    assertSegmentsEqual(resultForward.segments, resultReversed.segments)
+  }
+
+  @Test
+  fun mergeCaloriesWithFallback_gapFillOnly_keepsPrimaryWhenCovered() {
+    val primary =
+            normalizationResult(
+                    listOf(
+                            segment(
+                                    startMs = 0,
+                                    endMs = 1_000,
+                                    value = 10.0,
+                                    sourceType = "device"
+                            )
+                    )
+            )
+    val total =
+            normalizationResult(
+                    listOf(
+                            segment(
+                                    startMs = 0,
+                                    endMs = 1_000,
+                                    value = 30.0,
+                                    sourceType = "device"
+                            )
+                    )
+            )
+    val basal =
+            normalizationResult(
+                    listOf(
+                            segment(
+                                    startMs = 0,
+                                    endMs = 1_000,
+                                    value = 10.0,
+                                    sourceType = "device"
+                            )
+                    )
+            )
+    val stepsEvidence =
+            listOf(segment(startMs = 0, endMs = 1_000, value = 1.0, sourceType = "device"))
+
+    val merged =
+            HealthConnectModuleInternals.mergeCaloriesWithFallback(
+                    primaryActiveCalories = primary,
+                    totalCalories = total,
+                    basalCalories = basal,
+                    stepsEvidenceSegments = stepsEvidence
+            )
+
+    assertEquals(10.0, merged.segments.sumOf { it.value }, 1e-6)
+    assertEquals(0, merged.diagnostics?.fallbackUsedSegments ?: -1)
+  }
+
+  @Test
+  fun mergeCaloriesWithFallback_fillsOnlyUncoveredWindows() {
+    val primary =
+            normalizationResult(
+                    listOf(
+                            segment(
+                                    startMs = 0,
+                                    endMs = 500,
+                                    value = 10.0,
+                                    sourceType = "device"
+                            )
+                    )
+            )
+    val total =
+            normalizationResult(
+                    listOf(
+                            segment(
+                                    startMs = 0,
+                                    endMs = 1_000,
+                                    value = 40.0,
+                                    sourceType = "device"
+                            )
+                    )
+            )
+    val basal =
+            normalizationResult(
+                    listOf(
+                            segment(
+                                    startMs = 0,
+                                    endMs = 1_000,
+                                    value = 20.0,
+                                    sourceType = "device"
+                            )
+                    )
+            )
+    val stepsEvidence =
+            listOf(segment(startMs = 0, endMs = 1_000, value = 1.0, sourceType = "device"))
+
+    val merged =
+            HealthConnectModuleInternals.mergeCaloriesWithFallback(
+                    primaryActiveCalories = primary,
+                    totalCalories = total,
+                    basalCalories = basal,
+                    stepsEvidenceSegments = stepsEvidence
+            )
+
+    assertEquals(20.0, merged.segments.sumOf { it.value }, 1e-6)
+    assertEquals(1, merged.diagnostics?.fallbackUsedSegments ?: -1)
+  }
+
+  @Test
+  fun collectPagedRecords_readsAllPages() = runBlocking {
+    val calls = mutableListOf<String>()
+    val pages =
+            mapOf(
+                    "" to PagedResult(records = listOf(1, 2), nextPageToken = "p2"),
+                    "p2" to PagedResult(records = listOf(3), nextPageToken = "p3"),
+                    "p3" to PagedResult(records = listOf(4, 5), nextPageToken = "")
+            )
+
+    val result =
+            collectPagedRecords { token ->
+              calls += token
+              pages.getValue(token)
+            }
+
+    assertEquals(listOf("", "p2", "p3"), calls)
+    assertEquals(listOf(1, 2, 3, 4, 5), result)
+  }
+
+  @Test
+  fun collectPagedRecords_stopsWhenNextPageTokenMissing() = runBlocking {
+    var callCount = 0
+
+    val result =
+            collectPagedRecords<Int> {
+              callCount += 1
+              PagedResult(records = listOf(42), nextPageToken = null)
+            }
+
+    assertEquals(1, callCount)
+    assertEquals(listOf(42), result)
+  }
+
+  @Test
+  fun isRecordAllowed_respectsAllowlistMembership() {
+    val allowlist = setOf("device", "app")
+
+    assertTrue(HealthConnectModuleInternals.isRecordAllowed("device", allowlist))
+    assertFalse(HealthConnectModuleInternals.isRecordAllowed("manual_input", allowlist))
+  }
+
+  @Test
+  fun normalizePackageAllowlist_andIsPackageAllowed_followPolicyRules() {
+    val packageAllowlist =
+            HealthConnectModuleInternals.normalizePackageAllowlist(
+                    listOf(" COM.FIT.APP ", "", "com.fit.app", "com.google.fit")
+            )
+
+    assertEquals(setOf("com.fit.app", "com.google.fit"), packageAllowlist)
+    assertTrue(HealthConnectModuleInternals.isPackageAllowed("com.fit.app", packageAllowlist))
+    assertTrue(
+            HealthConnectModuleInternals.isPackageAllowed(
+                    " COM.GOOGLE.FIT ",
+                    packageAllowlist
+            )
+    )
+    assertFalse(HealthConnectModuleInternals.isPackageAllowed("", packageAllowlist))
+    assertFalse(HealthConnectModuleInternals.isPackageAllowed(null, packageAllowlist))
+    assertTrue(HealthConnectModuleInternals.isPackageAllowed("", emptySet()))
+  }
+
+  @Test
+  fun policyFiltering_monotonicForRandomizedDataset() {
+    val random = Random(20260226)
+    val sourcePool = listOf("manual_input", "device", "app", "unknown")
+    val packagePool = listOf("com.a.fit", "com.b.tracker")
+    val broadAllowlist = sourcePool.toSet()
+    val narrowAllowlist = setOf("device", "app")
+    val packageScope = setOf("com.a.fit")
+
+    repeat(200) {
+      val samples =
+              List(40) {
+                HealthConnectModuleInternals.IntervalInput(
+                        startMs = 0,
+                        endMs = 1000,
+                        totalValue = random.nextDouble(0.1, 200.0),
+                        sourceType = sourcePool[random.nextInt(sourcePool.size)],
+                        packageName = packagePool[random.nextInt(packagePool.size)],
+                        deviceModel = "model"
+                )
+              }
+
+      val unrestrictedTotal =
+              samples
+                      .filter { HealthConnectModuleInternals.isRecordAllowed(it.sourceType, broadAllowlist) }
+                      .sumOf { it.totalValue }
+      val narrowSourceTotal =
+              samples
+                      .filter { HealthConnectModuleInternals.isRecordAllowed(it.sourceType, narrowAllowlist) }
+                      .sumOf { it.totalValue }
+      val narrowSourceAndPackageTotal =
+              samples
+                      .filter { HealthConnectModuleInternals.isRecordAllowed(it.sourceType, narrowAllowlist) }
+                      .filter {
+                        HealthConnectModuleInternals.isPackageAllowed(it.packageName, packageScope)
+                      }
+                      .sumOf { it.totalValue }
+
+      assertTrue(narrowSourceTotal <= unrestrictedTotal + 1e-9)
+      assertTrue(narrowSourceAndPackageTotal <= narrowSourceTotal + 1e-9)
+    }
+  }
+
+  @Test
+  fun policyFiltering_isDeterministicUnderInputReordering() {
+    val random = Random(20260227)
+    val sourcePool = listOf("manual_input", "device", "app", "unknown")
+    val packagePool = listOf("com.a.fit", "com.b.tracker")
+    val allowlist = setOf("device", "app", "unknown")
+    val packageScope = setOf("com.a.fit")
+
+    val samples =
+            List(80) {
+              HealthConnectModuleInternals.IntervalInput(
+                      startMs = 0,
+                      endMs = 1000,
+                      totalValue = random.nextDouble(0.1, 200.0),
+                      sourceType = sourcePool[random.nextInt(sourcePool.size)],
+                      packageName = packagePool[random.nextInt(packagePool.size)],
+                      deviceModel = "model"
+              )
+            }
+
+    fun signature(records: List<HealthConnectModuleInternals.IntervalInput>): List<String> {
+      return records
+              .filter { HealthConnectModuleInternals.isRecordAllowed(it.sourceType, allowlist) }
+              .filter { HealthConnectModuleInternals.isPackageAllowed(it.packageName, packageScope) }
+              .map { record ->
+                listOf(
+                                record.startMs.toString(),
+                                record.endMs.toString(),
+                                record.totalValue.toString(),
+                                HealthConnectModuleInternals.normalizeSourceType(record.sourceType),
+                                record.packageName.trim().lowercase()
+                        )
+                        .joinToString("|")
+              }
+              .sorted()
+    }
+
+    val baselineSignature = signature(samples)
+    repeat(40) {
+      val shuffled = samples.shuffled(random)
+      assertEquals(baselineSignature, signature(shuffled))
+    }
+  }
+
+  private fun normalizationResult(
+          segments: List<HealthConnectModuleInternals.NormalizedSegment>
+  ): HealthConnectModuleInternals.NormalizationResult {
+    return HealthConnectModuleInternals.NormalizationResult(
+            segments = segments,
+            stats = HealthConnectModuleInternals.NormalizationStats(observedIntervals = segments.size),
+            overlapStrategy = "proportional"
+    )
+  }
+
+  private fun segment(
+          startMs: Long,
+          endMs: Long,
+          value: Double,
+          sourceType: String
+  ): HealthConnectModuleInternals.NormalizedSegment {
+    return HealthConnectModuleInternals.NormalizedSegment(
+            startMs = startMs,
+            endMs = endMs,
+            value = value,
+            sourceType = sourceType,
+            packageName = "pkg",
+            deviceModel = "model"
+    )
+  }
+
+  private fun assertSegmentsEqual(
+          expected: List<HealthConnectModuleInternals.NormalizedSegment>,
+          actual: List<HealthConnectModuleInternals.NormalizedSegment>
+  ) {
+    assertEquals(expected.size, actual.size)
+
+    expected.zip(actual).forEach { (left, right) ->
+      assertEquals(left.startMs, right.startMs)
+      assertEquals(left.endMs, right.endMs)
+      assertEquals(left.sourceType, right.sourceType)
+      assertEquals(left.packageName, right.packageName)
+      assertEquals(left.deviceModel, right.deviceModel)
+      assertEquals(left.value, right.value, 1e-9)
+    }
+  }
+
+  private class FakeMetadata(
+          private val recordingMethod: Any?,
+          private val device: Any?
+  ) {
+    fun getRecordingMethod(): Any? = recordingMethod
+
+    fun getDevice(): Any? = device
+  }
+
+  private class FakeDevice(
+          private val manufacturer: String? = null,
+          private val model: String? = null,
+          private val type: Int = 0
+  ) {
+    fun getManufacturer(): String? = manufacturer
+
+    fun getModel(): String? = model
+
+    fun getType(): Int = type
+  }
+}