diff --git a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt index 99408071f..7e6ad0376 100644 --- a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt +++ b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt @@ -244,9 +244,10 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde override fun key(code: Int, down: Boolean) { heldKeys.set(4, code, down) } override fun button(code: Int, down: Boolean) { heldButtons.set(4, code, down) } override fun pointer(dx: Float, dy: Float) { - if (Looper.myLooper() == Looper.getMainLooper()) moveInputPointer(dx, dy) - else uiHandler.post { - if (resumed && !SessionState.suspended && !pipUi && !drawerOpen && !inputSettingsOpen) + if (Looper.myLooper() == Looper.getMainLooper()) { + if (!menuOwnsController) moveInputPointer(dx, dy) + } else uiHandler.post { + if (resumed && !SessionState.suspended && !pipUi && !menuOwnsController && !inputSettingsOpen) moveInputPointer(dx, dy) } } @@ -545,6 +546,9 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde drawerOpenState = value if (!value && drawerDocked) closeDockedMenu() } + private val dockedMenuIdle: Boolean get() = com.droiddeck.launcher.input.DualScreen.menuIdleOnBottom(drawerOpen, drawerDocked, drawerPinned, dockedMenuController) + private val dockedTouchOnly: Boolean get() = drawerOpen && drawerDocked && !dockedMenuController + private val menuOwnsController: Boolean get() = com.droiddeck.launcher.input.DualScreen.menuOwnsController(drawerOpen, drawerDocked, dockedMenuController) private var quitFrom by mutableStateOf(null) private var quitFlooded = false private var leaving by mutableStateOf(false) @@ -588,6 +592,8 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde private var drawerPage by mutableStateOf(SessionDrawerPage.CONTROLLER) private var drawerControllerActive by mutableStateOf(false) private var backHold by mutableStateOf(true) + private var dockedMenuController by mutableStateOf(false) + private var sessionOrientation by mutableStateOf(android.content.pm.ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE) private var backActionsInverted by mutableStateOf(false) private var backDoubleTapMs by mutableStateOf(500) private var lowLatency by mutableStateOf(true) @@ -838,6 +844,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde SessionState.programArgs = intent.getStringArrayExtra(SessionService.EXTRA_PROGRAM_ARGS)?.toList().orEmpty() SessionEvents.begin(this, mode, SessionPaths.label(mode, intent.getStringExtra(SessionService.EXTRA_PROGRAM))) SessionState.secondScreenAutoOpened = false + SessionState.bottomMenu = false SessionState.secondScreenProvisional = false SessionState.secondScreenAutomatic = false SessionState.gameOnBottom = false @@ -1109,6 +1116,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde when { ::loading.isInitialized && loading.ended -> finish() inputSettingsOpen -> inputSettingsOpen = false + dockedTouchOnly -> routeBackAction() drawerOpen -> drawerOpen = false achievementsOpen -> closeAchievements() pcKeyboardOpen -> pcKeyboardOpen = false @@ -1137,6 +1145,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde } } val uiPointer = appUiOwnsPointer() + val cursorHidden = cursorHiddenByUi() androidx.compose.runtime.SideEffect { com.droiddeck.launcher.glasses.GlassesMenuMirror.setSessionMenuVisible(this@SessionActivity, (drawerOpen || achievementsOpen || pcKeyboardOpen) && !pipUi && steamVrStatus != SteamVr.Status.RUNNING) @@ -1187,7 +1196,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde } } else { com.droiddeck.launcher.ui.FocusGlideHost(androidx.compose.ui.Modifier.fillMaxSize()) { - CursorOverlay({ cursorPos }, cursorVisible && (!uiPointer || onlyPcKeyboardOpen()) && !bottomOutputActive, + CursorOverlay({ cursorPos }, cursorVisible && (!cursorHidden || onlyPcKeyboardOpen()) && !bottomOutputActive, resources.displayMetrics.density, cursorImage, cursorHotX, cursorHotY, cursorImageScale) if (memoryHud.text.isNotEmpty()) HudText(memoryHud.text, hudColor, hudOpacity) @@ -1304,9 +1313,9 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde runCatching { com.droiddeck.launcher.session.TelemetryOutput.applyAutomatic(this@SessionActivity, nextGame) } } } - LaunchedEffect(drawerOpen, pcKeyboardOpen, achievementsOpen, gestureSettingsOpen, inputSettingsOpen, pipUi, SessionState.suspended, resumed, appTextFocus) { + LaunchedEffect(drawerOpen, menuOwnsController, pcKeyboardOpen, achievementsOpen, gestureSettingsOpen, inputSettingsOpen, pipUi, SessionState.suspended, resumed, appTextFocus) { updateOnScreenControls() - padBridge?.setInputEnabled(resumed && !drawerOpen && !pcKeyboardOpen && !achievementsOpen && !gestureSettingsOpen && !inputSettingsOpen && !pipUi && !appTextFocus && !SessionState.suspended) + padBridge?.setInputEnabled(resumed && !menuOwnsController && !pcKeyboardOpen && !achievementsOpen && !gestureSettingsOpen && !inputSettingsOpen && !pipUi && !appTextFocus && !SessionState.suspended) if (drawerOpen || pcKeyboardOpen || achievementsOpen || gestureSettingsOpen || inputSettingsOpen || pipUi || appTextFocus || SessionState.suspended) { backQamInput.cancel() com.droiddeck.launcher.input.HomeButtonShortcuts.cancel(this@SessionActivity) @@ -1358,13 +1367,17 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde onDismiss = { gestureSettingsOpen = false }, onSaved = { gestureSettingsOpen = false; refreshGestureConfig() }, ) - androidx.compose.runtime.LaunchedEffect(drawerOpen) { + androidx.compose.runtime.LaunchedEffect(drawerOpen, menuOwnsController) { if (drawerOpen) { syncLossless() - releasePads() - androidx.compose.runtime.withFrameNanos { } - val requested = focusDrawer() - Log.i(TAG, "drawer root focus requested=$requested docked=$drawerDocked") + if (menuOwnsController) { + releasePads() + androidx.compose.runtime.withFrameNanos { } + val requested = focusDrawer() + Log.i(TAG, "drawer root focus requested=$requested docked=$drawerDocked") + } else { + releaseDrawerDirection() + } } else { releaseDrawerDirection() } @@ -1423,7 +1436,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde if (!SessionState.manualPause && !SessionState.suspended) pauseAnimated = false } SessionPausedOverlay( - suspended = SessionState.suspended && (!autoResume || SessionState.resumeFailed || SessionState.manualPause), + suspended = (SessionState.suspended || SessionState.manualPause) && (!autoResume || SessionState.resumeFailed || SessionState.manualPause), engaged = SessionState.resumeRequested || SessionState.resuming, failures = SessionState.resumeFailures, frame = pausedFrame, @@ -1761,6 +1774,12 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde SessionPrefs.setBackHold(this@SessionActivity, on) backHold = on }, + dockedMenuController = dockedMenuController, + onDockedMenuController = { on -> + SessionPrefs.setDockedMenuController(this@SessionActivity, on) + dockedMenuController = on + if (!on && drawerDocked) drawerControllerActive = false + }, backActionsInverted = backActionsInverted, backDoubleTapMs = backDoubleTapMs, onBackDoubleTapMs = { ms -> @@ -1829,6 +1848,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde setRelativeMouse(mode) }, onFexPreset = { v -> SessionPrefs.setFexPreset(this@SessionActivity, v); readPrefs() }, + onSelectMenuMode = ::pickMenuMode, onSecondScreenMode = { mode -> if (docked) drawerOpen = false pickSecondScreenMode(mode) @@ -1852,6 +1872,14 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde pipAutoEnter = pipAutoEnter, onPip = { pip.enter() }, onPause = ::pauseNow, + paused = SessionState.suspended || SessionState.manualPause, + onResume = { SessionService.resume(this@SessionActivity) }, + orientation = sessionOrientation, + onOrientation = { value -> + SessionPrefs.setOrientation(this@SessionActivity, value) + sessionOrientation = value + applyFollowOrientation(resources.configuration) + }, onPipAutoEnter = { on -> SessionPrefs.setPipAutoEnter(this@SessionActivity, on) pipAutoEnter = on @@ -1949,7 +1977,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde } private fun sendSteamGuide() { - drawerOpen = false + if (!dockedTouchOnly) drawerOpen = false padBridge?.triggerSteamMenu() } @@ -1996,7 +2024,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde } private fun triggerSteamQam() { - drawerOpen = false + if (!dockedTouchOnly) drawerOpen = false padBridge?.triggerQam() } @@ -2085,7 +2113,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde private fun performBackAction(double: Boolean) { val isSteam = SessionState.mode == SessionService.MODE_STEAM val opensQam = isSteam && (double xor backActionsInverted) - if (opensQam) triggerSteamQam() else drawerOpen = !drawerOpen + if (opensQam) triggerSteamQam() else if (!dockedTouchOnly) drawerOpen = !drawerOpen } private fun handleHomeGuideIntent(incoming: Intent?) { @@ -2629,6 +2657,8 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde oscRearButtons = SessionPrefs.oscRearButtons(this) oscTrackpads = SessionPrefs.oscTrackpads(this) backHold = SessionPrefs.backHold(this) + dockedMenuController = SessionPrefs.dockedMenuController(this) + sessionOrientation = SessionPrefs.orientation(this) backActionsInverted = SessionPrefs.backActionsInverted(this) physicalShortcuts.bindings = PhysicalShortcuts.read(this) backDoubleTapMs = SessionPrefs.backDoubleTapMs(this) @@ -3523,7 +3553,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde val steamVolume = SessionState.mode == SessionService.MODE_STEAM && SessionState.running && SessionState.firstFrameSeen && !SessionState.suspended && !ended && - !pipUi && !drawerOpen && !pcKeyboardOpen && !achievementsOpen && + !pipUi && !menuOwnsController && !pcKeyboardOpen && !achievementsOpen && !gestureSettingsOpen && !inputSettingsOpen && !appTextFocus && window.decorView.hasWindowFocus() if (steamVolume) { val audio = getSystemService(android.media.AudioManager::class.java) @@ -3537,13 +3567,13 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde if (penStream.holdsKey(event) || (penSettings.mode != SessionPrefs.PEN_TOUCH && PenStream.isPenKey(event))) return penStream.onKey(event) if (appTextFocus) return super.dispatchKeyEvent(event) if (!pipUi) { - if (physicalInputBindings?.onKey(event, resumed && !drawerOpen && !pcKeyboardOpen && !achievementsOpen && + if (physicalInputBindings?.onKey(event, resumed && !menuOwnsController && !pcKeyboardOpen && !achievementsOpen && !inputSettingsOpen && !gestureSettingsOpen && !SessionState.suspended && !loading.visible) == true) return true if (physicalShortcuts.onKey( event, enabled = resumed && SessionState.running && !SessionState.suspended && - !(drawerOpen && event.keyCode == KeyEvent.KEYCODE_BUTTON_A) && - !(drawerOpen && PhysicalShortcuts.isDrawerNavigationKey(event)) && + !(menuOwnsController && event.keyCode == KeyEvent.KEYCODE_BUTTON_A) && + !(menuOwnsController && PhysicalShortcuts.isDrawerNavigationKey(event)) && (event.deviceId to event.keyCode) !in resumeKeysDown && !(::loading.isInitialized && (loading.visible || loading.ended)) && !pcKeyboardOpen && !achievementsOpen && !gestureSettingsOpen && !inputSettingsOpen, @@ -3551,12 +3581,12 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde ) { action -> pendingBackAction?.let(uiHandler::removeCallbacks) pendingBackAction = null - drawerControllerActive = true + if (!dockedMenuIdle) drawerControllerActive = true Log.i(TAG, "physical shortcut ${action.name} device=${event.deviceId} key=${event.keyCode} scan=${event.scanCode}") when (action) { PhysicalShortcuts.Action.STEAM -> sendSteamGuide() PhysicalShortcuts.Action.QAM -> triggerSteamQam() - PhysicalShortcuts.Action.DROIDDECK -> drawerOpen = !drawerOpen + PhysicalShortcuts.Action.DROIDDECK -> if (!dockedTouchOnly) drawerOpen = !drawerOpen } }) return true } @@ -3582,7 +3612,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde } } if (mouseBackHandled) return true - val backToQam = !pipUi && !appTextFocus && !drawerOpen && !pcKeyboardOpen && !achievementsOpen && + val backToQam = !pipUi && !appTextFocus && !menuOwnsController && !pcKeyboardOpen && !achievementsOpen && !inputSettingsOpen && !gestureSettingsOpen && SessionState.mode == SessionService.MODE_STEAM && SessionState.running && SessionState.firstFrameSeen && !SessionState.suspended && padBridge?.canHoldQam() == true @@ -3595,12 +3625,12 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde val pad = com.droiddeck.launcher.input.JoyCon.normalize(event) if (pad !== event) return dispatchKeyEvent(pad) val fromController = PadBridge.isControllerKeyEvent(event) - if (fromController && (drawerOpen || pcKeyboardOpen || achievementsOpen || inputSettingsOpen || gestureSettingsOpen || SessionState.suspended)) { + if (fromController && (menuOwnsController || pcKeyboardOpen || achievementsOpen || inputSettingsOpen || gestureSettingsOpen || SessionState.suspended)) { padBridge?.setInputEnabled(false) padBridge?.onKeyEvent(event) } - if (fromController && event.action == KeyEvent.ACTION_DOWN) { - if (drawerOpen && !drawerControllerActive) focusDrawer() + if (fromController && event.action == KeyEvent.ACTION_DOWN && !dockedMenuIdle) { + if (menuOwnsController && !drawerControllerActive) focusDrawer() drawerControllerActive = true } if (fromController && event.keyCode == KeyEvent.KEYCODE_BUTTON_B && ::loading.isInitialized && loading.visible && !loading.ended && !drawerOpen) { @@ -3619,7 +3649,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde } val drawerShortcutKey = event.deviceId to event.keyCode if (fromController && (event.keyCode == KeyEvent.KEYCODE_BUTTON_SELECT || event.keyCode == KeyEvent.KEYCODE_BUTTON_START) && - ((drawerOpen && SessionState.mode == SessionService.MODE_STEAM) || drawerShortcutKey in drawerShortcutKeysDown)) { + ((menuOwnsController && SessionState.mode == SessionService.MODE_STEAM) || drawerShortcutKey in drawerShortcutKeysDown)) { if (event.action == KeyEvent.ACTION_DOWN) { drawerShortcutKeysDown.add(drawerShortcutKey) if (event.repeatCount == 0) { @@ -3631,7 +3661,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde } return true } - if (drawerOpen) { + if (drawerOpen && (menuOwnsController || (!fromController && !(dockedTouchOnly && event.keyCode == KeyEvent.KEYCODE_BACK)))) { if (fromController && (event.keyCode == KeyEvent.KEYCODE_BUTTON_L1 || event.keyCode == KeyEvent.KEYCODE_BUTTON_R1)) { if (event.action == KeyEvent.ACTION_DOWN && event.repeatCount == 0) { drawerPage = sessionDrawerPages(glasses.present) @@ -3701,11 +3731,11 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde override fun dispatchGenericMotionEvent(event: MotionEvent): Boolean { if (pipUi) return true notePress(event) - if (PadBridge.isControllerMotionEvent(event) && (drawerOpen || pcKeyboardOpen || achievementsOpen || inputSettingsOpen || gestureSettingsOpen || SessionState.suspended)) { + if (PadBridge.isControllerMotionEvent(event) && (menuOwnsController || pcKeyboardOpen || achievementsOpen || inputSettingsOpen || gestureSettingsOpen || SessionState.suspended)) { padBridge?.setInputEnabled(false) padBridge?.onMotionEvent(event) } - if (drawerOpen && PadBridge.isControllerMotionEvent(event)) { + if (menuOwnsController && PadBridge.isControllerMotionEvent(event)) { if (!drawerControllerActive) focusDrawer() drawerControllerActive = true if (event.actionMasked == MotionEvent.ACTION_MOVE && @@ -3882,6 +3912,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde } private fun closeDockedMenu() { + SessionState.bottomMenu = false drawerDocked = false val presentation = secondScreenPresentation ?: return presentation.showMenu(false) @@ -4307,7 +4338,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde ?: if (SessionState.gameOnBottom) bottomGameDisplay()?.displayId else null SessionState.secondScreenAutoOpened = true if (gameDisplay != null && gameDisplay != target.displayId && secondScreenDisplays.any { it.id == gameDisplay }) { - panelMode(openingPanel()) + panelMode(openingSurface()) } else { val selectionChanged = selectedSecondScreenDisplay != target.displayId selectedSecondScreenDisplay = target.displayId @@ -4326,14 +4357,43 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde } private fun openingPanel() = SecondScreenMode.opening(SessionPrefs.secondScreenPanel(this, desktopSession), SessionState.deckPad, - bottomPages().isNotEmpty(), com.droiddeck.launcher.session.BottomDesktop.available(), desktopSession) + bottomPages().isNotEmpty(), com.droiddeck.launcher.session.BottomDesktop.available()) + + private fun openingSurface() = openingPanel().takeIf { it != SecondScreenMode.MENU } ?: SecondScreenMode.KEYBOARD_TRACKPAD + + private fun menuShownOnBottom() = drawerDocked && (drawerOpen || drawerPinned) + + private fun pinDockedMenu() { + if (!dockDrawer()) return + drawerLayerOpen = false + if (!openDockedMenu()) return + drawerDocked = true + drawerOpenState = false + drawerPinned = true + updateKeyboardRoute() + } + + private fun showMenuMode() { + dualControlsProvisional = false + selectSecondScreenMode(secondScreenMode.takeIf { it != SecondScreenMode.NONE } ?: SecondScreenMode.KEYBOARD_TRACKPAD) + if (secondScreenMode != SecondScreenMode.NONE) pinDockedMenu() + } + + private fun pickMenuMode() { + typingReturnMode = null + automaticPanel = false + SessionPrefs.setSecondScreenPanel(this, desktopSession, SecondScreenMode.MENU.id) + drawerOpen = true + } private fun settleDualScreenControls() { if (!dualControlsProvisional || pipUi || !started || (::loading.isInitialized && loading.visible)) return dualControlsProvisional = false if (secondScreenMode == SecondScreenMode.NONE) return val wanted = openingPanel() - if (wanted != secondScreenMode) selectSecondScreenMode(wanted) else secondScreenPresentation?.retryTerminal() + if (wanted == SecondScreenMode.MENU) { + if (!menuShownOnBottom()) selectSecondScreenMode(wanted) else secondScreenPresentation?.retryTerminal() + } else if (wanted != secondScreenMode) selectSecondScreenMode(wanted) else secondScreenPresentation?.retryTerminal() } private fun selectSecondScreenDisplay(displayId: Int) { @@ -4354,6 +4414,10 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde closeSecondScreen(reset = true) return } + if (mode == SecondScreenMode.MENU) { + showMenuMode() + return + } if (secondScreenDisplays.isEmpty()) { panelMode(SecondScreenMode.NONE) return @@ -4370,7 +4434,12 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde private fun showSecondScreen(requested: SecondScreenMode) { if (pipUi || !started) return - val mode = if (requested == SecondScreenMode.DECK_CONTROLS && !SessionState.deckPad) openingPanel() else requested + val mode = when { + requested == SecondScreenMode.MENU -> + secondScreenMode.takeIf { it != SecondScreenMode.NONE && it != SecondScreenMode.MENU } ?: SecondScreenMode.KEYBOARD_TRACKPAD + requested == SecondScreenMode.DECK_CONTROLS && !SessionState.deckPad -> openingSurface() + else -> requested + } val target = displayManager.getDisplay(selectedSecondScreenDisplay) if (target == null || !target.isValid || (target.flags and Display.FLAG_PRESENTATION) == 0) { closeSecondScreen(reset = false) @@ -4414,7 +4483,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde private fun bottomScreenPicker(mode: SecondScreenMode) = com.droiddeck.launcher.ui.ScreenPicker( com.droiddeck.launcher.ui.secondScreenModes(false, SessionState.deckPad, bottomPages().isNotEmpty(), com.droiddeck.launcher.session.BottomDesktop.available()), - mode, ::pickSecondScreenMode, onMenu = { drawerOpen = true }, + mode, ::pickSecondScreenMode, onMenu = ::pickMenuMode, ) private fun secondScreenPresentation(target: Display) = SecondScreenPresentation( @@ -4840,6 +4909,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde } private fun dropDockedDrawer() { + if (drawerDocked && (drawerOpenState || drawerPinned)) SessionState.bottomMenu = true drawerPinned = false if (!drawerDocked) return drawerDocked = false @@ -4858,6 +4928,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde if (reset) { panelMode(SecondScreenMode.NONE) automaticPanel = false + SessionState.bottomMenu = false } } @@ -5410,8 +5481,13 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde private fun onlyPcKeyboardOpen(): Boolean = pcKeyboardOpen && !drawerOpen && !achievementsOpen && !inputSettingsOpen && !pipUi && !glassesOutputActive && !touchEditorOpen && !wowChatOnTop - private fun appUiOwnsPointer(): Boolean = - drawerOpen || pcKeyboardOpen || achievementsOpen || inputSettingsOpen || pipUi || glassesOutputActive || bottomOutputActive || touchEditorOpen || wowChatOnTop + private fun otherUiOwnsPointer(): Boolean = + pcKeyboardOpen || achievementsOpen || inputSettingsOpen || pipUi || glassesOutputActive || bottomOutputActive || touchEditorOpen || wowChatOnTop + + private fun appUiOwnsPointer(): Boolean = drawerOpen || otherUiOwnsPointer() + + /** A touch-only docked menu leaves the game cursor alone, so controller pointer moves stay visible. */ + private fun cursorHiddenByUi(): Boolean = menuOwnsController || otherUiOwnsPointer() private fun applyPlatformPointer(shown: Boolean) { if (!::sessionRoot.isInitialized || !::surfaceView.isInitialized) return @@ -5689,31 +5765,44 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde heldKeys.set(owner, code, down) } - private fun capturePausedFrame(manual: Boolean = false) { - if (!SessionState.running || pipUi || isInPictureInPictureMode || glassesOutputActive || bottomOutputActive) return + private fun capturePausedFrame(manual: Boolean = false, onDone: () -> Unit = {}) { + fun skipped(reason: String) { + if (manual) SessionEvents.record("pause.frame_skipped", mapOf("reason" to reason)) + onDone() + } + if (!SessionState.running || pipUi || isInPictureInPictureMode || glassesOutputActive || bottomOutputActive) { + return skipped("state running=${SessionState.running} pip=$pipUi glasses=$glassesOutputActive bottom=$bottomOutputActive") + } if (SessionState.suspended && pausedFrame != null) return - if ((suspendPolicy == SessionPrefs.SUSPEND_NEVER && !manual && !SessionState.manualPause) || !::surfaceView.isInitialized) return - if (surfaceView.holder.surface?.isValid != true) return + if ((suspendPolicy == SessionPrefs.SUSPEND_NEVER && !manual && !SessionState.manualPause) || !::surfaceView.isInitialized) return skipped("policy") + if (surfaceView.holder.surface?.isValid != true) return skipped("surface invalid") val width = surfaceView.width val height = surfaceView.height - if (width <= 0 || height <= 0) return + if (width <= 0 || height <= 0) return skipped("size ${width}x$height") val scale = minOf(1f, PAUSED_FRAME_MAX_EDGE / maxOf(width, height).toFloat()) val bitmap = try { android.graphics.Bitmap.createBitmap( maxOf(1, (width * scale).toInt()), maxOf(1, (height * scale).toInt()), android.graphics.Bitmap.Config.ARGB_8888, ) } catch (_: OutOfMemoryError) { - return + return skipped("oom") } val surfaceAt = IntArray(2).also { surfaceView.getLocationInWindow(it) } val overlayAt = IntArray(2).also { sessionOverlay.getLocationInWindow(it) } val left = surfaceAt[0] - overlayAt[0] val top = surfaceAt[1] - overlayAt[1] val bounds = android.graphics.Rect(left, top, left + width, top + height) + val requestedAt = SystemClock.elapsedRealtime() withPictureFrame { done -> try { android.view.PixelCopy.request(surfaceView, bitmap, { result -> done() + onDone() + if (manual) SessionEvents.record("pause.frame_copy", mapOf( + "result" to result, "ms" to SystemClock.elapsedRealtime() - requestedAt, + "zeroCopy" to SessionPrefs.zeroCopy(this, SessionState.mode), "size" to "${width}x$height", + "lit" to (result == android.view.PixelCopy.SUCCESS && bitmapHasPicture(bitmap)), + )) if (result == android.view.PixelCopy.SUCCESS && !isDestroyed) { pausedFrame = com.droiddeck.launcher.ui.PausedFrame(bitmap.asImageBitmap(), bounds) pausedFrameWanted = false @@ -5724,6 +5813,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde } catch (_: IllegalArgumentException) { done() bitmap.recycle() + skipped("copy rejected") } } } @@ -5731,12 +5821,35 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde private fun pauseNow() { if (!SessionState.running || SessionState.suspended) return pauseAnimated = true - drawerOpen = false + if (!dockedTouchOnly) drawerOpen = false pausedFrame = null - capturePausedFrame(manual = true) + if (zeroCopyActive()) { + WaylandCompositor.nativeSetZeroCopy(false) + val restore = java.util.concurrent.atomic.AtomicBoolean(false) + val back = { if (restore.compareAndSet(false, true)) WaylandCompositor.nativeSetZeroCopy(true) } + uiHandler.postDelayed({ capturePausedFrame(manual = true, onDone = back) }, ZERO_COPY_SETTLE_MS) + uiHandler.postDelayed({ back() }, ZERO_COPY_RESTORE_MS) + } else { + capturePausedFrame(manual = true) + } SessionService.pause(this) } + private fun zeroCopyActive(): Boolean = + CompositorHost.isStarted && !SessionState.hdr && SessionPrefs.zeroCopy(this, SessionState.mode) + + private fun bitmapHasPicture(bitmap: android.graphics.Bitmap): Boolean { + val w = bitmap.width + val h = bitmap.height + if (w <= 0 || h <= 0) return false + var lit = 0 + for (i in 0 until 64) { + val c = bitmap.getPixel((w * (i % 8 + 1)) / 9, (h * (i / 8 + 1)) / 9) + if (android.graphics.Color.red(c) + android.graphics.Color.green(c) + android.graphics.Color.blue(c) > 24) lit++ + } + return lit >= 3 + } + private fun requestPausedFrame() { if (pausedFrame != null) return pausedFrameWanted = true @@ -5840,8 +5953,11 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde reconcileDock(shownOnDisplayId) settleDualScreenControls() refreshSecondScreenDisplays() - if (secondScreenMode != SecondScreenMode.NONE && secondScreenPresentation == null) showSecondScreen(secondScreenMode) - else openDualScreenControls() + if (secondScreenMode != SecondScreenMode.NONE) { + if (secondScreenPresentation == null) showSecondScreen(secondScreenMode) + if (com.droiddeck.launcher.input.DualScreen.menuReturnsOnStart(openingPanel(), SessionState.bottomMenu, menuShownOnBottom())) pinDockedMenu() + SessionState.bottomMenu = false + } else openDualScreenControls() startedScreens++ SessionService.setActivityVisible(this, true, sessionActivityDisplayId) Glasses.rescan() @@ -5992,7 +6108,9 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde heldKeys.clear() heldButtons.clear() if (!screenOff) { + val menuUp = menuShownOnBottom() drawerOpen = false + if (menuUp) SessionState.bottomMenu = true pcKeyboardOpen = false achievementsOpen = false } @@ -6764,6 +6882,8 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde private const val LEAVE_TIMEOUT_MS = 1_500L private const val TEXT_FIELD_TAP_MS = 1_000L private const val PAUSED_FRAME_MAX_EDGE = 1920f + private const val ZERO_COPY_SETTLE_MS = 150L + private const val ZERO_COPY_RESTORE_MS = 1200L private const val BFI_PICTURE_SETTLE_MS = 50L private const val PAUSED_FRAME_REDRAW_MS = 150L private const val BOTTOM_RECOVERY_MS = 1_000L diff --git a/app/src/main/java/com/droiddeck/launcher/input/DualScreen.kt b/app/src/main/java/com/droiddeck/launcher/input/DualScreen.kt index 1d8bf5d68..a4de922ca 100644 --- a/app/src/main/java/com/droiddeck/launcher/input/DualScreen.kt +++ b/app/src/main/java/com/droiddeck/launcher/input/DualScreen.kt @@ -23,6 +23,14 @@ object DualScreen { @Volatile private var takenDisplays: Set = emptySet() private val main by lazy { android.os.Handler(android.os.Looper.getMainLooper()) } + fun menuOwnsController(open: Boolean, docked: Boolean, optIn: Boolean): Boolean = open && (!docked || optIn) + + fun menuReturnsOnStart(selected: SecondScreenMode, menuWasShown: Boolean, menuUp: Boolean): Boolean = + !menuUp && (selected == SecondScreenMode.MENU || menuWasShown) + + fun menuIdleOnBottom(open: Boolean, docked: Boolean, pinned: Boolean, optIn: Boolean): Boolean = + docked && (open || pinned) && !menuOwnsController(open, docked, optIn) + fun yieldsBottom(model: String): Boolean = model.trim().lowercase().let { m -> knownModels.any(m::startsWith) } fun taken(displayId: Int): Boolean = displayId in takenDisplays diff --git a/app/src/main/java/com/droiddeck/launcher/input/SecondScreenMode.kt b/app/src/main/java/com/droiddeck/launcher/input/SecondScreenMode.kt index 590ef4fc0..476ac443a 100644 --- a/app/src/main/java/com/droiddeck/launcher/input/SecondScreenMode.kt +++ b/app/src/main/java/com/droiddeck/launcher/input/SecondScreenMode.kt @@ -9,6 +9,7 @@ import com.droiddeck.launcher.session.SessionPrefs enum class SecondScreenMode(val id: String, @StringRes val label: Int, val bindings: String? = null) { NONE("none", R.string.second_mode_none), + MENU("menu", R.string.touch_droiddeck_menu), KEYBOARD_TRACKPAD("keyboard-trackpad", R.string.second_mode_keyboard_trackpad, InputStockLayouts.TRACKPAD), TERMINAL("terminal", R.string.second_mode_terminal), DECK_CONTROLS("deck-controls", R.string.second_mode_deck_controls, InputStockLayouts.DECK), @@ -21,19 +22,12 @@ enum class SecondScreenMode(val id: String, @StringRes val label: Int, val bindi fun panel(context: Context): String? = if (this == DECK_CONTROLS) SessionPrefs.deckPanel(context).bindings else bindings companion object { - fun opening(remembered: String?, deckPad: Boolean, dashboard: Boolean = false, bottomDesktop: Boolean = false, desktopSession: Boolean = false): SecondScreenMode { + /** The mode the bottom screen opens in: the one picked last if it is still available, else the DroidDeck menu. */ + fun opening(remembered: String?, deckPad: Boolean, dashboard: Boolean = false, bottomDesktop: Boolean = false): SecondScreenMode = entries.firstOrNull { it != NONE && it.id == remembered && (it != DECK_CONTROLS || deckPad) && (it != DASHBOARD || dashboard) && (it != DESKTOP || bottomDesktop) - }?.let { return it } - val picked = entries.any { it != NONE && it.id == remembered } - return when { - desktopSession -> KEYBOARD_TRACKPAD - deckPad -> DECK_CONTROLS - dashboard && !picked -> DASHBOARD - else -> KEYBOARD_TRACKPAD - } - } + } ?: MENU } } diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt index 33ce04959..0ff3d76e3 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt @@ -614,6 +614,12 @@ object SessionPrefs { prefs(context).edit().putBoolean("backHold", on).apply() } + fun dockedMenuController(context: Context): Boolean = prefs(context).getBoolean("dockedMenuController", false) + + fun setDockedMenuController(context: Context, on: Boolean) { + prefs(context).edit().putBoolean("dockedMenuController", on).apply() + } + fun backActionsInverted(context: Context): Boolean = prefs(context).getBoolean("backActionsInverted", false) fun setBackActionsInverted(context: Context, inverted: Boolean) { diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionState.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionState.kt index 847ed340b..e695f8b93 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionState.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionState.kt @@ -133,6 +133,7 @@ object SessionState { @Volatile var padBridge: com.droiddeck.launcher.input.PadBridge? = null @Volatile var secondScreenMode = com.droiddeck.launcher.input.SecondScreenMode.NONE + @Volatile var bottomMenu = false @Volatile var secondScreenDisplay = -1 @Volatile var secondScreenAutoOpened = false @Volatile var secondScreenProvisional = false diff --git a/app/src/main/java/com/droiddeck/launcher/session/SettingsReset.kt b/app/src/main/java/com/droiddeck/launcher/session/SettingsReset.kt index 2bb6190ce..5a61619d1 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SettingsReset.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SettingsReset.kt @@ -16,7 +16,7 @@ object SettingsReset { "dualScreenMode", "dualScreenSessionMode", "dualScreenLauncher", "dualScreenSessionControls", "androidTextFieldKeyboard", "soundtracksIngame", "gameStoresSpeedTier", "gameStoresParallel", "storesOpenTab", "storesShowMature", "storesInstallLanguage", - "hud", "hudDeck", "hudFps", "hudBattery", "hudGraph", "hudColor", "hudOpacity", "__KEEP_droidDeckHud__", "__KEEP_droidDeckHudPos__", "backHold", "backActionsInverted", "backDoubleTapMs", "touch", "pen", "penButton", "osc", "shape", "steamController", + "hud", "hudDeck", "hudFps", "hudBattery", "hudGraph", "hudColor", "hudOpacity", "__KEEP_droidDeckHud__", "__KEEP_droidDeckHudPos__", "backHold", "dockedMenuController", "backActionsInverted", "backDoubleTapMs", "touch", "pen", "penButton", "osc", "shape", "steamController", "gamepadLeft", "gamepadRight", "pipAutoEnter", "unfoldedControls", "unfoldedControlsWithController", "stretch16x9", "avoidNotch", "picturePosition", "integerScaling", "railLabels", "developerTools", "navTabOrder", "navTabShelved", "navTabHidden", "drawerPageOrder", "drawerPageHidden", "pcKeyboardSize", "pcKeyboardOpacity", "pcKeyboardHiddenKeys", "gpuDriverMode", "androidDriver", "linuxDriver", "linuxDriver.steam", "linuxDriver.desktop", diff --git a/app/src/main/java/com/droiddeck/launcher/ui/BottomScreenBar.kt b/app/src/main/java/com/droiddeck/launcher/ui/BottomScreenBar.kt index 0fbbcf3f3..b6509b332 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/BottomScreenBar.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/BottomScreenBar.kt @@ -230,6 +230,7 @@ internal fun BarButton( internal val SecondScreenMode.icon: ImageVector get() = when (this) { SecondScreenMode.NONE -> Icons.Outlined.DesktopAccessDisabled + SecondScreenMode.MENU -> Icons.Outlined.MoreHoriz SecondScreenMode.KEYBOARD_TRACKPAD -> Icons.Outlined.Keyboard SecondScreenMode.TERMINAL -> Icons.Outlined.Terminal SecondScreenMode.DECK_CONTROLS -> Icons.Outlined.SportsEsports @@ -290,17 +291,11 @@ private fun ScreenPickerMenu(picker: ScreenPicker, open: Boolean, dismiss: () -> leading = { Icon(painterResource(R.drawable.ic_stat_session), contentDescription = null, tint = colors.onBackground, modifier = Modifier.size(18.dp)) }, focusRequester = first.takeIf { target == null }, modifier = Modifier.testTag("screen-picker-menu"), ) { dismiss(); menu() } - Box(Modifier.fillMaxWidth().padding(vertical = 4.dp).height(1.dp).background(pal.line)) - Text( - stringResource(R.string.drawer_second_screen).uppercase(), fontSize = 12.sp, fontWeight = FontWeight.SemiBold, letterSpacing = 1.5.sp, - color = colors.onSurfaceVariant, modifier = Modifier.padding(start = 10.dp, top = 6.dp, bottom = 4.dp), - ) } picker.modes.forEach { mode -> val current = mode == picker.current MenuItem( stringResource(mode.label), checked = current && !picker.menuShown, - detail = if (current && picker.menuShown) stringResource(R.string.screen_picker_last_used) else null, leading = { Icon(mode.icon, contentDescription = null, tint = colors.onBackground, modifier = Modifier.size(18.dp)) }, focusRequester = first.takeIf { mode == target }, modifier = Modifier.testTag("screen-picker:${mode.id}"), ) { dismiss(); picker.onPick(mode) } diff --git a/app/src/main/java/com/droiddeck/launcher/ui/SecondScreenPresentation.kt b/app/src/main/java/com/droiddeck/launcher/ui/SecondScreenPresentation.kt index 6944d5a30..ff0400860 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/SecondScreenPresentation.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/SecondScreenPresentation.kt @@ -305,7 +305,7 @@ class SecondScreenPresentation( (onSteamMenu to onQam).takeIf { SessionState.mode == SessionService.MODE_STEAM }, onSwap, picker = picker?.let { pick -> { pick(SecondScreenMode.DESKTOP) } }), weightParams()) } - SecondScreenMode.NONE -> Unit + SecondScreenMode.NONE, SecondScreenMode.MENU -> Unit } } diff --git a/app/src/main/java/com/droiddeck/launcher/ui/SessionOverlay.kt b/app/src/main/java/com/droiddeck/launcher/ui/SessionOverlay.kt index 474e613c6..ffca74a17 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/SessionOverlay.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/SessionOverlay.kt @@ -44,6 +44,7 @@ import androidx.compose.runtime.CompositionLocalProvider import androidx.compose.material.icons.outlined.DesktopWindows import androidx.compose.material.icons.outlined.Layers import androidx.compose.material.icons.outlined.Pause +import androidx.compose.material.icons.outlined.PlayArrow import androidx.compose.material.icons.outlined.PictureInPictureAlt import androidx.compose.material.icons.automirrored.outlined.ExitToApp import androidx.compose.material.icons.outlined.Settings @@ -230,6 +231,8 @@ class DrawerActions( val onMicEnabled: (Boolean) -> Unit = {}, val backHold: Boolean = true, val onBackHold: (Boolean) -> Unit = {}, + val dockedMenuController: Boolean = false, + val onDockedMenuController: (Boolean) -> Unit = {}, val backActionsInverted: Boolean, val backDoubleTapMs: Int = 500, val onBackDoubleTapMs: (Int) -> Unit = {}, @@ -332,6 +335,7 @@ class DrawerActions( val onSteamVr: (String) -> Unit = {}, val onTextureAnisotropy: (Int?) -> Unit = {}, val onTextureLodBias: (String?) -> Unit = {}, + val onSelectMenuMode: () -> Unit = {}, val onSecondScreenMode: (SecondScreenMode) -> Unit, val onSecondScreenDisplay: (Int) -> Unit, val onLaunchAndroidApp: (HomeApp.LaunchableApp, Int?) -> Unit, @@ -340,6 +344,10 @@ class DrawerActions( val pipAutoEnter: Boolean = false, val onPip: () -> Unit = {}, val onPause: () -> Unit = {}, + val paused: Boolean = false, + val orientation: Int = android.content.pm.ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE, + val onOrientation: (Int) -> Unit = {}, + val onResume: () -> Unit = {}, val onPipAutoEnter: (Boolean) -> Unit = {}, val unfoldedControls: Boolean? = null, val adaptiveSticks: Boolean? = null, @@ -541,14 +549,15 @@ internal fun SessionDrawer(open: Boolean, requestedPage: SessionDrawerPage, cont ScreenPicker( secondScreenModes(a.secondScreenNone, com.droiddeck.launcher.session.SessionState.deckPad, a.dashboardAvailable, a.desktopAvailable), a.secondScreenMode, onPick = { host.open = null; a.onSecondScreenMode(it) }, - onMenu = if (docked) ({ host.open = null }) else null, menuShown = docked, + onMenu = if (docked) ({ host.open = null; a.onSelectMenuMode() }) else null, menuShown = docked, ), focus.track(page, "screen").testTag("drawer-screen-picker"), ) } else if (roomyHeader) Spacer(Modifier.weight(1f)) SteamActionPill( - stringResource(R.string.stores_dl_pause), Icons.Outlined.Pause, focus.track(page, "pause"), - ) { host.open = null; a.onPause() } + stringResource(if (a.paused) R.string.resume_session else R.string.stores_dl_pause), + if (a.paused) Icons.Outlined.PlayArrow else Icons.Outlined.Pause, focus.track(page, "pause"), + ) { host.open = null; if (a.paused) a.onResume() else a.onPause() } if (a.pipSupported) SteamActionPill( stringResource(R.string.pip_title), Icons.Outlined.PictureInPictureAlt, focus.track(page, "pip"), ) { host.open = null; a.onPip() } @@ -664,6 +673,11 @@ internal fun SessionDrawer(open: Boolean, requestedPage: SessionDrawerPage, cont } } } + SettingsGroup(stringResource(R.string.setup_orientation)) { + ChoiceRow(host, "orientation", stringResource(R.string.setup_session_orientation), null, + SessionPrefs.orientationOptions.map { (value, label) -> value to stringResource(label) }, + a.orientation, chipModifier = focus.track(page, "orientation"), onPick = a.onOrientation) + } SettingsGroup(stringResource(R.string.display_image_scaling)) { if (a.steam) SettingsRow(stringResource(R.string.display_integer_scaling), null) { PadTextButton( @@ -780,6 +794,9 @@ internal fun SessionDrawer(open: Boolean, requestedPage: SessionDrawerPage, cont SessionPrefs.BACK_DOUBLE_TAP_MS_OPTIONS.map { it to stringResource(R.string.back_tap_ms, it) }, a.backDoubleTapMs, chipModifier = focus.track(page, "back-double-tap"), onPick = a.onBackDoubleTapMs) PhysicalShortcutRows(modifierFor = { focus.track(page, "physical-shortcut-${it.name}") }) + if (a.secondScreenDisplays.isNotEmpty()) ToggleRow(host, "docked-menu-controller", stringResource(R.string.drawer_docked_menu_controller), + null, a.dockedMenuController, + chipModifier = focus.track(page, "docked-menu-controller"), onChange = a.onDockedMenuController) ToggleRow(host, "corner-tap", stringResource(R.string.drawer_corner_tap), stringResource(R.string.drawer_corner_tap_hint), a.cornerTap, chipModifier = focus.track(page, "corner-tap"), onChange = a.onCornerTap) diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index ecb1b28dd..579e08c38 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -4342,6 +4342,7 @@ %1$s opens this menu Back twice opens this menu ยท Back once opens Steam\'s menu Corner tap opens this menu + Physical controls can use bottom screen Double-tap the top-right corner, for devices without a Back button Open the session menu Settings need you diff --git a/app/src/test/java/com/droiddeck/launcher/input/DualScreenTest.kt b/app/src/test/java/com/droiddeck/launcher/input/DualScreenTest.kt index 7409d4558..02380b0f2 100644 --- a/app/src/test/java/com/droiddeck/launcher/input/DualScreenTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/input/DualScreenTest.kt @@ -23,6 +23,34 @@ class DualScreenTest { private val context: Context = ApplicationProvider.getApplicationContext() private val displays = context.getSystemService(DisplayManager::class.java) + @Test fun dockedMenuOnlyTakesTheControllerWhenOptedIn() { + assertFalse(DualScreen.menuOwnsController(open = false, docked = false, optIn = true)) + assertTrue(DualScreen.menuOwnsController(open = true, docked = false, optIn = false)) + assertFalse(DualScreen.menuOwnsController(open = true, docked = true, optIn = false)) + assertTrue(DualScreen.menuOwnsController(open = true, docked = true, optIn = true)) + } + + @Test fun theMenuComesBackOnStartWhenItIsTheSelectedModeOrWasShowingWhenTheScreenClosed() { + val menu = SecondScreenMode.MENU + val terminal = SecondScreenMode.TERMINAL + assertTrue(DualScreen.menuReturnsOnStart(menu, menuWasShown = false, menuUp = false)) + assertTrue(DualScreen.menuReturnsOnStart(menu, menuWasShown = true, menuUp = false)) + assertTrue(DualScreen.menuReturnsOnStart(terminal, menuWasShown = true, menuUp = false)) + assertFalse(DualScreen.menuReturnsOnStart(terminal, menuWasShown = false, menuUp = false)) + assertFalse(DualScreen.menuReturnsOnStart(menu, menuWasShown = true, menuUp = true)) + assertFalse(DualScreen.menuReturnsOnStart(terminal, menuWasShown = true, menuUp = true)) + } + + @Test fun aVisibleDockedMenuThatDoesNotOwnTheControllerIsIdle() { + assertFalse(DualScreen.menuIdleOnBottom(open = false, docked = false, pinned = false, optIn = false)) + assertFalse(DualScreen.menuIdleOnBottom(open = true, docked = false, pinned = false, optIn = false)) + assertTrue(DualScreen.menuIdleOnBottom(open = true, docked = true, pinned = false, optIn = false)) + assertTrue(DualScreen.menuIdleOnBottom(open = false, docked = true, pinned = true, optIn = false)) + assertTrue(DualScreen.menuIdleOnBottom(open = false, docked = true, pinned = true, optIn = true)) + assertFalse(DualScreen.menuIdleOnBottom(open = true, docked = true, pinned = false, optIn = true)) + assertFalse(DualScreen.menuIdleOnBottom(open = false, docked = true, pinned = false, optIn = false)) + } + @Test fun internalPanelsCountAsBuiltIn() { assertTrue(DualScreen.isBuiltIn(1, "Anything")) assertFalse(DualScreen.isBuiltIn(2, "Retroid Pocket Duo")) diff --git a/app/src/test/java/com/droiddeck/launcher/input/SecondScreenModeTest.kt b/app/src/test/java/com/droiddeck/launcher/input/SecondScreenModeTest.kt index 566a091c4..d49a937e0 100644 --- a/app/src/test/java/com/droiddeck/launcher/input/SecondScreenModeTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/input/SecondScreenModeTest.kt @@ -53,14 +53,10 @@ class SecondScreenModeTest { assertEquals(-1, SecondScreenDisplays.selection(-1, emptyList(), false)) } - @Test fun withNothingRememberedDeckPadsGetControlsAndOthersTheDashboard() { - assertEquals(SecondScreenMode.DECK_CONTROLS, SecondScreenMode.opening(null, deckPad = true, dashboard = true)) - assertEquals(SecondScreenMode.DASHBOARD, SecondScreenMode.opening(null, deckPad = false, dashboard = true)) - } - - @Test fun withNothingRememberedAndNoDashboardTheControllerPicksThePanel() { - assertEquals(SecondScreenMode.DECK_CONTROLS, SecondScreenMode.opening(null, deckPad = true)) - assertEquals(SecondScreenMode.KEYBOARD_TRACKPAD, SecondScreenMode.opening(null, deckPad = false)) + @Test fun withNothingRememberedTheDroidDeckMenuOpens() { + for (deckPad in listOf(false, true)) for (dashboard in listOf(false, true)) for (desktop in listOf(false, true)) { + assertEquals(SecondScreenMode.MENU, SecondScreenMode.opening(null, deckPad, dashboard, desktop)) + } } @Test fun thePanelTheUserPickedLastOpensAgain() { @@ -70,9 +66,18 @@ class SecondScreenModeTest { assertEquals(SecondScreenMode.KEYBOARD_TRACKPAD, SecondScreenMode.opening("keyboard-trackpad", deckPad = true)) } + @Test fun theMenuIsAModeAndOpensAgainWhenItWasPickedLast() { + for (deckPad in listOf(false, true)) { + assertEquals(SecondScreenMode.MENU, SecondScreenMode.opening("menu", deckPad, dashboard = true, bottomDesktop = true)) + } + assertEquals("menu", SecondScreenMode.MENU.id) + assertEquals(false, SecondScreenMode.MENU.controls) + assertEquals(null, SecondScreenMode.MENU.bindings) + } + @Test fun deckControlsNeedTheDeckPad() { - assertEquals(SecondScreenMode.KEYBOARD_TRACKPAD, SecondScreenMode.opening("deck-controls", deckPad = false)) - assertEquals(SecondScreenMode.KEYBOARD_TRACKPAD, SecondScreenMode.opening("deck-controls", deckPad = false, dashboard = true)) + assertEquals(SecondScreenMode.MENU, SecondScreenMode.opening("deck-controls", deckPad = false)) + assertEquals(SecondScreenMode.MENU, SecondScreenMode.opening("deck-controls", deckPad = false, dashboard = true)) } @Test fun customControlsReopenWithEitherControllerType() { @@ -81,37 +86,23 @@ class SecondScreenModeTest { } } - @Test fun anUnknownOrClosedChoiceFallsBackToTheDefault() { - assertEquals(SecondScreenMode.DECK_CONTROLS, SecondScreenMode.opening("none", deckPad = true, dashboard = true)) - assertEquals(SecondScreenMode.DASHBOARD, SecondScreenMode.opening("gone", deckPad = false, dashboard = true)) - assertEquals(SecondScreenMode.DECK_CONTROLS, SecondScreenMode.opening("none", deckPad = true)) - assertEquals(SecondScreenMode.KEYBOARD_TRACKPAD, SecondScreenMode.opening("gone", deckPad = false)) + @Test fun anUnknownOrClosedChoiceFallsBackToTheMenu() { + assertEquals(SecondScreenMode.MENU, SecondScreenMode.opening("none", deckPad = true, dashboard = true)) + assertEquals(SecondScreenMode.MENU, SecondScreenMode.opening("gone", deckPad = false, dashboard = true)) + assertEquals(SecondScreenMode.MENU, SecondScreenMode.opening("none", deckPad = true)) + assertEquals(SecondScreenMode.MENU, SecondScreenMode.opening("gone", deckPad = false)) } @Test fun theDashboardOpensAgainOnlyWhileItHasPages() { assertEquals(SecondScreenMode.DASHBOARD, SecondScreenMode.opening("dashboard", deckPad = true, dashboard = true)) - assertEquals(SecondScreenMode.DECK_CONTROLS, SecondScreenMode.opening("dashboard", deckPad = true, dashboard = false)) - assertEquals(SecondScreenMode.KEYBOARD_TRACKPAD, SecondScreenMode.opening("dashboard", deckPad = false)) + assertEquals(SecondScreenMode.MENU, SecondScreenMode.opening("dashboard", deckPad = true, dashboard = false)) + assertEquals(SecondScreenMode.MENU, SecondScreenMode.opening("dashboard", deckPad = false)) } @Test fun theDesktopOpensAgainOnlyWhileItCanRun() { assertEquals(SecondScreenMode.DESKTOP, SecondScreenMode.opening("desktop", deckPad = true, dashboard = true, bottomDesktop = true)) - assertEquals(SecondScreenMode.DECK_CONTROLS, SecondScreenMode.opening("desktop", deckPad = true, dashboard = true)) - assertEquals(SecondScreenMode.KEYBOARD_TRACKPAD, SecondScreenMode.opening("desktop", deckPad = false)) - } - - @Test fun withNothingRememberedTheDesktopIsNeverPicked() { - assertEquals(SecondScreenMode.DASHBOARD, SecondScreenMode.opening(null, deckPad = false, dashboard = true, bottomDesktop = true)) - assertEquals(SecondScreenMode.KEYBOARD_TRACKPAD, SecondScreenMode.opening(null, deckPad = false, bottomDesktop = true)) - } - - @Test fun desktopSessionsOpenTheTrackpadUntilTheUserPicksAnotherPanel() { - for (deckPad in listOf(false, true)) for (dashboard in listOf(false, true)) { - assertEquals(SecondScreenMode.KEYBOARD_TRACKPAD, SecondScreenMode.opening(null, deckPad, dashboard, desktopSession = true)) - assertEquals(SecondScreenMode.KEYBOARD_TRACKPAD, SecondScreenMode.opening("gone", deckPad, dashboard, desktopSession = true)) - assertEquals(SecondScreenMode.CUSTOM_CONTROLS, SecondScreenMode.opening("custom-controls", deckPad, dashboard, desktopSession = true)) - assertEquals(SecondScreenMode.TERMINAL, SecondScreenMode.opening("terminal", deckPad, dashboard, desktopSession = true)) - } + assertEquals(SecondScreenMode.MENU, SecondScreenMode.opening("desktop", deckPad = true, dashboard = true)) + assertEquals(SecondScreenMode.MENU, SecondScreenMode.opening("desktop", deckPad = false)) } @Test fun theEditorOpensOnTheChosenBottomScreenUnlessAnotherAppHoldsIt() { diff --git a/app/src/test/java/com/droiddeck/launcher/input/SecondScreenProfileMigrationTest.kt b/app/src/test/java/com/droiddeck/launcher/input/SecondScreenProfileMigrationTest.kt index 669db3975..ba688bcbd 100644 --- a/app/src/test/java/com/droiddeck/launcher/input/SecondScreenProfileMigrationTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/input/SecondScreenProfileMigrationTest.kt @@ -48,20 +48,14 @@ class SecondScreenProfileMigrationTest { SessionState.deckPad = previousDeckPad } - @Test fun firstOpeningKeepsTheLibraryAndOpensTheTrackpadOnDesktopAndTheControllerPanelInGames() { + @Test fun firstOpeningKeepsTheLibraryAndOpensTheMenuOverTheTrackpad() { for (desktop in listOf(false, true)) for (deckPad in listOf(false, true)) { val original = customLibrary(desktop) open(desktop, deckPad) assertEquals(original, InputLibraries.read(activity)) assertNull(SessionPrefs.secondScreenPanel(activity, desktop)) - val dashboard = ReflectionHelpers.callInstanceMethod>(activity, "bottomPages").isNotEmpty() - val expected = when { - desktop -> SecondScreenMode.KEYBOARD_TRACKPAD - deckPad -> SecondScreenMode.DECK_CONTROLS - dashboard -> SecondScreenMode.DASHBOARD - else -> SecondScreenMode.KEYBOARD_TRACKPAD - } - assertEquals(expected, SessionState.secondScreenMode) + assertEquals(SecondScreenMode.MENU, ReflectionHelpers.callInstanceMethod(activity, "openingPanel")) + assertEquals(SecondScreenMode.KEYBOARD_TRACKPAD, SessionState.secondScreenMode) } } @@ -107,9 +101,8 @@ class SecondScreenProfileMigrationTest { customLibrary(desktop) SessionState.deckPad = false show(SecondScreenMode.DECK_CONTROLS) - val fallback = ReflectionHelpers.callInstanceMethod(activity, "openingPanel") - assertNotEquals(SecondScreenMode.DECK_CONTROLS, fallback) - if (desktop) assertEquals(SecondScreenMode.KEYBOARD_TRACKPAD, fallback) + val fallback = ReflectionHelpers.callInstanceMethod(activity, "openingSurface") + assertEquals(SecondScreenMode.KEYBOARD_TRACKPAD, fallback) assertEquals(fallback, SessionState.secondScreenMode) assertNotEquals(InputLibraries.DECK, routedLayout()?.id) } diff --git a/docs/agent-control.md b/docs/agent-control.md index 13bf1c232..ac097234c 100644 --- a/docs/agent-control.md +++ b/docs/agent-control.md @@ -135,6 +135,7 @@ tools/droiddeckctl input text 'hello world' tools/droiddeckctl input tap 640 360 tools/droiddeckctl input swipe 100 600 100 100 --duration 400 tools/droiddeckctl input pad a +tools/droiddeckctl input gamepad b rb up --hold 120 --gap 400 tools/droiddeckctl input stick left 0 -1 --hold 500 tools/droiddeckctl input trigger right 1.0 tools/droiddeckctl input pen tap 0.5 0.5 --pressure 0.7 @@ -234,6 +235,18 @@ and returns its exit code with the last 160 KiB of stdout and stderr (`--timeout that side over conflicts. The store id is the one in the game's install record (`library` shows it). Both need Setup > Developer > Debugging tools. +`input pad` writes to the session's virtual pad, the one the guest sees, and never reaches the app's +own key handling. To test how DroidDeck's own screens treat a controller (menu focus and outlines, +page switching with LB and RB, Back and Steam shortcuts), use `input gamepad`. It registers a real +gamepad called "DroidDeck test pad" with `adb shell uinput -`, so Android reports a physical +controller, and presses the buttons in order: `a b x y lb rb select start guide l3 r3` and the +d-pad `up down left right`. `--hold` (120 ms) is how long each stays down and `--gap` (400 ms) the +pause after it; a d-pad press always waits at least 20 ms, so Android sees each release before +the next press. The device exists only while the command runs, takes about a second to appear, and +works without a session or Setup > Developer > Debugging tools. Its name does not start with +`uinput-`, which the app treats as a system virtual device. `UINPUT_UNAVAILABLE` and `UINPUT_FAILED` +mean the same as for `input pen`. + `input pen` does not go through the app. It registers a virtual pen with `adb shell uinput -`, so Android's own input reader makes the stylus events, as for a built-in pen, and it works on whatever is on screen, without a session or Setup > Developer > Debugging tools. Positions are fractions of diff --git a/tools/droiddeckctl b/tools/droiddeckctl index 2a404c1c6..2a4341c51 100755 --- a/tools/droiddeckctl +++ b/tools/droiddeckctl @@ -792,7 +792,7 @@ def uinput_commands(samples: list[dict], tool: str, viewport: dict) -> list[dict {"id": 1, "command": "sync", "syncToken": UINPUT_SYNC}] -def pen_uinput(adb: str, serial: str, samples: list[dict], tool: str) -> dict: +def uinput_check(adb: str, serial: str) -> None: probe = run_adb(adb, serial, "shell", "command -v uinput >/dev/null 2>&1 || echo no-uinput; [ -w /dev/uinput ] || echo no-dev-uinput") if probe.returncode != 0: @@ -802,6 +802,10 @@ def pen_uinput(adb: str, serial: str, samples: list[dict], tool: str) -> dict: raise ControlError("This device's shell has no `uinput` command", "UINPUT_UNAVAILABLE") if "no-dev-uinput" in missing: raise ControlError("The ADB shell cannot write /dev/uinput on this device", "UINPUT_UNAVAILABLE") + + +def pen_uinput(adb: str, serial: str, samples: list[dict], tool: str) -> dict: + uinput_check(adb, serial) viewport = input_viewport(run_adb(adb, serial, "shell", "dumpsys", "input").stdout.decode(errors="replace")) script = "".join(json.dumps(command) + "\n" for command in uinput_commands(samples, tool, viewport)) started = time.monotonic() @@ -817,6 +821,68 @@ def pen_uinput(adb: str, serial: str, samples: list[dict], tool: str) -> dict: "viewport": {key: viewport[key] for key in ("display", "rotation", "size")}} +GAMEPAD_NAME = "DroidDeck test pad" +GAMEPAD_SYNC = "droiddeckctl-gamepad-done" +GAMEPAD_BUTTONS = {"a": "BTN_SOUTH", "b": "BTN_EAST", "x": "BTN_NORTH", "y": "BTN_WEST", "lb": "BTN_TL", "rb": "BTN_TR", + "select": "BTN_SELECT", "start": "BTN_START", "guide": "BTN_MODE", "l3": "BTN_THUMBL", "r3": "BTN_THUMBR"} +GAMEPAD_DPAD = {"up": ("ABS_HAT0Y", -1), "down": ("ABS_HAT0Y", 1), "left": ("ABS_HAT0X", -1), "right": ("ABS_HAT0X", 1)} +GAMEPAD_MAX_PRESSES = 200 +GAMEPAD_DPAD_MIN_GAP_MS = 20 + + +def gamepad_commands(buttons: list[str], hold: int, gap: int) -> list[dict]: + def axis(code: str, low: int, high: int) -> dict: + return {"code": code, "info": {"value": 0, "minimum": low, "maximum": high, "fuzz": 0, "flat": 0, "resolution": 0}} + + unknown = [name for name in buttons if name not in GAMEPAD_BUTTONS and name not in GAMEPAD_DPAD] + if unknown: + raise ControlError(f"Unknown gamepad button {unknown[0]!r}; use " + f"{', '.join(list(GAMEPAD_BUTTONS) + list(GAMEPAD_DPAD))}", "INVALID_INPUT") + if not 1 <= len(buttons) <= GAMEPAD_MAX_PRESSES: + raise ControlError(f"Press between 1 and {GAMEPAD_MAX_PRESSES} buttons", "INVALID_INPUT") + if not 10 <= hold <= 5000 or not 0 <= gap <= 5000: + raise ControlError("--hold must be 10..5000 ms and --gap 0..5000 ms", "INVALID_INPUT") + commands: list[dict] = [ + {"id": 1, "command": "register", "name": GAMEPAD_NAME, "bus": "usb", "vid": 0x045E, "pid": 0x028E, + "configuration": [ + {"type": "UI_SET_EVBIT", "data": ["EV_KEY", "EV_ABS"]}, + {"type": "UI_SET_KEYBIT", "data": sorted(GAMEPAD_BUTTONS.values())}, + {"type": "UI_SET_ABSBIT", "data": ["ABS_X", "ABS_Y", "ABS_RX", "ABS_RY", "ABS_HAT0X", "ABS_HAT0Y"]}, + ], + "abs_info": [axis("ABS_X", -32768, 32767), axis("ABS_Y", -32768, 32767), axis("ABS_RX", -32768, 32767), + axis("ABS_RY", -32768, 32767), axis("ABS_HAT0X", -1, 1), axis("ABS_HAT0Y", -1, 1)]}, + {"id": 1, "command": "delay", "duration": UINPUT_REGISTER_MS}, + ] + for name in buttons: + code, down, up = (GAMEPAD_BUTTONS[name], 1, 0) if name in GAMEPAD_BUTTONS else \ + (GAMEPAD_DPAD[name][0], GAMEPAD_DPAD[name][1], 0) + kind = "EV_KEY" if name in GAMEPAD_BUTTONS else "EV_ABS" + commands += [{"id": 1, "command": "inject", "events": [kind, code, down, "EV_SYN", "SYN_REPORT", 0]}, + {"id": 1, "command": "delay", "duration": hold}, + {"id": 1, "command": "inject", "events": [kind, code, up, "EV_SYN", "SYN_REPORT", 0]}] + pause = gap if name in GAMEPAD_BUTTONS else max(gap, GAMEPAD_DPAD_MIN_GAP_MS) + if pause > 0: + commands.append({"id": 1, "command": "delay", "duration": pause}) + return commands + [{"id": 1, "command": "delay", "duration": UINPUT_TAIL_MS}, + {"id": 1, "command": "sync", "syncToken": GAMEPAD_SYNC}] + + +def gamepad_uinput(adb: str, serial: str, buttons: list[str], hold: int, gap: int) -> dict: + commands = gamepad_commands(buttons, hold, gap) + uinput_check(adb, serial) + script = "".join(json.dumps(command) + "\n" for command in commands) + started = time.monotonic() + result = run_adb(adb, serial, "shell", "uinput", "-", stdin=script.encode(), + timeout=(UINPUT_REGISTER_MS + len(buttons) * (hold + gap) + UINPUT_TAIL_MS) / 1000 + 30) + elapsed = round((time.monotonic() - started) * 1000) + if GAMEPAD_SYNC not in result.stdout.decode(errors="replace"): + detail = (result.stderr or result.stdout).decode(errors="replace").strip()[-400:] + raise ControlError(f"uinput stopped before the last button (exit {result.returncode})" + + (f": {detail}" if detail else "") + "; `adb logcat -s UINPUT UinputDevice` tells why", + "UINPUT_FAILED") + return {"ok": True, "command": "input", "type": "gamepad", "buttons": buttons, "ms": elapsed} + + def xr_ppm_to_png(data: bytes, linear: bool = False) -> bytes: header = re.match(rb"P6\n([0-9]+) ([0-9]+)\n255\n", data) if not header: @@ -1081,6 +1147,8 @@ def execute(args: argparse.Namespace, adb: str, serial: str) -> dict: if command == "input": if args.input_type == "pen": return add_serial(pen_uinput(adb, serial, pen_samples(args), args.tool), serial) + if args.input_type == "gamepad": + return add_serial(gamepad_uinput(adb, serial, args.buttons, args.hold, args.gap), serial) return add_serial(checked(provider_call(adb, serial, "input", request=input_request(args), timeout=60), "INPUT_FAILED"), serial) @@ -1359,6 +1427,13 @@ def build_parser() -> argparse.ArgumentParser: pad.add_argument("button") pad.add_argument("--action", choices=["tap", "down", "up"], default="tap") pad.add_argument("--hold", type=int, default=120) + gamepad = kinds.add_parser( + "gamepad", help="press buttons on a real uinput gamepad that Android sees as a physical controller " + "(unlike pad, which only feeds the guest's virtual pad)") + gamepad.add_argument("buttons", nargs="+", metavar="BUTTON", + help="a b x y lb rb select start guide l3 r3 up down left right, pressed in order") + gamepad.add_argument("--hold", type=int, default=120, help="ms each button stays down") + gamepad.add_argument("--gap", type=int, default=400, help="ms between buttons (a d-pad press always waits at least 20 ms)") stick = kinds.add_parser("stick", help="hold a stick at x, y (-1..1)") stick.add_argument("stick", choices=["left", "right"]) stick.add_argument("x", type=float) diff --git a/tools/tests/test_droiddeckctl_gamepad.py b/tools/tests/test_droiddeckctl_gamepad.py new file mode 100644 index 000000000..201a92e59 --- /dev/null +++ b/tools/tests/test_droiddeckctl_gamepad.py @@ -0,0 +1,91 @@ +import json +import unittest + +from test_droiddeckctl import FakeAdbTest, ctl + + +def key_frames(commands): + found = [] + for command in commands: + if command["command"] == "inject": + events = command["events"] + found.append({code: value for code, value in zip(events[1::3], events[2::3]) if code != "SYN_REPORT"}) + return found + + +class GamepadTest(FakeAdbTest): + def setUp(self): + super().setUp() + self.configure({}) + + def gamepad(self, *argv): + return self.run_ctl("input", "gamepad", *argv) + + def script(self): + [call] = [c for c in self.calls() if c["args"][:3] == ["shell", "uinput", "-"]] + return [json.loads(line) for line in call["stdin"].splitlines()] + + def test_buttons_are_pressed_in_order_on_a_real_looking_gamepad(self): + code, out = self.gamepad("b", "rb", "--hold", "50", "--gap", "100") + self.assertEqual(0, code) + self.assertEqual({"ok": True, "command": "input", "type": "gamepad", "buttons": ["b", "rb"], "deviceSerial": "fake-1"}, + {k: v for k, v in out.items() if k != "ms"}) + self.assertFalse(self.calls("input")) + commands = self.script() + register = commands[0] + bits = {c["type"]: c["data"] for c in register["configuration"]} + self.assertEqual(("register", "usb", ["EV_KEY", "EV_ABS"]), (register["command"], register["bus"], bits["UI_SET_EVBIT"])) + self.assertFalse(register["name"].lower().startswith(("uinput-", "uinput_"))) + self.assertTrue({"BTN_SOUTH", "BTN_EAST", "BTN_TL", "BTN_TR", "BTN_START"} <= set(bits["UI_SET_KEYBIT"])) + self.assertEqual(set(bits["UI_SET_ABSBIT"]), {a["code"] for a in register["abs_info"]}) + self.assertEqual({"id": 1, "command": "delay", "duration": ctl.UINPUT_REGISTER_MS}, commands[1]) + self.assertEqual([{"BTN_EAST": 1}, {"BTN_EAST": 0}, {"BTN_TR": 1}, {"BTN_TR": 0}], key_frames(commands)) + self.assertEqual([50, 100, 50, 100], [c["duration"] for c in commands[2:-2] if c["command"] == "delay"]) + self.assertEqual({"id": 1, "command": "sync", "syncToken": ctl.GAMEPAD_SYNC}, commands[-1]) + + def test_a_zero_gap_sends_no_empty_delay_which_android_rejects(self): + code, _ = self.gamepad("a", "b", "--hold", "40", "--gap", "0") + self.assertEqual(0, code) + commands = self.script() + self.assertEqual([{"BTN_SOUTH": 1}, {"BTN_SOUTH": 0}, {"BTN_EAST": 1}, {"BTN_EAST": 0}], key_frames(commands)) + self.assertEqual([], [c for c in commands if c["command"] == "delay" and c["duration"] <= 0]) + self.assertEqual([40, 40], [c["duration"] for c in commands[2:-2] if c["command"] == "delay"]) + + def test_a_dpad_release_never_runs_into_the_next_press_even_at_zero_gap(self): + code, _ = self.gamepad("left", "left", "--hold", "40", "--gap", "0") + self.assertEqual(0, code) + commands = self.script() + self.assertEqual([{"ABS_HAT0X": -1}, {"ABS_HAT0X": 0}, {"ABS_HAT0X": -1}, {"ABS_HAT0X": 0}], key_frames(commands)) + self.assertEqual([40, ctl.GAMEPAD_DPAD_MIN_GAP_MS, 40, ctl.GAMEPAD_DPAD_MIN_GAP_MS], + [c["duration"] for c in commands[2:-2] if c["command"] == "delay"]) + + def test_the_dpad_uses_the_hat_axes(self): + code, _ = self.gamepad("up", "right", "down", "left") + self.assertEqual(0, code) + self.assertEqual([{"ABS_HAT0Y": -1}, {"ABS_HAT0Y": 0}, {"ABS_HAT0X": 1}, {"ABS_HAT0X": 0}, + {"ABS_HAT0Y": 1}, {"ABS_HAT0Y": 0}, {"ABS_HAT0X": -1}, {"ABS_HAT0X": 0}], + key_frames(self.script())) + + def test_an_unknown_button_or_bad_timing_is_refused_before_touching_the_device(self): + for argv, message in ((("nope",), "Unknown gamepad button 'nope'"), (("a", "--hold", "1"), "--hold must be"), + (("a", "--gap", "-5"), "--gap 0..5000")): + with self.subTest(argv=argv): + code, out = self.gamepad(*argv) + self.assertEqual((2, "INVALID_INPUT"), (code, out["error"]["code"])) + self.assertIn(message, out["error"]["message"]) + self.assertFalse(self.calls()) + + def test_a_shell_without_uinput_is_unavailable(self): + self.configure({}, uinput_probe="no-dev-uinput") + code, out = self.gamepad("a") + self.assertEqual((3, "UINPUT_UNAVAILABLE"), (code, out["error"]["code"])) + self.assertFalse([c for c in self.calls() if c["args"][:2] == ["shell", "uinput"]]) + + def test_uinput_that_stops_early_fails(self): + self.configure({}, uinput_stdout="") + code, out = self.gamepad("a") + self.assertEqual((3, "UINPUT_FAILED"), (code, out["error"]["code"])) + + +if __name__ == "__main__": + unittest.main()