<p>注：本文所有代码基于 android.arch.lifecycle 1.0.0-alpha1</p>    <p>另外，为了避免混淆，Fragment、Activity 等组件自身的生命周期直用 “生命周期” 一词，而由 <strong>Lifecycle</strong> 提供的生命周期则称为 “Lifecyle”</p>    <p>最近看到不少人讨论 Google 推的 <a href="/misc/goto?guid=4959749169673805620" rel="nofollow,noindex">Android Architecture Components</a> ，其中 <a href="/misc/goto?guid=4959749486617582349" rel="nofollow,noindex">Handling Lifecycles</a> 一章展现了如何利用 android.arch.lifecycle 包提供的类来控制数据、监听器等的 Lifecycle。同时， <a href="/misc/goto?guid=4959749258932581264" rel="nofollow,noindex">LiveData</a> 与 <a href="/misc/goto?guid=4959749486736650405" rel="nofollow,noindex">ViewModel</a> 的 Lifecycle 也依赖于 <strong>Lifecycle</strong> 框架，所以分析 <strong>Lifecyle</strong> 显然是有必要的。</p>    <p>Lifecycle到底是通过怎样的方式来绑定 Android 组件的生命周期以及如何通知 <strong>LifecycleObserver</strong> 状态变化的呢？本文将会围绕这两个问题深入分析 <strong>Lifecycle</strong> 源码。</p>    <h2>前置工作</h2>    <p>由于完整的 <strong>Lifecycle</strong> 分为 common , core , extensions , runtime 四个包，并包含 <strong>ViewModel</strong> 、 <strong>LiveData</strong> 部分内容。为了方便分析，利用 proguard(只添加 -dontobfuscate ) 剔除所有不需要用到的类。</p>    <p>最终剩下的类：</p>    <p>android.arch.core.internal（ <strong>core</strong> ）</p>    <ul>     <li>SafeIterableMap</li>    </ul>    <p>android.arch.lifecycle（ <strong>runtime</strong> ）</p>    <ul>     <li>EmptyActivityLifecycleCallbacks</li>     <li>LifecycleActivity</li>     <li>LifecycleDispatcher</li>     <li>LifecycleFragment</li>     <li>LifecycleRegistry</li>     <li>LifecycleRegistryOwner</li>     <li>LifecycleRuntimeTrojanProvider</li>     <li>LifecycleService</li>     <li>ProcessLifecycleOwner</li>     <li>ReportFragment</li>     <li>ServiceLifecycleDispatcher</li>    </ul>    <p>android.arch.lifecycle（ <strong>common</strong> ）</p>    <ul>     <li>GenericLifecycleObserver</li>     <li>Lifecycle</li>     <li>LifecycleObserver</li>     <li>LifecycleOwner</li>     <li>Lifecycling</li>     <li>OnLifecycleEvent</li>     <li>ReflectiveGenericLifecycleObserver</li>    </ul>    <h2>Runtime</h2>    <p>先看 <strong>Lifecycle</strong> 的 AndroidManifest.xml（可以在 build/outputs/logs/manifest-merger-*.txt 中找到对应的路径）：</p>    <pre>  <code class="language-java"><manifestxmlns:android="http://schemas.android.com/apk/res/android"      package="android.arch.lifecycle"      android:versionCode="1"      android:versionName="1.0" >        <uses-sdk          android:minSdkVersion="14"          android:targetSdkVersion="26" />        <application>          <provider              android:name="android.arch.lifecycle.LifecycleRuntimeTrojanProvider"              android:authorities="${applicationId}.lifecycle-trojan"              android:exported="false"              android:multiprocess="true" />      </application>    </manifest>  </code></pre>    <p>可以看到 <strong>Lifecycle</strong> 会给应用添加一个 exported="false" 的 <strong>LifecycleRuntimeTrojanProvider</strong> 。</p>    <h3>LifecycleRuntimeTrojanProvider</h3>    <pre>  <code class="language-java">/**   * Internal class to initialize Lifecycles.   * @hide   */  public class LifecycleRuntimeTrojanProviderextends ContentProvider{      @Override      public boolean onCreate(){          LifecycleDispatcher.init(getContext());          ProcessLifecycleOwner.init(getContext());          return true;      }        ...  }  </code></pre>    <p>javadoc 已经写得很明显， <strong>LifecycleRuntimeTrojanProvider</strong> 就是用于初始化 <strong>Lifecycle</strong> 的，其余 ContentProvider 应实现的方法返回的均为默认值（null 或 0），顺着代码先看 <strong>LifecycleDispatcher</strong> 。</p>    <h3>LifecycleDispatcher</h3>    <p>LifecycleDispatcher的初始化代码比较简单：</p>    <pre>  <code class="language-java">private static AtomicBoolean sInitialized = new AtomicBoolean(false);    static void init(Context context){     if (sInitialized.getAndSet(true)) {         return;     }     ((Application) context.getApplicationContext())             .registerActivityLifecycleCallbacks(new DispatcherActivityCallback());  }  </code></pre>    <p>主要就是注册了一个 ActivityLifecycleCallbacks —— <strong>DispatcherActivityCallback</strong> 。</p>    <p>DispatcherActivityCallback</p>    <pre>  <code class="language-java">static class DispatcherActivityCallbackextends EmptyActivityLifecycleCallbacks{     private final FragmentCallback mFragmentCallback;       DispatcherActivityCallback() {         mFragmentCallback = new FragmentCallback();     }       @Override     public void onActivityCreated(Activity activity, Bundle savedInstanceState){         if (activity instanceof FragmentActivity) {             ((FragmentActivity) activity).getSupportFragmentManager()                     .registerFragmentLifecycleCallbacks(mFragmentCallback, true);         }         // ProcessLifecycleOwner should always correctly work and some activities may not extend         // FragmentActivity from support lib, so we use framework fragments for activities         android.app.FragmentManager manager = activity.getFragmentManager();         if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {             manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();             // Hopefully, we are the first to make a transaction.             manager.executePendingTransactions();         }     }       @Override     public void onActivityStopped(Activity activity){         if (activity instanceof FragmentActivity) {             markState((FragmentActivity) activity, CREATED);         }     }       @Override     public void onActivitySaveInstanceState(Activity activity, Bundle outState){         if (activity instanceof FragmentActivity) {             markState((FragmentActivity) activity, CREATED);         }     }  }  </code></pre>    <p>DispatcherActivityCallback的 onActivityStopped 和 onActivitySaveInstanceState 方法会将 LifecycleRegistryOwner 的状态重置成 CREATED （为何是 CREATED 可以查看 <a href="/misc/goto?guid=4959749486822533409" rel="nofollow,noindex">Lifecycle 的状态图</a> 及 <a href="/misc/goto?guid=4959749486909232187" rel="nofollow,noindex">各状态的描述</a> ）。再看 onActivityCreated ，当 activity 是 FragmentActivity 时，额外注册 FragmentLifecycleCallbacks —— <strong>FragmentCallback</strong> 。接着添加 <strong>ReportFragment</strong> 到 activity 中，考虑到并不是所有人都会使用 FragmentActivity，所以添加 <strong>ReportFragment</strong> 时使用的是原生的 FragmentManager。</p>    <p>ReportFragment</p>    <p>接着来看一下 <strong>ReportFragment</strong> 的源码：</p>    <pre>  <code class="language-java">public class ReportFragmentextends Fragment{        private ActivityInitializationListener mProcessListener;        private void dispatchCreate(ActivityInitializationListener listener){          if (listener != null) {              listener.onCreate();          }      }        private void dispatchStart(ActivityInitializationListener listener){          if (listener != null) {              listener.onStart();          }      }        private void dispatchResume(ActivityInitializationListener listener){          if (listener != null) {              listener.onResume();          }      }        @Override      public void onActivityCreated(Bundle savedInstanceState){          super.onActivityCreated(savedInstanceState);          dispatchCreate(mProcessListener);          dispatch(Lifecycle.Event.ON_CREATE);      }        @Override      public void onStart(){          super.onStart();          dispatchStart(mProcessListener);          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);          // just want to be sure that we won't leak reference to an activity          mProcessListener = null;      }        private void dispatch(Lifecycle.Event event){          if (getActivity() instanceof LifecycleRegistryOwner) {              ((LifecycleRegistryOwner) getActivity()).getLifecycle().handleLifecycleEvent(event);          }      }        void setProcessListener(ActivityInitializationListener processListener){          mProcessListener = processListener;      }        interface ActivityInitializationListener{          void onCreate();            void onStart();            void onResume();      }  }  </code></pre>    <p>不难看出 <strong>ReportFragment</strong> 主要是在所有生命周期发生变化时生成对应的 Lifecycle 事件发送到 LifecycleRegistryOwner（Activity）中。并在 onActivityCreated , onStart , onResume 时额外通知 <strong>ActivityInitializationListener</strong> （暂且记住，后面会用到）。可能会有读者有疑问，为什么要使用 <strong>ReportFragment</strong> 的生命周期而不直接使用 ActivityLifecycleCallbacks 的回调来处理 Lifecycle 的变化？由于 ActivityLifecycleCallbacks 的回调比 Fragment 和 Activity 还要早，实际上未真正执行对应的生命周期方法。至于为什么用 Fragment 而不直接重载 Activity 的生命周期，显然用 Fragment 侵入性低。</p>    <p>FragmentCallback</p>    <p>再看回 <strong>FragmentCallback</strong> ：</p>    <pre>  <code class="language-java">static class FragmentCallbackextends FragmentManager.FragmentLifecycleCallbacks{       @Override     public void onFragmentCreated(FragmentManager fm, Fragment f, Bundle savedInstanceState){         dispatchIfLifecycleOwner(f, ON_CREATE);           if (!(f instanceof LifecycleRegistryOwner)) {             return;         }           if (f.getChildFragmentManager().findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {             f.getChildFragmentManager().beginTransaction().add(new DestructionReportFragment(),                     REPORT_FRAGMENT_TAG).commit();         }     }       @Override     public void onFragmentStarted(FragmentManager fm, Fragment f){         dispatchIfLifecycleOwner(f, ON_START);     }       @Override     public void onFragmentResumed(FragmentManager fm, Fragment f){         dispatchIfLifecycleOwner(f, ON_RESUME);     }  }  </code></pre>    <p>与 <strong>DispatcherActivityCallback</strong> 类似，当 Fragment 为 Parent Fragment 且实现了 LifecycleRegistryOwner 接口时，FragmentCallback 会添加一个 Child Fragment —— <strong>DestructionReportFragment</strong> 。</p>    <pre>  <code class="language-java">public static class DestructionReportFragmentextends Fragment{     @Override     public void onPause(){         super.onPause();         dispatch(ON_PAUSE);     }       @Override     public void onStop(){         super.onStop();         dispatch(ON_STOP);     }       @Override     public void onDestroy(){         super.onDestroy();         dispatch(ON_DESTROY);     }       protected void dispatch(Lifecycle.Event event){         dispatchIfLifecycleOwner(getParentFragment(), event);     }  }    private static void dispatchIfLifecycleOwner(Fragment fragment, Lifecycle.Event event){     if (fragment instanceof LifecycleRegistryOwner) {         ((LifecycleRegistryOwner) fragment).getLifecycle().handleLifecycleEvent(event);     }  }  </code></pre>    <p>与 <strong>DispatcherActivityCallback</strong> 不一样的是， <strong>FragmentCallback</strong> 混合了 FragmentLifecycleCallbacks 及 Fragment 的生命周期来通知 Child Fragment Lifecycle 发生变化。这样做是为了确保 ON_CREATE , ON_START , ON_RESUME 在对应的生命周期之后分发， ON_PAUSE , ON_STOP , ON_DESTROY 在对应的生命周期之前分发。</p>    <p>所以 <strong>FragmentCallback</strong> 主要是通知 Parent Fragment（LifecycleRegistryOwner）Lifecycle 发生变化，从而给 Child Fragment（LifecycleObserver）分发 Lifecycle 事件。</p>    <p>值得注意的是，由于 FragmentLifecycleCallbacks 只存在于 v4 包中，如果 Child 是 android.app.Fragment，即使 Child 通过 ((LifecycleRegistryOwner) getParentFragment()).getLifecycle().addObserver(this) 注册了监听也不会接收到相关的 Lifecycle 事件，因为 LifecycleRegistryOwner 的 handleLifecycleEvent 从未被调用过。（暂时未知 Google 是有意为之，抑或是个 BUG。）</p>    <h3>ProcessLifecycleOwner</h3>    <p>看完 <strong>LifecycleDispatcher</strong> ，接着来了解一下 <strong>ProcessLifecycleOwner</strong> ：</p>    <pre>  <code class="language-java">public class ProcessLifecycleOwnerimplements LifecycleOwner{        @VisibleForTesting      static final long TIMEOUT_MS = 700; //mls        // ground truth counters      private int mStartedCounter = 0;      private int mResumedCounter = 0;        private boolean mPauseSent = true;      private boolean mStopSent = true;        private Handler mHandler;      private final LifecycleRegistry mRegistry = new LifecycleRegistry(this);        private Runnable mDelayedPauseRunnable = new Runnable() {          @Override          public void run(){              dispatchPauseIfNeeded();              dispatchStopIfNeeded();          }      };        private ActivityInitializationListener mInitializationListener =              new ActivityInitializationListener() {                  @Override                  public void onCreate(){                  }                    @Override                  public void onStart(){                      activityStarted();                  }                    @Override                  public void onResume(){                      activityResumed();                  }              };        private static final ProcessLifecycleOwner sInstance = new ProcessLifecycleOwner();        public staticLifecycleOwnerget(){          return sInstance;      }        static void init(Context context){          sInstance.attach(context);      }        void activityStarted(){          mStartedCounter++;          if (mStartedCounter == 1 && mStopSent) {              mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);              mStopSent = false;          }      }        void activityResumed(){          mResumedCounter++;          if (mResumedCounter == 1) {              if (mPauseSent) {                  mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);                  mPauseSent = false;              } else {                  mHandler.removeCallbacks(mDelayedPauseRunnable);              }          }      }        void activityPaused(){          mResumedCounter--;          if (mResumedCounter == 0) {              mHandler.postDelayed(mDelayedPauseRunnable, TIMEOUT_MS);          }      }        void activityStopped(){          mStartedCounter--;          dispatchStopIfNeeded();      }        private void dispatchPauseIfNeeded(){          if (mResumedCounter == 0) {              mPauseSent = true;              mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);          }      }        private void dispatchStopIfNeeded(){          if (mStartedCounter == 0 && mPauseSent) {              mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);              mStopSent = true;          }      }        private ProcessLifecycleOwner(){      }        void attach(Context context){          mHandler = new Handler();          mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);          Application app = (Application) context.getApplicationContext();          app.registerActivityLifecycleCallbacks(new EmptyActivityLifecycleCallbacks() {              @Override              public void onActivityCreated(Activity activity, Bundle savedInstanceState){                  LifecycleDispatcher.get(activity).setProcessListener(mInitializationListener);              }                @Override              public void onActivityPaused(Activity activity){                  activityPaused();              }                @Override              public void onActivityStopped(Activity activity){                  activityStopped();              }          });      }        @Override      publicLifecyclegetLifecycle(){          return mRegistry;      }  }  </code></pre>    <p>比起 <strong>LifecycleDispatcher</strong> ， <strong>ProcessLifecycleOwner</strong> 的代码要简单得多。 <strong>ProcessLifecycleOwner</strong> 的作用就是监听当前进程中 Activity 的状态变化以统计 Activity 的数量从而通知 LifecycleObserver Lifecycle 发生变化。</p>    <p>而为了达到这一目的， <strong>ProcessLifecycleOwner</strong> 的做法是为 <strong>LifecycleDispatcher</strong> 注册 <strong>ActivityInitializationListener</strong> 从而确保 Activity 进入了 onStart 或 onResume 生命周期（还记得前面 <strong>ReportFragment</strong> 提到的这部分内容？），并配合 ActivityLifecycleCallbacks 的 onActivityPaused , onActivityStopped 确保 Lifecycle 事件发生在 Activity 的 onPause , onStop 之前。</p>    <p>另外，由于 <strong>ProcessLifecycleOwner</strong> 没有 ON_DESTROY ，接收到 ON_STOP 时已经表示当前进程无存活的 Activity。同时需注意一点： <strong>ProcessLifecycleOwner</strong> 的统计不包含 Service，换句话说，即使接收到 ON_STOP 事件，并不意味着当前进程结束。</p>    <h3>LifecycleService</h3>    <p>了解完 Lifecycle 框架中 Activity、Fragment 相关的生命周期事件是如何生成的，接下来就看看 Service 相关的生命周期事件是如何生成的。</p>    <pre>  <code class="language-java">public class LifecycleServiceextends Serviceimplements LifecycleOwner{        private final ServiceLifecycleDispatcher mDispatcher = new ServiceLifecycleDispatcher(this);        @CallSuper      @Override      public void onCreate(){          mDispatcher.onServicePreSuperOnCreate();          super.onCreate();      }        @CallSuper      @Nullable      @Override      publicIBinderonBind(Intent intent){          mDispatcher.onServicePreSuperOnBind();          return null;      }        @SuppressWarnings("deprecation")      @CallSuper      @Override      public void onStart(Intent intent,intstartId){          mDispatcher.onServicePreSuperOnStart();          super.onStart(intent, startId);      }        @CallSuper      @Override      public int onStartCommand(Intent intent,intflags,intstartId){          return super.onStartCommand(intent, flags, startId);      }        @CallSuper      @Override      public void onDestroy(){          mDispatcher.onServicePreSuperOnDestroy();          super.onDestroy();      }        @Override      publicLifecyclegetLifecycle(){          return mDispatcher.getLifecycle();      }  }  </code></pre>    <pre>  <code class="language-java">public class ServiceLifecycleDispatcher{      private final LifecycleRegistry mRegistry;      private final Handler mHandler;      private DispatchRunnable mLastDispatchRunnable;        public ServiceLifecycleDispatcher(@NonNull LifecycleOwner provider){          mRegistry = new LifecycleRegistry(provider);          mHandler = new Handler();      }        private void postDispatchRunnable(Lifecycle.Event event){          if (mLastDispatchRunnable != null) {              mLastDispatchRunnable.run();          }          mLastDispatchRunnable = new DispatchRunnable(mRegistry, event);          mHandler.postAtFrontOfQueue(mLastDispatchRunnable);      }        public void onServicePreSuperOnCreate(){          postDispatchRunnable(Lifecycle.Event.ON_CREATE);      }        public void onServicePreSuperOnBind(){          postDispatchRunnable(Lifecycle.Event.ON_START);      }        public void onServicePreSuperOnStart(){          postDispatchRunnable(Lifecycle.Event.ON_START);      }        public void onServicePreSuperOnDestroy(){          postDispatchRunnable(Lifecycle.Event.ON_STOP);          postDispatchRunnable(Lifecycle.Event.ON_DESTROY);      }        publicLifecyclegetLifecycle(){          return mRegistry;      }        static class DispatchRunnableimplements Runnable{          private final LifecycleRegistry mRegistry;          final Lifecycle.Event mEvent;          private boolean mWasExecuted = false;            DispatchRunnable(@NonNull LifecycleRegistry registry, Lifecycle.Event event) {              mRegistry = registry;              mEvent = event;          }            @Override          public void run(){              if (!mWasExecuted) {                  mRegistry.handleLifecycleEvent(mEvent);                  mWasExecuted = true;              }          }      }  }  </code></pre>    <p>ServiceLifecycleDispatcher用于协助 <strong>LifecycleService</strong> 分发 Lifecycle 事件并确保每次发生变化时回调执行于 Worker Thread。同时我们可以看到 <strong>LifecycleService</strong> 只会产生 ON_CREATE , ON_START , ON_STOP , ON_DESTROY 四种事件。</p>    <p>需注意的是继承 <strong>LifecycleService</strong> 时如需重写 onStart 或 onStartCommand 方法，必须调用 super.onStart 或 super.onStartCommand 以确保 ON_START 事件能够被触发。</p>    <h3>小结</h3>    <p>至此，我们了解到 <strong>Lifecycle</strong> 框架是如何将 Lifecycle 事件与 Android 组件的生命周期绑定的：</p>    <ul>     <li><strong>LifecycleDispatcher</strong> ，通过 ActivityLifecycleCallbacks、FragmentLifecycleCallbacks 及 Fragment 获知 Activity、Fragment 的生命周期变化并产生相应的 Lifecycle 事件；</li>     <li><strong>ProcessLifecycleOwner</strong> ，通过 ActivityLifecycleCallbacks 与 <strong>LifecycleDispatcher</strong> 配合监听当前进程中 Activities 的生命周期变化并在必要时产生相应的 Lifecycle 事件；</li>     <li><strong>LifecycleService</strong> ，通过重载 Service 的生命周期方法并在相应方法内产生相应的 Lifecycle 事件。</li>    </ul>    <h2>Common</h2>    <h3>LifecycleRegistry 的 addObserver 流程</h3>    <p>我们使用的 LifecycleActivity 以及 LifecycleFragment 内部都是通过 <strong>LifecycleRegistry</strong> 来管理及分发 Lifecycle 事件。</p>    <p>先了解下 <strong>LifecycleRegistry</strong> 中 addObserver 的内部逻辑：</p>    <pre>  <code class="language-java">private SafeIterableMap<LifecycleObserver, ObserverWithState> mObserverSet =         new SafeIterableMap<>();    @Override  public void addObserver(LifecycleObserver observer){     ObserverWithState observerWithState = new ObserverWithState(observer);     mObserverSet.putIfAbsent(observer, observerWithState);     observerWithState.sync();  }  </code></pre>    <pre>  <code class="language-java">class ObserverWithState{     private State mObserverCurrentState = INITIALIZED;     private GenericLifecycleObserver mCallback;       ObserverWithState(LifecycleObserver observer) {         mCallback = Lifecycling.getCallback(observer);     }       ...  }  </code></pre>    <p>在调用 <strong>LifecycleRegistry</strong> 的 addObserver 方法时，LifecycleObserver 被传至 <strong>ObserverWithState</strong> 并通过 Lifecycling.getCallback(observer) 生成 <strong>GenericLifecycleObserver</strong> 。</p>    <p>Lifecycling</p>    <pre>  <code class="language-java">@NonNull  staticGenericLifecycleObservergetCallback(Object object){     if (object instanceof GenericLifecycleObserver) {         return (GenericLifecycleObserver) object;     }     ... // try         final Class<?> klass = object.getClass();         Constructor<? extends GenericLifecycleObserver> cachedConstructor;         ... // 缓存部分         cachedConstructor = getGeneratedAdapterConstructor(klass);         if (cachedConstructor != null) {             sCallbackCache.put(klass, cachedConstructor);             if (!cachedConstructor.isAccessible()) {                 cachedConstructor.setAccessible(true);             }             return cachedConstructor.newInstance(object);         } else {             sCallbackCache.put(klass, sREFLECTIVE);         }         return new ReflectiveGenericLifecycleObserver(object);     ... // catch  }  </code></pre>    <p>当调用 getCallback 时， <strong>Lifecycling</strong> 会根据传入的 Object（LifecycleObserver）调用 getGeneratedAdapterConstructor 。</p>    <p>LifecycleAdapter 的实例化</p>    <pre>  <code class="language-java">@Nullable  private static Constructor<? extends GenericLifecycleObserver> getGeneratedAdapterConstructor(         Class<?> klass) {     final String fullPackage = klass.getPackage().getName();       String name = klass.getCanonicalName();     // anonymous class bug:35073837     if (name == null) {         return null;     }     final String adapterName = getAdapterName(fullPackage.isEmpty() ? name :             name.substring(fullPackage.length() + 1));     try {         @SuppressWarnings("unchecked")         final Class<? extends GenericLifecycleObserver> aClass =                 (Class<? extends GenericLifecycleObserver>) Class.forName(                         fullPackage.isEmpty() ? adapterName : fullPackage + "." + adapterName);         return aClass.getDeclaredConstructor(klass);     } catch (ClassNotFoundException e) {         final Class<?> superclass = klass.getSuperclass();         if (superclass != null) {             return getGeneratedAdapterConstructor(superclass);         }     } catch (NoSuchMethodException e) {         // this should not happen         throw new RuntimeException(e);     }     return null;  }    staticStringgetAdapterName(String className){     return className.replace(".", "_") + "_LifecycleAdapter";  }  </code></pre>    <p>不难看出， getGeneratedAdapterConstructor 主要是获取 annotationProcessor 生成的 <strong>xxx_LifecycleAdapter</strong> （关于 <strong>LifecycleAdapter</strong> 后面补充说明）的构造函数，并实例化返回到 getCallback 中。需注意的是，如果找不到 <strong>LifecycleAdapter</strong> 且 object(LifecycleObserver) 存在父类时会试图获取父类的 <strong>LifecycleAdapter</strong> （估计是为了应对混淆时只混淆了子类的情况）。</p>    <p>ReflectiveGenericLifecycleObserver 的实例化</p>    <p>当获取 <strong>LifecycleAdapter</strong> 失败后， <strong>Lifecycling</strong> 会直接实例化 <strong>ReflectiveGenericLifecycleObserver</strong> 作为替代（估计也是为了应对混淆）。</p>    <pre>  <code class="language-java">class ReflectiveGenericLifecycleObserverimplements GenericLifecycleObserver{      private final Object mWrapped;      private final CallbackInfo mInfo;      @SuppressWarnings("WeakerAccess")      static final Map<Class, CallbackInfo> sInfoCache = new HashMap<>();        ReflectiveGenericLifecycleObserver(Object wrapped) {          mWrapped = wrapped;          mInfo = getInfo(mWrapped.getClass());      }            ...        private staticCallbackInfogetInfo(Class klass){          CallbackInfo existing = sInfoCache.get(klass);          if (existing != null) {              return existing;          }          existing = createInfo(klass);          return existing;      }            ...  }  </code></pre>    <p>ReflectiveGenericLifecycleObserver在实例化时会获取 Object（LifecycleObserver）的 class 并作为参数调用 createInfo 方法。</p>    <pre>  <code class="language-java">private staticCallbackInfocreateInfo(Class klass){     Method[] methods = klass.getDeclaredMethods();     List<MethodReference> methodReferences = null;     Set<Event> allEvents = new HashSet<>();     for (Method method : methods) {         OnLifecycleEvent annotation = method.getAnnotation(OnLifecycleEvent.class);         if (annotation == null) {             continue;         }         Class<?>[] params = method.getParameterTypes();         int callType = CALL_TYPE_NO_ARG;         if (params.length > 0) {             callType = CALL_TYPE_PROVIDER;             // 有参第一个参数必须为 LifecycleOwner             if (!params[0].isAssignableFrom(LifecycleOwner.class)) {                 throw new IllegalArgumentException(                         "invalid parameter type. Must be one and instanceof LifecycleOwner");             }         }         if (params.length > 1) {             callType = CALL_TYPE_PROVIDER_WITH_EVENT;             // 有两个参数时第二个参数必须为 Event             if (!params[1].isAssignableFrom(Event.class)) {                 throw new IllegalArgumentException(                         "invalid parameter type. second arg must be an event");             }         }         if (params.length > 2) {             // 最多只能有两个参数             throw new IllegalArgumentException("cannot have more than 2 params");         }         if (methodReferences == null) {             methodReferences = new ArrayList<>();         }         // 获取应该执行回调的事件集         Set<Event> events = expandOnAnyEvents(annotation.value());         methodReferences.add(new MethodReference(events, callType, method));         allEvents.addAll(events);     }     CallbackInfo info = new CallbackInfo(allEvents, methodReferences);     sInfoCache.put(klass, info);     Class superclass = klass.getSuperclass();     if (superclass != null) {         // 获取父类中带 OnLifecycleEvent 注解的方法集及事件集等         info.mSuper = getInfo(superclass);     }     Class[] interfaces = klass.getInterfaces();     // 获取接口中带 OnLifecycleEvent 注解的方法集及事件集等     for (Class intrfc : interfaces) {         CallbackInfo interfaceInfo = getInfo(intrfc);         if (!interfaceInfo.mEvents.isEmpty()) {             if (info.mInterfaces == null) {                 info.mInterfaces = new ArrayList<>();             }             info.mInterfaces.add(interfaceInfo);         }     }     return info;  }    @SuppressWarnings("WeakerAccess")  static class CallbackInfo{     final Set<Event> mEvents;     @Nullable     List<MethodReference> mMethodReferences;     @Nullable     List<CallbackInfo> mInterfaces;     @Nullable     CallbackInfo mSuper;       CallbackInfo(Set<Event> events, @Nullable List<MethodReference> methodReferences) {         mEvents = events;         mMethodReferences = methodReferences;     }  }    @SuppressWarnings("WeakerAccess")  static class MethodReference{     final Set<Event> mEvents;     final int mCallType;     final Method mMethod;       MethodReference(Set<Event> events, int callType, Method method) {         mEvents = events;         mCallType = callType;         mMethod = method;         mMethod.setAccessible(true);     }  }    private staticSet<Event>expandOnAnyEvents(Event[] events){     boolean hasOnAllEvents = false;     for (Event e: events) {         if (e == Event.ON_ANY) {             hasOnAllEvents = true;             break;         }     }       if (!hasOnAllEvents) {         HashSet<Event> set = new HashSet<>();         Collections.addAll(set, events);         return set;     } else {         return ALL_EVENTS;     }  }    private static final Set<Event> ALL_EVENTS = new HashSet<Event>() {     {         add(Event.ON_CREATE);         add(Event.ON_START);         add(Event.ON_RESUME);         add(Event.ON_PAUSE);         add(Event.ON_STOP);         add(Event.ON_DESTROY);     }  };    private static final int CALL_TYPE_NO_ARG = 0;  private static final int CALL_TYPE_PROVIDER = 1;  private static final int CALL_TYPE_PROVIDER_WITH_EVENT = 2;  </code></pre>    <p>不难看出 createInfo 主要是获取所有带 OnLifecycleEvent 注解的方法，在判断这些方法的合法性后，根据对应方法的参数个数、事件类型及方法名实例化 <strong>MethodReference</strong> 并添加到 List 中，同时亦会将 Object(LifecycleObserver) 涉及的所有事件类型保存到 Set 中。当遍历完 Object(LifecycleObserver) 定义的所有方法后，会根据 List 和 Set 实例化 <strong>CallbackInfo</strong> 并缓存至 <em>sInfoCache</em> 中。最后对 Object(LifecycleObserver) 的父类和接口执行同样的操作（即以它们作为参数传入 createInfo 中），并将返回的 <strong>CallbackInfo</strong> 分别赋值给 info.mSuper 和 info.mInterfaces 供后面使用。</p>    <p>ObserverWithState 的 sync 流程</p>    <p>在 <strong>GenericLifecycleObserver</strong> 的实例化完成后， addObserver 会调用 <strong>ObserverWithState</strong> 的 sync 方法：</p>    <pre>  <code class="language-java">observerWithState.sync();    void sync(){    if (mState == DESTROYED && mObserverCurrentState == INITIALIZED) {        mObserverCurrentState = DESTROYED;    }    while (mObserverCurrentState != mState) {        Event event = mObserverCurrentState.isAtLeast(mState)                ? downEvent(mObserverCurrentState) : upEvent(mObserverCurrentState);        mObserverCurrentState = getStateAfter(event);        mCallback.onStateChanged(mLifecycleOwner, event);    }  }  </code></pre>    <p>其中 mState 表示的是 <strong>LifecycleRegistry</strong> 当前所处的状态。</p>    <p>如果当前 <strong>LifecycleRegistry</strong> 处于 DESTROYED ， <strong>ObserverWithState</strong> 处于 INITIALIZED 时， <strong>ObserverWithState</strong> 会直接进入 DESTROYED ，并且此时 LifecycleObserver 不会收到任何回调。</p>    <p>当 <strong>ObserverWithState</strong> 与 <strong>LifecycleRegistry</strong> 的状态不相同时， <strong>ObserverWithState</strong> 会通过 mObserverCurrentState.isAtLeast(mState) 比较自身状态是高于或低于 <strong>LifecycleRegistry</strong> 的状态。状态的高低顺序（升序）如下：</p>    <pre>  <code class="language-java">public enum State {     DESTROYED,     INITIALIZED,     CREATED,     STARTED,     RESUMED;     public boolean isAtLeast(State state){         return compareTo(state) >= 0;     }  }  </code></pre>    <p>当 <strong>ObserverWithState</strong> 的状态高于或低于 <strong>LifecycleRegistry</strong> 时，会分别调用 downEvent 或 upEvent 决定 LifecycleObserver 的下一个 Lifecycle 事件：</p>    <pre>  <code class="language-java">staticEventdownEvent(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);  }    staticEventupEvent(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);  }  </code></pre>    <p>紧接着 <strong>ObserverWithState</strong> 会将获得的事件类型传入 getStateAfter 中获取新的状态：</p>    <pre>  <code class="language-java">staticStategetStateAfter(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);  }  </code></pre>    <p>如果修改完状态后 <strong>ObserverWithState</strong> 与 <strong>LifecycleRegistry</strong> 的状态依然不相同，上述过程会一直重复执行直到相同为止。例如，当 <strong>LifecycleRegistry</strong> 处于 RESUMED 而 <strong>ObserverWithState</strong> 处于 INITIALIZED 时， <strong>ObserverWithState</strong> 的状态会按照 INITIALIZED -> CREATED -> STARTED -> RESUMED 这样的顺序变迁。</p>    <p>下面再来了解下每次状态变迁之后调用的 OnStateChanged 方法内部做了些什么。</p>    <p>从前面 <strong>GenericLifecycleObserver</strong> 的生成过程中我们可以知道，这里的分析也需要分为两种情况分析：</p>    <ul>     <li>LifecycleAdapter</li>     <li>ReflectiveGenericLifecycleObserver</li>    </ul>    <p>LifecycleAdapter</p>    <p>由于没有找到 <strong>LifecycleProcessor</strong> 的源码，这里我就写了个 DataObserver 来让各位稍微了解一下 <strong>LifecycleAdapter</strong> ：</p>    <pre>  <code class="language-java">public class DataObserverimplements LifecycleObserver{        @OnLifecycleEvent(Lifecycle.Event.ON_ANY)      public void onAny(){      }        @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)      public void onCreate(){      }        @OnLifecycleEvent(Lifecycle.Event.ON_START)      public void onStart(){      }        @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)      public void onResume(){      }        @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)      public void onPause(){      }        @OnLifecycleEvent(Lifecycle.Event.ON_STOP)      public void onStop(){      }        @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)      public void onDestroy(){      }  }  </code></pre>    <pre>  <code class="language-java">public class DataObserver_LifecycleAdapterimplements GenericLifecycleObserver{    final DataObserver mReceiver;      DataObserver_LifecycleAdapter(DataObserver receiver) {      this.mReceiver = receiver;    }      @Override    public void onStateChanged(LifecycleOwner owner, Lifecycle.Event event){      mReceiver.onAny();      if (event == Lifecycle.Event.ON_CREATE) {        mReceiver.onCreate();      }      if (event == Lifecycle.Event.ON_START) {        mReceiver.onStart();      }      if (event == Lifecycle.Event.ON_RESUME) {        mReceiver.onResume();      }      if (event == Lifecycle.Event.ON_PAUSE) {        mReceiver.onPause();      }      if (event == Lifecycle.Event.ON_STOP) {        mReceiver.onStop();      }      if (event == Lifecycle.Event.ON_DESTROY) {        mReceiver.onDestroy();      }    }      publicObjectgetReceiver(){      return mReceiver;    }  }  </code></pre>    <p>从 DataObserver_LifecycleAdapter 中可以大概猜测到， <strong>LifecycleProcessor</strong> 生成的 <strong>LifecycleAdapter</strong> 会根据 LifecycleObserver 中带 OnLifecycleEvent 注解的方法生成 onStateChanged 。</p>    <p>从上面的代码不难看出， <strong>LifecycleAdapter</strong> 的 onStateChanged 会根据不同的事件分别执行 LifecycleObserver 中对应的方法。</p>    <p>ReflectiveGenericLifecycleObserver</p>    <p>当 Lifecycle 发生变化调用 onStateChanged 时：</p>    <pre>  <code class="language-java">@Override  public void onStateChanged(LifecycleOwner source, Event event){     invokeCallbacks(mInfo, source, event);  }    @SuppressWarnings("ConstantConditions")  private void invokeCallbacks(CallbackInfo info, LifecycleOwner source, Event event){     // 当前 ReflectiveGenericLifecycleObserver 有无该事件的相关注解     if (info.mEvents.contains(event)) {         for (int i = info.mMethodReferences.size() - 1; i >= 0; i--) {             MethodReference reference = info.mMethodReferences.get(i);             invokeCallback(reference, source, event);         }     }     // TODO prevent duplicate calls into the same method. Preferably while parsing     if (info.mSuper != null) {         // 交由此前传入的 LifecycleObserver 的父类处理         invokeCallbacks(info.mSuper, source, event);     }     if (info.mInterfaces != null) {         final int size = info.mInterfaces.size();         for (int i = 0; i < size; i++) {             // 交由此前传入的 LifecycleObserver 的接口处理             invokeCallbacks(info.mInterfaces.get(i), source, event);         }     }  }    private void invokeCallback(MethodReference reference, LifecycleOwner source, Event event){     // MethodReference 是否包含该事件     if (reference.mEvents.contains(event)) {         try {             switch (reference.mCallType) {                 case CALL_TYPE_NO_ARG:                     reference.mMethod.invoke(mWrapped);                     break;                 case CALL_TYPE_PROVIDER:                     reference.mMethod.invoke(mWrapped, source);                     break;                 case CALL_TYPE_PROVIDER_WITH_EVENT:                     reference.mMethod.invoke(mWrapped, source, event);                     break;             }         } catch (InvocationTargetException e) {             throw new RuntimeException("Failed to call observer method", e.getCause());         } catch (IllegalAccessException e) {             throw new RuntimeException(e);         }     }  }  </code></pre>    <p>ReflectiveGenericLifecycleObserver会判断接收到的事件是否存在于 createInfo 生成的 mInfo 中的事件集之中。当存在时，会遍历此前缓存的方法列表并由 <strong>MethodReference</strong> 判断是否处理该事件。当需要处理时，会根据此前得到的 callType 决定传递哪些参数。同样的，在处理完 class（LifecycleObserver） 自身定义的方法后，会将事件分发给父类和接口的 <strong>MethodReference</strong> 处理。</p>    <p>小结</p>    <p>所以 sync 方法的用途是使 LifecycleObserver 的状态与 LifecycleRegistry 的状态同步并通知 LifecycleObserver 状态已经发生变化。</p>    <p>至此， addObserver 完成了自身的工作。</p>    <h3>handleLifecycleEvent 流程</h3>    <p>从 <strong>ServiceLifecycleDispatcher</strong> , <strong>LifecycleDispatcher</strong> 等的源码我们可以看出所有 Lifecycle 事件都是通过 <strong>LifecycleRegistry</strong> 的 handleLifecycleEvent 来处理：</p>    <pre>  <code class="language-java">public void handleLifecycleEvent(Lifecycle.Event event){     if (mLastEvent == event) {         return;     }     mLastEvent = event;     mState = getStateAfter(event);     for (Map.Entry<LifecycleObserver, ObserverWithState> entry : mObserverSet) {         entry.getValue().sync();     }  }  </code></pre>    <p>有了前面的经验，我们就能很容易地知道当 Lifecycle 发生变化时， handleLifecycleEvent<br> 会通过 getStateAfter 获取当前应处的状态并修改 mState 值，紧接着遍历所有 <strong>ObserverWithState</strong> 并调用他们的 sync 方法来同步且通知 LifecycleObserver 状态发生变化。</p>    <h3>小结</h3>    <p>至此，我们了解到当 <strong>LifecycleRegistry</strong> 的 addObserver 或 handleLifecycleEvent 被调用时，新的 Lifecycle 事件会被传到 <strong>LifecycleAdapter</strong> 或 <strong>ReflectiveGenericLifecycleObserver</strong> 的 onStateChanged 中从而通知 LifecycleObserver Lifecycle 发生变化。</p>    <h2>最后</h2>    <p>结合来看，Lifecycle 事件可由 <strong>LifecycleDispatcher</strong> (ActivityLifecycleCallbacks, FragmentLifecycleCallbacks, Fragment), <strong>ProcessLifecycleOwner</strong> , <strong>LifecycleService</strong> 产生，并通过 <strong>LifecycleRegistry</strong> , <strong>LifecycleAdapter</strong> / <strong>ReflectiveGenericLifecycleObserver</strong> 传递给 LifecycleObserver。</p>    <p>至此，Lifecycle-aware Components 的基础框架分析完毕。</p>    <h3>稍微再说几句</h3>    <ul>     <li>个人认为该框架最有趣的地方在于使用 <strong>ReportFragment</strong> 监听 Activity 的生命周期；</li>     <li>Lifecycle 确实能帮助我们分拆 onCreate , onStart 等生命周期方法内所做的初始化、销毁操作，避免过多的代码堆在生命周期方法之中。只不过与 MVP 一样，会增加不少类，很小的项目也没什么必要使用；</li>     <li>整个框架的代码比较干净利落，反正看起来压力不大，学到的东西也不少。</li>    </ul>    <p> </p>    <p>来自：http://chaosleong.github.io/2017/05/27/How-Lifecycle-aware-Components-actually-works/</p>    <p> </p>