livedata/dev.funkymuse.livedata

Package-level declarations

Types

class EventObserver<T>(onEventUnhandledContent: (T) -> Unit) : Observer<SingleEvent<T>>

An Observer for SingleEvents, simplifying the pattern of checking if the SingleEvent's content has already been handled.

NonNullLiveData

class NonNullLiveData<T>(liveData: LiveData<T>) : LiveData<T>

open class SingleEvent<out T>(content: T)

class SingleLiveData<T>(liveData: LiveData<T>) : MediatorLiveData<T>

SingleLiveDataConcat

class SingleLiveDataConcat<T>(liveDataList: List<SingleLiveData<T>>) : MediatorLiveData<T>

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.

Properties

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

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

Emits at most 1 item and returns a SingleLiveData

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

fun <T> T?.asLiveData(): LiveData<T>

Creates an instance of LiveData with this as its value.

asMutableLiveData

fun <T> T?.asMutableLiveData(): MutableLiveData<T>

Creates an instance of MutableLiveData with this as its value.

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.

fun <T> concat(vararg liveData: LiveData<T>): LiveData<T>

Concats the given LiveData together and emits their values one by one in order

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

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

Emits the default value when a null value is emitted

fun <T> LiveData<T>.distinct(): LiveData<T>

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

distinctUntilChanged

fun <T> LiveData<T>.distinctUntilChanged(): LiveData<T>

Emits the items that are different from the last item

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.

fun <T> emptyLiveData(): MutableLiveData<T>

Creates an empty LiveData.

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

Emits the items that pass through the predicate

fun <T> LiveData<T>.first(): SingleLiveData<T>

Emits at most 1 item and returns a SingleLiveData

fun <T> liveDataOf(initialValue: T): MutableLiveData<T>

Creates a LiveData that emits the initialValue immediately.

fun <T> liveDataOf(callable: () -> T): LiveData<T>

Creates a LiveData that emits the value that the callable function produces, immediately.

fun <T> List<LiveData<T>>.merge(): LiveData<T>

Merges multiple LiveData, and emits any item that was emitted by any of them

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

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

Emits only the values that are not null

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

Emits only the values that are not null

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

Notifies the observer with the same live data as it holds

inline fun <T, L : LiveData<T>> LifecycleOwner.observe(liveData: L, crossinline body: (T) -> Unit = {})

Shorthand function that will observe the liveData using this as the LifecycleOwner. If the emitted value is not null then body is invoked with it as an argument.

fun <T, L : LiveData<SingleEvent<T>>> LifecycleOwner.observeEvent(liveData: L, body: (T) -> Unit = {})

Shorthand function that will observe the liveData using this as the LifecycleOwner. It uses EventObserver to observe the emitted values.

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

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

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

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

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

Skips the first n values

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)

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

Emits the startingValue before any other value.

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

Emits the first n valueus

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.

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

toMutableLiveData

fun <T> LiveData<T>.toMutableLiveData(): MutableLiveData<T>

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

toSingleLiveData

fun <T> LiveData<T>.toSingleLiveData(): SingleLiveData<T>

Converts a LiveData to a SingleLiveData (exactly similar to LiveData.first()