Jetpack组件之Lifecycle实现原理

提纲

1. Lifecycle是什么
2. 怎么使用Lifecycle观察宿主状态
3. LifecycleOwner、Lifecycle、LifecycleRegistry相关说明
4. Lifecycle在Fragment中是如何实现的
5. Lifecycle在Activity中是如何实现的
6. Lifecycle是如何分发宿主状态的

一、Lifecycle是什么

具备感知宿主生命周期能力的组件，Jetpack的核心组件，也是一些其他组件的根基

二、怎么使用Lifecycle观察宿主状态

    // eg:1
    class CustomObserver : LifecycleObserver {
        @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
        fun onCreate(){
            // do someting
        }

        @OnLifecycleEvent(Lifecycle.Event.ON_START)
        fun onStart() {}

        @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
        fun onStop() {}
         ···
    }
   // eg:2
   class CustomObserver : LifecycleEventObserver{
        override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
            when(event){
                Lifecycle.Event.ON_CREATE -> {
                     // do someting
                }
                Lifecycle.Event.ON_START -> {
                    // // do someting
                }
                ···
            }
        }
    }

  ······

   class MainActivity : AppCompatActivity() {
        override fun onCreate(savedInstanceState: Bundle?) {
            super.onCreate(savedInstanceState)
            setContentView(R.layout.activity_main)

            val observer = CustomObserver()
            lifecycle.addObserver(observer)
        }
    }

三、LifecycleOwner、Lifecycle、LifecycleRegistry相关说明

3.1 LifecycleOwner、Lifecycle、LifecycleRegistry的关系

1. LifecycleOwner：Activity、Fragment 都实现了该接口，用以声明它是一个能够提供生命周期事件的宿主；同时必须复写getLifecycle()方法提供一个Lifecycle对象；
2. Lifecycle：是一个抽象类，里面定义了两个枚举，State:宿主的状态，Event :需要分发的事件的类型

public enum State {
   DESTROYED,// LifecycleOwner的已销毁状态。此事件之后，此生命周期将不再分派任何事件 for >an Act，onDestory之前
   INITIALIZED, // LifecycleOwner的初始化状态 for an Act，not received onCreate
   CREATED, // LifecycleOwner的created状态
   STARTED, // LifecycleOwner的started状态
   RESUMED; // LifecycleOwner的resumed状态
    /**
     * 比较当前State与给定的State的大小
     */
   public boolean isAtLeast(@NonNull Lifecycle.State state) {
       return compareTo(state) >= 0;
    }
}  
public enum Event {
   ON_CREATE, // onCreate事件
   ON_START, // onStart事件
   ON_RESUME,// onResume事件
   ON_PAUSE,//onPause事件
   ON_STOP, //onStop事件
   ON_DESTROY, //onDestroy事件
   ON_ANY // 可用于匹配所有事件
}
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);
}

3. LifecycleRegistry: 是 Lifecycle 的唯一实现类，负责添加 Observer，以及分发宿主状态事件

3.2 关于LifecycleRegistry中相关方法说明

3.2.1 void addObserver(LifecycleObserver)添加观察者

    @Override
    public void addObserver(@NonNull LifecycleObserver observer) {
        //  如果mState不为DESTROYED的状态，重置mState状态为INITIALIZED
        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
        // 将observer和state包装为一个ObserverWithState对象
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
        // FastSafeIterableMap继承自SafeIterableMap(维护一个双向链表)
        // FastSafeIterableMap内部使用HashMap存储
        ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
        // 禁止重复add
        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循环，将observer的状态和宿主的当前状态对齐(DESTORYED < INIT < CREATED < STARTED < RESUMED)
        while ((statefulObserver.mState.compareTo(targetState) < 0
                && mObserverMap.contains(observer))) {
            pushParentState(statefulObserver.mState);
            //向观察者分发宿主生命周期事件的方法，想方设法把Observer适配成LifecycleEventObserver(目的是为了统一事件的分发形式)，调用其LifecycleEventObserver.onStateChanged()方法完成分发
            //假设是在宿主的onresume犯法内注册的该观察者
            //第一次：分发on_Create事件，观察者状态INIT->CREATED
            //第二次：分发on_Start事件，观察者状态CREATED->STARTED
            //第三次：分发on_Resume事件，观察者状态STARTED->RESUMED ？？？？？
            //第三次分发on_Resume是通过handlerLifecycle()最终通过forwardPass()方法分发的
            statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
            popParentState();
            // mState / subling may have been changed recalculate、
            // 重新计算targetState，同级观察者可能已经重新计算
            targetState = calculateTargetState(observer);
        }

        if (!isReentrance) {
            // we do sync only on the top level.
            // 同步观察者到宿主当前状态
            sync();
        }
        mAddingObserverCounter--;
    }

3.2.2 void sync() 完成事件的分发和观察者状态的同步

    // 完成事件的分发和观察者状态的同步
    private void sync() {
        while (!isSynced()) {
            //如果宿主当前转态 小于 mObserverMap集合中最先添加的那个观察者的状态
            //则说明宿主可能发生了状态回退，比如当前是RESUMED状态，执行了onPause则回退到STARTED状态
            //此时调用backwardPass把集合中的每个一观察者分发一个on_pause事件，并同步它的状态。
            if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
                backwardPass(lifecycleOwner);
            }
            //如果宿主当前转态 大于 mObserverMap集合中最先添加的那个观察者的状态
            //则说明宿主可能发生了状态升级，比如当前是STARTED状态，执行了onResume则前进到RESUMED状态
            //此时调用forwardPass把集合中的每个一观察者分发一个on_resume事件，并同步它的状态。
            Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
            if (!mNewEventOccurred && newest != null
                    && mState.compareTo(newest.getValue().mState) > 0) {
                forwardPass(lifecycleOwner);
            }
        }
    }

3.2.3 void handleLifecycleEvent (Lifecycle.Event event)设置当前状态并通知观察者

    /**
     * 设置当前状态并通知观察者
     */
    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;
    }

四、 Lifecycle在Fragment中的实现

使用 Fragment 实现 Lifecycle ，在各个生命周期方法内利用LifecycleRegistry分发相应的事件给每个观察者，以实现生命周期观察的能力：

    public class Fragment implements ···, LifecycleOwner,···{
    LifecycleRegistry mLifecycleRegistry;

    @Override
    @NonNull
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }

    public Fragment() {
        initLifecycle();
    }

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

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

五、 Lifecycle在Activity中的实现

Activity 实现 Lifecycle 是通过向 Activity上添加一个无UI的ReportFragment用以报告生命周期的变化,目的是为了兼顾不是继承自 AppCompactActivity 的场景.

public class ComponentActivity extends androidx.core.app.ComponentActivity implements LifecycleOwner, ···{
    
    private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

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

    public class ReportFragment extends Fragment {
    private static final String REPORT_FRAGMENT_TAG = "androidx.lifecycle"
            + ".LifecycleDispatcher.report_fragment_tag";

    public static void injectIfNeededIn(Activity 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();
        }
    }

    // 最终还是调用 handleLifecycleEvent() -> moveToState() -> sync()，实现设置状态和通知观察者
    private void dispatch(Lifecycle.Event event) {
        Activity activity = getActivity();
        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);
            }
        }
    }

    static ReportFragment get(Activity activity) {
        return (ReportFragment) activity.getFragmentManager().findFragmentByTag(
                REPORT_FRAGMENT_TAG);
    }

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

六、 Lifecycle是如何分发宿主状态的

    /**
     * 状态升级
     */
    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();
            // 比较当前observer的状态和宿主当前状态
            while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
                    && mObserverMap.contains(entry.getKey()))) {
                pushParentState(observer.mState);
                // 分发宿主事件到observer
                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();
            // 比较当前observer的状态和宿主当前状态
            while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
                    && mObserverMap.contains(entry.getKey()))) {
                Event event = downEvent(observer.mState);
                pushParentState(getStateAfter(event));
                // 分发宿主事件到observer
                observer.dispatchEvent(lifecycleOwner, event);
                popParentState();
            }
        }
    }
    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 = getStateAfter(event);
            mState = min(mState, newState);
            // 回调当前宿主状态到observer中
            mLifecycleObserver.onStateChanged(owner, event);
            mState = newState;
        }
    }