网站建设与管理这门课程的介绍,做网站的公司北京有哪些,网站建设话术宝典,硬件开发平台有哪些1.在上一篇文章中介绍了LiveData的简单使用#xff0c;可以查看LiveData简单使用_niuyongzhi的博客-CSDN博客
源码分析#xff1a;
也可以分成两部分来看#xff0c;一部分是注册observe源码#xff0c;另一部分是setValue的源码。
先看Observe注册监听的方法。
1…1.在上一篇文章中介绍了LiveData的简单使用可以查看LiveData简单使用_niuyongzhi的博客-CSDN博客
源码分析
也可以分成两部分来看一部分是注册observe源码另一部分是setValue的源码。
先看Observe注册监听的方法。
1先看liveData.observe() MutableLiveDataPerson liveData new MutableLiveData();liveData.observe(this, new ObserverPerson() {Overridepublic void onChanged(Person person) {ageTv.setText(String.valueOf(person.age));nameTv.setText(person.name);}}); private SafeIterableMapObserver? super T, ObserverWrapper mObservers new SafeIterableMap();MainThreadpublic void observe(NonNull LifecycleOwner owner, NonNull ObserverT observer) {if (owner.getLifecycle().getCurrentState() DESTROYED) {return;}//定义了一个Observer的包装类用于数据变化时的回调。LifecycleBoundObserver wrapper new LifecycleBoundObserver(owner, observer);//将wrapper存入一个HashMap中ObserverWrapper existing mObservers.putIfAbsent(observer, wrapper);....//向LifeCycle注册监听这样wrapper就可以感知Activity声明周期变化。owner.getLifecycle().addObserver(wrapper);} 看下这个LifecycleBoundObserver 类。 class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver {NonNullfinal LifecycleOwner mOwner;LifecycleBoundObserver(NonNull LifecycleOwner owner, Observer? super T observer) {super(observer);mOwner owner;}Overrideboolean shouldBeActive() {return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);}//在收到Activity生命周期变化时会回调这个方法。Overridepublic void onStateChanged(NonNull LifecycleOwner source,NonNull Lifecycle.Event event) {//拿到当前的状态Lifecycle.State currentState mOwner.getLifecycle().getCurrentState();if (currentState DESTROYED) {//如果Activity的状态是销毁状态则会从集合中移除注册的observer防止内存泄露removeObserver(mObserver);return;}//状态同步Lifecycle.State prevState null;while (prevState ! currentState) {prevState currentState;activeStateChanged(shouldBeActive());currentState mOwner.getLifecycle().getCurrentState();}}Overrideboolean isAttachedTo(LifecycleOwner owner) {return mOwner owner;}Overridevoid detachObserver() {mOwner.getLifecycle().removeObserver(this);}} 看activeStateChanged()方法 更新状态。 void activeStateChanged(boolean newActive) {if (newActive mActive) {return;}// immediately set active state, so wed never dispatch anything to inactive// ownermActive newActive;changeActiveCounter(mActive ? 1 : -1);if (mActive) {dispatchingValue(this);}} 2在看setValue中做了啥 //看setValue的执行逻辑protected void setValue(T value) {//不是运行在主线程抛异常assertMainThread(setValue);//版本控制每调用一次setValueversion加1mVersion;mData value;//数据分发注意这里传的参数是nulldispatchingValue(null);}
看dispatchingValue方法 private void dispatchingValue(Nullable ObserverWrapper initiator) {if (mDispatchingValue) {mDispatchInvalidated true;return;}mDispatchingValue true;do {mDispatchInvalidated false;if (initiator ! null) {considerNotify(initiator);initiator null;} else {//由于上面传过来的参数是null所以会执行这个循环遍历mObservers//而mObservers就保存了向liveData添加的observerfor (IteratorMap.EntryObserverT, ObserverWrapper iterator mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {considerNotify(iterator.next().getValue());if (mDispatchInvalidated) {break;}}}} while (mDispatchInvalidated);mDispatchingValue false;}
由于上面参数initiator传递过来的是null所以会执行到for循环中的 considerNotify(iterator.next().getValue()); iterator.next().getValue()拿到的就是ObserverWrapper的实例。
再看considerNotify方法 private void considerNotify(ObserverWrapper observer) {//如果观察在没有处于活跃状态则不会受到更新的数据if (!observer.mActive) {return;}//这个判断是LifeCycleOwner的状态是否处于活跃状态if (!observer.shouldBeActive()) {observer.activeStateChanged(false);return;}//如果Observer中的版本已经是最新的则不会更新if (observer.mLastVersion mVersion) {return;}observer.mLastVersion mVersion;//调用observer中的回调方法。//observer就是上面创建的LifecycleBoundObserver的实例//mObserver就是添加的观察者observer.mObserver.onChanged((T) mData);} if (!observer.mActive) { return; }
这行代码就控制了不是活跃状态的观察者不会去更新数据保证处于前台的Activity中的LiveData会刷新UI。
2.LiveData的粘性事件
在第一个Activity中调用 liveData.setValue(main);已经注册的Observer能够收到消息。 当跳转到第二个Activity向第一个Activity中的LiveData添加Observer时也会收到之前发送的消息。 这样的情况就是粘性事件。 正常的流程是 new LiveData----addObserver---setValue--收到消息 粘性事件的流程是 new LiveData---setValue-----addObserver--收到消息。 LiveData的粘性事件并不是他的bug而是出于某种业务需要才这样做到的就是为了确保数据更新后即使打开新的Activity也能够显示最新的数据。如果不期望这种效果由于目前LiveData还没有提供这样的Api所以得需要我们自己来实现。 LiveData出现粘性事件的源码分析。
由于第二个Activity也是实现了LifecycleOwner也会调用ReportFragment的dispatch(Lifecycle.Event event)方法
private void dispatch(Lifecycle.Event event) {if (activity instanceof LifecycleOwner) {Lifecycle lifecycle ((LifecycleOwner) activity).getLifecycle();if (lifecycle instanceof LifecycleRegistry) {((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);}}
}
看过LifeCycle源码分析的对后面的执行流程应该很熟悉。 static class ObserverWithState {State mState;GenericLifecycleObserver mLifecycleObserver;ObserverWithState(LifecycleObserver observer, State initialState) {mLifecycleObserver Lifecycling.getCallback(observer);mState initialState;}void dispatchEvent(LifecycleOwner owner, Event event) {State newState getStateAfter(event);mState min(mState, newState);mLifecycleObserver.onStateChanged(owner, event);mState newState;}}
直接看到这里mLifecycleObserver是谁的实例看Lifecycling.getCallback(observer); 在LifeCycle的回调中返回的是ReflectiveGenericLifecycleObserver的实例。 但是在LiveData中mLifecycleObserver是LifecycleBoundObserver的实例实现了GenericLifecycleObserver接口。 在调用LiveData.Observer()创建了LifecycleBoundObserver的实例。 static GenericLifecycleObserver getCallback(Object object) {if (object instanceof FullLifecycleObserver) {return new FullLifecycleObserverAdapter((FullLifecycleObserver) object);}//LiveData中传进来的是LifecycleBoundObserver//所以在这里就return了if (object instanceof GenericLifecycleObserver) {return (GenericLifecycleObserver) object;}.......return new ReflectiveGenericLifecycleObserver(object);}
看LiveData.Observer()源码创建了LifecycleBoundObserver对象并作为观察者添加到了LifeCycle中
public void observe(NonNull LifecycleOwner owner, NonNull ObserverT observer) {LifecycleBoundObserver wrapper new LifecycleBoundObserver(owner, observer);ObserverWrapper existing mObservers.putIfAbsent(observer, wrapper);owner.getLifecycle().addObserver(wrapper);
}
在addObserver中用ObserverWithState对LifecycleBoundObserver进行了一层封装。 public void addObserver(NonNull LifecycleObserver observer) {State initialState mState DESTROYED ? DESTROYED : INITIALIZED;ObserverWithState statefulObserver new ObserverWithState(observer, initialState);ObserverWithState previous mObserverMap.putIfAbsent(observer, statefulObserver);
}
综上代码可以知道 mLifecycleObserver.onStateChanged(owner, event); 调用的是LifecycleBoundObserver的onStateChanged方法。
public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {//如果当前Activity是Destroy的则回收Observer防止发送内存泄露if (mOwner.getLifecycle().getCurrentState() DESTROYED) {removeObserver(mObserver);return;}activeStateChanged(shouldBeActive());} //删除的LiveData中该Activity(LifecycleOwner)添加的observer//在LiveData.Observer时会传入LifecycleOwnerpublic void removeObserver(NonNull final ObserverT observer) {assertMainThread(removeObserver);ObserverWrapper removed mObservers.remove(observer);if (removed null) {return;}removed.detachObserver();removed.activeStateChanged(false);}
activeStateChanged(shouldBeActive());
//shouldBeActive判断是Activity是否是线上状态。boolean shouldBeActive() {return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
}
//在第二个Activity启动后这个newActive传过来的是true
void activeStateChanged(boolean newActive) {//mActive默认是falsenewActive是trueif (newActive mActive) {return;}mActive newActive;boolean wasInactive LiveData.this.mActiveCount 0;//记录avtiveCount如果活跃加1否则减1LiveData.this.mActiveCount mActive ? 1 : -1;if (wasInactive mActive) {onActive();}if (LiveData.this.mActiveCount 0 !mActive) {onInactive();}if (mActive) {dispatchingValue(this);}
}
//dispatchingValue把this传进来了所以下面代码会执行if判断的第一个分支private void dispatchingValue(Nullable ObserverWrapper initiator) {if (mDispatchingValue) {mDispatchInvalidated true;return;}mDispatchingValue true;do {mDispatchInvalidated false;//initiator不是null执行这里if (initiator ! null) {considerNotify(initiator);initiator null;} else {for (IteratorMap.EntryObserverT, ObserverWrapper iterator mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {considerNotify(iterator.next().getValue());if (mDispatchInvalidated) {break;}}}} while (mDispatchInvalidated);mDispatchingValue false;} private void considerNotify(ObserverWrapper observer) {//observer.mActive 为trueif (!observer.mActive) {return;}//observer.shouldBeActive()为trueif (!observer.shouldBeActive()) {observer.activeStateChanged(false);return;}//mVersion是LiveData的变量会大于0//observer.mLastVersion初始值是0//所以这个分支判断也不会进来if (observer.mLastVersion mVersion) {return;}//版本同步observer.mLastVersion mVersion;//这行代码就会调用observer的onChange方法observer.mObserver.onChanged((T) mData);}
所以在第二个Activity中添加的observer就收到了第一个Activity发送的消息。 这就是LiveData粘性事件的源码执行原理。 如果想要消除这种粘性事件通过上面的代码分析我们可以修改添加的Observer的mLastVersion值 使它在初始化时就和LiveData中的mVersion一致就不会出现粘性事件。
3. liveData.observeForever(observer) liveData.observeForever 是一个和Activity声明周期无关的消息订阅与发送的方法
public void observeForever(NonNull ObserverT observer) {AlwaysActiveObserver wrapper new AlwaysActiveObserver(observer);ObserverWrapper existing mObservers.putIfAbsent(observer, wrapper);if (existing ! null) {return;}//这个参数是truewrapper.activeStateChanged(true);
}
