From bf9435cd36baa6c3f20c9607c6958655cb5dc5cf Mon Sep 17 00:00:00 2001
From: Kurt Himebauch <136133082+xXJSONDeruloXx@users.noreply.github.com>
Date: Sun, 1 Nov 2026 16:13:52 -0500
Subject: [PATCH] feat: KDE desktop on the bottom screen beside the session
(#1966)
* feat: KDE desktop as a bottom-screen mode beside the top-screen session
* test: bottom-desktop launch test sets DISPLAY instead of inheriting it
* fix: drop the bottom desktop's launch when the session stops while preparing it
* fix: bottom desktop restarts on a fresh surface, trackpad/touch toggle, loading throbber, DroidDeck's display driver
* fix: bottom desktop pauses with the session and opens the keyboard for a tapped text field
* fix: no bottom desktop guest starts or keeps running unfrozen while the session is paused
* fix: bottom desktop treats a freeze in progress as paused
* fix: only the session that began a freeze clears its pausing flag
* fix: bottom desktop launch is stored and cleared only for its own session generation
* fix: a stopped session tears down the bottom desktop it started even after a newer launch is prepared
* fix: a new session's bottom desktop replaces one an earlier session left running
* fix: release the bottom desktop's keyboard watcher when its compositor dies
* fix: bottom desktop starts its guest only for the launch its compositor was attached for
* fix: bottom desktop ignores compositor replies to an earlier session's attach
---
app/src/main/AndroidManifest.xml | 5 +
.../main/java/com/droiddeck/launcher/App.kt | 2 +-
.../com/droiddeck/launcher/SessionActivity.kt | 30 +-
.../com/droiddeck/launcher/input/GuestKeys.kt | 31 ++
.../launcher/input/SecondScreenMode.kt | 8 +-
.../launcher/session/BottomDesktop.kt | 353 ++++++++++++++++++
.../launcher/session/SessionFiles.kt | 1 +
.../launcher/session/SessionPrefs.kt | 7 +
.../launcher/session/SessionService.kt | 14 +-
.../launcher/session/SessionState.kt | 2 +
.../launcher/ui/BottomDesktopPanel.kt | 345 +++++++++++++++++
.../launcher/ui/BottomDesktopStatus.kt | 55 +++
.../launcher/ui/DeckControlsPanel.kt | 9 +-
.../launcher/ui/SecondScreenPresentation.kt | 10 +-
.../droiddeck/launcher/ui/SessionOverlay.kt | 6 +-
.../wayland/BottomDesktopCompositorService.kt | 117 ++++++
.../main/res/drawable/ic_bottom_keyboard.xml | 5 +
app/src/main/res/drawable/ic_bottom_mouse.xml | 5 +
app/src/main/res/drawable/ic_bottom_touch.xml | 5 +
app/src/main/res/values/strings.xml | 11 +
.../launcher/input/SecondScreenModeTest.kt | 11 +
tools/linuxfs/desktop/droiddeck-desktop | 2 +-
.../usr/local/bin/droiddeck-bottom-desktop | 51 +++
.../overlay/usr/local/bin/droiddeck-ime | 2 +-
.../usr/local/bin/droiddeck-steam-launch | 8 +
tools/tests/test_steam_desktop_launch.py | 24 ++
26 files changed, 1083 insertions(+), 36 deletions(-)
create mode 100644 app/src/main/java/com/droiddeck/launcher/input/GuestKeys.kt
create mode 100644 app/src/main/java/com/droiddeck/launcher/session/BottomDesktop.kt
create mode 100644 app/src/main/java/com/droiddeck/launcher/ui/BottomDesktopPanel.kt
create mode 100644 app/src/main/java/com/droiddeck/launcher/ui/BottomDesktopStatus.kt
create mode 100644 app/src/main/java/com/droiddeck/launcher/wayland/BottomDesktopCompositorService.kt
create mode 100644 app/src/main/res/drawable/ic_bottom_keyboard.xml
create mode 100644 app/src/main/res/drawable/ic_bottom_mouse.xml
create mode 100644 app/src/main/res/drawable/ic_bottom_touch.xml
create mode 100755 tools/linuxfs/overlay/usr/local/bin/droiddeck-bottom-desktop
diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index 7d064b1983..e5b17b50e3 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -300,6 +300,11 @@
android:name=".session.SessionService"
android:exported="false"
android:stopWithTask="false" />
+
+
diff --git a/app/src/main/java/com/droiddeck/launcher/App.kt b/app/src/main/java/com/droiddeck/launcher/App.kt
index 7bf90d6352..de94c41a5e 100644
--- a/app/src/main/java/com/droiddeck/launcher/App.kt
+++ b/app/src/main/java/com/droiddeck/launcher/App.kt
@@ -37,7 +37,7 @@ class App : Application() {
return
}
if (process == "$packageName:vr_recovery" || process == "$packageName:rgb_diagnostic" ||
- process == "$packageName:shortcuts_sync") return
+ process == "$packageName:shortcuts_sync" || process == "$packageName:bottom_desktop") return
CrashHandler.install(this)
com.droiddeck.launcher.core.SteamIntegration.syncShortcutsListing(this)
com.droiddeck.launcher.session.QuestExperimental.initialize(this)
diff --git a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt
index 7ba6f5243d..3e8809134e 100644
--- a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt
+++ b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt
@@ -67,7 +67,6 @@ import com.droiddeck.launcher.gpu.ScreenEffectLooks
import com.droiddeck.launcher.gpu.ScreenEffects
import com.droiddeck.launcher.gpu.Lossless
import com.droiddeck.launcher.gpu.TurnipDriver
-import com.droiddeck.launcher.input.EvdevKeys
import com.droiddeck.launcher.input.HomeGuideInput
import com.droiddeck.launcher.input.InputSpace
import com.droiddeck.launcher.input.KeyboardHost
@@ -1198,6 +1197,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback {
fexPreset = fexPreset,
secondScreenMode = secondScreenMode,
dashboardAvailable = bottomPages().isNotEmpty(),
+ desktopAvailable = com.droiddeck.launcher.session.BottomDesktop.available(),
secondScreenDisplays = secondScreenDisplays,
selectedSecondScreenDisplay = selectedSecondScreenDisplay,
onHud = { on -> SessionPrefs.setHudEnabled(this@SessionActivity, on); hudOn = on; hud.refresh() },
@@ -2613,27 +2613,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback {
if (CompositorHost.isStarted && event.keyCode != KeyEvent.KEYCODE_BACK && !fromController) {
val down = event.action == KeyEvent.ACTION_DOWN
if (down && event.repeatCount > 0) return true
- if (down || event.action == KeyEvent.ACTION_UP) {
- var evdev = EvdevKeys.fromKeyCode(event.keyCode)
- val ch = event.unicodeChar
- val plain = if (ch > 0) EvdevKeys.unshiftedChar(ch) else 0
- if (evdev <= 0 && ch > 0) {
- val code = EvdevKeys.fromKeyCode(EvdevKeys.keycodeForChar(if (plain != 0) plain else ch))
- if (code > 0) evdev = code
- }
- val shiftEvdev = if (evdev > 0 && plain != 0 && event.deviceId <= 0) 42 else 0
- if (evdev <= 0 && event.scanCode > 0) evdev = event.scanCode
- if (evdev > 0) {
- if (down) {
- if (shiftEvdev != 0) sendGuestKey(shiftEvdev, true)
- sendGuestKey(evdev, true)
- } else {
- sendGuestKey(evdev, false)
- if (shiftEvdev != 0) sendGuestKey(shiftEvdev, false)
- }
- return true
- }
- }
+ if (com.droiddeck.launcher.input.GuestKeys.send(event, ::sendGuestKey)) return true
}
return super.dispatchKeyEvent(event)
}
@@ -3083,7 +3063,8 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback {
if (secondScreenDisplays.none { it.id == target.displayId }) return
SessionState.secondScreenAutoOpened = true
selectedSecondScreenDisplay = target.displayId
- selectSecondScreenMode(SecondScreenMode.opening(SessionPrefs.secondScreenPanel(this), SessionState.deckPad, bottomPages().isNotEmpty()))
+ selectSecondScreenMode(SecondScreenMode.opening(SessionPrefs.secondScreenPanel(this), SessionState.deckPad, bottomPages().isNotEmpty(),
+ com.droiddeck.launcher.session.BottomDesktop.available()))
dualControlsProvisional = ::loading.isInitialized && loading.visible
}
@@ -3091,7 +3072,8 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback {
if (!dualControlsProvisional || pipUi || !started || (::loading.isInitialized && loading.visible)) return
dualControlsProvisional = false
if (secondScreenMode == SecondScreenMode.NONE) return
- val wanted = SecondScreenMode.opening(SessionPrefs.secondScreenPanel(this), SessionState.deckPad, bottomPages().isNotEmpty())
+ val wanted = SecondScreenMode.opening(SessionPrefs.secondScreenPanel(this), SessionState.deckPad, bottomPages().isNotEmpty(),
+ com.droiddeck.launcher.session.BottomDesktop.available())
if (wanted != secondScreenMode) selectSecondScreenMode(wanted) else secondScreenPresentation?.retryTerminal()
}
diff --git a/app/src/main/java/com/droiddeck/launcher/input/GuestKeys.kt b/app/src/main/java/com/droiddeck/launcher/input/GuestKeys.kt
new file mode 100644
index 0000000000..fbc3739cd9
--- /dev/null
+++ b/app/src/main/java/com/droiddeck/launcher/input/GuestKeys.kt
@@ -0,0 +1,31 @@
+package com.droiddeck.launcher.input
+
+import android.view.KeyEvent
+
+object GuestKeys {
+ /** Sends [event] as evdev presses, with Shift around characters typed by a keyboard that has no Shift key; false when it has no evdev code. */
+ fun send(event: KeyEvent, sendKey: (code: Int, down: Boolean) -> Unit): Boolean {
+ val down = event.action == KeyEvent.ACTION_DOWN
+ if (!down && event.action != KeyEvent.ACTION_UP) return false
+ var evdev = EvdevKeys.fromKeyCode(event.keyCode)
+ val ch = event.unicodeChar
+ val plain = if (ch > 0) EvdevKeys.unshiftedChar(ch) else 0
+ if (evdev <= 0 && ch > 0) {
+ val code = EvdevKeys.fromKeyCode(EvdevKeys.keycodeForChar(if (plain != 0) plain else ch))
+ if (code > 0) evdev = code
+ }
+ val shiftEvdev = if (evdev > 0 && plain != 0 && event.deviceId <= 0) KEY_LEFTSHIFT else 0
+ if (evdev <= 0 && event.scanCode > 0) evdev = event.scanCode
+ if (evdev <= 0) return false
+ if (down) {
+ if (shiftEvdev != 0) sendKey(shiftEvdev, true)
+ sendKey(evdev, true)
+ } else {
+ sendKey(evdev, false)
+ if (shiftEvdev != 0) sendKey(shiftEvdev, false)
+ }
+ return true
+ }
+
+ private const val KEY_LEFTSHIFT = 42
+}
diff --git a/app/src/main/java/com/droiddeck/launcher/input/SecondScreenMode.kt b/app/src/main/java/com/droiddeck/launcher/input/SecondScreenMode.kt
index f030565ff5..38f7f76d95 100644
--- a/app/src/main/java/com/droiddeck/launcher/input/SecondScreenMode.kt
+++ b/app/src/main/java/com/droiddeck/launcher/input/SecondScreenMode.kt
@@ -10,12 +10,14 @@ enum class SecondScreenMode(val id: String, @StringRes val label: Int) {
KEYBOARD_TRACKPAD("keyboard-trackpad", R.string.second_mode_keyboard_trackpad),
TERMINAL("terminal", R.string.second_mode_terminal),
DECK_CONTROLS("deck-controls", R.string.second_mode_deck_controls),
- DASHBOARD("dashboard", R.string.second_mode_dashboard);
+ DASHBOARD("dashboard", R.string.second_mode_dashboard),
+ DESKTOP("desktop", R.string.second_mode_desktop);
companion object {
- fun opening(remembered: String?, deckPad: Boolean, dashboard: Boolean = false): SecondScreenMode {
+ fun opening(remembered: String?, deckPad: Boolean, dashboard: Boolean = false, desktop: Boolean = false): SecondScreenMode {
entries.firstOrNull {
- it != NONE && it.id == remembered && (it != DECK_CONTROLS || deckPad) && (it != DASHBOARD || dashboard)
+ it != NONE && it.id == remembered && (it != DECK_CONTROLS || deckPad) && (it != DASHBOARD || dashboard) &&
+ (it != DESKTOP || desktop)
}?.let { return it }
// No pick yet: the dashboard. A pick that can't open right now keeps the old fallback.
val picked = entries.any { it != NONE && it.id == remembered }
diff --git a/app/src/main/java/com/droiddeck/launcher/session/BottomDesktop.kt b/app/src/main/java/com/droiddeck/launcher/session/BottomDesktop.kt
new file mode 100644
index 0000000000..923ee29996
--- /dev/null
+++ b/app/src/main/java/com/droiddeck/launcher/session/BottomDesktop.kt
@@ -0,0 +1,353 @@
+package com.droiddeck.launcher.session
+
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.content.ServiceConnection
+import android.os.Bundle
+import android.os.Environment
+import android.os.Handler
+import android.os.IBinder
+import android.os.Looper
+import android.os.Message
+import android.os.Messenger
+import android.util.Log
+import android.view.Surface
+import com.droiddeck.launcher.core.HostProcess
+import com.droiddeck.launcher.runtime.DesktopCatalog
+import com.droiddeck.launcher.runtime.LinuxRuntime
+import com.droiddeck.launcher.wayland.BottomDesktopCompositorService as Comp
+import java.io.File
+
+/**
+ * KDE Plasma on the bottom screen while the session keeps the top one: its own compositor process
+ * ([Comp]) and a second guest started with the session's environment, like the bottom-screen terminal.
+ */
+object BottomDesktop {
+ private const val TAG = "BottomDesktop"
+ const val SCRIPT = "/usr/local/bin/droiddeck-bottom-desktop"
+ private const val TARGET_SHORT_SIDE = 720f
+
+ enum class State { OFF, STARTING, RUNNING, ENDED, FAILED }
+
+ private class Launch(
+ val guest: List,
+ val binds: List,
+ val sessionRoot: File,
+ val hostEnvironment: Array,
+ val root: File,
+ val sessionDir: File,
+ val generation: Int,
+ val installed: Boolean,
+ )
+
+ @Volatile private var launch: Launch? = null
+ private val launchLock = Any()
+ private val main = Handler(Looper.getMainLooper())
+ private val listeners = LinkedHashSet<() -> Unit>()
+
+ @Volatile var state = State.OFF
+ private set
+ private var onTextInput: ((Boolean) -> Unit)? = null
+ private var imeWatcher: android.os.FileObserver? = null
+
+ private var appContext: Context? = null
+ private var service: Messenger? = null
+ private var binding: ServiceConnection? = null
+ private var pendingAttach: Message? = null
+ /** The desktop guest's proot: -1 when there is none, 0 while it is being started. */
+ @Volatile private var guestPid = -1
+
+ /** The proot to freeze with the session when it pauses. */
+ val suspendPid: Int get() = guestPid
+ private var guestGeneration = 0
+ private var outputSize = 0 to 0
+ private var cursorShown = false
+ /** The session generation whose launch the running compositor and guest belong to; -1 when none. */
+ private var owner = -1
+
+ private val replies = Messenger(object : Handler(Looper.getMainLooper()) {
+ override fun handleMessage(msg: Message) {
+ if (msg.arg1 != owner) return
+ when (msg.what) {
+ Comp.MSG_ATTACHED -> {
+ service?.let { send(it, Message.obtain(null, Comp.MSG_CURSOR, if (cursorShown) 1 else 0, 0)) }
+ if (guestPid < 0 && state == State.STARTING) startGuest()
+ }
+ Comp.MSG_FIRST_FRAME -> if (state == State.STARTING) setState(State.RUNNING)
+ }
+ }
+ })
+
+ fun prepare(
+ guest: List,
+ binds: List,
+ sessionRoot: File,
+ hostEnvironment: Array,
+ root: File,
+ sessionDir: File,
+ generation: Int,
+ stillCurrent: () -> Boolean,
+ ) {
+ val prepared = Launch(ArrayList(guest), ArrayList(binds), sessionRoot, hostEnvironment.copyOf(), root, sessionDir, generation,
+ DesktopCatalog.desktopInstalled(root))
+ synchronized(launchLock) { if (stillCurrent()) launch = prepared }
+ }
+
+ fun available(): Boolean =
+ launch?.installed == true && SessionState.running && SessionState.mode != SessionService.MODE_DESKTOP
+
+ /**
+ * The desktop renders below the panel's resolution: about 720 pixels on the short side keeps
+ * Plasma's text big enough to touch and its software rendering cheap. A running desktop keeps its size.
+ */
+ fun outputSizeFor(width: Int, height: Int): Pair {
+ if ((state == State.STARTING || state == State.RUNNING) && outputSize.first > 0) return outputSize
+ if (width <= 0 || height <= 0) return 0 to 0
+ val scale = maxOf(1f, Math.round(minOf(width, height) / TARGET_SHORT_SIDE * 2f) / 2f)
+ return ((width / scale).toInt() and 1.inv()) to ((height / scale).toInt() and 1.inv())
+ }
+
+ fun addListener(listener: () -> Unit) { listeners.add(listener) }
+
+ fun removeListener(listener: () -> Unit) { listeners.remove(listener) }
+
+ /** Called on the main thread when a text field in the desktop gains or loses focus (droiddeck-ime's report). */
+ fun setTextInputListener(listener: ((Boolean) -> Unit)?) { onTextInput = listener }
+
+ private fun watchIme(dir: File) {
+ imeWatcher?.stopWatching()
+ dir.deleteRecursively()
+ dir.mkdirs()
+ @Suppress("DEPRECATION")
+ imeWatcher = object : android.os.FileObserver(dir.path, MOVED_TO or CLOSE_WRITE) {
+ override fun onEvent(event: Int, path: String?) {
+ if (path != "ime.json") return
+ val focused = runCatching { org.json.JSONObject(File(dir, path).readText()).optBoolean("textField") }
+ .getOrNull() ?: return
+ main.post { if (imeWatcher === this) onTextInput?.invoke(focused) }
+ }
+ }.also { it.startWatching() }
+ }
+
+ private fun setState(next: State) {
+ if (Looper.myLooper() != Looper.getMainLooper()) { main.post { setState(next) }; return }
+ if (state == next) return
+ Log.i(TAG, "state $state -> $next")
+ state = next
+ listeners.toList().forEach { it() }
+ }
+
+ fun attach(context: Context, surface: Surface, width: Int, height: Int, refreshHz: Float) {
+ val current = launch
+ if (current == null || !SessionState.running) {
+ setState(State.FAILED)
+ return
+ }
+ if (owner != -1 && owner != current.generation) stop(context, owner)
+ appContext = context.applicationContext
+ owner = current.generation
+ outputSize = width to height
+ val dir = File(current.sessionDir, "bottom-desktop").apply { mkdirs() }
+ val msg = Message.obtain(null, Comp.MSG_ATTACH).apply {
+ arg1 = owner
+ obj = surface
+ replyTo = replies
+ data = Bundle().apply {
+ putString(Comp.KEY_RUNTIME_DIR, runtimeDir(context).path)
+ putInt(Comp.KEY_WIDTH, width)
+ putInt(Comp.KEY_HEIGHT, height)
+ putFloat(Comp.KEY_REFRESH, refreshHz)
+ putString(Comp.KEY_LOG, File(dir, "wayland.log").path)
+ }
+ }
+ if (state == State.OFF || state == State.ENDED || state == State.FAILED) setState(State.STARTING)
+ val target = service
+ if (target != null) send(target, msg) else {
+ pendingAttach = msg
+ bind(context.applicationContext)
+ }
+ }
+
+ fun detach() {
+ pendingAttach = null
+ service?.let { send(it, Message.obtain(null, Comp.MSG_DETACH)) }
+ }
+
+ fun sendTouch(action: Int, pointerId: Int, x: Int, y: Int) {
+ val target = service ?: return
+ send(target, Message.obtain(null, Comp.MSG_TOUCH, (pointerId shl 8) or (action and 0xff),
+ (x.coerceIn(0, 0xffff) shl 16) or y.coerceIn(0, 0xffff)))
+ }
+
+ fun sendPointer(x: Int, y: Int) {
+ val target = service ?: return
+ send(target, Message.obtain(null, Comp.MSG_POINTER, x, y))
+ }
+
+ /** Button (3), wheel (4) and smooth-scroll (12) input, as `WaylandCompositor.nativeSendSceneInput` takes it. */
+ fun sendScene(type: Int, a: Int, b: Int = 0) {
+ val target = service ?: return
+ send(target, Message.obtain(null, Comp.MSG_SCENE, type, a).apply {
+ if (b != 0) data = Bundle().apply { putInt(Comp.KEY_B, b) }
+ })
+ }
+
+ fun showCursor(on: Boolean) {
+ cursorShown = on
+ service?.let { send(it, Message.obtain(null, Comp.MSG_CURSOR, if (on) 1 else 0, 0)) }
+ }
+
+ /** False when the next attach starts a new compositor process, which needs a surface no earlier one used. */
+ val connected: Boolean get() = service != null
+
+ fun sendKey(evdev: Int, down: Boolean) {
+ val target = service ?: return
+ send(target, Message.obtain(null, Comp.MSG_KEY, evdev, if (down) 1 else 0))
+ }
+
+ fun sendText(text: String) {
+ val target = service ?: return
+ send(target, Message.obtain(null, Comp.MSG_TEXT).apply { data = Bundle().apply { putString(Comp.KEY_TEXT, text) } })
+ }
+
+ fun stop(context: Context, generation: Int? = null) {
+ if (Looper.myLooper() != Looper.getMainLooper()) { main.post { stop(context, generation) }; return }
+ synchronized(launchLock) {
+ if (generation != null && launch?.generation == generation) launch = null
+ }
+ // A newer session may already have prepared its launch; only the desktop the stopped session started goes.
+ if (generation != null && owner != generation) return
+ owner = -1
+ val pid = guestPid
+ guestPid = -1
+ guestGeneration++
+ if (pid > 1) SessionService.stopTerminalProcess(context, pid)
+ service?.let { send(it, Message.obtain(null, Comp.MSG_STOP)) }
+ binding?.let { runCatching { context.applicationContext.unbindService(it) } }
+ binding = null
+ service = null
+ pendingAttach = null
+ imeWatcher?.stopWatching()
+ imeWatcher = null
+ setState(State.OFF)
+ }
+
+ private fun bind(context: Context) {
+ if (binding != null) return
+ val connection = object : ServiceConnection {
+ override fun onServiceConnected(name: ComponentName?, binder: IBinder?) {
+ if (binding !== this || binder == null) return
+ val messenger = Messenger(binder)
+ service = messenger
+ pendingAttach?.let { send(messenger, it) }
+ pendingAttach = null
+ }
+
+ override fun onServiceDisconnected(name: ComponentName?) {
+ if (binding !== this) return
+ Log.w(TAG, "the desktop's compositor process died")
+ service = null
+ binding = null
+ runCatching { context.unbindService(this) }
+ val pid = guestPid
+ guestPid = -1
+ guestGeneration++
+ if (pid > 1) SessionService.stopTerminalProcess(context, pid)
+ imeWatcher?.stopWatching()
+ imeWatcher = null
+ owner = -1
+ setState(State.FAILED)
+ }
+ }
+ binding = connection
+ val bound = runCatching {
+ context.bindService(Intent(context, Comp::class.java), connection,
+ Context.BIND_AUTO_CREATE or Context.BIND_IMPORTANT)
+ }.getOrDefault(false)
+ if (!bound) {
+ Log.e(TAG, "could not bind the desktop's compositor")
+ binding = null
+ setState(State.FAILED)
+ }
+ }
+
+ private fun send(target: Messenger, msg: Message) {
+ runCatching { target.send(msg) }.onFailure { Log.w(TAG, "compositor message ${msg.what} not delivered", it) }
+ }
+
+ private fun runtimeDir(context: Context) = File(context.filesDir, ".wayland-rt-bottom")
+
+ private fun startGuest() {
+ val context = appContext ?: return
+ val current = launch
+ if (current == null || !SessionState.running || current.generation != owner) {
+ setState(State.FAILED)
+ return
+ }
+ // A freeze collects its helpers once, when it begins; a guest started after that would run on unfrozen.
+ if (SessionState.suspended || SessionState.suspending) {
+ setState(State.OFF)
+ return
+ }
+ val generation = ++guestGeneration
+ guestPid = 0
+ val (width, height) = outputSize
+ service?.let { send(it, Message.obtain(null, Comp.MSG_NEW_GUEST)) }
+ Thread({
+ if (!DesktopCatalog.desktopInstalled(current.root)) {
+ Log.e(TAG, "the desktop package is not installed")
+ main.post { if (generation == guestGeneration) { guestPid = -1; setState(State.FAILED) } }
+ return@Thread
+ }
+ val dir = File(current.sessionDir, "bottom-desktop").apply { mkdirs() }
+ val runtime = runtimeDir(context).apply { mkdirs() }
+ val imeDir = File(current.sessionRoot, "bottom-desktop-ime")
+ main.post { if (generation == guestGeneration) watchIme(imeDir) }
+ val binds = LinuxRuntime.binds(context, current.sessionRoot, runtime, Environment.getExternalStorageDirectory(), current.binds)
+ val guest = ArrayList(current.guest).apply {
+ add("BL_WIDTH=$width")
+ add("BL_HEIGHT=$height")
+ add("BL_DEBUG_DIR=" + dir.path)
+ add("BL_TOP_SESSION=" + SessionState.mode)
+ add("BL_IME_DIR=" + imeDir.path)
+ add(SCRIPT)
+ }
+ val command = LinuxRuntime.commandWithBinds(context, current.root, binds, guest)
+ val line = command.joinToString(" ") { it.replace("\\", "\\\\").replace(" ", "\\ ") }
+ val pid = HostProcess.start(line, current.hostEnvironment, current.root, { status ->
+ main.post {
+ if (generation != guestGeneration) return@post
+ Log.i(TAG, "the desktop ended ($status)")
+ SessionService.terminalProcessExited(context, guestPid)
+ guestPid = -1
+ guestGeneration++
+ setState(if (state == State.RUNNING || status == 0) State.ENDED else State.FAILED)
+ }
+ }, null, File(dir, "proot.log"))
+ main.post {
+ if (generation != guestGeneration || launch !== current) {
+ if (pid > 1) SessionService.stopTerminalProcess(context, pid)
+ if (generation == guestGeneration) guestPid = -1
+ return@post
+ }
+ if (pid <= 1) {
+ guestPid = -1
+ Log.e(TAG, "the desktop's guest did not start")
+ setState(State.FAILED)
+ return@post
+ }
+ if (SessionState.suspended || SessionState.suspending) {
+ SessionService.stopTerminalProcess(context, pid)
+ guestPid = -1
+ guestGeneration++
+ setState(State.OFF)
+ return@post
+ }
+ guestPid = pid
+ SessionService.registerTerminalProcess(context, pid)
+ Log.i(TAG, "desktop guest pid $pid at ${width}x$height")
+ }
+ }, "bottom-desktop-start").start()
+ }
+}
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 bcb13d14f8..056fc205af 100644
--- a/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt
+++ b/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt
@@ -22,6 +22,7 @@ object SessionFiles {
internal val DESKTOP_FILES = arrayOf(
"usr/local/bin/droiddeck-desktop" to "usr/local/bin/droiddeck-desktop",
+ "usr/local/bin/droiddeck-bottom-desktop" to "usr/local/bin/droiddeck-bottom-desktop",
"usr/local/bin/droiddeck-gpu" to "usr/local/bin/droiddeck-gpu",
"usr/local/bin/droiddeck-desktop-gpu" to "usr/local/bin/droiddeck-desktop-gpu",
"usr/local/bin/droiddeck-desktop-window-rules" to "usr/local/bin/droiddeck-desktop-window-rules",
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 d49230f503..9ed3b6d275 100644
--- a/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt
+++ b/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt
@@ -100,6 +100,13 @@ object SessionPrefs {
prefs(context).edit().putString("secondScreenPanel", mode).apply()
}
+ /** The bottom-screen desktop takes touch as a trackpad unless the user switched it to direct touch. */
+ fun bottomDesktopDirectTouch(context: Context): Boolean = prefs(context).getBoolean("bottomDesktopDirectTouch", false)
+
+ fun setBottomDesktopDirectTouch(context: Context, on: Boolean) {
+ prefs(context).edit().putBoolean("bottomDesktopDirectTouch", on).apply()
+ }
+
fun statsStrip(context: Context): String? = prefs(context).getString("statsStrip", null)
fun setStatsStrip(context: Context, id: String) {
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 09bedc4e36..6a631341a4 100644
--- a/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt
+++ b/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt
@@ -577,6 +577,7 @@ class SessionService : Service() {
add("-c")
add("cd \"\$HOME\" && exec /bin/bash -i")
}
+ val desktopGuest = ArrayList(guest)
guest.add(LinuxRuntime.SESSION_SCRIPT)
guest.add(SessionState.mode)
if (SessionState.mode == MODE_STEAM) SessionState.steamUrl?.takeIf { it.startsWith("steam://") }?.let {
@@ -643,6 +644,10 @@ class SessionService : Service() {
}
if (gen == sessionGen && SessionState.running) {
SessionTerminal.prepare(terminalCommand, terminalHostEnvironment.map { (key, value) -> "$key=$value" }.toTypedArray(), root, gen)
+ val (fastPathName, _) = ProotFastPath.hostEnv("")
+ BottomDesktop.prepare(desktopGuest, binds, sessionRoot,
+ hostEnv.asArray().filterNot { it.startsWith("$fastPathName=") }.toTypedArray(), root, sessionDir, gen,
+ ) { gen == sessionGen && SessionState.running }
}
if (SessionState.mode == MODE_STEAM || SessionState.mode == MODE_DESKTOP) OfflineMode.apply(this, root)
@@ -704,7 +709,10 @@ class SessionService : Service() {
if (gen == sessionGen && SessionState.running) {
suspendController = SessionSuspendController(
sessionRoot = { sessionPid },
- helperRoots = { components.mapNotNull { it.suspendPid().takeIf { pid -> pid > 1 } } },
+ helperRoots = {
+ components.mapNotNull { it.suspendPid().takeIf { pid -> pid > 1 } } +
+ listOfNotNull(BottomDesktop.suspendPid.takeIf { it > 1 })
+ },
suspendAudio = {
if (!pulse.setSinkSuspended(true)) Log.w(TAG, "could not suspend audio sink")
if (!pulse.setMicSuspended(true)) Log.w(TAG, "could not suspend microphone source")
@@ -1610,6 +1618,7 @@ class SessionService : Service() {
))
if (shouldSuspend) {
freezePending = true
+ SessionState.suspending = true
freezeCancelled = false
val freezeSteamToken = steamSleepToken
val freezeNativeToken = nativeSleepToken
@@ -1618,6 +1627,7 @@ class SessionService : Service() {
) { success ->
mainHandler.post {
if (gen != sessionGen || !SessionState.running) return@post
+ SessionState.suspending = false
suspendOperationPending = false
freezePending = false
if (success) {
@@ -1830,6 +1840,7 @@ class SessionService : Service() {
GameThreadHints.stop()
suspendOperationPending = false
freezePending = false
+ SessionState.suspending = false
launchWatcher?.stopWatching()
launchWatcher = null
syncWatcher?.stopWatching()
@@ -1840,6 +1851,7 @@ class SessionService : Service() {
auxiliaryProcesses.toMap().also { auxiliaryProcesses.clear() }
}
SessionTerminal.clear(sessionGen)
+ BottomDesktop.stop(this, stoppedGen)
val controller = suspendController
suspendController = null
if (ended != null) {
diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionState.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionState.kt
index 947948f168..c93a2758b2 100644
--- a/app/src/main/java/com/droiddeck/launcher/session/SessionState.kt
+++ b/app/src/main/java/com/droiddeck/launcher/session/SessionState.kt
@@ -54,6 +54,8 @@ object SessionState {
var suspended by mutableStateOf(false)
var resumeRequested by mutableStateOf(false)
var resuming by mutableStateOf(false)
+ /** A freeze has begun and has not finished; it already chose which processes it stops. */
+ @Volatile var suspending = false
var resumeFailures by mutableIntStateOf(0)
var resumeFailed by mutableStateOf(false)
var manualPause by mutableStateOf(false)
diff --git a/app/src/main/java/com/droiddeck/launcher/ui/BottomDesktopPanel.kt b/app/src/main/java/com/droiddeck/launcher/ui/BottomDesktopPanel.kt
new file mode 100644
index 0000000000..d6b80ac813
--- /dev/null
+++ b/app/src/main/java/com/droiddeck/launcher/ui/BottomDesktopPanel.kt
@@ -0,0 +1,345 @@
+package com.droiddeck.launcher.ui
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.content.res.Configuration
+import android.graphics.Color
+import android.os.SystemClock
+import android.graphics.Typeface
+import android.view.Gravity
+import android.view.KeyEvent
+import android.view.MotionEvent
+import android.view.SurfaceHolder
+import android.view.SurfaceView
+import android.view.View
+import android.view.ViewConfiguration
+import android.graphics.RectF
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.ui.platform.ComposeView
+import android.widget.FrameLayout
+import android.widget.LinearLayout
+import android.widget.ImageView
+import android.widget.TextView
+import com.droiddeck.launcher.R
+import com.droiddeck.launcher.input.GuestKeys
+import com.droiddeck.launcher.input.InputSpace
+import com.droiddeck.launcher.input.KeyboardHost
+import com.droiddeck.launcher.input.PadBridge
+import com.droiddeck.launcher.input.PointerGestures
+import com.droiddeck.launcher.input.TouchpadGestures
+import com.droiddeck.launcher.session.SessionPrefs
+import com.droiddeck.launcher.session.BottomDesktop
+
+@SuppressLint("ViewConstructor")
+class BottomDesktopPanel(
+ context: Context,
+ onClose: () -> Unit,
+ onMenu: (() -> Unit)?,
+ steamButtons: Pair<() -> Unit, () -> Unit>?,
+) : LinearLayout(context), SurfaceHolder.Callback {
+ private lateinit var surfaceView: SurfaceView
+ private val area = FrameLayout(context).apply { clipChildren = true }
+ private val state = mutableStateOf(BottomDesktop.state)
+ private val status = ComposeView(context).apply {
+ setContent { DroidDeckTheme { BottomDesktopStatus(state.value, ::startAgain) } }
+ }
+ private val keyboardHost = KeyboardHost(context) { event -> sendKey(event) }
+ private var directTouch = SessionPrefs.bottomDesktopDirectTouch(context)
+ private lateinit var touchButton: ImageView
+ private lateinit var title: TextView
+ private val trackpad = TouchpadGestures(ViewConfiguration.get(context).scaledTouchSlop.toFloat(), TrackpadInput()).apply {
+ desktop = true
+ }
+ private var attached = false
+ /** The surface was given to a compositor process; a new process cannot connect to it again. */
+ private var surfaceUsed = false
+ private var fullWidth = 0
+ private var fullHeight = 0
+ private var lastTouchY = 0f
+ private var lastPressMs = 0L
+ private var scrollRestX = 0f
+ private var scrollRestY = 0f
+ private val stateListener: () -> Unit = { showState() }
+
+ init {
+ orientation = VERTICAL
+ setBackgroundColor(Color.BLACK)
+ isFocusable = true
+ isFocusableInTouchMode = true
+ addView(bar(onClose, onMenu, steamButtons), LayoutParams(-1, -2))
+ area.addView(keyboardHost)
+ addSurface()
+ area.addView(status, FrameLayout.LayoutParams(-1, -1))
+ addView(area, LayoutParams(-1, 0, 1f))
+ keyboardHost.onImeChanged = { pan() }
+ showTouchMode()
+ }
+
+ private fun addSurface() {
+ surfaceView = SurfaceView(context)
+ surfaceView.holder.addCallback(this)
+ @Suppress("ClickableViewAccessibility")
+ surfaceView.setOnTouchListener { _, event -> onSurfaceTouch(event) }
+ area.addView(surfaceView, 1, FrameLayout.LayoutParams(fullWidth.takeIf { it > 0 } ?: -1, fullHeight.takeIf { it > 0 } ?: -1))
+ }
+
+ private fun bar(onClose: () -> Unit, onMenu: (() -> Unit)?, steamButtons: Pair<() -> Unit, () -> Unit>?): View {
+ val bar = LinearLayout(context).apply {
+ orientation = HORIZONTAL
+ gravity = Gravity.CENTER_VERTICAL
+ setPadding(dp(8), dp(6), dp(8), dp(6))
+ setBackgroundColor(Color.BLACK)
+ }
+ fun gap() = View(context).apply { layoutParams = LayoutParams(dp(6), 1) }
+ bar.addView(DeckControlsPanel.roundButton(context, "×", context.getString(R.string.deck_close), onClose))
+ title = TextView(context).apply {
+ textSize = 14f
+ typeface = Typeface.create(Typeface.DEFAULT, Typeface.BOLD)
+ setTextColor(Color.rgb(0x7A, 0x80, 0x8A))
+ setPadding(dp(12), 0, dp(6), 0)
+ isSingleLine = true
+ ellipsize = android.text.TextUtils.TruncateAt.END
+ }
+ bar.addView(title, LayoutParams(0, -2, 1f))
+ touchButton = DeckControlsPanel.iconButton(context, R.drawable.ic_bottom_mouse, "") { setDirectTouch(!directTouch) }
+ bar.addView(touchButton)
+ bar.addView(gap())
+ bar.addView(DeckControlsPanel.iconButton(context, R.drawable.ic_bottom_keyboard,
+ context.getString(R.string.second_show_keyboard)) { keyboardHost.toggle() })
+ onMenu?.let {
+ bar.addView(gap())
+ bar.addView(DeckControlsPanel.menuButton(context, it))
+ }
+ steamButtons?.let { (steam, qam) ->
+ bar.addView(gap())
+ bar.addView(DeckControlsPanel.roundButton(context, "STEAM", context.getString(R.string.deck_open_steam_menu), steam, wide = true))
+ bar.addView(gap())
+ bar.addView(DeckControlsPanel.roundButton(context, "•••", context.getString(R.string.drawer_open_qam), qam, wide = true))
+ }
+ return bar
+ }
+
+ private fun setDirectTouch(on: Boolean) {
+ trackpad.cancel()
+ BottomDesktop.sendTouch(3, -1, 0, 0)
+ directTouch = on
+ SessionPrefs.setBottomDesktopDirectTouch(context, on)
+ showTouchMode()
+ }
+
+ private fun showTouchMode() {
+ touchButton.setImageResource(if (directTouch) R.drawable.ic_bottom_touch else R.drawable.ic_bottom_mouse)
+ touchButton.contentDescription = context.getString(
+ if (directTouch) R.string.bottom_desktop_direct_touch else R.string.bottom_desktop_trackpad)
+ title.text = context.getString(R.string.bottom_desktop_title,
+ context.getString(if (directTouch) R.string.bottom_desktop_mode_touch else R.string.bottom_desktop_mode_trackpad))
+ BottomDesktop.showCursor(!directTouch)
+ if (!directTouch && surfaceView.width > 0) {
+ trackpad.bounds = RectF(0f, 0f, surfaceView.width.toFloat(), surfaceView.height.toFloat())
+ trackpad.place(surfaceView.width / 2f, surfaceView.height / 2f)
+ movePointer(trackpad.x, trackpad.y)
+ }
+ }
+
+ override fun onAttachedToWindow() {
+ super.onAttachedToWindow()
+ BottomDesktop.addListener(stateListener)
+ BottomDesktop.setTextInputListener { focused ->
+ val tapped = SystemClock.uptimeMillis() - lastPressMs < TEXT_FIELD_TAP_MS
+ val hardKeyboard = resources.configuration.hardKeyboardHidden == Configuration.HARDKEYBOARDHIDDEN_NO
+ if (focused && tapped && !hardKeyboard && !keyboardHost.shown) keyboardHost.show()
+ else if (!focused && keyboardHost.shown) keyboardHost.hide()
+ }
+ showState()
+ post { if (!keyboardHost.shown) requestFocus() }
+ }
+
+ override fun onDetachedFromWindow() {
+ BottomDesktop.removeListener(stateListener)
+ BottomDesktop.setTextInputListener(null)
+ keyboardHost.takeIf { it.shown }?.hide()
+ trackpad.cancel()
+ status.disposeComposition()
+ super.onDetachedFromWindow()
+ }
+
+ override fun dispatchKeyEvent(event: KeyEvent): Boolean =
+ if (BottomDesktop.state == BottomDesktop.State.RUNNING && !PadBridge.isControllerKeyEvent(event) &&
+ event.keyCode != KeyEvent.KEYCODE_BACK && sendKey(event)) true
+ else super.dispatchKeyEvent(event)
+
+ private fun sendKey(event: KeyEvent): Boolean {
+ if (event.action == KeyEvent.ACTION_DOWN && event.repeatCount > 0) return true
+ if (GuestKeys.send(event, BottomDesktop::sendKey)) return true
+ val ch = event.unicodeChar
+ if (event.action == KeyEvent.ACTION_DOWN && ch > 0) {
+ BottomDesktop.sendText(String(Character.toChars(ch)))
+ return true
+ }
+ return false
+ }
+
+ private fun startAgain() {
+ if (surfaceUsed && !BottomDesktop.connected) {
+ attached = false
+ surfaceUsed = false
+ area.removeView(surfaceView)
+ addSurface()
+ return
+ }
+ if (attached) attach(surfaceView.holder)
+ }
+
+ private fun showState() {
+ state.value = BottomDesktop.state
+ status.visibility = if (state.value == BottomDesktop.State.RUNNING) View.GONE else View.VISIBLE
+ }
+
+ override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
+ super.onSizeChanged(w, h, oldw, oldh)
+ post { holdSurfaceSize() }
+ }
+
+ // The keyboard shrinks the window; the desktop keeps its size and slides up under it instead of being squeezed.
+ private fun holdSurfaceSize() {
+ val w = area.width
+ val h = area.height
+ if (w <= 0 || h <= 0) return
+ if (w != fullWidth || h > fullHeight || !keyboardHost.shown) {
+ fullWidth = w
+ fullHeight = h
+ surfaceView.layoutParams = FrameLayout.LayoutParams(w, h)
+ }
+ pan()
+ }
+
+ private fun pan() {
+ val visible = area.height
+ val hidden = (fullHeight - visible).coerceAtLeast(0)
+ val anchor = if (directTouch) lastTouchY else trackpad.y
+ surfaceView.translationY = if (hidden == 0 || !keyboardHost.shown) 0f
+ else -(anchor - visible * 0.4f).coerceIn(0f, hidden.toFloat())
+ }
+
+ override fun surfaceCreated(holder: SurfaceHolder) = Unit
+
+ override fun surfaceChanged(holder: SurfaceHolder, format: Int, width: Int, height: Int) {
+ if (!attached) attach(holder)
+ }
+
+ override fun surfaceDestroyed(holder: SurfaceHolder) {
+ if (holder !== surfaceView.holder) return
+ attached = false
+ surfaceUsed = false
+ BottomDesktop.detach()
+ }
+
+ private fun attach(holder: SurfaceHolder) {
+ val frame = holder.surfaceFrame
+ val (width, height) = BottomDesktop.outputSizeFor(fullWidth.takeIf { it > 0 } ?: frame.width(),
+ fullHeight.takeIf { it > 0 } ?: frame.height())
+ if (width <= 0 || height <= 0) return
+ if (frame.width() != width || frame.height() != height) {
+ holder.setFixedSize(width, height)
+ return
+ }
+ attached = true
+ surfaceUsed = true
+ BottomDesktop.attach(context, holder.surface, width, height, display?.refreshRate ?: 60f)
+ showTouchMode()
+ }
+
+ private fun onSurfaceTouch(event: MotionEvent): Boolean {
+ val w = surfaceView.width
+ val h = surfaceView.height
+ if (w <= 0 || h <= 0 || BottomDesktop.state != BottomDesktop.State.RUNNING) return true
+ if (event.actionMasked == MotionEvent.ACTION_DOWN || event.actionMasked == MotionEvent.ACTION_UP)
+ lastPressMs = SystemClock.uptimeMillis()
+ if (directTouch) return forwardTouch(event, w, h)
+ val bounds = RectF(0f, 0f, w.toFloat(), h.toFloat())
+ if (trackpad.bounds != bounds) {
+ trackpad.bounds = bounds
+ trackpad.place(trackpad.x, trackpad.y)
+ }
+ return trackpad.onTouch(event)
+ }
+
+ private fun forwardTouch(event: MotionEvent, w: Int, h: Int): Boolean {
+ val action = when (event.actionMasked) {
+ MotionEvent.ACTION_DOWN, MotionEvent.ACTION_POINTER_DOWN -> 0
+ MotionEvent.ACTION_MOVE -> 1
+ MotionEvent.ACTION_UP, MotionEvent.ACTION_POINTER_UP -> 2
+ MotionEvent.ACTION_CANCEL -> { BottomDesktop.sendTouch(3, -1, 0, 0); return true }
+ else -> return true
+ }
+ if (event.actionMasked == MotionEvent.ACTION_DOWN) lastTouchY = event.y
+ if (action == 1) {
+ for (i in 0 until event.pointerCount) send(1, event.getPointerId(i), event.getX(i), event.getY(i), w, h)
+ } else {
+ val i = event.actionIndex
+ send(action, event.getPointerId(i), event.getX(i), event.getY(i), w, h)
+ }
+ return true
+ }
+
+ private fun send(action: Int, id: Int, x: Float, y: Float, w: Int, h: Int) =
+ BottomDesktop.sendTouch(action, id, InputSpace.x(x, w), InputSpace.y(y, h))
+
+ private fun movePointer(x: Float, y: Float) =
+ BottomDesktop.sendPointer(InputSpace.x(x, surfaceView.width), InputSpace.y(y, surfaceView.height))
+
+ private inner class TrackpadInput : PointerGestures.Listener {
+ override fun onMove(x: Float, y: Float) = movePointer(x, y)
+
+ override fun onButton(button: Int, pressed: Boolean, x: Float, y: Float) {
+ movePointer(x, y)
+ BottomDesktop.sendScene(SCENE_BUTTON, button, if (pressed) 1 else 0)
+ }
+
+ override fun onWheel(steps: Int) = BottomDesktop.sendScene(SCENE_WHEEL, steps)
+
+ override fun onScroll(dx: Float, dy: Float) {
+ val (outW, outH) = BottomDesktop.outputSizeFor(surfaceView.width, surfaceView.height)
+ scrollRestX += dx * outW / surfaceView.width.coerceAtLeast(1) * AXIS_UNITS_PER_PIXEL
+ scrollRestY += dy * outH / surfaceView.height.coerceAtLeast(1) * AXIS_UNITS_PER_PIXEL
+ val h = scrollRestX.toInt()
+ val v = scrollRestY.toInt()
+ if (h == 0 && v == 0) return
+ scrollRestX -= h
+ scrollRestY -= v
+ BottomDesktop.sendScene(SCENE_AXIS, v, h)
+ }
+
+ override fun onScrollEnd() {
+ scrollRestX = 0f
+ scrollRestY = 0f
+ BottomDesktop.sendScene(SCENE_AXIS, 0, 0)
+ }
+
+ override fun onZoom(steps: Int) {
+ BottomDesktop.sendKey(KEY_LEFTCTRL, true)
+ BottomDesktop.sendScene(SCENE_WHEEL, steps)
+ BottomDesktop.sendKey(KEY_LEFTCTRL, false)
+ }
+
+ override fun onThreeFingerTap(): Boolean {
+ post { keyboardHost.toggle() }
+ return true
+ }
+
+ override fun onLongPress() {
+ performHapticFeedback(android.view.HapticFeedbackConstants.LONG_PRESS)
+ }
+ }
+
+ private fun dp(value: Int): Int = (value * resources.displayMetrics.density + 0.5f).toInt()
+
+ private companion object {
+ const val SCENE_BUTTON = 3
+ const val SCENE_WHEEL = 4
+ const val SCENE_AXIS = 12
+ const val KEY_LEFTCTRL = 29
+ const val AXIS_UNITS_PER_PIXEL = 3f
+ const val TEXT_FIELD_TAP_MS = 1_000L
+ }
+}
diff --git a/app/src/main/java/com/droiddeck/launcher/ui/BottomDesktopStatus.kt b/app/src/main/java/com/droiddeck/launcher/ui/BottomDesktopStatus.kt
new file mode 100644
index 0000000000..88bd567760
--- /dev/null
+++ b/app/src/main/java/com/droiddeck/launcher/ui/BottomDesktopStatus.kt
@@ -0,0 +1,55 @@
+package com.droiddeck.launcher.ui
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.layout.widthIn
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import com.droiddeck.launcher.R
+import com.droiddeck.launcher.session.BottomDesktop
+
+/** What the bottom screen shows while the desktop is not drawing: the session loading screen's throbber and a line of text. */
+@Composable
+internal fun BottomDesktopStatus(state: BottomDesktop.State, onStart: () -> Unit) {
+ val colors = MaterialTheme.colorScheme
+ val starting = state == BottomDesktop.State.STARTING
+ Box(Modifier.fillMaxSize().background(colors.background).blockTouches(), contentAlignment = Alignment.Center) {
+ Column(
+ horizontalAlignment = Alignment.CenterHorizontally,
+ verticalArrangement = Arrangement.Center,
+ modifier = Modifier.padding(horizontal = 32.dp),
+ ) {
+ LogoThrobber(Modifier.width(if (starting) 96.dp else 76.dp), running = starting)
+ Spacer(Modifier.height(24.dp))
+ Text(
+ stringResource(when (state) {
+ BottomDesktop.State.ENDED -> R.string.bottom_desktop_ended
+ BottomDesktop.State.FAILED -> R.string.bottom_desktop_failed
+ BottomDesktop.State.OFF -> R.string.bottom_desktop_off
+ else -> R.string.bottom_desktop_starting
+ }),
+ fontSize = 18.sp, fontWeight = FontWeight.SemiBold, color = colors.onBackground,
+ textAlign = TextAlign.Center, modifier = Modifier.widthIn(max = 420.dp),
+ )
+ if (!starting) {
+ Spacer(Modifier.height(20.dp))
+ PrimaryButton(stringResource(R.string.bottom_desktop_start), main = true, onClick = onStart)
+ }
+ }
+ }
+}
diff --git a/app/src/main/java/com/droiddeck/launcher/ui/DeckControlsPanel.kt b/app/src/main/java/com/droiddeck/launcher/ui/DeckControlsPanel.kt
index 1afa23b71a..aadacf1f4d 100644
--- a/app/src/main/java/com/droiddeck/launcher/ui/DeckControlsPanel.kt
+++ b/app/src/main/java/com/droiddeck/launcher/ui/DeckControlsPanel.kt
@@ -715,10 +715,13 @@ class DeckControlsPanel(
}
}
- internal fun menuButton(context: Context, onClick: () -> Unit) = android.widget.ImageView(context).apply {
- setImageResource(R.drawable.ic_stat_session)
+ internal fun menuButton(context: Context, onClick: () -> Unit) =
+ iconButton(context, R.drawable.ic_stat_session, context.getString(R.string.touch_droiddeck_menu), onClick)
+
+ internal fun iconButton(context: Context, icon: Int, description: String, onClick: () -> Unit) = android.widget.ImageView(context).apply {
+ setImageResource(icon)
setColorFilter(TEXT)
- contentDescription = context.getString(R.string.touch_droiddeck_menu)
+ contentDescription = description
scaleType = android.widget.ImageView.ScaleType.CENTER_INSIDE
val pad = dp(context, 11)
setPadding(pad, pad, pad, pad)
diff --git a/app/src/main/java/com/droiddeck/launcher/ui/SecondScreenPresentation.kt b/app/src/main/java/com/droiddeck/launcher/ui/SecondScreenPresentation.kt
index 18f54cf5d3..df4182e0de 100644
--- a/app/src/main/java/com/droiddeck/launcher/ui/SecondScreenPresentation.kt
+++ b/app/src/main/java/com/droiddeck/launcher/ui/SecondScreenPresentation.kt
@@ -34,6 +34,7 @@ import com.droiddeck.launcher.input.PointerGestures
import com.droiddeck.launcher.input.SecondScreenMode
import com.droiddeck.launcher.input.TouchpadGestures
import com.droiddeck.launcher.SessionActivity
+import com.droiddeck.launcher.session.BottomDesktop
import com.droiddeck.launcher.session.SessionService
import com.droiddeck.launcher.session.SessionState
import com.droiddeck.launcher.session.SessionTerminal
@@ -199,7 +200,8 @@ class SecondScreenPresentation(
}
override fun dispatchKeyEvent(event: KeyEvent): Boolean {
- val ownKeys = currentMode == SecondScreenMode.TERMINAL || currentMode == SecondScreenMode.DASHBOARD
+ val ownKeys = currentMode == SecondScreenMode.TERMINAL || currentMode == SecondScreenMode.DASHBOARD ||
+ currentMode == SecondScreenMode.DESKTOP
val forward = menuShown || !ownKeys || PadBridge.isControllerKeyEvent(event)
if (forward && sessionActivity.dispatchKeyEvent(event)) return true
return super.dispatchKeyEvent(event)
@@ -231,6 +233,7 @@ class SecondScreenPresentation(
val mode = when {
currentMode == SecondScreenMode.DECK_CONTROLS && !SessionState.deckPad -> SecondScreenMode.NONE
currentMode == SecondScreenMode.DASHBOARD && dashboard == null -> SecondScreenMode.NONE
+ currentMode == SecondScreenMode.DESKTOP && !BottomDesktop.available() -> SecondScreenMode.NONE
else -> currentMode
}
if (mode == SecondScreenMode.NONE) return
@@ -240,6 +243,11 @@ class SecondScreenPresentation(
SecondScreenMode.TERMINAL -> renderTerminal()
SecondScreenMode.DECK_CONTROLS -> root.addView(DeckControlsPanel(context, onClose, onSteamMenu, onQam, pad, onMenu = onMenu), weightParams())
SecondScreenMode.DASHBOARD -> renderDashboard()
+ SecondScreenMode.DESKTOP -> {
+ ownComposeViews()
+ root.addView(BottomDesktopPanel(context, onClose, onMenu,
+ (onSteamMenu to onQam).takeIf { SessionState.mode == SessionService.MODE_STEAM }), weightParams())
+ }
SecondScreenMode.NONE -> Unit
}
}
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 fad54cf813..1a20d0cb67 100644
--- a/app/src/main/java/com/droiddeck/launcher/ui/SessionOverlay.kt
+++ b/app/src/main/java/com/droiddeck/launcher/ui/SessionOverlay.kt
@@ -32,6 +32,7 @@ import androidx.compose.foundation.layout.heightIn
import androidx.compose.material.icons.outlined.Close
import androidx.compose.material.icons.outlined.Terminal
import androidx.compose.material.icons.outlined.Dashboard
+import androidx.compose.material.icons.outlined.DesktopWindows
import androidx.compose.material.icons.outlined.Keyboard
import androidx.compose.material.icons.outlined.AutoFixHigh
import androidx.compose.material.icons.outlined.ExpandMore
@@ -244,6 +245,7 @@ class DrawerActions(
val textureLodBias: String? = TextureFiltering.LOD_BIAS_OFF,
val secondScreenMode: SecondScreenMode,
val dashboardAvailable: Boolean = false,
+ val desktopAvailable: Boolean = false,
val secondScreenDisplays: List,
val selectedSecondScreenDisplay: Int,
val onHud: (Boolean) -> Unit,
@@ -901,6 +903,7 @@ private fun BottomScreenModes(a: DrawerActions, modifier: Modifier, onPick: () -
add(SecondScreenMode.KEYBOARD_TRACKPAD to Icons.Outlined.Keyboard)
add(SecondScreenMode.TERMINAL to Icons.Outlined.Terminal)
if (a.dashboardAvailable) add(SecondScreenMode.DASHBOARD to Icons.Outlined.Dashboard)
+ if (a.desktopAvailable) add(SecondScreenMode.DESKTOP to Icons.Outlined.DesktopWindows)
}
Row(
verticalAlignment = Alignment.CenterVertically,
@@ -1199,7 +1202,8 @@ private fun SecondScreenGroup(host: MenuHost, a: DrawerActions, track: (String)
val pal = LocalPalette.current
val modes = listOf(SecondScreenMode.NONE, SecondScreenMode.KEYBOARD_TRACKPAD, SecondScreenMode.TERMINAL) +
(if (com.droiddeck.launcher.session.SessionState.deckPad) listOf(SecondScreenMode.DECK_CONTROLS) else emptyList()) +
- (if (a.dashboardAvailable) listOf(SecondScreenMode.DASHBOARD) else emptyList())
+ (if (a.dashboardAvailable) listOf(SecondScreenMode.DASHBOARD) else emptyList()) +
+ (if (a.desktopAvailable) listOf(SecondScreenMode.DESKTOP) else emptyList())
SettingsGroup(stringResource(R.string.drawer_second_screen_mode)) {
Column(Modifier.fillMaxWidth().selectableGroup()) {
modes.forEach { mode ->
diff --git a/app/src/main/java/com/droiddeck/launcher/wayland/BottomDesktopCompositorService.kt b/app/src/main/java/com/droiddeck/launcher/wayland/BottomDesktopCompositorService.kt
new file mode 100644
index 0000000000..59c182dd35
--- /dev/null
+++ b/app/src/main/java/com/droiddeck/launcher/wayland/BottomDesktopCompositorService.kt
@@ -0,0 +1,117 @@
+package com.droiddeck.launcher.wayland
+
+import android.app.Service
+import android.content.Intent
+import android.os.Handler
+import android.os.IBinder
+import android.os.Looper
+import android.os.Message
+import android.os.Messenger
+import android.util.Log
+import android.view.Surface
+import com.droiddeck.launcher.core.FileUtils
+import java.io.File
+
+/**
+ * The bottom-screen desktop's compositor. The compositor's native state is one per process, so the
+ * desktop gets a process of its own while the session's compositor keeps the top screen.
+ */
+class BottomDesktopCompositorService : Service() {
+ private var client: Messenger? = null
+ /** Echoed in every reply, so the session process can tell replies to an earlier attach apart. */
+ @Volatile private var attachTag = 0
+
+ private val handler = object : Handler(Looper.getMainLooper()) {
+ override fun handleMessage(msg: Message) {
+ when (msg.what) {
+ MSG_ATTACH -> attach(msg)
+ MSG_DETACH -> CompositorHost.detach(null)
+ MSG_TOUCH -> WaylandCompositor.nativeSendTouch(msg.arg1 and 0xff, msg.arg1 shr 8,
+ msg.arg2 ushr 16, msg.arg2 and 0xffff)
+ MSG_KEY -> WaylandCompositor.nativeSendKey(msg.arg1, msg.arg2)
+ MSG_POINTER -> WaylandCompositor.nativeSendPointer(1, msg.arg1, msg.arg2)
+ MSG_SCENE -> WaylandCompositor.nativeSendSceneInput(msg.arg1, msg.arg2, msg.peekData()?.getInt(KEY_B) ?: 0)
+ MSG_CURSOR -> if (CompositorHost.isStarted) WaylandCompositor.nativeSetCursorComposite(msg.arg1 != 0)
+ MSG_NEW_GUEST -> WaylandCompositor.nativeResetFirstFrame()
+ MSG_TEXT -> msg.data?.getString(KEY_TEXT)?.let { WaylandCompositor.textInputCommit(it) }
+ MSG_STOP -> {
+ Log.i(TAG, "bottom-screen desktop closed; ending its compositor process")
+ // A producer that dies still connected keeps the panel's surface from taking another one.
+ CompositorHost.detach(null)
+ postDelayed({ android.os.Process.killProcess(android.os.Process.myPid()) }, 300)
+ }
+ else -> super.handleMessage(msg)
+ }
+ }
+ }
+
+ private val messenger = Messenger(handler)
+
+ override fun onBind(intent: Intent?): IBinder = messenger.binder
+
+ override fun onUnbind(intent: Intent?): Boolean {
+ // The session process went away without saying so; nothing is left to draw for.
+ android.os.Process.killProcess(android.os.Process.myPid())
+ return false
+ }
+
+ private fun attach(msg: Message) {
+ val surface = msg.obj as? Surface ?: return
+ val data = msg.data ?: return
+ client = msg.replyTo
+ attachTag = msg.arg1
+ val runtimeDir = File(data.getString(KEY_RUNTIME_DIR) ?: return).apply { mkdirs() }
+ val width = data.getInt(KEY_WIDTH)
+ val height = data.getInt(KEY_HEIGHT)
+ if (!CompositorHost.isStarted) {
+ FileUtils.copyAsset(this, "wayland/keymap.xkb", File(runtimeDir, "keymap.xkb"))
+ data.getString(KEY_LOG)?.let { path ->
+ WaylandCompositor.setSessionLogFile(File(path))
+ runCatching { android.system.Os.setenv("BL_WAYLAND_LOG", path, true) }
+ .onFailure { Log.w(TAG, "could not point the compositor's log at $path", it) }
+ }
+ WaylandCompositor.setFirstFrameListener { reply(MSG_FIRST_FRAME) }
+ WaylandCompositor.nativeSetScaleMode(SCALE_FIT, ALIGN_CENTER)
+ }
+ val turnip = com.droiddeck.launcher.gpu.TurnipDriver(this)
+ val driverId = if (CompositorHost.isStarted) null else turnip.install()
+ val started = CompositorHost.startOrAttach(
+ this, surface, runtimeDir.path, driverId?.let { turnip.driverPath(it) }, driverId?.let { turnip.libraryName(it) },
+ applicationInfo.nativeLibraryDir,
+ width, height, data.getFloat(KEY_REFRESH, 60f), 0,
+ )
+ Log.i(TAG, (if (started) "compositor started" else "compositor attached") + " at ${width}x$height in ${runtimeDir.path}")
+ reply(MSG_ATTACHED)
+ }
+
+ private fun reply(what: Int) {
+ val target = client ?: return
+ runCatching { target.send(Message.obtain(null, what, attachTag, 0)) }
+ .onFailure { Log.w(TAG, "the session process did not take message $what", it) }
+ }
+
+ companion object {
+ private const val TAG = "BottomDesktopComp"
+ const val MSG_ATTACH = 1
+ const val MSG_DETACH = 2
+ const val MSG_TOUCH = 3
+ const val MSG_KEY = 4
+ const val MSG_TEXT = 5
+ const val MSG_STOP = 6
+ const val MSG_NEW_GUEST = 7
+ const val MSG_POINTER = 8
+ const val MSG_SCENE = 9
+ const val MSG_CURSOR = 10
+ const val MSG_ATTACHED = 101
+ const val MSG_FIRST_FRAME = 102
+ const val KEY_RUNTIME_DIR = "runtimeDir"
+ const val KEY_WIDTH = "width"
+ const val KEY_HEIGHT = "height"
+ const val KEY_REFRESH = "refresh"
+ const val KEY_LOG = "log"
+ const val KEY_TEXT = "text"
+ const val KEY_B = "b"
+ private const val SCALE_FIT = 1
+ private const val ALIGN_CENTER = 0
+ }
+}
diff --git a/app/src/main/res/drawable/ic_bottom_keyboard.xml b/app/src/main/res/drawable/ic_bottom_keyboard.xml
new file mode 100644
index 0000000000..ff8aa75002
--- /dev/null
+++ b/app/src/main/res/drawable/ic_bottom_keyboard.xml
@@ -0,0 +1,5 @@
+
+
+
diff --git a/app/src/main/res/drawable/ic_bottom_mouse.xml b/app/src/main/res/drawable/ic_bottom_mouse.xml
new file mode 100644
index 0000000000..7a55849853
--- /dev/null
+++ b/app/src/main/res/drawable/ic_bottom_mouse.xml
@@ -0,0 +1,5 @@
+
+
+
diff --git a/app/src/main/res/drawable/ic_bottom_touch.xml b/app/src/main/res/drawable/ic_bottom_touch.xml
new file mode 100644
index 0000000000..ff90202a8c
--- /dev/null
+++ b/app/src/main/res/drawable/ic_bottom_touch.xml
@@ -0,0 +1,5 @@
+
+
+
diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml
index d0e4aaa158..ed95133b96 100644
--- a/app/src/main/res/values/strings.xml
+++ b/app/src/main/res/values/strings.xml
@@ -1881,6 +1881,17 @@
Terminal
Deck grips + trackpads
Dashboard
+ Desktop
+ Start the desktop
+ Desktop · %1$s
+ Trackpad
+ Direct touch
+ Trackpad. Tap for direct touch
+ Direct touch. Tap for trackpad
+ Starting the KDE desktop…
+ The desktop closed.
+ The desktop couldn\'t start. Its logs are in this session\'s bottom-desktop folder.
+ The desktop is closed.
Nothing to show here yet.
Downloads
No downloads running.
diff --git a/app/src/test/java/com/droiddeck/launcher/input/SecondScreenModeTest.kt b/app/src/test/java/com/droiddeck/launcher/input/SecondScreenModeTest.kt
index 8a66101f1b..f1ed577788 100644
--- a/app/src/test/java/com/droiddeck/launcher/input/SecondScreenModeTest.kt
+++ b/app/src/test/java/com/droiddeck/launcher/input/SecondScreenModeTest.kt
@@ -38,4 +38,15 @@ class SecondScreenModeTest {
assertEquals(SecondScreenMode.DECK_CONTROLS, SecondScreenMode.opening("dashboard", deckPad = true, dashboard = false))
assertEquals(SecondScreenMode.KEYBOARD_TRACKPAD, SecondScreenMode.opening("dashboard", deckPad = false))
}
+
+ @Test fun theDesktopOpensAgainOnlyWhileItCanRun() {
+ assertEquals(SecondScreenMode.DESKTOP, SecondScreenMode.opening("desktop", deckPad = true, dashboard = true, desktop = true))
+ assertEquals(SecondScreenMode.DECK_CONTROLS, SecondScreenMode.opening("desktop", deckPad = true, dashboard = true))
+ assertEquals(SecondScreenMode.KEYBOARD_TRACKPAD, SecondScreenMode.opening("desktop", deckPad = false))
+ }
+
+ @Test fun withNothingRememberedTheDesktopIsNeverPicked() {
+ assertEquals(SecondScreenMode.DASHBOARD, SecondScreenMode.opening(null, deckPad = false, dashboard = true, desktop = true))
+ assertEquals(SecondScreenMode.KEYBOARD_TRACKPAD, SecondScreenMode.opening(null, deckPad = false, desktop = true))
+ }
}
diff --git a/tools/linuxfs/desktop/droiddeck-desktop b/tools/linuxfs/desktop/droiddeck-desktop
index 30e95c70ec..f10cff2474 100644
--- a/tools/linuxfs/desktop/droiddeck-desktop
+++ b/tools/linuxfs/desktop/droiddeck-desktop
@@ -119,7 +119,7 @@ echo "== droiddeck-desktop: Plasma on $WAYLAND_DISPLAY"
dbus-run-session -- startplasma-wayland
rc=$?
echo "== droiddeck-desktop: Plasma ended ($rc)"
-if [ "$rc" -eq 0 ]; then
+if [ "$rc" -eq 0 ] && [ -z "${BL_BOTTOM_DESKTOP:-}" ]; then
/usr/local/bin/droiddeck-steam-launch bigpicture
sleep 30
fi
diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-bottom-desktop b/tools/linuxfs/overlay/usr/local/bin/droiddeck-bottom-desktop
new file mode 100755
index 0000000000..2c19c23bed
--- /dev/null
+++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-bottom-desktop
@@ -0,0 +1,51 @@
+#!/bin/bash
+# KDE Plasma on a dual-screen handheld's bottom screen, next to the session on the top one.
+set -u
+export HOME=${HOME:-/root}
+if [ -n "${BL_DEBUG_DIR:-}" ]; then
+ mkdir -p "$BL_DEBUG_DIR" 2>/dev/null || true
+ exec >>"$BL_DEBUG_DIR/bottom-desktop.log" 2>&1
+fi
+echo "== droiddeck-bottom-desktop $(date -u '+%Y-%m-%d %H:%M:%S UTC') ${BL_WIDTH:-?}x${BL_HEIGHT:-?} beside a ${BL_TOP_SESSION:-?} session"
+[ -x /usr/local/bin/droiddeck-desktop ] || { echo "== the desktop package is not installed"; exit 66; }
+
+# Launch requests would reach the top session's watcher and could replace it.
+unset BL_LAUNCH_DIR BL_LOG
+export BL_BOTTOM_DESKTOP=1
+
+for _ in $(seq 1 100); do
+ wayland-info >/dev/null 2>&1 && break
+ sleep 0.1
+done
+
+if command -v dbus-daemon >/dev/null 2>&1 && command -v droiddeck-netmanager >/dev/null 2>&1 \
+ && ! pgrep -f 'dbus-daemon --config-file=/usr/local/share/droiddeck/system-bus.conf' >/dev/null 2>&1; then
+ mkdir -p /run/dbus /usr/local/share/droiddeck
+ cat > /usr/local/share/droiddeck/system-bus.conf <<'BUSCONF'
+
+
+ system
+ unix:path=/run/dbus/system_bus_socket
+ EXTERNAL
+ /usr/share/droiddeck/system-services
+
+
+
+
+
+
+
+BUSCONF
+ rm -f /run/dbus/system_bus_socket
+ dbus-daemon --config-file=/usr/local/share/droiddeck/system-bus.conf --nofork --nopidfile &
+ for _ in $(seq 1 50); do
+ [ -S /run/dbus/system_bus_socket ] && break
+ sleep 0.1
+ done
+ [ -S /run/dbus/system_bus_socket ] && droiddeck-login1 --with-netmanager &
+fi
+
+# The game on the top screen keeps the CPU first.
+renice -n 5 $$ >/dev/null 2>&1 || true
+exec /usr/local/bin/droiddeck-desktop
diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-ime b/tools/linuxfs/overlay/usr/local/bin/droiddeck-ime
index c96aa283bb..4f110cfbc6 100755
--- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-ime
+++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-ime
@@ -85,7 +85,7 @@ def connect():
def main():
launch = os.environ.get("BL_LAUNCH_DIR", "")
- report = Report(os.path.join(launch, "agent") if launch else "")
+ report = Report(os.environ.get("BL_IME_DIR") or (os.path.join(launch, "agent") if launch else ""))
conn = Connection(connect())
conn.send(DISPLAY_ID, 1, struct.pack("/dev/null || true)
+ if [ -p "$client_home/.steam/steam.pipe" ] && [[ "$pid" =~ ^[0-9]+$ ]] && kill -0 "$pid" 2>/dev/null; then
+ # The top screen's client takes the request, so games open there.
+ exec "${client[@]}" -nobigpicture -no-cef-sandbox \
+ -cef-ozone-platform=x11 -cef-disable-gpu "${url:-steam://open/library}"
+ fi
+ fi
mkdir -p "${XDG_CACHE_HOME:-$HOME/.cache}/droiddeck"
exec 9>"${XDG_CACHE_HOME:-$HOME/.cache}/droiddeck/steam-desktop.lock"
if ! flock -n 9; then
diff --git a/tools/tests/test_steam_desktop_launch.py b/tools/tests/test_steam_desktop_launch.py
index 4100b3e79c..37e1a3ed86 100644
--- a/tools/tests/test_steam_desktop_launch.py
+++ b/tools/tests/test_steam_desktop_launch.py
@@ -92,6 +92,30 @@ class DesktopSteamLaunchTest(unittest.TestCase):
'-cef-disable-gpu', 'steam://open/settings'])
self.assertFalse((self.session / 'steam-launch').exists())
+ def _running_client(self):
+ steam = self.root / 'data/Steam/steamrtarm64/steam'
+ steam.parent.mkdir(parents=True)
+ steam.write_text('#!/bin/bash\nprintf "%s\\n" "$@"\n')
+ steam.chmod(0o755)
+ (self.root / '.steam').mkdir()
+ os.mkfifo(self.root / '.steam/steam.pipe')
+ (self.root / '.steam/steam.pid').write_text(str(os.getpid()))
+
+ def test_bottom_screen_desktop_hands_games_to_the_running_client(self):
+ self._running_client()
+ self.env['BL_BOTTOM_DESKTOP'] = '1'
+ result = self.launch('desktop', '501590')
+ self.assertEqual(result.returncode, 0, result.stderr)
+ self.assertEqual(result.stdout.splitlines(), ['-nobigpicture', '-no-cef-sandbox', '-cef-ozone-platform=x11',
+ '-cef-disable-gpu', 'steam://rungameid/501590'])
+ self.assertFalse((self.root / 'cache/droiddeck/steam-desktop.lock').exists())
+
+ def test_bottom_screen_desktop_starts_its_own_client_when_none_runs(self):
+ self.env.update(BL_BOTTOM_DESKTOP='1', DISPLAY=':7')
+ result = self.launch('desktop')
+ self.assertEqual(result.returncode, 0, result.stderr)
+ self.assertEqual(result.stdout.splitlines(), ['1', 'desktop', ':7', 'steam', 'steam://open/library'])
+
def test_second_click_forwards_to_the_x86_64_client_in_its_own_home(self):
lock = self.root / 'cache/droiddeck/steam-desktop.lock'
lock.parent.mkdir(parents=True)