application.unregisterActivityLifecycleCallbacks(mPresenter)
}
}
采用这种方式注册后，我们就能在Activity生命周期变化的时候收到回调，从而执行相应的逻辑。因为是同步回调，所以我们要注意不能在回调方法中执行耗时操作，防止出现卡顿。
因为是注册在Application上的，mPresenter对象可以监听到Application的所有Activity的生命周期回调。
而在sdk>=29版本上，Activity也提供了自身的registerActivityLifecycleCallbacks方法，调用Activity这个方法注册的观察者将只会收到注册的Activity生命周期事件的回调。
Application.ActivityLifecycleCallbacks的优点：
通过定义Application.ActivityLifecycleCallbacks接口屏蔽了不同观察者的差异。同时在Activity的各个生命回调方法中分发事件，从根本保障了各个观察者都能在生命周期变化时接收到事件。比较通用，既能用于监听我们自身的Activity生命事件，也能监听第三方Activity事件。
Application.ActivityLifecycleCallbacks缺点：
有了Application.ActivityLifecycleCallbacks，解决了Activity生命周期分发的问题，但它仅适用于Activity的生命周期分发，而Android具有生命周期的对象也不止有Activity（例如Service，Fragment）等。
所以谷歌推出了我们今天的主角 --JetPack之LifeCycle生命周期组件
-
LifecycleObserver接口（ Lifecycle观察者） 这是一个空接口，主要起标记作用。依赖注解方法可以被LifeCycle类的addObserver(@NonNull LifecycleObserver observer)方法注册，被注册后就能收到持有LifeCycle的LifeCycleOwner分发生命周期事件。其常见子接口有LifecycleEventObserver和FullLifecycleObserver
-
LifecycleOwner接口（Lifecycle持有者） 需要分发生命周期的对象（如Activity和Fragment）需要实现的接口，该接口只有一个方法，为Lifecycle getLifecycle()，即提供生命周期对象，并需要通过Lifecycle在其生命周期发生变化的时候通知LifecycleObserver
-
Lifecycle(生命周期) 这是一个抽象类，提供了添加移除LifeCycleObserver接口的方法以及记录了当前LifeCycle的生命周期状态
-
State（当前生命周期所处的状态） 是一个枚举类，表示生命周期的各种状态。有DESTROYED，INITIALIZED，CREATED，STARTED，RESUMED这几种取值
-
Event(当前生命周期改变对应的事件) 是一个枚举类，表示生命周期改变对应的事件。有ON_CREATE,ON_START,ON_RESUME,ON_PAUSE,ON_STOP,ON_DESTROY,ON_ANY这几种取值
LifeCycleRegister是LifeCycle的实现类，实现了添加移除LifeCycleObserver的逻辑和生命周期状态管理，并且能够在LifeCycleOwner的生命周期发生变化时及时通知LifeCycleObserver。 有了LifeCycleRegister类，大大简化开发者使用LifeCyclerOwner的成本。使得Activity，Fragment不需要直接和LifeCycleObserver打交道。只需要在生命周期变化时调用LifeCycleRegister的handleLifecycleEvent(@NonNull Lifecycle.Event event) 方法即可。
下面先看它的构造方法：
public LifecycleRegistry(@NonNull LifecycleOwner provider) {
//持有的是LifeCycleOwner对象的弱引用，防止因为LifeCycleRegistery被长生命周期对象持有而
//造成LifeCycleOwner内存泄漏
mLifecycleOwner = new WeakReference<>(provider);
mState = INITIALIZED;
}
构造方法很简单，只是保存了传入来的LifeCycleOwner对象并且将当前状态置为INITIALIZED
接下来看一下它添加观察者的方法
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
//将LifecycleObserver和它的状态封装成ObserverWithState对象
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
//表示statefulObserver已经添加过了，故直接返回
if (previous != null) {
return;
}
LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
//lifecycleOwner为null，表示LifecycleOwner已被回收，故不需要观察了，返回
if (lifecycleOwner == null) {
// it is null we should be destroyed. Fallback quickly
return;
}
boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
//计算出新加入的observer需要转变到的目标状态
State targetState = calculateTargetState(observer);
mAddingObserverCounter++;
//当observer的mState小于目标状态时且observer没有被移除时，向observer分发生命周期事件
while ((statefulObserver.mState.compareTo(targetState) < 0
&& mObserverMap.contains(observer))) {
pushParentState(statefulObserver.mState);
//分发事件
statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
popParentState();
// mState / subling may have been changed recalculate
targetState = calculateTargetState(observer);
}
//为false,代表当前没有在sync()以及没有同时并发添加Observer
//主要为了防止重复调用sync()方法
if (!isReentrance) {
// we do sync only on the top level.
//同步所有观察者状态，使它们保持一致
sync();
}
mAddingObserverCounter–;
}
//返回当前状态的下一个状态
private static Event upEvent(State state) {
switch (state) {
case INITIALIZED:
case DESTROYED:
return ON_CREATE;
case CREATED:
return ON_START;
case STARTED:
return ON_RESUME;
case RESUMED:
throw new IllegalArgumentException();
}
throw new IllegalArgumentException("Unexpected state value " + state);
}
从上面的代码分析可以看出当我们在onResume方法中添加Observer，Observer将会连续收到ON_CREATE,ON_START,ON_RESUME事件的回调。
下面看下它分发事件的方法
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
//根据event获取对应的state
State next = getStateAfter(event);
moveToState(next);
}
static State getStateAfter(Event event) {
switch (event) {
case ON_CREATE:
case ON_STOP:
return CREATED;
case ON_START:
case ON_PAUSE:
return STARTED;
case ON_RESUME:
return RESUMED;
case ON_DESTROY:
return DESTROYED;
case ON_ANY:
break;
}
throw new IllegalArgumentException("Unexpected event value " + event);
}
private void moveToState(State next) {
//当前状态和转变状态一样，不处理
if (mState == next) {
return;
}
mState = next;
if (mHandlingEvent || mAddingObserverCounter != 0) {
mNewEventOccurred = true;
// we will figure out what to do on upper level.
return;
}
mHandlingEvent = true;
//同步所有观察者状态，使它们保持一致
sync();
mHandlingEvent = false;
}
private void sync() {
LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
if (lifecycleOwner == null) {
Log.w(LOG_TAG, "LifecycleOwner is garbage collected, you shouldn’t try dispatch "
- “new events from it.”);
return;
}
while (!isSynced()) {
mNewEventOccurred = false;
// no need to check eldest for nullability, because isSynced does it for us.
if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
backwardPass(lifecycleOwner);
}
Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
if (!mNewEventOccurred && newest != null
&& mState.compareTo(newest.getValue().mState) > 0) {
forwardPass(lifecycleOwner);
}
}
mNewEventOccurred = false;
}
在backwardPass(lifecycleOwner)和forwardPass(lifecycleOwner)方法调用了ObserverWithState的 dispatchEvent(LifecycleOwner owner, Event event) 方法
void dispatchEvent(LifecycleOwner owner, Event event) {
State newState = getStateAfter(event);
mState = min(mState, newState);
//把事件通知LifeCycleObsever
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
至此LifeCycleRegister接收事件并把它分发给LifeCycleObserver的流程已经分析完了。
从前面可知，LifeCycleObserver只是一个空接口。它的子接口有LifecycleEventObserver和FullLifecycleObserver,甚至还可以采用注解的方式来声明生命周期回调函数。 那ObserverWithState是如何兼容不同类型的LifeCycleObserver呢？
static class ObserverWithState {
State mState;
LifecycleEventObserver mLifecycleObserver;
ObserverWithState(LifecycleObserver observer, State initialState) {
mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
mState = initialState;
}
//省略…
}
借用业志陈的从源码看 Jetpack（1）-Lifecycle 源码详解的一段结论
ObserverWithState 将外界传入的 LifecycleObserver 对象传给 Lifecycling 进行类型包装，将反射逻辑和接口回调逻辑都给汇总综合成一个新的 LifecycleEventObserver 对象，从而使得 Event 分发过程都统一为一个入口。
ObserverWithState将复杂的反射逻辑和接口回调处理和类型包装封装到LifeCycling类中,将生成新的 LifecycleEventObserver 对象的过程和LifeCycleRegistry解耦，体现了单一职责。使得LifeCycleRegistry仅需通过onStateChanged 方法就能完成生命周期事件的分发。
static LifecycleEventObserver lifecycleEventObserver(Object object) {
boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
//实现了LifecycleEventObserver接口和FullLifecycleObserver接口
if (isLifecycleEventObserver && isFullLifecycleObserver) {
return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,
(LifecycleEventObserver) object);
}
//只实现了FullLifecycleObserver接口
if (isFullLifecycleObserver) {
return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
}
//只实现了LifecycleEventObserver接口
if (isLifecycleEventObserver) {
return (LifecycleEventObserver) object;
}
// 省略…
}
class FullLifecycleObserverAdapter implements LifecycleEventObserver {
private final FullLifecycleObserver mFullLifecycleObserver;
private final LifecycleEventObserver mLifecycleEventObserver;
FullLifecycleObserverAdapter(FullLifecycleObserver fullLifecycleObserver,
LifecycleEventObserver lifecycleEventObserver) {
mFullLifecycleObserver = fullLifecycleObserver;
mLifecycleEventObserver = lifecycleEventObserver;
}
@Override
public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {
switch (event) {
case ON_CREATE:
mFullLifecycleObserver.onCreate(source);
break;
case ON_START:
mFullLifecycleObserver.onStart(source);
break;
case ON_RESUME:
mFullLifecycleObserver.onResume(source);
break;
case ON_PAUSE:
mFullLifecycleObserver.onPause(source);
break;
case ON_STOP:
mFullLifecycleObserver.onStop(source);
break;
case ON_DESTROY:
mFullLifecycleObserver.onDestroy(source);
break;
case ON_ANY:
throw new IllegalArgumentException(“ON_ANY must not been send by anybody”);
}
if (mLifecycleEventObserver != null) {
mLifecycleEventObserver.onStateChanged(source, event);
}
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Android）
尾声
面试成功其实都是必然发生的事情，因为在此之前我做足了充分的准备工作，不单单是纯粹的刷题，更多的还会去刷一些Android核心架构进阶知识点，比如：JVM、高并发、多线程、缓存、热修复设计、插件化框架解读、组件化框架设计、图片加载框架、网络、设计模式、设计思想与代码质量优化、程序性能优化、开发效率优化、设计模式、负载均衡、算法、数据结构、高级UI晋升、Framework内核解析、Android组件内核等。
不仅有学习文档，视频+笔记提高学习效率，还能稳固你的知识，形成良好的系统的知识体系。这里，笔者分享一份从架构哲学的层面来剖析的视频及资料分享给大家梳理了多年的架构经验，筹备近6个月最新录制的，相信这份视频能给你带来不一样的启发、收获。
Android进阶学习资料库
一共十个专题，包括了Android进阶所有学习资料，Android进阶视频，Flutter，java基础，kotlin，NDK模块，计算机网络，数据结构与算法，微信小程序，面试题解析，framework源码！
大厂面试真题
PS：之前因为秋招收集的二十套一二线互联网公司Android面试真题 （含BAT、小米、华为、美团、滴滴）和我自己整理Android复习笔记（包含Android基础知识点、Android扩展知识点、Android源码解析、设计模式汇总、Gradle知识点、常见算法题汇总。）
《2017-2021字节跳动Android面试历年真题解析》
《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》，点击传送门即可获取！
的，相信这份视频能给你带来不一样的启发、收获。
[外链图片转存中…(img-HtMlpP5C-1712282777785)]
Android进阶学习资料库
一共十个专题，包括了Android进阶所有学习资料，Android进阶视频，Flutter，java基础，kotlin，NDK模块，计算机网络，数据结构与算法，微信小程序，面试题解析，framework源码！
[外链图片转存中…(img-9ggj6G8E-1712282777785)]
大厂面试真题
PS：之前因为秋招收集的二十套一二线互联网公司Android面试真题 （含BAT、小米、华为、美团、滴滴）和我自己整理Android复习笔记（包含Android基础知识点、Android扩展知识点、Android源码解析、设计模式汇总、Gradle知识点、常见算法题汇总。）
[外链图片转存中…(img-gVAQmCIs-1712282777785)]
《2017-2021字节跳动Android面试历年真题解析》
[外链图片转存中…(img-Z0flWnya-1712282777785)]
966
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
