Android 架构组件 LiveData 的实现

阅读 275
收藏 1
2018-07-17
原文链接:mp.weixin.qq.com

本文由水晶虾饺授权投稿作者博客:https://jekton.github.io/

本篇我们来看看 Android 架构组件中的 LiveData 。跟 ViewModel 相比,LiveData 具有生命周期感知能力,也就是说,他把 ViewModel 和 lifecycle 结合了起来。当应用的数据有更新时,一般我们仅希望应用对用户可见时才更新 UI;更进一步,如果应用不可见,我们甚至可以停止数据的更新。这就是所谓的“感知应用的生命周期”。

这里我们主要关注 LiveData 的实现,用法可以参考 Google 的教程[1]

以下源码使用 1.1.1 版本

添加 Observer

使用 LiveData 时,首先要做的,就是添加一个 Observer

public interface Observer<T> {  /**   * Called when the data is changed.   * @param t  The new data   */  void onChanged(@Nullable T t);}// 注意,他是 abstract classpublic abstract class LiveData<T> {  // 只有 onStart 后,对数据的修改才会触发 observer.onChanged()  public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) {}  // 无论何时,只要数据发生改变,就会触发 observer.onChanged()  public void observeForever(@NonNull Observer<T> observer) {}}

由于 LiveData 是一个 abstract class,我们不能直接生成他的实例。对于数据的拥有者,可以使用 MutableLiveData:

public class MutableLiveData<T> extends LiveData<T> {  @Override  public void postValue(T value) {    // LiveData.postValue() 是一个 protected 方法    super.postValue(value);  }  @Override  public void setValue(T value) {    // LiveData.setValue() 是一个 protected 方法    super.setValue(value);  }}

所谓数据的拥有者。举个例子,你使用的是 MVP 模式,那么数据就属于 Model 层,另外两层不应该修改数据。

通过让这两个 setter 方法成为 protected,只要我们给客户返回的是 LiveData,就不用担心数据会被客户意外修改:

class SomeClass extends ViewModel {  // 在类的内部持有的是 MutableLiveData,所以我们可以调用 postValue/setValue  private final MutableLiveData<Foo> mYourData = new MutableLiveData<>();  // 返回的是 LiveData,LiveData 的 public 方法中并没有 postValue/setValue  public LiveData<Foo> getData() {    return mYourData;  }}

活用 public, protected, private, default access 和 final 可以让我们的设计意图更加清晰。

现在回到我们的 observe() 方法,observeForever 的实现跟 observe 是类似的,我们就不看了,这里只看 observe():

public abstract class LiveData<T> {  public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) {    // activity 已经 destroy,也就没必要添加 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)) {      // 同一个 observer,只有对应的 lifecycleOwner 不一样,才可以重新添加      throw new IllegalArgumentException("Cannot add the same observer"          + " with different lifecycles");    }    if (existing != null) {      return;    }    // 这种方式添加的 observer,只有 activity 可见时才会收到数据更新的通知,    // 为了知道什么时候 activity 是可见的,这里需要注册到 Lifecycle。    // 也是因为这个,observe() 比 observeForever() 多了一个参数 lifecycleOwner    owner.getLifecycle().addObserver(wrapper);  }}

我们继续看 LifecycleBoundObserver:

public abstract class LiveData<T> {  // 空实现,如果在 LiveData 变为 inactive 状态后想停止更新数据,可以  // override 这两个方法  protected void onActive() {}  protected void onInactive() {}  private abstract class ObserverWrapper {    final Observer<T> mObserver;    boolean mActive;    int mLastVersion = START_VERSION;    ObserverWrapper(Observer<T> observer) {      mObserver = observer;    }    // 如果 observer 处于 active 状态,则返回 true    abstract boolean shouldBeActive();    boolean isAttachedTo(LifecycleOwner owner) {      return false;    }    void detachObserver() {    }    void activeStateChanged(boolean newActive) {      if (newActive == mActive) {        return;      }      // immediately set active state, so we'd never dispatch anything to inactive      // owner      mActive = newActive;      // LiveData.this.mActiveCount 表示处于 active 状态的 observer 的数量      // 当 mActiveCount 大于 0 时,LiveData 处于 active 状态      // 注意区分 observer 的 active 状态和 LiveData 的 active 状态      boolean wasInactive = LiveData.this.mActiveCount == 0;      LiveData.this.mActiveCount += mActive ? 1 : -1;      if (wasInactive && mActive) {        // inactive -> active        onActive();      }      // 这里用 else if 比较好,因为只有一个会执行。else if 更易读      if (LiveData.this.mActiveCount == 0 && !mActive) {        // mActiveCount 在我们修改前等于 1,也就是说,LiveData 从 active        // 状态变到了 inactive        onInactive();      }      if (mActive) {        // observer 从 inactive 到 active,此时客户拿到的数据可能不是最新的,这里需要 dispatch 一下        // 关于他的实现,我们下一节再看        dispatchingValue(this);      }    }  }  class LifecycleBoundObserver extends ObserverWrapper implements GenericLifecycleObserver {    @NonNull final LifecycleOwner mOwner;    LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<T> observer) {      super(observer);      mOwner = owner;    }    @Override    boolean shouldBeActive() {      // onStart 到 onStop 之间则认为是 active 状态      return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);    }    // 这个是 lifecycle 的回调函数    @Override    public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {      if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {        removeObserver(mObserver);        return;      }      // 刚刚生成 LifecycleBoundObserver 的实例时,mActive == false,注册到      // Lifecycle 后,Lifecycle 会同步状态给我们(也就是回调本函数)。      // 不熟悉 lifecycle 的读者,可以看      // https://jekton.github.io/2018/07/06/android-arch-lifecycle/      activeStateChanged(shouldBeActive());    }    @Override    boolean isAttachedTo(LifecycleOwner owner) {      return mOwner == owner;    }    @Override    void detachObserver() {      mOwner.getLifecycle().removeObserver(this);    }  }}

到这里,observer 的注册我们就看完了。下面我们看看如何发布(publish)数据给 LiveData。

发布修改

要修改 LiveData,有两种方式:

public abstract class LiveData<T> {  // 同步修改数据  protected void setValue(T value);  // 会用 Handler post 一个 runnable,然后在 runnable 里面 setValue  protected void postValue(T value);}

setValue 比较简单,我们先看 setValue:

public abstract class LiveData<T> {  @MainThread  protected void setValue(T value) {    assertMainThread("setValue");    // 每次更新 value,都会使 mVersion + 1    // ObserverWrapper 也有一个字段,叫 mLastVersion    // 通过比较这两个字段,可以避免重复通知客户(具体在后面会看到)    mVersion++;    mData = value;    dispatchingValue(null);  }  // 如果 initiator == null,表示要通知所有的 observer  // 不等于 null 则只通知 initiator  private void dispatchingValue(@Nullable ObserverWrapper initiator) {    if (mDispatchingValue) {      // 在 observer 的回调里面又触发了数据的修改      // 设置 mDispatchInvalidated 为 true 后,可以让下面的循环知道      // 数据被修改了,从而开始一轮新的迭代。      //      // 比方说,dispatchingValue -> observer.onChanged -> setValue      //            -> dispatchingValue      // 这里 return 的是后面那个 dispatchingValue,然后在第一个      // dispatchingValue 会重新遍历所有的 observer,并调用他们的      // onChanged。      //      // 如果想避免这种情况,可以在回调里面使用 postValue 来更新数据      mDispatchInvalidated = true;      return;    }    mDispatchingValue = true;    do {      mDispatchInvalidated = false;      if (initiator != null) {        // 调用 observer.onChanged()        considerNotify(initiator);        initiator = null;      } else {        for (Iterator<Map.Entry<Observer<T>, ObserverWrapper>> iterator =            mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {          considerNotify(iterator.next().getValue());          if (mDispatchInvalidated) {            // 某个客户在回调里面更新了数据,break 后,这个 for 循环会            // 重新开始            break;          }        }      }    // 当某个客户在回调里面更新了数据,mDispatchInvalidated == true    } while (mDispatchInvalidated);    mDispatchingValue = false;  }}

看过我那篇 lifecycle 源码分析的读者应该对 dispatchingValue 处理循环调用的方式很熟悉了。以这里为例,为了防止循环调用,我们在调用客户代码前先置位一个标志(mDispatchingValue),结束后再设为 false。如果在回调里面又触发了这个方法,可以通过 mDispatchingValue 来检测。

检测到循环调用后,再设置第二个标志(mDispatchInvalidated),然后返回。返回又会回到之前的调用,前一个调用通过检查 mDispatchInvalidated,知道数据被修改,于是开始一轮新的迭代。

下面是 considerNotify:

public abstract class LiveData<T> {  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;    }    // 对于 LifecycleBoundObserver 来说,即使 LiveData 的数据没有变化,只要 activity 的生命    // 周期发生了改变,还是可能会调用 considerNotify 多次    // 通过比较 observer.mLastVersion 和 mVersion,就能够知道 observer 是否已经拥有了最新的数据    //    // 实际上,observer.mLastVersion 最多只能等于 mVersion    if (observer.mLastVersion >= mVersion) {      return;    }    observer.mLastVersion = mVersion;    //noinspection unchecked    observer.mObserver.onChanged((T) mData);  }}

看完了 setValue,postValue 对我们来说就很简单了:

public abstract class LiveData<T> {  // 注意,他是 volatile。因为 postValue 可以从后台线程调用,  private volatile Object mPendingData = NOT_SET;  private final Runnable mPostValueRunnable = new Runnable() {    @Override    public void run() {      Object newValue;      synchronized (mDataLock) {        newValue = mPendingData;        mPendingData = NOT_SET;      }      //noinspection unchecked      setValue((T) newValue);    }  };  protected void postValue(T value) {    boolean postTask;    synchronized (mDataLock) {      postTask = mPendingData == NOT_SET;      mPendingData = value;    }    if (!postTask) {      // 已经有一个 post 后还没有执行的 runnable,所以就不需要再 post 了,      // 前面 post 的 runnable 执行时,会拿到这个新设置的 value      return;    }    // 最终执行的就是 handler.post()    ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);  }}

LiveData 的核心代码我们已经看完了,其实它的实现也挺简单的,对吧?

总结

关于 LiveData,有两个值得我们学习的,一个是循环调用的处理,另一个是 mVersion 的使用。关于 mVersion,这里再举一个之前工作中遇到的例子。

在后台线程对数据进行持久化的时候(这个线程拷贝了一份数据),数据还有可能会被更新。为了判断所保存的数据是不是最新的,我当时的做法就是引入一个类似 mVersion 的东西,每次修改数据,都把 mVersion 加 1。通过比较 mVersion 和所保存的数据的 version,就能够知道是不是保存了最新的数据(当然,更好的做法是告诉后台线程数据已经修改,让他重新拿一次数据)。

附:[1]https://developer.android.google.cn/topic/libraries/architecture/

— — — END — — —

近期文章回顾

评论