0.介绍
LiveData，同属于JetPack构建集合，根据文档描述LiveData是一个可观察的数据持有者类。与常规observable不同，LiveData是生命周期感知的，这意味着它尊重其他应用程序组件的生命周期，例如Activity，Fragment或Service。此感知确保LiveData仅更新处于活动生命周期状态的应用程序组件观察者。
优势（以下摘自google文档，google翻译了一下）
（1）确保您的UI符合您的数据状态
LiveData遵循观察者模式。生命周期状态更改时，LiveData会通知Observer对象。您可以合并代码以更新这些Observer对象中的UI。每次应用程序数据更改时，您的观察者都可以在每次更改时更新UI，而不是更新UI。
（2）没有内存泄漏
观察者绑定到Lifecycle对象并在其相关生命周期被破坏后自行清理。
由于停止活动而没有崩溃
如果观察者的生命周期处于非活动状态（例如，在后端堆栈中的活动的情况下），则它不会接收任何LiveData事件。
（3）不再需要手动生命周期处理
UI组件只是观察相关数据，不会停止或恢复观察。 LiveData自动管理所有这些，因为它在观察时意识到相关的生命周期状态变化。
（4）始终保持最新数据
如果生命周期变为非活动状态，则会在再次变为活动状态时接收最新数据。例如，后台活动在返回前台后立即收到最新数据。
（5）适当的配置更改
如果由于配置更改（例如设备轮换）而重新创建活动或片段，则会立即接收最新的可用数据。
（6）共享资源
您可以使用单例模式扩展LiveData对象以包装系统服务，以便可以在应用程序中共享它们。 LiveData对象连接到系统服务一次，然后任何需要该资源的观察者都可以只观看LiveData对象。
1.使用
class MainActivity : AppCompatActivity() {
val curName: MutableLiveData by lazy {
MutableLiveData()
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
curName.observe(this, Observer {
println("value is $it")
})
curName.value="old value"
}
}
使用很简单，当MutableLiveData对象的value发生改变时会出发Observer的onChanged方法，其中MutableLiveData继承自LiveData。
2.目的
（1）LiveData如何进行生命周期感知
（2）如何更新事件
（3）如何避免内存泄漏
3.分析
3.1LiveData如何进行生命周期感知
先看一下LiveData的observer方法
@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer observer) {
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);
}
看最后一行，owner.getLifecycle().addObserver(wrapper);owner就是咱们用的Activity或者Fragment，这就和上一篇文章Lifecycle对应上了
android Lifecycle源码分析--源码阅读100天（1），这里添加的监听者就是LifecycleBoundObservr，这个类实现了LifecycleObserver，这就是感应的生命周期的方式。
3.2如何更新事件
说实话，这个控件就是个观察者模式，事件的Observer就是这个LifecycleBoundObserver，看看这个对象的onStateChanged方法
@Override
public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
removeObserver(mObserver);
return;
}
activeStateChanged(shouldBeActive());
}
看一下activieStageChanged方法
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);
}
}
这个方法前面都是用来处理生命周期防止内存泄漏的，真正的用来观察数据进行处理的就是dispatchingValue方法，看一下这个方法
private 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, ObserverWrapper>> iterator =
mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
considerNotify(iterator.next().getValue());
if (mDispatchInvalidated) {
break;
}
}
}
} while (mDispatchInvalidated);
mDispatchingValue = false;
}
如果ObserverWrapper参数不为null，就调用considerNotify方法，否则就遍历mObservers，调用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);
}
首先判断ObserverWrapper是否需要被激活，如果需要被激活就调用activeStateChanged方法，否则就调用 我们自定义的Observer的onChanged((T) mData)方法。
3.3如何避免内存泄漏
回到onStateChanged的方法里调用的activeStateChanged(shouldBeActive())，看一下shouldBeActive方法
@Override
boolean shouldBeActive() {
return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
}
public boolean isAtLeast(@NonNull State state) {
return compareTo(state) >= 0;
}
这个方法就是将当前的state和STARTED进行对比，如果是STARTED或者RESUMED状态，那么传入activeStateChanged的参数就是true，否则就是false，再回看activeStateChanged方法
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);
}
}
}
当状态没有改变时，直接返回，否则根据newActive进行判断是否为activt状态，
if (wasInactive && mActive) {
onActive();
}
if (LiveData.this.mActiveCount == 0 && !mActive) {
onInactive();
}
之后根据mActive和activeCount调用onActive和onInactive方法。这就一目了然了，当生命周期调用onStart之后，就处于激活状态，onstop之后就处于非激活状态，这样数据改变时也就不会走到Observer的方法了，从而避免了内存泄漏。
关注我的公众号