Android架构组件之Lifecycle

Lifecycle是Google I/O 大会上发布的架构组件，现阶段正式版已经推出。Lifecycle是用于生命周期管理的一个组件。它可以减少内存泄露和崩溃的可能性。同时，生命周期库是其他架构组件（如 LiveData）的基础，所以建议优先撸它。
如果需要配置请参考
相关Gradle配置参考

Lifecycle的基本使用

在传统的MVP中，如果需要在Presenter类里面管理Activity或者fragment的生命周期大概就需要写如下的代码，

/**
 * Created by Hubery on 2018/7/1.
 */
class FirstActivity : AppCompatActivity() {
    companion object {
        val TAG = FirstActivity.javaClass.simpleName
    }

    private var mFirstPresenter: FirstPresenter? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        mFirstPresenter = FirstPresenter(this)
        mFirstPresenter?.onCreate()
    }

    override fun onDestroy() {
        super.onDestroy()
        Log.d(TAG, "onDestroy()")
        mFirstPresenter?.onDestroy()
    }
}

interface IPresenter {
    fun onCreate()
    fun onDestroy()
}

class FirstPresenter(context:Context):IPresenter {

    override fun onCreate() {
        Log.d("FristPresenter","onCreate")
    }

    override fun onDestroy() {
        Log.d("FristPresenter","onDestroy")
    }
}

在这里为了简洁，只实现了两个生命周期，其他的生命周期同理，先实现一个IPresenter的接口，然后实现页面的Presenter代码，如果需要保持和FirstActivity生命周期一致，需要分别的FirstActivity生命周期里的每个方法里面去进行回调。这样写比较麻烦，有没有什么简洁的管理生命周期的方式，答案是Lifecycle。
现在我们来看看Lifecycle的实现方式：

interface IPresenter : LifecycleObserver {
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun onCreate(owner: LifecycleOwner)

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun onDestroy(owner: LifecycleOwner)
}

class CustomPresenter :IPresenter{
    override fun onCreate(owner: LifecycleOwner) {
        Log.d("BasePresenter","onCreate()")
    }

    override fun onDestroy(owner: LifecycleOwner) {
        Log.d("BasePresenter","onDestroy()")
    }
}


/**
 * Created by Hubery on 2018/7/1.
 */
class FirstActivity : AppCompatActivity() {
    companion object {
        val TAG = FirstActivity.javaClass.simpleName
    }

    private var mPresenter: CustomPresenter? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        mPresenter = CustomPresenter(this)
        getLifecycle().addObserver(mPresenter)
    }

    override fun onDestroy() {
        super.onDestroy()
        Log.d(TAG, "onDestroy()")
    }
}

使用Lifecycle在Activity里面就一句getLifecycle().addObserver(mPresenter),就可以达到管理生命周期，这里需要注意的两点：
1，这里的Activity需要继承AppCompatActivity；
2，这里的demo使用的java 7 写IPresenter接口的时候需要实现LifecycleObserver通过注解的方式来接收生命周期的变化，而在java8里面只需要去实现DefaultLifecycleObserver，然后重写里面的生命周期方法即可。

Lifecycle基本原理

借鉴ShymanZhu的图

lifecycle.png

LifecycleObserver：Lifecycle观察者的角色，通过addObserver(@NonNull LifecycleObserver observer)方法注册，java 7中需要实现LifecycleObserver是通过注解的方式来接收生命周期的变化，而在java 8里面只需要去实现DefaultLifecycleObserver，然后重写里面的生命周期方法即可。注册之后通过LifecycleObserver便可以观察到LifecycleOwner中持有的Lifecycle对象的生命周期变化。

LifecycleOwner：LifecycleOwner接口中，唯一定义的方法是getLifecycle(),通过实现该接口就可以获得Lifecycle对象，实现该接口的类持有生命周期(Lifecycle对象)。

Lifecycle：Lifecycle是一个抽象类且是生命周期类，它内部定义了一个addObserver添加事件，removeObserver移除事件，getCurrentState获取当前生命周期的状态，Event事件和State状态的枚举。

LifecycleRegistry:Lifecycle的实现类。

上面就是基本的类和接口的功能和作用之后，我们接下来看看Fragment和他们之间的联系。
Fragment里面可以看到下面的代码

   LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

    @Override
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }

我们上面已经说过了，通过实现LifecycleOwner重写getLifecycle方法是可以获得Lifecycle对象，而LifecycleRegistry是Lifecycle的实现类。

//下面的代码省略了部分
 void performStart() {
        mState = STARTED;
        onStart();          
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);             
    }

void performResume() {
        mState = RESUMED;
        onResume();
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
    }

 void performPause() {
      mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
        mState = STARTED;
        onPause();
    }
//...

代码比较多就不一一贴出来了，需要注意的是在这些生命周期里面，mLifecycleRegistry放置的位置是有变化的。
在Fragment里面，在执行不同的生命周期的时候，会先调用performXX方法，然后在里面真正的执行生命周期的XX方法，并且会执行mLifecycleRegistry的handleLifecycleEvent方法。

   public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
        State next = getStateAfter(event);
        moveToState(next);
    }

handleLifecycleEvent方法会通过 getStateAfter 传入当前的状态，并修改State值，之后会遍历FastSafeIterableMap mObserverMap = new FastSafeIterableMap<>()集合里面的元素，并 由LifecycleObserver 并同步且通知LifecycleOwner改变生命周期。

mLifecycleObserver.onStateChanged(owner, event);

再次感谢ShymanZhu的时序图：

lifecycle_two.png

在Fragment拿到Lifecycle生命周期，然后通过Observer注册监听，最后再生命周期过程中依次调用图中的方法，这下是不是比较清晰了。

Android架构组件之LiveData