diff --git a/app/src/main/java/com/droiddeck/launcher/frontend/AddedGames.kt b/app/src/main/java/com/droiddeck/launcher/frontend/AddedGames.kt index 29974a4a54..3fbf9c215e 100644 --- a/app/src/main/java/com/droiddeck/launcher/frontend/AddedGames.kt +++ b/app/src/main/java/com/droiddeck/launcher/frontend/AddedGames.kt @@ -99,10 +99,11 @@ object AddedGames { fun candidates(folder: File): List = rank(folder).exes - fun rank(folder: File): GameExePicker.Ranking { + fun rank(folder: File, reuse: Boolean = false): GameExePicker.Ranking { val key = "${folder.path}|${folder.lastModified()}" val now = System.currentTimeMillis() ranked[key]?.takeIf { now - it.first < RANK_FRESH_MS }?.let { return it.second } + if (reuse) kept?.rank(folder)?.let { ranked[key] = now to it; return it } val guessed = GameExePicker.rank(folder) { !skipExe(it.name) } val declared = declaredExes(folder) val preferred = declared.map { it.path }.toSet() @@ -114,23 +115,27 @@ object AddedGames { ) if (ranked.size > 256) ranked.clear() ranked[key] = now to result + kept?.keepRank(folder, result) return result } private val ranked = java.util.concurrent.ConcurrentHashMap>() private const val RANK_FRESH_MS = 60_000L + @Volatile private var kept: AddedGamesCache? = null private val identified = java.util.concurrent.ConcurrentHashMap() internal fun identifiedName(folder: File, exe: File): String? { val key = "${exe.path}|${exe.length()}|${exe.lastModified()}|${folder.lastModified()}" identified[key]?.let { return it.ifEmpty { null } } + kept?.name(key)?.let { identified[key] = it; return it.ifEmpty { null } } val id = runCatching { GameIdentifier.identify(exe) }.getOrNull() val found = id?.name?.takeIf { id.nameSource in setOf(GameIdentifier.Source.STEAM_MANIFEST_ACF, GameIdentifier.Source.GOG_INFO, GameIdentifier.Source.PE_VERSION) } val name = found?.let { if (id?.nameSource == GameIdentifier.Source.PE_VERSION) betterSpelling(underscoresToSpaces(it), folder.name) else it } identified[key] = name.orEmpty() + kept?.keepName(key, name.orEmpty()) return name } @@ -172,17 +177,17 @@ object AddedGames { "launcher", "game", "engine", "system", "data", "app", ) - internal fun groupGames(folder: File): List? { + internal fun groupGames(folder: File, reuse: Boolean = false): List? { val files = folder.listFiles() ?: return null if (files.any { it.isFile && it.name.endsWith(".exe", ignoreCase = true) && !skipExe(it.name) }) return null if (declaredExes(folder).isNotEmpty()) return null val dirs = files.filter { it.isDirectory && !it.name.startsWith(".") && !isSteamLibraryFolder(it.name) }.sortedBy { it.name.lowercase() } if (dirs.any { it.name.lowercase() in GAME_PARTS || GameExePicker.auxiliaryDir(it) }) return null - return dirs.filter { rank(it).exes.isNotEmpty() }.takeIf { it.size >= 2 } + return dirs.filter { rank(it, reuse).exes.isNotEmpty() }.takeIf { it.size >= 2 } } - private fun expand(folder: File, entries: Set): List = - if (folder.path in entries) listOf(folder) else groupGames(folder) ?: listOf(folder) + private fun expand(folder: File, entries: Set, reuse: Boolean = false): List = + if (folder.path in entries) listOf(folder) else groupGames(folder, reuse) ?: listOf(folder) private fun entryFolders(context: Context): Set = AddedExes.list(context).map { it.folder }.toSet() @@ -192,7 +197,19 @@ object AddedGames { internal fun isSteamLibraryFolder(name: String): Boolean = name.equals("steamapps", ignoreCase = true) || name == com.droiddeck.launcher.session.GameStorage.X64_CARD_DIR - fun scan(context: Context): List { + private val scanning = Any() + + fun scan(context: Context): List = synchronized(scanning) { + val file = File(context.filesDir, AddedGamesCache.FILE) + val cache = kept?.takeIf { it.file == file } ?: AddedGamesCache(file).also { kept = it } + try { + scanAll(context) + } finally { + cache.save() + } + } + + private fun scanAll(context: Context): List { val out = ArrayList() GamesFolderMigration.run(context) val folders = listOfNotNull( @@ -208,16 +225,16 @@ object AddedGames { if (folder.name.lowercase() in steamInstalls || isSteamLibraryFolder(folder.name)) continue if (folder.path in removed) continue if (folder.name == "Games" && StoreInstallRoot.roots(context).any { it.absolutePath == folder.absolutePath }) continue - for (game in expand(folder, entries)) if (game.path !in removed) scanGame(context, game, out) + for (game in expand(folder, entries, reuse = true)) if (game.path !in removed) scanGame(context, game, out, reuse = true) } } for (entry in AddedExes.list(context)) { val folder = File(entry.folder) if (folder.path in removed || !folder.isDirectory) continue - scanGame(context, folder, out, single = entry) + scanGame(context, folder, out, single = entry, reuse = true) } - for (folder in libraryDepotInstalls(context)) if (folder.path !in removed) scanGame(context, folder, out) - for (folder in StoreInstallRoot.gameFolders(context)) if (StoreInstallRoot.isFinished(folder)) scanGame(context, folder, out) + for (folder in libraryDepotInstalls(context)) if (folder.path !in removed) scanGame(context, folder, out, reuse = true) + for (folder in StoreInstallRoot.gameFolders(context)) if (StoreInstallRoot.isFinished(folder)) scanGame(context, folder, out, reuse = true) for (game in com.droiddeck.launcher.runtime.BattleNet.games(context)) { if (game.folder.path !in removed) com.droiddeck.launcher.runtime.BattleNet.shortcut(context, game)?.let(out::add) } @@ -398,11 +415,11 @@ object AddedGames { private val INSTALL_DIR = Regex("\"installdir\"\\s*\"([^\"]*)\"", RegexOption.IGNORE_CASE) - private fun scanGame(context: Context, folder: File, out: MutableList, single: AddedExes.Entry? = null) { + private fun scanGame(context: Context, folder: File, out: MutableList, single: AddedExes.Entry? = null, reuse: Boolean = false) { run { val sidecar = StoreGameSidecar.read(folder) sidecar?.takeIf { it.id.isNotEmpty() }?.let { SessionPrefs.followStoreGame(context, "${it.store.id}:${it.id}", folder.path) { old -> !File(old).exists() } } - val ranking = rank(folder) + val ranking = rank(folder, reuse) val candidates = ranking.exes val picked = SessionPrefs.addedGameExe(context, folder.path) val chosen = picked.takeIf { it.isNotEmpty() }?.let { File(it) }?.takeIf { it.isFile } diff --git a/app/src/main/java/com/droiddeck/launcher/frontend/AddedGamesCache.kt b/app/src/main/java/com/droiddeck/launcher/frontend/AddedGamesCache.kt new file mode 100644 index 0000000000..0f5b08b117 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/frontend/AddedGamesCache.kt @@ -0,0 +1,85 @@ +package com.droiddeck.launcher.frontend + +import android.util.AtomicFile +import org.json.JSONArray +import org.json.JSONObject +import java.io.File +import java.util.concurrent.ConcurrentHashMap + +internal class AddedGamesCache(val file: File) { + private class Rank(val modified: Long, val at: Long, val ranking: GameExePicker.Ranking) + private class Name(val name: String, val at: Long) + + private val ranks = ConcurrentHashMap() + private val names = ConcurrentHashMap() + @Volatile private var changed = false + + init { + val json = runCatching { JSONObject(AtomicFile(file).readFully().toString(Charsets.UTF_8)) }.getOrNull() + json?.optJSONObject("ranks")?.let { all -> + for (path in all.keys()) { + val o = all.optJSONObject(path) ?: continue + val exes = o.optJSONArray("exes") ?: continue + val scores = o.optJSONArray("scores") ?: continue + if (exes.length() == 0 || exes.length() != scores.length()) continue + ranks[path] = Rank(o.optLong("modified"), o.optLong("at"), GameExePicker.Ranking( + List(exes.length()) { File(exes.getString(it)) }, List(scores.length()) { scores.getInt(it) }, o.optBoolean("uncertain"), + )) + } + } + json?.optJSONObject("names")?.let { all -> + for (key in all.keys()) all.optJSONObject(key)?.let { names[key] = Name(it.optString("name"), it.optLong("at")) } + } + } + + fun rank(folder: File): GameExePicker.Ranking? { + val kept = ranks[folder.path] ?: return null + val age = System.currentTimeMillis() - kept.at + val top = kept.ranking.exes.first() + return kept.ranking.takeIf { kept.modified == folder.lastModified() && age in 0 until KEEP_MS && top.isFile } + } + + fun keepRank(folder: File, ranking: GameExePicker.Ranking) { + if (ranking.exes.isEmpty()) { + if (ranks.remove(folder.path) != null) changed = true + return + } + ranks[folder.path] = Rank(folder.lastModified(), System.currentTimeMillis(), ranking) + changed = true + } + + fun name(key: String): String? = names[key]?.name + + fun keepName(key: String, name: String) { + names[key] = Name(name, System.currentTimeMillis()) + changed = true + } + + @Synchronized + fun save() { + if (!changed) return + changed = false + val oldest = System.currentTimeMillis() - KEEP_MS + val keptRanks = JSONObject() + ranks.forEach { (path, r) -> + if (r.at >= oldest) keptRanks.put(path, JSONObject().put("modified", r.modified).put("at", r.at) + .put("exes", JSONArray(r.ranking.exes.map { it.path })).put("scores", JSONArray(r.ranking.scores)) + .put("uncertain", r.ranking.uncertain)) + } + val keptNames = JSONObject() + names.forEach { (key, n) -> if (n.at >= oldest) keptNames.put(key, JSONObject().put("name", n.name).put("at", n.at)) } + val atomic = AtomicFile(file) + val out = atomic.startWrite() + try { + out.write(JSONObject().put("ranks", keptRanks).put("names", keptNames).toString().toByteArray()) + atomic.finishWrite(out) + } catch (e: Exception) { + atomic.failWrite(out) + } + } + + companion object { + const val FILE = "added-games-scan.json" + const val KEEP_MS = 7L * 24 * 3600 * 1000 + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/frontend/AddedGamesCacheTest.kt b/app/src/test/java/com/droiddeck/launcher/frontend/AddedGamesCacheTest.kt new file mode 100644 index 0000000000..753deb24ea --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/frontend/AddedGamesCacheTest.kt @@ -0,0 +1,83 @@ +package com.droiddeck.launcher.frontend + +import java.io.File +import org.json.JSONArray +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.Rule +import org.junit.Test +import org.junit.rules.TemporaryFolder +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.RuntimeEnvironment +import org.robolectric.annotation.Config + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [33]) +class AddedGamesCacheTest { + private val app get() = RuntimeEnvironment.getApplication() + @get:Rule val tmp = TemporaryFolder() + + private fun game(name: String = "Example"): Pair { + val folder = tmp.newFolder(name) + val exe = File(folder, "bin/$name.exe").apply { parentFile!!.mkdirs(); writeText("game") } + return folder to exe + } + + private fun store() = File(tmp.root, "scan.json") + + @Test fun aRankingIsReusedAfterARestartWhileItsFolderIsUnchanged() { + val (folder, exe) = game() + AddedGamesCache(store()).apply { keepRank(folder, GameExePicker.Ranking(listOf(exe), listOf(72), uncertain = true)); save() } + val kept = AddedGamesCache(store()).rank(folder) + assertEquals(listOf(exe), kept?.exes) + assertEquals(listOf(72), kept?.scores) + assertEquals(true, kept?.uncertain) + } + + @Test fun aChangedFolderOrAMissingExecutableIsWalkedAgain() { + val (folder, exe) = game() + AddedGamesCache(store()).apply { keepRank(folder, GameExePicker.Ranking(listOf(exe), listOf(72), false)); save() } + val modified = folder.lastModified() + folder.setLastModified(modified + 60_000) + assertNull(AddedGamesCache(store()).rank(folder)) + folder.setLastModified(modified) + assertNotNull(AddedGamesCache(store()).rank(folder)) + exe.delete() + assertNull(AddedGamesCache(store()).rank(folder)) + } + + @Test fun aRankingOlderThanAWeekIsWalkedAgain() { + val (folder, exe) = game() + val walked = System.currentTimeMillis() - AddedGamesCache.KEEP_MS - 1 + store().writeText(JSONObject().put("ranks", JSONObject().put(folder.path, JSONObject() + .put("modified", folder.lastModified()).put("at", walked) + .put("exes", JSONArray(listOf(exe.path))).put("scores", JSONArray(listOf(72))))).toString()) + assertNull(AddedGamesCache(store()).rank(folder)) + } + + @Test fun aFolderWithNoExecutableIsNotKept() { + val folder = tmp.newFolder("Empty") + AddedGamesCache(store()).apply { keepRank(folder, GameExePicker.Ranking(emptyList(), emptyList(), false)); save() } + assertFalse(store().exists()) + assertNull(AddedGamesCache(store()).rank(folder)) + } + + @Test fun anIdentifiedNameIsReusedAfterARestart() { + AddedGamesCache(store()).apply { keepName("named", "God of War"); keepName("unnamed", ""); save() } + val kept = AddedGamesCache(store()) + assertEquals("God of War", kept.name("named")) + assertEquals("", kept.name("unnamed")) + assertNull(kept.name("unknown")) + } + + @Test fun aScanKeepsEachGamesRankingForTheNextLaunch() { + val (folder, exe) = game("Card Game") + AddedExes.put(app, AddedExes.Entry(folder.path, exe.path, picked = false)) + AddedGames.scan(app) + assertEquals(listOf(exe.path), AddedGamesCache(File(app.filesDir, AddedGamesCache.FILE)).rank(folder)?.exes?.map { it.path }) + } +}