Android LiveData原理分析

從API調用入手

舉個栗子：Activity中訂閱數據變更

    viewModel.contentLiveData.observe(this, Observer<String> { content ->
        tv.text = content
    })

ViewModel中初始化LiveData

    val contentLiveData: MutableLiveData<String> by lazy {
        MutableLiveData<String>()
    }

LiveData.observe()

    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        //檢查是否爲ui線程
        assertMainThread("observe");
        //頁面DESTROYED狀態不執行訂閱流程
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {
            return;
        }
        //包裝
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
        //添加到集合mObservers
        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;
        }
        owner.getLifecycle().addObserver(wrapper);
    }

owner爲上述this--->Activity，owner和用戶自定義的observer包裝到LifecycleBoundObserver

LifeCycle原理分析過Activity.getLifecycle()返回LifecycleRegistry--->LifecycleRegistry.addObserver(wrapper)

LifecycleBoundObserver實現LifecycleEventObserver接口

    class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver{
        final LifecycleOwner mOwner;

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

        @Override
        public void onStateChanged(@NonNull LifecycleOwner source,
                @NonNull Lifecycle.Event event) {
            if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
                removeObserver(mObserver);
                return;
            }
            activeStateChanged(shouldBeActive());
        }
    }

owner生命週期變更時會觸發onStateChanged()方法，DESTROYED狀態移除訂閱。

接下來觸發數據變更

    contentLiveData.value = ""

MutableLiveData.setValue()

    @Override
    public void setValue(T value) {
        super.setValue(value);
    }

調用父類LiveData.setValue()

    protected void setValue(T value) {
        assertMainThread("setValue");
        mVersion++;
        mData = value;
        dispatchingValue(null);
    }

LiveData.dispatchingValue()

    void dispatchingValue(@Nullable ObserverWrapper initiator) {
        if (mDispatchingValue) {
            mDispatchInvalidated = true;
            return;
        }
        mDispatchingValue = true;
        do {
            mDispatchInvalidated = false;
            if (initiator != null) {
                considerNotify(initiator);
                initiator = null;
            } else {
                for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =
                        mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
                    considerNotify(iterator.next().getValue());
                    if (mDispatchInvalidated) {
                        break;
                    }
                }
            }
        } while (mDispatchInvalidated);
        mDispatchingValue = false;
    }

遍歷集合調用considerNotify(ObserverWrapper)

LiveData.considerNotify()

    private void considerNotify(ObserverWrapper observer) {
        if (!observer.mActive) {
            return;
        }
        if (!observer.shouldBeActive()) {
            observer.activeStateChanged(false);
            return;
        }
        if (observer.mLastVersion >= mVersion) {
            return;
        }
        observer.mLastVersion = mVersion;
        observer.mObserver.onChanged((T) mData);
    }

回調到Observer.onChanged()方法

LiveData還有異步線程更新數據的api

    contentLiveData.postValue("")

MutableLiveData.postValue()

    @Override
    public void postValue(T value) {
        super.postValue(value);
    }

LiveData.postValue()

    protected void postValue(T value) {
        boolean postTask;
        synchronized (mDataLock) {
            postTask = mPendingData == NOT_SET;
            mPendingData = value;
        }
        if (!postTask) {
            return;
        }
        ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
    }

mPostValueRunnable

    private final Runnable mPostValueRunnable = new Runnable() {
        @SuppressWarnings("unchecked")
        @Override
        public void run() {
            Object newValue;
            synchronized (mDataLock) {
                newValue = mPendingData;
                mPendingData = NOT_SET;
            }
            setValue((T) newValue);
        }
    };

在Runnable中調用LiveData.setValue()

ArchTaskExecutor

public class ArchTaskExecutor extends TaskExecutor {
    public static ArchTaskExecutor getInstance() {
        if (sInstance != null) {
            return sInstance;
        }
        synchronized (ArchTaskExecutor.class) {
            if (sInstance == null) {
                sInstance = new ArchTaskExecutor();
            }
        }
        return sInstance;
    }

    private ArchTaskExecutor() {
        mDefaultTaskExecutor = new DefaultTaskExecutor();
        mDelegate = mDefaultTaskExecutor;
    }

    @Override
    public void postToMainThread(Runnable runnable) {
        mDelegate.postToMainThread(runnable);
    }
}

DefaultTaskExecutor.postToMainThread()

    @Override
    public void postToMainThread(Runnable runnable) {
        if (mMainHandler == null) {
            synchronized (mLock) {
                if (mMainHandler == null) {
                    mMainHandler = createAsync(Looper.getMainLooper());
                }
            }
        }
        mMainHandler.post(runnable);
    }

mMainHandler.post(runnable)

通過handler.post()切換到主線程執行

LiveData組件實現依賴於LifeCycle組件，分析完LifeCycle流程很容易理解其執行過程。