Lifecycle详解Lifecycle是Google推出的一个可以感知（Activity/Fragment）等组件生命

Lifecycle是Google推出的一个可以感知（Activity/Fragment）等组件生命周期的一个组件。使用Lifecycle，，可以避免在（Activity/Fragment）生命周期函数里写过多的逻辑代码，可以使我们的业务逻辑更加的解耦。下面介绍Lifecycle的使用以及原理。
LiveData详解
 ViewModel详解

一：添加依赖

dependencies {
    def lifecycle_version = "2.2.0"
    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"

    // 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"
}

根据自己所需要的去添加依赖

二：使用

2.1：ProcessLifecycleOwner（监听整个应用的生命周期）

我们可以通过ProcessLifecycleOwner监听应用处于前台，还是后台。代码如下：

class MApp :Application(){
    override fun onCreate() {
        super.onCreate()
        ProcessLifecycleOwner.get().lifecycle.addObserver(AppLifecycleObserver())
    }
}

class AppLifecycleObserver :LifecycleObserver{

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun onAppBackgound(){
        Log.e("ccm","====AppLifecycleObserver=====onAppBackgound==")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun onAppForeground(){
        Log.e("ccm","====AppLifecycleObserver=====onAppForeground==")
    }
}

在applicatioin的onCreate方法里使用ProcessLifecycleOwner.get().lifecycle.addObserver(AppLifecycleObserver())添加监听
AppLifecycleObserver实现LifecycleObserver。
@OnLifecycleEvent(Lifecycle.Event.ON_STOP)注解的onAppBackgound()方法,会在应用进入后台的时候调用。 @OnLifecycleEvent(Lifecycle.Event.ON_START)onAppForeground()方法,会在应用进入前台的时候调用。如上就实现了对应用进入前后台的监听。

2.2：监听Activity/Fragment的生命周期

以前我们经常在Activity的onDestroy里去释放一些资源。如果业务逻辑一多，那么对应的onDestroy里的代码也会很多，难以维护。而有了Lifecycle，我们可以使用Lifecycle去解耦这些逻辑代码，使Activity跟Fragment更加的干净。下面是一个简单的监听Activity声明周期的例子：

class LearnLifeCycleActivity :AppCompatActivity(){
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_learnlifecycle)
        lifecycle.addObserver(LearnLifecycleObserver())
    }
}

class LearnLifecycleObserver :LifecycleObserver{

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun onCreate(){
        Log.e("ccm","===LearnLifecycleObserver==onCreate====")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun onStart(){
        Log.e("ccm","===LearnLifecycleObserver==onStart====")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun onResume(){
        Log.e("ccm","===LearnLifecycleObserver==onResume====")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun onPause(){
        Log.e("ccm","===LearnLifecycleObserver==onPause====")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun onStop(){
        Log.e("ccm","===LearnLifecycleObserver==onStop====")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun onDestroy(){
        Log.e("ccm","===LearnLifecycleObserver==onDestroy====")
    }
}

lifecycle.addObserver(LearnLifecycleObserver()) 在Activity里使用该代码添加观察
LearnLifecycleObserver类实现LifecycleObserver，并且通过注解@OnLifecycleEvent，就可以去监听Activity的onCreate(),onStart(),onResume(),onPause(),onStop(),onDestroy()方法。使用起来很简单，下面再写个实战的例子。比如我们的代码经常会使用Handler,并且在onDestroy里去让Handler.removeCallbacksAndMessages。这块现在我们就可以通过Lifecycle解耦出来。如下：

class LifecycleHandler(val lifecycleOwner:LifecycleOwner) :Handler(),LifecycleObserver{
    init {
        addObserver()
    }
    private fun addObserver(){
        lifecycleOwner.lifecycle.addObserver(this)
    }
    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    private fun onDestroy(){
        removeCallbacksAndMessages(null)
        lifecycleOwner.lifecycle.removeObserver(this)
    }
}

LifecycleHandler类继承Handler，实现LifecycleObserver
在初始化时候lifecycleOwner.lifecycle.addObserver(this) 添加观察
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY) 接收到onDestroy之后，去 removeCallbacksAndMessages(null)跟lifecycleOwner.lifecycle.removeObserver(this)删除观察如上就是一个简单的例子。Lifecycle使用起来很简单，那么Lifecycle如何去做到能够监听组件（如Activity/Fragment）的生命周期的呢,下面我们通过源码的解析来进行分析。

三：源码解析

上面例子中，来看LearnLifeCycleActivity的代码：

class LearnLifeCycleActivity :AppCompatActivity(){
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_learnlifecycle)
        lifecycle.addObserver(LearnLifecycleObserver())
    }
}

点进lifecycle具体看看lifecycle是什么？跳转到ComponentActivity的

private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
...
public Lifecycle getLifecycle() {
  return mLifecycleRegistry;
}

我们发现其实lifecycle就是LifecycleRegistry，而调用lifecycle.addObserver方法其实就是调用LifecycleRegistry的addObserver方法。这时候，我们先暂停一下，先来看看LifecycleRegistry是什么

public class LifecycleRegistry extends Lifecycle {
...
}

LifecycleRegistry继承Lifecycle，LifecycleRegistry是Lifecycle的唯一实现类，来看看Lifecycle的代码

public abstract class Lifecycle {
	public abstract void addObserver(@NonNull LifecycleObserver observer);
	public abstract void removeObserver(@NonNull LifecycleObserver observer);
	public abstract State getCurrentState();
	
    public enum Event {
        ON_CREATE,
        ON_START,
        ON_RESUME,
        ON_PAUSE,
        ON_STOP,
        ON_DESTROY,
        ON_ANY
    }
    public enum State {
        DESTROYED,
        INITIALIZED,
        CREATED,
        STARTED,
        RESUMED
    }
}

Lifecycle主要有三个方法抽象方法addObserver，removeObserver，getCurrentState
两个枚举类Event，State。我们来看看Lifecycle官网的一张图，来展示Event跟State的关系的。

blockchain

State 是节点， Event 是连接每个节点的线。Event的值是完全按 Activity 的生命周期来理解，都是一一对应的，State 看起来是缺失了 PAUSED、STOPED，其实它的 PAUSED 就是 STARTED，STOPED 是 CREATED。总的来说，Event 就是改变生命周期的事件，State 是目前 Activity/Fragment 所处生命周期的状态\

有了对Lifecycle的了解之后，并且LifecycleRegistry是Lifecycle的唯一实现来，接下来我们回过头来看之前遗留的LifecycleRegistry的addObserver方法。

...
private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap =
            new FastSafeIterableMap<>();
...  
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
   State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
   ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
   ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);

   if (previous != null) {
       return;
   }
   LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
   if (lifecycleOwner == null) {
       // it is null we should be destroyed. Fallback quickly
       return;
   }
   ...
}

State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED; //初始化State状态

ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);把State状态跟observer观察者。作为参数传入ObserverWithState，构建ObserverWithState的实例。

static class ObserverWithState {
     State mState;
     LifecycleEventObserver mLifecycleObserver;

     ObserverWithState(LifecycleObserver observer, State initialState) {
         mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
         mState = initialState;
     }
     ...
 }

ObserverWithState是持有State跟Observer的对象。接着看Lifecycling.lifecycleEventObserver(observer); 方法

static LifecycleEventObserver lifecycleEventObserver(Object object) {
     ...
     return new ReflectiveGenericLifecycleObserver(object);
 }

传进来的observer其实又被ReflectiveGenericLifecycleObserver包了一层，接着看看ReflectiveGenericLifecycleObserver

class ReflectiveGenericLifecycleObserver implements LifecycleEventObserver {
 private final Object mWrapped;
 private final CallbackInfo mInfo;

 ReflectiveGenericLifecycleObserver(Object wrapped) {
     mWrapped = wrapped;
     mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());
 }

 @Override
 public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Event event) {
     mInfo.invokeCallbacks(source, event, mWrapped);
  }
}

再来看看CallbackInfo是什么，ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());

CallbackInfo getInfo(Class<?> klass) {
     CallbackInfo existing = mCallbackMap.get(klass);
     if (existing != null) {
         return existing;
     }
     existing = createInfo(klass, null);
     return existing;
 }
 private CallbackInfo createInfo(Class<?> klass, @Nullable Method[] declaredMethods) {
     ...
     Method[] methods = declaredMethods != null ? declaredMethods : getDeclaredMethods(klass);
     boolean hasLifecycleMethods = false;
     for (Method method : methods) {
         OnLifecycleEvent annotation = method.getAnnotation(OnLifecycleEvent.class);
         if (annotation == null) {
             continue;
         }
         ...
         Lifecycle.Event event = annotation.value();
         ...
         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;
 }

我们可以看到 method.getAnnotation(OnLifecycleEvent.class);annotation.value();去解析了注解，并且获取值，并且存储集合最终都封装到CallbackInfo这个类中。

mObserverMap.putIfAbsent(observer, statefulObserver); mObserverMaps是个HashMap集合，把observer跟statefulObserver键值对形式存储到集合中。到这里总结一下，addObserver做了什么。
第一步是构建了ObserverWithState类，并且ObserverWithState包含State跟传入的Observer对象，而这个传入的Observer其实又被ReflectiveGenericLifecycleObserver包装了一层，并且ReflectiveGenericLifecycleObserver里还包含了CallbackInfo。CallbackInfo类主要是解析了传入的Observer类的@OnLifecycleEvent注解对应的信息并保存着
将ObserverWithState跟传入的Observer类存入FastSafeIterableMap集合

到这里，我们分析完了addObserver方法做的事情，再回过头来看看getLifecycle()方法，我们的getLifecycle()方法是在ComponentActivity里，而我们的LearnLifeCycleActivity都是继承ComponentActivity

public class ComponentActivity extends androidx.core.app.ComponentActivity implements LifecycleOwner,ViewModelStoreOwner, SavedStateRegistryOwner, OnBackPressedDispatcherOwner {
   ...
   protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mSavedStateRegistryController.performRestore(savedInstanceState);
        ReportFragment.injectIfNeededIn(this);
        if (mContentLayoutId != 0) {
            setContentView(mContentLayoutId);
        }
    }
}

ComponentActivity实现了LifecycleOwner，并且在ComponentActivity的onCreate方法里有个ReportFragment.injectIfNeededIn(this);

public static void injectIfNeededIn(Activity activity) {
        if (Build.VERSION.SDK_INT >= 29) {
            // On API 29+, we can register for the correct Lifecycle callbacks directly
            activity.registerActivityLifecycleCallbacks(
                    new LifecycleCallbacks());
        }
        // 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();
        }
    }

我们可以看到API29以上都会去注册一个LifecycleCallbacks，并且不管哪个API都会去添加一个new ReportFragment() 先来看LifecycleCallbacks

// this class isn't inlined only because we need to add a proguard rule for it. (b/142778206)
    static class LifecycleCallbacks implements Application.ActivityLifecycleCallbacks {
        @Override
        public void onActivityCreated(@NonNull Activity activity,
                @Nullable Bundle bundle) {
        }

        @Override
        public void onActivityPostCreated(@NonNull Activity activity,
                @Nullable Bundle savedInstanceState) {
            dispatch(activity, Lifecycle.Event.ON_CREATE);
        }
        
        @Override
        public void onActivityStarted(@NonNull Activity activity) {
        }

        @Override
        public void onActivityPostStarted(@NonNull Activity activity) {
            dispatch(activity, Lifecycle.Event.ON_START);
        }

        @Override
        public void onActivityResumed(@NonNull Activity activity) {
        }

        @Override
        public void onActivityPostResumed(@NonNull Activity activity) {
            dispatch(activity, Lifecycle.Event.ON_RESUME);
        }

        @Override
        public void onActivityPrePaused(@NonNull Activity activity) {
            dispatch(activity, Lifecycle.Event.ON_PAUSE);
        }

        @Override
        public void onActivityPaused(@NonNull Activity activity) {
        }

        @Override
        public void onActivityPreStopped(@NonNull Activity activity) {
            dispatch(activity, Lifecycle.Event.ON_STOP);
        }

        @Override
        public void onActivityStopped(@NonNull Activity activity) {
        }

        @Override
        public void onActivitySaveInstanceState(@NonNull Activity activity,
                @NonNull Bundle bundle) {
        }

        @Override
        public void onActivityPreDestroyed(@NonNull Activity activity) {
            dispatch(activity, Lifecycle.Event.ON_DESTROY);
        }

        @Override
        public void onActivityDestroyed(@NonNull Activity activity) {
        }
    }

我们发现LifecycleCallbacks里是对Activity的生命周期的监听，并且在相应的生命周期里都调用了dispatch方法，只是传入的事件是对应声明周期的事件（如：dispatch(activity, Lifecycle.Event.ON_DESTROY)），在来看看ReportFragment这个Fragment

...
@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);
        }
}

我们发现在ReportFragment的生命周期里也都调用了dispatch这个方法，并且传入对应的生命周期事件（如：dispatch(Lifecycle.Event.ON_DESTROY);）接着我们来看看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);
            }
        }
}

我们看到代码会判断activity是否是LifecycleOwner类型，并且lifecycle是否是LifecycleRegistry，接着会调用 LifecycleRegistry的handleLifecycleEvent方法。并且事件作为参数传入。根据我们上面查看的源码，ComponentActivity是实现了LifecycleOwner，并且lifecycle就是LifecycleRegistry。所以来看看LifecycleRegistry的handleLifecycleEvent方法

public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
   State next = getStateAfter(event);
   moveToState(next);
}

State next = getStateAfter(event);是将Event转成State。Event跟State之前前面有张关系图

static State getStateAfter(Event event) {
        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;
        }
        throw new IllegalArgumentException("Unexpected event value " + event);
}

moveToState(next);主要是调用sync方法

 private void moveToState(State next) {
        ...
        sync();
        ...
    }

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);
            }
            Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
            // 生命周期前进逻辑
            if (!mNewEventOccurred && newest != null
                    && mState.compareTo(newest.getValue().mState) > 0) {
                forwardPass(lifecycleOwner);
            }
        }
        mNewEventOccurred = false;
}

根据 State 的状态会有前进、后退两种逻辑，前进就是生命周期状态和事件图中从左往右的线路，后退就是生命周期状态和事件图从右往左的线路，看下backwardPass逻辑：

private void backwardPass(LifecycleOwner lifecycleOwner) {
        Iterator<Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
                mObserverMap.descendingIterator();
        while (descendingIterator.hasNext() && !mNewEventOccurred) {
            Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();
            ObserverWithState observer = entry.getValue();
            while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
                    && mObserverMap.contains(entry.getKey()))) {
                Event event = downEvent(observer.mState);
                pushParentState(getStateAfter(event));
                observer.dispatchEvent(lifecycleOwner, event);
                popParentState();
            }
        }
}

关键代码是observer.dispatchEvent(lifecycleOwner, event);调到了ObserverWithState的dispatchEvent方法

void dispatchEvent(LifecycleOwner owner, Event event) {
            State newState = getStateAfter(event);
            mState = min(mState, newState);
            mLifecycleObserver.onStateChanged(owner, event);
            mState = newState;
}

调用到了mLifecycleObserver.onStateChanged(owner, event);我们上面分析过mLifecycleObserver的实现类是ReflectiveGenericLifecycleObserver，所以来看ReflectiveGenericLifecycleObserver的onStateChanged方法

...
private final CallbackInfo mInfo;
...
ReflectiveGenericLifecycleObserver(Object wrapped) {
        mWrapped = wrapped;
        mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());
}
@Override
public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Event event) {
        mInfo.invokeCallbacks(source, event, mWrapped);
}

又调用到了mInfo.invokeCallbacks(source, event, mWrapped);来看看CallbackInfo的invokeCallbacks方法

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);
                }
            }
}

其实是调用到了MethodReference的invokeCallback方法

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);
            }
}

这里会mMethod会通过反射去调用。那这个mMethod是什么呢？我们前面分析到CallbackInfo的createInfo的方法的时候

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);
            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);
            if (annotation == null) {
                continue;
            }
            hasLifecycleMethods = true;
            Class<?>[] params = method.getParameterTypes();
            int callType = CALL_TYPE_NO_ARG;
            if (params.length > 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) {
                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) {
                    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;
    }

会发现，其实method就是我们传入的observer的对应的注解了OnLifecycleEvent的方法。总结：组件Activity/Fragment会在相应的声命周期函数里调用dispatch方法分发事件，并调用LifecycleRegistry的handleLifecycleEvent去处理事件。LifecycleRegistry会根据传入的生命周期事件，去决定是否是向前还是向后的逻辑。然后经过ObserverWithState->ReflectiveGenericLifecycleObserver -> CallbackInfo -> MethodReference，最终通过反射真正调用到自定义LifecycleObserver添加了注解的方法。这就是整个流程