Android Jetpack架构组件之Lifecycle源码分析

最新推荐文章于 2024-06-30 23:11:46 发布

斌林诚上

最新推荐文章于 2024-06-30 23:11:46 发布

阅读量928

点赞数 3

分类专栏： Android Jetpack架构组件文章标签： Lifecycle Lifecycle源码 Lifecycle分析

本文链接：https://blog.csdn.net/cs_lwb/article/details/103092824

版权

本文深入探讨了Android Jetpack架构组件中的Lifecycle，分析了如何添加观察者、何时通知观察者以及源码实现的细节，旨在帮助读者理解Lifecycle的工作原理。

摘要由CSDN通过智能技术生成

您总说梦想遥不可及，可您却从不早睡。也不早起——《狼道》

一、前言

——回顾了一下之前学习过的东西并打算把这些东西整理成文章，加深映像和理解，同时也传达自己的见解供大家参考，若存在错误或不足的地方，希望您能指出。
本篇续《Android Jetpack架构组件之Lifecycle入门》文章之后，上一篇介绍了Lifecycle。由于篇幅太长拆成两篇。这篇主要是分析Lifecycle源码，理解其实现原理。回顾一下Lifecycle结构图

LifeCycle相关链接——官方文档、接口文档、相关依赖文档

二、源码分析

——通过上面的使用过程，大体理解为创建一个观察者，当组件生命周期发生变化时，通知观察者有LifeCycle注解的方法做出响应。那么实现原理分成两部分来分析

（1）怎么通知观察者响应生命周期的变化（怎么通知）

（2）生命周期更改的时候是如何通知观察者的（何时通知）

（1）添加观察者

1.使用入口**getLifecycle().addObserver()** （不同版本Lifecycle源码各有差异，这边引用的是'androidx.appcompat:appcompat:1.1.0）

   /*
    * 通过查看源码得出MainActivity继承了AppCompatActivity，AppCompatActivity继承了FragmentActivity ，FragmentActivity 继ComponentActivity
    * 并实现了LifecycleOwner接口的getLifecycle()方法 ，返回生命周期的提供者 ，而FragmentActivity重写了ComponentActivity的getLifecycle()方法
    * 所以这边调用的是FragmentActivity里面的getLifecycle()方法得到LifecycleRegistry实例
    */
 final LifecycleRegistry mFragmentLifecycleRegistry = new LifecycleRegistry(this);
 public Lifecycle getLifecycle() {
     //这里返回LifecycleRegistry对象
     return mFragmentLifecycleRegistry;
 }

2.FragmentActivity里面创建了LifecycleRegistry 实例，下面看下LifecycleRegistry构造源码

    // 给生命周期的提供者创建一个LifecycleRegistry
    public LifecycleRegistry(@NonNull LifecycleOwner provider) {
        mLifecycleOwner = new WeakReference<>(provider);
        mState = INITIALIZED;
    }

3.LifecycleRegistry继承了Lifecycle抽象类，并重写了addObserver()方法。主要作用是添加一个生命周期的观察者，当生命周期的提供者发生状态改变的时候，通知观察者做出响应

    //保存观察者的自定义列表
    private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap =
            new FastSafeIterableMap<>();
    @Override
    public void addObserver(@NonNull LifecycleObserver observer) {
        //设置lifecycle的初始状态 ，State是个生命周期的枚举类型
        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
        //创建ObserverWithState实例，并将LifecycleObserver 转化为LifecycleEventObserver，详情看（4）
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
        //保存生命周期的观察者与ObserverWithState（观察者的生命状态），保存成功返回NULL，否则说明已经保存过，返回ObserverWithState对象
        ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
        //拦截已经保存过的观察者
        if (previous != null) {  
            return;
        }
        //生命周期的提供者被回收则返回不继续执行
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        if (lifecycleOwner == null) {
            return;
        }
        // 判断是否连续添加了观察者 或者 正在处理事件  是返回true
        boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
        //获取状态 详情看（5）
        State targetState = calculateTargetState(observer);
        //正在添加的观察者数量+1
        mAddingObserverCounter++;
        //如果观察者生命周期状态比前面添加进来的小，说明生命周期发生变化，执行以下步骤
        //比如： onCreate()方法中与onResume()方法中同时调用了 addObserver()方法
        while ((statefulObserver.mState.compareTo(targetState) < 0
                && mObserverMap.contains(observer))) {
            //存储添加进来的观察者状态，详情看（7）
            pushParentState(statefulObserver.mState);
            //分发事件  dispatchEvent详情看（4）  upEvent详情看（8）
            statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
            //移除最后一个添加进去的观察者，详情看（7）
            popParentState();
            //获取状态 详情看（5）
            targetState = calculateTargetState(observer);
        }
        // 当isReentrance为false时 进行同步
        if (!isReentrance) {
            // we do sync only on the top level.
            sync();
        }
        //添加完成时正在处理的观察者数量减一
        mAddingObserverCounter--;
    }

4.ObserverWithState主要是将LifecycleObserver 转化为LifecycleEventObserver

     //将LifecycleObserver 转化为LifecycleEventObserver 
    static class ObserverWithState {
        State mState;
        LifecycleEventObserver mLifecycleObserver;
         //将LifecycleObserver 转化为LifecycleEventObserver 
        ObserverWithState(LifecycleObserver observer, State initialState) {
            //lifecycleEventObserver将LifecycleObserver 转化成LifecycleEventObserver 
            mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
            mState = initialState;
        }
        //将生命周期的提供者与Event 
        void dispatchEvent(LifecycleOwner owner, Event event) {
            //获取生命周期状态
            State newState = getStateAfter(event);
            //对比两个状态
            mState = min(mState, newState);
            //在发生生命周期状态转换事件时调用 FullLifecycleObserverAdapter实现了LifecycleEventObserver接口的该方法
            mLifecycleObserver.onStateChanged(owner, event);
            mState = newState;
        }
    }

5.给定观察者对比观察者列表前后的生命周期状态，calculateTargetState返回State最小的生命周期状态