使用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主干逻辑讲述完成