Android RxJava生命周期管理解决方案整理

于 2023-07-11 10:06:32 发布
阅读量960 收藏 1
点赞数 1
文章标签： android rxjava
原文链接：https://blog.youkuaiyun.com/fitaotao/article/details/117522260
版权

一、为什么要做生命周期管理？

Observable.create(new ObservableOnSubscribe<String>() {
    @Override
    public void subscribe(ObservableEmitter<String> emitter) throws Exception {
        //TODO
    }
})
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer<String>() {
    @Override
    public void accept(String str) throws Exception {
        
    }
});

这样就是一个简单的异步处理，但是如果只是这样使用肯定是不行，因为在 Android 开发过程中，如果在进行耗时操作的时候，操作还没有结束，这个时候退出的当前 Activity，这个时候，这段代码的处理并不会因为 Activity 的退出而结束，就会导致内存泄漏等问题，严重的时候甚至会导致 APP 闪退。

二、如何管理生命周期？
1、使用CompositeDisposable 这个类，手动实现对 RxJava 的管理
原理：每次使用 RxJava，都将其生成的 Disposable 对象添加到 CompositeDisposable 对象中，并在每个界面结束(onDestroy)的时候，调用 CompositeDisposable 对象的 clear()方法取消事件。

实现过程：1.实现一个统一管理的基准类

public class CommonComposite {
 
    private CompositeDisposable mCompositeDisposable;
 
    public void addDisposable(Disposable disposable) {
        if (mCompositeDisposable == null || mCompositeDisposable.isDisposed()) {
            mCompositeDisposable = new CompositeDisposable();
        }
        mCompositeDisposable.add(disposable);
    }
 
    public void unDisposable() {
        if (mCompositeDisposable != null) {
            mCompositeDisposable.dispose();
        }
    }
}


2.在每次使用RxJava时，在最后的订阅subscribe之前，统一添加doOnSubscribe()方法，并在里面调用上面的addDisposable()，如下：

RetrofitClient.get()
        .invoke(CommandId.CASH_OUT_APPLY_LIST, params.toString())
        .doOnSubscribe(new Consumer<Disposable>() {
            @Override
            public void accept(Disposable disposable) throws Exception {
                addDisposable(disposable);
            }
        })
        .subscribe(new CommonObserver<CashOutApplyList>() {
            @Override
            public void onSuccess(CashOutApplyList data) {
                mView.updateCashOutApplyList(data.getRows());
            }
 
            @Override
            public void onError(String msg, String code) {
                mView.updateCashOutApplyList(msg);
            }
        });


3.在页面销毁的回调方法中(如onDestroy)中调用unDisposable()进行取消事件订阅

@Override
protected void onDestroy() {
    if( mPresenter!=null){
        mPresenter.unsubscribe();
    }
    super.onDestroy();
}
@Override
public void unsubscribe() {
    unDisposable();
}


2、使用RxLifecycle
Github：https://github.com/trello/RxLifecycle

实现过程：1.添加依赖

implementation 'com.trello.rxlifecycle2:rxlifecycle:2.2.1'
implementation 'com.trello.rxlifecycle2:rxlifecycle-android:2.2.1'
implementation 'com.trello.rxlifecycle2:rxlifecycle-components:2.2.1'
2.继承容器类

Activity/Fragment 需要继承 RxAppCompatActivity/RxFragment，主要支持如下几种容器类：

只需要在项目中针对base类的容器中继承实现对应的Rx类即可，这一步主要是对生命周期的回调事件进行监听。

3.绑定容器生命周期

以Activity为例，主要有如下两种方法(Fragment也有同样的两种方法，只是方法名会有所不同)：

bindUntilEvent(@NonNull ActivityEvent event) 
 
bindToLifecycle()
（1）bindUntilEvent(@NonNull ActivityEvent event)

//该方法指定在哪个生命周期方法调用时取消订阅

其中ActivityEvent是一个枚举类，对应于Activity的生命周期

public enum ActivityEvent {
    CREATE,
    START,
    RESUME,
    PAUSE,
    STOP,
    DESTROY
}
使用如下：指定在生命周期onDestory()时，取消订阅

@SuppressLint("AutoDispose")
    private void test() {
      Observable.interval(1, TimeUnit.SECONDS)
                .doOnDispose(new Action() {
                    @Override
                    public void run() throws Exception {
                        //doOnDispose：当调用 Disposable 的 dispose() 之后回调该方法
                        Log.e(TAG, "=======" + "doOnDispose：" + "=========");
                        Log.e(TAG, "=======" + "doOnDispose，Thread：" + Thread.currentThread().getName() + "=========");
                    }
                })
                .compose(bindUntilEvent(ActivityEvent.DESTROY))//指定在生命周期onDestory()时，取消订阅
                .subscribe(new Observer<Long>() {
 
                    Disposable disposable;
 
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.e(TAG, "=======" + "onSubscribe：" + "=========");
                        disposable = d;
                    }
 
                    @Override
                    public void onNext(Long aLong) {
                        Log.e(TAG, "=======" + "onNext：" + aLong + "=========");
                        Log.e(TAG, "=======" + "onNext，Thread：" + Thread.currentThread().getName() + "=========");
                    }
 
                    @Override
                    public void onError(Throwable e) {
                        Log.e(TAG, "=======" + "onError：" + "=========");
                    }
 
                    @Override
                    public void onComplete() {
                        Log.e(TAG, "=======" + "onComplete：" + "=========");
                    }
                });
    }

运行结果如下：

（2）使用bindToLifecycle()

//在某个生命周期进行绑定，在对应的生命周期进行订阅解除。具体的对应关系如下：

使用如下：在生命周期onStart()时进行绑定(就是test2()方法放在onStart()中)，在onStop()时取消

@SuppressLint("AutoDispose")
    private void test2() {
        Observable.interval(1, TimeUnit.SECONDS)
                .doOnDispose(new Action() {
                    @Override
                    public void run() throws Exception {
                        //doOnDispose：当调用 Disposable 的 dispose() 之后回调该方法
                        Log.e(TAG, "=======" + "doOnDispose：" + "=========");
                        Log.e(TAG, "=======" + "doOnDispose，Thread：" + Thread.currentThread().getName() + "=========");
                    }
                })
                .compose(bindToLifecycle())//在某个生命周期进行绑定，在对应的生命周期进行订阅解除。如在onResume()里调用test2()进行绑定订阅，则在onPause()进行解除订阅，生命周期是两两对应的。
                .subscribe(new Observer<Long>() {
 
                    Disposable disposable;
 
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.e(TAG, "=======" + "onSubscribe：" + "=========");
                        disposable = d;
                    }
 
                    @Override
                    public void onNext(Long aLong) {
                        Log.e(TAG, "=======" + "onNext：" + aLong + "=========");
                        Log.e(TAG, "=======" + "onNext，Thread：" + Thread.currentThread().getName() + "========="); 
                    }
 
                    @Override
                    public void onError(Throwable e) {
                        Log.e(TAG, "=======" + "onError：" + "=========");
                    }
 
                    @Override
                    public void onComplete() {
                        Log.e(TAG, "=======" + "onComplete：" + "=========");
                    }
                });

运行结果如下：

原理分析：

主要就是：compose、BehaviorSubject、LifecycleTransformer、takeUntil、take、skip、combineLatest这几部分；详细参考 RxLifecycle的使用及原理分析

它的设计思路：

1.在Activity中，定义一个Observable（Subject），在不同的生命周期发射不同的事件；

2.通过compose操作符（内部实际上还是依赖takeUntil操作符），定义了上游数据，当其接收到Subject的特定事件时，取消订阅；

3.Subject的特定事件并非是ActivityEvent，而是简单的boolean，它已经内部通过combineLast操作符进行了对应的转化。

实际上，Subject和ActivityEvent对RxLifecycle的使用者来讲，是对应隐藏的。我们只需要调用它提供给我们的API,而内部的实现者我们无需考虑，但是也只有去阅读和理解了它的思想，我们才能更好的选择使用这个库

3、使用RxAutoDispose（分引入LifeCycle和不引入）
Github：https://github.com/uber/AutoDispose

实现过程：1.添加依赖

implementation 'com.uber.autodispose:autodispose:1.3.0'
implementation 'com.uber.autodispose:autodispose-android-archcomponents:1.3.0'
2.在代码中使用（两种使用方式）

//在Activity或Fragment中使用
.as(AutoDispose.autoDisposable(AndroidLifecycleScopeProvider.from(this)))//方式一，自动绑定，在哪里注册，那么就在它的对立时期解除绑定
.as(AutoDispose.autoDisposable(AndroidLifecycleScopeProvider.from(this, Lifecycle.Event.ON_DESTROY)))//方式二：指定解除绑定周期
private void test() {
    Observable.interval(0, 1, TimeUnit.SECONDS)
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .doOnDispose(new Action() {
                @Override
                public void run() throws Exception {
                    //doOnDispose：当调用 Disposable 的 dispose() 之后回调该方法
                    Log.e(TAG, "=======" + "doOnDispose：" + "=========");
                    Log.e(TAG, "=======" + "doOnDispose，Thread：" + Thread.currentThread().getName() + "=========");
                }
            })
            //AutoDispose在被订阅时，获取到Activity当前的生命周期，并找到对应需要结束订阅的生命周期事件
            .as(AutoDispose.autoDisposable(AndroidLifecycleScopeProvider.from(this)))//方式一，自动绑定，在哪里注册，那么就在它的对立时期解除绑定
            .subscribe(new Observer<Long>() {
 
                Disposable disposable;
 
                @Override
                public void onSubscribe(Disposable d) {
                    Log.e(TAG, "=======" + "onSubscribe：" + "=========");
                    disposable = d;
                }
 
                @Override
                public void onNext(Long aLong) {
                    Log.e(TAG, "=======" + "onNext：" + aLong + "=========");
                    Log.e(TAG, "=======" + "onNext，Thread：" + Thread.currentThread().getName() + "=========");
                    textview.setText(String.valueOf(aLong));
                    if (aLong >= 10) {
                        disposable.dispose();
                        Log.e(TAG, "=======" + "dispose" + "=========");//这里会落后于doOnDispose执行
                    }
                }
 
                @Override
                public void onError(Throwable e) {
                    Log.e(TAG, "=======" + "onError：" + "=========");
                }
 
                @Override
                public void onComplete() {
                    Log.e(TAG, "=======" + "onComplete：" + "=========");
                }
            });
}

原理分析：

as(AutoDispose.autoDisposable(AndroidLifecycleScopeProvider.from(this))

（1）参数this：

就是Activity本身，当然它也可以是Fragment，这个参数对象只有一个要求，就是必须实现LifecycleOwner接口。LifecycleOwner接口是Google Android官方架构组件:Lifecycle的一个重要组件，在androidx中，ComponentActivity实现了这个接口，实现了这个接口的对象都拥有生命周期（Lifecycle）。这意味着，只要是实现了LifecycleOwner的类，都可以作为参数传给AutoDispose，用以控制Observable和组件生命周期的绑定。

（2）如何实现生命周期的绑定

参考RxLifecycle的原理：

1.在Activity中，定义一个Observable（Subject），在不同的生命周期发射不同的事件； 2.通过compose操作符（内部实际上还是依赖takeUntil操作符），定义了上游数据，当其接收到Subject的特定事件时，取消订阅； 3.Subject的特定事件并非是ActivityEvent，而是简单的boolean，它已经内部通过combineLast操作符进行了对应的转化

AutoDispose获取了Activity(LifecycleOwner)对象，并定义了一个新的Observable，在Activity的不同生命周期中，发射对应的事件。

和RxLifecycle很类似的是，AutoDispose在被订阅时，获取到Activity当前的生命周期，并找到对应需要结束订阅的生命周期事件：

private static final CorrespondingEventsFunction<Lifecycle.Event> DEFAULT_CORRESPONDING_EVENTS =
    lastEvent -> {
      switch (lastEvent) {
        case ON_CREATE:
          return Lifecycle.Event.ON_DESTROY;
        case ON_START:
          return Lifecycle.Event.ON_STOP;
        case ON_RESUME:
          return Lifecycle.Event.ON_PAUSE;
        case ON_PAUSE:
          return Lifecycle.Event.ON_STOP;
        case ON_STOP:
        case ON_DESTROY:
        default:
          throw new LifecycleEndedException("Lifecycle has ended! Last event was " + lastEvent);
      }
    };

也就是说，在我们的ObservableA订阅时，就已经知道了自己在Activity的哪个生命周期让AutoDispose内部自定义的ObservableB自动发射事件，ObservableA监听到这个事件时且未dispose，解除订阅避免内存泄漏。

毕竟内存泄漏是少数，更大的可能是ObservableA早就执行完任务dispose了，因此ObservableB实际上就是一个Maybe，类似于

ObservableA.takeUntil( Maybe< true > )

核心代码：

public static <E> CompletableSource resolveScopeFromLifecycle(
    Observable<E> lifecycle, final E endEvent, @Nullable final Comparator<E> comparator) {
  Predicate<E> equalityPredicate;
  if (comparator != null) {
    equalityPredicate = e -> comparator.compare(e, endEvent) >= 0;
  } else {
    equalityPredicate = e -> e.equals(endEvent);
  }
  return lifecycle.skip(1).takeUntil(equalityPredicate).ignoreElements();
}


（3）as方法执行后生成了一个什么？

as方法内部生成了一个AutoDisposeConverter对象，类似于compose,不同的是，Observable通过compose生成的对象还是Observable，但as方法生成的则是一个新的对象：

public final <R> R as(@NonNull ObservableConverter<T, ? extends R> converter)
实际上，抛开复杂的细节，AutoDispose最终将原来的Observable，生成了一个新的AutoDisposeObservable对象, 在执行订阅时，也生成了一个新的AutoDisposingObserverImpl对象

（4）AutoDispose和RxLifecycle的区别

原理相似，但是RxLifecycle有如下局限性:

1、需要继承父类（RxActivity / RxFragment等）

2、如何处处绑定生命周期？

简单的例子，我的RecyclerView的Adapter中订阅了Observable，亦或者，在MVP的架构或者 MVVM架构中，我的presenter或者我的viewModel无法直接获取RxActivity的引用(作为View 层，更应该抽象为一个接口与Presenter进行交互)。 这意味着，想要进行Observable的生命周期绑定，在RecyclerView的Adapter中,我必须要通 过将Activity作为依赖，注入到Adapter中： new ListAdapter(RxActivity activity); 而对于Presenter，我需要对View抽象接口进行instanceof 的判断：

if (view instanceof RxActivity) {

        return bindToLifecycle((RxActivity) view);

}

4、如何把AutoDispose添加到目前的Android项目中
 

（以MVP架构为例）

方式一：

（1）封装Util类

static class RxAutoDisposeUtils {
 
    private RxAutoDisposeUtils() {
    }
 
    public static <T> AutoDisposeConverter<T> bindLifecycle(LifecycleOwner lifecycleOwner) {
        return AutoDispose.autoDisposable(AndroidLifecycleScopeProvider.from(lifecycleOwner));
    }
 
    public static <T> AutoDisposeConverter<T> bindLifecycle(LifecycleOwner lifecycleOwner, Lifecycle.Event event) {
        return AutoDispose.autoDisposable(AndroidLifecycleScopeProvider.from(lifecycleOwner, event));
    }
 
    public static <T> AutoDisposeConverter<T> bindDestroyLifecycle(LifecycleOwner lifecycleOwner) {
        return AutoDispose.autoDisposable(AndroidLifecycleScopeProvider.from(lifecycleOwner, Lifecycle.Event.ON_DESTROY));
    }
}

（2）在BaseActivity/BaseFragment中添加代码

只要持有LifecycleOwner对象，Observable都可以通过RxLifecycleUtils.bindLifecycle(LifecycleOwner)进行绑定

fun <T> bindLifecycle(): AutoDisposeConverter<T> {
        return AutoDispose.autoDisposable<T>(AndroidLifecycleScopeProvider.from(lifecycle))
 
//        return AutoDispose.autoDisposable<T>(
//            AndroidLifecycleScopeProvider.from(
//                lifecycleOwner,
//                Lifecycle.Event.ON_DESTROY
//            )
//        )
    }

（3）在任何BaseActivity的实现类中，我们都可以通过下述代码实现Observable的生命周期绑定

Observable.interval(0, 1, TimeUnit.SECONDS)
        .as(bindLifecycle())
        .subscribe()

（4）在Presenter中通过持有Activity的对象，达到Observable生命周期的绑定（类似RxLifecycle的使用）

public interface BaseView {
    <T> LifecycleTransformer<T> getActivityLifecycleProvider();
    LifecycleOwner getLifecycleOwner();
}
public class RxJavaContract {
    interface View extends BaseView {
        void onNetRequest();
    }
    interface Presenter extends BasePresenter {
        void netRequest();
    }
}

//在BaseActivity中实现如下方法

open fun <T> getActivityLifecycleProvider(): LifecycleTransformer<T> {
//        return bindToLifecycle() //可以绑定Activity生命周期
        return bindUntilEvent(ActivityEvent.DESTROY);//可以绑定Activity生命周期
    }
 
    fun getLifecycleOwner(): LifecycleOwner {
        return this
    }
public class RxJavaPresenter implements RxJavaContract.Presenter {
    private RxJavaContract.View mView;
    Observable.interval(1, TimeUnit.SECONDS)
            .compose(mView.getActivityLifecycleProvider())
            .subscribe()
}

方式二：使用Google官方Lifecycle组件

（1）首先让我们的IPresenter接口实现LifecycleObserver接口

//实现了 LifecycleObserver 接口的类可以和实现了 LifecycleOwner 接口的类无缝工作
//，因为 LifecycleOwner 可以提供一个 Lifecycle 对象，而 LifecycleObserver 就正
//需要对这个 Lifecycle 对象进行监听呢。 LifecycleOwner 是从特定的类（比如
// Activity 或者 Fragment 等）中抽象出来的Lifecycle 的持有者

interface IPresenter : LifecycleObserver {
    //使用Google官方Lifecycle组件
    // 使用注解  @OnLifecycleEvent 来表明该方法需要监听指定的生命周期事件
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun onCreate(@NotNull owner: LifecycleOwner)
 
    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun onDestroy(@NotNull owner: LifecycleOwner)
 
    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
    fun onLifecycleChanged(@NotNull owner: LifecycleOwner, @NotNull event: Lifecycle.Event)
}

（2）然后在BasePresenter中管理LifecycleOwner

abstract class BaseNewPresenter :
    IPresenter {

    private lateinit var lifecycleOwner: LifecycleOwner
 
    override fun onCreate(owner: LifecycleOwner) {
        Log.e("LifecycleOwner", "=======" + "onCreate：" + "=========")
        this.lifecycleOwner = owner
    }
 
    override fun onDestroy(owner: LifecycleOwner) {
 
    }
 
    override fun onLifecycleChanged(owner: LifecycleOwner, event: Lifecycle.Event) {
 
    }
 
    fun <T> bindLifecycle(): AutoDisposeConverter<T> {
        return AutoDispose.autoDisposable<T>(AndroidLifecycleScopeProvider.from(lifecycleOwner))
 
//        return AutoDispose.autoDisposable<T>(
//            AndroidLifecycleScopeProvider.from(
//                lifecycleOwner,
//                Lifecycle.Event.ON_DESTROY
//            )
//        )
    }
}

（3）最后在Activity中添加Presenter为观察者，观察Activity的生命周期

abstract class BaseNewMvpActivity<P : IPresenter> : BaseNewActivity(){
    lateinit var presenter: P
 
    override fun onCreate(savedInstanceState: Bundle?) {
        presenter = createPresenter()
        //这一行，如此每当Activity发生了对应的生命周期改变，Presenter就会执行
        //对应事件注解的方法
        lifecycle.addObserver(presenter)
        super.onCreate(savedInstanceState)
    }
}

（4）Presenter中的使用

public class RxAutoDisposePresenter extends BaseNewPresenter implements RxAutoDisposeContract.Presenter {
 
    private RxAutoDisposeContract.View mView;
    private Context mContext;
    private String TAG = RxAutoDisposePresenter.class.getSimpleName();
 
    public RxAutoDisposePresenter(Context context, RxAutoDisposeContract.View view) {
        this.mContext = context;
        this.mView = view;
    }
 
    @Override
    public void netRequest() {
        Observable.interval(0, 1, TimeUnit.SECONDS)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .doOnDispose(new Action() {
                    @Override
                    public void run() throws Exception {
                        //doOnDispose：当调用 Disposable 的 dispose() 之后回调该方法
                        Log.e(TAG, "=======" + "doOnDispose：" + "=========");
                        Log.e(TAG, "=======" + "doOnDispose，Thread：" + Thread.currentThread().getName() + "=========");
                    }
                })
                .as(bindLifecycle())//方式二：指定解除绑定周期
                .subscribe(new BaseObserver<Long>() {
                    @Override
                    public void onSuccess(Long data) {
                        Log.e(TAG, "=======" + "onSuccess：" + data + "=========");
                        mView.onNetRequest(data);
                    }
 
                    @Override
                    public void onError(String msg, String code) {
                        mView.onNetRequest(Long.parseLong(code));
                    }
                });
    }
}

我们即使在Presenter中，也能任意使用myObservable.as(bindLifecycle()) 方法了，和第一种方式相比，更加灵活。

 

原文链接：https://blog.youkuaiyun.com/fitaotao/article/details/117522260

ssuqin001
关注
Android-使用生命周期事件在Android上自动处理RxJava2流
08-13
使用生命周期事件在Android上自动处理RxJava 2流
Android 开发中 RxJava 生命周期简易管理
wangjie_de的博客
09-03 1294
导航Android 开发中 RxJava 生命周期简易管理为什么要做生命周期管理如何管理生命周期简易管理的第一个版本简易管理的第二个版本最后 Android 开发中 RxJava 生命周期简易管理 为什么要做生命周期管理 使用 RxJava 这个库做开发也已经很多年了，从刚开始使用到现在也经历了很多个阶段，中间也遇到了很多问题，今天我们就 RxJava 的生命周期问题好好聊一聊。 RxJ...
Android-RxJava2背压、生命周期
weixin_43506260的博客
03-29 362
Android-RxJava背压原理、生命周期 背压 产生原因 当上下游在不同的线程中，通过Observable发射，处理，响应数据流时，如果上游发射数据的速度快于下游接收处理数据的速度，这样对于那些没来得及处理的数据就会造成积压，这些数据既不会丢失，也不会被垃圾回收机制回收，而是存放在一个异步缓存池中，如果缓存池中的数据一直得不到处理，越积越多，最后就会造成内存溢出，这便是响应式编程中的背压（b...
Android组件生命周期管理
Watson的博客
01-14 1236
每个Android应用启动时，都会先创建一个Application。通常在Application里我们会做一些应用初始化的操作，常见的有第三方SDK初始化。在应用组件化之后，组件与壳工程是隔离开来的，但是组件有时候也需要获取应用的Application，也需要在应用启动时进行初始化。这就涉及到组件的生命周期管理问题。 最简单的实现方式如下： 我们定义一个Application的代理接口IAppL...
RxJava自动生命周期管理autodispose框架的实现
总结来说，RxJava结合Autodispose这样的生命周期管理库，为Android开发者提供了一种安全且高效的管理RxJava生命周期的方式。它不仅减少了资源泄漏的风险，还提升了代码的健壮性和可维护性。通过自动管理订阅和取消...
android-subscription-leaks:小样本应用程序展示了使用RxJava时的内存泄漏解决方案
04-24
1. **生命周期感知**：使用像`RxLifecycle`这样的库可以帮助你将RxJava订阅与Android组件的生命周期绑定。这样，当组件（如Activity或Fragment）销毁时，订阅也会自动取消，防止内存泄漏。 2. **使用...
android-subscription-leaks,使用rxjava时演示内存泄漏解决方案的小示例应用程序.zip
10-14
2. **使用RxLifecycle库**：RxLifecycle是专门为了解决RxJava与Android组件生命周期问题而设计的一个库。通过结合使用RxJava和RxLifecycle，可以自动在Activity或Fragment的生命周期事件中管理订阅的生命周期，防止...
Android-Android生命周期监听工具库
08-13
虽然具体细节无法在当前信息中得知，但通常这类库会提供自定义的解决方案，比如更细粒度的生命周期控制，或者与其他框架（如RxJava）的集成，以便更灵活地处理复杂的场景。 使用生命周期监听工具库的好处包括： 1. ...
Android-RxjavaApi实例代码
08-13
5. **生命周期管理**：在Android应用中，Activity和Fragment有其自身的生命周期，因此需要确保RxJava的订阅与它们同步。可以使用`RxLifecycle`库或者`.takeUntil()`操作符来自动解除订阅，防止内存泄漏。 6. **异常...
RxLifecycle:使用 RxJava 的 Android 应用程序生命周期处理 API-开源
08-10
该库允许基于第二个生命周期流自动完成序列。 此功能在 Android 中很有用，因为不完整的订阅会导致内存泄漏。 你必须从一个 Observable 开始表示生命周期流。 然后使用 RxLifecycle 将序列绑定到该生命周期。 它假设您想在相反的生命周期事件中结束序列——例如，如果在开始时订阅，它将在停止时终止。 如果您在暂停后订阅，它将在下一个销毁事件中终止（例如，pasue 将在停止时终止）。 RxLifecycle 实际上并没有取消订阅序列。 相反，它终止了序列。 它这样做的方式因类型而异。 如果一个序列需要 Subscription.unsubscribe() 行为，那么建议您自己手动处理 Subscription 并在适当的时候调用 unsubscribe()。
Android-rxjava2retrofit2rxlifecycle2有生命周期感知的网络请求框架封装
08-13
rxjava2 retrofit2 rxlifecycle2，有生命周期感知的网络请求框架封装（包含多文件上传及文件下载和下载进度）
rxjava+自动+生命周期+autodispose
03-26
打造RxJava生命周期管理框架autolife autodispose
Android-Disposer使用Android的生命周期轻松部署RxJava流
08-13
Disposer：使用Android的生命周期轻松部署RxJava流
android生命周期管理：启动一个Activity
11-16
android生命周期管理：启动一个Activity
安卓开发系列 之生命周期管理
langxiaolin的博客
02-20 320
安卓的生命周期管理大致分为： 从生到死的生命周期，对应方法为onCreate和onDestroy； 进出停止态，对应方法为onStart和onStop； 进出暂停态，对应方法为onResume和onPause。 现在以秒表APP场景为例，总结下三种状态的适用场景： START开始计时，STOP停止计时，RESET从0计时。 从生到死生命周期为最大的生命周期管理，即一个活动从开始创建到消亡的状态，这时对应一个场景是：如果当安卓屏幕翻转时会依次调用onDestroy和onCreate，这时没有保存翻转前的状态
Android ActivityLifecycle生命周期管理
mj910627的博客
09-23 546
ActivityLifecycle生命周期管理@TOC Android Activity生命周期管理 全局的所有Activity生命周期监听管理类 public class RegisterActivityListener implements Application.ActivityLifecycleCallbacks { private final ActivityManager activityManager; public RegisterActivityListener() {
Rxjava2生命周期绑定
浮生若梦-笑叹人生
03-11 3278
Rxjava2生命周期绑定使用步骤依赖RxLifecycle继承绑定Activity绑定原理bindUntilEvent绑定原理bindToLifecycle绑定原理     我们在使用rxjava请求网络的时候，会出现一种情况，当我们订阅后，activity销毁了，这个时候我们的activity就无法被收回，从而引发造成内存泄漏，对此我们可以使用RxLifecycle来管理activity的生命...
android 生命周期管理,Android Activity生命周期和堆栈管理的详解_Android_脚本之家...
weixin_35710158的博客
05-25 144
Activity的生命周期Activity是Android中的四大组件之一，也是最基本，最重要的组件，是android系统提供一个可视化的，能与用户交换的组件。系统提供的组件，不需要用户实例化，用户也不能实例化，是系统进行回调，例如web开发的servlet也是系统提供的，和android 的其他系统组件一样。那么不需要我们实例化我们怎么用呢，这些组件都有相同的特点就是：1.都需要在配置文件中注册...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值