经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 移动开发 » Android » 查看文章
Zygote家的大儿子 —— SystemServer
来源：cnblogs　　作者：秉心说　　时间：2019/10/14 9:40:25　　对本文有异议

本文基于 Android 9.0 , 代码仓库地址 ： android_9.0.0_r45

文中源码链接：

SystemServer.java

SystemServiceManager.java

SystemService.java

首先来回顾一下上篇文章 Java 世界的盘古和女娲 —— Zygote ，主要介绍了 Android 世界中的第一个 Java 进程 Zygote，它的主要工作流程如下：

  1. registerServerSocketFromEnv()， 注册服务端 socket，用于和客户端进程通信
  2. preload()，预加载一系列资源，提高应用启动速度
  3. forkSystemServer()，创建 system_server 进程
  4. 功成身退，调用 runSelectLoop() 等待响应客户端请求，创建应用进程

本篇文章的主角 system_server 进程是 Zygote 进程 fork 出的第一个进程，它负责管理和启动整个 Framework 层。

再来看看 Gityuan 的这张图片，找一下 System Server 的位置，它承载了各类系统服务的创建和启动。关于 system_server 进程的创建流程，上篇文章中已经做了详细介绍，这里再简单看一下流程图：

最终会调用到 SystemServer.main() 方法。下面就以此为起点，来具体分析 SystemServer 都做了些什么。

SystemServer 启动流程

  1. public static void main(String[] args) {
  2.     new SystemServer().run();
  3. }

接着看 run() 方法。

  1. private void run() {
  2.     try {
  3.         ......
  4.         // 如果设备时间早于 1970 年，很多 API 处理负数时会 crash。所以直接设置为 1970 年 1 月 1 日
  5.         if (System.currentTimeMillis() < EARLIEST_SUPPORTED_TIME) {
  6.             Slog.w(TAG, "System clock is before 1970; setting to 1970.");
  7.             SystemClock.setCurrentTimeMillis(EARLIEST_SUPPORTED_TIME);
  8.         }
  10.         // 未设置时区的话默认设为 GMT
  11.         String timezoneProperty =  SystemProperties.get("persist.sys.timezone");
  12.         if (timezoneProperty == null || timezoneProperty.isEmpty()) {
  13.             Slog.w(TAG, "Timezone not set; setting to GMT.");
  14.             SystemProperties.set("persist.sys.timezone", "GMT");
  15.         }
  17.         // 语言地区设置
  18.         if (!SystemProperties.get("persist.sys.language").isEmpty()) {
  19.             final String languageTag = Locale.getDefault().toLanguageTag();
  21.             SystemProperties.set("persist.sys.locale", languageTag);
  22.             SystemProperties.set("persist.sys.language", "");
  23.             SystemProperties.set("persist.sys.country", "");
  24.             SystemProperties.set("persist.sys.localevar", "");
  25.         }
  27.         // The system server should never make non-oneway calls
  28.         Binder.setWarnOnBlocking(true);
  29.         // The system server should always load safe labels
  30.         PackageItemInfo.setForceSafeLabels(true);
  32.         // Default to FULL within the system server.
  33.         SQLiteGlobal.sDefaultSyncMode = SQLiteGlobal.SYNC_MODE_FULL;
  35.         // Deactivate SQLiteCompatibilityWalFlags until settings provider is initialized
  36.         SQLiteCompatibilityWalFlags.init(null);
  38.         // Here we go!
  39.         Slog.i(TAG, "Entered the Android system server!");
  40.         int uptimeMillis = (int) SystemClock.elapsedRealtime();
  41.         EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_SYSTEM_RUN, uptimeMillis);
  42.         if (!mRuntimeRestart) {
  43.             MetricsLogger.histogram(null, "boot_system_server_init", uptimeMillis);
  44.         }
  46.         // 设置虚拟机运行库路径
  47.         SystemProperties.set("persist.sys.dalvik.vm.lib.2", VMRuntime.getRuntime().vmLibrary());
  49.         // Mmmmmm... more memory!
  50.         // 清除虚拟机内存增长限制，允许应用申请更多内存
  51.         VMRuntime.getRuntime().clearGrowthLimit();
  53.         // 设置堆内存的有效利用率为 0.8，(可能被忽略)
  54.         VMRuntime.getRuntime().setTargetHeapUtilization(0.8f);
  56.         // 确保指纹信息已经定义
  57.         Build.ensureFingerprintProperty();
  59.         // Within the system server, it is an error to access Environment paths without
  60.         // explicitly specifying a user.
  61.         Environment.setUserRequired(true);
  63.         // Within the system server, any incoming Bundles should be defused
  64.         // to avoid throwing BadParcelableException.
  65.         BaseBundle.setShouldDefuse(true);
  67.         // Within the system server, when parceling exceptions, include the stack trace
  68.         Parcel.setStackTraceParceling(true);
  70.         // 确保系统的 Binder 调用总是运行在前台优先级
  71.         BinderInternal.disableBackgroundScheduling(true);
  73.         // Increase the number of binder threads in system_server
  74.         BinderInternal.setMaxThreads(sMaxBinderThreads);
  76.         // Prepare the main looper thread (this thread).
  77.         android.os.Process.setThreadPriority(
  78.             android.os.Process.THREAD_PRIORITY_FOREGROUND);
  79.             android.os.Process.setCanSelfBackground(false);
  80.         // 1. 创建主线程 Looper
  81.         Looper.prepareMainLooper();
  82.         Looper.getMainLooper().setSlowLogThresholdMs(
  83.                 SLOW_DISPATCH_THRESHOLD_MS, SLOW_DELIVERY_THRESHOLD_MS);
  85.         // 初始化 native 服务，加载 libandroid_servers.so
  86.         System.loadLibrary("android_servers");
  88.         // 检查上次关机是否失败，可能不会有返回值
  89.         performPendingShutdown();
  91.         // 2. 初始化系统上下文
  92.         createSystemContext();
  94.         // 3. 创建系统服务管理 SystemServiceManager
  95.         // 并将 mSystemServiceManager 注册到 sLocalServiceObjects 中
  96.         mSystemServiceManager = new SystemServiceManager(mSystemContext);
  97.         mSystemServiceManager.setStartInfo(mRuntimeRestart,
  98.                 mRuntimeStartElapsedTime, mRuntimeStartUptime);
  99.         LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
  100.         // Prepare the thread pool for init tasks that can be parallelized
  101.         SystemServerInitThreadPool.get();
  102.     } finally {
  103.         traceEnd();  // InitBeforeStartServices
  104.     }
  106.     // Start services.
  107.     try {
  108.         traceBeginAndSlog("StartServices");
  109.         startBootstrapServices(); // 4. 启动系统引导服务
  110.         startCoreServices();      // 5. 启动系统核心服务
  111.         startOtherServices();     // 6. 启动其他服务
  112.         SystemServerInitThreadPool.shutdown();
  113.     } catch (Throwable ex) {
  114.         Slog.e("System", "******************************************");
  115.         Slog.e("System", "************ Failure starting system services", ex);
  116.         throw ex;
  117.     } finally {
  118.         traceEnd();
  119.     }
  121.     StrictMode.initVmDefaults(null);
  123.     if (!mRuntimeRestart && !isFirstBootOrUpgrade()) {
  124.         int uptimeMillis = (int) SystemClock.elapsedRealtime();
  125.         MetricsLogger.histogram(null, "boot_system_server_ready", uptimeMillis);
  126.         final int MAX_UPTIME_MILLIS = 60 * 1000;
  127.         if (uptimeMillis > MAX_UPTIME_MILLIS) {
  128.             Slog.wtf(SYSTEM_SERVER_TIMING_TAG,
  129.                     "SystemServer init took too long. uptimeMillis=" + uptimeMillis);
  130.         }
  131.     }
  133.     // 7. Loop forever.
  134.     Looper.loop();
  135.     throw new RuntimeException("Main thread loop unexpectedly exited");
  136. }

代码虽然比较长，但是逻辑很清晰。我在注释里标记了比较重要的 7 个步骤，逐一分析。

Looper.prepareMainLooper()

初始化 Looper。关于 Handler 消息机制，可以阅读我的另一篇文章 深入理解 Handler 消息机制 。最后会调用 Looper.loop() 开启消息循环，开始处理消息。

createSystemContext()

  1. private void createSystemContext() {
  2.     // 创建 system_server 上下文信息
  3.     ActivityThread activityThread = ActivityThread.systemMain();
  4.     mSystemContext = activityThread.getSystemContext();
  5.     mSystemContext.setTheme(DEFAULT_SYSTEM_THEME);
  7.     final Context systemUiContext = activityThread.getSystemUiContext();
  8.     // 设置主题，用于系统 dialog 等
  9.     systemUiContext.setTheme(DEFAULT_SYSTEM_THEME);
  10. }

创建系统上下文。首先调用 ActivityThread.systemMain() 方法获取 ActivityThread 对象，然后再获取上下文。

  1. public static ActivityThread systemMain() {
  2.     // 判断是否是大内存设备,在低内存设备上不启用硬件加速
  3.     if (!ActivityManager.isHighEndGfx()) {
  4.         ThreadedRenderer.disable(true);
  5.     } else {
  6.         ThreadedRenderer.enableForegroundTrimming();
  7.     }
  8.     ActivityThread thread = new ActivityThread();
  9.     thread.attach(true, 0);
  10.     return thread;
  11. }

关于 ActivityThread.attach() 方法这里不做具体分析了，后面文章说到应用启动时再来详细解析。

创建完系统上下文，接下来就是启动各种系统服务了。源码中把服务大致分为了三类，再来回顾一下：

  1. startBootstrapServices(); // 4. 启动系统引导服务
  2. startCoreServices();      // 5. 启动系统核心服务
  3. startOtherServices();     // 6. 启动其他服务

逐一进行分析。

startBootstrapServices()

  1. private void startBootstrapServices() {
  2.     final String TAG_SYSTEM_CONFIG = "ReadingSystemConfig";
  3.     SystemServerInitThreadPool.get().submit(SystemConfig::getInstance, TAG_SYSTEM_CONFIG);
  5.     // 阻塞等待与 installd 建立 socket 通道
  6.     Installer installer = mSystemServiceManager.startService(Installer.class);
  8.     // 启动 DeviceIdentifiersPolicyService，在 ActivityManagerService 之前
  9.     mSystemServiceManager.startService(DeviceIdentifiersPolicyService.class);
  11.     // 启动服务 ActivityManagerService
  12.     mActivityManagerService = mSystemServiceManager.startService(
  13.             ActivityManagerService.Lifecycle.class).getService();
  14.     mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
  15.     mActivityManagerService.setInstaller(installer);
  17.     // 启动服务 PowerManagerService
  18.     mPowerManagerService = mSystemServiceManager.startService(PowerManagerService.class);
  20.     // Now that the power manager has been started, let the activity manager
  21.     // initialize power management features.
  22.     mActivityManagerService.initPowerManagement();
  24.     // 启动服务 RecoverySystemService
  25.     mSystemServiceManager.startService(RecoverySystemService.class);
  27.     // Now that we have the bare essentials of the OS up and running, take
  28.     // note that we just booted, which might send out a rescue party if
  29.     // we're stuck in a runtime restart loop.
  30.     RescueParty.noteBoot(mSystemContext);
  32.     // 启动服务 LightsService
  33.     mSystemServiceManager.startService(LightsService.class);
  35.     // Package manager isn't started yet; need to use SysProp not hardware feature
  36.     if (SystemProperties.getBoolean("config.enable_sidekick_graphics", false)) {
  37.         mSystemServiceManager.startService(WEAR_SIDEKICK_SERVICE_CLASS);
  38.     }
  40.     // 启动 DisplayManagerService，在 PackageManagerService 之前
  41.     mDisplayManagerService = mSystemServiceManager.startService(DisplayManagerService.class);
  43.     // We need the default display before we can initialize the package manager.
  44.     mSystemServiceManager.startBootPhase(SystemService.PHASE_WAIT_FOR_DEFAULT_DISPLAY);
  46.     // 正在加密设备时只运行核心 app
  47.     String cryptState = SystemProperties.get("vold.decrypt");
  48.     if (ENCRYPTING_STATE.equals(cryptState)) {
  49.         Slog.w(TAG, "Detected encryption in progress - only parsing core apps");
  50.         mOnlyCore = true;
  51.     } else if (ENCRYPTED_STATE.equals(cryptState)) {
  52.         Slog.w(TAG, "Device encrypted - only parsing core apps");
  53.         mOnlyCore = true;
  54.     }
  56.     // 启动服务 PackageManagerService
  57.     if (!mRuntimeRestart) {
  58.         MetricsLogger.histogram(null, "boot_package_manager_init_start",
  59.                 (int) SystemClock.elapsedRealtime());
  60.     }
  61.     mPackageManagerService = PackageManagerService.main(mSystemContext, installer,
  62.             mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF, mOnlyCore);
  63.     mFirstBoot = mPackageManagerService.isFirstBoot();
  64.     mPackageManager = mSystemContext.getPackageManager();
  65.     if (!mRuntimeRestart && !isFirstBootOrUpgrade()) {
  66.         MetricsLogger.histogram(null, "boot_package_manager_init_ready",
  67.                 (int) SystemClock.elapsedRealtime());
  68.     }
  69.     if (!mOnlyCore) {
  70.         boolean disableOtaDexopt = SystemProperties.getBoolean("config.disable_otadexopt",
  71.                 false);
  72.         if (!disableOtaDexopt) {
  73.             traceBeginAndSlog("StartOtaDexOptService");
  74.             try {
  75.                 OtaDexoptService.main(mSystemContext, mPackageManagerService);
  76.             } catch (Throwable e) {
  77.                 reportWtf("starting OtaDexOptService", e);
  78.             } finally {
  79.                 traceEnd();
  80.             }
  81.         }
  82.     }
  84.     // 启动服务 UserManagerService
  85.     mSystemServiceManager.startService(UserManagerService.LifeCycle.class);
  87.     // 初始化属性 cache 以缓存包资源
  88.     AttributeCache.init(mSystemContext);
  90.     // 设置 AMS
  91.     mActivityManagerService.setSystemProcess();
  93.     // DisplayManagerService needs to setup android.display scheduling related policies
  94.     // since setSystemProcess() would have overridden policies due to setProcessGroup
  95.     mDisplayManagerService.setupSchedulerPolicies();
  97.     // 启动服务 OverlayManagerService
  98.     OverlayManagerService overlayManagerService = new OverlayManagerService(
  99.             mSystemContext, installer);
  100.     mSystemServiceManager.startService(overlayManagerService);
  102.     if (SystemProperties.getInt("persist.sys.displayinset.top", 0) > 0) {
  103.         // DisplayManager needs the overlay immediately.
  104.         overlayManagerService.updateSystemUiContext();
  105.         LocalServices.getService(DisplayManagerInternal.class).onOverlayChanged();
  106.     }
  108.     // 在单独的线程中启动 SensorService
  109.     mSensorServiceStart = SystemServerInitThreadPool.get().submit(() -> {
  110.         TimingsTraceLog traceLog = new TimingsTraceLog(
  111.                 SYSTEM_SERVER_TIMING_ASYNC_TAG, Trace.TRACE_TAG_SYSTEM_SERVER);
  112.         startSensorService();
  113.     }, START_SENSOR_SERVICE);
  114. }

startBootstrapServices() 方法中的都是系统启动过程中的关键服务，且相互依赖，主要下列服务 ：

Installer DeviceIdentifiersPolicyService ActivityManagerService PowerManagerService RecoverySystemService LightsService StartSidekickService DisplayManagerService

SystemService.PHASE_WAIT_FOR_DEFAULT_DISPLAY (100)

PackageManagerService UserManagerService OverlayManagerService SensorService

一共启动了十二个核心服务。注意中间的 SystemService.PHASE_WAIT_FOR_DEFAULT_DISPLAY，它并不是代表什么系统服务，而是一个 int 值 100,类似的 int 值还有一些，定义在 SystemService 类中，它的作用是给服务启动过程划分阶段，每个阶段都有特定的含义，可以做不同的事情。这里先混个脸熟，等介绍完所有的服务，再回过头来总结一下有哪些阶段。

startCoreServices()

  1. private void startCoreServices() {
  2.     // 启动服务 BatteryService，需要 LightService
  3.     mSystemServiceManager.startService(BatteryService.class);
  5.     // 启动服务 UsageStatsService，统计应用使用情况
  6.     mSystemServiceManager.startService(UsageStatsService.class);
  7.     mActivityManagerService.setUsageStatsManager(
  8.             LocalServices.getService(UsageStatsManagerInternal.class));
  10.     // 检查是否存在可更新的 WebView。存在就启动服务 WebViewUpdateService
  11.     if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_WEBVIEW)) {
  12.         mWebViewUpdateService = mSystemServiceManager.startService(WebViewUpdateService.class);
  13.     }
  15.     // 启动服务 BinderCallsStatsService，跟踪 Binder 调用的 cpu 时间消耗
  16.     BinderCallsStatsService.start();
  17. }

启动了四个服务，BatteryService UsageStatsService WebViewUpdateService 和 BinderCallsStatsService 。

startOtherServices()

startOtherServices() 源码有一千多行，就像一个杂货铺，启动了一系列的服务。下面尽量精简一下代码：

  1. KeyAttestationApplicationIdProviderService/KeyChainSystemService
  2. SchedulingPolicyService/TelecomLoaderService/TelephonyRegistry
  4. mContentResolver = context.getContentResolver();
  6. AccountManagerService/ContentService
  8. mActivityManagerService.installSystemProviders();
  9.   
  10. DropBoxManagerService/VibratorService/ConsumerIrService/AlarmManagerService
  12. final Watchdog watchdog = Watchdog.getInstance();
  13. watchdog.init(context, mActivityManagerService);
  15. InputManagerService/WindowManagerService/VrManagerService/BluetoothService
  16. IpConnectivityMetrics/NetworkWatchlistService/PinnerService
  17. InputMethodManagerService/AccessibilityManagerService/StorageManagerService
  18. StorageStatsService/UiModeManagerService/LockSettingsService
  19. PersistentDataBlockService/OemLockService/DeviceIdleController
  20. DevicePolicyManagerService/StatusBarManagerService/ClipboardService
  21. NetworkManagementService/IpSecService/TextServicesManagerService
  22. TextClassificationManagerService/NetworkScoreService/NetworkStatsService
  23. NetworkPolicyManagerService/WifiScanningService/RttService
  24. WifiAware/WifiP2P/Lowpan/Ethernet/ConnectivityService/NsdService
  25. SystemUpdateManagerService/UpdateLockService/NotificationManagerService
  26. DeviceStorageMonitorService/LocationManagerService/CountryDetectorService
  27. SearchManagerService/WallpaperManagerService/AudioService/BroadcastRadioService
  28. DockObserver/ThermalObserver/WiredAccessoryManager/MidiManager/UsbService
  29. SerialService/HardwarePropertiesManagerService/TwilightService
  30. ColorDisplayService/JobSchedulerService/SoundTriggerService/TrustManagerService
  31. BackupManager/AppWidgerService/VoiceRecognitionManager/GestureLauncherService
  32. SensorNotificationService/ContextHubSystemService/DiskStatsService
  33. TimeZoneRulesManagerService/NetworkTimeUpdateService/CommonTimeManagementService
  34. CertBlacklister/EmergencyAffordanceService/DreamManagerService/GraphicsStatsService
  35. CoverageService/PrintManager/CompanionDeviceManager/RestrictionsManagerService
  36. MediaSessionService/MediaUpdateService/HdmiControlService/TvInputManagerService
  37. MediaResourceMonitorService/TvRemoteService/MediaRouterService/FingerprintService
  38. BackgroundDexOptService/PruneInstantAppsJobService/ShortcutService
  39. LauncherAppsService/CrossProfileAppsService/MediaProjectionManagerService
  40. WearConfigService/WearConnectivityService/WearTimeService/WearLeftyService
  41. WearGlobalActionsService/SliceManagerService/CameraServiceProxy/IoTSystemService
  42. MmsServiceBroker/AutoFillService
  44. // It is now time to start up the app processes...
  45. vibrator.systemReady();
  46. lockSettings.systemReady();
  48. // 480
  49. mSystemServiceManager.startBootPhase(SystemService.PHASE_LOCK_SETTINGS_READY); 
  50. // 500
  51. mSystemServiceManager.startBootPhase(SystemService.PHASE_SYSTEM_SERVICES_READY); 
  53. wm.systemReady();
  54. mPowerManagerService.systemReady(mActivityManagerService.getAppOpsService());
  55. mPackageManagerService.systemReady();
  56. mDisplayManagerService.systemReady(safeMode, mOnlyCore);
  58. // Start device specific services
  59. final String[] classes = mSystemContext.getResources().getStringArray(
  60.         R.array.config_deviceSpecificSystemServices);
  61. for (final String className : classes) {
  62.     try {
  63.         mSystemServiceManager.startService(className);
  64.     } catch (Throwable e) {
  65.         reportWtf("starting " + className, e);
  66.     }
  67. }
  69. // 520
  70. mSystemServiceManager.startBootPhase(SystemService.PHASE_DEVICE_SPECIFIC_SERVICES_READY);
  72. mActivityManagerService.systemReady(() -> {
  73.     // 550
  74.     mSystemServiceManager.startBootPhase(SystemService.PHASE_ACTIVITY_MANAGER_READY);
  75.     
  76.     startSystemUi(context, windowManagerF);
  77.     
  78.     networkManagementF.systemReady();
  79.     ipSecServiceF.systemReady();
  80.     networkStatsF.systemReady();
  81.     connectivityF.systemReady();
  82.     
  83.     Watchdog.getInstance().start
  84.     mPackageManagerService.waitForAppDataPrepared();
  86.     // 600
  87.     mSystemServiceManager.startBootPhase(SystemService.PHASE_THIRD_PARTY_APPS_CAN_START);
  88.     
  89.     locationF.systemRunning();
  90.     countryDetectorF.systemRunning();
  91.     networkTimeUpdaterF.systemRunning();
  92.     commonTimeMgmtServiceF.systemRunning();
  93.     inputManagerF.systemRunning();
  94.     telephonyRegistryF.systemRunning();
  95.     mediaRouterF.systemRunning();
  96.     mmsServiceF.systemRunning();
  97.     incident.systemRunning();
  98. }

通过上面的代码可以看到启动了相当多的系统服务。startOtherServices() 方法共经历了五个启动阶段，如下所示：

  1. SystemService.PHASE_LOCK_SETTINGS_READY             // 480
  2. SystemService.PHASE_SYSTEM_SERVICES_READY           // 500
  3. SystemService.PHASE_DEVICE_SPECIFIC_SERVICES_READY  // 520
  4. SystemService.PHASE_ACTIVITY_MANAGER_READY          // 550
  5. SystemService.PHASE_THIRD_PARTY_APPS_CAN_START      // 600

最后调用的 mActivityManagerService.systemReady() 方法。该方法中会调用 startHomeActivityLocked 来启动桌面 Activity，这样桌面应用就启动了。

Looper.loop()

至此，system_server 进程的主要工作就算完成了，进入 Looper.loop() 状态,等待其他线程通过 Handler 发送消息到主线程并处理。

SystemServer 启动阶段分类

回过头再来看看前面提到的启动阶段分类，定义在 com.android.server.SystemService 类中：

  1. /*
  2.  * Boot Phases
  3.  * 
  4.  * 启动阶段
  5.  */
  6. public static final int PHASE_WAIT_FOR_DEFAULT_DISPLAY = 100; // maybe should be a dependency?
  8. /**
  9.  * After receiving this boot phase, services can obtain lock settings data.
  10.  */
  11. public static final int PHASE_LOCK_SETTINGS_READY = 480;
  13. /**
  14.  * After receiving this boot phase, services can safely call into core system services
  15.  * such as the PowerManager or PackageManager.
  16.  * 
  17.  * 在这个阶段之后，可以安全的调用系统核心服务，如 PowerManager 和 PackageManager
  18.  */
  19. public static final int PHASE_SYSTEM_SERVICES_READY = 500;
  21. /**
  22.  * After receiving this boot phase, services can safely call into device specific services.
  23.  * 
  24.  * 在这个阶段之后，可以安全调用设备特定的服务
  25.  */
  26. public static final int PHASE_DEVICE_SPECIFIC_SERVICES_READY = 520;
  28. /**
  29.  * After receiving this boot phase, services can broadcast Intents.
  30.  * 
  31.  * 在这个阶段之后，服务可以广播
  32.  */
  33. public static final int PHASE_ACTIVITY_MANAGER_READY = 550;
  35. /**
  36.  * After receiving this boot phase, services can start/bind to third party apps.
  37.  * Apps will be able to make Binder calls into services at this point.
  38.  * 
  39.  * 在这个阶段之后，服务可以启动/绑定第三方应用
  40.  * 应用此时可以进行 Binder 调用
  41.  */
  42. public static final int PHASE_THIRD_PARTY_APPS_CAN_START = 600;
  44. /**
  45.  * After receiving this boot phase, services can allow user interaction with the device.
  46.  * This phase occurs when boot has completed and the home application has started.
  47.  * System services may prefer to listen to this phase rather than registering a
  48.  * broadcast receiver for ACTION_BOOT_COMPLETED to reduce overall latency.
  49.  * 
  50.  * 在这个阶段之后，允许用户和设备交互。
  51.  * 这个阶段发生在启动完成，home 应用已经开始。
  52.  * 系统服务更倾向于监听这个阶段，而不是监听启动广播 ACTION_BOOT_COMPLETED，以降低延迟
  53.  */
  54. public static final int PHASE_BOOT_COMPLETED = 1000;

在 system_server 启动过程中各个阶段的位置大致如下：

  1. private void startBootstrapServices() {
  2.     ...
  3.     // 100
  4.     mSystemServiceManager.startBootPhase(SystemService.PHASE_WAIT_FOR_DEFAULT_DISPLAY);
  5.     ...
  6. }
  8. private void startOtherServices() {
  9.     ...
  10.     // 480
  11.     mSystemServiceManager.startBootPhase(SystemService.PHASE_LOCK_SETTINGS_READY);
  12.     // 500
  13.     mSystemServiceManager.startBootPhase(SystemService.PHASE_SYSTEM_SERVICES_READY);
  15.     ...
  16.     // 520
  17.     mSystemServiceManager.startBootPhase(SystemService.PHASE_DEVICE_SPECIFIC_SERVICES_READY);
  19.     mActivityManagerService.systemReady(() -> {
  20.         mSystemServiceManager.startBootPhase(
  21.                     SystemService.PHASE_ACTIVITY_MANAGER_READY); // 550
  22.                     
  23.         ...
  24.         mSystemServiceManager.startBootPhase(
  25.                     SystemService.PHASE_THIRD_PARTY_APPS_CAN_START); // 600
  26.     }
  27. }

最后的 SystemService.PHASE_BOOT_COMPLETED（1000） 在 AMS 的 finishBooting() 方法中调用。另外注意 480 和 500 两个阶段是连在一起的，中间没有发生任何事情。

那么，划分阶段的具体作用是什么呢？答案就在 startBootPhase() 方法中：

  1. public void startBootPhase(final int phase) {
  2.     if (phase <= mCurrentPhase) {
  3.         throw new IllegalArgumentException("Next phase must be larger than previous");
  4.     }
  5.     mCurrentPhase = phase;
  7.     try {
  8.         final int serviceLen = mServices.size();
  9.         for (int i = 0; i < serviceLen; i++) {
  10.             final SystemService service = mServices.get(i);
  11.             long time = SystemClock.elapsedRealtime();
  12.             try {
  13.                 // 回调系统服务的 onBootPhase() 方法
  14.                 service.onBootPhase(mCurrentPhase);
  15.             } catch (Exception ex) {
  16.                 throw new RuntimeException("Failed to boot service "
  17.                         + service.getClass().getName()
  18.                         + ": onBootPhase threw an exception during phase "
  19.                         + mCurrentPhase, ex);
  20.             }
  21.             warnIfTooLong(SystemClock.elapsedRealtime() - time, service, "onBootPhase");
  22.         }
  23.     } finally {
  24.         Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
  25.     }
  26. }

核心就在于 service.onBootPhase(mCurrentPhase);。所有系统服务都是继承于 SystemService 的，startBootPhase() 方法会回调当前阶段已经加入 mServices 的所有系统服务的 onBootPhase() 方法，在合适的阶段做一些合适的事情。以 AMS 为例：

  1. @Override
  2. public void onBootPhase(int phase) {
  3.     mService.mBootPhase = phase;
  4.     if (phase == PHASE_SYSTEM_SERVICES_READY) {
  5.         mService.mBatteryStatsService.systemServicesReady();
  6.         mService.mServices.systemServicesReady();
  7.     }
  8. }

SystemServer 是如何启动服务的 ？

看完 SystemServer 的源码，它最重要的工作就是创建和启动各种系统服务。那么服务一般是如何创建的呢？下面以 startBootstrapServices() 中创建的第一个服务 Installer 为例来看一下：

  1. Installer installer = mSystemServiceManager.startService(Installer.class);

进入 SystemServiceManager 的 startService() 方法：

  1. public <T extends SystemService> T startService(Class<T> serviceClass) {
  2.     try {
  3.         // 获取服务名称
  4.         final String name = serviceClass.getName();
  6.         // Create the service.
  7.         if (!SystemService.class.isAssignableFrom(serviceClass)) {
  8.             throw new RuntimeException("Failed to create " + name
  9.                     + ": service must extend " + SystemService.class.getName());
  10.         }
  11.         final T service;
  12.         try {
  13.             // 获取服务类的构造器
  14.             Constructor<T> constructor = serviceClass.getConstructor(Context.class);
  15.             // 反射创建 service
  16.             service = constructor.newInstance(mContext);
  17.         } catch (InstantiationException ex) {
  18.             throw new RuntimeException("Failed to create service " + name
  19.                     + ": service could not be instantiated", ex);
  20.         } catch (IllegalAccessException ex) {
  21.             throw new RuntimeException("Failed to create service " + name
  22.                     + ": service must have a public constructor with a Context argument", ex);
  23.         } catch (NoSuchMethodException ex) {
  24.             throw new RuntimeException("Failed to create service " + name
  25.                     + ": service must have a public constructor with a Context argument", ex);
  26.         } catch (InvocationTargetException ex) {
  27.             throw new RuntimeException("Failed to create service " + name
  28.                     + ": service constructor threw an exception", ex);
  29.         }
  31.         startService(service);
  32.         return service;
  33.     } finally {
  34.         Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
  35.     }
  36. }

创建并启动一个系统服务。这个系统服务必须是 com.android.server.SystemService 的子类。根据参数传入的 Class 对象反射创建其实例，再调用重载方法 startService() ：

  1. public void startService(@NonNull final SystemService service) {
  2.     // Register it.
  3.     mServices.add(service);
  4.     // Start it.
  5.     long time = SystemClock.elapsedRealtime();
  6.     try {
  7.         // 回调系统服务的 onStart() 方法
  8.         service.onStart();
  9.     } catch (RuntimeException ex) {
  10.         throw new RuntimeException("Failed to start service " + service.getClass().getName()
  11.             + ": onStart threw an exception", ex);
  12.     }
  13.     warnIfTooLong(SystemClock.elapsedRealtime() - time, service, "onStart");
  14. }

就两步。第一步，注册服务，mServices 是一个 ArrayList<SystemService> 对象，用来保存已经创建的系统服务。第二步，回调服务的 onStart() 方法，还是以 Installer 为例：

  1. @Override
  2. public void onStart() {
  3.     if (mIsolated) {
  4.         mInstalld = null;
  5.     } else {
  6.         connect();
  7.     }
  8. }

这样一个服务就启动完成了。这是一种比较普遍的启动方式，当然还有一些系统服务具有不一样的启动方式，这里就不一一分析了，后面有机会解析具体服务的时候再来分析。

总结

SystemServer 的启动流程比较耿直，没有那么多弯弯绕，下面简单总结一下：

  1. 语言、时区、地区等设置
  2. 虚拟机内存设置
  3. 指纹信息，Binder 调用设置
  4. Looper.prepareMainLooper() ，创建主线程 Looper
  5. 初始化 native 服务，加载 libandroid_servers.so
  6. createSystemContext()，初始化系统上下文
  7. 创建系统服务管理 SystemServiceManager
  8. startBootstrapServices，启动系统引导服务
  9. startCoreServices，启动系统核心服务
  10. startOtherServices，启动其他服务
  11. Looper.loop()，开启消息循环

另外，在 startOtherServices 的最后会调用 AMS 的 onSystemReady() 方法启动桌面 Activity。

预告

还记得 Zygote 进程的 runSelectLoop() 方法吗？Zygote 在创建完 system_server 进程之后，就开始默默的等待客户端请求创建应用进程。下一篇，我们将从源码角度来捋一遍客户端是如何发送请求，Zygote 是如何处理请求，应用进程是如何创建的，敬请期待！

文章首发微信公众号： 秉心说 ， 专注 Java 、 Android 原创知识分享，LeetCode 题解。

更多最新原创文章，扫码关注我吧！

原文链接：http://www.cnblogs.com/bingxinshuo/p/11669031.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Android热门文章

  • 安卓虚拟定位实现与反作弊思路
  • Android之Activity启动流程详解（基于api28）
  • MAUI开发Android程序使PDA扫码广播消息转发至Web页面
  • android开发技巧杂谈
  • 高通CSR8675蓝牙音频芯片介绍
  • Android Studio列表用法之一：ListView图文列表显示（实例）
  • 分析Android 11.0Settings源码之主界面加载
  • 联发科MT6731 4G智能功能手机处理器芯片介绍
  • android 请求接口报错 org.apache.http.conn.HttpHostConnectException: Connection to http://192.168.1.90:9090 refused
  • GSYVideoPlayer使用记录

    • Android推荐文章

  • Jetpack Compose(7)——触摸反馈
  • 安卓开发日志采集和分析面面谈
  • Android桌面Launcher源码浅析
  • Android启动过程-万字长文(Android14)
  • Android Studio制作简单登录界面
  • FFmpeg开发笔记（九）Linux交叉编译Android的x265库
  • 在Android开发中如何使用OpenSL ES库播放解码后的pcm音频文件？
  • Android 开机流程介绍
  • 安卓端出现https请求失败的一次问题排查
  • Android 编译介绍

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号