State in ViewModel in Android Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ ui_behavior

intermediate

What is the output of this ViewModel state update?

Consider this ViewModel code that holds a counter state. What will be the value of counter after calling increment() twice?

Android Kotlin

class CounterViewModel : ViewModel() {
  private val _counter = MutableLiveData(0)
  val counter: LiveData<Int> = _counter

  fun increment() {
    _counter.value = (_counter.value ?: 0) + 1
  }
}

// After calling increment() twice:

A counter.value == 1

B counter.value == 2

C counter.value == 0

D counter.value == null

💡 Hint

Each call to increment adds 1 to the current value stored in _counter.

The initial value is 0. Each increment adds 1, so after two calls, the value is 2.

❓ lifecycle

intermediate

When is ViewModel state preserved?

In Android, when does the ViewModel keep its state intact?

A When the user closes the app from recent apps

B When the app is killed by the system

C During configuration changes like screen rotation

D When the device is restarted

💡 Hint

Think about what happens to Activity and ViewModel during rotation.

ViewModel survives configuration changes such as screen rotations but is cleared when the Activity is finished or the app is killed.

📝 Syntax

advanced

Which option correctly exposes immutable state from ViewModel?

Given a MutableStateFlow in ViewModel, which option correctly exposes it as immutable to the UI?

Android Kotlin

private val _uiState = MutableStateFlow(0)
// Expose immutable state here:

A val uiState: StateFlow<Int> = _uiState

B val uiState: MutableStateFlow<Int> = _uiState

C val uiState: Flow<Int> = _uiState.asStateFlow()

D val uiState: StateFlow<Int> = _uiState.asStateFlow()

💡 Hint

Use the correct method to expose a read-only StateFlow.

The asStateFlow() method returns a read-only StateFlow view of the MutableStateFlow.

🔧 Debug

advanced

Why does UI not update after ViewModel state change?

This ViewModel updates a LiveData value, but the UI does not reflect the change. What is the likely cause?

Android Kotlin

class MyViewModel : ViewModel() {
  val data = MutableLiveData("Hello")

  fun update() {
    data.value = "World"
  }
}

// UI observes data but does not update after update() call.

A MutableLiveData.value was updated from a background thread

B UI is not observing LiveData on the main thread

C LiveData observer was not registered before update() call

D LiveData was declared as val instead of var

💡 Hint

LiveData.value must be updated on the main thread.

Updating LiveData.value from a background thread causes UI not to receive updates. Use postValue() or update on main thread.

🧠 Conceptual

expert

What is the main benefit of using StateFlow in ViewModel over LiveData?

Choose the best explanation for why StateFlow might be preferred over LiveData for state management in ViewModel.

A StateFlow supports coroutines and provides a consistent API for reactive streams

B LiveData cannot be observed from fragments

C StateFlow automatically saves state across process death

D LiveData requires manual lifecycle management

💡 Hint

Think about Kotlin coroutines integration and reactive programming.

StateFlow integrates seamlessly with Kotlin coroutines and provides a consistent reactive streams API, unlike LiveData which is lifecycle-aware but not coroutine-based.