MutableLiveData

LiveData

 

把ViewModel和LiveData与Act和Frg的生命周期关系理清楚就好了

ViewMode持有数据时长是高于Act/Frg的onDestroy()的，前两者就算执行到onDestroy()了，
vm里的数据也依然会存在一会，横竖屏切换就不用担心数据丢失

liveData回调数据往UI上显示的时候，也会观察Act/Frg生命周期
如果Acr/Frg被销毁，liveData是不会把数据往UI上回调，这个是防止内存泄漏

• LiveData
  abstract LivaData是一个可以在lifeCycle中监听的dataHolder。
  注册的LifecycleOwner,active时才会更新数据，Livecycle.State.STARED,Livecycle.State.RESUMED。或者所有状态都更新observeForever(Observer)，然后手动调用removeObserver(Observer)。
  Lifecycle.State.DESTROY时自动反注册，防止泄露。
• onActive,onInActive
  LiveData中的方法，监听是否在监听中
• ViewModel
  LiveData保存了ViewModel中的数据，也可以在不同的ViewModel中共享数据。
  abstract ViewModel用来为Activity和Fragment准备和管理数据，管理Activity和Fragment与其它业务逻辑的交互。
  Activity方向变化，新建后会重新retain旧的ViewModel
  ViewModel是用来获取和保存Activity或者Fragment的信息。
  ViewModel通常是通过LiveData或者AndroidDataBinding来暴露数据
  ViewModel是为Ui管理数据，不应该持有UI信息。
  ViewModel可以用于Activity中多个Fragment的数据共享。

 

      public void onStart() {
         UserModel userModel = ViewModelProviders.of(getActivity()).get(UserModel.class);
     }

• MutableLiveData
  可以修改的LiveData，包含setValue和poistValue，LiveData也包含，只是LiveData是abstract的。

创建

• ViewModelProviders

 

    final UserModel viewModel = ViewModelProviders.of(this).get(UserModel.class);

ViewModelProviders创建一个ViewModelProvider
ViewModelProvider通过ViewModelStore保存了ViewModel，键值对的形式。
ViewModel是通过ViewModelProvider来实现缓存以及复用的。
ViewModelProvider.get创建或者得到ViewModel，会在Activity生命周期内创建
Activity,Fragment都有一个ViewModelStore，ViewModel会放进ViewModelStore中。
Activity,Fragmetn活动的时候，没有finish，没有killed，随着Activity和Fragment的生而生。因为是它的一个属性。
ViewModel就是一个普通的类，ViewModelProvider加了一层HashMap缓存来创建ViewModel，ViewModel跟随Activity消亡。

LiveData

• observe

 

  @MainThread
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> 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);
}

liveData监听Activity或者Fragment的生命周期，onStart或者onResume状态才会接收消息。
LifecycleOwner，Destroy时，observer自动被remove掉。
如果没有active，则不接收消息，如果重新active则接收最后一条消息。
一个LifecycleOwner只能添加一个observer。

• LiveCycleBoundObserver

 

class LifecycleBoundObserver extends ObserverWrapper implements GenericLifecycleObserver
  final LifecycleOwner mOwner;
   @Override
        boolean shouldBeActive() {
            return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
        }

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

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

• ObserverWraper

 

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

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

• setValue，postValue
  postValue最终也会调用setValue

 

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

最终调用了dispatchingValue(value),version++。version很重要，在发送数据改变时会判断会不会发送出去。

 

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

LiveData持有LifecycleOwner，可以根据生命周期的状态决定要不要发送事件。也是面向接口编程。发送数据时，考虑生命周期，考虑发送次数，不是active，只发送最后一条信息。