RxJava2 实战知识梳理(10) 屏幕旋转致使 Activity 重建时恢复任务

时间 2019-11-21

标签 rxjava2 rxjava 实战知识梳理屏幕旋转致使 activity 重建恢复任务栏目 Java 繁體版

原文原文链接

1、前言

若是咱们在AndroidManifest.xml中声明Activity时，没有对android:configChanges进行特殊的声明，那么在屏幕旋转时，会致使Activity的重建，几个关键声明周期的调用状况以下所示： html

旋转屏幕前的 Activity中的变量都会被销毁，可是有时候咱们某些任务的执行不和 Activity的生命周期绑定，这时候咱们就能够利用 Fragment提供的 setRetainInstance方法，该方法的说明以下：

若是给 Fragment设置了该标志位，那么在屏幕旋转以后，虽然它依附的 Activity被销毁了，可是该 Fragment的实例会被保留，而且在 Activity的销毁过程当中，只会调用该 Fragment的 onDetach方法，而不会调用 onDestroy方法。

而在Activity重建时，会调用该Fragment实例的onAttach、onActivityCreated方法，但不会调用onCreate方法。java

根据Fragment提供的这一特性，那么咱们就能够将一些在屏幕旋转过程当中，仍然须要运行的任务放在具备该属性的Fragment中执行。在 Handling Configuration Changes with Fragments 这篇文章中，做者介绍了经过这个技巧来实现了一个不被中断的AsyncTask，你们有须要了解详细说明的能够查看这篇文章。android

今天，咱们跟着前人脚步，用RxJava来演示在屏幕旋转致使Activity重建时，仍然保持后台任务继续执行的例子。架构

2、示例

2.1 示例

首先，咱们声明一个接口，用于Fragment向Activity一个ConnectableObservable，使得Activity能够监听到Fragment中后台任务的工做进度。ide

public interface IHolder {
    public void onWorkerPrepared(ConnectableObservable<Long> workerFlow);
}
复制代码

下面，咱们来实现WorkerFragment，咱们在onCreate中建立了数据源，它每隔1s向下游发送数据，在onResume中，经过前面定义的接口向Activity传递一个ConnectableObservable用于监听。这里最关键的是须要调用咱们前面说到的setRetainInstance方法，最后别忘了，在onDetach中将mHolder置为空，不然它就会持有须要被重建的Activity示例，从而致使内存泄漏。学习

public class WorkerFragment extends Fragment {

    public static final String TAG = WorkerFragment.class.getName();

    private ConnectableObservable<String> mWorker;
    private Disposable mDisposable;
    private IHolder mHolder;

    @Override
    public void onAttach(Context context) {
        super.onAttach(context);
        if (context instanceof IHolder) {
            mHolder = (IHolder) context;
        }
    }

    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setRetainInstance(true);
        if (mWorker != null) {
            return;
        }
        Bundle bundle = getArguments();
        final String taskName = (bundle != null ? bundle.getString("task_name") : null);
        mWorker = Observable.create(new ObservableOnSubscribe<String>() {

            @Override
            public void subscribe(ObservableEmitter<String> observableEmitter) throws Exception {

                for (int i = 0; i < 10; i++) {
                    String message = "任务名称=" + taskName + ", 任务进度=" + i * 10 + "%";
                    try {
                        Log.d(TAG, message);
                        Thread.sleep(1000);
                        //若是已经抛弃，那么再也不继续任务。
                        if (observableEmitter.isDisposed()) {
                            break;
                        }
                    } catch (InterruptedException error) {
                        if (!observableEmitter.isDisposed()) {
                            observableEmitter.onError(error);
                        }
                    }
                    observableEmitter.onNext(message);
                }
                observableEmitter.onComplete();
            }

        }).subscribeOn(Schedulers.io()).publish();
        mDisposable = mWorker.connect();
    }

    @Override
    public void onResume() {
        super.onResume();
        if (mHolder != null) {
            mHolder.onWorkerPrepared(mWorker);
        }
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        mDisposable.dispose();
        Log.d(TAG, "onDestroy");
    }

    @Override
    public void onDetach() {
        super.onDetach();
        mHolder = null;
    }
}
复制代码

最后来看Activity，当点击“开始工做任务”后，咱们尝试添加WorkerFragment，这时候就会走到WorkerFragment的onCreate方法中启动任务，以后当WorkerFragment走到onResume方法后，就调用onWorkerPrepared，让Activity进行订阅，Activity就能够收到当前任务进度的通知，来更新UI。而在任务执行完毕以后，咱们就能够将该Fragment移除了。spa

public class RotationPersistActivity extends AppCompatActivity implements IHolder {

    private static final String TAG = RotationPersistActivity.class.getName();

    private Button mBtWorker;
    private TextView mTvResult;
    private CompositeDisposable mCompositeDisposable;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.d(TAG, "onCreate");
        setContentView(R.layout.activity_rotation_persist);
        mBtWorker = (Button) findViewById(R.id.bt_start_worker);
        mBtWorker.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View v) {
                startWorker();
            }

        });
        mTvResult = (TextView) findViewById(R.id.tv_worker_result);
        mCompositeDisposable = new CompositeDisposable();
    }

    @Override
    public void onWorkerPrepared(Observable<String> worker) {
        DisposableObserver<String> disposableObserver = new DisposableObserver<String>() {

            @Override
            public void onNext(String message) {
                mTvResult.setText(message);
            }

            @Override
            public void onError(Throwable throwable) {
                onWorkerFinished();
                mTvResult.setText("任务错误");
            }

            @Override
            public void onComplete() {
                onWorkerFinished();
                mTvResult.setText("任务完成");
            }

        };
        worker.observeOn(AndroidSchedulers.mainThread()).subscribe(disposableObserver);
        mCompositeDisposable.add(disposableObserver);
    }

    private void startWorker() {
        WorkerFragment worker = getWorkerFragment();
        if (worker == null) {
            addWorkerFragment();
        } else {
            Log.d(TAG, "WorkerFragment has attach");
        }
    }

    private void onWorkerFinished() {
        Log.d(TAG, "onWorkerFinished");
        removeWorkerFragment();
    }

    private void addWorkerFragment() {
        WorkerFragment workerFragment = new WorkerFragment();
        Bundle bundle = new Bundle();
        bundle.putString("task_name", "学习RxJava2");
        workerFragment.setArguments(bundle);
        FragmentManager manager = getSupportFragmentManager();
        FragmentTransaction transaction = manager.beginTransaction();
        transaction.add(workerFragment, WorkerFragment.TAG);
        transaction.commit();
    }

    private void removeWorkerFragment() {
        WorkerFragment workerFragment = getWorkerFragment();
        if (workerFragment != null) {
            FragmentManager manager = getSupportFragmentManager();
            FragmentTransaction transaction = manager.beginTransaction();
            transaction.remove(workerFragment);
            transaction.commit();
        }
    }

    private WorkerFragment getWorkerFragment() {
        FragmentManager manager = getSupportFragmentManager();
        return (WorkerFragment) manager.findFragmentByTag(WorkerFragment.TAG);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        Log.d(TAG, "onDestroy");
        mCompositeDisposable.clear();
    }
}
复制代码

咱们来演示一下屏幕旋转时的效果，在屏幕旋转以后，咱们仍然能够继续收到任务进度的更新： 3d

2.2 示例解析

下面，咱们来解释一下示例中的几个要点：code

2.2.1 Activity 和 Fragment 之间的数据传递

数据传递分为两个方向，它们各自能够经过如下方法来实现：cdn

Activity向Fragment传递数据（示例中咱们传递了任务的名称）通常用于向WorkerFragment传递一些任务参数，此时能够经过Fragment的setArguments传入相关的字段，Fragment在onCreate方法中经过getArguments获取参数。
Fragment向Activity传递数据（示例中咱们传递了Observable供Activity订阅以获取进度）可让Activity实现一个接口，咱们在Fragment的onAttach方法中获取Activity实例转换成对应的接口类型，以后经过它来调用Activity的方法，须要注意的是，在Fragment#onDetach时，要将该Activity的引用置空，不然会出现内存泄漏。

2.2 为何调用 publish 方法，使用 Hot Observable 做为 WorkerFragment 的数据源

推荐你们先看一下这篇文章 RxJava 教程第三部分：驯服数据流之 Hot & Cold Observable，这里面对于Cold & Hot Observable进行了解释，它们之间关键的区别就是：

只有当订阅者订阅时，Cold Observale才开始发送数据，而且每一个订阅者都独立执行一遍数据流代码。
而Hot Observable无论有没有订阅者，它都会发送数据流。

而在咱们的应用场景中，因为WorkerFragment是在后台执行任务：

从Activity的角度来看：每次Activity重建时，在Activity中都须要用一个新的Observer实例去订阅WorkerFragment中的数据源，所以咱们只能选择经过Hot Observable，而不是Cold Observable来实现WorkerFragment中的数据源，不然每次都会从新执行一遍数据流的代码，而不是继续接收它发送的事件。
从WorkerFragment的角度来看，它只是一个任务的执行者，无论有没有人在监听它的进度，它都应该执行任务。

经过Observable.create方法建立的是一个Cold Observable，该Cold Observable每隔1s发送一个事件。咱们调用publish方法来将它转换为Hot Observable，以后再调用该Hot Observable的connect方法让其对源Cold Observable进行订阅，这样源Cold Observable就能够开始执行任务了。而且，经过connect方法返回的Disposable对象，咱们就能够管理转换后的Hot Observable和源Cold Observable之间的订阅关系。

Disposable的用途在于：在某些时候，咱们但愿可以中止源Observable任务的执行，例如当该WorkerFragment真正被销毁时，也就是执行了它的onDestroy方法，那么咱们就能够经过上面的Disposable取消Hot Observable对源Cold Observable的订阅，而在Cold Observable的循环中，咱们判断若是下游（也就是Hot Observable）取消了订阅，那么就再也不执行任务。

整个的架构图以下所示：

2.3 在任务执行以后 removeFragment

在了能让WorkerFragment能正常进行下一次任务的执行，咱们须要在发生错误或者任务完成的时候，经过remove的方式销毁WorkerFragment。