1.类职责说明

Lifecycle:抽象类,定义了Event 生命周期事件 和 State 生命周期状态 的值,并提供observer的add/remove

Event:每个生命周期改变对应的事件

State:生命周期所处的状态

    INITIALIZED---初始化状态
    CREATED---onCreate()调用之后,onStop()调用之前的状态
    STARTED---onStart()调用之后,onPause()调用之前的状态
    RESUMED---onResume()时的状态
    DESTROYED---onDestory()调用时的状态
    

LifecycleOwner:接口,只有一个getLifecycle()方法,返回是一个Lifecycle对象,即向外提供一个具体生命周期的宿主

LifecycleRegistry:继承Lifecycle,主要是管理observer，以及将LifecycleOwner的生命周期变化事件派发给每个observer

LifecycleObserver:观察者,接受来自LifecycleOwner的生命周期变化事件,其主要子类有LifecycleEventObserver 和 FullLifecycleObserver

简单说流程就是LifecycleOwner的生命周期发生变化时,会告知LifecycleRegistry,LifecycleRegistry再将事件传递给每一个LifecycleObserver.

2.具体分析

LifecycleOwner

所有的事件来源于LifecycleOwner,那就从源头出发.

Fragment

androidx.fragment.app.Fragment

public class Fragment implements LifecycleOwner{

    int mState = INITIALIZING;

    LifecycleRegistry mLifecycleRegistry;

    public Fragment() {
        initLifecycle();
    }

    private void initLifecycle() {
        mLifecycleRegistry = new LifecycleRegistry(this);
        ....
    }

    @NonNull
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }
    
    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();
    }

}

在每个生命周期方法前的performxxx()里都告知LifecycleRegistry,生命周期有变化了,至于怎么处理就交给LifecycleRegistry。

（注意Create -> Start -> Resume 是先执行onxxx,再LifecycleRegistry.handleLifecycleEvent, Pause -> Stop - > Destroy 则是反过来）

Activity

androidx.core.app.ComponentActivity

public class ComponentActivity extends Activity implements LifecycleOwner{

        private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

        @Override
        protected void onCreate(@Nullable Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            ReportFragment.injectIfNeededIn(this);
        }
        
        @NonNull
        @Override
        public Lifecycle getLifecycle() {
            return mLifecycleRegistry;
        }
}

Activity里没有直接使用LifecycleRegistry,而是实例化了一个ReportFragment。

ReportFragment

    
 public static void injectIfNeededIn(Activity activity) {
        if (Build.VERSION.SDK_INT >= 29) {
            LifecycleCallbacks.registerIn(activity);
        }
        
        android.app.FragmentManager manager = activity.getFragmentManager();
        if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
            manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
            manager.executePendingTransactions();
        }
    }

    static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
        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);
            }
        }
    }

    private void dispatch(@NonNull Lifecycle.Event event) {
        if (Build.VERSION.SDK_INT < 29) {
            dispatch(getActivity(), event);
        }
    }


    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        dispatch(Lifecycle.Event.ON_CREATE);
    }

    @Override
    public void onStart() {
        super.onStart();
        dispatch(Lifecycle.Event.ON_START);
    }

    @Override
    public void onResume() {
        super.onResume();
        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);
    }
    
    @RequiresApi(29)
    static class LifecycleCallbacks implements Application.ActivityLifecycleCallbacks {

        static void registerIn(Activity activity) {
            activity.registerActivityLifecycleCallbacks(new LifecycleCallbacks());
        }

        @Override
        public void onActivityCreated(@NonNull Activity activity,
                @Nullable Bundle bundle) {
        }

        @Override
        public void onActivityPostCreated(@NonNull Activity activity,
                @Nullable Bundle savedInstanceState) {
            dispatch(activity, Lifecycle.Event.ON_CREATE);
        }

        @Override
        public void onActivityStarted(@NonNull Activity activity) {
        }

        @Override
        public void onActivityPostStarted(@NonNull Activity activity) {
            dispatch(activity, Lifecycle.Event.ON_START);
        }

        @Override
        public void onActivityResumed(@NonNull Activity activity) {
        }

        @Override
        public void onActivityPostResumed(@NonNull Activity activity) {
            dispatch(activity, Lifecycle.Event.ON_RESUME);
        }

        @Override
        public void onActivityPrePaused(@NonNull Activity activity) {
            dispatch(activity, Lifecycle.Event.ON_PAUSE);
        }

        @Override
        public void onActivityPaused(@NonNull Activity activity) {
        }

        @Override
        public void onActivityPreStopped(@NonNull Activity activity) {
            dispatch(activity, Lifecycle.Event.ON_STOP);
        }

        @Override
        public void onActivityStopped(@NonNull Activity activity) {
        }

        @Override
        public void onActivitySaveInstanceState(@NonNull Activity activity,
                @NonNull Bundle bundle) {
        }

        @Override
        public void onActivityPreDestroyed(@NonNull Activity activity) {
            dispatch(activity, Lifecycle.Event.ON_DESTROY);
        }

        @Override
        public void onActivityDestroyed(@NonNull Activity activity) {
        }
    }
}

这里有个api版本判断,<29的 Activity会实例化ReportFragment,使用ReportFragment的生命周期变化 来告知LifecycleRegistry。

至于>=29的,使用LifecycleCallbacks.registerIn给activity注册一个LifecycleCallbacks回调,在回调的生命周期方法里将activity和Event传给dispatch方法,dispatch方法里依然使用LifecycleRegistry.handleLifecycleEvent进行处理。

那activity是怎样回调到LifecycleCallbacks？

以下是api=30的Activity简化的源码

android.app.Activity

public class Activity{

    private final ArrayList<Application.ActivityLifecycleCallbacks> mActivityLifecycleCallbacks =
            new ArrayList<Application.ActivityLifecycleCallbacks>();

    public void registerActivityLifecycleCallbacks(
            @NonNull Application.ActivityLifecycleCallbacks callback) {
        synchronized (mActivityLifecycleCallbacks) {
            mActivityLifecycleCallbacks.add(callback);
        }
    }            


    public void unregisterActivityLifecycleCallbacks(
            @NonNull Application.ActivityLifecycleCallbacks callback) {
        synchronized (mActivityLifecycleCallbacks) {
            mActivityLifecycleCallbacks.remove(callback);
        }
    }

    private Object[] collectActivityLifecycleCallbacks() {
        Object[] callbacks = null;
        synchronized (mActivityLifecycleCallbacks) {
            if (mActivityLifecycleCallbacks.size() > 0) {
                callbacks = mActivityLifecycleCallbacks.toArray();
            }
        }
        return callbacks;
    }

    final void performCreate(Bundle icicle, PersistableBundle persistentState) {
        dispatchActivityPreCreated(icicle);
        if (persistentState != null) {
            onCreate(icicle, persistentState);
        } else {
            onCreate(icicle);
        }
        dispatchActivityPostCreated(icicle);
    }

    protected void onCreate(@Nullable Bundle savedInstanceState) {
        dispatchActivityCreated(savedInstanceState);
    }

    private void dispatchActivityPreCreated(@Nullable Bundle savedInstanceState) {
        getApplication().dispatchActivityPreCreated(this, savedInstanceState);
        Object[] callbacks = collectActivityLifecycleCallbacks();
        if (callbacks != null) {
            for (int i = 0; i < callbacks.length; i++) {
                ((Application.ActivityLifecycleCallbacks) callbacks[i]).onActivityPreCreated(this,
                        savedInstanceState);
            }
        }
    }

    private void dispatchActivityCreated(@Nullable Bundle savedInstanceState) {
        getApplication().dispatchActivityCreated(this, savedInstanceState);
        Object[] callbacks = collectActivityLifecycleCallbacks();
        if (callbacks != null) {
            for (int i = 0; i < callbacks.length; i++) {
                ((Application.ActivityLifecycleCallbacks) callbacks[i]).onActivityCreated(this,
                        savedInstanceState);
            }
        }
    }

    private void dispatchActivityPostCreated(@Nullable Bundle savedInstanceState) {
        Object[] callbacks = collectActivityLifecycleCallbacks();
        if (callbacks != null) {
            for (int i = 0; i < callbacks.length; i++) {
                ((Application.ActivityLifecycleCallbacks) callbacks[i]).onActivityPostCreated(this,
                        savedInstanceState);
            }
        }
        getApplication().dispatchActivityPostCreated(this, savedInstanceState);
    }
}

以上只列出Created,其他的生命周期相关代码也是如此.

使用mActivityLifecycleCallbacks记录观察者,

performCreate 执行onCreate前通知观察者 -> mActivityLifecycleCallbacks.onActivityPreCreated

onCreate 通知观察者正在执行onCreate -> mActivityLifecycleCallbacks.onActivityCreated

通知观察者onCreate完成-> mActivityLifecycleCallbacks.onActivityPostCreated

LifecycleOwner总结:

Fragment：在生命周期中直接使用LifecycleRegistry进行分发通知

api<29的Activity:实例化一个不可见的Fragment,用该Fragment的生命周期方法来使用 mLifecycleRegistry进行分发通知

api>=29的Activity:在生命周期中先使用LifecycleCallbacks回调,LifecycleCallbacks再使用LifecycleRegistry进行分发通知

LifecycleRegistry

用于注册观察者,将生命周期事件分发给观察者.

addObserver

public void addObserver(@NonNull LifecycleObserver observer) {
        //检测是否在主线程执行,不是主线程会抛出异常
        enforceMainThreadIfNeeded("addObserver");

        //初始化一个生命周期状态值 除非LifecycleOwner宿主处于DESTROYED状态,否则都初始化为INITIALIZED 
        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
        
        //用当前的observer观察者和初始化状态值 包装成一个ObserverWithState类
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);

        //将observer观察者与/ObserverWithState put到map中
        ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);

        //putIfAbsent 中会判断是否已存在这个observer,存在则返回对应的ObserverWithState,说明已经添加过了 可以直接return
        if (previous != null) {
            return;
        }
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        if (lifecycleOwner == null) {
            // it is null we should be destroyed. Fallback quickly
            return;
        }
        
        //控制是否可进行同步 具体可在LifecycleRegistry完整源码中搜索有mAddingObserverCounter与mHandlingEvent赋值的地方
        boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
        
        //计算出当前观察者应该要到达的状态
        //假设LifecycleOwner宿主生命周期已经走到onResume(),那么mState = State.RESUMED，
        //那么 targetState = State.RESUMED
        State targetState = calculateTargetState(observer);

        mAddingObserverCounter++;

        //如果当前statefulObserver.mState 还没前进到 目标状态 ,需要进行while
        while ((statefulObserver.mState.compareTo(targetState) < 0 && mObserverMap.contains(observer))) {

            //记录当前statefulObserver.mState状态
            pushParentState(statefulObserver.mState);

            /**获取statefulObserver.mState要到达下一个状态所需要执行的事件
             * 如开始statefulObserver.mState = INITIALIZED
             * 要到达下一个状态就要执行ON_CREATE事件
             */
            final Event event = Event.upFrom(statefulObserver.mState);

            if (event == null) {
                throw new IllegalStateException("no event up from " + statefulObserver.mState);
            }

            //利用包装类进行事件派发,并更新为下一个状态
            statefulObserver.dispatchEvent(lifecycleOwner, event);

            //删除记录的最后一个状态
            popParentState();
            
            //再一次更新目标状态
            targetState = calculateTargetState(observer);
        }

        if (!isReentrance) {
            //同步操作
            sync();
        }
        mAddingObserverCounter--;
    }


    private State calculateTargetState(LifecycleObserver observer) {
        //mObserverMap是一个双向链表，这里是获取当前的observer的前一个observer
        Map.Entry<LifecycleObserver, ObserverWithState> previous = mObserverMap.ceil(observer);

        //如果有前一个observer就将它最后所记录到的状态赋值给siblingState,否则赋值null
        State siblingState = previous != null ? previous.getValue().mState : null;

        //mParentStates用于记录当前观察者上一个状态
        State parentState = !mParentStates.isEmpty() ? mParentStates.get(mParentStates.size() - 1)
                : null;
        return min(min(mState, siblingState), parentState);
    }


    public static Event upFrom(@NonNull State state) {
            switch (state) {
                case INITIALIZED:
                    return ON_CREATE;
                case CREATED:
                    return ON_START;
                case STARTED:
                    return ON_RESUME;
                default:
                    return null;
            }
        }

addObserver流程总结：

1.线程检查

2.初始化initialState = INITIALIZED(宿主状态不是DESTROYED)

3.将observer和initialState包装成ObserverWithState实例

4.将observer和ObserverWithState放到mObserverMap中

5.获取observe应该要到达的目标状态(或理解为宿主当前状态)

6.判断observe最新状态是否少于目标状态,是则根据当前状态去获取到达下一个状态所需要执行的Event

7.ObserverWithState.dispatchEvent将Event派发,并根据Event对应的状态赋值给ObserverWithState.mState

8.如果更新后的ObserverWithState.mState还是少于目标状态,则继续执行while体,直到ObserverWithState.mState不少于目标状态

handleLifecycleEvent

handleLifecycleEvent是接受LifecycleOwner宿主生命周期事件的入口

public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
        enforceMainThreadIfNeeded("handleLifecycleEvent");
        //event.getTargetState() 根据LifecycleOwner宿主生命事件获取对应的状态值
        moveToState(event.getTargetState());
    }

    private void moveToState(State next) {
        if (mState == next) {
            return;
        }

        //用mState记录LifecycleOwner宿主最新的状态
        mState = next;

        //如果正在同步中 或者 正在走addObserver流程 则return 以免重复执行同步
        if (mHandlingEvent || mAddingObserverCounter != 0) {
            mNewEventOccurred = true;
            // we will figure out what to do on upper level.
            return;
        }
        mHandlingEvent = true;

        //执行同步操作
        sync();

        mHandlingEvent = false;
    }

    //判断所有的ObserverWithState中的状态是否一致,是否与记录LifecycleOwner宿主最新的状态mState一致
    //return true 说明所有ObserverWithState中的状态与mState一致,则表示同步完成
    private boolean isSynced() {
        //没有
        if (mObserverMap.size() == 0) {
            return true;
        }
        //链表头
        State eldestObserverState = mObserverMap.eldest().getValue().mState;
        //链表未
        State newestObserverState = mObserverMap.newest().getValue().mState;
        return eldestObserverState == newestObserverState && mState == newestObserverState;
    }


    private void sync() {
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();

        //LifecycleOwner宿主为空,抛异常
        if (lifecycleOwner == null) {
            throw new IllegalStateException("LifecycleOwner of this LifecycleRegistry is already"
                    + "garbage collected. It is too late to change lifecycle state.");
        }

        //循环判断 是否已同步完成
        while (!isSynced()) {
            //没有同步完成,则开始同步
            
            mNewEventOccurred = false;
            // no need to check eldest for nullability, because isSynced does it for us.

            //记录LifecycleOwner宿主的mState 是否少于 链表头元素记录的mState,
            //是则需要执行状态回退事件
            //如LifecycleOwner宿主从onResume()->onPause(),状态由State.RESUMED -> State.STARTED
            //而元素记录的mState还是State.RESUMED,那么就要执行状态回退
            if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
                backwardPass(lifecycleOwner);
            }


            //记录LifecycleOwner宿主的mState 是否大于 链表未位元素记录的mState,
            //是则需要执行状态前进事件
            Map.Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
            if (!mNewEventOccurred && newest != null
                    && mState.compareTo(newest.getValue().mState) > 0) {
                forwardPass(lifecycleOwner);
            }
        }
        mNewEventOccurred = false;
    }

    private void backwardPass(LifecycleOwner lifecycleOwner) {
        //获取mObserverMap的倒序迭代器
        Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
                mObserverMap.descendingIterator();
        //进行迭代获取每一个entry        
        while (descendingIterator.hasNext() && !mNewEventOccurred) {
            Map.Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();
            ObserverWithState observer = entry.getValue();

            //获取到entry后 根据状态 循环对比 大于宿主mState的 就回退一级,直到不大于宿主mState
            while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred && mObserverMap.contains(entry.getKey()))) {
                //根据状态获取回退事件
                Event event = Event.downFrom(observer.mState);
                if (event == null) {
                    throw new IllegalStateException("no event down from " + observer.mState);
                }
                pushParentState(event.getTargetState());
                //派发事件
                observer.dispatchEvent(lifecycleOwner, event);
                popParentState();
            }
        }
    }


     private void forwardPass(LifecycleOwner lifecycleOwner) {
         //获取mObserverMap的迭代器
        Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =
                mObserverMap.iteratorWithAdditions();
        //进行迭代获取每一个entry     
        while (ascendingIterator.hasNext() && !mNewEventOccurred) {
            Map.Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();
            ObserverWithState observer = entry.getValue();

            //获取到entry后 根据状态 循环对比 少于宿主mState的 就前进一级,直到不少于宿主mState
            while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
                    && mObserverMap.contains(entry.getKey()))) {
                pushParentState(observer.mState);
                //根据状态获取前进事件
                final Event event = Event.upFrom(observer.mState);
                if (event == null) {
                    throw new IllegalStateException("no event up from " + observer.mState);
                }
                //派发事件
                observer.dispatchEvent(lifecycleOwner, event);
                popParentState();
            }
        }
    }

    //根据状态 获取回退事件
    public static Event downFrom(@NonNull State state) {
            switch (state) {
                case CREATED:
                    return ON_DESTROY;
                case STARTED:
                    return ON_STOP;
                case RESUMED:
                    return ON_PAUSE;
                default:
                    return null;
            }
        }

    //根据状态 获取前进事件
    public static Event upFrom(@NonNull State state) {
            switch (state) {
                case INITIALIZED:
                    return ON_CREATE;
                case CREATED:
                    return ON_START;
                case STARTED:
                    return ON_RESUME;
                default:
                    return null;
            }
        }

handleLifecycleEvent流程总结

1.主线程检查

2.LifecycleOwner宿主传进来的事件转为State

3.判断当前记录的mState是否与State一致，如一致则直接return

4.更新mState,并判断是否正在同步中或者正在走addObserver流程,是则return 以免重复执行同步

5.sync()执行同步

 5.1.isSynced()判断mObserverMap链表的头尾state值是否相同,是否与最新的mState相等

 5.2.使用最新的mState与链表头的state值比较,如mState<链表头的state,需执行回退事件

   5.2.1.获取mObserverMap的倒序迭代器,迭代获取每一个entry(倒序迭代即是按照先后顺序加入的              观察者,最后加入的观察者最先获取回退事件)

   5.2.2.while循环判断entry状态是否大于宿主mStste,是则回退一级,直到不大于宿主mState

   5.2.3.使用Event.downFrom获取回退事件,使用ObserverWithState.dispatchEvent进行事件派发


 5.3.使用使用最新的mState与链表末尾的state值比较,如mState>链表末尾的state,需执行前进事件

   5.3.1.获取mObserverMap的迭代器,迭代获取每一个entry(这里顺序跟回退不同,是谁先加入就先              执行谁)

   5.3.2.while循环判断entry状态是否少于宿主mStste,是则前进一级,直到不少于宿主mState

   5.3.3.使用Event.upFrom获取前进事件,使用ObserverWithState.dispatchEvent进行事件派发

ObserverWithState.dispatchEvent

所有事件最终是通过ObserverWithState.dispatchEvent方法执行派发

static class ObserverWithState {
        //记录最新已派发处理的状态
        State mState;
        //观察者
        LifecycleEventObserver mLifecycleObserver;

        ObserverWithState(LifecycleObserver observer, State initialState) {
            //将LifecycleObserver观察者类型转化为LifecycleEventObserver类型
            //实现LifecycleObserver方式有
            //  方式1:implements LifecycleEventObserver接口
            //  方式2:implements FullLifecycleObserver接口
            //  方式3:implements LifecycleEventObserver 和 FullLifecycleObserver接口
            //  方式4:implements LifecycleObserver,使用@OnLifecycleEvent注解
            //根据不同的实现方式转化为不同的适配类,每个适配类均 implements LifecycleEventObserver,
            mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
            mState = initialState;
        }

        void dispatchEvent(LifecycleOwner owner, Event event) {
            //根据最新需要处理的Event获取其对应的状态值
            State newState = event.getTargetState();
            mState = min(mState, newState);

            //通知观察者生命周期变化
            mLifecycleObserver.onStateChanged(owner, event);
            //记录最新已派发的状态
            mState = newState;
        }
    }

ObserverWithState总结

  1.构造函数里 根据LifecycleObserver观察者的实现方式 统一转化为LifecycleEventObserver类型,方便事件派发
 
  2.分发事件时,先获取要派发事件对应的状态,然后使用mLifecycleObserver派发,最后记录新的状态