import com.trello.rxlifecycle2.android.RxLifecycleAndroid; //导入依赖的package包/类
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_mock);
    ButterKnife.bind(this);

    Observable.interval(1, TimeUnit.SECONDS)
            .doOnDispose(() -> Log.i("APP", "Disposed"))
            .compose(bindToLifecycle())
            .subscribe();

    Observable.interval(1, TimeUnit.SECONDS)
            .compose(RxLifecycleAndroid.bindActivity(lifecycle()))
            .subscribe();

    Observable.interval(1, TimeUnit.SECONDS)
            .compose(RxLifecycleAndroid.bindView(textView))
            .subscribe();
}
 

import com.trello.rxlifecycle2.android.RxLifecycleAndroid; //导入依赖的package包/类
public static <T> LifecycleTransformer<T> bindToLifecycle(@NonNull Lifecycleable lifecycleable) {
    Preconditions.checkNotNull(lifecycleable, "lifecycleable == null");
    if (lifecycleable instanceof ActivityLifecycleable) {
        return RxLifecycleAndroid.bindActivity(((ActivityLifecycleable) lifecycleable).provideLifecycleSubject());
    } else if (lifecycleable instanceof FragmentLifecycleable) {
        return RxLifecycleAndroid.bindFragment(((FragmentLifecycleable) lifecycleable).provideLifecycleSubject());
    } else {
        throw new IllegalArgumentException("Lifecycleable not match");
    }
}
 

import com.trello.rxlifecycle2.android.RxLifecycleAndroid; //导入依赖的package包/类
@Test
public void testBindActivityLifecycle() {
    BehaviorSubject<ActivityEvent> lifecycle = BehaviorSubject.create();

    lifecycle.onNext(ActivityEvent.CREATE);
    TestObserver<Object> createObserver = observable.compose(RxLifecycleAndroid.bindActivity(lifecycle)).test();

    lifecycle.onNext(ActivityEvent.START);
    createObserver.assertNotComplete();
    TestObserver<Object> startObserver = observable.compose(RxLifecycleAndroid.bindActivity(lifecycle)).test();

    lifecycle.onNext(ActivityEvent.RESUME);
    createObserver.assertNotComplete();
    startObserver.assertNotComplete();
    TestObserver<Object> resumeObserver = observable.compose(RxLifecycleAndroid.bindActivity(lifecycle)).test();

    lifecycle.onNext(ActivityEvent.PAUSE);
    createObserver.assertNotComplete();
    startObserver.assertNotComplete();
    resumeObserver.assertComplete();

    TestObserver<Object> pauseObserver = observable.compose(RxLifecycleAndroid.bindActivity(lifecycle)).test();
    lifecycle.onNext(ActivityEvent.STOP);
    createObserver.assertNotComplete();
    startObserver.assertComplete();
    pauseObserver.assertComplete();
    TestObserver<Object> stopObserver = observable.compose(RxLifecycleAndroid.bindActivity(lifecycle)).test();

    lifecycle.onNext(ActivityEvent.DESTROY);
    createObserver.assertComplete();
    stopObserver.assertComplete();
}
 

import com.trello.rxlifecycle2.android.RxLifecycleAndroid; //导入依赖的package包/类
@Test
public void testEndsImmediatelyOutsideActivityLifecycle() {
    BehaviorSubject<ActivityEvent> lifecycle = BehaviorSubject.create();
    lifecycle.onNext(ActivityEvent.DESTROY);

    TestObserver<Object> testObserver = observable.compose(RxLifecycleAndroid.bindActivity(lifecycle)).test();
    testObserver.assertComplete();
}
 

import com.trello.rxlifecycle2.android.RxLifecycleAndroid; //导入依赖的package包/类
@Test
public void testEndsImmediatelyOutsideFragmentLifecycle() {
    BehaviorSubject<FragmentEvent> lifecycle = BehaviorSubject.create();
    lifecycle.onNext(FragmentEvent.DETACH);

    TestObserver<Object> testObserver = observable.compose(RxLifecycleAndroid.bindFragment(lifecycle)).test();
    testObserver.assertComplete();
}
 

import com.trello.rxlifecycle2.android.RxLifecycleAndroid; //导入依赖的package包/类
@Override protected void onCreate(@Nullable Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);

  //Get the value ResLayout from the annotation if provided.
  LayoutResActivity layoutRes = this.getClass()
      .getAnnotation(LayoutResActivity.class);
  if (layoutRes != null) setContentView(layoutRes.value());

  //Inject the views with butter-knife.
  unbinder = ButterKnife.bind(this);

  //Try to get the Holder data if the Activity has been destroyed due to config changes in order to prevent
  // injecting the dependency graph again.
  if (getLastCustomNonConfigurationInstance() == null) {
    injectDagger();
  } else {
    presenter = (P) getLastCustomNonConfigurationInstance();
  }

  //Bind the lifecycle of this Activity provided by RxLifecycle to the associated presenter.
  presenter.bindLifeCycle(
      RxLifecycleAndroid.bindActivity(lifecycle()));

  //At this point is safe calling initViews to let the sub-class to configure its views.
  initViews();

  //At this point is safe calling onBindView from the presenter to provide the data required by the view.
  presenter.onBindView(this);
}
 

import com.trello.rxlifecycle2.android.RxLifecycleAndroid; //导入依赖的package包/类
@Override public void onActivityCreated(@Nullable Bundle savedInstanceState) {
  super.onActivityCreated(savedInstanceState);

  //Bind the lifecycle of this Fragment provided by RxLifecycle to the associated presenter.
  presenter.bindLifeCycle(
      RxLifecycleAndroid.bindFragment(lifecycle()));

  //At this point is safe calling initViews to let the sub-class to configure its views.
  initViews();

  //At this point is safe calling onBindView from the presenter to provide the data required by the view.
  presenter.onBindView(this);
}
 

import com.trello.rxlifecycle2.android.RxLifecycleAndroid; //导入依赖的package包/类
@Override
@NonNull
@CheckResult
public final <T> LifecycleTransformer<T> bindToLifecycle() {
    return RxLifecycleAndroid.bindActivity(lifecycleSubject);
}
 

import com.trello.rxlifecycle2.android.RxLifecycleAndroid; //导入依赖的package包/类
@Override
@NonNull
@CheckResult
public <T> LifecycleTransformer<T> bindToLifecycle() {
    return RxLifecycleAndroid.bindActivity(lifecycleSubject);
}
 

import com.trello.rxlifecycle2.android.RxLifecycleAndroid; //导入依赖的package包/类
@Override
@NonNull
@CheckResult
public <T> LifecycleTransformer<T> bindToLifecycle() {
    return RxLifecycleAndroid.bindFragment(lifecycleSubject);
}
 

import com.trello.rxlifecycle2.android.RxLifecycleAndroid; //导入依赖的package包/类
@Override
@NonNull
@CheckResult
public final <T> LifecycleTransformer<T> bindToLifecycle() {
    return RxLifecycleAndroid.bindFragment(lifecycleSubject);
}
 

import com.trello.rxlifecycle2.android.RxLifecycleAndroid; //导入依赖的package包/类
@Test
public void testBindFragmentLifecycle() {
    BehaviorSubject<FragmentEvent> lifecycle = BehaviorSubject.create();

    lifecycle.onNext(FragmentEvent.ATTACH);
    TestObserver<Object> attachObserver = observable.compose(RxLifecycleAndroid.bindFragment(lifecycle)).test();

    lifecycle.onNext(FragmentEvent.CREATE);
    attachObserver.assertNotComplete();
    TestObserver<Object> createObserver = observable.compose(RxLifecycleAndroid.bindFragment(lifecycle)).test();

    lifecycle.onNext(FragmentEvent.CREATE_VIEW);
    attachObserver.assertNotComplete();
    createObserver.assertNotComplete();
    TestObserver<Object> createViewObserver = observable.compose(RxLifecycleAndroid.bindFragment(lifecycle)).test();

    lifecycle.onNext(FragmentEvent.START);
    attachObserver.assertNotComplete();
    createObserver.assertNotComplete();
    createViewObserver.assertNotComplete();
    TestObserver<Object> startObserver = observable.compose(RxLifecycleAndroid.bindFragment(lifecycle)).test();

    lifecycle.onNext(FragmentEvent.RESUME);
    attachObserver.assertNotComplete();
    createObserver.assertNotComplete();
    createViewObserver.assertNotComplete();
    startObserver.assertNotComplete();
    TestObserver<Object> resumeObserver = observable.compose(RxLifecycleAndroid.bindFragment(lifecycle)).test();

    lifecycle.onNext(FragmentEvent.PAUSE);
    attachObserver.assertNotComplete();
    createObserver.assertNotComplete();
    createViewObserver.assertNotComplete();
    startObserver.assertNotComplete();
    resumeObserver.assertComplete();
    TestObserver<Object> pauseObserver = observable.compose(RxLifecycleAndroid.bindFragment(lifecycle)).test();

    lifecycle.onNext(FragmentEvent.STOP);
    attachObserver.assertNotComplete();
    createObserver.assertNotComplete();
    createViewObserver.assertNotComplete();
    startObserver.assertComplete();
    pauseObserver.assertComplete();
    TestObserver<Object> stopObserver = observable.compose(RxLifecycleAndroid.bindFragment(lifecycle)).test();

    lifecycle.onNext(FragmentEvent.DESTROY_VIEW);
    attachObserver.assertNotComplete();
    createObserver.assertNotComplete();
    createViewObserver.assertComplete();
    stopObserver.assertComplete();
    TestObserver<Object> destroyViewObserver = observable.compose(RxLifecycleAndroid.bindFragment(lifecycle))
        .test();

    lifecycle.onNext(FragmentEvent.DESTROY);
    attachObserver.assertNotComplete();
    createObserver.assertComplete();
    destroyViewObserver.assertComplete();
    TestObserver<Object> destroyObserver = observable.compose(RxLifecycleAndroid.bindFragment(lifecycle)).test();

    lifecycle.onNext(FragmentEvent.DETACH);
    attachObserver.assertComplete();
    destroyObserver.assertComplete();
}
 

import com.trello.rxlifecycle2.android.RxLifecycleAndroid; //导入依赖的package包/类
@Test(expected = NullPointerException.class)
public void testBindFragmentThrowsOnNull() {
    //noinspection ResourceType
    RxLifecycleAndroid.bindFragment(null);
}
 

import com.trello.rxlifecycle2.android.RxLifecycleAndroid; //导入依赖的package包/类
@Test(expected = NullPointerException.class)
public void testBindActivityThrowsOnNull() {
    //noinspection ResourceType
    RxLifecycleAndroid.bindActivity(null);
}
 

import com.trello.rxlifecycle2.android.RxLifecycleAndroid; //导入依赖的package包/类
@Test(expected = NullPointerException.class)
public void testBindViewThrowsOnNullView() {
    //noinspection ResourceType
    RxLifecycleAndroid.bindView((View) null);
}
 

import com.trello.rxlifecycle2.android.RxLifecycleAndroid; //导入依赖的package包/类
@Override
@NonNull
@CheckResult
public final <T> LifecycleTransformer<T> bindToLifecycle() {
    return RxLifecycleAndroid.bindFragment(mLifecycleSubject);
}
 

import com.trello.rxlifecycle2.android.RxLifecycleAndroid; //导入依赖的package包/类
@Override
@NonNull
@CheckResult
public final <T> LifecycleTransformer<T> bindToLifecycle() {
    return RxLifecycleAndroid.bindActivity(mLifecycleSubject);
}
 

import com.trello.rxlifecycle2.android.RxLifecycleAndroid; //导入依赖的package包/类
@NonNull
@CheckResult
public final <T> LifecycleTransformer<T> bindToLifecycle() {
    return RxLifecycleAndroid.bindFragment(mLifecycleSubject);
}