推荐阅读
heiyulong，公众号：Android进化之路Jetpack架构组件库-Lifecycle应用解析之知其然
前言
==本次主要讲解的内容：==
1、Fragment 是如何实现 Lifecycle 的
2、Activity 是如何实现 Lifecycle 的
3、Lifecycle 是如何分发状态的
一、Fragment 是如何实现 Lifecycle 的
使用 Fragment 实现 Lifecycle 需要在各个生命周期方法内利用LifecycleRegistry分发相应的事件给每个观察者，以实现生命周期观察的能力：
1、查看Fragment中getLifecycle()方法关联源码：
LifecycleOwner：Androidx中 Activity/Fragment 都实现了该接口，用以声明它是一个能够提供生命周期事件的宿主。同时必须复写getLifecycle()方法提供一个Lifecycle对象；
//LifecycleOwner源码
public interface LifecycleOwner {
/**
* Returns the Lifecycle of the provider.
*
* @return The lifecycle of the provider.
*/
@NonNull
Lifecycle getLifecycle();
}
//Fragment 实现了 LifecycleOwner
public class Fragment implements LifecycleOwner {
//...
LifecycleRegistry mLifecycleRegistry;
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
//通过LifecycleRegistry分发fragment的状态
void performCreate(Bundle savedInstanceState) {
//...
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
}
void performStart() {
//...
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
}
void performResume() {
//...
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
}
void performPause() {
//...
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
}
void performStop() {
//...
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
}
void performDestroy() {
//...
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY);
}
//...
}
2、查看LifecycleRegistry的父类是Lifecycle的源码：
Lifecycle：是一个抽象类，里面定义了两个枚举State宿主的状态，Event 需要分发的事件的类型；
public abstract class Lifecycle {
AtomicReference<Object> mInternalScopeRef = new AtomicReference<>();
@MainThread
public abstract void addObserver(@NonNull LifecycleObserver observer);
@MainThread
public abstract void removeObserver(@NonNull LifecycleObserver observer);
@MainThread
@NonNull
public abstract State getCurrentState();
//需要分发的事件的类型
@SuppressWarnings("WeakerAccess")
public enum Event {
/**
* Constant for onCreate event of the {@link LifecycleOwner}.
*/
ON_CREATE,
/**
* Constant for onStart event of the {@link LifecycleOwner}.
*/
ON_START,
/**
* Constant for onResume event of the {@link LifecycleOwner}.
*/
ON_RESUME,
/**
* Constant for onPause event of the {@link LifecycleOwner}.
*/
ON_PAUSE,
/**
* Constant for onStop event of the {@link LifecycleOwner}.
*/
ON_STOP,
/**
* Constant for onDestroy event of the {@link LifecycleOwner}.
*/
ON_DESTROY,
/**
* An {@link Event Event} constant that can be used to match all events.
*/
ON_ANY
}
//宿主的状态
@SuppressWarnings("WeakerAccess")
public enum State {
DESTROYED,
INITIALIZED,
CREATED,
STARTED,
RESUMED;
public boolean isAtLeast(@NonNull State state) {
return compareTo(state) >= 0;
}
}
}
3、再来查看LifecycleRegistry源码
LifecycleRegistry: 是 Lifecycle 的唯一实现类，主要用来负责注册 Observer，并分发宿主状态事件给注册的Observer。
如上个文章中提到的Lifecycle的三种写法的LifecycleObserver、FullLifecyclerObserver、LifecycleEventObserver就是在这里注册的，然后通过 ObserverWithState类回调你的Observer中的方法的。
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()) {
...
backwardPass(lifecycleOwner);
forwardPass(lifecycleOwner);
}
}
private void backwardPass(LifecycleOwner lifecycleOwner) {
ObserverWithState observer = entry.getValue();
while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
&& mObserverMap.contains(entry.getKey()))) {
//通过ObserverWithState来回调你定义的observer中的状态方法
observer.dispatchEvent(lifecycleOwner, event);
}
}
}
static class ObserverWithState {
State mState;
LifecycleEventObserver mLifecycleObserver;
//通过Lifecycling类区分是LifecycleObserver还是FullLifecyclerObserver进行回调
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);
//通过LifecycleEventObserver响应相关EVENT
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
}
二、Activity是如何实现Lifecycle的
Activity 实现 Lifecycle 需要借助于 ReportFragment 往 Activity 上添加一个 fragment 用以报告生命周期的变化。目的是为了兼顾不是继承自 AppCompactActivity 的场景， 同时也支持我们自定义 LifecycleOwner 的场景。
1、查看AppCompatActivity类的父类ComponentActivity：
public class ComponentActivity extends Activity implements LifecycleOwner,
KeyEventDispatcher.Component {
//...
private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
//通过ReportFragment往Activity上添加一个fragment,用以报告生命周期的变化
//目的是为了兼顾不是继承自AppCompactActivity的场景.
ReportFragment.injectIfNeededIn(this);
}
@Override
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
//...
}
2、查看ReportFragment相关源码
public class ReportFragment extends Fragment {
public static void injectIfNeededIn(Activity activity) {
android.app.FragmentManager manager = activity.getFragmentManager();
if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
//往Activity上添加一个fragment,用以报告生命周期的变化
manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
}
}
//触发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 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);
mProcessListener = null;
}
private void dispatch(@NonNull Lifecycle.Event event) {
if (Build.VERSION.SDK_INT < 29) {
dispatch(getActivity(), event);
}
}
static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
//在这里触发LifecycleRegistry类的handleLifecycleEvent方法
//发LifecycleRegistry类上面已有介绍
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);
}
}
}
}
三、Lifecycle 是如何分发状态的
如上分析：
1、添加 observer 时，完整的生命周期事件分发
基于 Lifecycle 的特性我们在任意生命周期方法内注册观察者都能接收到完成的生命周期事件，比如在onResume 中注册一个观察者它会依次收到：
LifecycleEvent.onCreate -> LifecycleEvent.onStart -> LifecycleEvent.onResume
2、添加observer时完整的生命周期事件分发源码分析
public void addObserver(@NonNull LifecycleObserver observer) {
//添加新的Observer时，会首先根据宿主的状态计算出它的初始状态，只要不是在onDestroy中注册的，它的初始状态都是INITIALIZED
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
//接着会把observer包装成ObserverWithState，这个类主要是包含了观察者及其状态。每个事件都会经由这个对象类转发,这个类后面会来分析
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
//添加到集合，如果之前已经添加过了，则return
ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
if (previous != null) {
return;
}
State targetState = calculateTargetState(observer);
//这里的while循环，是实现上图状态同步与事件分发的主要逻辑
//拿观察者的状态和宿主当前状态做比较，如果小于0，说明两者状态还没有对齐。
while ((statefulObserver.mState.compareTo(targetState) < 0
&& mObserverMap.contains(observer))) {
pushParentState(statefulObserver.mState);
//接着就会分发一次相应的事件，于此同时statefulObserver的mState对象也会被升级
//假设是在宿主的onresume方法内注册的该观察者
//第一次：分发on_Create事件，观察者状态INIT->CREATED
//第二次：分发on_Start事件，观察者状态CREATED->STARTED
//第三次：分发on_Resume事件，观察者状态STARTED->RESUMED
statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
//再一次计算观察者应该到达的状态，在下一轮循环中和宿主状态在做比较，知道两者状态对齐，退出循环。
targetState = calculateTargetState(observer);
}
}
3、通过LifecycleRegistry源码在分析下宿主生命周期变化后相应事件的分发
public class LifecycleRegistry extends Lifecycle {
public void handleLifecycleEvent(@NonNull Lifecycle.Event event){
//宿主的每个生命周期的变化都会分发一个对应的Lifecycle.Event，走到这里
//此时会根据需要分发的事件反推出 宿主当前的状态
State next = getStateAfter(event);
moveToState(next);
}
// moveToState方法只是将传入的宿主新的state和前持有宿主状态作比对，然后保存一下。
//如果宿主状态有变动，则调用sync方法来完成事件的分发和观察者状态的同步
private void sync() {
while (!isSynced()) {
//如果宿主当前状态 小于 mObserverMap集合中最先添加的那个观察者的状态
//则说明宿主可能发生了状态回退，比如当前是RESUMED状态，执行了onPause则回退到STARTED状态
//此时调用backwardPass把集合中的每个一观察者分发一个on_pause事件，并同步它的状态。
if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
backwardPass(lifecycleOwner);
}
//如果宿主当前状态 大于 mObserverMap集合中最先添加的那个观察者的状态
//则说明宿主可能发生了状态前进，比如当前是STARTED状态，执行了onResume则前进到RESUMED状态
//此时调用forwardPass把集合中的每个一观察者分发一个on_resume事件，并同步它的状态。
Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
if (!mNewEventOccurred && newest != null
&& mState.compareTo(newest.getValue().mState) > 0) {
forwardPass(lifecycleOwner);
}
}
}
}
如下图说明了提供生命周期感知的关键元素之间的关系：
总结：
整个 Lifecycle 中有几个重要的类：
1、Lifecycle 抽象类，定义了一些操作LifecycleObserver 的抽象方法，以及代表生命周期的State、Event枚举类。
2、LifecycleObserver接口，内部没有定义任何方法，通过Lifecycle.addObserver()可以注册监听生命周期变化，以注释的方法声明监听。
3、LifecycleOwner 接口，该接口是由生命周期宿主（activity / fragment）实现的，只有一个Lifecycle getLifecycle() 方法。
4、LifecycleRegistry 类，它是 Lifecycle的子类，其内部定义了具体的实现细节，默认情况下，一个宿主实现了 LifecycleOwner 接口后就应该在其内部声明一个LifecycleRegistry ，并在自己的生命周期回调方法中为其设置各种状态。
Jetpack架构组件库中的LiveData、ViewModel都是基Lifecycle来实现的！
< END >
【Android进化之路】
微信扫描二维码，关注我的公众号。
1532
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
