Android(安卓)Activity底层启动过程分析

借鉴自gityuan大神：http://gityuan.com/2016/03/12/start-activity/

看了这个图，有个小疑惑，Locked是啥意思，希望在阅读的时候能够得到解决。

还有希望可以记录下每个方法都做了什么。

Activity.startActivity

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

@Overridepublic void startActivity(Intent intent, @Nullable Bundle options) {    if (options != null) {        startActivityForResult(intent, -1, options);    } else {        startActivityForResult(intent, -1);    }}

Activity.startActivityForResult

public void startActivityForResult(@RequiresPermission Intent intent, int requestCode) {    startActivityForResult(intent, requestCode, null);}

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

//2:ApplicationThread,是ActivityThread的子类,3:数据类型为IBinder        if (ar != null) {            mMainThread.sendActivityResult(                mToken, mEmbeddedID, requestCode, ar.getResultCode(),                ar.getResultData());        }

        //此时requestCode=-1,为啥？难道要进行一个延迟启动吗        if (requestCode >= 0) {            mStartedActivity = true;        }        cancelInputsAndStartExitTransition(options);    } else {        ...    }}

Instrumentation.execStartActivity

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; ifinal ActivityMonitor am = mActivityMonitors.get(i);                ActivityResult result = null;                if (am.ignoreMatchingSpecificIntents()) {                    result = am.onStartActivity(intent);                }                if (result != null) {                    am.mHits++;                    return result;                } else if (am.match(who, null, intent)) {                    am.mHits++;

                    //如果Monitor（监视者）阻塞Activity启动，直接返回                    if (am.isBlocking()) {                        return requestCode >= 0 ? am.getResult() : null;                    }                    break;                }            }        }    }    try {        intent.migrateExtraStreamToClipData();        intent.prepareToLeaveProcess(who);

        //检查Activity是否启动成功,ActivityManager.getService()和之前的代码有所出入，不过应该依然是Activity.getDefault()，即ActivityManagerProxy对象
        int result = ActivityManager.getService()

            .startActivity(whoThread, who.getBasePackageName(), intent,                    intent.resolveTypeIfNeeded(who.getContentResolver()),                    token, target != null ? target.mEmbeddedID : null,                    requestCode, 0, null, options);

        //1:当前应用的ApplicationThread对象

          2:当前Activity所在包的包名

          7:requestCode=-1

        checkStartActivityResult(result, intent);    } catch (RemoteException e) {        throw new RuntimeException("Failure from system", e);    }    return null;}

ActivityManagerProxy.startActivity

class ActivityManagerProxy implements IActivityManager {    ...    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;    }    ...}

AMP通过binder，进入AMN，程序进入system_server进程

AMN.onTransact

public boolean onTransact(int code, Parcel data, Parcel reply, int flags) throws RemoteException {    switch (code) {        case START_ACTIVITY_TRANSACTION:        {            data.enforceInterface(IActivityManager.descriptor);            IBinder b = data.readStrongBinder();            IApplicationThread app = ApplicationThreadNative.asInterface(b);            String callingPackage = data.readString();            Intent intent = Intent.CREATOR.createFromParcel(data);            String resolvedType = data.readString();            IBinder resultTo = data.readStrongBinder();            String resultWho = data.readString();            int requestCode = data.readInt();            int startFlags = data.readInt();            ProfilerInfo profilerInfo = data.readInt() != 0                    ? ProfilerInfo.CREATOR.createFromParcel(data) : null;            Bundle options = data.readInt() != 0                    ? Bundle.CREATOR.createFromParcel(data) : null;                     int result = startActivity(app, callingPackage, intent, resolvedType,                    resultTo, resultWho, requestCode, startFlags, profilerInfo, options);            reply.writeNoException();            reply.writeInt(result);            return true;        }...    }    }

AMS.startActivity

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

@Overridepublic final int startActivityAsUser(IApplicationThread caller, String callingPackage,        Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,        int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId) {    enforceNotIsolatedCaller("startActivity");    userId = mUserController.handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(),            userId, false, ALLOW_FULL_ONLY, "startActivity", null);    // TODO: Switch to user app stacks here.    return mActivityStarter.startActivityMayWait(caller, -1, callingPackage, intent,            resolvedType, null, null, resultTo, resultWho, requestCode, startFlags,            profilerInfo, null, null, bOptions, false, userId, null, null,            "startActivityAsUser");

    //ActivityStarter,应该是功能从之前的ActivityStackSupervisior拆分出来了}

ActivityStarter

final int startActivityMayWait(IApplicationThread caller, int callingUid,        String callingPackage, Intent intent, String resolvedType,        IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,        IBinder resultTo, String resultWho, int requestCode, int startFlags,        ProfilerInfo profilerInfo, WaitResult outResult,        Configuration globalConfig, Bundle bOptions, boolean ignoreTargetSecurity, int userId,        IActivityContainer iContainer, TaskRecord inTask, String reason) {

    //1:ApplicationThreadProxy，用于跟调用者进程ApplicationThread进行通信的Binder代理类

    //2:callingUid =-1

    //3:Activity所在包的包名

    //5:intent.resolveTypeIfNeeded

    //6:voiceSession = null

    //7:voiceInteractor = null;

    //8:resultTo = Activity.mToken，Activity是调用者，mToken是用来保存自己所处的ActivityRecord信息    //9:resultWho = Activity.mEmbeddedID，Activity是调用者

    //10:resultCode=-1

    //11:startFlags = 0;    //12:profilerInfo = null;    //13:outResult = null;
    //14:config = null;
    //15:options = null;
    //16:ignoreTargetSecurity = false;
    //18:iContainer = null;
    //19:inTask = null;

    ...    boolean componentSpecified = intent.getComponent() != null;    // Save a copy in case ephemeral needs it    final Intent ephemeralIntent = new Intent(intent);    //创建新的Intent对象，即便intent被修改也不受影响    intent = new Intent(intent);    ...

    //收集intent指向的Activity的信息，如果存在多个Activity，则直接弹出resolveActivity    ActivityInfo aInfo = mSupervisor.resolveActivity(intent, rInfo, startFlags, profilerInfo);    ActivityOptions options = ActivityOptions.fromBundle(bOptions);    ActivityStackSupervisor.ActivityContainer container =            (ActivityStackSupervisor.ActivityContainer)iContainer;    synchronized (mService) {        if (container != null && container.mParentActivity != null &&                container.mParentActivity.state != RESUMED) {            //不会进入这里，因为container == null            return ActivityManager.START_CANCELED;        }        final int realCallingPid = Binder.getCallingPid();        final int realCallingUid = Binder.getCallingUid();        int callingPid;        if (callingUid >= 0) {            callingPid = -1;        } else if (caller == null) {            callingPid = realCallingPid;            callingUid = realCallingUid;        } else {            callingPid = callingUid = -1;        }        final ActivityStack stack;        if (container == null || container.mStack.isOnHomeDisplay()) {

            //container == null 进入这个分支            stack = mSupervisor.mFocusedStack;        } else {            stack = container.mStack;        }

        //stack.mConfigWillChange = false        stack.mConfigWillChange = globalConfig != null                && mService.getGlobalConfiguration().diff(globalConfig) != 0;        if (DEBUG_CONFIGURATION) Slog.v(TAG_CONFIGURATION,                "Starting activity when config will change = " + stack.mConfigWillChange);        final long origId = Binder.clearCallingIdentity();        if (aInfo != null &&                (aInfo.applicationInfo.privateFlags                        & ApplicationInfo.PRIVATE_FLAG_CANT_SAVE_STATE) != 0) {            // heavy-weight 处理这个流程，一般情况不进入这个分支            if (aInfo.processName.equals(aInfo.applicationInfo.packageName)) {                ...            }        }        final ActivityRecord[] outRecord = new ActivityRecord[1];        int res = startActivityLocked(caller, intent, ephemeralIntent, resolvedType,                aInfo, rInfo, voiceSession, voiceInteractor,                resultTo, resultWho, requestCode, callingPid,                callingUid, callingPackage, realCallingPid, realCallingUid, startFlags,                options, ignoreTargetSecurity, componentSpecified, outRecord, container,                inTask, reason);        Binder.restoreCallingIdentity(origId);        if (stack.mConfigWillChange) {            //不进入该分支        }        if (outResult != null) {            //不进入该分支

        }        mSupervisor.mActivityMetricsLogger.notifyActivityLaunched(res, outRecord[0]);        return res;    }}

主要就是通过resolveActivity来获取ActivityInfo信息

ASS.resolveActivity

ActivityInfo resolveActivity(Intent intent, ResolveInfo rInfo, int startFlags,        ProfilerInfo profilerInfo) {    final ActivityInfo aInfo = rInfo != null ? rInfo.activityInfo : null;    if (aInfo != null) {        ...//对于非system进程，根据flags来设置相应的信息    }    return aInfo;}

ActivityManager类有如下4个flags用于调试：
START_FLAG_DEBUG：用于调试debug app
START_FLAG_OPENGL_TRACES：用于调试OpenGL tracing
START_FLAG_NATIVE_DEBUGGING：用于调试native
START_FLAG_TRACK_ALLOCATION: 用于调试allocation tracking

最后会调用到PMS.resolveIntent

@Overridepublic ResolveInfo resolveIntent(Intent intent, String resolvedType,        int flags, int userId) {    return resolveIntentInternal(            intent, resolvedType, flags, userId, false /*includeInstantApps*/);}

private ResolveInfo resolveIntentInternal(Intent intent, String resolvedType,        int flags, int userId, boolean resolveForStart) {    try {        Trace.traceBegin(TRACE_TAG_PACKAGE_MANAGER, "resolveIntent");        if (!sUserManager.exists(userId)) return null;        final int callingUid = Binder.getCallingUid();        flags = updateFlagsForResolve(flags, userId, intent, callingUid, resolveForStart);        enforceCrossUserPermission(callingUid, userId,                false /*requireFullPermission*/, false /*checkShell*/, "resolve intent");        Trace.traceBegin(TRACE_TAG_PACKAGE_MANAGER, "queryIntentActivities");        final List query = queryIntentActivitiesInternal(intent, resolvedType,                flags, callingUid, userId, resolveForStart);        Trace.traceEnd(TRACE_TAG_PACKAGE_MANAGER);

        //根据priority，preferred选择最佳的Activity        final ResolveInfo bestChoice =                chooseBestActivity(intent, resolvedType, flags, query, userId);        return bestChoice;    } finally {        Trace.traceEnd(TRACE_TAG_PACKAGE_MANAGER);    }}

PMS.queryIntentActivitiesInternal

@Overridepublic List queryIntentActivities(        Intent intent, int flags, int filterCallingUid, int userId) {    final String resolvedType = intent.resolveTypeIfNeeded(mContext.getContentResolver());    return PackageManagerService.this            .queryIntentActivitiesInternal(intent, resolvedType, flags, filterCallingUid,                    userId, false /*resolveForStart*/);}

private @NonNull List queryIntentActivitiesInternal(Intent intent,        String resolvedType, int flags, int filterCallingUid, int userId,        boolean resolveForStart) {    ...    ComponentName comp = intent.getComponent();    if (comp == null) {        if (intent.getSelector() != null) {            intent = intent.getSelector();            comp = intent.getComponent();        }    }    flags = updateFlagsForResolve(flags, userId, intent, filterCallingUid, resolveForStart,            comp != null || pkgName != null /*onlyExposedExplicitly*/);    if (comp != null) {        final List list = new ArrayList(1);        final ActivityInfo ai = getActivityInfo(comp, flags, userId);        if (ai != null) {            // When specifying an explicit component, we prevent the activity from being            // used when either 1) the calling package is normal and the activity is within            // an ephemeral application or 2) the calling package is ephemeral and the            // activity is not visible to ephemeral applications.            final boolean matchInstantApp =                    (flags & PackageManager.MATCH_INSTANT) != 0;            final boolean matchVisibleToInstantAppOnly =                    (flags & PackageManager.MATCH_VISIBLE_TO_INSTANT_APP_ONLY) != 0;            final boolean matchExplicitlyVisibleOnly =                    (flags & PackageManager.MATCH_EXPLICITLY_VISIBLE_ONLY) != 0;            final boolean isCallerInstantApp =                    instantAppPkgName != null;            final boolean isTargetSameInstantApp =                    comp.getPackageName().equals(instantAppPkgName);            final boolean isTargetInstantApp =                    (ai.applicationInfo.privateFlags                            & ApplicationInfo.PRIVATE_FLAG_INSTANT) != 0;            final boolean isTargetVisibleToInstantApp =                    (ai.flags & ActivityInfo.FLAG_VISIBLE_TO_INSTANT_APP) != 0;            final boolean isTargetExplicitlyVisibleToInstantApp =                    isTargetVisibleToInstantApp                    && (ai.flags & ActivityInfo.FLAG_IMPLICITLY_VISIBLE_TO_INSTANT_APP) == 0;            final boolean isTargetHiddenFromInstantApp =                    !isTargetVisibleToInstantApp                    || (matchExplicitlyVisibleOnly && !isTargetExplicitlyVisibleToInstantApp);            final boolean blockResolution =                    !isTargetSameInstantApp                    && ((!matchInstantApp && !isCallerInstantApp && isTargetInstantApp)                            || (matchVisibleToInstantAppOnly && isCallerInstantApp                                    && isTargetHiddenFromInstantApp));            if (!blockResolution) {                final ResolveInfo ri = new ResolveInfo();                ri.activityInfo = ai;                list.add(ri);            }        }        return applyPostResolutionFilter(list, instantAppPkgName);    }

ASS.resolveActivity()方法的核心功能是找到相应的Activity组件，并保存到intent对象。

ActivityInfo resolveActivity(Intent intent, String resolvedType, int startFlags,        ProfilerInfo profilerInfo, int userId) {    final ResolveInfo rInfo = resolveIntent(intent, resolvedType, userId);    return resolveActivity(intent, rInfo, startFlags, profilerInfo);}

ASS.startActivityLocked is missed

AMS.checkAppSwitchAllowedLocked

boolean checkAppSwitchAllowedLocked(int sourcePid, int sourceUid,        int callingPid, int callingUid, String name) {    if (mAppSwitchesAllowedTime < SystemClock.uptimeMillis()) {        return true;    }    int perm = checkComponentPermission(            android.Manifest.permission.STOP_APP_SWITCHES, sourcePid,            sourceUid, -1, true);    if (perm == PackageManager.PERMISSION_GRANTED) {        return true;    }

    //当mAppSwitchesAllowedTime时间小于当前时长,或者具有STOP_APP_SWITCHES的权限,则允许app发生切换操作.    if (callingUid != -1 && callingUid != sourceUid) {        perm = checkComponentPermission(                android.Manifest.permission.STOP_APP_SWITCHES, callingPid,                callingUid, -1, true);        if (perm == PackageManager.PERMISSION_GRANTED) {            return true;        }    }    Slog.w(TAG, name + " request from " + sourceUid + " stopped");    return false;}

其中mAppSwitchesAllowedTime, 在AMS.stopAppSwitches()的过程中会设置为:mAppSwitchesAllowedTime = SystemClock.uptimeMillis() + APP_SWITCH_DELAY_TIME. 禁止app切换的timeout时长为5s(APP_SWITCH_DELAY_TIME = 5s).

当发送5秒超时或者执行AMS.resumeAppSwitches()过程会将mAppSwitchesAllowedTime设置0, 都会开启允许app执行切换的操作.另外,禁止App切换的操作,对于同一个app是不受影响的,有兴趣可以进一步查看checkComponentPermission过程.

AS.doPendingActivityLaunchesLocked

final void doPendingActivityLaunchesLocked(boolean doResume) {    while (!mPendingActivityLaunches.isEmpty()) {

        //mPendingActivityLaunches记录所有将要启动的Activity,因为startActivityLocked过程中，app不允许切换，就把Activity放入它里面，这个队列的成员在doPendingActivityLaunchesLocked执行完后，会清空        final PendingActivityLaunch pal = mPendingActivityLaunches.remove(0);        final boolean resume = doResume && mPendingActivityLaunches.isEmpty();        try {

            //这里的resume=false，所以不会执行resume，而是delay resume            startActivity(pal.r, pal.sourceRecord, null, null, pal.startFlags, resume, null,                    null, null /*outRecords*/);        } catch (Exception e) {            Slog.e(TAG, "Exception during pending activity launch pal=" + pal, e);            pal.sendErrorResult(e.getMessage());        }    }}

AS.startActivityUncheckedLocked

// sourceRecord是指调用者， r是指本次将要启动的Activityfinal int startActivityUncheckedLocked(final 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;    if (inTask != null && !inTask.inRecents) {        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();    // 当intent和activity manifest存在冲突，则manifest优先!!!    if ((launchFlags & Intent.FLAG_ACTIVITY_NEW_DOCUMENT) != 0 &&            (launchSingleInstance || launchSingleTask)) {        launchFlags &=                ~(Intent.FLAG_ACTIVITY_NEW_DOCUMENT | Intent.FLAG_ACTIVITY_MULTIPLE_TASK);    } else {    ...    }    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            && r.resultTo.task.stack != null) {        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 ((launchFlags & Intent.FLAG_ACTIVITY_NEW_TASK) != 0) {        if (launchTaskBehind                || r.info.documentLaunchMode == ActivityInfo.DOCUMENT_LAUNCH_ALWAYS) {            launchFlags |= Intent.FLAG_ACTIVITY_MULTIPLE_TASK;        }    }    mUserLeaving = (launchFlags & Intent.FLAG_ACTIVITY_NO_USER_ACTION) == 0;    //当本次不需要resume，则设置为延迟resume的状态    if (!doResume) {        r.delayedResume = true;    }    ActivityRecord notTop =            (launchFlags & Intent.FLAG_ACTIVITY_PREVIOUS_IS_TOP) != 0 ? r : null;    if ((startFlags&ActivityManager.START_FLAG_ONLY_IF_NEEDED) != 0) {        ActivityRecord checkedCaller = sourceRecord;        if (checkedCaller == null) {            checkedCaller = mFocusedStack.topRunningNonDelayedActivityLocked(notTop);        }        if (!checkedCaller.realActivity.equals(r.realActivity)) {            //调用者 与将要启动的Activity不相同时，进入该分支。            startFlags &= ~ActivityManager.START_FLAG_ONLY_IF_NEEDED;        }    }    boolean addingToTask = false;    TaskRecord reuseTask = null;    //当调用者不是来自activity，而是明确指定task的情况。    if (sourceRecord == null && inTask != null && inTask.stack != null) {    ... //目前sourceRecord不为空，则不进入该分支    } else {        inTask = null;    }    if (inTask == null) {        if (sourceRecord == null) {            //调用者并不是Activity context,则强制创建新task            if ((launchFlags & Intent.FLAG_ACTIVITY_NEW_TASK) == 0 && inTask == null) {                launchFlags |= Intent.FLAG_ACTIVITY_NEW_TASK;            }        } else if (sourceRecord.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE) {            //调用者activity带有single instance，则创建新task            launchFlags |= Intent.FLAG_ACTIVITY_NEW_TASK;        } else if (launchSingleInstance || launchSingleTask) {            //目标activity带有single instance或者single task，则创建新task            launchFlags |= Intent.FLAG_ACTIVITY_NEW_TASK;        }    }    ActivityInfo newTaskInfo = null;    Intent newTaskIntent = null;    ActivityStack sourceStack;    if (sourceRecord != null) {        if (sourceRecord.finishing) {            //调用者处于即将finish状态，则创建新task，所以应该先打开新的Activity再进行一个finish，不然性能上会有损耗            if ((launchFlags & Intent.FLAG_ACTIVITY_NEW_TASK) == 0) {                launchFlags |= Intent.FLAG_ACTIVITY_NEW_TASK;                newTaskInfo = sourceRecord.info;                newTaskIntent = sourceRecord.task.intent;            }            sourceRecord = null;            sourceStack = null;        } else {            //当调用者Activity不为空，且不处于finishing状态，则其所在栈赋于sourceStack            sourceStack = sourceRecord.task.stack;        }    } else {        sourceStack = null;    }    boolean movedHome = false;    ActivityStack targetStack;    intent.setFlags(launchFlags);    final boolean noAnimation = (launchFlags & Intent.FLAG_ACTIVITY_NO_ANIMATION) != 0;    if (((launchFlags & Intent.FLAG_ACTIVITY_NEW_TASK) != 0 &&            (launchFlags & Intent.FLAG_ACTIVITY_MULTIPLE_TASK) == 0)            || launchSingleInstance || launchSingleTask) {        if (inTask == null && r.resultTo == null) {            //从mActivityDisplays开始查询是否有相应ActivityRecord            ActivityRecord intentActivity = !launchSingleInstance ?                    findTaskLocked(r) : findActivityLocked(intent, r.info);            if (intentActivity != null) {                if (isLockTaskModeViolation(intentActivity.task,                        (launchFlags & (FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_CLEAR_TASK))                                == (FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_CLEAR_TASK))) {                    return ActivityManager.START_RETURN_LOCK_TASK_MODE_VIOLATION;                }                if (r.task == null) {                    r.task = intentActivity.task;                }                if (intentActivity.task.intent == null) {                    intentActivity.task.setIntent(r);                }                targetStack = intentActivity.task.stack;                targetStack.mLastPausedActivity = null;                final ActivityStack focusStack = getFocusedStack();                ActivityRecord curTop = (focusStack == null)                        ? null : focusStack.topRunningNonDelayedActivityLocked(notTop);                boolean movedToFront = false;                if (curTop != null && (curTop.task != intentActivity.task ||                        curTop.task != focusStack.topTask())) {                    r.intent.addFlags(Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT);                    if (sourceRecord == null || (sourceStack.topActivity() != null &&                            sourceStack.topActivity().task == sourceRecord.task)) {                        if (launchTaskBehind && sourceRecord != null) {                            intentActivity.setTaskToAffiliateWith(sourceRecord.task);                        }                        movedHome = true;                        //将该task移至前台                        targetStack.moveTaskToFrontLocked(intentActivity.task, noAnimation,                                options, r.appTimeTracker, "bringingFoundTaskToFront");                        movedToFront = true;                        if ((launchFlags &                                (FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_TASK_ON_HOME))                                == (FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_TASK_ON_HOME)) {                            //将toReturnTo设置为home                            intentActivity.task.setTaskToReturnTo(HOME_ACTIVITY_TYPE);                        }                        options = null;                    }                }                if (!movedToFront) {                    targetStack.moveToFront("intentActivityFound");                }                if ((launchFlags&Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED) != 0) {                    //重置目标task                    intentActivity = targetStack.resetTaskIfNeededLocked(intentActivity, r);                }                if ((startFlags & ActivityManager.START_FLAG_ONLY_IF_NEEDED) != 0) {                    if (doResume) {                        resumeTopActivitiesLocked(targetStack, null, options);                        //当没有启动至前台，则通知Keyguard                        if (!movedToFront) {                            notifyActivityDrawnForKeyguard();                        }                    } else {                        ActivityOptions.abort(options);                    }                    return ActivityManager.START_RETURN_INTENT_TO_CALLER;                }                if ((launchFlags & (FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_CLEAR_TASK))                        == (FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_CLEAR_TASK)) {                    reuseTask = intentActivity.task;                    //移除所有跟已存在的task有关联的activity                    reuseTask.performClearTaskLocked();                    reuseTask.setIntent(r);                } else if ((launchFlags & FLAG_ACTIVITY_CLEAR_TOP) != 0                        || launchSingleInstance || launchSingleTask) {                    ActivityRecord top =                            intentActivity.task.performClearTaskLocked(r, launchFlags);                    if (top != null) {                        if (top.frontOfTask) {                            top.task.setIntent(r);                        }                        //触发onNewIntent()                        top.deliverNewIntentLocked(callingUid, r.intent, r.launchedFromPackage);                    } else {                        sourceRecord = intentActivity;                        TaskRecord task = sourceRecord.task;                        if (task != null && task.stack == null) {                            targetStack = computeStackFocus(sourceRecord, false /* newTask */);                            targetStack.addTask(                                    task, !launchTaskBehind /* toTop */, false /* moving */);                        }                    }                } else if (r.realActivity.equals(intentActivity.task.realActivity)) {                    if (((launchFlags&Intent.FLAG_ACTIVITY_SINGLE_TOP) != 0 || launchSingleTop)                            && intentActivity.realActivity.equals(r.realActivity)) {                        if (intentActivity.frontOfTask) {                            intentActivity.task.setIntent(r);                        }                        //触发onNewIntent()                        intentActivity.deliverNewIntentLocked(callingUid, r.intent,                                r.launchedFromPackage);                    } else if (!r.intent.filterEquals(intentActivity.task.intent)) {                        addingToTask = true;                        sourceRecord = intentActivity;                    }                } else if ((launchFlags&Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED) == 0) {                    addingToTask = true;                    sourceRecord = intentActivity;                } else if (!intentActivity.task.rootWasReset) {                    intentActivity.task.setIntent(r);                }                if (!addingToTask && reuseTask == null) {                    if (doResume) {                        targetStack.resumeTopActivityLocked(null, options);                        if (!movedToFront) {                            notifyActivityDrawnForKeyguard();                        }                    } else {                        ActivityOptions.abort(options);                    }                    return ActivityManager.START_TASK_TO_FRONT;                }            }        }    }    if (r.packageName != null) {        //当启动的activity跟前台显示是同一个的情况        ActivityStack topStack = mFocusedStack;        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) {                        topStack.mLastPausedActivity = null;                        if (doResume) {                            resumeTopActivitiesLocked();                        }                        ActivityOptions.abort(options);                        if ((startFlags&ActivityManager.START_FLAG_ONLY_IF_NEEDED) != 0) {                        }                        //触发onNewIntent()                        top.deliverNewIntentLocked(callingUid, r.intent, r.launchedFromPackage);                        return ActivityManager.START_DELIVERED_TO_TOP;                    }                }            }        }    } else {        if (r.resultTo != null && r.resultTo.task.stack != 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;    if (r.resultTo == null && inTask == null && !addingToTask            && (launchFlags & Intent.FLAG_ACTIVITY_NEW_TASK) != 0) {        newTask = true;        targetStack = computeStackFocus(r, newTask);        targetStack.moveToFront("startingNewTask");        if (reuseTask == null) {            r.setTask(targetStack.createTaskRecord(getNextTaskId(),                    newTaskInfo != null ? newTaskInfo : r.info,                    newTaskIntent != null ? newTaskIntent : intent,                    voiceSession, voiceInteractor, !launchTaskBehind /* toTop */),                    taskToAffiliate);        } else {            r.setTask(reuseTask, taskToAffiliate);        }        if (isLockTaskModeViolation(r.task)) {            return ActivityManager.START_RETURN_LOCK_TASK_MODE_VIOLATION;        }        if (!movedHome) {            if ((launchFlags &                    (FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_TASK_ON_HOME))                    == (FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_TASK_ON_HOME)) {                r.task.setTaskToReturnTo(HOME_ACTIVITY_TYPE);            }        }    } else if (sourceRecord != null) {        final TaskRecord sourceTask = sourceRecord.task;        if (isLockTaskModeViolation(sourceTask)) {            return ActivityManager.START_RETURN_LOCK_TASK_MODE_VIOLATION;        }        targetStack = sourceTask.stack;        targetStack.moveToFront("sourceStackToFront");        final TaskRecord topTask = targetStack.topTask();        if (topTask != sourceTask) {            targetStack.moveTaskToFrontLocked(sourceTask, noAnimation, options,                    r.appTimeTracker, "sourceTaskToFront");        }        if (!addingToTask && (launchFlags&Intent.FLAG_ACTIVITY_CLEAR_TOP) != 0) {            ActivityRecord top = sourceTask.performClearTaskLocked(r, launchFlags);            keepCurTransition = true;            if (top != null) {                //触发onNewIntent()                top.deliverNewIntentLocked(callingUid, r.intent, r.launchedFromPackage);                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) {            final ActivityRecord top = sourceTask.findActivityInHistoryLocked(r);            if (top != null) {                final TaskRecord task = top.task;                task.moveActivityToFrontLocked(top);                top.updateOptionsLocked(options);                //触发onNewIntent()                top.deliverNewIntentLocked(callingUid, r.intent, r.launchedFromPackage);                targetStack.mLastPausedActivity = null;                if (doResume) {                    targetStack.resumeTopActivityLocked(null);                }                return ActivityManager.START_DELIVERED_TO_TOP;            }        }        r.setTask(sourceTask, null);    } else if (inTask != null) {        if (isLockTaskModeViolation(inTask)) {            return ActivityManager.START_RETURN_LOCK_TASK_MODE_VIOLATION;        }        targetStack = inTask.stack;        targetStack.moveTaskToFrontLocked(inTask, noAnimation, options, r.appTimeTracker,                "inTaskToFront");        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) {                if ((startFlags&ActivityManager.START_FLAG_ONLY_IF_NEEDED) != 0) {                    return ActivityManager.START_RETURN_INTENT_TO_CALLER;                }                //触发onNewIntent()                top.deliverNewIntentLocked(callingUid, r.intent, r.launchedFromPackage);                return ActivityManager.START_DELIVERED_TO_TOP;            }        }        if (!addingToTask) {            ActivityOptions.abort(options);            return ActivityManager.START_TASK_TO_FRONT;        }        r.setTask(inTask, null);    } else {        targetStack = computeStackFocus(r, newTask);        targetStack.moveToFront("addingToTopTask");        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);    }    targetStack.mLastPausedActivity = null;    //创建activity [见流程2.10]    targetStack.startActivityLocked(r, newTask, doResume, keepCurTransition, options);    if (!launchTaskBehind) {        mService.setFocusedActivityLocked(r, "startedActivity");    }    return ActivityManager.START_SUCCESS;}

最后再说说：设置FLAG_ACTIVITY_NEW_TASK的几个情况：
调用者并不是Activity context；
调用者activity带有single instance；
目标activity带有single instance或者single task；
调用者处于finishing状态；

ActivityStack.startActivityLocked

final void startActivityLocked(ActivityRecord r, boolean newTask, boolean doResume, boolean keepCurTransition, Bundle options) {    TaskRecord rTask = r.task;    final int taskId = rTask.taskId;    if (!r.mLaunchTaskBehind && (taskForIdLocked(taskId) == null || newTask)) {        //task中的上一个activity已被移除，或者ams重用该task,则将该task移到顶部        insertTaskAtTop(rTask, r);        mWindowManager.moveTaskToTop(taskId);    }    TaskRecord task = null;    if (!newTask) {        boolean startIt = true;        for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {            task = mTaskHistory.get(taskNdx);            if (task.getTopActivity() == null) {                //该task所有activity都finishing                continue;            }            if (task == r.task) {                if (!startIt) {                    task.addActivityToTop(r);                    r.putInHistory();                    mWindowManager.addAppToken(task.mActivities.indexOf(r), r.appToken,                            r.task.taskId, mStackId, r.info.screenOrientation, r.fullscreen,                            (r.info.flags & ActivityInfo.FLAG_SHOW_FOR_ALL_USERS) != 0,                            r.userId, r.info.configChanges, task.voiceSession != null,                            r.mLaunchTaskBehind);                    ActivityOptions.abort(options);                    return;                }                break;            } else if (task.numFullscreen > 0) {                startIt = false;            }        }    }    if (task == r.task && mTaskHistory.indexOf(task) != (mTaskHistory.size() - 1)) {        mStackSupervisor.mUserLeaving = false;    }    task = r.task;    task.addActivityToTop(r);    task.setFrontOfTask();    r.putInHistory();    mActivityTrigger.activityStartTrigger(r.intent, r.info, r.appInfo);    if (!isHomeStack() || numActivities() > 0) {        //当切换到新的task，或者下一个activity进程目前并没有运行，则        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 ((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_FOR_ALL_USERS) != 0, r.userId,                r.info.configChanges, task.voiceSession != null, r.mLaunchTaskBehind);        boolean doShow = true;        if (newTask) {            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) {            mWindowManager.setAppVisibility(r.appToken, true);            ensureActivitiesVisibleLocked(null, 0);        } else if (SHOW_APP_STARTING_PREVIEW && doShow) {            ActivityRecord prev = mResumedActivity;            if (prev != null) {                //当前activity所属不同的task                if (prev.task != r.task) {                    prev = null;                }                //当前activity已经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 {        mWindowManager.addAppToken(task.mActivities.indexOf(r), r.appToken,                r.task.taskId, mStackId, r.info.screenOrientation, r.fullscreen,                (r.info.flags & ActivityInfo.FLAG_SHOW_FOR_ALL_USERS) != 0, r.userId,                r.info.configChanges, task.voiceSession != null, r.mLaunchTaskBehind);        ActivityOptions.abort(options);        options = null;    }    if (doResume) {        // [见流程2.11]        mStackSupervisor.resumeTopActivitiesLocked(this, r, options);    }}

ASS.resumeTopActivitiesLocked

boolean resumeTopActivitiesLocked(ActivityStack targetStack, ActivityRecord target, Bundle targetOptions) {    if (targetStack == null) {        targetStack = mFocusedStack;    }    boolean result = false;    if (isFrontStack(targetStack)) {        //[见流程2.12]        result = targetStack.resumeTopActivityLocked(target, targetOptions);    }    for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {        final ArrayList stacks = mActivityDisplays.valueAt(displayNdx).mStacks;        for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {            final ActivityStack stack = stacks.get(stackNdx);            if (stack == targetStack) {                //上面刚已启动                continue;            }            if (isFrontStack(stack)) {                stack.resumeTopActivityLocked(null);            }        }    }    return result;}

AS.resumeTopActivityLocked

final boolean resumeTopActivityLocked(ActivityRecord prev, Bundle options) {    if (mStackSupervisor.inResumeTopActivity) {        return false; //防止递归启动    }    boolean result = false;    try {        mStackSupervisor.inResumeTopActivity = true;        if (mService.mLockScreenShown == ActivityManagerService.LOCK_SCREEN_LEAVING) {            mService.mLockScreenShown = ActivityManagerService.LOCK_SCREEN_HIDDEN;            mService.updateSleepIfNeededLocked();        }        //[见流程2.13]        result = resumeTopActivityInnerLocked(prev, options);    } finally {        mStackSupervisor.inResumeTopActivity = false;    }    return result;}

inResumeTopActivity用于保证每次只有一个Activity执行resumeTopActivityLocked()操作.

AS.resumeTopActivityInnerLocked

private boolean resumeTopActivityInnerLocked(ActivityRecord prev, Bundle options) {

... //系统没有进入booting或booted状态，则不允许启动Activity    ActivityRecord parent = mActivityContainer.mParentActivity;    if ((parent != null && parent.state != ActivityState.RESUMED) ||            !mActivityContainer.isAttachedLocked()) {        return false;    }    //top running之后的任意处于初始化状态且有显示StartingWindow, 则移除StartingWindow    cancelInitializingActivities();    //找到第一个没有finishing的栈顶activity    final ActivityRecord next = topRunningActivityLocked(null);    final boolean userLeaving = mStackSupervisor.mUserLeaving;    mStackSupervisor.mUserLeaving = false;    final TaskRecord prevTask = prev != null ? prev.task : null;    if (next == null) {        final String reason = "noMoreActivities";        if (!mFullscreen) {            //当该栈没有全屏，则尝试聚焦到下一个可见的stack            final ActivityStack stack = getNextVisibleStackLocked();            if (adjustFocusToNextVisibleStackLocked(stack, reason)) {                return mStackSupervisor.resumeTopActivitiesLocked(stack, prev, null);            }        }        ActivityOptions.abort(options);        final int returnTaskType = prevTask == null || !prevTask.isOverHomeStack() ?                HOME_ACTIVITY_TYPE : prevTask.getTaskToReturnTo();        //启动home桌面activity        return isOnHomeDisplay() &&                mStackSupervisor.resumeHomeStackTask(returnTaskType, prev, reason);    }    next.delayedResume = false;    if (mResumedActivity == next && next.state == ActivityState.RESUMED &&            mStackSupervisor.allResumedActivitiesComplete()) {        mWindowManager.executeAppTransition();        mNoAnimActivities.clear();        ActivityOptions.abort(options);        return false;    }    final TaskRecord nextTask = next.task;    if (prevTask != null && prevTask.stack == this &&            prevTask.isOverHomeStack() && prev.finishing && prev.frontOfTask) {        if (prevTask == nextTask) {            prevTask.setFrontOfTask();        } else if (prevTask != topTask()) {            final int taskNdx = mTaskHistory.indexOf(prevTask) + 1;            mTaskHistory.get(taskNdx).setTaskToReturnTo(HOME_ACTIVITY_TYPE);        } else if (!isOnHomeDisplay()) {            return false;        } else if (!isHomeStack()){            final int returnTaskType = prevTask == null || !prevTask.isOverHomeStack() ?                    HOME_ACTIVITY_TYPE : prevTask.getTaskToReturnTo();            return isOnHomeDisplay() &&                    mStackSupervisor.resumeHomeStackTask(returnTaskType, prev, "prevFinished");        }    }    //处于睡眠或者关机状态，top activity已暂停的情况下    if (mService.isSleepingOrShuttingDown()            && mLastPausedActivity == next            && mStackSupervisor.allPausedActivitiesComplete()) {        mWindowManager.executeAppTransition();        mNoAnimActivities.clear();        ActivityOptions.abort(options);        return false;    }    if (mService.mStartedUsers.get(next.userId) == null) {        return false; //拥有该activity的用户没有启动则直接返回    }    mStackSupervisor.mStoppingActivities.remove(next);    mStackSupervisor.mGoingToSleepActivities.remove(next);    next.sleeping = false;    mStackSupervisor.mWaitingVisibleActivities.remove(next);    mActivityTrigger.activityResumeTrigger(next.intent, next.info, next.appInfo);    if (!mStackSupervisor.allPausedActivitiesComplete()) {        return false; //当正处于暂停activity，则直接返回    }    mStackSupervisor.setLaunchSource(next.info.applicationInfo.uid);    //需要等待暂停当前activity完成，再resume top activity    boolean dontWaitForPause = (next.info.flags&ActivityInfo.FLAG_RESUME_WHILE_PAUSING) != 0;    //暂停其他Activity[见小节2.13.1]    boolean pausing = mStackSupervisor.pauseBackStacks(userLeaving, true, dontWaitForPause);    if (mResumedActivity != null) {        //当前resumd状态activity不为空，则需要先暂停该Activity        pausing |= startPausingLocked(userLeaving, false, true, dontWaitForPause);    }    if (pausing) {        if (next.app != null && next.app.thread != null) {            mService.updateLruProcessLocked(next.app, true, null);        }        return true;    }    if (mService.isSleeping() && mLastNoHistoryActivity != null &&            !mLastNoHistoryActivity.finishing) {        requestFinishActivityLocked(mLastNoHistoryActivity.appToken, Activity.RESULT_CANCELED,                null, "resume-no-history", false);        mLastNoHistoryActivity = null;    }    if (prev != null && prev != next) {        if (!mStackSupervisor.mWaitingVisibleActivities.contains(prev)                && next != null && !next.nowVisible) {            mStackSupervisor.mWaitingVisibleActivities.add(prev);        } else {            if (prev.finishing) {                mWindowManager.setAppVisibility(prev.appToken, false);            }        }    }    AppGlobals.getPackageManager().setPackageStoppedState(            next.packageName, false, next.userId);    boolean anim = true;    if (mIsAnimationBoostEnabled == true && mPerf == null) {        mPerf = new BoostFramework();    }    if (prev != null) {        if (prev.finishing) {            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);                if(prev.task != next.task && mPerf != null) {                    mPerf.perfLockAcquire(aBoostTimeOut, aBoostParamVal);                }            }            mWindowManager.setAppWillBeHidden(prev.appToken);            mWindowManager.setAppVisibility(prev.appToken, false);        } else {            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(prev.task != next.task && mPerf != null) {                    mPerf.perfLockAcquire(aBoostTimeOut, aBoostParamVal);                }            }        }    } else {        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) {        //activity正在成为可见        mWindowManager.setAppVisibility(next.appToken, true);        next.startLaunchTickingLocked();        ActivityRecord lastResumedActivity = lastStack == null ? null :lastStack.mResumedActivity;        ActivityState lastState = next.state;        mService.updateCpuStats();        //设置Activity状态为resumed        next.state = ActivityState.RESUMED;        mResumedActivity = next;        next.task.touchActiveTime();        mRecentTasks.addLocked(next.task);        mService.updateLruProcessLocked(next.app, true, null);        updateLRUListLocked(next);        mService.updateOomAdjLocked();        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) {            ActivityRecord nextNext = topRunningActivityLocked(null);            if (nextNext != next) {                mStackSupervisor.scheduleResumeTopActivities();            }            if (mStackSupervisor.reportResumedActivityLocked(next)) {                mNoAnimActivities.clear();                return true;            }            return false;        }        try {            //分发所有pending结果.            ArrayList a = next.results;            if (a != null) {                final int N = a.size();                if (!next.finishing && N > 0) {                    next.app.thread.scheduleSendResult(next.appToken, a);                }            }            if (next.newIntents != null) {                next.app.thread.scheduleNewIntent(next.newIntents, next.appToken);            }            next.sleeping = false;            mService.showAskCompatModeDialogLocked(next);            next.app.pendingUiClean = true;            next.app.forceProcessStateUpTo(mService.mTopProcessState);            next.clearOptionsLocked();            //触发onResume()!!!            next.app.thread.scheduleResumeActivity(next.appToken, next.app.repProcState,                    mService.isNextTransitionForward(), resumeAnimOptions);            mStackSupervisor.checkReadyForSleepLocked();        } catch (Exception e) {        ...            return true;        }        next.visible = true;        completeResumeLocked(next);        next.stopped = false;    } else {        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);            }        }        mStackSupervisor.startSpecificActivityLocked(next, true, true);    }    return true;}

主要分支功能：
当找不到需要resume的Activity，则直接回到桌面；
否则，当mResumedActivity不为空，则执行startPausingLocked()暂停该activity;
然后再进入startSpecificActivityLocked环节，接下来从这里继续往下说。

ASS.pauseBackStacks

boolean pauseBackStacks(boolean userLeaving, ActivityRecord resuming, boolean dontWait) {    boolean someActivityPaused = false;    for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {        ArrayList stacks = mActivityDisplays.valueAt(displayNdx).mStacks;        for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {            final ActivityStack stack = stacks.get(stackNdx);            if (!isFocusedStack(stack) && stack.mResumedActivity != null) {                if (DEBUG_STATES) Slog.d(TAG_STATES, "pauseBackStacks: stack=" + stack +                        " mResumedActivity=" + stack.mResumedActivity);                someActivityPaused |= stack.startPausingLocked(userLeaving, false, resuming,                        dontWait);            }        }    }    return someActivityPaused;}

暂停处于后台栈的所有Activity

AS.startPausingLocked

final boolean startPausingLocked(boolean userLeaving, boolean uiSleeping, boolean resuming, boolean dontWait) {      if (mPausingActivity != null) {          if (!mService.isSleeping()) {              completePauseLocked(false);          }      }      ActivityRecord prev = mResumedActivity;...      if (mActivityContainer.mParentActivity == null) {          //暂停所有子栈的Activity          mStackSupervisor.pauseChildStacks(prev, userLeaving, uiSleeping, resuming, dontWait);      }...      final ActivityRecord next = mStackSupervisor.topRunningActivityLocked();      if (prev.app != null && prev.app.thread != null) {          EventLog.writeEvent(EventLogTags.AM_PAUSE_ACTIVITY,                  prev.userId, System.identityHashCode(prev),                  prev.shortComponentName);

          //经过Binder调用，进入主线程，然后执行暂停Activity          mService.updateUsageStats(prev, false);          //暂停目标Activity          prev.app.thread.schedulePauseActivity(prev.appToken, prev.finishing,                  userLeaving, prev.configChangeFlags, dontWait);      }else {    ...      }      if (!uiSleeping && !mService.isSleepingOrShuttingDown()) {          mStackSupervisor.acquireLaunchWakelock(); //申请wakelock      }      if (mPausingActivity != null) {          if (!uiSleeping) {              prev.pauseKeyDispatchingLocked();          }

//对于dontWait=true则执行执行completePauseLocked，否则等待app通知或许500ms超时再执行该方法。          if (dontWait) {              completePauseLocked(false);              return false;          } else {              Message msg = mHandler.obtainMessage(PAUSE_TIMEOUT_MSG);              msg.obj = prev;              prev.pauseTime = SystemClock.uptimeMillis();              //500ms后，执行暂停超时的消息              mHandler.sendMessageDelayed(msg, PAUSE_TIMEOUT);              return true;          }      } else {          if (!resuming) { //调度暂停失败，则认为已暂停完成，开始执行resume操作              mStackSupervisor.getFocusedStack().resumeTopActivityLocked(null);          }          return false;      }

AS.completePauseLocked

ASS.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);    r.getStack().setLaunchTime(r);    if (app != null && app.thread != null) {        try {            if ((r.info.flags&ActivityInfo.FLAG_MULTIPROCESS) == 0                    || !"android".equals(r.info.packageName)) {                // Don't add this if it is a platform component that is marked                // to run in multiple processes, because this is actually                // part of the framework so doesn't make sense to track as a                // separate apk in the process.                app.addPackage(r.info.packageName, r.info.applicationInfo.versionCode,                        mService.mProcessStats);            }

            //真正地启动Activity!!!            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);}

AMS.startProcessLocked，创建完新进程后AMP.attachApplication，该方法经过Binder调用后，调用到AMS.attachApplicationLocked

private final boolean attachApplicationLocked(IApplicationThread thread, int pid) {...    //只有当系统启动完，或者app允许启动过程允许，则会true    boolean normalMode = mProcessesReady || isAllowedWhileBooting(app.info);    thread.bindApplication(...);    if (normalMode) {        //【见流程2.16】        if (mStackSupervisor.attachApplicationLocked(app)) {            didSomething = true;        }    }...}

在执行完bindApplication后会进入ASS.attachApplicationLocked()

ASS.attachApplicationLocked

boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {    final String processName = app.processName;    boolean didSomething = false;    for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {        ArrayList stacks = mActivityDisplays.valueAt(displayNdx).mStacks;        for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {            final ActivityStack stack = stacks.get(stackNdx);            if (!isFrontStack(stack)) {                continue;            }            //获取前台stack中栈顶第一个非finishing的Activity            ActivityRecord hr = stack.topRunningActivityLocked(null);            if (hr != null) {                if (hr.app == null && app.uid == hr.info.applicationInfo.uid                        && processName.equals(hr.processName)) {                    try {                        //真正的启动Activity!!!                        if (realStartActivityLocked(hr, app, true, true)) {                            didSomething = true;                        }                    } catch (RemoteException e) {                        throw e;                    }                }            }        }    }    if (!didSomething) {        //启动Activity不成功，则确保有可见的Activity        ensureActivitiesVisibleLocked(null, 0);    }    return didSomething;}

ASS.realStartActivityLocked

final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app, boolean andResume, boolean checkConfig) throws RemoteException {    if (andResume) {        r.startFreezingScreenLocked(app, 0);        mWindowManager.setAppVisibility(r.appToken, true);        //调度启动ticks用以收集应用启动慢的信息        r.startLaunchTickingLocked();    }    if (checkConfig) {        Configuration config = mWindowManager.updateOrientationFromAppTokens(                mService.mConfiguration,                r.mayFreezeScreenLocked(app) ? r.appToken : null);        //更新Configuration        mService.updateConfigurationLocked(config, r, false, false);    }    r.app = app;    app.waitingToKill = null;    r.launchCount++;    r.lastLaunchTime = SystemClock.uptimeMillis();    int idx = app.activities.indexOf(r);    if (idx < 0) {        app.activities.add(r);    }    mService.updateLruProcessLocked(app, true, null);    mService.updateOomAdjLocked();    final TaskRecord task = r.task;    if (task.mLockTaskAuth == LOCK_TASK_AUTH_LAUNCHABLE ||            task.mLockTaskAuth == LOCK_TASK_AUTH_LAUNCHABLE_PRIV) {        setLockTaskModeLocked(task, LOCK_TASK_MODE_LOCKED, "mLockTaskAuth==LAUNCHABLE", false);    }    final ActivityStack stack = task.stack;    try {        if (app.thread == null) {            throw new RemoteException();        }        List results = null;        List newIntents = null;        if (andResume) {            results = r.results;            newIntents = r.newIntents;        }        if (r.isHomeActivity() && r.isNotResolverActivity()) {            //home进程是该栈的根进程            mService.mHomeProcess = task.mActivities.get(0).app;        }        mService.ensurePackageDexOpt(r.intent.getComponent().getPackageName());    ...        if (andResume) {            app.hasShownUi = true;            app.pendingUiClean = true;        }        //将该进程设置为前台进程PROCESS_STATE_TOP        app.forceProcessStateUpTo(mService.mTopProcessState);        //【见流程2.18】        app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,                System.identityHashCode(r), r.info, new Configuration(mService.mConfiguration),                new Configuration(stack.mOverrideConfig), r.compat, r.launchedFromPackage,                task.voiceInteractor, app.repProcState, r.icicle, r.persistentState, results,                newIntents, !andResume, mService.isNextTransitionForward(), profilerInfo);        if ((app.info.privateFlags& ApplicationInfo.PRIVATE_FLAG_CANT_SAVE_STATE) != 0) {        ... //处理heavy-weight进程        }    } catch (RemoteException e) {        if (r.launchFailed) {            //第二次启动失败，则结束该activity            mService.appDiedLocked(app);            stack.requestFinishActivityLocked(r.appToken, Activity.RESULT_CANCELED, null,                    "2nd-crash", false);            return false;        }        //这是第一个启动失败，则重启进程        app.activities.remove(r);        throw e;    }    //将该进程加入到mLRUActivities队列顶部    stack.updateLRUListLocked(r)；    if (andResume) {        //启动过程的一部分        stack.minimalResumeActivityLocked(r);    } else {        r.state = STOPPED;        r.stopped = true;    }    if (isFrontStack(stack)) {        //当系统发生更新时，只会执行一次的用户向导        mService.startSetupActivityLocked();    }    //更新所有与该Activity具有绑定关系的Service连接    mService.mServices.updateServiceConnectionActivitiesLocked(r.app);    return true;}

ATP.scheduleLaunchActivity

public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident, ActivityInfo info, Configuration curConfig, Configuration overrideConfig, CompatibilityInfo compatInfo, String referrer, IVoiceInteractor voiceInteractor, int procState, Bundle state, PersistableBundle persistentState, List pendingResults, List pendingNewIntents, boolean notResumed, boolean isForward, ProfilerInfo profilerInfo) throws RemoteException {    Parcel data = Parcel.obtain();    data.writeInterfaceToken(IApplicationThread.descriptor);    intent.writeToParcel(data, 0);    data.writeStrongBinder(token);    data.writeInt(ident);    info.writeToParcel(data, 0);    curConfig.writeToParcel(data, 0);    if (overrideConfig != null) {        data.writeInt(1);        overrideConfig.writeToParcel(data, 0);    } else {        data.writeInt(0);    }    compatInfo.writeToParcel(data, 0);    data.writeString(referrer);    data.writeStrongBinder(voiceInteractor != null ? voiceInteractor.asBinder() : null);    data.writeInt(procState);    data.writeBundle(state);    data.writePersistableBundle(persistentState);    data.writeTypedList(pendingResults);    data.writeTypedList(pendingNewIntents);    data.writeInt(notResumed ? 1 : 0);    data.writeInt(isForward ? 1 : 0);    if (profilerInfo != null) {        data.writeInt(1);        profilerInfo.writeToParcel(data, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);    } else {        data.writeInt(0);    }    //【见流程2.19】    mRemote.transact(SCHEDULE_LAUNCH_ACTIVITY_TRANSACTION, data, null,            IBinder.FLAG_ONEWAY);    data.recycle();}

ATN.onTransact

public boolean onTransact(int code, Parcel data, Parcel reply, int flags) throws RemoteException {    switch (code) {        case SCHEDULE_LAUNCH_ACTIVITY_TRANSACTION:        {            data.enforceInterface(IApplicationThread.descriptor);            Intent intent = Intent.CREATOR.createFromParcel(data);            IBinder b = data.readStrongBinder();            int ident = data.readInt();            ActivityInfo info = ActivityInfo.CREATOR.createFromParcel(data);            Configuration curConfig = Configuration.CREATOR.createFromParcel(data);            Configuration overrideConfig = null;            if (data.readInt() != 0) {                overrideConfig = Configuration.CREATOR.createFromParcel(data);            }            CompatibilityInfo compatInfo = CompatibilityInfo.CREATOR.createFromParcel(data);            String referrer = data.readString();            IVoiceInteractor voiceInteractor = IVoiceInteractor.Stub.asInterface(                    data.readStrongBinder());            int procState = data.readInt();            Bundle state = data.readBundle();            PersistableBundle persistentState = data.readPersistableBundle();            List ri = data.createTypedArrayList(ResultInfo.CREATOR);            List pi = data.createTypedArrayList(ReferrerIntent.CREATOR);            boolean notResumed = data.readInt() != 0;            boolean isForward = data.readInt() != 0;            ProfilerInfo profilerInfo = data.readInt() != 0                    ? ProfilerInfo.CREATOR.createFromParcel(data) : null;            //【见流程2.20】            scheduleLaunchActivity(intent, b, ident, info, curConfig, overrideConfig, compatInfo,                    referrer, voiceInteractor, procState, state, persistentState, ri, pi,                    notResumed, isForward, profilerInfo);            return true;        }...    }}

AT.scheduleLaunchActivity

public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident, ActivityInfo info, Configuration curConfig, Configuration overrideConfig, CompatibilityInfo compatInfo, String referrer, IVoiceInteractor voiceInteractor, int procState, Bundle state, PersistableBundle persistentState, List pendingResults, List pendingNewIntents, boolean notResumed, boolean isForward, ProfilerInfo profilerInfo) {    updateProcessState(procState, false);    ActivityClientRecord r = new ActivityClientRecord();    r.token = token;    r.ident = ident;    r.intent = intent;    r.referrer = referrer;    r.voiceInteractor = voiceInteractor;    r.activityInfo = info;    r.compatInfo = compatInfo;    r.state = state;    r.persistentState = persistentState;    r.pendingResults = pendingResults;    r.pendingIntents = pendingNewIntents;    r.startsNotResumed = notResumed;    r.isForward = isForward;    r.profilerInfo = profilerInfo;    r.overrideConfig = overrideConfig;    updatePendingConfiguration(curConfig);    //【见流程2.21】    sendMessage(H.LAUNCH_ACTIVITY, r);}

H.handleMessage

public void handleMessage(Message msg) {    switch (msg.what) {        case LAUNCH_ACTIVITY: {            final ActivityClientRecord r = (ActivityClientRecord) msg.obj;            r.packageInfo = getPackageInfoNoCheck(                    r.activityInfo.applicationInfo, r.compatInfo);            //【见流程2.22】            handleLaunchActivity(r, null);        } break;    ...    }}

ActivityThread.handleLaunchActivity

private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent) {    unscheduleGcIdler();    mSomeActivitiesChanged = true;    //最终回调目标Activity的onConfigurationChanged()    handleConfigurationChanged(null, null);    //初始化wms    WindowManagerGlobal.initialize();    //最终回调目标Activity的onCreate[见流程2.23]    Activity a = performLaunchActivity(r, customIntent);    if (a != null) {        r.createdConfig = new Configuration(mConfiguration);        Bundle oldState = r.state;        //最终回调目标Activity的onStart,onResume.        handleResumeActivity(r.token, false, r.isForward,                !r.activity.mFinished && !r.startsNotResumed);        if (!r.activity.mFinished && r.startsNotResumed) {            r.activity.mCalled = false;            mInstrumentation.callActivityOnPause(r.activity);            r.paused = true;        }    } else {        //存在error则停止该Activity        ActivityManagerNative.getDefault()                .finishActivity(r.token, Activity.RESULT_CANCELED, null, false);    }}

ActivityThread.performLaunchActivity

private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {    ActivityInfo aInfo = r.activityInfo;    if (r.packageInfo == null) {        r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo,                Context.CONTEXT_INCLUDE_CODE);    }    ComponentName component = r.intent.getComponent();    if (component == null) {        component = r.intent.resolveActivity(                mInitialApplication.getPackageManager());        r.intent.setComponent(component);    }    if (r.activityInfo.targetActivity != null) {        component = new ComponentName(r.activityInfo.packageName,                r.activityInfo.targetActivity);    }    Activity activity = null;    try {        java.lang.ClassLoader cl = r.packageInfo.getClassLoader();        activity = mInstrumentation.newActivity(                cl, component.getClassName(), r.intent);        StrictMode.incrementExpectedActivityCount(activity.getClass());        r.intent.setExtrasClassLoader(cl);        r.intent.prepareToEnterProcess();        if (r.state != null) {            r.state.setClassLoader(cl);        }    } catch (Exception e) {    ...    }    try {        //创建Application对象        Application app = r.packageInfo.makeApplication(false, mInstrumentation);        if (activity != null) {            Context appContext = createBaseContextForActivity(r, activity);            CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());            Configuration config = new Configuration(mCompatConfiguration);            activity.attach(appContext, this, getInstrumentation(), r.token,                    r.ident, app, r.intent, r.activityInfo, title, r.parent,                    r.embeddedID, r.lastNonConfigurationInstances, config,                    r.referrer, r.voiceInteractor);            if (customIntent != null) {                activity.mIntent = customIntent;            }            r.lastNonConfigurationInstances = null;            activity.mStartedActivity = false;            int theme = r.activityInfo.getThemeResource();            if (theme != 0) {                activity.setTheme(theme);            }            activity.mCalled = false;            if (r.isPersistable()) {                mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);            } else {                mInstrumentation.callActivityOnCreate(activity, r.state);            }        ...            r.activity = activity;            r.stopped = true;            if (!r.activity.mFinished) {                activity.performStart();                r.stopped = false;            }            if (!r.activity.mFinished) {                if (r.isPersistable()) {                    if (r.state != null || r.persistentState != null) {                        mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state,                                r.persistentState);                    }                } else if (r.state != null) {                    mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);                }            }            if (!r.activity.mFinished) {                activity.mCalled = false;                if (r.isPersistable()) {                    mInstrumentation.callActivityOnPostCreate(activity, r.state,                            r.persistentState);                } else {                    mInstrumentation.callActivityOnPostCreate(activity, r.state);                }            ...            }        }        r.paused = true;        mActivities.put(r.token, r);    }  catch (Exception e) {    ...    }    return activity;}

总结：

1.运行在调用者所在进程，如果是从桌面进入，那么调用者进程就是launcher，launcher利用ActivityManagerProxy作为Binder client，进入system_server进程(AMS所在进程)。

2.会调用到resolveActivity()，借助PackageManager来查询系统中所有符合要求的Activity，当存在多个满足条件的Activity，会弹窗，让用户来选择。

3.创建ActivityRecord对象，并检查是否需要App切换，然后再处理mPendingActivityLaunches中的Activity。

4.为Activity找到或者创建新的Task对象，设置flags信息。

5.当没有处于非finishing状态的Activity，直接回到桌面；否则，当mResumedActivity不为空时，则暂停该Activity

6.如果进程不存在，需要创建进程。

7.system_server进程利用ATP（Binder client），通过Binder，进入目标进程

8.运行在目标进程，通过Handler，该进程中的Binder线程向主线程发送H.LAUNCH_ACTIVITY，最终通过反射创建Activity，进入生命周期。

流程

更多相关文章

随机推荐