Jetpack LifeCycle

Lifecycle-aware 组件是一个生命周期感知组件，可以简化Android中具有生命周期组件的逻辑处理(例如Activity和Fragment生命周期函数中的自定义逻辑)

此组件是通过观察者模式来实现的，被观察者是实现了LifecycleOwner接口的类，观察者是实现了LifecycleObserver的类

使用方式

1.引入依赖

implementation("androidx.lifecycle:lifecycle-runtime:2.6.1")

2.实现自己的LifeCycleObserver(三种方式)

<1> 通过实现DefaultLifecycleObsever

import android.util.Log
import androidx.lifecycle.DefaultLifecycleObserver
import androidx.lifecycle.LifecycleOwner

/**
* 自定义生命周期观察者
  */
  class MyObserver : DefaultLifecycleObserver {
  companion object {
  val TAG: String = MyObserver::class.java.simpleName
  }

  override fun onResume(owner: LifecycleOwner) {
  super.onResume(owner)
  Log.d(TAG, "onResume")
  }

  override fun onPause(owner: LifecycleOwner) {
  super.onPause(owner)
  Log.d(TAG, "onPause")
  }

  override fun onStart(owner: LifecycleOwner) {
  super.onStart(owner)
  Log.d(TAG, "onStart")
  }

  override fun onCreate(owner: LifecycleOwner) {
  super.onCreate(owner)
  Log.d(TAG, "onCreate")
  }

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

  override fun onStop(owner: LifecycleOwner) {
  super.onStop(owner)
  Log.d(TAG, "onStop")
  }


}

<2> 通过实现LifecycleEventObserver

package zeng.qiang.jetpack.lifecycle

import android.util.Log
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleEventObserver
import androidx.lifecycle.LifecycleOwner

class MyObserverByLifecycleEventObserver : LifecycleEventObserver {
    companion object {
        val TAG: String = MyObserverByLifecycleEventObserver::class.java.simpleName
    }

    override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
        when (event) {
            Lifecycle.Event.ON_CREATE -> {
                Log.d(TAG, "onCreate")
            }

            Lifecycle.Event.ON_RESUME -> {
                Log.d(TAG, "onResume")
            }

            Lifecycle.Event.ON_DESTROY -> {
                Log.d(TAG, "onDestroy")
            }

            Lifecycle.Event.ON_START -> {
                Log.d(TAG, "onStart")
            }

            Lifecycle.Event.ON_PAUSE -> {
                Log.d(TAG, "onPause")
            }

            Lifecycle.Event.ON_STOP -> {
                Log.d(TAG, "onStop")
            }

            Lifecycle.Event.ON_ANY -> {
                Log.d(TAG, "onAny")
            }

        }
    }
}

<3> 通过实现LifecycleObserver搭配@OnlifecycleEvent注解(此种方式注解已被标记废弃，不推荐使用)

package zeng.qiang.jetpack.lifecycle

import android.util.Log
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleObserver
import androidx.lifecycle.OnLifecycleEvent

class MyObserverByLifecycleObserver : LifecycleObserver {
    companion object {
        val TAG: String = MyObserverByLifecycleObserver::class.java.simpleName
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun onCreate() {
        Log.d(TAG, "onCreate")

    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun onResume() {
        Log.d(TAG, "onResume")

    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun onDestroy() {
        Log.d(TAG, "onDestroy")
    }


}

3.在LifecycleOwner 中注册Observer

package zeng.qiang.jetpack

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import zeng.qiang.jetpack.lifecycle.MyObserver

class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)

lifecycle.addObserver(MyObserverByDefaultLifecycleObserver())
lifecycle.addObserver(MyObserverByLifecycleObserver())
lifecycle.addObserver(MyObserverByLifecycleEventObserver())

    }
}

通过以上方式，我们就简单使用DefaultLifecycleObserver 完成了Activity中各个生命周期逻辑的抽取，完成了Activity生命周期代码的简化

实现自己的LifecycleOwner

import android.app.Activity
import android.os.Bundle
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleOwner
import androidx.lifecycle.LifecycleRegistry

open class MyActivity : Activity(), LifecycleOwner {
    private lateinit var lifecycleRegistry: LifecycleRegistry
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        lifecycleRegistry = LifecycleRegistry(this)
    }
    
    override fun getLifecycle(): Lifecycle {
        return lifecycleRegistry
    }
}