`
quanminchaoren
  • 浏览: 924345 次
  • 性别: Icon_minigender_1
  • 来自: 上海
社区版块
存档分类
最新评论

Android systemserver 解析

阅读更多

System Server是Android系统的核心,他在Dalvik虚拟机启动后立即开始初始化和运行。其它的系统服务在System Server进程的环境中运行。/base/services/java/com/android/server/SystemServer.java

Java代码  收藏代码
  1. /**  
  2.  * This method is called from Zygote to initialize the system. This will cause the native  
  3.  * services (SurfaceFlinger, AudioFlinger, etc..) to be started. After that it will call back  
  4.  * up into init2() to start the Android services.  
  5.  */   
  6. native   public   static   void  init1(String[] args);  
  7.   
  8. public   static   void  main(String[] args) {  
  9.     if  (System.currentTimeMillis() < EARLIEST_SUPPORTED_TIME) {  
  10.         // If a device's clock is before 1970 (before 0), a lot of   
  11.         // APIs crash dealing with negative numbers, notably   
  12.         // java.io.File#setLastModified, so instead we fake it and   
  13.         // hope that time from cell towers or NTP fixes it   
  14.         // shortly.   
  15.         Slog.w(TAG, "System clock is before 1970; setting to 1970." );  
  16.         SystemClock.setCurrentTimeMillis(EARLIEST_SUPPORTED_TIME);  
  17.     }  
  18.   
  19.     if  (SamplingProfilerIntegration.isEnabled()) {  
  20.         SamplingProfilerIntegration.start();  
  21.         timer = new  Timer();  
  22.         timer.schedule(new  TimerTask() {  
  23.             @Override   
  24.             public   void  run() {  
  25.                 SamplingProfilerIntegration.writeSnapshot("system_server" );  
  26.             }  
  27.         }, SNAPSHOT_INTERVAL, SNAPSHOT_INTERVAL);  
  28.     }  
  29.   
  30.     // The system server has to run all of the time, so it needs to be   
  31.     // as efficient as possible with its memory usage.   
  32.     VMRuntime.getRuntime().setTargetHeapUtilization(0 .8f);  
  33.       
  34.     System.loadLibrary("android_servers" );  
  35.     init1(args);  
  36. }  
  37.   
  38. public   static   final   void  init2() {  
  39.     Slog.i(TAG, "Entered the Android system server!" );  
  40.     Thread thr = new  ServerThread();  
  41.     thr.setName("android.server.ServerThread" );  
  42.     thr.start();  
  43. }  

 在main函数中,首先检查系统时间设置和SamplingProfiler。然后加载一个叫android_servers的本地库,他提供本 地方法的接口(源程序在framework/base/services/jni/目录中)。然后调用本地方法设置服务。具体执行设置的代码在 frameworks/base/cmds/system_server/library/system_init.cpp中。

C代码  收藏代码
  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.     return  NO_ERROR;  
  63. }  

 等初始化传感器,视频,音频等服务后,调用一个回调方法init2 (在SystemServer.java中)。在上面的代码可以看到,这个方法开启了ServerThread来初始化其它的服务。

Java代码  收藏代码
  1. public   void  run() {  
  2.      EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_SYSTEM_RUN,  
  3.          SystemClock.uptimeMillis());  
  4.   
  5.      Looper.prepare();  
  6.   
  7.      android.os.Process.setThreadPriority(  
  8.              android.os.Process.THREAD_PRIORITY_FOREGROUND);  
  9.   
  10.      BinderInternal.disableBackgroundScheduling(true );  
  11.      android.os.Process.setCanSelfBackground(false );  
  12.   
  13.      // Check whether we failed to shut down last time we tried.   
  14.      {  
  15.          final  String shutdownAction = SystemProperties.get(  
  16.                  ShutdownThread.SHUTDOWN_ACTION_PROPERTY, "" );  
  17.          if  (shutdownAction !=  null  && shutdownAction.length() >  0 ) {  
  18.              boolean  reboot = (shutdownAction.charAt( 0 ) ==  '1' );  
  19.   
  20.              final  String reason;  
  21.              if  (shutdownAction.length() >  1 ) {  
  22.                  reason = shutdownAction.substring(1 , shutdownAction.length());  
  23.              } else  {  
  24.                  reason = null ;  
  25.              }  
  26.   
  27.              ShutdownThread.rebootOrShutdown(reboot, reason);  
  28.          }  
  29.      }  
  30.   
  31.      String factoryTestStr = SystemProperties.get("ro.factorytest" );  
  32.      int  factoryTest =  "" .equals(factoryTestStr) ? SystemServer.FACTORY_TEST_OFF  
  33.              : Integer.parseInt(factoryTestStr);  
  34.   
  35.      LightsService lights = null ;  
  36.      PowerManagerService power = null ;  
  37.      BatteryService battery = null ;  
  38.      ConnectivityService connectivity = null ;  
  39.      IPackageManager pm = null ;  
  40.      Context context = null ;  
  41.      WindowManagerService wm = null ;  
  42.      BluetoothService bluetooth = null ;  
  43.      BluetoothA2dpService bluetoothA2dp = null ;  
  44.      HeadsetObserver headset = null ;  
  45.      DockObserver dock = null ;  
  46.      UsbService usb = null ;  
  47.      UiModeManagerService uiMode = null ;  
  48.      RecognitionManagerService recognition = null ;  
  49.      ThrottleService throttle = null ;  
  50.   
  51.      // Critical services...   
  52.      try  {  
  53.          Slog.i(TAG, "Entropy Service" );  
  54.          ServiceManager.addService("entropy" new  EntropyService());  
  55.   
  56.          Slog.i(TAG, "Power Manager" );  
  57.          power = new  PowerManagerService();  
  58.          ServiceManager.addService(Context.POWER_SERVICE, power);  
  59.   
  60.          Slog.i(TAG, "Activity Manager" );  
  61.          context = ActivityManagerService.main(factoryTest);  
  62.   
  63.          Slog.i(TAG, "Telephony Registry" );  
  64.          ServiceManager.addService("telephony.registry" new  TelephonyRegistry(context));  
  65.   
  66.          AttributeCache.init(context);  
  67.   
  68.          Slog.i(TAG, "Package Manager" );  
  69.          pm = PackageManagerService.main(context,  
  70.                  factoryTest != SystemServer.FACTORY_TEST_OFF);  
  71.   
  72.          ActivityManagerService.setSystemProcess();  
  73.   
  74.          mContentResolver = context.getContentResolver();  
  75.   
  76.          // The AccountManager must come before the ContentService   
  77.          try  {  
  78.              Slog.i(TAG, "Account Manager" );  
  79.              ServiceManager.addService(Context.ACCOUNT_SERVICE,  
  80.                      new  AccountManagerService(context));  
  81.          } catch  (Throwable e) {  
  82.              Slog.e(TAG, "Failure starting Account Manager" , e);  
  83.          }  
  84.   
  85.          Slog.i(TAG, "Content Manager" );  
  86.          ContentService.main(context,  
  87.                  factoryTest == SystemServer.FACTORY_TEST_LOW_LEVEL);  
  88.   
  89.          Slog.i(TAG, "System Content Providers" );  
  90.          ActivityManagerService.installSystemProviders();  
  91.   
  92.          Slog.i(TAG, "Battery Service" );  
  93.          battery = new  BatteryService(context);  
  94.          ServiceManager.addService("battery" , battery);  
  95.   
  96.          Slog.i(TAG, "Lights Service" );  
  97.          lights = new  LightsService(context);  
  98.   
  99.          Slog.i(TAG, "Vibrator Service" );  
  100.          ServiceManager.addService("vibrator" new  VibratorService(context));  
  101.   
  102.          // only initialize the power service after we have started the   
  103.          // lights service, content providers and the battery service.   
  104.          power.init(context, lights, ActivityManagerService.getDefault(), battery);  
  105.   
  106.          Slog.i(TAG, "Alarm Manager" );  
  107.          AlarmManagerService alarm = new  AlarmManagerService(context);  
  108.          ServiceManager.addService(Context.ALARM_SERVICE, alarm);  
  109.   
  110.          Slog.i(TAG, "Init Watchdog" );  
  111.          Watchdog.getInstance().init(context, battery, power, alarm,  
  112.                  ActivityManagerService.self());  
  113.   
  114.          Slog.i(TAG, "Window Manager" );  
  115.          wm = WindowManagerService.main(context, power,  
  116.                  factoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL);  
  117.          ServiceManager.addService(Context.WINDOW_SERVICE, wm);  
  118.   
  119.          ((ActivityManagerService)ServiceManager.getService("activity" ))  
  120.                  .setWindowManager(wm);  
  121.   
  122.          // Skip Bluetooth if we have an emulator kernel   
  123.          // TODO: Use a more reliable check to see if this product should   
  124.          // support Bluetooth - see bug 988521   
  125.          if  (SystemProperties.get( "ro.kernel.qemu" ).equals( "1" )) {  
  126.              Slog.i(TAG, "Registering null Bluetooth Service (emulator)" );  
  127.              ServiceManager.addService(BluetoothAdapter.BLUETOOTH_SERVICE, null );  
  128.          } else   if  (factoryTest == SystemServer.FACTORY_TEST_LOW_LEVEL) {  
  129.              Slog.i(TAG, "Registering null Bluetooth Service (factory test)" );  
  130.              ServiceManager.addService(BluetoothAdapter.BLUETOOTH_SERVICE, null );  
  131.          } else  {  
  132.              Slog.i(TAG, "Bluetooth Service" );  
  133.              bluetooth = new  BluetoothService(context);  
  134.              ServiceManager.addService(BluetoothAdapter.BLUETOOTH_SERVICE, bluetooth);  
  135.              bluetooth.initAfterRegistration();  
  136.              bluetoothA2dp = new  BluetoothA2dpService(context, bluetooth);  
  137.              ServiceManager.addService(BluetoothA2dpService.BLUETOOTH_A2DP_SERVICE,  
  138.                                        bluetoothA2dp);  
  139.   
  140.              int  bluetoothOn = Settings.Secure.getInt(mContentResolver,  
  141.                  Settings.Secure.BLUETOOTH_ON, 0 );  
  142.              if  (bluetoothOn >  0 ) {  
  143.                  bluetooth.enable();  
  144.              }  
  145.          }  
  146.   
  147.      } catch  (RuntimeException e) {  
  148.          Slog.e("System" "Failure starting core service" , e);  
  149.      }  
  150.   
  151.      DevicePolicyManagerService devicePolicy = null ;  
  152.      StatusBarManagerService statusBar = null ;  
  153.      InputMethodManagerService imm = null ;  
  154.      AppWidgetService appWidget = null ;  
  155.      NotificationManagerService notification = null ;  
  156.      WallpaperManagerService wallpaper = null ;  
  157.      LocationManagerService location = null ;  
  158.   
  159.      if  (factoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL) {  
  160.          try  {  
  161.              Slog.i(TAG, "Device Policy" );  
  162.              devicePolicy = new  DevicePolicyManagerService(context);  
  163.              ServiceManager.addService(Context.DEVICE_POLICY_SERVICE, devicePolicy);  
  164.          } catch  (Throwable e) {  
  165.              Slog.e(TAG, "Failure starting DevicePolicyService" , e);  
  166.          }  
  167.   
  168.          try  {  
  169.              Slog.i(TAG, "Status Bar" );  
  170.              statusBar = new  StatusBarManagerService(context);  
  171.              ServiceManager.addService(Context.STATUS_BAR_SERVICE, statusBar);  
  172.          } catch  (Throwable e) {  
  173.              Slog.e(TAG, "Failure starting StatusBarManagerService" , e);  
  174.          }  
  175.   
  176.          try  {  
  177.              Slog.i(TAG, "Clipboard Service" );  
  178.              ServiceManager.addService(Context.CLIPBOARD_SERVICE,  
  179.                      new  ClipboardService(context));  
  180.          } catch  (Throwable e) {  
  181.              Slog.e(TAG, "Failure starting Clipboard Service" , e);  
  182.          }  
  183.   
  184.          try  {  
  185.              Slog.i(TAG, "Input Method Service" );  
  186.              imm = new  InputMethodManagerService(context, statusBar);  
  187.              ServiceManager.addService(Context.INPUT_METHOD_SERVICE, imm);  
  188.          } catch  (Throwable e) {  
  189.              Slog.e(TAG, "Failure starting Input Manager Service" , e);  
  190.          }  
  191.   
  192.          try  {  
  193.              Slog.i(TAG, "NetStat Service" );  
  194.              ServiceManager.addService("netstat" new  NetStatService(context));  
  195.          } catch  (Throwable e) {  
  196.              Slog.e(TAG, "Failure starting NetStat Service" , e);  
  197.          }  
  198.   
  199.          try  {  
  200.              Slog.i(TAG, "NetworkManagement Service" );  
  201.              ServiceManager.addService(  
  202.                      Context.NETWORKMANAGEMENT_SERVICE,  
  203.                      NetworkManagementService.create(context));  
  204.          } catch  (Throwable e) {  
  205.              Slog.e(TAG, "Failure starting NetworkManagement Service" , e);  
  206.          }  
  207.   
  208.          try  {  
  209.              Slog.i(TAG, "Connectivity Service" );  
  210.              connectivity = ConnectivityService.getInstance(context);  
  211.              ServiceManager.addService(Context.CONNECTIVITY_SERVICE, connectivity);  
  212.          } catch  (Throwable e) {  
  213.              Slog.e(TAG, "Failure starting Connectivity Service" , e);  
  214.          }  
  215.   
  216.          try  {  
  217.              Slog.i(TAG, "Throttle Service" );  
  218.              throttle = new  ThrottleService(context);  
  219.              ServiceManager.addService(  
  220.                      Context.THROTTLE_SERVICE, throttle);  
  221.          } catch  (Throwable e) {  
  222.              Slog.e(TAG, "Failure starting ThrottleService" , e);  
  223.          }  
  224.   
  225.          try  {  
  226.            Slog.i(TAG, "Accessibility Manager" );  
  227.            ServiceManager.addService(Context.ACCESSIBILITY_SERVICE,  
  228.                    new  AccessibilityManagerService(context));  
  229.          } catch  (Throwable e) {  
  230.            Slog.e(TAG, "Failure starting Accessibility Manager" , e);  
  231.          }  
  232.   
  233.          try  {  
  234.              /*  
  235.               * NotificationManagerService is dependant on MountService,  
  236.               * (for media / usb notifications) so we must start MountService first.  
  237.               */   
  238.              Slog.i(TAG, "Mount Service" );  
  239.              ServiceManager.addService("mount" new  MountService(context));  
  240.          } catch  (Throwable e) {  
  241.              Slog.e(TAG, "Failure starting Mount Service" , e);  
  242.          }  
  243.   
  244.          try  {  
  245.              Slog.i(TAG, "Notification Manager" );  
  246.              notification = new  NotificationManagerService(context, statusBar, lights);  
  247.              ServiceManager.addService(Context.NOTIFICATION_SERVICE, notification);  
  248.          } catch  (Throwable e) {  
  249.              Slog.e(TAG, "Failure starting Notification Manager" , e);  
  250.          }  
  251.   
  252.          try  {  
  253.              Slog.i(TAG, "Device Storage Monitor" );  
  254.              ServiceManager.addService(DeviceStorageMonitorService.SERVICE,  
  255.                      new  DeviceStorageMonitorService(context));  
  256.          } catch  (Throwable e) {  
  257.              Slog.e(TAG, "Failure starting DeviceStorageMonitor service" , e);  
  258.          }  
  259.   
  260.          try  {  
  261.              Slog.i(TAG, "Location Manager" );  
  262.              location = new  LocationManagerService(context);  
  263.              ServiceManager.addService(Context.LOCATION_SERVICE, location);  
  264.          } catch  (Throwable e) {  
  265.              Slog.e(TAG, "Failure starting Location Manager" , e);  
  266.          }  
  267.   
  268.          try  {  
  269.              Slog.i(TAG, "Search Service" );  
  270.              ServiceManager.addService(Context.SEARCH_SERVICE,  
  271.                      new  SearchManagerService(context));  
  272.          } catch  (Throwable e) {  
  273.              Slog.e(TAG, "Failure starting Search Service" , e);  
  274.          }  
  275.   
  276.          if  (INCLUDE_DEMO) {  
  277.              Slog.i(TAG, "Installing demo data..." );  
  278.              (new  DemoThread(context)).start();  
  279.          }  
  280.   
  281.          try  {  
  282.              Slog.i(TAG, "DropBox Service" );  
  283.              ServiceManager.addService(Context.DROPBOX_SERVICE,  
  284.                      new  DropBoxManagerService(context,  new  File( "/data/system/dropbox" )));  
  285.          } catch  (Throwable e) {  
  286.              Slog.e(TAG, "Failure starting DropBoxManagerService" , e);  
  287.          }  
  288.   
  289.          try  {  
  290.              Slog.i(TAG, "Wallpaper Service" );  
  291.              wallpaper = new  WallpaperManagerService(context);  
  292.              ServiceManager.addService(Context.WALLPAPER_SERVICE, wallpaper);  
  293.          } catch  (Throwable e) {  
  294.              Slog.e(TAG, "Failure starting Wallpaper Service" , e);  
  295.          }  
  296.   
  297.          try  {  
  298.              Slog.i(TAG, "Audio Service" );  
  299.              ServiceManager.addService(Context.AUDIO_SERVICE, new  AudioService(context));  
  300.          } catch  (Throwable e) {  
  301.              Slog.e(TAG, "Failure starting Audio Service" , e);  
  302.          }  
  303.   
  304.          try  {  
  305.              Slog.i(TAG, "Headset Observer" );  
  306.              // Listen for wired headset changes   
  307.              headset = new  HeadsetObserver(context);  
  308.          } catch  (Throwable e) {  
  309.              Slog.e(TAG, "Failure starting HeadsetObserver" , e);  
  310.          }  
  311.   
  312.          try  {  
  313.              Slog.i(TAG, "Dock Observer" );  
  314.              // Listen for dock station changes   
  315.              dock = new  DockObserver(context, power);  
  316.          } catch  (Throwable e) {  
  317.              Slog.e(TAG, "Failure starting DockObserver" , e);  
  318.          }  
  319.   
  320.          try  {  
  321.              Slog.i(TAG, "USB Service" );  
  322.              // Listen for USB changes   
  323.              usb = new  UsbService(context);  
  324.              ServiceManager.addService(Context.USB_SERVICE, usb);  
  325.          } catch  (Throwable e) {  
  326.              Slog.e(TAG, "Failure starting UsbService" , e);  
  327.          }  
  328.   
  329.          try  {  
  330.              Slog.i(TAG, "UI Mode Manager Service" );  
  331.              // Listen for UI mode changes   
  332.              uiMode = new  UiModeManagerService(context);  
  333.          } catch  (Throwable e) {  
  334.              Slog.e(TAG, "Failure starting UiModeManagerService" , e);  
  335.          }  
  336.   
  337.          try  {  
  338.              Slog.i(TAG, "Backup Service" );  
  339.              ServiceManager.addService(Context.BACKUP_SERVICE,  
  340.                      new  BackupManagerService(context));  
  341.          } catch  (Throwable e) {  
  342.              Slog.e(TAG, "Failure starting Backup Service" , e);  
  343.          }  
  344.   
  345.          try  {  
  346.              Slog.i(TAG, "AppWidget Service" );  
  347.              appWidget = new  AppWidgetService(context);  
  348.              ServiceManager.addService(Context.APPWIDGET_SERVICE, appWidget);  
  349.          } catch  (Throwable e) {  
  350.              Slog.e(TAG, "Failure starting AppWidget Service" , e);  
  351.          }  
  352.   
  353.          try  {  
  354.              Slog.i(TAG, "Recognition Service" );  
  355.              recognition = new  RecognitionManagerService(context);  
  356.          } catch  (Throwable e) {  
  357.              Slog.e(TAG, "Failure starting Recognition Service" , e);  
  358.          }  
  359.            
  360.          try  {  
  361.              Slog.i(TAG, "DiskStats Service" );  
  362.              ServiceManager.addService("diskstats" new  DiskStatsService(context));  
  363.          } catch  (Throwable e) {  
  364.              Slog.e(TAG, "Failure starting DiskStats Service" , e);  
  365.          }  
  366.      }  
  367.   
  368.      // make sure the ADB_ENABLED setting value matches the secure property value   
  369.      Settings.Secure.putInt(mContentResolver, Settings.Secure.ADB_ENABLED,  
  370.              "1" .equals(SystemProperties.get( "persist.service.adb.enable" )) ?  1  :  0 );  
  371.   
  372.      // register observer to listen for settings changes   
  373.      mContentResolver.registerContentObserver(Settings.Secure.getUriFor(Settings.Secure.ADB_ENABLED),  
  374.              false new  AdbSettingsObserver());  
  375.   
  376.      // Before things start rolling, be sure we have decided whether   
  377.      // we are in safe mode.   
  378.      final   boolean  safeMode = wm.detectSafeMode();  
  379.      if  (safeMode) {  
  380.          try  {  
  381.              ActivityManagerNative.getDefault().enterSafeMode();  
  382.              // Post the safe mode state in the Zygote class   
  383.              Zygote.systemInSafeMode = true ;  
  384.              // Disable the JIT for the system_server process   
  385.              VMRuntime.getRuntime().disableJitCompilation();  
  386.          } catch  (RemoteException e) {  
  387.          }  
  388.      } else  {  
  389.          // Enable the JIT for the system_server process   
  390.          VMRuntime.getRuntime().startJitCompilation();  
  391.      }  
  392.   
  393.      // It is now time to start up the app processes...   
  394.   
  395.      if  (devicePolicy !=  null ) {  
  396.          devicePolicy.systemReady();  
  397.      }  
  398.   
  399.      if  (notification !=  null ) {  
  400.          notification.systemReady();  
  401.      }  
  402.   
  403.      if  (statusBar !=  null ) {  
  404.          statusBar.systemReady();  
  405.      }  
  406.      wm.systemReady();  
  407.      power.systemReady();  
  408.      try  {  
  409.          pm.systemReady();  
  410.      } catch  (RemoteException e) {  
  411.      }  
  412.   
  413.      // These are needed to propagate to the runnable below.   
  414.      final  StatusBarManagerService statusBarF = statusBar;  
  415.      final  BatteryService batteryF = battery;  
  416.      final  ConnectivityService connectivityF = connectivity;  
  417.      final  DockObserver dockF = dock;  
  418.      final  UsbService usbF = usb;  
  419.      final  ThrottleService throttleF = throttle;  
  420.      final  UiModeManagerService uiModeF = uiMode;  
  421.      final  AppWidgetService appWidgetF = appWidget;  
  422.      final  WallpaperManagerService wallpaperF = wallpaper;  
  423.      final  InputMethodManagerService immF = imm;  
  424.      final  RecognitionManagerService recognitionF = recognition;  
  425.      final  LocationManagerService locationF = location;  
  426.   
  427.      // We now tell the activity manager it is okay to run third party   
  428.      // code.  It will call back into us once it has gotten to the state   
  429.      // where third party code can really run (but before it has actually   
  430.      // started launching the initial applications), for us to complete our   
  431.      // initialization.   
  432.      ((ActivityManagerService)ActivityManagerNative.getDefault())  
  433.              .systemReady(new  Runnable() {  
  434.          public   void  run() {  
  435.              Slog.i(TAG, "Making services ready" );  
  436.   
  437.              if  (statusBarF !=  null ) statusBarF.systemReady2();  
  438.              if  (batteryF !=  null ) batteryF.systemReady();  
  439.              if  (connectivityF !=  null ) connectivityF.systemReady();  
  440.              if  (dockF !=  null ) dockF.systemReady();  
  441.              if  (usbF !=  null ) usbF.systemReady();  
  442.              if  (uiModeF !=  null ) uiModeF.systemReady();  
  443.              if  (recognitionF !=  null ) recognitionF.systemReady();  
  444.              Watchdog.getInstance().start();  
  445.   
  446.              // It is now okay to let the various system services start their   
  447.              // third party code...   
  448.   
  449.              if  (appWidgetF !=  null ) appWidgetF.systemReady(safeMode);  
  450.              if  (wallpaperF !=  null ) wallpaperF.systemReady();  
  451.              if  (immF !=  null ) immF.systemReady();  
  452.              if  (locationF !=  null ) locationF.systemReady();  
  453.              if  (throttleF !=  null ) throttleF.systemReady();  
  454.          }  
  455.      });  
  456.   
  457.      // For debug builds, log event loop stalls to dropbox for analysis.   
  458.      if  (StrictMode.conditionallyEnableDebugLogging()) {  
  459.          Slog.i(TAG, "Enabled StrictMode for system server main thread." );  
  460.      }  
  461.   
  462.      Looper.loop();  
  463.      Slog.d(TAG, "System ServerThread is exiting!" );  
  464.  }  

这里启动的没一个进程都作为一个Dalvik线程而存在于SystemServer进程里面。




 

分享到:
评论

相关推荐

    Android Zygote启动流程源码解析

    ### Android Zygote启动流程源码解析 #### 引言 在Android系统中,Zygote进程扮演着至关重要的角色,作为所有应用进程和SystemServer进程的“始祖”。了解Zygote的启动流程对于深入理解Android底层机制具有重要...

    android系统从init进程开始到systemserver启动详细流程

    ### Android系统从init进程开始到systemserver启动详细流程 #### 1. 概述 在Android系统的启动过程中,从Linux内核加载完成后,系统将执行第一个用户空间进程——`init`进程,它作为后续所有进程的父进程。`init`...

    探索Android FrameWork底层开发视频全套

    12.init脚本解析分析 13.init脚本执行和进程守护(1) 14.init脚本执行和进程守护(2) 15.android服务介绍与davlink启动 16.Zygote剖析与system_server启动 17.Zygote创建APP分析 18.zygote_load系统资源分析及优化 19....

    Android Bluetooth初始化代码解析

    在深入解析Android蓝牙初始化代码之前,先来了解一下蓝牙的整体架构。 蓝牙整体架构包括蓝牙系统apk、JNI、Framework、Bluedroid协议栈和硬件厂商提供的模块。蓝牙系统apk位于packages/app/Bluetooth,它打包成一个...

    System Server启动

    ### System Server启动详解 ...通过对关键步骤的深入解析,我们可以更全面地理解`SystemServer`在整个Android系统中的重要性和运作原理。这对于Android开发人员来说至关重要,有助于更好地优化应用性能和资源管理。

    android 核心分析之------Android 启动过程详解

    `SystemServer`是Android服务框架的中心,它在`SystemServer.java`中初始化并创建了一系列的系统服务,如`ActivityManagerService`、`PackageManagerService`等,并将它们注册到`servicemanager`中,供其他组件调用...

    Android 启动过程详解

    本文将对每个阶段进行详细解析,帮助读者更好地理解Android系统的启动流程。 #### 二、init进程启动 **init进程**是Android启动的第一个用户级进程,由内核直接启动。它的主要职责是读取配置文件`init.rc`及平台...

    王家林的Android系统完整训练:开发搭载Android系统的产品

    5. **Native Service**: Native Service是Android底层服务的重要组成部分,课程将深入解析如何使用IInterface(Java与C++的结合),BnInterface与BpInterface的运用,以及如何实现Native Service和Native Binder ...

    深入理解Android:卷I

    本书以情景化的方式,对Android的源代码进行了细致入微的解读,尤其侧重于Framework层的解析,同时兼顾了Native层和Application层的探讨,确保了内容的广度和深度。 ### 重要知识点概览 #### 1. Android系统架构和...

    android 我的笔记 源码

    本笔记将从以下几个方面对 Android 源码进行解析: 1. **Android 架构概述** Android 系统由五大部分组成:Linux 内核、HAL(硬件抽象层)、系统库、应用程序框架和应用程序。其中,Linux 内核提供底层硬件支持,...

    android.jar 源码

    9. **UI布局解析**:XML布局文件如何转换为Android视图树,源码解释了LayoutInflater的角色。 10. **系统启动过程**:了解Zygote进程如何孵化新的应用进程,以及SystemServer如何启动和管理整个系统的运行。 总之...

    深入理解Android 卷1.pdf

    第4章分析了Zygote、SystemServer等进程的工作机制,同时还讨论了Android的启动速度、虚拟机HeapSize的大小调整、Watchdog工作原理等问题;第5章讲解了Android系统中常用的类,包括sp、wp、RefBase、Thread等类,...

    android实现关机和重启.zip

    本文将详细解析如何在Android应用层通过编程实现这一目标,并结合提供的"android实现关机和重启"源码进行分析。 首先,我们要明白在Android中,应用程序通常没有足够的权限直接执行关机或重启操作。这是因为这些...

    android开机启动流程

    - **启动SystemServer**:`zygote` 启动`SystemServer` 进程,这是Android服务的核心。 - **处理应用请求**:通过`zygote` socket接收来自`ActivityManagerService` 的请求,分叉出新的应用进程。 #### 四、...

    Zygote启动流程-systemServer启动流程-homeLauncher启动

    通过对Zygote启动流程以及systemServer和Home Activity启动过程的详细解析,我们不仅了解了Android系统启动过程中的关键步骤和技术细节,还深入了解了ART虚拟机的工作原理。这些深入的理解对于开发者来说至关重要,...

    android核心分析之------Android启动过程详解.pdf

    Android启动过程详解主要分为四个关键步骤,这四个步骤构建了Android系统的基石。下面将详细阐述这些步骤以及涉及的重要组件。 第一步:初始化init进程 init进程是Android系统启动的第一个用户级进程,由Linux内核...

    安卓Android源码——Pax.zip

    《安卓Android源码解析——聚焦Pax》 在深入探讨Android源码之前,我们首先要明白,Android是一个开源的操作系统,其源代码公开发布,允许开发者对其进行定制和改进。这一特性使得Android成为全球开发者广泛研究的...

    android 开机启动源代码

    本文将深入解析Android开机启动的源代码,帮助读者理解这一过程的关键环节。 首先,Android系统的启动始于硬件层面的Bootloader。Bootloader是设备上电后执行的第一段程序,它负责加载kernel(内核)到内存中并启动...

Global site tag (gtag.js) - Google Analytics