From fa4a54f64a6aa6646e29771258cdc1f1442070c3 Mon Sep 17 00:00:00 2001 From: Kurt Himebauch <136133082+xXJSONDeruloXx@users.noreply.github.com> Date: Fri, 30 Oct 2026 14:09:44 -0400 Subject: [PATCH 1/5] Default game library to vertical covers (#1857) --- app/src/main/java/com/droiddeck/launcher/FrontEndActivity.kt | 2 +- .../main/java/com/droiddeck/launcher/session/SessionPrefs.kt | 5 +++-- .../main/java/com/droiddeck/launcher/ui/FrontEndScreen.kt | 2 +- 3 files changed, 5 insertions(+), 4 deletions(-) diff --git a/app/src/main/java/com/droiddeck/launcher/FrontEndActivity.kt b/app/src/main/java/com/droiddeck/launcher/FrontEndActivity.kt index 3c3a5fc79d..d67660460a 100644 --- a/app/src/main/java/com/droiddeck/launcher/FrontEndActivity.kt +++ b/app/src/main/java/com/droiddeck/launcher/FrontEndActivity.kt @@ -195,7 +195,7 @@ class FrontEndActivity : ComponentActivity() { private var navRequest by mutableStateOf(null) private var storesShowMature by mutableStateOf(false) private var storesSort by mutableStateOf(SessionPrefs.STORES_SORTS.first()) - private var storesView by mutableStateOf(SessionPrefs.STORES_VIEWS.first()) + private var storesView by mutableStateOf(SessionPrefs.DEFAULT_STORES_VIEW) private var mic by mutableStateOf(false) private var wifiDiscovery by mutableStateOf(false) private var wifiDiscoveryPermission by mutableStateOf(false) diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt index 306375cd80..a0aae83d7f 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt @@ -147,10 +147,10 @@ object SessionPrefs { } fun storesView(context: Context): String = - prefs(context).getString("storesView", null)?.takeIf { it in STORES_VIEWS } ?: STORES_VIEWS.first() + prefs(context).getString("storesView", null)?.takeIf { it in STORES_VIEWS } ?: DEFAULT_STORES_VIEW fun setStoresView(context: Context, view: String) { - prefs(context).edit().putString("storesView", if (view in STORES_VIEWS) view else STORES_VIEWS.first()).apply() + prefs(context).edit().putString("storesView", if (view in STORES_VIEWS) view else DEFAULT_STORES_VIEW).apply() } fun libraryCardLevel(context: Context): Int = prefs(context).getInt("libraryCardLevel", 2) @@ -199,6 +199,7 @@ object SessionPrefs { val STORES_SORTS = listOf("lastPlayed", "recentlyInstalled", "titleAsc", "titleDesc", "sizeDesc", "sizeAsc", "releaseDateDesc") val STORES_VIEWS = listOf("cards", "capsules", "list") + const val DEFAULT_STORES_VIEW = "capsules" fun storesInstallTarget(context: Context): String = prefs(context).getString("storesInstallTarget", "") ?: "" diff --git a/app/src/main/java/com/droiddeck/launcher/ui/FrontEndScreen.kt b/app/src/main/java/com/droiddeck/launcher/ui/FrontEndScreen.kt index eec57cfb9f..6360336da8 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/FrontEndScreen.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/FrontEndScreen.kt @@ -166,7 +166,7 @@ class FrontEndState( val sgdbUserKey: Boolean = false, val storesShowMature: Boolean = false, val storesSort: String = SessionPrefs.STORES_SORTS.first(), - val storesView: String = SessionPrefs.STORES_VIEWS.first(), + val storesView: String = SessionPrefs.DEFAULT_STORES_VIEW, val storeDownloadsActive: Int = 0, val updates: UpdatesState = UpdatesState(), ) From c8c5e22a34f26741414d9a3b725303c6967b0fd3 Mon Sep 17 00:00:00 2001 From: Kurt Himebauch <136133082+xXJSONDeruloXx@users.noreply.github.com> Date: Fri, 30 Oct 2026 14:17:45 -0400 Subject: [PATCH 2/5] fix: new Steam installs start with shader pre-caching off (#1861) --- .github/workflows/build.yml | 2 +- .../launcher/session/SessionPrefs.kt | 13 +++++-- .../session/ShaderPrecachePrefsTest.kt | 35 +++++++++++++++++++ 3 files changed, 46 insertions(+), 4 deletions(-) create mode 100644 app/src/test/java/com/droiddeck/launcher/session/ShaderPrecachePrefsTest.kt diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 8fee8a691c..fc5fe53c22 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -760,7 +760,7 @@ jobs: checks: name: Compile and test APK needs: [build, python-tests] - if: ${{ always() && (github.event_name != 'pull_request' || !github.event.pull_request.draft) }} + if: ${{ !cancelled() && (github.event_name != 'pull_request' || !github.event.pull_request.draft) }} runs-on: ubuntu-24.04 timeout-minutes: 5 steps: diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt index a0aae83d7f..15f366a107 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt @@ -442,11 +442,15 @@ object SessionPrefs { /** * Shader pre-caching as the launcher last set it, until a session reports it written into the - * client's config.vdf; after that the client's own toggle is the user's again. + * client's config.vdf; after that the client's own toggle is the user's again. A client that + * has never written a config.vdf starts with pre-caching off. */ fun pendingShaderPrecache(context: Context): Boolean? { val prefs = prefs(context) - if (!prefs.contains("shaderPrecache")) return null + if (!prefs.contains("shaderPrecache")) { + if (steamConfig(context).exists()) return null + prefs.edit().putBoolean("shaderPrecache", false).apply() + } val on = prefs.getBoolean("shaderPrecache", true) val applied = shaderPrecacheApplied(context) val written = runCatching { applied.readText().trim() }.getOrNull() ?: return on @@ -461,9 +465,12 @@ object SessionPrefs { prefs(context).edit().putBoolean("shaderPrecache", on).apply() } + private fun steamConfig(context: Context) = + java.io.File(steamRoot(context, steamClientArch(context)), "config/config.vdf") + fun shaderPrecache(context: Context): Boolean = pendingShaderPrecache(context) ?: runCatching { com.droiddeck.launcher.storage.SteamStorage.shaderPrecache( - java.io.File(steamRoot(context, steamClientArch(context)), "config/config.vdf").readText()) }.getOrDefault(true) + steamConfig(context).readText()) }.getOrDefault(true) fun stretch16x9(context: Context): Boolean = prefs(context).getBoolean("stretch16x9", false) diff --git a/app/src/test/java/com/droiddeck/launcher/session/ShaderPrecachePrefsTest.kt b/app/src/test/java/com/droiddeck/launcher/session/ShaderPrecachePrefsTest.kt new file mode 100644 index 0000000000..b4d8d81f83 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/session/ShaderPrecachePrefsTest.kt @@ -0,0 +1,35 @@ +package com.droiddeck.launcher.session + +import android.content.Context +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNull +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.RuntimeEnvironment +import org.robolectric.annotation.Config + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [28], manifest = Config.NONE) +class ShaderPrecachePrefsTest { + private val context: Context get() = RuntimeEnvironment.getApplication() + + @Before fun reset() { + context.getSharedPreferences("session", Context.MODE_PRIVATE).edit().clear().commit() + SessionPrefs.steamRoot(context, SessionPrefs.steamClientArch(context)).deleteRecursively() + } + + @Test fun clientWithoutConfigStartsWithPrecachingOff() { + assertEquals(false, SessionPrefs.pendingShaderPrecache(context)) + assertEquals(false, SessionPrefs.shaderPrecache(context)) + } + + @Test fun existingConfigKeepsTheClientsChoice() { + val config = SessionPrefs.steamRoot(context, SessionPrefs.steamClientArch(context)).resolve("config/config.vdf") + config.parentFile!!.mkdirs() + config.writeText("\"InstallConfigStore\" {}") + assertNull(SessionPrefs.pendingShaderPrecache(context)) + assertEquals(true, SessionPrefs.shaderPrecache(context)) + } +} From 7c49eef79f8b622645915ffc2833ee83b4570b25 Mon Sep 17 00:00:00 2001 From: MaxsTechReview Date: Fri, 30 Oct 2026 14:32:34 -0400 Subject: [PATCH 3/5] fix(dual-screen): keep the bottom-screen controls up while a game loads (#1840) * fix(dual-screen): keep the bottom-screen controls up while a game loads The session opened its bottom-screen trackpad only at the game's first frame. The launcher's bottom menu closes when a game starts, so on dual-screen handhelds the bottom screen showed whatever Android app was behind it for the whole load, which is long for Xbox games while Xodus prepares them. The controls now open when the session starts. Devices without a built-in second screen, and players who turned the in-game controls off, are unchanged. * fix(dual-screen): pick the bottom-screen panel again once the session's controller is known Opening the bottom-screen controls at session start can run before SessionService has prepared the Steam Deck pad, while SessionState.deckPad is still false, so the trackpad could be chosen where the Deck controls belong. That early choice is now provisional: at the game's first frame it switches to the panel the remembered choice and the real deckPad give, unless the player has already picked one. * fix(dual-screen): keep the loading-time panel choice through PiP, background and new sessions * fix(dual-screen): retry a terminal panel opened before it was ready and keep a manual close made during loading --- .../com/droiddeck/launcher/SessionActivity.kt | 28 ++++++++-- .../launcher/session/SessionService.kt | 1 - .../launcher/session/SessionState.kt | 1 + .../launcher/ui/SecondScreenPresentation.kt | 4 ++ .../launcher/ui/SessionSecondScreenTest.kt | 51 +++++++++++++++++++ 5 files changed, 81 insertions(+), 4 deletions(-) diff --git a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt index 067cd71399..efe4662878 100644 --- a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt +++ b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt @@ -464,6 +464,9 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { private var secondScreenDisplays by mutableStateOf>(emptyList()) private var selectedSecondScreenDisplay by mutableStateOf(SessionState.secondScreenDisplay) private var started = false + private var dualControlsProvisional: Boolean + get() = SessionState.secondScreenProvisional + set(value) { SessionState.secondScreenProvisional = value } private var sessionActivityDisplayId = Display.DEFAULT_DISPLAY private lateinit var displayManager: DisplayManager private var secondScreenPresentation: SecondScreenPresentation? = null @@ -580,6 +583,8 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { SessionState.steamUi = intent.getStringExtra(SessionService.EXTRA_STEAM_UI) SessionState.steamUrl = intent.getStringExtra(SessionService.EXTRA_STEAM_URL) SessionState.steamVr = intent.getBooleanExtra(EXTRA_STEAMVR, false) + SessionState.secondScreenAutoOpened = false + SessionState.secondScreenProvisional = false } else if (intent.getBooleanExtra(EXTRA_STEAMVR, false) && SessionState.mode == SessionService.MODE_STEAM) { SessionState.steamVr = true } @@ -3030,6 +3035,15 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { SessionState.secondScreenAutoOpened = true selectedSecondScreenDisplay = target.displayId selectSecondScreenMode(SecondScreenMode.opening(SessionPrefs.secondScreenPanel(this), SessionState.deckPad)) + dualControlsProvisional = ::loading.isInitialized && loading.visible + } + + private fun settleDualScreenControls() { + if (!dualControlsProvisional || pipUi || !started || (::loading.isInitialized && loading.visible)) return + dualControlsProvisional = false + if (secondScreenMode == SecondScreenMode.NONE) return + val wanted = SecondScreenMode.opening(SessionPrefs.secondScreenPanel(this), SessionState.deckPad) + if (wanted != secondScreenMode) selectSecondScreenMode(wanted) else secondScreenPresentation?.retryTerminal() } private fun selectSecondScreenDisplay(displayId: Int) { @@ -3040,6 +3054,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { } private fun selectSecondScreenMode(mode: SecondScreenMode) { + dualControlsProvisional = false if (mode == SecondScreenMode.NONE) { closeSecondScreen(reset = true) return @@ -3818,7 +3833,10 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON) updateOnScreenControls() if (resumed) { sessionClipboard.start(); updatePadMotion() } - if (started) refreshSecondScreenDisplays() + if (started) { + settleDualScreenControls() + refreshSecondScreenDisplays() + } if (CompositorHost.isStarted) applyFrameGen() } } @@ -3854,9 +3872,10 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { for (name in arrayOf("peak_refresh_rate", "min_refresh_rate")) { contentResolver.registerContentObserver(android.provider.Settings.System.getUriFor(name), false, refreshSettingObserver) } + settleDualScreenControls() refreshSecondScreenDisplays() if (secondScreenMode != SecondScreenMode.NONE && secondScreenPresentation == null) showSecondScreen(secondScreenMode) - else if (::loading.isInitialized && !loading.visible) openDualScreenControls() + else openDualScreenControls() startedScreens++ SessionService.setActivityVisible(this, true, sessionActivityDisplayId) Glasses.rescan() @@ -4384,7 +4403,10 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { loading.visible = false hud.start() memoryHud.start() - if (started) openDualScreenControls() + if (started) { + settleDualScreenControls() + openDualScreenControls() + } } } diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt index 892fc802ae..09f16f6423 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt @@ -543,7 +543,6 @@ class SessionService : Service() { val fakeInputDir = File(sessionRoot, "dev/input").apply { mkdirs() } val controllersOn = !File(Environment.getExternalStorageDirectory(), NO_PAD_SWITCH).exists() SessionState.deckPad = false - SessionState.secondScreenAutoOpened = false deckBinds = emptyList() inputSysfs = null if (controllersOn) { diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionState.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionState.kt index 088c8b7d00..0d19d49bc0 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionState.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionState.kt @@ -92,6 +92,7 @@ object SessionState { @Volatile var secondScreenMode = com.droiddeck.launcher.input.SecondScreenMode.NONE @Volatile var secondScreenDisplay = -1 @Volatile var secondScreenAutoOpened = false + @Volatile var secondScreenProvisional = false @Volatile var mode = "steam" diff --git a/app/src/main/java/com/droiddeck/launcher/ui/SecondScreenPresentation.kt b/app/src/main/java/com/droiddeck/launcher/ui/SecondScreenPresentation.kt index 2138a31a85..3caad9f771 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/SecondScreenPresentation.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/SecondScreenPresentation.kt @@ -141,6 +141,10 @@ class SecondScreenPresentation( if (created) renderMode() } + fun retryTerminal() { + if (created && isShowing && currentMode == SecondScreenMode.TERMINAL && terminalSession == null) renderMode() + } + val showsKeyboard: Boolean get() = isShowing && !menuShown && currentMode == SecondScreenMode.KEYBOARD_TRACKPAD val showsControls: Boolean get() = isShowing && currentMode != SecondScreenMode.NONE diff --git a/app/src/test/java/com/droiddeck/launcher/ui/SessionSecondScreenTest.kt b/app/src/test/java/com/droiddeck/launcher/ui/SessionSecondScreenTest.kt index a09ee55aac..213ab8750b 100644 --- a/app/src/test/java/com/droiddeck/launcher/ui/SessionSecondScreenTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/ui/SessionSecondScreenTest.kt @@ -22,6 +22,7 @@ import com.droiddeck.launcher.session.SessionService import com.droiddeck.launcher.session.SessionState import org.junit.After import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse import org.junit.Assert.assertTrue import org.junit.Before import org.junit.Rule @@ -72,6 +73,56 @@ class SessionSecondScreenTest { compose.onNodeWithText(context.getString(R.string.second_mode_keyboard_trackpad)).assertDoesNotExist() } + @Test fun provisionalBottomScreenPanelSettlesOnlyOnceTheSessionIsInFront() { + SessionState.mode = SessionService.MODE_STEAM + val previousMode = SessionState.secondScreenMode + val previousProvisional = SessionState.secondScreenProvisional + SessionState.secondScreenMode = SecondScreenMode.NONE + try { + val activity = Robolectric.buildActivity(SessionActivity::class.java).get() + val pip: MutableState = ReflectionHelpers.getField(activity, "pipUi\$delegate") + fun settle() = ReflectionHelpers.callInstanceMethod(activity, "settleDualScreenControls") + SessionState.secondScreenProvisional = true + ReflectionHelpers.setField(activity, "started", true) + pip.value = true + settle() + assertTrue(SessionState.secondScreenProvisional) + pip.value = false + ReflectionHelpers.setField(activity, "started", false) + settle() + assertTrue(SessionState.secondScreenProvisional) + ReflectionHelpers.setField(activity, "started", true) + settle() + assertFalse(SessionState.secondScreenProvisional) + } finally { + SessionState.secondScreenMode = previousMode + SessionState.secondScreenProvisional = previousProvisional + } + } + + @Test fun terminalOpenedBeforeItWasReadyIsRetriedButOtherPanelsAreLeftAlone() { + SessionState.mode = SessionService.MODE_STEAM + val activity = Robolectric.buildActivity(SessionActivity::class.java).get() + val display = activity.getSystemService(DisplayManager::class.java).getDisplay(Display.DEFAULT_DISPLAY) + val panel = SecondScreenPresentation(activity, display, { _, _, _, _ -> }, { _, _ -> }, {}, {}, {}, {}) + try { + panel.show() + panel.showMode(SecondScreenMode.KEYBOARD_TRACKPAD) + val root = panel.window!!.decorView + val trackpad = descendants(root).toList() + panel.retryTerminal() + assertEquals(trackpad, descendants(root).toList()) + panel.showMode(SecondScreenMode.TERMINAL) + val notReady = context.getString(R.string.second_terminal_not_ready) + val before = descendants(root).filter { (it as? TextView)?.text == notReady }.single() + panel.retryTerminal() + val after = descendants(root).filter { (it as? TextView)?.text == notReady }.single() + assertTrue(before !== after) + } finally { + panel.closeControls() + } + } + @Test fun desktopTrackpadOmitsSteamShortcuts() = checkShortcuts(steam = false) @Test fun steamTrackpadKeepsWorkingSteamShortcuts() = checkShortcuts(steam = true) From a8cebd024ba1e1a85e350c38ad1b33375094ddc0 Mon Sep 17 00:00:00 2001 From: MaxsTechReview Date: Fri, 30 Oct 2026 15:20:30 -0400 Subject: [PATCH 4/5] fix(ci): required-check test matches the gate's !cancelled() condition (#1864) fix(ci): the required-check test expects the gate's !cancelled() condition --- tools/tests/test_ci_checks.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/tests/test_ci_checks.py b/tools/tests/test_ci_checks.py index b7c29fceba..52c1607aad 100644 --- a/tools/tests/test_ci_checks.py +++ b/tools/tests/test_ci_checks.py @@ -82,7 +82,7 @@ class CiChecksTest(unittest.TestCase): gate = jobs['checks'] self.assertEqual(gate['name'], 'Compile and test APK') self.assertEqual(set(gate['needs']), {'build', 'python-tests'}) - self.assertIn('always()', gate['if']) + self.assertIn('!cancelled()', gate['if']) for build, python in itertools.product(('success', 'failure', 'cancelled', 'skipped'), repeat=2): with self.subTest(build=build, python=python): result = subprocess.run( From a5b035b247184c90d687d93a8da8efdbeac5fc0a Mon Sep 17 00:00:00 2001 From: Kurt Himebauch <136133082+xXJSONDeruloXx@users.noreply.github.com> Date: Fri, 30 Oct 2026 15:25:28 -0400 Subject: [PATCH 5/5] test: the required-status gate expects the skip-on-superseded condition (#1866)