AMS（ActivityManagerService）主要负责四大组件的启动、切换、调度以及应用进程的管理和调度工作。

Android系统启动流程：首先会从ROM中预定义的地方加载引导程序BootLoader到RAM中，并执行BootLoader程序启动Linux Kernel，然后启动用户级别的第一个进程init进程。init进程会解析init.rc脚本做一些初始化工作，包括挂载系统文件、创建工作目录以及启动系统服务进程等，其中系统服务进程包括Zygote、ServiceManager、Media等。在Zygote中会进一步启动system_server进程，然后system_server进程中会启动AMS、WMS、PMS等服务，这些服务启动后，AMS就会打开Launcher应用的home Activity，最终就看到了手机桌面。

AMS是在SystemServer中被添加的

//SystemServer.java
/**
 * The main entry point from zygote.
 */
public static void main(String[] args) {
  //new SystemServer()中创建了ActivityThread
  new SystemServer().run();
}

private void run() {
  //创建主线程Looper
  Looper.prepareMainLooper();
  //创建系统context（new ContextImpl）和加载系统资源
  createSystemContext();
  //启动引导服务
  startBootstrapServices();
  //启动核心服务
  startCoreServices();
  //启动其它服务
  startOtherServices();
  //loop循环
  Looper.loop();
}

SystemServer类的main中初始化SystemServer对象，调用run方法：

1）createSystemContext：创建系统上下文
2）startBootstrapServices：启动引导服务
3）startCoreServices：启动核心服务
4）startOtherServices：启动其它服务
5）Looper.loop：loop循环

在startBootstrapServices中启动了AMS

private void startBootstrapServices() {
  //启动AMS
  mActivityManagerService = ActivityManagerService.Lifecycle.startService(
                        mSystemServiceManager, atm);
  mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
  mActivityManagerService.setInstaller(installer);
  
  //③将AMS注册到ServiceManager中
  mActivityManagerService.setSystemProcess();
}

public static final class Lifecycle extends SystemService {
  private final ActivityManagerService mService;
  private static ActivityTaskManagerService sAtm;

  //ActivityManagerService.Lifecycle这个类的构造方法
  public Lifecycle(Context context) {
    super(context);
    //①创建AMS实例
    mService = new ActivityManagerService(context, sAtm);
  }
 
  public static ActivityManagerService startService(
    SystemServiceManager ssm, ActivityTaskManagerService atm) {
    sAtm = atm;
    //通过LifeCycle的getService返回AMS对象
    return ssm.startService(ActivityManagerService.Lifecycle.class).getService();
  }
  
  @Override
  public void onStart() {
    //②启动AMS
    mService.start();
  }
  
  public ActivityManagerService getService() {
    return mService;
  }
}

public <T extends SystemService> T startService(Class<T> serviceClass) {
  //通过反射创建AMS对象，会调到上面ActivityManagerService.Lifecycle构造方法
  Constructor<T> constructor = serviceClass.getConstructor(Context.class);
  service = constructor.newInstance(mContext);
  startService(service);
  return service;
}

// Services that should receive lifecycle events.
private final ArrayList<SystemService> mServices = new ArrayList<SystemService>();

public void startService(@NonNull final SystemService service) {
  // Register it.
  mServices.add(service);
  //开启服务
  service.onStart();
}

①创建AMS实例：new ActivityManagerService

public ActivityManagerService(Context systemContext, ActivityTaskManagerService atm) {
  mInjector = new Injector();
  //获取系统上下文环境
  mContext = systemContext;
  //获取当前ActivityThread线程
  mSystemThread = ActivityThread.currentActivityThread();
  //赋值mUiContext
  mUiContext = mSystemThread.getSystemUiContext();
  
  //创建Handler线程，用来处理handler消息
  mHandlerThread = new ServiceThread(TAG,
                THREAD_PRIORITY_FOREGROUND, false /*allowIo*/);
  mHandlerThread.start();
  mHandler = new MainHandler(mHandlerThread.getLooper());
  //处理ui相关msg的Handler
  mUiHandler = mInjector.getUiHandler(this);
  
  //初始化前台广播的队列，设置10s超时
  mFgBroadcastQueue = new BroadcastQueue(this, mHandler,
                "foreground", foreConstants, false);
  //初始化后台广播的队列，设置60s超时
  mBgBroadcastQueue = new BroadcastQueue(this, mHandler,
                "background", backConstants, true);
  //初始化离线广播的队列，设置60s超时
  mOffloadBroadcastQueue = new BroadcastQueue(this, mHandler,
                 "offload", offloadConstants, true);
  mBroadcastQueues[0] = mFgBroadcastQueue;
  mBroadcastQueues[1] = mBgBroadcastQueue;
  mBroadcastQueues[2] = mOffloadBroadcastQueue;
  
  //初始化管理Service的ActiveServices对象
  mServices = new ActiveServices(this);
  mProviderMap = new ProviderMap(this);
  mPackageWatchdog = PackageWatchdog.getInstance(mUiContext);
  mAppErrors = new AppErrors(mUiContext, this, mPackageWatchdog);
  //创建电池状态服务
   mBatteryStatsService = new BatteryStatsService(systemContext, systemDir,
                BackgroundThread.get().getHandler());
  mBatteryStatsService.getActiveStatistics().readLocked();
  mBatteryStatsService.scheduleWriteToDisk();
  mOnBattery = DEBUG_POWER ? true
    : mBatteryStatsService.getActiveStatistics().getIsOnBattery();
  mBatteryStatsService.getActiveStatistics().setCallback(this);
  mOomAdjProfiler.batteryPowerChanged(mOnBattery);
  
  //启动一个线程跟进CPU当前状态信息
  mProcessCpuThread = new Thread("CpuTracker"){
    @Override
    public void run() {
      synchronized (mProcessCpuTracker) {
        mProcessCpuInitLatch.countDown();
        mProcessCpuTracker.init();
      }
      while (true) {
        try {
          try {
            synchronized(this) {
              final long now = SystemClock.uptimeMillis();
              long nextCpuDelay = (mLastCpuTime.get()+MONITOR_CPU_MAX_TIME)-now;
              long nextWriteDelay = (mLastWriteTime+BATTERY_STATS_TIME)-now;
              //Slog.i(TAG, "Cpu delay=" + nextCpuDelay
              //        + ", write delay=" + nextWriteDelay);
              if (nextWriteDelay < nextCpuDelay) {
                nextCpuDelay = nextWriteDelay;
              }
              if (nextCpuDelay > 0) {
                mProcessCpuMutexFree.set(true);
                this.wait(nextCpuDelay);
              }
            }
          } catch (InterruptedException e) {
          }
          updateCpuStatsNow();
        } catch (Exception e) {
          Slog.e(TAG, "Unexpected exception collecting process stats", e);
        }
      }
    }
  }
  //看门狗，监听进程
  Watchdog.getInstance().addMonitor(this);
  Watchdog.getInstance().addThread(mHandler);
}

②启动AMS

private void start() {
  //移除所有的进程组
    removeAllProcessGroups();
  //启动Cpu进程
  mProcessCpuThread.start();
  //启动电池状态服务
  mBatteryStatsService.publish();
  mAppOpsService.publish(mContext);
  //创建本地服务并注册，将创建的本地服务放入本地服务集合完成注册
  LocalServices.addService(ActivityManagerInternal.class, new LocalService());
  
  //等待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");
  }
}

1）removeAllProcessGroups：移除所有的进程组
2）mProcessCpuThread.start()：启动CpuTracker线程
3）mBatteryStatsService.publish()：启动电池状态服务
4）LocalServices.addService(ActivityManagerInternal.class, new LocalService())：创建本地服务并放入本地服务集合

③将AMS注册到ServiceManager中 setSystemProcess

public void setSystemProcess() {
  try {
        //将AMS注册到ServiceManager中
    ServiceManager.addService(Context.ACTIVITY_SERVICE, this, /* allowIsolated= */ true,
                              DUMP_FLAG_PRIORITY_CRITICAL | DUMP_FLAG_PRIORITY_NORMAL | DUMP_FLAG_PROTO);
    //注册进程状态服务
    ServiceManager.addService(ProcessStats.SERVICE_NAME, mProcessStats);
    //注册内存Binder
    ServiceManager.addService("meminfo", new MemBinder(this), /* allowIsolated= */ false,
                              DUMP_FLAG_PRIORITY_HIGH);
    //注册图像信息Binder
    ServiceManager.addService("gfxinfo", new GraphicsBinder(this));
    //注册数据库Binder 
    ServiceManager.addService("dbinfo", new DbBinder(this));
    if (MONITOR_CPU_USAGE) {
      //注册监控CPU使用状态Binder
      ServiceManager.addService("cpuinfo", new CpuBinder(this),
                                /* allowIsolated= */ false, DUMP_FLAG_PRIORITY_CRITICAL);
    }
    //注册权限控制Binder
    ServiceManager.addService("permission", new PermissionController(this));
    //注册进程服务Binder
    ServiceManager.addService("processinfo", new ProcessInfoService(this));
        //查询并处理ApplicationInfo
    ApplicationInfo info = mContext.getPackageManager().getApplicationInfo(
      "android", STOCK_PM_FLAGS | MATCH_SYSTEM_ONLY);
    //将Application信息配置到ActivityThread中
    mSystemThread.installSystemApplicationInfo(info, getClass().getClassLoader());

    synchronized (this) {
      //创建并处理ProcessRecord
      ProcessRecord app = mProcessList.newProcessRecordLocked(info, info.processName,
                                                              false,
                                                              0,
                                                              new HostingRecord("system"));
      app.setPersistent(true);
      app.pid = MY_PID;
      app.getWindowProcessController().setPid(MY_PID);
      app.maxAdj = ProcessList.SYSTEM_ADJ;
      app.makeActive(mSystemThread.getApplicationThread(), mProcessStats);
      mPidsSelfLocked.put(app);
      mProcessList.updateLruProcessLocked(app, false, null);
      updateOomAdjLocked(OomAdjuster.OOM_ADJ_REASON_NONE);
    }
  } 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.
  mAppOpsService.startWatchingMode(AppOpsManager.OP_RUN_IN_BACKGROUND, null,
          new IAppOpsCallback.Stub() {
              @Override public void opChanged(int op, int uid, String packageName) {
                   if (op == AppOpsManager.OP_RUN_IN_BACKGROUND && packageName != null) {
                       if (mAppOpsService.checkOperation(op, uid, packageName)
                             != AppOpsManager.MODE_ALLOWED) {
                         runInBackgroundDisabled(uid);
                       }
                   }
              }
          });
}

1）添加了各种服务，如AMS
2）mSystemThread.installSystemApplicationInfo：最终调到LoadedApk，这是应用的基本信息

接着看startOtherServices

private void startOtherServices() {
  //AMS与WMS关联
  mActivityManagerService.setWindowManager(wm);
  //安装ContentProvider
  mActivityManagerService.installSystemProviders();
  //所有的服务已经准备就绪
  mActivityManagerService.systemReady(() -> {
    //启动系统UI
    startSystemUi(context, windowManagerF);
    //执行一系列服务的systemReady
    networkStatsF.systemReady();
    //...
  }
}

installSystemProviders

public final void installSystemProviders() {
    List<ProviderInfo> providers;
    synchronized (this) {
        //找到名为"system"的进程，就是setSystemProcess中创建的ProcessRecord对象
        ProcessRecord app = mProcessList.mProcessNames.get("system", SYSTEM_UID);
        providers = generateApplicationProvidersLocked(app);
        if (providers != null) {
            for (int i=providers.size()-1; i>=0; i--) {
                ProviderInfo pi = (ProviderInfo)providers.get(i);
                if ((pi.applicationInfo.flags&ApplicationInfo.FLAG_SYSTEM) == 0) {
                    //移除非系统provider
                    Slog.w(TAG, "Not installing system proc provider " + pi.name
                            + ": not system .apk");
                    providers.remove(i);
                }
            }
        }
    }
    if (providers != null) {
        //安全所有的系统provider
        mSystemThread.installSystemProviders(providers);
    }

    synchronized (this) {
        mSystemProvidersInstalled = true;
    }
    mConstants.start(mContext.getContentResolver());
    //创建核心Settings Observer，用于监听Settings的改变
    mCoreSettingsObserver = new CoreSettingsObserver(this);
    mActivityTaskManager.installSystemProviders();
    //开发者权限
    mDevelopmentSettingsObserver = new DevelopmentSettingsObserver();
    SettingsToPropertiesMapper.start(mContext.getContentResolver());
    mOomAdjuster.initSettings();

    // Now that the settings provider is published we can consider sending
    // in a rescue party.
    RescueParty.onSettingsProviderPublished(mContext);

    //mUsageStatsService.monitorPackages();
}

1）installSystemProviders：安装系统Provider
2）new CoreSettingsObserver(this)：创建CoreSettingsObserver，用于监听系统设置的改变

systemReady

public void systemReady(final Runnable goingCallback, TimingsTraceLog traceLog) {
  //启动Launcher界面
  mAtmInternal.startHomeOnAllDisplays(currentUserId, "systemReady");
}

小结：

1、new SystemServer()创建了ActivityThread
2、SystemServer的run方法中：
1）通过createSystemContext方法创建系统上下文对象
2）在startBootstrapServices方法中调用构造方法对AMS进行初始化，start方法启动AMS
3）调用setSystemProcess将AMS注册到ServiceManager中
4）在startOtherServices中安装了系统Provider
5）调用systemReady启动Launcher界面