jetpack分析1:lifecycle分析

59 阅读2分钟

问题思考

  1. 为啥lifecycle能感知生命周期呢
  2. 新增的生命周期观察者是如何监听生命周期的

状态和事件图解

image.png lifecycle重点是它的事件和状态的理解,根据上面的图理解下状态和事件的一个流程

1. lifecycle 如何绑定activity 的生命周期

  ComponentActivity实现LifecycleOwner接口,并且oncreate()创建ReportFragment,之后在这个fragment监听生命周期

ComponentActivity.java
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    mSavedStateRegistryController.performRestore(savedInstanceState);
    ReportFragment.injectIfNeededIn(this);
    if (mContentLayoutId != 0) {
        setContentView(mContentLayoutId);
    }
}
ReportFragment.java
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();
    }
}

// 多的不写了
@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);
}

private void dispatch(@NonNull Lifecycle.Event event) {
    if (Build.VERSION.SDK_INT < 29) {
        dispatch(getActivity(), event);
    }
}

// 最后还是调用了handleLifecycleEvent,下面详细讲解这个
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) lifecycle).handleLifecycleEvent(event);
        }
    }
}

   是不是有点像glide生命周期的管理,一样都是创建一个空白的fragment从而监听生命周期,接着往下分析handleLifecycleEvent干了什么。

2. 在监听到生命周期后如何通知观察者LifecycleObserver

   接着讲解handleLifecycleEvent。我们一开始就讲了,ComponentActivity实现LifecycleOwner接口,接口下面函数getLifecycle()对应具体返回就是LifecycleRegistry。本质就是LifecycleRegistry管理我们的针对生命周期的观察者,接着通过LifecycleRegistry同步所有观察者的状态+事件

//ComponentActivity.java

private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
@Override
public Lifecycle getLifecycle() {
    return mLifecycleRegistry;
}
LifecycleRegistry.java

// 处理lifecycleEvent
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
    State next = getStateAfter(event); // 获取下个状态
    moveToState(next);  // 移动到下个状态
}
// 通过事件获取到状态
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 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();
    
    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) {
            // 向后,例如created -> started
            backwardPass(lifecycleOwner);
        }
        Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
        if (!mNewEventOccurred && newest != null
                && mState.compareTo(newest.getValue().mState) > 0) {
            // 向前 onresumed  -> onStarted
            forwardPass(lifecycleOwner);
        }
    }
    mNewEventOccurred = false;
}

// 重点关注mObserverMap,这是就是我们的观察者Observer集合
private void forwardPass(LifecycleOwner lifecycleOwner) {
    Iterator<Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =
            mObserverMap.iteratorWithAdditions();
    while (ascendingIterator.hasNext() && !mNewEventOccurred) {
        Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();
        // 观察者的包装类
        ObserverWithState observer = entry.getValue();
        while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
                && mObserverMap.contains(entry.getKey()))) {
            pushParentState(observer.mState);
            // 重要代码,观察者事件分发
            observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
            popParentState();
        }
    }
}

private void backwardPass(LifecycleOwner lifecycleOwner) {
    Iterator<Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
            mObserverMap.descendingIterator();
    while (descendingIterator.hasNext() && !mNewEventOccurred) {
        Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();
        ObserverWithState observer = entry.getValue();
        while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
                && mObserverMap.contains(entry.getKey()))) {
            Event event = downEvent(observer.mState);
            pushParentState(getStateAfter(event));
            observer.dispatchEvent(lifecycleOwner, event);
            popParentState();
        }
    }
}

   上面可以看出,我们来到了我们观察者的包装类,并且调用了它的dispatchEvent函数,那包装类有啥?我们又是在哪生成这个包装类的呢?

// 先看包装类具体内容
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;
    }
}

// 看下我们的主线
 lifecycle.addObserver(MyLocationListener())// 代码调用
 
// LifecycleRegitstry.java

// 重点看到我们的包装类
@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); // mObserverMap 进行缓存

    ......

    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();
        targetState = calculateTargetState(observer);
    }

    if (!isReentrance) {
        // we do sync only on the top level.
        sync(); // 又回到我们之前说的代码同步
    }
    mAddingObserverCounter--;
}

   从我们的支线流程开始看,lifecycle.addObserver内部是会把我们的观察者LifecycleObserver和状态封装ObserverWithState,封装类内部dispatchEvent的方法去调用LifecycleObserver.onStateChanged。然后我们回到我们的原点空fragment如何管理生命周期,可以看到onstart\onresume等内部调用了dispatch->handleLifecycleEvent->backwardPass/forwardPass->ObserverWithState.dispatchEvent.。也就形成了闭环了