Android arch components 源码分析—— LiveData

Posted 黄毛火烧雪下

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Android arch components 源码分析—— LiveData相关的知识,希望对你有一定的参考价值。

本篇我们来看看 android 架构组件中的 LiveData 。跟 ViewModel 相比,LiveData 具有生命周期感知能力,也就是说,他把 ViewModel 和 lifecycle 结合了起来。当应用的数据有更新时,一般我们仅希望应用对用户可见时才更新 UI;更进一步,如果应用不可见,我们甚至可以停止数据的更新。这就是所谓的“感知应用的生命周期”。

这里我们主要关注 LiveData 的实现,用法可以参考 Google 的教程

添加 Observer

使用 LiveData 时,首先要做的,就是添加一个 Observer。

public interface Observer<T> 
    /**
     * Called when the data is changed.
     * @param t  The new data
     */
    void onChanged(@Nullable T t);


// 注意,他是 abstract class
public abstract class LiveData<T> 

    // 只有 onStart 后,对数据的修改才会触发 observer.onChanged()
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) 

    // 无论何时,只要数据发生改变,就会触发 observer.onChanged()
    public void observeForever(@NonNull Observer<T> observer) 

由于 LiveData 是一个 abstract class,我们不能直接生成他的实例。对于数据的拥有者,可以使用 MutableLiveData:

public class MutableLiveData<T> extends LiveData<T> 
    @Override
    public void postValue(T value) 
        // LiveData.postValue() 是一个 protected 方法
        super.postValue(value);
    

    @Override
    public void setValue(T value) 
        // LiveData.setValue() 是一个 protected 方法
        super.setValue(value);
    

所谓数据的拥有者。举个例子,你使用的是 MVP 模式,那么数据就属于 Model 层,另外两层不应该修改数据

通过让这两个 setter 方法成为 protected,只要我们给客户返回的是 LiveData,就不用担心数据会被客户意外修改:

class SomeClass extends ViewModel 

    // 在类的内部持有的是 MutableLiveData,所以我们可以调用 postValue/setValue
    private final MutableLiveData<Foo> mYourData = new MutableLiveData<>();

    // 返回的是 LiveData,LiveData 的 public 方法中并没有 postValue/setValue
    public LiveData<Foo> getData() 
        return mYourData;
    

活用 public, protected, private, default access 和 final 可以让我们的设计意图更加清晰。

现在回到我们的 observe() 方法,observeForever 的实现跟 observe 是类似的,我们就不看了,这里只看 observe():

public abstract class LiveData<T> 

    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) 
        // activity 已经 destroy,也就没必要添加 observer 了
        if (owner.getLifecycle().getCurrentState() == DESTROYED) 
            // ignore
            return;
        
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
        ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
        if (existing != null && !existing.isAttachedTo(owner)) 
            // 同一个 observer,只有对应的 lifecycleOwner 不一样,才可以重新添加
            throw new IllegalArgumentException("Cannot add the same observer"
                    + " with different lifecycles");
        
        if (existing != null) 
            return;
        
        // 这种方式添加的 observer,只有 activity 可见时才会收到数据更新的通知,
        // 为了知道什么时候 activity 是可见的,这里需要注册到 Lifecycle。
        // 也是因为这个,observe() 比 observeForever() 多了一个参数 lifecycleOwner
        owner.getLifecycle().addObserver(wrapper);
    


我们继续看 LifecycleBoundObserver:

public abstract class LiveData<T> 

    // 空实现,如果在 LiveData 变为 inactive 状态后想停止更新数据,可以
    // override 这两个方法
    protected void onActive() 
    protected void onInactive() 

    private abstract class ObserverWrapper 
        final Observer<T> mObserver;
        boolean mActive;
        int mLastVersion = START_VERSION;

        ObserverWrapper(Observer<T> observer) 
            mObserver = observer;
        

        // 如果 observer 处于 active 状态,则返回 true
        abstract boolean shouldBeActive();

        boolean isAttachedTo(LifecycleOwner owner) 
            return false;
        

        void detachObserver() 
        

        void activeStateChanged(boolean newActive) 
            if (newActive == mActive) 
                return;
            
            // immediately set active state, so we'd never dispatch anything to inactive
            // owner
            mActive = newActive;
            // LiveData.this.mActiveCount 表示处于 active 状态的 observer 的数量
            // 当 mActiveCount 大于 0 时,`LiveData` 处于 active 状态
            // 注意区分 observer 的 active 状态和 LiveData 的 active 状态
            boolean wasInactive = LiveData.this.mActiveCount == 0;
            LiveData.this.mActiveCount += mActive ? 1 : -1;
            if (wasInactive && mActive) 
                // inactive -> active
                onActive();
            
            // 这里用 else if 比较好,因为只有一个会执行。else if 更易读
            if (LiveData.this.mActiveCount == 0 && !mActive) 
                // mActiveCount 在我们修改前等于 1,也就是说,`LiveData` 从 active
                // 状态变到了 inactive
                onInactive();
            
            if (mActive) 
                // observer 从 inactive 到 active,此时客户拿到的数据可能不是最新的,这里需要 dispatch 一下
                // 关于他的实现,我们下一节再看
                dispatchingValue(this);
            
        
    

    class LifecycleBoundObserver extends ObserverWrapper implements GenericLifecycleObserver 
        @NonNull final LifecycleOwner mOwner;

        LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<T> observer) 
            super(observer);
            mOwner = owner;
        

        @Override
        boolean shouldBeActive() 
            // onStart 到 onStop 之间则认为是 active 状态
            return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
        

        // 这个是 lifecycle 的回调函数
        @Override
        public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) 
            if (mOwner.getLifecycle().getCurrentState() == DESTROYED) 
                removeObserver(mObserver);
                return;
            
            // 刚刚生成 LifecycleBoundObserver 的实例时,mActive == false,注册到
            // Lifecycle 后,Lifecycle 会同步状态给我们(也就是回调本函数)。
            // 不熟悉 lifecycle 的读者,可以看
            // https://jekton.github.io/2018/07/06/android-arch-lifecycle/
            activeStateChanged(shouldBeActive());
        

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

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

到这里,observer 的注册我们就看完了。下面我们看看如何发布(publish)数据给 LiveData。

发布修改

要修改 LiveData,有两种方式:

public abstract class LiveData<T> 

    // 同步修改数据
    protected void setValue(T value);

    // 会用 Handler post 一个 runnable,然后在 runnable 里面 setValue
    protected void postValue(T value);

setValue 比较简单,我们先看 setValue:

public abstract class LiveData<T> 

    @MainThread
    protected void setValue(T value) 
        assertMainThread("setValue");
        // 每次更新 value,都会使 mVersion + 1
        // ObserverWrapper 也有一个字段,叫 mLastVersion
        // 通过比较这两个字段,可以避免重复通知客户(具体在后面会看到)
        mVersion++;
        mData = value;
        dispatchingValue(null);
    

    // 如果 initiator == null,表示要通知所有的 observer
    // 不等于 null 则只通知 initiator
    private void dispatchingValue(@Nullable ObserverWrapper initiator) 
        if (mDispatchingValue) 
            // 在 observer 的回调里面又触发了数据的修改
            // 设置 mDispatchInvalidated 为 true 后,可以让下面的循环知道
            // 数据被修改了,从而开始一轮新的迭代。
            //
            // 比方说,dispatchingValue -> observer.onChanged -> setValue
            //            -> dispatchingValue
            // 这里 return 的是后面那个 dispatchingValue,然后在第一个
            // dispatchingValue 会重新遍历所有的 observer,并调用他们的
            // onChanged。
            //
            // 如果想避免这种情况,可以在回调里面使用 postValue 来更新数据
            mDispatchInvalidated = true;
            return;
        
        mDispatchingValue = true;
        do 
            mDispatchInvalidated = false;
            if (initiator != null) 
                // 调用 observer.onChanged()
                considerNotify(initiator);
                initiator = null;
             else 
                for (Iterator<Map.Entry<Observer<T>, ObserverWrapper>> iterator =
                        mObservers.iteratorWithAdditions(); iterator.hasNext(); ) 
                    considerNotify(iterator.next().getValue());
                    if (mDispatchInvalidated) 
                        // 某个客户在回调里面更新了数据,break 后,这个 for 循环会
                        // 重新开始
                        break;
                    
                
            
        // 当某个客户在回调里面更新了数据,mDispatchInvalidated == true
         while (mDispatchInvalidated);
        mDispatchingValue = false;
    

看过我那篇 lifecycle 源码分析的读者应该对 dispatchingValue 处理循环调用的方式很熟悉了。以这里为例,为了防止循环调用,我们在调用客户代码前先置位一个标志(mDispatchingValue),结束后再设为 false。如果在回调里面又触发了这个方法,可以通过 mDispatchingValue 来检测。

检测到循环调用后,再设置第二个标志(mDispatchInvalidated),然后返回。返回又会回到之前的调用,前一个调用通过检查 mDispatchInvalidated,知道数据被修改,于是开始一轮新的迭代。

下面是 considerNotify:


    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;
        
        // 对于 LifecycleBoundObserver 来说,即使 `LiveData` 的数据没有变化,只要 activity 的生命
        // 周期发生了改变,还是可能会调用 considerNotify 多次
        // 通过比较 observer.mLastVersion 和 mVersion,就能够知道 observer 是否已经拥有了最新的数据
        //
        // 实际上,observer.mLastVersion 最多只能等于 mVersion
        if (observer.mLastVersion >= mVersion) 
            return;
        
        observer.mLastVersion = mVersion;
        //noinspection unchecked
        observer.mObserver.onChanged((T) mData);
    


看完了 setValue,postValue 对我们来说就很简单了:

public abstract class LiveData<T> 

    // 注意,他是 volatile。因为 postValue 可以从后台线程调用,
    private volatile Object mPendingData = NOT_SET;

    private final Runnable mPostValueRunnable = new Runnable() 
        @Override
        public void run() 
            Object newValue;
            synchronized (mDataLock) 
                newValue = mPendingData;
                mPendingData = NOT_SET;
            
            //noinspection unchecked
            setValue((T) newValue);
        
    ;


    protected void postValue(T value) 
        boolean postTask;
        synchronized (mDataLock) 
            postTask = mPendingData == NOT_SET;
            mPendingData = value;
        
        if (!postTask) 
            // 已经有一个 post 后还没有执行的 runnable,所以就不需要再 post 了,
            // 前面 post 的 runnable 执行时,会拿到这个新设置的 value
            return;
        
        // 最终执行的就是 handler.post()
        ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
    

LiveData 的核心代码我们已经看完了,其实他的实现也挺简单的,对吧?

总结

关于 LiveData,有两个值得我们学习的,一个是循环调用的处理,另一个是 mVersion 的使用。关于 mVersion,这里再举一个之前工作中遇到的例子。在后台线程对数据进行持久化的时候(这个线程拷贝了一份数据),数据还有可能会被更新。为了判断所保存的数据是不是最新的,我当时的做法就是引入一个类似 mVersion 的东西,每次修改数据,都把 mVersion 加 1。通过比较 mVersion 和所保存的数据的 version,就能够知道是不是保存了最新的数据(当然,更好的做法是告诉后台线程数据已经修改,让他重新拿一次数据)。

以上是关于Android arch components 源码分析—— LiveData的主要内容,如果未能解决你的问题,请参考以下文章

Android arch components 源码分析—— Lifecycle

无法导入 android.arch.persistence.room.testing.MigrationTestHelper

RuntimeException:ClassNotFoundException android.arch.lifecycle.ProcessLifecycleOwnerInitializer

Arch Linux 更新源(以清华 arch 源为例)

在使用 Android 架构组件和 Room 时将数据插入外部源/数据库

manjaro和arch比哪个好使