之前写过Android LifeCycle，presenter实现LifecycleObserver接口观察生命周期变更，接下来以此为例，翻下源码。

Activity中通过lifecycle.addObserver(presenter)进行关联，先看lifecycle。

ComponentActivity implements LifecycleOwner

@Override

public Lifecycle getLifecycle() {

return mLifecycleRegistry;

}

LifecycleRegistry extends Lifecycle 是Lifecycle的实现类，getLifecycle()方法所在类ComponentActivity

此处ComponentActivity为androidx.activity.ComponentActivity

public class ComponentActivity extends androidx.core.app.ComponentActivity

androidx.core.app.ComponentActivity

@Override

protected void onCreate(@Nullable Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

ReportFragment.injectIfNeededIn(this);

}

这里带上包名，因为两个activity名称相同=。=

ReportFragment.injectIfNeededIn()

public static void injectIfNeededIn(Activity activity) {

// ProcessLifecycleOwner should always correctly work and some activities may not extend

// FragmentActivity from support lib, so we use framework fragments for activities

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

}

}

生成ReportFragment并添加到当前Acitivity--->androidx.core.app.ComponentActivity

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;

}

在对应生命周期调用dispatch()方法

ReportFragment.dispatch()

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

}

}

}

Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle()，此处getLifecycle()调用androidx.activity.ComponentActivity实现方法，对应本文例子中Activity.getLifecycle()， ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event)通过LifecycleRegistry分发对应生命周期事件Lifecycle.Event。

LifecycleRegistry.handleLifecycleEvent()

public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {

State next = getStateAfter(event);

moveToState(next);

}

LifecycleRegistry.getStateAfter(event)

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

}

合并某些生命周期状态并返回State，LifecycleRegistry.moveToState(next)

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;

}

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.");

}

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) {

backwardPass(lifecycleOwner);

}

Entry newest = mObserverMap.newest();

if (!mNewEventOccurred && newest != null

&& mState.compareTo(newest.getValue().mState) > 0) {

forwardPass(lifecycleOwner);

}

}

mNewEventOccurred = false;

}

forwardPass(lifecycleOwner)、backwardPass(lifecycleOwner)

private void forwardPass(LifecycleOwner lifecycleOwner) {

Iterator> ascendingIterator =

mObserverMap.iteratorWithAdditions();

while (ascendingIterator.hasNext() && !mNewEventOccurred) {

Entry entry = ascendingIterator.next();

ObserverWithState observer = entry.getValue();

while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred

&& mObserverMap.contains(entry.getKey()))) {

pushParentState(observer.mState);

observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));

popParentState();

}

}

}

private void backwardPass(LifecycleOwner lifecycleOwner) {

Iterator> descendingIterator =

mObserverMap.descendingIterator();

while (descendingIterator.hasNext() && !mNewEventOccurred) {

Entry entry = descendingIterator.next();

ObserverWithState observer = entry.getValue();

while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred

&& mObserverMap.contains(entry.getKey()))) {

Event event = downEvent(observer.mState);

pushParentState(getStateAfter(event));

observer.dispatchEvent(lifecycleOwner, event);

popParentState();

}

}

}

迭代mObserverMap取到LifecycleObserver包装类调用ObserverWithState.dispatchEvent()

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;

}

}

回看lifecycle.addObserver(presenter)->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);

...

}

LifecycleObserver最终包装成LifecycleEventObserver，回调LifecycleEventObserver.onStateChanged()

mLifecycleObserver = 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> 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);

}

FullLifecycleObserverAdapter

LifecycleEventObserver

SingleGeneratedAdapterObserver

CompositeGeneratedAdaptersObserver

ReflectiveGenericLifecycleObserver

通过以上实现类执行onStateChanged()

FullLifecycleObserverAdapter

@Override

public void onStateChanged(LifecycleOwner source, 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);

}

}

//观察所有生命周期

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

}

LifecycleEventObserver

//通过event判断对应生命周期事件

public interface LifecycleEventObserver extends LifecycleObserver {

void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event);

}

SingleGeneratedAdapterObserver、CompositeGeneratedAdaptersObserver注解方法APT生成，本文例子presenter走此流程。

ReflectiveGenericLifecycleObserver反射调用

原理比较清晰：Activity/Fragment实现LifecycleOwner接口，通过LifecycleRegistry在对应生命周期分发事件Lifecycle.Event，回调到生命周期观察者LifecycleObserver对应订阅方法。