一、前言
Lifecycle 生命周期感知控件属于谷歌在2018推出Android jetpack(外网)其中的软件架构组件中的一个。在谷歌开发者网站有介绍Lifecycle(外网)。本文指在介绍Lifecycle的使用。让你快速理解并上手Lifecycle库。虽然Lifecycle很简单，但我们还是应该仔细品一品。因为jetpack中太多库依赖这种声明周期管理了。
二、Lifecycle
谷歌爸爸是这么说的：生命周期感知型组件可执行操作来响应另一个组件（如 Activity 和 Fragment）的生命周期状态的变化。这些组件有助于您写出更有条理且往往更精简的代码，这样的代码更易于维护。
简单理解下：把声明周期用观察者模式来监听。把以前跟声明周期相关操作代码提出来写。
在介绍Lifecycle的两种用法前，我们需要先导入。其它用法请参看Lifecycle 版本说明(外网)
// Lifecycles only (without ViewModel or LiveData)
implementation "androidx.lifecycle:lifecycle-runtime:$lifecycle_version"
基本使用
三个步骤就可以使用起来了，就是普通观察者模式的三个步骤。
1、创建一个被观察者Lifecycle对象
2、创建一个或多个观察者LifecycleObserver对象
3、Lifecycle.addObserver把一个或多个LifecycleObserver观察者添加
第一步：创建Lifecycle
public class MyActivity extends Activity implements LifecycleOwner {
private LifecycleRegistry mLifecycleRegistry;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mLifecycleRegistry = new LifecycleRegistry(this);
mLifecycleRegistry.markState(Lifecycle.State.CREATED);
}
@Override
protected void onStart() {
super.onStart();
mLifecycleRegistry.markState(Lifecycle.State.STARTED);
}
@Override
protected void onDestroy() {
super.onDestroy();
mLifecycleRegistry.markState(Lifecycle.State.DESTROYED);
}
@NonNull
@Override
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
}
- Lifecycle是一个抽象类，LifecycleRegistry就是它的一个具体实现
- LifecycleOwner接口，就定义了一个getLifecycle，方便获取被观察者。它存在的意义表示你的Activity或者Fragement具有Lifecycle特性。很多依赖Lifecycle的组件就是通过这里来判断的。
- mLifecycleRegistry.markState为了绑定状态，绑定了才好通知观察者
第二步：创建LifecycleObserver观察者
public class MyObserver implements LifecycleObserver {
@OnLifecycleEvent(Lifecycle.Event.ON_START)
public void start() {
}
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
public void destroy() {
}
}
- LifecycleObserver是一个空接口，目的是为了方便注解使用
第三步：添加观察者
mLifecycleRegistry.addObserver(new MyObserver());
if (mLifecycleRegistry.getCurrentState().isAtLeast(Lifecycle.State.STARTED)) {
// do...
}
- addObserver添加就能监听了
- getCurrentState().isAtLeast提供了状态的查询
State和Event对应关系
三个步骤就完了，比较简单。细心的同学发现了，我们mark的时候状态是Lifecycle.State。而在观察者状态是Lifecycle.Event那么他们的对应关系如下图：
关系图
常规情况
上面讲的用法是我们使用的普通的Activity，而实际开发的时候，我们经常使用的是MainActivity extends AppCompatActivity而AppCompatActivity已经默认为我们实现了Lifecycle。所以我们可以少些上面的第一步直接在MainActivity中使用getLifecycle()获取被观察者Lifecycle对象
再者如果你引用的是androidx中的Activity和Fragment他们也实现了Lifcycle的代码。
三、原理
对原理没兴趣的同学可以直接跳过这一节。
Lifecycle的运行机制也比较简单，无非就是观察者模式的惯用套路。我们也按步骤来解析
先看LifecycleRegistry.java
@Deprecated
@MainThread
public void markState(@NonNull State state) {
setCurrentState(state);
}
@MainThread
public void setCurrentState(@NonNull State state) {
moveToState(state);
}
private void moveToState(State next) {
...
sync();
...
}
private void sync() {
...
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<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
if (!mNewEventOccurred && newest != null
&& mState.compareTo(newest.getValue().mState) > 0) {
forwardPass(lifecycleOwner);
}
}
mNewEventOccurred = false;
}
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();
}
}
}
- 1.我们再Activity里调用martState的时候就是响应的时候
- 2.根据martState的调用顺序，最后走到了
backwardPass和forwardPass他们类似 - 3.在forwardPass里，它遍历了观察者，调用了观察者的dispatchEvent方法。
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;
}
}
- 这里主要两点
Lifecycling.lifecycleEventObserver和onStateChanged，而lifecycleEventObserver主要生成注解解析相关类
@NonNull
static LifecycleEventObserver lifecycleEventObserver(Object object) {
...
return new ReflectiveGenericLifecycleObserver(object);
}
class ReflectiveGenericLifecycleObserver implements LifecycleEventObserver {
private final Object mWrapped;
private final CallbackInfo mInfo;
ReflectiveGenericLifecycleObserver(Object wrapped) {
mWrapped = wrapped;
mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());
}
@Override
public void onStateChanged(LifecycleOwner source, Event event) {
mInfo.invokeCallbacks(source, event, mWrapped);
}
}
通过反射调用就响应到了我们的方法上。
四、写在最后
简单的来看，Lifecycle通过观察者模式独立了生命周期的感知功能。一者方便了我们独立的使用。二者也给一些需要生命周期感知的其它的组件提供了基础。还是挺有意思的一个组件。
