Package io.reactivex.rxjava3.core
Flowable
, Observable
,
Single
, Maybe
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
Services which intend on exposing data asynchronously and wish
to allow reactive processing and composition can implement the
Flowable
, Observable
, Single
,
Maybe
or Completable
class which then allow
consumers to subscribe to them and receive events.
Usage examples can be found on the Flowable
/Observable
and Subscriber
classes.
-
Interface Summary Interface Description CompletableConverter<R> Convenience interface and callback used by theCompletable.to(io.reactivex.rxjava3.core.CompletableConverter<? extends R>)
operator to turn a Completable into another value fluently.CompletableEmitter Abstraction over an RxJavaCompletableObserver
that allows associating a resource with it.CompletableObserver Provides a mechanism for receiving push-based notification of a valueless completion or an error.CompletableOnSubscribe A functional interface that has asubscribe()
method that receives aCompletableEmitter
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 basicCompletable
source base interface, consumable via anCompletableObserver
.CompletableTransformer Convenience interface and callback used by the compose operator to turn aCompletable
into anotherCompletable
fluently.Emitter<T> Base interface for emitting signals in a push-fashion in various generator-like source operators (create, generate).FlowableConverter<T,R> Convenience interface and callback used by theFlowable.to(io.reactivex.rxjava3.core.FlowableConverter<T, ? extends R>)
operator to turn aFlowable
into another value fluently.FlowableEmitter<T> Abstraction over a Reactive StreamsSubscriber
that allows associating a resource with it and exposes the current number of downstream requested amount.FlowableOnSubscribe<T> A functional interface that has asubscribe()
method that receives aFlowableEmitter
instance that allows pushing events in a backpressure-safe and cancellation-safe manner.FlowableOperator<Downstream,Upstream> Interface to map/wrap a downstreamSubscriber
to an upstreamSubscriber
.FlowableSubscriber<T> FlowableTransformer<Upstream,Downstream> Interface to composeFlowable
s.MaybeConverter<T,R> Convenience interface and callback used by theMaybe.to(io.reactivex.rxjava3.core.MaybeConverter<T, ? extends R>)
operator to turn aMaybe
into another value fluently.MaybeEmitter<T> Abstraction over an RxJavaMaybeObserver
that allows associating a resource with it.MaybeObserver<T> Provides a mechanism for receiving push-based notification of a single value, an error or completion without any value.MaybeOnSubscribe<T> A functional interface that has asubscribe()
method that receives aMaybeEmitter
instance that allows pushing an event in a cancellation-safe manner.MaybeOperator<Downstream,Upstream> Interface to map/wrap a downstreamMaybeObserver
to an upstreamMaybeObserver
.MaybeSource<T> Represents a basicMaybe
source base interface, consumable via anMaybeObserver
.MaybeTransformer<Upstream,Downstream> Interface to composeMaybe
s.ObservableConverter<T,R> Convenience interface and callback used by theObservable.to(io.reactivex.rxjava3.core.ObservableConverter<T, ? extends R>)
operator to turn anObservable
into another value fluently.ObservableEmitter<T> Abstraction over an RxJavaObserver
that allows associating a resource with it.ObservableOnSubscribe<T> A functional interface that has asubscribe()
method that receives anObservableEmitter
instance that allows pushing events in a cancellation-safe manner.ObservableOperator<Downstream,Upstream> Interface to map/wrap a downstreamObserver
to an upstreamObserver
.ObservableSource<T> Represents a basic, non-backpressuredObservable
source base interface, consumable via anObserver
.ObservableTransformer<Upstream,Downstream> Interface to composeObservable
s.Observer<T> Provides a mechanism for receiving push-based notifications.SingleConverter<T,R> Convenience interface and callback used by theSingle.to(io.reactivex.rxjava3.core.SingleConverter<T, ? extends R>)
operator to turn aSingle
into another value fluently.SingleEmitter<T> Abstraction over an RxJavaSingleObserver
that allows associating a resource with it.SingleObserver<T> Provides a mechanism for receiving push-based notification of a single value or an error.SingleOnSubscribe<T> A functional interface that has asubscribe()
method that receives aSingleEmitter
instance that allows pushing an event in a cancellation-safe manner.SingleOperator<Downstream,Upstream> Interface to map/wrap a downstreamSingleObserver
to an upstreamSingleObserver
.SingleSource<T> Represents a basicSingle
source base interface, consumable via anSingleObserver
.SingleTransformer<Upstream,Downstream> Interface to composeSingle
s. -
Class Summary Class Description Completable TheCompletable
class represents a deferred computation without any value but only indication for completion or exception.Flowable<T> TheFlowable
class that implements the Reactive StreamsPublisher
Pattern and offers factory methods, intermediate operators and the ability to consume reactive dataflows.Maybe<T> TheMaybe
class represents a deferred computation and emission of a single value, no value at all or an exception.Notification<T> Represents the reactive signal types:onNext
,onError
andonComplete
and holds their parameter values (a value, aThrowable
, nothing).Observable<T> TheObservable
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 AScheduler
is an object that specifies an API for scheduling units of work provided in the form ofRunnable
s to be executed without delay (effectively as soon as possible), after a specified time delay or periodically and represents an abstraction over an asynchronous boundary that ensures these units of work get executed by some underlying task-execution scheme (such as custom Threads, event loop,Executor
or Actor system) with some uniform properties and guarantees regardless of the particular underlying scheme.Scheduler.DisposeTask Scheduler.PeriodicDirectTask Scheduler.Worker Represents an isolated, sequential worker of a parent Scheduler for executingRunnable
tasks on an underlying task-execution scheme (such as custom Threads, event loop,Executor
or Actor system).Single<T> TheSingle
class implements the Reactive Pattern for a single value response. -
Enum Summary Enum Description BackpressureOverflowStrategy Options to deal with buffer overflow when using onBackpressureBuffer.BackpressureStrategy Represents the options for applying backpressure to a source sequence.