欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

Android Jetpack架构组件(五)带你了解LiveData(原理篇)

程序员文章站 2022-03-13 21:03:13
...

本文首发于微信公众号「后厂技术官」

前言

在上一篇文章中我们学习了LiveData的基本用法,我们知道LiveData是一个可观察的数据持有者,他是具有组件生命周期感知的,那么它是如何观察组件生命周期变化的呢?LiveData和RxJava的不同的是,LiveData并不是通知所有观察者,它只会通知处于Active状态的观察者,如果一个观察者处于DESTROYED状态,它将不会收到通知,这一点又是如何做到的?还有另外一点,Transformations的map方法其内部进行了什么操作?等等问题,会在这篇文章中给大家进行讲解。

1.LiveData如何观察组件生命周期变化

通过调用LiveData的observe方法来注册观察者,LiveData的observe方法如下所示。
frameworks/support/lifecycle/livedata-core/src/main/java/androidx/lifecycle/LiveData.java

 @MainThread
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        assertMainThread("observe");
        //如果被观察者的当前的状态是DESTROYED,就return
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {//1
            return;
        }
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);//2
        ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);//3
        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);//4
    }

注释1处的owner实际上就是注册时传进来来组件,比如Activity,获取组件当前的状态,如果状态为DESTROYED,那么直接return,这说明DESTROYED状态的组件是不允许注册的。

如果你还不了解Lifecycle的状态,可以查看Android Jetpack架构组件(三)带你了解Lifecycle(原理篇)这篇文章。
注释2处新建了一个LifecycleBoundObserver包装类,将owner和observer传了进去。
注释3处将observer和LifecycleBoundObserver存储到SafeIterableMap<Observer<? super T>, ObserverWrapper>mObservers中,putIfAbsent方法和put方法有区别,如果传入key对应的value已经存在,就返回存在的value,不进行替换。如果不存在,就添加key和value,返回null。
如果等于null,在注释4处会将LifecycleBoundObserver添加到Lifecycle中完成注册,这样当我们调用LiveData的observe方法时,实际上是LiveData内部完成了Lifecycle的观察者的添加,这样LiveData自然也就有了观察组件生命周期变化的能力。

2.LiveData的observe方法回调

LifecycleBoundObservers是LiveData的内部类,代码如下所示。
frameworks/support/lifecycle/livedata-core/src/main/java/androidx/lifecycle/LiveData.java

 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);//1
                return;
            }
            activeStateChanged(shouldBeActive());//2
        }

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

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

LifecycleBoundObserver继承了ObserverWrapper类,重写了shouldBeActive方法,用于判断当前传入的组件的状态是否是Active的,Active状态包括STARTED和RESUMED状态。

LifecycleBoundObserver实现了GenericLifecycleObserver接口,当组件状态发生变化时,会调用onStateChanged方法,当组件处于DESTROYED状态时,会调用注释1处的removeObserver方法,来移除observer。
这样在文章开头的疑问就解决了,为什么一个观察者(组件)处于DESTROYED状态时,它将不会收到通知。

接着会调用注释2处的activeStateChange方法,代码如下所示。

frameworks/support/lifecycle/livedata-core/src/main/java/androidx/lifecycle/LiveData.java

  private abstract class ObserverWrapper {
        final Observer<? super T> mObserver;
        boolean 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) {
            if (newActive == mActive) {
                return;
            }
            mActive = newActive;
            boolean wasInactive = LiveData.this.mActiveCount == 0;
            LiveData.this.mActiveCount += mActive ? 1 : -1;
            if (wasInactive && mActive) {
                onActive();
            }
            if (LiveData.this.mActiveCount == 0 && !mActive) {
                onInactive();
            }
            if (mActive) {
                dispatchingValue(this);//1
            }
        }
    }

activeStateChanged方法定义在抽象类ObserverWrapper中,它是Observer的包装类,activeStateChanged方法会根据Active状态和处于Active状态的组件的数量,来对onActive方法和onInactive方法回调,这两个方法用于拓展LiveData对象。注释1处,如果是Active状态,会调用dispatchingValue方法,并将自身传进去。

  private void dispatchingValue(@Nullable ObserverWrapper initiator) {
        //正在处于分发状态中
        if (mDispatchingValue) {
            //分发无效
            mDispatchInvalidated = true;//1
            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;
    }

mDispatchingValue用于标记当前是否处于分发状态中,如果处于该状态,则在注释1处标记当前分发无效,直接return。一路调用过来,ObserverWrapper是不为null的,ObserverWrapper为null的情况第3小节会讲到,无论是那种情况,都会调用considerNotify方法,代码如下所示。

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

considerNotify方法中做了多次的判断,注释1处,如果ObserverWrapper的mActive值不为true,就直接return。注释2处,如果当前observer对应组件的状态不是Active,就会再次调用activeStateChanged方法,并传入false,其方法内部会再次判断是否执行onActive方法和onInactive方法回调。如果判断条件都满足会调用Observer的onChanged方法,这个方法正是使用LiveData的observe方法的回调。

3.postValue/setValue方法分析

当调用MutableLiveData的observe方法后,还需要通过postValue/setValue方法来更新数据。
frameworks/support/lifecycle/livedata-core/src/main/java/androidx/lifecycle/LiveData.java

...
  private final Runnable mPostValueRunnable = new Runnable() {
        @Override
        public void run() {
            Object newValue;
            synchronized (mDataLock) {
                newValue = mPendingData;
                mPendingData = NOT_SET;
            }
            //noinspection unchecked
            setValue((T) newValue);//1
        }
    };
    ...
    protected void postValue(T value) {
        boolean postTask;
        synchronized (mDataLock) {
            postTask = mPendingData == NOT_SET;
            mPendingData = value;
        }
        if (!postTask) {
            return;
        }
        ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);//2
    }
    
    @MainThread //3
    protected void setValue(T value) {
        assertMainThread("setValue");
        mVersion++;
        mData = value;
        dispatchingValue(null);
    }

postValue/setValue方法都定义在LiveData中,根据注释1和注释2处,可以发现postValue方法实际上就是将setValue方法切换到主线程调用。注释3处说明setValue方法是运行在主线程中的,其内部调用了dispatchingValue方法,这个方法在第2小节介绍过,也就是dispatchingValue方法的参数ObserverWrapper为null的情况。
从这里我们可以知道,无论是LiveData的observe方法还是LiveData的postValue/setValue方法都会调用dispatchingValue方法。

4.Transformations.map方法分析

除了以上讲的常用的方法之外,还可能会使用到Transformations.map和Transformations.switchMap方法,这里以Transformations.map为例。这个方法用来在LiveData对象分发给观察者之前对其中存储的值进行更改,
代码如下所示。
frameworks/support/lifecycle/livedata/src/main/java/androidx/lifecycle/Transformations.java

@MainThread
    public static <X, Y> LiveData<Y> map(
            @NonNull LiveData<X> source,
            @NonNull final Function<X, Y> mapFunction) {
        final MediatorLiveData<Y> result = new MediatorLiveData<>();//1
        result.addSource(source, new Observer<X>() {
            @Override
            public void onChanged(@Nullable X x) {
                result.setValue(mapFunction.apply(x));
            }
        });
        return result;
    }

Transformations.map方法运行在主线程,注释1处创建了MediatorLiveData,紧接着调用了它的addSource方法:
support/lifecycle/livedata/src/main/java/androidx/lifecycle/MediatorLiveData.java

  */
    @MainThread
    public <S> void addSource(@NonNull LiveData<S> source, @NonNull Observer<? super S> onChanged) {
        Source<S> e = new Source<>(source, onChanged);//1
        Source<?> existing = mSources.putIfAbsent(source, e);
        if (existing != null && existing.mObserver != onChanged) {
            throw new IllegalArgumentException(
                    "This source was already added with the different observer");
        }
        if (existing != null) {
            return;
        }
        if (hasActiveObservers()) {
            e.plug();//2
        }
    }

注释1处将传进来的LiveData和onChanged封装到Source类中,注释2处调用了Source的plug方法:

 private static class Source<V> implements Observer<V> {
        final LiveData<V> mLiveData;
        final Observer<? super V> mObserver;
        int mVersion = START_VERSION;

        Source(LiveData<V> liveData, final Observer<? super V> observer) {
            mLiveData = liveData;
            mObserver = observer;
        }

        void plug() {
            mLiveData.observeForever(this);//1
        }

        void unplug() {
            mLiveData.removeObserver(this);
        }

        @Override
        public void onChanged(@Nullable V v) {
            if (mVersion != mLiveData.getVersion()) {
                mVersion = mLiveData.getVersion();
                mObserver.onChanged(v);//2
            }
        }
    }

注释2处可以看到,Transformations.map方法传入的Observer的回调在这里进行处理。注释1处,Source的plug方法会调用LiveData的observeForever方法,这个和第2小节所讲的内容有什么区别呢?我们再往下看。
frameworks/support/lifecycle/livedata-core/src/main/java/androidx/lifecycle/LiveData.java

    @MainThread
    public void observeForever(@NonNull Observer<? super T> observer) {
        assertMainThread("observeForever");
        AlwaysActiveObserver wrapper = new AlwaysActiveObserver(observer);//1
        ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
        if (existing != null && existing instanceof LiveData.LifecycleBoundObserver) {
            throw new IllegalArgumentException("Cannot add the same observer"
                    + " with different lifecycles");
        }
        if (existing != null) {
            return;
        }
        wrapper.activeStateChanged(true);
    }

注释1处用AlwaysActiveObserver来对Observer进行包装,紧接着调用AlwaysActiveObserver的activeStateChanged方法,其内部实际调用的是ObserverWrapper的activeStateChanged方法,这个在第二小节已经做了分析,就不再赘述了。来看AlwaysActiveObserver类是如何定义的。
frameworks/support/lifecycle/livedata-core/src/main/java/androidx/lifecycle/LiveData.java

   private class AlwaysActiveObserver extends ObserverWrapper {
        AlwaysActiveObserver(Observer<? super T> observer) {
            super(observer);
        }
        @Override
        boolean shouldBeActive() {
            return true;
        }
    }

AlwaysActiveObserver是LiveData的内部类,它继承自ObserverWrapper,AlwaysActiveObserver是LiveData的内部类和ObserverWrapper的区别就是,它是永远处于Active状态的。

5.LiveData关联类

接下来给出LiveData关联类的UML图,看明白这个图以后,再回去重新阅读本文,也许你会收获更多。

Android Jetpack架构组件(五)带你了解LiveData(原理篇)
可以看到,在讲解LiveData时涉及的大部分类都在这个图中,其中MutableLiveData继承自LiveData,LifecycleOwner和Observer和LiveData有关联的关系,ObserverWrapper是Observer的包装类,因此它们有着关联的关系,其他的类大家看图就知道了。


技术官和架构师的聚集地。洞察前沿架构、技术资讯、行业秘闻,聚焦Java、Python、机器学习、大前端等前沿技术。
Android Jetpack架构组件(五)带你了解LiveData(原理篇)