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