Jetpack架构组件学习(1)——LifeCycle的使用

Stars-one 2021年11月19日 90次浏览 本篇字数为6,526字

本文为作者原创,转载请注明出处,谢谢配合
作者:Stars-one
链接:https://stars-one.site/2021/11/19/jetpack-study-1


要看本系列其他文章,可访问此链接Jetpack架构学习 | Stars-One的杂货小窝

最近有时间了,准备入坑Jetpack架构,第一篇就学个简单的LifeCycle,可以帮助开发者创建可感知生命周期的组件。

介绍

为什么需要LifeCycle组件?

在很多情况下,我们需要在Activity的相关生命周期中进行相关的初始化操作,比如上一节说到的EventBus,需要在OnCreate()onDestroy()方法中进行绑定和解绑,我们可以使用此组件来简化操作(下面的例子即是使用LifeCycle去简化EventBus绑定Activity的操作)

LifeCycle的本质原理就是观察者模式,其中有类LifecycleOwner(被观察者)和接口LifecycleObserver(观察者),通过观察者模式,即可实现对页面生命周期进行监听,从而减低代码耦合度

这里提下:

Support Library 26.1.0 及其以后的版本(含androidx),ActivityFragment 已经实现了LifecycleOwner 接口

所以,我们可以直接在Activity 和Fragment中使用getLifecycle()方法来获取lifecycle对象,来添加观察者监听。

我是直接使用了androidx版本,所以基本使用是无需导入额外的依赖

由于ActivityFragment实现了LifecycleOwner接口,所以,使用我们只需要创建我们的观察者对象,与Activity进行绑定即可

基本使用

下面以EventBus的初始化来讲解下使用方法

1.实现LifecycleObserver接口

前面也说到了,LifeCycle提供了一个接口类LifecycleObserver,这个接口里没有任何的方法,我们需要要定义个类去实现它,即可让该类成为一个LifeCycle观察者类

我们需要让一个类去实现此接口,由于EventBus需要绑定Activity对象,所以我们需要类提供一个构造方法来接收Activity对象

class EventBusInitiator(val context: Context) : LifecycleObserver {
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun register() {
        EventBus.getDefault().register(context)
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun unregister() {
        EventBus.getDefault().unregister(context)
    }
}

那我们实现了接口类,如何让Lifecycle回调我们的方法呢?这里Lifecycle设计就和EventBus有些异曲同工之妙了,也是提供注解的方式,从而Activity在进入对应的生命周期会回调参数

OnLifecycleEvent注解里的参数只接收对应的事件,事件有以下7种类型

  • ON_CREATE 匹配Activity的onCreate事件
  • ON_START 匹配Activity的onStart事件
  • ON_RESUME 匹配Activity的onResume事件
  • ON_PAUSE 匹配Activity的onStop事件
  • ON_STOP 匹配Activity的onStop事件
  • ON_DESTROY 匹配Activity的onDestroy事件
  • ON_ANY 可以匹配任何的事件(每次Activity的生命周期发生变化,都会调用一次)

前6种就是和Activity中的生命周期保持对应,最后一种有点迷,不知道具体是在哪种情况下使用的

PS:在这篇文章中提到Android 架构组件之 LifeCycle详解 - SegmentFault 思否,有两种方式用来实现LifeCycle的监听

  • 实现DefultLifecyceObserver接口,然后重写里面生命周期方法;
  • 直接实现LifecycleObserver接口,然后通过注解的方式来接收生命周期的变化;

Lifecycle.java文档中是建议使用第一种方式,随着Java8成为主流,注解的方式会被弃用。

这里我也没细找文档去研究,也不知道是不是这回事,就我个人感觉使用注解的方式会比较舒服,智者见智仁者见仁吧

2.Activity注册观察者对象

在上面实现LifecycleObserver接口后,我们就有个类,当Activity生命周期发生改变的话,就会将事件分发给类中,前提是我们得让Activity注册这个类的对象,代码如下所示

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_event_bus)

    lifecycle.addObserver(EventBusInitiator(this))
}

PS:如果是Java,是通过getLifecycle()方法获取LifeCycle对象

效果与之前的例子一样,点击按钮即可改变文字

补充-判断当前页面状态

LifeCycle中的状态有以下5种类型:

  • Lifecycle.State.CREATED
  • Lifecycle.State.DESTROYED
  • Lifecycle.State.RESUMED
  • Lifecycle.State.STARTED
  • Lifecycle.State.INITIALIZED

INITIALIZED状态表示的是初始化完成,但onCreate()周期未开始的状态

而之后CREATED状态,标明是onCreate()周期已结束的状态,后面的依次类推

可以参考下面的LifeCycle状态改变和事件的解析图:

LifeCycle状态改变和事件的解析图

判断的话我们可以使用LifeCycle对象的currentState状态,如下代码:

//直接一个判断就完事了
if (lifecycle.currentState == Lifecycle.State.INITIALIZED) {
    
}

//状态至少要是CREATED
lifecycle.currentState.isAtLeast(Lifecycle.State.CREATED)

进阶使用

进阶使用中,需要引入依赖

implementation 'androidx.lifecycle:lifecycle-extensions:2.2.0'

LifecycleService的使用

上述的只讲了Activity和Fragment的使用方法,如果我们想要Service中想要生命周期解耦,可以使用LifecycleService,其父类是Service,只不过里面已经实现了LifecycleOwner接口,所以用法是基本一样的

我们使用Android Studio快速新建一个Service

然后修改代码为下述代码:

class MyService : LifecycleService() {

    val TAG = "MyService"

    init {
        lifecycle.addObserver(MyServiceObserver())
    }

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        //开启服务就开启个线程
        Log.d(TAG, "onStartCommand: 执行")
        thread {
            for (i in 0..5) {
                Log.d(TAG, "线程打印: $i")
                Thread.sleep(1000)
            }

        }
        return super.onStartCommand(intent, flags, startId)
    }

}

class MyServiceObserver() : LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun create() {
        Log.d("MyService", "Service中的oncreate方法执行了");
    }
}

Service的生命周期和上述Activity的例子一样,这里不再赘述,日志打印如图所示

PS:记得在Activity中使用startService开启服务哦

想起来,之前还没写过Service的学习笔记😂 之后有空补上

ProcessLifecycleOwner的使用

除了上面的情况,有时候我们需要判断下APP是处于前台或后台,这个时候就可以使用ProcessLifecycleOwner,具体用法如下

需要我们自定义一个application,然后在其中注册观察者即可

class MyApplication: Application() {
    override fun onCreate() {
        super.onCreate()
        ProcessLifecycleOwner.get().lifecycle.addObserver(MyApplicationObserver())
    }
}

class MyApplicationObserver : LifecycleObserver{
    //在应用程序的整个生命周期中只会被调用一次
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun onCreate(){
        Log.e("application","Application onCreate方法执行了");
    }


    //在应用程序在前台出现时被调用
    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun onStart(){
        Log.e("application","Application onStart方法执行了");
    }

    //在应用程序在前台出现时被调用
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun onResume(){
        Log.e("application","Application onResume方法执行了");
    }

    //在应用程序退出到后台时被调用
    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun onPause(){
        Log.e("application","Application onPause方法执行了");
    }

    //在应用程序退出到后台时被调用
    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun onStop(){
        Log.e("application","Application onStop方法执行了");
    }


    //永远不会被调用,系统不会分发调用ON_DESTROY事件
    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun onDestroy(){
        Log.e("application","Application onDestroy方法执行了");
    }
}

PS:记得在AndroidManifest中使用我们的这个自定义Application

日志输出如下图所示:

参考