LifeCycle初识

LifeCycle的学习笔记

1.LifeCircle定义：

Lifecycle是Android Architecture Components(之后简称AAC)的一个组件，用于将系统组件（Activity、Fragment等等）的生命周期分离到

Lifecycle类，Lifecycle允许其他任意类作为观察者，观察组件生命周期的变化。

如activity中： getLifecycle().addObserver(new MtLifecycleObserver());添加生命周期的观察者,MtLifecycleObserver extends

LifecycleObserver

2.LifecycleOwner: LifeCircle的持有类 activity的父类以及fragment都实现了这个接口

     public class SupportActivity extends Activity implements LifecycleOwner{}
     

     public class Fragment implements ComponentCallbacks, OnCreateContextMenuListener, LifecycleOwner{} 

3.ProcessLifecycleOwnerInitializer：

public class ProcessLifecycleOwnerInitializer extends ContentProvider {} 
该类继承自ContentProvider，在APP应用编译期在\build\intermediates\manifests\full\debug\AndroidManifest.xml
中注册，这是整个生命周期观察分发的入口。那么定位到该类的onCreate方法如下：

@Override
public boolean onCreate() {
    LifecycleDispatcher.init(getContext());
    ProcessLifecycleOwner.init(getContext());
    return true;
}

对LifecycleDispatcher及ProcessLifecycleOwner进行了一个初始化操作。

4.LifecycleDispatcher：该类主要作生命周期的分发，注册生命周期的回调，给每个activity添加一个ReportFragment，给每个fragment添加一个
DestructionReportFragment。

 

static void init(Context context) {
    if (sInitialized.getAndSet(true)) {
        return;
    }
    ((Application) context.getApplicationContext())
            .registerActivityLifecycleCallbacks(new DispatcherActivityCallback());
}

static class DispatcherActivityCallback extends EmptyActivityLifecycleCallbacks {
    private final FragmentCallback mFragmentCallback;

    DispatcherActivityCallback() {
        mFragmentCallback = new FragmentCallback();
    }

    @Override
    public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
        if (activity instanceof FragmentActivity) {
            ((FragmentActivity) activity).getSupportFragmentManager()
                    .registerFragmentLifecycleCallbacks(mFragmentCallback, true);
        }
// 在每个activity类create时候添加一个ReportFragment，
这样activity的生命周期就与该ReportFragment挂钩，之后生命周期的分发操作就基于该类
        ReportFragment.injectIfNeededIn(activity);

    }

    @Override
    public void onActivityStopped(Activity activity) {
        if (activity instanceof FragmentActivity) {
            markState((FragmentActivity) activity, CREATED);
        }
    }

    @Override
    public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
        if (activity instanceof FragmentActivity) {
            markState((FragmentActivity) activity, CREATED);
        }
    }
}

ReportFragment的生命周期方法：

@Override
public void onActivityCreated(Bundle savedInstanceState) {
    super.onActivityCreated(savedInstanceState);
    dispatchCreate(mProcessListener);
    dispatch(Lifecycle.Event.ON_CREATE);
}

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

@Override
public void onResume() {
    super.onResume();
    dispatchResume(mProcessListener);
    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);
    // just want to be sure that we won't leak reference to an activity
    mProcessListener = null;
}
//生命周期分发

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);
        }
    }
}

在ReportFragment各个生命周期方法调用了dispatch分发生命周期，之前提到给activity
添加生命周期的观察者的使用方式----getLifecycle().addObserver(new MtLifecycleObserver())，这里拿AppCompatActivity来讲，

AppCompatActivity的父类supportActivity实现了LifecycleOwner。

依次调用了LifecycleRegistry.handleLifecycleEvent(){}---->sync()--->forwardPass()或者backwardPass()--->ObserverWithState.dispatchEvent()

5.LifecycleRegistry生命周期观察者的管理类

6.ObserverWithState：LifecycleRegistry的内部类，持有对应被观察者(如activity，fragment,service)组件生命周期状态的观察者封装类

static class ObserverWithState {
    State mState;
    GenericLifecycleObserver mLifecycleObserver;

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

    void dispatchEvent(LifecycleOwner owner, Event event) {
        State newState = getStateAfter(event);
        mState = min(mState, newState);
        mLifecycleObserver.onStateChanged(owner, event);
        mState = newState;
    }
}
回到LifeCycle基础使用方法---> getLifecycle().addObserver(new MtLifecycleObserver())，

getLifecycle返回的是我们activity父类中的LifecycleRegistry，我们查看addObserver添加观察者的方法：

   @Override
    public void addObserver(@NonNull LifecycleObserver observer) {
        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
        ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);

        if (previous != null) {
            return;
        }
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        if (lifecycleOwner == null) {
            // it is null we should be destroyed. Fallback quickly
            return;
        }

        boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
        State targetState = calculateTargetState(observer);
        mAddingObserverCounter++;
        while ((statefulObserver.mState.compareTo(targetState) < 0
                && mObserverMap.contains(observer))) {
            pushParentState(statefulObserver.mState);
            statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
            popParentState();
            // mState / subling may have been changed recalculate
            targetState = calculateTargetState(observer);
        }

        if (!isReentrance) {
            // we do sync only on the top level.
            sync();
        }
        mAddingObserverCounter--;
    }

---

 这里是我们自定义的MtLifecycleObserver类 --->最关键的一步获取到注解处理器通过对我们自定义类MtLifecycleObserver的方法注解
OnLifeCycleEvent生成的xxx类。

public class MtLifecycleObserver implements LifecycleObserver {

private static final String TAG = MtLifecycleObserver.class.getSimpleName();

@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
public void onCreate() { Log.d(TAG, "onCreate"); }

@OnLifecycleEvent(Lifecycle.Event.ON_START)
public void onStart() { Log.d(TAG, "onStart"); }

@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
public void onResume() { Log.d(TAG, "onResume"); }

@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
public void onPause() { Log.d(TAG, "onPause"); }

@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
public void onStop() { Log.d(TAG, "onStop"); }

@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
public void onDestroy() { Log.d(TAG, "onDestroy"); }


}

注解处理器生成的类路径为：build\generated\source\apt\debug\com\example\lifecircledemo\MtLifecycleObserver_LifecycleAdapter.java
 

public class MtLifecycleObserver_LifecycleAdapter implements GeneratedAdapter {
  final MtLifecycleObserver mReceiver;

  MtLifecycleObserver_LifecycleAdapter(MtLifecycleObserver receiver) {
    this.mReceiver = receiver;
  }

  /**
   * 当被观察者生命周期state变化时调用
   * @param owner
   * @param event
   * @param onAny
   * @param logger
   */
  @Override
  public void callMethods(LifecycleOwner owner, Lifecycle.Event event, boolean onAny,
      MethodCallsLogger logger) {
    boolean hasLogger = logger != null;
    if (onAny) {
      return;
    }
    if (event == Lifecycle.Event.ON_CREATE) {
      if (!hasLogger || logger.approveCall("onCreate", 1)) {
        mReceiver.onCreate();
      }
      return;
    }
    if (event == Lifecycle.Event.ON_START) {
      if (!hasLogger || logger.approveCall("onStart", 1)) {
        mReceiver.onStart();
      }
      return;
    }
    if (event == Lifecycle.Event.ON_RESUME) {
      if (!hasLogger || logger.approveCall("onResume", 1)) {
        mReceiver.onResume();
      }
      return;
    }
    if (event == Lifecycle.Event.ON_PAUSE) {
      if (!hasLogger || logger.approveCall("onPause", 1)) {
        mReceiver.onPause();
      }
      return;
    }
    if (event == Lifecycle.Event.ON_STOP) {
      if (!hasLogger || logger.approveCall("onStop", 1)) {
        mReceiver.onStop();
      }
      return;
    }
    if (event == Lifecycle.Event.ON_DESTROY) {
      if (!hasLogger || logger.approveCall("onDestroy", 1)) {
        mReceiver.onDestroy();
      }
      return;
    }
  }
}

可以看到在callMethods中MtLifecycleObserver（我们自定义的实现了LifecycleObserver接口的任意观察者类）对各个生命周期进行分发的操作。


 

---

该方法将observer与生命周期状态state封装到ObserverWithState类中，

ObserverWithState构造方法中Lifecycling.getCallback(observer)获取到注解处理器处理我们自定义类MtLifecycleObserver的方法注解

OnLifeCycleEvent生成的xxx类，在ObserverWithState的 dispatchEvent方法中调用GenericLifecycleObserver的onStateChanged

方法将生命周期状态分发给观察者类。

相关资料博客截取的LifeCycle时序图：

作为日常学习笔记学习记录，daydayup!