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中的服務的初始化流程，方便我們接下來對每個服務的學習和理解。