Lifecycle组件的原理解析

时间 2019-12-04

标签 lifecycle 组件原理解析繁體版

原文原文链接

Lifecycle组件，做为LiveDada和ViewModel的支撑的同时，也为咱们提供了一种新的监控生命周期的方法，因此咱们颇有必要了解一下其实现方式。 #1.从getLifecycle()开始经过Lifecycle的使用流程发现，咱们实现的LifecycleObserver的最终都要在Lifecycle#addObserver中注册。那么Lifecycle到底是什么呢。查阅源码咱们发现，该类是一个抽象类，声明了三个重要的方法：java

addObserver(@NonNull LifecycleObserver observer)
removeObserver(@NonNull LifecycleObserver observer)
getCurrentState() 经过前两个方法，咱们能够添加/删除回调，而经过getCurrentState()则能够获取一个State类型的实例，来知晓当前Activity/Fragment生命周期，State类声明以下：

public enum State {
        /** * Destroyed state for a LifecycleOwner. After this event, this Lifecycle will not dispatch * any more events. For instance, for an {@link android.app.Activity}, this state is reached * <b>right before</b> Activity's {@link android.app.Activity#onDestroy() onDestroy} call. */
        DESTROYED,

        /** * Initialized state for a LifecycleOwner. For an {@link android.app.Activity}, this is * the state when it is constructed but has not received * {@link android.app.Activity#onCreate(android.os.Bundle) onCreate} yet. */
        INITIALIZED,

        /** * Created state for a LifecycleOwner. For an {@link android.app.Activity}, this state * is reached in two cases: * <ul> * <li>after {@link android.app.Activity#onCreate(android.os.Bundle) onCreate} call; * <li><b>right before</b> {@link android.app.Activity#onStop() onStop} call. * </ul> */
        CREATED,

        /** * Started state for a LifecycleOwner. For an {@link android.app.Activity}, this state * is reached in two cases: * <ul> * <li>after {@link android.app.Activity#onStart() onStart} call; * <li><b>right before</b> {@link android.app.Activity#onPause() onPause} call. * </ul> */
        STARTED,

        /** * Resumed state for a LifecycleOwner. For an {@link android.app.Activity}, this state * is reached after {@link android.app.Activity#onResume() onResume} is called. */
        RESUMED;

        /** * Compares if this State is greater or equal to the given {@code state}. * * @param state State to compare with * @return true if this State is greater or equal to the given {@code state} */
        public boolean isAtLeast(@NonNull State state) {
            return compareTo(state) >= 0;
        }
    }
复制代码

注释很好的解释了每种状态的意义。那么这个Lifecycle又是什么时候在Activity/Fragment中赋值的呢？android

Activity Activity的getLifecycle()方法以下：

public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }
复制代码

mLifecycleRegistry是LifecycleRegistry类型的，而LifecycleRegistry是Lifecycle的子类，其在Activity被构造时便已经生成：app

private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
复制代码

能够看到，这里把Activity做为参数传给了LifecycleRegistry，其构造函数以下：ide

public LifecycleRegistry(@NonNull LifecycleOwner provider) {
        mLifecycleOwner = new WeakReference<>(provider);
        mState = INITIALIZED;
    }
复制代码

而ComponentActivity实现了如下接口：函数

LifecycleOwner
ViewModelStoreOwner
SavedStateRegistryOwner LifecycleOwner接口仅仅声明了getLifecycle()这一个方法。咱们先把目光放在LifecycleRegistry#addObserver()上:

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;
        }
        // 这里使用弱引用的方式防止Activity泄露
        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--;
    }
复制代码

该方法经过mObserverMap.putIfAbsent(observer, statefulObserver)将监听器填入到mObserverMap，该变量实际就是一个链表map，key为LifecycleObserver。实际上最终的生命周期回调都是在ObserverWithState#dispatchEvent(LifecycleOwner, Event)完成的，该类的存在，主要是为了处理临时添加监听器致使的状态不一致的问题。那么Lifecycle到底是如何感知声明周期的呢，答案在ComponentActivity#onCreate()中：ui

protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mSavedStateRegistryController.performRestore(savedInstanceState);
        // 关键代码
        ReportFragment.injectIfNeededIn(this);
        if (mContentLayoutId != 0) {
            setContentView(mContentLayoutId);
        }
    }
复制代码

咱们继续看ReportFragment.injectIfNeededIn():this

public static void injectIfNeededIn(Activity activity) {
        // ProcessLifecycleOwner should always correctly work and some activities may not extend
        // FragmentActivity from support lib, so we use framework fragments for activities
        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();
        }
    }
复制代码

该方法的做用就是若是当前Activity不存在ReportFragment便添加一个。manager.executePendingTransactions()这一行很关键，表示这一操做并不会添加到FragmentManager的消息队列中，而是当即执行，以此指望该Fragment可以第一被添加到Activity中。相信不少读者此时已经猜出答案了：Lifecycle正是经过一个无界面的Fragment来感知Activity的生命周期的。但这是以前版本的实现方式，在最新AndroidX 2.2.0版本中，采用了在相关生命周期中直接调用的方式来实现，以State.CREATED为例，该状态在ComponentActivity#onSaveInstanceState()被回调：spa

protected void onSaveInstanceState(@NonNull Bundle outState) {
        Lifecycle lifecycle = getLifecycle();
        if (lifecycle instanceof LifecycleRegistry) {
            // 关键代码
            ((LifecycleRegistry) lifecycle).markState(Lifecycle.State.CREATED);
        }
        super.onSaveInstanceState(outState);
        mSavedStateRegistryController.performSave(outState);
    }
复制代码

能够发现，CREATED这一状态实在onCreate()调用以后，onSaveInstanceState()调用以前切换的，而LifecycleRegistry#markState内部则会经过sync()方法来让每个Observer都追遇上当前的状态。这里之因此用追赶，是由于它并不会只通知当前状态，而是从observer所处的状态过渡到当前状态，这期间通过的每一状态都会产生回调，与Fragment生命周期颇为类似:code

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);
                observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
                popParentState();
            }
        }
    }

    private void backwardPass(LifecycleOwner lifecycleOwner) {
        Iterator<Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
                mObserverMap.descendingIterator();
        while (descendingIterator.hasNext() && !mNewEventOccurred) {
            Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();
            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();
            }
        }
    }
复制代码

回调代码以下[ObserverWithState#dispatchEvent()]：orm

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

这里的mLifecycleObserver类型为LifecycleEventObserver,它是在ObserverWithState构造函数中经过Lifecycling.lifecycleEventObserver(observer)生成的，其实是Lifecycling的实例。那么咱们转到Lifecycling.lifecycleEventObserver(),看看他作了什么：

static LifecycleEventObserver lifecycleEventObserver(Object object) {
        // LifecycleEventObserver 仅拥有onStateChanged()方法的接口
        boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
        // FullLifecycleObserver 拥有所有生命周期回调的接口
        boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
        // 若是同时实现了这两个接口
        if (isLifecycleEventObserver && isFullLifecycleObserver) {
            // FullLifecycleObserverAdapter是FullLifecycleObserver，LifecycleEventObserver
            // 的适配器，实现的是LifecycleEventObserver接口，用于在onStateChanged()转发生命周期
            return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,
                    (LifecycleEventObserver) object);
        }
        // 若是仅实现了FullLifecycleObserver
        if (isFullLifecycleObserver) {
            return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
        }
        // 若是仅实现了LifecycleEventObserver 直接返回该observer
        if (isLifecycleEventObserver) {
            return (LifecycleEventObserver) object;
        }
        // 若是使用的是
        final Class<?> klass = object.getClass();
        int type = getObserverConstructorType(klass);
        // 若是是生成类型 @OnLifecycleEvent 注解
        if (type == GENERATED_CALLBACK) {
            // 获取GeneratedAdapter的列表
            List<Constructor<? extends GeneratedAdapter>> constructors =
                    sClassToAdapters.get(klass);
            // 若是仅存在一个对应的adapter
            if (constructors.size() == 1) {
                GeneratedAdapter generatedAdapter = createGeneratedAdapter(
                        constructors.get(0), object);
                // 经过反射生成GeneratedAdapter并填入dadoter
                return new SingleGeneratedAdapterObserver(generatedAdapter);
            }
            // 若是父类及接口列表中有多个实现了LifecycleObserver，则对应的adapter都会收到通知
            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);
        }
        // 若是是反射类型，直接反射调用
        // 反射方法支持三种声明：
        // 1.没有参数
        // 2.仅有LifecycleOwner
        // 3.(LifecycleOwner,Lifecycle.Event)
        return new ReflectiveGenericLifecycleObserver(object);
    }
复制代码

这里是解析咱们自定义的LifecycleObserver的关键，主要作了如下工做，即识别Observer的类型并返回包装类：

LifecycleEventObserver或者FullLifecycleObserver的实现类，则直接返回对应适配器，这些适配器主要是为了兼顾使用@OnLifecycleEvent的方式。
使用@OnLifecycleEvent的方式
- 有生成类 xxx_LifecycleAdapter,则包装生成类 CompositeGeneratedAdaptersObserver
- 没有生成类，使用反射方式包装：ReflectiveGenericLifecycleObserver 由此看出最终都是经过包装类，最终调用到咱们自定义的Observer，完成生命周期的回调。

Fragment的实现与Activity相似，咱们先看LifecycleRegistry的生成：

private void initLifecycle() {
        mLifecycleRegistry = new LifecycleRegistry(this);
        mSavedStateRegistryController = SavedStateRegistryController.create(this);
        if (Build.VERSION.SDK_INT >= 19) {
            mLifecycleRegistry.addObserver(new GenericLifecycleObserver() {
                @Override
                public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {
                    if (event == Lifecycle.Event.ON_STOP) {
                        if (mView != null) {
                            mView.cancelPendingInputEvents();
                        }
                    }
                }
            });
        }
    }
复制代码

该方法在FragmentManagerImpl#makeInactive中调用，用于初始化LifecycleRegistry。那么又是如何感知Fragment的生命周期的呢？答案在Fragment的performXXX方法中，以onCreated为例：

void performCreate(Bundle savedInstanceState) {
        mChildFragmentManager.noteStateNotSaved();
        mState = CREATED;
        mCalled = false;
        mSavedStateRegistryController.performRestore(savedInstanceState);
        onCreate(savedInstanceState);
        mIsCreated = true;
        if (!mCalled) {
            throw new SuperNotCalledException("Fragment " + this
                    + " did not call through to super.onCreate()");
        }
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
    }
复制代码

handleLifecycleEvent()一样调用了makeState()来变动状态。而Fragment的performXXX正是由FragmentManagerImpl调用的。至此便实现了Fragment声明周期的感知。