Activity正常启动过程

startActivity方法会调用startActivityForResult方法。

public void startActivityForResult(
        String who, Intent intent, int requestCode, @Nullable Bundle options) {
    Uri referrer = onProvideReferrer();
    if (referrer != null) {
        intent.putExtra(Intent.EXTRA_REFERRER, referrer);
    }
    options = transferSpringboardActivityOptions(options);
    Instrumentation.ActivityResult ar =
        mInstrumentation.execStartActivity(
            this, mMainThread.getApplicationThread(), mToken, who,
            intent, requestCode, options);
    if (ar != null) {
        mMainThread.sendActivityResult(
            mToken, who, requestCode,
            ar.getResultCode(), ar.getResultData());
    }
    cancelInputsAndStartExitTransition(options);
}

可以看到是Instrumentation的execStartActivity方法启动一个Activity。Instrumentation是什么?用来监督应用程序和系统的交互的一个类，看看这个方法的参数。

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

源Activity是指调用了startActivity开启一个新Activity的Activity。

Instrumentation的execStartActivity方法参数

Context who Activity上下文环境

IBinder contextThread 这里传的是源Activity的ActivityThread内部的ApplicationThread对象,ApplicationThread是一个Binder本地对象，传过去是为了ActivityManagerService能够调用ApplicationThread实现的IPC接口方法。

IBinder Taken 这里传的是AMS传给源Activity的Binder代理对象,类型是ActivityRecord里的Token。每一个启动的Activity组件在AMS中都有一个对应的ActivityRecord对象。这样就能在AMS里找到源Activity的详细信息。

Activity target 这里传的是源Activity

Intent intent  传的是启动Activty的意图。

int requestcode 返回结果给源Activity的请求码，为-1则不返回结果。

Bundle options 将源Activity和新Activity之间的过渡动画ActivityOptions封装成Bundle对象传过来。

在execStartActivity又调用了ActivityManagerNatvie类的静态getDefault函数获得AMS的代理服务对象，进而调用AMS的startActivity方法

static public IActivityManager getDefault() {
    return gDefault.get();
}

private static final Singleton<IActivityManager> gDefault = new Singleton<IActivityManager>() {
    protected IActivityManager create() {
        IBinder b = ServiceManager.getService("activity");
        if (false) {
            Log.v("ActivityManager", "default service binder = " + b);
        }
        IActivityManager am = asInterface(b);
        if (false) {
            Log.v("ActivityManager", "default service = " + am);
        }
        return am;
    }
};

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

看下AMS的startActivity参数,很多参数,重点关注三个

IApplicationThread caller 指向源Activity的进程里的ApplicationThread对象。

intent 包含了启动的Activity的信息

ActivityRecord resultTo AMS传给源Activity的Binder代理对象,类型是ActivityRecord中的Token,

startActivity调用了startActivityAsUser方法.

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

startActivityAsUser又调用了ActivityStarter的startActivityMayWait方法

mActivityStarter.startActivityMayWait(caller, -1, callingPackage, intent,
        resolvedType, null, null, resultTo, resultWho, requestCode, startFlags,
        profilerInfo, null, null, bOptions, false, userId, null, null);

startActivityMayWait方法里关注两步，第一步调用ActivityStackSupervisor的resolveIntent和resolveActivity方法得到更多关于启动的Activity组件的信息(实际上是通过PackageManagerService)，第二步就是调用了startActivityLocked方法。

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, IActivityManager.WaitResult outResult, Configuration config,
        Bundle bOptions, boolean ignoreTargetSecurity, int userId,
        IActivityContainer iContainer, TaskRecord inTask) {
        ResolveInfo rInfo = mSupervisor.resolveIntent(intent, resolvedType, userId);
        ActivityInfo aInfo = mSupervisor.resolveActivity(intent, rInfo, startFlags, profilerInfo);
        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);

在startActivityLocked方法里,主要是三步，第一步通过AMS获得一个ProcessRecord，在AMS中每一个应用程序进程都用一个ProcessRecord对象描述，所以ProcessRecord指向源Activity的进程,接下来获得进程的PID和UID，第二步通过ActivityStackSupervisor和Token对象resultTo得到源Activity在AMS中对应的ActivityRecord。最后一步创建新的ActivityRecord,作为新启动的Activity在AMS对应的ActivityRecord,调用startActivityUnChecked方法。

final int startActivityLocked(IApplicationThread caller, Intent intent, Intent ephemeralIntent,
        String resolvedType, ActivityInfo aInfo, ResolveInfo rInfo,
        IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
        IBinder resultTo, String resultWho, int requestCode, int callingPid, int callingUid,
        String callingPackage, int realCallingPid, int realCallingUid, int startFlags,
        ActivityOptions options, boolean ignoreTargetSecurity, boolean componentSpecified,
        ActivityRecord[] outActivity, ActivityStackSupervisor.ActivityContainer container,
        TaskRecord inTask) {
        int err = ActivityManager.START_SUCCESS;

        ProcessRecord callerApp = null;
        if (caller != null) {
            callerApp = mService.getRecordForAppLocked(caller);
            if (callerApp != null) {
                callingPid = callerApp.pid;
                callingUid = callerApp.info.uid;
            }
            ActivityRecord sourceRecord = null;
            ActivityRecord resultRecord = null;
            if (resultTo != null) {
                sourceRecord = mSupervisor.isInAnyStackLocked(resultTo);
                if (DEBUG_RESULTS) Slog.v(TAG_RESULTS,
                        "Will send result to " + resultTo + " " + sourceRecord);
                if (sourceRecord != null) {
                    if (requestCode >= 0 && !sourceRecord.finishing) {
                        resultRecord = sourceRecord;
                    }
                }
            }
        }
    ActivityRecord r = new ActivityRecord(mService, callerApp, callingUid, callingPackage,
            intent, resolvedType, aInfo, mService.mConfiguration, resultRecord, resultWho,
            requestCode, componentSpecified, voiceSession != null, mSupervisor, container,
            options, sourceRecord);
    err = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor, startFlags,
            true, options, inTask);
}

startActivityUnChecked主要是处理Activity的四种启动模式，对于ActivityStack的操作。这个函数涉及内容较多，暂不细究，setInitalState和computeLanchingTaskFlags都是处理Activity组件的启动标志位,coputeSourceStack处理源Activity被finsh的情况。然后设置mIntent的启动标识位。通过一系列的判断是否采用新的ActivityStack,还是采用原本的ActivityStack,得到mTargetStack,然后调用ActivityStack的startActivityLocked方法将新启动的Activity对应的TaskRecord放在栈顶。最后调用ActivityStackSupervisor的resumeFocusedStackTopActivityLocked方法激活栈顶的Activity组件。

private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
                                   IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
                                   int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask) {

    setInitialState(r, options, inTask, doResume, startFlags, sourceRecord, voiceSession,
            voiceInteractor);

    computeLaunchingTaskFlags();

    computeSourceStack();

    mIntent.setFlags(mLaunchFlags);
    mTargetStack.startActivityLocked(mStartActivity, newTask, mKeepCurTransition, mOptions);
    mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack, mStartActivity,
            mOptions);
}

ActivityStackSupervisor的resumeFocusedStackTopActivityLocked调用了ActivityStack的resumeTopActivityUnCheckedLocked方法

boolean resumeFocusedStackTopActivityLocked(
        ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
        if (targetStack != null && isFocusedStack(targetStack)) {
        return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
        }
final ActivityRecord r = mFocusedStack.topRunningActivityLocked();
        if (r == null || r.state != RESUMED) {
        mFocusedStack.resumeTopActivityUncheckedLocked(null, null);
        }
        return false;
        }

ActivityStack的resumeTopActivityUnCheckedLocked方法里又调用了resumeTopActivityInnerLocked方法

boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
    if (mStackSupervisor.inResumeTopActivity) {
        // Don't even start recursing.
        return false;
    }

    boolean result = false;
    try {
        // Protect against recursion.
        mStackSupervisor.inResumeTopActivity = true;
        if (mService.mLockScreenShown == ActivityManagerService.LOCK_SCREEN_LEAVING) {
            mService.mLockScreenShown = ActivityManagerService.LOCK_SCREEN_HIDDEN;
            mService.updateSleepIfNeededLocked();
        }
        result = resumeTopActivityInnerLocked(prev, options);
    } finally {
        mStackSupervisor.inResumeTopActivity = false;
    }
    return result;
}

ActivityStack的resumeTopActivityInnerLocked方法又调用了ActivityStack的startPausingLocked方法。让源Activity进入停止状态。useLeaving表示用户离开事件通知,这个与前面的启动标志位中的FLAT_ACTIVITY_NO_USER_ACTION是相关联的，FLAT_ACTIVITY_NO_USER_ACTION表示是否由用户手动启动,为1为手动，userLeaving为true。为0不为手动，userLeaviing为false。next是即将启动的Activity的ActivityRecord,第二个参数表示屏幕是否进入休眠。

if (mResumedActivity != null) {
        if (DEBUG_STATES) Slog.d(TAG_STATES,
        "resumeTopActivityLocked: Pausing " + mResumedActivity);
        pausing |= startPausingLocked(userLeaving, false, next, dontWaitForPause);
        }

final boolean dontWaitForPause = (next.info.flags & FLAG_RESUME_WHILE_PAUSING) != 0;

startPausingLocked方法里又远程调用ApplicationThread的方法schedulePauseActivity,perv是源Activity对应的ActivityRecord,app成员是ProcessRecord对象,thread是ApplicationThread对象。并将mResumedActivity赋值为空。

prev.app.thread.schedulePauseActivity(prev.appToken, prev.finishing,
        userLeaving, prev.configChangeFlags, dontWait);

除此之外，startPausingLocked方法里向AMS的handler发送一个延时消息，如果没在规定时间内完成源activity进入pause状态，就会发送出去。

   if (dontWait) {
    // If the caller said they don't want to wait for the pause, then complete
    // the pause now.
    completePauseLocked(false, resuming);
    return false;

} else {
    // Schedule a pause timeout in case the app doesn't respond.
    // We don't give it much time because this directly impacts the
    // responsiveness seen by the user.
    Message msg = mHandler.obtainMessage(PAUSE_TIMEOUT_MSG);
    msg.obj = prev;
    prev.pauseTime = SystemClock.uptimeMillis();
    mHandler.sendMessageDelayed(msg, PAUSE_TIMEOUT);

ApplicationThread的schedulePauseActivity又调用了sendMessage方法，

public final void schedulePauseActivity(IBinder token, boolean finished,
                                        boolean userLeaving, int configChanges, boolean dontReport) {
    int seq = getLifecycleSeq();
    if (DEBUG_ORDER) Slog.d(TAG, "pauseActivity " + ActivityThread.this
            + " operation received seq: " + seq);
    sendMessage(
            finished ? H.PAUSE_ACTIVITY_FINISHING : H.PAUSE_ACTIVITY,
            token,
            (userLeaving ? USER_LEAVING : 0) | (dontReport ? DONT_REPORT : 0),
            configChanges,
            seq);
}

sendMessage方法取得一个Message初始化好发给Handler。

private void sendMessage(int what, Object obj, int arg1, int arg2, int seq) {
    if (DEBUG_MESSAGES) Slog.v(
            TAG, "SCHEDULE " + mH.codeToString(what) + " arg1=" + arg1 + " arg2=" + arg2 +
                    "seq= " + seq);
    Message msg = Message.obtain();
    msg.what = what;
    SomeArgs args = SomeArgs.obtain();
    args.arg1 = obj;
    args.argi1 = arg1;
    args.argi2 = arg2;
    args.argi3 = seq;
    msg.obj = args;
    mH.sendMessage(msg);
}

mH处理H_PAUSE_ACTIVITY类型的消息。调用了handlePasueActivity方法

case PAUSE_ACTIVITY: {
        Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityPause");
        SomeArgs args = (SomeArgs) msg.obj;
        handlePauseActivity((IBinder) args.arg1, false,
        (args.argi1 & USER_LEAVING) != 0, args.argi2,
        (args.argi1 & DONT_REPORT) != 0, args.argi3);
        maybeSnapshot();
        Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
        } break;

handlePauseAcivity方法分为四步，第一步调用performLeavingActivity向源Activity发送一个用户离开事件,调用Activity的onUserLeaveHint方法。第二步调用performPauseActivity向源Activity发送一个中止事件通知，调用Activity的onPause方法,并且会调用Activity的performsaveInState方法(版本在API11以下,且源Activity未finish掉)，进而调用onsaveInstate方法，第三步调用QueuedWork的静态waitToFinish方法,等待完成前面的数据写入操作。第四步通知AMS源Activity已进入pause状态。调用AMS的activitypause方法

private void handlePauseActivity(IBinder token, boolean finished,
                                 boolean userLeaving, int configChanges, boolean dontReport, int seq) {
    ActivityClientRecord r = mActivities.get(token);
    if (DEBUG_ORDER) Slog.d(TAG, "handlePauseActivity " + r + ", seq: " + seq);
    if (!checkAndUpdateLifecycleSeq(seq, r, "pauseActivity")) {
        return;
    }
    if (r != null) {
        //Slog.v(TAG, "userLeaving=" + userLeaving + " handling pause of " + r);
        if (userLeaving) {
            performUserLeavingActivity(r);
        }

        r.activity.mConfigChangeFlags |= configChanges;
        performPauseActivity(token, finished, r.isPreHoneycomb(), "handlePauseActivity");

        // Make sure any pending writes are now committed.
        if (r.isPreHoneycomb()) {
            QueuedWork.waitToFinish();
        }

        // Tell the activity manager we have paused.
        if (!dontReport) {
            try {
                ActivityManagerNative.getDefault().activityPaused(token);
            } catch (RemoteException ex) {
                throw ex.rethrowFromSystemServer();
            }
        }
        mSomeActivitiesChanged = true;
    }
}

AMS的activityPaused方法调用了ActivityStack的activityPausedLocked方法。

ActivityStack stack = ActivityRecord.getStackLocked(token);
          if (stack != null) {
    stack.activityPausedLocked(token, false);
}

ActivityStack的activityPausedLocked方法里移除了startPausingLocked向AMS的Handler发送的延迟消息。并调用completePausedLocked方法。

final ActivityRecord r = isInStackLocked(token);
  if (r != null) {
mHandler.removeMessages(PAUSE_TIMEOUT_MSG, r);
completePauseLocked(true, null);

ActivityStack的completePausedLocked方法调用了ActivityStackSupervisor的resumeFocusedStackTopActivityLocked方法.

mStackSupervisor.resumeFocusedStackTopActivityLocked(topStack, prev, null);

在resumeFocusedStackTopActivityLocked方法里又调用了ActivityStack的resumeTopActivityUncheckedLocked方法，resumeTopActivityUncheckedLocked方法又调用了resumeTopActivityInnerLocked方法与前面一样。但是这次由于mResumeActivity在startPausingLocked方法中被置空,所以最后会调用ActivityStackSuperviosr的startSpecificActivityLocked方法。

return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);

在ActivityStackSupervisor的startSpecificActivityLocked方法里分两种情况处理，一种是还没有Activity对应的进程出现，从luanch组件开启activity就是这种情况。这时需要走ActivityManagerService的startProcessLocked方法。另一种是Activity对应的进程已经出现了,就直接调用realStartActivityLocked方法。那么如何判断是否有对应的进程出现，在AMS中每个Activity都有一个用户ID和一个进程名称，用户ID在安装Activity时被PMS分配的,进程名称则是Activity的process属性决定,默认为包名,调用AMS的getProcessRecordLocked()遍历所有的ProcessRecord看有没有符合的。前一种最终还是要调realStartActivityLocked方法，不过在这之前要创建一个进程。所以从startProcessLocked创建一个进程开始。

void startSpecificActivityLocked(ActivityRecord r,
                                 boolean andResume, boolean checkConfig) {
    // Is this activity's application already running?
    ProcessRecord app = mService.getProcessRecordLocked(r.processName,
            r.info.applicationInfo.uid, true);

    r.task.stack.setLaunchTime(r);

    if (app != null && app.thread != null) {
        try {
            if ((r.info.flags&ActivityInfo.FLAG_MULTIPROCESS) == 0
                    || !"android".equals(r.info.packageName)) {
                // Don't add this if it is a platform component that is marked
                // to run in multiple processes, because this is actually
                // part of the framework so doesn't make sense to track as a
                // separate apk in the process.
                app.addPackage(r.info.packageName, r.info.applicationInfo.versionCode,
                        mService.mProcessStats);
            }
            realStartActivityLocked(r, app, andResume, checkConfig);
            return;
        } catch (RemoteException e) {
            Slog.w(TAG, "Exception when starting activity "
                    + r.intent.getComponent().flattenToShortString(), e);
        }

        // If a dead object exception was thrown -- fall through to
        // restart the application.
    }

    mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,
            "activity", r.intent.getComponent(), false, false, true);
}

startProcessLocked方法先生成一个ProcessRecord,再调用另一个重载的startProcessLocked方法

app = newProcessRecordLocked(info, processName, isolated, isolatedUid);
startProcessLocked(
        app, hostingType, hostingNameStr, abiOverride, entryPoint, entryPointArgs);
startProcessLocked(
        app, hostingType, hostingNameStr, abiOverride, entryPoint, entryPointArgs);

重载的startProcessLocked方法调用了Process的start方法开启一个进程,并将返回的ProcessRecord对象保存在mPidSelfLocked中。

if (entryPoint == null) entryPoint = "android.app.ActivityThread";
startResult = Process.start(entryPoint,
app.processName, uid, uid, gids, debugFlags, mountExternal,
app.info.targetSdkVersion, app.info.seinfo, requiredAbi, instructionSet,
app.info.dataDir, invokeWith, entryPointArgs);
this.mPidsSelfLocked.put(startResult.pid, app);

Process的start方法间接调用ActivityThread.的静态main方法。这个过程见另一篇应用程序进程的启动过程。看看main方法中做了什么?创建一个ActivityThread对象,它的handler作为主线程的handler,并调用attach方法向AMS发送一个启动通知,为当前进程的线程创建一个消息循环，然后进入消息循环中。

Looper.prepareMainLooper(); 

        ActivityThread thread = new ActivityThread();
        thread.attach(false);

        if (sMainThreadHandler == null) {
        sMainThreadHandler = thread.getHandler();
        }
        Looper.loop();

ActivityThread的attach方法中调用AMS的attachApplication方法。

final IActivityManager mgr = ActivityManagerNative.getDefault();
        try {
                mgr.attachApplication(mAppThread);

AMS的attachAppllication方法进而调用了自己的attachApplicationLocked方法，attachApplicationLocked方法中取出startProcessLocked方法中保存的ProcessRecord对象，完善ProcessRecord对象信息，移除启动进程超时延迟消息,调用ActivityStackSupervisor的attachApplicationLocked方法。

app = mPidsSelfLocked.get(pid);
        app.makeActive(thread, mProcessStats);
        app.curAdj = app.setAdj = app.verifiedAdj = ProcessList.INVALID_ADJ;
        app.curSchedGroup = app.setSchedGroup = ProcessList.SCHED_GROUP_DEFAULT;
        app.forcingToForeground = null;
        updateProcessForegroundLocked(app, false, false);
        app.hasShownUi = false;
        app.debugging = false;
        app.cached = false;
        app.killedByAm = false;
        app.killed = false;
        mHandler.removeMessages(PROC_START_TIMEOUT_MSG, app);
        // See if the top visible activity is waiting to run in this process...
        if (normalMode) {
        try {
        if (mStackSupervisor.attachApplicationLocked(app)) {
        didSomething = true;
        }

ActivityStackSupervisir的attachApplicationLocked方法取出栈顶的ActivityRecord，调用realStartActivityLocked方法。

ActivityRecord hr = stack.topRunningActivityLocked();
            if (hr != null) {
                    if (hr.app == null && app.uid == hr.info.applicationInfo.uid
                    && processName.equals(hr.processName)) {
                    try {
                    if (realStartActivityLocked(hr, app, true, true)) {
                    didSomething = true;
                    }

realStartActivityLocked方法做了两件事，首先将新的ActivityRecord r加入到ProcessRecord的ActivityRecord列表中,然后调用ProcessRecord的ApplicationThread的scheduleLanchActivity方法,这是个IPC调用,后面就到了应用进程中完成Activity的启动。

int idx = app.activities.indexOf(r);
    if (idx < 0) {
    app.activities.add(r);
    }
    app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,
    System.identityHashCode(r), r.info, new Configuration(mService.mConfiguration),
    new Configuration(task.mOverrideConfig), r.compat, r.launchedFromPackage,
    task.voiceInteractor, app.repProcState, r.icicle, r.persistentState, results,
    newIntents, !andResume, mService.isNextTransitionForward(), profilerInfo);

ApplicatonThread的scheduleLaunchActivity方法。IApplicationThread也是个IPC接口,调用的是ApplicationThreadNatvie的方法。ApplicationThreadNative(他是个抽象类)的实现者是ActivityThread的ApplicationThread,

private class ApplicationThread extends ApplicationThreadNative {

ApplicationThread的sheduleLaunchActivity方法中调用的是ActivityThread的sendmessge方法，发送了一个LAUNCH_ACTIVITY的消息给前面所说的handler mH。来看看handle如何处理LAUNCH_ACTIVITY消息的。

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<ResultInfo> pendingResults, List<ReferrerIntent> 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);

    sendMessage(H.LAUNCH_ACTIVITY, r);
}

private void sendMessage(int what, Object obj, int arg1, int arg2, int seq) {
    if (DEBUG_MESSAGES) Slog.v(
            TAG, "SCHEDULE " + mH.codeToString(what) + " arg1=" + arg1 + " arg2=" + arg2 +
                    "seq= " + seq);
    Message msg = Message.obtain();
    msg.what = what;
    SomeArgs args = SomeArgs.obtain();
    args.arg1 = obj;
    args.argi1 = arg1;
    args.argi2 = arg2;
    args.argi3 = seq;
    msg.obj = args;
    mH.sendMessage(msg);
}

public void handleMessage(Message msg) {
    if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
    switch (msg.what) {
        case LAUNCH_ACTIVITY: {
            Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
            final ActivityClientRecord r = (ActivityClientRecord) msg.obj;

            r.packageInfo = getPackageInfoNoCheck(
                    r.activityInfo.applicationInfo, r.compatInfo);
            handleLaunchActivity(r, null, "LAUNCH_ACTIVITY");
            Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
        } break;

可以看到调用了handleLaunchActivity方法,在handleLaunchActivity方法里接着调用了performLaunchActivity和handleResumeActivity方法,其中performLaunchActivity方法里调用了performResumeActivity方法会进而调用activity的Resume方法，不过这得在performLaunchActivity方法执行完之后。

Activity a = performLaunchActivity(r, customIntent);

    if (a != null) {
            r.createdConfig = new Configuration(mConfiguration);
            reportSizeConfigurations(r);
            Bundle oldState = r.state;
            handleResumeActivity(r.token, false, r.isForward,
            !r.activity.mFinished && !r.startsNotResumed, r.lastProcessedSeq, reason);

再来看看performLaunchActivity方法,先生成一个Activiyt对象,再生成一个application对象,一个Activity的Context对象。然后通过调用activity的attach方法将activity和application,context,AcitivityClientRecord关联起来,调用了Instrumentation的callActivityOnCreate方法，又调用了activitypeformstart方法进而调用activity的onStart方法。

  activity = mInstrumentation.newActivity(
     cl, component.getClassName(), r.intent);
     Application app = r.packageInfo.makeApplication(false, mInstrumentation);

 Context appContext = createBaseContextForActivity(r, activity);
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, window)
         if (r.isPersistable()) {
     mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
 } else {
     mInstrumentation.callActivityOnCreate(activity, r.state);
 }
  if (!r.activity.mFinished) {
     activity.performStart();
     r.stopped = false;
 }

而callActivityOnCreate方法里又调用了Activity的performCreate方法。最后调用了onCreate方法，Activity创建完成。

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

final void performCreate(Bundle icicle) {
    restoreHasCurrentPermissionRequest(icicle);
    onCreate(icicle);
    mActivityTransitionState.readState(icicle);
    performCreateCommon();
}

如果execStartActivity启动的Activity被ActivityMonitor拦截下来了,返回一个ActivityMonitor的ActivityResult，否则返回空,一般为空。除非你添加一个ActivityMonitor给Instrumentation。ActivityMonitro用来监视单个Activity与系统的交互。然后ActivityThread的sendActivityResult方法给Handler发一个消息。实际上是ApplicationThread的scheduleSendResult方法发给handler一个消息。

public final void sendActivityResult(
        IBinder token, String id, int requestCode,
        int resultCode, Intent data) {
    if (DEBUG_RESULTS) Slog.v(TAG, "sendActivityResult: id=" + id
            + " req=" + requestCode + " res=" + resultCode + " data=" + data);
    ArrayList<ResultInfo> list = new ArrayList<ResultInfo>();
    list.add(new ResultInfo(id, requestCode, resultCode, data));
    mAppThread.scheduleSendResult(token, list);
}

public final void scheduleSendResult(IBinder token, List<ResultInfo> results) {
    ResultData res = new ResultData();
    res.token = token;
    res.results = results;
    sendMessage(H.SEND_RESULT, res);
}

private void sendMessage(int what, Object obj) {
    sendMessage(what, obj, 0, 0, false);
}

private void sendMessage(int what, Object obj, int arg1) {
    sendMessage(what, obj, arg1, 0, false);
}

private void sendMessage(int what, Object obj, int arg1, int arg2) {
    sendMessage(what, obj, arg1, arg2, false);
}

private void sendMessage(int what, Object obj, int arg1, int arg2, boolean async) {
    if (DEBUG_MESSAGES) Slog.v(
        TAG, "SCHEDULE " + what + " " + mH.codeToString(what)
        + ": " + arg1 + " / " + obj);
    Message msg = Message.obtain();
    msg.what = what;
    msg.obj = obj;
    msg.arg1 = arg1;
    msg.arg2 = arg2;
    if (async) {
        msg.setAsynchronous(true);
    }
    mH.sendMessage(msg);
}

mH就是处理消息的Handler。位于ActivityThread类里，接收到处理类型为SEND_RESULT的消息，并且调用handleSendResult方法。

case SEND_RESULT:
    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityDeliverResult");
    handleSendResult((ResultData)msg.obj);
    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
    break;

private void handleSendResult(ResultData res) {
    ActivityClientRecord r = mActivities.get(res.token);
    if (DEBUG_RESULTS) Slog.v(TAG, "Handling send result to " + r);
    if (r != null) {
        final boolean resumed = !r.paused;
        if (!r.activity.mFinished && r.activity.mDecor != null
                && r.hideForNow && resumed) {
            // We had hidden the activity because it started another
            // one...  we have gotten a result back and we are not
            // paused, so make sure our window is visible.
            updateVisibility(r, true);
        }
        if (resumed) {
            try {
                // Now we are idle.
                r.activity.mCalled = false;
                r.activity.mTemporaryPause = true;
                mInstrumentation.callActivityOnPause(r.activity);
                if (!r.activity.mCalled) {
                    throw new SuperNotCalledException(
                        "Activity " + r.intent.getComponent().toShortString()
                        + " did not call through to super.onPause()");
                }
            } catch (SuperNotCalledException e) {
                throw e;
            } catch (Exception e) {
                if (!mInstrumentation.onException(r.activity, e)) {
                    throw new RuntimeException(
                            "Unable to pause activity "
                            + r.intent.getComponent().toShortString()
                            + ": " + e.toString(), e);
                }
            }
        }
        deliverResults(r, res.results);
        if (resumed) {
            r.activity.performResume();
            r.activity.mTemporaryPause = false;
        }
    }
}

调用了activity的performResume方法，activity的performResume方法有调用了performRestart方法,接着Instrumentation调用了callActivityOnResume方法,在这个方法里,调用了activity的onResume方法。

final void performResume() {
    performRestart();

    mFragments.execPendingActions();

    mLastNonConfigurationInstances = null;

    mCalled = false;
    // mResumed is set by the instrumentation
    mInstrumentation.callActivityOnResume(this);
    if (!mCalled) {
        throw new SuperNotCalledException(
            "Activity " + mComponent.toShortString() +
            " did not call through to super.onResume()");
    }

    // invisible activities must be finished before onResume() completes
    if (!mVisibleFromClient && !mFinished) {
        Log.w(TAG, "An activity without a UI must call finish() before onResume() completes");
        if (getApplicationInfo().targetSdkVersion
                > android.os.Build.VERSION_CODES.LOLLIPOP_MR1) {
            throw new IllegalStateException(
                    "Activity " + mComponent.toShortString() +
                    " did not call finish() prior to onResume() completing");
        }
    }

    // Now really resume, and install the current status bar and menu.
    mCalled = false;

    mFragments.dispatchResume();
    mFragments.execPendingActions();

    onPostResume();
    if (!mCalled) {
        throw new SuperNotCalledException(
            "Activity " + mComponent.toShortString() +
            " did not call through to super.onPostResume()");
    }
}

public void callActivityOnResume(Activity activity) {
    activity.mResumed = true;
    activity.onResume();
    
    if (mActivityMonitors != null) {
        synchronized (mSync) {
            final int N = mActivityMonitors.size();
            for (int i=0; i<N; i++) {
                final ActivityMonitor am = mActivityMonitors.get(i);
                am.match(activity, activity, activity.getIntent());
            }
        }
    }
}

现在让我们来总结下，分两个进程,应用程序进程和AMS所在进程。

首先应用程序进程->Activity->Instrumention(通过MS得到服务)->AMS进程->AMS->ActivityStarter->ActivityStackSupervisor->ActivityStack->ActivityStackSupervisor->(开启新进程流程:AMS->Process->新应用程序进程->ActivityThread->AMS进程->AMS->ActivityStackSupervisor->新的应用进程->ApplicationThread->ActivityThread->Activity)(不开启新进程:应用程序进程->ApplicationThread->ActivityThread->Activity)

从这个流程我们能知道什么?

每个应用程序开启多个activity，除非activity指定了process属性，否则只有一个应用程序进程和一个主线程(用ActivityThread描述)。

AMS有一个ActivityStackSupervisor，通过它来操作所有的ActivityStack。

AMS有一个ActivityStater，来操作启动Activity的相关事项。

onResume和onStart在mFinish被置为true的情况下不会被调用。比如在onCreate调用finish方法。

Instrumention是Activity和ActivityThread间的桥梁。