Jetpack之Process和Service.

我们这里主要是分析Lifecycle的两个组件，他们是

implementation "androidx.lifecycle:lifecycle-process:$lifecycle_version"
implementation "androidx.lifecycle:lifecycle-service:$lifecycle_version"

lifecycle-process是用来感知整个应用的生命周期，比如我们要知道当前引用处于前台还是后台。lifecycle-service是用来感知Service的生命周期的。

ActivityLifecycleCallbacks

在讲解使用他们之前，我们先看一个类ActivityLifecycleCallbacks，他是Application内部定义的一个接口，定义了Activity执行时候的生命周期，我们可以通过((Application) context.getApplicationContext()).registerActivityLifecycleCallbacks();来监听所有的Activity的生命周期。与我们的LifeCycle不太一样，他是系统层级去进行调用和通知的，他是可以起到类似LifecycleRegistry的作用，但是他是针对所有的Activity，而我们的LifecycleRegistry是针对单个Activity的。我们看下ActivityLifecycleCallbacks有那些方法。

public interface ActivityLifecycleCallbacks {
        default void onActivityPreCreated(@NonNull Activity activity,
                @Nullable Bundle savedInstanceState) {
        }
        void onActivityCreated(@NonNull Activity activity, @Nullable Bundle savedInstanceState);
        default void onActivityPostCreated(@NonNull Activity activity,
                @Nullable Bundle savedInstanceState) {
        }
        default void onActivityPreStarted(@NonNull Activity activity) {
        }
        void onActivityStarted(@NonNull Activity activity);
        default void onActivityPostStarted(@NonNull Activity activity) {
        }
        default void onActivityPreResumed(@NonNull Activity activity) {
        }
        void onActivityResumed(@NonNull Activity activity);
        default void onActivityPostResumed(@NonNull Activity activity) {
        }
        default void onActivityPrePaused(@NonNull Activity activity) {
        }
        void onActivityPaused(@NonNull Activity activity);
        default void onActivityPostPaused(@NonNull Activity activity) {
        }
        default void onActivityPreStopped(@NonNull Activity activity) {
        }
        void onActivityStopped(@NonNull Activity activity);
       default void onActivityPostStopped(@NonNull Activity activity) {
        }
        default void onActivityPreSaveInstanceState(@NonNull Activity activity,
                @NonNull Bundle outState) {
        }
        void onActivitySaveInstanceState(@NonNull Activity activity, @NonNull Bundle outState);
        default void onActivityPostSaveInstanceState(@NonNull Activity activity,
                @NonNull Bundle outState) {
        }
        default void onActivityPreDestroyed(@NonNull Activity activity) {
        }
        void onActivityDestroyed(@NonNull Activity activity);
        default void onActivityPostDestroyed(@NonNull Activity activity) {
        }
    }

可以看到看到关于Activity的生命周期的通知回调都是抽象方法，还有两种pre和post默认方法。其中pre就是在对应的生命周期执行之前执行，post则是在对应生命周期执行之后执行。比如我们的Activity执行了onCreate，那么ActivityLifecycleCallbacks则会执行onActivityCreated，而在Activity执行onCreate之前，先会执行ActivityLifecycleCallbacks的onActivityPreCreated，在执行完了onCreate到onActivityCreated之后，会再去执行onActivityPostCreated，其他的也类似。需要注意的是pre和post方法是需要Android10只会才会被调用的。同样的，对于Build.VERSION.SDK_INT >= 29以上的。
Activity也提供了registerActivityLifecycleCallbacks方法，假如在Activity里面注册，则是只针对当前的Activity，他可以收到一次onActivityCreated和一次onActivityDestroyed，其他生命周期可以收到多次。

lifecycle-process

我们的分析的源码版本是2.2.0。新版本的lifecycle-process组件已经不需要我们手动初始化了，他是会在ProcessLifecycleOwnerInitializer这个ContentProvider的onCreate去初始化（该方法是介于Application的attachBaseContext到onCreate之间的）。

@Override
public boolean onCreate() {
    LifecycleDispatcher.init(getContext());
    ProcessLifecycleOwner.init(getContext());
    return true;
}

LifecycleDispatcher的作用是给每个Activity注入ReportFragment，可以看到他往Application里面注册了一个ActivityLifecycleCallbacks

static class DispatcherActivityCallback extends EmptyActivityLifecycleCallbacks {
        @Override
        public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
            ReportFragment.injectIfNeededIn(activity);
        }
        ...
    }

然后我们再看ProcessLifecycleOwner，Lifecycle.Event.ON_CREATE只有在他的attach里面调用了，后续都没有调用，而且整个过程也没有调用Lifecycle.Event.ON_DESTROY，所以对于ProcessLifecycleOwner，注册到它的LifecycleObserver只会调用一次onCreate，同时不会调用onDestroy。
我们可以看到对于Build.VERSION.SDK_INT < 29一下的，会使用ReportFragment，给他注入一个ActivityInitializationListener，ReportFragment中会在对应的生命周期调用ActivityInitializationListener的方法。而对于Build.VERSION.SDK_INT >= 29的，则是注册了一个ActivityLifecycleCallbacks，然后在onActivityPreCreated中，给每个Activity再去注册ActivityLifecycleCallbacks。
所以其实他的activityResumed和activityStarted都只会在一个地方调用，要么是在ActivityInitializationListener(API<29)，要么是在Activity注册的ActivityLifecycleCallbacks调用。
然后我们再看他的成员变量

1. mStartedCounter，Activity执行start的次数，每执行一次增加1，每执行一次stop减1
2. mResumedCounter，Activity执行resume的次数，每执行一次增加1，每执行一次pause减1
3. mStopSent，Activity是否发送过stop，默认true
4. mPauseSent，Activity是否发送过pause，默认true
   在通知注册在ProcessLifecycleOwner的LifecycleObserver的时候，他是这样的

   void activityStarted() {
           mStartedCounter++;
           if (mStartedCounter == 1 && mStopSent) {
               //等于1而且是stop过的才会通知LifecycleObserver，而且只会通知一次，因为mStopSent执行之后设置为了false
               mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
               mStopSent = false;
           }
       }
   
       void activityResumed() {
           mResumedCounter++;
           if (mResumedCounter == 1) {
               //只有一个Act执行过onResume的时候才会进入
               if (mPauseSent) {
                   //需要执行过pause才会通知LifecycleObserver
                   mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
                   mPauseSent = false;
               } else {
                   //假如没有执行过pause则把mDelayedPauseRunnable移除
                   mHandler.removeCallbacks(mDelayedPauseRunnable);
               }
           }
       }

   其他的方法也是类似的，我们就不说了，我们说下实际中怎么使用

   class AppLife implements LifecycleObserver {
       //可以继承LifecycleEventObserver或者是FullLifecycleObserver也可以，不用注解
       private static final String TAG = "AppLife";
       /**
        * ON_CREATE 在应用程序的整个生命周期中只会被调用一次
        */
       @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
       public void onCreate() {
           Log.d(TAG, "Lifecycle.Event.ON_CREATE");
       }
   
       /**
        * 应用程序出现到前台时调用
        */
       @OnLifecycleEvent(Lifecycle.Event.ON_START)
       public void onStart() {
           Log.d(TAG, "Lifecycle.Event.ON_START");
       }
   
       /**
        * 应用程序出现到前台时调用
        */
       @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
       public void onResume() {
           Log.d(TAG, "Lifecycle.Event.ON_RESUME");
       }
   
       /**
        * 应用程序退出到后台时调用
        */
       @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
       public void onPause() {
           Log.d(TAG, "Lifecycle.Event.ON_PAUSE");
       }
   
       /**
        * 应用程序退出到后台时调用
        */
       @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
       public void onStop() {
           Log.d(TAG, "Lifecycle.Event.ON_STOP");
       }
   
       /**
        * 永远不会被调用到，系统不会分发调用ON_DESTROY事件
        */
       @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
       public void onDestroy() {
           Log.d(TAG, "Lifecycle.Event.ON_DESTROY");
       }
   }
   
   //然后在自定义的Application中
   @Override
       public void onCreate() {
           super.onCreate();
           ProcessLifecycleOwner.get().getLifecycle().addObserver(new AppLife());
       }

   应用启动，或者是从后台到前台的时候，只会调用一次onStart和onResume，应用推至后台的时候，则会执行一次onPause和onStop，我们可以选择一组进行判断使用。假如我们需要判断应用是处于前台还是后台，可以增加一个布尔变量，早onResume设置为true，在onStop设置为false。这样外部可以读取这个变量既可判断。

lifecycle-service

它的源码也比较的简单，就不多说了，它主要是提供了一个LifecycleService，我们的服务需要继承它，然后我们定义一个LifecycleObserver，通过它的getLifecycle()方法，添加到该Service的Lifecycle中。当Service被启动，被暂停，被重新Start都可以接受到回调。与Activity中注入LifecycleObserver差不多，注意Service的只有ON_CREATE，ON_START，ON_STOP，ON_DESTROY。其中ON_STOP，ON_DESTROY会被一起调用，这里就不举例子了。