ActivityManagerService屬于系統(tǒng)核心服務，主要負責管理Activity等組件肖方，是由SystemServer啟動的

    //frameworks/base/services/java/com/android/server/SystemServer.java
    private void run(){
        //做一些初始化操作闺魏，主要創(chuàng)建systemserver的Context以及ActivityThread
        createSystemContext();
        startCoreServices(t);
        startOtherServices(t);
        //ams在這里面
        startBootstrapServices(t);
        Looper.loop();
    }
    private void startBootstrapServices(@NonNull TimingsTraceAndSlog t) {

        //startService先通過反射創(chuàng)建了ActivityTaskManagerService.Lifecycle對象(在其構造函數(shù)里面創(chuàng)建了ActivityTaskManagerService),
        // 并調用了Lifecycle的onStart():在這里atm被注冊到了ServiceManager中,publishBinderService(Context.ACTIVITY_TASK_SERVICE, mService)
        // 接著調用getService拿到atm
        ActivityTaskManagerService atm = mSystemServiceManager.startService(
        ActivityTaskManagerService.Lifecycle.class).getService();
        //內部同樣是通過mSystemServiceManager.startService()啟動，也就是依舊反射創(chuàng)建了ActivityManagerService.Lifecycle,
        //調用了Lifecycle的onStart():調用了ams的start:mService.start();
        // 返回Lifecycle構造函數(shù)創(chuàng)建了ActivityManagerService
        mActivityManagerService = ActivityManagerService.Lifecycle.startService(
                mSystemServiceManager, atm);
        mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
        //ams真正向ServiceManager注冊Binder:
        mActivityManagerService.setSystemProcess();
    }


    //frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
    public void setSystemProcess() {
        //注冊各種service
        ServiceManager.addService(Context.ACTIVITY_SERVICE, this, /* allowIsolated= */ true,
                                  DUMP_FLAG_PRIORITY_CRITICAL | DUMP_FLAG_PRIORITY_NORMAL | DUMP_FLAG_PROTO);//這個是activity
        ServiceManager.addService(ProcessStats.SERVICE_NAME, mProcessStats);
        ServiceManager.addService("meminfo", new MemBinder(this), /* allowIsolated= */ false,
                                  DUMP_FLAG_PRIORITY_HIGH);
        ServiceManager.addService("gfxinfo", new GraphicsBinder(this));
        ServiceManager.addService("dbinfo", new DbBinder(this));
        if (MONITOR_CPU_USAGE) {
            ServiceManager.addService("cpuinfo", new CpuBinder(this),
                    /* allowIsolated= */ false, DUMP_FLAG_PRIORITY_CRITICAL);
        }
        ServiceManager.addService("permission", new PermissionController(this));
        ServiceManager.addService("processinfo", new ProcessInfoService(this));
        ServiceManager.addService("cacheinfo", new CacheBinder(this));
        ApplicationInfo info = mContext.getPackageManager().getApplicationInfo(
                "android", STOCK_PM_FLAGS | MATCH_SYSTEM_ONLY);
        //加載framework-res.apk
        mSystemThread.installSystemApplicationInfo(info, getClass().getClassLoader());
    }

可以看出俯画，在systemserver中主要是像servicemanager注冊了各種service析桥，然后陷入looper中等待通訊。
而AMS相關主要是ActivityManagerService以及ActivityTaskManagerService
從ActivityTaskManagerService的類注釋來看艰垂，它才是真正負責管理活動和容器的類泡仗，而ams主要是持有它，做一個代理工作猜憎？

//至此AMS服務已經啟動起來了娩怎，接下來我們從startActivity入手，在實際中看一下拉宗，歷經了哪些類，分別都處理了什么

    //frameworks/base/core/java/android/app/Activity.java
    //startActivity最終調用均為startActivityForResult
    public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
    @Nullable Bundle options) {
        options = transferSpringboardActivityOptions(options);
        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());
        }
    }
    //可以看到出現(xiàn)了多個全局變量
    // mInstrumentation:Instrumentation,
    // mMainThread:ActivityThread,
    // mMainThread.getApplicationThread:ApplicationThread
    // 這些變量都是在attach函數(shù)賦值的,具體attach是什么時候回調的辣辫，我們暫時放下到后續(xù)的分析中查看
    final void attach(Context context, ActivityThread aThread,
                      Instrumentation instr, IBinder token, int ident,
                      Application application, Intent intent, ActivityInfo info,
                      CharSequence title, Activity parent, String id,
                      NonConfigurationInstances lastNonConfigurationInstances,
                      Configuration config, String referrer, IVoiceInteractor voiceInteractor,
                      Window window, ActivityConfigCallback activityConfigCallback, IBinder assistToken) {
        attachBaseContext(context);
        //...
        mMainThread = aThread;
        mInstrumentation = instr;
        //...
    }
    //我們繼續(xù)查看execStartActivity
    //frameworks/base/core/java/android/app/Instrumentation.java:Instrumentation是Android系統(tǒng)提供的用來hook控制組件生命周期的類
    public ActivityResult execStartActivity(
            Context who, IBinder contextThread, IBinder token, Activity target,
            Intent intent, int requestCode, Bundle options) {
        //可以看到最終走到了ActivityTaskManagerService:從啟動應用進程進入了SystemServer進程
        int result = ActivityTaskManager.getService().startActivity(whoThread,
                                                                    who.getBasePackageName(), who.getAttributionTag(), intent,
                                                                    intent.resolveTypeIfNeeded(who.getContentResolver()), token,
                                                                    target != null ? target.mEmbeddedID : null, requestCode, 0, null, options);
    }

    //********************SystemServer進程***************************

    //frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
    @Override
    public final int startActivity(IApplicationThread caller, String callingPackage,
                                   String callingFeatureId, Intent intent, String resolvedType, IBinder resultTo,
                                   String resultWho, int requestCode, int startFlags, ProfilerInfo profilerInfo,
                                   Bundle bOptions) {
        return startActivityAsUser(caller, callingPackage, callingFeatureId, intent, resolvedType,
                                   resultTo, resultWho, requestCode, startFlags, profilerInfo, bOptions,
                                   UserHandle.getCallingUserId());
    }
    //startActivityAsUser 是幾個重載函數(shù)旦事，最終走到:
    private int startActivityAsUser(IApplicationThread caller, String callingPackage,
    @Nullable String callingFeatureId, Intent intent, String resolvedType,
            IBinder resultTo, String resultWho, int requestCode, int startFlags,
            ProfilerInfo profilerInfo, Bundle bOptions, int userId, boolean validateIncomingUser) {
        assertPackageMatchesCallingUid(callingPackage);
        enforceNotIsolatedCaller("startActivityAsUser");
        //通過ActivityStartController創(chuàng)建了ActivityStarter并進行一系列鏈式調用進行了配置(內部會把各個值設置給Request(mRequest)保存)，然后調用其execute
        return getActivityStartController().obtainStarter(intent, "startActivityAsUser")
                .setCaller(caller)
                .setCallingPackage(callingPackage)
                .setCallingFeatureId(callingFeatureId)
                .setResolvedType(resolvedType)
                .setResultTo(resultTo)
                .setResultWho(resultWho)
                .setRequestCode(requestCode)
                .setStartFlags(startFlags)
                .setProfilerInfo(profilerInfo)
                .setActivityOptions(bOptions)
                .setUserId(userId)
                .execute();
    }

    //frameworks/base/services/core/java/com/android/server/wm/ActivityStartController.java
    ActivityStarter obtainStarter(Intent intent, String reason) {
        return mFactory.obtain().setIntent(intent).setReason(reason);
    }
    //frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java
    //ActivityStarter用于解釋Activity是在什么時候急灭、怎樣啟動的一個控制器姐浮。這個類用于確定intent 和 flags 應如何轉換為 activity 以及相關任務和堆棧的所有邏輯
    int execute() {
        try {
            int res;
            res = executeRequest(mRequest);
            return getExternalResult(mRequest.waitResult == null ? res: waitForResult(res, mLastStartActivityRecord));
        } finally {
                //一些收尾工作，把當前的ActivityStarter設置為lastStarter
                onExecutionComplete();
        }
    }

    //這里主要是做一些啟動前的檢查葬馋，然后通過startActivityUnchecked->startActivityInner繼續(xù)進行后續(xù)啟動
    private int executeRequest(Request request) {

        mLastStartReason = request.reason;
        mLastStartActivityRecord = null;
        final IApplicationThread caller = request.caller;
        Intent intent = request.intent;
        NeededUriGrants intentGrants = request.intentGrants;
        String resolvedType = request.resolvedType;
        ActivityInfo aInfo = request.activityInfo;
        ResolveInfo rInfo = request.resolveInfo;
        final IVoiceInteractionSession voiceSession = request.voiceSession;
        final IBinder resultTo = request.resultTo;
        String resultWho = request.resultWho;
        int requestCode = request.requestCode;
        int callingPid = request.callingPid;
        int callingUid = request.callingUid;
        String callingPackage = request.callingPackage;
        String callingFeatureId = request.callingFeatureId;
        final int realCallingPid = request.realCallingPid;
        final int realCallingUid = request.realCallingUid;
        final int startFlags = request.startFlags;
        final SafeActivityOptions options = request.activityOptions;
        Task inTask = request.inTask;

        int err = ActivityManager.START_SUCCESS;
        final Bundle verificationBundle =
                options != null ? options.popAppVerificationBundle() : null;

        WindowProcessController callerApp = null;
        if (caller != null) {
            //mService : ActivityTaskManagerService:
            //caller : IApplicationThread
            //這里是拿到啟動Activity的WindowProcessController:應該是每個啟動的進程都會走到ATM里卖鲤，add緩存上自己的？
            callerApp = mService.getProcessController(caller);
            if (callerApp != null) {
                callingPid = callerApp.getPid();
                callingUid = callerApp.mInfo.uid;
            }
        }

        final int userId = aInfo != null && aInfo.applicationInfo != null
                           ? UserHandle.getUserId(aInfo.applicationInfo.uid) : 0;
        ActivityRecord sourceRecord = null;
        ActivityRecord resultRecord = null;
        if (resultTo != null) {
            sourceRecord = mRootWindowContainer.isInAnyStack(resultTo);
            if (sourceRecord != null) {
                //如果是startActivityForResult,并且啟動activity沒有finish掉畴嘶，那么被啟動的activity的返回activity還是之前的啟動activity
                if (requestCode >= 0 && !sourceRecord.finishing) {
                    resultRecord = sourceRecord;
                }
            }
        }

        //ActivityRecord即是Activity的數(shù)據(jù)結構類蛋逾，一個ActivityRecord對應一個Activity,此處構造待啟動的activity
        final ActivityRecord r = new ActivityRecord(mService, callerApp, callingPid, callingUid,
                                                    callingPackage, callingFeatureId, intent, resolvedType, aInfo,
                                                    mService.getGlobalConfiguration(), resultRecord, resultWho, requestCode,
                                                    request.componentSpecified, voiceSession != null, mSupervisor, checkedOptions,
                                                    sourceRecord);
        mLastStartActivityRecord = r;
        mLastStartActivityResult = startActivityUnchecked(r, sourceRecord, voiceSession,request.voiceInteractor, startFlags,
                true /* doResume */, checkedOptions, inTask,restrictedBgActivity, intentGrants);
        return mLastStartActivityResult;
    }

    //啟動前校驗完畢后走到startActivityUnchecked，主要是負責繼續(xù)啟動窗悯，以及啟動如果失敗后的remove工作
    private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
                                       IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
                                       int startFlags, boolean doResume, ActivityOptions options, Task inTask,
                                       boolean restrictedBgActivity, NeededUriGrants intentGrants) {
        int result = START_CANCELED;
        final ActivityStack startedActivityStack;
        try {
            mService.deferWindowLayout();
            //繼續(xù)進行啟動
            result = startActivityInner(r, sourceRecord, voiceSession, voiceInteractor,
                                        startFlags, doResume, options, inTask, restrictedBgActivity, intentGrants);
        } finally {
                //啟動成功后区匣，拿到新activity的棧信息
                startedActivityStack = handleStartResult(r, result);
                mService.continueWindowLayout();
        }
        postStartActivityProcessing(r, result, startedActivityStack);
        return result;
    }