一 前言
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的实现。
