From a25800149d10e374386882d6123bb032179b4d7e Mon Sep 17 00:00:00 2001 From: xXJsonDeruloXx Date: Fri, 2 Oct 2026 21:32:12 -0400 Subject: [PATCH] Restore Steam after idle sleep through session pause and login1 wake --- .../com/droiddeck/launcher/SessionActivity.kt | 3 +- .../launcher/session/SessionFiles.kt | 1 + .../launcher/session/SessionService.kt | 56 ++++++- .../overlay/usr/local/bin/bannerlator-login1 | 147 ++++++++++++++++++ .../overlay/usr/local/bin/bannerlator-session | 18 +++ tools/tests/test_login1.py | 122 +++++++++++++++ 6 files changed, 343 insertions(+), 4 deletions(-) create mode 100755 tools/linuxfs/overlay/usr/local/bin/bannerlator-login1 create mode 100644 tools/tests/test_login1.py diff --git a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt index 43606b3d0c..8974c13e18 100644 --- a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt +++ b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt @@ -1160,7 +1160,8 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { } return true } - val resumeKey = event.keyCode == KeyEvent.KEYCODE_BUTTON_A || event.keyCode == KeyEvent.KEYCODE_BUTTON_START + val resumeKey = event.keyCode == KeyEvent.KEYCODE_BUTTON_A || event.keyCode == KeyEvent.KEYCODE_BUTTON_START || + event.keyCode == KeyEvent.KEYCODE_BUTTON_MODE || event.keyCode == KeyEvent.KEYCODE_HOME val resumeKeyId = event.deviceId to event.keyCode if (fromController && resumeKey && (SessionState.suspended || resumeKeyId in resumeKeysDown)) { if (event.action == KeyEvent.ACTION_DOWN) { diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt index b5e36f00df..d404c8d4a8 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt @@ -39,6 +39,7 @@ object SessionFiles { "usr/local/bin/bannerlator-seed-redists" to "usr/local/bin/bannerlator-seed-redists", "usr/local/bin/bannerlator-proton-extra" to "usr/local/bin/bannerlator-proton-extra", "usr/local/bin/bannerlator-netmanager" to "usr/local/bin/bannerlator-netmanager", + "usr/local/bin/bannerlator-login1" to "usr/local/bin/bannerlator-login1", "usr/local/bin/bannerlator-steam-launch" to "usr/local/bin/bannerlator-steam-launch", "usr/local/bin/bannerlator-desktop-games" to "usr/local/bin/bannerlator-desktop-games", "usr/local/bin/bannerlator-steam-shim" to "usr/local/bin/bannerlator-steam-shim", 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 77cb816bd5..f6b5c8f830 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt @@ -74,6 +74,8 @@ class SessionService : Service() { private var activityVisible = true private var screenOn = true private var manualPauseRequested = false + /** An explicit Steam sleep request is independent of the background policy. */ + private var steamSleepToken: String? = null private var suspendOperationPending = false private var suspendAttemptFailed = false private var screenReceiverRegistered = false @@ -84,6 +86,7 @@ class SessionService : Service() { Intent.ACTION_SCREEN_ON -> screenOn = true else -> return } + if (screenOn) resumeSteamSleepOnReturn() suspendAttemptFailed = false updateSuspendPolicy() } @@ -139,6 +142,7 @@ class SessionService : Service() { } ACTION_ACTIVITY_VISIBLE -> { activityVisible = true + resumeSteamSleepOnReturn() suspendAttemptFailed = false updateSuspendPolicy() return START_NOT_STICKY @@ -160,6 +164,7 @@ class SessionService : Service() { activityVisible = true screenOn = (getSystemService(Context.POWER_SERVICE) as? PowerManager)?.isInteractive ?: screenOn manualPauseRequested = false + completeSteamSleep() suspendAttemptFailed = false updateSuspendPolicy() return START_NOT_STICKY @@ -177,6 +182,7 @@ class SessionService : Service() { activityVisible = true screenOn = (getSystemService(Context.POWER_SERVICE) as? PowerManager)?.isInteractive ?: true manualPauseRequested = false + steamSleepToken = null suspendOperationPending = false suspendAttemptFailed = false suspendController = null @@ -938,9 +944,26 @@ class SessionService : Service() { private fun watchLaunchRequests(dir: File) { launchWatcher?.stopWatching() + listOf("steam-sleep", "steam-sleep-state", "steam-sleep-ready").forEach { File(dir, it).delete() } + val gen = sessionGen @Suppress("DEPRECATION") val watcher = object : android.os.FileObserver(dir.path, CLOSE_WRITE or MOVED_TO) { override fun onEvent(event: Int, path: String?) { + if (path == "steam-sleep") { + val request = File(dir, path) + val token = runCatching { request.readText().trim() }.getOrNull() ?: return + request.delete() + if (!token.matches(Regex("[a-f0-9]{32}"))) return + mainHandler.post { + if (gen != sessionGen || !SessionState.running) return@post + steamSleepToken = token + writeSteamSleepState(token, "paused") + suspendAttemptFailed = false + Log.i(TAG, "Steam requested session sleep") + updateSuspendPolicy() + } + return + } if (path != "steam-launch") return val file = File(dir, path) val text = try { file.readText() } catch (e: Exception) { return } @@ -975,18 +998,23 @@ class SessionService : Service() { if (suspendPolicy == SessionPrefs.SUSPEND_MANUAL && (!activityVisible || !screenOn)) { manualPauseRequested = true } - val shouldSuspend = when (suspendPolicy) { + val shouldSuspend = steamSleepToken != null || when (suspendPolicy) { SessionPrefs.SUSPEND_AUTO -> !activityVisible || !screenOn SessionPrefs.SUSPEND_MANUAL -> manualPauseRequested else -> false } val controller = suspendController ?: return if (suspendOperationPending || suspendAttemptFailed || shouldSuspend == SessionState.suspended) return + val gen = sessionGen suspendOperationPending = true + SessionEvents.record(if (shouldSuspend) "session.suspend_requested" else "session.resume_requested", mapOf( + "policy" to suspendPolicy, "activityVisible" to activityVisible, + "screenOn" to screenOn, "steamSleep" to (steamSleepToken != null), + )) if (shouldSuspend) { controller.freeze { success -> mainHandler.post { - if (!SessionState.running) return@post + if (gen != sessionGen || !SessionState.running) return@post suspendOperationPending = false if (success) { SessionState.suspended = true @@ -994,6 +1022,7 @@ class SessionService : Service() { releaseLocks() refreshNotification() } else { + completeSteamSleep() suspendAttemptFailed = true Log.w(TAG, "could not confirm that the session stopped") } @@ -1004,7 +1033,7 @@ class SessionService : Service() { acquireLocks() controller.resume { success -> mainHandler.post { - if (!SessionState.running) return@post + if (gen != sessionGen || !SessionState.running) return@post suspendOperationPending = false if (success) { SessionState.suspended = false @@ -1020,6 +1049,27 @@ class SessionService : Service() { } } + private fun writeSteamSleepState(token: String, state: String) { + val dir = LinuxRuntime.sessionRoot(this) + runCatching { + val staged = File(dir, "steam-sleep-state.tmp") + staged.writeText("$token:$state\n") + check(staged.renameTo(File(dir, "steam-sleep-state"))) + }.onFailure { Log.w(TAG, "could not acknowledge Steam sleep", it) } + } + + private fun completeSteamSleep() { + val token = steamSleepToken ?: return + // Write before SIGCONT: the guest's login1 sees it immediately on thaw + // and delivers PrepareForSleep(false), restoring Steam's main surface. + writeSteamSleepState(token, "awake") + steamSleepToken = null + } + + private fun resumeSteamSleepOnReturn() { + if (suspendPolicy == SessionPrefs.SUSPEND_AUTO && activityVisible && screenOn) completeSteamSleep() + } + private fun finishSessionStop(status: Int, stoppedGen: Int) { mainHandler.post { if (stoppedGen != sessionGen || SessionState.running) { diff --git a/tools/linuxfs/overlay/usr/local/bin/bannerlator-login1 b/tools/linuxfs/overlay/usr/local/bin/bannerlator-login1 new file mode 100755 index 0000000000..dee4e026d5 --- /dev/null +++ b/tools/linuxfs/overlay/usr/local/bin/bannerlator-login1 @@ -0,0 +1,147 @@ +#!/usr/bin/python3 +"""Steam's login1 sleep notifications, backed by DroidDeck's session pause. + +Android owns device power. Suspend here pauses the guest through SessionService; +the app's Resume action thaws it and completes PrepareForSleep(false). Steam +must see this service before startup or it can stay black after its idle timer. +""" +import os +from pathlib import Path +import sys +import uuid + +import gi + +gi.require_version("Gio", "2.0") +from gi.repository import Gio, GLib # noqa: E402 + +NAME = "org.freedesktop.login1" +ROOT = "/org/freedesktop/login1" +INTERFACE = NAME + ".Manager" +INTROSPECTION = """ + + + + + + + + + +""" + + +class LoginManager: + def __init__(self, bus, directory): + self.bus = bus + self.directory = Path(directory) + self.request = self.directory / "steam-sleep" + self.state = self.directory / "steam-sleep-state" + self.pending = None + self.timeout = None + info = Gio.DBusNodeInfo.new_for_xml(INTROSPECTION).interfaces[0] + self.registration = bus.register_object(ROOT, info, self.method, self.property, None) + self.monitor = Gio.File.new_for_path(str(self.directory)).monitor_directory(Gio.FileMonitorFlags.NONE, None) + self.monitor.connect("changed", self.changed) + + def property(self, connection, sender, path, interface, name): + if name == "PreparingForSleep": + return GLib.Variant("b", self.pending is not None) + return None + + def notify(self, sleeping): + self.bus.emit_signal(None, ROOT, INTERFACE, "PrepareForSleep", GLib.Variant("(b)", (sleeping,))) + self.bus.emit_signal(None, ROOT, "org.freedesktop.DBus.Properties", "PropertiesChanged", + GLib.Variant("(sa{sv}as)", (INTERFACE, { + "PreparingForSleep": GLib.Variant("b", sleeping), + }, []))) + self.bus.flush_sync(None) + print("== login1: " + ("pausing the session" if sleeping else "session resumed"), flush=True) + + def method(self, connection, sender, path, interface, name, args, reply): + if name == "CanSuspend": + reply.return_value(GLib.Variant("(s)", ("yes",))) + elif name in ("Suspend", "SuspendWithFlags"): + if self.pending: + reply.return_dbus_error(NAME + ".OperationInProgress", "The session is already pausing") + return + self.pending = uuid.uuid4().hex + self.notify(True) + # Complete the D-Bus call before the host can freeze this service and + # its caller. Publishing on the next main-loop turn avoids that race. + reply.return_value(None) + self.bus.flush_sync(None) + GLib.idle_add(self.publish) + + def publish(self): + try: + staged = self.request.with_suffix(".tmp") + staged.write_text(self.pending + "\n") + staged.replace(self.request) + self.timeout = GLib.timeout_add_seconds(5, self.check_ack) + except OSError as error: + print("== login1: cannot request pause: " + str(error), file=sys.stderr) + self.resume() + return False + + def changed(self, monitor, file, other, event): + if file.get_basename() == self.state.name or (other and other.get_basename() == self.state.name): + self.check_state() + + def read_state(self): + try: + return self.state.read_text().strip() + except OSError: + return "" + + def check_state(self): + if self.pending and self.read_state() == self.pending + ":awake": + self.resume() + + def check_ack(self): + self.timeout = None + if self.pending and self.read_state() != self.pending + ":paused": + # A missing host or a failed freeze must not strand Steam in black. + self.request.unlink(missing_ok=True) + self.resume() + return False + + def resume(self): + if self.pending is None: + return + self.pending = None + if self.timeout is not None: + GLib.source_remove(self.timeout) + self.timeout = None + self.notify(False) + + +def main(): + directory = os.environ.get("BL_LAUNCH_DIR") + if not directory or not Path(directory).is_dir(): + sys.exit("bannerlator-login1: no DroidDeck session directory") + ready = Path(directory) / "steam-sleep-ready" + ready.unlink(missing_ok=True) + loop = GLib.MainLoop() + manager = [] + + def connected(bus, name): + manager.append(LoginManager(bus, directory)) + + def acquired(bus, name): + ready.write_text("ready\n") + + def lost(bus, name): + ready.unlink(missing_ok=True) + loop.quit() + + owner = Gio.bus_own_name(Gio.BusType.SYSTEM, NAME, Gio.BusNameOwnerFlags.NONE, connected, acquired, lost) + try: + loop.run() + finally: + ready.unlink(missing_ok=True) + Gio.bus_unown_name(owner) + + +if __name__ == "__main__": + main() diff --git a/tools/linuxfs/overlay/usr/local/bin/bannerlator-session b/tools/linuxfs/overlay/usr/local/bin/bannerlator-session index 4a40493159..532e1d0986 100755 --- a/tools/linuxfs/overlay/usr/local/bin/bannerlator-session +++ b/tools/linuxfs/overlay/usr/local/bin/bannerlator-session @@ -564,11 +564,29 @@ BUSCONF bannerlator-netmanager & netmanager=$! echo "== network: system bus up, NetworkManager stand-in running" + # Steam blanks its main UI before calling login1.Suspend. Without the + # matching resume notification it stays black although the menus work. + # Own the name before Steam constructs its login1 proxy at startup. + rm -f "$BL_LAUNCH_DIR/steam-sleep-ready" + bannerlator-login1 & + login_manager=$! + for ((_i = 0; _i < 50; _i++)); do + [ -f "$BL_LAUNCH_DIR/steam-sleep-ready" ] && break + kill -0 "$login_manager" 2>/dev/null || break + nap 0.1 + done + if [ ! -f "$BL_LAUNCH_DIR/steam-sleep-ready" ]; then + echo "== sleep: login1 did not start; refusing a client that cannot resume" + exit 69 + fi + echo "== sleep: login1 ready, Android session pause/resume available" else echo "== network: the system bus did not come up; the client will show no connection" + exit 69 fi else echo "== network: no dbus-daemon or netmanager in this runtime; the client will show no connection" + exit 69 fi export STEAM_RUNTIME=1 diff --git a/tools/tests/test_login1.py b/tools/tests/test_login1.py new file mode 100644 index 0000000000..168cbd7af1 --- /dev/null +++ b/tools/tests/test_login1.py @@ -0,0 +1,122 @@ +"""Real login1 sleep handshakes; run with dbus-run-session and python3-gi.""" +import os +from pathlib import Path +import subprocess +import signal +import tempfile +import time +import unittest + +try: + import gi + gi.require_version("Gio", "2.0") + from gi.repository import Gio, GLib +except ImportError: + Gio = GLib = None + +SCRIPT = Path(__file__).resolve().parents[1] / "linuxfs/overlay/usr/local/bin/bannerlator-login1" +NAME = "org.freedesktop.login1" +ROOT = "/org/freedesktop/login1" +IFACE = NAME + ".Manager" + + +@unittest.skipUnless(Gio and os.environ.get("DBUS_SESSION_BUS_ADDRESS"), "requires dbus-run-session and PyGObject") +class SleepHandshakeTest(unittest.TestCase): + def setUp(self): + self.directory = tempfile.TemporaryDirectory() + self.dir = Path(self.directory.name) + self.signals = [] + self.bus = Gio.DBusConnection.new_for_address_sync( + os.environ["DBUS_SESSION_BUS_ADDRESS"], + Gio.DBusConnectionFlags.AUTHENTICATION_CLIENT | Gio.DBusConnectionFlags.MESSAGE_BUS_CONNECTION, + None, None) + self.subscription = self.bus.signal_subscribe( + NAME, IFACE, "PrepareForSleep", ROOT, None, Gio.DBusSignalFlags.NONE, + lambda bus, sender, path, interface, name, body: self.signals.append(body.unpack()[0])) + env = dict(os.environ, BL_LAUNCH_DIR=str(self.dir), + DBUS_SYSTEM_BUS_ADDRESS=os.environ["DBUS_SESSION_BUS_ADDRESS"]) + self.process = subprocess.Popen(["/usr/bin/python3", str(SCRIPT)], env=env, + stdout=subprocess.DEVNULL) + self.wait_for(lambda: (self.dir / "steam-sleep-ready").exists()) + + def tearDown(self): + os.kill(self.process.pid, signal.SIGCONT) + self.process.terminate() + self.process.wait(timeout=5) + self.bus.signal_unsubscribe(self.subscription) + self.bus.close_sync(None) + self.directory.cleanup() + + def wait_for(self, condition, timeout=8): + deadline = time.monotonic() + timeout + while not condition(): + while GLib.MainContext.default().pending(): + GLib.MainContext.default().iteration(False) + if time.monotonic() >= deadline: + self.fail("timed out waiting for login1") + time.sleep(0.01) + + def call(self, interface, method, args=None): + return self.bus.call_sync(NAME, ROOT, interface, method, args, None, + Gio.DBusCallFlags.NONE, 2000, None).unpack() + + def preparing(self): + return self.call("org.freedesktop.DBus.Properties", "Get", + GLib.Variant("(ss)", (IFACE, "PreparingForSleep")))[0] + + def suspend(self): + self.call(IFACE, "Suspend", GLib.Variant("(b)", (True,))) + self.wait_for(lambda: (self.dir / "steam-sleep").exists()) + self.wait_for(lambda: self.signals == [True]) + return (self.dir / "steam-sleep").read_text().strip() + + def state(self, token, state): + staged = self.dir / "steam-sleep-state.tmp" + staged.write_text(token + ":" + state + "\n") + staged.replace(self.dir / "steam-sleep-state") + + def test_resume_and_second_sleep(self): + self.assertEqual(self.call(IFACE, "CanSuspend"), ("yes",)) + token = self.suspend() + self.assertTrue(self.preparing()) + self.state(token, "paused") + self.state("0" * 32, "awake") # stale session acknowledgments cannot wake this one + time.sleep(0.1) + self.assertTrue(self.preparing()) + self.state(token, "awake") + self.wait_for(lambda: self.signals == [True, False]) + self.assertFalse(self.preparing()) + self.signals.clear() + second = self.suspend() + self.assertNotEqual(token, second) + self.state(second, "awake") + self.wait_for(lambda: self.signals == [True, False]) + + def test_missing_host_recovers(self): + self.suspend() + self.wait_for(lambda: self.signals == [True, False]) + self.assertFalse(self.preparing()) + self.assertFalse((self.dir / "steam-sleep").exists()) + + def test_wake_after_service_was_frozen_past_ack_timeout(self): + token = self.suspend() + self.state(token, "paused") + os.kill(self.process.pid, signal.SIGSTOP) + time.sleep(6) + self.state(token, "awake") + os.kill(self.process.pid, signal.SIGCONT) + self.wait_for(lambda: self.signals == [True, False]) + self.assertFalse(self.preparing()) + + def test_failed_pause_recovers_and_duplicate_is_rejected(self): + token = self.suspend() + with self.assertRaises(GLib.Error): + self.call(IFACE, "Suspend", GLib.Variant("(b)", (True,))) + self.state(token, "awake") + self.wait_for(lambda: self.signals == [True, False]) + with self.assertRaises(GLib.Error): + self.call(IFACE, "PowerOff", GLib.Variant("(b)", (True,))) + + +if __name__ == "__main__": + unittest.main()