Feat: Add per game screens effects (#2472)

* Add per-game screen effects profiles

* Fix stale screen effects callbacks

* Fix per-game screen effects profile handling

* Fix screen effects restoration on cancelled launch

* Allow nullable screen effects profile in drawer

* Fix per-game screen effects initialization

* Fix per-game screen effects tracking

* Tighten Steam process detection tests

* Fix per-game screen effects profile resolution

* Fix per-game screen effects profile selection

* Fix screen effects cleanup on game exit

* Fix Steam closing between game launches

* Update SessionService.kt comments removed

* Fix screen effects profile synchronization

* Fix saving screen effects without profile

* Prevent stale screen effects overwriting active profile

* Refresh screen effects on session resume

* Update SessionActivity.kt ( used rabbit suggested fixed )

* Fix Steam game exit detection and return

* Clear screen effects profile while awaiting Steam exit

* Preserve screen effects profile when game restarts

* Refactor screen effects sync and fix game exit handling

* Fix Steam URL game ID fallback

* Add screen effects translations for all locales

* Add per-game screen effects profiles

* Fix per-game screen effects preset persistence

* Fix screen effects profile upscaler handling

* Fix screen effects profile synchronization

* Fix screen effects focus profile synchronization

* Fix screen effects profile restoration on resume

* Fix screen effects profile switching

* Fix Steam game launch rollback target

* Fix screen effects upscaler profile inheritance

* Update SessionActivity.kt ( removed coments )

* Remove unused setup stores translations

* Guard screen effects profile rollback

* Fix per-game screen effects and queued launches

* Fix queued game state and suspend-aware startup timeout

* Fix integer scaling picture bounds

* Fix nullable automatic screen effects profile validation

* Fix integer scaling fallback for small outputs

* Revert "Fix integer scaling fallback for small outputs"

This reverts commit c667a50d58.

* Fix Steam game exit watcher for direct launches

* Fix per-game screen effects resume handling

* Fix game picture bounds scaling
This commit is contained in:
LunaDL authored and GitHub committed 2026-11-15 09:20:37 -05:00
1 parent ae9bac225d
commit 9ce6d45be8
41 files changed
+845 -89

No files matched your search

@@ -151,6 +151,9 @@ import com.droiddeck.launcher.ui.sessionDrawerPages
import com.droiddeck.launcher.ui.step
import kotlin.math.abs
private const val SCREEN_EFFECTS_TARGET_AUTO = "auto"
private const val SCREEN_EFFECTS_TARGET_GLOBAL = "global"
class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droiddeck.launcher.ui.AgentPetHost {
override fun attachBaseContext(newBase: android.content.Context) {
super.attachBaseContext(newBase)
@@ -503,6 +506,8 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde
private var upscaler by mutableStateOf(0)
private var upscaleSharpness by mutableStateOf(75)
private var effects by mutableStateOf(ScreenEffects.OFF)
private var observedScreenEffectsProfileId by mutableStateOf<String?>(null)
private var screenEffectsTarget by mutableStateOf(SCREEN_EFFECTS_TARGET_AUTO)
private var cardboard by mutableStateOf(Cardboard.OFF)
private var headTracker: HeadTracker? = null
private var steamVrStatus by mutableStateOf<SteamVr.Status?>(null)
@@ -545,6 +550,11 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde
private val cardboardPrefListener = android.content.SharedPreferences.OnSharedPreferenceChangeListener { _, key ->
if (key == SessionPrefs.CARDBOARD_KEY) uiHandler.post { applyCardboard(SessionPrefs.cardboard(this)) }
}
private val screenEffectsProfilePrefListener = android.content.SharedPreferences.OnSharedPreferenceChangeListener { _, key ->
if (key == SessionPrefs.SCREEN_EFFECTS_ACTIVE_PROFILE_KEY) uiHandler.post {
syncActiveScreenEffectsProfile()
}
}
private val shortcutPrefListener = android.content.SharedPreferences.OnSharedPreferenceChangeListener { _, key ->
if (key == null || key == PhysicalShortcuts.KEY) {
physicalShortcuts.bindings = PhysicalShortcuts.read(this)
@@ -977,6 +987,18 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde
isFocusableInTouchMode = true
defaultFocusHighlightEnabled = false
setContent {
val activeEffectsProfileId = currentScreenEffectsProfileId()
val effectsEditorTarget = if (drawerOpen) screenEffectsTarget else null
val effectsEditorProfileId = activeEffectsProfileId.takeIf {
effectsEditorTarget == SCREEN_EFFECTS_TARGET_AUTO
}
androidx.compose.runtime.LaunchedEffect(effectsEditorTarget, effectsEditorProfileId) {
when (effectsEditorTarget) {
SCREEN_EFFECTS_TARGET_AUTO -> syncActiveScreenEffectsProfile()
null -> Unit
else -> syncScreenEffectsTarget(effectsEditorTarget)
}
}
val uiPointer = appUiOwnsPointer()
androidx.compose.runtime.SideEffect {
com.droiddeck.launcher.glasses.GlassesMenuMirror.setSessionMenuVisible(this@SessionActivity,
@@ -1070,6 +1092,8 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde
},
)
LaunchedEffect(AgentGuest.focusRevision, secondScreenDisplays.isNotEmpty(), drawerGameInventoryRevision) {
val startingActiveEffectsProfileId =
SessionPrefs.activeScreenEffectsProfileId(this@SessionActivity)
val nextGame = kotlinx.coroutines.withContext(kotlinx.coroutines.Dispatchers.IO) {
if (SessionState.mode == SessionService.MODE_RUN) SessionState.program?.let { "program:$it" }
else {
@@ -1092,18 +1116,36 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde
val id = AgentGuest.activeSteamAppId(
this@SessionActivity, cachedIds + inventoryIds
)
val name = id?.let { activeId ->
games.firstOrNull { it.profileKey == activeId.toString() }?.name
val activeGame = id?.let { activeId ->
games.firstOrNull { it.profileKey == activeId.toString() }
}
id to name
id to activeGame
}
if (target.first != frameGenActiveGameId) {
val previousActiveGameId = frameGenActiveGameId
frameGenActiveGameId = target.first
if ((target.first != null || previousActiveGameId != null) &&
SessionPrefs.activeScreenEffectsProfileId(this@SessionActivity) ==
startingActiveEffectsProfileId
) {
val activeEffectsProfileId = target.first?.let {
SessionPrefs.screenEffectsProfileId(
SessionService.MODE_STEAM,
target.second?.gameIdString ?: it.toString(),
null,
)
}
SessionPrefs.setActiveScreenEffectsProfile(
this@SessionActivity, activeEffectsProfileId,
)
observedScreenEffectsProfileId = activeEffectsProfileId
syncActiveScreenEffectsProfile()
}
if (drawerGameProfileFollowState.followsSteam) {
loadFrameGenFor(target.first)
}
}
frameGenActiveGameName = target.second
frameGenActiveGameName = target.second?.name
}
if (nextGame != gestureGame) {
if (nextGame != null) gameStarts++
@@ -1218,7 +1260,11 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde
onAndroidKeyboard = { pcKeyboardOpen = false; keyboard?.toggle() },
onClose = { pcKeyboardOpen = false },
)
if (!drawerDocked) SessionMenu(docked = false)
if (!drawerDocked) SessionMenu(
docked = false,
effectsEditorProfileId = effectsEditorProfileId,
effectsEditorTarget = effectsEditorTarget,
)
LaunchedEffect(achievementsOpen) {
if (achievementsOpen) {
releasePads()
@@ -1268,7 +1314,11 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde
}
@androidx.compose.runtime.Composable
private fun SessionMenu(docked: Boolean) {
private fun SessionMenu(
docked: Boolean,
effectsEditorProfileId: String?,
effectsEditorTarget: String?,
) {
SessionDrawer(drawerOpen || (docked && drawerPinned), drawerPage, drawerControllerActive, onPageChange = { drawerPage = it }, docked = docked,
backRequest = drawerBackRequests, onLayerChange = { drawerLayerOpen = it }, a = DrawerActions(
steam = SessionState.mode == SessionService.MODE_STEAM,
@@ -1284,6 +1334,11 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde
hudConfig = hudConfig,
upscaler = upscaler, upscaleSharpness = upscaleSharpness,
effects = effects,
screenEffectsTarget = screenEffectsTarget,
screenEffectsTargets = screenEffectsTargetOptions(),
screenEffectsCanDelete = screenEffectsProfileIdForTarget(screenEffectsTarget)?.let {
SessionPrefs.hasScreenEffectsOverride(this@SessionActivity, it)
} == true,
cardboard = cardboard,
cardboardSensor = hasRotationSensor,
onCardboard = { c -> SessionPrefs.setCardboard(this@SessionActivity, c); applyCardboard(c) },
@@ -1336,17 +1391,127 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde
onHudOrderReset = { hudConfig = DroidDeckHudConfig.clearOrder(this@SessionActivity); hud.applyConfig() },
onHudExport = { exportHudDiagnostics() },
onUpscaler = { m ->
SessionPrefs.setUpscaler(this@SessionActivity, m); upscaler = m
WaylandCompositor.nativeSetUpscaler(m)
WaylandCompositor.nativeSetLookName(ScreenEffectLooks.match(effects, m)?.name)
val target = effectsEditorTarget ?: screenEffectsTarget
val activeProfileId =
SessionPrefs.activeScreenEffectsProfileId(this@SessionActivity)
if (target == SCREEN_EFFECTS_TARGET_AUTO &&
activeProfileId != effectsEditorProfileId) {
Log.w(TAG, "Screen effects profile changed while editing; discarding stale upscaler edit")
observedScreenEffectsProfileId = activeProfileId
val activeEffects = SessionPrefs.screenEffects(this@SessionActivity, activeProfileId)
val activeUpscaler = SessionPrefs.screenEffectsUpscaler(this@SessionActivity, activeProfileId)
effects = activeEffects
upscaler = activeUpscaler
activeEffects.push(activeUpscaler)
} else {
val profileId = screenEffectsProfileIdForTarget(target)
SessionPrefs.setScreenEffectsUpscaler(this@SessionActivity, profileId, m)
if (target == screenEffectsTarget) {
upscaler = m
if (screenEffectsUpscalerTargetAppliesToLiveOutput(target)) {
val liveProfileId =
SessionPrefs.activeScreenEffectsProfileId(this@SessionActivity)
val liveUpscaler =
SessionPrefs.screenEffectsUpscaler(this@SessionActivity, liveProfileId)
val liveEffects =
SessionPrefs.screenEffects(this@SessionActivity, liveProfileId)
WaylandCompositor.nativeSetUpscaler(liveUpscaler)
WaylandCompositor.nativeSetLookName(
ScreenEffectLooks.match(liveEffects, liveUpscaler)?.name
)
liveEffects.push(liveUpscaler)
}
}
}
},
onPresetUpscaler = { m ->
val target = effectsEditorTarget ?: screenEffectsTarget
val activeProfileId = if (target == SCREEN_EFFECTS_TARGET_AUTO) {
SessionPrefs.activeScreenEffectsProfileId(this@SessionActivity)
} else null
if (target == SCREEN_EFFECTS_TARGET_AUTO &&
activeProfileId != effectsEditorProfileId) {
Log.w(TAG, "Screen effects profile changed while editing; discarding stale upscaler edit")
observedScreenEffectsProfileId = activeProfileId
val activeEffects = SessionPrefs.screenEffects(this@SessionActivity, activeProfileId)
effects = activeEffects
activeEffects.push(upscaler)
} else {
val profileId = screenEffectsProfileIdForTarget(target)
SessionPrefs.setScreenEffectsUpscaler(this@SessionActivity, profileId, m)
if (target == screenEffectsTarget) {
upscaler = m
if (screenEffectsUpscalerTargetAppliesToLiveOutput(target)) {
val liveProfileId =
SessionPrefs.activeScreenEffectsProfileId(this@SessionActivity)
val liveUpscaler =
SessionPrefs.screenEffectsUpscaler(this@SessionActivity, liveProfileId)
val liveEffects =
SessionPrefs.screenEffects(this@SessionActivity, liveProfileId)
WaylandCompositor.nativeSetUpscaler(liveUpscaler)
WaylandCompositor.nativeSetLookName(
ScreenEffectLooks.match(liveEffects, liveUpscaler)?.name
)
liveEffects.push(liveUpscaler)
}
}
}
},
onUpscaleSharpness = { pct ->
SessionPrefs.setUpscaleSharpness(this@SessionActivity, pct); upscaleSharpness = pct
WaylandCompositor.nativeSetUpscaleSharpness(pct)
},
onEffects = { e ->
SessionPrefs.setScreenEffects(this@SessionActivity, e); effects = e
e.push(upscaler)
if (drawerOpen || (docked && drawerPinned)) {
val editorTarget = effectsEditorTarget ?: screenEffectsTarget
if (editorTarget != screenEffectsTarget) {
syncScreenEffectsTarget(screenEffectsTarget)
} else if (editorTarget == SCREEN_EFFECTS_TARGET_AUTO) {
val activeProfileId =
SessionPrefs.activeScreenEffectsProfileId(this@SessionActivity)
if (activeProfileId != effectsEditorProfileId) {
Log.w(TAG, "Screen effects profile changed while editing; discarding stale edit")
observedScreenEffectsProfileId = activeProfileId
val activeEffects = SessionPrefs.screenEffects(this@SessionActivity, activeProfileId)
effects = activeEffects
activeEffects.push(upscaler)
} else {
SessionPrefs.setScreenEffects(this@SessionActivity, activeProfileId, e)
observedScreenEffectsProfileId = activeProfileId
effects = e
e.push(upscaler)
}
} else {
val profileId = screenEffectsProfileIdForTarget(editorTarget)
SessionPrefs.setScreenEffects(this@SessionActivity, profileId, e)
effects = e
if (screenEffectsTargetAppliesToLiveOutput(editorTarget)) e.push(upscaler)
}
}
},
onScreenEffectsTarget = ::selectScreenEffectsTarget,
onScreenEffectsReset = {
val target = effectsEditorTarget ?: screenEffectsTarget
val profileStillMatches = target != SCREEN_EFFECTS_TARGET_AUTO ||
SessionPrefs.activeScreenEffectsProfileId(this@SessionActivity) == effectsEditorProfileId
if (target == screenEffectsTarget && profileStillMatches) {
resetScreenEffectsTarget(target)
}
},
onScreenEffectsDelete = {
val target = effectsEditorTarget ?: screenEffectsTarget
val profileStillMatches = target != SCREEN_EFFECTS_TARGET_AUTO ||
SessionPrefs.activeScreenEffectsProfileId(this@SessionActivity) == effectsEditorProfileId
if (target == screenEffectsTarget && profileStillMatches) {
deleteScreenEffectsTarget(target)
}
},
onScreenEffectsProfilesRefresh = {
drawerGameInventoryRevision++
refreshDrawerGameProfile()
},
onTextureAnisotropy = { value ->
drawerGameProfileId?.let { appId ->
@@ -1969,6 +2134,131 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde
}, "drawer-game-no-steam").start()
}
private fun syncActiveScreenEffectsProfile() {
val profileId = SessionPrefs.activeScreenEffectsProfileId(this)
observedScreenEffectsProfileId = profileId
val activeEffects = SessionPrefs.screenEffects(this, profileId)
val activeUpscaler = SessionPrefs.screenEffectsUpscaler(this, profileId)
if (screenEffectsTarget == SCREEN_EFFECTS_TARGET_AUTO) {
effects = activeEffects
upscaler = activeUpscaler
}
WaylandCompositor.nativeSetUpscaler(activeUpscaler)
activeEffects.push(activeUpscaler)
}
private fun screenEffectsProfileIdForTarget(target: String): String? = when (target) {
SCREEN_EFFECTS_TARGET_AUTO -> currentScreenEffectsProfileId()
SCREEN_EFFECTS_TARGET_GLOBAL -> null
else -> target
}
private fun screenEffectsTargetOptions(): List<Pair<String, String>> {
val installed = LibraryCache.load(this)
.associate { it.gameIdString to it.name }
val ids = linkedSetOf<String>()
ids.addAll(installed.keys)
SessionPrefs.screenEffectsProfileIds(this).forEach { saved ->
if (saved.startsWith("game:")) {
saved.removePrefix("game:").toULongOrNull()?.let { ids.add(it.toString()) }
}
}
currentScreenEffectsProfileId()?.takeIf { it.startsWith("game:") }
?.removePrefix("game:")?.toULongOrNull()?.let { ids.add(it.toString()) }
return buildList {
add(SCREEN_EFFECTS_TARGET_AUTO to getString(R.string.screen_effects_target_auto))
add(SCREEN_EFFECTS_TARGET_GLOBAL to getString(R.string.frame_gen_scope_global))
ids.sortedBy { installed[it]?.lowercase() ?: it }.forEach { id ->
add("game:$id" to (installed[id] ?: getString(R.string.game_env_profile, id)))
}
}
}
private fun screenEffectsUpscalerTargetAppliesToLiveOutput(target: String): Boolean {
if (target == SCREEN_EFFECTS_TARGET_AUTO) return true
val selectedProfileId = screenEffectsProfileIdForTarget(target)
val activeProfileId = currentScreenEffectsProfileId()
if (selectedProfileId == activeProfileId) return true
return selectedProfileId == null &&
(activeProfileId == null ||
!SessionPrefs.hasScreenEffectsUpscalerOverride(this, activeProfileId))
}
private fun screenEffectsTargetAppliesToLiveOutput(target: String): Boolean {
if (target == SCREEN_EFFECTS_TARGET_AUTO) return true
val selectedProfileId = screenEffectsProfileIdForTarget(target)
val activeProfileId = currentScreenEffectsProfileId()
if (selectedProfileId == activeProfileId) return true
return selectedProfileId == null &&
(activeProfileId == null || !SessionPrefs.hasScreenEffectsOverride(this, activeProfileId))
}
private fun syncScreenEffectsTarget(target: String) {
if (target == SCREEN_EFFECTS_TARGET_AUTO) {
syncActiveScreenEffectsProfile()
return
}
val profileId = screenEffectsProfileIdForTarget(target)
val targetEffects = SessionPrefs.screenEffects(this, profileId)
val targetUpscaler = SessionPrefs.screenEffectsUpscaler(this, profileId)
effects = targetEffects
upscaler = targetUpscaler
if (screenEffectsTargetAppliesToLiveOutput(target)) {
WaylandCompositor.nativeSetUpscaler(targetUpscaler)
WaylandCompositor.nativeSetLookName(ScreenEffectLooks.match(targetEffects, targetUpscaler)?.name)
targetEffects.push(targetUpscaler)
}
}
private fun selectScreenEffectsTarget(target: String) {
if (target == screenEffectsTarget) return
screenEffectsTarget = target
syncScreenEffectsTarget(target)
}
private fun resetScreenEffectsTarget(target: String) {
if (target != screenEffectsTarget) return
SessionPrefs.resetScreenEffectsProfile(this, screenEffectsProfileIdForTarget(target))
syncScreenEffectsTarget(target)
}
private fun deleteScreenEffectsTarget(target: String) {
if (target != screenEffectsTarget) return
val profileId = screenEffectsProfileIdForTarget(target) ?: return
SessionPrefs.deleteScreenEffectsProfile(this, profileId)
syncScreenEffectsTarget(target)
}
private fun currentScreenEffectsProfileId(): String? {
if (SessionState.running) {
return observedScreenEffectsProfileId
?: SessionPrefs.activeScreenEffectsProfileId(this)
}
val mode = intent.getStringExtra(SessionService.EXTRA_MODE) ?: SessionService.MODE_STEAM
val explicitGameId = intent.getStringExtra(SessionService.EXTRA_GAME_ID)
?.trim()
?.takeIf(com.droiddeck.launcher.frontend.GameLaunchLink::validId)
val steamUrlGameId = intent.getStringExtra(SessionService.EXTRA_STEAM_URL)
?.let { url ->
when {
url.startsWith("steam://rungameid/") ->
url.removePrefix("steam://rungameid/")
url.startsWith("steam://run/") ->
url.removePrefix("steam://run/")
else -> null
}
}
?.takeIf(com.droiddeck.launcher.frontend.GameLaunchLink::validId)
val gameId = explicitGameId ?: steamUrlGameId
return SessionPrefs.screenEffectsProfileId(
mode,
gameId,
intent.getStringExtra(SessionService.EXTRA_PROGRAM),
)
}
private fun loadingMode(): String =
if (SessionState.running) SessionState.mode
else intent.getStringExtra(SessionService.EXTRA_MODE) ?: SessionService.MODE_STEAM
@@ -2063,9 +2353,9 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde
hudConfig = DroidDeckHudConfig.load(this)
hudColor = SessionPrefs.hudColor(this)
hudOpacity = SessionPrefs.hudOpacity(this)
upscaler = SessionPrefs.upscaler(this)
upscaler = SessionPrefs.screenEffectsUpscaler(this, screenEffectsProfileIdForTarget(screenEffectsTarget))
upscaleSharpness = SessionPrefs.upscaleSharpness(this)
effects = SessionPrefs.screenEffects(this)
effects = SessionPrefs.screenEffects(this, screenEffectsProfileIdForTarget(screenEffectsTarget))
applyCardboard(SessionPrefs.cardboard(this))
if (SessionPrefs.cardboardSourceBeforeSteamVr(this) >= 0 && !steamVrSwitchedPicture) {
steamVrSwitchedPicture = true
@@ -2306,9 +2596,12 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde
.onFailure { Log.e(TAG, "Could not update game environment", it) }
}, "game-env-publish").start()
WaylandCompositor.nativeSetScaleMode(SCALE_FIT, ALIGN_CENTER)
WaylandCompositor.nativeSetUpscaler(SessionPrefs.upscaler(this))
val activeProfileId = currentScreenEffectsProfileId()
val activeUpscaler = SessionPrefs.screenEffectsUpscaler(this, activeProfileId)
val activeEffects = SessionPrefs.screenEffects(this, activeProfileId)
WaylandCompositor.nativeSetUpscaler(activeUpscaler)
WaylandCompositor.nativeSetUpscaleSharpness(SessionPrefs.upscaleSharpness(this))
SessionPrefs.screenEffects(this).push(SessionPrefs.upscaler(this))
activeEffects.push(activeUpscaler)
activeCardboard = effectiveCardboard(SessionPrefs.cardboard(this))
pushCardboard(activeCardboard)
WaylandCompositor.nativeSetCardboardPoseFile(File(filesDir, ".wayland-rt/droiddeck-headpose").path)
@@ -3741,7 +4034,26 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde
}
},
menu = {
DroidDeckTheme { SessionMenu(docked = true) }
DroidDeckTheme {
val activeEffectsProfileId = currentScreenEffectsProfileId()
val effectsEditorTarget =
if (drawerOpen || drawerPinned) screenEffectsTarget else null
val effectsEditorProfileId = activeEffectsProfileId.takeIf {
effectsEditorTarget == SCREEN_EFFECTS_TARGET_AUTO
}
androidx.compose.runtime.LaunchedEffect(effectsEditorTarget, effectsEditorProfileId) {
when (effectsEditorTarget) {
SCREEN_EFFECTS_TARGET_AUTO -> syncActiveScreenEffectsProfile()
null -> Unit
else -> syncScreenEffectsTarget(effectsEditorTarget)
}
}
SessionMenu(
docked = true,
effectsEditorProfileId = effectsEditorProfileId,
effectsEditorTarget = effectsEditorTarget,
)
}
},
onSwap = if (bottomSwapAvailable && com.droiddeck.launcher.input.DualScreen.builtIn(target)) ({ putGameOnBottom(true) }) else null,
onDeckPanel = ::selectDeckPanel,
@@ -4253,7 +4565,19 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde
)
}
return rect
val nativeSize = IntArray(2)
if (!WaylandCompositor.nativeOutputSize(nativeSize)) return null
val nativeWidth = nativeSize[0].takeIf { it > 0 } ?: return null
val nativeHeight = nativeSize[1].takeIf { it > 0 } ?: return null
val scaleX = width.toFloat() / nativeWidth
val scaleY = height.toFloat() / nativeHeight
return android.graphics.RectF(
rect.left * scaleX,
rect.top * scaleY,
rect.right * scaleX,
rect.bottom * scaleY
)
}
val out = SessionState.outputSize
val scale = minOf(width / out.first.toFloat(), height / out.second.toFloat())
@@ -5031,7 +5355,21 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde
if (!pipUi) sessionClipboard.start()
updatePadMotion()
ControllerPrefs.prefs(this).registerOnSharedPreferenceChangeListener(shortcutPrefListener)
SessionPrefs.sessionPrefs(this).registerOnSharedPreferenceChangeListener(screenEffectsProfilePrefListener)
observedScreenEffectsProfileId = SessionPrefs.activeScreenEffectsProfileId(this)
readPrefs()
observedScreenEffectsProfileId = SessionPrefs.activeScreenEffectsProfileId(this)
if (CompositorHost.isStarted) {
syncActiveScreenEffectsProfile()
} else if (screenEffectsTarget == SCREEN_EFFECTS_TARGET_AUTO) {
effects = SessionPrefs.screenEffects(this, observedScreenEffectsProfileId)
upscaler = SessionPrefs.screenEffectsUpscaler(this, observedScreenEffectsProfileId)
}
if (screenEffectsTarget != SCREEN_EFFECTS_TARGET_AUTO) {
val editorProfileId = screenEffectsProfileIdForTarget(screenEffectsTarget)
effects = SessionPrefs.screenEffects(this, editorProfileId)
upscaler = SessionPrefs.screenEffectsUpscaler(this, editorProfileId)
}
refreshInputProfile()
refreshControls()
if (::pip.isInitialized) pip.resumed()
@@ -5079,6 +5417,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde
updatePadMotion()
keyboard?.takeIf { it.shown }?.hide()
SessionPrefs.sessionPrefs(this).unregisterOnSharedPreferenceChangeListener(cardboardPrefListener)
SessionPrefs.sessionPrefs(this).unregisterOnSharedPreferenceChangeListener(screenEffectsProfilePrefListener)
ControllerPrefs.prefs(this).unregisterOnSharedPreferenceChangeListener(shortcutPrefListener)
updateHeadTracker()
super.onPause()
@@ -13,6 +13,8 @@ import com.droiddeck.launcher.gpu.TurnipDriver
import org.json.JSONObject
import java.io.File
private const val SCREEN_EFFECTS_PROFILE_UPSCALER_KEY = "upscaler"
object SessionPrefs {
data class GameTextureFiltering(val anisotropy: Int? = null, val lodBias: String? = null)
@@ -1443,15 +1445,136 @@ object SessionPrefs {
}
private const val SCREEN_EFFECTS_PROFILES_KEY = "screenEffects.profiles"
const val SCREEN_EFFECTS_ACTIVE_PROFILE_KEY = "screenEffects.activeProfile"
fun screenEffectsProfileId(mode: String, gameId: String?, program: String?): String? {
if (mode == SessionService.MODE_DESKTOP) return "desktop"
val id = gameId?.trim()?.takeIf { it.isNotEmpty() }
if (id != null) return "game:$id"
return if (mode == SessionService.MODE_RUN) {
program?.trim()?.takeIf { it.isNotEmpty() }?.let { "program:$it" }
} else null
}
fun activeScreenEffectsProfileId(context: Context): String? =
prefs(context).getString(SCREEN_EFFECTS_ACTIVE_PROFILE_KEY, null)?.takeIf { it.isNotBlank() }
fun setActiveScreenEffectsProfile(context: Context, profileId: String?) {
prefs(context).edit().putString(SCREEN_EFFECTS_ACTIVE_PROFILE_KEY, profileId.orEmpty()).apply()
}
fun screenEffects(context: Context): ScreenEffects {
val text = prefs(context).getString("screenEffects", null) ?: return ScreenEffects.OFF
return runCatching { ScreenEffects.decode(JSONObject(text)) }.getOrDefault(ScreenEffects.OFF)
}
fun screenEffects(context: Context, profileId: String?): ScreenEffects {
if (profileId.isNullOrBlank()) return screenEffects(context)
val storedProfiles = prefs(context).getString(SCREEN_EFFECTS_PROFILES_KEY, null)
val profile = storedProfiles?.let { raw ->
runCatching { JSONObject(raw).optJSONObject(profileId) }.getOrNull()
}
return profile?.let {
runCatching { ScreenEffects.decode(it) }.getOrDefault(ScreenEffects.OFF)
} ?: screenEffects(context)
}
fun setScreenEffects(context: Context, effects: ScreenEffects) {
prefs(context).edit().putString("screenEffects", effects.encode().toString()).apply()
}
fun setScreenEffects(context: Context, profileId: String?, effects: ScreenEffects) {
if (profileId.isNullOrBlank()) {
setScreenEffects(context, effects)
return
}
val sessionPrefs = prefs(context)
val profiles = runCatching {
JSONObject(sessionPrefs.getString(SCREEN_EFFECTS_PROFILES_KEY, null) ?: "{}")
}.getOrDefault(JSONObject())
val encoded = effects.encode()
profiles.optJSONObject(profileId)?.let { savedProfile ->
if (savedProfile.has(SCREEN_EFFECTS_PROFILE_UPSCALER_KEY)) {
encoded.put(
SCREEN_EFFECTS_PROFILE_UPSCALER_KEY,
savedProfile.optInt(SCREEN_EFFECTS_PROFILE_UPSCALER_KEY),
)
}
}
profiles.put(profileId, encoded)
sessionPrefs.edit().putString(SCREEN_EFFECTS_PROFILES_KEY, profiles.toString()).apply()
}
fun hasScreenEffectsUpscalerOverride(context: Context, profileId: String?): Boolean {
if (profileId.isNullOrBlank()) return false
return runCatching {
val profiles = JSONObject(prefs(context).getString(SCREEN_EFFECTS_PROFILES_KEY, null) ?: "{}")
profiles.optJSONObject(profileId)?.has(SCREEN_EFFECTS_PROFILE_UPSCALER_KEY) == true
}.getOrDefault(false)
}
fun screenEffectsUpscaler(context: Context, profileId: String?): Int {
if (profileId.isNullOrBlank()) return upscaler(context)
val stored = runCatching {
val profiles = JSONObject(prefs(context).getString(SCREEN_EFFECTS_PROFILES_KEY, null) ?: "{}")
val profile = profiles.optJSONObject(profileId)
if (profile?.has(SCREEN_EFFECTS_PROFILE_UPSCALER_KEY) == true) {
profile.optInt(SCREEN_EFFECTS_PROFILE_UPSCALER_KEY, -1)
} else -1
}.getOrDefault(-1)
return if (stored >= 0) canonicalUpscaler(stored) else upscaler(context)
}
fun setScreenEffectsUpscaler(context: Context, profileId: String?, mode: Int) {
if (profileId.isNullOrBlank()) {
setUpscaler(context, mode)
return
}
val sessionPrefs = prefs(context)
val profiles = runCatching {
JSONObject(sessionPrefs.getString(SCREEN_EFFECTS_PROFILES_KEY, null) ?: "{}")
}.getOrDefault(JSONObject())
val profile = profiles.optJSONObject(profileId)
?: screenEffects(context, profileId).encode()
profile.put(SCREEN_EFFECTS_PROFILE_UPSCALER_KEY, canonicalUpscaler(mode))
profiles.put(profileId, profile)
sessionPrefs.edit().putString(SCREEN_EFFECTS_PROFILES_KEY, profiles.toString()).apply()
}
fun screenEffectsProfileIds(context: Context): Set<String> {
val profiles = runCatching {
JSONObject(prefs(context).getString(SCREEN_EFFECTS_PROFILES_KEY, null) ?: "{}")
}.getOrElse { JSONObject() }
return buildSet {
val keys = profiles.keys()
while (keys.hasNext()) add(keys.next())
}
}
fun hasScreenEffectsOverride(context: Context, profileId: String?): Boolean {
if (profileId.isNullOrBlank()) return prefs(context).contains("screenEffects")
return profileId in screenEffectsProfileIds(context)
}
fun resetScreenEffectsProfile(context: Context, profileId: String?) {
setScreenEffects(context, profileId, ScreenEffects.OFF)
}
fun deleteScreenEffectsProfile(context: Context, profileId: String?) {
if (profileId.isNullOrBlank()) return
val sessionPrefs = prefs(context)
val profiles = runCatching {
JSONObject(sessionPrefs.getString(SCREEN_EFFECTS_PROFILES_KEY, null) ?: "{}")
}.getOrElse { JSONObject() }
if (!profiles.has(profileId)) return
profiles.remove(profileId)
sessionPrefs.edit().apply {
if (profiles.length() == 0) remove(SCREEN_EFFECTS_PROFILES_KEY)
else putString(SCREEN_EFFECTS_PROFILES_KEY, profiles.toString())
}.apply()
}
const val CARDBOARD_KEY = "cardboard"
fun cardboard(context: Context): Cardboard {
@@ -114,7 +114,10 @@ class SessionService : Service() {
private var freezePending = false
private var freezeCancelled = false
private var pendingSteamGameId: String? = null
private var pendingSteamPreviousGameId: String? = null
private var pendingSteamPreviousGamePending = false
private var pendingSteamGameGeneration = -1
private var pendingSteamGameExitWatchToken = -1
@Volatile private var gameExitWatchToken = 0
private val flushSteamGame = object : Runnable {
override fun run() = flushQueuedSteamGame()
@@ -390,9 +393,28 @@ class SessionService : Service() {
pipTask = false
SessionState.program = intent?.getStringExtra(EXTRA_PROGRAM)
SessionState.programArgs = intent?.getStringArrayExtra(EXTRA_PROGRAM_ARGS)?.toList().orEmpty()
SessionState.gameId = intent?.getStringExtra(EXTRA_GAME_ID)
SessionState.steamUi = intent?.getStringExtra(EXTRA_STEAM_UI)
SessionState.steamUrl = intent?.getStringExtra(EXTRA_STEAM_URL)
val steamUrlGameId = SessionState.steamUrl
?.let { url ->
when {
url.startsWith(GAME_URL_PREFIX) ->
url.removePrefix(GAME_URL_PREFIX)
url.startsWith("steam://run/") ->
url.removePrefix("steam://run/")
else -> null
}
}
?.takeIf(GameLaunchLink::validId)
val resolvedGameId = intent?.getStringExtra(EXTRA_GAME_ID)
?.trim()
?.takeIf(GameLaunchLink::validId)
?: steamUrlGameId
SessionState.gameId = resolvedGameId
SessionPrefs.setActiveScreenEffectsProfile(
this,
SessionPrefs.screenEffectsProfileId(SessionState.mode, resolvedGameId, SessionState.program),
)
com.droiddeck.launcher.stores.battlenet.BattleNetClient.clearRequests(LinuxRuntime.sessionRoot(this))
val gen = synchronized(stopLock) {
SessionState.steamClientArch = null
@@ -413,8 +435,9 @@ class SessionService : Service() {
if (SessionPrefs.clearCachedApps(this)) clearCachedApps()
cancelQueuedSteamGame(clearMailbox = false)
clearSteamGameMailbox()
if (SessionState.mode == MODE_STEAM) SessionState.steamUrl
?.takeIf { it.startsWith(GAME_URL_PREFIX) }?.let { watchGameExit(it.removePrefix(GAME_URL_PREFIX), gen) }
if (SessionState.mode == MODE_STEAM) {
resolvedGameId?.let { watchGameExit(it, gen, ++gameExitWatchToken) }
}
acquireLocks()
Thread({
OrphanReaper.reap("session starting")
@@ -1520,7 +1543,19 @@ class SessionService : Service() {
return
}
val accepted = gameId!!
if (pendingSteamGameId != null) Log.i(TAG, "replacing a queued game launch with $accepted")
if (!pendingSteamPreviousGamePending) {
pendingSteamPreviousGameId = SessionState.gameId
pendingSteamPreviousGamePending = true
}
if (pendingSteamGameId != null) {
Log.i(TAG, "replacing queued game ${pendingSteamGameId} with $accepted")
}
pendingSteamGameExitWatchToken = ++gameExitWatchToken
SessionState.gameId = accepted
val effectsProfileId = SessionPrefs.screenEffectsProfileId(MODE_STEAM, accepted, null)
SessionPrefs.setActiveScreenEffectsProfile(this, effectsProfileId)
SessionPrefs.screenEffects(this, effectsProfileId)
.push(SessionPrefs.screenEffectsUpscaler(this, effectsProfileId))
pendingSteamGameId = accepted
pendingSteamGameGeneration = sessionGen
if (SessionState.suspended) resumeSession()
@@ -1531,9 +1566,29 @@ class SessionService : Service() {
private fun flushQueuedSteamGame() {
val gameId = pendingSteamGameId ?: return
val gen = pendingSteamGameGeneration
val exitWatchToken = pendingSteamGameExitWatchToken
if (exitWatchToken != gameExitWatchToken) return
if (gen != sessionGen || !SessionState.running || SessionState.stopRequested ||
SessionState.mode != MODE_STEAM || !GameLaunchLink.validId(gameId)) {
SessionState.mode != MODE_STEAM || SessionState.gameId != gameId ||
!GameLaunchLink.validId(gameId)) {
val previousGameId = pendingSteamPreviousGameId
val queuedProfileId = SessionPrefs.screenEffectsProfileId(MODE_STEAM, gameId, null)
val canRestore = gen == sessionGen &&
SessionState.running && !SessionState.stopRequested &&
SessionState.mode == MODE_STEAM &&
SessionState.gameId == gameId &&
SessionPrefs.activeScreenEffectsProfileId(this) == queuedProfileId
cancelQueuedSteamGame()
if (canRestore) {
SessionState.gameId = previousGameId
val previousProfileId =
SessionPrefs.screenEffectsProfileId(MODE_STEAM, previousGameId, null)
SessionPrefs.setActiveScreenEffectsProfile(this, previousProfileId)
SessionPrefs.screenEffects(this, previousProfileId)
.push(SessionPrefs.screenEffectsUpscaler(this, previousProfileId))
}
return
}
if (SessionState.suspended) {
@@ -1560,33 +1615,95 @@ class SessionService : Service() {
}
pendingSteamGameId = null
pendingSteamGameGeneration = -1
pendingSteamGameExitWatchToken = -1
SessionEvents.record("steam.game_launch_requested", mapOf("gameId" to gameId, "generation" to gen))
watchGameExit(gameId, gen)
watchGameExit(gameId, gen, exitWatchToken, pendingSteamPreviousGameId)
Log.i(TAG, "queued Steam game $gameId for the running client")
}
private fun watchGameExit(gameId: String, gen: Int) {
if (!SessionPrefs.returnAfterGame(this)) return
val token = ++gameExitWatchToken
private fun watchGameExit(
gameId: String,
gen: Int,
token: Int,
previousGameId: String? = null
) {
Thread({
val startBy = android.os.SystemClock.elapsedRealtime() + GAME_START_TIMEOUT_MS
var startupRemaining = GAME_START_TIMEOUT_MS
var lastStartupCheck = android.os.SystemClock.elapsedRealtime()
var startupWasSuspended = false
var seen = false
var goneSince = 0L
while (token == gameExitWatchToken && gen == sessionGen && SessionState.running && !SessionState.stopRequested) {
val now = android.os.SystemClock.elapsedRealtime()
if (steamGameRunning()) {
if (!seen) Log.i(TAG, "game $gameId started; returning to the launcher when it closes")
val startupSuspended = SessionState.suspended || SessionState.suspending || SessionState.phase != SessionPhase.READY
if (!seen) {
if (startupSuspended) {
startupWasSuspended = true
lastStartupCheck = now
} else if (startupWasSuspended) {
startupWasSuspended = false
lastStartupCheck = now
} else {
startupRemaining -= (now - lastStartupCheck).coerceAtLeast(0L)
lastStartupCheck = now
}
}
if (steamGameRunning(gameId)) {
if (!seen) {
Log.i(TAG, "game $gameId started; tracking its exit")
mainHandler.post {
if (token == gameExitWatchToken && gen == sessionGen &&
pendingSteamPreviousGamePending &&
pendingSteamPreviousGameId == previousGameId) {
pendingSteamPreviousGameId = null
pendingSteamPreviousGamePending = false
}
}
}
seen = true
goneSince = 0L
} else if (!seen) {
if (now > startBy) {
Log.i(TAG, "game $gameId did not start; not watching for its exit")
if (!startupSuspended && startupRemaining <= 0L) {
mainHandler.post {
if (token != gameExitWatchToken || gen != sessionGen ||
!SessionState.running || SessionState.stopRequested) {
return@post
}
if (previousGameId != null && steamGameRunning(previousGameId)) {
Log.w(TAG, "game $gameId did not start; restoring previous game $previousGameId")
SessionState.gameId = previousGameId
val previousProfileId =
SessionPrefs.screenEffectsProfileId(MODE_STEAM, previousGameId, null)
val failedGameProfileId =
SessionPrefs.screenEffectsProfileId(MODE_STEAM, gameId, null)
if (SessionPrefs.activeScreenEffectsProfileId(this@SessionService) == failedGameProfileId) {
SessionPrefs.setActiveScreenEffectsProfile(this@SessionService, previousProfileId)
SessionPrefs.screenEffects(this@SessionService, previousProfileId)
.push(SessionPrefs.screenEffectsUpscaler(this@SessionService, previousProfileId))
}
pendingSteamPreviousGameId = null
pendingSteamPreviousGamePending = false
watchGameExit(previousGameId, gen, token)
} else {
Log.i(TAG, "game $gameId did not start; clearing its screen effects profile")
pendingSteamPreviousGameId = null
pendingSteamPreviousGamePending = false
clearActiveScreenEffectsProfile(gameId, gen, token)
}
}
return@Thread
}
} else if (goneSince == 0L) {
goneSince = now
} else if (now - goneSince >= GAME_EXIT_GRACE_MS) {
mainHandler.post { returnAfterGame(gameId, gen, token) }
mainHandler.post {
if (SessionPrefs.returnAfterGame(this@SessionService)) {
returnAfterGame(gameId, gen, token)
} else {
clearActiveScreenEffectsProfile(gameId, gen, token)
}
}
return@Thread
}
try { Thread.sleep(GAME_EXIT_POLL_MS) } catch (e: InterruptedException) { return@Thread }
@@ -1594,17 +1711,52 @@ class SessionService : Service() {
}, "game-exit-watch").start()
}
private fun returnAfterGame(gameId: String, gen: Int, token: Int) {
if (token != gameExitWatchToken || gen != sessionGen || !SessionState.running ||
SessionState.stopRequested || SessionState.mode != MODE_STEAM || !SessionPrefs.returnAfterGame(this)) return
val written = runCatching { File(LinuxRuntime.sessionRoot(this), "steam-stop").writeText("") }
.onFailure { Log.w(TAG, "could not ask the client to exit after game $gameId", it) }.isSuccess
if (!written) return
SessionEvents.record("steam.return_after_game", mapOf("gameId" to gameId))
Log.i(TAG, "game $gameId closed: asking the client to exit and returning to the launcher")
private fun clearActiveScreenEffectsProfile(gameId: String, gen: Int, token: Int) {
if (token != gameExitWatchToken || gen != sessionGen || !SessionState.running || SessionState.stopRequested) return
val gameProfileId = SessionPrefs.screenEffectsProfileId(MODE_STEAM, gameId, null)
if (SessionPrefs.activeScreenEffectsProfileId(this) != gameProfileId) return
SessionPrefs.setActiveScreenEffectsProfile(this, null)
SessionPrefs.screenEffects(this, null).push(SessionPrefs.screenEffectsUpscaler(this, null))
}
private fun steamGameRunning(): Boolean = SteamGameProcess.running()
private fun returnAfterGame(gameId: String, gen: Int, token: Int) {
mainHandler.postDelayed({
if (token != gameExitWatchToken || gen != sessionGen || !SessionState.running ||
SessionState.stopRequested || SessionState.mode != MODE_STEAM ||
SessionState.gameId != gameId || pendingSteamGameId != null) {
return@postDelayed
}
if (steamGameRunning(gameId)) {
Log.i(TAG, "game $gameId is running again; restarting its exit watcher")
watchGameExit(gameId, gen, token)
return@postDelayed
}
if (SteamGameProcess.running()) {
Log.i(TAG, "another Steam game is still running after $gameId; checking again")
returnAfterGame(gameId, gen, token)
return@postDelayed
}
clearActiveScreenEffectsProfile(gameId, gen, token)
if (!SessionPrefs.returnAfterGame(this)) {
Log.i(TAG, "return after game disabled; keeping the Steam session open")
return@postDelayed
}
val written = runCatching { File(LinuxRuntime.sessionRoot(this), "steam-stop").writeText("") }
.onFailure { Log.w(TAG, "could not ask the client to exit after game $gameId", it) }.isSuccess
if (!written) return@postDelayed
SessionEvents.record("steam.return_after_game", mapOf("gameId" to gameId))
Log.i(TAG, "game $gameId closed: asking the client to exit and returning to the launcher")
}, GAME_EXIT_CONFIRM_MS)
}
private fun steamGameRunning(gameId: String): Boolean =
SteamGameProcess.running(gameId)
private fun resumeSession(panelVisible: Boolean = true) {
if (SessionState.suspended) SessionState.resumeRequested = true
@@ -1624,7 +1776,11 @@ class SessionService : Service() {
private fun cancelQueuedSteamGame(clearMailbox: Boolean = true) {
mainHandler.removeCallbacks(flushSteamGame)
pendingSteamGameId = null
pendingSteamPreviousGameId = null
pendingSteamPreviousGamePending = false
pendingSteamGameGeneration = -1
pendingSteamGameExitWatchToken = -1
gameExitWatchToken++
if (clearMailbox) clearSteamGameMailbox()
}
@@ -2447,6 +2603,7 @@ class SessionService : Service() {
private const val GAME_URL_PREFIX = "steam://rungameid/"
private const val GAME_START_TIMEOUT_MS = 20 * 60_000L
private const val GAME_EXIT_GRACE_MS = 10_000L
private const val GAME_EXIT_CONFIRM_MS = 2_000L
private const val GAME_EXIT_POLL_MS = 2_000L
private const val NO_PAD_SWITCH = "Download/droiddeck-no-pad"
private const val NO_UINPUT_SWITCH = "Download/droiddeck-no-uinput"
@@ -5,14 +5,59 @@ import java.io.File
object SteamGameProcess {
fun matches(cmdline: ByteArray): Boolean {
val args = String(cmdline).split('\u0000')
for (i in args.indices) {
if (args[i] == "waitforexitandrun") return true
if (args[i] == "SteamLaunch" && args.getOrNull(i + 1)?.startsWith("AppId=") == true) return true
return args.indices.any { i ->
args[i] == "waitforexitandrun" ||
(args[i] == "SteamLaunch" &&
args.getOrNull(i + 1)?.startsWith("AppId=") == true)
}
}
fun running(): Boolean =
File("/proc").listFiles()?.any { p ->
p.name.all(Char::isDigit) &&
runCatching { File(p, "cmdline").readBytes() }
.getOrNull()?.let(::matches) == true
} == true
private fun steamAppIdForGameId(gameId: String): String? {
if (gameId.isEmpty() || !gameId.all(Char::isDigit)) return null
val numericId = gameId.toULongOrNull() ?: return null
val appId = if (numericId > UInt.MAX_VALUE.toULong()) {
numericId shr 32
} else {
numericId
}
return appId.takeIf { it != 0uL }?.toString()
}
fun matches(cmdline: ByteArray, gameId: String): Boolean {
val expectedAppId = steamAppIdForGameId(gameId) ?: return false
val args = String(cmdline).split('\u0000')
for (i in args.indices) {
if (args[i] == "SteamLaunch") {
val appId = args.getOrNull(i + 1)
?.takeIf { it.startsWith("AppId=") }
?.removePrefix("AppId=")
if (appId == expectedAppId) return true
}
if (args[i] == "-applaunch" &&
args.getOrNull(i + 1) == expectedAppId
) {
return true
}
}
return false
}
fun running(proc: File = File("/proc")): Boolean = proc.listFiles()?.any { p ->
p.name.all(Char::isDigit) && runCatching { File(p, "cmdline").readBytes() }.getOrNull()?.let(::matches) == true
} == true
fun running(gameId: String, proc: File = File("/proc")): Boolean =
proc.listFiles()?.any { p ->
p.name.all(Char::isDigit) &&
runCatching { File(p, "cmdline").readBytes() }
.getOrNull()?.let { matches(it, gameId) } == true
} == true
}
@@ -243,6 +243,9 @@ class DrawerActions(
val upscaler: Int = 0,
val upscaleSharpness: Int = 75,
val effects: ScreenEffects = ScreenEffects.OFF,
val screenEffectsTarget: String = "auto",
val screenEffectsTargets: List<Pair<String, String>> = emptyList(),
val screenEffectsCanDelete: Boolean = false,
val cardboard: Cardboard = Cardboard.OFF,
val cardboardSensor: Boolean = false,
val steamVr: SteamVr.Status? = null,
@@ -304,8 +307,13 @@ class DrawerActions(
val onDirectHoldBehavior: (String) -> Unit = {},
val onFexPreset: (String) -> Unit,
val onUpscaler: (Int) -> Unit = {},
val onPresetUpscaler: (Int) -> Unit = onUpscaler,
val onUpscaleSharpness: (Int) -> Unit = {},
val onEffects: (ScreenEffects) -> Unit = {},
val onScreenEffectsTarget: (String) -> Unit = {},
val onScreenEffectsReset: () -> Unit = {},
val onScreenEffectsDelete: () -> Unit = {},
val onScreenEffectsProfilesRefresh: () -> Unit = {},
val onCardboard: (Cardboard) -> Unit = {},
val onCardboardRecenter: () -> Unit = {},
val onGlassesRecenter: () -> Unit = {},
@@ -422,6 +430,9 @@ internal fun SessionDrawer(open: Boolean, requestedPage: SessionDrawerPage, cont
}
}
}
LaunchedEffect(open, page) {
if (open && page == SessionDrawerPage.EFFECTS) a.onScreenEffectsProfilesRefresh()
}
LaunchedEffect(open, controllerActive) {
if (open && !controllerActive) focusManager.clearFocus(force = true)
}
@@ -1064,12 +1075,32 @@ private fun ScreenEffectsGroup(
val colors = MaterialTheme.colorScheme
val pal = LocalPalette.current
SettingsGroup(stringResource(R.string.drawer_effects)) {
ChoiceRow(
host, "effects-profile", stringResource(R.string.screen_effects_target),
stringResource(R.string.screen_effects_target_hint), a.screenEffectsTargets,
a.screenEffectsTarget, chipModifier = track("effects-profile"),
onPick = a.onScreenEffectsTarget,
)
ActionRow(
stringResource(R.string.screen_effects_reset),
stringResource(R.string.screen_effects_reset_hint),
stringResource(R.string.hud_reset_button),
a.onScreenEffectsReset,
modifier = track("effects-reset"),
)
if (a.screenEffectsCanDelete) ActionRow(
stringResource(R.string.screen_effects_delete),
stringResource(R.string.screen_effects_delete_hint),
stringResource(R.string.common_delete),
a.onScreenEffectsDelete,
modifier = track("effects-delete"),
)
val presets = ScreenEffectLooks.LOOKS.map { it.name to stringResource(it.label) }
ChoiceRow(host, "look", stringResource(R.string.drawer_look), null,
if (preset == null) listOf(LOOK_CUSTOM to stringResource(R.string.drawer_look_custom)) + presets else presets,
preset?.name ?: LOOK_CUSTOM, chipModifier = track("look")) { name ->
ScreenEffectLooks.LOOKS.firstOrNull { it.name == name }?.let { picked ->
picked.scalingMode?.let(a.onUpscaler)
picked.scalingMode?.let(a.onPresetUpscaler)
a.onEffects(picked.effects)
}
}
@@ -238,6 +238,8 @@ public final class WaylandCompositor {
public static native boolean nativeGamePictureRect(float[] out);
public static native boolean nativeOutputSize(int[] out);
public static native void nativeResizeOutput(int width, int height);
public static native void nativeResetFirstFrame();