Refactor input handling to use overlay priority pattern

Replace drawer routing with overlay handler that checks state internally.
The handler returns UNHANDLED when drawer is closed, allowing events to
fall through to the active screen handler. Eliminates routing desync bugs.

Author: tmgast

app/build.gradle.kts

@@ -22,8 +22,8 @@ android {
         applicationId = "com.nendo.argosy"
         minSdk = 26
         targetSdk = 34
-        versionCode = 19
-        versionName = "0.5.12"
+        versionCode = 20
+        versionName = "0.5.13"
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
         vectorDrawables {

app/src/main/kotlin/com/nendo/argosy/ui/ArgosyApp.kt

@@ -53,11 +53,11 @@ fun ArgosyApp(
     val drawerState = rememberDrawerState(initialValue = DrawerValue.Closed)
     val scope = rememberCoroutineScope()
 
-    val inputDispatcher = remember(drawerState) {
+    val inputDispatcher = remember {
         InputDispatcher(
             hapticManager = viewModel.hapticManager,
             soundManager = viewModel.soundManager
-        ).also { it.setDrawerOpenProvider { drawerState.isOpen } }
+        )
     }
 
     val startDestination = if (uiState.isFirstRun) {
@@ -89,11 +89,13 @@ fun ArgosyApp(
             }
     }
 
-    val drawerInputHandler = remember(currentRoute) {
+    val drawerInputHandler = remember {
         viewModel.createDrawerInputHandler(
+            isDrawerOpen = { drawerState.isOpen },
             onNavigate = { route ->
                 scope.launch { drawerState.close() }
-                if (route != currentRoute) {
+                val current = navController.currentDestination?.route
+                if (route != current) {
                     navController.navigate(route) {
                         popUpTo(Screen.Home.route) { saveState = true }
                         launchSingleTop = true
@@ -106,8 +108,8 @@ fun ArgosyApp(
     }
 
     DisposableEffect(drawerInputHandler) {
-        inputDispatcher.setDrawerHandler(drawerInputHandler)
-        onDispose { inputDispatcher.setDrawerHandler(null) }
+        inputDispatcher.setOverlayHandler(drawerInputHandler)
+        onDispose { inputDispatcher.setOverlayHandler(null) }
     }
 
     LaunchedEffect(Unit) {

app/src/main/kotlin/com/nendo/argosy/ui/ArgosyViewModel.kt

@@ -154,10 +154,12 @@ class ArgosyViewModel @Inject constructor(
     }
 
     fun createDrawerInputHandler(
+        isDrawerOpen: () -> Boolean,
         onNavigate: (String) -> Unit,
         onDismiss: () -> Unit
     ): InputHandler = object : InputHandler {
         override fun onUp(): InputResult {
+            if (!isDrawerOpen()) return InputResult.UNHANDLED
             if (_drawerFocusIndex.value > 0) {
                 _drawerFocusIndex.update { it - 1 }
                 return InputResult.HANDLED
@@ -166,6 +168,7 @@ class ArgosyViewModel @Inject constructor(
         }
 
         override fun onDown(): InputResult {
+            if (!isDrawerOpen()) return InputResult.UNHANDLED
             if (_drawerFocusIndex.value < drawerItems.lastIndex) {
                 _drawerFocusIndex.update { it + 1 }
                 return InputResult.HANDLED
@@ -177,16 +180,19 @@ class ArgosyViewModel @Inject constructor(
         override fun onRight(): InputResult = InputResult.UNHANDLED
 
         override fun onConfirm(): InputResult {
+            if (!isDrawerOpen()) return InputResult.UNHANDLED
             onNavigate(drawerItems[_drawerFocusIndex.value].route)
             return InputResult.HANDLED
         }
 
         override fun onBack(): InputResult {
+            if (!isDrawerOpen()) return InputResult.UNHANDLED
             onDismiss()
             return InputResult.HANDLED
         }
 
         override fun onMenu(): InputResult {
+            if (!isDrawerOpen()) return InputResult.UNHANDLED
             onDismiss()
             return InputResult.HANDLED
         }

app/src/main/kotlin/com/nendo/argosy/ui/input/InputDispatcher.kt

@@ -9,36 +9,25 @@ class InputDispatcher(
     private val soundManager: SoundFeedbackManager? = null
 ) {
     private var activeHandler: InputHandler? = null
-    private var drawerHandler: InputHandler? = null
-    private var drawerOpenProvider: (() -> Boolean)? = null
+    private var overlayHandler: InputHandler? = null
     private var pendingEvent: GamepadEvent? = null
     private var inputBlockedUntil: Long = 0L
 
-    private val isDrawerOpen: Boolean
-        get() = drawerOpenProvider?.invoke() ?: false
-
     fun setActiveScreen(handler: InputHandler?) {
         activeHandler = handler
-        if (handler != null && !isDrawerOpen) {
-            pendingEvent?.let { event ->
-                pendingEvent = null
-                dispatch(event)
-            }
-        }
+        handler?.let { processPendingEvent() }
     }
 
-    fun setDrawerHandler(handler: InputHandler?) {
-        drawerHandler = handler
-        if (handler != null && isDrawerOpen) {
-            pendingEvent?.let { event ->
-                pendingEvent = null
-                dispatch(event)
-            }
-        }
+    fun setOverlayHandler(handler: InputHandler?) {
+        overlayHandler = handler
+        handler?.let { processPendingEvent() }
     }
 
-    fun setDrawerOpenProvider(provider: () -> Boolean) {
-        drawerOpenProvider = provider
+    private fun processPendingEvent() {
+        pendingEvent?.let { event ->
+            pendingEvent = null
+            dispatch(event)
+        }
     }
 
     fun blockInputFor(durationMs: Long) {
@@ -50,20 +39,30 @@ class InputDispatcher(
             return true
         }
 
-        val handler = if (isDrawerOpen) drawerHandler else activeHandler
+        overlayHandler?.let { handler ->
+            val result = dispatchToHandler(event, handler)
+            if (result.handled) {
+                playFeedback(event, result)
+                return true
+            }
+        }
 
+        val handler = activeHandler
         if (handler == null) {
             pendingEvent = event
             return false
         }
 
         pendingEvent = null
         val result = dispatchToHandler(event, handler)
-        val handled = result.handled
+        playFeedback(event, result)
+        return result.handled
+    }
 
+    private fun playFeedback(event: GamepadEvent, result: InputResult) {
         when (event) {
             GamepadEvent.Up, GamepadEvent.Down, GamepadEvent.Left, GamepadEvent.Right -> {
-                if (handled) {
+                if (result.handled) {
                     hapticManager?.vibrate(HapticPattern.FOCUS_CHANGE)
                     soundManager?.play(result.soundOverride ?: SoundType.NAVIGATE)
                 } else {
@@ -72,7 +71,7 @@ class InputDispatcher(
                 }
             }
             GamepadEvent.PrevSection, GamepadEvent.NextSection -> {
-                if (handled) {
+                if (result.handled) {
                     hapticManager?.vibrate(HapticPattern.FOCUS_CHANGE)
                     soundManager?.play(result.soundOverride ?: SoundType.SECTION_CHANGE)
                 } else {
@@ -81,20 +80,18 @@ class InputDispatcher(
                 }
             }
             GamepadEvent.Confirm -> {
-                if (handled) {
+                if (result.handled) {
                     hapticManager?.vibrate(HapticPattern.SELECTION)
                     soundManager?.play(result.soundOverride ?: SoundType.SELECT)
                 }
             }
             GamepadEvent.Back -> {
-                if (handled) {
+                if (result.handled) {
                     soundManager?.play(result.soundOverride ?: SoundType.BACK)
                 }
             }
             else -> {}
         }
-
-        return handled
     }
 
     private fun dispatchToHandler(event: GamepadEvent, handler: InputHandler): InputResult {