Jetpack-Lifecycle

LiveData

LiveData是一种可观察的数据存储器类。与常规的可观察类不同，LiveData具有生命周期感知能力，也就是说它能感知Activity、Fragment 或 Service的生命周期，只有它们的生命周期处于活跃状态，观察者才能收到数据更新的通知，而处于非活跃状态时是不会收到通知的。

优点

• 避免了内存泄露：观察者会绑定到Lifecycle对象，并在其关联的生命周期销毁后进行释放。
• 不会因Activity停止而导致崩溃：比如，全局工具类中依赖了Activity，当Activity销毁后，我们如果调用了该工具类中的方法时，就会出现错误，这个错误可能对于用户不可见。如果使用LiveData，当观察者的生命周期处于非活跃状态时，它是不会收到LiveData的更新通知。
• 不再需要手动处理生命周期：LiveData在观察时可以感知相关的生命周期状态变化，它会自动停止和恢复对数据的观察。
• 数据始终保持最新状态：如果生命周期变为非活跃状态，它会在再次变为活跃状态时接收最新的数据。比如，当Activity处于后台的时候，如果数据发生了变化，这时页面是不会更新的，只有当Activity重新恢复到前台后才会更新页面。
• 资源共享：可以把LiveData封装成单例，只要有一个地方改变了数据，那么所有观察的地方都会收到更新的通知。

使用

LiveData本身是一个抽象类，我们需要使用它的子类：MutableLiveData。

public abstract class LiveData<T> 

从它的定义可以看出，需要传一个泛型，这个泛型就是观察数据的数据类型。

创建LiveData

class MyViewModel : ViewModel() {

    val price: MutableLiveData<Double> by lazy { MutableLiveData<Double>() }

}

LiveData都是结合ViewModel使用，如果不了解ViewModel，可以先把它当做一个普通的类，下一篇会讲解ViewModel。

观察LiveData

class MainActivity : AppCompatActivity() {

    private lateinit var mViewModel: MyViewModel

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        //获取ViewModel实例
        mViewModel = ViewModelProviders.of(this).get(MyViewModel::class.java)
        //调用LiveData的observe()方法添加观察者
        mViewModel.price.observe(this, Observer<Double> { price ->
            //todo
        })
    }
}

当price的数据发生变化时，就会调用Observer的onChanged()方法。

如果观察者的生命周期处于STARTED或RESUMED状态，则LiveData会认为该观察者处于活跃状态。就会调用它的onActive()方法，否则调用onInactive()方法。我们可以继承LiveData，重写这两个方法，来扩展LiveData。

public abstract class LiveData<T> {
    protected void onActive() {}
    protected void onInactive() {}
}

MediatorLiveData

如果想观察多个LiveData，只要其中任何一个LiveData发生变化，就会通知观察者。可以使用MediatorLiveData，它是LiveData的子类。

val liveData1: LiveData<String> by lazy { MutableLiveData<String>() }
val liveData2: LiveData<String> by lazy { MutableLiveData<String>() }
//将多个LiveData合并到一个里面，只需要观察liveDataMerger即可。
val liveDataMerger = MediatorLiveData<String>().apply {
    this.addSource(liveData1) { this.value = it }
    this.addSource(liveData2) { this.value = it }
}

只要liveData1，liveData2中有一个发生变化，那么liveDataMerger的观察者就会收到变化的通知。

数据转换

如果希望LiveData在分发给观察者之前更改数据，或者根据它返回另一个LiveData实例，可以使用Transformations中提供的方法。

map()

val price: MutableLiveData<Double> by lazy { MutableLiveData<Double>() }
val discountPrice = Transformations.map(price) { price ->
    price + 0.8
}

switchMap()

private val userId: MutableLiveData<String> by lazy { MutableLiveData<String>() }
val user = Transformations.switchMap(userId){userId ->getUser(userId)}

switchMap()与map()相似，但是传递给switchMap()的方法必须返回LiveData对象，也就是说getUser()方法的返回值必须是一个LiveData对象。而且switchMap()的转换只有在返回的LiveData对象数据改变时才会转换。

val userId: MutableLiveData<String> by lazy { MutableLiveData<String>() }
val user: LiveData<String> = Transformations.switchMap(userId) { userId ->getUser(userId)}

private fun getUser(id: String): LiveData<String> {
    val user = MutableLiveData<String>()
    Thread {
        Thread.sleep(2000)
        user.postValue("user：$id")
    }.start()
    return user
}

userId的变化会触发Transformations.switchMap(userId),但是只有当getUser()方法中的LiveData对象数据变化时才会触发user的变化。

实现原理

我们在使用LiveData的时候，需要给它添加一个观察者，然后当数据变化的时候就会回调对应的方法，如下所示：

mViewModel.user.observe(this, Observer<String> {
    //todo
})

那我们就以LiveData的observe()方法为分析入口，看一下该方法的实现：

public abstract class LiveData<T> {
    ...
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        assertMainThread("observe");
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {  
            return;
        }
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, 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);
    }
    ...
}

从上面的代码可以看出，观察者是作为LifeCycleOwner类型参数传进来的，observe()方法必须在主线程中调用，如果观察者的生命周期处于DESTROYED状态，直接返回，否则添加到观察者行列里。将owner包装成了LifecycleBoundObserver类型，然后调用了Lifecycle的addObserver()方法。该方法就是上一篇文章：Jetpack-Lifecycle分析的入口，这里不再阐述。下面看一下LifecycleBoundObserver的实现：

public abstract class LiveData<T> {
    ...
    class LifecycleBoundObserver extends ObserverWrapper implements GenericLifecycleObserver {
        @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(LifecycleOwner source, Lifecycle.Event event) {
            if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
                removeObserver(mObserver);
                return;
            }
            activeStateChanged(shouldBeActive());
        }

        @Override
        boolean isAttachedTo(LifecycleOwner owner) {
            return mOwner == owner;
        }

        @Override
        void detachObserver() {
            mOwner.getLifecycle().removeObserver(this);
        }
    }
    ...
}

LifecycleBoundObserver是LiveData里面的一个静态内部类，它继承自ObserverWrapper并实现了接口GenericLifecycleObserver，而GenericLifecycleObserver间接继承了接口LifecycleObserver，那么它就能感知LifecycleOwner的状态。这样LiveData就能感知观察者的生命周期。那么它是什么时候通知观察者的呢？只有当数据变化的时候，才会通知观察者，那么我们接下来就看一下它的赋值方法：setValue()

@MainThread
protected void setValue(T value) {
    assertMainThread("setValue");
    mVersion++;
    mData = value;
    dispatchingValue(null);
}

setValue()方法必须在主线程中调用，而postValue()方法没有限制。该方法实现比较简单，就是将传入的数据复制给mData，然后调用了dispatchingValue()方法。

void dispatchingValue(@Nullable ObserverWrapper initiator) {
    if (mDispatchingValue) {
        mDispatchInvalidated = true;
        return;
    }
    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) {
                    break;
                }
            }
        }
    } while (mDispatchInvalidated);
    mDispatchingValue = false;
}

该方法的参数实际上就是观察者，如果为null，就会遍历所有的观察者，否则只会调用传入的。通过调用considerNotify()方法来通知观察者，下面就看一下该方法的实现：

private void considerNotify(ObserverWrapper observer) {
    if (!observer.mActive) {
        return;
    }
    if (!observer.shouldBeActive()) {
        observer.activeStateChanged(false);
        return;
    }
    if (observer.mLastVersion >= mVersion) {
        return;
    }
    observer.mLastVersion = mVersion;
    //noinspection unchecked
    observer.mObserver.onChanged((T) mData);
}

如果观察者处于非活跃状态，则直接返回，否则调用observer.mObserver.onChanged((T) mData);，其中observer.mObserver就是我们调用LiveData的observe()方法传入的Observer，调用它的onChanged()方法，并把设置的数据mData传入，这样观察者就收到数据变化的通知了（方法调用）。

上面的示例用的是Lambda表达式，回调的方法不能直观的看出来，下面贴出代码对比一下，方便理解。

mViewModel.user.observe(this, Observer<String> {
      //todo
})

mViewModel.user.observe(this, object :Observer<String>{
    override fun onChanged(t: String?) {
      //todo
    }
})

KotlinAndroid