Android Jetpack架构组件之 Lifecycle（源码篇）

一、前言

最近简单看了下google推出的框架Jetpack，感觉此框架的内容可以对平时的开发有很大的帮助，也可以解决很多开发中的问题，对代码的逻辑和UI界面实现深层解耦，打造数据驱动型UI界面。

Android Architecture组件是Android Jetpack的一部分，它们是一组库，旨在帮助开发者设计健壮、可测试和可维护的应用程序，包含一下组件：

本文从源码和实现的角度分析一下，LifeCycle是如何实现感知活动生命周期的。

二、源码分析

关于Lifecycle的使用考上一篇文章Android Jetpack框架之 Lifecycles（使用篇），从使用的方法中我们知道Lifecycle的实现主要依赖：LifecycleObserver、LifecycleOwner；通过像Owner注册Observer实现感知Owner的生命周期，下面一起看看源码是如何巧妙设计的；

2.1、生命周期观察者：LifecycleObserver

// 实现LifecycleObserver
class MyObserver(var lifecycle: Lifecycle, var callback: CallBack) : LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public fun connectOnCreate() {
        p("connectOnCreate")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public fun connectOnResume() {
        p("connectOnResume")

    }
}

// LifecycleObserver 是一个空接口
public interface LifecycleObserver {

}

上面过程做了三件事情：

实现LifecycleObserver的接口
编写要执行的方法
为每个方法添加注解，表示其执行的时机

@OnLifecycleEvent：运行注解

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

2.2、生命周期：Lifecycle.Event & State

 // 生命周期Event
public enum Event {
        /**
         * Constant for onCreate event of the {@link LifecycleOwner}.
         */
        ON_CREATE,
        /**
         * Constant for onStart event of the {@link LifecycleOwner}.
         */
        ON_START,
        /**
         * Constant for onResume event of the {@link LifecycleOwner}.
         */
        ON_RESUME,
        /**
         * Constant for onPause event of the {@link LifecycleOwner}.
         */
        ON_PAUSE,
        /**
         * Constant for onStop event of the {@link LifecycleOwner}.
         */
        ON_STOP,
        /**
         * Constant for onDestroy event of the {@link LifecycleOwner}.
         */
        ON_DESTROY,
        /**
         * An {@link Event Event} constant that can be used to match all events.
         */
        ON_ANY
    }

//5个对应的生命周期状态
 public enum State {

        DESTROYED,

        INITIALIZED,

        CREATED,

        STARTED,

        RESUMED;

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

通过Lifecycle.Event和State的查看，系统提供了Activity每个生命周期对应的Event，而Event有会有对应的State，此时以大致猜想到上面的执行过程：

使用LifeEvent标记每个执行方法的Event
当活动状态改变时，系统会判断即将要改变成的状态
根据状态获取要执行的Event
从注册的Observer中获取标注为对应的Event，执行逻辑

2.3、生命周期的感知

LifecycleOwner

class LifeCyclerActivity : AppCompatActivity() {
  ...
 var myObserver = MyObserver(lifecycle, object : CallBack { // 创建LifecyclerObserver
            override fun update() {
          ...
            }
        })
        lifecycle.addObserver(myObserver) // 添加观察者
    }
}

从上面的使用情况看出，使用的活动需要调用getLifecycle（）方法，返回LifecycleRegistry，这里的getLifecycle（）方法其实是接口LifecycleOwner接口中的方法，

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

此时LifecycleActivity虽然没有实现接口，因为他继承的AppCompatActivity继承了SupportActivity，而SupportActivity实现了接口

@RestrictTo(LIBRARY_GROUP)
public class SupportActivity extends Activity implements LifecycleOwner {

 private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this); //创建

 @Override
    public Lifecycle getLifecycle() { // 重写方法返回LifecycleRegistry 
        return mLifecycleRegistry;
    }

}

SupportActivity除了执行上述操作外，在onCrate的方法中还有一句重要的代码，初始化了一个ReportFragment

protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ReportFragment.injectIfNeededIn(this);
    }

ReportFragment

public class ReportFragment extends Fragment {
    private static final String REPORT_FRAGMENT_TAG = "android.arch.lifecycle"
            + ".LifecycleDispatcher.report_fragment_tag";
 
    public static void injectIfNeededIn(Activity activity) { //初始化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();
        }
    }

  @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);
        mProcessListener = null;
    }

    private void dispatch(Lifecycle.Event event) {
        Activity activity = getActivity();
        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);
            }
        }
    }
}

上面代码中做了两件事：

添加一个ReportFragment的实例
根据Fragment的每个生命周期的回调，调用dispatch（）处理回调事件

在dispatch（）方法中根据LifecyclerOwner和LifecyclerRegistryOwner实例分别处理，因为LifecyclerRegistryOwner也是继承LifecyclerOwner，而在我们SupportActivity中的getLifecycler（）中返回的是LifecycleRegistry，所以此处回调的都是LifecycleRegistry的handleLifecycleEvent；

2.4、生命周期处理

LifecycleRegistry

创建LifecycleRegistry实例

 // 对LifecycleOwner使用了弱引用
private final WeakReference<LifecycleOwner> mLifecycleOwner;

 public LifecycleRegistry(@NonNull LifecycleOwner provider) {
        mLifecycleOwner = new WeakReference<>(provider);
        // 状态为初始化状态
        mState = INITIALIZED;
    }

接着上面的执行，我们找到handleLifecycleEvent（）

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

还记的上面的猜想吗？和此处执行的逻辑完全一致，对于getStateAfter（）和moveToState（），从名字中可以看出他们是执行响应生命周期的地方

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

private void moveToState(State next) {
        if (mState == next) {
            return;
        }
        mState = next;
        // 当正在sync中处理改变状态时 mHandlingEvent = true
        // 当我们调用addObserver时 mAddingObserverCounter ！= 0
        // 这两种状态都是正在执行任务的状态，所以此时直接return
        if (mHandlingEvent || mAddingObserverCounter != 0) {
            mNewEventOccurred = true;
            // we will figure out what to do on upper level.
            return;
        }
        mHandlingEvent = true;
        sync();
        mHandlingEvent = false;
    }

在getStateAfter中首先根据执行的Lifecycle.Event，判断执行事件后下一个到达的状态，然后使用moveToState（）中的sync（）修改活动的生命周期：

private void sync() {
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        if (lifecycleOwner == null) {
            Log.w(LOG_TAG, "LifecycleOwner is garbage collected, you shouldn't try dispatch "
                    + "new events from it.");
            return;
        }
        while (!isSynced()) {
            mNewEventOccurred = false;
            // 比较的是出现的顺序 如果下一个周期小于当前的周期 即向前back
            if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
                backwardPass(lifecycleOwner); // 修改集合
            }
            //获取新的Map的Entry
            Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
            if (!mNewEventOccurred && newest != null
                    && mState.compareTo(newest.getValue().mState) > 0) {
                forwardPass(lifecycleOwner);
            }
        }
        mNewEventOccurred = false;
    }

在sync()方法中除了必要的条件和判断外，主要的逻辑还是生命周期的比较和处理，由前面我们知道Lifecycle.Event和Lifecycle.State的声明顺序是和活动的声明周期执行顺序一致的，所以对Lifecycle.State的前后顺序的比较也就反应了声明周期状态的变换，比如活动此时的生命周期为Resumed（此时mObserverMap中保存的状态为Resumed），而下一个变换的状态为Started(此时的mState为Started)，从声明周期中可以知道此时执行的时onPause（），对应的LIfecycle.Event为ON_PAUSE，那么上述逻辑中此时执行的是

if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
                backwardPass(lifecycleOwner); // 修改集合
            }

backwardPass

 private void backwardPass(LifecycleOwner lifecycleOwner) {
        Iterator<Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
                mObserverMap.descendingIterator();
        while (descendingIterator.hasNext() && !mNewEventOccurred) {
            Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();
           // 获取当前保存的 ObserverWithState  从中提取状态
            ObserverWithState observer = entry.getValue(); 
            while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
                    && mObserverMap.contains(entry.getKey()))) {
               // 如果保存的状态大于 要变化的状态 向前修改
                Event event = downEvent(observer.mState); //查找对应周期变化的事件
                pushParentState(getStateAfter(event)); 
                observer.dispatchEvent(lifecycleOwner, event); // 发送事件
                popParentState();
            }
        }
    }

在backwardPass（）方法中会将mObserverMap中保存的状态与mState比较，然后调用downEvent（）根据保存的状态找出要执行的Event，并调用Observer的dispatEvent（）方法发送事件，对于downEvent（）还有个与之对应的方法upEvent（）：

private static Event downEvent(State state) {
        switch (state) {
            case INITIALIZED:
                throw new IllegalArgumentException();
            case CREATED:
                return ON_DESTROY;
            case STARTED:
                return ON_STOP;
            case RESUMED:
                return ON_PAUSE;
            case DESTROYED:
                throw new IllegalArgumentException();
        }
        throw new IllegalArgumentException("Unexpected state value " + state);
    }

    private static Event upEvent(State state) {
        switch (state) {
            case INITIALIZED:
            case DESTROYED:
                return ON_CREATE;
            case CREATED:
                return ON_START;
            case STARTED:
                return ON_RESUME;
            case RESUMED:
                throw new IllegalArgumentException();
        }
        throw new IllegalArgumentException("Unexpected state value " + state);
    }

上面的判断逻辑就是根据下一个目标生命周期的变化，与要执行的Event之间的转换，逻辑如下图：

按照我们上面的举例，从Resumed变为Started，从上图可以看出执行的Event是ON_PAUSE，与我们的猜想一致，总结一下Lifecycle对状态的处理流程：

实现LifecycleOwner获取LifecycleRegistry实例
绑定并存储HolderFragment
当HolderFragment生命周期改变时，调用handleLifecycleEvent处理事件
LifecycleRegistry根据要执行的Event获取要改变的状态和当前储存的状态
比较两个状态，获取真正要执行的Lifecycle.Event
调用储存的ObserverWithState的dispatchEvent（）发送事件

事件的处理流程已经清楚了，那么mState和ObserverWithState实例是什么时候存储的？又执行了哪些操作呢？那现在就从第一步添加开始看

2.5、添加Observer

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

ObserverWithState

上述过程中获取了要执行的Event后，调用了Observer的dispatchEvent（）发送事件，我么知道此时调用的就是ObserverWithState .dispatchEvent（）方法，ObserverWithState封装了State和GenericLifecycleObserver 实例，在dispatchEvent（）又调用了mLifecycleObserver.onStateChanged(owner, event)，所以事件真正的执行是从onStateChanged（）开始的。

 static class ObserverWithState {
        State mState;
        GenericLifecycleObserver mLifecycleObserver;

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

在ObserverWithState 的初始化过程中，同时调用了Lifecycling.getCallback(observer)创建了GenericLifecycleObserver实例

GenericLifecycleObserver

GenericLifecycleObserver的通过Lifecycling.getCallback(observer) 创建实例

 @NonNull
    static GenericLifecycleObserver getCallback(Object object) {
        if (object instanceof FullLifecycleObserver) {
            return new FullLifecycleObserverAdapter((FullLifecycleObserver) object);
        }

        if (object instanceof GenericLifecycleObserver) {
            return (GenericLifecycleObserver) 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);
        }
        return new ReflectiveGenericLifecycleObserver(object);
    }

创建不同的GenericLifecycleObserver并传入GeneratedAdapter实例，以SingleGeneratedAdapterObserver为例，实现GenericLifecycleObserver的接口重写onStateChange（）方法，在方法内部调用GeneratedAdapter的callMethod（）执行设定Observer的相关方法。

public class SingleGeneratedAdapterObserver implements GenericLifecycleObserver {

    private final GeneratedAdapter mGeneratedAdapter;

    SingleGeneratedAdapterObserver(GeneratedAdapter generatedAdapter) {
        mGeneratedAdapter = generatedAdapter;
    }

    @Override
    public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
        mGeneratedAdapter.callMethods(source, event, false, null);
        mGeneratedAdapter.callMethods(source, event, true, null);
    }
}

在使用Debug追踪方法执行，在Lifecycling.getCallback(observer)中返回的是ReflectiveGenericLifecycleObserver，查看源码

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

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

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

在构造函数中，初始化CallbackInfo实例，储存了Observer中定义的方法注解，在CallbackInfo的类中有一段代码比较明显：

//获取Observer的所有方法
 Method[] methods = declaredMethods != null ? declaredMethods : getDeclaredMethods(klass);
        boolean hasLifecycleMethods = false;
        for (Method method : methods) {
            // 获取方法的注解
            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 
            Lifecycle.Event event = annotation.value();

            if (params.length > 1) {
                callType = CALL_TYPE_PROVIDER_WITH_EVENT;
              ...
             }
              //创建MethodReference 封装了参数和方法
            MethodReference methodReference = new MethodReference(callType, method);
            verifyAndPutHandler(handlerToEvent, methodReference, event, klass);
        }
         // 创建并保存CallbackInfo实例
        CallbackInfo info = new CallbackInfo(handlerToEvent);
        mCallbackMap.put(klass, info);
        mHasLifecycleMethods.put(klass, hasLifecycleMethods);
        return info;

上述执行的逻辑很清楚，里面的几个属性需要简单说明：

MethodReference：封装了Method的参数类型和方法
handlerToEvent：是一个Map<MethodReference, Lifecycle.Event>，保存MethodReference和对应的Lifecycle.Event事件，上述调用的verifyAndPutHandler（）就是将MethodReference和Lifecycle.Event放进Map
mCallbackMap：Map<Class, CallbackInfo>，储存Observer的类对应的CallbackInfo
mHasLifecycleMethods：用于标注Observer类是否有注解的方法

所以在ReflectiveGenericLifecycleObserver中的CallbackInfo是储存了Observer中方法信息的实例，我们只需要在使用的时候获取并调用其中的方法，所以ReflectiveGenericLifecycleObserver的onStateChange（）中调用mInfo.invokeCallbacks(source, event, mWrapped)执行相应的方法，对于添加执行的逻辑总结：

初始化State为INITIALIZED或Destroy状态
调用ClassesInfoCache.sInstance.getInfo（），遍历获取Observer中的所有注解、参数和方法，并对应储存
创建ObserverWithState保存状态和CallbackInfo

到此结束，执行的时候只是按照上面的执行逻辑取出存储的ObserverWithState中的信息，即可在生命周期改变时，提取储存的方法和注解，找到目标方法，执行我们注解的Observer中的逻辑了。

三、实战

因为前面使用篇已经介绍过用法了，此处至简单看一下内部执行时的数据

MyObserver：简单创建了LifecyclerObserver子类，并定义两个方法

class MyLifeObserver : LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun start() {
        Log.e("LifecycleObserver = ", "Start")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun resume() {
        Log.e("LifecycleObserver = ", "Resume")
    }

}

添加时初始化ObserverWithState时储存的信息：获取到的正是我们定义的方法

点击并拖拽以移动

事件变化时的处理 onStateChange（），最终调用方法如下：

点击并拖拽以移动

其中handlers的数据就是根据Lifecycler.Event获取到的注解方法：

点击并拖拽以移动

到此Lifecycler组件的使用和源码分析到此结束了，希望有助于对此组件的理解和使用。