@TryLoveCatch 2022-10-25T06:18:51.000000Z 字数 27699 阅读 1250

Jetpack之LiveData

android Jetpack LiveData

简介

https://www.jianshu.com/p/8c15cadb638f

LiveData是Google推出的一系列的框架组件的其中一个，它是一个可以被观察的数据持有类，能够感知Activity、Fragment等组件的生命周期。
LiveData 可以和生命周期绑定，当 Lifecycle（例如 Activity、Fragment 等）处于活跃状态时才进行数据回调，并在 Lifecycle 处于无效状态（DESTROYED）时自动移除数据监听行为，从而避免常见的内存泄露和 NPE 问题

一个观察者去观察LiveData后，当观察者的生命周期处于STARTED或RESUMED状态时（即onStart()、onResume()、onPause()），LiveData的数据发生变化，则会通知观察者；若观察者处于其他状态，即使LiveData的数据发生变化，也不会发出通知。
所以说，LiveData可以做到仅在组件处于活跃状态时才进行更新UI的操作

用法

https://www.jianshu.com/p/8c15cadb638f

添加依赖

dependencies {
    //...
    def lifecycle_version = "1.1.1"
    //仅仅依赖LiveData
    implementation "android.arch.lifecycle:livedata:$lifecycle_version"
}

创建LiveData对象

google提倡LiveData配合ViewModel一起使用。
为了专注LiveData，这里先不用ViewModel，后面再补充说明如何跟ViewModel一起使用。直接看例子：

public class TestModel {
    private MutableLiveData<String> status;
    public MutableLiveData<String> getStatus() {
        if (status == null)
            status = new MutableLiveData<>();
        return status;
    }
}

MutableLiveData继承自LiveData，表示可变数据。
这里创建一个保存String类型数据的LiveData。

监听

public class TestActivity extends AppCompatActivity {
    private static final String TAG = "test";
    private TextView mTextView;
    private TestModel mTestModel;
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.test_activity);
        mTextView = findViewById(R.id.tv_test);
        init();
    }
    private void init() {
        //创建一个观察者去更新UI
        final Observer<String> statusObserver = new Observer<String>() {
            @Override
            public void onChanged(@Nullable final String newName) {
                Log.d(TAG, "onChanged: " + newName);
                mTextView.setText(newName);
            }
        };
        //创建TestModel对象
        mTestModel = new TestModel();
        //观察LiveData对象
        //这里的this指的是LifecycleOwner，即LiveData会跟生命周期联系起来
        mTestModel.getStatus().observe(this, statusObserver);
    }
}

observe()，可以对LiveData进行监听，需要传递一个LifecycleOwner参数进去，这表示LiveData会跟生命周期联系起来。
observeForever()，只需传递一个观察者进去就行，这意味着它跟生命周期没有任何关系，可以持续的观察，只要数据发生变化，都会通知观察者回调onChanged()。

更新数据

setValue(T)，主线程使用，执行之后，Observer的onChanged()方法将会被回调，从而实现更新UI的操作
postValue(T)，子线程使用，执行之后，Observer的onChanged()方法将会被回调，从而实现更新UI的操作

public class TestActivity extends AppCompatActivity {
    private static final String TAG = "test";
    private TextView mTextView;
    private TestModel mTestModel;
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.test_activity);
        mTextView = findViewById(R.id.tv_test);
        initVariable();
    }
    private void initVariable() {
        //创建一个观察者去更新UI
        final Observer<String> statusObserver = new Observer<String>() {
            @Override
            public void onChanged(@Nullable final String newName) {
                Log.d(TAG, "onChanged: " + newName);
                mTextView.setText(newName);
            }
        };
        //创建TestModel对象
        mTestModel = new TestModel();
        //观察LiveData对象
        //这里的this指的是LifecycleOwner，即LiveData会跟生命周期联系起来
        mTestModel.getStatus().observe(this, statusObserver);
        mTestModel.getStatus().setValue("onCreate");
    }
    @Override
    protected void onStart() {
        super.onStart();
        mTestModel.getStatus().setValue("onStart");
    }
    @Override
    protected void onResume() {
        super.onResume();
        mTestModel.getStatus().setValue("onResume");
    }
    @Override
    protected void onPause() {
        super.onPause();
        mTestModel.getStatus().setValue("onPause");
    }
    @Override
    protected void onStop() {
        super.onStop();
        mTestModel.getStatus().setValue("onStop");
    }
    @Override
    protected void onDestroy() {
        super.onDestroy();
        mTestModel.getStatus().setValue("onDestroy");
    }
}

一个完整的生命周期走下来，其输出结果为：

07-26 22:03:34.798 20995-20995/com.test.start D/test: onChanged: onStart
07-26 22:03:34.801 20995-20995/com.test.start D/test: onChanged: onResume
07-26 22:03:36.456 20995-20995/com.test.start D/test: onChanged: onPause

可以看到，只在onStart()、onResume()、onPause()时观察者才会收到数据更新的通知，其他状态下即使更新了数据也不会收到通知。

小结

在观察者处于STARTED或RESUMED状态时，LiveData才会通知观察者数据变化；
当观察者处于其他状态时，即使LiveData的数据变化了，也不会通知。
当组件的状态为DESTROYED时会自动移除观察者，这样Activity或Fragment就可以安全地观察LiveData而不用担心造成内存泄露

扩展

自定义LiveData

比如说定位，我们希望有观察者的时候，开启定位，没有观察者的时候，就可以停止定位，没必要一直获取定位点

public class TestLiveData extends LiveData<Location> {
    private static TestLiveData sInstance;
    private LocationUtil mLocationUtil;
    //设计为单例模式
    public static TestLiveData getInstance() {
        if (sInstance == null) {
            sInstance = new TestLiveData();
        }
        return sInstance;
    }
    private TestLiveData() {
        //创建一个获取位置的对象
        mLocationUtil = new LocationUtil();
    }
    @Override
    protected void onActive() {
        //开始获取位置信息
        mLocationUtil.start(mLocationListener);
    }
    @Override
    protected void onInactive() {
        //停止获取位置信息
        mLocationUtil.stop();
    }
    //创建一个位置监听器
    private LocationListener mLocationListener = new LocationListener() {
        @Override
        public void onReceiveLocation(Location location) {
            //接受到位置信息后，更新数据
            setValue(location);
        }
    };
}

onActive():当有一个处于活跃状态的观察者监听LiveData时会被调用，这表示开始获取位置信息。
onInactive()：当没有任何处于活跃状态的观察者监听LiveData时会被调用。由于没有观察者在监听了，所以也没必要继续去获取位置信息了，这只会消耗更多的电量等等，因此就可以停止获取位置信息了。
setValue()：更新LiveData的值，并通知到观察者。

转换LiveData

map

public class TestViewModel extends ViewModel {
    private MutableLiveData<Integer> mNumLiveData= new MutableLiveData<>();
    //通过Transformations.map()将Integer类型的值转换为String类型
    private LiveData<String> mStrLiveData = Transformations.map(mNumLiveData, new Function<Integer, String>() {
    @Override
    public String apply(Integer name) {
       return name + "";
    }
});
    //observe这个，获取Integer类型的数据
    public MutableLiveData<Integer> getNumLiveData() {
        return mNumLiveData;
    }
    //observe这个，获取string类型的数据
    public LiveData<String> getStrLiveData() {
        return mStrLiveData;
    }
}

switchMap

public class TestViewModel extends ViewModel {
    private MutableLiveData<String> mutableLiveData1 = new MutableLiveData<>();
    private MutableLiveData<String> mutableLiveData2 = new MutableLiveData<>();
    private MutableLiveData<Boolean> liveDataSwitch = new MutableLiveData<>();
    LiveData transformedLiveData= Transformations.switchMap(liveDataSwitch, new Function<Boolean, LiveData<String>>() {
        @Override
        public LiveData<String> apply(Boolean input) {
            if (input) {
                return mutableLiveData1;
            } else {
                return mutableLiveData2;
           }
        }
    });
    public MutableLiveData<String> getMutableLiveData1() {
        return mutableLiveData1;
    }
    public MutableLiveData<String> getMutableLiveData2() {
        return mutableLiveData2;
    }
    public MutableLiveData<Boolean> getLiveDataSwitch() {
        return liveDataSwitch;
    }
    public MutableLiveData<Boolean> getTransformedLiveData() {
        return transformedLiveData;
    }
}
// 使用
getTransformedLiveData().observe(this, new Observer<String>() {
    @Override
    public void onChanged(@Nullable final String s) {
        Log.d(TAG, "onChanged:" + s);
    }
});
getLiveDataSwitch().postValue(false);
getMutableLiveData1().postValue("1111");
getMutableLiveData2().postValue("2222");

当liveDataSwitch的值为true时返回mutableLiveData1，否则返回mutableLiveData2，可以用来切换监听的liveData

MediatorLiveData

MediatorLiveData继承自MutableLiveData，它可以将多个LiveData数据源集合起来，可以达到一个组件监听多个LiveData数据变化的目的。
当任何一个MutableLiveData数据发生变化时，MediatorLiveData都可以感知到。

public class TestViewModel extends ViewModel {
    private MutableLiveData<String> mutableLiveData1 = new MutableLiveData<>();
    private MutableLiveData<String> mutableLiveData2 = new MutableLiveData<>();
    private MediatorLiveData liveDataMerger = new MediatorLiveData<String>();
    liveDataMerger.addSource(mutableLiveData1, new Observer() {
        @Override
        public void onChanged(@Nullable String str) {
            liveDataMerger.setValue(str)
        }
    });
    liveDataMerger.addSource(mutableLiveData2, new Observer() {
        @Override
        public void onChanged(@Nullable Object str) {
            liveDataMerger.setValue(str)
        }
    });
    public MutableLiveData<String> getLiveDataMerger() {
        return liveDataMerger;
    }
    public MutableLiveData<String> getMutableLiveData1() {
        return mutableLiveData1;
    }
    public MutableLiveData<Boolean> getMutableLiveData2() {
        return getMutableLiveData2;
    }
}
// 使用
getLiveDataMerger().observe(this, new Observer<String>() {
    @Override
    public void onChanged(@Nullable final String s) {
        Log.d(TAG, "onChanged:" + s);
    }
});
getMutableLiveData1().postValue("1111");
getMutableLiveData2().postValue("2222");

MediatorLiveData相比于LiveData，主要是多了以下两个方法：

addSource()：添加源LiveData，并且开始监听给定的源LiveData，当源LiveData的数据发生变化时，观察者的onChanged()方法将会被调用，前提是MediatorLiveData处于活跃状态。
removeSource()：移除LiveData。

源码

首先我们带着问题来看：

只在 Observer 至少处于 STARTED 状态时才能收到事件通知。Activity 只有在 onStart 方法后且 onPause 方法前才能收到事件通知
LiveData 是黏性的。假设存在一个静态的 LiveData 变量，且已经包含了数据，对其进行监听的 Activity 都会收到其当前值的回调通知，即收到了黏性消息。这个概念就类似于 EventBus 中的 StickyEvent
中间值可以被新值直接掩盖。当 Activity 处于后台时，如果 LiveData 先后接收到了多个值，那么当 Activity 回到前台时也只会收到最新值的一次回调，中间值直接被掩盖了，Activity 完全不会感受到中间值的存在

然后我们从使用方式入手，根据使用API来一步一步看一下内部是怎么实现的

LiveData

LiveData 包含两个用于添加数据观察者（Observer）的方法，分别是

observe (LifecycleOwner , Observer)
observeForever (Observer)

两个方法的区别对于外部来说只在于是否提供了生命周期安全的保障

observe(LifecycleOwner , Observer)

observe(LifecycleOwner , Observer) 传入的 LifecycleOwner 参数意味着携带了 Lifecycle 对象，LiveData 内部就根据 Lifecycle 的生命周期事件的回调变化在合适的时机进行数据通知，并在 Lifecycle 对象处于 DESTROYED 状态时自动移除 Observer，这也是 LiveData 避免内存泄漏的最重要的一个点。

@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
    //限定只能在主线程调用 observe 方法
    assertMainThread("observe");
    //当 Lifecycle 已经处于 DESTROYED 状态时，此时进行 observe 是没有意义的，直接返回
    if (owner.getLifecycle().getCurrentState() == DESTROYED) {
        // ignore
        return;
    }
    //根据传入参数构建一个新的代理 Observer
    LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
    //将 observer 作为 key，wrapper 作为 value 进行存储
    //当 mObservers 不包含该 key 时，调用 putIfAbsent 会返回 null
    //当 mObservers 已包含该 key 时，调用 putIfAbsent 不会存储 key-value，并会返回之前保存的 value
    ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
    if (existing != null && !existing.isAttachedTo(owner)) {
        //走到此步，说明之前 LiveData 内部已经持有了 observer 对象，且该 observer 对象已经绑定了其它的 LifecycleOwner 对象
        //此时直接抛出异常
        throw new IllegalArgumentException("Cannot add the same observer"
                + " with different lifecycles");
    }
    if (existing != null) {
        //observer 之前已经传进来过了，此处直接返回
        return;
    }
    owner.getLifecycle().addObserver(wrapper);
}

我们注意到，observe()需要在主线程调用。
对 observer 进行了去重校验，如果之前已经用同个 observer 对象调用了 observe(LifecycleOwner,Observer)方法，而 LifecycleOwner 不是同一个对象，则直接抛出异常。
即一个 Observer 只允许和单个 LifecycleOwner 进行绑定。。
比如说ActivityA和ActivityB都绑定了同一个Observer，且A处于STOPED状态，B处于RESUMED状态，当 LiveData 数据发生变化时，B肯定会收到数据回调，但是因为是同一个Observer，所以A也是会收到回调的，这就会破坏了本来期望的生命周期安全

上面的代码使用到了 LifecycleBoundObserver，它是抽象类 ObserverWrapper 的实现类。

ObserverWrapper

ObserverWrapper 用于包装外部传进来的 Observer 对象，为子类定义好特定的抽象方法和共用逻辑，主要是提供了共用的状态分发函数。

private abstract class ObserverWrapper {
    //外部传进来的对 LiveData 进行数据监听的 Observer
    final Observer<? super T> mObserver;
    //用于标记 mObserver 是否处于活跃状态
    boolean mActive;
    //用于标记 Observer 内最后一个被回调的 value 的新旧程度
    int mLastVersion = START_VERSION;
    ObserverWrapper(Observer<? super T> observer) {
        mObserver = observer;
    }
    //用于获取当前 Lifecycle 是否处于活跃状态
    abstract boolean shouldBeActive();
    //用于判断 mObserver 是否和 LifecycleOwner（即 Lifecycle）有绑定关系
    boolean isAttachedTo(LifecycleOwner owner) {
        return false;
    }
    //移除 mObserver
    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;
        //判断当前 LiveData 所有的 Observer 是否都处于非活跃状态
        boolean wasInactive = LiveData.this.mActiveCount == 0;
        //更新 LiveData 当前所有处于活跃状态的 Observer 的数量
        LiveData.this.mActiveCount += mActive ? 1 : -1;
        if (wasInactive && mActive) {
            //如果 LiveData 处于活跃状态的 Observer 数量从 0 变成了 1,
            //则回调 onActive 方法
            onActive();
        }
        if (LiveData.this.mActiveCount == 0 && !mActive) {
            //如果 LiveData 处于活跃状态的 Observer 数量从 1 变成了 0,
            //则回调 onInactive 方法
            onInactive();
        }
        if (mActive) {
            //如果 mObserver 变成了活跃状态，则向其回调新值
            dispatchingValue(this);
        }
    }
}

主要是activeStateChanged(boolean newActive)方法：

去除重复传入相同的值
boolean wasInactive = LiveData.this.mActiveCount == 0，这个LiveData.this.mActiveCount是当前LiveData里面处于活跃状态的Observer个数，所以wasInactive判断是当前整个LiveData是否有活跃状态的Observer，true表示所有Observer都处于非活跃状态，false表示至少有一个Observer处于活跃状态
之前整个LiveData处于不活跃，并且当前传入值为活跃，则回调LiveData#onActive()，回调告知整个LiveData处于活跃
当前整个LiveData处于不活跃，并且传入值为不活跃，则回调LiveData#onInactive()，回调告知整个LiveData处于不活跃
当前传入值为活跃，则调用LiveData#dispatchingValue(this);，注意传入的参数值是this

所以ObserverWrapper#activeStateChanged主要做了两件事：

根据LiveData#mActiveCount来判断整个LiveData的活跃状态，不活跃 -> 活跃回调LiveData#onActive()，活跃 -> 不活跃回调LiveData#onInactive()
注意这个不活跃，需要是所有Observer都处于不活跃；活跃是其中一个Observer处于活跃就可以。
当前Observer如果处于活跃时，需要进行数据分发

调用大概有三个地方：

ObserverWrapper 一共有两个子类：LifecycleBoundObserver 和 AlwaysActiveObserver，两者的差别就在于是否和生命周期相绑定。

LifecycleBoundObserver

LifecycleBoundObserver，它是抽象类 ObserverWrapper 的实现类，它也实现了 GenericLifecycleObserver或者LifecycleEventObserver 接口，从而可以收到 Lifecycle 的每次生命周期事件切换时的事件回调。

class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver {
    @NonNull
    final LifecycleOwner mOwner;
    LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<? super T> observer) {
        super(observer);
        mOwner = owner;
    }
    @Override
    boolean shouldBeActive() {
        //只有当 Lifecycle 的当前状态是 STARTED 或者 RESUMED 时
        //才认为 Lifecycle 是处于活跃状态
        return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
    }
    //LifecycleEventObserver 的实现方法
    //当 Lifecycle 的生命周期状态发生变化时就会调用此方法
    @Override
    public void onStateChanged(@NonNull LifecycleOwner source,
            @NonNull Lifecycle.Event event) {
        //如果 Lifecycle 已经处于 DESTROYED 状态了,则主动移除 mObserver
        //这就是 LiveData 可以避免内存泄露最重要的一个点
        if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
            removeObserver(mObserver);
            return;
        }
        activeStateChanged(shouldBeActive());
    }
    @Override
    boolean isAttachedTo(LifecycleOwner owner) {
        return mOwner == owner;
    }
    @Override
    void detachObserver() {
        //移除 mObserver
        mOwner.getLifecycle().removeObserver(this);
    }
}

当 Lifecycle 的当前状态是 STARTED 或者 RESUMED 时，才认为 Lifecycle 是处于活跃状态
当 Lifecycle 的生命周期状态发生变化时会通知LifecycleBoundObserver，如果处于 DESTROYED 状态了,则会主动移除 mObserver
调用ObserverWrapper#activeStateChanged，这个上面已经说过了

observeForever(Observer)

observeForever() 函数本身不会考虑外部所处的生命周期状态，只要数据发生变化时就会进行数据回调，因此 observeForever()函数是非生命周期安全的

@MainThread
    public void observeForever(@NonNull Observer<? super T> observer) {
    //限定只能在主线程调用 observe 方法
    assertMainThread("observeForever");
    AlwaysActiveObserver wrapper = new AlwaysActiveObserver(observer);
    ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
    if (existing instanceof LiveData.LifecycleBoundObserver) {
        //会走到这一步，是因为之前已经先用该 observer 对象调用了 observe(LifecycleOwner,Observer)
        //这里直接抛出异常
        throw new IllegalArgumentException("Cannot add the same observer"
                + " with different lifecycles");
    }
    if (existing != null) {
        //如果之前已经添加过 observer 对象了的话，则直接返回
        return;
    }
    //主动触发 activeStateChanged 函数，因为当前 LiveData 可能已经被设置值了
    wrapper.activeStateChanged(true);
}

我们注意到，observe()需要在主线程调用。
对 observer 进行了去重校验，如果之前已经先用该 observer 对象调用了 observe(LifecycleOwner,Observer)方法，则直接抛出异常。因为如果允许 observer 同时调用observeForever() 和 observe() 函数，则当数据发生变化时，这可能会造成 Lifecycle 处于 DESTROYED 状态时还进行了数据回调，而这破坏了 observe(LifecycleOwner,Observer) 所期望的生命周期安全
直接调用ObserverWrapper#activeStateChanged(true)，不需要关系生命周期回调，直接传入true

AlwaysActiveObserver

AlwaysActiveObserver，它也是抽象类 ObserverWrapper 的实现类，其 shouldBeActive()返回值固定为 true，意味着只要有数据变化都会进行回调。
所以使用 observeForever() 函数一定要在过后主动移除 Observer，避免内存泄露和 NPE

 private class AlwaysActiveObserver extends ObserverWrapper {
    AlwaysActiveObserver(Observer<? super T> observer) {
        super(observer);
    }
    @Override
    boolean shouldBeActive() {
        //使其固定返回 true，则意味着只要有数据变化就都进行数据回调
        return true;
    }
}

removeObserver

removeObserver 的方式一共有两种，逻辑都比较简单

//移除指定的 Observer 对象
@MainThread
public void removeObserver(@NonNull final Observer<? super T> observer) {
    assertMainThread("removeObserver");
    ObserverWrapper removed = mObservers.remove(observer);
    if (removed == null) {
        return;
    }
    removed.detachObserver();
    removed.activeStateChanged(false);
}
//通过循环遍历移除所有和特定 LifecycleOwner 绑定的 Observer 对象
@SuppressWarnings("WeakerAccess")
@MainThread
public void removeObservers(@NonNull final LifecycleOwner owner) {
    assertMainThread("removeObservers");
    for (Map.Entry<Observer<? super T>, ObserverWrapper> entry : mObservers) {
        if (entry.getValue().isAttachedTo(owner)) {
            removeObserver(entry.getKey());
        }
    }
}

需要在主线程调用
一个LifecycleOwner，可能会有多个Observer，所以提供了根据LifecycleOwner来删除其所有的Observer

更新 LiveData 的值的方法一共有两个，分别是：

setValue(T value)
postValue(T value)

setValue()

private volatile Object mData;
private int mVersion;
@MainThread
protected void setValue(T value) {
    assertMainThread("setValue");
    //更新当前 value 的版本号，即 value 的新旧程度
    mVersion++;
    mData = value;
    dispatchingValue(null);
}

需要在主线程进行调用
更新数据版本号
保存最新数据，注意数据并不是一个集合，所以只能保存最近一次数据
调用dispatchingValue(null)，跟之前说的ObserverWrapper#activeStateChanged()不同，这里调用的时候，传入参数为null。

dispatchingValue()

dispatchingValue() 这个被提到了很多次了


//用于标记当前是否正处于向 mObservers 发布 value 的过程
private boolean mDispatchingValue;
//用于标记当前正在发布的 value 是否已经失效
//在 value 还未向所有 Observer 发布完成的时候，新 value 已经到来，此时旧 value 就是处于失效状态
@SuppressWarnings("FieldCanBeLocal")
private boolean mDispatchInvalidated;
//initiator 为 null 则说明需要遍历回调整个 mObservers
//initiator 不为 null 则说明仅回调 initiator 本身
@SuppressWarnings("WeakerAccess") /* synthetic access */
void dispatchingValue(@Nullable ObserverWrapper initiator) {
    if (mDispatchingValue) {
        //如果 mDispatchingValue 为 true，说明当前正处于向 mObservers 发布 mData 的过程中
        //而 dispatchingValue 方法只会在主线程进行调用，所以会出现 mDispatchingValue 为 true 的情况
        //说明 Observer 的 onChanged 方法内部又主动向 LiveData setValue
        //则将 mDispatchInvalidated 置为 true，用于标明有新值到来，正在回调的值是已经过时的了
        mDispatchInvalidated = true;
        return;
    }
    //用于标记当前正处于向 mObservers 发布 mData 的过程中
    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) {
                    //如果 mDispatchInvalidated 为 true，则中断继续遍历过程
                    //用新值来重新循环一遍
                    break;
                }
            }
        }
    } while (mDispatchInvalidated);
    mDispatchingValue = false;
}

dispatchingValue(ObserverWrapper) 关于这个入参有两种情况：
- 参数为null，通知所有的Observer
- 参数不为null，仅仅通知参数的Observer本身
mDispatchingValue：当前是否处于数据分发中
mDispatchInvalidated：当前数据是否无效，主要是可能新值来了，所以不需要再使用旧值了
mDispatchingValue为true，说明正在分发中，所以仅仅修改mDispatchInvalidated的值为true，然后return
for-each遍历所有的Observer，调用considerNotify()，并且每次遍历都会判断mDispatchInvalidated是否无效，如果无效直接break跳出for-each循环，进入while循环中
为什么这里用do..while呢？
当mDispatchInvalidated为true的时候，证明值改变了，所以需要重新用新值来进行再次分发

这里，我有一个疑惑：
从逻辑上看 dispatchingValue() 函数只会在主线程进行调用，那么 dispatchingValue() 一定是会在执行完毕后才被再次执行，不存在多线程同时调用的情况，那么此时 mDispatchingValue 和 mDispatchInvalidated 两个变量就没有存在的必要了吧

considerNotify()

private void considerNotify(ObserverWrapper observer) {
    //如果 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.
    //此处判断主要是为了照顾 LifecycleBoundObserver
    //由于 Lifecycle 有可能状态值 State 已经切换到了非活跃状态，但 LifecycleBoundObserver 还未收到事件通知
    //所以为了避免意外情况，此处主动检查 observer 的活跃状态并判断是否需要更新其活跃状态
    if (!observer.shouldBeActive()) {
        observer.activeStateChanged(false);
        return;
    }
    //根据 observer 本部的 value 版本号 mLastVersion 来决定是否需要向其进行回调
    //为了避免重复向某个 observer 回调值，所以此处需要判断下
    if (observer.mLastVersion >= mVersion) {
        return;
    }
    observer.mLastVersion = mVersion;
    observer.mObserver.onChanged((T) mData);
}

如果ObserverWrapper处于非活跃状态，直接return
由于 Lifecycle 有可能状态值 State 已经切换到了非活跃状态，但 LifecycleBoundObserver 还未收到事件通知，所以主动调用一下Lifecycle 的方法，来判断是否处于活跃状态
比较ObserverWrapper#mLastVersion和LiveData#mVersion，来判断是否需要分发数据
调用ObserverWrapper#Observer#onChanged()

postValue()

postValue(T) 函数不限定调用者所在线程，不管是主线程还是子线程都可以调用，因此是存在多线程竞争的可能性的，postValue(T) 函数的重点旧在于需要理解其从子线程切换到主线程之间的状态变化

@SuppressWarnings("WeakerAccess") /* synthetic access */
final Object mDataLock = new Object();
@SuppressWarnings("WeakerAccess") /* synthetic access */
//mPendingData 的默认值
//当 mPendingData 等于 NOT_SET 时说明当前 LiveData 没有值需要通过 postValue 回调
static final Object NOT_SET = new Object();        
volatile Object mPendingData = NOT_SET;
//用于在主线程对值进行回调
private final Runnable mPostValueRunnable = new Runnable() {
    @SuppressWarnings("unchecked")
    @Override
    public void run() {
        Object newValue;
        synchronized (mDataLock) {
            //通过加锁可以确保 newValue 指向的是当前最新值
            newValue = mPendingData;
            //重置 mPendingData
            mPendingData = NOT_SET;
        }
        setValue((T) newValue);
    }
};
protected void postValue(T value) {
    boolean postTask;
    //加锁以保证 mPendingData 值能够一直指向最新值
    synchronized (mDataLock) {
        postTask = mPendingData == NOT_SET;
        mPendingData = value;
    }
    //如果 postTask 为 false，则说明当前有旧值需要通过 postValue 进行回调
    //因为 postValue 可以在子线程调用，而 Observer 的 onChanged(value) 方法肯定是要在主线程被调用
    //从子线程切到主线程之间是有段时间间隔的
    //等到 mPostValueRunnable 真正执行时让其直接发送最新值 mPendingData 即可，所以此处直接返回
    if (!postTask) {
        return;
    }
    //向主线程发送一个 runnable，主要是为了在子线程调用 postValue，在主线程进行值回调
    ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
}

调用线程：

mPendingData是volatile，所以保证可见性
- 在调用postValue(value)的时候，把value赋值给mPendingData
- 在准备分发数据的时候，mPendingData赋值为默认值NOT_SET
判断postTask
- 如果postTask为true，证明mPendingData之前是默认值
- 如果postTask为false，证明mPendingData是旧值，并且还没有开始分发
value赋值给mPendingData
如果postTask为false，直接return
说明有旧值，且没有分发，这个时候只需要更新mPendingData为新值即可，因为它是volatile，所以主线程分发执行的时候，拿到的就是新值，调用线程可以不继续执行下去了，直接return就行了
利用handler切换到主线程

主线程：

更新newView的值
重置mPendingData为默认值NOT_SET
调用setValue()进行数据分发

所以当多个线程同时调用，在postTask为false，直接return的时候，其实是会导致丢值的。在单个线程连续调用的时候，也会导致这个问题，为什么？因为调用Handler#post()，会延迟调用，所以也会导致这个问题。

小结

LiveData 的实现基于观察者模式（reactive patterns）；
LiveData 跟 LifecycleOwner 绑定，能感知生命周期变化，并且只会在 LifecycleOwner 处于 Active 状态（STARTED/RESUMED）下通知数据改变；如果数据改变发生在非 active 状态，数据会变化，但是不发送通知，等 owner 回到 active 的状态下，再发送通知；
如果想要一直收到通知，则需要用 observeForever() 方法；
LiveData 会自动在 DESTROYED 的状态下移除 Observer ，取消订阅，所以不用担心内存泄露；
在 LifecycleOwner 处于 DESTROYED 的状态下，不能订阅；
postValue 方法其实最后调用了 setValue 只不过把操作放到主线程，适合在异步线程里调用，setValue 必须在主线程里调用；
如果同时多次调用 postValue 或 setValue 修改数据，只会修改成最新的那个数据，也即只会收到一次通知（set post混合调用则不一定）；
如果 LiveData 有数据，并且 owner 在 active 状态下，那么在订阅的时候，会立马收到一次通知；
一个 Observer 实例，只能绑定一个 LifecycleOwner，而一个 owner 可以绑定多个 Observer 实例；
LiveData 利用版本管理、绑定 Lifecycle 确保了只会发送最新的数据给 active 状态下的 Observer；

MutableLiveData

LiveData 的 setValue() 和 postValue() 方法的访问权限都是 protected，因此我们在日常开发中基本都是使用其子类

MutableLiveData 的源码很简单，只是将 setValue() 和 postValue() 方法的访问权限提升为了 public，从而让外部可以直接调用这两个方法:

public class MutableLiveData<T> extends LiveData<T> {
    /**
     * Creates a MutableLiveData initialized with the given {@code value}.
     *
     * @param value initial value
     */
    public MutableLiveData(T value) {
        super(value);
    }
    /**
     * Creates a MutableLiveData with no value assigned to it.
     */
    public MutableLiveData() {
        super();
    }
    @Override
    public void postValue(T value) {
        super.postValue(value);
    }
    @Override
    public void setValue(T value) {
        super.setValue(value);
    }
}

MediatorLiveData

MediatorLiveData 是 MutableLiveData 的子类，可以添加多个LiveData数据源，监听这个多个LiveData，在他们的Observer回调的时候，调用MediatorLiveData自己的setValue来通知自己的Observer，具体例子可以看上面关于MediatorLiveData的使用例子

addSource


private SafeIterableMap<LiveData<?>, Source<?>> mSources = new SafeIterableMap<>();
@MainThread
public <S> void addSource(@NonNull LiveData<S> source, @NonNull Observer<? super S> onChanged) {
    Source<S> e = new Source<>(source, onChanged);
    Source<?> existing = mSources.putIfAbsent(source, e);
    if (existing != null && existing.mObserver != onChanged) {
        //走到这一步，说明之前已经传进来过同个 source 对象
        //但当时传的 Observer 对象与本地传递的 Observer 对象不是同一个
        //直接抛出异常
        throw new IllegalArgumentException(
                "This source was already added with the different observer");
    }
    if (existing != null) {
        //走到此步，说明之间已经用相同的 source 和 onChanged 对象调用过 addSource 方法
        //所以直接返回
        return;
    }
    //如果 MediatorLiveData 当前有处于活跃状态的 Observer 对其进行监听
    //则调用 Source 对象的 plug() 函数
    if (hasActiveObservers()) {
        e.plug();
    }
}

MediatorLiveData的源码其实很类似于LiveData，最重要的是增加了addSource()和removeSource():

将参数LiveData和Observer封装为Source
判断LiveData是否存在，如果已经存在，并且该LiveData的Observer和传入的Observer不一致，直接抛异常
也就是说，MediatorLiveData 不允许对同个数据源添加多个 Observer 对象
如果已经使用过相同的LiveData和Observer，直接return
如果MediatorLiveData处于活跃状态，就调用Source#plug()

removeSource()

//移除对数据源的监听行为
@MainThread
public <S> void removeSource(@NonNull LiveData<S> toRemote) {
    Source<?> source = mSources.remove(toRemote);
    if (source != null) {
        source.unplug();
    }
}

代码很简单：

删除集合中的LiveData
调用Source#unplug()

Source

private static class Source<V> implements Observer<V> {
    final LiveData<V> mLiveData;
    final Observer<? super V> mObserver;
    int mVersion = START_VERSION;
    Source(LiveData<V> liveData, final Observer<? super V> observer) {
        mLiveData = liveData;
        mObserver = observer;
    }
    //对外部数据源 mLiveData 进行监听
    void plug() {
        mLiveData.observeForever(this);
    }
    //移除对外部数据源 mLiveData 的监听
    void unplug() {
        mLiveData.removeObserver(this);
    }
    @Override
    public void onChanged(@Nullable V v) {
        if (mVersion != mLiveData.getVersion()) {
            mVersion = mLiveData.getVersion();
            mObserver.onChanged(v);
        }
    }
}

内部也维护了一个版本号，避免重复通知
plug()的时候，是调用的observeForever()，所以有两个后果
- 与生命周期无关
- 必须调用removeObserver()，避免出现其他问题

所以虽然提供了unplug()，但是如果使用者没有调用呢，怎么能保证unplug()一定被调用呢？

MediatorLiveData复写了LiveData的onActive()和onInactive()：

onActive()：MediatorLiveData切换到活跃状态的时候，就调用自己所有Source#plug()，开始监听
onInactive()：MediatorLiveData切换到非活跃状态的时候，就调用自己所有Source#unplug()，保证可以调用到所有Source的removeObserver()

@CallSuper
@Override
protected void onActive() {
    for (Map.Entry<LiveData<?>, Source<?>> source : mSources) {
        source.getValue().plug();
    }
}
@CallSuper
@Override
protected void onInactive() {
    for (Map.Entry<LiveData<?>, Source<?>> source : mSources) {
        source.getValue().unplug();
    }
}

小结

再说一下用法，根据用法我们来理解一下：

MediatorLiveData#addSource(LiveData, Observer)

MediatorLiveData#addSource(LiveData, Observer)

MediatorLiveData#addSource(LiveData, Observer)

MediatorLiveData#Observer(Observer)

为了描述简单，我们说MediatorLiveData为父LiveData，addSource添加的LiveData为子LiveData：

父LiveData可以通过addSource()来添加多个子LiveData，并进行监听
而子LiveData，是通过调用的observeForever()来进行监听的，所以不具有生命周期安全
父LiveData使用observe(LifecycleOwner, Observer<T>)来进行监听自己本身的数据变化
子LiveData的数据只要更新了，不会考虑生命周期，都会进行通知，这样父LiveData会主动调用父LiveData的setValue()，来进行父LiveData的数据分发。

Transformations

Transformations 类是 lifecycle-livedata 库提供的一个工具类型的方法类，提供了三个静态方法用于简化对 MediatorLiveData 的使用，这里再来依次介绍下：

map

map(LiveData , Function) 函数用于简化向 MediatorLiveData 添加数据源的过程。大多数情况下，我们在使用 MediatorLiveData 时就是先将数据源类型 X 转换我们的目标数据类型 Y，然后再通过 setValue(Y) 进行数据回调。map 函数将这个数据类型转换过程抽象为了接口 Function，将 setValue(Y) 过程隐藏在了 map 函数内部

@MainThread
@NonNull
public static <X, Y> LiveData<Y> map(
        @NonNull LiveData<X> source,
        @NonNull final Function<X, Y> mapFunction) {
    final MediatorLiveData<Y> result = new MediatorLiveData<>();
    result.addSource(source, new Observer<X>() {
        @Override
        public void onChanged(@Nullable X x) {
            result.setValue(mapFunction.apply(x));
        }
    });
    return result;
}
public interface Function<I, O> {
    /**
    * Applies this function to the given input.
    *
    * @param input the input
    * @return the function result.
    */
    O apply(I input);
}

switchMap

switchMap，可以用来切换不同的子LiveData

@MainThread
@NonNull
public static <X, Y> LiveData<Y> switchMap(
        @NonNull LiveData<X> source,
        @NonNull final Function<X, LiveData<Y>> switchMapFunction) {
    final MediatorLiveData<Y> result = new MediatorLiveData<>();
    //先内部构建一个 MediatorLiveData，然后将 source 作为其数据源
    result.addSource(source, new Observer<X>() {
        //缓存每次的请求结果
        LiveData<Y> mSource;
        @Override
        public void onChanged(@Nullable X x) {
            //触发外界根据请求值 x 获得 LiveData 结果值的逻辑
            //对应上面例子的 getUsersWithNameLiveData 方法
            //这个过程是惰性的，即只有数据源 source 发生了变化才会触发请求
            LiveData<Y> newLiveData = switchMapFunction.apply(x);
            if (mSource == newLiveData) {
                //如果 newLiveData 之前已经拿到了，则不必重复监听其回调结果
                //直接返回即可
                return;
            }
            if (mSource != null) {
                //新值到来，移除对旧值的监听
                result.removeSource(mSource);
            }
            mSource = newLiveData;
            if (mSource != null) {
                result.addSource(mSource, new Observer<Y>() {
                    @Override
                    public void onChanged(@Nullable Y y) {
                        //等到拿到了getUsersWithNameLiveData 的请求结果后
                        //就将结果值回调出去
                        result.setValue(y);
                    }
                });
            }
        }
    });
    return result;
}

distinctUntilChanged

distinctUntilChanged() 函数用于过滤掉连续重复的回调值，只有本次的回调结果和上次不一致，本次的回调值才被认为是有效的

 @MainThread
@NonNull
public static <X> LiveData<X> distinctUntilChanged(@NonNull LiveData<X> source) {
    final MediatorLiveData<X> outputLiveData = new MediatorLiveData<>();
    outputLiveData.addSource(source, new Observer<X>() {
        //用于是否是第一次收到回调值
        boolean mFirstTime = true;
        @Override
        public void onChanged(X currentValue) {
            final X previousValue = outputLiveData.getValue();
            //等式成立的条件一共有三种，满足其一即可
            //1. 是第一次收到回调值，即 mFirstTime 为 true
            //2. 上次的回调值为 null，本次的回调值不为 null
            //3. 上次的回调值不为 null，且与本次的回调值不相等
            if (mFirstTime
                    || (previousValue == null && currentValue != null)
                    || (previousValue != null && !previousValue.equals(currentValue))) {
                mFirstTime = false;
                outputLiveData.setValue(currentValue);
            }
        }
    });
    return outputLiveData;
}

小结

map、switchMap和distinctUntilChanged内部都使用了MediatorLiveData，并且返回值也是MediatorLiveData
所以可以看出来MediatorLiveData的扩展性非常好

总结

感觉LiveData的源码相比Lifecycle，比较清晰简单

一个 Observer 对象只能和一个 Lifecycle 对象绑定，否则将抛出异常
同个 Observer 对象不能同时使用 observe() 和 observeForever() 函数，否则将抛出异常
LiveData 存在丢值的可能性。当单线程连续传值或者多线程同时 postValue 时，最终可能只有最后一个值能够被保留并回调
LiveData 存在仅有部分 Observer 有收到值回调的可能性。当单线程连续传值或者多线程同时传值时，假设是先后传 valueA 和 valueB，可能只有部分 Observer 可以接收到 valueA，然后所有 Observer 都接收到了 valueB

扩展

https://juejin.cn/post/6903096576734920717
https://tech.meituan.com/2018/07/26/android-livedatabus.html

livedata的粘性问题
使用SingleLiveEvent，虽然解决了粘性的问题，但是只支持单个观察者
还有一个问题，如果当前view不可见，那么只会调用setValue的，但是不会通知观察者，也就是不会调用onChanged，所以AtomicBoolean的值没有为置为false，在下次注册的时候，还是会通知一次
所以SingleLiveEvent只是解决了，多次注册时，非首次注册的观察者会获取到数据的问题，并没有解决首次注册的粘性问题

参考：https://github.com/JeremyLiao/LiveEventBus
https://yutiantina.github.io/2019/09/20/%E5%9F%BA%E4%BA%8ELiveData%E5%AE%9E%E7%8E%B0%E4%BA%8B%E4%BB%B6%E6%80%BB%E7%BA%BF%E6%80%9D%E8%B7%AF%E5%92%8C%E6%96%B9%E6%A1%88/
https://zhuanlan.zhihu.com/p/419512610

缺点

我们来回顾一下，之前说过LiveData有三个特性：

只在 Observer 至少处于 STARTED 状态时才能收到事件通知。Activity 只有在 onStart 方法后且 onPause 方法前才能收到事件通知

LiveData 是黏性的。假设存在一个静态的 LiveData 变量，且已经包含了数据，对其进行监听的 Activity 都会收到其当前值的回调通知，即收到了黏性消息。这个概念就类似于 EventBus 中的 StickyEvent

中间值可以被新值直接掩盖。当 Activity 处于后台时，如果 LiveData 先后接收到了多个值，那么当 Activity 回到前台时也只会收到最新值的一次回调，中间值直接被掩盖了，Activity 完全不会感受到中间值的存在

以上三点特性都是由于界面层的特点来决定的：

当界面处于后台时，此时就完全没有必要更新界面，因为此时界面对用户来说完全不可见，且界面有可能再也没有机会回到前台了，所以只有当界面回到前台时更新操作才是有意义的
当界面被意外销毁后，我们需要根据已有的数据来进行界面重建，所以 LiveData 被设计为黏性的
对于 LiveData 所代表的界面状态值来说，我们往往需要的只是其最新状态，不需要处理中间值，所以 LiveData 的中间值可以被新值直接掩盖

参考

https://www.jianshu.com/p/8c15cadb638f
http://liuwangshu.cn/application/jetpack/5-livedata-theory.html
https://github.com/leavesC/AndroidGuide/blob/gitbook/jetpack/LiveData%E6%BA%90%E7%A0%81%E8%A7%A3%E6%9E%90.md
https://github.com/leavesC/AndroidGuide/blob/gitbook/jetpack/LiveData%E8%A1%8D%E7%94%9F.md

Jetpack之LiveData

简介

用法

添加依赖

创建LiveData对象

监听

更新数据

小结

扩展

自定义LiveData

转换LiveData

map

switchMap

MediatorLiveData

源码

LiveData

observe(LifecycleOwner , Observer)

ObserverWrapper

LifecycleBoundObserver

observeForever(Observer)

AlwaysActiveObserver

removeObserver

setValue()

dispatchingValue()

considerNotify()

postValue()

小结

MutableLiveData

MediatorLiveData

addSource

removeSource()

Source

小结

Transformations

map

switchMap

distinctUntilChanged

小结

总结

扩展

缺点

参考

内容目录