jetpack之LifeCycle

假如我们有某个Activity 需要用到定位相关的逻辑我们代码大家或许会这样写

internal class MyLocationListener(private val context: Context,private val callback: (Location) -> Unit
) {fun start() {// connect to system location service}fun stop() {// disconnect from system location service}
}class MyActivity : AppCompatActivity() {private lateinit var myLocationListener: MyLocationListeneroverride fun onCreate(...) {myLocationListener = MyLocationListener(this) { location ->// update UI}}public override fun onStart() {super.onStart()myLocationListener.start()// manage other components that need to respond// to the activity lifecycle}public override fun onStop() {super.onStop()myLocationListener.stop()// manage other components that need to respond// to the activity lifecycle}
}

在我们需要使用定位的activity 中，注册定位的监听，然后在onStart()方法中开启定位监听，在onStop()方法中关闭定位监听。相比一般人都会这么写。此时如果我们假如有许多Activity都可能使用到定位，好一点的，我们会将定位的逻辑抽取到BaseActivity中然后根据子类是否需要，按需去开启定位的功能。这样写的确是可以实现我们的功能，但是如果Android的多个model，或者Fragemnt中要使用这一功能，我们是不是在每个需要使用的地方重写这样一套逻辑呢，显然大部分人都不希望这么干。此时我们可以使用我们的LifeCycle.

什么是Lifecycle

Lifecycle是一套专门用来感知Activity或Fragment生命周期变化的组件，当Activity或Fragment的生命周期发生的变化的时候，将会通知到Lifecycle的订阅者。这样我们可以把原本需要写在Activity或Fragment的代码抽出来，减少Activity或者Fragment的代码侵入性，使Activity或Fragment更加精简并且易于维护，也可以减少内存泄漏

Lifecycle的使用

1.继承LifeCycleObserver

class CustomLifecycleObserver:LifecycleObserver {val TAG = CustomLifecycleObserver::class.java.simpleName@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)fun onCreateMethod(){Log.e(TAG,"onCreateMethod run")}@OnLifecycleEvent(Lifecycle.Event.ON_START)fun onStartMethod(){Log.e(TAG,"onStartMethod run")}@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)fun onResumeMethod(){Log.e(TAG,"onResumeMethod run")}@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)fun onPauseMethod(){Log.e(TAG,"onPauseMethod run")}@OnLifecycleEvent(Lifecycle.Event.ON_STOP)fun onStopMethod(){Log.e(TAG,"onStopMethod run")}@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)fun onDestoryMethod(){Log.e(TAG,"onDestoryMethod run")}
}

我们只需要继承LifeCycleObserver ，然后在我们的Activity中注册一个观察者就行了

class LifeCycleActivity : AppCompatActivity() {override fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState)setContentView(R.layout.activity_life_cycle)lifecycle.addObserver(CustomLifecycleObserver())}
}

这样我们就可以在自定义的CustomLifecycleObserver中去监听Activity的生命周期变化了。

在CustomLifecycleObserver中，我们可以看到方法上面都有@OnLifecycleEvent注解，注解的参数正好是对应了Activity的各种生命周期。

2. 利用LifecycleOwner来实现(具体原来后面分析源码可以得知)

class CustomLifeOwnerActivity: Activity(),LifecycleOwner {private lateinit var lifecycleRegistry: LifecycleRegistryoverride fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState)lifecycleRegistry = LifecycleRegistry(this)lifecycleRegistry.currentState = Lifecycle.State.CREATEDlifecycleRegistry.addObserver(CustomLifecycleObserver())}override fun onStart() {super.onStart()lifecycleRegistry.currentState = Lifecycle.State.STARTED}override fun onResume() {super.onResume()lifecycleRegistry.currentState = Lifecycle.State.RESUMED}override fun getLifecycle(): Lifecycle {return lifecycleRegistry;}
}

这种实现，我们继承自Activity 而不是AppcompactActivity ，因为AppcompactActivity 已经帮我们实现了这些生命周期的处理。一般我们使用LifeCycle也不使用这种方式，使用第一种就OK了

Lifecycle的源码分析

在下面的代码中

class LifeCycleActivity : AppCompatActivity() {override fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState)setContentView(R.layout.activity_life_cycle)lifecycle.addObserver(CustomLifecycleObserver())}
}

我只要使用lifecycle.addObserver(CustomLifecycleObserver()) 代码注册观察者之后CustomLifecycleObserver就可以监听当前Activity的所有生命周期了，我们跟踪源码看看其到底是怎么实现的。

addObserver ->Lifecycle.addObserver(抽象类的方法) -->LifecycleRegistry.addObserver(具体实现)

@Overridepublic void addObserver(@NonNull LifecycleObserver observer) {enforceMainThreadIfNeeded("addObserver");State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);..... //后面省略的代码 可以到之后的LiveData中讲解 具体的意义}

这里其实就是将自己创建的CustomLifecycleObserver加入到mObserverMap中缓存起来，供后面的生命周期回调。

Activity的生命周期回调，怎么使我们的自定义Observer回调呢，这里其实有使用到跟Glide相同方法，就是构建一个Fragment，然后在Fragment中去回调生命周期，这样的确有点巧妙，我们看具体的代码

// ComponentActivity
protected void onCreate(@Nullable Bundle savedInstanceState) {super.onCreate(savedInstanceState);ReportFragment.injectIfNeededIn(this);}// ReportActivity
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 activitiesandroid.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();}}

使用这些代码之后就注入了一个不可见的ReportFragment，来感知Activity的生命周期，看ReportFragment的onResume方法

//ReprotFragment
@Overridepublic void onResume() {super.onResume();dispatchResume(mProcessListener);dispatch(Lifecycle.Event.ON_RESUME);}private void dispatch(Lifecycle.Event event) {Activity activity = getActivity();if (activity instanceof LifecycleRegistryOwner) {((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);return;}if (activity instanceof LifecycleOwner) {Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();if (lifecycle instanceof LifecycleRegistry) {((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);}}}

如果是Activity的话，最后走到了LifecycleRegistry 的handleLifecycleEvent(event)方法

public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {// 检查是否在主线程中执行enforceMainThreadIfNeeded("handleLifecycleEvent");moveToState(event.getTargetState());}private void moveToState(State next) {if (mState == next) {return;}mState = next;if (mHandlingEvent || mAddingObserverCounter != 0) {mNewEventOccurred = true;// we will figure out what to do on upper level.return;}mHandlingEvent = true;sync();mHandlingEvent = false;}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;// 检测如果你住处Observer的时候activity 状态 与存储的Observer状态对比// Activity 为onResume Observer可能需要执行从onCreate->onResumeif (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {backwardPass(lifecycleOwner);}Map.Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();if (!mNewEventOccurred && newest != null&& mState.compareTo(newest.getValue().mState) > 0) {forwardPass(lifecycleOwner);}}mNewEventOccurred = false;}

最终的逻辑会进入sync方法中，走两个分支的方法，backwardPass或者forwardPass方法，无非就是向前或者向后执行生命周期的相关方法。我们这里看forwardPass方法的距离逻辑

private void forwardPass(LifecycleOwner lifecycleOwner) {Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =mObserverMap.iteratorWithAdditions();while (ascendingIterator.hasNext() && !mNewEventOccurred) {Map.Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();ObserverWithState observer = entry.getValue();while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred&& mObserverMap.contains(entry.getKey()))) {pushParentState(observer.mState);final Event event = Event.upFrom(observer.mState);if (event == null) {throw new IllegalStateException("no event up from " + observer.mState);}observer.dispatchEvent(lifecycleOwner, event);popParentState();}}}

最后都会走到 observer.dispatchEvent(lifecycleOwner, event); 其中的observer 是 ObserverWithState。这个类我们在最开始的时候 lifecycle.addObserver方法中看到

@Overridepublic void addObserver(@NonNull LifecycleObserver observer) {enforceMainThreadIfNeeded("addObserver");State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);.....}

最终会走到ObserverWithState方法中的dispatchEvent方法中

static class ObserverWithState {State mState;LifecycleEventObserver mLifecycleObserver;ObserverWithState(LifecycleObserver observer, State initialState) {mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);mState = initialState;}void dispatchEvent(LifecycleOwner owner, Event event) {State newState = event.getTargetState();mState = min(mState, newState);mLifecycleObserver.onStateChanged(owner, event);mState = newState;}}

调用LifecycleEventObserver 的onStateChanged方法。看构造函数中的LifecycleEventObserver是怎么生成的

@NonNullstatic LifecycleEventObserver lifecycleEventObserver(Object object) {boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;if (isLifecycleEventObserver && isFullLifecycleObserver) {return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,(LifecycleEventObserver) object);}if (isFullLifecycleObserver) {return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);}if (isLifecycleEventObserver) {return (LifecycleEventObserver) object;}final Class<?> klass = object.getClass();// 根据我们传入的对象，获得tyep类型，带有@OnLifecycleEvent注解的类型 就返回// REFLECTIVE_CALLBACK 并且根据注解int type = getObserverConstructorType(klass);if (type == GENERATED_CALLBACK) {List<Constructor<? extends GeneratedAdapter>> constructors =sClassToAdapters.get(klass);if (constructors.size() == 1) {GeneratedAdapter generatedAdapter = createGeneratedAdapter(constructors.get(0), object);return new SingleGeneratedAdapterObserver(generatedAdapter);}GeneratedAdapter[] adapters = new GeneratedAdapter[constructors.size()];for (int i = 0; i < constructors.size(); i++) {adapters[i] = createGeneratedAdapter(constructors.get(i), object);}return new CompositeGeneratedAdaptersObserver(adapters);}return new ReflectiveGenericLifecycleObserver(object);}//Lifecycling.java   resolveObserverCallbackType 方法
boolean hasLifecycleMethods = ClassesInfoCache.sInstance.hasLifecycleMethods(klass);//ClassesInfoCacheboolean hasLifecycleMethods(Class<?> klass) {Boolean hasLifecycleMethods = mHasLifecycleMethods.get(klass);if (hasLifecycleMethods != null) {return hasLifecycleMethods;}Method[] methods = getDeclaredMethods(klass);for (Method method : methods) {OnLifecycleEvent annotation = method.getAnnotation(OnLifecycleEvent.class);if (annotation != null) {// Optimization for reflection, we know that this method is called// when there is no generated adapter. But there are methods with @OnLifecycleEvent// so we know that will use ReflectiveGenericLifecycleObserver,// so we createInfo in advance.// CreateInfo always initialize mHasLifecycleMethods for a class, so we don't do it// here.createInfo(klass, methods);return true;}}mHasLifecycleMethods.put(klass, false);return false;}

这里会将有OnLifecycleEvent 注解的方法通过反射拿出来，最后缓存起来。

然后回到Lifecycleing的方法因为type返回的是 REFLECTIVE_CALLBACK 所以最终会返回 ReflectiveGenericLifecycleObserver的对象，然后调用其onStateChanged方法，

class ReflectiveGenericLifecycleObserver implements LifecycleEventObserver {private final Object mWrapped;private final CallbackInfo mInfo;ReflectiveGenericLifecycleObserver(Object wrapped) {mWrapped = wrapped;mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());}@Overridepublic void onStateChanged(@NonNull LifecycleOwner source, @NonNull Event event) {mInfo.invokeCallbacks(source, event, mWrapped);}
}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);}private static void invokeMethodsForEvent(List<MethodReference> handlers,LifecycleOwner source, Lifecycle.Event event, Object mWrapped) {if (handlers != null) {for (int i = handlers.size() - 1; i >= 0; i--) {handlers.get(i).invokeCallback(source, event, mWrapped);}}}

最终回去从这里执行到刚刚通过反射缓存的生命周期的方法，这样就从ReportFragment 中生命周期回调到我们自定义的Observer中的回调方法了。