Jetpack之Lifecycle源码分析

lang_un
164 阅读3分钟

一、最官方的使用方法，不多BB直接上链接

Lifecycle使用简介： developer.android.google.cn/topic/libra…

二、源码分析

1、我们先从最简单的订阅说起：lifecycle.addObserver(observer)

  • lifecycle： 不管是Fragment还是ComponentActivity都实现了一个接口LifecycleOwner，重写了getLifecycle()方法。所以我们在自己的activity和fragment中都可以拿到Lifecycle对象，这也就是我们所说的被观察者。
  • observer： 这个可以是我们写的任意一个类，但是要继承LifecycleObserver或者它的子类DefaultLifecycleObserver，这个类也就是我们所说的观察者。
  • addObserver(): 就是将被观察者和观察者绑定在一起，我们来看下源码，点进去我们看到Lifecycle中addObserver()是一个抽象方法，看它的子类LifecycleRegistry
    • 第一步：创建ObserverWithState对象，并将observer和observer对应的状态存放进去

lifecycle_01.png

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

lifecycle_02.png

    • 第二步：创建LifecycleEventObserver对象，最后返回一个ReflectiveGenericLifecycleObserver(object)对象。

lifecycle_03.png

@NonNull
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);
}
    • 第三步：创建CallbackInfo对象，并将有@OnLifecycleEvent注解的方法保存起来

lifrcycle_04.png

lifecycle_05.png

lifecycle_06.png

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

    Method[] methods = declaredMethods != null ? declaredMethods : getDeclaredMethods(klass);
    boolean hasLifecycleMethods = false;
    for (Method method : methods) {
        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();

        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");
        }
        MethodReference methodReference = new MethodReference(callType, method);
        verifyAndPutHandler(handlerToEvent, methodReference, event, klass);
    }
    CallbackInfo info = new CallbackInfo(handlerToEvent);
    mCallbackMap.put(klass, info);
    mHasLifecycleMethods.put(klass, hasLifecycleMethods);
    return info;
}
    • 第四步：到这里订阅的代码差不多分析完了，那么怎么监听生命周期变化呢

2、监听生命周期变化

  • 1、不管是Fragment还是ComponentActivity都实现了一个接口LifecycleOwner，我们以ComponentActivity为例来分析

lifecycle_07.png

  • 2、在ReportFragment中有着一系列的生命周期的方法，他们方法中都有一个方法dispatch(Lifecycle.Event.ON_*******)
@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;
}
  • 3、在dispatch方法中，会调用LifecycleRegistry的handleLifecycleEvent(event)方法

lifecycle_08.png

lifecycle_09.png

  • 4、看下图：在sync方法中
    • 红框：
      • mState：表示我们自己的fragment或者activity的状态
      • mObserverMap.eldest().getValue().mState：表示当前observer的状态
    • 绿框：
      • mState：表示我们自己的fragment或者activity的状态
      • newest.getValue().mState：表示当前observer的状态

lifecycle_10.png

      • 我们再来看一下状态机的图（copy from 官网） lifecycle-states.svg
      • 在这张图上，States表示observer和activity的状态
public enum State {
    DESTROYED,//onDestroy
    INITIALIZED,//onCreate之前
    CREATED,//onCreate & onStop
    STARTED,//onStart & onPause
    RESUMED;//onResume
}
      • 在这张图上，Events表示fragment或activity的生命周期执行方法
public enum Event {
    ON_CREATE,
    ON_START,
    ON_RESUME,
    ON_PAUSE,
    ON_STOP,
    ON_DESTROY,
    ON_ANY
}
      • 生命周期开始
      • 当我们进入一个页面的时候，observer和activity的状态都是INITIALIZED，
      • activity执行ON_CREATE： activity的状态变为CREATED，这时候CREATED > INITIALIZED，这时候就执行frowardPass(lifecycleOwner)，执行完更新observer的状态为CREATED
      • activity执行ON_START： activity的状态变为STARTED，这时候STARTED > CREATED，这时候就执行frowardPass(lifecycleOwner)，执行完更新observer的状态为STARTED
      • activity执行ON_RESUME： activity的状态变为RESUMED，这时候RESUMED > STARTED，这时候就执行frowardPass(lifecycleOwner)，执行完更新observer的状态为RESUMED
      • activity执行ON_PAUSE： activity的状态变为STARTED，这时候STARTED < RESUMED，这时候就执行backwardPass(lifecycleOwner)，执行完更新observer的状态为STARTED
      • activity执行ON_STOP： activity的状态变为CREATED，这时候CREATED < STARTED，这时候就执行backwardPass(lifecycleOwner)，执行完更新observer的状态为CREATED
      • activity执行ON_DESTROY： activity的状态变为DESTROYED，这时候DESTROYED < CREATED，这时候就执行backwardPass(lifecycleOwner)，执行完更新observer的状态为DESTROYED
      • 生命周期结束

  • 5、接下来看frowardPass(lifecycleOwner)和backwardPass(lifecycleOwner)，这两个逻辑一样，我们看frowardPass(lifecycleOwner)

lifecycle_11.png

lifecycle_12.png

  • 6、在LifecycleObserver中onStateChanged()方法是接口方法，要看实现类中的方法，也就是ReflectiveGenericLifecycleObserver中的onStateChanged()

lifecycle_13.png

lifecycle_14.png

lifecycle_15.png

三、END~

avatar
文章
阅读
粉丝