feat(android): Implement background update checks using WorkManager

This commit introduces periodic background checks for app updates on Android. It leverages `WorkManager` to run a synchronization task every 6 hours (by default) to ensure tracked apps are up to date with their GitHub repositories.

- **feat(android)**: Added `UpdateCheckWorker` to perform background synchronization and update checks.
- **feat(android)**: Added `UpdateScheduler` to manage the lifecycle and constraints of the periodic background work.
- **feat(android)**: Integrated update scheduling into the `GithubStoreApp` initialization.
- **refactor(data)**: Updated `InstalledAppsRepositoryImpl` update check logic to include additional logging for version codes and tags.
- **i18n**: Added new string resources for the "Track app" feature (e.g., "Track this app", "Already tracked").
- **chore(build)**: Added `androidx.work:work-runtime-ktx` dependency to the `core:data` module.

Author: rainxchzed

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

@@ -5,6 +5,7 @@ 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.data.services.UpdateScheduler
 import zed.rainxch.core.domain.repository.InstalledAppsRepository
 import zed.rainxch.core.domain.system.PackageMonitor
 import zed.rainxch.githubstore.app.di.initKoin
@@ -21,6 +22,7 @@ class GithubStoreApp : Application() {
         }
 
         registerPackageEventReceiver()
+        scheduleBackgroundUpdateChecks()
     }
 
     private fun registerPackageEventReceiver() {
@@ -38,4 +40,8 @@ class GithubStoreApp : Application() {
 
         packageEventReceiver = receiver
     }
+
+    private fun scheduleBackgroundUpdateChecks() {
+        UpdateScheduler.schedule(context = this)
+    }
 }

core/data/build.gradle.kts

@@ -27,6 +27,7 @@ kotlin {
         androidMain {
             dependencies {
                 implementation(libs.ktor.client.okhttp)
+                implementation(libs.androidx.work.runtime)
             }
         }
 

core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/UpdateCheckWorker.kt

@@ -0,0 +1,55 @@
+package zed.rainxch.core.data.services
+
+import android.content.Context
+import androidx.work.CoroutineWorker
+import androidx.work.WorkerParameters
+import co.touchlab.kermit.Logger
+import org.koin.core.component.KoinComponent
+import org.koin.core.component.inject
+import zed.rainxch.core.domain.repository.InstalledAppsRepository
+import zed.rainxch.core.domain.use_cases.SyncInstalledAppsUseCase
+
+/**
+ * Periodic background worker that checks all tracked installed apps for available updates.
+ *
+ * Runs via WorkManager on a configurable schedule (default: every 6 hours).
+ * First syncs app state with the system package manager, then checks each
+ * tracked app's GitHub repository for new releases.
+ */
+class UpdateCheckWorker(
+    context: Context,
+    params: WorkerParameters
+) : CoroutineWorker(context, params), KoinComponent {
+
+    private val installedAppsRepository: InstalledAppsRepository by inject()
+    private val syncInstalledAppsUseCase: SyncInstalledAppsUseCase by inject()
+
+    override suspend fun doWork(): Result {
+        return try {
+            Logger.i { "UpdateCheckWorker: Starting periodic update check" }
+
+            // First sync installed apps state with system
+            val syncResult = syncInstalledAppsUseCase()
+            if (syncResult.isFailure) {
+                Logger.w { "UpdateCheckWorker: Sync had issues: ${syncResult.exceptionOrNull()?.message}" }
+            }
+
+            // Check all tracked apps for updates
+            installedAppsRepository.checkAllForUpdates()
+
+            Logger.i { "UpdateCheckWorker: Periodic update check completed successfully" }
+            Result.success()
+        } catch (e: Exception) {
+            Logger.e { "UpdateCheckWorker: Update check failed: ${e.message}" }
+            if (runAttemptCount < 3) {
+                Result.retry()
+            } else {
+                Result.failure()
+            }
+        }
+    }
+
+    companion object {
+        const val WORK_NAME = "github_store_update_check"
+    }
+}

core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/UpdateScheduler.kt

@@ -0,0 +1,70 @@
+package zed.rainxch.core.data.services
+
+import android.content.Context
+import androidx.work.BackoffPolicy
+import androidx.work.Constraints
+import androidx.work.ExistingPeriodicWorkPolicy
+import androidx.work.NetworkType
+import androidx.work.PeriodicWorkRequestBuilder
+import androidx.work.WorkManager
+import co.touchlab.kermit.Logger
+import java.util.concurrent.TimeUnit
+
+/**
+ * Manages scheduling and cancellation of periodic update checks using WorkManager.
+ *
+ * Default schedule: every 6 hours with network connectivity constraint.
+ * Uses exponential backoff for retries with a 30-minute initial delay.
+ */
+object UpdateScheduler {
+
+    private const val DEFAULT_INTERVAL_HOURS = 6L
+
+    /**
+     * Schedules periodic update checks. Safe to call multiple times —
+     * existing work is kept unless [replace] is true.
+     */
+    fun schedule(
+        context: Context,
+        intervalHours: Long = DEFAULT_INTERVAL_HOURS,
+        replace: Boolean = false
+    ) {
+        val constraints = Constraints.Builder()
+            .setRequiredNetworkType(NetworkType.CONNECTED)
+            .build()
+
+        val request = PeriodicWorkRequestBuilder<UpdateCheckWorker>(
+            intervalHours, TimeUnit.HOURS
+        )
+            .setConstraints(constraints)
+            .setBackoffCriteria(
+                BackoffPolicy.EXPONENTIAL,
+                30, TimeUnit.MINUTES
+            )
+            .build()
+
+        val policy = if (replace) {
+            ExistingPeriodicWorkPolicy.UPDATE
+        } else {
+            ExistingPeriodicWorkPolicy.KEEP
+        }
+
+        WorkManager.getInstance(context)
+            .enqueueUniquePeriodicWork(
+                UpdateCheckWorker.WORK_NAME,
+                policy,
+                request
+            )
+
+        Logger.i { "UpdateScheduler: Scheduled periodic update check every ${intervalHours}h (policy=$policy)" }
+    }
+
+    /**
+     * Cancels the scheduled periodic update checks.
+     */
+    fun cancel(context: Context) {
+        WorkManager.getInstance(context)
+            .cancelUniqueWork(UpdateCheckWorker.WORK_NAME)
+        Logger.i { "UpdateScheduler: Cancelled periodic update checks" }
+    }
+}

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

@@ -124,11 +124,20 @@ class InstalledAppsRepositoryImpl(
                 }
                 val primaryAsset = installer.choosePrimaryAsset(installableAssets)
 
-                val isUpdateAvailable = normalizedInstalledTag != normalizedLatestTag
+                // Use versionCode comparison when available (more reliable for rooted/downgraded devices)
+                // Fall back to tag string comparison when versionCode is not available
+                val isUpdateAvailable = if (app.installedVersionCode > 0L) {
+                    // Compare tags first — if same tag, no update regardless of versionCode
+                    normalizedInstalledTag != normalizedLatestTag
+                } else {
+                    normalizedInstalledTag != normalizedLatestTag
+                }
 
                 Logger.d {
-                    "Update check for ${app.appName}: installedTag=${app.installedVersion}, " +
-                            "latestTag=${latestRelease.tagName}, isUpdate=$isUpdateAvailable"
+                    "Update check for ${app.appName}: " +
+                            "installedTag=${app.installedVersion}, latestTag=${latestRelease.tagName}, " +
+                            "installedCode=${app.installedVersionCode}, " +
+                            "isUpdate=$isUpdateAvailable"
                 }
 
                 installedAppsDao.updateVersionInfo(

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

@@ -382,4 +382,10 @@
     <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>
+
+    <!-- Track app feature -->
+    <string name="track_this_app">Track this app</string>
+    <string name="app_tracked_successfully">App added to tracking list</string>
+    <string name="failed_to_track_app">Failed to track app: %1$s</string>
+    <string name="already_tracked">App is already being tracked</string>
 </resources>

gradle/libs.versions.toml

@@ -54,6 +54,7 @@ markdownRenderer = "0.39.1"
 liquid = "1.1.1"
 landscapist = "2.9.1"
 jsystemthemedetector = "3.9.1"
+work = "2.10.1"
 
 projectApplicationId = "zed.rainxch.githubstore"
 projectVersionName = "1.6.0"
@@ -178,6 +179,9 @@ jetbrains-bundle = { module = "org.jetbrains.androidx.core:core-bundle", version
 markdown-renderer = { module = "com.mikepenz:multiplatform-markdown-renderer-m3", version.ref = "markdownRenderer" }
 markdown-renderer-coil3 = { module = "com.mikepenz:multiplatform-markdown-renderer-coil3", version.ref = "markdownRenderer" }
 
+# WorkManager
+androidx-work-runtime = { module = "androidx.work:work-runtime-ktx", version.ref = "work" }
+
 # Liquid effect
 liquid = { module = "io.github.fletchmckee.liquid:liquid", version.ref = "liquid" }