一、什么是Lifecycle
Lifecycle是Android Jetpack中的一个组件，用来感知Activity、Fragment生命周期状态的；它涉及到两个非常重要的类
- LifecycleRegistry：它是 Lifecycle 的唯一实现类。主要用来注册观察者（LifecycleObserver），以及分发宿主状态给它们（可以处理多个观察者）
- LifecycleOwner：用来声明它是一个能够提供生命周期事件的宿主，Activity/Fragment 都实现了该接口。内部只有一个 getLifecycle 方法。
二、怎样使用Lifecycle
1、让需要感知Activity/Fragment生命周期的类继承LifecycleEventObserver接口，然后在onStateChanged方法中处理与生命周期相关的一些逻辑
class MyObserver :LifecycleEventObserver{
override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
when(event){
Lifecycle.Event.ON_CREATE ->{ }
Lifecycle.Event.ON_RESUME->{ }
Lifecycle.Event.ON_START ->{ }
Lifecycle.Event.ON_PAUSE->{ }
Lifecycle.Event.ON_DESTROY->{ }
else->{}
}
}
}
2、在Activity或者Fragment的onCreate方法中调用lifecycle的addObserver方法，然后将该类的实例作为参数传入；
class MainActivity : AppCompatActivity() {
private lateinit var viewPager:ViewPager2
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
lifecycle.addObserver(MyObserver())
}
}
三、Lifecycle源码
首先我们从 lifecycle.addObserver方法调用看起。在Acitivity方法中通过getLifecycle方法获取lifecycle对象，该方法的内部实际上是返回的mLifecycleRegistry变量；
@NonNull
@Override
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
mLifecycleRegistry是LifecycleRegistry的实例对象，该类是继承至Lifecycle类，所以lifecycle.addObserver实际上调用的是LifecycleRegistry方法的addObserver方法；
private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
在addObserver方法中，首先将observe和initialState封装成ObserverWithState对象，然后保存到HashMap中,至此就将观察者对象存入到LifecycleRegistry对象内部维护的一个Map集合中；
public void addObserver(@NonNull LifecycleObserver observer) {
....
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
//封装observer和initialState
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
//将封装后的observer保存到Hashmap中
ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
....
}
private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap = new FastSafeIterableMap<>();
四、LifeCycle是怎么通知Map中的观察者的
在LifecycleRegistry对象的sync方法中，可以看到最终是调用了backwardPass/forwardPass方法；
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);
}
Map.Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
if (!mNewEventOccurred && newest !=null&&mState.compareTo(newest.getValue().mState)> 0) {
forwardPass(lifecycleOwner);
}
}
mNewEventOccurred = false;
}
比较难理解的可能是 backwardPass 和 forwardPass 两个方法。我们先来看下官方关于 Lifecycle 对生命周期 Event 和 State 的描述：
可以看出 init 和 destroy 状态是在 create、start、resume 状态之前的。
backwardPass 方法用于 “向后传递”，例如屏幕旋转或关闭页面的情况，在关闭页面之前的状态是 resume，那么关闭页面后，就要依次执行 onPause、onStop、onDestroy，对照上面的图来看，有一种 “往回走” 的感觉，所以叫做 backwardPass
forwardPass 方法用于 “向前传递”，比如打开一个新页面，会执行 onCreate、onStart、onResume，对照上面的图来看，就是一直往前走的感觉，所以叫做 forwardPass
private void backwardPass(LifecycleOwner lifecycleOwner) {
Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
mObserverMap.descendingIterator();
while (descendingIterator.hasNext() && !mNewEventOccurred) {
Map.Entry<LifecycleObserver, ObserverWithState> entry =
descendingIterator.next();
ObserverWithState observer = entry.getValue();
while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred && mObserverMap.contains(entry.getKey()))) {
Event event = Event.downFrom(observer.mState);
if (event == null) {
throw new IllegalStateException("no event down from " + observer.mState);
}
.....
observer.dispatchEvent(lifecycleOwner, event);
....
}
}
}
private void forwardPass(LifecycleOwner lifecycleOwner) {
Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =
mObserverMap.iteratorWithAdditions();
while (ascendingIterator.hasNext() && !mNewEventOccurred) {
Map.Entry<LifecycleObserver, ObserverWithState> entry =ascendingIterator.next();
ObserverWithState observer = entry.getValue();
while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred &&
mObserverMap.contains(entry.getKey()))) {
pushParentState(observer.mState);
final Event event = Event.upFrom(observer.mState);
if (event == null) {
throw new IllegalStateException("no event up from " + observer.mState);
}
observer.dispatchEvent(lifecycleOwner, event);
......
}
}
}
在forwardPass/backwardPass源码中，当有新的生命周期事件发生时，通过遍历Map集合取出观察者对象，调用其dispachEvent方法，dispachEvent方法内部又调用了observer对象的onStateChanged回调方法，至此完成生命周期方法的回调；
void dispatchEvent(LifecycleOwner owner, Event event) {
State newState = event.getTargetState();
mState = min(mState, newState);
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
五、Lifecycle怎么感知Activity/Fragment生命周期的呢？
实际上Activity是通过ReportFragment.injectIfNeededIn类方法在onCreate生命周期方法中往Activity中插入一个空的Fragment，然后在这个空的Fragment对象的生命周期方法中，来处理Activity生命周期事件的分发，从而实现生命周期的注入；
public static void injectIfNeededIn(Activity activity) {
//如果是Android10以上，则通过注册LifecycleCallbacks来实现生命周期的回调
if (Build.VERSION.SDK_INT >= 29) {
// On API 29+, we can register for the correct Lifecycle callbacks directly
LifecycleCallbacks.registerIn(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();
}
}
在Fragment生命周期方法中通过dispatch最终调用到lifecycle的handleLifecycleEvent方法
@Override
public void onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
....
dispatch(Lifecycle.Event.ON_CREATE);
}
@Override
public void onStart() {
super.onStart();
....
dispatch(Lifecycle.Event.ON_START);
}
@Override
public void onResume() {
super.onResume();
....
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);
....
}
private void dispatch(@NonNull Lifecycle.Event event) {
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);
}
}
而Lifecycle对象的handleLifecycleEvent经过层层调用，最终调用到sync方法，sync方法在上面已经分析过，至此整个Lifecycle生命周期感知及事件分发处理就完成了。
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
enforceMainThreadIfNeeded("handleLifecycleEvent");
moveToState(event.getTargetState());
}
private void moveToState(State next) {
.....
sync();
......
}
六、为什么要在Activity中插入一个空白的Fragment来处理Lifecycle生命周期事件的分发？
因为我们在创建Activity的时候有可能继承至不同的组件，比如有可能继承至AppCompatActivity和ComponentActivity，为了做到兼容，通过插入空白的Fragment来处理可以做到很好的代码复用；
