diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index bf6630fd52..f8d3a75278 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -274,6 +274,9 @@ jobs:
if: steps.comet.outputs.cache-hit != 'true'
run: python3 tools/components/prepare.py comet
+ - name: Build the DiRT 3 / DiRT Showdown ws2_32 stand-in
+ run: python3 tools/components/prepare.py dirt-ws2
+
- name: Prepare graphics driver variants
run: python3 tools/quest/build-driver.py "$ANDROID_HOME/ndk/$NDK_VERSION"
- name: Record and pack prepared components
diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index 1dbfcd5b3c..cc9fd6688d 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -69,6 +69,14 @@
+
+
+
+
+
diff --git a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt
index 9b8a6f9727..ca627ab2a5 100644
--- a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt
+++ b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt
@@ -120,6 +120,10 @@ import com.droiddeck.launcher.ui.LoadingOverlay
import com.droiddeck.launcher.ui.SessionDrawer
import com.droiddeck.launcher.ui.SessionPausedOverlay
import com.droiddeck.launcher.ui.SecondScreenPresentation
+import com.droiddeck.launcher.ui.BottomDashboard
+import com.droiddeck.launcher.ui.BottomPage
+import com.droiddeck.launcher.ui.sessionBottomPages
+import com.droiddeck.launcher.ui.BottomPageActions
import com.droiddeck.launcher.ui.DroidDeckTheme
import com.droiddeck.launcher.wayland.CompositorHost
import com.droiddeck.launcher.wayland.WaylandCompositor
@@ -214,6 +218,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback {
private lateinit var touchscreenGestures: TouchscreenGestures
private var gestureConfig = com.droiddeck.launcher.input.TouchGestureConfig()
private var gestureGame: String? = null
+ private var gameStarts by mutableIntStateOf(0)
private var gestureSettingsOpen by mutableStateOf(false)
private var steamImportAsk by mutableStateOf(null)
private var steamImportAnswered: String? = null
@@ -914,7 +919,8 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback {
window.setBackgroundDrawable(android.graphics.drawable.ColorDrawable(android.graphics.Color.BLACK))
},
)
- LaunchedEffect(AgentGuest.focusRevision) {
+ // Also runs when a second screen appears, so Automatic applies then with the running game known.
+ LaunchedEffect(AgentGuest.focusRevision, secondScreenDisplays.isNotEmpty()) {
val nextGame = kotlinx.coroutines.withContext(kotlinx.coroutines.Dispatchers.IO) {
if (SessionState.mode == SessionService.MODE_RUN) SessionState.program?.let { "program:$it" }
else {
@@ -927,7 +933,14 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback {
}
}
}
- if (nextGame != gestureGame) { gestureGame = nextGame; refreshGestureConfig() }
+ if (nextGame != gestureGame) {
+ if (nextGame != null) gameStarts++
+ gestureGame = nextGame
+ refreshGestureConfig()
+ }
+ if (secondScreenDisplays.isNotEmpty()) kotlinx.coroutines.withContext(kotlinx.coroutines.Dispatchers.IO) {
+ runCatching { com.droiddeck.launcher.session.TelemetryOutput.applyAutomatic(this@SessionActivity, nextGame) }
+ }
}
LaunchedEffect(drawerOpen, pcKeyboardOpen, achievementsOpen, gestureSettingsOpen, pipUi, SessionState.suspended) {
if (drawerOpen || pcKeyboardOpen || achievementsOpen || gestureSettingsOpen || pipUi || SessionState.suspended) {
@@ -1177,6 +1190,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback {
touchAuto = getString(if (usingTouchpad()) R.string.session_touch_auto_touchpad else R.string.session_touch_auto_direct),
fexPreset = fexPreset,
secondScreenMode = secondScreenMode,
+ dashboardAvailable = bottomPages().isNotEmpty(),
secondScreenDisplays = secondScreenDisplays,
selectedSecondScreenDisplay = selectedSecondScreenDisplay,
onHud = { on -> SessionPrefs.setHudEnabled(this@SessionActivity, on); hudOn = on; hud.refresh() },
@@ -3038,7 +3052,7 @@ 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))
+ selectSecondScreenMode(SecondScreenMode.opening(SessionPrefs.secondScreenPanel(this), SessionState.deckPad, bottomPages().isNotEmpty()))
dualControlsProvisional = ::loading.isInitialized && loading.visible
}
@@ -3046,7 +3060,7 @@ 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)
+ val wanted = SecondScreenMode.opening(SessionPrefs.secondScreenPanel(this), SessionState.deckPad, bottomPages().isNotEmpty())
if (wanted != secondScreenMode) selectSecondScreenMode(wanted) else secondScreenPresentation?.retryTerminal()
}
@@ -3116,8 +3130,97 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback {
menu = {
DroidDeckTheme { SessionMenu(docked = true) }
},
+ dashboard = if (bottomPages().isEmpty()) null else ({
+ DroidDeckTheme {
+ BottomDashboard(
+ bottomPages(), com.droiddeck.launcher.ui.SessionBottomTab.picked(SessionState.sessionId),
+ gameStarts = gameStarts,
+ onPage = { com.droiddeck.launcher.ui.SessionBottomTab.pick(SessionState.sessionId, it) },
+ onClose = { selectSecondScreenMode(SecondScreenMode.NONE) },
+ onMenu = if (dockDrawer()) ({ drawerOpen = true }) else null,
+ )
+ }
+ }),
)
+ /** Pages for the bottom-screen dashboard; the dashboard is offered only while at least one exists. */
+ private fun bottomPages(): List = sessionBottomPages(BottomPageActions(
+ takeScreenshot = ::captureScreenshot,
+ fps = { if (::hud.isInitialized) hud.liveFps else null },
+ openSettings = ::openSettingsBelow,
+ runningGame = { gestureGame },
+ ))
+
+ // A settings page opened on the bottom screen sits under the dashboard window, so the dashboard hides
+ // until the setting is on, or for at most SETTINGS_WATCH_CHECKS seconds when it is left off (another
+ // app's page closing cannot be seen); choosing Dashboard in the menu again shows it sooner.
+ private fun openSettingsBelow(intent: android.content.Intent, done: () -> Boolean) {
+ val presentation = secondScreenPresentation ?: return
+ val options = android.app.ActivityOptions.makeBasic().setLaunchDisplayId(presentation.display.displayId)
+ val opened = listOf(intent, android.content.Intent(android.provider.Settings.ACTION_NOTIFICATION_LISTENER_SETTINGS)).any {
+ runCatching { startActivity(android.content.Intent(it).addFlags(android.content.Intent.FLAG_ACTIVITY_NEW_TASK), options.toBundle()) }
+ .onFailure { e -> Log.w(TAG, "could not open ${it.action} on display ${presentation.display.displayId}", e) }
+ .isSuccess
+ }
+ if (!opened) return
+ presentation.hide()
+ var checks = 0
+ // Show throws if the display went away while the settings page was open, as in showSecondScreen.
+ fun showAgain() {
+ try {
+ presentation.show()
+ } catch (e: Exception) {
+ Log.w(TAG, "could not show the dashboard again", e)
+ if (secondScreenPresentation === presentation) closeSecondScreen(reset = true)
+ }
+ }
+ uiHandler.postDelayed(object : Runnable {
+ override fun run() {
+ if (secondScreenPresentation !== presentation || presentation.isShowing) return
+ if (done()) {
+ showAgain()
+ return
+ }
+ if (++checks < SETTINGS_WATCH_CHECKS) uiHandler.postDelayed(this, SETTINGS_WATCH_MS) else showAgain()
+ }
+ }, SETTINGS_WATCH_MS)
+ }
+
+ /** Copies the game frame (no overlay) at the size it is shown and saves it to Pictures/DroidDeck. */
+ private fun captureScreenshot(onDone: (Boolean) -> Unit) {
+ // With the glasses as the output the game is drawn on their surface; the phone's surface is hidden then.
+ val source = if (glassesOutputActive) glassesScreen?.surfaceView else if (::surfaceView.isInitialized) surfaceView else null
+ val width = source?.width ?: 0
+ val height = source?.height ?: 0
+ if (source == null || width <= 0 || height <= 0 || source.holder.surface?.isValid != true) {
+ onDone(false)
+ return
+ }
+ val bitmap = try {
+ android.graphics.Bitmap.createBitmap(width, height, android.graphics.Bitmap.Config.ARGB_8888)
+ } catch (_: OutOfMemoryError) {
+ onDone(false)
+ return
+ }
+ try {
+ android.view.PixelCopy.request(source, bitmap, { result ->
+ if (result != android.view.PixelCopy.SUCCESS) {
+ bitmap.recycle()
+ onDone(false)
+ return@request
+ }
+ Thread {
+ val saved = com.droiddeck.launcher.session.BottomScreenshots.save(applicationContext, bitmap)
+ bitmap.recycle()
+ runOnUiThread { onDone(saved) }
+ }.start()
+ }, uiHandler)
+ } catch (_: IllegalArgumentException) {
+ bitmap.recycle()
+ onDone(false)
+ }
+ }
+
private fun tapSteamButton() {
if (SessionState.mode == SessionService.MODE_STEAM) {
padBridge?.applyTouch { st -> st.press(com.droiddeck.launcher.input.PadState.GUIDE, true) }
@@ -4513,6 +4616,8 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback {
private const val TEXT_FIELD_TAP_MS = 1_000L
private const val PAUSED_FRAME_MAX_EDGE = 1920f
private const val PAUSED_FRAME_REDRAW_MS = 150L
+ private const val SETTINGS_WATCH_MS = 1_000L
+ private const val SETTINGS_WATCH_CHECKS = 600
private const val TAG = "SessionActivity"
private var startedScreens = 0
@Volatile private var activeInstallWorker: Any? = null
diff --git a/app/src/main/java/com/droiddeck/launcher/frontend/Library.kt b/app/src/main/java/com/droiddeck/launcher/frontend/Library.kt
index 958e1c5ae2..c623e42233 100644
--- a/app/src/main/java/com/droiddeck/launcher/frontend/Library.kt
+++ b/app/src/main/java/com/droiddeck/launcher/frontend/Library.kt
@@ -101,15 +101,22 @@ object Library {
libraries: List = steamLibraries(context).map { it.first },
): File? {
val ids = listOf(appId.toString(), java.lang.Integer.toString(appId.toInt())).distinct()
+ return prefixRoots(context, libraries, preferredLibrary).asSequence()
+ .flatMap { root -> ids.asSequence().map { id -> File(root, "steamapps/compatdata/$id/pfx") } }
+ .firstOrNull { it.isDirectory }
+ }
+
+ /** Every steamapps/compatdata folder, in the libraries [protonPrefix] searches. */
+ fun compatdataDirs(context: Context, libraries: List = steamLibraries(context).map { it.first }): List =
+ prefixRoots(context, libraries).map { File(it, "steamapps/compatdata") }.filter { it.isDirectory }
+
+ private fun prefixRoots(context: Context, libraries: List, preferredLibrary: File? = null): List {
val secondary = libraries.drop(1).mapNotNull { runCatching { it.canonicalPath }.getOrNull() }.toSet()
fun prefixRoot(root: File): File = if (runCatching { root.canonicalPath }.getOrNull() in secondary)
SecondaryLibrary.privateRoot(context.filesDir, root).takeIf { File(it, "steamapps/compatdata").isDirectory } ?: root
else root
- val roots = (listOfNotNull(preferredLibrary) + libraries).map(::prefixRoot)
+ return (listOfNotNull(preferredLibrary) + libraries).map(::prefixRoot)
.distinctBy { runCatching { it.canonicalPath }.getOrDefault(it.absolutePath) }
- return roots.asSequence()
- .flatMap { root -> ids.asSequence().map { id -> File(root, "steamapps/compatdata/$id/pfx") } }
- .firstOrNull { it.isDirectory }
}
fun steamGames(
diff --git a/app/src/main/java/com/droiddeck/launcher/hud/DroidDeckHudHost.kt b/app/src/main/java/com/droiddeck/launcher/hud/DroidDeckHudHost.kt
index 07ed748436..b6b775f4ba 100644
--- a/app/src/main/java/com/droiddeck/launcher/hud/DroidDeckHudHost.kt
+++ b/app/src/main/java/com/droiddeck/launcher/hud/DroidDeckHudHost.kt
@@ -43,6 +43,9 @@ class DroidDeckHudHost(context: Context) {
var onPresentingWindowChanged: (() -> Unit)? = null
+ /** The frame rate the HUD shows; null while the HUD is off and not counting frames. */
+ val liveFps: Float? get() = if (polling) feed.stats.fps else null
+
/** The HUD itself changed a setting: a tap cycles the size, a long press locks it. */
var onConfigChanged: (() -> Unit)? = null
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 019ac686cf..f030565ff5 100644
--- a/app/src/main/java/com/droiddeck/launcher/input/SecondScreenMode.kt
+++ b/app/src/main/java/com/droiddeck/launcher/input/SecondScreenMode.kt
@@ -9,11 +9,22 @@ enum class SecondScreenMode(val id: String, @StringRes val label: Int) {
NONE("none", R.string.second_mode_none),
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);
+ DECK_CONTROLS("deck-controls", R.string.second_mode_deck_controls),
+ DASHBOARD("dashboard", R.string.second_mode_dashboard);
companion object {
- fun opening(remembered: String?, deckPad: Boolean): SecondScreenMode =
- entries.firstOrNull { it != NONE && it.id == remembered && (it != DECK_CONTROLS || deckPad) } ?: if (deckPad) DECK_CONTROLS else KEYBOARD_TRACKPAD
+ fun opening(remembered: String?, deckPad: Boolean, dashboard: Boolean = false): SecondScreenMode {
+ entries.firstOrNull {
+ it != NONE && it.id == remembered && (it != DECK_CONTROLS || deckPad) && (it != DASHBOARD || dashboard)
+ }?.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 }
+ return when {
+ dashboard && !picked -> DASHBOARD
+ deckPad -> DECK_CONTROLS
+ else -> KEYBOARD_TRACKPAD
+ }
+ }
}
}
diff --git a/app/src/main/java/com/droiddeck/launcher/session/BottomNotifications.kt b/app/src/main/java/com/droiddeck/launcher/session/BottomNotifications.kt
new file mode 100644
index 0000000000..d43b1f6175
--- /dev/null
+++ b/app/src/main/java/com/droiddeck/launcher/session/BottomNotifications.kt
@@ -0,0 +1,65 @@
+package com.droiddeck.launcher.session
+
+import android.app.Notification
+import android.content.Context
+import android.service.notification.NotificationListenerService
+import android.service.notification.StatusBarNotification
+import androidx.compose.runtime.mutableStateListOf
+import androidx.core.app.NotificationManagerCompat
+
+/** One notification for the bottom-screen list. Kept in memory only; never written to disk or logs. */
+data class BottomNotification(val key: String, val app: String, val title: String, val text: String, val postedAt: Long)
+
+/**
+ * Notifications from other apps for the bottom screen, so a message can be read without leaving the game.
+ * Works only after the user allows DroidDeck notification access in Android settings.
+ */
+object BottomNotifications {
+ val items = mutableStateListOf()
+
+ fun granted(context: Context): Boolean =
+ context.packageName in NotificationManagerCompat.getEnabledListenerPackages(context)
+
+ internal fun keep(own: String, pkg: String, ongoing: Boolean, groupSummary: Boolean, title: String, text: String): Boolean =
+ pkg != own && !ongoing && !groupSummary && (title.isNotBlank() || text.isNotBlank())
+
+ internal fun add(list: MutableList, item: BottomNotification) {
+ list.removeAll { it.key == item.key }
+ list.add(0, item)
+ while (list.size > MAX_ITEMS) list.removeAt(list.lastIndex)
+ }
+
+ fun clear() = items.clear()
+
+ internal fun post(context: Context, sbn: StatusBarNotification) {
+ val n = sbn.notification ?: return
+ val extras = n.extras
+ val title = extras?.getCharSequence(Notification.EXTRA_TITLE)?.toString().orEmpty()
+ val text = (extras?.getCharSequence(Notification.EXTRA_BIG_TEXT) ?: extras?.getCharSequence(Notification.EXTRA_TEXT))?.toString().orEmpty()
+ if (!keep(context.packageName, sbn.packageName, sbn.isOngoing, (n.flags and Notification.FLAG_GROUP_SUMMARY) != 0, title, text)) return
+ val app = runCatching {
+ val pm = context.packageManager
+ pm.getApplicationLabel(pm.getApplicationInfo(sbn.packageName, 0)).toString()
+ }.getOrDefault(sbn.packageName)
+ add(items, BottomNotification(sbn.key, app, title, text, sbn.postTime))
+ }
+
+ internal fun remove(key: String) {
+ items.removeAll { it.key == key }
+ }
+
+ private const val MAX_ITEMS = 30
+}
+
+class BottomNotificationListener : NotificationListenerService() {
+ override fun onListenerConnected() {
+ BottomNotifications.clear()
+ runCatching { activeNotifications }.getOrNull()?.sortedBy { it.postTime }?.forEach { BottomNotifications.post(this, it) }
+ }
+
+ override fun onNotificationPosted(sbn: StatusBarNotification) = BottomNotifications.post(this, sbn)
+
+ override fun onNotificationRemoved(sbn: StatusBarNotification) = BottomNotifications.remove(sbn.key)
+
+ override fun onListenerDisconnected() = BottomNotifications.clear()
+}
diff --git a/app/src/main/java/com/droiddeck/launcher/session/BottomScreenshots.kt b/app/src/main/java/com/droiddeck/launcher/session/BottomScreenshots.kt
new file mode 100644
index 0000000000..90010a82cb
--- /dev/null
+++ b/app/src/main/java/com/droiddeck/launcher/session/BottomScreenshots.kt
@@ -0,0 +1,97 @@
+package com.droiddeck.launcher.session
+
+import android.content.ContentValues
+import android.content.Context
+import android.graphics.Bitmap
+import android.net.Uri
+import android.os.Build
+import android.os.Environment
+import android.provider.MediaStore
+import java.io.File
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+
+/** A screenshot for the bottom-screen gallery: one DroidDeck took (a MediaStore [uri]) or one Steam saved (a [file]). */
+data class BottomShot(val uri: Uri?, val file: File?, val takenAt: Long, val steam: Boolean) {
+ val model: Any get() = uri ?: file!!
+}
+
+/** Game frames DroidDeck saves to Pictures/DroidDeck, plus the screenshots Steam keeps under userdata. */
+object BottomScreenshots {
+ private const val FOLDER = "DroidDeck"
+ private const val QUALITY = 95
+ private const val LIMIT = 120
+
+ internal fun fileName(at: Long): String =
+ "DroidDeck_" + SimpleDateFormat("yyyyMMdd_HHmmss", Locale.US).format(Date(at)) + ".jpg"
+
+ fun save(context: Context, bitmap: Bitmap, at: Long = System.currentTimeMillis()): Boolean = runCatching {
+ val name = fileName(at)
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+ val resolver = context.contentResolver
+ val values = ContentValues().apply {
+ put(MediaStore.Images.Media.DISPLAY_NAME, name)
+ put(MediaStore.Images.Media.MIME_TYPE, "image/jpeg")
+ put(MediaStore.Images.Media.DATE_TAKEN, at)
+ put(MediaStore.Images.Media.RELATIVE_PATH, "${Environment.DIRECTORY_PICTURES}/$FOLDER")
+ put(MediaStore.Images.Media.IS_PENDING, 1)
+ }
+ val uri = resolver.insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, values) ?: return false
+ val written = runCatching {
+ resolver.openOutputStream(uri)?.use { bitmap.compress(Bitmap.CompressFormat.JPEG, QUALITY, it) } == true
+ }.getOrDefault(false)
+ if (!written) {
+ resolver.delete(uri, null, null)
+ return false
+ }
+ resolver.update(uri, ContentValues().apply { put(MediaStore.Images.Media.IS_PENDING, 0) }, null, null)
+ true
+ } else {
+ @Suppress("DEPRECATION")
+ val dir = File(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES), FOLDER)
+ if (!dir.isDirectory && !dir.mkdirs()) return false
+ val file = File(dir, name)
+ file.outputStream().use { bitmap.compress(Bitmap.CompressFormat.JPEG, QUALITY, it) }
+ android.media.MediaScannerConnection.scanFile(context, arrayOf(file.path), arrayOf("image/jpeg"), null)
+ true
+ }
+ }.getOrDefault(false)
+
+ /** Newest first, at most [LIMIT]. */
+ fun list(context: Context, runtimeRoot: File): List =
+ (own(context) + steam(runtimeRoot)).sortedByDescending { it.takenAt }.take(LIMIT)
+
+ private fun own(context: Context): List = runCatching {
+ if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
+ @Suppress("DEPRECATION")
+ val dir = File(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES), FOLDER)
+ return dir.listFiles { f -> f.isFile && f.name.endsWith(".jpg", true) }.orEmpty()
+ .map { BottomShot(null, it, it.lastModified(), steam = false) }
+ }
+ val shots = ArrayList()
+ context.contentResolver.query(
+ MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
+ arrayOf(MediaStore.Images.Media._ID, MediaStore.Images.Media.DATE_TAKEN, MediaStore.Images.Media.DATE_ADDED),
+ "${MediaStore.Images.Media.RELATIVE_PATH} = ?", arrayOf("${Environment.DIRECTORY_PICTURES}/$FOLDER/"),
+ "${MediaStore.Images.Media.DATE_ADDED} DESC",
+ )?.use { c ->
+ while (c.moveToNext() && shots.size < LIMIT) {
+ val taken = c.getLong(1).takeIf { it > 0L } ?: (c.getLong(2) * 1000L)
+ shots += BottomShot(android.content.ContentUris.withAppendedId(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, c.getLong(0)),
+ null, taken, steam = false)
+ }
+ }
+ shots
+ }.getOrDefault(emptyList())
+
+ /** The .jpg files in userdata//760/remote//screenshots of each Steam home; the thumbnails folder is skipped. */
+ internal fun steam(runtimeRoot: File): List =
+ SteamDownloadMonitor.STEAM_HOMES.flatMap { home ->
+ File(runtimeRoot, "$home/userdata").listFiles { f -> f.isDirectory }.orEmpty().flatMap { account ->
+ File(account, "760/remote").listFiles { f -> f.isDirectory }.orEmpty().flatMap { app ->
+ File(app, "screenshots").listFiles { f -> f.isFile && f.name.endsWith(".jpg", true) }.orEmpty().toList()
+ }
+ }
+ }.map { BottomShot(null, it, it.lastModified(), steam = true) }
+}
diff --git a/app/src/main/java/com/droiddeck/launcher/session/GameTelemetry.kt b/app/src/main/java/com/droiddeck/launcher/session/GameTelemetry.kt
new file mode 100644
index 0000000000..28777f6b06
--- /dev/null
+++ b/app/src/main/java/com/droiddeck/launcher/session/GameTelemetry.kt
@@ -0,0 +1,232 @@
+package com.droiddeck.launcher.session
+
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+
+/** One reading from a racing game's telemetry. Fractions are 0..1; null means the game does not send it. */
+data class Telemetry(
+ val source: String,
+ val speedKmh: Float? = null,
+ val rpm: Float? = null,
+ val maxRpm: Float? = null,
+ val gear: String? = null,
+ val throttle: Float? = null,
+ val brake: Float? = null,
+ val lap: Int? = null,
+ val laps: Int? = null,
+ val position: Int? = null,
+ val fuel: Float? = null,
+ val currentLapS: Float? = null,
+ val lastLapS: Float? = null,
+ val bestLapS: Float? = null,
+ /** G-force as the game sends it (lateral, longitudinal) and steering from -1 (left) to 1 (right). */
+ val gLat: Float? = null,
+ val gLon: Float? = null,
+ val steer: Float? = null,
+ /** Front left, front right, rear left, rear right. */
+ val tireTempsC: List? = null,
+ val turboBar: Float? = null,
+ val engineTempC: Float? = null,
+ val oilTempC: Float? = null,
+ /** OutGauge dashboard lights that are on, as GameTelemetry.DL_* bits. */
+ val lights: Int? = null,
+)
+
+/**
+ * Racing telemetry games send over UDP to 127.0.0.1. Each format has its own port, the one the game or
+ * its common tools use by default:
+ * - [CODEMASTERS_PORT]: DiRT Rally 1/2, DiRT 4, GRID ("extradata 3" float array), DiRT Showdown (152-byte packet).
+ * - [FORZA_PORT]: Forza Motorsport 7/2023 and Forza Horizon 4/5 "Data Out" (Sled and Dash).
+ * - [OUTGAUGE_PORT]: BeamNG.drive and Live for Speed OutGauge.
+ */
+object GameTelemetry {
+ const val CODEMASTERS_PORT = 20777
+ const val FORZA_PORT = 5300
+ const val OUTGAUGE_PORT = 4444
+ val PORTS = listOf(CODEMASTERS_PORT, FORZA_PORT, OUTGAUGE_PORT)
+
+ // Games send to 127.0.0.1; on Android InetAddress.getLoopbackAddress() is ::1, which IPv4 packets never reach.
+ val LISTEN_ADDRESS: java.net.InetAddress = java.net.InetAddress.getByAddress(byteArrayOf(127, 0, 0, 1))
+
+ fun parse(port: Int, data: ByteArray, length: Int): Telemetry? = runCatching {
+ val buf = ByteBuffer.wrap(data, 0, length).order(ByteOrder.LITTLE_ENDIAN)
+ when (port) {
+ CODEMASTERS_PORT -> codemasters(buf, length)
+ FORZA_PORT -> forza(buf, length)
+ OUTGAUGE_PORT -> outGauge(buf, length)
+ else -> null
+ }
+ }.getOrNull()
+
+ private const val MPS_TO_KMH = 3.6f
+ private const val GRAVITY = 9.81f
+
+ // OutGauge DashLights / ShowLights bits (Live for Speed InSim; BeamNG uses the same values).
+ const val DL_SHIFT = 1
+ const val DL_HANDBRAKE = 4
+ const val DL_PITSPEED = 8
+ const val DL_TC = 16
+ const val DL_ABS = 1024
+
+ // Float indexes of the Codemasters packet; engine rpm values are sent divided by 10. Older games
+ // (DiRT Showdown) send only the first 38 floats, so lap count, position, fuel and max rpm are missing there.
+ private const val CM_LAP_TIME = 1
+ private const val CM_SPEED = 7
+ private const val CM_THROTTLE = 29
+ private const val CM_STEER = 30
+ private const val CM_BRAKE = 31
+ private const val CM_GEAR = 33
+ private const val CM_G_LAT = 34
+ private const val CM_G_LON = 35
+ private const val CM_LAP = 36
+ private const val CM_RPM = 37
+ private const val CM_POSITION = 39
+ private const val CM_FUEL = 45
+ private const val CM_FUEL_CAPACITY = 46
+ private const val CM_LAPS = 60
+ private const val CM_LAST_LAP = 62
+ private const val CM_MAX_RPM = 63
+ private const val CM_MIN_FLOATS = 38
+
+ internal fun codemasters(buf: ByteBuffer, length: Int): Telemetry? {
+ if (length < CM_MIN_FLOATS * 4) return null
+ val floats = length / 4
+ fun f(i: Int) = if (i < floats) buf.getFloat(i * 4) else 0f
+ val gear = f(CM_GEAR).toInt()
+ val capacity = f(CM_FUEL_CAPACITY)
+ return Telemetry(
+ source = "Codemasters",
+ speedKmh = f(CM_SPEED) * MPS_TO_KMH,
+ rpm = f(CM_RPM) * 10f,
+ maxRpm = (f(CM_MAX_RPM) * 10f).takeIf { it > 0f },
+ // Neutral is 0; DiRT Rally 2.0 reports reverse as 10, older games as -1.
+ gear = when {
+ gear == 0 -> "N"
+ gear < 0 || gear == 10 -> "R"
+ else -> gear.toString()
+ },
+ throttle = f(CM_THROTTLE).coerceIn(0f, 1f),
+ brake = f(CM_BRAKE).coerceIn(0f, 1f),
+ lap = f(CM_LAP).toInt() + 1,
+ laps = f(CM_LAPS).toInt().takeIf { it > 0 },
+ position = f(CM_POSITION).toInt().takeIf { it > 0 },
+ fuel = if (capacity > 0f) (f(CM_FUEL) / capacity).coerceIn(0f, 1f) else null,
+ currentLapS = f(CM_LAP_TIME).takeIf { it > 0f },
+ lastLapS = f(CM_LAST_LAP).takeIf { it > 0f },
+ gLat = f(CM_G_LAT),
+ gLon = f(CM_G_LON),
+ steer = f(CM_STEER).coerceIn(-1f, 1f),
+ )
+ }
+
+ // Forza "Data Out": Sled is 232 bytes; the Dash block follows it (FM7 311, FM 2023 331). Horizon 4/5 send
+ // 324 bytes with 12 extra bytes before the Dash block.
+ private const val FORZA_SLED = 232
+ private const val FORZA_FM7 = 311
+ private const val FORZA_HORIZON = 324
+ private const val FORZA_FM2023 = 331
+ private const val HORIZON_SHIFT = 12
+
+ internal fun forza(buf: ByteBuffer, length: Int): Telemetry? {
+ if (length < FORZA_SLED) return null
+ val racing = buf.getInt(0) != 0
+ val maxRpm = buf.getFloat(8)
+ val rpm = buf.getFloat(16)
+ val dash = when (length) {
+ FORZA_FM7, FORZA_FM2023 -> FORZA_SLED
+ FORZA_HORIZON -> FORZA_SLED + HORIZON_SHIFT
+ else -> -1
+ }
+ if (dash < 0) return Telemetry(source = "Forza", rpm = rpm, maxRpm = maxRpm.takeIf { it > 0f })
+ if (!racing) return Telemetry(source = "Forza")
+ val gear = buf.get(dash + 75).toInt() and 0xFF
+ // Tire temperatures are read as Fahrenheit, as community Data Out parsers do; not checked on a device.
+ val tiresF = (0 until 4).map { buf.getFloat(dash + 24 + it * 4) }
+ return Telemetry(
+ source = "Forza",
+ speedKmh = buf.getFloat(dash + 12) * MPS_TO_KMH,
+ rpm = rpm,
+ maxRpm = maxRpm.takeIf { it > 0f },
+ gear = if (gear == 0) "R" else gear.toString(),
+ throttle = (buf.get(dash + 71).toInt() and 0xFF) / 255f,
+ brake = (buf.get(dash + 72).toInt() and 0xFF) / 255f,
+ lap = (buf.getShort(dash + 68).toInt() and 0xFFFF) + 1,
+ position = (buf.get(dash + 70).toInt() and 0xFF).takeIf { it > 0 },
+ fuel = buf.getFloat(dash + 44).coerceIn(0f, 1f),
+ currentLapS = buf.getFloat(dash + 60).takeIf { it > 0f },
+ lastLapS = buf.getFloat(dash + 56).takeIf { it > 0f },
+ bestLapS = buf.getFloat(dash + 52).takeIf { it > 0f },
+ gLat = buf.getFloat(20) / GRAVITY,
+ gLon = buf.getFloat(28) / GRAVITY,
+ steer = (buf.get(dash + 76).toFloat() / 127f).coerceIn(-1f, 1f),
+ tireTempsC = tiresF.takeIf { f -> f.any { it > 0f } }?.map { (it - 32f) * 5f / 9f },
+ )
+ }
+
+ // OutGauge: 92 bytes, or 96 with the optional id at the end.
+ private const val OUTGAUGE_SIZE = 92
+
+ internal fun outGauge(buf: ByteBuffer, length: Int): Telemetry? {
+ if (length < OUTGAUGE_SIZE) return null
+ val gear = buf.get(10).toInt() and 0xFF
+ return Telemetry(
+ source = "OutGauge",
+ speedKmh = buf.getFloat(12) * MPS_TO_KMH,
+ rpm = buf.getFloat(16),
+ gear = when (gear) {
+ 0 -> "R"
+ 1 -> "N"
+ else -> (gear - 1).toString()
+ },
+ throttle = buf.getFloat(48).coerceIn(0f, 1f),
+ brake = buf.getFloat(52).coerceIn(0f, 1f),
+ fuel = buf.getFloat(28).coerceIn(0f, 1f),
+ turboBar = buf.getFloat(20).takeIf { it != 0f },
+ engineTempC = buf.getFloat(24).takeIf { it != 0f },
+ oilTempC = buf.getFloat(36).takeIf { it != 0f },
+ lights = buf.getInt(44).takeIf { buf.getInt(40) != 0 },
+ )
+ }
+}
+
+/** Games that publish their state locally without any setup: War Thunder's web page and Elite Dangerous' Status.json. */
+object GameStatusFiles {
+ const val WAR_THUNDER_STATE = "http://127.0.0.1:8111/state"
+ private const val ELITE_APP = "359320"
+ private const val ELITE_STATUS = "pfx/drive_c/users/steamuser/Saved Games/Frontier Developments/Elite Dangerous/Status.json"
+ const val WAR_THUNDER_ROWS = 12
+
+ /** War Thunder's own labels (for example "TAS, km/h") with their values, while a match runs. */
+ internal fun warThunder(json: String): List> {
+ val state = org.json.JSONObject(json)
+ if (!state.optBoolean("valid", false)) return emptyList()
+ return state.keys().asSequence().filter { it != "valid" }.mapNotNull { key ->
+ val value = state.opt(key) as? Number ?: return@mapNotNull null
+ key to if (value.toDouble() % 1.0 == 0.0) value.toLong().toString() else "%.1f".format(java.util.Locale.US, value.toDouble())
+ }.toList()
+ }
+
+ fun eliteStatusFile(runtimeRoot: java.io.File, mounts: Map): java.io.File? {
+ val libraries = SteamDownloadMonitor.manifests(runtimeRoot, mounts).mapNotNull { it.parentFile } +
+ SteamDownloadMonitor.STEAM_HOMES.map { java.io.File(runtimeRoot, "$it/steamapps") }
+ return libraries.distinct().map { java.io.File(it, "compatdata/$ELITE_APP/$ELITE_STATUS") }.firstOrNull { it.isFile }
+ }
+
+ data class Elite(val fuelMain: Double?, val fuelReserve: Double?, val cargo: Double?, val pips: List?, val legal: String?, val balance: Long?)
+
+ /** Null while Elite is at its menus (Status.json then carries only the timestamp and flags). */
+ internal fun elite(json: String): Elite? {
+ val s = org.json.JSONObject(json)
+ val fuel = s.optJSONObject("Fuel")
+ val pips = s.optJSONArray("Pips")?.let { a -> (0 until a.length()).map { a.optInt(it) } }
+ if (fuel == null && pips == null && !s.has("Cargo") && !s.has("Balance")) return null
+ return Elite(
+ fuelMain = fuel?.optDouble("FuelMain")?.takeIf { !it.isNaN() },
+ fuelReserve = fuel?.optDouble("FuelReservoir")?.takeIf { !it.isNaN() },
+ cargo = s.optDouble("Cargo").takeIf { !it.isNaN() },
+ pips = pips,
+ legal = s.optString("LegalState").takeIf { it.isNotEmpty() },
+ balance = if (s.has("Balance")) s.optLong("Balance") else null,
+ )
+ }
+}
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 1f94f3a7e9..9bc5e59fe1 100644
--- a/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt
+++ b/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt
@@ -170,6 +170,7 @@ object SessionFiles {
"usr/local/lib/droiddeck/uruntime" to "usr/local/lib/droiddeck/uruntime",
"usr/local/lib/droiddeck-pipewire.tzst" to "usr/local/lib/droiddeck-pipewire.tzst",
"usr/local/share/licenses/uruntime/LICENSE" to "usr/local/share/licenses/uruntime/LICENSE",
+ "usr/local/lib/droiddeck-dirt/ws2_32.dll" to "usr/local/lib/droiddeck-dirt/ws2_32.dll",
) + mangoapp + msitools.map { it to it } + vr + fexPreloads).filter { (asset, _) ->
val dir = asset.substringBeforeLast('/')
runCatching { context.assets.list("linuxfs/$dir")?.contains(asset.substringAfterLast('/')) == true }.getOrDefault(false)
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 4e3f824155..5b82b22f06 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,38 @@ object SessionPrefs {
prefs(context).edit().putString("secondScreenPanel", mode).apply()
}
+ fun statsStrip(context: Context): String? = prefs(context).getString("statsStrip", null)
+
+ fun setStatsStrip(context: Context, id: String) {
+ prefs(context).edit().putString("statsStrip", id).apply()
+ }
+
+ fun statsSpeedUnit(context: Context): String? = prefs(context).getString("statsSpeedUnit", null)
+
+ fun setStatsSpeedUnit(context: Context, id: String) {
+ prefs(context).edit().putString("statsSpeedUnit", id).apply()
+ }
+
+ fun statsDash(context: Context): String? = prefs(context).getString("statsDash", null)
+
+ fun setStatsDash(context: Context, id: String) {
+ prefs(context).edit().putString("statsDash", id).apply()
+ }
+
+ /** In-game stats "Send dashboard data" Automatic: on unless the user switched it off. */
+ fun telemetryAuto(context: Context): Boolean = prefs(context).getBoolean("telemetryAuto", true)
+
+ fun setTelemetryAuto(context: Context, on: Boolean) {
+ prefs(context).edit().putBoolean("telemetryAuto", on).apply()
+ }
+
+ /** Games the user switched off by hand, as TelemetryOutput keys; Automatic leaves them alone. */
+ fun telemetryOff(context: Context): Set = prefs(context).getStringSet("telemetryOff", null)?.toSet().orEmpty()
+
+ fun setTelemetryOff(context: Context, keys: Set) {
+ prefs(context).edit().putStringSet("telemetryOff", keys.toSet()).apply()
+ }
+
fun dualScreenLauncher(context: Context): Boolean = prefs(context).getBoolean("dualScreenLauncher", true)
fun setDualScreenLauncher(context: Context, on: Boolean) {
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 fee992446c..3a34404c2b 100644
--- a/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt
+++ b/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt
@@ -73,7 +73,9 @@ class SessionService : Service() {
private var downloadMonitorTask: Runnable? = null
private var downloadActive = false
private var clientInstallActive = false
- @Volatile private var steamLibraryMounts = emptyMap()
+ private var steamLibraryMounts: Map
+ get() = SessionState.steamLibraryMounts
+ set(value) { SessionState.steamLibraryMounts = value }
private var suspendDownloadNow = false
private var suspendPolicy = SessionPrefs.SUSPEND_MANUAL
private var steamDownloadsInBackground = false
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 0d19d49bc0..3cf93a322d 100644
--- a/app/src/main/java/com/droiddeck/launcher/session/SessionState.kt
+++ b/app/src/main/java/com/droiddeck/launcher/session/SessionState.kt
@@ -94,6 +94,9 @@ object SessionState {
@Volatile var secondScreenAutoOpened = false
@Volatile var secondScreenProvisional = false
+ /** Guest library paths on removable storage and the host folders they are mounted from, set by SessionService. */
+ @Volatile var steamLibraryMounts: Map = emptyMap()
+
@Volatile
var mode = "steam"
diff --git a/app/src/main/java/com/droiddeck/launcher/session/SettingsReset.kt b/app/src/main/java/com/droiddeck/launcher/session/SettingsReset.kt
index b78b1896c9..bce07bba5b 100644
--- a/app/src/main/java/com/droiddeck/launcher/session/SettingsReset.kt
+++ b/app/src/main/java/com/droiddeck/launcher/session/SettingsReset.kt
@@ -26,7 +26,7 @@ object SettingsReset {
"upscaler", "upscaleSharpness", "screenEffects", "textureAnisotropy", "textureLodBias",
"steamDownloadsInBackground", "steam_offline", "bootMovie", "bootMovieSound", "bootMovieVolume", "bootMovieSeconds",
"bootMovieApplyNext", "bootMovieSteamSeen",
- "questDefaultsV1",
+ "questDefaultsV1", "telemetryAuto", "telemetryOff", "statsStrip", "statsDash", "statsSpeedUnit",
)
internal val SESSION_PREFIXES = listOf(
diff --git a/app/src/main/java/com/droiddeck/launcher/session/StatsLayout.kt b/app/src/main/java/com/droiddeck/launcher/session/StatsLayout.kt
new file mode 100644
index 0000000000..d0ff1486a9
--- /dev/null
+++ b/app/src/main/java/com/droiddeck/launcher/session/StatsLayout.kt
@@ -0,0 +1,50 @@
+package com.droiddeck.launcher.session
+
+/** The In-game stats page's top strip, picked on the page (tap or the Layout row) and remembered. */
+enum class StatsStrip(val id: String) {
+ PANEL("panel"), TILES("tiles"), RINGS("rings");
+
+ fun next(): StatsStrip = entries[(ordinal + 1) % entries.size]
+
+ companion object {
+ fun from(id: String?): StatsStrip = entries.firstOrNull { it.id == id } ?: PANEL
+ }
+}
+
+/** Speeds on the racing dashes; telemetry arrives in km/h. */
+enum class SpeedUnit(val id: String, val label: String, val perKmh: Float) {
+ AUTO("auto", "", 1f), KMH("kmh", "km/h", 1f), MPH("mph", "mph", 0.621371f);
+
+ /** Auto is mph where road speed limits are signed in mph, by the device's region, else km/h. */
+ fun resolve(country: String): SpeedUnit = if (this != AUTO) this else if (country.uppercase() in MPH_REGIONS) MPH else KMH
+
+ fun next(): SpeedUnit = entries[(ordinal + 1) % entries.size]
+
+ companion object {
+ /** The United States and its territories, the United Kingdom and its Crown Dependencies, Liberia, the Bahamas, Belize. */
+ private val MPH_REGIONS = setOf("US", "PR", "GU", "VI", "AS", "MP", "GB", "IM", "JE", "GG", "LR", "BS", "BZ")
+
+ fun from(id: String?): SpeedUnit = entries.firstOrNull { it.id == id } ?: AUTO
+ }
+}
+
+/** The racing dash under the strip; Auto picks one by the game's data format. */
+enum class StatsDash(val id: String) {
+ AUTO("auto"), SPEEDOMETER("speedometer"), CIRCUIT("circuit"), TRACE("trace"), DIALS("dials"), GLANCE("glance");
+
+ /** The dash to draw for data from [source] (Telemetry.source). */
+ fun resolve(source: String): StatsDash = if (this != AUTO) this else when (source) {
+ "Forza" -> CIRCUIT
+ "OutGauge" -> DIALS
+ else -> SPEEDOMETER
+ }
+
+ companion object {
+ private val DRAWN = listOf(SPEEDOMETER, CIRCUIT, TRACE, DIALS, GLANCE)
+
+ fun from(id: String?): StatsDash = entries.firstOrNull { it.id == id } ?: AUTO
+
+ /** A tap on the dash moves on from the one on screen, so Auto never looks like a tap did nothing. */
+ fun tapped(shown: StatsDash): StatsDash = DRAWN[(DRAWN.indexOf(shown) + 1).mod(DRAWN.size)]
+ }
+}
diff --git a/app/src/main/java/com/droiddeck/launcher/session/SteamDownloadMonitor.kt b/app/src/main/java/com/droiddeck/launcher/session/SteamDownloadMonitor.kt
index ff3602c1bd..ccc8693c33 100644
--- a/app/src/main/java/com/droiddeck/launcher/session/SteamDownloadMonitor.kt
+++ b/app/src/main/java/com/droiddeck/launcher/session/SteamDownloadMonitor.kt
@@ -101,34 +101,6 @@ internal class SteamDownloadMonitor {
now - lastContentActivityAt <= CONTENT_ACTIVITY_GRACE_MS
}
- private fun manifests(runtimeRoot: File, mounts: Map): List {
- val steamRoots = linkedSetOf()
- for (home in STEAM_HOMES) {
- val primary = File(runtimeRoot, home)
- steamRoots += primary
- val libraryFolders = File(primary, "steamapps/libraryfolders.vdf")
- runCatching {
- PATH.findAll(libraryFolders.readText()).forEach { match ->
- steamRoots += hostPath(runtimeRoot, match.groupValues[1], mounts)
- }
- }
- }
- return steamRoots.flatMap { root ->
- File(root, "steamapps").listFiles { file ->
- file.isFile && file.name.startsWith("appmanifest_") && file.name.endsWith(".acf")
- }.orEmpty().toList()
- }
- }
-
- private fun hostPath(runtimeRoot: File, guest: String, mounts: Map): File {
- val path = guest.trimEnd('/')
- for ((mount, host) in mounts) {
- if (path == mount) return host
- if (path.startsWith("$mount/")) return File(host, path.removePrefix("$mount/"))
- }
- return File(runtimeRoot, path.removePrefix("/"))
- }
-
private fun read(file: File): ManifestState {
val text = runCatching { file.readText() }.getOrDefault("")
val flags = value(text, "StateFlags")?.toLongOrNull() ?: 0L
@@ -137,9 +109,6 @@ internal class SteamDownloadMonitor {
return ManifestState(downloaded, flags != 4L && (total <= 0L || downloaded < total))
}
- private fun value(text: String, key: String): String? =
- Regex("\"$key\"\\s+\"([^\"]*)\"").find(text)?.groupValues?.get(1)
-
companion object {
fun clientInstallPending(runtimeRoot: File): Boolean {
val home = File(runtimeRoot, "root")
@@ -149,12 +118,43 @@ internal class SteamDownloadMonitor {
return !(stamped && File(steam, "steamrtarm64/steam").isFile) || File(home, ".bl-steam-repair").exists()
}
+ internal fun manifests(runtimeRoot: File, mounts: Map): List {
+ val steamRoots = linkedSetOf()
+ for (home in STEAM_HOMES) {
+ val primary = File(runtimeRoot, home)
+ steamRoots += primary
+ val libraryFolders = File(primary, "steamapps/libraryfolders.vdf")
+ runCatching {
+ PATH.findAll(libraryFolders.readText()).forEach { match ->
+ steamRoots += hostPath(runtimeRoot, match.groupValues[1], mounts)
+ }
+ }
+ }
+ return steamRoots.flatMap { root ->
+ File(root, "steamapps").listFiles { file ->
+ file.isFile && file.name.startsWith("appmanifest_") && file.name.endsWith(".acf")
+ }.orEmpty().toList()
+ }
+ }
+
+ private fun hostPath(runtimeRoot: File, guest: String, mounts: Map): File {
+ val path = guest.trimEnd('/')
+ for ((mount, host) in mounts) {
+ if (path == mount) return host
+ if (path.startsWith("$mount/")) return File(host, path.removePrefix("$mount/"))
+ }
+ return File(runtimeRoot, path.removePrefix("/"))
+ }
+
+ internal fun value(text: String, key: String): String? =
+ Regex("\"$key\"\\s+\"([^\"]*)\"").find(text)?.groupValues?.get(1)
+
private const val MANIFEST_PROGRESS_GRACE_MS = 8_000L
private const val CONTENT_ACTIVITY_GRACE_MS = 90_000L
private const val MIN_RECEIVE_BYTES_PER_SEC = 64L * 1024L
private val PATH = Regex("\"path\"\\s+\"([^\"]+)\"")
- private val STEAM_HOMES = listOf("root/.local/share/Steam", "root/.droiddeck-x64/.local/share/Steam")
- private val CONTENT_UPDATE = Regex("""AppID (\d+) (App|Workshop|Shader) update changed : (.*)""")
+ internal val STEAM_HOMES = listOf("root/.local/share/Steam", "root/.droiddeck-x64/.local/share/Steam")
+ internal val CONTENT_UPDATE = Regex("""AppID (\d+) (App|Workshop|Shader) update changed : (.*)""")
private val CURRENT_RATE = Regex("""Current download rate: ([\d.]+) Mbps""")
}
}
diff --git a/app/src/main/java/com/droiddeck/launcher/session/SteamDownloads.kt b/app/src/main/java/com/droiddeck/launcher/session/SteamDownloads.kt
new file mode 100644
index 0000000000..b8b898457f
--- /dev/null
+++ b/app/src/main/java/com/droiddeck/launcher/session/SteamDownloads.kt
@@ -0,0 +1,76 @@
+package com.droiddeck.launcher.session
+
+import java.io.File
+import java.io.RandomAccessFile
+
+/** A Steam download or update the client is working on. [total] is 0 while Steam has not sized it yet. */
+data class SteamDownload(
+ val appId: String,
+ val name: String,
+ val done: Long,
+ val total: Long,
+ val shader: Boolean = false,
+ val paused: Boolean = false,
+)
+
+/** Reads Steam's own appmanifests and content log, the same files [SteamDownloadMonitor] watches. */
+object SteamDownloads {
+ fun read(runtimeRoot: File, mounts: Map = emptyMap(), client: String? = null): List {
+ val names = HashMap()
+ val apps = SteamDownloadMonitor.manifests(runtimeRoot, mounts).mapNotNull { file ->
+ val text = runCatching { file.readText() }.getOrNull() ?: return@mapNotNull null
+ val id = SteamDownloadMonitor.value(text, "appid") ?: file.name.removePrefix("appmanifest_").removeSuffix(".acf")
+ val name = SteamDownloadMonitor.value(text, "name") ?: id
+ names[id] = name
+ fromManifest(id, name, text)
+ }.let(::onePerApp)
+ val homes = client?.let { listOf(if (it == "x86_64") SteamDownloadMonitor.STEAM_HOMES[1] else SteamDownloadMonitor.STEAM_HOMES[0]) }
+ ?: SteamDownloadMonitor.STEAM_HOMES
+ val log = homes.map { File(runtimeRoot, "$it/logs/content_log.txt") }.filter { it.isFile }.maxByOrNull { it.lastModified() }
+ val shaders = log?.let { runningShaderUpdates(tail(it)) }.orEmpty()
+ .map { SteamDownload(it, names[it] ?: it, 0L, 0L, shader = true) }
+ return apps + shaders
+ }
+
+ /** The arm64 and x86-64 Steam homes can both hold an unfinished manifest of one app; the page keys rows by app. */
+ internal fun onePerApp(downloads: List): List =
+ downloads.groupBy { it.appId }.values.map { same -> same.maxBy { it.done } }
+
+ internal fun fromManifest(id: String, name: String, text: String): SteamDownload? {
+ val flags = SteamDownloadMonitor.value(text, "StateFlags")?.toLongOrNull() ?: 0L
+ if (flags == FULLY_INSTALLED) return null
+ val done = SteamDownloadMonitor.value(text, "BytesDownloaded")?.toLongOrNull() ?: 0L
+ val total = SteamDownloadMonitor.value(text, "BytesToDownload")?.toLongOrNull() ?: 0L
+ if (total > 0L && done >= total) return null
+ if ((flags and UPDATE_REQUIRED) == 0L && total <= 0L) return null
+ return SteamDownload(id, name, done, total, paused = (flags and UPDATE_PAUSED) != 0L)
+ }
+
+ /** App ids whose latest shader-cache line in the content log says the update is still running. */
+ internal fun runningShaderUpdates(lines: Sequence): List {
+ val state = LinkedHashMap()
+ for (line in lines) {
+ if ("Client version:" in line) state.clear()
+ val match = SteamDownloadMonitor.CONTENT_UPDATE.find(line) ?: continue
+ if (match.groupValues[2] != "Shader") continue
+ val running = match.groupValues[3].let { "Running Update" in it && "Stopping" !in it }
+ state[match.groupValues[1]] = running
+ }
+ return state.filterValues { it }.keys.toList()
+ }
+
+ private fun tail(file: File): Sequence = runCatching {
+ RandomAccessFile(file, "r").use { raf ->
+ val start = (raf.length() - TAIL_BYTES).coerceAtLeast(0L)
+ raf.seek(start)
+ val bytes = ByteArray((raf.length() - start).toInt())
+ raf.readFully(bytes)
+ String(bytes, Charsets.ISO_8859_1).lineSequence().drop(if (start > 0L) 1 else 0).toList().asSequence()
+ }
+ }.getOrDefault(emptySequence())
+
+ private const val FULLY_INSTALLED = 4L
+ private const val UPDATE_REQUIRED = 2L
+ private const val UPDATE_PAUSED = 512L
+ private const val TAIL_BYTES = 256L * 1024L
+}
diff --git a/app/src/main/java/com/droiddeck/launcher/session/SteamWebLogin.kt b/app/src/main/java/com/droiddeck/launcher/session/SteamWebLogin.kt
new file mode 100644
index 0000000000..f9075857fb
--- /dev/null
+++ b/app/src/main/java/com/droiddeck/launcher/session/SteamWebLogin.kt
@@ -0,0 +1,81 @@
+package com.droiddeck.launcher.session
+
+import android.database.sqlite.SQLiteDatabase
+import java.io.File
+import javax.crypto.Cipher
+import javax.crypto.SecretKeyFactory
+import javax.crypto.spec.IvParameterSpec
+import javax.crypto.spec.PBEKeySpec
+import javax.crypto.spec.SecretKeySpec
+
+/** A cookie for one https host, in the form CookieManager.setCookie takes. */
+data class WebCookie(val host: String, val header: String)
+
+/**
+ * The web sign-in the Steam client in the session already has, so the bottom-screen chat opens signed in.
+ * Steam's built-in browser keeps it in its Chromium cookie store under config/htmlcache. With no keyring
+ * (SteamOS and DroidDeck) Chromium encrypts values as "v10": AES-128-CBC, key PBKDF2-SHA1("peanuts",
+ * "saltysalt", 1 round), IV of 16 spaces. Values are never logged.
+ */
+object SteamWebLogin {
+ val HOSTS = listOf("steamcommunity.com", "steam-chat.com")
+ private const val COOKIES = "config/htmlcache/Default/Cookies"
+ private const val V10 = "v10"
+ // From cookie store version 24 Chromium puts the SHA-256 of the host before each value.
+ private const val HOST_HASH_VERSION = 24
+ private const val HOST_HASH_BYTES = 32
+
+ private val key: SecretKeySpec by lazy {
+ val spec = PBEKeySpec("peanuts".toCharArray(), "saltysalt".toByteArray(), 1, 128)
+ SecretKeySpec(SecretKeyFactory.getInstance("PBKDF2WithHmacSHA1").generateSecret(spec).encoded, "AES")
+ }
+
+ internal fun decrypt(encrypted: ByteArray, hostHashed: Boolean): String? = runCatching {
+ if (encrypted.size <= V10.length || String(encrypted, 0, V10.length, Charsets.US_ASCII) != V10) return null
+ val cipher = Cipher.getInstance("AES/CBC/PKCS5Padding")
+ cipher.init(Cipher.DECRYPT_MODE, key, IvParameterSpec(ByteArray(16) { ' '.code.toByte() }))
+ val plain = cipher.doFinal(encrypted, V10.length, encrypted.size - V10.length)
+ val value = if (hostHashed && plain.size >= HOST_HASH_BYTES) plain.copyOfRange(HOST_HASH_BYTES, plain.size) else plain
+ String(value, Charsets.UTF_8)
+ }.getOrNull()
+
+ /** Steam's own pages send the sign-in with its "||" separator percent-encoded. */
+ internal fun header(name: String, value: String, httpOnly: Boolean): String {
+ val v = if (name == "steamLoginSecure") value.replace("||", "%7C%7C") else value
+ return "$name=$v; Path=/; Secure" + if (httpOnly) "; HttpOnly" else ""
+ }
+
+ /** Empty when the client has no web sign-in, for example before the first login. */
+ fun read(runtimeRoot: File, client: String?, scratch: File): List {
+ val homes = client?.let { listOf(if (it == "x86_64") SteamDownloadMonitor.STEAM_HOMES[1] else SteamDownloadMonitor.STEAM_HOMES[0]) }
+ ?: SteamDownloadMonitor.STEAM_HOMES
+ val store = homes.map { File(runtimeRoot, "$it/$COOKIES") }.filter { it.isFile }.maxByOrNull { it.lastModified() }
+ ?: return emptyList()
+ // A copy, journal included: Steam keeps the store open and may be in the middle of a write.
+ scratch.deleteRecursively()
+ if (!scratch.mkdirs()) return emptyList()
+ return try {
+ val copy = File(scratch, "Cookies")
+ store.copyTo(copy, overwrite = true)
+ File(store.path + "-journal").takeIf { it.length() > 0L }?.copyTo(File(scratch, "Cookies-journal"), overwrite = true)
+ SQLiteDatabase.openDatabase(copy.path, null, SQLiteDatabase.OPEN_READWRITE).use { db ->
+ val version = db.rawQuery("SELECT value FROM meta WHERE key = 'version'", null).use { if (it.moveToFirst()) it.getString(0).toIntOrNull() else null } ?: 0
+ val marks = HOSTS.joinToString { "?" }
+ db.rawQuery("SELECT host_key, name, value, encrypted_value, is_httponly FROM cookies WHERE host_key IN ($marks)", HOSTS.toTypedArray()).use { c ->
+ val out = ArrayList()
+ while (c.moveToNext()) {
+ val name = c.getString(1)
+ val value = c.getString(2).takeUnless { it.isNullOrEmpty() }
+ ?: decrypt(c.getBlob(3) ?: continue, version >= HOST_HASH_VERSION) ?: continue
+ out += WebCookie(c.getString(0), header(name, value, c.getInt(4) != 0))
+ }
+ out
+ }
+ }
+ } catch (_: Exception) {
+ emptyList()
+ } finally {
+ scratch.deleteRecursively()
+ }
+ }
+}
diff --git a/app/src/main/java/com/droiddeck/launcher/session/TelemetryOutput.kt b/app/src/main/java/com/droiddeck/launcher/session/TelemetryOutput.kt
new file mode 100644
index 0000000000..afd60b02d1
--- /dev/null
+++ b/app/src/main/java/com/droiddeck/launcher/session/TelemetryOutput.kt
@@ -0,0 +1,121 @@
+package com.droiddeck.launcher.session
+
+import android.content.Context
+import com.droiddeck.launcher.frontend.Library
+import java.io.File
+
+/**
+ * Codemasters games keep their UDP / motion output in My Games//hardwaresettings/hardware_settings_config.xml
+ * inside the game's Proton prefix and read it when the game starts. Turning it on points that element at the
+ * In-game stats listener; the file as it was is kept beside it, and its element is put back when turned off.
+ */
+object TelemetryOutput {
+ data class Game(val name: String, val prefixId: String, val file: File, val on: Boolean)
+
+ data class MenuGame(val name: String, val setting: String, val port: Int)
+
+ /** Games whose output is only a setting in the game's own menus, by Steam app id. */
+ val MENU_GAMES: Map = mapOf(
+ 1293830 to MenuGame("Forza Horizon 4", "Data Out", GameTelemetry.FORZA_PORT),
+ 1551360 to MenuGame("Forza Horizon 5", "Data Out", GameTelemetry.FORZA_PORT),
+ 2440510 to MenuGame("Forza Motorsport", "Data Out", GameTelemetry.FORZA_PORT),
+ 284160 to MenuGame("BeamNG.drive", "OutGauge", GameTelemetry.OUTGAUGE_PORT),
+ )
+
+ internal const val ORIGINAL_SUFFIX = ".droiddeck-original"
+ private const val MY_GAMES = "pfx/drive_c/users/steamuser/Documents/My Games"
+ private const val CONFIG = "hardwaresettings/hardware_settings_config.xml"
+ private const val ADDRESS = "127.0.0.1"
+ private const val EXTRADATA = "3"
+ private val TAGS = listOf("udp", "motion")
+ // Byte-for-byte: every byte maps to one char and back, whatever the file's own encoding is.
+ private val BYTES = Charsets.ISO_8859_1
+
+ fun scan(compatdata: List): List = compatdata.asSequence()
+ .flatMap { root -> root.listFiles { f -> f.isDirectory }.orEmpty().asSequence() }
+ .flatMap { prefix -> File(prefix, MY_GAMES).listFiles { f -> f.isDirectory }.orEmpty().asSequence().map { prefix to it } }
+ .mapNotNull { (prefix, game) ->
+ val file = File(game, CONFIG)
+ val text = runCatching { file.readText(BYTES) }.getOrNull() ?: return@mapNotNull null
+ val element = element(text) ?: return@mapNotNull null
+ Game(game.name, prefix.name, file, pointsHere(element.value))
+ }
+ .sortedBy { it.name.lowercase() }
+ .toList()
+
+ /** Turns the game's output on or off; false when the file could not be read or written. */
+ fun set(game: Game, on: Boolean): Boolean = runCatching {
+ val file = game.file
+ val original = File(file.path + ORIGINAL_SUFFIX)
+ val xml = file.readText(BYTES)
+ val next = if (on) {
+ if (!original.exists()) file.copyTo(original)
+ turnedOn(xml)
+ } else {
+ turnedOff(xml, original.takeIf { it.isFile }?.readText(BYTES))
+ }
+ checkNotNull(next)
+ val tmp = File(file.path + ".droiddeck-tmp")
+ tmp.writeText(next, BYTES)
+ check(tmp.renameTo(file))
+ if (!on) original.delete()
+ true
+ }.getOrDefault(false)
+
+ /** Automatic: turns the output on for every found game the user has not switched off and that is not running. */
+ fun applyAutomatic(context: Context, running: String?) {
+ if (!SessionPrefs.telemetryAuto(context)) return
+ automaticTargets(scan(Library.compatdataDirs(context)), SessionPrefs.telemetryOff(context), running).forEach { set(it, true) }
+ }
+
+ internal fun key(game: Game) = "${game.prefixId}/${game.name}"
+
+ internal fun automaticTargets(games: List, off: Set, running: String?): List =
+ games.filter { !it.on && key(it) !in off && !isRunning(it.prefixId, running) }
+
+ /** Games DroidDeck changed, which go back to their own setting when Automatic is switched off. */
+ internal fun restoreTargets(games: List, running: String?): List =
+ games.filter { File(it.file.path + ORIGINAL_SUFFIX).isFile && !isRunning(it.prefixId, running) }
+
+ /** Whether [running] (the focused Steam app id, or another key for non-Steam programs) may be the game in [prefixId]. */
+ internal fun isRunning(prefixId: String, running: String?): Boolean {
+ val id = running?.toLongOrNull() ?: return running != null
+ return prefixId == id.toString() || prefixId == id.toInt().toString()
+ }
+
+ internal fun element(xml: String): MatchResult? = TAGS.firstNotNullOfOrNull { tag -> tagRegex(tag).find(xml) }
+
+ internal fun pointsHere(element: String): Boolean =
+ attr(element, "enabled") == "true" && attr(element, "ip") == ADDRESS &&
+ attr(element, "port") == GameTelemetry.CODEMASTERS_PORT.toString() &&
+ (attr(element, "extradata") ?: EXTRADATA) == EXTRADATA
+
+ internal fun turnedOn(xml: String): String? {
+ val element = element(xml) ?: return null
+ var on = withAttr(element.value, "enabled", "true")
+ on = withAttr(on, "ip", ADDRESS)
+ on = withAttr(on, "port", GameTelemetry.CODEMASTERS_PORT.toString())
+ if (attr(on, "extradata") != null) on = withAttr(on, "extradata", EXTRADATA)
+ return xml.replaceRange(element.range, on)
+ }
+
+ internal fun turnedOff(xml: String, original: String?): String? {
+ val element = element(xml) ?: return null
+ val tag = element.value.drop(1).takeWhile { !it.isWhitespace() }
+ val before = original?.let { tagRegex(tag).find(it)?.value }
+ return xml.replaceRange(element.range, before ?: withAttr(element.value, "enabled", "false"))
+ }
+
+ internal fun attr(element: String, name: String): String? =
+ Regex("\\s$name=\"([^\"]*)\"").find(element)?.groupValues?.get(1)
+
+ internal fun withAttr(element: String, name: String, value: String): String {
+ val existing = Regex("(\\s$name=\")[^\"]*\"")
+ if (existing.containsMatchIn(element)) return existing.replace(element) { it.groupValues[1] + value + "\"" }
+ val selfClosing = element.endsWith("/>")
+ val body = element.dropLast(if (selfClosing) 2 else 1).trimEnd()
+ return "$body $name=\"$value\"" + if (selfClosing) " />" else ">"
+ }
+
+ private fun tagRegex(tag: String) = Regex("<$tag\\s[^>]*>")
+}
diff --git a/app/src/main/java/com/droiddeck/launcher/ui/BottomChatPage.kt b/app/src/main/java/com/droiddeck/launcher/ui/BottomChatPage.kt
new file mode 100644
index 0000000000..e609537b78
--- /dev/null
+++ b/app/src/main/java/com/droiddeck/launcher/ui/BottomChatPage.kt
@@ -0,0 +1,215 @@
+package com.droiddeck.launcher.ui
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.media.AudioManager
+import android.view.ViewGroup
+import android.webkit.CookieManager
+import android.webkit.RenderProcessGoneDetail
+import android.webkit.WebResourceRequest
+import android.webkit.WebSettings
+import android.webkit.WebView
+import android.webkit.WebViewClient
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.LocalLifecycleOwner
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import androidx.compose.ui.viewinterop.AndroidView
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleEventObserver
+import com.droiddeck.launcher.R
+import com.droiddeck.launcher.session.SessionService
+import com.droiddeck.launcher.session.SessionState
+import com.droiddeck.launcher.session.SteamWebLogin
+import com.droiddeck.launcher.runtime.LinuxRuntime
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlinx.coroutines.withContext
+import java.io.File
+import kotlin.coroutines.resume
+import kotlin.math.roundToInt
+
+private const val STEAM_CHAT = "https://steamcommunity.com/chat"
+private const val CHAT_PAGE_SCALE = 0.75f
+private val STEAM_HOSTS = listOf("steamcommunity.com", "steam-chat.com", "steampowered.com", "steamstatic.com", "steamcontent.com")
+
+/** Steam chat stays on Steam's own sites; anything else is not opened on the bottom screen. */
+internal fun steamChatAllows(host: String?): Boolean =
+ host != null && STEAM_HOSTS.any { host == it || host.endsWith(".$it") }
+
+/** The desktop chat fits the bottom panel better than the phone site; keep WebView's Chrome version. */
+internal fun desktopUserAgent(webView: String?): String {
+ val chrome = webView?.let { Regex("Chrome/[\\d.]+").find(it)?.value } ?: "Chrome/127.0.6533.103"
+ return "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) $chrome Safari/537.36"
+}
+
+/**
+ * At the panel's own scale Steam's desktop chat gets about 600x300 CSS pixels and its friends list collapses, so the
+ * page is laid out [cssWidth] wide and drawn at [scale]. Steam's site header (the rows before .chat_main_flex; its
+ * class name is generated) is hidden to leave the height to the friends list and the chat. The group chat list keeps
+ * a fixed 114 px height and an empty-list note that cover the online friends, so it shrinks to its rows (at most a
+ * quarter of the panel) and the note is hidden.
+ */
+internal fun steamChatFitScript(cssWidth: Int, scale: Float): String {
+ val zoom = "%.2f".format(java.util.Locale.US, scale)
+ return "(function(){var m=document.querySelector('meta[name=viewport]');" +
+ "if(!m){m=document.createElement('meta');m.name='viewport';document.head.appendChild(m);}" +
+ "m.content='width=$cssWidth, initial-scale=$zoom';" +
+ "if(!document.getElementById('dd-chat-fit')){var s=document.createElement('style');s.id='dd-chat-fit';" +
+ "s.textContent='$STEAM_CHAT_FIT_CSS';document.head.appendChild(s);}" +
+ "window.dispatchEvent(new Event('resize'));})()"
+}
+
+internal const val STEAM_CHAT_FIT_CSS = ".chat_main>:has(~.chat_main_flex){display:none!important}" +
+ ".ChatRoomList_Empty{display:none!important}" +
+ ".chatRoomListContainer{height:auto!important;max-height:25vh!important}"
+
+@Composable
+fun BottomChatPage() {
+ val context = LocalContext.current
+ val colors = MaterialTheme.colorScheme
+ var chatOpen by remember { mutableStateOf(true) }
+ // Set when Android ended the page's renderer; the chat opens again once DroidDeck is back in front.
+ var stopped by remember { mutableStateOf(false) }
+ val lifecycle = LocalLifecycleOwner.current.lifecycle
+ DisposableEffect(lifecycle) {
+ val observer = LifecycleEventObserver { _, event ->
+ if (event == Lifecycle.Event.ON_RESUME && stopped) {
+ stopped = false
+ chatOpen = true
+ }
+ }
+ lifecycle.addObserver(observer)
+ onDispose { lifecycle.removeObserver(observer) }
+ }
+ // null while the Steam client's sign-in is being copied, then whether there was one.
+ var fromSteam by remember { mutableStateOf(null) }
+ LaunchedEffect(chatOpen) {
+ if (!chatOpen) {
+ fromSteam = null
+ return@LaunchedEffect
+ }
+ val cookies = withContext(Dispatchers.IO) {
+ SteamWebLogin.read(LinuxRuntime.rootDir(context), SessionState.steamClientArch, File(context.cacheDir, "steam-web-login"))
+ }
+ val manager = CookieManager.getInstance()
+ for (c in cookies) suspendCancellableCoroutine { cont -> manager.setCookie("https://${c.host}", c.header) { cont.resume(Unit) } }
+ manager.flush()
+ fromSteam = cookies.any { it.header.startsWith("steamLoginSecure=") }
+ }
+ Column(Modifier.fillMaxSize(), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+ if (!chatOpen) {
+ VoiceRow(context)
+ Column(Modifier.weight(1f).fillMaxWidth().padding(24.dp), horizontalAlignment = Alignment.CenterHorizontally,
+ verticalArrangement = Arrangement.spacedBy(16.dp, Alignment.CenterVertically)) {
+ if (stopped) Text(stringResource(R.string.bottom_chat_stopped), fontSize = 13.sp, color = colors.onSurfaceVariant, textAlign = TextAlign.Center)
+ Text(stringResource(R.string.bottom_chat_why), fontSize = 15.sp, color = colors.onBackground, textAlign = TextAlign.Center)
+ BottomPillButton(stringResource(R.string.bottom_chat_open), "bottom-chat-open") {
+ stopped = false
+ chatOpen = true
+ }
+ }
+ } else {
+ VoiceRow(context, onClose = { chatOpen = false },
+ note = if (fromSteam == false) stringResource(R.string.bottom_chat_not_signed_in) else "")
+ Box(Modifier.weight(1f).fillMaxWidth().clip(RoundedCornerShape(14.dp))) {
+ if (fromSteam != null) SteamChatView(onStopped = {
+ stopped = true
+ chatOpen = false
+ })
+ }
+ }
+ }
+}
+
+/** With [onClose] set the chat is open: the row also carries Close and leaves out the long mic hint. */
+@Composable
+private fun VoiceRow(context: Context, onClose: (() -> Unit)? = null, note: String = "") {
+ val colors = MaterialTheme.colorScheme
+ val audio = remember { context.getSystemService(Context.AUDIO_SERVICE) as AudioManager }
+ val max = remember { audio.getStreamMaxVolume(AudioManager.STREAM_MUSIC).coerceAtLeast(1) }
+ var volume by remember { mutableIntStateOf(audio.getStreamVolume(AudioManager.STREAM_MUSIC)) }
+ fun step(direction: Int) {
+ // No flags: Android's volume panel would cover the game on the main screen.
+ audio.adjustStreamVolume(AudioManager.STREAM_MUSIC, direction, 0)
+ volume = audio.getStreamVolume(AudioManager.STREAM_MUSIC)
+ }
+ Row(Modifier.fillMaxWidth(), verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+ if (onClose != null) BottomPillButton(stringResource(R.string.bottom_chat_close), "bottom-chat-close", onClose)
+ if (SessionState.micAvailable) {
+ val on = SessionState.micEnabled
+ BottomPillButton(stringResource(if (on) R.string.bottom_chat_mic_on else R.string.bottom_chat_mic_off), "bottom-chat-mic") {
+ SessionService.setMicEnabled(context, !on)
+ }
+ }
+ val hint = if (onClose == null && !SessionState.micAvailable) stringResource(R.string.bottom_chat_mic_unavailable) else note
+ Text(hint, fontSize = 12.sp, color = colors.onSurfaceVariant, maxLines = 3, modifier = Modifier.weight(1f))
+ Text(stringResource(R.string.bottom_chat_volume, volume * 100 / max), fontSize = 14.sp, color = colors.onSurfaceVariant)
+ BottomPillButton("−", "bottom-chat-volume-down") { step(AudioManager.ADJUST_LOWER) }
+ BottomPillButton("+", "bottom-chat-volume-up") { step(AudioManager.ADJUST_RAISE) }
+ }
+}
+
+@SuppressLint("SetJavaScriptEnabled")
+@Composable
+private fun SteamChatView(onStopped: () -> Unit) {
+ AndroidView(factory = { ctx ->
+ WebView(ctx).apply {
+ // AndroidView's default WRAP_CONTENT height gives the page a 0 px tall viewport, which collapses Steam
+ // chat's full-height layout (measured on the Retroid Pocket Duo: html and every container 0 px).
+ layoutParams = ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT)
+ setBackgroundColor(0xFF0A0B0D.toInt())
+ settings.javaScriptEnabled = true
+ settings.domStorageEnabled = true
+ settings.allowFileAccess = false
+ settings.allowContentAccess = false
+ settings.useWideViewPort = true
+ settings.loadWithOverviewMode = true
+ settings.userAgentString = desktopUserAgent(runCatching { WebSettings.getDefaultUserAgent(ctx) }.getOrNull())
+ CookieManager.getInstance().setAcceptCookie(true)
+ webViewClient = object : WebViewClient() {
+ override fun shouldOverrideUrlLoading(view: WebView, request: WebResourceRequest): Boolean =
+ !steamChatAllows(request.url.host)
+
+ override fun onPageFinished(view: WebView, url: String) {
+ val scale = view.resources.displayMetrics.density * CHAT_PAGE_SCALE
+ if (view.width > 0) view.evaluateJavascript(steamChatFitScript((view.width / scale).roundToInt(), CHAT_PAGE_SCALE), null)
+ }
+
+ // Android ends the page's renderer once DroidDeck goes to picture-in-picture ("isolated not needed"
+ // on the Retroid Pocket Duo); the page cannot come back, so the chat closes and reopens on resume.
+ override fun onRenderProcessGone(view: WebView, detail: RenderProcessGoneDetail): Boolean {
+ onStopped()
+ return true
+ }
+ }
+ loadUrl(STEAM_CHAT)
+ }
+ }, modifier = Modifier.fillMaxSize(), onRelease = { view ->
+ CookieManager.getInstance().flush()
+ view.destroy()
+ })
+}
diff --git a/app/src/main/java/com/droiddeck/launcher/ui/BottomDashboard.kt b/app/src/main/java/com/droiddeck/launcher/ui/BottomDashboard.kt
new file mode 100644
index 0000000000..4943d99d7e
--- /dev/null
+++ b/app/src/main/java/com/droiddeck/launcher/ui/BottomDashboard.kt
@@ -0,0 +1,161 @@
+package com.droiddeck.launcher.ui
+
+import androidx.annotation.StringRes
+import androidx.compose.foundation.background
+import androidx.compose.foundation.border
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.horizontalScroll
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.BoxWithConstraints
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.Close
+import androidx.compose.material.icons.outlined.Menu
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.Role
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import com.droiddeck.launcher.R
+
+/** A page the bottom screen can show while the game runs on the main screen. */
+class BottomPage(
+ val id: String,
+ @StringRes val label: Int,
+ val icon: ImageVector,
+ val content: @Composable () -> Unit,
+)
+
+internal fun pickBottomPage(remembered: String?, ids: List): String? =
+ ids.firstOrNull { it == remembered } ?: ids.firstOrNull { it == DEFAULT_PAGE } ?: ids.firstOrNull()
+
+/**
+ * The tab picked during one session. Each Steam session starts with no pick, so the dashboard opens on Chat; reopened
+ * later in the same session it shows the tab picked last.
+ */
+internal object SessionBottomTab {
+ private var session: String? = null
+ private var tab: String? = null
+
+ @Synchronized
+ fun picked(sessionId: String?): String? = tab.takeIf { sessionId != null && sessionId == session }
+
+ @Synchronized
+ fun pick(sessionId: String?, id: String) {
+ session = sessionId
+ tab = id
+ }
+}
+
+/** The page a game start switches to; not remembered as the user's pick. */
+internal fun pageForGameStart(ids: List): String? = GAME_PAGE.takeIf { it in ids }
+
+private const val DEFAULT_PAGE = "chat"
+private const val GAME_PAGE = "telemetry"
+
+/** Tabs show their names while every tab still fits at [TAB_WIDTH]; otherwise only the open tab keeps its name. */
+internal fun bottomTabsWithLabels(widthDp: Float, tabs: Int): Boolean = tabs * TAB_WIDTH + 2 * BAR_BUTTON <= widthDp
+
+private const val TAB_WIDTH = 132f
+private const val BAR_BUTTON = 56f
+
+@Composable
+fun BottomDashboard(
+ pages: List,
+ remembered: String?,
+ onPage: (String) -> Unit,
+ onClose: () -> Unit,
+ onMenu: (() -> Unit)?,
+ gameStarts: Int = 0,
+) {
+ val colors = MaterialTheme.colorScheme
+ var current by remember { mutableStateOf(pickBottomPage(remembered, pages.map { it.id })) }
+ val startsWhenOpened = remember { gameStarts }
+ LaunchedEffect(gameStarts) {
+ if (gameStarts != startsWhenOpened) pageForGameStart(pages.map { it.id })?.let { current = it }
+ }
+ val page = pages.firstOrNull { it.id == current } ?: pages.firstOrNull()
+ BoxWithConstraints(Modifier.fillMaxSize().background(colors.background)) {
+ val labels = bottomTabsWithLabels(maxWidth.value, pages.size)
+ Column(Modifier.fillMaxSize().padding(horizontal = 12.dp, vertical = 10.dp), verticalArrangement = Arrangement.spacedBy(10.dp)) {
+ Row(Modifier.fillMaxWidth().height(48.dp), verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+ BarButton(Icons.Outlined.Close, stringResource(R.string.deck_close), "bottom-close", onClose)
+ Row(Modifier.weight(1f).horizontalScroll(rememberScrollState()), horizontalArrangement = Arrangement.spacedBy(6.dp)) {
+ pages.forEach { p ->
+ PageTab(p, p.id == page?.id, labels) {
+ current = p.id
+ onPage(p.id)
+ }
+ }
+ }
+ if (onMenu != null) BarButton(Icons.Outlined.Menu, stringResource(R.string.touch_droiddeck_menu), "bottom-menu", onMenu)
+ }
+ Box(Modifier.weight(1f).fillMaxWidth()) {
+ if (page != null) page.content()
+ else Text(stringResource(R.string.bottom_dashboard_empty), fontSize = 15.sp, color = colors.onSurfaceVariant,
+ modifier = Modifier.align(Alignment.Center))
+ }
+ }
+ }
+}
+
+@Composable
+private fun BarButton(icon: ImageVector, label: String, tag: String, onClick: () -> Unit) {
+ val pal = LocalPalette.current
+ Box(
+ Modifier.size(44.dp).clip(RoundedCornerShape(22.dp)).background(pal.surface).border(1.dp, pal.line, RoundedCornerShape(22.dp))
+ .semantics { contentDescription = label }.clickable(role = Role.Button, onClick = onClick).testTag(tag),
+ contentAlignment = Alignment.Center,
+ ) {
+ Icon(icon, contentDescription = null, tint = MaterialTheme.colorScheme.onBackground, modifier = Modifier.size(22.dp))
+ }
+}
+
+@Composable
+private fun PageTab(page: BottomPage, selected: Boolean, label: Boolean, onClick: () -> Unit) {
+ val colors = MaterialTheme.colorScheme
+ val pal = LocalPalette.current
+ val shape = RoundedCornerShape(20.dp)
+ val name = stringResource(page.label)
+ Row(
+ Modifier.height(44.dp).clip(shape)
+ .background(if (selected) pal.signal else Color.Transparent)
+ .border(1.dp, if (selected) pal.signal else pal.line, shape)
+ .semantics { contentDescription = name }
+ .clickable(role = Role.Tab, onClick = onClick).testTag("bottom-page-${page.id}")
+ .padding(horizontal = 14.dp),
+ verticalAlignment = Alignment.CenterVertically,
+ horizontalArrangement = Arrangement.spacedBy(8.dp),
+ ) {
+ val tint = if (selected) colors.background else colors.onBackground
+ Icon(page.icon, contentDescription = null, tint = tint, modifier = Modifier.size(20.dp))
+ if (label || selected) Text(name, fontSize = 14.sp, fontWeight = FontWeight.SemiBold, color = tint, maxLines = 1, overflow = TextOverflow.Ellipsis)
+ }
+}
diff --git a/app/src/main/java/com/droiddeck/launcher/ui/BottomDownloadsPage.kt b/app/src/main/java/com/droiddeck/launcher/ui/BottomDownloadsPage.kt
new file mode 100644
index 0000000000..0ca56a10b4
--- /dev/null
+++ b/app/src/main/java/com/droiddeck/launcher/ui/BottomDownloadsPage.kt
@@ -0,0 +1,126 @@
+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.Row
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.LinearProgressIndicator
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import com.droiddeck.launcher.R
+import com.droiddeck.launcher.runtime.LinuxRuntime
+import com.droiddeck.launcher.session.SessionState
+import com.droiddeck.launcher.session.SteamDownload
+import com.droiddeck.launcher.session.SteamDownloads
+import com.droiddeck.launcher.stores.StoresState
+import com.droiddeck.launcher.stores.download.DownloadState
+import com.droiddeck.launcher.stores.formatBytes
+import com.droiddeck.launcher.stores.formatSpeed
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.withContext
+
+/** Bytes per second between two reads of the same download; 0 when it did not move or restarted. */
+internal fun downloadRate(previousDone: Long, previousAt: Long, done: Long, at: Long): Long =
+ if (previousDone < 0L || done <= previousDone || at <= previousAt) 0L else (done - previousDone) * 1000L / (at - previousAt)
+
+private const val STEAM_POLL_MS = 2_000L
+
+private class SteamRow(val download: SteamDownload, val rate: Long)
+
+@Composable
+fun BottomDownloadsPage() {
+ val context = LocalContext.current
+ val colors = MaterialTheme.colorScheme
+ var steam by remember { mutableStateOf>(emptyList()) }
+ LaunchedEffect(Unit) {
+ var last = emptyMap>()
+ while (true) {
+ val now = System.currentTimeMillis()
+ val read = withContext(Dispatchers.IO) {
+ runCatching {
+ SteamDownloads.read(LinuxRuntime.rootDir(context), SessionState.steamLibraryMounts, SessionState.steamClientArch)
+ }.getOrDefault(emptyList())
+ }
+ steam = read.map { d ->
+ val before = last[d.appId]
+ SteamRow(d, if (before == null) 0L else downloadRate(before.first, before.second, d.done, now))
+ }
+ last = read.associate { it.appId to (it.done to now) }
+ delay(STEAM_POLL_MS)
+ }
+ }
+ val store = StoresState.downloads.filter { it.isActive }
+ if (steam.isEmpty() && store.isEmpty()) {
+ Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
+ Text(stringResource(R.string.bottom_downloads_none), fontSize = 15.sp, color = colors.onSurfaceVariant)
+ }
+ return
+ }
+ LazyColumn(Modifier.fillMaxSize(), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+ items(steam, key = { "steam:${it.download.appId}:${it.download.shader}" }) { row ->
+ val d = row.download
+ val detail = when {
+ d.shader -> stringResource(R.string.bottom_downloads_shader)
+ d.paused -> stringResource(R.string.bottom_downloads_paused)
+ d.total <= 0L -> stringResource(R.string.bottom_downloads_queued)
+ else -> listOf("${formatBytes(d.done)} / ${formatBytes(d.total)}", formatSpeed(row.rate)).filter { it.isNotEmpty() }.joinToString(" · ")
+ }
+ BottomDownloadRow(d.name, stringResource(R.string.bottom_downloads_steam), detail,
+ if (d.total > 0L) (d.done.toFloat() / d.total).coerceIn(0f, 1f) else null)
+ }
+ items(store, key = { "store:${it.key}" }) { entry ->
+ val e = StoresState.download(entry.key) ?: entry
+ val detail = when (e.state) {
+ DownloadState.PAUSED -> stringResource(R.string.bottom_downloads_paused)
+ DownloadState.QUEUED -> stringResource(R.string.bottom_downloads_queued)
+ else -> listOf(
+ if (e.bytesTotal > 0L) "${formatBytes(e.bytesDone)} / ${formatBytes(e.bytesTotal)}" else "",
+ formatSpeed(e.speedBps),
+ ).filter { it.isNotEmpty() }.joinToString(" · ")
+ }
+ BottomDownloadRow(e.name, e.store.label, detail, e.stageFraction.takeIf { it >= 0f })
+ }
+ }
+}
+
+@Composable
+private fun BottomDownloadRow(name: String, source: String, detail: String, fraction: Float?) {
+ val colors = MaterialTheme.colorScheme
+ val pal = LocalPalette.current
+ Column(
+ Modifier.fillMaxWidth().clip(RoundedCornerShape(14.dp)).background(pal.surface).padding(horizontal = 14.dp, vertical = 10.dp),
+ verticalArrangement = Arrangement.spacedBy(6.dp),
+ ) {
+ Row(verticalAlignment = Alignment.CenterVertically) {
+ Text(name, fontSize = 15.sp, fontWeight = FontWeight.SemiBold, color = colors.onBackground,
+ maxLines = 1, overflow = TextOverflow.Ellipsis, modifier = Modifier.weight(1f))
+ Text(source, fontSize = 12.sp, color = colors.onSurfaceVariant, maxLines = 1, modifier = Modifier.padding(start = 8.dp))
+ }
+ if (fraction != null) LinearProgressIndicator(progress = { fraction }, modifier = Modifier.fillMaxWidth(), color = pal.signal)
+ else LinearProgressIndicator(modifier = Modifier.fillMaxWidth(), color = pal.signal)
+ if (detail.isNotEmpty()) Text(detail, fontSize = 13.sp, color = colors.onSurfaceVariant, maxLines = 1, overflow = TextOverflow.Ellipsis)
+ }
+}
diff --git a/app/src/main/java/com/droiddeck/launcher/ui/BottomNotificationsPage.kt b/app/src/main/java/com/droiddeck/launcher/ui/BottomNotificationsPage.kt
new file mode 100644
index 0000000000..379c74b6d8
--- /dev/null
+++ b/app/src/main/java/com/droiddeck/launcher/ui/BottomNotificationsPage.kt
@@ -0,0 +1,117 @@
+package com.droiddeck.launcher.ui
+
+import android.content.Intent
+import android.provider.Settings
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.Role
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import com.droiddeck.launcher.R
+import com.droiddeck.launcher.session.BottomNotifications
+import kotlinx.coroutines.delay
+
+/** DroidDeck's own switch on Android 11 and later; the list of all apps before that. */
+internal fun notificationAccessIntent(context: android.content.Context): Intent =
+ if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.R) {
+ Intent(Settings.ACTION_NOTIFICATION_LISTENER_DETAIL_SETTINGS).putExtra(
+ Settings.EXTRA_NOTIFICATION_LISTENER_COMPONENT_NAME,
+ android.content.ComponentName(context, com.droiddeck.launcher.session.BottomNotificationListener::class.java).flattenToString(),
+ )
+ } else Intent(Settings.ACTION_NOTIFICATION_LISTENER_SETTINGS)
+
+@Composable
+fun BottomNotificationsPage(openSettings: ((Intent, () -> Boolean) -> Unit)?) {
+ val context = LocalContext.current
+ val colors = MaterialTheme.colorScheme
+ val pal = LocalPalette.current
+ var granted by remember { mutableStateOf(BottomNotifications.granted(context)) }
+ LaunchedEffect(Unit) {
+ while (true) {
+ granted = BottomNotifications.granted(context)
+ delay(2_000L)
+ }
+ }
+ if (!granted) {
+ Column(Modifier.fillMaxSize().padding(24.dp), horizontalAlignment = Alignment.CenterHorizontally,
+ verticalArrangement = Arrangement.spacedBy(16.dp, Alignment.CenterVertically)) {
+ Text(stringResource(R.string.bottom_notifications_why), fontSize = 15.sp, color = colors.onBackground, textAlign = TextAlign.Center)
+ BottomPillButton(stringResource(R.string.bottom_notifications_allow), "bottom-notifications-allow") {
+ val intent = notificationAccessIntent(context)
+ if (openSettings != null) openSettings(intent) { BottomNotifications.granted(context) }
+ else runCatching { context.startActivity(intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)) }
+ }
+ }
+ return
+ }
+ val shown = BottomNotifications.items
+ if (shown.isEmpty()) {
+ Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
+ Text(stringResource(R.string.bottom_notifications_none), fontSize = 15.sp, color = colors.onSurfaceVariant)
+ }
+ return
+ }
+ val timeFormat = remember { android.text.format.DateFormat.getTimeFormat(context) }
+ Column(Modifier.fillMaxSize(), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+ Row(Modifier.fillMaxWidth(), verticalAlignment = Alignment.CenterVertically) {
+ Text(stringResource(R.string.bottom_notifications_count, shown.size), fontSize = 13.sp, color = colors.onSurfaceVariant,
+ modifier = Modifier.weight(1f))
+ BottomPillButton(stringResource(R.string.bottom_notifications_clear), "bottom-notifications-clear") { BottomNotifications.clear() }
+ }
+ LazyColumn(Modifier.weight(1f).fillMaxWidth(), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+ items(shown.toList(), key = { it.key }) { n ->
+ Column(Modifier.fillMaxWidth().clip(RoundedCornerShape(14.dp)).background(pal.surface).padding(horizontal = 14.dp, vertical = 10.dp),
+ verticalArrangement = Arrangement.spacedBy(4.dp)) {
+ Row(verticalAlignment = Alignment.CenterVertically) {
+ Text(n.app, fontSize = 12.sp, fontWeight = FontWeight.SemiBold, color = pal.signal, maxLines = 1,
+ overflow = TextOverflow.Ellipsis, modifier = Modifier.weight(1f))
+ Text(timeFormat.format(java.util.Date(n.postedAt)), fontSize = 12.sp, color = colors.onSurfaceVariant)
+ }
+ if (n.title.isNotBlank()) Text(n.title, fontSize = 15.sp, fontWeight = FontWeight.SemiBold, color = colors.onBackground,
+ maxLines = 1, overflow = TextOverflow.Ellipsis)
+ if (n.text.isNotBlank()) Text(n.text, fontSize = 14.sp, color = colors.onBackground, maxLines = 4, overflow = TextOverflow.Ellipsis)
+ }
+ }
+ }
+ }
+}
+
+@Composable
+internal fun BottomPillButton(label: String, tag: String, onClick: () -> Unit) {
+ val pal = LocalPalette.current
+ Box(
+ Modifier.height(40.dp).clip(RoundedCornerShape(20.dp)).background(pal.signal.copy(alpha = 0.16f))
+ .clickable(role = Role.Button, onClick = onClick).testTag(tag).padding(horizontal = 16.dp),
+ contentAlignment = Alignment.Center,
+ ) {
+ Text(label, fontSize = 14.sp, fontWeight = FontWeight.SemiBold, color = pal.signal, maxLines = 1)
+ }
+}
diff --git a/app/src/main/java/com/droiddeck/launcher/ui/BottomPages.kt b/app/src/main/java/com/droiddeck/launcher/ui/BottomPages.kt
new file mode 100644
index 0000000000..da9695cf95
--- /dev/null
+++ b/app/src/main/java/com/droiddeck/launcher/ui/BottomPages.kt
@@ -0,0 +1,28 @@
+package com.droiddeck.launcher.ui
+
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.Download
+import androidx.compose.material.icons.outlined.Forum
+import androidx.compose.material.icons.outlined.Speed
+import androidx.compose.material.icons.outlined.Notifications
+import androidx.compose.material.icons.outlined.PhotoLibrary
+import com.droiddeck.launcher.R
+
+/** What the bottom-screen pages can ask the running session to do. */
+class BottomPageActions(
+ val takeScreenshot: ((onDone: (Boolean) -> Unit) -> Unit)? = null,
+ val fps: () -> Float? = { null },
+ /** Opens an Android settings page on the bottom screen; the dashboard comes back once [done] is true. */
+ val openSettings: ((intent: android.content.Intent, done: () -> Boolean) -> Unit)? = null,
+ /** The focused game's Steam app id as text (or another key for non-Steam programs); null in the Steam menus. */
+ val runningGame: () -> String? = { null },
+)
+
+/** The pages the bottom-screen dashboard offers during a session, in tab order. */
+fun sessionBottomPages(actions: BottomPageActions): List = listOf(
+ BottomPage("telemetry", R.string.bottom_page_telemetry, Icons.Outlined.Speed) { BottomTelemetryPage(actions.fps, actions.runningGame) },
+ BottomPage("downloads", R.string.bottom_page_downloads, Icons.Outlined.Download) { BottomDownloadsPage() },
+ BottomPage("notifications", R.string.bottom_page_notifications, Icons.Outlined.Notifications) { BottomNotificationsPage(actions.openSettings) },
+ BottomPage("screenshots", R.string.bottom_page_screenshots, Icons.Outlined.PhotoLibrary) { BottomScreenshotsPage(actions.takeScreenshot) },
+ BottomPage("chat", R.string.bottom_page_chat, Icons.Outlined.Forum) { BottomChatPage() },
+)
diff --git a/app/src/main/java/com/droiddeck/launcher/ui/BottomScreenshotsPage.kt b/app/src/main/java/com/droiddeck/launcher/ui/BottomScreenshotsPage.kt
new file mode 100644
index 0000000000..e854016fbe
--- /dev/null
+++ b/app/src/main/java/com/droiddeck/launcher/ui/BottomScreenshotsPage.kt
@@ -0,0 +1,110 @@
+package com.droiddeck.launcher.ui
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.aspectRatio
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.grid.GridCells
+import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
+import androidx.compose.foundation.lazy.grid.items
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.Role
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import coil.compose.AsyncImage
+import coil.request.ImageRequest
+import com.droiddeck.launcher.R
+import com.droiddeck.launcher.runtime.LinuxRuntime
+import com.droiddeck.launcher.session.BottomScreenshots
+import com.droiddeck.launcher.session.BottomShot
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.withContext
+
+private const val SHOTS_POLL_MS = 5_000L
+
+@Composable
+fun BottomScreenshotsPage(takeScreenshot: ((onDone: (Boolean) -> Unit) -> Unit)?) {
+ val context = LocalContext.current
+ val colors = MaterialTheme.colorScheme
+ var shots by remember { mutableStateOf>(emptyList()) }
+ var refresh by remember { mutableIntStateOf(0) }
+ var open by remember { mutableStateOf(null) }
+ var status by remember { mutableStateOf(null) }
+ var busy by remember { mutableStateOf(false) }
+ LaunchedEffect(refresh) {
+ while (true) {
+ shots = withContext(Dispatchers.IO) { BottomScreenshots.list(context, LinuxRuntime.rootDir(context)) }
+ delay(SHOTS_POLL_MS)
+ }
+ }
+ LaunchedEffect(status) {
+ if (status != null) {
+ delay(3_000L)
+ status = null
+ }
+ }
+ open?.let { shot ->
+ Box(Modifier.fillMaxSize().clip(RoundedCornerShape(14.dp)).background(androidx.compose.ui.graphics.Color.Black)
+ .clickable(role = Role.Button) { open = null }.testTag("bottom-shot-full")) {
+ AsyncImage(ImageRequest.Builder(context).data(shot.model).build(), contentDescription = null,
+ contentScale = ContentScale.Fit, modifier = Modifier.fillMaxSize())
+ }
+ return
+ }
+ Column(Modifier.fillMaxSize(), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+ Row(Modifier.fillMaxWidth(), verticalAlignment = Alignment.CenterVertically) {
+ Text(status?.let { stringResource(it) } ?: stringResource(R.string.bottom_shots_where), fontSize = 13.sp,
+ color = colors.onSurfaceVariant, maxLines = 2, modifier = Modifier.weight(1f).padding(end = 8.dp))
+ if (takeScreenshot != null) BottomPillButton(stringResource(R.string.bottom_shots_take), "bottom-shots-take") {
+ if (!busy) {
+ busy = true
+ takeScreenshot { ok ->
+ busy = false
+ status = if (ok) R.string.bottom_shots_saved else R.string.bottom_shots_failed
+ refresh++
+ }
+ }
+ }
+ }
+ if (shots.isEmpty()) {
+ Box(Modifier.weight(1f).fillMaxWidth(), contentAlignment = Alignment.Center) {
+ Text(stringResource(R.string.bottom_shots_none), fontSize = 15.sp, color = colors.onSurfaceVariant)
+ }
+ } else {
+ LazyVerticalGrid(GridCells.Adaptive(150.dp), Modifier.weight(1f).fillMaxWidth(),
+ horizontalArrangement = Arrangement.spacedBy(8.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+ items(shots, key = { it.model.toString() }) { shot ->
+ AsyncImage(
+ ImageRequest.Builder(context).data(shot.model).size(480, 270).build(), contentDescription = null,
+ contentScale = ContentScale.Crop,
+ modifier = Modifier.fillMaxWidth().aspectRatio(16f / 9f).clip(RoundedCornerShape(10.dp))
+ .background(LocalPalette.current.surface).clickable(role = Role.Button) { open = shot },
+ )
+ }
+ }
+ }
+ }
+}
diff --git a/app/src/main/java/com/droiddeck/launcher/ui/BottomTelemetryPage.kt b/app/src/main/java/com/droiddeck/launcher/ui/BottomTelemetryPage.kt
new file mode 100644
index 0000000000..c1fb9c2a77
--- /dev/null
+++ b/app/src/main/java/com/droiddeck/launcher/ui/BottomTelemetryPage.kt
@@ -0,0 +1,404 @@
+package com.droiddeck.launcher.ui
+
+import android.content.res.Resources
+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.Row
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.selection.toggleable
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Switch
+import androidx.compose.material3.SwitchDefaults
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.Role
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import com.droiddeck.launcher.R
+import com.droiddeck.launcher.frontend.Library
+import com.droiddeck.launcher.hud.HudMetrics
+import com.droiddeck.launcher.hud.MangoReadings
+import com.droiddeck.launcher.runtime.LinuxRuntime
+import com.droiddeck.launcher.session.GameStatusFiles
+import com.droiddeck.launcher.session.GameTelemetry
+import com.droiddeck.launcher.input.SteamTouchConfig
+import com.droiddeck.launcher.session.SessionPrefs
+import com.droiddeck.launcher.session.SessionService
+import com.droiddeck.launcher.session.SessionState
+import com.droiddeck.launcher.session.SpeedUnit
+import com.droiddeck.launcher.session.StatsDash
+import com.droiddeck.launcher.session.StatsStrip
+import com.droiddeck.launcher.session.Telemetry
+import com.droiddeck.launcher.session.TelemetryOutput
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import java.io.File
+import java.net.DatagramPacket
+import java.net.DatagramSocket
+import java.net.HttpURLConnection
+import java.net.InetSocketAddress
+import java.net.SocketTimeoutException
+import java.net.URL
+import java.util.concurrent.atomic.AtomicReference
+
+private const val DRAW_MS = 66L
+private const val TELEMETRY_STALE_MS = 3_000L
+private const val METRICS_MS = 1_000L
+private const val THUNDER_MS = 500L
+private const val THUNDER_RETRY_MS = 3_000L
+private const val ELITE_MS = 1_000L
+private const val ELITE_SEARCH_MS = 10_000L
+private const val OUTPUT_SCAN_MS = 3_000L
+/** Top strip history: one reading a second for 30 s. */
+private const val PERF_N = 30
+
+/** What arrives on one telemetry port; written only by that port's listener. */
+private class PortTraffic {
+ @Volatile var packets = 0L
+ @Volatile var length = 0
+ @Volatile var readable = true
+}
+
+private data class UnknownTraffic(val port: Int, val packets: Long, val length: Int)
+
+@Composable
+fun BottomTelemetryPage(fps: () -> Float?, runningGame: () -> String? = { null }) {
+ val context = LocalContext.current
+ val colors = MaterialTheme.colorScheme
+ val scope = rememberCoroutineScope()
+ var outputs by remember { mutableStateOf>(emptyList()) }
+ var menuGames by remember { mutableStateOf>(emptyList()) }
+ var running by remember { mutableStateOf(null) }
+ var gameName by remember { mutableStateOf(null) }
+ val steamClient = remember { if (SessionState.mode == SessionService.MODE_STEAM) SessionPrefs.activeSteamClientArch(context) else null }
+ var outputFailed by remember { mutableStateOf(null) }
+ var rescan by remember { mutableIntStateOf(0) }
+ var auto by remember { mutableStateOf(SessionPrefs.telemetryAuto(context)) }
+ val latest = remember { AtomicReference?>(null) }
+ var race by remember { mutableStateOf(null) }
+ var fpsNow by remember { mutableStateOf(null) }
+ var device by remember { mutableStateOf(null) }
+ var thunder by remember { mutableStateOf>>(emptyList()) }
+ var elite by remember { mutableStateOf(null) }
+ var busyPorts by remember { mutableStateOf>(emptySet()) }
+ val traffic = remember { GameTelemetry.PORTS.associateWith { PortTraffic() } }
+ var unknown by remember { mutableStateOf>(emptyList()) }
+ var strip by remember { mutableStateOf(StatsStrip.from(SessionPrefs.statsStrip(context))) }
+ var dash by remember { mutableStateOf(StatsDash.from(SessionPrefs.statsDash(context))) }
+ var speedUnit by remember { mutableStateOf(SpeedUnit.from(SessionPrefs.statsSpeedUnit(context))) }
+ val shownUnit = speedUnit.resolve(Resources.getSystem().configuration.locales[0].country)
+ val fpsHistory = remember { History(PERF_N) }
+ val cpuHistory = remember { History(PERF_N) }
+ val gpuHistory = remember { History(PERF_N) }
+ val wattsHistory = remember { History(PERF_N) }
+ val throttleTrace = remember { History(TRACE_N) }
+ val brakeTrace = remember { History(TRACE_N) }
+ val speedTrace = remember { History(TRACE_N) }
+ var perfTick by remember { mutableIntStateOf(0) }
+ var traceTick by remember { mutableIntStateOf(0) }
+ var clock by remember { mutableStateOf("") }
+
+ LaunchedEffect(Unit) {
+ for (port in GameTelemetry.PORTS) launch(Dispatchers.IO) {
+ val socket = runCatching {
+ DatagramSocket(null).apply {
+ reuseAddress = true
+ soTimeout = 500
+ bind(InetSocketAddress(GameTelemetry.LISTEN_ADDRESS, port))
+ }
+ }.getOrNull()
+ if (socket == null) {
+ withContext(Dispatchers.Main) { busyPorts = busyPorts + port }
+ return@launch
+ }
+ val seen = traffic.getValue(port)
+ socket.use {
+ val data = ByteArray(2048)
+ val packet = DatagramPacket(data, data.size)
+ while (isActive) {
+ try {
+ packet.length = data.size
+ it.receive(packet)
+ val t = GameTelemetry.parse(port, data, packet.length)
+ seen.packets++
+ seen.length = packet.length
+ seen.readable = t != null
+ if (t != null) latest.set(System.currentTimeMillis() to t)
+ } catch (_: SocketTimeoutException) {
+ } catch (_: java.io.IOException) {
+ break
+ }
+ }
+ }
+ }
+ while (isActive) {
+ val reading = latest.get()
+ race = reading?.takeIf { System.currentTimeMillis() - it.first < TELEMETRY_STALE_MS }?.second
+ race?.let { r ->
+ throttleTrace.add(r.throttle ?: 0f)
+ brakeTrace.add(r.brake ?: 0f)
+ speedTrace.add(r.speedKmh ?: 0f)
+ traceTick++
+ }
+ fpsNow = fps()
+ unknown = traffic.filter { (_, t) -> t.packets > 0 && !t.readable }.map { (port, t) -> UnknownTraffic(port, t.packets, t.length) }
+ delay(DRAW_MS)
+ }
+ }
+ LaunchedEffect(Unit) {
+ val metrics = HudMetrics(context).apply { setMangoReadings(MangoReadings(File(context.filesDir, "session"), LinuxRuntime.rootDir(context))) }
+ while (isActive) {
+ device = withContext(Dispatchers.IO) { runCatching { metrics.snapshot() }.getOrNull() }
+ fps()?.takeIf { it > 0f }?.let { fpsHistory.add(it) }
+ device?.let { s ->
+ s.cpuPercent?.let { cpuHistory.add(it.toFloat()) }
+ s.gpuPercent?.let { gpuHistory.add(it.toFloat()) }
+ s.battery?.watts?.takeIf { it > 0f }?.let { wattsHistory.add(it) }
+ }
+ clock = java.text.DateFormat.getTimeInstance(java.text.DateFormat.SHORT).format(java.util.Date())
+ perfTick++
+ delay(METRICS_MS)
+ }
+ }
+ LaunchedEffect(Unit) {
+ while (isActive) {
+ val rows = withContext(Dispatchers.IO) { runCatching { GameStatusFiles.warThunder(httpGet(GameStatusFiles.WAR_THUNDER_STATE)) }.getOrNull() }
+ thunder = rows.orEmpty()
+ delay(if (rows == null) THUNDER_RETRY_MS else THUNDER_MS)
+ }
+ }
+ LaunchedEffect(Unit) {
+ var file: File? = null
+ var searchedAt = 0L
+ while (isActive) {
+ val now = System.currentTimeMillis()
+ if (file == null && now - searchedAt > ELITE_SEARCH_MS) {
+ searchedAt = now
+ file = withContext(Dispatchers.IO) {
+ runCatching { GameStatusFiles.eliteStatusFile(LinuxRuntime.rootDir(context), SessionState.steamLibraryMounts) }.getOrNull()
+ }
+ }
+ val f = file
+ // Status.json changes while Elite runs; one older than a minute belongs to an earlier session.
+ elite = if (f != null && now - f.lastModified() < 60_000L) {
+ withContext(Dispatchers.IO) { runCatching { GameStatusFiles.elite(f.readText()) }.getOrNull() }
+ } else null
+ delay(ELITE_MS)
+ }
+ }
+ LaunchedEffect(Unit) {
+ menuGames = withContext(Dispatchers.IO) {
+ runCatching { Library.steamGames(context).mapNotNull { TelemetryOutput.MENU_GAMES[it.appId] }.distinct() }.getOrDefault(emptyList())
+ }
+ }
+ LaunchedEffect(running) {
+ val id = running?.toLongOrNull()
+ gameName = if (id == null) null
+ else withContext(Dispatchers.IO) { runCatching { SteamTouchConfig.gameName(context, id.toInt()) }.getOrNull() }
+ }
+ LaunchedEffect(rescan) {
+ while (isActive) {
+ outputs = withContext(Dispatchers.IO) { runCatching { TelemetryOutput.scan(Library.compatdataDirs(context)) }.getOrDefault(emptyList()) }
+ running = runningGame()
+ delay(OUTPUT_SCAN_MS)
+ }
+ }
+
+ Column(Modifier.fillMaxSize().verticalScroll(rememberScrollState()), verticalArrangement = Arrangement.spacedBy(10.dp)) {
+ perfTick.let {
+ StatsStripView(strip, StripData(fpsNow, device, fpsHistory.snapshot(), cpuHistory.snapshot(), gpuHistory.snapshot(), wattsHistory.snapshot(), clock,
+ if (running != null) gameName else steamClient?.let { stringResource(steamClientLabel(it)) })) {
+ strip = strip.next()
+ SessionPrefs.setStatsStrip(context, strip.id)
+ }
+ }
+ race?.let { r ->
+ val shown = dash.resolve(r.source)
+ traceTick.let {
+ RaceDashView(shown, r, TraceData(throttleTrace.snapshot(), brakeTrace.snapshot(), speedTrace.snapshot()), shownUnit) {
+ dash = StatsDash.tapped(shown)
+ SessionPrefs.setStatsDash(context, dash.id)
+ }
+ }
+ }
+ if (thunder.isNotEmpty()) {
+ if (FlightLabels.drawable(thunder)) FlightDash(thunder)
+ else TelemetryCard(stringResource(R.string.bottom_telemetry_war_thunder)) { ValueGrid(thunder.take(GameStatusFiles.WAR_THUNDER_ROWS)) }
+ }
+ elite?.let { e ->
+ if (e.pips != null || e.fuelMain != null) ShipDash(e)
+ else TelemetryCard(stringResource(R.string.bottom_telemetry_elite)) {
+ ValueGrid(listOfNotNull(
+ e.fuelMain?.let { stringResource(R.string.bottom_telemetry_fuel) to "%.1f t".format(it) },
+ e.cargo?.let { stringResource(R.string.bottom_telemetry_cargo) to "%.0f t".format(it) },
+ e.pips?.takeIf { it.size == 3 }?.let { p ->
+ stringResource(R.string.bottom_telemetry_pips) to p.joinToString(" · ") { "%.1f".format(it / 2f) }
+ },
+ e.legal?.let { stringResource(R.string.bottom_telemetry_legal) to it },
+ e.balance?.let { stringResource(R.string.bottom_telemetry_balance) to "%,d CR".format(it) },
+ ))
+ }
+ }
+ if (race == null && thunder.isEmpty() && elite == null) {
+ Text(stringResource(R.string.bottom_telemetry_help),
+ fontSize = 14.sp, color = colors.onSurfaceVariant, modifier = Modifier.padding(horizontal = 4.dp))
+ }
+ if (outputs.isNotEmpty() || menuGames.isNotEmpty()) TelemetryCard(stringResource(R.string.bottom_telemetry_send_title)) {
+ if (outputs.isNotEmpty()) SwitchRow(stringResource(R.string.bottom_telemetry_send_auto), stringResource(R.string.bottom_telemetry_send_auto_hint), auto, true) { want ->
+ scope.launch {
+ withContext(Dispatchers.IO) {
+ SessionPrefs.setTelemetryAuto(context, want)
+ if (want) TelemetryOutput.applyAutomatic(context, running)
+ else TelemetryOutput.restoreTargets(outputs, running).forEach { TelemetryOutput.set(it, false) }
+ }
+ auto = want
+ rescan++
+ }
+ }
+ for (game in outputs) {
+ val locked = TelemetryOutput.isRunning(game.prefixId, running)
+ val hint = if (locked) stringResource(R.string.bottom_telemetry_send_close, game.name) else null
+ SwitchRow(game.name, hint, game.on, !locked) { want ->
+ scope.launch {
+ val ok = withContext(Dispatchers.IO) {
+ val key = TelemetryOutput.key(game)
+ val off = SessionPrefs.telemetryOff(context)
+ SessionPrefs.setTelemetryOff(context, if (want) off - key else off + key)
+ TelemetryOutput.set(game, want)
+ }
+ outputFailed = if (ok) null else game.name
+ rescan++
+ }
+ }
+ }
+ for (game in menuGames) {
+ Text(stringResource(R.string.bottom_telemetry_send_menu, game.name, game.setting, game.port), fontSize = 13.sp, color = colors.onSurfaceVariant)
+ }
+ if (outputs.isNotEmpty()) Text(stringResource(R.string.bottom_telemetry_send_note), fontSize = 12.sp, color = colors.onSurfaceVariant)
+ outputFailed?.let { Text(stringResource(R.string.bottom_telemetry_send_failed, it), fontSize = 12.sp, color = colors.error) }
+ }
+ for (u in unknown) {
+ Text(stringResource(R.string.bottom_telemetry_unknown_format, u.port, u.packets, u.length), fontSize = 13.sp,
+ color = colors.error, modifier = Modifier.padding(horizontal = 4.dp))
+ }
+ if (busyPorts.isNotEmpty()) {
+ Text(stringResource(R.string.bottom_telemetry_port_busy, busyPorts.sorted().joinToString()), fontSize = 13.sp,
+ color = colors.error, modifier = Modifier.padding(horizontal = 4.dp))
+ }
+ ChoiceRow(stringResource(R.string.stats_speed_units),
+ if (speedUnit == SpeedUnit.AUTO) stringResource(R.string.stats_speed_units_auto, shownUnit.label) else speedUnit.label) {
+ speedUnit = speedUnit.next()
+ SessionPrefs.setStatsSpeedUnit(context, speedUnit.id)
+ }
+ Text(stringResource(R.string.stats_tap_hint), fontSize = 12.sp, color = colors.onSurfaceVariant, modifier = Modifier.padding(horizontal = 4.dp))
+ }
+}
+
+private fun httpGet(url: String): String {
+ val c = URL(url).openConnection() as HttpURLConnection
+ c.connectTimeout = 300
+ c.readTimeout = 500
+ return try {
+ c.inputStream.bufferedReader().use { it.readText() }
+ } finally {
+ c.disconnect()
+ }
+}
+
+
+/** The Steam client the session runs, shown in the strip's top line while no game runs. */
+internal fun steamClientLabel(arch: String): Int = if (arch == "x86_64") R.string.stats_steam_client_x86 else R.string.stats_steam_client_arm
+
+@Composable
+private fun ChoiceRow(title: String, value: String, onClick: () -> Unit) {
+ val colors = MaterialTheme.colorScheme
+ Row(Modifier.fillMaxWidth().clickable(role = Role.Button, onClick = onClick).padding(horizontal = 4.dp, vertical = 6.dp),
+ verticalAlignment = Alignment.CenterVertically) {
+ Text(title, fontSize = 15.sp, color = colors.onBackground, modifier = Modifier.weight(1f))
+ Text(value, fontSize = 15.sp, fontWeight = FontWeight.Bold, color = LocalPalette.current.primary)
+ }
+}
+
+@Composable
+private fun SwitchRow(title: String, hint: String?, checked: Boolean, enabled: Boolean, onChange: (Boolean) -> Unit) {
+ val colors = MaterialTheme.colorScheme
+ Row(
+ Modifier.fillMaxWidth().toggleable(checked, enabled = enabled, role = Role.Switch, onValueChange = onChange).padding(vertical = 4.dp),
+ verticalAlignment = Alignment.CenterVertically,
+ ) {
+ Column(Modifier.weight(1f).padding(end = 12.dp)) {
+ Text(title, fontSize = 15.sp, color = colors.onBackground, maxLines = 1, overflow = TextOverflow.Ellipsis)
+ if (hint != null) Text(hint, fontSize = 12.sp, color = colors.onSurfaceVariant)
+ }
+ val pal = LocalPalette.current
+ Switch(checked, null, enabled = enabled, colors = SwitchDefaults.colors(
+ disabledCheckedTrackColor = pal.primary.copy(alpha = 0.45f),
+ disabledCheckedThumbColor = colors.background,
+ disabledCheckedBorderColor = pal.primary.copy(alpha = 0.45f),
+ ))
+ }
+}
+
+
+@Composable
+private fun TelemetryCard(title: String, content: @Composable () -> Unit) {
+ val pal = LocalPalette.current
+ Column(Modifier.fillMaxWidth().clip(RoundedCornerShape(14.dp)).background(pal.surface).padding(12.dp),
+ verticalArrangement = Arrangement.spacedBy(8.dp)) {
+ Text(title, fontSize = 13.sp, fontWeight = FontWeight.SemiBold, color = pal.signal)
+ content()
+ }
+}
+
+@Composable
+private fun ValueGrid(rows: List>) {
+ val colors = MaterialTheme.colorScheme
+ rows.chunked(2).forEach { pair ->
+ Row(Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.spacedBy(12.dp)) {
+ pair.forEach { (k, v) ->
+ Row(Modifier.weight(1f)) {
+ Text(k, fontSize = 13.sp, color = colors.onSurfaceVariant, maxLines = 1, overflow = TextOverflow.Ellipsis, modifier = Modifier.weight(1f))
+ Text(v, fontSize = 14.sp, fontWeight = FontWeight.SemiBold, color = colors.onBackground, maxLines = 1)
+ }
+ }
+ if (pair.size == 1) Box(Modifier.weight(1f))
+ }
+ }
+}
+
+internal fun lapTime(seconds: Float): String {
+ val total = kotlin.math.round(seconds * 1000.0).toLong()
+ return "%d:%02d.%03d".format(total / 60_000, total / 1000 % 60, total % 1000)
+}
+
+
+
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 3caad9f771..18f54cf5d3 100644
--- a/app/src/main/java/com/droiddeck/launcher/ui/SecondScreenPresentation.kt
+++ b/app/src/main/java/com/droiddeck/launcher/ui/SecondScreenPresentation.kt
@@ -56,9 +56,11 @@ class SecondScreenPresentation(
private val onKeyboardClosed: () -> Unit = {},
private val onMenu: (() -> Unit)? = null,
private val menu: (@androidx.compose.runtime.Composable () -> Unit)? = null,
+ private val dashboard: (@androidx.compose.runtime.Composable () -> Unit)? = null,
) : Presentation(sessionActivity, display) {
private val frame = FrameLayout(context)
private var menuView: androidx.compose.ui.platform.ComposeView? = null
+ private var dashboardView: androidx.compose.ui.platform.ComposeView? = null
var menuShown = false
private set
private val root = LinearLayout(context).apply {
@@ -155,12 +157,7 @@ class SecondScreenPresentation(
menuShown = on
if (on) {
keyboardHost?.takeIf { it.shown }?.hide()
- window?.decorView?.let { decor ->
- decor.setViewTreeLifecycleOwner(sessionActivity)
- decor.setViewTreeViewModelStoreOwner(sessionActivity)
- decor.setViewTreeSavedStateRegistryOwner(sessionActivity)
- decor.setViewTreeOnBackPressedDispatcherOwner(sessionActivity)
- }
+ ownComposeViews()
val view = menuView ?: androidx.compose.ui.platform.ComposeView(context).apply {
isFocusable = true
isFocusableInTouchMode = true
@@ -179,12 +176,22 @@ class SecondScreenPresentation(
}
}
+ private fun ownComposeViews() {
+ window?.decorView?.let { decor ->
+ decor.setViewTreeLifecycleOwner(sessionActivity)
+ decor.setViewTreeViewModelStoreOwner(sessionActivity)
+ decor.setViewTreeSavedStateRegistryOwner(sessionActivity)
+ decor.setViewTreeOnBackPressedDispatcherOwner(sessionActivity)
+ }
+ }
+
fun focusMenu(): Boolean = menuView?.requestFocus() == true
fun dispatchMenuKey(event: KeyEvent): Boolean = menuView?.dispatchKeyEvent(event) == true
fun closeControls() {
showMenu(false)
+ closeDashboard()
closeTerminal()
keyboardHost?.hide()
keyboardHost = null
@@ -192,7 +199,8 @@ class SecondScreenPresentation(
}
override fun dispatchKeyEvent(event: KeyEvent): Boolean {
- val forward = menuShown || currentMode != SecondScreenMode.TERMINAL || PadBridge.isControllerKeyEvent(event)
+ val ownKeys = currentMode == SecondScreenMode.TERMINAL || currentMode == SecondScreenMode.DASHBOARD
+ val forward = menuShown || !ownKeys || PadBridge.isControllerKeyEvent(event)
if (forward && sessionActivity.dispatchKeyEvent(event)) return true
return super.dispatchKeyEvent(event)
}
@@ -218,19 +226,37 @@ class SecondScreenPresentation(
keyboardButton = null
keyboardPending = false
closeTerminal()
+ closeDashboard()
root.removeAllViews()
- val mode = if (currentMode == SecondScreenMode.DECK_CONTROLS && !SessionState.deckPad) SecondScreenMode.NONE
- else currentMode
+ val mode = when {
+ currentMode == SecondScreenMode.DECK_CONTROLS && !SessionState.deckPad -> SecondScreenMode.NONE
+ currentMode == SecondScreenMode.DASHBOARD && dashboard == null -> SecondScreenMode.NONE
+ else -> currentMode
+ }
if (mode == SecondScreenMode.NONE) return
when (mode) {
SecondScreenMode.KEYBOARD_TRACKPAD -> renderKeyboardAndTrackpad()
SecondScreenMode.TERMINAL -> renderTerminal()
SecondScreenMode.DECK_CONTROLS -> root.addView(DeckControlsPanel(context, onClose, onSteamMenu, onQam, pad, onMenu = onMenu), weightParams())
+ SecondScreenMode.DASHBOARD -> renderDashboard()
SecondScreenMode.NONE -> Unit
}
}
+ private fun renderDashboard() {
+ val content = dashboard ?: return
+ ownComposeViews()
+ val view = androidx.compose.ui.platform.ComposeView(context).apply { setContent { content() } }
+ dashboardView = view
+ root.addView(view, weightParams())
+ }
+
+ private fun closeDashboard() {
+ dashboardView?.disposeComposition()
+ dashboardView = null
+ }
+
private fun renderKeyboardAndTrackpad() {
val panel = FrameLayout(context)
panel.addView(trackpadView(), FrameLayout.LayoutParams(-1, -1))
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 46f655c05a..6ff0ee910f 100644
--- a/app/src/main/java/com/droiddeck/launcher/ui/SessionOverlay.kt
+++ b/app/src/main/java/com/droiddeck/launcher/ui/SessionOverlay.kt
@@ -31,6 +31,7 @@ import androidx.compose.material.icons.Icons
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.Keyboard
import androidx.compose.material.icons.outlined.AutoFixHigh
import androidx.compose.material.icons.outlined.ExpandMore
@@ -240,6 +241,7 @@ class DrawerActions(
val textureAnisotropy: Int? = 0,
val textureLodBias: String? = TextureFiltering.LOD_BIAS_OFF,
val secondScreenMode: SecondScreenMode,
+ val dashboardAvailable: Boolean = false,
val secondScreenDisplays: List,
val selectedSecondScreenDisplay: Int,
val onHud: (Boolean) -> Unit,
@@ -893,6 +895,7 @@ private fun BottomScreenModes(a: DrawerActions, modifier: Modifier, onPick: () -
if (com.droiddeck.launcher.session.SessionState.deckPad) add(SecondScreenMode.DECK_CONTROLS to Icons.Outlined.SportsEsports)
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)
}
Row(
verticalAlignment = Alignment.CenterVertically,
@@ -1190,7 +1193,8 @@ private fun SecondScreenGroup(host: MenuHost, a: DrawerActions, track: (String)
val colors = MaterialTheme.colorScheme
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 (com.droiddeck.launcher.session.SessionState.deckPad) listOf(SecondScreenMode.DECK_CONTROLS) else emptyList()) +
+ (if (a.dashboardAvailable) listOf(SecondScreenMode.DASHBOARD) 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/ui/StatsDashes.kt b/app/src/main/java/com/droiddeck/launcher/ui/StatsDashes.kt
new file mode 100644
index 0000000000..9f185b824f
--- /dev/null
+++ b/app/src/main/java/com/droiddeck/launcher/ui/StatsDashes.kt
@@ -0,0 +1,588 @@
+package com.droiddeck.launcher.ui
+
+import androidx.compose.foundation.Canvas
+import androidx.compose.foundation.background
+import androidx.compose.foundation.border
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.horizontalScroll
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.shape.RoundedCornerShape
+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.draw.clip
+import androidx.compose.ui.geometry.CornerRadius
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.geometry.Size
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.Path
+import androidx.compose.ui.graphics.StrokeCap
+import androidx.compose.ui.graphics.StrokeJoin
+import androidx.compose.ui.graphics.drawscope.DrawScope
+import androidx.compose.ui.graphics.drawscope.Stroke
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.TextMeasurer
+import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.text.drawText
+import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.rememberTextMeasurer
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import com.droiddeck.launcher.R
+import com.droiddeck.launcher.session.GameStatusFiles
+import com.droiddeck.launcher.session.GameTelemetry
+import com.droiddeck.launcher.session.SpeedUnit
+import com.droiddeck.launcher.session.StatsDash
+import com.droiddeck.launcher.session.Telemetry
+import kotlin.math.abs
+import kotlin.math.cos
+import kotlin.math.floor
+import kotlin.math.max
+import kotlin.math.min
+import kotlin.math.roundToInt
+import kotlin.math.sin
+
+private val DASH_H = 290.dp
+/** Pedal and speed trace length: 150 readings at the page's 66 ms draw rate, about 10 s. */
+internal const val TRACE_N = 150
+
+internal class TraceData(val throttle: List, val brake: List, val speed: List)
+
+/** The racing dash in [style] with speeds in [unit] (km/h or mph); a tap moves to the next one. */
+@Composable
+internal fun RaceDashView(style: StatsDash, t: Telemetry, trace: TraceData, unit: SpeedUnit, onTap: () -> Unit) {
+ Box(Modifier.fillMaxWidth().clickable(onClick = onTap)) {
+ when (style) {
+ StatsDash.AUTO, StatsDash.SPEEDOMETER -> SpeedometerDash(t, unit)
+ StatsDash.CIRCUIT -> CircuitDash(t, unit)
+ StatsDash.TRACE -> TraceDash(t, trace, unit)
+ StatsDash.DIALS -> DialsDash(t, unit)
+ StatsDash.GLANCE -> GlanceDash(t, unit)
+ }
+ }
+}
+
+private fun polar(cx: Float, cy: Float, r: Float, deg: Float): Offset {
+ val a = Math.toRadians((deg - 90f).toDouble())
+ return Offset(cx + r * cos(a).toFloat(), cy + r * sin(a).toFloat())
+}
+
+private const val DIAL_START = -125f
+private const val DIAL_SWEEP = 250f
+
+private fun dialAngle(v: Float, max: Float) = DIAL_START + DIAL_SWEEP * (v / max).coerceIn(0f, 1f)
+
+/** A 250° dial face: track, optional red zone from [red], ticks and numbers every [major]. */
+private fun DrawScope.dialFace(
+ cx: Float, cy: Float, r: Float, max: Float, major: Float, label: (Float) -> String,
+ measurer: TextMeasurer, labelStyle: TextStyle, tick: Color, minor: Color, track: Color, red: Float?, redColor: Color,
+) {
+ val box = Size(2 * r, 2 * r)
+ val tl = Offset(cx - r, cy - r)
+ drawArc(track, DIAL_START - 90f, DIAL_SWEEP, false, topLeft = tl, size = box, style = Stroke(6.dp.toPx(), cap = StrokeCap.Round))
+ if (red != null && red < max) {
+ drawArc(redColor, dialAngle(red, max) - 90f, dialAngle(max, max) - dialAngle(red, max), false, topLeft = tl, size = box, style = Stroke(6.dp.toPx()))
+ }
+ val steps = (max / (major / 2f)).roundToInt()
+ for (i in 0..steps) {
+ val v = i * major / 2f
+ val isMajor = i % 2 == 0
+ val deg = dialAngle(v, max)
+ drawLine(if (isMajor) tick else minor, polar(cx, cy, r - (if (isMajor) 14.dp else 7.dp).toPx(), deg), polar(cx, cy, r - 2.dp.toPx(), deg),
+ strokeWidth = (if (isMajor) 2.5f else 1.2f).dp.toPx())
+ if (isMajor) {
+ val layout = measurer.measure(label(v), labelStyle)
+ val p = polar(cx, cy, r - 27.dp.toPx(), deg)
+ drawText(layout, topLeft = Offset(p.x - layout.size.width / 2f, p.y - layout.size.height / 2f))
+ }
+ }
+}
+
+private fun DrawScope.needle(cx: Float, cy: Float, len: Float, deg: Float, color: Color, hub: Color) {
+ drawLine(color, Offset(cx, cy), polar(cx, cy, len, deg), strokeWidth = 4.dp.toPx(), cap = StrokeCap.Round)
+ drawCircle(hub, radius = 7.dp.toPx(), center = Offset(cx, cy))
+}
+
+private fun speedValue(t: Telemetry, unit: SpeedUnit): Float = (t.speedKmh ?: 0f) * unit.perKmh
+
+private fun speedScale(speed: Float, unit: SpeedUnit): Float =
+ if (unit == SpeedUnit.MPH) (if (speed > 130f) 200f else 140f) else (if (speed > 210f) 320f else 220f)
+
+private fun rpmScale(t: Telemetry): Float = max(t.maxRpm ?: 9000f, t.rpm ?: 0f)
+
+private fun speedText(t: Telemetry, unit: SpeedUnit) = t.speedKmh?.let { "%.0f".format(it * unit.perKmh) } ?: "–"
+
+@Composable
+private fun unitAndGear(t: Telemetry, unit: SpeedUnit) = "${unit.label} · ${stringResource(R.string.stats_gear)} ${t.gear ?: "–"}"
+
+@Composable
+private fun SpeedometerDash(t: Telemetry, unit: SpeedUnit) {
+ val colors = MaterialTheme.colorScheme
+ val accent = LocalPalette.current.primary
+ Row(Modifier.fillMaxWidth().height(DASH_H), horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+ StatsCard(stringResource(R.string.stats_speed), Modifier.weight(1.55f).fillMaxHeight()) {
+ Box(Modifier.fillMaxWidth().weight(1f)) {
+ SpeedDial(t, unit, Modifier.fillMaxSize())
+ Column(Modifier.align(Alignment.BottomCenter), horizontalAlignment = Alignment.CenterHorizontally) {
+ Text(speedText(t, unit), fontSize = 44.sp, fontWeight = FontWeight.Bold, fontFamily = FontFamily.Monospace, color = accent)
+ Text(unitAndGear(t, unit), fontSize = 16.sp, fontWeight = FontWeight.Bold, fontFamily = FontFamily.Monospace, color = colors.onBackground)
+ Text(t.rpm?.let { "%,.0f rpm".format(it) } ?: "", fontSize = 11.sp, fontFamily = FontFamily.Monospace, color = colors.onSurfaceVariant)
+ }
+ }
+ }
+ Column(Modifier.weight(1f).fillMaxHeight(), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+ StatsCard(stringResource(R.string.stats_pedals), Modifier.fillMaxWidth().weight(1f)) { Pedals(t, Modifier.fillMaxWidth().weight(1f)) }
+ if (t.gLat != null && t.gLon != null) {
+ StatsCard(stringResource(R.string.stats_gforce), Modifier.fillMaxWidth().weight(1f)) { GForce(t, Modifier.fillMaxWidth().weight(1f)) }
+ }
+ }
+ }
+}
+
+@Composable
+private fun SpeedDial(t: Telemetry, unit: SpeedUnit, modifier: Modifier) {
+ val pal = LocalPalette.current
+ val colors = MaterialTheme.colorScheme
+ val measurer = rememberTextMeasurer()
+ val labelStyle = TextStyle(color = colors.onSurfaceVariant, fontSize = 11.sp, fontFamily = FontFamily.Monospace)
+ val speed = speedValue(t, unit)
+ val vmax = speedScale(speed, unit)
+ val rpmFraction = ((t.rpm ?: 0f) / rpmScale(t)).coerceIn(0f, 1f)
+ Canvas(modifier) {
+ val r = min(size.width * 0.42f, size.height * 0.47f)
+ val cx = size.width / 2f
+ val cy = r + 12.dp.toPx()
+ dialFace(cx, cy, r, vmax, 20f, { "%.0f".format(it) }, measurer, labelStyle, colors.onBackground, colors.onSurfaceVariant, pal.line, null, StatsColors.brake)
+ val rr = r + 9.dp.toPx()
+ val box = Size(2 * rr, 2 * rr)
+ val tl = Offset(cx - rr, cy - rr)
+ drawArc(pal.line, DIAL_START - 90f, DIAL_SWEEP, false, topLeft = tl, size = box, style = Stroke(5.dp.toPx(), cap = StrokeCap.Round))
+ if (rpmFraction > 0f) drawArc(if (rpmFraction > 0.9f) StatsColors.brake else pal.primary, DIAL_START - 90f, DIAL_SWEEP * rpmFraction, false,
+ topLeft = tl, size = box, style = Stroke(5.dp.toPx(), cap = StrokeCap.Round))
+ needle(cx, cy, r - 16.dp.toPx(), dialAngle(speed, vmax), colors.onBackground, pal.primary)
+ }
+}
+
+@Composable
+private fun Pedals(t: Telemetry, modifier: Modifier) {
+ Row(modifier, horizontalArrangement = Arrangement.SpaceEvenly) {
+ PedalBar("THR", t.throttle, StatsColors.throttle)
+ PedalBar("BRK", t.brake, StatsColors.brake)
+ }
+}
+
+@Composable
+private fun PedalBar(label: String, value: Float?, color: Color) {
+ val pal = LocalPalette.current
+ val colors = MaterialTheme.colorScheme
+ Column(Modifier.fillMaxHeight(), horizontalAlignment = Alignment.CenterHorizontally, verticalArrangement = Arrangement.spacedBy(3.dp)) {
+ Text(value?.let { "${(it * 100).roundToInt()}%" } ?: "–", fontSize = 11.sp, fontFamily = FontFamily.Monospace, color = colors.onBackground)
+ Box(Modifier.weight(1f).width(26.dp).clip(RoundedCornerShape(6.dp)).background(pal.line)) {
+ Box(Modifier.fillMaxWidth().fillMaxHeight((value ?: 0f).coerceIn(0f, 1f)).align(Alignment.BottomCenter).background(color))
+ }
+ Text(label, fontSize = 11.sp, fontWeight = FontWeight.Bold, color = colors.onSurfaceVariant)
+ }
+}
+
+@Composable
+private fun GForce(t: Telemetry, modifier: Modifier) {
+ val pal = LocalPalette.current
+ val colors = MaterialTheme.colorScheme
+ val g = kotlin.math.hypot(t.gLat ?: 0f, t.gLon ?: 0f)
+ Box(modifier) {
+ Canvas(Modifier.fillMaxSize()) {
+ val steerH = if (t.steer != null) 10.dp.toPx() else 0f
+ val r = min(size.width / 2f, (size.height - steerH) / 2f) - 2.dp.toPx()
+ val cx = size.width / 2f
+ val cy = (size.height - steerH) / 2f
+ for (k in listOf(1f, 0.62f, 0.24f)) drawCircle(pal.line, radius = r * k, center = Offset(cx, cy), style = Stroke(1.dp.toPx()))
+ drawLine(pal.line, Offset(cx - r, cy), Offset(cx + r, cy), strokeWidth = 1.dp.toPx())
+ drawLine(pal.line, Offset(cx, cy - r), Offset(cx, cy + r), strokeWidth = 1.dp.toPx())
+ val gx = (t.gLat ?: 0f).coerceIn(-2f, 2f) / 2f * r
+ val gy = (t.gLon ?: 0f).coerceIn(-2f, 2f) / 2f * r
+ drawCircle(colors.onBackground, radius = 6.dp.toPx(), center = Offset(cx + gx, cy - gy))
+ t.steer?.let { s ->
+ val y = size.height - 3.dp.toPx()
+ drawLine(pal.line, Offset(cx - r, y), Offset(cx + r, y), strokeWidth = 5.dp.toPx(), cap = StrokeCap.Round)
+ drawLine(pal.primary, Offset(cx, y), Offset(cx + s * r, y), strokeWidth = 5.dp.toPx(), cap = StrokeCap.Round)
+ }
+ }
+ Text("%.1f G".format(g), fontSize = 11.sp, fontFamily = FontFamily.Monospace, color = colors.onSurfaceVariant, modifier = Modifier.align(Alignment.TopEnd))
+ }
+}
+
+@Composable
+private fun CircuitDash(t: Telemetry, unit: SpeedUnit) {
+ val colors = MaterialTheme.colorScheme
+ val accent = LocalPalette.current.primary
+ Column(Modifier.fillMaxWidth(), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+ StatsCard(null, Modifier.fillMaxWidth()) { ShiftLights(t, Modifier.fillMaxWidth().height(20.dp)) }
+ Row(Modifier.fillMaxWidth().height(DASH_H - 48.dp), horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+ StatsCard(stringResource(R.string.stats_timing), Modifier.weight(1f).fillMaxHeight()) {
+ KvRow(stringResource(R.string.bottom_telemetry_lap), t.lap?.let { lap -> t.laps?.let { "$lap / $it" } ?: "$lap" } ?: "–")
+ KvRow(stringResource(R.string.bottom_telemetry_position), t.position?.let { "P$it" } ?: "–")
+ KvRow(stringResource(R.string.bottom_telemetry_this_lap), t.currentLapS?.let { lapTime(it) } ?: "–")
+ KvRow(stringResource(R.string.bottom_telemetry_last_lap), t.lastLapS?.let { lapTime(it) } ?: "–")
+ t.bestLapS?.let { KvRow(stringResource(R.string.stats_best_lap), lapTime(it), accent) }
+ }
+ StatsCard("", Modifier.weight(1.2f).fillMaxHeight()) {
+ Column(Modifier.fillMaxWidth().weight(1f), horizontalAlignment = Alignment.CenterHorizontally, verticalArrangement = Arrangement.Center) {
+ Text(speedText(t, unit), fontSize = 72.sp, fontWeight = FontWeight.Bold, fontFamily = FontFamily.Monospace, color = accent)
+ Text(unitAndGear(t, unit), fontSize = 24.sp, fontWeight = FontWeight.Bold, fontFamily = FontFamily.Monospace, color = colors.onBackground)
+ Text(t.rpm?.let { rpm -> t.maxRpm?.let { "%,.0f / %,.0f rpm".format(rpm, it) } ?: "%,.0f rpm".format(rpm) } ?: "",
+ fontSize = 12.sp, fontFamily = FontFamily.Monospace, color = colors.onSurfaceVariant)
+ }
+ }
+ val fuel = t.fuel
+ val tires = t.tireTempsC?.takeIf { it.size == 4 }
+ if (fuel != null || tires != null) Column(Modifier.weight(0.9f).fillMaxHeight(), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+ if (fuel != null) StatsCard(stringResource(R.string.bottom_telemetry_fuel), Modifier.fillMaxWidth().weight(1f)) {
+ Bar(fuel, colors.onBackground, Modifier.fillMaxWidth().height(14.dp))
+ Text("${(fuel * 100).roundToInt()}%", fontSize = 13.sp, fontFamily = FontFamily.Monospace, color = colors.onSurfaceVariant)
+ }
+ if (tires != null) StatsCard(stringResource(R.string.stats_tires), Modifier.fillMaxWidth().weight(1.3f)) { Tires(tires, Modifier.fillMaxWidth().weight(1f)) }
+ }
+ }
+ }
+}
+
+@Composable
+private fun ShiftLights(t: Telemetry, modifier: Modifier) {
+ val pal = LocalPalette.current
+ val ratio = ((t.rpm ?: 0f) / rpmScale(t)).coerceIn(0f, 1f)
+ val lit = (((ratio - 0.6f) / 0.35f).coerceIn(0f, 1f) * 15).roundToInt()
+ val flash = ratio > 0.95f && (System.currentTimeMillis() / 120) % 2 == 0L
+ Canvas(modifier) {
+ val step = size.width / 15f
+ val r = min(size.height / 2f, step / 2f - 2.dp.toPx())
+ for (i in 0 until 15) {
+ val c = when {
+ flash -> pal.primary
+ i >= lit -> pal.line
+ i < 5 -> StatsColors.shiftGreen
+ i < 10 -> StatsColors.warn
+ i < 13 -> StatsColors.brake
+ else -> pal.primary
+ }
+ drawCircle(c, radius = r, center = Offset(step * i + step / 2f, size.height / 2f))
+ }
+ }
+}
+
+@Composable
+private fun KvRow(label: String, value: String, valueColor: Color = MaterialTheme.colorScheme.onBackground) {
+ Row(Modifier.fillMaxWidth(), verticalAlignment = Alignment.CenterVertically) {
+ Text(label, fontSize = 12.sp, color = MaterialTheme.colorScheme.onSurfaceVariant, modifier = Modifier.weight(1f), maxLines = 1)
+ Text(value, fontSize = 15.sp, fontWeight = FontWeight.Bold, fontFamily = FontFamily.Monospace, color = valueColor, maxLines = 1)
+ }
+}
+
+@Composable
+private fun Bar(fraction: Float, color: Color, modifier: Modifier) {
+ Box(modifier.clip(RoundedCornerShape(5.dp)).background(LocalPalette.current.line)) {
+ Box(Modifier.fillMaxWidth(fraction.coerceIn(0f, 1f)).fillMaxHeight().background(color))
+ }
+}
+
+@Composable
+private fun Tires(tires: List, modifier: Modifier) {
+ Column(modifier, verticalArrangement = Arrangement.spacedBy(6.dp)) {
+ Row(Modifier.fillMaxWidth().weight(1f), horizontalArrangement = Arrangement.spacedBy(6.dp)) {
+ TireBox(tires[0], Modifier.weight(1f).fillMaxHeight())
+ TireBox(tires[1], Modifier.weight(1f).fillMaxHeight())
+ }
+ Row(Modifier.fillMaxWidth().weight(1f), horizontalArrangement = Arrangement.spacedBy(6.dp)) {
+ TireBox(tires[2], Modifier.weight(1f).fillMaxHeight())
+ TireBox(tires[3], Modifier.weight(1f).fillMaxHeight())
+ }
+ }
+}
+
+@Composable
+private fun TireBox(c: Float, modifier: Modifier) {
+ val bg = when {
+ c > 100f -> Color(0xFF5A2A2C)
+ c < 70f -> Color(0xFF1D3550)
+ else -> Color(0xFF23352B)
+ }
+ Box(modifier.clip(RoundedCornerShape(6.dp)).background(bg), contentAlignment = Alignment.Center) {
+ Text("%.0f".format(c), fontSize = 13.sp, fontWeight = FontWeight.Bold, fontFamily = FontFamily.Monospace, color = MaterialTheme.colorScheme.onBackground)
+ }
+}
+
+@Composable
+private fun TraceDash(t: Telemetry, trace: TraceData, unit: SpeedUnit) {
+ val colors = MaterialTheme.colorScheme
+ Column(Modifier.fillMaxWidth(), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+ StatsCard(stringResource(R.string.stats_trace), Modifier.fillMaxWidth().height(168.dp)) {
+ Row(horizontalArrangement = Arrangement.spacedBy(14.dp)) {
+ Legend(StatsColors.throttle, "${stringResource(R.string.stats_throttle)} ${t.throttle?.let { (it * 100).roundToInt() } ?: 0}%")
+ Legend(StatsColors.brake, "${stringResource(R.string.stats_brake)} ${t.brake?.let { (it * 100).roundToInt() } ?: 0}%")
+ }
+ TraceChart(listOf(trace.throttle to StatsColors.throttle, trace.brake to StatsColors.brake), 1f, Modifier.fillMaxWidth().weight(1f))
+ }
+ val speeds = trace.speed.map { it * unit.perKmh }
+ val top = max(if (unit == SpeedUnit.MPH) 125f else 200f, (speeds.maxOrNull() ?: 0f) * 1.1f)
+ StatsCard(stringResource(R.string.stats_speed_chart, unit.label), Modifier.fillMaxWidth().height(114.dp)) {
+ Row(horizontalArrangement = Arrangement.spacedBy(14.dp)) {
+ Legend(StatsColors.speed, "${stringResource(R.string.stats_speed)} ${speedText(t, unit)}")
+ Text("0 – %.0f".format(top), fontSize = 11.sp, fontFamily = FontFamily.Monospace, color = colors.onSurfaceVariant)
+ }
+ TraceChart(listOf(speeds to StatsColors.speed), top, Modifier.fillMaxWidth().weight(1f))
+ }
+ }
+}
+
+@Composable
+private fun Legend(color: Color, text: String) {
+ Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(5.dp)) {
+ Box(Modifier.size(8.dp).clip(CircleShape).background(color))
+ Text(text, fontSize = 12.sp, fontFamily = FontFamily.Monospace, color = MaterialTheme.colorScheme.onBackground, maxLines = 1)
+ }
+}
+
+@Composable
+private fun TraceChart(series: List, Color>>, max: Float, modifier: Modifier) {
+ val pal = LocalPalette.current
+ Canvas(modifier) {
+ for (k in listOf(0f, 0.5f, 1f)) {
+ val y = size.height - k * size.height
+ drawLine(pal.line, Offset(0f, y), Offset(size.width, y), strokeWidth = 1.dp.toPx())
+ }
+ for ((values, color) in series) {
+ if (values.size < 2) continue
+ val path = Path()
+ val offset = TRACE_N - values.size
+ values.forEachIndexed { i, v ->
+ val x = (i + offset) / (TRACE_N - 1f) * size.width
+ val y = size.height - (v / max).coerceIn(0f, 1f) * size.height
+ if (i == 0) path.moveTo(x, y) else path.lineTo(x, y)
+ }
+ drawPath(path, color, style = Stroke(width = 2.dp.toPx(), cap = StrokeCap.Round, join = StrokeJoin.Round))
+ }
+ }
+}
+
+@Composable
+private fun DialsDash(t: Telemetry, unit: SpeedUnit) {
+ val colors = MaterialTheme.colorScheme
+ val rpmMax = (rpmScale(t) / 1000f).let { kotlin.math.ceil(it) * 1000f }
+ val hasExtras = t.lights != null || t.turboBar != null || t.engineTempC != null || t.oilTempC != null
+ Column(Modifier.fillMaxWidth(), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+ Row(Modifier.fillMaxWidth().height(if (hasExtras) DASH_H - 56.dp else DASH_H), horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+ StatsCard("", Modifier.weight(1f).fillMaxHeight()) {
+ val speed = speedValue(t, unit)
+ ArcDial(speed, speedScale(speed, unit), if (unit == SpeedUnit.MPH) 20f else 40f, { "%.0f".format(it) }, null,
+ speedText(t, unit), unit.label, Modifier.fillMaxWidth().weight(1f))
+ }
+ StatsCard("", Modifier.weight(1f).fillMaxHeight()) {
+ ArcDial(t.rpm ?: 0f, rpmMax, 1000f, { "%.0f".format(it / 1000f) }, t.maxRpm?.let { it * 0.9f },
+ t.rpm?.let { "%,.0f".format(it) } ?: "–", "rpm × 1000 · ${t.gear ?: "–"}", Modifier.fillMaxWidth().weight(1f))
+ }
+ }
+ if (hasExtras) StatsCard(stringResource(R.string.stats_lights), Modifier.fillMaxWidth()) {
+ Row(Modifier.horizontalScroll(rememberScrollState()), horizontalArrangement = Arrangement.spacedBy(6.dp)) {
+ t.lights?.let { on ->
+ Lamp(stringResource(R.string.stats_lamp_shift), on and GameTelemetry.DL_SHIFT != 0, LocalPalette.current.primary)
+ Lamp(stringResource(R.string.stats_lamp_handbrake), on and GameTelemetry.DL_HANDBRAKE != 0, StatsColors.brake)
+ Lamp(stringResource(R.string.stats_lamp_pit), on and GameTelemetry.DL_PITSPEED != 0, StatsColors.warn)
+ Lamp(stringResource(R.string.stats_lamp_tc), on and GameTelemetry.DL_TC != 0, StatsColors.warn)
+ Lamp(stringResource(R.string.stats_lamp_abs), on and GameTelemetry.DL_ABS != 0, StatsColors.warn)
+ }
+ t.turboBar?.let { Lamp(stringResource(R.string.stats_turbo, "%.1f".format(it)), false, colors.onBackground) }
+ t.engineTempC?.let { Lamp(stringResource(R.string.stats_engine_temp, "%.0f".format(it)), false, colors.onBackground) }
+ t.oilTempC?.let { Lamp(stringResource(R.string.stats_oil_temp, "%.0f".format(it)), false, colors.onBackground) }
+ }
+ }
+ }
+}
+
+@Composable
+private fun ArcDial(value: Float, max: Float, major: Float, label: (Float) -> String, red: Float?, readout: String, unit: String, modifier: Modifier) {
+ val pal = LocalPalette.current
+ val colors = MaterialTheme.colorScheme
+ val measurer = rememberTextMeasurer()
+ val labelStyle = TextStyle(color = colors.onSurfaceVariant, fontSize = 11.sp, fontFamily = FontFamily.Monospace)
+ Box(modifier) {
+ Canvas(Modifier.fillMaxSize()) {
+ val r = min(size.width * 0.46f, size.height * 0.5f)
+ val cx = size.width / 2f
+ val cy = r + 6.dp.toPx()
+ dialFace(cx, cy, r, max, major, label, measurer, labelStyle, colors.onBackground, colors.onSurfaceVariant, pal.line, red, StatsColors.brake)
+ needle(cx, cy, r - 18.dp.toPx(), dialAngle(value, max), colors.onBackground, pal.primary)
+ }
+ Column(Modifier.align(Alignment.BottomCenter), horizontalAlignment = Alignment.CenterHorizontally) {
+ Text(readout, fontSize = 22.sp, fontWeight = FontWeight.Bold, fontFamily = FontFamily.Monospace, color = colors.onBackground)
+ Text(unit, fontSize = 11.sp, color = colors.onSurfaceVariant, maxLines = 1)
+ }
+ }
+}
+
+@Composable
+private fun Lamp(label: String, on: Boolean, color: Color) {
+ val pal = LocalPalette.current
+ val shape = RoundedCornerShape(8.dp)
+ Text(label, fontSize = 12.sp, fontFamily = FontFamily.Monospace, fontWeight = if (on) FontWeight.Bold else FontWeight.Normal,
+ color = if (on) MaterialTheme.colorScheme.background else MaterialTheme.colorScheme.onSurfaceVariant, maxLines = 1,
+ modifier = Modifier.clip(shape).background(if (on) color else Color.Transparent).border(1.dp, if (on) color else pal.line, shape)
+ .padding(horizontal = 10.dp, vertical = 4.dp))
+}
+
+@Composable
+private fun GlanceDash(t: Telemetry, unit: SpeedUnit) {
+ val colors = MaterialTheme.colorScheme
+ val accent = LocalPalette.current.primary
+ val ratio = ((t.rpm ?: 0f) / rpmScale(t)).coerceIn(0f, 1f)
+ Row(Modifier.fillMaxWidth().height(DASH_H), horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+ EdgeBar(t.throttle, StatsColors.throttle)
+ StatsCard("", Modifier.weight(1f).fillMaxHeight()) {
+ Bar(ratio, if (ratio > 0.9f) StatsColors.brake else accent, Modifier.fillMaxWidth().height(14.dp))
+ Column(Modifier.fillMaxWidth().weight(1f), horizontalAlignment = Alignment.CenterHorizontally, verticalArrangement = Arrangement.Center) {
+ Text(speedText(t, unit), fontSize = 110.sp, fontWeight = FontWeight.Bold, fontFamily = FontFamily.Monospace, color = accent, lineHeight = 112.sp)
+ Text(unitAndGear(t, unit), fontSize = 34.sp, fontWeight = FontWeight.Bold, fontFamily = FontFamily.Monospace, color = colors.onBackground)
+ }
+ }
+ EdgeBar(t.brake, StatsColors.brake)
+ }
+}
+
+@Composable
+private fun EdgeBar(value: Float?, color: Color) {
+ Box(Modifier.width(14.dp).fillMaxHeight().clip(RoundedCornerShape(5.dp)).background(LocalPalette.current.line)) {
+ Box(Modifier.fillMaxWidth().fillMaxHeight((value ?: 0f).coerceIn(0f, 1f)).align(Alignment.BottomCenter).background(color))
+ }
+}
+
+/** War Thunder's own labels the Flight layout places; others stay in the list. */
+internal object FlightLabels {
+ const val IAS = "IAS, km/h"
+ const val ALTITUDE = "H, m"
+ const val G = "Ny"
+ const val FUEL = "Mfuel, kg"
+ const val THROTTLE = "throttle 1, %"
+
+ fun drawable(rows: List>): Boolean = rows.any { it.first == IAS || it.first == ALTITUDE }
+}
+
+@Composable
+internal fun FlightDash(rows: List>) {
+ val colors = MaterialTheme.colorScheme
+ val v = rows.toMap()
+ fun num(key: String) = v[key]?.toFloatOrNull()
+ Row(Modifier.fillMaxWidth().height(DASH_H), horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+ StatsCard(FlightLabels.IAS, Modifier.weight(1f).fillMaxHeight()) {
+ num(FlightLabels.IAS)?.let { Tape(it, 10f, 50f, Modifier.fillMaxWidth().weight(1f)) } ?: Text("–", color = colors.onSurfaceVariant)
+ }
+ Column(Modifier.weight(1.3f).fillMaxHeight(), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+ StatsCard(FlightLabels.THROTTLE, Modifier.fillMaxWidth().weight(1f)) {
+ val thr = num(FlightLabels.THROTTLE)
+ Bar((thr ?: 0f) / 110f, StatsColors.throttle, Modifier.fillMaxWidth().height(16.dp))
+ Text(thr?.let { "%.0f%%".format(it) } ?: "–", fontSize = 13.sp, fontFamily = FontFamily.Monospace, color = colors.onSurfaceVariant)
+ }
+ StatsCard(FlightLabels.G, Modifier.fillMaxWidth().weight(1f)) {
+ Text(num(FlightLabels.G)?.let { "%.1f".format(it) } ?: "–", fontSize = 34.sp, fontWeight = FontWeight.Bold, fontFamily = FontFamily.Monospace,
+ color = colors.onBackground)
+ num(FlightLabels.FUEL)?.let { Text("${FlightLabels.FUEL} %.0f".format(it), fontSize = 12.sp, color = colors.onSurfaceVariant) }
+ }
+ }
+ StatsCard(FlightLabels.ALTITUDE, Modifier.weight(1f).fillMaxHeight()) {
+ num(FlightLabels.ALTITUDE)?.let { Tape(it, 100f, 500f, Modifier.fillMaxWidth().weight(1f)) } ?: Text("–", color = colors.onSurfaceVariant)
+ }
+ }
+}
+
+@Composable
+private fun Tape(value: Float, step: Float, every: Float, modifier: Modifier) {
+ val pal = LocalPalette.current
+ val colors = MaterialTheme.colorScheme
+ val measurer = rememberTextMeasurer()
+ val small = TextStyle(color = colors.onSurfaceVariant, fontSize = 11.sp, fontFamily = FontFamily.Monospace)
+ val big = TextStyle(color = colors.onBackground, fontSize = 18.sp, fontWeight = FontWeight.Bold, fontFamily = FontFamily.Monospace)
+ Canvas(modifier) {
+ val cy = size.height / 2f
+ val px = (size.height / 2f) / (step * 4f)
+ val boxH = 32.dp.toPx()
+ var m = floor((value - step * 5f) / step) * step
+ while (m < value + step * 6f) {
+ val y = cy - (m - value) * px
+ if (y in 0f..size.height) {
+ val labelled = abs((m / every).roundToInt() * every - m) < 0.01f
+ drawLine(colors.onSurfaceVariant, Offset(size.width * 0.74f, y), Offset(size.width, y), strokeWidth = (if (labelled) 2.5f else 1f).dp.toPx())
+ if (labelled && abs(y - cy) > boxH * 0.75f) {
+ val layout = measurer.measure("%.0f".format(m), small)
+ drawText(layout, topLeft = Offset(size.width * 0.70f - layout.size.width, y - layout.size.height / 2f))
+ }
+ }
+ m += step
+ }
+ drawRoundRect(pal.primary, topLeft = Offset(1.dp.toPx(), cy - boxH / 2f), size = Size(size.width - 2.dp.toPx(), boxH),
+ cornerRadius = CornerRadius(8.dp.toPx()), style = Stroke(2.dp.toPx()))
+ val layout = measurer.measure("%.0f".format(value), big)
+ drawText(layout, topLeft = Offset(size.width / 2f - layout.size.width / 2f, cy - layout.size.height / 2f))
+ }
+}
+
+@Composable
+internal fun ShipDash(e: GameStatusFiles.Elite) {
+ val colors = MaterialTheme.colorScheme
+ Row(Modifier.fillMaxWidth().height(210.dp), horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+ StatsCard(stringResource(R.string.stats_power), Modifier.weight(1.2f).fillMaxHeight()) {
+ e.pips?.takeIf { it.size == 3 }?.let { Pips(it, Modifier.fillMaxWidth().weight(1f)) } ?: Text("–", color = colors.onSurfaceVariant)
+ }
+ Column(Modifier.weight(1f).fillMaxHeight(), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+ StatsCard(stringResource(R.string.stats_fuel_t), Modifier.fillMaxWidth().weight(1f)) {
+ e.fuelMain?.let { Text(stringResource(R.string.stats_fuel_main, "%.1f".format(it)), fontSize = 15.sp, fontWeight = FontWeight.Bold,
+ fontFamily = FontFamily.Monospace, color = colors.onBackground) }
+ e.fuelReserve?.let { Text(stringResource(R.string.stats_fuel_reserve, "%.2f".format(it)), fontSize = 12.sp, color = colors.onSurfaceVariant) }
+ }
+ StatsCard("", Modifier.fillMaxWidth().weight(1f)) {
+ e.cargo?.let { KvRow(stringResource(R.string.bottom_telemetry_cargo), "%.0f t".format(it)) }
+ e.legal?.let { KvRow(stringResource(R.string.bottom_telemetry_legal), it, if (it == "Clean") StatsColors.gpu else StatsColors.warn) }
+ e.balance?.let { KvRow(stringResource(R.string.bottom_telemetry_balance), "%,d CR".format(it)) }
+ }
+ }
+ }
+}
+
+@Composable
+private fun Pips(pips: List, modifier: Modifier) {
+ val pal = LocalPalette.current
+ val colors = MaterialTheme.colorScheme
+ val measurer = rememberTextMeasurer()
+ val style = TextStyle(color = colors.onSurfaceVariant, fontSize = 12.sp, fontWeight = FontWeight.Bold)
+ val names = listOf("SYS", "ENG", "WEP")
+ Canvas(modifier) {
+ val colW = size.width / 3f
+ val pipW = colW * 0.62f
+ val labelH = 18.dp.toPx()
+ val pipH = (size.height - labelH) / 4f - 4.dp.toPx()
+ for (col in 0 until 3) {
+ val x = col * colW + (colW - pipW) / 2f
+ // Status.json counts half pips: 0..8 per system.
+ val value = pips[col] / 2f
+ for (i in 0 until 4) {
+ val y = size.height - labelH - (i + 1) * (pipH + 4.dp.toPx())
+ drawRoundRect(pal.line, topLeft = Offset(x, y), size = Size(pipW, pipH), cornerRadius = CornerRadius(4.dp.toPx()))
+ val fill = (value - i).coerceIn(0f, 1f)
+ if (fill > 0f) drawRoundRect(pal.primary, topLeft = Offset(x, y), size = Size(pipW * fill, pipH), cornerRadius = CornerRadius(4.dp.toPx()))
+ }
+ val layout = measurer.measure(names[col], style)
+ drawText(layout, topLeft = Offset(col * colW + colW / 2f - layout.size.width / 2f, size.height - layout.size.height))
+ }
+ }
+}
diff --git a/app/src/main/java/com/droiddeck/launcher/ui/StatsStrips.kt b/app/src/main/java/com/droiddeck/launcher/ui/StatsStrips.kt
new file mode 100644
index 0000000000..7e6ae6434d
--- /dev/null
+++ b/app/src/main/java/com/droiddeck/launcher/ui/StatsStrips.kt
@@ -0,0 +1,293 @@
+package com.droiddeck.launcher.ui
+
+import androidx.compose.foundation.Canvas
+import androidx.compose.foundation.background
+import androidx.compose.foundation.border
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ColumnScope
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.RowScope
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.layout.widthIn
+import androidx.compose.foundation.shape.RoundedCornerShape
+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.draw.clip
+import androidx.compose.ui.draw.drawBehind
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.geometry.Size
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.Path
+import androidx.compose.ui.graphics.StrokeCap
+import androidx.compose.ui.graphics.StrokeJoin
+import androidx.compose.ui.graphics.drawscope.Stroke
+import androidx.compose.ui.graphics.drawscope.drawIntoCanvas
+import androidx.compose.ui.graphics.lerp
+import androidx.compose.ui.graphics.nativeCanvas
+import androidx.compose.ui.graphics.toArgb
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import com.droiddeck.launcher.R
+import com.droiddeck.launcher.hud.DroidDeckMark
+import com.droiddeck.launcher.hud.HudMetrics
+import com.droiddeck.launcher.session.StatsStrip
+import kotlin.math.max
+import kotlin.math.roundToInt
+
+/** FusionHUD's metric colors, so the bottom screen reads like the HUD on the top screen. */
+internal object StatsColors {
+ val cpu = Color(0xFF58A6FF)
+ val gpu = Color(0xFF5EE08A)
+ val ram = Color(0xFFFF7BC0)
+ val bat = Color(0xFFFFAB5E)
+ // Throttle and brake stay apart for red-green colour blindness (checked against the dark surface).
+ val throttle = Color(0xFF14A39A)
+ val brake = Color(0xFFE5484D)
+ val speed = Color(0xFF2E8FD6)
+ val warn = Color(0xFFF2C94C)
+ val shiftGreen = Color(0xFF2FB36A)
+ val badge = Color(0xFF0B0D10)
+}
+
+/** The last [capacity] readings, oldest first. */
+internal class History(private val capacity: Int) {
+ private val values = ArrayDeque(capacity)
+ fun add(v: Float) {
+ if (values.size == capacity) values.removeFirst()
+ values.addLast(v)
+ }
+ fun snapshot(): List = values.toList()
+}
+
+private val MARK_RATIO = DroidDeckMark.widthFor(1f)
+
+/** The DroidDeck mark (the split D with the blue orb), the same artwork the HUD draws. */
+@Composable
+internal fun DroidDeckLogo(height: Dp, modifier: Modifier = Modifier, body: Color = Color.White, orb: Color = LocalPalette.current.primary) {
+ Canvas(modifier.size(height * MARK_RATIO, height)) {
+ val b = body.toArgb()
+ val o = orb.toArgb()
+ drawIntoCanvas { DroidDeckMark.draw(it.nativeCanvas, 0f, 0f, size.height, b, o) }
+ }
+}
+
+@Composable
+private fun LogoBadge(size: Dp) {
+ val shape = RoundedCornerShape(size * 0.22f)
+ Box(Modifier.size(size).clip(shape).background(StatsColors.badge).border(2.dp, LocalPalette.current.primary, shape), contentAlignment = Alignment.Center) {
+ DroidDeckLogo(size * 0.62f)
+ }
+}
+
+/** The mark and "DroidDeck" on the left, the running game's name in the middle, the clock on the right. */
+@Composable
+private fun LogoHeader(clock: String, game: String?) {
+ val colors = MaterialTheme.colorScheme
+ Row(Modifier.fillMaxWidth().padding(horizontal = 2.dp), verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(6.dp)) {
+ DroidDeckLogo(16.dp)
+ Text("DroidDeck", fontSize = 13.sp, fontWeight = FontWeight.Bold, color = colors.onBackground)
+ Text(game.orEmpty(), fontSize = 13.sp, fontWeight = FontWeight.Bold, color = colors.onBackground, textAlign = TextAlign.Center,
+ maxLines = 1, overflow = TextOverflow.Ellipsis, modifier = Modifier.weight(1f))
+ if (clock.isNotEmpty()) Text(clock, fontSize = 12.sp, fontFamily = FontFamily.Monospace, color = colors.onSurfaceVariant)
+ }
+}
+
+@Composable
+internal fun Sparkline(values: List, min: Float, max: Float, color: Color, modifier: Modifier) {
+ Canvas(modifier) {
+ if (values.size < 2 || max <= min) return@Canvas
+ val path = Path()
+ values.forEachIndexed { i, v ->
+ val x = i / (values.size - 1f) * size.width
+ val y = size.height - ((v - min) / (max - min)).coerceIn(0f, 1f) * (size.height - 2f) - 1f
+ if (i == 0) path.moveTo(x, y) else path.lineTo(x, y)
+ }
+ drawPath(path, color, style = Stroke(width = 2.dp.toPx(), cap = StrokeCap.Round, join = StrokeJoin.Round))
+ }
+}
+
+/** A readout card: dark surface, a thin accent edge and the DroidDeck mark before the title ("" = mark only). */
+@Composable
+internal fun StatsCard(title: String?, modifier: Modifier = Modifier, content: @Composable ColumnScope.() -> Unit) {
+ val pal = LocalPalette.current
+ val shape = RoundedCornerShape(14.dp)
+ Column(
+ modifier.clip(shape).background(pal.surface).border(1.dp, pal.primary.copy(alpha = 0.22f), shape).padding(horizontal = 12.dp, vertical = 10.dp),
+ verticalArrangement = Arrangement.spacedBy(6.dp),
+ ) {
+ if (title != null) Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(6.dp)) {
+ DroidDeckLogo(12.dp, body = MaterialTheme.colorScheme.onSurfaceVariant)
+ if (title.isNotEmpty()) Text(title.uppercase(), fontSize = 11.sp, fontWeight = FontWeight.SemiBold, color = pal.primary, letterSpacing = 0.6.sp,
+ maxLines = 1, overflow = TextOverflow.Ellipsis)
+ }
+ content()
+ }
+}
+
+/** What the top strip shows; histories hold one reading a second, oldest first. */
+internal class StripData(
+ val fps: Float?,
+ val device: HudMetrics.Snapshot?,
+ val fpsHistory: List,
+ val cpuHistory: List,
+ val gpuHistory: List,
+ val wattsHistory: List,
+ val clock: String,
+ val game: String? = null,
+)
+
+private fun percentTemp(percent: Int?, temp: Int?): String =
+ listOfNotNull(percent?.let { "$it%" }, temp?.let { "$it°" }).joinToString(" · ").ifEmpty { "–" }
+
+private fun batteryText(s: HudMetrics.Snapshot?): String =
+ listOfNotNull(s?.battery?.percent?.let { "$it%" }, s?.battery?.watts?.takeIf { it > 0f }?.let { "%.1f W".format(it) }).joinToString(" · ").ifEmpty { "–" }
+
+private fun fpsText(fps: Float?): String = fps?.takeIf { it > 0f }?.let { "%.1f".format(it) } ?: "–"
+
+/** The top strip; a tap moves to the next style. */
+@Composable
+internal fun StatsStripView(style: StatsStrip, d: StripData, onTap: () -> Unit) {
+ Box(Modifier.fillMaxWidth().clickable(onClick = onTap)) {
+ when (style) {
+ StatsStrip.PANEL -> PanelStrip(d)
+ StatsStrip.TILES -> TilesStrip(d)
+ StatsStrip.RINGS -> RingsStrip(d)
+ }
+ }
+}
+
+@Composable
+private fun PanelStrip(d: StripData) {
+ val pal = LocalPalette.current
+ val colors = MaterialTheme.colorScheme
+ val accent = pal.primary
+ val shape = RoundedCornerShape(18.dp)
+ Row(
+ Modifier.fillMaxWidth().clip(shape).background(pal.surface).border(2.dp, accent, shape).padding(horizontal = 12.dp, vertical = 10.dp),
+ verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(12.dp),
+ ) {
+ LogoBadge(40.dp)
+ Column(Modifier.widthIn(min = 84.dp)) {
+ Row(verticalAlignment = Alignment.Bottom) {
+ Text(fpsText(d.fps), fontSize = 30.sp, fontWeight = FontWeight.Bold, fontFamily = FontFamily.Monospace, color = accent, maxLines = 1)
+ Text(" fps", fontSize = 12.sp, color = colors.onSurfaceVariant, modifier = Modifier.padding(bottom = 4.dp))
+ }
+ Text(d.fps?.takeIf { it > 0f }?.let { "%.1f ms".format(1000f / it) } ?: stringResource(R.string.stats_fps_needs_hud),
+ fontSize = 12.sp, fontFamily = FontFamily.Monospace, color = colors.onSurfaceVariant, maxLines = 1)
+ }
+ Sparkline(d.fpsHistory.map { 1000f / max(it, 1f) }, 8f, 34f, lerp(accent, Color.White, 0.3f), Modifier.weight(1f).height(44.dp))
+ Column(verticalArrangement = Arrangement.spacedBy(1.dp)) {
+ MetricRow("CPU", percentTemp(d.device?.cpuPercent, d.device?.cpuTempC), StatsColors.cpu)
+ MetricRow("GPU", percentTemp(d.device?.gpuPercent, d.device?.gpuTempC), StatsColors.gpu)
+ MetricRow("RAM", d.device?.let { "${it.ramPercent.roundToInt()}%" } ?: "–", StatsColors.ram)
+ MetricRow("BAT", batteryText(d.device), StatsColors.bat)
+ }
+ }
+}
+
+@Composable
+private fun MetricRow(label: String, value: String, color: Color) {
+ Row(verticalAlignment = Alignment.CenterVertically) {
+ Text(label, fontSize = 11.sp, fontWeight = FontWeight.Bold, fontFamily = FontFamily.Monospace, color = color, modifier = Modifier.width(36.dp))
+ Text(value, fontSize = 13.sp, fontWeight = FontWeight.Bold, fontFamily = FontFamily.Monospace, color = MaterialTheme.colorScheme.onBackground, maxLines = 1)
+ }
+}
+
+@Composable
+private fun TilesStrip(d: StripData) {
+ val accent = LocalPalette.current.primary
+ val s = d.device
+ val gpuPercent: Int? = s?.gpuPercent
+ val gpuTemp: Int? = s?.gpuTempC
+ Column(Modifier.fillMaxWidth(), verticalArrangement = Arrangement.spacedBy(6.dp)) {
+ LogoHeader(d.clock, d.game)
+ Row(Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+ HistoryTile("FPS", accent, fpsText(d.fps), "fps", d.fpsHistory, 75f)
+ HistoryTile("CPU", StatsColors.cpu, s?.cpuPercent?.let { "$it%" } ?: "–", s?.cpuTempC?.let { "$it°" } ?: "", d.cpuHistory, 100f)
+ HistoryTile("GPU", StatsColors.gpu, gpuPercent?.let { "$it%" } ?: gpuTemp?.let { "$it°" } ?: "–",
+ if (gpuPercent != null) gpuTemp?.let { "$it°" } ?: "" else "", d.gpuHistory, 100f)
+ HistoryTile(stringResource(R.string.bottom_telemetry_battery).uppercase(), StatsColors.bat, s?.battery?.percent?.let { "$it%" } ?: "–",
+ s?.battery?.watts?.takeIf { it > 0f }?.let { "%.1fW".format(it) } ?: "", d.wattsHistory, 10f)
+ }
+ }
+}
+
+@Composable
+private fun RowScope.HistoryTile(label: String, color: Color, value: String, unit: String, history: List, max: Float) {
+ val pal = LocalPalette.current
+ val colors = MaterialTheme.colorScheme
+ Column(
+ Modifier.weight(1f).clip(RoundedCornerShape(12.dp)).background(pal.surface)
+ .drawBehind { drawRect(color, topLeft = Offset.Zero, size = Size(size.width, 3.dp.toPx())) }
+ .padding(start = 10.dp, end = 10.dp, top = 9.dp, bottom = 6.dp),
+ ) {
+ Text(label, fontSize = 11.sp, fontWeight = FontWeight.Bold, color = color, letterSpacing = 0.8.sp, maxLines = 1)
+ Row(verticalAlignment = Alignment.Bottom) {
+ Text(value, fontSize = 22.sp, fontWeight = FontWeight.Bold, fontFamily = FontFamily.Monospace, color = colors.onBackground, maxLines = 1)
+ if (unit.isNotEmpty()) Text(" $unit", fontSize = 11.sp, color = colors.onSurfaceVariant, maxLines = 1, modifier = Modifier.padding(bottom = 3.dp))
+ }
+ Sparkline(history, 0f, max, color, Modifier.fillMaxWidth().height(24.dp))
+ }
+}
+
+@Composable
+private fun RingsStrip(d: StripData) {
+ val s = d.device
+ val gpuPercent: Int? = s?.gpuPercent
+ val gpuTemp: Int? = s?.gpuTempC
+ Column(Modifier.fillMaxWidth(), verticalArrangement = Arrangement.spacedBy(6.dp)) {
+ LogoHeader(d.clock, d.game)
+ Row(Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+ RingTile("CPU", StatsColors.cpu, s?.cpuPercent?.let { it / 100f }, s?.cpuPercent?.let { "$it%" } ?: "–", s?.cpuTempC?.let { "$it °C" } ?: "")
+ RingTile("GPU", StatsColors.gpu, gpuPercent?.let { it / 100f }, gpuPercent?.let { "$it%" } ?: gpuTemp?.let { "$it°" } ?: "–",
+ if (gpuPercent != null) gpuTemp?.let { "$it °C" } ?: "" else "")
+ RingTile("RAM", StatsColors.ram, s?.ramPercent?.let { it / 100f }, s?.let { "${it.ramPercent.roundToInt()}%" } ?: "–",
+ s?.let { "%.1f of %.1f GB".format(it.ramUsedBytes / 1e9, it.ramTotalBytes / 1e9) } ?: "")
+ RingTile(stringResource(R.string.bottom_telemetry_battery).uppercase(), StatsColors.bat, s?.battery?.percent?.let { it / 100f },
+ s?.battery?.percent?.let { "$it%" } ?: "–", s?.battery?.watts?.takeIf { it > 0f }?.let { "%.1f W".format(it) } ?: "")
+ }
+ }
+}
+
+@Composable
+private fun RowScope.RingTile(label: String, color: Color, fraction: Float?, center: String, sub: String) {
+ val pal = LocalPalette.current
+ val colors = MaterialTheme.colorScheme
+ Row(
+ Modifier.weight(1f).clip(RoundedCornerShape(12.dp)).background(pal.surface).padding(8.dp),
+ verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp),
+ ) {
+ Box(Modifier.size(52.dp), contentAlignment = Alignment.Center) {
+ Canvas(Modifier.fillMaxSize()) {
+ val w = 6.dp.toPx()
+ val tl = Offset(w / 2, w / 2)
+ val sz = Size(size.width - w, size.height - w)
+ drawArc(pal.line, 0f, 360f, false, topLeft = tl, size = sz, style = Stroke(width = w))
+ if (fraction != null) drawArc(color, -90f, (fraction.coerceIn(0f, 1f) * 360f).coerceAtLeast(1f), false, topLeft = tl, size = sz,
+ style = Stroke(width = w, cap = StrokeCap.Round))
+ }
+ Text(center, fontSize = 12.sp, fontWeight = FontWeight.Bold, fontFamily = FontFamily.Monospace, color = colors.onBackground, maxLines = 1)
+ }
+ Column {
+ Text(label, fontSize = 11.sp, fontWeight = FontWeight.Bold, color = color, letterSpacing = 0.8.sp, maxLines = 1)
+ if (sub.isNotEmpty()) Text(sub, fontSize = 11.sp, color = colors.onSurfaceVariant, maxLines = 1, overflow = TextOverflow.Ellipsis)
+ }
+ }
+}
diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml
index d16af65eae..ed1ebe5455 100644
--- a/app/src/main/res/values/strings.xml
+++ b/app/src/main/res/values/strings.xml
@@ -1875,6 +1875,93 @@
Keyboard + trackpad
Terminal
Deck grips + trackpads
+ Dashboard
+ Nothing to show here yet.
+ Downloads
+ No downloads running.
+ Steam
+ Downloading shader cache
+ Paused
+ Waiting to start
+ Notifications
+ DroidDeck bottom screen
+ Show messages and other notifications here while you play. They stay on this screen only and are not saved. Android asks once: its notification access page opens on this screen; turn DroidDeck on there and this page comes back by itself.
+ Allow notification access
+ No notifications.
+ %1$d notifications
+ Clear
+ Screenshots
+ FPS needs the HUD on
+ Speed
+ Pedals
+ G-force
+ Timing
+ Best lap
+ Tires °C
+ Throttle and brake, last 10 s
+ Speed, %1$s
+ Gear
+ Speed units
+ Automatic (%1$s)
+ Steam Client ARM
+ Steam Client x86
+ Throttle
+ Brake
+ Dashboard
+ Shift
+ Handbrake
+ Pit limiter
+ TC
+ ABS
+ Turbo %1$s bar
+ Engine %1$s °C
+ Oil %1$s °C
+ Power distributor
+ Fuel, t
+ Main %1$s t
+ Reserve %1$s t
+ Tap the top strip or the dash to change its style.
+ Send dashboard data
+ Automatic
+ Turns it on for every game listed here, including games found later. Games you switch off stay off.
+ This changes the game\'s own data output setting. It takes effect the next time the game starts; turning it off puts the old setting back.
+ Close %1$s to change this.
+ Could not change the settings of %1$s.
+ %1$s: turn on %2$s in the game\'s settings with IP 127.0.0.1 and port %3$d.
+ Saved to Pictures/DroidDeck. Steam screenshots show here too.
+ Take screenshot
+ Screenshot saved.
+ Could not take a screenshot.
+ No screenshots yet.
+ Chat & voice
+ Read and answer Steam chat here while the game keeps running on the main screen. It uses the account Steam is signed in with.
+ Steam has no web sign-in to share yet, so sign in here once.
+ Android closed the chat page while DroidDeck was in the background. It opens again when you come back to DroidDeck.
+ Open Steam Chat
+ Close chat
+ Mic on
+ Mic off
+ Mic is off for this game. To talk, turn on Microphone in DroidDeck\'s Steam settings (Audio) and start the game again.
+ Volume %1$d%%
+ In-game stats
+ FPS
+ CPU
+ GPU
+ Battery
+ Lap
+ Position
+ This lap
+ Last lap
+ Fuel
+ Cargo
+ Pips SYS · ENG · WEP
+ Legal state
+ Balance
+ War Thunder
+ Elite Dangerous
+ Turn on a racing game\'s data output (often called telemetry or UDP) to see a live dash here. It stays on this device.
+ Port %1$d receives data (%2$d packets of %3$d bytes), but in a format this page cannot read yet.
+ Another program already uses port %1$s, so that game cannot show here.
Removing Linux runtime
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 da6b3bec2e..8a66101f1b 100644
--- a/app/src/test/java/com/droiddeck/launcher/input/SecondScreenModeTest.kt
+++ b/app/src/test/java/com/droiddeck/launcher/input/SecondScreenModeTest.kt
@@ -4,23 +4,38 @@ import org.junit.Assert.assertEquals
import org.junit.Test
class SecondScreenModeTest {
- @Test fun withNothingRememberedTheControllerPicksThePanel() {
+ @Test fun withNothingRememberedTheDashboardOpens() {
+ assertEquals(SecondScreenMode.DASHBOARD, SecondScreenMode.opening(null, deckPad = true, dashboard = true))
+ assertEquals(SecondScreenMode.DASHBOARD, SecondScreenMode.opening(null, deckPad = false, dashboard = true))
+ }
+
+ @Test fun withNothingRememberedAndNoDashboardTheControllerPicksThePanel() {
assertEquals(SecondScreenMode.DECK_CONTROLS, SecondScreenMode.opening(null, deckPad = true))
assertEquals(SecondScreenMode.KEYBOARD_TRACKPAD, SecondScreenMode.opening(null, deckPad = false))
}
@Test fun thePanelTheUserPickedLastOpensAgain() {
+ assertEquals(SecondScreenMode.KEYBOARD_TRACKPAD, SecondScreenMode.opening("keyboard-trackpad", deckPad = true, dashboard = true))
+ assertEquals(SecondScreenMode.DECK_CONTROLS, SecondScreenMode.opening("deck-controls", deckPad = true, dashboard = true))
+ assertEquals(SecondScreenMode.TERMINAL, SecondScreenMode.opening("terminal", deckPad = true, dashboard = true))
assertEquals(SecondScreenMode.KEYBOARD_TRACKPAD, SecondScreenMode.opening("keyboard-trackpad", deckPad = true))
- assertEquals(SecondScreenMode.DECK_CONTROLS, SecondScreenMode.opening("deck-controls", deckPad = true))
- assertEquals(SecondScreenMode.TERMINAL, SecondScreenMode.opening("terminal", deckPad = true))
}
@Test fun deckControlsNeedTheDeckPad() {
assertEquals(SecondScreenMode.KEYBOARD_TRACKPAD, SecondScreenMode.opening("deck-controls", deckPad = false))
+ assertEquals(SecondScreenMode.KEYBOARD_TRACKPAD, SecondScreenMode.opening("deck-controls", deckPad = false, dashboard = true))
}
@Test fun anUnknownOrClosedChoiceFallsBackToTheDefault() {
+ assertEquals(SecondScreenMode.DASHBOARD, SecondScreenMode.opening("none", deckPad = true, dashboard = true))
+ assertEquals(SecondScreenMode.DASHBOARD, SecondScreenMode.opening("gone", deckPad = false, dashboard = true))
assertEquals(SecondScreenMode.DECK_CONTROLS, SecondScreenMode.opening("none", deckPad = true))
assertEquals(SecondScreenMode.KEYBOARD_TRACKPAD, SecondScreenMode.opening("gone", deckPad = false))
}
+
+ @Test fun theDashboardOpensAgainOnlyWhileItHasPages() {
+ assertEquals(SecondScreenMode.DASHBOARD, SecondScreenMode.opening("dashboard", deckPad = true, dashboard = true))
+ assertEquals(SecondScreenMode.DECK_CONTROLS, SecondScreenMode.opening("dashboard", deckPad = true, dashboard = false))
+ assertEquals(SecondScreenMode.KEYBOARD_TRACKPAD, SecondScreenMode.opening("dashboard", deckPad = false))
+ }
}
diff --git a/app/src/test/java/com/droiddeck/launcher/session/BottomNotificationsTest.kt b/app/src/test/java/com/droiddeck/launcher/session/BottomNotificationsTest.kt
new file mode 100644
index 0000000000..19046dc27b
--- /dev/null
+++ b/app/src/test/java/com/droiddeck/launcher/session/BottomNotificationsTest.kt
@@ -0,0 +1,38 @@
+package com.droiddeck.launcher.session
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class BottomNotificationsTest {
+ private val own = "com.droiddeck.launcher"
+
+ @Test fun messagesFromOtherAppsAreKept() {
+ assertTrue(BottomNotifications.keep(own, "com.discord", ongoing = false, groupSummary = false, title = "Kurt", text = "ready?"))
+ }
+
+ @Test fun ownOngoingSummaryAndEmptyNotificationsAreSkipped() {
+ assertFalse(BottomNotifications.keep(own, own, ongoing = false, groupSummary = false, title = "Session", text = "running"))
+ assertFalse(BottomNotifications.keep(own, "com.spotify", ongoing = true, groupSummary = false, title = "Song", text = "Artist"))
+ assertFalse(BottomNotifications.keep(own, "com.discord", ongoing = false, groupSummary = true, title = "2 messages", text = ""))
+ assertFalse(BottomNotifications.keep(own, "com.discord", ongoing = false, groupSummary = false, title = " ", text = ""))
+ }
+
+ @Test fun anUpdatedNotificationMovesToTheTopOnce() {
+ val list = mutableListOf(
+ BottomNotification("a", "App", "one", "", 1L),
+ BottomNotification("b", "App", "two", "", 2L),
+ )
+ BottomNotifications.add(list, BottomNotification("b", "App", "two again", "", 3L))
+ assertEquals(listOf("b", "a"), list.map { it.key })
+ assertEquals("two again", list.first().title)
+ }
+
+ @Test fun theListKeepsTheNewestThirty() {
+ val list = mutableListOf()
+ repeat(35) { BottomNotifications.add(list, BottomNotification("k$it", "App", "t$it", "", it.toLong())) }
+ assertEquals(30, list.size)
+ assertEquals("k34", list.first().key)
+ }
+}
diff --git a/app/src/test/java/com/droiddeck/launcher/session/BottomScreenshotsTest.kt b/app/src/test/java/com/droiddeck/launcher/session/BottomScreenshotsTest.kt
new file mode 100644
index 0000000000..0731f6b90e
--- /dev/null
+++ b/app/src/test/java/com/droiddeck/launcher/session/BottomScreenshotsTest.kt
@@ -0,0 +1,32 @@
+package com.droiddeck.launcher.session
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+import java.io.File
+
+class BottomScreenshotsTest {
+ @get:Rule val tmp = TemporaryFolder()
+
+ @Test fun fileNamesSortByTime() {
+ val name = BottomScreenshots.fileName(0L)
+ assertTrue(name, name.startsWith("DroidDeck_") && name.endsWith(".jpg"))
+ assertEquals(29, name.length)
+ }
+
+ @Test fun steamScreenshotsAreFoundAndThumbnailsSkipped() {
+ val root = tmp.root
+ val shots = File(root, "root/.local/share/Steam/userdata/2932373/760/remote/220/screenshots")
+ File(shots, "thumbnails").mkdirs()
+ File(shots, "20261031010101_1.jpg").writeText("x")
+ File(shots, "thumbnails/20261031010101_1.jpg").writeText("x")
+ File(shots, "screenshots.vdf").writeText("x")
+ val x64 = File(root, "root/.droiddeck-x64/.local/share/Steam/userdata/2932373/760/remote/440/screenshots")
+ x64.mkdirs()
+ File(x64, "20261031020202_1.jpg").writeText("x")
+ val found = BottomScreenshots.steam(root).map { it.file!!.name }.sorted()
+ assertEquals(listOf("20261031010101_1.jpg", "20261031020202_1.jpg"), found)
+ }
+}
diff --git a/app/src/test/java/com/droiddeck/launcher/session/GameTelemetryTest.kt b/app/src/test/java/com/droiddeck/launcher/session/GameTelemetryTest.kt
new file mode 100644
index 0000000000..fc5cbfca98
--- /dev/null
+++ b/app/src/test/java/com/droiddeck/launcher/session/GameTelemetryTest.kt
@@ -0,0 +1,226 @@
+package com.droiddeck.launcher.session
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+
+class GameTelemetryTest {
+ private fun packet(size: Int, fill: ByteBuffer.() -> Unit): ByteArray =
+ ByteBuffer.allocate(size).order(ByteOrder.LITTLE_ENDIAN).apply(fill).array()
+
+ @Test fun codemastersFloatsBecomeADash() {
+ val data = packet(264) {
+ putFloat(7 * 4, 25f) // m/s
+ putFloat(29 * 4, 0.8f)
+ putFloat(31 * 4, 0.1f)
+ putFloat(33 * 4, 3f)
+ putFloat(36 * 4, 1f)
+ putFloat(37 * 4, 650f) // rpm / 10
+ putFloat(63 * 4, 800f)
+ putFloat(45 * 4, 30f)
+ putFloat(46 * 4, 60f)
+ }
+ val t = GameTelemetry.parse(GameTelemetry.CODEMASTERS_PORT, data, data.size)!!
+ assertEquals(90f, t.speedKmh!!, 0.01f)
+ assertEquals("3", t.gear)
+ assertEquals(6500f, t.rpm!!, 0.01f)
+ assertEquals(8000f, t.maxRpm!!, 0.01f)
+ assertEquals(2, t.lap)
+ assertEquals(0.5f, t.fuel!!, 0.001f)
+ }
+
+ // Values from a DiRT Showdown packet recorded on a Retroid Pocket Duo (extradata 3 still sends 152 bytes there).
+ @Test fun codemastersShortPacketFromDirtShowdown() {
+ val data = packet(152) {
+ putFloat(1 * 4, 80.085f)
+ putFloat(7 * 4, 10.739f)
+ putFloat(29 * 4, 0.816f)
+ putFloat(33 * 4, 1f)
+ putFloat(37 * 4, 827.531f)
+ }
+ val t = GameTelemetry.parse(GameTelemetry.CODEMASTERS_PORT, data, data.size)!!
+ assertEquals(38.66f, t.speedKmh!!, 0.01f)
+ assertEquals("1", t.gear)
+ assertEquals(8275.31f, t.rpm!!, 0.01f)
+ assertEquals(0.816f, t.throttle!!, 0.001f)
+ assertEquals(1, t.lap)
+ assertEquals(80.085f, t.currentLapS!!, 0.001f)
+ assertNull(t.maxRpm)
+ assertNull(t.laps)
+ assertNull(t.position)
+ assertNull(t.fuel)
+ assertNull(t.lastLapS)
+ }
+
+ @Test fun codemastersReverseAndNeutral() {
+ fun gear(g: Float) = GameTelemetry.parse(GameTelemetry.CODEMASTERS_PORT, packet(264) { putFloat(33 * 4, g) }, 264)!!.gear
+ assertEquals("N", gear(0f))
+ assertEquals("R", gear(-1f))
+ assertEquals("R", gear(10f))
+ }
+
+ @Test fun forzaHorizonDashSitsTwelveBytesLater() {
+ val dash = 232 + 12
+ val data = packet(324) {
+ putInt(0, 1)
+ putFloat(8, 8000f)
+ putFloat(16, 5000f)
+ putFloat(dash + 12, 50f)
+ put(dash + 71, 255.toByte())
+ put(dash + 75, 4)
+ putShort(dash + 68, 2)
+ put(dash + 70, 5)
+ }
+ val t = GameTelemetry.parse(GameTelemetry.FORZA_PORT, data, data.size)!!
+ assertEquals(180f, t.speedKmh!!, 0.01f)
+ assertEquals("4", t.gear)
+ assertEquals(1f, t.throttle!!, 0.001f)
+ assertEquals(3, t.lap)
+ assertEquals(5, t.position)
+ }
+
+ @Test fun forzaMotorsportDashFollowsTheSled() {
+ val data = packet(311) {
+ putInt(0, 1)
+ putFloat(232 + 12, 10f)
+ put(232 + 75, 0)
+ }
+ val t = GameTelemetry.parse(GameTelemetry.FORZA_PORT, data, data.size)!!
+ assertEquals(36f, t.speedKmh!!, 0.01f)
+ assertEquals("R", t.gear)
+ }
+
+ @Test fun forzaInMenusHasNoDash() {
+ val t = GameTelemetry.parse(GameTelemetry.FORZA_PORT, packet(324) {}, 324)!!
+ assertNull(t.speedKmh)
+ }
+
+ @Test fun outGaugeGearsAreShiftedByOne() {
+ val data = packet(96) {
+ put(10, 3)
+ putFloat(12, 20f)
+ putFloat(16, 4000f)
+ }
+ val t = GameTelemetry.parse(GameTelemetry.OUTGAUGE_PORT, data, data.size)!!
+ assertEquals("2", t.gear)
+ assertEquals(72f, t.speedKmh!!, 0.01f)
+ assertEquals(4000f, t.rpm!!, 0.01f)
+ }
+
+ @Test fun listensOnIpv4Loopback() {
+ assertTrue(GameTelemetry.LISTEN_ADDRESS is java.net.Inet4Address)
+ assertEquals("127.0.0.1", GameTelemetry.LISTEN_ADDRESS.hostAddress)
+ }
+
+ @Test fun shortPacketsAreIgnored() {
+ assertNull(GameTelemetry.parse(GameTelemetry.CODEMASTERS_PORT, ByteArray(148), 148))
+ assertNull(GameTelemetry.parse(GameTelemetry.OUTGAUGE_PORT, ByteArray(40), 40))
+ assertNull(GameTelemetry.parse(1234, ByteArray(400), 400))
+ }
+
+ // DiRT Showdown's 38 floats already carry steering and both G-forces.
+ @Test fun codemastersGForceAndSteering() {
+ val data = packet(152) {
+ putFloat(30 * 4, -0.5f)
+ putFloat(33 * 4, 2f)
+ putFloat(34 * 4, 1.2f)
+ putFloat(35 * 4, -0.8f)
+ }
+ val t = GameTelemetry.parse(GameTelemetry.CODEMASTERS_PORT, data, data.size)!!
+ assertEquals(-0.5f, t.steer!!, 1e-4f)
+ assertEquals(1.2f, t.gLat!!, 1e-4f)
+ assertEquals(-0.8f, t.gLon!!, 1e-4f)
+ }
+
+ @Test fun forzaReadsBestLapSteeringGForceAndTires() {
+ val dash = 232
+ val data = packet(311) {
+ putInt(0, 1)
+ putFloat(20, 9.81f)
+ putFloat(28, -4.905f)
+ putFloat(dash + 24, 212f)
+ putFloat(dash + 28, 32f)
+ putFloat(dash + 32, 194f)
+ putFloat(dash + 36, 176f)
+ putFloat(dash + 52, 81.5f)
+ put(dash + 75, 3)
+ put(dash + 76, (-127).toByte())
+ }
+ val t = GameTelemetry.parse(GameTelemetry.FORZA_PORT, data, data.size)!!
+ assertEquals(1f, t.gLat!!, 1e-3f)
+ assertEquals(-0.5f, t.gLon!!, 1e-3f)
+ assertEquals(listOf(100f, 0f, 90f, 80f), t.tireTempsC!!.map { Math.round(it).toFloat() })
+ assertEquals(81.5f, t.bestLapS!!, 1e-4f)
+ assertEquals(-1f, t.steer!!, 1e-4f)
+ }
+
+ @Test fun forzaWithoutTireDataLeavesThemOut() {
+ val data = packet(311) { putInt(0, 1); put(232 + 75, 2) }
+ assertNull(GameTelemetry.parse(GameTelemetry.FORZA_PORT, data, data.size)!!.tireTempsC)
+ }
+
+ @Test fun outGaugeReadsTurboTemperaturesAndLights() {
+ val data = packet(92) {
+ put(10, 3)
+ putFloat(20, 0.8f)
+ putFloat(24, 92f)
+ putFloat(36, 104f)
+ putInt(40, GameTelemetry.DL_SHIFT or GameTelemetry.DL_ABS or GameTelemetry.DL_HANDBRAKE)
+ putInt(44, GameTelemetry.DL_SHIFT or GameTelemetry.DL_ABS)
+ }
+ val t = GameTelemetry.parse(GameTelemetry.OUTGAUGE_PORT, data, data.size)!!
+ assertEquals(0.8f, t.turboBar!!, 1e-4f)
+ assertEquals(92f, t.engineTempC!!, 1e-4f)
+ assertEquals(104f, t.oilTempC!!, 1e-4f)
+ assertEquals(GameTelemetry.DL_SHIFT or GameTelemetry.DL_ABS, t.lights)
+ }
+
+ // BeamNG leaves some OutGauge fields at zero; those stay hidden.
+ @Test fun outGaugeZeroFieldsStayHidden() {
+ val t = GameTelemetry.parse(GameTelemetry.OUTGAUGE_PORT, packet(92) { put(10, 2) }, 92)!!
+ assertNull(t.turboBar)
+ assertNull(t.engineTempC)
+ assertNull(t.lights)
+ }
+}
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [33])
+class GameStatusFilesTest {
+ @Test fun warThunderShowsNumbersOnlyDuringAMatch() {
+ assertEquals(emptyList>(), GameStatusFiles.warThunder("""{"valid": false}"""))
+ val rows = GameStatusFiles.warThunder("""{"valid": true, "H, m": 1520, "TAS, km/h": 512.4, "name": "x"}""")
+ assertEquals(listOf("H, m" to "1520", "TAS, km/h" to "512.4"), rows)
+ }
+
+ @Test fun warThunderKeepsEveryNumberForTheFlightLayout() {
+ val json = buildString {
+ append("{\"valid\": true")
+ for (i in 0 until 20) append(", \"k$i\": $i")
+ append(", \"IAS, km/h\": 512, \"throttle 1, %\": 110}")
+ }
+ val rows = GameStatusFiles.warThunder(json)
+ assertEquals(22, rows.size)
+ assertTrue(com.droiddeck.launcher.ui.FlightLabels.drawable(rows))
+ assertEquals("110", rows.toMap()["throttle 1, %"])
+ }
+
+ @Test fun eliteAtTheMenusShowsNothing() {
+ assertNull(GameStatusFiles.elite("""{"timestamp": "2026-10-31T02:00:00Z", "event": "Status", "Flags": 0}"""))
+ }
+
+ @Test fun eliteInFlight() {
+ val e = GameStatusFiles.elite("""{"Flags": 16777240, "Pips": [4, 8, 0], "Fuel": {"FuelMain": 16.0, "FuelReservoir": 0.43},
+ "Cargo": 2.0, "LegalState": "Clean", "Balance": 1234567}""")!!
+ assertEquals(16.0, e.fuelMain!!, 0.001)
+ assertEquals(listOf(4, 8, 0), e.pips)
+ assertEquals("Clean", e.legal)
+ assertEquals(1234567L, e.balance)
+ }
+}
diff --git a/app/src/test/java/com/droiddeck/launcher/session/StatsLayoutTest.kt b/app/src/test/java/com/droiddeck/launcher/session/StatsLayoutTest.kt
new file mode 100644
index 0000000000..636e7e439a
--- /dev/null
+++ b/app/src/test/java/com/droiddeck/launcher/session/StatsLayoutTest.kt
@@ -0,0 +1,51 @@
+package com.droiddeck.launcher.session
+
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class StatsLayoutTest {
+ @Test fun unknownIdsFallBackToTheDefaults() {
+ assertEquals(StatsStrip.PANEL, StatsStrip.from(null))
+ assertEquals(StatsStrip.RINGS, StatsStrip.from("rings"))
+ assertEquals(StatsDash.AUTO, StatsDash.from("gone"))
+ assertEquals(StatsDash.TRACE, StatsDash.from("trace"))
+ }
+
+ @Test fun tappingTheStripCyclesThroughEveryStyle() {
+ assertEquals(StatsStrip.TILES, StatsStrip.PANEL.next())
+ assertEquals(StatsStrip.RINGS, StatsStrip.TILES.next())
+ assertEquals(StatsStrip.PANEL, StatsStrip.RINGS.next())
+ }
+
+ @Test fun autoPicksTheDashByTheGamesFormat() {
+ assertEquals(StatsDash.SPEEDOMETER, StatsDash.AUTO.resolve("Codemasters"))
+ assertEquals(StatsDash.CIRCUIT, StatsDash.AUTO.resolve("Forza"))
+ assertEquals(StatsDash.DIALS, StatsDash.AUTO.resolve("OutGauge"))
+ assertEquals(StatsDash.TRACE, StatsDash.TRACE.resolve("Forza"))
+ }
+
+ @Test fun tappingTheDashMovesOnFromTheOneOnScreen() {
+ assertEquals(StatsDash.CIRCUIT, StatsDash.tapped(StatsDash.SPEEDOMETER))
+ assertEquals(StatsDash.SPEEDOMETER, StatsDash.tapped(StatsDash.GLANCE))
+ assertEquals(StatsDash.SPEEDOMETER, StatsDash.tapped(StatsDash.AUTO))
+ }
+
+ @Test fun automaticSpeedUnitsFollowTheRegion() {
+ assertEquals(SpeedUnit.MPH, SpeedUnit.AUTO.resolve("US"))
+ assertEquals(SpeedUnit.MPH, SpeedUnit.AUTO.resolve("gb"))
+ assertEquals(SpeedUnit.KMH, SpeedUnit.AUTO.resolve("DE"))
+ assertEquals(SpeedUnit.KMH, SpeedUnit.AUTO.resolve(""))
+ assertEquals(SpeedUnit.KMH, SpeedUnit.KMH.resolve("US"))
+ assertEquals(SpeedUnit.MPH, SpeedUnit.MPH.resolve("DE"))
+ }
+
+ @Test fun speedUnitsCycleAndConvert() {
+ assertEquals(SpeedUnit.AUTO, SpeedUnit.from(null))
+ assertEquals(SpeedUnit.MPH, SpeedUnit.from("mph"))
+ assertEquals(SpeedUnit.KMH, SpeedUnit.AUTO.next())
+ assertEquals(SpeedUnit.MPH, SpeedUnit.KMH.next())
+ assertEquals(SpeedUnit.AUTO, SpeedUnit.MPH.next())
+ assertEquals(62.1f, 100f * SpeedUnit.MPH.perKmh, 0.05f)
+ assertEquals(100f, 100f * SpeedUnit.KMH.perKmh, 0f)
+ }
+}
diff --git a/app/src/test/java/com/droiddeck/launcher/session/SteamDownloadsTest.kt b/app/src/test/java/com/droiddeck/launcher/session/SteamDownloadsTest.kt
new file mode 100644
index 0000000000..ff6e7a4ae9
--- /dev/null
+++ b/app/src/test/java/com/droiddeck/launcher/session/SteamDownloadsTest.kt
@@ -0,0 +1,62 @@
+package com.droiddeck.launcher.session
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class SteamDownloadsTest {
+ private fun manifest(flags: Long, done: Long, total: Long) = """
+ "AppState"
+ {
+ "appid" "220"
+ "name" "Half-Life 2"
+ "StateFlags" "$flags"
+ "BytesToDownload" "$total"
+ "BytesDownloaded" "$done"
+ }
+ """.trimIndent()
+
+ @Test fun anAppUnfinishedInBothSteamHomesIsListedOnce() {
+ val arm = SteamDownload("220", "Half-Life 2", 10L, 100L)
+ val x86 = SteamDownload("220", "Half-Life 2", 60L, 100L)
+ val other = SteamDownload("440", "Team Fortress 2", 5L, 50L)
+ assertEquals(listOf(x86, other), SteamDownloads.onePerApp(listOf(arm, x86, other)))
+ }
+
+ @Test fun anInstalledGameIsNotADownload() {
+ assertNull(SteamDownloads.fromManifest("220", "Half-Life 2", manifest(4, 100, 100)))
+ }
+
+ @Test fun aRunningUpdateShowsItsBytes() {
+ val d = SteamDownloads.fromManifest("220", "Half-Life 2", manifest(1026, 40, 100))!!
+ assertEquals(40L, d.done)
+ assertEquals(100L, d.total)
+ }
+
+ @Test fun aPausedUpdateSaysSo() {
+ assertTrue(SteamDownloads.fromManifest("220", "Half-Life 2", manifest(514, 40, 100))!!.paused)
+ }
+
+ @Test fun anUpdateNotSizedYetIsStillListed() {
+ assertEquals(0L, SteamDownloads.fromManifest("220", "Half-Life 2", manifest(6, 0, 0))!!.total)
+ }
+
+ @Test fun onlyShaderUpdatesStillRunningCount() {
+ val log = sequenceOf(
+ "[2026-10-30 06:33:02] AppID 220 Shader update changed : Running Update,Downloading,",
+ "[2026-10-30 06:33:02] AppID 440 Shader update changed : Running Update,",
+ "[2026-10-30 06:33:03] AppID 440 Shader update changed : None",
+ "[2026-10-30 06:33:03] AppID 570 App update changed : Running Update,",
+ )
+ assertEquals(listOf("220"), SteamDownloads.runningShaderUpdates(log))
+ }
+
+ @Test fun aClientRestartForgetsOlderShaderUpdates() {
+ val log = sequenceOf(
+ "[2026-10-30 06:33:02] AppID 220 Shader update changed : Running Update,",
+ "[2026-10-30 07:00:00] Client version: 1761000000",
+ )
+ assertEquals(emptyList(), SteamDownloads.runningShaderUpdates(log))
+ }
+}
diff --git a/app/src/test/java/com/droiddeck/launcher/session/SteamWebLoginTest.kt b/app/src/test/java/com/droiddeck/launcher/session/SteamWebLoginTest.kt
new file mode 100644
index 0000000000..01988bf841
--- /dev/null
+++ b/app/src/test/java/com/droiddeck/launcher/session/SteamWebLoginTest.kt
@@ -0,0 +1,31 @@
+package com.droiddeck.launcher.session
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+class SteamWebLoginTest {
+ private fun hex(s: String) = ByteArray(s.length / 2) { s.substring(it * 2, it * 2 + 2).toInt(16).toByte() }
+
+ // Made with: openssl enc -aes-128-cbc -K -iv <16 spaces>, prefixed "v10".
+ @Test fun chromiumV10ValuesDecrypt() {
+ val encrypted = hex("7631300b9cf0a6eee9cf1aaac601b85ca37cf9fe9e67078564f0e05835ae2aa3d9b0ab")
+ assertEquals("0123456789abcdef01234567", SteamWebLogin.decrypt(encrypted, hostHashed = false))
+ }
+
+ @Test fun newerStoresDropTheHostHash() {
+ val encrypted = hex("7631304d4114329f1e692e807b8b044d67460f5e14d92ffb48b9f83be318ebd0d84c727674aea32f351b8a33c8aa42553dfeb5")
+ assertEquals("hello", SteamWebLogin.decrypt(encrypted, hostHashed = true))
+ }
+
+ @Test fun otherFormatsAreSkipped() {
+ assertNull(SteamWebLogin.decrypt("v11garbage".toByteArray(), hostHashed = false))
+ assertNull(SteamWebLogin.decrypt(ByteArray(2), hostHashed = false))
+ }
+
+ @Test fun theSignInIsSentTheWaySteamPagesSendIt() {
+ assertEquals("steamLoginSecure=76561190000000000%7C%7Ca.b.c; Path=/; Secure; HttpOnly",
+ SteamWebLogin.header("steamLoginSecure", "76561190000000000||a.b.c", httpOnly = true))
+ assertEquals("sessionid=0123; Path=/; Secure", SteamWebLogin.header("sessionid", "0123", httpOnly = false))
+ }
+}
diff --git a/app/src/test/java/com/droiddeck/launcher/session/TelemetryOutputTest.kt b/app/src/test/java/com/droiddeck/launcher/session/TelemetryOutputTest.kt
new file mode 100644
index 0000000000..cd65b2a577
--- /dev/null
+++ b/app/src/test/java/com/droiddeck/launcher/session/TelemetryOutputTest.kt
@@ -0,0 +1,116 @@
+package com.droiddeck.launcher.session
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+import java.io.File
+
+class TelemetryOutputTest {
+ @get:Rule val tmp = TemporaryFolder()
+
+ // DiRT Showdown's own line, as found in its prefix on the Retroid Pocket Duo.
+ private val showdown = "\n\n" +
+ "\t\n\t\n" +
+ "\n"
+
+ @Test fun turningOnPointsTheMotionLineHereAndKeepsTheRest() {
+ val on = TelemetryOutput.turnedOn(showdown)!!
+ assertTrue(on.contains(""))
+ assertEquals(showdown.replace("ip=\"dbox\"", "ip=\"127.0.0.1\"").replace("extradata=\"0\"", "extradata=\"3\""), on)
+ assertTrue(TelemetryOutput.pointsHere(TelemetryOutput.element(on)!!.value))
+ assertFalse(TelemetryOutput.pointsHere(TelemetryOutput.element(showdown)!!.value))
+ }
+
+ @Test fun theUdpLineWinsOverTheMotionLineAndLongerTagsAreIgnored() {
+ val xml = "" +
+ "" +
+ ""
+ assertTrue(TelemetryOutput.element(xml)!!.value.startsWith(""))
+ assertTrue(on.contains(""))
+ assertNull(TelemetryOutput.element(""))
+ }
+
+ @Test fun turningOffPutsTheOriginalLineBackOrSwitchesItOff() {
+ val on = TelemetryOutput.turnedOn(showdown)!!
+ assertEquals(showdown, TelemetryOutput.turnedOff(on, showdown))
+ assertTrue(TelemetryOutput.turnedOff(on, null)!!.contains("", TelemetryOutput.withAttr("", "ip", "127.0.0.1"))
+ assertEquals("", TelemetryOutput.withAttr("", "port", "20777"))
+ assertTrue(TelemetryOutput.pointsHere(""))
+ }
+
+ @Test fun scanFindsTheGameAndARoundTripRestoresTheFile() {
+ val compatdata = tmp.newFolder("steamapps", "compatdata")
+ val config = configFile(compatdata, "2848447563", "DiRT Showdown")
+ config.writeText(showdown)
+ configFile(compatdata, "12345", "Some Other Game").writeText("")
+
+ val games = TelemetryOutput.scan(listOf(compatdata))
+ assertEquals(listOf("DiRT Showdown"), games.map { it.name })
+ assertEquals("2848447563", games[0].prefixId)
+ assertFalse(games[0].on)
+
+ assertTrue(TelemetryOutput.set(games[0], true))
+ assertTrue(File(config.path + TelemetryOutput.ORIGINAL_SUFFIX).isFile)
+ assertTrue(TelemetryOutput.scan(listOf(compatdata))[0].on)
+
+ assertTrue(TelemetryOutput.set(games[0], false))
+ assertEquals(showdown, config.readText())
+ assertFalse(File(config.path + TelemetryOutput.ORIGINAL_SUFFIX).exists())
+ assertFalse(TelemetryOutput.scan(listOf(compatdata))[0].on)
+ }
+
+ @Test fun theRunningGameIsMatchedByItsPrefixId() {
+ assertTrue(TelemetryOutput.isRunning("2848447563", "2848447563"))
+ assertTrue(TelemetryOutput.isRunning("-1446519733", "2848447563"))
+ assertFalse(TelemetryOutput.isRunning("2848447563", "690790"))
+ assertFalse(TelemetryOutput.isRunning("2848447563", null))
+ assertTrue(TelemetryOutput.isRunning("2848447563", "program:/games/x.exe"))
+ }
+
+ @Test fun automaticSkipsGamesThatAreOnSwitchedOffOrRunning() {
+ val f = File("x")
+ val dirt4 = TelemetryOutput.Game("DiRT 4", "421020", f, on = false)
+ val rally = TelemetryOutput.Game("DiRT Rally 2.0", "690790", f, on = false)
+ val grid = TelemetryOutput.Game("GRID", "703860", f, on = true)
+ val games = listOf(dirt4, rally, grid)
+ assertEquals(listOf(dirt4, rally), TelemetryOutput.automaticTargets(games, emptySet(), null))
+ assertEquals(listOf(rally), TelemetryOutput.automaticTargets(games, setOf("421020/DiRT 4"), null))
+ assertEquals(listOf(dirt4), TelemetryOutput.automaticTargets(games, emptySet(), "690790"))
+ assertEquals("690790/DiRT Rally 2.0", TelemetryOutput.key(rally))
+ }
+
+ @Test fun switchingAutomaticOffRestoresOnlyGamesDroidDeckChanged() {
+ val compatdata = tmp.newFolder("steamapps", "compatdata")
+ val changed = configFile(compatdata, "2848447563", "DiRT Showdown").apply { writeText(showdown) }
+ val own = configFile(compatdata, "690790", "DiRT Rally 2.0")
+ .apply { writeText("") }
+ assertTrue(TelemetryOutput.set(TelemetryOutput.scan(listOf(compatdata)).first { it.name == "DiRT Showdown" }, true))
+ val targets = TelemetryOutput.restoreTargets(TelemetryOutput.scan(listOf(compatdata)), null)
+ assertEquals(listOf(changed), targets.map { it.file })
+ assertTrue(own.isFile)
+ assertTrue(TelemetryOutput.restoreTargets(TelemetryOutput.scan(listOf(compatdata)), "2848447563").isEmpty())
+ }
+
+ @Test fun automaticTurnsOnDirt3AndShowdownLikeTheOtherGames() {
+ val f = File("x")
+ val showdownGame = TelemetryOutput.Game("DiRT Showdown", "2848447563", f, on = false)
+ val dirt3 = TelemetryOutput.Game("DiRT3", "321040", f, on = false)
+ val rally = TelemetryOutput.Game("DiRT Rally 2.0", "690790", f, on = false)
+ assertEquals(listOf(showdownGame, dirt3, rally), TelemetryOutput.automaticTargets(listOf(showdownGame, dirt3, rally), emptySet(), null))
+ assertEquals(listOf(rally), TelemetryOutput.automaticTargets(listOf(showdownGame, dirt3, rally), setOf("2848447563/DiRT Showdown", "321040/DiRT3"), null))
+ }
+
+ private fun configFile(compatdata: File, id: String, game: String): File =
+ File(compatdata, "$id/pfx/drive_c/users/steamuser/Documents/My Games/$game/hardwaresettings/hardware_settings_config.xml")
+ .apply { parentFile!!.mkdirs() }
+}
diff --git a/app/src/test/java/com/droiddeck/launcher/ui/BottomChatPageTest.kt b/app/src/test/java/com/droiddeck/launcher/ui/BottomChatPageTest.kt
new file mode 100644
index 0000000000..34df15ff0a
--- /dev/null
+++ b/app/src/test/java/com/droiddeck/launcher/ui/BottomChatPageTest.kt
@@ -0,0 +1,42 @@
+package com.droiddeck.launcher.ui
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class BottomChatPageTest {
+ @Test fun steamSitesOpenOthersDoNot() {
+ assertTrue(steamChatAllows("steamcommunity.com"))
+ assertTrue(steamChatAllows("login.steampowered.com"))
+ assertTrue(steamChatAllows("steam-chat.com"))
+ assertTrue(steamChatAllows("community.cloudflare.steamstatic.com"))
+ assertFalse(steamChatAllows("steamcommunity.com.example.net"))
+ assertFalse(steamChatAllows("evilsteamcommunity.com"))
+ assertFalse(steamChatAllows(null))
+ }
+
+ @Test fun chatFitScriptUsesADotDecimalInEveryLocale() {
+ val before = java.util.Locale.getDefault()
+ try {
+ java.util.Locale.setDefault(java.util.Locale.GERMANY)
+ val js = steamChatFitScript(821, 0.75f)
+ assertTrue(js.contains("m.content='width=821, initial-scale=0.75'"))
+ assertTrue(js.contains("s.textContent='$STEAM_CHAT_FIT_CSS'"))
+ assertFalse(STEAM_CHAT_FIT_CSS.contains('\''))
+ } finally {
+ java.util.Locale.setDefault(before)
+ }
+ }
+
+ @Test fun theGroupChatListLeavesRoomForTheOnlineFriends() {
+ assertTrue(STEAM_CHAT_FIT_CSS.contains(".ChatRoomList_Empty{display:none!important}"))
+ assertTrue(STEAM_CHAT_FIT_CSS.contains(".chatRoomListContainer{height:auto!important;max-height:25vh!important}"))
+ assertTrue(STEAM_CHAT_FIT_CSS.contains(".chat_main>:has(~.chat_main_flex){display:none!important}"))
+ }
+
+ @Test fun desktopAgentKeepsTheWebViewChromeVersion() {
+ val ua = desktopUserAgent("Mozilla/5.0 (Linux; Android 15; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/141.0.7390.122 Mobile Safari/537.36")
+ assertEquals("Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.7390.122 Safari/537.36", ua)
+ }
+}
diff --git a/app/src/test/java/com/droiddeck/launcher/ui/BottomDashboardTest.kt b/app/src/test/java/com/droiddeck/launcher/ui/BottomDashboardTest.kt
new file mode 100644
index 0000000000..5a51418898
--- /dev/null
+++ b/app/src/test/java/com/droiddeck/launcher/ui/BottomDashboardTest.kt
@@ -0,0 +1,71 @@
+package com.droiddeck.launcher.ui
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class BottomDashboardTest {
+ @Test fun theRememberedPageOpensAgain() {
+ assertEquals("shots", pickBottomPage("shots", listOf("downloads", "shots")))
+ }
+
+ @Test fun aGoneOrMissingPageFallsBackToTheFirst() {
+ assertEquals("downloads", pickBottomPage("gone", listOf("downloads", "shots")))
+ assertEquals("downloads", pickBottomPage(null, listOf("downloads", "shots")))
+ assertNull(pickBottomPage("shots", emptyList()))
+ }
+
+ @Test fun withNothingPickedTheChatOpens() {
+ val ids = listOf("telemetry", "downloads", "notifications", "screenshots", "chat")
+ assertEquals("chat", pickBottomPage(null, ids))
+ assertEquals("chat", pickBottomPage("gone", ids))
+ assertEquals("telemetry", pickBottomPage("telemetry", ids))
+ assertEquals("screenshots", pickBottomPage("screenshots", ids))
+ }
+
+ @Test fun aGameStartShowsTheInGameStats() {
+ assertEquals("telemetry", pageForGameStart(listOf("telemetry", "downloads", "chat")))
+ assertNull(pageForGameStart(listOf("downloads", "chat")))
+ }
+
+ @Test fun tabNamesShowOnlyWhileEveryTabFits() {
+ // Retroid Pocket Duo bottom panel: 1280x960 at 320 dpi = 640 dp wide.
+ assertTrue(bottomTabsWithLabels(640f, 4))
+ assertFalse(bottomTabsWithLabels(640f, 5))
+ assertFalse(bottomTabsWithLabels(360f, 3))
+ }
+}
+
+class BottomDownloadsRateTest {
+ @Test fun rateIsBytesPerSecondBetweenReads() {
+ assertEquals(1_000_000L, downloadRate(0L, 0L, 2_000_000L, 2_000L))
+ }
+
+ @Test fun noMovementOrARestartIsZero() {
+ assertEquals(0L, downloadRate(500L, 0L, 500L, 2_000L))
+ assertEquals(0L, downloadRate(500L, 0L, 100L, 2_000L))
+ assertEquals(0L, downloadRate(-1L, 0L, 100L, 2_000L))
+ }
+}
+
+class BottomTelemetryLapTimeTest {
+ @Test fun lapTimesReadAsMinutesSecondsMillis() {
+ assertEquals("1:23.456", lapTime(83.456f))
+ assertEquals("0:05.000", lapTime(5f))
+ }
+
+ @Test fun eachSessionStartsWithoutAPickedTab() {
+ SessionBottomTab.pick("2026-11-01-01-steam", "screenshots")
+ assertEquals("screenshots", SessionBottomTab.picked("2026-11-01-01-steam"))
+ assertNull(SessionBottomTab.picked("2026-11-01-02-steam"))
+ assertNull(SessionBottomTab.picked(null))
+ assertEquals("chat", pickBottomPage(SessionBottomTab.picked("2026-11-01-02-steam"), listOf("telemetry", "chat", "screenshots")))
+ }
+
+ @Test fun theStripNamesTheSteamClient() {
+ assertEquals(com.droiddeck.launcher.R.string.stats_steam_client_x86, steamClientLabel("x86_64"))
+ assertEquals(com.droiddeck.launcher.R.string.stats_steam_client_arm, steamClientLabel("arm64"))
+ }
+}
diff --git a/tools/components/recipes.json b/tools/components/recipes.json
index 602fb379ec..0dfb8e4264 100644
--- a/tools/components/recipes.json
+++ b/tools/components/recipes.json
@@ -222,5 +222,20 @@
"cmake",
"xz-utils"
]
+ },
+ "dirt-ws2": {
+ "script": "tools/components/recipes/dirt-ws2.sh",
+ "inputs": [
+ "tools/dirt-ws2",
+ "tools/components/recipes/dirt-ws2.sh"
+ ],
+ "outputs": [
+ "app/src/main/assets/linuxfs/usr/local/lib/droiddeck-dirt/ws2_32.dll"
+ ],
+ "packages": [
+ "clang",
+ "lld",
+ "llvm"
+ ]
}
}
diff --git a/tools/components/recipes/dirt-ws2.sh b/tools/components/recipes/dirt-ws2.sh
new file mode 100644
index 0000000000..77a4070884
--- /dev/null
+++ b/tools/components/recipes/dirt-ws2.sh
@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+set -euo pipefail
+bash tools/dirt-ws2/build.sh app/src/main/assets/linuxfs/usr/local/lib/droiddeck-dirt
diff --git a/tools/dirt-ws2/README.md b/tools/dirt-ws2/README.md
new file mode 100644
index 0000000000..14f02478f1
--- /dev/null
+++ b/tools/dirt-ws2/README.md
@@ -0,0 +1,19 @@
+# DiRT 3 / DiRT Showdown ws2_32 stand-in
+
+DiRT 3 (`dirt3_game.exe`) and DiRT Showdown (`showdown.exe`, `showdown_avx.exe`) close their motion telemetry UDP
+socket at the end of a race, and when leaving Joyride, but keep calling `sendto()` on it. `sendto()` fails with
+WSAENOTSOCK and the game stops with "sendto failed with error 10038". The same happens on Windows.
+
+`ws2_32.dll` here is a 32-bit stand-in: every export jumps to the same-ordinal export of Wine's own `ws2_32.dll`;
+only a `sendto()` that fails with 10038 reports 0 bytes sent instead. Same behaviour as
+[DiRTTelemetryErrorFix](https://github.com/RoccoC/DiRTTelemetryErrorFix) by RoccoC (MIT), based on the original fix
+by Carsten Gottschling.
+
+Wine loads `ws2_32` as a KnownDLL, so a copy beside the game is ignored. `droiddeck-game-env` puts the stand-in in
+place of the prefix's `syswow64/ws2_32.dll` for these games while their telemetry output is on, adds
+`WINEDLLOVERRIDES=ws2_32=n,b`, and puts Wine's file back when the game exits. It skips the swap when the game's
+Proton already has the fix in its own `ws2_32.dll` (DroidDeck-Proton patch
+`dirt-telemetry-sendto-closed-socket.patch`).
+
+`build.sh OUT` builds it with clang, lld and llvm-dlltool and checks its exports against `ws2_32-exports.txt`
+(taken from Wine 11's `ws2_32.dll`).
diff --git a/tools/dirt-ws2/build.sh b/tools/dirt-ws2/build.sh
new file mode 100755
index 0000000000..3abe6d16cb
--- /dev/null
+++ b/tools/dirt-ws2/build.sh
@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+# Builds the 32-bit ws2_32.dll stand-in for DiRT 3 and DiRT Showdown into the given folder.
+set -euo pipefail
+here=$(cd "$(dirname "$0")" && pwd)
+mkdir -p "$1"
+out=$(cd "$1" && pwd)
+work=$(mktemp -d)
+trap 'rm -rf "$work"' EXIT
+
+tool() {
+ local found
+ found=$(command -v "$1" || ls /usr/lib/llvm-*/bin/"$1" 2>/dev/null | sort -V | tail -n1 || true)
+ [ -n "$found" ] || { echo "dirt-ws2: $1 not found" >&2; exit 1; }
+ echo "$found"
+}
+clang=$(tool clang)
+dlltool=$(tool llvm-dlltool)
+tool ld.lld > /dev/null
+
+python3 "$here/gen.py" generate "$here" "$work"
+"$dlltool" -m i386 -k -d "$here/kernel32.def" -l "$work/libkernel32.a"
+"$clang" --target=i686-w64-mingw32 -O2 -Wall -Wextra -Werror -ffreestanding -fno-stack-protector -fno-builtin \
+ -nostdlib -shared -fuse-ld=lld -o "$work/ws2_32.dll" "$here/ws2_32.c" "$work/thunks.c" "$work/ws2_32.def" \
+ -L"$work" -lkernel32 -Wl,--entry,DllMain@12 -Wl,--no-insert-timestamp
+python3 "$here/gen.py" verify "$here" "$work/ws2_32.dll"
+install -m 644 "$work/ws2_32.dll" "$out/ws2_32.dll"
diff --git a/tools/dirt-ws2/gen.py b/tools/dirt-ws2/gen.py
new file mode 100644
index 0000000000..3d2532b0e6
--- /dev/null
+++ b/tools/dirt-ws2/gen.py
@@ -0,0 +1,74 @@
+"""ws2_32 stand-in helpers.
+
+gen.py generate SRC OUT writes OUT/thunks.c (one jump per export) and OUT/ws2_32.def from SRC/ws2_32-exports.txt.
+gen.py verify SRC DLL checks that DLL exports exactly the ordinals and names in SRC/ws2_32-exports.txt.
+"""
+import struct
+import sys
+from pathlib import Path
+
+
+def exports_list(src):
+ rows = []
+ for line in (Path(src) / 'ws2_32-exports.txt').read_text().splitlines():
+ ordinal, name = line.split()
+ rows.append((int(ordinal), name))
+ return rows
+
+
+def generate(src, out):
+ rows = exports_list(src)
+ passed = [(o, n) for o, n in rows if n != 'sendto']
+ c = ['/* Generated by tools/dirt-ws2/gen.py. */',
+ 'const unsigned short dirtfix_ordinals[%d] = {%s};' % (len(passed), ', '.join(str(o) for o, _ in passed)),
+ 'const unsigned int dirtfix_count = %d;' % len(passed),
+ 'void *dirtfix_real[%d];' % len(passed),
+ '__asm__(".text\\n"']
+ for i, (o, _) in enumerate(passed):
+ c.append(' ".globl _dirtfix_t%d\\n_dirtfix_t%d:\\n\\tjmp *_dirtfix_real+%d\\n"' % (o, o, 4 * i))
+ c.append(');')
+ (Path(out) / 'thunks.c').write_text('\n'.join(c) + '\n')
+ d = ['LIBRARY ws2_32.dll', 'EXPORTS']
+ d += [' %s=%s @%d' % (n, 'dirtfix_sendto@24' if n == 'sendto' else 'dirtfix_t%d' % o, o) for o, n in rows]
+ (Path(out) / 'ws2_32.def').write_text('\n'.join(d) + '\n')
+
+
+def pe_exports(path):
+ data = Path(path).read_bytes()
+ pe = struct.unpack_from('= 500) continue;
+ if (path[0] == '\\' && path[1] == '?' && path[2] == '?' && path[3] == '\\') path[1] = '\\';
+ append(path, "\\i386-windows\\ws2_32.dll");
+ if (GetFileAttributesW(path) == (DWORD)-1) continue;
+ if ((real = LoadLibraryW(path)) && real != self) return real;
+ }
+ n = GetSystemDirectoryW(path, 280);
+ if (!n || n >= 280) return 0;
+ path[n] = 0;
+ append(path, "\\ws2_32.dll");
+ real = LoadLibraryW(path);
+ return real != self ? real : 0;
+}
+
+BOOL WINAPI DllMain(HMODULE self, DWORD reason, void *reserved)
+{
+ HMODULE real;
+ UINT i;
+
+ (void)reserved;
+ if (reason != 1) return 1;
+ if (!(real = load_wine_ws2_32(self))) return 0;
+ for (i = 0; i < dirtfix_count; i++) dirtfix_real[i] = GetProcAddress(real, ORDINAL(dirtfix_ordinals[i]));
+ real_sendto = GetProcAddress(real, ORDINAL(20));
+ real_WSAGetLastError = GetProcAddress(real, ORDINAL(111));
+ real_WSASetLastError = GetProcAddress(real, ORDINAL(112));
+ return real_sendto && real_WSAGetLastError && real_WSASetLastError;
+}
diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-game-env b/tools/linuxfs/overlay/usr/local/bin/droiddeck-game-env
index 72d8f98615..410e8bf5cc 100755
--- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-game-env
+++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-game-env
@@ -4,6 +4,7 @@ import json
import os
import re
import runpy
+import signal
import subprocess
import sys
import tempfile
@@ -735,7 +736,147 @@ def directaudio_settings(env):
return env
-def start(launch, launch_env, digest):
+DIRT_GAMES = {"dirt3_game": "dirt3", "showdown": "dirtshowdown", "showdown_avx": "dirtshowdown"}
+DIRT_WS2 = "/usr/local/lib/droiddeck-dirt/ws2_32.dll"
+DIRT_MARKER = b"droiddeck-dirt-ws2_32"
+DIRT_FIXED = "showdown_avx.exe".encode("utf-16-le")
+DIRT_SAVED = ".droiddeck-original"
+
+
+def dirt_telemetry_on(prefix, game):
+ """Whether the game's UDP/motion output is on, as In-game stats or another listener sets it ("dbox" is its default)."""
+ try:
+ folders = [f for f in (Path(prefix) / "pfx/drive_c/users/steamuser/Documents/My Games").iterdir()
+ if f.name.lower().replace(" ", "") == game]
+ except OSError:
+ return False
+ for folder in folders:
+ try:
+ text = (folder / "hardwaresettings/hardware_settings_config.xml").read_text(encoding="latin-1")
+ except OSError:
+ continue
+ for tag in ("udp", "motion"):
+ element = re.search(r"<%s\s[^>]*>" % tag, text)
+ if element:
+ attrs = dict(re.findall(r'\s(\w+)="([^"]*)"', element.group(0)))
+ return attrs.get("enabled") == "true" and attrs.get("ip", "").lower() not in ("", "dbox")
+ return False
+
+
+def proton_ws2(proton):
+ return Path(proton).parent / "files/lib/wine/i386-windows/ws2_32.dll"
+
+
+def proton_has_dirt_fix(proton):
+ try:
+ return DIRT_FIXED in proton_ws2(proton).read_bytes()
+ except OSError:
+ return False
+
+
+WINE_DLL_DIRS = ("/lib/wine/i386-windows", "/lib/wine/x86_64-windows", "/lib/wine/aarch64-windows", "/lib/wine",
+ "/lib/wine/fakedlls", "/lib64/wine", "/lib64/wine/fakedlls", "/lib64/wine/x86_64-windows")
+
+
+def is_wine_dll_link(path):
+ """A link into a Wine DLL folder: the rule Proton uses to tell its own DLLs in a prefix (file_is_wine_builtin_dll)."""
+ try:
+ return os.path.islink(path) and os.path.dirname(os.readlink(path)).endswith(WINE_DLL_DIRS)
+ except OSError:
+ return False
+
+
+def prefix_ws2(prefix):
+ return Path(prefix) / "pfx/drive_c/windows/syswow64/ws2_32.dll"
+
+
+def is_dirt_stand_in(path):
+ try:
+ return not path.is_symlink() and DIRT_MARKER in path.read_bytes()
+ except OSError:
+ return False
+
+
+def dirt_ws2_wanted(command, env):
+ """The prefix to give the ws2_32 stand-in: a DiRT 3 / Showdown launch with telemetry on and a Proton without the fix."""
+ prefix = env.get("STEAM_COMPAT_DATA_PATH", "").rstrip("/")
+ if len(command) < 3 or not prefix or not os.path.isfile(DIRT_WS2):
+ return None
+ game = DIRT_GAMES.get(os.path.splitext(os.path.basename(command[2]))[0].lower())
+ if not game or not dirt_telemetry_on(prefix, game) or proton_has_dirt_fix(command[0]):
+ return None
+ return prefix if os.path.lexists(prefix_ws2(prefix)) else None
+
+
+def swap_dirt_ws2(prefix):
+ """Puts the stand-in where the prefix's syswow64/ws2_32.dll is; that file is kept beside it."""
+ target = prefix_ws2(prefix)
+ saved = target.with_name(target.name + DIRT_SAVED)
+ data = Path(DIRT_WS2).read_bytes()
+ if not is_dirt_stand_in(target):
+ if os.path.lexists(saved):
+ os.unlink(saved)
+ os.replace(target, saved)
+ staged = target.with_name(target.name + ".droiddeck-tmp")
+ staged.write_bytes(data)
+ os.replace(staged, target)
+
+
+def restore_dirt_ws2(prefix, proton):
+ """Puts a Wine syswow64/ws2_32.dll back if the stand-in is still there; true when it changed something.
+
+ That is the prefix's own one, unless it was a link to a Wine DLL folder and the game ran on another Proton since
+ the swap: Proton then relinked the prefix's other DLLs to itself but left the stand-in, so a link to the running
+ Proton's ws2_32.dll goes back instead. Anything else (a native file, a link to a mod's DLL) goes back as it was."""
+ target = prefix_ws2(prefix)
+ saved = target.with_name(target.name + DIRT_SAVED)
+ own = proton_ws2(proton)
+ had_saved = os.path.lexists(saved)
+ if had_saved:
+ if os.path.lexists(target) and not is_dirt_stand_in(target):
+ os.unlink(saved)
+ return False
+ if not own.is_file() or not is_wine_dll_link(saved) or os.path.realpath(saved) == os.path.realpath(own):
+ os.replace(saved, target)
+ return True
+ os.unlink(saved)
+ if own.is_file() and (is_dirt_stand_in(target) or (had_saved and not os.path.lexists(target))):
+ link = target.with_name(target.name + ".droiddeck-tmp")
+ if os.path.lexists(link):
+ os.unlink(link)
+ os.symlink(own, link)
+ os.replace(link, target)
+ return True
+ return False
+
+
+def wait_forwarding_signals(process):
+ def forward(signum, frame):
+ try:
+ process.send_signal(signum)
+ except OSError:
+ pass
+
+ previous = {signum: signal.signal(signum, forward) for signum in (signal.SIGTERM, signal.SIGINT, signal.SIGHUP)}
+ try:
+ code = process.wait()
+ finally:
+ for signum, handler in previous.items():
+ signal.signal(signum, handler)
+ return 128 - code if code < 0 else code
+
+
+def start(launch, launch_env, digest, after=None):
+ if after:
+ process = subprocess.Popen(launch, env=launch_env)
+ try:
+ return wait_forwarding_signals(process)
+ finally:
+ try:
+ after()
+ except OSError as error:
+ print("droiddeck-game-env: DiRT telemetry fix: prefix ws2_32 not put back (%s); the next launch does it" % error,
+ file=sys.stderr)
if digest:
code = subprocess.run(launch, env=launch_env, check=False).returncode
if code == 0:
@@ -760,6 +901,7 @@ def main():
except OSError:
digest = None
app_id = game_id(env)
+ dirt_prefix = None
if app_id:
gl_default = gl_vsync(env)
waiting = len(command) > 1 and command[1] == "waitforexitandrun"
@@ -779,6 +921,10 @@ def main():
if components:
own = fixes.get("WINEDLLOVERRIDES")
fixes["WINEDLLOVERRIDES"] = components + ";" + own if own else components
+ dirt_prefix = dirt_ws2_wanted(command, env)
+ if dirt_prefix:
+ own = fixes.get("WINEDLLOVERRIDES")
+ fixes["WINEDLLOVERRIDES"] = own + ";ws2_32=n,b" if own else "ws2_32=n,b"
path = Path.home() / ".config/droiddeck/game-environment.json"
config = {}
try:
@@ -823,16 +969,45 @@ def main():
return 1
if xbox_result is not None:
return xbox_result
+ after = None
+ prefix = env.get("STEAM_COMPAT_DATA_PATH", "").rstrip("/")
+ if app_id and prefix and len(command) > 1 and command[1] == "waitforexitandrun":
+ try:
+ if dirt_prefix:
+ after = lambda: restore_dirt_ws2(dirt_prefix, command[0])
+ swap_dirt_ws2(dirt_prefix)
+ print("droiddeck-game-env: DiRT telemetry fix: ws2_32 stand-in in the prefix until the game exits",
+ file=sys.stderr)
+ elif restore_dirt_ws2(prefix, command[0]):
+ print("droiddeck-game-env: DiRT telemetry fix: put the prefix's own ws2_32 back", file=sys.stderr)
+ except OSError as error:
+ print("droiddeck-game-env: DiRT telemetry fix not applied (%s)" % error, file=sys.stderr)
+ if after:
+ after = None
+ try:
+ restore_dirt_ws2(dirt_prefix, command[0])
+ except OSError as undo:
+ print("droiddeck-game-env: DiRT telemetry fix: prefix ws2_32 not put back (%s); Wine uses its own copy "
+ "and the next launch puts the file back" % undo, file=sys.stderr)
sync = load_sync()
launch, launch_env = select_sync(command, env, sync)
if launch[0] != command[0]:
try:
- return start(launch, launch_env, digest)
+ return start(launch, launch_env, digest, after)
except OSError as error:
print("droiddeck-game-env: %s could not start (%s); stock launch" % (launch[0], error), file=sys.stderr)
launch, launch_env = command, without_pack(launch_env, env)
record_stock(sync, launch, launch_env)
- return start(launch, launch_env, digest)
+ try:
+ return start(launch, launch_env, digest, after)
+ except OSError:
+ if after:
+ try:
+ after()
+ except OSError as error:
+ print("droiddeck-game-env: DiRT telemetry fix: prefix ws2_32 not put back (%s); the next launch does it" % error,
+ file=sys.stderr)
+ raise
if __name__ == "__main__":
diff --git a/tools/release/runtime_inputs.py b/tools/release/runtime_inputs.py
index 6eff505e85..a375bbed55 100644
--- a/tools/release/runtime_inputs.py
+++ b/tools/release/runtime_inputs.py
@@ -23,7 +23,7 @@ PACK_NAMES = ['proot', 'directaudio', 'tracking', 'xbox', 'comet', 'butler']
SOURCE_PATHS = ['app/build.gradle', 'app/src/main/cpp/fakeinput_steam.cpp', 'app/src/main/assets/pulseaudio.tzst',
'tools/linuxfs', 'tools/proot', 'tools/aaudio-sink', 'tools/directaudio', 'tools/packs',
'tools/gamescope/release.env', 'tools/droiddeck-esync/release.env',
- 'tools/mangoapp', 'tools/msitools', 'tools/pipewire', 'tools/comet', 'tools/xbox', 'tools/components', 'tools/ci', 'tools/build_local.sh',
+ 'tools/mangoapp', 'tools/msitools', 'tools/pipewire', 'tools/comet', 'tools/xbox', 'tools/dirt-ws2', 'tools/components', 'tools/ci', 'tools/build_local.sh',
'tools/release/runtime_inputs.py', 'app/src/main/assets/desktop-removal',
'tools/quest', 'tools/vr/src', 'tools/vr/driver_droiddeck', 'tools/vr/layer', 'tools/vr/build.sh',
'app/src/main/cpp/waylandcomp/src/headpose_shm.h',
diff --git a/tools/tests/test_game_environment.py b/tools/tests/test_game_environment.py
index d9d2c30637..fc44cc50b1 100644
--- a/tools/tests/test_game_environment.py
+++ b/tools/tests/test_game_environment.py
@@ -29,6 +29,222 @@ def config_text(entries):
return '"InstallConfigStore" { "Software" { "Valve" { "Steam" { "CompatToolMapping" { %s } } } } }' % mapping
+class DirtTelemetryFixTest(unittest.TestCase):
+ SHOWDOWN_ON = ''
+ SHOWDOWN_DEFAULT = ''
+
+ def setUp(self):
+ self.tmp = tempfile.TemporaryDirectory()
+ root = Path(self.tmp.name)
+ self.prefix = root / "compatdata/2848447563"
+ self.proton = root / "Proton/proton"
+ self.own = root / "Proton/files/lib/wine/i386-windows/ws2_32.dll"
+ self.own.parent.mkdir(parents=True)
+ self.own.write_bytes(b"MZ wine ws2_32")
+ self.proton.write_text("")
+ self.target = self.prefix / "pfx/drive_c/windows/syswow64/ws2_32.dll"
+ self.target.parent.mkdir(parents=True)
+ self.target.symlink_to(self.own)
+ self.stand_in = root / "droiddeck-dirt/ws2_32.dll"
+ self.stand_in.parent.mkdir()
+ self.stand_in.write_bytes(b"MZ droiddeck-dirt-ws2_32 stand-in")
+ self.patch = mock.patch.dict(MODULE["dirt_ws2_wanted"].__globals__, {"DIRT_WS2": str(self.stand_in)})
+ self.patch.start()
+
+ def tearDown(self):
+ self.patch.stop()
+ self.tmp.cleanup()
+
+ def config(self, folder, text):
+ path = self.prefix / "pfx/drive_c/users/steamuser/Documents/My Games" / folder / "hardwaresettings/hardware_settings_config.xml"
+ path.parent.mkdir(parents=True, exist_ok=True)
+ path.write_text(text)
+
+ def command(self, exe="showdown.exe"):
+ return [str(self.proton), "waitforexitandrun", "/root/Storage/games/DiRT Showdown/" + exe]
+
+ def env(self):
+ return {"STEAM_COMPAT_DATA_PATH": str(self.prefix)}
+
+ def test_telemetry_counts_as_on_when_the_game_sends_somewhere(self):
+ self.config("DiRT Showdown", self.SHOWDOWN_DEFAULT)
+ self.assertFalse(MODULE["dirt_telemetry_on"](self.prefix, "dirtshowdown"))
+ self.config("DiRT Showdown", self.SHOWDOWN_ON)
+ self.assertTrue(MODULE["dirt_telemetry_on"](self.prefix, "dirtshowdown"))
+ self.config("DiRT Showdown", self.SHOWDOWN_ON.replace('enabled="true"', 'enabled="false"'))
+ self.assertFalse(MODULE["dirt_telemetry_on"](self.prefix, "dirtshowdown"))
+ self.config("DiRT3", '')
+ self.assertTrue(MODULE["dirt_telemetry_on"](self.prefix, "dirt3"))
+
+ def test_stand_in_is_wanted_only_for_the_dirt_games_with_telemetry_on_and_a_proton_without_the_fix(self):
+ wanted = MODULE["dirt_ws2_wanted"]
+ self.config("DiRT Showdown", self.SHOWDOWN_DEFAULT)
+ self.assertIsNone(wanted(self.command(), self.env()))
+ self.config("DiRT Showdown", self.SHOWDOWN_ON)
+ self.assertEqual(wanted(self.command(), self.env()), str(self.prefix))
+ self.assertEqual(wanted(self.command("Showdown_AVX.exe"), self.env()), str(self.prefix))
+ self.assertIsNone(wanted(self.command("DiRTRally2.exe"), self.env()))
+ self.own.write_bytes(b"MZ wine ws2_32 " + "showdown_avx.exe".encode("utf-16-le"))
+ self.assertIsNone(wanted(self.command(), self.env()))
+
+ def test_swap_keeps_the_prefix_link_and_restore_puts_it_back(self):
+ MODULE["swap_dirt_ws2"](self.prefix)
+ saved = self.target.with_name("ws2_32.dll.droiddeck-original")
+ self.assertFalse(self.target.is_symlink())
+ self.assertEqual(self.target.read_bytes(), self.stand_in.read_bytes())
+ self.assertEqual(os.readlink(saved), str(self.own))
+ self.assertEqual(self.own.read_bytes(), b"MZ wine ws2_32")
+ MODULE["swap_dirt_ws2"](self.prefix)
+ self.assertEqual(os.readlink(saved), str(self.own))
+ self.assertTrue(MODULE["restore_dirt_ws2"](self.prefix, self.proton))
+ self.assertEqual(os.readlink(self.target), str(self.own))
+ self.assertFalse(os.path.lexists(saved))
+ self.assertFalse(MODULE["restore_dirt_ws2"](self.prefix, self.proton))
+
+ def test_restore_keeps_a_file_proton_put_back_meanwhile(self):
+ MODULE["swap_dirt_ws2"](self.prefix)
+ newer = self.own.with_name("ws2_32-newer.dll")
+ newer.write_bytes(b"MZ newer wine ws2_32")
+ self.target.unlink()
+ self.target.symlink_to(newer)
+ self.assertFalse(MODULE["restore_dirt_ws2"](self.prefix, self.proton))
+ self.assertEqual(os.readlink(self.target), str(newer))
+ self.assertFalse(os.path.lexists(self.target.with_name("ws2_32.dll.droiddeck-original")))
+
+ def test_after_a_proton_switch_the_running_protons_file_goes_back(self):
+ MODULE["swap_dirt_ws2"](self.prefix)
+ other = Path(self.tmp.name) / "GE-Proton/proton"
+ other_own = other.parent / "files/lib/wine/i386-windows/ws2_32.dll"
+ other_own.parent.mkdir(parents=True)
+ other_own.write_bytes(b"MZ GE wine ws2_32")
+ other.write_text("")
+ self.assertTrue(MODULE["restore_dirt_ws2"](self.prefix, other))
+ self.assertEqual(os.readlink(self.target), str(other_own))
+ self.assertFalse(os.path.lexists(self.target.with_name("ws2_32.dll.droiddeck-original")))
+
+ def test_restore_follows_a_proton_reached_through_a_linked_folder(self):
+ MODULE["swap_dirt_ws2"](self.prefix)
+ pack = Path(self.tmp.name) / "pack"
+ (pack / "files/lib/wine").mkdir(parents=True)
+ (pack / "files/lib/wine/i386-windows").symlink_to(self.own.parent)
+ (pack / "proton").write_text("")
+ self.assertTrue(MODULE["restore_dirt_ws2"](self.prefix, pack / "proton"))
+ self.assertEqual(os.readlink(self.target), str(self.own))
+
+ def test_a_stand_in_left_without_the_saved_link_is_replaced_by_protons_own_file(self):
+ self.target.unlink()
+ self.target.write_bytes(self.stand_in.read_bytes())
+ self.assertTrue(MODULE["restore_dirt_ws2"](self.prefix, self.proton))
+ self.assertEqual(os.readlink(self.target), str(self.own))
+
+ def test_launch_swaps_the_stand_in_in_for_the_game_and_back_afterwards(self):
+ self.config("DiRT Showdown", self.SHOWDOWN_ON)
+ self.proton.write_text("#!" + sys.executable + "\nimport os, sys\n"
+ "target = os.path.join(os.environ['STEAM_COMPAT_DATA_PATH'], 'pfx/drive_c/windows/syswow64/ws2_32.dll')\n"
+ "print(os.environ.get('WINEDLLOVERRIDES', ''))\n"
+ "print(os.path.islink(target), b'droiddeck-dirt-ws2_32' in open(target, 'rb').read())\n")
+ self.proton.chmod(0o755)
+ runner = Path(self.tmp.name) / "run.py"
+ runner.write_text("import runpy, sys\nmain = runpy.run_path(sys.argv[1])['main']\nmain.__globals__['DIRT_WS2'] = sys.argv[2]\n"
+ "sys.argv = [sys.argv[1]] + sys.argv[3:]\nsys.exit(main())\n")
+ home = Path(self.tmp.name) / "home"
+ home.mkdir()
+ result = subprocess.run([sys.executable, str(runner), str(BIN / "droiddeck-game-env"), str(self.stand_in), *self.command()],
+ env={**os.environ, "HOME": str(home), "STEAM_COMPAT_DATA_PATH": str(self.prefix)}, text=True, capture_output=True)
+ self.assertEqual(result.returncode, 0, result.stderr)
+ overrides, state = result.stdout.splitlines()[-2:]
+ self.assertIn("ws2_32=n,b", overrides.split(";"))
+ self.assertEqual(state, "False True")
+ self.assertIn("DiRT telemetry fix: ws2_32 stand-in", result.stderr)
+ self.assertEqual(os.readlink(self.target), str(self.own))
+ self.assertFalse(os.path.lexists(self.target.with_name("ws2_32.dll.droiddeck-original")))
+
+ def test_a_proton_that_cannot_start_leaves_the_prefix_as_it_was(self):
+ self.config("DiRT Showdown", self.SHOWDOWN_ON)
+ self.proton.write_text("not a program")
+ self.proton.chmod(0o644)
+ runner = Path(self.tmp.name) / "run.py"
+ runner.write_text("import runpy, sys\nmain = runpy.run_path(sys.argv[1])['main']\nmain.__globals__['DIRT_WS2'] = sys.argv[2]\n"
+ "sys.argv = [sys.argv[1]] + sys.argv[3:]\nsys.exit(main())\n")
+ home = Path(self.tmp.name) / "home"
+ home.mkdir()
+ result = subprocess.run([sys.executable, str(runner), str(BIN / "droiddeck-game-env"), str(self.stand_in), *self.command()],
+ env={**os.environ, "HOME": str(home), "STEAM_COMPAT_DATA_PATH": str(self.prefix)}, text=True, capture_output=True)
+ self.assertNotEqual(result.returncode, 0)
+ self.assertIn("DiRT telemetry fix: ws2_32 stand-in", result.stderr)
+ self.assertEqual(os.readlink(self.target), str(self.own))
+ self.assertFalse(os.path.lexists(self.target.with_name("ws2_32.dll.droiddeck-original")))
+
+ def test_launch_with_telemetry_off_leaves_the_prefix_alone(self):
+ self.config("DiRT Showdown", self.SHOWDOWN_DEFAULT)
+ self.proton.write_text("#!" + sys.executable + "\nimport os\nprint(os.environ.get('WINEDLLOVERRIDES', ''))\n")
+ self.proton.chmod(0o755)
+ home = Path(self.tmp.name) / "home"
+ home.mkdir()
+ result = subprocess.run([sys.executable, str(BIN / "droiddeck-game-env"), *self.command()],
+ env={**os.environ, "HOME": str(home), "STEAM_COMPAT_DATA_PATH": str(self.prefix)}, text=True, capture_output=True)
+ self.assertEqual(result.returncode, 0, result.stderr)
+ self.assertNotIn("ws2_32=n,b", result.stdout)
+ self.assertEqual(os.readlink(self.target), str(self.own))
+
+ def test_a_failed_put_back_does_not_end_the_launch_with_an_error(self):
+ def fail():
+ raise OSError(28, "No space left on device")
+ stderr = io.StringIO()
+ with mock.patch("sys.stderr", stderr):
+ code = MODULE["start"]([sys.executable, "-c", "raise SystemExit(0)"], dict(os.environ), None, fail)
+ self.assertEqual(code, 0)
+ self.assertIn("not put back", stderr.getvalue())
+
+ def test_a_half_done_swap_is_put_back(self):
+ saved = self.target.with_name("ws2_32.dll.droiddeck-original")
+ os.replace(self.target, saved)
+ self.assertTrue(MODULE["restore_dirt_ws2"](self.prefix, self.proton))
+ self.assertEqual(os.readlink(self.target), str(self.own))
+ self.assertFalse(os.path.lexists(saved))
+
+ def test_a_native_ws2_32_goes_back_as_it_was_after_a_proton_switch(self):
+ self.target.unlink()
+ self.target.write_bytes(b"MZ a mod's own ws2_32")
+ MODULE["swap_dirt_ws2"](self.prefix)
+ other = Path(self.tmp.name) / "GE-Proton/proton"
+ (other.parent / "files/lib/wine/i386-windows").mkdir(parents=True)
+ (other.parent / "files/lib/wine/i386-windows/ws2_32.dll").write_bytes(b"MZ GE wine ws2_32")
+ other.write_text("")
+ self.assertTrue(MODULE["restore_dirt_ws2"](self.prefix, other))
+ self.assertFalse(self.target.is_symlink())
+ self.assertEqual(self.target.read_bytes(), b"MZ a mod's own ws2_32")
+
+ def test_a_link_to_a_mods_ws2_32_goes_back_as_it_was(self):
+ mod = Path(self.tmp.name) / "mods/ws2_32.dll"
+ mod.parent.mkdir()
+ mod.write_bytes(b"MZ a mod's ws2_32")
+ self.target.unlink()
+ self.target.symlink_to(mod)
+ MODULE["swap_dirt_ws2"](self.prefix)
+ other = Path(self.tmp.name) / "GE-Proton/proton"
+ (other.parent / "files/lib/wine/i386-windows").mkdir(parents=True)
+ (other.parent / "files/lib/wine/i386-windows/ws2_32.dll").write_bytes(b"MZ GE wine ws2_32")
+ other.write_text("")
+ self.assertTrue(MODULE["restore_dirt_ws2"](self.prefix, other))
+ self.assertEqual(os.readlink(self.target), str(mod))
+
+ def test_start_gives_the_signal_handlers_back(self):
+ import signal
+ before = {s: signal.getsignal(s) for s in (signal.SIGTERM, signal.SIGINT, signal.SIGHUP)}
+ MODULE["start"]([sys.executable, "-c", "pass"], dict(os.environ), None, lambda: None)
+ self.assertEqual(before, {s: signal.getsignal(s) for s in before})
+
+ def test_start_puts_the_file_back_after_the_game_exits(self):
+ calls = []
+ code = MODULE["start"]([sys.executable, "-c", "raise SystemExit(3)"], dict(os.environ), None, lambda: calls.append("restored"))
+ self.assertEqual(code, 3)
+ self.assertEqual(calls, ["restored"])
+ with self.assertRaises(OSError):
+ MODULE["start"]([str(Path(self.tmp.name) / "missing")], dict(os.environ), None, lambda: calls.append("again"))
+ self.assertEqual(calls, ["restored"])
+
+
class GameDebugLoggingTest(unittest.TestCase):
def test_maintenance_precision_survives_run_with_performance_game_settings(self):
with tempfile.TemporaryDirectory() as tmp: