Android之LifeCycle管理生命周期

引言：
当下，很多IT gay在编码的时候已经开始意识到内存这个问题，我们可能经常需要考虑什么时候释放一些资源，什么时候可能出现线程或者静态引用没有退出，所以绝大多数情况下，我们会关注Activity/Fragment的生命周期，防止测试MM跑monkey然后dump内存给你抛一堆内存泄漏问题。

这篇文章主要讲述如何很好的处理关于对生命周期比较敏感的组件，模拟LifeCycle源码的实现与理解其用意，这篇文章不会讲解LifeCycle如何使用（Gradle请加 implementation "android.arch.lifecycle:extensions:1.+" ） ，而是模拟他的实现方式（观察者模式），自己动手去实现，如果想要学习LifeCycle如何使用，请访问官方文档：https://developer.android.google.cn/topic/libraries/architecture/lifecycle

下面我们便开始吧。

1. 存在的问题

我们写一个activity，需要加载数据，简单例子如下：

public class LiveActivity extends AppCompatActivity{

    private AsyncLoader loader;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //setContentView();
        loader = new AsyncLoader<>(callback);
    }

    @Override
    protected void onResume() {
        super.onResume();
        if(null != loader) {
            loader.start();
        }
    }

    @Override
    protected void onStop() {
        super.onStop();
        if(null != loader) {
            loader.stop();
        }
    }

    private final LoaderCallback callback = new LoaderCallback() {
        @Override
        public void onLoadComplete(String result) {
    //update UI
        }

        @Override
        public void onError(Throwable e) {

        }
    };

}

这个例子很简单，要求就是在activity的onsume里面加载数据，onstop里面释放资源或者取消加载，callback是加载结果回调，用于跟新数据

这个示例看起来很好，但在真实的应用程序中，最终会有太多的调用来管理UI和其他组件以响应生命周期的当前状态。管理多个组件会在生命周期方法中放置大量代码，例如onStart()和 onStop()，这使得它们难以维护。还有可能存在一种情况，如果在onresume里面做太多校验，可能导致没有启动加载就已经执行了onstop退出页面，这样存在一种onstop貌似在onstart之前调用的情况。如下：

@Override
protected void onResume() {
    super.onResume();
    Util.checkUserStatus(result -> {
        // what if this callback is invoked AFTER activity is stopped?
        if (result) {
            loader.start();
        }
    });
}

@Override
protected void onStop() {
    super.onStop();
    if(null != loader) {
        loader.stop();
    }
}

Util.checkUserStatus花费时间较长，如果程序过早退出，执行了onstop，但是checkUserStatus回调导致loader任然启动了，这样就出现了内存泄漏。

对于这一点，我们需要时刻注意生命周期，需要能够简化代码，而且能更好管理与生命周期敏感的操作。

2. 解决方案

2.1 简化代码

第一步需要的就是将代码提取出来，如果任务过多，导致onresume和onstop里面会有大量的代码堆在一起，不仅仅可读性差，而且可能存在漏掉的操作，一时没有注意就会产生内存泄漏，比如我们把所有的操作都放在Presenter类里面，这样就简化了代码，例子如下：

private LivePresenter presenter;

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    //setContentView();
    presenter = new LivePresenter(callback);
}

@Override
protected void onResume() {
    super.onResume();
    presenter.onResume();
}

@Override
protected void onStop() {
    super.onStop();
    presenter.onStop();
}

通过使用Presenter类传入callback回调来代替实现onResume与onStop里面的加载与取消操作，这样便实现第一步简化代码，这样看上去貌似不错，但是总觉得好像是自己主动在生命周期里面操作，有没有一个更好的方法，比如在生命周期变化的时候通知presenter让他改变呢，下面我们需要引入观察者模式，让presenter观察activity的生命周期，activity变化状态的时候，presenter能够收到状态变化的通知然后自动进行一些操作。

观察者模式

1. 将activity修改为被观察者，添加监听，然后在生命周期变化的时候去通知presenter

private LivePresenter presenter;

private LifeCycleRegister lifeCycleRegister;

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    //setContentView();
    presenter = new LivePresenter(callback);


    lifeCycleRegister = new LifeCycleRegister();
    lifeCycleRegister.regitseObserver(presenter);
}

@Override
protected void onResume() {
    super.onResume();
    lifeCycleRegister.markStatue(LifeCycleRegister.STATUE.RESUMR);
}

@Override
protected void onStop() {
    super.onStop();
    lifeCycleRegister.markStatue(LifeCycleRegister.STATUE.STOP);
}

我们在activity里面加入一个LifeCycLeRegister用于注册管理观察者并下发通知，LifeCycLeRegister定义如下：

public class LifeCycleRegister {
    private LifeCycleObserver observer;

    public enum STATUE{
        CREATE,START,RESUMR,PAUSE,STOP,DESTORY
    }

    public void regitseObserver(LifeCycleObserver observer){
        this.observer = observer;
    }

    public void markStatue(STATUE statue){
        switch (statue) {
            case CREATE:
                this.observer.onCreate();
                break;
            case START:
                this.observer.onStart();
                break;
            case RESUMR:
                this.observer.onResume();
                break;
            case PAUSE:
                break;
            case STOP:
                this.observer.onStop();
                break;
            case DESTORY:
                break;
            default:
                break;
        }
    }
}

所有的状态变化都是由LifeCycLeRegister控制并判断是否下发通知，这里只是简单的实现，具体需要一些状态校验，这里主要源码见android.arch.lifecycle.LifecycleRegistry，然后下一步就是定义regitseObserver方法的接口

2. 定义监听变化的通知方法

public interface LifeCycleObserver {
    void onCreate();
    void onStart();
    void onResume();
    void onStop();
}

3. 将presenter修改为观察者，实现监听变化的方法

最后一步就是让presenter实现接口方法并加入LifeCycLeRegister里面用于接收通知，实现如下：

public class LivePresenter implements LifeCycleObserver {

    private AsyncLoader loader;
    private LoaderCallback callback;

    public LivePresenter(LoaderCallback callback) {
        this.callback = callback;
        loader = new AsyncLoader<>(callback);
    }

    @Override
    public void onCreate() {
        //do something onCreate
    }

    @Override
    public void onStart() {
        //do something onStart
    }

    @Override
    public void onResume(){
        Util.checkUserStatus(result -> {
            // what if this callback is invoked AFTER activity is stopped?
            if (result) {
                loader.start();
            }
        });
    }

    @Override
    public void onStop(){
        if(null != loader) {
            loader.stop();
        }
    }
}

至此我们就提取了activity的状态回调，让LivePresenter更好的实现一些逻辑代码，在处理生命周期的时候谨慎对待线程的开闭。

总结：

这篇文章的主要写于分析android.arch.lifecycle的功能，主要分析实现流程，对于LifecycleRegistry主要控制类并没有太多表述，关于判断是否下发状态通知没有详细介绍，读者若有兴趣可以自行研读该类的代码。