Jetpack组件之Lifecycle实现原理

作者: Guxxxd | 来源:发表于2021-03-08 13:26 被阅读0次

Android JetPack学习文章汇总
Android JetPack源码分析技巧
Android JetPack LiveData源码分析
Android JetPack Lifecycle源码分析
Android JetPack ViewModel源码分析
Android Jetpack架构组件之 Lifecycles
Jetpack组件之Lifecycle实现原理
Jetpack 架构组件之 Lifecycle (二) 使用
Jetpack 架构组件之 Lifecycle (三) 原理
JetPack学习笔记之LifeCyCle（一）

提纲

Lifecycle是什么
怎么使用Lifecycle观察宿主状态
LifecycleOwner、Lifecycle、LifecycleRegistry相关说明
Lifecycle在Fragment中是如何实现的
Lifecycle在Activity中是如何实现的
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的关系

LifecycleOwner：Activity、Fragment 都实现了该接口，用以声明它是一个能够提供生命周期事件的宿主；同时必须复写getLifecycle()方法提供一个Lifecycle对象；
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.1.1 宿主生命周期与宿主状态的对应关系

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

图3.5.1

Android JetPack学习文章汇总
android JetPack组件之Lifecycle Android JetPack组件之LiveData
Android JetPack源码分析技巧
本文从《一文搞懂Android JetPack组件原理之Lifecycle、LiveData、ViewModel与...
Android JetPack LiveData源码分析
本文从本人的《一文搞懂Android JetPack组件原理之Lifecycle、LiveData、ViewMod...
Android JetPack Lifecycle源码分析
本文从本人的《一文搞懂Android JetPack组件原理之Lifecycle、LiveData、ViewMod...
Android JetPack ViewModel源码分析
本文从本人的《一文搞懂Android JetPack组件原理之Lifecycle、LiveData、ViewMod...
Android Jetpack架构组件之 Lifecycles
带你领略Android Jetpack组件的魅力Android Jetpack 架构组件之 Lifecycle（使...
Jetpack组件之Lifecycle实现原理
提纲 Lifecycle是什么怎么使用Lifecycle观察宿主状态 LifecycleOwner、Lifecy...
Jetpack 架构组件之 Lifecycle (二) 使用
Android Jetpack 架构组件之 Lifecycle （一）起源[https://www.jianshu...
Jetpack 架构组件之 Lifecycle (三) 原理
Android Jetpack 架构组件之 Lifecycle （一）起源[https://www.jianshu...
JetPack学习笔记之LifeCyCle（一）
JetPack学习笔记之LifeCyCle（一） 1、为什么要用LifeCycle，是为了解决什么问题？普通组件...

Jetpack组件之Lifecycle实现原理

提纲

一、Lifecycle是什么

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

三、LifecycleOwner、Lifecycle、LifecycleRegistry相关说明

3.1 LifecycleOwner、Lifecycle、LifecycleRegistry的关系

3.2 关于LifecycleRegistry中相关方法说明

3.2.1 `void addObserver(LifecycleObserver)`添加观察者

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

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

四、 Lifecycle在Fragment中的实现

五、 Lifecycle在Activity中的实现

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

相关文章

Android JetPack学习文章汇总

Android JetPack源码分析技巧

Android JetPack LiveData源码分析

Android JetPack Lifecycle源码分析

Android JetPack ViewModel源码分析

Android Jetpack架构组件之 Lifecycles

Jetpack组件之Lifecycle实现原理

Jetpack 架构组件之 Lifecycle (二) 使用

Jetpack 架构组件之 Lifecycle (三) 原理

JetPack学习笔记之LifeCyCle（一）

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Jetpack组件集

Jetpack组件之Lifecycle实现原理

提纲

一、Lifecycle是什么

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

三、LifecycleOwner、Lifecycle、LifecycleRegistry相关说明

3.1 LifecycleOwner、Lifecycle、LifecycleRegistry的关系

3.2 关于LifecycleRegistry中相关方法说明

3.2.1 void addObserver(LifecycleObserver)添加观察者

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

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

四、 Lifecycle在Fragment中的实现

五、 Lifecycle在Activity中的实现

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

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

3.2.1 `void addObserver(LifecycleObserver)`添加观察者

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

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