Keyboard: combine state + nodes flows, drop stale node batches (#2255)

Wires the deferred pieces from #2249 and #2250 together:

- KeyboardNodesState.isStaleAgainst(currentBounds) compares the captured
  IME bounds against a live target.
- KeyboardNodesPolicy.shouldDropAsStale(nodes, state) lifts the full
  drop-or-forward rule into one place (hidden / uninitialized / stale).
- StartupOrchestrator combines KeyboardManager.keyboardState with
  NodeExaminer.keyboardNodesState and only forwards a batch to the
  scanner when the policy says it is current.

Closes the race where the keyboard scanner could receive a node batch
captured against a previous IME's bounds — e.g. swapping IMEs while
item-scanning, or the initial empty default emission before NodeExaminer
has run.

Unit tests cover the hidden and uninitialized drop paths. The
bounds-mismatch path needs android.graphics.Rect, which throws "Stub!"
in pure-JVM tests, and is left to on-device verification.

Fixes #2251

Co-authored-by: Owen McGirr <o.a.mcgirr@gmail.com>

Author: enaboapps

app/src/main/java/com/enaboapps/switchify/service/core/StartupOrchestrator.kt

@@ -1,9 +1,14 @@
 package com.enaboapps.switchify.service.core
 
 import android.accessibilityservice.AccessibilityService
+import com.enaboapps.switchify.service.keyboard.KeyboardManager
+import com.enaboapps.switchify.service.keyboard.KeyboardNodesPolicy
 import com.enaboapps.switchify.service.techniques.nodes.NodeExaminer
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.filter
+import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.launch
 
 class StartupOrchestrator(
@@ -14,6 +19,8 @@ class StartupOrchestrator(
         private const val STARTUP_EXAM_DELAY_MS = 100L
     }
 
+    private val keyboardNodesPolicy = KeyboardNodesPolicy()
+
     suspend fun executeStartupTasks(processAccessibilityEvent: suspend () -> Unit) {
         // Initial accessibility tree examination
         processAccessibilityEvent()
@@ -27,9 +34,19 @@ class StartupOrchestrator(
                 }
             }
             serviceScope.launch {
-                NodeExaminer.keyboardNodesState.collect { state ->
-                    scanningManager.updateKeyboardNodes(state.nodes)
-                }
+                // Combine keyboard state with the node batches so the scanner
+                // only sees nodes whose captured bounds match the current IME.
+                // Drops the initial empty batch and any leftover from a
+                // previous keyboard layout (e.g. when swapping IMEs).
+                combine(
+                    KeyboardManager.keyboardState,
+                    NodeExaminer.keyboardNodesState
+                ) { state, nodes -> state to nodes }
+                    .filter { (state, nodes) ->
+                        !keyboardNodesPolicy.shouldDropAsStale(nodes, state)
+                    }
+                    .map { (_, nodes) -> nodes.nodes }
+                    .collect { scanningManager.updateKeyboardNodes(it) }
             }
         }
     }

app/src/main/java/com/enaboapps/switchify/service/keyboard/KeyboardNodesPolicy.kt

@@ -1,6 +1,7 @@
 package com.enaboapps.switchify.service.keyboard
 
 import com.enaboapps.switchify.service.techniques.AccessTechnique
+import com.enaboapps.switchify.service.techniques.nodes.KeyboardNodesState
 
 /**
  * Encapsulates routing and lifetime decisions for the keyboard node scanner.
@@ -36,4 +37,21 @@ class KeyboardNodesPolicy {
     fun shouldKeepKeyboardScannerAlive(state: KeyboardState): Boolean {
         return state.isVisible
     }
+
+    /**
+     * Whether a [KeyboardNodesState] batch should be dropped instead of
+     * forwarded to the keyboard scanner.
+     *
+     * Drops when:
+     * - The keyboard is hidden — nodes are not relevant.
+     * - The batch carries no bounds — it is the default uninitialized state
+     *   from before NodeExaminer has produced its first emission.
+     * - The captured bounds differ from the current IME bounds — the batch
+     *   was extracted from a previous keyboard layout.
+     */
+    fun shouldDropAsStale(nodes: KeyboardNodesState, state: KeyboardState): Boolean {
+        return !state.isVisible ||
+                nodes.keyboardBounds == null ||
+                nodes.isStaleAgainst(state.keyboardBounds)
+    }
 }

app/src/main/java/com/enaboapps/switchify/service/techniques/nodes/KeyboardNodesState.kt

@@ -16,4 +16,18 @@ import android.graphics.Rect
 data class KeyboardNodesState(
     val nodes: List<Node> = emptyList(),
     val keyboardBounds: Rect? = null
-)
+) {
+    /**
+     * True when this batch's captured bounds differ from [currentBounds],
+     * meaning the nodes belong to a previous keyboard layout.
+     *
+     * Returns false when either side is null — callers needing to reject
+     * uninitialized batches (no bounds captured yet) should check that
+     * separately or go through `KeyboardNodesPolicy.shouldDropAsStale`.
+     */
+    fun isStaleAgainst(currentBounds: Rect?): Boolean {
+        return keyboardBounds != null &&
+                currentBounds != null &&
+                keyboardBounds != currentBounds
+    }
+}

app/src/test/java/com/enaboapps/switchify/service/keyboard/KeyboardNodesPolicyTest.kt

@@ -1,6 +1,7 @@
 package com.enaboapps.switchify.service.keyboard
 
 import com.enaboapps.switchify.service.techniques.AccessTechnique
+import com.enaboapps.switchify.service.techniques.nodes.KeyboardNodesState
 import org.junit.Assert.assertFalse
 import org.junit.Assert.assertTrue
 import org.junit.Test
@@ -74,4 +75,29 @@ class KeyboardNodesPolicyTest {
             )
         )
     }
+
+    @Test
+    fun dropsBatchWhenKeyboardHidden() {
+        // Hidden keyboard with stale (or any) captured nodes — drop regardless.
+        val state = KeyboardState(isVisible = false)
+        val nodes = KeyboardNodesState() // uses default null bounds
+
+        assertTrue(policy.shouldDropAsStale(nodes, state))
+    }
+
+    @Test
+    fun dropsUninitializedBatchWithNoCapturedBounds() {
+        // Visible keyboard but NodeExaminer has not yet produced a batch —
+        // the default KeyboardNodesState (bounds == null) must not leak
+        // through as an empty node update.
+        val state = KeyboardState(isVisible = true)
+        val nodes = KeyboardNodesState() // default: no nodes, no bounds
+
+        assertTrue(policy.shouldDropAsStale(nodes, state))
+    }
+
+    // Note: the bounds-mismatch and bounds-match cases of shouldDropAsStale
+    // depend on android.graphics.Rect, which throws "Stub!" in pure-JVM unit
+    // tests. Those paths are exercised on device by swapping IMEs while
+    // item-scanning (see the PR test plan).
 }