Lifecycle 生命周期

1. Lifecycle

抽象类，定义了Event及State, 以及添加和移除Observer的接口

2.1 Event & State

• Event对应生命周期事件

  

  • getTargetState

    获取事件发生后进入的状态

  • upTo & downTo

    正向和反向到达指定状态需要的事件 (对照状态和事件变化的图)

  • upFrom & downFrom

    从指定状态出发进入下一个状态(正向和反向)需要的事件

• State对应生命周期状态

  

  • isAtLeast(State)

    当前状态是否则少为 State 指定的状态, 很多时候需要至少在组件 STARTED 的状态下才工作

2.2 LifecycleRegistry

Lifecycle的实现类，实现了Lifecycle的抽象方法，同时在handleLifecycleEvent方法中完成了在事件来到时对所有Observer的状态同步和调用。

2.2.1 LifecycleObserver

标记接口, 实现了该接口的类可以内注册为生命周期的观察者

2.2.2 ObserverWithState

• LifecycleEventObserver 对LifecycleObserver接口的拓展，当生命周期发生变化时调用onStateChanged方法

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

• ObserverWithState 对生命周期观察者和生命周期状态的封装，在LifecycleRegistry的addObserver的是现在中会将LifecycleObserver封装成ObserverWithState

static class ObserverWithState {
    State mState; // 生命周期状态
    LifecycleEventObserver mLifecycleObserver; // 生命周期观察者

    ObserverWithState(LifecycleObserver observer, State initialState) {
        mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
        mState = initialState;
    }

    void dispatchEvent(LifecycleOwner owner, Event event) {
        State newState = getStateAfter(event);
        mState = min(mState, newState);
        mLifecycleObserver.onStateChanged(owner, event);
        mState = newState;
    }
}

• LifecycleEventObserver实例的获取
  Lifecycling.lifecycleEventObserver(observer)

  static LifecycleEventObserver lifecycleEventObserver(Object object) {
      // 这两个条件一般都不符合
      boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
      boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
      if (isLifecycleEventObserver && isFullLifecycleObserver) {
          return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,
                  (LifecycleEventObserver) object);
      }
      if (isFullLifecycleObserver) {
          return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
      }
  
      if (isLifecycleEventObserver) {
          return (LifecycleEventObserver) object;
      }
      final Class<?> klass = object.getClass();
      int type = getObserverConstructorType(klass);
      if (type == GENERATED_CALLBACK) {
          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);
      }
      // 一般返回的是这个类型
      return new ReflectiveGenericLifecycleObserver(object);
  }
  

• ReflectiveGenericLifecycleObserver
  实现LifecycleEventObserver接口，一般我们都过注解写的生命周期处理方法都会包装成该类，最后执行到对应方法。

  class ReflectiveGenericLifecycleObserver implements LifecycleEventObserver {
      private final Object mWrapped;
      private final CallbackInfo mInfo;
  
      ReflectiveGenericLifecycleObserver(Object wrapped) {
          mWrapped = wrapped;
          mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());
      }
  
      @Override
      public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Event event) {
          mInfo.invokeCallbacks(source, event, mWrapped);
      }
  }
  

2.2.3 handleLifecycleEvent

具有生命周期的对象(LifecycleOwner)，如Activity和Fragment，其内部会持有一个Lifecycle的实例，该实例维护了一组生命周期观察者，在组件生命周期发生变化时，Lifecycle会对生命周期观察者的相应方法进行调用。LifecycleOwner的生命周期事件如何传递到Lifecycle实例会在下面分析，这里这要知道生命周期发生变更后会调用到对应Lifecycle实例的handleLifecycleEvent方法进行处理。

• handleLifecycleEvent

  public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
      // 当前状态的下一个状态
      State next = getStateAfter(event);
      // 移动到新的状态
      moveToState(next);
  }
  
  
  static State getStateAfter(Event event) {
      switch (event) {
          case ON_CREATE:
          case ON_STOP:
              return CREATED;
          case ON_START:
          case ON_PAUSE:
              return STARTED;
          case ON_RESUME:
              return RESUMED;
          case ON_DESTROY:
              return DESTROYED;
          case ON_ANY:
              break;
      }
      throw new IllegalArgumentException("Unexpected event value " + event);
  }
  
  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;
  }
  

• sync 同步状态
  同步mState和ObserverWithState的状态
  

  生命周期状态的变化参考上图有上下两条路线, 上面从CREATED到RESUMED, 下面从RESUMED回到CREATED在进入DESTROYED

  同步操作主要有两个判断

  1. Lifecycle实例的mState < 最早的Observer的mState

     由于Lifecycle实例的mState是领先的(它的状态先变化再去同步Observer的mState)，因此这种情况出现在下面那条路线中，走backwardPass方法。

  2. Lifecycle实例的mState > 最新的Observer的mStat

     上面那条路线，走forwardPass方法。

  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.");
      }
      while (!isSynced()) {
          mNewEventOccurred = false;
          // 1) 
          if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
              backwardPass(lifecycleOwner);
          }
          // 2) 
          Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
          if (!mNewEventOccurred && newest != null
                  && mState.compareTo(newest.getValue().mState) > 0) {
              forwardPass(lifecycleOwner);
          }
      }
      mNewEventOccurred = false;
  }
  
  // 判断状态是否已经同步了
  private boolean isSynced() {
      if (mObserverMap.size() == 0) {
          return true;
      }
      // 获取列表中最早和最新的两个观察者
      State eldestObserverState = mObserverMap.eldest().getValue().mState;
      State newestObserverState = mObserverMap.newest().getValue().mState;
      // 如果最早和最新的两个观察者的状态一直说明已经同步了
      return eldestObserverState == newestObserverState && mState == newestObserverState;
  }
  

2. LifecycleOwner

LifecycleOwner是一个接口，表示持有生命周期实例的组件，如Activity和Fragment，提供getLifecycle方法用来返回一个Lifecycle的实例。对于Activity来说，它在ComponentActivity中实现了该接口。

public interface LifecycleOwner {
    Lifecycle getLifecycle();
}

2.1 ComponentActivity

实现了LifecycleOwner接口, 返回一个LifecycleRegistry实例。在onCreate生命周期方法中调用ReportFragment.injectIfNeededIn(this)，使用ReportFragment来完成生命周期的监听。

2.2 ReportFragment

监听Activity的生命周期，并进行对应的处理

以onActivityCreated方法为例，其他方法类似：

@Override
public void onActivityCreated(Bundle savedInstanceState) {
    super.onActivityCreated(savedInstanceState);
    dispatchCreate(mProcessListener); // 给Application用的暂时不用管
    dispatch(Lifecycle.Event.ON_CREATE);
}

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) {
            // 进入到上面所说的handleLifecycleEvent方法里面
            ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
        }
    }
}

3. ProcessLifecycleOwner

提供应用程序进程的生命周期，可以用来监控应用的前后台切换。

参考

• 使用生命周期感知型组件处理生命周期
• “终于懂了“系列：Jetpack AAC完整解析（一）Lifecycle 完全掌握！