java 在 RxJava/RxAndroid 中为 Activity 生命周期处理订阅的正确方法是什么？
声明：本页面是StackOverFlow热门问题的中英对照翻译，遵循CC BY-SA 4.0协议，如果您需要使用它，必须同样遵循CC BY-SA许可，注明原文地址和作者信息，同时你必须将它归于原作者（不是我）：StackOverFlow
原文地址: http://stackoverflow.com/questions/31795496/
Warning: these are provided under cc-by-sa 4.0 license. You are free to use/share it, But you must attribute it to the original authors (not me):
StackOverFlow
What is the proper way to handle subscriptions in RxJava/RxAndroid for an Activity Lifecycle?
提问by Sree
I am just getting started on RxJava/RxAndroid. I want to avoid context leaks so I created a BaseFragment like so:
我刚刚开始使用 RxJava/RxAndroid。我想避免上下文泄漏，所以我创建了一个 BaseFragment，如下所示：
public abstract class BaseFragment extends Fragment {
protected CompositeSubscription compositeSubscription = new CompositeSubscription();
@Override
public void onDestroy() {
super.onDestroy();
compositeSubscription.unsubscribe();
}
}
And inside my fragment that extends BaseFragment, I am doing this:
在扩展 BaseFragment 的片段中，我正在这样做：
protected void fetchNewerObjects(){
if(!areNewerObjectsFetching()){ //if it is not already fetching newer objects
Runtime.getRuntime().gc();//clean out memory if possible
fetchNewObjectsSubscription = Observable
.just(new Object1())
.map(new Func1<Object1, Object2>() {
@Override
public Object2 call(Object1 obj1) {
//do bg stuff
return obj2;
}
})
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Observer<Object2>() {
@Override
public void onCompleted() {
compositeSubscription.remove(fetchNewObjectsSubscription);
fetchNewObjectsSubscription = null;
}
@Override
public void onError(Throwable e) {
}
@Override
public void onNext(ArrayList<NewsFeedObject> newsFeedObjects) {
//do stuff
}
});
//add subscription to composite subscription so it can be unsubscribed onDestroy()
compositeSubscription.add(fetchNewObjectsSubscription);
}
}
protected boolean areNewerObjectsFetching(){
if(fetchNewObjectsSubscription == null || fetchNewObjectsSubscription.isUnsubscribed()){ //if its either null or is in a finished status
return false;
}
return true;
}
So I guess my question is two-fold:
所以我想我的问题有两个方面：
Will this stop context leaks because I am unsubscribing onDestroy()?
And am I properly keeping track of wether the observable is "running" by setting the subscription to null after completion and checking the nullity?
这会因为我取消订阅 onDestroy() 而停止上下文泄漏吗？
我是否通过在完成后将订阅设置为空并检查空性来正确跟踪可观察对象是否“正在运行”？
采纳答案by marwinXXII
Yes, it will stop, but you should also set subscription to
nullinonErrortoo (or after error, you won't load items again).Also do not forget that fragment can be stopped, but not destroyed (in back stack, for example) and you might not want to observe anything in this case. If you move
unsubscribefromonDestroytoonStopdo not forget to initialisecompositeSubscriptioninonCreateVieweach time view is created (because after CompositeSubscription is unsubscribed you no longer can add subscriptions there).Yes correct. But I think that
compositeSubscription.removecan be omitted, because you already check for null.
是的，它会停止，但你也应该将订阅设置为
nullinonError（或者在错误之后，你不会再次加载项目）。也不要忘记片段可以被停止，但不能被销毁（例如在后堆栈中），在这种情况下你可能不想观察任何东西。如果您
unsubscribe从onDestroy转到onStop不要忘记compositeSubscription在onCreateView每次创建视图时初始化（因为在取消订阅 CompositeSubscription 之后您不能再在那里添加订阅）。是，对的。但我认为
compositeSubscription.remove可以省略，因为您已经检查了 null。
回答by legendmohe
You don't need any third-party lib to manage Activity lifecycle. Try the following codes:
您不需要任何第三方库来管理 Activity 生命周期。尝试以下代码：
public class LifecycleBinder {
public static <R> Observable.Transformer<R, R> subscribeUtilEvent(final Activity target, LifecycleEvent event) {
final Application app = target.getApplication();
final PublishSubject<LifecycleEvent> publishSubject = PublishSubject.create();
final Application.ActivityLifecycleCallbacks callbacks = new Application.ActivityLifecycleCallbacks() {
@Override
public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
}
@Override
public void onActivityStarted(Activity activity) {
}
@Override
public void onActivityResumed(Activity activity) {
}
@Override
public void onActivityPaused(Activity activity) {
if (activity == target)
publishSubject.onNext(LifecycleEvent.ON_PAUSED);
}
@Override
public void onActivityStopped(Activity activity) {
if (activity == target)
publishSubject.onNext(LifecycleEvent.ON_STOPPED);
}
@Override
public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
if (activity == target)
publishSubject.onNext(LifecycleEvent.ON_SAVE_INSTANCE_STATE);
}
@Override
public void onActivityDestroyed(Activity activity) {
if (activity == target)
publishSubject.onNext(LifecycleEvent.ON_DESTROYED);
}
};
app.registerActivityLifecycleCallbacks(callbacks);
return subscribeUtilEvent(publishSubject, event, new Action0() {
@Override
public void call() {
app.unregisterActivityLifecycleCallbacks(callbacks);
}
});
}
public static <R> Observable.Transformer<R, R> subscribeUtilEvent(final Fragment target, LifecycleEvent event) {
final FragmentManager manager = target.getFragmentManager();
if (manager == null) {
throw new NullPointerException("fragment manager is null!");
}
final PublishSubject<LifecycleEvent> publishSubject = PublishSubject.create();
final FragmentManager.FragmentLifecycleCallbacks callbacks = manager.new FragmentLifecycleCallbacks() {
@Override
public void onFragmentPreAttached(FragmentManager fm, Fragment f, Context context) {
}
@Override
public void onFragmentAttached(FragmentManager fm, Fragment f, Context context) {
}
@Override
public void onFragmentCreated(FragmentManager fm, Fragment f, Bundle savedInstanceState) {
}
@Override
public void onFragmentActivityCreated(FragmentManager fm, Fragment f, Bundle savedInstanceState) {
}
@Override
public void onFragmentViewCreated(FragmentManager fm, Fragment f, View v, Bundle savedInstanceState) {
}
@Override
public void onFragmentStarted(FragmentManager fm, Fragment f) {
}
@Override
public void onFragmentResumed(FragmentManager fm, Fragment f) {
}
@Override
public void onFragmentPaused(FragmentManager fm, Fragment f) {
if (f == target)
publishSubject.onNext(LifecycleEvent.ON_PAUSED);
}
@Override
public void onFragmentStopped(FragmentManager fm, Fragment f) {
if (f == target)
publishSubject.onNext(LifecycleEvent.ON_STOPPED);
}
@Override
public void onFragmentSaveInstanceState(FragmentManager fm, Fragment f, Bundle outState) {
if (f == target)
publishSubject.onNext(LifecycleEvent.ON_SAVE_INSTANCE_STATE);
}
@Override
public void onFragmentViewDestroyed(FragmentManager fm, Fragment f) {
if (f == target)
publishSubject.onNext(LifecycleEvent.ON_VIEW_DESTORYED);
}
@Override
public void onFragmentDestroyed(FragmentManager fm, Fragment f) {
if (f == target)
publishSubject.onNext(LifecycleEvent.ON_DESTROYED);
}
@Override
public void onFragmentDetached(FragmentManager fm, Fragment f) {
if (f == target)
publishSubject.onNext(LifecycleEvent.ON_DESTROYED);
}
};
manager.registerFragmentLifecycleCallbacks(callbacks, true);
return subscribeUtilEvent(publishSubject, event, new Action0() {
@Override
public void call() {
manager.unregisterFragmentLifecycleCallbacks(callbacks);
}
});
}
private static <R, T> Observable.Transformer<R, R> subscribeUtilEvent(final Observable<T> source, final T event, final Action0 doOnComplete) {
return new Observable.Transformer<R, R>() {
@Override
public Observable<R> call(Observable<R> rObservable) {
return rObservable.takeUntil(takeUntilEvent(source, event)).doOnCompleted(doOnComplete);
}
};
}
private static <T> Observable<T> takeUntilEvent(final Observable<T> src, final T event) {
return src.takeFirst(new Func1<T, Boolean>() {
@Override
public Boolean call(T lifecycleEvent) {
return lifecycleEvent.equals(event);
}
});
}
}
Lifecycle events:
生命周期事件：
public enum LifecycleEvent {
ON_PAUSED,
ON_STOPPED,
ON_SAVE_INSTANCE_STATE,
ON_DESTROYED,
ON_VIEW_DESTORYED,
ON_DETACHED,
}
Usage:
用法：
myObservable
.compose(LifecycleBinder.subscribeUtilEvent(this, LifecycleEvent.ON_DESTROYED))
.subscribe();
