feat(dual-screen): Telemetry page on the bottom screen

DroidDeck's own numbers (FPS while the HUD runs, CPU, GPU, battery, from
the HUD's sources) plus a live dash for racing games that send UDP
telemetry to 127.0.0.1: Codemasters "extradata 3" (DiRT Rally, DiRT 4,
GRID) on 20777, Forza Data Out (Motorsport 7/2023, Horizon 4/5) on 5300,
OutGauge (BeamNG.drive, Live for Speed) on 4444. War Thunder's local
state page and Elite Dangerous' Status.json show without setup. The
listeners and readers run only while the page is shown.
This commit is contained in:
The412Banner committed 2026-10-31 19:49:41 +00:00
1 parent 125e39ea9c
commit 60184418ba
8 files changed
+623 -1

No files matched your search

@@ -3134,7 +3134,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback {
)
/** Pages for the bottom-screen dashboard; the dashboard is offered only while at least one exists. */
private fun bottomPages(): List<BottomPage> = sessionBottomPages(BottomPageActions(takeScreenshot = ::captureScreenshot))
private fun bottomPages(): List<BottomPage> = sessionBottomPages(BottomPageActions(takeScreenshot = ::captureScreenshot, fps = { if (::hud.isInitialized) hud.liveFps else null }))
/** Copies the game frame (no overlay) at the size it is shown and saves it to Pictures/DroidDeck. */
private fun captureScreenshot(onDone: (Boolean) -> Unit) {
@@ -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
@@ -0,0 +1,190 @@
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,
)
/**
* 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).
* - [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)
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
// Float indexes of the Codemasters "extradata 3" packet; engine rpm values are sent divided by 10.
private const val CM_LAP_TIME = 1
private const val CM_SPEED = 7
private const val CM_THROTTLE = 29
private const val CM_BRAKE = 31
private const val CM_GEAR = 33
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_FLOATS = 64
internal fun codemasters(buf: ByteBuffer, length: Int): Telemetry? {
if (length < CM_FLOATS * 4) return null
fun f(i: Int) = buf.getFloat(i * 4)
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 },
)
}
// 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
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 },
)
}
// 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),
)
}
}
/** 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"
private 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<Pair<String, String>> {
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())
}.take(WAR_THUNDER_ROWS).toList()
}
fun eliteStatusFile(runtimeRoot: java.io.File, mounts: Map<String, java.io.File>): 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<Int>?, 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,
)
}
}
@@ -3,6 +3,7 @@ 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
@@ -10,10 +11,12 @@ 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 },
)
/** The pages the bottom-screen dashboard offers during a session, in tab order. */
fun sessionBottomPages(actions: BottomPageActions): List<BottomPage> = listOf(
BottomPage("telemetry", R.string.bottom_page_telemetry, Icons.Outlined.Speed) { BottomTelemetryPage(actions.fps) },
BottomPage("downloads", R.string.bottom_page_downloads, Icons.Outlined.Download) { BottomDownloadsPage() },
BottomPage("notifications", R.string.bottom_page_notifications, Icons.Outlined.Notifications) { BottomNotificationsPage() },
BottomPage("screenshots", R.string.bottom_page_screenshots, Icons.Outlined.PhotoLibrary) { BottomScreenshotsPage(actions.takeScreenshot) },
@@ -0,0 +1,281 @@
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.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.shape.RoundedCornerShape
import androidx.compose.foundation.verticalScroll
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.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.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.session.SessionState
import com.droiddeck.launcher.session.Telemetry
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.InetAddress
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 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
@Composable
fun BottomTelemetryPage(fps: () -> Float?) {
val context = LocalContext.current
val colors = MaterialTheme.colorScheme
val latest = remember { AtomicReference<Pair<Long, Telemetry>?>(null) }
var race by remember { mutableStateOf<Telemetry?>(null) }
var fpsNow by remember { mutableStateOf<Float?>(null) }
var device by remember { mutableStateOf<HudMetrics.Snapshot?>(null) }
var thunder by remember { mutableStateOf<List<Pair<String, String>>>(emptyList()) }
var elite by remember { mutableStateOf<GameStatusFiles.Elite?>(null) }
var busyPorts by remember { mutableStateOf<Set<Int>>(emptySet()) }
LaunchedEffect(Unit) {
for (port in GameTelemetry.PORTS) launch(Dispatchers.IO) {
val socket = runCatching {
DatagramSocket(null).apply {
reuseAddress = true
soTimeout = 500
bind(InetSocketAddress(InetAddress.getLoopbackAddress(), port))
}
}.getOrNull()
if (socket == null) {
withContext(Dispatchers.Main) { busyPorts = busyPorts + port }
return@launch
}
socket.use {
val data = ByteArray(2048)
val packet = DatagramPacket(data, data.size)
while (isActive) {
try {
packet.length = data.size
it.receive(packet)
GameTelemetry.parse(port, data, packet.length)?.let { t -> latest.set(System.currentTimeMillis() to t) }
} catch (_: SocketTimeoutException) {
}
}
}
}
while (isActive) {
val reading = latest.get()
race = reading?.takeIf { System.currentTimeMillis() - it.first < STALE_MS }?.second
fpsNow = fps()
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() }
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)
}
}
Column(Modifier.fillMaxSize().verticalScroll(rememberScrollState()), verticalArrangement = Arrangement.spacedBy(10.dp)) {
DeviceRow(fpsNow, device)
race?.let { RaceDash(it) }
if (thunder.isNotEmpty()) Card(stringResource(R.string.bottom_telemetry_war_thunder)) { ValueGrid(thunder) }
elite?.let { e ->
Card(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, GameTelemetry.CODEMASTERS_PORT, GameTelemetry.FORZA_PORT, GameTelemetry.OUTGAUGE_PORT),
fontSize = 14.sp, color = colors.onSurfaceVariant, 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))
}
}
}
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()
}
}
@Composable
private fun DeviceRow(fps: Float?, s: HudMetrics.Snapshot?) {
Row(Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.spacedBy(8.dp)) {
Tile(stringResource(R.string.bottom_telemetry_fps), fps?.takeIf { it > 0f }?.let { "%.0f".format(it) } ?: "–", Modifier.weight(1f))
Tile(stringResource(R.string.bottom_telemetry_cpu), listOfNotNull(s?.cpuPercent?.let { "$it%" }, s?.cpuTempC?.let { "$it°" })
.joinToString(" ").ifEmpty { "–" }, Modifier.weight(1f))
Tile(stringResource(R.string.bottom_telemetry_gpu), listOfNotNull(s?.gpuPercent?.let { "$it%" }, s?.gpuTempC?.let { "$it°" })
.joinToString(" ").ifEmpty { "–" }, Modifier.weight(1f))
Tile(stringResource(R.string.bottom_telemetry_battery), listOfNotNull(s?.battery?.percent?.let { "$it%" },
s?.battery?.watts?.takeIf { it > 0f }?.let { "%.1fW".format(it) }).joinToString(" ").ifEmpty { "–" }, Modifier.weight(1f))
}
}
@Composable
private fun Tile(label: String, value: String, modifier: Modifier) {
val colors = MaterialTheme.colorScheme
Column(modifier.clip(RoundedCornerShape(12.dp)).background(LocalPalette.current.surface).padding(horizontal = 10.dp, vertical = 8.dp)) {
Text(label, fontSize = 11.sp, color = colors.onSurfaceVariant, maxLines = 1)
Text(value, fontSize = 17.sp, fontWeight = FontWeight.Bold, color = colors.onBackground, maxLines = 1, overflow = TextOverflow.Ellipsis)
}
}
@Composable
private fun Card(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<Pair<String, String>>) {
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)
}
@Composable
private fun RaceDash(t: Telemetry) {
val colors = MaterialTheme.colorScheme
val pal = LocalPalette.current
Card(t.source) {
Row(Modifier.fillMaxWidth(), verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(16.dp)) {
Text(t.gear ?: "–", fontSize = 56.sp, fontWeight = FontWeight.Bold, color = pal.signal)
Column(Modifier.weight(1f), verticalArrangement = Arrangement.spacedBy(6.dp)) {
Text(t.speedKmh?.let { "%.0f km/h".format(it) } ?: "–", fontSize = 30.sp, fontWeight = FontWeight.Bold, color = colors.onBackground)
val rpm = t.rpm
if (rpm != null) {
val max = t.maxRpm
Text(if (max != null) "%.0f / %.0f rpm".format(rpm, max) else "%.0f rpm".format(rpm), fontSize = 14.sp, color = colors.onSurfaceVariant)
if (max != null) Bar((rpm / max).coerceIn(0f, 1f), if (rpm / max > 0.92f) colors.error else pal.signal)
}
}
Row(Modifier.height(72.dp), horizontalArrangement = Arrangement.spacedBy(6.dp)) {
t.throttle?.let { Pedal(it, pal.good) }
t.brake?.let { Pedal(it, colors.error) }
}
}
ValueGrid(listOfNotNull(
t.lap?.let { lap -> stringResource(R.string.bottom_telemetry_lap) to (t.laps?.let { "$lap / $it" } ?: "$lap") },
t.position?.let { stringResource(R.string.bottom_telemetry_position) to "P$it" },
t.currentLapS?.let { stringResource(R.string.bottom_telemetry_this_lap) to lapTime(it) },
t.lastLapS?.let { stringResource(R.string.bottom_telemetry_last_lap) to lapTime(it) },
t.fuel?.let { stringResource(R.string.bottom_telemetry_fuel) to "%.0f%%".format(it * 100) },
))
}
}
@Composable
private fun Bar(fraction: Float, color: Color) {
Box(Modifier.fillMaxWidth().height(10.dp).clip(RoundedCornerShape(5.dp)).background(LocalPalette.current.line)) {
Box(Modifier.fillMaxWidth(fraction).fillMaxHeight().background(color))
}
}
@Composable
private fun Pedal(fraction: Float, color: Color) {
Box(Modifier.width(14.dp).fillMaxHeight().clip(RoundedCornerShape(4.dp)).background(LocalPalette.current.line),
contentAlignment = Alignment.BottomCenter) {
Box(Modifier.fillMaxWidth().fillMaxHeight(fraction.coerceIn(0f, 1f)).background(color))
}
}
+18
View File
@@ -1903,6 +1903,24 @@
<string name="bottom_chat_mic_on">Mic on</string>
<string name="bottom_chat_mic_off">Mic off</string>
<string name="bottom_chat_volume">Volume %1$d%%</string>
<string name="bottom_page_telemetry">Telemetry</string>
<string name="bottom_telemetry_fps">FPS</string>
<string name="bottom_telemetry_cpu">CPU</string>
<string name="bottom_telemetry_gpu">GPU</string>
<string name="bottom_telemetry_battery">Battery</string>
<string name="bottom_telemetry_lap">Lap</string>
<string name="bottom_telemetry_position">Position</string>
<string name="bottom_telemetry_this_lap">This lap</string>
<string name="bottom_telemetry_last_lap">Last lap</string>
<string name="bottom_telemetry_fuel">Fuel</string>
<string name="bottom_telemetry_cargo">Cargo</string>
<string name="bottom_telemetry_pips">Pips SYS · ENG · WEP</string>
<string name="bottom_telemetry_legal">Legal state</string>
<string name="bottom_telemetry_balance">Balance</string>
<string name="bottom_telemetry_war_thunder">War Thunder</string>
<string name="bottom_telemetry_elite">Elite Dangerous</string>
<string name="bottom_telemetry_help">Racing games show a live dash here when they send telemetry to 127.0.0.1: DiRT Rally, DiRT 4 and GRID on port %1$d (UDP on, extradata 3), Forza "Data Out" on port %2$d, BeamNG.drive and Live for Speed OutGauge on port %3$d. War Thunder and Elite Dangerous show up on their own. FPS needs the HUD on.</string>
<string name="bottom_telemetry_port_busy">Another program already uses port %1$s, so that game cannot show here.</string>
<string name="rtinst_removing">Removing Linux runtime</string>
<plurals name="rtinst_removing_entries">
@@ -0,0 +1,120 @@
package com.droiddeck.launcher.session
import org.junit.Assert.assertEquals
import org.junit.Assert.assertNull
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)
}
@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 shortPacketsAreIgnored() {
assertNull(GameTelemetry.parse(GameTelemetry.CODEMASTERS_PORT, ByteArray(100), 100))
assertNull(GameTelemetry.parse(GameTelemetry.OUTGAUGE_PORT, ByteArray(40), 40))
assertNull(GameTelemetry.parse(1234, ByteArray(400), 400))
}
}
@RunWith(RobolectricTestRunner::class)
@Config(sdk = [33])
class GameStatusFilesTest {
@Test fun warThunderShowsNumbersOnlyDuringAMatch() {
assertEquals(emptyList<Pair<String, String>>(), 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 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)
}
}
@@ -36,3 +36,10 @@ class BottomDownloadsRateTest {
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))
}
}