Lifecycle 源码分析

lifecycle 生命周期，是什么？为什么要设计这个？如何使用？

是什么？生命周期的抽象类

为什么要设计？我们都知道，activity和fragment等控件，都是有生命周期，而我们可以在各个生命周期内做相应的操作，比如说oncreate中创建对象，ondestory中销毁对象等。其实这样设计已经非常明确告诉了我们该在哪里做什么事情，但是最大的弊端就是，耦合性太高了，我们封装一些第三控件或者第三方库，会完全和我们的宿主耦合起来，这样就会造成如果使用方没有在相应的生命周期内调用我们的方法，则会出现一些bug或者是内存泄漏等问题。因此，这个生命周期类的作用就体现出来了，他可以将宿主activity或fragment等的生命周期完全告知自定义控件、第三方库，所有的有关生命周期的操作都可以封装到内部去实现，使用者无需关注业务之外的代码了。

如何使用？

第一部分：源码头文档翻译

/**
 * Defines an object that has an Android Lifecycle. {@link androidx.fragment.app.Fragment Fragment}
 * and {@link androidx.fragment.app.FragmentActivity FragmentActivity} classes implement
 * {@link LifecycleOwner} interface which has the {@link LifecycleOwner#getLifecycle()
 * getLifecycle} method to access the Lifecycle. You can also implement {@link LifecycleOwner}
 * in your own classes.
 //定义了一个具有安卓生命周期的类。fragment和activity已经拥有可以管理生命周期的类，可以用来管理生命周期，你也可以在自己的类中实现生命周期管理的类LifecycleOwner。
 * <p>
 * {@link Event#ON_CREATE}, {@link Event#ON_START}, {@link Event#ON_RESUME} events in this class
 * are dispatched <b>after</b> the {@link LifecycleOwner}'s related method returns.
 //oncreate\onstart\onresume 生命周期的回调是在宿主的相应的生命周期之后回调。
 * {@link Event#ON_PAUSE}, {@link Event#ON_STOP}, {@link Event#ON_DESTROY} events in this class
 * are dispatched <b>before</b> the {@link LifecycleOwner}'s related method is called.
 //onpause\onstop\ondestory 生命周期回调是在宿主的相应生命周期之前回调。
 * For instance, {@link Event#ON_START} will be dispatched after
 * {@link android.app.Activity#onStart onStart} returns, {@link Event#ON_STOP} will be dispatched
 * before {@link android.app.Activity#onStop onStop} is called.
 //例如：onstart方法会在activity的onstart方法后调用，onstop会在activity的onstop方法之后回调。
 * This gives you certain guarantees on which state the owner is in.
//这个类提供给你了宿主的生命周期。
 * <p>
 * If you use <b>Java 8 Language</b>, then observe events with {@link DefaultLifecycleObserver}.
 * To include it you should add {@code "androidx.lifecycle:lifecycle-common-java8:<version>"} to
 * your build.gradle file.
 * <pre>
 * class TestObserver implements DefaultLifecycleObserver {
 *     {@literal @}Override
 *     public void onCreate(LifecycleOwner owner) {
 *         // your code
 *     }
 * }
 * </pre>
 //如果用java8那么可以用 DefaultLifecycleObserver 
 * If you use <b>Java 7 Language</b>, Lifecycle events are observed using annotations.
 * Once Java 8 Language becomes mainstream on Android, annotations will be deprecated, so between
 * {@link DefaultLifecycleObserver} and annotations,
 * you must always prefer {@code DefaultLifecycleObserver}.
 * <pre>
 * class TestObserver implements LifecycleObserver {
 *   {@literal @}OnLifecycleEvent(ON_STOP)
 *   void onStopped() {}
 * }
 * </pre>
 * <p>
 //如果用java7，那么可以用注解，并且在java8中已经被弃用了。
 * Observer methods can receive zero or one argument.
 * If used, the first argument must be of type {@link LifecycleOwner}.
 //使用注解，观察者可以收到0或者1个参数，并且第一个参数必须是LifecycleOwner
 * Methods annotated with {@link Event#ON_ANY} can receive the second argument, which must be
 //ON_ANY注解可以收到2个参数，第二个参数必须是Event，实例如下：
 * of type {@link Event}.
 * <pre>
 * class TestObserver implements LifecycleObserver {
 *   {@literal @}OnLifecycleEvent(ON_CREATE)
 *   void onCreated(LifecycleOwner source) {}
 *   {@literal @}OnLifecycleEvent(ON_ANY)
 *   void onAny(LifecycleOwner source, Event event) {}
 * }
 * </pre>
 * These additional parameters are provided to allow you to conveniently observe multiple providers
 * and events without tracking them manually.
 */

头文件中我们可以知道：

1.这个类是提供生命周期的类，并且activity和fragment中已经提供了

2.onCreate/onStart/onResume 方法会在activity的对应方法之后回调

   onPause/onStop/onDestory 方法会在activity的对应方法之前回调

3.java 8中可以使用DefaultLifecycleObserver ，java7中使用注解方式，但是注解方式已经被废弃

第二部分：源码解析

   public abstract class Lifecycle { 

    //添加观察者
    @MainThread
    public abstract void addObserver(@NonNull LifecycleObserver observer);

    //移除观察者
    @MainThread
    public abstract void removeObserver(@NonNull LifecycleObserver observer);

    //获取当前宿主的生命周期
    @MainThread
    @NonNull
    public abstract State getCurrentState();
   

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

三个抽象方法，分为被添加观察者、移除观察者、获取宿主生命周期，以及枚举类定义的宿主生命周期。因为这是个抽象类，所以我们需要分析他的具体实现类，LifecycleRegistry 如何实现这三个方法的。

第三部分：LifecycleRegistry 源码分析

1.添加观察者

//保存所有的观察者，linkhashmap保存，key是观察者，value是LifecycleEventObserver包装类
private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap =
            new FastSafeIterableMap<>();

//LifecycleEventObserver包装类
static class ObserverWithState {
        //宿主状态
        State mState;
        //观察者
        LifecycleEventObserver mLifecycleObserver;

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

        void dispatchEvent(LifecycleOwner owner, Event event) {
            State newState = event.getTargetState();
            mState = min(mState, newState);
            //调用观察者的onStateChanged方法，通知观察者
            mLifecycleObserver.onStateChanged(owner, event);
            mState = newState;
        }
    }


    //添加观察者
    @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) {
            return;
        }
        //所有观察者当前状态和宿主当前状态对比，如果不一样则降级或者升级，同时回调观察者方法
        boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
        State targetState = calculateTargetState(observer);
        mAddingObserverCounter++;
        while ((statefulObserver.mState.compareTo(targetState) < 0
                && mObserverMap.contains(observer))) {
            pushParentState(statefulObserver.mState);
            final Event event = Event.upFrom(statefulObserver.mState);
            //调用包装类方法，然后调用观察者方法
            statefulObserver.dispatchEvent(lifecycleOwner, event);
            popParentState();
            targetState = calculateTargetState(observer);
        }

        if (!isReentrance) {
            sync();
        }
        mAddingObserverCounter--;
    }

添加观察者，将观察者添加到观察者链表中，同时进行生命周期通知回调。

2.移除观察者

@Override
    public void removeObserver(@NonNull LifecycleObserver observer) {
      
        mObserverMap.remove(observer);
    }

就是从链表中移除掉

3.获取当前宿主状态

    @NonNull
    @Override
    public State getCurrentState() {
        return mState;
    }

直接返回宿主状态。

至此，lifecycle源码解析完了，其实lifecycle就是提供了一个生命周期的抽象层，具体使用我们下一篇文章分析。