LiveData

What Is LiveData?

LiveData is an observable data holder that is lifecycle-aware. When a LiveData value changes, observers with STARTED or RESUMED state receive updates automatically. Observers in DESTROYED state are removed, preventing memory leaks.

This eliminates the common bug in Android where background threads update UI after the Activity is gone.

Creating LiveData

class UserViewModel(private val repo: UserRepository) : ViewModel() {
    private val _userName = MutableLiveData<String>()
    val userName: LiveData<String> = _userName

    fun loadUser(id: String) {
        viewModelScope.launch {
            val user = repo.getUser(id)
            _userName.value = user.name  // setValue: main thread only
        }
    }
}

Expose LiveData<String> (immutable) to the UI, keep MutableLiveData<String> private in the ViewModel.

Observing in Activities

class UserActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val viewModel: UserViewModel by viewModels()

        // Observer is automatically removed when Activity is destroyed
        viewModel.userName.observe(this) { name ->
            findViewById<TextView>(R.id.nameText).text = name
        }
    }
}

Observing in Compose

Use observeAsState() from androidx.compose.runtime:lifecycle-runtime-compose:

@Composable
fun UserScreen(viewModel: UserViewModel = hiltViewModel()) {
    val name by viewModel.userName.observeAsState("")
    Text(text = "Name: $name", style = MaterialTheme.typography.headlineMedium)
}

setValue vs postValue

setValue(value) must be called on the main thread. It updates the value synchronously and notifies observers immediately.

postValue(value) can be called from any thread. It posts the update to the main thread, so observers receive it asynchronously. Only the last posted value wins if multiple posts happen before the main thread processes them.

// Main thread — use setValue
_userName.value = "Alice"

// Background thread — use postValue
repository.fetchUser { user ->
    _userName.postValue(user.name)  // Queued for main thread
}

Rule of thumb: prefer setValue from viewModelScope.launch(Dispatchers.Main) and only use postValue when you genuinely cannot post to the main dispatcher.

Transformations.map

map transforms the value inside a LiveData without changing the source. It creates a new LiveData that applies a function to each emission.

val userLiveData: LiveData<User> = repo.getUserFlow().asLiveData()

// Transform User to just the name
val userName: LiveData<String> = userLiveData.map { user ->
    user.name
}

The transformation is lazy — it only runs when there is an active observer. No computation happens if nothing is listening.

Transformations.switchMap

switchMap is for when each value in a source LiveData should produce a different LiveData. It is commonly used for database queries or API calls that depend on a parameter.

class SearchViewModel(private val repo: SearchRepository) : ViewModel() {
    private val _query = MutableLiveData<String>()
    val query: LiveData<String> = _query

    val searchResults: LiveData<List<Result>> = _query.switchMap { query ->
        repo.searchResults(query).asLiveData()
    }

    fun search(newQuery: String) {
        _query.value = newQuery
    }
}

When query changes, switchMap cancels the previous LiveData and subscribes to the new one. This prevents stale results.

MediatorLiveData

MediatorLiveData observes multiple LiveData sources and merges them into one:

class FormViewModel : ViewModel() {
    val email = MutableLiveData<String>()
    val password = MutableLiveData<String>()

    val isFormValid: LiveData<Boolean> = MediatorLiveData<Boolean>().apply {
        fun update() {
            val emailValid = Patterns.EMAIL_ADDRESS.matcher(email.value ?: "").matches()
            val passwordValid = (password.value?.length ?: 0) >= 8
            value = emailValid && passwordValid
        }
        addSource(email) { update() }
        addSource(password) { update() }
    }
}

LiveData vs StateFlow

LiveData is still valid in existing codebases. For new projects, StateFlow with Compose is preferred.