Front end: box art for emulator games, found automatically and kept

CoverArt looks a game up by its file name in RetroArch's libretro-thumbnails
collection for the system (exactly, then loosely: tags dropped, same region
preferred, against the collection's cached list of names), then by the disc's
own ID - PS2 serials from SYSTEM.CNF against xlenore/ps2-covers, GameCube/Wii IDs
against GameTDB. Covers are downloaded once into files/covers after the list is
shown, and the list is refreshed when some arrive; a game with none is retried
after three days; nothing is fetched offline. PS3 disc dumps use their own
PS3_GAME/ICON0.PNG.
This commit is contained in:
The412Banner committed 2026-09-24 05:11:38 -04:00
1 parent e4e93c5f4a
commit 550d8711f2
3 files changed
+242 -2

No files matched your search

@@ -47,6 +47,7 @@ import com.droiddeck.launcher.ui.CreditsDialog
import com.droiddeck.launcher.ui.FrontEndScreen
import com.droiddeck.launcher.ui.FrontEndState
import com.droiddeck.launcher.ui.FrontEndActions
import com.droiddeck.launcher.frontend.CoverArt
import com.droiddeck.launcher.frontend.Library
import com.droiddeck.launcher.ui.DroidDeckTheme
import com.droiddeck.launcher.ui.RomsDialog
@@ -885,6 +886,12 @@ class MainActivity : ComponentActivity() {
} else emptyList()
val emus = Library.emulators(this) { id -> DesktopCatalog.installed(this, id) != null }
ui.post { steamGames = games; emulatorList = emus }
// Box art for the games that have none, fetched after the list is up; the list is
// rebuilt once if any was found.
if (!OfflineMode.enabled(this) && CoverArt.fetchMissing(this, emus.flatMap { it.games })) {
val refreshed = Library.emulators(this) { id -> DesktopCatalog.installed(this, id) != null }
ui.post { emulatorList = refreshed }
}
}, "library").start()
}
@@ -0,0 +1,229 @@
package com.droiddeck.launcher.frontend
import android.content.Context
import android.graphics.BitmapFactory
import android.util.Log
import org.json.JSONArray
import org.json.JSONObject
import java.io.File
import java.io.RandomAccessFile
import java.net.HttpURLConnection
import java.net.URL
import java.net.URLEncoder
/**
* Box art for the emulators' games, found and kept on the device: the front end shows a disc image
* with nothing but its emulator's logo otherwise.
*
* In order: the name of the file against RetroArch's thumbnail collection for the system
* (libretro-thumbnails, named after the standard disc-dump names - "Need for Speed - Underground 2
* (USA)"), first exactly and then loosely (tags dropped, the same region preferred) against the
* collection's list of names; then the disc's own ID, read from the image - PS2 serials against
* xlenore/ps2-covers (what PCSX2 and ARMSX2 download from), GameCube/Wii IDs against GameTDB (what
* Dolphin uses). A cover is downloaded once into files/covers; a game none of them has is not
* asked about again for a few days.
*/
object CoverArt {
private const val TAG = "CoverArt"
private const val MISS_RETRY_MS = 3L * 24 * 3600 * 1000
private const val INDEX_TTL_MS = 14L * 24 * 3600 * 1000
/** Downloads in one pass, so a first visit to a big library does not hold the network for long. */
private const val MAX_PER_PASS = 40
/** The emulator's systems in libretro-thumbnails, in the order they are tried. */
private val collections = mapOf(
"rpcs3" to listOf("Sony_-_PlayStation_3"),
"armsx2" to listOf("Sony_-_PlayStation_2"),
"duckstation" to listOf("Sony_-_PlayStation"),
"ppsspp" to listOf("Sony_-_PlayStation_Portable"),
"dolphin" to listOf("Nintendo_-_GameCube", "Nintendo_-_Wii"),
"melonds" to listOf("Nintendo_-_Nintendo_DS"),
"cemu" to listOf("Nintendo_-_Wii_U"),
)
private fun root(context: Context) = File(context.filesDir, "covers")
/** The file name, as the cover is kept under: a game keeps its art when its folder moves. */
private fun keyOf(rom: Library.Rom): String =
rom.hostPath.name.replace(Regex("[^A-Za-z0-9._() -]"), "_").take(150)
private fun coverFile(context: Context, rom: Library.Rom) = File(root(context), "${rom.emulatorId}/${keyOf(rom)}.img")
private fun missFile(context: Context, rom: Library.Rom) = File(root(context), "${rom.emulatorId}/${keyOf(rom)}.miss")
/** A cover already on the device for this game, or null. */
fun cached(context: Context, rom: Library.Rom): File? = coverFile(context, rom).takeIf { it.isFile && it.length() > 0 }
private fun wanted(context: Context, rom: Library.Rom): Boolean {
if (rom.art != null || cached(context, rom) != null || rom.emulatorId !in collections) return false
val miss = missFile(context, rom)
return !(miss.isFile && System.currentTimeMillis() - miss.lastModified() < MISS_RETRY_MS)
}
/**
* Looks for covers for the games that have none, on the calling (background) thread. True when
* at least one was found, so the caller rebuilds the list to show it.
*/
fun fetchMissing(context: Context, roms: List<Library.Rom>): Boolean {
var found = false
var tries = 0
for (rom in roms) {
if (!wanted(context, rom)) continue
if (++tries > MAX_PER_PASS) break
val url = try { findUrl(context, rom) } catch (e: Exception) { Log.w(TAG, "${rom.name}: $e"); null }
val target = coverFile(context, rom)
if (url != null && download(url, target)) {
Log.i(TAG, "${rom.name}: $url")
missFile(context, rom).delete()
found = true
} else {
missFile(context, rom).apply { parentFile?.mkdirs(); writeText(url ?: "") }
}
}
return found
}
private fun findUrl(context: Context, rom: Library.Rom): String? {
val name = rom.hostPath.nameWithoutExtension.removeSuffix(".dec")
for (collection in collections.getValue(rom.emulatorId)) {
// Exactly the dump name first: no listing needed.
val exact = thumbnailUrl(collection, name)
if (exists(exact)) return exact
// Then loosely, against the collection's names.
nearest(name, names(context, collection))?.let { return thumbnailUrl(collection, it) }
}
// The disc's own ID.
return when (rom.emulatorId) {
"armsx2" -> ps2Serial(rom.hostPath)?.let { "https://raw.githubusercontent.com/xlenore/ps2-covers/main/covers/default/$it.jpg" }
"dolphin" -> nintendoDiscId(rom.hostPath)?.let { id ->
val region = when (id.getOrNull(3)) { 'P' -> "EN"; 'J' -> "JA"; 'K' -> "KO"; else -> "US" }
"https://art.gametdb.com/wii/cover/$region/$id.png"
}
else -> null
}?.takeIf { exists(it) }
}
/** libretro-thumbnails replaces these in a title's file name. */
private fun thumbName(title: String) = title.replace(Regex("[&*/:`<>?\\\\|\"]"), "_")
private fun thumbnailUrl(collection: String, title: String) =
"https://raw.githubusercontent.com/libretro-thumbnails/$collection/master/Named_Boxarts/" +
URLEncoder.encode("${thumbName(title)}.png", "UTF-8").replace("+", "%20")
// ---- loose matching ------------------------------------------------------------------------
private fun tags(name: String): List<String> = Regex("[(\\[]([^)\\]]*)[)\\]]").findAll(name).map { it.groupValues[1].lowercase() }.toList()
/** A title without its tags, articles and punctuation: "Legend of Zelda, The (USA)" = "legend of zelda". */
private fun base(name: String): String = name
.replace(Regex("\\s*[(\\[][^)\\]]*[)\\]]"), " ")
.lowercase()
.replace(Regex("[^a-z0-9]+"), " ")
.split(' ').filter { it.isNotEmpty() && it != "the" && it != "a" }
.joinToString(" ")
private fun nearest(name: String, candidates: List<String>): String? {
if (candidates.isEmpty()) return null
val want = base(name)
if (want.isEmpty()) return null
val same = candidates.filter { base(it) == want }
if (same.isEmpty()) return null
val region = tags(name).firstOrNull { it in setOf("usa", "europe", "japan", "world", "korea") } ?: "usa"
return same.firstOrNull { region in tags(it) } ?: same.firstOrNull { "usa" in tags(it) } ?: same.first()
}
/** The titles in a collection's Named_Boxarts (no extension), kept for a fortnight. */
private fun names(context: Context, collection: String): List<String> {
val cache = File(root(context), "index-$collection.txt")
if (cache.isFile && System.currentTimeMillis() - cache.lastModified() < INDEX_TTL_MS) return cache.readLines()
val list = try {
val top = JSONArray(get("https://api.github.com/repos/libretro-thumbnails/$collection/contents/") ?: return cachedOr(cache))
val sha = (0 until top.length()).map { top.getJSONObject(it) }.firstOrNull { it.optString("name") == "Named_Boxarts" }
?.optString("sha") ?: return cachedOr(cache)
val tree = JSONObject(get("https://api.github.com/repos/libretro-thumbnails/$collection/git/trees/$sha") ?: return cachedOr(cache))
.getJSONArray("tree")
(0 until tree.length()).map { tree.getJSONObject(it).optString("path") }
.filter { it.endsWith(".png") }.map { it.removeSuffix(".png") }
} catch (e: Exception) {
Log.w(TAG, "index $collection: $e"); return cachedOr(cache)
}
cache.parentFile?.mkdirs()
cache.writeText(list.joinToString("\n"))
return list
}
private fun cachedOr(cache: File): List<String> = if (cache.isFile) cache.readLines() else emptyList()
// ---- disc IDs ------------------------------------------------------------------------------
/** "SLUS-21065" from a PS2 .iso's SYSTEM.CNF (BOOT2 = cdrom0:\SLUS_210.65;1), or null. */
private fun ps2Serial(file: File): String? {
if (!file.name.endsWith(".iso", ignoreCase = true)) return null
RandomAccessFile(file, "r").use { f ->
fun sector(lba: Long, length: Int): ByteArray = ByteArray(length).also { f.seek(lba * 2048); f.readFully(it) }
val pvd = sector(16, 2048)
if (String(pvd, 1, 5, Charsets.US_ASCII) != "CD001") return null
fun le32(b: ByteArray, at: Int) = (b[at].toLong() and 0xff) or ((b[at + 1].toLong() and 0xff) shl 8) or
((b[at + 2].toLong() and 0xff) shl 16) or ((b[at + 3].toLong() and 0xff) shl 24)
val rootLba = le32(pvd, 156 + 2)
val rootSize = le32(pvd, 156 + 10).toInt().coerceAtMost(64 * 1024)
val dir = sector(rootLba, rootSize)
var at = 0
while (at < dir.size) {
val len = dir[at].toInt() and 0xff
if (len == 0) { at = (at / 2048 + 1) * 2048; continue }
val nameLen = dir[at + 32].toInt() and 0xff
val name = String(dir, at + 33, nameLen, Charsets.US_ASCII)
if (name.startsWith("SYSTEM.CNF", ignoreCase = true)) {
val cnf = String(sector(le32(dir, at + 2), le32(dir, at + 10).toInt().coerceAtMost(4096)), Charsets.US_ASCII)
val m = Regex("BOOT2\\s*=\\s*cdrom0:\\\\?([A-Z]{4})_(\\d{3})\\.(\\d{2})").find(cnf) ?: return null
return "${m.groupValues[1]}-${m.groupValues[2]}${m.groupValues[3]}"
}
at += len
}
}
return null
}
/** The six-character ID of a GameCube/Wii disc image (.iso/.gcm, or .wbfs), or null. */
private fun nintendoDiscId(file: File): String? {
val offset = when (file.extension.lowercase()) { "iso", "gcm" -> 0L; "wbfs" -> 0x200L; else -> return null }
RandomAccessFile(file, "r").use { f ->
val b = ByteArray(6); f.seek(offset); f.readFully(b)
val id = String(b, Charsets.US_ASCII)
return id.takeIf { it.all { c -> c.isLetterOrDigit() } }
}
}
// ---- network -------------------------------------------------------------------------------
private fun open(url: String, method: String = "GET"): HttpURLConnection =
(URL(url).openConnection() as HttpURLConnection).apply {
requestMethod = method
connectTimeout = 10_000
readTimeout = 20_000
instanceFollowRedirects = true
setRequestProperty("User-Agent", "DroidDeck")
}
private fun exists(url: String): Boolean = try {
val c = open(url, "HEAD"); val ok = c.responseCode == 200; c.disconnect(); ok
} catch (e: Exception) { false }
private fun get(url: String): String? = try {
val c = open(url)
if (c.responseCode != 200) { c.disconnect(); null } else c.inputStream.bufferedReader().use { it.readText() }
} catch (e: Exception) { Log.w(TAG, "$url: $e"); null }
/** Saves the image at [url] to [target] if it really is an image. */
private fun download(url: String, target: File): Boolean = try {
val c = open(url)
if (c.responseCode != 200) { c.disconnect(); false } else {
target.parentFile?.mkdirs()
val tmp = File(target.path + ".part")
c.inputStream.use { input -> tmp.outputStream().use { input.copyTo(it) } }
val bounds = BitmapFactory.Options().apply { inJustDecodeBounds = true }
BitmapFactory.decodeFile(tmp.path, bounds)
if (bounds.outWidth > 0 && tmp.renameTo(target)) true else { tmp.delete(); false }
}
} catch (e: Exception) { Log.w(TAG, "$url: $e"); false }
}
@@ -104,7 +104,9 @@ object Library {
// A PS3 disc dump is a folder with PS3_GAME in it; RPCS3 boots the folder.
if (spec.id == "rpcs3" && File(dir, "PS3_GAME").isDirectory) {
val rel = dir.relativeTo(romsRoot).path
games.add(Rom(dir.name, dir, "/root/ROMs/$rel", spec.id))
games.add(Rom(dir.name, dir, "/root/ROMs/$rel", spec.id,
// The dump carries its own art, as an installed package does.
art = File(dir, "PS3_GAME/ICON0.PNG").takeIf { it.isFile }))
continue
}
dir.listFiles()?.sortedBy { it.name.lowercase() }?.forEach { f ->
@@ -118,7 +120,9 @@ object Library {
}
}
if (spec.id == "rpcs3") games.addAll(rpcs3Installed(context))
Emulator(spec.id, spec.name, spec.system, spec.program, installedPackage(installedIds.getValue(spec.id)), games)
// A cover found for the game before (CoverArt) where it has no art of its own.
val withArt = games.map { g -> if (g.art != null) g else CoverArt.cached(context, g)?.let { Rom(g.name, g.hostPath, g.guestPath, g.emulatorId, it) } ?: g }
Emulator(spec.id, spec.name, spec.system, spec.program, installedPackage(installedIds.getValue(spec.id)), withArt)
}
}