android P 关于Activity启动（上）启动之前的准备

简介

一直以来看过的源码不少，但是没几天就忘了，时间长了就和没看差不多，所以就自己记录下，没事的时候翻翻
本文涉及到的文件

frameworks/base/core/java/android/app/Activity.java
frameworks/base/core/java/android/app/Instrumentation.java
frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
frameworks/base/services/core/java/com/android/server/am/ActivityStartController.java
frameworks/base/services/core/java/com/android/server/am/ActivityStarter.java
frameworks/base/services/core/java/com/android/server/am/ActivityRecord.java
frameworks/base/services/core/java/com/android/server/am/ActivityStackSupervisor.java
frameworks/base/services/core/java/com/android/server/am/ActivityStack.java
frameworks/base/services/core/java/com/android/server/am/TaskRecord.java
frameworks/base/services/core/java/com/android/server/am/LaunchParamsController.java
frameworks/base/services/core/java/com/android/server/am/ActivityStartInterceptor.java

Activity启动实在太复杂，涉及的地方实在太多，比如windows的调度，各栈的进出，焦点的交替等等，随便一个就够研究好久的，本文只看一些流程，细节部分以后再慢慢看，本文的目录就是activity调度的流程，前面是类名，后面是方法。

一 Activity启动的两种情况

本文说的Activity的启动并不是Activity的四种启动模式而是我们在调用startActivity之后framework层是如何处理的，根据framework的处理大致可以分为两种情况：

被启动的Activity此时所在的进程还没有运行起来

这种情况就需要系统先去启动Activity所在的进程再去启动Activity，比较常见的场景是我们安装了一个应用，然后在Launcher界面点击图标去启动它

被启动的Activity此时所在的进程已经在运行

对于这种情况就没有那么复杂了，系统可以直接走启动流程即可，不用考虑进程是否启动的问题了

下面我们就来看看在我们调用startActivity之后系统时如何处理的，为了防止文章出现大篇幅粘贴代码的现象，后面上代码时会有一些缩减

二 Activity#startActivity

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

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

如上面代码所示，在我们日常开发中，我们启动Activity都是使用startActivity的方式去启动，而startActivity方法由于java多态的特性有很多不同参数的方法，这中间的调用没有什么营养，不管中间怎么调用，最终都会走到startActivityForResult这个方法，我们直接看这个方法

Activity#startActivityForResult

 public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
            @Nullable Bundle options) {
        if (mParent == null) {
            options = transferSpringboardActivityOptions(options);
            Instrumentation.ActivityResult ar =
                mInstrumentation.execStartActivity(
                    this, mMainThread.getApplicationThread(), mToken, this,
                    intent, requestCode, options);
            if (ar != null) {
                mMainThread.sendActivityResult(
                    mToken, mEmbeddedID, requestCode, ar.getResultCode(),
                    ar.getResultData());
            }
            if (requestCode >= 0) {
                mStartedActivity = true;
            }
            cancelInputsAndStartExitTransition(options);
        } else {
            if (options != null) {
                mParent.startActivityFromChild(this, intent, requestCode, options);
            } else {
                mParent.startActivityFromChild(this, intent, requestCode);
            }
        }
    }

对于上面代码我们可以看到一个关键的判断条件mParent 的值，关于这个值在源码里解释如下

    /** Is this activity embedded inside of another activity? */
    public final boolean isChild() {
        return mParent != null;
    }
    /** Return the parent activity if this view is an embedded child. */
    public final Activity getParent() {
        return mParent;
    }

通过英文解释我们可知是用于ActivityGroup嵌套时使用的，现在应该已经弃用了，所以一般情况下mParent值是null，所以我们直接进入if判断条件，这边有个关键调用

Instrumentation.execStartActivity(
                    this, mMainThread.getApplicationThread(), mToken, this,
                    intent, requestCode, options)

我们先看下execStartActivity方法的原型

public ActivityResult execStartActivity(
            Context who, IBinder contextThread, IBinder token, Activity target,
            Intent intent, int requestCode, Bundle options) 

我们可以看下参数的对应
Context who -------- this 代表Activity的启动方
IBinder contextThread -------- mMainThread.getApplicationThread()
其中我们要启动Activity的信息存放在第五个参数intent之中

Instrumentation#execStartActivity

进入if之后会调用Instrumentation类的execStartActivity方法，Instrumentation具有强大的跟踪application及activity生命周期的功能，关于Instrumentation类可参考Instrumentation

public ActivityResult execStartActivity(
            Context who, IBinder contextThread, IBinder token, Activity target,
            Intent intent, int requestCode, Bundle options) {
            ......//省略一些无关紧要的代码
            try {
            intent.migrateExtraStreamToClipData();
            intent.prepareToLeaveProcess(who);
            int result = ActivityManager.getService()
                .startActivity(whoThread, who.getBasePackageName(), intent,
                        intent.resolveTypeIfNeeded(who.getContentResolver()),
                        token, target != null ? target.mEmbeddedID : null,
                        requestCode, 0, null, options);
            checkStartActivityResult(result, intent);
        } catch (RemoteException e) {
            throw new RuntimeException("Failure from system", e);
        }
        return null;
    }

这段通过ActivityManager.getService()方式获得ActivityManagerService的服务，我们看下代码

    public static IActivityManager getService() {
        return IActivityManagerSingleton.get();
    }

    private static final Singleton<IActivityManager> IActivityManagerSingleton =
            new Singleton<IActivityManager>() {
                @Override
                protected IActivityManager create() {
                    final IBinder b = ServiceManager.getService(Context.ACTIVITY_SERVICE);
                    final IActivityManager am = IActivityManager.Stub.asInterface(b);
                    return am;
                }
            };

这是系统中比较常见的跨进程通信，主要是通过ServiceManager和相关字段(Context.ACTIVITY_SERVICE)来获取相应的系统服务，下面看下系统是什么时候将ActivityManagerService添加到ServiceManager中的呢，这就要看下SystemServer的启动流程了，这里只看下AMS的添加流程，SystemServer启动的时候在SystemServer#startBootstrapServices()方法中调用mActivityManagerService.setSystemProcess()，此时代码会进入AMS的相关代码，然后再setSystemProcess方法中通过下面方式将AMS添加到SystemServer中

ServiceManager.addService(Context.ACTIVITY_SERVICE, this, /* allowIsolated= */ true,
                    DUMP_FLAG_PRIORITY_CRITICAL | DUMP_FLAG_PRIORITY_NORMAL | DUMP_FLAG_PROTO);

下面我们就看下ActivityManagerService是如何处理的

ActivityManagerService#startActivity

先来看下ActivityManagerService的startActivity方法

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

这里面经过几次startActivityAsUser不同参数的调用最终会走到参数最多的那个，关于这点习惯就好，我们来看下最终的startActivityAsUser方法

ActivityManagerService#startActivityAsUser

 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();
    }

在这个方法里面主要是通过mActivityStartController来执行相关操作的，通过obtainStarter的方法来启动activity，下面我们先看下这个方法

ActivityStartController#obtainStarter

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

只有简单的一行代码，看到这我们就需要来看下mFactory的实现了
先看下Factory的相关定义，这个Factory是个定义在ActivityStarter中的接口，默认实现是DefaultFactory，可以看下相关代码

ActivityStarter#Factory

    interface Factory {
        void setController(ActivityStartController controller);
        ActivityStarter obtain();
        void recycle(ActivityStarter starter);
    }
static class DefaultFactory implements Factory {
        private final int MAX_STARTER_COUNT = 3;
        private ActivityStartController mController;
        private ActivityManagerService mService;
        private ActivityStackSupervisor mSupervisor;
        private ActivityStartInterceptor mInterceptor;
        private SynchronizedPool<ActivityStarter> mStarterPool =
                new SynchronizedPool<>(MAX_STARTER_COUNT);
        DefaultFactory(ActivityManagerService service,
                ActivityStackSupervisor supervisor, ActivityStartInterceptor interceptor) {
            mService = service;
            mSupervisor = supervisor;
            mInterceptor = interceptor;
        }
        @Override
        public void setController(ActivityStartController controller) {
            mController = controller;
        }
        @Override
        public ActivityStarter obtain() {
            ActivityStarter starter = mStarterPool.acquire();
           if (starter == null) {
                starter = new ActivityStarter(mController, mService, mSupervisor, mInterceptor);
            }
            return starter;
        }
        @Override
        public void recycle(ActivityStarter starter) {
            starter.reset(true /* clearRequest*/);
            mStarterPool.release(starter);
        }
    }

了解了Factory相关定义之后可以顺便看下他的实现，不过它的实现和mActivityStartController初始化有关，可以简单看下流程ActivityManagerService.java文件

private final ActivityStartController mActivityStartController;
public ActivityManagerService(Context systemContext) {
.........
mActivityStartController = new ActivityStartController(this);
.........
}

在AMS中直接new了ActivityStartController的对象，我们来看下ActivityStartController一个参数的构造方法
ActivityStartController.java文件中

    ActivityStartController(ActivityManagerService service) {
        this(service, service.mStackSupervisor,
                new DefaultFactory(service, service.mStackSupervisor,
                    new ActivityStartInterceptor(service, service.mStackSupervisor)));
    }
    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);
    }

在构造方法中分别有三个参数

ActivityManagerService service, 
ActivityStackSupervisor supervisor,
Factory factory

在这我们可以看到主要是给ActivityStartController中的mSupervisor，mService 赋值，同时实现Factory
现在我们知道了mFactory的实现之后就可以继续看下面的代码了

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

根据DefaultFactory的实现我们可知mFactory.obtain()返回的是ActivityStarter的实例，那么结合之前ActivityManagerService#startActivityAsUser中的代码我们可以知道在设置了一些列参数之后会进入ActivityStarter的execute()方法，其中设置参数的部分会被系统封装成Request的形式

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();

    ActivityStarter setMayWait(int userId) {
        mRequest.mayWait = true;
        mRequest.userId = userId;

        return this;
    }

通过上面代码我们可以了解到mRequest.mayWait的值为true，这在下面我们会用到

ActivityStarter#execute

 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,
                        mRequest.originatingPendingIntent);
            } 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,
                        mRequest.originatingPendingIntent);
            }
        } finally {
            onExecutionComplete();
        }
    }

上面我们知道mRequest.mayWait的值为true,所以就会进入startActivityMayWait这个函数里面

ActivityStarter#startActivityMayWait

关于startActivityMayWait的代码是很长的，我们只看关键流程，其他的一些细枝末节暂且忽略

 private int startActivityMayWait(IApplicationThread caller, int callingUid,
            String callingPackage, int requestRealCallingPid, int requestRealCallingUid,
            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);
    ............//省略部分代码
    final ActivityRecord[] outRecord = new ActivityRecord[1];
            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);
    ............//省略部分代码
}

在这里系统通过mSupervisor去做了很多事情，其中mSupervisor是ActivityStackSupervisor类型，通过名字我们就知道它负责管理Activity的栈和Activity的生命周期息息相关,先看下mSupervisor.resolveIntent的调用，这里主要是根据initent通过pms去匹配符合initent条件的Activity，关于这个我们应该也经常遇到，我们通过隐式intent去启动时是有可能有多个符合条件的Activity，当然这里面涉及启动优先级，默认应用等等，之后通过mSupervisor.resolveActivity去获取符合条件的相关Activity信息，在之后就会接着调用startActivity去启动Activity
当然后面还省略了一部分关于Result的代码，可自行查看

ActivityStarter#startActivity

这个startActivity也会经过不同参数的调用最终调道参数最多的那个startActivity，中间的部分先不看，直接看最终的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, boolean allowPendingRemoteAnimationRegistryLookup) {
            
		.......//这部是对一些FLAG的检测

		boolean abort = !mSupervisor.checkStartAnyActivityPermission(intent, aInfo, resultWho,
                requestCode, callingPid, callingUid, callingPackage, ignoreTargetSecurity,
                inTask != null, callerApp, resultRecord, resultStack);
        if (abort) Slog.i(TAG,"->startActivity for " + intent
                + " checkStartAnyActivityPermission result:false");
        boolean firewallCheck = !mService.mIntentFirewall.checkStartActivity(intent, callingUid,
                callingPid, resolvedType, aInfo.applicationInfo);
        if (firewallCheck) Slog.i(TAG,"->startActivity for " + intent
                + " mIntentFirewall.checkStartActivity result:false");
        abort |= firewallCheck;
        
		.......
		 mInterceptor.setStates(userId, realCallingPid, realCallingUid, startFlags, callingPackage);//这边设置了Activity的拦截部分
		.......//这部分主要是对一些特殊状态做了处理，比如休眠
			
		 ActivityRecord r = new ActivityRecord(mService, callerApp, callingPid, callingUid,
                callingPackage, intent, resolvedType, aInfo, mService.getGlobalConfiguration(),
                resultRecord, resultWho, requestCode, componentSpecified, voiceSession != null,
                mSupervisor, checkedOptions, sourceRecord);
                
		.......//这部分主要是分析要启动的activity是否需要进行apk之间的切换，根据情况做出处理
		
		 return startActivity(r, sourceRecord, voiceSession, voiceInteractor, startFlags,
                true /* doResume */, checkedOptions, inTask, outActivity);
}

这部分代码比较多，就只看跟我们相关的部门，省略的部分我根据自己的理解也做了一些说明，有错误的地方也欢迎指正，大概看下这部分逻辑首先通过checkStartAnyActivityPermission和checkStartActivity对要启动的Activity做权限检测和intent的检测，然后通过mInterceptor.setStates对Activity活动拦截类做了初始化，然后通过new ActivityRecord将Activity的相关信息全部保存在ActivityRecord，我们都知道一个ActivityRecord就相当于一个Activity,最后又启动一个startActivity函数来继续下面的流程，我来看下这个新的函数做了哪些处理

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);
        } catch (Exception e) {
            Slog.w(TAG, "startActivityUnchecked occurred error:", e);
            throw e;
        } finally {
            try {
            Slog.i(TAG, "->startActivity for " + r + " result:" +
                    startActivityResultCodeToString(result));
            final ActivityStack stack = mStartActivity.getStack();
            if (!ActivityManager.isStartResultSuccessful(result) && stack != null) {
                stack.finishActivityLocked(mStartActivity, RESULT_CANCELED,
                        null /* intentResultData */, "startActivity", true /* oomAdj */);
            }
            } finally {
            mService.mWindowManager.continueSurfaceLayout();
            }
        }
        postStartActivityProcessing(r, result, mTargetStack);
        return result;
    }

这里会走到startActivityUnchecked这个方法，至于finally里面的则是如果启动失败就会在task里面remove这个activity，下面就看startActivityUnchecked方法

ActivityStarter#startActivityUnchecked

private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
            IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
            int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
            ActivityRecord[] outActivity) {
        setInitialState(r, options, inTask, doResume, startFlags, sourceRecord, voiceSession,
                voiceInteractor);//初始化状态
        computeLaunchingTaskFlags();//计算launchFlags
        computeSourceStack();//计算sourceStack
        mIntent.setFlags(mLaunchFlags);
        ActivityRecord reusedActivity = getReusableIntentActivity();//查看是有可以复用的activity，和其启动模式有关
        ......//这边省略了一部分launch参数的设置
        if (reusedActivity != null) {
           ......这里面是根据activity启动模式，在有activity可复用的情况下进行不同的处理
        }
        if (mStartActivity.packageName == null) {
            final ActivityStack sourceStack = mStartActivity.resultTo != null
                    ? mStartActivity.resultTo.getStack() : null;
            if (sourceStack != null) {
                sourceStack.sendActivityResultLocked(-1 /* callingUid */, mStartActivity.resultTo,
                        mStartActivity.resultWho, mStartActivity.requestCode, RESULT_CANCELED,
                        null /* data */);
            }
            ActivityOptions.abort(mOptions);
            return START_CLASS_NOT_FOUND;
        }
//
        final ActivityStack topStack = mSupervisor.mFocusedStack;
        final ActivityRecord topFocused = topStack.getTopActivity();
        final ActivityRecord top = topStack.topRunningNonDelayedActivityLocked(mNotTop);
        final boolean dontStart = top != null && mStartActivity.resultTo == null
                && top.realActivity.equals(mStartActivity.realActivity)
                && top.userId == mStartActivity.userId
                && top.app != null && top.app.thread != null
                && ((mLaunchFlags & FLAG_ACTIVITY_SINGLE_TOP) != 0
                || isLaunchModeOneOf(LAUNCH_SINGLE_TOP, LAUNCH_SINGLE_TASK));
        if (dontStart) {
		......根据dontStart来判断要启动的activity与当前task顶部的activity是否相同，如果相同则执行相关onNewIntent逻辑
            return START_DELIVERED_TO_TOP;
        }
		............这部分省略主要是判断是否需要newTask,一些状态的初始化，权限的检测等
        if (mDoResume) {//这个在前面分析的时候传入的是true
            final ActivityRecord topTaskActivity =
                    mStartActivity.getTask().topRunningActivityLocked();
             //这个if判断的时候此activity是没有焦点的，没有焦点的activity是不能resume，此activity会进入下面if的逻辑，虽然没有焦点但是会显示出来，比如pip
            if (!mTargetStack.isFocusable()
                    || (topTaskActivity != null && topTaskActivity.mTaskOverlay
                    && mStartActivity != topTaskActivity)) {               
                    mTargetStack.ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
               		mService.mWindowManager.executeAppTransition();
            } else {
            //这边检查启动的activity是否有焦点，再检查目标栈是否有焦点，如果没有，则需要移到顶部
                if (mTargetStack.isFocusable() && !mSupervisor.isFocusedStack(mTargetStack)) {
                    mTargetStack.moveToFront("startActivityUnchecked");
                }
			//此处就是我们启动的关键
           mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack, mStartActivity,
                        mOptions);
            }
        } else if (mStartActivity != null) {
            mSupervisor.mRecentTasks.add(mStartActivity.getTask());
        }
        mSupervisor.updateUserStackLocked(mStartActivity.userId, mTargetStack);
        mSupervisor.handleNonResizableTaskIfNeeded(mStartActivity.getTask(), preferredWindowingMode,
                preferredLaunchDisplayId, mTargetStack);
        return START_SUCCESS;
    }

根据上面注释和代码理解我们可知这个函数对启动的参数做了初始化，并且起算出launchFlag和sourceStack,并且针对启动activty不同的情况做出了对应得处理，比如是否存在可复用得activity，这需要结合启动模式去做对应得处理，再比如要启动得activity在对应得栈顶已经存在，activity是否具有焦点等情况都做了处理，这里对我们来说主要看mSupervisor.resumeFocusedStackTopActivityLocked这个方法，这是我们启动得关键，这里又跳转到ActivityStackSupervisor里面

ActivityStackSupervisor#resumeFocusedStackTopActivityLocked

    boolean resumeFocusedStackTopActivityLocked() {
        return resumeFocusedStackTopActivityLocked(null, null, null);
    }
    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)) {
            if (mStoppingActivities.contains(r)) {
                mStoppingActivities.remove(r);
                Slog.i(TAG, "request to resume " + r + ", but it already resumed, " +
                            "remove it from mStoppingActivities.");
            }            mFocusedStack.executeAppTransition(targetOptions);
        }
        return false;
    }

这里面我们主要看resumeTopActivityUncheckedLocked()方法，这方法执行的条件是只有当目标不为空且具有焦点或者即将具有焦点时才会调用，我们这里是启动activity，符合条件

ActivityStack#resumeTopActivityUncheckedLocked

    boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
        if (mStackSupervisor.inResumeTopActivity) {
            return false;
        }
        boolean result = false;
        try {
            mStackSupervisor.inResumeTopActivity = true;
            result = resumeTopActivityInnerLocked(prev, options);
            final ActivityRecord next = topRunningActivityLocked(true /* focusableOnly */);
            if (next == null || !next.canTurnScreenOn()) {
                checkReadyForSleep();
            }
        } finally {
            mStackSupervisor.inResumeTopActivity = false;
        }
        return result;
    }

这里面我们主要看resumeTopActivityInnerLocked这个方法

ActivityStack#resumeTopActivityInnerLocked

这个方法特别特别长，对将要启动的activity做了各种场景的处理，还有之前提到的目标app是否启动，如未启动则会涉及进程的创建过程等，关于这部分由于篇幅太长下一篇文章再写，后面会针对启动过程中任务栈的调度，窗口的调度等都会做下详细分析