Android Jetpack之LiveData源码分析

LiveData的使用会结合Lifecycles和ViewModel一起使用，不了解二者的，建议先看这两篇文章：
Android Jetpack之ViewModel源码分析
Android Jetpack之Lifecycles源码分析

LiveData 简介

LiveData 是保存数据对象的类，通过注册监听器Observer 监听数据的变化。LiveData最大的优势：LiveData 是感知Activity、Fragment等生命周期的组件，Observer 可以指定监听的生命周期（Lifecycle）对象。当 Observer 的 Lifecycle 对象处于 STARTED 或者 RESUMED 状态的时候， LiveData 处于活动状态，在活动状态下数据变化会通知到相应的Observer。当相应Lifecycle对象的状态改变为DESTROYED时移除观察者，所以避免造成内存泄漏。当然也可以不和Lifecycles绑定，使用observeForever(Observer)方法注册一个没有关联生命周期所有者对象的观察者，观察者总是处于活动状态，因此数据变化事件总是会被通知到，可以通过调用removeObserver(Observer) 删除observer。
官网指导链接Android jetpack之LiveData

LiveData的简单使用

2.1、创建一个ViewModel类

创建一个ViewModel类，里面有LiveData实例来保存数据。使用ViewModel是为了在屏幕旋转等操作下时可以恢复现场数据。

class MyLiveDataViewModel : ViewModel(){    var liveData: MutableLiveData?= null        get() {            if(field == null){                field = MutableLiveData()            }            return field        }}

2.2 创建observer

（1）代码1: 创建LiveDataActivity实现LifecycleOwner接口，为了Observer和组件的生命周期绑定。
（2）代码2: 获取定义的MyLiveDataViewModel实例
（3）代码3: 创建定义onChanged()方法的Observer对象，在数据变化时更新UI页面。
（4）代码4: LiveData订阅观察，将LiveData和Lifecycles、Observer绑定，
（5）代码5: LiveData设置新数据，通知观察者更新数据。可以在子线程中执行。
完整代码如下：

//代码1class LiveDataActivity : AppCompatActivity(),LifecycleOwner{    private lateinit var lifecycleRegistroy: LifecycleRegistry    private var coun : Int by Delegates.notNull()    override fun getLifecycle(): Lifecycle {        return lifecycleRegistroy    }    override fun onCreate(savedInstanceState: Bundle?) {        super.onCreate(savedInstanceState)        setContentView(R.layout.activity_live_data)        lifecycleRegistroy = LifecycleRegistry(this)        coun = 0        //代码2        var viewModel = ViewModelProviders.of(this).get(MyLiveDataViewModel::class.java)        //代码3        val observer = Observer{            text.text = it        }        button.setOnClickListener {        //代码5            viewModel.liveData?.postValue("changed !!!!"+coun++)}        //代码4        viewModel.liveData?.observe(this,observer)    }}

源码分析

3.1 LiveData.observe方法

在Activity中通过添加observe方法将Lifecycles和Observer绑定起来。下面我们来分析该方法。该方法有两个参数：

LifecycleOwner是为了处理生命周期改变。
Observer是为了监听LiveData的数据变化的观察者。

下面来分析observe方法内部的实现原理：

在observe方法内部判断了Lifecycler的当前状态，如果State处于DESTROYED，即观察者处于DESTROYED状态时，不做任何处理。
如果处于活跃状态，则创建LifecycleBoundObserver实例保存传入的LifecycleOwner和Observer，并保存在mObservers中。SafeIterableMap存储的是键值对的形式，使用的是SafeIterableMap数据结构，不熟悉的可以参考Android Jectpack之Lifecycles源码分析。KEY是Observer，VALUE是LifecycleBoundObserver类。
如果Observer对象已经存在对应的Lifecycles则抛出异常。
为LifecycleOwner添加生命周期的观察者，其实就是LifecycleBoundObserver类，该类实现了GenericLifecycleObserver接口，可以通过onStateChanged方法监听LifecycleOwner的State变化。

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

3.2 LifecycleBoundObserver类

3.2.1 LifecycleBoundObserver类

通过observe.observer的分析我们知道，内部主要是用了LifecycleBoundObserver类，下面分析该类

LifecycleBoundObserver 继承自 ObserverWrapper 而且实现 GenericLifecycleObserver接口，而 GenericLifecycleObserver 接口又继承自 LifecycleObserver 接口。在Lifecycles的源码分析我们知道，实现了LifecycleObserver接口而且 LifecycleOwner 的观察者里可以获取 LifecycleOwner 的状态。
shouldBeActive方法表示只有STARTED，RESUMED才是活跃状态
当Lifecycles的State发生变化会回调onStateChanged方法，当State为DESTROYED是，则移除观察气Observer。里面调用的是LiveData的removeObserver方法（下面会分析）。
当State非DESTROYED，则调用ObserverWrapper的activeStateChanged方法。

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

3.2.2 ObserverWrapper类

LifecycleBoundObserver 继承自 ObserverWrapper并且在onStateChanged中调用了activeStateChanged的方法，下面来分析一下ObserverWrapper类。

ObserverWrapper 在LifecycleOwner活跃状态改变时回调onActive和onInactive方法。Owner为活跃状态时回调onActive() ，当Owner未活跃状态时回调onInactive()
当状态变为活跃态是，LiveData.this.mActiveCount加1
当变成活跃态时，会执行dispatchingValue方法，通知Observer并发送最新的数据。（源码分析在下一节）
onActive() ：当 LiveData 具有活动状态的 Observer 的时候会调用这个函数。当我们自定义LiveData时，可以在这个函数中处理自己的业务逻辑
onInactive()：当 LiveData 没有活动状态的 Observer 的时候会调用这个函数。当我们自定义LiveData时，可以在这个函数中处理自己的业务逻辑，不如一些非后台的操作或者变量的释放。

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

3.2.3 AlwaysActiveObserver类

使用observeForever(Observer)方法注册一个没有关联生命周期所有者对象的观察者，观察者总是处于活动状态，因此数据变化事件总是会被通知到。下面我们来看一下其中的原理：

public void observeForever(@NonNull Observer<? super T> observer) {        assertMainThread("observeForever");        AlwaysActiveObserver wrapper = new AlwaysActiveObserver(observer);        ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);        if (existing != null && existing instanceof LiveData.LifecycleBoundObserver) {            throw new IllegalArgumentException("Cannot add the same observer"                    + " with different lifecycles");        }        if (existing != null) {            return;        }        wrapper.activeStateChanged(true);    }

在observeForever使用的AlwaysActiveObserver该类不同于LifecycleBoundObserver类，没有实现GenericLifecycleObserver接口，所以不能感激组件的生命周期变化，并且其实该方法，也没有LifecycleOwner的形参。在AlwaysActiveObserver 的类内部的shouldBeActive方法用于返回ture，并且在observeForever内部将ObserverWrapper.mActive设置为true，也就是标明永远是处于活跃状态，所以Observer是一直可以观察数据变化的。

 private class AlwaysActiveObserver extends ObserverWrapper {        AlwaysActiveObserver(Observer<? super T> observer) {            super(observer);        }        @Override        boolean shouldBeActive() {            return true;        }    }

3.3 LiveData类

在Activity中，通过postValue或者setValue改变LivwData的数据，在通过Observer，观察LIveData数据的变化。通过上面的分析，我们已经知道了Observer是如何和组件的生命周期绑定起来的，下面我们就分析一下，LiveData的数据更新是如何通知到Observer 的。

3.3.1 setValue方法

先来分析一下setValue()方法，setValue()必须在主线程中调用，否则会报错，而postValue则没有这个检查。看到有无post的区别，第一反应就是是invalidate和postInvalidate的区别。

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

调用assertMainThread()检查是否在主线程。
把更新的数据赋给mData。
调用 dispatchingValue()方法并传入null，将数据分发给所有观察者。dispatchingValue如果传入null则是所有的观察者，如果是具体的ObserverWrapper对象，则通知到具体的Observer。

3.3.2 dispatchingValue方法

下面在分析一下dispatchingValue方法。

dispatchingValue参数传null将会通知所有的观察者，
dispatchingValue不传null只会通知传入的观察者。
在代码1处，通过遍历 mObservers ，将所有的 LifecycleBoundObserver 取出，对每个观察者调用considerNotify()方法，considerNotify方法就是真正通知到观察者的代码了。

void dispatchingValue(@Nullable ObserverWrapper initiator) {        if (mDispatchingValue) {            mDispatchInvalidated = true;            return;        }        mDispatchingValue = true;        do {            mDispatchInvalidated = false;            if (initiator != null) {                considerNotify(initiator);                initiator = null;            } else {               //代码1                for (Iterator, ObserverWrapper>> iterator =                        mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {                    considerNotify(iterator.next().getValue());                    if (mDispatchInvalidated) {                        break;                    }                }            }        } while (mDispatchInvalidated);        mDispatchingValue = false;    }

3.3.4 considerNotify方法

如果ObserverWrapper的状态为非活跃态则直接返回。这就验证了只有STARTED、RESUMED才能接受数据的结论
considerNotify方法中调用mObserver的onChange方法，从而通知Observer更新数据。

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;        }        if (observer.mLastVersion >= mVersion) {            return;        }        observer.mLastVersion = mVersion;        //noinspection unchecked        observer.mObserver.onChanged((T) mData);    }

3.3.5 postValue方法

postValue方法可以在非主线程中更新数据。主要是通过ArchTaskExecutor和DefaultTaskExecutor切换到主线程中。然后回调到Runnable方法中，在Runnable的run方法其实也是调用了setValue方法来实现通知观察者更新数据的逻辑的。

protected void postValue(T value) {        boolean postTask;        synchronized (mDataLock) {            postTask = mPendingData == NOT_SET;            mPendingData = value;        }        if (!postTask) {            return;        }        ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);    }

  private final Runnable mPostValueRunnable = new Runnable() {        @Override        public void run() {            Object newValue;            synchronized (mDataLock) {                newValue = mPendingData;                mPendingData = NOT_SET;            }            //noinspection unchecked            setValue((T) newValue);        }    };

3.3.6 ArchTaskExecutor类

ArchTaskExecutor是单例模式。继承自TaskExecutor。

public static ArchTaskExecutor getInstance() {        if (sInstance != null) {            return sInstance;        }        synchronized (ArchTaskExecutor.class) {            if (sInstance == null) {                sInstance = new ArchTaskExecutor();            }        }        return sInstance;    }

当调用postToMainThread切换线程是，内部实际上是执行了DefaultTaskExecutor类的postToMainThread方法。

public void postToMainThread(Runnable runnable) {        mDelegate.postToMainThread(runnable);    }

DefaultTaskExecutor类的postToMainThread内部通过Handler实现线程的切换。

@Override    public void postToMainThread(Runnable runnable) {        if (mMainHandler == null) {            synchronized (mLock) {                if (mMainHandler == null) {                    mMainHandler = new Handler(Looper.getMainLooper());                }            }        }        //noinspection ConstantConditions        mMainHandler.post(runnable);    }

3.4 小结

使用LifecycleOwner的observe() 方法将观察者对象附加到LiveData对象，将观察者向LiveData对象订阅，以便通知LiveData中数据的变化。
当Lifecycle 没有处于活动状态（ (STARTED 、RESUMED)），Observer 则不会被通知，即使数据发生了变化，没有处于活动状态的 Observer 也不会被通知。
Lifecycle 被销毁（destroyed）Observer 也自动被删除，无需用户手动清理。
避免内存泄漏：Observer 和 Lifecycle 绑定，可以感知组件生命周期，所以当 Lifecycle 被销毁后，Observer 自动被remove避免内粗泄漏。

LiveData高阶使用

4.1 转换LiveData

LiveData 支持简单的数据变换。

map 是把一个数据类型变换为另外一个数据类型。
switchMap 是把一个数据变化为另外一个 LiveData

使用 Transformation 的好处：如果 Lifecycle 处于未激活状态，则转换函数也同样不会执行。
map实例：

class MyLiveDataViewModel : ViewModel(){    var liveData: MutableLiveData = MutableLiveData()        get() {            return field        }}class User(val name: String,val lastName: String)class LiveDataActivity : AppCompatActivity(),LifecycleOwner{    private lateinit var lifecycleRegistroy: LifecycleRegistry    override fun getLifecycle(): Lifecycle {        return lifecycleRegistroy    }    override fun onCreate(savedInstanceState: Bundle?) {        super.onCreate(savedInstanceState)        setContentView(R.layout.activity_live_data)        lifecycleRegistroy = LifecycleRegistry(this)        var viewModel = ViewModelProviders.of(this).get(MyLiveDataViewModel::class.java)        val observer = Observer{            text.text = it        }        button.setOnClickListener {            var user = User("android","jectpack")            viewModel.liveData.postValue(user)}        val userLivaData: LiveData = viewModel.liveData        val nameLiveData: LiveData = Transformations.map(userLivaData){            it.name + it.lastName        }        nameLiveData.observe(this,observer)    }}

switchMap实例：

class LiveDataActivity : AppCompatActivity(),LifecycleOwner{    private lateinit var lifecycleRegistroy: LifecycleRegistry    override fun getLifecycle(): Lifecycle {        return lifecycleRegistroy    }    override fun onCreate(savedInstanceState: Bundle?) {        super.onCreate(savedInstanceState)        setContentView(R.layout.activity_live_data)        lifecycleRegistroy = LifecycleRegistry(this)        var viewModel = ViewModelProviders.of(this).get(MyLiveDataViewModel::class.java)        val observer = Observer{            text.text = it        }        button.setOnClickListener {            var user = User("android","jectpack")            viewModel.liveData.postValue(user)}        val userLivaData: LiveData = viewModel.liveData        val nameLiveData: LiveData = Transformations.switchMap(userLivaData){            getUserName(it)        }        nameLiveData.observe(this,observer)    }    private fun getUserName(user: User): LiveData {        val liveData: MutableLiveData = MutableLiveData()        liveData.value = user.name +" switch map " + user.lastName        return liveData    }}

4.2 MediatorLiveData

MediatorLiveData的作用是合并几个流到一个流中。
实例代码：

class LiveDataActivity : AppCompatActivity(),LifecycleOwner{    private lateinit var lifecycleRegistroy: LifecycleRegistry    override fun getLifecycle(): Lifecycle {        return lifecycleRegistroy    }    override fun onCreate(savedInstanceState: Bundle?) {        super.onCreate(savedInstanceState)        setContentView(R.layout.activity_live_data)        lifecycleRegistroy = LifecycleRegistry(this)        var viewModel = ViewModelProviders.of(this).get(MyLiveDataViewModel::class.java)        val observer = Observer{            text.text = it        }        button.setOnClickListener {            var user = User("android","jectpack")            viewModel.liveData.postValue(user)}        val userLivaData: LiveData = viewModel.liveData        val nameLiveData: LiveData = Transformations.switchMap(userLivaData){            getUserName(it)        }        var mediatorLiveData: MediatorLiveData = MediatorLiveData()        mediatorLiveData.addSource(userLivaData){            mediatorLiveData.value = "first source "        }        mediatorLiveData.addSource(nameLiveData){            mediatorLiveData.value = it + " second source"        }        mediatorLiveData.observe(this,observer)    }    private fun getUserName(user: User): LiveData {        val liveData: MutableLiveData = MutableLiveData()        liveData.value = "  "        return liveData    }}

Android(安卓)Jetpack之LiveData源码分析