Jetpack Lifecycle源码分析
文章目录
简介
官方对于Lifecycle的介绍是：
生命周期感知型组件可执行操作来响应另一个组件（如 Activity 和 Fragment）的生命周期状态的变化。这些组件有助于您写出更有条理且往往更精简的代码，这样的代码更易于维护。
通过官方介绍我们就可以知道Lifecycle这个jetpack组件是为了帮助我们能够方便的对Activity、Fragment的生命周期进行监听处理，比如我们可以把释放资源等一些操作从Activity、Fragment抽离出来放到对应的LifecycleObserver中对其进行处理，达到高内聚、低耦合，让每个部分的职责分明，使代码逻辑更清晰。
在有lifecycle之前我们常见的对Activity、Fragment的生命周期进行监听的实现是创建一个监听类，然后在每个生命周期对这个类的对象某个方法进行调用。但是，这种模式会导致代码条理性很差而且会扩散错误。通过使用lifecycle组件，我们可以将依赖组件的代码从生命周期方法移入组件本身中。
Lifecycle
Lifecycle是一个类，用于存储有关组件（如 Activity 或 Fragment）的生命周期状态的信息，并允许其他对象观察此状态。
Lifecycle中包含两个枚举类：
- Event（事件）
- ON_CREATE
- ON_START
- ON_RESUME
- ON_PASUE
- ON_STOP
- ON_DESTROY
- ON_ANY
- State（状态）
- DESTROYED
- INITIALIZED
- CREATED
- STARTED
- RESUMED
事件
从框架和 Lifecycle类分派的生命周期事件。这些事件映射到 Activity 和 Fragment 中的回调事件。
状态
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BXcmMflO-1629701996554)(https://skbiji.oss-cn-qingdao.aliyuncs.com/picgo/20210529182912.svg)]
上面是官方提供的状态与事件转换关系图，在之后的分析中我们会用到此图去分析关系转换。
简单的使用
声明依赖项
如果需要使用Lifecycle组件，我们需要添加lifecycle的依赖项，官方提供多个可选的依赖项，其中以前提供的lifecycle-extensions现已被弃用，我们可以通过个人需求进行选择。
dependencies {
def lifecycle_version = "2.3.1"
def arch_version = "2.1.0"
// ViewModel
implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version"
// LiveData
implementation "androidx.lifecycle:lifecycle-livedata-ktx:$lifecycle_version"
// Lifecycles only (without ViewModel or LiveData)
implementation "androidx.lifecycle:lifecycle-runtime-ktx:$lifecycle_version"
// Saved state module for ViewModel
implementation "androidx.lifecycle:lifecycle-viewmodel-savedstate:$lifecycle_version"
// Jetpack Compose Integration for ViewModel
implementation "androidx.lifecycle:lifecycle-viewmodel-compose:1.0.0-alpha04"
// Annotation processor
kapt "androidx.lifecycle:lifecycle-compiler:$lifecycle_version"
// alternately - if using Java8, use the following instead of lifecycle-compiler
implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"
// optional - helpers for implementing LifecycleOwner in a Service
implementation "androidx.lifecycle:lifecycle-service:$lifecycle_version"
// optional - ProcessLifecycleOwner provides a lifecycle for the whole application process
implementation "androidx.lifecycle:lifecycle-process:$lifecycle_version"
// optional - ReactiveStreams support for LiveData
implementation "androidx.lifecycle:lifecycle-reactivestreams-ktx:$lifecycle_version"
// optional - Test helpers for LiveData
testImplementation "androidx.arch.core:core-testing:$arch_version"
}
如果不添加依赖项我们也可以使用androidx.core:core-ktx等依赖项所依赖的依赖，不过为了更全面的用到lifecycle组件所提供的功能还是添加自己所需要的lifecycle的依赖项为好。
下面所有解析都依附以下面的依赖项即版本。
implementation 'androidx.lifecycle:lifecycle-runtime-ktx:2.3.1'
kapt 'androidx.lifecycle:lifecycle-compiler:2.3.1'
Coding
第一种实现方式
创建观察者类MLifecycleObserver并实现LifecycleObserver接口
class MLifecycleObserver : LifecycleObserver {
companion object {
private const val TAG = "MLifecycleObserver"
}
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
fun onCreate() {
Log.d(TAG, "onCreate: ")
}
@OnLifecycleEvent(Lifecycle.Event.ON_START)
fun onStart() {
Log.d(TAG, "onStart: ")
}
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
fun onResume() {
Log.d(TAG, "onResume: ")
}
@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
fun onPause() {
Log.d(TAG, "onPause: ")
}
@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
fun onStop() {
Log.d(TAG, "onStop: ")
}
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
fun onDestroy() {
Log.d(TAG, "onDestroy: ")
}
}
通过Lifecycle类的addObserver方法进行观察者的添加。
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
lifecycle.addObserver(MLifecycleObserver())
}
}
运行结果：
第二种实现方式
创建观察者类MLifecycleObserver并实现LifecycleEventObserver接口
class MLifecycleObserver2 : LifecycleEventObserver {
companion object {
private const val TAG = "MLifecycleObserver2"
}
private fun onCreate() {
Log.d(TAG, "onCreate: ")
}
private fun onStart() {
Log.d(TAG, "onStart: ")
}
private fun onResume() {
Log.d(TAG, "onResume: ")
}
private fun onPause() {
Log.d(TAG, "onPause: ")
}
private fun onStop() {
Log.d(TAG, "onStop: ")
}
private fun onDestroy() {
Log.d(TAG, "onDestroy: ")
}
override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
when (event) {
Lifecycle.Event.ON_CREATE -> onCreate()
Lifecycle.Event.ON_START -> onStart()
Lifecycle.Event.ON_RESUME -> onResume()
Lifecycle.Event.ON_PAUSE -> onPause()
Lifecycle.Event.ON_STOP -> onStop()
Lifecycle.Event.ON_DESTROY -> onDestroy()
}
}
}
通过Lifecycle类的addObserver方法进行观察者的添加。
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
lifecycle.addObserver(MLifecycleObserver2())
}
}
运行结果：
第三种实现方式
通过依赖androidx.lifecycle:lifecycle-common-java8
观察者类实现DefaultLifecycleObserver接口
class MLifecycleObserver3 : DefaultLifecycleObserver {
companion object {
private const val TAG = "MLifecycleObserver3"
}
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: ")
}
}
通过Lifecycle类的addObserver方法进行观察者的添加。
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
lifecycle.addObserver(MLifecycleObserver3())
}
}
分析
在分析之前先提出几个问题，在分析的过程中找到这些问题的答案。
- Activity、Fragment的生命周期是怎么转化成所对应的Lifecycle.Event？
- Lifecycle.Event经过那些处理？
- 如何将生命周期的事件分发给LifecycleObserver？
在我们添加观察者的时候会使用getLifecycle方法获取一个lifecycle并调用addObserver方法进行调用。那么我们先看看这个方法的实现。
ComponentActivity
public class ComponentActivity extends androidx.core.app.ComponentActivity implements LifecycleOwner, ViewModelStoreOwner, SavedStateRegistryOwner, OnBackPressedDispatcherOwner { private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this); @Override protected void onCreate(@Nullable Bundle savedInstanceState) { super.onCreate(savedInstanceState); ... ReportFragment.injectIfNeededIn(this); ... } @NonNull @Override public Lifecycle getLifecycle() { return mLifecycleRegistry; }}public interface LifecycleOwner { /** * Returns the Lifecycle of the provider. * * @return The lifecycle of the provider. */ @NonNull Lifecycle getLifecycle();}
从ComponentActivity可以看出这个类实现了LifecycleOwner接口，并且getLifecycle是该接口的方法。然后没有看出有什么特别的用来发送生命周期的变化，在onCreate方法我们看到有一段特殊的代码ReportFragment.injectIfNeededIn(this);，我们看看这个方法
ReportFragment
/** * Internal class that dispatches initialization events. * @hide */public class ReportFragment extends android.app.Fragment{ private static final String REPORT_FRAGMENT_TAG = "androidx.lifecycle" + ".LifecycleDispatcher.report_fragment_tag"; public static void injectIfNeededIn(Activity activity) { if (Build.VERSION.SDK_INT >= 29) { // 在API 29+上，直接注册生命周期回调 LifecycleCallbacks.registerIn(activity); } // Prior to API 29 and to maintain compatibility with older versions of // ProcessLifecycleOwner (which may not be updated when lifecycle-runtime is updated and // need to support activities that don't extend from FragmentActivity from support lib), // use a framework fragment to get the correct timing of Lifecycle events 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(); } } .... static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) { 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); } } } private void dispatchCreate(ActivityInitializationListener listener) { if (listener != null) { listener.onCreate(); } } private void dispatchStart(ActivityInitializationListener listener) { if (listener != null) { listener.onStart(); } } private void dispatchResume(ActivityInitializationListener listener) { if (listener != null) { listener.onResume(); } } @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); } @Override public void onDestroy() { super.onDestroy(); dispatch(Lifecycle.Event.ON_DESTROY); // just want to be sure that we won't leak reference to an activity mProcessListener = null; } private void dispatch(@NonNull Lifecycle.Event event) { if (Build.VERSION.SDK_INT < 29) { // Only dispatch events from ReportFragment on API levels prior // to API 29. On API 29+, this is handled by the ActivityLifecycleCallbacks // added in ReportFragment.injectIfNeededIn dispatch(getActivity(), event); } } ....}
通过上面的代码，可以看到injectIfNeededIn方法主要是为了给Activity提供Lifecycle生命周期感知的能力，在API 29或以上的时候使用Activity的registerActivityLifecycleCallbacks方法注册一个ActivityLifecycleCallbacks，在API 29以下的设备为了兼容性使用Fragment的生命周期来实现，不管使用的是ActivityLifecycleCallbacks或Fragment的生命周期最终调用dispatch方法。
static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) { 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); } } }
通过上述方法可以看到最终会调用LifecycleRegistry的handleLifecycleEvent方法，现在我们的第一个问题找到了答案，在API等级大于等于29的设备即安卓10即往后会使用Activity提供的生命周期回调ActivityLifecycleCallbacks来实现事件转换发送，而在低于29的设备则使用Fragment的生命周期调用相关进行事件的转换与分发。
LifecycleRegistry
public class LifecycleRegistry extends Lifecycle { private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap = new FastSafeIterableMap<>(); public LifecycleRegistry(@NonNull LifecycleOwner provider) { this(provider, true); } private LifecycleRegistry(@NonNull LifecycleOwner provider, boolean enforceMainThread) { mLifecycleOwner = new WeakReference<>(provider); mState = INITIALIZED; mEnforceMainThread = enforceMainThread; } ... 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; } ...}
在handleLifecycleEvent方法会调用moveToState方法，该方法会调用Lifecycle.Event提供的getTargetState方法获取目标状态。
Lifecycle#getTargetState
@NonNullpublic State getTargetState() { switch (this) { case ON_CREATE: case ON_STOP: return State.CREATED; case ON_START: case ON_PAUSE: return State.STARTED; case ON_RESUME: return State.RESUMED; case ON_DESTROY: return State.DESTROYED; case ON_ANY: break; } throw new IllegalArgumentException(this + " has no target state");}
看该部分的代码对比以下生命周期状态示意图
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ldcsXx01-1629701996556)(https://skbiji.oss-cn-qingdao.aliyuncs.com/picgo/20210529182912.svg)]
在getTargetState方法中，在ON_CREATE或ON_STOP事件后Lifecycle处于CREATED状态，在ON_START或ON_PAUSE事件后Lifecycle处于STARTED状态，在ON_RESUME事件后Lifecycle处于RESUMED状态，在ON_DESTROY事件后Lifecycle处于ON_DESTROY状态。
回到handleLifecycleEvent方法，在该方法中调用了moveToState方法，该方法主要用于判断新状态与当前状态是否有发生变化，如果有则调用sync方法进行同步。
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); } Map.Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest(); if (!mNewEventOccurred && newest != null && mState.compareTo(newest.getValue().mState) > 0) { forwardPass(lifecycleOwner); } } mNewEventOccurred = false;}
该方法通过比较当前状态和mObserverMap元素的枚举值来确定是否分发事件，由于mObserverMap里元素是按状态的大到小排序的，所以这里只需要拿第一位和最后一位元素的状态与当前状态比较，就可以判断是否需要分发事件，以及是分发降级事件，还是分发升级事件。再具体一点说，如果mObserverMap里最大状态比当前状态大，那就需要调用backwardPass()，遍历mObserverMap，同步其中每一个observer状态的同时，分发降级事件，反之，如果mObserverMap里最小状态比当前状态小，就调用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(); } } } private void backwardPass(LifecycleOwner lifecycleOwner) { Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> descendingIterator = mObserverMap.descendingIterator(); while (descendingIterator.hasNext() && !mNewEventOccurred) { Map.Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next(); ObserverWithState observer = entry.getValue(); while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred && mObserverMap.contains(entry.getKey()))) { Event event = Event.downFrom(observer.mState); if (event == null) { throw new IllegalStateException("no event down from " + observer.mState); } pushParentState(event.getTargetState()); observer.dispatchEvent(lifecycleOwner, event); popParentState(); } } }
forwardPass、backwardPass这两个方法比较类似，分别会以升序与降序来遍历mObserverMap，并在内部循环中会调用upFrom与downFrom来获取向下事件与向上事件，并通过observer的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; }}
@Nullablepublic static Event downFrom(@NonNull State state) { switch (state) { case CREATED: return ON_DESTROY; case STARTED: return ON_STOP; case RESUMED: return ON_PAUSE; default: return null; }}@Nullablepublic static Event upFrom(@NonNull State state) { switch (state) { case INITIALIZED: return ON_CREATE; case CREATED: return ON_START; case STARTED: return ON_RESUME; default: return null; }}
downFrom与upFrom依然可以通过官方图的详细了解状态转换成事件的过程
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gf06iz8X-1629701996558)(https://skbiji.oss-cn-qingdao.aliyuncs.com/picgo/20210529182912.svg)]
通过以上的分析我们知道了Lifecycle的状态与事件是如何进行转化的，并且也知道了是在哪儿分发的，那么分发的时候是怎么分发到具体的Observer的呢？
通过dispatchEvent我们知道直接调用LifecycleEventObserver的onStateChanged方法进行回调，这里的对象来自Lifecycling.lifecycleEventObserver(observer);方法
@NonNullstatic LifecycleEventObserver lifecycleEventObserver(Object object) { boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;//该对象是否实现了LifecycleEventObserver接口 boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;//该对象是否实现了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(); 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);//反射方式处理}
通过上面可以分析出来分为三种方式来处理，第一种判断对象是不是实现了FullLifecycleObserver、LifecycleEventObserver等接口类，如果是直接调用。第二种方式通过注解处理器生成的类文件。第三种通过反射的方式进行。
其中第一种性能优于第二种，第二种性能优于第三种，第三种通过反射性能最差。
看一下通过反射的方式进行调用：
//反射调用生命周期观察者class ReflectiveGenericLifecycleObserver implements LifecycleEventObserver { private final Object mWrapped; private final CallbackInfo mInfo; ReflectiveGenericLifecycleObserver(Object wrapped) { mWrapped = wrapped; mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());//通过单例获取wrapped对象的CallbackInfo } @Override public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Event event) { //调用方法 mInfo.invokeCallbacks(source, event, mWrapped); }}
ReflectiveGenericLifecycleObserver的实现很简单，在构造方法使用ClassesInfoCache的单例对象调用getInfo获取CallbackInfo对象，在生命周期发生变化的时候调用该对象的invokeCallbacks方法。所以通过上述的类可以知道反射方式实现过程中主要的类是ClassesInfoCache、CallbackInfo
private final Map<Class<?>, CallbackInfo> mCallbackMap = new HashMap<>();CallbackInfo getInfo(Class<?> klass) { CallbackInfo existing = mCallbackMap.get(klass);//从HashMap获取当前这个类的CallbackInfo if (existing != null) { return existing; } existing = createInfo(klass, null);//创建CallbackInfo return existing;}private CallbackInfo createInfo(Class<?> klass, @Nullable Method[] declaredMethods) { Class<?> superclass = klass.getSuperclass();//获取父类 Map<MethodReference, Lifecycle.Event> handlerToEvent = new HashMap<>(); if (superclass != null) { CallbackInfo superInfo = getInfo(superclass);//获取父类的CallbackInfo if (superInfo != null) { handlerToEvent.putAll(superInfo.mHandlerToEvent); } } Class<?>[] interfaces = klass.getInterfaces(); for (Class<?> intrfc : interfaces) { for (Map.Entry<MethodReference, Lifecycle.Event> entry : getInfo( intrfc).mHandlerToEvent.entrySet()) { verifyAndPutHandler(handlerToEvent, entry.getKey(), entry.getValue(), klass); } } Method[] methods = declaredMethods != null ? declaredMethods : getDeclaredMethods(klass); boolean hasLifecycleMethods = false; for (Method method : methods) {//遍历方法 OnLifecycleEvent annotation = method.getAnnotation(OnLifecycleEvent.class);//获取方法的OnLifecycleEvent注解 if (annotation == null) {//如果注解为空就跳过去 continue; } hasLifecycleMethods = true; Class<?>[] params = method.getParameterTypes();//获取参数类型 int callType = CALL_TYPE_NO_ARG;//无参数 if (params.length > 0) {//参数数量大于0 callType = CALL_TYPE_PROVIDER;//一个参数 if (!params[0].isAssignableFrom(LifecycleOwner.class)) { throw new IllegalArgumentException( "invalid parameter type. Must be one and instanceof LifecycleOwner"); } } Lifecycle.Event event = annotation.value(); if (params.length > 1) {//参数大于1 callType = CALL_TYPE_PROVIDER_WITH_EVENT;//两个参数 if (!params[1].isAssignableFrom(Lifecycle.Event.class)) { throw new IllegalArgumentException( "invalid parameter type. second arg must be an event"); } if (event != Lifecycle.Event.ON_ANY) {//evet不是ON_ANY throw new IllegalArgumentException( "Second arg is supported only for ON_ANY value"); } } if (params.length > 2) {//参数大于两个 throw new IllegalArgumentException("cannot have more than 2 params"); } MethodReference methodReference = new MethodReference(callType, method); verifyAndPutHandler(handlerToEvent, methodReference, event, klass); } CallbackInfo info = new CallbackInfo(handlerToEvent); mCallbackMap.put(klass, info); mHasLifecycleMethods.put(klass, hasLifecycleMethods); return info;}
createInfo的作用是递归遍历父类及自己每一个方法，并获取使用OnLifecycleEvent注解来注解方法，使用OnLifecycleEvent注解的方法分为无参、一个参数、两个参数这三种，在一个参数时参数对象是LifecycleOwner本身，在两个参数时则第一个参数为LifecycleOwner第二个参数为Event.ON_ANY
对方法的遍历会使用MethodReference包装起来，并调用verifyAndPutHandler放在handlerToEvent中建立Event与MethodReference的联系。
static class CallbackInfo { final Map<Lifecycle.Event, List<MethodReference>> mEventToHandlers;//event与MethodReference的一对多关系 final Map<MethodReference, Lifecycle.Event> mHandlerToEvent; //构造方法，此处简历一对多关系 CallbackInfo(Map<MethodReference, Lifecycle.Event> handlerToEvent) { mHandlerToEvent = handlerToEvent; mEventToHandlers = new HashMap<>(); for (Map.Entry<MethodReference, Lifecycle.Event> entry : handlerToEvent.entrySet()) {//遍历handlerToEvent Lifecycle.Event event = entry.getValue(); List<MethodReference> methodReferences = mEventToHandlers.get(event);//获取MethodReference列表 if (methodReferences == null) { methodReferences = new ArrayList<>(); mEventToHandlers.put(event, methodReferences);//添加到 } methodReferences.add(entry.getKey()); } } @SuppressWarnings("ConstantConditions") void invokeCallbacks(LifecycleOwner source, Lifecycle.Event event, Object target) { invokeMethodsForEvent(mEventToHandlers.get(event), source, event, target);//调用对应的Event事件 invokeMethodsForEvent(mEventToHandlers.get(Lifecycle.Event.ON_ANY), source, event,target);//用于发送ON_ANY事件 } 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); } } }}
CallbakcInfo在创建时，会解析hanlderToEvent，把一个MethodReference对应一个event的关系，转化为一个event对应多个MethodReference，并存入到mEventToHandlers中。这样在被调用invokeCallbacks()方法时，只需要从mEventToHandlers中取出对应的MethodReference，就可以回调观察者了。
static final class MethodReference { final int mCallType; final Method mMethod; MethodReference(int callType, Method method) { mCallType = callType; mMethod = method; mMethod.setAccessible(true); } void invokeCallback(LifecycleOwner source, Lifecycle.Event event, Object target) { //noinspection TryWithIdenticalCatches try { switch (mCallType) { case CALL_TYPE_NO_ARG://无参 mMethod.invoke(target); break; case CALL_TYPE_PROVIDER://一参数 mMethod.invoke(target, source); break; case CALL_TYPE_PROVIDER_WITH_EVENT://两个参数 mMethod.invoke(target, source, event); break; } } catch (InvocationTargetException e) { throw new RuntimeException("Failed to call observer method", e.getCause()); } catch (IllegalAccessException e) { throw new RuntimeException(e); } } ...}
总结
在API 29或以上的时候使用Activity的registerActivityLifecycleCallbacks方法注册一个ActivityLifecycleCallbacks，在API 29以下的设备为了兼容性使用Fragment的生命周期来实现对生命周期的监听，不管使用的是ActivityLifecycleCallbacks或Fragment的生命周期最终调用dispatch方法。经过层层处理最终会在ObserverWithState调用LifecycleObserver的onStateChanged方法，该LifecycleObserver对象来自Lifecycling.lifecycleEventObserver(observer)方法。在该方法对观察者对象的获取分为三种方式来处理，第一种判断对象是不是实现了FullLifecycleObserver、LifecycleEventObserver等接口类，如果是直接返回。第二种方式通过注解处理器生成的类文件。第三种通过反射的方式进行。
其中第一种性能优于第二种，第二种性能优于第三种，第三种通过反射性能最差。
反射方式是通过ReflectiveGenericLifecycleObserver这个实现了LifecycleEventObserver的类的onStateChanged方法进行反射调用。
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
