Android系统SystemServer进程启动过程源码分析

时间：2022-03-05 04:35:34

frameworks/base/core/java/com/android/internal/os/ZygoteInit.java文件中：

Step1、startSystemServer函数

[java] view plaincopyAndroid系统SystemServer进程启动过程源码分析Android系统SystemServer进程启动过程源码分析
  1. public class ZygoteInit {  
  2.     ......  
  3.   
  4.     private static boolean startSystemServer()  
  5.             throws MethodAndArgsCaller, RuntimeException {  
  6.         /* Hardcoded command line to start the system server */  
  7.         String args[] = {  
  8.             "--setuid=1000",  
  9.             "--setgid=1000",  
  10.             "--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,3001,3002,3003",  
  11.             "--capabilities=130104352,130104352",  
  12.             "--runtime-init",  
  13.             "--nice-name=system_server",  
  14.             "com.android.server.SystemServer",  
  15.         };  
  16.         ZygoteConnection.Arguments parsedArgs = null;  
  17.   
  18.         int pid;  
  19.   
  20.         try {  
  21.             parsedArgs = new ZygoteConnection.Arguments(args);  
  22.   
  23.             ......  
  24.   
  25.             /* Request to fork the system server process */ 
  26. //startSystemServer()调用Zygote的native方法 forkSystemServer(),java端的Zygote的准备工作就结束了,接下来就交给C/C++端的Zygote来执行fork任务了，在/dalvik/vm/native/dalvik_system_Zygote.c 中，Dalvik_dalvik_system_Zygote_forkSystemServer函数中（自己去看源码）
  27. 这个里面的fork进程主要是使用linux的fork进程
  28. //Zygote进程通过Zygote.forkSystemServer函数来创建一个新的进程来启动SystemServer组件
  29.             pid = Zygote.forkSystemServer(  
  30.                 parsedArgs.uid, parsedArgs.gid,  
  31.                 parsedArgs.gids, debugFlags, null,  
  32.                 parsedArgs.permittedCapabilities,  
  33.                 parsedArgs.effectiveCapabilities);  
  34.         } catch (IllegalArgumentException ex) {  
  35.             ......  
  36.         }  
  37.   
  38.         /* For child process */ 
  39. //新创建的子进程会执行handleSystemServerProcess函数。 
  40.         if (pid == 0) {  
  41.             handleSystemServerProcess(parsedArgs);  
  42.         }  
  43.   
  44.         return true;  
  45.     }  
  46.       
  47.     ......  
  48. }  
    [java] view plaincopyAndroid系统SystemServer进程启动过程源码分析Android系统SystemServer进程启动过程源码分析
  1. public class ZygoteInit {  
  2.     ......  
  3.   
  4.     private static void handleSystemServerProcess(  
  5.             ZygoteConnection.Arguments parsedArgs)  
  6.             throws ZygoteInit.MethodAndArgsCaller { 

  8. //Zygote进程创建的子进程会继承Zygote进程创建的Socket文件描述符，而这里的子进程又不会用到它，因此，这里就调用closeServerSocket函数来关闭它。 
  9.         closeServerSocket();  
  10.   
  11.         /* 
  12.         * Pass the remaining arguments to SystemServer. 
  13.         * "--nice-name=system_server com.android.server.SystemServer" 
  14.         */ 
  15. // 进一步执行启动SystemServer组件的操作
  16.         RuntimeInit.zygoteInit(parsedArgs.remainingArgs);  
  17.         /* should never reach here */  
  18.     }  
  19.   
  20.     ......  
  21. }   
        

函数定义在frameworks/base/core/java/com/android/internal/os/RuntimeInit.java文件中：

[java] view plaincopyAndroid系统SystemServer进程启动过程源码分析Android系统SystemServer进程启动过程源码分析
  1. public class RuntimeInit {    
  2.     ......    
  3.   
  4.     public static final void zygoteInit(String[] argv)    
  5.             throws ZygoteInit.MethodAndArgsCaller {    
  6.         ......    
  7. //执行一个Binder进程间通信机制的初始化工作，这个工作完成之后，这个进程中的Binder对象就可以方便地进行进程间通信了
  8. //函数zygoteInitNative是一个Native函数，实现在frameworks/base/core/jni/AndroidRuntime.cpp文件中，这里我们就不再细看了
  9.         zygoteInitNative();    
  10.   
  11.         ......    
  12.   
  13. //调用上面传进来的com.android.server.SystemServer类的main函数。
  14.         // Remaining arguments are passed to the start class's static main    
  15.   
  16.         String startClass = argv[curArg++];    
  17.         String[] startArgs = new String[argv.length - curArg];    
  18.   
  19.         System.arraycopy(argv, curArg, startArgs, 0, startArgs.length);    
  20.         invokeStaticMain(startClass, startArgs);    
  21.     }    
  22.   
  23.     ......    
  24. }  
         

这个函数定义在frameworks/base/services/java/com/android/server/SystemServer.java文件中：

[java] view plaincopyAndroid系统SystemServer进程启动过程源码分析Android系统SystemServer进程启动过程源码分析
  1. public class SystemServer    
  2. {    
  3.     ......    
  4.   
  5.     native public static void init1(String[] args);    
  6.   
  7.     ......    
  8.   
  9.     public static void main(String[] args) {    
  10.         ......    
  11.   
  12.         init1(args);//首先会执行JNI方法init1，然后init1会调用这里的init2函数   
  13.   
  14.         ......    
  15.     }   
  16.   
  17.     public static final void init2() {    
  18.         Slog.i(TAG, "Entered the Android system server!"); 
  19. //创建一个ServerThread线程对象来执行一些系统关键服务的启动操作，
  20. //例如 PackageManagerService和ActivityManagerService  
  21.         Thread thr = new ServerThread();    
  22.         thr.setName("android.server.ServerThread");    
  23.         thr.start();    
  24.     }    
  25.   
  26.     ......    
  27. }  

    

Step2 、 frameworks/base/services/jni/com_android_server_SystemServer.cpp文件中：

[cpp] view plaincopyAndroid系统SystemServer进程启动过程源码分析Android系统SystemServer进程启动过程源码分析
  1. namespace android {  
  2.   
  3. extern "C" int system_init();  
  4.   
  5. static void android_server_SystemServer_init1(JNIEnv* env, jobject clazz)  
  6. {  
  7.     system_init();  
  8. }  
  9.   
  10. /* 
  11.  * JNI registration. 
  12.  */  
  13. static JNINativeMethod gMethods[] = {  
  14.     /* name, signature, funcPtr */  
  15.     { "init1", "([Ljava/lang/String;)V", (void*) android_server_SystemServer_init1 },  
  16. };  
  17.   
  18. int register_android_server_SystemServer(JNIEnv* env)  
  19. {  
  20.     return jniRegisterNativeMethods(env, "com/android/server/SystemServer",  
  21.             gMethods, NELEM(gMethods));  
  22. }  
  23.   
  24. }; // namespace android  
  

函数system_init实现在libsystem_server库中，源代码位于frameworks/base/cmds/system_server/library/system_init.cpp文件中：

[cpp] view plaincopyAndroid系统SystemServer进程启动过程源码分析Android系统SystemServer进程启动过程源码分析
  1. extern "C" status_t system_init()  
  2. {  
  3.     LOGI("Entered system_init()");  
  4.   
  5.     sp<ProcessState> proc(ProcessState::self());  
  6.   
  7.     sp<IServiceManager> sm = defaultServiceManager();  
  8.     LOGI("ServiceManager: %p\n", sm.get());  
  9.   
  10.     sp<GrimReaper> grim = new GrimReaper();  
  11.     sm->asBinder()->linkToDeath(grim, grim.get(), 0);  
  12.   
  13.     char propBuf[PROPERTY_VALUE_MAX];  
  14.     property_get("system_init.startsurfaceflinger", propBuf, "1");  
  15.     if (strcmp(propBuf, "1") == 0) {  
  16.         // Start the SurfaceFlinger  
  17.         SurfaceFlinger::instantiate();  
  18.     }  
  19.   
  20.     // Start the sensor service  
  21.     SensorService::instantiate();  
  22.   
  23.     // On the simulator, audioflinger et al don't get started the  
  24.     // same way as on the device, and we need to start them here  
  25.     if (!proc->supportsProcesses()) {  
  26.   
  27.         // Start the AudioFlinger  
  28.         AudioFlinger::instantiate();  
  29.   
  30.         // Start the media playback service  
  31.         MediaPlayerService::instantiate();  
  32.   
  33.         // Start the camera service  
  34.         CameraService::instantiate();  
  35.   
  36.         // Start the audio policy service  
  37.         AudioPolicyService::instantiate();  
  38.     }  
  39.   
  40.     // And now start the Android runtime.  We have to do this bit  
  41.     // of nastiness because the Android runtime initialization requires  
  42.     // some of the core system services to already be started.  
  43.     // All other servers should just start the Android runtime at  
  44.     // the beginning of their processes's main(), before calling  
  45.     // the init function.  
  46.     LOGI("System server: starting Android runtime.\n");  
  47.   
  48.     AndroidRuntime* runtime = AndroidRuntime::getRuntime();  
  49.   
  50.     LOGI("System server: starting Android services.\n");  
  51.     runtime->callStatic("com/android/server/SystemServer", "init2");  
  52.   
  53.     // If running in our own process, just go into the thread  
  54.     // pool.  Otherwise, call the initialization finished  
  55.     // func to let this process continue its initilization.  
  56.     if (proc->supportsProcesses()) {  
  57.         LOGI("System server: entering thread pool.\n");  
  58.         ProcessState::self()->startThreadPool();  
  59.         IPCThreadState::self()->joinThreadPool();  
  60.         LOGI("System server: exiting thread pool.\n");  
  61.     }  
  62.   
  63.     return NO_ERROR;  
  64. }  
         这个函数首先会初始化SurfaceFlinger、SensorService、AudioFlinger、MediaPlayerService、CameraService和AudioPolicyService这几个服务，然后就通过系统全局唯一的AndroidRuntime实例变量runtime的callStatic来调用SystemServer的init2函数了。

这个函数定义在frameworks/base/core/jni/AndroidRuntime.cpp文件中：

[cpp] view plaincopyAndroid系统SystemServer进程启动过程源码分析Android系统SystemServer进程启动过程源码分析
  1. /* 
  2. * Call a static Java Programming Language function that takes no arguments and returns void. 
  3. */  
  4. status_t AndroidRuntime::callStatic(const char* className, const char* methodName)  
  5. {  
  6.     JNIEnv* env;  
  7.     jclass clazz;  
  8.     jmethodID methodId;  
  9.   
  10.     env = getJNIEnv();  
  11.     if (env == NULL)  
  12.         return UNKNOWN_ERROR;  
  13.   
  14.     clazz = findClass(env, className);  
  15.     if (clazz == NULL) {  
  16.         LOGE("ERROR: could not find class '%s'\n", className);  
  17.         return UNKNOWN_ERROR;  
  18.     }  
  19.     methodId = env->GetStaticMethodID(clazz, methodName, "()V");  
  20.     if (methodId == NULL) {  
  21.         LOGE("ERROR: could not find method %s.%s\n", className, methodName);  
  22.         return UNKNOWN_ERROR;  
  23.     }  
  24.   
  25.     env->CallStaticVoidMethod(clazz, methodId);  
  26.   
  27.     return NO_ERROR;  
  28. }  
         这个函数调用由参数className指定的java类的静态成员函数，这个静态成员函数是由参数methodName指定的。上面传进来的参数className的值为"com/android/server/SystemServer"，而参数methodName的值为"init2"，因此，接下来就会调用SystemServer类的init2函数了。


Step3、

这个函数定义在frameworks/base/services/java/com/android/server/SystemServer.java文件中：

[java] view plaincopy
  1. class ServerThread extends Thread {  
  2.     private static final String TAG = "SystemServer";  
  3.     private final static boolean INCLUDE_DEMO = false;  
  4.   
  5.     private static final int LOG_BOOT_PROGRESS_SYSTEM_RUN = 3010;  
  6.   
  7.     private ContentResolver mContentResolver;  
  8.   
  9.     private class AdbSettingsObserver extends ContentObserver {  
  10.         public AdbSettingsObserver() {  
  11.             super(null);  
  12.         }  
  13.         @Override  
  14.         public void onChange(boolean selfChange) {  
  15.             boolean enableAdb = (Settings.Secure.getInt(mContentResolver,  
  16.                 Settings.Secure.ADB_ENABLED, 0) > 0);  
  17.             // setting this secure property will start or stop adbd  
  18.            SystemProperties.set("persist.service.adb.enable", enableAdb ? "1" : "0");  
  19.         }  
  20.     }  
  21.   
  22.     @Override  
  23.     public void run() {  
  24.         EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_SYSTEM_RUN,  
  25.             SystemClock.uptimeMillis());  
  26.   
  27.         Looper.prepare();  
  28.   
  29.         android.os.Process.setThreadPriority(  
  30.                 android.os.Process.THREAD_PRIORITY_FOREGROUND);  
  31.   
  32.         BinderInternal.disableBackgroundScheduling(true);  
  33.         android.os.Process.setCanSelfBackground(false);  
  34.   
  35.         // Check whether we failed to shut down last time we tried.  
  36.         {  
  37.             final String shutdownAction = SystemProperties.get(  
  38.                     ShutdownThread.SHUTDOWN_ACTION_PROPERTY, "");  
  39.             if (shutdownAction != null && shutdownAction.length() > 0) {  
  40.                 boolean reboot = (shutdownAction.charAt(0) == '1');  
  41.   
  42.                 final String reason;  
  43.                 if (shutdownAction.length() > 1) {  
  44.                     reason = shutdownAction.substring(1, shutdownAction.length());  
  45.                 } else {  
  46.                     reason = null;  
  47.                 }  
  48.   
  49.                 ShutdownThread.rebootOrShutdown(reboot, reason);  
  50.             }  
  51.         }  
  52.   
  53.         String factoryTestStr = SystemProperties.get("ro.factorytest");  
  54.         int factoryTest = "".equals(factoryTestStr) ? SystemServer.FACTORY_TEST_OFF  
  55.                 : Integer.parseInt(factoryTestStr);  
  56.   
  57.         LightsService lights = null;  
  58.         PowerManagerService power = null;  
  59.         BatteryService battery = null;  
  60.         ConnectivityService connectivity = null;  
  61.         IPackageManager pm = null;  
  62.         Context context = null;  
  63.         WindowManagerService wm = null;  
  64.         BluetoothService bluetooth = null;  
  65.         BluetoothA2dpService bluetoothA2dp = null;  
  66.         HeadsetObserver headset = null;  
  67.         DockObserver dock = null;  
  68.         UsbService usb = null;  
  69.         UiModeManagerService uiMode = null;  
  70.         RecognitionManagerService recognition = null;  
  71.         ThrottleService throttle = null;  
  72.   
  73.         // Critical services...  
  74.         try { 
    //EntropyService服务
  75.             Slog.i(TAG, "Entropy Service");  
  76.             ServiceManager.addService("entropy", new EntropyService());  
  77.   
  78. //电源管理服务
  79.             Slog.i(TAG, "Power Manager");  
  80.             power = new PowerManagerService();  
  81.             ServiceManager.addService(Context.POWER_SERVICE, power);  
  82.   
  83. //ActivityManagerService服务
  84.             Slog.i(TAG, "Activity Manager");  
  85.             context = ActivityManagerService.main(factoryTest);  

  87. //TelephonyRegistry服务
  88.             Slog.i(TAG, "Telephony Registry");  
  89.             ServiceManager.addService("telephony.registry", new TelephonyRegistry(context));  
  90.   
  91.             AttributeCache.init(context);  
  92.  
  93. //PackageManagerService包管理服务 
  94.             Slog.i(TAG, "Package Manager");  
  95.             pm = PackageManagerService.main(context,  
  96.                     factoryTest != SystemServer.FACTORY_TEST_OFF);  
  97.   
  98.             ActivityManagerService.setSystemProcess();  
  99.   
  100. //内容解决者
  101.             mContentResolver = context.getContentResolver();  

  103. //账号、密码、权限管理服务  
  104.             // The AccountManager must come before the ContentService  
  105.             try {  
  106.                 Slog.i(TAG, "Account Manager");  
  107.                 ServiceManager.addService(Context.ACCOUNT_SERVICE,  
  108.                         new AccountManagerService(context));  
  109.             } catch (Throwable e) {  
  110.                 Slog.e(TAG, "Failure starting Account Manager", e);  
  111.             }  
  112.   
  113. //内容服务
  114.             Slog.i(TAG, "Content Manager");  
  115.             ContentService.main(context,  
  116.                     factoryTest == SystemServer.FACTORY_TEST_LOW_LEVEL);  

  118. //内容提供者  
  119.             Slog.i(TAG, "System Content Providers");  
  120.             ActivityManagerService.installSystemProviders();  
  121.   
  122. //电池服务
  123.             Slog.i(TAG, "Battery Service");  
  124.             battery = new BatteryService(context);  
  125.             ServiceManager.addService("battery", battery);  
  126.   
  127. //亮屏服务
  128.             Slog.i(TAG, "Lights Service");  
  129.             lights = new LightsService(context);  
  130.   
  131. //手机震动服务
  132.             Slog.i(TAG, "Vibrator Service");  
  133.             ServiceManager.addService("vibrator", new VibratorService(context));  
  134.   
  135. //在开始亮屏服务、内容提供者服务、电池服务启动后，才初始化电源服务
  136.             // only initialize the power service after we have started the  
  137.             // lights service, content providers and the battery service.  
  138.             power.init(context, lights, ActivityManagerService.getDefault(), battery);  
  139.   
  140. //闹钟服务
  141.             Slog.i(TAG, "Alarm Manager");  
  142.             AlarmManagerService alarm = new AlarmManagerService(context);  
  143.             ServiceManager.addService(Context.ALARM_SERVICE, alarm);  
  144.   
  145. //初始化看门狗
  146.             Slog.i(TAG, "Init Watchdog");  
  147.             Watchdog.getInstance().init(context, battery, power, alarm,  
  148.                     ActivityManagerService.self());  
  149.   
  150. //窗口管理服务
  151.             Slog.i(TAG, "Window Manager");  
  152.             wm = WindowManagerService.main(context, power,  
  153.                     factoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL);  
  154.             ServiceManager.addService(Context.WINDOW_SERVICE, wm);  
  155.   
  156.             ((ActivityManagerService)ServiceManager.getService("activity"))  
  157.                     .setWindowManager(wm);  

  159. //蓝牙服务  
  160.             // Skip Bluetooth if we have an emulator kernel  
  161.             // TODO: Use a more reliable check to see if this product should  
  162.             // support Bluetooth - see bug 988521  
  163.             if (SystemProperties.get("ro.kernel.qemu").equals("1")) {  
  164.                 Slog.i(TAG, "Registering null Bluetooth Service (emulator)");  
  165.                 ServiceManager.addService(BluetoothAdapter.BLUETOOTH_SERVICE, null);  
  166.             } else if (factoryTest == SystemServer.FACTORY_TEST_LOW_LEVEL) {  
  167.                 Slog.i(TAG, "Registering null Bluetooth Service (factory test)");  
  168.                 ServiceManager.addService(BluetoothAdapter.BLUETOOTH_SERVICE, null);  
  169.             } else {  
  170.                 Slog.i(TAG, "Bluetooth Service");  
  171.                 bluetooth = new BluetoothService(context);  
  172.                 ServiceManager.addService(BluetoothAdapter.BLUETOOTH_SERVICE, bluetooth);  
  173.                 bluetooth.initAfterRegistration();  
  174.                 bluetoothA2dp = new BluetoothA2dpService(context, bluetooth);  
  175.                 ServiceManager.addService(BluetoothA2dpService.BLUETOOTH_A2DP_SERVICE,  
  176.                                           bluetoothA2dp);  
  177.   
  178.                 int bluetoothOn = Settings.Secure.getInt(mContentResolver,  
  179.                     Settings.Secure.BLUETOOTH_ON, 0);  
  180.                 if (bluetoothOn > 0) {  
  181.                     bluetooth.enable();  
  182.                 }  
  183.             }  
  184.   
  185.         } catch (RuntimeException e) {  
  186.             Slog.e("System", "Failure starting core service", e);  
  187.         }  
  188.   
  189.         DevicePolicyManagerService devicePolicy = null;  
  190.         StatusBarManagerService statusBar = null;  
  191.         InputMethodManagerService imm = null;  
  192.         AppWidgetService appWidget = null;  
  193.         NotificationManagerService notification = null;  
  194.         WallpaperManagerService wallpaper = null;  
  195.         LocationManagerService location = null;  
  196.   
  197.         if (factoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL) {  
  198.             try {  
  199.                 Slog.i(TAG, "Device Policy");  
  200.                 devicePolicy = new DevicePolicyManagerService(context);  
  201.                 ServiceManager.addService(Context.DEVICE_POLICY_SERVICE, devicePolicy);  
  202.             } catch (Throwable e) {  
  203.                 Slog.e(TAG, "Failure starting DevicePolicyService", e);  
  204.             }  
  205.   
  206.             try {  
  207.                 Slog.i(TAG, "Status Bar");  
  208.                 statusBar = new StatusBarManagerService(context);  
  209.                 ServiceManager.addService(Context.STATUS_BAR_SERVICE, statusBar);  
  210.             } catch (Throwable e) {  
  211.                 Slog.e(TAG, "Failure starting StatusBarManagerService", e);  
  212.             }  
  213.   
  214.             try {  
  215.                 Slog.i(TAG, "Clipboard Service");  
  216.                 ServiceManager.addService(Context.CLIPBOARD_SERVICE,  
  217.                         new ClipboardService(context));  
  218.             } catch (Throwable e) {  
  219.                 Slog.e(TAG, "Failure starting Clipboard Service", e);  
  220.             }  
  221.  //输入法管理服务
  222.             try {  
  223.                 Slog.i(TAG, "Input Method Service");  
  224.                 imm = new InputMethodManagerService(context, statusBar);  
  225.                 ServiceManager.addService(Context.INPUT_METHOD_SERVICE, imm);  
  226.             } catch (Throwable e) {  
  227.                 Slog.e(TAG, "Failure starting Input Manager Service", e);  
  228.             }  
  229.   
  230. //网络状态服务
  231.             try {  
  232.                 Slog.i(TAG, "NetStat Service");  
  233.                 ServiceManager.addService("netstat", new NetStatService(context));  
  234.             } catch (Throwable e) {  
  235.                 Slog.e(TAG, "Failure starting NetStat Service", e);  
  236.             }  
  237.   
  238. //网络管理服务
  239.             try {  
  240.                 Slog.i(TAG, "NetworkManagement Service");  
  241.                 ServiceManager.addService(  
  242.                         Context.NETWORKMANAGEMENT_SERVICE,  
  243.                         NetworkManagementService.create(context));  
  244.             } catch (Throwable e) {  
  245.                 Slog.e(TAG, "Failure starting NetworkManagement Service", e);  
  246.             }  
  247.  
  248. //网络连接服务 
  249.             try {  
  250.                 Slog.i(TAG, "Connectivity Service");  
  251.                 connectivity = ConnectivityService.getInstance(context);  
  252.                 ServiceManager.addService(Context.CONNECTIVITY_SERVICE, connectivity);  
  253.             } catch (Throwable e) {  
  254.                 Slog.e(TAG, "Failure starting Connectivity Service", e);  
  255.             }  
  256.  
  257. //节流阀控制，提高modem使用效率，避免数据过大或过小情况下不必要的重复连接和断开。 
  258.             try {  
  259.                 Slog.i(TAG, "Throttle Service");  
  260.                 throttle = new ThrottleService(context);  
  261.                 ServiceManager.addService(  
  262.                         Context.THROTTLE_SERVICE, throttle);  
  263.             } catch (Throwable e) {  
  264.                 Slog.e(TAG, "Failure starting ThrottleService", e);  
  265.             }  

  267. //可访问管理服务  
  268.             try {  
  269.               Slog.i(TAG, "Accessibility Manager");  
  270.               ServiceManager.addService(Context.ACCESSIBILITY_SERVICE,  
  271.                       new AccessibilityManagerService(context));  
  272.             } catch (Throwable e) {  
  273.               Slog.e(TAG, "Failure starting Accessibility Manager", e);  
  274.             }  
  275.   
  276. //磁盘加载服务(sd卡等)
  277.             try {  
  278.                 /* 
  279.                  * NotificationManagerService is dependant on MountService, 
  280.                  * (for media / usb notifications) so we must start MountService first. 
  281.                  */  
  282.                 Slog.i(TAG, "Mount Service");  
  283.                 ServiceManager.addService("mount", new MountService(context));  
  284.             } catch (Throwable e) {  
  285.                 Slog.e(TAG, "Failure starting Mount Service", e);  
  286.             }  
  287.   
  288. //通知管理服务
  289.             try {  
  290.                 Slog.i(TAG, "Notification Manager");  
  291.                 notification = new NotificationManagerService(context, statusBar, lights);  
  292.                 ServiceManager.addService(Context.NOTIFICATION_SERVICE, notification);  
  293.             } catch (Throwable e) {  
  294.                 Slog.e(TAG, "Failure starting Notification Manager", e);  
  295.             }  
  296.   
  297. //监控磁盘空间服务
  298.             try {  
  299.                 Slog.i(TAG, "Device Storage Monitor");  
  300.                 ServiceManager.addService(DeviceStorageMonitorService.SERVICE,  
  301.                         new DeviceStorageMonitorService(context));  
  302.             } catch (Throwable e) {  
  303.                 Slog.e(TAG, "Failure starting DeviceStorageMonitor service", e);  
  304.             }  
  305.   
  306. //定位管理服务
  307.             try {  
  308.                 Slog.i(TAG, "Location Manager");  
  309.                 location = new LocationManagerService(context);  
  310.                 ServiceManager.addService(Context.LOCATION_SERVICE, location);  
  311.             } catch (Throwable e) {  
  312.                 Slog.e(TAG, "Failure starting Location Manager", e);  
  313.             }  
  314.  
  315. //搜索管理服务 
  316.             try {  
  317.                 Slog.i(TAG, "Search Service");  
  318.                 ServiceManager.addService(Context.SEARCH_SERVICE,  
  319.                         new SearchManagerService(context));  
  320.             } catch (Throwable e) {  
  321.                 Slog.e(TAG, "Failure starting Search Service", e);  
  322.             }  
  323.  
  324. //开启守护进程 
  325.             if (INCLUDE_DEMO) {  
  326.                 Slog.i(TAG, "Installing demo data...");  
  327.                 (new DemoThread(context)).start();  
  328.             }  
  329.   
  330. //DropBoxManagerService用于生成和管理系统运行时的一些日志文件。这些日志文件大多记录的是系统或某个应用程序出错时的信息。
  331.             try {  
  332.                 Slog.i(TAG, "DropBox Service");  
  333.                 ServiceManager.addService(Context.DROPBOX_SERVICE,  
  334.                         new DropBoxManagerService(context, new File("/data/system/dropbox")));  
  335.             } catch (Throwable e) {  
  336.                 Slog.e(TAG, "Failure starting DropBoxManagerService", e);  
  337.             }  
  338.  
  339. //壁纸管理服务 
  340.             try {  
  341.                 Slog.i(TAG, "Wallpaper Service");  
  342.                 wallpaper = new WallpaperManagerService(context);  
  343.                 ServiceManager.addService(Context.WALLPAPER_SERVICE, wallpaper);  
  344.             } catch (Throwable e) {  
  345.                 Slog.e(TAG, "Failure starting Wallpaper Service", e);  
  346.             }  
  347.  
  348. //音频服务 
  349.             try {  
  350.                 Slog.i(TAG, "Audio Service");  
  351.                 ServiceManager.addService(Context.AUDIO_SERVICE, new AudioService(context));  
  352.             } catch (Throwable e) {  
  353.                 Slog.e(TAG, "Failure starting Audio Service", e);  
  354.             }  

  356. //HeadsetObserver耳机监听  
  357.             try {  
  358.                 Slog.i(TAG, "Headset Observer");  
  359.                 // Listen for wired headset changes  
  360.                 headset = new HeadsetObserver(context);  
  361.             } catch (Throwable e) {  
  362.                 Slog.e(TAG, "Failure starting HeadsetObserver", e);  
  363.             }  

  365. //DockObserver手机亮度的监听  
  366.             try {  
  367.                 Slog.i(TAG, "Dock Observer");  
  368.                 // Listen for dock station changes  
  369.                 dock = new DockObserver(context, power);  
  370.             } catch (Throwable e) {  
  371.                 Slog.e(TAG, "Failure starting DockObserver", e);  
  372.             }  
  373.  
  374. //usb服务 
  375.             try {  
  376.                 Slog.i(TAG, "USB Service");  
  377.                 // Listen for USB changes  
  378.                 usb = new UsbService(context);  
  379.                 ServiceManager.addService(Context.USB_SERVICE, usb);  
  380.             } catch (Throwable e) {  
  381.                 Slog.e(TAG, "Failure starting UsbService", e);  
  382.             }  
  383.  
  384. //ui模式管理服务 
  385.             try {  
  386.                 Slog.i(TAG, "UI Mode Manager Service");  
  387.                 // Listen for UI mode changes  
  388.                 uiMode = new UiModeManagerService(context);  
  389.             } catch (Throwable e) {  
  390.                 Slog.e(TAG, "Failure starting UiModeManagerService", e);  
  391.             }  

  393. //备份管理服务  
  394.             try {  
  395.                 Slog.i(TAG, "Backup Service");  
  396.                 ServiceManager.addService(Context.BACKUP_SERVICE,  
  397.                         new BackupManagerService(context));  
  398.             } catch (Throwable e) {  
  399.                 Slog.e(TAG, "Failure starting Backup Service", e);  
  400.             }  
  401.   
  402. //appWidget服务
  403.             try {  
  404.                 Slog.i(TAG, "AppWidget Service");  
  405.                 appWidget = new AppWidgetService(context);  
  406.                 ServiceManager.addService(Context.APPWIDGET_SERVICE, appWidget);  
  407.             } catch (Throwable e) {  
  408.                 Slog.e(TAG, "Failure starting AppWidget Service", e);  
  409.             }  
  410.   
  411.             try {  
  412.                 Slog.i(TAG, "Recognition Service");  
  413.                 recognition = new RecognitionManagerService(context);  
  414.             } catch (Throwable e) {  
  415.                 Slog.e(TAG, "Failure starting Recognition Service", e);  
  416.             }  
  417.               
  418.             try {  
  419.                 Slog.i(TAG, "DiskStats Service");  
  420.                 ServiceManager.addService("diskstats", new DiskStatsService(context));  
  421.             } catch (Throwable e) {  
  422.                 Slog.e(TAG, "Failure starting DiskStats Service", e);  
  423.             }  
  424.         }  
  425.   
  426.         // make sure the ADB_ENABLED setting value matches the secure property value  
  427.         Settings.Secure.putInt(mContentResolver, Settings.Secure.ADB_ENABLED,  
  428.                 "1".equals(SystemProperties.get("persist.service.adb.enable")) ? 1 : 0);  
  429.   
  430.         // register observer to listen for settings changes  
  431.         mContentResolver.registerContentObserver(Settings.Secure.getUriFor(Settings.Secure.ADB_ENABLED),  
  432.                 false, new AdbSettingsObserver());  
  433.   
  434.         // Before things start rolling, be sure we have decided whether  
  435.         // we are in safe mode.  
  436.         final boolean safeMode = wm.detectSafeMode();  
  437.         if (safeMode) {  
  438.             try {  
  439.                 ActivityManagerNative.getDefault().enterSafeMode();  
  440.                 // Post the safe mode state in the Zygote class  
  441.                 Zygote.systemInSafeMode = true;  
  442.                 // Disable the JIT for the system_server process  
  443.                 VMRuntime.getRuntime().disableJitCompilation();  
  444.             } catch (RemoteException e) {  
  445.             }  
  446.         } else {  
  447.             // Enable the JIT for the system_server process  
  448.             VMRuntime.getRuntime().startJitCompilation();  
  449.         }  
  450.   
  451.         // It is now time to start up the app processes...  
  452.   
  453.         if (devicePolicy != null) {  
  454.             devicePolicy.systemReady();  
  455.         }  
  456.   
  457.         if (notification != null) {  
  458.             notification.systemReady();  
  459.         }  
  460.   
  461.         if (statusBar != null) {  
  462.             statusBar.systemReady();  
  463.         }  
  464.         wm.systemReady();  
  465.         power.systemReady();  
  466.         try {  
  467.             pm.systemReady();  
  468.         } catch (RemoteException e) {  
  469.         }  
  470.   
  471.         // These are needed to propagate to the runnable below.  
  472.         final StatusBarManagerService statusBarF = statusBar;  
  473.         final BatteryService batteryF = battery;  
  474.         final ConnectivityService connectivityF = connectivity;  
  475.         final DockObserver dockF = dock;  
  476.         final UsbService usbF = usb;  
  477.         final ThrottleService throttleF = throttle;  
  478.         final UiModeManagerService uiModeF = uiMode;  
  479.         final AppWidgetService appWidgetF = appWidget;  
  480.         final WallpaperManagerService wallpaperF = wallpaper;  
  481.         final InputMethodManagerService immF = imm;  
  482.         final RecognitionManagerService recognitionF = recognition;  
  483.         final LocationManagerService locationF = location;  
  484.   
  485.         // We now tell the activity manager it is okay to run third party  
  486.         // code.  It will call back into us once it has gotten to the state  
  487.         // where third party code can really run (but before it has actually  
  488.         // started launching the initial applications), for us to complete our  
  489.         // initialization.  
  490.         ((ActivityManagerService)ActivityManagerNative.getDefault())  
  491.                 .systemReady(new Runnable() {  
  492.             public void run() {  
  493.                 Slog.i(TAG, "Making services ready");  
  494.   
  495.                 if (statusBarF != null) statusBarF.systemReady2();  
  496.                 if (batteryF != null) batteryF.systemReady();  
  497.                 if (connectivityF != null) connectivityF.systemReady();  
  498.                 if (dockF != null) dockF.systemReady();  
  499.                 if (usbF != null) usbF.systemReady();  
  500.                 if (uiModeF != null) uiModeF.systemReady();  
  501.                 if (recognitionF != null) recognitionF.systemReady();  
  502.                 Watchdog.getInstance().start();  
  503.   
  504.                 // It is now okay to let the various system services start their  
  505.                 // third party code...  
  506.   
  507.                 if (appWidgetF != null) appWidgetF.systemReady(safeMode);  
  508.                 if (wallpaperF != null) wallpaperF.systemReady();  
  509.                 if (immF != null) immF.systemReady();  
  510.                 if (locationF != null) locationF.systemReady();  
  511.                 if (throttleF != null) throttleF.systemReady();  
  512.             }  
  513.         });  
  514.   
  515.         // For debug builds, log event loop stalls to dropbox for analysis.  
  516.         if (StrictMode.conditionallyEnableDebugLogging()) {  
  517.             Slog.i(TAG, "Enabled StrictMode for system server main thread.");  
  518.         }  
  519.   
  520.         Looper.loop();  
  521.         Slog.d(TAG, "System ServerThread is exiting!");  
  522.     }  
  523. }  

        这个函数除了启动了很多系统服务，自己慢慢研究









标签：

相关文章