ViewModel对象

创建viewModel对象

val mainVm: ViewModel = ViewModelProviders.of(this@MainActivity).get(MainVm::class.java)

ViewModelProvider数据结构

/**
*通过ViewModelProvider.AndroidViewModelFactory.getInstance(application)获得
*所以对象的具体类型为AndroidViewModelFactory 跟 application绑定
*/
private final Factory mFactory;
/**
*ViewModelStore 通过构造函数赋值 通过activity.getViewModelStore方法直接new ViewModelStore()返回
*所以ViewModelStore是activity的成员变量只跟activity绑定
*/
private final ViewModelStore mViewModelStore;

public <T extends ViewModel> T get(@NonNull String key, @NonNull Class<T> modelClass) {
        ViewModel viewModel = mViewModelStore.get(key);

        if (modelClass.isInstance(viewModel)) {
            //noinspection unchecked
            return (T) viewModel;
        } else {
            //noinspection StatementWithEmptyBody
            if (viewModel != null) {
                // TODO: log a warning.
            }
        }

        viewModel = mFactory.create(modelClass);
        mViewModelStore.put(key, viewModel);
        //noinspection unchecked
        return (T) viewModel;
    }

LiveData的订阅

mainVm.nameLiveData.observe(this@MainActivity, Observer {
                Log.v(TAG, it)
        })

    @MainThread
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        assertMainThread("observe");
        //判断activity生命周期
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {
            // ignore
            return;
        }
        //对Observer进行包装 LifecycleBoundObserver继承ObserverWrapper 内部持有当前Observer
        //变量和mLastVersion初始值为-1 下文针对mLastVersion会继续分析
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
        ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
      //判断当前owner是否已经添加过wrapper
        if (existing != null && !existing.isAttachedTo(owner)) {
            throw new IllegalArgumentException("Cannot add the same observer"
                    + " with different lifecycles");
        }
        if (existing != null) {
            return;
        }
      //将wrapper加入activity的LifecycleRegistry中  LifecycleRegistry在ComponentActivity的成员变量  
     //中创建
        owner.getLifecycle().addObserver(wrapper);
    }

LifecycleRegistry源码分析

    /**
     * Custom list that keeps observers and can handle removals / additions during traversal.
     *
     * Invariant: at any moment of time for observer1 & observer2:
     * if addition_order(observer1) < addition_order(observer2), then
     * state(observer1) >= state(observer2),
     */
    private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap =
            new FastSafeIterableMap<>();
    /**
     * Current state
     */
    private State mState;

    @Override
    public void addObserver(@NonNull LifecycleObserver observer) {
        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
        //其实就是持有当前状态的observer包装类
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
        ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
        //判断是否已经在mObserverMap中添加过
        if (previous != null) {
            return;
        }
        //mLifecycleOwner即为当前的activity
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        if (lifecycleOwner == null) {
            // it is null we should be destroyed. Fallback quickly
            return;
        }

        boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
        State targetState = calculateTargetState(observer);
        mAddingObserverCounter++;
        //通过反射将statefulObserver.mState的状态改掉可以避免事件接受发生在订阅以后
        while ((statefulObserver.mState.compareTo(targetState) < 0
                && mObserverMap.contains(observer))) {
            //将当前生命周期状态加入数组
            pushParentState(statefulObserver.mState);
            //分发当前的事件(重点)
            statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
            //从当前的数组中移除当前生命周期
             popParentState();
            // mState / subling may have been changed recalculate
            //重新计算当前的生命周期状态
            targetState = calculateTargetState(observer);
        }

        if (!isReentrance) {
            // we do sync only on the top level.
            sync();
        }
        mAddingObserverCounter--;
    }


static class ObserverWithState {
        State mState;
        GenericLifecycleObserver mLifecycleObserver;

        ObserverWithState(LifecycleObserver observer, State initialState) {
            //返回ExternalLifecycleBoundObserver类型的对象
            mLifecycleObserver = Lifecycling.getCallback(observer);
            mState = initialState;
        }

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

class ExternalLifecycleBoundObserver extends LifecycleBoundObserver

class LifecycleBoundObserver extends ObserverWrapper implements GenericLifecycleObserver

LifecycleBoundObserver为LiveData的内部类

 class LifecycleBoundObserver extends ObserverWrapper implements GenericLifecycleObserver {
        @NonNull
        final LifecycleOwner mOwner;

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

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

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

调用到LiveData的dispatchingValue方法

    @MainThread
    protected void setValue(T value) {
        assertMainThread("setValue");
      //每次发送事件会造成mVersion+1
        mVersion++;
        mData = value;
        dispatchingValue(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;
    }


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;
        }
        //这也是为什么会造成事件订阅发生在事件发送之后还会收到消息的原因 因为mVersion+1>observer.mLastVersion        
      //解决方法是在发生订阅的时候通过反射拿到ObserverWrapper中的mLastVersion并将其值设置为LiveData中的mVersion 这样就解决了订阅发生在事件发送以后并还能触发回调的问题
        if (observer.mLastVersion >= mVersion) {
            return;
        }
        observer.mLastVersion = mVersion;
        //noinspection unchecked
        //出发Observer的onChanged方法回调
        observer.mObserver.onChanged((T) mData);
    }