sessions: end same-display session when the launcher UI returns to foreground

Returning to Argosy left the play session alive for a 15s UsageStats grace
that nothing re-checked: gamepad input was swallowed by the dead-game
forward branch, the new task-removed release was blocked by the stale
flag, and the bottom screen kept the in-game panel until a second resume.

cleanupStaleSession now ends any session on the launcher's own display on
every resume and clears SessionStateStore synchronously so the companion
flips immediately; only cross-display sessions (swapped roles, per-game
display target) survive, which also removes the UsageStats dependency and
the swapped-mode resume clearing bug. Input dispatch defers to the
emulator only when it runs on a different display. onTaskRemoved checks
the in-memory session via new hasLiveSession instead of the prefs flag
that lags behind save sync. The companion respawn check no longer honors
a persisted session when the process restarted, it is an orphan by
definition. requiresEmulatorKill emulators get force-stopped at launch
when no session is tracked since the lingering-session kill trigger is
gone.

Author: tmgast

app/src/main/kotlin/com/nendo/argosy/DualScreenManager.kt

@@ -128,6 +128,9 @@ class DualScreenManager(
         com.nendo.argosy.util.SecondaryHomeComponent.setEnabled(appContext, enabled)
     }
 
+    /** Live in-memory session check; unlike SessionStateStore.hasActiveSession this flips false the moment session teardown begins, not after save sync completes. */
+    fun hasLiveSession(): Boolean = playSessionTracker.activeSession.value != null
+
     fun teardownCompanion() {
         stopStartupGuard()
         companionLaunchJob?.cancel()

app/src/main/kotlin/com/nendo/argosy/MainActivity.kt

@@ -49,7 +49,6 @@ import android.view.Display
 import com.nendo.argosy.hardware.SecondaryHomeActivity
 import com.nendo.argosy.util.DisplayAffinityHelper
 import com.nendo.argosy.util.DisplayRoleResolver
-import com.nendo.argosy.util.PermissionHelper
 import dagger.hilt.android.AndroidEntryPoint
 import com.nendo.argosy.util.SafeCoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -86,7 +85,6 @@ class MainActivity : ComponentActivity() {
     @Inject lateinit var ambientLedManager: AmbientLedManager
     @Inject lateinit var screenCaptureManager: ScreenCaptureManager
     @Inject lateinit var displayAffinityHelper: DisplayAffinityHelper
-    @Inject lateinit var permissionHelper: PermissionHelper
     @Inject lateinit var gameActionsDelegate: GameActionsDelegate
     @Inject lateinit var gameLaunchDelegate: GameLaunchDelegate
     @Inject lateinit var saveCacheManager: SaveCacheManager
@@ -417,7 +415,7 @@ class MainActivity : ComponentActivity() {
             ) return true
         }
 
-        if (dualScreenManager.swappedIsGameActive.value && !isOverlayFocused) {
+        if (dualScreenManager.swappedIsGameActive.value && !isOverlayFocused && isGameOnOtherDisplay()) {
             val emulatorDispatcher = dualScreenManager.emulatorKeyDispatcher
             if (emulatorDispatcher != null) {
                 Log.d(TAG, "dispatchKeyEvent: FORWARDING key=${event.keyCode} to emulator")
@@ -488,7 +486,7 @@ class MainActivity : ComponentActivity() {
         triggerAxisKeyEmitter.emit(event).forEach { dispatchKeyEvent(it) }
 
         if (!dualScreenManager.claimInput(event)) return true
-        if (dualScreenManager.swappedIsGameActive.value && !isOverlayFocused) {
+        if (dualScreenManager.swappedIsGameActive.value && !isOverlayFocused && isGameOnOtherDisplay()) {
             val emulatorDispatcher = dualScreenManager.emulatorMotionDispatcher
             if (emulatorDispatcher != null) {
                 return emulatorDispatcher(event)
@@ -587,6 +585,13 @@ class MainActivity : ComponentActivity() {
 
     // --- Private Helpers ---
 
+    /** True only when a session's emulator runs on a different display than this activity; a same-display session cannot have focus while we do, so input must never be deferred to it. */
+    private fun isGameOnOtherDisplay(): Boolean {
+        val emulatorDisplay = dualScreenManager.emulatorDisplayId ?: return false
+        val ownDisplay = window.decorView.display?.displayId ?: return false
+        return emulatorDisplay != ownDisplay
+    }
+
     /** Relinks companion input forwarding when input arrives on home but the link is stale (companion marked inactive or overlay focus latched) after a game, sleep/wake, or a foreground app yielding the secondary display. */
     private fun reassertCompanionForwarding() {
         if (!::dualScreenManager.isInitialized) return
@@ -601,13 +606,6 @@ class MainActivity : ComponentActivity() {
         }
     }
 
-    /**
-     * Best-effort housekeeping when we come back to the launcher: if a persisted
-     * session exists but the emulator is no longer in the foreground, clear it so
-     * stale state doesn't linger. Does not resume or yield to the emulator -- that
-     * path was too eager and occasionally pulled the user into a phantom session
-     * on cold start.
-     */
     /**
      * Re-checks localPath for every downloaded game whenever the user returns to
      * the launcher. Catches manual deletions performed outside the app (e.g. via
@@ -621,17 +619,25 @@ class MainActivity : ComponentActivity() {
         }
     }
 
+    /**
+     * The launcher UI returning to the foreground means the session on this display
+     * is over: end it and restore the companion immediately. Only a session running
+     * on a different display (swapped roles / per-game display target) survives,
+     * since the game and the launcher UI legitimately coexist there.
+     */
     private fun cleanupStaleSession() {
         activityScope.launch {
             if (!::dualScreenManager.isInitialized) return@launch
             if (dualScreenManager.isLaunchingGame) return@launch
-            if (dualScreenManager.emulatorDisplayId != null) {
-                val emulatorPkg = sessionStateStore.getEmulatorPackage() ?: return@launch
-                if (permissionHelper.isPackageInForeground(this@MainActivity, emulatorPkg, 15_000)) return@launch
-            }
-            if (preferencesRepository.getPersistedSession() == null) return@launch
+            val emulatorDisplay = dualScreenManager.emulatorDisplayId
+            val ownDisplay = window.decorView.display?.displayId
+            if (emulatorDisplay != null && ownDisplay != null && emulatorDisplay != ownDisplay) return@launch
+            if (playSessionTracker.activeSession.value == null &&
+                preferencesRepository.getPersistedSession() == null
+            ) return@launch
 
             dualScreenManager.emulatorDisplayId = null
+            sessionStateStore.clearSession()
             playSessionTracker.endSessionInBackground()
             dualScreenManager.broadcastSessionCleared()
             if (displayAffinityHelper.hasSecondaryDisplay) {

app/src/main/kotlin/com/nendo/argosy/hardware/CompanionGuardService.kt

@@ -68,10 +68,13 @@ class CompanionGuardService : Service() {
         super.onTaskRemoved(rootIntent)
         if (rootIntent?.component?.className != MainActivity::class.java.name) return
         if (SecondaryHomeComponent.isDefaultHome(this)) return
-        if (SessionStateStore(applicationContext).hasActiveSession()) return
+        val dsm = DualScreenManagerHolder.instance
+        val sessionLive = dsm?.hasLiveSession()
+            ?: SessionStateStore(applicationContext).hasActiveSession()
+        if (sessionLive) return
         Log.i(TAG, "Main task removed while not default home, releasing secondary display")
         SecondaryHomeComponent.setEnabled(this, false)
-        DualScreenManagerHolder.instance?.teardownCompanion()
+        dsm?.teardownCompanion()
         stopSelf()
     }
 

app/src/main/kotlin/com/nendo/argosy/hardware/SecondaryHomeActivity.kt

@@ -120,9 +120,7 @@ class SecondaryHomeActivity :
         if (existing != null) {
             dsm = existing
             initializeCompanion()
-        } else if (!com.nendo.argosy.util.SecondaryHomeComponent.isDefaultHome(this) &&
-            !SessionStateStore(applicationContext).hasActiveSession()
-        ) {
+        } else if (!com.nendo.argosy.util.SecondaryHomeComponent.isDefaultHome(this)) {
             android.util.Log.i("SecondaryHome", "Respawned without a running Argosy and not default home, releasing secondary display")
             com.nendo.argosy.util.SecondaryHomeComponent.setEnabled(this, false)
             CompanionGuardService.stop(this)

app/src/main/kotlin/com/nendo/argosy/ui/screens/common/GameLaunchDelegate.kt

@@ -237,6 +237,13 @@ class GameLaunchDelegate @Inject constructor(
 
                 val emulatorPackage = emulatorResolver.getEmulatorPackageForGame(gameId, game.platformId, game.platformSlug)
                 val emulatorId = emulatorPackage?.let { emulatorResolver.resolveEmulatorId(it) }
+                if (activeSession == null && emulatorPackage != null && emulatorId != null &&
+                    EmulatorRegistry.getById(emulatorId)?.launchConfig?.requiresEmulatorKill == true
+                ) {
+                    android.util.Log.d("GameLaunchDelegate", "Force-stopping $emulatorPackage before launch (requiresEmulatorKill, no tracked session)")
+                    gameLauncher.forceStopEmulator(emulatorPackage)
+                    delay(EMULATOR_KILL_DELAY_MS)
+                }
                 val prefs = preferencesRepository.preferences.first()
                 val canSync = resolvedVariantId == null && emulatorId != null && SavePathRegistry.canSyncWithSettings(
                     emulatorId,