对LiveData源码阅读，了解LiveData如何观察活动中数据变化，以及对UI更新

使用LiveData更新UI

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val textView : TextView = findViewById(R.id.tv_textview)

        // 1 观察者 眼睛 环节
        MyLiveData.info1.observe(this, {
            textView.text = it // 更新UI
        })

        // 完整写法 new  Observer  onChanged
        MyLiveData.info1.observe(this, object: Observer<String> {
            override fun onChanged(t: String?) {
                textView.text = t // 更新UI
            }
        })
            // 2 触发数据改变 环节
        MyLiveData.info1.value = "default" // setValue 主线程

        thread {
            Thread.sleep(3000)
            MyLiveData.info1.postValue("三秒钟后，修改了哦")  // postValue 子线程
        }

        thread { // 子线程
            Thread.sleep(6000)
            MyLiveData.info1.postValue("六秒钟后，修改了哦")  // postValue 子线程
        }
    }

}

package com.derry.livedata.livedata.simple1

import androidx.lifecycle.MutableLiveData

object MyLiveData { // 单例

    // 懒加载
    val info1: MutableLiveData<String> by lazy { MutableLiveData() }

}

查看LiveData源码

   @MainThread
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        assertMainThread("observe");
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {
            // ignore
            return;
        }
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
        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);
    }

observe参数

observe的第一个形参是用观察宿主Activity的生命周期

我们通过查看第二个形参的内部代码

public interface Observer<T> {
    /**
     * Called when the data is changed.
     * @param t  The new data
     */
    void onChanged(T t);
}

第一行代码用来判断如果不再主线程抛出异常,

在下面if预计判断宿主的生命状态是销毁状态直接进行销毁，

二次封装

LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);

LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);

为什么要写这行呢，因为第二个形参。它只是普通个接口，无法感知Activity生命状态

之后我们在进一步去查看LifecycleBoundObserver

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

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

        @Override
        boolean shouldBeActive() {
            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);
        }
    }

状态判断

首先就将宿主的状态保存了

这里我们先查看 onStateChanged（）方法

它在判断宿主的生命状态，如果是销毁状态，将Observer进行移除

如果不是销毁状态就进入activeStateChanged(shouldBeActive());

shouldBeActive()这个方法就是就是为了拿到Lifecycle是否存活，

如果存活，拿到true，我们再一次进入内部查看

        void activeStateChanged(boolean newActive) {
            if (newActive == mActive) {
                return;
            }
            // immediately set active state, so we'd never dispatch anything to inactive
            // owner
            mActive = newActive;
            boolean wasInactive = LiveData.this.mActiveCount == 0;
            LiveData.this.mActiveCount += mActive ? 1 : -1;
            if (wasInactive && mActive) {
                onActive();
            }
            if (LiveData.this.mActiveCount == 0 && !mActive) {
                onInactive();
            }
            if (mActive) {
                dispatchingValue(this);
            }
        }

如果是true会调用一个空函数onActive()用来告知外界，我们是存活的

如果不是存活的也会调用一个空函数onInactive();

最后如果是存活执行dispatchingValue(this);

传入this,当前ObserverWrapper类，它是LifecycleBoundObserver类的父类

再进入其中，进行分发

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;
}

我们知道传入this一定不为空

所以它一定走这个

if (initiator != null) {
        considerNotify(initiator);
        initiator = null;
    }

如果是setvalue，就走else，这里我们先跳过。

我们继续查看considerNotify

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;
    }
    if (observer.mLastVersion >= mVersion) {
        return;
    }
    observer.mLastVersion = mVersion;
    //noinspection unchecked
    observer.mObserver.onChanged((T) mData);
}

if (!observer.mActive) {
    return;
}

再次状态判断

还是先进行状态判断，保证在同一个状态

if (!observer.shouldBeActive()) { observer.activeStateChanged(false); return; }

如果Activity突然可见，能够重新在动起来，

决定了我们是否更新，

if (observer.mLastVersion >= mVersion) {
    return;
}

如果我们在Activity进行UI更新

MyLiveData.value1.observe(this, object: Observer<String>{
    override fun onChanged(t: String?) {
        Toast.makeText(this@MainActivity4, "观察者数据变化$t", Toast.LENGTH_SHORT).show()
    }
})

那么activity,作为被观察者进行了一次修改+1，变成0，即就是mVersion

而观察者并没有修改还是初始值-1，就是observer.mLastVersion

它就会进行判断，他们不相等

就会执行下一步另他们相等，并且onChanged把粘性数据mData

分发下去

observer.mLastVersion = mVersion;
//noinspection unchecked
observer.mObserver.onChanged((T) mData);

去除粘性

如果我们要去除粘性数据使用反射，使observer.mLastVersion++就可以，使他们相等

if (observer.mLastVersion >= mVersion) {
    return;
}

就return出去

接下来我们讲述另外一个情况postValue

// 2 触发数据改变 环节
MyLiveData.info1.value = "default" // setValue 主线程

thread {
    Thread.sleep(3000)
    MyLiveData.info1.postValue("三秒钟后，修改了哦")  // postValue 子线程
}

点进去查看，它继承于LiveData,你会发现它的用户良苦，

因为LiveData过于复杂，查看LiveData源码就知道，非常庞大。通过这种方式，进行简单封装。就像装饰一样，暴露最简单的东西给用户

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

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

进入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() {
    @Override
    public void run() {
        Object newValue;
        synchronized (mDataLock) {
            newValue = mPendingData;
            mPendingData = NOT_SET;
        }
        //noinspection unchecked
        setValue((T) newValue);
    }
};

为了调用setValue

它的目的非常简单就是最终调用我们的setValue

newValue就是我们最开始传入的字符串"三秒钟后，修改了哦"

newValue = mPendingData;

回到主线程

因为我们是在子线程进行更新，最后肯定要回到主线程

所以postToMainThread百分之百是主线程

我们开通点进去查看

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

public abstract void postToMainThread(@NonNull Runnable runnable);

再到DefaultTaskExecutor类

@Override
public void postToMainThread(Runnable runnable) {
    if (mMainHandler == null) {
        synchronized (mLock) {
            if (mMainHandler == null) {
                mMainHandler = new Handler(Looper.getMainLooper());
            }
        }
    }
    //noinspection ConstantConditions
    mMainHandler.post(runnable);
}

通过Handle回到了主线程

最后我们再查看setValue

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

就是我们提到的mVersion++;

这里传入null也就是我们上面的else要走的循环，我们点进去查看

@SuppressWarnings("WeakerAccess") /* synthetic access */
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;
}

我们解析其中的

else {
    for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =
            mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
        considerNotify(iterator.next().getValue());
        if (mDispatchInvalidated) {
            break;
        }
    }
}

为什么出现循环，因为当我们出现多个观察者如下所示

  thread {
            Thread.sleep(3000)
            MyLiveData.info1.postValue("三秒钟后，修改了哦")  // postValue 子线程
        }

    thread { // 子线程
        Thread.sleep(6000)
        MyLiveData.info1.postValue("六秒钟后，修改了哦")  // postValue 子线程
    }
}

他们同样会调用 considerNotify(iterator.next().getValue());函数。

一模一样的逻辑，

问题

多个赋值，会有线程安全问题吗？

我们刚进入postValve就可以看到，做了处理

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

什么是粘性数据

class MainActivity3 : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main3)
​
​
        val button = findViewById<Button>(R.id.button)
        button.setOnClickListener {
            // version++  == 0   第一步
            MyLiveData.value1.value = "我就是我，不一样的烟火1" // 以前的旧数据
            MyLiveData.value1.value = "我就是我，不一样的烟火2" // 以前的旧数据
            MyLiveData.value1.value = "我就是我，不一样的烟火3" // 以前的旧数据
            MyLiveData.value1.value = "我就是我，不一样的烟火4" // 以前的旧数据
            MyLiveData.value1.value = "我就是我，不一样的烟火5" // 以前的旧数据
​
            startActivity(Intent(this, MainActivity4::class.java))
        }
    }
}

class MainActivity4 : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main4)
​
        // 我后观察数据，居然能够收到 前面修改的数据，这就是 数据黏性
        /*MyLiveData.value1.observe(this, {
            Toast.makeText(this, "观察者数据变化:$it", Toast.LENGTH_SHORT).show()
        })*/
​
        // 第二步
        MyLiveData.value1.observe(this, object: Observer<String>{
            override fun onChanged(t: String?) {
                Toast.makeText(this@MainActivity4, "观察者数据变化$t", Toast.LENGTH_SHORT).show()
            }
        })

如上代码所示，你先setvalue 后订阅，就会收到 "我就是我，不一样的烟火5"，之前的旧数据，这就是粘性数据

正常应该先订阅再setValue.

什么是他们的状态

下图种显示

 

 

后期有时间再更新Lifecycle的源码学习笔记，这样更加便于理解

自此，LiveData主干逻辑讲述完成