LiveData使用、LiveData源码分析

简介

LiveData是可观察的数据持有者类。与常规的可观察对象不同，LiveData具有生命周期感知功能，这意味着它尊重其他应用程序组件（例如活动，片段或服务）的生命周期。这种意识确保LiveData仅更新处于活动生命周期状态的应用程序组件观察者。

LiveData的优点

1、确保用户界面与数据状态匹配
LiveData遵循观察者模式。Lifecycle对象生命周期状态更改时，LiveData会通知对象。这样不用单独处理数据比ui早的问题。
2、没有内存泄漏
观察者绑定到 Lifecycle对象，并在其相关的生命周期被破坏时自行清理。
3、活动停止不会导致崩溃
如果观察者的生命周期处于非活动状态（例如Activity处于非活动状态），则观察者不会收到任何LiveData事件。
4、不再需要人工生命周期处理
UI组件仅观察相关数据，而不会停止或继续观察。LiveData自动管理所有这些，因为它在观察的同时知道相关生命周期状态的变化。
5、始终最新的数据
如果生命周期变为非活动状态，则在再次处于活动状态时它将接收最新数据。例如，在后台的Activity返回到前台后会立即接收最新数据。
6、正确的配置更改
如果由于配置更改（例如设备旋转）而重新创建Activity或Fragment，则该Activity或者Fragment将立即接收最新的可用数据。
7、共享资源
LiveData 使用单例模式扩展对象以包装系统服务，以便可以在您的应用程序中共享它们。该LiveData对象一次连接到系统服务，然后任何需要资源的观察者都可以监视该LiveData 对象。

LiveData的使用

1、创建LiveData对象

public class NameViewModel {

// Create a LiveData with a String
private MutableLiveData<String> currentName;

    public MutableLiveData<String> getCurrentName() {
        if (currentName == null) {
            currentName = new MutableLiveData<String>();
        }
        return currentName;
    }
}

2、观察LivewData对象

public class NameActivity extends AppCompatActivity {

    private NameViewModel model;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
		......
        model = new NameViewModel();

        // Create the observer which updates the UI.
        final Observer<String> nameObserver = new Observer<String>() {
            @Override
            public void onChanged(@Nullable final String newName) {
                // Update the UI, in this case, a TextView.
                nameTextView.setText(newName);
            } 
        }; 

        //观察LiveData，并以LifecycleOwner和观察者的身份传入此活动。
        model.getCurrentName（）.observe（this，nameObserver）; 
    } 
}

Observer在收到LiveData状态变更回调onChanged()方法。有些时候可能项目中并没有实现Lifecycle并且着急使用LiveData，可以使用observeForever()方法，但是在Activity或者Fragment销毁时记得removeObserver。
3、更新LiveData数据

button.setOnClickListener(new OnClickListener() {
    @Override
    public void onClick(View v) {
        String anotherName = "John Doe";
        model.getCurrentName().setValue(anotherName);
    }
});

如果主线程调用setValue()，子线程调用postValue()

LiveData可以扩展封装耗时任务等

一般我们在项目中会使用RxJava等请求耗时任务，会在Activity.onCreate中启动任务，onDestroy销毁任务，同时还得处理回调。这些扩展LiveData就可以做到！！

	public class GetNameLiveData extends LiveData<String> {
        private NetworkRequestManager manager;
		// listener用于监听网络数据，监听到后setValue通知所有观察者
        private NetworkDataCallBack listener = new NetworkDataCallBack() {
            @Override
            public void onNameUpload(String name) {
            	if (isMainThread) {
                	setValue(name);
                } else {
                	postValue(name);
                }
            }
        };

        public GetNameLiveData() {
            manager = new NetworkRequestManager();
        }
		// onActive会在有Observe添加的时候调用
        @Override
        protected void onActive() {
        	// 这里请求网络，获取name，注意这个回调是主线程回调
        	new Thread(new Runnable() {
            	@Override
            	public void run() {
               	 	manager.requestName(listener);
            	}
        	}).start();
        }
		// onInactive会在没有任何Observe的时候调用
        @Override
        protected void onInactive() {
        	// 这里取消网络请求
            manager.cacelRequest();
        }
		private boolean isMainThread() {
        	return Looper.myLooper() == Looper.getMainLooper();
    	}
    }
	// 定义网络请求的接口回调
    private interface NetworkDataCallBack {
        void onNameUpload(String name);
    }

这样处理就不用切换线程、不用分发数据，不用随着Activity生命周期启动和取消任务。

LiveData获取数据后做链式转换传输

需求场景：例如，从网络获取到商品信息是一个json的String，既有android数据库监听存储这个json，又有UI获取到数据做展示。你可以通过此方法转换。

		MutableLiveData<String> liveData = new MutableLiveData<>();
        liveData.observe(this, new Observer<String>() {
            @Override
            public void onChanged(String s) {
                // 存储到数据库
            }
        });

        LiveData<ProductInfo> productInfoLiveData = Transformations.map(liveData, new Function<String, ProductInfo>() {
            @Override
            public ProductInfo apply(String json) {
                return new ProductInfo(json);
            }
        });
		// 这么做就不用每个地方处理ProductInfo转换了
        productInfoLiveData.observe(this, new Observer<ProductInfo>() {
            @Override
            public void onChanged(ProductInfo productInfo) {
                // UI 展示
            }
        });

维护可变的LiveData对象

需求：例如，你需要通过一个name参数获取一个LiveData对象，然后添加Observe监听这个LiveData对象。
一般做法：

	class MyViewModel {
        private final HashMap<String, LiveData<String>> mLiveDataMap;

        public MyViewModel(HashMap<String, LiveData<String>> liveDataMap) {
            mLiveDataMap = liveDataMap;
        }

        public LiveData<String> getNameMapLiveData(String name) {
            return mLiveDataMap.get(name);
        }
    }

分析下这个做法的弊端：
很明显，因为getNameMapLiveData获取到的是不同的LiveData对象，所以监听这个LiveData的Observer对象，需要每次getNameMapLiveData获取到新的LiveData对象后再做一次addObserve()操作，同时还需要解除之前观察的LiveData对象。

谷歌提供的神奇的办法：

	class MyViewModel {
        private final HashMap<String, LiveData<String>> mLiveDataMap;

        private final MutableLiveData<String> nameLiveData = new MutableLiveData();

        public final LiveData<String> mNameMapLiveData;

        public MyViewModel(HashMap<String, LiveData<String>> liveDataMap) {
            mLiveDataMap = liveDataMap;
            mNameMapLiveData = Transformations.switchMap(nameLiveData, new Function<String, LiveData<String>>() {
                @Override
                public LiveData<String> apply(String name) {
                    return mLiveDataMap.get(name);
                }
            });
        }

        private void setName(String address) {
            nameLiveData.setValue(address);
        }
    }

Transformations.switchMap自动帮你把Observe做了转换，你不再需要自己处理LiveData对象替换导致的观察者变动。

合并多个LiveData

MediatorLiveData允许您合并多个LiveData。只要MediatorLiveData对象发生更改，就会触发它的LiveData集合。

例如，如果LiveData在UI中有一个可以从本地数据库或网络更新的对象，则可以将以下源添加到该 MediatorLiveData对象：

LiveData与存储在数据库中的数据关联的对象。
LiveData与从网络访问的数据关联的对象

LiveData源码分析

一、LiveData如何分发Observe的
1、先看下LiveData的observe()方法

	private SafeIterableMap<Observer<? super T>, ObserverWrapper> mObservers =
            new SafeIterableMap<>();
            
	public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        ......
        ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
        ......
    }

很明显新增的观察者放到了mObservers集合
2、setValue是如何分发的

	protected void setValue(T value) {
        assertMainThread("setValue");
        mVersion++;
        mData = value;
        dispatchingValue(null);
    }
    void dispatchingValue(@Nullable ObserverWrapper initiator) {
    	......
        for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =
                        mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
            considerNotify(iterator.next().getValue());
			if (mDispatchInvalidated) {
				break;
            }
        }
        ......
    }

这里看到对mObservers集合做了遍历，最终到了considerNotify()

private void considerNotify(ObserverWrapper observer) {
		......
        observer.mLastVersion = mVersion;
        //noinspection unchecked
        observer.mObserver.onChanged((T) mData);
    }

很简单就是一个集合的遍历，啥也没有。回调observer.onChanged方法。
3、看下子线程的postValue()

	protected void postValue(T value) {
        ......
        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);
        }
    };

也很简单，利用ArchTaskExecutor回调到了主线程，主线程setValue()分发。

二、LiveData关联Lifecycle，避免内存泄露
对Lifecycle使用不理解的，可以先看下这篇文章lifecycle原理分析
1、还是先看下Observe()方法

    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        ......
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
        ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
        ......
        owner.getLifecycle().addObserver(wrapper);
    }

owner.getLifecycle().addObserver()很明显给包装的LifecycleBoundObserver添加了生命周期关联
2、看一下LifecycleBoundObserver

class LifecycleBoundObserver extends ObserverWrapper implements GenericLifecycleObserver {
        ......
        @Override
        public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
            if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
                removeObserver(mObserver);
                return;
            }
            activeStateChanged(shouldBeActive());
        }
		......
    }

Lifecycle在状态为DESTROYED时把Observer全部移除了，所以关联了lifecycle的LiveData不会发生内存泄露问题。
三、Transformations.map原理
1、看下MediatorLiveData包装类

public class MediatorLiveData<T> extends MutableLiveData<T> {
    private SafeIterableMap<LiveData<?>, Source<?>> mSources = new SafeIterableMap<>();
    
    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) {
            throw new IllegalArgumentException(
                    "This source was already added with the different observer");
        }
        if (existing != null) {
            return;
        }
        if (hasActiveObservers()) {
            e.plug();
        }
    }
    
    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;
        }

        void plug() {
            mLiveData.observeForever(this);
        }

        void unplug() {
            mLiveData.removeObserver(this);
        }

        @Override
        public void onChanged(@Nullable V v) {
            if (mVersion != mLiveData.getVersion()) {
                mVersion = mLiveData.getVersion();
                mObserver.onChanged(v);
            }
        }
    }
}

MediatorLiveData很明显做了一个LiveData的包装集合。addSource()对传入的LiveData对象增加了一个新的Observe观察者，这个新增的观察者又桥接到了addSource()传入的Observer。
2、看下Transformations.map()方法

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

这里会有点绕。map()方法最终的结果就是当source这个LiveData对象发生变更时，会分发到addSource()的第二个参数的onChanged()方法。因为result本身就是一个LiveData，所以调用result.setValue()就成功的链式分发到了map返回的LiveData对象。而mapFunction.apply(x)就是做了下数据处理。
四、Transformations.switchMap原理
搞懂了Map方法，switchMap就好理解一些了。
直接看switchMap代码：

    public static <X, Y> LiveData<Y> switchMap(
            @NonNull LiveData<X> source,
            @NonNull final Function<X, LiveData<Y>> switchMapFunction) {
        final MediatorLiveData<Y> result = new MediatorLiveData<>();
        result.addSource(source, new Observer<X>() {
            LiveData<Y> mSource;

            @Override
            public void onChanged(@Nullable X x) {
                LiveData<Y> newLiveData = switchMapFunction.apply(x);
                if (mSource == 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) {
                            result.setValue(y);
                        }
                    });
                }
            }
        });
        return result;
    }

这里的代码看着也会有点绕。跟map方法的不同是这里的onChange做了两次Observe观察者传递，当switchMapFunction.apply(x)返回新的LiveData对象后，会重新为这个对象添加一个Obsever，然后当新的LiveData对象状态变更时会通过这个Observe通知result。

这里根据代码解析switchMap的优点
（1）上边讲了switchMap会动态的变更LiveData对象，那么如何保证变更LiveData对象后，Observe集合没有变动呢？
final MediatorLiveData result = new MediatorLiveData<>();很明显，switchMap返回的result是一个new LiveData，并不是LiveData newLiveData = switchMapFunction.apply(x)返回的LiveData，所以虽然我们在apply变动了LiveData，但是switchMap返回的LiveData对象从来没有变过。
（2）switchMap会变更LiveData，如何保证已经废弃的LiveData不会再触发Observe观察者？

if (mSource != null) {
	result.removeSource(mSource);
}

因为MediatorLiveData对象内部有一个LiveData集合，所以remove掉后，集合遍历就找不到这个失效的LiveData对象了，也就不会触发Observe。