目录结构
1.Lifecycle简介
2.使用场景
3.使用方式
4.源码解析
5.其他事项
1.Lifecycle简介
简介，当然是官方的最权威：https://developer.android.com/jetpack/androidx/releases/lifecycle?hl=zh-cn
我的理解： 从命名可以看出，这个组件就是通过对生命周期监控。Lifecycle可以有效的避免内存泄漏和解决android生命周期的常见难题。类似ActivityLifecycle ，常见的就是我们的Activity、 Fragment 都能满足（默认androidX support需要倒入对应依赖）实现原理借鉴了Glide 的生命周期监控实现方式。
LifeCycle 基于观察者模式实现
1.被观察者
2.观察者
3.建立监听关系
Actiivty 默认是继承AppcompatActivty，又继承componentActivity 而这个componentActivity又实现了LifeCycleOwner.
public class ComponentActivity extends androidx.core.app.ComponentActivity implements
LifecycleOwner,
ViewModelStoreOwner,
SavedStateRegistryOwner,
OnBackPressedDispatcherOwner {
2.使用场景
我们在使用MVP模式时，经常要在Actvity的ondestroy 方法中调用presenter的销毁方法，这样容易遗忘，切书写麻烦，当然可以通过在IbasePresenter中及在BaseActivity中释放，但是还有更好的方式：lifecycle
1.解耦 Activity、 Fragment
在我们常规MVC MVP中可能会在Activity的onCreate生命周期通过通过调用presenter层的方法请求数据，在onDestroy生命周期中再去释放presenter,这样代码业务膨胀后，耦合就比较严重。借助Lifecycle 可以实现解耦。这样就可以把生命周期转移到观察者，一般就是处理逻辑的presenter中。
2.使用 LifecycleService 解耦 Service 与组件
implementation "androidx.lifecycle:lifecycle-service:2.2.0"
引入上面的依赖，创建实现 LifecycleObserver 接口。使用 @OnLifecycleEvent 标记希望在 Server 生命周期发生变化时得到同步调用的方法，然后创建服务继承 LifecycleService 就可以正常使用，和普通服务没区别。
3.使用方式
1.确定观察者
实现 LifecycleObserver ，然后通过注解定义自己关心的生命周期方法。注意Lifecycle.Event.ON_ANY 注解标记的会在每个生命周期执行回调
class LifeCyclePresent : LifecycleObserver {
companion object {
val TAG = LifeCyclePresent::class.java.simpleName
}
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
public fun onCreate() {
Log.e(SecondActivity.TAG, " :onCreate 调用了")
}
@OnLifecycleEvent(Lifecycle.Event.ON_ANY)
public fun onAny() {
Log.e(SecondActivity.TAG, ":onAny 调用了")
}
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
public fun onDestroy() {
Log.e(SecondActivity.TAG, ":onDestroy 调用了")
}
}
2.确定被观察者
如果是Activity、Fragment可以直接使用， 如果是别的，需要实现LifecycleOwner
3.建立观察链路
kt写法如下：如果是java 还需要用getLifeCycleI() ，被观察者.addObserver(观察者)
getLifecycle().addObserver(presenter);
lifecycle.addObserver(LifeCyclePresent())
小结
Livecycle 是一个表示android生命周期及状态的对象
LivecycleOwner 用于连接有生命周期的对象，如activity,fragment
LivecycleObserver 用于观察查LifecycleOwner
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_second)
val lifeCyclePresent = LifeCyclePresent()
lifecycle.addObserver(LifeCyclePresent())
4.源码解析
源码分析，对于这种生命周期的还是比较好找入口，直接看addObserver(传入的就是观察者)
思考
1.从用法上看，被观察者的生命周期回调，通过注解实现，可以猜到，要么是在编译期生成代码了，要么就是运行期使用反射获取注解来判断了，我们可点击看一下OnLifecycleEvent注解定义的类 ，保留类型是运行时。大致可以推断，当然不排除有些比较流氓的框架,只是在Class阶段操作，非要设置为runtime。
- 生命周期怎么发通知
大致也能猜到在ComponentActivity中处理的
源码分析：
1.LifecycleRegister 类中的addObserver方法
这里你会发现生成了一个ObserverWithState，然后放入FastSafeIterableMap里，这个类是一个自定义列表，用于保存观察者并可在遍历期间处理删除/添加。
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
2.再看ComponentActivity中的onCretae方法
通过下面的方法调用，看下注入这个方法，有没有很熟悉，就是抄袭Glide 添加fragment 的方法。
ReportFragment.injectIfNeededIn(this);
public static void injectIfNeededIn(Activity activity) {
// ProcessLifecycleOwner should always correctly work and some activities may not extend
// FragmentActivity from support lib, so we use framework fragments for activities
android.app.FragmentManager manager = activity.getFragmentManager();
if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
// Hopefully, we are the first to make a transaction.
manager.executePendingTransactions();
}
}
3.直接看进去ReportFragment
生命周期函数都调用了dispatch()方法，并且传入了枚举类的类型。有7个类型，和生命周期对应的 3对+any，
@Override
public void onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
dispatchCreate(mProcessListener);
dispatch(Lifecycle.Event.ON_CREATE);
}
@Override
public void onStart() {
super.onStart();
dispatchStart(mProcessListener);
dispatch(Lifecycle.Event.ON_START);
}
@Override
public void onResume() {
super.onResume();
dispatchResume(mProcessListener);
dispatch(Lifecycle.Event.ON_RESUME);
}
@Override
public void onPause() {
super.onPause();
dispatch(Lifecycle.Event.ON_PAUSE);
}
@Override
public void onStop() {
super.onStop();
dispatch(Lifecycle.Event.ON_STOP);
}
4.dispatch()会获取Lifecycle再调用handleLifecycleEvent
dispatch()方法则会判断Activity是否实现了LifecycleOwner接口，如果实现了该接口就调用LifecycleRegister的handleLifecycleEvent()，这样生命周期的状态就会借由LifecycleRegistry通知给各个LifecycleObserver从而调用其中对应Lifecycle.Event的方法。
5.状态处理
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
State next = getStateAfter(event);
moveToState(next);
}
5.根据Event返回state状态
可以看到下面Event有7种，但是状态只有四种，这么设计我猜应该是为了使用最小的代价更好的维护状态。分别是创建、开始、获得焦点、销毁
switch (event) {
case ON_CREATE:
case ON_STOP:
return CREATED;
case ON_START:
case ON_PAUSE:
return STARTED;
case ON_RESUME:
return RESUMED;
case ON_DESTROY:
return DESTROYED;
case ON_ANY:
break;
}
6.根据状态，同步状态
上面提到只有四种状态要表示6个事件，还需要借助前一个事件类型判断，
private void sync() {
LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
if (lifecycleOwner == null) {
throw new IllegalStateException("LifecycleOwner of this LifecycleRegistry is already"
+ "garbage collected. It is too late to change lifecycle state.");
}
while (!isSynced()) {
mNewEventOccurred = false;
// no need to check eldest for nullability, because isSynced does it for us.
if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
backwardPass(lifecycleOwner);
}
Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
if (!mNewEventOccurred && newest != null
&& mState.compareTo(newest.getValue().mState) > 0) {
forwardPass(lifecycleOwner);
}
}
mNewEventOccurred = false;
}
代码看起来还是比较不好理解，看下执行逻辑：
image.png
7.forwardPass(lifecycleOwner)方法
调用observer.dispatchEvent 方法去通知
ObserverWithState observer = entry.getValue();
找到ObserverWithState 类调用代码生成观察者适配器
mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
8.通知实现
调用onStateChanged(),来通知 实现了 LifecycleObserver的类，生命周期发生了变化
10.查看实现类
ReflectiveGenericLifecycleObserver。onStateChanged()
ReflectiveGenericLifecycleObserver。的构造方法中就把presenter中的方法和注解保存了下来
再通过onStateChanged()进行生命周期的方法的调用
@SuppressWarnings("ConstantConditions")
void invokeCallbacks(LifecycleOwner source, Lifecycle.Event event, Object target) {
invokeMethodsForEvent(mEventToHandlers.get(event), source, event, target);
invokeMethodsForEvent(mEventToHandlers.get(Lifecycle.Event.ON_ANY), source, event,
target);
}
小结
1.首先是调用addObserver( 观察者) 里面会通过反射 先从缓存中Map查找key是观察者的class,value是CallbackInfo,没查找到， 把事件和方法存在一个handlers的map种。
2.ComponentActivity 的oncreate中，会创建一个ReportFragment, Fragment能监控到Activity生命周期变化，而在生命周期中，调用dispatch一个具体的Event. 里面会获取到当前的State状态，因为他使用了4种状态来表示多个生命周期，里面进行了判断，确认具体生命周期方法
3.调用dispatchEvent 。里面继续 LifecycleObserver.onStateChanged(owner, event);再通过CallBackInfo.invokeCallbacks 反射调用具体注解的观察者方法
5.其他事项
1. 我们添加观察者，调用addObserver方法，API同时还提供了removeObserver 方法，是否需要调用
A： 不需要，github上开发工程师答复 ，从注解也可以看出 不希望开发者调用。可能引起不必要的异常 https://github.com/googlecodelabs/android-lifecycles/issues/5
image.png
2.为了防止重复添加
使用mActivie在onResume和在onstart两种状态下为true,来标识。
网友评论