扒一扒 Lifecycle 的实现

阅读 1080
收藏 27
2018-07-27
原文链接:mp.weixin.qq.com

本文由水晶虾饺授权投稿作者博客:https://jekton.github.io/

Lifecycle 隶属于 Android 官方架构组件,它的实现跟 ViewModel 类似,都是利用 Fragment 来实现它的功能。通过添加一个 fragment 到 activity 中,这个 fragment 便能够接收到各个生命周期回调。

以下源码使用 1.1.1 版本

使用方法简介

这里我并不打算讲太多 lifecycle 的用法,不熟悉的同学,可以阅读这篇[1]

为了使用 lifecycle,首先需要获取到一个 LifecycleOwner。

 1lifecycleOwner.getLifecycle().addObserver(observer); 2 3public interface LifecycleOwner { 4    /** 5     * Returns the Lifecycle of the provider. 6     * 7     * @return The lifecycle of the provider. 8     */ 9    @NonNull10    Lifecycle getLifecycle();11}

使用 support 包时,AppCompatActivity 就是一个 LifecycleOwner。具体的实现是 SupportActivity:

1public class SupportActivity extends Activity implements LifecycleOwner {}

下面,我们就从 SupportActivity 开始分析 lifecycle 组件的实现。

获取生命周期

 1public class SupportActivity extends Activity implements LifecycleOwner { 2 3    private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this); 4 5    @Override 6    public Lifecycle getLifecycle() { 7        return mLifecycleRegistry; 8    } 910    @Override11    protected void onCreate(@Nullable Bundle savedInstanceState) {12        super.onCreate(savedInstanceState);13        // 初始化 ReportFragment14        ReportFragment.injectIfNeededIn(this);15    }16}

可以看到,在上一节中我们执行 lifecycleOwner.getLifecycle() 返回的就是 mLifecycleRegistry。关于 LifecycleRegistry,我们在下一节再看,这里先看 ReportFragment。

ReportFragment 就是我们在一开始说的,用于获取生命周期的 fragment:

  1public class ReportFragment extends Fragment {  2    private static final String REPORT_FRAGMENT_TAG = "android.arch.lifecycle"  3            + ".LifecycleDispatcher.report_fragment_tag";  4  5    public static void injectIfNeededIn(Activity activity) {  6        // ProcessLifecycleOwner should always correctly work and some activities may not extend  7        // FragmentActivity from support lib, so we use framework fragments for activities  8        android.app.FragmentManager manager = activity.getFragmentManager();  9        if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) { 10            manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit(); 11            // Hopefully, we are the first to make a transaction. 12            manager.executePendingTransactions(); 13        } 14    } 15 16    static ReportFragment get(Activity activity) { 17        return (ReportFragment) activity.getFragmentManager().findFragmentByTag( 18                REPORT_FRAGMENT_TAG); 19    } 20 21    private ActivityInitializationListener mProcessListener; 22 23    private void dispatchCreate(ActivityInitializationListener listener) { 24        if (listener != null) { 25            listener.onCreate(); 26        } 27    } 28 29    private void dispatchStart(ActivityInitializationListener listener) { 30        if (listener != null) { 31            listener.onStart(); 32        } 33    } 34 35    private void dispatchResume(ActivityInitializationListener listener) { 36        if (listener != null) { 37            listener.onResume(); 38        } 39    } 40 41    @Override 42    public void onActivityCreated(Bundle savedInstanceState) { 43        super.onActivityCreated(savedInstanceState); 44        dispatchCreate(mProcessListener); 45        dispatch(Lifecycle.Event.ON_CREATE); 46    } 47 48    @Override 49    public void onStart() { 50        super.onStart(); 51        dispatchStart(mProcessListener); 52        dispatch(Lifecycle.Event.ON_START); 53    } 54 55    @Override 56    public void onResume() { 57        super.onResume(); 58        dispatchResume(mProcessListener); 59        dispatch(Lifecycle.Event.ON_RESUME); 60    } 61 62    @Override 63    public void onPause() { 64        super.onPause(); 65        dispatch(Lifecycle.Event.ON_PAUSE); 66    } 67 68    @Override 69    public void onStop() { 70        super.onStop(); 71        dispatch(Lifecycle.Event.ON_STOP); 72    } 73 74    @Override 75    public void onDestroy() { 76        super.onDestroy(); 77        dispatch(Lifecycle.Event.ON_DESTROY); 78        // just want to be sure that we won't leak reference to an activity 79        mProcessListener = null; 80    } 81 82    private void dispatch(Lifecycle.Event event) { 83        Activity activity = getActivity(); 84        if (activity instanceof LifecycleRegistryOwner) { 85            ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event); 86            return; 87        } 88 89        // 对于 SupportActivity 来说,执行的是下面这个 90        if (activity instanceof LifecycleOwner) { 91            Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle(); 92            if (lifecycle instanceof LifecycleRegistry) { 93                ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event); 94            } 95        } 96    } 97 98    void setProcessListener(ActivityInitializationListener processListener) { 99        mProcessListener = processListener;100    }101102    interface ActivityInitializationListener {103        void onCreate();104105        void onStart();106107        void onResume();108    }109}

ReportFragment 的实现很简单,读者自己看看就好。下面我们开始看不那么好理解的 LifecycleRegistry。

生命周期事件的分发

在看代码前,我们先来了解一下 Lifecycle 的状态和事件:

 1public abstract class Lifecycle { 2 3    public enum Event { 4        /** 5         * Constant for onCreate event of the {@link LifecycleOwner}. 6         */ 7        ON_CREATE, 8        /** 9         * Constant for onStart event of the {@link LifecycleOwner}.10         */11        ON_START,12        /**13         * Constant for onResume event of the {@link LifecycleOwner}.14         */15        ON_RESUME,16        /**17         * Constant for onPause event of the {@link LifecycleOwner}.18         */19        ON_PAUSE,20        /**21         * Constant for onStop event of the {@link LifecycleOwner}.22         */23        ON_STOP,24        /**25         * Constant for onDestroy event of the {@link LifecycleOwner}.26         */27        ON_DESTROY,28        /**29         * An {@link Event Event} constant that can be used to match all events.30         */31        ON_ANY32    }3334    /**35     * Lifecycle states. You can consider the states as the nodes in a graph and36     * {@link Event}s as the edges between these nodes.37     */38    public enum State {39        /**40         * Destroyed state for a LifecycleOwner. After this event, this Lifecycle will not dispatch41         * any more events. For instance, for an {@link android.app.Activity}, this state is reached42         * <b>right before</b> Activity's {@link android.app.Activity#onDestroy() onDestroy} call.43         */44        DESTROYED,4546        /**47         * Initialized state for a LifecycleOwner. For an {@link android.app.Activity}, this is48         * the state when it is constructed but has not received49         * {@link android.app.Activity#onCreate(android.os.Bundle) onCreate} yet.50         */51        INITIALIZED,5253        /**54         * Created state for a LifecycleOwner. For an {@link android.app.Activity}, this state55         * is reached in two cases:56         * <ul>57         *     <li>after {@link android.app.Activity#onCreate(android.os.Bundle) onCreate} call;58         *     <li><b>right before</b> {@link android.app.Activity#onStop() onStop} call.59         * </ul>60         */61        CREATED,6263        /**64         * Started state for a LifecycleOwner. For an {@link android.app.Activity}, this state65         * is reached in two cases:66         * <ul>67         *     <li>after {@link android.app.Activity#onStart() onStart} call;68         *     <li><b>right before</b> {@link android.app.Activity#onPause() onPause} call.69         * </ul>70         */71        STARTED,7273        /**74         * Resumed state for a LifecycleOwner. For an {@link android.app.Activity}, this state75         * is reached after {@link android.app.Activity#onResume() onResume} is called.76         */77        RESUMED;7879        /**80         * Compares if this State is greater or equal to the given {@code state}.81         *82         * @param state State to compare with83         * @return true if this State is greater or equal to the given {@code state}84         */85        public boolean isAtLeast(@NonNull State state) {86            return compareTo(state) >= 0;87        }88    }89}

Lifecycle.Event 对应 activity 的各个声明周期,State 则是 Lifecycle 的状态。在 LifecycleRegistry 中定义了状态间的转化关系:

 1public class LifecycleRegistry extends Lifecycle { 2 3    static State getStateAfter(Event event) { 4        switch (event) { 5            case ON_CREATE: 6            case ON_STOP: 7                return CREATED; 8            case ON_START: 9            case ON_PAUSE:10                return STARTED;11            case ON_RESUME:12                return RESUMED;13            case ON_DESTROY:14                return DESTROYED;15            case ON_ANY:16                break;17        }18        throw new IllegalArgumentException("Unexpected event value " + event);19    }2021    private static Event downEvent(State state) {22        switch (state) {23            case INITIALIZED:24                throw new IllegalArgumentException();25            case CREATED:26                return ON_DESTROY;27            case STARTED:28                return ON_STOP;29            case RESUMED:30                return ON_PAUSE;31            case DESTROYED:32                throw new IllegalArgumentException();33        }34        throw new IllegalArgumentException("Unexpected state value " + state);35    }3637    private static Event upEvent(State state) {38        switch (state) {39            case INITIALIZED:40            case DESTROYED:41                return ON_CREATE;42            case CREATED:43                return ON_START;44            case STARTED:45                return ON_RESUME;46            case RESUMED:47                throw new IllegalArgumentException();48        }49        throw new IllegalArgumentException("Unexpected state value " + state);50    }51}

这三个方法,可以总结为下面这样一张图:

android-arch-lifecycle-states

downEvent 在图中表示从一个状态到他下面的那个状态,upEvent 则是往上。

了解了 Lifecycle 的状态后,我们继续来看 LifecycleRegistry。上一节我们知道,activity 的生命周期发生变化后,会调用到 LifecycleRegistry 的 handleLifecycleEvent:

 1public class LifecycleRegistry extends Lifecycle { 2 3    private int mAddingObserverCounter = 0; 4 5    private boolean mHandlingEvent = false; 6    private boolean mNewEventOccurred = false; 7 8    public void handleLifecycleEvent(@NonNull Lifecycle.Event event) { 9        State next = getStateAfter(event);10        moveToState(next);11    }1213    private void moveToState(State next) {14        if (mState == next) {15            return;16        }17        mState = next;18        // 当我们在 LifecycleRegistry 回调 LifecycleObserver 的时候触发状态变化时,19        // mHandlingEvent 为 true;20        // 添加 observer 的时候,也可能会执行回调方法,这时候如果触发了状态变化,21        // 则 mAddingObserverCounter != 022        if (mHandlingEvent || mAddingObserverCounter != 0) {23            mNewEventOccurred = true;24            // 不需要执行 sync。25            // 执行到这里的情况是:sync() -> LifecycleObserver -> moveToState()26            // 这里直接返回后,还是会回到 sync(),然后继续同步状态给 observer27            // we will figure out what to do on upper level.28            return;29        }30        mHandlingEvent = true;31        // sync() 会把状态的变化转化为生命周期事件,然后转发给 LifecycleObserver32        sync();33        mHandlingEvent = false;34    }35}

LifecycleRegistry 本来要做的事其实是很简单的,但由于他需要执行客户的代码,由此引入了很多额外的复杂度。原因是,客户代码并不处在我们的控制之下,他们可能做出任何可以做到的事。例如这里,在回调中又触发状态变化。类似的情况是,在持有锁的时候不调用客户代码,这个也会让实现变得比较复杂。

接下来我们看 sync():

 1public class LifecycleRegistry extends Lifecycle { 2 3    /** 4     * Custom list that keeps observers and can handle removals / additions during traversal. 5     * 6     * 这个 Invariant 非常重要,他会影响到 sync() 的逻辑 7     * Invariant: at any moment of time for observer1 & observer2: 8     * if addition_order(observer1) < addition_order(observer2), then 9     * state(observer1) >= state(observer2),10     */11    private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap =12            new FastSafeIterableMap<>();131415    // happens only on the top of stack (never in reentrance),16    // so it doesn't have to take in account parents17    private void sync() {18        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();19        if (lifecycleOwner == null) {20            Log.w(LOG_TAG, "LifecycleOwner is garbage collected, you shouldn't try dispatch "21                    + "new events from it.");22            return;23        }24        while (!isSynced()) {25            // mNewEventOccurred 是为了在 observer 触发状态变化时让 backwardPass/forwardPass()26            // 提前返回用的。我们刚准备调他们,这里设置为 false 即可。27            mNewEventOccurred = false;28            // no need to check eldest for nullability, because isSynced does it for us.29            if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {30                // mObserverMap 里的元素的状态是非递增排列的,也就是说,队头的 state 最大31                // 如果 mState 小于队列里最大的那个,说明有元素需要更新状态32                // 为了维持 mObserverMap 的 Invariant,这里我们需要从队尾往前更新元素的状态33                backwardPass(lifecycleOwner);34            }35            Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();36            // 如果 mNewEventOccurred,说明在上面调用 backwardPass() 时,客户触发了状态修改37            if (!mNewEventOccurred && newest != null38                    && mState.compareTo(newest.getValue().mState) > 0) {39                forwardPass(lifecycleOwner);40            }41        }42        mNewEventOccurred = false;43    }4445    // 如果所有的 observer 的状态都已经同步完,则返回 true46    private boolean isSynced() {47        if (mObserverMap.size() == 0) {48            return true;49        }50        State eldestObserverState = mObserverMap.eldest().getValue().mState;51        State newestObserverState = mObserverMap.newest().getValue().mState;52        // 因为我们保证队头的 state >= 后面的元素的 state,所以只要判断头尾就够了53        return eldestObserverState == newestObserverState && mState == newestObserverState;54    }5556}

sync() 的主要作用就是根据把 mObserverMap 里所有元素的状态都同步为 mState。我们继续看剩下的 backwardPass/forwardPass:

 1public class LifecycleRegistry extends Lifecycle { 2 3    private ArrayList<State> mParentStates = new ArrayList<>(); 4 5 6    private void forwardPass(LifecycleOwner lifecycleOwner) { 7        // 从队头开始迭代 8        Iterator<Entry<LifecycleObserver, ObserverWithState>> ascendingIterator = 9                mObserverMap.iteratorWithAdditions();10        while (ascendingIterator.hasNext() && !mNewEventOccurred) {11            Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();12            ObserverWithState observer = entry.getValue();13            while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred14                    // 可能在回调客户代码的时候,客户把自己移除了15                    && mObserverMap.contains(entry.getKey()))) {16                // pushParentState 和 popParentState 我们下一小节再看,这里先忽略17                pushParentState(observer.mState);18                observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));19                popParentState();20            }21        }22    }2324    private void backwardPass(LifecycleOwner lifecycleOwner) {25        // 从队尾开始迭代26        Iterator<Entry<LifecycleObserver, ObserverWithState>> descendingIterator =27                mObserverMap.descendingIterator();28        while (descendingIterator.hasNext() && !mNewEventOccurred) {29            Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();30            ObserverWithState observer = entry.getValue();31            while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred32                    && mObserverMap.contains(entry.getKey()))) {33                Event event = downEvent(observer.mState);34                pushParentState(getStateAfter(event));35                observer.dispatchEvent(lifecycleOwner, event);36                popParentState();37            }38        }39    }4041    private void popParentState() {42        mParentStates.remove(mParentStates.size() - 1);43    }4445    private void pushParentState(State state) {46        mParentStates.add(state);47    }48}

在看这两个方法时,可以参考上面的状态图。比方说,假设当前队列里的元素都处于 CREATED。接着收到了一个 ON_START 事件,从图里面可以看出,接下来应该是要到 STARTED 状态。由于 STARTED 大于 CREATED,所以会执行 forwardPass()。forwardPass() 里面调用 upEvent(observer.mState),返回从 CREATED 往上到 STARTED 需要发送的事件,也就是 ON_START,于是 ON_START 事件发送给了客户。

注册/注销 observer

注册 observer 由 addObserver 方法完成:

 1public class LifecycleRegistry extends Lifecycle { 2 3    // 这段注释应该是这整个类里面最难理解的了吧,至少对于我来说是这样 4    // we have to keep it for cases: 5    // void onStart() { 6    //     // removeObserver(this),说明 this 是一个 LifecycleObserver 7    //     // 所以这里说的是,我们在回调里执行了下面两个操作 8    //     mRegistry.removeObserver(this); 9    //     mRegistry.add(newObserver);10    // }11    // 假定现在我们要从 CREATED 转到 STARTED 状态(也就是说,mState 现在是 STARTED)。12    // 这种情况下,只有将新的 observer 设置为 CREATED 状态,它的 onStart 才会被调用13    // 为了得到这个 CREATED,在这里才引入了 mParentStates。在 forwardPass 中执行14    // pushParentState(observer.mState) 时,observer.mState 就是我们需要的 CREATED。15    // backwardPass 的情况类似。16    // newObserver should be brought only to CREATED state during the execution of17    // this onStart method. our invariant with mObserverMap doesn't help, because parent observer18    // is no longer in the map.19    private ArrayList<State> mParentStates = new ArrayList<>();202122    private State calculateTargetState(LifecycleObserver observer) {23        Entry<LifecycleObserver, ObserverWithState> previous = mObserverMap.ceil(observer);2425        State siblingState = previous != null ? previous.getValue().mState : null;26        State parentState = !mParentStates.isEmpty() ? mParentStates.get(mParentStates.size() - 1)27                : null;28        // 返回最小的 state29        return min(min(mState, siblingState), parentState);30    }3132    @Override33    public void addObserver(@NonNull LifecycleObserver observer) {34        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;35        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);36        ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);3738        if (previous != null) {39            return;40        }4142        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();43        if (lifecycleOwner == null) {44            // it is null we should be destroyed. Fallback quickly45            return;46        }4748        // 在回调中执行了 addObserver()49        boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;50        State targetState = calculateTargetState(observer);51        mAddingObserverCounter++;52        while ((statefulObserver.mState.compareTo(targetState) < 053                && mObserverMap.contains(observer))) {54            pushParentState(statefulObserver.mState);55            statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));56            popParentState();57            // 我们 dispatch 了一个事件给客户,在回调客户代码的时候,客户可能会修改我们的状态58            // mState / subling may have been changed recalculate59            targetState = calculateTargetState(observer);60        }6162        if (!isReentrance) {63            // we do sync only on the top level.64            sync();65        }66        mAddingObserverCounter--;67    }686970    static class ObserverWithState {71        State mState;72        GenericLifecycleObserver mLifecycleObserver;7374        ObserverWithState(LifecycleObserver observer, State initialState) {75            mLifecycleObserver = Lifecycling.getCallback(observer);76            mState = initialState;77        }7879        void dispatchEvent(LifecycleOwner owner, Event event) {80            State newState = getStateAfter(event);81            mState = min(mState, newState);82            mLifecycleObserver.onStateChanged(owner, event);83            mState = newState;84        }85    }86}

由于篇幅有限,这里的 Lifecycling.getCallback 就不看了。简单提一下,在使用 annotion 的时候,对应的 observer 会生成一个 adapter,这个 adapter 会把对应的 Lifecycle.Event 装换为方法调用:

 1static class BoundLocationListener implements LifecycleObserver { 2    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME) 3    void addLocationListener() {} 4 5    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE) 6    void removeLocationListener() {} 7} 8 9// 生成的代码10public class BoundLocationManager_BoundLocationListener_LifecycleAdapter implements GeneratedAdapter {11  final BoundLocationManager.BoundLocationListener mReceiver;1213  BoundLocationManager_BoundLocationListener_LifecycleAdapter(BoundLocationManager.BoundLocationListener receiver) {14    this.mReceiver = receiver;15  }1617  @Override18  public void callMethods(LifecycleOwner owner, Lifecycle.Event event, boolean onAny,19      MethodCallsLogger logger) {20    boolean hasLogger = logger != null;21    if (onAny) {22      return;23    }24    if (event == Lifecycle.Event.ON_RESUME) {25      if (!hasLogger || logger.approveCall("addLocationListener", 1)) {26        mReceiver.addLocationListener();27      }28      return;29    }30    if (event == Lifecycle.Event.ON_PAUSE) {31      if (!hasLogger || logger.approveCall("removeLocationListener", 1)) {32        mReceiver.removeLocationListener();33      }34      return;35    }36  }37}

注销 observer 的实现就比较简单了:

 1public class LifecycleRegistry extends Lifecycle { 2    @Override 3    public void removeObserver(@NonNull LifecycleObserver observer) { 4        // we consciously decided not to send destruction events here in opposition to addObserver. 5        // Our reasons for that: 6        // 1. These events haven't yet happened at all. In contrast to events in addObservers, that 7        // actually occurred but earlier. 8        // 2. There are cases when removeObserver happens as a consequence of some kind of fatal 9        // event. If removeObserver method sends destruction events, then a clean up routine becomes10        // more cumbersome. More specific example of that is: your LifecycleObserver listens for11        // a web connection, in the usual routine in OnStop method you report to a server that a12        // session has just ended and you close the connection. Now let's assume now that you13        // lost an internet and as a result you removed this observer. If you get destruction14        // events in removeObserver, you should have a special case in your onStop method that15        // checks if your web connection died and you shouldn't try to report anything to a server.16        mObserverMap.remove(observer);17    }18}

恭喜你,相信你现在对 lifecycle 的实现已经胸有成竹,可以愉快地装逼了。

附:[1] https://developer.android.google.cn/topic/libraries/architecture/

— — — END — — —

近期文章回顾

评论