@cariva-dev/exercise-sdk 2.0.0

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

@@ -0,0 +1,316 @@
+package com.carivaexercisesdk.domain.exercise.services
+
+import java.time.Duration
+import java.time.Instant
+import java.time.ZoneId
+import java.time.format.DateTimeFormatter
+import kotlin.math.pow
+import kotlin.math.round
+
+internal object HealthConnectModuleInternals {
+  enum class MetricType {
+    STEPS,
+    ACTIVE_TIME,
+    CALORIES,
+    DISTANCE
+  }
+
+  data class IntervalInput(
+          val startMs: Long,
+          val endMs: Long,
+          val totalValue: Double,
+          val sourceType: String,
+          val packageName: String,
+          val deviceModel: String = ""
+  )
+
+  data class NormalizedSegment(
+          val startMs: Long,
+          val endMs: Long,
+          val value: Double,
+          val sourceType: String,
+          val packageName: String,
+          val deviceModel: String = "",
+          val normalized: Boolean = true
+  )
+
+  data class NormalizationStats(
+          val droppedNonPositiveCount: Int = 0,
+          val unknownSourceCount: Int = 0,
+          val observedIntervals: Int = 0
+  ) {
+    operator fun plus(other: NormalizationStats): NormalizationStats {
+      return NormalizationStats(
+              droppedNonPositiveCount = droppedNonPositiveCount + other.droppedNonPositiveCount,
+              unknownSourceCount = unknownSourceCount + other.unknownSourceCount,
+              observedIntervals = observedIntervals + other.observedIntervals
+      )
+    }
+  }
+
+  data class NormalizationResult(
+          val segments: List<NormalizedSegment>,
+          val stats: NormalizationStats,
+          val overlapStrategy: String,
+          val warnings: List<String> = emptyList(),
+          val diagnostics: Diagnostics? = null
+  )
+
+  data class Diagnostics(
+          val fallbackUsedSegments: Int = 0,
+          val fallbackSuppressedSegments: Int = 0,
+          val idleGateSuppressedSegments: Int = 0,
+          val basalSeedApplied: Boolean = false,
+          val seededFromBeforeSince: Boolean = false,
+          val basalSeedAgeHours: Double? = null,
+          val directActiveCaloriesKcal: Double = 0.0,
+          val totalCaloriesKcal: Double = 0.0,
+          val basalCaloriesKcal: Double = 0.0,
+          val mergedActiveCaloriesKcal: Double = 0.0,
+          val fallbackContributionKcal: Double = 0.0
+  )
+
+  data class UnifiedIntervalRecord(
+          val steps: Double,
+          val activeCalories: Double,
+          val activeCaloriesUnit: String,
+          val distance: Double,
+          val distanceUnit: String,
+          val activeTime: Double,
+          val activeTimeUnit: String,
+          val startDate: String,
+          val endDate: String,
+          val meta: UnifiedRecordMeta
+  )
+
+  data class UnifiedRecordMeta(
+          val source: String,
+          val device: String,
+          val deviceModel: String,
+          val trustLevel: String
+  )
+
+  data class UnifiedRecordsBuildResult(
+          val records: List<UnifiedIntervalRecord>,
+          val warnings: List<String>,
+          val projectionPreserved: Boolean,
+          val roundingScale: Int
+  )
+
+  data class RecordTrustResult(
+          val allowed: Boolean,
+          val reason: String,
+          val sourceType: String,
+          val trustLevel: String
+  )
+
+  fun isSupportedBucketPeriod(bucketPeriod: String): Boolean {
+    val normalized = bucketPeriod.trim().lowercase()
+    return normalized == HealthConnectInternalsConstants.SUPPORTED_HOURLY ||
+            normalized == HealthConnectInternalsConstants.SUPPORTED_DAILY
+  }
+
+  fun normalizeBucketPeriod(bucketPeriod: String): String {
+    return bucketPeriod.trim().lowercase()
+  }
+
+  fun normalizePermissionScope(scopeValue: String): String? {
+    return when (scopeValue.trim().lowercase()) {
+      HealthConnectInternalsConstants.SCOPE_STEPS -> HealthConnectInternalsConstants.SCOPE_STEPS
+      HealthConnectInternalsConstants.SCOPE_ACTIVE_TIMES ->
+              HealthConnectInternalsConstants.SCOPE_ACTIVE_TIMES
+      HealthConnectInternalsConstants.SCOPE_CALORIES ->
+              HealthConnectInternalsConstants.SCOPE_CALORIES
+      HealthConnectInternalsConstants.SCOPE_DISTANCES ->
+              HealthConnectInternalsConstants.SCOPE_DISTANCES
+      else -> null
+    }
+  }
+
+  fun normalizePermissionScopes(scopeValues: List<String>?): Set<String> {
+    if (scopeValues.isNullOrEmpty()) {
+      return emptySet()
+    }
+
+    return scopeValues.mapNotNull { normalizePermissionScope(it) }.toSet()
+  }
+
+  fun findUnsupportedPermissionScopes(scopeValues: List<String>?): Set<String> {
+    if (scopeValues.isNullOrEmpty()) {
+      return emptySet()
+    }
+
+    return scopeValues
+            .map { it.trim() }
+            .filter { normalizePermissionScope(it) == null }
+            .toSet()
+  }
+
+  fun defaultPermissionScopes(): Set<String> {
+    return setOf(
+            HealthConnectInternalsConstants.SCOPE_STEPS,
+            HealthConnectInternalsConstants.SCOPE_ACTIVE_TIMES,
+            HealthConnectInternalsConstants.SCOPE_CALORIES,
+            HealthConnectInternalsConstants.SCOPE_DISTANCES
+    )
+  }
+
+  fun toKilometers(distanceMeters: Double): Double {
+    return distanceMeters / 1000.0
+  }
+
+  fun roundToScale(value: Double, scale: Int = 5): Double {
+    val factor = 10.0.pow(scale.toDouble())
+    return round(value * factor) / factor
+  }
+
+  fun toIsoOffsetString(epochMillis: Long, zoneId: ZoneId): String {
+    return Instant.ofEpochMilli(epochMillis)
+            .atZone(zoneId)
+            .format(DateTimeFormatter.ISO_OFFSET_DATE_TIME)
+  }
+
+  fun buildUnifiedIntervalRecords(
+          stepsSegments: List<NormalizedSegment>,
+          activeTimeSegments: List<NormalizedSegment>,
+          caloriesSegments: List<NormalizedSegment>,
+          distanceSegments: List<NormalizedSegment>,
+          zoneId: ZoneId,
+          roundingScale: Int = 5
+  ): List<UnifiedIntervalRecord> {
+    return HealthConnectUnifiedRecordBuilder.buildUnifiedIntervalRecords(
+            stepsSegments = stepsSegments,
+            activeTimeSegments = activeTimeSegments,
+            caloriesSegments = caloriesSegments,
+            distanceSegments = distanceSegments,
+            zoneId = zoneId,
+            roundingScale = roundingScale
+    )
+  }
+
+  fun buildUnifiedRecordsResult(
+          stepsSegments: List<NormalizedSegment>,
+          activeTimeSegments: List<NormalizedSegment>,
+          caloriesSegments: List<NormalizedSegment>,
+          distanceSegments: List<NormalizedSegment>,
+          zoneId: ZoneId,
+          roundingScale: Int = 5
+  ): UnifiedRecordsBuildResult {
+    return HealthConnectUnifiedRecordBuilder.buildUnifiedRecordsResult(
+            stepsSegments = stepsSegments,
+            activeTimeSegments = activeTimeSegments,
+            caloriesSegments = caloriesSegments,
+            distanceSegments = distanceSegments,
+            zoneId = zoneId,
+            roundingScale = roundingScale
+    )
+  }
+
+  fun isValidPeriod(startInstant: Instant, endInstant: Instant, maxDays: Long = 90): Boolean {
+    if (startInstant.isAfter(endInstant)) {
+      return false
+    }
+
+    val duration = Duration.between(startInstant, endInstant)
+    val maxDuration = Duration.ofDays(maxDays)
+    return duration <= maxDuration
+  }
+
+  fun normalizeAllowlist(sources: List<String>): Set<String> {
+    return sources
+            .map { it.trim() }
+            .filter { it.isNotEmpty() }
+            .map { normalizeSourceType(it) }
+            .toSet()
+  }
+
+  fun normalizePackageAllowlist(packages: List<String>): Set<String> {
+    return packages
+            .map { it.trim().lowercase() }
+            .filter { it.isNotEmpty() }
+            .toSet()
+  }
+
+  fun normalizeSourceType(rawValue: String): String {
+    return HealthConnectSourceTrust.normalizeSourceType(rawValue)
+  }
+
+  fun normalizeSourceType(rawValue: Any?): String {
+    return HealthConnectSourceTrust.normalizeSourceType(rawValue)
+  }
+
+  fun evaluateRecordTrust(metadata: Any?): RecordTrustResult {
+    return HealthConnectSourceTrust.evaluateRecordTrust(metadata)
+  }
+
+  fun resolveTrustLevelFromSource(sourceType: String): String {
+    return HealthConnectSourceTrust.resolveTrustLevelFromSource(sourceType)
+  }
+
+  fun resolveDeviceModel(metadata: Any?): String {
+    return HealthConnectSourceTrust.resolveDeviceModel(metadata)
+  }
+
+  fun isRecordAllowed(sourceType: String, allowlist: Set<String>): Boolean {
+    return HealthConnectSourceTrust.isRecordAllowed(sourceType, allowlist)
+  }
+
+  fun isPackageAllowed(packageName: String?, packageAllowlist: Set<String>): Boolean {
+    if (packageAllowlist.isEmpty()) {
+      return true
+    }
+
+    val normalizedPackageName = packageName?.trim()?.lowercase().orEmpty()
+    if (normalizedPackageName.isEmpty()) {
+      return false
+    }
+
+    return packageAllowlist.contains(normalizedPackageName)
+  }
+
+  fun normalizeOverlaps(
+          metricType: MetricType,
+          rawIntervals: List<IntervalInput>,
+          sinceMs: Long,
+          untilMs: Long,
+          bucketPeriod: String,
+          zoneId: ZoneId
+  ): NormalizationResult {
+    return HealthConnectOverlapNormalizer.normalizeOverlaps(
+            metricType = metricType,
+            rawIntervals = rawIntervals,
+            sinceMs = sinceMs,
+            untilMs = untilMs,
+            bucketPeriod = bucketPeriod,
+            zoneId = zoneId
+    )
+  }
+
+  fun mergeCaloriesWithFallback(
+          primaryActiveCalories: NormalizationResult,
+          totalCalories: NormalizationResult,
+          basalCalories: NormalizationResult,
+          stepsEvidenceSegments: List<NormalizedSegment> = emptyList(),
+          activeTimeEvidenceSegments: List<NormalizedSegment> = emptyList(),
+          distanceEvidenceSegments: List<NormalizedSegment> = emptyList(),
+          basalSeedApplied: Boolean = false,
+          seededFromBeforeSince: Boolean = false,
+          basalSeedAgeHours: Double? = null
+  ): NormalizationResult {
+    return HealthConnectCaloriesFallbackMerger.mergeCaloriesWithFallback(
+            primaryActiveCalories = primaryActiveCalories,
+            totalCalories = totalCalories,
+            basalCalories = basalCalories,
+            stepsEvidenceSegments = stepsEvidenceSegments,
+            activeTimeEvidenceSegments = activeTimeEvidenceSegments,
+            distanceEvidenceSegments = distanceEvidenceSegments,
+            basalSeedApplied = basalSeedApplied,
+            seededFromBeforeSince = seededFromBeforeSince,
+            basalSeedAgeHours = basalSeedAgeHours
+    )
+  }
+
+  fun nextBucketBoundary(timeMs: Long, zoneId: ZoneId, bucketPeriod: String): Long {
+    return HealthConnectOverlapNormalizer.nextBucketBoundary(timeMs, zoneId, bucketPeriod)
+  }
+}