jetpack系列———Lifecycle

joychic
666 阅读7分钟

LifecycleOwner ，LifecycleObserver 和 Lifecycle

LifecycleOwner

LifecycleOwner 接口定义说明了某种东西是具有生命周期的。通过getLifecycle()可以返回这个生命周期

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

    @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
    @NonNull
    AtomicReference<Object> mInternalScopeRef = new AtomicReference<>();

    
    @MainThread
    public abstract void addObserver(@NonNull LifecycleObserver observer);

 
    @MainThread
    public abstract void removeObserver(@NonNull LifecycleObserver observer);

    @MainThread
    @NonNull
    public abstract State getCurrentState();

    @SuppressWarnings("WeakerAccess")
    public enum Event {
   
        ON_CREATE,
   
        ON_START,
     
        ON_RESUME,
    
        ON_PAUSE,
    
        ON_STOP,
   
        ON_DESTROY,
     
        ON_ANY
    }


    @SuppressWarnings("WeakerAccess")
    public enum State {
         /**
         * 在此之后，Lifecycle 不会再派发生命周期事件。
         * 以 Activity 为例，此状态在 Activity.onDestroy() 之前
         */
        DESTROYED,

         /**
         * 以 Activity 为例， 在 Activity 已经实例化但未 onCreate() 之前
         */
        INITIALIZED,

         /**
         * 以 Activity 为例，在 Activity 的 onCreate() 之后到 onStop() 之前
         */
        CREATED,

         /**
         * 以 Activity 为例， 在 Activity 的 onStart() 之后到 onPause() 之前
         */
        STARTED,

         /**
         * 以 Activity 为例，在 Activity 的 onResume() 之后
         */
        RESUMED;

        public boolean isAtLeast(@NonNull State state) {
            return compareTo(state) >= 0;
        }
    }
}

Lifecycle 是具体的生命周期对象，它是一个抽象类，定义了三个抽象方法

  • addObserver：增加观察者 LifecycleObserver，观察者可以观察到该生命周期的变化；

  • removeObserver ：移除观察者 LifecycleObserver；

  • getCurrentState ：返回当前生命周期状态；

Lifecycle 内部定义了两个枚举类

  • Event ：生命周期事件，与 LifecycleOwner 的生命周期事件是相对应的；

  • State ：生命周期状态；

LifecycleObserver
 public interface LifecycleObserver {
 
 }

LifecycleObserver 是用来观察生命周期的，它是一个空接口，我们需要自定义一个类来实现 LifecycleObserver 接口。

关系

生命周期组件 LifecycleOwner 在进入特定的生命周期后，发送特定的生命周期事件 Event ，通知 Lifcycle 进入特定的 State ，进而回调生命周期观察者 LifeCycleObserver 的指定方法

官方提供的构成 Android Activity 生命周期的状态和事件图如下：

lifecycle-states

Lifecycle 的典型使用

class MyObserver : LifecycleObserver {

        @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
        fun connectListener() {
            ...
        }

        @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
        fun disconnectListener() {
            ...
        }
    }

 myLifecycleOwner.getLifecycle().addObserver(MyObserver())

在上面的示例中，myLifecycleOwner 对象实现了 LifecycleOwner接口，AppCompatActivity 和 Fragment 都实现了 LifecycleOwner 接口。接下来源码 我们以 Fragment 的为例来做说明。

源码分析篇

/*Fragment.java*/
public Lifecycle getLifecycle() {
    return mLifecycleRegistry;
}

mLifecycleRegistry 是一个 LifecycleRegistry 对象，LifecycleRegistry 继承自 Lifecycle 。也就是说 LifecycleRegistry 就是我们的生命周期对象了。这个 mLifecycleRegistry 是什么时候创建的呢？答案是在 Fragment 的构造函数中通过 initLifecycle 方法注入的。

接下来跟踪 LifecycleRegistry 的 addObserver 方法，mState 对于的状态在 LifecycleRegistry 初始化时候设置为了 INITIALIZED，通过私有方法 moveToState 可以更新 mState 到给定的状态，跟踪 moveToState() 的调用情况，发现只有 setCurrentState() 和 handleLifecycleEvent() 这两个 public 的方法调用到了 moveToState()。 对于Fragment 来说，我们不难猜测到，当 Fragment 生命周期变更的时候，会直接或者间接调用 setCurrentState() 或者 handleLifecycleEvent() 来更新 LifecycleRegistry 中 mState 的状态。

/*LifecycleRegistry.java*/ 
public void addObserver(@NonNull LifecycleObserver observer) {
        //mState 代表当前所处生命周期状态
        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
        // statefulObserver 记录了观察者的初始状态
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
        // mObserverMap 保存了 LifecycleObserver 及其对应的 State
        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;
        // calculateTargetState 计算出的 targetState 一定是小于等于 mState 的
        State targetState = calculateTargetState(observer);
        mAddingObserverCounter++;
        // 如果 statefulObserver 小于 targetState，则需要将 statefulObserver 同步到 targetState
        while ((statefulObserver.mState.compareTo(targetState) < 0
                && mObserverMap.contains(observer))) {
            pushParentState(statefulObserver.mState);
            // 通过 dispatchEvent 方法 使 statefulObserver 的 state 向下一个状态流动
            statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
            popParentState();
            // 重新计算 targetState 是为了消除 mState 状态变更的影响
            targetState = calculateTargetState(observer);
        }

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

calculateTargetState 计算的是当前状态 mState、mObserverMap 中最后一个观察者状态、 ParentState 三者状态的最小值

/*LifecycleRegistry.java*/
private State calculateTargetState(LifecycleObserver observer) {
    Entry<LifecycleObserver, ObserverWithState> previous = mObserverMap.ceil(observer);

    State siblingState = previous != null ? previous.getValue().mState : null;
    State parentState = !mParentStates.isEmpty() ? mParentStates.get(mParentStates.size() - 1)
            : null;
    return min(min(mState, siblingState), parentState);
}

upEvent 获取 state 升级所需要经历的事件，对于首次添加的情况，默认 state 为 INITIALIZED，经过 upEvent 升级后 返回 ON_CREATE。

/*LifecycleRegistry.java*/
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);
}

与 upEvent 对应的是 downEvent，用于 获取 state 降级所需要经历的事件

/*LifecycleRegistry.java*/
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);
}

ObserverWithState 的 dispatchEvent 将事件分发给了 mLifecycleObserver 的 onStateChanged 去处理，mLifecycleObserver 是一个继承了 LifecycleObserver 的 LifecycleEventObserver 类型对象。mLifecycleObserver 会根据我们创建的 LifecycleObserver 类型生成对应类型的 LifecycleEventObserver 对象。

/*LifecycleRegistry.java*/
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;
        }
    }

getStateAfter 的作用是根据 Event 获取事件之后处于的状态，Lifecycling.lifecycleEventObserver(observer) 这句代码中做的事情就是把 LifecycleObserver 转化成 LifecycleEventObserver。

/*LifecycleRegistry.java*/
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);
}

lifecycleEventObserver 主要流程是利用 Adapter 将 LifecycleObserver 转换成 FullLifecycleObserverAdapter 、LifecycleEventObserver 或者 GeneratedAdapterObserver。其中 GeneratedAdapterObserver 根据处理方式又分为 注解 和 反射 两种类型。理论上，使用 FullLifecycleObserverAdapter 和 LifecycleEventObserver 是要比使用 GeneratedAdapterObserver 性能要高的。

/*Lifecycling.java*/
@NonNull
static LifecycleEventObserver lifecycleEventObserver(Object object) {
    boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
    boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
    // 实现了 FullLifecycleObserver 接口的对象，使用FullLifecycleObserverAdapter 构建
    if (isLifecycleEventObserver && isFullLifecycleObserver) {
        return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,
                (LifecycleEventObserver) object);
    }

    if (isFullLifecycleObserver) {
        return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
    }
    // 实现了 LifecycleEventObserver 接口的对象，直接返回该类型的对象
    if (isLifecycleEventObserver) {
        return (LifecycleEventObserver) object;
    }

    // 如果不是 LifecycleEventObserver 或 FullLifecycleObserver 类型，则需要做一些额外处理
    final Class<?> klass = object.getClass();
    // 获取 type 类型，有 REFLECTIVE_CALLBACK 和 GENERATED_CALLBACK 两种，核心函数通过resolveObserverCallbackType 实现
    int type = getObserverConstructorType(klass);
    if (type == GENERATED_CALLBACK) {
         // 通过注解实现的 LifecycleObserver
        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);
    }
    // 通过反射实现的 LifecycleObserver
    return new ReflectiveGenericLifecycleObserver(object);
}

如果我们自定义的 LifecycleObserver 是继承于 DefaultLifecycleObserver ，则生成的 Adapter 为 FullLifecycleObserverAdapter 类型；如果我们自定义的 LifecycleObserver 直接继承于 LifecycleObserver，则生成的 Adapter 为 GeneratedAdapter。

对于 FullLifecycleObserverAdapter 的 onStateChanged 处理情况，

/*FullLifecycleObserverAdapter.java*/
@Override
public void onStateChanged(@NonNull LifecycleOwner source, @NonNull 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);
    }
}

很简单，对于 FullLifecycleObserver 类型的 LifecycleObserver，直接回调了它的接口函数。

对应执行到 getObserverConstructorType 方法的情况，首先对应匿名类，直接返回 REFLECTIVE_CALLBACK ，表示使用反射实现 LifecycleObserver，

/*Lifecycling.java*/
private static int resolveObserverCallbackType(Class<?> klass) {
    // anonymous class bug:35073837 匿名类用反射处理
    if (klass.getCanonicalName() == null) {
        return REFLECTIVE_CALLBACK;
    }

   // 寻找注解生成的 GeneratedAdapter 对象
    Constructor<? extends GeneratedAdapter> constructor = generatedConstructor(klass);
    if (constructor != null) {
        sClassToAdapters.put(klass, Collections
                .<Constructor<? extends GeneratedAdapter>>singletonList(constructor));
        return GENERATED_CALLBACK;
    }

    // hasLifecycleMethods 寻找 OnLifecycleEvent 注解标注的方法，对于没有 GeneratedAdapter 对象但是声明了 @OnLifecycleEvent 情况，hasLifecycleMethods 返回true
    boolean hasLifecycleMethods = ClassesInfoCache.sInstance.hasLifecycleMethods(klass);
    if (hasLifecycleMethods) {
        return REFLECTIVE_CALLBACK;
    }

    // 没有找到 GeneratedAdapter 和 @OnLifecycleEvent 标注的方法， 寻找父类
    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;
}

Events 的注入时机

LifecycleRegistry 内部通过一个 mState 状态来与 Events 同步（与生命周期的状态和事件图对应起来），在两边状态不同步的时候会自动更新状态值到合适的位置，并且会通知具体的 LifecycleObserver 执行相应的动作。

Events 的注入是在 Fragment 的生命周期回调过程中，通过 LifecycleRegistry 的 handleLifecycleEvent 主动注入的。

/*Fragment.java*/
void performCreate(Bundle savedInstanceState) {
    ...
    onCreate(savedInstanceState);
    mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
}
void performStart() {
    ...
    onStart();
    mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
}
void performResume() {
    ...
    onResume();  
    mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
}
void performPause() {
    ...
    mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
    onPause();
}
void performStop() {
    ...
    mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
    onStop();
}
void performDestroy() {
    ...
    mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY);
    onDestroy();
}

/*LifecycleRegistry.java*/
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
    State next = getStateAfter(event);
    moveToState(next);
}

写在最后

最近准备对 jetpack 系列做一些梳理，关于 Lifecycle 当前只是对 一种情况作了简单分析， Lifecycle 中涉及的东西还是挺多的，对 Activity 、Service 甚至进程的生命周期感知处理方式也不尽相同。这里给出 Androidx 源码地址。

由于本人水平有限，文中如果理解不当之处，还望指正。 对其他情况的 Lifecycle ，如果后面 jetpack 其他组件涉及到了再来跟进吧。

avatar
文章
阅读
粉丝