(二) Jetpack LiveData 源码分析

参考

代码示例

class MyViewModel : ViewModel() {
    val myLiveData: MutableLiveData<Int> by lazy {
        MutableLiveData<Int>().apply {
            // liveData 中初始赋值为0
            value = 0
        }
    }
}
// 使用viewModels需要依赖 implementation "androidx.activity:activity-ktx:1.1.0"
class MyActivity : AppCompatActivity() {
    private val myViewModel: MyViewModel by viewModels {
        MyViewModelFactory()
    }
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.my_activity)
        // 设置LiveData的观察者
        myViewModel.myLiveData.observe(this, Observer<Int> {
            text_number.text = "$it"
        })
        // 更新LiveData的值
        myViewModel.liveData.value = 10
        // 主线程用
        // protected void setValue (T value)
        // 子线程用
        // protected void postValue (T value)
    }
}

将创建得观察者添加到LifecycleRegistry中

创建观察者并添加

myViewModel.liveData.observe(this, Observer<Int> {
    text_number.text = "$it"
})

点进去看observe()方法

public abstract class LiveData<T> {
    @MainThread
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        // 必须主线程才能添加观察者
        assertMainThread("observe");
        // `ComponentActivity`的`LifecycleRegistry`对象处于`DESTROYED`状态,也就是当前处于`DESTROYED`生命周期,
        // 就不要再往`LifecycleRegistry`中添加观察者了.
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {
            return;
        }
        // LifecycleBoundObserver中持有`LifecycleOwner`和观察者对象.
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
        // 每个LiveData都有一个mObservers变量,它是一个Map集合,用来存放观察者与LifecycleBoundObserver对象的
        ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
        // 向mObservers集合中添加观察者与LifecycleBoundObserver对象时,如果集合中已经添加过该观察者,就退出.
        if (existing != null) {
            return;
        }
        // owner.getLifecycle():这个owner其实就是Activity对象经过强转得到的,androidx.activity.ComponentActivity实现LifecycleOwner接口.
        // getLifecycle()方法最终得到的是ComponentActivity类中的LifecycleRegistry对象.
        // 这里就将LifecycleBoundObserver对象添加到`LifecycleRegistry`对象中.
        owner.getLifecycle().addObserver(wrapper);
    }
}

LifecycleBoundObserver对象被添加到LifecycleRegistry后发生了些什么?

public class LifecycleRegistry extends Lifecycle {
    // 这里只做简单的分析,LifecycleRegistry详细分析可以看上一篇文章.
    @Override
    public void addObserver(@NonNull LifecycleObserver observer) {
        ...
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
        ...
        // TODO 1 接着往下
        statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
        ...
    }
    static class ObserverWithState {
        void dispatchEvent(LifecycleOwner owner, Event event) {
            ...
            // TODO 2 
            // 到此处很清晰的说明了,LiveData也是一个观察者,他观察的是Activity的生命周期,当LiveData被添加到LifecycleRegistry中时,
            // LifecycleRegistry会同步ObserverWithState的状态mState,会改变LifecycleBoundObserver的状态.
            mLifecycleObserver.onStateChanged(owner, event);
            mState = newState;
        }
    }
}

接着向下看onStateChanged()后会发生什么.

public abstract class LiveData<T> {
    // 有多少观察者处于活动状态
    int mActiveCount = 0;
    class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver {
        @Override
        public void onStateChanged(@NonNull LifecycleOwner source,@NonNull Lifecycle.Event event) {
            if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
                removeObserver(mObserver);
                return;
            }
            // TODO 3 向下看
            activeStateChanged(shouldBeActive());
        }
        // TODO 4
        @Override
        boolean shouldBeActive() {
            // mOwner.getLifecycle().getCurrentState(): 获取LifecycleRegistry当前的状态,然后与STARTED状态比较
            // 如果时大于或者等于STARTED状态,就返回true.
            return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
        }
    }
    private abstract class ObserverWrapper {
        boolean mActive; // 记录当前LiveData的状态
        // TODO 5
        void activeStateChanged(boolean newActive) {
            // 如果当前LiveData状态与TODO 4 shouldBeActive()得到的相同,就不需要向下走了.
            if (newActive == mActive) {
                return;
            }
            // 这里是更新状态
            mActive = newActive;
            // wasInactive 代表是否有观察者处于活跃状态
            boolean wasInactive = LiveData.this.mActiveCount == 0;
            // mActiveCount 代表有几个观察者处于活跃状态
            LiveData.this.mActiveCount += mActive ? 1 : -1;
            if (wasInactive && mActive) {
                // 当观察者从0到1时候,会回调这个方法,也就是我可以对该方法重写做一些自己的操作.
                onActive();
            }
            if (LiveData.this.mActiveCount == 0 && !mActive) {
                // 当观察者从1到0时会回调这个方法
                onInactive();
            }
            // 这个是当观察者处于活跃状态会调用的方法,分析到这里先停下,下面会详细说该方法.
            if (mActive) {
                dispatchingValue(this);
            }
        } 
    }
}

改变LiveData中的值,然后通知观察者

public class MutableLiveData<T> extends LiveData<T> {
    @Override
    public void setValue(T value) {
        // 这里调用的是父类的setValue(value)方法.
        super.setValue(value);
    }
}

看下父类中的setValue(value)方法

public abstract class LiveData<T> {
    private SafeIterableMap<Observer<? super T>, ObserverWrapper> mObservers = new SafeIterableMap<>();
    // TODO 1
    @MainThread 
    protected void setValue(T value) {
        // 这个注解是主线程调用
        assertMainThread("setValue");
        // 这个是用来记录当前LiveData的版本,每此LiveData值改变了,这个版本号就会+1,
        // 然后当通知观察者的时候,需要判断最后一个版本与现在版本号大小,下面有分析.
        mVersion++;
        // 记录传入的值
        mData = value;
        // 开始向观察者分发更新的数据
        dispatchingValue(null);
    }
    // TODO 2
    void dispatchingValue(@Nullable ObserverWrapper initiator) {
        if (mDispatchingValue) {
            mDispatchInvalidated = true;
            return;
        }
        // 分发中
        mDispatchingValue = true;
        // 先执行do语句,while中条件为真才继续执行
        do {
            mDispatchInvalidated = false;
            if (initiator != null) {
                // 更具上一步中,initiator = null,所以不走这里.
                considerNotify(initiator);
                initiator = null;
            } else {
                // 遍历当前LiveData中的mObservers对象
                for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator = mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
                    // iterator.next().getValue()获取ObserverWrapper的子类LifecycleBoundObserver对象.
                    considerNotify(iterator.next().getValue());
                    if (mDispatchInvalidated) {
                        break;
                    }
                }
            }
        } while (mDispatchInvalidated);
        // 分发完成
        mDispatchingValue = false;
    }
    // TODO 3
    private void considerNotify(ObserverWrapper observer) {
        // mActive这个LifecycleBoundObserver中的变量, 表示当前观察者是否处于活动状态.
        if (!observer.mActive) {
            // 如果处于非活动状态,就不对这次LiveData值更改的事件进行分发.
            return;
        }
        if (!observer.shouldBeActive()) {
            // 再次的对观察者的当前活动状态进行检测,如果是Activity当前处于STARTED之前的状态,
            // 那么同步观察者处于非活动状态.
            observer.activeStateChanged(false);
            return;
        }
        // 如果当前观察者的版本号比前一次版本号还小,就别通知了,
        // 这个mVersion值得增加是在setValue()方法中做的.
        if (observer.mLastVersion >= mVersion) {
            return;
        }
        // 更新LiveData最后一次更新得版本号
        observer.mLastVersion = mVersion;
        // 最后的最后终于调用了观察者的onChanged()方法了.
        // observer类型是LifecycleBoundObserver,它的mObserver就是示例代码里Activity中创建的Observer对象了.
        observer.mObserver.onChanged((T) mData);
    }
}

至此,LiveData源码也分析完了,LifeCycle源码理解好了后来看LiveData源码还是比较的容易的.