前言

为了响应具有生命周期的组件所发生的变化，一种常见的模式是在 Activity 和 Fragment 的生命周期方法中实现依赖组件的操作。

但是这样子会产生几个问题：

管理多个组件会在生命周期方法中放置大量的代码；
容易出现忘记取消注册的操作；

而 Lifecycle 是具有生命周期感知能力的组件。

基本用法

Lifecycle 使用两种主要枚举跟踪其关联组件的生命周期状态：

Events：从框架和 Lifecycle 类分派的生命周期事件。这些事件映射到 Activity 和 Fragment 中的回调事件。
States：由 Lifecycle 对象跟踪的组件的当前状态。

构成 Android Activity 生命周期的状态和事件.png

通过注解的方式举个简单例子：

class MyLifecycleObserver : LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun connect() {
        Log.e(TAG, "connect")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun disconnect() {
        Log.e(TAG, "disconnect")
    }

    companion object {
        private const val TAG = "lifecycle_observer_demo"
    }
}

// 将 Lifecycle 对象和 LifecycleObserver 对象进行绑定
LifecycleOwner.getLifecycle().addObserver(MyLifecycleObserver())
复制代码

关联接口

LifecycleOwner

// LifecycleOwner.java
// 具有Android生命周期的类。自定义组件可以使用这些事件来处理生命周期更改，而无需在Activity或Fragment中实现任何代码。
@SuppressWarnings({"WeakerAccess", "unused"})
public interface LifecycleOwner {
    
    @NonNull
    Lifecycle getLifecycle();
}
复制代码

LifecycleObserver

// LifecycleObserver.java
// 将一个类标记为LifecycleObserver。它没有任何方法，而是依赖于{@link OnLifecycleEvent}注解方法。
@SuppressWarnings("WeakerAccess")
public interface LifecycleObserver {

}
复制代码

LifecycleEventObserver

LifecycleEventObserver 可以获取哪个生命周期事件发生了变化

如果同时使用了 DefaultLifecycleObserver，会优先调用 DefaultLifecycleObserver 的对应方法；
如果同时使用了 OnLifecycleEvent 注解，将会忽略注解；

// LifecycleEventObserver.java
public interface LifecycleEventObserver extends LifecycleObserver {
    
    void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event);
}
复制代码

FullLifecycleObserver

注意：该修饰符为缺省访问修饰符

// FullLifecycleObserver.java
interface FullLifecycleObserver extends LifecycleObserver {

    void onCreate(LifecycleOwner owner);

    void onStart(LifecycleOwner owner);

    void onResume(LifecycleOwner owner);

    void onPause(LifecycleOwner owner);

    void onStop(LifecycleOwner owner);

    void onDestroy(LifecycleOwner owner);
}
复制代码

DefaultLifecycleObserver

DefaultLifecycleObserver 存在于 androidx.lifecycle:lifecycle-common-java8:xxx 这个依赖库内；

相比于注解的形式，官方推荐使用此方式来监听生命周期；
如果同时使用了 LifecycleEventObserver，会先调用 DefaultLifecycleObserver 的对应方法；
如果同时使用了 OnLifecycleEvent 注解，将会忽略注解；

// DefaultLifecycleObserver.java
@SuppressWarnings("unused")
public interface DefaultLifecycleObserver extends FullLifecycleObserver {

    // LifecycleOwner 的 onCreate 方法之后调用
    @Override
    default void onCreate(@NonNull LifecycleOwner owner) {
    }

    // LifecycleOwner 的 onStart 方法之后调用
    @Override
    default void onStart(@NonNull LifecycleOwner owner) {
    }

    // LifecycleOwner 的 onResume 方法之后调用
    @Override
    default void onResume(@NonNull LifecycleOwner owner) {
    }

    // LifecycleOwner 的 onPause 方法之前调用
    @Override
    default void onPause(@NonNull LifecycleOwner owner) {
    }

    // LifecycleOwner 的 onStop 方法之前调用
    @Override
    default void onStop(@NonNull LifecycleOwner owner) {
    }

    // LifecycleOwner 的 onDestroy 方法之前调用
    @Override
    default void onDestroy(@NonNull LifecycleOwner owner) {
    }
}
复制代码

FullLifecycleObserverAdapter

注意：该修饰符为缺省访问修饰符

// FullLifecycleObserverAdapter.java
class FullLifecycleObserverAdapter implements LifecycleEventObserver {

    private final FullLifecycleObserver mFullLifecycleObserver;
    private final LifecycleEventObserver mLifecycleEventObserver;

    FullLifecycleObserverAdapter(FullLifecycleObserver fullLifecycleObserver,
            LifecycleEventObserver lifecycleEventObserver) {
        mFullLifecycleObserver = fullLifecycleObserver;
        mLifecycleEventObserver = lifecycleEventObserver;
    }

    @Override
    public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {
        switch (event) {
            case ON_CREATE:
                mFullLifecycleObserver.onCreate(source);
                break;
            case ON_START:
                mFullLifecycleObserver.onStart(source);
                break;
            case ON_RESUME:
                mFullLifecycleObserver.onResume(source);
                break;
            case ON_PAUSE:
                mFullLifecycleObserver.onPause(source);
                break;
            case ON_STOP:
                mFullLifecycleObserver.onStop(source);
                break;
            case ON_DESTROY:
                mFullLifecycleObserver.onDestroy(source);
                break;
            case ON_ANY:
                throw new IllegalArgumentException("ON_ANY must not been send by anybody");
        }
        if (mLifecycleEventObserver != null) {
            mLifecycleEventObserver.onStateChanged(source, event);
        }
    }
}
复制代码

Activity 的 LifecycleRegistry 如何感知生命周期

先来看下 Activity 的基类 ComponentActivity

// androidx.core.app.ComponentActivity
@RestrictTo(LIBRARY_GROUP_PREFIX)
public class ComponentActivity extends Activity implements
        LifecycleOwner,
        KeyEventDispatcher.Component {
    ...      
		private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
    ...
    @SuppressLint("RestrictedApi")
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ReportFragment.injectIfNeededIn(this);
    }

    @CallSuper
    @Override
    protected void onSaveInstanceState(@NonNull Bundle outState) {
        mLifecycleRegistry.markState(Lifecycle.State.CREATED);
        super.onSaveInstanceState(outState);
    }
    ...
    @NonNull
    @Override
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }      
}
复制代码

再来看下 ReportFragment

// ReportFragment.java
public class ReportFragment extends android.app.Fragment {
    private static final String REPORT_FRAGMENT_TAG = "androidx.lifecycle"
            + ".LifecycleDispatcher.report_fragment_tag";

    public static void injectIfNeededIn(Activity activity) {
        if (Build.VERSION.SDK_INT >= 29) {
            // 在API 29+上，我们可以直接注册正确的生命周期回调
            LifecycleCallbacks.registerIn(activity);
        }
        // 在API 29之前，并且为了保持与较旧版本的ProcessLifecycleOwner的兼容性（当生命周期运行时已经更新的时候可能不会更新
        // 和需要支持未从support lib的FragmentActivity继承的activities），请使用framework fragment来获取正确的生命周期事件
        android.app.FragmentManager manager = activity.getFragmentManager();
        if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
            manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
            manager.executePendingTransactions();
        }
    }

    @SuppressWarnings("deprecation")
    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);
            }
        }
    }

    static ReportFragment get(Activity activity) {
        return (ReportFragment) activity.getFragmentManager().findFragmentByTag(
                REPORT_FRAGMENT_TAG);
    }

    private ActivityInitializationListener mProcessListener;

    private void dispatchCreate(ActivityInitializationListener listener) {
        if (listener != null) {
            listener.onCreate();
        }
    }

    private void dispatchStart(ActivityInitializationListener listener) {
        if (listener != null) {
            listener.onStart();
        }
    }

    private void dispatchResume(ActivityInitializationListener listener) {
        if (listener != null) {
            listener.onResume();
        }
    }

    @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);
        // 只是想确保我们不会泄漏对activity的引用
        mProcessListener = null;
    }

    private void dispatch(@NonNull Lifecycle.Event event) {
        if (Build.VERSION.SDK_INT < 29) {
            // 仅在API 29之前的API上从ReportFragment调度事件。在API 29+上，
            // 这由ReportFragment.injectIfNeededIn中添加的ActivityLifecycleCallbacks处理
            dispatch(getActivity(), event);
        }
    }

    void setProcessListener(ActivityInitializationListener processListener) {
        mProcessListener = processListener;
    }

    interface ActivityInitializationListener {
        void onCreate();

        void onStart();

        void onResume();
    }

    // 此类不是内联的，仅因为我们需要为其添加一个proguard规则（b / 142778206）除此之外，registerIn方法还可以避免类验证失败，
    // 因为registerActivityLifecycleCallbacks仅从api 29开始可用。
    @RequiresApi(29)
    static class LifecycleCallbacks implements Application.ActivityLifecycleCallbacks {

        static void registerIn(Activity activity) {
            activity.registerActivityLifecycleCallbacks(new LifecycleCallbacks());
        }

        @Override
        public void onActivityCreated(@NonNull Activity activity,
                @Nullable Bundle bundle) {
        }

        @Override
        public void onActivityPostCreated(@NonNull Activity activity,
                @Nullable Bundle savedInstanceState) {
            dispatch(activity, Lifecycle.Event.ON_CREATE);
        }

        @Override
        public void onActivityStarted(@NonNull Activity activity) {
        }

        @Override
        public void onActivityPostStarted(@NonNull Activity activity) {
            dispatch(activity, Lifecycle.Event.ON_START);
        }

        @Override
        public void onActivityResumed(@NonNull Activity activity) {
        }

        @Override
        public void onActivityPostResumed(@NonNull Activity activity) {
            dispatch(activity, Lifecycle.Event.ON_RESUME);
        }

        @Override
        public void onActivityPrePaused(@NonNull Activity activity) {
            dispatch(activity, Lifecycle.Event.ON_PAUSE);
        }

        @Override
        public void onActivityPaused(@NonNull Activity activity) {
        }

        @Override
        public void onActivityPreStopped(@NonNull Activity activity) {
            dispatch(activity, Lifecycle.Event.ON_STOP);
        }

        @Override
        public void onActivityStopped(@NonNull Activity activity) {
        }

        @Override
        public void onActivitySaveInstanceState(@NonNull Activity activity,
                @NonNull Bundle bundle) {
        }

        @Override
        public void onActivityPreDestroyed(@NonNull Activity activity) {
            dispatch(activity, Lifecycle.Event.ON_DESTROY);
        }

        @Override
        public void onActivityDestroyed(@NonNull Activity activity) {
        }
    }
}
复制代码

截屏2021-04-17 19.04.00.png

LifecycleRegistry 如何将事件分发到 LifecycleObserver

// LifecycleRegistry.java
// 设置当前状态并通知观察者。
// 请注意，如果{@code currentState}与该方法的最后一次调用的状态相同，则调用此方法无效。
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
    enforceMainThreadIfNeeded("handleLifecycleEvent");
    moveToState(event.getTargetState());
}

private void moveToState(State next) {
    if (mState == next) {
        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;
}

// 仅发生在堆栈的顶部（永远不可再进入）
// 因此不必考虑父类
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;
        // 无需检查最老的是否可空, 因为在 isSynced 已经验证了
        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 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);
            popParentState();
        }
    }
}

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 = event.getTargetState();
        mState = min(mState, newState);
        // 回调 LifecycleEventObserver 的 onStateChanged
        mLifecycleObserver.onStateChanged(owner, event);
        mState = newState;
    }
}


@Override
public void addObserver(@NonNull LifecycleObserver observer) {
    enforceMainThreadIfNeeded("addObserver");
    State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
    // 创建 ObserverWithState 的位置
    ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
    ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);

    // 不重复添加，直接返回
    if (previous != null) {
        return;
    }
   //如果 LifecycleOwner 对象已经被回收了，直接返回
    LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
    if (lifecycleOwner == null) {
        // it is null we should be destroyed. Fallback quickly
        return;
    }

    boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
    State targetState = calculateTargetState(observer);
    mAddingObserverCounter++;
  	// State值是否到目标状态 && observer 未移除
    while ((statefulObserver.mState.compareTo(targetState) < 0
            && mObserverMap.contains(observer))) {
        pushParentState(statefulObserver.mState);
        final Event event = Event.upFrom(statefulObserver.mState);
        if (event == null) {
            throw new IllegalStateException("no event up from " + statefulObserver.mState);
        }
        statefulObserver.dispatchEvent(lifecycleOwner, event);
        popParentState();
        // mState / subling may have been changed recalculate
        targetState = calculateTargetState(observer);
    }

    if (!isReentrance) {
        // we do sync only on the top level.
        sync();
    }
    mAddingObserverCounter--;
}
复制代码

截屏2021-04-17 19.05.03.png

Lifecycling

// Lifecycling.java
@NonNull
static LifecycleEventObserver lifecycleEventObserver(Object object) {
    boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
    boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
    if (isLifecycleEventObserver && isFullLifecycleObserver) {
        return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,
                (LifecycleEventObserver) object);
    }
    if (isFullLifecycleObserver) {
        return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
    }

    if (isLifecycleEventObserver) {
        return (LifecycleEventObserver) object;
    }

    final Class<?> klass = object.getClass();
    // 往里跳 跳到 resolveObserverCallbackType(Class<?>) - ClassesInfoCache.sInstance.hasLifecycleMethods(Class<?>)，跳完看下面
    int type = getObserverConstructorType(klass);
    if (type == GENERATED_CALLBACK) {
        List<Constructor<? extends GeneratedAdapter>> constructors =
                sClassToAdapters.get(klass);
        if (constructors.size() == 1) {
            GeneratedAdapter generatedAdapter = createGeneratedAdapter(
                    constructors.get(0), object);
            return new SingleGeneratedAdapterObserver(generatedAdapter);
        }
        GeneratedAdapter[] adapters = new GeneratedAdapter[constructors.size()];
        for (int i = 0; i < constructors.size(); i++) {
            adapters[i] = createGeneratedAdapter(constructors.get(i), object);
        }
        return new CompositeGeneratedAdaptersObserver(adapters);
    }
    // 通过反射来调用各回调函数
    return new ReflectiveGenericLifecycleObserver(object);
}
复制代码

通过反射获取注解信息

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

    ReflectiveGenericLifecycleObserver(Object wrapped) {
        mWrapped = wrapped;
        // 因为反射的代价是比较大的，所以对 ReflectiveGenericLifecycleObserver 类要调用的各种方法的相关信息进行了缓存。
        mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());
    }

    @Override
    public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Event event) {
        mInfo.invokeCallbacks(source, event, mWrapped);
    }
}
复制代码

// ClassesInfoCache.java
// 判断该 class 对象是否包含带有 OnLifecycleEvent 注解的方法
boolean hasLifecycleMethods(Class<?> klass) {
    Boolean hasLifecycleMethods = mHasLifecycleMethods.get(klass);
    // 如果本地有缓存的话则直接返回缓存值
    if (hasLifecycleMethods != null) {
        return hasLifecycleMethods;
    }

    //获取 klass 包含的所有方法
    Method[] methods = getDeclaredMethods(klass);
    for (Method method : methods) {
        // 获取方法注解
        OnLifecycleEvent annotation = method.getAnnotation(OnLifecycleEvent.class);
        if (annotation != null) {
            // Optimization for reflection, we know that this method is called
            // when there is no generated adapter. But there are methods with @OnLifecycleEvent
            // so we know that will use ReflectiveGenericLifecycleObserver,
            // so we createInfo in advance.
            // CreateInfo always initialize mHasLifecycleMethods for a class, so we don't do it
            // here.
            createInfo(klass, methods);
            return true;
        }
    }
    mHasLifecycleMethods.put(klass, false);
    return false;
}

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

private CallbackInfo createInfo(Class<?> klass, @Nullable Method[] declaredMethods) {
    Class<?> superclass = klass.getSuperclass();
    Map<MethodReference, Lifecycle.Event> handlerToEvent = new HashMap<>();
    if (superclass != null) {
        CallbackInfo superInfo = getInfo(superclass);
        if (superInfo != null) {
            handlerToEvent.putAll(superInfo.mHandlerToEvent);
        }
    }

    Class<?>[] interfaces = klass.getInterfaces();
    for (Class<?> intrfc : interfaces) {
        for (Map.Entry<MethodReference, Lifecycle.Event> entry : getInfo(
                intrfc).mHandlerToEvent.entrySet()) {
            verifyAndPutHandler(handlerToEvent, entry.getKey(), entry.getValue(), klass);
        }
    }

    Method[] methods = declaredMethods != null ? declaredMethods : getDeclaredMethods(klass);
    boolean hasLifecycleMethods = false;
    for (Method method : methods) {
        // 获取 kclass 内中的 @OnLifecycleEvent 注解
        OnLifecycleEvent annotation = method.getAnnotation(OnLifecycleEvent.class);
        if (annotation == null) {
            continue;
        }
        hasLifecycleMethods = true;
        // 获取 method 所对应的方法的参数个数
        Class<?>[] params = method.getParameterTypes();
        // 如果参数个数为 0，则 callType = CALL_TYPE_NO_ARG
        int callType = CALL_TYPE_NO_ARG;
        // 如果参数个数大于 0
        if (params.length > 0) {
            // 如果参数个数为 1，则 callType = CALL_TYPE_PROVIDER
            callType = CALL_TYPE_PROVIDER;
            // 第一个参数必须是 LifecycleOwner 类型，否则抛出异常
            if (!params[0].isAssignableFrom(LifecycleOwner.class)) {
                throw new IllegalArgumentException(
                        "invalid parameter type. Must be one and instanceof LifecycleOwner");
            }
        }
        Lifecycle.Event event = annotation.value();

        // 如果参数个数大于 1
        if (params.length > 1) {
            callType = CALL_TYPE_PROVIDER_WITH_EVENT;
            // 第二个参数必须是 Lifecycle.Event 类型的对象
            if (!params[1].isAssignableFrom(Lifecycle.Event.class)) {
                throw new IllegalArgumentException(
                        "invalid parameter type. second arg must be an event");
            }
    	      // annotation 注解值必须是 Lifecycle.Event.ON_ANY
            if (event != Lifecycle.Event.ON_ANY) {
                throw new IllegalArgumentException(
                        "Second arg is supported only for ON_ANY value");
            }
        }
        // 如果参数个数大于 2，则抛出异常
        if (params.length > 2) {
            throw new IllegalArgumentException("cannot have more than 2 params");
        }
        // MethodReference 内的 invokeCallback 方法完成最终的反射调用
        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;
}

@SuppressWarnings("WeakerAccess")
static final 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);
        }
    }
		...
}
复制代码