Activity的启动流程

activity 的启动流程
ActivityManagerService（ActivityManagerNative）
ActivityStackSupervisor 管理整个手机任务栈
ActivityStack Activity的栈（任务栈）
PackageManagerService(完成组件在清单里的扫描和注册)
ActivityThread(安卓java应用层的入口函数类)
C/S 架构思想
ServiceManager
多进程多任务多窗口多app
分模块思想
Activity
分层次思想

在Activity里面启动应用最终会走到startActivityForResult()

1、Activity#startActivityForResult()

mInstrumentation.execStartActivity(
                   this, mMainThread.getApplicationThread(), mToken, this,
                   intent, requestCode, options);

• mInstrumentation是Activity的成员变量，它用来监控应用程序和系统的交互；

• mMainThread也是Activity的成员变量，都是通过attach()方法在ActivityThread创建Activity的时候传递给Activity作为成员变量。

• mMainThread.getApplicationThread()，获取到的是ApplicationThread类型的对象，他是Activty的一个内部类，继承于ApplicationThreadNative，是一个binder对象ActivityThread远程交互存根，ActivityManagerService（继承于ActivityManagerNative）会使用它来和ActivityThread来进行进程间通信，Activity、Service的创建、生命周期都是它与系统ActivityManagerService来交互的

2、Instrumentation#execStartActivity()

int result = ActivityManagerNative.getDefault()//拿到ActivityManagerServiece的远程代理
                .startActivity(whoThread, who.getBasePackageName(), intent,
                        intent.resolveTypeIfNeeded(who.getContentResolver()),
                        token, target != null ? target.mEmbeddedID : null,
                        requestCode, 0, null, options);

• ActivityManagerNative.getDefault()拿到的是ActivityManagerService(通过ManagerService)系统服务在当先进程的本地代理（Proxy），startActivity（）调用的是ActivityManagerProxy.startActivity方法。

Parcel data = Parcel.obtain();
        Parcel reply = Parcel.obtain();
        data.writeInterfaceToken(IActivityManager.descriptor);
        data.writeStrongBinder(caller != null ? caller.asBinder() : null);
        data.writeString(callingPackage);
        intent.writeToParcel(data, 0);
        data.writeString(resolvedType);
        data.writeStrongBinder(resultTo);
        data.writeString(resultWho);
        data.writeInt(requestCode);
        data.writeInt(startFlags);
        if (profilerInfo != null) {
            data.writeInt(1);
            profilerInfo.writeToParcel(data, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
        } else {
            data.writeInt(0);
        }
        if (options != null) {
            data.writeInt(1);
            options.writeToParcel(data, 0);
        } else {
            data.writeInt(0);
        }
        mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);

可以看到这里就就是进行进程间通讯了

• whoThread：ApplicationThread，一个binder对象，作为参数将会传递到AcitivityMangerService远程服务中，后面会用此作为远程回调，在AtivityThread中对Activity的生命周期的控制都是在这个类里面。
• 另外传入的参数还有intent、应用包名等等。

---

开始跨进程

3、ActivityManagerService#startActivity()
通过上一步就调用到ActivityManagerService中来，属于系统服务进程，已经进行了跨进程操作。

@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) {
        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) {
        enforceNotIsolatedCaller("startActivity");
        userId = handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(), userId,
                false, ALLOW_FULL_ONLY, "startActivity", null);
        // TODO: Switch to user app stacks here.
        return mStackSupervisor.startActivityMayWait(caller, -1, callingPackage, intent,
                resolvedType, null, null, resultTo, resultWho, requestCode, startFlags,
                profilerInfo, null, null, options, false, userId, null, null);
    }

ActivityStackSupervsior是用用来管理手机所有的Activity的栈信息的一个类

4、ActivityStackSupervsior.startActivityMayWait()

// Collect information about the target of the Intent.
ActivityInfo aInfo =
                resolveActivity(intent, resolvedType, startFlags, profilerInfo, userId);

resolveActivity{
        try {
            ResolveInfo rInfo =
                AppGlobals.getPackageManager().resolveIntent(
                        intent, resolvedType,
                        PackageManager.MATCH_DEFAULT_ONLY
                                    | ActivityManagerService.STOCK_PM_FLAGS, userId);
            aInfo = rInfo != null ? rInfo.activityInfo : null;
        } catch (RemoteException e) {
            aInfo = null;
        }
    if (aInfo != null) {
            // Store the found target back into the intent, because now that
            // we have it we never want to do this again.  For example, if the
            // user navigates back to this point in the history, we should
            // always restart the exact same activity.
            intent.setComponent(new ComponentName(
                    aInfo.applicationInfo.packageName, aInfo.name));
}

AppGlobals.getPackageManager()拿到PackageManagerService系统服务，去扫描所有的app（IPC），拿到符合intent匹配规则的Activity的相关信息保存到aInfo中。aInfo是一个ActivityInfo类型，他包含了在Manifest中注册Activity的所有信息和一些其他启动需要的信息。

5、ActivityStackSupervsior.startActivityLocked
验证intent、Class、Permission等
保存将要启动的Activity的Record

//把启动的应用的进程信息保存到callerApp中
callerApp = mService.getRecordForAppLocked(caller);

ProcessRecord callerApp 保存的是启动应用的进程信息，反正xxxRecord顾名思义就是用来记录信息用的。
ActivityRecord保存了Activity所需要的很多的信息
startActivityUncheckedLocked（）:

{
int launchFlags = intent.getFlags();
if (r.resultTo != null && (launchFlags & Intent.FLAG_ACTIVITY_NEW_TASK) != 0
                && r.resultTo.task.stack != null) {
            // For whatever reason this activity is being launched into a new
            // task...  yet the caller has requested a result back.  Well, that
            // is pretty messed up, so instead immediately send back a cancel
            // and let the new task continue launched as normal without a
            // dependency on its originator.
            Slog.w(TAG, "Activity is launching as a new task, so cancelling activity result.");
            r.resultTo.task.stack.sendActivityResultLocked(-1,
                    r.resultTo, r.resultWho, r.requestCode,
                    Activity.RESULT_CANCELED, null);
            r.resultTo = null;
        }
}

检查将要启动的Activity的launchMode和启动Flag，根据launcheMode和Flag配置task

6、ActivityStack.startActivityLocked()
去检查是否要简历新的任务栈

7、ActivityStackSupervsior.resumeTopActivityLocked()
查找需要暂停的Activity。

8、ActivityStack---------->startPausingLocked()

prev.app.thread.schedulePauseActivity(prev.appToken, prev.finishing,
                        userLeaving, prev.configChangeFlags, dontWait);
这里调用到ActivityThread的ApplicationThread的远对象，进行进程间通讯

正式让之前的Activity暂停
告诉AMS已经暂停完成

9.ApplicationThread.handlePauseActivity()
在用户进程执行performPauseActivity(token, finished, r.isPreHoneycomb());最终调用Activity的onPause(),等到Activity暂停之后再次和AMS进程通信调用：ActivityManagerNative.getDefault().activityPaused(token);告诉AMS Activity已经暂停，可以启动新的Activity。

10、AMS-->activityPaused()
11.ActivityStack->activityPausedLocked()->finishCurrentActivityLocked()
12.ActivityStackSuperVisor------> resumeTopActivitiesLocked()
13.ActivityStack----------------> resumeTopActivityLocked()
该进程不存在，创建进程
14.ActivityStackSuperVisor------> startSpecificActivityLocked()
15.ActivityManagerService-------> startProcessLocked()
16.Process.start()
这里主要是调用Process.start接口来创建一个新的进程，新的进程会导入android.app.ActivityThread类，并且执行它的main函数，这就是为什么我们前面说每一个应用程序都有一个ActivityThread实例来对应的原因

17.ActivityThread.main()
18.AMS.attachApplication();
函数attach最终调用了ActivityManagerService的远程接口ActivityManagerProxy的attachApplication函数，传入的参数是mAppThread，这是一个ApplicationThread类型的Binder对象，它的作用是用来进行进程间通信的
19 ActivityManagerProxy.attachApplication
20.ActivityManagerService.attachApplicationLocked
准备启动应用，先查找MainActivity
21ActivityStackSuperVisor------>attachApplicationLocked--->realStartActivityLocked()

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

21 ActivityThread----------> scheduleLaunchActivity()
最终通过IPC调用到ActivityThread的scheduleLaunchActivity()来执行Activity的生命周期的函数。