Android Architecture Component之LiveData

前言

看本片文章之前建议先看Android Architecture Component之Lifecycle-Aware Components源码分析,会用到里面的一些知识。本人水平有限，写的不好请谅解。

一、liveData是什么？

1.介绍
* LiveData是一个数据持有者类，他持有一个允许被观察的值，不同于普通的被观察者，liveData遵从应用程序的生命周期，被注册的观察者都要遵循其生命周期。
* 如果观察者的生命周期处于started或者resumed状态的时候，liveData认为观察者处于活动状态。
LiveData只通知处于活跃状态的observer,不活跃的不通知其改变。
2. 优点
* 没有内存泄漏的风险，当页面销毁的时候，他们会自动被移除，不会导致内存溢出
* 不会因为activity的不可见导致crash。
* 当Activity不可见的时候，即使有数据发生改变，LiveData也不同通知观察者，因为磁力的观察者的生命周期处于Started或者Resumed状态
* 配置的改变。
* 当前的Activity配置发生改变（如屏幕方向，导致生命周期重新走了一遍，但是观察者们会恢复到变化前的数据。
* 资源共享
* 我们的LiveData，只要连接系统服务一次就能支持所有的观察者。
* 不在手动处理生命周期
* 生命周期组件，只需要在观察数据的时候观察数据即可，不需要理会生命周期，这一切就交给类liveData.
* 总是能获取最新的数据
* 当Activity从后台进入前台的时候总共能够获取最新的数据。

二、用法简介

• 添加依赖
  
compile "android.arch.lifecycle:runtime:1.0.3"
compile "android.arch.lifecycle:extensions:1.0.0-rc1"
annotationProcessor "android.arch.lifecycle:compiler:1.0.0-rc1"


• 创建一个LiveData的实例来保存特定类型的数据。 这通常在ViewModel类中完成。

  public class MainViewModel extends AndroidViewModel {
  private int i=10;
  
  private MutableLiveData studentMutableLiveData =new MutableLiveData<>();
  
  public MainViewModel(Application application) {
      super(application);
  }
  
  
  public void changeName(Student student) {
  
      student.setAge(i++);
      studentMutableLiveData.setValue(student);
  
  }
  
  public MutableLiveData getStudentMutableLiveData() {
      return studentMutableLiveData;
  }
  }

  MutableLiveData类公开公开setValue(T)和postValue(T)方法，如果需要编辑存储在LiveData对象中的值，则必须使用这些方法。 通常在ViewModel使用MutableLiveData ，然后ViewModel仅向观察者公开不可变的LiveData对象。

  • 在Activity中

    ViewModelProvider of = ViewModelProviders.of(this);
    mainViewModel = of.get(MainViewModel.class);
    mainViewModel.getStudentMutableLiveData().observe(this, new Observer() {
        @Override
        public void onChanged(@Nullable Student student) {
    
    
        }
    });
    findViewById(R.id.tv).setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
    
            mainViewModel.changeName(mstudent);
    
        }
    });

    每次点击之后都会调用LiveData的setValue()方法，注册的观察者在onChanged()方法中就会收到更新后的我们观察的数据student.

三、源码分析

我们主要从三个方面讲解：怎么添加观察者？什么时候通知调用观察者，怎么移除观察者？怎么判定是liveData是活动活动状态？
1. 怎么添加观察者？
* 上面的列子用到了MutableLiveData，看下他的源码
“`
public class MutableLiveData extends LiveData {
@Override
public void postValue(T value) {
super.postValue(value);
}

@Override
public void setValue(T value) {
    super.setValue(value);
}
}
```
很简单，继承了LiveData，提供了两个修改我们要观察数据的值。
>  注意： 您必须调用setValue(T)方法来更新主线程中的LiveData对象。如果代码在工作线程中执行，则可以使用postValue(T)方法更新LiveData对象。

* 从上面的列子中我们看到了MutableLiveData调用了observe()方法，这个方法是干什么用的呢？observer()继承于LiveData,所以我们看下LiveData的Observer()

@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer observer) {
if (owner.getLifecycle().getCurrentState() == DESTROYED) {
// ignore
return;
}
LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
LifecycleBoundObserver existing = mObservers.putIfAbsent(observer, wrapper);
if (existing != null && existing.owner != wrapper.owner) {
throw new IllegalArgumentException("Cannot add the same observer"
+ " with different lifecycles");
}
if (existing != null) {
return;
}
owner.getLifecycle().addObserver(wrapper);
}

* LifecycleOwner在上面的列子中我们传入的是this,上篇我们说Lifecycle-Aware Components的时候我们知道activity实现了LifecycleOwner（继承了class SupportActivity extends Activity implements LifecycleOwner ）有个方法getLifecycle()返回了一个LifecycleRegistry的被观察者，它的主要作用是组件生命周期通知注册的观察者，做出改变。
* 方法进来之后，首先获取LifecycleRegistry中当前组件的状态，如果处于destoryed，就什么也不做。
* 如果不是destroyed就把我们的观察者封装成了LifecycleBoundObserver(),

* 然后判断我们LiveData中的观察者mObservers集合中有咩有，没有的话就放入，有的话就返回空。
* 如果没有的话也放入我们Activity组件中LifecycleRegistry中观察者集合中（这里面的观察者很杂，有观察数据的观察者（属于liveData）,也有我们上篇讲到到用注解自定义的观察者（处理与生命周期有关事件的））。

2. 什么时候通知观察者？
* 有人也可能会问为什么我们要把liveData中的观察者注册到LifecycleRegistry的handleLifecycleEvent()中，它自己不是有自己的观察者集合吗？

这是因为在上篇我们将组件的生命周期事件分发的时候讲到过通过LifecycleRegistry的handleLifecycleEvent()方法，而它被通过Activity中的ReportFragment的各个生命周期方法调用，所以我们要把我们的观察者注册到LifecycleRegistry，交由它去负责生命周期事件分发给我们的观察者。

* 注册到LifecycleRegistry中的时候会被封装成ObserverWithState观察者，有生命周期事件的时候会调用ObserverWithState的dispatchEvent()

ObserverWithState(LifecycleObserver observer, State initialState) {
mLifecycleObserver = Lifecycling.getCallback(observer);
mState = initialState;
}
void dispatchEvent(LifecycleOwner owner, Event event) {
State newState = getStateAfter(event);
mState = min(mState, newState);
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}

其中传入的LifecycleObserver就是我们上面讲的LifecycleBoundObserver，我们看到代码中的dispatchEvent()，会调用onStateChanged，他怎么写的呢？

@Override
public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
if (owner.getLifecycle().getCurrentState() == DESTROYED就一处，不是就通知改变) {
removeObserver(observer);
return;
}
// immediately set active state, so we'd never dispatch anything to inactive
// owner
activeStateChanged(isActiveState(owner.getLifecycle().getCurrentState()));
}

若果当前的LifecycleRegistry的状态是DESTROYED就移除我们的观察者，这就知道什么时候移除，我们也就不需要担心内存泄漏的风险。不是就通知改变，怎么通知观察者的呢？我们看下activeStateChanged，传入的参数我们后面会提到，先看下它的源码。

if (active) {
dispatchingValue(this);
}

如果处于活动状态就调用dispatchingValue()

for (Iterator, LifecycleBoundObserver>> iterator =
mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
for (Iterator, LifecycleBoundObserver>> iterator =
mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
considerNotify(iterator.next().getValue());
if (mDispatchInvalidated) {
break;
}
}(iterator.next().getValue());
if (mDispatchInvalidated) {
break;
}
}

在这里遍历liveData存放观察者的集合，然后considerNotify().看下源码

observer.observer.onChanged()((T) mData);

onChanged()方法就是我们在用法中最终回调的方法。

我们总结一下过程：
* liveData的observer()，把我们的观察者封装成了LifecycleBoundObserver，这个是liveData专用的观察者。
* 添加到LiveData的观察者集合和Activity中的LifecycleRegistry的集合（负责生命周期分发，和获取当前activit状态）
* 当Activity状态发生改变，就会通知我们的了LifecycleBoundObserver，同时调用它的onStateChanged()
* 然后在调用activeStateChanged(isActiveState(owner.getLifecycle().getCurrentState()));
* 然后遍历liveData的观察集合最后知道调用observer.observer.onChanged()((T) mData);

1. 怎么判断liveData是出于活跃状态？
   在文章的开头部分我们提到：

   如果观察者的生命周期处于started或者resumed状态的时候，liveData认为观察者处于活动状态。

   代码中怎么体现出来的呢？

   • 在上面的带面中我们分析到了
     

     activeStateChanged(
     isActiveState(owner.getLifecycle().getCurrentState()));

   其中有个关键方法就是

   isActiveState(owner.getLifecycle().getCurrentState())

   看下它的源码

   static boolean isActiveState(State state) {
       return state.isAtLeast(STARTED);
   }

   关键点就在State，看下它的源码

   public enum State {
       /**
        * Destroyed state for a LifecycleOwner. After this event, this Lifecycle will not dispatch
        * any more events. For instance, for an {@link android.app.Activity}, this state is reached
        * right before Activity's {@link android.app.Activity#onDestroy() onDestroy} call.
        */
       DESTROYED,
   
       /**
        * Initialized state for a LifecycleOwner. For an {@link android.app.Activity}, this is
        * the state when it is constructed but has not received
        * {@link android.app.Activity#onCreate(android.os.Bundle) onCreate} yet.
        */
       INITIALIZED,
   
       /**
        * Created state for a LifecycleOwner. For an {@link android.app.Activity}, this state
        * is reached in two cases:
        * 
   
        *     
   after {@link android.app.Activity#onCreate(android.os.Bundle) onCreate} call;
        *     
   right before {@link android.app.Activity#onStop() onStop} call.
        * 
        */
       CREATED,
   
       /**
        * Started state for a LifecycleOwner. For an {@link android.app.Activity}, this state
        * is reached in two cases:
        * 
   
        *     
   after {@link android.app.Activity#onStart() onStart} call;
        *     
   right before {@link android.app.Activity#onPause() onPause} call.
        * 
        */
       STARTED,
   
       /**
        * Resumed state for a LifecycleOwner. For an {@link android.app.Activity}, this state
        * is reached after {@link android.app.Activity#onResume() onResume} is called.
        */
       RESUMED;
   
       /**
        * Compares if this State is greater or equal to the given {@code state}.
        *
        * @param state State to compare with
        * @return true if this State is greater or equal to the given {@code state}
        */
       public boolean isAtLeast(@NonNull State state) {
           return compareTo(state) >= 0;
       }
   }

   对于isAtLeast()方法调用了枚举的compareTo，参数传入进来的是STARTED，大于等于就剩STARTED，RESUMED，所以我们说LiveData活动状态只有STARTED，RESUMED。