AMS-Activity启动流程_android ams startactivity流程

本文基于Android_9.0、kernel_3.18源码

由PMS-PackageManagerService我们知道，PMS会在开机/安装app时解析APK的AndroidManifest.xml文件，并将解析的结果缓存在PMS中。

接下来分析启动Activity的流程。

Launcher启动流程

一、AMS获取Launcher的Activity

1、SystemServer

由Binder（五）服务注册流程-发送注册请求可知：
手机开机后会启动system_server进程，然后调用SystemServer的main方法，在main方法中通过startBootstrapServices启动AMS。之后通过startOtherServices方法调用AMS的systemReady ，告知AMS可以执行第三方代码。

private void startBootstrapServices() {
    ...
    // 启动AMS
    traceBeginAndSlog("StartActivityManager");
    mActivityManagerService = mSystemServiceManager.startService(
            ActivityManagerService.Lifecycle.class).getService();
    mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
    mActivityManagerService.setInstaller(installer);
    traceEnd();
    ...
}

private void startOtherServices() {
    ...
    // 告诉AMS可以执行第三方代码，并完成systemserver的初始化。
    // We now tell the activity manager it is okay to run third party
    // code.  It will call back into us once it has gotten to the state
    // where third party code can really run (but before it has actually
    // started launching the initial applications), for us to complete our
    // initialization.
    mActivityManagerService.systemReady(() -> {...}, BOOT_TIMINGS_TRACE_LOG);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

2、systemReady

public void systemReady(final Runnable goingCallback, TimingsTraceLog traceLog) {
    ...
    synchronized (this) {
        ...
        // Start up initial activity.
        mBooting = true;
        ...
        // 启动初始Activity
        startHomeActivityLocked(currentUserId, "systemReady");
        ...
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

在AMS的systemReady方法中，通过调用startHomeActivityLocked来启动初始Activity。

3、startHomeActivityLocked

public static final String ACTION_MAIN = "android.intent.action.MAIN";
public static final String CATEGORY_HOME = "android.intent.category.HOME";
String mTopAction = Intent.ACTION_MAIN;

// 获取home的intent
Intent getHomeIntent() {
    Intent intent = new Intent(mTopAction, mTopData != null ? Uri.parse(mTopData) : null);
    intent.setComponent(mTopComponent);
    intent.addFlags(Intent.FLAG_DEBUG_TRIAGED_MISSING);
    if (mFactoryTest != FactoryTest.FACTORY_TEST_LOW_LEVEL) {
        intent.addCategory(Intent.CATEGORY_HOME);
    }
    return intent;
}

// 启动homeActivity
boolean startHomeActivityLocked(int userId, String reason) {
    ...
    // 获取首页Intent
    Intent intent = getHomeIntent();
    // 获取activity的信息
    ActivityInfo aInfo = resolveActivityInfo(intent, STOCK_PM_FLAGS, userId);
    if (aInfo != null) {
        intent.setComponent(new ComponentName(aInfo.applicationInfo.packageName, aInfo.name));
        // Don't do this if the home app is currently being
        // instrumented.
        aInfo = new ActivityInfo(aInfo);
        aInfo.applicationInfo = getAppInfoForUser(aInfo.applicationInfo, userId);
        ProcessRecord app = getProcessRecordLocked(aInfo.processName,
                aInfo.applicationInfo.uid, true);
        if (app == null || app.instr == null) {
            intent.setFlags(intent.getFlags() | FLAG_ACTIVITY_NEW_TASK);
            final int resolvedUserId = UserHandle.getUserId(aInfo.applicationInfo.uid);
            // For ANR debugging to verify if the user activity is the one that actually
            // launched.
            final String myReason = reason + ":" + userId + ":" + resolvedUserId;
            
            // 启动Home activity
            mActivityStartController.startHomeActivity(intent, aInfo, myReason);
        }
    } else {...}
    return 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

首先， 通过getHomeIntent获取到Intent；
然后， 通过resolveActivityInfo得到Activity；
最后， 通过mActivityStartController.startHomeActivity启动Activity。

下面对resolveActivityInfo 和mActivityStartController.startHomeActivity 进行分析。

4、resolveActivityInfo

private ActivityInfo resolveActivityInfo(Intent intent, int flags, int userId) {
    ActivityInfo ai = null;
    // 由于mTopComponent是null，在getHomeIntent设置的就是null，所以这里得到的intent也是null。
    ComponentName comp = intent.getComponent();
    try {
        if (comp != null) {
           ...
        } else {
            ResolveInfo info = AppGlobals.getPackageManager().resolveIntent(
                    intent,
                    intent.resolveTypeIfNeeded(mContext.getContentResolver()),
                    flags, userId);
            if (info != null) {
                ai = info.activityInfo;
            }
        }
    } catch (RemoteException e) {...}
    return ai;
}

// AppGlobals的getPackageManager，调用ActivityThread的方法
public static IPackageManager getPackageManager() {
    return ActivityThread.getPackageManager();
}

// 通过binder获取到PMS的代理对象
public static IPackageManager getPackageManager() {
    if (sPackageManager != null) {
        return sPackageManager;
    }
    IBinder b = ServiceManager.getService("package");
    sPackageManager = IPackageManager.Stub.asInterface(b);
    return sPackageManager;
}
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

由于mTopComponent是null，在getHomeIntent设置的就是null，所以这里得到的intent也是null；因此通过PMS的resolveIntent获取数据。

5、resolveIntent

public ResolveInfo resolveIntent(Intent intent, String resolvedType,
        int flags, int userId) {
    return resolveIntentInternal(intent, resolvedType, flags, userId, false,
            Binder.getCallingUid());
}

private ResolveInfo resolveIntentInternal(Intent intent, String resolvedType,
        int flags, int userId, boolean resolveForStart, int filterCallingUid) {
    try {
        ...
        final List<ResolveInfo> query = queryIntentActivitiesInternal(intent, resolvedType,
                flags, filterCallingUid, userId, resolveForStart, true /*allowDynamicSplits*/);
        // 选择合适的activity，某些场景（如：url）可能多个app支持打开，需要让用户选择
        final ResolveInfo bestChoice =
                chooseBestActivity(intent, resolvedType, flags, query, userId);
        return bestChoice;
    } finally {...}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

resolveIntent调用到resolveIntentInternal，其中通过queryIntentActivitiesInternal查找Activity，通过chooseBestActivity选择合适的Activity进行返回。

6、queryIntentActivitiesInternal

private @NonNull List<ResolveInfo> queryIntentActivitiesInternal(Intent intent,
        String resolvedType, int flags, int filterCallingUid, int userId,
        boolean resolveForStart, boolean allowDynamicSplits) {
    // 由上下文可知，这里为null
    final String pkgName = intent.getPackage();
    ComponentName comp = intent.getComponent();
    if (comp == null) {
        if (intent.getSelector() != null) {
            intent = intent.getSelector();
            comp = intent.getComponent();
        }
    }
    // 情况一：由于comp==null，不走这里
    if (comp != null) {
        final List<ResolveInfo> list = new ArrayList<ResolveInfo>(1);
        final ActivityInfo ai = getActivityInfo(comp, flags, userId);
        ...
        return applyPostResolutionFilter(
                list, instantAppPkgName, allowDynamicSplits, filterCallingUid, resolveForStart,
                userId, intent);
    }
    // reader
    List<ResolveInfo> result;
    synchronized (mPackages) {
        if (pkgName == null) {
            // 情况二：通过userid查询intent
            List<CrossProfileIntentFilter> matchingFilters = getMatchingCrossProfileIntentFilters(intent, resolvedType, userId);
            // Check for results that need to skip the current profile.
            ResolveInfo xpResolveInfo  = querySkipCurrentProfileIntents(matchingFilters, intent,
                    resolvedType, flags, userId);
            if (xpResolveInfo != null) {
                List<ResolveInfo> xpResult = new ArrayList<ResolveInfo>(1);
                xpResult.add(xpResolveInfo);
                return applyPostResolutionFilter(
                        filterIfNotSystemUser(xpResult, userId), instantAppPkgName,
                        allowDynamicSplits, filterCallingUid, resolveForStart, userId, intent);
            }
            // Check for results in the current profile.
            result = filterIfNotSystemUser(mActivities.queryIntent(
                    intent, resolvedType, flags, userId), userId);
            ...
            boolean hasNonNegativePriorityResult = hasNonNegativePriority(result);
            xpResolveInfo = queryCrossProfileIntents(
                    matchingFilters, intent, resolvedType, flags, userId,
                    hasNonNegativePriorityResult);
            ...
        } else {
            // 情况三：从pkg中查找
            final PackageParser.Package pkg = mPackages.get(pkgName);
            result = null;
            if (pkg != null) {
                result = filterIfNotSystemUser(
                        mActivities.queryIntentForPackage(
                                intent, resolvedType, flags, pkg.activities, userId),
                        userId);
            }
            ...
        }
    }
    ...
    return applyPostResolutionFilter(
            result, instantAppPkgName, allowDynamicSplits, filterCallingUid, resolveForStart,
            userId, intent);
}
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

该方法分三种情况：
1、comp != null：通过getActivityInfo -> getActivityInfoInternal 查找Activity的信息；
2、comp == null && pkgName == null：通过userid查询intent；
3、comp == null && pkgName != null：通过pkg的信息查找intent。

由前文分析可知，此处走分支2，调用querySkipCurrentProfileIntents。

7、querySkipCurrentProfileIntents

private ResolveInfo querySkipCurrentProfileIntents(
        List<CrossProfileIntentFilter> matchingFilters, Intent intent, String resolvedType,
        int flags, int sourceUserId) {
    if (matchingFilters != null) {
        int size = matchingFilters.size();
        for (int i = 0; i < size; i ++) {
            CrossProfileIntentFilter filter = matchingFilters.get(i);
            if ((filter.getFlags() & PackageManager.SKIP_CURRENT_PROFILE) != 0) {
                // Checking if there are activities in the target user that can handle the
                // intent.
                ResolveInfo resolveInfo = createForwardingResolveInfo(filter, intent,
                        resolvedType, flags, sourceUserId);
                if (resolveInfo != null) {
                    return resolveInfo;
                }
            }
        }
    }
    return null;
}

private ResolveInfo createForwardingResolveInfo(CrossProfileIntentFilter filter, Intent intent,
        String resolvedType, int flags, int sourceUserId) {
    int targetUserId = filter.getTargetUserId();
    List<ResolveInfo> resultTargetUser = mActivities.queryIntent(intent,
            resolvedType, flags, targetUserId);
    if (resultTargetUser != null && isUserEnabled(targetUserId)) {
        // If all the matches in the target profile are suspended, return null.
        for (int i = resultTargetUser.size() - 1; i >= 0; i--) {
            if ((resultTargetUser.get(i).activityInfo.applicationInfo.flags
                    & ApplicationInfo.FLAG_SUSPENDED) == 0) {
                return createForwardingResolveInfoUnchecked(filter, sourceUserId,
                        targetUserId);
            }
        }
    }
    return 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
26
27
28
29
30
31
32
33
34
35
36
37
38

querySkipCurrentProfileIntents最终会调用到createForwardingResolveInfo方法，可以看到方法内部通过mActivities.queryIntent() 查找Activity的信息。其他方法也是类似的逻辑，不再叙述，此处找到的Activity是com.android.launcher3.Launcher 。

二、AMS启动Activity的处理工作

1、mActivityStartController.startHomeActivity

首先看看mActivityStartController是什么：

// AMS的构造函数中直接new
public ActivityManagerService(Context systemContext) {
    ...
    mActivityStartController = new ActivityStartController(this);
    ...
}

// 在ActivityStartController构造函数中，new了DefaultFactory。
ActivityStartController(ActivityManagerService service) {
    this(service, service.mStackSupervisor,
            new DefaultFactory(service, service.mStackSupervisor,
                new ActivityStartInterceptor(service, service.mStackSupervisor)));
}

@VisibleForTesting
ActivityStartController(ActivityManagerService service, ActivityStackSupervisor supervisor,
        Factory factory) {
    mService = service;
    mSupervisor = supervisor;
    mHandler = new StartHandler(mService.mHandlerThread.getLooper());
    mFactory = factory;
    mFactory.setController(this);
    mPendingRemoteAnimationRegistry = new PendingRemoteAnimationRegistry(service,
            service.mHandler);
}
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

可以看到，mActivityStartController就是一个ActivityStartController实例，它的属性mFactory是一个ActivityStarter.DefaultFactory的对象。

void startHomeActivity(Intent intent, ActivityInfo aInfo, String reason) {
    mSupervisor.moveHomeStackTaskToTop(reason);
    // 启动Activity
    mLastHomeActivityStartResult = obtainStarter(intent, "startHomeActivity: " + reason)
            .setOutActivity(tmpOutRecord)
            .setCallingUid(0)
            .setActivityInfo(aInfo)
            .execute();
    mLastHomeActivityStartRecord = tmpOutRecord[0];
    if (mSupervisor.inResumeTopActivity) {
        // If we are in resume section already, home activity will be initialized, but not
        // resumed (to avoid recursive resume) and will stay that way until something pokes it
        // again. We need to schedule another resume.
        mSupervisor.scheduleResumeTopActivities();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

在startHomeActivity中，通过obtainStarter().execute()启动Activity。

2、obtainStarter()

// 这里执行的ActivityStarter.DefaultFactory的obtain。
ActivityStarter obtainStarter(Intent intent, String reason) {
    return mFactory.obtain().setIntent(intent).setReason(reason);
}

// ontain直接生成了ActivityStarter对象
public ActivityStarter obtain() {
    ActivityStarter starter = mStarterPool.acquire();
    if (starter == null) {
        starter = new ActivityStarter(mController, mService, mSupervisor, mInterceptor);
    }
    return starter;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

通过obtainStarter调用了ActivityStarter.DefaultFactory的obtain，直接返回了一个新的ActivityStarter。

3、ActivityStarter.execute()

int execute() {
    try {
        // TODO(b/64750076): Look into passing request directly to these methods to allow
        // for transactional diffs and preprocessing.
        if (mRequest.mayWait) {
            return startActivityMayWait(mRequest.caller, mRequest.callingUid,
                    mRequest.callingPackage, mRequest.intent, mRequest.resolvedType,
                    mRequest.voiceSession, mRequest.voiceInteractor, mRequest.resultTo,
                    mRequest.resultWho, mRequest.requestCode, mRequest.startFlags,
                    mRequest.profilerInfo, mRequest.waitResult, mRequest.globalConfig,
                    mRequest.activityOptions, mRequest.ignoreTargetSecurity, mRequest.userId,
                    mRequest.inTask, mRequest.reason,
                    mRequest.allowPendingRemoteAnimationRegistryLookup);
        } else {
            return startActivity(mRequest.caller, mRequest.intent, mRequest.ephemeralIntent,
                    mRequest.resolvedType, mRequest.activityInfo, mRequest.resolveInfo,
                    mRequest.voiceSession, mRequest.voiceInteractor, mRequest.resultTo,
                    mRequest.resultWho, mRequest.requestCode, mRequest.callingPid,
                    mRequest.callingUid, mRequest.callingPackage, mRequest.realCallingPid,
                    mRequest.realCallingUid, mRequest.startFlags, mRequest.activityOptions,
                    mRequest.ignoreTargetSecurity, mRequest.componentSpecified,
                    mRequest.outActivity, mRequest.inTask, mRequest.reason,
                    mRequest.allowPendingRemoteAnimationRegistryLookup);
        }
    } finally {
        onExecutionComplete();
    }
}
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

这里由于没有设置mayWait，所以会走下方的逻辑。

4、startActivity

private int startActivity(IApplicationThread caller, Intent intent, Intent ephemeralIntent,
        String resolvedType, ActivityInfo aInfo, ResolveInfo rInfo,
        IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
        IBinder resultTo, String resultWho, int requestCode, int callingPid, int callingUid,
        String callingPackage, int realCallingPid, int realCallingUid, int startFlags,
        SafeActivityOptions options, boolean ignoreTargetSecurity, boolean componentSpecified,
        ActivityRecord[] outActivity, TaskRecord inTask, String reason,
        boolean allowPendingRemoteAnimationRegistryLookup) {
    ...
    mLastStartActivityResult = startActivity(caller, intent, ephemeralIntent, resolvedType,
            aInfo, rInfo, voiceSession, voiceInteractor, resultTo, resultWho, requestCode,
            callingPid, callingUid, callingPackage, realCallingPid, realCallingUid, startFlags,
            options, ignoreTargetSecurity, componentSpecified, mLastStartActivityRecord,
            inTask, allowPendingRemoteAnimationRegistryLookup);
    ...
    return getExternalResult(mLastStartActivityResult);
}

private int startActivity(IApplicationThread caller, Intent intent, Intent ephemeralIntent,
                          String resolvedType, ActivityInfo aInfo, ResolveInfo rInfo,
                          IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
                          IBinder resultTo, String resultWho, int requestCode, int callingPid, int callingUid,
                          String callingPackage, int realCallingPid, int realCallingUid, int startFlags,
                          SafeActivityOptions options,
                          boolean ignoreTargetSecurity, boolean componentSpecified, ActivityRecord[] outActivity,
                          TaskRecord inTask, boolean allowPendingRemoteAnimationRegistryLookup) {
    ...
    // 生成ActivityRecord
    ActivityRecord r = new ActivityRecord(mService, callerApp, callingPid, callingUid,
            callingPackage, intent, resolvedType, aInfo, mService.getGlobalConfiguration(),
            resultRecord, resultWho, requestCode, componentSpecified, voiceSession != null,
    ...
    // 继续调用重载方法
    return startActivity(r, sourceRecord, voiceSession, voiceInteractor, startFlags,
            true /* doResume */, checkedOptions, inTask, outActivity);
}

private int startActivity(final ActivityRecord r, ActivityRecord sourceRecord,
                          IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
                          int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
                          ActivityRecord[] outActivity) {
    int result = START_CANCELED;
    try {
        mService.mWindowManager.deferSurfaceLayout();
        result = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor,
                startFlags, doResume, options, inTask, outActivity);
    } finally {
        ...
    }
    postStartActivityProcessing(r, result, mTargetStack);
    return result;
}
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

startActivity会调用多个重载方法，期间生成ActivityRecord，并调用startActivityUnchecked继续进行操作。

5、startActivityUnchecked

private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
                                   IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
                                   int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
                                   ActivityRecord[] outActivity) {
    // 处理启动模式
    computeLaunchingTaskFlags();

    ...处理栈相关的逻辑...

    mTargetStack.startActivityLocked(mStartActivity, topFocused, newTask, mKeepCurTransition,
            mOptions);
    if (mDoResume) {
        final ActivityRecord topTaskActivity = mStartActivity.getTask().topRunningActivityLocked();
        if (!mTargetStack.isFocusable()
                || (topTaskActivity != null && topTaskActivity.mTaskOverlay
                && mStartActivity != topTaskActivity)) {
            ...
        } else {
            // If the target stack was not previously focusable (previous top running activity
            // on that stack was not visible) then any prior calls to move the stack to the
            // will not update the focused stack.  If starting the new activity now allows the
            // task stack to be focusable, then ensure that we now update the focused stack
            // accordingly.
            if (mTargetStack.isFocusable() && !mSupervisor.isFocusedStack(mTargetStack)) {
                mTargetStack.moveToFront("startActivityUnchecked");
            }
            mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack, mStartActivity,
                    mOptions);
        }
    } else if (mStartActivity != null) {
        mSupervisor.mRecentTasks.add(mStartActivity.getTask());
    }
    ...
    return START_SUCCESS;
}
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

该方法处理启动模式、栈相关的逻辑，并通过resumeFocusedStackTopActivityLocked继续执行。

6、resumeFocusedStackTopActivityLocked

boolean resumeFocusedStackTopActivityLocked(
        ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
    if (!readyToResume()) {
        return false;
    }
    if (targetStack != null && isFocusedStack(targetStack)) {
        return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
    }
    final ActivityRecord r = mFocusedStack.topRunningActivityLocked();
    if (r == null || !r.isState(RESUMED)) {
        mFocusedStack.resumeTopActivityUncheckedLocked(null, null);
    } else if (r.isState(RESUMED)) {
        // Kick off any lingering app transitions form the MoveTaskToFront operation.
        mFocusedStack.executeAppTransition(targetOptions);
    }
    return false;
}

boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
    ...
    try {
        ...
        result = resumeTopActivityInnerLocked(prev, options);
        ...
    } finally {... }
    return result;
}
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

通过调用链 resumeFocusedStackTopActivityLocked -> resumeTopActivityUncheckedLocked -> resumeTopActivityInnerLocked 最终调用resumeTopActivityInnerLocked方法。

7、resumeTopActivityInnerLocked

private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
    ...
    
    // 这里找到的就是Launcher
    final ActivityRecord next = topRunningActivityLocked(true /* focusableOnly */);
    ...
    
    // mResumedActivity == null，不走startPausingLocked
    if (mResumedActivity != null) {
        pausing |= startPausingLocked(userLeaving, false, next, false);
    }
    ...
    
    if (next.app != null && next.app.thread != null) {
        ...
    } else {
        ...
        // 启动Activity
        mStackSupervisor.startSpecificActivityLocked(next, true, true);
    }
    if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
    return true;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

在resumeTopActivityInnerLocked中，通过一系列调用，会调用到startSpecificActivityLocked方法。

8、startSpecificActivityLocked

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);
    getLaunchTimeTracker().setLaunchTime(r);
    if (app != null && app.thread != null) {
       ...
    }
    mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,
            "activity", r.intent.getComponent(), false, false, true);
}
1
2
3
4
5
6
7
8
9
10
11

通过AMS的startProcessLocked启动App进程。

三、App进程启动

1、startProcessLocked

final ProcessRecord startProcessLocked(String processName,
        ApplicationInfo info, boolean knownToBeDead, int intentFlags,
        String hostingType, ComponentName hostingName, boolean allowWhileBooting,
        boolean isolated, boolean keepIfLarge) {
    return startProcessLocked(processName, info, knownToBeDead, intentFlags, hostingType,
            hostingName, allowWhileBooting, isolated, 0 /* isolatedUid */, keepIfLarge,
            null /* ABI override */, null /* entryPoint */, null /* entryPointArgs */,
            null /* crashHandler */);
}


final ProcessRecord startProcessLocked(String processName, ApplicationInfo info,
                                       boolean knownToBeDead, int intentFlags, String hostingType, ComponentName hostingName,
                                       boolean allowWhileBooting, boolean isolated, int isolatedUid, boolean keepIfLarge,
                                       String abiOverride, String entryPoint, String[] entryPointArgs, Runnable crashHandler) {
    long startTime = SystemClock.elapsedRealtime();
    ProcessRecord app;
    ...
    if (app == null) {
        ...
        // 生成新的ProcessRecord
        app = newProcessRecordLocked(info, processName, isolated, isolatedUid);
        ...
    } else {...}
    ...
    
    final boolean success = startProcessLocked(app, hostingType, hostingNameStr, abiOverride);
    checkTime(startTime, "startProcess: done starting proc!");
    return success ? app : 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
26
27
28
29
30

startProcessLocked会调用重载方法，然后通过newProcessRecordLocked生成新的ProcessRecord，之后会调用startProcessLocked进一步处理。

2、startProcessLocked

private final boolean startProcessLocked(ProcessRecord app,
        String hostingType, String hostingNameStr, String abiOverride) {
    return startProcessLocked(app, hostingType, hostingNameStr,
            false /* disableHiddenApiChecks */, abiOverride);
}


private final boolean startProcessLocked(ProcessRecord app, String hostingType,
                                         String hostingNameStr, boolean disableHiddenApiChecks, String abiOverride) {
    ...
    try {
        ...
        final String entryPoint = "android.app.ActivityThread";
        
        return startProcessLocked(hostingType, hostingNameStr, entryPoint, app, uid, gids,
                runtimeFlags, mountExternal, seInfo, requiredAbi, instructionSet, invokeWith,
                startTime);
    } catch (RuntimeException e) {...}
}


private boolean startProcessLocked(String hostingType, String hostingNameStr, String entryPoint,
                                   ProcessRecord app, int uid, int[] gids, int runtimeFlags, int mountExternal,
                                   String seInfo, String requiredAbi, String instructionSet, String invokeWith,
                                   long startTime) {
    ...
    // 同步还是异步
    if (mConstants.FLAG_PROCESS_START_ASYNC) {
        mProcStartHandler.post(() -> {
            try {
                ...
                final ProcessStartResult startResult = startProcess(app.hostingType, entryPoint,
                        app, app.startUid, gids, runtimeFlags, mountExternal, app.seInfo,
                        requiredAbi, instructionSet, invokeWith, app.startTime);
                synchronized (ActivityManagerService.this) {
                    handleProcessStartedLocked(app, startResult, startSeq);
                }
            } catch (RuntimeException e) {...}
        });
        return true;
    } else {
        try {
            final ProcessStartResult startResult = startProcess(hostingType, entryPoint, app,
                    uid, gids, runtimeFlags, mountExternal, seInfo, requiredAbi, instructionSet,
                    invokeWith, startTime);
            handleProcessStartedLocked(app, startResult.pid, startResult.usingWrapper,
                    startSeq, false);
        } catch (RuntimeException e) {...}
        return app.pid > 0;
    }
}
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

startProcessLocked通过一系列重载方法，最终调用startProcess进行处理，注意这里的entryPoint = “android.app.ActivityThread”

3、startProcess

private ProcessStartResult startProcess(String hostingType, String entryPoint,
                                        ProcessRecord app, int uid, int[] gids, int runtimeFlags, int mountExternal,
                                        String seInfo, String requiredAbi, String instructionSet, String invokeWith,
                                        long startTime) {
    try {
        ...
        final ProcessStartResult startResult;
        if (hostingType.equals("webview_service")) {...} else {
            startResult = Process.start(entryPoint,
                    app.processName, uid, uid, gids, runtimeFlags, mountExternal,
                    app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
                    app.info.dataDir, invokeWith,
                    new String[] {PROC_START_SEQ_IDENT + app.startSeq});
        }
        checkTime(startTime, "startProcess: returned from zygote!");
        return startResult;
    } finally {...}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

通过Process.start()启动进程

4、通过socket通知zygote进程

通过如下掉用链，会将启动进程的数据发送给zygote进程，
ProcessStartResult.start() ->
ZygoteProcess.start() ->
ZygoteProcess.startViaZygote() ->
ZygoteProcess.zygoteSendArgsAndGetResult() ->
ZygoteProcess.attemptZygoteSendArgsAndGetResult() ->
{ zygoteWriter.write(msgStr); zygoteWriter.flush(); }

由Zygote进程简介可知，zygote进程启动后，会启动轮询等待消息。

在zygote中，会通过ZygoteConnection.processOneCommand()处理client发送来的消息，然后通过Zygote.forkAndSpecialize() fork出进程，在通过ZygoteConnection.handleChildProc() -> ZygoteInit.childZygoteInit() -> RuntimeInit.findStaticMain() 调用main方法。由上文可知，这里会调用到android.app.ActivityThread的main方法。

四、Activity生命周期

1、ActivityThread

final ApplicationThread mAppThread = new ApplicationThread();

public static void main(String[] args) {
    ...
    Looper.prepareMainLooper();
    ...
    // 创建ActivityThread
    ActivityThread thread = new ActivityThread();
    // 执行attach
    thread.attach(false, startSeq);
    ...
    // 启动looper
    Looper.loop();
}

private void attach(boolean system, long startSeq) {
    ...
    if (!system) {
        ...
        // 获取AMS代理
        final IActivityManager mgr = ActivityManager.getService();
        try {
            mgr.attachApplication(mAppThread, startSeq);
        } catch (RemoteException ex) {
            throw ex.rethrowFromSystemServer();
        }
        ...
    } else {...}
}
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

ActivityThread的main方法中，通过构造方法生成了ActivityThread，同时生成了ApplicationThread；然后通过attach方法，与AMS进行通信；最后启动looper等待处理消息。

2、attachApplication

 public final void attachApplication(IApplicationThread thread, long startSeq) {
     synchronized (this) {
         ...
         attachApplicationLocked(thread, callingPid, callingUid, startSeq);
         ...
     }
 }

private final boolean attachApplicationLocked(IApplicationThread thread,
                                              int pid, int callingUid, long startSeq) {
    ...
    // 回调App绑定方法
    thread.bindApplication(processName, appInfo, providers,
            app.instr.mClass,
            profilerInfo, app.instr.mArguments,
            app.instr.mWatcher,
            app.instr.mUiAutomationConnection, testMode,
            mBinderTransactionTrackingEnabled, enableTrackAllocation,
            isRestrictedBackupMode || !normalMode, app.persistent,
            new Configuration(getGlobalConfiguration()), app.compat,
            getCommonServicesLocked(app.isolated),
            mCoreSettingsObserver.getCoreSettingsLocked(),
            buildSerial, isAutofillCompatEnabled);
    ...
    // See if the top visible activity is waiting to run in this process...
    if (normalMode) {
        try {
            if (mStackSupervisor.attachApplicationLocked(app)) {
                didSomething = true;
            }
        } catch (Exception e) {...}
    }
    ...
    return 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

attachApplication会调用attachApplicationLocked；然后通过bindApplication回调到App进程，发送BIND_APPLICATION消息，通过handleBindApplication做一些绑定后的操作：创建mInstrumentation，并回调Application的onCreate()；最后通过mStackSupervisor.attachApplicationLocked(app)进一步处理。

3、attachApplicationLocked

boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {
    final String processName = app.processName;
    boolean didSomething = false;
    for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
        final ActivityDisplay display = mActivityDisplays.valueAt(displayNdx);
        for (int stackNdx = display.getChildCount() - 1; stackNdx >= 0; --stackNdx) {
            final ActivityStack stack = display.getChildAt(stackNdx);
            if (!isFocusedStack(stack)) {
                continue;
            }
            stack.getAllRunningVisibleActivitiesLocked(mTmpActivityList);
            final ActivityRecord top = stack.topRunningActivityLocked();
            final int size = mTmpActivityList.size();
            for (int i = 0; i < size; i++) {
                final ActivityRecord activity = mTmpActivityList.get(i);
                if (activity.app == null && app.uid == activity.info.applicationInfo.uid
                        && processName.equals(activity.processName)) {
                    try {
                        if (realStartActivityLocked(activity, app,
                                top == activity /* andResume */, true /* checkConfig */)) {
                            didSomething = true;
                        }
                    } catch (RemoteException e) {
                        Slog.w(TAG, "Exception in new application when starting activity "
                                + top.intent.getComponent().flattenToShortString(), e);
                        throw e;
                    }
                }
            }
        }
    }
    if (!didSomething) {
        ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
    }
    return didSomething;
}
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

attachApplicationLocked调用realStartActivityLocked

4、realStartActivityLocked

final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
                                      boolean andResume, boolean checkConfig) throws RemoteException {
    ...
    try {
        ...
        try {
            ...
            // 添加启动事务
            clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
                    System.identityHashCode(r), r.info,
                    // TODO: Have this take the merged configuration instead of separate global
                    // and override configs.
                    mergedConfiguration.getGlobalConfiguration(),
                    mergedConfiguration.getOverrideConfiguration(), r.compat,
                    r.launchedFromPackage, task.voiceInteractor, app.repProcState, r.icicle,
                    r.persistentState, results, newIntents, mService.isNextTransitionForward(),
                    profilerInfo));
            // 添加resume或pause事务
            final ActivityLifecycleItem lifecycleItem;
            if (andResume) {
                lifecycleItem = ResumeActivityItem.obtain(mService.isNextTransitionForward());
            } else {
                lifecycleItem = PauseActivityItem.obtain();
            }
            clientTransaction.setLifecycleStateRequest(lifecycleItem);
            // 执行事务
            mService.getLifecycleManager().scheduleTransaction(clientTransaction);
            ...
        } catch (RemoteException e) {...}
    } finally {...}
    ...
    return 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

添加启动Activity和OnResume的事务，并通过AMS的LifecycleManager执行事务。

5、scheduleTransaction

void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
    final IApplicationThread client = transaction.getClient();
    transaction.schedule();
    ...
}

public void schedule() throws RemoteException {
    mClient.scheduleTransaction(this);
}

public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
    ActivityThread.this.scheduleTransaction(transaction);
}

void scheduleTransaction(ClientTransaction transaction) {
    transaction.preExecute(this);
    sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

LifecycleManager是ClientLifecycleManager类型；
transaction是ClientTransaction类型；
mClient是IApplicaItionThread类型；
ActivityThread继承自ClientTransactionHandler。

LifecycleManager.scheduleTransaction()调用ClientTransaction.schedule()，然后调用mClient.scheduleTransaction(this)；mClient会通过Binder将数据发送到App进程，调用ApplicationThread.scheduleTransaction()，然后调用到ActivityThread.scheduleTransaction()；由于ActivityThread继承自ClientTransactionHandler，最终会调用到ClientTransactionHandler.scheduleTransaction()；在这里，发送了类型为EXECUTE_TRANSACTION的消息。

6、EXECUTE_TRANSACTION消息处理

public void handleMessage(Message msg) {
    if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
    switch (msg.what) {
        case EXECUTE_TRANSACTION:
            final ClientTransaction transaction = (ClientTransaction) msg.obj;
            mTransactionExecutor.execute(transaction);
            ...
    }
}

public void execute(ClientTransaction transaction) {
    final IBinder token = transaction.getActivityToken();
    // 先执行callBack
    executeCallbacks(transaction);
    // 再执行LifeCycle
    executeLifecycleState(transaction);
    ...
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

在case分之中，通过TransactionExecutor.execute()对事物进行处理，在execute中，先执行callBack，再执行LifeCycle。

7、LaunchActivityItem.execute()

由上文我们知道，callBack是LaunchActivityItem，lifeCycle是ResumeActivityItem。

public void executeCallbacks(ClientTransaction transaction) {
    final List<ClientTransactionItem> callbacks = transaction.getCallbacks();
    ...
    final int size = callbacks.size();
    for (int i = 0; i < size; ++i) {
        final ClientTransactionItem item = callbacks.get(i);
        ...
        
        item.execute(mTransactionHandler, token, mPendingActions);
        ...
    }
}

public void execute(ClientTransactionHandler client, IBinder token,
        PendingTransactionActions pendingActions) {
    Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
    ActivityClientRecord r = new ActivityClientRecord(token, mIntent, mIdent, mInfo,
            mOverrideConfig, mCompatInfo, mReferrer, mVoiceInteractor, mState, mPersistentState,
            mPendingResults, mPendingNewIntents, mIsForward,
            mProfilerInfo, client);
    client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
    Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

LaunchActivityItem的execute会调用client.handleLaunchActivity进行处理，由上文我们知道ActivityThread继承自ClientTransactionHandler，因此调用到ActivityThread内部。

8、handleLaunchActivity

public Activity handleLaunchActivity(ActivityThread.ActivityClientRecord r,
                                     PendingTransactionActions pendingActions, Intent customIntent) {
    ...
    final Activity a = performLaunchActivity(r, customIntent);
    ...
    return a;
}

private Activity performLaunchActivity(ActivityThread.ActivityClientRecord r, Intent customIntent) {
    ActivityInfo aInfo = r.activityInfo;
    ...
    ComponentName component = r.intent.getComponent();
    ...
    
    // 创建Activity的Context
    ContextImpl appContext = createBaseContextForActivity(r);
    Activity activity = null;
    try {
        // 实例化Activity
        ClassLoader cl = appContext.getClassLoader();
        activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent);
        ...
    } catch (Exception e) {...}
    try {
        ...
        if (activity != null) {
            ...
            if (r.isPersistable()) {
                mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
            } else {
                mInstrumentation.callActivityOnCreate(activity, r.state);
            }
            ...
        }
        ...
    } catch (SuperNotCalledException e) {
        ...
    } catch (Exception e) {...}
    return activity;
}

public void callActivityOnCreate(Activity activity, Bundle icicle) {
    prePerformCreate(activity);
    activity.performCreate(icicle);
    postPerformCreate(activity);
}

final void performCreate(Bundle icicle) {
    performCreate(icicle, null);
}

final void performCreate(Bundle icicle, PersistableBundle persistentState) {
    ...
    if (persistentState != null) {
        onCreate(icicle, persistentState);
    } else {
        onCreate(icicle);
    }
    ...
}
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

通过performLaunchActivity处理Activity的启动，包括创建Context，实例化Activity，并通过mInstrumentation.callActivityOnCreate -> Activity.performCreate -> Activity.onCreate调用到onCreate方法。

9、executeLifecycleState

private void executeLifecycleState(ClientTransaction transaction) {
    // 取到的是ResumeActivityItem
    final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();
    ...
    final IBinder token = transaction.getActivityToken();
    final ActivityClientRecord r = mTransactionHandler.getActivityClient(token);
    ...
    // Cycle to the state right before the final requested state.
    cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */);
    // Execute the final transition with proper parameters.
    lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
    lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
}


private void cycleToPath(ActivityClientRecord r, int finish,
                         boolean excludeLastState) {
    // start 是 ON_CREATE，finish 是 ON_RESUME
    final int start = r.getLifecycleState();
    log("Cycle from: " + start + " to: " + finish + " excludeLastState:" + excludeLastState);
    final IntArray path = mHelper.getLifecyclePath(start, finish, excludeLastState);
    performLifecycleSequence(r, path);
}


public IntArray getLifecyclePath(int start, int finish, boolean excludeLastState) {
    ...
    // 将中间缺少的生命周期补全
    mLifecycleSequence.clear();
    if (finish >= start) {
        // just go there
        for (int i = start + 1; i <= finish; i++) {
            mLifecycleSequence.add(i);
        }
    } else { // finish < start, can't just cycle down
        ...
    }
    // 移除最后一个状态，需要额外处理
    if (excludeLastState && mLifecycleSequence.size() != 0) {
        mLifecycleSequence.remove(mLifecycleSequence.size() - 1);
    }
    return mLifecycleSequence;
}

private void performLifecycleSequence(ActivityClientRecord r, IntArray path) {
        final int size = path.size();
        for (int i = 0, state; i < size; i++) {
            state = path.get(i);
            log("Transitioning to state: " + state);
            switch (state) {
                case ON_CREATE:
                    mTransactionHandler.handleLaunchActivity(r, mPendingActions,
                            null /* customIntent */);
                    break;
                case ON_START:
                    mTransactionHandler.handleStartActivity(r, mPendingActions);
                    break;
                case ON_RESUME:
                    mTransactionHandler.handleResumeActivity(r.token, false /* finalStateRequest */,
                            r.isForward, "LIFECYCLER_RESUME_ACTIVITY");
                    break;
                case ON_PAUSE:
                    mTransactionHandler.handlePauseActivity(r.token, false /* finished */,
                            false /* userLeaving */, 0 /* configChanges */, mPendingActions,
                            "LIFECYCLER_PAUSE_ACTIVITY");
                    break;
                case ON_STOP:
                    mTransactionHandler.handleStopActivity(r.token, false /* show */,
                            0 /* configChanges */, mPendingActions, false /* finalStateRequest */,
                            "LIFECYCLER_STOP_ACTIVITY");
                    break;
                case ON_DESTROY:
                    mTransactionHandler.handleDestroyActivity(r.token, false /* finishing */,
                            0 /* configChanges */, false /* getNonConfigInstance */,
                            "performLifecycleSequence. cycling to:" + path.get(size - 1));
                    break;
                case ON_RESTART:
                    mTransactionHandler.performRestartActivity(r.token, false /* start */);
                    break;
                default:
                    throw new IllegalArgumentException("Unexpected lifecycle state: " + state);
            }
        }
    }
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

执行完毕executeCallbacks后，会执行到executeLifecycleState，该方法会取到ResumeActivityItem，之后通过cycleToPath补全中间的状态，然后执行ResumeActivityItem的execute方法。

由于start 是 ON_CREATE，finish 是 ON_RESUME，所以补齐ON_START状态，然后通过performLifecycleSequence继续执行，在ON_START分支中，通过mTransactionHandler.handleStartActivity()执行onStart方法，我们知道此处的mTransactionHandler就是ActivityThread，之后通过activity.performStart -> mInstrumentation.callActivityOnStart -> activity.onStart 调用到onStart方法。

最后通过ResumeActivityItem.execute -> ActivityThread.handleResumeActivity -> ActivityThread.performResumeActivity -> activity.performResume -> mInstrumentation.callActivityOnResume -> activity.onResume；调用到onResume方。

点击屏幕图标启动Activity

frameworks/base/core/java/android/app/Activity.java
frameworks/base/core/java/android/app/Instrumentation.java

1、startActivity

public void startActivity(Intent intent) {
    this.startActivity(intent, null);
}

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

public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
        @Nullable Bundle options) {
    if (mParent == null) {
        options = transferSpringboardActivityOptions(options);
        Instrumentation.ActivityResult ar =
            mInstrumentation.execStartActivity(
                this, mMainThread.getApplicationThread(), mToken, this,
                intent, requestCode, options);
        ...
    } else {...}
}
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

startActivity会通过重载方法调用到startActivityForResult，然后通过mInstrumentation.execStartActivity进行启动。

2、Instrumentation.execStartActivity

public ActivityResult execStartActivity(
        Context who, IBinder contextThread, IBinder token, android.app.Activity target,
        Intent intent, int requestCode, Bundle options) {
    ...
    try {
        ...
        int result = ActivityManager.getService()
            .startActivity(whoThread, who.getBasePackageName(), intent,
                    intent.resolveTypeIfNeeded(who.getContentResolver()),
                    token, target != null ? target.mEmbeddedID : null,
                    requestCode, 0, null, options);
        checkStartActivityResult(result, intent);
    } catch (RemoteException e) {...}
    return null;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

通过binder调用AMS的startActivity。

3、AMS.startActivity

public final int startActivity(IApplicationThread caller, String callingPackage,
        Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
        int startFlags, ProfilerInfo profilerInfo, Bundle bOptions) {
    return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
            resultWho, requestCode, startFlags, profilerInfo, bOptions,
            UserHandle.getCallingUserId());
}

public final int startActivityAsUser(IApplicationThread caller, String callingPackage,
        Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
        int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId) {
    return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
            resultWho, requestCode, startFlags, profilerInfo, bOptions, userId,
            true /*validateIncomingUser*/);
}

public final int startActivityAsUser(IApplicationThread caller, String callingPackage,
        Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
        int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId,
        boolean validateIncomingUser) {
    enforceNotIsolatedCaller("startActivity");
    userId = mActivityStartController.checkTargetUser(userId, validateIncomingUser,
            Binder.getCallingPid(), Binder.getCallingUid(), "startActivityAsUser");
    // TODO: Switch to user app stacks here.
    return mActivityStartController.obtainStarter(intent, "startActivityAsUser")
            .setCaller(caller)
            .setCallingPackage(callingPackage)
            .setResolvedType(resolvedType)
            .setResultTo(resultTo)
            .setResultWho(resultWho)
            .setRequestCode(requestCode)
            .setStartFlags(startFlags)
            .setProfilerInfo(profilerInfo)
            .setActivityOptions(bOptions)
            .setMayWait(userId)
            .execute();
}
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

startActivity通过startActivityAsUser的重载方法，调用到mActivityStartController.obtainStarter().execute()。

4、mActivityStartController.obtainStarter().execute()

ActivityStarter obtainStarter(Intent intent, String reason) {
    return mFactory.obtain().setIntent(intent).setReason(reason);
}

int execute() {
    try {
        if (mRequest.mayWait) {
            return startActivityMayWait(mRequest.caller, mRequest.callingUid,
                    mRequest.callingPackage, mRequest.intent, mRequest.resolvedType,
                    mRequest.voiceSession, mRequest.voiceInteractor, mRequest.resultTo,
                    mRequest.resultWho, mRequest.requestCode, mRequest.startFlags,
                    mRequest.profilerInfo, mRequest.waitResult, mRequest.globalConfig,
                    mRequest.activityOptions, mRequest.ignoreTargetSecurity, mRequest.userId,
                    mRequest.inTask, mRequest.reason,
                    mRequest.allowPendingRemoteAnimationRegistryLookup);
        } else {
            ...
        }
    } finally {...}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

mActivityStartController.obtainStarter()会得到ActivityStarter对象，然后执行execute方法，调用startActivityMayWait。

5、startActivityMayWait

private int startActivityMayWait(IApplicationThread caller, int callingUid,
        String callingPackage, Intent intent, String resolvedType,
        IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
        IBinder resultTo, String resultWho, int requestCode, int startFlags,
        ProfilerInfo profilerInfo, WaitResult outResult,
        Configuration globalConfig, SafeActivityOptions options, boolean ignoreTargetSecurity,
        int userId, TaskRecord inTask, String reason,
        boolean allowPendingRemoteAnimationRegistryLookup) {
    ...
    ResolveInfo rInfo = mSupervisor.resolveIntent(intent, resolvedType, userId,
            0 /* matchFlags */,
                    computeResolveFilterUid(
                            callingUid, realCallingUid, mRequest.filterCallingUid));
    ...
    ActivityInfo aInfo = mSupervisor.resolveActivity(intent, rInfo, startFlags, profilerInfo);
    synchronized (mService) {
        ...
        int res = startActivity(caller, intent, ephemeralIntent, resolvedType, aInfo, rInfo,
                voiceSession, voiceInteractor, resultTo, resultWho, requestCode, callingPid,
                callingUid, callingPackage, realCallingPid, realCallingUid, startFlags, options,
                ignoreTargetSecurity, componentSpecified, outRecord, inTask, reason,
                allowPendingRemoteAnimationRegistryLookup);
        ...
        return res;
    }
}
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

startActivityMayWait中通过resolveIntent获取到ResolveInfo；然后通过startActivity进行操作。

6、resolveIntent

ResolveInfo resolveIntent(Intent intent, String resolvedType, int userId, int flags,
        int filterCallingUid) {
    synchronized (mService) {
        try {
            ...
            try {
                return mService.getPackageManagerInternalLocked().resolveIntent(
                        intent, resolvedType, modifiedFlags, userId, true, filterCallingUid);
            } finally {...}
        } finally {...}
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

在resolveIntent中，通过PMS进行数据解析。

7、getPackageManagerInternalLocked

PackageManagerInternal getPackageManagerInternalLocked() {
    if (mPackageManagerInt == null) {
        mPackageManagerInt = LocalServices.getService(PackageManagerInternal.class);
    }
    return mPackageManagerInt;
}

public class PackageManagerService extends IPackageManager.Stub implements PackageSender {
    ...
    public PackageManagerService(Context context, Installer installer,boolean factoryTest, boolean onlyCore) {
        ...
        // 注册本地服务
        LocalServices.addService(PackageManagerInternal.class, new PackageManagerInternalImpl());
        ...
    }

    // 内部类，持有PMS
    private class PackageManagerInternalImpl extends PackageManagerInternal {
        ...
        public ResolveInfo resolveIntent(Intent intent, String resolvedType,
                int flags, int userId, boolean resolveForStart, int filterCallingUid) {
            return resolveIntentInternal(
                    intent, resolvedType, flags, userId, resolveForStart, filterCallingUid);
        }
        ...
    }
}
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

在PMS构造方法中，注册了PackageManagerInternal.class，真正的实现类是PackageManagerInternalImpl，这样AMS便可以通过它与PMS进行交互。

8、PMS.getActivityInfoInternal

通过如下调用链
resolveIntentInternal->queryIntentActivitiesInternal->getActivityInfo->getActivityInfoInternal调用到getActivityInfoInternal。

private ActivityInfo getActivityInfoInternal(ComponentName component, int flags,
        int filterCallingUid, int userId) {
    ...
    synchronized (mPackages) {
        PackageParser.Activity a = mActivities.mActivities.get(component);
        if (DEBUG_PACKAGE_INFO) Log.v(TAG, "getActivityInfo " + component + ": " + a);
        if (a != null && mSettings.isEnabledAndMatchLPr(a.info, flags, userId)) {
            ...
            return PackageParser.generateActivityInfo(
                    a, flags, ps.readUserState(userId), userId);
        }
        if (mResolveComponentName.equals(component)) {
            return PackageParser.generateActivityInfo(
                    mResolveActivity, flags, new PackageUserState(), userId);
        }
    }
    return null;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

在这里通过PMS中缓存的Activity信息查找对应的Activity。在找到Activity后，通过startActivity启动Activity，逻辑与上文内容相似，不再赘述。

需要注意的是，由于有Launcher程序，因此在执行resumeTopActivityInnerLocked时，会通过startPausingLocked执行上一个页面（Launcher）的onPause逻辑。