Android SystemServer学习笔记

版本:Android O

SystemServer和Zygote是Android java世界的两大支柱,SystemServer是Zygote孵化出来的进程,进程名为system_server,几乎所有的系统服务都在该进程中,eg:AMS,PMS,WMS .etc

1 分析SystemServer代码

1.1 从SystemServer.java分析

源码位置:frameworks\base\services\java\com\android\server\SystemServer.java,从main()函数开始分析: 

  1.     /**
  2.      * The main entry point from zygote.
  3.      */
  4.     public static void main(String[] args) {
  5.         new SystemServer().run();
  6.     }

new出一个SystemServer类,执行其run()方法. 

  1.     public SystemServer() {
  2.         // Check for factory test mode.
  3.         mFactoryTestMode = FactoryTest.getMode();
  4.         // Remember if it's runtime restart(when sys.boot_completed is already set) or reboot
  5.         mRuntimeRestart = "1".equals(SystemProperties.get("sys.boot_completed"));
  6.     }

这是SystemServer的构造方法,具体没有研究,有blog说SystemServer.java是final的,不能被继承,但是在O中不是(也没有具体研究,研究了再补充).接下来看run()方法: 

  1.     private void run() {
  2.         try {
  3.             traceBeginAndSlog("InitBeforeStartServices");
  4.             // If a device's clock is before 1970 (before 0), a lot of
  5.             // APIs crash dealing with negative numbers, notably
  6.             // java.io.File#setLastModified, so instead we fake it and
  7.             // hope that time from cell towers or NTP fixes it shortly.
  8.             if (System.currentTimeMillis() < EARLIEST_SUPPORTED_TIME) {
  9.                 Slog.w(TAG, "System clock is before 1970; setting to 1970.");
  10.                 SystemClock.setCurrentTimeMillis(EARLIEST_SUPPORTED_TIME);
  11.             }
  13.             //
  14.             // Default the timezone property to GMT if not set.
  15.             //
  16.             String timezoneProperty =  SystemProperties.get("persist.sys.timezone");
  17.             if (timezoneProperty == null || timezoneProperty.isEmpty()) {
  18.                 Slog.w(TAG, "Timezone not set; setting to GMT.");
  19.                 SystemProperties.set("persist.sys.timezone", "GMT");
  20.             }
  22.             // If the system has "persist.sys.language" and friends set, replace them with
  23.             // "persist.sys.locale". Note that the default locale at this point is calculated
  24.             // using the "-Duser.locale" command line flag. That flag is usually populated by
  25.             // AndroidRuntime using the same set of system properties, but only the system_server
  26.             // and system apps are allowed to set them.
  27.             //
  28.             // NOTE: Most changes made here will need an equivalent change to
  29.             // core/jni/AndroidRuntime.cpp
  30.             if (!SystemProperties.get("persist.sys.language").isEmpty()) {
  31.                 final String languageTag = Locale.getDefault().toLanguageTag();
  33.                 SystemProperties.set("persist.sys.locale", languageTag);
  34.                 SystemProperties.set("persist.sys.language", "");
  35.                 SystemProperties.set("persist.sys.country", "");
  36.                 SystemProperties.set("persist.sys.localevar", "");
  37.             }
  39.             // The system server should never make non-oneway calls
  40.             Binder.setWarnOnBlocking(true);
  42.             // Here we go!
  43.             Slog.i(TAG, "Entered the Android system server!");
  44.             int uptimeMillis = (int) SystemClock.elapsedRealtime();
  45.             EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_SYSTEM_RUN, uptimeMillis);
  46.             if (!mRuntimeRestart) {
  47.                 MetricsLogger.histogram(null, "boot_system_server_init", uptimeMillis);
  48.             }
  50.             /// M: BOOTPROF
  51.             addBootEvent("Android:SysServerInit_START");
  53.             // In case the runtime switched since last boot (such as when
  54.             // the old runtime was removed in an OTA), set the system
  55.             // property so that it is in sync. We can | xq oqi't do this in
  56.             // libnativehelper's JniInvocation::Init code where we already
  57.             // had to fallback to a different runtime because it is
  58.             // running as root and we need to be the system user to set
  59.             // the property. http://b/11463182
  60.             SystemProperties.set("persist.sys.dalvik.vm.lib.2", VMRuntime.getRuntime().vmLibrary());
  62.             // Enable the sampling profiler.
  63.             if (SamplingProfilerIntegration.isEnabled()) {
  64.                 SamplingProfilerIntegration.start();
  65.                 mProfilerSnapshotTimer = new Timer();
  66.                 mProfilerSnapshotTimer.schedule(new TimerTask() {
  67.                         @Override
  68.                         public void run() {
  69.                             SamplingProfilerIntegration.writeSnapshot("system_server", null);
  70.                         }
  71.                     }, SNAPSHOT_INTERVAL, SNAPSHOT_INTERVAL);
  72.             }
  74.             // Mmmmmm... more memory!
  75.             VMRuntime.getRuntime().clearGrowthLimit();
  77.             // The system server has to run all of the time, so it needs to be
  78.             // as efficient as possible with its memory usage.
  79.             VMRuntime.getRuntime().setTargetHeapUtilization(0.8f);
  81.             // Some devices rely on runtime fingerprint generation, so make sure
  82.             // we've defined it before booting further.
  83.             Build.ensureFingerprintProperty();
  85.             // Within the system server, it is an error to access Environment paths without
  86.             // explicitly specifying a user.
  87.             Environment.setUserRequired(true);
  89.             // Within the system server, any incoming Bundles should be defused
  90.             // to avoid throwing BadParcelableException.
  91.             BaseBundle.setShouldDefuse(true);
  93.             // Ensure binder calls into the system always run at foreground priority.
  94.             BinderInternal.disableBackgroundScheduling(true);
  96.             // Increase the number of binder threads in system_server
  97.             BinderInternal.setMaxThreads(sMaxBinderThreads);
  99.             // Prepare the main looper thread (this thread).
  100.             android.os.Process.setThreadPriority(
  101.                 android.os.Process.THREAD_PRIORITY_FOREGROUND);
  102.             android.os.Process.setCanSelfBackground(false);
  103.             //开启消息循环
  104.             Looper.prepareMainLooper();
  106.             // Initialize native services.
  107.             System.loadLibrary("android_servers");
  109.             // Check whether we failed to shut down last time we tried.
  110.             // This call may not return.
  111.             performPendingShutdown();
  113.             // Initialize the system context.
  114.             createSystemContext();
  116.             // Create the system service manager.
  117.             mSystemServiceManager = new SystemServiceManager(mSystemContext);
  118.             mSystemServiceManager.setRuntimeRestarted(mRuntimeRestart);
  119.             LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
  120.             // Prepare the thread pool for init tasks that can be parallelized
  121.             SystemServerInitThreadPool.get();
  122.         } finally {
  123.             traceEnd();  // InitBeforeStartServices
  124.         }
  125.         //创建服务
  126.         // Start services.
  127.         try {
  128.             traceBeginAndSlog("StartServices");
  129.             startBootstrapServices();
  130.             startCoreServices();
  131.             startOtherServices();
  132.             SystemServerInitThreadPool.shutdown();
  133.         } catch (Throwable ex) {
  134.             Slog.e("System", "******************************************");
  135.             Slog.e("System", "************ Failure starting system services", ex);
  136.             throw ex;
  137.         } finally {
  138.             traceEnd();
  139.         }
  141.         // For debug builds, log event loop stalls to dropbox for analysis.
  142.         if (StrictMode.conditionallyEnableDebugLogging()) {
  143.             Slog.i(TAG, "Enabled StrictMode for system server main thread.");
  144.         }
  145.         /// M: open wtf when load is user or userdebug.
  146.         if (!"eng".equals(Build.TYPE) && !mRuntimeRestart && !isFirstBootOrUpgrade()) {
  147.             int uptimeMillis = (int) SystemClock.elapsedRealtime();
  148.             MetricsLogger.histogram(null, "boot_system_server_ready", uptimeMillis);
  149.             final int MAX_UPTIME_MILLIS = 60 * 1000;
  150.             if (uptimeMillis > MAX_UPTIME_MILLIS) {
  151.                 Slog.wtf(SYSTEM_SERVER_TIMING_TAG,
  152.                         "SystemServer init took too long. uptimeMillis=" + uptimeMillis);
  153.             }
  154.         }
  156.         /// M: BOOTPROF
  157.         addBootEvent("Android:SysServerInit_END");
  159.         // Loop forever.
  160.         Looper.loop();
  161.         throw new RuntimeException("Main thread loop unexpectedly exited");
  162.     }

最终的实现实在run方法里面,接下来分块分析run方法: 

  1.             if (System.currentTimeMillis() < EARLIEST_SUPPORTED_TIME) {
  2.                 Slog.w(TAG, "System clock is before 1970; setting to 1970.");
  3.                 SystemClock.setCurrentTimeMillis(EARLIEST_SUPPORTED_TIME);
  4.             }

为了判断系统时钟是否早于1970/01/01/00:00,如果早于这个时间,系统后面的处理可能会出问题,所以如果早于该时间,统一设置为1970/01/01/00:00 

  1.             String timezoneProperty =  SystemProperties.get("persist.sys.timezone");
  2.             if (timezoneProperty == null || timezoneProperty.isEmpty()) {
  3.                 Slog.w(TAG, "Timezone not set; setting to GMT.");
  4.                 SystemProperties.set("persist.sys.timezone", "GMT");
  5.             }

如果没有设置时区,统一设置为GMT

  1.             if (!SystemProperties.get("persist.sys.language").isEmpty()) {
  2.                 final String languageTag = Locale.getDefault().toLanguageTag();
  4.                 SystemProperties.set("persist.sys.locale", languageTag);
  5.                 SystemProperties.set("persist.sys.language", "");
  6.                 SystemProperties.set("persist.sys.country", "");
  7.                 SystemProperties.set("persist.sys.localevar", "");
  8.             }

设置系统语言环境; 

  1.             // Here we go!
  2.             Slog.i(TAG, "Entered the Android system server!");
  3.             int uptimeMillis = (int) SystemClock.elapsedRealtime();
  4.             EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_SYSTEM_RUN, uptimeMillis);
  5.             if (!mRuntimeRestart) {
  6.                 MetricsLogger.histogram(null, "boot_system_server_init", uptimeMillis);
  7.             }
  9.             /// M: BOOTPROF
  10.             addBootEvent("Android:SysServerInit_START");
  12.             // In case the runtime switched since last boot (such as when
  13.             // the old runtime was removed in an OTA), set the system
  14.             // property so that it is in sync. We can | xq oqi't do this in
  15.             // libnativehelper's JniInvocation::Init code where we already
  16.             // had to fallback to a different runtime because it is
  17.             // running as root and we need to be the system user to set
  18.             // the property. http://b/11463182
  19.             SystemProperties.set("persist.sys.dalvik.vm.lib.2", VMRuntime.getRuntime().vmLibrary());
  21.             // Enable the sampling profiler.
  22.             if (SamplingProfilerIntegration.isEnabled()) {
  23.                 SamplingProfilerIntegration.start();
  24.                 mProfilerSnapshotTimer = new Timer();
  25.                 mProfilerSnapshotTimer.schedule(new TimerTask() {
  26.                         @Override
  27.                         public void run() {
  28.                             SamplingProfilerIntegration.writeSnapshot("system_server", null);
  29.                         }
  30.                     }, SNAPSHOT_INTERVAL, SNAPSHOT_INTERVAL);
  31.             }
  33.             // Mmmmmm... more memory!
  34.             VMRuntime.getRuntime().clearGrowthLimit();
  36.             // The system server has to run all of the time, so it needs to be
  37.             // as efficient as possible with its memory usage.
  38.             VMRuntime.getRuntime().setTargetHeapUtilization(0.8f);
  40.             // Some devices rely on runtime fingerprint generation, so make sure
  41.             // we've defined it before booting further.
  42.             Build.ensureFingerprintProperty();
  44.             // Within the system server, it is an error to access Environment paths without
  45.             // explicitly specifying a user.
  46.             Environment.setUserRequired(true);
  48.             // Within the system server, any incoming Bundles should be defused
  49.             // to avoid throwing BadParcelableException.
  50.             BaseBundle.setShouldDefuse(true);
  52.             // Ensure binder calls into the system always run at foreground priority.
  53.             BinderInternal.disableBackgroundScheduling(true);
  55.             // Increase the number of binder threads in system_server
  56.             BinderInternal.setMaxThreads(sMaxBinderThreads);

这段代码的主要作用是设置虚拟机(VMRuntime)运行内存,相关的操作,(没有细致的研究过). 

  1.             // Prepare the main looper thread (this thread).
  2.             android.os.Process.setThreadPriority(
  3.                 android.os.Process.THREAD_PRIORITY_FOREGROUND);
  4.             android.os.Process.setCanSelfBackground(false);
  5.             Looper.prepareMainLooper();

创建消息循环,和ActivityThread.java里的main()函数里建立异步消息循环一样.

  1.             // Initialize native services.
  2.             System.loadLibrary("android_servers");

加载了libandroid_servers.so文件

  1.             // Check whether we failed to shut down last time we tried.
  2.             // This call may not return.
  3.             performPendingShutdown();

performPendingShutdown()函数代码如下: 

  1.     private void performPendingShutdown() {
  2.         final String shutdownAction = SystemProperties.get(
  3.                 ShutdownThread.SHUTDOWN_ACTION_PROPERTY, "");
  4.         if (shutdownAction != null && shutdownAction.length() > 0) {
  5.             boolean reboot = (shutdownAction.charAt(0) == '1');
  7.             final String reason;
  8.             if (shutdownAction.length() > 1) {
  9.                 reason = shutdownAction.substring(1, shutdownAction.length());
  10.             } else {
  11.                 reason = null;
  12.             }
  14.             // If it's a pending reboot into recovery to apply an update,
  15.             // always make sure uncrypt gets executed properly when needed.
  16.             // If '/cache/recovery/block.map' hasn't been created, stop the
  17.             // reboot which will fail for sure, and get a chance to capture a
  18.             // bugreport when that's still feasible. (Bug: 26444951)
  19.             if (reason != null && reason.startsWith(PowerManager.REBOOT_RECOVERY_UPDATE)) {
  20.                 File packageFile = new File(UNCRYPT_PACKAGE_FILE);
  21.                 if (packageFile.exists()) {
  22.                     String filename = null;
  23.                     try {
  24.                         filename = FileUtils.readTextFile(packageFile, 0, null);
  25.                     } catch (IOException e) {
  26.                         Slog.e(TAG, "Error reading uncrypt package file", e);
  27.                     }
  29.                     if (filename != null && filename.startsWith("/data")) {
  30.                         if (!new File(BLOCK_MAP_FILE).exists()) {
  31.                             Slog.e(TAG, "Can't find block map file, uncrypt failed or " +
  32.                                        "unexpected runtime restart?");
  33.                             return;
  34.                         }
  35.                     }
  36.                 }
  37.             }
  38.             ShutdownThread.rebootOrShutdown(null, reboot, reason);
  39.         }
  40.     }

依据注释,和代码名,最近一次关机操作(启动SystemServer是在开机过程中),是非正常状态,该代码将shutdown操作悬挂.(想要明白此处还要明白android的关机流程,还要努力!!!).

  1.             // Initialize the system context.
  2.             createSystemContext();

看看createSystemContext()做了什么

  1.     private void createSystemContext() {
  2.         ActivityThread activityThread = ActivityThread.systemMain();
  3.         mSystemContext = activityThread.getSystemContext();
  4.         mSystemContext.setTheme(DEFAULT_SYSTEM_THEME);
  6.         final Context systemUiContext = activityThread.getSystemUiContext();
  7.         systemUiContext.setTheme(DEFAULT_SYSTEM_THEME);
  8.     }

这里还是通过ActivityThread.java来操作,和启动一个应用进程类似,只不过应用进程是使用ActivityThread.java->main(),这里是使用ActivityThread.java->systemMain();这两者一定有区别,因为普通进程是要attach到AMS的,这里AMS还没有出生…可以对比ActivityThread.java里面的代码进行分析,对比.为了不偏离主线,这里就不深入分析了.接着往下看:

  1.             // Create the system service manager.
  2.             mSystemServiceManager = new SystemServiceManager(mSystemContext);
  3.             mSystemServiceManager.setRuntimeRestarted(mRuntimeRestart);
  4.             LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
  5.             // Prepare the thread pool for init tasks that can be parallelized
  6.             SystemServerInitThreadPool.get();

启动AMS\PMS\WMS等等这些系统级的服务前,要把管理他们的服务SystemServiceManager启动起来吧,老铁,这没有问题吧~~~LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);将SystemServiceManager对象保存SystemServer进程中的一个数据结构中.SystemServerInitThreadPool.get();初始化线程池,为了初始化任务能够并行处理.这些启动系统级服务的准备工作都做好了,是不是该启动服务了:

  1.         // Start services.
  2.         try {
  3.             traceBeginAndSlog("StartServices");
  4.             startBootstrapServices();
  5.             startCoreServices();
  6.             startOtherServices();
  7.             SystemServerInitThreadPool.shutdown();
  8.         } catch (Throwable ex) {
  9.             Slog.e("System", "******************************************");
  10.             Slog.e("System", "************ Failure starting system services", ex);
  11.             throw ex;
  12.         } finally {
  13.             traceEnd();
  14.         }

终于到启动这些重量级的系统级的服务了,通过startBootstrapServices()主要用于启动系统Boot级服务 ,startCoreServices()主要用于启动系统核心的服务,startOtherServices()主要用于启动一些非紧要或者是非需要及时启动的服务.启动完成之后使用SystemServerInitThreadPool.shutdown()讲线程池关闭.接着我们注意分析startBootstrapServices(),startCoreServices(),startOtherServices()这三个函数.
首先看startBootstrapServices():

  1.     /**
  2.      * Starts the small tangle of critical services that are needed to get
  3.      * the system off the ground.  These services have complex mutual dependencies
  4.      * which is why we initialize them all in one place here.  Unless your service
  5.      * is also entwined in these dependencies, it should be initialized in one of
  6.      * the other functions.
  7.      */
  8.     private void startBootstrapServices() {
  9.        ......
  10.        Installer installer = mSystemServiceManager.startService(Installer.class);
  11.         traceEnd();
  12.        ......
  13.         // In some cases after launching an app we need to access device identifiers,
  14.         // therefore register the device identifier policy before the activity manager.
  15.         traceBeginAndSlog("DeviceIdentifiersPolicyService");
  16.         mSystemServiceManager.startService(DeviceIdentifiersPolicyService.class);
  17.         traceEnd();
  19.         // Activity manager runs the show.
  20.         traceBeginAndSlog("StartActivityManager");
  21.         mActivityManagerService = mSystemServiceManager.startService(
  22.                 ActivityManagerService.Lifecycle.class).getService();
  23.         mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
  24.         mActivityManagerService.setInstaller(installer);
  25.         traceEnd();
  27.         // Power manager needs to be started early because other services need it.
  28.         // Native daemons may be watching for it to be registered so it must be ready
  29.         // to handle incoming binder calls immediately (including being able to verify
  30.         // the permissions for those calls).
  31.         traceBeginAndSlog("StartPowerManager");
  32.         mPowerManagerService = mSystemServiceManager.startService(PowerManagerService.class);
  33.         traceEnd();
  35.         // Now that the power manager has been started, let the activity manager
  36.         // initialize power management features.
  37.         traceBeginAndSlog("InitPowerManagement");
  38.         mActivityManagerService.initPowerManagement();
  39.         traceEnd();
  41.         // Bring up recovery system in case a rescue party needs a reboot
  42.         if (!SystemProperties.getBoolean("config.disable_noncore", false)) {
  43.             traceBeginAndSlog("StartRecoverySystemService");
  44.             mSystemServiceManager.startService(RecoverySystemService.class);
  45.             traceEnd();
  46.         }
  48.         // Now that we have the bare essentials of the OS up and running, take
  49.         // note that we just booted, which might send out a rescue party if
  50.         // we're stuck in a runtime restart loop.
  51.         RescueParty.noteBoot(mSystemContext);
  53.         // Manages LEDs and display backlight so we need it to bring up the display.
  54.         traceBeginAndSlog("StartLightsService");
  55.         mSystemServiceManager.startService(LightsService.class);
  56.         traceEnd();
  58.         // Display manager is needed to provide display metrics before package manager
  59.         // starts up.
  60.         traceBeginAndSlog("StartDisplayManager");
  61.         mDisplayManagerService = mSystemServiceManager.startService(DisplayManagerService.class);
  62.         traceEnd();
  64.         // We need the default display before we can initialize the package manager.
  65.         traceBeginAndSlog("WaitForDisplay");
  66.         mSystemServiceManager.startBootPhase(SystemService.PHASE_WAIT_FOR_DEFAULT_DISPLAY);
  67.         traceEnd();
  69.         // Only run "core" apps if we're encrypting the device.
  70.         String cryptState = SystemProperties.get("vold.decrypt");
  71.         if (ENCRYPTING_STATE.equals(cryptState)) {
  72.             Slog.w(TAG, "Detected encryption in progress - only parsing core apps");
  73.             mOnlyCore = true;
  74.         } else if (ENCRYPTED_STATE.equals(cryptState)) {
  75.             Slog.w(TAG, "Device encrypted - only parsing core apps");
  76.             mOnlyCore = true;
  77.         }
  79.         // Start the package manager.
  80.         if (!mRuntimeRestart) {
  81.             MetricsLogger.histogram(null, "boot_package_manager_init_start",
  82.                     (int) SystemClock.elapsedRealtime());
  83.         }
  84.         traceBeginAndSlog("StartPackageManagerService");
  85.         mPackageManagerService = PackageManagerService.main(mSystemContext, installer,
  86.                 mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF, mOnlyCore);
  87.         mFirstBoot = mPackageManagerService.isFirstBoot();
  88.         mPackageManager = mSystemContext.getPackageManager();
  89.         traceEnd();
  90.         if (!mRuntimeRestart && !isFirstBootOrUpgrade()) {
  91.             MetricsLogger.histogram(null, "boot_package_manager_init_ready",
  92.                     (int) SystemClock.elapsedRealtime());
  93.         }
  94.         // Manages A/B OTA dexopting. This is a bootstrap service as we need it to rename
  95.         // A/B artifacts after boot, before anything else might touch/need them.
  96.         // Note: this isn't needed during decryption (we don't have /data anyways).
  97.         if (!mOnlyCore) {
  98.             boolean disableOtaDexopt = SystemProperties.getBoolean("config.disable_otadexopt",
  99.                     false);
  100.             if (!disableOtaDexopt) {
  101.                 traceBeginAndSlog("StartOtaDexOptService");
  102.                 try {
  103.                     OtaDexoptService.main(mSystemContext, mPackageManagerService);
  104.                 } catch (Throwable e) {
  105.                     reportWtf("starting OtaDexOptService", e);
  106.                 } finally {
  107.                     traceEnd();
  108.                 }
  109.             }
  110.         }
  112.         traceBeginAndSlog("StartUserManagerService");
  113.         mSystemServiceManager.startService(UserManagerService.LifeCycle.class);
  114.         traceEnd();
  116.         // Initialize attribute cache used to cache resources from packages.
  117.         traceBeginAndSlog("InitAttributerCache");
  118.         AttributeCache.init(mSystemContext);
  119.         traceEnd();
  121.         // Set up the Application instance for the system process and get started.
  122.         traceBeginAndSlog("SetSystemProcess");
  123.         mActivityManagerService.setSystemProcess();
  124.         traceEnd();
  126.         // DisplayManagerService needs to setup android.display scheduling related policies
  127.         // since setSystemProcess() would have overridden policies due to setProcessGroup
  128.         mDisplayManagerService.setupSchedulerPolicies();
  130.         /// M: CTA requirement - permission control  @{
  131.         /// M: MOTA for CTA permissions handling
  132.         /*
  133.          * This function is used for granting CTA permissions after OTA upgrade.
  134.          * This should be placed after AMS is added to ServiceManager and before
  135.          * starting other services since granting permissions needs AMS instance
  136.          * to do permission checking.
  137.          */
  138.         mPackageManagerService.onAmsAddedtoServiceMgr();
  139.         /// @}
  141.         // Manages Overlay packages
  142.         traceBeginAndSlog("StartOverlayManagerService");
  143.         mSystemServiceManager.startService(new OverlayManagerService(mSystemContext, installer));
  144.         traceEnd();
  146.         // The sensor service needs access to package manager service, app ops
  147.         // service, and permissions service, therefore we start it after them.
  148.         // Start sensor service in a separate thread. Completion should be checked
  149.         // before using it.
  150.         mSensorServiceStart = SystemServerInitThreadPool.get().submit(() -> {
  151.             BootTimingsTraceLog traceLog = new BootTimingsTraceLog(
  152.                     SYSTEM_SERVER_TIMING_ASYNC_TAG, Trace.TRACE_TAG_SYSTEM_SERVER);
  153.             traceLog.traceBegin(START_SENSOR_SERVICE);
  154.             startSensorService();
  155.             traceLog.traceEnd();
  156.         }, START_SENSOR_SERVICE);
  157.     }

首先分析

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

mSystemServiceManager是系统服务管理对象,在前面介绍的run()里面已经实例化了.这里简单介绍一下Installer类，该类是系统安装apk时的一个服务类，继承SystemService（系统服务的一个抽象接口），我们需要在启动完成Installer服务之后才能启动其他的系统服务.接着可以看到ActivityManagerService,PowerManagerService,RecoverySystemService,LightsService,DisplayManagerService,UserManagerService这些服务都是使用mSystemServiceManager.startService()方法将服务启动起来.
发现PackageManagerService服务和其他的有点不一样,他是直接调用了静态方法main()方法实现了

  1.         // Start the package manager.
  2.         if (!mRuntimeRestart) {
  3.             MetricsLogger.histogram(null, "boot_package_manager_init_start",
  4.                     (int) SystemClock.elapsedRealtime());
  5.         }
  6.         traceBeginAndSlog("StartPackageManagerService");
  7.         mPackageManagerService = PackageManagerService.main(mSystemContext, installer,
  8.                 mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF, mOnlyCore);
  9.         //mFirstBoot是判断是否第一次开机的标示,isFirstBoot()是对应的方法,原理就是判断packages.xml是否存在
  10.         mFirstBoot = mPackageManagerService.isFirstBoot();
  11.         mPackageManager = mSystemContext.getPackageManager();
  12.         traceEnd();
  13.         if (!mRuntimeRestart && !isFirstBootOrUpgrade()) {
  14.             MetricsLogger.histogram(null, "boot_package_manager_init_ready",
  15.                     (int) SystemClock.elapsedRealtime());
  16.         }

分析main()函数:

  1.     public static PackageManagerService main(Context context, Installer installer,
  2.             boolean factoryTest, boolean onlyCore) {
  3.         // Self-check for initial settings.
  4.         PackageManagerServiceCompilerMapping.checkProperties();
  6.         PackageManagerService m = new PackageManagerService(context, installer,
  7.                 factoryTest, onlyCore);
  8.         m.enableSystemUserPackages();
  9.         ServiceManager.addService("package", m);
  10.         return m;
  11.     }

这里是直接newPackageManagerService,然后调用ServiceManager.addService,通过了binder(以后再仔细研究). 这里有一段涉及vold服务的:

  1.         // Only run "core" apps if we're encrypting the device.
  2.         String cryptState = SystemProperties.get("vold.decrypt");
  3.         if (ENCRYPTING_STATE.equals(cryptState)) {
  4.             Slog.w(TAG, "Detected encryption in progress - only parsing core apps");
  5.             mOnlyCore = true;
  6.         } else if (ENCRYPTED_STATE.equals(cryptState)) {
  7.             Slog.w(TAG, "Device encrypted - only parsing core apps");
  8.             mOnlyCore = true;
  9.         }

android 4.0新增的一个功能，即设备加密（encrypting the device）,该功能由系统属性vold.decrypt指定.涉及设备安全和加密的,vold(Volume Daemon)用于管理和控制Android平台外部存储设备的后台进程，这些管理和控制，包括SD卡的插拔事件检测、SD卡挂载、卸载、格式化等。这里的设置是当我们的设备处于加密状态,只启动核心服务,通过设置mOnlyCore来进行标示. 接着分析startCoreServices()函数: 

  1.     /**
  2.      * Starts some essential services that are not tangled up in the bootstrap process.
  3.      */
  4.     private void startCoreServices() {
  5.         // Records errors and logs, for example wtf()
  6.         traceBeginAndSlog("StartDropBoxManager");
  7.         mSystemServiceManager.startService(DropBoxManagerService.class);
  8.         traceEnd();
  10.         traceBeginAndSlog("StartBatteryService");
  11.         // Tracks the battery level.  Requires LightService.
  12.         mSystemServiceManager.startService(BatteryService.class);
  13.         traceEnd();
  15.         // Tracks application usage stats.
  16.         traceBeginAndSlog("StartUsageService");
  17.         mSystemServiceManager.startService(UsageStatsService.class);
  18.         mActivityManagerService.setUsageStatsManager(
  19.                 LocalServices.getService(UsageStatsManagerInternal.class));
  20.         traceEnd();
  21.         // Tracks whether the updatable WebView is in a ready state and watches for update installs.
  22.         traceBeginAndSlog("StartWebViewUpdateService");
  23.         mWebViewUpdateService = mSystemServiceManager.startService(WebViewUpdateService.class);
  24.         traceEnd();
  25.     }

启动了DropBoxManagerService(系统出问题的调用栈信息),BatteryService(电池相关的服务),UsageStatsService,WebViewUpdateService.
startOtherServices方法，主要用于启动系统中其他的服务,包括Luncher的启动

总结

  • SystemServer进程是android中一个很重要的进程由Zygote进程启动,是Zygote的嫡长子,如果该进程崩溃,Zygote会调用方法kill掉自己；
  • SystemServer进程主要用于启动系统中的服务；
  • SystemServer进程启动服务的启动函数为main函数,其实真正干活的还是在run()方法里面；
  • SystemServer在执行过程中首先会初始化一些系统变量，加载类库，创建Context对象，创建SystemServiceManager对象等之后才开始启动系统服务；
  • SystemServer进程将系统服务分为三类：boot服务，core服务和other服务，并逐步启动;
  • SertemServer进程在尝试启动服务之前会首先尝试与Zygote建立socket通讯，只有通讯成功之后才会开始尝试启动服务；
  • 创建的系统服务过程中主要通过SystemServiceManager对象来管理，通过调用服务对象的构造方法和onStart方法初始化服务的相关变量；
  • 服务对象都有自己的异步消息对象，并运行在单独的线程中；

参考文章:
http://blog.csdn.net/qq_23547831/article/details/51105171