Package io.reactivex.flowable

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

See: Description

Interface Summary

Interface	Description
FlowableEmitter<T>	Abstraction over a Reactive Streams 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.
FlowableTransformer<Upstream,Downstream>	Interface to compose Flowables.
ParallelTransformer<Upstream,Downstream>	Interface to compose ParallelFlowable.

Class Summary

Class	Description
ConnectableFlowable<T>	A ConnectableObservable resembles an ordinary Flowable, except that it does not begin emitting items when it is subscribed to, but only when its ConnectableFlowable.connect(io.reactivex.common.functions.Consumer<? super io.reactivex.common.Disposable>) method is called.
Flowable<T>	The Flowable class that implements the Reactive-Streams Pattern and offers factory methods, intermediate operators and the ability to consume reactive dataflows.
GroupedFlowable<K,T>	A Flowable that has been grouped by key, the value of which can be obtained with GroupedFlowable.getKey().
ParallelFlowable<T>	Abstract base class for Parallel publishers that take an array of Subscribers.
RxJavaFlowablePlugins	Utility class to inject handlers to certain standard RxJava operations.

Enum Summary

Enum	Description
BackpressureKind	Enumeration for various kinds of backpressure support.
BackpressureOverflowStrategy	Options to deal with buffer overflow when using onBackpressureBuffer.
BackpressureStrategy	Represents the options for applying backpressure to a source sequence.
ParallelFailureHandling	Enumerations for handling failure within a parallel operator.

Annotation Types Summary

Annotation Type	Description
BackpressureSupport	Indicates the backpressure support kind of the associated operator or class.

Package io.reactivex.flowable 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 Subscriber classes.