LiveData is an observable data holder class. Unlike a regular observable, LiveData is lifecycle-aware, meaning it respects the lifecycle of other app components, such as activities, fragments, or services. This awareness ensures LiveData only updates app component observers in an active lifecycle state.
Observables are also like callbacks and promise responsible for handling async requests.
The Android lifecycle helps developers understand which states activities go through when a user navigates through an app. As a result, we can do proper operations at the right time and avoid crashes and other bugs. An Android application has a lifecycle, and it crosses through various stages from when a user opens and exits an application. An application’s state helps you manage when a user opens an activity, pauses, resumes, stops, and destroys it.
LiveData considers an observer, represented by the Observer class, to be in an active state if its lifecycle is in the STARTED or RESUMED state. LiveData only notifies active observers about updates, and inactive observers registered to watch LiveData objects aren’t informed about changes.
You can register an observer paired with an object that implements the LifecycleOwner interface. This relationship allows the observer to be removed when the state of the corresponding Lifecycle object changes to DESTROYED. This is especially useful for activities and fragments because they can safely observe LiveData objects and not worry about leaks—activities and fragments are instantly unsubscribed when their lifecycles are destroyed.
The advantages of using LiveData
Using LiveData provides the following advantages:
Ensures your UI matches your data state
LiveData follows the observer pattern. LiveData notifies Observer objects when underlying data changes. You can consolidate your code to update the UI in these Observer objects. That way, you don’t need to update the UI every time the app data changes because the observer does it for you.
No memory leaks
Observers are bound to Lifecycle objects and clean up after themselves when their associated lifecycle is destroyed.
No crashes due to stopped activities.
If the observer’s lifecycle is inactive, such as in the case of an activity in the back stack, then it doesn’t receive any LiveData events.
No more manual lifecycle handling
UI components observe relevant data and don’t stop or resume observation. LiveData automatically manages everything since it knows the appropriate lifecycle status changes while observing.
Always up to date data
If a lifecycle becomes inactive, it receives the latest data upon becoming active again. For example, an activity in the background gets the latest data right after returning to the foreground.
Proper configuration changes
If an activity or fragment is recreated due to a configuration change, like device rotation, it immediately receives the latest available data.
Sharing resources
You can extend a LiveData object using the singleton pattern to wrap system services so that they can be shared in your app. The LiveData object connects to the system service once, and then any observer that needs the resource can just watch the LiveData object. For more information, see Extend LiveData.
Work with LiveData objects.
Follow these steps to work with LiveData objects:
- Create an instance of LiveData to hold a certain type of data. This is usually done within your ViewModel class.
- Create an Observer object that defines the onChanged() method, which controls what happens when the LiveData object’s held data changes. You usually create an Observer object in a UI controller, such as an activity or fragment.
- Attach the Observer object to the LiveData object using the observe() method. The observe() method takes a LifecycleOwner object, and this subscribes the Observer object to the LiveData object so that it is notified of changes. You usually attach the Observer object in a UI controller, such as an activity or fragment.
- Note: You can register an observer without an associated LifecycleOwner object using the observeForever(Observer) method. In this case, the observer is considered always active and is therefore always notified about modifications. You can remove these observers by calling the removeObserver(Observer) method.
When you update the value stored in the LiveData object, it triggers all registered observers as long as the attached LifecycleOwner is in the active state.
LiveData allows UI controller observers to subscribe to updates. When the data held by the LiveData object changes, the UI automatically updates in response.