Android源码--startActivityUncheckedLocked

startActivityUncheckedLocked(ActivityRecord r,ActivityRecord sourceRecord, int startFlags, boolean doResume,Bundle options)

传入的参数为：

ActivityRecord r：要启动的Activity的ActivityRecord

ActivityRecord sourceRecord:调用者Activity的ActivityRecord

int startFlags:0

boolean doResume:true

Bundle options：调用者传入，一般为null

final Intent intent = r.intent;        final int callingUid = r.launchedFromUid;        final int userId = r.userId;        int launchFlags = intent.getFlags();                // We'll invoke onUserLeaving before onPause only if the launching        // activity did not explicitly state that this is an automated launch.        mUserLeaving = (launchFlags&Intent.FLAG_ACTIVITY_NO_USER_ACTION) == 0;        if (DEBUG_USER_LEAVING) Slog.v(TAG,                "startActivity() => mUserLeaving=" + mUserLeaving);                // If the caller has asked not to resume at this point, we make note        // of this in the record so that we can skip it when trying to find        // the top running activity.        if (!doResume) {            r.delayedResume = true;        }                ActivityRecord notTop = (launchFlags&Intent.FLAG_ACTIVITY_PREVIOUS_IS_TOP)                != 0 ? r : null;

首先得到要启动的Activity的Intent，然后得到调用者的uid，以及要启动的UID，以及Intent中的LaunchFlags，接着判断launchFlags中是否有FLAG_ACTIVITY_NO_USER_ACTION，如果有的话，那么则得到mUserLeaving为true，此标志位是用来判断是否回调onUserLeaving函数的。

接着判断doResume是否为false，如果为false的话，说明需要延迟resume，则将r.delayedResume设置为true，接着判断launchFlags中是否有FLAG_ACTIVITY_PREVIOUS_IS_TOP，如果有的话，那么则将notTop置为r，否则为null

// If the onlyIfNeeded flag is set, then we can do this if the activity        // being launched is the same as the one making the call...  or, as        // a special case, if we do not know the caller then we count the        // current top activity as the caller.        if ((startFlags&ActivityManager.START_FLAG_ONLY_IF_NEEDED) != 0) {            ActivityRecord checkedCaller = sourceRecord;            if (checkedCaller == null) {                checkedCaller = topRunningNonDelayedActivityLocked(notTop);            }            if (!checkedCaller.realActivity.equals(r.realActivity)) {                // Caller is not the same as launcher, so always needed.                startFlags &= ~ActivityManager.START_FLAG_ONLY_IF_NEEDED;            }        }        if (sourceRecord == null) {            // This activity is not being started from another...  in this            // case we -always- start a new task.            if ((launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK) == 0) {                Slog.w(TAG, "startActivity called from non-Activity context; forcing Intent.FLAG_ACTIVITY_NEW_TASK for: "                      + intent);                launchFlags |= Intent.FLAG_ACTIVITY_NEW_TASK;            }        } else if (sourceRecord.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE) {            // The original activity who is starting us is running as a single            // instance...  this new activity it is starting must go on its            // own task.            launchFlags |= Intent.FLAG_ACTIVITY_NEW_TASK;        } else if (r.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE                || r.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK) {            // The activity being started is a single instance...  it always            // gets launched into its own task.            launchFlags |= Intent.FLAG_ACTIVITY_NEW_TASK;        }        if (r.resultTo != null && (launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK) != 0) {            // For whatever reason this activity is being launched into a new            // task...  yet the caller has requested a result back.  Well, that            // is pretty messed up, so instead immediately send back a cancel            // and let the new task continue launched as normal without a            // dependency on its originator.            Slog.w(TAG, "Activity is launching as a new task, so cancelling activity result.");            sendActivityResultLocked(-1,                    r.resultTo, r.resultWho, r.requestCode,                Activity.RESULT_CANCELED, null);            r.resultTo = null;        }

接着判断startFlags中是否有START_FLAG_ONLY_IF_NEED标志位，那么就会检查调用者的ActivityRecord与要启动的Activity是否是同一个，如果不是同一个的话，那么就将这个START_FLAG_ONLY_IF_NEEDED的标识取消掉。

接着判断sourceRecord是否为空，如果sourceRecord为空的话，那么则会将Intent的launchFlags添加上Intent.FLAG_ACTIVITY_NEW_TASK

如果sourceRecord不为空，那么则判断sourceRecord的LaunchMode是否为SINGLE_INSTANCE，如果是的话，也将launchFlags添上Intent.FLAG_ACTIVITY_NEW_TASK

如果sourceRecord的launchMode不是SINGLE_INSTANCE的话，则判断要启动的Activity是否是SINGLE_INSTANCE或者SINGLE_TASK的，如果是的话，那么将launchFlags添加上Intent.FLAG_ACTIVITY_NEW_TASK

接着判断要启动的Activity的resultTo是否为空，如果不为空而且launchFlags中有Intent.FLAG_ACTIVITY_NEW_TASK的话，那么就将要启动的Activity的resultTo设为null，并且发送取消的消息给调用者的Activity，因为Android不允许两个Task之间通信。

boolean addingToTask = false;        boolean movedHome = false;        TaskRecord reuseTask = null;        if (((launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK) != 0 &&                (launchFlags&Intent.FLAG_ACTIVITY_MULTIPLE_TASK) == 0)                || r.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK                || r.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE) {            // If bring to front is requested, and no result is requested, and            // we can find a task that was started with this same            // component, then instead of launching bring that one to the front.            if (r.resultTo == null) {                // See if there is a task to bring to the front.  If this is                // a SINGLE_INSTANCE activity, there can be one and only one                // instance of it in the history, and it is always in its own                // unique task, so we do a special search.                ActivityRecord taskTop = r.launchMode != ActivityInfo.LAUNCH_SINGLE_INSTANCE                        ? findTaskLocked(intent, r.info)                        : findActivityLocked(intent, r.info);                if (taskTop != null) {                    if (taskTop.task.intent == null) {                        // This task was started because of movement of                        // the activity based on affinity...  now that we                        // are actually launching it, we can assign the                        // base intent.                        taskTop.task.setIntent(intent, r.info);                    }                    // If the target task is not in the front, then we need                    // to bring it to the front...  except...  well, with                    // SINGLE_TASK_LAUNCH it's not entirely clear.  We'd like                    // to have the same behavior as if a new instance was                    // being started, which means not bringing it to the front                    // if the caller is not itself in the front.                    ActivityRecord curTop = topRunningNonDelayedActivityLocked(notTop);                    if (curTop != null && curTop.task != taskTop.task) {                        r.intent.addFlags(Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT);                        boolean callerAtFront = sourceRecord == null                                || curTop.task == sourceRecord.task;                        if (callerAtFront) {                            // We really do want to push this one into the                            // user's face, right now.                            movedHome = true;                            moveHomeToFrontFromLaunchLocked(launchFlags);                            moveTaskToFrontLocked(taskTop.task, r, options);                            options = null;                        }                    }                    // If the caller has requested that the target task be                    // reset, then do so.                    if ((launchFlags&Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED) != 0) {                        taskTop = resetTaskIfNeededLocked(taskTop, r);                    }                    if ((startFlags&ActivityManager.START_FLAG_ONLY_IF_NEEDED)  != 0) {                        // We don't need to start a new activity, and                        // the client said not to do anything if that                        // is the case, so this is it!  And for paranoia, make                        // sure we have correctly resumed the top activity.                        if (doResume) {                            resumeTopActivityLocked(null, options);                        } else {                            ActivityOptions.abort(options);                        }                        return ActivityManager.START_RETURN_INTENT_TO_CALLER;                    }                    if ((launchFlags &                            (Intent.FLAG_ACTIVITY_NEW_TASK|Intent.FLAG_ACTIVITY_CLEAR_TASK))                            == (Intent.FLAG_ACTIVITY_NEW_TASK|Intent.FLAG_ACTIVITY_CLEAR_TASK)) {                        // The caller has requested to completely replace any                        // existing task with its new activity.  Well that should                        // not be too hard...                        reuseTask = taskTop.task;                        performClearTaskLocked(taskTop.task.taskId);                        reuseTask.setIntent(r.intent, r.info);                    } else if ((launchFlags&Intent.FLAG_ACTIVITY_CLEAR_TOP) != 0                            || r.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK                            || r.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE) {                        // In this situation we want to remove all activities                        // from the task up to the one being started.  In most                        // cases this means we are resetting the task to its                        // initial state.                        ActivityRecord top = performClearTaskLocked(                                taskTop.task.taskId, r, launchFlags);                        if (top != null) {                            if (top.frontOfTask) {                                // Activity aliases may mean we use different                                // intents for the top activity, so make sure                                // the task now has the identity of the new                                // intent.                                top.task.setIntent(r.intent, r.info);                            }                            logStartActivity(EventLogTags.AM_NEW_INTENT, r, top.task);                            top.deliverNewIntentLocked(callingUid, r.intent);                        } else {                            // A special case: we need to                            // start the activity because it is not currently                            // running, and the caller has asked to clear the                            // current task to have this activity at the top.                            addingToTask = true;                            // Now pretend like this activity is being started                            // by the top of its task, so it is put in the                            // right place.                            sourceRecord = taskTop;                        }                    } else if (r.realActivity.equals(taskTop.task.realActivity)) {                        // In this case the top activity on the task is the                        // same as the one being launched, so we take that                        // as a request to bring the task to the foreground.                        // If the top activity in the task is the root                        // activity, deliver this new intent to it if it                        // desires.                        if ((launchFlags&Intent.FLAG_ACTIVITY_SINGLE_TOP) != 0                                && taskTop.realActivity.equals(r.realActivity)) {                            logStartActivity(EventLogTags.AM_NEW_INTENT, r, taskTop.task);                            if (taskTop.frontOfTask) {                                taskTop.task.setIntent(r.intent, r.info);                            }                            taskTop.deliverNewIntentLocked(callingUid, r.intent);                        } else if (!r.intent.filterEquals(taskTop.task.intent)) {                            // In this case we are launching the root activity                            // of the task, but with a different intent.  We                            // should start a new instance on top.                            addingToTask = true;                            sourceRecord = taskTop;                        }                    } else if ((launchFlags&Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED) == 0) {                        // In this case an activity is being launched in to an                        // existing task, without resetting that task.  This                        // is typically the situation of launching an activity                        // from a notification or shortcut.  We want to place                        // the new activity on top of the current task.                        addingToTask = true;                        sourceRecord = taskTop;                    } else if (!taskTop.task.rootWasReset) {                        // In this case we are launching in to an existing task                        // that has not yet been started from its front door.                        // The current task has been brought to the front.                        // Ideally, we'd probably like to place this new task                        // at the bottom of its stack, but that's a little hard                        // to do with the current organization of the code so                        // for now we'll just drop it.                        taskTop.task.setIntent(r.intent, r.info);                    }                    if (!addingToTask && reuseTask == null) {                        // We didn't do anything...  but it was needed (a.k.a., client                        // don't use that intent!)  And for paranoia, make                        // sure we have correctly resumed the top activity.                        if (doResume) {                            resumeTopActivityLocked(null, options);                        } else {                            ActivityOptions.abort(options);                        }                        return ActivityManager.START_TASK_TO_FRONT;                    }                }            }        }

声明三个变量，addingToTask，moveHome，reuseTask。判断launchFlags中存在的Intent.FLAG_ACTIVITY_NEW_TASK，并且没有Intent.FLAG_ACTIVITY_MULTIPLE_TASK或者要启动的Activity是SINGLE_TASK或者SINGLE_INSTANCE的话，那么就会执行上面的逻辑，否则则不会。

判断r.resultTo是否为空，如果为空的话才执行下面代码，否则不执行。

接着通过r.launchMode来找到当前位于Task顶部的Activty，如果是SINGLE_INSTANCE的话，那么就找到Activity，否则则是找到Task顶部的Activity。接着判断taskTop是否为null，如果为Null的话，说明没有启动过这个Activity或者是没有创建过这个TASK，否则就将intent设置到对应的Task中。

接着得到整个ActivityTask最上面的那个ActivityRecord，如果当前最上面的Activity的task和要启动的Activity的Task不一样的话，那么将launchFlags添加Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT，接着判断sourceRecord是否为null，如果不为null并且sourceRecord与curTop的Task一致的话，那么说明，调用者Activity正在最上层显示，那么此时因为两个Activity的Task不一样，所以就会调用moveTaskToFrontLocked将目标Task整个移动到最上面。

接着判断launchFlag中是否有FLAG_ACTIVITY_RESET_TASK_IF_NEEDED，如果有的话，则调用resetTaskIfNeededLocked，然后重新计算出当前Task的顶部Activity，然后赋值给taskTop。

接着判断startFlags是否有START_FLAG_ONLY_IF_NEEDED，判断当前要启动的Activity是否启动新的Activity，如果标志位设成true的话，那么就调用resumeTopActivity(null)启动顶部的Activity，也就是什么都不做。

然后判断：launchFlags是否有FLAG_ACTIVITY_NEW_TASK和FLAG_ACTIVITY_CLEAR_TASK，如果有的话，那么就会将reuseTask被赋值成为taskTop.task，也就是说，新运行的这个Activity将重用这个Task，并且调用performClearTaskLocked，然后将Task中的Activity全部清空。否则判断launchFlags中是否有FLAG_ACTIVITY_CLEAR_TOP，或者要启动的Activity的launchMode是否为SINGLE_TASK或者SINGLE_INSTANCE的，如果是的话，那么清掉Task中的Activity，并且找到位于Task中的Activity，如果是一样的话，那么则返回top，也就是说，如果ABCDE，那么从E要启动C，并且C是SINGLE_TASK的话，那么就会清掉DE，然后得到的top就是C了，然后判断top是否为空，如果不为空的话，那么就会调用top.deliverNewIntentLocked回调C的onNewIntent函数，如果不存在的话，那么就将addingToTask设成true，表示要添加到这个Task中，并且将sourceRecord设置成为TaskTop。

否则则判断，launchFlags是否有FLAG_ACTIVITY_RESET_TASK_IF_NEEDED，如果有的话那么设置addingTask=true，并且将sourceRecord设置成taskTop。

最后判断，addingTask是否为false，并且reuseTask是否为null，如果addingTask为false，代表不添加到Task中，而reuseTask为null，代表无重用的Task，那么就直接调用resumeTopActivityLocked

  if (r.packageName != null) {            // If the activity being launched is the same as the one currently            // at the top, then we need to check if it should only be launched            // once.            ActivityRecord top = 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                            || r.launchMode == ActivityInfo.LAUNCH_SINGLE_TOP                            || r.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK) {                            logStartActivity(EventLogTags.AM_NEW_INTENT, top, top.task);                            // For paranoia, make sure we have correctly                            // resumed the top activity.                            if (doResume) {                                resumeTopActivityLocked(null);                            }                            ActivityOptions.abort(options);                            if ((startFlags&ActivityManager.START_FLAG_ONLY_IF_NEEDED) != 0) {                                // We don't need to start a new activity, and                                // the client said not to do anything if that                                // is the case, so this is it!                                return ActivityManager.START_RETURN_INTENT_TO_CALLER;                            }                            top.deliverNewIntentLocked(callingUid, r.intent);                            return ActivityManager.START_DELIVERED_TO_TOP;                        }                    }                }            }        } else {            if (r.resultTo != null) {                sendActivityResultLocked(-1,                        r.resultTo, r.resultWho, r.requestCode,                    Activity.RESULT_CANCELED, null);            }            ActivityOptions.abort(options);            return ActivityManager.START_CLASS_NOT_FOUND;        }

判断要启动的Activity的包名是否为空，如果不为空的话，那么得到mHistory最顶部的ActivityRecord，接着判断当前顶部的Activity与要启动的Activity是否相同，并且Activity的进程以及ApplicationThread不为空，接着如果判断launchFlags为FLAG_ACTIVITY_SINGLE_TOP或者LaunchMode为SINGLE_TOP或者SINGLE_TASK的话，那么就调用resumeTopActivityLocked，并且调用top.deliverNewIntentLocked回调Activity的onNewIntent。否则如果包名为空，那么返回CLASS_NOT_FOUND结果。

boolean newTask = false;        boolean keepCurTransition = false;        // Should this be considered a new task?        if (r.resultTo == null && !addingToTask                && (launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK) != 0) {            if (reuseTask == null) {                // todo: should do better management of integers.                mService.mCurTask++;                if (mService.mCurTask <= 0) {                    mService.mCurTask = 1;                }                r.setTask(new TaskRecord(mService.mCurTask, r.info, intent), null, true);                if (DEBUG_TASKS) Slog.v(TAG, "Starting new activity " + r                        + " in new task " + r.task);            } else {                r.setTask(reuseTask, reuseTask, true);            }            newTask = true;            if (!movedHome) {                moveHomeToFrontFromLaunchLocked(launchFlags);            }                    } else if (sourceRecord != null) {            if (!addingToTask &&                    (launchFlags&Intent.FLAG_ACTIVITY_CLEAR_TOP) != 0) {                // In this case, we are adding the activity to an existing                // task, but the caller has asked to clear that task if the                // activity is already running.                ActivityRecord top = performClearTaskLocked(                        sourceRecord.task.taskId, r, launchFlags);                keepCurTransition = true;                if (top != null) {                    logStartActivity(EventLogTags.AM_NEW_INTENT, r, top.task);                    top.deliverNewIntentLocked(callingUid, r.intent);                    // For paranoia, make sure we have correctly                    // resumed the top activity.                    if (doResume) {                        resumeTopActivityLocked(null);                    }                    ActivityOptions.abort(options);                    return ActivityManager.START_DELIVERED_TO_TOP;                }            } else if (!addingToTask &&                    (launchFlags&Intent.FLAG_ACTIVITY_REORDER_TO_FRONT) != 0) {                // In this case, we are launching an activity in our own task                // that may already be running somewhere in the history, and                // we want to shuffle it to the front of the stack if so.                int where = findActivityInHistoryLocked(r, sourceRecord.task.taskId);                if (where >= 0) {                    ActivityRecord top = moveActivityToFrontLocked(where);                    logStartActivity(EventLogTags.AM_NEW_INTENT, r, top.task);                    top.updateOptionsLocked(options);                    top.deliverNewIntentLocked(callingUid, r.intent);                    if (doResume) {                        resumeTopActivityLocked(null);                    }                    return ActivityManager.START_DELIVERED_TO_TOP;                }            }            // An existing activity is starting this new activity, so we want            // to keep the new one in the same task as the one that is starting            // it.            r.setTask(sourceRecord.task, sourceRecord.thumbHolder, false);            if (DEBUG_TASKS) Slog.v(TAG, "Starting new activity " + r                    + " in existing task " + r.task);        } else {            // This not being started from an existing activity, and not part            // of a new task...  just put it in the top task, though these days            // this case should never happen.            final int N = mHistory.size();            ActivityRecord prev =                N > 0 ? mHistory.get(N-1) : null;            r.setTask(prev != null                    ? prev.task                    : new TaskRecord(mService.mCurTask, r.info, intent), null, true);            if (DEBUG_TASKS) Slog.v(TAG, "Starting new activity " + r                    + " in new guessed " + r.task);        }

创建两个变量，newTask以及keepCurTransition，newTask标识着是否需要创建一个新的Task：

1.判断r.resultTo是否为null，如果为null，并且addingToTask为false，launchFlag被置为FLAG_ACTIVITY_NEW_TASK的话，然后判断reuseTask是否为空，如果为空的话，说明没有可以重用的Task，那么就需要创建一个新的Task，如果reuseTask不为空的话，那么说明有重用的Task，那么就直接设置Task即可。然后判断moveHome，如果moveHome为false的话，那么就会调用moveHomeToFrontLaunchLocked

2.否则判断sourceReocrd是否为空，如果不为空的话，那么判断addingToTask是否为false，并且launchFlags中是否有FLAG_ACTIVITY_CLEAR_TOP，如果存在的话，那么就调用performClearTaskLocked函数，清除掉Task上面的Activity，然后得到Task的顶部的Activity，如果该Activity不为空的话，那么就会调用top.delieverNewIntentLocked，回调onNewIntent

3.否则判断addingToTask是否为false，并且launcFlag是否为FLAG_ACTIVITY_REORDER_TO_FRONT，如果存在该标志位的话，接着通过findActivityInHistoryLocked得到与TaskID还有r相同的ActivityRecord，如果相同的话，那么则返回Activity的Index，如果index大于等于0的话，那么就会将Activity移到History的顶部，然后回调onNewIntent，然后设置它的Task。

4.否则得到mHistory最顶部的Activity，如果Activity是否为null，如果不为null的话，那么就设置r.taskId为Activity的ID，如果为null的话，那么就创建一个新的TaskRecord，然后通过r.setTask设置进去。