一 前言

Lifecycle是生命周期感知組件，可以對Activity或者Fragment的生命周期的狀態(tài)變化做出響應，幫助開發(fā)者寫出更好組織的，輕量級的代碼，更容易維護。

二 為什么需要Lifecycle

舉個栗子，在應用開發(fā)過程中，處理Activity或者Fragment的生命周期不可避免，先看官方文檔舉的例子，是一段對獲取位置的監(jiān)聽代碼，分別在onStart()里啟動監(jiān)聽和在onStop()里停止監(jiān)聽，代碼如下：

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

   fun start(){
       // 連接接定位系統(tǒng)服務
   }

   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需執(zhí)行的業(yè)務邏輯
    }

    @Override
    public void onResume() {
        // onResume需執(zhí)行的業(yè)務邏輯

    }

    @Override
    public void onPause() {
        // onPause需執(zhí)行的業(yè)務邏輯

    }
}

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();
    }

}

在實際開發(fā)中，可能要在多個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. 創(chuàng)建MyObserver

并實現(xiàn)LifecycleObserver接口，Lifecycle實現(xiàn)的過程實際上是觀察者模式，不了解觀察者模式的，可以參考 觀察者模式，我們這篇文章先講怎么使用Lifecycle，下一篇文章將對Lifecycle的源碼進行解讀，現(xiàn)在只需知道，是觀察者模式即可。

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添加到監(jiān)聽列表中，就可以監(jiān)聽到Activity的生命周期變化。

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

        })

        lifecycle.addObserver(myObserver)

從執(zhí)行結果中，看到了是執(zhí)行了索要監(jiān)聽的生命周期。

四.實現(xiàn)自定義的LifecycleOwner

LifecycleOwner是一個接口，定義如下：

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

可以看到，LifecycleOwner只有一個方法，返回了Lifecycle，Lifecycle這個類包含F(xiàn)ragments 和 Activities的生命周期狀態(tài)，并且可以讓其他的組件觀察這個狀態(tài)。

Fragments 和 Activities在Support Library 26.1.0以及以后的版本已經實現(xiàn)了LifecycleOwner接口，如果我們想要一個自定義類，擁有Fragments 和 Activities的生命周期狀態(tài)，可以實現(xiàn)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的各個狀態(tài)。

以上介紹了Jetpack組件Lifecycle的使用，下一篇文章，從源碼介紹Lifecycle的實現(xiàn)。