Android架构组件(Architecture Compone

写在前面

在上一篇文章Android架构组件(Architecture Components)之 Lifecycle详解中，说到了要想了解LiveData，需要先了解Lifecycle。所以这次就开始来讲讲LiveData了。希望还没看过的朋友先看下上一篇文章，因为这篇文章会有一些依赖到上一篇文章的。

LiveData

结构

先来看看LiveData的结构：

livedata.png

LiveData其实是一个抽象类，但它的内部并没有抽象的方法。我们可以通过MutableLiveData来使用它。它的实现仅仅只是将setValue()和postValue()方法设置为public。所以重点还是应该来分析LiveData。除此之外，LiveData还有几个内部类：

observer.png

和LifecycleRegistry一样，LiveData内部也维护着一个观察者列表：mObservers，它的类型是SafeIterableMap<Observer<? super T>, ObserverWrapper>，对应存储的值是ObserverWrapper，用了装饰器模式将Observer给包装起来。为什么要将Observer包装起来呢？这是因为LiveData允许我们有两种不同的观察模式：有生命周期限制的观察者和一直观察的观察者，分别对应着它的两个子类：LifecycleBoundObserver和AlwaysActiveObserver。两种不同的方式供我们选择，给我们带来了很高的灵活性。

observe()

回到LiveData的方法上，先从使用频率最高的observe()方法入手。

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

首先要确保该方法是在主线程上调用的，否则会直接抛出异常。接着判断如果依附的LifecycleOwner目前已经是DESTROYED状态的话，就直接返回了。紧接着将方法传入的Observer和LifecycleOwner封装成一个LifecycleBoundObserver添加到队列中。最后向LifecycleOwner中注册了一个观察者。到这里为止，有了观察者和被观察者，整套机制就能运转起来了。

上一篇文章的最后，讲到了dispatchEvent()方法就结束了，再来回顾一下：

void dispatchEvent(LifecycleOwner owner, Event event) {
    State newState = getStateAfter(event);
    mState = min(mState, newState);
    mLifecycleObserver.onStateChanged(owner, event);
    mState = newState;
}

当时说了：

LifecycleObserver是一个LifecycleEventObserver，也是一个接口来着，继承了LifecycleObserver

结合上面的类图，LifecycleBoundObserver不仅是继承了ObserverWrapper，它还实现了LifecycleEventObserver接口。所以当LifecycleOwner的状态发生变化时，会走到LifecycleBoundObserver的onStateChanged()方法中：

@Override
public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
    if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
        removeObserver(mObserver);
        return;
    }
    activeStateChanged(shouldBeActive());
}

如果生命周期的状态变成了DESTROYED,LiveData会自动帮我们移除掉观察者，避免内存泄漏。

shouldBeActive()是一个抽象方法，来看下它的两个子类的不同。

// LifecycleBoundObserver
@Override
boolean shouldBeActive() {
    return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
}

// AlwaysActiveObserver
@Override
boolean shouldBeActive() {
    return true;
}

LifecycleBoundObserver中，只有当前的状态至少处于STARTED的才会被认为是活跃的。而AlwaysActiveObserver由于没有生命周期的概念，所以一直是处于活跃的状态的。这是它们的区别所在。

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

这里主要是判断Observer是否应该处于活跃状态，如果是的话，才去更新数据。这里又看到了熟悉的dispatchXXX()方法。

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

重点在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);
}

在这里会最后一次去检查Observer是否处于激活状态，并且目前的新的数据版本是否比当前高，条件都满足的话就会通知Observer更新数据了。

observeForever()

除了observe()方法外，还有一个observeForever()方法。这个比较简单，就是普通的观察者模式。使用这个方法，一定要注意，要在恰当的时机，通过removeObserver()或者removeObservers()将观察者移除掉，否则很可能会发生内存泄漏。

setValue()

通过LifecycleOwner的生命周期变化来决定是否要通知观察者，这只是LiveData通知观察者的一种方式。当数据发生变化时，LiveData也会通知观察者。

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

当数据发生变化时，会更新版本号，然后又是调用了dispatchingValue(),流程还是和上面的一样，就不再讲下去了。

postValue()

上面的setValue()要求在主线程中调用，如果是在子线程想更新数据的话，可以使用这个方法。

写在最后

和上一篇的LifecycleOwner结合起来，总算是把这套加入生命周期的观察者模式给理清了。剩下的就差ViewModel还没有分析了。