@cariva-dev/exercise-sdk 2.0.0

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

@@ -0,0 +1,400 @@
+package com.carivaexercisesdk.domain.exercise.services
+
+import java.time.Duration
+import java.time.Instant
+import java.time.ZoneId
+
+internal object HealthConnectOverlapNormalizer {
+  fun normalizeOverlaps(
+          metricType: HealthConnectModuleInternals.MetricType,
+          rawIntervals: List<HealthConnectModuleInternals.IntervalInput>,
+          sinceMs: Long,
+          untilMs: Long,
+          bucketPeriod: String,
+          zoneId: ZoneId
+  ): HealthConnectModuleInternals.NormalizationResult {
+    val valid =
+            rawIntervals.mapNotNull { interval ->
+              val clampedStart = maxOf(interval.startMs, sinceMs)
+              val clampedEnd = minOf(interval.endMs, untilMs)
+              if (clampedEnd <= clampedStart) {
+                null
+              } else {
+                HealthConnectModuleInternals.IntervalInput(
+                        startMs = clampedStart,
+                        endMs = clampedEnd,
+                        totalValue = interval.totalValue,
+                        sourceType = HealthConnectSourceTrust.normalizeSourceType(interval.sourceType),
+                        packageName = interval.packageName,
+                        deviceModel = interval.deviceModel
+                )
+              }
+            }
+
+    if (valid.isEmpty()) {
+      return HealthConnectModuleInternals.NormalizationResult(
+              segments = emptyList(),
+              stats = HealthConnectModuleInternals.NormalizationStats(observedIntervals = 0),
+              overlapStrategy = resolveOverlapStrategy(metricType)
+      )
+    }
+
+    val atomicResult = buildAtomicSegments(metricType, valid)
+    val atomic = atomicResult.segments
+    val merged = mergeAdjacentSegments(atomic)
+    val bucketized =
+            bucketize(
+                    segments = merged,
+                    zoneId = zoneId,
+                    bucketPeriod = HealthConnectModuleInternals.normalizeBucketPeriod(bucketPeriod)
+            )
+    val bucketWarnings = mutableListOf<String>()
+    if (bucketized.guardTriggered) {
+      bucketWarnings.add("bucket_boundary_guard_triggered")
+    }
+    val unknownSourceCount =
+            bucketized.segments.count {
+              it.sourceType == HealthConnectInternalsConstants.SOURCE_UNKNOWN
+            }
+    if (unknownSourceCount > 0) {
+      bucketWarnings.add(HealthConnectInternalsConstants.WARNING_UNKNOWN_SOURCE_TYPE)
+    }
+
+    return HealthConnectModuleInternals.NormalizationResult(
+            segments = bucketized.segments,
+            stats =
+                    HealthConnectModuleInternals.NormalizationStats(
+                            droppedNonPositiveCount = atomicResult.droppedNonPositiveCount,
+                            unknownSourceCount = unknownSourceCount,
+                            observedIntervals = valid.size
+                    ),
+            overlapStrategy = resolveOverlapStrategy(metricType),
+            warnings = bucketWarnings
+    )
+  }
+
+  fun nextBucketBoundary(timeMs: Long, zoneId: ZoneId, bucketPeriod: String): Long {
+    val bucketDuration =
+            if (bucketPeriod == HealthConnectInternalsConstants.SUPPORTED_DAILY) {
+              Duration.ofDays(1)
+            } else {
+              Duration.ofHours(1)
+            }
+    val bucketStartMs = alignToBucketStart(timeMs, zoneId, bucketDuration)
+    val bucketStartZoned = Instant.ofEpochMilli(bucketStartMs).atZone(zoneId)
+
+    val next =
+            if (bucketPeriod == HealthConnectInternalsConstants.SUPPORTED_DAILY) {
+              bucketStartZoned.plusDays(1)
+            } else {
+              bucketStartZoned.plusHours(1)
+            }
+    val nextMs = next.toInstant().toEpochMilli()
+    if (nextMs <= timeMs) {
+      return Instant.ofEpochMilli(timeMs).plus(bucketDuration).toEpochMilli()
+    }
+    return nextMs
+  }
+
+  private data class AtomicBuildResult(
+          val segments: List<HealthConnectModuleInternals.NormalizedSegment>,
+          val droppedNonPositiveCount: Int
+  )
+
+  private fun buildAtomicSegments(
+          metricType: HealthConnectModuleInternals.MetricType,
+          intervals: List<HealthConnectModuleInternals.IntervalInput>
+  ): AtomicBuildResult {
+    val breakpoints = intervals.flatMap { listOf(it.startMs, it.endMs) }.toSortedSet().toList()
+
+    if (breakpoints.size < 2) {
+      return AtomicBuildResult(emptyList(), droppedNonPositiveCount = 0)
+    }
+
+    val segments = mutableListOf<HealthConnectModuleInternals.NormalizedSegment>()
+    var droppedNonPositiveCount = 0
+
+    for (index in 0 until breakpoints.lastIndex) {
+      val segmentStart = breakpoints[index]
+      val segmentEnd = breakpoints[index + 1]
+      if (segmentEnd <= segmentStart) {
+        continue
+      }
+
+      val active = intervals.filter { it.startMs < segmentEnd && it.endMs > segmentStart }
+      if (active.isEmpty()) {
+        continue
+      }
+
+      val duration = (segmentEnd - segmentStart).toDouble()
+      val segment =
+              when (metricType) {
+                HealthConnectModuleInternals.MetricType.STEPS ->
+                        resolveStepsSegment(segmentStart, segmentEnd, duration, active)
+                HealthConnectModuleInternals.MetricType.ACTIVE_TIME,
+                HealthConnectModuleInternals.MetricType.CALORIES,
+                HealthConnectModuleInternals.MetricType.DISTANCE ->
+                        resolveProportionalSegment(segmentStart, segmentEnd, duration, active)
+              }
+
+      if (segment.value > 0.0) {
+        segments.add(segment)
+      } else {
+        droppedNonPositiveCount += 1
+      }
+    }
+
+    return AtomicBuildResult(segments = segments, droppedNonPositiveCount = droppedNonPositiveCount)
+  }
+
+  private fun resolveProportionalSegment(
+          segmentStart: Long,
+          segmentEnd: Long,
+          duration: Double,
+          active: List<HealthConnectModuleInternals.IntervalInput>
+  ): HealthConnectModuleInternals.NormalizedSegment {
+    var value = 0.0
+    val sourceTypes = mutableSetOf<String>()
+    val packageNames = mutableSetOf<String>()
+    val deviceModels = mutableSetOf<String>()
+
+    active.forEach { interval ->
+      val intervalDuration = (interval.endMs - interval.startMs).toDouble()
+      if (intervalDuration <= 0.0) {
+        return@forEach
+      }
+      value += interval.totalValue * (duration / intervalDuration)
+      sourceTypes.add(interval.sourceType)
+      if (interval.packageName.isNotEmpty()) {
+        packageNames.add(interval.packageName)
+      }
+      if (interval.deviceModel.isNotEmpty()) {
+        deviceModels.add(interval.deviceModel)
+      }
+    }
+
+    return HealthConnectModuleInternals.NormalizedSegment(
+            startMs = segmentStart,
+            endMs = segmentEnd,
+            value = value,
+            sourceType = resolveMergedSourceType(sourceTypes),
+            packageName = resolveMergedPackageName(packageNames),
+            deviceModel = resolveMergedDeviceModel(deviceModels)
+    )
+  }
+
+  private data class StepWinnerCandidate(
+          val interval: HealthConnectModuleInternals.IntervalInput,
+          val overlapDuration: Double,
+          val intervalDuration: Double
+  )
+
+  private fun resolveStepsSegment(
+          segmentStart: Long,
+          segmentEnd: Long,
+          duration: Double,
+          active: List<HealthConnectModuleInternals.IntervalInput>
+  ): HealthConnectModuleInternals.NormalizedSegment {
+    val winnerPriority = active.maxOf { HealthConnectSourceTrust.resolveSourcePriority(it.sourceType) }
+    val winnerGroup =
+            active.filter {
+              HealthConnectSourceTrust.resolveSourcePriority(it.sourceType) == winnerPriority
+            }
+
+    val winner =
+            winnerGroup
+                    .mapNotNull { interval ->
+                      val intervalDuration = (interval.endMs - interval.startMs).toDouble()
+                      if (intervalDuration <= 0.0) {
+                        return@mapNotNull null
+                      }
+                      val overlapStart = maxOf(segmentStart, interval.startMs)
+                      val overlapEnd = minOf(segmentEnd, interval.endMs)
+                      val overlapDuration = (overlapEnd - overlapStart).toDouble()
+                      if (overlapDuration <= 0.0) {
+                        return@mapNotNull null
+                      }
+                      StepWinnerCandidate(
+                              interval = interval,
+                              overlapDuration = overlapDuration,
+                              intervalDuration = intervalDuration
+                      )
+                    }
+                    .sortedWith(
+                            compareByDescending<StepWinnerCandidate> { it.overlapDuration }
+                                    .thenByDescending { it.intervalDuration }
+                                    .thenBy { it.interval.packageName }
+                                    .thenBy { it.interval.startMs }
+                                    .thenBy { it.interval.endMs }
+                    )
+                    .firstOrNull()
+
+    return HealthConnectModuleInternals.NormalizedSegment(
+            startMs = segmentStart,
+            endMs = segmentEnd,
+            value =
+                    winner?.let { candidate ->
+                      candidate.interval.totalValue * (duration / candidate.intervalDuration)
+                    } ?: 0.0,
+            sourceType = winner?.interval?.sourceType ?: HealthConnectInternalsConstants.SOURCE_UNKNOWN,
+            packageName = winner?.interval?.packageName.orEmpty(),
+            deviceModel = winner?.interval?.deviceModel.orEmpty()
+    )
+  }
+
+  private fun mergeAdjacentSegments(
+          segments: List<HealthConnectModuleInternals.NormalizedSegment>
+  ): List<HealthConnectModuleInternals.NormalizedSegment> {
+    if (segments.isEmpty()) {
+      return emptyList()
+    }
+
+    val sorted = segments.sortedBy { it.startMs }
+    val merged = mutableListOf<HealthConnectModuleInternals.NormalizedSegment>()
+
+    sorted.forEach { current ->
+      val previous = merged.lastOrNull()
+      if (previous != null &&
+                      previous.endMs == current.startMs &&
+                      previous.sourceType == current.sourceType &&
+                      previous.packageName == current.packageName &&
+                      previous.deviceModel == current.deviceModel &&
+                      hasSameRate(previous, current)
+      ) {
+        merged[merged.lastIndex] =
+                previous.copy(endMs = current.endMs, value = previous.value + current.value)
+      } else {
+        merged.add(current)
+      }
+    }
+
+    return merged
+  }
+
+  private fun hasSameRate(
+          left: HealthConnectModuleInternals.NormalizedSegment,
+          right: HealthConnectModuleInternals.NormalizedSegment
+  ): Boolean {
+    val leftDuration = (left.endMs - left.startMs).toDouble()
+    val rightDuration = (right.endMs - right.startMs).toDouble()
+    if (leftDuration <= 0.0 || rightDuration <= 0.0) {
+      return false
+    }
+
+    val leftRate = left.value / leftDuration
+    val rightRate = right.value / rightDuration
+    return kotlin.math.abs(leftRate - rightRate) < 1e-9
+  }
+
+  private data class BucketizeResult(
+          val segments: List<HealthConnectModuleInternals.NormalizedSegment>,
+          val guardTriggered: Boolean
+  )
+
+  private fun bucketize(
+          segments: List<HealthConnectModuleInternals.NormalizedSegment>,
+          zoneId: ZoneId,
+          bucketPeriod: String
+  ): BucketizeResult {
+    if (segments.isEmpty()) {
+      return BucketizeResult(emptyList(), guardTriggered = false)
+    }
+
+    val result = mutableListOf<HealthConnectModuleInternals.NormalizedSegment>()
+    var guardTriggered = false
+
+    segments.forEach { segment ->
+      var cursor = segment.startMs
+      while (cursor < segment.endMs) {
+        val bucketEnd = nextBucketBoundary(cursor, zoneId, bucketPeriod)
+        if (bucketEnd <= cursor) {
+          guardTriggered = true
+          val clippedEnd = segment.endMs
+          val clippedDuration = (clippedEnd - cursor).toDouble()
+          val fullDuration = (segment.endMs - segment.startMs).toDouble()
+          if (clippedDuration > 0.0 && fullDuration > 0.0) {
+            val clippedValue = segment.value * (clippedDuration / fullDuration)
+            result.add(
+                    HealthConnectModuleInternals.NormalizedSegment(
+                            startMs = cursor,
+                            endMs = clippedEnd,
+                            value = clippedValue,
+                            sourceType = segment.sourceType,
+                            packageName = segment.packageName,
+                            deviceModel = segment.deviceModel
+                    )
+            )
+          }
+          break
+        }
+        val clippedEnd = minOf(segment.endMs, bucketEnd)
+        val clippedDuration = (clippedEnd - cursor).toDouble()
+        val fullDuration = (segment.endMs - segment.startMs).toDouble()
+
+        if (clippedDuration > 0.0 && fullDuration > 0.0) {
+          val clippedValue = segment.value * (clippedDuration / fullDuration)
+          result.add(
+                  HealthConnectModuleInternals.NormalizedSegment(
+                          startMs = cursor,
+                          endMs = clippedEnd,
+                          value = clippedValue,
+                          sourceType = segment.sourceType,
+                          packageName = segment.packageName,
+                          deviceModel = segment.deviceModel
+                  )
+          )
+        }
+
+        cursor = clippedEnd
+      }
+    }
+
+    return BucketizeResult(segments = result, guardTriggered = guardTriggered)
+  }
+
+  private fun alignToBucketStart(timeMs: Long, zoneId: ZoneId, bucketDuration: Duration): Long {
+    val instant = Instant.ofEpochMilli(timeMs)
+    val zoned = instant.atZone(zoneId)
+
+    return if (bucketDuration == Duration.ofDays(1)) {
+      zoned.toLocalDate().atStartOfDay(zoneId).toInstant().toEpochMilli()
+    } else {
+      zoned.withMinute(0).withSecond(0).withNano(0).toInstant().toEpochMilli()
+    }
+  }
+
+  private fun resolveOverlapStrategy(metricType: HealthConnectModuleInternals.MetricType): String {
+    return when (metricType) {
+      HealthConnectModuleInternals.MetricType.STEPS ->
+              HealthConnectInternalsConstants.OVERLAP_STRATEGY_SOURCE_PRIORITY
+      HealthConnectModuleInternals.MetricType.ACTIVE_TIME,
+      HealthConnectModuleInternals.MetricType.CALORIES,
+      HealthConnectModuleInternals.MetricType.DISTANCE ->
+              HealthConnectInternalsConstants.OVERLAP_STRATEGY_PROPORTIONAL
+    }
+  }
+
+  private fun resolveMergedSourceType(sourceTypes: Set<String>): String {
+    return when (sourceTypes.size) {
+      0 -> HealthConnectInternalsConstants.SOURCE_UNKNOWN
+      1 -> sourceTypes.first()
+      else -> HealthConnectInternalsConstants.SOURCE_UNKNOWN
+    }
+  }
+
+  private fun resolveMergedPackageName(packageNames: Set<String>): String {
+    return when (packageNames.size) {
+      0 -> ""
+      1 -> packageNames.first()
+      else -> "multiple"
+    }
+  }
+
+  private fun resolveMergedDeviceModel(deviceModels: Set<String>): String {
+    return when (deviceModels.size) {
+      0 -> ""
+      1 -> deviceModels.first()
+      else -> deviceModels.toList().sorted().joinToString(", ")
+    }
+  }
+}

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

@@ -0,0 +1,249 @@
+package com.carivaexercisesdk.domain.exercise.services
+
+internal object HealthConnectSourceTrust {
+  fun normalizeSourceType(rawValue: String): String {
+    return when (rawValue.trim().lowercase()) {
+      HealthConnectInternalsConstants.SOURCE_MANUAL_INPUT,
+      "manual",
+      "manual_entry" -> HealthConnectInternalsConstants.SOURCE_MANUAL_INPUT
+      HealthConnectInternalsConstants.SOURCE_DEVICE,
+      "automatic",
+      "automatically_recorded" -> HealthConnectInternalsConstants.SOURCE_DEVICE
+      HealthConnectInternalsConstants.SOURCE_APP,
+      "actively_recorded" -> HealthConnectInternalsConstants.SOURCE_APP
+      HealthConnectInternalsConstants.SOURCE_UNKNOWN -> HealthConnectInternalsConstants.SOURCE_UNKNOWN
+      else -> HealthConnectInternalsConstants.SOURCE_UNKNOWN
+    }
+  }
+
+  fun normalizeSourceType(rawValue: Any?): String {
+    return when (rawValue) {
+      is Number ->
+              when (safeToInt(rawValue) ?: Int.MIN_VALUE) {
+                1 -> HealthConnectInternalsConstants.SOURCE_APP
+                2 -> HealthConnectInternalsConstants.SOURCE_DEVICE
+                3 -> HealthConnectInternalsConstants.SOURCE_MANUAL_INPUT
+                else -> HealthConnectInternalsConstants.SOURCE_UNKNOWN
+              }
+      is String -> normalizeSourceType(rawValue)
+      else -> normalizeSourceType(rawValue?.toString().orEmpty())
+    }
+  }
+
+  fun evaluateRecordTrust(metadata: Any?): HealthConnectModuleInternals.RecordTrustResult {
+    if (metadata == null) {
+      return HealthConnectModuleInternals.RecordTrustResult(
+              allowed = false,
+              reason = HealthConnectInternalsConstants.TRUST_REASON_MALFORMED_METADATA,
+              sourceType = HealthConnectInternalsConstants.SOURCE_UNKNOWN,
+              trustLevel = HealthConnectInternalsConstants.TRUST_LEVEL_REJECTED
+      )
+    }
+
+    val recordingMethodResult = invokeGetter(metadata, "getRecordingMethod")
+    if (recordingMethodResult.invocationFailed) {
+      return HealthConnectModuleInternals.RecordTrustResult(
+              allowed = false,
+              reason = HealthConnectInternalsConstants.TRUST_REASON_MALFORMED_METADATA,
+              sourceType = HealthConnectInternalsConstants.SOURCE_UNKNOWN,
+              trustLevel = HealthConnectInternalsConstants.TRUST_LEVEL_REJECTED
+      )
+    }
+
+    val sourceType = normalizeSourceType(recordingMethodResult.value)
+    return when (sourceType) {
+      HealthConnectInternalsConstants.SOURCE_MANUAL_INPUT -> {
+        val deviceResult = invokeGetter(metadata, "getDevice")
+        if (deviceResult.invocationFailed) {
+          return HealthConnectModuleInternals.RecordTrustResult(
+                  allowed = false,
+                  reason = HealthConnectInternalsConstants.TRUST_REASON_MALFORMED_METADATA,
+                  sourceType = HealthConnectInternalsConstants.SOURCE_UNKNOWN,
+                  trustLevel = HealthConnectInternalsConstants.TRUST_LEVEL_REJECTED
+          )
+        }
+
+        val hasDeviceIdentity = hasDeviceIdentity(deviceResult.value)
+        if (hasDeviceIdentity) {
+          HealthConnectModuleInternals.RecordTrustResult(
+                  allowed = true,
+                  reason =
+                          HealthConnectInternalsConstants
+                                  .TRUST_REASON_MANUAL_WITH_DEVICE_LOW_CONFIDENCE,
+                  sourceType = HealthConnectInternalsConstants.SOURCE_MANUAL_INPUT,
+                  trustLevel = HealthConnectInternalsConstants.TRUST_LEVEL_LOW_CONFIDENCE
+          )
+        } else {
+          HealthConnectModuleInternals.RecordTrustResult(
+                  allowed = false,
+                  reason = HealthConnectInternalsConstants.TRUST_REASON_MANUAL_INPUT,
+                  sourceType = HealthConnectInternalsConstants.SOURCE_MANUAL_INPUT,
+                  trustLevel = HealthConnectInternalsConstants.TRUST_LEVEL_REJECTED
+          )
+        }
+      }
+      HealthConnectInternalsConstants.SOURCE_APP,
+      HealthConnectInternalsConstants.SOURCE_DEVICE ->
+              HealthConnectModuleInternals.RecordTrustResult(
+                      allowed = true,
+                      reason = HealthConnectInternalsConstants.TRUST_REASON_ALLOWED,
+                      sourceType = sourceType,
+                      trustLevel = HealthConnectInternalsConstants.TRUST_LEVEL_TRUSTED
+              )
+      else -> {
+        val deviceResult = invokeGetter(metadata, "getDevice")
+        if (deviceResult.invocationFailed) {
+          return HealthConnectModuleInternals.RecordTrustResult(
+                  allowed = false,
+                  reason = HealthConnectInternalsConstants.TRUST_REASON_MALFORMED_METADATA,
+                  sourceType = HealthConnectInternalsConstants.SOURCE_UNKNOWN,
+                  trustLevel = HealthConnectInternalsConstants.TRUST_LEVEL_REJECTED
+          )
+        }
+
+        val hasDeviceIdentity = hasDeviceIdentity(deviceResult.value)
+        HealthConnectModuleInternals.RecordTrustResult(
+                allowed = hasDeviceIdentity,
+                reason =
+                        if (hasDeviceIdentity) {
+                          HealthConnectInternalsConstants
+                                  .TRUST_REASON_UNKNOWN_WITH_DEVICE_LOW_CONFIDENCE
+                        } else {
+                          HealthConnectInternalsConstants.TRUST_REASON_UNKNOWN_WITHOUT_DEVICE
+                        },
+                sourceType = HealthConnectInternalsConstants.SOURCE_UNKNOWN,
+                trustLevel =
+                        if (hasDeviceIdentity) {
+                          HealthConnectInternalsConstants.TRUST_LEVEL_LOW_CONFIDENCE
+                        } else {
+                          HealthConnectInternalsConstants.TRUST_LEVEL_REJECTED
+                        }
+        )
+      }
+    }
+  }
+
+  fun resolveTrustLevelFromSource(sourceType: String): String {
+    return when (normalizeSourceType(sourceType)) {
+      HealthConnectInternalsConstants.SOURCE_DEVICE,
+      HealthConnectInternalsConstants.SOURCE_APP -> HealthConnectInternalsConstants.TRUST_LEVEL_TRUSTED
+      else -> HealthConnectInternalsConstants.TRUST_LEVEL_LOW_CONFIDENCE
+    }
+  }
+
+  fun resolveDeviceModel(metadata: Any?): String {
+    if (metadata == null) {
+      return ""
+    }
+
+    val deviceResult = invokeGetter(metadata, "getDevice")
+    if (deviceResult.invocationFailed) {
+      return ""
+    }
+
+    val device = deviceResult.value ?: return ""
+    val manufacturer = readNonBlankGetterValue(device, "getManufacturer")
+    val model = readNonBlankGetterValue(device, "getModel")
+
+    val combined = listOf(manufacturer, model).filter { it.isNotEmpty() }.joinToString(" ").trim()
+    if (combined.isNotEmpty()) {
+      return combined
+    }
+
+    val fallback = device.toString().trim()
+    if (fallback.isEmpty() || fallback == "null") {
+      return ""
+    }
+    if (Regex("^[\\w.$]+@[0-9a-fA-F]+$").matches(fallback)) {
+      return ""
+    }
+    return fallback
+  }
+
+  fun isRecordAllowed(sourceType: String, allowlist: Set<String>): Boolean {
+    return allowlist.contains(normalizeSourceType(sourceType))
+  }
+
+  fun resolveSourcePriority(sourceType: String): Int {
+    return HealthConnectInternalsConstants.SOURCE_PRIORITY[normalizeSourceType(sourceType)]
+            ?: HealthConnectInternalsConstants.SOURCE_PRIORITY.getValue(
+                    HealthConnectInternalsConstants.SOURCE_UNKNOWN
+            )
+  }
+
+  private data class GetterResult(val value: Any?, val invocationFailed: Boolean)
+
+  private fun invokeGetter(target: Any, methodName: String): GetterResult {
+    val method =
+            (target.javaClass.methods.firstOrNull { candidate ->
+                      candidate.name == methodName && candidate.parameterCount == 0
+                    }
+                    ?: target.javaClass.declaredMethods.firstOrNull { candidate ->
+                      candidate.name == methodName && candidate.parameterCount == 0
+                    })
+                    ?: return GetterResult(value = null, invocationFailed = false)
+
+    return try {
+      if (!method.isAccessible) {
+        method.isAccessible = true
+      }
+      GetterResult(value = method.invoke(target), invocationFailed = false)
+    } catch (_: Throwable) {
+      GetterResult(value = null, invocationFailed = true)
+    }
+  }
+
+  private fun hasDeviceIdentity(device: Any?): Boolean {
+    if (device == null) {
+      return false
+    }
+
+    if (hasNonBlankGetterValue(device, "getManufacturer")) {
+      return true
+    }
+    if (hasNonBlankGetterValue(device, "getModel")) {
+      return true
+    }
+    if (hasPositiveNumericGetterValue(device, "getType")) {
+      return true
+    }
+
+    val text = device.toString().trim()
+    if (text.isEmpty() || text == "null") {
+      return false
+    }
+    if (Regex("^[\\w.$]+@[0-9a-fA-F]+$").matches(text)) {
+      return false
+    }
+    return true
+  }
+
+  private fun hasNonBlankGetterValue(target: Any, methodName: String): Boolean {
+    return readNonBlankGetterValue(target, methodName).isNotEmpty()
+  }
+
+  private fun hasPositiveNumericGetterValue(target: Any, methodName: String): Boolean {
+    val result = invokeGetter(target, methodName)
+    if (result.invocationFailed) {
+      return false
+    }
+    val value = result.value
+    if (value !is Number) {
+      return false
+    }
+    return (safeToInt(value) ?: 0) > 0
+  }
+
+  private fun readNonBlankGetterValue(target: Any, methodName: String): String {
+    val result = invokeGetter(target, methodName)
+    if (result.invocationFailed) {
+      return ""
+    }
+    val text = result.value?.toString()?.trim().orEmpty()
+    return if (text.isNotEmpty() && text != "null") text else ""
+  }
+
+  private fun safeToInt(value: Number): Int? {
+    return runCatching { value.toInt() }.getOrNull()
+  }
+}