livedata/dev.funkymuse.livedata/NonNullLiveData

NonNullLiveData

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

Constructors

NonNullLiveData

constructor(liveData: LiveData<T>)

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.

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

observe

@MainThread

open fun observe(@NonNull p0: LifecycleOwner, @NonNull p1: 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>)

removeObserver

@MainThread

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

removeObservers

@MainThread

open fun removeObservers(@NonNull p0: LifecycleOwner)

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