Android Architecture Component之LiveData

前言

系列文章

Android Architecture Component之Lifecycle-Aware Components源码分析

Android Architecture Component之LiveData源码分析

Android Architecture Component之ViewModel源码分析

一、liveData是什么？

1.介绍

LiveData是一个数据持有者类，他持有一个允许被观察的值，不同于普通的被观察者，liveData遵从应用程序的生命周期，被注册的观察者都要遵循其生命周期。
如果观察者的生命周期处于started或者resumed状态的时候，liveData认为观察者处于活动状态。
LiveData只通知处于活跃状态的observer,不活跃的不通知其改变。

优点

没有内存泄漏的风险，当页面销毁的时候，他们会自动被移除，不会导致内存溢出
不会因为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<Student> studentMutableLiveData =new MutableLiveData<>();

public MainViewModel(Application application) {
    super(application);
}


public void changeName(Student student) {

    student.setAge(i++);
    studentMutableLiveData.setValue(student);

}

public MutableLiveData<Student> 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<Student>() {
       @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是活动活动状态？

怎么添加观察者？

上面的列子用到了MutableLiveData，看下他的源码
```
public class MutableLiveData<T> extends LiveData<T> {
@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<T> 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）,也有我们上篇讲到到用注解自定义的观察者（处理与生命周期有关事件的））。

什么时候通知观察者？

有人也可能会问为什么我们要把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<Map.Entry<Observer<T>, LifecycleBoundObserver>> iterator =
                    mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
                for (Iterator<Map.Entry<Observer<T>, 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);

怎么判断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
     * <b>right before</b> 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:
     * <ul>
     *     <li>after {@link android.app.Activity#onCreate(android.os.Bundle) onCreate} call;
     *     <li><b>right before</b> {@link android.app.Activity#onStop() onStop} call.
     * </ul>
     */
    CREATED,

    /**
     * Started state for a LifecycleOwner. For an {@link android.app.Activity}, this state
     * is reached in two cases:
     * <ul>
     *     <li>after {@link android.app.Activity#onStart() onStart} call;
     *     <li><b>right before</b> {@link android.app.Activity#onPause() onPause} call.
     * </ul>
     */
    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。