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:
Services which intend on exposing data asynchronously and wish
to allow reactive processing and composition can implement the
Flowable
, Observable
, Single
or Completable
class which then allow consumers to subscribe to them
and receive events.
Usage examples can be found on the Flowable
/Observable
and org.reactivestreams.Subscriber classes.
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. |
Emitter<T> | Base interface for emitting signals in a push-fashion in various generator-like source operators (create, generate). |
FlowableEmitter<T> | Abstraction over a Reactive Streams org.reactivestreams.Subscriber that allows associating a resource with it and exposes the current number of downstream requested amount. |
FlowableOnSubscribe<T> | A functional interface that has a subscribe() method that receives
an instance of a FlowableEmitter instance that allows pushing
events in a backpressure-safe and cancellation-safe manner. |
FlowableOperator<Downstream, Upstream> | Interface to map/wrap a downstream subscriber to an upstream subscriber. |
FlowableSubscriber<T> | Represents a Reactive-Streams inspired Subscriber that is RxJava 2 only and weakens rules §1.3 and §3.9 of the specification for gaining performance. |
FlowableTransformer<Upstream, Downstream> | Interface to compose Flowables. |
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. |
Completable | Represents a deferred computation without any value but only indication for completion or exception. |
Flowable<T> | The Flowable class that implements the Reactive-Streams Pattern and offers factory methods, intermediate operators and the ability to consume reactive dataflows. |
Maybe<T> | Represents a deferred computation and emission of a maybe value or exception. |
Notification<T> | Represents the reactive signal types: onNext, onError and onComplete and holds their parameter values (a value, a Throwable, nothing). |
Observable<T> | The Observable class is the non-backpressured, optionally multi-valued base reactive class that offers factory methods, intermediate operators and the ability to consume synchronous and/or asynchronous reactive dataflows. |
Scheduler | A Scheduler is an object that specifies an API for scheduling
units of work with or without delays or periodically. |
Scheduler.Worker | Sequential Scheduler for executing actions on a single thread or event loop. |
Single<T> | The Single class implements the Reactive Pattern for a single value response. |
BackpressureOverflowStrategy | Options to deal with buffer overflow when using onBackpressureBuffer. |
BackpressureStrategy | Represents the options for applying backpressure to a source sequence. |