refactor(updates): Simplify update check logic and improve UX

This commit refactors the update-checking mechanism to be faster and more reliable by removing the pre-download and APK parsing steps. It now compares version tags directly. It also enhances the user experience on the "Apps" screen with pull-to-refresh, better status indicators, and improved handling of pending and stale app installations.

- **refactor(data)**: Simplified `checkForUpdate` logic in `InstalledAppsRepositoryImpl`. The check for updates now directly compares the normalized installed version tag with the latest release tag, removing the need to download the APK for version code comparison. This makes the process significantly faster and less error-prone.
- **feat(apps)**: Added pull-to-refresh functionality on the Apps screen to manually trigger a sync and check for updates.
- **feat(apps)**: Implemented a "last checked" timestamp on the Apps screen to inform the user when updates were last fetched. An automatic check now runs on a 30-minute cooldown.
- **feat(domain)**: Added logic to `SyncInstalledAppsUseCase` to automatically clean up pending installs that have not been completed within 24 hours.
- **feat(ui)**: Introduced a "Pending Install" badge on the app details screen for apps that are awaiting installation. The install buttons are now correctly disabled for pending installs.
- **chore(android)**: Registered a `PackageEventReceiver` in the main `Application` class to respond to app install/uninstall events, ensuring the database is kept in sync with the system's state.

Author: rainxchzed

composeApp/src/androidMain/kotlin/zed/rainxch/githubstore/app/GithubStoreApp.kt

@@ -1,16 +1,41 @@
 package zed.rainxch.githubstore.app
 
 import android.app.Application
+import android.os.Build
+import org.koin.android.ext.android.get
 import org.koin.android.ext.koin.androidContext
+import zed.rainxch.core.data.services.PackageEventReceiver
+import zed.rainxch.core.domain.repository.InstalledAppsRepository
+import zed.rainxch.core.domain.system.PackageMonitor
 import zed.rainxch.githubstore.app.di.initKoin
 
 class GithubStoreApp : Application() {
 
+    private var packageEventReceiver: PackageEventReceiver? = null
+
     override fun onCreate() {
         super.onCreate()
 
         initKoin {
             androidContext(this@GithubStoreApp)
         }
+
+        registerPackageEventReceiver()
+    }
+
+    private fun registerPackageEventReceiver() {
+        val receiver = PackageEventReceiver(
+            installedAppsRepository = get<InstalledAppsRepository>(),
+            packageMonitor = get<PackageMonitor>()
+        )
+        val filter = PackageEventReceiver.createIntentFilter()
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            registerReceiver(receiver, filter, RECEIVER_NOT_EXPORTED)
+        } else {
+            registerReceiver(receiver, filter)
+        }
+
+        packageEventReceiver = receiver
     }
 }

core/data/src/commonMain/kotlin/zed/rainxch/core/data/di/SharedModule.kt

@@ -63,7 +63,6 @@ val coreModule = module {
             installedAppsDao = get(),
             historyDao = get(),
             installer = get(),
-            downloader = get(),
             httpClient = get()
         )
     }

core/data/src/commonMain/kotlin/zed/rainxch/core/data/repository/InstalledAppsRepositoryImpl.kt

@@ -12,7 +12,7 @@ import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.map
 import zed.rainxch.core.data.dto.ReleaseNetwork
-import zed.rainxch.core.data.dto.RepoByIdNetwork
+
 import zed.rainxch.core.data.local.db.AppDatabase
 import zed.rainxch.core.data.local.db.dao.InstalledAppDao
 import zed.rainxch.core.data.local.db.dao.UpdateHistoryDao
@@ -24,16 +24,13 @@ import zed.rainxch.core.domain.system.Installer
 import zed.rainxch.core.domain.model.GithubRelease
 import zed.rainxch.core.domain.model.InstallSource
 import zed.rainxch.core.domain.model.InstalledApp
-import zed.rainxch.core.domain.network.Downloader
 import zed.rainxch.core.domain.repository.InstalledAppsRepository
-import java.io.File
 
 class InstalledAppsRepositoryImpl(
     private val database: AppDatabase,
     private val installedAppsDao: InstalledAppDao,
     private val historyDao: UpdateHistoryDao,
     private val installer: Installer,
-    private val downloader: Downloader,
     private val httpClient: HttpClient
 ) : InstalledAppsRepository {
 
@@ -79,21 +76,6 @@ class InstalledAppsRepositoryImpl(
         installedAppsDao.deleteByPackageName(packageName)
     }
 
-    private suspend fun fetchDefaultBranch(owner: String, repo: String): String? {
-        return try {
-            val repoInfo = httpClient.executeRequest<RepoByIdNetwork> {
-                get("/repos/$owner/$repo") {
-                    header(HttpHeaders.Accept, "application/vnd.github+json")
-                }
-            }.getOrNull()
-
-            repoInfo?.defaultBranch
-        } catch (e: Exception) {
-            Logger.e { "Failed to fetch default branch for $owner/$repo: ${e.message}" }
-            null
-        }
-    }
-
     private suspend fun fetchLatestPublishedRelease(
         owner: String,
         repo: String
@@ -125,14 +107,6 @@ class InstalledAppsRepositoryImpl(
         val app = installedAppsDao.getAppByPackage(packageName) ?: return false
 
         try {
-            val branch = fetchDefaultBranch(app.repoOwner, app.repoName)
-
-            if (branch == null) {
-                Logger.w { "Could not determine default branch for ${app.repoOwner}/${app.repoName}" }
-                installedAppsDao.updateLastChecked(packageName, System.currentTimeMillis())
-                return false
-            }
-
             val latestRelease = fetchLatestPublishedRelease(
                 owner = app.repoOwner,
                 repo = app.repoName
@@ -142,68 +116,16 @@ class InstalledAppsRepositoryImpl(
                 val normalizedInstalledTag = normalizeVersion(app.installedVersion)
                 val normalizedLatestTag = normalizeVersion(latestRelease.tagName)
 
-                if (normalizedInstalledTag == normalizedLatestTag) {
-                    installedAppsDao.updateVersionInfo(
-                        packageName = packageName,
-                        available = false,
-                        version = latestRelease.tagName,
-                        assetName = app.latestAssetName,
-                        assetUrl = app.latestAssetUrl,
-                        assetSize = app.latestAssetSize,
-                        releaseNotes = latestRelease.description ?: "",
-                        timestamp = System.currentTimeMillis(),
-                        latestVersionName = app.latestVersionName,
-                        latestVersionCode = app.latestVersionCode
-                    )
-                    return false
-                }
-
                 val installableAssets = latestRelease.assets.filter { asset ->
                     installer.isAssetInstallable(asset.name)
                 }
-
                 val primaryAsset = installer.choosePrimaryAsset(installableAssets)
 
-                var isUpdateAvailable = true
-                var latestVersionName: String? = null
-                var latestVersionCode: Long? = null
-
-                if (primaryAsset != null) {
-                    val tempAssetName = primaryAsset.name + ".tmp"
-                    try {
-                        downloader.download(primaryAsset.downloadUrl, tempAssetName).collect { }
-
-                        val tempPath = downloader.getDownloadedFilePath(tempAssetName)
-                        if (tempPath != null) {
-                            val latestInfo = try {
-                                installer.getApkInfoExtractor().extractPackageInfo(tempPath)
-                            } finally {
-                                File(tempPath).delete()
-                            }
-                            if (latestInfo != null) {
-                                latestVersionName = latestInfo.versionName
-                                latestVersionCode = latestInfo.versionCode
-                                isUpdateAvailable = latestVersionCode > app.installedVersionCode
-                            } else {
-                                latestVersionName = latestRelease.tagName
-                            }
-
-                        } else {
-                            latestVersionName = latestRelease.tagName
-                        }
-                    } catch (e: Exception) {
-                        Logger.w { "Failed to download or extract APK for version check of ${app.packageName}: ${e.message}" }
-                        downloader.getDownloadedFilePath(tempAssetName)?.let { File(it).delete() }
-                        latestVersionName = latestRelease.tagName
-                    }
-                } else {
-                    latestVersionName = latestRelease.tagName
-                }
+                val isUpdateAvailable = normalizedInstalledTag != normalizedLatestTag
 
                 Logger.d {
-                    "Update check for ${app.appName}: currentTag=${app.installedVersion}, latestTag=${latestRelease.tagName}, " +
-                            "currentCode=${app.installedVersionCode}, latestCode=$latestVersionCode, isUpdate=$isUpdateAvailable, " +
-                            "primaryAsset=${primaryAsset?.name}"
+                    "Update check for ${app.appName}: installedTag=${app.installedVersion}, " +
+                            "latestTag=${latestRelease.tagName}, isUpdate=$isUpdateAvailable"
                 }
 
                 installedAppsDao.updateVersionInfo(
@@ -215,11 +137,13 @@ class InstalledAppsRepositoryImpl(
                     assetSize = primaryAsset?.size,
                     releaseNotes = latestRelease.description ?: "",
                     timestamp = System.currentTimeMillis(),
-                    latestVersionName = latestVersionName,
-                    latestVersionCode = latestVersionCode
+                    latestVersionName = latestRelease.tagName,
+                    latestVersionCode = null
                 )
 
                 return isUpdateAvailable
+            } else {
+                installedAppsDao.updateLastChecked(packageName, System.currentTimeMillis())
             }
         } catch (e: Exception) {
             Logger.e { "Failed to check updates for $packageName: ${e.message}" }

core/domain/src/commonMain/kotlin/zed/rainxch/core/domain/use_cases/SyncInstalledAppsUseCase.kt

@@ -11,12 +11,13 @@ import zed.rainxch.core.domain.system.PackageMonitor
 
 /**
  * Use case for synchronizing installed apps state with the system package manager.
- * 
+ *
  * Responsibilities:
  * 1. Remove apps from DB that are no longer installed on the system
  * 2. Migrate legacy apps missing versionName/versionCode fields
  * 3. Resolve pending installs once they appear in the system package manager
- * 
+ * 4. Clean up stale pending installs (older than 24 hours)
+ *
  * This should be called before loading or refreshing app data to ensure consistency.
  */
 class SyncInstalledAppsUseCase(
@@ -25,6 +26,9 @@ class SyncInstalledAppsUseCase(
     private val platform: Platform,
     private val logger: GitHubStoreLogger
 ) {
+    companion object {
+        private const val PENDING_TIMEOUT_MS = 24 * 60 * 60 * 1000L // 24 hours
+    }
     /**
      * Executes the sync operation.
      * 
@@ -34,17 +38,21 @@ class SyncInstalledAppsUseCase(
         try {
             val installedPackageNames = packageMonitor.getAllInstalledPackageNames()
             val appsInDb = installedAppsRepository.getAllInstalledApps().first()
+            val now = System.currentTimeMillis()
 
             val toDelete = mutableListOf<String>()
             val toMigrate = mutableListOf<Pair<String, MigrationResult>>()
             val toResolvePending = mutableListOf<InstalledApp>()
+            val toDeleteStalePending = mutableListOf<String>()
 
             appsInDb.forEach { app ->
                 val isOnSystem = installedPackageNames.contains(app.packageName)
                 when {
                     app.isPendingInstall -> {
                         if (isOnSystem) {
                             toResolvePending.add(app)
+                        } else if (now - app.installedAt > PENDING_TIMEOUT_MS) {
+                            toDeleteStalePending.add(app.packageName)
                         }
                     }
 
@@ -69,6 +77,15 @@ class SyncInstalledAppsUseCase(
                     }
                 }
 
+                toDeleteStalePending.forEach { packageName ->
+                    try {
+                        installedAppsRepository.deleteInstalledApp(packageName)
+                        logger.info("Removed stale pending install (>24h): $packageName")
+                    } catch (e: Exception) {
+                        logger.error("Failed to delete stale pending $packageName: ${e.message}")
+                    }
+                }
+
                 toResolvePending.forEach { app ->
                     try {
                         val systemInfo = packageMonitor.getInstalledPackageInfo(app.packageName)
@@ -116,7 +133,8 @@ class SyncInstalledAppsUseCase(
             }
 
             logger.info(
-                "Sync completed: ${toDelete.size} deleted, ${toResolvePending.size} pending resolved, ${toMigrate.size} migrated"
+                "Sync completed: ${toDelete.size} deleted, ${toDeleteStalePending.size} stale pending removed, " +
+                        "${toResolvePending.size} pending resolved, ${toMigrate.size} migrated"
             )
 
             Result.success(Unit)

core/presentation/src/commonMain/composeResources/values/strings.xml

@@ -346,4 +346,12 @@
     <string name="latest_badge">Latest</string>
     <string name="no_version_selected">No version</string>
     <string name="versions_title">Versions</string>
+
+    <!-- Apps feature - Last checked -->
+    <string name="last_checked">Last checked: %1$s</string>
+    <string name="last_checked_never">Never checked</string>
+    <string name="last_checked_just_now">just now</string>
+    <string name="last_checked_minutes_ago">%1$d min ago</string>
+    <string name="last_checked_hours_ago">%1$d h ago</string>
+    <string name="checking_for_updates">Checking for updates…</string>
 </resources>

feature/apps/presentation/src/commonMain/kotlin/zed/rainxch/apps/presentation/AppsAction.kt

@@ -11,5 +11,6 @@ sealed interface AppsAction {
     data object OnUpdateAll : AppsAction
     data object OnCancelUpdateAll : AppsAction
     data object OnCheckAllForUpdates : AppsAction
+    data object OnRefresh : AppsAction
     data class OnNavigateToRepo(val repoId: Long) : AppsAction
 }