Android架构组件二 Android Architecture Components Lifecycles 组件解析

1 前言

前一篇博文已经初步的介绍了Android Architecture Components的基本概念以及基本使用，相信大家已经对这个组件有了一定的了解，这一篇博文主要来解析Android Architecture Components 的Lifecycles生命周期组件，以便于大家更好的深入理解这个组件。从而更好的进行App架构设计。

2 Lifecycles 的作用

生命周期管理（Lifecycles）组件，官方解释是帮助开发者创建 “可感知生命周期的” 组件，让其自己管理自己的生命周期，从而减少内存泄露和崩溃的可能性。参考
https://developer.android.google.cn/topic/libraries/architecture/lifecycle.html

从官方的说明知道，Lifecycles的作用是监测Activity/Fragment等生命周期组件在生命周期变化时，能及时通知其他组件。
在Lifecycles出现以前，我们需要手动的在Activity/Fragment的生命周期中通知其他组件，并且往往会定义基类的Activity/Fragment来达到代码复用的目的。在传统的MVP中，Activity/Fragment充当了V的角色，由于引用了P，为了防止空指针引用和减少内存泄漏，我们都会在V层的生命周期中回调P，从而避免这些问题，这些代码往往会被定义层基类及泛型。对开发者的开发能力增加了一定的要求。google应该是看到了传统的Activity/Fragment的这些缺陷，从而发布了这个Android Architecture Components 来改善Android 程序的开发。
在android support组件升级到26.1.0之后，Fragment和FragmentActivity都已经默认实现了Lifecycles接口，相信在不久的将来，Activity也会实现Lifecycles接口

Fragment 实现了LifecycleOwner 接口

public class Fragment implements ComponentCallbacks, OnCreateContextMenuListener, LifecycleOwner {    private static final SimpleArrayMap> sClassMap =            new SimpleArrayMap>();.....

SupportActivity 实现了LifecycleOwner 接口

public class SupportActivity extends Activity implements LifecycleOwner {    /**     * Storage for {@link ExtraData} instances.     *     * Note that these objects are not retained across configuration changes
     */    private SimpleArrayMap, ExtraData> mExtraDataMap =            new SimpleArrayMap<>();    private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);.....public class FragmentActivity extends BaseFragmentActivityApi16 implements        ActivityCompat.OnRequestPermissionsResultCallback,        ActivityCompat.RequestPermissionsRequestCodeValidator {    private static final String TAG = "FragmentActivity";

FragmentActivity 最终会继承SupportActivity ，都会实现LifecycleOwner 接口

这样，Google从官方上解决了Activity/Fragment在生命周期变化时，其他组件之前无法感知的问题。

3 Lifecycles 类图

Lifecycles 组件涉及到的类和接口并不多，大多数都在android.arch.lifecycle这个包下，查看源码，我们可以画出如下的UML类图
Android架构组件二 Android Architecture Components Lifecycles 组件解析_第1张图片
可以看到，包含以下几个重要的类
LifecycleOwner 接口

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

该接口返回一个Lifecycle 对象，Activity/Fragment都需要实现该接口，这样Activity/Fragment都会有自己的Lifecycle 的对象了

Lifecycle

public abstract class Lifecycle {    /**     * Adds a LifecycleObserver that will be notified when the LifecycleOwner changes     * state.     *      * The given observer will be brought to the current state of the LifecycleOwner.     * For example, if the LifecycleOwner is in {@link State#STARTED} state, the given observer     * will receive {@link Event#ON_CREATE}, {@link Event#ON_START} events.     *     * @param observer The observer to notify.     */    @MainThread    public abstract void addObserver(@NonNull LifecycleObserver observer);    /**     * Removes the given observer from the observers list.     * 
     * If this method is called while a state change is being dispatched,     * 
     * If the given observer has not yet received that event, it will not receive it.     * 
If the given observer has more than 1 method that observes the currently dispatched     * event and at least one of them received the event, all of them will receive the event and     * the removal will happen afterwards.     * 
     *     * @param observer The observer to be removed.     */    @MainThread    public abstract void removeObserver(@NonNull LifecycleObserver observer);    /**     * Returns the current state of the Lifecycle.     *     * @return The current state of the Lifecycle.     */    @MainThread    public abstract State getCurrentState();    @SuppressWarnings("WeakerAccess")    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    }    /**     * Lifecycle states. You can consider the states as the nodes in a graph and     * {@link Event}s as the edges between these nodes.     */    @SuppressWarnings("WeakerAccess")    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         * right before 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:         *          *     after {@link android.app.Activity#onCreate(android.os.Bundle) onCreate} call;         *     
right before {@link android.app.Activity#onStop() onStop} call.         * 
         */        CREATED,        /**         * Started state for a LifecycleOwner. For an {@link android.app.Activity}, this state         * is reached in two cases:         *          *     after {@link android.app.Activity#onStart() onStart} call;         *     
right before {@link android.app.Activity#onPause() onPause} call.         * 
         */        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对象提供了添加和移除LifecycleObserver的接口，

    @MainThread    public abstract void addObserver(@NonNull LifecycleObserver observer);    @MainThread    public abstract void removeObserver(@NonNull LifecycleObserver observer);    @MainThread    public abstract State getCurrentState();

这里运用了观察者模式，将Activity/Fragment的状态作为被观察者，提供给感兴趣的观察者组件。

另外，Lifecycle里面有两个内部枚举类Event和State
Event共有7个类型，分别对应于Activity/Fragment的onCreate() – onDestory()，其中ON_ANY表示匹配任一生命周期
State根据注释的解释如下：
DESTROYED：在Activity/Fragment将要回调onDestory()时，该状态之后Lifecycle将不会分发任何事件
**INITIALIZED：**Activity/Fragment被创建实例，但是还没有回调onCreate()方法，作为一个初始状态
CREATED：两种情况，一是在Activity/Fragment回调onCreate()之后，onStart()之前。二是在onStop()回调之前的状态
STARTED：两种情况，一是在Activity/Fragment回调onStart()之后，onResume()之前。二是在onPause()回调之前的状态
RESUMED：在Activity/Fragment回调onResume()之后的状态
关于State与Event之间的状态转化，可以用官方的如下图表示
Android架构组件二 Android Architecture Components Lifecycles 组件解析_第2张图片

另外Lifecycle是一个抽象类，具体的实现是在LifecycleRegistry 类中

public class LifecycleRegistry extends Lifecycle {    private static final String LOG_TAG = "LifecycleRegistry";    /**     * Custom list that keeps observers and can handle removals / additions during traversal.     *     * Invariant: at any moment of time for observer1 & observer2:     * if addition_order(observer1) < addition_order(observer2), then     * state(observer1) >= state(observer2),     */    private FastSafeIterableMap mObserverMap =            new FastSafeIterableMap<>();    /**     * Current state     */    private State mState;    /**     * The provider that owns this Lifecycle.     * Only WeakReference on LifecycleOwner is kept, so if somebody leaks Lifecycle, they won't leak     * the whole Fragment / Activity. However, to leak Lifecycle object isn't great idea neither,     * because it keeps strong references on all other listeners, so you'll leak all of them as     * well.     */    private final WeakReference mLifecycleOwner;    private int mAddingObserverCounter = 0;    private boolean mHandlingEvent = false;    private boolean mNewEventOccurred = false;    // we have to keep it for cases:    // void onStart() {    //     mRegistry.removeObserver(this);    //     mRegistry.add(newObserver);    // }    // newObserver should be brought only to CREATED state during the execution of    // this onStart method. our invariant with mObserverMap doesn't help, because parent observer    // is no longer in the map.    private ArrayList mParentStates = new ArrayList<>();    /**     * Creates a new LifecycleRegistry for the given provider.     *      * You should usually create this inside your LifecycleOwner class's constructor and hold     * onto the same instance.     *     * @param provider The owner LifecycleOwner     */    public LifecycleRegistry(@NonNull LifecycleOwner provider) {        mLifecycleOwner = new WeakReference<>(provider);        mState = INITIALIZED;    }    /**     * Moves the Lifecycle to the given state and dispatches necessary events to the observers.     *     * @param state new state     */    @SuppressWarnings("WeakerAccess")    @MainThread    public void markState(@NonNull State state) {        moveToState(state);    }    /**     * Sets the current state and notifies the observers.     *      * Note that if the {@code currentState} is the same state as the last call to this method,     * calling this method has no effect.     *     * @param event The event that was received     */    public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {        State next = getStateAfter(event);        moveToState(next);    }    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;    }    .....    @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--;    }    ....    @Override    public void removeObserver(@NonNull LifecycleObserver observer) {        // we consciously decided not to send destruction events here in opposition to addObserver.        // Our reasons for that:        // 1. These events haven't yet happened at all. In contrast to events in addObservers, that        // actually occurred but earlier.        // 2. There are cases when removeObserver happens as a consequence of some kind of fatal        // event. If removeObserver method sends destruction events, then a clean up routine becomes        // more cumbersome. More specific example of that is: your LifecycleObserver listens for        // a web connection, in the usual routine in OnStop method you report to a server that a        // session has just ended and you close the connection. Now let's assume now that you        // lost an internet and as a result you removed this observer. If you get destruction        // events in removeObserver, you should have a special case in your onStop method that        // checks if your web connection died and you shouldn't try to report anything to a server.        mObserverMap.remove(observer);    }    /**     * The number of observers.     *     * @return The number of observers.     */    @SuppressWarnings("WeakerAccess")    public int getObserverCount() {        return mObserverMap.size();    }    @Override    public State getCurrentState() {        return mState;    }    .....        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;        }    }}

这里列出来主要的一些接口实现，其他的可以参考源码来阅读，在Activity/Fragment中返回的Lifecycle就是返回LifecycleRegistry

LifecycleObserver

public interface LifecycleObserver {}

LifecycleObserver 是一个空接口，Activity和Fragment的实现是在GenericLifecycleObserver 接口

public interface GenericLifecycleObserver extends LifecycleObserver {    /**     * Called when a state transition event happens.     *     * @param source The source of the event     * @param event The event     */    void onStateChanged(LifecycleOwner source, Lifecycle.Event event);}

可以看到，这里面有一个onStateChanged(LifecycleOwner source, Lifecycle.Event event)方法，这样当Lifecycle组件生命周期变化时，就可以通知LifecycleObserver 的Lifecycle.Event 变化了。

了解了以上的内容，我们从以下几个方面来分析LifeCycles组件的工作过程

1 Activity/Fragment 生命周期事件如何通知LifecycleRegistry？
Activity/Fragment中持有LifecycleRegistry对象，那么是如何进行通讯的呢？
2 LifecycleRegistry 如何通知LifecycleObserver？
LifecycleRegistry对象又是如何把这些事件通知给LifecycleObserver观察者的呢？
3 LifecycleObserver如何处理这些事件？
这个本篇博文暂时不讨论。

4 Lifecycles 解析

1 Activity/Fragment 生命周期事件如何通知LifecycleRegistry？
在Fragment中声明周期在回调的时候，都会调用LifecycleRegistry的handleLifecycleEvent(@NonNull Lifecycle.Event event)来进行与LifecycleRegistry的交互，如下：

void performCreate(Bundle savedInstanceState) {        ...        onCreate(savedInstanceState);        ....        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);    }    void performStart() {        ....        onStart();        ....        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);    }    void performResume() {        ....        onResume();        ....        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);    }    void performPause() {        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);        ....        onPause();        ....    }    void performStop() {        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);        ....        onStop();        ....    }    void performDestroy() {        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY);        ....        onDestroy();        ....    }

这里需要注意的是performCreate()、performStart()、performResume()会先调用自身的onXXX()方法，然后再调用LifecycleRegistry的handleLifecycleEvent()方法；而在performPause()、performStop()、performDestroy()中会先LifecycleRegistry的handleLifecycleEvent()方法，然后调用自身的onXXX()方法。借用一下别人的图，如下：
Android架构组件二 Android Architecture Components Lifecycles 组件解析_第3张图片

这样，Fragment的生命周期状态就被传递到了LifecycleRegistry中，Activity中也应该类似

2 LifecycleRegistry 如何通知LifecycleObserver？
LifecycleRegistry中处理生命周期的核心方法如下：

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

这里逻辑比较简单，就不做说明了。接着调用moveToState(next)更新到下一个状态

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

主要做了两件事，第一就是将mState 置位为相应的状态，调用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;            // no need to check eldest for nullability, because isSynced does it for us.            if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {                backwardPass(lifecycleOwner);            }            Entry newest = mObserverMap.newest();            if (!mNewEventOccurred && newest != null                    && mState.compareTo(newest.getValue().mState) > 0) {                forwardPass(lifecycleOwner);            }        }        mNewEventOccurred = false;    }

这里首先判断了mLifecycleOwner是否为null，如果为null说明不需要进行下面的分发了。接着如果没有同步过就进行状态的同步，主要根据之前添加的观察者的mObserverMap来进行状态同步。mObserverMap定义如下：

    private FastSafeIterableMap mObserverMap =            new FastSafeIterableMap<>();

最终经过一系列的判断和逻辑，这里以forwardPass为例：

    private void forwardPass(LifecycleOwner lifecycleOwner) {        Iterator> ascendingIterator =                mObserverMap.iteratorWithAdditions();        while (ascendingIterator.hasNext() && !mNewEventOccurred) {            Entry 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();            }        }    }

会调用ObserverWithState的dispatchEvent(LifecycleOwner owner, Event event)方法

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

最终会调用到GenericLifecycleObserver #onStateChanged(LifecycleOwner source, Lifecycle.Event event);
这样就把Activity/Fragment的状态通知了LifecycleObserver，实现了观察者感知Activity/Fragment的生命周期

分析到这里，Lifecycles组件分析的也差不多了，Lifecycles如何添加观察者，以及LifecycleObserver如何处理具体事件，下一篇博客再进行分析。

参考：
https://shymanzhu.com/
https://developer.android.google.cn/topic/libraries/architecture/lifecycle.html
https://developer.android.google.cn/topic/libraries/architecture/lifecycle.html

1 前言

2 Lifecycles 的作用

3 Lifecycles 类图

4 Lifecycles 解析

更多相关文章

随机推荐