AMS_0

SystemServer启动

createSystemContext

创建Context,加载android系统需要的资源等。

//SystemServer.java
private void createSystemContext() {
    //创建ActivityThread，通过ActivityThread获取mSystemContext，通过mSystemContext设置主题
    ActivityThread activityThread = ActivityThread.systemMain();
    mSystemContext = activityThread.getSystemContext();
    mSystemContext.setTheme(DEFAULT_SYSTEM_THEME);

    //获取系统UI上下文并设置系统主题
    final Context systemUiContext = activityThread.getSystemUiContext();
    systemUiContext.setTheme(DEFAULT_SYSTEM_THEME);
}

//ActivityThread.java
public static ActivityThread systemMain() {
    // ...
    //只用系统启动SystemServer流程，才能走到这里，用new的方式创建ActivityThread，如果是正常启动App，走的是ActivityThread的main方法，创建创建ActivityThread，调用attach传入的是false
    //创建ActivityThread，调用attach方法传入true，并返回创建ActivityThread.
    ActivityThread thread = new ActivityThread();
    thread.attach(true, 0);
    return thread;
}
//构造方法创建了ResourcesManager。
ActivityThread() {
    mResourcesManager = ResourcesManager.getInstance();
}
//ActivityThread.java
//由上面知道，启动系统SystemServer流程，system为true,正常启动App为false。
private void attach(boolean system, long startSeq) {
    sCurrentActivityThread = this;
    mSystemThread = system;
    if (!system) {
        //正常启动App
        //...
    } else {
        //启动系统SystemServer流程
        // Don't set application object here -- if the system crashes,
        // we can't display an alert, we just want to die die die.
        android.ddm.DdmHandleAppName.setAppName("system_process",
                                                UserHandle.myUserId());
        try {
            //创建Instrumentation
            mInstrumentation = new Instrumentation();
            mInstrumentation.basicInit(this);
            //先创建SystemContext对象，再通过它创建AppContext
            ContextImpl context = ContextImpl.createAppContext(
                this, getSystemContext().mPackageInfo);
            //makeApplication()方法给 mInitialApplication的赋值
            mInitialApplication = context.mPackageInfo.makeApplication(true, null);
            mInitialApplication.onCreate();
        } catch (Exception e) {
            throw new RuntimeException(
                "Unable to instantiate Application():" + e.toString(), e);
        }
    }

   //...
}

//ActivityThread.java
//单例方法，调用ContextImpl.createSystemContext(this)
public ContextImpl getSystemContext() {
    synchronized (this) {
        if (mSystemContext == null) {
            mSystemContext = ContextImpl.createSystemContext(this);
        }
        return mSystemContext;
    }
}

//ContextImpl.java Context的真正实现类
//创建其他类型的context都要间接的通过SystemContext进行，所以SystemContex是第一个ContextImpl实例，也是其他类型context的基础
static ContextImpl createSystemContext(ActivityThread mainThread) {
    //创建LoadedApk对象,在构造方法中创建ApplicationInfo对象和ClassLoader并保存在其成员变量中
    LoadedApk packageInfo = new LoadedApk(mainThread);
    //创建ContextImpl对象将LoadedApk对象存入mPackageInfo成员中
    ContextImpl context = new ContextImpl(null, mainThread, packageInfo, null, null, null, 0,
                                          null);
    context.setResources(packageInfo.getResources());
    context.mResources.updateConfiguration(context.mResourcesManager.getConfiguration(),
                                           context.mResourcesManager.getDisplayMetrics());
    return context;
}

//LoadedApk.java
//构造方法 初始化一些成员
LoadedApk(ActivityThread activityThread) {
    mApplicationInfo = new ApplicationInfo();
    mApplicationInfo.packageName = "android";
    mPackageName = "android";
    //...
    mClassLoader = ClassLoader.getSystemClassLoader();
    mResources = Resources.getSystem();
}

public Application makeApplication(boolean forceDefaultAppClass,
                                   Instrumentation instrumentation) {
    //...
    String appClass = mApplicationInfo.className;
    if (forceDefaultAppClass || (appClass == null)) {
        appClass = "android.app.Application";
    }

    try {
        java.lang.ClassLoader cl = getClassLoader();
        if (!mPackageName.equals("android")) {
            Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER,
                             "initializeJavaContextClassLoader");
            //设置当前线程的Context ClassLoader
            initializeJavaContextClassLoader();
            Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
        }
        ContextImpl appContext = ContextImpl.createAppContext(mActivityThread, this);
        // Instrumentation.newApplication方法传入ContextImpl 创建Application对象
        app = mActivityThread.mInstrumentation.newApplication(
            cl, appClass, appContext);
        appContext.setOuterContext(app);
    } catch (Exception e) {
       //...
    }
    mActivityThread.mAllApplications.add(app);
    mApplication = app;

    if (instrumentation != null) {
        try {
            instrumentation.callApplicationOnCreate(app);
        } catch (Exception e) {
           //...
        }
    }
   //...
    return app;
}

//Instrumentation.java
public Application newApplication(ClassLoader cl, String className, Context context)
    throws InstantiationException, IllegalAccessException, ClassNotFoundException {
    Application app = getFactory(context.getPackageName())
        .instantiateApplication(cl, className);
    //将新创建的ContextImpl对象保存到Application的父类成员变量mBase；
    //将新创建的LoadedApk对象保存到Application的父员变量mLoadedApk
    app.attach(context);
    return app;
}

startBootstrapServices

private void startBootstrapServices() { 
    //... 
    // Activity manager runs the show. 
    traceBeginAndSlog("StartActivityManager"); 
    //启动了AMS 
    mActivityManagerService = mSystemServiceManager.startService(
        ActivityManagerService.Lifecycle.class).getService();
    mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
    //设置AMS的APP安装器
    mActivityManagerService.setInstaller(installer); traceEnd(); 
    //... 
    //初始化AMS相关的PMS
    features. traceBeginAndSlog("InitPowerManagement");
    mActivityManagerService.initPowerManagement(); traceEnd(); 
    //...
    //PackageManagerService的初始化和启动也是在startBootstrapServices
    traceBeginAndSlog("StartPackageManagerService");
    mPackageManagerService = PackageManagerService.main(mSystemContext, installer, mFactoryTestMode = FactoryTest.FACTORY_TEST_OFF, mOnlyCore);
    mFirstBoot = mPackageManagerService.isFirstBoot();
    mPackageManager = mSystemContext.getPackageManager();
    traceEnd();
    
    // Set up the Application instance for the system process and get 
    started. traceBeginAndSlog("SetSystemProcess"); 
    mActivityManagerService.setSystemProcess();
    traceEnd(); 
} 

// SystemServiceManager.java
// SystemServiceManager用一个集合保存启动的服务。
private final ArrayList<SystemService> mServices = new ArrayList<SystemService>();
//SystemServiceManager.java有三个startService()方法，string参数的会调用Class参数的;class参数的会调用SystemService参数的。
//在Class参数的方法中newInstance方法会执行ActivityManagerService构造方法,并且调用SystemService参数的。
public <T extends SystemService> T startService(Class<T> serviceClass) {
    try {
        final String name = serviceClass.getName();
        Slog.i(TAG, "Starting " + name);
        Trace.traceBegin(Trace.TRACE_TAG_SYSTEM_SERVER, "StartService " + name);

        // Create the service.
        if (!SystemService.class.isAssignableFrom(serviceClass)) {
            throw new RuntimeException("Failed to create " + name
                                       + ": service must extend " + SystemService.class.getName());
        }
        final T service;
        try {
            Constructor<T> constructor = serviceClass.getConstructor(Context.class);
            service = constructor.newInstance(mContext);
        } catch (Exception ex) {
           //...
        }

        startService(service);
        return service;
    } finally {
        Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
    }
}
//在SystemService参数的方法中会调用
public void startService(@NonNull final SystemService service) {
    // 将服务加入到集合中
    mServices.add(service);
    // Start it.
    long time = SystemClock.elapsedRealtime();
    try {
        service.onStart();
    } catch (RuntimeException ex) {
        throw new RuntimeException("Failed to start service " +
                                   service.getClass().getName()
                                   + ": onStart threw an exception", ex);
    }
    warnIfTooLong(SystemClock.elapsedRealtime() - time, service, "onStart");
}

//ActivityManagerService.java-Lifecycle
//SystemService这个父类就是为了让各种服务有一个生命周期
public static final class Lifecycle extends SystemService {
    private final ActivityManagerService mService;
    public Lifecycle(Context context) {
        super(context);
        mService = new ActivityManagerService(context);
    }
    @Override
    public void onStart() {
        mService.start();
    }
    @Override
    public void onBootPhase(int phase) {
        mService.mBootPhase = phase;
        if (phase == PHASE_SYSTEM_SERVICES_READY) {
            mService.mBatteryStatsService.systemServicesReady();
            mService.mServices.systemServicesReady();
        }
    }
    @Override
    public void onCleanupUser(int userId) {
        mService.mBatteryStatsService.onCleanupUser(userId);
    }
    public ActivityManagerService getService() {
        return mService;
    }
}

//ActivityManagerService构造方法  干了很多很多事情我们关注
//1.创建"android.ui"的线程 2.创建ActiveServices 3.创建ActivityStackSupervisor对象
public ActivityManagerService(Context systemContext) {
    LockGuard.installLock(this, LockGuard.INDEX_ACTIVITY);
    mInjector = new Injector();
    mContext = systemContext;//赋值mContext

    mFactoryTest = FactoryTest.getMode();
    //获取当前的ActivityThread
    mSystemThread = ActivityThread.currentActivityThread();
    mUiContext = mSystemThread.getSystemUiContext();

    Slog.i(TAG, "Memory class: " + ActivityManager.staticGetMemoryClass());

    mPermissionReviewRequired = mContext.getResources().getBoolean(
        com.android.internal.R.bool.config_permissionReviewRequired);
	//创建Handler线程，用来处理handler消息
    mHandlerThread = new ServiceThread(TAG,
                                       THREAD_PRIORITY_FOREGROUND, false /*allowIo*/);
    mHandlerThread.start();
    mHandler = new MainHandler(mHandlerThread.getLooper());
    mUiHandler = mInjector.getUiHandler(this);

    mProcStartHandlerThread = new ServiceThread(TAG + ":procStart",
                                                THREAD_PRIORITY_FOREGROUND, false /* allowIo */);
    mProcStartHandlerThread.start();
    mProcStartHandler = new Handler(mProcStartHandlerThread.getLooper());
	//管理AMS的一些常量，厂商定制系统就可能修改此处
    mConstants = new ActivityManagerConstants(this, mHandler);

    /* static; one-time init here */
    if (sKillHandler == null) {
        sKillThread = new ServiceThread(TAG + ":kill",
                                        THREAD_PRIORITY_BACKGROUND, true /* allowIo */);
        sKillThread.start();
        sKillHandler = new KillHandler(sKillThread.getLooper());
    }
	//初始化管理前台、后台广播的队列， 系统会优先遍历发送前台广播
    mFgBroadcastQueue = new BroadcastQueue(this, mHandler,
                                           "foreground", BROADCAST_FG_TIMEOUT, false);
    mBgBroadcastQueue = new BroadcastQueue(this, mHandler,
                                           "background", BROADCAST_BG_TIMEOUT, true);
    mBroadcastQueues[0] = mFgBroadcastQueue;
    mBroadcastQueues[1] = mBgBroadcastQueue;
	//初始化管理Service的 ActiveServices对象
    mServices = new ActiveServices(this);
    //初始化Provider的管理者
    mProviderMap = new ProviderMap(this);
    //初始化APP错误日志的打印器
    mAppErrors = new AppErrors(mUiContext, this);
	//创建电池统计服务， 并输出到指定目录
    File dataDir = Environment.getDataDirectory();
    File systemDir = new File(dataDir, "system");
    systemDir.mkdirs();

    mAppWarnings = new AppWarnings(this, mUiContext, mHandler, mUiHandler, systemDir);

    // TODO: Move creation of battery stats service outside of activity manager service.
    //创建进程统计分析服务，追踪统计哪些进程有滥用或不良行为 :
    mBatteryStatsService = new BatteryStatsService(systemContext, systemDir, mHandler);
    mBatteryStatsService.getActiveStatistics().readLocked();
    mBatteryStatsService.scheduleWriteToDisk();
    mOnBattery = DEBUG_POWER ? true
        : mBatteryStatsService.getActiveStatistics().getIsOnBattery();
   
    mBatteryStatsService.getActiveStatistics().setCallback(this);
	
    mProcessStats = new ProcessStatsService(this, new File(systemDir, "procstats"));

    mAppOpsService = mInjector.getAppOpsService(new File(systemDir, "appops.xml"), mHandler);
	//加载Uri的授权文件
    mGrantFile = new AtomicFile(new File(systemDir, "urigrants.xml"), "uri-grants");
	//负责管理多用户
    mUserController = new UserController(this);
	//vr功能的控制器
    mVrController = new VrController(this);
	//初始化OpenGL版本号
    GL_ES_VERSION = SystemProperties.getInt("ro.opengles.version",
                                            ConfigurationInfo.GL_ES_VERSION_UNDEFINED);

    if (SystemProperties.getInt("sys.use_fifo_ui", 0) != 0) {
        mUseFifoUiScheduling = true;
    }

    mTrackingAssociations = "1".equals(SystemProperties.get("debug.track-associations"));
    mTempConfig.setToDefaults();
    mTempConfig.setLocales(LocaleList.getDefault());
    mConfigurationSeq = mTempConfig.seq = 1;
    //创建ActivityStackSupervisor：管理ActivityStack的重要类，这里面记录着activity状态信息，是AMS中的核心类
    mStackSupervisor = createStackSupervisor();
    mStackSupervisor.onConfigurationChanged(mTempConfig);
    //根据当前可见的Activity类型，控制Keyguard遮挡，关闭和转换。 Keyguard就是我们的锁屏相关页面
    mKeyguardController = mStackSupervisor.getKeyguardController();
    //管理APK的兼容性配置
    mCompatModePackages = new CompatModePackages(this, systemDir, mHandler);
    //Intent防火墙，Google定义了一组规则，来过滤intent，如果触发了，则intent会被系统丢弃，且不会告知发送者
    mIntentFirewall = new IntentFirewall(new IntentFirewallInterface(), mHandler);
    mTaskChangeNotificationController =
        new TaskChangeNotificationController(this, mStackSupervisor, mHandler);
    //这是activity启动的处理类，这里管理者activity启动中用到的intent信息和flag标识，也和stack和task有重要的联系
    mActivityStartController = new ActivityStartController(this);
    mRecentTasks = createRecentTasks();
    mStackSupervisor.setRecentTasks(mRecentTasks);
    mLockTaskController = new LockTaskController(mContext, mStackSupervisor, mHandler);
    mLifecycleManager = new ClientLifecycleManager();

    //启动一个线程专门跟进cpu当前状态信息，AMS对当前cpu状态了如指掌，可以更加高效的安排其他工作
    mProcessCpuThread = new Thread("CpuTracker") {
        @Override
        public void run() {
            synchronized (mProcessCpuTracker) {
                mProcessCpuInitLatch.countDown();
                mProcessCpuTracker.init();
            }
            while (true) {
                //...
            }
        }
    };

    mHiddenApiBlacklist = new HiddenApiSettings(mHandler, mContext);

    Watchdog.getInstance().addMonitor(this);
    Watchdog.getInstance().addThread(mHandler);

    // bind background thread to little cores
    // this is expected to fail inside of framework tests because apps can't touch cpusets directly
    // make sure we've already adjusted system_server's internal view of itself first
    //更新进程的优先级
    updateOomAdjLocked();
    try {
        Process.setThreadGroupAndCpuset(BackgroundThread.get().getThreadId(),
                                        Process.THREAD_GROUP_BG_NONINTERACTIVE);
    } catch (Exception e) {
        Slog.w(TAG, "Setting background thread cpuset failed");
    }

}


private void start() {
    removeAllProcessGroups();  //移除所有的进程组
    mProcessCpuThread.start();//启动CpuTracker线程

    mBatteryStatsService.publish();//启动电池统计服务
    mAppOpsService.publish(mContext);
    Slog.d("AppOps", "AppOpsService published");
    //创建LocalService，并添加到LocalServices
    LocalServices.addService(ActivityManagerInternal.class, new LocalService());
    // Wait for the synchronized block started in mProcessCpuThread,
    // so that any other acccess to mProcessCpuTracker from main thread
    // will be blocked during mProcessCpuTracker initialization.
    //等待mProcessCpuThread完成初始化后， 释放锁，初始化期间禁止访问
    try {
        mProcessCpuInitLatch.await();
    } catch (InterruptedException e) {
        Slog.wtf(TAG, "Interrupted wait during start", e);
        Thread.currentThread().interrupt();
        throw new IllegalStateException("Interrupted wait during start");
    }
}

看看 setSystemProcess 干了什么事情 在startBootstrapServices 中调用，

注册服务。首先将ActivityManagerService注册到ServiceManager中，其次将几个与系统性能调试相关的服务注册到ServiceManager。

•查询并处理ApplicationInfo。首先调用PackageManagerService的接口，查询包名为android的应用程序的ApplicationInfo信息，对应于framework-res.apk。然后以该信息为参数调用ActivityThread上的installSystemApplicationInfo方法。
•创建并处理ProcessRecord。调用ActivityManagerService上的newProcessRecordLocked，创建一个ProcessRecord类型的对象，并保存该对象的信息

public void setSystemProcess() {
    try {
        //将AMS加入到binder中
        ServiceManager.addService(Context.ACTIVITY_SERVICE, this, /* allowIsolated= */ true,
                                  DUMP_FLAG_PRIORITY_CRITICAL | DUMP_FLAG_PRIORITY_NORMAL | DUMP_FLAG_PROTO);
        //添加了各种服务
        //procstats  进程统计 内存 图像信息 CPU 权限 进程服务
        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));
		//最终调用LoadedApk的installSystemApplicationInfo，加载名为“android”的package
        //创建用于性能统计的Profiler对象
        ApplicationInfo info = mContext.getPackageManager().getApplicationInfo(
            "android", STOCK_PM_FLAGS | MATCH_SYSTEM_ONLY);
        mSystemThread.installSystemApplicationInfo(info, getClass().getClassLoader());

        //创建ProcessRecord对象
        synchronized (this) {
            ProcessRecord app = newProcessRecordLocked(info, info.processName, false, 0);
            app.persistent = true;
            app.pid = MY_PID;
            app.maxAdj = ProcessList.SYSTEM_ADJ;
            app.makeActive(mSystemThread.getApplicationThread(), mProcessStats);
            synchronized (mPidsSelfLocked) {
                mPidsSelfLocked.put(app.pid, app);
            }
            updateLruProcessLocked(app, false, null);
            updateOomAdjLocked();
        }
    } catch (PackageManager.NameNotFoundException e) {
        throw new RuntimeException(
            "Unable to find android system package", e);
    }

    // Start watching app ops after we and the package manager are up and running.
    //...
}

startOtherServices

//SystemServer.java
private void startOtherServices() {
    //...
    //安装系统Provider 创建核心Settings Observer，用于监控Settings的改变
    traceBeginAndSlog("InstallSystemProviders");
    mActivityManagerService.installSystemProviders();
    // Now that SettingsProvider is ready, reactivate SQLiteCompatibilityWalFlags
    SQLiteCompatibilityWalFlags.reset();
    traceEnd();
    //...
    //初始化wms
    traceBeginAndSlog("StartWindowManagerService");
    // WMS needs sensor service ready
    ConcurrentUtils.waitForFutureNoInterrupt(mSensorServiceStart, START_SENSOR_SERVICE);
    mSensorServiceStart = null;
    wm = WindowManagerService.main(context, inputManager,
                                   mFactoryTestMode != FactoryTest.FACTORY_TEST_LOW_LEVEL,
                                   !mFirstBoot, mOnlyCore, new PhoneWindowManager());
    ServiceManager.addService(Context.WINDOW_SERVICE, wm, /* allowIsolated= */ false,
                              DUMP_FLAG_PRIORITY_CRITICAL | DUMP_FLAG_PROTO);
    ServiceManager.addService(Context.INPUT_SERVICE, inputManager,
                              /* allowIsolated= */ false, DUMP_FLAG_PRIORITY_CRITICAL);
    traceEnd();

  	//...
    //这个函数执行完后，最终会执行到startHomeActivityLocked；代表启动桌面程序
    mActivityManagerService.systemReady(() -> {
        //...
        //启动系统UI
        traceBeginAndSlog("StartSystemUI");
        try {
            startSystemUi(context, windowManagerF);
        } catch (Throwable e) {
            reportWtf("starting System UI", e);
        }
        traceEnd();
        //...
        //执行一系列服务的systemReady
        //..
    }
    
}
 
//ActivityManagerService.java
public void systemReady(final Runnable goingCallback, TimingsTraceLog traceLog) {
    //...
    goingCallback.run();
    //...
    //启动桌面程序
    startHomeActivityLocked(currentUserId, "systemReady");
}

AMS相关重要类介绍

ProcessRecord 数据结构

第一类数据：描述身份的数据
第二类数据：描述进程中组件的数据
第三类数据：描述进程状态的数据
第四类数据：和pss相关的数据 我们先来普及一下一些名词：
第五类数据：和时间相关的数据
第六类数据：crash和anr相关的数据
第七类数据：和instrumentation相关的数据
instrumentation 也可以说是apk的一个组件，如果我们不提供的话，系统会默认使用Instrumentation.java类，按照我们一般的理解，UI 线程控制activity的生命周 期，是是直接调用Activity类的方法，实际是，UI线程调用的是instrumentation的方法，由它在调用Activity涉及生命周期的方法，所有如果我们覆写了instrumentation的这些方法，就可以了解所有的Activity的生命周期了
第八类数据：电源信息和调试信息
第九类数据：最后我们来看一下31个boolean值

ProcessRecord容器

内部四大组件记录表的容器

组件运行才是进程存在的意义，由于android系统进程间的无缝结合，所以系统需要控制到组件级别， 所有的组件信息都需要映射到系统，一个ActivityRecord记录对应一个Activity的信息，一个 ServiceRecord记录对应一个Service的信息，一个ConnectionRecord记录对应一个bind service的客户 端信息，一个ReceiverList对应处理同一事件的一组广播，一个ContentProviderRecord记录对应一个 ContentProvider信息，一个ContentProviderConnection对应一个进程中的所有ContentProvider客户端

activity记录
1.activities：ActivityRecord的容器，进程启动的所有的activity组件记录表

service记录
1.services：ServiceRecord的容器，进程启动的所有的service组件记录表
2.executingServices：正在运行（executing）的ServiceRecord是怎么定义的？首先需要明确的是 系统是怎么控制组件的？发送消息给apk进程，apk进程处理消息，上报消息完成，这被定义为一 个完整的执行过程，因此正在执行（executing）被定义为发送消息到上报完成这段时间
3.connections：ConnectionRecord容器，绑定service的客户端记录表

广播接收器记录
1.receivers：ReceiverList容器，广播接收器的记录表

ContentProvider记录
1.pubProviders：名字到ContentProviderRecord的映射容器，pub是publish（发布）的意思， ContentProvider需要安装然后把自己发布到系统（AMS）中后，才能使用，安装指的是apk进程 加载ContentProvider子类、初始化、创建数据库等过程，发布是将ContentProvider的binder客 户端注册到AMS中
2.conProviders：ContentProviderConnection容器，使用ContentProvider的客户端记录表 \

与Activity管理有关的数据结构

ActivityRecord

ActivityRecord，源码中的注释介绍：An entry in the history stack, representing an activity. 翻译：历 史栈中的一个条目，代表一个activity。
ActivityRecord中存在着大量的成员变量，包含了一个Activity的所有信息。 ActivityRecord中的成员变 量task表示其所在的TaskRecord，由此可以看出：ActivityRecord与TaskRecord建立了联系

ActivityRecord是在ActivityStarter的startActivity()方法中创建的。

final class ActivityRecord extends ConfigurationContainer implements
    AppWindowContainerListener {
    final ActivityManagerService service; // owner
    final IApplicationToken.Stub appToken; // window manager token
    AppWindowContainerController mWindowContainerController;
    final ActivityInfo info; // all about me
    final ApplicationInfo appInfo; // information about activity's app
    //省略其他成员变量
    //ActivityRecord所在的TaskRecord
    private TaskRecord task; // the task this is in.
    //构造方法，需要传递大量信息
    //...
}

TaskRecord

TaskRecord，内部维护一个 ArrayList 用来保存ActivityRecord。
TaskRecord是在ActivityStarter的setTaskFromReuseOrCreateNewTask()方法中创建的。调用

class TaskRecord extends ConfigurationContainer implements TaskWindowContainerListener {
    final int taskId; //任务ID
    final ArrayList<ActivityRecord> mActivities; //使用一个ArrayList来保存所有的ActivityRecord
    private ActivityStack mStack; //TaskRecord所在的ActivityStack
    TaskRecord(ActivityManagerService service, int _taskId, Intent _intent,
               Intent _affinityIntent, String _affinity, String _rootAffinity,
               ComponentName _realActivity, ComponentName _origActivity, boolean
               _rootWasReset,
               boolean _autoRemoveRecents, boolean _askedCompatMode, int _userId,
               int _effectiveUid, String _lastDescription,
               ArrayList<ActivityRecord> activities,
               long lastTimeMoved, boolean neverRelinquishIdentity,
               TaskDescription _lastTaskDescription, int taskAffiliation, int
               prevTaskId,
               int nextTaskId, int taskAffiliationColor, int callingUid, String
               callingPackage,
               int resizeMode, boolean supportsPictureInPicture, boolean
               _realActivitySuspended,
               boolean userSetupComplete, int minWidth, int minHeight) {
    }
    //添加Activity到顶部
    void addActivityToTop(com.android.server.am.ActivityRecord r) {
        addActivityAtIndex(mActivities.size(), r);
    }
    //添加Activity到指定的索引位置
    void addActivityAtIndex(int index, ActivityRecord r) {
        //...
        r.setTask(this);//为ActivityRecord设置TaskRecord，就是这里建立的联系
        //...
        index = Math.min(size, index);
        mActivities.add(index, r);//添加到mActivities
        //...
    }
}

ActivityStarter

class ActivityStarter {
    private int setTaskFromReuseOrCreateNewTask(TaskRecord taskToAffiliate,int preferredLaunchStackId, ActivityStack topStack) {
        mTargetStack = computeStackFocus(mStartActivity, true,
                                         mLaunchBounds, mLaunchFlags, mOptions);
        if (mReuseTask == null) {
            //创建一个createTaskRecord，实际上是调用ActivityStack里面的 createTaskRecord（）方法，ActivityStack下面会讲到
                final TaskRecord task = mTargetStack.createTaskRecord(
                mSupervisor.getNextTaskIdForUserLocked(mStartActivity.userId),
                mNewTaskInfo != null ? mNewTaskInfo :
                mStartActivity.info,
                mNewTaskIntent != null ? mNewTaskIntent : mIntent,
                mVoiceSession,
                mVoiceInteractor, !mLaunchTaskBehind /* toTop */,
                mStartActivity.mActivityType);
            //其他代码略
        }
    }

    private int startActivity(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,
                              SafeActivityOptions options,
                              boolean ignoreTargetSecurity, boolean componentSpecified,
                              ActivityRecord[] outActivity,
                              TaskRecord inTask, boolean
                              allowPendingRemoteAnimationRegistryLookup) {
        ActivityRecord r = new ActivityRecord(mService, callerApp, callingPid,
                                              callingUid,
                                              callingPackage, intent, resolvedType, aInfo,
                                              mService.getGlobalConfiguration(),
                                              resultRecord, resultWho, requestCode, componentSpecified,
                                              voiceSession != null,
                                              mSupervisor, checkedOptions, sourceRecord);
    }

}

ActivityStack

ActivityStack,内部维护了一个 ArrayList ，用来管理TaskRecord

class ActivityStack<T extends StackWindowController> extends ConfigurationContainer
    implements StackWindowListener {
    //使用一个ArrayList来保存TaskRecord
    private final ArrayList<TaskRecord> mTaskHistory = new ArrayList<>();
    //持有一ActivityStackSupervisor，所有的运行中的ActivityStacks都通过它来进行管
    protected final ActivityStackSupervisor mStackSupervisor;
    ActivityStack(ActivityDisplay display, int stackId, ActivityStackSupervisor
                  supervisor,
                  int windowingMode, int activityType, boolean onTop) {
    }
    TaskRecord createTaskRecord(int taskId, ActivityInfo info, Intent intent,
                                IVoiceInteractionSession voiceSession,
                                IVoiceInteractor voiceInteractor,
                                boolean toTop, int type) {
        //创建一个task
        TaskRecord task = new TaskRecord(mService, taskId, info, intent,
                                         voiceSession, voiceInteractor, type);
        //将task添加到ActivityStack中去
        addTask(task, toTop, "createTaskRecord");
        //其他代码略
        return task;
    }
    //添加Task
    void addTask(final TaskRecord task, final boolean toTop, String reason){
        addTask(task, toTop ? MAX_VALUE : 0, true /*
schedulePictureInPictureModeChange */, reason);
        //其他代码略
    }
    //添加Task到指定位置
    void addTask(final TaskRecord task, int position, boolean
                 schedulePictureInPictureModeChange,
                 String reason) {
        mTaskHistory.remove(task);//若存在，先移除
        //...
        mTaskHistory.add(position, task);//添加task到mTaskHistory
        task.setStack(this);//为TaskRecord设置ActivityStack
        //...
    }
}

可以看到ActivityStack使用了一个ArrayList来保存TaskRecord。 另外，ActivityStack中还持有 ActivityStackSupervisor对象，这个是用来管理ActivityStacks的。 ActivityStack是由 ActivityStackSupervisor来创建的，实际ActivityStackSupervisor就是用来管理ActivityStack的

ActivityStackSupervisor

public class ActivityStackSupervisor extends ConfigurationContainer implements
    DisplayListener {
    ActivityStack mHomeStack;//管理的是Launcher相关的任务
    ActivityStack mFocusedStack;//管理非Launcher相关的任务
    //创建ActivityStack
    ActivityStack createStack(int stackId,
                              ActivityStackSupervisor.ActivityDisplay display, boolean onTop) {
        switch (stackId) {
            case PINNED_STACK_ID:
                //PinnedActivityStack是ActivityStack的子类
                return new PinnedActivityStack(display, stackId, this,
                                               mRecentTasks, onTop);
            default:
                //创建一个ActivityStack
                return new ActivityStack(display, stackId, this,
                                         mRecentTasks, onTop);
        }
    }
}

ActivityStackSupervisor内部有两个不同的ActivityStack对象：mHomeStack、mFocusedStack，用来 管理不同的任务。 ActivityStackSupervisor内部包含了创建ActivityStack对象的方法。 AMS初始化时会创建一个ActivityStackSupervisor对象

Activity启动流程相关