android LiveData

Android LiveData

LiveData 是一种可观察的数据存储器类。与常规的可观察类不同，LiveData 具有生命周期感知能力，意指它遵循其他应用组件（如 Activity、Fragment 或 Service）的生命周期。如果观察者（由 Observer 类表示）的生命周期处于 STARTED 或 RESUMED 状态，则 LiveData 会认为该观察者处于活跃状态。LiveData 只会将更新通知给活跃的观察者。为观察 LiveData 对象而注册的非活跃观察者不会收到更改通知。

使用示例

创建 LiveData 对象

class NameViewModel : ViewModel() {

    // Create a LiveData with a String
    val currentName: MutableLiveData<String> by lazy {
        MutableLiveData<String>()
    }

    // Rest of the ViewModel...
}

class NameActivity : AppCompatActivity() {

    // Use the 'by viewModels()' Kotlin property delegate
    // from the activity-ktx artifact
    private val model: NameViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        //创建Observer,currentName更新值的时候会回调Observer的onChanged方法,从而更新UI
        val nameObserver = Observer<String> { newName ->
            nameTextView.text = newName
        }
        //给currentName设置订阅;
        model.currentName.observe(this, nameObserver)
    }
}

扩展 LiveData

class StockLiveData(symbol: String) : LiveData<BigDecimal>() {
    private val stockManager = StockManager(symbol)

    private val listener = { price: BigDecimal ->
        value = price // 更新LiveData的值
    }

    override fun onActive() {
        stockManager.requestPriceUpdates(listener) // LiveData有活跃的观察者时会自动调用onActive方法
    }

    override fun onInactive() {
        stockManager.removeUpdates(listener) //LiveData没有活跃的观察者时会自动调用onInactive方法
    }
}

转换 LiveData

Transformations.map() 、Transformations.switchMap()

val userLiveData: LiveData<User> = UserLiveData()
val userName: LiveData<String> = Transformations.map(userLiveData) { // userName是一个新的LiveData
    user -> "${user.name} ${user.lastName}"
}

合并多个 LiveData 源

MediatorLiveData 是 LiveData 的子类，允许您合并多个 LiveData 源。

源码分析

目标

• LiveData更新数据的流程
• LiveData是如何做到感知生命周期的

LiveData.java

    @MainThread
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        assertMainThread("observe"); // 只能在UI线程里面调用observe方法
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {// lifecycle的state为destory，添加失效
            // ignore
            return;
        }
        // 包装observer,生命周期感知就是在LifecycleBoundObserver里面处理的
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
        // mObservers 实现了一个map,key是observer,value是LifecycleBoundObserver,是ObserverWrapper的子类;
        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;
        }
        // 注册生命周期监听,生命周期感知肯定跟LifecycleBoundObserver有关
        owner.getLifecycle().addObserver(wrapper);
    }

LiveData通过setValue或者postValue来更新存储value，postValue和setValue的区别在于postValue在非UI线程里面调用，setValue在UI线程调用

  protected void postValue(T value) {
        boolean postTask;
        synchronized (mDataLock) {
            postTask = mPendingData == NOT_SET;
            mPendingData = value;
        }
        if (!postTask) {
            return;
        }
        ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
    }

    private final Runnable mPostValueRunnable = new Runnable() {
        @Override
        public void run() {
            Object newValue;
            synchronized (mDataLock) {
                newValue = mPendingData;
                mPendingData = NOT_SET;
            }
            //noinspection unchecked
            setValue((T) newValue); // 最终都是调用setValue来更新数据
        }
    };

    @MainThread
    protected void setValue(T value) {
        assertMainThread("setValue");
        mVersion++;// 没调用一次，+1 ，记录数据更新了多少次
        mData = value;
        dispatchingValue(null); // 更新value,参数为null会更新触发所有observer的回调
    }

    @SuppressWarnings("WeakerAccess") /* synthetic access */
    void dispatchingValue(@Nullable ObserverWrapper initiator) {
        if (mDispatchingValue) {
            mDispatchInvalidated = true;
            return;
        }
        mDispatchingValue = true;
        do {
            mDispatchInvalidated = false;
            //单个observer,更新数据
            if (initiator != null) {
                considerNotify(initiator);
                initiator = null;
            } else {
                // 遍历mObservers,通知每一个observer更新数据;
                for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =
                        mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
                    considerNotify(iterator.next().getValue());// 触发单个observer
                    if (mDispatchInvalidated) {
                        break;
                    }
                }
            }
        } while (mDispatchInvalidated);
        mDispatchingValue = false;
    }

    private void considerNotify(ObserverWrapper observer) {
        // observer是否可用
        if (!observer.mActive) {
            return;
        }
        // observer是否处于活跃状态(Lifecycle的 State >= STARTED)
        if (!observer.shouldBeActive()) {
            observer.activeStateChanged(false);
            return;
        }
        // observer是否是最新数据了,如果已经更新到最新了，那么这次就不更新;
        if (observer.mLastVersion >= mVersion) {
            return;
        }
        observer.mLastVersion = mVersion;
        //回调observer的onChanged方法,这个mObserver就是我们observe方法里面传入的observer
        observer.mObserver.onChanged((T) mData);
    }

好的，到这里LiveData更新数据的流程基本完成了，但是还有些疑问

• observer.mActive 是干啥的

LifecycleBoundObserver.java

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

        LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<? super T> observer) {
            super(observer);
            mOwner = owner;
        }
        
        // 生命周期是否 >= STARTED, observer是否处于活跃状态
        @Override
        boolean shouldBeActive() {
            return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
        }

        //LiveData observe()方面里面调用owner.getLifecycle().addObserver(wrapper),这个wrapper就是LifecycleBoundObserver，
        // 所以Lifecycle生命周期回调，会执行LifecycleBoundObserver的onStateChanged方法
        @Override
        public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
            if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
                removeObserver(mObserver);// 移除添加到LiveData里面的observer
                return;
            }
            activeStateChanged(shouldBeActive());// 用shouldBeActive()的值来作为active的状态
        }

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

        @Override
        void detachObserver() {
            mOwner.getLifecycle().removeObserver(this);// 将自己从Lifecycle里面移除
        }
    }

LiveData通过LifecycleBoundObserver是感知Lifecycle生命周期的状态，并且处理了active状态更新 , Lifecycle生命周期Observer的释放和LiveData Observer的释放

removeObserver(mObserver)

    // LiveData
	@MainThread
    public void removeObserver(@NonNull final Observer<? super T> observer) {
        assertMainThread("removeObserver");
        ObserverWrapper removed = mObservers.remove(observer);// 移除添加到LiveData里面的observer
        if (removed == null) {
            return;
        }
        removed.detachObserver();
        removed.activeStateChanged(false);
    }

mLastVersion 和 mVersion是如何判断数据是否是最新数据的 和 observer.mActive 是干啥的这两个问题还没有答案啊，继续看ObserverWrapper.java,它是LifecycleBoundObserver的父类

ObserverWrapper.java

 private abstract class ObserverWrapper {
        final Observer<? super T> mObserver;// LiveData.observe(Observer observer)
        boolean mActive; //在这里 observer.mActive
        int mLastVersion = START_VERSION;

        ObserverWrapper(Observer<? super T> observer) {
            mObserver = observer;
        }

        abstract boolean shouldBeActive();

        boolean isAttachedTo(LifecycleOwner owner) {
            return false;
        }

        void detachObserver() {
        }

        void activeStateChanged(boolean newActive) {
            // 如果active状态发生变化，那么更新active
            if (newActive == mActive) {
                return;
            }
            mActive = newActive;
            // 是否有活跃的观察者
            boolean wasInactive = LiveData.this.mActiveCount == 0;
            // 更新LiveData mActiveCount数量
            LiveData.this.mActiveCount += mActive ? 1 : -1;
            if (wasInactive && mActive) {// 从不活跃到活跃，调用onActive()
                onActive();
            }
            if (LiveData.this.mActiveCount == 0 && !mActive) { // 完全不活跃，调用onInactive();
                onInactive();
            }
            if (mActive) {
                dispatchingValue(this);// 更新数据;
            }
        }
    }

observer.mActive是observer是否活跃的最终判断依据，而不是简单的直接通过Lifecycle的State来判读，这样做的好处是什么呢？其实是为了便于扩展，比如AlwaysActiveObserver , 一直是活跃的，不受生命周期影响 ，这种类型的Observer就需要我们主动释放了

    private class AlwaysActiveObserver extends ObserverWrapper {

        AlwaysActiveObserver(Observer<? super T> observer) {
            super(observer);
        }

        @Override
        boolean shouldBeActive() {
            return true;
        }
    }

最后看一下Observer的释放

   // 删除特定observer
	@MainThread
    public void removeObserver(@NonNull final Observer<? super T> observer) {
        assertMainThread("removeObserver");
        ObserverWrapper removed = mObservers.remove(observer);
        if (removed == null) {
            return;
        }
        removed.detachObserver();
        removed.activeStateChanged(false);
    }

	// 删除所有关联Lifecycle的observers
    @SuppressWarnings("WeakerAccess")
    @MainThread
    public void removeObservers(@NonNull final LifecycleOwner owner) {
        assertMainThread("removeObservers");
        for (Map.Entry<Observer<? super T>, ObserverWrapper> entry : mObservers) {
            if (entry.getValue().isAttachedTo(owner)) {
                removeObserver(entry.getKey());
            }
        }
    }