（原创）Jetpack系列（一）：lifecycle

jetpack系列介绍文章

除去前言，

（原创）初识Jetpack

今天是正式内容的第一篇

我们先从lifecycle开始讲

另外需要说明，这个系列的示例代码

我都会采用kotlin语言

这也是希望大家快速掌握这门谷歌推荐的安卓开发语言

1、什么是lifecycle

lifecycle是jetpack系列库中的一个，

主要作用是可以帮助开发者创建可感知生命周期的组件

从而实现业务组件和系统组件解耦

这样描述或许还有些不清楚

但我们需要关注的其实就两点

生命周期和解耦

如图所示，之前我们写的组件（比如自定义的view，service等）

都是需要在系统组件的生命周期方法里做相应的业务

而现在lifecycle让我们自己写的组件

能够在其内部管理自己的生命周期

从而降低模块间的耦合度，并降低内存泄漏发生的可能性

2、lifecycle使用场景

LifeCycle不只对Activity/Fragment有用，

在Service和Application中也能大显身手。

通过查看SupportActivity的源码，可以看到，

在新版本的SDK包中，Activity和Fragment已经默认实现了LifecycleOwner接口。

LifecycleOwner接口中只有一个getLifecycle（LifecycleObserver observer）方法，

LifecycleOwner正是通过该方法实现观察者模式的

当然，更多的使用场景

还是我们自己写的业务场景中使用到的lifecycle。

3、lifecycle使用示例

lifecycle使用起来很简单，下面通过三个简单的小例子开始介绍

示例1

通过做一个简单的计时器

让该计时器在Activity页面显示时（onResume）开始计时

退到后台时（onPause）停止计时

再次进入时（onResume）又开始计时

首先我们先自定义这个计时器Mychronometer

class MyChronometer @JvmOverloads constructor(
    context: Context, attrs: AttributeSet? = null
) : Chronometer(context, attrs), LifecycleObserver {

    var elpase:Long=0

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun startMeter(){
        base = SystemClock.elapsedRealtime() - elpase
        start()
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun stopMeter(){
        elpase = SystemClock.elapsedRealtime() - base
        stop()
    }

}

可以看到，这个自定义控件的两个方法上面

都加上了@onlifecycleEvent注解

这个注解的作用

就代表在执行到这个生命周期的时候

会执行注解下面的方法

然后在xml中使用它，这部分代码我就不写了

现在来到Activity

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

可以看到关键代码其实就只有一行

就是把这个控件放入观察者中

这样，这个控件，就能得到MainActivity生命周期调用情况了

同理，如果需要监听这个Activity的OnRestart等方法

只需要添加相应的注解即可

这边还需要注意一点

大家可能会发现

我这里都没有findViewById

其实是用到了一个kotlin的插件

可以直接用控件的id，当做控件的对象来使用

具体使用方法，在build.gradle里的plugins里添加如下代码：

id 'kotlin-android-extensions'
id 'kotlin-kapt'

就像这样：

plugins {
    id 'com.android.application'
    id 'kotlin-android'
    id 'kotlin-android-extensions'
    id 'kotlin-kapt'
}

示例2

使用LifecycleService解耦Service与组件

除了Activity外，我们也可以监听Service

这时候就需要在build.gradle文件中导入

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

同时我们的Service也需要继承LifecycleService

因为默认的Service不像Activity和Fragment一样实现了LifecycleOwner接口

只有这个LifecycleService，才实现了LifecycleOwner接口

而这个LifecycleService是在lifecycle-extensions库里面的

所以使用前一定要记得导入这个库

class MyService : LifecycleService() {
    private val myLifecycleObserver: MyLifecycleObserver = MyLifecycleObserver()

    init {
        lifecycle.addObserver(myLifecycleObserver)
    }
}

class MyLifecycleObserver : LifecycleObserver {
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    private fun startGetLocation() {
        Log.i("MyLocationListener", "OnResume")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    private fun stopGetLocation() {
        Log.i("MyLocationListener", "OnPause")
    }
}

可以看到，使用方式和前面的Activity是差不多的

示例3

ProcessLifecycIeOwner的使用

ProcessLifecycIeOwner主要是对应用程序的生命周期进行监听的

使用时也要记得添加依赖

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

最后使用也很简单，在自己的application里这样写

class Myapplication : Application() {

    override fun onCreate() {
        super.onCreate()
        ProcessLifecycleOwner.get().lifecycle.addObserver(MyApplicationObserver())
    }

}

MyApplicationObserver里这样写

class MyApplicationObserver : LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun onCreate() {
        Log.d("MyApplicationObserver", "Observer::onCreate")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun onStart() {
        Log.d("MyApplicationObserver", "Observer::onStart")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun onResume() {
        Log.d("MyApplicationObserver", "Observer::onResume")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun onPause() {
        Log.d("MyApplicationObserver", "Observer::onPause")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun onStop() {
        Log.d("MyApplicationObserver", "Observer::onStop")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun onDestroy() {
        Log.d("MyApplicationObserver", "Observer::onDestroy")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
    fun onAny() {
        Log.d("MyApplicationObserver", "Observer::onAny")
    }


}

这里需要注意几点

1、ProcessLifecycleOwner是针对整个应用程序的监听，与Activity数量无关，你有一个Activity或多个Activity，对ProcessLifecycleOwner来说是没有区别的。

2、Lifecycle.Event.ON_CREATE只会被调用一次，而Lifecycle.Event.ON_DESTROY永远不会被调用。

3、当应用程序从后台回到前台，或者应用程序被首次打开时，会依次调用Lifecycle.Event.ON_START和Lifecycle.Event.ON_RESUME。

4、当应用程序从前台退到后台（用户按下Home键或任务菜单键），会依次调用Lifecycle.Event.ON_PAUSE和Lifecycle.Event.ON_STOP。

需要注意的是，这两个方法的调用会有一定的延后。

这是因为系统需要为“屏幕旋转，由于配置发生变化而导致Activity重新创建”的情况预留一些时间。

也就是说，系统需要保证当设备出现这种情况时，这两个事件不会被调用。因为当旋转屏幕时，你的应用程序并没有退到后台，它只是进入了横/竖屏模式而已。

最后，关于lifecycle就先介绍到这里了