feat: pick GPU drivers as matched pairs, set automatically for the device's GPU (#103)

* feat: pick GPU drivers as matched pairs, set automatically for the device's GPU

* DD-Turnip Driver Support (#106)

---------

Co-authored-by: MaxsTechReview <maxjividen@gmail.com>
This commit is contained in:
Kurt HimebauchandMaxsTechReview authored and GitHub committed 2026-09-30 16:57:49 -04:00
1 parent 5251c6a5f6
commit 7e6df11344
20 files changed
+1475 -188

No files matched your search

@@ -0,0 +1,133 @@
package com.droiddeck.launcher.gpu
import android.content.Context
import android.net.Uri
import com.droiddeck.launcher.session.SessionPrefs
import org.json.JSONObject
import org.junit.Assert.assertEquals
import org.junit.Assert.assertFalse
import org.junit.Assert.assertNotNull
import org.junit.Assert.assertNull
import org.junit.Assert.assertTrue
import org.junit.Assert.fail
import org.junit.Before
import org.junit.Test
import org.junit.runner.RunWith
import org.robolectric.RobolectricTestRunner
import org.robolectric.RuntimeEnvironment
import org.robolectric.annotation.Config
import java.io.File
import java.util.zip.ZipEntry
import java.util.zip.ZipOutputStream
@RunWith(RobolectricTestRunner::class)
@Config(sdk = [28], manifest = Config.NONE)
class DriverBundleTest {
private lateinit var context: Context
@Before fun setUp() {
context = RuntimeEnvironment.getApplication()
File(context.filesDir, "graphics_driver").deleteRecursively()
File(context.filesDir, LinuxVulkanDriverManager.DIR_NAME).deleteRecursively()
context.getSharedPreferences("driver_bundles", Context.MODE_PRIVATE).edit().clear().commit()
SessionPrefs.setAndroidDriver(context, "")
SessionPrefs.setLinuxDriver(context, "")
}
/** Enough of an AArch64 ELF for the importers: the header they read, then the libc they look for. */
private fun library(libc: String) = ByteArray(64).also {
byteArrayOf(0x7f, 'E'.code.toByte(), 'L'.code.toByte(), 'F'.code.toByte(), 2, 1).copyInto(it)
it[18] = 0xB7.toByte()
} + libc.toByteArray() + ByteArray(1)
private val manifest = JSONObject()
.put("package", "DD-Turnip").put("version", "0.1.0").put("tag", "DD-Turnip-v0.1.0")
.put("drivers", JSONObject()
.put("android", JSONObject().put("path", "android"))
.put("linux", JSONObject().put("path", "linux")))
private fun zip(entries: Map<String, ByteArray>): Uri {
val file = File.createTempFile("bundle", ".zip", context.cacheDir)
ZipOutputStream(file.outputStream()).use { z ->
for ((name, data) in entries) { z.putNextEntry(ZipEntry(name)); z.write(data); z.closeEntry() }
}
return Uri.fromFile(file)
}
private fun bundle(linuxLibc: String = "libc.so.6", extra: Map<String, ByteArray> = emptyMap()) = zip(mapOf(
"android/meta.json" to JSONObject().put("name", "DD-Turnip v0.1.0").put("libraryName", "libvulkan_freedreno.so").toString().toByteArray(),
"android/libvulkan_freedreno.so" to library("libc.so"),
"linux/meta.json" to JSONObject().put("name", "DD-Turnip v0.1.0").put("driverVersion", "DD-Turnip-v0.1.0").toString().toByteArray(),
"linux/libvulkan_freedreno.so" to library(linuxLibc),
"manifest.json" to manifest.toString().toByteArray(),
) + extra)
@Test fun manifestNeedsBothHalvesInSeparateSafeDirectories() {
val m = DriverBundle.parseManifest(manifest)!!
assertEquals("android", m.androidPath)
assertEquals("linux", m.linuxPath)
assertNull(DriverBundle.parseManifest(JSONObject().put("drivers", JSONObject().put("android", JSONObject().put("path", "a")))))
val same = JSONObject(manifest.toString()).apply { getJSONObject("drivers").getJSONObject("linux").put("path", "android/") }
assertNull(DriverBundle.parseManifest(same))
val escape = JSONObject(manifest.toString()).apply { getJSONObject("drivers").getJSONObject("linux").put("path", "../x") }
assertNull(DriverBundle.parseManifest(escape))
}
@Test fun singleDriverZipsAreNotBundles() {
val legacy = zip(mapOf("meta.json" to "{}".toByteArray(), "libvulkan_freedreno.so" to library("libc.so")))
assertFalse(DriverBundle.isBundle(context, legacy))
assertTrue(DriverBundle.isBundle(context, bundle()))
}
@Test fun installsBothHalvesAndPicksAndDeletesThemTogether() {
val b = DriverBundle.install(context, bundle())
assertEquals("DD-Turnip-v0.1.0", b.id)
assertEquals("DD-Turnip 0.1.0", b.label)
assertTrue(TurnipDriver(context).isInstalled(b.androidId))
assertTrue(LinuxVulkanDriverManager(context).isInstalled(b.linuxId))
assertEquals(b.id, DriverBundle.containing(context, b.linuxId, linux = true)?.id)
assertEquals(b.id, DriverBundle.containing(context, b.androidId, linux = false)?.id)
assertNull(DriverBundle.active(context))
DriverBundle.select(context, b)
assertEquals(b.androidId, SessionPrefs.androidDriver(context))
assertEquals(b.linuxId, SessionPrefs.linuxDriver(context))
assertNotNull(DriverBundle.active(context))
DriverBundle.remove(context, b)
assertFalse(TurnipDriver(context).isInstalled(b.androidId))
assertFalse(LinuxVulkanDriverManager(context).isInstalled(b.linuxId))
assertEquals("", SessionPrefs.androidDriver(context))
assertEquals("", SessionPrefs.linuxDriver(context))
assertTrue(DriverBundle.all(context).isEmpty())
}
@Test fun aRefusedHalfLeavesNothingInstalled() {
try {
DriverBundle.install(context, bundle(linuxLibc = "libc.so"))
fail("a bionic library in linux/ must be refused")
} catch (e: IllegalArgumentException) {
assertTrue(e.message!!.contains("glibc"))
}
assertTrue(TurnipDriver(context).enumerateImported().isEmpty())
assertTrue(LinuxVulkanDriverManager(context).enumerateInstalledDrivers().isEmpty())
}
@Test fun entriesOutsideTheBundleAreRefused() {
try {
DriverBundle.install(context, bundle(extra = mapOf("../escape.so" to ByteArray(4))))
fail("a zip-slip entry must be refused")
} catch (e: IllegalArgumentException) {
assertTrue(e.message!!.contains("outside"))
}
assertFalse(File(context.cacheDir.parentFile, "escape.so").exists())
}
@Test fun twoInstallsOfOneReleaseGetTheirOwnIds() {
val first = DriverBundle.install(context, bundle())
val second = DriverBundle.install(context, bundle())
assertEquals("DD-Turnip-v0.1.0-2", second.id)
assertEquals(2, DriverBundle.all(context).size)
assertFalse(first.androidId == second.androidId)
}
}
@@ -0,0 +1,109 @@
package com.droiddeck.launcher.gpu
import com.droiddeck.launcher.gpu.GpuInfo.Family
import org.junit.Assert.assertEquals
import org.junit.Assert.assertFalse
import org.junit.Assert.assertNull
import org.junit.Assert.assertTrue
import org.junit.Test
class DriverPairsTest {
private fun gpu(model: Int, adreno: Boolean = true, oneUi: Boolean = false) =
GpuInfo("Adreno $model", model, GpuInfo.familyOf(adreno, model), "", oneUi)
private fun asset(name: String, tag: String, linux: Boolean, pair: String) =
TurnipReleases.Asset("src", tag, name, "https://example/$name", 3_000_000, linux, "label", "0".repeat(64), pair)
@Test
fun familiesFollowTheAdrenoModel() {
assertEquals(Family.A8XX, GpuInfo.familyOf(true, 825))
assertEquals(Family.A8XX, GpuInfo.familyOf(true, 810))
assertEquals(Family.A7XX_LOW, GpuInfo.familyOf(true, 722))
assertEquals(Family.A7XX, GpuInfo.familyOf(true, 740))
assertEquals(Family.A6XX, GpuInfo.familyOf(true, 610))
assertEquals(Family.ADRENO_UNKNOWN, GpuInfo.familyOf(true, 0))
assertEquals(Family.NOT_ADRENO, GpuInfo.familyOf(false, 0))
}
@Test
fun onlyTestedHardwareCountsAsSupported() {
assertEquals(GpuInfo.Support.TESTED, gpu(740).support)
assertEquals(GpuInfo.Support.TESTED, gpu(825).support)
assertEquals(GpuInfo.Support.UNTESTED, gpu(610).support)
assertEquals(GpuInfo.Support.UNTESTED, gpu(720).support)
assertEquals(GpuInfo.Support.UNSUPPORTED, gpu(0, adreno = false).support)
}
@Test
fun autoPicksWinNativeBalancedOn8xxAndBannersElsewhere() {
assertEquals(DriverPairs.WN_BALANCED, DriverPairs.recommendedKey(gpu(830), emptyList()))
assertEquals("840 with no DD-Turnip release listed", DriverPairs.WN_BALANCED, DriverPairs.recommendedKey(gpu(840), emptyList()))
assertEquals(DriverPairs.WN_BALANCED, DriverPairs.recommendedKey(gpu(825), emptyList()))
assertEquals(DriverPairs.BANNER, DriverPairs.recommendedKey(gpu(740), emptyList()))
assertEquals(DriverPairs.BANNER_ONEUI, DriverPairs.recommendedKey(gpu(740, oneUi = true), emptyList()))
assertEquals(DriverPairs.BANNER_710, DriverPairs.recommendedKey(gpu(720), emptyList()))
assertEquals(DriverPairs.BANNER, DriverPairs.recommendedKey(gpu(650), emptyList()))
assertNull(DriverPairs.recommendedKey(gpu(0, adreno = false), emptyList()))
}
@Test
fun pairsMatchHalvesAndNeverMixBannersReleases() {
val check = TurnipReleases.Check(
listOf(
asset("Turnip-r4.zip", "r4", false, DriverPairs.BANNER),
asset("Turnip-r4-Linux.zip", "r4", true, DriverPairs.BANNER),
// The A8xx set's newest display build is r4, but its Linux half is only in r3.
asset("Turnip-r4-A8xx.zip", "r4", false, DriverPairs.BANNER_A8XX),
asset("Turnip-r3-A8xx-Linux.zip", "r3", true, DriverPairs.BANNER_A8XX),
asset("WN-Turnip-1.19-b_Axxx.zip", "v1.19", false, DriverPairs.WN_BALANCED),
asset("WN-Linux-Turnip-0.1.2-b_Axxx.zip", "linux-v0.1.2", true, DriverPairs.WN_BALANCED),
),
emptyList(), emptyList(), 0L,
)
val pairs = DriverPairs.from(check).associateBy { it.key }
assertTrue(pairs.getValue(DriverPairs.BANNER).complete)
assertFalse("halves from two releases are not a pair", pairs.getValue(DriverPairs.BANNER_A8XX).complete)
val wn = pairs.getValue(DriverPairs.WN_BALANCED)
assertTrue("WinNative's two release lines pair up", wn.complete)
assertEquals("v1.19 + v0.1.2", wn.version)
assertTrue(wn.suits(gpu(830)))
assertFalse(pairs.getValue(DriverPairs.BANNER).suits(gpu(830)))
}
@Test
fun everyBundleReleaseIsACompletePairOnItsOwnNewestFirst() {
fun bundle(tag: String) = TurnipReleases.Asset("DroidDeck", tag, "$tag.zip", "https://example/$tag", 6_000_000,
false, "Android + Linux", "0".repeat(64), DriverPairs.ddTurnip(tag), bundle = true)
val newer = bundle("DD-Turnip-v0.2.0")
val older = bundle("DD-Turnip-v0.1.0")
val pairs = DriverPairs.from(TurnipReleases.Check(
listOf(asset("Turnip-r4.zip", "r4", false, DriverPairs.BANNER), newer, older,
asset("Turnip-r4-Linux.zip", "r4", true, DriverPairs.BANNER)),
emptyList(), emptyList(), 0L,
))
assertEquals(listOf(DriverPairs.ddTurnip("DD-Turnip-v0.2.0"), DriverPairs.ddTurnip("DD-Turnip-v0.1.0"), DriverPairs.BANNER), pairs.map { it.key })
val dd = pairs.first()
assertTrue(dd.complete)
assertEquals(listOf(newer), dd.assets)
assertEquals("v0.2.0", dd.version)
assertEquals("DroidDeck · DD-Turnip", dd.name)
assertTrue(dd.suits(gpu(840)))
assertTrue(dd.suits(gpu(740)))
}
@Test
fun adreno840GetsTheNewestOfficialDdTurnip() {
fun bundle(tag: String) = TurnipReleases.Asset("DroidDeck", tag, "$tag.zip", "https://example/$tag", 6_000_000,
false, "Android + Linux", "0".repeat(64), DriverPairs.ddTurnip(tag), bundle = true)
val pairs = DriverPairs.from(TurnipReleases.Check(
listOf(bundle("DD-Turnip-v0.9.0"), bundle("DD-Turnip-v1.0.0"), bundle("DD-Turnip-v0.10.1"),
asset("WN-Turnip-1.19-b_Axxx.zip", "v1.19", false, DriverPairs.WN_BALANCED),
asset("WN-Linux-Turnip-0.1.2-b_Axxx.zip", "linux-v0.1.2", true, DriverPairs.WN_BALANCED)),
emptyList(), emptyList(), 0L,
))
assertEquals(DriverPairs.ddTurnip("DD-Turnip-v1.0.0"), DriverPairs.recommendedKey(gpu(840), pairs))
assertEquals("other 8xx keep WinNative", DriverPairs.WN_BALANCED, DriverPairs.recommendedKey(gpu(830), pairs))
assertEquals(DriverPairs.WN_BALANCED, DriverPairs.recommendedKey(gpu(825), pairs))
assertEquals(DriverPairs.BANNER, DriverPairs.recommendedKey(gpu(740), pairs))
}
}