乐趣区

关于android:2022-让我带你Jetpack架构组件从入门到精通-Lifecycle

jiezi

前言

不是题目党！作者会尽力把文章写的更容易了解也更充斥深度，本文也随作者的继续学习，继续更新，有问题欢送在评论区提出~

最近更新工夫：2022-06-17

介绍

Jetpack 的正式亮相是在 2018 年的 Google I/ O 大会上，距今曾经过来了四年，在当初的根底上又多了许多的新组件，每个组件都给开发者提供了一个规范，可能帮忙开发者缩小样板代码并编写可在各种 Android 版本和设施中统一运行的 代码，让开发者可能集中精力编写重要的业务代码。然而，也有很多 Android 工程师四年过来了都停留在：晓得、理解过、但没用过。也有很多敌人想要好好学习 Jetpack，然而又无奈网上的知识点太过扩散。本系列文章指标就是带大家残缺的学习 Jetpack 组件，由浅入深。

罕用架构组件图

本系列源码地址：https://github.com/taxze6/Jet…

当初就让咱们进入 Jetpack 的世界，第一站就是 Lifecycle 生命周期治理组件！

Lifecycle

🌟官网文档：https://developer.android.goo…

🌟举荐浏览：深刻了解 AAC 架构 – Lifecycle 整体机制源码

🌟举荐浏览：Lifecycle，看完这次就真的懂了

我置信，在你第一次看见 Lifecycle 时，你会有上面四个疑难：

  • Lifecycle 到底是什么呢？
  • 它是用来干什么的？
  • 它有什么劣势呢？
  • 它要怎么用呢?

Lifecycle 是什么：

  • life: 生命,(某事物)的存在期
  • cycle: 周期

Lifecycle 就是生命周期的意思。它是一个生命周期感知型组件，用来感知响应别的组件，例如感知 Activity 和 Fragment 的生命周期状态的变动。

Lifecycle 用来干什么：

💡 Lifecycle 可能主动感知其余组件的生命周期，可能升高组件之间的耦合性。

在 android 开发中，生命周期这个词很重要，因为内存透露和它有很大很大的关系，内存透露的最次要起因是因为对象的内存无奈被回收，短生命周期对象被长生命周期对象所援用时，短生命周期对象不应用时无奈被回收….. 状况下，就造成了内存透露。（此处留个坑，兴许当前会写对于内存透露如何解决方面的常识，当初大家能够先看其余材料学习）

大家此时心里会想，我要治理生命周期，然而 android 的 activity 不是自带了生命周期的函数吗，我在它外面批改不就行了，你要说有耦合，那全抽到 Base 类中不就好了。方法总是有的嘛~ 的确，在平时开发时，咱们会封装一个 BaseActivity，而后让所有的 Activity 都继承于它。BaseActivity 个别会覆写 onCreate、onStart、onResume、onPause、onStop、onDestroy 以及 onRestart 函数，并在其中加上日志信息，不便察看每个流动的各种状态。咱们能够想到封装 BaseActivity，那么官网必定也会想到，于是就呈现了 Lifecycle。

lifecycle 有什么劣势呢？

既然，咱们本人封装 BaseActivity 就根本可能治理生命周期了，那么官网为何还要 推出 Lifecycle 这个组件呢？

劣势：

  • Lifecycler 实现了执行的逻辑和流动的拆散，代码解耦并且减少了代码的额可读性
  • Lifecycler 在流动完结时自定移除监听，防止了申明周期的问题

如何应用 Lifecycle 呢？

先来理解一下 lifecycle 的外围类：

  • Lifecycle

    Lifecycle 是一个抽象类，实现子类为 LifecycleRegistry


```kotlin
class LifecycleRegistry extends Lifecycle{.......}
```

  • lifecycleRegister

    lifecycle 的惟一子类，用于在生命周期变动时触发本身状态和相干观察者的订阅回调逻辑

  • LifecycleOwner

    用于连贯有生命周期的对象

    public interface LifecycleOwner {
@NonNull
    Lifecycle getLifecycle();}

  • LifecycleObserver

    Lifecycle 观察者

  • State（Lifecycle 的抽象类外部）

    示意以后生命周期所处状态

    public enum State {
    DESTROYED,
    INITIALIZED,
    CREATED,
    STARTED,
    RESUMED;
    public boolean isAtLeast(@NonNull State state) {return compareTo(state) >= 0;
    }
}

  • Event（Lifecycle 的抽象类外部）

    以后生命周期扭转对应的事件

    public enum Event {
    ON_CREATE,
    ON_START,
    ON_RESUME,
    ON_PAUSE,
    ON_STOP,
    ON_DESTROY,
    ON_ANY;
......
}

在理解了这些类和接口的用途之后，再去学习如何应用和源码剖析就简略很多了。

Lifecycle 的应用：

  • gradle 的援用

    dependencies {
        def lifecycle_version = "2.5.0-rc01"
        def arch_version = "2.1.0"
        kapt "androidx.lifecycle:lifecycle-compiler:$lifecycle_version"
        implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"
        implementation "androidx.lifecycle:lifecycle-service:$lifecycle_version"
        implementation "androidx.lifecycle:lifecycle-process:$lifecycle_version"
        implementation "androidx.lifecycle:lifecycle-reactivestreams-ktx:$lifecycle_version"
        testImplementation "androidx.arch.core:core-testing:$arch_version"
    }

    💡 这里能够发现咱们导入了 lifecycle-service，lifecycle-process 这两个组件，因为，在新版的 SDK 中，Activity/Fragment 曾经默认实现了 LifecycleOwner 接口，针对 Service，Android 独自提供了 LifeCycleService，而不是像 Activity、Fragment 默认实现了 LifeCycleOwner。针对 Application，Android 提供了 ProcessLifeCycleOwner 用于监听整个应用程序的生命周期。

当初就让咱们用两种形式实现对 Activity 生命周期的监听吧

  • LifecycleObserver

咱们须要创立一个 MyLifecycleTest 并继承于 LifecycleObserver，应用 OnLifecycleEvent(此办法已过期)，实现对生命周期的监听。

import android.util.Log
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleObserver
import androidx.lifecycle.OnLifecycleEvent
​
//OnLifecycleEvent 曾经过期了
class MyLifecycleTest : LifecycleObserver {
    companion object{private const val TAG = "MyLifecycleTest"}
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun create() {Log.d(TAG, "create:")
    }
​
    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun start() {Log.d(TAG, "start:")
    }
​
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun resume() {Log.d(TAG, "resume:")
    }
​
    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun pause() {Log.d(TAG, "pause:")
    }
​
    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun stop() {Log.d(TAG, "stop:")
    }
​
    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun destroy() {Log.d(TAG, "destroy:")
    }
​
    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
    fun any() {//        Log.d(TAG, "any:")
    }
​
}

在 MainActivity onCreate 种调用 addObserver 办法新增加一个 LifecycleObserver。

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
​
class MainActivity : AppCompatActivity() {override fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        lifecycle.addObserver(MyLifecycleTest())
    }
}

  • 应用DefaultLifecycleObserver

应用它须要映入 androidx.lifecycle:lifecycle-common-java8，如果我的项目中应用了 java8 或者开启 java8 个性，那么官网举荐应用 DefaultLifecycleObserver 代替的@OnLifecycleEvent 注解实现（因为当初注解曾经被弃用了），包含预编译。

咱们创立一个MyDefaultLifecycleObserver 继承于 DefaultLifecycleObserver

import android.util.Log
import androidx.lifecycle.DefaultLifecycleObserver
import androidx.lifecycle.LifecycleOwner
​
class MyDefaultLifecycleObserver : DefaultLifecycleObserver {
    companion object {private const val TAG = "MyDefaultLifecycleObserver"}
​
    override fun onCreate(owner: LifecycleOwner) {super.onCreate(owner)
        Log.d(TAG, "onCreate:")
    }
​
    override fun onStart(owner: LifecycleOwner) {super.onStart(owner)
        Log.d(TAG, "onStart:")
    }
​
    override fun onResume(owner: LifecycleOwner) {super.onResume(owner)
        Log.d(TAG, "onResume:")
    }
​
    override fun onPause(owner: LifecycleOwner) {super.onPause(owner)
        Log.d(TAG, "onPause:")
    }
​
    override fun onStop(owner: LifecycleOwner) {super.onStop(owner)
        Log.d(TAG, "onStop:")
    }
​
    override fun onDestroy(owner: LifecycleOwner) {super.onDestroy(owner)
        Log.d(TAG, "onDestroy:")
    }
}

而后咱们再创立一个MyApplication

通过 addObserver() 将Observer增加到LifecycleRegistry。

应用 ProcessLifecycleOwner.get().lifecycle.addObserver(MyDefaultLifecycleObserver())

import android.app.Application
import androidx.lifecycle.ProcessLifecycleOwner
​
class MyApplication : Application() {override fun onCreate() {super.onCreate()
        ProcessLifecycleOwner.get().lifecycle.addObserver(MyDefaultLifecycleObserver())
    }
}

在 AndroidManifest.xml 中增加上面这行运行代码，当应用程序过程启动时，这个被指定的子类在任何利用的组件之前被实例化。

应用起来是很简略的，当然，这只是一个简略的例子，所以咱们还须要摸索一下 Lifecycle 的具体实现，并多多练习能力把握好它。

举例几个 Lifecycle 的应用场景：

  • Retrofit 配合 Lifecycle 治理 Http 生命周期

    • 这里举荐浏览：https://mp.weixin.qq.com/s/om…
  • 暂停和复原动画绘制
  • 视频的暂停与播放
  • Handler 的音讯移除
  • ……..

这里留下几个问题：

  • Lifecycle 的创立形式有哪几种（有什么不同，举荐应用哪一种）？
  • Lifecycle 是如何进行生命周期同步的？
  • Event 事件和 State 状态是什么关系？
  • Lifecycle 的注册，派发，感知的过程是怎么样的？
  • 什么叫做嵌套事件？产生的机会是什么？Lifecycle 是如何解决的？

请大家本人先寻找一下答案，在 Jetpack 源码剖析系列咱们会详细分析（这个系列还没写🌝）。

根底系列：

2022 · 让我带你 Jetpack 架构组件从入门到精通 — Lifecycle (本文🌟)

以下局部还在码字，连忙点个珍藏吧🔥

2022 · 让我带你 Jetpack 架构组件从入门到精通 — ViewModel&LiveData

2022 · 让我带你 Jetpack 架构组件从入门到精通 — DataBinding

2022 · 让我带你 Jetpack 架构组件从入门到精通 — Navigation

2022 · 让我带你 Jetpack 架构组件从入门到精通 — Room

2022 · 让我带你 Jetpack 架构组件从入门到精通 — Paging3

2022 · 让我带你 Jetpack 架构组件从入门到精通 — WorkManager

2022 · 让我带你 Jetpack 架构组件从入门到精通 — ViewPager2

2022 · 让我带你 Jetpack 架构组件从入门到精通 — 登录注册页面实战（MVVM）

进阶系列：

协程 + Retrofit 网络申请状态封装

Room 缓存封装

…..

退出移动版