diff --git a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt index 9f9284b92f..39ae906175 100644 --- a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt +++ b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt @@ -541,6 +541,9 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde private var lastMouseY = Float.NaN private var padType by mutableStateOf(SessionPrefs.CONTROLLER_DECK) private var pcKeyboardOpen by mutableStateOf(false) + private var fieldKeyboardOnPrimary = false + private var pendingFieldKeyboard = false + private var fieldKeyboardImeShown = false private var achievementsInFront by mutableStateOf(null) private var achievementsOpen by mutableStateOf(false) private var hudOn by mutableStateOf(true) @@ -658,11 +661,13 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde override fun onDisplayAdded(displayId: Int) { notifyActivityDisplayStateChanged(displayId) refreshSecondScreenDisplays() + updateBottomGame() } override fun onDisplayRemoved(displayId: Int) { if (refreshActivityDisplayId() && started) { SessionService.setActivityDisplay(this@SessionActivity, sessionActivityDisplayId) } + updateBottomGame() refreshSecondScreenDisplays() } override fun onDisplayChanged(displayId: Int) { @@ -874,10 +879,10 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde root.addView(controls) } keyboard = KeyboardHost(this).also { host -> - host.onImeChanged = { updateDesktopKeyboardButton() } + host.onImeChanged = ::onPrimaryImeChanged root.addView(host) } - desktopKeyboardButton = com.droiddeck.launcher.input.DesktopKeyboardButton(this) { keyboard?.show() } + desktopKeyboardButton = com.droiddeck.launcher.input.DesktopKeyboardButton(this) { showPrimaryKeyboard() } .also { root.addView(it) } touchpad = TouchpadGestures(PointerGestures.slop(this), pointerListener) directTouchHold = DirectTouchHold(PointerGestures.slop(this), pointerListener, directTouchSink) @@ -1093,6 +1098,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde if (AgentGuest.keyboardDismissals != keyboardDismissalsSeen[0]) { keyboardDismissalsSeen[0] = AgentGuest.keyboardDismissals secondScreenPresentation?.closeFieldKeyboard() + dismissFieldKeyboard() } } androidx.compose.runtime.LaunchedEffect(picturePosition, integerScaling, SessionState.running, pipUi, cardboard.enabled) { applyGameAlignment() } @@ -1315,7 +1321,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde } if (pcKeyboardOpen) com.droiddeck.launcher.ui.PcKeyboard( sendKey = { code, down -> if (CompositorHost.isStarted) sendGuestKey(code, down, 32) }, - onAndroidKeyboard = { pcKeyboardOpen = false; keyboard?.toggle() }, + onAndroidKeyboard = { pcKeyboardOpen = false; togglePrimaryKeyboard() }, onClose = { pcKeyboardOpen = false }, ) if (!drawerDocked) SessionMenu( @@ -1439,6 +1445,8 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde secondScreenNone = !bottomOutputActive && !dockDrawer(), gameOnBottom = bottomOutputActive, gameSwapAvailable = bottomSwapAvailable, + gameSwapBuiltIn = !::displayManager.isInitialized || displayManager.getDisplay(selectedSecondScreenDisplay) + ?.let(com.droiddeck.launcher.input.DualScreen::builtIn) ?: true, onGameOnBottom = { on -> drawerOpen = false; putGameOnBottom(on) }, dashboardAvailable = bottomPages().isNotEmpty(), desktopAvailable = com.droiddeck.launcher.session.BottomDesktop.available(), @@ -1632,7 +1640,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde pickLossless.launch(InAppFilePicker.buildIntent( this@SessionActivity, listOf("dll"), getString(R.string.lsfg_pick_title))) }, - onKeyboard = { drawerOpen = false; pcKeyboardOpen = false; keyboard?.toggle() }, + onKeyboard = { drawerOpen = false; pcKeyboardOpen = false; togglePrimaryKeyboard() }, onHardwareKeyboard = ::togglePcKeyboard, wowChatShown = com.droiddeck.launcher.ui.WowChat.isWow(AgentGuest.gameProgram), wowChat = wowChat.remembered, @@ -1863,7 +1871,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde val all = com.droiddeck.launcher.input.VrControllers.Emulate.entries com.droiddeck.launcher.input.VrControllers.setEmulate(this, all[(pads.emulate.ordinal + 1) % all.size]) }) else null, - onKeyboard = { keyboard?.toggle() }, + onKeyboard = { togglePrimaryKeyboard() }, onSessionMenu = { drawerOpen = true }, onStopSteamVr = if (vr) ({ steamVrAction("stop") }) else null, brightness = glasses.brightness, @@ -1904,12 +1912,44 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde private fun togglePcKeyboard() { drawerOpen = false - keyboard?.hide() + hidePrimaryKeyboard() onScreenControls?.releaseAll() bottomInputControls?.releaseAll() pcKeyboardOpen = !pcKeyboardOpen } + private fun showPrimaryKeyboard() { + pendingFieldKeyboard = false + fieldKeyboardOnPrimary = false + keyboard?.show() + } + + private fun togglePrimaryKeyboard() { + pendingFieldKeyboard = false + fieldKeyboardOnPrimary = false + keyboard?.toggle() + } + + private fun hidePrimaryKeyboard() { + pendingFieldKeyboard = false + fieldKeyboardOnPrimary = false + keyboard?.hide() + } + + private fun onPrimaryImeChanged(visible: Boolean) { + if (visible) fieldKeyboardImeShown = true + else if (fieldKeyboardImeShown) { + fieldKeyboardImeShown = false + fieldKeyboardOnPrimary = false + } + updateDesktopKeyboardButton() + } + + private fun dismissFieldKeyboard() { + pendingFieldKeyboard = false + if (fieldKeyboardOnPrimary) hidePrimaryKeyboard() + } + private fun updateControllerPrefs(change: () -> Unit) { change() controllerSettings = ControllerPrefs.read(this) @@ -3660,7 +3700,6 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde val target = com.droiddeck.launcher.input.DualScreen.sessionDisplay(this, displayManager, shownOnDisplayId) ?: return false return try { val presentation = secondScreenPresentation ?: secondScreenPresentation(target).also { - selectedSecondScreenDisplay = target.displayId secondScreenPresentation = it } if (!presentation.isShowing) presentation.show() @@ -4019,16 +4058,23 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde val candidates = SecondScreenDisplays.available(displayManager, primaryId) .filter { glassesScreen == null || it.id != glasses.displayId } val oldIds = secondScreenDisplays.map { it.id }.toSet() + val oldSelectedDisplay = selectedSecondScreenDisplay secondScreenDisplays = candidates reconcileDock(primaryId) - bottomSwapAvailable = bottomGame != null || bottomGameDisplay() != null val newIds = candidates.map { it.id }.toSet() if (secondScreenMode != SecondScreenMode.NONE && oldIds.isNotEmpty() && selectedSecondScreenDisplay !in newIds) { + bottomSwapAvailable = bottomGame != null closeSecondScreen(reset = true) SessionState.secondScreenAutoOpened = false return } - if (selectedSecondScreenDisplay !in newIds) selectedSecondScreenDisplay = candidates.firstOrNull()?.id ?: -1 + selectedSecondScreenDisplay = SecondScreenDisplays.selection(selectedSecondScreenDisplay, candidates.map { it.id }, gameOnBottom) { + SessionState.secondScreenDisplay = it + } + if (selectedSecondScreenDisplay != oldSelectedDisplay) { + updateBottomGame() + } + bottomSwapAvailable = bottomGame != null || bottomGameDisplay() != null if (secondScreenMode != SecondScreenMode.NONE && candidates.isEmpty()) { closeSecondScreen(reset = true) SessionState.secondScreenAutoOpened = false @@ -4050,12 +4096,22 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde private fun openDualScreenControls() { if (SessionState.secondScreenAutoOpened || secondScreenMode != SecondScreenMode.NONE || pipUi) return + if (gameOnBottom && selectedSecondScreenDisplay >= 0 && secondScreenDisplays.none { it.id == selectedSecondScreenDisplay }) return if (!SessionPrefs.dualScreenSessionControls(this)) return val target = com.droiddeck.launcher.input.DualScreen.sessionDisplay(this, displayManager, shownOnDisplayId) ?: return if (secondScreenDisplays.none { it.id == target.displayId }) return + val gameDisplay = bottomGame?.display?.displayId + ?: if (SessionState.gameOnBottom) bottomGameDisplay()?.displayId else null SessionState.secondScreenAutoOpened = true - selectedSecondScreenDisplay = target.displayId - selectSecondScreenMode(openingPanel()) + if (gameDisplay != null && gameDisplay != target.displayId && secondScreenDisplays.any { it.id == gameDisplay }) { + panelMode(openingPanel()) + } else { + val selectionChanged = selectedSecondScreenDisplay != target.displayId + selectedSecondScreenDisplay = target.displayId + SessionState.secondScreenDisplay = target.displayId + if (selectionChanged) updateBottomGame() + selectSecondScreenMode(openingPanel()) + } automaticPanel = secondScreenMode != SecondScreenMode.NONE dualControlsProvisional = ::loading.isInitialized && loading.visible } @@ -4081,6 +4137,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde if (secondScreenDisplays.none { it.id == displayId }) return selectedSecondScreenDisplay = displayId SessionState.secondScreenDisplay = displayId + updateBottomGame() if (secondScreenMode != SecondScreenMode.NONE) showSecondScreen(secondScreenMode) } @@ -4099,6 +4156,10 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde return } if (selectedSecondScreenDisplay !in secondScreenDisplays.map { it.id }) { + if (gameOnBottom && selectedSecondScreenDisplay >= 0) { + panelMode(mode) + return + } selectedSecondScreenDisplay = secondScreenDisplays.first().id } showSecondScreen(mode) @@ -4177,7 +4238,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde ) } }, - onSwap = if (bottomSwapAvailable && com.droiddeck.launcher.input.DualScreen.builtIn(target)) ({ putGameOnBottom(true) }) else null, + onSwap = if (bottomSwapAvailable) ({ putGameOnBottom(true) }) else null, onDeckPanel = ::selectDeckPanel, dashboard = if (bottomPages().isEmpty()) null else ({ DroidDeckTheme { @@ -4421,6 +4482,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde if (!started) return null if (secondScreenPresentation?.showsKeyboard != true && dockDrawer()) { val target = com.droiddeck.launcher.input.DualScreen.sessionDisplay(this, displayManager, shownOnDisplayId) ?: return null + if (gameOnBottom && selectedSecondScreenDisplay != target.displayId) return null if (drawerOpen || drawerPinned) drawerOpen = false typingReturnMode = secondScreenMode selectedSecondScreenDisplay = target.displayId @@ -4430,16 +4492,37 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde } private fun openBottomKeyboard() { - val presentation = bottomKeyboardPresentation() ?: return + val presentation = bottomKeyboardPresentation() + if (presentation == null) { + if (keyboardBelongsOnPrimary()) { + pendingFieldKeyboard = true + retryFieldKeyboard(hasWindowFocus()) + } + return + } + pendingFieldKeyboard = false + if (fieldKeyboardOnPrimary) hidePrimaryKeyboard() presentation.requestKeyboard(forField = true) com.droiddeck.launcher.ui.SessionTyping.focusDisplay(this, presentation.display.displayId) } + private fun keyboardBelongsOnPrimary() = SecondScreenDisplays.keyboardOnPrimary(gameOnBottom, selectedSecondScreenDisplay, + secondScreenDisplays.map { it.id }, taken = com.droiddeck.launcher.input.DualScreen::taken) + + private fun retryFieldKeyboard(hasFocus: Boolean) { + if (!pendingFieldKeyboard || !hasFocus || !resumed || pipUi) return + pendingFieldKeyboard = false + if (!keyboardBelongsOnPrimary()) return + fieldKeyboardOnPrimary = true + fieldKeyboardImeShown = keyboard?.hideMeansDismissal == true + keyboard?.show() + } + private fun onGameTextField(focused: Boolean) { if (!focused || !com.droiddeck.launcher.ui.WowChat.isWow(AgentGuest.gameProgram)) wowChat.chatClosed() else if (resumed && !pipUi && !pcKeyboardOpen && resources.configuration.hardKeyboardHidden != android.content.res.Configuration.HARDKEYBOARDHIDDEN_NO) { - keyboard?.takeIf { it.shown }?.hide() + hidePrimaryKeyboard() wowChat.chatOpened() } } @@ -4526,9 +4609,13 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde } private fun updateKeyboardRoute() { - AgentGuest.routeKeyboard(this, SessionState.mode == SessionService.MODE_STEAM && - (secondScreenPresentation?.showsKeyboard == true || dockDrawer()) && - SessionPrefs.androidTextFieldKeyboard(this)) + AgentGuest.routeKeyboard(this, SecondScreenDisplays.routeKeyboard( + SessionState.mode == SessionService.MODE_STEAM, + SessionPrefs.androidTextFieldKeyboard(this), + secondScreenPresentation?.showsKeyboard == true, + dockDrawer(), + SecondScreenDisplays.keyboardOnPrimary(gameOnBottom, selectedSecondScreenDisplay, + secondScreenDisplays.map { it.id }, resumed && !pipUi, com.droiddeck.launcher.input.DualScreen::taken))) } private fun dropDockedDrawer() { @@ -5427,6 +5514,8 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde private fun showPipUi(show: Boolean) { pipUi = show + updateKeyboardRoute() + if (!show) retryFieldKeyboard(hasWindowFocus()) if (show) { if (::hud.isInitialized) hud.setHidden(true) drawerOpen = false @@ -5446,7 +5535,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde guestKeysDown.toList().forEach { sendGuestKey(it, false) } heldKeys.clear() heldButtons.clear() - keyboard?.hide() + hidePrimaryKeyboard() sessionClipboard.stop() padMotion?.stop() cursorVisible = false @@ -5589,6 +5678,8 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde onScreenControls?.reload() controllerSettings = ControllerPrefs.read(this) resumed = true + updateKeyboardRoute() + retryFieldKeyboard(hasWindowFocus()) updateDesktopKeyboardButton() com.droiddeck.launcher.input.HomeButtonShortcuts.attach(this, enabled = { @@ -5662,9 +5753,12 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde if (::scrollTouch.isInitialized) scrollTouch.cancel() if (::padMouse.isInitialized) padMouse.reset() resumed = false + updateKeyboardRoute() updatePointerCapture() updatePadMotion() - keyboard?.takeIf { it.shown }?.hide() + val pendingKeyboard = pendingFieldKeyboard + hidePrimaryKeyboard() + pendingFieldKeyboard = pendingKeyboard SessionPrefs.sessionPrefs(this).unregisterOnSharedPreferenceChangeListener(cardboardPrefListener) SessionPrefs.sessionPrefs(this).unregisterOnSharedPreferenceChangeListener(screenEffectsProfilePrefListener) ControllerPrefs.prefs(this).unregisterOnSharedPreferenceChangeListener(shortcutPrefListener) @@ -5910,9 +6004,10 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde } private fun bottomGameDisplay(): Display? { - if (!::displayManager.isInitialized) return null - return com.droiddeck.launcher.input.DualScreen.sessionDisplay(this, displayManager, shownOnDisplayId) - ?.takeIf { it.isValid && com.droiddeck.launcher.input.DualScreen.builtIn(it) } + if (!::displayManager.isInitialized || SessionPrefs.dualScreenSessionMode(this) == com.droiddeck.launcher.input.DualScreen.MODE_OFF) return null + return com.droiddeck.launcher.input.DualScreen.selectedSessionDisplay( + this, displayManager, shownOnDisplayId, selectedSecondScreenDisplay, + ) } private fun putGameOnBottom(on: Boolean) { @@ -6038,7 +6133,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde tabs = tabs, ) val keyboardExtra = com.droiddeck.launcher.ui.BarExtra(getString(R.string.second_show_keyboard), icon = R.drawable.ic_bottom_keyboard) { - keyboard?.toggle() + togglePrimaryKeyboard() } val profileLayout = secondaryInputLayout androidx.compose.foundation.layout.Box( @@ -6235,6 +6330,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde releaseHeldGuestInput() } if (hasFocus && !pipUi) { + retryFieldKeyboard(true) goFullscreen() refreshClipboard() } 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 848fc65701..1d8bf5d682 100644 --- a/app/src/main/java/com/droiddeck/launcher/input/DualScreen.kt +++ b/app/src/main/java/com/droiddeck/launcher/input/DualScreen.kt @@ -82,6 +82,12 @@ object DualScreen { fun sessionDisplay(context: Context, displayManager: DisplayManager, primaryDisplayId: Int): Display? = display(context, displayManager, primaryDisplayId, SessionPrefs.dualScreenSessionMode(context)) + fun selectedSessionDisplay(context: Context, displayManager: DisplayManager, primaryDisplayId: Int, selectedDisplayId: Int): Display? = + displayManager.getDisplay(selectedDisplayId)?.takeIf { + SessionPrefs.dualScreenSessionMode(context) != MODE_OFF && it.isValid && it.displayId != primaryDisplayId && + (it.flags and Display.FLAG_PRESENTATION) != 0 && !taken(it.displayId) + } + fun display(context: Context, displayManager: DisplayManager, primaryDisplayId: Int, mode: String = SessionPrefs.dualScreenMode(context)): Display? = when (mode) { MODE_OFF -> null diff --git a/app/src/main/java/com/droiddeck/launcher/input/KeyboardHost.kt b/app/src/main/java/com/droiddeck/launcher/input/KeyboardHost.kt index 6656b7697f..5372be6db5 100644 --- a/app/src/main/java/com/droiddeck/launcher/input/KeyboardHost.kt +++ b/app/src/main/java/com/droiddeck/launcher/input/KeyboardHost.kt @@ -26,6 +26,8 @@ class KeyboardHost( var imeShowing = false private set var onImeChanged: ((Boolean) -> Unit)? = null + val hideMeansDismissal: Boolean + get() = Build.VERSION.SDK_INT < Build.VERSION_CODES.R || (shown && imeShowing) init { isFocusable = false 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 2d0006925f..590ef4fc08 100644 --- a/app/src/main/java/com/droiddeck/launcher/input/SecondScreenMode.kt +++ b/app/src/main/java/com/droiddeck/launcher/input/SecondScreenMode.kt @@ -40,6 +40,18 @@ enum class SecondScreenMode(val id: String, @StringRes val label: Int, val bindi data class SecondScreenDisplay(val id: Int, val label: String) object SecondScreenDisplays { + fun selection(selected: Int, available: List, gameRequested: Boolean): Int = + if (selected in available || gameRequested && selected >= 0) selected else available.firstOrNull() ?: -1 + + fun selection(selected: Int, available: List, gameRequested: Boolean, save: (Int) -> Unit): Int = + selection(selected, available, gameRequested).also { if (it != selected) save(it) } + + fun keyboardOnPrimary(gameRequested: Boolean, selected: Int, available: List, visible: Boolean = true, taken: (Int) -> Boolean): Boolean = + visible && gameRequested && selected >= 0 && (selected !in available || taken(selected)) + + fun routeKeyboard(steam: Boolean, enabled: Boolean, panel: Boolean, dock: Boolean, primaryFallback: Boolean): Boolean = + steam && enabled && (panel || dock || primaryFallback) + fun available(displayManager: DisplayManager, primaryDisplayId: Int = Display.DEFAULT_DISPLAY): List = displayManager.getDisplays(DisplayManager.DISPLAY_CATEGORY_PRESENTATION) .asSequence() 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 7584c5d4d2..dd737b1d3a 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/SessionOverlay.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/SessionOverlay.kt @@ -262,6 +262,7 @@ class DrawerActions( val secondScreenNone: Boolean = true, val gameOnBottom: Boolean = false, val gameSwapAvailable: Boolean = false, + val gameSwapBuiltIn: Boolean = true, val onGameOnBottom: (Boolean) -> Unit = {}, val dashboardAvailable: Boolean = false, val desktopAvailable: Boolean = false, @@ -1303,7 +1304,8 @@ private fun SecondScreenGroup(host: MenuHost, a: DrawerActions, track: (String) } if (a.gameSwapAvailable || a.gameOnBottom) SettingsGroup(stringResource(R.string.swap_game_screen_group)) { ChoiceRow(host, "game-screen", stringResource(R.string.swap_game_screen), null, - listOf(false to stringResource(R.string.swap_game_screen_top), true to stringResource(R.string.swap_game_screen_bottom)), + if (a.gameSwapBuiltIn) listOf(false to stringResource(R.string.swap_game_screen_top), true to stringResource(R.string.swap_game_screen_bottom)) + else listOf(false to stringResource(R.string.main_primary), true to stringResource(R.string.main_secondary)), a.gameOnBottom, chipModifier = track("game-screen"), onPick = a.onGameOnBottom) } } 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 c510dc72f3..7409d4558b 100644 --- a/app/src/test/java/com/droiddeck/launcher/input/DualScreenTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/input/DualScreenTest.kt @@ -29,6 +29,26 @@ class DualScreenTest { assertFalse(DualScreen.isBuiltIn(5, "AYN Thor")) } + @Test @Config(sdk = [34]) fun selectedInternalAndExternalDisplaysCanBeUsed() { + withDisplay(INTERNAL, "Bottom screen") { internal -> + assertEquals(internal.displayId, DualScreen.selectedSessionDisplay(context, displays, Display.DEFAULT_DISPLAY, internal.displayId)?.displayId) + } + withDisplay(EXTERNAL, "HDMI Screen") { external -> + assertEquals(external.displayId, DualScreen.selectedSessionDisplay(context, displays, Display.DEFAULT_DISPLAY, external.displayId)?.displayId) + SessionPrefs.setDualScreenSessionMode(context, DualScreen.MODE_OFF) + assertNull(DualScreen.selectedSessionDisplay(context, displays, Display.DEFAULT_DISPLAY, external.displayId)) + SessionPrefs.setDualScreenSessionMode(context, DualScreen.MODE_AUTO) + } + } + + @Test @Config(sdk = [34]) fun missingOrRemovedSelectedDisplaysCannotBeUsed() { + assertNull(DualScreen.selectedSessionDisplay(context, displays, Display.DEFAULT_DISPLAY, Display.INVALID_DISPLAY)) + val id = ShadowDisplayManager.addDisplay("w640dp-h480dp", EXTERNAL) + shadowOf(displays.getDisplay(id)).setFlags(Display.FLAG_PRESENTATION) + ShadowDisplayManager.removeDisplay(id) + assertNull(DualScreen.selectedSessionDisplay(context, displays, Display.DEFAULT_DISPLAY, id)) + } + @Test fun knownModelsCountWhenTheTypeIsHidden() { assertTrue(DualScreen.isBuiltIn(null, "Retroid Pocket Duo")) assertTrue(DualScreen.isBuiltIn(null, " AYN Thor ")) 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 9956f1aa6d..566a091c42 100644 --- a/app/src/test/java/com/droiddeck/launcher/input/SecondScreenModeTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/input/SecondScreenModeTest.kt @@ -1,9 +1,58 @@ package com.droiddeck.launcher.input import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue import org.junit.Test class SecondScreenModeTest { + @Test fun fallbackSelectionSurvivesRecreationAndRequestedDisplaySurvivesDisconnect() { + var saved = 2 + SecondScreenDisplays.selection(saved, listOf(3), false) { saved = it } + assertEquals(3, saved) + assertEquals(3, SecondScreenDisplays.selection(saved, listOf(3), true)) + SecondScreenDisplays.selection(saved, listOf(2), true) { saved = it } + assertEquals(3, saved) + } + + @Test fun keyboardFallsBackOnlyForADisconnectedRequestedDisplay() { + val taken: (Int) -> Boolean = { it == 2 } + val free: (Int) -> Boolean = { false } + assertTrue(SecondScreenDisplays.keyboardOnPrimary(true, 2, listOf(3), taken = free)) + assertTrue(SecondScreenDisplays.keyboardOnPrimary(true, 2, listOf(2, 3), taken = taken)) + assertFalse(SecondScreenDisplays.keyboardOnPrimary(true, 2, listOf(2, 3), taken = free)) + assertFalse(SecondScreenDisplays.keyboardOnPrimary(false, 2, listOf(3), taken = taken)) + assertFalse(SecondScreenDisplays.keyboardOnPrimary(true, -1, listOf(3), taken = taken)) + } + + @Test fun primaryFallbackRequiresVisibleActivity() { + for (available in listOf(emptyList(), listOf(2))) { + assertTrue(SecondScreenDisplays.keyboardOnPrimary(true, 2, available, true) { true }) + assertFalse(SecondScreenDisplays.keyboardOnPrimary(true, 2, available, false) { true }) + } + } + + @Test fun keyboardRouteIncludesOccupiedDisplayFallbackOnlyWhenEnabled() { + val fallback = SecondScreenDisplays.keyboardOnPrimary(true, 2, listOf(2)) { it == 2 } + assertTrue(fallback) + assertTrue(SecondScreenDisplays.routeKeyboard(true, true, false, false, fallback)) + assertFalse(SecondScreenDisplays.routeKeyboard(true, false, false, false, fallback)) + assertFalse(SecondScreenDisplays.routeKeyboard(false, true, false, false, fallback)) + assertFalse(SecondScreenDisplays.routeKeyboard(true, true, false, false, false)) + assertTrue(SecondScreenDisplays.routeKeyboard(true, true, true, false, false)) + assertTrue(SecondScreenDisplays.routeKeyboard(true, true, false, true, false)) + } + + @Test fun selectedGameDisplayIsNotReplacedWhenItDisconnects() { + assertEquals(2, SecondScreenDisplays.selection(2, listOf(3), true)) + assertEquals(2, SecondScreenDisplays.selection(2, emptyList(), true)) + assertEquals(2, SecondScreenDisplays.selection(2, listOf(3, 2), true)) + assertEquals(3, SecondScreenDisplays.selection(3, listOf(3), true)) + assertEquals(3, SecondScreenDisplays.selection(2, listOf(3), false)) + assertEquals(3, SecondScreenDisplays.selection(-1, listOf(3), true)) + 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)) diff --git a/app/src/test/java/com/droiddeck/launcher/input/SessionFieldKeyboardTest.kt b/app/src/test/java/com/droiddeck/launcher/input/SessionFieldKeyboardTest.kt new file mode 100644 index 0000000000..483c61f562 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/input/SessionFieldKeyboardTest.kt @@ -0,0 +1,169 @@ +package com.droiddeck.launcher.input + +import android.view.KeyEvent +import android.view.WindowInsets +import com.droiddeck.launcher.SessionActivity +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.Robolectric +import org.robolectric.RobolectricTestRunner +import org.robolectric.annotation.Config +import org.robolectric.util.ReflectionHelpers + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [28], manifest = Config.NONE) +class SessionFieldKeyboardTest { + private lateinit var activity: SessionActivity + private lateinit var keyboard: KeyboardHost + + @Before fun setUp() { + activity = Robolectric.buildActivity(SessionActivity::class.java).get() + keyboard = KeyboardHost(activity) + ReflectionHelpers.setField(activity, "keyboard", keyboard) + keyboard.onImeChanged = { visible -> + ReflectionHelpers.callInstanceMethod(activity, "onPrimaryImeChanged", + ReflectionHelpers.ClassParameter.from(Boolean::class.javaPrimitiveType, visible)) + } + } + + @Test fun guestDismissalClosesOnlyTheGuestOwnedKeyboard() { + openFieldKeyboard() + call("dismissFieldKeyboard") + assertFalse(keyboard.shown) + call("showPrimaryKeyboard") + call("dismissFieldKeyboard") + assertTrue(keyboard.shown) + } + + @Test fun pauseHideThenManualReopenSurvivesGuestDismissal() { + openFieldKeyboard() + call("hidePrimaryKeyboard") + assertFalse(keyboard.shown) + call("showPrimaryKeyboard") + call("dismissFieldKeyboard") + assertTrue(keyboard.shown) + openFieldKeyboard() + call("dismissFieldKeyboard") + assertFalse(keyboard.shown) + } + + @Test fun manualToggleAndPcKeyboardRelinquishGuestOwnership() { + openFieldKeyboard() + call("togglePrimaryKeyboard") + call("togglePrimaryKeyboard") + call("dismissFieldKeyboard") + assertTrue(keyboard.shown) + openFieldKeyboard() + call("togglePcKeyboard") + call("showPrimaryKeyboard") + call("dismissFieldKeyboard") + assertTrue(keyboard.shown) + } + + @Test fun pendingGuestRequestWaitsForFocusAndCanBeDismissed() { + ReflectionHelpers.callInstanceMethod(activity, "setGameOnBottom", ReflectionHelpers.ClassParameter.from(Boolean::class.javaPrimitiveType, true)) + ReflectionHelpers.callInstanceMethod(activity, "setSelectedSecondScreenDisplay", ReflectionHelpers.ClassParameter.from(Int::class.javaPrimitiveType, 2)) + ReflectionHelpers.callInstanceMethod(activity, "setResumed", ReflectionHelpers.ClassParameter.from(Boolean::class.javaPrimitiveType, true)) + call("openBottomKeyboard") + ReflectionHelpers.callInstanceMethod(activity, "retryFieldKeyboard", ReflectionHelpers.ClassParameter.from(Boolean::class.javaPrimitiveType, false)) + assertFalse(keyboard.shown) + call("dismissFieldKeyboard") + ReflectionHelpers.callInstanceMethod(activity, "retryFieldKeyboard", ReflectionHelpers.ClassParameter.from(Boolean::class.javaPrimitiveType, true)) + assertFalse(keyboard.shown) + call("openBottomKeyboard") + ReflectionHelpers.callInstanceMethod(activity, "retryFieldKeyboard", ReflectionHelpers.ClassParameter.from(Boolean::class.javaPrimitiveType, true)) + assertTrue(keyboard.shown) + call("dismissFieldKeyboard") + assertFalse(keyboard.shown) + } + + @Config(sdk = [33]) + @Test fun staleHiddenEventFromEarlierHideKeepsNewGuestOwnership() { + call("showPrimaryKeyboard") + ime(true) + call("hidePrimaryKeyboard") + requestFieldKeyboard() + ime(false) + assertTrue(owned()) + ime(true) + call("dismissFieldKeyboard") + assertFalse(keyboard.shown) + } + + @Config(sdk = [33]) + @Test fun hiddenEventAfterGuestKeyboardShowsClearsOwnership() { + requestFieldKeyboard() + ime(true) + ime(false) + assertFalse(owned()) + call("showPrimaryKeyboard") + call("dismissFieldKeyboard") + assertTrue(keyboard.shown) + } + + @Config(sdk = [33]) + @Test fun guestRequestWhileKeyboardAlreadyVisibleClearsOnRealDismissal() { + call("showPrimaryKeyboard") + ime(true) + requestFieldKeyboard() + assertTrue(owned()) + ime(false) + assertFalse(owned()) + } + + @Test fun backDismissalWithoutImeInsetsClearsOwnership() { + requestFieldKeyboard() + assertTrue(owned()) + val t = System.currentTimeMillis() + keyboard.onKeyPreIme(KeyEvent.KEYCODE_BACK, KeyEvent(t, t, KeyEvent.ACTION_UP, KeyEvent.KEYCODE_BACK, 0)) + assertFalse(keyboard.shown) + assertFalse(owned()) + } + + @Test fun focusReturnSkipsPrimaryKeyboardWhenDestinationNoLongerPrimary() { + setFlag("setGameOnBottom", true) + selectDisplay(2) + setFlag("setResumed", true) + call("openBottomKeyboard") + retry(false) + setFlag("setGameOnBottom", false) + retry(true) + assertFalse(keyboard.shown) + assertFalse(owned()) + assertFalse(ReflectionHelpers.getField(activity, "pendingFieldKeyboard")) + } + + private fun requestFieldKeyboard() { + setFlag("setGameOnBottom", true) + selectDisplay(2) + setFlag("setResumed", true) + call("openBottomKeyboard") + retry(true) + assertTrue(keyboard.shown) + } + + private fun ime(visible: Boolean) { + keyboard.dispatchApplyWindowInsets(WindowInsets.Builder().setVisible(WindowInsets.Type.ime(), visible).build()) + } + + private fun owned() = ReflectionHelpers.getField(activity, "fieldKeyboardOnPrimary") + + private fun selectDisplay(id: Int) = ReflectionHelpers.callInstanceMethod(activity, "setSelectedSecondScreenDisplay", + ReflectionHelpers.ClassParameter.from(Int::class.javaPrimitiveType, id)) + + private fun retry(focus: Boolean) = ReflectionHelpers.callInstanceMethod(activity, "retryFieldKeyboard", + ReflectionHelpers.ClassParameter.from(Boolean::class.javaPrimitiveType, focus)) + + private fun setFlag(name: String, value: Boolean) = ReflectionHelpers.callInstanceMethod(activity, name, + ReflectionHelpers.ClassParameter.from(Boolean::class.javaPrimitiveType, value)) + + private fun openFieldKeyboard() { + ReflectionHelpers.setField(activity, "fieldKeyboardOnPrimary", true) + keyboard.show() + } + + private fun call(name: String) = ReflectionHelpers.callInstanceMethod(activity, name) +}