Lifecycle源码解析

Posted 2022-02-12 涂程

作者：Gs2000

本篇文章只讲解Lifecycle源码，不涉及如何使用。

1、猜想

如果是我们实现Lifecycle的功能，我们会怎么设计？

1. 一定是在生命周期回调的时候，调用了Lifecycle相应的分发方法，把生命周期方法被调用通知给LifecycleObserver。那么Activity或者Fragment作为生命周期的所有者，在他们的生命周期方法中一定有分发的逻辑。
2. Lifecycle一定会有一个集合，用于保存所有的LifecycleObserver。收到生命周期方法被调用的通知后，调用集合中所有LifecycleObserver的对应方法。
3. 应该是通过反射的机制，调用LifecycleObserver的对应方法。

2、入口

既然Activity或者Fragment作为生命周期的所有者，而且是在他们中增加的LifecycleObserver。就把Activity或者Fragment作为我们探索Lifecycle原理的入口。 我们使用Lifecycle，在Activity或者Fragment中一定有如下代码：

getLifecycle().addObserver(new MyLifecycleObserver());

我们进入getLifecycle()方法。注：以Activity中的代码为例。

@NonNull
@Override
public Lifecycle getLifecycle() 
    return mLifecycleRegistry;

这是Activity的父类ComponentActivity中的代码：

getLifecycle()返回的mLifecycleRegistry，直接使用new创建。

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

LifecycleRegistry的构造方法必须传递LifecycleOwner参数。而ComponentActivity已经实现了LifecycleOwner接口，所以可以直接

private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

LifecycleOwner接口很简单，只有一个getLifecycle()抽象方法。

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

所以我们的Activity或者Fragment作为生命周期的所有者，同时也实现了LifecycleOwner接口，通过getLifecycle()方法获取LifecycleRegistry对象，LifecycleRegistry也就是实现生命周期分发的类。

LifecycleRegistry在lifecycle-runtime包中。

3、生命周期事件分发

我们看到Activity的父类ComponentActivity实现了LifecycleOwner接口，并且创建了LifecycleRegistry对象。那么生命周期的分发也应该在ComponentActivity的各个生命周期方法中了吧。可是我们看到ComponentActivity中只复写了一个onCreate()方法，没有其他的生命周期方法。

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) 
    super.onCreate(savedInstanceState);
    mSavedStateRegistryController.performRestore(savedInstanceState);
    ReportFragment.injectIfNeededIn(this);
    if (mContentLayoutId != 0) 
        setContentView(mContentLayoutId);
    

里面有一句代码

ReportFragment.injectIfNeededIn(this);

ReportFragment不是在上面图片中和LifecycleRegistry在lifecycle-runtime包中一起出现了吗。所以ReportFragment一定是为了实现Lifecycle功能。

public static void injectIfNeededIn(Activity activity) 
    // ProcessLifecycleOwner should always correctly work and some activities may not extend
    // FragmentActivity from support lib, so we use framework fragments for activities
    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();
    

injectIfNeededIn()方法很简单，就是创建ReportFragment加入到Activity中。但是他里面有各个生命周期方法，而且都调用了分发方法dispatch()。参数就是我们在自定义LifecycleObserver中给方法加的注释事件。

public class ReportFragment extends Fragment 

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

    @Override
    public void onStart() 
        super.onStart();
        dispatch(Lifecycle.Event.ON_START);
    

    @Override
    public void onResume() 
        super.onResume();
        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);
    

    private void dispatch(Lifecycle.Event event) 
        Activity activity = getActivity();
        if (activity instanceof LifecycleRegistryOwner) 
            ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
            return;
        

        if (activity instanceof LifecycleOwner) 
            Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
            if (lifecycle instanceof LifecycleRegistry) 
                ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
            
        
    

至此，我们找到了生命周期事件的分发方法dispatch(Event event)，方法内部使用LifecycleRegistry的handleLifecycleEvent(event)分发事件。上面我们也说过LifecycleRegistry就是实现生命周期分发的类。
而ReportFragment的作用就是获取生命周期而已，因为Fragment生命周期是依附Activity的。好处就是把这部分逻辑抽离出来，实现Activity的无侵入。如果你对图片加载库Glide比较熟，就会知道它也是使用透明Fragment获取生命周期的。

4、生命周期事件处理

LifecycleRegistry继承自Lifecycle。

public abstract class Lifecycle 
    //添加观察者
    @MainThread
    public abstract void addObserver(@NonNull LifecycleObserver observer);
    //移除观察者
    @MainThread
    public abstract void removeObserver(@NonNull LifecycleObserver observer);
    //获取当前状态
    @MainThread
    @NonNull
    public abstract State getCurrentState();

    //生命周期事件，对应Activity生命周期方法
    public enum Event 
        ON_CREATE,
        ON_START,
        ON_RESUME,
        ON_PAUSE,
        ON_STOP,
        ON_DESTROY,
        //可以响应任意一个事件
        ON_ANY
    

    //生命周期状态. （Event是进入这种状态的事件）
    public enum State 
        DESTROYED,
        INITIALIZED,
        CREATED,
        STARTED,
        RESUMED;

        //判断至少是某一状态
        public boolean isAtLeast(@NonNull State state) 
            return compareTo(state) >= 0;
        
    

Lifecycle使用两种主要枚举跟踪其关联组件的生命周期状态：

• 事件Event
  从框架和Lifecycle类分派的生命周期事件。这些事件映射到 Activity 和 Fragment 中的回调事件。
• 状态State
  由Lifecycle 对象跟踪的组件的当前状态。

Event触发的时机：

• ON_CREATE、ON_START、ON_RESUME事件，是在LifecycleOwner对应的方法执行之后分发。
• ON_PAUSE、ON_STOP、ON_DESTROY事件，是在LifecycleOwner对应的方法调用之前分发。

您可以将状态看作图中的节点，将事件看作这些节点之间的边。
上一节中，我们知道ReportFragment生命周期发生变化时，都会调用LifecycleRegistry中的handleLifecycleEvent()方法。所以我们先看一下handleLifecycleEvent()方法。

//系统自定义的保存Observer的map，可在遍历中增删
private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap =
        new FastSafeIterableMap<>();

//当前LifecycleOwner所处的状态
private State mState;

public void handleLifecycleEvent(@NonNull Event event) 
    State next = getStateAfter(event);//获取event发生之后的将要处于的状态
    this.moveToState(next);//移动到这个状态


//获取event发生之后的将要处于的状态（看前面那张图很好理解）
static State getStateAfter(Event event) 
    switch(event) 
    case ON_CREATE:
    case ON_STOP:
        return State.CREATED;
    case ON_START:
    case ON_PAUSE:
        return State.STARTED;
    case ON_RESUME:
        return State.RESUMED;
    case ON_DESTROY:
        return State.DESTROYED;
    case ON_ANY:
    default:
        throw new IllegalArgumentException("Unexpected event value " + event);
    


//移动到这个状态
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;


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()) //isSynced()意思是 所有观察者都同步完了
        mNewEventOccurred = false;
         //mObserverMap就是 在activity中添加observer后 用于存放observer的map
        if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) 
            backwardPass(lifecycleOwner);
        
        Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
        if (!mNewEventOccurred && newest != null
                && mState.compareTo(newest.getValue().mState) > 0) 
            forwardPass(lifecycleOwner);
        
    
    mNewEventOccurred = false;