Jetpack组件之Lifecycle的使用与解析

一.使用方式

Lifecycle可以感知Activity和Fragment的生命周期，使用方法如下。

首先新建一个类实现LifecycleObserver接口，该接口不提供任何方法，而是依靠OnLifecycleEvent注解实现生命周期感知。

public class CustomLifeCycle implements LifecycleObserver {
    private String TAG;

    public CustomLifeCycle(String tag) {
        this.TAG = tag;
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public void onCreateMethod(){
        Log.e(TAG, "onCreateMethod: " );
    }
    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    public void onStartMethod(){
        Log.e(TAG, "onStartMethod: " );
    }
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void onResumeMethod(){
        Log.e(TAG, "onResumeMethod: " );
    }
    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void onPauseMethod(){
        Log.e(TAG, "onPauseMethod: " );
    }
    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    public void onStopMethod(){
        Log.e(TAG, "onStopMethod: " );
    }
    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    public void onDestroyMethod(){
        Log.e(TAG, "onDestroyMethod: " );
    }
}

在以上代码中，Lifecycle.Event是一个枚举类，值包括ON_CREATE、ON_START、ON_RESUME、ON_PAUSE、ON_STOP、ON_DESTROY、ON_ANY，分别对应Activity的生命周期。将LifecycleObserver的实现类添加到Activity中：

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        getLifecycle().addObserver(new CustomLifeCycle("MainActivity"));
    }
}

当Activity回调生命周期函数时，与生命周期对应的被OnLifecycleEvent注解修饰的方法会执行。

二.原理分析

1 生命周期事件分发

AppCompatActivity的getLifecycle()方法来自LifecycleOwner接口（LifecycleOwner表示一个类具有生命周期），AppCompatActivity的父类ComponentActivity实现了该接口，ComponentActivity的getLifecycle()得到LifecycleRegistry对象，LifecycleRegistry继承自Lifecycle。

在ComponentActivity的onCreate方法中，执行了ReportFragment.injectIfNeededIn(this)，为ComponentActivity绑定了一个ReportFragment，生命周期事件就是由ReportFragment分发给观察者的。

//ComponentActivity：
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    mSavedStateRegistryController.performRestore(savedInstanceState);
    ReportFragment.injectIfNeededIn(this);
    if (mContentLayoutId != 0) {
        setContentView(mContentLayoutId);
    }
}
//ReportFragment：
public static void injectIfNeededIn(Activity activity) {
    if (Build.VERSION.SDK_INT >= 29) {
        // On API 29+, we can register for the correct Lifecycle callbacks directly
        activity.registerActivityLifecycleCallbacks(new LifecycleCallbacks());
    }
    android.app.FragmentManager manager = activity.getFragmentManager();
    if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
        manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
        // Hopefully, we are the first to make a transaction.
        manager.executePendingTransactions();
    }
}

ReportFragment是如何分发生命周期事件的，以onActivityCreated为例，代码如下：

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

dispatchCreate(mProcessListener)是将事件分发给ProcessLifecycleOwner，ProcessLifecycleOwner针对的是整个应用程序的监听，当应用程序从后台回到前台，或者应用程序首次打开，会依次调用Lifecycle.Event.ON_START，Lifecycle.Event.ON_RESUME。

dispatch(Lifecycle.Event.ON_CREATE)是将事件分发给用户的Activity。在Android 28及以下，分发过程如下。

private void dispatch(@NonNull Lifecycle.Event event) {
    if (Build.VERSION.SDK_INT < 29) {
        dispatch(getActivity(), event);
    }
}
static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
    if (activity instanceof LifecycleRegistryOwner) {
        ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
        return;
    }

    if (activity instanceof LifecycleOwner) {
    //对应ComponentActivity中的LifecycleRegistry
        Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
        if (lifecycle instanceof LifecycleRegistry) {
            ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
        }
    }
}

在Android 29中，分发过程通过LifecycleCallbacks实现,LifecycleCallbacks类中的方法在Activity的生命周期方法中得到调用。

//ReportFragment
public static void injectIfNeededIn(Activity activity) {
    if (Build.VERSION.SDK_INT >= 29) {
        // On API 29+, we can register for the correct Lifecycle callbacks directly
        activity.registerActivityLifecycleCallbacks(new LifecycleCallbacks());
    }
     ...  
}

// ReportFragment.LifecycleCallbacks
static class LifecycleCallbacks implements Application.ActivityLifecycleCallbacks {
    @Override
    public void onActivityCreated(@NonNull Activity activity,
            @Nullable Bundle bundle) {
    }

    @Override
    public void onActivityPostCreated(@NonNull Activity activity,@Nullable Bundle savedInstanceState) {
        dispatch(activity, Lifecycle.Event.ON_CREATE);
    }
	@Override
    public void onActivityStarted(@NonNull Activity activity) {
        }
	@Override
    public void onActivityPostStarted(@NonNull Activity activity) {
        dispatch(activity, Lifecycle.Event.ON_START);
    }
	@Override
    public void onActivityResumed(@NonNull Activity activity) {
    }
	@Override
    public void onActivityPostResumed(@NonNull Activity activity) {
        dispatch(activity, Lifecycle.Event.ON_RESUME);
    }
    @Override
    public void onActivityPrePaused(@NonNull Activity activity) {
        dispatch(activity, Lifecycle.Event.ON_PAUSE);
    }
    @Override
    public void onActivityPaused(@NonNull Activity activity) {
    }
	@Override
    public void onActivityPreStopped(@NonNull Activity activity) {
        dispatch(activity, Lifecycle.Event.ON_STOP);
    }
	@Override
    public void onActivityStopped(@NonNull Activity activity) {
        }
    @Override
    public void onActivitySaveInstanceState(@NonNull Activity activity,@NonNull Bundle bundle) {
    }
	@Override
    public void onActivityPreDestroyed(@NonNull Activity activity) {
        dispatch(activity, Lifecycle.Event.ON_DESTROY);
    }
	@Override
    public void onActivityDestroyed(@NonNull Activity activity) {
    }
}

2 LifecycleRegistry对事件的处理

经过上面的过程，最终来到LifecycleRegistry的handleLifecycleEvent方法，LifecycleRegistry继承自Lifecycle，首先来看Lifecycle的两个枚举类Event和State。

public enum Event {
        
        ON_CREATE,
        
        ON_START,
        
        ON_RESUME,
        
        ON_PAUSE,
        
        ON_STOP,
        
        ON_DESTROY,
        
        ON_ANY
}
public enum State {
        
        DESTROYED,

        
        INITIALIZED,

        
        CREATED,

        
        STARTED,

        
        RESUMED;

        /**
         判断当前状态是否大于等于给定状态
         */
        public boolean isAtLeast(@NonNull State state) {
            return compareTo(state) >= 0;
        }
}

LifecycleRegistry有一个成员变量private State mState，用来表示LifecycleRegistry当前的状态，该状态会随着接收的Event变化，变化过程通过一下方法实现：

//计算当事件发生后，LifecycleRegistry的状态值。
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);
}
//计算状态值的上一个事件
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);
}

通过以上方法可以得出事件与状态的转化关系：

在Activity中执行addObserver方法添加观察者时，执行方法如下：

@Override
public void addObserver(@NonNull LifecycleObserver observer) {
	//设置Observer的初始状态，如果LifecycleRegistry为DESTROYED，则初始状态为DESTROYED，否则为INITIALIZED
    State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
    //把observer封装成ObserverWithState，ObserverWithState中有mState用来表示observer的状态
    ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
    //将statefulObserver添加到mObserverMap
    ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
	//如果statefulObserver之前添加过，不进行后续操作。
	if (previous != null) {
        return;
    }
    LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
    if (lifecycleOwner == null) {
            return;
    }
	boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
    State targetState = calculateTargetState(observer);
    mAddingObserverCounter++;
    //当statefulObserver的状态小于目标状态时，通过分发事件进行状态升级。
    while ((statefulObserver.mState.compareTo(targetState) < 0&& mObserverMap.contains(observer))) {
        pushParentState(statefulObserver.mState);
        //分发事件，此处通过upEvent进行状态的升级
        statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
        popParentState();
        //重新进行目标状态计算
        targetState = calculateTargetState(observer);
    }
    if (!isReentrance) {
        // 对所有Observer进行状态同步
        sync();
    }
    mAddingObserverCounter--;
}

在ReportFragment的生命周期方法中进行事件分发，调用到LifecycleRegistry的handleLifecycleEvent方法，如下：

public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
	//计算事件之后的状态
    State next = getStateAfter(event);
    //迁移到该状态
    moveToState(next);
}

private void moveToState(State next) {
    if (mState == next) {
        return;
    }
    //改变mState的值
    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()方法中进行状态同步时，每进行一次状态改变，会调用一次ObserverWithState的dispatchEvent方法。

static class ObserverWithState {
    State mState;
    LifecycleEventObserver mLifecycleObserver;

    ObserverWithState(LifecycleObserver observer, State initialState) {
    //根据observer的类型生成不同的LifecycleEventObserver对象，具体类型包括FullLifecycleObserverAdapter、SingleGeneratedAdapterObserver、CompositeGeneratedAdaptersObserver、ReflectiveGenericLifecycleObserver。
        mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
        mState = initialState;
    }
    void dispatchEvent(LifecycleOwner owner, Event event) {
        State newState = getStateAfter(event);
        mState = min(mState, newState);
        //在第一节中自定义的CustomLifeCycle实现了LifecycleObserver接口，此处的mLifecycleObserver类型为ReflectiveGenericLifecycleObserver，CustomLifeCycle中的方法通过反射执行。
        mLifecycleObserver.onStateChanged(owner, event);
        mState = newState;
    }
}