@cariva-dev/exercise-sdk 2.0.0

package/android/src/main/java/com/carivaexercisesdk/infrastructure/healthconnect/HealthConnectExerciseRecordAdapter.kt

@@ -0,0 +1,464 @@
+package com.carivaexercisesdk.infrastructure.healthconnect
+
+import androidx.health.connect.client.HealthConnectClient
+import androidx.health.connect.client.records.ActiveCaloriesBurnedRecord
+import androidx.health.connect.client.records.BasalMetabolicRateRecord
+import androidx.health.connect.client.records.DistanceRecord
+import androidx.health.connect.client.records.ExerciseSessionRecord
+import androidx.health.connect.client.records.Record
+import androidx.health.connect.client.records.StepsRecord
+import androidx.health.connect.client.records.TotalCaloriesBurnedRecord
+import androidx.health.connect.client.request.ReadRecordsRequest
+import androidx.health.connect.client.time.TimeRangeFilter
+import com.carivaexercisesdk.domain.exercise.services.HealthConnectModuleInternals
+import com.carivaexercisesdk.PagedResult
+import com.carivaexercisesdk.application.exercise.dto.BasalReadResultDto
+import com.carivaexercisesdk.application.exercise.port.ExerciseRecordPort
+import com.carivaexercisesdk.collectPagedRecords
+import com.carivaexercisesdk.domain.connection.valueobject.HealthConnectStatus
+import com.facebook.react.bridge.ReactApplicationContext
+import java.time.Instant
+import kotlin.reflect.KClass
+import android.util.Log
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+internal class HealthConnectExerciseRecordAdapter(
+        private val reactApplicationContext: ReactApplicationContext,
+        private val healthConnectClient: HealthConnectClient,
+        private val datasourceAllowlistProvider: () -> Set<String>,
+        private val datasourcePackageAllowlistProvider: () -> Set<String>
+) : ExerciseRecordPort {
+
+  override suspend fun getHealthConnectStatus(): HealthConnectStatus {
+    val sdkStatus = HealthConnectClient.getSdkStatus(reactApplicationContext)
+    return when (sdkStatus) {
+      HealthConnectClient.SDK_AVAILABLE -> HealthConnectStatus.AVAILABLE
+      HealthConnectClient.SDK_UNAVAILABLE_PROVIDER_UPDATE_REQUIRED ->
+              HealthConnectStatus.PROVIDER_UPDATE_REQUIRED
+      HealthConnectClient.SDK_UNAVAILABLE -> HealthConnectStatus.UNAVAILABLE
+      else -> HealthConnectStatus.UNKNOWN
+    }
+  }
+
+  override suspend fun readStepsIntervals(
+          startInstant: Instant,
+          endInstant: Instant,
+          includeManualWithDevice: Boolean
+  ): List<HealthConnectModuleInternals.IntervalInput> {
+    return safeReadRecordsWithPagination(
+                    label = "steps",
+                    recordType = StepsRecord::class,
+                    startInstant = startInstant,
+                    endInstant = endInstant
+            )
+            .mapNotNull { record ->
+              runCatching {
+                        if (!filterRecord(record.metadata, includeManualWithDevice)) {
+                          return@runCatching null
+                        }
+                        HealthConnectModuleInternals.IntervalInput(
+                                startMs = record.startTime.toEpochMilli(),
+                                endMs = record.endTime.toEpochMilli(),
+                                totalValue = record.count.toDouble(),
+                                sourceType = resolveSourceType(record.metadata),
+                                packageName = resolvePackageName(record.metadata),
+                                deviceModel =
+                                        HealthConnectModuleInternals.resolveDeviceModel(
+                                                record.metadata
+                                        )
+                        )
+                      }
+                      .getOrNull()
+            }
+  }
+
+  override suspend fun readActiveTimeIntervals(
+          startInstant: Instant,
+          endInstant: Instant,
+          includeManualWithDevice: Boolean
+  ): List<HealthConnectModuleInternals.IntervalInput> {
+    return safeReadRecordsWithPagination(
+                    label = "active_time",
+                    recordType = ExerciseSessionRecord::class,
+                    startInstant = startInstant,
+                    endInstant = endInstant
+            )
+            .mapNotNull { record ->
+              runCatching {
+                        if (!filterRecord(record.metadata, includeManualWithDevice)) {
+                          return@runCatching null
+                        }
+                        HealthConnectModuleInternals.IntervalInput(
+                                startMs = record.startTime.toEpochMilli(),
+                                endMs = record.endTime.toEpochMilli(),
+                                totalValue =
+                                        (record.endTime.toEpochMilli() -
+                                                        record.startTime.toEpochMilli())
+                                                .toDouble(),
+                                sourceType = resolveSourceType(record.metadata),
+                                packageName = resolvePackageName(record.metadata),
+                                deviceModel =
+                                        HealthConnectModuleInternals.resolveDeviceModel(
+                                                record.metadata
+                                        )
+                        )
+                      }
+                      .getOrNull()
+            }
+  }
+
+  override suspend fun readCaloriesIntervals(
+          startInstant: Instant,
+          endInstant: Instant,
+          includeManualWithDevice: Boolean
+  ): List<HealthConnectModuleInternals.IntervalInput> {
+    return safeReadRecordsWithPagination(
+                    label = "active_calories",
+                    recordType = ActiveCaloriesBurnedRecord::class,
+                    startInstant = startInstant,
+                    endInstant = endInstant
+            )
+            .mapNotNull { record ->
+              runCatching {
+                        if (!filterRecord(record.metadata, includeManualWithDevice)) {
+                          return@runCatching null
+                        }
+                        HealthConnectModuleInternals.IntervalInput(
+                                startMs = record.startTime.toEpochMilli(),
+                                endMs = record.endTime.toEpochMilli(),
+                                totalValue = record.energy.inKilocalories,
+                                sourceType = resolveSourceType(record.metadata),
+                                packageName = resolvePackageName(record.metadata),
+                                deviceModel =
+                                        HealthConnectModuleInternals.resolveDeviceModel(
+                                                record.metadata
+                                        )
+                        )
+                      }
+                      .getOrNull()
+            }
+  }
+
+  override suspend fun readDistanceIntervals(
+          startInstant: Instant,
+          endInstant: Instant,
+          includeManualWithDevice: Boolean
+  ): List<HealthConnectModuleInternals.IntervalInput> {
+    return safeReadRecordsWithPagination(
+                    label = "distance",
+                    recordType = DistanceRecord::class,
+                    startInstant = startInstant,
+                    endInstant = endInstant
+            )
+            .mapNotNull { record ->
+              runCatching {
+                        if (!filterRecord(record.metadata, includeManualWithDevice)) {
+                          return@runCatching null
+                        }
+                        HealthConnectModuleInternals.IntervalInput(
+                                startMs = record.startTime.toEpochMilli(),
+                                endMs = record.endTime.toEpochMilli(),
+                                totalValue = record.distance.inMeters,
+                                sourceType = resolveSourceType(record.metadata),
+                                packageName = resolvePackageName(record.metadata),
+                                deviceModel =
+                                        HealthConnectModuleInternals.resolveDeviceModel(
+                                                record.metadata
+                                        )
+                        )
+                      }
+                      .getOrNull()
+            }
+  }
+
+  override suspend fun readTotalCaloriesIntervals(
+          startInstant: Instant,
+          endInstant: Instant,
+          includeManualWithDevice: Boolean
+  ): List<HealthConnectModuleInternals.IntervalInput> {
+    return safeReadRecordsWithPagination(
+                    label = "total_calories",
+                    recordType = TotalCaloriesBurnedRecord::class,
+                    startInstant = startInstant,
+                    endInstant = endInstant
+            )
+            .mapNotNull { record ->
+              runCatching {
+                        if (!filterRecord(record.metadata, includeManualWithDevice)) {
+                          return@runCatching null
+                        }
+                        HealthConnectModuleInternals.IntervalInput(
+                                startMs = record.startTime.toEpochMilli(),
+                                endMs = record.endTime.toEpochMilli(),
+                                totalValue = record.energy.inKilocalories,
+                                sourceType = resolveSourceType(record.metadata),
+                                packageName = resolvePackageName(record.metadata),
+                                deviceModel =
+                                        HealthConnectModuleInternals.resolveDeviceModel(
+                                                record.metadata
+                                        )
+                        )
+                      }
+                      .getOrNull()
+            }
+  }
+
+  override suspend fun readBasalCaloriesIntervals(
+          startInstant: Instant,
+          endInstant: Instant
+  ): BasalReadResultDto {
+    val inRangeRecords =
+            safeReadRecordsWithPagination(
+                    label = "basal_in_range",
+                    recordType = BasalMetabolicRateRecord::class,
+                    startInstant = startInstant,
+                    endInstant = endInstant
+            )
+    val beforeRangeRecords =
+            safeReadRecordsWithPagination(
+                    label = "basal_before_range",
+                    recordType = BasalMetabolicRateRecord::class,
+                    startInstant = Instant.EPOCH,
+                    endInstant = startInstant
+            )
+
+    val millisPerDay = 86_400_000.0
+    val records =
+            inRangeRecords
+                    .mapNotNull { record ->
+                      runCatching {
+                                if (filterRecord(record.metadata)) {
+                                  record
+                                } else {
+                                  null
+                                }
+                              }
+                              .getOrNull()
+                    }
+                    .sortedBy { it.time.toEpochMilli() }
+    val latestBeforeSince =
+            beforeRangeRecords
+                    .mapNotNull { record ->
+                      runCatching {
+                                if (filterRecord(record.metadata)) {
+                                  record
+                                } else {
+                                  null
+                                }
+                              }
+                              .getOrNull()
+                    }
+                    .filter { it.time < startInstant }
+                    .maxByOrNull { it.time.toEpochMilli() }
+
+    val intervals = mutableListOf<HealthConnectModuleInternals.IntervalInput>()
+    var basalSeedApplied = false
+    var seededFromBeforeSince = false
+    var basalSeedAgeHours: Double? = null
+    val warnings = linkedSetOf<String>()
+
+    if (latestBeforeSince != null) {
+      val seedAgeMs = startInstant.toEpochMilli() - latestBeforeSince.time.toEpochMilli()
+      val seedStartMs = startInstant.toEpochMilli()
+      val seedEndMs =
+              minOf(
+                      records.firstOrNull()?.time?.toEpochMilli() ?: endInstant.toEpochMilli(),
+                      endInstant.toEpochMilli()
+              )
+      if (seedEndMs > seedStartMs) {
+        basalSeedApplied = true
+        seededFromBeforeSince = true
+        basalSeedAgeHours = seedAgeMs.toDouble() / MILLIS_PER_HOUR
+        intervals.add(
+                buildBasalInterval(
+                        startMs = seedStartMs,
+                        endMs = seedEndMs,
+                        kcalPerDay = latestBeforeSince.basalMetabolicRate.inKilocaloriesPerDay,
+                        packageName = resolvePackageName(latestBeforeSince.metadata),
+                        sourceType = resolveSourceType(latestBeforeSince.metadata),
+                        deviceModel =
+                                HealthConnectModuleInternals.resolveDeviceModel(
+                                        latestBeforeSince.metadata
+                                ),
+                        millisPerDay = millisPerDay
+                )
+        )
+      }
+    }
+
+    val inRangeIntervals =
+            records.mapIndexedNotNull { index, record ->
+              val startMs = maxOf(record.time.toEpochMilli(), startInstant.toEpochMilli())
+              val nextMs =
+                      records.getOrNull(index + 1)?.time?.toEpochMilli() ?: endInstant.toEpochMilli()
+              val endMs = minOf(nextMs, endInstant.toEpochMilli())
+              if (endMs <= startMs) {
+                return@mapIndexedNotNull null
+              }
+
+              buildBasalInterval(
+                      startMs = startMs,
+                      endMs = endMs,
+                      kcalPerDay = record.basalMetabolicRate.inKilocaloriesPerDay,
+                      packageName = resolvePackageName(record.metadata),
+                      sourceType = resolveSourceType(record.metadata),
+                      deviceModel = HealthConnectModuleInternals.resolveDeviceModel(record.metadata),
+                      millisPerDay = millisPerDay
+              )
+            }
+    intervals.addAll(inRangeIntervals)
+
+    return BasalReadResultDto(
+            intervals = intervals.sortedBy { it.startMs },
+            basalSeedApplied = basalSeedApplied,
+            seededFromBeforeSince = seededFromBeforeSince,
+            basalSeedAgeHours = basalSeedAgeHours,
+            warnings = warnings
+    )
+  }
+
+  private fun buildBasalInterval(
+          startMs: Long,
+          endMs: Long,
+          kcalPerDay: Double,
+          packageName: String,
+          sourceType: String,
+          deviceModel: String,
+          millisPerDay: Double
+  ): HealthConnectModuleInternals.IntervalInput {
+    val durationMs = (endMs - startMs).toDouble()
+    val basalCaloriesForInterval = kcalPerDay * (durationMs / millisPerDay)
+    return HealthConnectModuleInternals.IntervalInput(
+            startMs = startMs,
+            endMs = endMs,
+            totalValue = basalCaloriesForInterval,
+            sourceType = sourceType,
+            packageName = packageName,
+            deviceModel = deviceModel
+    )
+  }
+
+  private suspend fun <T : Record> readRecordsWithPagination(
+          recordType: KClass<T>,
+          startInstant: Instant,
+          endInstant: Instant
+  ): List<T> {
+    return withContext(Dispatchers.IO) {
+      collectPagedRecords { pageToken ->
+        val response =
+                healthConnectClient.readRecords(
+                        ReadRecordsRequest(
+                                recordType = recordType,
+                                timeRangeFilter = TimeRangeFilter.between(startInstant, endInstant),
+                                pageToken = pageToken
+                        )
+                )
+        PagedResult(
+                records = response.records,
+                nextPageToken = response.pageToken
+        )
+      }
+    }
+  }
+
+  private suspend fun <T : Record> safeReadRecordsWithPagination(
+          label: String,
+          recordType: KClass<T>,
+          startInstant: Instant,
+          endInstant: Instant
+  ): List<T> {
+    return runCatching {
+              readRecordsWithPagination(
+                      recordType = recordType,
+                      startInstant = startInstant,
+                      endInstant = endInstant
+              )
+            }
+            .getOrElse { error ->
+              Log.w(
+                      TAG,
+                      "Failed to read records for $label. Returning empty list to preserve getExerciseData availability.",
+                      error
+              )
+              emptyList()
+            }
+  }
+
+  private fun resolveSourceType(metadata: Any?): String {
+    if (metadata == null) {
+      return "unknown"
+    }
+
+    val recordingMethod =
+            try {
+              metadata.javaClass
+                      .methods
+                      .firstOrNull { it.name == "getRecordingMethod" && it.parameterCount == 0 }
+                      ?.invoke(metadata)
+            } catch (_: Throwable) {
+              null
+            }
+
+    return HealthConnectModuleInternals.normalizeSourceType(recordingMethod)
+  }
+
+  private fun filterRecord(metadata: Any?): Boolean {
+    return filterRecord(metadata, includeManualWithDevice = true)
+  }
+
+  private fun filterRecord(metadata: Any?, includeManualWithDevice: Boolean): Boolean {
+    val trustResult = HealthConnectModuleInternals.evaluateRecordTrust(metadata)
+    if (!trustResult.allowed) {
+      return false
+    }
+    if (!includeManualWithDevice &&
+                    HealthConnectModuleInternals.normalizeSourceType(trustResult.sourceType) ==
+                            "manual_input") {
+      return false
+    }
+    return HealthConnectModuleInternals.isRecordAllowed(
+            trustResult.sourceType,
+            datasourceAllowlistProvider()
+    ) && isPackageAllowed(metadata)
+  }
+
+  private fun isPackageAllowed(metadata: Any?): Boolean {
+    return HealthConnectModuleInternals.isPackageAllowed(
+            packageName = resolvePackageName(metadata),
+            packageAllowlist = datasourcePackageAllowlistProvider()
+    )
+  }
+
+  private fun resolvePackageName(metadata: Any?): String {
+    if (metadata == null) {
+      return ""
+    }
+
+    val dataOrigin =
+            try {
+              metadata.javaClass
+                      .methods
+                      .firstOrNull { it.name == "getDataOrigin" && it.parameterCount == 0 }
+                      ?.invoke(metadata)
+            } catch (_: Throwable) {
+              null
+            } ?: return ""
+
+    return try {
+      (dataOrigin.javaClass
+                      .methods
+                      .firstOrNull { it.name == "getPackageName" && it.parameterCount == 0 }
+                      ?.invoke(dataOrigin) as? String)
+                      ?.trim()
+                      .orEmpty()
+    } catch (_: Throwable) {
+      ""
+    }
+  }
+
+  private companion object {
+    private const val MILLIS_PER_HOUR = 3_600_000.0
+    private const val TAG = "HCExerciseRecordAdapter"
+  }
+}

package/android/src/main/java/com/carivaexercisesdk/infrastructure/persistence/InMemoryDatasourcePolicyRepository.kt

@@ -0,0 +1,21 @@
+package com.carivaexercisesdk.infrastructure.persistence
+
+import com.carivaexercisesdk.application.datasource.port.DatasourcePolicyRepository
+import com.carivaexercisesdk.domain.datasource.entity.DatasourcePolicy
+import com.carivaexercisesdk.domain.datasource.valueobject.DatasourceType
+
+class InMemoryDatasourcePolicyRepository : DatasourcePolicyRepository {
+  private var state =
+          DatasourcePolicy(
+                  allowlist = DatasourceType.entries.toSet(),
+                  packageAllowlist = emptySet()
+          )
+
+  override fun get(): DatasourcePolicy {
+    return state
+  }
+
+  override fun save(policy: DatasourcePolicy) {
+    state = policy
+  }
+}

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

@@ -0,0 +1,23 @@
+package com.carivaexercisesdk.infrastructure.reactnative
+
+import com.carivaexercisesdk.application.connection.dto.ConnectResultDto
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+
+object ConnectResultMapper {
+  fun toWritableMap(result: ConnectResultDto): WritableMap {
+    return Arguments.createMap().apply {
+      putBoolean("ready", result.ready)
+      putBoolean("healthConnectInstalled", result.healthConnectInstalled)
+      putString("healthConnectStatus", result.healthConnectStatus.name)
+      putBoolean("hasPermissions", result.hasPermissions)
+      putString("nextAction", result.nextAction.wireValue)
+      putArray(
+              "requestedPermissions",
+              Arguments.createArray().apply {
+                result.requestedPermissions.forEach { permission -> pushString(permission) }
+              }
+      )
+    }
+  }
+}

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

@@ -0,0 +1,51 @@
+package com.carivaexercisesdk.infrastructure.reactnative
+
+import com.carivaexercisesdk.domain.datasource.valueobject.DatasourceType
+import org.json.JSONArray
+import org.json.JSONObject
+
+internal object DatasourcePolicyJsonParser {
+  private const val DATASOURCE_ALLOWLIST_KEY = "allowlist"
+  private const val DATASOURCE_SCOPE_KEY = "scope"
+  private const val DATASOURCE_SCOPE_PACKAGES_KEY = "packages"
+
+  fun parseDatasourceAllowlist(config: JSONObject): List<String> {
+    val parsedAllowlist = parseStringArray(config.optJSONArray(DATASOURCE_ALLOWLIST_KEY))
+    return resolveAllowlist(
+            hasAllowlistKey = config.has(DATASOURCE_ALLOWLIST_KEY),
+            parsedAllowlist = parsedAllowlist
+    )
+  }
+
+  fun parseDatasourceScopePackages(config: JSONObject): List<String> {
+    val scope = config.optJSONObject(DATASOURCE_SCOPE_KEY) ?: return emptyList()
+    return resolveScopePackages(parseStringArray(scope.optJSONArray(DATASOURCE_SCOPE_PACKAGES_KEY)))
+  }
+
+  fun parseStringArray(array: JSONArray?): List<String> {
+    if (array == null) {
+      return emptyList()
+    }
+
+    return buildList {
+      for (i in 0 until array.length()) {
+        (array[i] as? String)?.let { add(it) }
+      }
+    }
+  }
+
+  internal fun resolveAllowlist(
+          hasAllowlistKey: Boolean,
+          parsedAllowlist: List<String>
+  ): List<String> {
+    if (parsedAllowlist.isNotEmpty() || hasAllowlistKey) {
+      return parsedAllowlist
+    }
+
+    return DatasourceType.entries.map { it.wireValue }
+  }
+
+  internal fun resolveScopePackages(parsedScopePackages: List<String>?): List<String> {
+    return parsedScopePackages ?: emptyList()
+  }
+}

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

@@ -0,0 +1,46 @@
+package com.carivaexercisesdk.infrastructure.reactnative
+
+import com.carivaexercisesdk.domain.datasource.entity.DatasourcePolicy
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+
+object DatasourcePolicyMapper {
+  internal data class CanonicalDatasourceConfig(
+          val allowlist: List<String>,
+          val packages: List<String>
+  )
+
+  internal fun toCanonicalConfig(policy: DatasourcePolicy): CanonicalDatasourceConfig {
+    return CanonicalDatasourceConfig(
+            allowlist = policy.allowlist.map { it.wireValue }.sorted(),
+            packages = policy.packageAllowlist.sorted()
+    )
+  }
+
+  fun toConfigMap(policy: DatasourcePolicy): WritableMap {
+    val canonical = toCanonicalConfig(policy)
+    return Arguments.createMap().apply {
+      putArray(
+              "allowlist",
+              Arguments.createArray().apply {
+                canonical.allowlist.forEach { sourceType -> pushString(sourceType) }
+              }
+      )
+      putMap(
+              "scope",
+              Arguments.createMap().apply {
+                putArray(
+                        "packages",
+                        Arguments.createArray().apply {
+                          canonical.packages.forEach { packageName -> pushString(packageName) }
+                        }
+                )
+              }
+      )
+    }
+  }
+
+  fun toSuccessMap(success: Boolean): WritableMap {
+    return Arguments.createMap().apply { putBoolean("success", success) }
+  }
+}