视频看到这（结合源码），谈谈个人理解，望老师指正：

1) ViewModel

ViewModel 通过 ViewModelProvider(this).get(XXViewModel::class.java)获取，
这里的this可以是XXActivity/ XXFragment/.., 因为它们都实现了ViewModelStoreOwner接口，而ViewModelStoreOwner又持有ViewModelStore，其实就是个缓存viewmodel的一个hashmap（key为"$DEFAULT_KEY:$modelClass.canonicalName"）; 
这里的XXViewModel::class.java，就是我们定义的modelClass, 调用get方法来获取我们需要的 viewmodel 的实例（内部先判断 modelClass.isInstance(store[key] )缓存中是否已经存在这样的实例，有则直接用，无则创建）。

通过上面分析，由于key为"$DEFAULT_KEY:$modelClass.canonicalName"在同一个class中是唯一的，这样我们就可以把它放在一个activity中，由其fragment访问就可以实现viewmodel的数据共享。
另外由于XXActivity继承了ComponentActivity（持有mLifecycleRegistry对象），LifecycleRegistry是Lifecycle唯一子类实现，可以处理多个观察者的生命周期实现。
在ComponentActivity的onCreate中有调用ReportFragment.injectIfNeededIn(this)用来监听和分发Activitty生命周期的(大致流程：handleLifecycleEvent —> moveToState—> sync—> dispatchEvent—>onStateChanged)，这样在CommponentActivity添加lifecycly.addObserver()，比如监听页面销毁

直接贴代码：

getLifecycle().addObserver(new LifecycleEventObserver() {
            @Override
            public void onStateChanged(@NonNull LifecycleOwner source,
                    @NonNull Lifecycle.Event event) {
                if (event == Lifecycle.Event.ON_DESTROY) {
                    // Clear out the available context
                    mContextAwareHelper.clearAvailableContext();
                    // And clear the ViewModelStore
                    if (!isChangingConfigurations()) {
                        getViewModelStore().clear();
                    }
                }
            }
        });

可以看到页面销毁onDestory事件分发后，会判断如果不是由于Configurations变化（如横竖屏切换）导致的才会去销毁当前页面使用的所有ViewModel（不至于内存泄露）, 反之不销毁。从这里可以发现几点：1. ViewModel的生命周期比Activity要长；2. Configurations变化时，可以用viewmodel来临时缓存一鞋数据；3. 由于持有LifecycleRegistry对象，使viewmodel具有所谓的“感知生命周期”能力；4. 感觉比bundle更好用，bundle传个对象还得序列化一下。

总结，viewmodel 就是一个寄生在Lifecycle的页面间"传递数据"的工具罢了。

2) LiveData

LiveData is a data holder class that can be observed within a given lifecycle. This means that an Observer can be added in a pair with a LifecycleOwner, and this observer will be notified about modifications of the wrapped data only if the paired LifecycleOwner is in active state.

从LiveData源码描述来看，LiveData是一个可以在给定生命周期内观察到的数据持有者类。
这意味着可以将一个观察者添加到一对LifecycleOwner中，并且只有当配对的LifecycleOwner处于活动状态时，才会通知该观察者关于包装数据的修改。
结合上面的ViewModel分析，可以看出LiveData也是一个与LifecycleRegistry（所谓的“感知生命周期”）相关的组件，而且只有当界面的生命周期处于活跃状态时，观察者才能收到数据更新的通知。

一般 livedata通过传入LifecycleOwner监听数据变化（或者说订阅消息）：

livedata.observe(getViewLifecycleOwner()) {data->
       // onChanged()
}

那么livedata持有的数据(mData)什么时候发射呢？也就是这个onChanged() 什么时候会触发呢？
先看observe源码：

    @MainThread
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        assertMainThread("observe");
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {
            // ignore 
            // 如果页面（fragment/activity...）持有的当前的lifecycle处于DESTROYED状态则不处理
            return;
        }
        // 把observer包装成与lifecycle生命周期关联的LifecycleBoundObserver对象
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
        // 然后放入mObservers（map）中返回wrapper本身，如果observer有对应的wrapper则直接返回wrapper。
        ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
        // 如果observer已经添加并且不是同一个owner，则抛异常
        if (existing != null && !existing.isAttachedTo(owner)) {
            throw new IllegalArgumentException("Cannot add the same observer"
                    + " with different lifecycles");
        }
        // 如果observer已经添加则不处理，反之将wrapper添加到lifecycle生命周期中
        if (existing != null) {
            return;
        }
        owner.getLifecycle().addObserver(wrapper);
    }

大致逻辑：把observer先包装成LifecycleBoundObserver添加到lifecycle中。
再看liveData里面的几个主要方法：

private final Runnable mPostValueRunnable = new Runnable() {
        @SuppressWarnings("unchecked")
        @Override
        public void run() {
            Object newValue;
            synchronized (mDataLock) {
                // 待发数据赋给临时变量
                newValue = mPendingData;
                // 重置（说明待发数据已处理）
                mPendingData = NOT_SET;
            }
            // 发射数据
            setValue((T) newValue);
        }
    };
protected void postValue(T value) {
        boolean postTask;
        synchronized (mDataLock) {
            postTask = mPendingData == NOT_SET;
            mPendingData = value;
        }
        if (!postTask) {
            return;
        }
        // 交由异步线程处理
        ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
    }
@MainThread
    protected void setValue(T value) {
        assertMainThread("setValue");
        mVersion++;// 标记发射次数
        mData = value;
        dispatchingValue(null);// wrapper传null
    }
可以看出postValue最终还是调用setValue,

之后交由dispatchingValue处理，如果wrapper不为空则只分发给它，反之分发给所有的observer (setValue/postValue).

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，触发observer的onChange回调：

private void considerNotify(ObserverWrapper observer) {
        if (!observer.mActive) {// observer不是活跃状态则不处理
            return;
        }
        ...
        if (!observer.shouldBeActive()) {// lifecycle低于STARTED状态，则更新当前observer为不活跃状态
            observer.activeStateChanged(false);
            return;
        }
        if (observer.mLastVersion >= mVersion) {// 如果当前observer的发射次数比livedata的发射次数还高，也不处理。
            return;
        }
        observer.mLastVersion = mVersion;// 更新version
        observer.mObserver.onChanged((T) mData);// 触发observer的onChange回调。
    }

通过上面可以知道，我们主动调用setValue/postValue给dispatchingValue方法传的都是null，会遍历发射数据给所有活跃的观察者，那什么时候dispatchingValue传的不为null呢？
代码追溯：LifecycleRegistry.dispatchEvent(LifecycleOwner, Event) —> onStateChanged —> activeStateChanged —> dispatchingValue，最终又又又回到了 LifecycleRegistry（一个可以感知生命周期的家伙），上面分析ViewModel已经分析过了，不再赘述。 另外observeForever订阅时，也会主动触发一个 dispatchingValue。

This class is designed to hold individual data fields of ViewModel, but can also be used for sharing data between different modules in your application in a decoupled fashion.
LiveData 设计用于保存ViewModel的各个数据字段，但也可以用于以解耦方式在应用程序中的不同模块之间共享数据

最后：谷歌建议与ViewModel结合使用（即viewmodel持有LiveData对象，如：方便页面数据共享时，各frament都能订阅到数据变更），也可以用于不同模块间的数据共享。

总结：livedata是一个感知生命周期的“订阅消息”的组件，由于观察者会绑定到Lifecycle对象 wrapper(避免了内存泄露)，并且只有当界面的生命周期处于活跃onActive()状态，观察者才能收到数据更新的通知（除非你直接或间接触发setValue/postValue主动发射操作，比如页面刷新）。