代码示例
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源码还是比较的容易的.