#### 1.1.1 典型情况下的生命周期分析 在正常情况下，Activity会经历如下生命周期。 * （1）onCreate：表示**Activity正在被创建**，这是生命周期的第一个方法。在这个方法中，我们可以做一些**初始化工作**，比如调用setContentView去加载界面布局资源、初始化Activity所需数据等。 * （2）onRestart：表示Activity正在重新启动。**一般情况下，当当前Activity从不可见重新变为可见状态时，onRestart就会被调用**。这种情形一般是用户行为所导致的，比如用户按Home键切换到桌面或者用户打开了一个新的Activity，这时当前的Activity就会暂停，也就是onPause和onStop被执行了，接着用户又回到了这个Activity，就会出现这种情况。 * （3）onStart：表示Activity正在被启动，即将开始，这时**Activity已经可见了，但是还没有出现在前台，还无法和用户交互**。这个时候其实可以理解**为Activity已经显示出来了，但是我们还看不到**。 * **可见，但是不可交互，可见，但只是没有出现在前台，比如Activity中弹出了一个对话框，导致Activity可见但是位于后台无法和用户直接交互**。 * （4）onResume：表示Activity已经**可见**了，并**且出现在前台并开始活动**。要注意这个和onStart的对比，onStart和onResume都表示Activity已经可见，但是**onStart的时候Activity还在后台，onResume的时候Activity才显示到前台**。 * （5）onPause：表示Activity正在停止，正常情况下，紧接着onStop就会被调用。**在特殊情况下，如果这个时候快速地再回到当前Activity，那么onResume会被调用。笔者的理解是，这种情况属于极端情况，用户操作很难重现这一场景**。此时可以做一些**存储数据、停止动画等工作，但是注意不能太耗时，因为这会影响到新Activity的显示，onPause必须先执行完，新Activity的onResume才会执行**。 * **可见，但不可交互，不在前台** * （6）onStop：表示Activity即将停止，可以**做一些稍微重量级的回收工作，同样不能太耗时**。 * （7）onDestroy：表示Activity即将被销毁，这是Activity生命周期中的最后一个回调，在这里，我们可以**做一些回收工作和最终的资源释放**。 正常情况下，Activity的常用生命周期就只有上面7个，图1-1更详细地描述了Activity各种生命周期的切换过程。 :-:  图1-1 Activity生命周期的切换过程 针对图1-1，这里再附加一下具体说明，分如下几种情况。 * （1）针对一个特定的Activity，第一次启动，回调如下：onCreate -> onStart -> onResume。 * （2）当用户打开新的Activity或者切换到桌面的时候，回调如下：onPause -> onStop。这里有一种特殊情况，如果新Activity采用了透明主题（仍然可见），那么当前Activity不会回调onStop。 * （3）当用户再次回到原Activity时，回调如下：onRestart -> onStart -> onResume。 * （4）当用户按back键回退时，回调如下：onPause -> onStop -> onDestroy。 * （5）**当Activity被系统回收后再次打开，生命周期方法回调过程和（1）一样，注意只是生命周期方法一样，不代表所有过程都一样**，这个问题在下一节会详细说明。 * （6）从整个生命周期来说，**onCreate和onDestroy是配对的**，分别标识着Activity的创建和销毁，并**且只可能有一次调用**。从**Activity是否可见**来说，**onStart和onStop是配对的**，随着用户的操作或者设备屏幕的点亮和熄灭，**这两个方法可能被调用多次**；从**Activity是否在前台**来说，**onResume和onPause是配对的**，随着用户操作或者设备屏幕的点亮和熄灭，这两个方法**可能被调用多次**。 这里提出2个问题，不知道大家是否清楚。 * 问题1:onStart和onResume、onPause和onStop从描述上来看差不多，对我们来说有什么实质的不同呢？ * 问题2：假设当前Activity为A，如果这时用户打开一个新Activity B，那么B的onResume和A的onPause哪个先执行呢？ * onPause(A)——>onCreate(B) ——> onStart(B) ——> onResume(B)——> onStop(A) 先说第一个问题，从实际使用过程来说，onStart和onResume、onPause和onStop看起来的确差不多，甚至我们可以只保留其中一对，比如只保留onStart和onStop。既然如此，那为什么Android系统还要提供看起来重复的接口呢？根据上面的分析，我们知道，这两个配对的回调分别表示不同的意义，**onStart和onStop是从Activity是否可见这个角度来回调的，而onResume和onPause是从Activity是否位于前台这个角度来回调的**，除了这种区别，在实际使用中没有其他明显区别。 第二个问题可以从Android源码里得到解释。关于Activity的工作原理在本书后续章节会进行介绍，这里我们先大概了解即可。从Activity的启动过程来看，我们来看一下系统源码。**Activity的启动过程的源码相当复杂**，涉及Instrumentation、ActivityThread和ActivityManagerServic（e下面简称AMS）。这里不详细分析这一过程，**简单理解，启动Activity的请求会由Instrumentation来处理，然后它通过Binder向AMS发请求，AMS内部维护着一个ActivityStack并负责栈内的Activity的状态同步，AMS通过ActivityThread去同步Activity的状态从而完成生命周期方法的调用**。在ActivityStack中的resumeTopActivity-InnerLocked方法中，有这么一段代码： ``` // We need to start pausing the current activity so the top one // can be resumed... boolean dontWaitForPause = (next.info.flags&ActivityInfo.FLAG_RESUME_ WHILE_PAUSING) ! = 0; boolean pausing = mStackSupervisor.pauseBackStacks(userLeaving, true, dontWaitForPause); if (mResumedActivity ! = null) { pausing |= startPausingLocked(userLeaving, false, true, dontWait- ForPause); if (DEBUG_STATES) Slog.d(TAG, "resumeTopActivityLocked: Pausing " + mResumedActivity); } ``` 从上述代码可以看出，**在新Activity启动之前，桟顶的Activity需要先onPause后，新Activity才能启动**。最终，在ActivityStackSupervisor中的realStartActivityLocked方法会调用如下代码。 ``` app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken, System.identityHashCode(r), r.info, new Configuration(mService. mConfiguration), r.compat, r.task.voiceInteractor, app.repProcState, r.icicle, r.persistentState, results, newIntents, ! andResume, mService.isNextTransition- Forward(), profilerInfo); ``` 我们知道，这个app.thread的类型是IApplicationThread，而IApplicationThread的具体实现是ActivityThread中的ApplicationThread。所以，这段代码实际上调到了ActivityThread的中，即ApplicationThread的scheduleLaunchActivity方法，而scheduleLaunchActivity方法最终会完成新Activity的onCreate、onStart、onResume的调用过程。因此，可以得出结论，是**旧Activity先onPause，然后新Activity再启动**。 至于ApplicationThread的scheduleLaunchActivity方法为什么会完成新Activity的onCreate、onStart、onResume的调用过程，请看下面的代码。scheduleLaunchActivity最终会调用如下方法，而如下方法的确会完成onCreate、onStart、onResume的调用过程。 源码：[ActivityThread](https://www.androidos.net.cn/android/7.1.1_r28/xref/frameworks/base/core/java/android/app/ActivityThread.java)# handleLaunchActivity ``` private void handleLaunchActivity(ActivityClientRecord r, Intent custom- Intent) { // If we are getting ready to gc after going to the background, well // we are back active so skip it. unscheduleGcIdler(); mSomeActivitiesChanged = true; if (r.profilerInfo ! = null) { mProfiler.setProfiler(r.profilerInfo); mProfiler.startProfiling(); } // Make sure we are running with the most recent config. handleConfigurationChanged(null, null); if (localLOGV) Slog.v( TAG, "Handling launch of " + r); //这里新Activity被创建出来，其onCreate和onStart会被调用 Activity a = performLaunchActivity(r, customIntent); if (a ! = null) { r.createdConfig = new Configuration(mConfiguration); Bundle oldState = r.state; //这里新Activity的onResume会被调用 handleResumeActivity(r.token, false, r.isForward, !r.activity.mFinished && ! r.startsNotResumed); //省略 } ``` 从上面的分析可以看出，当**新启动一个Activity的时候，旧Activity的onPause会先执行，然后才会启动新的Activity。到底是不是这样呢**？我们写个例子验证一下，如下是2个Activity的代码，在MainActivity中单击按钮可以跳转到SecondActivity，同时为了分析我们的问题，在生命周期方法中打印出了日志，通过日志我们就能看出它们的调用顺序。 代码：MainActivity.java ``` public class MainActivity extends Activity { private static final String TAG = "MainActivity"; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); if (savedInstanceState != null) { String test = savedInstanceState.getString("extra_test"); Log.d(TAG, "[onCreate]restore extra_test:" + test); } findViewById(R.id.button1).setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { Intent intent = new Intent("com.ryg.charpter_1.c"); //intent.setClass(MainActivity.this, SecondActivity.class); intent.putExtra("time", System.currentTimeMillis()); intent.addCategory("com.ryg.category.c"); intent.setDataAndType(Uri.parse("file://abc"), "text/plain"); startActivity(intent); } }); } @Override protected void onNewIntent(Intent intent) { super.onNewIntent(intent); Log.d(TAG, "onNewIntent, time=" + intent.getLongExtra("time", 0)); } @Override protected void onStart() { Log.d(TAG, "onStart"); super.onStart(); } @Override protected void onResume() { Log.d(TAG, "onResume"); super.onStart(); } @Override public void onConfigurationChanged(Configuration newConfig) { super.onConfigurationChanged(newConfig); Log.d(TAG, "onConfigurationChanged, newOrientation:" + newConfig.orientation); } @Override protected void onSaveInstanceState(Bundle outState) { super.onSaveInstanceState(outState); Log.d(TAG, "onSaveInstanceState"); outState.putString("extra_test", "test"); } @Override protected void onRestoreInstanceState(Bundle savedInstanceState) { super.onRestoreInstanceState(savedInstanceState); //Log.d(TAG, "onRestoreInstanceState"); String test = savedInstanceState.getString("extra_test"); Log.d(TAG, "[onRestoreInstanceState]restore extra_test:" + test); } @Override protected void onPause() { Log.d(TAG, "onPause"); super.onPause(); } @Override protected void onStop() { Log.d(TAG, "onStop"); super.onStop(); } @Override protected void onDestroy() { Log.d(TAG, "onDestroy"); super.onDestroy(); } } ``` 代码：SecondActivity.java ``` public class SecondActivity extends Activity { private static final String TAG = "SecondActivity"; @Override protected void onCreate(Bundle savedInstanceState) { // TODO Auto-generated method stub super.onCreate(savedInstanceState); setContentView(R.layout.activity_second); findViewById(R.id.button1).setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { Intent intent = new Intent(); intent.setClass(SecondActivity.this, ThirdActivity.class); intent.putExtra("time", System.currentTimeMillis()); startActivity(intent); } }); Log.d(TAG, "onCreate"); } @Override protected void onStart() { // TODO Auto-generated method stub super.onStart(); Log.d(TAG, "onStart"); } @Override protected void onResume() { // TODO Auto-generated method stub super.onResume(); Log.d(TAG, "onResume"); } @Override protected void onSaveInstanceState(Bundle outState) { super.onSaveInstanceState(outState); Log.d(TAG, "onSaveInstanceState"); } @Override protected void onRestoreInstanceState(Bundle savedInstanceState) { super.onRestoreInstanceState(savedInstanceState); Log.d(TAG, "onRestoreInstanceState"); } } ``` 我们来看一下log，是不是和我们上面分析的一样，如图1-2所示。 :-:  图1-2 Activity生命周期方法的回调顺序 通过图1-2可以发现，旧Activity的onPause先调用，然后新Activity才启动，这也证实了我们上面的分析过程。也许有人会问，你只是分析了Android5.0的源码，你怎么知道所有版本的源码都是相同逻辑呢？关于这个问题，我们的确不大可能把所有版本的源码都分析一遍，但是作为Android运行过程的基本机制，随着版本的更新并不会有大的调整，因为Android系统也需要兼容性，不能说在不同版本上同一个运行机制有着截然不同的表现。关于这一点我们需要把握一个度，就是对于Android运行的基本机制在不同Android版本上具有延续性。从另一个角度来说，**Android官方文档对onPause的解释有这么一句：不能在onPause中做重量级的操作，因为必须onPause执行完成以后新Activity才能Resume**，从这一点也能间接证明我们的结论。通过分析这个问题，我们知道**onPause和onStop都不能执行耗时的操作，尤其是onPause，这也意味着，我们应当尽量在onStop中做操作，从而使得新Activity尽快显示出来并切换到前台**。