Android Jetpack之Lifecycle的使用及源码分析

Lifecycle生命周期感知型组件可执行操作来响应另一个组件（如 Activity 和 Fragment）的生命周期状态的变化。这些组件有助于您编写出更有条理且往往更精简的代码，此类代码更易于维护。

尤其是在Activity和Fragment在已经默认支持LifeCycle的情况下，我们更有理由来使用它，以便让我们的代码变得更加整洁以及可维护。

本文的内容：

• 一、Lifecycle的使用
• 1.1，在Activity中使用
• 1.2，在Application中使用
• 二、自定义LifecycleOwner
• 三、Lifecycle源码分析（知其然，知其所以然）

一、Lifecycle的使用

Lifecycle 出现之前，我们通常都是在生命周期的onStart和onStop中处理，我们的逻辑（比如，获取定位等等），随着项目的基类，我们的onStart和onStop会越来越臃肿，并难以维护。

下面，我们通过Lifecycle来实现。

1.1，在Activity中使用

首先，我们创建一个Lifecycle观察者

public class MyActLifeCycleObserver implements LifecycleObserver {

    private String mObserverNum;

    public MyActLifeCycleObserver(String observerNum) {
        this.mObserverNum = observerNum;
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public void onCreate() {
        printLog("onCreate");
    }
    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    public void onStart() {
        printLog("onStart");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void onResume() {
        printLog("onResume");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    public void onStop() {
        printLog("onStop");
    }

    private void printLog(String eventStatus) {
        Log.d("liu.MyActivity", mObserverNum + "： " + eventStatus);
    }
}
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

然后，因为Activity默认已经实现了LifecycleOwner。我们可以直接添加到Activity中。如下

public class TestLifeCycleActivity extends AppCompatActivity {
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        getLifecycle().addObserver(new MyActLifeCycleObserver("observer.onCreate"));
    }
}
1
2
3
4
5
6
7
8

这样，就完成了，对TestLifeCycleActivity生命周期的监听。在MyActLifeCycleObserver中，处理该Activity的逻辑，很简单吧

1.2，在Application中使用

之前，我们判断App的前后台运行，都是通过registerActivityLifecycleCallbacks（）。在onStart跟onStop中通过计数器来判断App的前后台运行的。

现在，我们完全可以通过LifeCycle，更优雅的实现该功能

首先，跟Activity的监听一样，创建一个观察者

/**
 * Application的Lifecycle。
 * 1，oncreate只会执行一次
 * 2，onDestroy不执行
 */
public class MyAppLifeCycleObserver implements LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public void onCreate() {
        printLog("onCreate");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    private void onStart() {
        printLog("onStart");
		//前台
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    public void onStop() {
        printLog("onStop");
		//后台
    }

    private void printLog(String eventStatus) {
        Log.d("liu.MyAppLifeCycle", "--- " + eventStatus);
    }
}

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

然后，添加到自定义的Application中

public class MyLifecycleApp extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        ProcessLifecycleOwner.get().getLifecycle().addObserver(new MyAppLifeCycleObserver());
    }
}

1
2
3
4
5
6
7
8

最后，在MyAppLifeCycleObserver中，判断App的前后台逻辑。这样是不是更优雅呢。

这里需要注意的是，1，监听的Application的onCreate()方法，只会执行一次，不管是不是多进程；2，onDestroy方法不会执行

二、自定义LifecycleOwner

如果，我们想让自定义的控件（view,Dialog等），也具有生命周期感知的能力，我们就只需要实现LifecycleOwner，使用 LifecycleRegistry 类，将事件转发到该类，就可以让其具有了感知生命周期的能力。

代码如下：

public class MyActivity extends Activity implements LifecycleOwner {
    private LifecycleRegistry lifecycleRegistry;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        lifecycleRegistry = new LifecycleRegistry(this);
        lifecycleRegistry.markState(Lifecycle.State.CREATED);
    }

    @Override
    public void onStart() {
        super.onStart();
        lifecycleRegistry.markState(Lifecycle.State.STARTED);
    }

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

我们可以照猫画虎，通过上面代码，让自定义view或者Dialog等，也具有生命周期的感知能力

三、Lifecycle源码分析（知其然，知其所以然）

上面，我们一直说LifeCycle已经实现了Activity的生命周期感知能力，就一起来看看源码吧

这里，我们主要从3个方面来分析

• 首先，就是LifecycleOwner是什么
• 其次，就是把我们自定义的的Observer添加进去后，发生了什么
• 最后，就是当Activity生命周期切换的时候，状态是怎么转换的

1,LifecycleOwner作用

LifecycleOwner相当于一个添加观察者的入口。

TestLifeCycleActivity extends AppCompatActivity
...
 AppCompatActivity extends FragmentActivity
...
 FragmentActivity extends ComponentActivity 
...
public class ComponentActivity extends androidx.core.app.ComponentActivity implements
        LifecycleOwner,
        ViewModelStoreOwner,
        HasDefaultViewModelProviderFactory,
        SavedStateRegistryOwner,
        OnBackPressedDispatcherOwner

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

通过上面，我们看到，通过连续的继承，在ComponentActivity的时候，实现了LifecycleOwner

看下LifecycleOwner类

public interface LifecycleOwner {
    /**
     * Returns the Lifecycle of the provider.
     *
     * @return The lifecycle of the provider.
     */
    @NonNull
    Lifecycle getLifecycle();
}

1
2
3
4
5
6
7
8
9
10

他只有一个方法，就是我们在使用LifeCycle时候的getLifecycle()方法，

查看下Activity的具体实现

    private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
	...
    @Override
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }

1
2
3
4
5
6
7

这里，可以看到，方法只返回了一个LifecycleRegistry。我们再来看下，需要感知Activity生命周期的代码

public class TestLifeCycleActivity extends AppCompatActivity {
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        getLifecycle().addObserver(new MyActLifeCycleObserver("observer.onCreate"));
    }
}
1
2
3
4
5
6
7
8

通过这里，我们能确定了，感知生命周期的核心就是LifecycleRegistry这个类了。

先看下这个LifecycleRegistry的初始化，因为是成员变量，所以，每个Activity只会存在一个

    public LifecycleRegistry(@NonNull LifecycleOwner provider) {
        mLifecycleOwner = new WeakReference<>(provider);
        mState = INITIALIZED;
    }

1
2
3
4
5

这里，可以看到，传入的了一个LifecycleOwner，这个owner就是Activity(现在，分析的是Activity)
做了2个事：

• 1，把LifecycleOwner通过mLifecycleOwner保存
• 2，初始化mState的状态

下面，我们分析，添加观察者都做了什么事情

getLifecycle().addObserver()
1

2，看下添加观察者的源码

 @Override
    public void addObserver(@NonNull LifecycleObserver observer) {
        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
        ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
		//如果observer已经存在，直接返回
        if (previous != null) {
            return;
        }
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
		//如果lifecycleOwner(Activity)已经destroy，直接返回
        if (lifecycleOwner == null) {
            // it is null we should be destroyed. Fallback quickly
            return;
        }
		
		//这里是为了计算State的状态，以及是否需要同步其它Observer的状态State
		//毕竟可以再Event的不同阶段(onCreate,onStart)都可以添加Observer
        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--;
    }

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

这里，首先是把observer观察者放到mObserverMap里面

3，当Activity生命周期切换时，Lifecycle是怎么记录状态的

1,首先看下ComponentActivity的onCreate()方法

public class ComponentActivity extends androidx.core.app.ComponentActivity implements
        LifecycleOwner,
        ViewModelStoreOwner,
        HasDefaultViewModelProviderFactory,
        SavedStateRegistryOwner,
        OnBackPressedDispatcherOwner {

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

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

该Activity实现了LifecyclOwner接口，并在onCreate调用了ReportFragment.injectIfNeededIn(this);

接着看下 ReportFragment.injectIfNeededIn(this);

 public static void injectIfNeededIn(Activity activity) {
        if (Build.VERSION.SDK_INT >= 29) {
            // On API 29+, we can register for the correct Lifecycle callbacks directly
            activity.registerActivityLifecycleCallbacks(
                    new LifecycleCallbacks());
        }
        
        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();
        }
    }

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

该段代码的作用就是把一个空白的ReportFragment通过FragmentManager添加到Activity上，使其有观察Activity生命周期的能力。（SDK大于29的话，通过registerActivityLifecycleCallbacks方式监听Activity生命周期）
这种方式，有没有熟悉的感觉呢，当然啦，根本就是和我们常用的大名鼎鼎的图片加载框架Glide，使用的是一种监听方式。

看下Fragment的生命周期，是否会分发生命周期

public class ReportFragment extends Fragment {

    @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 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;
    }

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

在这里我们就看到了，Fragment的每个生命周期，都会调用disatch()的方法

看下dispatch方法

 private void dispatch(@NonNull Lifecycle.Event event) {
		//前面说了，SDK>29的话，会调用 registerActivityLifecycleCallbacks方式监听生命周期
        if (Build.VERSION.SDK_INT < 29) {
            // Only dispatch events from ReportFragment on API levels prior
            // to API 29. On API 29+, this is handled by the ActivityLifecycleCallbacks
            // added in ReportFragment.injectIfNeededIn
            dispatch(getActivity(), event);
        }
    }

...

    static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
        if (activity instanceof LifecycleRegistryOwner) {
            ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
            return;
        }
		//这里就会调用LifecycleRegistry的handleLifecycleEvent方法
        if (activity instanceof LifecycleOwner) {
            Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
            if (lifecycle instanceof LifecycleRegistry) {
                ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
            }
        }
    }

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

到这里，我们看到了生命周期变化，监听的全过程。
1，给Activity添加一个空白的Fragment
2，通过Fragment的生命周期监听，最终回调到Activity的成员变量LifecycleRegistry#handleLifecycleEvent()方法

再次回到LifecycleRegistry里面看看handleLifecycleEvent()方法

 public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
		//这里把event转换成State保存
        State next = getStateAfter(event);
        moveToState(next);
    }

    private void moveToState(State next) {
		//如果当前的状态跟传入的状态一样的话，不改变
		//猜测，Application中如果多进程的话，onCreate()方法也只走一次，是不是因为这个原因呢
        if (mState == next) {
            return;
        }
        mState = next;
        if (mHandlingEvent || mAddingObserverCounter != 0) {
            mNewEventOccurred = true;
            // we will figure out what to do on upper level.
            return;
        }
        mHandlingEvent = true;
        sync();
        mHandlingEvent = false;
    }
	
	...

	static State getStateAfter(Event event) {
        switch (event) {
			//这里的把Event转换成State，为什么ON_CREATE/ON_STOP都转成年CREATED，是因为State属于LifecycleRegistry，通用
			//而Event更接近Activity的周期。这样的话，扩展性就出来了
            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);
    }

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

这里除了判断，把mState赋值成新的State状态。就是走了一个sync()方法，从名字看，应该是同步状态用的

看下源码

 private void sync() {
		//判断宿主是否存在
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        if (lifecycleOwner == null) {
            throw new IllegalStateException("LifecycleOwner of this LifecycleRegistry is already"
                    + "garbage collected. It is too late to change lifecycle state.");
        }
		//如果没有同步过的话。从mObserverMap获取数据，判断走backwardPass还是forwardPass方法
        while (!isSynced()) {
            mNewEventOccurred = false;
            // no need to check eldest for nullability, because isSynced does it for us.
            if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
                backwardPass(lifecycleOwner);
            }
            Entry newest = mObserverMap.newest();
            if (!mNewEventOccurred && newest != null
                    && mState.compareTo(newest.getValue().mState) > 0) {
                forwardPass(lifecycleOwner);
            }
        }
        mNewEventOccurred = false;
    }

	...
	//是否同步过，判断条件：1，是否有观察者；2，是否观察者mObserverMap集合的状态跟mState一样
	private boolean isSynced() {
        if (mObserverMap.size() == 0) {
            return true;
        }
        State eldestObserverState = mObserverMap.eldest().getValue().mState;
        State newestObserverState = mObserverMap.newest().getValue().mState;
        return eldestObserverState == newestObserverState && mState == newestObserverState;
    }


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

看下backwordPass和forwardPass代码

    private void forwardPass(LifecycleOwner lifecycleOwner) {
        Iterator> ascendingIterator =
                mObserverMap.iteratorWithAdditions();
        while (ascendingIterator.hasNext() && !mNewEventOccurred) {
            Entry entry = ascendingIterator.next();
            ObserverWithState observer = entry.getValue();
            while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
                    && mObserverMap.contains(entry.getKey()))) {
                
                observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
                
            }
        }
    }

    private void backwardPass(LifecycleOwner lifecycleOwner) {
        Iterator> descendingIterator =
                mObserverMap.descendingIterator();
        while (descendingIterator.hasNext() && !mNewEventOccurred) {
            Entry entry = descendingIterator.next();
            ObserverWithState observer = entry.getValue();
            while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
                    && mObserverMap.contains(entry.getKey()))) {
                    //State转换成Event
                Event event = downEvent(observer.mState);
                //分发给观察者
                observer.dispatchEvent(lifecycleOwner, event);
                
            }
        }
    }
	

	...

	static class ObserverWithState {
        State mState;
        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;
        }
    }
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

从代码，可以看出。不管走哪个方法，都会遍历mObserverMap集合。这个集合在开始的时候已经看过，就是用来存观察者的集合。

遍历之后，把State转换成Event，调用observer.dispatchEvent()方法，调用ObserverWithState#dispatchEvent()方法，来回调观察者对应的当前的Activity生命周期。

到这里，基本就看完了，那什么时候，执行forwardPass，什么时候执行backwardPass()方法呢。

因为枚举enum类型的compareTo()方法，比较的是序数差。所以，我们需要看下State枚举类

public enum State {

        DESTROYED,

        INITIALIZED,

        CREATED,


        STARTED,

        RESUMED;

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

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

看到每个State定义后，我们通过官网的图，知道。

forwardPass（）方法，是State，按照箭头向右走时执行(INITIALIZED–CREATED–STARTED–RESUMED)，并获取相应的Event
backwardPass()方式，是State，按照箭头向左走时执行(RESUMED–STARTED–CREATED–INITIALIZED)，并获取相应的Event

通过这2个方法内部的downEvent/upEvent()也可以知道

  private static Event downEvent(State state) {
        switch (state) {
            case INITIALIZED:
                throw new IllegalArgumentException();
            case CREATED:
                return ON_DESTROY;
            case STARTED:
                return ON_STOP;
            case RESUMED:
                return ON_PAUSE;
            case DESTROYED:
                throw new IllegalArgumentException();
        }
        throw new IllegalArgumentException("Unexpected state value " + state);
    }

    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);
    }
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

Lifecycle的整体流程

1，Activity添加Lifecycle观察者

2，当Activity生命周期发生变化通知观察者

猜测。
因为Lifecycle生命周期的监听，不光可以用在Activity,Fragment等当中，在自定义View,Dialog或者其它我们有可以定义Event的组件上都是可以使用的。所以，Lifecycle内容维护的是State而不是Activity等独有的Event。这样扩展性更强，也更独立。

官网文档：https://developer.android.google.cn/topic/libraries/architecture/lifecycle#java