• Lifecycle 一篇文章就够了

    使用篇

    引入库：

    1.     implementation "androidx.lifecycle:lifecycle-runtime:2.0.0"
    2.     implementation "androidx.lifecycle:lifecycle-extensions:2.0.0"
    3.     implementation "androidx.lifecycle:lifecycle-common-java8:2.0.0"
    4.     annotationProcessor  "androidx.lifecycle:lifecycle-compiler:2.0.0"

    创建一个观察者对象，注意一定要实现LifecycleObserver接口：

    1. package com.example.myapplication
    2.  
    3. import android.util.Log
    4. import androidx.lifecycle.Lifecycle
    5. import androidx.lifecycle.LifecycleObserver
    6. import androidx.lifecycle.OnLifecycleEvent
    7.  
    8. class MyObserver : LifecycleObserver {
    9.  
    10.     @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    11.     fun onCreate() {
    12.         Log.w(TAG, "onCreate: ")
    13.     }
    14.  
    15.     @OnLifecycleEvent(Lifecycle.Event.ON_START)
    16.     fun onStart() {
    17.         Log.w(TAG, "onStart: ")
    18.     }
    19.  
    20.     @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    21.     fun onResume() {
    22.         Log.w(TAG, "onResume: ")
    23.     }
    24.  
    25.     @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    26.     fun onPause() {
    27.         Log.w(TAG, "onPause: ")
    28.     }
    29.  
    30.     @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    31.     fun onStop() {
    32.         Log.w(TAG, "onStop: ")
    33.     }
    34.  
    35.     @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    36.     fun onDestroy() {
    37.         Log.w(TAG, "onDestroy: ")
    38.     }
    39.  
    40.     companion object {
    41.         private const val TAG = "MyObserver"
    42.     }
    43.  
    44. }

    使用：

    1. class MainActivity : AppCompatActivity() {
    2.     override fun onCreate(savedInstanceState: Bundle?) {
    3.         super.onCreate(savedInstanceState)
    4.         setContentView(R.layout.activity_main)
    5.         val observer = MyObserver()
    6.         lifecycle.addObserver(observer)
    7.     }
    8. }

    这样运行以后就可以实时观察activity的生命周期了：

    1. 2022-08-13 19:06:03.025 8263-8263/com.example.lifecycletest W/MyObserver: onCreate: 
    2. 2022-08-13 19:06:03.028 8263-8263/com.example.lifecycletest W/MyObserver: onStart: 
    3. 2022-08-13 19:06:03.030 8263-8263/com.example.lifecycletest W/MyObserver: onResume: 
    4. 2022-08-13 19:06:38.333 8263-8263/com.example.lifecycletest W/MyObserver: onPause: 
    5. 2022-08-13 19:06:38.363 8263-8263/com.example.lifecycletest W/MyObserver: onStop: 
    6. 2022-08-13 19:06:44.911 8263-8263/com.example.lifecycletest W/MyObserver: onDestroy:

    使用比较简单，下面来重点分析一下原理吧。

    原理篇

    整个使用过程非常简单，但是这个Jetpack给我们提供的生命周期监听框架的实现原理又是什么呢？今天就来一探究竟。

    我们先来看使用代码：

    1. class MainActivity : AppCompatActivity() {
    2.     override fun onCreate(savedInstanceState: Bundle?) {
    3.         super.onCreate(savedInstanceState)
    4.         setContentView(R.layout.activity_main)
    5.         val observer = MyObserver()//1
    6.         lifecycle.addObserver(observer)//2
    7.     }
    8. }

    我们先关注注释2，lifecycle点进去看看：

    1.     @NonNull
    2.     @Override
    3.     public Lifecycle getLifecycle() {
    4.         return mLifecycleRegistry;
    5.     }

    这个方法在ComponentActivity里面，而：

    • MainActivity的父类是AppCompatActivity
    • AppCompatActivity的父类是FragmentActivity
    • FragmentActivity的父类是ComponentActivity

    返回了一个mLifecycleRegistry，我们先来看下这个东西是啥？

    private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

    继续看构造方法：

    1. public LifecycleRegistry(@NonNull LifecycleOwner provider) {
    2.         this(provider, true);
    3.     }
    4.  
    5.     private LifecycleRegistry(@NonNull LifecycleOwner provider, boolean enforceMainThread) {
    6.         mLifecycleOwner = new WeakReference<>(provider);//2
    7.         mState = INITIALIZED;//1
    8.         mEnforceMainThread = enforceMainThread;
    9.     }

    这里面注意一下注释1处，对后面分析代码有用。注释2处的mLifecycleOwner就是MainActivity本身的弱引用，也是通过构造传过来的。我们接着来分析LifecycleRegistry（翻译：生命周期登记处）的addObserver方法：

    1. @Override
    2.     public void addObserver(@NonNull LifecycleObserver observer) {
    3.         enforceMainThreadIfNeeded("addObserver");
    4.         State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
    5.         ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);//1
    6.         ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);//2
    7.  
    8.         if (previous != null) {
    9.             return;
    10.         }
    11.         LifecycleOwner lifecycleOwner = mLifecycleOwner.get();//3
    12.         if (lifecycleOwner == null) {
    13.             // it is null we should be destroyed. Fallback quickly
    14.             return;
    15.         }
    16.  
    17.         boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
    18.         State targetState = calculateTargetState(observer);
    19.         mAddingObserverCounter++;
    20.         while ((statefulObserver.mState.compareTo(targetState) < 0
    21.                 && mObserverMap.contains(observer))) {
    22.             pushParentState(statefulObserver.mState);
    23.             final Event event = Event.upFrom(statefulObserver.mState);
    24.             if (event == null) {
    25.                 throw new IllegalStateException("no event up from " + statefulObserver.mState);
    26.             }
    27.             statefulObserver.dispatchEvent(lifecycleOwner, event);
    28.             popParentState();
    29.             // mState / subling may have been changed recalculate
    30.             targetState = calculateTargetState(observer);
    31.         }
    32.  
    33.         if (!isReentrance) {
    34.             // we do sync only on the top level.
    35.             sync();
    36.         }
    37.         mAddingObserverCounter--;
    38.     }

    先来看注释1处：先把observer和mState封装成一个ObserverWithState对象：

    1. static class ObserverWithState {
    2.         State mState;
    3.         LifecycleEventObserver mLifecycleObserver;
    4.  
    5.         ObserverWithState(LifecycleObserver observer, State initialState) {
    6.             mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);//1
    7.             mState = initialState;
    8.         }
    9.  
    10.         void dispatchEvent(LifecycleOwner owner, Event event) {
    11.             State newState = event.getTargetState();
    12.             mState = min(mState, newState);
    13.             mLifecycleObserver.onStateChanged(owner, event);
    14.             mState = newState;
    15.         }
    16.     }

    再进lifecycleEventobserver方法看下：

    1. @NonNull
    2.     static LifecycleEventObserver lifecycleEventObserver(Object object) {
    3.         boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
    4.         boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
    5.         if (isLifecycleEventObserver && isFullLifecycleObserver) {
    6.             return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,
    7.                     (LifecycleEventObserver) object);
    8.         }
    9.         if (isFullLifecycleObserver) {
    10.             return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
    11.         }
    12.  
    13.         if (isLifecycleEventObserver) {
    14.             return (LifecycleEventObserver) object;
    15.         }
    16.  
    17.         final Class klass = object.getClass();
    18.         int type = getObserverConstructorType(klass);
    19.         if (type == GENERATED_CALLBACK) {
    20.             Listextends GeneratedAdapter>> constructors =
    21.                     sClassToAdapters.get(klass);
    22.             if (constructors.size() == 1) {
    23.                 GeneratedAdapter generatedAdapter = createGeneratedAdapter(
    24.                         constructors.get(0), object);
    25.                 return new SingleGeneratedAdapterObserver(generatedAdapter);
    26.             }
    27.             GeneratedAdapter[] adapters = new GeneratedAdapter[constructors.size()];
    28.             for (int i = 0; i < constructors.size(); i++) {
    29.                 adapters[i] = createGeneratedAdapter(constructors.get(i), object);
    30.             }
    31.             return new CompositeGeneratedAdaptersObserver(adapters);
    32.         }
    33.         return new ReflectiveGenericLifecycleObserver(object);//走这里，看下面分析
    34.     }

    我们来看：

    1. public interface LifecycleEventObserver extends LifecycleObserver {
    2.    
    3.     void onStateChanged(@NonNull LifecycleOwner source,
    4.  @NonNull Lifecycle.Event event);
    5. }
    6.  
    7. interface FullLifecycleObserver extends LifecycleObserver {
    8.  
    9.     void onCreate(LifecycleOwner owner);
    10.  
    11.     void onStart(LifecycleOwner owner);
    12.  
    13.     void onResume(LifecycleOwner owner);
    14.  
    15.     void onPause(LifecycleOwner owner);
    16.  
    17.     void onStop(LifecycleOwner owner);
    18.  
    19.     void onDestroy(LifecycleOwner owner);
    20. }

    我们知道MyObserver类实现了LifecycleObserver接口，而LifecycleEventObserver和FullLifecycleObserver是LifecycleObserver的子接口，所以MyObserver不属于这两个接口的任何一种。我们再来关注一下这行代码：

    int type = getObserverConstructorType(klass);

    再看下调用链：

    1. private static int getObserverConstructorType(Class klass) {
    2.         Integer callbackCache = sCallbackCache.get(klass);
    3.         if (callbackCache != null) {
    4.             return callbackCache;
    5.         }
    6.         int type = resolveObserverCallbackType(klass);//一开始没有缓存，走这里
    7.         sCallbackCache.put(klass, type);
    8.         return type;
    9.     }
    10.  
    11. private static int resolveObserverCallbackType(Class klass) {
    12.         // anonymous class bug:35073837
    13.         if (klass.getCanonicalName() == null) {
    14.             return REFLECTIVE_CALLBACK;//走了这个
    15.         }
    16.  
    17.         Constructorextends GeneratedAdapter> constructor = generatedConstructor(klass);
    18.         if (constructor != null) {
    19.             sClassToAdapters.put(klass, Collections
    20.                     .extends GeneratedAdapter>>singletonList(constructor));
    21.             return GENERATED_CALLBACK;
    22.         }
    23.  
    24.         boolean hasLifecycleMethods = ClassesInfoCache.sInstance.hasLifecycleMethods(klass);
    25.         if (hasLifecycleMethods) {
    26.             return REFLECTIVE_CALLBACK;
    27.         }
    28.  
    29.         Class superclass = klass.getSuperclass();
    30.         Listextends GeneratedAdapter>> adapterConstructors = null;
    31.         if (isLifecycleParent(superclass)) {
    32.             if (getObserverConstructorType(superclass) == REFLECTIVE_CALLBACK) {
    33.                 return REFLECTIVE_CALLBACK;
    34.             }
    35.             adapterConstructors = new ArrayList<>(sClassToAdapters.get(superclass));
    36.         }
    37.  
    38.         for (Class intrface : klass.getInterfaces()) {
    39.             if (!isLifecycleParent(intrface)) {
    40.                 continue;
    41.             }
    42.             if (getObserverConstructorType(intrface) == REFLECTIVE_CALLBACK) {
    43.                 return REFLECTIVE_CALLBACK;
    44.             }
    45.             if (adapterConstructors == null) {
    46.                 adapterConstructors = new ArrayList<>();
    47.             }
    48.             adapterConstructors.addAll(sClassToAdapters.get(intrface));
    49.         }
    50.         if (adapterConstructors != null) {
    51.             sClassToAdapters.put(klass, adapterConstructors);
    52.             return GENERATED_CALLBACK;
    53.         }
    54.  
    55.         return REFLECTIVE_CALLBACK;
    56.     }
    57.  
    58. public String getCanonicalName() {
    59.         if (isArray()) {//是数组？
    60.             String canonicalName = getComponentType().getCanonicalName();
    61.             if (canonicalName != null)
    62.                 return canonicalName + "[]";
    63.             else
    64.                 return null;
    65.         }
    66.         if (isLocalOrAnonymousClass())//MyObserver是本地类
    67.             return null;
    68.         Class enclosingClass = getEnclosingClass();
    69.         if (enclosingClass == null) { // top level class
    70.             return getName();
    71.         } else {
    72.             String enclosingName = enclosingClass.getCanonicalName();
    73.             if (enclosingName == null)
    74.                 return null;
    75.             return enclosingName + "." + getSimpleName();
    76.         }
    77.     }

    一开始没有缓存，走resolveObserverCallbackType，如果是本地方法，返回

    REFLECTIVE_CALLBACK

    所以Lifecycling.lifecycleEventObserver(observer)最终会走到

    return new ReflectiveGenericLifecycleObserver(object);

    下面重点分析一下这个类（generic：通用的意思）：

    1. class ReflectiveGenericLifecycleObserver implements LifecycleEventObserver {
    2.     private final Object mWrapped;
    3.     private final CallbackInfo mInfo;
    4.  
    5.     ReflectiveGenericLifecycleObserver(Object wrapped) {
    6.         mWrapped = wrapped;
    7.         mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());
    8.     }
    9.  
    10.     @Override
    11.     public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Event event) {
    12.         mInfo.invokeCallbacks(source, event, mWrapped);
    13.     }
    14. }

    这个类实现了LifecycleEventObserver，重写了onStateChanged方法。

    先来关注一下getInfo方法：

    1. CallbackInfo getInfo(Class klass) {
    2.         CallbackInfo existing = mCallbackMap.get(klass);//下面会有存的操作
    3.         if (existing != null) {
    4.             return existing;
    5.         }
    6.         existing = createInfo(klass, null);//一开没有缓存，走这个
    7.         return existing;
    8.     }

    接着看：

    1. private CallbackInfo createInfo(Class klass, @Nullable Method[] declaredMethods) {
    2.         Class superclass = klass.getSuperclass();
    3.         Map handlerToEvent = new HashMap<>();
    4.         if (superclass != null) {
    5.             CallbackInfo superInfo = getInfo(superclass);
    6.             if (superInfo != null) {
    7.                 handlerToEvent.putAll(superInfo.mHandlerToEvent);
    8.             }
    9.         }
    10.  
    11.         Class[] interfaces = klass.getInterfaces();
    12.         for (Class intrfc : interfaces) {
    13.             for (Map.Entry entry : getInfo(
    14.                     intrfc).mHandlerToEvent.entrySet()) {
    15.                 verifyAndPutHandler(handlerToEvent, entry.getKey(), entry.getValue(), klass);
    16.             }
    17.         }
    18.  
    19.  
    20.         //获取所有MyObserver里面的方法
    21.         Method[] methods = declaredMethods != null ? declaredMethods : getDeclaredMethods(klass);
    22.         boolean hasLifecycleMethods = false;
    23.         //遍历方法
    24.         for (Method method : methods) {
    25.             //是否有OnLifecycleEvent注解
    26.             OnLifecycleEvent annotation = method.getAnnotation(OnLifecycleEvent.class);
    27.             if (annotation == null) {
    28.                 continue;
    29.             }
    30.             hasLifecycleMethods = true;
    31.             Class[] params = method.getParameterTypes();
    32.             int callType = CALL_TYPE_NO_ARG;
    33.             //参数类型集合数量 目前demo是0
    34.             if (params.length > 0) {
    35.                 callType = CALL_TYPE_PROVIDER;
    36.                 if (!params[0].isAssignableFrom(LifecycleOwner.class)) {
    37.                     throw new IllegalArgumentException(
    38.                             "invalid parameter type. Must be one and instanceof LifecycleOwner");
    39.                 }
    40.             }
    41.             Lifecycle.Event event = annotation.value();
    42.  
    43.             if (params.length > 1) {
    44.                 callType = CALL_TYPE_PROVIDER_WITH_EVENT;
    45.                 if (!params[1].isAssignableFrom(Lifecycle.Event.class)) {
    46.                     throw new IllegalArgumentException(
    47.                             "invalid parameter type. second arg must be an event");
    48.                 }
    49.                 if (event != Lifecycle.Event.ON_ANY) {
    50.                     throw new IllegalArgumentException(
    51.                             "Second arg is supported only for ON_ANY value");
    52.                 }
    53.             }
    54.             if (params.length > 2) {
    55.                 throw new IllegalArgumentException("cannot have more than 2 params");
    56.             }
    57.             //方法和参数类型封装
    58.             MethodReference methodReference = new MethodReference(callType, method);
    59.             //注解value（event）和方法引用类型放到map里面
    60.             verifyAndPutHandler(handlerToEvent, methodReference, event, klass);
    61.         }
    62.         //放到callBackInfo里面
    63.         CallbackInfo info = new CallbackInfo(handlerToEvent);
    64.         mCallbackMap.put(klass, info);//缓存 前面有取的操作
    65.         mHasLifecycleMethods.put(klass, hasLifecycleMethods);
    66.         return info;
    67.     }

    verifyAndPutHandler方法：

    1. private void verifyAndPutHandler(Map handlers,
    2.             MethodReference newHandler, Lifecycle.Event newEvent, Class klass) {
    3.         Lifecycle.Event event = handlers.get(newHandler);
    4.         if (event != null && newEvent != event) {
    5.             Method method = newHandler.mMethod;
    6.             throw new IllegalArgumentException(
    7.                     "Method " + method.getName() + " in " + klass.getName()
    8.                             + " already declared with different @OnLifecycleEvent value: previous"
    9.                             + " value " + event + ", new value " + newEvent);
    10.         }
    11.         if (event == null) {
    12.             handlers.put(newHandler, newEvent);
    13.         }
    14.     }

    一开始获取event为null，放到map里面。

    这样，lifecycle.addObserver就将MyObserver里面所有带@OnLifecycleEvent注解的方法封装到CallbackInfo里面了。但是到目前为止好像并没有看到为什么观察者MyObserver可以监听activity的生命周期。

    我们接着回到ComponentActivity的onCreate方法：

    1. @Override
    2.     protected void onCreate(@Nullable Bundle savedInstanceState) {
    3.         // Restore the Saved State first so that it is available to
    4.         // OnContextAvailableListener instances
    5.         mSavedStateRegistryController.performRestore(savedInstanceState);
    6.         mContextAwareHelper.dispatchOnContextAvailable(this);
    7.         super.onCreate(savedInstanceState);
    8.         mActivityResultRegistry.onRestoreInstanceState(savedInstanceState);
    9.         ReportFragment.injectIfNeededIn(this);//重点关注
    10.         if (mContentLayoutId != 0) {
    11.             setContentView(mContentLayoutId);
    12.         }
    13.     }

    进重点关注那个注释里面看看：

    1. @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP_PREFIX)
    2. public class ReportFragment extends android.app.Fragment {
    3.     private static final String REPORT_FRAGMENT_TAG = "androidx.lifecycle"
    4.             + ".LifecycleDispatcher.report_fragment_tag";
    5.  
    6.     public static void injectIfNeededIn(Activity activity) {
    7.         if (Build.VERSION.SDK_INT >= 29) {
    8.             // On API 29+, we can register for the correct Lifecycle callbacks directly
    9.             LifecycleCallbacks.registerIn(activity);
    10.         }
    11.         // Prior to API 29 and to maintain compatibility with older versions of
    12.         // ProcessLifecycleOwner (which may not be updated when lifecycle-runtime is updated and
    13.         // need to support activities that don't extend from FragmentActivity from support lib),
    14.         // use a framework fragment to get the correct timing of Lifecycle events
    15.         android.app.FragmentManager manager = activity.getFragmentManager();
    16.         if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
    17.             manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
    18.             // Hopefully, we are the first to make a transaction.
    19.             manager.executePendingTransactions();
    20.         }
    21.     }
    22.  
    23.     @SuppressWarnings("deprecation")
    24.     static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
    25.         if (activity instanceof LifecycleRegistryOwner) {
    26.             ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
    27.             return;
    28.         }
    29.  
    30.         if (activity instanceof LifecycleOwner) {//7
    31.             Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
    32.             if (lifecycle instanceof LifecycleRegistry) {
    33.                 ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
    34.             }
    35.         }
    36.     }
    37.  
    38.     static ReportFragment get(Activity activity) {
    39.         return (ReportFragment) activity.getFragmentManager().findFragmentByTag(
    40.                 REPORT_FRAGMENT_TAG);
    41.     }
    42.  
    43.     private ActivityInitializationListener mProcessListener;
    44.  
    45.     private void dispatchCreate(ActivityInitializationListener listener) {
    46.         if (listener != null) {
    47.             listener.onCreate();
    48.         }
    49.     }
    50.  
    51.     private void dispatchStart(ActivityInitializationListener listener) {
    52.         if (listener != null) {
    53.             listener.onStart();
    54.         }
    55.     }
    56.  
    57.     private void dispatchResume(ActivityInitializationListener listener) {
    58.         if (listener != null) {
    59.             listener.onResume();
    60.         }
    61.     }
    62.  
    63.     @Override
    64.     public void onActivityCreated(Bundle savedInstanceState) {
    65.         super.onActivityCreated(savedInstanceState);
    66.         dispatchCreate(mProcessListener);
    67.         dispatch(Lifecycle.Event.ON_CREATE);//1
    68.     }
    69.  
    70.     @Override
    71.     public void onStart() {
    72.         super.onStart();
    73.         dispatchStart(mProcessListener);
    74.         dispatch(Lifecycle.Event.ON_START);//2
    75.     }
    76.  
    77.     @Override
    78.     public void onResume() {
    79.         super.onResume();
    80.         dispatchResume(mProcessListener);
    81.         dispatch(Lifecycle.Event.ON_RESUME);//3
    82.     }
    83.  
    84.     @Override
    85.     public void onPause() {
    86.         super.onPause();
    87.         dispatch(Lifecycle.Event.ON_PAUSE);//4
    88.     }
    89.  
    90.     @Override
    91.     public void onStop() {
    92.         super.onStop();
    93.         dispatch(Lifecycle.Event.ON_STOP);//5
    94.     }
    95.  
    96.     @Override
    97.     public void onDestroy() {
    98.         super.onDestroy();
    99.         dispatch(Lifecycle.Event.ON_DESTROY);//6
    100.         // just want to be sure that we won't leak reference to an activity
    101.         mProcessListener = null;
    102.     }
    103.  
    104.     private void dispatch(@NonNull Lifecycle.Event event) {
    105.         if (Build.VERSION.SDK_INT < 29) {
    106.             // Only dispatch events from ReportFragment on API levels prior
    107.             // to API 29. On API 29+, this is handled by the ActivityLifecycleCallbacks
    108.             // added in ReportFragment.injectIfNeededIn
    109.             dispatch(getActivity(), event);
    110.         }
    111.     }
    112.  
    113.     void setProcessListener(ActivityInitializationListener processListener) {
    114.         mProcessListener = processListener;
    115.     }
    116.  
    117.     interface ActivityInitializationListener {
    118.         void onCreate();
    119.  
    120.         void onStart();
    121.  
    122.         void onResume();
    123.     }
    124.  
    125.     // this class isn't inlined only because we need to add a proguard rule for it (b/142778206)
    126.     // In addition to that registerIn method allows to avoid class verification failure,
    127.     // because registerActivityLifecycleCallbacks is available only since api 29.
    128.     @RequiresApi(29)
    129.     static class LifecycleCallbacks implements Application.ActivityLifecycleCallbacks {
    130.  
    131.         static void registerIn(Activity activity) {
    132.             activity.registerActivityLifecycleCallbacks(new LifecycleCallbacks());
    133.         }
    134.  
    135.         @Override
    136.         public void onActivityCreated(@NonNull Activity activity,
    137.                 @Nullable Bundle bundle) {
    138.         }
    139.  
    140.         @Override
    141.         public void onActivityPostCreated(@NonNull Activity activity,
    142.                 @Nullable Bundle savedInstanceState) {
    143.             dispatch(activity, Lifecycle.Event.ON_CREATE);
    144.         }
    145.  
    146.         @Override
    147.         public void onActivityStarted(@NonNull Activity activity) {
    148.         }
    149.  
    150.         @Override
    151.         public void onActivityPostStarted(@NonNull Activity activity) {
    152.             dispatch(activity, Lifecycle.Event.ON_START);
    153.         }
    154.  
    155.         @Override
    156.         public void onActivityResumed(@NonNull Activity activity) {
    157.         }
    158.  
    159.         @Override
    160.         public void onActivityPostResumed(@NonNull Activity activity) {
    161.             dispatch(activity, Lifecycle.Event.ON_RESUME);
    162.         }
    163.  
    164.         @Override
    165.         public void onActivityPrePaused(@NonNull Activity activity) {
    166.             dispatch(activity, Lifecycle.Event.ON_PAUSE);
    167.         }
    168.  
    169.         @Override
    170.         public void onActivityPaused(@NonNull Activity activity) {
    171.         }
    172.  
    173.         @Override
    174.         public void onActivityPreStopped(@NonNull Activity activity) {
    175.             dispatch(activity, Lifecycle.Event.ON_STOP);
    176.         }
    177.  
    178.         @Override
    179.         public void onActivityStopped(@NonNull Activity activity) {
    180.         }
    181.  
    182.         @Override
    183.         public void onActivitySaveInstanceState(@NonNull Activity activity,
    184.                 @NonNull Bundle bundle) {
    185.         }
    186.  
    187.         @Override
    188.         public void onActivityPreDestroyed(@NonNull Activity activity) {
    189.             dispatch(activity, Lifecycle.Event.ON_DESTROY);
    190.         }
    191.  
    192.         @Override
    193.         public void onActivityDestroyed(@NonNull Activity activity) {
    194.         }
    195.     }
    196. }

    在MainActivity里面加了一个无UI的fragment，我们这里先不分析api大于等于29的情况，以简化我们的思考。我们知道，每当activity生命周期变化时，fragment生命周期也会发生变化。然后通过注释1，2，3，4，5，6处分发事件。又因为：

    1. public class ComponentActivity extends androidx.core.app.ComponentActivity implements
    2.         ContextAware,
    3.         LifecycleOwner//1

    所以走注释7处：

    1. static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
    2.         if (activity instanceof LifecycleRegistryOwner) {
    3.             ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
    4.             return;
    5.         }
    6.  
    7.         if (activity instanceof LifecycleOwner) {//7
    8.             Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
    9.             if (lifecycle instanceof LifecycleRegistry) {
    10.                 ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
    11.             }
    12.         }
    13.     }
    1. public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
    2.         enforceMainThreadIfNeeded("handleLifecycleEvent");
    3.         moveToState(event.getTargetState());
    4.     }

    接着看：

    1. public State getTargetState() {
    2.             switch (this) {
    3.                 case ON_CREATE:
    4.                 case ON_STOP:
    5.                     return State.CREATED;
    6.                 case ON_START:
    7.                 case ON_PAUSE:
    8.                     return State.STARTED;
    9.                 case ON_RESUME:
    10.                     return State.RESUMED;
    11.                 case ON_DESTROY:
    12.                     return State.DESTROYED;
    13.                 case ON_ANY:
    14.                     break;
    15.             }
    16.             throw new IllegalArgumentException(this + " has no target state");
    17.         }

    getTargetState这个意思很明确：根据event值进行判断，返回对应状态。直接这么说可能不是很好理解，我们来看一张图（个人认为这张图在解释Lifecycle原理这块不可或缺）：

     从左向右，代表activity的正向生命周期，从右往左代表activity的反向生命周期。

    下面再来分析moveToState方法：

    1. private void moveToState(State next) {
    2.         if (mState == next) {//mState初始值为INITIALIZED，不相等，往下走
    3.             return;
    4.         }
    5.         mState = next;
    6.         if (mHandlingEvent || mAddingObserverCounter != 0) {
    7.             mNewEventOccurred = true;
    8.             // we will figure out what to do on upper level.
    9.             return;
    10.         }
    11.         mHandlingEvent = true;
    12.         sync();//1
    13.         mHandlingEvent = false;
    14.     }

    关注sync方法：

    1. private void sync() {
    2.         LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
    3.         if (lifecycleOwner == null) {
    4.             throw new IllegalStateException("LifecycleOwner of this LifecycleRegistry is already"
    5.                     + "garbage collected. It is too late to change lifecycle state.");
    6.         }
    7.         while (!isSynced()) {
    8.             mNewEventOccurred = false;
    9.             // no need to check eldest for nullability, because isSynced does it for us.
    10.             if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
    11.                 backwardPass(lifecycleOwner);
    12.             }
    13.             Map.Entry newest = mObserverMap.newest();
    14.             if (!mNewEventOccurred && newest != null
    15.                     && mState.compareTo(newest.getValue().mState) > 0) {
    16.                 forwardPass(lifecycleOwner);
    17.             }
    18.         }
    19.         mNewEventOccurred = false;
    20.     }

    我们先来看看mObserverMap是啥？

    1. private FastSafeIterableMap mObserverMap =
    2.             new FastSafeIterableMap<>();

    这个Map是以LifecycleObserver为键，以ObserverWithState为值。我们又联系到addObserver方法：

    1. @Override
    2.     public void addObserver(@NonNull LifecycleObserver observer) {
    3.         enforceMainThreadIfNeeded("addObserver");
    4.         State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
    5.         ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
    6.         ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);//1
    7.  
    8.  
    9. ···
    10. }

    我们进注释1处看看：

    1.     @Override
    2.     public V putIfAbsent(@NonNull K key, @NonNull V v) {
    3.         Entry current = get(key);
    4.         if (current != null) {
    5.             return current.mValue;
    6.         }
    7.         mHashMap.put(key, put(key, v));
    8.         return null;
    9.     }

    这个Map里面又封装了一个HashMap：

    private HashMap> mHashMap = new HashMap<>();

    我们再来分析一下：

    1. private boolean isSynced() {
    2.         if (mObserverMap.size() == 0) {
    3.             return true;
    4.         }
    5.         State eldestObserverState = mObserverMap.eldest().getValue().mState;
    6.         State newestObserverState = mObserverMap.newest().getValue().mState;
    7.         return eldestObserverState == newestObserverState && mState == newestObserverState;
    8.     }

    这个方法是什么意思呢？看代码很明显：mObserverMap里面是有数据的，而且State存的是INITIALIZED，当无UI的fragment分发事件时，mState改变。isSynced返回false。

    所以，while(true)，我们先来看正向流程：

    1.  private void forwardPass(LifecycleOwner lifecycleOwner) {
    2.         Iterator> ascendingIterator =
    3.                 mObserverMap.iteratorWithAdditions();
    4. //遍历所有观察者，demo里我们只写了一个
    5.         while (ascendingIterator.hasNext() && !mNewEventOccurred) {
    6.             Map.Entry entry = ascendingIterator.next();
    7.             //取ObserverWithState对象
    8.             ObserverWithState observer = entry.getValue();
    9.             while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
    10.                     && mObserverMap.contains(entry.getKey()))) {
    11.                 pushParentState(observer.mState);
    12.                 final Event event = Event.upFrom(observer.mState);//1
    13.                 if (event == null) {
    14.                     throw new IllegalStateException("no event up from " + observer.mState);
    15.                 }
    16.                 observer.dispatchEvent(lifecycleOwner, event);//2
    17.                 popParentState();
    18.             }
    19.         }
    20.     }

    因为是正向流程，所以是图中从左往右，看注释1处：

    1.         @Nullable
    2.         public static Event upFrom(@NonNull State state) {
    3.             switch (state) {
    4.                 case INITIALIZED:
    5.                     return ON_CREATE;
    6.                 case CREATED:
    7.                     return ON_START;
    8.                 case STARTED:
    9.                     return ON_RESUME;
    10.                 default:
    11.                     return null;
    12.             }
    13.         }

    最开始observer.mState是INITIALIZED，正向流程所以event为ON_CREATE，再来看注释2:

    1. void dispatchEvent(LifecycleOwner owner, Event event) {
    2.             State newState = event.getTargetState();
    3.             mState = min(mState, newState);
    4.             mLifecycleObserver.onStateChanged(owner, event);//1
    5.             mState = newState;
    6.         }

    获取新的state，把新的状态赋给mState。我们注意注释1，通过前面的分析我们知道：

    mLifecycleobserver其实是一个ReflectiveGenericLifecycleObserver，所以：

    1. class ReflectiveGenericLifecycleObserver implements LifecycleEventObserver {
    2.     private final Object mWrapped;
    3.     private final CallbackInfo mInfo;
    4.  
    5.     ReflectiveGenericLifecycleObserver(Object wrapped) {
    6.         mWrapped = wrapped;
    7.         mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());
    8.     }
    9.  
    10.     @Override
    11.     public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Event event) {
    12.         mInfo.invokeCallbacks(source, event, mWrapped);//1
    13.     }
    14. }

    会走到这个注释1。接着看：

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

    我们先来看看mEventToHandlers又是个啥？

    1. static class CallbackInfo {
    2.         final Map> mEventToHandlers;
    3.         final Map mHandlerToEvent;
    4.  
    5.         CallbackInfo(Map handlerToEvent) {
    6.             mHandlerToEvent = handlerToEvent;
    7.             mEventToHandlers = new HashMap<>();
    8.             for (Map.Entry entry : handlerToEvent.entrySet()) {
    9.                 Lifecycle.Event event = entry.getValue();
    10.                 List methodReferences = mEventToHandlers.get(event);
    11.                 if (methodReferences == null) {//为null
    12.                     methodReferences = new ArrayList<>();
    13.                     mEventToHandlers.put(event, methodReferences);
    14.                 }
    15.                 methodReferences.add(entry.getKey());
    16.             }
    17.         }
    18.  
    19. ···
    20. }
    1. ```
    2. MethodReference methodReference = new MethodReference(callType, method);
    3.             verifyAndPutHandler(handlerToEvent, methodReference, event, klass);
    4.         }
    5.         CallbackInfo info = new CallbackInfo(handlerToEvent);
    6. ```

    首先我们将参数类型和方法封装到MethodReference，然后将MethodReference作为键，Event作为值存到handlerToEvent这个Map里面，然后在CallbackInfo这个类构造里面遍历这个Map，然后这里面进行了一个非常骚气的操作，将event作为键，所有event对应methodReference的集合作为值存到一个新Map里面。这样做是保证了fragment分发一个event，所有观察者对应方法都会响应！

    在往下看：

    1. //List handlers 一个event事件对应的所有观察者的方法
    2.  
    3.  private static void invokeMethodsForEvent(List handlers,
    4.                 LifecycleOwner source, Lifecycle.Event event, Object mWrapped) {
    5.             if (handlers != null) {
    6.                 for (int i = handlers.size() - 1; i >= 0; i--) {
    7.                     handlers.get(i).invokeCallback(source, event, mWrapped);
    8.                 }
    9.             }
    10.         }

    继续：

    1. void invokeCallback(LifecycleOwner source, Lifecycle.Event event, Object target) {
    2.             //noinspection TryWithIdenticalCatches
    3.             try {
    4.                 switch (mCallType) {
    5.                     case CALL_TYPE_NO_ARG:
    6.                         mMethod.invoke(target);//1
    7.                         break;
    8.                     case CALL_TYPE_PROVIDER:
    9.                         mMethod.invoke(target, source);
    10.                         break;
    11.                     case CALL_TYPE_PROVIDER_WITH_EVENT:
    12.                         mMethod.invoke(target, source, event);
    13.                         break;
    14.                 }
    15.             } catch (InvocationTargetException e) {
    16.                 throw new RuntimeException("Failed to call observer method", e.getCause());
    17.             } catch (IllegalAccessException e) {
    18.                 throw new RuntimeException(e);
    19.             }
    20.         }

    我们在MyObserver里面定义的方法是无参数的，走注释1。target->mWrapped->object->observer->MyObserver。也就是调用了MyObserver对应注释的方法。到这里，Lifecycle的流程就分析完了。用起来非常简单的Jetpack框架，其原理确实相当的复杂，但是给我们带来的思考确实非常的宝贵。

  • 相关阅读:
    帆软FineReport本地部署springboot
    使用VS 不调试的情况下启动诊断工具功能 生成程序分析报告
    window环境下mysql忘记密码或者原正确密码无法登录
    ShiroFilter
    『忘了再学』Shell基础 — 31、字符处理相关命令
    stm32f4dma串口收数卡死
    Nginx安装Openresty加载Lua代码
    vue.js毕业设计，基于vue.js前后端分离订座预约系统（H5移动项目） 开题报告
    django和celery的项目，nginx和uwsgi协议，在通过api端口进行deeplearning任务的训练和排队
    如何保护 LDAP 目录服务中的用户安全？
  • 原文地址：https://blog.csdn.net/qq_36428821/article/details/126333623