Jetpack ---- Lifecycle源码解析（1）基础知识

最新推荐文章于 2024-07-16 15:26:55 发布

detachment_w

最新推荐文章于 2024-07-16 15:26:55 发布

阅读量217

点赞数

文章标签： android

本文链接：https://blog.csdn.net/aha_jasper/article/details/111176186

版权

android框架使用及源码解析专栏收录该内容

37 篇文章 5 订阅

订阅专栏

转载自青蛙要fly，略有删减

看源码最好还是自己先去android官网的该模块看一下，如果大家英语不太好，可以去看我的这篇博客 Jetpack ---- Lifecycle入门，如果哪里不太对，可以指正。

如果看完这系列文章对lifecycle还有疑惑可以在阅读一下一下几篇博客，不过最主要的还是自己看完之后结合源码自己思考一下: 其实我看完原作者的博客之后，也是自己回过头来有看了一遍下面的博客，才对于Lifecycling、ProcessLifecycleOwner、LifecycleDispatcher有了更清晰的认识。
【AAC系列二】深入理解架构组件的基石：生命周期
 3. Jetpack原始解析—使用生命周期管理生命周期
 剖析Lifecycle源码

导读

本系列适合三类读者：

完全没用过Lifecycle，但是听过，第一次接触的，想从浅入深的读者，我会有实际生活中的例子来让大家更容易掌握
稍微知道整个基础流程的，能大概讲个大概，但是深入就没有了解过的读者
自己也写过相关Lifecycle的文章，写了自认为所谓的《整个Lifecycle源码解析》的读者

也许有些人会说，那你凭啥说第三类读者还要读你的这篇Lifecycle文章，（当然有些作者是真的所有Lifecycle的完整的小细节都知道，只是没有写出来而已，那种可以忽视不看）

比如我问几个简单的Lifecycle面试问题：

Lifecycle 我们知道很多文章都说你写了XXXLifecycleObserver后，编译后会自动生成XXXLifeObserver_LifecycleAdapter文件，但是我没引入annotationProcessor "android.arch.lifecycle:compiler:1.1.1"，不会自动生成这个辅助文件，这时候是怎么回调通知的。
为什么Lifecycle的State和Event是这么定义的，为什么State的值只有这么几个？
LifecycleRegistry中管理我们观察者的队列 FastSafeIterableMap是我们平常使用的Map结构吗？如果不是那是什么，大概介绍下这种数据结构。

比如最后在sync()方法里面更新状态时候，下面这段代码部分看源码的作者应该不陌生，请看我在下面提的问题：

private void sync () {
    LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
    if (lifecycleOwner == null) {
        return;
    }
    while (!isSynced()) {
        mNewEventOccurred = false;

        /*'很多作者写这块介绍的时候就说简单的说拿队列头部的观察者的State和当前State比较，
         *如果小，就执行backwardPass方法，
         *如果大就执行forwardPass方法。'
         */

        if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
            backwardPass(lifecycleOwner);

            /*
             * '请问既然是执行backwardPass操作，
             * 为什么不在这里直接添加return代码,
             * 而执行完backwardPass后又去判断执行forwardPass了???'
             */
            
            // return;
            // 为什么此处不加return，什么情况下会出错 ??'
        }

        Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
        if (!mNewEventOccurred && newest != null
                && mState.compareTo(newest.getValue().mState) > 0) {
            forwardPass(lifecycleOwner);
        }
    }
    mNewEventOccurred = false;

    /*
     *'为什么backwardPass的时候，使用队列的头部状态值来比较，而forwardPass的时候是拿队列尾部的状态来比较？'
     *
     * '在具体执行forwardPass的时候，为什么使用的正序迭代器，而backwardPass的时候用的是倒序迭代器？'
     */
}

等等等等其他问题（太多了不想写了）

正文

1. 对比

我们把以房东 ——> 中介 ——> 购房者三者来对比 LifecycleOwner ——> Lifecycle ——> LifecycleObserver。
在这里插入图片描述

具体的内容我们可以看脑图即可。

2. 基础

关于基础篇，直接可以官网查看基础知识就行，或者看我自己翻译自官网的博客：
使用生命周期感知型组件处理生命周期

集成方式一

我就简单列出代码了：

Activity (房东)：

//实现LifecycleOwner接口，等于门上贴了纸条，告诉人们，我有一个中介再帮我打理房子，有事找中介
public class MainActivity extends Activity implements LifecycleOwner {
    
    private LifecycleRegistry registry = new LifecycleRegistry(this);
   
    //通过门口的号码，告诉你们，具体的中介是谁，直接找它吧
    @NonNull
    @Override
    public Lifecycle getLifecycle() {
        return registry;
    }
    
    //买家1
    private LifeObserver observer1 = new LifeObserver();
    //买家2
    private LifeObserver observer2 = new LifeObserver();
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        //拿到了房屋中介对象，然后买家1到中介那边注册了
        getLifecycle().addObserver(observer1);
        //拿到了房屋中介对象，然后买家2到中介那边注册了
        getLifecycle().addObserver(observer2);
    }
    
    //房东的想法变了
    @Override
    protected void onResume() {
        super.onResume();
        //'中介马上把房东的新想法通知到各个买家'
        registry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
    }    
    
    //'房东的想法变了'
    @Override
    protected void onPause() {
        super.onResume();
        //'中介马上把房东的新想法通知到各个买家'
        registry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
    }   
    
    //房东的想法变了
    @Override
    protected void onStop() {
        super.onStop();
        //中介马上把房东的新想法通知到各个买家
        registry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
    }
    
    //房屋买家类
    class LifeObserver implements LifecycleObserver{

        @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
        public void AAAA(LifecycleOwner owner, Lifecycle.Event event){
            //买家收到中介的通知......
            Log.v(TAG,"AAAA : " + event.name());
        }
    }
}

没错，这个就是最基础的Lifecycle使用方式。是不是一下子就知道怎么使用了。

集成方式二

很多人会说，我写的Activity怎么跟你的代码不一样，没有这么多杂七杂八的代码，比如：

public class Main2Activity extends AppCompatActivity {

    //'买家'
    private LifeObserver observer = new LifeObserver();

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        
        //'买家到中介处注册'
        getLifecycle().addObserver(observer);

    }
}

是不是少了很多，不需要各个生命周期去复写，然后发送事件，也不需要去实现LifecycleOwner接口，但是我们说了，你买房子既然走了这个流程，是不可能少任何东西的，只不过它内部帮我们把一些东西给提前写好了代码而已。

我们查看AppCompatActivity的代码：

public class AppCompatActivity extends FragmentActivity implements AppCompatCallback, SupportParentable, DelegateProvider {

}


public class FragmentActivity extends SupportActivity implements ViewModelStoreOwner, OnRequestPermissionsResultCallback, RequestPermissionsRequestCodeValidator {

}


//'我们的AppcompatActivity也等价于继承了SupportActivity'
//'果然实现了LifecycleOwner接口'
public class SupportActivity extends Activity implements LifecycleOwner, Component {
    
    //'果然，实例化了这个房屋中介对象'
    private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
    
    //'也实现了这个方法，并且返回房屋中介对象'
    public Lifecycle getLifecycle() {
        return this.mLifecycleRegistry;
    }    
    
    //'这个后面会具体给大家讲解，看过RxPermission源码的，应该一眼就知道'
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ReportFragment.injectIfNeededIn(this);
    }
    ......
    ......
    ......
}

//'统一的中介分发房东信息类'
public class ReportFragment extends Fragment {
    
    @Override
    public void onStart() {
        super.onStart();
        dispatchStart(mProcessListener);
        
        //'中介马上把房东的新想法通知到各个买家'
        dispatch(Lifecycle.Event.ON_START);
    }

    @Override
    public void onResume() {
        super.onResume();
        dispatchResume(mProcessListener);
        
        //'中介马上把房东的新想法通知到各个买家'
        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);
    }
    
    
    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) {
                //'果然跟我们自己写的集成方式一相同，使用handleLifecycleEvent(event);去发送通知'
                ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
            }
        }
    }    
    
}

所以你们写的代码，本质上也就是跟我们刚写的一模一样。

集成方式三

当然，如果你的support包比较老，可能默认的类似AppcompatActivity都没有帮我们自动集成相关Lifecycle代码，然后我们又不想写集成方式一那么多代码（每个生命周期事件都要复写，然后调用发送事件代码），想要实现类似集成方式二的使用方案，那怎么办呢？

implementation 'android.arch.lifecycle:extensions:1.1.1'

我们只需要依赖上面这个扩展包就可以了。

public class MainActivity extends Activity implements LifecycleOwner {
    
    private LifecycleRegistry registry = new LifecycleRegistry(this);
    
    @Override
    public Lifecycle getLifecycle() {
        return registry;
    }
    
    //'买家1'
    private LifeObserver observer1 = new LifeObserver();
    //'买家2'
    private LifeObserver observer2 = new LifeObserver();
    
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        //'拿到了房屋中介对象，然后买家1到中介那边注册了'
        getLifecycle().addObserver(observer1);
        //'拿到了房屋中介对象，然后买家2到中介那边注册了'
        getLifecycle().addObserver(observer2);
    }
}

具体的原理我们后面会细细讲解，不用急。

集成方式一代码量 > 集成方式三代码量 > 集成方式二代码量

所以我们可以根据不同情况来使用Lifecycle。

3. 使用场景

3.1 普通Activity、Fragment等生命周期监听

这个基本是包含了百分之90几的需求。

举例我们恰好用的是MVP模式，我现在要引入Lifecycle，这样V层销毁时候，我们的P层可以自动解绑（P层里面的网络请求自动解绑，P层自动与M层解绑，P层销毁，M层销毁等）

3.2 监听整个App

一个比较常见需求，比如我现在APP在运行，我点击了Home键，APP退到了后台，这时候我在退到后台后，会进行某一段代码，APP从后台又回来了，又要执行其他代码，这时候怎么写这个监听。

通常大部分人的写法是这样的:

public class DemoApplication extends Application {

    private int appCount;
    private boolean isRunInBackground;
    
    @Override
    public void onCreate() {
        super.onCreate();

        registerActivityLifecycleCallbacks(new ActivityLifecycleCallbacks() {
            @Override
            public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
            }

            @Override
            public void onActivityStarted(Activity activity) {
                appCount++;
                if (isRunInBackground) {
                    
                    //应用从后台回到前台 需要做的操作
                    isRunInBackground = false;
                    //xxxxxxxxxxxxxx
                }
            }
            
            @Override
            public void onActivityStopped(Activity activity) {
                appCount--;
                if (appCount == 0) {
                    //应用进入后台 需要做的操作
                    isRunInBackground = true;
                    //xxxxxxxxxxxxxx
                }
            }

            ......
            ......
            ......
            
        });
    }
}

我们可以看到，我们监听了APP 里面所有的Activity的状态，如果所有的Activity都处于Stop状态，说明已经在后台了，如果有一个回到Start状态，且我们的boolean值变量也是true,则说明了回到了前台。

这个写法没啥问题，当然我们使用了Lifecycle后：

首先需要引进这个扩展包 implementation "android.arch.lifecycle:extensions:1.1.1"

ProcessLifecycleOwner.get().getLifecycle().addObserver(new LifeObserver());

class LifeObserver extends LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    public void onForeground() {
        //应用进入前台
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    public void onBackground() {
        //应用进入后台
    }
}

实际上真正的这个ProcessLifecycleOwner用到的源码，也是跟我们registerActivityLifecycleCallbacks(new ActivityLifecycleCallbacks())原理是一样的，只是他帮我们把这大批的代码给封装了而已。具体这块的源码分析，后面我会具体说明的。

3.3 配合LiveData，消息总线

Android消息总线的演进之路：用LiveDataBus替代RxBus、EventBus

结语

本文我们学会了Lifecycle基本的使用方式，通过房东-中介-购房者，能更好的理解Lifecycle。

detachment_w

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Jetpack ---- Lifecycle源码解析（1）基础知识

转载自青蛙要fly，略有删减Jetpack ---- Lifecycle 篇（1）基础知识导读正文1. 对比2. 基础集成方式一集成方式二集成方式三3. 使用场景3.1 普通Activity、Fragment等生命周期监听3.2 监听整个App3.3 配合LiveData，消息总线结语导读本系列适合三类读者：完全没用过Lifecycle，但是听过，第一次接触的，想从浅入深的读者，我会有实际生活中的例子来让大家更容易掌握稍微知道整个基础流程的，能大概讲个大概，但是深入就没有了解过的读者自己也写
复制链接

扫一扫