Android SystemServer进程U源码解析

诸神黄昏EX

已于 2024-04-26 20:53:16 修改

阅读量685

点赞数 6

文章标签： android

于 2024-03-15 18:32:05 首次发布

本文链接：https://blog.csdn.net/qq_27672101/article/details/136746558

版权

SystemServer进程在android系统中占了举足轻重的地位，系统的所有服务和SystemUI都是由它启动。

一、SystemServer进程主函数流程

1、主函数三部曲

//frameworks/base/services/java/com/android/server/SystemServer.java    
    /** * The main entry point from zygote. */
    public static void main(String[] args) {
        new SystemServer().run();
    }

SystemServer的入口函数同样是main，调用顺序先是构造函数，再是run，构造函数没有什么重点地方后文dump详细介绍，主要流程主要还是run方法。run里面哦流程其实还是遵循普遍的三部曲：初始化上下文->启动服务->进入loop循环

1）初始化上下文

//frameworks/base/services/java/com/android/server/SystemServer.java    
    private void run() {
        TimingsTraceAndSlog t = new TimingsTraceAndSlog();
        try {
            t.traceBegin("InitBeforeStartServices");
        //.....一些属性的初始化....
            // The system server should never make non-oneway calls
            Binder.setWarnOnBlocking(true);
            // The system server should always load safe labels
            PackageItemInfo.forceSafeLabels();
            // Default to FULL within the system server.
            SQLiteGlobal.sDefaultSyncMode = SQLiteGlobal.SYNC_MODE_FULL;
            // Deactivate SQLiteCompatibilityWalFlags until settings provider is initialized
            SQLiteCompatibilityWalFlags.init(null);
            // Here we go! 
            Slog.i(TAG, "Entered the Android system server!");
            final long uptimeMillis = SystemClock.elapsedRealtime(); //记录开始启动的时间错，调试系统启动时间的时候需要关注
            // Mmmmmm... more memory!
            VMRuntime.getRuntime().clearGrowthLimit();
            // Some devices rely on runtime fingerprint generation, so make sure we've defined it before booting further.
            Build.ensureFingerprintProperty();
            // Within the system server, it is an error to access Environment paths without explicitly specifying a user.
            Environment.setUserRequired(true);
            // Within the system server, any incoming Bundles should be defused to avoid throwing BadParcelableException.
            BaseBundle.setShouldDefuse(true);
            // Within the system server, when parceling exceptions, include the stack trace
            Parcel.setStackTraceParceling(true);
            // Ensure binder calls into the system always run at foreground priority.
            BinderInternal.disableBackgroundScheduling(true);
            // Increase the number of binder threads in system_server
            BinderInternal.setMaxThreads(sMaxBinderThreads);
            // Prepare the main looper thread (this thread).              
        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);
            SystemServiceRegistry.sEnableServiceNotFoundWtf = true;
            // Initialize native services.
            System.loadLibrary("android_servers");
            // Allow heap / perf profiling.
            initZygoteChildHeapProfiling();
            // Check whether we failed to shut down last time we tried. This call may not return.
            performPendingShutdown();
            // Initialize the system context.
            createSystemContext();
            // Call per-process mainline module initialization.
            ActivityThread.initializeMainlineModules();
       } finally {
            t.traceEnd();  // InitBeforeStartServices
        }

2）启动系统所有服务

//frameworks/base/services/java/com/android/server/SystemServer.java    
        // Start services.
        try {
            t.traceBegin("StartServices");
            startBootstrapServices(t);   //启动BOOT服务（即没有这些服务系统无法运行）
            startCoreServices(t);        //启动核心服务
            startOtherServices(t);       //启动其他服务
            startApexServices(t);        //启动APEX服务，此服务必现要在前面的所有服务启动之后才能启动，为了防止OTA相关问题
            // Only update the timeout after starting all the services so that we use
            // the default timeout to start system server.
            updateWatchdogTimeout(t);
        } catch (Throwable ex) {
            Slog.e("System", "******************************************");
            Slog.e("System", "************ Failure starting system services", ex);
            throw ex;
        } finally {
            t.traceEnd(); // StartServices
        }
    /**
     * Starts system services defined in apexes.
     * <p>Apex services must be the last category of services to start. No other service must be
     * starting after this point. This is to prevent unnecessary stability issues when these apexes
     * are updated outside of OTA; and to avoid breaking dependencies from system into apexes.
     */
    private void startApexServices(@NonNull TimingsTraceAndSlog t) {
        t.traceBegin("startApexServices");
        // TODO(b/192880996): get the list from "android" package, once the manifest entries are migrated to system manifest.
        List<ApexSystemServiceInfo> services = ApexManager.getInstance().getApexSystemServices();
        for (ApexSystemServiceInfo info : services) {
            String name = info.getName();
            String jarPath = info.getJarPath();
            t.traceBegin("starting " + name);
            if (TextUtils.isEmpty(jarPath)) {
                mSystemServiceManager.startService(name);
            } else {
                mSystemServiceManager.startServiceFromJar(name, jarPath);
            }
            t.traceEnd();
        }
        // make sure no other services are started after this point
        mSystemServiceManager.sealStartedServices();
        t.traceEnd(); // startApexServices
    }

如上代码大体启动了四类服务：

startBootstrapServices：启动一些关键引导服务，这些服务耦合到一起
startCoreServices：启动一些关键引导服务，这些服务没有耦合到一起
startOtherServices：启动其他一些杂七杂八的服务
startApexServices：启动apex类的服务，其实就是mainline那些东西，详情参考请点击我

另外，我找到了一篇文章专门记录了所有的服务：Android10.0 Framework层服务一览表_android contexthub-CSDN博客

3）进入loop循环

//frameworks/base/services/java/com/android/server/SystemServer.java
        StrictMode.initVmDefaults(null);
        if (!mRuntimeRestart && !isFirstBootOrUpgrade()) {
            final long uptimeMillis = SystemClock.elapsedRealtime();
            final long maxUptimeMillis = 60 * 1000;
            if (uptimeMillis > maxUptimeMillis) {
                Slog.wtf(SYSTEM_SERVER_TIMING_TAG, "SystemServer init took too long. uptimeMillis=" + uptimeMillis);
            }
        }
        // Loop forever.
        Looper.loop();
        throw new RuntimeException("Main thread loop unexpectedly exited");

和之前讲的binder一样，基本上所有的进程最后都会进入loop进行循环，轮询主线程相关的handle消息和binder消息，如下日志堆栈，表示handle消息处理过程中发生异常：

2、顺序启动服务

1）startBootstrapServices阶段

启动看门狗->启动AMS：

//开始启动Bootstrap服务
//t.traceBegin("ArtModuleServiceInitializer");
//注册artd服务：这是Android系统中用于支持Android Runtime的后台守护进程
ArtModuleServiceInitializer.setArtModuleServiceManager(new ArtModuleServiceManager());
//启动watchdog：这是Android系统framework层使用的看门狗
final Watchdog watchdog = Watchdog.getInstance();
watchdog.start();
//读取SYSTEM配置：详见后续章节
SystemServerInitThreadPool.submit(SystemConfig::getInstance, TAG_SYSTEM_CONFIG);
//启动platform_compat和platform_compat_native服务：底层兼容性相关服务，当前只有AMS和PMS用到了它
PlatformCompat platformCompat = new PlatformCompat(mSystemContext);
ServiceManager.addService(Context.PLATFORM_COMPAT_SERVICE, platformCompat);
ServiceManager.addService(Context.PLATFORM_COMPAT_NATIVE_SERVICE, new PlatformCompatNative(platformCompat));
//启动file_integrity服务：跟文件加密校验等相关，该服务需要依赖keystore
mSystemServiceManager.startService(FileIntegrityService.class);
//启动installd服务：该服务直接影响应用程序的安装和管理，在后续AMS和PKMS启动的时候会使用到
Installer installer = mSystemServiceManager.startService(Installer.class);
//启动device_identifiers服务：该服务管理设备标识符（例如设备序列号/IMEI）的生成存储访问策略
mSystemServiceManager.startService(DeviceIdentifiersPolicyService.class);
//启动uri_grants服务：用于管理URI授权相关任务，控制应用程序之间共享数据时的URI访问权限确保系统安全
mSystemServiceManager.startService(UriGrantsManagerService.Lifecycle.class);
//启动powerstats服务：该服务监控和管理设备的能耗统计信息，涉及收集、分析和报告应用程序和系统组件的能耗数据
mSystemServiceManager.startService(PowerStatsService.class);
//调用native方法：android_server_SystemServer_startIStatsService
startIStatsService();
startMemtrackProxyService();
//实际上启动了AppOpService和PermissionService服务，他们用于管理应用程序操作权限
mSystemServiceManager.startService(AccessCheckingService.class);
//启动ams服务
ActivityTaskManagerService atm = mSystemServiceManager.startService(ActivityTaskManagerService.Lifecycle.class).getService();
mActivityManagerService = ActivityManagerService.Lifecycle.startService(mSystemServiceManager, atm);
mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
mActivityManagerService.setInstaller(installer);
mWindowManagerGlobalLock = atm.getGlobalLock();

启动AMS->启动PMS：

//启动dataloader_manager服务：用于管理data目录加载相关的服务，在PMS启动之前要先启动它
mDataLoaderManagerService = mSystemServiceManager.startService(DataLoaderManagerService.class);
// Incremental service needs to be started before package manager
mIncrementalServiceHandle = startIncrementalService();
//启动pms服务：电源管理相关的服务，包括息屏和亮屏，开机和关机等操作
mPowerManagerService = mSystemServiceManager.startService(PowerManagerService.class);
//启动thermalservice服务：温控相关的服务
mSystemServiceManager.startService(ThermalManagerService.class);
//启动performance_hint服务：
mSystemServiceManager.startService(HintManagerService.class);
//让AMS和PMS建立联系
mActivityManagerService.initPowerManagement();

启动PMS->启动DMS：

//启动recovery服务：用户系统恢复相关的服务，init进程可以通过/system/bin/uncrypt触发OTA包解密
mSystemServiceManager.startService(RecoverySystemService.Lifecycle.class);
//启动PackageWatchdog.noteBoot
RescueParty.registerHealthObserver(mSystemContext);
PackageWatchdog.getInstance(mSystemContext).noteBoot();
//启动lights服务：管理控制LED指示灯事件，例如接收新消息、电话来电、设备充电等LED的闪烁频率亮度颜色
mSystemServiceManager.startService(LightsService.class);
//启动手表上面的两个跟显示相关的服务
if (SystemProperties.getBoolean("config.enable_display_offload", false)) mSystemServiceManager.startService(WEAR_DISPLAYOFFLOAD_SERVICE_CLASS);
if (SystemProperties.getBoolean("config.enable_sidekick_graphics", false))  mSystemServiceManager.startService(WEAR_SIDEKICK_SERVICE_CLASS);
//启动display服务：即DMS服务，管理设备显示相关逻辑
mDisplayManagerService = mSystemServiceManager.startService(DisplayManagerService.class);
//设置SystemService当前阶段：PHASE_WAIT_FOR_DEFAULT_DISPLAY，此状态是系统启动阶段最早的，字面理解等待DMS服务器启动
mSystemServiceManager.startBootPhase(t, SystemService.PHASE_WAIT_FOR_DEFAULT_DISPLAY);

启动DMS->启动PKMS：

//启动domain_verification服务：这个服务的功能通常涉及验证特定的域名或域，在后续PKMS启动的时候会使用到
DomainVerificationService domainVerificationService = new DomainVerificationService( mSystemContext, SystemConfig.getInstance(), platformCompat);
mSystemServiceManager.startService(domainVerificationService);
//启动PKMS：调用PKMS的主函数
try {
    Watchdog.getInstance().pauseWatchingCurrentThread("packagemanagermain");
    mPackageManagerService = PackageManagerService.main(mSystemContext, installer, domainVerificationService, mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF);
    } finally {
        Watchdog.getInstance().resumeWatchingCurrentThread("packagemanagermain");
}
mFirstBoot = mPackageManagerService.isFirstBoot();
mPackageManager = mSystemContext.getPackageManager();
//注册DexUseManagerLocal：PKMS需要使用它，负责负责管理应用程序中的Dex文件，包括加载、卸载、优化等操作
LocalManagerRegistry.addManager(  DexUseManagerLocal.class,  DexUseManagerLocal.createInstance(mSystemContext));
//启动otadexopt服务：PKMS需要使用它，在OTA升级的时候需要通过它对包进行优化
boolean disableOtaDexopt = SystemProperties.getBoolean("config.disable_otadexopt", false);
if (!disableOtaDexopt) {
    Watchdog.getInstance().pauseWatchingCurrentThread("moveab");
    OtaDexoptService.main(mSystemContext, mPackageManagerService);
    Watchdog.getInstance().resumeWatchingCurrentThread("moveab");
}
//启动user服务：管理多用户的服务，例如用户切换，包括用户涉及到的信息和权限
mSystemServiceManager.startService(UserManagerService.LifeCycle.class);

初始化相关操作：

// Initialize attribute cache used to cache resources from packages.
AttributeCache.init(mSystemContext);
//通过 setSystemProcess方法为系统进程设置一个Application实例确保系统进程中的应用程序环境得到正确初始化
mActivityManagerService.setSystemProcess();
//为前文的domain_verification服务进行注册接受者
platformCompat.registerPackageReceiver(mSystemContext);
//初始化看门狗：此操作只能在ams所有工作准备完毕之后
watchdog.init(mSystemContext, mActivityManagerService);
//设置DMS服务的调度策略
mDisplayManagerService.setupSchedulerPolicies();
//启动overlay服务：管理应用程序的覆盖层，例如不同用户的主题、图标、颜色等
mSystemServiceManager.startService(new OverlayManagerService(mSystemContext));
//启动resources服务：管理应用程序的资源，如布局文件、字符串、图形等
ResourcesManagerService resourcesService = new ResourcesManagerService(mSystemContext);
resourcesService.setActivityManagerService(mActivityManagerService);
mSystemServiceManager.startService(resourcesService);
//启动sensor_privacy服务：负责管理和控制设备上的传感器相关服务
mSystemServiceManager.startService(new SensorPrivacyService(mSystemContext));
mSystemServiceManager.startService(SensorService.class);

2）startCoreServices阶段

//启动system_config服务：负责管理系统的各种配置信息，如权限配置、功能开关、默认设置等
mSystemServiceManager.startService(SystemConfigService.class);
//启动battery和batteryproperties服务：能够实时监控电池的状态、电量变化等信息，可能需要 LightService（灯光服务）等其他服务的支持
mSystemServiceManager.startService(BatteryService.class);
//启动usagestats服务：通过监控应用程序的使用情况和统计数据，为系统和应用程序提供有关应用程序活动的详细信息
mSystemServiceManager.startService(UsageStatsService.class);
mActivityManagerService.setUsageStatsManager(LocalServices.getService(UsageStatsManagerInternal.class));
//启动webviewupdate服务：负责追踪可更新的WebView是否准备就绪，并监控WebView的更新安装情况
if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_WEBVIEW)) mWebViewUpdateService = mSystemServiceManager.startService(WebViewUpdateService.class);
//本地服务，跟踪设备的各种状态，如网络连接状态、电量情况、传感器数据等， 该服务会将设备状态信息进行缓存，以便系统和应用程序可以更快速地访问设备状态数据，而无需每次都重新获取
mSystemServiceManager.startService(CachedDeviceStateService.class);
//启动binder_calls_stats服务：该服务用于跟踪在Binder调用中消耗的CPU时间，有助于系统开发人员分析和优化系统中的Binder通信性能
mSystemServiceManager.startService(BinderCallsStatsService.LifeCycle.class);
//启动looper_stats服务：该服务可以收集关于Handler处理消息时间的统计数据，有助于开发人员分析和优化系统中处理消息的效率和性能
mSystemServiceManager.startService(LooperStatsService.Lifecycle.class);
//启动rollback服务：负责管理应用程序包的回滚操作，即在应用程序升级失败时将其还原到先前的版本
mSystemServiceManager.startService(ROLLBACK_MANAGER_SERVICE_CLASS);
//本地服务：可以监视并处理由应用程序或进程崩溃导致的原生Tombstones，帮助识别问题并进行故障排除
mSystemServiceManager.startService(NativeTombstoneManagerService.class);
//启动bugreport服务：负责捕获和处理系统中发生的bug报告，以帮助开发人员诊断和解决应用程序或系统的问题
mSystemServiceManager.startService(BugreportManagerService.class);
//启动gpu服务：负责管理GPU驱动和图形处理相关的服务
mSystemServiceManager.startService(GpuService.class);
//启动remote_provisioning服务：该服务负责处理系统进程对远程配置密钥和数据的请求，以支持设备在远程配置方面的操作
mSystemServiceManager.startService(RemoteProvisioningService.class);
//启动cpu_monitor服务：用于监控CPU的运行情况，以便跟踪和优化系统在不同CPU负载下的性能表现
if (Build.IS_DEBUGGABLE || Build.IS_ENG) mSystemServiceManager.startService(CpuMonitorService.class);

3）startOtherServices阶段

启动安全相关服务->启动系统调度策略服务：

//启动sec_key_att_app_id_provider服务：为应用程序提供密钥验证服务，以确保应用程序的安全性和完整性
ServiceManager.addService("sec_key_att_app_id_provider",  new KeyAttestationApplicationIdProviderService(context));
//此服务可以有效地管理设备上的密钥链KeyChain，包括存储和访问各种加密密钥、证书等敏感信息。这对于安全通信、数字签名、数据加密等方面都是至关重要的
mSystemServiceManager.startService(KeyChainSystemService.class);
//此服务可以实现对软件包或二进制文件的透明性验证，确保它们未被篡改且来源可信
mSystemServiceManager.startService(BinaryTransparencyService.class);
//启动scheduling_policy服务：负责处理系统调度策略的服务，以优化系统资源的分配和任务执行
ServiceManager.addService("scheduling_policy", new SchedulingPolicyService());
//启动telephony相关服务
if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_MICROPHONE) || mPackageManager.hasSystemFeature(PackageManager.FEATURE_TELECOM) || mPackageManager.hasSystemFeature(PackageManager.FEATURE_TELEPHONY))   mSystemServiceManager.startService(TelecomLoaderService.class);
telephonyRegistry = new TelephonyRegistry(context, new TelephonyRegistry.ConfigurationProvider());
ServiceManager.addService("telephony.registry", telephonyRegistry);
//启动EntropyMixer组件：用于生成随机数和加密所需的随机性数据
mEntropyMixer = new EntropyMixer(context);
//启动account服务：负责处理设备上的账户管理相关操作，包括添加、删除、验证账户等功能
mSystemServiceManager.startService(ACCOUNT_SERVICE_CLASS);
//启动content服务：内容提供者服务，此服务提供应用程序对设备上存储的内容进行访问和管理的功能。这包括文件系统操作、数据库访问、共享数据等内容服务，有助于应用程序之间共享数据、处理多媒体内容和实现数据持久化等功能
mSystemServiceManager.startService(CONTENT_SERVICE_CLASS);
//启动device_config_updatable服务：此服务可以处理与设备配置相关的操作，确保设备的配置信息得到正确地管理和更新
mActivityManagerService.getContentProviderHelper().installSystemProviders();
mSystemServiceManager.startService(UPDATABLE_DEVICE_CONFIG_SERVICE_CLASS);
SQLiteCompatibilityWalFlags.reset();
//启动dropbox服务：负责记录系统中发生的错误、异常和其他日志信息，以便开发人员进行故障排查和问题分析
mSystemServiceManager.startService(DropBoxManagerService.class);
//启动role服务：负责管理和分配系统中的角色，以及授予默认权限和定义各种角色
LocalManagerRegistry.addManager(RoleServicePlatformHelper.class, new RoleServicePlatformHelperImpl(mSystemContext));
mSystemServiceManager.startService(ROLE_SERVICE_CLASS);
//启动vibrator_manager服务：对设备的振动功能进行管理，包括控制振动强度、模式以及在特定事件触发时触发振动等功能
mSystemServiceManager.startService(VibratorManagerService.Lifecycle.class);
//启动dynamic_system服务：动态分区服务
dynamicSystem = new DynamicSystemService(context);
ServiceManager.addService("dynamic_system", dynamicSystem);
//启动consumer_ir服务：管理红外线功能，通过红外等控制周围的设备（例如电视等），与硬件强相关            
if (context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_CONSUMER_IR)) {
consumerIr = new ConsumerIrService(context);
ServiceManager.addService(Context.CONSUMER_IR_SERVICE, consumerIr); }
//启动tare服务：主要在InternalResourceService中负责处理应用程序的ARC计数（应用程序引用计数），通常用于管理内存、文件句柄、网络连接等资源，确保资源被正确释放以避免浪费或系统不稳定
mSystemServiceManager.startService(RESOURCE_ECONOMY_SERVICE_CLASS);

启动系统调度策略服务->开始DMS相关的所有服务

//启动alarm服务：责管理和触发各种定时任务、闹钟以及重复性任务。提供闹铃和定时器等功能
if(!sMtkSystemServerIns.startMtkAlarmManagerService()) mSystemServiceManager.startService(ALARM_MANAGER_SERVICE_CLASS);
//启动input服务：处理事件分发，以前在WindowManagerService中，现在独立了出来，并且初始化的时候传递了 DisplayThread.get().getLooper()进去作为消息处理器，还启动了了Watchdog.getInstance().addMonitor(this)进行监视
inputManager = new InputManagerService(context);
//启动device_state服务：管理带有用户可配置硬件的设备状态的系统服务，根据设备的物理状态，dms wms和systemUI可能会有不同的行为。这对于可变状态设备(如可折叠或可滚动设备)非常有用
mSystemServiceManager.startService(DeviceStateManagerService.class);
//启动media.camera.proxy服务：camera相关的服务，同时会与media.camera服务进行交互
if (!disableCameraService)  mSystemServiceManager.startService(CameraServiceProxy.class);
//设置PHASE_WAIT_FOR_SENSOR_SERVICE状态，WMS开始执行main函数，注册window服务，注册input服务
mSystemServiceManager.startBootPhase(t, SystemService.PHASE_WAIT_FOR_SENSOR_SERVICE);
wm = WindowManagerService.main(context, inputManager, !mFirstBoot, 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);
mActivityManagerService.setWindowManager(wm);
wm.onInitReady();
//启动相关sensor服务，这些服务必现在PHASE_WAIT_FOR_SENSOR_SERVICE之后
SystemServerInitThreadPool.submit(() -> { startISensorManagerService(); }, START_SENSOR_MANAGER_SERVICE);
SystemServerInitThreadPool.submit(() -> { startHidlServices(); }, START_HIDL_SERVICES);
//启动vrmanager服务：如果是手表启动VR服务，VR也跟DMS/WMS相关
if (!isWatch && enableVrService) mSystemServiceManager.startService(VrManagerService.class);
//开始input服务：主要调用mNative.start()，然后添加到了看门狗进行监听
inputManager.setWindowManagerCallbacks(wm.getInputManagerCallback());
inputManager.start();
//通知DMS窗口管理服务，系统事件输入服务已经准备好
mDisplayManagerService.windowManagerAndInputReady();

开始DMS相关的所有服务->启动相对独立的服务

//启动bluetooth_manager服务：通过jar来实例化BluetoothService
mSystemServiceManager.startServiceFromJar(BLUETOOTH_SERVICE_CLASS, BLUETOOTH_APEX_SERVICE_JAR_PATH);
//启动connmetrics和netd_listener服务：分别对应网络连接相关的服务IpConnectivityMetrics；接收netd进程的底层事件的服务NetdEventListenerService
mSystemServiceManager.startService(IP_CONNECTIVITY_METRICS_CLASS);
//启动network_watchlist服务：管理系统的网络监控列表
mSystemServiceManager.startService(NetworkWatchlistService.Lifecycle.class);
//启动pinner服务：主要功能是将关键进程的重要文件固定在内存中，避免因为数据被移动到磁盘上而导致性能下降或延迟。这种服务对于优化系统性能和确保关键数据持续在内存中非常重要
mSystemServiceManager.startService(PinnerService.class);
//debug模式才能启用：System-server-local proxy into the native service.
if (Build.IS_DEBUGGABLE && ProfcollectForwardingService.enabled()) mSystemServiceManager.startService(ProfcollectForwardingService.class);
//他不是一个服务，而只是拥有一个用于接收包安装和更新通知的广播接收器，来负责处理应用程序的签名配置或相关的安全性功能
SignedConfigService.registerUpdateReceiver(mSystemContext);
//启动app_integrity服务：主要目的是确保应用程序的完整性，并执行相关的验证规则以增强系统的安全性和稳定性
mSystemServiceManager.startService(AppIntegrityManagerService.class);
//启动logcat服务： Service responsible for managing the access to Logcat.
mSystemServiceManager.startService(LogcatManagerService.class);

启动输入法服务->启动存储相关服务

//安全模式开启飞行模式
final boolean safeMode = wm.detectSafeMode();
if (safeMode) Settings.Global.putInt(context.getContentResolver(), Settings.Global.AIRPLANE_MODE_ON, 1);
else if (context.getResources().getBoolean(R.bool.config_autoResetAirplaneMode)) Settings.Global.putInt(context.getContentResolver(), Settings.Global.AIRPLANE_MODE_ON, 0);
//启动input_method服务：键盘输入法服务，打开和关闭输入法。注意和前面的事件输入服务区别
String immsClassName = context.getResources().getString(R.string.config_deviceSpecificInputMethodManagerService);
if (immsClassName.isEmpty()) mSystemServiceManager.startService(InputMethodManagerService.Lifecycle.class);
else  mSystemServiceManager.startService(immsClassName);
//启动accessibility服务：截获所有的用户输入，集中处理和分发设备上产生的无障碍事件，保证无障碍服务相关功能的稳定
mSystemServiceManager.startService(ACCESSIBILITY_MANAGER_SERVICE_CLASS);
//making display ready
wm.displayReady();
//启动mount服务：StorageManagerService服务，负责管理存储设备（如内部存储、外部存储、USB 存储等）的服务。它处理挂载（mounting）、卸载（unmounting）、格式化、检测存储设备状态等操作。 NotificationManagerService在某些情况下需要依赖他，例如插入USB的时候需要弹框
//启动storagestats服务：访问详细的存储统计信息。这提供了应用程序、用户和外部/共享存储如何利用磁盘空间的摘要
if (!"0".equals(SystemProperties.get("system_init.startmountservice"))) {
    mSystemServiceManager.startService(STORAGE_MANAGER_SERVICE_CLASS);
    storageManager = IStorageManager.Stub.asInterface(ServiceManager.getService("mount"));
    mSystemServiceManager.startService(STORAGE_STATS_SERVICE_CLASS);
}
//启动uimode服务：UiModeManagerService服务，负责管理深色主题/夜间模式，包括车载模式，同时虽然不直接管理省电模式，但是和省电模式UI相关功能有一些耦合
mSystemServiceManager.startService(UiModeManagerService.class);
//启动locale服务：为应用程序提供一种机制来存储和管理与本地化设置相关的信息，允许应用程序将其特定的UI本地化信息存储在系统中，以便在需要时访问并应用到应用程序的用户界面中
mSystemServiceManager.startService(LocaleManagerService.class);
//启动grammatical_inflection服务：该服务可能被用于文本处理工具、语言学应用程序或其他需要处理语言变形的应用中
mSystemServiceManager.startService(GrammaticalInflectionService.class);
//启动app_hibernation服务：AppHibernationService 服务，主要用于处理应用程序的休眠状态管理，以支持系统在需要时对不活跃应用程序进行优化处理，从而提高存储利用率并改善系统效率
mSystemServiceManager.startService(APP_HIBERNATION_SERVICE_CLASS);

启动锁屏服务->启动状态栏管理服务

//初始化ArtManagerLocal相关设置，updatePackagesIfNeeded检查并更新应用程序包，performFstrimIfNeeded执行TRIM操作，确保系统中的应用程序处于最新状态
DexOptHelper.initializeArtManagerLocal(context, mPackageManagerService);
Watchdog.getInstance().pauseWatchingCurrentThread("dexopt");
mPackageManagerService.updatePackagesIfNeeded();
Watchdog.getInstance().resumeWatchingCurrentThread("dexopt");
mPackageManagerService.performFstrimIfNeeded();
//启动lock_settings服务：LockSettingsService服务，管理设备的锁屏设置，包括密码、图案、PIN 码等锁定方式的配置和验证
mSystemServiceManager.startService(LOCK_SETTINGS_SERVICE_CLASS);
lockSettings = ILockSettings.Stub.asInterface(ServiceManager.getService("lock_settings"));
//启动persistent_data_block服务：系统可以管理设备上存储的重要持久化数据块，并确保这些数据块得到正确地处理和维护，以支持设备的正常运行和数据的安全性
final boolean hasPdb = !SystemProperties.get(PERSISTENT_DATA_BLOCK_PROP).equals("");
if(hasPdb) mSystemServiceManager.startService(PersistentDataBlockService.class);
//启动testharness服务：用于管理测试工具模式（Test Harness Mode）服务，管理自动化测试服务，用于在设备上设置自动测试框架
mSystemServiceManager.startService(TestHarnessModeService.class);
//启动oem_lock服务：负责控制和管理设备的 OEM 锁定设置
if (hasPdb || OemLockService.isHalPresent()) mSystemServiceManager.startService(OemLockService.class);
//启动deviceidle服务：监控设备的使用情况，以确定设备是否处于空闲状态，控制设备的休眠模式和管理应用程序的激活和限制
mSystemServiceManager.startService(DEVICE_IDLE_CONTROLLER_CLASS);
//启动device_policy服务：用于管理设备安全策略和控制权限的重要服务。它允许管理员远程管理设备并强制执行各种策略以确保设备的安全性和合规性
dpms = mSystemServiceManager.startService(DevicePolicyManagerService.Lifecycle.class);
//启动statusbar服务：负责状态栏的显示、隐藏、通知管理以及其他与状态栏相关的功能。而SystemUI则负责更新、渲染和显示状态栏内容，并处理用户与状态栏的交互
statusBar = new StatusBarManagerService(context);
if (!isWatch) statusBar.publishGlobalActionsProvider();
ServiceManager.addService(Context.STATUS_BAR_SERVICE, statusBar, false, DUMP_FLAG_PRIORITY_NORMAL | DUMP_FLAG_PROTO);

启动一些比较使用功能的服务

//启动music_recognition服务：根据设备配置判断是否应启动音乐识别管理器服务
if (deviceHasConfigString(context, R.string.config_defaultMusicRecognitionService)) mSystemServiceManager.startService(MUSIC_RECOGNITION_MANAGER_SERVICE_CLASS);
//启动content_capture服务：ContentCaptureManagerService服务，负责处理和管理与内容捕获相关的功能，内容捕获服务通常用于提供自动填充、建议、或者其他智能功能，以改善用户体验并增强应用程序的功能性
startContentCaptureService(context, t);
//启动attention服务：AttentionManagerService服务，注意力管理器服务通常与用户界面、通知系统或其他应用程序交互，以根据用户的注意力状态做出相应的反应或调整
startAttentionService(context, t);
//启动resolver服务：RotationResolverManagerService服务，务负责处理设备屏幕旋转相关的逻辑，包括监测设备方向变化、调整屏幕显示方向、以及触发相应的屏幕旋转事件等
startRotationResolverService(context, t);
//SystemCaptionsManagerService：根据设备配置情况判断是否应启动系统字幕管理器服务
startSystemCaptionsManagerService(context, t);
//启动texttospeech服务：TextToSpeechManagerService服务，负责提供文本转语音的功能，允许应用程序将文本数据转换为语音输出。通过该服务，用户可以享受到文字内容的语音朗读功能，增强了用户体验和可访问性
startTextToSpeechManagerService(context, t);
//启动ambient_context服务：AmbientContextManagerService服务，负责收集和分析设备周围环境的数据，以提供更智能和个性化的用户体验。通过监测环境信息，该服务可以自动调整设备设置、应用程序行为或提供定制化的功能，从而增强用户体验并提供更多智能化的服务
startAmbientContextService(t);
//启动wearable_sensing服务：WearableSensingManagerService服务，负责管理和处理与可穿戴设备相关的传感器数据，如运动传感器、心率传感器等。通过该服务，系统可以监测和分析用户在可穿戴设备上的活动、健康状况等数据，以提供个性化的健康、运动或其他方面的服务和建议
startWearableSensingService(t);
//启动speech_recognition服务：SpeechRecognitionManagerService服务，系统语音识别管理器服务，负责处理设备上的语音输入，并将其转换为文本或对应的命令
mSystemServiceManager.startService(SPEECH_RECOGNITION_MANAGER_SERVICE_CLASS);
//启动app_prediction服务：AppPredictionManagerService服务，负责分析用户的操作习惯、使用模式和其他相关数据，以预测用户可能要使用的应用程序，提供更智能、个性化的应用程序推荐
if (deviceHasConfigString(context, R.string.config_defaultAppPredictionService)) mSystemServiceManager.startService(APP_PREDICTION_MANAGER_SERVICE_CLASS);
//启动content_suggestions服务：ContentSuggestionsManagerService服务，负责根据用户的偏好、历史数据和其他相关信息，提供个性化的内容推荐，包括应用程序、新闻、视频、音乐等。通过该服务，系统可以为用户提供更加符合其兴趣和需求的内容，并改善用户体验
if (deviceHasConfigString(context, R.string.config_defaultContentSuggestionsService))  mSystemServiceManager.startService(CONTENT_SUGGESTIONS_SERVICE_CLASS);
//启动search_ui服务：SearchUiManagerService服务，负责管理设备上的搜索界面，包括搜索功能的展示、用户界面交互等，此服务可以为lanucher应用提供搜索相关的功能支持，例如在搜索界面中展示搜索结果、协助搜索操作等
mSystemServiceManager.startService(SEARCH_UI_MANAGER_SERVICE_CLASS);
//启动smartspace服务：SmartspaceManagerService服务，智能空间管理器服务通常负责提供设备主屏幕上的智能助手功能，例如展示天气信息、日历事件、提醒事项等内容。通过智能空间管理器服务，用户可以快速查看重要信息，并获取有用的实时数据
mSystemServiceManager.startService(SMARTSPACE_MANAGER_SERVICE_CLASS);

启动网络相关服务

//网络堆栈器初始化,所有网络相关服务之前都需要初始化它
ConnectivityModuleConnector.getInstance().init(context); //会打印日志"Network stack init"
NetworkStackClient.getInstance().init();                 //会打印日志"Network stack init"
//启动network_management服务：主要是用于创建、配置和启动网络管理服务，并确保该服务可以有效地运行以满足系统对网络管理的需求
networkManagement = NetworkManagementService.create(context);
ServiceManager.addService(Context.NETWORKMANAGEMENT_SERVICE, networkManagement);
//启动font服务：负责管理设备上的字体资源，包括加载、缓存、渲染字体以及提供字体相关功能，以确保应用程序和系统能够正确显示文本内容并提供字体选择和调整的功能
mSystemServiceManager.startService(new FontManagerService.Lifecycle(context, safeMode));
//启动textservices服务：负责管理设备上的文本输入服务、文本处理服务、拼写检查等相关功能，为用户提供良好的文本输入和编辑体验
mSystemServiceManager.startService(TextServicesManagerService.Lifecycle.class);
//启动textclassification服务：用于启动文本分类管理器服务，以提供文本内容的智能分类和分析功能，例如识别文本中的实体、情感分析、语言识别等，帮助用户更好地理解和处理文本信息
if (!disableSystemTextClassifier) mSystemServiceManager.startService(TextClassificationManagerService.Lifecycle.class);
//启动network_score服务：服务通常负责根据网络质量、连接稳定性等因素为网络提供评分，并帮助系统做出优化网络连接的决策
mSystemServiceManager.startService(NetworkScoreService.Lifecycle.class);
//启动netstats服务：启动网络统计服务，并确保在启动NetworkPolicyManager之前先启动 NetworkStatsService，同时进行相应的跟踪操作来监控执行过程
mSystemServiceManager.startServiceFromJar(NETWORK_STATS_SERVICE_INITIALIZER_CLASS,CONNECTIVITY_SERVICE_APEX_PATH);
//启动netpolicy服务：可以监控和限制应用程序的数据使用，有助于优化数据使用，节省用户的流量消耗，并在需要时提供通知提示，还可以配置网络策略，以确定是否允许应用程序在漫游状态下访问数据网络，以避免高额的漫游费用
networkPolicy = new NetworkPolicyManagerService(context, mActivityManagerService,networkManagement);
ServiceManager.addService(Context.NETWORK_POLICY_SERVICE, networkPolicy);
//启动wifi和wifiscanner服务：管理WIFI和WIFI扫描服务
if (context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_WIFI)) {
    mSystemServiceManager.startServiceFromJar(WIFI_SERVICE_CLASS, WIFI_APEX_SERVICE_JAR_PATH);
    mSystemServiceManager.startServiceFromJar(WIFI_SCANNING_SERVICE_CLASS, WIFI_APEX_SERVICE_JAR_PATH);
}
//启动wifirtt服务：
if (context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_WIFI_RTT)) mSystemServiceManager.startServiceFromJar(WIFI_RTT_SERVICE_CLASS, WIFI_APEX_SERVICE_JAR_PATH);
//启动wifiaware服务：
if (context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_WIFI_AWARE)) mSystemServiceManager.startServiceFromJar(WIFI_AWARE_SERVICE_CLASS, WIFI_APEX_SERVICE_JAR_PATH);
//启动wifip2p服务：
if (context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_WIFI_DIRECT)) mSystemServiceManager.startServiceFromJar(WIFI_P2P_SERVICE_CLASS, WIFI_APEX_SERVICE_JAR_PATH);
//根据设备是否支持 LoWPAN 功能来决定是否启动 LoWPAN 服务。 LoWPAN 是一种低功耗无线个人区域网络技术，用于连接低功耗设备，例如传感器、智能家居设备等，以实现设备间的通信互连。
if (context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_LOWPAN)) mSystemServiceManager.startService(LOWPAN_SERVICE_CLASS);
//启动pac_proxy服务：PAC代理服务通常用于管理和配置网络代理设置，以便应用程序能够正确地路由网络流量
pacProxyService = new PacProxyService(context);
ServiceManager.addService(Context.PAC_PROXY_SERVICE, pacProxyService);
//Connectivity service initializer for core networking
//启动ethernet服务/connectivity服务/ipsec服务/connectivity_native服务/servicediscovery服务/nearby服务
mSystemServiceManager.startServiceFromJar(CONNECTIVITY_SERVICE_INITIALIZER_CLASS, CONNECTIVITY_SERVICE_APEX_PATH);
networkPolicy.bindConnectivityManager();
//启动vpn_management服务：管理VPN相关功能
vpnManager = VpnManagerService.create(context);
ServiceManager.addService(Context.VPN_MANAGEMENT_SERVICE, vpnManager);
//启动vcn_management服务： VCN 管理服务，可以实现对虚拟运营商网络的配置、管理和控制，从而提供更灵活的网络连接选项和功能
vcnManagement = VcnManagementService.create(context);
ServiceManager.addService(Context.VCN_MANAGEMENT_SERVICE, vcnManagement);

启动通知和时间定位相关的服务

//启动system_update服务：允许查询发送系统更新的信息，通过维护system-update-info.xml文件来实现
ServiceManager.addService(Context.SYSTEM_UPDATE_SERVICE, new SystemUpdateManagerService(context));
//启动updatelock服务：OTA/update purposes can so advise the OS. 服务启动后发送android.os.UpdateLock.UPDATE_LOCK_CHANGED广播
ServiceManager.addService(Context.UPDATE_LOCK_SERVICE, new UpdateLockService(context));
//启动notification服务：通知服务，管理通知的发布和是否显示
mSystemServiceManager.startService(NotificationManagerService.class);
SystemNotificationChannels.removeDeprecated(context);
SystemNotificationChannels.createAll(context);
notification = INotificationManager.Stub.asInterface( ServiceManager.getService(Context.NOTIFICATION_SERVICE));
//启动devicestoragemonitor服务：存储空间的监控，当存储空间低于阈值时发送广播
mSystemServiceManager.startService(DeviceStorageMonitorService.class);
//启动time_detector服务：TimeDetectorService服务， 处理时间检测周围的逻辑。
mSystemServiceManager.startService(TIME_DETECTOR_SERVICE_CLASS);
//启动location服务：位置服务，实现了通过GNSS、GPS、定位等功能	
mSystemServiceManager.startService(LocationManagerService.Lifecycle.class);
//启动country_detector服务：通过检查设备的时区、语言设置、SIM 卡信息等来确定用户所在的国家或地区。开发人员可以利用这个服务来适应不同国家或地区的用户需求，以提供更个性化和本地化的体验
countryDetector = new CountryDetectorService(context);
ServiceManager.addService(Context.COUNTRY_DETECTOR, countryDetector);
//启动time_zone_detector服务：TimeZoneDetectorService服务，主要用于检测用户所在的时区信息
mSystemServiceManager.startService(TIME_ZONE_DETECTOR_SERVICE_CLASS);
//启动AltitudeService服务：处理海拔高度相关功能的服务，可能涉及到获取设备所在位置的海拔高度信息或其他与海拔有关的操作
mSystemServiceManager.startService(AltitudeService.Lifecycle.class);
//启动location_time_zone_manager服务：LocationTimeZoneManagerService服务，负责处理位置和时区信息的管理服务
mSystemServiceManager.startService(LOCATION_TIME_ZONE_MANAGER_SERVICE_CLASS);
//启动gnss_time_update_service服务：GnssTimeUpdateService服务，通过GNSS卫星来更新时间
if (context.getResources().getBoolean(R.bool.config_enableGnssTimeUpdateService)) mSystemServiceManager.startService(GNSS_TIME_UPDATE_SERVICE_CLASS);

启动壁纸和audio相关的服务

//启动search服务：SearchManagerService服务，是搜索管理服务，负责处理搜索用户界面，并维护可搜索活动的注册表。与桌面应用的搜索栏有关系
if (!isWatch) mSystemServiceManager.startService(SEARCH_MANAGER_SERVICE_CLASS);
//启动wallpaper服务：WallpaperManagerService服务，壁纸管理服务
if (context.getResources().getBoolean(R.bool.config_enableWallpaperService)) mSystemServiceManager.startService(WALLPAPER_SERVICE_CLASS);
//启动wallpaper_effects_generation服务：A service used to return wallpaper effect given a request. 从注释来看跟壁纸效果有关系，例如动态壁纸，交互式壁纸
mSystemServiceManager.startService(WALLPAPER_EFFECTS_GENERATION_MANAGER_SERVICE_CLASS);
//启动audio服务：AudioService服务，AudioFlinger的上层管理封装，主要是音量、音效、声道及铃声等的管理
boolean isArc = context.getPackageManager().hasSystemFeature("org.chromium.arc");
if (!isArc) { mSystemServiceManager.startService(AudioService.Lifecycle.class);
} else { // 
    String className = context.getResources().getString(R.string.config_deviceSpecificAudioService);
    mSystemServiceManager.startService(className + "$Lifecycle");
}
//启动soundtrigger_middleware服务：SoundTriggerMiddlewareService则可能处于底层系统层次，提供声音触发功能的中间件支持，并与硬件驱动等交互，为更高级别的声音触发功能提供基础支持（注意和SoundTriggerService区分）
mSystemServiceManager.startService(SoundTriggerMiddlewareService.Lifecycle.class);
//启动broadcastradio服务：可以实现设备上广播电台的调谐、收听、搜索等功能。这个服务负责管理与广播电台相关的逻辑，并提供给应用程序或其他组件访问广播收音机的能力
if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_BROADCAST_RADIO)) mSystemServiceManager.startService(BroadcastRadioService.class);
//启动DockObserver服务：？
if (!isTv) mSystemServiceManager.startService(DockObserver.class);
//启动com.android.clockwork.ThermalObserver服务：？
if (isWatch) mSystemServiceManager.startService(THERMAL_OBSERVER_CLASS);
//WiredAccessoryManager 用于监视主板或对接站上连接的有线耳机，并通过 InputManagerService 的 notifyWiredAccessoryChanged 接口和 UEventObserver 子系统来进行监测
if (!isWatch) inputManager.setWiredAccessoryCallbacks(new WiredAccessoryManager(context, inputManager));
//启动midi服务：MidiService服务，涉及MIDI音乐相关功能，如MIDI文件播放、音乐合成等操作。MIDI是音乐乐器数字接口的缩写，定义了如何通过数字信号传输音乐数据，包括音符、音量、音色、节奏等信息，而不涉及声音本身
if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_MIDI)) mSystemServiceManager.startService(MIDI_SERVICE_CLASS);

启动adb/usb/serial和其他服务

//启动adb服务：AdbService服务，用于adb调试
mSystemServiceManager.startService(ADB_SERVICE_CLASS);
//启动usb服务：UsbService服务，管理所有USB状态，主机模式委托给UsbHostManager管理，从机模式委托给UsbDeviceManager管理
if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_USB_HOST) || mPackageManager.hasSystemFeature(PackageManager.FEATURE_USB_ACCESSORY) || isEmulator){
    mSystemServiceManager.startService(USB_SERVICE_CLASS);
}
//启动serial服务：串口服务，对串口的设备进行操作
if (!isWatch) ServiceManager.addService(Context.SERIAL_SERVICE, new SerialService(context));
//启动hardware_properties服务：可以给其他组件提供硬件信息，可以通过dumpsys hardware_properties获取这些信息
hardwarePropertiesService = new HardwarePropertiesManagerService(context);
ServiceManager.addService(Context.HARDWARE_PROPERTIES_SERVICE, hardwarePropertiesService);
//启动TwilightManager服务：此服务可以根据经度和纬度来计算黄昏状态，计算黄昏状态对于确定日出和日落时间以及天文事件的安排非常重要，也有助于制定户外活动、摄影计划等。
if (!isWatch) mSystemServiceManager.startService(TwilightService.class);
//启动color_display服务：负责管理设备屏幕的色彩显示设置，包括调整亮度、对比度、色温等选项，以提供用户个性化和舒适的屏幕显示体验
mSystemServiceManager.startService(ColorDisplayService.class);
//启动jobscheduler服务：JobSchedulerService服务，负责管理作业队列、调度作业的执行时间和条件，以及通知应用程序关于作业执行状态的信息。这个服务有助于提高应用程序的稳定性和用户体验，同时有效地管理后台任务的执行
mSystemServiceManager.startService(JOB_SCHEDULER_SERVICE_CLASS);
//启动soundtrigger服务：SoundTriggerService可能更专注于用户界面上的声音触发功能，如语音助手、语音控制等。注意和SoundTriggerMiddlewareService区分
mSystemServiceManager.startService(SoundTriggerService.class);
//启动trust服务：该服务是设备中的信任管理相关的服务，通常用于处理和管理设备上的安全认证和信任相关功能。管理和验证设备用户的身份认证信息，如密码、指纹、面部识别等
mSystemServiceManager.startService(TrustManagerService.class);
//启动backup服务：BackupManagerService服务，处理和管理应用程序数据的备份和恢复操作，以确保用户数据的安全性和可靠性
if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_BACKUP)) mSystemServiceManager.startService(BACKUP_MANAGER_SERVICE_CLASS);
//启动appwidget服务：AppWidgetService负责管理和显示应用程序小部件的服务，提供了处理小部件更新和事件的功能，在Launcher中被调用和管理，Launcher 负责在设备主屏幕上管理小部件的布局和显示
if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_APP_WIDGETS) || context.getResources().getBoolean(R.bool.config_enableAppWidgetService)) {
mSystemServiceManager.startService(APPWIDGET_SERVICE_CLASS);}
//启动voiceinteraction服务：VoiceInteractionManagerService语音交互管理服务，语音识别和交互功能，使用户可以通过语音与设备进行交互和控制
mSystemServiceManager.startService(VOICE_RECOGNITION_MANAGER_SERVICE_CLASS);
//启动GestureLauncherService服务：The service that listens for gestures detected in sensor firmware and starts the intent accordingly. For now, only camera launch gesture is supported, and in the future, more gestures can be  added
if (GestureLauncherService.isGestureLauncherEnabled(context.getResources())) mSystemServiceManager.startService(GestureLauncherService.class);
//启动SensorNotificationService服务：传感器通知服务可能是与设备中的传感器相关的服务，代码中监听了传音的状态变化
mSystemServiceManager.startService(SensorNotificationService.class);
//启动contexthub服务：上下文中心运行时环境 (CHRE) 为在低功耗处理器上运行应用程序提供了一个通用平台，具有简单、标准化、嵌入式友好的 API,参考https://source.android.google.cn/devices/contexthub?hl=vi
if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_CONTEXT_HUB)) mSystemServiceManager.startService(ContextHubSystemService.class);
//启动diskstats服务：主要用来各个应用程序的磁盘使用统计信息，使用adb shell dumpsys diskstats可以输出用程序的UID（用户ID）、读取字节数、写入字节数、读取操作数和写入操作数等信息
ServiceManager.addService("diskstats", new DiskStatsService(context));
//启动runtime服务：主要用来统计当前时间相关的数据信息，使用adb shell dumpsys runtime可以输出这些信息。注意跟运行时好像没有太大关系
ServiceManager.addService("runtime", new RuntimeService(context));
//启动network_time_update_service服务：通过[ntp://time.android.com, ntp://pool.ntp.org]查询网络时间，如果查询失败会有重连机制
if (!isWatch && !disableNetworkTime) {
    networkTimeUpdater = new NetworkTimeUpdateService(context);
    ServiceManager.addService("network_time_update_service", networkTimeUpdater); }
//CertBlacklister提供了一种简单的机制来更新SSL证书公钥和序列号的平台黑名单，android维护在/data/misc/keychain目录
CertBlacklister blacklister = new CertBlacklister(context); 
//启动emergency_affordance服务：A service that listens to connectivity and SIM card changes and determines if the emergency affordance should be enabled.
if (EmergencyAffordanceManager.ENABLED) mSystemServiceManager.startService(EmergencyAffordanceService.class);

启动TV和多媒体相关的服务

//启动blob_store服务：BlobStoreManagerService服务，Service responsible for maintaining and facilitating access to data blobs published by apps
mSystemServiceManager.startService(BLOB_STORE_MANAGER_SERVICE_CLASS);
//启动dreams服务：DreamManagerService主要是提供屏保服务，应用可以通过继承DreamService实现自己想要的屏保效果，可以参考https://www.jianshu.com/p/75d8581ec4fe/
mSystemServiceManager.startService(DreamManagerService.class);
//启动graphicsstats服务：图形统计服务通常用于收集和记录与图形渲染相关的性能数据和统计信息，收集有关GPU、渲染器等图形相关组件的性能指标，记录应用程序的帧率（FPS）、绘制时间、内存使用情况等性能数据
ServiceManager.addService(GraphicsStatsService.GRAPHICS_STATS_SERVICE, new GraphicsStatsService(context));
//启动coverage服务：CoverageService可能与代码覆盖率检测相关，实现用于监视代码执行的机制，收集有关代码路径和执行次数的信息，用于衡量源代码中被测试用例覆盖到的代码比例
if (CoverageService.ENABLED) ServiceManager.addService(CoverageService.COVERAGE_SERVICE, new CoverageService());
//启动print服务：PrintManagerService服务主要用于处理打印相关的功能。让应用程序可以与打印服务进行通信，从而实现打印文档、图片等内容
if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_PRINTING)) mSystemServiceManager.startService(PRINT_MANAGER_SERVICE_CLASS);
//启动attestation_verification服务：处理关于认证和验证相关的功能，负责管理设备或组件的认证过程，确保设备的合法性和可信度
mSystemServiceManager.startService(AttestationVerificationManagerService.class);
if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_COMPANION_DEVICE_SETUP)) {
    //启动companiondevice服务：CompanionDeviceManagerService服务用于处理配件设备的管理和设置，包括配对、连接和配置外部设备，如智能手表、健康追踪器等
    mSystemServiceManager.startService(COMPANION_DEVICE_MANAGER_SERVICE_CLASS);
    //启动virtualdevice服务：VirtualDeviceManagerService用于管理虚拟设备或模拟器，可能包括创建、启动和管理虚拟设备实例
    mSystemServiceManager.startService(VIRTUAL_DEVICE_MANAGER_SERVICE_CLASS);
}
//启动restrictions服务：系统可以实现对设备和应用程序使用的某些功能、资源或数据进行限制和控制，从而确保系统在合规性和安全性方面的要求得到满足
mSystemServiceManager.startService(RestrictionsManagerService.class);
//启动media_session服务：MediaSessionService负责注册、跟踪和处理应用程序之间的多媒体控制命，
mSystemServiceManager.startService(MEDIA_SESSION_SERVICE_CLASS);
//启动hdmi_control服务：提供HDMI控制消息、HDMI- cec和MHL控制命令的发送和处理服务，另外还负责建立和管理eARC连接
if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_HDMI_CEC)) mSystemServiceManager.startService(HdmiControlService.class);
//启动tv_interactive_app服务：提供了一种专门处理电视上交互式应用程序的服务，负责管理安装、卸载和运行在电视上的交互式应用程序
if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_LIVE_TV) mSystemServiceManager.startService(TvInteractiveAppManagerService.class);
//启动tv_input服务：关注管理电视输入设备和频道，与输入源和多媒体内容相关
if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_LIVE_TV) mSystemServiceManager.startService(TvInputManagerService.class);
//启动tv_tuner_resource_mgr服务：TunerResourceManagerService服务通常用于管理电视信号调谐器tuner资源，协助进行节目频道的切换和调谐器设置，以便用户可以浏览不同的电视频道
if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_TUNER)) mSystemServiceManager.startService(TunerResourceManagerService.class);
//启动media_resource_monitor服务：MediaResourceMonitorService服务用于监控系统中各种媒体资源的使用情况，包括音频、视频、图像等
if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_PICTURE_IN_PICTURE)) mSystemServiceManager.startService(MEDIA_RESOURCE_MONITOR_SERVICE_CLASS);
//TvInputManagerService关注电视信号和输入设备的管理，TvInteractiveAppManagerService关注电视应用程序和用户界面的管理，TunerResourceManagerService主要关注电视信号调谐器资源的管理，MediaResourceMonitorService则主要关注系统中各种媒体资源的实时监控和优化
//TvRemoteService服务负责接收来自电视遥控器的配对和各种点击滑动事件，且还加入了 Watchdog.getInstance().addMonitor(this)监视
if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_LEANBACK)) mSystemServiceManager.startService(TvRemoteService.class);
//启动media_router服务：负责检测、注册和管理设备上可用的多媒体输出和输入路由，实现多屏互动、外部设备连接和优化用户体验的目的
mediaRouter = new MediaRouterService(context);
ServiceManager.addService(Context.MEDIA_ROUTER_SERVICE, mediaRouter);

启动人脸、虹膜、指纹检查匹配特征码提取服务

//启动face服务：通常用于处理人脸识别相关的功能，包括人脸检测，人脸匹配，人脸特征提取，从而实现对用户身份的验证，进而解锁设备或授权访问
final boolean hasFeatureFace = mPackageManager.hasSystemFeature(PackageManager.FEATURE_FACE);
if (hasFeatureFace) final FaceService faceService = mSystemServiceManager.startService(FaceService.class);
//启动iris服务：通常用于处理虹膜识别相关的功能，包括虹膜检测，虹膜匹配，虹膜特征提取，从而实现对用户身份的验证，进而解锁设备或授权访问
final boolean hasFeatureIris = mPackageManager.hasSystemFeature(PackageManager.FEATURE_IRIS);
if (hasFeatureIris)  mSystemServiceManager.startService(IrisService.class);
//启动fingerprint服务：通常用于处理指纹识别相关的功能，包括指纹检查，指纹匹配，指纹特征提取，指纹支付，从而实现对用户身份的验证，进而解锁设备或授权访问
final boolean hasFeatureFingerprint = mPackageManager.hasSystemFeature(PackageManager.FEATURE_FINGERPRINT);
if (hasFeatureFingerprint) final FingerprintService fingerprintService = mSystemServiceManager.startService(FingerprintService.class);
//启动biometric服务：通常用于管理和提供生物识别相关功能，负责统一管理不同类型的生物识别技术，如人脸识别、虹膜识别、指纹识别等，从而实现多模态生物识别和更全面的身份验证功能
mSystemServiceManager.startService(BiometricService.class);
//启动auth服务：AuthService主要关注用户的身份认证和授权管理，与用户身份验证和访问控制有关。BiometricService主要涉及生物识别技术的管理和应用。BiometricService可能作为AuthService的一部分，为身份认证提供更多选择，例如通过生物特征进行快速身份验证或强化认证措施
mSystemServiceManager.startService(AuthService.class);
//启动jobscheduler服务：是一个执行与动态代码加载相关的后台任务的服务，负责在特定条件下进行日志记录和监视动态代码加载的情况
if (!isWatch) DynamicCodeLoggingService.schedule(context);
if (!isWatch) PruneInstantAppsJobService.schedule(context);
//启动shortcut服务：用于管理应用程序快捷方式的服务。快捷方式允许用户快速访问应用程序的特定功能或操作，而不必打开整个应用程序
mSystemServiceManager.startService(ShortcutService.Lifecycle.class);
//启动launcherapps服务：LauncherAppsService主要负责与设备启动器应用程序进行交互，管理应用程序快捷方式的显示和操作；ShortcutService则专注于应用程序内部的快捷方式管理，提供创建和管理应用程序快捷方式的功能。LauncherAppsService可能会利用ShortcutService提供的快捷方式管理功能来对启动器界面上的应用程序快捷方式进行管理
mSystemServiceManager.startService(LauncherAppsService.class);
//启动crossprofileapps服务：在android上多个用户可以拥有各自的配置文件或用户账户，CrossProfileAppsService 服务主要针对设备上不同用户配置文件之间的应用程序交互，提供跨用户配置文件应用程序的管理和访问功能
mSystemServiceManager.startService(CrossProfileAppsService.class);
//启动people服务：？
mSystemServiceManager.startService(PeopleService.class);
//启动media_metrics服务：用于收集和管理与媒体应用程序相关的统计数据、指标和信息
mSystemServiceManager.startService(MediaMetricsManagerService.class);
//启动background_install_control服务：应该是从data/bic/states记录的信息进行后台安装？
mSystemServiceManager.startService(BackgroundInstallControlService.class);
//启动media_projection服务：用于屏幕捕获和录制功能的管理。用户可以选择允许或拒绝应用程序对屏幕内容的访问，从而保护用户隐私和安全。这个服务在需要使用屏幕录制或捕获功能的应用程序中发挥着重要作用，如屏幕分享应用、教育应用、游戏录制应用等
mSystemServiceManager.startService(MediaProjectionManagerService.class);

启动状态监控统计相关的服务

//手表特有的一些服务
if (isWatch) {
    mSystemServiceManager.startService(WEAR_POWER_SERVICE_CLASS);
    mSystemServiceManager.startService(HEALTH_SERVICE_CLASS);
    mSystemServiceManager.startService(WEAR_CONNECTIVITY_SERVICE_CLASS);
    mSystemServiceManager.startService(WEAR_DISPLAY_SERVICE_CLASS);
    mSystemServiceManager.startService(WEAR_TIME_SERVICE_CLASS);
    mSystemServiceManager.startService(WEAR_GLOBAL_ACTIONS_SERVICE_CLASS);
}
//启动slice服务：SliceManagerService服务通常用于管理和提供Slice切片功能，它是Android中的一种交互式内容片段，可以显示在系统桌面、通知栏或其他应用程序中，参考https://developer.android.google.cn/guide/slices?hl=zh-cn
if (!mPackageManager.hasSystemFeature(PackageManager.FEATURE_SLICES_DISABLED)) mSystemServiceManager.startService(SLICE_MANAGER_SERVICE_CLASS);
//启动IoTSystemService
if (context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_EMBEDDED)) mSystemServiceManager.startService(IOT_SERVICE_CLASS);
//启动statscompanion和statsmanager服务：StatsCompanion类注册了两个服务，StatsCompanionService和StatsManagerService，他们一起负责管理和协调统计数据的采集、存储和处理工作
mSystemServiceManager.startServiceFromJar(STATS_COMPANION_LIFECYCLE_CLASS, STATS_COMPANION_APEX_PATH);
//启动reboot_readiness服务：RebootReadinessManagerService服务，用于检测设备是否处于空闲状态并且可以重新启动而不会造成用户中断，参考https://source.android.google.cn/docs/core/architecture/modular-system/scheduling?hl=zh-cn
mSystemServiceManager.startServiceFromJar(REBOOT_READINESS_LIFECYCLE_CLASS, SCHEDULING_APEX_PATH);
//StatsPullAtomService服务：SystemService containing PullAtomCallbacks that are registered with statsd ？
mSystemServiceManager.startService(STATS_PULL_ATOM_SERVICE_CLASS);
//启动statsbootstrap服务：StatsBootstrapAtomService服务，用于系统启动时进行初始统计数据拉取和初始化的服务
mSystemServiceManager.startService(STATS_BOOTSTRAP_ATOM_SERVICE_LIFECYCLE_CLASS);
//启动incidentcompanion服务：用于处理系统事件或故障信息的服务。IncidentCompanionService更专注于故障事件的管理和处理，而StatsBootstrapAtomService和StatsPullAtomService则更偏向于数据准备、系统初始化和性能数据拉取方面的工作
mSystemServiceManager.startService(IncidentCompanionService.class);
//启动sdk_sandbox服务：通过SdkSandboxManagerService，开发者可以更好地管理和控制SDK的运行环境，特别是在集成第三方SDK或插件时，以确保外部代码不会对系统造成潜在威胁或风险。
mSystemServiceManager.startService(SDK_SANDBOX_MANAGER_SERVICE_CLASS);
//启动adservices_manager服务：AdServicesManagerService服务，怀疑是广告相关的服务，该服务像/data/system/adservices存储了一些配置
SystemService adServices = mSystemServiceManager.startService(AD_SERVICES_MANAGER_SERVICE_CLASS);
//启动ondevicepersonalization_system_service服务：提供的构建块示例包括政策引擎，用于保护用户数据的入站流量、出站流量和列入许可名单的操作。参考https://source.android.google.cn/docs/core/architecture/modular-system/ondevicepersonalization?hl=pt-br
mSystemServiceManager.startService(ON_DEVICE_PERSONALIZATION_SYSTEM_SERVICE_CLASS);

启动telephone相关服务

//如果使能了安全模式，调用AMS接口进入安全模式
if (safeMode) mActivityManagerService.enterSafeMode();
//启动imms服务：用于处理多媒体短信（Multimedia Messaging Service即彩信）相关的功能和通讯
if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_TELEPHONY)) mmsService = mSystemServiceManager.startService(MmsServiceBroker.class);
//启动autofill服务：AutofillManagerService是自动填充服务。这种功能可以自动识别并填写出现过的数据，例如用户名、密码、地址等，减少用户的重复输入和提高操作效率
if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_AUTOFILL)) mSystemServiceManager.startService(AUTO_FILL_MANAGER_SERVICE_CLASS);
//启动credential服务：CredentialManagerService是用于实现凭据管理服务。通常指用户的身份验证信息，如用户名、密码、API 密钥等，用于确认用户身份或授权用户访问特定资源
if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_CREDENTIALS)) {
    boolean credentialManagerEnabled = DeviceConfig.getBoolean(DeviceConfig.NAMESPACE_CREDENTIAL, CredentialManager.DEVICE_CONFIG_ENABLE_CREDENTIAL_MANAGER, true);
    if (credentialManagerEnabled)  mSystemServiceManager.startService(CREDENTIAL_MANAGER_SERVICE_CLASS);
}
//启动translation服务：TranslationManagerService是用于实现翻译管理的服务。这种服务通常用于处理文本内容的翻译，将文本从一种语言翻译成另一种语言，以满足用户在多语言环境下的需求
if (deviceHasConfigString(context, R.string.config_defaultTranslationService)) mSystemServiceManager.startService(TRANSLATION_MANAGER_SERVICE_CLASS);
//启动selection_toolbar服务：SelectionToolbarManagerService用于实现选择工具栏管理功能。这种服务通常与用户界面中的文本或内容选择交互相关，并提供一系列操作和选项以增强用户在选择文本或内容时的体验和效率
mSystemServiceManager.startService(SELECTION_TOOLBAR_MANAGER_SERVICE_CLASS);
//启动clipboard服务：ClipboardService用于实现剪贴板管理功能。剪贴板是计算机操作系统中的一种缓冲区，用于在不同应用程序之间传递数据、复制和粘贴文本、图像或其他类型的内容
mSystemServiceManager.startService(ClipboardService.class);
//启动app_binding服务：从注释和dump来看，此服务跟SMS有关系。As of android Q, we only use it for the default SMS app.
mSystemServiceManager.startService(AppBindingService.Lifecycle.class);
//启动tracing.proxy服务：此服务是Perfetto工具与systemserver的中介，帮助来抓取trace报告
mSystemServiceManager.startService(TracingServiceProxy.class);

进入PHASE_LOCK_SETTINGS_READY阶段

// It is now time to start up the app processes...
if (lockSettings != null) lockSettings.systemReady();
//system server进程进入PHASE_LOCK_SETTINGS_READY阶段，可以启动应用程序了？
mSystemServiceManager.startBootPhase(t, SystemService.PHASE_LOCK_SETTINGS_READY);

二、SystemServer正常启动日志

1、SystemServerTiming日志封装

如上可以看出一些需要有时序的日志被封装在TimingsTraceAndSlog里面，SystemServer进程直接固定为"SystemServerTiming"。此类的traceBegin对时间搓进行了判断，即在耗时太久的时候会打印"not tracing duration of "，逻辑如下：

    public void traceBegin(String name) {
        assertSameThread();
        Trace.traceBegin(mTraceTag, name);
        if (!DEBUG_BOOT_TIME) return;
        if (mCurrentLevel + 1 >= mMaxNestedCalls) {
            Slog.w(mTag, "not tracing duration of '" + name + "' because already reached "   + mMaxNestedCalls + " levels");
            return;
        }
        mCurrentLevel++;
        mStartNames[mCurrentLevel] = name;
        mStartTimes[mCurrentLevel] = SystemClock.elapsedRealtime();
    }

2、ReadingSystemConfig多线程读取系统配置

SystemServer进程在启动看门狗之后，就开始进行系统配置文件的解析，具体代码如下：

//frameworks/base/services/java/com/android/server/SystemServer.java
// 初始化线程池
SystemServerInitThreadPool tp = SystemServerInitThreadPool.start();
mDumper.addDumpable(tp);  
Slog.i(TAG, "Reading configuration...");
final String TAG_SYSTEM_CONFIG = "ReadingSystemConfig";
t.traceBegin(TAG_SYSTEM_CONFIG);
// 给线程池提交任务：SystemConfig::getInstance
SystemServerInitThreadPool.submit(SystemConfig::getInstance, TAG_SYSTEM_CONFIG);
t.traceEnd()
//frameworks/base/services/core/java/com/android/server/SystemServerInitThreadPool.java
public static @NonNull Future<?> submit(@NonNull Runnable runnable, @NonNull String description) {
        Objects.requireNonNull(description, "description cannot be null");
        SystemServerInitThreadPool instance;
        synchronized (LOCK) {
            Preconditions.checkState(sInstance != null, "Cannot get " + TAG  + " - it has been shut down");
            instance = sInstance;
        }//核心逻辑submitTask,最后还是调用了runnable.run(),这里相当于通过线程启动了SystemConfig::getInstance任务
        return instance.submitTask(runnable, description); 
}

如上代码相当于在线程池中启了SystemConfig.java，从他的代码逻辑可以看出读取etc目录下相关的配置文件

//frameworks/base/services/core/java/com/android/server/SystemConfig.java
//Loads global system configuration info.
//Note: Initializing this class hits the disk and is slow.  This class should generally only be accessed by the system_server process.
public class SystemConfig {
    static final String TAG = "SystemConfig";
    static SystemConfig sInstance;
    SystemConfig() {
        TimingsTraceLog log = new TimingsTraceLog(TAG, Trace.TRACE_TAG_SYSTEM_SERVER);
        log.traceBegin("readAllPermissions");
        try {
            readAllPermissions();
            readPublicNativeLibrariesList();
        } finally {
            log.traceEnd();
        }
    }
    private void readAllPermissions() {
        final XmlPullParser parser = Xml.newPullParser();
        // Read configuration from system
        readPermissions(parser, Environment.buildPath(Environment.getRootDirectory(), "etc", "sysconfig"), ALLOW_ALL);
        // Read configuration from the old permissions dir
        readPermissions(parser, Environment.buildPath(Environment.getRootDirectory(), "etc", "permissions"), ALLOW_ALL);
        // .....省略读取其他分区的etc配置文件
    }
    private void readPublicNativeLibrariesList() {
        readPublicLibrariesListFile(new File("/vendor/etc/public.libraries.txt"));
        String[] dirs = {"/system/etc", "/system_ext/etc", "/product/etc"};
        for (String dir : dirs) {
            File[] files = new File(dir).listFiles();
            if (files == null) {
                Slog.w(TAG, "Public libraries file folder missing: " + dir);
                continue;
            }
            for (File f : files) {
                String name = f.getName();
                if (name.startsWith("public.libraries-") && name.endsWith(".txt")) {
                    readPublicLibrariesListFile(f);
                }
            }
        }
    }}

3、SystemServer启动阶段OnBootPhase

SystemServiceManager维护了改进程的各个状态，具体在 startBootPhase方法中实现：

    //Starts the specified boot phase for all system services that have been started up to this point.
    public void startBootPhase(@NonNull TimingsTraceAndSlog t, int phase) {
        if (phase <= mCurrentPhase) {
            throw new IllegalArgumentException("Next phase must be larger than previous");
        }
        mCurrentPhase = phase;
        Slog.i(TAG, "Starting phase " + mCurrentPhase);
        try {
            t.traceBegin("OnBootPhase_" + phase);
            final int serviceLen = mServices.size();
            for (int i = 0; i < serviceLen; i++) {
                final SystemService service = mServices.get(i);
                long time = SystemClock.elapsedRealtime();
                t.traceBegin("OnBootPhase_" + phase + "_" + service.getClass().getName());
                try {
                    //遍历回调所有服务的onBootPhase方法，各个服务可以在此回调方法中判断当前所处阶段并执行对应需要的逻辑
                    service.onBootPhase(mCurrentPhase); 
                } catch (Exception ex) {
                    throw new RuntimeException("Failed to boot service " + service.getClass().getName() + ": onBootPhase threw an exception during phase " + mCurrentPhase, ex);
                }
                warnIfTooLong(SystemClock.elapsedRealtime() - time, service, "onBootPhase");
                t.traceEnd();
            }
        } finally {
            t.traceEnd();
        }

        if (phase == SystemService.PHASE_BOOT_COMPLETED) {
            final long totalBootTime = SystemClock.uptimeMillis() - mRuntimeStartUptime;
            t.logDuration("TotalBootTime", totalBootTime);
            SystemServerInitThreadPool.shutdown();
        }
    }

所以在每个阶段进入的时候，都会有关键日志：

Starting phase XXX

OnBootPhase_XXX

OnBootPhase_XXX_服务名

1）PHASE_WAIT_FOR_DEFAULT_DISPLAY = 100

The earliest boot phase the system send to system services on boot. 即systemserver进程启动过程中第一个状态，系统启动后等待DMS服务的初始化，调用时间点在SystemService->startBootstrapServices：

搜索了此阶段状态，只有DisplayManagerService里面有去处理回调中此状态，从代码逻辑来看只是简单的阻塞等待DMS初始化完成：

2）PHASE_WAIT_FOR_SENSOR_SERVICE = 200

第二个阶段，阻塞等待Sensor服务的启动，因为此阶段需要调用WMS的main方法，此方法依赖sensor服务（包括加速度计、陀螺仪、磁力传感器）：

搜索了该阶段状态，只有SensorService有去处理回调中此状态，从代码逻辑来看只是简单的等待sensor服务的启动完成，sensor服务的启动在子线程中调用jni的方式来到SensorService.cpp

3）PHASE_LOCK_SETTINGS_READY = 480

4、SystemServer无法找到服务

ArtModuleServiceInitializer.setArtModuleServiceManager(new ArtModuleServiceManager());
ServiceManager.addService(Context.PLATFORM_COMPAT_SERVICE, platformCompat);
mSystemServiceManager.startService(FileIntegrityService.class);

mSystemServiceManager.startService(Installer.class);

5、Slow operation

三、SystemServer dumpsys解读

1、SystemServer的dump

2、其他服务的dump

SystemServer:
  Runtime restart: false
  Start count: 1
  Runtime start-up time: +8s0ms
  Runtime start-elapsed time: +8s0ms

SystemServiceManager:
  Current phase: 1000
  Current user not set!
  1 target users: 0(full)
  172 started services:
    com.transsion.hubcore.server.TranBootstrapServiceManagerService
    com.android.server.security.FileIntegrityService
    com.android.server.pm.Installer
    com.android.server.os.DeviceIdentifiersPolicyService
    com.android.server.uri.UriGrantsManagerService.Lifecycle
    com.android.server.powerstats.PowerStatsService
    com.android.server.permission.access.AccessCheckingService
    com.android.server.wm.ActivityTaskManagerService.Lifecycle
    com.android.server.am.ActivityManagerService.Lifecycle
    ......

com.android.server.Watchdog:
  WatchdogTimeoutMillis=60000

SystemServerInitThreadPool:
  has instance: false
  number of threads: 8
  service: java.util.concurrent.ThreadPoolExecutor@7bf04fb[Terminated, pool size = 0, active threads = 0, queued tasks = 0, completed tasks = 351]
  is shutdown: true
  no pending tasks

AdServices:
  mAdServicesModuleName: com.google.android.adservices
  mAdServicesModuleVersion: 341131050
  mHandlerThread: Thread[AdServicesManagerServiceHandler,5,main]
  mAdServicesPackagesRolledBackFrom: {}
  mAdServicesPackagesRolledBackTo: {}
  ShellCmd enabled: false
  UserInstanceManager
    mAdServicesBaseDir: /data/system/adservices
    mConsentManagerMapLocked: {}
    mAppConsentManagerMapLocked: {}
    mRollbackHandlingManagerMapLocked: {}
    mBlockedTopicsManagerMapLocked={}
    TopicsDbHelper
      CURRENT_DATABASE_VERSION: 1
      mDbFile: /data/system/adservices_topics.db
      mDbVersion: 1