1.启动流程：

请参考：https://blog.csdn.net/zhao5214319/article/details/90448185

文章中介绍了Zygote的启动流程，并介绍了SystemService进程的Fork流程，进程创建后开始调用main方法开始运行

2.构造方法：

主要是初始化了2个属性：

1.mFactoryTestMode 是否是工厂的测试模式

2.mRuntimeRestart 是否是第一次启动

3.run方法：

初始化系统时间最早为1970年
初始化时区为GMT
初始化预言、国家、区域
初始化内存阀值
初始化指纹配置
设置Environment环境变量的获取限制，使用此功能必须指定user
设置Bundle中使用空的Bundle来替代抛出BadParcelableException，并在日志中记录
设置来电必须在前台进行
设置系统服务中最大的Binder线程数为31
创建Looper并设置优先级为前台
加载系统服务运行需要的native库
创建ActivityThread和SystemContext
创建SystemServiceManager
准备线程池，为启动其他服务做准备（并行的）
启动3个级别的所有服务，启动完成后销毁线程池
Looper等待消息进行处理

源生代码：

 private void run() {
278        try {
279            traceBeginAndSlog("InitBeforeStartServices");
280            // If a device's clock is before 1970 (before 0), a lot of
281            // APIs crash dealing with negative numbers, notably
282            // java.io.File#setLastModified, so instead we fake it and
283            // hope that time from cell towers or NTP fixes it shortly.
284            if (System.currentTimeMillis() < EARLIEST_SUPPORTED_TIME) {
285                Slog.w(TAG, "System clock is before 1970; setting to 1970.");
286                SystemClock.setCurrentTimeMillis(EARLIEST_SUPPORTED_TIME);
287            }
288
289            //
290            // Default the timezone property to GMT if not set.
291            //
292            String timezoneProperty =  SystemProperties.get("persist.sys.timezone");
293            if (timezoneProperty == null || timezoneProperty.isEmpty()) {
294                Slog.w(TAG, "Timezone not set; setting to GMT.");
295                SystemProperties.set("persist.sys.timezone", "GMT");
296            }
297
298            // If the system has "persist.sys.language" and friends set, replace them with
299            // "persist.sys.locale". Note that the default locale at this point is calculated
300            // using the "-Duser.locale" command line flag. That flag is usually populated by
301            // AndroidRuntime using the same set of system properties, but only the system_server
302            // and system apps are allowed to set them.
303            //
304            // NOTE: Most changes made here will need an equivalent change to
305            // core/jni/AndroidRuntime.cpp
306            if (!SystemProperties.get("persist.sys.language").isEmpty()) {
307                final String languageTag = Locale.getDefault().toLanguageTag();
308
309                SystemProperties.set("persist.sys.locale", languageTag);
310                SystemProperties.set("persist.sys.language", "");
311                SystemProperties.set("persist.sys.country", "");
312                SystemProperties.set("persist.sys.localevar", "");
313            }
314
315            // The system server should never make non-oneway calls
316            Binder.setWarnOnBlocking(true);
317
318            // Here we go!
319            Slog.i(TAG, "Entered the Android system server!");
320            int uptimeMillis = (int) SystemClock.elapsedRealtime();
321            EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_SYSTEM_RUN, uptimeMillis);
322            if (!mRuntimeRestart) {
323                MetricsLogger.histogram(null, "boot_system_server_init", uptimeMillis);
324            }
325
326            // In case the runtime switched since last boot (such as when
327            // the old runtime was removed in an OTA), set the system
328            // property so that it is in sync. We can | xq oqi't do this in
329            // libnativehelper's JniInvocation::Init code where we already
330            // had to fallback to a different runtime because it is
331            // running as root and we need to be the system user to set
332            // the property. http://b/11463182
333            SystemProperties.set("persist.sys.dalvik.vm.lib.2", VMRuntime.getRuntime().vmLibrary());
334
335            // Mmmmmm... more memory!
336            VMRuntime.getRuntime().clearGrowthLimit();
337
338            // The system server has to run all of the time, so it needs to be
339            // as efficient as possible with its memory usage.
340            VMRuntime.getRuntime().setTargetHeapUtilization(0.8f);
341
342            // Some devices rely on runtime fingerprint generation, so make sure
343            // we've defined it before booting further.
344            Build.ensureFingerprintProperty();
345
346            // Within the system server, it is an error to access Environment paths without
347            // explicitly specifying a user.
348            Environment.setUserRequired(true);
349
350            // Within the system server, any incoming Bundles should be defused
351            // to avoid throwing BadParcelableException.
352            BaseBundle.setShouldDefuse(true);
353
354            // Ensure binder calls into the system always run at foreground priority.
355            BinderInternal.disableBackgroundScheduling(true);
356
357            // Increase the number of binder threads in system_server
358            BinderInternal.setMaxThreads(sMaxBinderThreads);
359
360            // Prepare the main looper thread (this thread).
361            android.os.Process.setThreadPriority(
362                android.os.Process.THREAD_PRIORITY_FOREGROUND);
363            android.os.Process.setCanSelfBackground(false);
364            Looper.prepareMainLooper();
365
366            // Initialize native services.
367            System.loadLibrary("android_servers");
368
369            // Check whether we failed to shut down last time we tried.
370            // This call may not return.
371            performPendingShutdown();
372
373            // Initialize the system context.
374            createSystemContext();
375
376            // Create the system service manager.
377            mSystemServiceManager = new SystemServiceManager(mSystemContext);
378            mSystemServiceManager.setRuntimeRestarted(mRuntimeRestart);
379            LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
380            // Prepare the thread pool for init tasks that can be parallelized
381            SystemServerInitThreadPool.get();
382        } finally {
383            traceEnd();  // InitBeforeStartServices
384        }
385
386        // Start services.
387        try {
388            traceBeginAndSlog("StartServices");
389            startBootstrapServices();
390            startCoreServices();
391            startOtherServices();
392            SystemServerInitThreadPool.shutdown();
393        } catch (Throwable ex) {
394            Slog.e("System", "******************************************");
395            Slog.e("System", "************ Failure starting system services", ex);
396            throw ex;
397        } finally {
398            traceEnd();
399        }
400
401        // For debug builds, log event loop stalls to dropbox for analysis.
402        if (StrictMode.conditionallyEnableDebugLogging()) {
403            Slog.i(TAG, "Enabled StrictMode for system server main thread.");
404        }
405        if (!mRuntimeRestart && !isFirstBootOrUpgrade()) {
406            int uptimeMillis = (int) SystemClock.elapsedRealtime();
407            MetricsLogger.histogram(null, "boot_system_server_ready", uptimeMillis);
408            final int MAX_UPTIME_MILLIS = 60 * 1000;
409            if (uptimeMillis > MAX_UPTIME_MILLIS) {
410                Slog.wtf(SYSTEM_SERVER_TIMING_TAG,
411                        "SystemServer init took too long. uptimeMillis=" + uptimeMillis);
412            }
413        }
414
415        // Loop forever.
416        Looper.loop();
417        throw new RuntimeException("Main thread loop unexpectedly exited");
418    }

4.startBootstrapServices启动引导服务：

加载系统配置与权限限制
启动APK安装服务
启动设备管理服务
启动ActivityMangerService android四大基本组件的运行都依赖此服务
启动PowerManagerService 电源管理服务例如电池状态更新等
启动RecoveryMangerService 与Recovery小系统交互的服务主要有升级、恢复出厂设置、清除数据等功能
启动LightsService LED灯管理服务
启动DisplayManagerService 显示管理服务
启动PackageManagerService
启动UserManagerSercie
启动OverlayManagerSercice
启动传感器相关服务

源码如下：

492    /**
493     * Starts the small tangle of critical services that are needed to get
494     * the system off the ground.  These services have complex mutual dependencies
495     * which is why we initialize them all in one place here.  Unless your service
496     * is also entwined in these dependencies, it should be initialized in one of
497     * the other functions.
498     */
499    private void startBootstrapServices() {
500        Slog.i(TAG, "Reading configuration...");
501        final String TAG_SYSTEM_CONFIG = "ReadingSystemConfig";
502        traceBeginAndSlog(TAG_SYSTEM_CONFIG);
503        SystemServerInitThreadPool.get().submit(SystemConfig::getInstance, TAG_SYSTEM_CONFIG);
504        traceEnd();
505
506        // Wait for installd to finish starting up so that it has a chance to
507        // create critical directories such as /data/user with the appropriate
508        // permissions.  We need this to complete before we initialize other services.
509        traceBeginAndSlog("StartInstaller");
510        Installer installer = mSystemServiceManager.startService(Installer.class);
511        traceEnd();
512
513        // In some cases after launching an app we need to access device identifiers,
514        // therefore register the device identifier policy before the activity manager.
515        traceBeginAndSlog("DeviceIdentifiersPolicyService");
516        mSystemServiceManager.startService(DeviceIdentifiersPolicyService.class);
517        traceEnd();
518
519        // Activity manager runs the show.
520        traceBeginAndSlog("StartActivityManager");
521        mActivityManagerService = mSystemServiceManager.startService(
522                ActivityManagerService.Lifecycle.class).getService();
523        mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
524        mActivityManagerService.setInstaller(installer);
525        traceEnd();
526
527        // Power manager needs to be started early because other services need it.
528        // Native daemons may be watching for it to be registered so it must be ready
529        // to handle incoming binder calls immediately (including being able to verify
530        // the permissions for those calls).
531        traceBeginAndSlog("StartPowerManager");
532        mPowerManagerService = mSystemServiceManager.startService(PowerManagerService.class);
533        traceEnd();
534
535        // Now that the power manager has been started, let the activity manager
536        // initialize power management features.
537        traceBeginAndSlog("InitPowerManagement");
538        mActivityManagerService.initPowerManagement();
539        traceEnd();
540
541        // Bring up recovery system in case a rescue party needs a reboot
542        if (!SystemProperties.getBoolean("config.disable_noncore", false)) {
543            traceBeginAndSlog("StartRecoverySystemService");
544            mSystemServiceManager.startService(RecoverySystemService.class);
545            traceEnd();
546        }
547
548        // Now that we have the bare essentials of the OS up and running, take
549        // note that we just booted, which might send out a rescue party if
550        // we're stuck in a runtime restart loop.
551        RescueParty.noteBoot(mSystemContext);
552
553        // Manages LEDs and display backlight so we need it to bring up the display.
554        traceBeginAndSlog("StartLightsService");
555        mSystemServiceManager.startService(LightsService.class);
556        traceEnd();
557
558        // Display manager is needed to provide display metrics before package manager
559        // starts up.
560        traceBeginAndSlog("StartDisplayManager");
561        mDisplayManagerService = mSystemServiceManager.startService(DisplayManagerService.class);
562        traceEnd();
563
564        // We need the default display before we can initialize the package manager.
565        traceBeginAndSlog("WaitForDisplay");
566        mSystemServiceManager.startBootPhase(SystemService.PHASE_WAIT_FOR_DEFAULT_DISPLAY);
567        traceEnd();
568
569        // Only run "core" apps if we're encrypting the device.
570        String cryptState = SystemProperties.get("vold.decrypt");
571        if (ENCRYPTING_STATE.equals(cryptState)) {
572            Slog.w(TAG, "Detected encryption in progress - only parsing core apps");
573            mOnlyCore = true;
574        } else if (ENCRYPTED_STATE.equals(cryptState)) {
575            Slog.w(TAG, "Device encrypted - only parsing core apps");
576            mOnlyCore = true;
577        }
578
579        // Start the package manager.
580        if (!mRuntimeRestart) {
581            MetricsLogger.histogram(null, "boot_package_manager_init_start",
582                    (int) SystemClock.elapsedRealtime());
583        }
584        traceBeginAndSlog("StartPackageManagerService");
585        mPackageManagerService = PackageManagerService.main(mSystemContext, installer,
586                mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF, mOnlyCore);
587        mFirstBoot = mPackageManagerService.isFirstBoot();
588        mPackageManager = mSystemContext.getPackageManager();
589        traceEnd();
590        if (!mRuntimeRestart && !isFirstBootOrUpgrade()) {
591            MetricsLogger.histogram(null, "boot_package_manager_init_ready",
592                    (int) SystemClock.elapsedRealtime());
593        }
594        // Manages A/B OTA dexopting. This is a bootstrap service as we need it to rename
595        // A/B artifacts after boot, before anything else might touch/need them.
596        // Note: this isn't needed during decryption (we don't have /data anyways).
597        if (!mOnlyCore) {
598            boolean disableOtaDexopt = SystemProperties.getBoolean("config.disable_otadexopt",
599                    false);
600            if (!disableOtaDexopt) {
601                traceBeginAndSlog("StartOtaDexOptService");
602                try {
603                    OtaDexoptService.main(mSystemContext, mPackageManagerService);
604                } catch (Throwable e) {
605                    reportWtf("starting OtaDexOptService", e);
606                } finally {
607                    traceEnd();
608                }
609            }
610        }
611
612        traceBeginAndSlog("StartUserManagerService");
613        mSystemServiceManager.startService(UserManagerService.LifeCycle.class);
614        traceEnd();
615
616        // Initialize attribute cache used to cache resources from packages.
617        traceBeginAndSlog("InitAttributerCache");
618        AttributeCache.init(mSystemContext);
619        traceEnd();
620
621        // Set up the Application instance for the system process and get started.
622        traceBeginAndSlog("SetSystemProcess");
623        mActivityManagerService.setSystemProcess();
624        traceEnd();
625
626        // DisplayManagerService needs to setup android.display scheduling related policies
627        // since setSystemProcess() would have overridden policies due to setProcessGroup
628        mDisplayManagerService.setupSchedulerPolicies();
629
630        // Manages Overlay packages
631        traceBeginAndSlog("StartOverlayManagerService");
632        mSystemServiceManager.startService(new OverlayManagerService(mSystemContext, installer));
633        traceEnd();
634
635        // The sensor service needs access to package manager service, app ops
636        // service, and permissions service, therefore we start it after them.
637        // Start sensor service in a separate thread. Completion should be checked
638        // before using it.
639        mSensorServiceStart = SystemServerInitThreadPool.get().submit(() -> {
640            TimingsTraceLog traceLog = new TimingsTraceLog(
641                    SYSTEM_SERVER_TIMING_ASYNC_TAG, Trace.TRACE_TAG_SYSTEM_SERVER);
642            traceLog.traceBegin(START_SENSOR_SERVICE);
643            startSensorService();
644            traceLog.traceEnd();
645        }, START_SENSOR_SERVICE);
646    }

5.startCoreServices请核心服务：

启动DropBoxManagerServices crash服务
启动BatteryService 电池服务
启动UsagestatsService 统计使用数据服务
启动WebViewUpdateService WebView刷新服务

源码如下：

648    /**
649     * Starts some essential services that are not tangled up in the bootstrap process.
650     */
651    private void startCoreServices() {
652        // Records errors and logs, for example wtf()
653        traceBeginAndSlog("StartDropBoxManager");
654        mSystemServiceManager.startService(DropBoxManagerService.class);
655        traceEnd();
656
657        traceBeginAndSlog("StartBatteryService");
658        // Tracks the battery level.  Requires LightService.
659        mSystemServiceManager.startService(BatteryService.class);
660        traceEnd();
661
662        // Tracks application usage stats.
663        traceBeginAndSlog("StartUsageService");
664        mSystemServiceManager.startService(UsageStatsService.class);
665        mActivityManagerService.setUsageStatsManager(
666                LocalServices.getService(UsageStatsManagerInternal.class));
667        traceEnd();
668
669        // Tracks whether the updatable WebView is in a ready state and watches for update installs.
670        traceBeginAndSlog("StartWebViewUpdateService");
671        mWebViewUpdateService = mSystemServiceManager.startService(WebViewUpdateService.class);
672        traceEnd();
673    }

6.startOtherServices启动其他服务：

Android剩余的服务都在这个方法中启动，并完成所有服务的Ready状态，服务类型不详细介绍，大约分为以下几类(自己见解，以后不断的学习优化)：

网络相关服务（包含WIFI）
相机相关服务
媒体相关服务
设备管理服务
设置相关服务
电话相关服务
短彩信相关服务
磁盘，端口相关服务
其他服务

源代码如下：

675    /**
676     * Starts a miscellaneous grab bag of stuff that has yet to be refactored
677     * and organized.
678     */
679    private void startOtherServices() {
680        final Context context = mSystemContext;
681        VibratorService vibrator = null;
682        IStorageManager storageManager = null;
683        NetworkManagementService networkManagement = null;
684        NetworkStatsService networkStats = null;
685        NetworkPolicyManagerService networkPolicy = null;
686        ConnectivityService connectivity = null;
687        NetworkScoreService networkScore = null;
688        NsdService serviceDiscovery= null;
689        WindowManagerService wm = null;
690        SerialService serial = null;
691        NetworkTimeUpdateService networkTimeUpdater = null;
692        CommonTimeManagementService commonTimeMgmtService = null;
693        InputManagerService inputManager = null;
694        TelephonyRegistry telephonyRegistry = null;
695        ConsumerIrService consumerIr = null;
696        MmsServiceBroker mmsService = null;
697        HardwarePropertiesManagerService hardwarePropertiesService = null;
698
699        boolean disableStorage = SystemProperties.getBoolean("config.disable_storage", false);
700        boolean disableBluetooth = SystemProperties.getBoolean("config.disable_bluetooth", false);
701        boolean disableLocation = SystemProperties.getBoolean("config.disable_location", false);
702        boolean disableSystemUI = SystemProperties.getBoolean("config.disable_systemui", false);
703        boolean disableNonCoreServices = SystemProperties.getBoolean("config.disable_noncore", false);
704        boolean disableNetwork = SystemProperties.getBoolean("config.disable_network", false);
705        boolean disableNetworkTime = SystemProperties.getBoolean("config.disable_networktime", false);
706        boolean disableRtt = SystemProperties.getBoolean("config.disable_rtt", false);
707        boolean disableMediaProjection = SystemProperties.getBoolean("config.disable_mediaproj",
708                false);
709        boolean disableSerial = SystemProperties.getBoolean("config.disable_serial", false);
710        boolean disableSearchManager = SystemProperties.getBoolean("config.disable_searchmanager",
711                false);
712        boolean disableTrustManager = SystemProperties.getBoolean("config.disable_trustmanager",
713                false);
714        boolean disableTextServices = SystemProperties.getBoolean("config.disable_textservices",
715                false);
716        boolean disableConsumerIr = SystemProperties.getBoolean("config.disable_consumerir", false);
717        boolean disableVrManager = SystemProperties.getBoolean("config.disable_vrmanager", false);
718        boolean disableCameraService = SystemProperties.getBoolean("config.disable_cameraservice",
719                false);
720        boolean enableLeftyService = SystemProperties.getBoolean("config.enable_lefty", false);
721
722        boolean isEmulator = SystemProperties.get("ro.kernel.qemu").equals("1");
723
724        // For debugging RescueParty
725        if (Build.IS_DEBUGGABLE && SystemProperties.getBoolean("debug.crash_system", false)) {
726            throw new RuntimeException();
727        }
728
729        try {
730            final String SECONDARY_ZYGOTE_PRELOAD = "SecondaryZygotePreload";
731            // We start the preload ~1s before the webview factory preparation, to
732            // ensure that it completes before the 32 bit relro process is forked
733            // from the zygote. In the event that it takes too long, the webview
734            // RELRO process will block, but it will do so without holding any locks.
735            mZygotePreload = SystemServerInitThreadPool.get().submit(() -> {
736                try {
737                    Slog.i(TAG, SECONDARY_ZYGOTE_PRELOAD);
738                    TimingsTraceLog traceLog = new TimingsTraceLog(
739                            SYSTEM_SERVER_TIMING_ASYNC_TAG, Trace.TRACE_TAG_SYSTEM_SERVER);
740                    traceLog.traceBegin(SECONDARY_ZYGOTE_PRELOAD);
741                    if (!Process.zygoteProcess.preloadDefault(Build.SUPPORTED_32_BIT_ABIS[0])) {
742                        Slog.e(TAG, "Unable to preload default resources");
743                    }
744                    traceLog.traceEnd();
745                } catch (Exception ex) {
746                    Slog.e(TAG, "Exception preloading default resources", ex);
747                }
748            }, SECONDARY_ZYGOTE_PRELOAD);
749
750            traceBeginAndSlog("StartKeyAttestationApplicationIdProviderService");
751            ServiceManager.addService("sec_key_att_app_id_provider",
752                    new KeyAttestationApplicationIdProviderService(context));
753            traceEnd();
754
755            traceBeginAndSlog("StartKeyChainSystemService");
756            mSystemServiceManager.startService(KeyChainSystemService.class);
757            traceEnd();
758
759            traceBeginAndSlog("StartSchedulingPolicyService");
760            ServiceManager.addService("scheduling_policy", new SchedulingPolicyService());
761            traceEnd();
762
763            traceBeginAndSlog("StartTelecomLoaderService");
764            mSystemServiceManager.startService(TelecomLoaderService.class);
765            traceEnd();
766
767            traceBeginAndSlog("StartTelephonyRegistry");
768            telephonyRegistry = new TelephonyRegistry(context);
769            ServiceManager.addService("telephony.registry", telephonyRegistry);
770            traceEnd();
771
772            traceBeginAndSlog("StartEntropyMixer");
773            mEntropyMixer = new EntropyMixer(context);
774            traceEnd();
775
776            mContentResolver = context.getContentResolver();
777
778            // The AccountManager must come before the ContentService
779            traceBeginAndSlog("StartAccountManagerService");
780            mSystemServiceManager.startService(ACCOUNT_SERVICE_CLASS);
781            traceEnd();
782
783            traceBeginAndSlog("StartContentService");
784            mSystemServiceManager.startService(CONTENT_SERVICE_CLASS);
785            traceEnd();
786
787            traceBeginAndSlog("InstallSystemProviders");
788            mActivityManagerService.installSystemProviders();
789            traceEnd();
790
791            traceBeginAndSlog("StartVibratorService");
792            vibrator = new VibratorService(context);
793            ServiceManager.addService("vibrator", vibrator);
794            traceEnd();
795
796            if (!disableConsumerIr) {
797                traceBeginAndSlog("StartConsumerIrService");
798                consumerIr = new ConsumerIrService(context);
799                ServiceManager.addService(Context.CONSUMER_IR_SERVICE, consumerIr);
800                traceEnd();
801            }
802
803            traceBeginAndSlog("StartAlarmManagerService");
804            mSystemServiceManager.startService(AlarmManagerService.class);
805            traceEnd();
806
807            traceBeginAndSlog("InitWatchdog");
808            final Watchdog watchdog = Watchdog.getInstance();
809            watchdog.init(context, mActivityManagerService);
810            traceEnd();
811
812            traceBeginAndSlog("StartInputManagerService");
813            inputManager = new InputManagerService(context);
814            traceEnd();
815
816            traceBeginAndSlog("StartWindowManagerService");
817            // WMS needs sensor service ready
818            ConcurrentUtils.waitForFutureNoInterrupt(mSensorServiceStart, START_SENSOR_SERVICE);
819            mSensorServiceStart = null;
820            wm = WindowManagerService.main(context, inputManager,
821                    mFactoryTestMode != FactoryTest.FACTORY_TEST_LOW_LEVEL,
822                    !mFirstBoot, mOnlyCore, new PhoneWindowManager());
823            ServiceManager.addService(Context.WINDOW_SERVICE, wm);
824            ServiceManager.addService(Context.INPUT_SERVICE, inputManager);
825            traceEnd();
826
827            // Start receiving calls from HIDL services. Start in in a separate thread
828            // because it need to connect to SensorManager. This have to start
829            // after START_SENSOR_SERVICE is done.
830            SystemServerInitThreadPool.get().submit(() -> {
831                TimingsTraceLog traceLog = new TimingsTraceLog(
832                        SYSTEM_SERVER_TIMING_ASYNC_TAG, Trace.TRACE_TAG_SYSTEM_SERVER);
833                traceLog.traceBegin(START_HIDL_SERVICES);
834                startHidlServices();
835                traceLog.traceEnd();
836            }, START_HIDL_SERVICES);
837
838            if (!disableVrManager) {
839                traceBeginAndSlog("StartVrManagerService");
840                mSystemServiceManager.startService(VrManagerService.class);
841                traceEnd();
842            }
843
844            traceBeginAndSlog("SetWindowManagerService");
845            mActivityManagerService.setWindowManager(wm);
846            traceEnd();
847
848            traceBeginAndSlog("StartInputManager");
849            inputManager.setWindowManagerCallbacks(wm.getInputMonitor());
850            inputManager.start();
851            traceEnd();
852
853            // TODO: Use service dependencies instead.
854            traceBeginAndSlog("DisplayManagerWindowManagerAndInputReady");
855            mDisplayManagerService.windowManagerAndInputReady();
856            traceEnd();
857
858            // Skip Bluetooth if we have an emulator kernel
859            // TODO: Use a more reliable check to see if this product should
860            // support Bluetooth - see bug 988521
861            if (isEmulator) {
862                Slog.i(TAG, "No Bluetooth Service (emulator)");
863            } else if (mFactoryTestMode == FactoryTest.FACTORY_TEST_LOW_LEVEL) {
864                Slog.i(TAG, "No Bluetooth Service (factory test)");
865            } else if (!context.getPackageManager().hasSystemFeature
866                       (PackageManager.FEATURE_BLUETOOTH)) {
867                Slog.i(TAG, "No Bluetooth Service (Bluetooth Hardware Not Present)");
868            } else if (disableBluetooth) {
869                Slog.i(TAG, "Bluetooth Service disabled by config");
870            } else {
871                traceBeginAndSlog("StartBluetoothService");
872                mSystemServiceManager.startService(BluetoothService.class);
873                traceEnd();
874            }
875
876            traceBeginAndSlog("IpConnectivityMetrics");
877            mSystemServiceManager.startService(IpConnectivityMetrics.class);
878            traceEnd();
879
880            traceBeginAndSlog("PinnerService");
881            mSystemServiceManager.startService(PinnerService.class);
882            traceEnd();
883        } catch (RuntimeException e) {
884            Slog.e("System", "******************************************");
885            Slog.e("System", "************ Failure starting core service", e);
886        }
887
888        StatusBarManagerService statusBar = null;
889        INotificationManager notification = null;
890        LocationManagerService location = null;
891        CountryDetectorService countryDetector = null;
892        ILockSettings lockSettings = null;
893        MediaRouterService mediaRouter = null;
894
895        // Bring up services needed for UI.
896        if (mFactoryTestMode != FactoryTest.FACTORY_TEST_LOW_LEVEL) {
897            traceBeginAndSlog("StartInputMethodManagerLifecycle");
898            mSystemServiceManager.startService(InputMethodManagerService.Lifecycle.class);
899            traceEnd();
900
901            traceBeginAndSlog("StartAccessibilityManagerService");
902            try {
903                ServiceManager.addService(Context.ACCESSIBILITY_SERVICE,
904                        new AccessibilityManagerService(context));
905            } catch (Throwable e) {
906                reportWtf("starting Accessibility Manager", e);
907            }
908            traceEnd();
909        }
910
911        traceBeginAndSlog("MakeDisplayReady");
912        try {
913            wm.displayReady();
914        } catch (Throwable e) {
915            reportWtf("making display ready", e);
916        }
917        traceEnd();
918
919        if (mFactoryTestMode != FactoryTest.FACTORY_TEST_LOW_LEVEL) {
920            if (!disableStorage &&
921                    !"0".equals(SystemProperties.get("system_init.startmountservice"))) {
922                traceBeginAndSlog("StartStorageManagerService");
923                try {
924                    /*
925                     * NotificationManagerService is dependant on StorageManagerService,
926                     * (for media / usb notifications) so we must start StorageManagerService first.
927                     */
928                    mSystemServiceManager.startService(STORAGE_MANAGER_SERVICE_CLASS);
929                    storageManager = IStorageManager.Stub.asInterface(
930                            ServiceManager.getService("mount"));
931                } catch (Throwable e) {
932                    reportWtf("starting StorageManagerService", e);
933                }
934                traceEnd();
935
936                traceBeginAndSlog("StartStorageStatsService");
937                try {
938                    mSystemServiceManager.startService(STORAGE_STATS_SERVICE_CLASS);
939                } catch (Throwable e) {
940                    reportWtf("starting StorageStatsService", e);
941                }
942                traceEnd();
943            }
944        }
945
946        // We start this here so that we update our configuration to set watch or television
947        // as appropriate.
948        traceBeginAndSlog("StartUiModeManager");
949        mSystemServiceManager.startService(UiModeManagerService.class);
950        traceEnd();
951
952        if (!mOnlyCore) {
953            traceBeginAndSlog("UpdatePackagesIfNeeded");
954            try {
955                mPackageManagerService.updatePackagesIfNeeded();
956            } catch (Throwable e) {
957                reportWtf("update packages", e);
958            }
959            traceEnd();
960        }
961
962        traceBeginAndSlog("PerformFstrimIfNeeded");
963        try {
964            mPackageManagerService.performFstrimIfNeeded();
965        } catch (Throwable e) {
966            reportWtf("performing fstrim", e);
967        }
968        traceEnd();
969
970        if (mFactoryTestMode != FactoryTest.FACTORY_TEST_LOW_LEVEL) {
971            if (!disableNonCoreServices) {
972                traceBeginAndSlog("StartLockSettingsService");
973                try {
974                    mSystemServiceManager.startService(LOCK_SETTINGS_SERVICE_CLASS);
975                    lockSettings = ILockSettings.Stub.asInterface(
976                            ServiceManager.getService("lock_settings"));
977                } catch (Throwable e) {
978                    reportWtf("starting LockSettingsService service", e);
979                }
980                traceEnd();
981
982                final boolean hasPdb = !SystemProperties.get(PERSISTENT_DATA_BLOCK_PROP).equals("");
983                if (hasPdb) {
984                    traceBeginAndSlog("StartPersistentDataBlock");
985                    mSystemServiceManager.startService(PersistentDataBlockService.class);
986                    traceEnd();
987                }
988
989                if (hasPdb || OemLockService.isHalPresent()) {
990                    // Implementation depends on pdb or the OemLock HAL
991                    traceBeginAndSlog("StartOemLockService");
992                    mSystemServiceManager.startService(OemLockService.class);
993                    traceEnd();
994                }
995
996                traceBeginAndSlog("StartDeviceIdleController");
997                mSystemServiceManager.startService(DeviceIdleController.class);
998                traceEnd();
999
1000                // Always start the Device Policy Manager, so that the API is compatible with
1001                // API8.
1002                traceBeginAndSlog("StartDevicePolicyManager");
1003                mSystemServiceManager.startService(DevicePolicyManagerService.Lifecycle.class);
1004                traceEnd();
1005            }
1006
1007            if (!disableSystemUI) {
1008                traceBeginAndSlog("StartStatusBarManagerService");
1009                try {
1010                    statusBar = new StatusBarManagerService(context, wm);
1011                    ServiceManager.addService(Context.STATUS_BAR_SERVICE, statusBar);
1012                } catch (Throwable e) {
1013                    reportWtf("starting StatusBarManagerService", e);
1014                }
1015                traceEnd();
1016            }
1017
1018            if (!disableNonCoreServices) {
1019                traceBeginAndSlog("StartClipboardService");
1020                mSystemServiceManager.startService(ClipboardService.class);
1021                traceEnd();
1022            }
1023
1024            if (!disableNetwork) {
1025                traceBeginAndSlog("StartNetworkManagementService");
1026                try {
1027                    networkManagement = NetworkManagementService.create(context);
1028                    ServiceManager.addService(Context.NETWORKMANAGEMENT_SERVICE, networkManagement);
1029                } catch (Throwable e) {
1030                    reportWtf("starting NetworkManagement Service", e);
1031                }
1032                traceEnd();
1033            }
1034
1035            if (!disableNonCoreServices && !disableTextServices) {
1036                traceBeginAndSlog("StartTextServicesManager");
1037                mSystemServiceManager.startService(TextServicesManagerService.Lifecycle.class);
1038                traceEnd();
1039            }
1040
1041            if (!disableNetwork) {
1042                traceBeginAndSlog("StartNetworkScoreService");
1043                try {
1044                    networkScore = new NetworkScoreService(context);
1045                    ServiceManager.addService(Context.NETWORK_SCORE_SERVICE, networkScore);
1046                } catch (Throwable e) {
1047                    reportWtf("starting Network Score Service", e);
1048                }
1049                traceEnd();
1050
1051                traceBeginAndSlog("StartNetworkStatsService");
1052                try {
1053                    networkStats = NetworkStatsService.create(context, networkManagement);
1054                    ServiceManager.addService(Context.NETWORK_STATS_SERVICE, networkStats);
1055                } catch (Throwable e) {
1056                    reportWtf("starting NetworkStats Service", e);
1057                }
1058                traceEnd();
1059
1060                traceBeginAndSlog("StartNetworkPolicyManagerService");
1061                try {
1062                    networkPolicy = new NetworkPolicyManagerService(context,
1063                            mActivityManagerService, networkStats, networkManagement);
1064                    ServiceManager.addService(Context.NETWORK_POLICY_SERVICE, networkPolicy);
1065                } catch (Throwable e) {
1066                    reportWtf("starting NetworkPolicy Service", e);
1067                }
1068                traceEnd();
1069
1070                // Wifi Service must be started first for wifi-related services.
1071                traceBeginAndSlog("StartWifi");
1072                mSystemServiceManager.startService(WIFI_SERVICE_CLASS);
1073                traceEnd();
1074                traceBeginAndSlog("StartWifiScanning");
1075                mSystemServiceManager.startService(
1076                        "com.android.server.wifi.scanner.WifiScanningService");
1077                traceEnd();
1078
1079                if (!disableRtt) {
1080                    traceBeginAndSlog("StartWifiRtt");
1081                    mSystemServiceManager.startService("com.android.server.wifi.RttService");
1082                    traceEnd();
1083                }
1084
1085                if (context.getPackageManager().hasSystemFeature(
1086                        PackageManager.FEATURE_WIFI_AWARE)) {
1087                    traceBeginAndSlog("StartWifiAware");
1088                    mSystemServiceManager.startService(WIFI_AWARE_SERVICE_CLASS);
1089                    traceEnd();
1090                } else {
1091                    Slog.i(TAG, "No Wi-Fi Aware Service (Aware support Not Present)");
1092                }
1093
1094                if (context.getPackageManager().hasSystemFeature(
1095                        PackageManager.FEATURE_WIFI_DIRECT)) {
1096                    traceBeginAndSlog("StartWifiP2P");
1097                    mSystemServiceManager.startService(WIFI_P2P_SERVICE_CLASS);
1098                    traceEnd();
1099                }
1100
1101                if (context.getPackageManager().hasSystemFeature(
1102                        PackageManager.FEATURE_LOWPAN)) {
1103                    traceBeginAndSlog("StartLowpan");
1104                    mSystemServiceManager.startService(LOWPAN_SERVICE_CLASS);
1105                    traceEnd();
1106                }
1107
1108                if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_ETHERNET) ||
1109                    mPackageManager.hasSystemFeature(PackageManager.FEATURE_USB_HOST)) {
1110                    traceBeginAndSlog("StartEthernet");
1111                    mSystemServiceManager.startService(ETHERNET_SERVICE_CLASS);
1112                    traceEnd();
1113                }
1114
1115                traceBeginAndSlog("StartConnectivityService");
1116                try {
1117                    connectivity = new ConnectivityService(
1118                            context, networkManagement, networkStats, networkPolicy);
1119                    ServiceManager.addService(Context.CONNECTIVITY_SERVICE, connectivity);
1120                    networkStats.bindConnectivityManager(connectivity);
1121                    networkPolicy.bindConnectivityManager(connectivity);
1122                } catch (Throwable e) {
1123                    reportWtf("starting Connectivity Service", e);
1124                }
1125                traceEnd();
1126
1127                traceBeginAndSlog("StartNsdService");
1128                try {
1129                    serviceDiscovery = NsdService.create(context);
1130                    ServiceManager.addService(
1131                            Context.NSD_SERVICE, serviceDiscovery);
1132                } catch (Throwable e) {
1133                    reportWtf("starting Service Discovery Service", e);
1134                }
1135                traceEnd();
1136            }
1137
1138            if (!disableNonCoreServices) {
1139                traceBeginAndSlog("StartUpdateLockService");
1140                try {
1141                    ServiceManager.addService(Context.UPDATE_LOCK_SERVICE,
1142                            new UpdateLockService(context));
1143                } catch (Throwable e) {
1144                    reportWtf("starting UpdateLockService", e);
1145                }
1146                traceEnd();
1147            }
1148
1149            /*
1150             * StorageManagerService has a few dependencies: Notification Manager and
1151             * AppWidget Provider. Make sure StorageManagerService is completely started
1152             * first before continuing.
1153             */
1154            if (storageManager != null && !mOnlyCore) {
1155                traceBeginAndSlog("WaitForAsecScan");
1156                try {
1157                    storageManager.waitForAsecScan();
1158                } catch (RemoteException ignored) {
1159                }
1160                traceEnd();
1161            }
1162
1163            traceBeginAndSlog("StartNotificationManager");
1164            mSystemServiceManager.startService(NotificationManagerService.class);
1165            SystemNotificationChannels.createAll(context);
1166            notification = INotificationManager.Stub.asInterface(
1167                    ServiceManager.getService(Context.NOTIFICATION_SERVICE));
1168            networkPolicy.bindNotificationManager(notification);
1169            traceEnd();
1170
1171            traceBeginAndSlog("StartDeviceMonitor");
1172            mSystemServiceManager.startService(DeviceStorageMonitorService.class);
1173            traceEnd();
1174
1175            if (!disableLocation) {
1176                traceBeginAndSlog("StartLocationManagerService");
1177                try {
1178                    location = new LocationManagerService(context);
1179                    ServiceManager.addService(Context.LOCATION_SERVICE, location);
1180                } catch (Throwable e) {
1181                    reportWtf("starting Location Manager", e);
1182                }
1183                traceEnd();
1184
1185                traceBeginAndSlog("StartCountryDetectorService");
1186                try {
1187                    countryDetector = new CountryDetectorService(context);
1188                    ServiceManager.addService(Context.COUNTRY_DETECTOR, countryDetector);
1189                } catch (Throwable e) {
1190                    reportWtf("starting Country Detector", e);
1191                }
1192                traceEnd();
1193            }
1194
1195            if (!disableNonCoreServices && !disableSearchManager) {
1196                traceBeginAndSlog("StartSearchManagerService");
1197                try {
1198                    mSystemServiceManager.startService(SEARCH_MANAGER_SERVICE_CLASS);
1199                } catch (Throwable e) {
1200                    reportWtf("starting Search Service", e);
1201                }
1202                traceEnd();
1203            }
1204
1205            if (!disableNonCoreServices && context.getResources().getBoolean(
1206                        R.bool.config_enableWallpaperService)) {
1207                traceBeginAndSlog("StartWallpaperManagerService");
1208                mSystemServiceManager.startService(WALLPAPER_SERVICE_CLASS);
1209                traceEnd();
1210            }
1211
1212            traceBeginAndSlog("StartAudioService");
1213            mSystemServiceManager.startService(AudioService.Lifecycle.class);
1214            traceEnd();
1215
1216            if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_BROADCAST_RADIO)) {
1217                traceBeginAndSlog("StartBroadcastRadioService");
1218                mSystemServiceManager.startService(BroadcastRadioService.class);
1219                traceEnd();
1220            }
1221
1222            if (!disableNonCoreServices) {
1223                traceBeginAndSlog("StartDockObserver");
1224                mSystemServiceManager.startService(DockObserver.class);
1225                traceEnd();
1226
1227                if (context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_WATCH)) {
1228                    traceBeginAndSlog("StartThermalObserver");
1229                    mSystemServiceManager.startService(THERMAL_OBSERVER_CLASS);
1230                    traceEnd();
1231                }
1232            }
1233
1234            traceBeginAndSlog("StartWiredAccessoryManager");
1235            try {
1236                // Listen for wired headset changes
1237                inputManager.setWiredAccessoryCallbacks(
1238                        new WiredAccessoryManager(context, inputManager));
1239            } catch (Throwable e) {
1240                reportWtf("starting WiredAccessoryManager", e);
1241            }
1242            traceEnd();
1243
1244            if (!disableNonCoreServices) {
1245                if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_MIDI)) {
1246                    // Start MIDI Manager service
1247                    traceBeginAndSlog("StartMidiManager");
1248                    mSystemServiceManager.startService(MIDI_SERVICE_CLASS);
1249                    traceEnd();
1250                }
1251
1252                if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_USB_HOST)
1253                        || mPackageManager.hasSystemFeature(
1254                                PackageManager.FEATURE_USB_ACCESSORY)) {
1255                    // Manage USB host and device support
1256                    traceBeginAndSlog("StartUsbService");
1257                    mSystemServiceManager.startService(USB_SERVICE_CLASS);
1258                    traceEnd();
1259                }
1260
1261                if (!disableSerial) {
1262                    traceBeginAndSlog("StartSerialService");
1263                    try {
1264                        // Serial port support
1265                        serial = new SerialService(context);
1266                        ServiceManager.addService(Context.SERIAL_SERVICE, serial);
1267                    } catch (Throwable e) {
1268                        Slog.e(TAG, "Failure starting SerialService", e);
1269                    }
1270                    traceEnd();
1271                }
1272
1273                traceBeginAndSlog("StartHardwarePropertiesManagerService");
1274                try {
1275                    hardwarePropertiesService = new HardwarePropertiesManagerService(context);
1276                    ServiceManager.addService(Context.HARDWARE_PROPERTIES_SERVICE,
1277                            hardwarePropertiesService);
1278                } catch (Throwable e) {
1279                    Slog.e(TAG, "Failure starting HardwarePropertiesManagerService", e);
1280                }
1281                traceEnd();
1282            }
1283
1284            traceBeginAndSlog("StartTwilightService");
1285            mSystemServiceManager.startService(TwilightService.class);
1286            traceEnd();
1287
1288            if (NightDisplayController.isAvailable(context)) {
1289                traceBeginAndSlog("StartNightDisplay");
1290                mSystemServiceManager.startService(NightDisplayService.class);
1291                traceEnd();
1292            }
1293
1294            traceBeginAndSlog("StartJobScheduler");
1295            mSystemServiceManager.startService(JobSchedulerService.class);
1296            traceEnd();
1297
1298            traceBeginAndSlog("StartSoundTrigger");
1299            mSystemServiceManager.startService(SoundTriggerService.class);
1300            traceEnd();
1301
1302            if (!disableNonCoreServices) {
1303                if (!disableTrustManager) {
1304                    traceBeginAndSlog("StartTrustManager");
1305                    mSystemServiceManager.startService(TrustManagerService.class);
1306                    traceEnd();
1307                }
1308
1309                if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_BACKUP)) {
1310                    traceBeginAndSlog("StartBackupManager");
1311                    mSystemServiceManager.startService(BACKUP_MANAGER_SERVICE_CLASS);
1312                    traceEnd();
1313                }
1314
1315                if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_APP_WIDGETS)
1316                    || context.getResources().getBoolean(R.bool.config_enableAppWidgetService)) {
1317                    traceBeginAndSlog("StartAppWidgerService");
1318                    mSystemServiceManager.startService(APPWIDGET_SERVICE_CLASS);
1319                    traceEnd();
1320                }
1321
1322                // We need to always start this service, regardless of whether the
1323                // FEATURE_VOICE_RECOGNIZERS feature is set, because it needs to take care
1324                // of initializing various settings.  It will internally modify its behavior
1325                // based on that feature.
1326                traceBeginAndSlog("StartVoiceRecognitionManager");
1327                mSystemServiceManager.startService(VOICE_RECOGNITION_MANAGER_SERVICE_CLASS);
1328                traceEnd();
1329
1330                if (GestureLauncherService.isGestureLauncherEnabled(context.getResources())) {
1331                    traceBeginAndSlog("StartGestureLauncher");
1332                    mSystemServiceManager.startService(GestureLauncherService.class);
1333                    traceEnd();
1334                }
1335                traceBeginAndSlog("StartSensorNotification");
1336                mSystemServiceManager.startService(SensorNotificationService.class);
1337                traceEnd();
1338
1339                traceBeginAndSlog("StartContextHubSystemService");
1340                mSystemServiceManager.startService(ContextHubSystemService.class);
1341                traceEnd();
1342            }
1343
1344            traceBeginAndSlog("StartDiskStatsService");
1345            try {
1346                ServiceManager.addService("diskstats", new DiskStatsService(context));
1347            } catch (Throwable e) {
1348                reportWtf("starting DiskStats Service", e);
1349            }
1350            traceEnd();
1351
1352            // timezone.RulesManagerService will prevent a device starting up if the chain of trust
1353            // required for safe time zone updates might be broken. RuleManagerService cannot do
1354            // this check when mOnlyCore == true, so we don't enable the service in this case.
1355            // This service requires that JobSchedulerService is already started when it starts.
1356            final boolean startRulesManagerService =
1357                    !mOnlyCore && context.getResources().getBoolean(
1358                            R.bool.config_enableUpdateableTimeZoneRules);
1359            if (startRulesManagerService) {
1360                traceBeginAndSlog("StartTimeZoneRulesManagerService");
1361                mSystemServiceManager.startService(TIME_ZONE_RULES_MANAGER_SERVICE_CLASS);
1362                traceEnd();
1363            }
1364
1365            if (!disableNetwork && !disableNetworkTime) {
1366                traceBeginAndSlog("StartNetworkTimeUpdateService");
1367                try {
1368                    networkTimeUpdater = new NetworkTimeUpdateService(context);
1369                    ServiceManager.addService("network_time_update_service", networkTimeUpdater);
1370                } catch (Throwable e) {
1371                    reportWtf("starting NetworkTimeUpdate service", e);
1372                }
1373                traceEnd();
1374            }
1375
1376            traceBeginAndSlog("StartCommonTimeManagementService");
1377            try {
1378                commonTimeMgmtService = new CommonTimeManagementService(context);
1379                ServiceManager.addService("commontime_management", commonTimeMgmtService);
1380            } catch (Throwable e) {
1381                reportWtf("starting CommonTimeManagementService service", e);
1382            }
1383            traceEnd();
1384
1385            if (!disableNetwork) {
1386                traceBeginAndSlog("CertBlacklister");
1387                try {
1388                    CertBlacklister blacklister = new CertBlacklister(context);
1389                } catch (Throwable e) {
1390                    reportWtf("starting CertBlacklister", e);
1391                }
1392                traceEnd();
1393            }
1394
1395            if (!disableNetwork && !disableNonCoreServices && EmergencyAffordanceManager.ENABLED) {
1396                // EmergencyMode service
1397                traceBeginAndSlog("StartEmergencyAffordanceService");
1398                mSystemServiceManager.startService(EmergencyAffordanceService.class);
1399                traceEnd();
1400            }
1401
1402            if (!disableNonCoreServices) {
1403                // Dreams (interactive idle-time views, a/k/a screen savers, and doze mode)
1404                traceBeginAndSlog("StartDreamManager");
1405                mSystemServiceManager.startService(DreamManagerService.class);
1406                traceEnd();
1407            }
1408
1409            if (!disableNonCoreServices) {
1410                traceBeginAndSlog("AddGraphicsStatsService");
1411                ServiceManager.addService(GraphicsStatsService.GRAPHICS_STATS_SERVICE,
1412                        new GraphicsStatsService(context));
1413                traceEnd();
1414            }
1415
1416            if (!disableNonCoreServices && CoverageService.ENABLED) {
1417                traceBeginAndSlog("AddCoverageService");
1418                ServiceManager.addService(CoverageService.COVERAGE_SERVICE, new CoverageService());
1419                traceEnd();
1420            }
1421
1422            if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_PRINTING)) {
1423                traceBeginAndSlog("StartPrintManager");
1424                mSystemServiceManager.startService(PRINT_MANAGER_SERVICE_CLASS);
1425                traceEnd();
1426            }
1427
1428            if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_COMPANION_DEVICE_SETUP)) {
1429                traceBeginAndSlog("StartCompanionDeviceManager");
1430                mSystemServiceManager.startService(COMPANION_DEVICE_MANAGER_SERVICE_CLASS);
1431                traceEnd();
1432            }
1433
1434            traceBeginAndSlog("StartRestrictionManager");
1435            mSystemServiceManager.startService(RestrictionsManagerService.class);
1436            traceEnd();
1437
1438            traceBeginAndSlog("StartMediaSessionService");
1439            mSystemServiceManager.startService(MediaSessionService.class);
1440            traceEnd();
1441
1442            if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_HDMI_CEC)) {
1443                traceBeginAndSlog("StartHdmiControlService");
1444                mSystemServiceManager.startService(HdmiControlService.class);
1445                traceEnd();
1446            }
1447
1448            if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_LIVE_TV)
1449                    || mPackageManager.hasSystemFeature(PackageManager.FEATURE_LEANBACK)) {
1450                traceBeginAndSlog("StartTvInputManager");
1451                mSystemServiceManager.startService(TvInputManagerService.class);
1452                traceEnd();
1453            }
1454
1455            if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_PICTURE_IN_PICTURE)) {
1456                traceBeginAndSlog("StartMediaResourceMonitor");
1457                mSystemServiceManager.startService(MediaResourceMonitorService.class);
1458                traceEnd();
1459            }
1460
1461            if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_LEANBACK)) {
1462                traceBeginAndSlog("StartTvRemoteService");
1463                mSystemServiceManager.startService(TvRemoteService.class);
1464                traceEnd();
1465            }
1466
1467            if (!disableNonCoreServices) {
1468                traceBeginAndSlog("StartMediaRouterService");
1469                try {
1470                    mediaRouter = new MediaRouterService(context);
1471                    ServiceManager.addService(Context.MEDIA_ROUTER_SERVICE, mediaRouter);
1472                } catch (Throwable e) {
1473                    reportWtf("starting MediaRouterService", e);
1474                }
1475                traceEnd();
1476
1477                if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_FINGERPRINT)) {
1478                    traceBeginAndSlog("StartFingerprintSensor");
1479                    mSystemServiceManager.startService(FingerprintService.class);
1480                    traceEnd();
1481                }
1482
1483                traceBeginAndSlog("StartBackgroundDexOptService");
1484                try {
1485                    BackgroundDexOptService.schedule(context);
1486                } catch (Throwable e) {
1487                    reportWtf("starting StartBackgroundDexOptService", e);
1488                }
1489                traceEnd();
1490
1491                traceBeginAndSlog("StartPruneInstantAppsJobService");
1492                try {
1493                    PruneInstantAppsJobService.schedule(context);
1494                } catch (Throwable e) {
1495                    reportWtf("StartPruneInstantAppsJobService", e);
1496                }
1497                traceEnd();
1498            }
1499            // LauncherAppsService uses ShortcutService.
1500            traceBeginAndSlog("StartShortcutServiceLifecycle");
1501            mSystemServiceManager.startService(ShortcutService.Lifecycle.class);
1502            traceEnd();
1503
1504            traceBeginAndSlog("StartLauncherAppsService");
1505            mSystemServiceManager.startService(LauncherAppsService.class);
1506            traceEnd();
1507        }
1508
1509        if (!disableNonCoreServices && !disableMediaProjection) {
1510            traceBeginAndSlog("StartMediaProjectionManager");
1511            mSystemServiceManager.startService(MediaProjectionManagerService.class);
1512            traceEnd();
1513        }
1514
1515        if (context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_WATCH)) {
1516            traceBeginAndSlog("StartWearConnectivityService");
1517            mSystemServiceManager.startService(WEAR_CONNECTIVITY_SERVICE_CLASS);
1518            traceEnd();
1519
1520            if (!disableNonCoreServices) {
1521                traceBeginAndSlog("StartWearTimeService");
1522                mSystemServiceManager.startService(WEAR_DISPLAY_SERVICE_CLASS);
1523                mSystemServiceManager.startService(WEAR_TIME_SERVICE_CLASS);
1524                traceEnd();
1525
1526                if (enableLeftyService) {
1527                    traceBeginAndSlog("StartWearLeftyService");
1528                    mSystemServiceManager.startService(WEAR_LEFTY_SERVICE_CLASS);
1529                    traceEnd();
1530                }
1531            }
1532        }
1533
1534        if (!disableCameraService) {
1535            traceBeginAndSlog("StartCameraServiceProxy");
1536            mSystemServiceManager.startService(CameraServiceProxy.class);
1537            traceEnd();
1538        }
1539
1540        // Before things start rolling, be sure we have decided whether
1541        // we are in safe mode.
1542        final boolean safeMode = wm.detectSafeMode();
1543        if (safeMode) {
1544            traceBeginAndSlog("EnterSafeModeAndDisableJitCompilation");
1545            mActivityManagerService.enterSafeMode();
1546            // Disable the JIT for the system_server process
1547            VMRuntime.getRuntime().disableJitCompilation();
1548            traceEnd();
1549        } else {
1550            // Enable the JIT for the system_server process
1551            traceBeginAndSlog("StartJitCompilation");
1552            VMRuntime.getRuntime().startJitCompilation();
1553            traceEnd();
1554        }
1555
1556        // MMS service broker
1557        traceBeginAndSlog("StartMmsService");
1558        mmsService = mSystemServiceManager.startService(MmsServiceBroker.class);
1559        traceEnd();
1560
1561        if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_AUTOFILL)) {
1562            traceBeginAndSlog("StartAutoFillService");
1563            mSystemServiceManager.startService(AUTO_FILL_MANAGER_SERVICE_CLASS);
1564            traceEnd();
1565        }
1566
1567        // It is now time to start up the app processes...
1568
1569        traceBeginAndSlog("MakeVibratorServiceReady");
1570        try {
1571            vibrator.systemReady();
1572        } catch (Throwable e) {
1573            reportWtf("making Vibrator Service ready", e);
1574        }
1575        traceEnd();
1576
1577        traceBeginAndSlog("MakeLockSettingsServiceReady");
1578        if (lockSettings != null) {
1579            try {
1580                lockSettings.systemReady();
1581            } catch (Throwable e) {
1582                reportWtf("making Lock Settings Service ready", e);
1583            }
1584        }
1585        traceEnd();
1586
1587        // Needed by DevicePolicyManager for initialization
1588        traceBeginAndSlog("StartBootPhaseLockSettingsReady");
1589        mSystemServiceManager.startBootPhase(SystemService.PHASE_LOCK_SETTINGS_READY);
1590        traceEnd();
1591
1592        traceBeginAndSlog("StartBootPhaseSystemServicesReady");
1593        mSystemServiceManager.startBootPhase(SystemService.PHASE_SYSTEM_SERVICES_READY);
1594        traceEnd();
1595
1596        traceBeginAndSlog("MakeWindowManagerServiceReady");
1597        try {
1598            wm.systemReady();
1599        } catch (Throwable e) {
1600            reportWtf("making Window Manager Service ready", e);
1601        }
1602        traceEnd();
1603
1604        if (safeMode) {
1605            mActivityManagerService.showSafeModeOverlay();
1606        }
1607
1608        // Update the configuration for this context by hand, because we're going
1609        // to start using it before the config change done in wm.systemReady() will
1610        // propagate to it.
1611        final Configuration config = wm.computeNewConfiguration(DEFAULT_DISPLAY);
1612        DisplayMetrics metrics = new DisplayMetrics();
1613        WindowManager w = (WindowManager)context.getSystemService(Context.WINDOW_SERVICE);
1614        w.getDefaultDisplay().getMetrics(metrics);
1615        context.getResources().updateConfiguration(config, metrics);
1616
1617        // The system context's theme may be configuration-dependent.
1618        final Theme systemTheme = context.getTheme();
1619        if (systemTheme.getChangingConfigurations() != 0) {
1620            systemTheme.rebase();
1621        }
1622
1623        traceBeginAndSlog("MakePowerManagerServiceReady");
1624        try {
1625            // TODO: use boot phase
1626            mPowerManagerService.systemReady(mActivityManagerService.getAppOpsService());
1627        } catch (Throwable e) {
1628            reportWtf("making Power Manager Service ready", e);
1629        }
1630        traceEnd();
1631
1632        traceBeginAndSlog("MakePackageManagerServiceReady");
1633        try {
1634            mPackageManagerService.systemReady();
1635        } catch (Throwable e) {
1636            reportWtf("making Package Manager Service ready", e);
1637        }
1638        traceEnd();
1639
1640        traceBeginAndSlog("MakeDisplayManagerServiceReady");
1641        try {
1642            // TODO: use boot phase and communicate these flags some other way
1643            mDisplayManagerService.systemReady(safeMode, mOnlyCore);
1644        } catch (Throwable e) {
1645            reportWtf("making Display Manager Service ready", e);
1646        }
1647        traceEnd();
1648
1649        mSystemServiceManager.setSafeMode(safeMode);
1650
1651        // These are needed to propagate to the runnable below.
1652        final NetworkManagementService networkManagementF = networkManagement;
1653        final NetworkStatsService networkStatsF = networkStats;
1654        final NetworkPolicyManagerService networkPolicyF = networkPolicy;
1655        final ConnectivityService connectivityF = connectivity;
1656        final NetworkScoreService networkScoreF = networkScore;
1657        final LocationManagerService locationF = location;
1658        final CountryDetectorService countryDetectorF = countryDetector;
1659        final NetworkTimeUpdateService networkTimeUpdaterF = networkTimeUpdater;
1660        final CommonTimeManagementService commonTimeMgmtServiceF = commonTimeMgmtService;
1661        final InputManagerService inputManagerF = inputManager;
1662        final TelephonyRegistry telephonyRegistryF = telephonyRegistry;
1663        final MediaRouterService mediaRouterF = mediaRouter;
1664        final MmsServiceBroker mmsServiceF = mmsService;
1665        final WindowManagerService windowManagerF = wm;
1666
1667        // We now tell the activity manager it is okay to run third party
1668        // code.  It will call back into us once it has gotten to the state
1669        // where third party code can really run (but before it has actually
1670        // started launching the initial applications), for us to complete our
1671        // initialization.
1672        mActivityManagerService.systemReady(() -> {
1673            Slog.i(TAG, "Making services ready");
1674            traceBeginAndSlog("StartActivityManagerReadyPhase");
1675            mSystemServiceManager.startBootPhase(
1676                    SystemService.PHASE_ACTIVITY_MANAGER_READY);
1677            traceEnd();
1678            traceBeginAndSlog("StartObservingNativeCrashes");
1679            try {
1680                mActivityManagerService.startObservingNativeCrashes();
1681            } catch (Throwable e) {
1682                reportWtf("observing native crashes", e);
1683            }
1684            traceEnd();
1685
1686            // No dependency on Webview preparation in system server. But this should
1687            // be completed before allowring 3rd party
1688            final String WEBVIEW_PREPARATION = "WebViewFactoryPreparation";
1689            Future<?> webviewPrep = null;
1690            if (!mOnlyCore) {
1691                webviewPrep = SystemServerInitThreadPool.get().submit(() -> {
1692                    Slog.i(TAG, WEBVIEW_PREPARATION);
1693                    TimingsTraceLog traceLog = new TimingsTraceLog(
1694                            SYSTEM_SERVER_TIMING_ASYNC_TAG, Trace.TRACE_TAG_SYSTEM_SERVER);
1695                    traceLog.traceBegin(WEBVIEW_PREPARATION);
1696                    ConcurrentUtils.waitForFutureNoInterrupt(mZygotePreload, "Zygote preload");
1697                    mZygotePreload = null;
1698                    mWebViewUpdateService.prepareWebViewInSystemServer();
1699                    traceLog.traceEnd();
1700                }, WEBVIEW_PREPARATION);
1701            }
1702
1703            if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_AUTOMOTIVE)) {
1704                traceBeginAndSlog("StartCarServiceHelperService");
1705                mSystemServiceManager.startService(CarServiceHelperService.class);
1706                traceEnd();
1707            }
1708
1709            traceBeginAndSlog("StartSystemUI");
1710            try {
1711                startSystemUi(context, windowManagerF);
1712            } catch (Throwable e) {
1713                reportWtf("starting System UI", e);
1714            }
1715            traceEnd();
1716            traceBeginAndSlog("MakeNetworkScoreReady");
1717            try {
1718                if (networkScoreF != null) networkScoreF.systemReady();
1719            } catch (Throwable e) {
1720                reportWtf("making Network Score Service ready", e);
1721            }
1722            traceEnd();
1723            traceBeginAndSlog("MakeNetworkManagementServiceReady");
1724            try {
1725                if (networkManagementF != null) networkManagementF.systemReady();
1726            } catch (Throwable e) {
1727                reportWtf("making Network Managment Service ready", e);
1728            }
1729            CountDownLatch networkPolicyInitReadySignal = null;
1730            if (networkPolicyF != null) {
1731                networkPolicyInitReadySignal = networkPolicyF
1732                        .networkScoreAndNetworkManagementServiceReady();
1733            }
1734            traceEnd();
1735            traceBeginAndSlog("MakeNetworkStatsServiceReady");
1736            try {
1737                if (networkStatsF != null) networkStatsF.systemReady();
1738            } catch (Throwable e) {
1739                reportWtf("making Network Stats Service ready", e);
1740            }
1741            traceEnd();
1742            traceBeginAndSlog("MakeConnectivityServiceReady");
1743            try {
1744                if (connectivityF != null) connectivityF.systemReady();
1745            } catch (Throwable e) {
1746                reportWtf("making Connectivity Service ready", e);
1747            }
1748            traceEnd();
1749            traceBeginAndSlog("MakeNetworkPolicyServiceReady");
1750            try {
1751                if (networkPolicyF != null) {
1752                    networkPolicyF.systemReady(networkPolicyInitReadySignal);
1753                }
1754            } catch (Throwable e) {
1755                reportWtf("making Network Policy Service ready", e);
1756            }
1757            traceEnd();
1758
1759            traceBeginAndSlog("StartWatchdog");
1760            Watchdog.getInstance().start();
1761            traceEnd();
1762
1763            // Wait for all packages to be prepared
1764            mPackageManagerService.waitForAppDataPrepared();
1765
1766            // It is now okay to let the various system services start their
1767            // third party code...
1768            traceBeginAndSlog("PhaseThirdPartyAppsCanStart");
1769            // confirm webview completion before starting 3rd party
1770            if (webviewPrep != null) {
1771                ConcurrentUtils.waitForFutureNoInterrupt(webviewPrep, WEBVIEW_PREPARATION);
1772            }
1773            mSystemServiceManager.startBootPhase(
1774                    SystemService.PHASE_THIRD_PARTY_APPS_CAN_START);
1775            traceEnd();
1776
1777            traceBeginAndSlog("MakeLocationServiceReady");
1778            try {
1779                if (locationF != null) locationF.systemRunning();
1780            } catch (Throwable e) {
1781                reportWtf("Notifying Location Service running", e);
1782            }
1783            traceEnd();
1784            traceBeginAndSlog("MakeCountryDetectionServiceReady");
1785            try {
1786                if (countryDetectorF != null) countryDetectorF.systemRunning();
1787            } catch (Throwable e) {
1788                reportWtf("Notifying CountryDetectorService running", e);
1789            }
1790            traceEnd();
1791            traceBeginAndSlog("MakeNetworkTimeUpdateReady");
1792            try {
1793                if (networkTimeUpdaterF != null) networkTimeUpdaterF.systemRunning();
1794            } catch (Throwable e) {
1795                reportWtf("Notifying NetworkTimeService running", e);
1796            }
1797            traceEnd();
1798            traceBeginAndSlog("MakeCommonTimeManagementServiceReady");
1799            try {
1800                if (commonTimeMgmtServiceF != null) {
1801                    commonTimeMgmtServiceF.systemRunning();
1802                }
1803            } catch (Throwable e) {
1804                reportWtf("Notifying CommonTimeManagementService running", e);
1805            }
1806            traceEnd();
1807            traceBeginAndSlog("MakeInputManagerServiceReady");
1808            try {
1809                // TODO(BT) Pass parameter to input manager
1810                if (inputManagerF != null) inputManagerF.systemRunning();
1811            } catch (Throwable e) {
1812                reportWtf("Notifying InputManagerService running", e);
1813            }
1814            traceEnd();
1815            traceBeginAndSlog("MakeTelephonyRegistryReady");
1816            try {
1817                if (telephonyRegistryF != null) telephonyRegistryF.systemRunning();
1818            } catch (Throwable e) {
1819                reportWtf("Notifying TelephonyRegistry running", e);
1820            }
1821            traceEnd();
1822            traceBeginAndSlog("MakeMediaRouterServiceReady");
1823            try {
1824                if (mediaRouterF != null) mediaRouterF.systemRunning();
1825            } catch (Throwable e) {
1826                reportWtf("Notifying MediaRouterService running", e);
1827            }
1828            traceEnd();
1829            traceBeginAndSlog("MakeMmsServiceReady");
1830            try {
1831                if (mmsServiceF != null) mmsServiceF.systemRunning();
1832            } catch (Throwable e) {
1833                reportWtf("Notifying MmsService running", e);
1834            }
1835            traceEnd();
1836
1837            traceBeginAndSlog("MakeNetworkScoreServiceReady");
1838            try {
1839                if (networkScoreF != null) networkScoreF.systemRunning();
1840            } catch (Throwable e) {
1841                reportWtf("Notifying NetworkScoreService running", e);
1842            }
1843            traceEnd();
1844            traceBeginAndSlog("IncidentDaemonReady");
1845            try {
1846                // TODO: Switch from checkService to getService once it's always
1847                // in the build and should reliably be there.
1848                final IIncidentManager incident = IIncidentManager.Stub.asInterface(
1849                        ServiceManager.checkService("incident"));
1850                if (incident != null) incident.systemRunning();
1851            } catch (Throwable e) {
1852                reportWtf("Notifying incident daemon running", e);
1853            }
1854            traceEnd();
1855        }, BOOT_TIMINGS_TRACE_LOG);
1856    }

7.startSystemUI启动状态栏服务

这个方法是在startOtherService方法中调用的，因为状态栏是Android UI的重要组成部分，因此单独记录，方法以后回顾学习。

源代码如下：

1859    static final void startSystemUi(Context context, WindowManagerService windowManager) {
1859        Intent intent = new Intent();
1860        intent.setComponent(new ComponentName("com.android.systemui",
1861                    "com.android.systemui.SystemUIService"));
1862        intent.addFlags(Intent.FLAG_DEBUG_TRIAGED_MISSING);
1863        //Slog.d(TAG, "Starting service: " + intent);
1864        context.startServiceAsUser(intent, UserHandle.SYSTEM);
1865        windowManager.onSystemUiStarted();
1866    }

8.总结：

在SystemService中主要负责Android所有系统服务的启动以及初始化工作，当所有的服务都启动到Ready状态时，Android系统就正式启动完成，开机动画隐藏，开始显示界面（开机向导或锁屏界面），学习SystemService可以帮助我们理解Framework中的服务的初始化流程，方便我们接下来对每个服务的学习和理解。

SystemService简介相关推荐

Android系统服务(SystemService)简介
什么是SystemService 我们在Android开发过程中经常会用到各种各样的系统管理服务,如进行窗口相关的操作会用到窗口管理服务WindowManager,进行电源相关的操作会用到电源管理服务 ...
inflate简介，LayoutInflater和inflate()方法的用法
一.inflate简介 inflate这个方法总共有四种形式(见下面),目的都是把xml表述的layout转化为View对象. 其中有一个比较常用,View inflate(int resource, ...
Android以太网框架情景分析之启动简介
Android以太网框架情景分析之启动简介 Android网络框架分析系列文章目录: Android P适配以太网功能开发指南 Android以太网框架情景分析之启动简介 Androi ...
unidbg 简介、基本使用、调用so中方法、unidbg-web
逆向调试时还是 IDA 的图形化界面更方便,一般首选 IDA 调试分析,后期要在生产线上生成 sign 字段,这时再用 unidbg 就更合适了! 1.调用 so 库中函数的一些方式 frida 的 ...
Android-0.PMS简介及VirtualApp中安装App全流程
文章目录 1.Package Manager简介 2.PackageInstaller简介 2.1 PackageInstaller初始化 2.2 PackageInstaller安装APK 3. P ...
Android-0.AMS初始化和启动简介
文章目录 1.Activity Manager简介 2.AMS 的启动和初始化过程 2.1.AMS 所在的system进程 2.1.AMS 初始化流程 2.2.AMS 启动流程 2.3.AMS 的 s ...
etcd 笔记（01）— etcd 简介、特点、应用场景、常用术语、分布式 CAP 理论、分布式原理
1. etcd 简介 etcd 官网定义: A highly-available key value store for shared configuration and service discov ...
Docker学习(一)-----Docker简介与安装
一.Docker介绍 1.1什么是docker Docker是一个开源的应用容器引擎,基于Go语言并遵从Apache2.0协议开源 Docker可以让开发者打包他们的应用以及依赖包到一个轻量级,可移植 ...
【Spring】框架简介
[Spring]框架简介 Spring是什么 Spring是分层的Java SE/EE应用full-stack轻量级开源框架,以IOC(Inverse Of Control:反转控制)和AOP(Asp ...

SystemService简介