Jetpack之一 Lifecycle

导语

Jetpack出来也有几年了，平时也是主要使用jetpack来进行开发。我个人理解，Jetpack主要是围绕Lifecycle（生命周期）来进行构建的。所有的一切都包含生命周期，生命周期是通过观察者模式来实现的。但这里和普通的观察者模式不太一。一般的观察者模式是仅通过 被观察者去通知观察者变化，而Jetpack的观察者，不单单可以被观察者去通知观察者，还可以当观察者的生命周期出现变化时去通知被观察者进行解绑。Jetpack部分主要讲：Lifecycle、LiveData、Viewmodel，个人认为这是Jetpack的核心，最多再加一个Room。

**

一、大致流程

**
先来看一下Android Jetpack官网：Jetpack入门（外网地址），小伙伴打开不了的话，可以看国内的：Jetpack入门（国内）

dependencies {
    def lifecycle_version = "2.2.0"
    implementation "androidx.lifecycle:lifecycle-livedata-ktx:$lifecycle_version"
    implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version"
    ...
}

先根据官网提示把库同步下来，然后我们来分析Lifecycle包。
看一下目录结构，生命周期相关的主要在这两个库：

其实主要分为两类：第一类是生命周期持有者（被观察者），第二类是生命周期的观察者。
第一类主要有：LifecycleOwner、Lifecycle、LifecycleRegistry；
第二类主要：LifecycleObserver；
先看一下类图：

上图所示类的依赖关系，下面来说一下流程：
LifecycleOwner（生命周期持有者，比如AppCompatActivity）会持有一个LifecycleRegistry（生命周期Lifecycle的实现类，其实这个类才是真实的生命周期，包括生命周期状态变化和注册生命周期监听的观察者都在这个类里面），如下图：

**

二、源码分析

**

1.增加生命周期观察者

**
**
通过LifecycleRegistry的markState(State state)方法来告知观察者生命周期变化。生命周期观察者需要实现LifecycleObserver接口：

package android.arch.lifecycle;

@SuppressWarnings("WeakerAccess")
public interface LifecycleObserver {

}

那么可能要问了，只是单独的接口，没有具体的要实现的方法么？这里比较微妙，是通过注解来实现的，@OnLifecycleEvent：

package android.arch.lifecycle;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

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

我们重点看一下LifecycleRegistry类，该类包含了所有生命周期观察的实现。先看一下注册观察者：

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

这里 //1处，重点看一下静态内部类ObserverWithState的构造方法，这里通过 Lifecycling.getCallback(observer)把LifecycleObserver包装为接口的实现接口GenericLifecycleObserver，

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

下面我们来看一下Lifecycling类的getCallback方法：

 @NonNull
    static GenericLifecycleObserver getCallback(Object object) {
    // 1 观察所有生命周期的变化，这里需要实现所有生命周期的方法
        if (object instanceof FullLifecycleObserver) {
            return new FullLifecycleObserverAdapter((FullLifecycleObserver) object);
        }
		// 2 这里是通过1个方法，返回生命周期事件Lifecycle.Event
        if (object instanceof GenericLifecycleObserver) {
            return (GenericLifecycleObserver) object;
        }
		// 3 
        return new ReflectiveGenericLifecycleObserver(object);
    }

我们重点看一下//3处，进入ReflectiveGenericLifecycleObserver的构造方法：

class ReflectiveGenericLifecycleObserver implements GenericLifecycleObserver {
    private final Object mWrapped;
    final Map<MethodReference, Lifecycle.Event> mHandlerToEvent;
    // 1 回调方法的包装类，里面包含final Map<Lifecycle.Event, List<MethodReference>> mEventToHandlers;
    private final CallbackInfo mInfo;

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

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

我们在重点看一下//2 mInfo怎么生成的：

    CallbackInfo getInfo(Class klass) {
    // 1 先从缓冲的集合里面取，private final Map<Class, CallbackInfo> mCallbackMap = new HashMap<>();该集合是以类作为key
        CallbackInfo existing = mCallbackMap.get(klass);
        if (existing != null) {
            return existing;
        }
        // 2 
        existing = createInfo(klass, null);
        return existing;
    }

我们在看一下//2 处，createInfo(klass, null)方法

private CallbackInfo createInfo(Class klass, @Nullable Method[] declaredMethods) {
        Class superclass = klass.getSuperclass();
        //1 handlerToEvent 用于保存 <方法,事件> 键值对
        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) {
        // 2 此处查找当前类的OnLifecycleEvent注解的方法，
            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");
                }
            }
            Lifecycle.Event event = annotation.value();

            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");
            }
            MethodReference methodReference = new MethodReference(callType, method);
            // 3 这里把方法和事件加入handlerToEvent集合
            verifyAndPutHandler(handlerToEvent, methodReference, event, klass);
        }
        // 把收集到的handlerToEvent存入CallbackInfo
        CallbackInfo info = new CallbackInfo(handlerToEvent);
        mCallbackMap.put(klass, info);
        mHasLifecycleMethods.put(klass, hasLifecycleMethods);
        return info;
    }

经过上面的代码可以发现，监听生命周期，已经提供了三种方式：
1.实现LifecycleObserver，注解对应的生命周期方法；
2.实现GenericLifecycleObserver，重写：void onStateChanged(LifecycleOwner source, Lifecycle.Event event)方法；
3.实现FullLifecycleObserver，重写所有的生命周期方法。

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

2.如何关联Activity生命周期

上面说了注册监听，下面看一下生命周期变化时怎么回调：
LifecycleOwner 通过调用LifecycleRegistry下面两个方法，来通知生命周期的变化：

...
    @MainThread
    public void markState(@NonNull State state) {
        moveToState(state);
    }

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

我们从下面两个方面来追踪代码：
1.这两个方法是怎么和Activity和Fragment的生命周期相关联起来的；
2.当生命周期变化时，这两个方法是怎么去通知LifecycleObserver的；

和Activity生命周期关联：
其实这两个方法最终都是调用moveToState(state)方法，只不过一个是直接使用State参数，另一个是根据Lifecycle.Event来获取State，再去调用moveToState()方法。而且再看看handleLifecycleEvent()方法主要就是通过FragmentManager用来观察Fragment的生命周期，这里不做多讲，有兴趣的同学可以自行去看看源码。
我们先看看markState(@NonNull State state)方法有哪些地方调用：
调用此方法的一共三个类：LifecycleDispatcher、SupportActivity、FragmentActivity，一个个来。
我们先看LifecycleDispatcher类：

 private static void markStateIn(Object object, State state) {
        if (object instanceof LifecycleRegistryOwner) {
            LifecycleRegistry registry = ((LifecycleRegistryOwner) object).getLifecycle();
            registry.markState(state);
        }
    }

再追踪markStateIn方法

    // 1 负责Fragment生命周期
    private static void markState(FragmentManager manager, State state) {
        Collection<Fragment> fragments = manager.getFragments();
        if (fragments == null) {
            return;
        }
        for (Fragment fragment : fragments) {
            if (fragment == null) {
                continue;
            }
            markStateIn(fragment, state);
            if (fragment.isAdded()) {
                markState(fragment.getChildFragmentManager(), state);
            }
        }
    }
     // 2.负责Activity生命周期
    private static void markState(FragmentActivity activity, State state) {
        // 3
        markStateIn(activity, state);
        // 4
        markState(activity.getSupportFragmentManager(), state);
    }

其实我们看一下代码//3和//4处，其实Fragment的生命周期也最终是根据Activity的来的。下面在往上，看看markState(FragmentActivity activity, State state)在哪里调用的：

 @VisibleForTesting
    static class DispatcherActivityCallback extends EmptyActivityLifecycleCallbacks {
       ...

        @Override
        public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
            if (activity instanceof FragmentActivity) {
            // 1
                ((FragmentActivity) activity).getSupportFragmentManager()
                        .registerFragmentLifecycleCallbacks(mFragmentCallback, true);
            }
            ReportFragment.injectIfNeededIn(activity);
        }

        @Override
        public void onActivityStopped(Activity activity) {
        // 2
            if (activity instanceof FragmentActivity) {
                markState((FragmentActivity) activity, CREATED);
            }
        }

        @Override
        public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
        // 3
            if (activity instanceof FragmentActivity) {
                markState((FragmentActivity) activity, CREATED);
            }
        }
    }

DispatcherActivityCallback最终实现了Application.ActivityLifecycleCallbacks接口，该接口大家可能很熟悉，我们在自定义ActivityManager的时候，就是通过该接口来监听所有的Activity的生命周期的变化的。看看DispatcherActivityCallback类是哪里调用的：

class LifecycleDispatcher {
...
    static void init(Context context) {
        if (sInitialized.getAndSet(true)) {
            return;
        }
        // 1
        ((Application) context.getApplicationContext())
                .registerActivityLifecycleCallbacks(new DispatcherActivityCallback());
    }
}

LifecycleDispatcher的init()方法，再往上追踪，

public class ProcessLifecycleOwnerInitializer extends ContentProvider {
    @Override
    public boolean onCreate() {
    // 1
        LifecycleDispatcher.init(getContext());
        ProcessLifecycleOwner.init(getContext());
        return true;
    }
}

ProcessLifecycleOwnerInitializer类，是一个ContentProvider，此处是通过ContentProvider来减少侵入性。至此，我们可以看到Framework底层已经帮我们实现了生命周期的绑定，是通过Application.ActivityLifecycleCallbacks来监听Activity的生命周期变化。
再看SupportActivity和FragmentActivity，其实这里面没有多少东西：

SupportActivity
    @Override
    protected void onSaveInstanceState(Bundle outState) {
        mLifecycleRegistry.markState(Lifecycle.State.CREATED);
        super.onSaveInstanceState(outState);
    }


FragmentActivity
 private void markFragmentsCreated() {
        boolean reiterate;
        do {
            reiterate = markState(getSupportFragmentManager(), Lifecycle.State.CREATED);
        } while (reiterate);
    }

    private static boolean markState(FragmentManager manager, Lifecycle.State state) {
        boolean hadNotMarked = false;
        Collection<Fragment> fragments = manager.getFragments();
        for (Fragment fragment : fragments) {
            if (fragment == null) {
                continue;
            }
            if (fragment.getLifecycle().getCurrentState().isAtLeast(Lifecycle.State.STARTED)) {
                fragment.mLifecycleRegistry.markState(state);
                hadNotMarked = true;
            }

            FragmentManager childFragmentManager = fragment.peekChildFragmentManager();
            if (childFragmentManager != null) {
                hadNotMarked |= markState(childFragmentManager, state);
            }
        }
        return hadNotMarked;
    }

**

3.生命周期变化通知LifecycleObserver

**
说完系统是怎么帮我Activity和Fragment实现了生命周期的监听，下面再看看生命周期变化之后是怎么告知LifecycleObserver的。回过头来看LifecycleRegistry的moveToState()方法：

private void moveToState(State next) {
       ...
        // 1 
        sync();
       ...
    }

再看sync()方法怎么实现的：

private void sync() {
      ...
        while (!isSynced()) {
            mNewEventOccurred = false;
            // 1 之前的生命周期变化不再关注
            if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
                backwardPass(lifecycleOwner);
            }
            Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
            if (!mNewEventOccurred && newest != null
                    && mState.compareTo(newest.getValue().mState) > 0) {
                    // 2
                forwardPass(lifecycleOwner);
            }
        }
        mNewEventOccurred = false;
    }

再看// 2 处的forwardPass()方法：

   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处调用ObserverWithState的dispatchEvent方法
                observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
                popParentState();
            }
        }
    }

根据1处，再看ObserverWithState的dispatchEvent方法：

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

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

mLifecycleObserver其实是Lifecycling.getCallback(observer)生成的，如果通过自定义实现LifecycleOwner接口，最终返回的是ReflectiveGenericLifecycleObserver对象，再看ReflectiveGenericLifecycleObserver的onStateChanged方法：

class ReflectiveGenericLifecycleObserver implements GenericLifecycleObserver {
    private final Object mWrapped;
    // 1 根据OnLifecycleEvent注解修饰的方法
    private final CallbackInfo mInfo;

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

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

再看CallbackInfo的invokeCallbacks方法：

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

这里其实就很简单了，便利之前的Map<Lifecycle.Event, List< MethodReference> > mEventToHandlers,然后调用对应的方法:
总结：
1.Application的registerActivityLifecycleCallbacks方法注册监听所有Activity的生命周期变化;
2.当Activity的生命周期变化之后，通过LifecycleRegistry的moveToState方法通知LifecycleObserver执行对应的方法；

最后我们整理一下，见下图：