本篇文章基于Android6.0源码分析

相关源码文件：

/frameworks/base/core/java/com/android/internal/os/
- ZygoteInit.java
- RuntimeInit.java
- Zygote.java

/frameworks/base/core/services/java/com/android/server/
- SystemServer.java

/frameworks/base/core/jni/
- com_android_internal_os_Zygote.cpp
- AndroidRuntime.cpp

/frameworks/base/cmds/app_process/App_main.cpp

SystemServer进程

根据上篇Android系统启动-Zygote进程
文章，在Zygote进程启动时，会调用ZygoteInit.main()方法，其中分别会调用registerZygoteSocket、preload 、startSystemServer 、runSelectLoop来创建服务Socket、提前加载资源、创建SystemServer进程、循环创建子进程。

本篇文章讲解startSystemServer()方法，在startSystemServer()方法中主要完成两件事：
· 创建SystemServer进程
· SystemServer进程启动系统服务

  private static boolean startSystemServer(String abiList, String socketName)
  throws MethodAndArgsCaller, RuntimeException
  {
      ...
      // 创建SystemServer进程的一些参数数组
      String args [] = {
          "--setuid=1000",
          "--setgid=1000",
          "--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1021,1032,3001,3002,3003,3006,3007",
          "--capabilities=" + capabilities + "," + capabilities,
          "--nice-name=system_server",
          "--runtime-args",
          "com.android.server.SystemServer",
      };
      ZygoteConnection.Arguments parsedArgs = null;

      int pid;

      try {
           ...
          // 1. 创建SystemServer进程
          pid = Zygote.forkSystemServer(
              parsedArgs.uid, parsedArgs.gid,
              parsedArgs.gids,
              parsedArgs.debugFlags,
              null,
              parsedArgs.permittedCapabilities,
              parsedArgs.effectiveCapabilities
          );
      } catch (IllegalArgumentException ex) {
          throw new RuntimeException (ex);
      }

      // pid为0则子进程，就是SystemServer进程
      if (pid == 0) {
          if (hasSecondZygote(abiList)) {
              waitForSecondaryZygote(socketName);
          }
          // 2. 在SystemServer进程中启动服务
          handleSystemServerProcess(parsedArgs);
      }

      return true;
  }

下图则是startSystemServer方法的创建过程，先通过Zygote.forkSystemServe去创建SystemServer进程，创建SystemServer进程之后,通过handleSystemServerProcess()在SystemServer进程中去启动服务。

SystemServer进程启动

创建SystemServer进程

Zygote.forkSystemServer：

  package com.android.internal.os;
  public final class Zygote {
      
      public static int forkSystemServer(int uid, int gid, int[] gids, int debugFlags,
      int[][] rlimits, long permittedCapabilities, long effectiveCapabilities)
      {
          VM_HOOKS.preFork();
          // 通过nativeForkSystemServer创建进程
          int pid = nativeForkSystemServer (
                  uid, gid, gids, debugFlags, rlimits, permittedCapabilities, effectiveCapabilities);
          // Enable tracing as soon as we enter the system_server.
          if (pid == 0) {
              Trace.setTracingEnabled(true);
          }
          VM_HOOKS.postForkCommon();
          return pid;
      }

       // nativeForkSystemServer是个 native方法
      // 通过: [包名]_[类名] 在AndroidRuntime查找Jni的注册的Cpp文件，然后通过：  [包名]_[类名]_[方法名]找到对应的方法。
      // 对应执行com_android_internal_os_Zygote.cpp类中的com_android_internal_os_Zygote_nativeForkAndSpecialize
      native private static int nativeForkSystemServer(int uid, int gid, int[] gids, int debugFlags,
      int[][] rlimits, long permittedCapabilities, long effectiveCapabilities);
  }


 // com_android_internal_os_Zygote.cpp
  static jint com_android_internal_os_Zygote_nativeForkAndSpecialize(
  JNIEnv* env, jclass, jint uid, jint gid, jintArray gids,
  jint debug_flags, jobjectArray rlimits,
  jint mount_external, jstring se_info, jstring se_name,
  jintArray fdsToClose, jstring instructionSet, jstring appDataDir)
  {
      // Grant CAP_WAKE_ALARM to the Bluetooth process.
      jlong capabilities = 0;
      if (uid == AID_BLUETOOTH) {
          capabilities | = (1LL << CAP_WAKE_ALARM);
      }
      // 又调用ForkAndSpecializeCommon进行进程创建
      return ForkAndSpecializeCommon(
          env, uid, gid, gids, debug_flags,
          rlimits, capabilities, capabilities, mount_external, se_info,
          se_name, false, fdsToClose, instructionSet, appDataDir
      );
  }

  static pid_t ForkAndSpecializeCommon(JNIEnv* env, uid_t uid, gid_t gid, jintArray javaGids,
  jint debug_flags, jobjectArray javaRlimits,
  jlong permittedCapabilities, jlong effectiveCapabilities,
  jint mount_external,
  jstring java_se_info, jstring java_se_name,
  bool is_system_server, jintArray fdsToClose,
  jstring instructionSet, jstring dataDir)
  {
      //设置子进程的 signal 信号处理函数
      SetSigChldHandler();
      //  fork 创建SystemServer进程
      pid_t pid = fork ();

      if (pid == 0) {
          // 子进程
         ...
      } else if (pid > 0) {
          // 父进程
      }
      return pid;
  }

创建SystemServer进程是通过com.android.internal.os. Zygote的nativeForkSystemServer本地方法创建的，JNI方法的注册在AndroidRuntime中，通过查询[包名]_[类名]可以知道对应的方法为：com_android_internal_os_Zygote.cpp类的com_android_internal_os_Zygote_nativeForkAndSpecialize()方法。最后通过ForkAndSpecializeCommon方法fork()创建SystemServer进程。

SystemServer进程启动服务

handleSystemServerProcess(parsedArgs)

  public class ZygoteInit {
      // 在SystemServer进程中启动服务
      private static void handleSystemServerProcess(
      ZygoteConnection.Arguments parsedArgs)
      throws ZygoteInit.MethodAndArgsCaller
      {
          // 关闭从Zygote进程复制而来的socket
          closeServerSocket();
          ...
          if (parsedArgs.invokeWith != null) {
              ...
          } else {
              ClassLoader cl = null;
              if (systemServerClasspath != null) {
                  // 创建类加载器，并赋予当前进程
                  cl =
                      new PathClassLoader (systemServerClasspath, ClassLoader.getSystemClassLoader());
                  Thread.currentThread().setContextClassLoader(cl);
              }
              // 跳转到RuntimeInit.zygoteInit
              RuntimeInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, cl);
          }

      }
  }


  public class RuntimeInit {
      public static final void zygoteInit(int targetSdkVersion, String[] argv, ClassLoader classLoader)
      throws ZygoteInit.MethodAndArgsCaller
      {
          // 做一些通用的初始化
          commonInit();
          // 这个方法是 native 方法，主要是打开 binder 驱动，启动 binder 线程
          nativeZygoteInit();
          // 通过异常，通过异常跳转到SystemServer.main
          applicationInit(targetSdkVersion, argv, classLoader);
      }

  }

  private static void applicationInit(int targetSdkVersion, String[] argv, ClassLoader classLoader)
  throws ZygoteInit.MethodAndArgsCaller
  {
      ...
      final Arguments args;
      try {
          args = new Arguments (argv);
      } catch (IllegalArgumentException ex) {
          return;
      }
      ...
      // 执行此方法
      invokeStaticMain(args.startClass, args.startArgs, classLoader);
  }

  private static void invokeStaticMain(String className, String[] argv, ClassLoader classLoader)
  throws ZygoteInit.MethodAndArgsCaller
  {
      Class<?> cl;
      try {
          // 这里的className为com.android.server.SystemServer，所以是SystemServer类
          cl = Class.forName(className, true, classLoader);
      } catch (ClassNotFoundException ex) {
      }
      Method m;
      try {
          // SystemServer的main方法
          m = cl.getMethod("main", new Class [] { String[].class });
      } catch (NoSuchMethodException ex) {
      } catch (SecurityException ex) {
      }

      // 通过ZygoteInit.MethodAndArgsCaller将方法带带出去
     // 那么这里的异常在那个catch处理呢？，发现由执行最初的startSystemServer()的ZygoteInit.main()方法处理此异常
      throw new ZygoteInit.MethodAndArgsCaller (m, argv);
  }

   public class ZygoteInit {
      public static void main(String argv[])
      {
          try {
              ...
              if (startSystemServer) {
                  startSystemServer(abiList, socketName);
              }
              ...
          } catch (MethodAndArgsCaller caller) {
              // 处理MethodAndArgsCaller ，并执行此run方法
              caller.run();
          } catch (RuntimeException ex) {
              Log.e(TAG, "Zygote died with exception", ex);
              closeServerSocket();
              throw ex;
          }
      }

      public static
      class MethodAndArgsCaller extends Exception
      implements Runnable
      {
          private final Method mMethod;
          private final String[] mArgs;

          public MethodAndArgsCaller (Method method, String[] args) {
          mMethod = method;
          mArgs = args;
          }

          public void run() {
              try {
                  // 通过反射执行方法
                  mMethod.invoke(null, new Object [] { mArgs });
              } catch (IllegalAccessException ex) {
                 ...
              } catch (InvocationTargetException ex) {
                ...
              }
          }
      }
  }

通过一连串的分析得知，一是通过nativeZygoteInit去启动Bind,二是通过applicationInit方法通过异常去反射执行SystemServer.main方法，这里为什么需要通过异常去反射执行方法呢？为什么不直接反射执行方法？其实是为了清空栈的信息。到这里并没有启动服务，接下来的SystemServer.main方法是启动服务的开始。

SystemServer.main

public final class SystemServer {

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

  private void run()
  {
      ...
      // 主线程 looper
      Looper.prepareMainLooper();

      // 加载android_servers.so 库
      System.loadLibrary("android_servers");

      // 初始化系统上下文
      createSystemContext();

      // 创建 系统服务管理 mSystemServiceManager
      mSystemServiceManager = new SystemServiceManager (mSystemContext);
      // 将mSystemServiceManager添加到LocalServices.sLocalServiceObjects,是个map
      LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);

      // 启动服务
      try {
          // 启动引导服务
          startBootstrapServices();
          // 启动核心服务
          startCoreServices();
          // 启动其他服务
          startOtherServices();
      } catch (Throwable ex) {
          Slog.e("System", "******************************************");
          Slog.e("System", "************ Failure starting system services", ex);
          throw ex;
      }

      // 一直循环执行
      Looper.loop();
      throw new RuntimeException ("Main thread loop unexpectedly exited");
  }

  private void createSystemContext()
  {
      // 创建系统进程的上下文信息
      ActivityThread activityThread = ActivityThread.systemMain ();
      mSystemContext = activityThread.getSystemContext();
      mSystemContext.setTheme(android.R.style.Theme_DeviceDefault_Light_DarkActionBar);
  }

  // 启动指导服务
  private void startBootstrapServices()
  {
      //阻塞等待与installd建立socket通道
      //Installer系统安装apk时的一个服务类，启动完成Installer服务之后才能启动其他的系统服务
      Installer installer = mSystemServiceManager . startService (Installer.class);

      // 启动ActivityManagerService服务
      // ActivityManagerService：负责四大组件的启动、切换、调度。
      mActivityManagerService = mSystemServiceManager.startService(
          ActivityManagerService.Lifecycle.class).getService();
      mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
      mActivityManagerService.setInstaller(installer);

      // 启动PowerManagerService服务
      // PowerManagerService：计算系统中和电池相关的计算，然后决策系统应该如何反应
      mPowerManagerService = mSystemServiceManager.startService(PowerManagerService.class);

      // 现在电源管理器已经启动，让活动管理器初始化电源管理功能。
      mActivityManagerService.initPowerManagement();

      // 启动LightsService服务
      // LightsService：管理 LED 和显示器背光，因此我们需要它来调出显示器。
      mSystemServiceManager.startService(LightsService.class);

      // 启动 DisplayManagerService 服务
      // 需要显示管理器在包管理器启动之前提供显示指标。
      mDisplayManagerService = mSystemServiceManager.startService(DisplayManagerService.class);

      //Phase100: 在初始化package manager之前，我们需要默认的显示.
      mSystemServiceManager.startBootPhase(SystemService.PHASE_WAIT_FOR_DEFAULT_DISPLAY);

      // 如果我们正在加密设备，则仅运行“核心”应用程序。
      String cryptState = SystemProperties . get ("vold.decrypt");
      if (ENCRYPTING_STATE.equals(cryptState)) {
          Slog.w(TAG, "Detected encryption in progress - only parsing core apps");
          mOnlyCore = true;
      } else if (ENCRYPTED_STATE.equals(cryptState)) {
          Slog.w(TAG, "Device encrypted - only parsing core apps");
          mOnlyCore = true;
      }

      //启动 PackageManagerService 服务
      // PackageManagerService：用来对apk进行安装、解析、删除、卸载等等操作
      Slog.i(TAG, "Package Manager");
      mPackageManagerService = PackageManagerService.main(
          mSystemContext, installer,
          mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF, mOnlyCore
      );
      mFirstBoot = mPackageManagerService.isFirstBoot();
      mPackageManager = mSystemContext.getPackageManager();

      // 启动 UserManagerService 服务，多用户模式管理
      ServiceManager.addService(Context.USER_SERVICE, UserManagerService.getInstance());

      // Initialize attribute cache used to cache resources from packages.
      AttributeCache.init(mSystemContext);

      // 为系统进程设置应用程序实例并开始
      mActivityManagerService.setSystemProcess();

      //启动传感器服务
      // 传感器服务需要访问包管理服务、应用操作服务和权限服务，因此我们在它们之后启动它
      startSensorService();
  }

  // 启动核心服务
  private void startCoreServices()
  {
      // 启动BatteryService 服务
      // BatteryService：管理电池相关的服务
      mSystemServiceManager.startService(BatteryService.class);

      // 启动UsageStatsService服务
      // UsageStatsService：收集用户使用每一个APP的频率、使用时常
      mSystemServiceManager.startService(UsageStatsService.class);
      mActivityManagerService.setUsageStatsManager(
          LocalServices.getService(UsageStatsManagerInternal.class));
      // 在 UsageStatsService 可用后更新，在 performBootDexOpt 之前需要
      mPackageManagerService.getUsageStatsIfNoPackageUsageInfo();

      // 启动WebViewUpdateService服务
      // 跟踪可更新的 WebView 是否处于就绪状态并监视更新安装。
      mSystemServiceManager.startService(WebViewUpdateService.class);
  }

  private void startOtherServices()
  {
      ...
      try {
          // 启动CameraService 服务,摄像头相关服务
          mSystemServiceManager.startService(CameraService.class);
          ...
          // 启动 AlarmManagerService 服务， 全局定时器管理服务
          mSystemServiceManager.startService(AlarmManagerService.class);
          alarm = IAlarmManager.Stub.asInterface(
              ServiceManager.getService(Context.ALARM_SERVICE)
          );
          ...
          // 启动InputManagerService服务 ，管理输入事件
          inputManager = new InputManagerService (context);

          // 启动 WindowManagerService 服务， 窗口管理服务
          wm = WindowManagerService.main(
              context, inputManager,
              mFactoryTestMode != FactoryTest.FACTORY_TEST_LOW_LEVEL,
              !mFirstBoot, mOnlyCore
          );
          ServiceManager.addService(Context.WINDOW_SERVICE, wm);
          ServiceManager.addService(Context.INPUT_SERVICE, inputManager);
          mActivityManagerService.setWindowManager(wm);
          inputManager.setWindowManagerCallbacks(wm.getInputMonitor());
          // 启动input
          inputManager.start();
          mDisplayManagerService.windowManagerAndInputReady();

          // 启动 BluetoothService 服务，蓝牙管理服务
          mSystemServiceManager.startService(BluetoothService.class);
          ...
          // 启动 NotificationManagerService 服务，通知管理服务
          mSystemServiceManager.startService(NotificationManagerService.class);
          notification = INotificationManager.Stub.asInterface(
              ServiceManager.getService(Context.NOTIFICATION_SERVICE)
          );
          networkPolicy.bindNotificationManager(notification);

          // 启动DeviceStorageMonitorService 服务，存储相关管理服务
          mSystemServiceManager.startService(DeviceStorageMonitorService.class);

          if (!disableLocation) {
              try {
                  Slog.i(TAG, "Location Manager");
                  // 启动 LocationManagerService 服务， 定位管理服务
                  location = new LocationManagerService (context);
                  ServiceManager.addService(Context.LOCATION_SERVICE, location);
              } catch (Throwable e) {
                  reportWtf("starting Location Manager", e);
              }
              ...
              // 准备好了 wms,  pms, ams 服务
              wm.systemReady();
              mPowerManagerService.systemReady(mActivityManagerService.getAppOpsService());
              mPackageManagerService.systemReady();
              mDisplayManagerService.systemReady(safeMode, mOnlyCore);

              // 我们现在告诉活动管理器可以运行第三方代码。一旦达到第三方代码真正可以运行的状态（但在它实际开始启动初始应用程序之前），它就会回调我们，以便我们完成初始化。
              mActivityManagerService.systemReady(new Runnable () {
                  @Override
                  public void run() {

                  }
              });
          }
      }
  }
}

SystemServer执行main()方法后调用run方法，之后分别调用startBootstrapServices、startCoreServices、startOtherServices开始启动很多服务，像常见的ActivityManagerService、PackageManagerService、WindowManagerService、InputManagerServic服务都在这里开启。
开启服务有两种方式：

1. mSystemServiceManager.startService(LightsService.class);

2. LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);

但是发现最终都是调用到LocalServices.addService这种方法。

public final class ServiceManager {

  public static void addService(String name, IBinder service)
  {
      try {
          // 调用ServiceManagerProxy的addService方法
          getIServiceManager().addService(name, service, false);
      } catch (RemoteException e) {
          Log.e(TAG, "error in addService", e);
      }
  }

  private static IServiceManager getIServiceManager()
  {
      if (sServiceManager != null) {
          return sServiceManager;
      }

      // Find the service manager
      sServiceManager = ServiceManagerNative.asInterface(BinderInternal.getContextObject());
      return sServiceManager;
  }
}

public abstract class ServiceManagerNative extends Binder implements IServiceManager
{

  /**
   * 将 Binder 对象投射到服务管理器接口中，如果需要则生成代理
   */
  static public IServiceManager asInterface (IBinder obj)
  {
      if (obj == null) {
          return null;

      }
      IServiceManager in =
      (IServiceManager) obj . queryLocalInterface (descriptor);
      if ( in != null) {
      return in;

  }
      // 返回
      return new ServiceManagerProxy (obj);
  }
}

class ServiceManagerProxy implements IServiceManager {

  public ServiceManagerProxy (IBinder remote) {
      mRemote = remote;
  }

 // IPC binder 驱动
  public void addService(String name, IBinder service, boolean allowIsolated)
  throws RemoteException {
      Parcel data = Parcel.obtain ();
      Parcel reply = Parcel.obtain ();
      data.writeInterfaceToken(IServiceManager.descriptor);
      data.writeString(name);
      data.writeStrongBinder(service);
      data.writeInt(allowIsolated ? 1 : 0);
      mRemote.transact(ADD_SERVICE_TRANSACTION, data, reply, 0);
      reply.recycle();
      data.recycle();
  }

}

可见启动服务是靠Binder驱动去开启的。

SystemServer进程总结

首先通过JNI的注册方法去创建SystemServer进程，创建进程之后，开始处理SystemServer进程，通过异常反射调用SystemServer的main方法，主要完成两件事：一、启动Binder驱动线程，二、开启服务(AMS、PMS、WMS、IMS等)，最后通过Binder驱动去启动服务。