@cariva-dev/exercise-sdk 2.0.0

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

@@ -0,0 +1,316 @@
+package com.carivaexercisesdk.domain.exercise.services
+
+import java.time.ZoneId
+
+internal object HealthConnectUnifiedRecordBuilder {
+  fun buildUnifiedIntervalRecords(
+          stepsSegments: List<HealthConnectModuleInternals.NormalizedSegment>,
+          activeTimeSegments: List<HealthConnectModuleInternals.NormalizedSegment>,
+          caloriesSegments: List<HealthConnectModuleInternals.NormalizedSegment>,
+          distanceSegments: List<HealthConnectModuleInternals.NormalizedSegment>,
+          zoneId: ZoneId,
+          roundingScale: Int = 5
+  ): List<HealthConnectModuleInternals.UnifiedIntervalRecord> {
+    return buildUnifiedRecordsResult(
+                    stepsSegments = stepsSegments,
+                    activeTimeSegments = activeTimeSegments,
+                    caloriesSegments = caloriesSegments,
+                    distanceSegments = distanceSegments,
+                    zoneId = zoneId,
+                    roundingScale = roundingScale
+            )
+            .records
+  }
+
+  fun buildUnifiedRecordsResult(
+          stepsSegments: List<HealthConnectModuleInternals.NormalizedSegment>,
+          activeTimeSegments: List<HealthConnectModuleInternals.NormalizedSegment>,
+          caloriesSegments: List<HealthConnectModuleInternals.NormalizedSegment>,
+          distanceSegments: List<HealthConnectModuleInternals.NormalizedSegment>,
+          zoneId: ZoneId,
+          roundingScale: Int = 5
+  ): HealthConnectModuleInternals.UnifiedRecordsBuildResult {
+    val breakpoints =
+            listOf(stepsSegments, activeTimeSegments, caloriesSegments, distanceSegments)
+                    .flatMap { segments ->
+                      segments.flatMap { segment -> listOf(segment.startMs, segment.endMs) }
+                    }
+                    .toSortedSet()
+                    .toList()
+
+    if (breakpoints.size < 2) {
+      return HealthConnectModuleInternals.UnifiedRecordsBuildResult(
+              records = emptyList(),
+              warnings = emptyList(),
+              projectionPreserved = true,
+              roundingScale = roundingScale
+      )
+    }
+
+    val records = mutableListOf<HealthConnectModuleInternals.UnifiedIntervalRecord>()
+    val warnings = linkedSetOf<String>()
+    var projectedStepsRaw = 0.0
+    var projectedCaloriesRaw = 0.0
+    var projectedDistanceMetersRaw = 0.0
+    var projectedActiveTimeRaw = 0.0
+
+    for (index in 0 until breakpoints.lastIndex) {
+      val startMs = breakpoints[index]
+      val endMs = breakpoints[index + 1]
+      if (endMs <= startMs) {
+        continue
+      }
+
+      val rawSteps = projectSegmentValue(stepsSegments, startMs, endMs)
+      val rawActiveCalories = projectSegmentValue(caloriesSegments, startMs, endMs)
+      val rawDistanceMeters = projectSegmentValue(distanceSegments, startMs, endMs)
+      val rawActiveTime = projectSegmentValue(activeTimeSegments, startMs, endMs)
+
+      val steps = sanitizeMetricValue(rawSteps, warnings)
+      val activeCalories = sanitizeMetricValue(rawActiveCalories, warnings)
+      val distanceMeters = sanitizeMetricValue(rawDistanceMeters, warnings)
+      val activeTime = sanitizeMetricValue(rawActiveTime, warnings)
+
+      if (steps <= 0.0 && activeCalories <= 0.0 && distanceMeters <= 0.0 && activeTime <= 0.0) {
+        continue
+      }
+
+      projectedStepsRaw += steps
+      projectedCaloriesRaw += activeCalories
+      projectedDistanceMetersRaw += distanceMeters
+      projectedActiveTimeRaw += activeTime
+
+      records.add(
+              HealthConnectModuleInternals.UnifiedIntervalRecord(
+                      steps =
+                              normalizeNegativeZero(
+                                      HealthConnectModuleInternals.roundToScale(
+                                              steps,
+                                              roundingScale
+                                      )
+                              ),
+                      activeCalories =
+                              normalizeNegativeZero(
+                                      HealthConnectModuleInternals.roundToScale(
+                                              activeCalories,
+                                              roundingScale
+                                      )
+                              ),
+                      activeCaloriesUnit = "kcal",
+                      distance =
+                              normalizeNegativeZero(
+                                      HealthConnectModuleInternals.roundToScale(
+                                              HealthConnectModuleInternals.toKilometers(
+                                                      distanceMeters
+                                              ),
+                                              roundingScale
+                                      )
+                              ),
+                      distanceUnit = "km",
+                      activeTime =
+                              normalizeNegativeZero(
+                                      HealthConnectModuleInternals.roundToScale(
+                                              activeTime,
+                                              roundingScale
+                                      )
+                              ),
+                      activeTimeUnit = "milliseconds",
+                      startDate = HealthConnectModuleInternals.toIsoOffsetString(startMs, zoneId),
+                      endDate = HealthConnectModuleInternals.toIsoOffsetString(endMs, zoneId),
+                      meta =
+                              resolveUnifiedMeta(
+                                      stepsSegments = stepsSegments,
+                                      activeTimeSegments = activeTimeSegments,
+                                      caloriesSegments = caloriesSegments,
+                                      distanceSegments = distanceSegments,
+                                      startMs = startMs,
+                                      endMs = endMs
+                              )
+              )
+      )
+    }
+
+    val sourceTotals =
+            ProjectionTotals(
+                    steps = sanitizeMetricValue(stepsSegments.sumOf { it.value }, warnings),
+                    activeCalories =
+                            sanitizeMetricValue(caloriesSegments.sumOf { it.value }, warnings),
+                    distanceMeters =
+                            sanitizeMetricValue(distanceSegments.sumOf { it.value }, warnings),
+                    activeTime =
+                            sanitizeMetricValue(activeTimeSegments.sumOf { it.value }, warnings)
+            )
+    val projectedTotals =
+            ProjectionTotals(
+                    steps = projectedStepsRaw,
+                    activeCalories = projectedCaloriesRaw,
+                    distanceMeters = projectedDistanceMetersRaw,
+                    activeTime = projectedActiveTimeRaw
+            )
+    val projectionPreserved = isProjectionPreserved(sourceTotals, projectedTotals)
+    if (!projectionPreserved) {
+      warnings.add("projection_totals_mismatch")
+    }
+
+    return HealthConnectModuleInternals.UnifiedRecordsBuildResult(
+            records = records,
+            warnings = warnings.toList(),
+            projectionPreserved = projectionPreserved,
+            roundingScale = roundingScale
+    )
+  }
+
+  private fun resolveUnifiedMeta(
+          stepsSegments: List<HealthConnectModuleInternals.NormalizedSegment>,
+          activeTimeSegments: List<HealthConnectModuleInternals.NormalizedSegment>,
+          caloriesSegments: List<HealthConnectModuleInternals.NormalizedSegment>,
+          distanceSegments: List<HealthConnectModuleInternals.NormalizedSegment>,
+          startMs: Long,
+          endMs: Long
+  ): HealthConnectModuleInternals.UnifiedRecordMeta {
+    val allSegments =
+            listOf(stepsSegments, activeTimeSegments, caloriesSegments, distanceSegments).flatten()
+
+    val packageWeights = linkedMapOf<String, Double>()
+    val modelWeights = linkedMapOf<String, Double>()
+    allSegments.forEach { segment ->
+      if (segment.packageName.isEmpty()) {
+        return@forEach
+      }
+      if (segment.value <= 0.0) {
+        return@forEach
+      }
+
+      val overlapStart = maxOf(startMs, segment.startMs)
+      val overlapEnd = minOf(endMs, segment.endMs)
+      if (overlapEnd <= overlapStart) {
+        return@forEach
+      }
+
+      val segmentDuration = (segment.endMs - segment.startMs).toDouble()
+      if (segmentDuration <= 0.0) {
+        return@forEach
+      }
+
+      val overlapDuration = (overlapEnd - overlapStart).toDouble()
+      val projectedValue = segment.value * (overlapDuration / segmentDuration)
+      packageWeights[segment.packageName] =
+              (packageWeights[segment.packageName] ?: 0.0) + projectedValue
+      if (segment.deviceModel.isNotEmpty()) {
+        modelWeights[segment.deviceModel] = (modelWeights[segment.deviceModel] ?: 0.0) + projectedValue
+      }
+    }
+
+    val selectedPackage =
+            packageWeights
+                    .entries
+                    .sortedWith(
+                            compareByDescending<Map.Entry<String, Double>> { it.value }.thenBy {
+                              it.key
+                            }
+                    )
+                    .firstOrNull()
+                    ?.key
+                    .orEmpty()
+
+    val selectedSource =
+            if (selectedPackage.isEmpty()) {
+              HealthConnectInternalsConstants.SOURCE_UNKNOWN
+            } else {
+              allSegments
+                      .asSequence()
+                      .filter { segment ->
+                        segment.packageName == selectedPackage &&
+                                segment.value > 0.0 &&
+                                minOf(endMs, segment.endMs) > maxOf(startMs, segment.startMs)
+                      }
+                      .map { HealthConnectSourceTrust.normalizeSourceType(it.sourceType) }
+                      .maxByOrNull { HealthConnectSourceTrust.resolveSourcePriority(it) }
+                      ?: HealthConnectInternalsConstants.SOURCE_UNKNOWN
+            }
+
+    val selectedModel =
+            modelWeights
+                    .entries
+                    .sortedWith(
+                            compareByDescending<Map.Entry<String, Double>> { it.value }.thenBy {
+                              it.key
+                            }
+                    )
+                    .firstOrNull()
+                    ?.key
+                    .orEmpty()
+
+    return HealthConnectModuleInternals.UnifiedRecordMeta(
+            source = selectedSource,
+            device = selectedPackage,
+            deviceModel = selectedModel,
+            trustLevel = HealthConnectSourceTrust.resolveTrustLevelFromSource(selectedSource)
+    )
+  }
+
+  private fun projectSegmentValue(
+          segments: List<HealthConnectModuleInternals.NormalizedSegment>,
+          startMs: Long,
+          endMs: Long
+  ): Double {
+    if (segments.isEmpty() || endMs <= startMs) {
+      return 0.0
+    }
+
+    var total = 0.0
+    segments.forEach { segment ->
+      val overlapStart = maxOf(startMs, segment.startMs)
+      val overlapEnd = minOf(endMs, segment.endMs)
+      if (overlapEnd <= overlapStart) {
+        return@forEach
+      }
+
+      val segmentDuration = (segment.endMs - segment.startMs).toDouble()
+      if (segmentDuration <= 0.0) {
+        return@forEach
+      }
+
+      val overlapDuration = (overlapEnd - overlapStart).toDouble()
+      total += segment.value * (overlapDuration / segmentDuration)
+    }
+
+    return total
+  }
+
+  private data class ProjectionTotals(
+          val steps: Double,
+          val activeCalories: Double,
+          val distanceMeters: Double,
+          val activeTime: Double
+  )
+
+  private fun sanitizeMetricValue(value: Double, warnings: MutableSet<String>): Double {
+    if (!value.isFinite()) {
+      warnings.add("non_finite_metric_value_sanitized")
+      return 0.0
+    }
+    if (value < 0.0) {
+      warnings.add("negative_metric_value_clamped")
+      return 0.0
+    }
+    return normalizeNegativeZero(value)
+  }
+
+  private fun normalizeNegativeZero(value: Double): Double {
+    return if (value == -0.0) 0.0 else value
+  }
+
+  private fun isProjectionPreserved(
+          sourceTotals: ProjectionTotals,
+          projectedTotals: ProjectionTotals,
+          tolerance: Double = 1e-6
+  ): Boolean {
+    return kotlin.math.abs(sourceTotals.steps - projectedTotals.steps) <= tolerance &&
+            kotlin.math.abs(sourceTotals.activeCalories - projectedTotals.activeCalories) <=
+                    tolerance &&
+            kotlin.math.abs(sourceTotals.distanceMeters - projectedTotals.distanceMeters) <=
+                    tolerance &&
+            kotlin.math.abs(sourceTotals.activeTime - projectedTotals.activeTime) <= tolerance
+  }
+}

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

@@ -0,0 +1,156 @@
+package com.carivaexercisesdk.infrastructure.healthconnect
+
+import android.content.ActivityNotFoundException
+import android.content.Intent
+import android.net.Uri
+import androidx.activity.ComponentActivity
+import androidx.activity.result.ActivityResultLauncher
+import androidx.health.connect.client.HealthConnectClient
+import androidx.health.connect.client.PermissionController
+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.StepsRecord
+import androidx.health.connect.client.records.TotalCaloriesBurnedRecord
+import com.carivaexercisesdk.application.connection.port.HealthConnectConnectionPort
+import com.carivaexercisesdk.application.connection.port.PermissionRequestPort
+import com.carivaexercisesdk.domain.connection.valueobject.HealthConnectStatus
+import com.carivaexercisesdk.domain.connection.valueobject.PermissionScope
+import com.facebook.react.bridge.ReactApplicationContext
+import java.util.concurrent.atomic.AtomicInteger
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlinx.coroutines.withContext
+
+class HealthConnectConnectionAdapter(
+        private val reactApplicationContext: ReactApplicationContext,
+        private val healthConnectClient: HealthConnectClient,
+        private val permissionRequestKeySeed: AtomicInteger
+) : HealthConnectConnectionPort, PermissionRequestPort {
+
+  private val permissionByScope =
+          mapOf(
+                  PermissionScope.CALORIES to
+                          setOf(
+                                  androidx.health.connect.client.permission.HealthPermission
+                                          .getReadPermission(ActiveCaloriesBurnedRecord::class),
+                                  androidx.health.connect.client.permission.HealthPermission
+                                          .getReadPermission(TotalCaloriesBurnedRecord::class),
+                                  androidx.health.connect.client.permission.HealthPermission
+                                          .getReadPermission(BasalMetabolicRateRecord::class)
+                          ),
+                  PermissionScope.STEPS to
+                          setOf(
+                                  androidx.health.connect.client.permission.HealthPermission
+                                          .getReadPermission(StepsRecord::class)
+                          ),
+                  PermissionScope.DISTANCES to
+                          setOf(
+                                  androidx.health.connect.client.permission.HealthPermission
+                                          .getReadPermission(DistanceRecord::class)
+                          ),
+                  PermissionScope.ACTIVETIMES to
+                          setOf(
+                                  androidx.health.connect.client.permission.HealthPermission
+                                          .getReadPermission(ExerciseSessionRecord::class)
+                          )
+          )
+
+  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 fun isHealthConnectInstalled(): Boolean {
+    return HEALTH_CONNECT_PACKAGES.any(::isPackageInstalled)
+  }
+
+  override suspend fun getGrantedPermissions(): Set<String> {
+    return withContext(Dispatchers.IO) {
+      healthConnectClient.permissionController.getGrantedPermissions()
+    }
+  }
+
+  override fun resolvePermissions(scopes: Set<PermissionScope>): Set<String> {
+    return scopes.flatMapTo(mutableSetOf()) { scope -> permissionByScope[scope].orEmpty() }
+  }
+
+  override suspend fun requestPermissions(permissions: Set<String>) {
+    val activity = reactApplicationContext.currentActivity as? ComponentActivity ?: return
+
+    suspendCancellableCoroutine { continuation ->
+      val requestKey = "health_connect_permission_${permissionRequestKeySeed.incrementAndGet()}"
+      lateinit var launcher: ActivityResultLauncher<Set<String>>
+
+      launcher =
+              activity.activityResultRegistry.register(
+                      requestKey,
+                      PermissionController.createRequestPermissionResultContract()
+              ) {
+                launcher.unregister()
+                if (continuation.isActive) {
+                  continuation.resume(Unit)
+                }
+              }
+
+      continuation.invokeOnCancellation { launcher.unregister() }
+
+      try {
+        launcher.launch(permissions)
+      } catch (t: Throwable) {
+        launcher.unregister()
+        if (continuation.isActive) {
+          continuation.resumeWithException(t)
+        }
+      }
+    }
+  }
+
+  override fun openHealthConnectStore() {
+    val marketIntent =
+            Intent(Intent.ACTION_VIEW, Uri.parse("market://details?id=$HEALTH_CONNECT_PLAY_STORE_PACKAGE"))
+                    .apply { addFlags(Intent.FLAG_ACTIVITY_NEW_TASK) }
+
+    val webIntent =
+            Intent(
+                            Intent.ACTION_VIEW,
+                            Uri.parse(
+                                    "https://play.google.com/store/apps/details?id=$HEALTH_CONNECT_PLAY_STORE_PACKAGE"
+                            )
+                    )
+                    .apply { addFlags(Intent.FLAG_ACTIVITY_NEW_TASK) }
+
+    try {
+      reactApplicationContext.startActivity(marketIntent)
+    } catch (_: ActivityNotFoundException) {
+      reactApplicationContext.startActivity(webIntent)
+    }
+  }
+
+  private fun isPackageInstalled(packageName: String): Boolean {
+    return try {
+      reactApplicationContext.packageManager.getPackageInfo(packageName, 0)
+      true
+    } catch (_: Throwable) {
+      false
+    }
+  }
+
+  private companion object {
+    private const val HEALTH_CONNECT_PLAY_STORE_PACKAGE = "com.google.android.apps.healthdata"
+    private val HEALTH_CONNECT_PACKAGES =
+            listOf(
+                    "com.google.android.apps.healthdata",
+                    "com.google.android.healthconnect.controller"
+            )
+  }
+}