fix(dual-screen): allow game swap to external second screens (#2350)

* fix(dual-screen): allow game swap to external second screens

* fix(dual-screen): name external screens primary and secondary in the game screen choice

* Keep the selected game screen in step with display changes and session mode

* Refresh the game output when the screen is picked automatically

* Keep the game screen when controls open automatically

* Keep the external game screen across restarts and show the controls on the primary screen

* fix(dual-screen): preserve selected game display

* fix(dual-screen): retain fallback selection and keyboard access

* fix(input): clear field keyboard ownership on transitions

* fix(dual-screen): route keyboard when selected display is occupied

* fix(dual-screen): enable keyboard fallback routing

* fix(dual-screen): defer keyboard requests until focus returns

* fix(dual-screen): recheck keyboard destination on focus return and ignore stale hide events

* fix(dual-screen): end guest keyboard ownership on real dismissals
This commit is contained in:
MaxsTechReview authored and GitHub committed 2026-11-17 11:22:33 -05:00
1 parent 913cb85c92
commit 2ff890f0ec
8 files changed
+380 -24

No files matched your search

@@ -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 "))
@@ -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))
@@ -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<Any?>(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<Any?>(activity, "setGameOnBottom", ReflectionHelpers.ClassParameter.from(Boolean::class.javaPrimitiveType, true))
ReflectionHelpers.callInstanceMethod<Any?>(activity, "setSelectedSecondScreenDisplay", ReflectionHelpers.ClassParameter.from(Int::class.javaPrimitiveType, 2))
ReflectionHelpers.callInstanceMethod<Any?>(activity, "setResumed", ReflectionHelpers.ClassParameter.from(Boolean::class.javaPrimitiveType, true))
call("openBottomKeyboard")
ReflectionHelpers.callInstanceMethod<Any?>(activity, "retryFieldKeyboard", ReflectionHelpers.ClassParameter.from(Boolean::class.javaPrimitiveType, false))
assertFalse(keyboard.shown)
call("dismissFieldKeyboard")
ReflectionHelpers.callInstanceMethod<Any?>(activity, "retryFieldKeyboard", ReflectionHelpers.ClassParameter.from(Boolean::class.javaPrimitiveType, true))
assertFalse(keyboard.shown)
call("openBottomKeyboard")
ReflectionHelpers.callInstanceMethod<Any?>(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<Boolean>(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<Boolean>(activity, "fieldKeyboardOnPrimary")
private fun selectDisplay(id: Int) = ReflectionHelpers.callInstanceMethod<Any?>(activity, "setSelectedSecondScreenDisplay",
ReflectionHelpers.ClassParameter.from(Int::class.javaPrimitiveType, id))
private fun retry(focus: Boolean) = ReflectionHelpers.callInstanceMethod<Any?>(activity, "retryFieldKeyboard",
ReflectionHelpers.ClassParameter.from(Boolean::class.javaPrimitiveType, focus))
private fun setFlag(name: String, value: Boolean) = ReflectionHelpers.callInstanceMethod<Any?>(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<Any?>(activity, name)
}