Jetpack学习之 Lifecycle，2024金九银十

// 1

@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)

fun connect() {

Log.d(TAG, “connect”)

}

// 2

@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)

fun disconnect() {

Log.d(TAG, “disconnect”)

}

}

MainObserver 继承自 LifecycleObserver ，表明成为一个 Lifecycle 的观察者。

注释1：通过 @OnLifecycleEvent(Lifecycle.Event.ON_RESUME) 来观察组件的 Resume 状态

注释2：通过 @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE) 来观察组件的 Pause 状态

接下来要将它观察指定的Activity。

AndroidX 的 AppCompatActivity 继承了 ComponentActivity，后者实现了 getLifecycle()方法，所以我们可以在 Activity（需要继承）中直接获取当前组件的 Lifecycle，所以可以看下下面的代码：

class MainActivity : AppCompatActivity() {

override fun onCreate(savedInstanceState: Bundle?) {

super.onCreate(savedInstanceState)

setContentView(R.layout.activity_main)

// 1

lifecycle.addObserver(MainObserver())

}

}

在注释一处， 通过 getLifecycle() 获取到当前组件的 Lifecycle，接下来可以通过其 addObserver() 方法，将 MainObserver 添加到 LifecycleOwner 中了。

LifecycleOwner 是一个接口，它只有一个 getLifecycle() 方法，而 ComponentActivity 实现了它，所以我们可以调用这个方法。获取它后，可以添加观察者进去，当生命周期发生变化时， MainObserver 就能感知。接下来我打开 MainActivity，或者放到后台，就会下面这个Log：

2.3 *自定义 LifecycleOwner

---

因为只有 Support26.1.0+ 、 AndroidX 的版本是在 Activity、Fragment中实现了 LifecycleOwner 接口，所以这些版本的代码中，可以通过 getLifecycle() 来获取 Lifecycle。

但是非这些版本，就需要开发者自己手动实现，具体使用需要使用 LifecycleRegistry 这个类。但是我认为这种场景是已经比较少了，所以这里就不多赘述。

3. 原理

=======================================================================

3.1 Lifecycle 的生命周期状态事件和状态

---

Lifecyce 使用 两个枚举 来跟踪其关联组件的生命周期状态， 它们分别是： Event 和 Status。

• State 代表 Lifecycle 的生命周期所处的状态

• Event 代表 Lifecycle 生命周期对应的事件

这些事件会映射到 Activity 和 Fragment的回调事件中。

来看下 Lifecycle 的部分源码：

public abstract class Lifecycle {

public abstract void addObserver(@NonNull LifecycleObserver observer);

public abstract void removeObserver(@NonNull LifecycleObserver observer);

@SuppressWarnings(“WeakerAccess”)

public enum Event {

ON_CREATE,

ON_START,

ON_RESUME,

ON_PAUSE,

ON_STOP,

ON_DESTROY,

ON_ANY;

…

}

public enum State {

DESTROYED,

INITIALIZED,

CREATED,

STARTED,

RESUMED;

public boolean isAtLeast(@NonNull State state) {

return compareTo(state) >= 0;

}

}

}

Lifecycle 是一个抽象类，提供了 add 和 remove 观察者的方法，还定义了 Event 和 Status 两个枚举。

可以看到 Event 中的事件和 Activity 的生命周期几乎是对应的，还有一个 ON_ANY，和它名字一样，用来匹配所有的事件。

Status 与 Events 的关系如下图所示：

3.2 Lifecycle 是如何观察生命周期的

---

因为 MainActivity 继承了 ComponentActivity，它实现了 Lifecycler接口，所以我们可以看看它是如何实现该接口的。下面是一个调用链时序图：

// ComponentActivity.java

public class ComponentActivity extends androidx.core.app.ComponentActivity implements

LifecycleOwner, … {

// 1

private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

@Override

protected void onCreate(@Nullable Bundle savedInstanceState) {

…

// 2

ReportFragment.injectIfNeededIn(this);

}

@Override

protected void onSaveInstanceState(@NonNull Bundle outState) {

// 3

Lifecycle lifecycle = getLifecycle();

if (lifecycle instanceof LifecycleRegistry) {

((LifecycleRegistry) lifecycle).setCurrentState(Lifecycle.State.CREATED);

}

…

}

@Override

public Lifecycle getLifecycle() {

// 4

return mLifecycleRegistry;

}

}

注释1：创建了 LifecycleRegistry， 它是 Lifecycle 的实现类。 注释4实现接口方法，并返回了这个实例。

注释3： 在 onSaveInstanceState() 方法中， 使用 LifecycleRegistry 标记当前的 State 为 CREATED。

正常来说，ComponentActivity 会在每个生命周期方法中，都会去标记下State，但是我们发现它并没有这样做。 而是交给了 注释2中的 ReportFragment 来处理。

注释2：将 ComponentActivity 注入到 ReportFragment 中：

// ReportFragment.java

public class ReportFragment extends android.app.Fragment {

public static void injectIfNeededIn(Activity activity) {

if (Build.VERSION.SDK_INT >= 29) {

LifecycleCallbacks.registerIn(activity);

}

android.app.FragmentManager manager = activity.getFragmentManager();

if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {

manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();

manager.executePendingTransactions();

}

}

static ReportFragment get(Activity activity) {

return (ReportFragment) activity.getFragmentManager().findFragmentByTag(

REPORT_FRAGMENT_TAG);

}

@Override

public void onActivityCreated(Bundle savedInstanceState) {

super.onActivityCreated(savedInstanceState);

dispatchCreate(mProcessListener);

dispatch(Lifecycle.Event.ON_CREATE);

}

@Override

public void onStart() {

super.onStart();

dispatchStart(mProcessListener);

// 1

dispatch(Lifecycle.Event.ON_START);

}

@Override

public void onResume() {

super.onResume();

dispatchResume(mProcessListener);

dispatch(Lifecycle.Event.ON_RESUME);

}

@Override

public void onPause() {

super.onPause();

dispatch(Lifecycle.Event.ON_PAUSE);

}

@Override

public void onStop() {

super.onStop();

dispatch(Lifecycle.Event.ON_STOP);

}

@Override

public void onDestroy() {

super.onDestroy();

dispatch(Lifecycle.Event.ON_DESTROY);

mProcessListener = null;

}

private void dispatch(@NonNull Lifecycle.Event event) {

if (Build.VERSION.SDK_INT < 29) {

dispatch(getActivity(), event);

}

}

void setProcessListener(ActivityInitializationListener processListener) {

mProcessListener = processListener;

}

interface ActivityInitializationListener {

void onCreate();

void onStart();

void onResume();

}

static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {

// 2

if (activity instanceof LifecycleRegistryOwner) {

((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);

return;

}

// 3

if (activity instanceof LifecycleOwner) {

Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();

if (lifecycle instanceof LifecycleRegistry) {

((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);

}

}

}

…

}

ReportFragment 的 onStart() 方法中会调用注释 1 处的 dispatch()。

该方法中，注释2处：判断 Activity 是否实现了 LifecycleRegistryOwner 接口。该接口和 LifecyclerOwner 的不同之处，就是前者 getLifecycle() 返回的是 LifecycleRegistry 实例，后者返回的是 Lifecycle实例。

注释3： 如果 Activity 继承了 LifecycleOwner 接口，则调用 LifecycleRegistry 的 handleLifecycleEvent() 方法，也就是说 注释2 和 3 所做的事情是一样的。

来看看 handleLifecycleEvent() 方法：

public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {、

moveToState(event.getTargetState());

}

public State getTargetState() {

switch (this) {

case ON_CREATE:

case ON_STOP:

return State.CREATED;

case ON_START:

case ON_PAUSE:

return State.STARTED;

case ON_RESUME:

return State.RESUMED;

case ON_DESTROY:

return State.DESTROYED;

case ON_ANY:

break;

}

throw new IllegalArgumentException(this + " has no target state");

}

它会调用 Event getTargetState() 方法，来获取当前Event所映射的State。这个和上面的映射表一致。

接着调用 moveToState():

private void moveToState(State next) {

if (mState == next) {

return;

}

mState = next;

if (mHandlingEvent || mAddingObserverCounter != 0) {

mNewEventOccurred = true;

return;

}

mHandlingEvent = true;

sync();

mHandlingEvent = false;

}

这里主要是调用了 sync() 方法：

private void sync() {

LifecycleOwner lifecycleOwner = mLifecycleOwner.get();

…

while (!isSynced()) {

mNewEventOccurred = false;

// 当前状态 - 最早的状态<0 ，表明当前状态是向后的

if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {

backwardPass(lifecycleOwner);

}

// 当前状态 - 最新的状态>0 ，表明当前状态是向前的

Map.Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();

if (!mNewEventOccurred && newest != null

&& mState.compareTo(newest.getValue().mState) > 0) {

forwardPass(lifecycleOwner);

}

}

mNewEventOccurred = false;

}

sync() 方法会根据当前状态和 mObserverMap 中的 eldest 和 newest 的状态进行对比，判断当前的状态是向前的还是向后的。 比如 STARTED -> RESUMED 是状态向前，反过来是向后的。

无论向前还是向后，代码都是差不多的，这里以 backwardPass() 为例：

private void backwardPass(LifecycleOwner lifecycleOwner) {

Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> descendingIterator =

mObserverMap.descendingIterator();

while (descendingIterator.hasNext() && !mNewEventOccurred) {

Map.Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();

// 1

ObserverWithState observer = entry.getValue();

while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred

&& mObserverMap.contains(entry.getKey()))) {

Event event = Event.downFrom(observer.mState);

if (event == null) {

throw new IllegalStateException("no event down from " + observer.mState);

}

pushParentState(event.getTargetState());

// 2

observer.dispatchEvent(lifecycleOwner, event);

popParentState();

}

}

}

注释1： 获取了 ObserverWithState 实例

注释2： 执行注释1实例的 dispatchEvent，传入的 event 代表的是当前状态的向后状态

来看看那 ObserverWithState.dispatchEvent():

static class ObserverWithState {

State mState;

LifecycleEventObserver mLifecycleObserver;

ObserverWithState(LifecycleObserver observer, State initialState) {

mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);

mState = initialState;

}

void dispatchEvent(LifecycleOwner owner, Event event) {

State newState = event.getTargetState();

mState = min(mState, newState);

mLifecycleObserver.onStateChanged(owner, event);

mState = newState;

}

}

该类包含了 State 和 LifecycleEventObserver，后者是一个接口，继承了 LifecycleObserver~

而 ReflectiveGenericLifecycleObserver 则是它的一个实现类，来看看它是如何实现的：

class ReflectiveGenericLifecycleObserver implements LifecycleEventObserver {

private final Object mWrapped;

private final CallbackInfo mInfo;

ReflectiveGenericLifecycleObserver(Object wrapped) {

mWrapped = wrapped;

mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());

}

@Override

public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Event event) {

// 1

mInfo.invokeCallbacks(source, event, mWrapped);

}

}

注释1处会调用 CallbackInfo 的 invokeCallbacks()。这个就是执行回调咯。 所以我们要搞清楚 CallbackInfo 是如何创建出来的。

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip204888 （备注Android）

最后

**一个零基础的新人，我认为坚持是最最重要的。**我的很多朋友都找我来学习过，我也很用心的教他们，可是不到一个月就坚持不下来了。我认为他们坚持不下来有两点主要原因：

他们打算入行不是因为兴趣，而是因为所谓的IT行业工资高，或者说完全对未来没有任何规划。

刚开始学的时候确实很枯燥，这确实对你是个考验，所以说坚持下来也很不容易，但是如果你有兴趣就不会认为这是累，不会认为这很枯燥，总之还是贵在坚持。

技术提升遇到瓶颈了？缺高级Android进阶视频学习提升自己吗？还有大量大厂面试题为你面试做准备！

提升自己去挑战一下BAT面试难关吧

对于很多Android工程师而言，想要提升技能，往往是自己摸索成长，不成体系的学习效果低效漫长且无助。整理的这些知识图谱希望对Android开发的朋友们有所参考以及少走弯路，本文的重点是你有没有收获与成长，其余的都不重要，希望读者们能谨记这一点。

不论遇到什么困难，都不应该成为我们放弃的理由！

如果有什么疑问的可以直接私我，我尽自己最大力量帮助你！

最后祝各位新人都能坚持下来，学有所成。

本文已被CODING开源项目：《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》收录

一个人可以走的很快，但一群人才能走的更远。如果你从事以下工作或对以下感兴趣，欢迎戳这里加入程序员的圈子，让我们一起学习成长！

AI人工智能、Android移动开发、AIGC大模型、C C#、Go语言、Java、Linux运维、云计算、MySQL、PMP、网络安全、Python爬虫、UE5、UI设计、Unity3D、Web前端开发、产品经理、车载开发、大数据、鸿蒙、计算机网络、嵌入式物联网、软件测试、数据结构与算法、音视频开发、Flutter、IOS开发、PHP开发、.NET、安卓逆向、云计算

是因为所谓的IT行业工资高，或者说完全对未来没有任何规划。

刚开始学的时候确实很枯燥，这确实对你是个考验，所以说坚持下来也很不容易，但是如果你有兴趣就不会认为这是累，不会认为这很枯燥，总之还是贵在坚持。

技术提升遇到瓶颈了？缺高级Android进阶视频学习提升自己吗？还有大量大厂面试题为你面试做准备！

提升自己去挑战一下BAT面试难关吧

[外链图片转存中…(img-ma0e05KG-1712194502546)]

对于很多Android工程师而言，想要提升技能，往往是自己摸索成长，不成体系的学习效果低效漫长且无助。整理的这些知识图谱希望对Android开发的朋友们有所参考以及少走弯路，本文的重点是你有没有收获与成长，其余的都不重要，希望读者们能谨记这一点。

不论遇到什么困难，都不应该成为我们放弃的理由！

如果有什么疑问的可以直接私我，我尽自己最大力量帮助你！

最后祝各位新人都能坚持下来，学有所成。

本文已被CODING开源项目：《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》收录

一个人可以走的很快，但一群人才能走的更远。如果你从事以下工作或对以下感兴趣，欢迎戳这里加入程序员的圈子，让我们一起学习成长！

AI人工智能、Android移动开发、AIGC大模型、C C#、Go语言、Java、Linux运维、云计算、MySQL、PMP、网络安全、Python爬虫、UE5、UI设计、Unity3D、Web前端开发、产品经理、车载开发、大数据、鸿蒙、计算机网络、嵌入式物联网、软件测试、数据结构与算法、音视频开发、Flutter、IOS开发、PHP开发、.NET、安卓逆向、云计算