最新Jetpack学习之 Lifecycle(2)，2024年最新android开发基础自学

最后看一下学习需要的所有知识点的思维导图。在刚刚那份学习笔记里包含了下面知识点所有内容！文章里已经展示了部分！如果你正愁这块不知道如何学习或者想提升学习这块知识的学习效率，那么这份学习笔记绝对是你的秘密武器！

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

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 是如何创建出来的。

下面这个 createInfo() 方法用来创建 CallbackInfo的：

private CallbackInfo createInfo(Class<?> klass, @Nullable Method[] declaredMethods) {

Class<?> superclass = klass.getSuperclass();

Map<MethodReference, Lifecycle.Event> handlerToEvent = new HashMap<>();

…

Method[] methods = declaredMethods != null ? declaredMethods : getDeclaredMethods(klass);

boolean hasLifecycleMethods = false;

for (Method method : methods) {

// 1

OnLifecycleEvent annotation = method.getAnnotation(OnLifecycleEvent.class);

…

Lifecycle.Event event = annotation.value();

if (params.length > 1) {

callType = CALL_TYPE_PROVIDER_WITH_EVENT;

if (!params[1].isAssignableFrom(Lifecycle.Event.class)) {

throw new IllegalArgumentException(

“invalid parameter type. second arg must be an event”);

}

if (event != Lifecycle.Event.ON_ANY) {

throw new IllegalArgumentException(

“Second arg is supported only for ON_ANY value”);

}

}

if (params.length > 2) {

throw new IllegalArgumentException(“cannot have more than 2 params”);

}

// 3

MethodReference methodReference = new MethodReference(callType, method);

// 4

verifyAndPutHandler(handlerToEvent, methodReference, event, klass);

}

// 5

CallbackInfo info = new CallbackInfo(handlerToEvent);

mCallbackMap.put(klass, info);

mHasLifecycleMethods.put(klass, hasLifecycleMethods);

return info;

}

注释1： 遍历所有方法，获取其 OnLifecycleEvent 注解，这个注解正是实现 LifecycleObserver 接口时用到的。

注释2：获取该注解的值， 也就是在 @OnLifecycleEvent 中定义的事件

注释3： 创建一个 MethodReference 对象，其内部包括使用了该注解的方法。

注释4：用于将 MethodReference 和 对应的Event 存入到 Map类型的 handlerToEvent 中。

注释5： 新建 CallbackInfo， 并将 handlerToEvent 传进去。

继续来看 CallbackInfo 的 invokeCallbacks 方法：

static class CallbackInfo {

final Map<Lifecycle.Event, List> mEventToHandlers;

final Map<MethodReference, Lifecycle.Event> mHandlerToEvent;

CallbackInfo(Map<MethodReference, Lifecycle.Event> handlerToEvent) {

mHandlerToEvent = handlerToEvent;

mEventToHandlers = new HashMap<>();

// 1

for (Map.Entry<MethodReference, Lifecycle.Event> entry : handlerToEvent.entrySet()) {

Lifecycle.Event event = entry.getValue();

List methodReferences = mEventToHandlers.get(event);

if (methodReferences == null) {

methodReferences = new ArrayList<>();

mEventToHandlers.put(event, methodReferences);

}

methodReferences.add(entry.getKey());

}

}

最后我还整理了很多Android中高级的PDF技术文档。以及一些大厂面试真题解析文档。

Android高级架构师之路很漫长，一起共勉吧！

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

andlerToEvent;

mEventToHandlers = new HashMap<>();

// 1

for (Map.Entry<MethodReference, Lifecycle.Event> entry : handlerToEvent.entrySet()) {

Lifecycle.Event event = entry.getValue();

List methodReferences = mEventToHandlers.get(event);

if (methodReferences == null) {

methodReferences = new ArrayList<>();

mEventToHandlers.put(event, methodReferences);

}

methodReferences.add(entry.getKey());

}

}

最后我还整理了很多Android中高级的PDF技术文档。以及一些大厂面试真题解析文档。

[外链图片转存中…(img-jLUQYYQB-1715372810725)]

Android高级架构师之路很漫长，一起共勉吧！

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！