com.trello.rxlifecycle2.android.ActivityEvent Java Examples

@Override
@CallSuper
protected void onDestroy() {
    mLifecycleSubject.onNext(ActivityEvent.DESTROY);
    NetworkStateReceiver.unRegisterNetworkStateReceiver(this);
    ButterKnife.unbind(this);
    Glide.get(this).clearMemory();
    AppManager.getAppManager().finishActivity(this);
    super.onDestroy();

    if (isFinishing()) {
        if (!AppManager.getAppManager().has()) {
            if (getApplication() instanceof BaseApplication) {
                ((BaseApplication) getApplication()).onDestory();
            }
        }
    }
}
 

@Override
public void onClick(View v) {
    int id = v.getId();
    switch (id) {
        case R.id.simple:
            Observable.interval(1, TimeUnit.SECONDS)
                    .doOnDispose(() -> {
                        Log.e(TAG, "auto disposed");
                    })
                    .compose(bindUntilEvent(ActivityEvent.DESTROY))
                    .subscribe(aLong -> Log.e(TAG, "accept: " + aLong));
            break;

        case R.id.simple_1:
            Observable.interval(1, TimeUnit.SECONDS)
                    .doOnDispose(() -> Log.e(TAG, "auto disposed"))
                    .compose(bindToLifecycle())
                    .subscribe(aLong -> Log.e(TAG, "accept: " + aLong));
            break;
        default:
            break;
    }
}
 

@Override
@NonNull
@CheckResult
public final <T> LifecycleTransformer<T> bindToLifecycle() {
    //return RxLifecycleAndroid.bindActivity(lifecycleSubject);
    return bindUntilEvent(ActivityEvent.DESTROY);
}
 

@Override
protected void onNewIntent(Intent intent)
{
    super.onNewIntent(intent);
    setIntent(intent);
    lifecycle().
            filter(event -> event == ActivityEvent.RESUME).
            firstElement().
            subscribe(res -> startAction(null), err ->
            {
                if(!(err instanceof CancellationException))
                    Logger.log(err);
            });
}
 

public void bind(ViewActivity<T> activity) {
    this.activity = activity;
    disposable = activity.lifecycle()
            .filter(activityEvent -> activityEvent.equals(ActivityEvent.START))
            .flatMap((at) -> dataSubject)
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(activity::render, this::handleError);
}
 

public void bind(ViewActivity<T> activity) {
    this.activity = activity;
    disposable = activity.lifecycle()
            .filter(activityEvent -> activityEvent.equals(ActivityEvent.START))
            .flatMap((at) -> dataSubject)
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(activity::render, this::handleError);
}
 

public void bind(ViewActivity<T> activity) {
    this.activity = activity;
    disposable = activity.lifecycle()
            .filter(activityEvent -> activityEvent.equals(ActivityEvent.START))
            .flatMap((at) -> dataSubject)
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(activity::render, this::handleError);
}
 

public void bind(ViewActivity<T> activity) {
    this.activity = activity;
    disposable = activity.lifecycle()
            .filter(activityEvent -> activityEvent.equals(ActivityEvent.START))
            .flatMap((at) -> dataSubject)
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(activity::render, this::handleError);
}
 

public void bind(ViewActivity<T> activity) {
    this.activity = activity;
    disposable = activity.lifecycle()
            .filter(activityEvent -> activityEvent.equals(ActivityEvent.START))
            .flatMap((at) -> dataSubject)
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(activity::render, this::handleError);
}
 

public void bind(ViewActivity<T> activity) {
    this.activity = activity;
    disposable = activity.lifecycle()
            .filter(activityEvent -> activityEvent.equals(ActivityEvent.START))
            .flatMap((at) -> dataSubject)
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(activity::render, this::handleError);
}
 

public void bind(ViewActivity<T> activity) {
    this.activity = activity;
    disposable = activity.lifecycle()
            .filter(activityEvent -> activityEvent.equals(ActivityEvent.START))
            .flatMap((at) -> dataSubject)
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(activity::render, this::handleError);
}
 

public void bind(ViewActivity<T> activity) {
    this.activity = activity;
    disposable = activity.lifecycle()
            .filter(activityEvent -> activityEvent.equals(ActivityEvent.START))
            .flatMap((at) -> dataSubject)
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(activity::render, this::handleError);
}
 

public void bind(ViewActivity<T> activity) {
    this.activity = activity;
    disposable = activity.lifecycle()
            .filter(activityEvent -> activityEvent.equals(ActivityEvent.START))
            .flatMap((at) -> dataSubject)
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(activity::render, this::handleError);
}
 

public void bind(ViewActivity<T> activity) {
    this.activity = activity;
    disposable = activity.lifecycle()
            .filter(activityEvent -> activityEvent.equals(ActivityEvent.START))
            .flatMap((at) -> dataSubject)
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(activity::render, this::handleError);
}
 

@Override
public void start() {
    view.setupView(user);
    if (AccountManager.getInstance().getMe() == null || AccountManager.getInstance().getMe().equals(user)) {
        view.setFollowButtonVisibility(false);
    } else {
        view.setFollowButtonVisibility(true);
        if (followingChecked) {
            view.setFollowButtonEnabled(true);
            view.setFollowing(following);
        } else {
            repository.isFollowing(user.id())
                    .subscribeOn(Schedulers.io())
                    .observeOn(AndroidSchedulers.mainThread())
                    .compose(((LifecycleProvider<ActivityEvent>) view.getContext())
                            .bindUntilEvent(ActivityEvent.DESTROY))
                    .subscribe(response -> {
                        followingChecked = true;
                        view.setFollowButtonEnabled(true);
                        if (response.code() == 204) {
                            following = true;
                            view.setFollowing(true);
                        } else if (response.code() == 404) {
                            following = false;
                            view.setFollowing(false);
                        }
                    }, throwable -> {
                        view.setFollowButtonEnabled(true);
                        view.setFollowing(false);
                    });
        }
    }
    view.showUser(user);
}
 

public void bind(ViewActivity<T> activity) {
    this.activity = activity;
    disposable = activity.lifecycle()
            .filter(activityEvent -> activityEvent.equals(ActivityEvent.START))
            .flatMap((at) -> dataSubject)
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(activity::render, this::handleError);
}
 

/**
 * 通过桥梁对象 {@code BehaviorSubject<ActivityEvent> mLifecycleSubject}
 * 在每个 Activity 的生命周期中发出对应的生命周期事件
 */
@Override
public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
    if (activity instanceof ActivityLifecycleable) {
        obtainSubject(activity).onNext(ActivityEvent.CREATE);
        if (activity instanceof FragmentActivity){
            if (mFragmentLifecycle == null) {
                mFragmentLifecycle = new FragmentLifecycleForRxLifecycle();
            }
            ((FragmentActivity) activity).getSupportFragmentManager().registerFragmentLifecycleCallbacks(mFragmentLifecycle, true);
        }
    }
}
 

public void bind(ViewActivity<T> activity) {
    this.activity = activity;
    disposable = activity.lifecycle()
            .filter(activityEvent -> activityEvent.equals(ActivityEvent.START))
            .flatMap((at) -> dataSubject)
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(activity::render, this::handleError);
}
 

/**
 * 绑定 Activity 的指定生命周期
 *
 * @param view
 * @param event
 * @param <T>
 * @return
 */
public static <T> LifecycleTransformer<T> bindUntilEvent(@NonNull final IView view,
                                                         final ActivityEvent event) {
    Preconditions.checkNotNull(view, "view == null");
    if (view instanceof ActivityLifecycleable) {
        return bindUntilEvent((ActivityLifecycleable) view, event);
    } else {
        throw new IllegalArgumentException("view isn't ActivityLifecycleable");
    }
}
 

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_memory_leak_with_rx2);
    Observable.interval(1, TimeUnit.SECONDS)
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .compose(this.bindUntilEvent(ActivityEvent.DESTROY))
            .subscribe(aLong -> Log.e(TAG, "accept: "+aLong ));
}
 

@Override
@CallSuper
protected void onPause() {
    InputMethodUtils.hideSoftInput(this);
    mLifecycleSubject.onNext(ActivityEvent.PAUSE);
    super.onPause();

}
 

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    lifecycleSubject.onNext(ActivityEvent.CREATE);
    if (printLifeCycle) {
        Log.d(TAG, "onCreate");
    }
    TAG = this.getClass().getSimpleName();
    IntentFilter filter = new IntentFilter();
    filter.addAction(ACTION_EXIT_APPLICATION);
    mReceiver = new ActivityBaseReceiver();
    registerReceiver(mReceiver, filter);
}
 

@Override
protected void onStart() {
    super.onStart();
    lifecycleSubject.onNext(ActivityEvent.START);
    if (printLifeCycle) {
        Log.d(TAG, "onStart");
    }
}
 

@Override
protected void onResume() {
    super.onResume();
    lifecycleSubject.onNext(ActivityEvent.RESUME);
    if (printLifeCycle) {
        Log.d(TAG, "onResume");
    }
}
 

@Override
protected void onPause() {
    super.onPause();
    lifecycleSubject.onNext(ActivityEvent.PAUSE);
    if (printLifeCycle) {
        Log.d(TAG, "onPause");
    }
}
 

@Override
protected void onStop() {
    super.onStop();
    lifecycleSubject.onNext(ActivityEvent.STOP);
    if (printLifeCycle) {
        Log.d(TAG, "onStop");
    }
}
 

@Override
protected void onDestroy() {
    super.onDestroy();
    lifecycleSubject.onNext(ActivityEvent.DESTROY);
    if (printLifeCycle) {
        Log.d(TAG, "onDestroy");
    }
    unregisterReceiver(mReceiver);
}
 

/**
 * 通过桥梁对象 {@code BehaviorSubject<ActivityEvent> mLifecycleSubject}
 * 在每个 Activity 的生命周期中发出对应的生命周期事件
 */
@Override
public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
    if (activity instanceof ActivityLifecycleable) {
        obtainSubject(activity).onNext(ActivityEvent.CREATE);
        if (activity instanceof FragmentActivity) {
            ((FragmentActivity) activity).getSupportFragmentManager().registerFragmentLifecycleCallbacks(mFragmentLifecycle.get(), true);
        }
    }
}
 

@Override
@CallSuper
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    AppManager.getAppManager().addActivity(this);
    if (android.os.Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
        //新版本的转场动画
        getWindow().requestFeature(Window.FEATURE_CONTENT_TRANSITIONS);
    }
    onBeforeSetContentView();
    setContentView(getContentViewId());
    ButterKnife.bind(this);
    NetworkStateReceiver.registerNetworkStateReceiver(this);
    mLifecycleSubject.onNext(ActivityEvent.CREATE);
}
 

/**
 * 绑定 Activity 的指定生命周期
 *
 * @param view
 * @param event
 * @param <T>
 * @return
 */
public static <T> LifecycleTransformer<T> bindUntilEvent(@NonNull final IView view,
                                                         final ActivityEvent event) {
    Preconditions.checkNotNull(view, "view == null");
    if (view instanceof ActivityLifecycleable) {
        return bindUntilEvent((ActivityLifecycleable) view, event);
    } else {
        throw new IllegalArgumentException("view isn't ActivityLifecycleable");
    }
}