Jetpack学习之 Lifecycle

最新推荐文章于 2024-04-11 08:50:35 发布

RikkaTheWorld

最新推荐文章于 2024-04-11 08:50:35 发布

阅读量204

点赞数

分类专栏： Jetpack Android框架

本文链接：https://blog.csdn.net/rikkatheworld/article/details/114782552

版权

Android框架同时被 2 个专栏收录

17 篇文章 0 订阅

订阅专栏

Jetpack

8 篇文章 2 订阅

订阅专栏

Lifecycle 用于帮助开发者管理 Activity 和 Fragment 的生命周期，由于 Lifecycle 是 LiveData 和 ViewModel的基础，所以要了解后面那两位，需要先学习 Lifecycle。

1. 概述

1.1 Lifecycle定义

Lifecycle 组件用来感知另外一个组件（Activity、Application、Fragment）的生命周期。
在这里插入图片描述

1.2 为什么使用Lifecycle

我们代码是能够直接访问组件的生命周期相关的方法的，为什么还要特意去用 Lifecycle 来感知它？

来看看下面这段代码：

class MainActivity : AppCompatActivity() {
    val listener = Listener()
    ...

    override fun onStart() {
        listener.onStart()
    }

    override fun onResume() {
        listener.onResume()
    }

    override fun onStop() {
        listener.onStop()
    }

    class Listener {
        fun onStart()...
        fun onResume()...
        fun onStop()...
    }
}

上面的代码还可以把 Listener 换成MVP中的 Presenter。

这种写法比较普遍也不难，但是我们平时开发中，不可能只是单单这样子调用那么简单。
如果出现了多种组件需要依赖Activity、Fragment生命周期的场景，那么在它们生命周期的方法中，就可能需要写入大量的代码，这使得它们难以维护。

如果我们在组件中做了耗时操作（比如 onStart 方法），那么这种写法就无法保证组件在 Activity 或者 Fragment 停止之前完成启动。因此我们需要一个能够管理 Activity 和 Fragmgent 的生命周期的库，这个库就是 Lifecycle。

2. 使用

2.1 导入

下面是官方文档给出的导入配置，比较全，可以选其中的几个导入就行了：

dependencies {
    def lifecycle_version = "2.3.0"
    def arch_version = "2.1.0"

    // ViewModel
    implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version"
    // LiveData
    implementation "androidx.lifecycle:lifecycle-livedata-ktx:$lifecycle_version"
    // Lifecycles only (without ViewModel or LiveData)
    implementation "androidx.lifecycle:lifecycle-runtime-ktx:$lifecycle_version"

    // Saved state module for ViewModel
    implementation "androidx.lifecycle:lifecycle-viewmodel-savedstate:$lifecycle_version"

    // Jetpack Compose Integration for ViewModel
    implementation "androidx.lifecycle:lifecycle-viewmodel-compose:1.0.0-alpha01"

    // Annotation processor
    kapt "androidx.lifecycle:lifecycle-compiler:$lifecycle_version"
    // alternately - if using Java8, use the following instead of lifecycle-compiler
    implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"

    // optional - helpers for implementing LifecycleOwner in a Service
    implementation "androidx.lifecycle:lifecycle-service:$lifecycle_version"

    // optional - ProcessLifecycleOwner provides a lifecycle for the whole application process
    implementation "androidx.lifecycle:lifecycle-process:$lifecycle_version"

    // optional - ReactiveStreams support for LiveData
    implementation "androidx.lifecycle:lifecycle-reactivestreams-ktx:$lifecycle_version"

    // optional - Test helpers for LiveData
    testImplementation "androidx.arch.core:core-testing:$arch_version"
}

2.2 简单示例

我们需要创建一个 Lifecycle，来观察一个 Activity，如下所示：

    class MainObserver: LifecycleObserver {
        companion object {
            private const val TAG = "MainObserver"
        }
        // 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 是如何创建出来的。

下面这个 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<MethodReference>> 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<MethodReference> methodReferences = mEventToHandlers.get(event);
                if (methodReferences == null) {
                    methodReferences = new ArrayList<>();
                    mEventToHandlers.put(event, methodReferences);
                }
                methodReferences.add(entry.getKey());
            }
        }

        void invokeCallbacks(LifecycleOwner source, Lifecycle.Event event, Object target) {
            // 2
            invokeMethodsForEvent(mEventToHandlers.get(event), source, event, target);
            invokeMethodsForEvent(mEventToHandlers.get(Lifecycle.Event.ON_ANY), source, event,
                    target);
        }

        private static void invokeMethodsForEvent(List<MethodReference> handlers,
                LifecycleOwner source, Lifecycle.Event event, Object mWrapped) {
            if (handlers != null) {
                for (int i = handlers.size() - 1; i >= 0; i--) {
                    handlers.get(i).invokeCallback(source, event, mWrapped);
                }
            }
        }
    }

注释1：对Map做一个类型转化，转化成HashMap

注释2： invokeMthodsForEvent() 方法会传入 mEventToHandlers.get(event)，也就是事件对应的 MethodReference 的集合。在 invokeMethodsForEvent 方法中，就回去遍历 MethodReference 的集合，调用 MethodReference 的 invokeCallback 方法，如下所示：

    static final class MethodReference {
        final int mCallType;
        final Method mMethod;

        void invokeCallback(LifecycleOwner source, Lifecycle.Event event, Object target) {
            try {
                switch (mCallType) {
                    case CALL_TYPE_NO_ARG:
                        mMethod.invoke(target);
                        break;
                    case CALL_TYPE_PROVIDER:
                        mMethod.invoke(target, source);
                        break;
                    case CALL_TYPE_PROVIDER_WITH_EVENT:
                        mMethod.invoke(target, source, event);
                        break;
                }
            } catch (InvocationTargetException e) {
                throw new RuntimeException("Failed to call observer method", e.getCause());
            } catch (IllegalAccessException e) {
                throw new RuntimeException(e);
            }
        }
        ...
}

MethodReference 类中有两个变量，一个是callType，它代表调用方法的类型，另一个变量则是 Method，它代表方法，无论是哪种 callType 都会通过 invoke 对方法进行反射。

总结：
实现 LifecycleOvserver 接口的类中，注解修饰的方法和事件会被保存成一个 MethodReference，在生命周期变化的时候，会通过反射去调用这些对应生命周期的方法。

3.3 Lifecycle UML图

最后贴一下 UML图，更直观的了解他的一个架构（其实还是比较简单的）：
在这里插入图片描述

参考文章

《Android进阶指北》第10章Android Jetpack架构组件
Android开发者–Lifecycle官方文档

RikkaTheWorld

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Jetpack学习之 Lifecycle

Lifecycle 用于帮助开发者管理 Activity 和 Fragment 的生命周期，由于 Lifecycle 是 LiveData 和 ViewModel的基础，所以要了解后面那两位，需要先学习 Lifecycle。目录1. 概述1.1 Lifecycle定义1.2 为什么使用Lifecycle2. 使用2.1 导入1. 概述1.1 Lifecycle定义Lifecycle 组件用来感知另外一个组件（Activity、Application、Fragment）的生命周期。1.2 为什么
复制链接

扫一扫