程序员徐公

微信公众号:【徐公】

0%

Android lifecyle 源码解剖

说在前面

本次推出 Android Architecture Components 系列文章,目前写好了四篇,主要是关于 lifecycle,livedata 的使用和源码分析,其余的 Navigation, Paging library,Room,WorkMannager 等春节结束之后会更新,欢迎关注我的公众号,有更新的话会第一时间会在公众号上面通知。

Android lifecycle 使用详解

Android LiveData 使用详解

Android lifecyle 源码解剖

Android livedata 源码解剖

github sample 地址: ArchiteComponentsSample

徐公码字,一位不羁的码农。


前言

前两篇博客,我们已经讲解了 lifecycle ,liveData, ViewModel 的使用,这一篇博客,让我们一起来看一下 lifecycle 的原理。


从自定义的 lifecycle 说起

首先我们先来复习一下,如果要自定义 lifecycle,我们要这样做。

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
public class CustomLifecycleActivity extends FragmentActivity implements LifecycleOwner {

private LifecycleRegistry mLifecycleRegistry;

private static final String TAG = "CustomLifecycleActivity";

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_custom_lifecycle);
mLifecycleRegistry = new LifecycleRegistry(this);
mLifecycleRegistry.markState(Lifecycle.State.CREATED);
getLifecycle().addObserver(new GenericLifecycleObserver() {
@Override
public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
Log.d(TAG, "onStateChanged: event = " + event);
}
});

}

@Override
protected void onStart() {
super.onStart();
mLifecycleRegistry.markState(Lifecycle.State.STARTED);
}

@Override
protected void onResume() {
super.onResume();
mLifecycleRegistry.markState(Lifecycle.State.RESUMED);
}

@Override
protected void onDestroy() {
super.onDestroy();
mLifecycleRegistry.markState(Lifecycle.State.DESTROYED);
}

@NonNull
@Override
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
}

  1. 第一步:先实现 LifecycleOwner 接口,并返回 mLifecycleRegistry
  2. 第二步:在 Activity 生命周期变化的时候,调用 mLifecycleRegistry.markState() 方法标记相应的状态
  3. 如果想添加 observer,调用 addObserver 方法添加观察者,这样会在 activity 生命周期变化的时候,回调 observer 的 onchange 方法。

我们先来看一下 getLifecycle() 方法, getLifecycle() 它返回的是一个 Lifecycle 的实例,sdk 中默认的实现类为 LifecycleRegistry。

接下来,我们一起来看一下它的 observer 方法。

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
public void addObserver(@NonNull LifecycleObserver observer) {
// 判断是否是 DESTROYED,如果是将初始状态置为 DESTROYED,否则为 INITIALIZED
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
// ObserverWithState 包装
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
// 将 observer 作为key,在缓存的 mObserverMap 中查找是否存在
ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);

// 存在,直接返回回去,证明该 observer 已经添加过了。否则,证明还没有添加过该 observer
if (previous != null) {
return;
}

LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
if (lifecycleOwner == null) {
// it is null we should be destroyed. Fallback quickly
return;
}

// 这里 mAddingObserverCounter 为 0 ,mHandlingEvent 为 false
boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
State targetState = calculateTargetState(observer);
mAddingObserverCounter++;
while ((statefulObserver.mState.compareTo(targetState) < 0
&& mObserverMap.contains(observer))) {
pushParentState(statefulObserver.mState);
statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
popParentState();
// mState / subling may have been changed recalculate
targetState = calculateTargetState(observer);
}

if (!isReentrance) {
// we do sync only on the top level.
sync();
}
mAddingObserverCounter--;
}

在 addObserver 方法中,它主要干这几件事情

  1. 首先,先初始化状态, 判断当前 mState 是否是 DESTROYED,如果是将初始状态置为 DESTROYED,否则为 INITIALIZED,接着用 ObserverWithState 包装 observer 和 初始化状态 initialState
  2. 将 observer 作为 key,在缓存的 mObserverMap 中查找是否存在,如果存在,证明该 observer 已经添加过,直接返回回去,不必再进行处理。
  3. addObserver 方法中第 21 行 , isReentrance 一般情况下为 false,什么情况 为 true,暂时未想到,

接下来我们先来看 calculateTargetState 方法。

1
2
3
4
5
6
7
8
9
10
11
12
private State calculateTargetState(LifecycleObserver observer) {
// 取出 mObserverMap 的上一个 entry,previous
Entry<LifecycleObserver, ObserverWithState> previous = mObserverMap.ceil(observer);

// 如果不为空,获取它的状态
State siblingState = previous != null ? previous.getValue().mState : null;
// 判断 mParentStates 是否为 null,不为 null,去最后的一个状态,否则,为 null
State parentState = !mParentStates.isEmpty() ? mParentStates.get(mParentStates.size() - 1)
: null;
// 取最小的状态
return min(min(mState, siblingState), parentState);
}
  1. 首先,取出 mObserverMap 中上一个的 entry,该 LifecycleRegistry 实例如果是第一次调用 addObserver 实例的话,那么是 null,否则是上一个 observer 的 entry
  2. 根据 previous 是否为 null,设置 siblingState 的值
  3. 判断 mParentStates 是否为 null,不为 null,取 mParentStates 最后一次的状态
  4. 取 mState, siblingState 最小的状态 a,再取 a 与 parentState 的状态 b
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public enum State {

DESTROYED,

INITIALIZED,

CREATED,

STARTED,

RESUMED;

public boolean isAtLeast(@NonNull State state) {
return compareTo(state) >= 0;
}
}

State 中,他们排序的顺序是 DESTROYED < INITIALIZED < CREATED < STARTED < RESUMED。

我们知道,我们在 activity 的 onCreate 方法中初始化 LifecycleRegistry,并标记它的状态为 CREATED。当我们第一次在 onCreate 方法调用 addObserver 的时候,在 calculateTargetState 方法中,若是首次调用 previous 为 null,则 siblingState,parentState 为 null, 而 mState 为 CREATED,所以最终的状态为 CREATED,即 State targetState = calculateTargetState(observer); 中 targetState 为 CREATED

1
2
// 取最小的状态
return min(min(mState, siblingState), parentState);

看完 calculateTargetState 方法,我们回过头再来看一下 addObserver 方法。

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
public void addObserver(@NonNull LifecycleObserver observer) {


// 省略若干行

// 这里 mAddingObserverCounter 为 0 ,mHandlingEvent 为 false
boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
State targetState = calculateTargetState(observer);
mAddingObserverCounter++;
while ((statefulObserver.mState.compareTo(targetState) < 0
&& mObserverMap.contains(observer))) {
pushParentState(statefulObserver.mState);
statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
popParentState();
// mState / subling may have been changed recalculate
targetState = calculateTargetState(observer);
}

if (!isReentrance) {
// we do sync only on the top level.
sync();
}
mAddingObserverCounter--;
}

这里 statefulObserver.mState 为 DESTROYED 或者 INITIALIZED,肯定比 CREATED 小。而 mObserverMap.contains(observer) 必定为 true,除非我们手动移除掉 mObserverMap。因而,会走进 while循环。

1
2
3
4
5
private void pushParentState(State state) {
mParentStates.add(state);
}

private ArrayList<State> mParentStates = new ArrayList<>();

pushParentState(statefulObserver.mState); 很简单,只是将 statefulObserver 的状态添加到 mParentStates 集合中。

继续往下走,接着会调用 statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
private static Event upEvent(State state) {
switch (state) {
case INITIALIZED:
case DESTROYED:
return ON_CREATE;
case CREATED:
return ON_START;
case STARTED:
return ON_RESUME;
case RESUMED:
throw new IllegalArgumentException();
}
throw new IllegalArgumentException("Unexpected state value " + state);
}

upEvent 方法也很简单,只是返回它的下一个 event。这里因为他们的 state为 INITIALIZED,所以它会返回 ON_CREATE。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
void dispatchEvent(LifecycleOwner owner, Event event) {
State newState = getStateAfter(event);
mState = min(mState, newState);
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}

static State getStateAfter(Event event) {
switch (event) {
case ON_CREATE:
case ON_STOP:
return CREATED;
case ON_START:
case ON_PAUSE:
return STARTED;
case ON_RESUME:
return RESUMED;
case ON_DESTROY:
return DESTROYED;
case ON_ANY:
break;
}
throw new IllegalArgumentException("Unexpected event value " + event);
}

这里 event 为 ON_CREATE,所以 newState 也为 CREATED。 mState = min(mState, newState); mState newState,两者状态相同,所以 mState 也为 CREATED。接着回调 mLifecycleObserver 的 onStateChanged 方法。所以,这里,会收到我们的 onCreate 事件,与我们的预想相符。

但是我们并没有在 onStart,onResume, onPause , onStop 和 onDestroy 方法中调用 mLifecycleRegistry.handleLifecycleEvent 方法,它又是怎样促发 Observer 的 onStateChanged 方法的。这里先不揭晓,我们先来看一下 26.1.0 以后的 AppCompatActivity,待会你就明白了,会感叹 google 真的牛逼!

从 26.1.0 以后 AppCompatActivity 的设计说起

我们知道,在 26.1.0 以后,如果我们要使用 lifecycle,我们只需要调用以下的方法即可。

SupportActivity

1
2
3
4
5
6
7
8
getLifecycle().addObserver(new GenericLifecycleObserver() {

@Override
public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
Log.d(TAG, "onStateChanged: event =" + event);
}
});

跟踪 getLifecycle() 方法,它会跳转到 SupportActivity 的 getLifecycle 方法 中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class SupportActivity extends Activity implements LifecycleOwner, Component {

private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
ReportFragment.injectIfNeededIn(this);
}

@Override
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}

}

在 SupportActivity 中,它默认为我们初始化 mLifecycleRegistry,作为一个成员变量。接着,他在
onCreate 方法中调用了 ReportFragment.injectIfNeededIn(this); 方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class ReportFragment extends Fragment {
private static final String REPORT_FRAGMENT_TAG = "android.arch.lifecycle"
+ ".LifecycleDispatcher.report_fragment_tag";

public static void injectIfNeededIn(Activity activity) {
// ProcessLifecycleOwner should always correctly work and some activities may not extend
// FragmentActivity from support lib, so we use framework fragments for activities
android.app.FragmentManager manager = activity.getFragmentManager();
if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
// Hopefully, we are the first to make a transaction.
manager.executePendingTransactions();
}
}

在 injectIfNeededIn 方法中,它会判断我们是否已经添加 ReportFragment,没有的话,添加进去。

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
public class ReportFragment extends Fragment {
private static final String REPORT_FRAGMENT_TAG = "android.arch.lifecycle"
+ ".LifecycleDispatcher.report_fragment_tag";

private ActivityInitializationListener mProcessListener;

private void dispatchCreate(ActivityInitializationListener listener) {
if (listener != null) {
listener.onCreate();
}
}

private void dispatchStart(ActivityInitializationListener listener) {
if (listener != null) {
listener.onStart();
}
}

private void dispatchResume(ActivityInitializationListener listener) {
if (listener != null) {
listener.onResume();
}
}

@Override
public void onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
dispatchCreate(mProcessListener);
dispatch(Lifecycle.Event.ON_CREATE);
}

@Override
public void onStart() {
super.onStart();
dispatchStart(mProcessListener);
dispatch(Lifecycle.Event.ON_START);
}

@Override
public void onResume() {
super.onResume();
dispatchResume(mProcessListener);
dispatch(Lifecycle.Event.ON_RESUME);
}

@Override
public void onPause() {
super.onPause();
dispatch(Lifecycle.Event.ON_PAUSE);
}

@Override
public void onStop() {
super.onStop();
dispatch(Lifecycle.Event.ON_STOP);
}

@Override
public void onDestroy() {
super.onDestroy();
dispatch(Lifecycle.Event.ON_DESTROY);
// just want to be sure that we won't leak reference to an activity
mProcessListener = null;
}
}


然后,它在 onCreat ,onStart, onResume, onPause, onStop, onDestroy 方法中分别调用 dispatch 方法进行分发生命周期。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

private void dispatch(Lifecycle.Event event) {
Activity activity = getActivity();
if (activity instanceof LifecycleRegistryOwner) {
((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
return;
}

if (activity instanceof LifecycleOwner) {
Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
if (lifecycle instanceof LifecycleRegistry) {
((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
}
}
}

在 dispatch 方法中,会先判断 activity 是不是实现了 LifecycleRegistryOwner ,如果是,直接分发,不过不是,判断是否实现 LifecycleOwner,获取它的 lifecycle,调用它 的 handleLifecycleEvent 进行分发。

1
2
3
public class SupportActivity extends Activity implements LifecycleOwner, Component {

private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this

而很明显,高版本的 SupportActivity 实现了 LifecycleOwner 接口,并写 LifecycleOwner.getLifecycle() 是 LifecycleRegistry

普通的 Activity

对于 26.1.0 以后的版本,你会发现,对于普通的 Activity,如果你想要使用 lifecycle,你只需要实现
LifecycleOwner 接口即可。当生命周期变化的时候,它也可以回调 Observer 的 onStateChanged 方法。

回到我们前面的问题:

我们并没有在 onStart,onResume, onPause , onStop 和 onDestroy 方法中调用 mLifecycleRegistry.handleLifecycleEvent 方法,它又是怎样促发 onStateChanged 方法的

我们猜想它也是通过 ReportFragment 实现的。但是在 Activity 的 onCreate 方法中,我们并没有发现它有添加 ReportFragment,我们在 As 全局搜一下,看哪些地方使用到 ReportFragment。如下图

从图中可以看到,有几个地方使用到他。我们先来看一下 LifecycleDispatcher

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
class LifecycleDispatcher {

private static final String REPORT_FRAGMENT_TAG = "android.arch.lifecycle"
+ ".LifecycleDispatcher.report_fragment_tag";

private static AtomicBoolean sInitialized = new AtomicBoolean(false);

static void init(Context context) {
if (sInitialized.getAndSet(true)) {
return;
}
// 在 init 方法中,监听全局 activity 的创建,从而来添加 fragment
((Application) context.getApplicationContext())
.registerActivityLifecycleCallbacks(new DispatcherActivityCallback());
}

@SuppressWarnings("WeakerAccess")
@VisibleForTesting
static class DispatcherActivityCallback extends EmptyActivityLifecycleCallbacks {
private final FragmentCallback mFragmentCallback;

DispatcherActivityCallback() {
mFragmentCallback = new FragmentCallback();
}

@Override
public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
if (activity instanceof FragmentActivity) {
((FragmentActivity) activity).getSupportFragmentManager()
.registerFragmentLifecycleCallbacks(mFragmentCallback, true);
}
ReportFragment.injectIfNeededIn(activity);
}

@Override
public void onActivityStopped(Activity activity) {
if (activity instanceof FragmentActivity) {
markState((FragmentActivity) activity, CREATED);
}
}

@Override
public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
if (activity instanceof FragmentActivity) {
markState((FragmentActivity) activity, CREATED);
}
}
}

// 省略若干代码

}

可以看到,它 在 init 方法中,通过 context.getApplicationContext() .registerActivityLifecycleCallbacks 监听全局 activity 的创建,在 activity oncreate 的时候,调用 ReportFragment.injectIfNeededIn(activity) ,从而来添加 fragment,进而分发相应的事件。

那 LifecycleDispatcher 的 init 方法又是在哪里调用的呢? 我们全局搜索一下

1
2
3
4
5
6
7
public class ProcessLifecycleOwnerInitializer extends ContentProvider {
@Override
public boolean onCreate() {
LifecycleDispatcher.init(getContext());
ProcessLifecycleOwner.init(getContext());
return true;
}

可以看到它是在 ProcessLifecycleOwnerInitializer 的 onCreate 方法中调用的。而 ProcessLifecycleOwnerInitializer 是一个 ContentProvider。我们知道 ContentProvider 一般是在 AndroidManifest 中生命的。

果然,在 extensions-1.1.1.aar 中,我们惊喜地发现,它在 Manifest 里面注册了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="android.arch.lifecycle.extensions" >

<uses-sdk android:minSdkVersion="14" />

<application>
<provider
android:name="android.arch.lifecycle.ProcessLifecycleOwnerInitializer"
android:authorities="${applicationId}.lifecycle-trojan"
android:exported="false"
android:multiprocess="true" />
</application>

</manifest>

而 ContentProvider 的 onCreate 方法优先于 Application 的 onCreate 执行,所以在 Application 之前我们就调用了 ProcessLifecycleOwnerInitializer init 方法,监听了 Activity 的创建,当 Actiivty 创建的时候,会尝试为 Activity 添加 ReportFragment。而 ReportFragment 会在 Activity 生命周期变化的时候帮助我们分发生命周期。

ContentProvider 的 onCreate 方法优先于 Application 的 onCreate 执行,可以查看这一篇博客 Android系统中的Application和四大组件一些方法的启动顺序和一些坑


总结

ok,我们来梳理一下。

对于 26.1.0 以后的 SupportActivity

它在 Activity onCreate 的时候添加了 ReportFragment,这个 ReportFragment 相当于一个代理,它在 onActivityCreated 的时候 dispatch(Lifecycle.Event.ON_CREATE) 进行分发生命周期,onStart, onResume, onPause, onStop, onDestroy 的时候也是如此。而 在 dispatch 中 它调用了 LifecycleRegistry handleLifecycleEvent 的方法。而 LifecycleRegistry 方法中经过一系列处理,它又调用了 observer 的 onStateChange 方法,去通知相应的 observer。

对于普通的 Activity

它利用了 ContentProvide 的特征,它是在 Application onCreate 之前初始化的,他在 ProcessLifecycleOwnerInitializer oncreate 的时候监听 Activity 的创建,在 Activity 创建的时候,判断是否已经添加过 ReportFragment,没有的话,添加进去。这是一个很巧妙的设计,隐式初始化了 lifecycle。

用流程图表示如下:

该图片引用自 Android 架构组件(一)——Lifecycle

Lifecycle 设计借鉴

  1. 利用 ProcessLifecycleOwnerInitializer contentProvider 来隐式加载

想一下,如果 ProcessLifecycleOwnerInitializer 不利用 contentProvider 来隐式加载的话,对于 普通的 Activity,旧版本等,如果想使用 lifecycle,那必须在基类中,手动调用 ReportFragment.injectIfNeededIn(activity) 的方法。

  1. 利用 fragment 来分发生命周期

利用 fragment 来分发生命周期有两个优点

  • 将逻辑从 Activity 中剥离出来,减少耦合,方便复用
  • 可以做到在 Activity onCreate 之后才回调 observer 的 CREATED Event 事件。如果是通过 Application registerActivityLifecycleCallbacks 方法来分发生命周期的话,因为 ActivityLifecycleCallbacks 的 onActivityCreated 是在 Activity oncreate 之前调用的。

下一篇:Android livedata 源码解剖

推荐阅读:

java 代理模式详解
观察者设计模式 Vs 事件委托(java)
Android Fragment 的妙用 - 优雅地申请权限和处理 onActivityResult