亲宝软件园·资讯

展开

Android LiveData

猪飞啦~ 人气:2

LiveData简介

在日常安卓开发中,一些耗时的操比如列网络请求,数据库读写都不能在主线程执行,必须开一条子线程去执行这些耗时操作,但我们往往需要在这些耗时操作执行完毕后更新UI,但安卓不能在子线程进行UI的更新,这时我们只能通过创建一个Handler来切回到主线程进行UI的更新,直到LiveData出现,LiveData是一个可被观察的数据容器,它将数据包装起来,使数据成为被观察者。当数据发生改变时,观察者能够及时得到通知。

LiveData用法

LiveData是一个数据容器,订阅视图的生命周期,在子线程通过postValue()切换到主线程来传递数据给观察者,当视图是活动的状态下观察者即可接受到数据,LiveData是一个典型的观察者模式。

class MainActivity : AppCompatActivity() {
    private val mLiveData = MutableLiveData<String>()
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val binding = ActivityMainBinding.inflate(LayoutInflater.from(baseContext))
        setContentView(binding.root)
        mLiveData.observe(this, {
            binding.tvContent.text = it
        })
        Thread(BackgroundThread(mLiveData)).start()
    }
    private class BackgroundThread(liveData: MutableLiveData<String>) : Runnable {
        private val mLive = WeakReference(liveData)
        override fun run() {
            mLive.apply {
                get()?.apply {
                    postValue("hello LiveData")
                }
            }
        }
    }
}

数据订阅过程

@MainThread
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        //1,判断是否在主线程
        assertMainThread("observe");
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {
            // ignore
            return;
        }
        //2,通过owner,observer来构建一个LifecycleBoundObserver
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
        //3,把observer存放到mObservers中
        ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
        //4,如果existing不为空代表观察者已经存在并且已经绑定了生命周期,抛一个Exception来提示                 
        if (existing != null && !existing.isAttachedTo(owner)) {
            throw new IllegalArgumentException("Cannot add the same observer"
                    + " with different lifecycles");
        }
        if (existing != null) {
            return;
        }
        //5,调用Lifecycle的addObserver()方法来订阅生命周期
        owner.getLifecycle().addObserver(wrapper);
    }

1,先判断当前订阅数据这个操作是否是在主线程中执行,否则的话抛一个Exception

2,把owner,observer传入到LifecycleBoundObserver构建出一个LifecycleBoundObserver对象

3,调用mObservers.putIfAbsent()方法把观察者放到观察者集合中,mObservers是SafeIterableMap类型的集合类似Map,但它是通过链表的方式来实现Map接口,SafeIterableMap.putIfAbsent()方法与Map.put()方法不一样,如果根据key获取的value不为null,就将当前的value返回,如果为null,就将当前的键值对存储起来,然后返回一个null

4,existing不为null,代表Observer存在,就抛一个Exception来提示开发者:无法添加具有不同生命周期的同一观察者

5,existing为null,代表observer不存在,添加观察者来观察生命周期拥有者的生命周期,

当我们的视图的生命周期发生改变,LifecycleBoundObserver的onStateChange()方法就会被调用

PostValue过程

protected void postValue(T value) {
        boolean postTask;
        //判断当前是否正在下发数据
        synchronized (mDataLock) {
            postTask = mPendingData == NOT_SET;
            mPendingData = value;
        }
        //如果正在下发数据则继续下发数据
        if (!postTask) {
            return;
        }
        //构建Handler并关联主线程的Looper,回到主线程执行run方法中的逻辑
        ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
    }
private final Runnable mPostValueRunnable = new Runnable() {
        @Override
        public void run() {
            Object newValue;
            synchronized (mDataLock) {
                newValue = mPendingData;
                mPendingData = NOT_SET;
            }
            //在主线程中调用setValue来执行数据下发逻辑
            //noinspection unchecked
            setValue((T) newValue);
        }
    };

当调用postValue()方法是通过构建一个Handler并关联主线程的Looper来post一个Runnable来回到主线程执行run方法里面的逻辑,而mPostValueRunnable的run()方法则调用了setValue()方法来实现数据的发送

SetValue过程

@MainThread
    protected void setValue(T value) {
        assertMainThread("setValue");
        mVersion++;
        mData = value;
        dispatchingValue(null);
    }
void dispatchingValue(@Nullable ObserverWrapper initiator) {
        //1,判断当前是正在下发数据
        if (mDispatchingValue) {
            mDispatchInvalidated = true;
            return;
        }
        mDispatchingValue = true;
        do {
            mDispatchInvalidated = false;
            //2,如果initiator不为空直接给initiator发送数据更新通知
            if (initiator != null) {
                considerNotify(initiator);
                initiator = null;
            } else {
                /,3,否则遍历所有observer
                for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
                    /4,发送数据更新通知
                    considerNotify(iterator.next().getValue());
                    if (mDispatchInvalidated) {
                        break;
                    }
                }
            }
        } while (mDispatchInvalidated);
        mDispatchingValue = false;
    }
private void considerNotify(ObserverWrapper observer) {
        5,如果当前observer不是活动状态,不下发数据
        if (!observer.mActive) {
            return;
        }
        6,如果当前observer的状态至少不是started状态(可见状态),resumed比started高一个级别(可触摸状态)则不下发数据
        if (!observer.shouldBeActive()) {
            observer.activeStateChanged(false);
            return;
        }
        7,判断数据版本号 如果当前observer的数据是最新的 则不下发数据
        if (observer.mLastVersion >= mVersion) {
            return;
        }
        8,记录最新数据版本号
        observer.mLastVersion = mVersion;
        
        9,通知数据更新
        observer.mObserver.onChanged((T) mData);
    }
     @Override
        boolean shouldBeActive() {
            判断当前状态是否>=STARTED
            return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
        }

1,检查当前是否在主线程

2, 每次调用setValue()方法版本号(mVersion)都进行累加

3,把需要新数据赋值给mData

4,调用dispatchingValue来执行数据下发

5,如果initiator不为null则直接给这个观察者下发数据更新通知

6,否则遍历所有的观察者,逐个下发数据更新通知

7,判断当前的observer是否为活动状态,不是活动状态不下发数据,这也就是为什么我们界面不可见时数据不会更新的原因(onStop状态)

8,判断当前的observer是否是resumed状态,不是resumed状态不下发数据,这就是为什么当我们的页面可见但不可触摸时数据不更新的原因(onPause状态)

9,比对数据版本号,如果当前observer的数据是最新数据则不需要下发

10,记录数据版本号并通知observer数据更新,回调observer的onChanged()方法

生命周期变化

@Override
        public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
            1,如果当前的状态为destroyed就移除observer
            if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
                removeObserver(mObserver);
                return;
            }
            2,更新状态并下发数据
            activeStateChanged(shouldBeActive());
        }
void activeStateChanged(boolean newActive) {
            3,如果新状态和当前状态一致的话不需要更新
            if (newActive == mActive) {
                return;
            }
            4,记录新状态
            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();
            }
            5,如果是活动状态 下发数据
            if (mActive) {
                dispatchingValue(this);
            }
        }

在订阅数据那一刻(即调用LiveData.observer())就构建了一个LifecycleBoundObserver并且让LifecycleBoundObserver订阅了页面生命周期,所以当页面的生命周期发生改变,LifecycleBoundObserver的onStateChanged()方法都会被调用

1,如果当前页面的状态为destroyed(即销毁状态),则移除观察者

2,更新状态并下发数据

3,判断当前observer的状态跟新状态是否一致,如果时是则不需要更新状态以及数据

4,记录当前observer的状态

5,调用dispatchingValue()并传入当前observer,执行准确下发数据业务

加载全部内容

相关教程
猜你喜欢
用户评论