Android-Jetpack Lifecycle

使用生命周期感知型组件处理生命周期

前言

网上关于 lifecycle 的文章非常多,本文主要是记录一下,自己对源码这块的阅读,也加上一些自己的理解,如有错误,请指正

lifecycle 的作用

一个事物的出现,一定有他的作用,Android 上其实已经有了自己的生命周期,例如 activity 的生命周期,开发者可自行在生命周期中处理自己的业务逻辑,

既然有了 生命周期 为啥还要有 lifecycle 干啥

这里我比较认可 重学安卓:为你还原一个真实的 Jetpack Lifecycle 作者的观点

  • 1.实现生命周期 管理的一致性,做到 “一处修改、处处生效”。
  • 2.让第三方组件能够 随时在自己内部拿到生命周期状态,以便执行 及时叫停 错过时机的 异步业务 等操作。
  • 3.让第三方组件在调试时 能够 更方便和安全地追踪到 事故所在的生命周期源。

举个例子,开发者写了一个 业务组件 ,需要在生命周期的各个部分实现,不同的功能,一般的逻辑,可能对外暴露出 每个生命周期的方法,然后在外部的 activity 或者 fragment 对应的生命周期去调用这些对外的方法。虽然实现了相同的功能,但是代码量,和错误的几率都在提高,

而是用 lifecycle 就不用这样,业务组件 通过lifecycle 就能够感知 activity 或者 fragment 的生命周期变化,自行在内部就处理了对应的业务逻辑,不需要再写对外的方法,在外部在调用

基本使用

创建一个类 继承 LifecycleObserver 通过注解的方式获取状态

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80


class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
//添加即可
lifecycle.addObserver(MyLifecycle())

Log.e(MainActivity.TAG,"MainActivity-------->" + "onCreate")
}

override fun onStart() {
super.onStart()
Log.e(MainActivity.TAG,"MainActivity-------->" + "onStart")
}

override fun onResume() {
super.onResume()
Log.e(MainActivity.TAG,"MainActivity-------->" + "onResume")
}


override fun onPause() {
super.onPause()
Log.e(MainActivity.TAG,"MainActivity-------->" + "onPause")
}

override fun onStop() {
super.onStop()
Log.e(MainActivity.TAG,"MainActivity-------->" + "onStop")
}

override fun onDestroy() {
super.onDestroy()
Log.e(MainActivity.TAG,"MainActivity-------->" + "onDestroy")
}




companion object{
val TAG = "fuck"
}
}


//继承 LifecycleObserver
class MyLifecycle() : LifecycleObserver {

@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
fun lifeCreate() {
Log.e(MainActivity.TAG,"MyLifecycle-------->" + "ON_CREATE")
}

@OnLifecycleEvent(Lifecycle.Event.ON_START)
fun lifeStart() {
Log.e(MainActivity.TAG,"MyLifecycle-------->" + "ON_START")
}

@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
fun lifeResume() {
Log.e(MainActivity.TAG,"MyLifecycle-------->" + "ON_RESUME")
}

@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
fun lifePause() {
Log.e(MainActivity.TAG,"MyLifecycle-------->" + "ON_PAUSE")
}

@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
fun lifeStop() {
Log.e(MainActivity.TAG,"MyLifecycle-------->" + "ON_STOP")
}

@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
fun lifeDestroy() {
Log.e(MainActivity.TAG,"MyLifecycle-------->" + "ON_DESTROY")
}
}

分析 Lifecycle 的处理过程

Lifecycle 也有他几个很重要的部分,先放一个大的类图关系

从图中我们能够分析出几个关键的东西

方法说明
Lifecycle抽象类 添加删除观察者,获取状态
LifecycleRegistry继承Lifecycle 真正处理状态变化
ObserverWithState静态类,保存了当前观察者的状态
Status枚举类 观察者的状态
Event枚举类 记录当前的生命周期状态

Lifecycle

从 addObserver 方法开始查看,可以看到 addObserver 是 Lifecycle 的一个抽象方法

Lifecycle 是一个抽象类,他拥有3个抽象方法

1
2
3
addObserver(@NonNull LifecycleObserver observer)
removeObserver(@NonNull LifecycleObserver observer)
State getCurrentState()

继承这个抽象类的只有一个 LifecycleRegistry

LifecycleRegistry

继续查看 LifecycleRegistry 可以看到在activity 和 fragment 中都有实现

这里分析Fragment 通过源码可以知道 这个类是在 fragment 构造函数中就创建出来

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Fragment implements ComponentCallbacks, OnCreateContextMenuListener, LifecycleOwner,
ViewModelStoreOwner, SavedStateRegistryOwner {

LifecycleRegistry mLifecycleRegistry;

public Fragment() {
initLifecycle();
}

private void initLifecycle() {
mLifecycleRegistry = new LifecycleRegistry(this);
}
}

当Fragment 生命周期变化的的时候 通过 handleLifecycleEvent方法将状态传递出去

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

public class Fragment implements ComponentCallbacks, OnCreateContextMenuListener, LifecycleOwner,
ViewModelStoreOwner, SavedStateRegistryOwner {

LifecycleRegistry mLifecycleRegistry;

void performCreate(Bundle savedInstanceState) {
onCreate(savedInstanceState);
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() {
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();
}

}

这里有个细节,performPause performStop performDestroy 都是执行 handleLifecycleEvent 在执行自己的生命周期的

分析一下 handleLifecycleEvent 这个方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

public class LifecycleRegistry extends Lifecycle {

public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
State next = getStateAfter(event);
moveToState(next);
}

private void moveToState(State next) {
//省略代码
sync();
//省略代码
}

private void sync() {
//省略代码
while (!isSynced()) {
//省略代码
if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
backwardPass(lifecycleOwner);
}
Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
if (!mNewEventOccurred && newest != null
&& mState.compareTo(newest.getValue().mState) > 0) {
forwardPass(lifecycleOwner);
}
}
//省略代码
}

private void forwardPass(LifecycleOwner lifecycleOwner) {
Iterator<Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =
mObserverMap.iteratorWithAdditions();
while (ascendingIterator.hasNext() && !mNewEventOccurred) {
Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();
ObserverWithState observer = entry.getValue();
while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
&& mObserverMap.contains(entry.getKey()))) {
pushParentState(observer.mState);
//这里将状态传递出去
observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
popParentState();
}
}
}

private void backwardPass(LifecycleOwner lifecycleOwner) {
Iterator<Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
mObserverMap.descendingIterator();
//map 中多有的 LifecycleObserver 遍历
while (descendingIterator.hasNext() && !mNewEventOccurred) {
Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();
ObserverWithState observer = entry.getValue();
while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
&& mObserverMap.contains(entry.getKey()))) {
Event event = downEvent(observer.mState);
pushParentState(getStateAfter(event));
//这里将状态传递出去
observer.dispatchEvent(lifecycleOwner, event);
popParentState();
}
}
}
}

继续查看 会发现在 ObserverWithState 这个类中 所有的状态都在 LifecycleEventObserver 的 onStateChanged 接口中触发了

1
2
3
4
5
6
7
8
9
10

static class ObserverWithState {

LifecycleEventObserver mLifecycleObserver;

void dispatchEvent(LifecycleOwner owner, Event event) {
//change
mLifecycleObserver.onStateChanged(owner, event);
}
}

继续看一下 LifecycleObserver 这个观察者

上图是 LifecycleObserver 中所有的继承关系 LifecycleEventObserver 则是实现了 LifecycleObserver接口的接口

1
2
3
4
5

public interface LifecycleEventObserver extends LifecycleObserver {

void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event);
}

LifecycleRegistry add 的 时候,生成 ObserverWithState,并将创建的 ObserverWithState 存放在 mObserverMap

1
2
3
4
5
6
7
8
9
10
11
12
13
public class LifecycleRegistry extends Lifecycle {

private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap =
new FastSafeIterableMap<>();
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
//省略代码
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
//存放在map 中
ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
//省略代码
}
}

在 构造方法中,可以发现 生成了一个新的 LifecycleEventObserver

1
2
3
4
5
6
7
8
static class ObserverWithState {
LifecycleEventObserver mLifecycleObserver;

ObserverWithState(LifecycleObserver observer, State initialState) {
//生成一个新的 LifecycleEventObserver
mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
}
}

LifecycleOwner

正在的boss ,持有 Lifecycle

总结

lifecycle 其实并没有那么复杂,仅仅使用观察者模式

1.在初始化的时候 创建了一个 LifecycleRegistry
2.将所有的观察者(LifecycleObserver)通过 LifecycleaddObserver 方法 ,将 观察者保存在 LifecycleRegistrymObserverMap
3.在生命周期发生变化的时候,通过 LifecycleRegistryhandleLifecycleEvent 方法将状态传递出去,然后遍历所有的观察者(LifecycleObserver) 并发通知告知他们,状态变化了

放上一个很好的时序图能够很清晰的看到过程

图片来源 https://blog.csdn.net/zhuzp_blog/article/details/78871374

参考

官网