Improve home screen with smart sorting, ratings, and View All navigation

- Sort platform games by: installed, recently played, community score
- Add View All card at end of platform rows to jump to Library
- Display ratings below game info (community, user rating, difficulty)
- Add platform logo caching with black background removal
- Support deep-linking to Library with platform pre-selected

Author: tmgast

app/src/main/kotlin/com/nendo/argosy/MainActivity.kt

@@ -34,6 +34,7 @@ class MainActivity : ComponentActivity() {
         enableEdgeToEdge()
         hideSystemUI()
         imageCacheManager.resumePendingCache()
+        imageCacheManager.resumePendingLogoCache()
 
         setContent {
             ALauncherTheme {

app/src/main/kotlin/com/nendo/argosy/data/cache/ImageCacheManager.kt

@@ -3,8 +3,10 @@ package com.nendo.argosy.data.cache
 import android.content.Context
 import android.graphics.Bitmap
 import android.graphics.BitmapFactory
+import android.graphics.Color
 import android.util.Log
 import com.nendo.argosy.data.local.dao.GameDao
+import com.nendo.argosy.data.local.dao.PlatformDao
 import dagger.hilt.android.qualifiers.ApplicationContext
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -50,16 +52,24 @@ data class ScreenshotCacheRequest(
     val gameTitle: String = ""
 )
 
+data class PlatformLogoCacheRequest(
+    val platformId: String,
+    val logoUrl: String
+)
+
 @OptIn(kotlinx.coroutines.ExperimentalCoroutinesApi::class)
 @Singleton
 class ImageCacheManager @Inject constructor(
     @ApplicationContext private val context: Context,
-    private val gameDao: GameDao
+    private val gameDao: GameDao,
+    private val platformDao: PlatformDao
 ) {
     private val cacheDir: File by lazy {
         File(context.cacheDir, "images").also { it.mkdirs() }
     }
 
+    private val logoQueue = Channel<PlatformLogoCacheRequest>(Channel.UNLIMITED)
+
     private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
     private val queue = Channel<ImageCacheRequest>(Channel.UNLIMITED)
     private val screenshotQueue = Channel<ScreenshotCacheRequest>(Channel.UNLIMITED)
@@ -309,4 +319,106 @@ class ImageCacheManager @Inject constructor(
             }
         }
     }
+
+    fun queuePlatformLogoCache(platformId: String, logoUrl: String) {
+        scope.launch {
+            logoQueue.send(PlatformLogoCacheRequest(platformId, logoUrl))
+            startLogoProcessingIfNeeded()
+        }
+    }
+
+    private var isProcessingLogos = false
+
+    private fun startLogoProcessingIfNeeded() {
+        if (isProcessingLogos) return
+        isProcessingLogos = true
+
+        scope.launch {
+            Log.d(TAG, "Starting platform logo cache processing")
+
+            for (request in logoQueue) {
+                try {
+                    processLogoRequest(request)
+                } catch (e: Exception) {
+                    Log.e(TAG, "Failed to process logo for ${request.platformId}: ${e.message}")
+                }
+
+                if (logoQueue.isEmpty) break
+            }
+            isProcessingLogos = false
+        }
+    }
+
+    private suspend fun processLogoRequest(request: PlatformLogoCacheRequest) {
+        val fileName = "logo_${request.platformId}_${request.logoUrl.md5Hash()}.png"
+        val cachedFile = File(cacheDir, fileName)
+
+        if (cachedFile.exists()) {
+            platformDao.updateLogoPath(request.platformId, cachedFile.absolutePath)
+            return
+        }
+
+        val bitmap = downloadBitmap(request.logoUrl) ?: return
+        val transparentBitmap = removeBlackBackground(bitmap)
+        bitmap.recycle()
+
+        FileOutputStream(cachedFile).use { out ->
+            transparentBitmap.compress(Bitmap.CompressFormat.PNG, 100, out)
+        }
+        transparentBitmap.recycle()
+
+        Log.d(TAG, "Cached logo for platform ${request.platformId}: ${cachedFile.length() / 1024}KB")
+        platformDao.updateLogoPath(request.platformId, cachedFile.absolutePath)
+    }
+
+    private fun downloadBitmap(url: String): Bitmap? {
+        return try {
+            val connection = URL(url).openConnection()
+            connection.connectTimeout = 10_000
+            connection.readTimeout = 30_000
+            connection.getInputStream().use { inputStream ->
+                BitmapFactory.decodeStream(inputStream)
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to download bitmap: ${e.message}")
+            null
+        }
+    }
+
+    private fun removeBlackBackground(source: Bitmap): Bitmap {
+        val width = source.width
+        val height = source.height
+        val result = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
+
+        val pixels = IntArray(width * height)
+        source.getPixels(pixels, 0, width, 0, 0, width, height)
+
+        for (i in pixels.indices) {
+            val pixel = pixels[i]
+            val r = Color.red(pixel)
+            val g = Color.green(pixel)
+            val b = Color.blue(pixel)
+
+            // Check if pixel is near-black (threshold of 30 for each channel)
+            if (r < 30 && g < 30 && b < 30) {
+                pixels[i] = Color.TRANSPARENT
+            }
+        }
+
+        result.setPixels(pixels, 0, width, 0, 0, width, height)
+        return result
+    }
+
+    fun resumePendingLogoCache() {
+        scope.launch {
+            val uncached = platformDao.getPlatformsWithRemoteLogos()
+            if (uncached.isEmpty()) return@launch
+
+            Log.d(TAG, "Resuming cache for ${uncached.size} platforms with uncached logos")
+            uncached.forEach { platform ->
+                val url = platform.logoPath ?: return@forEach
+                queuePlatformLogoCache(platform.id, url)
+            }
+        }
+    }
 }

app/src/main/kotlin/com/nendo/argosy/data/local/dao/GameDao.kt

@@ -16,6 +16,20 @@ interface GameDao {
     @Query("SELECT * FROM games WHERE platformId = :platformId AND isHidden = 0 ORDER BY sortTitle ASC")
     fun observeByPlatform(platformId: String): Flow<List<GameEntity>>
 
+    @Query("""
+        SELECT * FROM games
+        WHERE platformId = :platformId AND isHidden = 0
+        ORDER BY
+            CASE WHEN localPath IS NOT NULL THEN 0 ELSE 1 END,
+            CASE WHEN lastPlayed IS NULL THEN 1 ELSE 0 END,
+            lastPlayed DESC,
+            CASE WHEN rating IS NULL THEN 1 ELSE 0 END,
+            rating DESC,
+            sortTitle ASC
+        LIMIT :limit
+    """)
+    fun observeByPlatformSorted(platformId: String, limit: Int = 20): Flow<List<GameEntity>>
+
     @Query("SELECT * FROM games WHERE isHidden = 0 ORDER BY sortTitle ASC")
     fun observeAll(): Flow<List<GameEntity>>
 

app/src/main/kotlin/com/nendo/argosy/data/local/dao/PlatformDao.kt

@@ -40,4 +40,10 @@ interface PlatformDao {
 
     @Query("UPDATE platforms SET isVisible = :visible WHERE id = :platformId")
     suspend fun updateVisibility(platformId: String, visible: Boolean)
+
+    @Query("UPDATE platforms SET logoPath = :path WHERE id = :platformId")
+    suspend fun updateLogoPath(platformId: String, path: String)
+
+    @Query("SELECT * FROM platforms WHERE logoPath LIKE 'http%'")
+    suspend fun getPlatformsWithRemoteLogos(): List<PlatformEntity>
 }

app/src/main/kotlin/com/nendo/argosy/data/remote/romm/RomMRepository.kt

@@ -323,14 +323,15 @@ class RomMRepository @Inject constructor(
         val existing = platformDao.getById(remote.slug)
         val platformDef = PlatformDefinitions.getById(remote.slug)
 
+        val logoUrl = remote.logoUrl?.let { buildMediaUrl(it) }
         val entity = PlatformEntity(
             id = remote.slug,
             name = platformDef?.name ?: remote.name,
             shortName = platformDef?.shortName ?: remote.name,
             romExtensions = platformDef?.extensions?.joinToString(",") ?: "",
             gameCount = remote.romCount,
             isVisible = existing?.isVisible ?: true,
-            logoPath = existing?.logoPath,
+            logoPath = logoUrl ?: existing?.logoPath,
             sortOrder = platformDef?.sortOrder ?: existing?.sortOrder ?: 0,
             lastScanned = existing?.lastScanned
         )
@@ -340,6 +341,11 @@ class RomMRepository @Inject constructor(
         } else {
             platformDao.update(entity)
         }
+
+        // Queue logo for caching with black background removal
+        if (logoUrl != null && logoUrl.startsWith("http")) {
+            imageCacheManager.queuePlatformLogoCache(remote.slug, logoUrl)
+        }
     }
 
     private suspend fun syncRom(rom: RomMRom, platformSlug: String): Pair<Boolean, GameEntity> {

app/src/main/kotlin/com/nendo/argosy/ui/navigation/NavGraph.kt

@@ -47,12 +47,24 @@ fun NavGraph(
                 onGameSelect = { gameId ->
                     navController.navigate(Screen.GameDetail.createRoute(gameId))
                 },
+                onNavigateToLibrary = { platformId ->
+                    navController.navigate(Screen.Library.createRoute(platformId))
+                },
                 onDrawerToggle = onDrawerToggle
             )
         }
 
-        composable(Screen.Library.route) {
+        composable(
+            route = Screen.Library.route,
+            arguments = listOf(navArgument("platformId") {
+                type = NavType.StringType
+                nullable = true
+                defaultValue = null
+            })
+        ) { backStackEntry ->
+            val platformId = backStackEntry.arguments?.getString("platformId")
             LibraryScreen(
+                initialPlatformId = platformId,
                 onGameSelect = { gameId ->
                     navController.navigate(Screen.GameDetail.createRoute(gameId))
                 },

app/src/main/kotlin/com/nendo/argosy/ui/navigation/Screen.kt

@@ -3,7 +3,10 @@ package com.nendo.argosy.ui.navigation
 sealed class Screen(val route: String) {
     data object FirstRun : Screen("first_run")
     data object Home : Screen("home")
-    data object Library : Screen("library")
+    data object Library : Screen("library?platformId={platformId}") {
+        fun createRoute(platformId: String? = null): String =
+            if (platformId != null) "library?platformId=$platformId" else "library"
+    }
     data object Downloads : Screen("downloads")
     data object Apps : Screen("apps")
     data object Settings : Screen("settings")