Offline-First Android App Architecture

@Entity(tableName = "tasks")
data class TaskEntity(
    @PrimaryKey val id: String,                 // client-generated UUID: works offline
    val title: String,
    val done: Boolean,
    val updatedAt: Long,                        // local modification time
    val serverVersion: Long?,                   // version from server, for conflict detection
    val pendingSync: Boolean = false,
    val deleted: Boolean = false,               // soft delete until the server confirms
)

class TaskRepository(
    private val dao: TaskDao,
    private val syncScheduler: SyncScheduler,
    private val clock: Clock,
) {
    fun observeTasks(): Flow<List<Task>> =
        dao.observeVisible().map { list -> list.map(TaskEntity::toDomain) }   // WHERE deleted = 0

    suspend fun toggleDone(id: String) {
        dao.update(id) { it.copy(done = !it.done, updatedAt = clock.millis(), pendingSync = true) }
        syncScheduler.requestSync()             // enqueue unique work; runs when online
    }

    suspend fun delete(id: String) {
        dao.update(id) { it.copy(deleted = true, pendingSync = true, updatedAt = clock.millis()) }
        syncScheduler.requestSync()
    }
}

@HiltWorker
class SyncWorker @AssistedInject constructor(
    @Assisted context: Context,
    @Assisted params: WorkerParameters,
    private val dao: TaskDao,
    private val api: TaskApi,
) : CoroutineWorker(context, params) {

    override suspend fun doWork(): Result = try {
        // 1. Push local changes
        dao.pending().forEach { local ->
            if (local.deleted) api.delete(local.id)
            else {
                val saved = api.upsert(local.toDto())          // server resolves version conflicts
                dao.markSynced(local.id, saved.version)
            }
            if (local.deleted) dao.hardDelete(local.id)
        }
        // 2. Pull remote changes since last sync
        val changes = api.changesSince(dao.maxServerVersion() ?: 0)
        dao.applyRemote(changes.map { it.toEntity() })         // skip rows with pendingSync = true
        Result.success()
    } catch (e: IOException) {
        Result.retry()                                          // backoff handled by WorkManager
    }
}

class SyncScheduler(private val workManager: WorkManager) {
    fun requestSync() = workManager.enqueueUniqueWork(
        "sync", ExistingWorkPolicy.KEEP,
        OneTimeWorkRequestBuilder<SyncWorker>()
            .setConstraints(Constraints(requiredNetworkType = NetworkType.CONNECTED))
            .setBackoffCriteria(BackoffPolicy.EXPONENTIAL, 30, TimeUnit.SECONDS)
            .build(),
    )
}