refactor: Extract toCachedState extension and add tests

Move per-device persist logic from DeviceMonitor into a pure PodDevice.toCachedState() extension in the cache package. Add ToCachedStateTest with coverage for creates, skips, dedup, and slot preservation. Delete unused PodSorter.

app/src/main/java/eu/darken/capod/monitor/core/DeviceMonitor.kt

@@ -6,21 +6,15 @@ import eu.darken.capod.common.debug.logging.log
 import eu.darken.capod.common.debug.logging.logTag
 import eu.darken.capod.common.flow.replayingShare
 import eu.darken.capod.monitor.core.ble.BlePodMonitor
-import eu.darken.capod.monitor.core.cache.CachedDeviceState
-import eu.darken.capod.monitor.core.cache.CachedDeviceState.CachedBatterySlot
 import eu.darken.capod.monitor.core.cache.DeviceStateCache
+import eu.darken.capod.monitor.core.cache.toCachedState
 import eu.darken.capod.pods.core.apple.aap.AapConnectionManager
-import eu.darken.capod.pods.core.apple.ble.DualBlePodSnapshot
-import eu.darken.capod.pods.core.apple.ble.SingleBlePodSnapshot
-import eu.darken.capod.pods.core.apple.ble.devices.HasCase
 import eu.darken.capod.profiles.core.DeviceProfilesRepo
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.firstOrNull
 import kotlinx.coroutines.flow.onEach
-import java.time.Duration
-import java.time.Instant
 import javax.inject.Inject
 import javax.inject.Singleton
 
@@ -76,54 +70,15 @@ class DeviceMonitor @Inject constructor(
 
     private suspend fun persistLiveDevices(devices: List<PodDevice>) {
         for (device in devices) {
-            if (!device.isLive) continue
             val profileId = device.profileId ?: continue
-
-            val now = Instant.now()
             val existing = deviceStateCache.cachedStates.value[profileId]
+            val newState = device.toCachedState(existing) ?: continue
 
-            val liveLeft = device.aap?.batteryLeft ?: (device.ble as? DualBlePodSnapshot)?.batteryLeftPodPercent
-            val liveRight = device.aap?.batteryRight ?: (device.ble as? DualBlePodSnapshot)?.batteryRightPodPercent
-            val liveCase = device.aap?.batteryCase ?: (device.ble as? HasCase)?.batteryCasePercent
-            val liveHeadset = device.aap?.batteryHeadset ?: (device.ble as? SingleBlePodSnapshot)?.batteryHeadsetPercent
-
-            if (liveLeft == null && liveRight == null && liveCase == null && liveHeadset == null) continue
-
-            val newState = CachedDeviceState(
-                profileId = profileId,
-                model = device.model,
-                address = device.address,
-                left = liveLeft?.let { CachedBatterySlot(it, now) } ?: existing?.left,
-                right = liveRight?.let { CachedBatterySlot(it, now) } ?: existing?.right,
-                case = liveCase?.let { CachedBatterySlot(it, now) } ?: existing?.case,
-                headset = liveHeadset?.let { CachedBatterySlot(it, now) } ?: existing?.headset,
-                isLeftCharging = device.isLeftPodCharging,
-                isRightCharging = device.isRightPodCharging,
-                isCaseCharging = device.isCaseCharging,
-                isHeadsetCharging = device.isHeadsetBeingCharged,
-                lastSeenAt = device.seenLastAt ?: now,
-            )
-
-            if (isSameState(existing, newState)) continue
-
-            log(TAG, VERBOSE) { "Persisting state for $profileId (L=$liveLeft R=$liveRight C=$liveCase H=$liveHeadset)" }
+            log(TAG, VERBOSE) { "Persisting state for $profileId" }
             deviceStateCache.save(profileId, newState)
         }
     }
 
-    private fun isSameState(old: CachedDeviceState?, new: CachedDeviceState): Boolean {
-        if (old == null) return false
-        if (Duration.between(old.lastSeenAt, new.lastSeenAt).abs() > Duration.ofMinutes(1)) return false
-        return old.left?.percent == new.left?.percent
-            && old.right?.percent == new.right?.percent
-            && old.case?.percent == new.case?.percent
-            && old.headset?.percent == new.headset?.percent
-            && old.isLeftCharging == new.isLeftCharging
-            && old.isRightCharging == new.isRightCharging
-            && old.isCaseCharging == new.isCaseCharging
-            && old.isHeadsetCharging == new.isHeadsetCharging
-    }
-
     suspend fun getDeviceForProfile(profileId: String): PodDevice? {
         log(TAG) { "getDeviceForProfile(profileId=$profileId)" }
 

app/src/main/java/eu/darken/capod/monitor/core/DeviceMonitorExtensions.kt

@@ -70,3 +70,4 @@ fun PodDevice.cachedBatteryFormatted(now: Instant): String {
         )
     }
 }
+

app/src/main/java/eu/darken/capod/monitor/core/PodSorter.kt

@@ -1,9 +0,0 @@
-package eu.darken.capod.monitor.core
-
-import dagger.Reusable
-import javax.inject.Inject
-
-@Reusable
-class PodSorter @Inject constructor(
-
-)

app/src/main/java/eu/darken/capod/monitor/core/cache/DeviceStateCacheExtensions.kt

@@ -0,0 +1,63 @@
+package eu.darken.capod.monitor.core.cache
+
+import eu.darken.capod.monitor.core.PodDevice
+import eu.darken.capod.monitor.core.cache.CachedDeviceState.CachedBatterySlot
+import eu.darken.capod.pods.core.apple.ble.DualBlePodSnapshot
+import eu.darken.capod.pods.core.apple.ble.SingleBlePodSnapshot
+import eu.darken.capod.pods.core.apple.ble.devices.HasCase
+import java.time.Duration
+import java.time.Instant
+
+/**
+ * Creates a [CachedDeviceState] from this live device's raw BLE/AAP battery data.
+ * Returns null if:
+ * - The device is not live (cached-only)
+ * - The device has no profile
+ * - All live battery values are null
+ * - The state hasn't changed from [existing] (dedup)
+ */
+fun PodDevice.toCachedState(
+    existing: CachedDeviceState?,
+    now: Instant = Instant.now(),
+): CachedDeviceState? {
+    if (!isLive) return null
+    val pid = profileId ?: return null
+
+    val liveLeft = aap?.batteryLeft ?: (ble as? DualBlePodSnapshot)?.batteryLeftPodPercent
+    val liveRight = aap?.batteryRight ?: (ble as? DualBlePodSnapshot)?.batteryRightPodPercent
+    val liveCase = aap?.batteryCase ?: (ble as? HasCase)?.batteryCasePercent
+    val liveHeadset = aap?.batteryHeadset ?: (ble as? SingleBlePodSnapshot)?.batteryHeadsetPercent
+
+    if (liveLeft == null && liveRight == null && liveCase == null && liveHeadset == null) return null
+
+    val newState = CachedDeviceState(
+        profileId = pid,
+        model = model,
+        address = address,
+        left = liveLeft?.let { CachedBatterySlot(it, now) } ?: existing?.left,
+        right = liveRight?.let { CachedBatterySlot(it, now) } ?: existing?.right,
+        case = liveCase?.let { CachedBatterySlot(it, now) } ?: existing?.case,
+        headset = liveHeadset?.let { CachedBatterySlot(it, now) } ?: existing?.headset,
+        isLeftCharging = isLeftPodCharging,
+        isRightCharging = isRightPodCharging,
+        isCaseCharging = isCaseCharging,
+        isHeadsetCharging = isHeadsetBeingCharged,
+        lastSeenAt = seenLastAt ?: now,
+    )
+
+    if (existing != null && !hasStateChanged(existing, newState)) return null
+
+    return newState
+}
+
+private fun hasStateChanged(old: CachedDeviceState, new: CachedDeviceState): Boolean {
+    if (Duration.between(old.lastSeenAt, new.lastSeenAt).abs() > Duration.ofMinutes(1)) return true
+    return old.left?.percent != new.left?.percent
+        || old.right?.percent != new.right?.percent
+        || old.case?.percent != new.case?.percent
+        || old.headset?.percent != new.headset?.percent
+        || old.isLeftCharging != new.isLeftCharging
+        || old.isRightCharging != new.isRightCharging
+        || old.isCaseCharging != new.isCaseCharging
+        || old.isHeadsetCharging != new.isHeadsetCharging
+}