Activity 启动流程

港控/mmm° 2023-07-04 06:07 49阅读 0赞

一下分析基于从`Launcher`点击图标打开一个`app`进行分析

对于该流程，总共分为三个进程，分别是`Launcher`进程，`AMS`进程和`app`进程，以下会根据该进程流程进行分析。

#### `Launcher`进程,用户点击 ####

##### `LauncherActivity` #####

该页面是桌面的页面，其对应的图标回调如下：

@Override
        protected void onListItemClick(ListView l, View v, int position, long id) { 
            Intent intent = intentForPosition(position);
            startActivity(intent);
        }

也就是说其实质是调用`startActivity()`，该方法来自于`Activity`

##### `startActivity`并最终调用`startActivityForResult`方法 #####

@Override
        public void startActivity(Intent intent) { 
            this.startActivity(intent, null);
        }
    
        @Override
        public void startActivity(Intent intent, @Nullable Bundle options) { 
            if (options != null) { 
                startActivityForResult(intent, -1, options);
            } else { 
                // Note we want to go through this call for compatibility with
                // applications that may have overridden the method.
                startActivityForResult(intent, -1);
            }
        }

##### `startActivityForResult`的实现 #####

public void startActivityForResult(Intent intent, int requestCode, @Nullable Bundle options) { 
        	//一般的Activity其mParent为null，mParent常用在ActivityGroup中，ActivityGroup已废弃 api13
            if (mParent == null) { 
            	// 负责发起Activity的启动、并具体负责Activity的创建以及Activity生命周期的回调。一个应用进程只会有一个Instrumentation对象，App内的所有Activity都持有该对象的引用
            	// mMainThread为ActivityThread对象，代表一个应用进程
            	// mMainThread.getApplicationThread()是一个binder对象，Ams可以通过他通知ActivityThread对象
            	// mToken 的类型为IBinder对象，它是一个代理对象，指向了ams中的一个类型为ActivityRecord的Binder对象，用来维护Activity的运行状态
                Instrumentation.ActivityResult ar =
                    mInstrumentation.execStartActivity(
                        this, mMainThread.getApplicationThread(), mToken, this,
                        intent, requestCode, options);
                        
                if (ar != null) { 
                    mMainThread.sendActivityResult(
                        mToken, mEmbeddedID, requestCode, ar.getResultCode(),
                        ar.getResultData());
                }
                if (requestCode >= 0) { 
                    // If this start is requesting a result, we can avoid making
                    // the activity visible until the result is received. Setting
                    // this code during onCreate(Bundle savedInstanceState) or onResume() will keep the
                    // activity hidden during this time, to avoid flickering.
                    // This can only be done when a result is requested because
                    // that guarantees we will get information back when the
                    // activity is finished, no matter what happens to it.
                    mStartedActivity = true;
                }
    
                cancelInputsAndStartExitTransition(options);
                // TODO Consider clearing/flushing other event sources and events for child windows.
            } else { 
                // ....
            }
        }

`Instrumentation`使用来管理`activity`声明周期的类，负责`activity`的启动等一些功能。

该方法的实质是调用`Instrumentation`的`execStartActivity()`。

##### `Instrumentation`的`execStartActivity()` #####

public ActivityResult execStartActivity(
                Context who, IBinder contextThread, IBinder token, Activity target,
                Intent intent, int requestCode, Bundle options) { 
            // ... 
            try { 
                intent.migrateExtraStreamToClipData();
                intent.prepareToLeaveProcess();
                // 核心方法 通过ActivityManagerNative.getDefault() 获取AMS的代理对象并调用startActivity
                int result = ActivityManagerNative.getDefault()
                    .startActivity(whoThread, who.getBasePackageName(), intent,
                            intent.resolveTypeIfNeeded(who.getContentResolver()),
                            token, target != null ? target.mEmbeddedID : null,
                            requestCode, 0, null, options);
    
                checkStartActivityResult(result, intent);
            } catch (RemoteException e) { 
                throw new RuntimeException("Failure from system", e);
            }
            return null;
        }

该方法实质就是通过`ActivityManagerNative`获取到`ActivityManagerService`的代理对象`ActivityManagerProxy`,通过代理代理对象调用到`AMS`的启动`activity`方法。

看一下`ActivityManagerNative`的`getDefault()`方法

##### 通过`ActivityManagerNative`获取到`ActivityManagerService`的代理对象 #####

private static final Singleton<IActivityManager> gDefault = new Singleton<IActivityManager>() { 
            protected IActivityManager create() { 
                // 获取ams的binder代理
                IBinder b = ServiceManager.getService("activity");
                if (false) { 
                    Log.v("ActivityManager", "default service binder = " + b);
                }
                // ActivityManagerProxy 构造amp代理对象
                IActivityManager am = asInterface(b);
                if (false) { 
                    Log.v("ActivityManager", "default service = " + am);
                }
                return am;
            }
        };

其中`asInterface()`方法如下：

*/
        static public IActivityManager asInterface(IBinder obj) { 
            if (obj == null) { 
                return null;
            }
            // 判断是否是同一进程,如果是统一进程，就不需要包装了。
            IActivityManager in =
                (IActivityManager)obj.queryLocalInterface(descriptor);
            if (in != null) { 
                return in;
            }
            // 否则包装成Proxy对象
            return new ActivityManagerProxy(obj);
        }

###### 通过`ActivityManagerProxy`对象调用`startActivity()`用以通知`AMS` ######

// caller 代表launcher所在的applicationThread对象
        // intent 包含了所要启动组件的信息
        // resultTo 指向AMS内部的ActiityRecord的代理binder对象
        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);
            }
            // 远程binder调用的类型
            mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);
            reply.readException();
            int result = reply.readInt();
            reply.recycle();
            data.recycle();
            return result;
        }

> 总结  
> 1.`LauncherActivity`中的`onListItemClick()`处理点击事件，调用`Activity`的`startActivity()`  
> 2.通过层层传递，最终会调用`activity`的`startForResult()`的方法  
> 3.`startActivityForResult()`中会调用`Instrumentation`的`execStartActivity()`,`Instrumentation`为`Activity`的管理者，其中的一些生命周期等都会调用该类。  
> 4.在`execStartActivity()`中，通过`ActivityManagerNative.getDefault()`获取到`AMS`的代理对象，其实质是`Binder`机制，进行进程间通信。调用远程`AMS`的`startActivity()`。  
> 5，至此，从`Launcher`进程跳转到了`AMS`进程。

#### `AMS`进程 ####

在`launcher`进程的最后，通过`ActivityManagerProxy`代理对象，以`binder`的方式，远程调用了`AMS`的方法，此时进入到`AMS`进程。

##### 调用`AMS`的`startActivity()`方法 #####

@Override
        public final int startActivity(IApplicationThread caller, String callingPackage,
                Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
                int startFlags, ProfilerInfo profilerInfo, Bundle options) { 
            // startActivity用来处理START_ACTIVITY_TRANSACTION的请求
            return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
                resultWho, requestCode, startFlags, profilerInfo, options,
                UserHandle.getCallingUserId());
        }
    
       @Override
        public final int startActivityAsUser(IApplicationThread caller, String callingPackage,
                Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
                int startFlags, ProfilerInfo profilerInfo, Bundle options, int userId) { 
            // 参数说明
            // IApplicationThread caller 源进程发起者
            // String callingPackage 发起者对应的包名
            // Intent intent, String resolvedType, 启动使用的Intent和resolvedType
            // IBinder resultTo, String resultWho, int requestCode 回调相关
            // int startFlags Intent携带的start activity对应的flag
            // ProfilerInfo profilerInfo, 性能统计有关
            // Bundle bOptions : ?
            // int userId ： 调用的用户id
            enforceNotIsolatedCaller("startActivity");
            userId = handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(), userId,
                    false, ALLOW_FULL_ONLY, "startActivity", null);
            // TODO: Switch to user app stacks here.
            // mSupervisor的类型为ActivityStackSupervisor， 负责管理Activity和对应Task之间的关系
            return mStackSupervisor.startActivityMayWait(caller, -1, callingPackage, intent,
                    resolvedType, null, null, resultTo, resultWho, requestCode, startFlags,
                    profilerInfo, null, null, options, false, userId, null, null);
        }

`AMS`收到请求后会通过`mStackSupervisor`的`startActivityMayWait`完成获取的页面跳转。其中`ActivityStacksupervisor`是用来管理`ActvityStack`的。

##### `ActivityStackSupervisor`的`startActivityMayWait()` #####

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 config,
                Bundle options, boolean ignoreTargetSecurity, int userId,
                IActivityContainer iContainer, TaskRecord inTask) { 
            // Refuse possible leaked file descriptors
            if (intent != null && intent.hasFileDescriptors()) { 
                throw new IllegalArgumentException("File descriptors passed in Intent");
            }
            // 判断是否指定了组件名
            boolean componentSpecified = intent.getComponent() != null;
    
            // Don't modify the client's object!
            intent = new Intent(intent);
            
            // 获取activity的一些信息， 通过PackageManagerService
            ActivityInfo aInfo =
                    resolveActivity(intent, resolvedType, startFlags, profilerInfo, userId);
    
            ActivityContainer container = (ActivityContainer)iContainer;
            synchronized (mService) { 
                // 此处container为null
                if (container != null && container.mParentActivity != null &&
                        container.mParentActivity.state != RESUMED) { 
                    // Cannot start a child activity if the parent is not resumed.
                    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;
                }
                // 启动时的activity栈
                final ActivityStack stack;
                if (container == null || container.mStack.isOnHomeDisplay()) { 
                    // 获取当前的任务栈
                    stack = mFocusedStack;
                } else { 
                    //当从一个Activity启动另一个Activity时，
                    //启动栈为父Activity的Task
                    stack = container.mStack;
                }
                // 为false 因为config为null
                stack.mConfigWillChange = config != null && mService.mConfiguration.diff(config) != 0;
                if (DEBUG_CONFIGURATION) Slog.v(TAG_CONFIGURATION,
                        "Starting activity when config will change = " + stack.mConfigWillChange);
    
                final long origId = Binder.clearCallingIdentity();
                // AndroidManifest.xml中的Application标签可以申明一个CANT_SAVE_STATE属性 ,被称为heavy-weight process
                // 这个没用过，所以这段逻辑不会走
                if (aInfo != null &&
                        (aInfo.applicationInfo.privateFlags
                                &ApplicationInfo.PRIVATE_FLAG_CANT_SAVE_STATE) != 0) { 
                    // ...
                }
    
                // 继续执行startActivity的启动
                int res = startActivityLocked(caller, intent, resolvedType, aInfo,
                        voiceSession, voiceInteractor, resultTo, resultWho,
                        requestCode, callingPid, callingUid, callingPackage,
                        realCallingPid, realCallingUid, startFlags, options, ignoreTargetSecurity,
                        componentSpecified, null, container, inTask);
    
                // ...
                // outResult为null ，所以该段逻辑不会走
                if (outResult != null) { 
                   // ...
                }
    
                return res;
            }
        }

通过`PackageManagerService`查询要启动的目标`activity`的一些信息。

调用`startActivityLocked()`

##### `ActivityStackSupervisor`的`startActivityLocked()` #####

final int startActivityLocked(IApplicationThread caller,
                Intent intent, String resolvedType, ActivityInfo aInfo,
                IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
                IBinder resultTo, String resultWho, int requestCode,
                int callingPid, int callingUid, String callingPackage,
                int realCallingPid, int realCallingUid, int startFlags, Bundle options,
                boolean ignoreTargetSecurity, boolean componentSpecified, ActivityRecord[] outActivity,
                ActivityContainer container, TaskRecord inTask) { 
            // 用于保存错误信息
            int err = ActivityManager.START_SUCCESS;
            // 用户获取源进程的信息
            ProcessRecord callerApp = null;
            // 如果参数中的调用者不为空，则从AMS中找到对应的ProcessRecord，目的是得到调用者的pid和uid
            if (caller != null) { 
                callerApp = mService.getRecordForAppLocked(caller);
                if (callerApp != null) { 
                    // 保存 pid 和 uid
                    callingPid = callerApp.pid;
                    callingUid = callerApp.info.uid;
                } else { 
                    Slog.w(TAG, "Unable to find app for caller " + caller
                          + " (pid=" + callingPid + ") when starting: "
                          + intent.toString());
                    err = ActivityManager.START_PERMISSION_DENIED;
                }
            }
    
            final int userId = aInfo != null ? UserHandle.getUserId(aInfo.applicationInfo.uid) : 0;
    
            if (err == ActivityManager.START_SUCCESS) { 
                Slog.i(TAG, "START u" + userId + " {" + intent.toShortString(true, true, true, false)
                        + "} from uid " + callingUid
                        + " on display " + (container == null ? (mFocusedStack == null ?
                                Display.DEFAULT_DISPLAY : mFocusedStack.mDisplayId) :
                                (container.mActivityDisplay == null ? Display.DEFAULT_DISPLAY :
                                        container.mActivityDisplay.mDisplayId)));
            }
            // sourceRecord用于保存源进程actvity的信息
            ActivityRecord sourceRecord = null;
            // 如果需要获取result则将源进程actvity保存到此
            ActivityRecord resultRecord = null;
            // 通过resultTo 来找到Launcher所对应的activityRecord
            if (resultTo != null) { 
                sourceRecord = 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;
                    }
                }
            }
            //得到启动Activity使用的标志位
            final int launchFlags = intent.getFlags();
            // 没用过，忽略。。。FLAG_ACTIVITY_FORWARD_RESULT
            if ((launchFlags & Intent.FLAG_ACTIVITY_FORWARD_RESULT) != 0 && sourceRecord != null) { 
                // ....
            }
            // 检查一些条件
            // ....
    
            // 得到接受启动结果的task
            final ActivityStack resultStack = resultRecord == null ? null : resultRecord.task.stack;
    
            if (err != ActivityManager.START_SUCCESS) { 
                if (resultRecord != null) { 
                    // 暂时没有接受启动结果，所以忽略
                    resultStack.sendActivityResultLocked(-1,
                        resultRecord, resultWho, requestCode,
                        Activity.RESULT_CANCELED, null);
                }
                ActivityOptions.abort(options);
                return err;
            }
            // 检查权限
            boolean abort = false;
            final int startAnyPerm = mService.checkPermission(
                    START_ANY_ACTIVITY, callingPid, callingUid);
    
            if (startAnyPerm != PERMISSION_GRANTED) { 
                final int componentRestriction = getComponentRestrictionForCallingPackage(
                        aInfo, callingPackage, callingPid, callingUid, ignoreTargetSecurity);
                final int actionRestriction = getActionRestrictionForCallingPackage(
                        intent.getAction(), callingPackage, callingPid, callingUid);
    
                if (componentRestriction == ACTIVITY_RESTRICTION_PERMISSION
                        || actionRestriction == ACTIVITY_RESTRICTION_PERMISSION) { 
                    if (resultRecord != null) { 
                        resultStack.sendActivityResultLocked(-1,
                                resultRecord, resultWho, requestCode,
                                Activity.RESULT_CANCELED, null);
                    }
                    String msg;
                    if (actionRestriction == ACTIVITY_RESTRICTION_PERMISSION) { 
                        msg = "Permission Denial: starting " + intent.toString()
                                + " from " + callerApp + " (pid=" + callingPid
                                + ", uid=" + callingUid + ")" + " with revoked permission "
                                + ACTION_TO_RUNTIME_PERMISSION.get(intent.getAction());
                    } else if (!aInfo.exported) { 
                        msg = "Permission Denial: starting " + intent.toString()
                                + " from " + callerApp + " (pid=" + callingPid
                                + ", uid=" + callingUid + ")"
                                + " not exported from uid " + aInfo.applicationInfo.uid;
                    } else { 
                        msg = "Permission Denial: starting " + intent.toString()
                                + " from " + callerApp + " (pid=" + callingPid
                                + ", uid=" + callingUid + ")"
                                + " requires " + aInfo.permission;
                    }
                    Slog.w(TAG, msg);
                    throw new SecurityException(msg);
                }
    
                if (actionRestriction == ACTIVITY_RESTRICTION_APPOP) { 
                    String message = "Appop Denial: starting " + intent.toString()
                            + " from " + callerApp + " (pid=" + callingPid
                            + ", uid=" + callingUid + ")"
                            + " requires " + AppOpsManager.permissionToOp(
                                    ACTION_TO_RUNTIME_PERMISSION.get(intent.getAction()));
                    Slog.w(TAG, message);
                    abort = true;
                } else if (componentRestriction == ACTIVITY_RESTRICTION_APPOP) { 
                    String message = "Appop Denial: starting " + intent.toString()
                            + " from " + callerApp + " (pid=" + callingPid
                            + ", uid=" + callingUid + ")"
                            + " requires appop " + AppOpsManager.permissionToOp(aInfo.permission);
                    Slog.w(TAG, message);
                    abort = true;
                }
            }
            // 检查是否满足启动activity
            abort |= !mService.mIntentFirewall.checkStartActivity(intent, callingUid,
                    callingPid, resolvedType, aInfo.applicationInfo);
            // 通过接口，可以为AMS设置一个IActivityController类型的监听者；AMS进行操作时，将会回调该监听者
            // 没设置过，忽略。。。
            if (mService.mController != null) { 
                try { 
                    // The Intent we give to the watcher has the extra data
                    // stripped off, since it can contain private information.
                    // 是否能继续
                    Intent watchIntent = intent.cloneFilter();
                    abort |= !mService.mController.activityStarting(watchIntent,
                            aInfo.applicationInfo.packageName);
                } catch (RemoteException e) { 
                    mService.mController = null;
                }
            }
            // 如果不通过，则源进程activity将获取到一个取消的结果
            // startActvityForResult();
            if (abort) { 
                if (resultRecord != null) { 
                    resultStack.sendActivityResultLocked(-1, resultRecord, resultWho, requestCode,
                            Activity.RESULT_CANCELED, null);
                }
                // We pretend to the caller that it was really started, but
                // they will just get a cancel result.
                ActivityOptions.abort(options);
                return ActivityManager.START_SUCCESS;
            }
            // 用来描述即将启动的activity组件并构造ActivityRecord
            ActivityRecord r = new ActivityRecord(mService, callerApp, callingUid, callingPackage,
                    intent, resolvedType, aInfo, mService.mConfiguration, resultRecord, resultWho,
                    requestCode, componentSpecified, voiceSession != null, this, container, options);
           
            if (outActivity != null) { 
                outActivity[0] = r;
            }
    
            if (r.appTimeTracker == null && sourceRecord != null) { 
                // If the caller didn't specify an explicit time tracker, we want to continue
                // tracking under any it has.
                r.appTimeTracker = sourceRecord.appTimeTracker;
            }
    
            final ActivityStack stack = mFocusedStack;
    
            if (voiceSession == null && (stack.mResumedActivity == null
                    || stack.mResumedActivity.info.applicationInfo.uid != callingUid)) { 
                //检查调用进程是否有权限切换Activity
                if (!mService.checkAppSwitchAllowedLocked(callingPid, callingUid,
                        realCallingPid, realCallingUid, "Activity start")) { 
                    //如果调用进程没有权限进行切换，则将本次Activity的启动请求保存起来
                    //后续有机会再进行启动
                    PendingActivityLaunch pal =
                            new PendingActivityLaunch(r, sourceRecord, startFlags, stack);
                    mPendingActivityLaunches.add(pal);
                    ActivityOptions.abort(options);
                    return ActivityManager.START_SWITCHES_CANCELED;
                }
            }
    
            if (mService.mDidAppSwitch) { 
                // This is the second allowed switch since we stopped switches,
                // so now just generally allow switches. Use case: user presses
                // home (switches disabled, switch to home, mDidAppSwitch now true);
                // user taps a home icon (coming from home so allowed, we hit here
                // and now allow anyone to switch again).
                mService.mAppSwitchesAllowedTime = 0;
            } else { 
                mService.mDidAppSwitch = true;
            }
            // 启动延时的activity
            doPendingActivityLaunchesLocked(false);
            // 启动activity r 为目标activity sourceRecord为launcher
            err = startActivityUncheckedLocked(r, sourceRecord, voiceSession, voiceInteractor,
                    startFlags, true, options, inTask);
    
            if (err < 0) { 
                // If someone asked to have the keyguard dismissed on the next
                // activity start, but we are not actually doing an activity
                // switch... just dismiss the keyguard now, because we
                // probably want to see whatever is behind it.
                notifyActivityDrawnForKeyguard();
            }
            return err;
        }

该方法主要流程如下：

查找调用者的进程对象`ProcessRecord`，并查询到启动的`callingPid`和`callingUid`。

检查一下启动权限，当前`callerApp`是否可以打开`activity`，如果不能打开，且设置`activiytResult`，则会给一个回调：`RESULT_CANCELED`

构造`ActivityRecord`，该对象就代表了未来打开的`activity`

判断当前`AMS`是否打开`activity`，如果不能打开，则会存储一下，等待下次打开时机。

最后调用`startActivityUncheckedLocked()`启动。

##### `ActivityStackSupervisor`的`startActivityUncheckedLocked()` #####

final int startActivityUncheckedLocked(final ActivityRecord r, ActivityRecord sourceRecord,
                IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor, int startFlags,
                boolean doResume, Bundle options, TaskRecord inTask) { 
            // .... 
            
            // 以上省略的代码有400行。。。。主要是根据flag等判断其所在的目标任务栈`ActivityStack`
            
            // 启动新的activity
            targetStack.startActivityLocked(r, newTask, doResume, keepCurTransition, options);
            if (!launchTaskBehind) { 
                // Don't set focus on an activity that's going to the back.
                mService.setFocusedActivityLocked(r, "startedActivity");
            }
            return ActivityManager.START_SUCCESS;
        }

该逻辑中主要是找到`activity`应该在的`ActivityStack`

##### `ActivityStack`的`startActivityLocked()` #####

final void startActivityLocked(ActivityRecord r, boolean newTask,
                boolean doResume, boolean keepCurTransition, Bundle options) { 
            // 将activity加入到task中
            task.addActivityToTop(r);
             // 添加了新的Activity, 所以需要给 ActivityRecord的变量frontOfTask重新赋值
            // 该变量在后面会用到, 表示是否是 TaskRecord集合中第一个元素, 也就是根元素
            task.setFrontOfTask();
                
            if (doResume) { 
                // 激活activity堆栈顶端的activity组件激活，该组件就是要启动的activity
                mStackSupervisor.resumeTopActivitiesLocked(this, r, options);
            }
        }

在改方法

构造任务栈，并且将`activity`添加到`task`中。

然后激活顶端的`activity`组件

##### 通过`ActivityStackSupervisor`最终调用`ActivityStack`的`resumeTopActivityInnerLocked()` #####

boolean resumeTopActivitiesLocked(ActivityStack targetStack, ActivityRecord target,
                Bundle targetOptions) { 
            if (targetStack == null) { 
                targetStack = mFocusedStack;
            }
            // Do targetStack first.
            boolean result = false;
            if (isFrontStack(targetStack)) { 
                // 在开始的时候，将新建的任务栈移动到了前台
                result = targetStack.resumeTopActivityLocked(target, targetOptions);
            }
    
            for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 
                final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
                for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 
                    final ActivityStack stack = stacks.get(stackNdx);
                    if (stack == targetStack) { 
                        // Already started above.
                        continue;
                    }
                    if (isFrontStack(stack)) { 
                        stack.resumeTopActivityLocked(null);
                    }
                }
            }
            return result;
        }

final boolean resumeTopActivityLocked(ActivityRecord prev, Bundle 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()` #####

private boolean resumeTopActivityInnerLocked(ActivityRecord prev, Bundle options) { 
            // ...
            // 如果当前显示的activity不为null，则发送一个停止的通知
            // We need to start pausing the current activity so the top one
            // can be resumed...
            boolean dontWaitForPause = (next.info.flags&ActivityInfo.FLAG_RESUME_WHILE_PAUSING) != 0;
            boolean pausing = mStackSupervisor.pauseBackStacks(userLeaving, true, dontWaitForPause);
            if (mResumedActivity != null) { 
                if (DEBUG_STATES) Slog.d(TAG_STATES,
                        "resumeTopActivityLocked: Pausing " + mResumedActivity);
                        
                pausing |= startPausingLocked(userLeaving, false, true, dontWaitForPause);
            }
            // 后面的逻辑非常重要，但是一会才走
            return true;
        }

在该方法中，准备启动顶部的`activity`时，发现`launcherActivity`仍在显示，所以需要先停止`Launcher`

##### `ActivityStack`的`startPausingLocked` #####

final boolean startPausingLocked(boolean userLeaving, boolean uiSleeping, boolean resuming,
                boolean dontWait) { 
            // ...
            
            // launcher对象 
            ActivityRecord prev = mResumedActivity;
            if (prev == null) { 
                if (!resuming) { 
                    Slog.wtf(TAG, "Trying to pause when nothing is resumed");
                    mStackSupervisor.resumeTopActivitiesLocked();
                }
                return false;
            }
    
            if (mActivityContainer.mParentActivity == null) { 
                // Top level stack, not a child. Look for child stacks.
                mStackSupervisor.pauseChildStacks(prev, userLeaving, uiSleeping, resuming, dontWait);
            }
    
            if (DEBUG_STATES) Slog.v(TAG_STATES, "Moving to PAUSING: " + prev);
            else if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Start pausing: " + prev);
            // 将mPausingActivity 和 mLastPausedActivity置为launcher对象
            mResumedActivity = null;
            mPausingActivity = prev;
            mLastPausedActivity = prev;
            mLastNoHistoryActivity = (prev.intent.getFlags() & Intent.FLAG_ACTIVITY_NO_HISTORY) != 0
                    || (prev.info.flags & ActivityInfo.FLAG_NO_HISTORY) != 0 ? prev : null;
            prev.state = ActivityState.PAUSING;
            prev.task.touchActiveTime();
            // ....
    
            if (prev.app != null && prev.app.thread != null) { 
                if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Enqueueing pending pause: " + prev);
                try { 
                    EventLog.writeEvent(EventLogTags.AM_PAUSE_ACTIVITY,
                            prev.userId, System.identityHashCode(prev),
                            prev.shortComponentName);
                    mService.updateUsageStats(prev, false);
                    // 告诉launcher一个通知，状态变更,此时其实调用的`ActivityThread`中`ApplicationThread`的代理对象
                    prev.app.thread.schedulePauseActivity(prev.appToken, prev.finishing,
                            userLeaving, prev.configChangeFlags, dontWait);
                } catch (Exception e) { 
                    // Ignore exception, if process died other code will cleanup.
                    Slog.w(TAG, "Exception thrown during pause", e);
                    mPausingActivity = null;
                    mLastPausedActivity = null;
                    mLastNoHistoryActivity = null;
                }
            } else { 
                mPausingActivity = null;
                mLastPausedActivity = null;
                mLastNoHistoryActivity = null;
            }
            // ....
            if (mPausingActivity != null) { 
                // ....
                if (dontWait) { 
                    // If the caller said they don't want to wait for the pause, then complete
                    // the pause now.
                    completePauseLocked(false);
                    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.
                    // 构造一个handler ,等待launcher状态结束之后，再次发起启动操作
                    Message msg = mHandler.obtainMessage(PAUSE_TIMEOUT_MSG);
                    msg.obj = prev;
                    prev.pauseTime = SystemClock.uptimeMillis();
                    mHandler.sendMessageDelayed(msg, PAUSE_TIMEOUT);
                    if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Waiting for pause to complete...");
                    return true;
                }
    
            } else { 
                // ....
                return false;
            }
        }

该方法中做了两件事情

通知`LauncherActivity`,你该停止了。

自己发了一个`handler`，防止`pause`超时，如果超时，则继续往下执行

在该方法中，通过`ApplicationThread`的`Binder`对象，通知到`Launcher`进程，于是下面又回到`Launcher`进程

> 总结  
> 1.在`Launcher`进程中，通过`Binder`调用到了`AMS`的`startActivity()`方法。  
> 2.`AMS`的`startActivity()`会调用`ActivityStackSupervisor`的`startActivityMayWait()`方法，`ActivityStackSupervisor`负责管理`activity`以及`task`。  
> 3.依次调用`ActivityStackSupervisor`的`startActivityMayWait` \-> `startActivityLocked()` , 在这个中间过程中创建了`ActivityStack`，`ActivityRecord`  
> 4.然后调用`ActivityStack`的`startActivityLocked()`方法,在该方法中找到任务栈`task`，并添加绑订关系。  
> 5.继续回到`ActivityStackSupervisor`，调用`resumeTopActivitiesLocked()`进行激活操作。应为之前只是把将要启动的`ActivityRecord`到任务栈中，并没有激活。  
> 6.经过一系列方法最终调用`ActvityStack`的`resumeTopActivityInnerLocked()`方法，在该方法中，会检测所有的`ActivityStack`有没有正处于`resume`的`ActviityRecord`，因为此时`LauncherActivity`仍在显示中，所以此时会调用`ActivityStack`的`startPausingLocked()`做`pause`操作.  
> 7.最终通过`Binder`机制，通过`applicationThread`代理对象调用`schedulePauseActivity()`,通知`Launcher`进程停止。在通知过程中会发送一个延时`handler`，处理超时逻辑。

#### `Launcher`进程 ####

##### `ApplicationThread`的`schedulePauseActivity()` #####

public final void schedulePauseActivity(IBinder token, boolean finished,
                    boolean userLeaving, int configChanges, boolean dontReport) { 
                // 发送一个类型为PAUSE_ACTIVITY的状态变更
                sendMessage(
                        finished ? H.PAUSE_ACTIVITY_FINISHING : H.PAUSE_ACTIVITY,
                        token,
                        (userLeaving ? 1 : 0) | (dontReport ? 2 : 0),
                        configChanges);
            }

`H`为`ActivityThread`的一个对象，实际会在该类的`handlerMessage()`

##### `H`的`handlerMessage()` #####

case PAUSE_ACTIVITY:
                        // 暂停activity
                        Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityPause");
                        handlePauseActivity((IBinder)msg.obj, false, (msg.arg1&1) != 0, msg.arg2,
                                (msg.arg1&2) != 0);
                        maybeSnapshot();
                        Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                        break;

private void handlePauseActivity(IBinder token, boolean finished,
                boolean userLeaving, int configChanges, boolean dontReport) { 
            ActivityClientRecord r = mActivities.get(token);
            if (r != null) { 
                //Slog.v(TAG, "userLeaving=" + userLeaving + " handling pause of " + r);
                if (userLeaving) { 
                    // 发送一个用户离开时间通知，及onUserLeaveHint()
                    performUserLeavingActivity(r);
                }
    
                r.activity.mConfigChangeFlags |= configChanges;
                // 发送一个中止事件，调用onPause
                performPauseActivity(token, finished, r.isPreHoneycomb());
    
                // Make sure any pending writes are now committed.
                if (r.isPreHoneycomb()) { 
                    // 等待一些数据写入操作
                    QueuedWork.waitToFinish();
                }
    
                // Tell the activity manager we have paused.
                if (!dontReport) { 
                    try { 
                        // 通知ams activity 已经pause ，token代表activityRecord的标志
                        ActivityManagerNative.getDefault().activityPaused(token);
                    } catch (RemoteException ex) { 
                    }
                }
                mSomeActivitiesChanged = true;
            }
        }

该方法中做了一些回调，最终通过`ActivityManagerProxy`通知`AMS`调用了`activityPaused()`。

> 总结  
> 1.通过`ApplicationThread`，`AMS`调用了`launcher`的`schedulePauseActivity()`方法，该方法会发送一个`handler`，最终调用`handlePauseActivity()`。  
> 2.在`handlePauseActivity()`中，会调用`performPauseActivity()`，此时会回调`onPause()`方法。  
> 3.最终继续通过`ams`的代理对象，有回到了`ams`进程，并调用`activityPaused()`方法。

#### `AMS`进程 ####

##### `AMS`中`activityPause()` #####

@Override
        public final void activityPaused(IBinder token) { 
            final long origId = Binder.clearCallingIdentity();
            synchronized(this) { 
                // 通过token获取到activityRecord LauncherActivity
                ActivityStack stack = ActivityRecord.getStackLocked(token);
                if (stack != null) { 
                    stack.activityPausedLocked(token, false);
                }
            }
            Binder.restoreCallingIdentity(origId);
        }

通知`ActivityStack`暂停

##### `ActivityStack`的 #####

final void activityPausedLocked(IBinder token, boolean timeout) { 
            if (DEBUG_PAUSE) Slog.v(TAG_PAUSE,
                "Activity paused: token=" + token + ", timeout=" + timeout);
    
            final ActivityRecord r = isInStackLocked(token);
            if (r != null) { 
                // 移除超时
                mHandler.removeMessages(PAUSE_TIMEOUT_MSG, r);
                if (mPausingActivity == r) { 
                    if (DEBUG_STATES) Slog.v(TAG_STATES, "Moving to PAUSED: " + r
                            + (timeout ? " (due to timeout)" : " (pause complete)"));
                    // pause完成
                    completePauseLocked(true);
                } else { 
                    EventLog.writeEvent(EventLogTags.AM_FAILED_TO_PAUSE,
                            r.userId, System.identityHashCode(r), r.shortComponentName,
                            mPausingActivity != null
                                ? mPausingActivity.shortComponentName : "(none)");
                    if (r.finishing && r.state == ActivityState.PAUSING) { 
                        if (DEBUG_PAUSE) Slog.v(TAG,
                                "Executing finish of failed to pause activity: " + r);
                        finishCurrentActivityLocked(r, FINISH_AFTER_VISIBLE, false);
                    }
                }
            }
        }

该方法主要移除超时，然后调用`completePauseLocked()`

##### `ActivityStack`的`completePauseLocked()` #####

private void completePauseLocked(boolean resumeNext) { 
            ActivityRecord prev = mPausingActivity;
            if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Complete pause: " + prev);
            // 处理LauncherActivity
            if (prev != null) { 
                // .....
                mPausingActivity = null;
            }
    
            if (resumeNext) { 
                final ActivityStack topStack = mStackSupervisor.getFocusedStack();
                if (!mService.isSleepingOrShuttingDown()) { 
                    // 继续恢复当前在前端的ActivityStack的页面，又会走到resumeTopActivityInnerLocked方法
                    mStackSupervisor.resumeTopActivitiesLocked(topStack, prev, null);
                } else { 
                    mStackSupervisor.checkReadyForSleepLocked();
                    ActivityRecord top = topStack.topRunningActivityLocked(null);
                    if (top == null || (prev != null && top != prev)) { 
                        // If there are no more activities available to run,
                        // do resume anyway to start something. Also if the top
                        // activity on the stack is not the just paused activity,
                        // we need to go ahead and resume it to ensure we complete
                        // an in-flight app switch.
                        mStackSupervisor.resumeTopActivitiesLocked(topStack, null, null);
                    }
                }
            }
            // ....
        }

##### `ActivityStack`的`resumeTopActivityInnerLocked()` #####

private boolean resumeTopActivityInnerLocked(ActivityRecord prev, Bundle options) { 
            // ...
            // 如果当前显示的activity不为null，则发送一个停止的通知
            // We need to start pausing the current activity so the top one
            // can be resumed...
            boolean dontWaitForPause = (next.info.flags&ActivityInfo.FLAG_RESUME_WHILE_PAUSING) != 0;
            // 暂停其余`ActivityStack`中是否有正在显示的activity
            boolean pausing = mStackSupervisor.pauseBackStacks(userLeaving, true, dontWaitForPause);
            if (mResumedActivity != null) { 
                if (DEBUG_STATES) Slog.d(TAG_STATES,
                        "resumeTopActivityLocked: Pausing " + mResumedActivity);
                        
                pausing |= startPausingLocked(userLeaving, false, true, dontWaitForPause);
            }
            // 后面的逻辑非常重要，现在开始走后面的逻辑
            
            return true;
        }

##### `ActivityStack`的`resumeTopActivityInnerLocked()` #####

private boolean resumeTopActivityInnerLocked(ActivityRecord prev, Bundle options) { 
            // ...
            if (next.app != null && next.app.thread != null) { 
                // 如果当前activity的app已经绑定了，说明activity已经启动过一次了，所以直接走恢复流程
           
            } else { 
                // 如果没有指定`ActivityThread`，则说明没有加入到`ActivityThread`中
                // 启动activity
                mStackSupervisor.startSpecificActivityLocked(next, true, true);
            }
            // ....
            return true;
        }

##### `ActivityStackSupervisor`的 `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.task.stack.setLaunchTime(r);
    
            if (app != null && app.thread != null) { 
                // 判断进程是否已经创建，如果创建了，只需要启动`activity`即可
                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);
        }

##### 调用`ActivityManagerService`创建进程`startProcessLocked()` #####

创建过程的实质就是创建`ActivityThread`

private final void startProcessLocked(ProcessRecord app, String hostingType,
                String hostingNameStr, String abiOverride, String entryPoint, String[] entryPointArgs) { 
                // ... 
    
                // Start the process. It will either succeed and return a result containing
                // the PID of the new process, or else throw a RuntimeException.
                boolean isActivityProcess = (entryPoint == null);
                if (entryPoint == null) entryPoint = "android.app.ActivityThread";
                // ... 
                // 启动一个ActivityThread对象
                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);
                checkTime(startTime, "startProcess: returned from zygote!");
                Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
          
                checkTime(startTime, "startProcess: building log message");
                StringBuilder buf = mStringBuilder;
                buf.setLength(0);
                buf.append("Start proc ");
                buf.append(startResult.pid);
                buf.append(':');
                buf.append(app.processName);
                buf.append('/');
                UserHandle.formatUid(buf, uid);
                if (!isActivityProcess) { 
                    buf.append(" [");
                    buf.append(entryPoint);
                    buf.append("]");
                }
                buf.append(" for ");
                buf.append(hostingType);
                if (hostingNameStr != null) { 
                    buf.append(" ");
                    buf.append(hostingNameStr);
                }
                Slog.i(TAG, buf.toString());
                app.setPid(startResult.pid);
                app.usingWrapper = startResult.usingWrapper;
                app.removed = false;
                app.killed = false;
                app.killedByAm = false;
                checkTime(startTime, "startProcess: starting to update pids map");
                synchronized (mPidsSelfLocked) { 
                    this.mPidsSelfLocked.put(startResult.pid, app);
                    if (isActivityProcess) { 
                        // //发送一个延迟消息
                        //在消息被处理前，若新创建的进程没有和AMS交互，那么该进程启动失败
                        //正常延迟时间为10s
                        Message msg = mHandler.obtainMessage(PROC_START_TIMEOUT_MSG);
                        msg.obj = app;
                        mHandler.sendMessageDelayed(msg, startResult.usingWrapper
                                ? PROC_START_TIMEOUT_WITH_WRAPPER : PROC_START_TIMEOUT);
                    }
                }
                checkTime(startTime, "startProcess: done updating pids map");
            } catch (RuntimeException e) { 
                // XXX do better error recovery.
                app.setPid(0);
                mBatteryStatsService.noteProcessFinish(app.processName, app.info.uid);
                if (app.isolated) { 
                    mBatteryStatsService.removeIsolatedUid(app.uid, app.info.uid);
                }
                Slog.e(TAG, "Failure starting process " + app.processName, e);
            }
        }

如上开始创建`app`的进程

> 总结  
> 1.先调用`ams`进程的`activityPause()`方法，根据`token`找到对应的`ActivityStack`，并调用`activityPausedLocked()`方法。  
> 2.在`activityPausedLocked()`中先移除之前的超时检测，然后继续调用方法`completePauseLocked()`。  
> 3.找到当前有焦点的`ActivityStack`，继续调用`resumeTopActivitiesLocked()`方法，恢复最顶的`activity`。  
> 4.因为所有的`activity`都已经处于`pause`了，所以判断当前需要恢复的`ActivityRecod`是否已经启动过，如果已经启动过，则直接恢复就行，如果没有，则说明还没有和`ActivityThread`绑订，既没有打开过。如果没有绑订，则调用`ActivityStackSupervisor`的`startSpecificActivityLocked()`进行启动工作。  
> 5.在`startSpecificActivityLocked()`中，会先判断进程创建没有，如果没有穿件，则先创建进程，此时应为目标`activity`还没有创建进程，所以会先创建进程。调用`ams`的`startProcessLocked()`方法。  
> 6. 核心就是调用 `AcivityThread`的`main()`方法。

#### `app`进程 ####

##### `ActivityThread`的`main` #####

public static void main(String[] args) { 
            Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");
            SamplingProfilerIntegration.start();
    
            // CloseGuard defaults to true and can be quite spammy. We
            // disable it here, but selectively enable it later (via
            // StrictMode) on debug builds, but using DropBox, not logs.
            CloseGuard.setEnabled(false);
    
            Environment.initForCurrentUser();
    
            // Set the reporter for event logging in libcore
            EventLogger.setReporter(new EventLoggingReporter());
    
            AndroidKeyStoreProvider.install();
    
            // Make sure TrustedCertificateStore looks in the right place for CA certificates
            final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());
            TrustedCertificateStore.setDefaultUserDirectory(configDir);
    
            Process.setArgV0("<pre-initialized>");
            // handler
            Looper.prepareMainLooper();
            // 构造ActivityThread
            ActivityThread thread = new ActivityThread();
            thread.attach(false);
    
            if (sMainThreadHandler == null) { 
                sMainThreadHandler = thread.getHandler();
            }
    
            if (false) { 
                Looper.myLooper().setMessageLogging(new
                        LogPrinter(Log.DEBUG, "ActivityThread"));
            }
    
            // End of event ActivityThreadMain.
            Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
            Looper.loop();
    
            throw new RuntimeException("Main thread loop unexpectedly exited");
        }

关键在于`thread.attach(false)`方法

##### `ActivityThread`的`attach()` #####

private void attach(boolean system) { 
            sCurrentActivityThread = this;
            mSystemThread = system;
            if (!system) { 
                // ... 
                android.ddm.DdmHandleAppName.setAppName("<pre-initialized>",
                                                        UserHandle.myUserId());
                // 设置appThread
                RuntimeInit.setApplicationObject(mAppThread.asBinder());
                final IActivityManager mgr = ActivityManagerNative.getDefault();
                try { 
                    // 调用 ams 的 attachApplication（） 方法，此时又回到了ams进程
                    mgr.attachApplication(mAppThread);
                } catch (RemoteException ex) { 
                    // Ignore
                }
                
            } else { 
                // ... 
            }
        }

通过`mgr.attachApplication(mAppThread);`又回到了`ams`的进程

> 总结  
> 调用`ActivityThread`的`main()`，完成初始化工作。内部调用了`ActivityThread`的`attch()`方法，该方法会通知`ams`的`attachApplication()`,参数为`ApplicationThread`。

#### `AMS`进程 ####

##### `AMS`的`attachApplication()` #####

@Override
        public final void attachApplication(IApplicationThread thread) { 
            synchronized (this) { 
                int callingPid = Binder.getCallingPid();
                final long origId = Binder.clearCallingIdentity();
                attachApplicationLocked(thread, callingPid);
                Binder.restoreCallingIdentity(origId);
            }
        }

private final boolean attachApplicationLocked(IApplicationThread thread,
                int pid) { 
    
            // Find the application record that is being attached... either via
            // the pid if we are running in multiple processes, or just pull the
            // next app record if we are emulating process with anonymous threads.
            // 取出进程id
            ProcessRecord app;
            // ...
    
            // If this application record is still attached to a previous
            // process, clean it up now.
            if (app.thread != null) { 
                handleAppDiedLocked(app, true, true);
            }
    
            // Tell the process all about itself.
            // 初始化进程
            if (DEBUG_ALL) Slog.v(
                    TAG, "Binding process pid " + pid + " to record " + app);
                 // ....
                // 回调进程信息
                thread.bindApplication(processName, appInfo, providers, app.instrumentationClass,
                        profilerInfo, app.instrumentationArguments, app.instrumentationWatcher,
                        app.instrumentationUiAutomationConnection, testMode, enableOpenGlTrace,
                        isRestrictedBackupMode || !normalMode, app.persistent,
                        new Configuration(mConfiguration), app.compat,
                        getCommonServicesLocked(app.isolated),
                        mCoreSettingsObserver.getCoreSettingsLocked());
                updateLruProcessLocked(app, false, null);
                app.lastRequestedGc = app.lastLowMemory = SystemClock.uptimeMillis();
            } catch (Exception e) { 
                // ....
                return false;
            }
    
            // See if the top visible activity is waiting to run in this process...
            if (normalMode) { 
                try { 
                    // 告诉stackSupervisor ,进程启动成功
                    if (mStackSupervisor.attachApplicationLocked(app)) { 
                        didSomething = true;
                    }
                } catch (Exception e) { 
                    Slog.wtf(TAG, "Exception thrown launching activities in " + app, e);
                    badApp = true;
                }
            }
            // ...
            return true;
        }

##### 调用`ActivityStackSupervisor`的`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<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
                for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 
                    final ActivityStack stack = stacks.get(stackNdx);
                    if (!isFrontStack(stack)) { 
                        continue;
                    }
                    ActivityRecord hr = stack.topRunningActivityLocked(null);
                    if (hr != null) { 
                        if (hr.app == null && app.uid == hr.info.applicationInfo.uid
                                && processName.equals(hr.processName)) { 
                            try { 
                                // 启动actvity的方法
                                if (realStartActivityLocked(hr, app, true, true)) { 
                                    didSomething = true;
                                }
                            } catch (RemoteException e) { 
                                Slog.w(TAG, "Exception in new application when starting activity "
                                      + hr.intent.getComponent().flattenToShortString(), e);
                                throw e;
                            }
                        }
                    }
                }
            }
            if (!didSomething) { 
                ensureActivitiesVisibleLocked(null, 0);
            }
            return didSomething;
        }

final boolean realStartActivityLocked(ActivityRecord r,
                ProcessRecord app, boolean andResume, boolean checkConfig)
                throws RemoteException { 
                 // ...
                 r.app = app;
                 // ...
                 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);
    
    }

> 总结  
> 1.`ams`收到`attachApplication()`之后，会回调告诉`app`进程，新创建的进程一些信息。  
> 2.然后调用`ActivityStackSupervisor`的`attachApplicationLocked()`,查找获取焦点的`stack`，并调用`realStartActivityLocked()`，  
> 3.绑订`ActivityRecord`和`ApplicationThread`，然后告诉`app`进程，启动`activity`.

#### `app`进程 ####

##### `ActivityThread`的`scheduleLaunchActivity()` #####

@Override
            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) { 
                // 告诉ThreadActivity需要启动的进程
                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);
            }

最终会调用到`performLaunchActivity()`

private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) { 
            // ActivityClientRecord 包含了
            // System.out.println("##### [" + System.currentTimeMillis() + "] ActivityThread.performLaunchActivity(" + r + ")");
    
            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 { 
                // 获取class loader
                java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
                // 构造一个新的activity
                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) { 
                if (!mInstrumentation.onException(activity, e)) { 
                    throw new RuntimeException(
                        "Unable to instantiate activity " + component
                        + ": " + e.toString(), e);
                }
            }
    
            try { 
                // 构造application对象
                Application app = r.packageInfo.makeApplication(false, mInstrumentation);
    
                if (localLOGV) Slog.v(TAG, "Performing launch of " + r);
                if (localLOGV) Slog.v(
                        TAG, r + ": app=" + app
                        + ", appName=" + app.getPackageName()
                        + ", pkg=" + r.packageInfo.getPackageName()
                        + ", comp=" + r.intent.getComponent().toShortString()
                        + ", dir=" + r.packageInfo.getAppDir());
    
                if (activity != null) { 
                    // 创建基础的context对象
                    Context appContext = createBaseContextForActivity(r, activity);
                    CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
                    Configuration config = new Configuration(mCompatConfiguration);
                    if (DEBUG_CONFIGURATION) Slog.v(TAG, "Launching activity "
                            + r.activityInfo.name + " with config " + config);
                    // 初始化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);
    
                    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()) { 
                        // 调用onCreate方法
                        mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
                    } else { 
                        mInstrumentation.callActivityOnCreate(activity, r.state);
                    }
                    if (!activity.mCalled) { 
                        throw new SuperNotCalledException(
                            "Activity " + r.intent.getComponent().toShortString() +
                            " did not call through to super.onCreate()");
                    }
                    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);
                        }
                        if (!activity.mCalled) { 
                            throw new SuperNotCalledException(
                                "Activity " + r.intent.getComponent().toShortString() +
                                " did not call through to super.onPostCreate()");
                        }
                    }
                }
                r.paused = true;
    
                mActivities.put(r.token, r);
    
            } catch (SuperNotCalledException e) { 
                throw e;
    
            } catch (Exception e) { 
                if (!mInstrumentation.onException(activity, e)) { 
                    throw new RuntimeException(
                        "Unable to start activity " + component
                        + ": " + e.toString(), e);
                }
            }
    
            return activity;
        }

> 总结  
> `app`进程中，最后调用`performLaunchActivity()`，完成`activity`的创建，完成`application`的创建等。。。。

### 来张图 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpc2R5ZTI_size_16_color_FFFFFF_t_70]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpc2R5ZTI_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200208165420450.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpc2R5ZTI=,size_16,color_FFFFFF,t_70