• LiveData粘性事件原理解析

    我们先来举个例子：

    1. class MainActivity : AppCompatActivity() {
    2.  
    3.     companion object {
    4.         val liveData = MutableLiveData()
    5.     }
    6.  
    7.     override fun onCreate(savedInstanceState: Bundle?) {
    8.         super.onCreate(savedInstanceState)
    9.         setContentView(R.layout.activity_main)
    10.         val tvSend = findViewById(R.id.tv_send)
    11.         tvSend.setOnClickListener {
    12.             Thread {
    13.                 liveData.postValue("hello lzy")
    14.             }.start()
    15.         }
    16.         val btn = findViewById
    17.         btn.setOnClickListener {
    18.             startActivity(Intent(this, SecondActivity::class.java))
    19.         }
    20.     }
    21.  
    22. }

    SecondActiviy代码：

    1. class SecondActivity : AppCompatActivity() {
    2.  
    3.     override fun onCreate(savedInstanceState: Bundle?) {
    4.         super.onCreate(savedInstanceState)
    5.         setContentView(R.layout.activity_second)
    6.         MainActivity.liveData.observe(this) {
    7.             Toast.makeText(this, it, Toast.LENGTH_SHORT).show()
    8.         }
    9.     }
    10.  
    11. }

    大家觉得SecondActivity的吐司会不会弹呢？我们试一把：

     有些同学可能有这样的疑惑：第二个activity还没有创建(还没有observe)，为啥在第二个activity还能监听到livaData的数据变化？带着这样的疑惑进入今天的主题吧：

    1. @MainThread
    2.     public void observe(@NonNull LifecycleOwner owner, @NonNull Observersuper T> observer) {
    3.         assertMainThread("observe");
    4.         if (owner.getLifecycle().getCurrentState() == DESTROYED) {
    5.             // ignore
    6.             return;
    7.         }
    8.         LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);//1
    9.         ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);//2
    10.         if (existing != null && !existing.isAttachedTo(owner)) {
    11.             throw new IllegalArgumentException("Cannot add the same observer"
    12.                     + " with different lifecycles");
    13.         }
    14.         if (existing != null) {
    15.             return;
    16.         }
    17.         owner.getLifecycle().addObserver(wrapper);//3
    18.     }

    我们先来看上面一段代码：

    注释1处：将SecondActivity对象和Observer对象封装到LifecycleBoundObserver对象里面去；

    注释2处：将Observer对象作为键，LifecycleBoundObserver对象作为值放到mObservers里面去；

    注释3处：将wrapper和owner生命周期绑定。

    前面学习Lifecycle原理我们了解到addObserver最终会走到：

    1. static class ObserverWithState {
    2.         State mState;
    3.         LifecycleEventObserver mLifecycleObserver;
    4.  
    5.         ObserverWithState(LifecycleObserver observer, State initialState) {
    6.             mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);//1
    7.             mState = initialState;
    8.         }
    9.  
    10.         void dispatchEvent(LifecycleOwner owner, Event event) {
    11.             State newState = event.getTargetState();
    12.             mState = min(mState, newState);
    13.             mLifecycleObserver.onStateChanged(owner, event);//2
    14.             mState = newState;
    15.         }
    16.     }

    这里面很明显是两个流程，我们先来看流程1。

    流程1:

    我们注意到，我们传进来的observer其实是一个LifecycleBoundObserver，进注释1处的方法：

    1. @NonNull
    2.     static LifecycleEventObserver lifecycleEventObserver(Object object) {
    3.         boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
    4.         ···
    5.  
    6.         if (isLifecycleEventObserver) {
    7.             return (LifecycleEventObserver) object;
    8.         }
    9.  
    10.         ···
    11.     }

    又因为：

    class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver

    再来看下分发流程，我们来看ReportFragment里面的方法：

    1. static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
    2.         if (activity instanceof LifecycleRegistryOwner) {
    3.             ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
    4.             return;
    5.         }
    6.  
    7.         if (activity instanceof LifecycleOwner) {
    8.             Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
    9.             if (lifecycle instanceof LifecycleRegistry) {
    10.                 ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);//1
    11.             }
    12.         }
    13.     }

    走注释1:

    1. public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
    2.         enforceMainThreadIfNeeded("handleLifecycleEvent");
    3.         moveToState(event.getTargetState());
    4.     }

    接着看：

    1. private void moveToState(State next) {
    2.         if (mState == next) {
    3.             return;
    4.         }
    5.         mState = next;
    6.         if (mHandlingEvent || mAddingObserverCounter != 0) {
    7.             mNewEventOccurred = true;
    8.             // we will figure out what to do on upper level.
    9.             return;
    10.         }
    11.         mHandlingEvent = true;
    12.         sync();//1
    13.         mHandlingEvent = false;
    14.     }

    进注释1:

    1. private void sync() {
    2.         LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
    3.         if (lifecycleOwner == null) {
    4.             throw new IllegalStateException("LifecycleOwner of this LifecycleRegistry is already"
    5.                     + "garbage collected. It is too late to change lifecycle state.");
    6.         }
    7.         while (!isSynced()) {
    8.             mNewEventOccurred = false;
    9.             // no need to check eldest for nullability, because isSynced does it for us.
    10.             if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
    11.                 backwardPass(lifecycleOwner);
    12.             }
    13.             Map.Entry newest = mObserverMap.newest();
    14.             if (!mNewEventOccurred && newest != null
    15.                     && mState.compareTo(newest.getValue().mState) > 0) {
    16.                 forwardPass(lifecycleOwner);//1
    17.             }
    18.         }
    19.         mNewEventOccurred = false;
    20.     }

    进注释1:

    1. private void forwardPass(LifecycleOwner lifecycleOwner) {
    2.         Iterator> ascendingIterator =
    3.                 mObserverMap.iteratorWithAdditions();
    4.         while (ascendingIterator.hasNext() && !mNewEventOccurred) {
    5.             Map.Entry entry = ascendingIterator.next();
    6.             ObserverWithState observer = entry.getValue();
    7.             while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
    8.                     && mObserverMap.contains(entry.getKey()))) {
    9.                 pushParentState(observer.mState);
    10.                 final Event event = Event.upFrom(observer.mState);
    11.                 if (event == null) {
    12.                     throw new IllegalStateException("no event up from " + observer.mState);
    13.                 }
    14.                 observer.dispatchEvent(lifecycleOwner, event);//1
    15.                 popParentState();
    16.             }
    17.         }
    18.     }

    再进注释1:

    1. static class ObserverWithState {
    2.         State mState;
    3.         LifecycleEventObserver mLifecycleObserver;
    4.  
    5.         ObserverWithState(LifecycleObserver observer, State initialState) {
    6.             mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
    7.             mState = initialState;
    8.         }
    9.  
    10.         void dispatchEvent(LifecycleOwner owner, Event event) {//走到这里了
    11.             State newState = event.getTargetState();
    12.             mState = min(mState, newState);
    13.             mLifecycleObserver.onStateChanged(owner, event);
    14.             mState = newState;
    15.         }
    16.     }

    这样就走到了dispatchEvent方法里面了。分发流程具体的可以去看博主的另一篇博客：

    Lifecycle 一篇文章就够了_AD钙奶-lalala的博客-CSDN博客使用比较简单，下面来重点分析一下原理吧。https://blog.csdn.net/qq_36428821/article/details/126333623?spm=1001.2014.3001.5502这里就步赘述了。

    上面我们讲到mLifecycleObserver其实是一个LifecycleBoundObserver，那我们就进源码看看：

    1. class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver {
    2.         @NonNull
    3.         final LifecycleOwner mOwner;
    4.  
    5.         LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observersuper T> observer) {
    6.             super(observer);
    7.             mOwner = owner;
    8.         }
    9.  
    10.         @Override
    11.         boolean shouldBeActive() {
    12.             return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);//2
    13.         }
    14.  
    15.         @Override
    16.         public void onStateChanged(@NonNull LifecycleOwner source,
    17.                 @NonNull Lifecycle.Event event) {
    18.             Lifecycle.State currentState = mOwner.getLifecycle().getCurrentState();
    19.             if (currentState == DESTROYED) {
    20.                 removeObserver(mObserver);
    21.                 return;
    22.             }
    23.             Lifecycle.State prevState = null;
    24.             while (prevState != currentState) {
    25.                 prevState = currentState;
    26.                 activeStateChanged(shouldBeActive());//1
    27.                 currentState = mOwner.getLifecycle().getCurrentState();
    28.             }
    29.         }
    30.  
    31.         @Override
    32.         boolean isAttachedTo(LifecycleOwner owner) {
    33.             return mOwner == owner;
    34.         }
    35.  
    36.         @Override
    37.         void detachObserver() {
    38.             mOwner.getLifecycle().removeObserver(this);
    39.         }
    40.     }
    分发里面调用了mLifecycleObserver.onStateChanged(owner, event);

    我们来看注释1处：

    1. void activeStateChanged(boolean newActive) {
    2.             if (newActive == mActive) {
    3.                 return;
    4.             }
    5.             // immediately set active state, so we'd never dispatch anything to inactive
    6.             // owner
    7.             mActive = newActive;
    8.             changeActiveCounter(mActive ? 1 : -1);
    9.             if (mActive) {
    10.                 dispatchingValue(this);
    11.             }
    12.         }

    mActive默认为false。为了理解这块代码，我们要先看一个东西：

    1. boolean shouldBeActive() {
    2.             return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
    3.         }
    1. public enum State {
    2.         
    3.         DESTROYED,
    4.         INITIALIZED,
    5.         CREATED,
    6.         STARTED,
    7.         RESUMED;
    8.         public boolean isAtLeast(@NonNull State state) {
    9.             return compareTo(state) >= 0;
    10.         }
    11.     }

    满足条件的状态值只有：STARTED和RESUMED。

     所以当ON_START事件分发后，newActivie值是为true的。这个时候接着往下走：

    1. void dispatchingValue(@Nullable ObserverWrapper initiator) {
    2.         if (mDispatchingValue) {
    3.             mDispatchInvalidated = true;
    4.             return;
    5.         }
    6.         mDispatchingValue = true;
    7.         do {
    8.             mDispatchInvalidated = false;
    9.             if (initiator != null) {//走这个
    10.                 considerNotify(initiator);
    11.                 initiator = null;
    12.             } else {
    13.                 for (Iteratorsuper T>, ObserverWrapper>> iterator =
    14.                         mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
    15.                     considerNotify(iterator.next().getValue());
    16.                     if (mDispatchInvalidated) {
    17.                         break;
    18.                     }
    19.                 }
    20.             }
    21.         } while (mDispatchInvalidated);
    22.         mDispatchingValue = false;
    23.     }

    接着看：

    1. private void considerNotify(ObserverWrapper observer) {//LifecycleBoundObserver
    2.         if (!observer.mActive) { //mActive为true 不走
    3.             return;
    4.         }
    5.         // Check latest state b4 dispatch. Maybe it changed state but we didn't get the event yet.
    6.         //
    7.         // we still first check observer.active to keep it as the entrance for events. So even if
    8.         // the observer moved to an active state, if we've not received that event, we better not
    9.         // notify for a more predictable notification order.
    10.         if (!observer.shouldBeActive()) { //不走
    11.             observer.activeStateChanged(false);
    12.             return;
    13.         }
    14.         if (observer.mLastVersion >= mVersion) {
    15.             return;
    16.         }
    17.         observer.mLastVersion = mVersion;
    18.         observer.mObserver.onChanged((T) mData);
    19.     }

    还有一个点要补充一下：

    dispatchingValue(this)

    这个this是啥？

    1. private abstract class ObserverWrapper {
    2.         final Observersuper T> mObserver;
    3.         boolean mActive;
    4.         int mLastVersion = START_VERSION;
    5.  
    6.         ObserverWrapper(Observersuper T> observer) {
    7.             mObserver = observer;
    8.         }
    9.  
    10.         abstract boolean shouldBeActive();
    11.  
    12.         boolean isAttachedTo(LifecycleOwner owner) {
    13.             return false;
    14.         }
    15.  
    16.         void detachObserver() {
    17.         }
    18.  
    19.         void activeStateChanged(boolean newActive) {
    20.             if (newActive == mActive) {
    21.                 return;
    22.             }
    23.             // immediately set active state, so we'd never dispatch anything to inactive
    24.             // owner
    25.             mActive = newActive;
    26.             changeActiveCounter(mActive ? 1 : -1);
    27.             if (mActive) {
    28.                 dispatchingValue(this);
    29.             }
    30.         }
    31.     }

    可见，这是一个抽象类，那么肯定有谁继承了它！

    class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver

    原来就是LifecycleBoundObserver！

    前面我们知道：

    LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);

    这样子再看前面的分发流程是不是会恍然大悟！

  • 相关阅读:
    十月一日作业
    「GitLab篇」如何用Git平台账号登录建木CI
    荐读 | 图计算的查询模式有哪些？
    mysql主从复制搭建
    Chrome清除Cookie未生效
    ChatGPT被曝测试新功能：学习所有历史聊天，还能重置记忆、“阅后即焚”
    pykafka的基本使用及统计kafka消息总数
    我的用户留言案例哪位懂的能帮我看一下
    【Python】matplotlib之折线图的各种样式和画法
    lc42接雨水详解
  • 原文地址：https://blog.csdn.net/qq_36428821/article/details/126435198