Livedata原理

1. Livedata特性

LiveData 是一种可观察的数据存储器类。并且具有生命周期感知能力,能遵循其他应用组件(如 Activity、Fragment 或 Service)的生命周期。

1.1 只有当它关联的应用组件处于生命周期活跃状态时,才会通知对应观察者。

1.2 当关联的应用组件的状态变为 DESTROYED 时,便可移除此观察者,避免内存泄露。

1.3 LiveData 仅在数据发生更改时才发送更新,并且仅发送给活跃观察者。此行为的一种例外情况是,观察者从非活跃状态更改为活跃状态时也会收到更新。此外,如果观察者第二次从非活跃状态更改为活跃状态,则只有在自上次变为活跃状态以来,值发生了更改时,它才会收到更新。

2. 原理介绍

2.1 Livedata.observe方法

    @MainThread
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer super T> observer) {
        assertMainThread("observe");
        //如当前LifecycleOwner的状态的是DESTROYED,就不绑定
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {
            // ignore
            return;
        }
        //创建一个LifecycleBoundObserver(生命周期限制的观察者)
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
        //将观察者添加到mObservers map
        ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
        //如果已经存在并且观察者对应的LifecycleOwner不是之前绑定的LifecycleOwner报错
        if (existing != null && !existing.isAttachedTo(owner)) {
            throw new IllegalArgumentException("Cannot add the same observer"
                    + " with different lifecycles");
        }
        //如果存在直接返回
        if (existing != null) {
            return;
        }
        //将观察者生命周期和LifecycleOwner对应的Lifecycle绑定
        //当LifecycleOwner的生命周期发生变化时,回调LifecycleBoundObserver中的 onStateChanged
        owner.getLifecycle().addObserver(wrapper);
    }

1,observe方法先判断LifecycleOwner是否已经处于DESTROYED的状态,如果是就不绑定;

2,然后将创建一个LifecycleBoundObserver,并且将observer和LifecycleBoundObserver添加到观察者map中;

3,最后将LifecycleBoundObserver和LifecycleOwner的生命周期绑定。

2.2 LifecycleBoundObserver

class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver {
        @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);
        }

        // 当LifecycleOwner生命周期发生变化时,调用这个函数 
       @Override
        public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
            if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
                removeObserver(mObserver);
                return;
            }
           //LifecycleOwner生命周期改变时,如果LifecycleOwner生命周期处于活跃状态,更新数据
            activeStateChanged(shouldBeActive());
        }

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

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

1,当LifecycleOwner的生命周期变化是会调用LifecycleBoundObserver的onStateChanged方法;

2,判断LifecycleOwner如果处于DESTROYED,移除观察者;

3,否则如果当前是活跃状态,就将最新值通知给所有观察者。

2.3 ObserverWrapper

 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;
            }
            // immediately set active state, so we'd never dispatch anything to inactive
            // owner
            mActive = newActive;
            changeActiveCounter(mActive ? 1 : -1);
            
            //有变化,且是活跃状态,更新数据
            if (mActive) {
                dispatchingValue(this);
            }
        }  
    }

2.4 Livedata.dispatchingValue

 void dispatchingValue(@Nullable ObserverWrapper initiator) {
         //如果正在刷新数据,mDispatchInvalidated置为true,表示之前的刷新无效
        if (mDispatchingValue) {
            mDispatchInvalidated = true;
            return;
        }
        mDispatchingValue = true;
        do {
            mDispatchInvalidated = false;
            //如果ObserverWrapper不为null,则只刷新传入的ObserverWrapper
            if (initiator != null) {
                considerNotify(initiator);
                initiator = null;
            } else {
                //否则刷新所有观察者
                for (Iterator, ObserverWrapper>> iterator =
                        mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
                    considerNotify(iterator.next().getValue());
                    //刷新数据的时候,如果在次调用此方法,则重新刷新
                    if (mDispatchInvalidated) {
                        break;
                    }
                }
            }
            //刷新数据的时候,如果在次调用此方法,则重新刷新
        } while (mDispatchInvalidated);
        mDispatchingValue = false;
    }

1,如果传入观察者,则只刷新当前观察者,用于LifecycleOwner生命周期改变时,因为所有的观察者都绑定了LifecycleOwner的生命周期,所以这里还是刷新所有观察者;

2,如果没有传入观察者,遍历观察者map,刷新所有观察者,用于Livedata持有数据改变时;

3,如果刷新的时候,此方法被再次调用,会放弃当前刷新,重新再开始下一轮刷新。

2.5 Livedata.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.
        / 如果当前LifecycleOwner的生命周期是非活跃,不回调onChanged
        //并在LifecycleBoundObserver 中记录状态,当生命周期变为活跃,去更新数据
        if (!observer.shouldBeActive()) {
            observer.activeStateChanged(false);
            return;
        }
        if (observer.mLastVersion >= mVersion) {
            return;
        }
        observer.mLastVersion = mVersion;
        //调用观察者的onChanged
        observer.mObserver.onChanged((T) mData);
    }

2.5 Livedata.setValue

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

setValue也是调用了dispatchingValue方法,传的参数时null,更新所有观察者。

总结:
Livedata通知观察者分为两种情况
1,LifecycleOwner生命周期从非活跃变成活跃状态时:
Livedata添加一个观察者时,会关联一个LifecycleOwner,然后把这个观察者包装成一个LifecycleBoundObserver,和LifecycleOwner的Lifecycle关联,当LifecycleOwner的生命周期变化时,会调用LifecycleBoundObserver的onStateChanged方法,在这个方法中判断当前生命周期和上次的生命周期是否是同一类型(要么活跃要么非活跃),如果是,就直接返回,避免重复通知(start通知了,resume就不需要通知了),如果不是同一类型,并且当前生命周期是活跃状态,就调用dispatchingValue方法通知观察者,判断LifecycleOwner是否时活跃状态,如果是,将Livedata中持有的最新更新给观察者。

2,Livedata中的值改变时:
同样是调用dispatchingValue,判断LifecycleOwner是否时活跃状态,如果是,就遍历通知所有观察者。

3,livedata粘性事件:第一次添加观察者会收到数据,原因是,LifecycleOwner向观察者刷新生命周期事件,解决方法:自定义一个类实现livedata,定义一个atomicboolean变量,初始值为false,setvalue设置为true,在这个类发消息给观察者前,将这个变量从ture转成false。

image.jpeg

3. 参考

1,https://blog.csdn.net/xx326664162/article/details/90756817
2,https://developer.android.com/topic/libraries/architecture/livedata?hl=zh-cn

下载说明:
1、本站所有资源均从互联网上收集整理而来,仅供学习交流之用,因此不包含技术服务请大家谅解!
2、本站不提供任何实质性的付费和支付资源,所有需要积分下载的资源均为网站运营赞助费用或者线下劳务费用!
3、本站所有资源仅用于学习及研究使用,您必须在下载后的24小时内删除所下载资源,切勿用于商业用途,否则由此引发的法律纠纷及连带责任本站和发布者概不承担!
4、本站站内提供的所有可下载资源,本站保证未做任何负面改动(不包含修复bug和完善功能等正面优化或二次开发),但本站不保证资源的准确性、安全性和完整性,用户下载后自行斟酌,我们以交流学习为目的,并不是所有的源码都100%无错或无bug!如有链接无法下载、失效或广告,请联系客服处理!
5、本站资源除标明原创外均来自网络整理,版权归原作者或本站特约原创作者所有,如侵犯到您的合法权益,请立即告知本站,本站将及时予与删除并致以最深的歉意!
6、如果您也有好的资源或教程,您可以投稿发布,成功分享后有站币奖励和额外收入!
7、如果您喜欢该资源,请支持官方正版资源,以得到更好的正版服务!
8、请您认真阅读上述内容,注册本站用户或下载本站资源即您同意上述内容!
原文链接:https://www.dandroid.cn/19599,转载请注明出处。
0

评论0

显示验证码
没有账号?注册  忘记密码?