LiveData: Lifecycle-Aware Data Observation

Why it exists

Before LiveData, developers manually managed the connection between data sources and the UI. This meant writing boilerplate code in onStart() and onStop() to subscribe and unsubscribe, a process that was tedious and a common source of memory leaks and crashes when updating a UI that was no longer visible.

The mental model

Think of LiveData as a smart bulletin board for your app's data. UI components, like an Activity, can "watch" this board. LiveData is smart enough to know if the watcher is actually looking (is the UI active?). It only posts updates for active watchers and automatically removes the subscription when the watcher leaves for good (is destroyed). When a watcher returns, like after a screen rotation, it immediately sees the latest notice on the board.

How it works

LiveData uses the observer pattern and is aware of Android's Lifecycle. You hold data in a LiveData object, usually in a ViewModel. In your UI (an Activity or Fragment, which are LifecycleOwners), you create an Observer and attach it to the LiveData. LiveData checks the owner's state and only delivers updates by calling the observer's onChanged() method if the lifecycle is STARTED or RESUMED. When the owner is DESTROYED, LiveData automatically cleans up the observer, preventing leaks.

When to use it

Use LiveData to bridge the gap between your ViewModel and your UI. It's perfect for displaying data that changes over time, like user profiles or sensor readings. It shines when handling configuration changes (like device rotation) because it automatically provides the latest data to the newly created UI component, ensuring consistency without extra code.

When not to use it

LiveData is tied to the Android framework. For business logic in your data or domain layers that should be platform-agnostic, Kotlin Flows are a better choice. Also, because LiveData caches and re-emits its last value to new observers, it's not ideal for one-shot events (like showing a Toast), which could be triggered multiple times unintentionally.

One canonical example

A ViewModel fetches a user's profile and stores it in a MutableLiveData<User>. An Activity observes this LiveData. When the profile data arrives, the ViewModel updates the LiveData's value. The Observer in the Activity receives the new User object and updates the TextViews on screen. If the user navigates away and comes back, the UI is automatically updated with the latest data held by LiveData.