LifeCycle 组件与 Android 组件（如 Activity 或 Fragment）的生命周期事件相关，它包含三个主要的类：

  • LifeCycle（生命周期）
  • LifeCycleOwner（生命周期所有者）
  • LifeCycleObserver（生命周期观察者）

LifeCycle

一个 LifeCycle 对象可以获取与 LifeCycleOwner（通常是 Activity 或 Fragment）当前生命周期相关的信息。

LifeCycle 对象提供了关于所有者生命周期的信息，以事件和状态的形式。

事件是与生命周期所有者事件相关的，如 onCreate()、onStart()、onStop() 等。

alt text

从上面的时间线图中，我们注意到事件 ON_CREATE、ON_START 和 ON_RESUME 在相应的 Activity（LifeCycleOwner）的 onCreate()、onStart() 和 onResume() 返回后立即分派。

另外，我们还注意到有一个特殊的事件：ON_ANY，它匹配所有的生命周期所有者事件。

状态如文档所述：

生命周期状态。你可以将状态视为图中的节点，将 Lifecycle.Events 视为这些节点之间的边。

我也喜欢把它们看作是描述生命周期所有者在某一时刻的生命周期状态的值。

alt text

从上面的示例中，我们从 INITIALIZED 状态开始，它代表了生命周期所有者已经被构建，但尚未接收到其 onCreate() 方法的状态。

我们还注意到一个状态可以跨越多个生命周期所有者事件，因此对于一个 Activity 来说，一旦创建完成并且在暂停之前，它就被认为处于 CREATED 状态，在活动的 onStart() 和 onPause() 之间的时间段也被认为是处于 STARTED 状态。

由于在给定的时间点上可以交替使用多个状态，如果我们想要检查特定的状态，我们总是使用 isAtLeast 方法：

1
2
3
if (lifeCycle.currentState.isAtLeast(Lifecycle.State.STARTED)) {
    //...
}

LifeCycleOwner

任何实现 LifeCycleOwner 接口的类都表示它具有 Android 生命周期。

例如，从支持库 26.1.0 开始，Fragments 和 Activities 实现了 LifeCycleOwner 接口。

我们可以通过实现该接口并使用 LifeCycleRegistry 来创建自定义的 LifeCycleOwner 组件。

LifeCycleObserver

它是一个标记接口，表示实现该接口的类是一个 LifeCycleObserver。与 LifeCycle 事件的交互可以通过两种方式进行：

  • 如果我们使用 Java 8，观察者类可以实现 DefaultLifecycleObserver 接口（该接口又实现了 LifecycleObserver 接口），它定义了生命周期事件作为默认方法，因此我们可以重写我们感兴趣的事件方法：
1
2
3
4
5
6
class MyLifeCycleObserver : DefaultLifecycleObserver {
     
     override fun onCreate(owner: LifecycleOwner) {
         //...
     }
 }
  • 否则，我们可以直接实现 LifecycleObserver 接口，并使用 OnLifecycleEvent 注解：
1
2
3
4
5
6
class MyLifeCycleObserver(val lifeCycle: Lifecycle) : LifecycleObserver {
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
 fun onCreated() {
  //...
 }
}

现在我们将实现一个简单的demo来展示如何使用 LifeCycle 组件，这将是一个非常简单的应用程序，记录我们的主 Activity 经历的不同生命周期事件。

Demo

首先我们创建一个日志类：

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

    companion object {
        private const val TAG = "MyLogger"
    }

    fun logCreate() {
        Log.d(TAG, "Activity created")
    }

    fun logStart() {
        Log.d(TAG, "Activity started")
    }

    fun logResume() {
        Log.d(TAG, "Activity resumed")
    }

    fun logPause() {
        Log.d(TAG, "Activity will pause")
    }

    fun logStop() {
        Log.d(TAG, "Activity will stop")
    }

    fun logDestroy() {
        Log.d(TAG, "Activity will be destroyed")
    }
}

然后，我们将创建一个 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
class MyLifeCycleObserver(private val lifeCycle: Lifecycle, private val logger: MyLogger) : LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun logCreate() {
        logger.logCreate()
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun logStart() {
        if (lifeCycle.currentState.isAtLeast(Lifecycle.State.STARTED)) {
            logger.logStart()
        }
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun logResume() {
        logger.logResume()
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun logPause() {
        logger.logPause()
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun logStop() {
        logger.logStop()
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun logDestroy() {
        if (lifeCycle.currentState.isAtLeast(Lifecycle.State.DESTROYED)) {
            logger.logDestroy()
        }
    }
}

在这里，我们通过 @OnLifecycleEvent 注解与 LifeCycle 事件进行交互。

然后，在我们的主 Activity（即我们的 LifeCycleOwner）中，我们将观察者添加到活动的生命周期观察者中：

1
2
3
4
5
6
7
8
9
10
class MainActivity: AppCompatActivity() {

	override fun onCreate(savedInstanceState: Bundle ? ) {
		super.onCreate(savedInstanceState)
		setContentView(R.layout.activity_main)

		val lifeCycleObserver = MyLifeCycleObserver(lifecycle)
		lifecycle.addObserver(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
class MyLifeCycleObserverTest {

    lateinit var lifeCycleObserver: MyLifeCycleObserver
    lateinit var lifeCycle: LifecycleRegistry
    val logger = mock(MyLogger::class.java)

    @Before
    fun setUp() {
        val lifeCycleOwner: LifecycleOwner = mock(LifecycleOwner::class.java)
        lifeCycle = LifecycleRegistry(lifeCycleOwner)
        lifeCycleObserver = MyLifeCycleObserver(lifeCycle, logger)
        lifeCycle.addObserver(lifeCycleObserver)

        lifeCycle.handleLifecycleEvent(Lifecycle.Event.ON_CREATE)
    }

    @Test
    fun shouldLogStart() {
        lifeCycle.markState(Lifecycle.State.STARTED)
        verify(logger).logStart()
    }

    @Test
    fun shouldLogStop() {
        lifeCycle.handleLifecycleEvent(Lifecycle.Event.ON_RESUME)
        lifeCycle.handleLifecycleEvent(Lifecycle.Event.ON_STOP)
        verify(logger).logStop()
    }

}

在这里，我们使用了一个LifeCycleRegistry作为LifeCycleOwner，在测试onStop()生命周期事件时，我们必须将生命周期移动到先前的状态（onResume()）然后再将其置于ON_STOP状态，这对于在实际LifeCycleOwner事件返回之前分派的生命周期事件（如ON_STOP和ON_PAUSE）是必要的。

原理

添加观察者

首先我们从添加观察者说起，在Activity中，为什么可以获取到Lifecycle？

1
2
3
public Lifecycle getLifecycle() {
    return mLifecycleRegistry;
}

跳转源码，可以看到在父类ComponentActivity中，实现 LifecycleOwner 接口， getLifecycle 返回了 mLifecycleRegistry

1
2
3
4
5
6
7
8
9
public class ComponentActivity extends androidx.core.app.ComponentActivity implements
        ContextAware,
        LifecycleOwner,
        ............
        {
    ............
    private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
    ............       
 }

在 ComponentActivity 创建的时候，同时创建了 LifecycleRegistry ，LifecycleRegistry 是Lifecycle 子类。

看到这里就可以理解为什么可以在Activity 里 添加观察者了。

接下来我们看下，添加观察者。

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
LifecycleRegistry类   

@Override
    public void addObserver(@NonNull LifecycleObserver observer) {
        enforceMainThreadIfNeeded("addObserver");
        //初始状态
        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
        //通过ObserverWithState将观察者和状态进行包装
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
        //将包装类放到 FastSafeIterableMap<LifecycleObserver, ObserverWithState> 中 。
        ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
        ............
        //将状态进行对齐  
        while ((statefulObserver.mState.compareTo(targetState) < 0
                && mObserverMap.contains(observer))) {
            pushParentState(statefulObserver.mState);
            final Event event = Event.upFrom(statefulObserver.mState);
            if (event == null) {
                throw new IllegalStateException("no event up from " +                statefulObserver.mState);
            }
            statefulObserver.dispatchEvent(lifecycleOwner, event);
            popParentState();         
            targetState = calculateTargetState(observer);
        }

        if (!isReentrance) {
            //同步状态 
            sync();
        }
        mAddingObserverCounter--;
    }

使用 ObserverWithState类 将观察者对象和状态进行包装，然后存储在 FastSafeIterableMap 中，这里先对ObserverWithState这个类有点印象， 在下文事件分发的时候，会再详细讲解。

FastSafeIterableMap 具有以下特性：

  • 支持键值对存储，用链表实现，模拟成Map的接口
  • 支持在遍历的过程中删除任意元素，不会触发ConcurrentModifiedException
  • 非线程安全

注释中提到的将状态进行对齐，是在添加观察者的时候，可能是在任何状态的时候进行添加的，lifecycle需要将这个状态进行对齐。

例如我们在onResume的回调中添加了观察者，此时我们的观察者就收到依次收到 onCreate， onStart，onResume的回调。

监听生命周期

我们的观察者是怎样收到Activity 的生命周期的监听的呢？

这里我们看下父类ComponentActivity的onCreate方法中，有一个这样的操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    ............
    ReportFragment.injectIfNeededIn(this);
    if (mContentLayoutId != 0) {
        setContentView(mContentLayoutId);
    }
}

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();
        // Hopefully, we are the first to make a transaction.
        manager.executePendingTransactions();
    }
}

在 ComponentActivity 创建的时候，同时创建了ReportFragment，这个Fragment的作用就是用来分发生命周期状态的。

在ReportFragment的每个生命周期的回调中，都对应的调用了 dispatch 方法 ，来进行状态分发。

最后 dispatch的方法中，又调用了 LifecycleRegistry 的handleLifecycleEvent

1
2
3
4
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
    enforceMainThreadIfNeeded("handleLifecycleEvent");
    moveToState(event.getTargetState());
}

我们当前的状态是通过 event.getTargetState()来获取的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public State getTargetState() {
    switch (this) {
        case ON_CREATE:
        case ON_STOP:
            return State.CREATED;
        case ON_START:
        case ON_PAUSE:
            return State.STARTED;
        case ON_RESUME:
            return State.RESUMED;
        case ON_DESTROY:
            return State.DESTROYED;
        case ON_ANY:
            break;
    }
    throw new IllegalArgumentException(this + " has no target state");
}

这里是维护了一个状态机，State 一共维护了 DESTROYED ， INITIALIZED ， CREATED ，STARTED ， RESUMED 五种状态

上图简要说明了一下 各个生命周期回调时，分别对应的状态，整个状态趋势 是分为 正在可见 和正在不可见。

通过状态机获取当前的状态之后，会将当前状态进行记录，然后会 执行 sync() 方法进行同步操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
private void sync() {
    LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
    ......
    //当 mObserverMap 中存储的最新的状态(刚插入的) 与 最老的状态(最先插入的) 一致，并且当前状态等于最新的状态，停止同步。 
    while (!isSynced()) {
        mNewEventOccurred = false;
        if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
            backwardPass(lifecycleOwner);
        }
        Map.Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
        if (!mNewEventOccurred && newest != null
                && mState.compareTo(newest.getValue().mState) > 0) {
            forwardPass(lifecycleOwner);
        }
    }
    mNewEventOccurred = false;
}

在这里会通过当前状态和存储的状态进行比较操作，判断当然流程 是 向正在可见发展 还是 正在向不可见发展，

例如当前执行的状态是START，与上个状态相比，如果上个状态是CREATE，相比结果就是>0 ，说明是正在可见；如果上个状态是RESUME ，相比结果<0 ，说明是正在不可见。

backwardPass 和 forwardPass 主要有两点不同

1.在对mObserverMap 存储的状态进行遍历时，backwardPass 是以 栈的形式遍历，forwardPass是以队列的形式遍历。

2.对状态还原的时候，backwardPass 是不可见方向还原，也就是上图的粉色箭头方向，forwardPass 是以可见方向还原，也就是上图的 青绿色箭头方向。

最后是通过ObserverWithState 的 dispatchEvent 方法 进行了分发。

最后是怎样通知到我们对应的观察者对象的呢？

ObserverWithState 在上文有提到，是对观察者对象和状态进行了一个包装，在这里我们来详细看一下。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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 = event.getTargetState();
        mState = min(mState, newState);
        mLifecycleObserver.onStateChanged(owner, event);
        mState = newState;
    }
}

我们先看包装的时候的操作，是执行了一个 Lifecycling.lifecycleEventObserver(observer) 操作。

1
2
3
4
5
6
7
8
9
10
11
    static LifecycleEventObserver lifecycleEventObserver(Object object) {
        boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
        boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
        if (isLifecycleEventObserver && isFullLifecycleObserver) {
            return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,
                    (LifecycleEventObserver) object);
        }
        if (isFullLifecycleObserver) {
            return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
        }
}

是返回一个对应类型 的实例化对象 ，我们自定义的观察者，实现的是DefaultLifecycleObserver 接口，DefaultLifecycleObserver接口又继承了FullLifecycleObserver ，所以这里会新建一个 FullLifecycleObserverAdapter 对象，并返回，

再看 ObserverWithState 的 dispatchEvent 操作,调用了 onStateChanged 方法，然后就会调用到 FullLifecycleObserverAdapter 的 onStateChanged 里面

在这里面 就是进行接口回调，然后我们的观察者就可以接收到生命周期的回调了。

分析到这里，我们就可以将整个添加观察者，对应生命周期时间分发的过程全部联系起来了。

参考：Lifecycle原理解析，人人都能看得懂！🔗