Class DisposableMaybeObserver<T>

java.lang.Object
io.reactivex.rxjava3.observers.DisposableMaybeObserver<T>
Type Parameters:
T - the received value type
All Implemented Interfaces:
MaybeObserver<T>, Disposable

public abstract class DisposableMaybeObserver<T> extends Object implements MaybeObserver<T>, Disposable
An abstract MaybeObserver that allows asynchronous cancellation by implementing Disposable.

All pre-implemented final methods are thread-safe.

Note that MaybeObserver.onSuccess(Object), MaybeObserver.onError(Throwable) and MaybeObserver.onComplete() are exclusive to each other, unlike a regular Observer, and onComplete() is never called after an onSuccess().

Like all other consumers, DisposableMaybeObserver can be subscribed only once. Any subsequent attempt to subscribe it to a new source will yield an IllegalStateException with message "It is not allowed to subscribe with a(n) <class name> multiple times.".

Implementation of onStart(), MaybeObserver.onSuccess(Object), MaybeObserver.onError(Throwable) and MaybeObserver.onComplete() are not allowed to throw any unchecked exceptions.

Example


 Disposable d =
     Maybe.just(1).delay(1, TimeUnit.SECONDS)
     .subscribeWith(new DisposableMaybeObserver<Integer>() {
         @Override public void onStart() {
             System.out.println("Start!");
         }
         @Override public void onSuccess(Integer t) {
             System.out.println(t);
         }
         @Override public void onError(Throwable t) {
             t.printStackTrace();
         }
         @Override public void onComplete() {
             System.out.println("Done!");
         }
     });
 // ...
 d.dispose();
 
  • Field Details

  • Constructor Details

    • DisposableMaybeObserver

      public DisposableMaybeObserver()
  • Method Details

    • onSubscribe

      public final void onSubscribe(@NonNull @NonNull Disposable d)
      Description copied from interface: MaybeObserver
      Provides the MaybeObserver with the means of cancelling (disposing) the connection (channel) with the Maybe in both synchronous (from within onSubscribe(Disposable) itself) and asynchronous manner.
      Specified by:
      onSubscribe in interface MaybeObserver<T>
      Parameters:
      d - the Disposable instance whose Disposable.dispose() can be called anytime to cancel the connection
    • onStart

      protected void onStart()
      Called once the single upstream Disposable is set via onSubscribe(Disposable).
    • isDisposed

      public final boolean isDisposed()
      Description copied from interface: Disposable
      Returns true if this resource has been disposed.
      Specified by:
      isDisposed in interface Disposable
      Returns:
      true if this resource has been disposed
    • dispose

      public final void dispose()
      Description copied from interface: Disposable
      Dispose the resource, the operation should be idempotent.
      Specified by:
      dispose in interface Disposable