From 9ce6d45be88a3f44abb57a5d78ec8044565a861c Mon Sep 17 00:00:00 2001 From: LunaDL <91587464+EnzoDLofi@users.noreply.github.com> Date: Sun, 15 Nov 2026 10:20:37 -0400 Subject: [PATCH] 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 c667a50d588c3079f890de60fed9036c3c9ba10e. * Fix Steam game exit watcher for direct launches * Fix per-game screen effects resume handling * Fix game picture bounds scaling --- app/src/main/cpp/waylandcomp/src/vk_present.c | 2 +- .../cpp/waylandcomp/src/waylandcomp_jni.c | 12 + .../com/droiddeck/launcher/SessionActivity.kt | 373 +++++++++++++++++- .../launcher/session/SessionPrefs.kt | 123 ++++++ .../launcher/session/SessionService.kt | 205 ++++++++-- .../launcher/session/SteamGameProcess.kt | 57 ++- .../droiddeck/launcher/ui/SessionOverlay.kt | 33 +- .../launcher/wayland/WaylandCompositor.java | 2 + app/src/main/res/values-ar/strings.xml | 2 +- app/src/main/res/values-bg/strings.xml | 2 +- app/src/main/res/values-cs/strings.xml | 2 +- app/src/main/res/values-da/strings.xml | 2 +- app/src/main/res/values-de/strings.xml | 2 +- app/src/main/res/values-el/strings.xml | 2 +- app/src/main/res/values-es/strings.xml | 2 +- app/src/main/res/values-fi/strings.xml | 2 +- app/src/main/res/values-fr/strings.xml | 2 +- app/src/main/res/values-hi/strings.xml | 2 +- app/src/main/res/values-hu/strings.xml | 2 +- app/src/main/res/values-in/strings.xml | 2 +- app/src/main/res/values-it/strings.xml | 2 +- app/src/main/res/values-ja/strings.xml | 2 +- app/src/main/res/values-ko/strings.xml | 2 +- app/src/main/res/values-ms/strings.xml | 2 +- app/src/main/res/values-nb/strings.xml | 2 +- app/src/main/res/values-nl/strings.xml | 2 +- app/src/main/res/values-pl/strings.xml | 2 +- app/src/main/res/values-pt-rPT/strings.xml | 2 +- app/src/main/res/values-pt/strings.xml | 9 +- app/src/main/res/values-ro/strings.xml | 2 +- app/src/main/res/values-ru/strings.xml | 2 +- app/src/main/res/values-sv/strings.xml | 2 +- app/src/main/res/values-th/strings.xml | 2 +- app/src/main/res/values-tr/strings.xml | 2 +- app/src/main/res/values-uk/strings.xml | 2 +- app/src/main/res/values-vi/strings.xml | 2 +- app/src/main/res/values-zh-rCN/strings.xml | 2 +- app/src/main/res/values-zh-rHK/strings.xml | 2 +- app/src/main/res/values-zh-rTW/strings.xml | 2 +- app/src/main/res/values/strings.xml | 7 + .../launcher/session/SteamGameProcessTest.kt | 51 ++- 41 files changed, 845 insertions(+), 89 deletions(-) diff --git a/app/src/main/cpp/waylandcomp/src/vk_present.c b/app/src/main/cpp/waylandcomp/src/vk_present.c index 44fea0c768..58af40333f 100644 --- a/app/src/main/cpp/waylandcomp/src/vk_present.c +++ b/app/src/main/cpp/waylandcomp/src/vk_present.c @@ -426,7 +426,7 @@ static void update_map(int scene_w, int scene_h) { else if (align == VKP_ALIGN_PICTURE_RIGHT) g_map.off_x = W - scene_w * g_map.kx; g_map.valid = 1; pthread_mutex_lock(&g_game_picture_lock); - g_game_picture_placed = align == VKP_ALIGN_PICTURE_TOP || align == VKP_ALIGN_PICTURE_BOTTOM || align == VKP_ALIGN_PICTURE_LEFT || align == VKP_ALIGN_PICTURE_RIGHT; + g_game_picture_placed = mode == VKP_MODE_INTEGER || align == VKP_ALIGN_PICTURE_TOP || align == VKP_ALIGN_PICTURE_BOTTOM || align == VKP_ALIGN_PICTURE_LEFT || align == VKP_ALIGN_PICTURE_RIGHT; g_game_picture_rect[0] = g_map.off_x; g_game_picture_rect[1] = g_map.off_y; g_game_picture_rect[2] = g_map.off_x + scene_w * g_map.kx; diff --git a/app/src/main/cpp/waylandcomp/src/waylandcomp_jni.c b/app/src/main/cpp/waylandcomp/src/waylandcomp_jni.c index 25b97ae0f8..e5032a72a0 100644 --- a/app/src/main/cpp/waylandcomp/src/waylandcomp_jni.c +++ b/app/src/main/cpp/waylandcomp/src/waylandcomp_jni.c @@ -448,6 +448,18 @@ Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeGamePictureRect(JNIE return JNI_TRUE; } +JNIEXPORT jboolean JNICALL +Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeOutputSize(JNIEnv *env, jclass clazz, jintArray out) { + (void)clazz; + if (!out || (*env)->GetArrayLength(env, out) < 2) return JNI_FALSE; + int width = 0, height = 0; + vkp_output_size(&width, &height); + if (width <= 0 || height <= 0) return JNI_FALSE; + jint size[2] = {(jint)width, (jint)height}; + (*env)->SetIntArrayRegion(env, out, 0, 2, size); + return JNI_TRUE; +} + JNIEXPORT void JNICALL Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSetUpscaler(JNIEnv *env, jclass clazz, jint mode) { vkp_effects_set_scaling(mode); diff --git a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt index d3e8cf877c..bcf8acfa1d 100644 --- a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt +++ b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt @@ -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(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(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> { + val installed = LibraryCache.load(this) + .associate { it.gameIdString to it.name } + val ids = linkedSetOf() + 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() 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 e6a8befb90..9cef53bd9c 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt @@ -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 { + 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 { 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 0a079af416..5313647d8b 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt @@ -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" diff --git a/app/src/main/java/com/droiddeck/launcher/session/SteamGameProcess.kt b/app/src/main/java/com/droiddeck/launcher/session/SteamGameProcess.kt index 891fb57ca8..13a88ee493 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SteamGameProcess.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SteamGameProcess.kt @@ -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 } 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 2e57de51cf..90a2ba884f 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/SessionOverlay.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/SessionOverlay.kt @@ -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> = 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) } } diff --git a/app/src/main/java/com/droiddeck/launcher/wayland/WaylandCompositor.java b/app/src/main/java/com/droiddeck/launcher/wayland/WaylandCompositor.java index 10735a1710..1f0e535c8c 100644 --- a/app/src/main/java/com/droiddeck/launcher/wayland/WaylandCompositor.java +++ b/app/src/main/java/com/droiddeck/launcher/wayland/WaylandCompositor.java @@ -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(); diff --git a/app/src/main/res/values-ar/strings.xml b/app/src/main/res/values-ar/strings.xml index 07367e93d9..5f242431c5 100644 --- a/app/src/main/res/values-ar/strings.xml +++ b/app/src/main/res/values-ar/strings.xml @@ -4162,7 +4162,7 @@ ثلج قرمزي أسطح بيضاء مع لمسات حمراء. - + الموسيقى التصويرية الموسيقى خيارات التشغيل diff --git a/app/src/main/res/values-bg/strings.xml b/app/src/main/res/values-bg/strings.xml index e270f812c2..b7b889739e 100644 --- a/app/src/main/res/values-bg/strings.xml +++ b/app/src/main/res/values-bg/strings.xml @@ -4002,7 +4002,7 @@ Ален сняг Бели повърхности с червени акценти. - + Саундтраци Музика Опции за възпроизвеждане diff --git a/app/src/main/res/values-cs/strings.xml b/app/src/main/res/values-cs/strings.xml index b4e47f86a0..ef898c549a 100644 --- a/app/src/main/res/values-cs/strings.xml +++ b/app/src/main/res/values-cs/strings.xml @@ -4082,7 +4082,7 @@ Šarlatový sníh Bílé povrchy s červenými akcenty. - + Soundtracky Hudba Možnosti přehrávání diff --git a/app/src/main/res/values-da/strings.xml b/app/src/main/res/values-da/strings.xml index dc34e25600..b331e0ddda 100644 --- a/app/src/main/res/values-da/strings.xml +++ b/app/src/main/res/values-da/strings.xml @@ -4002,7 +4002,7 @@ Skarlagensne Hvide overflader med røde accenter. - + Soundtracks Musik Afspilningsindstillinger diff --git a/app/src/main/res/values-de/strings.xml b/app/src/main/res/values-de/strings.xml index 5502230464..ba918b65f6 100644 --- a/app/src/main/res/values-de/strings.xml +++ b/app/src/main/res/values-de/strings.xml @@ -4002,7 +4002,7 @@ Scharlachroter Schnee Weiße Oberflächen mit roten Akzenten. - + Soundtracks Musik Wiedergabeoptionen diff --git a/app/src/main/res/values-el/strings.xml b/app/src/main/res/values-el/strings.xml index 035adf0fd9..406bef90ae 100644 --- a/app/src/main/res/values-el/strings.xml +++ b/app/src/main/res/values-el/strings.xml @@ -4002,7 +4002,7 @@ Κατακόκκινο χιόνι Λευκές επιφάνειες με κόκκινες λεπτομέρειες. - + Soundtrack Μουσική Επιλογές αναπαραγωγής diff --git a/app/src/main/res/values-es/strings.xml b/app/src/main/res/values-es/strings.xml index 52f24a4b17..2d1824196c 100644 --- a/app/src/main/res/values-es/strings.xml +++ b/app/src/main/res/values-es/strings.xml @@ -4042,7 +4042,7 @@ Nieve escarlata Superficies blancas con acentos rojos. - + Bandas sonoras Música Opciones de reproducción diff --git a/app/src/main/res/values-fi/strings.xml b/app/src/main/res/values-fi/strings.xml index 8ca89b8053..46f0b78781 100644 --- a/app/src/main/res/values-fi/strings.xml +++ b/app/src/main/res/values-fi/strings.xml @@ -4002,7 +4002,7 @@ Helakanpunainen lumi Valkoiset pinnat punaisin korostuksin. - + Soundtrackit Musiikki Toistoasetukset diff --git a/app/src/main/res/values-fr/strings.xml b/app/src/main/res/values-fr/strings.xml index 993d7e6ab1..993c9c8a16 100644 --- a/app/src/main/res/values-fr/strings.xml +++ b/app/src/main/res/values-fr/strings.xml @@ -4041,7 +4041,7 @@ Neige écarlate Surfaces blanches avec des accents rouges. - + Bandes originales Musique Options de lecture diff --git a/app/src/main/res/values-hi/strings.xml b/app/src/main/res/values-hi/strings.xml index c4bbeba561..454495d79b 100644 --- a/app/src/main/res/values-hi/strings.xml +++ b/app/src/main/res/values-hi/strings.xml @@ -4002,7 +4002,7 @@ किरमिज़ी बर्फ लाल रंग की झलकियों वाली सफ़ेद सतहें। - + साउंडट्रैक संगीत प्लेबैक विकल्प diff --git a/app/src/main/res/values-hu/strings.xml b/app/src/main/res/values-hu/strings.xml index c8c8707223..21eeafeab6 100644 --- a/app/src/main/res/values-hu/strings.xml +++ b/app/src/main/res/values-hu/strings.xml @@ -4002,7 +4002,7 @@ Skarlátvörös hó Fehér felületek piros kiemelésekkel. - + Soundtrackek Zene Lejátszási beállítások diff --git a/app/src/main/res/values-in/strings.xml b/app/src/main/res/values-in/strings.xml index 795462f5f6..46381a0361 100644 --- a/app/src/main/res/values-in/strings.xml +++ b/app/src/main/res/values-in/strings.xml @@ -3972,7 +3972,7 @@ Salju Kirmizi Permukaan putih dengan aksen merah. - + Soundtrack Musik Opsi pemutaran diff --git a/app/src/main/res/values-it/strings.xml b/app/src/main/res/values-it/strings.xml index 46f9488737..0b1cc00fb0 100644 --- a/app/src/main/res/values-it/strings.xml +++ b/app/src/main/res/values-it/strings.xml @@ -4041,7 +4041,7 @@ Neve scarlatta Superfici bianche con accenti rossi. - + Colonne sonore Musica Opzioni di riproduzione diff --git a/app/src/main/res/values-ja/strings.xml b/app/src/main/res/values-ja/strings.xml index 76f94c1c26..8012204e20 100644 --- a/app/src/main/res/values-ja/strings.xml +++ b/app/src/main/res/values-ja/strings.xml @@ -3972,7 +3972,7 @@ 緋色の雪 白いサーフェスに赤のアクセント。 - + サウンドトラック 音楽 再生オプション diff --git a/app/src/main/res/values-ko/strings.xml b/app/src/main/res/values-ko/strings.xml index 359e7036f6..9948828682 100644 --- a/app/src/main/res/values-ko/strings.xml +++ b/app/src/main/res/values-ko/strings.xml @@ -3972,7 +3972,7 @@ 진홍빛 눈 빨간색 포인트가 있는 흰색 표면. - + 사운드트랙 음악 재생 옵션 diff --git a/app/src/main/res/values-ms/strings.xml b/app/src/main/res/values-ms/strings.xml index ced8b9e05c..4eacf7d480 100644 --- a/app/src/main/res/values-ms/strings.xml +++ b/app/src/main/res/values-ms/strings.xml @@ -3972,7 +3972,7 @@ Salji Merah Skarlet Permukaan putih dengan aksen merah. - + Runut bunyi Muzik Pilihan main balik diff --git a/app/src/main/res/values-nb/strings.xml b/app/src/main/res/values-nb/strings.xml index 0c598bdc7b..4836c4e2a4 100644 --- a/app/src/main/res/values-nb/strings.xml +++ b/app/src/main/res/values-nb/strings.xml @@ -4002,7 +4002,7 @@ Skarlagenssnø Hvite flater med røde aksenter. - + Lydspor Musikk Avspillingsalternativer diff --git a/app/src/main/res/values-nl/strings.xml b/app/src/main/res/values-nl/strings.xml index 5b14250ecc..9061c61d51 100644 --- a/app/src/main/res/values-nl/strings.xml +++ b/app/src/main/res/values-nl/strings.xml @@ -4002,7 +4002,7 @@ Scharlakenrode sneeuw Witte oppervlakken met rode accenten. - + Soundtracks Muziek Afspeelopties diff --git a/app/src/main/res/values-pl/strings.xml b/app/src/main/res/values-pl/strings.xml index c6bd62f832..b8e171bfe9 100644 --- a/app/src/main/res/values-pl/strings.xml +++ b/app/src/main/res/values-pl/strings.xml @@ -4082,7 +4082,7 @@ Szkarłatny śnieg Białe powierzchnie z czerwonymi akcentami. - + Ścieżki dźwiękowe Muzyka Opcje odtwarzania diff --git a/app/src/main/res/values-pt-rPT/strings.xml b/app/src/main/res/values-pt-rPT/strings.xml index e79c27bbfa..26d665abe5 100644 --- a/app/src/main/res/values-pt-rPT/strings.xml +++ b/app/src/main/res/values-pt-rPT/strings.xml @@ -4041,7 +4041,7 @@ Neve Escarlate Superfícies brancas com detalhes vermelhos. - + Bandas sonoras Música Opções de reprodução diff --git a/app/src/main/res/values-pt/strings.xml b/app/src/main/res/values-pt/strings.xml index 37a4d7cdc9..db90e852fe 100644 --- a/app/src/main/res/values-pt/strings.xml +++ b/app/src/main/res/values-pt/strings.xml @@ -740,6 +740,13 @@ Redefinir Modo de escala Nitidez da escala + Perfil de efeitos + Escolha qual perfil terá os efeitos de tela editados. + Jogo atual (automático) + Redefinir efeitos + Define os efeitos deste perfil como desativados por padrão. + Excluir configuração salva + Remove os efeitos salvos deste jogo para ele herdar o perfil padrão. Efeitos de tela Em tempo real. Custa um pouco de tempo de GPU enquanto algum efeito estiver ativado. Predefinições @@ -4042,7 +4049,7 @@ Neve Escarlate Superfícies brancas com detalhes em vermelho. - + Trilhas sonoras Música Opções de reprodução diff --git a/app/src/main/res/values-ro/strings.xml b/app/src/main/res/values-ro/strings.xml index eb29ef3f65..30de20027b 100644 --- a/app/src/main/res/values-ro/strings.xml +++ b/app/src/main/res/values-ro/strings.xml @@ -4042,7 +4042,7 @@ Zăpadă stacojie Suprafețe albe cu accente roșii. - + Coloane sonore Muzică Opțiuni de redare diff --git a/app/src/main/res/values-ru/strings.xml b/app/src/main/res/values-ru/strings.xml index 18b38e6def..b1c9f1fd40 100644 --- a/app/src/main/res/values-ru/strings.xml +++ b/app/src/main/res/values-ru/strings.xml @@ -4082,7 +4082,7 @@ Алый снег Белые поверхности с красными акцентами. - + Саундтреки Музыка Параметры воспроизведения diff --git a/app/src/main/res/values-sv/strings.xml b/app/src/main/res/values-sv/strings.xml index 108c4e0e19..46929f6d28 100644 --- a/app/src/main/res/values-sv/strings.xml +++ b/app/src/main/res/values-sv/strings.xml @@ -4002,7 +4002,7 @@ Scharlakansröd snö Vita ytor med röda accenter. - + Soundtracks Musik Uppspelningsalternativ diff --git a/app/src/main/res/values-th/strings.xml b/app/src/main/res/values-th/strings.xml index 5f55cb3866..193ac70dca 100644 --- a/app/src/main/res/values-th/strings.xml +++ b/app/src/main/res/values-th/strings.xml @@ -3972,7 +3972,7 @@ หิมะสีแดงชาด พื้นผิวสีขาวมีสีแดงเป็นสีเน้น - + ซาวด์แทร็ก เพลง ตัวเลือกการเล่น diff --git a/app/src/main/res/values-tr/strings.xml b/app/src/main/res/values-tr/strings.xml index c7a06f41ef..8c77c78108 100644 --- a/app/src/main/res/values-tr/strings.xml +++ b/app/src/main/res/values-tr/strings.xml @@ -4002,7 +4002,7 @@ Kızıl Kar Kırmızı vurgulu beyaz yüzeyler. - + Oyun müzikleri Müzik Oynatma seçenekleri diff --git a/app/src/main/res/values-uk/strings.xml b/app/src/main/res/values-uk/strings.xml index a2c14afa7f..b1520255cb 100644 --- a/app/src/main/res/values-uk/strings.xml +++ b/app/src/main/res/values-uk/strings.xml @@ -4082,7 +4082,7 @@ Багряний сніг Білі поверхні з червоними акцентами. - + Саундтреки Музика Параметри відтворення diff --git a/app/src/main/res/values-vi/strings.xml b/app/src/main/res/values-vi/strings.xml index 9921fc4369..be35e05cc9 100644 --- a/app/src/main/res/values-vi/strings.xml +++ b/app/src/main/res/values-vi/strings.xml @@ -3972,7 +3972,7 @@ Tuyết đỏ thẫm Bề mặt trắng với điểm nhấn màu đỏ. - + Nhạc nền Nhạc Tùy chọn phát diff --git a/app/src/main/res/values-zh-rCN/strings.xml b/app/src/main/res/values-zh-rCN/strings.xml index 99238c5183..5cd73bbb81 100644 --- a/app/src/main/res/values-zh-rCN/strings.xml +++ b/app/src/main/res/values-zh-rCN/strings.xml @@ -3972,7 +3972,7 @@ 猩红之雪 白色界面配红色点缀。 - + 原声音乐 音乐 播放选项 diff --git a/app/src/main/res/values-zh-rHK/strings.xml b/app/src/main/res/values-zh-rHK/strings.xml index e8e8eb1dbf..36934e918a 100644 --- a/app/src/main/res/values-zh-rHK/strings.xml +++ b/app/src/main/res/values-zh-rHK/strings.xml @@ -3972,7 +3972,7 @@ 緋紅之雪 白色表面配紅色點綴。 - + 原聲帶 音樂 播放選項 diff --git a/app/src/main/res/values-zh-rTW/strings.xml b/app/src/main/res/values-zh-rTW/strings.xml index 463eb785da..74f5101319 100644 --- a/app/src/main/res/values-zh-rTW/strings.xml +++ b/app/src/main/res/values-zh-rTW/strings.xml @@ -3972,7 +3972,7 @@ 緋紅之雪 白色表面搭配紅色點綴。 - + 原聲帶 音樂 播放選項 diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index d12d4f4600..57ea45a404 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -766,6 +766,13 @@ Reset Scaling mode Scaling sharpness + Edit profile + Choose which profile to change screen effects for. + Current session (automatic) + Reset effects + Restore the default-off effect values for this profile. + Delete saved override + Remove saved effects for this game so it inherits the Default profile. Screen effects Live. Costs a little GPU time while any effect is on. Presets diff --git a/app/src/test/java/com/droiddeck/launcher/session/SteamGameProcessTest.kt b/app/src/test/java/com/droiddeck/launcher/session/SteamGameProcessTest.kt index 7a1723b95f..fc1a1bb276 100644 --- a/app/src/test/java/com/droiddeck/launcher/session/SteamGameProcessTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/session/SteamGameProcessTest.kt @@ -13,17 +13,46 @@ class SteamGameProcessTest { private fun cmdline(vararg args: String) = args.joinToString("\u0000", postfix = "\u0000").toByteArray() @Test fun theSessionsOwnSearchesAreNotAGame() { - assertFalse(SteamGameProcess.matches(cmdline("pgrep", "-a", "-f", "SteamLaunch AppId=[0-9]"))) - assertFalse(SteamGameProcess.matches(cmdline("pgrep", "-f", "reaper SteamLaunch"))) - assertFalse(SteamGameProcess.matches(cmdline("pgrep", "-f", "reaper SteamLaunch AppId=976310( |$)"))) - assertFalse(SteamGameProcess.matches(cmdline("sh", "-c", "pgrep -f 'proton waitforexitandrun'"))) - assertFalse(SteamGameProcess.matches(cmdline("/usr/bin/steam", "steam://rungameid/976310"))) + assertFalse(SteamGameProcess.matches(cmdline("pgrep", "-a", "-f", "SteamLaunch AppId=[0-9]"), "976310")) + assertFalse(SteamGameProcess.matches(cmdline("pgrep", "-f", "reaper SteamLaunch"), "976310")) + assertFalse(SteamGameProcess.matches(cmdline("pgrep", "-f", "reaper SteamLaunch AppId=976310( |$)"), "976310")) + assertFalse(SteamGameProcess.matches(cmdline("sh", "-c", "pgrep -f 'proton waitforexitandrun'"), "976310")) + assertFalse(SteamGameProcess.matches(cmdline("/usr/bin/steam", "steam://rungameid/976310"), "976310")) + assertFalse(SteamGameProcess.matches(cmdline("reaper", "SteamLaunch", "AppId=976310"), "")) + assertFalse(SteamGameProcess.matches(cmdline("reaper", "SteamLaunch", "AppId=976310"), "abc")) } @Test fun steamsReaperAndProtonAreAGame() { assertTrue(SteamGameProcess.matches(cmdline("/root/.local/share/Steam/steamrtarm64/reaper", "SteamLaunch", "AppId=976310", "--", - "/root/.local/share/Steam/compatibilitytools.d/droiddeck-proton-arm64/proton", "waitforexitandrun", "MK11.exe"))) - assertTrue(SteamGameProcess.matches(cmdline("python3", "/proton", "waitforexitandrun", "game.exe"))) + "/root/.local/share/Steam/compatibilitytools.d/droiddeck-proton-arm64/proton", "waitforexitandrun", "MK11.exe"), "976310")) + assertFalse(SteamGameProcess.matches(cmdline("/root/.local/share/Steam/steamrtarm64/reaper", "SteamLaunch", "AppId=976310", "--", + "/root/.local/share/Steam/compatibilitytools.d/droiddeck-proton-arm64/proton", "waitforexitandrun", "MK11.exe"), "123")) + assertFalse(SteamGameProcess.matches(cmdline("python3", "/proton", "waitforexitandrun", "game.exe"), "976310")) + } + + @Test fun shortcutCGameIdsMatchTheir32BitSteamAppId() { + val cgameId = ((976310L shl 32) or 0x02000000L).toString() + + assertTrue( + SteamGameProcess.matches( + cmdline("reaper", "SteamLaunch", "AppId=976310", "--", "proton", "waitforexitandrun", "game.exe"), + cgameId, + ) + ) + + assertTrue( + SteamGameProcess.matches( + cmdline("steam", "-applaunch", "976310"), + cgameId, + ) + ) + + assertFalse( + SteamGameProcess.matches( + cmdline("reaper", "SteamLaunch", "AppId=123", "--", "proton", "waitforexitandrun", "game.exe"), + cgameId, + ) + ) } @Test fun runningLooksAtEveryProcess() { @@ -31,8 +60,12 @@ class SteamGameProcessTest { fun process(pid: String, vararg args: String) = File(proc, pid).apply { mkdirs() }.resolve("cmdline").writeBytes(cmdline(*args)) process("100", "pgrep", "-a", "-f", "SteamLaunch AppId=[0-9]") process("self", "reaper", "SteamLaunch", "AppId=1") - assertFalse(SteamGameProcess.running(proc)) + assertFalse(SteamGameProcess.running("976310", proc)) + assertFalse(SteamGameProcess.running("1", proc)) + process("101", "reaper", "SteamLaunch", "AppId=1") + assertTrue(SteamGameProcess.running("1", proc)) process("200", "reaper", "SteamLaunch", "AppId=976310", "--", "proton", "waitforexitandrun", "MK11.exe") - assertTrue(SteamGameProcess.running(proc)) + assertTrue(SteamGameProcess.running("976310", proc)) + assertFalse(SteamGameProcess.running("123", proc)) } }