Room with Coroutines in Android Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ ui_behavior

intermediate

What happens when you call a suspend DAO function from the main thread?

Consider a Room DAO suspend function called directly from the main thread without using any coroutine builder. What will happen?

A The app crashes with an IllegalStateException.

B The function returns immediately without executing.

C The function blocks the main thread until completion.

D The function runs asynchronously without blocking the main thread.

💡 Hint

Room enforces thread rules for database access.

Room requires database operations to be off the main thread. Calling a suspend DAO function directly on the main thread without coroutine context causes an IllegalStateException.

🧠 Conceptual

intermediate

Why use Flow in Room DAO with Coroutines?

What is the main advantage of returning a Flow from a Room DAO query function compared to a suspend function?

A Suspend functions automatically cache data, Flow does not.

B Flow provides continuous updates when the database changes, while suspend functions return data only once.

C Flow runs on the main thread by default, making UI updates easier.

D Flow requires no coroutine context to collect data.

💡 Hint

Think about live data updates.

Flow emits new data whenever the database table changes, allowing UI to reactively update. Suspend functions return a single snapshot of data.

❓ lifecycle

advanced

What happens if you collect a Flow from Room DAO without lifecycle awareness?

If you collect a Flow returned by a Room DAO in a coroutine launched in a ViewModel without tying it to lifecycle, what is a likely consequence?

A The Flow collection pauses and resumes automatically with lifecycle.

B The Flow collection automatically stops when the UI is destroyed.

C The Flow collection throws an exception when UI is destroyed.

D The Flow collection continues even after the UI is destroyed, causing memory leaks.

💡 Hint

Consider what happens when UI components are destroyed.

Without lifecycle-aware collection, the coroutine collecting the Flow keeps running, potentially leaking memory and wasting resources.

📝 Syntax

advanced

Which DAO function signature correctly uses suspend with Room?

Choose the correct Kotlin DAO function signature for inserting a User entity using coroutines.

A suspend fun insertUser(user: User): Long

B fun insertUser(user: User): Deferred<Long>

C fun insertUser(user: User): Long

D suspend fun insertUser(user: User): Unit

💡 Hint

Room supports suspend functions returning inserted row id.

The correct signature is a suspend function returning Long for the inserted row id. Deferred return type is not supported by Room DAO directly.

🔧 Debug

expert

Why does this coroutine collecting a Room Flow never emit data?

Given this code snippet in a ViewModel: val usersFlow = userDao.getAllUsers() init { viewModelScope.launch { usersFlow.collect { users -> // update UI } } } The UI never updates even though the database has users. What is the most likely cause?

Android Kotlin

val usersFlow = userDao.getAllUsers()

init {
  viewModelScope.launch {
    usersFlow.collect { users ->
      // update UI
    }
  }
}

A The usersFlow variable is not marked as suspend.

B The coroutine is launched on Dispatchers.Main which cannot collect Flow.

C The getAllUsers() DAO function is not annotated with @Query returning Flow.

D The collect block is missing a delay causing it to skip emissions.

💡 Hint

Check DAO function annotations and return types.

If the DAO function does not return a Flow (missing @Query or wrong return type), the Flow will never emit data and collection will not trigger updates.