LiveData是给定生命周期的一个数据持有类
LiveData配合ViewModel可以将Controller中的逻辑更加简单，在数据进行变动的时候可以通过注入观察者来监听数据的变化
LiveData可以感知实现LifecycleOwner组件的生命周期，只有在上述组件的激活状态 （STARTED， RESUMED） 才会通知观察者数据更新
当组件的生命周期到了DESTROYED 状态的时候，添加的观察者将会被自动移除
class MyViewModel : ViewModel() {
// MutableLiveData 是 LiveData 的一个最简单实现，它可以接收数据更新并通知观察者
private var mLikedNumber: MutableLiveData<Int>? = null
fun getLikedNumber(): MutableLiveData<Int> {
if (mLikedNumber == null) {
mLikedNumber = MutableLiveData()
mLikedNumber!!.value = 0
}
return mLikedNumber!!
}
fun setLikedNumber(value: Int) {
mLikedNumber!!.value = mLikedNumber!!.value!! + value
}
}
class MainActivity : AppCompatActivity() {
var mViewModel: MyViewModel? = null
private lateinit var activityMainBinding: ActivityMainBinding
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main2)
// ViewModel和控制器绑定
mViewModel = ViewModelProviders.of(this).get(MyViewModel::class.java)
// 给LiveData设置一个观察者，观察数据的变化，数据发生变化，就直接更新到View之上
mViewModel!!.getLikedNumber().observe(this, Observer {integer ->
integer?.let {
textView.setText(integer.toString())
}
})
button.setOnClickListener({
mViewModel!!.setLikedNumber(1)
})
button2.setOnClickListener({
mViewModel!!.setLikedNumber(2)
})
}
}
我们一般可以定义一个Respository负责从网络或者数据库中获取数据，下面是数据的处理链以及实际应用实现（具体代码可以参考 ）
// Repository
class HomeRepository (loadState : MutableLiveData<State>) : BaseArticleRepository(loadState) {
fun loadBanner(liveData: MutableLiveData<BaseResponse<List<BannerResponse>>>) {
apiService.loadBanner()
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(BaseObserver(liveData, loadState, this))
}
fun loadHomeArticle(pageNum : Int, liveData: MutableLiveData<BaseResponse<HomeArticleResponse>>) {
apiService.loadHomeArticle(pageNum)
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(BaseObserver(liveData, loadState, this))
}
fun loadTopArticle(liveData: MutableLiveData<BaseResponse<List<Article>>>) {
apiService.loadTopArticle()
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(BaseObserver(liveData, loadState, this))
}
}
// ViewModel
class HomeViewModel(application: Application) :
BaseArticleViewModel<HomeRepository>(application) {
val mBannerData : MutableLiveData<BaseResponse<List<BannerResponse>>> = MutableLiveData()
val mHomeArticleData : MutableLiveData<BaseResponse<HomeArticleResponse>> = MutableLiveData()
val mTopArticleData : MutableLiveData<BaseResponse<List<Article>>> = MutableLiveData()
fun loadBanner() {
mRepository.loadBanner(mBannerData)
}
fun loadHomeArticleData(pageNum : Int) {
mRepository.loadHomeArticle(pageNum, mHomeArticleData)
}
fun loadTopArticle() {
mRepository.loadTopArticle(mTopArticleData)
}
}
// View
mViewModel.mBannerData.observe(this, Observer { response ->
response?.let {
setBannerData(it.data)
}
})
了解了如何使用LiveData，那么就从源码的角度对LiveData的观察者模式进行解读，对其再进行深入的理解
@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
assertMainThread("observe");
if (owner.getLifecycle().getCurrentState() == DESTROYED) {
// ignore
return;
}
// 将LifecycleOwner对象（Activity, Fragment, Service）封装成LifecycleBoundObserver对象
LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
// 对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);
}
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() {
return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
}
// 组件生命周期发生改变的回调方法
@Override
public void onStateChanged(@NonNull LifecycleOwner source,
@NonNull Lifecycle.Event event) {
// 如果是DESTROYED状态则移除观察者
if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
removeObserver(mObserver);
return;
}
// 将状态传入activeStateChanged
activeStateChanged(shouldBeActive());
}
@Override
boolean isAttachedTo(LifecycleOwner owner) {
return mOwner == owner;
}
@Override
void detachObserver() {
mOwner.getLifecycle().removeObserver(this);
}
}
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;
// 分别对是否在激活状态的observer个数进行+1， -1
if (wasInactive && mActive) {
onActive(); // +1 使得 从0->1 添加观察者
}
if (LiveData.this.mActiveCount == 0 && !mActive) {
onInactive();// -1使得从1->0 移除观察者
}
if (mActive) {
dispatchingValue(this);
}
}
void dispatchingValue(@Nullable ObserverWrapper initiator) {
if (mDispatchingValue) {
mDispatchInvalidated = true;
return;
}
mDispatchingValue = true;
do {
mDispatchInvalidated = false;
if (initiator != null) {
// 如果observer不为空，通知回调
considerNotify(initiator);
initiator = null;
} else {
// observer为空，则将mObservers容器中的值进行回调参数
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;
}
if (observer.mLastVersion >= mVersion) {
return;
}
observer.mLastVersion = mVersion;
// 回调可观察对象的onChange()方法即我们在View中重写的方法
observer.mObserver.onChanged((T) mData);
}
