LifeCycle 完全指南：实践与背后原理全解

captain_p
115 阅读13分钟

引言

在Android开发中，理解并正确处理应用的生命周期是至关重要的。Lifecycle组件作为Android架构组件的一部分，为开发者提供了一套工具，以更简洁的方式管理UI控制器（如Activity和Fragment）的生命周期和数据。本文旨在深入探讨Lifecycle的概念，分析其优缺点，提供实际的代码示例，并通过生活中的比喻帮助读者更好地理解和应用这一重要的架构组件。

好的，我们将继续撰写有关Android Lifecycle的完整博客。下面是接下来的几个部分。

一、引入Lifecycle的原因

在Android开发中，处理Activity和Fragment的生命周期一直是一个挑战。传统的开发方式要求开发者在每个生命周期回调中插入管理逻辑，这不仅容易出错，也使得代码难以管理和维护。引入Lifecycle架构的原因主要包括：

  • 提升应用稳定性与性能：通过标准化生命周期管理，Lifecycle减少了因错误处理生命周期事件而引发的崩溃和内存泄漏。
  • 简化代码管理：Lifecycle允许开发者将生命周期管理逻辑外包给框架处理，从而简化了代码并提高了可维护性。
  • 更好的资源管理：Lifecycle组件能够精确控制组件何时注册监听器，何时释放资源，从而有效地防止内存泄漏和其他资源问题。

解决的痛点

Lifecycle组件的引入，主要解决以下几个常见的开发痛点：

  • 防止内存泄漏：开发者经常会遇到因为持有过期的Context或者未及时取消注册的监听器导致的内存泄漏问题。Lifecycle通过自动管理这些问题，极大地减少了内存泄漏的风险。
  • 管理资源使用：Lifecycle确保在组件不可见时不执行不必要的操作（如数据更新或动画），从而优化应用的性能。
  • 应对配置更改：如屏幕旋转时，Activity需要重建，使用Lifecycle可以更容易地保存和恢复数据。

Lifecycle的优缺点分析

优点

  1. 自动管理生命周期：Lifecycle可以自动调用清理代码，开发者无需手动插入。
  2. 简化开发：使得代码更加整洁，专注于业务逻辑而非生命周期控制。
  3. 提高应用的健壮性：减少由于生命周期错误管理导致的崩溃。

缺点

  1. 学习曲线：初学者需要时间来理解和适应Lifecycle的使用。
  2. 可能的过度设计：在一些简单的应用场景中，使用Lifecycle可能会让项目变得过于复杂。

二、在Android中的具体使用

Lifecycle组件的使用主要集中在对Activity和Fragment的生命周期事件进行监听和响应。通过实现LifecycleObserver接口，并使用@OnLifecycleEvent注解，开发者可以创建能够响应生命周期变化的组件。这些组件将自动接收如onCreate、onStart、onResume等生命周期事件的通知。

具体代码示例

public class MyObserver implements LifecycleObserver {
    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    public void onStart() {
        // 组件可见时执行的操作
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    public void onStop() {
        // 组件不可见时执行的操作
    }
}

public class MyActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        getLifecycle().addObserver(new MyObserver());
    }
}

三、生活实例与知识点建模

将Lifecycle比作一个智能家居系统可以帮助理解其工作原理。就像智能家居系统根据屋主是否在家自动调节温度和 照明一样，Lifecycle根据组件是否处于活动状态自动管理资源和任务。

四、源码分析

Lifecycle组件内部通过使用一个精简且高效的观察者模式，监控Activity和Fragment的生命周期事件。核心类是LifecycleRegistry，它持有观察者的引用并在生命周期事件发生时通知它们。

Lifecycle的原理分析的前置准备

在分析 Lifecycle 源码之前，我们必须先对几个重要的类有感性的认识，方便下面看源码！

4.1.LifecycleOwner

public interface LifecycleOwner {
    /**
     * Returns the Lifecycle of the provider.
     *
     * @return The lifecycle of the provider.
     */
    @NonNull
    Lifecycle getLifecycle();
}

生命周期持有者，返回一个Lifecycle对象，如果你使用的是 AndroidX（也属于 Jetpack 一部分）在这Activity 、Fragment 两个类中，默认实现了 LifecycleOwner 接口

我贴下代码：

下面都是简化后的代码

public class ComponentActivity extends androidx.core.app.ComponentActivity implements LifecycleOwner,XXX {

	private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }

}

public class Fragment implements LifecycleOwner,XXX {

	private final LifecycleRegistry mLifecycleRegistry;

    public Fragment() {
        initLifecycle();
    }

    private void initLifecycle() {
        mLifecycleRegistry = new LifecycleRegistry(this);
        //....
    }

    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }

}

可以看到我们 Activity 和 Fragment 中默认实现了

可以看到在 ComponentActivity 和 Fragment类默认实现了 LifecycleOwner 接口，并在中 getLifecycle()方法返回的是LifecycleRegistry对象，此时 Activity 和 Fragment类中分别持有了 Lifecycle

我们先看下 Lifecycle 类是什么

4.2.Lifecycle

public abstract class Lifecycle {

    @MainThread
    public abstract void addObserver(@NonNull LifecycleObserver observer);

    @MainThread
    public abstract void removeObserver(@NonNull LifecycleObserver observer);

    @MainThread
    @NonNull
    public abstract State getCurrentState();

    public enum Event {
        
    }
    public enum State {
       
    }
}

在Lifecycle类中定义了添加观察者和移除观察者的方法，并定义了两个枚举类，这两个类等一下再具体说

LifecycleRegistry类是对Lifecycle这个抽象类的具体实现，可以处理多个观察者，如果你自定义 LifecycleOwner可以直接使用它。

说完了被观察者，接下来看下观察者LifecycleObserver

4.3.LifecycleObserver

public interface LifecycleObserver {

}

就是一个简单的接口，这个接口只是来标志这个是对Lifecycle的观察者，内部没有任何方法，全部都依赖于OnLifecycleEvent注解

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface OnLifecycleEvent {
    Lifecycle.Event value();
}

注解的值是一个 Lifecycle.Event 也就是 4.2小节没有看的那两个枚举中的一个，接下来去看下Lifecycle中的两个枚举类。

4.4.Lifecycle.Event和Lifecycle.State

public abstract class Lifecycle {

    public enum Event {
        ON_CREATE,
        ON_START,
        ON_RESUME,
        ON_PAUSE,
        ON_STOP,
        ON_DESTROY,
        ON_ANY
    }

    public enum State {
        DESTROYED,
        INITIALIZED,
        CREATED,
        STARTED,
        RESUMED;
        public boolean isAtLeast(@NonNull State state) {
            return compareTo(state) >= 0;
        }
    }
}

Event：定一个一些枚举常量，和 Activity、Fragment 的生命周期是一一对应的，可以响应其生命周期，其中多了一个ON_ANY，它是可以匹配任何事件的，Event 的使用是和 LifecycleObserver 配合使用的，

* class TestObserver implements LifecycleObserver {
*   @OnLifecycleEvent(ON_STOP)
*   void onStopped() {}
* }

State：当前Lifecycle的自己的目前的状态，它是和Event配合使用的

Event和State之间的关系

如下图

转存失败，建议直接上传图片文件

4.5 总结

  • LifecycleOwner：可获取Lifecycle的接口，可以再 Activity、Fragment生命周期改变时，通过LifecycleRegistry类处理对应的生命周期事件，并通知 LifecycleObserver这个观察者
  • Lifecycle：是被观察者，用于存储有关组件（如 Activity 或 Fragment）的生命周期状态的信息，并允许其他对象观察此状态。
  • LifecycleObserver：观察者，可以通过被LifecycleRegistry类通过 addObserver(LifecycleObserver o)方法注册,被注册后，LifecycleObserver便可以观察到LifecycleOwner对应的生命周期事件
  • Lifecycle.Event：分派的生命周期事件。这些事件映射到 Activity 和 Fragment 中的回调事件。
  • Lifecycle.State：Lifecycle组件的当前状态。

了解上面的基本内容，就进行具体的源码分析，通过看源码，就能知道整个流程了。

5.Lifecycle的源码解析

5.1.分析的入口BaseActivity

在基类BaseActivity中的一行代码就能实现对应生命周期的回调

open class BaseActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        lifecycle.addObserver(ActivityLifecycleObserver())//1
    }
}

我们先看下getLifecycle() 方法，然后在看addObserver(ActivityLifecycleObserver())的内容，注意这时候分成两步了，我们先看getLifecycle()

我们点进去这个getLifecycle()方法

5.2.ComponentActivity 类

然后我们来到了ComponentActivity中，代码如下

public class ComponentActivity extends xxx implements LifecycleOwner,xxx {//1

	private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);//2

	@Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        ReportFragment.injectIfNeededIn(this);//4
        
    }

    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;//3
    }

}

是不是很熟悉因为，之前我们在 4.1 小节已经看到过了，这里看下重点，在onCreate方法中有一行代码ReportFragment.injectIfNeededIn(this);

**注释4：**在onCreate方法中，看到初始化了一个ReportFragment，接下来看一下ReportFragment的源码

5.3.ReportFragment 类

public class ReportFragment extends 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);
        // just want to be sure that we won't leak reference to an activity
        mProcessListener = null;
    }

    private void dispatch(Lifecycle.Event event) {
        Activity activity = getActivity();
      	//1
        if (activity instanceof LifecycleRegistryOwner) {
            ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
            return;
        }
				//2
        if (activity instanceof LifecycleOwner) {
            Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
            if (lifecycle instanceof LifecycleRegistry) {
                ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
            }
        }
    }
}

可以看到在 ReportFragment 中的各个生命周期都调用了dispatch(Lifecycle.Event event) 方法，传递了不同的Event的值，这个就是在Activity、Fragment的各个生命周期回调时，Lifecycle 所要处理的生命周期方法。

在**dispatch(Lifecycle.Event event)**方法中最终调用了((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);方法

看到这儿，还记得咱们在第 3 节的疑问吗？到这儿就可以解答前两个问题了

1.Lifecycle是怎样感知生命周期的？

就是在ReportFragment中的各个生命周期都调用了dispatch(Lifecycle.Event event) 方法，传递了不同的Event的值

2.Lifecycle是如何处理生命周期的？

通过调用了((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);方法，也就是LifecycleRegistry 类来处理这些生命周期。

此时，就应该看 LifecycleRegistry 的 handleLifecycleEvent 方法中的代码了

5.4.LifecycleRegistry 的 handleLifecycleEvent 方法

//LifecycleRegistry.java
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
    State next = getStateAfter(event);
    moveToState(next);
}

根据当前Lifecycle.Event的值，其实也就是 Activity、Fragment 生命周期回调的值，来获取下一个 Lifecycle.State 的状态，也就是 Lifecycle 将要到什么状态

//LifecycleRegistry.java
static State getStateAfter(Event event) {
    switch (event) {
        case ON_CREATE:
        case ON_STOP:
            return CREATED;
        case ON_START:
        case ON_PAUSE:
            return STARTED;
        case ON_RESUME:
            return RESUMED;
        case ON_DESTROY:
            return DESTROYED;
        case ON_ANY:
            break;
    }
    throw new IllegalArgumentException("Unexpected event value " + event);
}

image.png

不同的 Lifecycle.Event 的生命周期状态对 Lifecycle.State 的当前状态的取值。

继续跟代码，看下当到下一个状态时，要发生什么事情

//LifecycleRegistry.java
private void moveToState(State next) {
    if (mState == next) {
        return;
    }
    mState = next;
    if (mHandlingEvent || mAddingObserverCounter != 0) {
        mNewEventOccurred = true;
        return;
    }
    mHandlingEvent = true;
    sync();//1
    mHandlingEvent = false;
}

注释1： sync()方法

然后看 LifecycleRegistry 的 sync 方法

//LifecycleRegistry.java
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;
        // no need to check eldest for nullability, because isSynced does it for us.
        if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
            backwardPass(lifecycleOwner);//1
        }
        Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
        if (!mNewEventOccurred && newest != null
                && mState.compareTo(newest.getValue().mState) > 0) {
            forwardPass(lifecycleOwner);//2
        }
    }
    mNewEventOccurred = false;
}

如果没有同步过，会比较mState当前的状态和mObserverMap中的eldest和newest的状态做对比，看是往前还是往后；比如mState由STARTED到RESUMED是状态向前，反过来就是状态向后。这个是和 Lifecycle 生命周期有关系，但不是一个东西，具体的看上面贴的图，一目了然！

注释2：往后这里看下往后的代码forwardPass(lifecycleOwner);

然后看 LifecycleRegistry 的 forwardPass 方法

//LifecycleRegistry.java
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()；//1
        while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
                && mObserverMap.contains(entry.getKey()))) {
            pushParentState(observer.mState);
            observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));//2
            popParentState();
        }
    }
}

注释1：获取 ObserverWithState 实例

注释2：调用 ObserverWithState 的 dispatchEvent 方法

接下来看下ObserverWithState的代码

6.ObserverWithState

这个类名很直接，观察者并且带着 State，

//ObserverWithState.java
static class ObserverWithState {
    State mState;
    LifecycleEventObserver mLifecycleObserver;

    ObserverWithState(LifecycleObserver observer, State initialState) {
        mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);//1
        mState = initialState;
    }

    void dispatchEvent(LifecycleOwner owner, Event event) {
        State newState = getStateAfter(event);
        mState = min(mState, newState);
        mLifecycleObserver.onStateChanged(owner, event);//2
        mState = newState;
    }
}

在看dispatchEvent方法之前，先看下构造，ObserverWithState 是怎么初始化的？这里提一句，是在Lifecycle.addObserver(@NonNull LifecycleObserver observer);方法时候初始化的。

也就是 lifecycle.addObserver(ActivityLifecycleObserver())

open class BaseActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        lifecycle.addObserver(ActivityLifecycleObserver())
    }
}

在这里初始化的。

ObserverWithState 内部包括了 State 和 LifecycleEventObserver，LifecycleEventObserver 是一个接口，它继承了 LifecycleObserver 接口。

注释1：mLifecycleObserver这个的获取的实例其实是ReflectiveGenericLifecycleObserver，具体的点进去看一眼就明白了，我就不贴代码了，但是得注意在实例化 ReflectiveGenericLifecycleObserver(object);时候把LifecycleObserver，传入ReflectiveGenericLifecycleObserver的构造中了，此时ReflectiveGenericLifecycleObserver持有LifecycleObserver的实例

注释2：关键代码 mLifecycleObserver.onStateChanged(owner, event)，这里其实调用的是ReflectiveGenericLifecycleObserver的onStateChanged方法

接下来看下 ReflectiveGenericLifecycleObserver 的 onStateChanged 方法

7.ReflectiveGenericLifecycleObserver

//ReflectiveGenericLifecycleObserver.java
class ReflectiveGenericLifecycleObserver implements LifecycleEventObserver {
    private final Object mWrapped;
    private final CallbackInfo mInfo;

    ReflectiveGenericLifecycleObserver(Object wrapped) {
        mWrapped = wrapped;//LifecycleObserver的实例
        mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());//1
    }

    @Override
    public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Event event) {
        mInfo.invokeCallbacks(source, event, mWrapped);//2
    }
}

mWrapped其实是LifecycleObserver的实例

注释 1：接下来看mInfo的初始化过程，这个是最关键的代码了

注意注意注意，此时我们要兵分两路先看注释 1 的代码，此时注释 2 的代码是被回调的代码

8.ClassesInfoCache 的 getInfo 方法

//ClassesInfoCache.java
CallbackInfo getInfo(Class<?> klass) {
    CallbackInfo existing = mCallbackMap.get(klass);
    if (existing != null) {
        return existing;
    }
    existing = createInfo(klass, null);//1
    return existing;
}

这个klass是LifecycleObserver的字节码文件对象（LifecycleObserver.class）字节码？反射的味道，没错继续看下去马上就有结果了。

继续跟代码

private CallbackInfo createInfo(Class<?> klass, @Nullable Method[] declaredMethods) {
   ...
     //1
    Method[] methods = declaredMethods != null ? declaredMethods : getDeclaredMethods(klass);
    boolean hasLifecycleMethods = false;
    for (Method method : methods) {
      //2
        OnLifecycleEvent annotation = method.getAnnotation(OnLifecycleEvent.class);
        if (annotation == null) {
            continue;
        }
        hasLifecycleMethods = true;
      
        Class<?>[] params = method.getParameterTypes();
        int callType = CALL_TYPE_NO_ARG;
        if (params.length > 0) {
            callType = CALL_TYPE_PROVIDER;
            if (!params[0].isAssignableFrom(LifecycleOwner.class)) {
                throw new IllegalArgumentException(
                        "invalid parameter type. Must be one and instanceof LifecycleOwner");
            }
        }
      //3
        Lifecycle.Event event = annotation.value();
			//4
        if (params.length > 1) {
            callType = CALL_TYPE_PROVIDER_WITH_EVENT;
            if (!params[1].isAssignableFrom(Lifecycle.Event.class)) {
                throw new IllegalArgumentException(
                        "invalid parameter type. second arg must be an event");
            }
            if (event != Lifecycle.Event.ON_ANY) {
                throw new IllegalArgumentException(
                        "Second arg is supported only for ON_ANY value");
            }
        }
        if (params.length > 2) {
            throw new IllegalArgumentException("cannot have more than 2 params");
        }
      //5
        MethodReference methodReference = new MethodReference(callType, method);
        verifyAndPutHandler(handlerToEvent, methodReference, event, klass);
    }
    CallbackInfo info = new CallbackInfo(handlerToEvent);
    mCallbackMap.put(klass, info);
    mHasLifecycleMethods.put(klass, hasLifecycleMethods);
    return info;
}

上面代码比较长，但都有用其实就是反射获取方法获取注解值的过程，我们挨个看

注释1：获取LifecycleObserver.class 声明的方法，也即是我们例子中ILifecycleObserver接口中声明的方法

注释2：遍历方法，获取方法上声明的OnLifecycleEvent注解

注释3：获取OnLifecycleEvent注解上的value

注释4：给callType = CALL_TYPE_PROVIDER_WITH_EVENT 赋值

注释5：把callType和当前的method 存储到 MethodReference 中，方便接下来取用

看一下MethodReference中的代码

//MethodReference.java
static class MethodReference {
    final int mCallType;
    final Method mMethod;

    MethodReference(int callType, Method method) {
        mCallType = callType;
        mMethod = method;
        mMethod.setAccessible(true);
    }
}

好的，以上的mInfo 赋值的问题就看完了

当初在第 7 节在看注释 1 的代码是兵分两路了，现在继续看第 7 节注释 2 的代码吧

也即是就是mInfo的invokeCallbacks方法

继续看ClassesInfoCache的invokeCallbacks方法

点进去来到了 ClassesInfoCache 的 invokeCallbacks方法中

//ClassesInfoCache.java
void invokeCallbacks(LifecycleOwner source, Lifecycle.Event event, Object target) {
    invokeMethodsForEvent(mEventToHandlers.get(event), source, event, target);
    invokeMethodsForEvent(mEventToHandlers.get(Lifecycle.Event.ON_ANY), source, event,
            target);//ON_ANY也会调用
}

private static void invokeMethodsForEvent(List<MethodReference> handlers,
        LifecycleOwner source, Lifecycle.Event event, Object mWrapped) {
    if (handlers != null) {
        for (int i = handlers.size() - 1; i >= 0; i--) {
            handlers.get(i).invokeCallback(source, event, mWrapped);//1
        }
    }
}

注释 1：继续看MethodReference 的invokeCallback方法

//MethodReference.java
void invokeCallback(LifecycleOwner source, Lifecycle.Event event, Object target) {
    //noinspection TryWithIdenticalCatches
    try {
        switch (mCallType) {
            case CALL_TYPE_NO_ARG:
                mMethod.invoke(target);
                break;
            case CALL_TYPE_PROVIDER:
                mMethod.invoke(target, source);
                break;
            case CALL_TYPE_PROVIDER_WITH_EVENT://1
                mMethod.invoke(target, source, event);
                break;
        }
    } catch (InvocationTargetException e) {
        throw new RuntimeException("Failed to call observer method", e.getCause());
    } catch (IllegalAccessException e) {
        throw new RuntimeException(e);
    }
}

看到最后是用反射调用了mMethod.invoke(target);这里的target就是LifecycleObserver之前解释过了

mCallType和mMethod的值分别是什么呢？就是在前面初始化mInfo存的值，再看下源码

static class MethodReference {
    final int mCallType;
    final Method mMethod;

    MethodReference(int callType, Method method) {
        mCallType = callType;
        mMethod = method;
        mMethod.setAccessible(true);
    }

    void invokeCallback(LifecycleOwner source, Lifecycle.Event event, Object target) {
        //noinspection TryWithIdenticalCatches
        try {
            switch (mCallType) {
                case CALL_TYPE_NO_ARG:
                    mMethod.invoke(target);
                    break;
                case CALL_TYPE_PROVIDER:
                    mMethod.invoke(target, source);
                    break;
                case CALL_TYPE_PROVIDER_WITH_EVENT:
                    mMethod.invoke(target, source, event);
                    break;
            }
        } catch (InvocationTargetException e) {
            throw new RuntimeException("Failed to call observer method", e.getCause());
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }
}

由前面分析可以知道mCallType = CALL_TYPE_PROVIDER_WITH_EVENT，mMethod就是当时遍历时当前的方法

由于之前通过Map存储过，所以invokeCallback会被遍历调用，最终会反射调用对方法和注解。

当然其他mCallType的值也会被反射调用

9.总结

在来回顾当初抛出的问题

1.Lifecycle是怎样感知生命周期的？

就是在ReportFragment中的各个生命周期都调用了dispatch(Lifecycle.Event event) 方法，传递了不同的Event的值

2.Lifecycle是如何处理生命周期的？

通过调用了((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);方法，也就是LifecycleRegistry 类来处理这些生命周期。

3.LifecycleObserver的方法是怎么回调是的呢？

LifecycleRegistry 的 handleLifecycleEvent方法，然后会通过层层调用最后通过反射到LifecycleObserver方法上的@OnLifecycleEvent(Lifecycle.Event.XXX)注解值，来调用对应的方法

4.为什么LifecycleObserver可以感知到Activity的生命周期

LifecycleRegistry调用handleLifecycleEvent方法时会传递Event类型，然后会通过层层调用，最后是通过反射获取注解的值，到LifecycleObserver方法上的@OnLifecycleEvent(Lifecycle.Event.XXX)注解上对应的Event的值，注意这个值是和Activity/Fragment的生命周期的一一对应的，所以就可以感知Activity、Fragment的生命周期了。

avatar
文章
阅读
粉丝