android8-0-0源码分析-app启动1

发表于 | 分类于

前言补充

当系统决定要在一个新的进程中启动一个Activity或者Service时，ActivityManagerService组件负责通知Zygote创建一个新的进程，然后在这个新的进程中启动这个Activity或者Service。

Android应用程序架构中非常核心的一点：MainActivity不需要知道SubActivity的存在，即它不直接拥有SubActivity的接口，但是它可以通过一个字符串来告诉应用程序框架层，它要启动的Activity的名称是什么，其它的事情就交给应用程序框架层来做，这种模式大大降低了模块间的耦合，利于开发。
对于每一个应用程序来说，都有一个ActivityThread来表示应用程序的主进程，而每一个ActivityThread都包含有一个ApplicationThread实例，它是一个Binder对象，负责和其它进程进行通信。

Binder是Android系统进程间通信（IPC）方式之一。

目前linux支持的IPC包括传统的管道，System V IPC，即消息队列/共享内存/信号量，以及socket中只有socket支持Client-Server的通信方式。
而Client-Server的通信方式在android系统中被广泛使用，诸如媒体播放，视音频频捕获，到各种让手机更智能的传感器（加速度，方位，温度，光亮度等）都由不同的Server负责管理，应用程序只需做为Client与这些Server建立连接便可以使用这些服务，花很少的时间和精力就能开发出令人眩目的功能。因此需要高效的CS通信。

传输性能方面：socket通用主用于跨网络性能低，消息队列与管道都是二次拷贝，共享性能控制复杂。binder只有一次拷贝。

安全性：传统IPC的接收方无法获得对方进程可靠的UID/PID（用户ID/进程ID），从而无法鉴别对方身份。接入点开放，无法私有通道。

Binder是一个实体位于Server的对象，client使用它的句柄调用其方法
Binder模糊了进程边界，淡化了进程间通信过程，整个系统仿佛运行于同一个面向对象的程序之中。形形色色的Binder对象以及星罗棋布的引用仿佛粘接各个应用程序的胶水，这也是Binder在英文里的原意。

Binder的四个角色：Server、Client、ServiceManager、Binder驱动。驱动位于内核空间。与互联网类似：服务器、客户端、域名服务器、路由器

https://blog.csdn.net/universus/article/details/6211589

目前知道：可用于进程间通信，大量用于android各层即可。

参考文：
http://duanqz.github.io/2016-07-29-Activity-LaunchProcess-Part1#%E6%A6%82%E8%BF%B0
老罗
gityuan

不得不说http://duanqz.github.io/ 这位大佬的博客写的太详细了而且版本很新……接下来尽量都看完

概览

一张图：

启动部分涉及4个进程：发起进程、system_server进程、Zygote进程、新建进程。
本篇我们先看启动部分的前俩个进程的工作，值得注意的是各安装的应用都会有自己的信息记录在AMS中，启动的Task也由其间接管理，对于将要启动的app，它会首先将其信息放入栈中再去执行进程的启动任务。

开始

1-Launcher3

点击屏幕最后会调用到：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
public boolean startActivitySafely(View v, Intent intent, ItemInfo item) {
    ...
    // Only launch using the new animation if the shortcut has not opted out (this is a
    // private contract between launcher and may be ignored in the future).
    boolean useLaunchAnimation = (v != null) &&
            !intent.hasExtra(INTENT_EXTRA_IGNORE_LAUNCH_ANIMATION);
    Bundle optsBundle = useLaunchAnimation ? getActivityLaunchOptions(v) : null;
    UserHandle user = item == null ? null : item.user;
    // Prepare intent
    intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
    if (v != null) {
        intent.setSourceBounds(getViewBounds(v));
    }
    try {
        if (Utilities.ATLEAST_MARSHMALLOW
                && (item instanceof ShortcutInfo)
                && (item.itemType == Favorites.ITEM_TYPE_SHORTCUT
                 || item.itemType == Favorites.ITEM_TYPE_DEEP_SHORTCUT)
                && !((ShortcutInfo) item).isPromise()) {
            // Shortcuts need some special checks due to legacy reasons.
            startShortcutIntentSafely(intent, optsBundle, item);
        } else if (user == null || user.equals(Process.myUserHandle())) {
            // Could be launching some bookkeeping activity
            startActivity(intent, optsBundle);
        } else {
            LauncherAppsCompat.getInstance(this).startActivityForProfile(
                    intent.getComponent(), user, intent.getSourceBounds(), optsBundle);
        }
        return true;
    } catch (ActivityNotFoundException|SecurityException e) {
        Toast.makeText(this, R.string.activity_not_found, Toast.LENGTH_SHORT).show();
        Log.e(TAG, "Unable to launch. tag=" + item + " intent=" + intent, e);
    }
    return false;
}
Activity的样式：
        <activity
            android:name=".firstActivity"
            android:label="1">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

可见它是在一个新的TASK中启动intent。
启动activity的规则为activity可以规定多个action与多个category。隐式启动activity发送的intent也可以指定一个action与多个category，当有activity匹配了intent的一个action与全部category时即可响应该意图。
ACTION-MAIN标识该Activity为入口，CATEGORY-LAUNCHER设置该组件为在当前应用程序启动器中优先级最高的Activity，通常为入口ACTION_MAIN配合使用。这俩个保证该组件导出可被其它启动。为系统规定所识别。
获取方式为：View->ItemInfo ->PromiseAppInfo

最后执行的是startActivity
此时还是应用之中。Activity的方法

Activity.startActivity
android-8.0.0_r1\frameworks\base\core\java\android\app\Activity.java

1
2
3
4
5
6
7
8
9
10
@Override
public void startActivity(Intent intent, @Nullable Bundle options) {
    if (options != null) {
        startActivityForResult(intent, -1, options);
    } else {
        // Note we want to go through this call for compatibility with
        // applications that may have overridden the method.
        startActivityForResult(intent, -1);
    }
}

2-startActivityForResult

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
        @Nullable Bundle options) {
    if (mParent == null) {
        options = transferSpringboardActivityOptions(options);
        Instrumentation.ActivityResult ar =
            mInstrumentation.execStartActivity(
                this, mMainThread.getApplicationThread(), mToken, this,
                intent, requestCode, options);
        if (ar != null) {
            mMainThread.sendActivityResult(
                mToken, mEmbeddedID, requestCode, ar.getResultCode(),
                ar.getResultData());
        }
        if (requestCode >= 0) {
            // If this start is requesting a result, we can avoid making
            // the activity visible until the result is received.  Setting
            // this code during onCreate(Bundle savedInstanceState) or onResume() will keep the
            // activity hidden during this time, to avoid flickering.
            // This can only be done when a result is requested because
            // that guarantees we will get information back when the
            // activity is finished, no matter what happens to it.
            mStartedActivity = true;
        }
        cancelInputsAndStartExitTransition(options);
        // TODO Consider clearing/flushing other event sources and events for child windows.
    } else {
        if (options != null) {
            mParent.startActivityFromChild(this, intent, requestCode, options);
        } else {
            // Note we want to go through this method for compatibility with
            // existing applications that may have overridden it.
            mParent.startActivityFromChild(this, intent, requestCode);
        }
    }
}

调用mInstrumentation.execStartActivity，Intrumentation成员变量用来监控程序和系统的交互
这里通过mMainThread.getApplicationThread获得它里面的ApplicationThread成员变量，它是一个Binder对象，负责与其它进程通信。
mMainThread是ActivityThread类型的，代表应用程序的主线程。
ActivityThread与ApplicationThread分别是同应用进程的不同线程。

3-execStartActivity

Instrumentation.execStartActivity
frameworks\base\core\java\android\app\Instrumentation.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 public ActivityResult execStartActivity(
         Context who, IBinder contextThread, IBinder token, Activity target,
         Intent intent, int requestCode, Bundle options) {
     IApplicationThread whoThread = (IApplicationThread) contextThread;
     Uri referrer = target != null ? target.onProvideReferrer() : null;
     if (referrer != null) {
         intent.putExtra(Intent.EXTRA_REFERRER, referrer);
     }
     if (mActivityMonitors != null) {
         synchronized (mSync) {
             final int N = mActivityMonitors.size();
             for (int i=0; i<N; i++) {
                 final ActivityMonitor am = mActivityMonitors.get(i);
                 ActivityResult result = null;
                 if (am.ignoreMatchingSpecificIntents()) {
                     result = am.onStartActivity(intent);
                 }
                 if (result != null) {
                     am.mHits++;
                     return result;
                 } else if (am.match(who, null, intent)) {
                     am.mHits++;
                     if (am.isBlocking()) {
                         return requestCode >= 0 ? am.getResult() : null;
                     }
                     break;
                 }
             }
         }
     }
     try {
         intent.migrateExtraStreamToClipData();
         intent.prepareToLeaveProcess(who);
//AMS远程调用
         int result = ActivityManager.getService()
             .startActivity(whoThread, who.getBasePackageName(), intent,
                     intent.resolveTypeIfNeeded(who.getContentResolver()),
                     token, target != null ? target.mEmbeddedID : null,
                     requestCode, 0, null, options);
         checkStartActivityResult(result, intent);
     } catch (RemoteException e) {
         throw new RuntimeException("Failure from system", e);
     }
     return null;
 }

ActivityManager.getService()拿到的是IActivityManager，IActivityManager是一个aidl文件
ActivityManagerService存在于system_server进程，ActivityManagerService继承自IActivityManager.Stub成为远程调用服务，所以上面ActivityManager.getService().startActivity调用的其实是ActivityManagerService里面的方法

注意这里是aidl跨进程调用。
关于aidl……我的理解就是android中的RPC方案：android进程间CS通信常用Binder，RPC远程调用除了传输问题还有接口定义问题，aidl就是用来定义RPC接口的。
这样就可以实现仿佛自我调用般的RPC远程调用。

4、5-startActivity、startActivityAsUser

ActivityManagerService存在于system_server进程
frameworks\base\services\core\java\com\android\server\am\ActivityManagerService.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
@Override
public final int startActivity(IApplicationThread caller, String callingPackage,
        Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
        int startFlags, ProfilerInfo profilerInfo, Bundle bOptions) {
    return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
            resultWho, requestCode, startFlags, profilerInfo, bOptions,
            UserHandle.getCallingUserId());
}
@Override
public final int startActivityAsUser(IApplicationThread caller, String callingPackage,
        Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
        int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId) {
    enforceNotIsolatedCaller("startActivity");
    userId = mUserController.handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(),
            userId, false, ALLOW_FULL_ONLY, "startActivity", null);
    // TODO: Switch to user app stacks here.
    return mActivityStarter.startActivityMayWait(caller, -1, callingPackage, intent,
            resolvedType, null, null, resultTo, resultWho, requestCode, startFlags,
            profilerInfo, null, null, bOptions, false, userId, null, null,
            "startActivityAsUser");
}

mActivityStarter为ActivityStarter类型的对象，该方法中取得userId调用其startActivityMayWait

接下来
ActivityStarter.java
–>startActivityMayWait
–>startActivityLocked
–>startActivity
–>startActivity
–>startActivityUnchecked

6-startActivityMayWait

ActivityStarter
frameworks\base\services\core\java\com\android\server\am\ActivityStarter.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
    final int startActivityMayWait(IApplicationThread caller, int callingUid,
            String callingPackage, Intent intent, String resolvedType,
            IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
            IBinder resultTo, String resultWho, int requestCode, int startFlags,
            ProfilerInfo profilerInfo, WaitResult outResult,
            Configuration globalConfig, Bundle bOptions, boolean ignoreTargetSecurity, int userId,
            IActivityContainer iContainer, TaskRecord inTask, String reason) {
...
     
 
        // Don't modify the client's object!
        intent = new Intent(intent);
...
        ResolveInfo rInfo = mSupervisor.resolveIntent(intent, resolvedType, userId);
...
        // Collect information about the target of the Intent.
        ActivityInfo aInfo = mSupervisor.resolveActivity(intent, rInfo, startFlags, profilerInfo);
...
        synchronized (mService) {
            if (container != null && container.mParentActivity != null &&
                    container.mParentActivity.state != RESUMED) {
                // Cannot start a child activity if the parent is not resumed.
                return ActivityManager.START_CANCELED;
            }
            final int realCallingPid = Binder.getCallingPid();
            final int realCallingUid = Binder.getCallingUid();
            int callingPid;
            if (callingUid >= 0) {
                callingPid = -1;
            } else if (caller == null) {
                callingPid = realCallingPid;
                callingUid = realCallingUid;
            } else {
                callingPid = callingUid = -1;
            }
...
...
            final ActivityRecord[] outRecord = new ActivityRecord[1];
            int res = startActivityLocked(caller, intent, ephemeralIntent, resolvedType,
                    aInfo, rInfo, voiceSession, voiceInteractor,
                    resultTo, resultWho, requestCode, callingPid,
                    callingUid, callingPackage, realCallingPid, realCallingUid, startFlags,
                    options, ignoreTargetSecurity, componentSpecified, outRecord, container,
                    inTask, reason);
...
  
            return res;
        }
    }

aInfo为应用信息

7、8-startActivityLocked、startActivity

startActivityLocked ：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
    int startActivityLocked(IApplicationThread caller, Intent intent, Intent ephemeralIntent,
            String resolvedType, ActivityInfo aInfo, ResolveInfo rInfo,
            IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
            IBinder resultTo, String resultWho, int requestCode, int callingPid, int callingUid,
            String callingPackage, int realCallingPid, int realCallingUid, int startFlags,
            ActivityOptions options, boolean ignoreTargetSecurity, boolean componentSpecified,
            ActivityRecord[] outActivity, ActivityStackSupervisor.ActivityContainer container,
            TaskRecord inTask, String reason) {
        if (TextUtils.isEmpty(reason)) {
            throw new IllegalArgumentException("Need to specify a reason.");
        }
        mLastStartReason = reason;
        mLastStartActivityTimeMs = System.currentTimeMillis();
        mLastStartActivityRecord[0] = null;
        mLastStartActivityResult = startActivity(caller, intent, ephemeralIntent, resolvedType,
                aInfo, rInfo, voiceSession, voiceInteractor, resultTo, resultWho, requestCode,
                callingPid, callingUid, callingPackage, realCallingPid, realCallingUid, startFlags,
                options, ignoreTargetSecurity, componentSpecified, mLastStartActivityRecord,
                container, inTask);
        if (outActivity != null) {
            // mLastStartActivityRecord[0] is set in the call to startActivity above.
            outActivity[0] = mLastStartActivityRecord[0];
        }
        return mLastStartActivityResult;
    }
	
	
    /** DO NOT call this method directly. Use {@link #startActivityLocked} instead. */
    private int startActivity(IApplicationThread caller, Intent intent, Intent ephemeralIntent,
            String resolvedType, ActivityInfo aInfo, ResolveInfo rInfo,
            IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
            IBinder resultTo, String resultWho, int requestCode, int callingPid, int callingUid,
            String callingPackage, int realCallingPid, int realCallingUid, int startFlags,
            ActivityOptions options, boolean ignoreTargetSecurity, boolean componentSpecified,
            ActivityRecord[] outActivity, ActivityStackSupervisor.ActivityContainer container,
            TaskRecord inTask) {
        int err = ActivityManager.START_SUCCESS;
        // Pull the optional Ephemeral Installer-only bundle out of the options early.
        final Bundle verificationBundle
                = options != null ? options.popAppVerificationBundle() : null;
        ProcessRecord callerApp = null;
        if (caller != null) {
            callerApp = mService.getRecordForAppLocked(caller);
            if (callerApp != null) {
                callingPid = callerApp.pid;
                callingUid = callerApp.info.uid;
            } else {
...
            }
        }
...
        ActivityRecord sourceRecord = null;
        ActivityRecord resultRecord = null;
        if (resultTo != null) {
            sourceRecord = mSupervisor.isInAnyStackLocked(resultTo);
            if (DEBUG_RESULTS) Slog.v(TAG_RESULTS,
                    "Will send result to " + resultTo + " " + sourceRecord);
            if (sourceRecord != null) {
                if (requestCode >= 0 && !sourceRecord.finishing) {
                    resultRecord = sourceRecord;
                }
            }
        }
        final int launchFlags = intent.getFlags();
...		
//，创建即将要启动的Activity的相关信息，并保存在r变量中
        ActivityRecord r = new ActivityRecord(mService, callerApp, callingPid, callingUid,
                callingPackage, intent, resolvedType, aInfo, mService.getGlobalConfiguration(),
                resultRecord, resultWho, requestCode, componentSpecified, voiceSession != null,
                mSupervisor, container, options, sourceRecord);
...
        return startActivity(r, sourceRecord, voiceSession, voiceInteractor, startFlags, true,
                options, inTask, outActivity);
    }

r中是要启动的Activity相关信息。
resultTo是Launcher这个Activity里面的一个Binder对象，通过它可以获得Launcher这个Activity的相关信息。callerApp也是Launcher的信息。

9、10-startActivityUnchecked

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
  private int startActivity(final ActivityRecord r, ActivityRecord sourceRecord,
          IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
          int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
          ActivityRecord[] outActivity) {
      int result = START_CANCELED;
      try {
          mService.mWindowManager.deferSurfaceLayout();
          result = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor,
                  startFlags, doResume, options, inTask, outActivity);
      } finally {
          // If we are not able to proceed, disassociate the activity from the task. Leaving an
          // activity in an incomplete state can lead to issues, such as performing operations
          // without a window container.
          if (!ActivityManager.isStartResultSuccessful(result)
                  && mStartActivity.getTask() != null) {
              mStartActivity.getTask().removeActivity(mStartActivity);
          }
          mService.mWindowManager.continueSurfaceLayout();
      }
      postStartActivityProcessing(r, result, mSupervisor.getLastStack().mStackId,  mSourceRecord,
              mTargetStack);
      return result;
  }
	
	
	
  // Note: This method should only be called from {@link startActivity}.
  private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
          IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
          int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
          ActivityRecord[] outActivity) {
      setInitialState(r, options, inTask, doResume, startFlags, sourceRecord, voiceSession,
              voiceInteractor);
      computeLaunchingTaskFlags();
      computeSourceStack();
      mIntent.setFlags(mLaunchFlags);
      ActivityRecord reusedActivity = getReusableIntentActivity();
      final int preferredLaunchStackId =
              (mOptions != null) ? mOptions.getLaunchStackId() : INVALID_STACK_ID;
      final int preferredLaunchDisplayId =
              (mOptions != null) ? mOptions.getLaunchDisplayId() : DEFAULT_DISPLAY;
      if (reusedActivity != null) {
          // When the flags NEW_TASK and CLEAR_TASK are set, then the task gets reused but
          // still needs to be a lock task mode violation since the task gets cleared out and
          // the device would otherwise leave the locked task.
          if (mSupervisor.isLockTaskModeViolation(reusedActivity.getTask(),
                  (mLaunchFlags & (FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_CLEAR_TASK))
                          == (FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_CLEAR_TASK))) {
              mSupervisor.showLockTaskToast();
              Slog.e(TAG, "startActivityUnchecked: Attempt to violate Lock Task Mode");
              return START_RETURN_LOCK_TASK_MODE_VIOLATION;
          }
          if (mStartActivity.getTask() == null) {
              mStartActivity.setTask(reusedActivity.getTask());
          }
          if (reusedActivity.getTask().intent == null) {
              // This task was started because of movement of the activity based on affinity...
              // Now that we are actually launching it, we can assign the base intent.
              reusedActivity.getTask().setIntent(mStartActivity);
          }
          // This code path leads to delivering a new intent, we want to make sure we schedule it
          // as the first operation, in case the activity will be resumed as a result of later
          // operations.
          if ((mLaunchFlags & FLAG_ACTIVITY_CLEAR_TOP) != 0
                  || isDocumentLaunchesIntoExisting(mLaunchFlags)
                  || mLaunchSingleInstance || mLaunchSingleTask) {
              final TaskRecord task = reusedActivity.getTask();
              // In this situation we want to remove all activities from the task up to the one
              // being started. In most cases this means we are resetting the task to its initial
              // state.
              final ActivityRecord top = task.performClearTaskForReuseLocked(mStartActivity,
                      mLaunchFlags);
              // The above code can remove {@code reusedActivity} from the task, leading to the
              // the {@code ActivityRecord} removing its reference to the {@code TaskRecord}. The
              // task reference is needed in the call below to
              // {@link setTargetStackAndMoveToFrontIfNeeded}.
              if (reusedActivity.getTask() == null) {
                  reusedActivity.setTask(task);
              }
              if (top != null) {
                  if (top.frontOfTask) {
                      // Activity aliases may mean we use different intents for the top activity,
                      // so make sure the task now has the identity of the new intent.
                      top.getTask().setIntent(mStartActivity);
                  }
                  ActivityStack.logStartActivity(AM_NEW_INTENT, mStartActivity, top.getTask());
                  top.deliverNewIntentLocked(mCallingUid, mStartActivity.intent,
                          mStartActivity.launchedFromPackage);
              }
          }
          sendPowerHintForLaunchStartIfNeeded(false /* forceSend */);
          reusedActivity = setTargetStackAndMoveToFrontIfNeeded(reusedActivity);
          final ActivityRecord outResult =
                  outActivity != null && outActivity.length > 0 ? outActivity[0] : null;
          // When there is a reused activity and the current result is a trampoline activity,
          // set the reused activity as the result.
          if (outResult != null && (outResult.finishing || outResult.noDisplay)) {
              outActivity[0] = reusedActivity;
          }
          if ((mStartFlags & START_FLAG_ONLY_IF_NEEDED) != 0) {
              // We don't need to start a new activity, and the client said not to do anything
              // if that is the case, so this is it!  And for paranoia, make sure we have
              // correctly resumed the top activity.
              resumeTargetStackIfNeeded();
              return START_RETURN_INTENT_TO_CALLER;
          }
          setTaskFromIntentActivity(reusedActivity);
          if (!mAddingToTask && mReuseTask == null) {
              // We didn't do anything...  but it was needed (a.k.a., client don't use that
              // intent!)  And for paranoia, make sure we have correctly resumed the top activity.
              resumeTargetStackIfNeeded();
              if (outActivity != null && outActivity.length > 0) {
                  outActivity[0] = reusedActivity;
              }
              return START_TASK_TO_FRONT;
          }
      }
      if (mStartActivity.packageName == null) {
          final ActivityStack sourceStack = mStartActivity.resultTo != null
                  ? mStartActivity.resultTo.getStack() : null;
          if (sourceStack != null) {
              sourceStack.sendActivityResultLocked(-1 /* callingUid */, mStartActivity.resultTo,
                      mStartActivity.resultWho, mStartActivity.requestCode, RESULT_CANCELED,
                      null /* data */);
          }
          ActivityOptions.abort(mOptions);
          return START_CLASS_NOT_FOUND;
      }
//如果堆栈栈顶就是要启动的Activity，不会重复启动
      // If the activity being launched is the same as the one currently at the top, then
      // we need to check if it should only be launched once.
      final ActivityStack topStack = mSupervisor.mFocusedStack;
      final ActivityRecord topFocused = topStack.topActivity();
      final ActivityRecord top = topStack.topRunningNonDelayedActivityLocked(mNotTop);
      final boolean dontStart = top != null && mStartActivity.resultTo == null
              && top.realActivity.equals(mStartActivity.realActivity)
              && top.userId == mStartActivity.userId
              && top.app != null && top.app.thread != null
              && ((mLaunchFlags & FLAG_ACTIVITY_SINGLE_TOP) != 0
              || mLaunchSingleTop || mLaunchSingleTask);
      if (dontStart) {
          ActivityStack.logStartActivity(AM_NEW_INTENT, top, top.getTask());
          // For paranoia, make sure we have correctly resumed the top activity.
          topStack.mLastPausedActivity = null;
          if (mDoResume) {
              mSupervisor.resumeFocusedStackTopActivityLocked();
          }
          ActivityOptions.abort(mOptions);
          if ((mStartFlags & START_FLAG_ONLY_IF_NEEDED) != 0) {
              // We don't need to start a new activity, and the client said not to do
              // anything if that is the case, so this is it!
              return START_RETURN_INTENT_TO_CALLER;
          }
          top.deliverNewIntentLocked(
                  mCallingUid, mStartActivity.intent, mStartActivity.launchedFromPackage);
          // Don't use mStartActivity.task to show the toast. We're not starting a new activity
          // but reusing 'top'. Fields in mStartActivity may not be fully initialized.
          mSupervisor.handleNonResizableTaskIfNeeded(top.getTask(), preferredLaunchStackId,
                  preferredLaunchDisplayId, topStack.mStackId);
          return START_DELIVERED_TO_TOP;
      }
//是否在新栈
      boolean newTask = false;
      final TaskRecord taskToAffiliate = (mLaunchTaskBehind && mSourceRecord != null)
              ? mSourceRecord.getTask() : null;
      // Should this be considered a new task?
      int result = START_SUCCESS;
      if (mStartActivity.resultTo == null && mInTask == null && !mAddingToTask
              && (mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0) {
          newTask = true;
          result = setTaskFromReuseOrCreateNewTask(
                  taskToAffiliate, preferredLaunchStackId, topStack);
      } else if (mSourceRecord != null) {
          result = setTaskFromSourceRecord();
      } else if (mInTask != null) {
          result = setTaskFromInTask();
      } else {
          // This not being started from an existing activity, and not part of a new task...
          // just put it in the top task, though these days this case should never happen.
          setTaskToCurrentTopOrCreateNewTask();
      }
      if (result != START_SUCCESS) {
          return result;
      }
      mService.grantUriPermissionFromIntentLocked(mCallingUid, mStartActivity.packageName,
              mIntent, mStartActivity.getUriPermissionsLocked(), mStartActivity.userId);
      mService.grantEphemeralAccessLocked(mStartActivity.userId, mIntent,
              mStartActivity.appInfo.uid, UserHandle.getAppId(mCallingUid));
      if (mSourceRecord != null) {
          mStartActivity.getTask().setTaskToReturnTo(mSourceRecord);
      }
      if (newTask) {
          EventLog.writeEvent(
                  EventLogTags.AM_CREATE_TASK, mStartActivity.userId,
                  mStartActivity.getTask().taskId);
      }
      ActivityStack.logStartActivity(
              EventLogTags.AM_CREATE_ACTIVITY, mStartActivity, mStartActivity.getTask());
      mTargetStack.mLastPausedActivity = null;
      sendPowerHintForLaunchStartIfNeeded(false /* forceSend */);
//停止其它Activity
      mTargetStack.startActivityLocked(mStartActivity, topFocused, newTask, mKeepCurTransition,
              mOptions);
      if (mDoResume) {
          final ActivityRecord topTaskActivity =
                  mStartActivity.getTask().topRunningActivityLocked();
          if (!mTargetStack.isFocusable()
                  || (topTaskActivity != null && topTaskActivity.mTaskOverlay
                  && mStartActivity != topTaskActivity)) {
              // If the activity is not focusable, we can't resume it, but still would like to
              // make sure it becomes visible as it starts (this will also trigger entry
              // animation). An example of this are PIP activities.
              // Also, we don't want to resume activities in a task that currently has an overlay
              // as the starting activity just needs to be in the visible paused state until the
              // over is removed.
              mTargetStack.ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
              // Go ahead and tell window manager to execute app transition for this activity
              // since the app transition will not be triggered through the resume channel.
              mWindowManager.executeAppTransition();
          } else {
              // If the target stack was not previously focusable (previous top running activity
              // on that stack was not visible) then any prior calls to move the stack to the
              // will not update the focused stack.  If starting the new activity now allows the
              // task stack to be focusable, then ensure that we now update the focused stack
              // accordingly.
              if (mTargetStack.isFocusable() && !mSupervisor.isFocusedStack(mTargetStack)) {
                  mTargetStack.moveToFront("startActivityUnchecked");
              }
              mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack, mStartActivity,
                      mOptions);
          }
      } else {
          mTargetStack.addRecentActivityLocked(mStartActivity);
      }
      mSupervisor.updateUserStackLocked(mStartActivity.userId, mTargetStack);
      mSupervisor.handleNonResizableTaskIfNeeded(mStartActivity.getTask(), preferredLaunchStackId,
              preferredLaunchDisplayId, mTargetStack.mStackId);
      return START_SUCCESS;
  }

该方法中获取activity的启动模式，activity的栈管理。若app未启动，在本方法中入栈并记录。
startActivityLocked 内切换界面，通知活动界面执行Paused
根据是否需要新栈创建新栈。调用resumeFocusedStackTopActivityLocked激活顶端的要启动的activity

11-resumeFocusedStackTopActivityLocked

ActivityStackSupervisor.java
–>resumeFocusedStackTopActivityLocked

frameworks\base\services\core\java\com\android\server\am\ActivityStackSupervisor.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
boolean resumeFocusedStackTopActivityLocked(
        ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
    if (targetStack != null && isFocusedStack(targetStack)) {
        return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
    }
    final ActivityRecord r = mFocusedStack.topRunningActivityLocked();
    if (r == null || r.state != RESUMED) {
        mFocusedStack.resumeTopActivityUncheckedLocked(null, null);
    } else if (r.state == RESUMED) {
        // Kick off any lingering app transitions form the MoveTaskToFront operation.
        mFocusedStack.executeAppTransition(targetOptions);
    }
    return false;
}

12、13-ActivityStack

ActivityStack.java
–>resumeTopActivityUncheckedLocked
–>resumeTopActivityInnerLocked

frameworks\base\services\core\java\com\android\server\am\ActivityStack.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
    boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
        if (mStackSupervisor.inResumeTopActivity) {
            // Don't even start recursing.
            return false;
        }
        boolean result = false;
        try {
            // Protect against recursion.
            mStackSupervisor.inResumeTopActivity = true;
            result = resumeTopActivityInnerLocked(prev, options);
        } finally {
            mStackSupervisor.inResumeTopActivity = false;
        }
        // When resuming the top activity, it may be necessary to pause the top activity (for
        // example, returning to the lock screen. We suppress the normal pause logic in
        // {@link #resumeTopActivityUncheckedLocked}, since the top activity is resumed at the end.
        // We call the {@link ActivityStackSupervisor#checkReadyForSleepLocked} again here to ensure
        // any necessary pause logic occurs.
        mStackSupervisor.checkReadyForSleepLocked();
        return result;
    }
	
    private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
        if (!mService.mBooting && !mService.mBooted) {
            // Not ready yet!
            return false;
        }
        // Find the next top-most activity to resume in this stack that is not finishing and is
        // focusable. If it is not focusable, we will fall into the case below to resume the
        // top activity in the next focusable task.
        final ActivityRecord next = topRunningActivityLocked(true /* focusableOnly */);
        final boolean hasRunningActivity = next != null;
        final ActivityRecord parent = mActivityContainer.mParentActivity;
        final boolean isParentNotResumed = parent != null && parent.state != ActivityState.RESUMED;
        if (hasRunningActivity
                && (isParentNotResumed || !mActivityContainer.isAttachedLocked())) {
            // Do not resume this stack if its parent is not resumed.
            // TODO: If in a loop, make sure that parent stack resumeTopActivity is called 1st.
            return false;
        }
        mStackSupervisor.cancelInitializingActivities();
        // Remember how we'll process this pause/resume situation, and ensure
        // that the state is reset however we wind up proceeding.
        final boolean userLeaving = mStackSupervisor.mUserLeaving;
        mStackSupervisor.mUserLeaving = false;
        if (!hasRunningActivity) {
            // There are no activities left in the stack, let's look somewhere else.
            return resumeTopActivityInNextFocusableStack(prev, options, "noMoreActivities");
        }
        next.delayedResume = false;
        // If the top activity is the resumed one, nothing to do.
        if (mResumedActivity == next && next.state == ActivityState.RESUMED &&
                    mStackSupervisor.allResumedActivitiesComplete()) {
......
        }
        final TaskRecord nextTask = next.getTask();
        final TaskRecord prevTask = prev != null ? prev.getTask() : null;
        if (prevTask != null && prevTask.getStack() == this &&
                prevTask.isOverHomeStack() && prev.finishing && prev.frontOfTask) {
            if (DEBUG_STACK)  mStackSupervisor.validateTopActivitiesLocked();
            if (prevTask == nextTask) {
                prevTask.setFrontOfTask();
            } else if (prevTask != topTask()) {
                // This task is going away but it was supposed to return to the home stack.
                // Now the task above it has to return to the home task instead.
                final int taskNdx = mTaskHistory.indexOf(prevTask) + 1;
                mTaskHistory.get(taskNdx).setTaskToReturnTo(HOME_ACTIVITY_TYPE);
            } else if (!isOnHomeDisplay()) {
                return false;
            } else if (!isHomeStack()){
                if (DEBUG_STATES) Slog.d(TAG_STATES,
                        "resumeTopActivityLocked: Launching home next");
                return isOnHomeDisplay() &&
                        mStackSupervisor.resumeHomeStackTask(prev, "prevFinished");
            }
        }
        // If we are sleeping, and there is no resumed activity, and the top
        // activity is paused, well that is the state we want.
        if (mService.isSleepingOrShuttingDownLocked()
                && mLastPausedActivity == next
                && mStackSupervisor.allPausedActivitiesComplete()) {
            // Make sure we have executed any pending transitions, since there
            // should be nothing left to do at this point.
            executeAppTransition(options);
            if (DEBUG_STATES) Slog.d(TAG_STATES,
                    "resumeTopActivityLocked: Going to sleep and all paused");
            if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
            return false;
        }
        // Make sure that the user who owns this activity is started.  If not,
        // we will just leave it as is because someone should be bringing
        // another user's activities to the top of the stack.
        if (!mService.mUserController.hasStartedUserState(next.userId)) {
            Slog.w(TAG, "Skipping resume of top activity " + next
                    + ": user " + next.userId + " is stopped");
            if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
            return false;
        }
        // The activity may be waiting for stop, but that is no longer
        // appropriate for it.
        mStackSupervisor.mStoppingActivities.remove(next);
        mStackSupervisor.mGoingToSleepActivities.remove(next);
        next.sleeping = false;
        mStackSupervisor.mActivitiesWaitingForVisibleActivity.remove(next);
        if (DEBUG_SWITCH) Slog.v(TAG_SWITCH, "Resuming " + next);
        // If we are currently pausing an activity, then don't do anything until that is done.
        if (!mStackSupervisor.allPausedActivitiesComplete()) {
            if (DEBUG_SWITCH || DEBUG_PAUSE || DEBUG_STATES) Slog.v(TAG_PAUSE,
                    "resumeTopActivityLocked: Skip resume: some activity pausing.");
            if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
            return false;
        }
        mStackSupervisor.setLaunchSource(next.info.applicationInfo.uid);
        boolean lastResumedCanPip = false;
        final ActivityStack lastFocusedStack = mStackSupervisor.getLastStack();
        if (lastFocusedStack != null && lastFocusedStack != this) {
            // So, why aren't we using prev here??? See the param comment on the method. prev doesn't
            // represent the last resumed activity. However, the last focus stack does if it isn't null.
            final ActivityRecord lastResumed = lastFocusedStack.mResumedActivity;
            lastResumedCanPip = lastResumed != null && lastResumed.checkEnterPictureInPictureState(
                    "resumeTopActivity", true /* noThrow */, userLeaving /* beforeStopping */);
        }
......
        // If the most recent activity was noHistory but was only stopped rather
        // than stopped+finished because the device went to sleep, we need to make
        // sure to finish it as we're making a new activity topmost.
        if (mService.isSleepingLocked() && mLastNoHistoryActivity != null &&
                !mLastNoHistoryActivity.finishing) {
            if (DEBUG_STATES) Slog.d(TAG_STATES,
                    "no-history finish of " + mLastNoHistoryActivity + " on new resume");
            requestFinishActivityLocked(mLastNoHistoryActivity.appToken, Activity.RESULT_CANCELED,
                    null, "resume-no-history", false);
            mLastNoHistoryActivity = null;
        }
        if (prev != null && prev != next) {
            if (!mStackSupervisor.mActivitiesWaitingForVisibleActivity.contains(prev)
                    && next != null && !next.nowVisible) {
                mStackSupervisor.mActivitiesWaitingForVisibleActivity.add(prev);
                if (DEBUG_SWITCH) Slog.v(TAG_SWITCH,
                        "Resuming top, waiting visible to hide: " + prev);
            } else {
                if (prev.finishing) {
                    prev.setVisibility(false);
                    if (DEBUG_SWITCH) Slog.v(TAG_SWITCH,
                            "Not waiting for visible to hide: " + prev + ", waitingVisible="
                            + mStackSupervisor.mActivitiesWaitingForVisibleActivity.contains(prev)
                            + ", nowVisible=" + next.nowVisible);
                } else {
                    if (DEBUG_SWITCH) Slog.v(TAG_SWITCH,
                            "Previous already visible but still waiting to hide: " + prev
                            + ", waitingVisible="
                            + mStackSupervisor.mActivitiesWaitingForVisibleActivity.contains(prev)
                            + ", nowVisible=" + next.nowVisible);
                }
            }
        }
        // Launching this app's activity, make sure the app is no longer
        // considered stopped.
        try {
            AppGlobals.getPackageManager().setPackageStoppedState(
                    next.packageName, false, next.userId); /* TODO: Verify if correct userid */
        } catch (RemoteException e1) {
        } catch (IllegalArgumentException e) {
            Slog.w(TAG, "Failed trying to unstop package "
                    + next.packageName + ": " + e);
        }
......
        ActivityStack lastStack = mStackSupervisor.getLastStack();
        if (next.app != null && next.app.thread != null) {
 .....
        } else {
            // Whoops, need to restart this activity!
            if (!next.hasBeenLaunched) {
                next.hasBeenLaunched = true;
            } else {
                if (SHOW_APP_STARTING_PREVIEW) {
                    next.showStartingWindow(null /* prev */, false /* newTask */,
                            false /* taskSwich */);
                }
                if (DEBUG_SWITCH) Slog.v(TAG_SWITCH, "Restarting: " + next);
            }
            if (DEBUG_STATES) Slog.d(TAG_STATES, "resumeTopActivityLocked: Restarting " + next);
            mStackSupervisor.startSpecificActivityLocked(next, true, true);
        }
        if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
        return true;
    }

当前在堆栈顶端的Activity为我们即将要启动的MainActivity，这里通过调用topRunningActivityLocked将它取回来，保存在next变量中。之前最后一个Resumed状态的Activity，即Launcher，到了这里已经处于Paused状态了，因此，mResumedActivity为null。最后一个处于Paused状态的Activity为Launcher，因此，这里的mLastPausedActivity就为Launcher。前面我们为MainActivity创建了ActivityRecord后，它的app域一直保持为null。

14-startSpecificActivityLocked

ActivityStackSupervisor.java
–>startSpecificActivityLocked
frameworks\base\services\core\java\com\android\server\am\ActivityStackSupervisor.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
  void startSpecificActivityLocked(ActivityRecord r,
          boolean andResume, boolean checkConfig) {
      // 这个app的进程是否已经启动过
      ProcessRecord app = mService.getProcessRecordLocked(r.processName,
              r.info.applicationInfo.uid, true);
      r.getStack().setLaunchTime(r);
//已经存在，直接运行
      if (app != null && app.thread != null) {
          try {
              if ((r.info.flags&ActivityInfo.FLAG_MULTIPROCESS) == 0
                      || !"android".equals(r.info.packageName)) {
                  // Don't add this if it is a platform component that is marked
                  // to run in multiple processes, because this is actually
                  // part of the framework so doesn't make sense to track as a
                  // separate apk in the process.
                  app.addPackage(r.info.packageName, r.info.applicationInfo.versionCode,
                          mService.mProcessStats);
              }
              realStartActivityLocked(r, app, andResume, checkConfig);
              return;
          } catch (RemoteException e) {
              Slog.w(TAG, "Exception when starting activity "
                      + r.intent.getComponent().flattenToShortString(), e);
          }
          // If a dead object exception was thrown -- fall through to
          // restart the application.
      }
//开进程启动
      mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,
              "activity", r.intent.getComponent(), false, false, true);
  }

第一次启动时
ProcessRecord app = mService.getProcessRecordLocked(r.processName,r.info.applicationInfo.uid, true);
为null。
在Activity应用程序中的AndroidManifest.xml配置文件中，我们没有指定Application标签的process属性，系统就会默认使用package的名称。每一个应用程序都有自己的uid，因此，这里uid + process的组合就可以为每一个应用程序创建一个ProcessRecord。当然，我们可以配置两个应用程序具有相同的uid和package，或者在AndroidManifest.xml配置文件的application标签或者activity标签中显式指定相同的process属性值，这样，不同的应用程序也可以在同一个进程中启动。

15、16、17-startProcessLocked

frameworks\base\services\core\java\com\android\server\am\ActivityManagerService.java
ActivityManagerService.startProcessLocked

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
  final ProcessRecord startProcessLocked(String processName,
          ApplicationInfo info, boolean knownToBeDead, int intentFlags,
          String hostingType, ComponentName hostingName, boolean allowWhileBooting,
          boolean isolated, boolean keepIfLarge) {
      return startProcessLocked(processName, info, knownToBeDead, intentFlags, hostingType,
              hostingName, allowWhileBooting, isolated, 0 /* isolatedUid */, keepIfLarge,
              null /* ABI override */, null /* entryPoint */, null /* entryPointArgs */,
              null /* crashHandler */);
  }
  final ProcessRecord startProcessLocked(String processName, ApplicationInfo info,
          boolean knownToBeDead, int intentFlags, String hostingType, ComponentName hostingName,
          boolean allowWhileBooting, boolean isolated, int isolatedUid, boolean keepIfLarge,
          String abiOverride, String entryPoint, String[] entryPointArgs, Runnable crashHandler) {
      long startTime = SystemClock.elapsedRealtime();
      ProcessRecord app;
......
      checkTime(startTime, "startProcess: stepping in to startProcess");
      startProcessLocked(
              app, hostingType, hostingNameStr, abiOverride, entryPoint, entryPointArgs);
      checkTime(startTime, "startProcess: done starting proc!");
      return (app.pid != 0) ? app : null;
  }
	
  private final void startProcessLocked(ProcessRecord app, String hostingType,
          String hostingNameStr, String abiOverride, String entryPoint, String[] entryPointArgs) {
      long startTime = SystemClock.elapsedRealtime();
      if (app.pid > 0 && app.pid != MY_PID) {
          checkTime(startTime, "startProcess: removing from pids map");
          synchronized (mPidsSelfLocked) {
              mPidsSelfLocked.remove(app.pid);
              mHandler.removeMessages(PROC_START_TIMEOUT_MSG, app);
          }
          checkTime(startTime, "startProcess: done removing from pids map");
          app.setPid(0);
      }
      if (DEBUG_PROCESSES && mProcessesOnHold.contains(app)) Slog.v(TAG_PROCESSES,
              "startProcessLocked removing on hold: " + app);
      mProcessesOnHold.remove(app);
      checkTime(startTime, "startProcess: starting to update cpu stats");
      updateCpuStats();
      checkTime(startTime, "startProcess: done updating cpu stats");
      try {
          try {
              final int userId = UserHandle.getUserId(app.uid);
              AppGlobals.getPackageManager().checkPackageStartable(app.info.packageName, userId);
          } catch (RemoteException e) {
              throw e.rethrowAsRuntimeException();
          }
          int uid = app.uid;
          int[] gids = null;
          int mountExternal = Zygote.MOUNT_EXTERNAL_NONE;
          if (!app.isolated) {
              int[] permGids = null;
              try {
                  checkTime(startTime, "startProcess: getting gids from package manager");
                  final IPackageManager pm = AppGlobals.getPackageManager();
                  permGids = pm.getPackageGids(app.info.packageName,
                          MATCH_DEBUG_TRIAGED_MISSING, app.userId);
                  StorageManagerInternal storageManagerInternal = LocalServices.getService(
                          StorageManagerInternal.class);
                  mountExternal = storageManagerInternal.getExternalStorageMountMode(uid,
                          app.info.packageName);
              } catch (RemoteException e) {
                  throw e.rethrowAsRuntimeException();
              }
              /*
               * Add shared application and profile GIDs so applications can share some
               * resources like shared libraries and access user-wide resources
               */
              if (ArrayUtils.isEmpty(permGids)) {
                  gids = new int[3];
              } else {
                  gids = new int[permGids.length + 3];
                  System.arraycopy(permGids, 0, gids, 3, permGids.length);
              }
              gids[0] = UserHandle.getSharedAppGid(UserHandle.getAppId(uid));
              gids[1] = UserHandle.getCacheAppGid(UserHandle.getAppId(uid));
              gids[2] = UserHandle.getUserGid(UserHandle.getUserId(uid));
          }
          checkTime(startTime, "startProcess: building args");
          if (mFactoryTest != FactoryTest.FACTORY_TEST_OFF) {
              if (mFactoryTest == FactoryTest.FACTORY_TEST_LOW_LEVEL
                      && mTopComponent != null
                      && app.processName.equals(mTopComponent.getPackageName())) {
                  uid = 0;
              }
              if (mFactoryTest == FactoryTest.FACTORY_TEST_HIGH_LEVEL
                      && (app.info.flags&ApplicationInfo.FLAG_FACTORY_TEST) != 0) {
                  uid = 0;
              }
          }
	
	
	//调试权限
          int debugFlags = 0;
          if ((app.info.flags & ApplicationInfo.FLAG_DEBUGGABLE) != 0) {
              debugFlags |= Zygote.DEBUG_ENABLE_JDWP;
              debugFlags |= Zygote.DEBUG_JAVA_DEBUGGABLE;
              // Also turn on CheckJNI for debuggable apps. It's quite
              // awkward to turn on otherwise.
              debugFlags |= Zygote.DEBUG_ENABLE_CHECKJNI;
          }
          // Run the app in safe mode if its manifest requests so or the
          // system is booted in safe mode.
          if ((app.info.flags & ApplicationInfo.FLAG_VM_SAFE_MODE) != 0 ||
              mSafeMode == true) {
              debugFlags |= Zygote.DEBUG_ENABLE_SAFEMODE;
          }
          if ("1".equals(SystemProperties.get("debug.checkjni"))) {
              debugFlags |= Zygote.DEBUG_ENABLE_CHECKJNI;
          }
          String genDebugInfoProperty = SystemProperties.get("debug.generate-debug-info");
          if ("true".equals(genDebugInfoProperty)) {
              debugFlags |= Zygote.DEBUG_GENERATE_DEBUG_INFO;
          }
          if ("1".equals(SystemProperties.get("debug.jni.logging"))) {
              debugFlags |= Zygote.DEBUG_ENABLE_JNI_LOGGING;
          }
          if ("1".equals(SystemProperties.get("debug.assert"))) {
              debugFlags |= Zygote.DEBUG_ENABLE_ASSERT;
          }
          if (mNativeDebuggingApp != null && mNativeDebuggingApp.equals(app.processName)) {
              // Enable all debug flags required by the native debugger.
              debugFlags |= Zygote.DEBUG_ALWAYS_JIT;          // Don't interpret anything
              debugFlags |= Zygote.DEBUG_GENERATE_DEBUG_INFO; // Generate debug info
              debugFlags |= Zygote.DEBUG_NATIVE_DEBUGGABLE;   // Disbale optimizations
              mNativeDebuggingApp = null;
          }
          String invokeWith = null;
          if ((app.info.flags & ApplicationInfo.FLAG_DEBUGGABLE) != 0) {
              // Debuggable apps may include a wrapper script with their library directory.
              String wrapperFileName = app.info.nativeLibraryDir + "/wrap.sh";
              StrictMode.ThreadPolicy oldPolicy = StrictMode.allowThreadDiskReads();
              try {
                  if (new File(wrapperFileName).exists()) {
                      invokeWith = "/system/bin/logwrapper " + wrapperFileName;
                  }
              } finally {
                  StrictMode.setThreadPolicy(oldPolicy);
              }
          }
          String requiredAbi = (abiOverride != null) ? abiOverride : app.info.primaryCpuAbi;
          if (requiredAbi == null) {
              requiredAbi = Build.SUPPORTED_ABIS[0];
          }
          String instructionSet = null;
          if (app.info.primaryCpuAbi != null) {
              instructionSet = VMRuntime.getInstructionSet(app.info.primaryCpuAbi);
          }
          app.gids = gids;
          app.requiredAbi = requiredAbi;
          app.instructionSet = instructionSet;
          // the per-user SELinux context must be set
          if (TextUtils.isEmpty(app.info.seInfoUser)) {
              Slog.wtf(TAG, "SELinux tag not defined",
                      new IllegalStateException("SELinux tag not defined for "
                      + app.info.packageName + " (uid " + app.uid + ")"));
          }
          final String seInfo = app.info.seInfo
                  + (TextUtils.isEmpty(app.info.seInfoUser) ? "" : app.info.seInfoUser);
          // Start the process.  It will either succeed and return a result containing
          // the PID of the new process, or else throw a RuntimeException.
          boolean isActivityProcess = (entryPoint == null);
	
	//入口点
          if (entryPoint == null) entryPoint = "android.app.ActivityThread";
          Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "Start proc: " +
                  app.processName);
          checkTime(startTime, "startProcess: asking zygote to start proc");
          ProcessStartResult startResult;
          if (hostingType.equals("webview_service")) {
              startResult = startWebView(entryPoint,
                      app.processName, uid, uid, gids, debugFlags, mountExternal,
                      app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
                      app.info.dataDir, null, entryPointArgs);
          } else {
		
		//进程开启
              startResult = Process.start(entryPoint,
                      app.processName, uid, uid, gids, debugFlags, mountExternal,
                      app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
                      app.info.dataDir, invokeWith, entryPointArgs);
          }
          checkTime(startTime, "startProcess: returned from zygote!");
          Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
          mBatteryStatsService.noteProcessStart(app.processName, app.info.uid);
          checkTime(startTime, "startProcess: done updating battery stats");
          EventLog.writeEvent(EventLogTags.AM_PROC_START,
                  UserHandle.getUserId(uid), startResult.pid, uid,
                  app.processName, hostingType,
                  hostingNameStr != null ? hostingNameStr : "");
          try {
              AppGlobals.getPackageManager().logAppProcessStartIfNeeded(app.processName, app.uid,
                      seInfo, app.info.sourceDir, startResult.pid);
          } catch (RemoteException ex) {
              // Ignore
          }
          if (app.persistent) {
              Watchdog.getInstance().processStarted(app.processName, startResult.pid);
          }
          checkTime(startTime, "startProcess: building log message");
          StringBuilder buf = mStringBuilder;
          buf.setLength(0);
          buf.append("Start proc ");
          buf.append(startResult.pid);
          buf.append(':');
          buf.append(app.processName);
          buf.append('/');
          UserHandle.formatUid(buf, uid);
          if (!isActivityProcess) {
              buf.append(" [");
              buf.append(entryPoint);
              buf.append("]");
          }
          buf.append(" for ");
          buf.append(hostingType);
          if (hostingNameStr != null) {
              buf.append(" ");
              buf.append(hostingNameStr);
          }
          Slog.i(TAG, buf.toString());
          app.setPid(startResult.pid);
          app.usingWrapper = startResult.usingWrapper;
          app.removed = false;
          app.killed = false;
          app.killedByAm = false;
          checkTime(startTime, "startProcess: starting to update pids map");
          ProcessRecord oldApp;
          synchronized (mPidsSelfLocked) {
              oldApp = mPidsSelfLocked.get(startResult.pid);
          }
          // If there is already an app occupying that pid that hasn't been cleaned up
          if (oldApp != null && !app.isolated) {
              // Clean up anything relating to this pid first
              Slog.w(TAG, "Reusing pid " + startResult.pid
                      + " while app is still mapped to it");
              cleanUpApplicationRecordLocked(oldApp, false, false, -1,
                      true /*replacingPid*/);
          }
          synchronized (mPidsSelfLocked) {
              this.mPidsSelfLocked.put(startResult.pid, app);
              if (isActivityProcess) {
                  Message msg = mHandler.obtainMessage(PROC_START_TIMEOUT_MSG);
                  msg.obj = app;
                  mHandler.sendMessageDelayed(msg, startResult.usingWrapper
                          ? PROC_START_TIMEOUT_WITH_WRAPPER : PROC_START_TIMEOUT);
              }
          }
          checkTime(startTime, "startProcess: done updating pids map");
      } catch (RuntimeException e) {
          Slog.e(TAG, "Failure starting process " + app.processName, e);
          // Something went very wrong while trying to start this process; one
          // common case is when the package is frozen due to an active
          // upgrade. To recover, clean up any active bookkeeping related to
          // starting this process. (We already invoked this method once when
          // the package was initially frozen through KILL_APPLICATION_MSG, so
          // it doesn't hurt to use it again.)
          forceStopPackageLocked(app.info.packageName, UserHandle.getAppId(app.uid), false,
                  false, true, false, false, UserHandle.getUserId(app.userId), "start failure");
      }
  }

三个startProcessLocked方法，最后一个设置进程属性，entryPoint表示入口方法android.app.ActivityThread。Process.start开始进程。

18-start

Process.start
frameworks\base\core\java\android\os\Process.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 * @param processClass The class to use as the process's main entry
 *                     point.
 * @param niceName A more readable name to use for the process.
 * @param uid The user-id under which the process will run.
 * @param gid The group-id under which the process will run.
 * @param gids Additional group-ids associated with the process.
 * @param debugFlags Additional flags.
 * @param targetSdkVersion The target SDK version for the app.
 * @param seInfo null-ok SELinux information for the new process.
 * @param abi non-null the ABI this app should be started with.
 * @param instructionSet null-ok the instruction set to use.
 * @param appDataDir null-ok the data directory of the app.
 * @param invokeWith null-ok the command to invoke with.
 * @param zygoteArgs Additional arguments to supply to the zygote process.
 * 
 * @return An object that describes the result of the attempt to start the process.
 * @throws RuntimeException on fatal start failure
 * 
 * {@hide}
 */
public static final ProcessStartResult start(final String processClass,
                              final String niceName,
                              int uid, int gid, int[] gids,
                              int debugFlags, int mountExternal,
                              int targetSdkVersion,
                              String seInfo,
                              String abi,
                              String instructionSet,
                              String appDataDir,
                              String invokeWith,
                              String[] zygoteArgs) {
    return zygoteProcess.start(processClass, niceName, uid, gid, gids,
                debugFlags, mountExternal, targetSdkVersion, seInfo,
                abi, instructionSet, appDataDir, invokeWith, zygoteArgs);
}

zygoteProcess进程是final static的，可见其唯一性，调用其产生进程。
此时还在server

19、20-start、startViaZygote

ZygoteProcess.start
frameworks\base\core\java\android\os\ZygoteProcess.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
    /**
     * Start a new process.
     *
     * <p>If processes are enabled, a new process is created and the
     * static main() function of a <var>processClass</var> is executed there.
     * The process will continue running after this function returns.
     *
     * <p>If processes are not enabled, a new thread in the caller's
     * process is created and main() of <var>processClass</var> called there.
     *
     * <p>The niceName parameter, if not an empty string, is a custom name to
     * give to the process instead of using processClass.  This allows you to
     * make easily identifyable processes even if you are using the same base
     * <var>processClass</var> to start them.
     *
     * When invokeWith is not null, the process will be started as a fresh app
     * and not a zygote fork. Note that this is only allowed for uid 0 or when
     * debugFlags contains DEBUG_ENABLE_DEBUGGER.
     *
     * @param processClass The class to use as the process's main entry
     *                     point.
     * @param niceName A more readable name to use for the process.
     * @param uid The user-id under which the process will run.
     * @param gid The group-id under which the process will run.
     * @param gids Additional group-ids associated with the process.
     * @param debugFlags Additional flags.
     * @param targetSdkVersion The target SDK version for the app.
     * @param seInfo null-ok SELinux information for the new process.
     * @param abi non-null the ABI this app should be started with.
     * @param instructionSet null-ok the instruction set to use.
     * @param appDataDir null-ok the data directory of the app.
     * @param invokeWith null-ok the command to invoke with.
     * @param zygoteArgs Additional arguments to supply to the zygote process.
     *
     * @return An object that describes the result of the attempt to start the process.
     * @throws RuntimeException on fatal start failure
     */
    public final Process.ProcessStartResult start(final String processClass,
                                                  final String niceName,
                                                  int uid, int gid, int[] gids,
                                                  int debugFlags, int mountExternal,
                                                  int targetSdkVersion,
                                                  String seInfo,
                                                  String abi,
                                                  String instructionSet,
                                                  String appDataDir,
                                                  String invokeWith,
                                                  String[] zygoteArgs) {
        try {
            return startViaZygote(processClass, niceName, uid, gid, gids,
                    debugFlags, mountExternal, targetSdkVersion, seInfo,
                    abi, instructionSet, appDataDir, invokeWith, zygoteArgs);
        } catch (ZygoteStartFailedEx ex) {
            Log.e(LOG_TAG,
                    "Starting VM process through Zygote failed");
            throw new RuntimeException(
                    "Starting VM process through Zygote failed", ex);
        }
    }
	
	
    /**
     * Starts a new process via the zygote mechanism.
     *
     * @param processClass Class name whose static main() to run
     * @param niceName 'nice' process name to appear in ps
     * @param uid a POSIX uid that the new process should setuid() to
     * @param gid a POSIX gid that the new process shuold setgid() to
     * @param gids null-ok; a list of supplementary group IDs that the
     * new process should setgroup() to.
     * @param debugFlags Additional flags.
     * @param targetSdkVersion The target SDK version for the app.
     * @param seInfo null-ok SELinux information for the new process.
     * @param abi the ABI the process should use.
     * @param instructionSet null-ok the instruction set to use.
     * @param appDataDir null-ok the data directory of the app.
     * @param extraArgs Additional arguments to supply to the zygote process.
     * @return An object that describes the result of the attempt to start the process.
     * @throws ZygoteStartFailedEx if process start failed for any reason
     */
    private Process.ProcessStartResult startViaZygote(final String processClass,
                                                      final String niceName,
                                                      final int uid, final int gid,
                                                      final int[] gids,
                                                      int debugFlags, int mountExternal,
                                                      int targetSdkVersion,
                                                      String seInfo,
                                                      String abi,
                                                      String instructionSet,
                                                      String appDataDir,
                                                      String invokeWith,
                                                      String[] extraArgs)
                                                      throws ZygoteStartFailedEx {
        ArrayList<String> argsForZygote = new ArrayList<String>();
        // --runtime-args, --setuid=, --setgid=,
        // and --setgroups= must go first
        argsForZygote.add("--runtime-args");
        argsForZygote.add("--setuid=" + uid);
        argsForZygote.add("--setgid=" + gid);
        if ((debugFlags & Zygote.DEBUG_ENABLE_JNI_LOGGING) != 0) {
            argsForZygote.add("--enable-jni-logging");
        }
        if ((debugFlags & Zygote.DEBUG_ENABLE_SAFEMODE) != 0) {
            argsForZygote.add("--enable-safemode");
        }
        if ((debugFlags & Zygote.DEBUG_ENABLE_JDWP) != 0) {
            argsForZygote.add("--enable-jdwp");
        }
        if ((debugFlags & Zygote.DEBUG_ENABLE_CHECKJNI) != 0) {
            argsForZygote.add("--enable-checkjni");
        }
        if ((debugFlags & Zygote.DEBUG_GENERATE_DEBUG_INFO) != 0) {
            argsForZygote.add("--generate-debug-info");
        }
        if ((debugFlags & Zygote.DEBUG_ALWAYS_JIT) != 0) {
            argsForZygote.add("--always-jit");
        }
        if ((debugFlags & Zygote.DEBUG_NATIVE_DEBUGGABLE) != 0) {
            argsForZygote.add("--native-debuggable");
        }
        if ((debugFlags & Zygote.DEBUG_JAVA_DEBUGGABLE) != 0) {
            argsForZygote.add("--java-debuggable");
        }
        if ((debugFlags & Zygote.DEBUG_ENABLE_ASSERT) != 0) {
            argsForZygote.add("--enable-assert");
        }
        if (mountExternal == Zygote.MOUNT_EXTERNAL_DEFAULT) {
            argsForZygote.add("--mount-external-default");
        } else if (mountExternal == Zygote.MOUNT_EXTERNAL_READ) {
            argsForZygote.add("--mount-external-read");
        } else if (mountExternal == Zygote.MOUNT_EXTERNAL_WRITE) {
            argsForZygote.add("--mount-external-write");
        }
        argsForZygote.add("--target-sdk-version=" + targetSdkVersion);
        // --setgroups is a comma-separated list
        if (gids != null && gids.length > 0) {
            StringBuilder sb = new StringBuilder();
            sb.append("--setgroups=");
            int sz = gids.length;
            for (int i = 0; i < sz; i++) {
                if (i != 0) {
                    sb.append(',');
                }
                sb.append(gids[i]);
            }
            argsForZygote.add(sb.toString());
        }
        if (niceName != null) {
            argsForZygote.add("--nice-name=" + niceName);
        }
        if (seInfo != null) {
            argsForZygote.add("--seinfo=" + seInfo);
        }
        if (instructionSet != null) {
            argsForZygote.add("--instruction-set=" + instructionSet);
        }
        if (appDataDir != null) {
            argsForZygote.add("--app-data-dir=" + appDataDir);
        }
        if (invokeWith != null) {
            argsForZygote.add("--invoke-with");
            argsForZygote.add(invokeWith);
        }
        argsForZygote.add(processClass);
        if (extraArgs != null) {
            for (String arg : extraArgs) {
                argsForZygote.add(arg);
            }
        }
        synchronized(mLock) {
            return zygoteSendArgsAndGetResult(openZygoteSocketIfNeeded(abi), argsForZygote);
        }
    }
    /**
     * Tries to open socket to Zygote process if not already open. If
     * already open, does nothing.  May block and retry.  Requires that mLock be held.
     */
    @GuardedBy("mLock")
    private ZygoteState openZygoteSocketIfNeeded(String abi) throws ZygoteStartFailedEx {
        Preconditions.checkState(Thread.holdsLock(mLock), "ZygoteProcess lock not held");
        if (primaryZygoteState == null || primaryZygoteState.isClosed()) {
            try {
                primaryZygoteState = ZygoteState.connect(mSocket);
            } catch (IOException ioe) {
                throw new ZygoteStartFailedEx("Error connecting to primary zygote", ioe);
            }
        }
        if (primaryZygoteState.matches(abi)) {
            return primaryZygoteState;
        }
        // The primary zygote didn't match. Try the secondary.
        if (secondaryZygoteState == null || secondaryZygoteState.isClosed()) {
            try {
                secondaryZygoteState = ZygoteState.connect(mSecondarySocket);
            } catch (IOException ioe) {
                throw new ZygoteStartFailedEx("Error connecting to secondary zygote", ioe);
            }
        }
        if (secondaryZygoteState.matches(abi)) {
            return secondaryZygoteState;
        }
        throw new ZygoteStartFailedEx("Unsupported zygote ABI: " + abi);
    }
/**
 * The state of the connection to the primary zygote.
 */
private ZygoteState primaryZygoteState;
/**
 * The state of the connection to the secondary zygote.
 */
private ZygoteState secondaryZygoteState;

设置参数。ZygoteState一共有俩个，都是与zygote通信用的，openZygoteSocketIfNeeded内尝试连接zygote返回ZygoteState。为socket连接

21-zygoteSendArgsAndGetResult

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
  /**
   * Sends an argument list to the zygote process, which starts a new child
   * and returns the child's pid. Please note: the present implementation
   * replaces newlines in the argument list with spaces.
   *
   * @throws ZygoteStartFailedEx if process start failed for any reason
   */
//发送参数表给zygote进程，返回新的进程pid
  @GuardedBy("mLock")
  private static Process.ProcessStartResult zygoteSendArgsAndGetResult(
          ZygoteState zygoteState, ArrayList<String> args)
          throws ZygoteStartFailedEx {
      try {
          // Throw early if any of the arguments are malformed. This means we can
          // avoid writing a partial response to the zygote.
          int sz = args.size();
          for (int i = 0; i < sz; i++) {
              if (args.get(i).indexOf('\n') >= 0) {
                  throw new ZygoteStartFailedEx("embedded newlines not allowed");
              }
          }
          /**
           * See com.android.internal.os.SystemZygoteInit.readArgumentList()
           * Presently the wire format to the zygote process is:
           * a) a count of arguments (argc, in essence)
           * b) a number of newline-separated argument strings equal to count
           *
           * After the zygote process reads these it will write the pid of
           * the child or -1 on failure, followed by boolean to
           * indicate whether a wrapper process was used.
           */
          final BufferedWriter writer = zygoteState.writer;
          final DataInputStream inputStream = zygoteState.inputStream;
          writer.write(Integer.toString(args.size()));
          writer.newLine();
          for (int i = 0; i < sz; i++) {
              String arg = args.get(i);
              writer.write(arg);
              writer.newLine();
          }
          writer.flush();
          // Should there be a timeout on this?
          Process.ProcessStartResult result = new Process.ProcessStartResult();
          // Always read the entire result from the input stream to avoid leaving
          // bytes in the stream for future process starts to accidentally stumble
          // upon.
	  //等待socket服务端（即zygote）返回新创建的进程pid
          result.pid = inputStream.readInt();
          result.usingWrapper = inputStream.readBoolean();
          if (result.pid < 0) {
              throw new ZygoteStartFailedEx("fork() failed");
          }
          return result;
      } catch (IOException ex) {
          zygoteState.close();
          throw new ZygoteStartFailedEx(ex);
      }
  }

开启对zygote的写与读，发送args。注意此时还在AMS进程

这里就与之前android系统启动的文章相接了。

后记

这部分主要完成了以下几个工作：

  1. Launcher通过Binder进程间通信机制通知ActivityManagerService，它要启动一个Activity；
  2. ActivityManagerService通过Binder进程间通信机制通知Launcher进入Paused状态–10中的startActivityLocked
  3. 暂停成功后通过Task管理保存新应用信息并向zygote发送消息进行分裂新进程。