Android应用程序启动过程源代码分析

时间：2021-07-15 17:24:53

文章转载至CSDN社区罗升阳的安卓之旅，原文地址：http://blog.csdn.net/luoshengyang/article/details/6689748

前文简要介绍了Android应用程序的Activity的启动过程。在Android系统中，应用程序是由Activity组成的，因此，应用程 序的启动过程实际上就是应用程序中的默认Activity的启动过程，本文将详细分析应用程序框架层的源代码，了解Android应用程序的启动过程。

在上一篇文章Android应用程序的Activity启动过程简要介绍和学习计划中， 我们举例子说明了启动Android应用程序中的Activity的两种情景，其中，在手机屏幕中点击应用程序图标的情景就会引发Android应用程序 中的默认Activity的启动，从而把应用程序启动起来。这种启动方式的特点是会启动一个新的进程来加载相应的Activity。这里，我们继续以这个 例子为例来说明Android应用程序的启动过程，即MainActivity的启动过程。

MainActivity的启动过程如下图所示：

Android应用程序启动过程源代码分析

点击查看大图

下面详细分析每一步是如何实现的。

Step 1. Launcher.startActivitySafely

在Android系统中，应用程序是由Launcher启动起来的，其实，Launcher本身也是一个应用程序，其它的应用程序安装后，就会Launcher的界面上出现一个相应的图标，点击这个图标时，Launcher就会对应的应用程序启动起来。

Launcher的源代码工程在packages/apps/Launcher2目录下，负责启动其它应用程序的源代码实现在src/com/android/launcher2/Launcher.java文件中：

  1. /**
  2. * Default launcher application.
  3. */
  4. public final class Launcher extends Activity
  5. implements View.OnClickListener, OnLongClickListener, LauncherModel.Callbacks, AllAppsView.Watcher {
  6. ......
  7. /**
  8. * Launches the intent referred by the clicked shortcut.
  9. *
  10. * @param v The view representing the clicked shortcut.
  11. */
  12. public void onClick(View v) {
  13. Object tag = v.getTag();
  14. if (tag instanceof ShortcutInfo) {
  15. // Open shortcut
  16. final Intent intent = ((ShortcutInfo) tag).intent;
  17. int[] pos = new int[2];
  18. v.getLocationOnScreen(pos);
  19. intent.setSourceBounds(new Rect(pos[0], pos[1],
  20. pos[0] + v.getWidth(), pos[1] + v.getHeight()));
  21. startActivitySafely(intent, tag);
  22. } else if (tag instanceof FolderInfo) {
  23. ......
  24. } else if (v == mHandleView) {
  25. ......
  26. }
  27. }
  28. void startActivitySafely(Intent intent, Object tag) {
  29. intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
  30. try {
  31. startActivity(intent);
  32. } catch (ActivityNotFoundException e) {
  33. ......
  34. } catch (SecurityException e) {
  35. ......
  36. }
  37. }
  38. ......
  39. }

回忆一下前面一篇文章Android应用程序的Activity启动过程简要介绍和学习计划说到的应用程序Activity，它的默认Activity是MainActivity，这里是AndroidManifest.xml文件中配置的：

  1. <activity android:name=".MainActivity"
  2. android:label="@string/app_name">
  3. <intent-filter>
  4. <action android:name="android.intent.action.MAIN" />
  5. <category android:name="android.intent.category.LAUNCHER" />
  6. </intent-filter>
  7. </activity>

因此，这里的intent包含的信息为：action = "android.intent.action.Main"，category="android.intent.category.LAUNCHER", cmp="shy.luo.activity/.MainActivity"，表示它要启动的Activity为 shy.luo.activity.MainActivity。Intent.FLAG_ACTIVITY_NEW_TASK表示要在一个新的Task中 启动这个Activity，注意，Task是Android系统中的概念，它不同于进程Process的概念。简单地说，一个Task是一系列 Activity的集合，这个集合是以堆栈的形式来组织的，遵循后进先出的原则。事实上，Task是一个非常复杂的概念，有兴趣的读者可以到官网http://developer.android.com/guide/topics/manifest/activity-element.html查看相关的资料。这里，我们只要知道，这个MainActivity要在一个新的Task中启动就可以了。

Step 2. Activity.startActivity

在Step 1中，我们看到，Launcher继承于Activity类，而Activity类实现了startActivity函数，因此，这里就调用了 Activity.startActivity函数，它实现在frameworks/base/core/java/android/app /Activity.java文件中：

  1. public class Activity extends ContextThemeWrapper
  2. implements LayoutInflater.Factory,
  3. Window.Callback, KeyEvent.Callback,
  4. OnCreateContextMenuListener, ComponentCallbacks {
  5. ......
  6. @Override
  7. public void startActivity(Intent intent) {
  8. startActivityForResult(intent, -1);
  9. }
  10. ......
  11. }

这个函数实现很简单，它调用startActivityForResult来进一步处理，第二个参数传入-1表示不需要这个Actvity结束后的返回结果。

Step 3. Activity.startActivityForResult

这个函数也是实现在frameworks/base/core/java/android/app/Activity.java文件中：

  1. public class Activity extends ContextThemeWrapper
  2. implements LayoutInflater.Factory,
  3. Window.Callback, KeyEvent.Callback,
  4. OnCreateContextMenuListener, ComponentCallbacks {
  5. ......
  6. public void startActivityForResult(Intent intent, int requestCode) {
  7. if (mParent == null) {
  8. Instrumentation.ActivityResult ar =
  9. mInstrumentation.execStartActivity(
  10. this, mMainThread.getApplicationThread(), mToken, this,
  11. intent, requestCode);
  12. ......
  13. } else {
  14. ......
  15. }
  16. ......
  17. }

这里的mInstrumentation是Activity类的成员变量，它的类型是Intrumentation，定义在 frameworks/base/core/java/android/app/Instrumentation.java文件中，它用来监控应用程序和 系统的交互。

这里的mMainThread也是Activity类的成员变量，它的类型是ActivityThread，它代表的是应用程序的主线程，我们在Android系统在新进程中启动自定义服务过程（startService）的原理分析一 文中已经介绍过了。这里通过mMainThread.getApplicationThread获得它里面的ApplicationThread成员变 量，它是一个Binder对象，后面我们会看到，ActivityManagerService会使用它来和ActivityThread来进行进程间通 信。这里我们需注意的是，这里的mMainThread代表的是Launcher应用程序运行的进程。

这里的mToken也是Activity类的成员变量，它是一个Binder对象的远程接口。

Step 4. Instrumentation.execStartActivity
         这个函数定义在frameworks/base/core/java/android/app/Instrumentation.java文件中：

  1. public class Instrumentation {
  2. ......
  3. public ActivityResult execStartActivity(
  4. Context who, IBinder contextThread, IBinder token, Activity target,
  5. Intent intent, int requestCode) {
  6. IApplicationThread whoThread = (IApplicationThread) contextThread;
  7. if (mActivityMonitors != null) {
  8. ......
  9. }
  10. try {
  11. int result = ActivityManagerNative.getDefault()
  12. .startActivity(whoThread, intent,
  13. intent.resolveTypeIfNeeded(who.getContentResolver()),
  14. null, 0, token, target != null ? target.mEmbeddedID : null,
  15. requestCode, false, false);
  16. ......
  17. } catch (RemoteException e) {
  18. }
  19. return null;
  20. }
  21. ......
  22. }

这里的ActivityManagerNative.getDefault返回ActivityManagerService的远程接口，即ActivityManagerProxy接口，具体可以参考Android系统在新进程中启动自定义服务过程（startService）的原理分析一文。

这里的intent.resolveTypeIfNeeded返回这个intent的MIME类型，在这个例子中，没有AndroidManifest.xml设置MainActivity的MIME类型，因此，这里返回null。

这里的target不为null，但是target.mEmbddedID为null，我们不用关注。

Step 5. ActivityManagerProxy.startActivity

这个函数定义在frameworks/base/core/java/android/app/ActivityManagerNative.java文件中：

  1. class ActivityManagerProxy implements IActivityManager
  2. {
  3. ......
  4. public int startActivity(IApplicationThread caller, Intent intent,
  5. String resolvedType, Uri[] grantedUriPermissions, int grantedMode,
  6. IBinder resultTo, String resultWho,
  7. int requestCode, boolean onlyIfNeeded,
  8. boolean debug) throws RemoteException {
  9. Parcel data = Parcel.obtain();
  10. Parcel reply = Parcel.obtain();
  11. data.writeInterfaceToken(IActivityManager.descriptor);
  12. data.writeStrongBinder(caller != null ? caller.asBinder() : null);
  13. intent.writeToParcel(data, 0);
  14. data.writeString(resolvedType);
  15. data.writeTypedArray(grantedUriPermissions, 0);
  16. data.writeInt(grantedMode);
  17. data.writeStrongBinder(resultTo);
  18. data.writeString(resultWho);
  19. data.writeInt(requestCode);
  20. data.writeInt(onlyIfNeeded ? 1 : 0);
  21. data.writeInt(debug ? 1 : 0);
  22. mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);
  23. reply.readException();
  24. int result = reply.readInt();
  25. reply.recycle();
  26. data.recycle();
  27. return result;
  28. }
  29. ......
  30. }

这里的参数比较多，我们先整理一下。从上面的调用可以知道，这里的参数resolvedType、grantedUriPermissions和
resultWho均为null；参数caller为ApplicationThread类型的Binder实体；参数resultTo为一个
Binder实体的远程接口，我们先不关注它；参数grantedMode为0，我们也先不关注它；参数requestCode为-1；参数
onlyIfNeeded和debug均空false。

Step 6. ActivityManagerService.startActivity

上一步Step
5通过Binder驱动程序就进入到ActivityManagerService的startActivity函数来了，它定义在
frameworks/base/services/java/com/android/server/am
/ActivityManagerService.java文件中：

  1. public final class ActivityManagerService extends ActivityManagerNative
  2. implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
  3. ......
  4. public final int startActivity(IApplicationThread caller,
  5. Intent intent, String resolvedType, Uri[] grantedUriPermissions,
  6. int grantedMode, IBinder resultTo,
  7. String resultWho, int requestCode, boolean onlyIfNeeded,
  8. boolean debug) {
  9. return mMainStack.startActivityMayWait(caller, intent, resolvedType,
  10. grantedUriPermissions, grantedMode, resultTo, resultWho,
  11. requestCode, onlyIfNeeded, debug, null, null);
  12. }
  13. ......
  14. }

这里只是简单地将操作转发给成员变量mMainStack的startActivityMayWait函数，这里的mMainStack的类型为ActivityStack。

Step 7. ActivityStack.startActivityMayWait

这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：

  1. public class ActivityStack {
  2. ......
  3. final int startActivityMayWait(IApplicationThread caller,
  4. Intent intent, String resolvedType, Uri[] grantedUriPermissions,
  5. int grantedMode, IBinder resultTo,
  6. String resultWho, int requestCode, boolean onlyIfNeeded,
  7. boolean debug, WaitResult outResult, Configuration config) {
  8. ......
  9. boolean componentSpecified = intent.getComponent() != null;
  10. // Don't modify the client's object!
  11. intent = new Intent(intent);
  12. // Collect information about the target of the Intent.
  13. ActivityInfo aInfo;
  14. try {
  15. ResolveInfo rInfo =
  16. AppGlobals.getPackageManager().resolveIntent(
  17. intent, resolvedType,
  18. PackageManager.MATCH_DEFAULT_ONLY
  19. | ActivityManagerService.STOCK_PM_FLAGS);
  20. aInfo = rInfo != null ? rInfo.activityInfo : null;
  21. } catch (RemoteException e) {
  22. ......
  23. }
  24. if (aInfo != null) {
  25. // Store the found target back into the intent, because now that
  26. // we have it we never want to do this again.  For example, if the
  27. // user navigates back to this point in the history, we should
  28. // always restart the exact same activity.
  29. intent.setComponent(new ComponentName(
  30. aInfo.applicationInfo.packageName, aInfo.name));
  31. ......
  32. }
  33. synchronized (mService) {
  34. int callingPid;
  35. int callingUid;
  36. if (caller == null) {
  37. ......
  38. } else {
  39. callingPid = callingUid = -1;
  40. }
  41. mConfigWillChange = config != null
  42. && mService.mConfiguration.diff(config) != 0;
  43. ......
  44. if (mMainStack && aInfo != null &&
  45. (aInfo.applicationInfo.flags&ApplicationInfo.FLAG_CANT_SAVE_STATE) != 0) {
  46. ......
  47. }
  48. int res = startActivityLocked(caller, intent, resolvedType,
  49. grantedUriPermissions, grantedMode, aInfo,
  50. resultTo, resultWho, requestCode, callingPid, callingUid,
  51. onlyIfNeeded, componentSpecified);
  52. if (mConfigWillChange && mMainStack) {
  53. ......
  54. }
  55. ......
  56. if (outResult != null) {
  57. ......
  58. }
  59. return res;
  60. }
  61. }
  62. ......
  63. }

注意，从Step
6传下来的参数outResult和config均为null，此外，表达式
(aInfo.applicationInfo.flags&ApplicationInfo.FLAG_CANT_SAVE_STATE)
!= 0为false，因此，这里忽略了无关代码。

下面语句对参数intent的内容进行解析，得到MainActivity的相关信息，保存在aInfo变量中：

  1. ActivityInfo aInfo;
  2. try {
  3. ResolveInfo rInfo =
  4. AppGlobals.getPackageManager().resolveIntent(
  5. intent, resolvedType,
  6. PackageManager.MATCH_DEFAULT_ONLY
  7. | ActivityManagerService.STOCK_PM_FLAGS);
  8. aInfo = rInfo != null ? rInfo.activityInfo : null;
  9. } catch (RemoteException e) {
  10. ......
  11. }

解析之后，得到的aInfo.applicationInfo.packageName的值
为"shy.luo.activity"，aInfo.name的值为"shy.luo.activity.MainActivity"，这是在这个实例
的配置文件AndroidManifest.xml里面配置的。

此外，函数开始的地方调用intent.getComponent()函数的返回值不为null，因此，这里的componentSpecified变量为true。

接下去就调用startActivityLocked进一步处理了。

Step 8. ActivityStack.startActivityLocked

这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：

  1. public class ActivityStack {
  2. ......
  3. final int startActivityLocked(IApplicationThread caller,
  4. Intent intent, String resolvedType,
  5. Uri[] grantedUriPermissions,
  6. int grantedMode, ActivityInfo aInfo, IBinder resultTo,
  7. String resultWho, int requestCode,
  8. int callingPid, int callingUid, boolean onlyIfNeeded,
  9. boolean componentSpecified) {
  10. int err = START_SUCCESS;
  11. ProcessRecord callerApp = null;
  12. if (caller != null) {
  13. callerApp = mService.getRecordForAppLocked(caller);
  14. if (callerApp != null) {
  15. callingPid = callerApp.pid;
  16. callingUid = callerApp.info.uid;
  17. } else {
  18. ......
  19. }
  20. }
  21. ......
  22. ActivityRecord sourceRecord = null;
  23. ActivityRecord resultRecord = null;
  24. if (resultTo != null) {
  25. int index = indexOfTokenLocked(resultTo);
  26. ......
  27. if (index >= 0) {
  28. sourceRecord = (ActivityRecord)mHistory.get(index);
  29. if (requestCode >= 0 && !sourceRecord.finishing) {
  30. ......
  31. }
  32. }
  33. }
  34. int launchFlags = intent.getFlags();
  35. if ((launchFlags&Intent.FLAG_ACTIVITY_FORWARD_RESULT) != 0
  36. && sourceRecord != null) {
  37. ......
  38. }
  39. if (err == START_SUCCESS && intent.getComponent() == null) {
  40. ......
  41. }
  42. if (err == START_SUCCESS && aInfo == null) {
  43. ......
  44. }
  45. if (err != START_SUCCESS) {
  46. ......
  47. }
  48. ......
  49. ActivityRecord r = new ActivityRecord(mService, this, callerApp, callingUid,
  50. intent, resolvedType, aInfo, mService.mConfiguration,
  51. resultRecord, resultWho, requestCode, componentSpecified);
  52. ......
  53. return startActivityUncheckedLocked(r, sourceRecord,
  54. grantedUriPermissions, grantedMode, onlyIfNeeded, true);
  55. }
  56. ......
  57. }

从传进来的参数caller得到调用者的进程信息，并保存在callerApp变量中，这里就是Launcher应用程序的进程信息了。

前面说过，参数resultTo是Launcher这个Activity里面的一个Binder对象，通过它可以获得Launcher这个Activity的相关信息，保存在sourceRecord变量中。
        再接下来，创建即将要启动的Activity的相关信息，并保存在r变量中：

  1. ActivityRecord r = new ActivityRecord(mService, this, callerApp, callingUid,
  2. intent, resolvedType, aInfo, mService.mConfiguration,
  3. resultRecord, resultWho, requestCode, componentSpecified);

接着调用startActivityUncheckedLocked函数进行下一步操作。

Step 9. ActivityStack.startActivityUncheckedLocked

这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：

  1. public class ActivityStack {
  2. ......
  3. final int startActivityUncheckedLocked(ActivityRecord r,
  4. ActivityRecord sourceRecord, Uri[] grantedUriPermissions,
  5. int grantedMode, boolean onlyIfNeeded, boolean doResume) {
  6. final Intent intent = r.intent;
  7. final int callingUid = r.launchedFromUid;
  8. int launchFlags = intent.getFlags();
  9. // We'll invoke onUserLeaving before onPause only if the launching
  10. // activity did not explicitly state that this is an automated launch.
  11. mUserLeaving = (launchFlags&Intent.FLAG_ACTIVITY_NO_USER_ACTION) == 0;
  12. ......
  13. ActivityRecord notTop = (launchFlags&Intent.FLAG_ACTIVITY_PREVIOUS_IS_TOP)
  14. != 0 ? r : null;
  15. // If the onlyIfNeeded flag is set, then we can do this if the activity
  16. // being launched is the same as the one making the call...  or, as
  17. // a special case, if we do not know the caller then we count the
  18. // current top activity as the caller.
  19. if (onlyIfNeeded) {
  20. ......
  21. }
  22. if (sourceRecord == null) {
  23. ......
  24. } else if (sourceRecord.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE) {
  25. ......
  26. } else if (r.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE
  27. || r.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK) {
  28. ......
  29. }
  30. if (r.resultTo != null && (launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK) != 0) {
  31. ......
  32. }
  33. boolean addingToTask = false;
  34. if (((launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK) != 0 &&
  35. (launchFlags&Intent.FLAG_ACTIVITY_MULTIPLE_TASK) == 0)
  36. || r.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK
  37. || r.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE) {
  38. // If bring to front is requested, and no result is requested, and
  39. // we can find a task that was started with this same
  40. // component, then instead of launching bring that one to the front.
  41. if (r.resultTo == null) {
  42. // See if there is a task to bring to the front.  If this is
  43. // a SINGLE_INSTANCE activity, there can be one and only one
  44. // instance of it in the history, and it is always in its own
  45. // unique task, so we do a special search.
  46. ActivityRecord taskTop = r.launchMode != ActivityInfo.LAUNCH_SINGLE_INSTANCE
  47. ? findTaskLocked(intent, r.info)
  48. : findActivityLocked(intent, r.info);
  49. if (taskTop != null) {
  50. ......
  51. }
  52. }
  53. }
  54. ......
  55. if (r.packageName != null) {
  56. // If the activity being launched is the same as the one currently
  57. // at the top, then we need to check if it should only be launched
  58. // once.
  59. ActivityRecord top = topRunningNonDelayedActivityLocked(notTop);
  60. if (top != null && r.resultTo == null) {
  61. if (top.realActivity.equals(r.realActivity)) {
  62. ......
  63. }
  64. }
  65. } else {
  66. ......
  67. }
  68. boolean newTask = false;
  69. // Should this be considered a new task?
  70. if (r.resultTo == null && !addingToTask
  71. && (launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK) != 0) {
  72. // todo: should do better management of integers.
  73. mService.mCurTask++;
  74. if (mService.mCurTask <= 0) {
  75. mService.mCurTask = 1;
  76. }
  77. r.task = new TaskRecord(mService.mCurTask, r.info, intent,
  78. (r.info.flags&ActivityInfo.FLAG_CLEAR_TASK_ON_LAUNCH) != 0);
  79. ......
  80. newTask = true;
  81. if (mMainStack) {
  82. mService.addRecentTaskLocked(r.task);
  83. }
  84. } else if (sourceRecord != null) {
  85. ......
  86. } else {
  87. ......
  88. }
  89. ......
  90. startActivityLocked(r, newTask, doResume);
  91. return START_SUCCESS;
  92. }
  93. ......
  94. }

函数首先获得intent的标志值，保存在launchFlags变量中。

这个intent的标志值的位Intent.FLAG_ACTIVITY_NO_USER_ACTION没有置位，因此 ，成员变量mUserLeaving的值为true。

这个intent的标志值的位Intent.FLAG_ACTIVITY_PREVIOUS_IS_TOP也没有置位，因此，变量notTop的值为null。

由于在这个例子的AndroidManifest.xml文件中，MainActivity没有配置launchMode属值，因此，这里的
r.launchMode为默认值0，表示以标准（Standard，或者称为ActivityInfo.LAUNCH_MULTIPLE）的方式来启动
这个Activity。Activity的启动方式有四种，其余三种分别是ActivityInfo.LAUNCH_SINGLE_INSTANCE、
ActivityInfo.LAUNCH_SINGLE_TASK和ActivityInfo.LAUNCH_SINGLE_TOP，具体可以参考官方网
站http://developer.android.com/reference/android/content/pm/ActivityInfo.html。

传进来的参数r.resultTo为null，表示Launcher不需要等这个即将要启动的MainActivity的执行结果。

由于这个intent的标志值的位Intent.FLAG_ACTIVITY_NEW_TASK被置位，而且Intent.FLAG_ACTIVITY_MULTIPLE_TASK没有置位，因此，下面的if语句会被执行：

  1. if (((launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK) != 0 &&
  2. (launchFlags&Intent.FLAG_ACTIVITY_MULTIPLE_TASK) == 0)
  3. || r.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK
  4. || r.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE) {
  5. // If bring to front is requested, and no result is requested, and
  6. // we can find a task that was started with this same
  7. // component, then instead of launching bring that one to the front.
  8. if (r.resultTo == null) {
  9. // See if there is a task to bring to the front.  If this is
  10. // a SINGLE_INSTANCE activity, there can be one and only one
  11. // instance of it in the history, and it is always in its own
  12. // unique task, so we do a special search.
  13. ActivityRecord taskTop = r.launchMode != ActivityInfo.LAUNCH_SINGLE_INSTANCE
  14. ? findTaskLocked(intent, r.info)
  15. : findActivityLocked(intent, r.info);
  16. if (taskTop != null) {
  17. ......
  18. }
  19. }
  20. }

这段代码的逻辑是查看一下，当前有没有Task可以用来执行这个Activity。由于r.launchMode的值不为
ActivityInfo.LAUNCH_SINGLE_INSTANCE，因此，它通过findTaskLocked函数来查找存不存这样的Task，
这里返回的结果是null，即taskTop为null，因此，需要创建一个新的Task来启动这个Activity。

接着往下看：

  1. if (r.packageName != null) {
  2. // If the activity being launched is the same as the one currently
  3. // at the top, then we need to check if it should only be launched
  4. // once.
  5. ActivityRecord top = topRunningNonDelayedActivityLocked(notTop);
  6. if (top != null && r.resultTo == null) {
  7. if (top.realActivity.equals(r.realActivity)) {
  8. ......
  9. }
  10. }
  11. }

这段代码的逻辑是看一下，当前在堆栈顶端的Activity是否就是即将要启动的Activity，有些情况下，如果即将要启动的Activity就在堆栈的顶端，那么，就不会重新启动这个Activity的别一个实例了，具体可以参考官方网站http://developer.android.com/reference/android/content/pm/ActivityInfo.html。现在处理堆栈顶端的Activity是Launcher，与我们即将要启动的MainActivity不是同一个Activity，因此，这里不用进一步处理上述介绍的情况。

执行到这里，我们知道，要在一个新的Task里面来启动这个Activity了，于是新创建一个Task：

  1. if (r.resultTo == null && !addingToTask
  2. && (launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK) != 0) {
  3. // todo: should do better management of integers.
  4. mService.mCurTask++;
  5. if (mService.mCurTask <= 0) {
  6. mService.mCurTask = 1;
  7. }
  8. r.task = new TaskRecord(mService.mCurTask, r.info, intent,
  9. (r.info.flags&ActivityInfo.FLAG_CLEAR_TASK_ON_LAUNCH) != 0);
  10. ......
  11. newTask = true;
  12. if (mMainStack) {
  13. mService.addRecentTaskLocked(r.task);
  14. }
  15. }

新建的Task保存在r.task域中，同时，添加到mService中去，这里的mService就是ActivityManagerService了。

最后就进入startActivityLocked(r, newTask,
doResume)进一步处理了。这个函数定义在frameworks/base/services/java/com/android/server
/am/ActivityStack.java文件中：

  1. public class ActivityStack {
  2. ......
  3. private final void startActivityLocked(ActivityRecord r, boolean newTask,
  4. boolean doResume) {
  5. final int NH = mHistory.size();
  6. int addPos = -1;
  7. if (!newTask) {
  8. ......
  9. }
  10. // Place a new activity at top of stack, so it is next to interact
  11. // with the user.
  12. if (addPos < 0) {
  13. addPos = NH;
  14. }
  15. // If we are not placing the new activity frontmost, we do not want
  16. // to deliver the onUserLeaving callback to the actual frontmost
  17. // activity
  18. if (addPos < NH) {
  19. ......
  20. }
  21. // Slot the activity into the history stack and proceed
  22. mHistory.add(addPos, r);
  23. r.inHistory = true;
  24. r.frontOfTask = newTask;
  25. r.task.numActivities++;
  26. if (NH > 0) {
  27. // We want to show the starting preview window if we are
  28. // switching to a new task, or the next activity's process is
  29. // not currently running.
  30. ......
  31. } else {
  32. // If this is the first activity, don't do any fancy animations,
  33. // because there is nothing for it to animate on top of.
  34. ......
  35. }
  36. ......
  37. if (doResume) {
  38. resumeTopActivityLocked(null);
  39. }
  40. }
  41. ......
  42. }

这里的NH表示当前系统中历史任务的个数，这里肯定是大于0，因为Launcher已经跑起来了。当NH>0时，并且现在要切换新任务时，要做一
些任务切的界面操作，这段代码我们就不看了，这里不会影响到下面启Activity的过程，有兴趣的读取可以自己研究一下。

这里传进来的参数doResume为true，于是调用resumeTopActivityLocked进一步操作。

Step 10. Activity.resumeTopActivityLocked

这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：

  1. public class ActivityStack {
  2. ......
  3. /**
  4. * Ensure that the top activity in the stack is resumed.
  5. *
  6. * @param prev The previously resumed activity, for when in the process
  7. * of pausing; can be null to call from elsewhere.
  8. *
  9. * @return Returns true if something is being resumed, or false if
  10. * nothing happened.
  11. */
  12. final boolean resumeTopActivityLocked(ActivityRecord prev) {
  13. // Find the first activity that is not finishing.
  14. ActivityRecord next = topRunningActivityLocked(null);
  15. // Remember how we'll process this pause/resume situation, and ensure
  16. // that the state is reset however we wind up proceeding.
  17. final boolean userLeaving = mUserLeaving;
  18. mUserLeaving = false;
  19. if (next == null) {
  20. ......
  21. }
  22. next.delayedResume = false;
  23. // If the top activity is the resumed one, nothing to do.
  24. if (mResumedActivity == next && next.state == ActivityState.RESUMED) {
  25. ......
  26. }
  27. // If we are sleeping, and there is no resumed activity, and the top
  28. // activity is paused, well that is the state we want.
  29. if ((mService.mSleeping || mService.mShuttingDown)
  30. && mLastPausedActivity == next && next.state == ActivityState.PAUSED) {
  31. ......
  32. }
  33. ......
  34. // If we are currently pausing an activity, then don't do anything
  35. // until that is done.
  36. if (mPausingActivity != null) {
  37. ......
  38. }
  39. ......
  40. // We need to start pausing the current activity so the top one
  41. // can be resumed...
  42. if (mResumedActivity != null) {
  43. ......
  44. startPausingLocked(userLeaving, false);
  45. return true;
  46. }
  47. ......
  48. }
  49. ......
  50. }

函数先通过调用topRunningActivityLocked函数获得堆栈顶端的Activity，这里就是MainActivity了，这是在上面的Step 9设置好的，保存在next变量中。

接下来把mUserLeaving的保存在本地变量userLeaving中，然后重新设置为false，在上面的Step 9中，mUserLeaving的值为true，因此，这里的userLeaving为true。

这里的mResumedActivity为Launcher，因为Launcher是当前正被执行的Activity。

当我们处理休眠状态时，mLastPausedActivity保存堆栈顶端的Activity，因为当前不是休眠状态，所以mLastPausedActivity为null。

有了这些信息之后，下面的语句就容易理解了：

  1. // If the top activity is the resumed one, nothing to do.
  2. if (mResumedActivity == next && next.state == ActivityState.RESUMED) {
  3. ......
  4. }
  5. // If we are sleeping, and there is no resumed activity, and the top
  6. // activity is paused, well that is the state we want.
  7. if ((mService.mSleeping || mService.mShuttingDown)
  8. && mLastPausedActivity == next && next.state == ActivityState.PAUSED) {
  9. ......
  10. }

它首先看要启动的Activity是否就是当前处理Resumed状态的Activity，如果是的话，那就什么都不用做，直接返回就可以了；否则再看
一下系统当前是否休眠状态，如果是的话，再看看要启动的Activity是否就是当前处于堆栈顶端的Activity，如果是的话，也是什么都不用做。

上面两个条件都不满足，因此，在继续往下执行之前，首先要把当处于Resumed状态的Activity推入Paused状态，然后才可以启动新的
Activity。但是在将当前这个Resumed状态的Activity推入Paused状态之前，首先要看一下当前是否有Activity正在进入
Pausing状态，如果有的话，当前这个Resumed状态的Activity就要稍后才能进入Paused状态了，这样就保证了所有需要进入
Paused状态的Activity串行处理。

这里没有处于Pausing状态的Activity，即mPausingActivity为null，而且mResumedActivity也不为
null，于是就调用startPausingLocked函数把Launcher推入Paused状态去了。

Step 11. ActivityStack.startPausingLocked

这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：

  1. public class ActivityStack {
  2. ......
  3. private final void startPausingLocked(boolean userLeaving, boolean uiSleeping) {
  4. if (mPausingActivity != null) {
  5. ......
  6. }
  7. ActivityRecord prev = mResumedActivity;
  8. if (prev == null) {
  9. ......
  10. }
  11. ......
  12. mResumedActivity = null;
  13. mPausingActivity = prev;
  14. mLastPausedActivity = prev;
  15. prev.state = ActivityState.PAUSING;
  16. ......
  17. if (prev.app != null && prev.app.thread != null) {
  18. ......
  19. try {
  20. ......
  21. prev.app.thread.schedulePauseActivity(prev, prev.finishing, userLeaving,
  22. prev.configChangeFlags);
  23. ......
  24. } catch (Exception e) {
  25. ......
  26. }
  27. } else {
  28. ......
  29. }
  30. ......
  31. }
  32. ......
  33. }

函数首先把mResumedActivity保存在本地变量prev中。在上一步Step
10中，说到mResumedActivity就是Launcher，因此，这里把Launcher进程中的ApplicationThread对象取出
来，通过它来通知Launcher这个Activity它要进入Paused状态了。当然，这里的prev.app.thread是一个
ApplicationThread对象的远程接口，通过调用这个远程接口的schedulePauseActivity来通知Launcher进入
Paused状态。

参数prev.finishing表示prev所代表的Activity是否正在等待结束的Activity列表中，由于Laucher这个
Activity还没结束，所以这里为false；参数prev.configChangeFlags表示哪些config发生了变化，这里我们不关心它
的值。

Step 12. ApplicationThreadProxy.schedulePauseActivity

这个函数定义在frameworks/base/core/java/android/app/ApplicationThreadNative.java文件中：

  1. class ApplicationThreadProxy implements IApplicationThread {
  2. ......
  3. public final void schedulePauseActivity(IBinder token, boolean finished,
  4. boolean userLeaving, int configChanges) throws RemoteException {
  5. Parcel data = Parcel.obtain();
  6. data.writeInterfaceToken(IApplicationThread.descriptor);
  7. data.writeStrongBinder(token);
  8. data.writeInt(finished ? 1 : 0);
  9. data.writeInt(userLeaving ? 1 :0);
  10. data.writeInt(configChanges);
  11. mRemote.transact(SCHEDULE_PAUSE_ACTIVITY_TRANSACTION, data, null,
  12. IBinder.FLAG_ONEWAY);
  13. data.recycle();
  14. }
  15. ......
  16. }

这个函数通过Binder进程间通信机制进入到ApplicationThread.schedulePauseActivity函数中。

Step 13. ApplicationThread.schedulePauseActivity

这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中，它是ActivityThread的内部类：

  1. public final class ActivityThread {
  2. ......
  3. private final class ApplicationThread extends ApplicationThreadNative {
  4. ......
  5. public final void schedulePauseActivity(IBinder token, boolean finished,
  6. boolean userLeaving, int configChanges) {
  7. queueOrSendMessage(
  8. finished ? H.PAUSE_ACTIVITY_FINISHING : H.PAUSE_ACTIVITY,
  9. token,
  10. (userLeaving ? 1 : 0),
  11. configChanges);
  12. }
  13. ......
  14. }
  15. ......
  16. }

这里调用的函数queueOrSendMessage是ActivityThread类的成员函数。

上面说到，这里的finished值为false，因此，queueOrSendMessage的第一个参数值为H.PAUSE_ACTIVITY，表示要暂停token所代表的Activity，即Launcher。

Step 14. ActivityThread.queueOrSendMessage

这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中：

  1. public final class ActivityThread {
  2. ......
  3. private final void queueOrSendMessage(int what, Object obj, int arg1) {
  4. queueOrSendMessage(what, obj, arg1, 0);
  5. }
  6. private final void queueOrSendMessage(int what, Object obj, int arg1, int arg2) {
  7. synchronized (this) {
  8. ......
  9. Message msg = Message.obtain();
  10. msg.what = what;
  11. msg.obj = obj;
  12. msg.arg1 = arg1;
  13. msg.arg2 = arg2;
  14. mH.sendMessage(msg);
  15. }
  16. }
  17. ......
  18. }

这里首先将相关信息组装成一个msg，然后通过mH成员变量发送出去，mH的类型是H，继承于Handler类，是ActivityThread的内部类，因此，这个消息最后由H.handleMessage来处理。

Step 15. H.handleMessage

这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中：

  1. public final class ActivityThread {
  2. ......
  3. private final class H extends Handler {
  4. ......
  5. public void handleMessage(Message msg) {
  6. ......
  7. switch (msg.what) {
  8. ......
  9. case PAUSE_ACTIVITY:
  10. handlePauseActivity((IBinder)msg.obj, false, msg.arg1 != 0, msg.arg2);
  11. maybeSnapshot();
  12. break;
  13. ......
  14. }
  15. ......
  16. }
  17. ......
  18. }

这里调用ActivityThread.handlePauseActivity进一步操作，msg.obj是一个ActivityRecord对象的引用，它代表的是Launcher这个Activity。
        Step 16. ActivityThread.handlePauseActivity

这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中：

  1. public final class ActivityThread {
  2. ......
  3. private final void handlePauseActivity(IBinder token, boolean finished,
  4. boolean userLeaving, int configChanges) {
  5. ActivityClientRecord r = mActivities.get(token);
  6. if (r != null) {
  7. //Slog.v(TAG, "userLeaving=" + userLeaving + " handling pause of " + r);
  8. if (userLeaving) {
  9. performUserLeavingActivity(r);
  10. }
  11. r.activity.mConfigChangeFlags |= configChanges;
  12. Bundle state = performPauseActivity(token, finished, true);
  13. // Make sure any pending writes are now committed.
  14. QueuedWork.waitToFinish();
  15. // Tell the activity manager we have paused.
  16. try {
  17. ActivityManagerNative.getDefault().activityPaused(token, state);
  18. } catch (RemoteException ex) {
  19. }
  20. }
  21. }
  22. ......
  23. }

函数首先将Binder引用token转换成ActivityRecord的远程接口ActivityClientRecord，然后做了三个事情：1.

如果userLeaving为true，则通过调用performUserLeavingActivity函数来调用
Activity.onUserLeaveHint通知Activity，用户要离开它了；2.
调用performPauseActivity函数来调用Activity.onPause函数，我们知道，在Activity的生命周期中，当它要让位
于其它的Activity时，系统就会调用它的onPause函数；3.
它通知ActivityManagerService，这个Activity已经进入Paused状态了，ActivityManagerService
现在可以完成未竟的事情，即启动MainActivity了。

Step 17. ActivityManagerProxy.activityPaused

这个函数定义在frameworks/base/core/java/android/app/ActivityManagerNative.java文件中：

  1. class ActivityManagerProxy implements IActivityManager
  2. {
  3. ......
  4. public void activityPaused(IBinder token, Bundle state) throws RemoteException
  5. {
  6. Parcel data = Parcel.obtain();
  7. Parcel reply = Parcel.obtain();
  8. data.writeInterfaceToken(IActivityManager.descriptor);
  9. data.writeStrongBinder(token);
  10. data.writeBundle(state);
  11. mRemote.transact(ACTIVITY_PAUSED_TRANSACTION, data, reply, 0);
  12. reply.readException();
  13. data.recycle();
  14. reply.recycle();
  15. }
  16. ......
  17. }

这里通过Binder进程间通信机制就进入到ActivityManagerService.activityPaused函数中去了。

Step 18. ActivityManagerService.activityPaused

这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityManagerService.java文件中：

  1. public final class ActivityManagerService extends ActivityManagerNative
  2. implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
  3. ......
  4. public final void activityPaused(IBinder token, Bundle icicle) {
  5. ......
  6. final long origId = Binder.clearCallingIdentity();
  7. mMainStack.activityPaused(token, icicle, false);
  8. ......
  9. }
  10. ......
  11. }

这里，又再次进入到ActivityStack类中，执行activityPaused函数。

Step 19. ActivityStack.activityPaused

这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：

  1. public class ActivityStack {
  2. ......
  3. final void activityPaused(IBinder token, Bundle icicle, boolean timeout) {
  4. ......
  5. ActivityRecord r = null;
  6. synchronized (mService) {
  7. int index = indexOfTokenLocked(token);
  8. if (index >= 0) {
  9. r = (ActivityRecord)mHistory.get(index);
  10. if (!timeout) {
  11. r.icicle = icicle;
  12. r.haveState = true;
  13. }
  14. mHandler.removeMessages(PAUSE_TIMEOUT_MSG, r);
  15. if (mPausingActivity == r) {
  16. r.state = ActivityState.PAUSED;
  17. completePauseLocked();
  18. } else {
  19. ......
  20. }
  21. }
  22. }
  23. }
  24. ......
  25. }

这里通过参数token在mHistory列表中得到ActivityRecord，从上面我们知道，这个ActivityRecord代表的是
Launcher这个Activity，而我们在Step
11中，把Launcher这个Activity的信息保存在mPausingActivity中，因此，这里mPausingActivity等于r，
于是，执行completePauseLocked操作。

Step 20. ActivityStack.completePauseLocked

这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：

  1. public class ActivityStack {
  2. ......
  3. private final void completePauseLocked() {
  4. ActivityRecord prev = mPausingActivity;
  5. ......
  6. if (prev != null) {
  7. ......
  8. mPausingActivity = null;
  9. }
  10. if (!mService.mSleeping && !mService.mShuttingDown) {
  11. resumeTopActivityLocked(prev);
  12. } else {
  13. ......
  14. }
  15. ......
  16. }
  17. ......
  18. }

函数首先把mPausingActivity变量清空，因为现在不需要它了，然后调用resumeTopActivityLokced进一步操作，它传入的参数即为代表Launcher这个Activity的ActivityRecord。

Step 21. ActivityStack.resumeTopActivityLokced
        这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：

  1. public class ActivityStack {
  2. ......
  3. final boolean resumeTopActivityLocked(ActivityRecord prev) {
  4. ......
  5. // Find the first activity that is not finishing.
  6. ActivityRecord next = topRunningActivityLocked(null);
  7. // Remember how we'll process this pause/resume situation, and ensure
  8. // that the state is reset however we wind up proceeding.
  9. final boolean userLeaving = mUserLeaving;
  10. mUserLeaving = false;
  11. ......
  12. next.delayedResume = false;
  13. // If the top activity is the resumed one, nothing to do.
  14. if (mResumedActivity == next && next.state == ActivityState.RESUMED) {
  15. ......
  16. return false;
  17. }
  18. // If we are sleeping, and there is no resumed activity, and the top
  19. // activity is paused, well that is the state we want.
  20. if ((mService.mSleeping || mService.mShuttingDown)
  21. && mLastPausedActivity == next && next.state == ActivityState.PAUSED) {
  22. ......
  23. return false;
  24. }
  25. .......
  26. // We need to start pausing the current activity so the top one
  27. // can be resumed...
  28. if (mResumedActivity != null) {
  29. ......
  30. return true;
  31. }
  32. ......
  33. if (next.app != null && next.app.thread != null) {
  34. ......
  35. } else {
  36. ......
  37. startSpecificActivityLocked(next, true, true);
  38. }
  39. return true;
  40. }
  41. ......
  42. }

通过上面的Step
9，我们知道，当前在堆栈顶端的Activity为我们即将要启动的MainActivity，这里通过调用
topRunningActivityLocked将它取回来，保存在next变量中。之前最后一个Resumed状态的Activity，即
Launcher，到了这里已经处于Paused状态了，因此，mResumedActivity为null。最后一个处于Paused状态的
Activity为Launcher，因此，这里的mLastPausedActivity就为Launcher。前面我们为MainActivity创
建了ActivityRecord后，它的app域一直保持为null。有了这些信息后，上面这段代码就容易理解了，它最终调用
startSpecificActivityLocked进行下一步操作。

Step 22. ActivityStack.startSpecificActivityLocked
       这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：

  1. public class ActivityStack {
  2. ......
  3. private final void startSpecificActivityLocked(ActivityRecord r,
  4. boolean andResume, boolean checkConfig) {
  5. // Is this activity's application already running?
  6. ProcessRecord app = mService.getProcessRecordLocked(r.processName,
  7. r.info.applicationInfo.uid);
  8. ......
  9. if (app != null && app.thread != null) {
  10. try {
  11. realStartActivityLocked(r, app, andResume, checkConfig);
  12. return;
  13. } catch (RemoteException e) {
  14. ......
  15. }
  16. }
  17. mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,
  18. "activity", r.intent.getComponent(), false);
  19. }
  20. ......
  21. }

注意，这里由于是第一次启动应用程序的Activity，所以下面语句：

  1. ProcessRecord app = mService.getProcessRecordLocked(r.processName,
  2. r.info.applicationInfo.uid);

取回来的app为null。在Activity应用程序中的AndroidManifest.xml配置文件中，我们没有指定Application标
签的process属性，系统就会默认使用package的名称，这里就是"shy.luo.activity"了。每一个应用程序都有自己的uid，因
此，这里uid +
process的组合就可以为每一个应用程序创建一个ProcessRecord。当然，我们可以配置两个应用程序具有相同的uid和package，或
者在AndroidManifest.xml配置文件的application标签或者activity标签中显式指定相同的process属性值，这
样，不同的应用程序也可以在同一个进程中启动。

函数最终执行ActivityManagerService.startProcessLocked函数进行下一步操作。

Step 23. ActivityManagerService.startProcessLocked

这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityManagerService.java文件中：

  1. public final class ActivityManagerService extends ActivityManagerNative
  2. implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
  3. ......
  4. final ProcessRecord startProcessLocked(String processName,
  5. ApplicationInfo info, boolean knownToBeDead, int intentFlags,
  6. String hostingType, ComponentName hostingName, boolean allowWhileBooting) {
  7. ProcessRecord app = getProcessRecordLocked(processName, info.uid);
  8. ......
  9. String hostingNameStr = hostingName != null
  10. ? hostingName.flattenToShortString() : null;
  11. ......
  12. if (app == null) {
  13. app = new ProcessRecordLocked(null, info, processName);
  14. mProcessNames.put(processName, info.uid, app);
  15. } else {
  16. // If this is a new package in the process, add the package to the list
  17. app.addPackage(info.packageName);
  18. }
  19. ......
  20. startProcessLocked(app, hostingType, hostingNameStr);
  21. return (app.pid != 0) ? app : null;
  22. }
  23. ......
  24. }

这里再次检查是否已经有以process +
uid命名的进程存在，在我们这个情景中，返回值app为null，因此，后面会创建一个ProcessRecord，并存保存在成员变量
mProcessNames中，最后，调用另一个startProcessLocked函数进一步操作：

  1. public final class ActivityManagerService extends ActivityManagerNative
  2. implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
  3. ......
  4. private final void startProcessLocked(ProcessRecord app,
  5. String hostingType, String hostingNameStr) {
  6. ......
  7. try {
  8. int uid = app.info.uid;
  9. int[] gids = null;
  10. try {
  11. gids = mContext.getPackageManager().getPackageGids(
  12. app.info.packageName);
  13. } catch (PackageManager.NameNotFoundException e) {
  14. ......
  15. }
  16. ......
  17. int debugFlags = 0;
  18. ......
  19. int pid = Process.start("android.app.ActivityThread",
  20. mSimpleProcessManagement ? app.processName : null, uid, uid,
  21. gids, debugFlags, null);
  22. ......
  23. } catch (RuntimeException e) {
  24. ......
  25. }
  26. }
  27. ......
  28. }

这里主要是调用Process.start接口来创建一个新的进程，新的进程会导入android.app.ActivityThread类，并且执行
它的main函数，这就是为什么我们前面说每一个应用程序都有一个ActivityThread实例来对应的原因。

Step 24. ActivityThread.main

这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中：

  1. public final class ActivityThread {
  2. ......
  3. private final void attach(boolean system) {
  4. ......
  5. mSystemThread = system;
  6. if (!system) {
  7. ......
  8. IActivityManager mgr = ActivityManagerNative.getDefault();
  9. try {
  10. mgr.attachApplication(mAppThread);
  11. } catch (RemoteException ex) {
  12. }
  13. } else {
  14. ......
  15. }
  16. }
  17. ......
  18. public static final void main(String[] args) {
  19. .......
  20. ActivityThread thread = new ActivityThread();
  21. thread.attach(false);
  22. ......
  23. Looper.loop();
  24. .......
  25. thread.detach();
  26. ......
  27. }
  28. }

这个函数在进程中创建一个ActivityThread实例，然后调用它的attach函数，接着就进入消息循环了，直到最后进程退出。

函数attach最终调用了ActivityManagerService的远程接口ActivityManagerProxy的
attachApplication函数，传入的参数是mAppThread，这是一个ApplicationThread类型的Binder对象，它的
作用是用来进行进程间通信的。

Step 25. ActivityManagerProxy.attachApplication

这个函数定义在frameworks/base/core/java/android/app/ActivityManagerNative.java文件中：

  1. class ActivityManagerProxy implements IActivityManager
  2. {
  3. ......
  4. public void attachApplication(IApplicationThread app) throws RemoteException
  5. {
  6. Parcel data = Parcel.obtain();
  7. Parcel reply = Parcel.obtain();
  8. data.writeInterfaceToken(IActivityManager.descriptor);
  9. data.writeStrongBinder(app.asBinder());
  10. mRemote.transact(ATTACH_APPLICATION_TRANSACTION, data, reply, 0);
  11. reply.readException();
  12. data.recycle();
  13. reply.recycle();
  14. }
  15. ......
  16. }

这里通过Binder驱动程序，最后进入ActivityManagerService的attachApplication函数中。

Step 26. ActivityManagerService.attachApplication

这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityManagerService.java文件中：

  1. public final class ActivityManagerService extends ActivityManagerNative
  2. implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
  3. ......
  4. public final void attachApplication(IApplicationThread thread) {
  5. synchronized (this) {
  6. int callingPid = Binder.getCallingPid();
  7. final long origId = Binder.clearCallingIdentity();
  8. attachApplicationLocked(thread, callingPid);
  9. Binder.restoreCallingIdentity(origId);
  10. }
  11. }
  12. ......
  13. }

这里将操作转发给attachApplicationLocked函数。

Step 27. ActivityManagerService.attachApplicationLocked

这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityManagerService.java文件中：

  1. public final class ActivityManagerService extends ActivityManagerNative
  2. implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
  3. ......
  4. private final boolean attachApplicationLocked(IApplicationThread thread,
  5. int pid) {
  6. // Find the application record that is being attached...  either via
  7. // the pid if we are running in multiple processes, or just pull the
  8. // next app record if we are emulating process with anonymous threads.
  9. ProcessRecord app;
  10. if (pid != MY_PID && pid >= 0) {
  11. synchronized (mPidsSelfLocked) {
  12. app = mPidsSelfLocked.get(pid);
  13. }
  14. } else if (mStartingProcesses.size() > 0) {
  15. ......
  16. } else {
  17. ......
  18. }
  19. if (app == null) {
  20. ......
  21. return false;
  22. }
  23. ......
  24. String processName = app.processName;
  25. try {
  26. thread.asBinder().linkToDeath(new AppDeathRecipient(
  27. app, pid, thread), 0);
  28. } catch (RemoteException e) {
  29. ......
  30. return false;
  31. }
  32. ......
  33. app.thread = thread;
  34. app.curAdj = app.setAdj = -100;
  35. app.curSchedGroup = Process.THREAD_GROUP_DEFAULT;
  36. app.setSchedGroup = Process.THREAD_GROUP_BG_NONINTERACTIVE;
  37. app.forcingToForeground = null;
  38. app.foregroundServices = false;
  39. app.debugging = false;
  40. ......
  41. boolean normalMode = mProcessesReady || isAllowedWhileBooting(app.info);
  42. ......
  43. boolean badApp = false;
  44. boolean didSomething = false;
  45. // See if the top visible activity is waiting to run in this process...
  46. ActivityRecord hr = mMainStack.topRunningActivityLocked(null);
  47. if (hr != null && normalMode) {
  48. if (hr.app == null && app.info.uid == hr.info.applicationInfo.uid
  49. && processName.equals(hr.processName)) {
  50. try {
  51. if (mMainStack.realStartActivityLocked(hr, app, true, true)) {
  52. didSomething = true;
  53. }
  54. } catch (Exception e) {
  55. ......
  56. }
  57. } else {
  58. ......
  59. }
  60. }
  61. ......
  62. return true;
  63. }
  64. ......
  65. }

在前面的Step
23中，已经创建了一个ProcessRecord，这里首先通过pid将它取回来，放在app变量中，然后对app的其它成员进行初始化，最后调用
mMainStack.realStartActivityLocked执行真正的Activity启动操作。这里要启动的Activity通过调用
mMainStack.topRunningActivityLocked(null)从堆栈顶端取回来，这时候在堆栈顶端的Activity就是
MainActivity了。

Step 28. ActivityStack.realStartActivityLocked

这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：

  1. public class ActivityStack {
  2. ......
  3. final boolean realStartActivityLocked(ActivityRecord r,
  4. ProcessRecord app, boolean andResume, boolean checkConfig)
  5. throws RemoteException {
  6. ......
  7. r.app = app;
  8. ......
  9. int idx = app.activities.indexOf(r);
  10. if (idx < 0) {
  11. app.activities.add(r);
  12. }
  13. ......
  14. try {
  15. ......
  16. List<ResultInfo> results = null;
  17. List<Intent> newIntents = null;
  18. if (andResume) {
  19. results = r.results;
  20. newIntents = r.newIntents;
  21. }
  22. ......
  23. app.thread.scheduleLaunchActivity(new Intent(r.intent), r,
  24. System.identityHashCode(r),
  25. r.info, r.icicle, results, newIntents, !andResume,
  26. mService.isNextTransitionForward());
  27. ......
  28. } catch (RemoteException e) {
  29. ......
  30. }
  31. ......
  32. return true;
  33. }
  34. ......
  35. }

这里最终通过app.thread进入到ApplicationThreadProxy的scheduleLaunchActivity函数中，注意，
这里的第二个参数r，是一个ActivityRecord类型的Binder对象，用来作来这个Activity的token值。

Step 29. ApplicationThreadProxy.scheduleLaunchActivity
        这个函数定义在frameworks/base/core/java/android/app/ApplicationThreadNative.java文件中：

  1. class ApplicationThreadProxy implements IApplicationThread {
  2. ......
  3. public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,
  4. ActivityInfo info, Bundle state, List<ResultInfo> pendingResults,
  5. List<Intent> pendingNewIntents, boolean notResumed, boolean isForward)
  6. throws RemoteException {
  7. Parcel data = Parcel.obtain();
  8. data.writeInterfaceToken(IApplicationThread.descriptor);
  9. intent.writeToParcel(data, 0);
  10. data.writeStrongBinder(token);
  11. data.writeInt(ident);
  12. info.writeToParcel(data, 0);
  13. data.writeBundle(state);
  14. data.writeTypedList(pendingResults);
  15. data.writeTypedList(pendingNewIntents);
  16. data.writeInt(notResumed ? 1 : 0);
  17. data.writeInt(isForward ? 1 : 0);
  18. mRemote.transact(SCHEDULE_LAUNCH_ACTIVITY_TRANSACTION, data, null,
  19. IBinder.FLAG_ONEWAY);
  20. data.recycle();
  21. }
  22. ......
  23. }

这个函数最终通过Binder驱动程序进入到ApplicationThread的scheduleLaunchActivity函数中。

Step 30. ApplicationThread.scheduleLaunchActivity
        这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中：

  1. public final class ActivityThread {
  2. ......
  3. private final class ApplicationThread extends ApplicationThreadNative {
  4. ......
  5. // we use token to identify this activity without having to send the
  6. // activity itself back to the activity manager. (matters more with ipc)
  7. public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,
  8. ActivityInfo info, Bundle state, List<ResultInfo> pendingResults,
  9. List<Intent> pendingNewIntents, boolean notResumed, boolean isForward) {
  10. ActivityClientRecord r = new ActivityClientRecord();
  11. r.token = token;
  12. r.ident = ident;
  13. r.intent = intent;
  14. r.activityInfo = info;
  15. r.state = state;
  16. r.pendingResults = pendingResults;
  17. r.pendingIntents = pendingNewIntents;
  18. r.startsNotResumed = notResumed;
  19. r.isForward = isForward;
  20. queueOrSendMessage(H.LAUNCH_ACTIVITY, r);
  21. }
  22. ......
  23. }
  24. ......
  25. }

函数首先创建一个ActivityClientRecord实例，并且初始化它的成员变量，然后调用ActivityThread类的queueOrSendMessage函数进一步处理。

Step 31. ActivityThread.queueOrSendMessage
         这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中：

  1. public final class ActivityThread {
  2. ......
  3. private final class ApplicationThread extends ApplicationThreadNative {
  4. ......
  5. // if the thread hasn't started yet, we don't have the handler, so just
  6. // save the messages until we're ready.
  7. private final void queueOrSendMessage(int what, Object obj) {
  8. queueOrSendMessage(what, obj, 0, 0);
  9. }
  10. ......
  11. private final void queueOrSendMessage(int what, Object obj, int arg1, int arg2) {
  12. synchronized (this) {
  13. ......
  14. Message msg = Message.obtain();
  15. msg.what = what;
  16. msg.obj = obj;
  17. msg.arg1 = arg1;
  18. msg.arg2 = arg2;
  19. mH.sendMessage(msg);
  20. }
  21. }
  22. ......
  23. }
  24. ......
  25. }

函数把消息内容放在msg中，然后通过mH把消息分发出去，这里的成员变量mH我们在前面已经见过，消息分发出去后，最后会调用H类的handleMessage函数。

Step 32. H.handleMessage

这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中：

  1. public final class ActivityThread {
  2. ......
  3. private final class H extends Handler {
  4. ......
  5. public void handleMessage(Message msg) {
  6. ......
  7. switch (msg.what) {
  8. case LAUNCH_ACTIVITY: {
  9. ActivityClientRecord r = (ActivityClientRecord)msg.obj;
  10. r.packageInfo = getPackageInfoNoCheck(
  11. r.activityInfo.applicationInfo);
  12. handleLaunchActivity(r, null);
  13. } break;
  14. ......
  15. }
  16. ......
  17. }
  18. ......
  19. }

这里最后调用ActivityThread类的handleLaunchActivity函数进一步处理。

Step 33. ActivityThread.handleLaunchActivity

这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中：

  1. public final class ActivityThread {
  2. ......
  3. private final void handleLaunchActivity(ActivityClientRecord r, Intent customIntent) {
  4. ......
  5. Activity a = performLaunchActivity(r, customIntent);
  6. if (a != null) {
  7. r.createdConfig = new Configuration(mConfiguration);
  8. Bundle oldState = r.state;
  9. handleResumeActivity(r.token, false, r.isForward);
  10. ......
  11. } else {
  12. ......
  13. }
  14. }
  15. ......
  16. }

这里首先调用performLaunchActivity函数来加载这个Activity类，即
shy.luo.activity.MainActivity，然后调用它的onCreate函数，最后回到handleLaunchActivity函
数时，再调用handleResumeActivity函数来使这个Activity进入Resumed状态，即会调用这个Activity的
onResume函数，这是遵循Activity的生命周期的。

Step 34. ActivityThread.performLaunchActivity
        这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中：

  1. public final class ActivityThread {
  2. ......
  3. private final Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
  4. ActivityInfo aInfo = r.activityInfo;
  5. if (r.packageInfo == null) {
  6. r.packageInfo = getPackageInfo(aInfo.applicationInfo,
  7. Context.CONTEXT_INCLUDE_CODE);
  8. }
  9. ComponentName component = r.intent.getComponent();
  10. if (component == null) {
  11. component = r.intent.resolveActivity(
  12. mInitialApplication.getPackageManager());
  13. r.intent.setComponent(component);
  14. }
  15. if (r.activityInfo.targetActivity != null) {
  16. component = new ComponentName(r.activityInfo.packageName,
  17. r.activityInfo.targetActivity);
  18. }
  19. Activity activity = null;
  20. try {
  21. java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
  22. activity = mInstrumentation.newActivity(
  23. cl, component.getClassName(), r.intent);
  24. r.intent.setExtrasClassLoader(cl);
  25. if (r.state != null) {
  26. r.state.setClassLoader(cl);
  27. }
  28. } catch (Exception e) {
  29. ......
  30. }
  31. try {
  32. Application app = r.packageInfo.makeApplication(false, mInstrumentation);
  33. ......
  34. if (activity != null) {
  35. ContextImpl appContext = new ContextImpl();
  36. appContext.init(r.packageInfo, r.token, this);
  37. appContext.setOuterContext(activity);
  38. CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
  39. Configuration config = new Configuration(mConfiguration);
  40. ......
  41. activity.attach(appContext, this, getInstrumentation(), r.token,
  42. r.ident, app, r.intent, r.activityInfo, title, r.parent,
  43. r.embeddedID, r.lastNonConfigurationInstance,
  44. r.lastNonConfigurationChildInstances, config);
  45. if (customIntent != null) {
  46. activity.mIntent = customIntent;
  47. }
  48. r.lastNonConfigurationInstance = null;
  49. r.lastNonConfigurationChildInstances = null;
  50. activity.mStartedActivity = false;
  51. int theme = r.activityInfo.getThemeResource();
  52. if (theme != 0) {
  53. activity.setTheme(theme);
  54. }
  55. activity.mCalled = false;
  56. mInstrumentation.callActivityOnCreate(activity, r.state);
  57. ......
  58. r.activity = activity;
  59. r.stopped = true;
  60. if (!r.activity.mFinished) {
  61. activity.performStart();
  62. r.stopped = false;
  63. }
  64. if (!r.activity.mFinished) {
  65. if (r.state != null) {
  66. mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);
  67. }
  68. }
  69. if (!r.activity.mFinished) {
  70. activity.mCalled = false;
  71. mInstrumentation.callActivityOnPostCreate(activity, r.state);
  72. if (!activity.mCalled) {
  73. throw new SuperNotCalledException(
  74. "Activity " + r.intent.getComponent().toShortString() +
  75. " did not call through to super.onPostCreate()");
  76. }
  77. }
  78. }
  79. r.paused = true;
  80. mActivities.put(r.token, r);
  81. } catch (SuperNotCalledException e) {
  82. ......
  83. } catch (Exception e) {
  84. ......
  85. }
  86. return activity;
  87. }
  88. ......
  89. }

函数前面是收集要启动的Activity的相关信息，主要package和component信息：

  1. ActivityInfo aInfo = r.activityInfo;
  2. if (r.packageInfo == null) {
  3. r.packageInfo = getPackageInfo(aInfo.applicationInfo,
  4. Context.CONTEXT_INCLUDE_CODE);
  5. }
  6. ComponentName component = r.intent.getComponent();
  7. if (component == null) {
  8. component = r.intent.resolveActivity(
  9. mInitialApplication.getPackageManager());
  10. r.intent.setComponent(component);
  11. }
  12. if (r.activityInfo.targetActivity != null) {
  13. component = new ComponentName(r.activityInfo.packageName,
  14. r.activityInfo.targetActivity);
  15. }

然后通过ClassLoader将shy.luo.activity.MainActivity类加载进来：

  1. Activity activity = null;
  2. try {
  3. java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
  4. activity = mInstrumentation.newActivity(
  5. cl, component.getClassName(), r.intent);
  6. r.intent.setExtrasClassLoader(cl);
  7. if (r.state != null) {
  8. r.state.setClassLoader(cl);
  9. }
  10. } catch (Exception e) {
  11. ......
  12. }

接下来是创建Application对象，这是根据AndroidManifest.xml配置文件中的Application标签的信息来创建的：

  1. Application app = r.packageInfo.makeApplication(false, mInstrumentation);

后面的代码主要创建Activity的上下文信息，并通过attach方法将这些上下文信息设置到MainActivity中去：

  1. activity.attach(appContext, this, getInstrumentation(), r.token,
  2. r.ident, app, r.intent, r.activityInfo, title, r.parent,
  3. r.embeddedID, r.lastNonConfigurationInstance,
  4. r.lastNonConfigurationChildInstances, config);

最后还要调用MainActivity的onCreate函数：

  1. mInstrumentation.callActivityOnCreate(activity, r.state);

这里不是直接调用MainActivity的onCreate函数，而是通过mInstrumentation的
callActivityOnCreate函数来间接调用，前面我们说过，mInstrumentation在这里的作用是监控Activity与系统的
交互操作，相当于是系统运行日志。

Step 35. MainActivity.onCreate

这个函数定义在packages/experimental/Activity/src/shy/luo/activity/MainActivity.java文件中，这是我们自定义的app工程文件：

  1. public class MainActivity extends Activity  implements OnClickListener {
  2. ......
  3. @Override
  4. public void onCreate(Bundle savedInstanceState) {
  5. ......
  6. Log.i(LOG_TAG, "Main Activity Created.");
  7. }
  8. ......
  9. }

这样，MainActivity就启动起来了，整个应用程序也启动起来了。

整个应用程序的启动过程要执行很多步骤，但是整体来看，主要分为以下五个阶段：

一. Step1 - Step 11：Launcher通过Binder进程间通信机制通知ActivityManagerService，它要启动一个Activity；

二. Step 12 - Step 16：ActivityManagerService通过Binder进程间通信机制通知Launcher进入Paused状态；

三. Step 17 - Step
24：Launcher通过Binder进程间通信机制通知ActivityManagerService，它已经准备就绪进入Paused状态，于是
ActivityManagerService就创建一个新的进程，用来启动一个ActivityThread实例，即将要启动的Activity就是在
这个ActivityThread实例中运行；

四. Step 25 - Step
27：ActivityThread通过Binder进程间通信机制将一个ApplicationThread类型的Binder对象传递给
ActivityManagerService，以便以后ActivityManagerService能够通过这个Binder对象和它进行通信；

五. Step 28 - Step 35：ActivityManagerService通过Binder进程间通信机制通知ActivityThread，现在一切准备就绪，它可以真正执行Activity的启动操作了。

这里不少地方涉及到了Binder进程间通信机制，相关资料请参考Android进程间通信（IPC）机制Binder简要介绍和学习计划一文。

这样，应用程序的启动过程就介绍完了，它实质上是启动应用程序的默认Activity，在下一篇文章中，我们将介绍在应用程序内部启动另一个
Activity的过程，即新的Activity与启动它的Activity将会在同一个进程（Process）和任务（Task）运行，敬请关注。

老罗的新浪微博：http://weibo.com/shengyangluo，欢迎关注！

相关文章