jetpack–Lifecycle 扩展

前言

生命周期持有者除了Activity、fragment还有 service 和 application ，本文讲述 LifeCycleService 和 ProccessLifeCycleOwner

一、LifeCycleService

public class LifecycleService extends Service implements LifecycleOwner {
    //可以理解为事件分发工具类，辅助进行 service 的事件分发
    private final ServiceLifecycleDispatcher mDispatcher = new ServiceLifecycleDispatcher(this);

    //Oncreate 会触发事件分发---调用mDispatcher.onServicePreSuperOnCreate()
    @CallSuper
    @Override
    public void onCreate() {
        mDispatcher.onServicePreSuperOnCreate();
        super.onCreate();
    }
    
    @CallSuper
    @Nullable
    @Override
    //OnBind 会触发事件分发---调用mDispatcher.onServicePreSuperOnBind()
    public IBinder onBind(@NonNull Intent intent) {
        mDispatcher.onServicePreSuperOnBind();
        return null;
    }

    @SuppressWarnings("deprecation")
    @CallSuper
    @Override
    //OnBind 会触发事件分发---调用mDispatcher.onServicePreSuperOnStart()
    public void onStart(@Nullable Intent intent, int startId) {
        mDispatcher.onServicePreSuperOnStart();
        super.onStart(intent, startId);
    }

    //这里没有事件分发 因为内部调用了 onStart 
    @CallSuper
    @Override
    public int onStartCommand(@Nullable Intent intent, int flags, int startId) {
        return super.onStartCommand(intent, flags, startId);
    }
    
    @CallSuper
    @Override
    //OnBind 会触发事件分发---调用mDispatcher.onServicePreSuperOnDestroy()
    public void onDestroy() {
        mDispatcher.onServicePreSuperOnDestroy();
        super.onDestroy();
    }

    @Override
    @NonNull
    //实现lifeCycleOwner 的 getLifeCycle 接口
    public Lifecycle getLifecycle() {
        return mDispatcher.getLifecycle();
    }
}
复制代码

可以看到 LifecycleService 实现了 lifeCycleOwner 接口，作为生命周期持有者，生命周期的分发和 返回 LifeCycle 是借助于 ServiceLifecycleDispatcher 来实现的，而 ServiceLifecycleDispatcher 是一开始就初始化好的；

我们可以看到分别会在 onCreate/onStart/onBind/onDestroy 中触发 事件分发，那到底分发了哪些事件呢？我们来看ServiceLifecycleDispatcher

public class ServiceLifecycleDispatcher {
    //维护Observer 和 event
    private final LifecycleRegistry mRegistry;
    // 辅助进行 事件分发
    private final Handler mHandler;
    //分发任务
    private DispatchRunnable mLastDispatchRunnable;

    /**
     * @param provider {@link LifecycleOwner} for a service, usually it is a service itself
     */
    public ServiceLifecycleDispatcher(@NonNull LifecycleOwner provider) {
        mRegistry = new LifecycleRegistry(provider);
        mHandler = new Handler();
    }

    private void postDispatchRunnable(Lifecycle.Event event) {
        if (mLastDispatchRunnable != null) {
            mLastDispatchRunnable.run();
        }
        mLastDispatchRunnable = new DispatchRunnable(mRegistry, event);
        mHandler.postAtFrontOfQueue(mLastDispatchRunnable);
    }

    //service onCreate  onServicePreSuperOnCreate 分发 ON_CREATE 事件，在service 调用super.Oncreate 之前
    public void onServicePreSuperOnCreate() {
        postDispatchRunnable(Lifecycle.Event.ON_CREATE);
    }

   //service onBind  onServicePreSuperOnBind 分发 ON_START 事件，在service 调用super.OnBind之前
    public void onServicePreSuperOnBind() {
        postDispatchRunnable(Lifecycle.Event.ON_START);
    }

    //service onStart/onStartCommand  onServicePreSuperOnStart 分发 ON_START 事件，在service 调用super.OnStart之前
    public void onServicePreSuperOnStart() {
        postDispatchRunnable(Lifecycle.Event.ON_START);
    }

    //service onDestroy   onServicePreSuperOnDestroy 分发 ON_STOP/ON_DESTROY 事件，在service 调用super.OnDestroy之前
    public void onServicePreSuperOnDestroy() {
        postDispatchRunnable(Lifecycle.Event.ON_STOP);
        postDispatchRunnable(Lifecycle.Event.ON_DESTROY);
    }

    /**
     * @return {@link Lifecycle} for the given {@link LifecycleOwner}
     */
    @NonNull
    public Lifecycle getLifecycle() {
        return mRegistry;
    }

    static class DispatchRunnable implements Runnable {
        private final LifecycleRegistry mRegistry;
        final Lifecycle.Event mEvent;
        private boolean mWasExecuted = false;

        DispatchRunnable(@NonNull LifecycleRegistry registry, Lifecycle.Event event) {
            mRegistry = registry;
            mEvent = event;
        }

        @Override
        public void run() {
            if (!mWasExecuted) {
                mRegistry.handleLifecycleEvent(mEvent);
                mWasExecuted = true;
            }
        }
    }
}
复制代码

小结

LifeCycleService借助ServiceLifecycleDispatcher 来进行LifeCycle的获取和 事件分发。

Service.OnCreate 中会触发 分发ON_CTEATE 事件

Service.OnStart/onStartCommand/OnBind 中会触发 分发 ON_START 事件

Service.onDestroy 会触发 分发 ON_STOP 、ON_DESTROY 事件

二、ProcessLifecycleOwner

public class ProcessLifecycleOwner implements LifecycleOwner {

    @VisibleForTesting
    static final long TIMEOUT_MS = 700; //mls

    //记录start的activity的数量
    private int mStartedCounter = 0;
    //记录 resume 的activity 的数量
    private int mResumedCounter = 0;
    //是否发送了 应用pause 事件
    private boolean mPauseSent = true;
    //是否发送了应用Stop事件
    private boolean mStopSent = true;

    private Handler mHandler;
    
    private final LifecycleRegistry mRegistry = new LifecycleRegistry(this);
    //事件分发任务
    private Runnable mDelayedPauseRunnable = new Runnable() {
        @Override
        public void run() {
            dispatchPauseIfNeeded();
            dispatchStopIfNeeded();
        }
    };
    //activity 初始化监听 只监听了 onCreate onStart onResume 
    ActivityInitializationListener mInitializationListener =
            new ActivityInitializationListener() {
                @Override
                public void onCreate() {
                }

                @Override
                public void onStart() {
                    activityStarted();
                }

                @Override
                public void onResume() {
                    activityResumed();
                }
            };
    //单例实现方式
    private static final ProcessLifecycleOwner sInstance = new ProcessLifecycleOwner();

    //返回单例
    @NonNull
    public static LifecycleOwner get() {
        return sInstance;
    }
    //关联context,初始化
    static void init(Context context) {
        sInstance.attach(context);
    }
    //分发应用ON_START 事件 start 的 activity 数量等于1 且 且mStopSent 是true
    void activityStarted() {
        mStartedCounter++;
        if (mStartedCounter == 1 && mStopSent) {
            mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
            mStopSent = false;
        }
    }

    //分发应用ON_RESUME 事件 resume 的 activity 数量等于1 且 且mPanseSent 是true,如果mPauseSent 不为true,移除即将要发送的 mDelayedPauseRunnable 
    void activityResumed() {
        mResumedCounter++;
        if (mResumedCounter == 1) {
            if (mPauseSent) {
                mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
                mPauseSent = false;
            } else {
                mHandler.removeCallbacks(mDelayedPauseRunnable);
            }
        }
    }

   //mResumedCounter 等于 0 的时候 延时700 ms触发 mDelayedPauseRunnable 任务
    void activityPaused() {
        mResumedCounter--;
        if (mResumedCounter == 0) {
            mHandler.postDelayed(mDelayedPauseRunnable, TIMEOUT_MS);
        }
    }
    //stop 时 
    void activityStopped() {
        mStartedCounter--;
        dispatchStopIfNeeded();
    }
   //如果mResumedCounter == 0 分发 ON_PAUSE 事件
    void dispatchPauseIfNeeded() {
        if (mResumedCounter == 0) {
            mPauseSent = true;
            mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
        }
    }
   //如果mStartedCounter == 0 且发送了onpause 则分发ON_STOP 事件
    void dispatchStopIfNeeded() {
        if (mStartedCounter == 0 && mPauseSent) {
            mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
            mStopSent = true;
        }
    }
    //私有构造函数
    private ProcessLifecycleOwner() {
    }
    //attach 会触发 分发onCreate事件，并在api >= 29时通过 activity.registerActivityLifecycleCallbacks 时 感知acitivity 生命周期，<29时 通过setProcessListener(mInitializationListener) 来感知
    void attach(Context context) {
        mHandler = new Handler();
        mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
        Application app = (Application) context.getApplicationContext();
        app.registerActivityLifecycleCallbacks(new EmptyActivityLifecycleCallbacks() {
            @Override
            public void onActivityPreCreated(@NonNull Activity activity,
                    @Nullable Bundle savedInstanceState) {
                activity.registerActivityLifecycleCallbacks(new EmptyActivityLifecycleCallbacks() {
                    @Override
                    public void onActivityPostStarted(@NonNull Activity activity) {
                        activityStarted();
                    }

                    @Override
                    public void onActivityPostResumed(@NonNull Activity activity) {
                        activityResumed();
                    }
                });
            }

            @Override
            public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
                 
                if (Build.VERSION.SDK_INT < 29) {
                         ReportFragment.get(activity).setProcessListener(mInitializationListener);
                }
            }

            @Override
            public void onActivityPaused(Activity activity) {
                activityPaused();
            }

            @Override
            public void onActivityStopped(Activity activity) {
                activityStopped();
            }
        });
    }

    @NonNull
    @Override
    public Lifecycle getLifecycle() {
        return mRegistry;
    }
}

  //ReportFragment 会先进行  mProcessListener 的分发 ，然后进行ON_CREATE 分发
  @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        dispatchCreate(mProcessListener);
        dispatch(Lifecycle.Event.ON_CREATE);
    }
 //activity 会先进行 dispatchActivityPreCreated 分发，然后是 fragment 的 dispatchActivityCreated，然后是 activity 的 onCreate
   @UnsupportedAppUsage
    final void performCreate(Bundle icicle, PersistableBundle persistentState) {
        dispatchActivityPreCreated(icicle);
        //省略代码
        mFragments.dispatchActivityCreated();
        dispatchActivityPostCreated(icicle);
    }
复制代码

小结

1.ProcessLifecycleOwner 会在attach 时触发 ON_CREATE 事件

2.ProcessLifecycleOwner 会 在API >= 29 onActivityPreCreated时 向 activity 注入EmptyActivityLifecycleCallbacks 用于在activity 的 onCreate、onStart、onResume 之前提前application 可以提前知道 生命周期；API < 29 时会通过 ReportFragment.get(activity).setProcessListener(mInitializationListener) 来提前感知 onCreate、onStart、onResume 生命周期(提前是相对于 activity 的 onCreate/onStart/onResume 回调)。

3.ON_START 事件的分发依赖 mStartedCounter 和 mStopSent 值

4.ON_RESUME 事件的分发依赖mResumedCounter 和 mPauseSent

5.ON_PAUSE 依赖mResumedCounter ，且会有一个 700ms 的延时，主要是为了保证屏幕旋转时不会触发此事件的分发

6.ON_STOP 依赖 mStartedCounter 且和 mPauseSent的值

7.ON_DESTROY 不会触发