Android应用启动过程分析

发表于 | 分类于

引言

在知乎上看到一个问题，是关于Android中应用的入口到底在哪里，本文以点击Launcher中某个icon为启动，分析Android应用的启动过程。

1.点击Launcher中的icon

Launcher其实也就是一个特殊的Activity而已,点击icon时的执行逻辑如下:

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
public void onClick(View v) {
         ...
        Object tag = v.getTag();
        if (tag instanceof ShortcutInfo) {
            // Open shortcut
            final Intent intent = ((ShortcutInfo) tag).intent;
            int[] pos = new int[2];
            v.getLocationOnScreen(pos);
            intent.setSourceBounds(new Rect(pos[0], pos[1],
                    pos[0] + v.getWidth(), pos[1] + v.getHeight()));
       
            //here is where to start activity
            boolean success = startActivitySafely(v, intent, tag);
            if (success && v instanceof BubbleTextView) {
                mWaitingForResume = (BubbleTextView) v;
                mWaitingForResume.setStayPressed(true);
            }
        } else if (tag instanceof FolderInfo) {
            if (v instanceof FolderIcon) {
                FolderIcon fi = (FolderIcon) v;
                handleFolderClick(fi);
            }
        } else if (v == mAllAppsButton) {
            ...
        }
    }

显然，startActivitySafely()就是打开App的代码：

1
2
3
4
5
6
7
8
9
10
boolean startActivitySafely(View v, Intent intent, Object tag) {
        boolean success = false;
        try {
            success = startActivity(v, intent, tag);
        } catch (ActivityNotFoundException e) {
            Toast.makeText(this, R.string.activity_not_found, Toast.LENGTH_SHORT).show();
            Log.e(TAG, "Unable to launch. tag=" + tag + " intent=" + intent, e);
        }
        return success;
    }

显然，这里只是做一个检查,看该activity是否能找到,startActivity()的代码如下:

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
boolean startActivity(View v, Intent intent, Object tag) {
        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        try {
            // 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);
            UserHandle user = (UserHandle) intent.getParcelableExtra(ApplicationInfo.EXTRA_PROFILE);
            LauncherApps launcherApps = (LauncherApps)
                    this.getSystemService(Context.LAUNCHER_APPS_SERVICE);
            if (useLaunchAnimation) {
                ActivityOptions opts = ActivityOptions.makeScaleUpAnimation(v, 0, 0,
                        v.getMeasuredWidth(), v.getMeasuredHeight());
                if (user == null || user.equals(android.os.Process.myUserHandle())) {
                    // Could be launching some bookkeeping activity
                    startActivity(intent, opts.toBundle());
                } else {
                    launcherApps.startMainActivity(intent.getComponent(), user,
                            intent.getSourceBounds(),
                            opts.toBundle());
                }
            } else {
                if (user == null || user.equals(android.os.Process.myUserHandle())) {
                    startActivity(intent);
                } else {
                    launcherApps.startMainActivity(intent.getComponent(), user,
                            intent.getSourceBounds(), null);
                }
            }
            return true;
        } catch (SecurityException e) {
           ...
           return false;
    }

代码虽然有点长，但是逻辑很简单，即区分是否使用launch动画，之后会调用到Activity中的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
38
39
public void startActivityForResult(Intent intent, int requestCode, @Nullable Bundle options) {
		if (mParent == null) {
			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;
			}
			final View decor = mWindow != null ? mWindow.peekDecorView() : null;
			if (decor != null) {
				decor.cancelPendingInputEvents();
			}
			// 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);
			}
		}
		if (options != null && !isTopOfTask()) {
			mActivityTransitionState.startExitOutTransition(this, options);
		}
	}

启动App时mParent为null,故调用Instrumentation#execStartActivity()方法：

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
public ActivityResult execStartActivity(
            Context who, IBinder contextThread, IBinder token, Activity target,
            Intent intent, int requestCode, Bundle options) {
        IApplicationThread whoThread = (IApplicationThread) contextThread;
        if (mActivityMonitors != null) {
            synchronized (mSync) {
                final int N = mActivityMonitors.size();
                for (int i=0; i<N; i++) {
                    final ActivityMonitor am = mActivityMonitors.get(i);
                    if (am.match(who, null, intent)) {
                        am.mHits++;
                        if (am.isBlocking()) {
                            return requestCode >= 0 ? am.getResult() : null;
                        }
                        break;
                    }
                }
            }
        }
        try {
            intent.migrateExtraStreamToClipData();
            intent.prepareToLeaveProcess();
            int result = ActivityManagerNative.getDefault()
                .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) {
        }
        return null;
    }

之后就是Binder通信的常用套路了，这里ActivityManagerNative.getDefault().startActivity()实际上调用的是ActivityManagerProxy的startActivity()方法：

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
public int startActivity(IApplicationThread caller, String callingPackage, Intent intent,
            String resolvedType, IBinder resultTo, String resultWho, int requestCode,
            int startFlags, ProfilerInfo profilerInfo, Bundle options) throws RemoteException {
        Parcel data = Parcel.obtain();
        Parcel reply = Parcel.obtain();
        data.writeInterfaceToken(IActivityManager.descriptor);
        data.writeStrongBinder(caller != null ? caller.asBinder() : null);
        data.writeString(callingPackage);
        intent.writeToParcel(data, 0);
        data.writeString(resolvedType);
        data.writeStrongBinder(resultTo);
        data.writeString(resultWho);
        data.writeInt(requestCode);
        data.writeInt(startFlags);
        if (profilerInfo != null) {
            data.writeInt(1);
            profilerInfo.writeToParcel(data, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
        } else {
            data.writeInt(0);
        }
        if (options != null) {
            data.writeInt(1);
            options.writeToParcel(data, 0);
        } else {
            data.writeInt(0);
        }
        mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);
        reply.readException();
        int result = reply.readInt();
        reply.recycle();
        data.recycle();
        return result;
    }

这里最终会通过Binder通信调用到AMS中的startActivity()：

1
2
3
4
5
6
7
8
@Override
public final int startActivity(IApplicationThread caller, String callingPackage,
        Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
        int startFlags, ProfilerInfo profilerInfo, Bundle options) {
    return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
        resultWho, requestCode, startFlags, profilerInfo, options,
        UserHandle.getCallingUserId());
}

startActivityAsUser()的代码如下: 

1
2
3
4
5
6
7
8
9
10
11
public final int startActivityAsUser(IApplicationThread caller, String callingPackage,
            Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
            int startFlags, ProfilerInfo profilerInfo, Bundle options, int userId) {
        enforceNotIsolatedCaller("startActivity");
        userId = handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(), userId,
                false, ALLOW_FULL_ONLY, "startActivity", null);
        // TODO: Switch to user app stacks here.
        return mStackSupervisor.startActivityMayWait(caller, -1, callingPackage, intent,
                resolvedType, null, null, resultTo, resultWho, requestCode, startFlags,
                profilerInfo, null, null, options, userId, null, null);
    }

而ActivityStackSupervisor#startActivityMayWait()的代码如下:

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
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 config,
            Bundle options, int userId, IActivityContainer iContainer, TaskRecord inTask) {
        // Refuse possible leaked file descriptors
        if (intent != null && intent.hasFileDescriptors()) {
            throw new IllegalArgumentException("File descriptors passed in Intent");
        }
        boolean componentSpecified = intent.getComponent() != null;
        // Don't modify the client's object!
        intent = new Intent(intent);
        // Collect information about the target of the Intent.
        ActivityInfo aInfo = resolveActivity(intent, resolvedType, startFlags,
                profilerInfo, userId);
        ActivityContainer container = (ActivityContainer)iContainer;
        synchronized (mService) {
            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 ActivityStack stack;
            if (container == null || container.mStack.isOnHomeDisplay()) {
                stack = getFocusedStack();
            } else {
                stack = container.mStack;
            }
            stack.mConfigWillChange = config != null
                    && mService.mConfiguration.diff(config) != 0;
            if (DEBUG_CONFIGURATION) Slog.v(TAG,
                    "Starting activity when config will change = " + stack.mConfigWillChange);
            final long origId = Binder.clearCallingIdentity();
            if (aInfo != null &&
                    (aInfo.applicationInfo.flags&ApplicationInfo.FLAG_CANT_SAVE_STATE) != 0) {
                // This may be a heavy-weight process!  Check to see if we already
                // have another, different heavy-weight process running.
                if (aInfo.processName.equals(aInfo.applicationInfo.packageName)) {
                    if (mService.mHeavyWeightProcess != null &&
                            (mService.mHeavyWeightProcess.info.uid != aInfo.applicationInfo.uid ||
                            !mService.mHeavyWeightProcess.processName.equals(aInfo.processName))) {
                        int appCallingUid = callingUid;
                        if (caller != null) {
                            ProcessRecord callerApp = mService.getRecordForAppLocked(caller);
                            if (callerApp != null) {
                                appCallingUid = callerApp.info.uid;
                            } else {
                                Slog.w(TAG, "Unable to find app for caller " + caller
                                      + " (pid=" + callingPid + ") when starting: "
                                      + intent.toString());
                                ActivityOptions.abort(options);
                                return ActivityManager.START_PERMISSION_DENIED;
                            }
                        }
                        IIntentSender target = mService.getIntentSenderLocked(
                                ActivityManager.INTENT_SENDER_ACTIVITY, "android",
                                appCallingUid, userId, null, null, 0, new Intent[] { intent },
                                new String[] { resolvedType }, PendingIntent.FLAG_CANCEL_CURRENT
                                | PendingIntent.FLAG_ONE_SHOT, null);
                        Intent newIntent = new Intent();
                        if (requestCode >= 0) {
                            // Caller is requesting a result.
                            newIntent.putExtra(HeavyWeightSwitcherActivity.KEY_HAS_RESULT, true);
                        }
                        newIntent.putExtra(HeavyWeightSwitcherActivity.KEY_INTENT,
                                new IntentSender(target));
                        if (mService.mHeavyWeightProcess.activities.size() > 0) {
                            ActivityRecord hist = mService.mHeavyWeightProcess.activities.get(0);
                            newIntent.putExtra(HeavyWeightSwitcherActivity.KEY_CUR_APP,
                                    hist.packageName);
                            newIntent.putExtra(HeavyWeightSwitcherActivity.KEY_CUR_TASK,
                                    hist.task.taskId);
                        }
                        newIntent.putExtra(HeavyWeightSwitcherActivity.KEY_NEW_APP,
                                aInfo.packageName);
                        newIntent.setFlags(intent.getFlags());
                        newIntent.setClassName("android",
                                HeavyWeightSwitcherActivity.class.getName());
                        intent = newIntent;
                        resolvedType = null;
                        caller = null;
                        callingUid = Binder.getCallingUid();
                        callingPid = Binder.getCallingPid();
                        componentSpecified = true;
                        try {
                            ResolveInfo rInfo =
                                AppGlobals.getPackageManager().resolveIntent(
                                        intent, null,
                                        PackageManager.MATCH_DEFAULT_ONLY
                                        | ActivityManagerService.STOCK_PM_FLAGS, userId);
                            aInfo = rInfo != null ? rInfo.activityInfo : null;
                            aInfo = mService.getActivityInfoForUser(aInfo, userId);
                        } catch (RemoteException e) {
                            aInfo = null;
                        }
                    }
                }
            }
            int res = startActivityLocked(caller, intent, resolvedType, aInfo,
                    voiceSession, voiceInteractor, resultTo, resultWho,
                    requestCode, callingPid, callingUid, callingPackage,
                    realCallingPid, realCallingUid, startFlags, options,
                    componentSpecified, null, container, inTask);
            Binder.restoreCallingIdentity(origId);
            if (stack.mConfigWillChange) {
                // If the caller also wants to switch to a new configuration,
                // do so now.  This allows a clean switch, as we are waiting
                // for the current activity to pause (so we will not destroy
                // it), and have not yet started the next activity.
                mService.enforceCallingPermission(android.Manifest.permission.CHANGE_CONFIGURATION,
                        "updateConfiguration()");
                stack.mConfigWillChange = false;
                if (DEBUG_CONFIGURATION) Slog.v(TAG,
                        "Updating to new configuration after starting activity.");
                mService.updateConfigurationLocked(config, null, false, false);
            }
            if (outResult != null) {
                outResult.result = res;
                if (res == ActivityManager.START_SUCCESS) {
                    mWaitingActivityLaunched.add(outResult);
                    do {
                        try {
                            mService.wait();
                        } catch (InterruptedException e) {
                        }
                    } while (!outResult.timeout && outResult.who == null);
                } else if (res == ActivityManager.START_TASK_TO_FRONT) {
                    ActivityRecord r = stack.topRunningActivityLocked(null);
                    if (r.nowVisible && r.state == ActivityState.RESUMED) {
                        outResult.timeout = false;
                        outResult.who = new ComponentName(r.info.packageName, r.info.name);
                        outResult.totalTime = 0;
                        outResult.thisTime = 0;
                    } else {
                        outResult.thisTime = SystemClock.uptimeMillis();
                        mWaitingActivityVisible.add(outResult);
                        do {
                            try {
                                mService.wait();
                            } catch (InterruptedException e) {
                            }
                        } while (!outResult.timeout && outResult.who == null);
                    }
                }
            }
            return res;
        }
    }

代码虽然很长，当时目前只要关注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
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
final int startActivityLocked(IApplicationThread caller,
            Intent intent, String resolvedType, ActivityInfo aInfo,
            IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
            IBinder resultTo, String resultWho, int requestCode,
            int callingPid, int callingUid, String callingPackage,
            int realCallingPid, int realCallingUid, int startFlags, Bundle options,
            boolean componentSpecified, ActivityRecord[] outActivity, ActivityContainer container,
            TaskRecord inTask) {
        int err = ActivityManager.START_SUCCESS;
        ProcessRecord callerApp = null;
        if (caller != null) {
            callerApp = mService.getRecordForAppLocked(caller);
            if (callerApp != null) {
                callingPid = callerApp.pid;
                callingUid = callerApp.info.uid;
            } else {
                Slog.w(TAG, "Unable to find app for caller " + caller
                      + " (pid=" + callingPid + ") when starting: "
                      + intent.toString());
                err = ActivityManager.START_PERMISSION_DENIED;
            }
        }
        if (err == ActivityManager.START_SUCCESS) {
            final int userId = aInfo != null ? UserHandle.getUserId(aInfo.applicationInfo.uid) : 0;
            Slog.i(TAG, "START u" + userId + " {" + intent.toShortString(true, true, true, false)
                    + "} from uid " + callingUid
                    + " on display " + (container == null ? (mFocusedStack == null ?
                            Display.DEFAULT_DISPLAY : mFocusedStack.mDisplayId) :
                            (container.mActivityDisplay == null ? Display.DEFAULT_DISPLAY :
                                    container.mActivityDisplay.mDisplayId)));
        }
        ActivityRecord sourceRecord = null;
        ActivityRecord resultRecord = null;
        if (resultTo != null) {
            sourceRecord = isInAnyStackLocked(resultTo);
            if (DEBUG_RESULTS) Slog.v(
                TAG, "Will send result to " + resultTo + " " + sourceRecord);
            if (sourceRecord != null) {
                if (requestCode >= 0 && !sourceRecord.finishing) {
                    resultRecord = sourceRecord;
                }
            }
        }
        ActivityStack resultStack = resultRecord == null ? null : resultRecord.task.stack;
        final int launchFlags = intent.getFlags();
        if ((launchFlags&Intent.FLAG_ACTIVITY_FORWARD_RESULT) != 0 && sourceRecord != null) {
            // Transfer the result target from the source activity to the new
            // one being started, including any failures.
            if (requestCode >= 0) {
                ActivityOptions.abort(options);
                return ActivityManager.START_FORWARD_AND_REQUEST_CONFLICT;
            }
            resultRecord = sourceRecord.resultTo;
            resultWho = sourceRecord.resultWho;
            requestCode = sourceRecord.requestCode;
            sourceRecord.resultTo = null;
            if (resultRecord != null) {
                resultRecord.removeResultsLocked(sourceRecord, resultWho, requestCode);
            }
            if (sourceRecord.launchedFromUid == callingUid) {
                // The new activity is being launched from the same uid as the previous
                // activity in the flow, and asking to forward its result back to the
                // previous.  In this case the activity is serving as a trampoline between
                // the two, so we also want to update its launchedFromPackage to be the
                // same as the previous activity.  Note that this is safe, since we know
                // these two packages come from the same uid; the caller could just as
                // well have supplied that same package name itself.  This specifially
                // deals with the case of an intent picker/chooser being launched in the app
                // flow to redirect to an activity picked by the user, where we want the final
                // activity to consider it to have been launched by the previous app activity.
                callingPackage = sourceRecord.launchedFromPackage;
            }
        }
        if (err == ActivityManager.START_SUCCESS && intent.getComponent() == null) {
            // We couldn't find a class that can handle the given Intent.
            // That's the end of that!
            err = ActivityManager.START_INTENT_NOT_RESOLVED;
        }
        if (err == ActivityManager.START_SUCCESS && aInfo == null) {
            // We couldn't find the specific class specified in the Intent.
            // Also the end of the line.
            err = ActivityManager.START_CLASS_NOT_FOUND;
        }
        if (err == ActivityManager.START_SUCCESS && sourceRecord != null
                && sourceRecord.task.voiceSession != null) {
            // If this activity is being launched as part of a voice session, we need
            // to ensure that it is safe to do so.  If the upcoming activity will also
            // be part of the voice session, we can only launch it if it has explicitly
            // said it supports the VOICE category, or it is a part of the calling app.
            if ((launchFlags & Intent.FLAG_ACTIVITY_NEW_TASK) == 0
                    && sourceRecord.info.applicationInfo.uid != aInfo.applicationInfo.uid) {
                try {
                    if (!AppGlobals.getPackageManager().activitySupportsIntent(
                            intent.getComponent(), intent, resolvedType)) {
                        err = ActivityManager.START_NOT_VOICE_COMPATIBLE;
                    }
                } catch (RemoteException e) {
                    err = ActivityManager.START_NOT_VOICE_COMPATIBLE;
                }
            }
        }
        if (err == ActivityManager.START_SUCCESS && voiceSession != null) {
            // If the caller is starting a new voice session, just make sure the target
            // is actually allowing it to run this way.
            try {
                if (!AppGlobals.getPackageManager().activitySupportsIntent(intent.getComponent(),
                        intent, resolvedType)) {
                    err = ActivityManager.START_NOT_VOICE_COMPATIBLE;
                }
            } catch (RemoteException e) {
                err = ActivityManager.START_NOT_VOICE_COMPATIBLE;
            }
        }
        if (err != ActivityManager.START_SUCCESS) {
            if (resultRecord != null) {
                resultStack.sendActivityResultLocked(-1,
                    resultRecord, resultWho, requestCode,
                    Activity.RESULT_CANCELED, null);
            }
            ActivityOptions.abort(options);
            return err;
        }
        final int startAnyPerm = mService.checkPermission(
                START_ANY_ACTIVITY, callingPid, callingUid);
        final int componentPerm = mService.checkComponentPermission(aInfo.permission, callingPid,
                callingUid, aInfo.applicationInfo.uid, aInfo.exported);
        if (startAnyPerm != PERMISSION_GRANTED && componentPerm != PERMISSION_GRANTED) {
            if (resultRecord != null) {
                resultStack.sendActivityResultLocked(-1,
                    resultRecord, resultWho, requestCode,
                    Activity.RESULT_CANCELED, null);
            }
            String msg;
            if (!aInfo.exported) {
                msg = "Permission Denial: starting " + intent.toString()
                        + " from " + callerApp + " (pid=" + callingPid
                        + ", uid=" + callingUid + ")"
                        + " not exported from uid " + aInfo.applicationInfo.uid;
            } else {
                msg = "Permission Denial: starting " + intent.toString()
                        + " from " + callerApp + " (pid=" + callingPid
                        + ", uid=" + callingUid + ")"
                        + " requires " + aInfo.permission;
            }
            Slog.w(TAG, msg);
            throw new SecurityException(msg);
        }
        boolean abort = !mService.mIntentFirewall.checkStartActivity(intent, callingUid,
                callingPid, resolvedType, aInfo.applicationInfo);
        if (mService.mController != null) {
            try {
                // The Intent we give to the watcher has the extra data
                // stripped off, since it can contain private information.
                Intent watchIntent = intent.cloneFilter();
                abort |= !mService.mController.activityStarting(watchIntent,
                        aInfo.applicationInfo.packageName);
            } catch (RemoteException e) {
                mService.mController = null;
            }
        }
        if (abort) {
            if (resultRecord != null) {
                resultStack.sendActivityResultLocked(-1, resultRecord, resultWho, requestCode,
                        Activity.RESULT_CANCELED, null);
            }
            // We pretend to the caller that it was really started, but
            // they will just get a cancel result.
            ActivityOptions.abort(options);
            return ActivityManager.START_SUCCESS;
        }
        ActivityRecord r = new ActivityRecord(mService, callerApp, callingUid, callingPackage,
                intent, resolvedType, aInfo, mService.mConfiguration, resultRecord, resultWho,
                requestCode, componentSpecified, this, container, options);
        if (outActivity != null) {
            outActivity[0] = r;
        }
        final ActivityStack stack = getFocusedStack();
        if (voiceSession == null && (stack.mResumedActivity == null
                || stack.mResumedActivity.info.applicationInfo.uid != callingUid)) {
            if (!mService.checkAppSwitchAllowedLocked(callingPid, callingUid,
                    realCallingPid, realCallingUid, "Activity start")) {
                PendingActivityLaunch pal =
                        new PendingActivityLaunch(r, sourceRecord, startFlags, stack);
                mPendingActivityLaunches.add(pal);
                ActivityOptions.abort(options);
                return ActivityManager.START_SWITCHES_CANCELED;
            }
        }
        if (mService.mDidAppSwitch) {
            // This is the second allowed switch since we stopped switches,
            // so now just generally allow switches.  Use case: user presses
            // home (switches disabled, switch to home, mDidAppSwitch now true);
            // user taps a home icon (coming from home so allowed, we hit here
            // and now allow anyone to switch again).
            mService.mAppSwitchesAllowedTime = 0;
        } else {
            mService.mDidAppSwitch = true;
        }
        doPendingActivityLaunchesLocked(false);
        err = startActivityUncheckedLocked(r, sourceRecord, voiceSession, voiceInteractor,
                startFlags, true, options, inTask);
        if (err < 0) {
            // If someone asked to have the keyguard dismissed on the next
            // activity start, but we are not actually doing an activity
            // switch...  just dismiss the keyguard now, because we
            // probably want to see whatever is behind it.
            notifyActivityDrawnForKeyguard();
        }
        return err;
    }

参数resultTo是Launcher这个Activity里面的一个Binder对象，通过它可以获得Launcher这个Activity的相关信息，保存在sourceRecord变量中。之后进入到startActivityUncheckedLocked()中:

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
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
  final int startActivityUncheckedLocked(ActivityRecord r, ActivityRecord sourceRecord,
            IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor, int startFlags,
            boolean doResume, Bundle options, TaskRecord inTask) {
        final Intent intent = r.intent;
        final int callingUid = r.launchedFromUid;
        // In some flows in to this function, we retrieve the task record and hold on to it
        // without a lock before calling back in to here...  so the task at this point may
        // not actually be in recents.  Check for that, and if it isn't in recents just
        // consider it invalid.
        if (inTask != null && !inTask.inRecents) {
            Slog.w(TAG, "Starting activity in task not in recents: " + inTask);
            inTask = null;
        }
        final boolean launchSingleTop = r.launchMode == ActivityInfo.LAUNCH_SINGLE_TOP;
        final boolean launchSingleInstance = r.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE;
        final boolean launchSingleTask = r.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK;
        int launchFlags = intent.getFlags();
        if ((launchFlags & Intent.FLAG_ACTIVITY_NEW_DOCUMENT) != 0 &&
                (launchSingleInstance || launchSingleTask)) {
            // We have a conflict between the Intent and the Activity manifest, manifest wins.
            
            launchFlags &=
                    ~(Intent.FLAG_ACTIVITY_NEW_DOCUMENT | Intent.FLAG_ACTIVITY_MULTIPLE_TASK);
        } else {
            switch (r.info.documentLaunchMode) {
                case ActivityInfo.DOCUMENT_LAUNCH_NONE:
                    break;
                case ActivityInfo.DOCUMENT_LAUNCH_INTO_EXISTING:
                    launchFlags |= Intent.FLAG_ACTIVITY_NEW_DOCUMENT;
                    break;
                case ActivityInfo.DOCUMENT_LAUNCH_ALWAYS:
                    launchFlags |= Intent.FLAG_ACTIVITY_NEW_DOCUMENT;
                    break;
                case ActivityInfo.DOCUMENT_LAUNCH_NEVER:
                    launchFlags &= ~Intent.FLAG_ACTIVITY_MULTIPLE_TASK;
                    break;
            }
        }
        final boolean launchTaskBehind = r.mLaunchTaskBehind
                && !launchSingleTask && !launchSingleInstance
                && (launchFlags & Intent.FLAG_ACTIVITY_NEW_DOCUMENT) != 0;
        if (r.resultTo != null && (launchFlags & Intent.FLAG_ACTIVITY_NEW_TASK) != 0) {
            // For whatever reason this activity is being launched into a new
            // task...  yet the caller has requested a result back.  Well, that
            // is pretty messed up, so instead immediately send back a cancel
            // and let the new task continue launched as normal without a
            // dependency on its originator.
            Slog.w(TAG, "Activity is launching as a new task, so cancelling activity result.");
            r.resultTo.task.stack.sendActivityResultLocked(-1,
                    r.resultTo, r.resultWho, r.requestCode,
                    Activity.RESULT_CANCELED, null);
            r.resultTo = null;
        }
        if ((launchFlags & Intent.FLAG_ACTIVITY_NEW_DOCUMENT) != 0 && r.resultTo == null) {
            launchFlags |= Intent.FLAG_ACTIVITY_NEW_TASK;
        }
        // If we are actually going to launch in to a new task, there are some cases where
        // we further want to do multiple task.
        if ((launchFlags & Intent.FLAG_ACTIVITY_NEW_TASK) != 0) {
            if (launchTaskBehind
                    || r.info.documentLaunchMode == ActivityInfo.DOCUMENT_LAUNCH_ALWAYS) {
                launchFlags |= Intent.FLAG_ACTIVITY_MULTIPLE_TASK;
            }
        }
        // We'll invoke onUserLeaving before onPause only if the launching
        // activity did not explicitly state that this is an automated launch.
        mUserLeaving = (launchFlags & Intent.FLAG_ACTIVITY_NO_USER_ACTION) == 0;
        
        // If the caller has asked not to resume at this point, we make note
        // of this in the record so that we can skip it when trying to find
        // the top running activity.
        if (!doResume) {
            r.delayedResume = true;
        }
        ActivityRecord notTop =
                (launchFlags & Intent.FLAG_ACTIVITY_PREVIOUS_IS_TOP) != 0 ? r : null;
        // If the onlyIfNeeded flag is set, then we can do this if the activity
        // being launched is the same as the one making the call...  or, as
        // a special case, if we do not know the caller then we count the
        // current top activity as the caller.
        if ((startFlags&ActivityManager.START_FLAG_ONLY_IF_NEEDED) != 0) {
            ActivityRecord checkedCaller = sourceRecord;
            if (checkedCaller == null) {
                checkedCaller = getFocusedStack().topRunningNonDelayedActivityLocked(notTop);
            }
            if (!checkedCaller.realActivity.equals(r.realActivity)) {
                // Caller is not the same as launcher, so always needed.
                startFlags &= ~ActivityManager.START_FLAG_ONLY_IF_NEEDED;
            }
        }
        boolean addingToTask = false;
        TaskRecord reuseTask = null;
        // If the caller is not coming from another activity, but has given us an
        // explicit task into which they would like us to launch the new activity,
        // then let's see about doing that.
        if (sourceRecord == null && inTask != null && inTask.stack != null) {
            final Intent baseIntent = inTask.getBaseIntent();
            final ActivityRecord root = inTask.getRootActivity();
            if (baseIntent == null) {
                ActivityOptions.abort(options);
                throw new IllegalArgumentException("Launching into task without base intent: "
                        + inTask);
            }
            // If this task is empty, then we are adding the first activity -- it
            // determines the root, and must be launching as a NEW_TASK.
            if (launchSingleInstance || launchSingleTask) {
                if (!baseIntent.getComponent().equals(r.intent.getComponent())) {
                    ActivityOptions.abort(options);
                    throw new IllegalArgumentException("Trying to launch singleInstance/Task "
                            + r + " into different task " + inTask);
                }
                if (root != null) {
                    ActivityOptions.abort(options);
                    throw new IllegalArgumentException("Caller with inTask " + inTask
                            + " has root " + root + " but target is singleInstance/Task");
                }
            }
            // If task is empty, then adopt the interesting intent launch flags in to the
            // activity being started.
            if (root == null) {
                final int flagsOfInterest = Intent.FLAG_ACTIVITY_NEW_TASK
                        | Intent.FLAG_ACTIVITY_MULTIPLE_TASK | Intent.FLAG_ACTIVITY_NEW_DOCUMENT
                        | Intent.FLAG_ACTIVITY_RETAIN_IN_RECENTS;
                launchFlags = (launchFlags&~flagsOfInterest)
                        | (baseIntent.getFlags()&flagsOfInterest);
                intent.setFlags(launchFlags);
                inTask.setIntent(r);
                addingToTask = true;
            // If the task is not empty and the caller is asking to start it as the root
            // of a new task, then we don't actually want to start this on the task.  We
            // will bring the task to the front, and possibly give it a new intent.
            } else if ((launchFlags & Intent.FLAG_ACTIVITY_NEW_TASK) != 0) {
                addingToTask = false;
            } else {
                addingToTask = true;
            }
            reuseTask = inTask;
        } else {
            inTask = null;
        }
        if (inTask == null) {
            if (sourceRecord == null) {
                // This activity is not being started from another...  in this
                // case we -always- start a new task.
                if ((launchFlags & Intent.FLAG_ACTIVITY_NEW_TASK) == 0 && inTask == null) {
                    Slog.w(TAG, "startActivity called from non-Activity context; forcing " +
                            "Intent.FLAG_ACTIVITY_NEW_TASK for: " + intent);
                    launchFlags |= Intent.FLAG_ACTIVITY_NEW_TASK;
                }
            } else if (sourceRecord.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE) {
                // The original activity who is starting us is running as a single
                // instance...  this new activity it is starting must go on its
                // own task.
                launchFlags |= Intent.FLAG_ACTIVITY_NEW_TASK;
            } else if (launchSingleInstance || launchSingleTask) {
                // The activity being started is a single instance...  it always
                // gets launched into its own task.
                launchFlags |= Intent.FLAG_ACTIVITY_NEW_TASK;
            }
        }
        ActivityInfo newTaskInfo = null;
        Intent newTaskIntent = null;
        ActivityStack sourceStack;
        if (sourceRecord != null) {
            if (sourceRecord.finishing) {
                // If the source is finishing, we can't further count it as our source.  This
                // is because the task it is associated with may now be empty and on its way out,
                // so we don't want to blindly throw it in to that task.  Instead we will take
                // the NEW_TASK flow and try to find a task for it. But save the task information
                // so it can be used when creating the new task.
                if ((launchFlags & Intent.FLAG_ACTIVITY_NEW_TASK) == 0) {
                    ...
                    newTaskInfo = sourceRecord.info;
                    newTaskIntent = sourceRecord.task.intent;
                }
                sourceRecord = null;
                sourceStack = null;
            } else {
                sourceStack = sourceRecord.task.stack;
            }
        } else {
            sourceStack = null;
        }
        boolean movedHome = false;
        ActivityStack targetStack;
        intent.setFlags(launchFlags);
        // We may want to try to place the new activity in to an existing task.  We always
        // do this if the target activity is singleTask or singleInstance; we will also do
        // this if NEW_TASK has been requested, and there is not an additional qualifier telling
        // us to still place it in a new task: multi task, always doc mode, or being asked to
        // launch this as a new task behind the current one.
        if (((launchFlags & Intent.FLAG_ACTIVITY_NEW_TASK) != 0 &&
                (launchFlags & Intent.FLAG_ACTIVITY_MULTIPLE_TASK) == 0)
                || launchSingleInstance || launchSingleTask) {
            // If bring to front is requested, and no result is requested and we have not
            // been given an explicit task to launch in to, and
            // we can find a task that was started with this same
            // component, then instead of launching bring that one to the front.
            if (inTask == null && r.resultTo == null) {
                // See if there is a task to bring to the front.  If this is
                // a SINGLE_INSTANCE activity, there can be one and only one
                // instance of it in the history, and it is always in its own
                // unique task, so we do a special search.
                ActivityRecord intentActivity = !launchSingleInstance ?
                        findTaskLocked(r) : findActivityLocked(intent, r.info);
                if (intentActivity != null) {
                    if (isLockTaskModeViolation(intentActivity.task)) {
                        showLockTaskToast();
                        Slog.e(TAG, "startActivityUnchecked: Attempt to violate Lock Task Mode");
                        return ActivityManager.START_RETURN_LOCK_TASK_MODE_VIOLATION;
                    }
                    if (r.task == null) {
                        r.task = intentActivity.task;
                    }
                    targetStack = intentActivity.task.stack;
                    targetStack.mLastPausedActivity = null;
                    if (DEBUG_TASKS) Slog.d(TAG, "Bring to front target: " + targetStack
                            + " from " + intentActivity);
                    targetStack.moveToFront();
                    if (intentActivity.task.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.
                        intentActivity.task.setIntent(r);
                    }
                    // If the target task is not in the front, then we need
                    // to bring it to the front...  except...  well, with
                    // SINGLE_TASK_LAUNCH it's not entirely clear.  We'd like
                    // to have the same behavior as if a new instance was
                    // being started, which means not bringing it to the front
                    // if the caller is not itself in the front.
                    final ActivityStack lastStack = getLastStack();
                    ActivityRecord curTop = lastStack == null?
                            null : lastStack.topRunningNonDelayedActivityLocked(notTop);
                    if (curTop != null && (curTop.task != intentActivity.task ||
                            curTop.task != lastStack.topTask())) {
                        r.intent.addFlags(Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT);
                        if (sourceRecord == null || (sourceStack.topActivity() != null &&
                                sourceStack.topActivity().task == sourceRecord.task)) {
                            // We really do want to push this one into the
                            // user's face, right now.
                            if (launchTaskBehind && sourceRecord != null) {
                                intentActivity.setTaskToAffiliateWith(sourceRecord.task);
                            }
                            movedHome = true;
                            targetStack.moveTaskToFrontLocked(intentActivity.task, r, options);
                            if ((launchFlags &
                                    (FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_TASK_ON_HOME))
                                    == (FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_TASK_ON_HOME)) {
                                // Caller wants to appear on home activity.
                                intentActivity.task.setTaskToReturnTo(HOME_ACTIVITY_TYPE);
                            }
                            options = null;
                        }
                    }
                    // If the caller has requested that the target task be
                    // reset, then do so.
                    if ((launchFlags&Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED) != 0) {
                        intentActivity = targetStack.resetTaskIfNeededLocked(intentActivity, r);
                    }
                    if ((startFlags&ActivityManager.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.
                        if (doResume) {
                            resumeTopActivitiesLocked(targetStack, null, options);
                        } else {
                            ActivityOptions.abort(options);
                        }
                        return ActivityManager.START_RETURN_INTENT_TO_CALLER;
                    }
                    if ((launchFlags &
                            (Intent.FLAG_ACTIVITY_NEW_TASK|Intent.FLAG_ACTIVITY_CLEAR_TASK))
                            == (Intent.FLAG_ACTIVITY_NEW_TASK|Intent.FLAG_ACTIVITY_CLEAR_TASK)) {
                        // The caller has requested to completely replace any
                        // existing task with its new activity.  Well that should
                        // not be too hard...
                        reuseTask = intentActivity.task;
                        reuseTask.performClearTaskLocked();
                        reuseTask.setIntent(r);
                    } else if ((launchFlags&Intent.FLAG_ACTIVITY_CLEAR_TOP) != 0
                            || launchSingleInstance || launchSingleTask) {
                        // 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.
                        ActivityRecord top =
                                intentActivity.task.performClearTaskLocked(r, launchFlags);
                        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.task.setIntent(r);
                            }
                            ActivityStack.logStartActivity(EventLogTags.AM_NEW_INTENT,
                                    r, top.task);
                            top.deliverNewIntentLocked(callingUid, r.intent);
                        } else {
                            // A special case: we need to
                            // start the activity because it is not currently
                            // running, and the caller has asked to clear the
                            // current task to have this activity at the top.
                            addingToTask = true;
                            // Now pretend like this activity is being started
                            // by the top of its task, so it is put in the
                            // right place.
                            sourceRecord = intentActivity;
                        }
                    } else if (r.realActivity.equals(intentActivity.task.realActivity)) {
                        // In this case the top activity on the task is the
                        // same as the one being launched, so we take that
                        // as a request to bring the task to the foreground.
                        // If the top activity in the task is the root
                        // activity, deliver this new intent to it if it
                        // desires.
                        if (((launchFlags&Intent.FLAG_ACTIVITY_SINGLE_TOP) != 0 || launchSingleTop)
                                && intentActivity.realActivity.equals(r.realActivity)) {
                            ActivityStack.logStartActivity(EventLogTags.AM_NEW_INTENT, r,
                                    intentActivity.task);
                            if (intentActivity.frontOfTask) {
                                intentActivity.task.setIntent(r);
                            }
                            intentActivity.deliverNewIntentLocked(callingUid, r.intent);
                        } else if (!r.intent.filterEquals(intentActivity.task.intent)) {
                            // In this case we are launching the root activity
                            // of the task, but with a different intent.  We
                            // should start a new instance on top.
                            addingToTask = true;
                            sourceRecord = intentActivity;
                        }
                    } else if ((launchFlags&Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED) == 0) {
                        // In this case an activity is being launched in to an
                        // existing task, without resetting that task.  This
                        // is typically the situation of launching an activity
                        // from a notification or shortcut.  We want to place
                        // the new activity on top of the current task.
                        addingToTask = true;
                        sourceRecord = intentActivity;
                    } else if (!intentActivity.task.rootWasReset) {
                        // In this case we are launching in to an existing task
                        // that has not yet been started from its front door.
                        // The current task has been brought to the front.
                        // Ideally, we'd probably like to place this new task
                        // at the bottom of its stack, but that's a little hard
                        // to do with the current organization of the code so
                        // for now we'll just drop it.
                        intentActivity.task.setIntent(r);
                    }
                    if (!addingToTask && reuseTask == 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.
                        if (doResume) {
                            targetStack.resumeTopActivityLocked(null, options);
                        } else {
                            ActivityOptions.abort(options);
                        }
                        return ActivityManager.START_TASK_TO_FRONT;
                    }
                }
            }
        }
        //String uri = r.intent.toURI();
        //Intent intent2 = new Intent(uri);
        //Slog.i(TAG, "Given intent: " + r.intent);
        //Slog.i(TAG, "URI is: " + uri);
        //Slog.i(TAG, "To intent: " + intent2);
        if (r.packageName != null) {
            // 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.
            ActivityStack topStack = getFocusedStack();
            ActivityRecord top = topStack.topRunningNonDelayedActivityLocked(notTop);
            if (top != null && r.resultTo == null) {
                if (top.realActivity.equals(r.realActivity) && top.userId == r.userId) {
                    if (top.app != null && top.app.thread != null) {
                        if ((launchFlags & Intent.FLAG_ACTIVITY_SINGLE_TOP) != 0
                            || launchSingleTop || launchSingleTask) {
                            ActivityStack.logStartActivity(EventLogTags.AM_NEW_INTENT, top,
                                    top.task);
                            // For paranoia, make sure we have correctly
                            // resumed the top activity.
                            topStack.mLastPausedActivity = null;
                            if (doResume) {
                                resumeTopActivitiesLocked();
                            }
                            ActivityOptions.abort(options);
                            if ((startFlags&ActivityManager.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 ActivityManager.START_RETURN_INTENT_TO_CALLER;
                            }
                            top.deliverNewIntentLocked(callingUid, r.intent);
                            return ActivityManager.START_DELIVERED_TO_TOP;
                        }
                    }
                }
            }
        } else {
            if (r.resultTo != null) {
                r.resultTo.task.stack.sendActivityResultLocked(-1, r.resultTo, r.resultWho,
                        r.requestCode, Activity.RESULT_CANCELED, null);
            }
            ActivityOptions.abort(options);
            return ActivityManager.START_CLASS_NOT_FOUND;
        }
        boolean newTask = false;
        boolean keepCurTransition = false;
        TaskRecord taskToAffiliate = launchTaskBehind && sourceRecord != null ?
                sourceRecord.task : null;
        // Should this be considered a new task?
        if (r.resultTo == null && inTask == null && !addingToTask
                && (launchFlags & Intent.FLAG_ACTIVITY_NEW_TASK) != 0) {
            if (isLockTaskModeViolation(reuseTask)) {
                Slog.e(TAG, "Attempted Lock Task Mode violation r=" + r);
                return ActivityManager.START_RETURN_LOCK_TASK_MODE_VIOLATION;
            }
            newTask = true;
            targetStack = adjustStackFocus(r, newTask);
            if (!launchTaskBehind) {
                targetStack.moveToFront();
            }
            if (reuseTask == null) {
                r.setTask(targetStack.createTaskRecord(getNextTaskId(),
                        newTaskInfo != null ? newTaskInfo : r.info,
                        newTaskIntent != null ? newTaskIntent : intent,
                        voiceSession, voiceInteractor, !launchTaskBehind /* toTop */),
                        taskToAffiliate);
                if (DEBUG_TASKS) Slog.v(TAG, "Starting new activity " + r + " in new task " +
                        r.task);
            } else {
                r.setTask(reuseTask, taskToAffiliate);
            }
            if (!movedHome) {
                if ((launchFlags &
                        (Intent.FLAG_ACTIVITY_NEW_TASK|Intent.FLAG_ACTIVITY_TASK_ON_HOME))
                        == (Intent.FLAG_ACTIVITY_NEW_TASK|Intent.FLAG_ACTIVITY_TASK_ON_HOME)) {
                    // Caller wants to appear on home activity, so before starting
                    // their own activity we will bring home to the front.
                    r.task.setTaskToReturnTo(HOME_ACTIVITY_TYPE);
                }
            }
        } else if (sourceRecord != null) {
            final TaskRecord sourceTask = sourceRecord.task;
            if (isLockTaskModeViolation(sourceTask)) {
                Slog.e(TAG, "Attempted Lock Task Mode violation r=" + r);
                return ActivityManager.START_RETURN_LOCK_TASK_MODE_VIOLATION;
            }
            targetStack = sourceTask.stack;
            targetStack.moveToFront();
            final TaskRecord topTask = targetStack.topTask();
            if (topTask != sourceTask) {
                targetStack.moveTaskToFrontLocked(sourceTask, r, options);
            } else {
                mWindowManager.moveTaskToTop(topTask.taskId);
            }
            if (!addingToTask && (launchFlags&Intent.FLAG_ACTIVITY_CLEAR_TOP) != 0) {
                // In this case, we are adding the activity to an existing
                // task, but the caller has asked to clear that task if the
                // activity is already running.
                ActivityRecord top = sourceTask.performClearTaskLocked(r, launchFlags);
                keepCurTransition = true;
                if (top != null) {
                    ActivityStack.logStartActivity(EventLogTags.AM_NEW_INTENT, r, top.task);
                    top.deliverNewIntentLocked(callingUid, r.intent);
                    // For paranoia, make sure we have correctly
                    // resumed the top activity.
                    targetStack.mLastPausedActivity = null;
                    if (doResume) {
                        targetStack.resumeTopActivityLocked(null);
                    }
                    ActivityOptions.abort(options);
                    return ActivityManager.START_DELIVERED_TO_TOP;
                }
            } else if (!addingToTask &&
                    (launchFlags&Intent.FLAG_ACTIVITY_REORDER_TO_FRONT) != 0) {
                // In this case, we are launching an activity in our own task
                // that may already be running somewhere in the history, and
                // we want to shuffle it to the front of the stack if so.
                final ActivityRecord top = sourceTask.findActivityInHistoryLocked(r);
                if (top != null) {
                    final TaskRecord task = top.task;
                    task.moveActivityToFrontLocked(top);
                    ActivityStack.logStartActivity(EventLogTags.AM_NEW_INTENT, r, task);
                    top.updateOptionsLocked(options);
                    top.deliverNewIntentLocked(callingUid, r.intent);
                    targetStack.mLastPausedActivity = null;
                    if (doResume) {
                        targetStack.resumeTopActivityLocked(null);
                    }
                    return ActivityManager.START_DELIVERED_TO_TOP;
                }
            }
            // An existing activity is starting this new activity, so we want
            // to keep the new one in the same task as the one that is starting
            // it.
            r.setTask(sourceTask, null);
            ...
        } else if (inTask != null) {
            // The calling is asking that the new activity be started in an explicit
            // task it has provided to us.
            if (isLockTaskModeViolation(inTask)) {
                Slog.e(TAG, "Attempted Lock Task Mode violation r=" + r);
                return ActivityManager.START_RETURN_LOCK_TASK_MODE_VIOLATION;
            }
            targetStack = inTask.stack;
            targetStack.moveTaskToFrontLocked(inTask, r, options);
            targetStack.moveToFront();
            mWindowManager.moveTaskToTop(inTask.taskId);
            // Check whether we should actually launch the new activity in to the task,
            // or just reuse the current activity on top.
            ActivityRecord top = inTask.getTopActivity();
            if (top != null && top.realActivity.equals(r.realActivity) && top.userId == r.userId) {
                if ((launchFlags & Intent.FLAG_ACTIVITY_SINGLE_TOP) != 0
                        || launchSingleTop || launchSingleTask) {
                    ActivityStack.logStartActivity(EventLogTags.AM_NEW_INTENT, top, top.task);
                    if ((startFlags&ActivityManager.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 ActivityManager.START_RETURN_INTENT_TO_CALLER;
                    }
                    top.deliverNewIntentLocked(callingUid, r.intent);
                    return ActivityManager.START_DELIVERED_TO_TOP;
                }
            }
            if (!addingToTask) {
                // We don't actually want to have this activity added to the task, so just
                // stop here but still tell the caller that we consumed the intent.
                ActivityOptions.abort(options);
                return ActivityManager.START_TASK_TO_FRONT;
            }
            r.setTask(inTask, null);
            ...
        } 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.
            targetStack = adjustStackFocus(r, newTask);
            targetStack.moveToFront();
            ActivityRecord prev = targetStack.topActivity();
            r.setTask(prev != null ? prev.task : targetStack.createTaskRecord(getNextTaskId(),
                            r.info, intent, null, null, true), null);
            mWindowManager.moveTaskToTop(r.task.taskId);
            ...
        }
        mService.grantUriPermissionFromIntentLocked(callingUid, r.packageName,
                intent, r.getUriPermissionsLocked(), r.userId);
        if (sourceRecord != null && sourceRecord.isRecentsActivity()) {
            r.task.setTaskToReturnTo(RECENTS_ACTIVITY_TYPE);
        }
        if (newTask) {
            EventLog.writeEvent(EventLogTags.AM_CREATE_TASK, r.userId, r.task.taskId);
        }
        ActivityStack.logStartActivity(EventLogTags.AM_CREATE_ACTIVITY, r, r.task);
        targetStack.mLastPausedActivity = null;
        targetStack.startActivityLocked(r, newTask, doResume, keepCurTransition, options);
        if (!launchTaskBehind) {
            // Don't set focus on an activity that's going to the back.
            mService.setFocusedActivityLocked(r);
        }
        return ActivityManager.START_SUCCESS;
    }
```  
虽然代码很多，但是由于这里是Intent.FLAG_ACTIVITY_NEW_TASK,这里我们只要关注最后一部分,最后会调用到targetStack.startActivityLocked(),该方法如下:
```java
   final void startActivityLocked(ActivityRecord r, boolean newTask,
            boolean doResume, boolean keepCurTransition, Bundle options) {
        TaskRecord rTask = r.task;
        final int taskId = rTask.taskId;
        // mLaunchTaskBehind tasks get placed at the back of the task stack.
        if (!r.mLaunchTaskBehind && (taskForIdLocked(taskId) == null || newTask)) {
            // Last activity in task had been removed or ActivityManagerService is reusing task.
            // Insert or replace.
            // Might not even be in.
            insertTaskAtTop(rTask);
            mWindowManager.moveTaskToTop(taskId);
        }
        TaskRecord task = null;
        if (!newTask) {
           ...
        }
        // Place a new activity at top of stack, so it is next to interact
        // with the user.
        // If we are not placing the new activity frontmost, we do not want
        // to deliver the onUserLeaving callback to the actual frontmost
        // activity
        if (task == r.task && mTaskHistory.indexOf(task) != (mTaskHistory.size() - 1)) {
            mStackSupervisor.mUserLeaving = false;
            if (DEBUG_USER_LEAVING) Slog.v(TAG,
                    "startActivity() behind front, mUserLeaving=false");
        }
        task = r.task;
        // Slot the activity into the history stack and proceed
        if (DEBUG_ADD_REMOVE) Slog.i(TAG, "Adding activity " + r + " to stack to task " + task,
                new RuntimeException("here").fillInStackTrace());
        task.addActivityToTop(r);
        task.setFrontOfTask();
        r.putInHistory();
        if (!isHomeStack() || numActivities() > 0) {
            // We want to show the starting preview window if we are
            // switching to a new task, or the next activity's process is
            // not currently running.
            boolean showStartingIcon = newTask;
            ProcessRecord proc = r.app;
            if (proc == null) {
                proc = mService.mProcessNames.get(r.processName, r.info.applicationInfo.uid);
            }
            if (proc == null || proc.thread == null) {
                showStartingIcon = true;
            }
            if (DEBUG_TRANSITION) Slog.v(TAG,
                    "Prepare open transition: starting " + r);
            if ((r.intent.getFlags()&Intent.FLAG_ACTIVITY_NO_ANIMATION) != 0) {
                mWindowManager.prepareAppTransition(AppTransition.TRANSIT_NONE, keepCurTransition);
                mNoAnimActivities.add(r);
            } else {
                mWindowManager.prepareAppTransition(newTask
                        ? r.mLaunchTaskBehind
                                ? AppTransition.TRANSIT_TASK_OPEN_BEHIND
                                : AppTransition.TRANSIT_TASK_OPEN
                        : AppTransition.TRANSIT_ACTIVITY_OPEN, keepCurTransition);
                mNoAnimActivities.remove(r);
            }
            mWindowManager.addAppToken(task.mActivities.indexOf(r),
                    r.appToken, r.task.taskId, mStackId, r.info.screenOrientation, r.fullscreen,
                    (r.info.flags & ActivityInfo.FLAG_SHOW_ON_LOCK_SCREEN) != 0, r.userId,
                    r.info.configChanges, task.voiceSession != null, r.mLaunchTaskBehind);
            boolean doShow = true;
            if (newTask) {
                // Even though this activity is starting fresh, we still need
                // to reset it to make sure we apply affinities to move any
                // existing activities from other tasks in to it.
                // If the caller has requested that the target task be
                // reset, then do so.
                if ((r.intent.getFlags() & Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED) != 0) {
                    resetTaskIfNeededLocked(r, r);
                    doShow = topRunningNonDelayedActivityLocked(null) == r;
                }
            } else if (options != null && new ActivityOptions(options).getAnimationType()
                    == ActivityOptions.ANIM_SCENE_TRANSITION) {
                doShow = false;
            }
            if (r.mLaunchTaskBehind) {
                // Don't do a starting window for mLaunchTaskBehind. More importantly make sure we
                // tell WindowManager that r is visible even though it is at the back of the stack.
                mWindowManager.setAppVisibility(r.appToken, true);
                ensureActivitiesVisibleLocked(null, 0);
            } else if (SHOW_APP_STARTING_PREVIEW && doShow) {
                // Figure out if we are transitioning from another activity that is
                // "has the same starting icon" as the next one.  This allows the
                // window manager to keep the previous window it had previously
                // created, if it still had one.
                ActivityRecord prev = mResumedActivity;
                if (prev != null) {
                    // We don't want to reuse the previous starting preview if:
                    // (1) The current activity is in a different task.
                    if (prev.task != r.task) {
                        prev = null;
                    }
                    // (2) The current activity is already displayed.
                    else if (prev.nowVisible) {
                        prev = null;
                    }
                }
                mWindowManager.setAppStartingWindow(
                        r.appToken, r.packageName, r.theme,
                        mService.compatibilityInfoForPackageLocked(
                                r.info.applicationInfo), r.nonLocalizedLabel,
                        r.labelRes, r.icon, r.logo, r.windowFlags,
                        prev != null ? prev.appToken : null, showStartingIcon);
                r.mStartingWindowShown = true;
            }
        } else {
            // If this is the first activity, don't do any fancy animations,
            // because there is nothing for it to animate on top of.
            mWindowManager.addAppToken(task.mActivities.indexOf(r), r.appToken,
                    r.task.taskId, mStackId, r.info.screenOrientation, r.fullscreen,
                    (r.info.flags & ActivityInfo.FLAG_SHOW_ON_LOCK_SCREEN) != 0, r.userId,
                    r.info.configChanges, task.voiceSession != null, r.mLaunchTaskBehind);
            ActivityOptions.abort(options);
            options = null;
        }
        if (VALIDATE_TOKENS) {
            validateAppTokensLocked();
        }
        if (doResume) {
            mStackSupervisor.resumeTopActivitiesLocked(this, r, options);
        }
    }

由于是新任务,并且传进来的参数doResume为true，于是调用resumeTopActivityLocked():

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
boolean resumeTopActivitiesLocked(ActivityStack targetStack, ActivityRecord target,
        Bundle targetOptions) {
    if (targetStack == null) {
        targetStack = getFocusedStack();
    }
    // Do targetStack first.
    boolean result = false;
    if (isFrontStack(targetStack)) {
        result = targetStack.resumeTopActivityLocked(target, targetOptions);
    }
    for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
        final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
        for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
            final ActivityStack stack = stacks.get(stackNdx);
            if (stack == targetStack) {
                // Already started above.
                continue;
            }
            if (isFrontStack(stack)) {
                stack.resumeTopActivityLocked(null);
            }
        }
    }
    return result;
}

进入resumeTopActivityLocked()中:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
final boolean resumeTopActivityLocked(ActivityRecord prev, Bundle options) {
       if (inResumeTopActivity) {
           // Don't even start recursing.
           return false;
       }
       boolean result = false;
       try {
           // Protect against recursion.
           inResumeTopActivity = true;
           result = resumeTopActivityInnerLocked(prev, options);
       } finally {
           inResumeTopActivity = false;
       }
       return result;
   }

真正执行是在resumeTopActivityInnerLocked()中: 

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
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
final boolean resumeTopActivityInnerLocked(ActivityRecord prev, Bundle options) {
      if (ActivityManagerService.DEBUG_LOCKSCREEN) mService.logLockScreen("");
      if (!mService.mBooting && !mService.mBooted) {
          // Not ready yet!
          return false;
      }
      ActivityRecord parent = mActivityContainer.mParentActivity;
      ...
      cancelInitializingActivities();
      // Find the first activity that is not finishing.
      ActivityRecord next = topRunningActivityLocked(null);
      // 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;
      final TaskRecord prevTask = prev != null ? prev.task : null;
      
      ...
      next.delayedResume = false;
      // If the top activity is the resumed one, nothing to do.
      if (mResumedActivity == next && next.state == ActivityState.RESUMED &&
                  mStackSupervisor.allResumedActivitiesComplete()) {
          // Make sure we have executed any pending transitions, since there
          // should be nothing left to do at this point.
          mWindowManager.executeAppTransition();
          mNoAnimActivities.clear();
          ActivityOptions.abort(options);
          if (DEBUG_STATES) Slog.d(TAG, "resumeTopActivityLocked: Top activity resumed " + next);
          if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
          // Make sure to notify Keyguard as well if it is waiting for an activity to be drawn.
          mStackSupervisor.notifyActivityDrawnForKeyguard();
          return false;
      }
      final TaskRecord nextTask = next.task;
      if (prevTask != null && prevTask.stack == 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 (DEBUG_STATES && isOnHomeDisplay()) Slog.d(TAG,
                      "resumeTopActivityLocked: Launching home next");
              // Only resume home if on home display
              final int returnTaskType = prevTask == null || !prevTask.isOverHomeStack() ?
                      HOME_ACTIVITY_TYPE : prevTask.getTaskToReturnTo();
              return isOnHomeDisplay() &&
                      mStackSupervisor.resumeHomeStackTask(returnTaskType, prev);
          }
      }
      // 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.isSleepingOrShuttingDown()
              && mLastPausedActivity == next
              && mStackSupervisor.allPausedActivitiesComplete()) {
          // Make sure we have executed any pending transitions, since there
          // should be nothing left to do at this point.
          mWindowManager.executeAppTransition();
          mNoAnimActivities.clear();
          ActivityOptions.abort(options);
          if (DEBUG_STATES) Slog.d(TAG, "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.mStartedUsers.get(next.userId) == null) {
          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.mWaitingVisibleActivities.remove(next);
      if (DEBUG_SWITCH) Slog.v(TAG, "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,
                  "resumeTopActivityLocked: Skip resume: some activity pausing.");
          if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
          return false;
      }
      // Okay we are now going to start a switch, to 'next'.  We may first
      // have to pause the current activity, but this is an important point
      // where we have decided to go to 'next' so keep track of that.
      // XXX "App Redirected" dialog is getting too many false positives
      // at this point, so turn off for now.
      if (false) {
          if (mLastStartedActivity != null && !mLastStartedActivity.finishing) {
              long now = SystemClock.uptimeMillis();
              final boolean inTime = mLastStartedActivity.startTime != 0
                      && (mLastStartedActivity.startTime + START_WARN_TIME) >= now;
              final int lastUid = mLastStartedActivity.info.applicationInfo.uid;
              final int nextUid = next.info.applicationInfo.uid;
              if (inTime && lastUid != nextUid
                      && lastUid != next.launchedFromUid
                      && mService.checkPermission(
                              android.Manifest.permission.STOP_APP_SWITCHES,
                              -1, next.launchedFromUid)
                      != PackageManager.PERMISSION_GRANTED) {
                  mService.showLaunchWarningLocked(mLastStartedActivity, next);
              } else {
                  next.startTime = now;
                  mLastStartedActivity = next;
              }
          } else {
              next.startTime = SystemClock.uptimeMillis();
              mLastStartedActivity = next;
          }
      }
      // We need to start pausing the current activity so the top one
      // can be resumed...
      boolean dontWaitForPause = (next.info.flags&ActivityInfo.FLAG_RESUME_WHILE_PAUSING) != 0;
      boolean pausing = mStackSupervisor.pauseBackStacks(userLeaving, true, dontWaitForPause);
      if (mResumedActivity != null) {
          pausing |= startPausingLocked(userLeaving, false, true, dontWaitForPause);
          if (DEBUG_STATES) Slog.d(TAG, "resumeTopActivityLocked: Pausing " + mResumedActivity);
      }
      if (pausing) {
          if (DEBUG_SWITCH || DEBUG_STATES) Slog.v(TAG,
                  "resumeTopActivityLocked: Skip resume: need to start pausing");
          // At this point we want to put the upcoming activity's process
          // at the top of the LRU list, since we know we will be needing it
          // very soon and it would be a waste to let it get killed if it
          // happens to be sitting towards the end.
          if (next.app != null && next.app.thread != null) {
              mService.updateLruProcessLocked(next.app, true, null);
          }
          if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
          return true;
      }
      // 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.isSleeping() && mLastNoHistoryActivity != null &&
              !mLastNoHistoryActivity.finishing) {
          if (DEBUG_STATES) Slog.d(TAG, "no-history finish of " + mLastNoHistoryActivity +
                  " on new resume");
          requestFinishActivityLocked(mLastNoHistoryActivity.appToken, Activity.RESULT_CANCELED,
                  null, "no-history", false);
          mLastNoHistoryActivity = null;
      }
      if (prev != null && prev != next) {
          if (!prev.waitingVisible && next != null && !next.nowVisible) {
              prev.waitingVisible = true;
              mStackSupervisor.mWaitingVisibleActivities.add(prev);
              if (DEBUG_SWITCH) Slog.v(
                      TAG, "Resuming top, waiting visible to hide: " + prev);
          } else {
              // The next activity is already visible, so hide the previous
              // activity's windows right now so we can show the new one ASAP.
              // We only do this if the previous is finishing, which should mean
              // it is on top of the one being resumed so hiding it quickly
              // is good.  Otherwise, we want to do the normal route of allowing
              // the resumed activity to be shown so we can decide if the
              // previous should actually be hidden depending on whether the
              // new one is found to be full-screen or not.
              if (prev.finishing) {
                  mWindowManager.setAppVisibility(prev.appToken, false);
                  ...
              } else {
                  ...
              }
          }
      }
      // 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) {
          ...
      }
      // We are starting up the next activity, so tell the window manager
      // that the previous one will be hidden soon.  This way it can know
      // to ignore it when computing the desired screen orientation.
      boolean anim = true;
      if (prev != null) {
          if (prev.finishing) {
              if (DEBUG_TRANSITION) Slog.v(TAG,
                      "Prepare close transition: prev=" + prev);
              if (mNoAnimActivities.contains(prev)) {
                  anim = false;
                  mWindowManager.prepareAppTransition(AppTransition.TRANSIT_NONE, false);
              } else {
                  mWindowManager.prepareAppTransition(prev.task == next.task
                          ? AppTransition.TRANSIT_ACTIVITY_CLOSE
                          : AppTransition.TRANSIT_TASK_CLOSE, false);
              }
              mWindowManager.setAppWillBeHidden(prev.appToken);
              mWindowManager.setAppVisibility(prev.appToken, false);
          } else {
              if (DEBUG_TRANSITION) Slog.v(TAG, "Prepare open transition: prev=" + prev);
              if (mNoAnimActivities.contains(next)) {
                  anim = false;
                  mWindowManager.prepareAppTransition(AppTransition.TRANSIT_NONE, false);
              } else {
                  mWindowManager.prepareAppTransition(prev.task == next.task
                          ? AppTransition.TRANSIT_ACTIVITY_OPEN
                          : next.mLaunchTaskBehind
                                  ? AppTransition.TRANSIT_TASK_OPEN_BEHIND
                                  : AppTransition.TRANSIT_TASK_OPEN, false);
              }
          }
          if (false) {
              mWindowManager.setAppWillBeHidden(prev.appToken);
              mWindowManager.setAppVisibility(prev.appToken, false);
          }
      } else {
          if (DEBUG_TRANSITION) Slog.v(TAG, "Prepare open transition: no previous");
          if (mNoAnimActivities.contains(next)) {
              anim = false;
              mWindowManager.prepareAppTransition(AppTransition.TRANSIT_NONE, false);
          } else {
              mWindowManager.prepareAppTransition(AppTransition.TRANSIT_ACTIVITY_OPEN, false);
          }
      }
      Bundle resumeAnimOptions = null;
      if (anim) {
          ActivityOptions opts = next.getOptionsForTargetActivityLocked();
          if (opts != null) {
              resumeAnimOptions = opts.toBundle();
          }
          next.applyOptionsLocked();
      } else {
          next.clearOptionsLocked();
      }
      ActivityStack lastStack = mStackSupervisor.getLastStack();
      if (next.app != null && next.app.thread != null) {
          if (DEBUG_SWITCH) Slog.v(TAG, "Resume running: " + next);
          // This activity is now becoming visible.
          mWindowManager.setAppVisibility(next.appToken, true);
          // schedule launch ticks to collect information about slow apps.
          next.startLaunchTickingLocked();
          ActivityRecord lastResumedActivity =
                  lastStack == null ? null :lastStack.mResumedActivity;
          ActivityState lastState = next.state;
          mService.updateCpuStats();
          if (DEBUG_STATES) Slog.v(TAG, "Moving to RESUMED: " + next + " (in existing)");
          next.state = ActivityState.RESUMED;
          mResumedActivity = next;
          next.task.touchActiveTime();
          mService.addRecentTaskLocked(next.task);
          mService.updateLruProcessLocked(next.app, true, null);
          updateLRUListLocked(next);
          mService.updateOomAdjLocked();
          // Have the window manager re-evaluate the orientation of
          // the screen based on the new activity order.
          boolean notUpdated = true;
          if (mStackSupervisor.isFrontStack(this)) {
              Configuration config = mWindowManager.updateOrientationFromAppTokens(
                      mService.mConfiguration,
                      next.mayFreezeScreenLocked(next.app) ? next.appToken : null);
              if (config != null) {
                  next.frozenBeforeDestroy = true;
              }
              notUpdated = !mService.updateConfigurationLocked(config, next, false, false);
          }
          if (notUpdated) {
              // The configuration update wasn't able to keep the existing
              // instance of the activity, and instead started a new one.
              // We should be all done, but let's just make sure our activity
              // is still at the top and schedule another run if something
              // weird happened.
              ActivityRecord nextNext = topRunningActivityLocked(null);
              if (DEBUG_SWITCH || DEBUG_STATES) Slog.i(TAG,
                      "Activity config changed during resume: " + next
                      + ", new next: " + nextNext);
              if (nextNext != next) {
                  // Do over!
                  mStackSupervisor.scheduleResumeTopActivities();
              }
              if (mStackSupervisor.reportResumedActivityLocked(next)) {
                  mNoAnimActivities.clear();
                  if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
                  return true;
              }
              if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
              return false;
          }
          try {
              // Deliver all pending results.
              ArrayList<ResultInfo> a = next.results;
              if (a != null) {
                  final int N = a.size();
                  if (!next.finishing && N > 0) {
                      if (DEBUG_RESULTS) Slog.v(
                              TAG, "Delivering results to " + next
                              + ": " + a);
                      next.app.thread.scheduleSendResult(next.appToken, a);
                  }
              }
              if (next.newIntents != null) {
                  next.app.thread.scheduleNewIntent(next.newIntents, next.appToken);
              }
              EventLog.writeEvent(EventLogTags.AM_RESUME_ACTIVITY,
                      next.userId, System.identityHashCode(next),
                      next.task.taskId, next.shortComponentName);
              next.sleeping = false;
              mService.showAskCompatModeDialogLocked(next);
              next.app.pendingUiClean = true;
              next.app.forceProcessStateUpTo(ActivityManager.PROCESS_STATE_TOP);
              next.clearOptionsLocked();
              next.app.thread.scheduleResumeActivity(next.appToken, next.app.repProcState,
                      mService.isNextTransitionForward(), resumeAnimOptions);
              mStackSupervisor.checkReadyForSleepLocked();
              if (DEBUG_STATES) Slog.d(TAG, "resumeTopActivityLocked: Resumed " + next);
          } catch (Exception e) {
              // Whoops, need to restart this activity!
              if (DEBUG_STATES) Slog.v(TAG, "Resume failed; resetting state to "
                      + lastState + ": " + next);
              next.state = lastState;
              if (lastStack != null) {
                  lastStack.mResumedActivity = lastResumedActivity;
              }
              Slog.i(TAG, "Restarting because process died: " + next);
              if (!next.hasBeenLaunched) {
                  next.hasBeenLaunched = true;
              } else  if (SHOW_APP_STARTING_PREVIEW && lastStack != null &&
                      mStackSupervisor.isFrontStack(lastStack)) {
                  mWindowManager.setAppStartingWindow(
                          next.appToken, next.packageName, next.theme,
                          mService.compatibilityInfoForPackageLocked(next.info.applicationInfo),
                          next.nonLocalizedLabel, next.labelRes, next.icon, next.logo,
                          next.windowFlags, null, true);
              }
              mStackSupervisor.startSpecificActivityLocked(next, true, false);
              if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
              return true;
          }
          // From this point on, if something goes wrong there is no way
          // to recover the activity.
          try {
              next.visible = true;
              completeResumeLocked(next);
          } catch (Exception e) {
              // If any exception gets thrown, toss away this
              // activity and try the next one.
              Slog.w(TAG, "Exception thrown during resume of " + next, e);
              requestFinishActivityLocked(next.appToken, Activity.RESULT_CANCELED, null,
                      "resume-exception", true);
              if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
              return true;
          }
          next.stopped = false;
      } else {
          // Whoops, need to restart this activity!
          if (!next.hasBeenLaunched) {
              next.hasBeenLaunched = true;
          } else {
              if (SHOW_APP_STARTING_PREVIEW) {
                  mWindowManager.setAppStartingWindow(
                          next.appToken, next.packageName, next.theme,
                          mService.compatibilityInfoForPackageLocked(
                                  next.info.applicationInfo),
                          next.nonLocalizedLabel,
                          next.labelRes, next.icon, next.logo, next.windowFlags,
                          null, true);
              }
              if (DEBUG_SWITCH) Slog.v(TAG, "Restarting: " + next);
          }
          if (DEBUG_STATES) Slog.d(TAG, "resumeTopActivityLocked: Restarting " + next);
          mStackSupervisor.startSpecificActivityLocked(next, true, true);
      }
      if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
      return true;
  }

这里mResumedActivity其实就是Launcher,因为Launcher是当前正被执行的Activity.从而会进入startPausingLocked()方法中: 

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
final boolean startPausingLocked(boolean userLeaving, boolean uiSleeping, boolean resuming,
         boolean dontWait) {
     if (mPausingActivity != null) {
         Slog.wtf(TAG, "Going to pause when pause is already pending for " + mPausingActivity);
         completePauseLocked(false);
     }
     ActivityRecord prev = mResumedActivity;
     if (prev == null) {
         if (!resuming) {
             Slog.wtf(TAG, "Trying to pause when nothing is resumed");
             mStackSupervisor.resumeTopActivitiesLocked();
         }
         return false;
     }
     if (mActivityContainer.mParentActivity == null) {
         // Top level stack, not a child. Look for child stacks.
         mStackSupervisor.pauseChildStacks(prev, userLeaving, uiSleeping, resuming, dontWait);
     }
     if (DEBUG_STATES) Slog.v(TAG, "Moving to PAUSING: " + prev);
     else if (DEBUG_PAUSE) Slog.v(TAG, "Start pausing: " + prev);
     mResumedActivity = null;
     mPausingActivity = prev;
     mLastPausedActivity = prev;
     mLastNoHistoryActivity = (prev.intent.getFlags() & Intent.FLAG_ACTIVITY_NO_HISTORY) != 0
             || (prev.info.flags & ActivityInfo.FLAG_NO_HISTORY) != 0 ? prev : null;
     prev.state = ActivityState.PAUSING;
     prev.task.touchActiveTime();
     clearLaunchTime(prev);
     final ActivityRecord next = mStackSupervisor.topRunningActivityLocked();
     if (mService.mHasRecents && (next == null || next.noDisplay || next.task != prev.task)) {
         prev.updateThumbnail(screenshotActivities(prev), null);
     }
     stopFullyDrawnTraceIfNeeded();
     mService.updateCpuStats();
     if (prev.app != null && prev.app.thread != null) {
         if (DEBUG_PAUSE) Slog.v(TAG, "Enqueueing pending pause: " + prev);
         try {
             EventLog.writeEvent(EventLogTags.AM_PAUSE_ACTIVITY,
                     prev.userId, System.identityHashCode(prev),
                     prev.shortComponentName);
             mService.updateUsageStats(prev, false);
             prev.app.thread.schedulePauseActivity(prev.appToken, prev.finishing,
                     userLeaving, prev.configChangeFlags, dontWait);
         } catch (Exception e) {
             // Ignore exception, if process died other code will cleanup.
             Slog.w(TAG, "Exception thrown during pause", e);
             mPausingActivity = null;
             mLastPausedActivity = null;
             mLastNoHistoryActivity = null;
         }
     } else {
         mPausingActivity = null;
         mLastPausedActivity = null;
         mLastNoHistoryActivity = null;
     }
     // If we are not going to sleep, we want to ensure the device is
     // awake until the next activity is started.
     if (!mService.isSleepingOrShuttingDown()) {
         mStackSupervisor.acquireLaunchWakelock();
     }
     if (mPausingActivity != null) {
         // Have the window manager pause its key dispatching until the new
         // activity has started.  If we're pausing the activity just because
         // the screen is being turned off and the UI is sleeping, don't interrupt
         // key dispatch; the same activity will pick it up again on wakeup.
         if (!uiSleeping) {
             prev.pauseKeyDispatchingLocked();
         } else {
             if (DEBUG_PAUSE) Slog.v(TAG, "Key dispatch not paused for screen off");
         }
         if (dontWait) {
             // If the caller said they don't want to wait for the pause, then complete
             // the pause now.
             completePauseLocked(false);
             return false;
         } else {
             // Schedule a pause timeout in case the app doesn't respond.
             // We don't give it much time because this directly impacts the
             // responsiveness seen by the user.
             Message msg = mHandler.obtainMessage(PAUSE_TIMEOUT_MSG);
             msg.obj = prev;
             prev.pauseTime = SystemClock.uptimeMillis();
             mHandler.sendMessageDelayed(msg, PAUSE_TIMEOUT);
             if (DEBUG_PAUSE) Slog.v(TAG, "Waiting for pause to complete...");
             return true;
         }
     } else {
         // This activity failed to schedule the
         // pause, so just treat it as being paused now.
         if (DEBUG_PAUSE) Slog.v(TAG, "Activity not running, resuming next.");
         if (!resuming) {
             mStackSupervisor.getFocusedStack().resumeTopActivityLocked(null);
         }
         return false;
     }
 }

注意其中的prev.app.thread.schedulePauseActivity(),这是典型的Binder通信，最终会调用到ApplicationThread的schedulePauseActivity()中，注意这里的ApplicationThread是与Launcher对应的，还不是与要启动的App对应的。

1
2
3
4
5
6
7
8
public final void schedulePauseActivity(IBinder token, boolean finished,
                boolean userLeaving, int configChanges, boolean dontReport) {
            sendMessage(
                    finished ? H.PAUSE_ACTIVITY_FINISHING : H.PAUSE_ACTIVITY,
                    token,
                    (userLeaving ? 1 : 0) | (dontReport ? 2 : 0),
                    configChanges);
        }

这里的H是ActivityThread的一个内部类,继承自Handler,跟踪H.PAUSE_ACTIVITY 消息的流动可以发现消息的处理在ActivityThread,注意这里的ActivityThread也是与Launcher（确切地说是与Launcher所在的App)对应的,其中ActivityThread的处理代码如下:

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
public void handleMessage(Message msg) {
           if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
           switch (msg.what) {
               case LAUNCH_ACTIVITY: {
                   Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
                   final ActivityClientRecord r = (ActivityClientRecord) msg.obj;
                   r.packageInfo = getPackageInfoNoCheck(
                           r.activityInfo.applicationInfo, r.compatInfo);
                   handleLaunchActivity(r, null);
                   Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
               } break;
               case RELAUNCH_ACTIVITY: {
                   Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityRestart");
                   ActivityClientRecord r = (ActivityClientRecord)msg.obj;
                   handleRelaunchActivity(r);
                   Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
               } break;
               case PAUSE_ACTIVITY:
                   Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityPause");
                   handlePauseActivity((IBinder)msg.obj, false, (msg.arg1&1) != 0, msg.arg2,
                           (msg.arg1&2) != 0);
                   maybeSnapshot();
                   Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                   break;
                   ...
               }
           }

显然调用handlePauseActivity()进行处理:

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
private void handlePauseActivity(IBinder token, boolean finished,
          boolean userLeaving, int configChanges, boolean dontReport) {
      ActivityClientRecord r = mActivities.get(token);
      if (r != null) {
          //Slog.v(TAG, "userLeaving=" + userLeaving + " handling pause of " + r);
          if (userLeaving) {
              performUserLeavingActivity(r);
          }
          r.activity.mConfigChangeFlags |= configChanges;
          performPauseActivity(token, finished, r.isPreHoneycomb());
          // Make sure any pending writes are now committed.
          if (r.isPreHoneycomb()) {
              QueuedWork.waitToFinish();
          }
          // Tell the activity manager we have paused.
          if (!dontReport) {
              try {
                  ActivityManagerNative.getDefault().activityPaused(token);
              } catch (RemoteException ex) {
              }
          }
          mSomeActivitiesChanged = true;
      }
  }

注意其中的ActivityManagerNative.getDefault().activityPaused(token),这是在Launcher进入Paused状态后通知AMS.
进入performPauseActivity中: 

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
final Bundle performPauseActivity(IBinder token, boolean finished,
          boolean saveState) {
      ActivityClientRecord r = mActivities.get(token);
      return r != null ? performPauseActivity(r, finished, saveState) : null;
  }
  final Bundle performPauseActivity(ActivityClientRecord r, boolean finished,
          boolean saveState) {
      if (r.paused) {
          if (r.activity.mFinished) {
              // If we are finishing, we won't call onResume() in certain cases.
              // So here we likewise don't want to call onPause() if the activity
              // isn't resumed.
              return null;
          }
          RuntimeException e = new RuntimeException(
                  "Performing pause of activity that is not resumed: "
                  + r.intent.getComponent().toShortString());
          Slog.e(TAG, e.getMessage(), e);
      }
      if (finished) {
          r.activity.mFinished = true;
      }
      try {
          // Next have the activity save its current state and managed dialogs...
          if (!r.activity.mFinished && saveState) {
              callCallActivityOnSaveInstanceState(r);
          }
          // Now we are idle.
          r.activity.mCalled = false;
          mInstrumentation.callActivityOnPause(r.activity);
          EventLog.writeEvent(LOG_ON_PAUSE_CALLED, UserHandle.myUserId(),
                  r.activity.getComponentName().getClassName());
          if (!r.activity.mCalled) {
              throw new SuperNotCalledException(
                  "Activity " + r.intent.getComponent().toShortString() +
                  " did not call through to super.onPause()");
          }
      } catch (SuperNotCalledException e) {
          throw e;
      } catch (Exception e) {
          if (!mInstrumentation.onException(r.activity, e)) {
              throw new RuntimeException(
                      "Unable to pause activity "
                      + r.intent.getComponent().toShortString()
                      + ": " + e.toString(), e);
          }
      }
      r.paused = true;
      // Notify any outstanding on paused listeners
      ArrayList<OnActivityPausedListener> listeners;
      synchronized (mOnPauseListeners) {
          listeners = mOnPauseListeners.remove(r.activity);
      }
      int size = (listeners != null ? listeners.size() : 0);
      for (int i = 0; i < size; i++) {
          listeners.get(i).onPaused(r.activity);
      }
      return !r.activity.mFinished && saveState ? r.state : null;
  }

可以看到，真正的执行是在Instrumentation的callActivityOnPause()中:

1
2
3
public void callActivityOnPause(Activity activity) {
       activity.performPause();
   }

而Activity的performPause()如下:

1
2
3
4
5
6
7
8
9
10
11
12
final void performPause() {
		mDoReportFullyDrawn = false;
		mFragments.dispatchPause();
		mCalled = false;
		onPause();
		mResumed = false;
		if (!mCalled && getApplicationInfo().targetSdkVersion >= android.os.Build.VERSION_CODES.GINGERBREAD) {
			throw new SuperNotCalledException(
					"Activity " + mComponent.toShortString() + " did not call through to super.onPause()");
		}
		mResumed = false;
	}

可以看到，这里回调了Activity的onPause()方法,到这里为止Launcher就进入了Paused状态，结合前面的ActivityManagerNative.getDefault().activityPaused(token)，可以发现之后会通过Binder调用AMS的activityPaused()方法:

1
2
3
4
5
6
7
8
9
10
public final void activityPaused(IBinder token) {
        final long origId = Binder.clearCallingIdentity();
        synchronized(this) {
            ActivityStack stack = ActivityRecord.getStackLocked(token);
            if (stack != null) {
                stack.activityPausedLocked(token, false);
            }
        }
        Binder.restoreCallingIdentity(origId);
    }

进入activityPausedLocked()方法中:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
final void activityPausedLocked(IBinder token, boolean timeout) {
       if (DEBUG_PAUSE) Slog.v(
           TAG, "Activity paused: token=" + token + ", timeout=" + timeout);
       final ActivityRecord r = isInStackLocked(token);
       if (r != null) {
           mHandler.removeMessages(PAUSE_TIMEOUT_MSG, r);
           if (mPausingActivity == r) {
               if (DEBUG_STATES) Slog.v(TAG, "Moving to PAUSED: " + r
                       + (timeout ? " (due to timeout)" : " (pause complete)"));
               completePauseLocked(true);
           } else {
               EventLog.writeEvent(EventLogTags.AM_FAILED_TO_PAUSE,
                       r.userId, System.identityHashCode(r), r.shortComponentName,
                       mPausingActivity != null
                           ? mPausingActivity.shortComponentName : "(none)");
           }
       }
   }

再进入completePauseLocked()中,注意插入的resumeNext为true:

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
private void completePauseLocked(boolean resumeNext) {
     ActivityRecord prev = mPausingActivity;
     if (DEBUG_PAUSE) Slog.v(TAG, "Complete pause: " + prev);
     if (prev != null) {
         prev.state = ActivityState.PAUSED;
         if (prev.finishing) {
             if (DEBUG_PAUSE) Slog.v(TAG, "Executing finish of activity: " + prev);
             prev = finishCurrentActivityLocked(prev, FINISH_AFTER_VISIBLE, false);
         } else if (prev.app != null) {
             if (DEBUG_PAUSE) Slog.v(TAG, "Enqueueing pending stop: " + prev);
             if (prev.waitingVisible) {
                 prev.waitingVisible = false;
                 mStackSupervisor.mWaitingVisibleActivities.remove(prev);
                 if (DEBUG_SWITCH || DEBUG_PAUSE) Slog.v(
                         TAG, "Complete pause, no longer waiting: " + prev);
             }
             if (prev.configDestroy) {
                 // The previous is being paused because the configuration
                 // is changing, which means it is actually stopping...
                 // To juggle the fact that we are also starting a new
                 // instance right now, we need to first completely stop
                 // the current instance before starting the new one.
                 if (DEBUG_PAUSE) Slog.v(TAG, "Destroying after pause: " + prev);
                 destroyActivityLocked(prev, true, "pause-config");
             } else if (!hasVisibleBehindActivity()) {
                 // If we were visible then resumeTopActivities will release resources before
                 // stopping.
                 mStackSupervisor.mStoppingActivities.add(prev);
                 if (mStackSupervisor.mStoppingActivities.size() > 3 ||
                         prev.frontOfTask && mTaskHistory.size() <= 1) {
                     // If we already have a few activities waiting to stop,
                     // then give up on things going idle and start clearing
                     // them out. Or if r is the last of activity of the last task the stack
                     // will be empty and must be cleared immediately.
                     if (DEBUG_PAUSE) Slog.v(TAG, "To many pending stops, forcing idle");
                     mStackSupervisor.scheduleIdleLocked();
                 } else {
                     mStackSupervisor.checkReadyForSleepLocked();
                 }
             }
         } else {
             if (DEBUG_PAUSE) Slog.v(TAG, "App died during pause, not stopping: " + prev);
             prev = null;
         }
         mPausingActivity = null;
     }
     if (resumeNext) {
         final ActivityStack topStack = mStackSupervisor.getFocusedStack();
         if (!mService.isSleepingOrShuttingDown()) {
             mStackSupervisor.resumeTopActivitiesLocked(topStack, prev, null);
         } else {
             mStackSupervisor.checkReadyForSleepLocked();
             ActivityRecord top = topStack.topRunningActivityLocked(null);
             if (top == null || (prev != null && top != prev)) {
                 // If there are no more activities available to run,
                 // do resume anyway to start something.  Also if the top
                 // activity on the stack is not the just paused activity,
                 // we need to go ahead and resume it to ensure we complete
                 // an in-flight app switch.
                 mStackSupervisor.resumeTopActivitiesLocked(topStack, null, null);
             }
         }
     }
     if (prev != null) {
         prev.resumeKeyDispatchingLocked();
         if (prev.app != null && prev.cpuTimeAtResume > 0
                 && mService.mBatteryStatsService.isOnBattery()) {
             long diff = mService.mProcessCpuTracker.getCpuTimeForPid(prev.app.pid)
                     - prev.cpuTimeAtResume;
             if (diff > 0) {
                 BatteryStatsImpl bsi = mService.mBatteryStatsService.getActiveStatistics();
                 synchronized (bsi) {
                     BatteryStatsImpl.Uid.Proc ps =
                             bsi.getProcessStatsLocked(prev.info.applicationInfo.uid,
                                     prev.info.packageName);
                     if (ps != null) {
                         ps.addForegroundTimeLocked(diff);
                     }
                 }
             }
         }
         prev.cpuTimeAtResume = 0; // reset it
     }
 }

由于resumeNext为true,会执行到 mStackSupervisor.resumeTopActivitiesLocked(topStack, prev, null);该方法如下：

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
boolean resumeTopActivitiesLocked(ActivityStack targetStack, ActivityRecord target,
         Bundle targetOptions) {
     if (targetStack == null) {
         targetStack = getFocusedStack();
     }
     // Do targetStack first.
     boolean result = false;
     if (isFrontStack(targetStack)) {
         result = targetStack.resumeTopActivityLocked(target, targetOptions);
     }
     for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
         final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
         for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
             final ActivityStack stack = stacks.get(stackNdx);
             if (stack == targetStack) {
                 // Already started above.
                 continue;
             }
             if (isFrontStack(stack)) {
                 stack.resumeTopActivityLocked(null);
             }
         }
     }
     return result;
 }

isFrontStack()会返回true,从而执行result = targetStack.resumeTopActivityLocked(target, targetOptions);该方法如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
final boolean resumeTopActivityLocked(ActivityRecord prev, Bundle options) {
     if (inResumeTopActivity) {
         // Don't even start recursing.
         return false;
     }
     boolean result = false;
     try {
         // Protect against recursion.
         inResumeTopActivity = true;
         result = resumeTopActivityInnerLocked(prev, options);
     } finally {
         inResumeTopActivity = false;
     }
     return result;
 }

再进入resumeTopActivityInnerLocked()中:

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
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
final boolean resumeTopActivityInnerLocked(ActivityRecord prev, Bundle options) {
    if (ActivityManagerService.DEBUG_LOCKSCREEN) mService.logLockScreen("");
    if (!mService.mBooting && !mService.mBooted) {
        // Not ready yet!
        return false;
    }
    ActivityRecord parent = mActivityContainer.mParentActivity;
    if ((parent != null && parent.state != ActivityState.RESUMED) ||
            !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;
    }
    cancelInitializingActivities();
    // Find the first activity that is not finishing.
    ActivityRecord next = topRunningActivityLocked(null);
    // 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;
    final TaskRecord prevTask = prev != null ? prev.task : null;
    if (next == null) {
        // There are no more activities!  Let's just start up the
        // Launcher...
        ActivityOptions.abort(options);
        if (DEBUG_STATES) Slog.d(TAG, "resumeTopActivityLocked: No more activities go home");
        if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
        // Only resume home if on home display
        final int returnTaskType = prevTask == null || !prevTask.isOverHomeStack() ?
                HOME_ACTIVITY_TYPE : prevTask.getTaskToReturnTo();
        return isOnHomeDisplay() &&
                mStackSupervisor.resumeHomeStackTask(returnTaskType, prev);
    }
    next.delayedResume = false;
    // If the top activity is the resumed one, nothing to do.
    if (mResumedActivity == next && next.state == ActivityState.RESUMED &&
                mStackSupervisor.allResumedActivitiesComplete()) {
        // Make sure we have executed any pending transitions, since there
        // should be nothing left to do at this point.
        mWindowManager.executeAppTransition();
        mNoAnimActivities.clear();
        ActivityOptions.abort(options);
        if (DEBUG_STATES) Slog.d(TAG, "resumeTopActivityLocked: Top activity resumed " + next);
        if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
        // Make sure to notify Keyguard as well if it is waiting for an activity to be drawn.
        mStackSupervisor.notifyActivityDrawnForKeyguard();
        return false;
    }
    final TaskRecord nextTask = next.task;
    if (prevTask != null && prevTask.stack == 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 (DEBUG_STATES && isOnHomeDisplay()) Slog.d(TAG,
                    "resumeTopActivityLocked: Launching home next");
            // Only resume home if on home display
            final int returnTaskType = prevTask == null || !prevTask.isOverHomeStack() ?
                    HOME_ACTIVITY_TYPE : prevTask.getTaskToReturnTo();
            return isOnHomeDisplay() &&
                    mStackSupervisor.resumeHomeStackTask(returnTaskType, prev);
        }
    }
    // 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.isSleepingOrShuttingDown()
            && mLastPausedActivity == next
            && mStackSupervisor.allPausedActivitiesComplete()) {
        // Make sure we have executed any pending transitions, since there
        // should be nothing left to do at this point.
        mWindowManager.executeAppTransition();
        mNoAnimActivities.clear();
        ActivityOptions.abort(options);
        if (DEBUG_STATES) Slog.d(TAG, "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.mStartedUsers.get(next.userId) == null) {
        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.mWaitingVisibleActivities.remove(next);
    if (DEBUG_SWITCH) Slog.v(TAG, "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,
                "resumeTopActivityLocked: Skip resume: some activity pausing.");
        if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
        return false;
    }
    // Okay we are now going to start a switch, to 'next'.  We may first
    // have to pause the current activity, but this is an important point
    // where we have decided to go to 'next' so keep track of that.
    // XXX "App Redirected" dialog is getting too many false positives
    // at this point, so turn off for now.
    if (false) {
        if (mLastStartedActivity != null && !mLastStartedActivity.finishing) {
            long now = SystemClock.uptimeMillis();
            final boolean inTime = mLastStartedActivity.startTime != 0
                    && (mLastStartedActivity.startTime + START_WARN_TIME) >= now;
            final int lastUid = mLastStartedActivity.info.applicationInfo.uid;
            final int nextUid = next.info.applicationInfo.uid;
            if (inTime && lastUid != nextUid
                    && lastUid != next.launchedFromUid
                    && mService.checkPermission(
                            android.Manifest.permission.STOP_APP_SWITCHES,
                            -1, next.launchedFromUid)
                    != PackageManager.PERMISSION_GRANTED) {
                mService.showLaunchWarningLocked(mLastStartedActivity, next);
            } else {
                next.startTime = now;
                mLastStartedActivity = next;
            }
        } else {
            next.startTime = SystemClock.uptimeMillis();
            mLastStartedActivity = next;
        }
    }
    // We need to start pausing the current activity so the top one
    // can be resumed...
    boolean dontWaitForPause = (next.info.flags&ActivityInfo.FLAG_RESUME_WHILE_PAUSING) != 0;
    boolean pausing = mStackSupervisor.pauseBackStacks(userLeaving, true, dontWaitForPause);
    if (mResumedActivity != null) {
        pausing |= startPausingLocked(userLeaving, false, true, dontWaitForPause);
        if (DEBUG_STATES) Slog.d(TAG, "resumeTopActivityLocked: Pausing " + mResumedActivity);
    }
    if (pausing) {
        if (DEBUG_SWITCH || DEBUG_STATES) Slog.v(TAG,
                "resumeTopActivityLocked: Skip resume: need to start pausing");
        // At this point we want to put the upcoming activity's process
        // at the top of the LRU list, since we know we will be needing it
        // very soon and it would be a waste to let it get killed if it
        // happens to be sitting towards the end.
        if (next.app != null && next.app.thread != null) {
            mService.updateLruProcessLocked(next.app, true, null);
        }
        if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
        return true;
    }
    // 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.isSleeping() && mLastNoHistoryActivity != null &&
            !mLastNoHistoryActivity.finishing) {
        if (DEBUG_STATES) Slog.d(TAG, "no-history finish of " + mLastNoHistoryActivity +
                " on new resume");
        requestFinishActivityLocked(mLastNoHistoryActivity.appToken, Activity.RESULT_CANCELED,
                null, "no-history", false);
        mLastNoHistoryActivity = null;
    }
    if (prev != null && prev != next) {
        if (!prev.waitingVisible && next != null && !next.nowVisible) {
            prev.waitingVisible = true;
            mStackSupervisor.mWaitingVisibleActivities.add(prev);
            if (DEBUG_SWITCH) Slog.v(
                    TAG, "Resuming top, waiting visible to hide: " + prev);
        } else {
            // The next activity is already visible, so hide the previous
            // activity's windows right now so we can show the new one ASAP.
            // We only do this if the previous is finishing, which should mean
            // it is on top of the one being resumed so hiding it quickly
            // is good.  Otherwise, we want to do the normal route of allowing
            // the resumed activity to be shown so we can decide if the
            // previous should actually be hidden depending on whether the
            // new one is found to be full-screen or not.
            if (prev.finishing) {
                mWindowManager.setAppVisibility(prev.appToken, false);
                if (DEBUG_SWITCH) Slog.v(TAG, "Not waiting for visible to hide: "
                        + prev + ", waitingVisible="
                        + (prev != null ? prev.waitingVisible : null)
                        + ", nowVisible=" + next.nowVisible);
            } else {
                if (DEBUG_SWITCH) Slog.v(TAG, "Previous already visible but still waiting to hide: "
                    + prev + ", waitingVisible="
                    + (prev != null ? prev.waitingVisible : null)
                    + ", 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);
    }
    // We are starting up the next activity, so tell the window manager
    // that the previous one will be hidden soon.  This way it can know
    // to ignore it when computing the desired screen orientation.
    boolean anim = true;
    if (prev != null) {
        if (prev.finishing) {
            if (DEBUG_TRANSITION) Slog.v(TAG,
                    "Prepare close transition: prev=" + prev);
            if (mNoAnimActivities.contains(prev)) {
                anim = false;
                mWindowManager.prepareAppTransition(AppTransition.TRANSIT_NONE, false);
            } else {
                mWindowManager.prepareAppTransition(prev.task == next.task
                        ? AppTransition.TRANSIT_ACTIVITY_CLOSE
                        : AppTransition.TRANSIT_TASK_CLOSE, false);
            }
            mWindowManager.setAppWillBeHidden(prev.appToken);
            mWindowManager.setAppVisibility(prev.appToken, false);
        } else {
            if (DEBUG_TRANSITION) Slog.v(TAG, "Prepare open transition: prev=" + prev);
            if (mNoAnimActivities.contains(next)) {
                anim = false;
                mWindowManager.prepareAppTransition(AppTransition.TRANSIT_NONE, false);
            } else {
                mWindowManager.prepareAppTransition(prev.task == next.task
                        ? AppTransition.TRANSIT_ACTIVITY_OPEN
                        : next.mLaunchTaskBehind
                                ? AppTransition.TRANSIT_TASK_OPEN_BEHIND
                                : AppTransition.TRANSIT_TASK_OPEN, false);
            }
        }
        if (false) {
            mWindowManager.setAppWillBeHidden(prev.appToken);
            mWindowManager.setAppVisibility(prev.appToken, false);
        }
    } else {
        if (DEBUG_TRANSITION) Slog.v(TAG, "Prepare open transition: no previous");
        if (mNoAnimActivities.contains(next)) {
            anim = false;
            mWindowManager.prepareAppTransition(AppTransition.TRANSIT_NONE, false);
        } else {
            mWindowManager.prepareAppTransition(AppTransition.TRANSIT_ACTIVITY_OPEN, false);
        }
    }
    Bundle resumeAnimOptions = null;
    if (anim) {
        ActivityOptions opts = next.getOptionsForTargetActivityLocked();
        if (opts != null) {
            resumeAnimOptions = opts.toBundle();
        }
        next.applyOptionsLocked();
    } else {
        next.clearOptionsLocked();
    }
    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) {
                mWindowManager.setAppStartingWindow(
                        next.appToken, next.packageName, next.theme,
                        mService.compatibilityInfoForPackageLocked(
                                next.info.applicationInfo),
                        next.nonLocalizedLabel,
                        next.labelRes, next.icon, next.logo, next.windowFlags,
                        null, true);
            }
            if (DEBUG_SWITCH) Slog.v(TAG, "Restarting: " + next);
        }
        if (DEBUG_STATES) Slog.d(TAG, "resumeTopActivityLocked: Restarting " + next);
        mStackSupervisor.startSpecificActivityLocked(next, true, true);
    }
    if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
    return true;
}

由于App还未启动,故执行到mStackSupervisor.startSpecificActivityLocked(next, true, true);该方法如下:

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
void startSpecificActivityLocked(ActivityRecord r,
        boolean andResume, boolean checkConfig) {
    // Is this activity's application already running?
    ProcessRecord app = mService.getProcessRecordLocked(r.processName,
            r.info.applicationInfo.uid, true);
    r.task.stack.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);
}

由于app为null,故执行startProcessLocked()方法:

1
2
3
4
5
6
7
8
9
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 */);
    }

进入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
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;
    if (!isolated) {
        app = getProcessRecordLocked(processName, info.uid, keepIfLarge);
        checkTime(startTime, "startProcess: after getProcessRecord");
    } else {
        // If this is an isolated process, it can't re-use an existing process.
        app = null;
    }
    // We don't have to do anything more if:
    // (1) There is an existing application record; and
    // (2) The caller doesn't think it is dead, OR there is no thread
    //     object attached to it so we know it couldn't have crashed; and
    // (3) There is a pid assigned to it, so it is either starting or
    //     already running.
    if (DEBUG_PROCESSES) Slog.v(TAG, "startProcess: name=" + processName
            + " app=" + app + " knownToBeDead=" + knownToBeDead
            + " thread=" + (app != null ? app.thread : null)
            + " pid=" + (app != null ? app.pid : -1));
    if (app != null && app.pid > 0) {
        if (!knownToBeDead || app.thread == null) {
            // We already have the app running, or are waiting for it to
            // come up (we have a pid but not yet its thread), so keep it.
            if (DEBUG_PROCESSES) Slog.v(TAG, "App already running: " + app);
            // If this is a new package in the process, add the package to the list
            app.addPackage(info.packageName, info.versionCode, mProcessStats);
            checkTime(startTime, "startProcess: done, added package to proc");
            return app;
        }
        // An application record is attached to a previous process,
        // clean it up now.
        if (DEBUG_PROCESSES || DEBUG_CLEANUP) Slog.v(TAG, "App died: " + app);
        checkTime(startTime, "startProcess: bad proc running, killing");
        Process.killProcessGroup(app.info.uid, app.pid);
        handleAppDiedLocked(app, true, true);
        checkTime(startTime, "startProcess: done killing old proc");
    }
    String hostingNameStr = hostingName != null
            ? hostingName.flattenToShortString() : null;
    if (!isolated) {
        if ((intentFlags&Intent.FLAG_FROM_BACKGROUND) != 0) {
            // If we are in the background, then check to see if this process
            // is bad.  If so, we will just silently fail.
            if (mBadProcesses.get(info.processName, info.uid) != null) {
                if (DEBUG_PROCESSES) Slog.v(TAG, "Bad process: " + info.uid
                        + "/" + info.processName);
                return null;
            }
        } else {
            // When the user is explicitly starting a process, then clear its
            // crash count so that we won't make it bad until they see at
            // least one crash dialog again, and make the process good again
            // if it had been bad.
            if (DEBUG_PROCESSES) Slog.v(TAG, "Clearing bad process: " + info.uid
                    + "/" + info.processName);
            mProcessCrashTimes.remove(info.processName, info.uid);
            if (mBadProcesses.get(info.processName, info.uid) != null) {
                EventLog.writeEvent(EventLogTags.AM_PROC_GOOD,
                        UserHandle.getUserId(info.uid), info.uid,
                        info.processName);
                mBadProcesses.remove(info.processName, info.uid);
                if (app != null) {
                    app.bad = false;
                }
            }
        }
    }
    if (app == null) {
        checkTime(startTime, "startProcess: creating new process record");
        app = newProcessRecordLocked(info, processName, isolated, isolatedUid);
        app.crashHandler = crashHandler;
        if (app == null) {
            Slog.w(TAG, "Failed making new process record for "
                    + processName + "/" + info.uid + " isolated=" + isolated);
            return null;
        }
        mProcessNames.put(processName, app.uid, app);
        if (isolated) {
            mIsolatedProcesses.put(app.uid, app);
        }
        checkTime(startTime, "startProcess: done creating new process record");
    } else {
        // If this is a new package in the process, add the package to the list
        app.addPackage(info.packageName, info.versionCode, mProcessStats);
        checkTime(startTime, "startProcess: added package to existing proc");
    }
    // If the system is not ready yet, then hold off on starting this
    // process until it is.
    if (!mProcessesReady
            && !isAllowedWhileBooting(info)
            && !allowWhileBooting) {
        if (!mProcessesOnHold.contains(app)) {
            mProcessesOnHold.add(app);
        }
        if (DEBUG_PROCESSES) Slog.v(TAG, "System not ready, putting on hold: " + app);
        checkTime(startTime, "startProcess: returning with proc on hold");
        return 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;
}

排除那些检查及log代码，发现其实真正执行的是重载的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
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,
               "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 {
           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 PackageManager pm = mContext.getPackageManager();
                   permGids = pm.getPackageGids(app.info.packageName);
                   if (Environment.isExternalStorageEmulated()) {
                       checkTime(startTime, "startProcess: checking external storage perm");
                       if (pm.checkPermission(
                               android.Manifest.permission.ACCESS_ALL_EXTERNAL_STORAGE,
                               app.info.packageName) == PERMISSION_GRANTED) {
                           mountExternal = Zygote.MOUNT_EXTERNAL_MULTIUSER_ALL;
                       } else {
                           mountExternal = Zygote.MOUNT_EXTERNAL_MULTIUSER;
                       }
                   }
               } catch (PackageManager.NameNotFoundException e) {
                   Slog.w(TAG, "Unable to retrieve gids", e);
               }
               /*
                * Add shared application and profile GIDs so applications can share some
                * resources like shared libraries and access user-wide resources
                */
               if (permGids == null) {
                   gids = new int[2];
               } else {
                   gids = new int[permGids.length + 2];
                   System.arraycopy(permGids, 0, gids, 2, permGids.length);
               }
               gids[0] = UserHandle.getSharedAppGid(UserHandle.getAppId(uid));
               gids[1] = 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_DEBUGGER;
               // 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;
           }
           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;
           }
           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);
           }
           // 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";
           checkTime(startTime, "startProcess: asking zygote to start proc");
           Process.ProcessStartResult startResult = Process.start(entryPoint,
                   app.processName, uid, uid, gids, debugFlags, mountExternal,
                   app.info.targetSdkVersion, app.info.seinfo, requiredAbi, instructionSet,
                   app.info.dataDir, entryPointArgs);
           checkTime(startTime, "startProcess: returned from zygote!");
           if (app.isolated) {
               mBatteryStatsService.addIsolatedUid(app.uid, app.info.uid);
           }
           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 : "");
           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(app.processName);
           if (!isActivityProcess) {
               buf.append(" [");
               buf.append(entryPoint);
               buf.append("]");
           }
           buf.append(" for ");
           buf.append(hostingType);
           if (hostingNameStr != null) {
               buf.append(" ");
               buf.append(hostingNameStr);
           }
           buf.append(": pid=");
           buf.append(startResult.pid);
           buf.append(" uid=");
           buf.append(uid);
           buf.append(" gids={");
           if (gids != null) {
               for (int gi=0; gi<gids.length; gi++) {
                   if (gi != 0) buf.append(", ");
                   buf.append(gids[gi]);
               }
           }
           buf.append("}");
           if (requiredAbi != null) {
               buf.append(" abi=");
               buf.append(requiredAbi);
           }
           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");
           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) {
           // XXX do better error recovery.
           app.setPid(0);
           mBatteryStatsService.noteProcessFinish(app.processName, app.info.uid);
           if (app.isolated) {
               mBatteryStatsService.removeIsolatedUid(app.uid, app.info.uid);
           }
           Slog.e(TAG, "Failure starting process " + app.processName, e);
       }
   }

该方法的前面主要是参数解析和获取,核心代码是下面这一部分:

1
2
3
4
5
6
entryPoint = "android.app.ActivityThread";
checkTime(startTime, "startProcess: asking zygote to start proc");
Process.ProcessStartResult startResult = Process.start(entryPoint,
         app.processName, uid, uid, gids, debugFlags, mountExternal,
         app.info.targetSdkVersion, app.info.seinfo, requiredAbi, instructionSet,
         app.info.dataDir, entryPointArgs);

注意到entryPoint为”android.app.ActivityThread”,Process.start()实际上是调用Zygote来fork一个新的进程，并且在最后会调用ActivityThread的main()方法.AMS 所在的进程和 Zygote 所在的进程通过Socket通信，关于Socket的通信就不展开了。
ZygoteInit 中有如下代码:

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
private static void runSelectLoop(String abiList) throws MethodAndArgsCaller {
    ArrayList<FileDescriptor> fds = new ArrayList<FileDescriptor>();
    ArrayList<ZygoteConnection> peers = new ArrayList<ZygoteConnection>();
    FileDescriptor[] fdArray = new FileDescriptor[4];
    fds.add(sServerSocket.getFileDescriptor());
    peers.add(null);
    int loopCount = GC_LOOP_COUNT;
    while (true) {
        int index;
        /*
         * Call gc() before we block in select().
         * It's work that has to be done anyway, and it's better
         * to avoid making every child do it.  It will also
         * madvise() any free memory as a side-effect.
         *
         * Don't call it every time, because walking the entire
         * heap is a lot of overhead to free a few hundred bytes.
         */
        if (loopCount <= 0) {
            gc();
            loopCount = GC_LOOP_COUNT;
        } else {
            loopCount--;
        }
        try {
            fdArray = fds.toArray(fdArray);
            index = selectReadable(fdArray);
        } catch (IOException ex) {
            throw new RuntimeException("Error in select()", ex);
        }
        if (index < 0) {
            throw new RuntimeException("Error in select()");
        } else if (index == 0) {
            ZygoteConnection newPeer = acceptCommandPeer(abiList);
            peers.add(newPeer);
            fds.add(newPeer.getFileDescriptor());
        } else {
            boolean done;
            done = peers.get(index).runOnce();
            if (done) {
                peers.remove(index);
                fds.remove(index);
            }
        }
    }
}

显然，Zygote 进程在循环读取Socket通信信息，一旦accept到一个ZygoteConnection,就会通过runOnce()方法进行处理:

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
boolean runOnce() throws ZygoteInit.MethodAndArgsCaller {
    String args[];
    Arguments parsedArgs = null;
    FileDescriptor[] descriptors;
    long startTime = SystemClock.elapsedRealtime();
    try {
        args = readArgumentList();
        descriptors = mSocket.getAncillaryFileDescriptors();
    } catch (IOException ex) {
        Log.w(TAG, "IOException on command socket " + ex.getMessage());
        closeSocket();
        return true;
    }
    checkTime(startTime, "zygoteConnection.runOnce: readArgumentList");
    if (args == null) {
        // EOF reached.
        closeSocket();
        return true;
    }
    /** the stderr of the most recent request, if avail */
    PrintStream newStderr = null;
    if (descriptors != null && descriptors.length >= 3) {
        newStderr = new PrintStream(
                new FileOutputStream(descriptors[2]));
    }
    int pid = -1;
    FileDescriptor childPipeFd = null;
    FileDescriptor serverPipeFd = null;
    try {
        parsedArgs = new Arguments(args);
        if (parsedArgs.abiListQuery) {
            return handleAbiListQuery();
        }
        if (parsedArgs.permittedCapabilities != 0 || parsedArgs.effectiveCapabilities != 0) {
            throw new ZygoteSecurityException("Client may not specify capabilities: " +
                    "permitted=0x" + Long.toHexString(parsedArgs.permittedCapabilities) +
                    ", effective=0x" + Long.toHexString(parsedArgs.effectiveCapabilities));
        }
        applyUidSecurityPolicy(parsedArgs, peer, peerSecurityContext);
        applyRlimitSecurityPolicy(parsedArgs, peer, peerSecurityContext);
        applyInvokeWithSecurityPolicy(parsedArgs, peer, peerSecurityContext);
        applyseInfoSecurityPolicy(parsedArgs, peer, peerSecurityContext);
        checkTime(startTime, "zygoteConnection.runOnce: apply security policies");
        applyDebuggerSystemProperty(parsedArgs);
        applyInvokeWithSystemProperty(parsedArgs);
        checkTime(startTime, "zygoteConnection.runOnce: apply security policies");
        int[][] rlimits = null;
        if (parsedArgs.rlimits != null) {
            rlimits = parsedArgs.rlimits.toArray(intArray2d);
        }
        if (parsedArgs.runtimeInit && parsedArgs.invokeWith != null) {
            FileDescriptor[] pipeFds = Os.pipe();
            childPipeFd = pipeFds[1];
            serverPipeFd = pipeFds[0];
            ZygoteInit.setCloseOnExec(serverPipeFd, true);
        }
        /**
         * In order to avoid leaking descriptors to the Zygote child,
         * the native code must close the two Zygote socket descriptors
         * in the child process before it switches from Zygote-root to
         * the UID and privileges of the application being launched.
         *
         * In order to avoid "bad file descriptor" errors when the
         * two LocalSocket objects are closed, the Posix file
         * descriptors are released via a dup2() call which closes
         * the socket and substitutes an open descriptor to /dev/null.
         */
        int [] fdsToClose = { -1, -1 };
        FileDescriptor fd = mSocket.getFileDescriptor();
        if (fd != null) {
            fdsToClose[0] = fd.getInt$();
        }
        fd = ZygoteInit.getServerSocketFileDescriptor();
        if (fd != null) {
            fdsToClose[1] = fd.getInt$();
        }
        fd = null;
        checkTime(startTime, "zygoteConnection.runOnce: preForkAndSpecialize");
        pid = Zygote.forkAndSpecialize(parsedArgs.uid, parsedArgs.gid, parsedArgs.gids,
                parsedArgs.debugFlags, rlimits, parsedArgs.mountExternal, parsedArgs.seInfo,
                parsedArgs.niceName, fdsToClose, parsedArgs.instructionSet,
                parsedArgs.appDataDir);
        checkTime(startTime, "zygoteConnection.runOnce: postForkAndSpecialize");
    } catch (IOException ex) {
        logAndPrintError(newStderr, "Exception creating pipe", ex);
    } catch (ErrnoException ex) {
        logAndPrintError(newStderr, "Exception creating pipe", ex);
    } catch (IllegalArgumentException ex) {
        logAndPrintError(newStderr, "Invalid zygote arguments", ex);
    } catch (ZygoteSecurityException ex) {
        logAndPrintError(newStderr,
                "Zygote security policy prevents request: ", ex);
    }
    try {
        if (pid == 0) {
            // in child
            IoUtils.closeQuietly(serverPipeFd);
            serverPipeFd = null;
            handleChildProc(parsedArgs, descriptors, childPipeFd, newStderr);
            // should never get here, the child is expected to either
            // throw ZygoteInit.MethodAndArgsCaller or exec().
            return true;
        } else {
            // in parent...pid of < 0 means failure
            IoUtils.closeQuietly(childPipeFd);
            childPipeFd = null;
            return handleParentProc(pid, descriptors, serverPipeFd, parsedArgs);
        }
    } finally {
        IoUtils.closeQuietly(childPipeFd);
        IoUtils.closeQuietly(serverPipeFd);
    }
}

创建App进程的代码是Zygote.forkAndSpecialize()这个方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public static int forkAndSpecialize(int uid, int gid, int[] gids, int debugFlags,
         int[][] rlimits, int mountExternal, String seInfo, String niceName, int[] fdsToClose,
         String instructionSet, String appDataDir) {
       long startTime = SystemClock.elapsedRealtime();
       VM_HOOKS.preFork();
       checkTime(startTime, "Zygote.preFork");
       int pid = nativeForkAndSpecialize(
                 uid, gid, gids, debugFlags, rlimits, mountExternal, seInfo, niceName, fdsToClose,
                 instructionSet, appDataDir);
       checkTime(startTime, "Zygote.nativeForkAndSpecialize");
       VM_HOOKS.postForkCommon();
       checkTime(startTime, "Zygote.postForkCommon");
       return pid;
   }
   native private static int nativeForkAndSpecialize(int uid, int gid, int[] gids,int debugFlags,
         int[][] rlimits, int mountExternal, String seInfo, String niceName, int[] fdsToClose,
         String instructionSet, String appDataDir);

显然forkAndSpecialize()其实是调用nativeForkAndSpecialize()这个native方法来完成进程的fork过程，下面就不分析C/C++代码了。回到ZygoteConnection中的runOnce()方法中,注意下面这一段代码: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
if (pid == 0) {
    // in child
    IoUtils.closeQuietly(serverPipeFd);
    serverPipeFd = null;
    handleChildProc(parsedArgs, descriptors, childPipeFd, newStderr);
    // should never get here, the child is expected to either
    // throw ZygoteInit.MethodAndArgsCaller or exec().
    return true;
} else {
    // in parent...pid of < 0 means failure
    IoUtils.closeQuietly(childPipeFd);
    childPipeFd = null;
    return handleParentProc(pid, descriptors, serverPipeFd, parsedArgs);
}

表示会在创建的App进程中执行handleChildProc()方法,该方法代码如下:

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
private void handleChildProc(Arguments parsedArgs,
           FileDescriptor[] descriptors, FileDescriptor pipeFd, PrintStream newStderr)
           throws ZygoteInit.MethodAndArgsCaller {
       /**
        * By the time we get here, the native code has closed the two actual Zygote
        * socket connections, and substituted /dev/null in their place.  The LocalSocket
        * objects still need to be closed properly.
        */
       closeSocket();
       ZygoteInit.closeServerSocket();
       if (descriptors != null) {
           try {
               ZygoteInit.reopenStdio(descriptors[0],
                       descriptors[1], descriptors[2]);
               for (FileDescriptor fd: descriptors) {
                   IoUtils.closeQuietly(fd);
               }
               newStderr = System.err;
           } catch (IOException ex) {
               Log.e(TAG, "Error reopening stdio", ex);
           }
       }
       if (parsedArgs.niceName != null) {
           Process.setArgV0(parsedArgs.niceName);
       }
       if (parsedArgs.runtimeInit) {
           if (parsedArgs.invokeWith != null) {
               WrapperInit.execApplication(parsedArgs.invokeWith,
                       parsedArgs.niceName, parsedArgs.targetSdkVersion,
                       pipeFd, parsedArgs.remainingArgs);
           } else {
               RuntimeInit.zygoteInit(parsedArgs.targetSdkVersion,
                       parsedArgs.remainingArgs, null /* classLoader */);
           }
       } else {
           String className;
           try {
               className = parsedArgs.remainingArgs[0];
           } catch (ArrayIndexOutOfBoundsException ex) {
               logAndPrintError(newStderr,
                       "Missing required class name argument", null);
               return;
           }
           String[] mainArgs = new String[parsedArgs.remainingArgs.length - 1];
           System.arraycopy(parsedArgs.remainingArgs, 1,
                   mainArgs, 0, mainArgs.length);
           if (parsedArgs.invokeWith != null) {
               WrapperInit.execStandalone(parsedArgs.invokeWith,
                       parsedArgs.classpath, className, mainArgs);
           } else {
               ClassLoader cloader;
               if (parsedArgs.classpath != null) {
                   cloader = new PathClassLoader(parsedArgs.classpath,
                           ClassLoader.getSystemClassLoader());
               } else {
                   cloader = ClassLoader.getSystemClassLoader();
               }
               try {
                   ZygoteInit.invokeStaticMain(cloader, className, mainArgs);
               } catch (RuntimeException ex) {
                   logAndPrintError(newStderr, "Error starting.", ex);
               }
           }
       }
   }

注意最后面的ZygoteInit.invokeStaticMain(cloader, className, mainArgs);显然，ActivityThread 的main()方法就是在这里通过反射调用的,而ActivityThread的main()方法如下:

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
public static void main(String[] args) {
       SamplingProfilerIntegration.start();
       // CloseGuard defaults to true and can be quite spammy.  We
       // disable it here, but selectively enable it later (via
       // StrictMode) on debug builds, but using DropBox, not logs.
       CloseGuard.setEnabled(false);
       Environment.initForCurrentUser();
       // Set the reporter for event logging in libcore
       EventLogger.setReporter(new EventLoggingReporter());
       Security.addProvider(new AndroidKeyStoreProvider());
       // Make sure TrustedCertificateStore looks in the right place for CA certificates
       final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());
       TrustedCertificateStore.setDefaultUserDirectory(configDir);
       Process.setArgV0("<pre-initialized>");
       Looper.prepareMainLooper();
       ActivityThread thread = new ActivityThread();
       thread.attach(false);
       if (sMainThreadHandler == null) {
           sMainThreadHandler = thread.getHandler();
       }
       AsyncTask.init();
       if (false) {
           Looper.myLooper().setMessageLogging(new
                   LogPrinter(Log.DEBUG, "ActivityThread"));
       }
       Looper.loop();
       throw new RuntimeException("Main thread loop unexpectedly exited");
   }

从这里开始，准备号主线程的消息队列，并为App配置一个ActivityThread,在通过thread.attach()将ActivityThead与AMS关联起来，注意这里的ActivityThread才是属于App的，后续AMS通过Binder通知ActivityThread进行这个App中所有主线程的调度工作，ActivityThread 再通过Instrumentation来真正执行。