Jetpack学习之ViewModel、Lifecycles、LiveData

声明：本学习笔记基于郭霖大大的《第一行代码 第3版》并结合官方文档、网络资源以及个人理解整理而成，欢迎大家讨论指正

Jetpack简介

主要组成

​ Jetpack是一个开发工具集，能够协助开发者编写出更简洁的代码，简化开发过程，并且这些组件有一个很好的特点，他们大部分不依赖与任何Android系统版本，这意味着这些组件通常是定义在AndroidX库当中，并且拥有非常好的向下兼容性。

​ Jetpack全家桶包含内容非常多，主要可分为 基础、架构、行为、界面 4个部分，本次学习主要聚焦于对架构的学习，其中很多组件更是专门为MVVM架构量身打造的。

使用前准备

​ Jetpack中组件通常都是以AndroidX库的形式发布的，所以常用的Jetpack组件会在创建Android项目时被自动包含进去，使用者个可以根据官方文档的说明，在app/build.gradle根据需要添加依赖

    dependencies {
        def lifecycle_version = "2.4.0-rc01"
        def arch_version = "2.1.0"

        // ViewModel
        implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version"
        // LiveData
        implementation "androidx.lifecycle:lifecycle-livedata-ktx:$lifecycle_version"
        // Lifecycles only (without ViewModel or LiveData)
        implementation "androidx.lifecycle:lifecycle-runtime-ktx:$lifecycle_version"

        // Saved state module for ViewModel
        implementation "androidx.lifecycle:lifecycle-viewmodel-savedstate:$lifecycle_version"

        // Annotation processor
        kapt "androidx.lifecycle:lifecycle-compiler:$lifecycle_version"
        // alternately - if using Java8, use the following instead of lifecycle-compiler
        implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"

        // optional - helpers for implementing LifecycleOwner in a Service
        implementation "androidx.lifecycle:lifecycle-service:$lifecycle_version"

        // optional - ProcessLifecycleOwner provides a lifecycle for the whole application process
        implementation "androidx.lifecycle:lifecycle-process:$lifecycle_version"

        // optional - ReactiveStreams support for LiveData
        implementation "androidx.lifecycle:lifecycle-reactivestreams-ktx:$lifecycle_version"

        // optional - Test helpers for LiveData
        testImplementation "androidx.arch.core:core-testing:$arch_version"
    }
    

示例准备

​ 还有一个简单的，包含了一堆按钮的布局文件activity_main.xml，可以提前写进进去了

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <TextView
        android:id="@+id/infoText"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="center_horizontal"
        android:textSize="32sp"/>

    <Button
        android:id="@+id/plusOneBtn"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_gravity="center_horizontal"
        android:text="Plus One"/>

    <Button
        android:id="@+id/clearBtn"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_gravity="center_horizontal"
        android:text="Clear"/>

    <Button
        android:id="@+id/getUserBtn"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_gravity="center_horizontal"
        android:text="Get User"/>

    <Button
        android:id="@+id/addDataBtn"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_gravity="center_horizontal"
        android:text="Add Data"/>

    <Button
        android:id="@+id/updateDataBtn"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_gravity="center_horizontal"
        android:text="Update Data"/>

    <Button
        android:id="@+id/deleteDataBtn"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_gravity="center_horizontal"
        android:text="Delete Data"/>

    <Button
        android:id="@+id/queryDataBtn"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_gravity="center_horizontal"
        android:text="Query Data"/>

    <Button
        android:id="@+id/doWorkBtn"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_gravity="center_horizontal"
        android:text="Do Work"/>

</LinearLayout>

ViewModel

简介

​ Jetpack最重要的组件之一，可以帮任务太重的Activity分担一部分工作，用于专门存放界面相关数据，即界面上能看到的数据，其相关变量都应该存放在ViewModel中，而不是Activity，从而减轻Activity工作。

重要特性

​ 手机横竖屏旋转时，Activity会被重新创建，存放在Activity中的数据也会丢失，而ViewModel不会因为屏幕旋转而重新创建，只有当Activity退出时才会跟着Activity一起销毁，所以非常适合存放界面上的变量。

生命周期示意图

基本用法

​ 通常来讲，比较好的编程规范是要给每个Activity和Fragment都创建一个对应的ViewModel，这里以创建一个简单的计数器为例

1. 为MainActivity创建一个对应的MainViewModel类继承自ViewModel

   import androidx.lifecycle.ViewModel
   class MainViewModel: ViewModel() {
       //计数器变量
       var counter = 0
   }
   

2. 在MainActivity中获取MainViewModel并调用

   import androidx.appcompat.app.AppCompatActivity
   import android.os.Bundle
   import android.view.LayoutInflater
   import androidx.lifecycle.ViewModelProvider
   import com.example.jetpacktest.databinding.ActivityMainBinding
   
   class MainActivity : AppCompatActivity() {
   
       val binding: ActivityMainBinding by lazy{
           ActivityMainBinding.inflate(LayoutInflater.from(this))
       }
   	
       lateinit var viewModel: MainViewModel
       override fun onCreate(savedInstanceState: Bundle?) {
           super.onCreate(savedInstanceState)
           setContentView(binding.root)
           //注意：ViewModelProviders.of已弃用
           //注意：绝对不可以直接去创建ViewModel实例
           viewModel = ViewModelProvider(this)[MainViewModel::class.java]
   		//调用
           binding.plusOneBtn.setOnClickListener {
               viewModel.counter++
               refreshCounter()
           }
       }
       
   	//刷新函数
       private fun refreshCounter() {
           binding.infoText.text = viewModel.counter.toString()
       }
   
   }
   

   ​ 记住绝对不可以直接去创建ViewModel实例，一定要通过ViewModelProvider(ViewModelStoreOwner)构造函数来获取，具体语法规则为为viewModel = ViewModelProvider(<你的Activity或Fragment实例>)[<你的ViewModel>::class.java]

   ​ 之所以要这样写是因为每次旋转屏幕都会重新调用onCreate()方法，若每次都创建新的实例就无法保存数据了。用上述方法，onCreate方法被再次调用，它会返回一个与确切的与MainActivity相关联的预先存在的ViewModel，这就是保存数据的原因。

   ​ 悲报：

   ​ 在2019.08..07的版本更新中弃用了 ViewModelProviders.of()。您可以将 Fragment 或 FragmentActivity 传递给新的ViewModelProvider(ViewModelStoreOwner) 构造函数，以实现相同的功能。

向ViewModel传递参数

​ 来看看需要通过构造函数传递参数的情况，主要借助ViewModelProvider.Factory实现，并且还能实现退出程序后重新打开仍然保留数据的功能

1. 修改MainViewModel代码，添加构造函数

   class MainViewModel(countReserved: Int): ViewModel() {
       var counter = countReserved
   }
   

2. 新建一个MainViewModelFactory类实现ViewModelProvider.Factory接口

   import androidx.lifecycle.ViewModel
   import androidx.lifecycle.ViewModelProvider
   
   class MainViewModelFactory(private val countReserved: Int): ViewModelProvider.Factory {
       override fun <T : ViewModel> create(modelClass: Class<T>): T {
           //创建MainViewModel实例
           return MainViewModel(countReserved) as T
       }
   }
   

   ​ 构造器中接受了countReserved参数，并要求实现create()方法，并在里面创建MainViewModel实例，因为该方法的执行时机与Activity的生命周期无关，所以不会产生此前的问题。

3. 修改MainActivity

   class MainActivity : AppCompatActivity() {
   	...
       lateinit var viewModel: MainViewModel
       lateinit var sp: SharedPreferences
   
       override fun onCreate(savedInstanceState: Bundle?) {
           super.onCreate(savedInstanceState)
           setContentView(binding.root)
           
           sp = getPreferences(Context.MODE_PRIVATE)
           val countReserved = sp.getInt("count_reservde",0)
   
           viewModel = ViewModelProvider(
               this, MainViewModelFactory(countReserved))[MainViewModel::class.java]
           ...
           binding.clearBtn.setOnClickListener { 
               viewModel.counter  = 0
               refreshCounter()
           }
           refreshCounter()
       }
   
       override fun onPause() {
           super.onPause()
           //对计数进行保存
           sp.edit {
               putInt("count_reservde",viewModel.counter)
           }
       }
       
   	...
   }
   

   ​ 在onCreate()方法中，我们先获取SharedPreferences的实例，用于关闭程序后保存数据。然后读取之前保存的计数值，如果没有读到就以0为默认值。要注意在ViewModelProvider()方法中多传入了一个参数，是将读取到的计数值传给了 MainViewModelFactory，这有这样才能将计数值传递给MainViewModel的构造函数。

Lifecycles

简介

Lifecycles用于感知Activity的生命周期（在非Activity类也可），下面是手写Lifecycle监听器的两步方法

基本用法

1. 新建一个MyObserver类实现LifecycleObserver接口

   import android.util.Log
   import androidx.lifecycle.Lifecycle
   import androidx.lifecycle.LifecycleObserver
   import androidx.lifecycle.OnLifecycleEvent
   
   class MyObserver : LifecycleObserver{ //其实这是一个空方法接口，只需要实现声明即可
   	//利用注解功能，会在Activity的OnStart()触发时执行
       @OnLifecycleEvent(Lifecycle.Event.ON_START)
       fun activityStart() {
           Log.d("MyObserver","activityStart")
       }
   
       @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
       fun activityStop() {
           Log.d("MyObserver","activityStop")
       }
       
   }
   

   ​ 利用注解功能传入相应得生命周期时间，需要注意的是除了熟悉的六种外还多了一种ON_ANY类型，可以表示以匹配Activity的任何生命周期回调

2. 借助LifecycleOwner获取通知，在MainActivity中增加一行代码，MyObserver就能自动感应Activity的生命周期了

   override fun onCreate(savedInstanceState: Bundle?) {
           super.onCreate(savedInstanceState)
           setContentView(binding.root)
           ...
       	//增加一行
           lifecycle.addObserver(MyObserver())
       	...
       }
   

   ​ 首先我们要了解LifecycleOwner的语法结构是：LifecycleOwner.lifecycle.addObserver(MyObserver())，而只要你的Activity是继承自AppCompatActivity，或者你的Fragment继承自androidx.fragment.app.Fragment的，那么它们本身就是一个LifecycleOwner实例，在AndroidX库中已经自动帮我们实现了，所以上示代码才可以这样写。

3. 若是想要主动获取当前生命周期状态，只需在MyObserver的构造函数中传入Lifecycle对象，相应修改MainActivity即可

   class MyObserver(val lifecycle: Lifecycle) : LifecycleObserver{ //其实这是一个空方法接口，只需要实现声明即可
   	...
   }
   

    lifecycle.addObserver(MyObserver(lifecycle))
   

生命周期对应状态示意图

LiveData

简介

LiveData是一种可观察的数据存储器类。与常规的可观察类不同，LiveData 具有生命周期感知能力，意指它遵循其他应用组件（如 Activity、Fragment 或 Service）的生命周期。这种感知能力可确保 LiveData 仅更新处于活跃生命周期状态的应用组件观察者。

之前示例代码的缺陷：

​ 一直都是在Activity中操作，每次加一先给ViewModel 中的计数加一，然后再调用其获取，，而并不是ViewModel 主动通知返回给Activity，在多线程任务中容易或渠道错误的数据

解决方法:

​ 把Activity传给ViewModel ？那绝对不行，根据上示ViewModel 生命周期示意图，ViewModel 的生命周期是长于Activity的，若把Activity实例传给ViewModel ，很可能导致Activity无法释放从而造成内存泄露，这是一种非常错误的做法！正解当然就是用LiveData啦

基本用法

​ MutableLiveData是一种可变的LiveData，主要是3种读写数据的方法

• getValue()用于获取LiveData中包含的数据

• setValue()用于在主线程中给LiveData设置数据

• postValue()用于在非主线程中给LiveData设置数据

  一般在Kotlin中会采用语法糖写法，如下例

1. 修改上面写过的MainViewModel代码

   class MainViewModel(countReserved: Int): ViewModel() {
   
       var counter = MutableLiveData<Int>()
   
       init {//初始化之前保存的数据
           counter.value = countReserved
       }
   
       fun plusOne() {
           val count = counter.value ?:0
           counter.value = count + 1
       }
   
       fun clear() {
           counter.value = 0
       }
   
   }
   

   ​ 这里counter变量修改为一个MutableLiveData对象，泛型指定为Int表示整形数据。init结构体给counter设置数据，这样之前保存的数据可以在初始化时得以恢复。新增两个函数分别用于“加1”和“清零”操作，由于LiveData的getvalue方法可能为空，所以这里用一个?:操作符，当获取到的数据为空时就用0为默认计数。

2. 修改MainActivity

   override fun onCreate(savedInstanceState: Bundle?) {
   		...
           binding.plusOneBtn.setOnClickListener {
   //            viewModel.counter++
   //            refreshCounter()
               viewModel.plusOne()
           }
   
           binding.clearBtn.setOnClickListener {
   //            viewModel.counter = 0
   //            refreshCounter()
               viewModel.clear()
           }
   
           viewModel.counter.observe(this, Observer { count ->
               binding.infoText.text = count.toString()
           })
   
       }
   
       override fun onPause() {
           super.onPause()
           sp.edit {
               putInt("count_reservde", viewModel.counter.value ?: 0)
           }
       }
   

   ​ 在两个按钮对应的事件中都换成了对应的方法plusOne()和clear()，在onPause()方法中也相应修改了写法，中间是最关键的修改地方：这里调用了viewModel.counter的observe()方法，需要传入两个参数，一是LifecycleOwner，在上文提到Activity本身也是LifecycleOwner，所以直接传入this，第二个参数是Observer接口，当counter中包含的数据发生变化时，就会回调到这里，我们也能借此更新到界面上。

   ​ 修改后的好处：不用担心ViewModel 开启线程执行耗时逻辑，同时也应注意此时是运行在主线程中，若要在子线程修改LiveData值则要注意一定要调用postValue()方法

3. 以上就是LiveData的基础用法了，但还不算最规范的，主要问题在于我们把counter这个可变的LiveData暴露给了外部，这样即使是在ViewModel 外面也能为counter设置数据，从而破坏ViewModel 的封装性并存在一定风险。所以比较推荐的做法是，永远只暴露不可变的LiveData给外部。这样在非ViewModel中就只能观察LiveData的数据变化而不能设置LiveData数据：

   class MainViewModel(countReserved: Int): ViewModel() {
   //    var counter = MutableLiveData<Int>()
   //    init { counter.value = countReserved }
   //    fun plusOne() {
   //        val count = counter.value ?:0
   //        counter.value = count + 1
   //    }
   //    fun clear() { counter.value = 0}
       
       val counter : LiveData<Int>
           get() = _counter
       
       private val _counter = MutableLiveData<Int>()
   
       init {
           _counter.value = countReserved
       }
   
       fun plusOne() {
           val count = _counter.value ?:0
           _counter.value = count + 1
       }
   
       fun clear() {
           _counter.value = 0
       }
   
   }
   

   ​ 相比原来，counter变量全部变为了_counter变量，并添加了private修饰符对外部不可见，然后重新定义一个counter变量声明为不可变的LiveData，并在它的get()属性方法中返回_counter变量，这样做当外部调用counter变量时，实际上获得的是_counter的实例，并无法给counter设置数据，从而保证了封装性，这也是官方的推荐写法，非常规范

map和switchMap

LiveData的两种转换方法：map()和switchMap()