Jetpack-Lifecycle源码解析

PHP小丑

Lifecycle源码解析

源码版本：

Lifecycle：2.4.0

androidx.activity:activity：1.4.0

androidx.fragment:fragment：1.4.0

使用

声明LifecycleObserver
1. DefaultLifecycleObserver
生命周期状态改变时，会调用对应的方法。可根据需要，重写某个方法。

val lifecycleObserver = object : DefaultLifecycleObserver {
  override fun onResume(owner: LifecycleOwner) {
    super.onResume(owner)
  }
  override fun onPause(owner: LifecycleOwner) {
    super.onPause(owner)
  }
}

2. LifecycleEventObserver
生命周期状态改变时，会调用onStateChanged方法。

val lifecycleObserver = object : LifecycleEventObserver {
  override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
  }
}

3. OnLifecycleEvent（已弃用）
生命周期状态改变时，会调用LifecycleObserver子类被对应event标注的方法。使用OnLifecycleEvent注解标注方法上，方法要求：方法名称任意，方法参数可无、可1个（必须是LifecycleOwner）、可2个（必须先后是LifecycleOwner、Lifecycle.Event、且event必须是Lifecycle.Event.ON_ANY）。

val lifecycleObserver = object : LifecycleObserver {
  @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
  fun onCreate() {
  }
  @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
  fun onResume(owner: LifecycleOwner) {
  }
  @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
  fun onAny(owner: LifecycleOwner, event: Lifecycle.Event) {
  }
}

添加观察者

lifecycle.addObserver(lifecycleObserver)

移除观察者

lifecycle.removeObserver(lifecycleObserver)

获取当前状态

val state = lifecycle.currentState

源码

声明LifecycleObserver
1. DefaultLifecycleObserver
DefaultLifecycleObserver接口

public interface DefaultLifecycleObserver extends FullLifecycleObserver {
  @Override
  default void onCreate(@NonNull LifecycleOwner owner) {}
  @Override
  default void onStart(@NonNull LifecycleOwner owner) {}
  @Override
  default void onResume(@NonNull LifecycleOwner owner) {}
  @Override
  default void onPause(@NonNull LifecycleOwner owner) {}
  @Override
  default void onStop(@NonNull LifecycleOwner owner) {}
  @Override
  default void onDestroy(@NonNull LifecycleOwner owner) {}
}

DefaultLifecycleObserver接口对FullLifecycleObserver接口进行了默认实现，所以可以按需实现某个方法。由于此接口方法使用default，这一特性是从 Java 8才开始有的，所以需要配置以 Java 8及以上作为编译版本才可以使用。
FullLifecycleObserver接口

interface FullLifecycleObserver extends LifecycleObserver {
  void onCreate(LifecycleOwner owner);
  void onStart(LifecycleOwner owner);
  void onResume(LifecycleOwner owner);
  void onPause(LifecycleOwner owner);
  void onStop(LifecycleOwner owner);
  void onDestroy(LifecycleOwner owner);
}

生命周期状态改变时，会调用对应的方法（调用逻辑后面讲）。FullLifecycleObserver接口不是public的，所以不能使用，推荐使用DefaultLifecycleObserver。
LifecycleObserver接口

public interface LifecycleObserver {
}

LifecycleObserver是一个空接口，用于标记可以被Lifecycle添加、删除。可以使用它的子接口DefaultLifecycleObserver、LifecycleEventObserver或被OnLifecycleEvent（已弃用）标注方法的子类，来通知生命周期事件。
2. LifecycleEventObserver
LifecycleEventObserver接口

public interface LifecycleEventObserver extends LifecycleObserver {
  void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event);
}

生命周期状态改变时，会调用onStateChanged方法（调用逻辑后面讲）。参数event为当前的事件（ON_CREATE、ON_START、ON_RESUME、ON_PAUSE、ON_STOP、ON_DESTROY）。
3. OnLifecycleEvent（已弃用）
OnLifecycleEvent注解

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Deprecated
public @interface OnLifecycleEvent {
  Lifecycle.Event value();
}

生命周期状态改变时，会调用LifecycleObserver子类被对应event标注的方法（调用逻辑后面讲）。OnLifecycleEvent已被@Deprecated标注，已经被弃用，后面会减少对此的讲解。

添加观察者
使用

class MainActivity : AppCompatActivity() {
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    // 添加
    lifecycle.addObserver(lifecycleObserver)
  }
}

获取到Lifecycle，然后进行添加。我们先看一下Lifecycle类。
Lifecycle
Lifecycle类

public abstract class Lifecycle {
  // 协程相关，存放coroutineScope的。
  @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
  @NonNull
  AtomicReference<Object> mInternalScopeRef = new AtomicReference<>();
  // 添加观察者
  @MainThread
  public abstract void addObserver(@NonNull LifecycleObserver observer);
  // 移除观察者
  @MainThread
  public abstract void removeObserver(@NonNull LifecycleObserver observer);
  // 获取当前的状态
  @MainThread
  @NonNull
  public abstract State getCurrentState();
  // 事件类
  public enum Event {
    ON_CREATE,
    ON_START,
    ON_RESUME,
    ON_PAUSE,
    ON_STOP,
    ON_DESTROY,
    ON_ANY; // 任何事件都会触发
  }
  // 状态类
  public enum State {
    DESTROYED,
    INITIALIZED,
    CREATED,
    STARTED,
    RESUMED;
    // 比较这个状态是否大于等于给定的状态，RESUMED > STARTED > CREATED > INITIALIZED > DESTROYED。
    public boolean isAtLeast(@NonNull State state) {
      return compareTo(state) >= 0;
    }
  }
}

State和Event的关系图

LifecycleOwner
我们再来看一下，从Actvity或Fragment中是如何获取到Lifecycle的，因为androidx.activity.ComponentActivity和androidx.fragment.app.Fragment都实现了LifecycleOwner接口，表明可以提供Lifecycle实例，相关的源码如下：
LifecycleOwner接口

public interface LifecycleOwner {
  @NonNull
  Lifecycle getLifecycle();
}

Activity
androidx.activity.ComponentActivity --> getLifecycle方法

public class ComponentActivity extends androidx.core.app.ComponentActivity implements
    ContextAware,
    LifecycleOwner,
    ViewModelStoreOwner,
    HasDefaultViewModelProviderFactory,
    SavedStateRegistryOwner,
    OnBackPressedDispatcherOwner,
    ActivityResultRegistryOwner,
    ActivityResultCaller,
    MenuHost {
  private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
  @NonNull
  @Override
  public Lifecycle getLifecycle() {
    return mLifecycleRegistry;
  }
}

androidx.core.app.ComponentActivity --> getLifecycle方法

public class ComponentActivity extends Activity implements
    LifecycleOwner,
    KeyEventDispatcher.Component {
  private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
  @NonNull
  @Override
  public Lifecycle getLifecycle() {
    return mLifecycleRegistry;
  }
}

说明：

MyActivity继承关系：MyActivity->AppCompatActivity->FragmentActivity->androidx.activity.ComponentActivity->androidx.core.app.ComponentActivity

虽然androidx.activity.ComponentActivity和父类androidx.core.app.ComponentActivity都实现了LifecycleOwner接口，但是androidx.core.app.ComponentActivity的被子类androidx.activity.ComponentActivity覆盖，导致父类的无效。

Fragment
androidx.fragment.app.Fragment --> getLifecycle方法

public class Fragment implements ComponentCallbacks, OnCreateContextMenuListener, LifecycleOwner,
    ViewModelStoreOwner, HasDefaultViewModelProviderFactory, SavedStateRegistryOwner,
    ActivityResultCaller {
  LifecycleRegistry mLifecycleRegistry;
  @Override
  @NonNull
  public Lifecycle getLifecycle() {
    return mLifecycleRegistry;
  }
  public Fragment() {
    initLifecycle();
  }
  private void initLifecycle() {
    mLifecycleRegistry = new LifecycleRegistry(this);
  }
}

androidx的Activity和Fragment都实现了LifecycleOwner接口，并返回的都是LifecycleRegistry类。我们接下来看一下LifecycleRegistry类。
LifecycleRegistry
构造方法
LifecycleRegistry --> 构造方法

public LifecycleRegistry(@NonNull LifecycleOwner provider) {
  // 默认，强制在主线程执行，mEnforceMainThread为true
  this(provider, true);
}
private LifecycleRegistry(@NonNull LifecycleOwner provider, boolean enforceMainThread) {
  // 记录LifecycleOwner
  mLifecycleOwner = new WeakReference<>(provider);
  // 当前状态为INITIALIZED
  mState = INITIALIZED;
  mEnforceMainThread = enforceMainThread;
}

我们接下来再看一下addObserver方法。
addObserver
LifecycleRegistry --> addObserver方法

@Override
public void addObserver(@NonNull LifecycleObserver observer) {
  // 当mEnforceMainThread为true时，必须是在主线程调用，否则抛出异常
  enforceMainThreadIfNeeded("addObserver");  
  // 观察者的初始化状态
  State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
  // 生成ObserverWithState，它包含状态和观察者，它会把上面全部3种情况的LifecycleObserver统一转换成LifecycleEventObserver。
  ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
  // 将观察者添加到map，如果已经添加，则直接返回。
  // putIfAbsent，如果传入key对应的value已经存在，就返回存在的value，不进行替换。如果不存在，就添加key和value，并返回null。
  ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);  
  if (previous != null) {
    return;
  }
  // 获取LifecycleOwner实例，一般来说是Activity或者Fragment实例。
  LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
  if (lifecycleOwner == null) {
    // 对象为空，说明已经被销毁，直接返回。
    return;
  }
  // isReentrance：是否是再次进入
  // 1.mAddingObserverCounter：添加中的观察者数量。在执行前加1，在执行后减1，又因为addObserver方法强制在主线程执行（没有并发），所以它一般都为0。之所以不为0，是因为它在添加的observer的生命周期回调的方法内，又调用addObserver方法增加了一个新的LifecycleObserver。
  // 2.mHandlingEvent：是否正在处理事件中。
  boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
  // 计算目标状态
  State targetState = calculateTargetState(observer);
  mAddingObserverCounter++;
  // statefulObserver.mState.compareTo(targetState) < 0：说明观察者ObserverWithState的状态未到达目标状态。
  // mObserverMap.contains(observer)：上面已添加，这边再判断是否包含，是因为它在添加的observer的生命周期回调的方法内，调用了removeObserver。
  // 使用while，保证依次分发所有的事件。
  while ((statefulObserver.mState.compareTo(targetState) < 0
      && mObserverMap.contains(observer))) {      
    pushParentState(statefulObserver.mState);
    // 获取观察者状态的下一个事件
    final Event event = Event.upFrom(statefulObserver.mState);
    if (event == null) {
      throw new IllegalStateException("no event up from " + statefulObserver.mState);
    }
    // 观察者ObserverWithState分发事件，通知被Lifecycle添加的LifecycleObserver状态改变，讲ObserverWithState时会介绍。
    statefulObserver.dispatchEvent(lifecycleOwner, event);    
    popParentState();
    // mState可能被更改，重新计算。
    targetState = calculateTargetState(observer);
  }
  if (!isReentrance) {
    // we do sync only on the top level.
    sync();
  }
  mAddingObserverCounter--;
}

说明：

目标状态一般为mState（当前状态），观察者ObserverWithState初始化状态一般为INITIALIZED，如果观察者的状态一直未到达目标状态，则一直循环分发事件，直到相同为止。

例如：如果在Activity的onResume后addObserver，则当前状态为RESUMED，观察者的状态为INITIALIZED到RESUMED，所以此观察者会依次接收到ON_CREATE、ON_START、ON_RESUME事件或对应的回调。

我们再来看一下带状态的观察者ObserverWithState，以及它的dispatchEvent分发方法。
ObserverWithState
ObserverWithState类

static class ObserverWithState {
  State mState;
  LifecycleEventObserver mLifecycleObserver;
  ObserverWithState(LifecycleObserver observer, State initialState) {
    // 把上面全部3种情况的LifecycleObserver统一转换成LifecycleEventObserver。
    mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
    mState = initialState;
  }
  void dispatchEvent(LifecycleOwner owner, Event event) {
    State newState = event.getTargetState();
    mState = min(mState, newState);
    // 用转换后的LifecycleEventObserver通知被Lifecycle添加的LifecycleObserver状态改变。
    mLifecycleObserver.onStateChanged(owner, event);
    mState = newState;
  }
}

ObserverWithState带状态的观察者，它统一了全部3种情况的LifecycleObserver，以及dispatchEvent方法，用转换后的LifecycleEventObserver通知被Lifecycle添加的LifecycleObserver状态改变。我们再来看一下Lifecycling它是如何统一的。
Lifecycling
Lifecycling --> lifecycleEventObserver方法

@NonNull
@SuppressWarnings("deprecation")
static LifecycleEventObserver lifecycleEventObserver(Object object) {
  // 是否是LifecycleEventObserver子类
  boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
  // 是否是FullLifecycleObserver子类
  boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
  if (isLifecycleEventObserver && isFullLifecycleObserver) {
    // 两者都是，需要适配，两个样式回调都通知。
    return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,
        (LifecycleEventObserver) object);
  }
  if (isFullLifecycleObserver) {
    // 只是FullLifecycleObserver，需要适配，只回调一个。
    return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
  }
  if (isLifecycleEventObserver) {
    // 只是LifecycleEventObserver，不用适配，直接返回即可。
    return (LifecycleEventObserver) object;
  }
  // 使用OnLifecycleEvent注解的处理
  final Class<?> klass = object.getClass();
  int type = getObserverConstructorType(klass);
  if (type == GENERATED_CALLBACK) {
    // 使用OnLifecycleEvent注解，并且依赖了androidx.lifecycle:lifecycle-compiler注解处理器，使用注解处理器优化反射带来的性能问题。
    List<Constructor<? extends GeneratedAdapter>> constructors =
        sClassToAdapters.get(klass);
    if (constructors.size() == 1) {
      GeneratedAdapter generatedAdapter = createGeneratedAdapter(
          constructors.get(0), object);
      return new SingleGeneratedAdapterObserver(generatedAdapter);
    }
    GeneratedAdapter[] adapters = new GeneratedAdapter[constructors.size()];
    for (int i = 0; i < constructors.size(); i++) {
      adapters[i] = createGeneratedAdapter(constructors.get(i), object);
    }
    return new CompositeGeneratedAdaptersObserver(adapters);
  }
  // 使用OnLifecycleEvent注解，并且未依赖注解处理器，使用反射处理。
  return new ReflectiveGenericLifecycleObserver(object);
}

我们再来看一下具体实现。
LifecycleEventObserver Adapter
LifecycleEventObserver Adapter一共有4个，FullLifecycleObserverAdapter、SingleGeneratedAdapterObserver、CompositeGeneratedAdaptersObserver、ReflectiveGenericLifecycleObserver。和OnLifecycleEvent注解相关的3个，由于OnLifecycleEvent已经弃用，所以我们只讲1个反射的，注解处理器的2个它们的方法要求和反射的相同，只不过它们是在编译期检测的。
FullLifecycleObserverAdapter
FullLifecycleObserverAdapter类

class FullLifecycleObserverAdapter implements LifecycleEventObserver {
  private final FullLifecycleObserver mFullLifecycleObserver;
  private final LifecycleEventObserver mLifecycleEventObserver;
  FullLifecycleObserverAdapter(FullLifecycleObserver fullLifecycleObserver,
      LifecycleEventObserver lifecycleEventObserver) {
    mFullLifecycleObserver = fullLifecycleObserver;
    mLifecycleEventObserver = lifecycleEventObserver;
  }
  @Override
  public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {
    // 以对应生命周期方法回调方式通知
    switch (event) {
      case ON_CREATE:
        mFullLifecycleObserver.onCreate(source);
        break;
      case ON_START:
        mFullLifecycleObserver.onStart(source);
        break;
      case ON_RESUME:
        mFullLifecycleObserver.onResume(source);
        break;
      case ON_PAUSE:
        mFullLifecycleObserver.onPause(source);
        break;
      case ON_STOP:
        mFullLifecycleObserver.onStop(source);
        break;
      case ON_DESTROY:
        mFullLifecycleObserver.onDestroy(source);
        break;
      case ON_ANY:
        throw new IllegalArgumentException("ON_ANY must not been send by anybody");
    }
    // 以状态改变回调方式通知
    if (mLifecycleEventObserver != null) {
      mLifecycleEventObserver.onStateChanged(source, event);
    }
  }
}

当ObserverWithState调用dispatchEvent的时候，如果是使用DefaultLifecycleObserver或LifecycleEventObserver，则会调用此onStateChanged方法，以通知被Lifecycle添加的LifecycleObserver状态改变。
ReflectiveGenericLifecycleObserver
ReflectiveGenericLifecycleObserver类

@Deprecated
class ReflectiveGenericLifecycleObserver implements LifecycleEventObserver {
  private final Object mWrapped;
  private final androidx.lifecycle.ClassesInfoCache.CallbackInfo mInfo;
  @SuppressWarnings("deprecation")
  ReflectiveGenericLifecycleObserver(Object wrapped) {
    mWrapped = wrapped;
    // 获取观察者类的信息，内部会解析判断被OnLifecycleEvent注解的方法声明是否正确。
    mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());
  }
  @Override
  public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Event event) {
    // 调用被OnLifecycleEvent标注的对应的方法，通知回调。
    mInfo.invokeCallbacks(source, event, mWrapped);
  }
}

当ObserverWithState调用dispatchEvent的时候，如果是使用OnLifecycleEvent并且无添加依赖androidx.lifecycle:lifecycle-compiler注解处理器，则会调用此onStateChanged方法，以通知被Lifecycle添加的LifecycleObserver状态改变。
ClassesInfoCache --> getInfo方法

CallbackInfo getInfo(Class<?> klass) {
  CallbackInfo existing = mCallbackMap.get(klass);
  if (existing != null) {
    return existing;
  }
  existing = createInfo(klass, null);
  return existing;
}

ClassesInfoCache类的getInfo方法，一开始缓存里面是没有的，然后会调用createInfo方法进行创建并存储到缓存并返回其结果。
ClassesInfoCache --> createInfo方法

private CallbackInfo createInfo(Class<?> klass, @Nullable Method[] declaredMethods) {
  ...
  for (Method method : methods) {
    OnLifecycleEvent annotation = method.getAnnotation(OnLifecycleEvent.class);
    if (annotation == null) {
      continue;
    }
    hasLifecycleMethods = true;
    Class<?>[] params = method.getParameterTypes();
    int callType = CALL_TYPE_NO_ARG;
    if (params.length > 0) {
      callType = CALL_TYPE_PROVIDER;
      // 第1个参数必须是LifecycleOwner，否则抛异常。
      if (!params[0].isAssignableFrom(LifecycleOwner.class)) {
        throw new IllegalArgumentException(
            "invalid parameter type. Must be one and instanceof LifecycleOwner");
      }
    }
    Lifecycle.Event event = annotation.value();
    if (params.length > 1) {
      callType = CALL_TYPE_PROVIDER_WITH_EVENT;
      // 第2个参数必须是Lifecycle.Event，否则抛异常。
      if (!params[1].isAssignableFrom(Lifecycle.Event.class)) {
        throw new IllegalArgumentException(
            "invalid parameter type. second arg must be an event");
      }
      // 并且OnLifecycleEvent注解的值必须是Lifecycle.Event.ON_ANY，否则抛异常。
      if (event != Lifecycle.Event.ON_ANY) {
        throw new IllegalArgumentException(
            "Second arg is supported only for ON_ANY value");
      }
    }
    if (params.length > 2) {
      // 超过2个参数，报错。
      throw new IllegalArgumentException("cannot have more than 2 params");
    }
    ...
  }
  CallbackInfo info = new CallbackInfo(handlerToEvent);
  // 存储到缓存
  mCallbackMap.put(klass, info);
  ...
  return info;
}

说明：

使用OnLifecycleEvent注解标注方法上，方法要求：方法名称任意，方法参数可无、可1个（必须是LifecycleOwner）、可2个（必须先后是LifecycleOwner、Lifecycle.Event、且event必须是Lifecycle.Event.ON_ANY）。

总结

代码流程：

androidx的Activity和Fragment都实现了LifecycleOwner接口，并getLifecycle方法返回的都是LifecycleRegistry类。

LifecycleRegistry类addObserver方法，会把观察者和状态的包装为ObserverWithState，并添加到mObserverMap集合以记录所有观察者。

如果观察者的状态一直未到达目标状态，则一直循环分发事件，直到相同为止。

分发事件是由ObserverWithState进行分发的，它统一了所有形式的LifecycleObserver，并处理dispatchEvent方法，用转换后的LifecycleEventObserver通知被Lifecycle添加的LifecycleObserver状态改变。

移除观察者
LifecycleRegistry --> removeObserver方法

@Override
public void removeObserver(@NonNull LifecycleObserver observer) {
  // 当mEnforceMainThread为true时，必须是在主线程调用，否则抛出异常
  enforceMainThreadIfNeeded("removeObserver");
  // 从map中移除
  mObserverMap.remove(observer);
}

获取当前状态
LifecycleRegistry --> getCurrentState方法

@NonNull
@Override
public State getCurrentState() {
  return mState;
}

此状态是如何被通知的，它又是如何感知生命周期的，我们一起看生命周期感知。

生命周期感知
Lifecycle是一个生命周期感知的框架，那么它是如何感知Activity或Fragment的生命周期的呢？
Activity
MyActivity继承关系：MyActivity->AppCompatActivity->FragmentActivity->androidx.activity.ComponentActivity->androidx.core.app.ComponentActivity
androidx.activity.ComponentActivity
androidx.activity.ComponentActivity–> onCreate方法

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
  ...
  super.onCreate(savedInstanceState);
  ReportFragment.injectIfNeededIn(this);
  ...
}

androidx.core.app.ComponentActivity
androidx.core.app.ComponentActivity–> onCreate方法

@SuppressLint("RestrictedApi")
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  ReportFragment.injectIfNeededIn(this);
}

说明： androidx.activity.ComponentActivity以及它的父类androidx.core.app.ComponentActivity都调用了ReportFragment.injectIfNeededIn(this)，让其处理当前Activity的事件分发。

LifecycleDispatcher
LifecycleDispatcher类

class LifecycleDispatcher {
  private static AtomicBoolean sInitialized = new AtomicBoolean(false);
  static void init(Context context) {
    if (sInitialized.getAndSet(true)) {
      return;
    }
    ((Application) context.getApplicationContext())
        .registerActivityLifecycleCallbacks(new DispatcherActivityCallback());
  }
  @SuppressWarnings("WeakerAccess")
  @VisibleForTesting
  static class DispatcherActivityCallback extends EmptyActivityLifecycleCallbacks {
    @Override
    public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
      ReportFragment.injectIfNeededIn(activity);
    }
    @Override
    public void onActivityStopped(Activity activity) {
    }
    @Override
    public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
    }
  }
  private LifecycleDispatcher() {
  }
}

说明：

添加依赖androidx.lifecycle:lifecycle-process:XXX库后，内部的startup库（底层ContentProvider）会调用LifecycleDispatcher.init方法进行初始化，然后会注册一个App级别的ActivityLifecycleCallbacks，监听所有Activity的生命周期变化，并在onActivityCreated的时候调用了ReportFragment.injectIfNeededIn(this)让其处理当前Activity的事件分发。

问题：

为什么在App全局内监听了所有的Activity，还要在androidx.activity.ComponentActivity、androidx.core.app.ComponentActivity内调用？

因为可能没依赖androidx.lifecycle:lifecycle-process:XXX库。 2. 为什么在androidx.activity.ComponentActivity内调用了，还要在其父类androidx.core.app.ComponentActivity内调用？因为MyActivity可能直接继承的是父类androidx.core.app.ComponentActivity。 3. 上面问题，会导致同一个Activity调用了多次，那addObserver增加的观察者会不会同一个状态被通知多次？不会，因为在LifecycleRegistry分发的时候，判断了，如果要分发的状态和当前的状态相同，则不操作直接返回，所以不会被被通知多次。 4. 为什么要用Fragment来实现Activity的事件分发？因为Fragment能感知生命周期变化，并且Fragment好在Activity中进行增删，例如MyActivity直接继承Activity，想要此功能，直接在onCreate方法内调用ReportFragment.injectIfNeededIn(this)即可。

ReportFragment
ReportFragment–> injectIfNeededIn方法

public class ReportFragment extends android.app.Fragment {
  public static void injectIfNeededIn(Activity activity) {
    if (Build.VERSION.SDK_INT >= 29) {
      // 29及以上，直接向Activity注册ActivityLifecycleCallbacks。
      LifecycleCallbacks.registerIn(activity);
    }
    // 添加无布局的Fragment，如果之前已经添加，则不再添加。
    android.app.FragmentManager manager = activity.getFragmentManager();
    if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
      manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
      // Hopefully, we are the first to make a transaction.
      manager.executePendingTransactions();
    }
  }   
}

SDK >= 29

@RequiresApi(29)
static class LifecycleCallbacks implements Application.ActivityLifecycleCallbacks {
  static void registerIn(Activity activity) {
    // 注册ActivityLifecycleCallbacks
    activity.registerActivityLifecycleCallbacks(new LifecycleCallbacks());
  }
  @Override
  public void onActivityCreated(@NonNull Activity activity,
      @Nullable Bundle bundle) {
  }
  @Override
  public void onActivityPostCreated(@NonNull Activity activity,
      @Nullable Bundle savedInstanceState) {
    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) {
  }
}

SDK >= 29， Activity会注册一个ActivityLifecycleCallbacks监听此Activity的生命周期变化，会在onCreate、onStart、onResume 方法被调用后， onPause、onStop、onDestroy 方法被调用前分发对应的 Event。同一个Activity可能会注册多个ActivityLifecycleCallbacks，则同一个状态会调用 dispatch(Activity, Lifecycle.Event)多次。
ReportFragment–> dispatch(Activity, Lifecycle.Event)方法

@SuppressWarnings("deprecation")
static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
  // LifecycleRegistryOwner已被弃用
  if (activity instanceof LifecycleRegistryOwner) {
    ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
    return;
  }
  // ComponentActivity已经实现LifecycleOwner，并getLifecycle方法返回的是LifecycleRegistry。
  if (activity instanceof LifecycleOwner) {
    Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
    if (lifecycle instanceof LifecycleRegistry) {
      ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
    }
  }
}

由于ComponentActivity已经实现LifecycleOwner，并getLifecycle方法返回的是LifecycleRegistry，所以我们接下来看一下LifecycleRegistry的handleLifecycleEvent方法。
LifecycleRegistry–> handleLifecycleEvent()方法

public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
  // 当mEnforceMainThread为true时，必须是在主线程调用，否则抛出异常
  enforceMainThreadIfNeeded("handleLifecycleEvent");
  moveToState(event.getTargetState());
}
private void moveToState(State next) {
  if (mState == next) {
    // 如果要设置的状态和当前的状态相同，则直接返回
    return;
  }
  // 记录当前状态
  mState = next;
  if (mHandlingEvent || mAddingObserverCounter != 0) {
    mNewEventOccurred = true;
    // we will figure out what to do on upper level.
    return;
  }
  mHandlingEvent = true;
  sync();
  mHandlingEvent = false;
}

由于moveToState判断了同状态不处理，所以同一个事件多次调用handleLifecycleEvent才不会有问题。我们再来看一下sync方法
LifecycleRegistry–> sync()方法

private void sync() {
  LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
  if (lifecycleOwner == null) {
    throw new IllegalStateException("LifecycleOwner of this LifecycleRegistry is already"
        + "garbage collected. It is too late to change lifecycle state.");
  }
  // 只要未同步，就一直同步。不用if用while的原因，因为同步过程中状态可能改变了。
  while (!isSynced()) {
    mNewEventOccurred = false;
    // no need to check eldest for nullability, because isSynced does it for us.
    if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
      // 小于当前State，调用backwardPass向后。
      backwardPass(lifecycleOwner);
    }
    Map.Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
    if (!mNewEventOccurred && newest != null
        && mState.compareTo(newest.getValue().mState) > 0) {
      // 大于当前State，调用forwardPass向前。
      forwardPass(lifecycleOwner);
    }
  }
  mNewEventOccurred = false;
}

backwardPass和forwardPass类似，我们只看forwardPass。
LifecycleRegistry–> forwardPass()方法

private void forwardPass(LifecycleOwner lifecycleOwner) {
  Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =
      mObserverMap.iteratorWithAdditions();
  // 遍历所有的观察者
  while (ascendingIterator.hasNext() && !mNewEventOccurred) {
    Map.Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();
    ObserverWithState observer = entry.getValue();
    // 依次同步所有的状态
    while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
        && mObserverMap.contains(entry.getKey()))) {
      pushParentState(observer.mState);
      final Event event = Event.upFrom(observer.mState);
      if (event == null) {
        throw new IllegalStateException("no event up from " + observer.mState);
      }
      // 观察者ObserverWithState分发事件，通知被Lifecycle添加的LifecycleObserver状态改变。
      observer.dispatchEvent(lifecycleOwner, event);
      popParentState();
    }
  }
}

至此通过分发事件，被Lifecycle添加的LifecycleObserver也得到了通知。
SDK < 29 SDK < 29， Activity会添加一个无布局的ReportFragment来监听此Activity的生命周期变化，会在对应的生命周期方法里分发对应的 Event。同一个Activity不会添加多个ReportFragment，所以同一个事件不会调用 dispatch( Lifecycle.Event)多次。
ReportFragment–> 生命周期方法

@Override
public void onActivityCreated(Bundle savedInstanceState) {
  super.onActivityCreated(savedInstanceState);
  ...
  dispatch(Lifecycle.Event.ON_CREATE);
}
@Override
public void onStart() {
  super.onStart();
  ...
  dispatch(Lifecycle.Event.ON_START);
}
@Override
public void onResume() {
  super.onResume();
  ...
  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);
  ...
}

ReportFragment–> dispatch(Activity, Lifecycle.Event)方法

private void dispatch(@NonNull Lifecycle.Event event) {
  if (Build.VERSION.SDK_INT < 29) {
    // 仅在SDK 29之前分发，防止重复。
    dispatch(getActivity(), event);
  }
}

由于ReportFragment，在SDK所有版本都有添加，而在SDK >= 29的时候是使用ActivityLifecycleCallbacks处理的分发，所以ReportFragment的分发需要在SDK < 29下，防止重复。
Fragment
androidx.fragment.app.Fragment–> 生命周期方法

public class Fragment implements ComponentCallbacks, OnCreateContextMenuListener, LifecycleOwner,
    ViewModelStoreOwner, HasDefaultViewModelProviderFactory, SavedStateRegistryOwner,
    ActivityResultCaller {
  void performCreate(Bundle savedInstanceState) {
    ...
    mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
  }
  @SuppressWarnings("ConstantConditions")
  void performStart() {
    ...
    mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
    ...
  }
  @SuppressWarnings("ConstantConditions")
  void performResume() {
    ...
    mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
    ...
  }
  @SuppressWarnings("ConstantConditions")
  void performPause() {
    ...
    mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
    ...
  }
  void performStop() {
    ...
    mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
    ...
  }
  void performDestroy() {
    ...
    mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY);
    ...
  }

androidx.fragment.app.Fragment的实现是直接其生命周期方法内调用的handleLifecycleEvent方法进行的分发。
总结

代码流程：

androidx的Activity是使用ReportFragment处理，在其SDK >= 29的时候是使用ActivityLifecycleCallbacks进行的分发，在SDK < 29的时候是使用ReportFragment的生命周期方法进行的分发。

androidx的Fragment是使用androidx Fragment的生命周期方法进行的分发。

分发方法最后会调用LifecycleRegistry类handleLifecycleEvent方法，如果当前的状态和要分发的状态不同，则它会同步所有的观察者。

如果某一个观察者的状态一直未到达目标状态，则一直循环分发事件，直到相同为止。

分发事件是由ObserverWithState进行分发的，它统一了所有形式的LifecycleObserver，并处理dispatchEvent方法，用转换后的LifecycleEventObserver通知被Lifecycle添加的LifecycleObserver状态改变。

总结
以上就是全面的Jetpack-Lifecycle源码了！之后会出Jetpack其它源码系列，请及时关注。如果你有什么问题，大家评论区见！

[Hbase] Jetpack-Lifecycle源码解析

相关帖子

浏览过的版块

nodejs如何查看版本

H5+JS+CSS3实现七夕言情源码分享

在线文字转语音PHP源码

PHP自动发卡系统源码,个人免签支付配安装使用教程

帝国cms汉语字典源码,PC移动端自适应整站源码,自带采集规则

给大家一款很不错的个人博客源码

分享一个小清新自适应宇航员404页面丢失网页模板

HTML实现爱心旋转代码

jQuery实时节气罗盘时钟代码

jQuery创意圆形罗盘时钟代码（二）

PHP小丑 LV3