feat(session): the DroidDeck menu is a bottom-screen mode, and the controller stays with the game (#3001)

This commit is contained in:
Kurt Himebauch authored and GitHub committed 2026-11-22 00:16:49 -05:00
1 parent aefa5a3c0d
commit 9cfab884d5
16 files changed
+446 -113

No files matched your search

@@ -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<androidx.compose.ui.geometry.Rect?>(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
@@ -23,6 +23,14 @@ object DualScreen {
@Volatile private var takenDisplays: Set<Int> = 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
@@ -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
}
}
@@ -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) {
@@ -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
@@ -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",
@@ -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) }
@@ -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
}
}
@@ -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)
+1
View File
@@ -4342,6 +4342,7 @@
<string name="drawer_hint_button">%1$s opens this menu</string>
<string name="drawer_hint_steam_inverted">Back twice opens this menu · Back once opens Steam\'s menu</string>
<string name="drawer_corner_tap">Corner tap opens this menu</string>
<string name="drawer_docked_menu_controller">Physical controls can use bottom screen</string>
<string name="drawer_corner_tap_hint">Double-tap the top-right corner, for devices without a Back button</string>
<string name="drawer_handle">Open the session menu</string>
<string name="play_needs_you">Settings need you</string>
@@ -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"))
@@ -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() {
@@ -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<List<*>>(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<SecondScreenMode>(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<SecondScreenMode>(activity, "openingPanel")
assertNotEquals(SecondScreenMode.DECK_CONTROLS, fallback)
if (desktop) assertEquals(SecondScreenMode.KEYBOARD_TRACKPAD, fallback)
val fallback = ReflectionHelpers.callInstanceMethod<SecondScreenMode>(activity, "openingSurface")
assertEquals(SecondScreenMode.KEYBOARD_TRACKPAD, fallback)
assertEquals(fallback, SessionState.secondScreenMode)
assertNotEquals(InputLibraries.DECK, routedLayout()?.id)
}
+13
View File
@@ -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
+76 -1
View File
@@ -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)
+91
View File
@@ -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()