Lifecycle

Lifecycle源码

Lifecycle是Google推出的Jetpack组件库中一个非常重要的组件。Lifecycle能够使所有的使用它的组件能够拥有感知Activity/Fragment生命周期的能力。它的使用也非常的简单，就是让组件实现DefaultLifecycleObserver这个接口，然后在Activity中添加：getLifecycle().addObserver(xxx);xxx就表示刚才所实现接口的组件。这样就能够让实现DefaultLifecycleObserver这个接口的组件拥有感知Activity生命周期的能力。

源码

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

这个接口继承了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);

}

这个接口中定义了这些方法，这些方法基本上对应了Activity生命周期中的方法，当Activity这些生命周期被调用的时候，这些对应的方法就会被执行。

getLifecycle()方法

@Override
public Lifecycle getLifecycle() {
    return mLifecycleRegistry;
}

在这返回了LifecycleRegistry对象。然后在onCreate方法中调用了

ReportFragment.injectIfNeededIn(this);

在这创建了一个Fragment，当Activity的生命周期发生变化的时候，这个Fragment的生命周期也会发生变化。以onStart方法为例：

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

在这调用了dispatch方法：最中调用了以下的dispatch方法：

static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
    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);
        }
    }
}

在这里调用了handleLifecycleEvent方法。

先来看一下addObserver()方法。

addObserver()方法

这是一个状态图对应的各个生命周期的状态。

因为上面的getLifecycle()方法返回了一个LifecycleRegistry对象，所以在这里调用的是LifecycleRegistry这个类里面的addObserver方法：

@Override
public void addObserver(@NonNull LifecycleObserver observer) {
    enforceMainThreadIfNeeded("addObserver");
    //判断当前Activity的状态是什么，如果不是DESTROYED，就将其赋值为INITIALIZED（状态和生命周期），所以就算是再onResume中执行addObserver方法，它的状态也是INITIALIZED
    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;
    //根据集合中的前一个Observer状态和宿主的状态与当前Observer应该处于正确的状态mState作min()比较。从这里我们可以得出一个Activity/Fragment可以有多个观察者，每个观察者的状态全部一致
    State targetState = calculateTargetState(observer);
    mAddingObserverCounter++;
    
    //循环判断，如果观察者状态小于目标状态，表示发生生命周期的前进。调用upEvent(State state)计算前进事件。初始化是INITIALIZED状态，发生前进事件，根据前面的图，应该发生ON_CREATE事件。就是小于的情况下。肯定发生生命周期的前进，所以INITIALIZED状态下，下一个事件必然是ON_CREATE事件。然后调用ObserverWithState#dispatchEvent()，通过 getStateAfter(event)来根据事件，判断所处的状态。ON_CREATE事件一定是CREATED状态。接着保存起来newState，调用注册进来的观察者的回调方法mLifecycleObserver.onStateChanged(owner, event)把事件分发出去，然后更新mStatemState = newState，下次循环mState=CREATED还是小于目标状态，upEvent():CREATED-->ON_START，getStateAfter(event)：ON_START-->STARTED，保存状态newState，回调监听onStateChanged，保存状态mState = newState，直到mState = RESUMED
    
    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);
        }
        statefulObserver.dispatchEvent(lifecycleOwner, event);
        popParentState();
        // mState / subling may have been changed recalculate
        targetState = calculateTargetState(observer);
    }

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

经过上面的代码之后就会发现新注册的Observer和宿主同步到相同的生命周期。

然后再来看上面说到调用handleLifecycleEvent方法：

public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
    enforceMainThreadIfNeeded("handleLifecycleEvent");
    moveToState(event.getTargetState());
}

在这调用了moveToState方法：

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方法，这个方法是用来进行同步状态的。

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;
        //这种情况就是：假如观察者为RESUMED状态，此时宿主发生onPase()生命周期，那么宿主会进入STARTED状态。进入生命周期后退过程所以会调用backwardPass(lifecycleOwner)向后传递
        if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
            backwardPass(lifecycleOwner);
        }
        Map.Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
        //这种情况就和上面addObserver的情况一样
        if (!mNewEventOccurred && newest != null
                && mState.compareTo(newest.getValue().mState) > 0) {
            forwardPass(lifecycleOwner);
        }
    }
    mNewEventOccurred = false;
}

在每次状态改变的时候调用了ObserverWithState这个类中的dispatchEvent方法：

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

在这调用了observer的onStateChanged方法，如何去区分调用的到底是那个生命周期的方法呢，是在ObserverWithState类的构造方法中调用了Lifecycling.lifecycleEventObserver(observer);

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

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

在这使用了适配器模式，就是根据实现接口的不同根据每个接口的类型做一个适配器。

以上就是Lifecycle能够实现观察者能够感知Activity的生命周期的原理。