Uses of Interface
io.reactivex.rxjava3.core.Observer

Packages that use Observer

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.internal.disposables
io.reactivex.rxjava3.internal.jdk8
io.reactivex.rxjava3.internal.observers
io.reactivex.rxjava3.internal.operators.completable
io.reactivex.rxjava3.internal.operators.maybe
io.reactivex.rxjava3.internal.operators.mixed
io.reactivex.rxjava3.internal.operators.observable
io.reactivex.rxjava3.internal.operators.single
io.reactivex.rxjava3.internal.util
io.reactivex.rxjava3.observers	Default wrappers and implementations for observer-based consumer classes and interfaces, including disposable and resource-tracking variants and the TestObserver that allows unit testing Observable-, Single-, Maybe- and Completable-based flows.
io.reactivex.rxjava3.plugins	Contains the central plugin handler RxJavaPlugins class to hook into the lifecycle of the base reactive types and schedulers.
io.reactivex.rxjava3.subjects	Classes representing so-called hot sources, aka subjects, that implement a base reactive class and the respective consumer type at once to allow forms of multicasting events to multiple consumers as well as consuming another base reactive type of their kind.

Uses of Observer in io.reactivex.rxjava3.core

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

Modifier and Type	Method	Description
final <@NonNull E extends Observer<? super @NonNull T>> E	Observable.subscribeWith(@NonNull E observer)	Subscribes a given Observer (subclass) to the current Observable and returns the given Observer instance as is.

Methods in io.reactivex.rxjava3.core that return Observer

Modifier and Type	Method	Description
@NonNull Observer<? super Upstream>	ObservableOperator.apply(@NonNull Observer<? super @NonNull Downstream> observer)	Applies a function to the child Observer and returns a new parent Observer.

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

Modifier and Type	Method	Description
@NonNull Observer<? super Upstream>	ObservableOperator.apply(@NonNull Observer<? super @NonNull Downstream> observer)	Applies a function to the child Observer and returns a new parent Observer.
final void	Observable.blockingSubscribe(@NonNull Observer<? super @NonNull T> observer)	Subscribes to the source and calls the Observer methods on the current thread.
final @NonNull Observable<T>	Observable.doOnEach(@NonNull Observer<? super @NonNull T> observer)	Returns an Observable that forwards the items and terminal events of the current Observable to its Observers and to the given shared Observer instance.
final void	Observable.safeSubscribe(@NonNull Observer<? super @NonNull T> observer)	Subscribes to the current Observable and wraps the given Observer into a SafeObserver (if not already a SafeObserver) that deals with exceptions thrown by a misbehaving Observer (that doesn't follow the Reactive Streams specification).
final void	Observable.subscribe(@NonNull Observer<? super @NonNull T> observer)
void	ObservableSource.subscribe(@NonNull Observer<? super @NonNull T> observer)	Subscribes the given Observer to this ObservableSource instance.
protected abstract void	Observable.subscribeActual(@NonNull Observer<? super @NonNull T> observer)	Operator implementations (both source and intermediate) should implement this method that performs the necessary business logic and handles the incoming Observers.

Uses of Observer in io.reactivex.rxjava3.internal.disposables

Methods in io.reactivex.rxjava3.internal.disposables with parameters of type Observer

Modifier and Type	Method	Description
static void	EmptyDisposable.complete(Observer<?> observer)
static void	EmptyDisposable.error(Throwable e, Observer<?> observer)

Uses of Observer in io.reactivex.rxjava3.internal.jdk8

Classes in io.reactivex.rxjava3.internal.jdk8 that implement Observer

Modifier and Type	Class	Description
final class	ObservableFirstStageObserver<T>	Signals the first element of the source via the underlying CompletableFuture, signals the a default item if the upstream is empty or signals NoSuchElementException.
final class	ObservableLastStageObserver<T>	Signals the last element of the source via the underlying CompletableFuture, signals the a default item if the upstream is empty or signals NoSuchElementException.
final class	ObservableSingleStageObserver<T>	Signals the only element of the source via the underlying CompletableFuture, signals the a default item if the upstream is empty or signals IllegalArgumentException if the upstream has more than one item.

Methods in io.reactivex.rxjava3.internal.jdk8 with parameters of type Observer

Modifier and Type	Method	Description
protected void	MaybeFlattenStreamAsObservable.subscribeActual(@NonNull Observer<? super R> s)
protected void	ObservableCollectWithCollector.subscribeActual(@NonNull Observer<? super R> observer)
protected void	ObservableFlatMapStream.subscribeActual(Observer<? super R> observer)
protected void	ObservableFromCompletionStage.subscribeActual(Observer<? super T> observer)
protected void	ObservableFromStream.subscribeActual(Observer<? super T> observer)
protected void	ObservableMapOptional.subscribeActual(Observer<? super R> observer)
protected void	SingleFlattenStreamAsObservable.subscribeActual(@NonNull Observer<? super R> s)
static <T> void	ObservableFromStream.subscribeStream(Observer<? super T> observer, Stream<T> stream)	Subscribes to the Stream.

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

Classes in io.reactivex.rxjava3.internal.observers that implement Observer

Modifier and Type	Class	Description
class	BasicFuseableObserver<T,R>	Base class for a fuseable intermediate observer.
class	BlockingBaseObserver<T>
final class	BlockingFirstObserver<T>	Blocks until the upstream signals its first value or completes.
final class	BlockingLastObserver<T>	Blocks until the upstream signals its last value or completes.
final class	BlockingObserver<T>
class	DeferredScalarObserver<T,R>	A fuseable Observer that can generate 0 or 1 resulting value.
final class	DisposableAutoReleaseObserver<T>	Wraps lambda callbacks and when the upstream terminates or this observer gets disposed, removes itself from a CompositeDisposable.
final class	DisposableLambdaObserver<T>
final class	ForEachWhileObserver<T>
final class	FutureObserver<T>	An Observer + Future that expects exactly one upstream value and provides it via the (blocking) Future API.
final class	InnerQueuedObserver<T>	Subscriber that can fuse with the upstream and calls a support interface whenever an event is available.
final class	LambdaObserver<T>
class	QueueDrainObserver<T,U,V>	Abstract base class for subscribers that hold another subscriber, a queue and requires queue-drain behavior.

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

Modifier and Type	Field	Description
protected final Observer<? super R>	BasicFuseableObserver.downstream	The downstream subscriber.
protected final Observer<? super T>	DeferredScalarDisposable.downstream	The target of the events.
protected final Observer<? super V>	QueueDrainObserver.downstream

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

Modifier and Type	Method	Description
void	QueueDrainObserver.accept(Observer<? super V> a, U v)

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

Modifier	Constructor	Description
	BasicFuseableObserver(Observer<? super R> downstream)	Construct a BasicFuseableObserver by wrapping the given subscriber.
	DeferredScalarDisposable(Observer<? super T> downstream)	Constructs a DeferredScalarDisposable by wrapping the Observer.
	DeferredScalarObserver(Observer<? super R> downstream)	Creates a DeferredScalarObserver instance and wraps a downstream Observer.
	DisposableLambdaObserver(Observer<? super T> actual, Consumer<? super Disposable> onSubscribe, Action onDispose)
	QueueDrainObserver(Observer<? super V> actual, SimplePlainQueue<U> queue)

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

Methods in io.reactivex.rxjava3.internal.operators.completable with parameters of type Observer

Modifier and Type	Method	Description
protected void	CompletableToObservable.subscribeActual(Observer<? super T> observer)

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

Methods in io.reactivex.rxjava3.internal.operators.maybe with parameters of type Observer

Modifier and Type	Method	Description
static <T> MaybeObserver<T>	MaybeToObservable.create(Observer<? super T> downstream)	Creates a MaybeObserver wrapper around a Observer.
protected void	MaybeFlatMapIterableObservable.subscribeActual(Observer<? super R> observer)
protected void	MaybeToObservable.subscribeActual(Observer<? super T> observer)

Uses of Observer in io.reactivex.rxjava3.internal.operators.mixed

Classes in io.reactivex.rxjava3.internal.operators.mixed that implement Observer

Modifier and Type	Class	Description
class	ConcatMapXMainObserver<T>	Base class for implementing concatMapX main observers.

Methods in io.reactivex.rxjava3.internal.operators.mixed with parameters of type Observer

Modifier and Type	Method	Description
protected void	CompletableAndThenObservable.subscribeActual(Observer<? super R> observer)
protected void	MaybeFlatMapObservable.subscribeActual(Observer<? super R> observer)
protected void	ObservableConcatMapMaybe.subscribeActual(Observer<? super R> observer)
protected void	ObservableConcatMapSingle.subscribeActual(Observer<? super R> observer)
protected void	ObservableSwitchMapMaybe.subscribeActual(Observer<? super R> observer)
protected void	ObservableSwitchMapSingle.subscribeActual(Observer<? super R> observer)
protected void	SingleFlatMapObservable.subscribeActual(Observer<? super R> observer)

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

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

Modifier and Type	Class	Description
final class	ObservableCache<T>	An observable which auto-connects to another observable, caches the elements from that observable but allows terminating the connection and completing the cache.
static final class	ObservableGroupBy.GroupByObserver<T,K,V>
static final class	ObservableOnErrorComplete.OnErrorCompleteObserver<T>
final class	ObserverResourceWrapper<T>

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

Modifier and Type	Method	Description
static <T> Action	ObservableInternalHelper.observerOnComplete(Observer<T> observer)
static <T> Consumer<Throwable>	ObservableInternalHelper.observerOnError(Observer<T> observer)
static <T> Consumer<T>	ObservableInternalHelper.observerOnNext(Observer<T> observer)
static <T> void	ObservableBlockingSubscribe.subscribe(ObservableSource<? extends T> o, Observer<? super T> observer)	Subscribes to the source and calls the Observer methods on the current thread.
protected void	ObservableAll.subscribeActual(Observer<? super Boolean> t)
void	ObservableAmb.subscribeActual(Observer<? super T> observer)
protected void	ObservableAny.subscribeActual(Observer<? super Boolean> t)
void	ObservableAutoConnect.subscribeActual(Observer<? super T> child)
protected void	ObservableBuffer.subscribeActual(Observer<? super U> t)
protected void	ObservableBufferBoundary.subscribeActual(Observer<? super U> t)
protected void	ObservableBufferExactBoundary.subscribeActual(Observer<? super U> t)
protected void	ObservableBufferTimed.subscribeActual(Observer<? super U> t)
protected void	ObservableCache.subscribeActual(Observer<? super T> t)
protected void	ObservableCollect.subscribeActual(Observer<? super U> t)
void	ObservableCombineLatest.subscribeActual(Observer<? super R> observer)
void	ObservableConcatMap.subscribeActual(Observer<? super U> observer)
protected void	ObservableConcatMapEager.subscribeActual(Observer<? super R> observer)
void	ObservableConcatMapScheduler.subscribeActual(Observer<? super U> observer)
protected void	ObservableConcatWithCompletable.subscribeActual(Observer<? super T> observer)
protected void	ObservableConcatWithMaybe.subscribeActual(Observer<? super T> observer)
protected void	ObservableConcatWithSingle.subscribeActual(Observer<? super T> observer)
void	ObservableCount.subscribeActual(Observer<? super Long> t)
protected void	ObservableCreate.subscribeActual(Observer<? super T> observer)
void	ObservableDebounce.subscribeActual(Observer<? super T> t)
void	ObservableDebounceTimed.subscribeActual(Observer<? super T> t)
void	ObservableDefer.subscribeActual(Observer<? super T> observer)
void	ObservableDelay.subscribeActual(Observer<? super T> t)
void	ObservableDelaySubscriptionOther.subscribeActual(Observer<? super T> child)
void	ObservableDematerialize.subscribeActual(Observer<? super R> observer)
protected void	ObservableDetach.subscribeActual(Observer<? super T> observer)
protected void	ObservableDistinct.subscribeActual(Observer<? super T> observer)
protected void	ObservableDistinctUntilChanged.subscribeActual(Observer<? super T> observer)
protected void	ObservableDoAfterNext.subscribeActual(Observer<? super T> observer)
protected void	ObservableDoFinally.subscribeActual(Observer<? super T> observer)
void	ObservableDoOnEach.subscribeActual(Observer<? super T> t)
protected void	ObservableDoOnLifecycle.subscribeActual(Observer<? super T> observer)
void	ObservableElementAt.subscribeActual(Observer<? super T> t)
protected void	ObservableEmpty.subscribeActual(Observer<? super Object> o)
void	ObservableError.subscribeActual(Observer<? super T> observer)
void	ObservableFilter.subscribeActual(Observer<? super T> observer)
void	ObservableFlatMap.subscribeActual(Observer<? super U> t)
protected void	ObservableFlatMapCompletable.subscribeActual(Observer<? super T> observer)
protected void	ObservableFlatMapMaybe.subscribeActual(Observer<? super R> observer)
protected void	ObservableFlatMapSingle.subscribeActual(Observer<? super R> observer)
protected void	ObservableFlattenIterable.subscribeActual(Observer<? super R> observer)
protected void	ObservableFromAction.subscribeActual(Observer<? super T> observer)
void	ObservableFromArray.subscribeActual(Observer<? super T> observer)
void	ObservableFromCallable.subscribeActual(Observer<? super T> observer)
protected void	ObservableFromCompletable.subscribeActual(Observer<? super T> observer)
void	ObservableFromFuture.subscribeActual(Observer<? super T> observer)
void	ObservableFromIterable.subscribeActual(Observer<? super T> observer)
protected void	ObservableFromPublisher.subscribeActual(Observer<? super T> o)
protected void	ObservableFromRunnable.subscribeActual(Observer<? super T> observer)
void	ObservableFromSupplier.subscribeActual(Observer<? super T> observer)
protected void	ObservableFromUnsafeSource.subscribeActual(Observer<? super T> observer)
void	ObservableGenerate.subscribeActual(Observer<? super T> observer)
void	ObservableGroupBy.subscribeActual(Observer<? super GroupedObservable<K,V>> t)
protected void	ObservableGroupJoin.subscribeActual(Observer<? super R> observer)
protected void	ObservableHide.subscribeActual(Observer<? super T> o)
void	ObservableIgnoreElements.subscribeActual(Observer<? super T> t)
void	ObservableInterval.subscribeActual(Observer<? super Long> observer)
void	ObservableIntervalRange.subscribeActual(Observer<? super Long> observer)
protected void	ObservableJoin.subscribeActual(Observer<? super R> observer)
protected void	ObservableJust.subscribeActual(Observer<? super T> observer)
void	ObservableLift.subscribeActual(Observer<? super R> observer)
void	ObservableMap.subscribeActual(Observer<? super U> t)
void	ObservableMapNotification.subscribeActual(Observer<? super ObservableSource<? extends R>> t)
void	ObservableMaterialize.subscribeActual(Observer<? super Notification<T>> t)
protected void	ObservableMergeWithCompletable.subscribeActual(Observer<? super T> observer)
protected void	ObservableMergeWithMaybe.subscribeActual(Observer<? super T> observer)
protected void	ObservableMergeWithSingle.subscribeActual(Observer<? super T> observer)
protected void	ObservableNever.subscribeActual(Observer<? super Object> o)
protected void	ObservableObserveOn.subscribeActual(Observer<? super T> observer)
protected void	ObservableOnErrorComplete.subscribeActual(Observer<? super T> observer)
void	ObservableOnErrorNext.subscribeActual(Observer<? super T> t)
void	ObservableOnErrorReturn.subscribeActual(Observer<? super T> t)
protected void	ObservablePublish.subscribeActual(Observer<? super T> observer)
protected void	ObservablePublishSelector.subscribeActual(Observer<? super R> observer)
protected void	ObservableRange.subscribeActual(Observer<? super Integer> o)
protected void	ObservableRangeLong.subscribeActual(Observer<? super Long> o)
protected void	ObservableRefCount.subscribeActual(Observer<? super T> observer)
void	ObservableRepeat.subscribeActual(Observer<? super T> observer)
void	ObservableRepeatUntil.subscribeActual(Observer<? super T> observer)
protected void	ObservableRepeatWhen.subscribeActual(Observer<? super T> observer)
protected void	ObservableReplay.subscribeActual(Observer<? super T> observer)
void	ObservableRetryBiPredicate.subscribeActual(Observer<? super T> observer)
void	ObservableRetryPredicate.subscribeActual(Observer<? super T> observer)
protected void	ObservableRetryWhen.subscribeActual(Observer<? super T> observer)
void	ObservableSampleTimed.subscribeActual(Observer<? super T> t)
void	ObservableSampleWithObservable.subscribeActual(Observer<? super T> t)
void	ObservableScan.subscribeActual(Observer<? super T> t)
void	ObservableScanSeed.subscribeActual(Observer<? super R> t)
void	ObservableSequenceEqual.subscribeActual(Observer<? super Boolean> observer)
protected void	ObservableSerialized.subscribeActual(Observer<? super T> observer)
void	ObservableSkip.subscribeActual(Observer<? super T> observer)
void	ObservableSkipLast.subscribeActual(Observer<? super T> observer)
void	ObservableSkipLastTimed.subscribeActual(Observer<? super T> t)
void	ObservableSkipUntil.subscribeActual(Observer<? super T> child)
void	ObservableSkipWhile.subscribeActual(Observer<? super T> observer)
void	ObservableSubscribeOn.subscribeActual(Observer<? super T> observer)
void	ObservableSwitchIfEmpty.subscribeActual(Observer<? super T> t)
void	ObservableSwitchMap.subscribeActual(Observer<? super R> t)
protected void	ObservableTake.subscribeActual(Observer<? super T> observer)
void	ObservableTakeLast.subscribeActual(Observer<? super T> t)
void	ObservableTakeLastOne.subscribeActual(Observer<? super T> observer)
void	ObservableTakeLastTimed.subscribeActual(Observer<? super T> t)
void	ObservableTakeUntil.subscribeActual(Observer<? super T> child)
void	ObservableTakeUntilPredicate.subscribeActual(Observer<? super T> observer)
void	ObservableTakeWhile.subscribeActual(Observer<? super T> t)
void	ObservableThrottleFirstTimed.subscribeActual(Observer<? super T> t)
protected void	ObservableThrottleLatest.subscribeActual(Observer<? super T> observer)
void	ObservableTimeInterval.subscribeActual(Observer<? super Timed<T>> t)
protected void	ObservableTimeout.subscribeActual(Observer<? super T> observer)
protected void	ObservableTimeoutTimed.subscribeActual(Observer<? super T> observer)
void	ObservableTimer.subscribeActual(Observer<? super Long> observer)
void	ObservableToList.subscribeActual(Observer<? super U> t)
void	ObservableUnsubscribeOn.subscribeActual(Observer<? super T> t)
void	ObservableUsing.subscribeActual(Observer<? super T> observer)
void	ObservableWindow.subscribeActual(Observer<? super Observable<T>> t)
void	ObservableWindowBoundary.subscribeActual(Observer<? super Observable<T>> observer)
void	ObservableWindowBoundarySelector.subscribeActual(Observer<? super Observable<T>> t)
protected void	ObservableWindowTimed.subscribeActual(Observer<? super Observable<T>> downstream)
void	ObservableWithLatestFrom.subscribeActual(Observer<? super R> t)
protected void	ObservableWithLatestFromMany.subscribeActual(Observer<? super R> observer)
void	ObservableZip.subscribeActual(Observer<? super R> observer)
void	ObservableZipIterable.subscribeActual(Observer<? super V> t)
static <T,R> boolean	ObservableScalarXMap.tryScalarXMapSubscribe(ObservableSource<T> source, Observer<? super R> observer, Function<? super T, ? extends ObservableSource<? extends R>> mapper)	Tries to subscribe to a possibly Supplier source's mapped ObservableSource.

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

Modifier	Constructor	Description
	FromCompletableObserver(Observer<? super T> downstream)
	GroupByObserver(Observer<? super GroupedObservable<K,V>> actual, Function<? super T, ? extends K> keySelector, Function<? super T, ? extends V> valueSelector, int bufferSize, boolean delayError)
	ObserverResourceWrapper(Observer<? super T> downstream)
	OnErrorCompleteObserver(Observer<? super T> actual, Predicate<? super Throwable> predicate)
	ScalarDisposable(Observer<? super T> observer, T value)

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

Methods in io.reactivex.rxjava3.internal.operators.single with parameters of type Observer

Modifier and Type	Method	Description
static <T> SingleObserver<T>	SingleToObservable.create(Observer<? super T> downstream)	Creates a SingleObserver wrapper around a Observer.
protected void	SingleFlatMapIterableObservable.subscribeActual(Observer<? super R> observer)
void	SingleToObservable.subscribeActual(Observer<? super T> observer)

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

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

Modifier and Type	Class	Description
enum	EmptyComponent	Singleton implementing many interfaces as empty.

Methods in io.reactivex.rxjava3.internal.util that return Observer

Modifier and Type	Method	Description
static <T> Observer<T>	EmptyComponent.asObserver()

Methods in io.reactivex.rxjava3.internal.util with parameters of type Observer

Modifier and Type	Method	Description
<U> boolean	AppendOnlyLinkedArrayList.accept(Observer<? super U> observer)	Interprets the contents as NotificationLite objects and calls the appropriate Observer method.
static <T> boolean	NotificationLite.accept(Object o, Observer<? super T> observer)	Calls the appropriate Observer method based on the type of the notification.
void	ObservableQueueDrain.accept(Observer<? super U> a, T v)	Accept the value and return true if forwarded.
static <T> boolean	NotificationLite.acceptFull(Object o, Observer<? super T> observer)	Calls the appropriate Observer method based on the type of the notification.
static <T,U> boolean	QueueDrainHelper.checkTerminated(boolean d, boolean empty, Observer<?> observer, boolean delayError, SimpleQueue<?> q, Disposable disposable, ObservableQueueDrain<T,U> qd)
static <T,U> void	QueueDrainHelper.drainLoop(SimplePlainQueue<T> q, Observer<? super U> a, boolean delayError, Disposable dispose, ObservableQueueDrain<T,U> qd)
static void	HalfSerializer.onComplete(Observer<?> observer, AtomicInteger wip, AtomicThrowable errors)	Emits an onComplete signal or an onError signal with the given error or indicates the concurrently running onNext should do that.
static void	HalfSerializer.onError(Observer<?> observer, Throwable ex, AtomicInteger wip, AtomicThrowable errors)	Emits the given exception if possible or adds it to the given error container to be emitted by a concurrent onNext if one is running.
static <T> void	HalfSerializer.onNext(Observer<? super T> observer, T value, AtomicInteger wip, AtomicThrowable errors)	Emits the given value if possible and terminates if there was an onComplete or onError while emitting, drops the value otherwise.
void	AtomicThrowable.tryTerminateConsumer(Observer<?> consumer)	Tries to terminate this atomic throwable (by swapping in the TERMINATED indicator) and notifies the consumer if there was no error (onComplete) or there was a non-null, non-indicator exception contained before (onError).

Uses of Observer in io.reactivex.rxjava3.observers

Classes in io.reactivex.rxjava3.observers that implement Observer

Modifier and Type	Class	Description
class	DefaultObserver<T>	Abstract base implementation of an Observer with support for cancelling a subscription via DefaultObserver.cancel() (synchronously) and calls DefaultObserver.onStart() when the subscription happens.
class	DisposableObserver<T>	An abstract Observer that allows asynchronous cancellation by implementing Disposable.
class	ResourceObserver<T>	An abstract Observer that allows asynchronous cancellation of its subscription and associated resources.
final class	SafeObserver<T>	Wraps another Observer and ensures all onXXX methods conform the protocol (except the requirement for serialized access).
final class	SerializedObserver<T>	Serializes access to the Observer.onNext(Object), Observer.onError(Throwable) and Observer.onComplete() methods of another Observer.
class	TestObserver<T>	An Observer, MaybeObserver, SingleObserver and CompletableObserver composite that can record events from Observables, Maybes, Singles and Completables and allows making assertions about them.

Methods in io.reactivex.rxjava3.observers with parameters of type Observer

Modifier and Type	Method	Description
static <T> @NonNull TestObserver<T>	TestObserver.create(@NonNull Observer<? super T> delegate)	Constructs a forwarding TestObserver.

Constructors in io.reactivex.rxjava3.observers with parameters of type Observer

Modifier	Constructor	Description
	SafeObserver(@NonNull Observer<? super T> downstream)	Constructs a SafeObserver by wrapping the given actual Observer.
	SerializedObserver(@NonNull Observer<? super T> downstream)	Construct a SerializedObserver by wrapping the given actual Observer.
	SerializedObserver(@NonNull Observer<? super T> actual, boolean delayError)	Construct a SerializedObserver by wrapping the given actual Observer and optionally delaying the errors till all regular values have been emitted from the internal buffer.
	TestObserver(@NonNull Observer<? super T> downstream)	Constructs a forwarding TestObserver.

Uses of Observer in io.reactivex.rxjava3.plugins

Methods in io.reactivex.rxjava3.plugins that return Observer

Modifier and Type	Method	Description
static <@NonNull T> @NonNull Observer<? super T>	RxJavaPlugins.onSubscribe(@NonNull Observable<@NonNull T> source, @NonNull Observer<? super @NonNull T> observer)	Calls the associated hook function.

Methods in io.reactivex.rxjava3.plugins that return types with arguments of type Observer

Modifier and Type	Method	Description
static @Nullable BiFunction<? super Observable, @NonNull ? super Observer, @NonNull ? extends Observer>	RxJavaPlugins.getOnObservableSubscribe()	Returns the current hook function.
static @Nullable BiFunction<? super Observable, @NonNull ? super Observer, @NonNull ? extends Observer>	RxJavaPlugins.getOnObservableSubscribe()	Returns the current hook function.

Methods in io.reactivex.rxjava3.plugins with parameters of type Observer

Modifier and Type	Method	Description
static <@NonNull T> @NonNull Observer<? super T>	RxJavaPlugins.onSubscribe(@NonNull Observable<@NonNull T> source, @NonNull Observer<? super @NonNull T> observer)	Calls the associated hook function.

Method parameters in io.reactivex.rxjava3.plugins with type arguments of type Observer

Modifier and Type	Method	Description
static void	RxJavaPlugins.setOnObservableSubscribe(@Nullable BiFunction<? super Observable, @NonNull ? super Observer, @NonNull ? extends Observer> onObservableSubscribe)	Sets the specific hook function.
static void	RxJavaPlugins.setOnObservableSubscribe(@Nullable BiFunction<? super Observable, @NonNull ? super Observer, @NonNull ? extends Observer> onObservableSubscribe)	Sets the specific hook function.

Uses of Observer in io.reactivex.rxjava3.subjects

Classes in io.reactivex.rxjava3.subjects that implement Observer

Modifier and Type	Class	Description
final class	AsyncSubject<T>	A Subject that emits the very last value followed by a completion event or the received error to Observers.
final class	BehaviorSubject<T>	Subject that emits the most recent item it has observed and all subsequent observed items to each subscribed Observer.
final class	PublishSubject<T>	A Subject that emits (multicasts) items to currently subscribed Observers and terminal events to current or late Observers.
final class	ReplaySubject<T>	Replays events (in a configurable bounded or unbounded manner) to current and late Observers.
class	Subject<T>	Represents an Observer and an Observable at the same time, allowing multicasting events from a single source to multiple child Observers.
final class	UnicastSubject<T>	A Subject that queues up events until a single Observer subscribes to it, replays those events to it until the Observer catches up and then switches to relaying events live to this single Observer until this UnicastSubject terminates or the Observer disposes.

Methods in io.reactivex.rxjava3.subjects with parameters of type Observer

Modifier and Type	Method	Description
protected void	AsyncSubject.subscribeActual(Observer<? super T> observer)
protected void	BehaviorSubject.subscribeActual(Observer<? super T> observer)
protected void	PublishSubject.subscribeActual(Observer<? super T> t)
protected void	ReplaySubject.subscribeActual(Observer<? super T> observer)
protected void	UnicastSubject.subscribeActual(Observer<? super T> observer)