Android开发学习—手机开机启动的AMS流程

前言

AMS是Android中最核心的服务，主要负责系统中四大组件的启动、切换、调度及应用进程的管理和调度等工作，其职责与操作系统中的进程管理和调度模块相类似，因此它在Android中非常重要。

客户端使用ActivityManager类。由于AMS是系统核心服务，很多API不能开放供客户端使用，所以设计者没有让ActivityManager直接加入AMS家族。在ActivityManager类内部通过调用AMN的getDefault函数得到一个ActivityManagerProxy对象，通过它可与AMS通信。

启动流程

在Android系统启动流程中中我们提到过，AMS是在system_service中启动的，

//frameworks/base/services/java/corri/android/server/SystemServer.java
 
//该方法主要启动服务 ActivityManagerService，PowerManagerService，LightsService，DisplayManagerService，PackageManagerService，UserManagerService。
//设置 ActivityManagerService，启动传感器服务。
startBootstrapServices(); // 启动引导服务
 
//该方法主要
//启动服务 BatteryService 用于统计电池电量，需要 LightService。
//启动服务 UsageStatsService，用于统计应用使用情况。
//启动服务 WebViewUpdateService。
startCoreServices(); // 启动核心服务
 
//该方法主要启动服务 InputManagerService，WindowManagerService。
//等待 ServiceManager，SurfaceFlinger启动完成，然后显示启动界面。
//启动服务 StatusBarManagerService，
//准备好 window, power, package, display 服务：
//  - WindowManagerService.systemReady()
//  - PowerManagerService.systemReady()
//  - PackageManagerService.systemReady()
//  - DisplayManagerService.systemReady()
startOtherServices(); // 启动其他服务

在启动核心服务功能中，会进行AMS的启动。

//frameworks/base/services/java/corri/android/server/SystemServer.java
private void startBootstrapServices() {
   ...
//这里会将ATMS注册到ServiceManager中，然后调用ATMS的start方法。
ActivityTaskManagerService atm = mSystemServiceManager.startService(ActivityTaskManagerService.Lifecycle.class).getService();
//重点方法1。 注册AMS服务，并返回对应的对象信息
mActivityManagerService = ActivityManagerService.Lifecycle.startService(mSystemServiceManager, atm);
mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
//设置app安装器
mActivityManagerService.setInstaller(installer);
...
//重点方法2。 向ServiceManager中注册Binder服务
mActivityManagerService.setSystemProcess();
}

这里我们只截取了AMS的启动代码。

这里会通过startService方法来进行AMS的注册和启动过程。我们看一下具体的ActivityManagerService中的startService方法

startService

// 
    public static ActivityManagerService startService(SystemServiceManager ssm, ActivityTaskManagerService atm) {
  sAtm = atm;
  //调用SM的startService方法。创建AMS实例，并启动AMS
  return ssm.startService(ActivityManagerService.Lifecycle.class).getService();
 }

我们在ServiceManager的工作原理中讲解过，systemServiceManager.startService方法会将对应的服务注册到ServiceManager中，然后再调用start方法。

//frameworks/base/services/core/java/com/android/server/SystemServiceManager.java
        public SystemService startService(String className) {
 final Class<SystemService> serviceClass;
 serviceClass = (Class<SystemService>)Class.forName(className);
 return startService(serviceClass);
 }
 
 @SuppressWarnings("unchecked")
 public <T extends SystemService> T startService(Class<T> serviceClass) {
 try {
  final String name = serviceClass.getName();
  final T service;
  try {
  //反射构造函数
  Constructor<T> constructor = serviceClass.getConstructor(Context.class);
  //创建服务
  service = constructor.newInstance(mContext);
  ...
  //启动服务
  startService(service);
  return service;
 } finally {
  Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
 }
 }
 
 public void startService(@NonNull final SystemService service) {
 // Register it.
 //注册到ServiceManager列表中
 mServices.add(service);
 //调用服务对应的onStart方法
 service.onStart();
 }

在启动AMS的时候传入的参数是：ActivityManagerService.Lifecycle.class。所以这里实际上会调用ActivityManagerService.Lifecycle 的构造方法，然后调用它的onStart方法

public static final class Lifecycle extends SystemService {
private final ActivityTaskManagerService mService;
public Lifecycle(Context context) {
 super(context);
 //创建AMS对象
 mService = new ActivityManagerService(context, sAtm);
}
@Override
public void onStart() {
 //调用AMS的start方法
 mService.start();
}
 
public ActivityManagerService getService() {
 //返回了AMS实例
 return mService;
}
}

在Lifecycle对象的创建过程中，会创建AMS对象，然后通过start()方法进行了启动。

AMS的创建

对于AMS对象的创建是通过构造函数来创建的。

//构造方法，
public ActivityManagerService(Context systemContext, ActivityTaskManagerService atm) {
//获取系统的ActivityThread
mSystemThread = ActivityThread.currentActivityThread();
//创建一个ServiceThread用来处理AMS接收到的命令
mHandlerThread = new ServiceThread(TAG,THREAD_PRIORITY_FOREGROUND, false /*allowIo*/);
mHandlerThread.start();
mHandler = new MainHandler(mHandlerThread.getLooper());
mUiHandler = mInjector.getUiHandler(this);
//低内存监控
mLowMemDetector = new LowMemDetector(this);
//初始化广播队列。这里包含了前台广播，后台广播等
mFgBroadcastQueue = new BroadcastQueue(this, mHandler, "foreground", foreConstants, false);
mBgBroadcastQueue = new BroadcastQueue(this, mHandler, "background", backConstants, true);
mOffloadBroadcastQueue = new BroadcastQueue(this, mHandler, "offload", offloadConstants, true);
mBroadcastQueues[0] = mFgBroadcastQueue;
mBroadcastQueues[1] = mBgBroadcastQueue;
mBroadcastQueues[2] = mOffloadBroadcastQueue;
//用于保存注册的Service
mServices = new ActiveServices(this);
//map，用于保存注册的ContentProvider
mProviderMap = new ProviderMap(this);
mPackageWatchdog = PackageWatchdog.getInstance(mUiContext);
mAppErrors = new AppErrors(mUiContext, this, mPackageWatchdog);
 
//创建 /data/system目录
final File systemDir = SystemServiceManager.ensureSystemDir();
//创建进程统计服务，保存在/data/system/proccstats目录中。
mProcessStats = new ProcessStatsService(this, new File(systemDir, "procstats"));
//赋值ATM，并进行初始化
mActivityTaskManager = atm;
mActivityTaskManager.initialize(mIntentFirewall, mPendingIntentController, DisplayThread.get().getLooper());
//CPU追踪器进程
mProcessCpuThread = new Thread("CpuTracker") {
 @Override
 public void run() {
 ...
 }
};
 
}

在AMS的构造函数中进行了一些初始化的东西：比如说启动CPU监控、启动进程统计服务、启动低内存监控、初始化Service和ContentProvider对应的保存类等等。

start()

当AMS类创建完成之后，会调用start()方法。

private void start() {
    //移除所有的进程组
removeAllProcessGroups();
//启动CpuTracker线程
mProcessCpuThread.start();
//启动电池统计服务，能够统计具体的应用的电池消耗，从而来进行一定的电量统计
mBatteryStatsService.publish();
//创建LocalService，并添加到LocalServices列表中
LocalServices.addService(ActivityManagerInternal.class, new LocalService());
mActivityTaskManager.onActivityManagerInternalAdded();
mUgmInternal.onActivityManagerInternalAdded();
mPendingIntentController.onActivityManagerInternalAdded();
}

在start方法中，会将在构造函数中创建的一些线程进行启动。

setSystemProcess

在创建并启动完成之后，会通过setSystemProcess方法来向ServiceManager中注册一些系统相关的服务。

public void setSystemProcess() {
try {
   //注册ActivityService服务
 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));
 //注册SQLite DB 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));
 //获取“android”应用的ApplicationInfo，并装载到mSystemThread
 ApplicationInfo info = mContext.getPackageManager().getApplicationInfo("android", STOCK_PM_FLAGS | MATCH_SYSTEM_ONLY);
 mSystemThread.installSystemApplicationInfo(info, getClass().getClassLoader());
 //创建ProcessRecord维护进程的相关信息
 synchronized (this) {
 ProcessRecord app = mProcessList.newProcessRecordLocked(info, info.processName,...);
 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);
}
}

在这个方法中会设置一些系统进程，主要功能为：

注册一些服务:activity、procstats、meminfo、gfxinfo、dbinfo、cpuinfo、permission、processinfo等。
获取包名为“android”的应用的ApplicationInfo对象，并将该ApplicationInfo信息安装设置到SystemThread(系统进程主线程)。即可以理解，系统也是一个特殊的应用。
创建ProcessRecord维护进程的相关信息，这里MY_PID即为SystemServer进程ID。
启动检测应用运行和交互。

后续

当AMS创建并启动之后，会有一系列的后续的工作需要处理。这些操作都是在startOtherServices()中去调用的

private void startOtherServices() {
 //注册系统的ContentProvider信息
 mActivityManagerService.installSystemProviders();
 
 mActivityManagerService.setWindowManager(wm);
   mActivityManagerService.systemReady(() -> {
 ......//goingCallback
 }, BOOT_TIMINGS_TRACE_LOG);
}

这里的主要功能是：

关键服务继续进行初始化
已经启动的进程，如果没有FLAG_PERSISTENT标志位，则会被kill掉
运行goingCallBack
启动launcher的Activity，即桌面应用。

这里继续跟踪一下goingCallBack的具体执行内容。

goingCallBack

mActivityManagerService.systemReady(() -> {
 try {
 //启动NativeCrash的监测
 mActivityManagerService.startObservingNativeCrashes();
 } catch (Throwable e) {
 reportWtf("observing native crashes", e);
 }
 if (!mOnlyCore && mWebViewUpdateService != null) {
 webviewPrep = SystemServerInitThreadPool.get().submit(() -> {
  //启动WebView相关
  mWebViewUpdateService.prepareWebViewInSystemServer();
 }, WEBVIEW_PREPARATION);
 }
 
 try {
 //启动systemUI
 startSystemUi(context, windowManagerF);
 } catch (Throwable e) {
 reportWtf("starting System UI", e);
 }
 ...
}

在这个里面会继续进行一些初始化的工作：

启动NativeCrash监测
启动WebView相关服务
启动SystemUI

startHomeOnAllDisplays

该功能主要是进行桌面程序的启动，和AMS的启动流程关联不大，在这里不再详细进行解析。

AMS启动流程源码分析

1.AMS由SystemServer的ServerThread线程创建，代码如下：

编辑切换为居中

添加图片注释，不超过 140 字（可选）

由以上代码分析可得：

AMS的创建是通过ActivityManagerService.java里面的Lifecycle类创建出来的。该LifeCycle的代码如下：

这个其实很好理解啦，就相当于AMS的生命周期。在后面的源码分析中我们会经常看到这个类，没什么好说的，就相当于一个服务的生命周期，从创建到销毁的整个过程。

我们去看一下AMS的构造方法里面有些什么东西，代码如下：

  1     public ActivityManagerService(Context systemContext) {
  2         LockGuard.installLock(this, LockGuard.INDEX_ACTIVITY);
  3         mInjector = new Injector();
  4         mContext = systemContext;
  5 
  6         mFactoryTest = FactoryTest.getMode();
  7         mSystemThread = ActivityThread.currentActivityThread();
  8         mUiContext = mSystemThread.getSystemUiContext();
  9 
 10         Slog.i(TAG, "Memory class: " + ActivityManager.staticGetMemoryClass());
 11 
 12         mPermissionReviewRequired = mContext.getResources().getBoolean(
 13                 com.android.internal.R.bool.config_permissionReviewRequired);
 14 
 15         mHandlerThread = new ServiceThread(TAG,
 16                 THREAD_PRIORITY_FOREGROUND, false /*allowIo*/);
 17         mHandlerThread.start();
 18         mHandler = new MainHandler(mHandlerThread.getLooper());
 19         mUiHandler = mInjector.getUiHandler(this);
 20 
 21         mConstants = new ActivityManagerConstants(this, mHandler);
 22 
 23         /* static; one-time init here */
 24         if (sKillHandler == null) {
 25             sKillThread = new ServiceThread(TAG + ":kill",
 26                     THREAD_PRIORITY_BACKGROUND, true /* allowIo */);
 27             sKillThread.start();
 28             sKillHandler = new KillHandler(sKillThread.getLooper());
 29         }
 30 
 31         mFgBroadcastQueue = new BroadcastQueue(this, mHandler,
 32                 "foreground", BROADCAST_FG_TIMEOUT, false);
 33         mBgBroadcastQueue = new BroadcastQueue(this, mHandler,
 34                 "background", BROADCAST_BG_TIMEOUT, true);
 35         mBroadcastQueues[0] = mFgBroadcastQueue;
 36         mBroadcastQueues[1] = mBgBroadcastQueue;
 37 
 38         mServices = new ActiveServices(this);
 39         mProviderMap = new ProviderMap(this);
 40         mAppErrors = new AppErrors(mUiContext, this);
 41 
 42         // TODO: Move creation of battery stats service outside of activity manager service.
 43         File dataDir = Environment.getDataDirectory();
 44         File systemDir = new File(dataDir, "system");
 45         systemDir.mkdirs();
 46         mBatteryStatsService = new BatteryStatsService(systemDir, mHandler);
 47         mBatteryStatsService.getActiveStatistics().readLocked();
 48         mBatteryStatsService.scheduleWriteToDisk();
 49         mOnBattery = DEBUG_POWER ? true
 50                 : mBatteryStatsService.getActiveStatistics().getIsOnBattery();
 51         mBatteryStatsService.getActiveStatistics().setCallback(this);
 52 
 53         mProcessStats = new ProcessStatsService(this, new File(systemDir, "procstats"));
 54 
 55         mAppOpsService = mInjector.getAppOpsService(new File(systemDir, "appops.xml"), mHandler);
 56         mAppOpsService.startWatchingMode(AppOpsManager.OP_RUN_IN_BACKGROUND, null,
 57                 new IAppOpsCallback.Stub() {
 58                     @Override public void opChanged(int op, int uid, String packageName) {
 59                         if (op == AppOpsManager.OP_RUN_IN_BACKGROUND && packageName != null) {
 60                             if (mAppOpsService.checkOperation(op, uid, packageName)
 61                                     != AppOpsManager.MODE_ALLOWED) {
 62                                 runInBackgroundDisabled(uid);
 63                             }
 64                         }
 65                     }
 66                 });
 67 
 68         mGrantFile = new AtomicFile(new File(systemDir, "urigrants.xml"));
 69 
 70         mUserController = new UserController(this);
 71 
 72         mVrController = new VrController(this);
 73 
 74         GL_ES_VERSION = SystemProperties.getInt("ro.opengles.version",
 75             ConfigurationInfo.GL_ES_VERSION_UNDEFINED);
 76 
 77         if (SystemProperties.getInt("sys.use_fifo_ui", 0) != 0) {
 78             mUseFifoUiScheduling = true;
 79         }
 80 
 81         mTrackingAssociations = "1".equals(SystemProperties.get("debug.track-associations"));
 82         mTempConfig.setToDefaults();
 83         mTempConfig.setLocales(LocaleList.getDefault());
 84         mConfigurationSeq = mTempConfig.seq = 1;
 85         mStackSupervisor = createStackSupervisor();
 86         mStackSupervisor.onConfigurationChanged(mTempConfig);
 87         mKeyguardController = mStackSupervisor.mKeyguardController;
 88         mCompatModePackages = new CompatModePackages(this, systemDir, mHandler);
 89         mIntentFirewall = new IntentFirewall(new IntentFirewallInterface(), mHandler);
 90         mTaskChangeNotificationController =
 91                 new TaskChangeNotificationController(this, mStackSupervisor, mHandler);
 92         mActivityStarter = new ActivityStarter(this, mStackSupervisor);
 93         mRecentTasks = new RecentTasks(this, mStackSupervisor);
 94 
 95         mProcessCpuThread = new Thread("CpuTracker") {
 96             @Override
 97             public void run() {
 98                 synchronized (mProcessCpuTracker) {
 99                     mProcessCpuInitLatch.countDown();
100                     mProcessCpuTracker.init();
101                 }
102                 while (true) {
103                     try {
104                         try {
105                             synchronized(this) {
106                                 final long now = SystemClock.uptimeMillis();
107                                 long nextCpuDelay = (mLastCpuTime.get()+MONITOR_CPU_MAX_TIME)-now;
108                                 long nextWriteDelay = (mLastWriteTime+BATTERY_STATS_TIME)-now;
109                                 //Slog.i(TAG, "Cpu delay=" + nextCpuDelay
110                                 //        + ", write delay=" + nextWriteDelay);
111                                 if (nextWriteDelay < nextCpuDelay) {
112                                     nextCpuDelay = nextWriteDelay;
113                                 }
114                                 if (nextCpuDelay > 0) {
115                                     mProcessCpuMutexFree.set(true);
116                                     this.wait(nextCpuDelay);
117                                 }
118                             }
119                         } catch (InterruptedException e) {
120                         }
121                         updateCpuStatsNow();
122                     } catch (Exception e) {
123                         Slog.e(TAG, "Unexpected exception collecting process stats", e);
124                     }
125                 }
126             }
127         };
128 
129         Watchdog.getInstance().addMonitor(this);
130         Watchdog.getInstance().addThread(mHandler);
131     }

主要内容包括：

1>.主线程mHandlerThread创建并启动(Android UI线程)
2>.创建了一个工作目录：/data/system (AMS的活动目录)
3>.ActiveService,ActivityStackSupervisor的创建(专门用于管理Activity)
4>.AMS的守护进程Watchdog（俗称 “看门狗”）

总结：

AMS的启动流程图：

AMS是在SystemServer进程中进行创建并启动的
在AMS的服务启动过程中，通过构造函数进行了一些对象的创建和初始化工作（初Activity外其他3大组件的列表和调度对象的创建；内存、电池、权限、CPU等的监控等等相关对象的创建），并且通过start()方法启动服务（移除进程组、启动CPU线程、权限注册、电池服务等等）。
AMS创建并将对应服务启动之后，会通过setSystemProcess方法，将framework-res.apk的信息加入到SystemServer进程的LoadedApk中，并创建了SystemServer进程的ProcessRecord，加入到了mPidsSelfLocked，交给AMS来统一管理
AMS启动之后的后续工作，主要调用systemReady()和传入的goingCallBack来执行。主要是各种服务或者进程，等AMS启动完成后需要进一步完成的工作以及系统相关的初始化。
桌面应用是在systemReady()方法中启动，systemUI是在goingCallback中完成。
当桌面应用启动完成以后，发送开机广播ACTION_BOOT_COMPLETED。