LiveData源码解析

是什么

是一个可观察的数据存储类，且具备宿主生命周期的感知能力。

优势

• 页面不可见时不会派发消息
• 页面可见时,会立刻派发最新的一条消息给所有观察者--保证页面最新状态
• 不再需要手动处理生命周期，避免NPE
• 支持黏性事件的分发
• 共享资源，可以使用单例模式拓展 LiveData，实现全局的，不用反注册，不会内存泄漏的消息分发总线。

各类之间的关系

image.png

注册观察者流程，事件分发原理

// LiveData.class
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        // 判断是否主线程
        assertMainThread("observe");
        
        // 如果宿主已经destroy，则return
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {
            return;
        }
        
        // 用LifecycleBoundObserver包装observer，其中包含LifecycleOwner，且能响应生命周期事, 如果页面destroy了，可以将observer自动从lifecycle移除
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
        
        // 将observer和wrapper保存起来，如果之前已经存在则返回之前的wrapper，否则返回null
        ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
        
        // 如果之前已经添加过该observer，且observer不是绑定当前owner，抛出异常
        if (existing != null && !existing.isAttachedTo(owner)) {
            throw new IllegalArgumentException("Cannot add the same observer"
                    + " with different lifecycles");
        }
        // 如果之前已经添加过该observer，则不再添加，return
        if (existing != null) {
            return;
        }
        owner.getLifecycle().addObserver(wrapper);
    }
    
// 更新mActiveCount，判断是否触发LiveData的onActive()和onInactive()
@MainThread
void changeActiveCounter(int change) {
        int previousActiveCount = mActiveCount;
        mActiveCount += change;
        if (mChangingActiveState) {
            return;
        }
        mChangingActiveState = true;
        try {
            // 更新mActiveCount
            while (previousActiveCount != mActiveCount) {
                boolean needToCallActive = previousActiveCount == 0 && mActiveCount > 0;
                boolean needToCallInactive = previousActiveCount > 0 && mActiveCount == 0;
                previousActiveCount = mActiveCount;
                
                // 触发onActive()或onInactive()
                // 可以充分利用 onActive() 方法被激活的时机，来实现一些数据懒加载的功能。
                if (needToCallActive) {
                    onActive();
                } else if (needToCallInactive) {
                    onInactive();
                }
            }
        } finally {
            mChangingActiveState = false;
        }
}

// 给Observer分发数据
void dispatchingValue(@Nullable ObserverWrapper initiator) {
        // 如果正在分发数据，则将mDispatchInvalidated置为true，后面分发结束后会再分发一次
        if (mDispatchingValue) {
            mDispatchInvalidated = true;
            return;
        }
        mDispatchingValue = true;
        do {
            mDispatchInvalidated = false;
            // 如果initiator则只给initiator分发，否则给所有observer分发数据
            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());
                    // 如果正在分发数据，dispatchingValue(observer)又被调用了，则停止本次分发，重新开始分发
                    if (mDispatchInvalidated) {
                        break;
                    }
                }
            }
        } while (mDispatchInvalidated);
        mDispatchingValue = false;
}

// 真正分发数据的地方
private void considerNotify(ObserverWrapper observer) {
        // 如果observer所在页面不是活跃状态，则不分发数据
        if (!observer.mActive) {
            return;
        }
        
        // 获取observer所在页面的最新状态，有可能页面状态变了，但是还没更新Observer的mActive
        // 我们仍然先判断observer.mActive，如果页面已经变为活跃状态，但是observer.mActive还没更新，即还是不活跃状态，则更新observer.mActive，但仍不分发数据
        if (!observer.shouldBeActive()) {
            observer.activeStateChanged(false);
            return;
        }
        
        // observer的数据版本大于LiveData的版本，即接收数据的次数大于发送数据的次数，说明observer已经收到最新的数据，不再回调observer#onChanged()通知更新
        // observer的mLastVersion=-1，如果之前已经发送过数据了，即mLastVersion<mVersion，则会出现黏性事件，后注册的观察者收到了前面发送的消息
        if (observer.mLastVersion >= mVersion) {
            return;
        }
        
        // 每分发一次消息，则把观察者和LiveData的version对齐，防止重复发送
        observer.mLastVersion = mVersion;

        // 通知更新
        observer.mObserver.onChanged((T) mData);
}
    
    
#########################################################


// LifecycleBoundObserver.class
class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver {
        @NonNull
        final LifecycleOwner mOwner;

        LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<? super T> observer) {
            super(observer);
            mOwner = owner;
        }

        // 当前界面是否活跃，即当前界面状态是否大于STARED
        @Override
        boolean shouldBeActive() {
            return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
        }

        // 当生命周期变化时回调
        @Override
        public void onStateChanged(@NonNull LifecycleOwner source,
                @NonNull Lifecycle.Event event) {
                
            // 获取当前界面状态
            Lifecycle.State currentState = mOwner.getLifecycle().getCurrentState();
            
            // 如果当前界面已经销毁，则移除observer
            if (currentState == DESTROYED) {
                removeObserver(mObserver);
                return;
            }
            
            Lifecycle.State prevState = null;
            while (prevState != currentState) {
                prevState = currentState;
                // 给父类OvserverWrapper设置活跃状态，如果是活跃的话分发数据
            activeStateChanged(shouldBeActive());
                currentState = mOwner.getLifecycle().getCurrentState();
            }
        }

        @Override
        boolean isAttachedTo(LifecycleOwner owner) {
            return mOwner == owner;
        }

        @Override
        void detachObserver() {
            mOwner.getLifecycle().removeObserver(this);
        }
    }

// ObserverWrapper.class
    private abstract class ObserverWrapper {
        final Observer<? super T> mObserver;
        boolean mActive;
        int mLastVersion = START_VERSION;

        ObserverWrapper(Observer<? super T> observer) {
            mObserver = observer;
        }

        abstract boolean shouldBeActive();

        boolean isAttachedTo(LifecycleOwner owner) {
            return false;
        }

        void detachObserver() {
        }

        // 设置活跃状态，如果是活跃的话分发数据
        void activeStateChanged(boolean newActive) {
            // 状态一样不做处理
            if (newActive == mActive) {
                return;
            }
            
            mActive = newActive;
            // 更新mActiveCount，判断是否出发LiveData的onActive()和onInactive()
            changeActiveCounter(mActive ? 1 : -1);
            
            // 如果是活跃的话，分发数据
            if (mActive) {
                dispatchingValue(this);
            }
        }
    }

image.png

小结

1. 首先调用LiveData#observe(owner, observer)进行注册，这时会将observer包装成LifecycleBoundObserver
2. LifecycleBoundObserver继承自ObserverWrapper，保存了Observer和LifecycleOwner，所以可以回调observer#onChanged(data)，也可以从LifecycleOwner中获得页面活跃状态；同时它实现了LifecycleEventObserver，所以能够监听lifecycle的生命周期事件，在页面销毁时移除observer，在页面变为活跃状态时，接收最新的数据（如果之前没有接收过的话）。
3. 如果是在页面onResume是注册的观察者，onStateChanged(owner, event)会回调3次：onCreate、onStart、onResume。但是observer#onChanged(data)只会回调一次，因为onStateChanged(owner, event)会判断如果页面状态和之前一样（mActive没有改变），则return。
4. 另外即使mActive改变了，但是如果数据没有改变，也不会回调observer#onChanged(data)，因为LiveData会根据ObserverWrapper#mLastVersion和自身的mVersion判断数据的接收次数和发送次数是否一致：mLastVersion<mVersion则发送；否则不发送。
5. LifecycleBoundObserver#onStateChanged(owner, event)回调时，会根据是否有活跃的观察者（mActiveCount）来触发LiveData#onActive()/onInactive()
6. 之后就会判断页面是否活跃，如果活跃则分发数据，调用considerNotify方法，通过ObserverWrapper#mLastVersion和LiveData#mVersion来判断是否触发Observer#onChanged(data)

发送数据

// LiveData.class

private final Runnable mPostValueRunnable = new Runnable() {
        @Override
        public void run() {
            Object newValue;
            // 加锁，防止主线程更新数据时，mPendingData被改变
            synchronized (mDataLock) {
                newValue = mPendingData;
                mPendingData = NOT_SET;
            }
            //noinspection unchecked
            setValue((T) newValue);
        }
};
    
    
protected void postValue(T value) {
        boolean postTask;
        // 加锁，防止主线程更新数据时，mPendingData被改变
        synchronized (mDataLock) {
            postTask = mPendingData == NOT_SET;
            mPendingData = value;
        }
        // 如果postTask=false，说明正在等待runnable获取mPendingData更新界面，不再发送runnable
        if (!postTask) {
            return;
        }
        ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
}

@MainThread
protected void setValue(T value) {
        assertMainThread("setValue");
        // 增加发送次数
        mVersion++;
        mData = value;
        // 通知所有的observer更新数据
        dispatchingValue(null);
}

image.png

数据倒灌是什么

页面在再次打开时，收到了旧数据。
比如，有3个fragment：列表、详情、编辑，它们都共享viewmodel中的同一个liveData，在编辑页编辑完后通过livedata保存数据，退出返回详情页时，详情页恢复活跃状态，会从liveData收到最新的数据更新界面。再次回退到列表页，点击另一个item打开详情页，这时详情页调用liveData#addObserver()会从liveData收到之前到旧数据，这就是数据倒灌。

如果解决黏性事件

1. 反射干涉Version
   不推荐这种方式，网上的方案是在LiveData#observe()方法中利用反射修改LifecycleBoundObserver中的mLastVersion的值=LiveData的mVersion，但是这种方案只适合在页面的onCreate（页面还不是活跃状态）时注册observer，因为这时页面的state是INITIALIZED， 在LiveData#observe()->LifecycleRegistrty#addObserver()中由于LifecycleRegistrty.mState=LifecycleBoundObserver.mState，导致不会回调ObserverWithState#dispatchEvent()->LifecycleBoundObserver#onStateChanged()，从而不会触发observer.onChanged()，也就达到了取消粘性事件的目的。但是如果在onStart()或之后（页面变为活跃状态）注册observer，由于这时页面的state是大于INITIALIZED的， 所以在LiveData#observe()->LifecycleRegistrty#addObserver()中会触发ObserverWithState#dispatchEvent()->LifecycleBoundObserver#onStateChanged()，也就导致observer.onChanged()被触发，还是发生粘性事件。

2. 自定义LiveData和Observer，分别在内部维护一个version。当不需要粘性事件时，在用LiveData注册Observer时，将LiveData的version赋值给observer的version；当需要粘性事件时，在用LiveData注册Observer时，设置Observer的version为-1。

参考：https://github.com/KunMinX/UnPeek-LiveData/blob/de958b679b/unpeeklivedata/src/main/java/com/kunminx/architecture/ui/callback/ProtectedUnPeekLiveData.java#L40-L176

public class ProtectedUnPeekLiveData<T> extends LiveData<T> {


  private final static int START_VERSION = -1;


  private final AtomicInteger mCurrentVersion = new AtomicInteger(START_VERSION);


  protected boolean isAllowNullValue;


  /**
   * TODO tip：当 liveData 用作 event 用途时，可使用该方法来观察 "生命周期敏感" 的非粘性消息
   * <p>
   * state 是可变且私用的，event 是只读且公用的，
   * state 的倒灌是应景的，event 倒灌是不符预期的，
   * <p>
   * 如果这样说还不理解，详见《LiveData 唯一可信源 读写分离设计》的解析：
   * https://xiaozhuanlan.com/topic/2049857631
   *
   * @param owner    activity 传入 this，fragment 建议传入 getViewLifecycleOwner
   * @param observer observer
   */
  @Override
  public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
    super.observe(owner, createObserverWrapper(observer, mCurrentVersion.get()));
  }


  /**
   * TODO tip：当 liveData 用作 event 用途时，可使用该方法来观察 "生命周期不敏感" 的非粘性消息
   *
   * @param observer observer
   */
  @Override
  public void observeForever(@NonNull Observer<? super T> observer) {
    super.observeForever(createObserverWrapper(observer, mCurrentVersion.get()));
  }


  /**
   * TODO tip：当 liveData 用作 state 用途时，可使用该方法来观察 "生命周期敏感" 的粘性消息
   *
   * @param owner    activity 传入 this，fragment 建议传入 getViewLifecycleOwner
   * @param observer observer
   */
  public void observeSticky(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) {
    super.observe(owner, createObserverWrapper(observer, START_VERSION));
  }


  /**
   * TODO tip：当 liveData 用作 state 用途时，可使用该方法来观察 "生命周期不敏感" 的粘性消息
   *
   * @param observer observer
   */
  public void observeStickyForever(@NonNull Observer<? super T> observer) {
    super.observeForever(createObserverWrapper(observer, START_VERSION));
  }


  /**
   * TODO tip：只需重写 setValue
   * postValue 最终还是会经过这里
   *
   * @param value value
   */
  @Override
  protected void setValue(T value) {
    mCurrentVersion.getAndIncrement();
    super.setValue(value);
  }


  /**
   * TODO tip：
   * 1.添加一个包装类，自己维护一个版本号判断，用于无需 map 的帮助也能逐一判断消费情况
   * 2.重写 equals 方法和 hashCode，在用于手动 removeObserver 时，忽略版本号的变化引起的变化
   */
  class ObserverWrapper implements Observer<T> {
    private final Observer<? super T> mObserver;
    private int mVersion = START_VERSION;


    public ObserverWrapper(@NonNull Observer<? super T> observer, int version) {
      this.mObserver = observer;
      this.mVersion = version;
    }


    @Override
    public void onChanged(T t) {
      if (mCurrentVersion.get() > mVersion && (t != null || isAllowNullValue)) {
        mObserver.onChanged(t);
      }
    }


    @SuppressWarnings("unchecked")
    @Override
    public boolean equals(Object o) {
      if (this == o) {
        return true;
      }
      if (o == null || getClass() != o.getClass()) {
        return false;
      }
      ObserverWrapper that = (ObserverWrapper) o;
      return Objects.equals(mObserver, that.mObserver);
    }


    @Override
    public int hashCode() {
      return Objects.hash(mObserver);
    }
  }


  /**
   * TODO tip：
   * 通过 ObserveForever 的 Observe，需要记得 remove，不然存在 LiveData 内存泄漏的隐患，
   * 保险的做法是，在页面的 onDestroy 环节安排 removeObserver 代码，
   * 具体可参见 app module 中 ObserveForeverFragment 的案例
   *
   * @param observer observeForever 注册的 observer，或 observe 注册的 observerWrapper
   */
  @Override
  public void removeObserver(@NonNull Observer<? super T> observer) {
    if (observer.getClass().isAssignableFrom(ObserverWrapper.class)) {
      super.removeObserver(observer);
    } else {
      super.removeObserver(createObserverWrapper(observer, START_VERSION));
    }
  }


  private ObserverWrapper createObserverWrapper(@NonNull Observer<? super T> observer, int version) {
    return new ObserverWrapper(observer, version);
  }


  /**
   * TODO tip：
   * 手动将消息从内存中清空，
   * 以免无用消息随着 SharedViewModel 的长时间驻留而导致内存溢出的发生。
   */
  public void clear() {
    super.setValue(null);
  }


}