Jetpack-LiveData

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的数据发生变化时,就会调用ObserveronChanged()方法。

如果观察者的生命周期处于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
})

那我们就以LiveDataobserve()方法为分析入口,看一下该方法的实现:

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类型,然后调用了LifecycleaddObserver()方法。该方法就是上一篇文章: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);
        }
    }
    ...
}

LifecycleBoundObserverLiveData里面的一个静态内部类,它继承自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就是我们调用LiveDataobserve()方法传入的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

推荐阅读更多精彩内容

  • LiveData 概述 LiveData 是一个可观察数据包装类,与普通观察者不同,LiveData 具备生命周期...
    SkyRiN阅读 397评论 0 1
  • 一、 是什么 Google2018年推出的新架构,意图在统一UI组件与架构。 先说一些前置知识。 androidx...
    落水木木阅读 66评论 0 0
  • [TOC] LiveData LiveData概述 LiveData是一个可观察的数据持有者类。与常规observ...
    雪晨杰阅读 665评论 0 8
  • 早上品尝了燃面,没想到三餐都吃!干面加油加花生碎加辣椒等佐料,拌好后超级好吃!辣得顿时头上冒汗!川南产花椒,吃辣祛...
    飞鸿2017阅读 65评论 0 0
  • 幼儿数学核心概念(Big Ideas of Early Math),描绘了3-6岁幼儿应该努力理解的关键性数学概...
    taotaolin1122阅读 253评论 0 0