class MainViewModel: ViewModel() {
    // 定義 LiveData 注意這里給了 0 作為初始值
    val number = MutableLiveData<Int>(0)
    fun add(){
        // 相當(dāng)于 number.setValue(number.getValue() + 1)
        number.value = number.value?.plus(1)
    }
    fun sub(){
        // 相當(dāng)于 number.setValue(number.getValue() - 1)
        number.value = number.value?.minus(1)
    }
}

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        // 獲取 ViewModel 實(shí)例
        val vm = ViewModelProvider(this).get(MainViewModel::class.java)
        // 調(diào)用 ViewModel 方法 進(jìn)行加法操作
        bnAdd.setOnClickListener {
             vm.add()
        }
        // 調(diào)用 ViewModel 方法 進(jìn)行減法操作
        bnSub.setOnClickListener {
            vm.sub()
        }
        // 觀(guān)察 LiveData 變化， Observer 是接口，kotlin 寫(xiě)法簡(jiǎn)化
        vm.number.observe(this, Observer {
            tvNumber.text = it.toString()
        })
    }
}

public interface Observer<T> {
    void onChanged(T t);
}

public abstract class LiveData<T> {
    //...
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        // 檢查是否在主線(xiàn)程
        assertMainThread("observe");
        // 如果觀(guān)察者所在組件的生命周期為 DESTROYED 則直接 return
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {
            return;
        }
        // LifecycleBoundObserver 實(shí)現(xiàn)了 ObserverWrapper
        // 理解為這是對(duì) 觀(guān)察者 Observer 的一層包裝類(lèi)即可
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
        // mObservers 是一個(gè) Map 容器，原始的 Observer 為 key，包裝后的 wrapper 為 value
        ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
        // 同一個(gè) observer 不能在不同的生命周期組件中進(jìn)行訂閱
        if (existing != null && !existing.isAttachedTo(owner)) {
            throw new IllegalArgumentException("Cannot add the same observer"
                    + " with different lifecycles");
        }
        // 重復(fù)訂閱直接return
        if (existing != null) {
            return;
        }
        // LifecycleBoundObserver 利用 Lifecycle 實(shí)現(xiàn)自動(dòng)解綁
        // Lifecycle 原理詳見(jiàn)我之前的博客
        owner.getLifecycle().addObserver(wrapper);
    }
    // ...
}

private abstract class ObserverWrapper {
    final Observer<? super T> mObserver; // Observer 原始對(duì)象
    boolean mActive; // 是否激活
    int mLastVersion = START_VERSION; // 版本號(hào) 默認(rèn) -1
    ObserverWrapper(Observer<? super T> observer) {
        mObserver = observer; // 賦值
    }
    abstract boolean shouldBeActive(); // 抽象方法
    boolean isAttachedTo(LifecycleOwner owner) {
        return false;
    }
    void detachObserver() {
    }
    void activeStateChanged(boolean newActive) {
        if (newActive == mActive) { // 如果值一樣則返回
            return;
        }
        mActive = newActive; // 不一樣則更新 mActive
        changeActiveCounter(mActive ? 1 : -1); // 記錄有多少個(gè)激活狀態(tài)的observer
        // 注意這里，如果mActive是從false變更為true 則調(diào)用一次 dispatchingValue
        // dispatchingValue 的源碼下面再分析
        if (mActive) { 
            dispatchingValue(this);
        }
    }
}

class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver {
    @NonNull
    final LifecycleOwner mOwner;
    LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<? super T> observer) {
        super(observer); // 父類(lèi)構(gòu)造器 賦值
        mOwner = owner;
    }
    @Override
    boolean shouldBeActive() { // 判斷是否是激活狀態(tài)
        return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
    }
    // 如果再 activity 中進(jìn)行 observer
    // 當(dāng) activity 生命周期發(fā)生變化時(shí) 會(huì)回調(diào)到這里
    @Override
    public void onStateChanged(@NonNull LifecycleOwner source,
            @NonNull Lifecycle.Event event) {
        Lifecycle.State currentState = mOwner.getLifecycle().getCurrentState();
        // 自動(dòng)解綁
        if (currentState == DESTROYED) { 
            // removeObserver 內(nèi)部會(huì)將 observer 從 map 容器中移除
            // 并且調(diào)用其 detachObserver 方法
            removeObserver(mObserver);
            return;
        }
        Lifecycle.State prevState = null;
        while (prevState != currentState) {
            prevState = currentState;
            // activeStateChanged 上面已經(jīng)說(shuō)過(guò)了
            // 如果 mActive 由 fasle 變更為 true 會(huì)執(zhí)行一次 dispatchingValue
            activeStateChanged(shouldBeActive());
            currentState = mOwner.getLifecycle().getCurrentState();
        }
    }
    // ...
}

public class MutableLiveData<T> extends LiveData<T> {
    public MutableLiveData(T value) {
        super(value);
    }
    public MutableLiveData() {
        super();
    }
    @Override
    public void postValue(T value) {
        super.postValue(value);
    }
    @Override
    public void setValue(T value) {
        super.setValue(value);
    }
}

public abstract class LiveData<T> {
    protected void postValue(T value) {
        boolean postTask;
        synchronized (mDataLock) {
            // mPendingData 默認(rèn)值為 NOT_SET
            postTask = mPendingData == NOT_SET;
            // 調(diào)用 postValue 后，會(huì)賦值成傳進(jìn)來(lái)的 value
            mPendingData = value; 
        }
        if (!postTask) { // 第一次調(diào)用 肯定為 true
            return;
        }
        // 核心在于這一行，postToMainThread 
        // 看名字也知道是切換到主線(xiàn)程去執(zhí)行 mPostValueRunnable
        ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
    }
}

private final Runnable mPostValueRunnable = new Runnable() {
    @Override
    public void run() {
        Object newValue;
        synchronized (mDataLock) { // 加鎖同步
            newValue = mPendingData; // 獲取最新傳遞過(guò)來(lái)的值
            mPendingData = NOT_SET; // 將 mPendingData 恢復(fù)為默認(rèn)值
        }
        // 最終還是調(diào)用了 setValue
        setValue((T) newValue);
    }
};

public abstract class LiveData<T> {
    static final int START_VERSION = -1;
    private volatile Object mData;
    private int mVersion
    // 帶初始值的構(gòu)造器
    public LiveData(T value) {
        mData = value; // 直接給 mData 賦值
        mVersion = START_VERSION + 1; //版本號(hào) +1，也就是 0
    }
    // 無(wú)參構(gòu)造器
    public LiveData() {
        mData = NOT_SET;
        mVersion = START_VERSION; // 版本號(hào)默認(rèn) -1
    }
    protected void setValue(T value) {
        // 內(nèi)部根據(jù) Looper 判斷是否在主線(xiàn)程，不在主線(xiàn)程則拋出異常
        assertMainThread("setValue");
        // 版本號(hào) +1
        mVersion++;
        // LiveData 的數(shù)據(jù)，也就是被觀(guān)察的數(shù)據(jù)，設(shè)置為最新值
        mData = value;
        // 這里是重點(diǎn)
        dispatchingValue(null);
    }
}

// 用于保存其觀(guān)察者 Observer，Observer 會(huì)包裝成
private SafeIterableMap<Observer<? super T>, ObserverWrapper> mObservers =
        new SafeIterableMap<>();
void dispatchingValue(@Nullable ObserverWrapper initiator) {
    if (mDispatchingValue) { // 默認(rèn)為 false 
        mDispatchInvalidated = true;
        return;
    }
    mDispatchingValue = true; // 進(jìn)入方法后設(shè)置為 true
    do {
        mDispatchInvalidated = false; 
        // setValue 傳進(jìn)來(lái)的是 null 不會(huì)進(jìn)入這個(gè) if
        // initiator 實(shí)際上就是觀(guān)察者，如果傳遞進(jìn)來(lái)一個(gè)觀(guān)察者對(duì)象
        // 則只進(jìn)行一次 considerNotify 方法調(diào)用
        if (initiator != null) { 
            considerNotify(initiator);
            initiator = null;
        } else { // 遍歷自身的觀(guān)察者
            for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =
                    mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
                // 調(diào)用 considerNotify 將觀(guān)察者傳入
                considerNotify(iterator.next().getValue());
                if (mDispatchInvalidated) {
                    break;
                }
            }
        }
    } while (mDispatchInvalidated);
    mDispatchingValue = false; // 方法執(zhí)行結(jié)束前 設(shè)置為 false
}
private void considerNotify(ObserverWrapper observer) {
    if (!observer.mActive) { // 未激活狀態(tài)直接返回
        return;
    }
    // 判斷是否可以是激活狀態(tài)
    // LifecycleBoundObserver 中則是判斷所在組件的生命周期是否為激活狀態(tài)
    if (!observer.shouldBeActive()) { 
        observer.activeStateChanged(false); // 將 observer 的 mActive 設(shè)置為 fasle
        return;
    }
    // 如果 observer 的版本號(hào) 大于 LiveData 本身的版本號(hào) 則直接返回
    if (observer.mLastVersion >= mVersion) {
        return;
    }
    // 將 observer 的版本號(hào)和 LiveData 本身的版本號(hào)同步
    observer.mLastVersion = mVersion;
    // 觸發(fā)其 onChanged 方法回調(diào)
    observer.mObserver.onChanged((T) mData);
}

class SingleLiveData<T> : MutableLiveData<T>() {
    private val mPendingMap = HashMap<Observer<in T>, AtomicBoolean>()
    @MainThread
    override fun observe(owner: LifecycleOwner, observer: Observer<in T>) {
        val lifecycle = owner.lifecycle
        if (lifecycle.currentState == Lifecycle.State.DESTROYED) {
            return
        }
        mPendingMap[observer] = AtomicBoolean(false)
        lifecycle.addObserver(LifecycleEventObserver { source: LifecycleOwner?, event: Lifecycle.Event ->
            if (event == Lifecycle.Event.ON_DESTROY) {
                mPendingMap.remove(observer)
            }
        })
        super.observe(owner) { t: T ->
            val pending = mPendingMap[observer]
            if (pending != null && pending.compareAndSet(true, false)) {
                observer.onChanged(t)
            }
        }
    }
    @MainThread
    override fun observeForever(observer: Observer<in T>) {
        mPendingMap[observer] = AtomicBoolean(false)
        super.observeForever(observer)
    }
    @MainThread
    override fun removeObserver(observer: Observer<in T>) {
        mPendingMap.remove(observer)
        super.removeObserver(observer)
    }
    @MainThread
    override fun removeObservers(owner: LifecycleOwner) {
        mPendingMap.clear()
        super.removeObservers(owner)
    }
    @MainThread
    override fun setValue(t: T?) {
        for (value in mPendingMap.values) {
            value.set(true)
        }
        super.setValue(t)
    }
}