From 1a527e8ed19f0dc6eddaa359b120ba779d29de21 Mon Sep 17 00:00:00 2001 From: The412Banner Date: Thu, 8 Oct 2026 22:35:52 -0400 Subject: [PATCH] Stores: a download no longer slows the UI Engines report per chunk or per file, and every report published a new queue that the whole front end read - the rail badge was computed from it in the root composition. Progress-only changes now reach the UI at most four times a second (a stage or state change at once); each row and card reads only its own entry; the list is replaced only when rows come, go or change state; the badge count changes only when it changes; the notification redraws at most once a second. Download threads run at background priority - the queue's runner and every manager's pool - and the tier leaves two cores for the UI. The stores log is written in half-second batches. --- .../launcher/stores/StoreLogFiles.kt | 44 ++++++++++----- .../droiddeck/launcher/stores/StoresState.kt | 38 +++++++++++-- .../stores/amazon/AmazonDownloadManager.java | 2 +- .../launcher/stores/download/DownloadQueue.kt | 53 ++++++++++++++++--- .../stores/download/StoreDownloadService.kt | 11 ++-- .../stores/download/StoreDownloadTier.kt | 6 ++- .../stores/epic/EpicDownloadManager.java | 2 +- .../stores/gog/GogDownloadManager.java | 4 +- .../com/droiddeck/launcher/ui/StoresDetail.kt | 2 +- .../droiddeck/launcher/ui/StoresDownloads.kt | 3 +- .../com/droiddeck/launcher/ui/StoresPage.kt | 2 +- docs/progress-log.md | 9 ++++ 12 files changed, 141 insertions(+), 35 deletions(-) diff --git a/app/src/main/java/com/droiddeck/launcher/stores/StoreLogFiles.kt b/app/src/main/java/com/droiddeck/launcher/stores/StoreLogFiles.kt index 0791df3d1f..eb4a14fc2c 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/StoreLogFiles.kt +++ b/app/src/main/java/com/droiddeck/launcher/stores/StoreLogFiles.kt @@ -25,23 +25,39 @@ object StoreLogFiles { fun dir(context: Context): File = File(context.applicationContext.filesDir, "logs/stores") - /** Appends one stamped line to today's file. Any thread. */ + private val pending = java.util.concurrent.ConcurrentLinkedQueue() + private val flushQueued = java.util.concurrent.atomic.AtomicBoolean(false) + private val flusher = java.util.concurrent.Executors.newSingleThreadScheduledExecutor { r -> + Thread({ android.os.Process.setThreadPriority(android.os.Process.THREAD_PRIORITY_BACKGROUND); r.run() }, "store-log-flush").apply { isDaemon = true } + } + + /** + * Queues one stamped line for today's file. Any thread; nothing touches the disk here. Lines are + * written in batches, at most every half second, on [writer] in order. + */ fun append(context: Context, line: String) { val app = context.applicationContext - val now = Date() - writer.execute { - try { - val dir = dir(app).apply { mkdirs() } - val file = File(dir, "stores-${synchronized(DAY) { DAY.format(now) }}.log") - if (file.length() > MAX_BYTES) { - val old = File(dir, file.name + ".1") - old.delete() - file.renameTo(old) - } - file.appendText(line + "\n") - } catch (e: Exception) { - Log.w(TAG, "could not write the stores log: ${e.message}") + pending.add(line) + if (flushQueued.compareAndSet(false, true)) { + flusher.schedule({ flushQueued.set(false); writer.execute { flush(app) } }, 500, java.util.concurrent.TimeUnit.MILLISECONDS) + } + } + + private fun flush(app: Context) { + if (pending.isEmpty()) return + val batch = StringBuilder() + while (true) { val l = pending.poll() ?: break; batch.append(l).append('\n') } + try { + val dir = dir(app).apply { mkdirs() } + val file = File(dir, "stores-${synchronized(DAY) { DAY.format(Date()) }}.log") + if (file.length() > MAX_BYTES) { + val old = File(dir, file.name + ".1") + old.delete() + file.renameTo(old) } + file.appendText(batch.toString()) + } catch (e: Exception) { + Log.w(TAG, "could not write the stores log: ${e.message}") } } diff --git a/app/src/main/java/com/droiddeck/launcher/stores/StoresState.kt b/app/src/main/java/com/droiddeck/launcher/stores/StoresState.kt index 89861188f9..cf097ef4a0 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/StoresState.kt +++ b/app/src/main/java/com/droiddeck/launcher/stores/StoresState.kt @@ -47,17 +47,47 @@ object StoresState { var installed by mutableStateOf>(emptyList()) private set - /** The download queue as the Downloads page lists it, newest first. */ + /** + * The download queue as the Downloads page lists it, newest first. Replaced only when a row is + * added, removed, reordered or changes state - not on progress - so whatever iterates it does + * not recompose on every byte. A row's progress is read through [download]. + */ var downloads by mutableStateOf>(emptyList()) - internal set + private set + + /** Downloads queued, running or paused across the stores (the rail badge); changes only when the count does. */ + var activeDownloads by mutableStateOf(0) + private set + + private val rows = HashMap>() + + /** One row's live entry: a composable reading it recomposes for that row's progress only. Main thread. */ + fun download(key: String): DownloadEntry? = rows.getOrPut(key) { mutableStateOf(null) }.value + + /** Main thread: each row's holder set (equal entries change nothing), the list and the count only when they change. */ + /** The newest list as published, progress included; for the notification, which is not composed. */ + @Volatile var latestDownloads: List = emptyList() + private set + private var notifiedAt = 0L + + internal fun publishDownloads(list: List) { + latestDownloads = list + // The notification follows at most once a second. + val now = android.os.SystemClock.uptimeMillis() + if (now - notifiedAt >= 1000) { notifiedAt = now; com.droiddeck.launcher.stores.download.StoreDownloadService.tick() } + val keys = list.mapTo(HashSet()) { it.key } + for (e in list) rows.getOrPut(e.key) { mutableStateOf(null) }.value = e + for ((k, holder) in rows) if (k !in keys) holder.value = null + val shape = { l: List -> l.map { it.key to it.state } } + if (shape(list) != shape(downloads)) downloads = list + activeDownloads = list.count { it.isActive } + } /** The native engine's version once probed, "" when the probe said it is missing, null before. */ var engine by mutableStateOf(null) private set - /** Downloads queued, running or paused across the stores (the rail badge). */ - val activeDownloads: Int get() = downloads.count { it.isActive } private val backends = HashMap() diff --git a/app/src/main/java/com/droiddeck/launcher/stores/amazon/AmazonDownloadManager.java b/app/src/main/java/com/droiddeck/launcher/stores/amazon/AmazonDownloadManager.java index c24ebf6c43..82a8b23ea4 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/amazon/AmazonDownloadManager.java +++ b/app/src/main/java/com/droiddeck/launcher/stores/amazon/AmazonDownloadManager.java @@ -99,7 +99,7 @@ public final class AmazonDownloadManager { } } else { cb.onLog("amazon: engine=built-in (" + MAX_PARALLEL + " threads)"); - ExecutorService pool = Executors.newFixedThreadPool(MAX_PARALLEL); + ExecutorService pool = Executors.newFixedThreadPool(MAX_PARALLEL, com.droiddeck.launcher.stores.download.DownloadQueue.workerFactory("amazon-dl")); List> futures = new ArrayList<>(); for (AmazonManifest.ManifestFile file : files) { final String dlUrl = spec.downloadUrl; diff --git a/app/src/main/java/com/droiddeck/launcher/stores/download/DownloadQueue.kt b/app/src/main/java/com/droiddeck/launcher/stores/download/DownloadQueue.kt index 01d84e53c2..7076c850e3 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/download/DownloadQueue.kt +++ b/app/src/main/java/com/droiddeck/launcher/stores/download/DownloadQueue.kt @@ -58,9 +58,11 @@ object DownloadQueue { private fun enter(key: String, stage: DownloadStage, detail: String) { synchronized(lock) { val item = items[key] ?: return + val moved = item.entry.stage != stage || item.entry.state != DownloadState.RUNNING transitionLocked(item, stage) item.entry = item.entry.copy(detail = detail.ifEmpty { item.entry.detail }, state = DownloadState.RUNNING) - publishLocked() + // A new stage shows at once; a new line within the same stage (one per file) waits its turn. + publishLocked(progressOnly = !moved) } } @@ -90,7 +92,7 @@ object DownloadQueue { if (bytes) speed = sample(item, done) val eta = if (bytes && speed > 0 && total > done) (total - done) / speed else -1L item.entry = e.copy(stageDone = done, stageTotal = total, stageItems = files, stageItemsTotal = filesTotal, speedBps = if (bytes) speed else 0, etaSeconds = eta) - publishLocked() + publishLocked(progressOnly = true) } } @@ -120,8 +122,9 @@ object DownloadQueue { if (bytesDone >= 0) sample(item, done) val speed = item.speedEwma.toLong() val eta = if (speed > 0 && total > done) (total - done) / speed else -1L + val moved = e.stage != DownloadStage.DOWNLOAD || e.state != DownloadState.RUNNING item.entry = e.copy(state = DownloadState.RUNNING, stage = DownloadStage.DOWNLOAD, bytesDone = done, bytesTotal = total, detail = detail ?: e.detail, speedBps = speed, etaSeconds = eta) - publishLocked() + publishLocked(progressOnly = !moved) } } @@ -138,6 +141,18 @@ object DownloadQueue { fun parallel(context: Context): Int = SessionPrefs.gameStoresParallel(context) + /** Threads for a store's download pool: background priority, so the UI and its render thread come first. */ + @JvmStatic + fun workerFactory(name: String): java.util.concurrent.ThreadFactory { + val n = java.util.concurrent.atomic.AtomicInteger() + return java.util.concurrent.ThreadFactory { r -> + Thread({ + android.os.Process.setThreadPriority(android.os.Process.THREAD_PRIORITY_BACKGROUND) + r.run() + }, "$name-${n.incrementAndGet()}") + } + } + fun setParallel(context: Context, count: Int) { SessionPrefs.setGameStoresParallel(context, count) advance(context.applicationContext) @@ -258,10 +273,33 @@ object DownloadQueue { private fun publish(context: Context) { synchronized(lock) { publishLocked() }; StoreDownloadService.sync(context) } - /** Newest first: what was started last sits on top, as the preview lists them. Caller holds [lock]. */ - private fun publishLocked() { + /** At most this often a progress-only change reaches the UI; a state or stage change goes at once. */ + private const val PROGRESS_PUBLISH_MS = 250L + private var lastPublishAt = 0L + private var publishPending = false + private val main = android.os.Handler(android.os.Looper.getMainLooper()) + + /** + * Newest first: what was started last sits on top, as the preview lists them. Caller holds + * [lock]. Engines report per chunk or per file - hundreds of times a second at full speed - so + * [progressOnly] changes are coalesced to [PROGRESS_PUBLISH_MS]; the UI then recomposes a few + * times a second, not on every callback. + */ + private fun publishLocked(progressOnly: Boolean = false) { + val now = android.os.SystemClock.uptimeMillis() + if (progressOnly) { + val wait = lastPublishAt + PROGRESS_PUBLISH_MS - now + if (wait > 0) { + if (!publishPending) { + publishPending = true + main.postDelayed({ synchronized(lock) { publishPending = false; publishLocked() } }, wait) + } + return + } + } + lastPublishAt = now val list = items.values.map { it.entry }.sortedByDescending { it.startedAt } - StoresState.post { StoresState.downloads = list } + StoresState.post { StoresState.publishDownloads(list) } } /** Starts queued items while slots are free. */ @@ -282,6 +320,9 @@ object DownloadQueue { } private fun runItem(context: Context, item: Item) { + // Downloads run beside the UI, never ahead of it: background priority for this thread and + // (through [workerFactory]) every pool a store's manager starts. + android.os.Process.setThreadPriority(android.os.Process.THREAD_PRIORITY_BACKGROUND) val handle = JobHandle(item.entry.key, item.cancelled) var result: String? = null var error: String? = null diff --git a/app/src/main/java/com/droiddeck/launcher/stores/download/StoreDownloadService.kt b/app/src/main/java/com/droiddeck/launcher/stores/download/StoreDownloadService.kt index f3c2a52db7..6e1ee292fb 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/download/StoreDownloadService.kt +++ b/app/src/main/java/com/droiddeck/launcher/stores/download/StoreDownloadService.kt @@ -52,7 +52,7 @@ class StoreDownloadService : Service() { override fun onBind(intent: Intent?): IBinder? = null private fun build(): Notification { - val entries = StoresState.downloads.filter { it.state == DownloadState.RUNNING } + val entries = StoresState.latestDownloads.filter { it.state == DownloadState.RUNNING } val first = entries.firstOrNull() val title = if (active.size > 1) getString(R.string.stores_notification_many, active.size) else getString(R.string.stores_notification_one) val text = when { @@ -90,7 +90,7 @@ class StoreDownloadService : Service() { /** A download started: the service is up (idempotent). */ fun start(context: Context) { - StoresState.downloads.filter { it.state == DownloadState.RUNNING }.forEach { active.add(it.key) } + StoresState.latestDownloads.filter { it.state == DownloadState.RUNNING }.forEach { active.add(it.key) } try { val app = context.applicationContext val intent = Intent(app, StoreDownloadService::class.java) @@ -100,6 +100,11 @@ class StoreDownloadService : Service() { } } + /** Progress moved: redraw the notification line (StoresState calls it at most once a second). */ + fun tick() { + instance?.refresh() + } + /** The queue changed: redraw the notification line. */ fun sync(context: Context) { instance?.refresh() @@ -109,7 +114,7 @@ class StoreDownloadService : Service() { fun finish(context: Context, key: String) { active.remove(key) val inst = instance ?: return - if (active.isEmpty() && StoresState.downloads.none { it.state == DownloadState.RUNNING }) inst.stopNow() else inst.refresh() + if (active.isEmpty() && StoresState.latestDownloads.none { it.state == DownloadState.RUNNING }) inst.stopNow() else inst.refresh() } } } diff --git a/app/src/main/java/com/droiddeck/launcher/stores/download/StoreDownloadTier.kt b/app/src/main/java/com/droiddeck/launcher/stores/download/StoreDownloadTier.kt index 02c299eecc..3b12de899a 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/download/StoreDownloadTier.kt +++ b/app/src/main/java/com/droiddeck/launcher/stores/download/StoreDownloadTier.kt @@ -19,7 +19,11 @@ enum class StoreDownloadTier(val id: String, @StringRes val label: Int, val netw MAX("max", R.string.stores_tier_max, 96, 0.8); /** Inflate / hash / write workers for this device, at least two so a fetch never waits on a single writer. */ - val processWorkers: Int get() = (Runtime.getRuntime().availableProcessors() * decompressPerCore).toInt().coerceIn(2, 32) + /** Inflate / hash / write threads: by the tier, but two cores always left for the UI (at least 2 workers). */ + val processWorkers: Int get() { + val cores = Runtime.getRuntime().availableProcessors() + return (cores * decompressPerCore).toInt().coerceIn(2, maxOf(2, minOf(32, cores - 2))) + } companion object { val ALL: List = entries diff --git a/app/src/main/java/com/droiddeck/launcher/stores/epic/EpicDownloadManager.java b/app/src/main/java/com/droiddeck/launcher/stores/epic/EpicDownloadManager.java index 552ad648c4..16ff379c09 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/epic/EpicDownloadManager.java +++ b/app/src/main/java/com/droiddeck/launcher/stores/epic/EpicDownloadManager.java @@ -225,7 +225,7 @@ public final class EpicDownloadManager { } if (javaPool) { cb.onLog("epic: engine=built-in (8 threads)"); - ExecutorService pool = Executors.newFixedThreadPool(8); + ExecutorService pool = Executors.newFixedThreadPool(8, com.droiddeck.launcher.stores.download.DownloadQueue.workerFactory("epic-dl")); for (ChunkInfo chunk : needed) { final ChunkInfo fc = chunk; pool.submit(() -> { diff --git a/app/src/main/java/com/droiddeck/launcher/stores/gog/GogDownloadManager.java b/app/src/main/java/com/droiddeck/launcher/stores/gog/GogDownloadManager.java index 7b54f6420f..79ea513b24 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/gog/GogDownloadManager.java +++ b/app/src/main/java/com/droiddeck/launcher/stores/gog/GogDownloadManager.java @@ -216,7 +216,7 @@ public final class GogDownloadManager { cancelled, anyFailed, doneCount, total, planned, totalBytes, lastSpeedMs, lastSpeedB, speedBps, cb); } else { cb.onLog("gog: engine=built-in (" + threads + " threads)"); - ExecutorService pool = Executors.newFixedThreadPool(threads); + ExecutorService pool = Executors.newFixedThreadPool(threads, com.droiddeck.launcher.stores.download.DownloadQueue.workerFactory("gog-dl")); List> futures = new ArrayList<>(); for (DepotFile df : files) { futures.add(pool.submit((Callable) () -> { @@ -364,7 +364,7 @@ public final class GogDownloadManager { new AtomicReference<>(""), null, null, new AtomicInteger(0), 0, threads, threads, false, "gog gen1=" + game.gameId, cancelled, anyFailed, done, total, planned, totalBytes, lastSpeedMs, lastSpeedB, speedBps, cb); } else { - ExecutorService pool = Executors.newFixedThreadPool(threads); + ExecutorService pool = Executors.newFixedThreadPool(threads, com.droiddeck.launcher.stores.download.DownloadQueue.workerFactory("gog-dl")); List> futures = new ArrayList<>(); for (Gen1File gf : files) { futures.add(pool.submit((Callable) () -> { diff --git a/app/src/main/java/com/droiddeck/launcher/ui/StoresDetail.kt b/app/src/main/java/com/droiddeck/launcher/ui/StoresDetail.kt index 3748a58cc8..403a1a47ea 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/StoresDetail.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/StoresDetail.kt @@ -48,7 +48,7 @@ internal fun StoreGameDetail(store: Store, key: String, s: FrontEndState, a: Fro val id = key.substringAfter(':') val item = (StoresState.library[store].orEmpty() + StoresState.shelves[store]?.all.orEmpty()).firstOrNull { it.id == id } val installed = StoresState.installedGame(store, id) - val download = StoresState.downloads.firstOrNull { it.store == store && it.id == id && it.isActive } + val download = StoresState.download("${store.id}:$id")?.takeIf { it.isActive } // Removal asks twice: one stray press of A should not cost a download. var confirmRemove by remember(key) { mutableStateOf(false) } LaunchedEffect(confirmRemove) { if (confirmRemove) { kotlinx.coroutines.delay(4000); confirmRemove = false } } diff --git a/app/src/main/java/com/droiddeck/launcher/ui/StoresDownloads.kt b/app/src/main/java/com/droiddeck/launcher/ui/StoresDownloads.kt index ead3832037..eb0123d786 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/StoresDownloads.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/StoresDownloads.kt @@ -76,7 +76,8 @@ private fun DownloadList(s: FrontEndState, a: FrontEndActions) { return } Column(verticalArrangement = Arrangement.spacedBy(10.dp)) { - entries.forEachIndexed { i, d -> key(d.key) { Rise(1 + i.coerceAtMost(5)) { DownloadCard(d, s, a) } } } + // The list changes only when rows come, go or change state; each row reads its own progress. + entries.forEachIndexed { i, row -> key(row.key) { Rise(1 + i.coerceAtMost(5)) { DownloadCard(StoresState.download(row.key) ?: row, s, a) } } } } } diff --git a/app/src/main/java/com/droiddeck/launcher/ui/StoresPage.kt b/app/src/main/java/com/droiddeck/launcher/ui/StoresPage.kt index 798f739f35..5692becdb5 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/StoresPage.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/StoresPage.kt @@ -442,7 +442,7 @@ private fun GameCard(item: CatalogItem, store: Store, s: FrontEndState, a: Front val pressed by src.collectIsPressedAsState() val scale by animateFloatAsState(if (pressed) 0.985f else 1f, Motion.sp(0.5f, Spring.StiffnessMedium), label = "cardScale") val installed = item.id in installedKeys - val download = StoresState.downloads.firstOrNull { it.store == store && it.id == item.id && it.isActive } + val download = StoresState.download("${store.id}:${item.id}")?.takeIf { it.isActive } val open = { onOpen(item.key) } Column( modifier = Modifier.fillMaxWidth().paneItem("card:${item.key}").then(if (first) Modifier.firstTile() else Modifier).graphicsLayer { scaleX = scale; scaleY = scale } diff --git a/docs/progress-log.md b/docs/progress-log.md index 668d367bc2..dcb3814adb 100644 --- a/docs/progress-log.md +++ b/docs/progress-log.md @@ -144,6 +144,15 @@ without it and Setup says "Stores engine not built"). (`token`, `__token__`, `f_token`, `hdnts`, access/refresh/id tokens, `code=`) and Authorization / Cookie headers are blanked outside URLs too. `StoreLogTest` covers a GOG secure link and an Epic Akamai URL. The engine's own logcat lines (tag `EpicNative` etc.) are written on the native side. +- **UI slow while downloading (device):** engines report per chunk or file, and each report + published a new queue that the whole front end read (the rail badge was computed from it in the + root composition). Now progress-only changes reach the UI at most four times a second (stage and + state changes at once), each row and card reads only its own entry, the list replaces itself only + when rows come, go or change state, the badge count changes only when it changes, and the + notification redraws at most once a second. Download threads run at background priority (the + queue's runner and every Java pool), the tier leaves two cores free (`processWorkers` capped at + cores - 2, at least 2), and the stores log is written in half-second batches. The native engine's + own threads need the same priority on its side. - **Installed tab empty under "Installed (2)" (device):** the count came from the installs on disk, the grid from the library filtered by id. Both now come from `installedCards`: each install joined to its library item by id (or title), else a card from the sidecar's title and art.