2020-11-22 20:23:56.753 14432-14432/com.hfy.androidlearning I/Lifecycle_Test: onPause:
2020-11-22 21:23:56.753 14432-14432/com.hfy.androidlearning I/Lifecycle_Test: onChanged: onPause
2020-11-22 20:23:58.320 14432-14432/com.hfy.androidlearning I/Lifecycle_Test: onStop:
2020-11-22 20:23:58.322 14432-14432/com.hfy.androidlearning I/Lifecycle_Test: onDestroy:
复制代码
-
首先打开页面,onCreate()中setValue,由于activity是非活跃状态,不会立即回调onChanged。当走到onStart()变为活跃时,onChanged被调用,但value被onStart()中setValue的value覆盖,所以打印的是onChanged: onStart。(为啥不是连续打印两次呢?,是因为ON_START事件是在onStart() return之后,即onStart()走完之后才变为活跃<详见上一篇>,此时observer接收最新的数据。) 接着走到onResume(),也setValue了,同样是活跃状态,所以立刻回调onChanged,打印onChanged: onResume
-
按Home键时,onPause()中setValue,活跃状态,立刻回调onChanged方法。onStop()执行时已经变为非活跃状态,此时setValue不会立即回调onChanged方法。
-
再点开时,走到onStart()变为活跃时,onChanged被调用,但value被onStart()中setValue的value覆盖,所以打印的是onChanged: onStart。接着走到onResume(),也setValue了,同样是活跃状态,所以立刻回调onChanged。
-
返回键退出时,onPause()/onStop()的效果和按Home键一样。onDestroy()中setValue,此时非活跃状态,且此时observer已被移除,不会回调onChanged。
另外,除了使用observe()方法添加观察者,也可以使用observeForever(Observer) 方法来注册未关联 LifecycleOwner的观察者。在这种情况下,观察者会被视为始终处于活跃状态。
扩展包括两点:
-
自定义LiveData,本身回调方法的覆写:onActive()、onInactive()。
-
实现LiveData为单例模式,便于在多个Activity、Fragment之间共享数据。
官方的例子如下:
public class StockLiveData extends LiveData {
private static StockLiveData sInstance; //单实例
private StockManager stockManager;
private SimplePriceListener listener = new SimplePriceListener() {
@Override
public void onPriceChanged(BigDecimal price) {
setValue(price);//监听到股价变化 使用setValue(price) 告知所有活跃观察者
}
};
//获取单例
@MainThread
public static StockLiveData get(String symbol) {
if (sInstance == null) {
sInstance = new StockLiveData(symbol);
}
return sInstance;
}
private StockLiveData(String symbol) {
stockManager = new StockManager(symbol);
}
//活跃的观察者(LifecycleOwner)数量从 0 变为 1 时调用
@Override
protected void onActive() {
stockManager.requestPriceUpdates(listener);//开始观察股价更新
}
//活跃的观察者(LifecycleOwner)数量从 1 变为 0 时调用。这不代表没有观察者了,可能是全都不活跃了。可以使用hasObservers()检查是否有观察者。
@Override
protected void onInactive() {
stockManager.removeUpdates(listener);//移除股价更新的观察
}
}
复制代码
为了观察股票价格变动,继承LiveData自定义了StockLiveData,且为单例模式,只能通过get(String symbol)方法获取实例。 并且重写了onActive()、onInactive(),并加入了 开始观察股价更新、移除股价更新观察 的逻辑。
-
onActive()调用时机为:活跃的观察者(LifecycleOwner)数量从 0 变为 1 时。
-
onInactive()调用时机为:活跃的观察者(LifecycleOwner)数量从 1 变为 0 时。
也就是说,只有当 存在活跃的观察者(LifecycleOwner)时 才会连接到 股价更新服务 监听股价变化。使用如下:
public class MyFragment extends Fragment {
@Override
public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
super.onViewCreated(view, savedInstanceState);
//获取StockLiveData单实例,添加观察者,更新UI
StockLiveData.get(symbol).observe(getViewLifecycleOwner(), price -> {
// Update the UI.
});
}
}
复制代码
由于StockLiveData是单实例模式,那么多个LifycycleOwner(Activity、Fragment)间就可以共享数据了。
如果希望在将 LiveData 对象分派给观察者之前对存储在其中的值进行更改,或者需要根据另一个实例的值返回不同的 LiveData 实例,可以使用LiveData中提供的Transformations类。
2.3.1 数据修改 - Transformations.map
//Integer类型的liveData1
MutableLiveData liveData1 = new MutableLiveData<>();
//转换成String类型的liveDataMap
LiveData liveDataMap = Transformations.map(liveData1, new Function<Integer, String>() {
@Override
public String apply(Integer input) {
String s = input + " + Transformations.map";
Log.i(TAG, "apply: " + s);
return s;
}
});
liveDataMap.observe(this, new Observer() {
@Override
public void onChanged(String s) {
Log.i(TAG, "onChanged1: "+s);
}
});
liveData1.setValue(100);
复制代码
使用很简单:原本的liveData1 没有添加观察者,而是使用Transformations.map()方法 对liveData1的数据进行的修改 生成了新的liveDataMap,liveDataMap添加观察者,最后liveData1设置数据 。
此例子把 Integer类型的liveData1 修改为String类型的liveDataMap。结果如下:
2020-12-06 17:01:56.095 21998-21998/com.hfy.androidlearning I/Lifecycle_Test: apply: 100 + Transformations.map
2020-12-06 17:01:56.095 21998-21998/com.hfy.androidlearning I/Lifecycle_Test: onChanged1: 100 + Transformations.map
复制代码
2.3.2 数据切换 - Transformations.switchMap
如果想要根据某个值 切换观察不同LiveData数据,则可以使用Transformations.switchMap()方法。
//两个liveData,由liveDataSwitch决定 返回哪个livaData数据
MutableLiveData liveData3 = new MutableLiveData<>();
MutableLiveData liveData4 = new MutableLiveData<>();
//切换条件LiveData,liveDataSwitch的value 是切换条件
MutableLiveData liveDataSwitch = new MutableLiveData<>();
//liveDataSwitchMap由switchMap()方法生成,用于添加观察者
LiveData liveDataSwitchMap = Transformations.switchMap(liveDataSwitch, new Function<Boolean, LiveData>() {
@Override
public LiveData apply(Boolean input) {
//这里是具体切换逻辑:根据liveDataSwitch的value返回哪个liveData
if (input) {
return liveData3;
}
return liveData4;
}
});
liveDataSwitchMap.observe(this, new Observer() {
@Override
public void onChanged(String s) {
Log.i(TAG, "onChanged2: " + s);
}
});
boolean switchValue = true;
liveDataSwitch.setValue(switchValue);//设置切换条件值
liveData3.setValue(“liveData3”);
liveData4.setValue(“liveData4”);
复制代码
liveData3、liveData4是两个数据源,有一个判断条件来决定 取哪一个数据 ,这个条件就是liveDataSwitch,如果值为true则取liveData3,false则取liveData4。 Transformations.switchMap()就用于实现这一逻辑,返回值liveDataSwitchMap添加观察者就可以了。 结果如下:
2020-12-06 17:33:53.844 27347-27347/com.hfy.androidlearning I/Lifecycle_Test: switchValue=true
2020-12-06 17:33:53.847 27347-27347/com.hfy.androidlearning I/Lifecycle_Test: onChanged2: liveData3
2020-12-06 17:34:37.600 27628-27628/com.hfy.androidlearning I/Lifecycle_Test: switchValue=false
2020-12-06 17:34:37.602 27628-27628/com.hfy.androidlearning I/Lifecycle_Test: onChanged2: liveData4
复制代码
(Transformations对LivaData这两个用法和Rxjava简直一毛一样)
2.3.3 观察多个数据 - MediatorLiveData
MediatorLiveData 是 LiveData 的子类,允许合并多个 LiveData 源。只要任何原始的 LiveData 源对象发生更改,就会触发 MediatorLiveData 对象的观察者。
MediatorLiveData mediatorLiveData = new MediatorLiveData<>();
MutableLiveData liveData5 = new MutableLiveData<>();
MutableLiveData liveData6 = new MutableLiveData<>();
//添加 源 LiveData
mediatorLiveData.addSource(liveData5, new Observer() {
@Override
public void onChanged(String s) {
Log.i(TAG, "onChanged3: " + s);
mediatorLiveData.setValue(s);
}
});
//添加 源 LiveData
mediatorLiveData.addSource(liveData6, new Observer() {
@Override
public void onChanged(String s) {
Log.i(TAG, "onChanged4: " + s);
mediatorLiveData.setValue(s);
}
});
//添加观察
mediatorLiveData.observe(this, new Observer() {
@Override
public void onChanged(String s) {
Log.i(TAG, "onChanged5: "+s);
//无论liveData5、liveData6更新,都可以接收到
}
});
liveData5.setValue(“liveData5”);
//liveData6.setValue(“liveData6”);
复制代码
例如,如果界面中有可以从本地数据库或网络更新的 LiveData 对象,则可以向 MediatorLiveData 对象添加以下源:
-
与存储在本地数据库中的数据关联的 liveData5
-
与从网络访问的数据关联的 liveData6
Activity 只需观察 MediatorLiveData 对象即可从这两个源接收更新。 结果如下:
2020-12-06 17:56:17.870 29226-29226/com.hfy.androidlearning I/Lifecycle_Test: onChanged3: liveData5
2020-12-06 17:56:17.870 29226-29226/com.hfy.androidlearning I/Lifecycle_Test: onChanged5: liveData5
复制代码
(Transformations也是对MediatorLiveData的使用。)
LiveData的使用就讲完了,下面开始源码分析。
=================================================================
前面提到 LiveData几个特点,能感知生命周期状态变化、不用手动解除观察等等,这些是如何做到的呢?
LiveData原理是观察者模式,下面就先从LiveData.observe()方法看起:
/**
-
添加观察者. 事件在主线程分发. 如果LiveData已经有数据,将直接分发给observer。
-
观察者只在LifecycleOwner活跃时接受事件,如果变为DESTROYED状态,observer自动移除。
-
当数据在非活跃时更新,observer不会接收到。变为活跃时 将自动接收前面最新的数据。
-
LifecycleOwner非DESTROYED状态时,LiveData持有observer和 owner的强引用,DESTROYED状态时自动移除引用。
-
@param owner 控制observer的LifecycleOwner
-
@param observer 接收事件的observer
*/
@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
assertMainThread(“observe”);
if (owner.getLifecycle().getCurrentState() == DESTROYED) {
// LifecycleOwner是DESTROYED状态,直接忽略
return;
}
//使用LifecycleOwner、observer 组装成LifecycleBoundObserver,添加到mObservers中
LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
ObserverWrapper existing = mObservers中.putIfAbsent(observer, wrapper);
if (existing != null && !existing.isAttachedTo(owner)) {
//!existing.isAttachedTo(owner)说明已经添加到mObservers中的observer指定的owner不是传进来的owner,就会报错“不能添加同一个observer却不同LifecycleOwner”
throw new IllegalArgumentException(“Cannot add the same observer”
- " with different lifecycles");
}
if (existing != null) {
return;//这里说明已经添加到mObservers中,且owner就是传进来的owner
}
owner.getLifecycle().addObserver(wrapper);
}
复制代码
首先是判断LifecycleOwner是DESTROYED状态,就直接忽略,不能添加。接着使用LifecycleOwner、observer 组装成LifecycleBoundObserver包装实例wrapper,使用putIfAbsent方法observer-wrapper作为key-value添加到观察者列表mObservers中。(putIfAbsent意思是只有列表中没有这个observer时才会添加。)
然后对添加的结果进行判断,如果mObservers中已经存在此observer key,但value中的owner不是传进来的owner,就会报错“不能添加同一个observer却是不同LifecycleOwner”。如果是相同的owner,就直接returne。
最后用LifecycleOwner的Lifecycle添加observer的封装wrapper。
另外,再看observeForever方法:
@MainThread
public void observeForever(@NonNull Observer<? super T> observer) {
assertMainThread(“observeForever”);
AlwaysActiveObserver wrapper = new AlwaysActiveObserver(observer);
ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
if (existing instanceof LiveData.LifecycleBoundObserver) {
throw new IllegalArgumentException(“Cannot add the same observer”
- " with different lifecycles");
}
if (existing != null) {
return;
}
wrapper.activeStateChanged(true);
}
复制代码
和observe()类似,只不过 会认为观察者一直是活跃状态,且不会自动移除观察者。
LiveData添加了观察者LifecycleBoundObserver,接着看如何进行回调的:
class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver {
@NonNull
final LifecycleOwner mOwner;
LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<? super T> observer) {
super(observer);
mOwner = owner;
}
@Override
boolean shouldBeActive() { //至少是STARTED状态
return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
}
@Override
public void onStateChanged(@NonNull LifecycleOwner source,
@NonNull Lifecycle.Event event) {
if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
removeObserver(mObserver);//LifecycleOwner变成DESTROYED状态,则移除观察者
return;
}
activeStateChanged(shouldBeActive());
}
@Override
boolean isAttachedTo(LifecycleOwner owner) {
return mOwner == owner;
}
@Override
void detachObserver() {
mOwner.getLifecycle().removeObserver(this);
}
}
复制代码
LifecycleBoundObserver是LiveData的内部类,是对原始Observer的包装,把LifecycleOwner和Observer绑定在一起。当LifecycleOwner处于活跃状态,就称 LifecycleBoundObserver是活跃的观察者。
它实现自接口LifecycleEventObserver,实现了onStateChanged方法。上一篇Lifecycle中提到onStateChanged是生命周期状态变化的回调。
在LifecycleOwner生命周期状态变化时 判断如果是DESTROYED状态,则移除观察者。LiveData自动移除观察者特点就来源于此。 如果不是DESTROYED状态,将调用父类ObserverWrapper的activeStateChanged()方法处理 这个生命周期状态变化,shouldBeActive()的值作为参数,至少是STARTED状态为true,即活跃状态为true。
private abstract class ObserverWrapper {
…
void activeStateChanged(boolean newActive) {
if (newActive == mActive) {
return;//活跃状态 未发生变化时,不会处理。
}
mActive = newActive;
boolean wasInactive = LiveData.this.mActiveCount == 0;//没有活跃的观察者
LiveData.this.mActiveCount += mActive ? 1 : -1;//mActive为true表示变为活跃
if (wasInactive && mActive) {
onActive();//活跃的观察者数量 由0变为1
}
if (LiveData.this.mActiveCount == 0 && !mActive) {
onInactive(); //活跃的观察者数量 由1变为0
}
if (mActive) {
dispatchingValue(this);//观察者变为活跃,就进行数据分发
}
}
}
复制代码
ObserverWrapper也是LiveData的内部类。mActive是ObserverWrapper的属性,表示此观察者是否活跃。如果活跃状态 未发生变化时,不会处理。
LiveData.this.mActiveCount == 0 是指 LiveData 的活跃观察者数量。活跃的观察者数量 由0变为1、由1变为0 会分别调用LiveData的 onActive()、onInactive()方法。这就是前面提到的扩展使用
的回调方法。
最后观察者变为活跃,就使用LiveData的dispatchingValue(observerWrapper)进行数据分发:
void dispatchingValue(@Nullable ObserverWrapper initiator) {
if (mDispatchingValue) {
mDispatchInvalidated = true;//如果当前正在分发,则分发无效,return
return;
}
mDispatchingValue = true; //标记正在分发
do {
mDispatchInvalidated = false;
if (initiator != null) {
considerNotify(initiator); //observerWrapper不为空,使用considerNotify()通知真正的观察者
initiator = null;
} else { //observerWrapper为空,遍历通知所有的观察者
for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =
mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
considerNotify(iterator.next().getValue());
if (mDispatchInvalidated) {
break;
}
}
}
} while (mDispatchInvalidated);
mDispatchingValue = false;
}
复制代码
如果当前正在分发,则分发无效;observerWrapper不为空,就使用considerNotify()通知真正的观察者,observerWrapper为空 则遍历通知所有的观察者。 observerWrapper啥时候为空呢?这里先留个疑问。 继续看considerNotify()方法:
private void considerNotify(ObserverWrapper observer) {
if (!observer.mActive) {
return; //观察者非活跃 return
}
学习福利
【Android 详细知识点思维脑图(技能树)】
其实Android开发的知识点就那么多,面试问来问去还是那么点东西。所以面试没有其他的诀窍,只看你对这些知识点准备的充分程度。so,出去面试时先看看自己复习到了哪个阶段就好。
虽然 Android 没有前几年火热了,已经过去了会四大组件就能找到高薪职位的时代了。这只能说明 Android 中级以下的岗位饱和了,现在高级工程师还是比较缺少的,很多高级职位给的薪资真的特别高(钱多也不一定能找到合适的),所以努力让自己成为高级工程师才是最重要的。
这里附上上述的面试题相关的几十套字节跳动,京东,小米,腾讯、头条、阿里、美团等公司19年的面试题。把技术点整理成了视频和PDF(实际上比预期多花了不少精力),包含知识脉络 + 诸多细节。
由于篇幅有限,这里以图片的形式给大家展示一小部分。
网上学习 Android的资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。希望这份系统化的技术体系对大家有一个方向参考。
e;
}
复制代码
如果当前正在分发,则分发无效;observerWrapper不为空,就使用considerNotify()通知真正的观察者,observerWrapper为空 则遍历通知所有的观察者。 observerWrapper啥时候为空呢?这里先留个疑问。 继续看considerNotify()方法:
private void considerNotify(ObserverWrapper observer) {
if (!observer.mActive) {
return; //观察者非活跃 return
}
学习福利
【Android 详细知识点思维脑图(技能树)】
[外链图片转存中…(img-YSt0pCbF-1720105521282)]
其实Android开发的知识点就那么多,面试问来问去还是那么点东西。所以面试没有其他的诀窍,只看你对这些知识点准备的充分程度。so,出去面试时先看看自己复习到了哪个阶段就好。
虽然 Android 没有前几年火热了,已经过去了会四大组件就能找到高薪职位的时代了。这只能说明 Android 中级以下的岗位饱和了,现在高级工程师还是比较缺少的,很多高级职位给的薪资真的特别高(钱多也不一定能找到合适的),所以努力让自己成为高级工程师才是最重要的。
这里附上上述的面试题相关的几十套字节跳动,京东,小米,腾讯、头条、阿里、美团等公司19年的面试题。把技术点整理成了视频和PDF(实际上比预期多花了不少精力),包含知识脉络 + 诸多细节。
由于篇幅有限,这里以图片的形式给大家展示一小部分。
[外链图片转存中…(img-B7dUwGUP-1720105521283)]
网上学习 Android的资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。希望这份系统化的技术体系对大家有一个方向参考。