LiveData

Kotlin |Java

abstract class LiveData<T : Any!>

kotlin.Any
↳	androidx.lifecycle.LiveData

Known Direct Subclasses MutableLiveData, SliceLiveData.CachedSliceLiveData MutableLiveData LiveData which publicly exposes setValue(T) and postValue(T) method. SliceLiveData.CachedSliceLiveData Implementation of LiveData that provides controls over how cached vs live slices work.

Known Indirect Subclasses MediatorLiveData MediatorLiveData LiveData subclass which may observe other LiveData objects and react on OnChanged events from them.

LiveData is a data holder class that can be observed within a given lifecycle. This means that an Observer can be added in a pair with a LifecycleOwner, and this observer will be notified about modifications of the wrapped data only if the paired LifecycleOwner is in active state. LifecycleOwner is considered as active, if its state is Lifecycle.State#STARTED or Lifecycle.State#RESUMED. An observer added via observeForever(Observer) is considered as always active and thus will be always notified about modifications. For those observers, you should manually call removeObserver(Observer).

An observer added with a Lifecycle will be automatically removed if the corresponding Lifecycle moves to Lifecycle.State#DESTROYED state. This is especially useful for activities and fragments where they can safely observe LiveData and not worry about leaks: they will be instantly unsubscribed when they are destroyed.

In addition, LiveData has LiveData#onActive() and LiveData#onInactive() methods to get notified when number of active Observers change between 0 and 1. This allows LiveData to release any heavy resources when it does not have any Observers that are actively observing.

This class is designed to hold individual data fields of ViewModel, but can also be used for sharing data between different modules in your application in a decoupled fashion.

Summary

Public constructors
<init>(value: T) Creates a LiveData initialized with the given value.
<init>() Creates a LiveData with no value assigned to it.

Public methods
open T?	getValue() Returns the current value.
open Boolean	hasActiveObservers() Returns true if this LiveData has active observers.
open Boolean	hasObservers() Returns true if this LiveData has observers.
open Unit	observe(@NonNull owner: LifecycleOwner, @NonNull observer: Observer<in T>) Adds the given observer to the observers list within the lifespan of the given owner.
open Unit	observeForever(@NonNull observer: Observer<in T>) Adds the given observer to the observers list.
open Unit	removeObserver(@NonNull observer: Observer<in T>) Removes the given observer from the observers list.
open Unit	removeObservers(@NonNull owner: LifecycleOwner) Removes all observers that are tied to the given LifecycleOwner.

Protected methods
open Unit	onActive() Called when the number of active observers change from 0 to 1.
open Unit	onInactive() Called when the number of active observers change from 1 to 0.
open Unit	postValue(value: T) Posts a task to a main thread to set the given value.
open Unit	setValue(value: T) Sets the value.

Extension functions
From androidx.lifecycle Flow<T> LiveData<T>.asFlow() Creates a Flow containing values dispatched by originating LiveData: at the start a flow collector receives the latest value held by LiveData and then observes LiveData updates. LiveData<X> LiveData<X>.distinctUntilChanged() Creates a new LiveData object does not emit a value until the source this LiveData value has been changed. LiveData<Y> LiveData<X>.map(crossinline transform: (X) -> Y) Returns a LiveData mapped from this LiveData by applying transform to each value set on this LiveData. Observer<T> LiveData<T>.observe(owner: LifecycleOwner, crossinline onChanged: (T) -> Unit) Adds the given onChanged lambda as an observer within the lifespan of the given owner and returns a reference to observer. LiveData<Y> LiveData<X>.switchMap(crossinline transform: (X) -> LiveData<Y>) Returns a LiveData mapped from the input this LiveData by applying transform to each value set on this. Publisher<T> LiveData<T>.toPublisher(lifecycle: LifecycleOwner) Adapts the given LiveData stream to a ReactiveStreams Publisher.
From androidx.paging LiveData<PagingData<T>> LiveData<PagingData<T>>.cachedIn(lifecycle: Lifecycle) Operator which caches a LiveData of PagingData within the scope of a Lifecycle. LiveData<PagingData<T>> LiveData<PagingData<T>>.cachedIn(scope: CoroutineScope) Operator which caches a LiveData of PagingData within a CoroutineScope.

Public constructors

<init>

LiveData(value: T)

Creates a LiveData initialized with the given value.

Parameters
value	T: initial value

<init>

LiveData()

Creates a LiveData with no value assigned to it.

Public methods

getValue

@Nullable open fun getValue(): T?

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

Return
T?	the current value

hasActiveObservers

open fun hasActiveObservers(): Boolean

Returns true if this LiveData has active observers.

Return
Boolean	true if this LiveData has active observers

hasObservers

open fun hasObservers(): Boolean

Returns true if this LiveData has observers.

Return
Boolean	true if this LiveData has observers

observe

@MainThread open fun observe(
    @NonNull owner: LifecycleOwner, 
    @NonNull observer: Observer<in T>
): Unit

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 Lifecycle.State#STARTED or Lifecycle.State#RESUMED state (active).

If the owner moves to the Lifecycle.State#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 Lifecycle.State#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.

Parameters
owner	LifecycleOwner: The LifecycleOwner which controls the observer
observer	Observer<in T>: The observer that will receive the events

observeForever

@MainThread open fun observeForever(@NonNull observer: Observer<in T>): Unit

Adds the given observer to the observers list. This call is similar to LiveData#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.

Parameters
observer	Observer<in T>: The observer that will receive the events

removeObserver

@MainThread open fun removeObserver(@NonNull observer: Observer<in T>): Unit

Removes the given observer from the observers list.

Parameters
observer	Observer<in T>: The Observer to receive events.

removeObservers

@MainThread open fun removeObservers(@NonNull owner: LifecycleOwner): Unit

Removes all observers that are tied to the given LifecycleOwner.

Parameters
owner	LifecycleOwner: The LifecycleOwner scope for the observers to be removed.

Protected methods

onActive

protected open fun onActive(): Unit

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

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

onInactive

protected open fun onInactive(): Unit

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 Lifecycle.State#STARTED or Lifecycle.State#RESUMED (like an Activity in the back stack).

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

postValue

protected open fun postValue(value: T): Unit

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");
      

The value "b" would be set at first and later the main thread would override it with the value "a".

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

Parameters
value	T: The new value

setValue

@MainThread protected open fun setValue(value: T): Unit

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)

Parameters
value	T: The new value