AndroidX設計架構MVVM之LiveDatal生命週期及數據監聽分析

AndroidX設計架構MVVM之LiveDatal2.1.0生命週期及數據監聽分析

原文
AndroidX設計架構MVVM之ViewModel創建流程原理分析
AndroidX設計架構MVVM之ViewModel生命週期分析
AndroidX設計架構MVVM之LiveDatal生命週期及數據監聽分析
AndroidX設計架構MVVM之DataBinding搭配LiveData的分析
AndroidX設計架構MVVM之DataBinding+ViewModel+LiveData

LiveData的簡單使用，詳細使用參考其他^^

//分析點1
 getViewModel().getUserInfo().observe(this, new Observer<UserBean>() {
            @Override
            public void onChanged(UserBean userBean) {
                Toast.makeText(MvvmMainActivity.this, userBean.getName(), Toast.LENGTH_SHORT).show();
            }
        });
 //分析點2
  getViewModel().getUserInfo().setValue(UserBean.UserBeanBuilder.newBuilder().setName("小明").setAge("11").build());

分析點1：主要有兩部分1）對View生命週期進行監聽，2）對LiveData數據進行監聽

  @MainThread
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        assertMainThread("observe");
        //在destroy中直接返回
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {
            // ignore
            return;
        }
        //分析點3
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
        //將包裝的Observer保存在livedata的觀察者列表中
        ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
        if (existing != null && !existing.isAttachedTo(owner)) {
            throw new IllegalArgumentException("Cannot add the same observer"
                    + " with different lifecycles");
        }
        if (existing != null) {
            return;
        }
        //添加到view生命週期的觀察者集合中
        owner.getLifecycle().addObserver(wrapper);
    }

先看分析點3：LifecycleBoundObserver實現了LifecycleEventObserver ，而LifecycleEventObserver 繼承了LifecycleObserver，因此可以添加到View的生命週期的觀察者列表中。

先看一下LifecycleBoundObserver的父類ObserverWrapper，它有通知當前監聽者的功能 ，詳情看註釋

 private abstract class ObserverWrapper {
        final Observer<? super T> mObserver;
        boolean mActive;
        int mLastVersion = START_VERSION;

        ObserverWrapper(Observer<? super T> observer) {
           //這裏是代碼中new出來的的那個observer對象，從子類中傳入的
            mObserver = observer;
        }

        abstract boolean shouldBeActive();

        boolean isAttachedTo(LifecycleOwner owner) {
            return false;
        }

        void detachObserver() {
        }
       
       //向當前的監聽者進行通知 
        void activeStateChanged(boolean newActive) {
           //生命週期沒有變化，直接返回，即沒有出現【onStart，onPause】區間和
           //非【onStart，onPause】區間的切換
            if (newActive == mActive) {
                return;
            }
            // immediately set active state, so we'd never dispatch anything to inactive
            // owner
            mActive = newActive;
            //mActiveCount = 0時說明處於非
            boolean wasInactive = LiveData.this.mActiveCount == 0;
            LiveData.this.mActiveCount += mActive ? 1 : -1;
            if (wasInactive && mActive) {
               //生命週期狀態在 started 或 resumed時，且是從非活動狀態切換過來的
                onActive();
            }
            if (LiveData.this.mActiveCount == 0 && !mActive) {
                onInactive();
            }
            //mActive爲true時，表示生命週期從Inactive轉換到了active狀態
            //這時要刷新數據
            if (mActive) {
                 // 分析點4 ：向當前的監聽者進行通知 
                dispatchingValue(this);
            }
        }
    }

而子類LifecycleBoundObserver 主要負責生命週期的判斷以及傳遞

class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver {
        @NonNull
        final LifecycleOwner mOwner;

        LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<? super T> observer) {
            super(observer);
            mOwner = owner;
        }

        @Override
        boolean shouldBeActive() {
          //判斷當前生命週期是否在【onStart，onPause】區間
            return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
        }

        @Override
        public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
            if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
                removeObserver(mObserver);
                return;
            }
            //傳遞對生命週期的判斷
            activeStateChanged(shouldBeActive());
        }

        @Override
        boolean isAttachedTo(LifecycleOwner owner) {
            return mOwner == owner;
        }

        @Override
        void detachObserver() {
            mOwner.getLifecycle().removeObserver(this);
        }
    }

接下來看分析點2:setValue()方法中對value的版本進行了記錄mVersion，這個隨後看。

 @MainThread
    protected void setValue(T value) {
        assertMainThread("setValue");
        //記錄當前版本
        mVersion++;
        mData = value;
        dispatchingValue(null);
    }
   

那麼分析點2和分析點4的區別就在於dispatchingValue()傳值是否爲null。

void dispatchingValue(@Nullable ObserverWrapper initiator) {
       //通知各個監聽者中
        if (mDispatchingValue) {
            mDispatchInvalidated = true;
            return;
        }
        mDispatchingValue = true;
        do {
            mDispatchInvalidated = false;
            if (initiator != null) {
              //不爲空，則只通知傳入的監聽者
                considerNotify(initiator);//分析點5
                initiator = null;
            } else {
                //則通知所有的監聽者
                for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =
                        mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
                    //分析點5
                    considerNotify(iterator.next().getValue());
                    if (mDispatchInvalidated) {
                        break;
                    }
                }
            }
        } while (mDispatchInvalidated);
        mDispatchingValue = false;
    }

分析點5：到這一步纔是真正的對觀察者的通知

private void considerNotify(ObserverWrapper observer) {
       //不是活動狀態，直接返回，那還這麼更新數據？總結中分析
        if (!observer.mActive) {
            return;
        }
        // Check latest state b4 dispatch. Maybe it changed state but we didn't get the event yet.
        //
        // we still first check observer.active to keep it as the entrance for events. So even if
        // the observer moved to an active state, if we've not received that event, we better not
        // notify for a more predictable notification order.
        //再判斷一遍活動狀態
        if (!observer.shouldBeActive()) {
            observer.activeStateChanged(false);
            return;
        }
        //value 當前版本不大於上一次的，直接返回
        if (observer.mLastVersion >= mVersion) {
            return;
        }
        //更新上一次的value版本
        observer.mLastVersion = mVersion;
        //noinspection unchecked
        //onChanged 眼熟吧，就是在代碼中創建observer的方法
        observer.mObserver.onChanged((T) mData);
    }

接下來簡單分析一下postValue()：其實就在利用Handler來切換到主線程的。

   protected void postValue(T value) {
        boolean postTask;
        synchronized (mDataLock) {
            postTask = mPendingData == NOT_SET;
            mPendingData = value;
        }
        if (!postTask) {
            return;
        }
        ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
    }
    
 private final Runnable mPostValueRunnable = new Runnable() {
        @Override
        public void run() {
            Object newValue;
            synchronized (mDataLock) {
                newValue = mPendingData;
                mPendingData = NOT_SET;
            }
            //noinspection unchecked
            setValue((T) newValue);
        }
    };

總結：
1）livedata的observe()，將傳入的LifecycleOwner和Observer封裝爲LifecycleBoundObserver對象，並保存到LiveData的觀察者集合中，同時加入到View的生命週期觀察者集合中。
2）（參考分析點3）當生命週期由InActive狀態切換到Active狀態時會通知當前的LiveData的觀察者，這個主要用於在InActive狀態時數據發生變化時進行刷新。
3）而使用setValue()時，將通知LiveData所有觀察者。