feat(hud): every reading gets its own switch and a row order (#2454)

* feat: every HUD reading has its own switch and a row order

* feat: readings get a reorder dialog of their own

* refactor: drag alone moves a reading

* fix: the readings list is one column with a switch per row

* fix: one scrolling readings list, titled HUD info

* refactor: derive the readings order from the defaults instead of a second list

* fix: the readings dialog loses its doubled title and follows the saved order

* refactor: no title in the readings dialog, its actions sit beside the list

* refactor: readings dialog actions take the free side on landscape, the foot on portrait

* fix: the readings list follows the size it draws and drags with a live gap

* fix: the readings dialog fills the window and keeps scrolling under a held drag

* fix: reset restores every size's order, and the new HUD strings are translated

* refactor: one table for each size's rows and one for its text sizes

* refactor: the readings list swaps rows as the drag passes them, and the list animates the rest

* refactor: give the readings rows test tags for the local UI test

* refactor: HUD readings follow one configurable row table

* refactor: the Strip HUD draws its rows from the same table

* refactor: each size orders its rows by its own table, and the frame graph is a row

* fix: the readings dialog keeps the row order a drag leaves

* fix: each size keeps its own row order, and reset clears only the order

* refactor: the graph's size lives in one place, and the section markers are gone

* fix: a size change and the first save of a legacy config both keep the order

* chore: retrigger the build

* feat: a reading can be grabbed with Y and shuffled with the d-pad

* feat: controller hints float beside the dialog, and a moved row stays in view

* feat: Y grabs on a hold and drops on release, and a touch no longer flips the dialog

* fix: keep the key hints off the rows on narrow windows, and let Enter toggle a row
This commit is contained in:
kingokksa authored and GitHub committed 2026-11-14 14:49:47 -05:00
1 parent d8b3c66b95
commit 269d462825
42 files changed
+1322 -625

No files matched your search

@@ -1330,7 +1330,9 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde
selectedSecondScreenDisplay = selectedSecondScreenDisplay,
onHud = { on -> SessionPrefs.setHudEnabled(this@SessionActivity, on); hudOn = on; hud.refresh() },
onHudSetting = { key, value -> hudConfig = DroidDeckHudConfig.set(this@SessionActivity, key, value); hud.applyConfig() },
onHudOrder = { switches, order -> hudConfig = DroidDeckHudConfig.choose(this@SessionActivity, switches, order); hud.applyConfig() },
onHudReset = { hudConfig = DroidDeckHudConfig.reset(this@SessionActivity); hud.applyConfig() },
onHudOrderReset = { hudConfig = DroidDeckHudConfig.clearOrder(this@SessionActivity); hud.applyConfig() },
onHudExport = { exportHudDiagnostics() },
onUpscaler = { m ->
SessionPrefs.setUpscaler(this@SessionActivity, m); upscaler = m
@@ -7,15 +7,21 @@ internal object DroidDeckHudConfig {
val DEFAULTS: Map<String, String> = linkedMapOf(
"hudSize" to "minimal", "hudLocked" to "1", "hudSnap" to "1", "hudScale" to "100", "hudDock" to "none", "hudOpacity" to "80", "hudColor" to "mid",
"hudOutline" to "40", "hudOutlineAccent" to "1",
"showFPS" to "1", "showFPSGraph" to "1", "showCPUUsage" to "1", "showCPULoad" to "1", "showGPULoad" to "1",
"showVram" to "1", "showRAM" to "1", "showPower" to "1", "showTemp" to "1", "showBatteryTemp" to "1",
"showGpuTemp" to "0", "showBattery" to "0", "showBatteryTime" to "0", "showLow1" to "1", "showLow01" to "1", "showLow001" to "1", "fpsDecimal" to "1", "showPerCore" to "1",
"showSwap" to "1", "showNet" to "1", "showResolution" to "1", "showProton" to "1", "showSession" to "1",
"showClock" to "1", "showEngine" to "1", "showRenderer" to "1", "showGpuModel" to "1",
"showGpuModel" to "1", "showGPULoad" to "1", "showCPUUsage" to "1", "showCPULoad" to "1",
"showPerCore" to "1", "showTemp" to "1", "showBatteryTemp" to "1", "showGpuTemp" to "0",
"showVram" to "1", "showRAM" to "1", "showSwap" to "1", "showBattery" to "0", "showBatteryTime" to "0", "showPower" to "1",
"showFPS" to "1", "showFPSGraph" to "1", "fpsDecimal" to "1",
"showLatency" to "1", "showAvg" to "1", "showLow1" to "1", "showLow01" to "1", "showLow001" to "1",
"showEngine" to "1", "showRenderer" to "1",
"showDisplay" to "1", "showHdr" to "1", "showNet" to "1", "showResolution" to "1",
"showProton" to "1", "showSession" to "1", "showClock" to "1", "hudOrder" to "",
"tempUnit" to "c", "tempBands" to "1", "tempAuto" to "1", "tempRedCpu" to "90", "tempRedGpu" to "90", "tempRedBat" to "48",
)
private val TWINS = mapOf("showCPUUsage" to "showCPULoad", "showTemp" to "showBatteryTemp", "showEngine" to "showRenderer")
private val NOT_READINGS = setOf("showCPULoad", "showRenderer", "fpsDecimal")
/** Orders saved before the GPU switch was named after the alias the HUD actually reads. */
private val RENAMED = mapOf("showGPU" to "showGPULoad")
fun load(context: Context): MutableMap<String, String> {
val values = LinkedHashMap(DEFAULTS)
@@ -36,7 +42,31 @@ internal object DroidDeckHudConfig {
val values = load(context)
if (key !in DEFAULTS) return values
values[key] = value
TWINS[key]?.let { values[it] = value }
SessionPrefs.setDroidDeckHudConfig(context, encode(values))
return values
}
/** Writes several switches and the row order in one go, so the HUD is rebuilt once. */
fun choose(context: Context, switches: Map<String, Boolean>, order: List<String>): Map<String, String> {
val values = load(context)
for ((key, on) in switches) if (key in DEFAULTS) {
values[key] = flag(on)
}
val size = DroidDeckHudSize.from(values["hudSize"])
val groups = sizeOrders(values).toMutableMap()
if (groups.isEmpty()) {
val legacy = legacyOrder(values)
if (legacy.isNotEmpty()) for (each in DroidDeckHudSize.values()) groups[each] = legacy.filter { it in each.rows }
}
groups[size] = order.filter { it in ORDER }
values["hudOrder"] = encodeOrders(groups)
SessionPrefs.setDroidDeckHudConfig(context, encode(values))
return values
}
fun clearOrder(context: Context): Map<String, String> {
val values = load(context)
values["hudOrder"] = ""
SessionPrefs.setDroidDeckHudConfig(context, encode(values))
return values
}
@@ -46,5 +76,37 @@ internal object DroidDeckHudConfig {
return DEFAULTS
}
/** Every metric switch, in the order the HUD lists them before the user moves any. Derived from
* [DEFAULTS], so a switch added there shows up here without a second list to keep in step. */
val ORDER: List<String> = DEFAULTS.keys.filter { it.startsWith("show") && it !in NOT_READINGS }
/** Only the rows the user moved for [size], in the order they left them. */
fun storedOrder(values: Map<String, String>, size: DroidDeckHudSize): List<String> =
sizeOrders(values)[size] ?: legacyOrder(values)
/** Orders saved before each size kept its own: one list, applied to every size. */
private fun legacyOrder(values: Map<String, String>): List<String> {
val raw = values["hudOrder"].orEmpty()
if (raw.isBlank() || raw.contains(':')) return emptyList()
return raw.split('|').map { RENAMED[it] ?: it }.filter { it in ORDER }
}
private fun sizeOrders(values: Map<String, String>): Map<DroidDeckHudSize, List<String>> {
val raw = values["hudOrder"].orEmpty()
if (raw.isBlank()) return emptyMap()
val groups = LinkedHashMap<DroidDeckHudSize, List<String>>()
for (group in raw.split(';')) {
val colon = group.indexOf(':')
if (colon <= 0) continue
val size = DroidDeckHudSize.values().firstOrNull { it.token == group.substring(0, colon) } ?: continue
groups[size] = group.substring(colon + 1).split('|').map { RENAMED[it] ?: it }.filter { it in ORDER }
}
return groups
}
private fun encodeOrders(groups: Map<DroidDeckHudSize, List<String>>): String =
groups.entries.filter { it.value.isNotEmpty() }
.joinToString(";") { "${it.key.token}:${it.value.joinToString("|")}" }
private fun flag(on: Boolean) = if (on) "1" else "0"
}
@@ -13,6 +13,27 @@
package com.droiddeck.launcher.hud
/**
* Size modes for the DroidDeck HUD (the 4th selectable in-game overlay style). One shared color-coded
* visual language, four amounts of detail — see the approved mockup. The config value is the lower-case
* token stored under the `hudSize` key; the label is the user-facing string.
*/
/** The text sizes and spacing a [DroidDeckHudSize] lays its rows out with, in sp. */
data class DroidDeckHudStyle(
val row: Float,
val unit: Float,
val pad: Float,
val lineGap: Float,
val labelGap: Float,
val key: Float = 0f,
val sub: Float = 0f,
val foot: Float = 0f,
val band: Float = 0f,
val gutter: Float = 0f,
val tileGap: Float = 0f,
val innerPad: Float = 0f,
)
enum class DroidDeckHudSize(val token: String, val label: String) {
FULL("full", "Full"),
TILES("tiles", "Tiles"),
@@ -26,27 +47,73 @@ enum class DroidDeckHudSize(val token: String, val label: String) {
return all[(ordinal + 1) % all.size]
}
fun supportedChips(): Set<String> = when (this) {
MINIMAL -> MINIMAL_CHIPS
PILL -> PILL_CHIPS
FULL, TILES, STRIP -> STANDARD_CHIPS
MEGA -> MEGA_CHIPS
}
/**
* The rows this size draws, in the order it draws them before the user moves any. This is the single
* source of truth for both surfaces: [DroidDeckHudView] draws exactly these and the settings screen
* offers exactly these. A switch outside the set is ignored by the size, so the two cannot drift.
*/
val rows: List<String> get() = ROWS.getValue(this)
/** This size's rows: the ones the user moved first, then the rest in the order [rows] lists them. */
fun rowsIn(stored: List<String>): List<String> =
stored.filter { it in rows } + rows.filter { it !in stored }
/**
* The numbers each size sets its text in, in sp. One table so a size's scale can be read (and changed)
* in one place instead of hunting the `sp(...)` literals scattered through its builder.
*/
val style: DroidDeckHudStyle get() = STYLE.getValue(this)
companion object {
fun from(token: String?): DroidDeckHudSize =
values().firstOrNull { it.token.equals(token, ignoreCase = true) } ?: FULL
val MINIMAL_CHIPS = setOf("FPS", "Battery time", "FPS graph", "1% low", "0.1% low", "0.01% low", "FPS .1", "Engine", "Clock")
val PILL_CHIPS = setOf("FPS", "Battery time", "FPS graph", "GPU", "CPU", "VRAM", "RAM", "Battery", "GPU model", "FPS .1", "Engine", "Clock")
val STANDARD_CHIPS = setOf(
"FPS", "FPS graph", "GPU", "GPU temp", "CPU", "VRAM", "RAM", "Power", "Temp",
"Battery", "Battery time", "GPU model", "Engine", "1% low", "0.1% low", "0.01% low", "FPS .1", "Clock",
private val EXTRAS = setOf("showClock")
val ROWS: Map<DroidDeckHudSize, List<String>> = mapOf(
FULL to listOf(
"showFPS", "showFPSGraph", "showGpuModel", "showDisplay", "showHdr", "showGPULoad", "showGpuTemp",
"showCPUUsage", "showTemp", "showVram", "showRAM", "showBattery", "showBatteryTemp", "showBatteryTime",
"showPower", "showLatency", "showAvg", "showLow1", "showLow01", "showLow001",
),
TILES to listOf(
"showFPS", "showFPSGraph", "showLatency", "showGPULoad", "showGpuTemp", "showCPUUsage", "showTemp",
"showVram", "showRAM", "showEngine", "showDisplay", "showHdr", "showAvg", "showLow1",
"showLow01", "showLow001", "showGpuModel", "showBattery", "showBatteryTemp", "showBatteryTime", "showPower",
),
PILL to listOf(
"showFPS", "showFPSGraph", "showGpuModel", "showGPULoad", "showGpuTemp", "showCPUUsage", "showTemp",
"showRAM", "showBattery", "showBatteryTemp", "showBatteryTime", "showPower", "showLatency", "showDisplay",
"showVram", "showHdr",
),
MINIMAL to listOf(
"showFPS", "showBatteryTime", "showFPSGraph", "showLow1", "showLow01", "showLow001", "showAvg", "showLatency",
"showEngine", "showDisplay", "showHdr",
),
MEGA to DroidDeckHudConfig.ORDER.filter { it !in EXTRAS },
STRIP to listOf(
"showFPS", "showFPSGraph", "showLow1", "showLow01", "showLow001", "showGPULoad", "showGpuTemp",
"showCPUUsage", "showTemp", "showVram", "showRAM", "showBattery", "showBatteryTemp", "showBatteryTime",
"showPower", "showDisplay", "showHdr", "showGpuModel",
),
)
val MEGA_ONLY = setOf(
"Per-core", "Swap", "Network", "Resolution", "Proton", "Wrapper", "DX ver", "Session",
val STYLE: Map<DroidDeckHudSize, DroidDeckHudStyle> = mapOf(
FULL to DroidDeckHudStyle(row = 12f, unit = 12f * 0.62f, pad = 10f, lineGap = 4f, labelGap = 8f),
TILES to DroidDeckHudStyle(row = 18f, unit = 11f, pad = 9f, lineGap = 4f, labelGap = 8f,
key = 10f, sub = 10f, tileGap = 6f, innerPad = 8f),
PILL to DroidDeckHudStyle(row = 30f, unit = 30f * 0.36f, pad = 10f, lineGap = 3f, labelGap = 12f,
sub = 11.5f),
MINIMAL to DroidDeckHudStyle(row = 34f, unit = 34f * 0.32f, pad = 10f, lineGap = 4f, labelGap = 8f,
sub = 11.5f, foot = 9.5f),
MEGA to DroidDeckHudStyle(row = 11.5f, unit = 11.5f * 0.62f, pad = 10f, lineGap = 3.5f, labelGap = 7f,
band = 9.5f, gutter = 16f),
STRIP to DroidDeckHudStyle(row = 11.5f, unit = 11.5f * 0.8f, pad = 10f, lineGap = 0f, labelGap = 13f),
)
val MEGA_CHIPS = STANDARD_CHIPS + MEGA_ONLY
fun rowsFor(size: DroidDeckHudSize, values: Map<String, String>): List<String> =
size.rowsIn(DroidDeckHudConfig.storedOrder(values, size))
}
}
@@ -69,6 +69,7 @@ class DroidDeckHudView(context: Context) : View(context) {
private val density = resources.displayMetrics.density
private var cfg: KeyValueSet = KeyValueSet()
private var size = DroidDeckHudSize.FULL
private var scale = 1f
private var bgOpacity = 0.8f
@@ -87,7 +88,6 @@ class DroidDeckHudView(context: Context) : View(context) {
private var showVram = true
private var showRAM = true
private var showBattery = true
private var showBatteryTime = true
private var showPower = true
private var showBatteryTemp = false
private var showGraph = false
@@ -96,13 +96,16 @@ class DroidDeckHudView(context: Context) : View(context) {
private var showLow001 = true
private var fpsDecimal = true
private var showClockTime = true
private var showLatency = true
private var showAvg = true
private var showDisplay = true
private var showHdr = true
private var storedOrder: List<String> = emptyList()
private var showPerCore = true
private var showSwap = true
private var showNet = true
private var showResolution = true
private var showProton = true
private var showWrapper = true
private var showDxVer = true
private var showSession = true
private var engineLabel = ""
@@ -178,7 +181,7 @@ class DroidDeckHudView(context: Context) : View(context) {
fun moved(dx: Float, dy: Float) = Glyph(x + dx, baseline + dy, text, color, sizePx, glow)
}
private class Span(val text: String, val color: Int, val sizePx: Float, val glow: Boolean = false)
private class HudRow(val label: Span, val vals: List<Span>, val inline: Boolean = false)
private class HudRow(val key: String, val label: Span, val vals: List<Span>, val inline: Boolean = false)
private val glyphs = ArrayList<Glyph>()
private val tileRects = ArrayList<RectF>()
private var graphRect: RectF? = null
@@ -290,42 +293,52 @@ class DroidDeckHudView(context: Context) : View(context) {
private fun cycleSize() {
size = size.next()
refreshOrder()
onSizeCycledListener?.accept(size.token)
rebuildAndInvalidate()
}
private fun refreshOrder() {
storedOrder = DroidDeckHudConfig.storedOrder(mapOf("hudOrder" to cfg.get("hudOrder", "")), size)
}
private fun switchOn(key: String): Boolean =
cfg.get(key, DroidDeckHudConfig.DEFAULTS[key] ?: "1") == "1"
fun applyConfig(configString: String?) {
if (configString.isNullOrEmpty()) return
val cfg = KeyValueSet(configString)
cfg = KeyValueSet(configString)
size = DroidDeckHudSize.from(cfg.get("hudSize", "minimal"))
showFPS = cfg.get("showFPS", "1") == "1"
showEngine = cfg.get("showEngine", "1") == "1"
showGpuModel = cfg.get("showGpuModel", "1") == "1"
showCPU = cfg.get("showCPUUsage", cfg.get("showCPULoad", "1")) == "1"
showGPU = cfg.get("showGPULoad", "1") == "1"
showCpuTemp = cfg.get("showTemp", "1") == "1"
showGpuTemp = cfg.get("showGpuTemp", "0") == "1"
showVram = cfg.get("showVram", "1") == "1"
showRAM = cfg.get("showRAM", "1") == "1"
showBattery = cfg.get("showBattery", "1") == "1"
showBatteryTime = cfg.get("showBatteryTime", "1") == "1"
showPower = cfg.get("showPower", "1") == "1"
showBatteryTemp = cfg.get("showBatteryTemp", "0") == "1"
showGraph = cfg.get("showFPSGraph", "0") == "1"
showLow1 = cfg.get("showLow1", "1") == "1"
showLow01 = cfg.get("showLow01", "1") == "1"
showLow001 = cfg.get("showLow001", "1") == "1"
showFPS = switchOn("showFPS")
showEngine = switchOn("showEngine")
showGpuModel = switchOn("showGpuModel")
showCPU = switchOn("showCPUUsage")
showGPU = switchOn("showGPULoad")
showCpuTemp = switchOn("showTemp")
showGpuTemp = switchOn("showGpuTemp")
showVram = switchOn("showVram")
showRAM = switchOn("showRAM")
showBattery = switchOn("showBattery")
showPower = switchOn("showPower")
showBatteryTemp = switchOn("showBatteryTemp")
showGraph = switchOn("showFPSGraph")
showLow001 = switchOn("showLow001")
fpsDecimal = cfg.get("fpsDecimal", "1") == "1"
showClockTime = cfg.get("showClock", "1") == "1"
showPerCore = cfg.get("showPerCore", "1") == "1"
showSwap = cfg.get("showSwap", "1") == "1"
showNet = cfg.get("showNet", "1") == "1"
showResolution = cfg.get("showResolution", "1") == "1"
showProton = cfg.get("showProton", "1") == "1"
showWrapper = cfg.get("showWrapper", "1") == "1"
showDxVer = cfg.get("showDxVer", "1") == "1"
showSession = cfg.get("showSession", "1") == "1"
showClockTime = switchOn("showClock")
showLatency = switchOn("showLatency")
showAvg = switchOn("showAvg")
showLow1 = switchOn("showLow1")
showLow01 = switchOn("showLow01")
showDisplay = switchOn("showDisplay")
showHdr = switchOn("showHdr")
refreshOrder()
showPerCore = switchOn("showPerCore")
showSwap = switchOn("showSwap")
showNet = switchOn("showNet")
showResolution = switchOn("showResolution")
showProton = switchOn("showProton")
showSession = switchOn("showSession")
tempDisplay = HudMetrics.TempDisplay.from(cfg)
lockController.setLocked(cfg.get("hudLocked", "1") == "1")
dock = DroidDeckHudDock.from(cfg.get("hudDock", "none"))
@@ -460,6 +473,8 @@ class DroidDeckHudView(context: Context) : View(context) {
return w
}
private fun showHdrLine(): Boolean = showHdr && hdrState != DroidDeckHudHdr.NONE
private fun placeRun(startX: Float, baseline: Float, spans: List<Span>, glow: Boolean = false): Float {
var x = startX
for (s in spans) {
@@ -541,13 +556,15 @@ class DroidDeckHudView(context: Context) : View(context) {
val s = snap
if (s == null) { contentW = 0f; contentH = 0f; return }
if (dock != DroidDeckHudDock.NONE) { buildDockTab(); return }
if (size == DroidDeckHudSize.STRIP) { buildStrip(s); return }
buildRows(s)
if (contentW <= 0f || contentH <= 0f) return
if (size == DroidDeckHudSize.PILL) addSubtleClock(sp(10f), leftAligned = true)
val pad = sp(size.style.pad)
when (size) {
DroidDeckHudSize.FULL -> { buildFull(s); intoPanel(sp(10f), header = true) }
DroidDeckHudSize.TILES -> { buildTiles(s); intoPanel(sp(9f), header = true) }
DroidDeckHudSize.PILL -> { buildPill(s); intoPanel(sp(10f), header = false) }
DroidDeckHudSize.MINIMAL -> buildMinimal(s)
DroidDeckHudSize.MEGA -> { buildMega(s); intoPanel(sp(10f), header = true) }
DroidDeckHudSize.STRIP -> buildStrip(s)
DroidDeckHudSize.MINIMAL -> intoPanel(pad, header = true, halfRound = true)
DroidDeckHudSize.PILL -> intoPanel(pad, header = false)
else -> intoPanel(pad, header = true)
}
}
@@ -617,7 +634,12 @@ class DroidDeckHudView(context: Context) : View(context) {
return Pair(dDividerTop + max(1f, density), x)
}
private fun intoPanel(pad: Float, header: Boolean) {
/**
* Moves a size's content, laid out from [pad] at the origin, into the panel: under the header, or after
* the logo chip on the Pill. Lines that start on the content's left edge are lined up by their ink, so
* the logo, labels and numbers share one edge.
*/
private fun intoPanel(pad: Float, header: Boolean, halfRound: Boolean = !header) {
if (contentW <= 0f || contentH <= 0f) return
for (i in glyphs.indices) {
val g = glyphs[i]
@@ -643,7 +665,7 @@ class DroidDeckHudView(context: Context) : View(context) {
val panel = RectF(panelLeft(), panelInset(), max(contentW - pad + dx, headerRight) + sp(18f),
contentH - pad + dy + sp(10f) + stroke)
chipRect?.let { it.offsetTo(it.left, panel.centerY() - it.height() / 2f) }
finishPanel(panel, halfRound = !header)
finishPanel(panel, halfRound = halfRound)
}
private fun finishPanel(panel: RectF, halfRound: Boolean) {
@@ -714,289 +736,188 @@ class DroidDeckHudView(context: Context) : View(context) {
contentW = max(contentW, pad + w + pad)
}
private fun hasGpuStats(s: HudMetrics.Snapshot): Boolean =
s.gpuPercent != null || s.gpuTempC != null || s.gpuClockMhz != null
private fun buildFull(s: HudMetrics.Snapshot) {
val rowPx = sp(12f); val unitPx = rowPx * 0.62f
val pad = sp(10f); val lineGap = sp(4f); val lvGap = sp(8f)
val rows = ArrayList<HudRow>()
if (showGpuModel && gpuNameText().isNotBlank())
rows.add(HudRow(Span("GPU", colGpu, rowPx), gpuModelSpans(rowPx, colValue)))
if (displayServer.isNotBlank())
rows.add(HudRow(Span("DISP", colDisp, rowPx), listOf(Span(displayServer, colValue, rowPx))))
if (hdrState != DroidDeckHudHdr.NONE)
rows.add(HudRow(Span("HDR", colHdr, rowPx), hdrValue(rowPx)))
if (showGPU && hasGpuStats(s)) {
val v = ArrayList<Span>()
v += numUnit(s.gpuPercent?.toString(), "%", rowPx, unitPx)
if (showGpuTemp) tempSpans(s.gpuTempC, HudMetrics.TempSensor.GPU, rowPx, unitPx)
.let { if (it.isNotEmpty()) { v += gap(unitPx); v += it } }
v += gap(unitPx); v += numUnit(s.gpuClockMhz?.toString(), "MHz", rowPx, unitPx)
rows.add(HudRow(Span("GPU", colGpu, rowPx), v))
}
if (showCPU) {
val v = ArrayList<Span>()
v += numUnit(s.cpuPercent?.toString(), "%", rowPx, unitPx)
v += gap(unitPx); v += numUnit(s.cpuClockMhz?.toString(), "MHz", rowPx, unitPx)
if (showCpuTemp) tempSpans(s.cpuTempC, HudMetrics.TempSensor.CPU, rowPx, unitPx)
.let { if (it.isNotEmpty()) { v += gap(unitPx); v += it } }
rows.add(HudRow(Span("CPU", colCpu, rowPx), v))
}
if (showVram && s.vramText() != null)
rows.add(HudRow(Span("VRAM", colVram, rowPx), valueUnit(s.vramText()!!, rowPx, unitPx)))
if (showRAM) {
val v = ArrayList<Span>()
v += valueUnit(s.ramUsedText(), rowPx, unitPx)
v += gap(unitPx); v += numUnit(s.ramPercent.roundToInt().toString(), "%", rowPx, unitPx)
rows.add(HudRow(Span("RAM", colRam, rowPx), v))
}
if (showBattery || showPower || showBatteryTemp) {
val v = ArrayList<Span>(); var any = false
if (showBattery && s.battery.percent != null) { v += numUnit(s.battery.percent.toString(), "%", rowPx, unitPx); any = true }
if (showBatteryTemp) tempSpans(s.battery.tempC, HudMetrics.TempSensor.BATTERY, rowPx, unitPx)
.let { if (it.isNotEmpty()) { if (any) v += gap(unitPx); v += it; any = true } }
if (showPower && s.battery.watts > 0f) { if (any) v += gap(unitPx); v += numUnit(fmt1(s.battery.watts), "W", rowPx, unitPx); any = true }
if (any) rows.add(HudRow(Span("BAT", colBat, rowPx), v))
}
if (showBatteryTime) rows.add(HudRow(Span("TIME", colBat, rowPx), listOf(Span(s.battery.runtimeText ?: "—", colValue, rowPx))))
if (showFPS) {
val v = ArrayList<Span>()
v += glowing(numUnit(fpsText(fpsNow), "FPS", rowPx, unitPx))
v += gap(unitPx); v += numUnit(fmt1(1000f / max(fpsNow, 1f)), "ms", rowPx, unitPx)
rows.add(HudRow(Span(apiLabel(), colFps, rowPx), v))
rows.add(HudRow(Span("AVG", colLo, rowPx), numUnit(fmt1(fpsAvg), "FPS", rowPx, unitPx)))
if (showLow1)
rows.add(HudRow(Span("1%", colLo, rowPx), numUnit(lowText(lows.low1Fps), "FPS", rowPx, unitPx)))
if (showLow01)
rows.add(HudRow(Span("0.1%", colLo, rowPx), numUnit(lowText(lows.low01Fps), "FPS", rowPx, unitPx)))
if (showLow001)
rows.add(HudRow(Span("0.01%", colLo, rowPx), numUnit(lowText(lows.low001Fps), "FPS", rowPx, unitPx)))
}
var labelCol = 0f
for (r in rows) if (!r.inline) labelCol = max(labelCol, measure(r.label.text, rowPx))
val h = lineH(rowPx); val asc = ascent(rowPx)
var y = pad; var maxRight = pad
for (r in rows) {
val baseline = y - asc
placeRun(pad, baseline, listOf(r.label))
val valX = if (r.inline) pad + measure(r.label.text, rowPx) + lvGap
else pad + labelCol + lvGap
val end = placeRun(valX, baseline, r.vals)
maxRight = max(maxRight, end)
y += h + lineGap
}
if (showFPS && showGraph) {
val ftPx = unitPx * 1.15f
val baseline = y - asc
placeRun(pad, baseline, listOf(Span("Frametime", colFps, ftPx)))
val stat = "min:${fmt1(graphMinMs)} max:${fmt1(graphMaxMs)}"
val statX = pad + max(labelCol, measure("Frametime", ftPx)) + lvGap
val end = placeRun(statX, baseline, listOf(Span(stat, colDim, unitPx)))
maxRight = max(maxRight, end)
y += h + lineGap
val gh = sp(22f)
val right = max(maxRight, pad + sp(160f))
graphRect = RectF(pad, y, right, y + gh)
maxRight = max(maxRight, right)
y += gh
}
contentW = maxRight + pad
contentH = y + pad
addSubtleClock(pad)
private fun switchLabel(key: String): Pair<String, Int> = when (key) {
"showGpuModel" -> "MODEL" to colGpu
"showGPULoad" -> "GPU" to colGpu
"showGpuTemp" -> "GPU.T" to colGpu
"showCPUUsage" -> "CPU" to colCpu
"showTemp" -> "CPU.T" to colCpu
"showBatteryTemp" -> "BAT.T" to colBat
"showPower" -> "PWR" to colBat
"showBattery" -> "BAT" to colBat
"showBatteryTime" -> "BAT TIME" to colBat
"showVram" -> "VRAM" to colVram
"showRAM" -> "RAM" to colRam
"showSwap" -> "SWP" to colRam
"showNet" -> "NET" to colFps
"showPerCore" -> "CORE" to colCpu
"showFPS" -> "FPS" to colFps
"showLatency" -> "MS" to colDim
"showAvg" -> "AVG" to colLo
"showLow1" -> "1%" to colLo
"showLow01" -> "0.1%" to colLo
"showLow001" -> "0.01%" to colLo
"showEngine" -> "API" to colFps
"showDisplay" -> "DISP" to colDisp
"showHdr" -> "HDR" to colHdr
"showResolution" -> "RES" to colDim
"showProton" -> "PROTON" to colVram
"showSession" -> "TIME" to colDim
else -> key.removePrefix("show") to colDim
}
private fun buildTiles(s: HudMetrics.Snapshot) {
val keyPx = sp(10f); val valPx = sp(18f); val subPx = sp(10f); val unitPx = sp(11f)
val pad = sp(9f); val innerPad = sp(8f); val tileGap = sp(6f); val lineGap = sp(4f)
class Tile(val key: String, val keyColor: Int, val value: List<Span>, val sub: String?, val wide: Boolean)
val tiles = ArrayList<Tile>()
if (showFPS) tiles.add(Tile("FPS", colFps, listOf(Span(fpsText(fpsNow), colValue, valPx, glow = true)),
"${fmt1(fpsAvg)} avg" + (if (showLow1) " · ${lowText(lows.low1Fps) ?: "—"} 1%" else ""), false))
if (showFPS) tiles.add(Tile("FRAME", colDim, numUnit(fmt1(1000f / max(fpsNow, 1f)), "ms", valPx, unitPx),
"${fmt1(graphMinMs)} – ${fmt1(graphMaxMs)}", false))
if (showGPU && hasGpuStats(s)) tiles.add(Tile("GPU", colGpu, numUnit(s.gpuPercent?.toString(), "%", valPx, unitPx),
if (showGpuTemp && s.gpuTempC != null) HudMetrics.formatTemp(s.gpuTempC.toFloat(), tempDisplay, false)
else s.gpuClockMhz?.let { "${it}MHz" }, false))
if (showCPU) tiles.add(Tile("CPU", colCpu, numUnit(s.cpuPercent?.toString(), "%", valPx, unitPx),
listOfNotNull(s.cpuClockMhz?.let { "${it}MHz" },
if (showCpuTemp) s.cpuTempC?.let { HudMetrics.formatTemp(it.toFloat(), tempDisplay, false) } else null)
.joinToString(" · ").ifBlank { null }, false))
if (showVram && s.vramText() != null) tiles.add(Tile("VRAM", colVram, valueUnit(s.vramText()!!, valPx, unitPx), null, false))
if (showRAM) tiles.add(Tile("RAM", colRam, numUnit(s.ramPercent.roundToInt().toString(), "%", valPx, unitPx),
"${s.ramUsedText()} / ${s.ramTotalText()}", false))
if (showEngine && engineLabel.isNotBlank())
tiles.add(Tile("API", colFps, listOf(Span(engineLabel, colValue, valPx)),
dxVersion().ifBlank { null }, false))
if (displayServer.isNotBlank())
tiles.add(Tile("DISPLAY", colDisp, listOf(Span(displayServer, colValue, valPx)),
if (hdrState != DroidDeckHudHdr.NONE) hdrText() else null, false))
if (showGpuModel && gpuNameText().isNotBlank())
tiles.add(Tile("GPU", colGpu, gpuModelSpans(valPx, colValue), null, true))
if (showBattery || showPower || showBatteryTemp) {
val parts = ArrayList<Span>(); var any = false
if (showBattery && s.battery.percent != null) { parts += numUnit(s.battery.percent.toString(), "%", valPx, unitPx); any = true }
if (showBatteryTemp && s.battery.tempC != null) { if (any) parts += Span(" · ", colDim, subPx); parts += tempSpans(s.battery.tempC, HudMetrics.TempSensor.BATTERY, valPx, unitPx); any = true }
if (showPower && s.battery.watts > 0f) { if (any) parts += Span(" · ", colDim, subPx); parts += numUnit(fmt1(s.battery.watts), "W", valPx, unitPx); any = true }
if (any) tiles.add(Tile("BAT", colBat, parts, null, true))
private fun reading(key: String, s: HudMetrics.Snapshot, labelPx: Float, valuePx: Float, unitPx: Float): HudRow {
if (key == "showFPSGraph") return HudRow(key, Span("", colDim, 0f), emptyList())
val (label, color) = switchLabel(key)
val values: List<Span> = when (key) {
"showGpuModel" -> if (gpuNameText().isBlank()) numUnit(null, "", valuePx, unitPx)
else gpuModelSpans(valuePx, colValue)
"showGPULoad" -> numUnit(s.gpuPercent?.toString(), "%", valuePx, unitPx)
"showGpuTemp" -> tempSpans(s.gpuTempC, HudMetrics.TempSensor.GPU, valuePx, unitPx)
"showCPUUsage" -> numUnit(s.cpuPercent?.toString(), "%", valuePx, unitPx)
"showTemp" -> tempSpans(s.cpuTempC, HudMetrics.TempSensor.CPU, valuePx, unitPx)
"showBatteryTemp" -> tempSpans(s.battery.tempC, HudMetrics.TempSensor.BATTERY, valuePx, unitPx)
"showPower" -> numUnit(if (s.battery.watts > 0f) fmt1(s.battery.watts) else null, "W", valuePx, unitPx)
"showBattery" -> numUnit(s.battery.percent?.toString(), "%", valuePx, unitPx)
"showBatteryTime" -> valueUnit(s.battery.runtimeText ?: "—", valuePx, unitPx)
"showVram" -> valueUnit(s.vramText() ?: "—", valuePx, unitPx)
"showRAM" -> numUnit(s.ramPercent.roundToInt().toString(), "%", valuePx, unitPx)
"showSwap" -> valueUnit(s.swapUsedText() ?: "—", valuePx, unitPx)
"showNet" -> listOf(
Span("↓", colDim, unitPx), Span(((s.netDownBps ?: 0L) / 1024L).toString(), colValue, valuePx),
Span(" ↑", colDim, unitPx), Span(((s.netUpBps ?: 0L) / 1024L).toString(), colValue, valuePx),
)
"showPerCore" -> listOf(Span(s.perCorePercent.size.toString(), colValue, valuePx))
"showFPS" -> glowing(numUnit(fpsText(fpsNow), "", valuePx, unitPx))
"showLatency" -> numUnit(fmt1(1000f / max(fpsNow, 1f)), "ms", valuePx, unitPx)
"showAvg" -> numUnit(fmt1(fpsAvg), "", valuePx, unitPx)
"showLow1" -> numUnit(lowText(lows.low1Fps), "", valuePx, unitPx)
"showLow01" -> numUnit(lowText(lows.low01Fps), "", valuePx, unitPx)
"showLow001" -> numUnit(lowText(lows.low001Fps), "", valuePx, unitPx)
"showEngine" -> listOf(Span(engineLabel.ifBlank { "—" }, colValue, valuePx))
"showDisplay" -> listOf(Span(displayServer.ifBlank { "—" }, colDisp, valuePx))
"showHdr" -> if (showHdrLine()) hdrValue(valuePx) else listOf(Span("off", colDim, valuePx))
"showResolution" -> listOf(Span(resolutionString(), colValue, valuePx))
"showProton" -> listOf(Span(wineVersion.ifBlank { "—" }, colVram, valuePx))
"showSession" -> listOf(Span(elapsedString(), colValue, valuePx))
else -> listOf(Span("—", colDim, valuePx))
}
if (showBatteryTime) tiles.add(Tile("BAT TIME", colBat, listOf(Span(s.battery.runtimeText ?: "—", colValue, valPx)), "", true))
if (tiles.isEmpty()) { contentW = 0f; contentH = 0f; return }
return HudRow(key, Span(label, color, labelPx), values.ifEmpty { listOf(Span("—", colDim, valuePx)) })
}
val keyH = lineH(keyPx); val valH = lineH(valPx); val subH = lineH(subPx)
fun tileW(t: Tile) = max(max(measure(t.key, keyPx), runWidth(t.value)),
t.sub?.let { measure(it, subPx) } ?: 0f) + innerPad * 2
var normalW = 0f
for (t in tiles) if (!t.wide) normalW = max(normalW, tileW(t))
if (normalW == 0f) for (t in tiles) normalW = max(normalW, tileW(t) / 2f)
val tileH = innerPad * 2 + keyH + lineGap + valH + lineGap + subH
val fullW = normalW * 2 + tileGap
private fun buildRows(s: HudMetrics.Snapshot) {
val st = size.style
val pad = sp(st.pad); val lineGap = sp(st.lineGap); val lvGap = sp(st.labelGap)
val gutter = sp(if (st.gutter > 0f) st.gutter else 14f)
val unitPx = sp(if (st.unit > 0f) st.unit else st.row * 0.62f)
val basePx = sp(if (st.sub > 0f) st.sub else st.row)
var x = pad; var y = pad; var col = 0
fun place(t: Tile, tx: Float, ty: Float, tw: Float) {
tileRects.add(RectF(tx, ty, tx + tw, ty + tileH))
var by = ty + innerPad - ascent(keyPx)
placeRun(tx + innerPad, by, listOf(Span(t.key, t.keyColor, keyPx)))
by = ty + innerPad + keyH + lineGap - ascent(valPx)
placeRun(tx + innerPad, by, t.value)
if (t.sub != null) {
by = ty + innerPad + keyH + lineGap + valH + lineGap - ascent(subPx)
placeRun(tx + innerPad, by, listOf(Span(t.sub, colDim, subPx)))
val keys = size.rowsIn(storedOrder).filter { switchOn(it) }
if (keys.isEmpty()) { contentW = 0f; contentH = 0f; return }
val hero = (size == DroidDeckHudSize.PILL || size == DroidDeckHudSize.MINIMAL) && keys.firstOrNull() == "showFPS"
val tiles = size == DroidDeckHudSize.TILES
val bigPx = sp(st.row); val bigUnitPx = sp(st.unit)
val heroSpans = listOf(
Span(fpsText(fpsNow), colValue, bigPx, glow = true),
Span("fps", colDim, bigUnitPx),
)
val listed = keys.filter { !hero || it != "showFPS" }.flatMap { key ->
val labelPx = if (tiles) sp(st.key) else basePx
val valuePx = if (tiles) sp(st.row) else basePx
if (key == "showPerCore" && size == DroidDeckHudSize.MEGA)
perCoreRows(s, labelPx, valuePx, unitPx)
else listOf(reading(key, s, labelPx, valuePx, unitPx))
}
val maxCols = if (size == DroidDeckHudSize.MEGA) 3 else 2
val cols = when {
listed.size >= 9 -> maxCols
listed.size >= 4 -> minOf(2, maxCols)
else -> 1
}
if (tiles) {
val innerPad = sp(st.innerPad); val tileGap = sp(st.tileGap)
val keyH = lineH(sp(st.key)); val valH = lineH(sp(st.row))
val cellW = listed.maxOf { max(measure(it.label.text, it.label.sizePx), runWidth(it.vals)) } + innerPad * 2f
val graphMin = if (listed.any { it.key == "showFPSGraph" }) sp(GRAPH_MIN_WIDTH_SP) else 0f
val cellMin = graphMin + innerPad * 2f
val cellH = innerPad * 2f + keyH + lineGap + valH
for ((i, r) in listed.withIndex()) {
val x = pad + (i % cols) * (cellW + tileGap)
val y = pad + (i / cols) * (cellH + tileGap)
tileRects.add(RectF(x, y, x + cellW, y + cellH))
if (r.key == "showFPSGraph") {
graphRect = RectF(x + innerPad, y + innerPad, x + max(cellW, cellMin) - innerPad, y + cellH - innerPad)
continue
}
placeRun(x + innerPad, y + innerPad - ascent(r.label.sizePx), listOf(r.label))
placeRun(x + innerPad, y + innerPad + keyH + lineGap - ascent(sp(st.row)), r.vals)
}
}
for (t in tiles) {
if (t.wide) {
if (col != 0) { y += tileH + tileGap; col = 0; x = pad }
place(t, pad, y, fullW)
y += tileH + tileGap; col = 0; x = pad
} else {
place(t, x, y, normalW)
col++; x += normalW + tileGap
if (col == 2) { col = 0; x = pad; y += tileH + tileGap }
val lines = (listed.size + cols - 1) / cols
contentW = pad + cols * (cellW + tileGap) - tileGap + pad
contentH = pad + lines * (cellH + tileGap) - tileGap + pad
} else {
val columns = (0 until cols).map { c -> listed.filterIndexed { i, _ -> i % cols == c } }
val labelW = columns.map { col -> col.maxOfOrNull { measure(it.label.text, it.label.sizePx) } ?: 0f }
val colW = columns.mapIndexed { c, col ->
val body = if (col.isEmpty()) 0f else labelW[c] + lvGap + (col.maxOfOrNull { runWidth(it.vals) } ?: 0f)
val graph = if (col.any { it.key == "showFPSGraph" }) sp(GRAPH_MIN_WIDTH_SP) + labelW[c] + lvGap else 0f
max(body, graph)
}
val gaps = (0 until cols).count { columns[it].isNotEmpty() }.coerceAtLeast(1) - 1
val bodyW = colW.sum() + gutter * gaps
var bodyH = 0f
for (col in columns) {
var y = 0f
for (r in col) y += rowHeight(r) + lineGap
if (col.isNotEmpty()) bodyH = max(bodyH, y - lineGap)
}
val heroW = if (hero) runWidth(heroSpans) else 0f
val heroH = if (hero) lineH(bigPx) else 0f
val x0 = pad + if (hero && listed.isNotEmpty()) heroW + gutter else 0f
val top = pad + (max(bodyH, heroH) - bodyH) / 2f
var x = x0
for (c in 0 until cols) {
if (columns[c].isEmpty()) continue
var y = top
for (r in columns[c]) {
if (r.key == "showFPSGraph") {
val left = x + labelW[c] + lvGap
graphRect = RectF(left, y, max(x + colW[c], left + sp(GRAPH_MIN_WIDTH_SP)), y + sp(GRAPH_HEIGHT_SP))
y += sp(GRAPH_HEIGHT_SP) + lineGap
continue
}
val px = maxOf(r.label.sizePx, r.vals.maxOfOrNull { it.sizePx } ?: 0f)
val baseline = y - ascent(px)
placeRun(x, baseline, listOf(r.label))
placeRun(x + labelW[c] + lvGap, baseline, r.vals)
y += lineH(px) + lineGap
}
x += colW[c] + gutter
}
if (hero) {
val baseline = pad + (max(bodyH, heroH) - heroH) / 2f - ascent(bigPx)
placeRun(pad, baseline, heroSpans, glow = true)
}
contentW = max(x0 + bodyW, pad + heroW) + pad
contentH = pad + max(bodyH, heroH) + pad
}
if (col != 0) y += tileH + tileGap
if (showFPS && showGraph) {
graphRect = RectF(pad, y, pad + fullW, y + sp(22f))
y += sp(22f) + tileGap
}
contentW = pad + fullW + pad
contentH = y + (pad - tileGap)
addSubtleClock(pad)
}
private fun buildPill(s: HudMetrics.Snapshot) {
val bigPx = sp(30f); val bigUnitPx = bigPx * 0.36f; val stkPx = sp(11.5f)
val pad = sp(10f); val midGap = sp(12f); val stkLineGap = sp(3f)
val left = ArrayList<Span>()
val generating = differs(fpsNow)
val fpsPx = if (generating) bigPx * 0.55f else bigPx
if (showFPS) {
left += Span(fpsText(fpsNow), colValue, fpsPx, glow = true)
left += Span("fps", colDim, if (generating) bigUnitPx * 0.8f else bigUnitPx)
} else if (showBatteryTime) left += Span(s.battery.runtimeText ?: "TIME —", colBat, bigPx * 0.8f)
private fun rowHeight(r: HudRow): Float =
if (r.key == "showFPSGraph") sp(GRAPH_HEIGHT_SP)
else lineH(maxOf(r.label.sizePx, r.vals.maxOfOrNull { it.sizePx } ?: 0f))
val stack = ArrayList<List<Span>>()
val gpuName = if (showGpuModel && gpuNameText().isNotBlank()) gpuModelSpans(stkPx, colDim, compact = true) else null
run {
val l = ArrayList<Span>()
if (showGPU && s.gpuPercent != null) l += Span("GPU ${s.gpuPercent}%", colGpu, stkPx)
if (showCPU) { if (l.isNotEmpty()) l += Span(" · ", colDim, stkPx); l += Span("CPU ${s.cpuPercent ?: "—"}%", colCpu, stkPx) }
if (l.isNotEmpty()) stack.add(l)
private fun perCoreRows(s: HudMetrics.Snapshot, labelPx: Float, valuePx: Float, unitPx: Float): List<HudRow> {
val pct = s.perCorePercent
val clk = s.perCoreClockMhz
return (0 until max(pct.size, clk.size)).map { i ->
val vals = ArrayList<Span>()
vals += numUnit(if (i < pct.size && pct[i] >= 0) pct[i].toString() else null, "%", valuePx, unitPx)
vals += Span(" ", colDim, unitPx)
vals += numUnit(if (i < clk.size && clk[i] > 0) clk[i].toString() else null, "MHz", valuePx, unitPx)
HudRow("showPerCore", Span("C$i", colCpu, labelPx), vals)
}
if (showRAM) stack.add(listOf(Span("RAM ${s.ramPercent.roundToInt()}%", colRam, stkPx)))
if (showBattery || showPower || showBatteryTemp) {
val l = ArrayList<Span>()
fun part(spans: List<Span>) { l += if (l.isEmpty()) Span("BAT ", colBat, stkPx) else Span(" · ", colDim, stkPx); l += spans }
if (showBattery && s.battery.percent != null) part(listOf(Span("${s.battery.percent}%", colBat, stkPx)))
if (showBatteryTemp && s.battery.tempC != null) part(tempSpans(s.battery.tempC, HudMetrics.TempSensor.BATTERY, stkPx, stkPx * 0.62f))
if (showPower && s.battery.watts > 0f) part(listOf(Span("${fmt1(s.battery.watts)}W", colDim, stkPx)))
if (l.isNotEmpty()) stack.add(l)
}
if (showBatteryTime) stack.add(listOf(Span("BAT TIME ${s.battery.runtimeText ?: "—"}", colBat, stkPx)))
run {
val l = ArrayList<Span>()
if (showFPS) l += Span("${fmt1(1000f / max(fpsNow, 1f))}ms", colDim, stkPx)
if (showFPS && displayServer.isNotBlank()) { l += Span(" · ", colDim, stkPx); l += Span(displayServer, colDisp, stkPx) }
else if (displayServer.isNotBlank()) l += Span(displayServer, colDisp, stkPx)
if (showVram && s.vramText() != null) { if (l.isNotEmpty()) l += Span(" · ", colDim, stkPx); l += Span("${s.vramText()} vram", colDim, stkPx) }
if (l.isNotEmpty()) stack.add(l)
}
if (hdrState != DroidDeckHudHdr.NONE) stack.add(hdrLine(stkPx))
var statsW = 0f
for (l in stack) statsW = max(statsW, runWidth(l))
val nameOnTop = gpuName != null && runWidth(gpuName) > statsW
if (gpuName != null && !nameOnTop) stack.add(0, gpuName)
val apiStr = apiLabel()
val hasApi = showFPS && apiStr != "FPS"
val apiH = if (hasApi) lineH(stkPx) else 0f
val apiGap = if (hasApi) stkLineGap else 0f
val leftW = runWidth(left); val leftH = if (left.isEmpty()) 0f else lineH(bigPx)
val apiW = if (hasApi) measure(apiStr, stkPx) else 0f
val leftBlockW = max(leftW, apiW)
val leftColH = apiH + apiGap + leftH
val stkH = lineH(stkPx)
var stackW = 0f
for (l in stack) stackW = max(stackW, runWidth(l))
val stackTotalH = stack.size * stkH + (stack.size - 1).coerceAtLeast(0) * stkLineGap
val innerH = max(leftColH, stackTotalH)
val topLineH = if (nameOnTop) stkH + stkLineGap else 0f
contentW = pad + leftBlockW + midGap + stackW + pad
contentH = pad + topLineH + innerH + pad
var ly = pad + topLineH + (innerH - leftColH) / 2f
if (hasApi) { placeRun(pad, ly - ascent(stkPx), listOf(Span(apiStr, colFps, stkPx))); ly += apiH + apiGap }
if (left.isNotEmpty()) placeRun(pad, ly - ascent(bigPx), left)
var sy = pad + topLineH + (innerH - stackTotalH) / 2f
for (l in stack) { placeRun(pad + leftBlockW + midGap, sy - ascent(stkPx), l); sy += stkH + stkLineGap }
addSubtleClock(pad, leftAligned = true)
if (nameOnTop && gpuName != null) { val end = placeRun(pad, pad - ascent(stkPx), gpuName); contentW = max(contentW, end + pad) }
}
private fun buildMinimal(s: HudMetrics.Snapshot) {
val bigPx = sp(34f); val bigUnitPx = bigPx * 0.32f; val subPx = sp(11.5f); val footPx = sp(9.5f)
val stroke = outlineWidth()
val left = contentLeft()
val inner = panelInset() + stroke
val runtime = if (showBatteryTime) s.battery.runtimeText ?: "TIME —" else null
val minGenerating = differs(fpsNow)
val big = when {
showFPS -> listOf(Span(fpsText(fpsNow), colValue, if (minGenerating) bigPx * 0.55f else bigPx), Span("fps", colDim, if (minGenerating) bigUnitPx * 0.8f else bigUnitPx))
runtime != null -> listOf(Span(runtime, colBat, sp(24f)))
else -> emptyList()
}
val sub = ArrayList<Span>()
fun low(label: String, value: Float) {
if (sub.isNotEmpty()) sub += Span(" · ", colDim, subPx)
sub += Span("$label ", colDim, subPx)
sub += Span(lowText(value) ?: "—", colFps, subPx)
}
if (showFPS && showLow1) low("1%", lows.low1Fps)
if (showFPS && showLow01) low("0.1%", lows.low01Fps)
if (showFPS && showLow001) low("0.01%", lows.low001Fps)
if (showBatteryTime) {
if (sub.isNotEmpty()) sub += Span(" · ", colDim, subPx)
sub += Span("BAT TIME ", colBat, subPx)
sub += Span(s.battery.runtimeText ?: "—", colBat, subPx)
}
val footerLabel = listOf(if (showFPS && showEngine) engineLabel else "", if (showFPS) displayServer else "").filter { it.isNotBlank() }.joinToString(" · ")
val hdr = if (hdrState != DroidDeckHudHdr.NONE) hdrLine(footPx) else emptyList()
val (headerBottom, headerRight) = addPanelHeader(left, inner)
val colW = maxOf(runWidth(big), runWidth(sub), headerRight - left, max(measure(footerLabel, footPx), runWidth(hdr)), if (showFPS && showGraph) sp(120f) else 0f)
var last = headerBottom + sp(8f)
if (big.isNotEmpty()) { last += capHeight(big[0].sizePx); placeRun(left - inkLeft(big[0].text, big[0].sizePx), last, big, glow = showFPS) }
if (sub.isNotEmpty()) { last += sp(10f) + capHeight(subPx); placeRun(left - inkLeft(sub[0].text, subPx), last, sub) }
if (showFPS && showGraph) { val top = last + sp(9f); graphRect = RectF(left, top, left + colW, top + sp(24f)); last = top + sp(24f) }
if (footerLabel.isNotBlank()) { val base = last + sp(8f) + capHeight(footPx); glyphs.add(Glyph(left - inkLeft(footerLabel, footPx), base, footerLabel, blend(colDim), footPx)); last = base }
if (hdr.isNotEmpty()) { val base = last + sp(6f) + capHeight(footPx); placeRun(left - inkLeft(hdr[0].text, footPx), base, hdr); last = base }
measurePaint.textSize = footPx
finishPanel(RectF(panelLeft(), panelInset(), left + colW + sp(34f), last + measurePaint.fontMetrics.descent + sp(9f) + stroke), halfRound = true)
}
private fun buildStrip(s: HudMetrics.Snapshot) {
@@ -1020,70 +941,28 @@ class DroidDeckHudView(context: Context) : View(context) {
right -= groupGap
}
if (showFPS) {
val generating = differs(fpsNow)
val fps = ArrayList<Span>()
if (apiLabel() != "FPS") fps += Span("${apiLabel()} ", colDim, rowPx)
fps += Span(fpsText(fpsNow), colValue, if (generating) fpsPx * 0.8f else fpsPx, glow = true)
fps += Span("fps", colDim, unitPx)
x = placeRun(x, baseline, fps) + groupGap
}
if (showFPS && showGraph) {
val gw = sp(72f); val gh = h * 0.55f
if (x + gw <= right) {
val generating = differs(fpsNow)
for (key in size.rowsIn(storedOrder)) {
if (!switchOn(key)) continue
if (key == "showFPSGraph") {
val gw = sp(72f); val gh = h * 0.55f
if (x + gw > right) break
graphRect = RectF(x, mid - gh / 2f, x + gw, mid + gh / 2f)
x += gw + groupGap
continue
}
}
val groups = ArrayList<List<Span>>()
run {
val l = ArrayList<Span>()
fun low(label: String, value: Float) {
if (l.isNotEmpty()) l += Span(" ", colDim, rowPx)
l += Span("$label ", colDim, rowPx)
l += Span(lowText(value) ?: "—", colFps, rowPx)
val spans = if (key == "showFPS") {
val fps = ArrayList<Span>()
if (apiLabel() != "FPS") fps += Span("${apiLabel()} ", colDim, rowPx)
fps += Span(fpsText(fpsNow), colValue, if (generating) fpsPx * 0.8f else fpsPx, glow = true)
fps += Span("fps", colDim, unitPx)
fps
} else {
val row = reading(key, s, rowPx, rowPx, unitPx)
listOf(row.label, Span(" ", colDim, rowPx)) + row.vals
}
if (showFPS && showLow1) low("1%", lows.low1Fps)
if (showFPS && showLow01) low("0.1%", lows.low01Fps)
if (showFPS && showLow001) low("0.01%", lows.low001Fps)
if (l.isNotEmpty()) groups += l
}
if (showGPU || showGpuTemp) {
val l = arrayListOf(Span("GPU", colGpu, rowPx))
if (showGPU) l += Span(" ${s.gpuPercent ?: "—"}%", colGpu, rowPx)
if (showGpuTemp && s.gpuTempC != null) { l += Span(" ", colDim, rowPx); l += tempSpans(s.gpuTempC, HudMetrics.TempSensor.GPU, rowPx, unitPx) }
groups += l
}
if (showCPU || showCpuTemp) {
val l = arrayListOf(Span("CPU", colCpu, rowPx))
if (showCPU) l += Span(" ${s.cpuPercent ?: "—"}%", colCpu, rowPx)
if (showCpuTemp && s.cpuTempC != null) { l += Span(" ", colDim, rowPx); l += tempSpans(s.cpuTempC, HudMetrics.TempSensor.CPU, rowPx, unitPx) }
groups += l
}
if (showVram) s.vramText()?.let { groups += listOf(Span("VRAM $it", colVram, rowPx)) }
if (showRAM) groups += listOf(Span("RAM ${s.ramPercent.roundToInt()}%", colRam, rowPx))
if (showBattery || showPower || showBatteryTemp) {
val l = ArrayList<Span>()
fun part(spans: List<Span>) {
l += if (l.isEmpty()) Span("BAT ", colBat, rowPx) else Span(" ", colDim, rowPx)
l += spans
}
if (showBattery && s.battery.percent != null) part(listOf(Span("${s.battery.percent}%", colBat, rowPx)))
if (showBatteryTemp && s.battery.tempC != null)
part(tempSpans(s.battery.tempC, HudMetrics.TempSensor.BATTERY, rowPx, unitPx))
if (showPower && s.battery.watts > 0f) part(listOf(Span("${fmt1(s.battery.watts)}W", colDim, rowPx)))
if (l.isNotEmpty()) groups += l
}
if (showBatteryTime) groups += listOf(Span("BAT TIME ${s.battery.runtimeText ?: "—"}", colBat, rowPx))
if (displayServer.isNotBlank()) groups += listOf(Span(displayServer, colDisp, rowPx))
if (hdrState != DroidDeckHudHdr.NONE) groups += hdrLine(rowPx)
if (showGpuModel && gpuNameText().isNotBlank()) groups += gpuModelSpans(rowPx, colDim, compact = true)
for (g in groups) {
if (x + runWidth(g) > right) break
x = placeRun(x, baseline, g) + groupGap
if (x + runWidth(spans) > right) break
x = placeRun(x, baseline, spans) + groupGap
}
stripRect = RectF(0f, 0f, w, h)
@@ -1103,169 +982,6 @@ class DroidDeckHudView(context: Context) : View(context) {
return inkRect.left.toFloat()
}
private fun layoutColumn(rows: List<HudRow>, x: Float, y0: Float,
rowPx: Float, lineGap: Float, lvGap: Float): Pair<Float, Float> {
if (rows.isEmpty()) return Pair(y0, x)
var labelCol = 0f
for (r in rows) if (!r.inline) labelCol = max(labelCol, measure(r.label.text, rowPx))
val h = lineH(rowPx); val asc = ascent(rowPx)
var y = y0; var right = x
for (r in rows) {
val baseline = y - asc
placeRun(x, baseline, listOf(r.label))
val valX = if (r.inline) x + measure(r.label.text, rowPx) + lvGap
else x + labelCol + lvGap
val end = placeRun(valX, baseline, r.vals)
right = max(right, end)
y += h + lineGap
}
return Pair(y - lineGap, right)
}
private fun layoutWrap(fragments: List<List<Span>>, x: Float, y0: Float, maxWidth: Float,
px: Float, lineGap: Float): Pair<Float, Float> {
if (fragments.isEmpty()) return Pair(y0, x)
val h = lineH(px); val asc = ascent(px)
val sepW = measure(" · ", px)
var cx = x; var y = y0; var right = x; var firstOnLine = true
for (frag in fragments) {
val w = runWidth(frag)
if (!firstOnLine && (cx + sepW + w - x) > maxWidth) { y += h + lineGap; cx = x; firstOnLine = true }
if (!firstOnLine) { placeRun(cx, y - asc, listOf(Span(" · ", colDim, px))); cx += sepW }
val end = placeRun(cx, y - asc, frag)
cx = end; right = max(right, end); firstOnLine = false
}
return Pair(y + h, right)
}
private fun buildMega(s: HudMetrics.Snapshot) {
val rowPx = sp(11.5f); val unitPx = rowPx * 0.62f; val bandPx = sp(9.5f)
val pad = sp(10f); val lineGap = sp(3.5f); val lvGap = sp(7f); val gutter = sp(16f)
val left = ArrayList<HudRow>()
if (showGpuModel && gpuNameText().isNotBlank())
left.add(HudRow(Span("GPU", colGpu, rowPx), gpuModelSpans(rowPx, colValue)))
if (showGPU && hasGpuStats(s)) {
val v = ArrayList<Span>()
v += numUnit(s.gpuPercent?.toString(), "%", rowPx, unitPx)
if (showGpuTemp) tempSpans(s.gpuTempC, HudMetrics.TempSensor.GPU, rowPx, unitPx)
.let { if (it.isNotEmpty()) { v += gap(unitPx); v += it } }
v += gap(unitPx); v += numUnit(s.gpuClockMhz?.toString(), "MHz", rowPx, unitPx)
left.add(HudRow(Span("GPU", colGpu, rowPx), v))
}
if (showCPU) {
val v = ArrayList<Span>()
v += numUnit(s.cpuPercent?.toString(), "%", rowPx, unitPx)
v += gap(unitPx); v += numUnit(s.cpuClockMhz?.toString(), "MHz", rowPx, unitPx)
if (showCpuTemp) tempSpans(s.cpuTempC, HudMetrics.TempSensor.CPU, rowPx, unitPx)
.let { if (it.isNotEmpty()) { v += gap(unitPx); v += it } }
left.add(HudRow(Span("CPU", colCpu, rowPx), v))
}
if (showPerCore) {
val pct = s.perCorePercent; val clk = s.perCoreClockMhz
val n = max(pct.size, clk.size)
for (i in 0 until n) {
val v = ArrayList<Span>()
v += numUnit(if (i < pct.size && pct[i] >= 0) pct[i].toString() else null, "%", rowPx, unitPx)
v += gap(unitPx)
v += numUnit(if (i < clk.size && clk[i] > 0) clk[i].toString() else null, "MHz", rowPx, unitPx)
left.add(HudRow(Span("C$i", colCpu, rowPx), v))
}
}
val right = ArrayList<HudRow>()
if (showVram && s.vramText() != null)
right.add(HudRow(Span("VRAM", colVram, rowPx), valueUnit(s.vramText()!!, rowPx, unitPx)))
if (showRAM) {
val v = ArrayList<Span>()
v += valueUnit(s.ramUsedText(), rowPx, unitPx)
v += Span("/", colDim, unitPx); v += valueUnit(s.ramTotalText(), rowPx, unitPx)
v += gap(unitPx); v += numUnit(s.ramPercent.roundToInt().toString(), "%", rowPx, unitPx)
right.add(HudRow(Span("RAM", colRam, rowPx), v))
}
if (showSwap && s.swapUsedText() != null) {
val v = ArrayList<Span>()
v += valueUnit(s.swapUsedText()!!, rowPx, unitPx)
s.swapTotalText()?.let { v += Span("/", colDim, unitPx); v += valueUnit(it, rowPx, unitPx) }
right.add(HudRow(Span("SWP", colRam, rowPx), v))
}
if (showNet && s.netDownBps != null) {
val d = (s.netDownBps ?: 0L) / 1024L
val u = (s.netUpBps ?: 0L) / 1024L
val v = ArrayList<Span>()
v += Span("↓", colDim, unitPx); v += Span(d.toString(), colValue, rowPx)
v += Span(" ↑", colDim, unitPx); v += Span(u.toString(), colValue, rowPx)
v += Span("KB/s", colDim, unitPx)
right.add(HudRow(Span("NET", colFps, rowPx), v))
}
if (showBattery || showPower || showBatteryTemp) {
val v = ArrayList<Span>(); var any = false
if (showBattery && s.battery.percent != null) { v += numUnit(s.battery.percent.toString(), "%", rowPx, unitPx); any = true }
if (showBatteryTemp) tempSpans(s.battery.tempC, HudMetrics.TempSensor.BATTERY, rowPx, unitPx)
.let { if (it.isNotEmpty()) { if (any) v += gap(unitPx); v += it; any = true } }
if (showPower && s.battery.watts > 0f) { if (any) v += gap(unitPx); v += numUnit(fmt1(s.battery.watts), "W", rowPx, unitPx); any = true }
if (any) right.add(HudRow(Span("BAT", colBat, rowPx), v))
}
if (showBatteryTime) right.add(HudRow(Span("TIME", colBat, rowPx), listOf(Span(s.battery.runtimeText ?: "—", colValue, rowPx))))
if (showFPS) {
val v = ArrayList<Span>()
v += glowing(numUnit(fpsText(fpsNow), "FPS", rowPx, unitPx))
v += gap(unitPx); v += numUnit(fmt1(1000f / max(fpsNow, 1f)), "ms", rowPx, unitPx)
right.add(HudRow(Span(apiLabel(), colFps, rowPx), v))
right.add(HudRow(Span("AVG", colLo, rowPx), numUnit(fmt1(fpsAvg), "FPS", rowPx, unitPx)))
if (showLow1)
right.add(HudRow(Span("1%", colLo, rowPx), numUnit(lowText(lows.low1Fps), "FPS", rowPx, unitPx)))
if (showLow01)
right.add(HudRow(Span("0.1%", colLo, rowPx), numUnit(lowText(lows.low01Fps), "FPS", rowPx, unitPx)))
if (showLow001)
right.add(HudRow(Span("0.01%", colLo, rowPx), numUnit(lowText(lows.low001Fps), "FPS", rowPx, unitPx)))
}
val (leftBottom, leftRight) = layoutColumn(left, pad, pad, rowPx, lineGap, lvGap)
val rightX = (if (left.isEmpty()) pad else leftRight + gutter)
val (rightBottom, rightRight) = layoutColumn(right, rightX, pad, rowPx, lineGap, lvGap)
var y = max(leftBottom, rightBottom)
var maxRight = max(leftRight, rightRight)
val band = ArrayList<List<Span>>()
if (showResolution) band.add(listOf(Span("RES ", colDim, bandPx), Span(resolutionString(), colValue, bandPx)))
if (displayServer.isNotBlank()) band.add(listOf(Span("DISP ", colDim, bandPx), Span(displayServer, colDisp, bandPx)))
if (hdrState != DroidDeckHudHdr.NONE) band.add(listOf(Span("HDR ", colDim, bandPx)) + hdrValue(bandPx))
if (showProton && wineVersion.isNotBlank()) band.add(listOf(Span(wineVersion, colVram, bandPx)))
if (showSession) band.add(listOf(Span("elapsed ", colDim, bandPx), Span(elapsedString(), colValue, bandPx)))
if (band.isNotEmpty()) {
y += sp(4f)
val (bBottom, bRight) = layoutWrap(band, pad, y, max(maxRight - pad, sp(180f)), bandPx, lineGap)
y = bBottom; maxRight = max(maxRight, bRight)
}
if (showGraph) {
y += sp(3f)
val gh = sp(22f)
val gr = max(maxRight, pad + sp(220f))
graphRect = RectF(pad, y, gr, y + gh)
maxRight = max(maxRight, gr)
y += gh
}
val dxLine = dxVersionLabeled()
val hasDx = showDxVer && dxLine.isNotBlank()
if (hasDx) {
y += sp(4f)
maxRight = max(maxRight, placeRun(pad, y - ascent(bandPx), listOf(Span(dxLine, colDim, bandPx))))
y += lineH(bandPx)
}
if (showWrapper && graphicsWrapper.isNotBlank()) {
y += if (hasDx) sp(1f) else sp(4f)
maxRight = max(maxRight, placeRun(pad, y - ascent(bandPx), listOf(Span(graphicsWrapper, colDim, bandPx))))
y += lineH(bandPx)
}
contentW = maxRight + pad
contentH = y + pad
addSubtleClock(pad)
}
override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
if (stripRect != null) { setMeasuredDimension(contentW.roundToInt(), resolveSize(contentH.roundToInt(), heightMeasureSpec)); return }
setMeasuredDimension(
@@ -1546,6 +1262,8 @@ class DroidDeckHudView(context: Context) : View(context) {
const val MIN_SCALE = 0.5f
const val MAX_SCALE = 2f
const val GRAPH_CLIP_MS = 49.9f
const val GRAPH_HEIGHT_SP = 22f
const val GRAPH_MIN_WIDTH_SP = 160f
fun parseIntOr(s: String?, d: Int): Int = try { s?.trim()?.toInt() ?: d } catch (e: Exception) { d }
@@ -301,6 +301,9 @@ internal fun rememberShown(onDismiss: () -> Unit): MutableTransitionState<Boolea
return shown
}
private val DIALOG_MARGIN = 12.dp
private val SIDE_GAP = 24.dp
@Composable
internal fun AppDialog(
shown: MutableTransitionState<Boolean>, close: () -> Unit, label: String, wide: Boolean,
@@ -309,17 +312,23 @@ internal fun AppDialog(
back: (() -> Unit)? = null,
scrollable: Boolean = true,
scrollState: androidx.compose.foundation.ScrollState = rememberScrollState(),
side: (@Composable () -> Unit)? = null,
sideRoom: Dp = 0.dp,
content: @Composable ColumnScope.() -> Unit,
) {
val pal = LocalPalette.current
val panelCap = maxWidth ?: if (wide) 860.dp else 560.dp
VeilRing()
Dialog(onDismissRequest = back ?: close, properties = DialogProperties(usePlatformDefaultWidth = false, decorFitsSystemWindows = false)) {
CompositionLocalProvider(LocalFrontFocus provides null) {
Box(
BoxWithConstraints(
contentAlignment = Alignment.Center,
modifier = Modifier.fillMaxSize().imePadding()
.tapOutside(close),
) {
val panel = (this.maxWidth - DIALOG_MARGIN * 2).coerceAtMost(panelCap)
val free = (this.maxWidth - panel) / 2 - SIDE_GAP
val beside = side != null && free >= sideRoom
AnimatedVisibility(
visibleState = shown,
enter = fadeIn(Motion.tw(180)) + scaleIn(Motion.sp(0.7f), initialScale = 0.94f),
@@ -329,8 +338,8 @@ internal fun AppDialog(
Column(
verticalArrangement = Arrangement.spacedBy(14.dp),
modifier = Modifier
.padding(12.dp)
.widthIn(max = maxWidth ?: if (wide) 860.dp else 560.dp)
.padding(DIALOG_MARGIN)
.widthIn(max = panelCap)
.then(
when {
width != null -> Modifier.width(width)
@@ -348,8 +357,21 @@ internal fun AppDialog(
.then(modifier)
.then(if (scrollable) Modifier.verticalScroll(scrollState) else Modifier)
.padding(horizontal = 18.dp, vertical = 16.dp),
content = content,
)
) {
content()
if (side != null && !beside) side()
}
}
if (side != null && beside) {
AnimatedVisibility(
visibleState = shown,
enter = fadeIn(Motion.tw(180)),
exit = fadeOut(Motion.tw(140)),
modifier = Modifier.align(Alignment.CenterEnd).padding(end = SIDE_GAP),
label = "$label-side",
) {
Box(Modifier.widthIn(max = free).blockTouches()) { side() }
}
}
}
}
@@ -1,5 +1,7 @@
package com.droiddeck.launcher.ui
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
@@ -8,7 +10,9 @@ import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.unit.sp
import com.droiddeck.launcher.R
import com.droiddeck.launcher.hud.DroidDeckHudConfig
import com.droiddeck.launcher.hud.DroidDeckHudSize
import com.droiddeck.launcher.session.SessionPrefs
import com.droiddeck.launcher.session.StripMetric
@@ -55,30 +59,34 @@ internal fun DroidDeckHudSettings(host: MenuHost, a: DrawerActions, track: (Stri
ChoiceRow(host, "hud-outline-color", stringResource(R.string.hud_outline_color), null,
listOf("0" to stringResource(R.string.hud_outline_gray), "1" to stringResource(R.string.hud_outline_theme)),
if (cfg["hudOutlineAccent"] == "0") "0" else "1", chipModifier = track("hud-outline-color")) { a.onHudSetting("hudOutlineAccent", it) }
ToggleRow(host, "hud-fps-decimal", stringResource(R.string.hud_metric_decimal), null, on("fpsDecimal"),
chipModifier = track("hud-fps-decimal")) { a.onHudSetting("fpsDecimal", flag(it)) }
ToggleRow(host, "hud-clock", stringResource(R.string.hud_metric_clock), null, on("showClock"),
chipModifier = track("hud-clock")) { a.onHudSetting("showClock", flag(it)) }
ToggleRow(host, "hud-graph", stringResource(R.string.hud_metric_graph), null, on("showFPSGraph"),
chipModifier = track("hud-graph")) { a.onHudSetting("showFPSGraph", flag(it)) }
}
val size = DroidDeckHudSize.from(cfg["hudSize"])
val chips = size.supportedChips() + EXTRA[size].orEmpty()
var editing by remember { mutableStateOf(false) }
SettingsGroup(stringResource(R.string.hud_group_metrics)) {
for (metric in METRICS) {
if (metric.chip !in chips || metric.chip in HIDDEN[size].orEmpty()) continue
ToggleRow(host, "hud-${metric.key}", stringResource(metric.label), null, on(metric.key),
chipModifier = track("hud-${metric.key}")) { a.onHudSetting(metric.key, flag(it)) }
if (metric.key == "showBattery" && size != DroidDeckHudSize.MINIMAL) {
ToggleRow(host, "hud-showBatteryTime", stringResource(R.string.hud_metric_battery_time), null, on("showBatteryTime"),
chipModifier = track("hud-showBatteryTime")) { a.onHudSetting("showBatteryTime", flag(it)) }
}
}
if (size == DroidDeckHudSize.MINIMAL && "Battery time" in chips &&
"Battery time" !in HIDDEN[size].orEmpty()) {
ToggleRow(host, "hud-showBatteryTime", stringResource(R.string.hud_metric_battery_time), null, on("showBatteryTime"),
chipModifier = track("hud-showBatteryTime")) { a.onHudSetting("showBatteryTime", flag(it)) }
ActionRow(stringResource(R.string.hud_group_metrics), null, stringResource(R.string.common_edit),
onClick = { editing = true }, modifier = track("hud-readings"))
val rows = DroidDeckHudSize.rowsFor(DroidDeckHudSize.from(cfg["hudSize"]), cfg)
SettingsRow(stringResource(R.string.hud_readings_shown), null) {
Text(stringResource(R.string.hud_readings_count, rows.count { on(it) }, rows.size),
fontSize = 13.sp, color = MaterialTheme.colorScheme.onSurfaceVariant)
}
if (editing) HudReadingsDialog(
visible = rows,
initialOrder = rows,
initialOn = rows.associateWith { on(it) },
onDismiss = { editing = false },
onSave = { switches, order -> a.onHudOrder(switches, order) },
onReset = a.onHudOrderReset,
)
}
val tempsShown = ("Temp" in chips && on("showTemp")) || ("GPU temp" in chips && on("showGpuTemp"))
if (tempsShown) SettingsGroup(stringResource(R.string.hud_group_temps)) {
if (on("showTemp") || on("showGpuTemp") || on("showBatteryTemp")) SettingsGroup(stringResource(R.string.hud_group_temps)) {
ChoiceRow(host, "hud-temp-unit", stringResource(R.string.hud_temp_unit), null,
listOf("c" to "°C", "f" to "°F"), if (cfg["tempUnit"].equals("f", true)) "f" else "c",
chipModifier = track("hud-temp-unit")) { a.onHudSetting("tempUnit", it) }
@@ -155,37 +163,39 @@ private val BOTTOM_STRIP_ROWS = listOf(
StripMetric.CLOCK to R.string.hud_metric_clock,
)
private val EXTRA = mapOf(DroidDeckHudSize.PILL to setOf("Temp", "Power"))
private class HudMetric(val chip: String, val key: String, val label: Int)
private class HudMetric(val key: String, val label: Int)
// Wrapper and DX version have nothing to show in DroidDeck.
private val METRICS = listOf(
HudMetric("FPS", "showFPS", R.string.drawer_hud_fps),
HudMetric("FPS graph", "showFPSGraph", R.string.hud_metric_graph),
HudMetric("FPS .1", "fpsDecimal", R.string.hud_metric_decimal),
HudMetric("1% low", "showLow1", R.string.hud_metric_low1),
HudMetric("0.1% low", "showLow01", R.string.hud_metric_low01),
HudMetric("0.01% low", "showLow001", R.string.hud_metric_low001),
HudMetric("Engine", "showEngine", R.string.hud_metric_engine),
HudMetric("GPU model", "showGpuModel", R.string.hud_metric_gpu_model),
HudMetric("GPU", "showGPULoad", R.string.hud_metric_gpu),
HudMetric("GPU temp", "showGpuTemp", R.string.hud_metric_gpu_temp),
HudMetric("CPU", "showCPUUsage", R.string.hud_metric_cpu),
HudMetric("Per-core", "showPerCore", R.string.hud_metric_per_core),
HudMetric("Temp", "showTemp", R.string.hud_metric_temp),
HudMetric("RAM", "showRAM", R.string.hud_metric_ram),
HudMetric("VRAM", "showVram", R.string.hud_metric_vram),
HudMetric("Swap", "showSwap", R.string.hud_metric_swap),
HudMetric("Battery", "showBattery", R.string.hud_metric_battery),
HudMetric("Power", "showPower", R.string.hud_metric_power),
HudMetric("Network", "showNet", R.string.hud_metric_network),
HudMetric("Resolution", "showResolution", R.string.hud_metric_resolution),
HudMetric("Proton", "showProton", R.string.hud_metric_proton),
HudMetric("Session", "showSession", R.string.hud_metric_session),
HudMetric("Clock", "showClock", R.string.hud_metric_clock),
HudMetric("showGpuModel", R.string.hud_metric_gpu_model),
HudMetric("showGPULoad", R.string.hud_metric_gpu),
HudMetric("showCPUUsage", R.string.hud_metric_cpu),
HudMetric("showPerCore", R.string.hud_metric_per_core),
HudMetric("showTemp", R.string.hud_metric_temp),
HudMetric("showBatteryTemp", R.string.drawer_hud_battery),
HudMetric("showGpuTemp", R.string.hud_metric_gpu_temp),
HudMetric("showVram", R.string.hud_metric_vram),
HudMetric("showRAM", R.string.hud_metric_ram),
HudMetric("showSwap", R.string.hud_metric_swap),
HudMetric("showBattery", R.string.hud_metric_battery),
HudMetric("showBatteryTime", R.string.hud_metric_battery_time),
HudMetric("showPower", R.string.hud_metric_power),
HudMetric("showFPS", R.string.drawer_hud_fps),
HudMetric("showFPSGraph", R.string.hud_metric_graph),
HudMetric("showLatency", R.string.hud_metric_latency),
HudMetric("showAvg", R.string.hud_metric_avg),
HudMetric("showLow1", R.string.hud_metric_low1),
HudMetric("showLow01", R.string.hud_metric_low01),
HudMetric("showLow001", R.string.hud_metric_low001),
HudMetric("showEngine", R.string.hud_metric_engine),
HudMetric("showDisplay", R.string.hud_metric_display),
HudMetric("showHdr", R.string.hud_metric_hdr),
HudMetric("showNet", R.string.hud_metric_network),
HudMetric("showResolution", R.string.hud_metric_resolution),
HudMetric("showProton", R.string.hud_metric_proton),
HudMetric("showSession", R.string.hud_metric_session),
HudMetric("showClock", R.string.hud_metric_clock),
)
private val HIDDEN = mapOf(
DroidDeckHudSize.PILL to setOf("FPS graph"),
DroidDeckHudSize.TILES to setOf("FPS graph", "0.1% low", "0.01% low"),
)
internal fun hudMetricLabel(key: String): Int? =
METRICS.firstOrNull { it.key == key }?.label
@@ -0,0 +1,389 @@
package com.droiddeck.launcher.ui
import android.view.KeyEvent
import androidx.compose.foundation.ExperimentalFoundationApi
import androidx.compose.foundation.background
import androidx.compose.animation.core.LinearEasing
import androidx.compose.animation.core.animateFloatAsState
import androidx.compose.animation.core.tween
import androidx.compose.foundation.border
import androidx.compose.foundation.focusable
import androidx.compose.foundation.gestures.awaitEachGesture
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.foundation.gestures.awaitFirstDown
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.widthIn
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.itemsIndexed
import androidx.compose.foundation.lazy.rememberLazyListState
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.DragHandle
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.mutableFloatStateOf
import androidx.compose.runtime.mutableStateListOf
import androidx.compose.runtime.mutableStateMapOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.setValue
import androidx.compose.runtime.withFrameNanos
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.focus.FocusRequester
import androidx.compose.ui.focus.focusProperties
import androidx.compose.ui.focus.focusRequester
import androidx.compose.ui.focus.onFocusChanged
import androidx.compose.ui.graphics.graphicsLayer
import androidx.compose.ui.input.InputMode
import androidx.compose.ui.input.key.onPreviewKeyEvent
import androidx.compose.ui.input.pointer.PointerEventPass
import androidx.compose.ui.input.pointer.pointerInput
import androidx.compose.material3.LocalTextStyle
import androidx.compose.ui.platform.LocalDensity
import androidx.compose.ui.platform.LocalInputModeManager
import androidx.compose.ui.platform.testTag
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.PlatformTextStyle
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.compose.ui.zIndex
import com.droiddeck.launcher.R
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import kotlin.math.roundToInt
private val ROW_HEIGHT = 44.dp
private val HANDLE_WIDTH = 40.dp
private const val RESET_HOLD_MS = 5_000
private const val TAP_HOLD_MS = 400
private val HINT_LABEL_WIDTH = 92.dp
private val HINT_KEY_SIZE = 18.dp
private val HINT_GAP = 8.dp
private val HINT_LABEL_MIN = 24.dp
private val HINT_ROOM = HINT_LABEL_MIN + HINT_KEY_SIZE + HINT_GAP
@Composable
internal fun ResetHold(held: Boolean, onFire: () -> Unit): Float {
val fill by animateFloatAsState(
if (held) 1f else 0f,
if (held) tween(RESET_HOLD_MS, easing = LinearEasing) else tween(120),
label = "resetHold",
)
LaunchedEffect(held) {
if (!held) return@LaunchedEffect
delay(RESET_HOLD_MS.toLong())
onFire()
}
return fill
}
@Composable
private fun HudKeyHints(grabbed: String?, resetFill: Float) {
Column(
horizontalAlignment = Alignment.End,
verticalArrangement = Arrangement.spacedBy(6.dp),
) {
KeyHint("X", stringResource(R.string.hud_hint_reset), resetFill)
KeyHint("Y", stringResource(if (grabbed != null) R.string.hud_hint_drop else R.string.hud_hint_grab))
KeyHint("B", stringResource(R.string.hud_hint_save))
}
}
@Composable
private fun KeyHint(key: String, label: String, fill: Float = 0f) {
Row(
verticalAlignment = Alignment.CenterVertically,
horizontalArrangement = Arrangement.spacedBy(HINT_GAP),
) {
Text(
label,
fontSize = 11.sp,
lineHeight = 14.sp,
textAlign = TextAlign.End,
color = MaterialTheme.colorScheme.onSurfaceVariant,
maxLines = 2,
modifier = Modifier.widthIn(max = HINT_LABEL_WIDTH),
)
Box(
contentAlignment = Alignment.Center,
modifier = Modifier.size(HINT_KEY_SIZE).clip(RoundedCornerShape(5.dp))
.background(
if (fill > 0f) MaterialTheme.colorScheme.primary.copy(alpha = 0.15f + 0.55f * fill)
else MaterialTheme.colorScheme.surfaceVariant,
)
.border(1.dp, MaterialTheme.colorScheme.outline, RoundedCornerShape(5.dp)),
) {
Text(
key,
fontSize = 10.sp,
lineHeight = 10.sp,
textAlign = TextAlign.Center,
fontWeight = FontWeight.SemiBold,
color = MaterialTheme.colorScheme.onSurface,
style = LocalTextStyle.current.copy(
platformStyle = PlatformTextStyle(includeFontPadding = false),
),
)
}
}
}
@OptIn(ExperimentalFoundationApi::class)
@Composable
internal fun HudReadingsDialog(
visible: List<String>,
initialOrder: List<String>,
initialOn: Map<String, Boolean>,
onDismiss: () -> Unit,
onSave: (Map<String, Boolean>, List<String>) -> Unit,
onReset: () -> Unit,
controller: Boolean = LocalInputModeManager.current.inputMode == InputMode.Keyboard,
) {
val order = remember { mutableStateListOf<String>().apply { addAll(initialOrder.filter { it in visible }) } }
val enabled = remember { mutableStateMapOf<String, Boolean>() }
remember(initialOn) { for (key in initialOrder) enabled[key] = initialOn[key] == true; true }
val merged = {
val moved = order.toList()
var i = 0
initialOrder.map { if (it in visible) moved[i++] else it }
}
val shown = rememberShown { onDismiss() }
val close = { shown.targetState = false }
val save = { onSave(enabled.toMap(), merged()); close() }
val restore = { onReset(); close() }
val rowPx = with(LocalDensity.current) { ROW_HEIGHT.toPx() }
var pad by remember { mutableStateOf(controller) }
var yHeld by remember { mutableStateOf(false) }
var yLong by remember { mutableStateOf(false) }
var yStartedGrab by remember { mutableStateOf(false) }
LaunchedEffect(yHeld) {
if (!yHeld) return@LaunchedEffect
delay(TAP_HOLD_MS.toLong())
yLong = true
}
var resetHeld by remember { mutableStateOf(false) }
val resetFill = ResetHold(resetHeld, restore)
var dragging by remember { mutableStateOf(-1) }
var dragOffset by remember { mutableFloatStateOf(0f) }
val panelFocus = remember { FocusRequester() }
val firstKey = remember { order.firstOrNull() }
val firstFocus = remember { FocusRequester() }
LaunchedEffect(Unit) {
runCatching { panelFocus.requestFocus() }
repeat(30) {
if (runCatching { firstFocus.requestFocus() }.isSuccess) return@LaunchedEffect
withFrameNanos { }
}
}
var focusedKey by remember { mutableStateOf<String?>(null) }
var grabbed by remember { mutableStateOf<String?>(null) }
val before = remember { mutableStateListOf<String>() }
val grab = {
val target = focusedKey ?: order.firstOrNull()
if (target != null && grabbed == null && dragging < 0) {
before.clear()
before.addAll(order)
grabbed = target
}
}
val cancel = {
val held = grabbed
if (held != null) {
order.clear()
order.addAll(before)
grabbed = null
}
}
AppDialog(
shown, close, "hudReadings", wide = false, scrollable = false,
modifier = Modifier.fillMaxHeight(),
back = { if (grabbed != null) cancel() else if (pad) save() else close() },
side = if (pad) {
{ HudKeyHints(grabbed, resetFill) }
} else {
null
},
sideRoom = HINT_ROOM,
) {
val state = rememberLazyListState()
val scope = rememberCoroutineScope()
val handlePx = with(LocalDensity.current) { HANDLE_WIDTH.toPx() }
Column(
Modifier.fillMaxWidth().weight(1f).focusRequester(panelFocus).focusable()
.onPreviewKeyEvent { event ->
val key = event.nativeKeyEvent
val down = key.action == KeyEvent.ACTION_DOWN
if (down) pad = true
val first = down && key.repeatCount == 0
val held = grabbed
when {
key.keyCode == KeyEvent.KEYCODE_BUTTON_Y -> {
when {
down && first -> {
yHeld = true
yLong = key.flags and KeyEvent.FLAG_LONG_PRESS != 0
yStartedGrab = grabbed == null
if (yStartedGrab) grab()
}
down -> if (key.repeatCount > 0) yLong = true
else -> {
val drop = grabbed != null && (!yStartedGrab || yLong)
yHeld = false
if (drop) grabbed = null
}
}
true
}
key.keyCode == KeyEvent.KEYCODE_BUTTON_X && pad -> {
resetHeld = down
true
}
key.keyCode == KeyEvent.KEYCODE_BUTTON_A ||
key.keyCode == KeyEvent.KEYCODE_ENTER ||
key.keyCode == KeyEvent.KEYCODE_SPACE -> {
val target = focusedKey
when {
held != null -> {
if (first) grabbed = null
true
}
target == null -> false
else -> {
if (first) enabled[target] = !(enabled[target] == true)
true
}
}
}
held == null -> false
key.keyCode == KeyEvent.KEYCODE_DPAD_UP || key.keyCode == KeyEvent.KEYCODE_DPAD_DOWN -> {
if (down) {
val from = order.indexOf(held)
val step = if (key.keyCode == KeyEvent.KEYCODE_DPAD_UP) -1 else 1
val to = (from + step).coerceIn(0, order.lastIndex)
if (to != from) {
order.add(to, order.removeAt(from))
val visible = state.layoutInfo.visibleItemsInfo
if (visible.isNotEmpty()) {
val first = visible.first().index
val last = visible.last().index
val target = when {
to <= first -> to
to > last -> (to - visible.size + 1).coerceAtLeast(0)
else -> null
}
if (target != null) scope.launch { state.animateScrollToItem(target) }
}
}
}
true
}
else -> false
}
},
) {
val list = @Composable { m: Modifier ->
LazyColumn(state = state, modifier = m.pointerInput(Unit) {
awaitEachGesture {
val down = awaitFirstDown(requireUnconsumed = false)
val item = state.layoutInfo.visibleItemsInfo.firstOrNull {
it.offset <= down.position.y && down.position.y < it.offset + it.size
}
if (item == null || down.position.x > handlePx || grabbed != null) return@awaitEachGesture
val start = item.index
dragging = start
dragOffset = 0f
while (true) {
val change = awaitPointerEvent(PointerEventPass.Initial).changes.firstOrNull { it.id == down.id } ?: break
val travel = change.position.y - down.position.y
change.consume()
if (!change.pressed) break
val target = (start + (travel / rowPx).roundToInt()).coerceIn(0, order.lastIndex)
while (target != dragging) {
val step = if (target > dragging) 1 else -1
order.add(dragging + step, order.removeAt(dragging))
dragging += step
}
dragOffset = travel - (dragging - start) * rowPx
}
dragging = -1
dragOffset = 0f
}
}) {
itemsIndexed(order, key = { _, key -> key }) { index, key ->
val held = index == dragging || key == grabbed
Row(
verticalAlignment = Alignment.CenterVertically,
modifier = Modifier.fillMaxWidth().height(ROW_HEIGHT).testTag("hud-row-$key")
.then(if (key == firstKey) Modifier.focusRequester(firstFocus) else Modifier)
.onFocusChanged { if (it.isFocused) focusedKey = key else if (focusedKey == key) focusedKey = null }
.zIndex(if (held) 1f else 0f)
.graphicsLayer { translationY = if (index == dragging) dragOffset else 0f }
.clip(Shape12)
.background(
if (held) MaterialTheme.colorScheme.surfaceVariant
else MaterialTheme.colorScheme.surface,
)
.then(
if (key == focusedKey) Modifier.border(2.dp, LocalPalette.current.signal, Shape12)
else Modifier,
)
.focusable()
.padding(start = 4.dp, end = 6.dp),
) {
Box(
contentAlignment = Alignment.Center,
modifier = Modifier.size(width = HANDLE_WIDTH, height = ROW_HEIGHT).testTag("hud-handle-$key"),
) {
Icon(
Icons.Filled.DragHandle, null,
tint = MaterialTheme.colorScheme.onSurfaceVariant,
modifier = Modifier.size(20.dp),
)
}
val label = hudMetricLabel(key)
Text(
if (label != null) stringResource(label) else key,
fontSize = 14.sp, color = MaterialTheme.colorScheme.onBackground, maxLines = 1,
modifier = Modifier.weight(1f).padding(start = 2.dp),
)
ToggleSwitch(
enabled[key] == true, true, null,
modifier = Modifier.testTag("hud-switch-$key").focusProperties { canFocus = false },
) { enabled[key] = !(enabled[key] == true) }
}
}
}
}
list(Modifier.weight(1f).fillMaxWidth())
if (!pad) {
Row(Modifier.fillMaxWidth().padding(top = 8.dp), horizontalArrangement = Arrangement.spacedBy(8.dp)) {
Box(Modifier.weight(1f))
PrimaryButton(stringResource(R.string.common_ok), compact = true, onClick = save)
SecondaryButton(stringResource(R.string.hud_reset_button), compact = true, onClick = restore)
}
}
}
}
}
@@ -262,6 +262,8 @@ class DrawerActions(
val selectedSecondScreenDisplay: Int,
val onHud: (Boolean) -> Unit,
val onHudSetting: (String, String) -> Unit = { _, _ -> },
val onHudOrder: (Map<String, Boolean>, List<String>) -> Unit = { _, _ -> },
val onHudOrderReset: () -> Unit = {},
val onHudReset: () -> Unit = {},
val onHudExport: () -> Unit = {},
val onFrameGenPick: (FrameGen.Mode) -> Unit,