JetPack框架组件2——liveData的使用和源码分析

JetPack框架组件2——liveData的使用和源码分析

一.liveData的使用和概述

1.概述

LiveData 是一种可观察的数据存储器类。
与常规的可观察类不同，LiveData 具有生命周期感知能力，它遵循其他应用组件（如 Activity、Fragment 或 Service）的生命周期。
这种感知能力可确保 LiveData 仅更新处于活跃生命周期状态的应用组件观察者。

具体来说：如果观察者（由 Observer 类表示）的生命周期处于 STARTED 或 RESUMED 状态，则 LiveData 会认为该观察者处于活跃状态。
LiveData 只会将更新通知给活跃的观察者。为观察 LiveData 对象而注册的非活跃观察者不会收到更改通知。这个是具体是由上一节我们讲过的lifecycles

使用 LiveData 的优势如下:

1. LiveData 遵循观察者模式。当底层数据发生变化时，LiveData 会通知 Observer 对象
2. 不会发生内存泄漏,观察者会绑定到 Lifecycle 对象，并在其关联的生命周期遭到销毁后进行自我清理。
3. 不会因 Activity 停止而导致崩溃.如果观察者的生命周期处于非活跃状态（如返回栈中的 Activity），则它不会接收任何 LiveData 事件。
4. 不再需要手动处理生命周期
5. 数据始终保持最新状态
6. 共享资源

2.使用

定义

class NameViewModel :ViewModel() {
    val currentName: MutableLiveData<String> by lazy {
        MutableLiveData<String>()
    }

}

使用

class FirstFragment : Fragment() {

    private val model: NameViewModel by viewModels()

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)

        //定义观察者
        val nameObserver = Observer<String> { newName ->
            textview_first.text = newName
        }
        //注册
        model.currentName.observe(this, nameObserver)
        view.findViewById<Button>(R.id.button_first).setOnClickListener {
            val anotherName = "John Doe"
            //发送事件
            model.currentName.setValue(anotherName)
        }
    }
}

二.liveData的注册

入口代码:

model.currentName.observe(this, nameObserver)

public abstract class LiveData<T> {
    private SafeIterableMap<Observer<? super T>, ObserverWrapper> mObservers =
                new SafeIterableMap<>();

    @MainThread
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        assertMainThread("observe");
        //判断所在的fragment或者activity是不是DESTROYED
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {
            // ignore
            return;
        }
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
        //将<observer,wrapper>存入map中
        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;
        }
        //将LiveData和lifecycle进行绑定，此时LiveData可以关联的其生命周期
        owner.getLifecycle().addObserver(wrapper);
    }
}

这里我们可以看出，最后将Observer放入一个map中，同时将Observer和lifecycle进行绑定

三.liveData的事件分发

入口代码

model.currentName.setValue(anotherName)

public class MutableLiveData<T> extends LiveData<T> {
    @Override
    public void postValue(T value) {
        super.postValue(value);
    }

    @Override
    public void setValue(T value) {
        super.setValue(value);
    }
}

继续进入

public abstract class LiveData<T> {
    @MainThread
    protected void setValue(T value) {
        assertMainThread("setValue");
        mVersion++;
        //保存
        mData = value;
        //进行分发
        dispatchingValue(null);
    }

    void dispatchingValue(@Nullable ObserverWrapper initiator) {
        if (mDispatchingValue) {
            mDispatchInvalidated = true;
            return;
        }
        mDispatchingValue = true;
        do {
            mDispatchInvalidated = false;
            if (initiator != null) {
                considerNotify(initiator);
                initiator = null;
            } else {
                //遍历mObservers
                for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =
                        mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
                    //处理事件分发
                    considerNotify(iterator.next().getValue());
                    if (mDispatchInvalidated) {
                        break;
                    }
                }
            }
        } while (mDispatchInvalidated);
        mDispatchingValue = false;
    }

    private void considerNotify(ObserverWrapper observer) {
        if (!observer.mActive) {
            return;
        }

        //判断lifecycles否是活跃的
        if (!observer.shouldBeActive()) {
            observer.activeStateChanged(false);
            return;
        }

        //判断是否发送过
        if (observer.mLastVersion >= mVersion) {
            return;
        }
        observer.mLastVersion = mVersion;
        //发送事件
        observer.mObserver.onChanged((T) mData);
    }
}

四.liveData的粘性事件实现

粘性事件是指：在注册前发送的事件，注册后会收到。
这个粘性事件的实现是在liveData注册的时候，通过lifecycles实现的
入口代码

owner.getLifecycle().addObserver(wrapper);

这里面的代码。我们在上一篇已经分析过了

class LifecycleRegistry{
    @Override
    public void addObserver(@NonNull LifecycleObserver observer) {
        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
        ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);

        if (previous != null) {
            return;
        }
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        if (lifecycleOwner == null) {
            // it is null we should be destroyed. Fallback quickly
            return;
        }

        boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
        State targetState = calculateTargetState(observer);
        mAddingObserverCounter++;
        while ((statefulObserver.mState.compareTo(targetState) < 0
                && mObserverMap.contains(observer))) {
            pushParentState(statefulObserver.mState);
            //这里处理分发
            statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
            popParentState();
            // mState / subling may have been changed recalculate
            targetState = calculateTargetState(observer);
        }

        if (!isReentrance) {
            // we do sync only on the top level.
            sync();
        }
        mAddingObserverCounter--;
    }
    static class ObserverWithState {
        State mState;
        LifecycleEventObserver mLifecycleObserver;

        ObserverWithState(LifecycleObserver observer, State initialState) {
            mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
            mState = initialState;
        }

        void dispatchEvent(LifecycleOwner owner, Event event) {
            State newState = getStateAfter(event);
            mState = min(mState, newState);
            //这里在次进行分发
            mLifecycleObserver.onStateChanged(owner, event);
            mState = newState;
        }
    }
}

liveData的mLifecycleObserver是LifecycleBoundObserver，是liveData的内部类

public abstract class LiveData<T> {
    class LifecycleBoundObserver extends ObserverWrapper implements GenericLifecycleObserver {
        //....
        @Override
        public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
            if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
                removeObserver(mObserver);
                return;
            }
            activeStateChanged(shouldBeActive());
        }
        //...
    }

    private abstract class ObserverWrapper {
        //....
        void activeStateChanged(boolean newActive) {
            if (newActive == mActive) {
                return;
            }
            // immediately set active state, so we'd never dispatch anything to inactive
            // owner
            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) {
                //和之前不同。这里不是传null。而是传了一个this
                dispatchingValue(this);
            }
        }
    }
    @SuppressWarnings("WeakerAccess") /* synthetic access */
    void dispatchingValue(@Nullable ObserverWrapper initiator) {
        if (mDispatchingValue) {
            mDispatchInvalidated = true;
            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;
    }

    private void considerNotify(ObserverWrapper observer) {
        if (!observer.mActive) {
            return;
        }

        if (!observer.shouldBeActive()) {
            observer.activeStateChanged(false);
            return;
        }
        if (observer.mLastVersion >= mVersion) {
            return;
        }
        observer.mLastVersion = mVersion;
        //传入之前缓存的data数据
        observer.mObserver.onChanged((T) mData);
    }


}

总结:在livedata进行注册，同时也会将observer注册给lifecycles。
在注册给lifecycle时，会检查lifecycle状态，如果有未发送的事件，在再次发送

五.参考资料

官方文档