AutoDispose2之LifecycleEventsObse

  @RestrictTo(LIBRARY_GROUP)
  class LifecycleEventsObservable extends Observable<Event> {

  private final Lifecycle lifecycle;
   private final BehaviorSubject<Event> eventsObservable = BehaviorSubject.create();

  @SuppressWarnings("CheckReturnValue")
  LifecycleEventsObservable(Lifecycle lifecycle) {
this.lifecycle = lifecycle;
  }

  Event getValue() {
return eventsObservable.getValue();

}

  /**
   * Backfill if already created for boundary checking. We do a trick here for     corresponding events
   * where we pretend something is created upon initialized state so that it assumes the
   * corresponding event is DESTROY.
   */
  void backfillEvents() {
@Nullable Lifecycle.Event correspondingEvent;
switch (lifecycle.getCurrentState()) {
  case INITIALIZED:
    correspondingEvent = ON_CREATE;
    break;
  case CREATED:
    correspondingEvent = ON_START;
    break;
  case STARTED:
  case RESUMED:
    correspondingEvent = ON_RESUME;
    break;
  case DESTROYED:
  default:
    correspondingEvent = ON_DESTROY;
    break;
}
eventsObservable.onNext(correspondingEvent);
  }

  @Override
  protected void subscribeActual(Observer<? super Event> observer) {
AutoDisposeLifecycleObserver lifecycleObserver =
    new AutoDisposeLifecycleObserver(lifecycle, observer, eventsObservable);
observer.onSubscribe(lifecycleObserver);
if (!isMainThread()) {
  observer.onError(
      new IllegalStateException("Lifecycles can only be bound to on the main thread!"));
  return;
    }
lifecycle.addObserver(lifecycleObserver);
if (lifecycleObserver.isDisposed()) {
  lifecycle.removeObserver(lifecycleObserver);
    }
  }

  static final class AutoDisposeLifecycleObserver extends MainThreadDisposable
  implements LifecycleObserver {
private final Lifecycle lifecycle;
private final Observer<? super Event> observer;
private final BehaviorSubject<Event> eventsObservable;

AutoDisposeLifecycleObserver(
    Lifecycle lifecycle,
    Observer<? super Event> observer,
    BehaviorSubject<Event> eventsObservable) {
  this.lifecycle = lifecycle;
  this.observer = observer;
  this.eventsObservable = eventsObservable;
}

@Override
protected void onDispose() {
  lifecycle.removeObserver(this);
}

@OnLifecycleEvent(Event.ON_ANY)
void onStateChange(@SuppressWarnings("unused") LifecycleOwner owner, Event event) {
  if (!isDisposed()) {
    if (!(event == ON_CREATE && eventsObservable.getValue() == event)) {
      // Due to the INITIALIZED->ON_CREATE mapping trick we do in backfill(),
      // we fire this conditionally to avoid duplicate CREATE events.
      eventsObservable.onNext(event);
    }
    observer.onNext(event);
  }
    }
  }
}