Android Data Layer

Room — Local Database

Entity

@Entity(tableName = "articles")
data class ArticleEntity(
    @PrimaryKey val id: String,
    val title: String,
    val body: String,
    val publishedAt: Long
)

DAO

Return Flow<T> for observable queries; suspend fun for one-shot reads and writes.

@Dao
interface ArticleDao {

    @Query("SELECT * FROM articles ORDER BY publishedAt DESC")
    fun observeAll(): Flow<List<ArticleEntity>>

    @Query("SELECT * FROM articles WHERE id = :id")
    suspend fun findById(id: String): ArticleEntity?

    @Upsert
    suspend fun upsertAll(articles: List<ArticleEntity>)

    @Query("DELETE FROM articles")
    suspend fun deleteAll()
}

Database

@Database(entities = [ArticleEntity::class], version = 1, exportSchema = true)
abstract class AppDatabase : RoomDatabase() {
    abstract fun articleDao(): ArticleDao
}

Provide as a singleton via Hilt and export the schema for migration history tracking.

Offline-First Strategies

Read — Stale-While-Revalidate

Show local data immediately; trigger a background refresh in parallel.

// In ViewModel
fun loadNews() {
    viewModelScope.launch {
        // 1. Start observing the local DB immediately
        repository.newsStream
            .collect { articles -> _uiState.update { it.copy(articles = articles) } }
    }

    viewModelScope.launch {
        // 2. Trigger a network refresh in parallel
        repository.refreshNews().onFailure { error ->
            _uiState.update { it.copy(error = error.message) }
        }
    }
}

Write — Outbox Pattern

Save changes locally first, then sync to the server. Use WorkManager to guarantee delivery even if the app is killed.

// 1. Mark item as unsynced in the DB immediately
suspend fun likeArticle(id: String) {
    articleDao.markAsUnsynced(id, action = "LIKE")
}

// 2. WorkManager job (runs when connected)
class SyncWorker @AssistedInject constructor(
    @Assisted context: Context,
    @Assisted params: WorkerParameters,
    private val articleDao: ArticleDao,
    private val newsApi: NewsApi
) : CoroutineWorker(context, params) {

    override suspend fun doWork(): Result {
        val unsynced = articleDao.getUnsyncedActions()
        unsynced.forEach { action ->
            newsApi.postAction(action)
            articleDao.markAsSynced(action.id)
        }
        return Result.success()
    }
}

Model Mapping

Keep three distinct model types and map between them at layer boundaries:

// DTO → Entity (in repository, before writing to DB)
fun ArticleDto.toEntity(): ArticleEntity = ArticleEntity(
    id = id,
    title = title,
    body = body,
    publishedAt = publishedAt
)

// Entity → Domain model (in repository, before returning to ViewModel)
fun ArticleEntity.toDomain(): Article = Article(
    id = id,
    title = title,
    body = body,
    publishedAt = Instant.ofEpochMilli(publishedAt)
)

Checklist

• Repository exposes Flow for streams and suspend fun returning Result<T> for one-shot operations
• Raw DTOs and entities never reach the ViewModel — map at the repository boundary
• Room DAOs return Flow for observed queries; suspend for mutations
• Schema exported (exportSchema = true) and migration scripts provided for version bumps
• Offline-first: local DB is the source of truth; network writes go through an outbox if reliability matters
• WorkManager used for sync operations that must survive process death