core/com.tealium.prism.core.api.pubsub

Package-level declarations

Types

BiConsumer

fun interface BiConsumer<T, R>

Reimplementation of the Java SDK's java.util.function.BiConsumer that isn't supported across all Android API levels.

CompositeDisposable

interface CompositeDisposable : Disposable

Defines a Disposable implementation that can dispose of multiple other Disposable implementations in one go.

Consumer

fun interface Consumer<T>

Reimplementation of the Java SDK's java.util.function.Consumer that isn't supported across all Android API levels.

Disposable

interface Disposable

Defines a resource that can be disposed.

Disposables

object Disposables

Contains factory methods for creating common Disposable instances for use with the Tealium SDK.

Observable

interface Observable<T> : Subscribable<T>

Base class for observable implementations - provides methods for built in intermediate operations.

Observables

object Observables

Factory object for creating common Observable and Subject implementations.

ObservableState

interface ObservableState<T> : Observable<T> , SubscribableState<T>

ObservableState is a read-only wrapper of a StateSubject. It can be used to provide assurances that the Subject itself cannot be accidentally retrieved via casting, but that accessors can still subscribe to the underlying Subject.

Observer

interface Observer<T>

Interface representing an Observer of items emitted by an Observable.

ReplaySubject

interface ReplaySubject<T> : Subject<T>

A ReplaySubject is a specialized Subject that also maintains the latest N emissions in a cache. Upon subscription, all values in the cache will be emitted to the subscriber.

Single

interface Single<T> : Subscribable<T>

A Subscribable implementation whereby only a single result is expected to be emitted to the subscriber.

SingleResult

typealias SingleResult<T> = Single<TealiumResult<T>>

A Single that completes with a TealiumResult.

StateSubject

interface StateSubject<T> : Subject<T> , ObservableState<T>

A StateSubject is a specialized Subject that also maintains the latest emission as state, retrievable via the value getter.

Subject

interface Subject<T> : Observable<T> , Observer<T>

A Subject is an Observable that can be used to publish new values to any subscribers, where an Observable cannot.

Subscribable

interface Subscribable<T>

A Subscribable object allows you to subscribe an Observer to receive updates from a specific source. Each updated value will be provided through the given Observer.onNext method.

SubscribableState

interface SubscribableState<T> : Subscribable<T>

A SubscribableState object allows you to subscribe an Observer to receive updates from a specific source - as with Subscribable. Each updated value will be provided through the given Observer.onNext method.

Functions

addTo

fun <T : Disposable> T.addTo(container: CompositeDisposable): T

Add the current disposable to a specific container for easier cleanup.

filterNotNull

fun <T> Observable<T?>.filterNotNull(): Observable<T>

Convenience method for converting an observable of nullable items, into an observable of non-nullable items.

mapToUnit

fun <T> Observable<T>.mapToUnit(): Observable<Unit>

Convenience method that maps any incoming emission to Unit

merge

fun <T> Iterable<Observable<T>>.merge(): Observable<T>

Convenience method for merging a Iterable group of Observables of the same type.

onFailure

fun <T : TealiumResult<R>, R> Single<T>.onFailure(handler: Callback<Exception>): Disposable

Subscribes a handler for handling only the failure element of this Single.

onSuccess

fun <T : TealiumResult<R>, R> Single<T>.onSuccess(handler: Callback<R>): Disposable

Subscribes a handler for handling only the successful element of this Single.

fun <T> Observable<T>.subscribe(composite: CompositeDisposable, onNext: Consumer<T>): Disposable

Subscribes the given onNext to receive updates. The subscription is stored in the given composite

fun <T> Observable<T>.subscribe(composite: CompositeDisposable, observer: Observer<T>): Disposable

Subscribes the given observer to receive updates, including an Observer.onComplete notification when the upstream source terminates. The subscription is stored in the given composite

fun <T> Observable<T>.subscribe(composite: CompositeDisposable, onNext: Consumer<T>, onComplete: Runnable): Disposable

Subscribes the given onNext to receive updates and the given onComplete to receive the Observer.onComplete signal. The subscription is stored in the given composite