前言
AMS属于Android中最核心的服务，主要负责系统中四大组件的启动、切换、调度及应用进程的管理和调度等工作，其职责与操作系统中的进程管理和调度模块相类似。而AMS的初始化与启动是在系统进程SystemServer中，这个系统进程囊括各种各样的系统服务，比如AMS、WMS、PKMS等。
1. AMS初始化
AMS是在SystemServer中的startBootstrapServices方法去初始化与启动的。
startBootstrapServices方法会去启动一些系统引导服务，如AMS、PowerManagerService等服务，还有其他两个方法会去启动一些服务，下面我们大概来看看这几个方法：
/frameworks/base/services/java/com/android/server/SystemServer.java
private void run() {
....................
// Start services.
try {
t.traceBegin("StartServices");
/**
*该方法主要启动服务 ActivityManagerService，PowerManagerService， LightsService，
*DisplayManagerService，PackageManagerService，UserManagerService。
* 设置 ActivityManagerService，启动传感器服务。
*/
startBootstrapServices(t);// 启动引导服务
/**
*该方法主要启动服务 BatteryService 用于统计电池电量，需要 LightService。
*启动服务 UsageStatsService，用于统计应用使用情况。
*启动服务 WebViewUpdateService。
*/
startCoreServices(t);// 启动核心服务
/**
*该方法主要启动服务 InputManagerService，WindowManagerService。
*等待 ServiceManager，SurfaceFlinger启动完成，然后显示启动界面。
*启动服务 StatusBarManagerService，
* 准备好 window, power, package, display 服务：
* - WindowManagerService.systemReady()
* - PowerManagerService.systemReady()
* - PackageManagerService.systemReady()
* - DisplayManagerService.systemReady()
*/
startOtherServices(t);// 启动其他服务
} catch (Throwable ex) {
Slog.e("System", "******************************************");
Slog.e("System", "************ Failure starting system services", ex);
throw ex;
} finally {
t.traceEnd(); // StartServices
}
}下面来startBootstrapServices方法看看AMS的初始化流程：
1.1 SystemServer.startBootstrapServices
/frameworks/base/services/java/com/android/server/SystemServer.java
private void startBootstrapServices(@NonNull TimingsTraceAndSlog t) {
..................
// Activity manager runs the show.
t.traceBegin("StartActivityManager");
// TODO: Might need to move after migration to WM.
// 将ATMS注册到ServiceManager中，然后调用ATMS的start方法
ActivityTaskManagerService atm = mSystemServiceManager.startService(
ActivityTaskManagerService.Lifecycle.class).getService();
// 注册AMS服务，并返回对应的对象信息
mActivityManagerService = ActivityManagerService.Lifecycle.startService(
mSystemServiceManager, atm);
mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
// 设置app安装器
mActivityManagerService.setInstaller(installer);
mWindowManagerGlobalLock = atm.getGlobalLock();
t.traceEnd();
...........
// Set up the Application instance for the system process and get started.
t.traceBegin("SetSystemProcess");
// 向ServiceManager中注册Binder服务
mActivityManagerService.setSystemProcess();
t.traceEnd();
..............
}上面我们可以看出先拿到ATMS对象，然后在调用AMS的startService方法中传入，通过startService去注册与启动：
1.2 ActivityManagerService.Lifecycle.startService
/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
public static ActivityManagerService startService(
SystemServiceManager ssm, ActivityTaskManagerService atm) {
sAtm = atm;
// 通过SystemServiceManager.startService去启动
return ssm.startService(ActivityManagerService.Lifecycle.class).getService();
}可以看出AMS是通过SystemServiceManager.startService去启动的，并且传入的参数是
ActivityManagerService.Lifecycle.class
1.3 SystemServiceManager.startService
/frameworks/base/services/core/java/com/android/server/SystemServiceManager.java
public SystemService startService(String classNam
final Class<SystemService> serviceClass = loa
this.getClass().getClassLoader());
return startService(serviceClass);
}
public <T extends SystemService> T startService(Class<T> serviceClass) {
try {
...........
final T service;
try {
// 反射构造方法
Constructor<T> constructor = serviceClass.getConstructor(Context.class);
// 创建服务，实际就是new一个AMS对象
service = constructor.newInstance(mContext);
} catch (InstantiationException ex) {
................
}
// 启动服务
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);
// Start it.
long time = SystemClock.elapsedRealtime();
try {
// 调用服务对应的onStart方法
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");
}从上面可以看出反射构造方法的时候会走到Lifecycle里面的带context的构造方法里面：
1.4 ActivityManagerService.Lifecycle构造方法
/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
public static final class Lifecycle extends SystemService {
private final ActivityManagerService mService;
private static ActivityTaskManagerService sAtm;
public Lifecycle(Context context) {
super(context);
// 进入AMS构造方法
mService = new ActivityManagerService(context, sAtm);
}
...........
}Lifecycle属于AMS的静态内部类。
进入AMS的构造方法，这时候来到了AMS的初始化流程:
1.5 ActivityManagerService构造方法
/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
public ActivityManagerService(Context systemContext, ActivityTaskManagerService atm) {
LockGuard.installLock(this, LockGuard.INDEX_ACTIVITY);
mInjector = new Injector(systemContext);
// AMS的运行上下文与SystemServer一致
mContext = systemContext;
mFactoryTest = FactoryTest.getMode();
// 获取运行在SystemServer中的ActivityThread对象，mSystemThread与SystemServer中的ActivityThread一致
mSystemThread = ActivityThread.currentActivityThread();
mUiContext = mSystemThread.getSystemUiContext();
Slog.i(TAG, "Memory class: " + ActivityManager.staticGetMemoryClass());
// 创建用于处理消息的线程和Handler对象
mHandlerThread = new ServiceThread(TAG,
THREAD_PRIORITY_FOREGROUND, false /*allowIo*/);
mHandlerThread.start();
mHandler = new MainHandler(mHandlerThread.getLooper());
// 创建用于UI操作相关的Handler对象
mUiHandler = mInjector.getUiHandler(this);
................
// Broadcast policy parameters
// 广播策略参数
final BroadcastConstants foreConstants = new BroadcastConstants(
Settings.Global.BROADCAST_FG_CONSTANTS);
foreConstants.TIMEOUT = BROADCAST_FG_TIMEOUT;
final BroadcastConstants backConstants = new BroadcastConstants(
Settings.Global.BROADCAST_BG_CONSTANTS);
backConstants.TIMEOUT = BROADCAST_BG_TIMEOUT;
final BroadcastConstants offloadConstants = new BroadcastConstants(
Settings.Global.BROADCAST_OFFLOAD_CONSTANTS);
offloadConstants.TIMEOUT = BROADCAST_BG_TIMEOUT;
// by default, no "slow" policy in this queue
// 缺省情况下，该队列中没有“slow”策略
offloadConstants.SLOW_TIME = Integer.MAX_VALUE;
mEnableOffloadQueue = SystemProperties.getBoolean(
"persist.device_config.activity_manager_native_boot.offload_queue_enabled", false);
// 创建 BroadcastQueue 前台广播对象，处理超时时长是 10s
mFgBroadcastQueue = new BroadcastQueue(this, mHandler,
"foreground", foreConstants, false);
// 创建 BroadcastQueue 后台广播对象，处理超时时长是 60s
mBgBroadcastQueue = new BroadcastQueue(this, mHandler,
"background", backConstants, true);
//创建 BroadcastQueue 分流广播对象，处理超时时长是 60s
mOffloadBroadcastQueue = new BroadcastQueue(this, mHandler,
"offload", offloadConstants, true);
mBroadcastQueues[0] = mFgBroadcastQueue;
mBroadcastQueues[1] = mBgBroadcastQueue;
mBroadcastQueues[2] = mOffloadBroadcastQueue;
// 创建管理组件Service的对象
mServices = new ActiveServices(this);
mProviderMap = new ProviderMap(this);
mPackageWatchdog = PackageWatchdog.getInstance(mUiContext);
mAppErrors = new AppErrors(mUiContext, this, mPackageWatchdog);
final File systemDir = SystemServiceManager.ensureSystemDir();
// TODO: Move creation of battery stats service outside of activity manager service.
// 将电池状态服务的创建移出活动管理器服务。
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);
// 创建ProcessStatsService服务
mProcessStats = new ProcessStatsService(this, new File(systemDir, "procstats"));
// 创建AppOpsService应用权限管理服务
mAppOpsService = mInjector.getAppOpsService(new File(systemDir, "appops.xml"), mHandler);
................
mTrackingAssociations = "1".equals(SystemProperties.get("debug.track-associations"));
// 创建Intent “防火墙”
mIntentFirewall = new IntentFirewall(new IntentFirewallInterface(), mHandler);
// 绑定了 ActivityTaskManagerService 对象
mActivityTaskManager = atm;
mActivityTaskManager.initialize(mIntentFirewall, mPendingIntentController,
DisplayThread.get().getLooper());
mAtmInternal = LocalServices.getService(ActivityTaskManagerInternal.class);
// 程对象mProcessCpuThread的创建，在这个线程中，进行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);
}
}
}
};
mHiddenApiBlacklist = new HiddenApiSettings(mHandler, mContext);
// 把服务加到watchdog的监控中
Watchdog.getInstance().addMonitor(this);
Watchdog.getInstance().addThread(mHandler);
// bind background threads 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
// 将后台线程绑定到小内核，这在框架测试中可能会失败，因为应用程序不能直接接触cpusets。确保我们已经首先调整了system_server的内部视图
updateOomAdjLocked(OomAdjuster.OOM_ADJ_REASON_NONE);
try {
Process.setThreadGroupAndCpuset(BackgroundThread.get().getThreadId(),
Process.THREAD_GROUP_SYSTEM);
Process.setThreadGroupAndCpuset(
mOomAdjuster.mCachedAppOptimizer.mCachedAppOptimizerThread.getThreadId(),
Process.THREAD_GROUP_SYSTEM);
} catch (Exception e) {
Slog.w(TAG, "Setting background thread cpuset failed");
}
mInternal = new LocalService();
mPendingStartActivityUids = new PendingStartActivityUids(mContext);
}AMS 的构造方法，主要完成一些对象的构造及变量的初始化，三大组件的（service、broadcast、provider）管理和调度（activity 移到了ActivityTaskManagerService 中，但此处也绑定了 ActivityTaskManagerService 对象)。监控内存、电池、权限（可以了解下appops.xml）以及性能相关的对象或变量。BatteryStatsService、mProcessStats、mAppOpsService等。
AMS的初始化流程就到这里了，接下来我们再回去看看AMS的启动过程,在1.3小结中我们可以看到最后启动AMS服务调用它的start方法：
2. AMS启动
2.1 SystemServiceManager.startService
/frameworks/base/services/core/java/com/android/server/SystemServiceManager.java
public void startService(@NonNull final SystemService service) {
// Register it.
// 注册到ServiceManager列表中
mServices.add(service);
// Start it.
long time = SystemClock.elapsedRealtime();
try {
// 调用服务对应的onStart方法
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");
}然后调用到SystemService的onStart方法，SystemService是一个抽象类，这里AMS#Lifecycle内部类继承了SystemService，所以也重写了onStart方法：
2.2 ActivityManagerService.Lifecycle.startService
/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
public static final class Lifecycle extends SystemService {
...........
@Override
public void onStart() {
// 调用AMS的Start方法
mService.start();
}
}2.3 ActivityManagerService.start
/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
private void start() {
// 移除所有的进程组
removeAllProcessGroups();
// 启动cpu使用监控线程
mProcessCpuThread.start();
// 注册电池、权限管理相关服务
mBatteryStatsService.publish();
mAppOpsService.publish();
Slog.d("AppOps", "AppOpsService published");
// 把AMS服务自己保存到LocalServices供内部调用
LocalServices.addService(ActivityManagerInternal.class, mInternal);
mActivityTaskManager.onActivityManagerInternalAdded();
mPendingIntentController.onActivityManagerInternalAdded();
// Wait for the synchronized block started in mProcessCpuThread,
// so that any other access to mProcessCpuTracker from main thread
// will be blocked during mProcessCpuTracker initialization.
try {
// 等待mProcessCpuInitLatch完成初始化后，释放锁，初始化期间禁止访问
mProcessCpuInitLatch.await();
} catch (InterruptedException e) {
Slog.wtf(TAG, "Interrupted wait during start", e);
Thread.currentThread().interrupt();
throw new IllegalStateException("Interrupted wait during start");
}
}AMS的start方法主要做了如下几件事：
- 移除所有的进程组;
- 启动cpu使用监控线程;
- 注册电池、权限管理相关服务;
- 把AMS服务自己保存到LocalServices供内部调用，LocalServices类似于ServiceManager，但仅供同进程使用;
- 等待mProcessCpuInitLatch完成初始化后，释放锁，初始化期间禁止访问;
至此AMS启动流程完毕，接下来在看看SystemServer里面关于AMS的其他重要方法：
3. mActivityManagerService.setSystemProcess()
/frameworks/base/services/java/com/android/server/SystemServer.java
private void startBootstrapServices(@NonNull TimingsTraceAndSlog t) {
....
// Set up the Application instance for the system process and get started.
t.traceBegin("SetSystemProcess");
mActivityManagerService.setSystemProcess();
t.traceEnd();
....
}/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
public void setSystemProcess() {
try {
// 注册服务activity
ServiceManager.addService(Context.ACTIVITY_SERVICE, this, /* allowIsolated= */ true,
DUMP_FLAG_PRIORITY_CRITICAL | DUMP_FLAG_PRIORITY_NORMAL | DUMP_FLAG_PROTO);
// 注册服务ProcessStats，进程状态
ServiceManager.addService(ProcessStats.SERVICE_NAME, mProcessStats);
// 注册服务meminfo，内存信息
ServiceManager.addService("meminfo", new MemBinder(this), /* allowIsolated= */ false,
DUMP_FLAG_PRIORITY_HIGH);
// 注册服务gfxinfo，图像信息
ServiceManager.addService("gfxinfo", new GraphicsBinder(this));
// 注册服务dbinfo，数据库信息
ServiceManager.addService("dbinfo", new DbBinder(this));
if (MONITOR_CPU_USAGE) {
// 注册服务，cpu信息
ServiceManager.addService("cpuinfo", new CpuBinder(this),
/* allowIsolated= */ false, DUMP_FLAG_PRIORITY_CRITICAL);
}
// 注册服务permission和processinfo，权限和进程信息
ServiceManager.addService("permission", new PermissionController(this));
ServiceManager.addService("processinfo", new ProcessInfoService(this));
// 注册服务cacheinfo，缓存信息
ServiceManager.addService("cacheinfo", new CacheBinder(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,
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);
// 将系统进程的processRecord对象也添加到sActiveProcessInfoSelfLocked集合中，和普通应用的进程一样，接收AMS的管理调度
addPidLocked(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 (getAppOpsManager().checkOpNoThrow(op, uid, packageName)
!= AppOpsManager.MODE_ALLOWED) {
runInBackgroundDisabled(uid);
}
}
}
});
final int[] cameraOp = {AppOpsManager.OP_CAMERA};
mAppOpsService.startWatchingActive(cameraOp, new IAppOpsActiveCallback.Stub() {
@Override
public void opActiveChanged(int op, int uid, String packageName, boolean active) {
cameraActiveChanged(uid, active);
}
});
}AMS#setSystemProcess主要作用：
- 通过Binder向系统服务管理ServiceManager注册我们的服务，这样android中的其他进程就可以通过context的getSystemService找到我们的服务;
- 注册了权限服务等其他的系统服务；
- 让AMS同样可以管理调度system系统进程(AMS所在进程)，也创建了一个关于系统进程的ProcessRecord对象，ProcessRecord对象保存一个进程的相关信息。然后将它保存到sActiveProcessInfoSelfLocked集合中方便管理；
AMS启动完毕后调用SystemServer#startOtherServices方法，startOtherServices方法里面调用了 ActivityManagerService#systemReady()方法：
4. mActivityManagerService.systemReady
/frameworks/base/services/java/com/android/server/SystemServer.java
private void startOtherServices(@NonNull TimingsTraceAndSlog t) {
....
mActivityManagerService.systemReady(() -> {
...
})
....
}该方法分为三个阶段：
- 主要是调用一些关键服务的初始化方法， 然后杀死那些没有FLAG_PERSISTENT却在AMS启动完成前已经存在的进程，同时获取一些配置参数。需要注意的是，由于只有Java进程才会向AMS注册，而一般的Native进程不会向AMS注册，因此此处杀死的进程是Java进程。
- 执行goingCallback的处理，主要的工作就是通知一些服务可以进行systemReady、systemRunning相关的工作，并进行启动服务或应用进程的工作。
- 启动Home Activity。
4.1 关键服务初始化
该阶段主要是调用一些关键服务的初始化方法，然后杀死那些没有FLAG_PERSISTENT却在AMS启动完成前已经存在的进程， 同时获取一些配置参数。 需要注意的是，由于只有Java进程才会向AMS注册，而一般的Native进程不会向AMS注册，因此此处杀死的进程是Java进程。
/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
public void systemReady(final Runnable goingCallback, @NonNull TimingsTraceAndSlog t) {
t.traceBegin("PhaseActivityManagerReady");
mSystemServiceManager.preSystemReady();
synchronized(this) {
// 第一次进入mSystemReady 为false，不走该流程
if (mSystemReady) {
// If we're done calling all the receivers, run the next "boot phase" passed in
// by the SystemServer
if (goingCallback != null) {
goingCallback.run();
}
t.traceEnd(); // PhaseActivityManagerReady
return;
}
t.traceBegin("controllersReady");
// 这一部分主要是调用一些关键服务SystemReady相关的方法，
// 进行一些等待AMS初始完，才能进行的工作
mLocalDeviceIdleController =
LocalServices.getService(DeviceIdleInternal.class);
mActivityTaskManager.onSystemReady();
// Make sure we have the current profile info, since it is needed for security checks.
mUserController.onSystemReady();
mAppOpsService.systemReady();
mProcessList.onSystemReady();
mSystemReady = true;
t.traceEnd();
}
try {
sTheRealBuildSerial = IDeviceIdentifiersPolicyService.Stub.asInterface(
ServiceManager.getService(Context.DEVICE_IDENTIFIERS_SERVICE))
.getSerial();
} catch (RemoteException e) {}
t.traceBegin("killProcesses");
ArrayList<ProcessRecord> procsToKill = null;
synchronized(mPidsSelfLocked) {
// mPidsSelfLocked 中保存当前正在运行的所有进程的信息
for (int i=mPidsSelfLocked.size()-1; i>=0; i--) {
ProcessRecord proc = mPidsSelfLocked.valueAt(i);
if (!isAllowedWhileBooting(proc.info)){
if (procsToKill == null) {
procsToKill = new ArrayList<ProcessRecord>();
}
procsToKill.add(proc);
}
}
}
.................
}4.2 执行goingCallback处理
/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
public void systemReady(final Runnable goingCallback, TimingsTraceLog traceLog) {
...
// 调用参数传入的runnable对象，SystemServer中有具体的定义
if (goingCallback != null) goingCallback.run();
...
// 启动系统服务(在这里主要是电池状态管理服务)
t.traceBegin("ActivityManagerStartApps");
mBatteryStatsService.onSystemReady();
mBatteryStatsService.noteEvent(BatteryStats.HistoryItem.EVENT_USER_RUNNING_START,
Integer.toString(currentUserId), currentUserId);
mBatteryStatsService.noteEvent(BatteryStats.HistoryItem.EVENT_USER_FOREGROUND_START,
Integer.toString(currentUserId), currentUserId);
final boolean bootingSystemUser = currentUserId == UserHandle.USER_SYSTEM;
if (bootingSystemUser) {
mSystemServiceManager.onUserStarting(t, currentUserId);
}
synchronized (this) {
//启动persistent为1的application所在的进程
startPersistentApps(PackageManager.MATCH_DIRECT_BOOT_AWARE);
// Start up initial activity.
mBooting = true;
...
}
}goingCallback.run()该方法主体在SystemServer#startOtherServices下,systemReady()下有一个Lambda 表达式，这个表达式的主体既为goingCallback.run()的内容，主要用于监控Native的crash，启动WebView，执行一些服务的systemReady 和systemRunning方法。
private void startOtherServices(){
mActivityManagerService.systemReady(()->{
// 阶段 550 Acitvity Manager启动完成
mSystemServiceManager.startBootPhase(
SystemService.PHASE_ACTIVITY_MANAGER_READY);
...
// 监控Native的crash
mActivityManagerService.startObservingNativeCrashes();
...
},BOOT_TIMINGS_TRACE_LOG);
...
//启动WebView
mWebViewUpdateService.prepareWebViewInSystemServer();
// 执行一系列服务的systemReady方法
networkManagementF.systemReady();
ipSecServiceF.systemReady();
networkStatsF.systemReady();
connectivityF.systemReady();
networkPolicyF.systemReady(networkPolicyInitReadySignal);
...
//阶段 600 第三方应用程序可以启动
t.traceBegin("PhaseThirdPartyAppsCanStart");
// confirm webview completion before starting 3rd party
if (webviewPrep != null) {
ConcurrentUtils.waitForFutureNoInterrupt(webviewPrep, WEBVIEW_PREPARATION);
}
mSystemServiceManager.startBootPhase(t, SystemService.PHASE_THIRD_PARTY_APPS_CAN_START);
t.traceEnd();
...........
//执行一系列服务的systemRunning方法
locationF.systemRunning();
countryDetectorF.systemRunning();
networkTimeUpdaterF.systemRunning();
inputManagerF.systemRunning();
telephonyRegistryF.systemRunning();
mediaRouterF.systemRunning();
...
}startPersistentApps()该方法用于启动persistent为1的application所在的进程：
void startPersistentApps(int matchFlags) {
if (mFactoryTest == FactoryTest.FACTORY_TEST_LOW_LEVEL) return;
synchronized (this) {
try {
final List<ApplicationInfo> apps = AppGlobals.getPackageManager().getPersistentApplications(STOCK_PM_FLAGS | matchFlags).getList();
for (ApplicationInfo app : apps) {
//由于framework-res.apk已经由系统启动，所以此处不再启动它
if (!"android".equals(app.packageName)) {
//addAppLocked中将启动application所在进程
addAppLocked(app, null, false, null /* ABI override */);
}
}
} catch (RemoteException ex) {
}
}
}
4.3 完成AMS启动(启动Home Activity—第一次启动的是fallbackhome)
4.3.1 home activity启动
下面我们来看看home activity的启动：
/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
public void systemReady(final Runnable goingCallback, @NonNull TimingsTraceAndSlog t) {
........
...
// 通过ATM，启动Home Activity
mAtmInternal.startHomeOnAllDisplays(currentUserId, "systemReady");
...
// 发送广播消息
try {
// system发送广播 ACTION_USER_STARTED = "android.intent.action.USER_STARTED";
Intent intent = new Intent(Intent.ACTION_USER_STARTED);
intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY| Intent.FLAG_RECEIVER_FOREGROUND);
intent.putExtra(Intent.EXTRA_USER_HANDLE, currentUserId);
broadcastIntentLocked(null, null, intent,null, null, 0, null, null, null, OP_NONE,null, false, false, MY_PID, SYSTEM_UID, callingUid, callingPid,currentUserId);
//system发送广播 ACTION_USER_STARTING= "android.intent.action.USER_STARTING";
intent = new Intent(Intent.ACTION_USER_STARTING);
intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);
intent.putExtra(Intent.EXTRA_USER_HANDLE, currentUserId);
broadcastIntentLocked(null, null, intent,null, new IIntentReceiver.Stub() {
@Override
public void performReceive(Intent intent, int resultCode, String data,
Bundle extras, boolean ordered, boolean sticky, int sendingUser)
throws RemoteException {
}
}, 0, null, null,
new String[] {INTERACT_ACROSS_USERS}, OP_NONE,
null, true, false, MY_PID, SYSTEM_UID, callingUid, callingPid,UserHandle.USER_ALL);
} catch (Throwable t) {
} finally {
}
..................
}/frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
@Override
public boolean startHomeOnAllDisplays(int userId, String reason) {
synchronized (mGlobalLock) {
// 通过RootWindowContainer启动
return mRootWindowContainer.startHomeOnAllDisplays(userId, reason);
}
}/frameworks/base/services/core/java/com/android/server/wm/RootWindowContainer.java
boolean startHomeOnAllDisplays(int userId, String reason) {
boolean homeStarted = false;
// getChildCount获取显示设备数目，这个主要从mChildren参数中获取对应的数量
// mChildren是一个WindowList的一个对象，其包含的数据是在setWindowManager方法被调用时，从DisplayManagerService中获取到的Display的数目
for (int i = getChildCount() - 1; i >= 0; i--) {
// 获取到对应新建的DisplayContent的displayId
final int displayId = getChildAt(i).mDisplayId;
// 调用startHomeOnDisplay方法
homeStarted |= startHomeOnDisplay(userId, reason, displayId);
}
return homeStarted;
}
//一系列调用最终调用startHomeOnTaskDisplayArea.......
boolean startHomeOnTaskDisplayArea(int userId, String reason, TaskDisplayArea taskDisplayArea,
boolean allowInstrumenting, boolean fromHomeKey) {
...............
Intent homeIntent = null;
ActivityInfo aInfo = null;
if (taskDisplayArea == getDefaultTaskDisplayArea()) {
// 向ActivityTaskManagerService获取 Launcher 的启动意图
homeIntent = mService.getHomeIntent();
// 向PackageManagerService通过意图解析到 ActivityInfo
aInfo = resolveHomeActivity(userId, homeIntent);
} else if (shouldPlaceSecondaryHomeOnDisplayArea(taskDisplayArea)) {
............
// Updates the home component of the intent.
homeIntent.setComponent(new ComponentName(aInfo.applicationInfo.packageName, aInfo.name));
homeIntent.setFlags(homeIntent.getFlags() | FLAG_ACTIVITY_NEW_TASK);
// Updates the extra information of the intent.
if (fromHomeKey) {
homeIntent.putExtra(WindowManagerPolicy.EXTRA_FROM_HOME_KEY, true);
mWindowManager.cancelRecentsAnimation(REORDER_KEEP_IN_PLACE, "startHomeActivity");
}
// Update the reason for ANR debugging to verify if the user activity is the one that
// actually launched.
final String myReason = reason + ":" + userId + ":" + UserHandle.getUserId(
aInfo.applicationInfo.uid) + ":" + taskDisplayArea.getDisplayId();
// 根据homeIntent、aInfo，调用 startHomeActivity 方法去启动和创建 Launcher
mService.getActivityStartController().startHomeActivity(homeIntent, aInfo, myReason,
taskDisplayArea);
return true;
}上面的resolveHomeActivity方法会优先判断开机向导的flag值，为1则启动桌面launcher，为0 启动开机向导业务。
上面的逻辑主要作用：
- 向ActivityTaskManagerService获取 Launcher 的启动意图；
- 向PackageManagerService通过意图解析到 ActivityInfo；
- 根据homeIntent、aInfo，通过拿到ActivityStartController对象去调用 startHomeActivity 方法去启动和创建 Launcher；
注意这里的getHomeIntent方法：
Intent getHomeIntent() {
Intent intent = new Intent(mTopAction, mTopData != null ? Ur
intent.setComponent(mTopComponent);
intent.addFlags(Intent.FLAG_DEBUG_TRIAGED_MISSING);
if (mFactoryTest != FactoryTest.FACTORY_TEST_LOW_LEVEL) {
intent.addCategory(Intent.CATEGORY_HOME);
}
return intent;
}重点我们看category，这里设置了category为Intent.CATEGORY_HOME的Intent，fallbackhome这个Activity也设置了这个category，系统首次启动进入的时候会进入这个fallbackhome作为一个过度Activity，如果用户解锁之后就不会再进入这个fallbackhome。
/frameworks/base/services/core/java/com/android/server/wm/ActivityStartController.java
void startHomeActivity(Intent intent, ActivityInfo aInfo, String reason,
TaskDisplayArea taskDisplayArea) {
..........
// 检查权限，操作堆栈等行为
mLastHomeActivityStartResult = obtainStarter(intent, "startHomeActivity: " + reason)
.setOutActivity(tmpOutRecord)
.setCallingUid(0)
.setActivityInfo(aInfo)
.setActivityOptions(options.toBundle())
.execute();
mLastHomeActivityStartRecord = tmpOutRecord[0];
if (rootHomeTask.mInResumeTopActivity) {
// If we are in resume section already, home activity will be initialized, but not
// resumed (to avoid recursive resume) and will stay that way until something pokes it
// again. We need to schedule another resume.
mSupervisor.scheduleResumeTopActivities();// 启动activity的下一步核心流程
}
}ActivityStart.execute() 方法主要检查intent权限，启动的栈，等行为，然后我们通过ActivityStackSupervisor调用scheduleResumeTopActivities启动Activity：
/frameworks/base/services/core/java/com/android/server/wm/ActivityStackSupervisor.java
final void scheduleResumeTopActivities() {
if (!mHandler.hasMessages(RESUME_TOP_ACTIVITY_MSG)) {
mHandler.sendEmptyMessage(RESUME_TOP_ACTIVITY_MSG);
}
}RESUME_TOP_ACTIVITY_MSG消息最终启动的是RootWindowContainer。
接下来的代码多了，这里简略一下：
RootWindowContainer#resumeFocusedStacksTopActivities-----> ActivityStack#resumeTopActivityUncheckedLocked----->
ActivityStack#resumeTopActivityInnerLocked----->
ActivityStackSupervisor#startSpecificActivity----->
ActivityTaskManagerService#startProcessAsync----->
ActivityManagerService#startProcessLocked----->
......省略一大截...................
这里 流程主要是通知zygote进程去fork出launcher进程，当然，如果launcher进程存在就不用再去fork了；
有了launcher进程之后通过LaunchActivityItem的execute() 方法，执行handleLaunchActivity 最终开始走 Activity的流程。home activity也就显示出来了。
这省略的一大截流程跟Activity的启动流程没啥区别，我的AMS的专栏后面会有Activity的详细启动流程。
4.3.2 开机广播流程
当开机动画执行完毕之后会调用到AMS里面的bootAnimationComplete方法，然后调用finishBooting去发送开机广播。下面我们来看看流程：
/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
@Override
public void bootAnimationComplete() {
final boolean callFinishBooting;
synchronized (this) {
callFinishBooting = mCallFinishBooting;
mBootAnimationComplete = true;
}
if (callFinishBooting) {
finishBooting();
}
}
final void finishBooting() {
..........
// Let the ART runtime in zygote and system_server know that the boot completed.
// 让zygote和system_server中的ART运行时知道系统启动完成。
ZYGOTE_PROCESS.bootCompleted();
VMRuntime.bootCompleted();
..........
// Tell anyone interested that we are done booting!
// 配置"sys.boot_completed"，"1"，表示启动完成
SystemProperties.set("sys.boot_completed", "1");
.........
// 发送开机广播
mUserController.sendBootCompleted(
new IIntentReceiver.Stub() {
@Override
public void performReceive(Intent intent, int resultCode,
String data, Bundle extras, boolean ordered,
boolean sticky, int sendingUser) {
synchronized (ActivityManagerService.this) {
mOomAdjuster.mCachedAppOptimizer.compactAllSystem();
requestPssAllProcsLocked(SystemClock.uptimeMillis(), true, false);
}
}
});
.............
}通过上面的代码我们可以看到通过mUserController.sendBootCompleted去执行发送开机广播的流程：
/frameworks/base/services/core/java/com/android/server/am/UserController.java
看看大致流程：
UserController#sendBootCompleted----------->
UserController#finishUserBoot----------->
UserController#maybeUnlockUser----------->
UserController#unlockUserCleared----------->
UserController#finishUserUnlocking----------->
通过handler发送消息 USER_UNLOCK_MSG 给到finishUserUnlocked去处理
UserController#finishUserUnlocked----------->
UserController#finishUserUnlockedCompleted----------->
private void finishUserUnlockedCompleted(UserState uss) {
...........
// 发送开机广播
final Intent bootIntent = new Intent(Intent.ACTION_BOOT_COMPLETED, null);
bootIntent.putExtra(Intent.EXTRA_USER_HANDLE, userId);
bootIntent.addFlags(Intent.FLAG_RECEIVER_NO_ABORT
| Intent.FLAG_RECEIVER_INCLUDE_BACKGROUND
| Intent.FLAG_RECEIVER_OFFLOAD);
// Widget broadcasts are outbound via FgThread, so to guarantee sequencing
// we also send the boot_completed broadcast from that thread.
final int callingUid = Binder.getCallingUid();
final int callingPid = Binder.getCallingPid();
FgThread.getHandler().post(() -> {
mInjector.broadcastIntent(bootIntent, null,
new IIntentReceiver.Stub() {
@Override
public void performReceive(Intent intent, int resultCode, String data,
Bundle extras, boolean ordered, boolean sticky, int sendingUser)
throws RemoteException {
Slog.i(UserController.TAG, "Finished processing BOOT_COMPLETED for u"
+ userId);
mBootCompleted = true;
}
}, 0, null, null,
new String[]{android.Manifest.permission.RECEIVE_BOOT_COMPLETED},
AppOpsManager.OP_NONE, null, true, false, MY_PID, SYSTEM_UID,
callingUid, callingPid, userId);
});
............
}开机广播发送就到此结束。
5. 总结
- 调用AMS的构造方法和start方法，对AMS必要的内容进行初始化。
- 将AMS注册到ServiceManager中，同时对system进程也创建了一个ProcessRecord对象，并设置Context的appliation为framework-res的application对象, 由于AMS是Java世界的进程管理及调度中心，要做到对Java进程一视同仁，尽管system贵为系统进程，此时也不得不将其并入AMS的管理范围内。
- 调用systemReady方法做系统启动完毕前最后一些扫尾工作,该方法调用完毕后，Home Activity将呈现在用户面前。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
