Add support for exposing delegate observers.

autodispose/src/main/java/com/uber/autodispose/AutoDisposingObserverImpl.java

@@ -37,6 +37,10 @@ final class AutoDisposingObserverImpl<T> implements AutoDisposingObserver<T> {
     this.delegate = delegate;
   }
 
+  @Override public Observer<? super T> delegateObserver() {
+    return delegate;
+  }
+
   @Override public void onSubscribe(final Disposable d) {
     if (AutoDisposeEndConsumerHelper.setOnce(lifecycleDisposable,
         lifecycle.doOnEvent(new BiConsumer<Object, Throwable>() {

autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingObserver.java

@@ -23,4 +23,10 @@
  * A {@link Disposable} {@link Observer} that can automatically dispose itself.
  * Interface here for type safety but enforcement is left to the implementation.
  */
-public interface AutoDisposingObserver<T> extends Observer<T>, Disposable {}
+public interface AutoDisposingObserver<T> extends Observer<T>, Disposable {
+
+    /**
+     * @return {@link Observer} The delegate Observer that is used under the hood for introspection purposes.
+     */
+    Observer<? super T> delegateObserver();
+}

autodispose/src/test/java/com/uber/autodispose/AutoDisposeObserverTest.java

@@ -17,26 +17,34 @@
 package com.uber.autodispose;
 
 import com.uber.autodispose.test.RecordingObserver;
+import com.uber.autodispose.observers.AutoDisposingObserver;
 import io.reactivex.Maybe;
 import io.reactivex.Observable;
 import io.reactivex.ObservableEmitter;
 import io.reactivex.ObservableOnSubscribe;
+import io.reactivex.Observer;
 import io.reactivex.disposables.Disposable;
+import io.reactivex.functions.BiFunction;
 import io.reactivex.functions.Cancellable;
 import io.reactivex.functions.Consumer;
 import io.reactivex.functions.Predicate;
 import io.reactivex.observers.TestObserver;
+import io.reactivex.plugins.RxJavaPlugins;
 import io.reactivex.subjects.BehaviorSubject;
 import io.reactivex.subjects.MaybeSubject;
 import io.reactivex.subjects.PublishSubject;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
 import org.junit.After;
 import org.junit.Test;
 
 import static com.google.common.truth.Truth.assertThat;
 
 public class AutoDisposeObserverTest {
 
+  private final AtomicReference<Observer> atomicObserver = new AtomicReference();
+  private final AtomicReference<Observer> atomicAutoDisposingObserver = new AtomicReference<>();
+
   private static final RecordingObserver.Logger LOGGER = new RecordingObserver.Logger() {
     @Override public void log(String message) {
       System.out.println(AutoDisposeObserverTest.class.getSimpleName() + ": " + message);
@@ -154,7 +162,7 @@ public class AutoDisposeObserverTest {
     lifecycle.onNext(1);
     source.onNext(2);
 
-    assertThat(source.hasObservers()).isTrue();
+    assertThat(source.hasObservers()).isTrue();Å
     assertThat(lifecycle.hasObservers()).isTrue();
     assertThat(o.takeNext()).isEqualTo(2);
 
@@ -256,6 +264,31 @@ public class AutoDisposeObserverTest {
     });
   }
 
+  @Test public void verifyObserverDelegate() {
+    try {
+      RxJavaPlugins.setOnObservableSubscribe(new BiFunction<Observable, Observer, Observer>() {
+        @Override public Observer apply(Observable source, Observer observer) {
+          if (atomicObserver.get() == null) {
+            atomicObserver.set(observer);
+          } else if (atomicAutoDisposingObserver.get() == null) {
+            atomicAutoDisposingObserver.set(observer);
+            RxJavaPlugins.setOnObservableSubscribe(null);
+          }
+          return observer;
+        }
+      });
+      Observable.just(1).to(new ObservableScoper<Integer>(Maybe.never())).subscribe();
+
+      assertThat(atomicAutoDisposingObserver.get()).isNotNull();
+      assertThat(atomicAutoDisposingObserver.get()).isInstanceOf(AutoDisposingObserver.class);
+      assertThat(((AutoDisposingObserver)atomicAutoDisposingObserver.get()).delegateObserver()).isNotNull();
+      assertThat(((AutoDisposingObserver)atomicAutoDisposingObserver.get()).delegateObserver())
+              .isEqualTo(atomicObserver.get());
+    } finally {
+      RxJavaPlugins.reset();
+    }
+  }
+
   @Test public void verifyCancellation() throws Exception {
     final AtomicInteger i = new AtomicInteger();
     //noinspection unchecked because Java