feat: downloads storage manager tab

app/src/main/java/app/gamenative/db/dao/AmazonGameDao.kt

@@ -29,6 +29,9 @@ interface AmazonGameDao {
     @Query("SELECT * FROM amazon_games ORDER BY title ASC")
     suspend fun getAllAsList(): List<AmazonGame>
 
+    @Query("SELECT * FROM amazon_games WHERE is_installed = 0")
+    suspend fun getNonInstalledGames(): List<AmazonGame>
+
     @Query(
         "UPDATE amazon_games SET is_installed = 1, install_path = :path, install_size = :size, version_id = :versionId WHERE product_id = :productId",
     )

app/src/main/java/app/gamenative/db/dao/DownloadingAppInfoDao.kt

@@ -11,15 +11,15 @@ interface DownloadingAppInfoDao {
     @Insert(onConflict = OnConflictStrategy.REPLACE)
     suspend fun insert(appInfo: DownloadingAppInfo)
 
+    @Query("SELECT * FROM downloading_app_info")
+    suspend fun getAll(): List<DownloadingAppInfo>
+
     @Query("SELECT * FROM downloading_app_info WHERE appId = :appId")
     suspend fun getDownloadingApp(appId: Int): DownloadingAppInfo?
 
     @Query("DELETE from downloading_app_info WHERE appId = :appId")
     suspend fun deleteApp(appId: Int)
 
-    @Query("SELECT * FROM downloading_app_info")
-    suspend fun getAll(): List<DownloadingAppInfo>
-
     @Query("DELETE from downloading_app_info")
     suspend fun deleteAll()
 }

app/src/main/java/app/gamenative/db/dao/EpicGameDao.kt

@@ -53,9 +53,15 @@ interface EpicGameDao {
     @Query("SELECT * FROM epic_games WHERE is_dlc = 0 AND namespace != 'ue' AND namespace != '89efe5924d3d467c839449ab6ab52e7f' ORDER BY title ASC")
     fun getAll(): Flow<List<EpicGame>>
 
+    @Query("SELECT * FROM epic_games WHERE is_dlc = 0 AND namespace != 'ue' AND namespace != '89efe5924d3d467c839449ab6ab52e7f' ORDER BY title ASC")
+    suspend fun getAllAsList(): List<EpicGame>
+
     @Query("SELECT * FROM epic_games WHERE is_installed = :isInstalled ORDER BY title ASC")
     fun getByInstallStatus(isInstalled: Boolean): Flow<List<EpicGame>>
 
+    @Query("SELECT * FROM epic_games WHERE is_installed = 0 ORDER BY title ASC")
+    suspend fun getNonInstalledGames(): List<EpicGame>
+
     @Query("SELECT * FROM epic_games WHERE base_game_app_name = (SELECT catalog_id FROM epic_games WHERE id = :appId)")
     fun getDLCForTitle(appId: Int): Flow<List<EpicGame>>
 

app/src/main/java/app/gamenative/db/dao/GOGGameDao.kt

@@ -43,6 +43,9 @@ interface GOGGameDao {
     @Query("SELECT * FROM gog_games WHERE is_installed = :isInstalled AND exclude = 0 ORDER BY title ASC")
     fun getByInstallStatus(isInstalled: Boolean): Flow<List<GOGGame>>
 
+    @Query("SELECT * FROM gog_games WHERE is_installed = 0 AND exclude = 0")
+    suspend fun getNonInstalledGames(): List<GOGGame>
+
     @Query("SELECT * FROM gog_games WHERE exclude = 0 AND title LIKE '%' || :searchQuery || '%' ORDER BY title ASC")
     fun searchByTitle(searchQuery: String): Flow<List<GOGGame>>
 

app/src/main/java/app/gamenative/db/dao/SteamAppDao.kt

@@ -91,6 +91,17 @@ interface SteamAppDao {
             flow { emit(_getAllOwnedAppsPaged(invalidPkgId)) }
         }
 
+    @Query(
+        "SELECT * FROM steam_app " +
+            "WHERE id != 480 " +
+            "AND package_id != :invalidPkgId " +
+            "AND type != 0 " +
+            "ORDER BY LOWER(name)",
+    )
+    suspend fun getAllOwnedAppsAsList(
+        invalidPkgId: Int = INVALID_PKG_ID,
+    ): List<SteamApp>
+
     @Query("SELECT * FROM steam_app WHERE received_pics = 0 AND package_id != :invalidPkgId AND owner_account_id = :ownerId")
     fun getAllOwnedAppsWithoutPICS(
         ownerId: Int,

app/src/main/java/app/gamenative/service/SteamService.kt

@@ -353,7 +353,7 @@ class SteamService : Service(), IChallengeUrlChanged {
             }
 
             val dirPath = getAppDirPath(appId)
-            return File(dirPath).exists() && !MarkerUtils.hasMarker(dirPath, Marker.DOWNLOAD_COMPLETE_MARKER)
+            return MarkerUtils.hasPartialInstall(dirPath)
         }
 
         private val syncInProgressApps = ConcurrentHashMap<Int, AtomicBoolean>()
@@ -564,6 +564,15 @@ class SteamService : Service(), IChallengeUrlChanged {
             return downloadJobs[appId]
         }
 
+        fun getActiveDownloads(): Map<Int, DownloadInfo> = HashMap(downloadJobs)
+
+        suspend fun getPartialDownloads(): List<Int> {
+            return instance?.downloadingAppInfoDao?.getAll()
+                ?.map { it.appId }
+                ?.filter { appId -> !downloadJobs.containsKey(appId) }
+                ?: emptyList()
+        }
+
         fun isAppInstalled(appId: Int): Boolean {
             return MarkerUtils.hasMarker(getAppDirPath(appId), Marker.DOWNLOAD_COMPLETE_MARKER)
         }

app/src/main/java/app/gamenative/service/amazon/AmazonConstants.kt

@@ -51,16 +51,26 @@ object AmazonConstants {
     // ── SDK / Launcher channel ──────────────────────────────────────────────
     const val LAUNCHER_CHANNEL_ID = "87d38116-4cbf-4af0-a371-a5b498975346"
 
+    fun internalAmazonGamesPath(context: Context): String {
+        val path = Paths.get(context.dataDir.path, "Amazon").toString()
+        File(path).mkdirs()
+        return path
+    }
+
+    fun externalAmazonGamesPath(): String {
+        val path = Paths.get(PrefManager.externalStoragePath, "Amazon", "games").toString()
+        File(path).mkdirs()
+        return path
+    }
+
     fun defaultAmazonGamesPath(context: Context): String {
         return if (PrefManager.useExternalStorage && File(PrefManager.externalStoragePath).exists()) {
-            val path = Paths.get(PrefManager.externalStoragePath, "Amazon", "games").toString()
+            val path = externalAmazonGamesPath()
             Timber.i("Amazon using external storage: $path")
-            File(path).mkdirs()
             path
         } else {
-            val path = Paths.get(context.dataDir.path, "Amazon").toString()
+            val path = internalAmazonGamesPath(context)
             Timber.i("Amazon using internal storage: $path")
-            File(path).mkdirs()
             path
         }
     }

app/src/main/java/app/gamenative/service/amazon/AmazonManager.kt

@@ -57,6 +57,11 @@ class AmazonManager @Inject constructor(
         amazonGameDao.getAllAsList()
     }
 
+    /** Return non-installed Amazon games from DB. */
+    suspend fun getNonInstalledGames(): List<AmazonGame> = withContext(Dispatchers.IO) {
+        amazonGameDao.getNonInstalledGames()
+    }
+
     /** Mark a game as installed and persist install metadata. */
     suspend fun markInstalled(productId: String, installPath: String, installSize: Long, versionId: String = "") =
         withContext(Dispatchers.IO) {

app/src/main/java/app/gamenative/service/amazon/AmazonService.kt

@@ -357,6 +357,41 @@ class AmazonService : Service() {
         fun getDownloadInfo(productId: String): DownloadInfo? =
             getInstance()?.activeDownloads?.get(productId)
 
+        fun getActiveDownloads(): Map<String, DownloadInfo> =
+            getInstance()?.activeDownloads?.let { HashMap(it) } ?: emptyMap()
+
+        private fun getPartialInstallPaths(context: Context): Set<String> {
+            val roots = buildList {
+                add(AmazonConstants.internalAmazonGamesPath(context))
+                if (app.gamenative.PrefManager.externalStoragePath.isNotBlank()) {
+                    add(AmazonConstants.externalAmazonGamesPath())
+                }
+            }.distinct()
+
+            return roots.asSequence()
+                .flatMap { root -> MarkerUtils.findResumablePartialInstalls(root).asSequence() }
+                .toSet()
+        }
+
+        suspend fun getPartialDownloads(context: Context): List<String> {
+            val instance = getInstance() ?: return emptyList()
+            val partialInstallPaths = getPartialInstallPaths(context)
+            if (partialInstallPaths.isEmpty()) return emptyList()
+
+            return instance.amazonManager.getNonInstalledGames()
+                .asSequence()
+                .filter { game -> !instance.activeDownloads.containsKey(game.productId) }
+                .filter { game ->
+                    val expectedPaths = buildList {
+                        game.installPath.takeIf { it.isNotBlank() }?.let(::add)
+                        add(AmazonConstants.getGameInstallPath(context, game.title))
+                    }
+                    expectedPaths.any(partialInstallPaths::contains)
+                }
+                .map { it.productId }
+                .toList()
+        }
+
         /** Returns the active [DownloadInfo] for [appId], or null if not downloading. */
         fun getDownloadInfoByAppId(appId: Int): DownloadInfo? {
             val productId = getProductIdByAppId(appId) ?: return null

app/src/main/java/app/gamenative/service/epic/EpicDownloadManager.kt

@@ -362,6 +362,7 @@ class EpicDownloadManager @Inject constructor(
             downloadInfo.updateStatusMessage("Complete")
             // Ensure bytes-based progress shows 100% completion
             downloadInfo.updateBytesDownloaded(downloadInfo.getTotalExpectedBytes() - downloadInfo.getBytesDownloaded())
+            downloadInfo.clearPersistedBytesDownloaded(installPath)
             downloadInfo.setProgress(1.0f)
             downloadInfo.setActive(false)
             downloadInfo.emitProgressChange()

app/src/main/java/app/gamenative/service/epic/EpicManager.kt

@@ -336,7 +336,7 @@ class EpicManager @Inject constructor(
                     }
 
                     // Skip invalid platform (such as Android versions)
-                    if(platforms.isNotEmpty() && !platforms.contains("Win32") && !platforms.contains("Windows")){ 
+                    if(platforms.isNotEmpty() && !platforms.contains("Win32") && !platforms.contains("Windows")){
                         Timber.tag("Epic").d("Skipping due to invalid platform: $appName (namespace=$namespace, sandbox=$sandboxType)")
                         continue
                     }
@@ -718,6 +718,12 @@ class EpicManager @Inject constructor(
         }
     }
 
+    suspend fun getNonInstalledGames(): List<EpicGame> {
+        return withContext(Dispatchers.IO) {
+            epicGameDao.getNonInstalledGames()
+        }
+    }
+
     /**
      * Start background sync (called after login)
      */

app/src/main/java/app/gamenative/service/epic/EpicService.kt

@@ -179,6 +179,47 @@ class EpicService : Service() {
             return getInstance()?.activeDownloads?.get(appId)
         }
 
+        fun getActiveDownloads(): Map<Int, DownloadInfo> =
+            getInstance()?.activeDownloads?.let { HashMap(it) } ?: emptyMap()
+
+        fun hasPartialDownload(context: Context, appId: Int): Boolean {
+            val game = getEpicGameOf(appId) ?: return false
+            if (game.isInstalled) return false
+            val appName = game.appName.ifBlank { return false }
+            val installPath = EpicConstants.getGameInstallPath(context, appName)
+            return MarkerUtils.hasPartialInstall(installPath)
+        }
+
+        private fun getPartialInstallPaths(context: Context): Set<String> {
+            val roots = buildList {
+                add(EpicConstants.internalEpicGamesPath(context))
+                if (app.gamenative.PrefManager.externalStoragePath.isNotBlank()) {
+                    add(EpicConstants.externalEpicGamesPath())
+                }
+            }.distinct()
+
+            return roots.asSequence()
+                .flatMap { root -> MarkerUtils.findResumablePartialInstalls(root).asSequence() }
+                .toSet()
+        }
+
+        suspend fun getPartialDownloads(): List<Int> {
+            val instance = getInstance() ?: return emptyList()
+            val context = instance.applicationContext
+            val partialInstallPaths = getPartialInstallPaths(context)
+            if (partialInstallPaths.isEmpty()) return emptyList()
+
+            return instance.epicManager.getNonInstalledGames()
+                .asSequence()
+                .filter { game -> !instance.activeDownloads.containsKey(game.id) }
+                .filter { game ->
+                    val appName = game.appName.ifBlank { return@filter false }
+                    partialInstallPaths.contains(EpicConstants.getGameInstallPath(context, appName))
+                }
+                .map { it.id }
+                .toList()
+        }
+
         suspend fun deleteGame(context: Context, appId: Int): Result<Unit> {
             val instance = getInstance()
             if (instance == null) {
@@ -369,6 +410,12 @@ class EpicService : Service() {
                 gameId = appId,
                 downloadingAppIds = CopyOnWriteArrayList<Int>(),
             )
+            downloadInfo.setPersistencePath(installPath)
+
+            val persistedBytes = downloadInfo.loadPersistedBytesDownloaded(installPath)
+            if (persistedBytes > 0L) {
+                downloadInfo.initializeBytesDownloaded(persistedBytes)
+            }
 
             instance.activeDownloads[appId] = downloadInfo
             downloadInfo.setActive(true)

app/src/main/java/app/gamenative/service/gog/GOGDownloadManager.kt

@@ -501,6 +501,7 @@ class GOGDownloadManager @Inject constructor(
             if (game != null) {
                 val installSize = calculateDirectorySize(installPath)
                 gogManager.updateGame(game.copy(isInstalled = true, installPath = installPath.absolutePath, installSize = installSize))
+                downloadInfo.clearPersistedBytesDownloaded(installPath.absolutePath)
                 Timber.tag("GOG").i("Updated database: game marked as installed, size: ${installSize / 1_000_000} MB")
             } else {
                 Timber.tag("GOG").w("Game $gameId not found in database, skipping DB update")

app/src/main/java/app/gamenative/service/gog/GOGManager.kt

@@ -112,6 +112,10 @@ class GOGManager @Inject constructor(
         }
     }
 
+    suspend fun getNonInstalledGames(): List<GOGGame> {
+        return withContext(Dispatchers.IO) { gogGameDao.getNonInstalledGames() }
+    }
+
     suspend fun insertGame(game: GOGGame) {
         withContext(Dispatchers.IO) {
             gogGameDao.insert(game)
@@ -468,6 +472,7 @@ class GOGManager @Inject constructor(
                 val gameId = libraryItem.gameId.toString()
                 val installPath = getGameInstallPath(gameId, libraryItem.name)
                 val installDir = File(installPath)
+                val hadInstallArtifacts = installDir.exists() || MarkerUtils.hasPartialInstall(installPath)
                 val wasInstalled = MarkerUtils.hasMarker(installPath, Marker.DOWNLOAD_COMPLETE_MARKER)
 
                 // Delete the manifest file
@@ -493,13 +498,11 @@ class GOGManager @Inject constructor(
                 MarkerUtils.removeMarker(installPath, Marker.DOWNLOAD_COMPLETE_MARKER)
                 MarkerUtils.removeMarker(installPath, Marker.DOWNLOAD_IN_PROGRESS_MARKER)
 
-                if (wasInstalled) {
-                    val game = getGameFromDbById(gameId)
-                    if (game != null) {
-                        val updatedGame = game.copy(isInstalled = false, installPath = "")
-                        gogGameDao.update(updatedGame)
-                        Timber.d("Updated database: game marked as not installed")
-                    }
+                val game = getGameFromDbById(gameId)
+                if (game != null && (wasInstalled || hadInstallArtifacts)) {
+                    val updatedGame = game.copy(isInstalled = false, installPath = "")
+                    gogGameDao.update(updatedGame)
+                    Timber.d("Updated database: game marked as not installed")
                 }
 
                 withContext(Dispatchers.Main) {

app/src/main/java/app/gamenative/service/gog/GOGService.kt

@@ -194,6 +194,52 @@ class GOGService : Service() {
             return getInstance()?.activeDownloads?.get(gameId)
         }
 
+        fun getActiveDownloads(): Map<String, DownloadInfo> =
+            getInstance()?.activeDownloads?.let { HashMap(it) } ?: emptyMap()
+
+        private fun hasPartialDownload(game: GOGGame): Boolean {
+            if (game.isInstalled) return false
+            val title = game.title.ifBlank { return false }
+            val installPath = GOGConstants.getGameInstallPath(title)
+            return app.gamenative.utils.MarkerUtils.hasPartialInstall(installPath)
+        }
+
+        fun hasPartialDownload(gameId: String, fallbackTitle: String? = null): Boolean {
+            getGOGGameOf(gameId)?.let { return hasPartialDownload(it) }
+            val title = fallbackTitle?.ifBlank { null } ?: return false
+            val installPath = GOGConstants.getGameInstallPath(title)
+            return app.gamenative.utils.MarkerUtils.hasPartialInstall(installPath)
+        }
+
+        private fun getPartialInstallPaths(): Set<String> {
+            val roots = buildList {
+                add(GOGConstants.internalGOGGamesPath)
+                if (app.gamenative.PrefManager.externalStoragePath.isNotBlank()) {
+                    add(GOGConstants.externalGOGGamesPath)
+                }
+            }.distinct()
+
+            return roots.asSequence()
+                .flatMap { root -> app.gamenative.utils.MarkerUtils.findResumablePartialInstalls(root).asSequence() }
+                .toSet()
+        }
+
+        suspend fun getPartialDownloads(): List<String> {
+            val instance = getInstance() ?: return emptyList()
+            val partialInstallPaths = getPartialInstallPaths()
+            if (partialInstallPaths.isEmpty()) return emptyList()
+
+            return instance.gogManager.getNonInstalledGames()
+                .asSequence()
+                .filter { game -> !instance.activeDownloads.containsKey(game.id) }
+                .filter { game ->
+                    val title = game.title.ifBlank { return@filter false }
+                    partialInstallPaths.contains(GOGConstants.getGameInstallPath(title))
+                }
+                .map { it.id }
+                .toList()
+        }
+
         fun cleanupDownload(gameId: String) {
             getInstance()?.activeDownloads?.remove(gameId)
         }
@@ -294,6 +340,12 @@ class GOGService : Service() {
 
             // Create DownloadInfo for progress tracking
             val downloadInfo = DownloadInfo(jobCount = 1, gameId = 0, downloadingAppIds = CopyOnWriteArrayList<Int>())
+            downloadInfo.setPersistencePath(installPath)
+
+            val persistedBytes = downloadInfo.loadPersistedBytesDownloaded(installPath)
+            if (persistedBytes > 0L) {
+                downloadInfo.initializeBytesDownloaded(persistedBytes)
+            }
 
             // Track in activeDownloads first
             instance.activeDownloads[gameId] = downloadInfo

app/src/main/java/app/gamenative/ui/PluviaMain.kt

@@ -1258,7 +1258,7 @@ fun PluviaMain(
                         },
                     )
                 }
-                /** Library, Downloads, Friends **/
+                /** Library, Downloads **/
                 composable(
                     route = PluviaScreen.Home.route + "?offline={offline}",
                     deepLinks = listOf(navDeepLink { uriPattern = "pluvia://home" }),