livedata/dev.funkymuse.livedata/SingleLiveEvent

SingleLiveEvent

class SingleLiveEvent<T> : MutableLiveData<T>

A lifecycle-aware observable that sends only new updates after subscription, used for events like navigation and Snackbar messages.

This avoids a common problem with events: on configuration change (like rotation) an update can be emitted if the observer is active. This LiveData only calls the observable if there's an explicit call to setValue() or call().

Note that only one observer is going to be notified of changes.

Constructors

SingleLiveEvent

constructor()

Types

Companion

object Companion

Properties

distinct

val <T> LiveData<T>.distinct: LiveData<T>

Emits the items that are different from all the values that have been emitted so far

distinctUntilChanged

val <T> LiveData<T>.distinctUntilChanged: LiveData<T>

Emits the items that are different from the last item

first

val <T> LiveData<T>.first: SingleLiveData<T>

Emits at most 1 item and returns a SingleLiveData

nonNullValues

val <T> LiveData<T>.nonNullValues: NonNullLiveData<T>

Emits only the values that are not null

toMutableLiveData

val <T> LiveData<T>.toMutableLiveData: MutableLiveData<T>

Converts a LiveData to a MutableLiveData with the initial value set by this LiveData's value

toSingleLiveData

val <T> LiveData<T>.toSingleLiveData: SingleLiveData<T>

Converts a LiveData to a SingleLiveData

Functions

buffer

fun <T> LiveData<T>.buffer(count: Int): MutableLiveData<List<T?>>

Buffers the items emitted by the LiveData, and emits them when they reach the count as a List.

call

@MainThread

fun call()

Used for cases where T is Void, to make calls cleaner.

concatWith

fun <T> LiveData<T>.concatWith(otherLiveData: LiveData<T>): LiveData<T>

defaultIfNull

fun <T> LiveData<T>.defaultIfNull(default: T): LiveData<T>

Emits the default value when a null value is emitted

elementAt

fun <T> LiveData<T>.elementAt(index: Int): SingleLiveData<T>

emits the item that was emitted at index position Note: This only works for elements that were emitted after the elementAt is applied.

filter

inline fun <T> LiveData<T>.filter(crossinline predicate: (T?) -> Boolean): LiveData<T>

Emits the items that pass through the predicate

getValue

@Nullable

open fun getValue(): T?

hasActiveObservers

open fun hasActiveObservers(): Boolean

hasObservers

open fun hasObservers(): Boolean

isInitialized

open fun isInitialized(): Boolean

mergeWith

fun <T> LiveData<T>.mergeWith(vararg liveDatas: LiveData<T>): LiveData<T>

Merges this LiveData with another one, and emits any item that was emitted by any of them

nonNull

fun <T> LiveData<T>.nonNull(): NonNullLiveData<T>

Emits only the values that are not null

notifyObserver

fun <T> MutableLiveData<T>.notifyObserver()

Notifies the observer with the same live data as it holds

observe

@MainThread

open override fun observe(owner: LifecycleOwner, observer: Observer<in T>)

observeEvent

inline fun <T> LiveData<SingleEvent<T>>.observeEvent(owner: LifecycleOwner, crossinline onEventUnhandledContent: (T) -> Unit)

observeForever

@MainThread

open fun observeForever(@NonNull p0: Observer<in T>)

observeOnce

fun <T> LiveData<T>.observeOnce(observer: Observer<T>)

postValue

open override fun postValue(p0: T)

postValueIfNew

fun <T> MutableLiveData<T>.postValueIfNew(newValue: T)

removeObserver

@MainThread

open fun removeObserver(@NonNull p0: Observer<in T>)

removeObservers

@MainThread

open fun removeObservers(@NonNull p0: LifecycleOwner)

setValue

@MainThread

open override fun setValue(t: T?)

setValueIfNew

fun <T> MutableLiveData<T>.setValueIfNew(newValue: T)

skip

fun <T> LiveData<T>.skip(count: Int): LiveData<T>

Skips the first n values

skipUntil

inline fun <T> LiveData<T>.skipUntil(crossinline predicate: (T?) -> Boolean): LiveData<T>

Skips all values until a certain predicate is met (the item that actives the predicate is also emitted)

startWith

fun <T> LiveData<T>.startWith(startingValue: T?): LiveData<T>

Emits the startingValue before any other value.

take

fun <T> LiveData<T>.take(count: Int): LiveData<T>

Emits the first n valueus

takeUntil

inline fun <T> LiveData<T>.takeUntil(crossinline predicate: (T?) -> Boolean): LiveData<T>

Takes until a certain predicate is met, and does not emit anything after that, whatever the value.

then

fun <T> LiveData<T>.then(otherLiveData: LiveData<T>): LiveData<T>

Converts the LiveData to SingleLiveData and concats it with the otherLiveData and emits their values one by one