Jetpack 之 Lifecycles 原始碼分析

阿新 • • 發佈：2020-06-24

LifecycleOwner

LifecycleOwner 是單一方法介面，實現此介面表明此類具有生命週期 Lifecycle。

public interface LifecycleOwner {
    /**
     * Returns the Lifecycle of the provider.
     *
     * @return The lifecycle of the provider.
     */
    @NonNull
    Lifecycle getLifecycle();
}

複製程式碼

LifecycleObserver

LifecycleObserver

，實現此介面的類，可以觀察 LifecycleOwner 的生命週期 Lifecycle 狀態。

public interface LifecycleObserver {

}
複製程式碼

這裡瞭解一下它的幾個常用實現類。

FullLifecycleObserver

實現了 LifecycleObserver，定義了一些常用的生命週期事件回撥。

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

實現了 LifecycleObserver，暴露生命週期變更時的回撥。

public interface LifecycleEventObserver extends LifecycleObserver 
 {
    /**
     * Called when a state transition event happens.
     *
     * @param source The source of the event
     * @param event The event
     */
    void onStateChanged(@NonNull LifecycleOwner source,@NonNull Lifecycle.Event event);
}
複製程式碼

ReflectiveGenericLifecycleObserver

實現了 LifecycleObserver。在構造器中，會通過反射將使用了 OnLifecycleEvent 註解的方法儲存到 Map 中，當生命週期變動的時候，通過反射呼叫對應的方法。

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(LifecycleOwner source,Event event) {
        mInfo.invokeCallbacks(source,event,mWrapped);
    }
}
複製程式碼

構造器裡面接受一個 LifecycleObserver，然後所有的解析邏輯實際上都是 ClassesInfoCache完成的。

ClassesInfoCache

通過反射解析和存放使用了 OnLifecycleEvent 的方法，方便生命週期變動的時候回撥對應的方法。

CallbackInfo getInfo(Class klass) {
    CallbackInfo existing = mCallbackMap.get(klass);
    // 已經存在，直接返回快取的
    if (existing != null) {
        return existing;
    }
    // 解析
    existing = createInfo(klass,null);
    return existing;
}
複製程式碼

解析的過程主要是發生在 createInfo() 裡面，我們來看看這個方法。

private CallbackInfo createInfo(Class klass,@Nullable Method[] declaredMethods) {
    // 解析父類
    Class superclass = klass.getSuperclass();
    Map<MethodReference,Lifecycle.Event> handlerToEvent = new HashMap<>();
    if (superclass != null) {
        CallbackInfo superInfo = getInfo(superclass);
        if (superInfo != null) {
            handlerToEvent.putAll(superInfo.mHandlerToEvent);
        }
    }

    // 解析父介面
    Class[] interfaces = klass.getInterfaces();
    for (Class intrfc : interfaces) {
        for (Map.Entry<MethodReference,Lifecycle.Event> entry : getInfo(
                intrfc).mHandlerToEvent.entrySet()) {
            verifyAndPutHandler(handlerToEvent,entry.getKey(),entry.getValue(),klass);
        }
    }

    // 開始解析自身
    
    // 1. 獲取所有宣告的方法
    Method[] methods = declaredMethods != null ? declaredMethods : getDeclaredMethods(klass);
    boolean hasLifecycleMethods = false;
    for (Method method : methods) {
        // 2. 找到所有使用了 OnLifecycleEvent 註解的方法
        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;
            if (!params[0].isAssignableFrom(LifecycleOwner.class)) {
                throw new IllegalArgumentException(
                        "invalid parameter type. Must be one and instanceof LifecycleOwner");
            }
        }
        Lifecycle.Event event = annotation.value();

        // 這裡是確定引數，除了ON_ANY事件可以接收兩個引數，其他事件只能接收一個LifecycleOwner引數
        if (params.length > 1) {
            callType = CALL_TYPE_PROVIDER_WITH_EVENT;
            if (!params[1].isAssignableFrom(Lifecycle.Event.class)) {
                throw new IllegalArgumentException(
                        "invalid parameter type. second arg must be an event");
            }
            if (event != Lifecycle.Event.ON_ANY) {
                throw new IllegalArgumentException(
                        "Second arg is supported only for ON_ANY value");
            }
        }
        if (params.length > 2) {
            throw new IllegalArgumentException("cannot have more than 2 params");
        }
        
        // 3. 儲存對應關係
        MethodReference methodReference = new MethodReference(callType,method);
        verifyAndPutHandler(handlerToEvent,methodReference,klass);
    }
    CallbackInfo info = new CallbackInfo(handlerToEvent);
    mCallbackMap.put(klass,info);
    mHasLifecycleMethods.put(klass,hasLifecycleMethods);
    return info;
}
複製程式碼

Lifecycle

Lifecycle 用於儲存有關元件（如 Activity 或 Fragment）的生命週期狀態的資訊，並允許其他物件觀察此狀態。

Lifecyce.State

Lifecycle.State 標記元件生命週期狀態。

public enum State {
    // 標記 LifecycleOwner 是 DESTROYED 狀態，這個狀態之後，不會再分發任何事件。比如 Activity.onDestroy() 已經呼叫了。
    DESTROYED,// 標記 LifecycleOwner 是 INITIALIZED 狀態。比如 Activity 已經建立，但是還沒有走到 onCreate()。
    INITIALIZED,// 標記 LifecycleOwner 是 CREATED 狀態。比如 Activity.onCreate() 或 Activity.onStop()。
    CREATED,// 標記 LifecycleOwner 是 STARTED 狀態。比如 Activity.onStart() 或者 Activity.onPause()。
    STARTED,// 標記 LifecycleOwner 是 RESUMED 狀態。比如 Activity.onResume()。
    RESUMED;

    public boolean isAtLeast(@NonNull State state) {
        return compareTo(state) >= 0;
    }
}
複製程式碼

Lifecycle.Event

Lifecycle.Event 是分發的生命週期事件，對應元件一系列生命週期回撥。

public enum Event {
    ON_CREATE,ON_START,ON_RESUME,ON_PAUSE,ON_STOP,ON_DESTROY,ON_ANY
}
複製程式碼

ON_CREATE,ON_RESUME 這三個事件是 LifecycleOwner 對應的生命週期方法返回之後被分發的；ON_PAUSE,ON_DESTROY 這三個事件是在 LifecycleOwner 對應的生命週期事件呼叫之前被分發的。

下圖顯示了 Event 與 State 之間的關係。

LifecycleRegistry

LifecycleRegistry 是 Lifecycle 的實現類。

前面說了，Lifecycle 用來存放元件生命週期狀態，且允許其他物件觀察此狀態。那麼裡面必然會存放 LifecycleOwner 和 Lifecycle.State ，並提供新增/移除 LifecycleObserver 的方法。

private State mState;

private final WeakReference<LifecycleOwner> mLifecycleOwner;

public LifecycleRegistry(@NonNull LifecycleOwner provider) {
    mLifecycleOwner = new WeakReference<>(provider);
    mState = INITIALIZED;
}

// 用來存放 LifecycleObserver
private FastSafeIterableMap<LifecycleObserver,ObserverWithState> mObserverMap =
            new FastSafeIterableMap<>();

@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);
    // 已經被在 mObserverMap 裡面了
    if (previous != null) {
        return;
    }
    
    LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
    if (lifecycleOwner == null) {
        return;
    }

    boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
    State targetState = calculateTargetState(observer);
    mAddingObserverCounter++;
    // 保證給新增加的 LifecycleObserver 分發對應的 Lifecycle.Event 讓其到達最新的狀態
    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) {
        sync();
    }
    mAddingObserverCounter--;
}

@Override
public void removeObserver(@NonNull LifecycleObserver observer) {
    mObserverMap.remove(observer);
}
複製程式碼

這裡需要注意一下 ObserverWithState，這個類是 LifecycleRegistry 的內部類，他在構造器中對 LifecycleObserver 進行了一次轉換。

ObserverWithState(LifecycleObserver observer,State initialState) {
    // 這裡通過 Lifecycling.lifecycleEventObserver()進行一次轉換
    mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
    mState = initialState;
}
複製程式碼

我們來看一下 Lifecycling.lifecycleEventObserver()。

static LifecycleEventObserver lifecycleEventObserver(Object object) {
    boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
    boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
    // 1. 如果是 LifecycleEventObserver，FullLifecycleObserver 則返回 FullLifecycleObserverAdapter
    if (isLifecycleEventObserver && isFullLifecycleObserver) {
        return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,(LifecycleEventObserver) object);
    }
    // 2. 如果是 FullLifecycleObserver 則返回 FullLifecycleObserverAdapter
    if (isFullLifecycleObserver) {
        return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,null);
    }

    // 3. 如果是 LifecycleEventObserver 直接返回
    if (isLifecycleEventObserver) {
        return (LifecycleEventObserver) object;
    }

    // 4. 不是上面的情況，需要通過 getObserverConstructorType() 決定
    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);
}
複製程式碼

這個方法對 LifecycleObserver 進行了如下轉換。

如果是 LifecycleEventObserver 和 FullLifecycleObserver，則轉換成 FullLifecycleObserverAdapter；
如果是 FullLifecycleObserver ，則轉換成 FullLifecycleObserverAdapter；
如果是 LifecycleEventObserver ，直接返回；
如果 getObserverConstructorType() 是 GENERATED_CALLBACK，則轉換成對應的 GeneratedAdapterObserver；
其他情況則轉換成 ReflectiveGenericLifecycleObserver。

這裡主要分析一下 getObserverConstructorType() 這個方法，其他的幾種情況都比較簡單，可以自行檢視原始碼，這裡就不贅述了。

private static int getObserverConstructorType(Class<?> klass) {
    // 快取有，直接返回快取裡面的
    Integer callbackCache = sCallbackCache.get(klass);
    if (callbackCache != null) {
        return callbackCache;
    }
    // 這裡呼叫了 resolveObserverCallbackType()
    int type = resolveObserverCallbackType(klass);
    sCallbackCache.put(klass,type);
    return type;
}
複製程式碼

這個方法呼叫了 resolveObserverCallbackType() 來解析 callBack 型別。

private static int resolveObserverCallbackType(Class<?> klass) {
    // anonymous class bug:35073837
    if (klass.getCanonicalName() == null) {
        return REFLECTIVE_CALLBACK;
    }

    // 1. generatedConstructor() 獲取構造器
    Constructor<? extends GeneratedAdapter> constructor = generatedConstructor(klass);
    if (constructor != null) {
        sClassToAdapters.put(klass,Collections
                .<Constructor<? extends GeneratedAdapter>>singletonList(constructor));
        return GENERATED_CALLBACK;
    }

    // 2. 使用了 OnLifecycleEvent 註解的
    boolean hasLifecycleMethods = ClassesInfoCache.sInstance.hasLifecycleMethods(klass);
    if (hasLifecycleMethods) {
        return REFLECTIVE_CALLBACK;
    }

    // 3. 遞迴看父類
    Class<?> superclass = klass.getSuperclass();
    List<Constructor<? extends GeneratedAdapter>> adapterConstructors = null;
    if (isLifecycleParent(superclass)) {
        if (getObserverConstructorType(superclass) == REFLECTIVE_CALLBACK) {
            return REFLECTIVE_CALLBACK;
        }
        adapterConstructors = new ArrayList<>(sClassToAdapters.get(superclass));
    }

    // 遞迴看父介面
    for (Class<?> intrface : klass.getInterfaces()) {
        if (!isLifecycleParent(intrface)) {
            continue;
        }
        if (getObserverConstructorType(intrface) == REFLECTIVE_CALLBACK) {
            return REFLECTIVE_CALLBACK;
        }
        if (adapterConstructors == null) {
            adapterConstructors = new ArrayList<>();
        }
        adapterConstructors.addAll(sClassToAdapters.get(intrface));
    }
    if (adapterConstructors != null) {
        sClassToAdapters.put(klass,adapterConstructors);
        return GENERATED_CALLBACK;
    }

    return REFLECTIVE_CALLBACK;
}
複製程式碼

這裡我們主要看下返回 GENERATED_CALLBACK 的情況，它通過 generatedConstructor() 獲取構造器。

private static Constructor<? extends GeneratedAdapter> generatedConstructor(Class<?> klass) {
    try {
        Package aPackage = klass.getPackage();
        String name = klass.getCanonicalName();
        final String fullPackage = aPackage != null ? aPackage.getName() : "";
        final String adapterName = getAdapterName(fullPackage.isEmpty() ? name :
                name.substring(fullPackage.length() + 1));

        @SuppressWarnings("unchecked") final Class<? extends GeneratedAdapter> aClass =
                (Class<? extends GeneratedAdapter>) Class.forName(
                        fullPackage.isEmpty() ? adapterName : fullPackage + "." + adapterName);
        Constructor<? extends GeneratedAdapter> constructor =
                aClass.getDeclaredConstructor(klass);
        if (!constructor.isAccessible()) {
            constructor.setAccessible(true);
        }
        return constructor;
    } catch (ClassNotFoundException e) {
        return null;
    } catch (NoSuchMethodException e) {
        // this should not happen
        throw new RuntimeException(e);
    }
}
複製程式碼

這個程式碼看著就很奇怪，我們沒有去定義一個 xxx_LifecycleAdapter 的類，這是哪來的？這個比較有意思，它是 apt 在編譯的時候自動生成的，我們可以在 build/generated/source/kapt 下面找到。

這裡我們看一下定義的 LifecycleObserver 和它的生成類。

// 我們定義的 LifecycleObserver
class LifecycleObserverA
    : LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun onCreate(owner: LifecycleOwner) {
    }

}

// apt 的生成類
public class LifecycleObserverA_LifecycleAdapter implements GeneratedAdapter {
  final LifecycleObserverA mReceiver;

  LifecycleObserverA_LifecycleAdapter(LifecycleObserverA receiver) {
    this.mReceiver = receiver;
  }

  @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",2)) {
        mReceiver.onCreate(owner);
      }
      return;
    }
  }
}
複製程式碼

分析完這個過程，我們回到 LifecycleRegistry，

狀態同步

當 LifecycleOwner 的生命週期狀態發生變化的時候，LifecycleRegistry 主要是通過 sync() 方法來給 LifecycleObserver 進行狀態同步的。

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;
        // LifecycleOwner 狀態 比 LifecycleObserver 對應的狀態小，則同步 LifecycleObserver downEvent()
        if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
            backwardPass(lifecycleOwner);
        }
        Entry<LifecycleObserver,ObserverWithState> newest = mObserverMap.newest();
        // LifecycleOwner 狀態比 LifecycleObserver 對應的狀態大，則同步 LifecycleObserver upEvent()
        if (!mNewEventOccurred && newest != null
                && mState.compareTo(newest.getValue().mState) > 0) {
            forwardPass(lifecycleOwner);
        }
    }
    mNewEventOccurred = false;
}

// 當 LifecycleOwner 裡面存在狀態與 mState 不一致，或者 LifecycleOwner 之間存在狀態不一致的時候，需要進行狀態同步
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;
}
複製程式碼

isSynced() 方法決定了是否需要進行狀態同步。然後在 while 迴圈裡面，通過 LifecycleOwner 和 LifecycleObserver 狀態的比較，決定是應該走 backwardPass()，還是 forwardPass()。backwardPass() 和 forwardPass() 方法也比較簡單，就是遍歷所有的 LifecycleObserver ，然後進行一層層的事件分發，直到 LifecycleObserver 的狀態和 LifecycleOwner 的狀態平齊。

private void forwardPass(LifecycleOwner lifecycleOwner) {
    Iterator<Entry<LifecycleObserver,ObserverWithState>> ascendingIterator =
            mObserverMap.iteratorWithAdditions();
    while (ascendingIterator.hasNext() && !mNewEventOccurred) {
        Entry<LifecycleObserver,ObserverWithState> entry = ascendingIterator.next();
        ObserverWithState observer = entry.getValue();
        while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
                && mObserverMap.contains(entry.getKey()))) {
            pushParentState(observer.mState);
            // 分發 upEvent()
            observer.dispatchEvent(lifecycleOwner,upEvent(observer.mState));
            popParentState();
        }
    }
}

private void backwardPass(LifecycleOwner lifecycleOwner) {
    Iterator<Entry<LifecycleObserver,ObserverWithState>> descendingIterator =
            mObserverMap.descendingIterator();
    while (descendingIterator.hasNext() && !mNewEventOccurred) {
        Entry<LifecycleObserver,ObserverWithState> 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));
            // 分發 downEvent()
            observer.dispatchEvent(lifecycleOwner,event);
            popParentState();
        }
    }
}

private static Event downEvent(State state) {
    switch (state) {
        case INITIALIZED:
            throw new IllegalArgumentException();
        case CREATED:
            return ON_DESTROY;
        case STARTED:
            return ON_STOP;
        case RESUMED:
            return ON_PAUSE;
        case DESTROYED:
            throw new IllegalArgumentException();
    }
    throw new IllegalArgumentException("Unexpected state value " + state);
}

private static Event upEvent(State state) {
    switch (state) {
        case INITIALIZED:
        case DESTROYED:
            return ON_CREATE;
        case CREATED:
            return ON_START;
        case STARTED:
            return ON_RESUME;
        case RESUMED:
            throw new IllegalArgumentException();
    }
    throw new IllegalArgumentException("Unexpected state value " + state);
}
複製程式碼