带你详细了解 Android Lifecycle

原创

已于 2023-05-31 21:31:09 修改 · 1.8k 阅读

标签

#android #lifecycle

于 2023-04-05 13:59:56 首次发布

本文详细介绍了Android的Lifecycle组件，包括它的概念、依赖关系、使用方法和原理分析。Lifecycle组件用于监听Activity和Fragment的生命周期状态变化，通过Observer对象响应这些变化。文章还探讨了Kotlin和Java项目的依赖设置，以及Lifecycle的处理机制，如ObserverWithState、Lifecycling和ProcessLifecycleOwner。此外，还讨论了如何在Service中使用LifecycleService进行生命周期监听。

Lifecycle

文章目录

Lifecycle

概述

Lifecycle是一个生命周期感知型组件，可以通过添加Oberver来响应Activity和Fragment的生命周期状态变化，也就是监听生命周期。对于Activity来说，是在Activity构造函数中添加一个空的ReportFragment,然后再这个ragment生命周期方法中来通知lifecycle组件， t的performXXX(XXX表示生命周期)相应方法里面去通知到lifcycle组件。

Lifecycle是一个抽象类，他的具体实现类是 LifecycleRegistry 和Activity,Fragment之间是一对一的关系，他的作用就是管理想要监听Activity,Fragment的Oberver对象，并把Activity,Fragment生命周期发生变化时通知到所有Oberver.并且维护好每一个Oberver的状态使其保持和Activity,Fragment的生命周期状态一致。

Lifecycle里面有两个枚举类（下面类容中的界面组件表示Activity or Fragment）
Event用来标识当界面组件生命周期发生变化时的事件类型：
[ON_CREATE,ON_START,ON_RESUME,ON_PAUSE,ON_STOP,ON_DESTROY,ON_ANY]
State用来跟踪界面组件生命周期的状态：
[DESTROYED,INITIALIZED,CREATED,STARTED,RESUMED]

Lifecycle中用一个mState:State变量记录了他所跟踪的界面组件的生命周期状态
Observer也有一个同样的一个mState变量记录这个Oberver自身处于的一个状态，新添加一个Oberver时，其初始状态为INITIALIZED，因此当我们给Lifecycle新添加一个Oberver时，如果Observer的mState 小于 LifeCycle中 mState,那么新添加的observer会依次收到相应的事件回调，直到Oberver的mState和LifeCycle的mState一致，比如目前Activity的状态是RESUMED，onResume方法已经执行完成了，那么此时LifeCycle 中mState = RESUMED,我们通过点击一个按钮触发了一个添加Oberver的事件。那么Observer 就会依次收到 ON_CREATE,ON_START,ON_RESUME 事件回调。这里举的这一种比较简单理想的情况，还有可能涉及到更复杂的嵌套事件，

依赖关系

使用LifeCycle 需要再build.gradle 文件中添加依赖,LifeCycle相关的包比较多，常见的 livedata,viewModel 相关的代码都在 lifeCycle 下面。

Kotlin项目

dependencies {
   
   
        val lifecycle_version = "2.5.1"
        val arch_version = "2.1.0"

        /**
         * ViewModel相关：
         * lifecycle-viewmodel-ktx 是对 lifecycle-viewmodel里面的api进行kotiln相关扩展
         * ViewModel真正的代码是在 lifecycle-viewmodel里面。
         * lifecycle-viewmodel-ktx 里面依赖了 lifecycle-viewmodel，因此不需要在写一份对
				 * lifecycle-viewmodel的依赖声明 
  			 */
        implementation("androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version")
  			
        // ViewModel utilities for Compose
        implementation("androidx.lifecycle:lifecycle-viewmodel-compose:$lifecycle_version")
  
        // LiveData相关，对livedata api 进行kotlin相关扩展，其也依赖lifecycle-livedata
        implementation("androidx.lifecycle:lifecycle-livedata-ktx:$lifecycle_version")
  			
        // 只包含Lifecycles 不包含ViewModel 和 LiveData
        implementation("androidx.lifecycle:lifecycle-runtime-ktx:$lifecycle_version")

        // Saved state module for ViewModel
        implementation("androidx.lifecycle:lifecycle-viewmodel-savedstate:$lifecycle_version")

        // Annotation processo,如果要想通过注解的方式来实现生命周期方法回调必须依赖这个，但是注解的方式已经
  			//不建议使用了，因此我们的oberver继续至DefaultLifecycleObserver这个接口即可
        kapt("androidx.lifecycle:lifecycle-compiler:$lifecycle_version")
  
  			/**
  			 * 在2.4 （不包括）版本之前，要使用DefaultLifecycleObserver需要添加这个依赖，
  			 * 从2.4版本开始，DefaultLifecycleObserver代码移到了lifecycle-common这个包中
  			 * lifecycle-common这个包主要就是包含了各种Abserver和其对应的adapter.这个包
  			 * 不需要单独对其进行依赖，lifecycle-runtime里面依赖了 lifecycle-common。
  			 * 因此lifecycle-common-java8 在2.4+版本不再需要了
  			 */
        // alternately - if using Java8, use the following instead of lifecycle-compiler
        implementation("androidx.lifecycle:lifecycle-common-java8:$lifecycle_version")

        // 如果需要对Services生命周期进行监听
        implementation("androidx.lifecycle:lifecycle-service:$lifecycle_version")
				
  			// 监听整个app进程的生命周期需要添加依赖。
        // 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")

        // optional - Test helpers for Lifecycle runtime
        testImplementation ("androidx.lifecycle:lifecycle-runtime-testing:$lifecycle_version")
    }

java项目

java 项目的依赖和kotlin 基本类似，只是不需要对kotlin相关的支持


dependencies {
   
   
        val lifecycle_version = "2.5.1"
        val arch_version = "2.1.0"

        // ViewModel
        implementation("androidx.lifecycle:lifecycle-viewmodel:$lifecycle_version")
        // LiveData
        implementation("androidx.lifecycle:lifecycle-livedata:$lifecycle_version")
        // Lifecycles only (without ViewModel or LiveData)
        implementation("androidx.lifecycle:lifecycle-runtime:$lifecycle_version")

        // Saved state module for ViewModel
        implementation("androidx.lifecycle:lifecycle-viewmodel-savedstate:$lifecycle_version")

        // Annotation processor
        annotationProcessor("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:$lifecycle_version")

        // optional - Test helpers for LiveData
        testImplementation("androidx.arch.core:core-testing:$arch_version")

        // optional - Test helpers for Lifecycle runtime
        testImplementation("androidx.lifecycle:lifecycle-runtime-testing:$lifecycle_version")
    }

用法

在 Android 框架中定义的大多数应用组件都存在生命周期。生命周期由操作系统或进程中运行的框架代码管理。它们是 Android 工作原理的核心，应用必须遵循它们。如果不这样做，可能会引发内存泄漏甚至应用崩溃。

在Actitity 和Fragment 中使用方法一样，他们都实现了LifecycleOwner接口，调用其中的 getLifeCycle 方法拿到lifecycle 对象。然后调用lifecycle 的 addOberver 添加一个 LifecycleObserver 对象。

LifecycleObserver它是是一个空接口，里面没有定义任何方法，因此我们要添加一个Oberver对象，大体上可以分为类：

implement 其子类LifecycleEventObserver 或者孙子类DefaultLifecycleObserver

实现 LifecycleEventObserver接口：

class MyLifecycleEventObserver : LifecycleEventObserver{
       
       
    override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
       
       
      // 根据不同事件做出相应的处理
      when(event){
       
       
          Lifecycle.Event.ON_CREATE -> TODO()
          Lifecycle.Event.ON_START -> TODO()
          Lifecycle.Event.ON_RESUME -> TODO()
          Lifecycle.Event.ON_PAUSE -> TODO()
          Lifecycle.Event.ON_STOP -> TODO()
          Lifecycle.Event.ON_DESTROY -> TODO()
          Lifecycle.Event.ON_ANY -> TODO()
      }
    }
}

实现 DefaultLifecycleObserver接口，DefaultLifecycleObserver继承FullLifecycleObserver接口，用default方法实现了FullLifecycleObserver接口中的所有生命周期回调方法，因此子类只需要重写需要的方法即可，需要java8支持：

//此处只重写了一个方法，DefaultLifecycleObserver继承FullLifecycleObserver接口
class MyLifecycleObserver : DefaultLifecycleObserver{
       
       

    override fun onStart(owner: LifecycleOwner) {
       
       
        super.onStart(owner)
    }
}

implment LifecyclerOberver 接口，然后使用泛型 OnLifecycleEvent 标注自定义的生命周期方法：
```
class MyLifecycleObserver : LifecycleObserver {
     
     
        @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
        fun created(){
     
     
            println("----------- created")
        }
        @OnLifecycleEvent(Lifecycle.Event.ON_START)
        fun started(){
     
     
            println("----------- started")
        }
    }
```
通过注解的方式时，又分为了两种，一种是apt生成，在编译时通过注解处理器生成一个Adapter，这个Adapter里面持有了我们自己写的Observer,在Adapter里面根据不同类型的事件调用Observer里面被相应注解标注的生命周期方法，另一种是通过反射调用我们写的Observer的生命周期方法。

这两种方式从lifecycle 2.4 开始已经不建议使用了，理由也很简单，apt会影响编译速度，反射会影响运行时速度，之所以会有这种方式，就是因为我们大多数时候并不想关注所有生命周期方法，现在java8已经支持默认方法了，我们直接实现DefaultLifecycleObserver接口就可以，即能达到我们的目的，又不影响性能。

关系图：

在这里插入图片描述

apt生成

需要在build.gradle文件中添加注解处理器依赖： kapt("androidx.lifecycle:lifecycle-compiler:$lifecycle_version"),编译器在编译的时候会生成一个 className + “_LifecycleAdapter” 并且实现了 GeneratedAdapter 接口，相当于一个静态代理类的功能，例如上面的MyLifecycleObserver 会生成如下:

public class MyLifecycleObserver_LifecycleAdapter implements GeneratedAdapter {
   
   
  final MyLifecycleObserver mReceiver;

  MyLifecycleObserver_LifecycleAdapter(MyLifecycleObserver receiver) {
   
   
    this.mReceiver = receiver;
  }
	
  //在这个方法里面根据不同事件调用不同方法
  @Override
  public void callMethods(LifecycleOwner owner, Lifecycle.Event event, boolean onAny,
      MethodCallsLogger logger) {
   
   
    boolean hasLogger = logger != null;
    if (onAny) {
   
   
      return;
    }
    if (event == Lifecycle.Event.ON_CREATE) {
   
   
      if (!hasLogger || logger.approveCall("onCreate", 1)) {
   
   
        mReceiver.onCreate();
      }
      return;
    }
    if (event == Lifecycle.Event.ON_START) {
   
   
      if (!hasLogger || logger.approveCall("onStart", 1)) {
   
   
        mReceiver.onStart();
      }
      return;
    }
  }

反射反射就是在运行时通过反射去获取OnLifecycleEvent 注解标注相应事件方法然后进行调用，虽然在代码中对反射寻找方法做了缓存，不需要每次调用的时候都去反射，但是对性能还是有一定影响。

class ReflectiveGenericLifecycleObserver implements LifecycleEventObserver {
   
   
  // 这就是我们自己定义的Oberver对象
    private final Object mWrapped;
  	// 这里面就是一个支持缓存的反射调用
    private final androidx.lifecycle.ClassesInfoCache.CallbackInfo mInfo;

    @SuppressWarnings("deprecation")
    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);
    }
}

原理分析

Lifecycle 是一个类，用于存储有关组件（如 activity 或 fragment）的生命周期状态的信息，并允许其他对象观察此状态。

Lifecycle 使用两种主要枚举跟踪其关联组件的生命周期状态：

Event 从框架和 Lifecycle 类分派的生命周期事件。这些事件映射到 activity 和 fragment 中的生命周期方法回调事件。

// 定义了LifecyclerOwner发生的生命周期事件，这儿的LifecyclerOwner一般指Activity or Fragment 
public enum Event {
   
   
  			//表示LifecyclerOwner的OnCreate 方法被执行的事件
        ON_CREATE,
       	//表示LifecyclerOwner的OnStart 方法被执行的事件
        ON_START,
       //表示LifecyclerOwner的OnResume 方法被执行的事件
        ON_RESUME,
       //表示LifecyclerOwner的OnPause 方法被执行的事件
        ON_PAUSE,
        //表示LifecyclerOwner的OnStop 方法被执行的事件
        ON_STOP,
      //表示LifecyclerOwner的OnDestroy 方法被执行的事件
        ON_DESTROY,
       //用来匹配任意事件
        ON_ANY;

}

State 由 Lifecycle 对象跟踪的组件(activity 和 fragment)的当前状态。简单的来说就是用来表示组件(activity 和Fragment)当前的生命周期状态，

public enum State {
   
   
			
        //表示LifecycleOwener被destroyed。被标记为这个状态后，也就意味Lifecycle在也不会派发其他任何事件了，
  			//注意：Lifecycle派发ON_DESTROOY事件发生在Activity的onDestroy方法之前。意思就是Observer的
  			//ON_DESTROY事件先与Activity的OnDestroy方法调用
        DESTROYED,
  
        //表示LifecyclerOwner被初始化了，例如Activity调用构造方法，但是还没调用OnCreate方法
        INITIALIZED,
  
					/**
         * 表示LifecyclerOwner处于CREATED状态，比如对于Activity和Fragment来说
         * 有两种情况下会到达该状态
         *		1.调用Actitity or Fragment的onCreate后
         *    2.Activiy or Fragment的OnStop方法被调用前
         * 第一种OnCreate被调用后好理解，OnStop被调之前是什么意思？就是当我Activity或者Fragment进入到后台的时
         * 把Lifecycle中跟踪组件的状态变量mState置为CREATED,然后Lifecycle再dispatch一个ON_STOP事件,最后
					 * Activity或者Fragment的OnStop方法才被调用。也就意味着Observer的ON_STOP事件先与Activity or 						 * Fragment的onStop方法. 
         */
        CREATED,
				
        /**
         * 表示LifecycleOwner处于STARTED状态，比如对于Activity和Fragment来说
         * 有两种情况下会到达该状态
         * 		1.Activity or Fragment的onStart方法被调用
         * 		2.在Activity or Fragment的onPause方法被调用前
         * onPause之前的意思和CREATE状态类似，只是针对的事件是ON_PAUSE,针对的方法时onPause
         */
        STARTED,

        /**
					 * 表示LifecycleOwner处于RESUME状态，对于Actvity of Fragment来说，调用了其onResume方法后就会到达
					 * 这个状态
         */
        RESUMED;
        }
    }

有没有发现State这个枚举中并没有 PAUSED,STOPED等状态来跟踪LifecycleOwner对应的生命周期状态。仔细回想一下Activity or Fragment的生命周期方法，就拿Activity来说，当执行onPause方法后，虽然是进入了PAUSED状态，但是有没有感觉就是相当于回退到了STARED状态，要想Activity变得再次可以和用户交互，就要往下继续执行onResume方法进入RESUMED状态，所以只需要一个STARED状态就可以表示两种情况。同理 CREATED也可以表示Activity执行完onStop方法后进入的一种状态。

这儿有一张官网图构成了activity 生命周期的状态和事件：

在这里插入图片描述

图解：拿Activity来说，最开始Activity被实例化出来即被new出来的时候，Lifecycle中记录为mState = INITIALIZED,当Activity的onCreate方法被执行的时候，Lifecycle dispatch ON_CREATE 事件，同时记录mState = CREATED,onStart方法被执行的时候 dispatch ON_START事件，同时记录mState = STARTED，onResume方法被执行的时候disptch ON_RESUME事件，同时记录 mState = RESUME。当onPause方法执行的时候，dispatch ON_PAUSE事件，同时记录mState = STARTED.往后依次类推。

Lifecycle作为一个能监听Activity or Fragment生命周期的组件，里面包含了很多类和相关逻辑，为了更好的理解和说清楚，先简单介绍几个关键类类的作用，Lifecycle ，LifecyleOwner,LifecyclåeRegister.

Lifecycle

一个抽象类，声明了 addObserver，removeObserver，getCurrentState 三个方法，以及内部定了了两个枚举：Eveent和State

LifecycleOwner

一个接口，表示Lifecycle的拥有者，也就是说一个类如果想拥有其生命周期被监听或者被感知，那么这个类就一定实现这个接口，该接口有一个唯一的方法 Lifecycle getLifecycle()用来返回一个Lifecylce对象，比如我们的Activity和Fragment都实现了这个接口

LifecycleRegister

Lifecycle具体的实现类，他在组件（Activity，Fragment）和 Observer 之间起到一个中间作用，接收组件的生命周期发生变化的通知，如果有Observer则把事件通知给所有Observer.

接下来把后面的内容分为接收，和处理两个阶段来详细介绍lifecycle具体如何实现组件生命周期跟踪的：

接收

接收组件（Activiy or Fragment）生命周期发生变化时的通知。Lifecycle接收Activity和Fragment生命周期发生变化的事件通知逻辑是不一样的:

接收Activity生命周期事件

对于Activity来说是通过在Activity里面添加一个没有界面的空Fragment(ReportFragment)，然后在ReportFragment的生命周期方法中去通知到Lifecycle告知其Activity生命周期发生了变化，以下是关键代码片段：

Activity相关


//Acyiviy onCreate方法，基于androidx.activity.ComponentActivity

public class ComponentActivity extends androidx.core.app.ComponentActivity implements
        ContextAware,
        LifecycleOwner,// 实现了LifecycleOwner接口
        ViewModelStoreOwner,
        HasDefaultViewModelProviderFactory,
        SavedStateRegistryOwner,
        OnBackPressedDispatcherOwner,
        ActivityResultRegistryOwner,
        ActivityResultCaller,
        MenuHost {
   
   
          
  //内部持有了mLifecycleRegistry 实例对象，LifecycleRegistry是lifecycle具体实现类 
  // ReportFragment中会把生命周期事件交给 mLifecycleRegistry 处理
	private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
          
	protected void onCreate(@Nullable Bundle savedInstanceState) {
   
   
        mSavedStateRegistryController.performRestore(savedInstanceState);
        mContextAwareHelper.dispatchOnContextAvailable(this);
        super.onCreate(savedInstanceState);
  				//把ReportFragment添加到Activity中
        ReportFragment.injectIfNeededIn(this);
        if (mContentLayoutId != 0) {
   
   
            setContentView(mContentLayoutId);
        }
    }
  //返回lifecycle实例
   public Lifecycle getLifecycle() {
   
   
        return mLifecycleRegistry;
    }
          
}

ReportFragment：

//一个不包含任何界面的Fragment。主要用于把生命周期事件报告给lifecycle
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+，使用ActivityLifecycleCallbacks来跟踪Activity生命周期事件
            // On API 29+, we can register for the correct Lifecycle callbacks directly
            LifecycleCallbacks.registerIn(activity);
           //注意这儿没有直接return掉，意味着即使API29+，RepportFragment依然会被添加
           //但是没关系，虽然添加了，对于api29+,不会把生命周期事件报告给Lifecycle,而是通过上面的callbacks
        }
    		//把ReportFragment添加到Activity中
       android.app.FragmentManager manager = activity.getFragmentManager();
        if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
   
   
            manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
            manager.executePendingTransactions();
        }
    }
		//调用Lifecycle的handleLifecycleEvent方法把Event交给Lifecycle处理
    static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
   
   
      	//这种情况主要是指我们的界面Activity继承至androidx.appcompat.app.AppCompatActivity
        if (activity instanceof LifecycleRegistryOwner) {
   
   
          // 拿到activity中的mLifecycleRegistry对象把事件通知到lifecycle，也就是ComponentActivity
          	//中的mLifecycleRegistry
            ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
            return;
        }
			
        if (activity instanceof LifecycleOwner) {
   
   
            Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
            if (lifecycle instanceof LifecycleRegistry) {
   
   
              //拿到activity中的mLifecycleRegistry对象把事件通知到lifecycle
                ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
            }
        }
    }

    static ReportFragment get(Activity activity) {
   
   
        return (ReportFragment) activity.getFragmentManager().findFragmentByTag(
                REPORT_FRAGMENT_TAG);
    }

  //这个是当我们使用ProcessLifecycleOwner监听整个进程生命周期时用的，在后面会讲到
    private ActivityInitializationListener mProcessListener;
   //告知进程监听器，Activity onCreate
    private void dispatchCreate(ActivityInitializationListener listener) {
   
   
        if (listener != null) {
   
   
            listener.onCreate();
        }
    }
   //告知进程监听器，Activity onStart
    private void dispatchStart(ActivityInitializationListener listener) {
   
   
        if (listener != null) {
   
   
            listener.onStart();
        }
    }
	//告知进程监听器，Activity onResuem
    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);
    }
	
  //Fragement 的onStart被调用，以为着Activity得onStart已经被调用了
  // 那么开始分发事件，其他几个生命周期方法类似
    @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;
    }

  
  //这个方法是在上面生命周期方法中被调用 当api版本小于29的时候才调用 dispatch(getActivity(), event)，真正把事
  //件交给lifecycle去处理,如果api29+,采用下面LifecycleCallbacks去跟踪生命周期事件
    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);
        }
    }
	
  //ProcessLifecycleOwner中会调用
    void setProcessListener(ActivityInitializationListener processListener) {
   
   
        mProcessListener = processListener;
    }
	//在ProcessLifecycleOwner中会调用，监听一个Activity的初始化阶段的生命周期事件，因此没有onPuase,onStop等
    interface ActivityInitializationListener {
   
   
        void onCreate();

        void onStart();

        void onResume();
    }

		// 需要api29+,用来监听Activity生命周期的回调，他会被注册到Activity 中，在Activity中的perform相关声明周期方法
   // 里面会回调这个callback. 
    @RequiresApi(29)
    static class LifecycleCallbacks implements Application.ActivityLifecycleCallbacks {
   
   

        static void registerIn(Activity activity) {
   
   
          // 把回调注册到Activity中
            activity.registerActivityLifecycleCallbacks(new LifecycleCallbacks());
        }

        @Override
        public void onActivityPostCreated(@NonNull Activity activity,
                @Nullable Bundle savedInstanceState) {
   
   
          	//把生命周期事件分发给lifeCycle去处理
            dispatch(