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" + + @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: