前言
本文将开始Jetpack系列之Lifecycle的学习，为什么先说Lifecycle呢，因为Lifecycle是Jetpack的核心，我们熟悉的ViewModel,LiveData都是基于它实现的。（关于Jetpack大家也可以直接看Jetpack官网 ）
看完本文可以达到什么程度
- 掌握Lifecycle的基本原理及使用
- 掌握Activity Fragment是如何实现Lifecycle的。
- 掌握Lifecycle宿主分发
如果您已经达到上面的程度，那么可以不看下文了；
什么是Jetpack
简单点总结就是：Jetpack是众多组件的统称，而AndroidX是这些组件的统一包名。
什么是Lifecycle
Lifecycle也即是Jetpack众多组件之一，这个组件库代码也就是小十个类，如下：
Lifecycle库.png
简单点总结就是：Lifecycle组件抽象出了一套观察者(继承LifecycleObserver)，被观察者(继承LifecycleOwner,例如Fragment)，以及他们两之间事件分发 的能力。
Lifecycle简单流程.png
- Lifecycle是一个能感知宿主(LifecycleOwner)生命周期的组件。
- 允许其它观察者监听宿主生命周期状态。
- 省略了以前手动分发宿主生命周期的操作.(例如在onDestroy中去调用三方组件的销毁)。
- 宿主如何分发生命周期状态？之后再详细分析。
Lifecycle的使用
1). 首先得添加依赖，以下两种选一种就行
//通常情况下，只需要添加appcompat就可以了
api 'androidx.appcompat:appcompat:1.1.0'
//如果想单独使用，可引入下面这个依赖
api 'androidx.lifecycle:lifecycle-common:2.1.0'
2). 使用有如下三种方式：
- 实现LifecycleObserver，并使用@OnLifecycleEvent注解
// 1.自定义的组件，也是LifecycleObserver观察者
class MyObserver implements LifecycleObserver {
// 在对应的方法上用注解声明想要观察的宿主生命周期
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
void onCreate(LifecycleOwner owner){
// 宿主(例如Fragment)的onCreate事件分发
}
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
void onDestroy(LifecycleOwner owner){
// 宿主(例如Fragment)的onDestroy事件分发
}
}
// 1.Fragment继承了LifecycleOwner，是个宿主
// 2.注册观察者,观察宿主生命周期变化
class MyFragment extends Fragment {
@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
MyObserver observer = new MyObserver();
getLifecycle().addObserver(observer);
}
}
- 实现FullLifecyclerObserver，拥有生命周期所有事件，但FullLifecyclerObserver类对外不可见。
class MyObserver1 implements FullLifecycleObserver {
@Override
public void onCreate(LifecycleOwner owner) {
}
@Override
public void onStart(LifecycleOwner owner) {
}
@Override
public void onResume(LifecycleOwner owner) {
}
@Override
public void onPause(LifecycleOwner owner) {
}
@Override
public void onStop(LifecycleOwner owner) {
}
@Override
public void onDestroy(LifecycleOwner owner) {
}
}
- LifecycleEventObserver宿主生命周期事件封装成 Lifecycle.Event，观察者根据Lifecycle.Event区分宿主的不同生命周期
// 源码
public interface LifecycleEventObserver extends LifecycleObserver {
void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event);
}
class MyObserver2 implements LifecycleEventObserver {
@Override
public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {
switch (event){
case ON_CREATE:
// 宿主onCreate生命周期
break;
case ON_DESTROY:
// 宿主onDestroy生命周期
break;
}
}
}
3). 我们的Activity跟Fragment都是LifecycleOwner；也就是说一些自定义组件可以通过addObserver，在组件内部获得Activity跟Fragment的生命周期回调；举个例子：
/**
* 倒计时组件
* 1. 最原始的做法我们需要在Activity或Fragment的onDestroy中手动去停止。万一漏了就可能造成内存泄漏问题。
* 2. 有了Lifecycle，就能在组件内部去处理，再也不怕内存泄漏了
*/
public class CountDownTextView extends AppCompatTextView implements LifecycleObserver {
public CountDownTextView(......) {
super(......);
// 自动注册
autoBindLifecycle(context);
}
}
private void autoBindLifecycle(Context context) {
...
xxx.getLifecycle().addObserver(this);
...
}
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
private void onDestroy() {
// 自动去做一些停止，释放资源等操作
......
}
Fragment如何实现Lifecycle
先看看整体架构图：
Lifecycle-fragment架构.png
Fragment中代码如下：
public class Fragment implements LifecycleOwner {
LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
@Override
public Lifecycle getLifecycle() {
//复写自LifecycleOwner,所以必须new LifecycleRegistry对象返回
return mLifecycleRegistry;
}
void performCreate(){
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
}
void performStart(){
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
}
.....
void performResume(){
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
}
}
- Fragment实现了LifecycleOwner接口，是一个能提供生命周期事件的宿主
- Fragment中通过Lifecycle addObserver()，来添加观察者。
- Fragment中通过Lifecycle的具体实现类LifecycleRegistry来进行生命周期事件的分发。
Activity如何实现Lifecycle
Activity的实现跟Fragment稍有不同，不是利用自己的生命周期去分发事件，而是添加一个Fragment，通过Fragment的生命周期去分发。(为啥这样设计？？)
public class ComponentActivity extends Activity implements LifecycleOwner{
private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
@NonNull
@Override
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
protected void onCreate(Bundle bundle) {
super.onCreate(savedInstanceState);
//往Activity上添加一个fragment,用以报告生命周期的变化
//目的是为了兼顾不是继承自AppCompactActivity的场景.
ReportFragment.injectIfNeededIn(this);
}
ReportFragment的实现原理跟Fragment类似，通过LifecycleRegistry对生命周期事件分发。
public class ReportFragment extends Fragment{
public static void injectIfNeededIn(Activity activity) {
android.app.FragmentManager manager = activity.getFragmentManager();
if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
manager.executePendingTransactions();
}
}
@Override
public void onStart() {
super.onStart();
dispatch(Lifecycle.Event.ON_START);
}
@Override
public void onResume() {
super.onResume();
dispatch(Lifecycle.Event.ON_RESUME);
}
@Override
public void onPause() {
super.onPause();
dispatch(Lifecycle.Event.ON_PAUSE);
}
@Override
public void onDestroy() {
super.onDestroy();
dispatch(Lifecycle.Event.ON_DESTROY);
}
private void dispatch(Lifecycle.Event event) {
Lifecycle lifecycle = activity.getLifecycle();
if (lifecycle instanceof LifecycleRegistry) {
((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
}
}
生命周期事件及状态
先明确两个概念：Lifecycle类中有两个枚举，Event(事件),State(状态)。
Event：当宿主的生命周期有变化时，会发送相应的事件Event,如下：
void performCreate(Bundle savedInstanceState) {
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
}
State：Lifecycle的实现类LifecycleRegistry中保存了mState，代表当前宿主的状态；宿主发送不同的事件，相应的State也会变化。
Event和State关系如下：
Lifecycle事件及状态.png
事件分发原理
首先先思考一个问题：如果是在Fragment的onResume中注册一个Observer，这个Observer还能收到Fragment的oncreate,onstart,onresume事件吗？
这里先给答案：可以收到，这几个事件在addObserver方法中就会去分发。
以这个为例来讲讲lifecycle的事件分发原理，主要看下LifecycleRegistry流程，先见下图：
LifecycleRegistry主要流程.png
上图就是一个大致的了解，要详细的认知还是得看源码：
Step1:初始化
public LifecycleRegistry(@NonNull LifecycleOwner provider) {
mLifecycleOwner = new WeakReference<>(provider);
mState = INITIALIZED;
}
这个构造方法就是在Fragment的构造方法中调用，主要是对mState做了个初始化INITIALIZED
Step2：注册Observer
以下代码只展示一些主流程
public void addObserver(@NonNull LifecycleObserver observer) {
// 1.添加新的Observer时，会根据宿主状态计算observer的初始状态
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
// 2.把初始状态跟observer封装成一个新的对象ObserverWithState
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
// 3. 计算宿主对象的状态
State targetState = calculateTargetState(observer);
......
}
// Observer对象的封装对象
static class ObserverWithState {
State mState;
// 所有的Observer会转成LifecycleEventObserver类型
LifecycleEventObserver mLifecycleObserver;
ObserverWithState(LifecycleObserver observer, State initialState) {
mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
mState = initialState;
}
// 事件发送
void dispatchEvent(LifecycleOwner owner, Event event) {
State newState = getStateAfter(event);
mState = min(mState, newState);
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
}
把observer与State封装成ObserverWithState，这个对象对把observer统一转成LifecycleEventObserver类型；怎么转的大家可以详细看下Lifecycling中lifecycleEventObserver，这里不展开叙述了
Step3:对比Observer状态跟宿主状态
public void addObserver( LifecycleObserver observer) {
以上是Step2
......
// 1. 拿观察者的状态和宿主当前状态做比较，如果小于0，说明两者状态还没有对齐
while ((statefulObserver.mState.compareTo(targetState) < 0,...){
......
// 2.接着就会分发一次相应的事件，于此同时statefulObserver的mState对象也会被升级
statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
// 3.再一次计算观察者应该到达的状态
targetState = calculateTargetState(observer);
}
}
在以上三步后，在onResume中注册的Observer就能收到oncreate,onstart,onresume三个事件。当宿主在执行其他的生命周期时，会通过handleLifecycleEvent发送相应的事件。
Step4:宿主发送相应事件
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
// 1. 获取事件相对应的状态
State next = getStateAfter(event);
// 2.同步到该状态，给所有的Observer发送事件
moveToState(next);
}
总结
看完本篇再回到开头的几项目标，是不是都掌握了呢？还没掌握可以对着源码再细细屡屡，相信一定能掌握Lifecycle的核心，之后要讲的LiveData，ViewModel都是基于它来实现的。
