LiveData

LiveData

LiveData ()

getValue

T getValue ()

Returns the current value. Note that calling this method on a background thread does not guarantee that the latest value set will be received.

hasActiveObservers

boolean hasActiveObservers ()

Returns true if this LiveData has active observers.

hasObservers

boolean hasObservers ()

Returns true if this LiveData has observers.

observe

void observe (LifecycleOwner owner, 
                Observer<T> observer)

Adds the given observer to the observers list within the lifespan of the given owner. The events are dispatched on the main thread. If LiveData already has data set, it will be delivered to the observer.

The observer will only receive events if the owner is in STARTED or RESUMED state (active).

If the owner moves to the DESTROYED state, the observer will automatically be removed.

When data changes while the owner is not active, it will not receive any updates. If it becomes active again, it will receive the last available data automatically.

LiveData keeps a strong reference to the observer and the owner as long as the given LifecycleOwner is not destroyed. When it is destroyed, LiveData removes references to the observer & the owner.

If the given owner is already in DESTROYED state, LiveData ignores the call.

If the given owner, observer tuple is already in the list, the call is ignored. If the observer is already in the list with another owner, LiveData throws an IllegalArgumentException.

observeForever

void observeForever (Observer<T> observer)

Adds the given observer to the observers list. This call is similar to observe(LifecycleOwner, Observer) with a LifecycleOwner, which is always active. This means that the given observer will receive all events and will never be automatically removed. You should manually call removeObserver(Observer) to stop observing this LiveData. While LiveData has one of such observers, it will be considered as active.

If the observer was already added with an owner to this LiveData, LiveData throws an IllegalArgumentException.

removeObserver

void removeObserver (Observer<T> observer)

Removes the given observer from the observers list.

removeObservers

void removeObservers (LifecycleOwner owner)

Removes all observers that are tied to the given LifecycleOwner.

onActive

void onActive ()

Called when the number of active observers change to 1 from 0.

This callback can be used to know that this LiveData is being used thus should be kept up to date.

onInactive

void onInactive ()

Called when the number of active observers change from 1 to 0.

This does not mean that there are no observers left, there may still be observers but their lifecycle states aren't STARTED or RESUMED (like an Activity in the back stack).

You can check if there are observers via hasObservers().

postValue

void postValue (T value)

Posts a task to a main thread to set the given value. So if you have a following code executed in the main thread:

 liveData.postValue("a");
 liveData.setValue("b");
 

If you called this method multiple times before a main thread executed a posted task, only the last value would be dispatched.

setValue

void setValue (T value)

Sets the value. If there are active observers, the value will be dispatched to them.

This method must be called from the main thread. If you need set a value from a background thread, you can use postValue(Object)