Android Launcher 启动 APP 流程的源码分析

以启动淘宝APP为例：

从用户点击淘宝APP的图标，到APP启动，其中大致可以分为7个步骤：

第一部分 源码

点击APP（淘宝），收集参数，通知AMS启动Activity：

代码：

step 1.1
// Activity.java
public void startActivity(Intent intent) {
 // --> 1.2
        this.startActivity(intent, null);
}

step 1.2
// Activity.java
public void startActivity(Intent intent, @Nullable Bundle options) 
{
        if (options != null) {
           。。。。。。
        } else {
     //  --> 1.3
            startActivityForResult(intent, -1);// -1 表示不需要这个Actvity结束后的返回结果。
        }
}


step 1.3
// Activity.java
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode) {
 // step 1.1 传进来的 requestCode 值为 -1 。 
        //  --> 1.4
        startActivityForResult(intent, requestCode, null);
}


step 1.4
// Activity.java
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
            @Nullable Bundle options)
{

             
              Instrumentation.ActivityResult ar =
               //  --> 1.5
               mInstrumentation.execStartActivity(
                    this, mMainThread.getApplicationThread(), mToken, this,
                    intent, requestCode, options);
// 参数的含义：
// mMainThread，它代表的是 Launcher 应用程序的主线程
// mMainThread.getApplicationThread() 代表 Launcher 应用进程的 IBinder 接口
// mToken 代表桌面Activity的 IBinder接口

}


step 1.5
// Instrumentation.java
public ActivityResult execStartActivity(
            Context who, IBinder contextThread, IBinder token, Activity target,
            Intent intent, int requestCode, Bundle options) 
{
// IApplicationThread 是 IBinder 的子类
IApplicationThread whoThread = (IApplicationThread) contextThread;

try {

            // ActivityManagerNative.getDefault() 返回的是一个IActivityManager接口：
            // 核心源码：
            // IBinder b = ServiceManager.getService("activity");
            // IActivityManager am = asInterface(b);
            // 通过IActivityManager，可以向 AMS 端发起进程间通信（ADIL）
            // 这边的IActivityManager接口调用什么函数，那边的AMS端就执行同名同参数的函数
            //  --> 2.1 进程间通信
            int result = ActivityManagerNative.getDefault()
                .startActivity( whoThread , who.getBasePackageName(), intent,
                        intent.resolveTypeIfNeeded(who.getContentResolver()),
                        token, target != null ? target.mEmbeddedID : null,
                        requestCode, 0, null, options);
           // whoThread 是 代表 Launcher 应用的 IApplicationThread 接口实例，
           // AMS 端拿到这个 IApplicationThread 接口后，可以向 Launcher 发起进程间通信。
           // token 是一个IBinder接口，代表的是桌面这个Activity。
        } 
}

第一部分小结：

收集到用户点击的 APP 的相关信息放入 intent，获取代表自身进程的IBinder接口，
然后发起进程间通信并传递收集到的参数，通知 AMS 要开始启动指定的 Activity 。








第二部分  源码

AMS 给 APP（淘宝）做登记，通知桌面暂停：

本部分的代码主要涉及到的类和数据结构，
ActivityManagerService：管理 Activity 的系统服务。
ActivityStarter：Activity启动器。
ActivityStackSupervisor：ActivityStack的监督员。
ActivityStack：Activity的栈，一个应用只有一个Stack，是一个manager的角色，他是负责管理协调    
                       TaskRecord 和 ActivityRecord 。
TaskRecord：任务栈，保存着启动的Activity，栈中Activity的顺序就是按照它们被打开的顺序依次存    
  放的。

ActivityRecord：Activity的代表，一个 ActivityRecord 代表一个 Activity。

代码：

step 2.1
// ActivityManagerService.java（AMS）
public final int startActivity(IApplicationThread caller, String callingPackage,
            Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
            int startFlags, ProfilerInfo profilerInfo, Bundle bOptions) {
 // caller 就是指 Launcher 。
 // requestCode 从 step 1.1 传进来的值为 -1 。
 // startFlags 从 step 1.3 传进来的值为 0 。常规启动。
 // resultTo 用于接收startActivityForResult的结果,launcher启动app这种情景下没有用,为null
 return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
                resultWho, requestCode, startFlags, profilerInfo, bOptions,
                UserHandle.getCallingUserId());
    }


step 2.2
// ActivityManagerService.java（AMS）
public final int startActivityAsUser(IApplicationThread caller, String callingPackage,
            Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
            int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId) 
{     
        // 2.2 --> 2.3
        return mActivityStarter.startActivityMayWait(caller, -1, callingPackage, intent,
                resolvedType, null, null, resultTo, resultWho, requestCode, startFlags,
                profilerInfo, null, null, bOptions, false, userId, null, null);
}

step 2.3
// ActivityStarter.java
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)
{
// inTask 从 step 2.2 传进来的值为 null 。

// Collect information about the target of the Intent.
// 得到淘宝的 主Activity 的相关信息，保存在aInfo变量中
        ActivityInfo aInfo = mSupervisor.resolveActivity(intent, rInfo, startFlags, profilerInfo);

synchronized (mService)
{
     final int realCallingPid = Binder.getCallingPid();
            final int realCallingUid = Binder.getCallingUid();
            int callingPid; // 获取调用者（Launcher 应用）的Pid，Uid 。
            if (callingUid >= 0) {
                callingPid = -1;
            } else if (caller == null) {
                callingPid = realCallingPid;
                callingUid = realCallingUid;
            } else {
                callingPid = callingUid = -1;
            }

// 2.3 --> 2.4
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);
}
}


step 2.4
// ActivityStarter.java
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)
{
        ProcessRecord callerApp = null;
        if (caller != null) {
            // 获得了代表 Launcher应用进程的 callerApp 实例。
            callerApp = mService.getRecordForAppLocked(caller);

        }

// 省略代码......

//创建一个ActivityRecord ，代表着淘宝的 主Activity
ActivityRecord r = new ActivityRecord(mService, callerApp, callingUid, callingPackage,
                intent, resolvedType, aInfo, mService.mConfiguration, resultRecord, resultWho,
                requestCode, componentSpecified, voiceSession != null, mSupervisor, container,
                options, sourceRecord);

//省略代码......

try {
            // 下一步处理 2.4 --> 2.5
            // 把代表着淘宝主activity的 r 作为参数传给下一步
            err = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor, startFlags, true, options, inTask);
        }

           //省略代码......
}

step 2.5
// ActivityStarter.java
该方法主要负责task的管理,也可以理解为对task的调度.
换句话说,也可以理解为找到或者创建一个合适的task.
private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
            IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
            int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask)
{
        // doResume 从step 2.4 传进来的值为 true。

        // 初始化了以下的主要变量：
        // mStartActivity = r，
        // mInTask = inTask，null （step 2.2 ）
        // mStartFlags = startFlags，0（step 1.3）
        // mDoResume = doResume 等
        setInitialState(r, options, inTask, doResume, startFlags, sourceRecord, voiceSession,
                voiceInteractor);

// 省略代码......复杂的 task 调度算法。
// 如果点击淘宝的时候，淘宝已经启动了，运行在后台，那才需要进入这里，
// 淘宝还没启动，不存在 task 。

 // Should this be considered a new task?
        // 考虑是否需要一个新的 task
        if (mStartActivity.resultTo == null && mInTask == null && !mAddingToTask
                && (mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0) {
            newTask = true;

            // 给 mStartActivity 创建并绑定一个 task
            // 再创建一个 mTargetStack （淘宝APP），并且设置为焦点stack
            setTaskFromReuseOrCreateNewTask(taskToAffiliate);
        }

//省略代码......

if (mDoResume) // 在 setInitialState 函数设置过该变量，为 true
if (!mTargetStack.isFocusable()
                    || (topTaskActivity != null && topTaskActivity.mTaskOverlay
                    && mStartActivity != topTaskActivity)) 
else{
              //  --> 2.6
              mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack, 	
mStartActivity,  mOptions);
}

}

step 2.6
// ActivityStackSupervisor.java
boolean resumeFocusedStackTopActivityLocked(
            ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) 
{
// 新打开淘宝的话，淘宝app对应的这个 targetStack 就会是焦点stack
if (targetStack != null && isFocusedStack( targetStack )) {
            // --> 2.7
            return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
  }

//省略代码......
}

step 2.7
// ActivityStack.java
boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) 
{
//省略代码......

try {
            //关键代码：
            //  --> 2.8
            result = resumeTopActivityInnerLocked(prev, options);
        }
 
    //省略代码......
}

step 2.8
// ActivityStack.java
private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) 
{

// mResumedActivity 指已经resumed的Activity( Launcher 的桌面Activity )
if (mResumedActivity != null) {
            // 关键代码
            //  --> 2.9
            pausing |= startPausingLocked(userLeaving, false, true, dontWaitForPause);
}

if (next.app != null && next.app.thread != null) {
// 说明淘宝App已经启动
}
else{
            // 4.5 --> 4.6
            // 创建进程，冷启动Activity。或者已启动App，重新启动Activity
            mStackSupervisor.startSpecificActivityLocked(next, true, true);
}

}

step 2.9
// ActivityStack.java
final boolean startPausingLocked(boolean userLeaving, boolean uiSleeping, boolean resuming,
            boolean dontWait)
{

mResumedActivity = null; // step4.5 会用到这个变量
       mPausingActivity = prev; //  Launcher 的桌面 activity   step4.2会用到

if (prev.app != null && prev.app.thread != null){
try{

//  --> 3.0 跨进程通信
// prev.app.threa 在这里是一个指向 Launcher 的 IApplicationThread 接口
// prev.appToke  桌面activity 的 IBinder 接口
prev.app.thread.schedulePauseActivity( prev.appToken , prev.finishing,
userLeaving, prev.configChangeFlags, dontWait);

}
}
}

第二部分小结：

AMS 端获取到 Launcher 端的进程间通信后，
从传进来的参数中，解析出调用者（Launcher）进程的pid等信息，
和待启动 Activity（淘宝的主Activity）的相关信息，
然后为待启动 Activity 创建一个 ActivityRecord 对象，
并且为待启动 Activity 创建新的任务栈 task 和 新的栈 stack , 并把 stack 设置为焦点 Stack，
然后发起进程间通信去通知 Launcher 暂停桌面 activity。









第三部分 源码
该部分工作发生在 Launcher 里。

Launcher进入pause状态，通知AMS已经paused完成：

step 3.1
//ActivityThread.java（内部类：class ApplicationThread ）
public final void schedulePauseActivity(IBinder token, boolean finished,
                boolean userLeaving, int configChanges, boolean dontReport)
{

sendMessage(finished ? H.PAUSE_ACTIVITY_FINISHING : H.PAUSE_ACTIVITY,
                    token,
                    (userLeaving ? USER_LEAVING : 0) | (dontReport ? DONT_REPORT : 0),
                    configChanges,
                    seq);

}

step 3.2
//ActivityThread.java
private void sendMessage(int what, Object obj, int arg1, int arg2, int seq) {
。。。。。。
        Message msg = Message.obtain();
        msg.what = what;
。。。。。。
        args.arg1 = obj;
。。。。。。
        mH.sendMessage( msg );
    }

step 3.3
//ActivityThread.java（内部类：class H extends Handler）
public void handleMessage(Message msg)
{
case PAUSE_ACTIVITY: {
                    
                    //  --> 3.4
                    handlePauseActivity( (IBinder) args.arg1 , false,
                            (args.argi1 & USER_LEAVING) != 0, args.argi2,
                            (args.argi1 & DONT_REPORT) != 0, args.argi3);
}

step 3.4
// ActivityThread.java
private void handlePauseActivity(IBinder token, boolean finished,
            boolean userLeaving, int configChanges, boolean dontReport, int seq) 
{
// r 就是桌面 activity
ActivityClientRecord r = mActivities.get( token );
if (r != null) {
//  --> 3.5
performPauseActivity( token, finished, r.isPreHoneycomb(), "handlePauseActivity");

// Tell the activity manager we have paused.
        if (!dontReport) {
                try {
                    //  --> 4.0 进程间通信，告知 AMS，暂停完成。
                    ActivityManagerNative.getDefault().activityPaused( token );
                } 
         }
}
}

step 3.5
// ActivityThread.java
final Bundle performPauseActivity(IBinder token, boolean finished,
            boolean saveState, String reason) {
        // r 就是桌面 activity
        ActivityClientRecord r = mActivities.get( token );
        // --> 3.6
        return r != null ? performPauseActivity(r, finished, saveState, reason) : null;
 }

step 3.6
// ActivityThread.java
final Bundle performPauseActivity(ActivityClientRecord r, boolean finished,
            boolean saveState, String reason)
{
。。。。。。
// --> 3.7
        performPauseActivityIfNeeded( r , reason);
}

step 3.7
// ActivityThread.java
private void performPauseActivityIfNeeded(ActivityClientRecord r, String reason) 
{
try {
            // --> 3.8
            // 通过仪表盘类来控制 Activity 的生命周期
            mInstrumentation.callActivityOnPause(r.activity);
            // 省略代码。。。
        }
}

step 3.8
// Instrumentation.java
public void callActivityOnPause(Activity activity) {
// --> 3.9
// activity  就是桌面 Activity
        activity.performPause();
 }

step 3.9
// Activity.java
final void performPause() 
{
 	。。。。。。
        onPause();
        mResumed = false;
        。。。。。。
 }

代码：

第三部分小结：

调用了桌面 Activity 的 onPause 函数，完成暂停后，发起进程间通信告知AMS。












第四部分 源码

给APP（淘宝）新建进程，完成时触发main函数：

代码：

step 4.1
//AMS
public final void activityPaused(IBinder token){
synchronized(this) {
     // token 指 桌面Activity
     // 该 stack 对应 Launcher 应用
            ActivityStack stack = ActivityRecord.getStackLocked( token );
            if (stack != null) {
                //  --> 4.2
                stack.activityPausedLocked( token , false);
            }

}

step 4.2
//ActivityStack.java
final void activityPausedLocked(IBinder token, boolean timeout){
// r 是 Launcher 桌面 Activity
final ActivityRecord r = isInStackLocked(token);
        if (r != null) {
            // 移除暂停超时的通知
            mHandler.removeMessages(PAUSE_TIMEOUT_MSG, r);
     // mPausingActivity 也是 Launcher 桌面 Activity（step 2.9 设置的）
            if (mPausingActivity == r) {
                //  --> 4.3
                completePauseLocked( true );
                return;
            } 
  // 代码省略......
}

step 4.3
//ActivityStack.java
private void completePauseLocked(boolean resumeNext) 
{
// prev 是 Launcher 的桌面 activity
ActivityRecord prev = mPausingActivity;
if (prev != null) {
//省略代码...
mPausingActivity = null;
}

// resumeNext 从 step4.2 传进来的值为 true
if (resumeNext) {
     // topStack  淘宝 app 的 stack （step 2.5 设置的）
            final ActivityStack topStack = mStackSupervisor.getFocusedStack();
            if (!mService.isSleepingOrShuttingDownLocked()) {
                //  --> 4.4
                mStackSupervisor.resumeFocusedStackTopActivityLocked(topStack, prev, null);
            }

}

step 4.4 （同 step 2.6）
// ActivityStackSupervisor.java
boolean resumeFocusedStackTopActivityLocked(
            ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) 
{
// 此时的 target 是 Launcher的桌面 activity
// 此时的 targetStack 淘宝 app 的 stack
if ( targetStack != null && isFocusedStack(targetStack) ) {
            //   --> 4.5
            return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
 }
}

step 4.5 （同 step 2.7）
// ActivityStack.java
boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
       
// 省略代码

        try {
     // 此时 prev 是  Launcher 的桌面 activity
            //   --> 4.6
            result = resumeTopActivityInnerLocked(prev, options);
        } 
        return result;
 }

step 4.6 （同 step 2.8）
// ActivityStack.java
private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options)
{
 // Find the first activity that is not finishing.
 // next 此时为待启动的activity（淘宝的 主Activity）
        final ActivityRecord next = topRunningActivityLocked();

// 代码省略。。。

// 这次不走这个逻辑，所以 mResumedActivity 在 step2.9 startPausingLocked函数 被置为空
        if (mResumedActivity != null) {        
            //  --> 2.9
            pausing |= startPausingLocked(userLeaving, false, true, dontWaitForPause);
        }

if (next.app != null && next.app.thread != null) {
// 说明淘宝App已经启动
}
else{
     //  --> 4.7
     // 创建进程
     mStackSupervisor.startSpecificActivityLocked(next, true, true);
}

// 代码省略。。。
}




step 4.7
// ActivityStackSupervisor.java
void startSpecificActivityLocked(ActivityRecord r, boolean andResume, boolean checkConfig)
{
// r 淘宝 APP 的主 Activity

// Is this activity's application already running?
// app 为 null ，淘宝APP 还没启动
       ProcessRecord app = mService.getProcessRecordLocked( r.processName,
                r.info.applicationInfo.uid , true);

if (app != null && app.thread != null){
// 目标Activity的App已经启动（存在ActivityThread）
// 如果淘宝APP 已经启动，运行在后台，就会走这个逻辑
            try {
  //  省略代码。。。        	

                realStartActivityLocked(r, app, andResume, checkConfig);
                return;
            }
}

 // 如果进程不存在，则通过zygote创建应用进程
        //  --> 4.8
        mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,
                "activity", r.intent.getComponent(), false, false, true);

}

step 4.8
// ActivityManagerService.java
final ProcessRecord startProcessLocked(String processName,
            ApplicationInfo info, boolean knownToBeDead, int intentFlags,
            String hostingType, ComponentName hostingName, boolean allowWhileBooting,
            boolean isolated, boolean keepIfLarge)
 {
// 省略代码 。。。
        //  --> 4.9
        return startProcessLocked(processName, info, knownToBeDead, intentFlags, 	
 hostingType,
                hostingName, allowWhileBooting, isolated, 0 /* isolatedUid */, keepIfLarge,
                null /* ABI override */, null /* entryPoint */, null /* entryPointArgs */,
                null /* crashHandler */);
 }

step 4.9
// ActivityManagerService.java
final ProcessRecord startProcessLocked(String processName, ApplicationInfo info,
            boolean knownToBeDead, int intentFlags, String hostingType, ComponentName hostingName,
            boolean allowWhileBooting, boolean isolated, int isolatedUid, boolean keepIfLarge,
            String abiOverride, String entryPoint, String[] entryPointArgs, Runnable crashHandler) 
{
ProcessRecord app;

// 省略代码 。。。

if (app == null) {
            checkTime(startTime, "startProcess: creating new process record");
     // 为淘宝 app 创建一个进程代表的实例
            app = newProcessRecordLocked( info , processName , isolated, isolatedUid);
}

//  --> 4.10
        startProcessLocked(
                app, hostingType, hostingNameStr, abiOverride, entryPoint, entryPointArgs);

}

step 4.10
// ActivityManagerService.java
private final void startProcessLocked(ProcessRecord app, String hostingType,
            String hostingNameStr, String abiOverride, String entryPoint, String[] entryPointArgs)
{
try{
// 省略代码 。。。
checkTime(startTime, "startProcess: asking zygote to start proc");
            // Process.java的start函数，将通过 socket 发送消息给 zygote
            // zygote 将派生出一个子进程，
     // 子进程将通过反射调用新进程（淘宝） ActivityThread 的 main 函数 
            Process.ProcessStartResult startResult = Process.start(entryPoint,
                    app.processName, uid, uid, gids, debugFlags, mountExternal,
                    app.info.targetSdkVersion, app.info.seinfo, requiredAbi, instructionSet,
                    app.info.dataDir, entryPointArgs);

// 省略代码 。。。
  }
}

第四部分小结：

在收到 Launcher 的桌面 Activity 暂停完成的通知后，
调用 startSpecificActivityLocked 函数，尝试去启动淘宝 APP 的主Activity，
然后发现淘宝 APP 没有启动，接着在调用 startProcessLocked 函数，
通知 zygote 进程为淘宝 APP 创建新进程，请触发新进程的main函数。








第五部分

淘宝app主线程开始启动，完毕后通知AMS，并传入applicationThread以便通讯：

代码：

step 5.1
// ActivityThread.java
public static void main(String[] args) 
{

// 准备主线程的Looper 
        Looper.prepareMainLooper();

        // 创建当前进程的主线程 ActivityThread
        ActivityThread thread = new ActivityThread();

        // 将该进程绑定到AMS 
        // 5.1 --> 5.2
        thread.attach( false );


// 省略代码 。。。

// 进入主线程的消息循环
        Looper.loop();

}

step 5.2
// ActivityThread.java
private void attach(boolean system) 
{
if (!system) // 上一步传了 false 进来
{
     。。。。。。
     final IActivityManager mgr = ActivityManagerNative.getDefault();
            try {
                
                // 将 ApplicationThread类型的对象 mAppThread 发送给 AMS
                // 这样 AMS 就可以通过该接口来对新进程（淘宝APP）进行进程间通信了
  //  --> 6.0 进程间通信
                mgr.attachApplication( mAppThread );
            }
     。。。。。。
}
}

第五部分小结：

在main函数内，通过Looper来启动消息循环，
创建了 ActivityThread 实例，并调用其attach 函数想 AMS 发起进程间通信。







第六部分

AMS通知淘宝绑定Application并启动MainActivity：

代码：

step 6.1
// AMS
public final void attachApplication(IApplicationThread thread) 
{
synchronized (this) {
            // 获取进程Pid( 淘宝进程的 Pid )
            int callingPid = Binder.getCallingPid();

            // --> 6.2
            attachApplicationLocked( thread, callingPid );
        }
}

step 6.2
// AMS
private final boolean attachApplicationLocked(IApplicationThread thread, int pid)
{

// 初始化 app（淘宝） 的一下变量
 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;

try {
。。。。。。
//  完成绑定 App （淘宝）
thread.bindApplication(processName, appInfo, providers, app.instrumentationClass,
                    profilerInfo, app.instrumentationArguments, app.instrumentationWatcher,
                    app.instrumentationUiAutomationConnection, testMode,
                    mBinderTransactionTrackingEnabled, enableTrackAllocation,
                    isRestrictedBackupMode || !normalMode, app.persistent,
                    new Configuration(mConfiguration), app.compat,
                    getCommonServicesLocked(app.isolated),
                    mCoreSettingsObserver.getCoreSettingsLocked());
。。。。。。
}

// 在启动 AMS 的时候，该 mProcessesReady 值就被设置为 true。
boolean normalMode = mProcessesReady || isAllowedWhileBooting(app.info);

。。。。。。

// See if the top visible activity is waiting to run in this process...
        if (normalMode) {
            try {
                // --> 6.3
                if (mStackSupervisor.attachApplicationLocked(app)) {
                    didSomething = true;// didSomething 表示是否有启动四大组件
                }
            } 
        }
}





step 6.3
// StackSupervisor.java
boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {

        boolean didSomething = false;

  // 遍历每个stack
         for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
                final ActivityStack stack = stacks.get(stackNdx);
                if (!isFocusedStack(stack)) { // 不是焦点stack，就继续找
                    continue;
                }
// 到这里找到焦点stack，
// hr 就是 淘宝app 的 主Activity
                ActivityRecord hr = stack.topRunningActivityLocked();
                if (hr != null) {
// hr.app 是 ProcessRecord app 这个变量。
// ProcessRecord app;  源码中该变量的解释： if non-null, hosting application
                    if (hr.app == null && app.uid == hr.info.applicationInfo.uid
                            && processName.equals(hr.processName)) {
                        try {
                            // --> 6.4
                            if (realStartActivityLocked(hr, app, true, true)) {
                                didSomething = true;
                            }
                        }
                    }
                }
            }


//如果以上没有启动任何组件，那么didSomething为false
        if (!didSomething) {
            // 调整进程的 oom_adj 值， oom_adj 相当于一种优先级
            // 如果应用进程没有运行任何组件，则降低该进程的优先级
     // 当内存出现不足时，该进程是最先被系统“杀死”
            updateOomAdjLocked();
        }


}

step 6.4
// StackSupervisor.java
final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
            boolean andResume, boolean checkConfig) throws RemoteException 
{

            // -->7.1 进程间通信
            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);

}

第六部分小结：

收到新进程要求绑定自的通信，初始化新进程APP的一些变量，
然后调用 thread.bindApplication 完成绑定。
接着获取到 hr 变量，发现新进程（淘宝APP）的主Activity没有启动
调用 realStartActivityLocked 函数，发起进程间通信通知新进程启动主Activity 。








第七部分

调用主activity的 onCreate 函数：

代码：

step 7.1
// ActivityThread.java（内部类：class ApplicationThread ）
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)
{

ActivityClientRecord r = new ActivityClientRecord();
// 根据传过来的 token，初始化 r ，然后 r 就是代表淘宝APP的主Activity 
       r.token = token;
       r.ident = ident;
       r.intent = intent;
。。。。。。

//  --> 7.2
sendMessage(H.LAUNCH_ACTIVITY, r );
}


step 7.2
// ActivityThread.java
private void sendMessage(int what, Object obj)
 {
        // --> 7.3
        sendMessage(what, obj, 0, 0, false);
 }

step 7.3
// ActivityThread.java
private void sendMessage(int what, Object obj, int arg1, int arg2, boolean async) {
  
// --> 7.4
        mH.sendMessage(msg);
}

step 7.4
//  ActivityThread.java （内部类class H）
public void handleMessage(Message msg)
{

case LAUNCH_ACTIVITY: {
      //   r 代表淘宝APP的主Activity 
                    final ActivityClientRecord r = (ActivityClientRecord) msg.obj;
     
      // --> 7.5
                    handleLaunchActivity(r, null, "LAUNCH_ACTIVITY");
                } break;

}


step 7.5
// ActivityThread.java
private void handleLaunchActivity(ActivityClientRecord r , Intent customIntent, String reason) 
{
// --> 7.6
Activity a = performLaunchActivity( r , customIntent);

}


step 7.6
// ActivityThread.java
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent)
{

Activity activity = null;
        try
 {
            java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
     // 创建了淘宝的主activity 的实例，真正的实例，不是代表。
            activity = mInstrumentation.newActivity(
                    cl, component.getClassName(), r.intent);
            }
        }

try 
{
if (activity != null) 
{
。。。。。。
if (r.isPersistable()) {
//  --> 7.7
                mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
        } else {
                mInstrumentation.callActivityOnCreate(activity, r.state);
        }
}
}
}

step 7.7
// Instrumentation.java
public void callActivityOnCreate(Activity activity, Bundle icicle,
            PersistableBundle persistentState) {
        prePerformCreate(activity);
 //  --> 7.8
        activity.performCreate(icicle, persistentState);
        postPerformCreate(activity);
    }

step 7.8
// Activity.java
final void performCreate(Bundle icicle, PersistableBundle persistentState) {
        restoreHasCurrentPermissionRequest(icicle);
        onCreate(icicle, persistentState);
        mActivityTransitionState.readState(icicle);
        performCreateCommon();
}

第七部分小结：

收到 AMS 的启动主Activity 的通知后，
创建一个 mInstrumentation 实例。
先通过 mInstrumentation 为 主Activity 新建一个 Activity 的实例，
再通过 mInstrumentation 调用该 Activity 的 onCreate 函数。