Android Jetpack架构组件（三）Lifecycle原理篇

最新推荐文章于 2024-01-17 18:05:08 发布

Zhou Jiang

最新推荐文章于 2024-01-17 18:05:08 发布

阅读量1.5k

点赞数 1

分类专栏： Jetpack Archtecture 移动端安卓开发源码分析文章标签： Android Jetpack

本文链接：https://blog.csdn.net/oman001/article/details/104371450

版权

移动端安卓开发同时被 3 个专栏收录

28 篇文章 11 订阅

订阅专栏

源码分析

24 篇文章 1 订阅

订阅专栏

Jetpack Archtecture

9 篇文章 0 订阅

订阅专栏

前言
上一篇讲述了Jetpack中的Lifecycle的使用，这一篇我们从源码角度来分析一下它是如何实现的。

源码解析(基于最新的lifecycle2.2.0版本)

在上一篇的Lifecycle使用篇中我们知道了怎么使用，这里我们把源码部分贴出来，我们从使用的角度来分析源码是如何实现的：

class DetailActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_app_detail)
        //-----1-----
        lifecycle.addObserver(LifecycleListener())
    }

    override fun onStart() {
        super.onStart()
        Log.i("aaa", "Activity onStart ")
    }

    override fun onStop() {
        super.onStop()
        Log.i("aaa", "Activity onStop ")
    }

//-----2-----
class LifecycleListener : LifecycleObserver { 

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun onStart() {
        Log.i("aaa", "listener onStart ")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun onStop() {
        Log.i("aaa", "listener onStop ")
    }
}

首先在注释2处，我们声明了一个LifecycleListener，然后在注释1处调用lifecycle.addObserver将LifecycleListener()传进去(Fragment同理)，我们就从这里的开始源码的分析。但是在分析源码之前，我们先大致捋一下Lifecycle的原理和继承结构，Lifecycle是一种观察者模式，在Activity中持有LifecycleObserver的实现类，然后根据生命周期的变化，调用对应的LifecycleObserver中的方法来实现逻辑代码。

针对源码结构部分，我们先来看一下, 心中大概有个印象，后面用到的时候会详细讲解：

public interface LifecycleObserver {
}

public interface LifecycleEventObserver extends LifecycleObserver {
    void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event);
}

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

    ReflectiveGenericLifecycleObserver(Object wrapped) {
        mWrapped = wrapped;
        mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());
    }

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

public interface LifecycleOwner {
    Lifecycle getLifecycle();
}

public abstract class Lifecycle {

    @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
    @NonNull
    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 {
       
        ON_CREATE,
        
        ON_START,
       
        ON_RESUME,
       
        ON_PAUSE,
       
        ON_STOP,
       
        ON_DESTROY,
       
        ON_ANY
    }

    @SuppressWarnings("WeakerAccess")
    public enum State {
      
        DESTROYED,

        INITIALIZED,

        CREATED,

        STARTED,

        RESUMED;

        public boolean isAtLeast(@NonNull State state) {
            return compareTo(state) >= 0;
        }
    }
}

public class LifecycleRegistry extends Lifecycle {
...
}

好了，下面我们开始从Activity的getLifecycle()开始分析，这个方法是在ComponentActivity中的，源码如下所示：

class ComponentActivity implements LifecycleOwner 

    private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

	public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }
 }

上面LifecycleRegistry是Lifecycle的唯一的实现类，看名字就知道它是负责对LifecycleObserver的注册和解除注册的操作。接着我们看addObserver(observer)源码：

@Override
public void addObserver(@NonNull LifecycleObserver observer) {
    State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
    ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
    ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);

    if (previous != null) {
        return;
    }
    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++;
    while ((statefulObserver.mState.compareTo(targetState) < 0
            && mObserverMap.contains(observer))) {
        pushParentState(statefulObserver.mState);
        statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
        popParentState();
        // mState / subling may have been changed recalculate
        targetState = calculateTargetState(observer);
    }

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

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 = getStateAfter(event);
        mState = min(mState, newState);
        mLifecycleObserver.onStateChanged(owner, event);
        mState = newState;
    }
}

在addObserver方法的开头先将mState赋值为INITIALIZED状态，然后将传入的实参observer用ObserverWithState包装起来，ObserverWithState中仅仅存在两个变量，一个是State, 一个是LifecycleEventObserver。然后将封装类放在mObserverMap这个map中，便于将来取出来使用。addObserver方法中后面的代码因为是第一次调用addObserver，所以后面的代码就没什么实际的作用，就不分析了。接着我们看自定义的LifecycleListener中的方法是如何跟随生命周期被调用的。

我们看下ComponentActivity的onCreate方法源码：

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    mSavedStateRegistryController.performRestore(savedInstanceState);
    ReportFragment.injectIfNeededIn(this);
    if (mContentLayoutId != 0) {
        setContentView(mContentLayoutId);
    }
}

我们看到其中调用了ReportFragment.injectIfNeededIn(this)，其中ReportFragment是一个分发生命周期事件的类，它是一个没有界面的Fragment.它的主要作用就是用来监控生命周期的变化并做相应的响应。我们看下ReportFragment整个源码：

@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP_PREFIX)
public class ReportFragment extends 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) {
            // On API 29+, we can register for the correct Lifecycle callbacks directly
            activity.registerActivityLifecycleCallbacks(
                    new LifecycleCallbacks());
        }
        // Prior to API 29 and to maintain compatibility with older versions of
        // ProcessLifecycleOwner (which may not be updated when lifecycle-runtime is updated and
        // need to support activities that don't extend from FragmentActivity from support lib),
        // use a framework fragment to get the correct timing of Lifecycle events
        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();
        }
    }

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

    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);
        }
    }

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

    interface ActivityInitializationListener {
        void onCreate();

        void onStart();

        void onResume();
    }
}

从上面的injectIfNeededIn源码部分看到，在Android 29以上直接通过activity.registerActivityLifecycleCallbacks来注册的，我们关注下面的injectIfNeededIn方法内部底部的内容，它会将ReportFragment添加到FragmentManager中。

然后我们来关注生命周期部分，我们看到每一个生命周期都会对应的调用dispatch方法，从而触发后续的操作，我们以onStart源码为例进行分析：

@Override
public void onStart() {
    super.onStart();
    dispatchStart(mProcessListener);
    dispatch(Lifecycle.Event.ON_START);
}

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);
    }
}

static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
    if (activity instanceof LifecycleRegistryOwner) {
        ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
        return;
    }

    if (activity instanceof LifecycleOwner) {
    	//-----1-----
        Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
        if (lifecycle instanceof LifecycleRegistry) {
            ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
        }
    }
}

因为Component是实现的LifecycleOwner, 所以接着会进入到注释1的判断中，然后调用handleLifecycleEvent, 我们看源码部分, 首先会调用getStateAfter:

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

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);
}

getStateAfter的逻辑可以用一张图来解释说明一下, 这里Event代表的是事件，基本包含了重要的生命周期，getStateAfter转换为对应的State，只包含了INITIALIZED,CREATED,STARTED,RESUMED,以及DESTROYED。

通过getStateAfter得到的是State为STARTED, 接着会调用moveToState(state)方法：

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;
}

moveToState首先判断mState状态是否和传进来的一样，如果是的话就return, 我们接下来看sync()方法：

 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.
        //-----1-----
        if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
            backwardPass(lifecycleOwner);
        }
        Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
        if (!mNewEventOccurred && newest != null
                //-----2-----
                && mState.compareTo(newest.getValue().mState) > 0) {
            forwardPass(lifecycleOwner);
        }
    }
    mNewEventOccurred = false;
}

sync()在注释1处首先判断当前状态mState和mObserverMap.eldest().getValue().mState的的关系，如果mState状态在它之前就调用backwardPass，如果在它之后就调用注释2处的forwardPass，这里满足注释2处的条件，就以forwardPass为例，其实和backwardPass大同小异：

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

调用了observer.dispatchEvent方法：

static class ObserverWithState {
    State mState;
    LifecycleEventObserver mLifecycleObserver;

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

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

注释1处ObserverWithState的构造方法在addObserver时候被调用，ObserverWithState中有一个变量mLifecycleObserver通过Lifecycling.lifecycleEventObserver(observer)得到，查看源码如下：

static LifecycleEventObserver lifecycleEventObserver(Object object) {
    boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
    boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
    //-----1-----
    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();
    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);
    }
    //-----2-----
    return new ReflectiveGenericLifecycleObserver(object);
}

由上源码得知使用注解@OnLifecycleEvent得到的注释2处的ReflectiveGenericLifecycleObserver对象，如果我们采用另外一种实现DefaultLifecycleObserver的方式的话，在注释1处可知，返回的是FullLifecycleObserverAdapter, 我们分析比较复杂的，所以在注释2处实际上调用的是ReflectiveGenericLifecycleObserver.onStateChanged方法，源码如下：

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

    ReflectiveGenericLifecycleObserver(Object wrapped) {
        mWrapped = wrapped;
        //-----1-----
        mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());
    }

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

在调用注释2处代码之前，我们先分析mInfo是做什么的，以及它是怎么来的。在构造方法中通过传入的wrapped参数获取mInfo，这里wrapped就是我们前面自定义的LifecycleObserver对象，我们先看注释1处的getInfo方法。

private final Map<Class<?>, CallbackInfo> mCallbackMap = new HashMap<>();

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

在getInfo中先尝试从mCallbackMap中获取，如果为空的话再走createInfo()方法来获取CallbackInfo，下面是createInfo源码：

private CallbackInfo createInfo(Class<?> klass, @Nullable Method[] declaredMethods) {
	//-----1-----
    Class<?> superclass = klass.getSuperclass();
    //-----2-----
    Map<MethodReference, Lifecycle.Event> handlerToEvent = new HashMap<>();
    if (superclass != null) {
        CallbackInfo superInfo = getInfo(superclass);
        if (superInfo != null) {
            handlerToEvent.putAll(superInfo.mHandlerToEvent);
        }
    }
	//-----3-----
    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);
        }
    }
	//-----4-----
    Method[] methods = declaredMethods != null ? declaredMethods : getDeclaredMethods(klass);
    boolean hasLifecycleMethods = false;
    for (Method method : methods) {
    	//-----5-----
        OnLifecycleEvent annotation = method.getAnnotation(OnLifecycleEvent.class);
        if (annotation == null) {
            continue;
        }
        hasLifecycleMethods = true;
        //-----6-----
        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");
            }
        }
        Lifecycle.Event event = annotation.value();
		//------7------
        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");
            }
        }
        //-----8-----
        if (params.length > 2) {
            throw new IllegalArgumentException("cannot have more than 2 params");
        }
        //-----9-----
        MethodReference methodReference = new MethodReference(callType, method);
        //-----10-----
        verifyAndPutHandler(handlerToEvent, methodReference, event, klass);
    }
    //-----11-----
    CallbackInfo info = new CallbackInfo(handlerToEvent);
    mCallbackMap.put(klass, info);
    mHasLifecycleMethods.put(klass, hasLifecycleMethods);
    return info;
}

首先在注释1处获取待处理的类的父类，看父类中是否有和生命周期相关的方法加入到注释2创建的Map中，这个Map是以Key为MethodReference，Value为Lifecycle.Event, 其中MethodReference是封装了Method的一个类。注释3处是处理接口相关的信息。
注释4处会通过getDeclaredMethods拿到所有在这个类中声明的方法，包括public, protected，private修饰符修饰的方法，但是不包括继承的方法以及接口中default修饰的方法，这个和getMethods（只能获取到public声明的方法，包括public修饰的继承的方法以及接口中的default方法）要注意区别。
获取到方法之后就进入了for循环，会在注释5处获取方法的OnLifecycleEvent注解，如果注解为空的话就直接continue进入下一个元素。
注释6处获取这个方法参数的类型，callType有三种取值，其中默认情况下等于CALL_TYPE_NO_ARG, 如果参数的长度大于0的话就将callType赋值为CALL_TYPE_PROVIDER,并且使用isAssignableFrom来检测第一个参数是不是属于LifecycleOwner, 如果不是的话就要抛出异常throw new IllegalArgumentException("invalid parameter type. Must be one and instanceof LifecycleOwner")。
注释7处会获取注解的值，接下来会判断如果参数的数量大于1的话就将callType赋值为CALL_TYPE_PROVIDER_WITH_EVENT, 并且如果第二个参数不是Lifecycle.Event类型的话，也会抛出异常throw new IllegalArgumentException("invalid parameter type. second arg must be an event")。并且如果两个参数的时候，注解中必须使用的是@OnLifecycleEvent(Lifecycle.Event.ON_ANY), 否则会有异常throw new IllegalArgumentException("Second arg is supported only for ON_ANY value")。
注释8处判断参数的长度不能大于两个，如果大于两个的话还是会抛出异常throw new IllegalArgumentException("cannot have more than 2 params")。
注释9处会将上面的callType和method封装到MethodReference中，然后在注释10处将methodReference和event放入前面注释2的handlerToEvent中。
注释11处创建我们需要的callbackInfo，然后将其放入mCallbackMap中，最后返回生成的callbackInfo。
综上分析，如果我们想使用注解的方法带有参数的话，如果是一个参数的话，这个参数一定要是LifecycleOwner类型的；如果是两个参数的话，第一个参数还得是LifecycleOwner类型，而且第二个参数必须得是Lifecycle.Event类型的，并且注解中的事件必须是ON_ANY;如果大于两个参数的也是会抛出异常的。

然后再分析前面ReflectiveGenericLifecycleObserver中的onStateChanged方法，它调用的是mInfo.invokeCallbacks(source, event, mWrapped);方法，我们看一下整个类的源码，源码如下：

static class CallbackInfo {
    final Map<Lifecycle.Event, List<MethodReference>> mEventToHandlers;
    final Map<MethodReference, Lifecycle.Event> mHandlerToEvent;
	//-----1-----
    CallbackInfo(Map<MethodReference, Lifecycle.Event> handlerToEvent) {
        mHandlerToEvent = handlerToEvent;
        mEventToHandlers = new HashMap<>();
        for (Map.Entry<MethodReference, Lifecycle.Event> entry : handlerToEvent.entrySet()) {
            Lifecycle.Event event = entry.getValue();
            List<MethodReference> methodReferences = mEventToHandlers.get(event);
            if (methodReferences == null) {
                methodReferences = new ArrayList<>();
                mEventToHandlers.put(event, methodReferences);
            }
            methodReferences.add(entry.getKey());
        }
    }

    @SuppressWarnings("ConstantConditions")
    //-----2-----
    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);
    }

    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--) {
            	//-----3-----
                handlers.get(i).invokeCallback(source, event, mWrapped);
            }
        }
    }
}

我们看到invokeCallbacks中出现了mEventToHandlers变量，这个变量其实是在注释1 处CallbackInfo的构造方法中将我们刚才在createInfo中遍历得到的mHandlerToEvent的Key和Value交换位置，存储到了mEventToHandlers, 这是为了方便后续的根据Event得到对应的MethodReference列表的操作。
然后进入到了注释2的invokeCallbacks中，代码执行了invokeMethodsForEvent。mEventToHandlers.get(event)获取的是Event对应的MethodReference列表，注释3处是对此列表进行遍历，然后执行MethodReference中的invokeCallback方法，源码如下：

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);
        }
    }

然后根据前面分析的callType来反射调用，最终达到了我们需要的效果。
整个流程可以用一张图来直观感受一下：

总结

其实Lifecycle的源码也不算太多，理解起来也不算太难，简单来说就是我们自定义的LifecycleObserver中使用注解修饰的方法以及事件都会在addObserver时候被保存起来，在生命周期发生变化的时候，通过反射找到对应的方法执行调用即可。如果对Lifecycle使用不熟悉的，可以参考Lifecycle使用篇。

Zhou Jiang

关注

1
点赞
踩
5

收藏

觉得还不错? 一键收藏
1
评论
Android Jetpack架构组件（三）Lifecycle原理篇

前言上一篇讲述了Jetpack中的Lifecycle的使用，这一篇我们从源码角度来分析一下它是如何实现的。源码解析(基于最新的2.2.0版本)在上一篇的Lifecycle使用篇中我们知道了怎么使用，这里我们把源码部分贴出来，我们从使用的角度来分析源码是如何实现的：class DetailActivity : AppCompatActivity() { override fun...
复制链接

扫一扫

专栏目录