问题：
- LifeCycle怎么绑定Activity/Fragment？
- LifeCycle怎么监听Activity/Fragment生命周期？
下面我们带着问题一步步从基本使用到源码进行分析。
1. 定义：
LifeCycle 是一个类，用于存储有关组件（如 Activity 或 Fragment）的生命周期状态的信息，并允许其他对象观察此状态
2. 绑定生命周期
LifeCycle没有使用之前，我们监听Activity或Fragment生命周期一般都是下面这种形式：
先定义一个监听类：
class MyLifeCycleListener {
fun onStart() {
}
fun onStop() {
}
}
然后在Activity中使用这个类：
class MainActivity : AppCompatActivity() {
private lateinit var myLifeCycleListener:MyLifeCycleListener
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
myLifeCycleListener = MyLifeCycleListener()
}
override fun onStart() {
myLifeCycleListener.onStart()
super.onStart()
}
override fun onStop() {
myLifeCycleListener.onStart()
super.onStop()
}
}
最后在onStart和onStop方法调用对应的方法。
虽然上面看起来没问题，但在真实的应用中，会有太多管理界面和其他组件的调用，以响应生命周期的当前状态。在LifeCycle出来之后，我们再也不用手动在Activity或Fragment中去添加类似的代码。使用观察者设计模式绑定生命周期，观察生命周期状态。
基本使用
常用一般有三种写法。
第一种，实现LifecycleObserver接口：
class MyLifeCycleObserver : LifecycleObserver {
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
fun onCreate() {
}
@OnLifecycleEvent(Lifecycle.Event.ON_START)
fun onStart() {
}
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
fun onResume() {
}
@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
fun onPause() {
}
@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
fun onStop() {
}
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
fun onDestroy() {
}
}
第二种，实现DefaultLifecycleObserver接口
class MyDefaultLifeCycleObserver:DefaultLifecycleObserver {
override fun onCreate(owner: LifecycleOwner) {
super.onCreate(owner)
}
override fun onStart(owner: LifecycleOwner) {
super.onStart(owner)
}
override fun onResume(owner: LifecycleOwner) {
super.onResume(owner)
}
override fun onPause(owner: LifecycleOwner) {
super.onPause(owner)
}
override fun onStop(owner: LifecycleOwner) {
super.onStop(owner)
}
override fun onDestroy(owner: LifecycleOwner) {
super.onDestroy(owner)
}
}
第三种，实现LifecycleEventObserver接口
class MyLifecycleEventObserver:LifecycleEventObserver{
override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
when(event){
Lifecycle.Event.ON_START->{
}
Lifecycle.Event.ON_STOP->{
}
}
}
}
三种方式，在Activity和Fragment中绑定的方式一样。
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
lifecycle.addObserver(MyLifeCycleObserver())
lifecycle.addObserver(MyDefaultLifeCycleObserver())
lifecycle.addObserver(MyLifecycleEventObserver())
}
3. 绑定组件
在上面的示例中，我们调用了lifecycle.addObsever将观察者与Activity绑定一起，为什么要这么做，是如何绑定的？我们接着往下看。
首先我们看一下lifecycle是什么？
public class ComponentActivity extends androidx.core.app.ComponentActivity implements
ContextAware,
LifecycleOwner,
@NonNull
@Override
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
}
public interface LifecycleOwner {
/**
* Returns the Lifecycle of the provider.
*
* @return The lifecycle of the provider.
*/
@NonNull
Lifecycle getLifecycle();
}
我们通过分析MainActivity的父类ComponentActivity发现，lifecycle是调用了getLifecycle() 这个方法 返回的一个lifeCycle。而这个getLifecycle() 是接口LifecycleOwner中定义的方法，我们看到ComponentActivity实现了LifecycleOwner接口。我们再看一下Lifecycle。
public abstract class Lifecycle {
@MainThread
public abstract void addObserver(@NonNull LifecycleObserver observer);
@MainThread
public abstract void removeObserver(@NonNull LifecycleObserver observer);
........................
}
可以看出Lifecycle这个抽象类中的方法addObserver方法的参数正好是LifecycleObserver。而三种使用方式都是继承自LifecycleObserver接口，所以Activity作为LifecycleOwner接口的实现者，可以直接调用addObserver添加监听者。至此我们可以知道LifeCycle是怎么绑定Activity/Fragment的了。
4. 监听生命周期
Lifecycle使用两种主要枚举跟踪其关联组件的生命周期状态：
事件枚举 ON_CREATE，ON_START，ON_RESUME，ON_PAUSE，ON_STOP，ON_DESTROY，ON_ANY
从框架和 Lifecycle 类分派的生命周期事件。这些事件映射到 activity 和 fragment 中的回调事件。
状态枚举 DESTROYED，INITIALIZED，CREATED，STARTED，RESUMED
由 Lifecycle 对象跟踪的组件的当前状态。
其事件与状态之间的关系如下图所示:
从图中我们可以看出事件和状态之间的关系，当事件为前进事件ON_CREATE时，状态变成CREATE状态，当事件为回退事件ON_STOP时，对应的状态从STARTED变成CREATE。接下来我们进入源码。
首先我们从MainActivity的父类ComponentActivity的onCreate方法开始分析。
protected void onCreate(@Nullable Bundle savedInstanceState) {
// Restore the Saved State first so that it is available to
// OnContextAvailableListener instances
mSavedStateRegistryController.performRestore(savedInstanceState);
mContextAwareHelper.dispatchOnContextAvailable(this);
super.onCreate(savedInstanceState);
ReportFragment.injectIfNeededIn(this); //初始化 ReportFragment
if (mContentLayoutId != 0) {
setContentView(mContentLayoutId);
}
}
我们看到在ComponentActivity的onCreate方法中初始化了一个ReportFragment。这个ReportFragment有什么、作用？我们接着往下看。
public static void injectIfNeededIn(Activity activity) {
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) {
//将这个fragment注册到ComponentActivity中
manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG)
.commit();
manager.executePendingTransactions();
}
}
@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);
}
ReportFragment的生命周期方法中调用了dispatch方法。
static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
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);
}
}
}
dispatch将生命周期事件传给handleLifecycleEvent处理。
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
enforceMainThreadIfNeeded("handleLifecycleEvent");
//通过生命周期事件获取，目标状态，调用moveTostate方法进行状态更新
moveToState(event.getTargetState());
}
private void moveToState(State next) {
if (mState == next) { //如果当前lifeCycle的状态与下一个状态相同则不处理
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;
}
moveToState方法中首先判断lifecycle当前状态来决定是否进行状态同步 。
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.");
}
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;
}
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);
}
pushParentState(event.getTargetState());
//分发事件
observer.dispatchEvent(lifecycleOwner, event);
popParentState();
}
}
}
@Nullable
public static Event downFrom(@NonNull State state) {
switch (state) {
case CREATED:
return ON_DESTROY;
case STARTED:
return ON_STOP;
case RESUMED:
return ON_PAUSE;
default:
return null;
}
}
结合前面我们讲的事件Event和状态States的关系，我们很容易能理解downFrom方法，当状态为STARTED，回退一下对应的事件正好是ON_STOP，Android源码通过这样状态机的方式管理着状态与事件之间的关系。至于forwardPass这个方法，我们留给读者自己动手分析。至此Lifecycle的核心原理，我们就讲完了。
LifeCycle怎么监听Activity/Fragment生命周期，这个问题相信大家就能回答的上来，Lifecycle的难点在于事件与状态之间的关系的理解。大家根据文章多读几遍，动手画一遍流程图，相信大家很快都能明白。
