@cariva-dev/exercise-sdk 2.0.0

package/android/src/main/java/com/carivaexercisesdk/HealthConnectModule.kt

@@ -0,0 +1,222 @@
+package com.carivaexercisesdk
+
+import androidx.health.connect.client.HealthConnectClient
+import com.carivaexercisesdk.application.connection.command.ConnectCommand
+import com.carivaexercisesdk.application.connection.command.MissingAppBehavior
+import com.carivaexercisesdk.application.connection.handler.ConnectHandler
+import com.carivaexercisesdk.application.connection.handler.InvalidPermissionScopeException
+import com.carivaexercisesdk.application.datasource.command.SetDatasourcePolicyCommand
+import com.carivaexercisesdk.application.datasource.handler.GetDatasourcePolicyHandler
+import com.carivaexercisesdk.application.datasource.handler.SetDatasourcePolicyHandler
+import com.carivaexercisesdk.application.exercise.handler.ExerciseDataException
+import com.carivaexercisesdk.application.exercise.handler.GetExerciseDataHandler
+import com.carivaexercisesdk.application.exercise.query.GetExerciseDataQuery
+import com.carivaexercisesdk.infrastructure.healthconnect.HealthConnectConnectionAdapter
+import com.carivaexercisesdk.infrastructure.healthconnect.HealthConnectExerciseRecordAdapter
+import com.carivaexercisesdk.infrastructure.persistence.InMemoryDatasourcePolicyRepository
+import com.carivaexercisesdk.infrastructure.reactnative.DatasourcePolicyJsonParser
+import com.carivaexercisesdk.infrastructure.reactnative.ConnectResultMapper
+import com.carivaexercisesdk.infrastructure.reactnative.DatasourcePolicyMapper
+import com.carivaexercisesdk.infrastructure.reactnative.ExerciseDataMapper
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import java.util.concurrent.atomic.AtomicInteger
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
+import org.json.JSONObject
+
+class HealthConnectModule(reactContext: ReactApplicationContext) :
+        ReactContextBaseJavaModule(reactContext) {
+
+  private val moduleScope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
+
+  private val healthConnectClient: HealthConnectClient by lazy {
+    HealthConnectClient.getOrCreate(reactApplicationContext)
+  }
+
+  private val permissionRequestKeySeed = AtomicInteger(0)
+
+  private val datasourcePolicyRepository = InMemoryDatasourcePolicyRepository()
+  private val setDatasourcePolicyHandler = SetDatasourcePolicyHandler(datasourcePolicyRepository)
+  private val getDatasourcePolicyHandler = GetDatasourcePolicyHandler(datasourcePolicyRepository)
+
+  private val healthConnectConnectionAdapter: HealthConnectConnectionAdapter by lazy {
+    HealthConnectConnectionAdapter(
+            reactApplicationContext = reactApplicationContext,
+            healthConnectClient = healthConnectClient,
+            permissionRequestKeySeed = permissionRequestKeySeed
+    )
+  }
+
+  private val connectHandler: ConnectHandler by lazy {
+    ConnectHandler(
+            connectionPort = healthConnectConnectionAdapter,
+            permissionRequestPort = healthConnectConnectionAdapter
+    )
+  }
+
+  private val healthConnectExerciseRecordAdapter: HealthConnectExerciseRecordAdapter by lazy {
+    HealthConnectExerciseRecordAdapter(
+            reactApplicationContext = reactApplicationContext,
+            healthConnectClient = healthConnectClient,
+            datasourceAllowlistProvider = {
+              datasourcePolicyRepository.get().allowlist.map { it.wireValue }.toSet()
+            },
+            datasourcePackageAllowlistProvider = {
+              datasourcePolicyRepository.get().packageAllowlist
+            }
+    )
+  }
+
+  private val getExerciseDataHandler: GetExerciseDataHandler by lazy {
+    GetExerciseDataHandler(healthConnectExerciseRecordAdapter)
+  }
+
+  override fun getName(): String = NAME
+
+  @ReactMethod
+  fun connect(optionsJson: String?, promise: Promise) {
+    moduleScope.launch {
+      try {
+        val command = parseConnectCommand(optionsJson)
+        val result = connectHandler.handle(command)
+        promise.resolve(ConnectResultMapper.toWritableMap(result))
+      } catch (e: InvalidPermissionScopeException) {
+        promise.reject(
+                "E_INVALID_PERMISSION_SCOPE",
+                "Unsupported permissionScope values: ${e.unsupportedScopes.joinToString(", ")}"
+        )
+      } catch (t: Throwable) {
+        promise.reject("E_CONNECT", "Failed to connect to Health Connect.", t)
+      }
+    }
+  }
+
+  @ReactMethod
+  fun getExerciseData(optionsJson: String, promise: Promise) {
+    moduleScope.launch {
+      try {
+        val query = parseExerciseQuery(optionsJson)
+        val result = getExerciseDataHandler.handle(query)
+        promise.resolve(ExerciseDataMapper.toWritableMap(result))
+      } catch (e: ExerciseDataException) {
+        promise.reject(e.code, e.detail)
+      } catch (t: Throwable) {
+        val rootMessage =
+                buildString {
+                  append("Failed to get exercise data.")
+                  append(" ")
+                  append(t.javaClass.simpleName)
+                  t.message?.takeIf { it.isNotBlank() }?.let { message ->
+                    append(": ")
+                    append(message)
+                  }
+                }
+        promise.reject("E_GET_EXERCISE_DATA", rootMessage, t)
+      }
+    }
+  }
+
+  @ReactMethod
+  fun setAllowDatasource(configJson: String, promise: Promise) {
+    try {
+      val config = JSONObject(configJson)
+      val allowlist = DatasourcePolicyJsonParser.parseDatasourceAllowlist(config)
+      val packageAllowlist = DatasourcePolicyJsonParser.parseDatasourceScopePackages(config)
+
+      setDatasourcePolicyHandler.handle(
+              SetDatasourcePolicyCommand(
+                      allowlist = allowlist,
+                      packageAllowlist = packageAllowlist
+              )
+      )
+      promise.resolve(DatasourcePolicyMapper.toSuccessMap(success = true))
+    } catch (e: Exception) {
+      promise.reject("E_INVALID_JSON", "Invalid JSON format for datasource config.", e)
+    } catch (t: Throwable) {
+      promise.reject("E_SET_ALLOW_DATASOURCE", "Failed to set allow datasource.", t)
+    }
+  }
+
+  @ReactMethod
+  fun getAllowDatasource(promise: Promise) {
+    try {
+      val policy = getDatasourcePolicyHandler.handle()
+      promise.resolve(DatasourcePolicyMapper.toConfigMap(policy))
+    } catch (t: Throwable) {
+      promise.reject("E_GET_ALLOW_DATASOURCE", "Failed to get allow datasource.", t)
+    }
+  }
+
+  override fun invalidate() {
+    moduleScope.cancel()
+    super.invalidate()
+  }
+
+  private fun parseConnectCommand(optionsJson: String?): ConnectCommand {
+    val json =
+            if (optionsJson.isNullOrBlank()) {
+              JSONObject()
+            } else {
+              JSONObject(optionsJson)
+            }
+
+    val onMissingApp = json.optString("onMissingApp", STATUS_MISSING_APP).trim().lowercase()
+    val requestPermission = json.optBoolean("requestPermission", false)
+    val permissionScope =
+            json.optJSONArray("permissionScope")?.let { array ->
+              buildList {
+                for (i in 0 until array.length()) {
+                  (array[i] as? String)?.let { add(it) }
+                }
+              }
+            }
+
+    return ConnectCommand(
+            onMissingApp =
+                    if (onMissingApp == OPEN_MISSING_APP) {
+                      MissingAppBehavior.OPEN
+                    } else {
+                      MissingAppBehavior.STATUS
+                    },
+            requestPermission = requestPermission,
+            permissionScope = permissionScope
+    )
+  }
+
+  private fun parseExerciseQuery(optionsJson: String): GetExerciseDataQuery {
+    val json = JSONObject(optionsJson)
+
+    if (!json.has("sinceMillis") || !json.has("untilMillis")) {
+      throw IllegalArgumentException("Both sinceMillis and untilMillis are required.")
+    }
+
+    return GetExerciseDataQuery(
+            sinceMillis = parseRequiredMillis(json, "sinceMillis"),
+            untilMillis = parseRequiredMillis(json, "untilMillis"),
+            type = json.optString("type", "all").trim().lowercase(),
+            bucketPeriod = json.optString("bucketPeriod", "hourly").trim().lowercase(),
+            debug = json.optBoolean("debug", false)
+    )
+  }
+
+  private fun parseRequiredMillis(json: JSONObject, key: String): Long {
+    val rawValue = json.opt(key)
+    return when (rawValue) {
+      is Number -> rawValue.toLong()
+      is String -> rawValue.trim().toLongOrNull()
+      else -> null
+    } ?: throw IllegalArgumentException("$key must be a valid epoch millis number.")
+  }
+
+  companion object {
+    const val NAME = "HealthConnectModule"
+    private const val STATUS_MISSING_APP = "status"
+    private const val OPEN_MISSING_APP = "open"
+  }
+}

package/android/src/main/java/com/carivaexercisesdk/HealthConnectPermissionUsageActivity.kt

@@ -0,0 +1,11 @@
+package com.carivaexercisesdk
+
+import android.app.Activity
+import android.os.Bundle
+
+class HealthConnectPermissionUsageActivity : Activity() {
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    finish()
+  }
+}

package/android/src/main/java/com/carivaexercisesdk/HealthConnectPermissionsRationaleActivity.kt

@@ -0,0 +1,11 @@
+package com.carivaexercisesdk
+
+import android.app.Activity
+import android.os.Bundle
+
+class HealthConnectPermissionsRationaleActivity : Activity() {
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    finish()
+  }
+}

package/android/src/main/java/com/carivaexercisesdk/Pagination.kt

@@ -0,0 +1,23 @@
+package com.carivaexercisesdk
+
+internal data class PagedResult<T>(
+        val records: List<T>,
+        val nextPageToken: String?
+)
+
+internal suspend fun <T> collectPagedRecords(
+        readPage: suspend (pageToken: String) -> PagedResult<T>
+): List<T> {
+  val allRecords = mutableListOf<T>()
+  var pageToken = ""
+
+  while (true) {
+    val page = readPage(pageToken)
+    allRecords.addAll(page.records)
+
+    val nextToken = page.nextPageToken?.takeUnless { it.isBlank() } ?: break
+    pageToken = nextToken
+  }
+
+  return allRecords
+}

package/android/src/main/java/com/carivaexercisesdk/application/connection/command/ConnectCommand.kt

@@ -0,0 +1,12 @@
+package com.carivaexercisesdk.application.connection.command
+
+enum class MissingAppBehavior {
+  STATUS,
+  OPEN
+}
+
+data class ConnectCommand(
+        val onMissingApp: MissingAppBehavior = MissingAppBehavior.STATUS,
+        val requestPermission: Boolean = false,
+        val permissionScope: List<String>? = null
+)

package/android/src/main/java/com/carivaexercisesdk/application/connection/dto/ConnectResultDto.kt

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

package/android/src/main/java/com/carivaexercisesdk/application/connection/handler/ConnectHandler.kt

@@ -0,0 +1,79 @@
+package com.carivaexercisesdk.application.connection.handler
+
+import com.carivaexercisesdk.application.connection.command.ConnectCommand
+import com.carivaexercisesdk.application.connection.command.MissingAppBehavior
+import com.carivaexercisesdk.application.connection.dto.ConnectResultDto
+import com.carivaexercisesdk.application.connection.port.HealthConnectConnectionPort
+import com.carivaexercisesdk.application.connection.port.PermissionRequestPort
+import com.carivaexercisesdk.domain.connection.service.ConnectionDecisionService
+import com.carivaexercisesdk.domain.connection.valueobject.HealthConnectStatus
+import com.carivaexercisesdk.domain.connection.valueobject.PermissionScope
+
+class ConnectHandler(
+        private val connectionPort: HealthConnectConnectionPort,
+        private val permissionRequestPort: PermissionRequestPort,
+        private val decisionService: ConnectionDecisionService = ConnectionDecisionService()
+) {
+  suspend fun handle(command: ConnectCommand): ConnectResultDto {
+    val unsupportedScopes = PermissionScope.findUnsupported(command.permissionScope)
+    if (unsupportedScopes.isNotEmpty()) {
+      throw InvalidPermissionScopeException(unsupportedScopes)
+    }
+
+    val normalizedScopes = PermissionScope.normalizeAll(command.permissionScope)
+    val effectiveScopes = if (normalizedScopes.isEmpty()) PermissionScope.defaults() else normalizedScopes
+    val requestedPermissions = connectionPort.resolvePermissions(effectiveScopes)
+
+    val healthConnectStatus = connectionPort.getHealthConnectStatus()
+    val healthConnectInstalled =
+            healthConnectStatus == HealthConnectStatus.AVAILABLE ||
+                    connectionPort.isHealthConnectInstalled()
+
+    var grantedPermissions =
+            if (healthConnectStatus == HealthConnectStatus.AVAILABLE) {
+              connectionPort.getGrantedPermissions()
+            } else {
+              emptySet()
+            }
+
+    var hasPermissions =
+            healthConnectStatus == HealthConnectStatus.AVAILABLE &&
+                    requestedPermissions.all(grantedPermissions::contains)
+
+    val shouldRequestPermission =
+            healthConnectInstalled &&
+                    healthConnectStatus == HealthConnectStatus.AVAILABLE &&
+                    !hasPermissions &&
+                    command.requestPermission
+
+    if (shouldRequestPermission) {
+      permissionRequestPort.requestPermissions(requestedPermissions)
+      grantedPermissions = connectionPort.getGrantedPermissions()
+      hasPermissions = requestedPermissions.all(grantedPermissions::contains)
+    }
+
+    if (command.onMissingApp == MissingAppBehavior.OPEN && !healthConnectInstalled) {
+      connectionPort.openHealthConnectStore()
+    }
+
+    val aggregate =
+            decisionService.decide(
+                    healthConnectInstalled = healthConnectInstalled,
+                    healthConnectStatus = healthConnectStatus,
+                    hasPermissions = hasPermissions,
+                    requestedPermissions = requestedPermissions
+            )
+
+    return ConnectResultDto(
+            ready = aggregate.ready,
+            healthConnectInstalled = aggregate.healthConnectInstalled,
+            healthConnectStatus = aggregate.healthConnectStatus,
+            hasPermissions = aggregate.hasPermissions,
+            nextAction = aggregate.nextAction,
+            requestedPermissions = aggregate.requestedPermissions.sorted()
+    )
+  }
+}
+
+class InvalidPermissionScopeException(val unsupportedScopes: Set<String>) :
+        IllegalArgumentException("Unsupported permission scope values")

package/android/src/main/java/com/carivaexercisesdk/application/connection/port/HealthConnectConnectionPort.kt

@@ -0,0 +1,16 @@
+package com.carivaexercisesdk.application.connection.port
+
+import com.carivaexercisesdk.domain.connection.valueobject.HealthConnectStatus
+import com.carivaexercisesdk.domain.connection.valueobject.PermissionScope
+
+interface HealthConnectConnectionPort {
+  suspend fun getHealthConnectStatus(): HealthConnectStatus
+
+  fun isHealthConnectInstalled(): Boolean
+
+  suspend fun getGrantedPermissions(): Set<String>
+
+  fun resolvePermissions(scopes: Set<PermissionScope>): Set<String>
+
+  fun openHealthConnectStore()
+}

package/android/src/main/java/com/carivaexercisesdk/application/connection/port/PermissionRequestPort.kt

@@ -0,0 +1,5 @@
+package com.carivaexercisesdk.application.connection.port
+
+interface PermissionRequestPort {
+  suspend fun requestPermissions(permissions: Set<String>)
+}

package/android/src/main/java/com/carivaexercisesdk/application/datasource/command/SetDatasourcePolicyCommand.kt

@@ -0,0 +1,6 @@
+package com.carivaexercisesdk.application.datasource.command
+
+data class SetDatasourcePolicyCommand(
+        val allowlist: List<String>,
+        val packageAllowlist: List<String>
+)

package/android/src/main/java/com/carivaexercisesdk/application/datasource/handler/GetDatasourcePolicyHandler.kt

@@ -0,0 +1,10 @@
+package com.carivaexercisesdk.application.datasource.handler
+
+import com.carivaexercisesdk.application.datasource.port.DatasourcePolicyRepository
+import com.carivaexercisesdk.domain.datasource.entity.DatasourcePolicy
+
+class GetDatasourcePolicyHandler(private val repository: DatasourcePolicyRepository) {
+  fun handle(): DatasourcePolicy {
+    return repository.get()
+  }
+}

package/android/src/main/java/com/carivaexercisesdk/application/datasource/handler/SetDatasourcePolicyHandler.kt

@@ -0,0 +1,22 @@
+package com.carivaexercisesdk.application.datasource.handler
+
+import com.carivaexercisesdk.application.datasource.command.SetDatasourcePolicyCommand
+import com.carivaexercisesdk.application.datasource.port.DatasourcePolicyRepository
+import com.carivaexercisesdk.domain.datasource.entity.DatasourcePolicy
+import com.carivaexercisesdk.domain.datasource.valueobject.DatasourceType
+import com.carivaexercisesdk.domain.exercise.services.HealthConnectModuleInternals
+
+class SetDatasourcePolicyHandler(private val repository: DatasourcePolicyRepository) {
+  fun handle(command: SetDatasourcePolicyCommand): DatasourcePolicy {
+    val allowlist =
+            command.allowlist
+                    .mapNotNull { DatasourceType.fromWireValue(it) }
+                    .toSet()
+    val packageAllowlist =
+            HealthConnectModuleInternals.normalizePackageAllowlist(command.packageAllowlist)
+
+    val policy = DatasourcePolicy(allowlist = allowlist, packageAllowlist = packageAllowlist)
+    repository.save(policy)
+    return policy
+  }
+}

package/android/src/main/java/com/carivaexercisesdk/application/datasource/port/DatasourcePolicyRepository.kt

@@ -0,0 +1,9 @@
+package com.carivaexercisesdk.application.datasource.port
+
+import com.carivaexercisesdk.domain.datasource.entity.DatasourcePolicy
+
+interface DatasourcePolicyRepository {
+  fun get(): DatasourcePolicy
+
+  fun save(policy: DatasourcePolicy)
+}

package/android/src/main/java/com/carivaexercisesdk/application/exercise/dto/BasalReadResultDto.kt

@@ -0,0 +1,11 @@
+package com.carivaexercisesdk.application.exercise.dto
+
+import com.carivaexercisesdk.domain.exercise.services.HealthConnectModuleInternals
+
+internal data class BasalReadResultDto(
+        val intervals: List<HealthConnectModuleInternals.IntervalInput>,
+        val basalSeedApplied: Boolean,
+        val seededFromBeforeSince: Boolean = false,
+        val basalSeedAgeHours: Double? = null,
+        val warnings: Set<String> = emptySet()
+)

package/android/src/main/java/com/carivaexercisesdk/application/exercise/dto/ExerciseDataDto.kt

@@ -0,0 +1,41 @@
+package com.carivaexercisesdk.application.exercise.dto
+
+import com.carivaexercisesdk.domain.exercise.services.HealthConnectModuleInternals
+
+internal data class ExerciseDataDto(
+        val totalKcal: Double,
+        val totalSteps: Double,
+        val totalActiveTimeMillis: Double,
+        val totalDistanceMeters: Double,
+        val timeZone: String,
+        val records: List<HealthConnectModuleInternals.UnifiedIntervalRecord>,
+        val warnings: List<String>,
+        val integrityProjectionPreserved: Boolean,
+        val integrityRoundingScale: Int,
+        val diagnostics: ExerciseDiagnosticsDto?,
+        val debug: ExerciseDebugDto?
+)
+
+internal data class ExerciseDiagnosticsDto(
+        val fallbackUsedSegments: Int,
+        val fallbackSuppressedSegments: Int,
+        val idleGateSuppressedSegments: Int,
+        val basalSeedApplied: Boolean,
+        val seededFromBeforeSince: Boolean,
+        val basalSeedAgeHours: Double?
+)
+
+internal data class ExerciseDebugDto(
+        val directActiveCaloriesKcal: Double,
+        val totalCaloriesKcal: Double,
+        val basalCaloriesKcal: Double,
+        val mergedActiveCaloriesKcal: Double,
+        val fallbackContributionKcal: Double,
+        val fallbackUsedSegments: Int,
+        val fallbackSuppressedSegments: Int,
+        val idleGateSuppressedSegments: Int,
+        val basalSeedApplied: Boolean,
+        val seededFromBeforeSince: Boolean,
+        val basalSeedAgeHours: Double?,
+        val basalIntervalsCount: Int
+)