Android Jetpack架构组件（二） Lifecycle的使用

一 前言

Lifecycle是生命周期感知组件，可以对Activity或者Fragment的生命周期的状态变化做出响应，帮助开发者写出更好组织的，轻量级的代码，更容易维护。

二 为什么需要Lifecycle

举个栗子，在应用开发过程中，处理Activity或者Fragment的生命周期不可避免，先看官方文档举的例子，是一段对获取位置的监听代码，分别在onStart()里启动监听和在onStop()里停止监听，代码如下：

class MyLocationListener(private val context: Context, private val callback:(Location) -> Unit) {

   fun start(){
       // 连接接定位系统服务
   }

   fun stop(){
       // 断开与定位服务的连接
   }
}

class MyLocationActivity : AppCompatActivity() {

    private lateinit var myLocationListener: MyLocationListener

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_my_location)

        myLocationListener = MyLocationListener(this) {
          // updata UI
        }
    }

    override fun onStart() {
        super.onStart()
        myLocationListener.start()
    }

    override fun onStop() {
        super.onStop()
        myLocationListener.stop()
    }
}

再举个例子，在MVP模式中常用的，要将Presenter的生命周期和Activity的生命周期去绑定。

public interface IPresenter {
    void onStart();
    void onResume();
    void onPause();
}

public class LoginPresenter implements IPresenter{
    @Override
    public void onStart() {
        // onStart需执行的业务逻辑
    }

    @Override
    public void onResume() {
        // onResume需执行的业务逻辑

    }

    @Override
    public void onPause() {
        // onPause需执行的业务逻辑

    }
}

public class LoginActivity extends BaseActivity implements IView.ILoginView {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_login);
    }

    @Override
    protected void onStart() {
        super.onStart();
        mLoginPresenter.onStart();
    }

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


    @Override
    protected void onPause() {
        super.onPause();
        mLoginPresenter.onPause();
    }

}

在实际开发中，可能要在多个Activity的生命周期进行回调，这样，Activity中就要写大量代码，造成代码难以维护。还有一个问题，如果我们在onStart()方法里做了耗时操作，就可能造成当Activity或者Fragment的onStop()方法在onStart()方法之前结束，所以，我们需要一个感知生命周期的组件，这就是Lifecycle。

三 使用Lifecycle

官方给出的添加Lifecycle的依赖如下：

dependencies {
    def lifecycle_version = "2.1.0"

    // ViewModel and LiveData
    implementation "androidx.lifecycle:lifecycle-extensions:$lifecycle_version"
    // alternatively - just ViewModel
    implementation "androidx.lifecycle:lifecycle-viewmodel:$lifecycle_version" // For Kotlin use lifecycle-viewmodel-ktx
    // alternatively - just LiveData
    implementation "androidx.lifecycle:lifecycle-livedata:$lifecycle_version"
    // alternatively - Lifecycles only (no ViewModel or LiveData). Some UI
    //     AndroidX libraries use this lightweight import for Lifecycle
    implementation "androidx.lifecycle:lifecycle-runtime:$lifecycle_version"

    annotationProcessor "androidx.lifecycle:lifecycle-compiler:$lifecycle_version" // For Kotlin use kapt instead of annotationProcessor
    // alternately - if using Java8, use the following instead of lifecycle-compiler
    implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"

    // optional - ReactiveStreams support for LiveData
    implementation "androidx.lifecycle:lifecycle-reactivestreams:$lifecycle_version" // For Kotlin use lifecycle-reactivestreams-ktx

    // optional - Test helpers for LiveData
    testImplementation "androidx.arch.core:core-testing:$lifecycle_version"
}

下面举例说明，Lifecycle使用步骤

1. 创建MyObserver

并实现LifecycleObserver接口，Lifecycle实现的过程实际上是观察者模式，不了解观察者模式的，可以参考 观察者模式，我们这篇文章先讲怎么使用Lifecycle，下一篇文章将对Lifecycle的源码进行解读，现在只需知道，是观察者模式即可。

class MyObserver(var lifecycle:Lifecycle,var lifecycleCallback: LifecycleCallback) :LifecycleObserver{

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun connectOnCreate(){
        print("OnCreate")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun connectOnStart() {
        print("OnStart")
    }


    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun connectOnResume(){
        print("OnResume")
    }


    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun disconnectOnDestroye() {

        print("OnDestroy")
    }

    private fun print(string:String){
        lifecycleCallback.update(string)
    }

}

interface LifecycleCallback {
    fun update(message:String)
}

2.在Activity中使用

在Activity中，只要将自定义的MyObserver添加到监听列表中，就可以监听到Activity的生命周期变化。

 myObserver = MyObserver(lifecycle, object : LifecycleCallback {
            override fun update(message: String) {
                Log.d("hbj--", message)
            }

        })

        lifecycle.addObserver(myObserver)

从执行结果中，看到了是执行了索要监听的生命周期。

四.实现自定义的LifecycleOwner

LifecycleOwner是一个接口，定义如下：

public interface LifecycleOwner {
    /**
     * Returns the Lifecycle of the provider.
     *
     * @return The lifecycle of the provider.
     */
    @NonNull
    Lifecycle getLifecycle();
}

可以看到，LifecycleOwner只有一个方法，返回了Lifecycle，Lifecycle这个类包含Fragments 和 Activities的生命周期状态，并且可以让其他的组件观察这个状态。

Fragments 和 Activities在Support Library 26.1.0以及以后的版本已经实现了LifecycleOwner接口，如果我们想要一个自定义类，拥有Fragments 和 Activities的生命周期状态，可以实现LifecycleOwner接口，我们可以使用LifecycleRegistry类，具体代码如下：

class MyActivity : Activity(), LifecycleOwner {

    private lateinit var lifecycleRegistry: LifecycleRegistry

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        lifecycleRegistry = LifecycleRegistry(this)
        lifecycleRegistry.markState(Lifecycle.State.CREATED)
    }

    public override fun onStart() {
        super.onStart()
        lifecycleRegistry.markState(Lifecycle.State.STARTED)
    }

    override fun getLifecycle(): Lifecycle {
        return lifecycleRegistry
    }
}

通过新建LifecycleRegistry，为LifecycleRegistry设置Lifecycle的各个状态。

以上介绍了Jetpack组件Lifecycle的使用，下一篇文章，从源码介绍Lifecycle的实现。