Add reaction option: Popup on new connection

2026-09-16 11:16:12 -04:00 · 2023-07-05 08:21:37 +02:00
parent c9587b2bf0
commit ef1c4615aa
12 changed files with 238 additions and 41 deletions
@@ -0,0 +1,15 @@
+package eu.darken.capod.common.bluetooth
+
+import android.bluetooth.BluetoothDevice
+import java.time.Instant
+
+data class BluetoothDevice2(
+    internal val internal: BluetoothDevice,
+    val seenFirstAt: Instant,
+) {
+    val address: String
+        get() = internal.address
+
+    val name: String?
+        get() = internal.name
+}
@@ -1,6 +1,10 @@
 package eu.darken.capod.common.bluetooth

-import android.bluetooth.*
+import android.bluetooth.BluetoothAdapter
+import android.bluetooth.BluetoothDevice
+import android.bluetooth.BluetoothHeadset
+import android.bluetooth.BluetoothManager
+import android.bluetooth.BluetoothProfile
 import android.bluetooth.le.BluetoothLeScanner
 import android.content.BroadcastReceiver
 import android.content.Context
@@ -12,14 +16,24 @@ import android.os.ParcelUuid
 import dagger.hilt.android.qualifiers.ApplicationContext
 import eu.darken.capod.common.coroutine.DispatcherProvider
 import eu.darken.capod.common.debug.Bugs
-import eu.darken.capod.common.debug.logging.Logging.Priority.*
+import eu.darken.capod.common.debug.logging.Logging.Priority.ERROR
+import eu.darken.capod.common.debug.logging.Logging.Priority.VERBOSE
+import eu.darken.capod.common.debug.logging.Logging.Priority.WARN
 import eu.darken.capod.common.debug.logging.log
 import eu.darken.capod.common.debug.logging.logTag
 import eu.darken.capod.pods.core.apple.protocol.ContinuityProtocol
 import kotlinx.coroutines.channels.awaitClose
-import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.callbackFlow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
 import java.io.IOException
+import java.time.Instant
 import javax.inject.Inject
 import javax.inject.Singleton

@@ -74,7 +88,7 @@ class BluetoothManager2 @Inject constructor(
            }

            override fun onServiceDisconnected(profile: Int) {
-                log(TAG, WARN) { "onServiceDisconnected(profile=$profile" }
+                log(TAG, WARN) { "onServiceDisconnected(profile=$profile)" }
                close(IOException("BluetoothProfile service disconnected (profile=$profile)"))
            }

@@ -128,6 +142,7 @@ class BluetoothManager2 @Inject constructor(
                                log(TAG) { "Adding $device to current devices $currentDevices" }
                                trySend(currentDevices.plus(device))
                            }
+
                            BluetoothDevice.ACTION_ACL_DISCONNECTED -> {
                                log(TAG) { "Removing $device from current devices $currentDevices" }
                                trySend(currentDevices.minus(device))
@@ -145,23 +160,54 @@ class BluetoothManager2 @Inject constructor(
        }
    }

+    private val seenDevicesLock = Mutex()
+    private val seenDevicesCache = mutableMapOf<String, Instant>()
+
    fun connectedDevices(
        featureFilter: Set<ParcelUuid> = ContinuityProtocol.BLE_FEATURE_UUIDS
-    ): Flow<List<BluetoothDevice>> = isBluetoothEnabled
+    ): Flow<List<BluetoothDevice2>> = isBluetoothEnabled
        .flatMapLatest { monitorDevicesForProfile(BluetoothProfile.HEADSET) }
        .map { devices ->
-            devices.filter { device ->
-                featureFilter.any { feature ->
-                    device.hasFeature(feature)
-                }
+            val currentAddresses = devices.map { it.address }
+
+            seenDevicesLock.withLock {
+                val cleanedCache = seenDevicesCache.filterKeys { currentAddresses.contains(it) }
+                seenDevicesCache.clear()
+                seenDevicesCache.putAll(cleanedCache)
            }
+
+            devices
+                .filter { device -> featureFilter.any { feature -> device.hasFeature(feature) } }
+                .map { device ->
+                    BluetoothDevice2(
+                        internal = device,
+                        seenFirstAt = seenDevicesLock.withLock {
+                            seenDevicesCache[device.address] ?: Instant.now().also {
+                                seenDevicesCache[device.address] = it
+                            }
+                        }
+                    )
+                }
        }

-    fun bondedDevices(): Flow<Set<BluetoothDevice>> = flow {
-        emit(adapter?.bondedDevices ?: throw IllegalStateException("Bluetooth adapter unavailable"))
+    fun bondedDevices(): Flow<Set<BluetoothDevice2>> = flow {
+        val rawDevices = adapter?.bondedDevices ?: throw IllegalStateException("Bluetooth adapter unavailable")
+        val wrappedDevices = rawDevices.map { device ->
+
+            BluetoothDevice2(
+                internal = device,
+                seenFirstAt = seenDevicesLock.withLock {
+                    seenDevicesCache[device.address] ?: Instant.now().also {
+                        seenDevicesCache[device.address] = it
+                    }
+                }
+            )
+
+        }.toSet()
+        emit(wrappedDevices)
    }

-    suspend fun nudgeConnection(device: BluetoothDevice): Boolean = getBluetoothProfile().map { bluetoothProfile ->
+    suspend fun nudgeConnection(device: BluetoothDevice2): Boolean = getBluetoothProfile().map { bluetoothProfile ->
        try {
            log(TAG) { "Nudging Android connection to $device" }

@@ -169,7 +215,7 @@ class BluetoothManager2 @Inject constructor(
                "connect", BluetoothDevice::class.java
            ).apply { isAccessible = true }

-            connectMethod.invoke(bluetoothProfile.proxy, device)
+            connectMethod.invoke(bluetoothProfile.proxy, device.internal)

            log(TAG) { "Nudged connection to $device" }
            true
@@ -47,6 +47,11 @@ class ReactionSettings @Inject constructor(
        false
    )

+    val showPopUpOnConnection = preferences.createFlowPreference(
+        "reaction.popup.connected",
+        false
+    )
+
    val onePodMode = preferences.createFlowPreference(
        "reaction.onepod.enabled",
        false
@@ -58,6 +63,7 @@ class ReactionSettings @Inject constructor(
        autoConnect,
        autoConnectCondition,
        showPopUpOnCaseOpen,
+        showPopUpOnConnection,
        onePodMode,
    )
 }
@@ -1,15 +1,26 @@
 package eu.darken.capod.reaction.core.popup

-import eu.darken.capod.common.debug.logging.Logging.Priority.*
+import eu.darken.capod.common.bluetooth.BluetoothManager2
+import eu.darken.capod.common.debug.logging.Logging.Priority.INFO
+import eu.darken.capod.common.debug.logging.Logging.Priority.VERBOSE
+import eu.darken.capod.common.debug.logging.Logging.Priority.WARN
 import eu.darken.capod.common.debug.logging.log
 import eu.darken.capod.common.debug.logging.logTag
 import eu.darken.capod.common.flow.setupCommonEventHandlers
 import eu.darken.capod.common.flow.withPrevious
+import eu.darken.capod.main.core.GeneralSettings
 import eu.darken.capod.monitor.core.PodMonitor
 import eu.darken.capod.pods.core.PodDevice
 import eu.darken.capod.pods.core.apple.DualApplePods
 import eu.darken.capod.reaction.core.ReactionSettings
-import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.distinctUntilChangedBy
+import kotlinx.coroutines.flow.emptyFlow
+import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.mapNotNull
+import kotlinx.coroutines.flow.merge
 import java.time.Duration
 import java.time.Instant
 import javax.inject.Inject
@@ -19,11 +30,13 @@ import javax.inject.Singleton
 class PopUpReaction @Inject constructor(
    private val podMonitor: PodMonitor,
    private val reactionSettings: ReactionSettings,
+    private val generalSettings: GeneralSettings,
+    private val bluetoothManager: BluetoothManager2,
 ) {

-    private val coolDowns = mutableMapOf<PodDevice.Id, Instant>()
+    private val caseCoolDowns = mutableMapOf<PodDevice.Id, Instant>()

-    fun monitor(): Flow<Event> = reactionSettings.showPopUpOnCaseOpen.flow
+    private fun monitorCase(): Flow<Event> = reactionSettings.showPopUpOnCaseOpen.flow
        .flatMapLatest { isEnabled ->
            if (isEnabled) {
                podMonitor.mainDevice.distinctUntilChangedBy { it?.rawDataHex }
@@ -32,7 +45,7 @@ class PopUpReaction @Inject constructor(
            }
        }
        .withPrevious()
-        .setupCommonEventHandlers(TAG) { "monitor" }
+        .setupCommonEventHandlers(TAG) { "popUpCase" }
        .mapNotNull { (previous, current) ->
            if (previous !is DualApplePods? || current !is DualApplePods) {
                return@mapNotNull null
@@ -54,35 +67,37 @@ class PopUpReaction @Inject constructor(
            }
            log(TAG) { "Case lid status changed for monitored device." }

-            tryPopWindow(current)
+            throttleCasePopUps(current)
        }

-    private suspend fun tryPopWindow(current: DualApplePods): Event? = when {
+    private fun throttleCasePopUps(current: DualApplePods): Event? = when {
        current.caseLidState == DualApplePods.LidState.OPEN -> {
            log(TAG, INFO) { "Show popup" }

            val now = Instant.now()
-            val lastShown = coolDowns[current.identifier] ?: Instant.MIN
+            val lastShown = caseCoolDowns[current.identifier] ?: Instant.MIN
            val sinceLastPop = Duration.between(lastShown, now)
-            log(TAG) { "Time since last popup: $sinceLastPop" }
+            log(TAG) { "Time since last case popup: $sinceLastPop" }

            if (sinceLastPop >= Duration.ofSeconds(10)) {
-                coolDowns[current.identifier] = Instant.now()
+                caseCoolDowns[current.identifier] = Instant.now()
                Event.PopupShow(device = current)
            } else {
-                log(TAG, INFO) { "Popup is still on cooldown: $sinceLastPop" }
+                log(TAG, INFO) { "Case popup is still on cooldown: $sinceLastPop" }
                null
            }
        }
+
        current.caseLidState != DualApplePods.LidState.OPEN -> {
            when (current.caseLidState) {
                DualApplePods.LidState.CLOSED -> {
                    log(TAG, INFO) { "Lid was actively closed, resetting cooldown." }
-                    coolDowns.remove(current.identifier)
+                    caseCoolDowns.remove(current.identifier)
                }
+
                else -> {
                    log(TAG, WARN) { "Lid was was not actively closed, refreshing cooldown." }
-                    coolDowns[current.identifier] = Instant.now()
+                    caseCoolDowns[current.identifier] = Instant.now()
                }
            }

@@ -90,9 +105,78 @@ class PopUpReaction @Inject constructor(

            Event.PopupHide()
        }
+
        else -> null
    }

+    private val connectionCoolDowns = mutableMapOf<String, Instant>()
+
+    private fun monitorConnection(): Flow<Event> = reactionSettings.showPopUpOnConnection.flow
+        .flatMapLatest { isEnabled ->
+            if (!isEnabled) return@flatMapLatest emptyFlow()
+
+            combine(
+                generalSettings.mainDeviceAddress.flow,
+                bluetoothManager.connectedDevices().distinctUntilChanged(),
+                podMonitor.mainDevice.distinctUntilChangedBy { it?.rawDataHex },
+            ) { targetAddress, devices, broadcast ->
+                log(TAG) { "$targetAddress $broadcast $devices " }
+                val direct = devices.singleOrNull { it.address == targetAddress }.also {
+                    log(TAG, VERBOSE) { "Connected main device is $it" }
+                }
+                if (direct == null) {
+                    connectionCoolDowns.remove(targetAddress).also {
+                        if (it != null) log(TAG) { "Cleared connection cooldown for $targetAddress due to disconect" }
+                    }
+                }
+                if (direct != null && broadcast != null) direct to broadcast else null
+            }
+        }
+        .withPrevious()
+        .mapNotNull { (previouss, currents) ->
+            val previousConnected = previouss?.first
+            log(TAG, VERBOSE) { "previousConnected: $previousConnected" }
+            val previousBroadcasted = previouss?.second
+            log(TAG, VERBOSE) { "previousBroadcasted: $previousBroadcasted" }
+            val currentConnected = currents?.first
+            log(TAG, VERBOSE) { "currentConnected: $currentConnected" }
+            val currentBroadcasted = currents?.second
+            log(TAG, VERBOSE) { "currentBroadcasted: $currentBroadcasted" }
+
+            if (previousConnected != null && previousBroadcasted != null && currentConnected == null) {
+                return@mapNotNull Event.PopupHide()
+            }
+
+            if (currentConnected == null || currentBroadcasted == null) {
+                // We need an active connection
+                return@mapNotNull null
+            }
+
+            val ageOfBroadcastedDevice = Duration.between(Instant.now(), currentBroadcasted.seenFirstAt)
+            val ageOfConnectedDevice = Duration.between(Instant.now(), currentConnected.seenFirstAt)
+            if (ageOfBroadcastedDevice > (ageOfConnectedDevice + Duration.ofSeconds(30))) {
+                // This is likely a false positive, some random nearby device
+                // We expect the first broadcasts to not be much older than the first connection
+                log(TAG, VERBOSE) { "Current broadcasted main device is probably a false-positive" }
+                return@mapNotNull null
+            }
+
+            val now = Instant.now()
+            val lastShown = connectionCoolDowns[currentConnected.address]
+            val sinceLastPop = lastShown?.let { Duration.between(it, now) }
+            log(TAG) { "Time since last connection popup: ${sinceLastPop?.seconds}s" }
+
+            if (lastShown == null) {
+                connectionCoolDowns[currentConnected.address] = Instant.now()
+                Event.PopupShow(device = currentBroadcasted)
+            } else {
+                log(TAG) { "Connection popup is still on cooldown: $sinceLastPop" }
+                null
+            }
+        }
+        .setupCommonEventHandlers(TAG) { "popUpConnection" }
+
+    fun monitor(): Flow<Event> = merge(monitorCase(), monitorConnection())

    sealed class Event {
        data class PopupShow(