androidlifecycle的简单介绍

本篇文章给大家谈谈androidlifecycle，以及对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

• 1、Android-Lifecycle原理解析
• 2、Android Lifecycle源码解析
• 3、androidx.lifecycle 生命周期感知型组件实现原理
• 4、Android生命周期绑定

Android-Lifecycle原理解析

Event触发的时机：

而在androidx.activity.ComponentActivity和androidx.core.app.ComponentActivity中，该方法的实现，其实都是一样的。

但是这两个Activity，其实都有自己的mLifecycleRegistry对象。

LifecycleRegistry对象其实可以理解为观察者模式中的Observable，也就是被观察者，而LifecycleRegistry对象的创建，其实是传入一个LifecycleOwner实现类对象，而androidx.activity.ComponentActivity和androidx.core.app.ComponentActivity实现了LifecycleOwner接口，所以传入的是this。

LifecycleRegistry中聚合了多个LifecycleObserver，生命周期改变时，通知LifecycleObserver进行相应方法的调用。

在LifecycleRegistry类中的addObserver方法中，其实就是通过封装LifecycleObserver生成了一个ObserverWithState对象，然后放入FastSafeIterableMap中，而FastSafeIterableMap其实就是一个自定义列表，用于保存观察者并且可在遍历期间处理删除核拆/添加。

其实在自定义的某个类去实现LifecycleObserver接口的时候，在activity中，是需要通过getLifecycle().addObserver()进行注册的，这个过程其实就是调用了LifecycleRegistry的addObserver()方法。

ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);会将LifecycleObserver对象封装在ReflectiveGenericLifecycleObserver对象中。但是这里的需要判断是实现了哪个接口，比如androidx.activity.ComponentActivity中的构造函数中，因为是直接new LifecycleEventObserver匿名内部类实现接口对象，则isLifecycleEventObserver为true，就不态坦会new ReflectiveGenericLifecycleObserver()，而在自定义一个类的时候，一般实现LifecycleObserver接口，则就会new ReflectiveGenericLifecycleObserver()

androidx.activity.ComponentActivity的构造函数：这里是new LifecycleEventObserver

自定义的BasePresenter：这里是实现LifecycleObserver接口

所以上面的两种不同的实现，BasePresenter实现的是LifecycleObserver，帆氏桐所以这个LifecycleObserver的最终实现是ReflectiveGenericLifecycleObserver。而ComponentActivity因为是new LifecycleEventObserver，所以这个匿名内部类对象就是最终实现。

在androidx.core.app.ComponentActivity的onCreate方法中，会调用

这里使用ReportFragment，如果是api29以及以上的，则可以直接注册回调来获取Activity的生命周期回调。如果是api29以下的，则需要手动给Activity添加一个空白的Fragment，类似于Glide监听生命周期回调的做法。

LifecycleCallbacks的定义如上，是在ReportFragment中定义的，其实就是使用了Application.ActivityLifecycleCallbacks来实现了。

其实就是在androidx.core.app.ComponentActivity中添加一个ReportFragment，而ReportFragment的生命周期方法，其实都调用了一个dispatch方法。

所以在ReportFragment的生命周期方法，其实就会通过调用对应的dispatch方法进而调用到了Activity的getLifecycle()方法获取到一个LifecycleRegistry对象，然后调用LifecycleRegistry的handleLifecycleEvent()方法。

这里需要事先获取到Activity的下一个生命周期状态，而这个状态过程其实与Fragment的类似，都是先升序，然后再降序的一个过程。即ON_CREATE是CREATED，ON_RESUME是RESUMED，然后ON_PAUSE是变成STARTED

而上面调用的sync()方法，其实其内部会调用两个方法backwardPass()和forwardPass()，一个是逆推，一个是顺推，其实就是可以认为一个是正序，一个是倒序。

比如forwardPass()，其实其内部就是遍历刚才缓存Observer的集合，找到每个Observer

而这里的dispatchEvent，其实就是ObserverWithState的方法，因为ObserverWithState内部封装了LifecycleEventObserver对象，而LifecycleEventObserver对象又是封装了LifecycleObserver对象的。

比如Activity的，其实onStateChanged是在androidx.activity.ComponentActivity的构造器中添加注册的LifecycleEventObserver监听接收对应的处理回调，在这里就会根据是ON_STOP还是ON_DESTROY进行回调的处理，也就是生命周期的处理。

这样的生命周期回调，在自定义类实现LifecycleObserver接口的时候，也可以采用注解的方式注册对应的LifecycleEventObserver监听，这样的生命周期的回调，其实就是回调到对应的注解和事件的方法中。这样是采用了类似于apt注解处理器的方式，生成了对应的java类

这里需要注意，如果是自定义添加监听的时候，是实现了LifecycleEventObserver，那么在分发的时候，调用ObserverWithState的dispatchEvent方法去分发，就会直接回调到了自定义LifecycleEventObserver实现类中的onStateChanged中；而如果是使用LiveData添加观察者的话，则是封装成LifecycleBoundObserver对象，然后通过其onStateChanged方法继续进一步的处理分发，调用到对应的Observer的onChanged方法进行最终的处理

如果这里的分发是分发到上面的那个自定义的BasePresenter，则需要经过ReflectiveGenericLifecycleObserver

从上面的原理解析，可以知道，Lifecycle的生命周期的感知和分发，其实也是依赖于一个ReportFragment，这其实也是一个空的Fragment，这样的做法，其实与Glide的生命周期的监听是类似的做法，都是采用一个空的Fragment来监听生命周期的变化，然后在不同的生命周期做不同的操作。

[img]

Android Lifecycle源码解析

 Lifecycle是生命周期的意思。它是Jetpack中的一个 生命周期感知型组件 ，可执行操作来感知响应另一个组件（如 Activity 和 Fragment）的生命周期状态的变化。

 1.第一步添加依赖

 2.实现LifecycleObserver接口以及添加注解

 3.在Activity中或者Fragment中调用lifecycle.addObserver方法,把LifecycleObserver传入进去就可以

使用是不是很简单,在MytViewModelLifecycle里面就可以监听到Activity中或者Fragment生命周期了

 1.首先分析lifecycle怎么来的

  lifecycle调用的是ComponentActivity的getLifecycle方法,返回了一个mLifecycleRegistry

那么我们就从ComponentActivity入手会实现了它LifecycleOwner接口,并且初始化了LifecycleRegistry

  2.addObserver分析

  上面了解了lifecycle的实例,那么我们就从LifecycleRegistry入手,首先看addObserver方法,我们只管传入的参数哪里去了,也就是说我们只需要看ObserverWithState做了什么事.

  ObserverWithState会调用Lifecycling.lifecycleEventObserver方法,然后绝洞创建ReflectiveGenericLifecycleObserver对象,然后调用ClassesInfoCache.sInstance.getInfo,这个方法传入的是我们的MytViewModelLifecycle的对象,拿到他的class,然后通过反射拿到MytViewModelLifecycle方法和注解并且存入map.具体怎么反射这里就不细讲了! (在反射中一般都是通过map去存昌宏腊取提高性能)

 3.观察者(MytViewModelLifecycle)是如何知道被观察者(Activity)的生命周期的

   回到ComponentActivity中的onCreate方法,它会创建一个空白的ReportFragment,有了这个ReportFragment,当activity执行生命周期ReportFragment也会执行相应的生命周期. 我们以onStart为例,每个生命周期都会调用dispatch方法,最终都会调用**dispatch( Activity activity, Lifecycle.Event event)方法. 然后调用((LifecycleRegistry) lifecycle).handleLifecycleEvent(event)方法

  在handleLifecycleEvent分别会调用getStateAfter和moveToState方法这两个方法,getStateAfter的目的就是通过生命周期得到一个状态.方便大家理解大家可以看白色背景的那张图.通过不同的事件拿到相应的状态

 1.初始化状态-页面显示状态,这种情况属于activity的创建到显示 这属于前进状态

 2.页面显示状态-销毁状态:这种情况下属于activity回到不可见了 这属于倒退状态

  耐滑moveToState(next):这个方法的意思就是状态对齐.举个栗子吧:假如activity(被观察者)现在是onstart状态,这时候观察者MytViewModelLifecycle还是CREATE状态,这时候为了保证生命周期对齐,所以需要将next赋值给State,接着调用sync()进行同步

   backwardPass方法 如果满足条件的主要调用downEvent 这个方法主要通过状态拿到事件,例如现在是STARTED对应上面的图拿到ON_STOP事件,然后又通过getStateAfter(ON_STOP)方法去拿到CREATED状态,

   LifecycleEventObserver是一个接口 然后ReflectiveGenericLifecycleObserver实现了这个接口,所以最终调用了ReflectiveGenericLifecycleObserver的onStateChanged方法

   invokeCallbacks方法里面通过反射拿到执行相应方法,这里就不多阐述了!

   再回到sync()里面的forwardPass方法 如果满足条件的主要调用upEvent(observer.mState)拿到前进状态,例如现在是STARTED状态就可以到ON_RESUME事件通过ON_RESUME事件最终通过反射调用@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)的方法

总结一下:

1.ComponentActivity里面实现了LifecycleOwner接口 ,并且初始化LifecycleRegistry了,LifecycleRegistry是实现了LifecycleOwner接口

2.在ComponentActivity里面创建了一个透明的ReportFragment来感应activity的生命周期,在Fragment的生命周期方法里面分别执行对应的dispatch方法

2.addObserver方法创建了ReflectiveGenericLifecycleObserver并且存储了观察者的class信息,

3.在dispatch传入相应的事件之后,然后通过getStateAfter拿到相应的状态

4.通过状态枚举比大小,如果是倒退流程就调用backwardPass方法,backwardPass方法会通过downEvent拿到状态拿到事件,然后又通过事件拿到状态

5.,如果是前进流程就调用forwardPass方法,forwardPass方法会通过upEvent拿到状态拿到事件

6.最后在ReflectiveGenericLifecycleObserver.onStateChanged里面执行mInfo.invokeCallbacks执行相应的方法

7.之所以要设计状态 是要留给其他框架用的

androidx.lifecycle 生命周期感知型组件实现原理

androidx.lifecycle 组件用来感知另一个组件如 Activity 和 Fragment 的生命周期变化，方便在生命周期变更时处理一些事情。

其逻辑简单来说就是：使用者向 LifecycleRegistry 注册一个 LifecycleObserver ，当 LifecycleOwner（一般由 Activity 和 Fragment 实现）发生生命周期变更时，将其变更的 STATE 通知给 LifecycleRegistry ，然后 LifecycleRegistry 将其变更的 EVENT 告知 LifecycleEventObserver ，LifecycleEventObserver 通过 Lifecycling 转换成用户注册的 LifecycleObserver 类型并回调。

可以看到这里面最有趣的就是 LifecycleObserver 的实现方式，这是本篇重点描述的内容。

整个 lifecylce 组件最有趣的实现应该就是这个 LifecycleObserver ，它是一个空接口。所有实现它的类最后会通过 Lifecycling 转换成它的一个已知实现类 LifecycleEventObserver 。

这个框架实现的核心。它定义了一个回调函数 onStateChanged(owner, event) 。

我们先回到 Lifecycle 及其实现类 LifecycleRegistry 。

Lifecycle 定义了 Lifecycle 的 STATE 和 EVENT 。

状态和 EVENT 和 Activity 及 Fragment 对应。初始状态为 INITIALIZED 和 DESTROYED ，定厅橡义从初始状态到 CREATED 再到 STARTED 再到 RESUMED 为状态上升，相反为状态下降。

Lifecycle 存储了 Activity 、Fragment 的生命周期状态，并方便其它对象跟踪。LifecycleRegistry 是其实现类，它允许多个对象同时跟踪生命周期状态（通过 LifecycleObserver）。

上面说到可以向 LifecycleRegistry 注册任意实现的 LifecycleObserver ，然后 LifecycleRegistry 会通过 Lifecycling 转换成 LifecycleEventObserver 去监听，说到变更时再转换回自定义 LifecycleObserver 中的回调方法。那孙渗么是怎么实现的呢？

这个框架中定义了两个实现方式，一种通过自定义的 adater ，另外一种为反射。

通过 adapter 的方法其实原理很简单，就是自定义 LifecycleObserver 时同时自定义一个 adapter ，这个 adapter 需要自己实现将 LifecycleEventObserver 中回调的状态转换成 observer 中回调的方法。

这个 adapter 需要在 LifecycleObserver 同级的 pkg 下面且名为 LifecycleAdapter ，其父类或其本身继承自 GeneratedAdapter ，并有构造函数 LifecycleAdapter(LifecyelObserver)。

Lifecycling 在转换时将为这种类型的 observer 创建一个 SingleGeneratedAdapterObserver 或 CompositeGeneratedAdaptersObserver ，并传入自定义的 GeneratedAdapter 实现类。因为这个 XXXGeneratedAdapterObserver 实现了 LifecycleEventObserver ，所以在其收到 onStateChange 回调时只需调用 GeneratedAdapter #callMethods ，剩下交给 adapter 自己去实现状则伏脊态与回调的转换。

如果不想自定义 GeneratedAdapter 的实现类可以吗，可以。这个框架还实现了反射回调机制。只要你在自定义 LifecycleObserver 时给回调函数加上 @OnLifecycleEvent(Lifecycle.Event xxx) 的注释，Lifecycling 会帮你创建一个 ReflectiveGenericLifecycleObserver 并传入 observer 对象，这个 ReflectiveGenericLifecycleObserver 实现 LifecycleEventObserver ，并通过反射机制取出并缓存所有按规则加上了 @OnLifecycleEvent 注释的方法，在收到 onStateChange 时取出对应 event 的反射方法，并回调。

可以看到其核心实现在 CallbackInfo ，其缓存了 observer 对象中的 [event, 反射方法 list] map ，在收到 lifecycle 变更时，取出对应 event 的所有反射方法 list 并回调就行。

Lifecycling 可以说是整个实现的精髓了，它在 LifecycleObserver 注册时将其转换成 LifecycleEventObserver 的 adapter 或 reflect 实现类。

一般来说，我们使用 LifecycleEventObserver 就行，虽然这个框架通过复杂的实现可以让你随意（其实还是有条件）的定义自己要的 LifecycleObserver ，但似乎也不是很有实际用途？

android developers：使用生命周期感知型组件处理生命周期

Android生命周期绑定

最近封装了几个View，都和生命周期有关，比如BannerView、和我们公司的ARView，那他们的生命周期怎么绑定呢？刚开始我是直接告诉别人，你自己在哪个activity使用的，就在哪个activity绑定，结果使用的时候被甲方对接物信碰人员打回来说这是低级处理方式，wtm这暴脾气，谁tm低级了，但是没办法别人是甲方只能听他的，直接将生命周期的绑定绑在view里面。下面就介绍几个常用的生命周期绑定。

Application.ActivityLifecycleCallbacks是Android自带的生命周期绑定接口，他有注册与解除方法，当我们进入一个activity的时候就可以注册绑定他了。

简单demo。比如我们要讲一个自定义的View绑定生命周期。

1、先定义一个Application.ActivityLifecycleCallbacks的实现类，为什么这样呢？是因为用户可以要什么选什么，就不用被迫每次都实现全部。

2、定义一个测试用的view，在构造方法绑定注册生命周期，

((Activity)context).getApplication().registerActivityLifecycleCallbacks(lifecycleCallbacks);这句话是注册生命周期当然他也对应了一个((Activity)context).getApplication().unregisterActivityLifecycleCallbacks(lifecycleCallbacks);解绑方法。

在ActivityLifecycleCallbacks 的实现中判断了返回的activity是否为这个view所在的acrivity因为很多activity都会走这个方法，如果不做判断，其他activity的生命周期也会影响这个view，所以加判断是个好习惯。

这次我们模拟一个普坦袭通类绑定生命周期这个类名叫Test，哈哈，是不是很高大上？但是写Test类之前先定义我们要绑定的生命周期接口LifecycleListener

这里我们监听下常用的onResume、onPause、onDestroy。

然后是Test类

然后写LifecycleDetector，尝试将test类的实例与fragment绑定

定义没有布局的fragment实例

然后保存fragment和Requestmanager关系

还有一个遗漏的接口

上面这些完成后，就可以使用了，我们随便搞个activity试试名字就叫LeftDemoActivity非常好听了有没有！

当你运行起来的时候，就是成功的时候。

有个东西忘啦，getSnapshot是做保存的，直接把源码拿过来的。

还有其他的方法我没试过，但是这样的生命周期绑定可以解决挺多bug的，玩过哔哩哔哩的应该会遇到他们的一个bug，就是进入一个视频播放页，然后还没加载完成就息屏，他这个时候异步回调回来视频数据了就会在息屏或锁屏界面播出音频来，这是典型的生命周期bug，我遇到过几罩谈次了，如果加入这个绑定轻松就能解决问题啦。

关于androidlifecycle和的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。