Jetpack

一 ViewModel

ViewModel的一个重要作用就是可以帮助Activity分担一部分工作，它是专门用于存放与界面相关的数据的。也就是说，只要是界面上能看得到的数据，它的相关变量都应该存放在ViewModel中，而不是Activity中，这样可以一定程度上减少Activity中的逻辑。
当手机发生横竖屏切换的时候，Activity会被重新创建，同时存放在Activity中的数据也会丢失，而ViewModel的生命周期和Activity不同，它可以保证在手机屏幕发生旋转的时候不会被重新创建，只有当Activity退出的时候才会跟着Activity一起销毁，因此，将与界面相关的变量存放在ViewModel当中，这样即使旋转手机屏幕，界面上显示的数据也不会丢失。

ViewModel生命周期

  • ViewModel基本用法
    由于Jetpack中的组件通常是以AndroidX库的形式发布的，因此一些常用的Jetpack组件会在创建Android项目时自动被包含进去，不过如果想要使用ViewModel组件，还需要添加依赖：
    implementation 'androidx.lifecycle:lifecycle-extensions:2.2.0'
    通常来讲，比较好的编程规范是给每一个Activity或Fragment都创建一个对应的ViewModel
class MainViewModel : ViewModel() {

    var counter = 0

}

<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity"
    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:text="加1"/>

</LinearLayout>

class MainActivity : AppCompatActivity() {

    private lateinit var viewModel: MainViewModel
    private lateinit var infoText: TextView
    private lateinit var plusOneBtn: Button

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        initView()
        setListener()
    }

    private fun initView() {
        viewModel = ViewModelProvider(this).get(MainViewModel::class.java)
        infoText = findViewById(R.id.infoText)
        plusOneBtn = findViewById(R.id.plusOneBtn)
        refreshCounter()
    }

    private fun setListener() {
        plusOneBtn.setOnClickListener {
            viewModel.counter++
            refreshCounter()
        }
    }

    private fun refreshCounter() {
        infoText.text = viewModel.counter.toString()
    }
}
  • 不能直接去创建ViewModel的实例，而是一定要通过ViewModelProvider来获取ViewModel的实例，具体语法规则如下：
    ViewModelProvider(<你的Activity或Fragment实例>).get(<你的ViewModel>::class.java)
  • 之所以要怎么写，是因为ViewModel有其独立的生命周期，并且生命周期要长于Activity
  • 如果我们在onCreate()方法中创建ViewModel的实例，那么每次onCreate()方法执行的时候，ViewModel都会创建一个新的实例，这样当手机屏幕发生旋转的时候，就无法保留其中的数据了
  • 向ViewModel传递参数
    借助ViewModelProvider.Factory实现传递参数给ViewModel的构造函数，实现即使退出程序之后再重新打开，数据仍然不会丢失：
    修改MainViewModel：
class MainViewModel(countReserved: Int) : ViewModel() {

    var counter = countReserved

}

新建一个MainViewModelFactory类并让它实现ViewModelProvider.Factory接口，如下：

class MainViewModelFactory(private val countReserved: Int) : ViewModelProvider.Factory {

    override fun <T : ViewModel?> create(modelClass: Class<T>): T {
        return MainViewModel(countReserved) as T
    }

}

为什么这里就可以创建MainViewModel的实例了呢？因为create()方法的执行时机和Activity的生命周期无关，所以不会产生之前提到的问题。
加个清零按钮：

<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity"
    android:orientation="vertical">
    
    ...
    <Button
        android:id="@+id/clearBtn"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="清零"/>

</LinearLayout>

class MainActivity : AppCompatActivity() {

    private lateinit var viewModel: MainViewModel
    private lateinit var infoText: TextView
    private lateinit var plusOneBtn: Button
    private lateinit var sp: SharedPreferences
    private lateinit var clearBtn: Button

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        initView()
        setListener()
    }

    private fun initView() {
        sp = getPreferences(Context.MODE_PRIVATE)
        val countReserved = sp.getInt("count_reserved", 0)
        viewModel = ViewModelProvider(this, MainViewModelFactory(countReserved)).get(MainViewModel::class.java)
        infoText = findViewById(R.id.infoText)
        clearBtn = findViewById(R.id.clearBtn)
        plusOneBtn = findViewById(R.id.plusOneBtn)
        refreshCounter()
    }

    private fun setListener() {
        plusOneBtn.setOnClickListener {
            viewModel.counter++
            refreshCounter()
        }
        clearBtn.setOnClickListener { 
            viewModel.counter = 0
            refreshCounter()
        }
    }

    private fun refreshCounter() {
        infoText.text = viewModel.counter.toString()
    }

    override fun onPause() {
        super.onPause()
        sp.edit().putInt("count_reserved", viewModel.counter)
    }
}

二 Lifecycles

  • 我们知道，再Activity里感知它的生命周期非常简单，只需复写它的生命周期方法即可
  • 那么如果我们需要在一个非Activity类里面去时刻感知Activity的生命周期，就需要借助Lifecycles
  • Lifecycles组件可以让任何一个类都能轻松感知到Activity的生命周期
    下面通过具体例子来学习Lifecycles组件的用法，新建一个MyObserver类，并让它实现LifecycleObserver接口：
class MyObserver : LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun activityStart(){
        Log.e("MyObserver", "activityStart")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun activityStop(){
        Log.e("MyObserver", "activityStop")
    }
}

可以看到，我们在方法上使用了@OnLifecycleEvent注解，并传入了一种生命周期事件，生命周期事件一共有七种，分别匹配Activity中相应的生命周期回调；另外还有一种ON_ANY类型，表示可以匹配Activity的任何生命周期回调，因此，上述代码中的activityStart()和activityStop()方法就应该分别在Activity的onStart()和onStop()触发的时候执行。

  • 为了使当Activity的生命周期发生变化的时候能够通知MyObserver，就得借助LifecycleOwner：
    lifecycleOwner.lifecycle.addObserver(MyObserver())
    首先调用LifecycleOwner的getLifecycle()方法，得到一个Lifecycle对象，然后调用它的addObserver()方法来观察LifecycleOwner的生命周期，再把MyObserver是实例传进去就OK了。
  • 那么LifecycleOwner又是什么呢？怎样才可以获取一个LifecycleOwner的实例？
    只要你的Activity是继承自AppCompatActivity的，或者你的Fragment是继承自androidx.fragment.app.Fragment的，那么它们本身就是一个LifecycleOwner的实例，这部分工作由AndroidX库自动帮我们完成了。可以在MainActivity中这么写：
    lifecycle.addObserver(MyObserver())

只要添加这么一行代码，MyObserver就能自动感知到Activity的生命周期了，在Fragment中也是一样的。

  • 不过目前MyObserver虽然能够感知到Activity的生命周期发生了变化，却没有办法主动获知当前的生命周期状态。要解决这个问题只需要在MyObserver的构造函数中将Lifecycle对象传进来即可：
class MyObserver(val lifecycle: Lifecycle) : LifecycleObserver {

    ...
}

有了Lifecycle对象之后，我们就可以在任何地方调用lifecycle.currentState来主动获知当前的生命周期状态。
lifecycle.currentState返回的生命周期状态是一个枚举类型，一共有INITIALIZED、DESTROYED、CREATED、STARTED、RESUMED这五种状态类型

四 LiveData

LiveData是Jetpack提供的一种响应式编程组件，它可以包含任意类型的数据，并在数据发生变化的时候通知给观察者。

  • 之前编写的计数器其实存在一个问题，那就是如果ViewModel内部开启了线程去执行一些耗时逻辑，那么在点击按钮后就立即去获取最新的数据，得到的肯定还是之前的数据
  • 现在，就通过LiveData让ViewModel在数据变化时主动通知给观察者
  • 修改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
    }

}

MutableLiveData是一种可变的LiveData，它的用法很简单，主要有三种读写数据的方法，分别是getValue()、setValue()、postValue()，postValue()方法用于在非主线程中给LiveData设置数据，setValue()只能在主线程中调用。

  • 接下来开始改造MainActivity 
class MainActivity : AppCompatActivity() {

    。。。

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        initView()
        setListener()
        viewModel.counter.observe(this, Observer{
            infoText.text = it.toString()
        })
    }

    。。。

    private fun setListener() {
        plusOneBtn.setOnClickListener {
            viewModel.plusOne()
        }
        clearBtn.setOnClickListener { 
            viewModel.clear()
        }
    }

    private fun refreshCounter() {
        infoText.text = viewModel.counter.toString()
    }

    override fun onPause() {
        super.onPause()
        sp.edit().putInt("count_reserved", viewModel.counter.value ?: 0)
    }
}

这里调用viewModel.counter的observe()方法来观察数据的变化，经过对MainViewModel的改造，现在counter变量已经变成了一个LiveData对象，任何LiveData对象都可以调用它的observe()方法来观察数据的变化。observe()方法接收两个参数：第一个参数是一个LifecycleOwner对象；第二个参数是一个Observer接口，当counter中包含的数据发生变化时，就会回调到这里，此时将最新的数据更新到界面上即可

  • lifecycle-livedata-ktx是一个专门为Kotlin语言设计的库，这个库在2.2.0版本加入了对observe()方法的语法扩展，只需添加如下依赖：
    implementation "androidx.lifecycle:lifecycle-livedata-ktx:2.2.0"
  • 然后就可以使用如下语法结构的observe()方法了
viewModel.counter.observe(this){
    infoText.text = it.toString()
}
  • 改造MainViewModel，永远只暴露不可变的LiveData给外部
class MainViewModel(countReserved: Int) : ViewModel() {

    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变量对于外部就是不可见的了；然后我们又重新定义了一个counter变量，将它的类型声明为不可变的LiveData，并在它的get()属性方法中返回_counter变量，这样，当外部调用counter变量时，实际上获得的就是_counter的实例，但是无法给counter设置数据，从而保证了ViewModel的数据封装性，这也是Android官方推荐的写法。

  • switchMap
  • model
    data class User(var firstName: String, var lastName: String, var age: Int)
  • MainViewModel
class MainViewModel(countReserved: Int) : ViewModel() {

    ...
    private val userIdLiveData = MutableLiveData<String>()

    val user: LiveData<User> = Transformations.switchMap(userIdLiveData){
        Repository.getUser(it)
    }

    fun getUser(userId: String){
        userIdLiveData.value = userId
    }
}

switchMap方法接收两个参数：第一个参数传入userIdLiveData，switchMap方法会对它进行观察；第二个参数是一个转换函数。它整体的工作流程是：当外部调用MainViewModel的getUser()方法来获取用户数据时，并不会发起任何请求或者函数调用，只会将传入的userId值设置到userIdLiveData当中，一旦userIdLiveData的数据发生变化，那么观察userIdLiveData的switchMap()方法就会执行，并且调用我们编写的转换函数，然后在转换函数中调用Repository.getUser()方法获取真正的用户数据，同时，switchMap()方法会将Repository.getUser()方法返回的LiveData对象转换成一个可观察的LiveData对象，对于Activity而言，只要去观察这个LiveData对象就可以了，如下：

class MainActivity : AppCompatActivity() {

    。。。

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        initView()
        setListener()
        getUserBtn.setOnClickListener {
            viewModel.getUser("yang")
        }
        viewModel.user.observe(this, Observer {user ->
            infoText.text = user.firstName
        })
    }

   。。。
}
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容

  • 第一行代码读书笔记 15 -- 探究 Jetpack
    本篇文章主要介绍以下几个知识点：ViewModelLifecyclesLiveDataRoomWorkManage...
    开心wonderful阅读 1,157评论 0赞 0
  • Jetpack笔记
    Jetpack 简介 JetPack是一个开发组件工具集，主要目的是帮助我们编写出更加简洁的代码，并简化开发过程。...
    FFFSnow阅读 450评论 0赞 0
  • JetPack
    Jetpack 知识点 1.1 JetPack是什么？ 官方定义如下: Jetpack 是一个由多个库组成的套件，...
    半称心x度阅读 1,194评论 0赞 1
  • Jetpack系列全解析
    一、什么是Jetpack? Jetpack并不是一个框架或者组件，它是一套库、工具和指南的集合，可帮助开发者更轻松...
    沉淀者阅读 11,613评论 0赞 7
  • Jetpack
    1、Jetpack简介 Jetpack是一个开发组件工具集，主要由基础、架构、行为、界面四部分组成。它主要目的是帮...
    code希必地阅读 390评论 0赞 1