refactor(details): Improve download and downgrade UX

This commit enhances the user experience on the details screen by improving the download and version management logic.

Downloads are now cached within a screen session. If a user dismisses an install prompt and retries the installation, the app will reuse the already-downloaded file instead of re-downloading it. The download progress indicator now displays the downloaded size (e.g., "14.2 MB / 25.0 MB") for better feedback. Temporary files from canceled or completed downloads are now reliably cleaned up when the user navigates away from the screen.

The downgrade detection logic has also been made more robust. It now uses the release list order as the primary method to determine if a selected version is older, falling back to semantic version comparison only when necessary. This provides more accurate downgrade warnings.

Finally, ProGuard/R8 is now enabled for release builds to optimize and shrink the application size.

- **feat(download)**: Reuse an already-downloaded file if the user cancels the install prompt and then re-initiates it in the same session.
- **feat(download)**: Display download progress with file sizes (e.g., "X MB / Y MB") instead of just a percentage.
- **fix(download)**: Ensure partially downloaded and cached files are properly cleaned up when the user leaves the details screen.

Author: rainxchzed

composeApp/release/baselineProfiles/0/composeApp-release.dm

@@ -33,6 +33,8 @@ data class DetailsState(
 
     val isDownloading: Boolean = false,
     val downloadProgressPercent: Int? = null,
+    val downloadedBytes: Long = 0L,
+    val totalBytes: Long? = null,
     val isInstalling: Boolean = false,
     val downloadError: String? = null,
     val installError: String? = null,

composeApp/release/baselineProfiles/1/composeApp-release.dm

@@ -66,6 +66,9 @@ class DetailsViewModel(
     private var hasLoadedInitialData = false
     private var currentDownloadJob: Job? = null
     private var currentAssetName: String? = null
+    // Tracks the most recently downloaded file so it can be reused if the user
+    // dismisses the install dialog and re-clicks install on the same screen session.
+    private var cachedDownloadAssetName: String? = null
 
     private val _state = MutableStateFlow(DetailsState())
     val state = _state
@@ -314,23 +317,19 @@ class DetailsViewModel(
                 val installedApp = _state.value.installedApp
 
                 if (primary != null && release != null) {
+                    // Downgrade detection: only warn when the user picks an OLDER version
                     if (installedApp != null &&
                         !installedApp.isPendingInstall &&
-                        !installedApp.isUpdateAvailable &&
                         normalizeVersion(release.tagName) != normalizeVersion(installedApp.installedVersion) &&
                         platform == Platform.ANDROID
                     ) {
-                        val isConfirmedDowngrade = if (
-                            normalizeVersion(release.tagName) == normalizeVersion(installedApp.latestVersion) &&
-                            (installedApp.latestVersionCode ?: 0L) > 0
-                        ) {
-                            installedApp.installedVersionCode > (installedApp.latestVersionCode
-                                ?: 0L)
-                        } else {
-                            true
-                        }
+                        val isDowngrade = isDowngradeVersion(
+                            candidate = release.tagName,
+                            current = installedApp.installedVersion,
+                            allReleases = _state.value.allReleases
+                        )
 
-                        if (isConfirmedDowngrade) {
+                        if (isDowngrade) {
                             viewModelScope.launch {
                                 _events.send(
                                     DetailsEvent.ShowDowngradeWarning(
@@ -369,21 +368,17 @@ class DetailsViewModel(
 
                 val assetName = currentAssetName
                 if (assetName != null) {
-                    viewModelScope.launch {
-                        try {
-                            val deleted = downloader.cancelDownload(assetName)
-                            logger.debug("Cancel download - file deleted: $deleted")
-
-                            appendLog(
-                                assetName = assetName,
-                                size = 0L,
-                                tag = _state.value.selectedRelease?.tagName ?: "",
-                                result = LogResult.Cancelled
-                            )
-                        } catch (t: Throwable) {
-                            logger.error("Failed to cancel download: ${t.message}")
-                        }
-                    }
+                    // Keep the partially/fully downloaded file so the user can resume
+                    // without re-downloading. It will be cleaned up in onCleared().
+                    cachedDownloadAssetName = assetName
+                    val releaseTag = _state.value.selectedRelease?.tagName ?: ""
+                    appendLog(
+                        assetName = assetName,
+                        size = _state.value.downloadedBytes,
+                        tag = releaseTag,
+                        result = LogResult.Cancelled
+                    )
+                    logger.debug("Download cancelled – keeping file for potential reuse: $assetName")
                 }
 
                 currentAssetName = null
@@ -723,16 +718,43 @@ class DetailsViewModel(
                     extOrMime = assetName.substringAfterLast('.', "").lowercase()
                 )
 
-                _state.value = _state.value.copy(downloadStage = DownloadStage.DOWNLOADING)
-                downloader.download(downloadUrl, assetName).collect { p ->
-                    _state.value = _state.value.copy(downloadProgressPercent = p.percent)
-                    if (p.percent == 100) {
-                        _state.value = _state.value.copy(downloadStage = DownloadStage.VERIFYING)
+                // Check if file was already downloaded (e.g. user dismissed install dialog)
+                val existingPath = downloader.getDownloadedFilePath(assetName)
+                val filePath: String
+
+                if (existingPath != null && java.io.File(existingPath).exists()) {
+                    logger.debug("Reusing already downloaded file: $assetName")
+                    filePath = existingPath
+                    _state.value = _state.value.copy(
+                        downloadProgressPercent = 100,
+                        downloadedBytes = sizeBytes,
+                        totalBytes = sizeBytes,
+                        downloadStage = DownloadStage.VERIFYING
+                    )
+                } else {
+                    _state.value = _state.value.copy(
+                        downloadStage = DownloadStage.DOWNLOADING,
+                        downloadedBytes = 0L,
+                        totalBytes = sizeBytes
+                    )
+                    downloader.download(downloadUrl, assetName).collect { p ->
+                        _state.value = _state.value.copy(
+                            downloadProgressPercent = p.percent,
+                            downloadedBytes = p.bytesDownloaded,
+                            totalBytes = p.totalBytes ?: sizeBytes
+                        )
+                        if (p.percent == 100) {
+                            _state.value =
+                                _state.value.copy(downloadStage = DownloadStage.VERIFYING)
+                        }
                     }
-                }
 
-                val filePath = downloader.getDownloadedFilePath(assetName)
-                    ?: throw IllegalStateException("Downloaded file not found")
+                    filePath = downloader.getDownloadedFilePath(assetName)
+                        ?: throw IllegalStateException("Downloaded file not found")
+
+                    // Cache asset name so it persists for reuse until screen is left
+                    cachedDownloadAssetName = assetName
+                }
 
                 appendLog(
                     assetName = assetName,
@@ -983,9 +1005,19 @@ class DetailsViewModel(
         super.onCleared()
         currentDownloadJob?.cancel()
 
-        currentAssetName?.let { assetName ->
+        // When the screen is actually left (ViewModel destroyed), clean up any
+        // in-progress or cached download file so we don't accumulate stale files.
+        val assetsToClean = listOfNotNull(currentAssetName, cachedDownloadAssetName).distinct()
+        if (assetsToClean.isNotEmpty()) {
             viewModelScope.launch {
-                downloader.cancelDownload(assetName)
+                for (asset in assetsToClean) {
+                    try {
+                        downloader.cancelDownload(asset)
+                        logger.debug("Cleaned up download on screen leave: $asset")
+                    } catch (t: Throwable) {
+                        logger.error("Failed to clean download on leave: ${t.message}")
+                    }
+                }
             }
         }
     }
@@ -994,6 +1026,52 @@ class DetailsViewModel(
         return version?.removePrefix("v")?.removePrefix("V")?.trim() ?: ""
     }
 
+    /**
+     * Returns true if [candidate] is strictly older than [current].
+     * Uses list-index order as primary heuristic (releases are newest-first),
+     * and falls back to semantic version comparison when list lookup fails.
+     */
+    private fun isDowngradeVersion(
+        candidate: String,
+        current: String,
+        allReleases: List<GithubRelease>
+    ): Boolean {
+        val normalizedCandidate = normalizeVersion(candidate)
+        val normalizedCurrent = normalizeVersion(current)
+
+        if (normalizedCandidate == normalizedCurrent) return false
+
+        val candidateIndex = allReleases.indexOfFirst {
+            normalizeVersion(it.tagName) == normalizedCandidate
+        }
+        val currentIndex = allReleases.indexOfFirst {
+            normalizeVersion(it.tagName) == normalizedCurrent
+        }
+
+        // Both found in list → use list order (newer = lower index)
+        if (candidateIndex != -1 && currentIndex != -1) {
+            return candidateIndex > currentIndex
+        }
+
+        // Fallback: semantic version comparison
+        return compareSemanticVersions(normalizedCandidate, normalizedCurrent) < 0
+    }
+
+    /**
+     * Compares two semantic version strings. Returns positive if a > b, negative if a < b, 0 if equal.
+     */
+    private fun compareSemanticVersions(a: String, b: String): Int {
+        val aParts = a.split("[.\\-]".toRegex())
+        val bParts = b.split("[.\\-]".toRegex())
+        val maxLen = maxOf(aParts.size, bParts.size)
+        for (i in 0 until maxLen) {
+            val aPart = aParts.getOrNull(i)?.filter { it.isDigit() }?.toLongOrNull() ?: 0L
+            val bPart = bParts.getOrNull(i)?.filter { it.isDigit() }?.toLongOrNull() ?: 0L
+            if (aPart != bPart) return aPart.compareTo(bPart)
+        }
+        return 0
+    }
+
     private companion object {
         const val OBTAINIUM_REPO_ID: Long = 523534328
         const val APP_MANAGER_REPO_ID: Long = 268006778

feature/details/presentation/src/commonMain/kotlin/zed/rainxch/details/presentation/DetailsState.kt

@@ -251,8 +251,13 @@ fun SmartInstallButton(
                                     fontWeight = FontWeight.Bold
                                 )
 
+                                val progressText = if (state.totalBytes != null && state.totalBytes > 0) {
+                                    "${formatFileSize(state.downloadedBytes)} / ${formatFileSize(state.totalBytes)}"
+                                } else {
+                                    "${progress ?: 0}%"
+                                }
                                 Text(
-                                    text = "${progress ?: 0}%",
+                                    text = progressText,
                                     style = MaterialTheme.typography.bodySmall,
                                     color = MaterialTheme.colorScheme.onPrimary.copy(alpha = 0.8f)
                                 )
@@ -323,6 +328,9 @@ fun SmartInstallButton(
                         if (primaryAsset != null) {
                             val assetArch = extractArchitectureFromName(primaryAsset.name)
                             val systemArch = state.systemArchitecture
+                            val sizeText = formatFileSize(primaryAsset.size)
+                            val archLabel = assetArch ?: systemArch.name.lowercase()
+                            val subtitle = "$archLabel  \u2022  $sizeText"
 
                             Spacer(modifier = Modifier.height(2.dp))
 
@@ -331,7 +339,7 @@ fun SmartInstallButton(
                                 verticalAlignment = Alignment.CenterVertically
                             ) {
                                 Text(
-                                    text = assetArch ?: systemArch.name.lowercase(),
+                                    text = subtitle,
                                     color = if (enabled) {
                                         when {
                                             isUpdateAvailable -> MaterialTheme.colorScheme.onTertiary.copy(
@@ -449,6 +457,15 @@ private fun normalizeVersion(version: String): String {
     return version.removePrefix("v").removePrefix("V").trim()
 }
 
+private fun formatFileSize(bytes: Long): String {
+    return when {
+        bytes >= 1_073_741_824 -> "%.1f GB".format(bytes / 1_073_741_824.0)
+        bytes >= 1_048_576 -> "%.1f MB".format(bytes / 1_048_576.0)
+        bytes >= 1_024 -> "%.1f KB".format(bytes / 1_024.0)
+        else -> "$bytes B"
+    }
+}
+
 @Preview
 @Composable
 fun SmartInstallButtonDownloadingPreview() {