LiveData 是一个可以在给定生命周期内观察到的数据持有者类。 这意味着Observer可以与LifecycleOwner成对添加,并且仅当配对的 LifecycleOwner 处于活动状态时,才会通知此观察者有关包装数据的修改。
LifecycleOwner 被认为是活动的,如果它的状态是Lifecycle.State.STARTED或Lifecycle.State.RESUMED 。
通过observeForever(Observer)添加的observeForever(Observer)被视为始终处于活动状态,因此将始终收到有关修改的通知。 对于这些观察者,您应该手动调用removeObserver(Observer) 。
如果相应的 Lifecycle 移动到Lifecycle.State.DESTROYED状态,则会自动删除添加了 Lifecycle 的观察者。 这对于 Activity 和 Fragment 尤其有用,它们可以安全地观察 LiveData 而不必担心泄漏:它们在被销毁时会立即取消订阅。
此外,LiveData 有onActive()和onInactive()方法,可以在活动Observer的数量在 0 和 1 之间变化时得到通知。这允许 LiveData 在没有任何 Observer 正在积极观察时释放任何繁重的资源。
此类旨在保存ViewModel各个数据字段,但也可用于以解耦方式在应用程序中的不同模块之间共享数据。
类型参数:
– 此实例持有的数据类型
从调用处看起
@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
//事件在主线程上调度
assertMainThread("observe");
//如果给定的所有者已经处于Lifecycle.State.DESTROYED状态,LiveData 会忽略调用
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;
}
//为LifecycleBoundObserver绑定生命周期
owner.getLifecycle().addObserver(wrapper);
}
现在监听已经添加进去了,然后看看触发
触发的操作有 setValue 和 postValue两个方法
setValue只能在主线程里面操作;postValue可以在子线程里操作,它是借助Handler机制调用setValue进行实现的
@MainThread
protected void setValue(T value) {
// 主线程操作
assertMainThread("setValue");
mVersion++;
//设置value值,供后面使用
mData = value;
dispatchingValue(null);
}
dispatchingValue 这个方法在setValue的传入值为null,在另一个地方不为null。区别就是一个是直接触发设置的,另一个是根据生命周期的触发设置的。
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;
}
根据生命周期改变触发
@Override
public void onStateChanged(@NonNull LifecycleOwner source,
@NonNull Lifecycle.Event event) {
Lifecycle.State currentState = mOwner.getLifecycle().getCurrentState();
if (currentState == DESTROYED) {
removeObserver(mObserver);
return;
}
Lifecycle.State prevState = null;
while (prevState != currentState) {
prevState = currentState;
activeStateChanged(shouldBeActive());
currentState = mOwner.getLifecycle().getCurrentState();
}
}
void activeStateChanged(boolean newActive) {
if (newActive == mActive) {
return;
}
// immediately set active state, so we'd never dispatch anything to inactive
// owner
mActive = newActive;
changeActiveCounter(mActive ? 1 : -1);
//如果在活跃状态就更新
if (mActive) {
dispatchingValue(this);
}
}
这个就是在恢复活跃状态时进行设置的
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;
}
只有在setValue时才会增加,所以生命周期一直改变触发并不会多次调用onChange
if (observer.mLastVersion >= mVersion) {
return;
}
// mVersion
observer.mLastVersion = mVersion;
observer.mObserver.onChanged((T) mData);
}
@MainThread
public void observeForever(@NonNull Observer<? super T> observer) {
assertMainThread("observeForever");
AlwaysActiveObserver wrapper = new AlwaysActiveObserver(observer);
ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
if (existing instanceof LiveData.LifecycleBoundObserver) {
throw new IllegalArgumentException("Cannot add the same observer"
+ " with different lifecycles");
}
if (existing != null) {
return;
}
wrapper.activeStateChanged(true);
}
private class AlwaysActiveObserver extends ObserverWrapper {
AlwaysActiveObserver(Observer<? super T> observer) {
super(observer);
}
@Override
boolean shouldBeActive() {
return true;
}
}
observeForever 忽略了生命周期的控制,即使页面不可见 依然可以触发onChange, 但是要记得手动remove。防止内存泄漏