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界面