Hement：项目中的LifeCycle（五）

时间 2019-12-12

标签 hement 项目 lifecycle 繁體版

原文原文链接

GitHub地址：Hement:持续更新中html
apk下载地址 react
app详情 android
欢迎关注个人公众号 git
LifeCyclegithub
在17年的谷歌IO大会上，Google官方向咱们推出了 Android Architecture Components,其中谈到Android组件处理生命周期的问题，向咱们介绍了 Handling Lifecycles。数据库
因为和小组成员讨论过，感受使用时机尚未到，并且那个时候我反编译微信的apk，发现也没有使用的到，因此这个框架的学习计划就不断地搁浅，前几天又反编译了一下微信的安卓apk，发现它使用了来减小代码的臃肿！推荐一个**反编译工具**api

因此就有必要了解它究竟是个什么东西bash
为何要使用Lifecycle微信
咱们在处理Activity或者Fragment组件的生命周期相关时，不可避免会遇到这样的问题：咱们在Activity的onCreate()中初始化某些成员（好比MVP架构中的Presenter，或者AudioManager、MediaPlayer等），而后在onStop中对这些成员进行对应处理，在onDestroy中释放这些资源，这样致使咱们的代码也许会像这样：网络

class MyPresenter{
    public MyPresenter() {
    }

    void create() {
        //do something
    }

    void destroy() {
        //do something
    }
}

class MyActivity extends AppCompatActivity {
    private MyPresenter presenter;

    public void onCreate(...) {
        presenter= new MyPresenter ();
        presenter.create();
    }

    public void onDestroy() {
        super.onDestroy();
        presenter.destory();
    }
}
复制代码

代码没有问题，关键问题是，实际生产环境中，这样的代码会很是复杂，你最终会有太多的相似调用而且会致使 onCreate() 和 onDestroy() 方法变的很是臃肿。
如何使用Lifecycle 在前面我写过一篇文章Hement：MVP架构中的网络框架(RxJava2+Retrofit2+RxAndroid)（二）这是没有使用的Lifecycle的网络请求的Presenter必须在onDestroy时候去销毁view！

@Override
    protected void onDestroy() {
        super.onDestroy();
        mMainPresenter.detachView();
    }
复制代码

能不能集成到BasePresenter的中去呢？实际上是能够滴,只须要把BasePresenter实现LifecycleObserver便可

public class NewBasePresenter<V extends IMvpView> implements LifecycleObserver {


    public static final String TAG = "NewBasePresenter";
    private V mMvpView;


    public void attachView(V mvpView) {
        mMvpView = mvpView;
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    public void onDestroy() {
        Timber.tag(TAG).d("onDestroy lifecycle event.start ");
        detachView();
    }

    /**
     * 因为在每次这个方法都会去执行，因此能够这样进行
     * @param owner
     * @param event
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
    public void onLifecycleChanged(@NotNull LifecycleOwner owner, @NotNull Lifecycle.Event event) {

    }
    public void detachView() {
        mMvpView = null;
    }
    /**
     * 判断是否还在链接在一块儿的
     * @return
     */
    public boolean isViewAttached() {
        return mMvpView != null;
    }

    /**
     * 获取View
     * @return
     */
    public V getMvpView() {
        return mMvpView;
    }

    /**
     * 检查View是否附着
     */
    public void checkViewAttached() {
        if (!isViewAttached()) throw new MvpViewNotAttachedException();
    }

    public static class MvpViewNotAttachedException extends RuntimeException {
        public MvpViewNotAttachedException() {
            super("在绑定数据以前必定要绑定视图");
        }
    }

    /**
     * 这是Observer 中的 onServer ,当咱们调用这个方法，直接就不会走到 onNext中去
     * @param disposable
     */
    public  void dispose(Disposable disposable) {
        if (disposable != null && !disposable.isDisposed()) {
            disposable.dispose();
        }
    }
}
复制代码

具体的Preseter的实现

public class NewNetWorkPresenter extends NewBasePresenter<NetWorkView> {


    private Disposable mDisposable;
    private final IRemoteServer mIRemoteServer;

    public NewNetWorkPresenter() {
        mIRemoteServer = IRemoteServer.Creator.newHementService();
    }

    @Override
    public void attachView(NetWorkView mvpView) {
        super.attachView(mvpView);
    }

    @Override
    public void detachView() {
        super.detachView();
        if (mDisposable != null) mDisposable.dispose();
        Timber.tag(TAG).d("onDestroy lifecycle event. end ");
    }
    public void loadData(String key,String day){
        //检查View是否附着在上面，不在直接抛出异常
        checkViewAttached();
        //检查是否往下运行
        dispose(mDisposable);
        loadData(key,day,new BaseObserver<SMResponse<ArrayList<TodayBean>>>(new SubscriberListener<SMResponse<ArrayList<TodayBean>>>() {

            @Override
            public void onSubscribe(Disposable disposable) {
                super.onSubscribe(disposable);
                mDisposable = disposable;
            }

            @Override
            public void onSuccess(SMResponse<ArrayList<TodayBean>> response) {
                getMvpView().getDataSuccess(response.result);
            }

            @Override
            public void onFail(String errorCode, String errorMsg) {
                getMvpView().getDataFail(errorCode,errorMsg);
            }

            @Override
            public void onError(Throwable e) {
                getMvpView().onError(e);
            }
        }));
    }
    public void loadData(String key, String day, BaseObserver observer) {
        Observable<SMResponse<ArrayList<TodayBean>>> today = mIRemoteServer.getToday(key, day);
        today.observeOn(AndroidSchedulers.mainThread())
                .subscribeOn(Schedulers.io())
                .subscribe(observer);
    }
}
复制代码

在Activity中的使用,只须要使用这样使用，咱们就可以检测到生命周期的使用，有兴趣的能够下载Apk查看日志！

private NewNetWorkPresenter mNewNetWorkPresenter;
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_new_net_work);
        mNewNetWorkPresenter = new NewNetWorkPresenter();
        getLifecycle().addObserver(mNewNetWorkPresenter);
   
    }
复制代码

Lifecycle的升级使用
假如咱们有个这样的需求，某个页面须要去查询数据库展现数据，同时使用到RxJava2的依赖,查询数据的过程在子线程处理数据回调到UI线程，当忽然有一天产品经理说这个页面的数据咱们要从网络获取，那么你也不肯定那究竟是把代码删除了仍是备份，这些你都不知道！因此这时候你就须要独立绑定getLifecycle().addObserver(mSyncLifecycleObserver);Activity只关心结果便可！代码以下
在这里须要使用这个依赖

api  "com.jakewharton.rxrelay2:rxrelay:2.0.0"
复制代码

SyncResponse

public class SyncResponse {
    public final SyncResponseEventType eventType;
    public final Events comment;

    public SyncResponse(SyncResponseEventType eventType, Events comment) {
        this.eventType = eventType;
        this.comment = comment;
    }
}
复制代码

SyncLifecycleObserver

package com.shiming.hement.lifecycle;

import android.arch.lifecycle.Lifecycle;
import android.arch.lifecycle.LifecycleObserver;
import android.arch.lifecycle.OnLifecycleEvent;
import android.widget.Toast;

import com.shiming.hement.utils.Events;

import org.w3c.dom.Comment;

import io.reactivex.Completable;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.disposables.CompositeDisposable;
import io.reactivex.functions.Action;
import io.reactivex.functions.Consumer;
import io.reactivex.schedulers.Schedulers;
import timber.log.Timber;

/**
 * <p>
 *
 * </p>
 *
 * @author shiming
 * @version v1.0
 * @since 2018/12/18 10:44
 */

public class SyncLifecycleObserver implements LifecycleObserver {

    private static final String TAG = "SyncLifecycleObserver";

    private final CompositeDisposable disposables = new CompositeDisposable();


    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public void onCreate() {
        Timber.tag(TAG).d("onCreate lifecycle event.");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    public void onStart() {
        Timber.tag(TAG).d("onStart lifecycle event.");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void onResume() {
        Timber.tag(TAG).d("onResume lifecycle event.");
        disposables.add(SyncRxBus.getInstance().toObservable()
                .subscribe(new Consumer<SyncResponse>() {
                    @Override
                    public void accept(SyncResponse syncResponse) throws Exception {
                        handleSyncResponse(syncResponse);
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Timber.tag(TAG).d("onResume lifecycle event. Throwable= %s",throwable);
                    }
                }));
    }

    private void handleSyncResponse(SyncResponse response) {
        if (response.eventType == SyncResponseEventType.SUCCESS) {
            onSyncSuccess(response.comment);
        } else {
            onSyncFailed(response.comment);
        }
    }

    private void onSyncSuccess(Events comment) {
        Timber.tag(TAG).d("received sync comment success event for comment %s", comment);
        disposables.add(Completable.fromAction(new Action() {
            @Override
            public void run() throws Exception {
                doWhat();
                Thread thread = Thread.currentThread();
                Timber.tag(TAG).i(thread.toString());
            }
        })
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Action() {
                               @Override
                               public void run() throws Exception {
                                   Timber.tag(TAG).d(" success");
                               }
                           },
                        new Consumer<Throwable>() {
                            @Override
                            public void accept(Throwable throwable) throws Exception {
                                Timber.tag(TAG).e(throwable, " error");
                            }
                        }));
    }

    /**
     * 能够作些子线程的数据操做
     */
    private void doWhat() {

    }
    private void onSyncFailed(Events comment) {
        Timber.tag(TAG).d("received sync comment failed event for comment %s", comment);
        disposables.add(Completable.fromAction(new Action() {
            @Override
            public void run() throws Exception {
                doWhat();
            }
        })
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Action() {
                               @Override
                               public void run() throws Exception {
                                   Timber.tag(TAG).d(" success");
                               }
                           },
                        new Consumer<Throwable>() {
                            @Override
                            public void accept(Throwable throwable) throws Exception {
                                Timber.tag(TAG).e(throwable, " error");
                            }
                        }));
    }

    /**
     * 12-19 15:35:52.317 29721-29721/com.shiming.hement D/SyncLifecycleObserver: received sync comment success event for comment Events=我是NewRxBusDemoActivity中发出成功的事件
     * 12-19 15:35:52.318 29721-29834/com.shiming.hement I/SyncLifecycleObserver: Thread[RxCachedThreadScheduler-2,5,main]
     * 12-19 15:35:52.318 29721-29721/com.shiming.hement D/SyncLifecycleObserver: received sync comment success event for comment Events=我是NewRxBusDemoActivity中发出成功的事件
     * 12-19 15:35:52.319 29721-29835/com.shiming.hement I/SyncLifecycleObserver: Thread[RxCachedThreadScheduler-3,5,main]
     * 12-19 15:35:52.320 29721-29721/com.shiming.hement D/SyncLifecycleObserver: received sync comment success event for comment Events=我是NewRxBusDemoActivity中发出成功的事件
     * 12-19 15:35:52.321 29721-29834/com.shiming.hement I/SyncLifecycleObserver: Thread[RxCachedThreadScheduler-2,5,main]
     * 12-19 15:35:52.323 29721-29721/com.shiming.hement D/SyncLifecycleObserver:   success
     * 12-19 15:35:52.330 29721-29721/com.shiming.hement D/SyncLifecycleObserver:   success
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void onPause() {
        Timber.tag(TAG).d("onPause lifecycle event.");
        // 若是不在这里
        disposables.clear();
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    public void onStop() {
        Timber.tag(TAG).d("onStop lifecycle event.");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    public void onDestroy() {
        Timber.tag(TAG).d("onDestroy lifecycle event.");
    }

    /**
     * 全部的事件都会输出
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
    public void onAny() {
        Timber.tag(TAG).d("onAny 全部的事件都会输出");
    }
}

复制代码

SyncResponseEventType

public enum SyncResponseEventType {
    SUCCESS,
    FAILED
}

复制代码

SyncRxBus

public class SyncRxBus {

    private static SyncRxBus instance;
    private final PublishRelay<SyncResponse> relay;

    public static synchronized SyncRxBus getInstance() {
        if (instance == null) {
            instance = new SyncRxBus();
        }
        return instance;
    }

    private SyncRxBus() {
        relay = PublishRelay.create();
    }

    public void post(SyncResponseEventType eventType, Events comment) {
        relay.accept(new SyncResponse(eventType, comment));
    }

    public Observable<SyncResponse> toObservable() {
        return relay;
    }
}

复制代码

在Activity中的使用

// 若是使用的多的话，能够放在BaseActivity中
    private SyncLifecycleObserver mSyncLifecycleObserver = new SyncLifecycleObserver();


    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_rx_bus_layout);
        getLifecycle().addObserver(mSyncLifecycleObserver);

        findViewById(R.id.btn_mock_send_s_onclick).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Events events = new Events("我是NewRxBusDemoActivity中发出成功的事件");
                SyncRxBus.getInstance().post(SyncResponseEventType.SUCCESS, events);
            }
        });
        findViewById(R.id.btn_mock_send_f_onclick).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Events events = new Events("我是NewRxBusDemoActivity中发出失败的事件");
                SyncRxBus.getInstance().post(SyncResponseEventType.FAILED, events);
            }
        });
复制代码

若是后续咱们不须要使用的话，直接就把Activity中两行代码注释掉就行~~~
GitHub地址：Hement:持续更新中
感谢如下博客对个人帮助
- Android官方架构组件:Lifecycle详解&原理分析
  - Android官方架构组件介绍之LifeCycle