转载请标明出处：https://blog.csdn.net/zhaoyanjun6/article/details/99695779
本文出自【赵彦军的博客】
一、Lifecycle简介
为什么要引进Lifecycle？
我们在处理Activity或者Fragment组件的生命周期相关时，不可避免会遇到这样的问题：
我们在Activity的onCreate()中初始化某些成员（比如MVP架构中的Presenter，或者AudioManager、MediaPlayer等），然后在onStop中对这些成员进行对应处理，在onDestroy中释放这些资源，这样导致我们的代码也许会像这样：
class MyPresenter{
public MyPresenter() {
}
void create() {
//do something
}
void destroy() {
//do something
}
}
class MyActivity extends AppCompatActivity {
private MyPresenter presenter;
public void onCreate(...) {
presenter= new MyPresenter ();
presenter.create();
}
public void onDestroy() {
super.onDestroy();
presenter.destory();
}
}
代码没有问题，关键问题是，实际生产环境中 ，这样的代码会非常复杂，你最终会有太多的类似调用并且会导致 onCreate()和 onDestroy()方法变的非常臃肿。
二、解决方案
Lifecycle 是一个类，它持有关于组件（如 Activity或 Fragment）生命周期状态的信息，并且允许其他对象观察此状态。
第1步：BasePresenter 继承 LifecycleObserver
open class BasePresenter : LifecycleObserver {
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
open fun onCreate(owner: LifecycleOwner) {
}
@OnLifecycleEvent(Lifecycle.Event.ON_START)
open fun onStart(owner: LifecycleOwner) {
}
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
open fun onResume(owner: LifecycleOwner) {
}
@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
open fun onPause(owner: LifecycleOwner) {
}
@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
open fun onStop(owner: LifecycleOwner) {
}
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
open fun onDestroy(owner: LifecycleOwner) {
}
@OnLifecycleEvent(Lifecycle.Event.ON_ANY)
open fun onLifecycleChanged(owner: LifecycleOwner, event: Lifecycle.Event) {
}
}
第2步：MainPresenter 继承 BasePresenter
class MyPresenter : BasePresenter() {
override fun onCreate(owner: LifecycleOwner) {
super.onCreate(owner)
Log.e("Lifecycle", "onCreate")
}
override fun onStart(owner: LifecycleOwner) {
super.onStart(owner)
Log.e("Lifecycle", "onStart")
}
override fun onResume(owner: LifecycleOwner) {
super.onResume(owner)
Log.e("Lifecycle", "onResume")
}
override fun onPause(owner: LifecycleOwner) {
super.onPause(owner)
Log.e("Lifecycle", "onPause")
}
override fun onStop(owner: LifecycleOwner) {
super.onStop(owner)
Log.e("Lifecycle", "onStop")
}
override fun onDestroy(owner: LifecycleOwner) {
super.onDestroy(owner)
Log.e("Lifecycle", "onDestroy")
}
override fun onLifecycleChanged(owner: LifecycleOwner, event: Lifecycle.Event) {
super.onLifecycleChanged(owner, event)
Log.e("Lifecycle", "onLifecycleChanged $event")
}
}
第4步：在Activity/Fragment容器中添加Observer
package com.yanjun
import android.os.Bundle
import android.support.v7.app.AppCompatActivity
import android.util.Log
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
lifecycle.addObserver(MainPresenter())
}
override fun onDestroy() {
super.onDestroy()
}
}
如此，每当Activity发生了对应的生命周期改变，Presenter就会执行对应事件注解的方法：
除onCreate和onDestroy事件之外，Lifecycle一共提供了所有的生命周期事件，只要
通过注解进行声明，就能够使LifecycleObserver观察到对应的生命周期事件：
//app进入时
com.example.myapplication E/Lifecycle: onCreate
com.example.myapplication E/Lifecycle: onLifecycleChanged ON_CREATE
com.example.myapplication E/Lifecycle: onStart
com.example.myapplication E/Lifecycle: onLifecycleChanged ON_START
com.example.myapplication E/Lifecycle: onResume
com.example.myapplication E/Lifecycle: onLifecycleChanged ON_RESUME
//app退出时
com.example.myapplication E/Lifecycle: onPause
com.example.myapplication E/Lifecycle: onLifecycleChanged ON_PAUSE
com.example.myapplication E/Lifecycle: onStop
com.example.myapplication E/Lifecycle: onLifecycleChanged ON_STOP
com.example.myapplication E/Lifecycle: onDestroy
com.example.myapplication E/Lifecycle: onLifecycleChanged ON_DESTROY
三、Lifecycle.Event
Lifecycle 是一个抽象类
public abstract class Lifecycle {
public enum Event {
/**
* Constant for onCreate event of the {@link LifecycleOwner}.
*/
ON_CREATE,
/**
* Constant for onStart event of the {@link LifecycleOwner}.
*/
ON_START,
/**
* Constant for onResume event of the {@link LifecycleOwner}.
*/
ON_RESUME,
/**
* Constant for onPause event of the {@link LifecycleOwner}.
*/
ON_PAUSE,
/**
* Constant for onStop event of the {@link LifecycleOwner}.
*/
ON_STOP,
/**
* Constant for onDestroy event of the {@link LifecycleOwner}.
*/
ON_DESTROY,
/**
* An {@link Event Event} constant that can be used to match all events.
*/
ON_ANY
}
public enum State {
/**
* Destroyed state for a LifecycleOwner. After this event, this Lifecycle will not dispatch
* any more events. For instance, for an {@link android.app.Activity}, this state is reached
* <b>right before</b> Activity's {@link android.app.Activity#onDestroy() onDestroy} call.
*/
DESTROYED,
/**
* Initialized state for a LifecycleOwner. For an {@link android.app.Activity}, this is
* the state when it is constructed but has not received
* {@link android.app.Activity#onCreate(android.os.Bundle) onCreate} yet.
*/
INITIALIZED,
/**
* Created state for a LifecycleOwner. For an {@link android.app.Activity}, this state
* is reached in two cases:
* <ul>
* <li>after {@link android.app.Activity#onCreate(android.os.Bundle) onCreate} call;
* <li><b>right before</b> {@link android.app.Activity#onStop() onStop} call.
* </ul>
*/
CREATED,
/**
* Started state for a LifecycleOwner. For an {@link android.app.Activity}, this state
* is reached in two cases:
* <ul>
* <li>after {@link android.app.Activity#onStart() onStart} call;
* <li><b>right before</b> {@link android.app.Activity#onPause() onPause} call.
* </ul>
*/
STARTED,
/**
* Resumed state for a LifecycleOwner. For an {@link android.app.Activity}, this state
* is reached after {@link android.app.Activity#onResume() onResume} is called.
*/
RESUMED;
/**
* Compares if this State is greater or equal to the given {@code state}.
*
* @param state State to compare with
* @return true if this State is greater or equal to the given {@code state}
*/
public boolean isAtLeast(@NonNull State state) {
return compareTo(state) >= 0;
}
}
}
四、原理分析
我们先将重要的这些类挑选出来：
LifecycleObserver接口（ Lifecycle观察者）：
实现该接口的类，通过注解的方式，可以通过被LifecycleOwner类的addObserver(LifecycleObserver o)方法注册,被注册后，LifecycleObserver便可以观察到LifecycleOwner的生命周期事件。
LifecycleOwner接口Lifecycle持有者）：
实现该接口的类持有生命周期(Lifecycle对象)，该接口的生命周期(Lifecycle对象)的改变会被其注册的观察者LifecycleObserver观察到并触发其对应的事件。
Lifecycle(生命周期)：
和LifecycleOwner不同的是，LifecycleOwner本身持有Lifecycle对象，LifecycleOwner通过其Lifecycle getLifecycle()的接口获取内部Lifecycle对象。
-
State(当前生命周期所处状态)：如图所示。 -
Event(当前生命周期改变对应的事件)：
当Lifecycle发生改变，如进入onCreate,会自动发出ON_CREATE事件。
下面我们将换一种方式在Fragment 中实现 Lifecycle 的功能，来探究它的内部实现原理：
1、Fragment：LifecycleOwner
Fragment(Activity同理，我们 本文以Fragment为例，下同)：实现了LifecycleOwner接口，这意味着Fragment对象持有生命周期对象（Lifecycle），并可以通过Lifecycle getLifecycle()方法获取内部的Lifecycle对象：
public class Fragment implements xxx, LifecycleOwner {
//...省略其他
LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
@Override
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
}
public interface LifecycleOwner {
@NonNull
Lifecycle getLifecycle();
}
可以看到，实现的getLifecycle()方法，实际上返回的是 LifecycleRegistry 对象，LifecycleRegistry对象实际上继承了 Lifecycle，这个下文再讲。
持有Lifecycle有什么作用呢？实际上在Fragment对应的生命周期内，都会发送对应的生命周期事件给内部的 LifecycleRegistry对象处理：
public class Fragment implements xxx, LifecycleOwner {
//...
void performCreate(Bundle savedInstanceState) {
onCreate(savedInstanceState); //1.先执行生命周期方法
//...省略代码
//2.生命周期事件分发
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
}
void performStart() {
onStart();
//...
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
}
void performResume() {
onResume();
//...
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
}
void performPause() {
//3.注意，调用顺序变了
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
//...
onPause();
}
void performStop() {
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
//...
onStop();
}
void performDestroy() {
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY);
//...
onDestroy();
}
}
随着Fragment不同走到不同的生命周期，除了暴露给我们的生命周期方法onCreate/onStart/…/onDestroy等，同时，Fragment内部的Lifecycle对象（就是mLifecycleRegistry）还将生命周期对应的事件作为参数传给了 handleLifecycleEvent() 方法。
同时，你会发现
Fragment中performCreate()、performStart()、performResume()会先调用自身的onXXX()方法，然后再调用LifecycleRegistry的handleLifecycleEvent()方法；而在performPause()、performStop()、performDestroy()中会先LifecycleRegistry的handleLifecycleEvent()方法 ，然后调用自身的onXXX()方法。
FullLifecycleObserver
LifecycleObserver有一个子类是 ：FullLifecycleObserver ，下面我们看看它的实现：
package android.arch.lifecycle;
interface FullLifecycleObserver extends LifecycleObserver {
void onCreate(LifecycleOwner owner);
void onStart(LifecycleOwner owner);
void onResume(LifecycleOwner owner);
void onPause(LifecycleOwner owner);
void onStop(LifecycleOwner owner);
void onDestroy(LifecycleOwner owner);
}
不过可惜的是 FullLifecycleObserver 不是 public ， 我们也用不了。
扫一扫
1649
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
