1. 注册流程

final LifecycleRegistry mFragmentLifecycleRegistry = new LifecycleRegistry(this);

@Override
public void addObserver(@NonNull LifecycleObserver observer) {
    // 可以让刚注册的可以获取先前的回调，在下面的while循环
    State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
    // observer的转化流程在这里，这一步走完就已经将LifecycleObserver转换为LifecycleEventObserver了，
    // 其内部会根据条件生成多个 LifecycleEventObserver的子类进行return，最终即为统一为：LifecycleEventObserver
    ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
    ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
    // 重复添加，直接返回
    if (previous != null) {
        return;
    }
    // 判空
    LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
    if (lifecycleOwner == null) {
        return;
    }

    // 是否重入
    boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
    State targetState = calculateTargetState(observer);
    mAddingObserverCounter++;
    // ********* 重要 ********
    // 此时statefulObserver.mState 的初始值为 
    // INITIALIZED ，通过与计算出的 targetState 比较，
    // 小于的话，就进入循环。
    // （DESTROYED是最小的，INITIALIZED比DESTROYED大，CREATED比INITIALIZED，以此类推）
    while ((statefulObserver.mState.compareTo(targetState) < 0
            && mObserverMap.contains(observer))) {
        // 将自身状态存起来
        pushParentState(statefulObserver.mState);
        // 分发Event
        statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
        // 将自身状态删掉
        popParentState();
        // 重新计算状态，用于循环退出条件：直到observer的状态从INITIALIZED的状态递进到当前LifecyleOwner的状态
        targetState = calculateTargetState(observer);
    }

    //如果重入的话没有必要每次都同步，浪费资源，只需要在最后一次处理完所有任务之后同步一次即可
    if (!isReentrance) {
        //更新一些属性，并分发event
        sync();
    }
    mAddingObserverCounter--;
}

2. 通知流程

2.1 ComponentActivity

// ComponentActivity
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    mSavedStateRegistryController.performRestore(savedInstanceState);
    mContextAwareHelper.dispatchOnContextAvailable(this);
    super.onCreate(savedInstanceState);
    ReportFragment.injectIfNeededIn(this);
    if (mContentLayoutId != 0) {
        setContentView(mContentLayoutId);
    }
}

2.1 ReportFragment

// ReportFragment
public static void injectIfNeededIn(Activity activity) {
    if (Build.VERSION.SDK_INT >= 29) { // android 10及以后 使用LifecycleCallbacks
        LifecycleCallbacks.registerIn(activity);
    }
    // 额外添加一个Fragment，Glide也有相关的添加一个Fragment获取生命周期变化
    android.app.FragmentManager manager = activity.getFragmentManager();
    if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
        manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
        manager.executePendingTransactions();
    }
}

// ReportFragment 
@Override
public void onActivityCreated(Bundle savedInstanceState) {
    dispatch(Lifecycle.Event.ON_CREATE);
}

@Override
public void onStart() {
    dispatch(Lifecycle.Event.ON_START);
}

@Override
public void onResume() {
    dispatch(Lifecycle.Event.ON_RESUME);
}

@Override
public void onPause() {
    dispatch(Lifecycle.Event.ON_PAUSE);
}

@Override
public void onStop() {
    dispatch(Lifecycle.Event.ON_STOP);
}

@Override
public void onDestroy() {
    dispatch(Lifecycle.Event.ON_DESTROY);
}

private void dispatch(Lifecycle.Event event) {
    Activity activity = getActivity();
    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);
        }
    }
}

2.1 LifecycleCallbacks

• LifecycleCallbacks 是ReportFragment内的 静态内部类
• dispatch会执行 activity对应的liftcyle去分发Event事件

static class LifecycleCallbacks implements Application.ActivityLifecycleCallbacks {
    static void registerIn(Activity activity) {
        activity.registerActivityLifecycleCallbacks(new LifecycleCallbacks());
    }

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

    @Override
    public void onActivityPostCreated(@NonNull Activity activity,
                                      @Nullable Bundle savedInstanceState) {
        // activity对应的liftcyle去分发Event事件
        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) {
    }
}