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
final void	Completable.blockingSubscribe(@NonNull Action onComplete)	Subscribes to the current Completable and calls given onComplete callback on the current thread when it completes normally.
final void	Completable.blockingSubscribe(@NonNull Action onComplete, @NonNull Consumer<? super Throwable> onError)	Subscribes to the current Completable and calls the appropriate callback on the current thread when it terminates.
final void	Flowable.blockingSubscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete)	Subscribes to the source and calls the given callbacks on the current thread.
final void	Flowable.blockingSubscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete, int bufferSize)	Subscribes to the source and calls the given callbacks on the current thread.
final void	Maybe.blockingSubscribe(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete)	Subscribes to the current Maybe and calls the appropriate callback on the current thread when it terminates.
final void	Observable.blockingSubscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete)	Subscribes to the source and calls the given callbacks on the current thread.
final @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.
final @NonNull Flowable<T>	Flowable.doAfterTerminate(@NonNull Action onAfterTerminate)	Registers an Action to be called when this Publisher invokes either onComplete or onError.
final @NonNull Maybe<T>	Maybe.doAfterTerminate(@NonNull Action onAfterTerminate)	Registers an Action to be called when this Maybe invokes either onSuccess, onComplete or onError.
final @NonNull Observable<T>	Observable.doAfterTerminate(@NonNull Action onAfterTerminate)	Registers an Action to be called when the current Observable invokes either onComplete or onError.
final @NonNull Single<T>	Single.doAfterTerminate(@NonNull Action onAfterTerminate)	Registers an Action to be called after this Single invokes either onSuccess or onError.
final @NonNull Completable	Completable.doFinally(@NonNull Action onFinally)	Calls the specified Action after this Completable signals onError or onComplete or gets disposed by the downstream.
final @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.
final @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.
final @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.
final @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.
final @NonNull Flowable<T>	Flowable.doOnCancel(@NonNull Action onCancel)	Calls the cancel Action if the downstream cancels the sequence.
final @NonNull Completable	Completable.doOnComplete(@NonNull Action onComplete)	Returns a Completable which calls the given onComplete Action if this Completable completes.
final @NonNull Flowable<T>	Flowable.doOnComplete(@NonNull Action onComplete)	Invokes an Action just before the current Flowable calls onComplete.
final @NonNull Maybe<T>	Maybe.doOnComplete(@NonNull Action onComplete)	Invokes an Action just before the current Maybe calls onComplete.
final @NonNull Observable<T>	Observable.doOnComplete(@NonNull Action onComplete)	Returns an Observable that invokes an Action when the current Observable calls onComplete.
final @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.
final @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.
final @NonNull Observable<T>	Observable.doOnDispose(@NonNull Action onDispose)	Calls the given shared Action if the downstream disposes the sequence.
final @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 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 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.
final @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 Throwable> onError, Action onComplete, Action onTerminate, Action onAfterTerminate, Action onDispose)	Returns a Completable instance that calls the various callbacks upon the specific lifecycle events.
final @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).
final @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).
final @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).
final @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).
final @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.
final @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.
final @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.
final @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.
final @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.
final @NonNull Disposable	Flowable.forEachWhile(@NonNull Predicate<? super @NonNull T> onNext, @NonNull Consumer<? super 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.
final @NonNull Disposable	Observable.forEachWhile(@NonNull Predicate<? super @NonNull T> onNext, @NonNull Consumer<? super 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.
final @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.
final @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.
final @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.
final @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.
final @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.
final @NonNull Disposable	Completable.subscribe(@NonNull Action onComplete)	Subscribes to this Completable and calls the given Action when this Completable completes normally.
final @NonNull Disposable	Completable.subscribe(@NonNull Action onComplete, @NonNull Consumer<? super Throwable> onError)	Subscribes to this Completable and calls back either the onError or onComplete functions.
final @NonNull Disposable	Completable.subscribe(@NonNull Action onComplete, @NonNull Consumer<? super 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.
final @NonNull Disposable	Flowable.subscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super 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.
final @NonNull Disposable	Flowable.subscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super 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.
final @NonNull Disposable	Maybe.subscribe(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super 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.
final @NonNull Disposable	Maybe.subscribe(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super 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.
final @NonNull Disposable	Observable.subscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super 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.
final @NonNull Disposable	Observable.subscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super 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

Subclasses with type arguments of type Action in io.reactivex.rxjava3.disposables

Modifier and Type	Class	Description
(package private) final class	ActionDisposable	A Disposable container that manages an Action instance.

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

Modifier	Constructor	Description
(package private)	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 final class	Functions.EmptyAction
(package private) static final class	Functions.FutureAction
(package private) static final class	Functions.NotificationOnComplete<T>

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

Modifier and Type	Field	Description
(package private) final Action	Functions.ActionConsumer.action
static final 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 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

Modifier	Constructor	Description
(package private)	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) final Action	AbstractDisposableAutoRelease.onComplete
(package private) final Action	CallbackCompletableObserver.onComplete
(package private) final Action	ForEachWhileObserver.onComplete
(package private) final Action	LambdaObserver.onComplete
(package private) final 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 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

Modifier	Constructor	Description
(package private)	AbstractDisposableAutoRelease(DisposableContainer composite, Consumer<? super Throwable> onError, Action onComplete)
	CallbackCompletableObserver(Consumer<? super Throwable> onError, Action onComplete)
	DisposableAutoReleaseMultiObserver(DisposableContainer composite, Consumer<? super T> onSuccess, Consumer<? super Throwable> onError, Action onComplete)
	DisposableAutoReleaseObserver(DisposableContainer composite, Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete)
	DisposableLambdaObserver(Observer<? super T> actual, Consumer<? super Disposable> onSubscribe, Action onDispose)
	ForEachWhileObserver(Predicate<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete)
	LambdaObserver(Consumer<? super T> onNext, Consumer<? super 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) final Action	CompletablePeek.onAfterTerminate
(package private) final Action	CompletablePeek.onComplete
(package private) final Action	CompletablePeek.onDispose
(package private) final Action	CompletableDoFinally.DoFinallyObserver.onFinally
(package private) final Action	CompletableDoFinally.onFinally
(package private) final Action	CompletablePeek.onTerminate
(package private) final Action	CompletableFromAction.run

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

Modifier	Constructor	Description
	CompletableDoFinally(CompletableSource source, Action onFinally)
	CompletableFromAction(Action run)
	CompletablePeek(CompletableSource source, Consumer<? super Disposable> onSubscribe, Consumer<? super Throwable> onError, Action onComplete, Action onTerminate, Action onAfterTerminate, Action onDispose)
(package private)	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 final class	FlowableInternalHelper.SubscriberOnComplete<T>

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

Modifier and Type	Field	Description
(package private) final Action	FlowableFromAction.action
(package private) final Action	FlowableDoOnEach.DoOnEachConditionalSubscriber.onAfterTerminate
(package private) final Action	FlowableDoOnEach.DoOnEachSubscriber.onAfterTerminate
(package private) final Action	FlowableDoOnEach.onAfterTerminate
private final Action	FlowableDoOnLifecycle.onCancel
(package private) final Action	FlowableDoOnLifecycle.SubscriptionLambdaSubscriber.onCancel
(package private) final Action	FlowableDoOnEach.DoOnEachConditionalSubscriber.onComplete
(package private) final Action	FlowableDoOnEach.DoOnEachSubscriber.onComplete
(package private) final Action	FlowableDoOnEach.onComplete
(package private) final Action	FlowableDoFinally.DoFinallyConditionalSubscriber.onFinally
(package private) final Action	FlowableDoFinally.DoFinallySubscriber.onFinally
(package private) final Action	FlowableDoFinally.onFinally
(package private) final Action	FlowableOnBackpressureBuffer.BackpressureBufferSubscriber.onOverflow
(package private) final Action	FlowableOnBackpressureBuffer.onOverflow
(package private) final Action	FlowableOnBackpressureBufferStrategy.OnBackpressureBufferStrategySubscriber.onOverflow
(package private) final 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 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 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

Modifier	Constructor	Description
(package private)	BackpressureBufferSubscriber(org.reactivestreams.Subscriber<? super T> actual, int bufferSize, boolean unbounded, boolean delayError, Action onOverflow, Consumer<? super T> onDropped)
(package private)	DoFinallyConditionalSubscriber(ConditionalSubscriber<? super T> actual, Action onFinally)
(package private)	DoFinallySubscriber(org.reactivestreams.Subscriber<? super T> actual, Action onFinally)
(package private)	DoOnEachConditionalSubscriber(ConditionalSubscriber<? super T> actual, Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete, Action onAfterTerminate)
(package private)	DoOnEachSubscriber(org.reactivestreams.Subscriber<? super T> actual, Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete, Action onAfterTerminate)
	FlowableDoFinally(Flowable<T> source, Action onFinally)
	FlowableDoOnEach(Flowable<T> source, Consumer<? super T> onNext, Consumer<? super 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)
(package private)	OnBackpressureBufferStrategySubscriber(org.reactivestreams.Subscriber<? super T> actual, Action onOverflow, BackpressureOverflowStrategy strategy, long bufferSize, Consumer<? super T> onDropped)
(package private)	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) final Action	MaybeFromAction.action
(package private) final Action	MaybePeek.onAfterTerminate
(package private) final Action	MaybeCallbackObserver.onComplete
(package private) final Action	MaybePeek.onCompleteCall
(package private) final Action	MaybeDoOnLifecycle.MaybeLifecycleObserver.onDispose
(package private) final Action	MaybeDoOnLifecycle.onDispose
(package private) final Action	MaybePeek.onDisposeCall
(package private) final Action	MaybeDoFinally.DoFinallyObserver.onFinally
(package private) final Action	MaybeDoFinally.onFinally
(package private) final Action	MaybeDoOnTerminate.onTerminate

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

Modifier	Constructor	Description
(package private)	DoFinallyObserver(MaybeObserver<? super T> actual, Action onFinally)
	MaybeCallbackObserver(Consumer<? super T> onSuccess, Consumer<? super 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)
(package private)	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 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 final class	ObservableInternalHelper.ObserverOnComplete<T>

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

Modifier and Type	Field	Description
(package private) final Action	ObservableFromAction.action
(package private) final Action	ObservableDoOnEach.DoOnEachObserver.onAfterTerminate
(package private) final Action	ObservableDoOnEach.onAfterTerminate
(package private) final Action	ObservableDoOnEach.DoOnEachObserver.onComplete
(package private) final Action	ObservableDoOnEach.onComplete
private final Action	ObservableDoOnLifecycle.onDispose
(package private) final Action	ObservableDoFinally.DoFinallyObserver.onFinally
(package private) final 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 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

Modifier	Constructor	Description
(package private)	DoFinallyObserver(Observer<? super T> actual, Action onFinally)
(package private)	DoOnEachObserver(Observer<? super T> actual, Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete, Action onAfterTerminate)
	ObservableDoFinally(ObservableSource<T> source, Action onFinally)
	ObservableDoOnEach(ObservableSource<T> source, Consumer<? super T> onNext, Consumer<? super 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) final Action	ParallelPeek.onAfterTerminated
(package private) final Action	ParallelPeek.onCancel
(package private) final Action	ParallelPeek.onComplete

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

Modifier	Constructor	Description
	ParallelPeek(ParallelFlowable<T> source, Consumer<? super T> onNext, Consumer<? super T> onAfterNext, Consumer<? super 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

Subclasses with type arguments of type Action in io.reactivex.rxjava3.internal.operators.single

Modifier and Type	Class	Description
(package private) static final class	SingleDoOnDispose.DoOnDisposeObserver<T>

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

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

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

Modifier	Constructor	Description
(package private)	DoAfterTerminateObserver(SingleObserver<? super T> actual, Action onAfterTerminate)
(package private)	DoFinallyObserver(SingleObserver<? super T> actual, Action onFinally)
(package private)	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)
(package private)	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) final Action	BoundedSubscriber.onComplete
(package private) final Action	DisposableAutoReleaseSubscriber.onComplete
(package private) final Action	ForEachWhileSubscriber.onComplete
(package private) final Action	LambdaSubscriber.onComplete

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

Modifier	Constructor	Description
	BoundedSubscriber(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete, Consumer<? super org.reactivestreams.Subscription> onSubscribe, int bufferSize)
	DisposableAutoReleaseSubscriber(DisposableContainer composite, Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete)
	ForEachWhileSubscriber(Predicate<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete)
	LambdaSubscriber(Consumer<? super T> onNext, Consumer<? super 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
final 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
final @NonNull ParallelFlowable<T>	ParallelFlowable.doAfterTerminated(@NonNull Action onAfterTerminate)	Run the specified Action when a 'rail' completes or signals an error.
final @NonNull ParallelFlowable<T>	ParallelFlowable.doOnCancel(@NonNull Action onCancel)	Run the specified Action when a 'rail' receives a cancellation.
final @NonNull ParallelFlowable<T>	ParallelFlowable.doOnComplete(@NonNull Action onComplete)	Run the specified Action when a 'rail' completes.