Uses of Interface
io.reactivex.rxjava3.functions.Action

Packages that use Action

Package	Description
io.reactivex.rxjava3.core	Base reactive classes: Flowable, Observable, Single, Maybe and Completable; base reactive consumers; other common base interfaces.
io.reactivex.rxjava3.disposables	Default implementations for Disposable-based resource management (Disposable container types) and utility classes to construct Disposables from callbacks and other types.
io.reactivex.rxjava3.internal.functions
io.reactivex.rxjava3.internal.observers
io.reactivex.rxjava3.internal.operators.completable
io.reactivex.rxjava3.internal.operators.flowable
io.reactivex.rxjava3.internal.operators.maybe
io.reactivex.rxjava3.internal.operators.observable
io.reactivex.rxjava3.internal.operators.parallel
io.reactivex.rxjava3.internal.operators.single
io.reactivex.rxjava3.internal.subscribers
io.reactivex.rxjava3.internal.util
io.reactivex.rxjava3.parallel	Contains the base type ParallelFlowable, a sub-DSL for working with Flowable sequences in parallel.

Uses of Action in io.reactivex.rxjava3.core

Methods in io.reactivex.rxjava3.core with parameters of type Action

Modifier and Type	Method	Description
void	Completable.blockingSubscribe(@NonNull Action onComplete)	Subscribes to the current Completable and calls given onComplete callback on the current thread when it completes normally.
void	Completable.blockingSubscribe(@NonNull Action onComplete, @NonNull Consumer<? super java.lang.Throwable> onError)	Subscribes to the current Completable and calls the appropriate callback on the current thread when it terminates.
void	Flowable.blockingSubscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull Action onComplete)	Subscribes to the source and calls the given callbacks on the current thread.
void	Flowable.blockingSubscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull Action onComplete, int bufferSize)	Subscribes to the source and calls the given callbacks on the current thread.
void	Maybe.blockingSubscribe(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull Action onComplete)	Subscribes to the current Maybe and calls the appropriate callback on the current thread when it terminates.
void	Observable.blockingSubscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull Action onComplete)	Subscribes to the source and calls the given callbacks on the current thread.
@NonNull Completable	Completable.doAfterTerminate(@NonNull Action onAfterTerminate)	Returns a Completable instance that calls the given onAfterTerminate Action after this Completable completes normally or with an exception.
@NonNull Flowable<T>	Flowable.doAfterTerminate(@NonNull Action onAfterTerminate)	Registers an Action to be called when this Publisher invokes either onComplete or onError.
@NonNull Maybe<T>	Maybe.doAfterTerminate(@NonNull Action onAfterTerminate)	Registers an Action to be called when this Maybe invokes either onSuccess, onComplete or onError.
@NonNull Observable<T>	Observable.doAfterTerminate(@NonNull Action onAfterTerminate)	Registers an Action to be called when the current Observable invokes either onComplete or onError.
@NonNull Single<T>	Single.doAfterTerminate(@NonNull Action onAfterTerminate)	Registers an Action to be called after this Single invokes either onSuccess or onError.
@NonNull Completable	Completable.doFinally(@NonNull Action onFinally)	Calls the specified Action after this Completable signals onError or onComplete or gets disposed by the downstream.
@NonNull Flowable<T>	Flowable.doFinally(@NonNull Action onFinally)	Calls the specified action after this Flowable signals onError or onComplete or gets canceled by the downstream.
@NonNull Maybe<T>	Maybe.doFinally(@NonNull Action onFinally)	Calls the specified action after this Maybe signals onSuccess, onError or onComplete or gets disposed by the downstream.
@NonNull Observable<T>	Observable.doFinally(@NonNull Action onFinally)	Calls the specified action after the current Observable signals onError or onCompleted or gets disposed by the downstream.
@NonNull Single<T>	Single.doFinally(@NonNull Action onFinally)	Calls the specified action after this Single signals onSuccess or onError or gets disposed by the downstream.
@NonNull Flowable<T>	Flowable.doOnCancel(@NonNull Action onCancel)	Calls the cancel Action if the downstream cancels the sequence.
@NonNull Completable	Completable.doOnComplete(@NonNull Action onComplete)	Returns a Completable which calls the given onComplete Action if this Completable completes.
@NonNull Flowable<T>	Flowable.doOnComplete(@NonNull Action onComplete)	Invokes an Action just before the current Flowable calls onComplete.
@NonNull Maybe<T>	Maybe.doOnComplete(@NonNull Action onComplete)	Invokes an Action just before the current Maybe calls onComplete.
@NonNull Observable<T>	Observable.doOnComplete(@NonNull Action onComplete)	Returns an Observable that invokes an Action when the current Observable calls onComplete.
@NonNull Completable	Completable.doOnDispose(@NonNull Action onDispose)	Calls the shared Action if a CompletableObserver subscribed to the current Completable disposes the common Disposable it received via onSubscribe.
@NonNull Maybe<T>	Maybe.doOnDispose(@NonNull Action onDispose)	Calls the shared Action if a MaybeObserver subscribed to the current Maybe disposes the common Disposable it received via onSubscribe.
@NonNull Observable<T>	Observable.doOnDispose(@NonNull Action onDispose)	Calls the given shared Action if the downstream disposes the sequence.
@NonNull Single<T>	Single.doOnDispose(@NonNull Action onDispose)	Calls the shared Action if a SingleObserver subscribed to the current Single disposes the common Disposable it received via onSubscribe.
private @NonNull Flowable<T>	Flowable.doOnEach(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError, Action onComplete, Action onAfterTerminate)	Calls the appropriate onXXX consumer (shared between all subscribers) whenever a signal with the same type passes through, before forwarding them to downstream.
private @NonNull Observable<T>	Observable.doOnEach(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull Action onComplete, @NonNull Action onAfterTerminate)	Calls the appropriate onXXX consumer (shared between all Observers) whenever a signal with the same type passes through, before forwarding them to the downstream.
@NonNull Completable	Completable.doOnLifecycle(@NonNull Consumer<? super Disposable> onSubscribe, @NonNull Action onDispose)	Calls the appropriate onXXX method (shared between all CompletableObservers) for the lifecycle events of the sequence (subscription, disposal).
private @NonNull Completable	Completable.doOnLifecycle(Consumer<? super Disposable> onSubscribe, Consumer<? super java.lang.Throwable> onError, Action onComplete, Action onTerminate, Action onAfterTerminate, Action onDispose)	Returns a Completable instance that calls the various callbacks upon the specific lifecycle events.
@NonNull Flowable<T>	Flowable.doOnLifecycle(@NonNull Consumer<? super org.reactivestreams.Subscription> onSubscribe, @NonNull LongConsumer onRequest, @NonNull Action onCancel)	Calls the appropriate onXXX method (shared between all Subscribers) for the lifecycle events of the sequence (subscription, cancellation, requesting).
@NonNull Maybe<T>	Maybe.doOnLifecycle(@NonNull Consumer<? super Disposable> onSubscribe, @NonNull Action onDispose)	Calls the appropriate onXXX method (shared between all MaybeObservers) for the lifecycle events of the sequence (subscription, disposal).
@NonNull Observable<T>	Observable.doOnLifecycle(@NonNull Consumer<? super Disposable> onSubscribe, @NonNull Action onDispose)	Calls the appropriate onXXX method (shared between all Observers) for the lifecycle events of the sequence (subscription, disposal).
@NonNull Single<T>	Single.doOnLifecycle(@NonNull Consumer<? super Disposable> onSubscribe, @NonNull Action onDispose)	Calls the appropriate onXXX method (shared between all SingleObservers) for the lifecycle events of the sequence (subscription, disposal).
@NonNull Completable	Completable.doOnTerminate(@NonNull Action onTerminate)	Returns a Completable instance that calls the given onTerminate Action just before this Completable completes normally or with an exception.
@NonNull Flowable<T>	Flowable.doOnTerminate(@NonNull Action onTerminate)	Calls the given Action when the current Flowable completes normally or with an error before those signals are forwarded to the downstream.
@NonNull Maybe<T>	Maybe.doOnTerminate(@NonNull Action onTerminate)	Returns a Maybe instance that calls the given onTerminate callback just before this Maybe completes normally or with an exception.
@NonNull Observable<T>	Observable.doOnTerminate(@NonNull Action onTerminate)	Returns an Observable so that it invokes an action when the current Observable calls onComplete or onError.
@NonNull Single<T>	Single.doOnTerminate(@NonNull Action onTerminate)	Returns a Single instance that calls the given onTerminate callback just before this Single completes normally or with an exception.
@NonNull Disposable	Flowable.forEachWhile(@NonNull Predicate<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull Action onComplete)	Subscribes to the current Flowable and receives notifications for each element and the terminal events until the onNext Predicate returns false.
@NonNull Disposable	Observable.forEachWhile(@NonNull Predicate<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull Action onComplete)	Subscribes to the ObservableSource and calls a Predicate for each item, a Consumer with the error or an Action upon completion of the current Observable, on their original emission threads, until the predicate returns false.
static @NonNull Completable	Completable.fromAction(@NonNull Action action)	Returns a Completable instance that runs the given Action for each CompletableObserver and emits either an exception or simply completes.
static <@NonNull T> @NonNull Flowable<T>	Flowable.fromAction(@NonNull Action action)	Returns a Flowable instance that runs the given Action for each Subscriber and emits either its exception or simply completes.
static <@NonNull T> @NonNull Maybe<T>	Maybe.fromAction(@NonNull Action action)	Returns a Maybe instance that runs the given Action for each MaybeObserver and emits either its exception or simply completes.
static <@NonNull T> @NonNull Observable<T>	Observable.fromAction(@NonNull Action action)	Returns an Observable instance that runs the given Action for each Observer and emits either its exception or simply completes.
@NonNull Flowable<T>	Flowable.onBackpressureBuffer(int capacity, boolean delayError, boolean unbounded, @NonNull Action onOverflow)	Buffers an optionally unlimited number of items from the current Flowable and allows it to emit as fast it can while allowing the downstream to consume the items at its own place.
@NonNull Flowable<T>	Flowable.onBackpressureBuffer(int capacity, boolean delayError, boolean unbounded, @NonNull Action onOverflow, @NonNull Consumer<? super @NonNull T> onDropped)	Buffers an optionally unlimited number of items from the current Flowable and allows it to emit as fast it can while allowing the downstream to consume the items at its own place.
@NonNull Flowable<T>	Flowable.onBackpressureBuffer(int capacity, @NonNull Action onOverflow)	Buffers an limited number of items from the current Flowable and allows it to emit as fast it can while allowing the downstream to consume the items at its own place, however, the resulting Flowable will signal a MissingBackpressureException via onError as soon as the buffer's capacity is exceeded, dropping all undelivered items, canceling the flow and calling the onOverflow action.
@NonNull Flowable<T>	Flowable.onBackpressureBuffer(long capacity, @Nullable Action onOverflow, @NonNull BackpressureOverflowStrategy overflowStrategy)	Buffers an optionally unlimited number of items from the current Flowable and allows it to emit as fast it can while allowing the downstream to consume the items at its own place.
@NonNull Flowable<T>	Flowable.onBackpressureBuffer(long capacity, @Nullable Action onOverflow, @NonNull BackpressureOverflowStrategy overflowStrategy, @NonNull Consumer<? super @NonNull T> onDropped)	Buffers an optionally unlimited number of items from the current Flowable and allows it to emit as fast it can while allowing the downstream to consume the items at its own place.
@NonNull Disposable	Completable.subscribe(@NonNull Action onComplete)	Subscribes to this Completable and calls the given Action when this Completable completes normally.
@NonNull Disposable	Completable.subscribe(@NonNull Action onComplete, @NonNull Consumer<? super java.lang.Throwable> onError)	Subscribes to this Completable and calls back either the onError or onComplete functions.
@NonNull Disposable	Completable.subscribe(@NonNull Action onComplete, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull DisposableContainer container)	Wraps the given onXXX callbacks into a Disposable CompletableObserver, adds it to the given DisposableContainer and ensures, that if the upstream terminates or this particular Disposable is disposed, the CompletableObserver is removed from the given composite.
@NonNull Disposable	Flowable.subscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull Action onComplete)	Subscribes to the current Flowable and provides callbacks to handle the items it emits and any error or completion notification it issues.
@NonNull Disposable	Flowable.subscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull Action onComplete, @NonNull DisposableContainer container)	Wraps the given onXXX callbacks into a Disposable Subscriber, adds it to the given DisposableContainer and ensures, that if the upstream terminates or this particular Disposable is disposed, the Subscriber is removed from the given container.
@NonNull Disposable	Maybe.subscribe(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull Action onComplete)	Subscribes to a Maybe and provides callbacks to handle the items it emits and any error or completion notification it issues.
@NonNull Disposable	Maybe.subscribe(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull Action onComplete, @NonNull DisposableContainer container)	Wraps the given onXXX callbacks into a Disposable MaybeObserver, adds it to the given DisposableContainer and ensures, that if the upstream terminates or this particular Disposable is disposed, the MaybeObserver is removed from the given composite.
@NonNull Disposable	Observable.subscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull Action onComplete)	Subscribes to the current Observable and provides callbacks to handle the items it emits and any error or completion notification it signals.
@NonNull Disposable	Observable.subscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull Action onComplete, @NonNull DisposableContainer container)	Wraps the given onXXX callbacks into a Disposable Observer, adds it to the given DisposableContainer and ensures, that if the upstream terminates or this particular Disposable is disposed, the Observer is removed from the given container.

Uses of Action in io.reactivex.rxjava3.disposables

Methods in io.reactivex.rxjava3.disposables with parameters of type Action

Modifier and Type	Method	Description
static @NonNull Disposable	Disposable.fromAction(@NonNull Action action)	Construct a Disposable by wrapping a Action that is executed exactly once when the Disposable is disposed.
protected void	ActionDisposable.onDisposed(@NonNull Action value)

Constructors in io.reactivex.rxjava3.disposables with parameters of type Action

Constructor	Description
ActionDisposable(Action value)

Uses of Action in io.reactivex.rxjava3.internal.functions

Classes in io.reactivex.rxjava3.internal.functions that implement Action

Modifier and Type	Class	Description
(package private) static class	Functions.EmptyAction
(package private) static class	Functions.FutureAction
(package private) static class	Functions.NotificationOnComplete<T>

Fields in io.reactivex.rxjava3.internal.functions declared as Action

Modifier and Type	Field	Description
(package private) Action	Functions.ActionConsumer.action
static Action	Functions.EMPTY_ACTION

Methods in io.reactivex.rxjava3.internal.functions that return Action

Modifier and Type	Method	Description
static @NonNull Action	Functions.futureAction(@NonNull java.util.concurrent.Future<?> future)	Wraps the blocking get call of the Future into an Action.
static <T> Action	Functions.notificationOnComplete(Consumer<? super Notification<T>> onNotification)

Methods in io.reactivex.rxjava3.internal.functions with parameters of type Action

Modifier and Type	Method	Description
static <T> Consumer<T>	Functions.actionConsumer(Action action)

Constructors in io.reactivex.rxjava3.internal.functions with parameters of type Action

Constructor	Description
ActionConsumer(Action action)

Uses of Action in io.reactivex.rxjava3.internal.observers

Fields in io.reactivex.rxjava3.internal.observers declared as Action

Modifier and Type	Field	Description
(package private) Action	AbstractDisposableAutoRelease.onComplete
(package private) Action	CallbackCompletableObserver.onComplete
(package private) Action	ForEachWhileObserver.onComplete
(package private) Action	LambdaObserver.onComplete
(package private) Action	DisposableLambdaObserver.onDispose

Methods in io.reactivex.rxjava3.internal.observers with parameters of type Action

Modifier and Type	Method	Description
void	BlockingMultiObserver.blockingConsume(Consumer<? super T> onSuccess, Consumer<? super java.lang.Throwable> onError, Action onComplete)	Blocks until the source completes and calls the appropriate callback.

Constructors in io.reactivex.rxjava3.internal.observers with parameters of type Action

Constructor	Description
AbstractDisposableAutoRelease(DisposableContainer composite, Consumer<? super java.lang.Throwable> onError, Action onComplete)
CallbackCompletableObserver(Consumer<? super java.lang.Throwable> onError, Action onComplete)
DisposableAutoReleaseMultiObserver(DisposableContainer composite, Consumer<? super T> onSuccess, Consumer<? super java.lang.Throwable> onError, Action onComplete)
DisposableAutoReleaseObserver(DisposableContainer composite, Consumer<? super T> onNext, Consumer<? super java.lang.Throwable> onError, Action onComplete)
DisposableLambdaObserver(Observer<? super T> actual, Consumer<? super Disposable> onSubscribe, Action onDispose)
ForEachWhileObserver(Predicate<? super T> onNext, Consumer<? super java.lang.Throwable> onError, Action onComplete)
LambdaObserver(Consumer<? super T> onNext, Consumer<? super java.lang.Throwable> onError, Action onComplete, Consumer<? super Disposable> onSubscribe)

Uses of Action in io.reactivex.rxjava3.internal.operators.completable

Fields in io.reactivex.rxjava3.internal.operators.completable declared as Action

Modifier and Type	Field	Description
(package private) Action	CompletablePeek.onAfterTerminate
(package private) Action	CompletablePeek.onComplete
(package private) Action	CompletablePeek.onDispose
(package private) Action	CompletableDoFinally.DoFinallyObserver.onFinally
(package private) Action	CompletableDoFinally.onFinally
(package private) Action	CompletablePeek.onTerminate
(package private) Action	CompletableFromAction.run

Constructors in io.reactivex.rxjava3.internal.operators.completable with parameters of type Action

Constructor	Description
CompletableDoFinally(CompletableSource source, Action onFinally)
CompletableFromAction(Action run)
CompletablePeek(CompletableSource source, Consumer<? super Disposable> onSubscribe, Consumer<? super java.lang.Throwable> onError, Action onComplete, Action onTerminate, Action onAfterTerminate, Action onDispose)
DoFinallyObserver(CompletableObserver actual, Action onFinally)

Uses of Action in io.reactivex.rxjava3.internal.operators.flowable

Classes in io.reactivex.rxjava3.internal.operators.flowable that implement Action

Modifier and Type	Class	Description
(package private) static class	FlowableInternalHelper.SubscriberOnComplete<T>

Fields in io.reactivex.rxjava3.internal.operators.flowable declared as Action

Modifier and Type	Field	Description
(package private) Action	FlowableFromAction.action
(package private) Action	FlowableDoOnEach.DoOnEachConditionalSubscriber.onAfterTerminate
(package private) Action	FlowableDoOnEach.DoOnEachSubscriber.onAfterTerminate
(package private) Action	FlowableDoOnEach.onAfterTerminate
private Action	FlowableDoOnLifecycle.onCancel
(package private) Action	FlowableDoOnLifecycle.SubscriptionLambdaSubscriber.onCancel
(package private) Action	FlowableDoOnEach.DoOnEachConditionalSubscriber.onComplete
(package private) Action	FlowableDoOnEach.DoOnEachSubscriber.onComplete
(package private) Action	FlowableDoOnEach.onComplete
(package private) Action	FlowableDoFinally.DoFinallyConditionalSubscriber.onFinally
(package private) Action	FlowableDoFinally.DoFinallySubscriber.onFinally
(package private) Action	FlowableDoFinally.onFinally
(package private) Action	FlowableOnBackpressureBuffer.BackpressureBufferSubscriber.onOverflow
(package private) Action	FlowableOnBackpressureBuffer.onOverflow
(package private) Action	FlowableOnBackpressureBufferStrategy.OnBackpressureBufferStrategySubscriber.onOverflow
(package private) Action	FlowableOnBackpressureBufferStrategy.onOverflow

Methods in io.reactivex.rxjava3.internal.operators.flowable that return Action

Modifier and Type	Method	Description
static <T> Action	FlowableInternalHelper.subscriberOnComplete(org.reactivestreams.Subscriber<T> subscriber)

Methods in io.reactivex.rxjava3.internal.operators.flowable with parameters of type Action

Modifier and Type	Method	Description
static <T> void	FlowableBlockingSubscribe.subscribe(org.reactivestreams.Publisher<? extends T> o, Consumer<? super T> onNext, Consumer<? super java.lang.Throwable> onError, Action onComplete)	Subscribes to the source and calls the given actions on the current thread.
static <T> void	FlowableBlockingSubscribe.subscribe(org.reactivestreams.Publisher<? extends T> o, Consumer<? super T> onNext, Consumer<? super java.lang.Throwable> onError, Action onComplete, int bufferSize)	Subscribes to the source and calls the given actions on the current thread.

Constructors in io.reactivex.rxjava3.internal.operators.flowable with parameters of type Action

Constructor	Description
BackpressureBufferSubscriber(org.reactivestreams.Subscriber<? super T> actual, int bufferSize, boolean unbounded, boolean delayError, Action onOverflow, Consumer<? super T> onDropped)
DoFinallyConditionalSubscriber(ConditionalSubscriber<? super T> actual, Action onFinally)
DoFinallySubscriber(org.reactivestreams.Subscriber<? super T> actual, Action onFinally)
DoOnEachConditionalSubscriber(ConditionalSubscriber<? super T> actual, Consumer<? super T> onNext, Consumer<? super java.lang.Throwable> onError, Action onComplete, Action onAfterTerminate)
DoOnEachSubscriber(org.reactivestreams.Subscriber<? super T> actual, Consumer<? super T> onNext, Consumer<? super java.lang.Throwable> onError, Action onComplete, Action onAfterTerminate)
FlowableDoFinally(Flowable<T> source, Action onFinally)
FlowableDoOnEach(Flowable<T> source, Consumer<? super T> onNext, Consumer<? super java.lang.Throwable> onError, Action onComplete, Action onAfterTerminate)
FlowableDoOnLifecycle(Flowable<T> source, Consumer<? super org.reactivestreams.Subscription> onSubscribe, LongConsumer onRequest, Action onCancel)
FlowableFromAction(Action action)
FlowableOnBackpressureBuffer(Flowable<T> source, int bufferSize, boolean unbounded, boolean delayError, Action onOverflow, Consumer<? super T> onDropped)
FlowableOnBackpressureBufferStrategy(Flowable<T> source, long bufferSize, Action onOverflow, BackpressureOverflowStrategy strategy, Consumer<? super T> onDropped)
OnBackpressureBufferStrategySubscriber(org.reactivestreams.Subscriber<? super T> actual, Action onOverflow, BackpressureOverflowStrategy strategy, long bufferSize, Consumer<? super T> onDropped)
SubscriptionLambdaSubscriber(org.reactivestreams.Subscriber<? super T> actual, Consumer<? super org.reactivestreams.Subscription> onSubscribe, LongConsumer onRequest, Action onCancel)

Uses of Action in io.reactivex.rxjava3.internal.operators.maybe

Fields in io.reactivex.rxjava3.internal.operators.maybe declared as Action

Modifier and Type	Field	Description
(package private) Action	MaybeFromAction.action
(package private) Action	MaybePeek.onAfterTerminate
(package private) Action	MaybeCallbackObserver.onComplete
(package private) Action	MaybePeek.onCompleteCall
(package private) Action	MaybeDoOnLifecycle.MaybeLifecycleObserver.onDispose
(package private) Action	MaybeDoOnLifecycle.onDispose
(package private) Action	MaybePeek.onDisposeCall
(package private) Action	MaybeDoFinally.DoFinallyObserver.onFinally
(package private) Action	MaybeDoFinally.onFinally
(package private) Action	MaybeDoOnTerminate.onTerminate

Constructors in io.reactivex.rxjava3.internal.operators.maybe with parameters of type Action

Constructor	Description
DoFinallyObserver(MaybeObserver<? super T> actual, Action onFinally)
MaybeCallbackObserver(Consumer<? super T> onSuccess, Consumer<? super java.lang.Throwable> onError, Action onComplete)
MaybeDoFinally(MaybeSource<T> source, Action onFinally)
MaybeDoOnLifecycle(Maybe<T> upstream, Consumer<? super Disposable> onSubscribe, Action onDispose)
MaybeDoOnTerminate(MaybeSource<T> source, Action onTerminate)
MaybeFromAction(Action action)
MaybeLifecycleObserver(MaybeObserver<? super T> downstream, Consumer<? super Disposable> onSubscribe, Action onDispose)
MaybePeek(MaybeSource<T> source, Consumer<? super Disposable> onSubscribeCall, Consumer<? super T> onSuccessCall, Consumer<? super java.lang.Throwable> onErrorCall, Action onCompleteCall, Action onAfterTerminate, Action onDispose)

Uses of Action in io.reactivex.rxjava3.internal.operators.observable

Classes in io.reactivex.rxjava3.internal.operators.observable that implement Action

Modifier and Type	Class	Description
(package private) static class	ObservableInternalHelper.ObserverOnComplete<T>

Fields in io.reactivex.rxjava3.internal.operators.observable declared as Action

Modifier and Type	Field	Description
(package private) Action	ObservableFromAction.action
(package private) Action	ObservableDoOnEach.DoOnEachObserver.onAfterTerminate
(package private) Action	ObservableDoOnEach.onAfterTerminate
(package private) Action	ObservableDoOnEach.DoOnEachObserver.onComplete
(package private) Action	ObservableDoOnEach.onComplete
private Action	ObservableDoOnLifecycle.onDispose
(package private) Action	ObservableDoFinally.DoFinallyObserver.onFinally
(package private) Action	ObservableDoFinally.onFinally

Methods in io.reactivex.rxjava3.internal.operators.observable that return Action

Modifier and Type	Method	Description
static <T> Action	ObservableInternalHelper.observerOnComplete(Observer<T> observer)

Methods in io.reactivex.rxjava3.internal.operators.observable with parameters of type Action

Modifier and Type	Method	Description
static <T> void	ObservableBlockingSubscribe.subscribe(ObservableSource<? extends T> o, Consumer<? super T> onNext, Consumer<? super java.lang.Throwable> onError, Action onComplete)	Subscribes to the source and calls the given actions on the current thread.

Constructors in io.reactivex.rxjava3.internal.operators.observable with parameters of type Action

Constructor	Description
DoFinallyObserver(Observer<? super T> actual, Action onFinally)
DoOnEachObserver(Observer<? super T> actual, Consumer<? super T> onNext, Consumer<? super java.lang.Throwable> onError, Action onComplete, Action onAfterTerminate)
ObservableDoFinally(ObservableSource<T> source, Action onFinally)
ObservableDoOnEach(ObservableSource<T> source, Consumer<? super T> onNext, Consumer<? super java.lang.Throwable> onError, Action onComplete, Action onAfterTerminate)
ObservableDoOnLifecycle(Observable<T> upstream, Consumer<? super Disposable> onSubscribe, Action onDispose)
ObservableFromAction(Action action)

Uses of Action in io.reactivex.rxjava3.internal.operators.parallel

Fields in io.reactivex.rxjava3.internal.operators.parallel declared as Action

Modifier and Type	Field	Description
(package private) Action	ParallelPeek.onAfterTerminated
(package private) Action	ParallelPeek.onCancel
(package private) Action	ParallelPeek.onComplete

Constructors in io.reactivex.rxjava3.internal.operators.parallel with parameters of type Action

Constructor	Description
ParallelPeek(ParallelFlowable<T> source, Consumer<? super T> onNext, Consumer<? super T> onAfterNext, Consumer<? super java.lang.Throwable> onError, Action onComplete, Action onAfterTerminated, Consumer<? super org.reactivestreams.Subscription> onSubscribe, LongConsumer onRequest, Action onCancel)

Uses of Action in io.reactivex.rxjava3.internal.operators.single

Fields in io.reactivex.rxjava3.internal.operators.single declared as Action

Modifier and Type	Field	Description
(package private) Action	SingleDoAfterTerminate.DoAfterTerminateObserver.onAfterTerminate
(package private) Action	SingleDoAfterTerminate.onAfterTerminate
(package private) Action	SingleDoOnDispose.onDispose
(package private) Action	SingleDoOnLifecycle.onDispose
(package private) Action	SingleDoOnLifecycle.SingleLifecycleObserver.onDispose
(package private) Action	SingleDoFinally.DoFinallyObserver.onFinally
(package private) Action	SingleDoFinally.onFinally
(package private) Action	SingleDoOnTerminate.onTerminate

Constructors in io.reactivex.rxjava3.internal.operators.single with parameters of type Action

Constructor	Description
DoAfterTerminateObserver(SingleObserver<? super T> actual, Action onAfterTerminate)
DoFinallyObserver(SingleObserver<? super T> actual, Action onFinally)
DoOnDisposeObserver(SingleObserver<? super T> actual, Action onDispose)
SingleDoAfterTerminate(SingleSource<T> source, Action onAfterTerminate)
SingleDoFinally(SingleSource<T> source, Action onFinally)
SingleDoOnDispose(SingleSource<T> source, Action onDispose)
SingleDoOnLifecycle(Single<T> upstream, Consumer<? super Disposable> onSubscribe, Action onDispose)
SingleDoOnTerminate(SingleSource<T> source, Action onTerminate)
SingleLifecycleObserver(SingleObserver<? super T> downstream, Consumer<? super Disposable> onSubscribe, Action onDispose)

Uses of Action in io.reactivex.rxjava3.internal.subscribers

Fields in io.reactivex.rxjava3.internal.subscribers declared as Action

Modifier and Type	Field	Description
(package private) Action	BoundedSubscriber.onComplete
(package private) Action	DisposableAutoReleaseSubscriber.onComplete
(package private) Action	ForEachWhileSubscriber.onComplete
(package private) Action	LambdaSubscriber.onComplete

Constructors in io.reactivex.rxjava3.internal.subscribers with parameters of type Action

Constructor	Description
BoundedSubscriber(Consumer<? super T> onNext, Consumer<? super java.lang.Throwable> onError, Action onComplete, Consumer<? super org.reactivestreams.Subscription> onSubscribe, int bufferSize)
DisposableAutoReleaseSubscriber(DisposableContainer composite, Consumer<? super T> onNext, Consumer<? super java.lang.Throwable> onError, Action onComplete)
ForEachWhileSubscriber(Predicate<? super T> onNext, Consumer<? super java.lang.Throwable> onError, Action onComplete)
LambdaSubscriber(Consumer<? super T> onNext, Consumer<? super java.lang.Throwable> onError, Action onComplete, Consumer<? super org.reactivestreams.Subscription> onSubscribe)

Uses of Action in io.reactivex.rxjava3.internal.util

Classes in io.reactivex.rxjava3.internal.util that implement Action

Modifier and Type	Class	Description
class	BlockingIgnoringReceiver	Stores an incoming Throwable (if any) and counts itself down.

Uses of Action in io.reactivex.rxjava3.parallel

Methods in io.reactivex.rxjava3.parallel with parameters of type Action

Modifier and Type	Method	Description
@NonNull ParallelFlowable<T>	ParallelFlowable.doAfterTerminated(@NonNull Action onAfterTerminate)	Run the specified Action when a 'rail' completes or signals an error.
@NonNull ParallelFlowable<T>	ParallelFlowable.doOnCancel(@NonNull Action onCancel)	Run the specified Action when a 'rail' receives a cancellation.
@NonNull ParallelFlowable<T>	ParallelFlowable.doOnComplete(@NonNull Action onComplete)	Run the specified Action when a 'rail' completes.