From 5bc5f68761cd4ac874c89b4a431423a9ef1301e3 Mon Sep 17 00:00:00 2001 From: The412Banner Date: Thu, 15 Oct 2026 19:22:04 -0400 Subject: [PATCH] Open driver pairs: the installed build's version, its upload date, and an Update when the release is rebuilt in place - The release check records each asset's GitHub id and updated_at; a download records them (with the digest) for an open non-Adreno pair. - Components > GPU drivers: an installed open pair shows its manifest version ("android + linux "), one not yet installed shows "built YYYY-MM-DD". A different digest, asset id or upload time on the same tag marks the installed pair "Update available" with an Update action: the pair is downloaded again and replaced in place, and stays selected only if it was. Adreno and DD-Turnip pairs are unchanged. - graphics-report.txt: the pair release line gives the installed and the listed upload dates and flags a newer build; an exact bundle id match is preferred (RADV-Xclipse-upstream is not RADV-Xclipse). --- .../com/droiddeck/launcher/DriverMenus.kt | 32 +++++++++++++-- .../com/droiddeck/launcher/MainActivity.kt | 1 + .../droiddeck/launcher/gpu/TurnipReleases.kt | 41 +++++++++++++++++-- .../launcher/session/GraphicsReport.kt | 13 +++--- .../droiddeck/launcher/ui/ComponentsPage.kt | 14 ++++--- .../droiddeck/launcher/ui/GpuDriversPanel.kt | 3 ++ app/src/main/res/values/strings.xml | 2 + .../launcher/gpu/DriverPairUpdateTest.kt | 37 +++++++++++++++++ 8 files changed, 125 insertions(+), 18 deletions(-) create mode 100644 app/src/test/java/com/droiddeck/launcher/gpu/DriverPairUpdateTest.kt diff --git a/app/src/main/java/com/droiddeck/launcher/DriverMenus.kt b/app/src/main/java/com/droiddeck/launcher/DriverMenus.kt index 405396e576..4818be7373 100644 --- a/app/src/main/java/com/droiddeck/launcher/DriverMenus.kt +++ b/app/src/main/java/com/droiddeck/launcher/DriverMenus.kt @@ -111,12 +111,21 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl val pairs = DriverPairs.from(TurnipReleases.cached(activity)) val recommended = if (QuestExperimental.isSupported()) null else DriverPairs.recommendedKey(gpu, pairs) pairRows = pairs.map { p -> - val bundle = p.bundle?.let { installedBundle(it) } + val nad = DriverPairs.isNonAdreno(p.key) + val bundle = p.bundle?.let { if (nad) installedBundleAnyBuild(it) else installedBundle(it) } val displayId = if (p.bundle != null) bundle?.androidId else p.display?.let { TurnipReleases.installedId(activity, it, td::isInstalled) } val linuxId = if (p.bundle != null) bundle?.linuxId else p.linux?.let { TurnipReleases.installedId(activity, it, lm::isInstalled) } val mb = p.assets.sumOf { it.size } / 1_048_576.0 + val update = nad && bundle != null && p.bundle?.let { TurnipReleases.updateAvailable(activity, it) } == true + val builtOn = if (nad) p.bundle?.builtOn.orEmpty() else "" + val version = when { + !nad -> p.version + bundle != null -> bundle.version.ifEmpty { p.version } + builtOn.isNotEmpty() -> activity.getString(R.string.drivers_built_on, builtOn) + else -> p.version + } PairRow( - key = p.key, name = p.name, version = p.version, + key = p.key, name = p.name, version = version, update = if (update) builtOn.takeIf { it.isNotEmpty() }?.let { activity.getString(R.string.drivers_built_on, it) } ?: p.version else null, detail = if (!p.complete) activity.getString(R.string.drivers_half_published) else activity.getString(R.string.drivers_pair_size, mb), recommended = p.key == recommended, suits = p.suits(gpu), complete = p.complete, installed = displayId != null && linuxId != null, @@ -245,7 +254,15 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl installPair(pair, auto = false) } - private fun installPair(pair: DriverPairs.DriverPair, auto: Boolean) { + /** A newer build of an installed open non-Adreno pair: replaced in place, still selected if it was. */ + fun updatePair(key: String) { + if (pairBusy != null) return + val pair = DriverPairs.from(TurnipReleases.cached(activity)).firstOrNull { it.key == key && it.complete } ?: return + val wasActive = pairRows.firstOrNull { it.key == key }?.active == true + installPair(pair, auto = wasActive && mode == SessionPrefs.GPU_DRIVERS_AUTO, force = true, select = wasActive) + } + + private fun installPair(pair: DriverPairs.DriverPair, auto: Boolean, force: Boolean = false, select: Boolean = true) { if (!pair.complete) return pairBusy = pair.key pairPercent = 0 @@ -257,7 +274,7 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl val result = runCatching { val zips = pair.assets val ids = zips.mapIndexed { i, asset -> - installedIdOf(asset) + (if (force) null else installedIdOf(asset)) ?: installAsset(asset) { pct -> ui.post { pairPercent = (i * 100 + pct) / zips.size } }.also { downloaded = true } } if (pair.bundle != null) DriverBundle.get(activity, ids[0])!!.let { listOf(it.androidId, it.linuxId) } else ids @@ -266,6 +283,10 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl pairBusy = null pairPercent = -1 result.onSuccess { (pairDisplayId, linuxId) -> + if (!select) { + android.widget.Toast.makeText(activity, activity.getString(R.string.drivers_pair_updated, pair.name), android.widget.Toast.LENGTH_LONG).show() + return@onSuccess + } // A Mali pair under Auto: the compositor draws on the phone's own Mali driver // (dma-buf, modifiers and AHB all work there) and the guest runs the pair's // PanVK. Its Android half stays installed for a manual pick. @@ -313,6 +334,9 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl private fun installedBundle(asset: TurnipReleases.Asset): DriverBundle.Bundle? = TurnipReleases.installedId(activity, asset) { DriverBundle.get(activity, it) != null }?.let { DriverBundle.get(activity, it) } + private fun installedBundleAnyBuild(asset: TurnipReleases.Asset): DriverBundle.Bundle? = + TurnipReleases.installedIdAnyBuild(activity, asset) { DriverBundle.get(activity, it) != null }?.let { DriverBundle.get(activity, it) } + private fun installedIdOf(asset: TurnipReleases.Asset): String? = when { asset.bundle -> installedBundle(asset)?.id asset.linux -> TurnipReleases.installedId(activity, asset, LinuxVulkanDriverManager(activity)::isInstalled) diff --git a/app/src/main/java/com/droiddeck/launcher/MainActivity.kt b/app/src/main/java/com/droiddeck/launcher/MainActivity.kt index e65f02a072..ac7b7eb409 100644 --- a/app/src/main/java/com/droiddeck/launcher/MainActivity.kt +++ b/app/src/main/java/com/droiddeck/launcher/MainActivity.kt @@ -1199,6 +1199,7 @@ class MainActivity : ComponentActivity() { gpuActions = com.droiddeck.launcher.ui.GpuDriversActions( onAuto = { on -> drivers.setMode(on) }, onPair = { key -> drivers.selectPair(key) }, + onPairUpdate = { key -> drivers.updatePair(key) }, onRefresh = { if (drivers.mode == SessionPrefs.GPU_DRIVERS_AUTO) drivers.ensureAuto(force = true) else drivers.checkLatestTurnip() }, onSelectLinux = { id -> drivers.selectDriver(id, linux = true) }, onSelectAndroid = { id -> drivers.selectDriver(id, linux = false) }, diff --git a/app/src/main/java/com/droiddeck/launcher/gpu/TurnipReleases.kt b/app/src/main/java/com/droiddeck/launcher/gpu/TurnipReleases.kt index 5493d6e325..b774b5da2e 100644 --- a/app/src/main/java/com/droiddeck/launcher/gpu/TurnipReleases.kt +++ b/app/src/main/java/com/droiddeck/launcher/gpu/TurnipReleases.kt @@ -18,7 +18,11 @@ object TurnipReleases { private const val KEY_DOWNLOADS = "downloads" class Asset(val source: String, val tag: String, val name: String, val url: String, val size: Long, val linux: Boolean, val label: String, - val sha256: String = "", val pair: String = "", val bundle: Boolean = false) + val sha256: String = "", val pair: String = "", val bundle: Boolean = false, + val assetId: Long = 0, val updatedAt: String = "") { + /** "2026-10-15" from GitHub's updated_at; empty when the check did not record it. */ + val builtOn: String get() = updatedAt.take(10) + } class Check(val assets: List, val latest: List>, val failed: List, val checkedAt: Long) private class Kind(val linux: Boolean, val label: String, val pair: String, val bundle: Boolean = false) @@ -102,7 +106,7 @@ object TurnipReleases { assets.put(JSONObject().put("source", src.label).put("tag", tag).put("name", name) .put("url", a.getString("browser_download_url")).put("size", a.optLong("size")) .put("linux", linux).put("label", label).put("sha256", sha).put("pair", kind.pair) - .put("bundle", kind.bundle)) + .put("bundle", kind.bundle).put("id", a.optLong("id")).put("updated_at", a.optString("updated_at"))) } } if (newest != null) latest.put(JSONObject().put("source", src.label).put("tag", newest)) @@ -141,7 +145,7 @@ object TurnipReleases { val a = list.getJSONObject(i) out.add(Asset(a.getString("source"), a.getString("tag"), a.getString("name"), a.getString("url"), a.optLong("size"), a.getBoolean("linux"), a.getString("label"), a.optString("sha256", ""), a.optString("pair", ""), - a.optBoolean("bundle", false))) + a.optBoolean("bundle", false), a.optLong("id"), a.optString("updated_at", ""))) } val latest = ArrayList>() val l = json.optJSONArray("latest") ?: JSONArray() @@ -160,6 +164,31 @@ object TurnipReleases { } private const val SHA_PREFIX = "sha256:" + private const val ASSET_ID_PREFIX = "asset:" + private const val UPDATED_PREFIX = "updated:" + + /** The id an open non-Adreno pair's asset was installed as, whichever build of it that was. */ + fun installedIdAnyBuild(context: Context, asset: Asset, isInstalled: (String) -> Boolean): String? = + downloads(context).optString(asset.name, "").takeIf { it.isNotEmpty() && isInstalled(it) } + + /** + * An open non-Adreno pair is rebuilt in place under the same tag: a different digest, asset id + * or upload time than the one installed means a newer build. + */ + fun updateAvailable(context: Context, asset: Asset): Boolean { + if (!DriverPairs.isNonAdreno(asset.pair)) return false + val d = downloads(context) + if (d.optString(asset.name, "").isEmpty()) return false + val sha = d.optString(SHA_PREFIX + asset.name, "") + val id = d.optLong(ASSET_ID_PREFIX + asset.name, 0) + val updated = d.optString(UPDATED_PREFIX + asset.name, "") + return (sha.isNotEmpty() && asset.sha256.isNotEmpty() && !sha.equals(asset.sha256, ignoreCase = true)) || + (id != 0L && asset.assetId != 0L && id != asset.assetId) || + (updated.isNotEmpty() && asset.updatedAt.isNotEmpty() && updated != asset.updatedAt) + } + + /** When the installed build of [asset] was uploaded, as recorded at download ("" if unknown). */ + fun installedBuiltOn(context: Context, asset: Asset): String = downloads(context).optString(UPDATED_PREFIX + asset.name, "").take(10) fun isDownloaded(context: Context, id: String): Boolean { val d = downloads(context) @@ -168,7 +197,11 @@ object TurnipReleases { fun recordDownload(context: Context, asset: Asset, id: String) { val d = downloads(context).put(asset.name, id) - if (DriverPairs.isNonAdreno(asset.pair) && asset.sha256.isNotEmpty()) d.put(SHA_PREFIX + asset.name, asset.sha256) + if (DriverPairs.isNonAdreno(asset.pair)) { + if (asset.sha256.isNotEmpty()) d.put(SHA_PREFIX + asset.name, asset.sha256) + if (asset.assetId != 0L) d.put(ASSET_ID_PREFIX + asset.name, asset.assetId) + if (asset.updatedAt.isNotEmpty()) d.put(UPDATED_PREFIX + asset.name, asset.updatedAt) + } prefs(context).edit().putString(KEY_DOWNLOADS, d.toString()).apply() } diff --git a/app/src/main/java/com/droiddeck/launcher/session/GraphicsReport.kt b/app/src/main/java/com/droiddeck/launcher/session/GraphicsReport.kt index 4462dc216e..48a2d646c3 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/GraphicsReport.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/GraphicsReport.kt @@ -133,12 +133,15 @@ object GraphicsReport { /** The release tag and download a pair bundle came from, when the last release check knows it. */ private fun release(context: Context, bundleId: String): String? { - val asset = TurnipReleases.cached(context)?.assets?.firstOrNull { a -> - val id = a.name.removeSuffix("-Pair.zip") - a.bundle && (bundleId == id || bundleId.startsWith("$id-")) - } + val bundles = TurnipReleases.cached(context)?.assets?.filter { it.bundle }.orEmpty() + val asset = bundles.firstOrNull { it.name.removeSuffix("-Pair.zip") == bundleId } + ?: bundles.firstOrNull { bundleId.startsWith(it.name.removeSuffix("-Pair.zip") + "-") } ?: return null - return "${asset.tag} ${asset.url}" + val installed = TurnipReleases.installedBuiltOn(context, asset) + return "${asset.tag} ${asset.url}" + + (if (installed.isNotEmpty()) ", installed build uploaded $installed" else "") + + (if (asset.builtOn.isNotEmpty()) ", listed build uploaded ${asset.builtOn}" else "") + + (if (TurnipReleases.updateAvailable(context, asset)) " << NEWER BUILD AVAILABLE" else "") } private fun node(path: String): String { diff --git a/app/src/main/java/com/droiddeck/launcher/ui/ComponentsPage.kt b/app/src/main/java/com/droiddeck/launcher/ui/ComponentsPage.kt index d77b623013..45c1c08532 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/ComponentsPage.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/ComponentsPage.kt @@ -521,7 +521,7 @@ fun ComponentsPage( } val availableTitle: @Composable (String) -> String = { l -> when (l) { - GPU_TAB -> stringResource(R.string.comp_available_count, gpu.pairs.count { !it.installed && it.complete && (it.suits || showAllPairs) }) + GPU_TAB -> stringResource(R.string.comp_available_count, gpu.pairs.count { (!it.installed || it.update != null) && it.complete && (it.suits || showAllPairs) }) PROTON_TAB -> stringResource(R.string.comp_available_count, protons.rows.count { it.installed == null || it.update != null }) else -> stringResource(R.string.comp_nightlies_count, availableFor(l, catalog, snapshot).size) } @@ -543,7 +543,8 @@ fun ComponentsPage( for (p in gpu.pairs.filter { it.installed && (it.suits || showAllPairs) }) { val key = "gpu:${p.key}" ChoiceLine( - p.name, "${p.version} · ${p.detail}", !gpu.auto && p.active, removable = false, + p.name, "${p.version} · ${p.detail}" + (p.update?.let { " · " + stringResource(R.string.proton_update_available, it) } ?: ""), + !gpu.auto && p.active, removable = false, badge = if (p.recommended) stringResource(R.string.gpu_recommended_caps) else null, progress = if (gpu.busy == p.key) gpu.percent else null, modifier = Modifier.trackRow(key, rowsAt), @@ -612,12 +613,15 @@ fun ComponentsPage( val availableRows: @Composable ColumnScope.(String) -> Unit = { l -> when (l) { GPU_TAB -> { - val shown = gpu.pairs.filter { !it.installed && it.complete && (it.suits || showAllPairs) } + val shown = gpu.pairs.filter { (!it.installed || it.update != null) && it.complete && (it.suits || showAllPairs) } if (shown.isEmpty()) EmptyLine(stringResource(if (gpu.checking) R.string.gpu_checking else R.string.gpu_none_listed)) for (p in shown) GetLine( - p.name, "${p.version} · ${p.detail}", progress = if (gpu.busy == p.key) gpu.percent else null, enabled = gpu.busy == null, + p.name, + if (p.update != null) "${p.version} · " + stringResource(R.string.proton_update_available, p.update) else "${p.version} · ${p.detail}", + progress = if (gpu.busy == p.key) gpu.percent else null, enabled = gpu.busy == null, badge = if (p.recommended) stringResource(R.string.gpu_recommended_caps) else null, - ) { gpuActions.onAuto(false); gpuActions.onPair(p.key) } + action = if (p.update != null) stringResource(R.string.common_update) else null, + ) { if (p.update != null) gpuActions.onPairUpdate(p.key) else { gpuActions.onAuto(false); gpuActions.onPair(p.key) } } if (gpu.pairs.any { !it.suits }) Box(Modifier.padding(horizontal = 6.dp, vertical = 4.dp)) { FocusText(stringResource(if (showAllPairs) R.string.gpu_hide_other else R.string.gpu_show_other), pal.signal) { showAllPairs = !showAllPairs } } diff --git a/app/src/main/java/com/droiddeck/launcher/ui/GpuDriversPanel.kt b/app/src/main/java/com/droiddeck/launcher/ui/GpuDriversPanel.kt index 8702844ec7..bdefc10630 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/GpuDriversPanel.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/GpuDriversPanel.kt @@ -72,6 +72,8 @@ class PairRow( val complete: Boolean, val installed: Boolean, val active: Boolean, + /** A newer build of this installed pair (its build date), or null. */ + val update: String? = null, ) class GpuDriversState( @@ -106,6 +108,7 @@ class GpuDriversState( class GpuDriversActions( val onAuto: (Boolean) -> Unit = {}, val onPair: (String) -> Unit = {}, + val onPairUpdate: (String) -> Unit = {}, val onRefresh: () -> Unit = {}, val onSelectLinux: (String) -> Unit = {}, val onSelectAndroid: (String) -> Unit = {}, diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 516a7130f9..186a0d9e66 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -720,6 +720,8 @@ Detailed graphics logs Steam interface: GPU drawing With the Xclipse driver pair, Steam draws its pages in software (GPU drawing showed broken tiles). Turn on for a faster Steam interface if it looks right on this phone. + built %1$s + %1$s updated to the newest build The Mali bridge failed its self-test on %1$s last session (images or draws), so the session used the PanVK driver pair instead. The Mali bridge found no way to share memory with the driver on %1$s last session, so the session used the PanVK driver pair instead. The bridge cannot work on this phone; turning it off keeps the PanVK pair. Each game\'s Proton, DXVK and driver logs in the session\'s logs. Always on when the GPU is not an Adreno. diff --git a/app/src/test/java/com/droiddeck/launcher/gpu/DriverPairUpdateTest.kt b/app/src/test/java/com/droiddeck/launcher/gpu/DriverPairUpdateTest.kt new file mode 100644 index 0000000000..eb3a556de4 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/gpu/DriverPairUpdateTest.kt @@ -0,0 +1,37 @@ +package com.droiddeck.launcher.gpu + +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.RuntimeEnvironment +import org.robolectric.annotation.Config + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [28], manifest = Config.NONE) +class DriverPairUpdateTest { + private fun pair(sha: String, id: Long, updated: String, key: String = DriverPairs.nonAdreno("PanVK-Mali-G615")) = + TurnipReleases.Asset("Non-Adreno", "panvk-mali-g615", "PanVK-Mali-G615-Pair.zip", "https://example/p", 9_000_000, false, + "label", sha, key, bundle = true, assetId = id, updatedAt = updated) + + @Test fun aRebuildUnderTheSameTagIsAnUpdate() { + val context = RuntimeEnvironment.getApplication() + val installed = pair("a".repeat(64), 1, "2026-10-13T10:00:00Z") + assertFalse("nothing installed yet", TurnipReleases.updateAvailable(context, installed)) + TurnipReleases.recordDownload(context, installed, "PanVK-Mali-G615") + assertFalse(TurnipReleases.updateAvailable(context, installed)) + assertEquals("2026-10-13", TurnipReleases.installedBuiltOn(context, installed)) + assertTrue(TurnipReleases.updateAvailable(context, pair("b".repeat(64), 2, "2026-10-15T10:00:00Z"))) + assertTrue("a new asset id alone", TurnipReleases.updateAvailable(context, pair("a".repeat(64), 2, "2026-10-13T10:00:00Z"))) + assertEquals("2026-10-15", pair("b".repeat(64), 2, "2026-10-15T10:00:00Z").builtOn) + } + + @Test fun adrenoPairsAreNeverFlagged() { + val context = RuntimeEnvironment.getApplication() + val turnip = pair("a".repeat(64), 1, "2026-10-13T10:00:00Z", key = DriverPairs.BANNER) + TurnipReleases.recordDownload(context, turnip, "Turnip-x") + assertFalse(TurnipReleases.updateAvailable(context, pair("b".repeat(64), 2, "2026-10-15T10:00:00Z", key = DriverPairs.BANNER))) + } +}