乐趣区

关于android:Jetpack架构组件库Lifecycle应用解析之知其然

jiezi

原文连贯：https://mp.weixin.qq.com/s/vF4v5ELjM6qYzU-MlXHhWw

前言

== 本次次要解说的内容：==

1、Lifecycle 介绍，解决了什么问题

2、Lifecycle 了解与使用

3、Lifecycle 如何感知生命周期的状态？

一、Jetpack 介绍

1、什么是 Lifecycle

Lifecycle 是具备宿主生命周期感知能力的组件。

它能持有组件（如 Activity 或 Fragment）生命周期状态的信息，并且容许其余观察者监听宿主的状态。

它也是 Jetpack 组件库的的外围根底，包含咱们就前面会讲到的 LiveData，ViewModel 组件等也都是基于它来实现的。

2、Lifecycle 解决什么问题？

Android 开发中的次要问题之一是生命周期治理问题。

换句话说，如果不能正确处理应用程序生命周期，可能会导致一些问题，如内存透露和一些解体。

生命周期感知组件作为 Android 体系结构组件的一部分，可依据其余组件（如 Activity 或 Fragment）生命周期状态的变动实现工作。

因而，这些组件可帮忙您创立组织更好的代码，并且通常分量更轻的代码更易于保护和测试。

一种常见的模式是在 Activity 和 Fragment 的生命周期办法中实现依赖组件的操作。然而，这种模式会导致代码条理性很差而且会扩散谬误。

比方，咱们通过 Activity 在屏幕上显示以后的定位，通常会做如下实现：

    class MyLocationListener {public MyLocationListener(Context context, Callback callback) {// ...}

        void start() {// 开启定位服务}

        void stop() {// 断开定位服务}
    }

    class MyActivity extends AppCompatActivity {
        private MyLocationListener myLocationListener;

        @Override
        public void onCreate(...) {myLocationListener = new MyL ocationListener(this, (location) -> {// update UI});
        }

        @Override
        public void onStart() {super.onStart();
            myLocationListener.start();
            // 治理其余组件须要响应 Activity 生命周期
        }

        @Override
        public void onStop() {super.onStop();
            myLocationListener.stop();
            // 治理其余组件须要响应 Activity 生命周期
        }
    }

示例看起来没问题，但在实在的利用中，最终会有太多治理界面和其余组件的调用，以响应生命周期的以后状态。治理多个组件会在生命周期办法（如 onStart() 和 onStop()）中搁置大量的代码，这使得它们难以保护。

此外，无奈保障组件会在 Activity 或 Fragment 进行之前启动。在咱们须要执行长时间运行的操作（如 onStart() 中的某种配置查看）时尤其如此。这可能会导致呈现一种竞争条件，在这种条件下，onStop() 办法会在 onStart() 之前完结，这使得组件留存的工夫比所需的工夫要长。

二、Lifecycle 了解与使用

Lifecycle 用法：

Lifecycle 有三种写法，接下来介绍它的写法：

应用 Lifecycle 前须要先增加依赖：

 // 如果想独自应用，可引入上面这个依赖
api 'androidx.lifecycle:lifecycle-common:2.1.0'

以下面通过 Activity 在屏幕上显示以后的定位位列

1、LifecycleObserver 配合注解用法：

//1. 自定义的 LifecycleObserver 观察者，在对应办法上用注解申明想要观  察的宿主的生命周期事件即可
class LocationObserver extends LifecycleObserver{
    // 宿主执行了 onstart 时，会散发该事件
    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    void onStart(@NotNull LifecycleOwner owner){// 开启定位}
  
  // 宿主执行了 onstop 时 会散发该事件
  @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
  void onStop(@NotNull LifecycleOwner owner){// 进行定位}
 }

//2. 注册观察者, 察看宿主生命周期状态变动
class MyActivity extends AppCompatActivity{public void onCreate(...){LocationObserver observer =new LocationObserver()
    // 应该在 Activity 的 onCreate（）办法中增加此行代码，以便通过应用  getLifecycle().addObserver() 将生命周期所有者 Activity 与 LocationObserver 关联。getLifecycle().addObserver(observer);
  }
 }

2、通过集成 FullLifecyclerObserver 领有宿主所有生命周期事件用法：

//1. 查看 FullLifecycleObserver 源码
interface FullLifecycleObserver extends LifecycleObserver {void onCreate(LifecycleOwner owner);

    void onStart(LifecycleOwner owner);

    void onResume(LifecycleOwner owner);

    void onPause(LifecycleOwner owner);

    void onStop(LifecycleOwner owner);

    void onDestroy(LifecycleOwner owner);
}

//2. 用法, 复写须要监听的办法
class LocationObserver implements FullLifecycleObserver{void onStart(LifecycleOwner owner){// 开启定位}
    void onStop(LifecycleOwner owner){// 进行定位}
}

//3. 注册观察者, 察看宿主生命周期状态变动
class MyActivity extends AppCompatActivity{public void onCreate(...){LocationObserver observer =new LocationObserver()
    // 应该在 Activity 的 onCreate（）办法中增加此行代码，以便通过应用  getLifecycle().addObserver() 将生命周期所有者 Activity 与 LocationObserver 关联。getLifecycle().addObserver(observer);
  }
 }

3、通过 LifecycleEventObserver 宿主生命周期事件封装成 Lifecycle.Event 的用法：

//1、LifecycleEventObserver 源码
public interface LifecycleEventObserver extends LifecycleObserver {
    /**
     * Called when a state transition event happens.
     *
     * @param source The source of the event
     * @param event The event
     */
    void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event);
}

//2. 用法 
class LocationObserver extends LifecycleEventObserver{
    @Override
    public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {
        // 须要自行判断 life-event 是 onstart, 还是 onstop
       if(event == Lifecycle.Event.ON_START){// 开启定位}else  if (event == Lifecycle.Event.ON_STOP) {// 进行定位}
    }
}

//3. 注册观察者, 察看宿主生命周期状态变动
class MyActivity extends AppCompatActivity{public void onCreate(...){LocationObserver observer =new LocationObserver()
    // 应该在 Activity 的 onCreate（）办法中增加此行代码，以便通过应用  getLifecycle().addObserver() 将生命周期所有者 Activity 与 LocationObserver 关联。getLifecycle().addObserver(observer);
  }
 }

三、Lifecycle 如何感知生命周期的状态？

咱们晓得了 Lifecycle 是一个类，用于存储无关组件（如 Activity 或 Fragment）的生命周期状态的信息，并容许其余对象察看此状态。

咱们先温习一下 Activity&Fragment 的生命周期办法：

1、Activity 生命周期：

onCreate()、onStart()、onResume()、onPause()、onStop() 和 onDestroy()。当 Activity 进入新状态时，零碎会调用其中每个回调。

Activity A 启动 Activity B 时的操作产生程序：

1、Activity A 的 onPause() 办法执行。

2、Activity B 的 onCreate()、onStart() 和 onResume() 办法顺次执行（Activity B 当初具备用户焦点）。

3、而后，如果 Activity A 在屏幕上不再显示，其 onStop() 办法执行。

2、Fragment 生命周期

Fragment 和 Activity 还不同，它不属于四大组件领域，然而它必须依靠于 Activity，其生命周期间接受宿主 Activity 生命周期的影响，

当 Activity 暂停时，Activity 的所有 Fragment 也会暂停；当 Activity 被销毁时，所有 Fragment 也会被销毁。不过，当 Activity 正在运行（处于已复原生命周期状态）时，您能够独立操纵每个 Fragment，如增加或移除 Fragment。

当其 Activity 运行时，Fragment 的生命周期如下：

治理 Fragment 生命周期与治理 Activity 生命周期很类似。和 Activity 一样，片段也以三种状态存在：

已复原

Fragment 在运行中的 Activity 中可见。

已暂停

另一个 Activity 位于前台并具备焦点，但此片段所在的 Activity 依然可见（前台 Activity 局部通明，或未笼罩整个屏幕）。

已进行

片段不可见。宿主 Activity 已进行，或片段已从 Activity 中移除，但已增加到返回栈。已进行的片段仍处于活动状态（零碎会保留所有状态和成员信息）。不过，它对用户不再可见，并随 Activity 的终止而终止。

如下图：Activity 生命周期对应的 Fragment 的生命周期

Fragment 所在 Activity 的生命周期会间接影响 Fragment 段的生命周期，其体现为，Activity 的每次生命周期回调都会引发每个 Fragment 的相似回调。例如，当 Activity 收到 onPause() 时，Activity 中的每个 Fragment 也会收到 onPause()。

Fragment 还有几个额定的生命周期回调，用于解决与 Activity 的惟一交互，从而执行构建和销毁 Fragment 界面等操作。这些额定的回调办法是：

  • [x] onAttach()

在片段已与 Activity 关联时进行调用（Activity 传递到此办法内）。

  • [x] onCreateView()

调用它可创立与片段关联的视图层次结构。

  • [x] onActivityCreated()

当 Activity 的 onCreate() 办法已返回时进行调用。

  • [x] onDestroyView()

在移除与片段关联的视图层次结构时进行调用。

  • [x] onDetach()

在勾销片段与 Activity 的关联时进行调用。

3、Lifecycle 如何感知生命周期的状态？

Lifecycle 应用两种次要枚举跟踪其关联组件的生命周期状态：

事件

从框架和 Lifecycle 类分派的生命周期事件。这些事件映射到 Activity 和 Fragment 中的回调事件。

状态

由 Lifecycle 对象跟踪的组件的以后状态。

形成 Android Activity 生命周期的状态和事件如下：

宿主生命周期与宿主状态的对应关系别离为：onCreate-Created、onStart-Started、onResume-Resumed、onpause-Started、onStop-Created、onDestroy-Destroyed

当生命周期所有者的状态产生更改时，调配的生命周期对象将更新为新状态。在任何给定工夫，生命周期所有者将处于以下五种状态之一：

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

当组件通过不同状态转换时，生命周期对象将在已增加到列表中的任何观察器上触发事件。以下事件可用于在生命周期观察者中实现：

  • Lifecycle.Event.ON_CREATE
  • Lifecycle.Event.ON_START
  • Lifecycle.Event.ON_RESUME
  • Lifecycle.Event.ON_PAUSE
  • Lifecycle.Event.ON_STOP
  • Lifecycle.Event.ON_DESTROY
  • Lifecycle.Event.ON_ANY

增加 observer 时，残缺的生命周期事件散发

如下图，生命周期所有者的状态更改程序以及将在每个状态转换之间在观察者上触发的生命周期事件：

< END >

【Android 进化之路】

微信扫描二维码，关注我的公众号。

退出移动版