Lifecycle源码浅析

朴灿烈づ我的快乐病毒、 2022-01-19 00:27 267阅读 0赞

> 之前用过一些android架构组件,但也仅限于api调用,知其然也该知其所以然,所以尝试了解下其源码实现;
> 
> 本文主要想简单探究下以下问题:
> 
> 1.  Lifecycle 如何知晓 Activity 的生命周期变化;
> 2.  LifecycleObserver 的注解如何生效;
> 
> 本文基于: macOS 10.13/AS 3.4/support-v7 28.0.0

[demo项目][demo]

## 使用方法简介 ##

以前拆分业务逻辑到独立的 `presenter` 中时,需要重写 `Activity`/`Fragment` 各生命周期,然后告知 `presenter`, 写起来麻烦, 有没有比较简单的方式能把这些"脏活"给处理掉呢?

我们看看 `Lifecycle` 的用法:

// MainActiviy.kt
    class MainActivity : AppCompatActivity() {
        override fun onCreate(savedInstanceState: Bundle?) {
            super.onCreate(savedInstanceState)
            setContentView(R.layout.activity_main)
            lifecycle.addObserver(MainActObserver())
        }
    }
    
    // MainActObserver.kt
    class MainActObserver : LifecycleObserver { 
        @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
        fun onCreate() {
            Logger.d("MainActObserver $this onCreate")
        }
    
        @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
        fun onResume() {
            Logger.d("MainActObserver onResume")
        }
        // 其他生命周期回调,此处省略
    }
    复制代码

可以看到就简单一句 `lifecycle.addObserver(MainActObserver())` 就完成了 `Activity` 各生命周期的监听;

> P.S. 由于 `Android Studio` 创建项目时默认导入了 support 的 `appcompat-v7` 包,已经把 `Lifecycle` 相关代码导入进来了, 因此我们可以直接使用,不需要额外添加依赖;

以下就从 `lifecycle.addObserver(MainActObserver())` 展开:

## 先认识下 `Lifecycle` 类 ##

// package android.arch.lifecycle;
    // Lifecycle.java
    public abstract class Lifecycle {
        @MainThread
        public abstract void addObserver(@NonNull LifecycleObserver observer);
    
        @MainThread
        public abstract void removeObserver(@NonNull LifecycleObserver observer);
    
        @MainThread
        @NonNull
        public abstract State getCurrentState();
    
        // 生命周期事件
        public enum Event {
            ON_CREATE, ON_START, ON_RESUME, ON_PAUSE, ON_STOP, ON_DESTROY, ON_ANY
        }
    
        // 生命周期状态
        public enum State {
            // 以下均已 Activity 为例,介绍各状态值,具体请看源码注释
            DESTROYED,
            INITIALIZED, // 对象创建后但尚未收到 onCreate() 通知之前
            CREATED,// onCreate()/onStop() 之后
            STARTED, // onStart()/onPause() 之后
            RESUMED; // onResume() 之后
            public boolean isAtLeast(@NonNull State state) {
                return compareTo(state) >= 0;
            }
        }
    }
    复制代码

可以发现: `Lifecycle` 只是个抽象类,也没有对生命周期的变化做出响应的方法,只是简单定义了生命周期事件及状态, 因此应该有个实现类对生命周期事件作出处理;

## 顺便看下 `MainActObserver` ##

它实现了 `LifecycleObserver` 接口,而 `LifecycleObserver` 仅是一个标记接口:

/** * Marks a class as a LifecycleObserver. It does not have any methods, instead, relies on { @link OnLifecycleEvent} annotated methods. * 这是个标记性接口,没有任何方法 */
    public interface LifecycleObserver {
    }
    
    /** * 通过上面 LifecycleObserver 的注释,可以发现,最终是通过本注解来实现生命周期感知的 */
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.METHOD)
    public @interface OnLifecycleEvent {
        Lifecycle.Event value();
    }
    复制代码

通过代码注释我们也可大概猜到:各生命周期事件应该是通过遍历 `LifecycleObserver` 实现类,查找带有 `OnLifecycleEvent` 注解的方法,然后进行回调的;

## 言归正传,探究下 `getLifecycle()` ##

// package android.support.v4.app;
    // FragmentActivity.java
    public class FragmentActivity extends SupportActivity {
        public Lifecycle getLifecycle() {
            return super.getLifecycle();
        }
    }
    
    // package android.support.v4.app;
    // SupportActivity.java
    public class SupportActivity extends Activity implements LifecycleOwner, Component {
        // LifecycleRegistry 是 Lifecycle 的实现类,所有逻辑由其来完成
        private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
        public Lifecycle getLifecycle() {
            return this.mLifecycleRegistry;
        }
    }
    复制代码

从上图可知, `LifecycleRegistry` 应能会接收并处理各生命周期事件/状态,并通过 `sync()` 同步到各observer;

### 生命周期状态的变化顺序 ###

回看 `Lifecycle` 源码,发现生命周期状态(`State`)的个数小于事件(`Event`)的个数,因此应该有多个事件归属于同一个状态,并且状态之间的变化规律应该也定义在 `LifecycleRegistry` 中:

// package android.arch.lifecycle;
    // LifecycleRegistry.java
    public class LifecycleRegistry extends Lifecycle {
        private State mState; // 当前状态
    
        // 使用弱引用,避免影响Activity的GC
        public LifecycleRegistry(@NonNull LifecycleOwner provider) {
            mLifecycleOwner = new WeakReference<>(provider);
            mState = INITIALIZED;
        }
    
        // 计算发生某个生命周期时间后应有的状态
        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 static Event downEvent(State state) {
            switch (state) {
                case INITIALIZED:
                    throw new IllegalArgumentException();
                case CREATED:
                    return ON_DESTROY;
                case STARTED:
                    return ON_STOP;
                case RESUMED:
                    return ON_PAUSE;
                case DESTROYED:
                    throw new IllegalArgumentException();
            }
            throw new IllegalArgumentException("Unexpected state value " + state);
        }
    
        // 前进到下一状态时的事件
        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);
        }
    }
    复制代码

可得出下图(图片来自[官网][Link 1]):

### 生命周期事件/状态的处理 ###

// package android.arch.lifecycle;
    // LifecycleRegistry.java
    public class LifecycleRegistry extends Lifecycle {
    
        /** * 由于实际生命周期事件多于lifecycle定义的数量,可能有部分生命周期回调需要直接指定其当前的状态, * 如: SupportActivity 的 onSaveInstanceState(Bundle) 事件, 就被直接标记为 CREATED 状态 */
        @MainThread
        public void markState(@NonNull State state) {
            moveToState(state);
        }
    
       public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
            State next = getStateAfter(event); // 计算事件发生后的状态
            moveToState(next); // 更新当前状态
        }
    
        // Activity 生命周期事件变化时都会走到这里, 最终通过 sync() 方法通知各 observer
        private void moveToState(State next) {
            if (mState == next) {
                return;
            }
            mState = next; // 更新当前状态
            if (mHandlingEvent || mAddingObserverCounter != 0) {
                mNewEventOccurred = true;
                return;
            }
            mHandlingEvent = true;
            sync(); // 通知各 LifecycleObserver 更新状态
            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.
                // 如果当前状态比observerMap中最小的状态值还小,则回退状态
                if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
                    backwardPass(lifecycleOwner);
                }
    
                // 如果当前状态比observerMap中最大的状态值还大,则前移状态
                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, Event)` 方法, 我们来看下这个类:

// LifecycleRegistry.java
    public class LifecycleRegistry extends Lifecycle {
        private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap =
                new FastSafeIterableMap<>();
    
        @Override
        public void addObserver(@NonNull LifecycleObserver observer) {
            State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
            // 我们定义的 LifecycleObserver 被包装成 ObserverWithState
            ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
            // 缓存所有的observer,后续用于遍历回调通知
            ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
            // 省略部分代码
        }
    
        static class ObserverWithState {
            State mState;
            GenericLifecycleObserver mLifecycleObserver;
    
            ObserverWithState(LifecycleObserver observer, State initialState) {
                // GenericLifecycleObserver 继承自 LifecycleObserver,此处又做了一次包装
                mLifecycleObserver = Lifecycling.getCallback(observer);
                mState = initialState;
            }
    
            // 当 LifecycleOwner 生命周期变化时,通过本方法来通知各 LifeObserver
            void dispatchEvent(LifecycleOwner owner, Event event) {
                State newState = getStateAfter(event);
                mState = min(mState, newState);
                mLifecycleObserver.onStateChanged(owner, event);
                mState = newState;
            }
        }
    }
    复制代码

到此,我们知道了 `LifecycleRegistry` 通知 `LifecycleOwner` 的大体流程,但我们仍然没看到我们的注解如何发生作用,如何收到生命周期事件,接下来我们就来看看

### 生命周期注解的使用 ###

// package android.arch.lifecycle;
    // Lifecycling.java
    public class Lifecycling {
    
       @NonNull
        static GenericLifecycleObserver getCallback(Object object) {
            if (object instanceof FullLifecycleObserver) {
                return new FullLifecycleObserverAdapter((FullLifecycleObserver) object);
            }
    
            if (object instanceof GenericLifecycleObserver) {
                return (GenericLifecycleObserver) object;
            }
    
            // 由于我没有使用 LifeCycleCompiler ,因此不会生成 MainActObserver_LifecycleAdapter 类, 此if判断不满足
            // P.S. MainActObserver_LifecycleAdapter 位于: app/build/generated/source/kapt/debug/***
            final Class<?> klass = object.getClass();
            int type = getObserverConstructorType(klass);
            if (type == GENERATED_CALLBACK) {
                List<Constructor<? extends GeneratedAdapter>> constructors =
                        sClassToAdapters.get(klass);
                if (constructors.size() == 1) {
                    GeneratedAdapter generatedAdapter = createGeneratedAdapter(
                            constructors.get(0), object);
                    return new SingleGeneratedAdapterObserver(generatedAdapter);
                }
                GeneratedAdapter[] adapters = new GeneratedAdapter[constructors.size()];
                for (int i = 0; i < constructors.size(); i++) {
                    adapters[i] = createGeneratedAdapter(constructors.get(i), object);
                }
                return new CompositeGeneratedAdaptersObserver(adapters);
            }
    
            // 最终是通过反射获取 LifecycleObserver 的方法
            // 但反射比较耗性能, 因此可以猜想应该有做缓存优化
            return new ReflectiveGenericLifecycleObserver(object);
        }
    }
    复制代码

// package android.arch.lifecycle;
    // ReflectiveGenericLifecycleObserver.java
    class ReflectiveGenericLifecycleObserver implements GenericLifecycleObserver {
        private final Object mWrapped;
        private final CallbackInfo mInfo;
    
        ReflectiveGenericLifecycleObserver(Object wrapped) {
            mWrapped = wrapped;
            // 可以猜想 ClassesInfoCache 是用于缓存 包含lifecycle生命周期事件方法的
            mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());
        }
    
        @Override
        public void onStateChanged(LifecycleOwner source, Event event) {
            // 当Activity生命周期发生变化时,通过 CallbackInfo 来触发 LifecycleObserver 各方法
            // 因此重点就在 ClassesInfoCache 类生成的 CallbackInfo 中
            mInfo.invokeCallbacks(source, event, mWrapped);
        }
    }
    复制代码

// package android.arch.lifecycle;
    // ClassesInfoCache.java
    class ClassesInfoCache {
        CallbackInfo getInfo(Class klass) {
            // 由于运行时反射成本大, 因此先查缓存,若不存在,则反射提取各方法
            CallbackInfo existing = mCallbackMap.get(klass);
            if (existing != null) {
                return existing;
            }
            existing = createInfo(klass, null);
            return existing;
        }
    
        private CallbackInfo createInfo(Class klass, @Nullable Method[] declaredMethods) {
            // 查看父类是否也有生命周期事件注解,若有,一并添加到缓存中
            Class superclass = klass.getSuperclass();
            Map<MethodReference, Lifecycle.Event> handlerToEvent = new HashMap<>();
            if (superclass != null) {
                CallbackInfo superInfo = getInfo(superclass);
                if (superInfo != null) {
                    handlerToEvent.putAll(superInfo.mHandlerToEvent);
                }
            }
    
            Class[] interfaces = klass.getInterfaces();
            for (Class intrfc : interfaces) {
                for (Map.Entry<MethodReference, Lifecycle.Event> entry : getInfo(
                        intrfc).mHandlerToEvent.entrySet()) {
                    verifyAndPutHandler(handlerToEvent, entry.getKey(), entry.getValue(), klass);
                }
            }
    
            // 遍历我们定义的 LifecycleObserver 实现类方法, 若带有 OnLifecycleEvent 注解,则缓存
            Method[] methods = declaredMethods != null ? declaredMethods : getDeclaredMethods(klass);
            boolean hasLifecycleMethods = false;
            for (Method method : methods) {
                OnLifecycleEvent annotation = method.getAnnotation(OnLifecycleEvent.class);
                if (annotation == null) {
                    continue;
                }
                hasLifecycleMethods = true;
                Class<?>[] params = method.getParameterTypes();
                int callType = CALL_TYPE_NO_ARG;
    
                // 自定义的方法允许带有参数,并且第一个参数类型只能是 LifecycleOwner
                if (params.length > 0) {
                    callType = CALL_TYPE_PROVIDER;
                    if (!params[0].isAssignableFrom(LifecycleOwner.class)) {
                        throw new IllegalArgumentException(
                                "invalid parameter type. Must be one and instanceof LifecycleOwner");
                    }
                }
                Lifecycle.Event event = annotation.value();
    
                // 若注解事件是 Lifecycle.Event.ON_ANY, 则还允许有第二个参数,但参数类型必须是 Lifecycle.Event
                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");
                    }
                }
    
                // 参数个数不允许超过2个
                if (params.length > 2) {
                    throw new IllegalArgumentException("cannot have more than 2 params");
                }
    
                // 若handlerToEvent中无该方法的缓存,则添加进去
                MethodReference methodReference = new MethodReference(callType, method);
                verifyAndPutHandler(handlerToEvent, methodReference, event, klass);
            }
    
            // 将搜索到的带注解事件方法列表缓存到CallbackInfo中,并返回
            CallbackInfo info = new CallbackInfo(handlerToEvent);
            // 把相关的 LifecycleObserver 类及相应注解方法都缓存到 mCallbackMap 中
            mCallbackMap.put(klass, info);
            mHasLifecycleMethods.put(klass, hasLifecycleMethods);
            return info;
        }
    
        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<>();
                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());
                }
            }
    
            @SuppressWarnings("ConstantConditions")
            void invokeCallbacks(LifecycleOwner source, Lifecycle.Event event, Object target) {
                // 调用一次对应 event 事件的注解方法,同一个event事件可能存在多个注解方法,需要遍历
                invokeMethodsForEvent(mEventToHandlers.get(event), source, event, target);
                // 任意事件都会触发一次 ON_ANY 注解方法
                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) {
                    // 遍历指定 event 事件对应的方法列表, 触发 MethodReference 的 invokeCallback(*) 方法
                    for (int i = handlers.size() - 1; i >= 0; i--) {
                        handlers.get(i).invokeCallback(source, event, mWrapped);
                    }
                }
            }
        }
    
        static class MethodReference {
            final int mCallType;
            final Method mMethod;
    
            MethodReference(int callType, Method method) {
                mCallType = callType;
                mMethod = method;
                mMethod.setAccessible(true);
            }
    
            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);
                }
            }
        }
    }
    复制代码

至此我们就知晓了 `LifecycleRegistry` 处理生命周期变化的逻辑及如何回调通知被各注解标记的方法的, 但它是如何知道 `Activity` 生命周期的? 这个我们还没有看到,下面探究下;

## `LifecycleRegistry` 如何获知 `Activity` 的生命周期变化 ##

偶然看了眼 `SupportActivity` 类的导包列表,发现 `android.arch.lifecycle` 包下除了 `ReportFragment` 类外都有分析过, 我们来看看它的作用:

package android.support.v4.app;
    
    import android.arch.lifecycle.Lifecycle;
    import android.arch.lifecycle.LifecycleOwner;
    import android.arch.lifecycle.LifecycleRegistry;
    import android.arch.lifecycle.ReportFragment;
    import android.arch.lifecycle.Lifecycle.State;
    
    @RestrictTo({Scope.LIBRARY_GROUP})
    public class SupportActivity extends Activity implements LifecycleOwner, Component {
    
        protected void onCreate(@Nullable Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            ReportFragment.injectIfNeededIn(this);
        }
    }
    复制代码

// package android.arch.lifecycle;
    // ReportFragment.java
    public class ReportFragment extends Fragment {
        private static final String REPORT_FRAGMENT_TAG = "android.arch.lifecycle"
                + ".LifecycleDispatcher.report_fragment_tag";
    
        /** * 搜索当前activity中是否已有 ReportFragment, 若无,则创建并注入 */
        public static void injectIfNeededIn(Activity 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();
            }
        }
    
        /** * 通过fragment的生命周期来获知activity的生命周期 * 然后通过 dispatch(event) 来通知各 LifecycleObserver */
        @Override
        public void onActivityCreated(Bundle savedInstanceState) {
            super.onActivityCreated(savedInstanceState);
            dispatch(Lifecycle.Event.ON_CREATE);
        }
    
        @Override
        public void onStart() {
            super.onStart();
            dispatch(Lifecycle.Event.ON_START);
        }
    
        @Override
        public void onResume() {
            super.onResume();
            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);
        }
    
        private void dispatch(Lifecycle.Event event) {
            Activity activity = getActivity();
            if (activity instanceof LifecycleRegistryOwner) {
                ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
                return;
            }
    
            // 此处就把activity的生命周期事件发送到 LifecycleRegistry 中了
            if (activity instanceof LifecycleOwner) {
                Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
                if (lifecycle instanceof LifecycleRegistry) {
                    ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
                }
            }
        }
    }
    复制代码

至此,整体流程就通了,不过我还是有点疑问,知道的童鞋可以帮忙解惑下:

1.  为何要通过注入 `Fragment` 的方式来获取 `Activity` 的生命周期, 通过 `ActivityLifecycleCallbacks` 也可以吧?
2.  为何 `ReportFragment` 是继承自已被Deprecated的 `android.app.Fragment`?
    
    整套lifecycle的实现是基于 `SupportActivity` 的, `support-fragment` 库已被导入, `injectIfNeededIn(Activity)` 参数类型不需要非得是 `Activity` 吧?

## 小结 ##

1.  `ReportFragment` 在 `SupportActivity` 创建后被注入到Activity中,作为"中介",监听 `Activity` 的生命周期变化,并把事件传递给 `LifecycleRegistry`;
2.  `LifecycleRegistry` 会弱引用其所在的 `SupportActivity`, 并管理各 `LifecycleObserver`;
3.  我们自定义的 `LifecycleObserver` 实现类, 默认会在运行时通过反射查找并缓存带有 `OnLifecycleEvent` 注解的方法;
4.  若使用 `lifeCycleCompiler` 库(`kapt("android.arch.lifecycle:compiler:1.1.1")`),则自定义的 `LifecycleObserver` 类会在编译时生成 `*_LifecycleAdapter` 类, 避免运行时反射;
5.  `LifecycleObserver` 实现类中的相关注解方法允许带有最多2个参数;

转载于:https://juejin.im/post/5ccfac6cf265da03474e1568

[demo]: https://link.juejin.im?target=https%3A%2F%2Fgithub.com%2Flucid-lynxz%2FBlogSamples%2Ftree%2Fd84d2e2288015537094ddb06623117ab122a3eb2%2FLifeCycleDemo
[Link 1]: https://link.juejin.im?target=https%3A%2F%2Fdeveloper.android.google.cn%2Ftopic%2Flibraries%2Farchitecture%2Flifecycle%23lc