Package io.reactivex.observable

Base reactive classes: Flowable, Observable, Single and Completable; base reactive consumers; other common base interfaces.

See: Description

Interface Summary

Interface	Description
CompletableEmitter	Abstraction over an RxJava CompletableObserver that allows associating a resource with it.
CompletableObserver	Represents the subscription API callbacks when subscribing to a Completable instance.
CompletableOnSubscribe	A functional interface that has a subscribe() method that receives an instance of a CompletableEmitter instance that allows pushing an event in a cancellation-safe manner.
CompletableOperator	Interface to map/wrap a downstream observer to an upstream observer.
CompletableSource	Represents a basic Completable source base interface, consumable via an CompletableObserver.
CompletableTransformer	Convenience interface and callback used by the compose operator to turn a Completable into another Completable fluently.
MaybeEmitter<T>	Abstraction over an RxJava MaybeObserver that allows associating a resource with it.
MaybeObserver<T>	Provides a mechanism for receiving push-based notifications.
MaybeOnSubscribe<T>	A functional interface that has a subscribe() method that receives an instance of a MaybeEmitter instance that allows pushing an event in a cancellation-safe manner.
MaybeOperator<Downstream,Upstream>	Interface to map/wrap a downstream observer to an upstream observer.
MaybeSource<T>	Represents a basic Maybe source base interface, consumable via an MaybeObserver.
MaybeTransformer<Upstream,Downstream>	Interface to compose Maybes.
ObservableEmitter<T>	Abstraction over an RxJava Observer that allows associating a resource with it.
ObservableOnSubscribe<T>	A functional interface that has a subscribe() method that receives an instance of an ObservableEmitter instance that allows pushing events in a cancellation-safe manner.
ObservableOperator<Downstream,Upstream>	Interface to map/wrap a downstream observer to an upstream observer.
ObservableSource<T>	Represents a basic, non-backpressured Observable source base interface, consumable via an Observer.
ObservableTransformer<Upstream,Downstream>	Interface to compose Observables.
Observer<T>	Provides a mechanism for receiving push-based notifications.
SingleEmitter<T>	Abstraction over an RxJava SingleObserver that allows associating a resource with it.
SingleObserver<T>	Provides a mechanism for receiving push-based notifications.
SingleOnSubscribe<T>	A functional interface that has a subscribe() method that receives an instance of a SingleEmitter instance that allows pushing an event in a cancellation-safe manner.
SingleOperator<Downstream,Upstream>	Interface to map/wrap a downstream observer to an upstream observer.
SingleSource<T>	Represents a basic Single source base interface, consumable via an SingleObserver.
SingleTransformer<Upstream,Downstream>	Interface to compose Singles.

Class Summary

Class	Description
Completable	Represents a deferred computation without any value but only indication for completion or exception.
ConnectableObservable<T>	A ConnectableObservable resembles an ordinary Observable, except that it does not begin emitting items when it is subscribed to, but only when its ConnectableObservable.connect(io.reactivex.common.functions.Consumer<? super io.reactivex.common.Disposable>) method is called.
GroupedObservable<K,T>	An Observable that has been grouped by key, the value of which can be obtained with GroupedObservable.getKey().
Maybe<T>	Represents a deferred computation and emission of a maybe value or exception.
Observable<T>	The Observable class that is designed similar to the Reactive-Streams Pattern, minus the backpressure, and offers factory methods, intermediate operators and the ability to consume reactive dataflows.
RxJavaObservablePlugins	Utility class to inject handlers to certain standard RxJava operations.
Single<T>	The Single class implements the Reactive Pattern for a single value response.

Package io.reactivex.observable Description

Base reactive classes: Flowable, Observable, Single and Completable; base reactive consumers; other common base interfaces.

A library that enables subscribing to and composing asynchronous events and callbacks.

The Flowable/Subscriber, Observable/Observer, Single/SingleObserver and Completable/CompletableObserver interfaces and associated operators (in the io.reactivex.internal.operators package) are inspired by the Reactive Rx library in Microsoft .NET but designed and implemented on the more advanced Reactive-Streams ( http://www.reactivestreams.org ) principles.

More information can be found at http://msdn.microsoft.com/en-us/data/gg577609.

Compared with the Microsoft implementation:

• Observable == IObservable (base type)
• Observer == IObserver (event consumer)
• Disposable == IDisposable (resource/cancellation management)
• Observable == Observable (factory methods)
• Flowable == IAsyncEnumerable (backpressure)
• Subscriber == IAsyncEnumerator

The Single and Completable reactive base types have no equivalent in Rx.NET as of 3.x.

Services which intend on exposing data asynchronously and wish to allow reactive processing and composition can implement the io.reactivex.Flowable, io.reactivex.Observable, io.reactivex.Single or io.reactivex.Completable class which then allow consumers to subscribe to them and receive events.

Usage examples can be found on the io.reactivex.Flowable/io.reactivex.Observable and org.reactivestreams.Subscriber classes.