Android 启动（五）SystemServer启动

SystemServer进程

在zygote启动过程中我们知道最终执行到了ZyogoteInit#main

frameworks/base/core/java/com/android/internal/os/ZygoteInit.java

在这个方法中

• 注册名为 zygote 的 LocalServerSocket 用来接收AMS请求
• 启动SystemServer进程
  • SystemServer源码位置 frameworks/base/services/java/com/android/server/SystemServer.java
• runSelectLoop启动循环让注册的LocalServerSocket 等待接收Ams的请求

这里我们主要分析启动SystemServer

ForkSystemServer进程

ZyogoteInit#main

public static void main(String argv[]) {
   //4 启动SystemServer 通过Zygote.forkSystemService
   if (startSystemServer) {
      Runnable r = forkSystemServer(abiList, socketName, zygoteServer);
   	  r.run();
   }   	 			 
}

ZyogoteInit#main#forkSystemServer

 private static Runnable forkSystemServer(String abiList, String socketName,
            ZygoteServer zygoteServer) {
      String args[] = {
			   //....
            "--capabilities=" + capabilities + "," + capabilities,
            "--nice-name=system_server",// 指定要fork的进程名字
            "--runtime-args",
            "--target-sdk-version=" + VMRuntime.SDK_VERSION_CUR_DEVELOPMENT,
            "com.android.server.SystemServer",//指定fork后要执行的程序
        };
            ZygoteConnection.Arguments parsedArgs = null;
            parsedArgs = new ZygoteConnection.Arguments(args);
			//并通过Zygote.forkSystemServer来forK SystemServer进程
            pid = Zygote.forkSystemServer(
                    parsedArgs.uid, parsedArgs.gid,
                    parsedArgs.gids,
                    parsedArgs.runtimeFlags,
                    null,
					parsedArgs.permittedCapabilities,
                    parsedArgs.effectiveCapabilities);
                  zygoteServer.closeServerSocket();
     		// 调用 handleSystemServerProcess来启动SystemServer
		    return handleSystemServerProcess(parsedArgs);
    }

• 上面这段代码中 指定了fork 进程的名字（system_server）和fork之后执行的程序（SystemServer）
• 并通过Zygote.forkSystemServe来fork systemServer进程

Zygote.forkSystemServer

 public static int forkSystemServer(int uid, int gid, int[] gids, int runtimeFlags,
            int[][] rlimits, long permittedCapabilities, long effectiveCapabilities) {
		//调用Natvie方法Fork 一个新的进程
        int pid = nativeForkSystemServer(
                uid, gid, gids, runtimeFlags, rlimits, permittedCapabilities, effectiveCapabilities);
        return pid;
    }
native private static int nativeForkSystemServer(int uid, int gid, int[] gids, int runtimeFlags,int[][] rlimits, long permittedCapabilities, long effectiveCapabilities);

• 调用nativeForkSystemServer方法forkSystemServer进程
  • 该方法的实现在frameworks/base/core/jni/com_android_internal_os_Zygote.cpp

nativeForkSystemServer

static jint com_android_internal_os_Zygote_nativeForkSystemServer(
        JNIEnv* env, jclass, uid_t uid, gid_t gid, jintArray gids,
        jint runtime_flags, jobjectArray rlimits, jlong permittedCapabilities,
        jlong effectiveCapabilities) {
  pid_t pid = ForkAndSpecializeCommon(env, uid, gid, gids,
                                      runtime_flags, rlimits,
                                      permittedCapabilities, effectiveCapabilities,
                                      MOUNT_EXTERNAL_DEFAULT, NULL, NULL, true, NULL,
                                      NULL, false, NULL, NULL);
    return pid

}

• nativeForkSystemServer fork完进程之后返回一个pid，到这里systemServier进程fork就结束了，下面返回pid方法执行回到了ZyogoteInit#main#forkSystemServer中 开始执行SystemServer

执行SystemServer

nativeForkSystemServer fork完进程之后返回一个pid，方法执行回到了ZyogoteInit#main#forkSystemServer中 开始执行SystemServer

• private static Runnable forkSystemServer(String abiList, String socketName,
              ZygoteServer zygoteServer) {
  			//并通过Zygote.forkSystemServer来forK SystemServer进程
              pid = Zygote.forkSystemServer(
                      parsedArgs.uid, parsedArgs.gid,
                      parsedArgs.gids,
                      parsedArgs.runtimeFlags,
                      null,
  					parsedArgs.permittedCapabilities,
                      parsedArgs.effectiveCapabilities);
                    zygoteServer.closeServerSocket();
       		
          if (pid == 0) {
              if (hasSecondZygote(abiList)) {
                  waitForSecondaryZygote(socketName);
              }
              zygoteServer.closeServerSocket();
              // 调用 handleSystemServerProcess来启动SystemServer
              return handleSystemServerProcess(parsedArgs);
          };
          return null;
      }
  

• 上述方法返回一个Runnable此时方法执行到了ZyogoteInit#main中

  • public static void main(String argv[]) {
       //4 启动SystemServer 通过Zygote.forkSystemService
       if (startSystemServer) {
          Runnable r = forkSystemServer(abiList, socketName, zygoteServer);
       	  r.run();
       }   	 			 
    }
    

  • Runnable.run 就是执行handleSystemServerProcess方法来执行SystemServer

handleSystemServerProcess 启动SystemSever

private static Runnable handleSystemServerProcess(ZygoteConnection.Arguments parsedArgs){
  	//将参数传递给SystemServer
    return ZygoteInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, cl);
}

ZygoteInit.zygoteInit

    public static final Runnable zygoteInit(int targetSdkVersion, String[] argv, ClassLoader classLoader) {
        //通过Jni调用Native层的代码 启动Binder线程池,这样SyetemServer进程就可以使用Binder来与其他进程进行通讯
        ZygoteInit.nativeZygoteInit();
        return RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader);
    }

RuntimeInit.ApplicationInit

RuntimeInit源码位置在frameworks/base/core/java/com/android/internal/os/RuntimeInit.java

protected static Runnable applicationInit(int targetSdkVersion,
                                          String[] argv,
                                          ClassLoader classLoader) {
    //执行传递进来执行文件的main方法  也就是SystemSever的main 
       return findStaticMain(args.startClass, args.startArgs, classLoader);
 }

终于执行到了SystemServer# main 方法

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

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

• main方法中执行run方法

最终执行到了SystemSever#run

 private void run() {
        try {
            traceBeginAndSlog("InitBeforeStartServices");
            //调整系统时间
            if (System.currentTimeMillis() < EARLIEST_SUPPORTED_TIME) {
                Slog.w(TAG, "System clock is before 1970; setting to 1970.");
                SystemClock.setCurrentTimeMillis(EARLIEST_SUPPORTED_TIME);
            }
    		//如果未设置，则将时区属性默认为GMT。
            String timezoneProperty =  SystemProperties.get("persist.sys.timezone");
            if (timezoneProperty == null || timezoneProperty.isEmpty()) {
                Slog.w(TAG, "Timezone not set; setting to GMT.");
                SystemProperties.set("persist.sys.timezone", "GMT");
            }
            //设置语言环境
            if (!SystemProperties.get("persist.sys.language").isEmpty()) {
                final String languageTag = Locale.getDefault().toLanguageTag();

                SystemProperties.set("persist.sys.locale", languageTag);
                SystemProperties.set("persist.sys.language", "");
                SystemProperties.set("persist.sys.country", "");
                SystemProperties.set("persist.sys.localevar", "");
            }
			
            // 进入安卓系统服务器！
            Slog.i(TAG, "Entered the Android system server!");
			// 性能采集分析
            if (SamplingProfilerIntegration.isEnabled()) {
                SamplingProfilerIntegration.start();
                mProfilerSnapshotTimer = new Timer();
                mProfilerSnapshotTimer.schedule(new TimerTask() {
                        @Override
                        public void run() {
                            SamplingProfilerIntegration.writeSnapshot("system_server", null);
                        }
                    }, SNAPSHOT_INTERVAL, SNAPSHOT_INTERVAL);
			}
  			//初始化虚拟机
           VMRuntime.getRuntime().clearGrowthLimit();
           VMRuntime.getRuntime().setTargetHeapUtilization(0.8f);

           // Some devices rely on runtime fingerprint generation, so make sure
           // we've defined it before booting further.
           Build.ensureFingerprintProperty();

           // Within the system server, it is an error to access Environment paths without
           // explicitly specifying a user.
           Environment.setUserRequired(true);

          // Within the system server, any incoming Bundles should be defused
           // to avoid throwing BadParcelableException.
          BaseBundle.setShouldDefuse(true);

          // Ensure binder calls into the system always run at foreground priority.
          BinderInternal.disableBackgroundScheduling(true);

         // Increase the number of binder threads in system_server
         BinderInternal.setMaxThreads(sMaxBinderThreads);
            // 准备主线程looper
            android.os.Process.setThreadPriority(
                android.os.Process.THREAD_PRIORITY_FOREGROUND);
            android.os.Process.setCanSelfBackground(false);
            Looper.prepareMainLooper();

            // 初始化Native服务
            System.loadLibrary("android_servers");


            //创建系统Context 在ActivityThread中完成
            createSystemContext();
            //创建SystemServiceManager
            mSystemServiceManager = new SystemServiceManager(mSystemContext);
            mSystemServiceManager.setRuntimeRestarted(mRuntimeRestart);
            LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
            //为可以并行的init任务准备线程池
            SystemServerInitThreadPool.get();
        } finally {
            traceEnd();  
        }

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

        // Loop forever. 启动loop永远运行
        Looper.loop();
        throw new RuntimeException("Main thread loop unexpectedly exited");
    }
 private void createSystemContext() {
       // 创建系统Context 在ActivityThread中完成
        ActivityThread activityThread = ActivityThread.systemMain();
        mSystemContext = activityThread.getSystemContext();
        mSystemContext.setTheme(DEFAULT_SYSTEM_THEME);
        final Context systemUiContext = activityThread.getSystemUiContext();
        systemUiContext.setTheme(DEFAULT_SYSTEM_THEME);
    }

run总结

执行SystemServer 内部做了如下工作

1. 初始化系统，如 运行时环境，VM 虚拟机、和线程池优先级等

2. 调用Looper#prepareMainLooper()，准备 Android 主线程Looper

3. 调用System#loadLibrary()初始化native环境

4. 调用createSystemContext()创建应用上下文

5. 创建SystemServiceManager，用于对系统服务进行创建，启动，管理,所有启动的服务都会注册到ServiceManager中

   • mSystemServiceManager.startService(xxxService.class);
     

6. 启动相关核心服务

   1. startBootstrapServices();//启动引导服务
      • SyetemServer进程在启动的过程中会启动PackageManagerService，PackageManagerService启动后会将系统中的应用程序安装完成。在此前已经启动的ActivityManagerService会将Launcher启动起来。入口就在Ams的systemReady()里
   2. startCoreServices();//启动核心服务
   3. startOtherServices();//启动其他服务
      • 当所有系统服务启动结束，会依次调用
        • WindowManagerService.systemReady()
        • PowerManagerService.systemReady()
        • PackageManagerService.systemReady() //安装系统程序
        • DisplayManagerService.systemReady() //安装第三方代码在这里启动了Launcher

7. 调用Looper.loop()让主线程的Looper跑起来

SystemServer总结

1. 启动Binder线程池
2. 初始化系统相关，系统环境 虚拟机等
3. 创建主线程looper
4. 创建系统Context
5. 创建SystemServiceManager，用于对系统服务进行创建，启动，管理
6. 启动各种服务 引导，核心，其他服务
   1. 启动launcher
   2. 完成系统程序的安装

启动服务分类

• 引导服务 startBootstrapServices
• 核心服务 startCoreServices
• 其他服务 startOtherServices

引导服务

1. 启动Installer服务
   • 系统安装Apk时的一个服务类，启动完成Installer服务之后才能启动其他的系统服务
2. 启动ActivityManagerService，Installer服务赋值给AMS
   • 负责四大组件的启动，切换，调度
3. 启动PowerManagerService，AMS initPowerManagement
4. 启动LightsService
   • 管理和显示所有显示设备
5. 启动PackageManagerService
   • 用来对Apk进行安装，解析，删除，卸载等操作
6. 启动SensorService
   • 为系统提供各种感应器服务

核心服务

1. 启动StartDropBoxManager
   • 用于生成和管理系统运行时的一些日志文件
2. 启动BatteryService
   • 管理电池相关服务
3. 启动UsageStatsService 赋值给AMS
   • 收集用户使用每一个app的频率，时长
4. 启动WebViewUpdateService
   • webView 更新服务

其他服务

这个太多了

1. 启动CameraService 摄像头相关服务
2. 启动AlarmManagerService ：全局定时器服务
3. 启动InputManagerService：管理输入事件
4. 启动WindowManagerService：窗口管理服务
5. 启动VrManagerService：VR模式管理服务
6. 启动BluetoothService：蓝牙管理服务
7. 启动NotificationManagerService：通知管理服务
8. 启动DeviceStorageMonitorService：存储相关管理服务
9. 启动LocationManangerService：定位管理服务
10. 启动AudioService：音频相关服务

…剩下的不列举了 大家可以自己看下