在前面的Zygote系列文章中已经讲了SystemServer进程的创建以及zygote如何调用到com.android.server.SystemServer.main方法的。
SystemServer是Zygote fork的第一个Java进程， 这个进程非常重要，因为有很多核心的系统服务，如大名鼎鼎的WindowManager、ActivityManager等，它们都是运行在SystemServer的进程里，还有很多“Binder-x”的线程，它们是各个Service为了响应应用程序远程调用请求而创建的。除此之外，还有很多内部的线程，比如 ”UI thread”、“InputReader”、“InputDispatch”等。
public static void main(String[] args) {
new SystemServer().run();
}
main方法调用核心在run中，它的代码非常多，我将SystemServer run方法的初始化流程分为4部分分析：
- 初始化必要的SystemServer环境参数，比如系统时间、默认时区、语言、load一些Library等等；
- 初始化Looper，我们在主线程中使用到的looper就是在SystemServer中进行初始化的；
- 初始化Context，只有初始化一个Context才能进行启动Service等操作；
- 初始化SystemServiceManager，用来管理启动service，它也是最重要的部分；
环境参数设置
//从属性中读取system_server进程的一些信息
// Record the process start information in sys props.
SystemProperties.set(SYSPROP_START_COUNT, String.valueOf(mStartCount));
SystemProperties.set(SYSPROP_START_ELAPSED, String.valueOf(mRuntimeStartElapsedTime));
SystemProperties.set(SYSPROP_START_UPTIME, String.valueOf(mRuntimeStartUptime));
//如果一个设备的时钟是在1970年之前(0年之前)，
//那么很多api 都会因为处理负数而崩溃，尤其是java.io.File#setLastModified
//我把把时间设置为1970
// If a device's clock is before 1970 (before 0), a lot of
// APIs crash dealing with negative numbers, notably
// java.io.File#setLastModified, so instead we fake it and
// hope that time from cell towers or NTP fixes it shortly.
if (System.currentTimeMillis() < EARLIEST_SUPPORTED_TIME) {
Slog.w(TAG, "System clock is before 1970; setting to 1970.");
SystemClock.setCurrentTimeMillis(EARLIEST_SUPPORTED_TIME);
}
//如果时区不存在，设置时区为GMT
String timezoneProperty = SystemProperties.get("persist.sys.timezone");
if (timezoneProperty == null || timezoneProperty.isEmpty()) {
Slog.w(TAG, "Timezone not set; setting to GMT.");
SystemProperties.set("persist.sys.timezone", "GMT");
}
//变更虚拟机的库文件，对于Android 10.0默认采用的是libart.so
// In case the runtime switched since last boot (such as when
// the old runtime was removed in an OTA), set the system
// property so that it is in sync. We can | xq oqi't do this in
// libnativehelper's JniInvocation::Init code where we already
// had to fallback to a different runtime because it is
// running as root and we need to be the system user to set
// the property. http://b/11463182
SystemProperties.set("persist.sys.dalvik.vm.lib.2", VMRuntime.getRuntime().vmLibrary());
// Mmmmmm... more memory!
//清除vm内存增长上限，由于启动过程需要较多的虚拟机内存空间
VMRuntime.getRuntime().clearGrowthLimit();
//系统服务器必须一直运行，所以它需要尽可能高效地使用内存
//设置内存的可能有效使用率为0.8
VMRuntime.getRuntime().setTargetHeapUtilization(0.8f);
//一些设备依赖于运行时指纹生成，所以在进一步启动之前，请确保我们已经定义了它。
Build.ensureFingerprintProperty();
//访问环境变量前，需要明确地指定用户
//在system_server中，任何传入的包都应该被解除，以避免抛出BadParcelableException。
BaseBundle.setShouldDefuse(true);
//在system_server中，当打包异常时，信息需要包含堆栈跟踪
Parcel.setStackTraceParceling(true);
//确保当前系统进程的binder调用，总是运行在前台优先级
BinderInternal.disableBackgroundScheduling(true);
//设置system_server中binder线程的最大数量,最大值为31
BinderInternal.setMaxThreads(sMaxBinderThreads);
//准备主线程lopper，即在当前线程运行
android.os.Process.setThreadPriority(android.os.Process.THREAD_PRIORITY_FOREGROUND);
android.os.Process.setCanSelfBackground(false);
Looper.prepareMainLooper();
Looper.getMainLooper().setSlowLogThresholdMs(SLOW_DISPATCH_THRESHOLD_MS, SLOW_DELIVERY_THRESHOLD_MS);
//加载android_servers.so库，初始化nativeservice
System.loadLibrary("android_servers");
// Debug builds - allow heap profiling.
//如果是Debug版本，允许堆内存分析
if (Build.IS_DEBUGGABLE) {
initZygoteChildHeapProfiling();
}
//检测上次关机过程是否失败，这个调用可能不会返回
performPendingShutdown();
Looper
//准备主线程lopper，即在当前线程运行
android.os.Process.setThreadPriority(android.os.Process.THREAD_PRIORITY_FOREGROUND);
android.os.Process.setCanSelfBackground(false);
Looper.prepareMainLooper();
Looper.getMainLooper().setSlowLogThresholdMs(SLOW_DISPATCH_THRESHOLD_MS, SLOW_DELIVERY_THRESHOLD_MS);
//Looper进入循环
// Loop forever.
Looper.loop();
关于Looper的内容在我的"Android10 Framework—Handler消息系统"系列文章中也详细分析过了，大家可以去看看。
初始化Context
// Initialize the system context.
createSystemContext();
private void createSystemContext() {
ActivityThread activityThread = ActivityThread.systemMain();
mSystemContext = activityThread.getSystemContext();
mSystemContext.setTheme(DEFAULT_SYSTEM_THEME);
final Context systemUiContext = activityThread.getSystemUiContext();
systemUiContext.setTheme(DEFAULT_SYSTEM_THEME);
}
上面的代码通过调用ActivityThread.systemMain创建ActivityThread，然后从getSystemContext获取Context对象,可见Context是在systemMain中创建的。
public static ActivityThread systemMain() {
// The system process on low-memory devices do not get to use hardware
// accelerated drawing, since this can add too much overhead to the
// process.
if (!ActivityManager.isHighEndGfx()) {
ThreadedRenderer.disable(true);
} else {
ThreadedRenderer.enableForegroundTrimming();
}
ActivityThread thread = new ActivityThread();
thread.attach(true, 0);
return thread;
}
ActivityThread() {
mResourcesManager = ResourcesManager.getInstance();
}
这里直接new了ActivityThread，构造函数中获取到ResourcesManager，然后调用attch方法
//调用
thread.attach(true, 0);
//实现
private void attach(boolean system, long startSeq) {
sCurrentActivityThread = this;
mSystemThread = system;
if (!system) {
...省略代码
} else {
// 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 {
mInstrumentation = new Instrumentation();
mInstrumentation.basicInit(this);
ContextImpl context = ContextImpl.createAppContext(
this, getSystemContext().mPackageInfo);
mInitialApplication = context.mPackageInfo.makeApplication(true, null);
mInitialApplication.onCreate();
} catch (Exception e) {
throw new RuntimeException(
"Unable to instantiate Application():" + e.toString(), e);
}
}
...省略代码
}
system参数为true，这里执行ContextImpl.createAppContext创建ContextImpl对象，但是创建ContextImpl需要传入LoadedApk，它描述了一个APK的信息，这里就会有个疑问：为什么SystemServer进程与APK有什么关系？这需要从它的功能上分析：
SystemServer除了会创建WindowManager、ActivityManager等进程外，它还会负责系统对话框等UI功能显示；SystemServer如果只是一个常规的进程，那它是无法拥有UI功能功能的，因此它内部也需要创建一个类似APP应用程序的环境，这样才能具备UI功能。而创建APP应用程序的环境，通常就需要加载APK，因为它里面具备图片、字体、文本等资源。
public ContextImpl getSystemContext() {
synchronized (this) {
if (mSystemContext == null) {
mSystemContext = ContextImpl.createSystemContext(this);
}
return mSystemContext;
}
}
static ContextImpl createSystemContext(ActivityThread mainThread) {
LoadedApk packageInfo = new LoadedApk(mainThread);
ContextImpl context = new ContextImpl(null, mainThread, packageInfo, null, null, null, 0,
null, null);
context.setResources(packageInfo.getResources());
context.mResources.updateConfiguration(context.mResourcesManager.getConfiguration(),
context.mResourcesManager.getDisplayMetrics());
return context;
}
这里调用new LoadedApk创建LoadedApk对象
LoadedApk(ActivityThread activityThread) {
mActivityThread = activityThread;
mApplicationInfo = new ApplicationInfo();
mApplicationInfo.packageName = "android";
mPackageName = "android";
...省略代码
}
其中ApplicationInfo的packageName设置为android，它其实对应系统的framework-res.apk，framework-res.apk包含了系统UI资源，这个apk文件在系统如下路径：
这个apk对应的源码路径为frameworks/base/core/res，通过其AndroidManifest.xml可以看到包名为android
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="android" coreApp="true" android:sharedUserId="android.uid.system"
android:sharedUserLabel="@string/android_system_label">
</manifest>
就这样SystemServer的应用程序环境准备好了。
启动Service
接下来开始启动系统服务了
try {
// Create the system service manager.
mSystemServiceManager = new SystemServiceManager(mSystemContext);
mSystemServiceManager.setStartInfo(mRuntimeRestart,
mRuntimeStartElapsedTime, mRuntimeStartUptime);
LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
// Prepare the thread pool for init tasks that can be parallelized
SystemServerInitThreadPool.get();
} finally {
traceEnd(); // InitBeforeStartServices
}
// Start services.
try {
traceBeginAndSlog("StartServices");
startBootstrapServices();
startCoreServices();
startOtherServices();
SystemServerInitThreadPool.shutdown();
} catch (Throwable ex) {
Slog.e("System", "******************************************");
Slog.e("System", "************ Failure starting system services", ex);
throw ex;
} finally {
traceEnd();
}
SystemServiceManager
public final class SystemServiceManager implements Dumpable {
......
private final Context mContext;
// Services that should receive lifecycle events.
private final ArrayList<SystemService> mServices = new ArrayList<SystemService>();
......
SystemServiceManager(Context context) {
mContext = context;
}
// 启动 Service，入参为待启动的服务类名，返回服务的实例
public SystemService startService(String className) {
// 内部通过反射调用获取到待启动服务的类
final Class<SystemService> serviceClass = loadClassFromLoader(className,
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);
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) {
mServices.add(service); // 将启动的服务注册到已启动的服务列表中
long time = SystemClock.elapsedRealtime();
try {
service.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");
}
......
}
SystemServiceManager 是用来管理系统服务 (SystemService) 的创建、启动和其他生命周期事件的。其内部的 mServices 用来存储启动的 Service 的列表。
服务启动类
每个系统服务的启动类都必须实现SystemService中相关生命周期方法，这样做的目的是方便SystemServiceManager进行统一管理
public abstract class SystemService {
public abstract void onStart();
public void onBootPhase(int phase) {}
/**
* Publish the service so it is accessible to other services and apps.
*
* @param name the name of the new service
* @param service the service object
*/
protected final void publishBinderService(String name, IBinder service) {
publishBinderService(name, service, false);
}
/**
* Publish the service so it is accessible to other services and apps.
*
* @param name the name of the new service
* @param service the service object
* @param allowIsolated set to true to allow isolated sandboxed processes
* to access this service
*/
protected final void publishBinderService(String name, IBinder service,
boolean allowIsolated) {
publishBinderService(name, service, allowIsolated, DUMP_FLAG_PRIORITY_DEFAULT);
}
/**
* Publish the service so it is accessible to other services and apps.
*
* @param name the name of the new service
* @param service the service object
* @param allowIsolated set to true to allow isolated sandboxed processes
* to access this service
* @param dumpPriority supported dump priority levels as a bitmask
*/
protected final void publishBinderService(String name, IBinder service,
boolean allowIsolated, int dumpPriority) {
ServiceManager.addService(name, service, allowIsolated, dumpPriority);
}
/**
* Get a binder service by its name.
*/
protected final IBinder getBinderService(String name) {
return ServiceManager.getService(name);
}
/**
* Publish the service so it is only accessible to the system process.
*/
protected final <T> void publishLocalService(Class<T> type, T service) {
LocalServices.addService(type, service);
}
/**
* Get a local service by interface.
*/
protected final <T> T getLocalService(Class<T> type) {
return LocalServices.getService(type);
}
private SystemServiceManager getManager() {
return LocalServices.getService(SystemServiceManager.class);
}
}
其中onStart表示服务正真的启动实现，SystemServiceManager启动服务时会调用服务启动类的onStart去触发服务启动，参考如下调用示例，进行分析：
Installer installer = mSystemServiceManager.startService(Installer.class);
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 (InstantiationException ex) {
throw new RuntimeException("Failed to create service " + name
+ ": service could not be instantiated", ex);
} catch (IllegalAccessException ex) {
throw new RuntimeException("Failed to create service " + name
+ ": service must have a public constructor with a Context argument", ex);
} catch (NoSuchMethodException ex) {
throw new RuntimeException("Failed to create service " + name
+ ": service must have a public constructor with a Context argument", ex);
} catch (InvocationTargetException ex) {
throw new RuntimeException("Failed to create service " + name
+ ": service constructor threw an exception", ex);
}
startService(service);
return service;
} finally {
Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
}
}
startService中通过反射找到Installer.class的实现类，然后继续调用重载方法startService
public void startService(@NonNull final SystemService service) {
// Register it.
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");
}
重载方法最终调用实现类的onStart方法进行启动。
启动服务
服务启动分为如下三类
startBootstrapServices用于启动系统Boot级服务，代码比较长，方法中按序启动了很多的引导服务，有：Installer、ActivityTaskManagerService、ActivityManagerService、PowerManagerService、LightsService、DisplayManagerService、PackageManagerService、UserManagerService、OverlayManagerService 和 SensorService 等服务。
private void startBootstrapServices(@NonNull TimingsTraceAndSlog t) {
t.traceBegin("startBootstrapServices");
// 启动 Watchdog 监控启动引导服务时是否会死锁
t.traceBegin("StartWatchdog");
final Watchdog watchdog = Watchdog.getInstance();
watchdog.start();
t.traceEnd();
...... // 平台配套服务由 AMS、PMS 以及将来可能的其他服务使用
t.traceBegin("PlatformCompat");
PlatformCompat platformCompat = new PlatformCompat(mSystemContext);
ServiceManager.addService(Context.PLATFORM_COMPAT_SERVICE, platformCompat);
ServiceManager.addService(Context.PLATFORM_COMPAT_NATIVE_SERVICE,
new PlatformCompatNative(platformCompat));
AppCompatCallbacks.install(new long[0]);
t.traceEnd();
// FileIntegrityService 响应来自应用程序和系统的请求。需在资源准备好之后，在应用程序(或系统中的第一个客户)运行之前运行
t.traceBegin("StartFileIntegrityService");
mSystemServiceManager.startService(FileIntegrityService.class);
t.traceEnd();
t.traceBegin("StartInstaller"); // 阻塞等待 Installd 服务启动完成且与其建立 socket 通道
Installer installer = mSystemServiceManager.startService(Installer.class);
t.traceEnd();
// 在某些情况下，在启动应用程序后，需要访问设备标识符，因此要在 activity manager 之前注册
t.traceBegin("DeviceIdentifiersPolicyService");
mSystemServiceManager.startService(DeviceIdentifiersPolicyService.class);
t.traceEnd();
t.traceBegin("UriGrantsManagerService"); // 启动 Uri 授权管理服务
mSystemServiceManager.startService(UriGrantsManagerService.Lifecycle.class);
t.traceEnd();
t.traceBegin("StartPowerStatsService"); // 启动 PowerStatsService 服务，用于功率统计
mSystemServiceManager.startService(PowerStatsService.class);
t.traceEnd();
t.traceBegin("StartIStatsService");
startIStatsService(); // 阻塞调用，启动 IStats 服务
t.traceEnd();
// 在 ActivityManager 之前启动 MemtrackProxyService 服务，以免调用 Memtrack::getMemory() 方法失败
t.traceBegin("MemtrackProxyService");
startMemtrackProxyService();
t.traceEnd();
// Activity manager 负责显示
t.traceBegin("StartActivityManager"); // 启动 ActivityTaskManagerService 服务
// ATMS 是 Android 10 中新增的，本来都是 ActivityManagerService 来管理
// Google考虑到AMS职责太多、代码太庞大，所以单独拆出来ATMS用于管理Activity及其容器类如Task、Stack、Display等，分担部分职责
ActivityTaskManagerService atm = mSystemServiceManager.startService(
ActivityTaskManagerService.Lifecycle.class).getService();
mActivityManagerService = ActivityManagerService.Lifecycle.startService(
mSystemServiceManager, atm); // 启动 ActivityManagerService 服务
mActivityManagerService.setSystemServiceManager(mSystemServiceManager); // AMS 设置 SystemServiceManager
mActivityManagerService.setInstaller(installer); // AMS 设置 Installer
mWindowManagerGlobalLock = atm.getGlobalLock(); // 获取 ATMS 的成员 mGlobalLock 赋值给 mWindowManagerGlobalLock
t.traceEnd();
// DataLoaderManagerService 数据加载器管理服务需要在包管理服务之前启动
t.traceBegin("StartDataLoaderManagerService");
mDataLoaderManagerService = mSystemServiceManager.startService(
DataLoaderManagerService.class);
t.traceEnd();
// IncrementalService 服务需要在包管理服务之前启动
t.traceBegin("StartIncrementalService");
mIncrementalServiceHandle = startIncrementalService();
t.traceEnd();
// 因有其他业务需要用到，因此 PowerManagerService 电源管理服务要尽早启动
t.traceBegin("StartPowerManager");
mPowerManagerService = mSystemServiceManager.startService(PowerManagerService.class);
t.traceEnd();
t.traceBegin("StartThermalManager");
mSystemServiceManager.startService(ThermalManagerService.class);
t.traceEnd();
t.traceBegin("StartHintManager");
mSystemServiceManager.startService(HintManagerService.class);
t.traceEnd();
// 电源管理服务已经启动，Activity Manager 初始化电源管理特性
t.traceBegin("InitPowerManagement");
mActivityManagerService.initPowerManagement();
t.traceEnd();
// 启动恢复系统，以防需要重启
t.traceBegin("StartRecoverySystemService");
mSystemServiceManager.startService(RecoverySystemService.Lifecycle.class);
t.traceEnd();
// 已经启动并运行了操作系统的基本要素，但须注意，有可能会陷入运行时重启循环
RescueParty.registerHealthObserver(mSystemContext);
PackageWatchdog.getInstance(mSystemContext).noteBoot();
t.traceBegin("StartLightsService"); // 启动 LightsService 服务，管理 LED 和显示
mSystemServiceManager.startService(LightsService.class);
t.traceEnd();
t.traceBegin("StartSidekickService");
if (SystemProperties.getBoolean("config.enable_sidekick_graphics", false)) {
mSystemServiceManager.startService(WEAR_SIDEKICK_SERVICE_CLASS);
}
t.traceEnd();
// 启动 DisplayManagerService 服务，需在包管理服务之前启动，用于提供显示
t.traceBegin("StartDisplayManager");
mDisplayManagerService = mSystemServiceManager.startService(DisplayManagerService.class);
t.traceEnd();
// 在初始化包管理服务之前，我们需要默认的显示
t.traceBegin("WaitForDisplay");
mSystemServiceManager.startBootPhase(t, SystemService.PHASE_WAIT_FOR_DEFAULT_DISPLAY);
t.traceEnd();
......
t.traceBegin("StartDomainVerificationService");
DomainVerificationService domainVerificationService = new DomainVerificationService(
mSystemContext, SystemConfig.getInstance(), platformCompat);
mSystemServiceManager.startService(domainVerificationService);
t.traceEnd();
t.traceBegin("StartPackageManagerService");
try { // 启动包管理服务 PackageManagerService
Watchdog.getInstance().pauseWatchingCurrentThread("packagemanagermain");
mPackageManagerService = PackageManagerService.main(mSystemContext, installer,
domainVerificationService, mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF,
mOnlyCore);
} finally {
Watchdog.getInstance().resumeWatchingCurrentThread("packagemanagermain");
}
// 包管理服务已经启动，注册 dex load reporter 捕获系统服务加载的任何 dex 文件，这些 dex 文件将被后台dexoptservice优化
SystemServerDexLoadReporter.configureSystemServerDexReporter(mPackageManagerService);
mFirstBoot = mPackageManagerService.isFirstBoot(); // 是否第一次启动
mPackageManager = mSystemContext.getPackageManager();
t.traceEnd();
if (!mRuntimeRestart && !isFirstBootOrUpgrade()) {
FrameworkStatsLog.write(FrameworkStatsLog.BOOT_TIME_EVENT_ELAPSED_TIME_REPORTED,
FrameworkStatsLog
.BOOT_TIME_EVENT_ELAPSED_TIME__EVENT__PACKAGE_MANAGER_INIT_READY,
SystemClock.elapsedRealtime());
}
......
t.traceBegin("StartUserManagerService"); // 启动 UserManagerService 服务
mSystemServiceManager.startService(UserManagerService.LifeCycle.class);
t.traceEnd();
t.traceBegin("InitAttributerCache");
AttributeCache.init(mSystemContext); // 初始化用于缓存从包中获取的属性缓存
t.traceEnd();
// 为系统进程设置 Application 实例并开始
t.traceBegin("SetSystemProcess");
mActivityManagerService.setSystemProcess();
t.traceEnd();
// PackageReceiver 依赖于 Activity Service 服务来注册
platformCompat.registerPackageReceiver(mSystemContext);
// 使用 ActivityManager 实例完成 Watchdog 设置，并侦听重新启动
// 只有在 ActivityManagerService 作为系统进程且正确启动后才能执行此操作
t.traceBegin("InitWatchdog");
watchdog.init(mSystemContext, mActivityManagerService);
t.traceEnd();
// DisplayManagerService 需要设置与显示调度相关的策略，因为setSystemProcess()会因为setProcessGroup而覆盖策略
mDisplayManagerService.setupSchedulerPolicies();
// 启动 OverlayManagerService 服务，用于管理叠加包
t.traceBegin("StartOverlayManagerService");
mSystemServiceManager.startService(new OverlayManagerService(mSystemContext));
t.traceEnd();
// 启动 SensorPrivacyService 服务，传感器有关如重力加速、光线等
t.traceBegin("StartSensorPrivacyService");
mSystemServiceManager.startService(new SensorPrivacyService(mSystemContext));
t.traceEnd();
if (SystemProperties.getInt("persist.sys.displayinset.top", 0) > 0) {
// 更新 DisplayManagerService 服务
mActivityManagerService.updateSystemUiContext();
LocalServices.getService(DisplayManagerInternal.class).onOverlayChanged();
}
// 启动 SensorService 传感器服务，其需要访问包管理服务、应用ops服务和权限服务，因此我们在它们之后启动它
t.traceBegin("StartSensorService");
mSystemServiceManager.startService(SensorService.class);
t.traceEnd();
t.traceEnd(); // startBootstrapServices
}
startCoreServices用于启动一些在启动引导服务过程中没有相互依赖的基本服务，如：SystemConfigService、BatteryService、BinderCallsStatsService、BugreportManagerService 等服务，这些服务很少或基本不依赖于别的服务。
private void startCoreServices(@NonNull TimingsTraceAndSlog t) {
t.traceBegin("startCoreServices");
// 启动 SystemConfigService 系统配置服务
t.traceBegin("StartSystemConfigService");
mSystemServiceManager.startService(SystemConfigService.class);
t.traceEnd();
t.traceBegin("StartBatteryService");
// 启动 BatteryService 电池服务，用于统计电池电量，需结合 LightService
mSystemServiceManager.startService(BatteryService.class);
t.traceEnd();
// 启动 UsageStatsService 服务，用于统计应用使用情况
t.traceBegin("StartUsageService");
mSystemServiceManager.startService(UsageStatsService.class);
mActivityManagerService.setUsageStatsManager(
LocalServices.getService(UsageStatsManagerInternal.class));
t.traceEnd();
// 启动 WebViewUpdateService 服务，用于观察可更新的 WebView 是否处于就绪状态，并监视更新安装
if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_WEBVIEW)) {
t.traceBegin("StartWebViewUpdateService");
mWebViewUpdateService = mSystemServiceManager.startService(WebViewUpdateService.class);
t.traceEnd();
}
// 启动 CachedDeviceStateService 服务，用于追踪和缓存设备状态
t.traceBegin("StartCachedDeviceStateService");
mSystemServiceManager.startService(CachedDeviceStateService.class);
t.traceEnd();
// 启动 BinderCallsStatsService 服务，用于追踪在 binder 调用中花费的 cpu 时间
t.traceBegin("StartBinderCallsStatsService");
mSystemServiceManager.startService(BinderCallsStatsService.LifeCycle.class);
t.traceEnd();
// 启动 LooperStatsService 服务，用于追踪在处理程序中处理消息所花费的时间
t.traceBegin("StartLooperStatsService");
mSystemServiceManager.startService(LooperStatsService.Lifecycle.class);
t.traceEnd();
// 启动 RollbackManagerService 服务，用于管理 apk 安装包的回滚
t.traceBegin("StartRollbackManagerService");
mSystemServiceManager.startService(ROLLBACK_MANAGER_SERVICE_CLASS);
t.traceEnd();
// 启动 NativeTombstoneManagerService 服务，用于追踪 native tombstones
t.traceBegin("StartNativeTombstoneManagerService");
mSystemServiceManager.startService(NativeTombstoneManagerService.class);
t.traceEnd();
// 启动 BugreportManagerService 服务，用于捕获并报告 bug
t.traceBegin("StartBugreportManagerService");
mSystemServiceManager.startService(BugreportManagerService.class);
t.traceEnd();
// 启动 GPU 和 GPU 驱动服务，用于为 GPU 和 GPU 驱动程序提供服务
t.traceBegin("GpuService");
mSystemServiceManager.startService(GpuService.class);
t.traceEnd();
t.traceEnd(); // startCoreServices
}
startOtherServices方法代码太多，主要是启动一些非紧要和不需要立即启动的服务，如：CameraService、AlarmManagerService、InputManagerService、WindowManagerService、…、AndioServcie 等，然后准备好这些启动过的服务，等待后续客户端的调用。
private void startOtherServices(@NonNull TimingsTraceAndSlog t) {
t.traceBegin("startOtherServices");
final Context context = mSystemContext;
WindowManagerService wm = null;
......
InputManagerService inputManager = null;
......
try {
......
t.traceBegin("StartKeyAttestationApplicationIdProviderService");
ServiceManager.addService("sec_key_att_app_id_provider",
new KeyAttestationApplicationIdProviderService(context));
......
mContentResolver = context.getContentResolver(); // 获取 ContentResolver 实例对象
...... // 安装 ContentProvider
mActivityManagerService.getContentProviderHelper().installSystemProviders();
......
t.traceBegin("StartInputManagerService"); // 启动 InputManagerService 服务
inputManager = new InputManagerService(context);
......
t.traceBegin("StartWindowManagerService"); // 启动 WindowManagerService 服务
mSystemServiceManager.startBootPhase(t, SystemService.PHASE_WAIT_FOR_SENSOR_SERVICE);
wm = WindowManagerService.main(context, inputManager, !mFirstBoot, mOnlyCore,
new PhoneWindowManager(), mActivityManagerService.mActivityTaskManager);
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);
t.traceBegin("SetWindowManagerService"); // ActivityManagerService 设置 WindowManagerService
mActivityManagerService.setWindowManager(wm);
......
} catch (Throwable e) {
......// 日志输出并抛出异常
}
......
t.traceBegin("MakeDisplayReady");
try {
wm.displayReady();
} catch (Throwable e) {
reportWtf("making display ready", e);
}
t.traceEnd();
......
t.traceBegin("MakeInputManagerServiceReady");
try {
if (inputManagerF != null) {
inputManagerF.systemRunning();
}
} catch (Throwable e) {
reportWtf("Notifying InputManagerService running", e);
}
......
// 准备好上面启动过的服务，如 WMS、PMS、DMS等
t.traceBegin("MakeWindowManagerServiceReady");
try {
wm.systemReady();
} catch (Throwable e) {
reportWtf("making Window Manager Service ready", e);
}
mActivityManagerService.systemReady(() -> {
Slog.i(TAG, "Making services ready");
}, t);
......
t.traceEnd(); // startOtherServices
}
startOtherServices最后会调用到 mActivityManagerService.systemReady() 方法：
public void systemReady(final Runnable goingCallback, TimingsTraceLog traceLog) {
traceLog.traceBegin("PhaseActivityManagerReady");
synchronized(this) {
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();
}
return;
}
mLocalDeviceIdleController
= LocalServices.getService(DeviceIdleController.LocalService.class);
mActivityTaskManager.onSystemReady();
// Make sure we have the current profile info, since it is needed for security checks.
mUserController.onSystemReady();
mAppOpsService.systemReady();
mSystemReady = true;
}
...
mAtmInternal.resumeTopActivities(false /* scheduleIdle */);
if (bootingSystemUser) {
mUserController.sendUserSwitchBroadcasts(-1, currentUserId);
}
...
}
goingCallback.run调用的是传入的回调
private void startOtherServices() {
mActivityManagerService.systemReady(() -> {
...
startSystemUi(context, windowManagerF);
...
})
}
在回调中调用startSystemUi，它包含基本的StatusBar、VolumeBar、NavigationBar等内容；
private static void startSystemUi(Context context, WindowManagerService windowManager) {
Intent intent = new Intent();
intent.setComponent(new ComponentName("com.android.systemui",
"com.android.systemui.SystemUIService"));
intent.addFlags(Intent.FLAG_DEBUG_TRIAGED_MISSING);
//Slog.d(TAG, "Starting service: " + intent);
context.startServiceAsUser(intent, UserHandle.SYSTEM);
windowManager.onSystemUiStarted();
}
再回到systemReady函数，后面接着就会调用到 startHomeOnAllDisplays 方法，来启动 Launcher。
SystemServer启动的服务及其作用
下面简单的罗列下这些在 Android 系统中常见的服务及其作用:
- 引导服务
- Installer ：系统安装 APK 时的一个服务类，启动完成 Installer 服务之后才能启动其他的系统服务
- ActivityManagerService ：负责四大组件的启动、切换、调度
- PowerManagerService ：计算系统中与 Power 相关的计算，然后决策系统应该如何反应
- LightsService ：管理和显示背光 LED
- DisplayManagerService ：用来管理所有显示设备
- UserManagerService ：多用户模式管理
- SensorService ：为系统提供各种感应器服务
- PackageManagerService ：对 APK 进行安装、解析、删除、卸载等操作
- 核心服务
- DropBoxManagerService：用于生成和管理系统运行时的一些日志文件
- BatteryService：管理电池相关的服务
- UsageStatsService：收集用户使用每一个 App 的频率、使用时长
- WebViewUpdateService：WebView 更新服务
- 其他服务
- CameraService：摄像头相关服务
- AlarmManagerService：全局定时器管理服务
- InputManagerService：管理输入事件
- WindowManagerService：窗口管理服务
- VrManagerService：VR模式管理服务
- BluetoothService：蓝牙管理服务
- LocationManagerService：定位管理服务，GPS、定位等
- AndioServcie：音频相关管理服务
- LockSettingsService：屏幕锁定服务，管理每个用户的相关锁屏信息
- DeviceIdleController：Doze模式的主要驱动
- DevicePolicyManagerService：提供一些系统级别的设置及属性
- StatusBarManagerService：状态栏管理服务
- ClipboardService：系统剪切板服务
- NetworkManagementService：网络管理服务
- TextServicesManagerService：文本服务，例如文本检查等
- NetworkScoreService：网络评分服务
- NetworkStatsService：网络状态服务
- NetworkPolicyManagerService：网络策略服务
- WifiP2pService：Wifi Direct服务
- WifiService：Wifi服务
- WifiScanningService：Wifi扫描服务
- RttService：Wifi相关
- EthernetService：以太网服务
- ConnectivityService：网络连接管理服务
- NsdService：网络发现服务
- NotificationManagerService：通知栏管理服务
- DeviceStorageMonitorService：磁盘空间状态检测服务
- CountryDetectorService：检测用户国家
- SearchManagerService：搜索管理服务
- DropBoxManagerService：用于系统运行时日志的存储于管理
- WallpaperManagerService：壁纸管理服务
- AudioService：AudioFlinger的上层管理封装，主要是音量、音效、声道及铃声等的管理
- DockObserver：如果系统有个座子，当手机装上或拔出这个座子的话，就得靠他来管理了
- WiredAccessoryManager：监视手机和底座上的耳机
- UsbService：USB服务
- SerialService：串口服务
- TwilightService：指出用户当前所在位置是否为晚上，被 UiModeManager 等用来调整夜间模式
- BackupManagerService：备份服务
- AppWidgetService：提供Widget的管理和相关服务
- VoiceInteractionManagerService：语音交互管理服务
- DiskStatsService：磁盘统计服务，供dumpsys使用
- SamplingProfilerService：用于耗时统计等
- NetworkTimeUpdateService：监视网络时间，当网络时间变化时更新本地时间。
- CertBlacklister：提供一种机制更新SSL certificate blacklist
- DreamManagerService：屏幕保护
- PrintManagerService：打印服务
- HdmiControlService：HDMI控制服务
- FingerprintService：指纹服务
参考
blog.csdn.net/u010347226/… www.cnblogs.com/bingxinshuo… blog.csdn.net/fengluoye20…
