LiveData原理分析

LiveData使用流程

LiveData是一种具有生命周期感知能力的可观察数据持有类。
LiveData可以保证屏幕上的显示内容和数据一直保持同步。

• LiveData了解UI界面的状态，如果activity不在屏幕上显示，LiveData不会触发没必要的界面更新，如果activity已经被销毁，会自动清空与Observer的连接，意外的调用就不会发生。
• LiveData是一个LifecycleOwner，他可以直接感知activity或Fragment的生命周期。

在项目中，LiveData一般是存放在ViewModel中，以保证app配置变更时，数据不会丢失。

使用流程其实很简单，就是自定义实现一个Observer观察者，然后在Activity或者Fragment中获取到ViewModel，通过ViewModel获取到对应的LiveData，然后给LiveData添加观察者监听，用来监听LiveData中的数据变化，在Observer的onChanged中使用监听回调数据。

在使用LiveData的时候需要注意，LiveData有两个设置数据的方法，一个是setValue，一个是postValue，setValue只能是在主线程使用，而postValue只能在子线程中使用。

LiveData核心原理

LiveData.observe

//LiveData.java
//用observer作为key,LifecycleBoundObserver作为Value的map集合
private SafeIterableMap<Observer<? super T>, ObserverWrapper> mObservers =
            new SafeIterableMap<>();
@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
    assertMainThread("observe");//判断主线程
    if (owner.getLifecycle().getCurrentState() == DESTROYED) {
        // ignore
        return;
    }
     // 将LifecycleOwner和Observer实现对象封装成LifecycleBoundObserver
    LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
     // 往LiveData中的mObservers集合添加对应的wrapper对象 这样做的目的，就是为了用来在LiveData更新的时候进行通知观察者
    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对象作为观察者，添加到LifeCycle中。
    owner.getLifecycle().addObserver(wrapper);
}

//LiveData.java-LifecycleBoundObserver
//LifecycleBoundObserver继承ObserverWrapper实现LifecycleEventObserver。LifeCycle最终通知到Observer就是调用LifecycleEventObserver的onStateChanged方法
class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver {
    @NonNull
    final LifecycleOwner mOwner;
	//将LifecycleOwner和observer保存
    LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<? super T> observer) {
        super(observer);
        mOwner = owner;
    }

    @Override
    boolean shouldBeActive() {
        return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
    }

    //lifeCycle感知到activity或fragment生命周期变化后，会回调到这里。
    @Override
    public void onStateChanged(@NonNull LifecycleOwner source,
                               @NonNull Lifecycle.Event event) {
        if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
            removeObserver(mObserver);
            return;
        }
        //这个方法是在ObserverWrapper中实现的
        activeStateChanged(shouldBeActive());
    }

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

    @Override
    void detachObserver() {
        mOwner.getLifecycle().removeObserver(this);
    }
}
//LiveData.java-ObserverWrapper
//这个类是对Observer的封装，持有该对象
private abstract class ObserverWrapper {
    final Observer<? super T> mObserver;
    boolean mActive;//这个状体代表当先观察者是否获取，决定是否回调LiveData的onChange方法。
    int mLastVersion = START_VERSION;

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

    //...
	//在这个方法中，会调用dispatchingValue方法。
    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) {
            //这个方法在setValue流程中也会调用
            dispatchingValue(this);
        }
    }
}

setValue和postValue

//LiveData.java
protected void postValue(T value) {
    boolean postTask;
    synchronized (mDataLock) {
        postTask = mPendingData == NOT_SET;
        mPendingData = value;
    }
    if (!postTask) {
        return;
    }
    //经过handler转发到主线程
    ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
}

private final Runnable mPostValueRunnable = new Runnable() {
    @SuppressWarnings("unchecked")
    @Override
    public void run() {
        Object newValue;
        synchronized (mDataLock) {
            newValue = mPendingData;
            mPendingData = NOT_SET;
        }
        //还是调用setValue
        setValue((T) newValue);
    }
};

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

//dispatchingValue方法在两个地方有调用。
//1、在生命周期发生变化的时候。会回调LifecycleBoundObserver的onStateChanged方法。最后会调到这个方法，传入this(LifecycleBoundObserver)；这个是由观察者自己触发。哪个观察者的生命周期符合条件了就会自己调用。
//2、在setValue的时候调用。传入null;这个是手动调用setValue触发，会遍历所有的保存的观察者，符合生命周期条件的就会触发。
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;
}

//这个方法会根据传入observer的状态，判断是否回调onChanged方法。
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.
    if (!observer.shouldBeActive()) {
        observer.activeStateChanged(false);
        return;
    }
    if (observer.mLastVersion >= mVersion) {
        return;
    }
    observer.mLastVersion = mVersion;
    //在这里回调onChanged方法
    observer.mObserver.onChanged((T) mData);
}