(二) Jetpack LiveData 源碼分析

參考

代碼示例

class MyViewModel : ViewModel() {
    val myLiveData: MutableLiveData<Int> by lazy {
        MutableLiveData<Int>().apply {
            // liveData 中初始賦值爲0
            value = 0
        }
    }
}
// 使用viewModels需要依賴 implementation "androidx.activity:activity-ktx:1.1.0"
class MyActivity : AppCompatActivity() {
    private val myViewModel: MyViewModel by viewModels {
        MyViewModelFactory()
    }
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.my_activity)
        // 設置LiveData的觀察者
        myViewModel.myLiveData.observe(this, Observer<Int> {
            text_number.text = "$it"
        })
        // 更新LiveData的值
        myViewModel.liveData.value = 10
        // 主線程用
        // protected void setValue (T value)
        // 子線程用
        // protected void postValue (T value)
    }
}

將創建得觀察者添加到LifecycleRegistry中

創建觀察者並添加

myViewModel.liveData.observe(this, Observer<Int> {
    text_number.text = "$it"
})

點進去看observe()方法

public abstract class LiveData<T> {
    @MainThread
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        // 必須主線程才能添加觀察者
        assertMainThread("observe");
        // `ComponentActivity`的`LifecycleRegistry`對象處於`DESTROYED`狀態,也就是當前處於`DESTROYED`生命週期,
        // 就不要再往`LifecycleRegistry`中添加觀察者了.
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {
            return;
        }
        // LifecycleBoundObserver中持有`LifecycleOwner`和觀察者對象.
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
        // 每個LiveData都有一個mObservers變量,它是一個Map集合,用來存放觀察者與LifecycleBoundObserver對象的
        ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
        // 向mObservers集合中添加觀察者與LifecycleBoundObserver對象時,如果集合中已經添加過該觀察者,就退出.
        if (existing != null) {
            return;
        }
        // owner.getLifecycle():這個owner其實就是Activity對象經過強轉得到的,androidx.activity.ComponentActivity實現LifecycleOwner接口.
        // getLifecycle()方法最終得到的是ComponentActivity類中的LifecycleRegistry對象.
        // 這裏就將LifecycleBoundObserver對象添加到`LifecycleRegistry`對象中.
        owner.getLifecycle().addObserver(wrapper);
    }
}

LifecycleBoundObserver對象被添加到LifecycleRegistry後發生了些什麼?

public class LifecycleRegistry extends Lifecycle {
    // 這裏只做簡單的分析,LifecycleRegistry詳細分析可以看上一篇文章.
    @Override
    public void addObserver(@NonNull LifecycleObserver observer) {
        ...
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
        ...
        // TODO 1 接着往下
        statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
        ...
    }
    static class ObserverWithState {
        void dispatchEvent(LifecycleOwner owner, Event event) {
            ...
            // TODO 2 
            // 到此處很清晰的說明了,LiveData也是一個觀察者,他觀察的是Activity的生命週期,當LiveData被添加到LifecycleRegistry中時,
            // LifecycleRegistry會同步ObserverWithState的狀態mState,會改變LifecycleBoundObserver的狀態.
            mLifecycleObserver.onStateChanged(owner, event);
            mState = newState;
        }
    }
}

接着向下看onStateChanged()後會發生什麼.

public abstract class LiveData<T> {
    // 有多少觀察者處於活動狀態
    int mActiveCount = 0;
    class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver {
        @Override
        public void onStateChanged(@NonNull LifecycleOwner source,@NonNull Lifecycle.Event event) {
            if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
                removeObserver(mObserver);
                return;
            }
            // TODO 3 向下看
            activeStateChanged(shouldBeActive());
        }
        // TODO 4
        @Override
        boolean shouldBeActive() {
            // mOwner.getLifecycle().getCurrentState(): 獲取LifecycleRegistry當前的狀態,然後與STARTED狀態比較
            // 如果時大於或者等於STARTED狀態,就返回true.
            return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
        }
    }
    private abstract class ObserverWrapper {
        boolean mActive; // 記錄當前LiveData的狀態
        // TODO 5
        void activeStateChanged(boolean newActive) {
            // 如果當前LiveData狀態與TODO 4 shouldBeActive()得到的相同,就不需要向下走了.
            if (newActive == mActive) {
                return;
            }
            // 這裏是更新狀態
            mActive = newActive;
            // wasInactive 代表是否有觀察者處於活躍狀態
            boolean wasInactive = LiveData.this.mActiveCount == 0;
            // mActiveCount 代表有幾個觀察者處於活躍狀態
            LiveData.this.mActiveCount += mActive ? 1 : -1;
            if (wasInactive && mActive) {
                // 當觀察者從0到1時候,會回調這個方法,也就是我可以對該方法重寫做一些自己的操作.
                onActive();
            }
            if (LiveData.this.mActiveCount == 0 && !mActive) {
                // 當觀察者從1到0時會回調這個方法
                onInactive();
            }
            // 這個是當觀察者處於活躍狀態會調用的方法,分析到這裏先停下,下面會詳細說該方法.
            if (mActive) {
                dispatchingValue(this);
            }
        } 
    }
}

改變LiveData中的值,然後通知觀察者

public class MutableLiveData<T> extends LiveData<T> {
    @Override
    public void setValue(T value) {
        // 這裏調用的是父類的setValue(value)方法.
        super.setValue(value);
    }
}

看下父類中的setValue(value)方法

public abstract class LiveData<T> {
    private SafeIterableMap<Observer<? super T>, ObserverWrapper> mObservers = new SafeIterableMap<>();
    // TODO 1
    @MainThread 
    protected void setValue(T value) {
        // 這個註解是主線程調用
        assertMainThread("setValue");
        // 這個是用來記錄當前LiveData的版本,每此LiveData值改變了,這個版本號就會+1,
        // 然後當通知觀察者的時候,需要判斷最後一個版本與現在版本號大小,下面有分析.
        mVersion++;
        // 記錄傳入的值
        mData = value;
        // 開始向觀察者分發更新的數據
        dispatchingValue(null);
    }
    // TODO 2
    void dispatchingValue(@Nullable ObserverWrapper initiator) {
        if (mDispatchingValue) {
            mDispatchInvalidated = true;
            return;
        }
        // 分發中
        mDispatchingValue = true;
        // 先執行do語句,while中條件爲真才繼續執行
        do {
            mDispatchInvalidated = false;
            if (initiator != null) {
                // 更具上一步中,initiator = null,所以不走這裏.
                considerNotify(initiator);
                initiator = null;
            } else {
                // 遍歷當前LiveData中的mObservers對象
                for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator = mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
                    // iterator.next().getValue()獲取ObserverWrapper的子類LifecycleBoundObserver對象.
                    considerNotify(iterator.next().getValue());
                    if (mDispatchInvalidated) {
                        break;
                    }
                }
            }
        } while (mDispatchInvalidated);
        // 分發完成
        mDispatchingValue = false;
    }
    // TODO 3
    private void considerNotify(ObserverWrapper observer) {
        // mActive這個LifecycleBoundObserver中的變量, 表示當前觀察者是否處於活動狀態.
        if (!observer.mActive) {
            // 如果處於非活動狀態,就不對這次LiveData值更改的事件進行分發.
            return;
        }
        if (!observer.shouldBeActive()) {
            // 再次的對觀察者的當前活動狀態進行檢測,如果是Activity當前處於STARTED之前的狀態,
            // 那麼同步觀察者處於非活動狀態.
            observer.activeStateChanged(false);
            return;
        }
        // 如果當前觀察者的版本號比前一次版本號還小,就別通知了,
        // 這個mVersion值得增加是在setValue()方法中做的.
        if (observer.mLastVersion >= mVersion) {
            return;
        }
        // 更新LiveData最後一次更新得版本號
        observer.mLastVersion = mVersion;
        // 最後的最後終於調用了觀察者的onChanged()方法了.
        // observer類型是LifecycleBoundObserver,它的mObserver就是示例代碼裏Activity中創建的Observer對象了.
        observer.mObserver.onChanged((T) mData);
    }
}

至此,LiveData源碼也分析完了,LifeCycle源碼理解好了後來看LiveData源碼還是比較的容易的.