Jetpack-认识Lifecycle

Offer 驾到，掘友接招！我正在参与2022春招打卡活动，点击查看活动详情。

简介

生命周期感知型组件可执行操作来响应另一个组件（如 Activity 和 Fragment）的生命周期状态的变化。这些组件有助于您编写出更有条理且往往更精简的代码，此类代码更易于维护。

上图列了Lifecycle相关联的几个重要类，下面会逐一介绍。

1. Lifecycle是抽象类，存在的意义是感应生命周期，分发给观察者；
2. LifecycleObserver是一个接口，目的是观察生命周期变化；
3. LifecycleRegistry是Lifecycle具体的实现类，具体的操作都是在它内部实现。

Lifecycle类

Lifecycle是一个抽象类，内部包含两个重要的枚举类State和Event。

State表示当前生命周期的状态，Event表示当前生命周期的事件；

State一共有：DESTROYED、CREATED、STARTED、RESUMED和INITIALIZED；

Event一共有：onCreate、OnStart、OnResume、OnPause、OnStop和OnDestroy，可以发现Event和Activity的生命周期基本一致，这样我们就能很好的理解Event的概念。

结合上图我们就可以很清楚的理解Event和State的关系。

Lifecycle类中还有两个重要的方法，addObserver(LifecycleObserver observer)和remove(LifecycleObserver observer)，Observer是一个观察者，用来感应当前生命周期的变化。

LifecycleObserver

LifecycleObserver是一个接口，未提供任何方法，但是Google为我们提供两种较为便捷的接口。

public interface LifecycleObserver {

}
复制代码

光看这个空接口，我们很是一头雾水，怎么就一个接口定义，里面没有任何方法呢，但是我们看了下面的两个接口就会豁然开朗了。

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) {
    }
}
复制代码

DefaultLifecycleObserver继承了FullLifecycleObserver，也为我们提供了6个默认的方法，其实看到这些方法名我们就很清楚这些方法发挥的作用是什么了，几乎和Activity生命周期完全一致，没错，它就是这些生命周期的回调方法，我们可以在对应的生命周期回调中加入自己的逻辑。

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);
}
复制代码

LifecycleEventObserver顾名思义它是对生命周期时间的一个观察，如果有事件改变了就会回调到onStateChanged()方法中，我们可以根据对应的事件加入不同的逻辑。

Google给出的两种默认接口可以让我们更加深入的去理解LifecycleObserver。

LifecycleRegistry

LifecycleRegistry是Lifecycle的实现类，在思维导图中我们可以看到，它的内部维护了两个重要的变量：

• observerMap是一个Map对象，用来保存LifecycleObserver的一个集合；
• LifecycleOwner记录着一个被观察者的对象，通常是Activity或者Fragment。

下面我们从源码着重看看LifecycleRegistry是如何管理Observer对象并且如果分发事件的。

public class LifecycleRegistry extends Lifecycle {

    /**
     * Custom list that keeps observers and can handle removals / additions during traversal.
     *
     * Invariant: at any moment of time for observer1 & observer2:
     * if addition_order(observer1) < addition_order(observer2), then
     * state(observer1) >= state(observer2),
     */
    private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap =
            new FastSafeIterableMap<>();
    
    private final WeakReference<LifecycleOwner> mLifecycleOwner;

    /**
     * 设置当前State，只能在主线程
     * Moves the Lifecycle to the given state and dispatches necessary events to the observers.
     *
     * @param state new state
     */
    @MainThread
    public void setCurrentState(@NonNull State state) {
        enforceMainThreadIfNeeded("setCurrentState");
        moveToState(state);
    }

    /**
     * 处理生命周期事件，根据对应的Event，转换成State，这里主要就是处理Activity生命周期变化
     * Sets the current state and notifies the observers.
     * <p>
     * Note that if the {@code currentState} is the same state as the last call to this method,
     * calling this method has no effect.
     *
     * @param event The event that was received
     */
    public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
        enforceMainThreadIfNeeded("handleLifecycleEvent");
        moveToState(event.getTargetState());
    }

    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;
    }
    
    @Override
    public void addObserver(@NonNull LifecycleObserver observer) {
        enforceMainThreadIfNeeded("addObserver");
        // 设置初始状态
        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
        // 组建ObserverWithState对象
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
        // 将statefulObserver放入observerMap中，如果已经存在直接返回存在的对象
        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);
            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--;
    }
    
    /**
    * 用来同步事件和状态
    */
    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);
            }
            Map.Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
            if (!mNewEventOccurred && newest != null
                    && mState.compareTo(newest.getValue().mState) > 0) {
                forwardPass(lifecycleOwner);
            }
        }
        mNewEventOccurred = false;
    }
    
}
复制代码

addObserver(observer)此方法就是添加一个观察者到Map中，相同的对象只添加一次；

handleLifecycleEvent(event)用来处理Lifecycle.Event，通过sync将当前Map中所有的观察者的State和当前mState同步一致才算结束。

初体验Lifecycle

为了更方便的使用Lifecycle，官方为我们封装了DefaultLifecycleObserver类，用来感知全部的声明周期，接下来我们用简单的例子体验下。

class ObserverActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_observer)
        
        // 添加观察者
        lifecycle.addObserver(MyLifecycleObserver())
    }
}

class MyLifecycleObserver : DefaultLifecycleObserver {
    private val TAG = "MyLifecycleObserver"

    override fun onCreate(owner: LifecycleOwner) {
        super.onCreate(owner)
        Log.d(TAG, "onCreate: ")
    }

    override fun onStart(owner: LifecycleOwner) {
        super.onStart(owner)
        Log.d(TAG, "onStart: ")
    }

    override fun onResume(owner: LifecycleOwner) {
        super.onResume(owner)
        Log.d(TAG, "onResume: ")
    }

    override fun onPause(owner: LifecycleOwner) {
        super.onPause(owner)
        Log.d(TAG, "onPause: ")
    }

    override fun onStop(owner: LifecycleOwner) {
        super.onStop(owner)
        Log.d(TAG, "onStop: ")
    }

    override fun onDestroy(owner: LifecycleOwner) {
        super.onDestroy(owner)
        Log.d(TAG, "onDestroy: ")
    }
}
复制代码

现在我们想要监听一个Activity的声明周期，不必再写一堆监听回调了，只需要继承DefaultLifecycleObserver然后将此对象添加到Activity的Lifecycle对象中，然后在Observer中覆写我们想要监听的生命周期。

Lifecycle如何监听Activity声明周期的

这部分的关键步骤我们需要在ComponentActivity和ReportFragment中找到答案，我们先看入口：

public class ComponentActivity extends androidx.core.app.ComponentActivity implements
        ContextAware,
        LifecycleOwner... {
            
    private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
   
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        // Restore the Saved State first so that it is available to
        // OnContextAvailableListener instances
        mSavedStateRegistryController.performRestore(savedInstanceState);
        mContextAwareHelper.dispatchOnContextAvailable(this);
        super.onCreate(savedInstanceState);
        // 绑定一个空白的Fragment，来感知Activity，这样保证Activity代码不冗余
        ReportFragment.injectIfNeededIn(this);
        if (mContentLayoutId != 0) {
            setContentView(mContentLayoutId);
        }
    }
}
复制代码

到这为止，Activity既和LifecycleRegistry绑定，也和ReportFragment绑定，下面就没有Activity什么事了，我们要的答案都在这个神奇的ReportFragment中。

public class ReportFragment extends android.app.Fragment {

    @SuppressWarnings("deprecation")
    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处理事件
                ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
            }
        }
    }

    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        dispatchCreate(mProcessListener);
        // 分发事件
        dispatch(Lifecycle.Event.ON_CREATE);
    }

......省略其它生命周期

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

    private void dispatch(@NonNull Lifecycle.Event event) {
        if (Build.VERSION.SDK_INT < 29) {
            // Only dispatch events from ReportFragment on API levels prior
            // to API 29. On API 29+, this is handled by the ActivityLifecycleCallbacks
            // added in ReportFragment.injectIfNeededIn
            dispatch(getActivity(), event);
        }
    }
}
复制代码

其实看上面精简的代码，我们就可以一目了然了，在Fragment生命周期中分发不同的Event事件，然后交给LifecycleRegistry来处理这些事件，具体怎么处理我们在介绍LifecycleRegistry中已经提过。

文档

官方文档

Lifecycle版本