Android Framework实战视频--系统SystemServer启动篇

Posted 2021-09-01 Android高级知识分享官

课程答疑和新课信息：QQ交流群：422901085进行课程讨论
FrameWork入门课视频链接：https://edu.csdn.net/course/detail/30298
FrameWork实战课1视频链接：https://edu.csdn.net/course/detail/30275
专题博客系列：
Android 8.1 zygote 启动过程源码
Android Framework实战视频–Zygote的fork进程篇
Android Framework实战视频–SystemServer启动篇
Android Framework实战视频–SystemServer启动FallbackHome篇
Android Framework实战视频–FallbackHome进程启动及Activity启动篇
Android Framework实战视频–FallbackHome结束启动Launcher篇

SystemServer启动篇

上一讲已经讲了systemserver进程被fork出来了
代码在ZygoteInit的main方法中的：

Runnable r = forkSystemServer(abiList, socketName, zygoteServer);

进入forkSystemServer方法后已经分析到：

   pid = Zygote.forkSystemServer

即在Zygote中又调用了forkSystemServer方法一直到native层才调用了真正的linux的 fork（）
在Zygote.forkSystemServer返回后看代码如下：

 if (pid == 0) {
            if (hasSecondZygote(abiList)) {
                waitForSecondaryZygote(socketName);
            }

            zygoteServer.closeServerSocket();
            return handleSystemServerProcess(parsedArgs);
        }

由于SystemServer是复制Zygote的进程，因此也会包含Zygote的zygoteServer，对于SystemServer没有其他作用，需要先将其关闭；通过调用handleSystemServerProcess:

 private static Runnable handleSystemServerProcess(ZygoteConnection.Arguments parsedArgs) {
     //省略。。
        final String systemServerClasspath = Os.getenv("SYSTEMSERVERCLASSPATH");
        //省略。。

        if (parsedArgs.invokeWith != null) {
         //省略。。
        } else {
            ClassLoader cl = null;
            if (systemServerClasspath != null) {
             //创建PathClassLoader
                cl = createPathClassLoader(systemServerClasspath, parsedArgs.targetSdkVersion);

                Thread.currentThread().setContextClassLoader(cl);
            }

            /*
             * Pass the remaining arguments to SystemServer.
             */
            return ZygoteInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, cl);
        }

        /* should never reach here */
    }

这里创建PathClassLoader然后又调用ZygoteInit.zygoteInit

 public static final Runnable zygoteInit(int targetSdkVersion, String[] argv, ClassLoader classLoader) {
//省略
        RuntimeInit.commonInit();
        //启动一下binder线程池
        ZygoteInit.nativeZygoteInit();
        return RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader);
    }

这里先调用ZygoteInit.nativeZygoteInit()，是一个native方法，实现在androidRuntime里面，最后调到app_main.cpp的onZygoteInit，来启动binder线程池：

 virtual void onZygoteInit()
    {
        sp<ProcessState> proc = ProcessState::self();
        ALOGV("App process: starting thread pool.\\n");
        proc->startThreadPool();
    }

接下来调用RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader);

 protected static Runnable applicationInit(int targetSdkVersion, String[] argv,
            ClassLoader classLoader) {
       //省略
        return findStaticMain(args.startClass, args.startArgs, classLoader);
    }

applicationInit主要就是实现寻找startClass中的main方法，然后构造一个Runable，对应的run方法就是调用main方法：

private static Runnable findStaticMain(String className, String[] argv,
            ClassLoader classLoader) {
      //省略
            cl = Class.forName(className, true, classLoader);
        //省略
            m = cl.getMethod("main", new Class[] { String[].class });
         //省略
        return new MethodAndArgsCaller(m, argv);
    }

其中MethodAndArgsCaller：

 static class MethodAndArgsCaller implements Runnable {
       //省略
        public void run() {
           //省略
                mMethod.invoke(null, new Object[] { mArgs });
            //省略
        }
    }

所以这里就是关键确定startClass是谁
这里又得回到开始ZygoteInit类的forkSystemServer：
有如下参数：

  String args[] = {
            "--setuid=1000",
            "--setgid=1000",
            "--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1021,1023,1032,3001,3002,3003,3006,3007,3009,3010",
            "--capabilities=" + capabilities + "," + capabilities,
            "--nice-name=system_server",
            "--runtime-args",
            "com.android.server.SystemServer",
        };

其实这里的statClass就是最后一个参数： “com.android.server.SystemServer”

以上过程完成了从Zygote经过RuntimeInit最后完成SystemServer的main方法的运行。下面重点分析SystemServer的main方法：

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

直接调用run方法：

private void run() {
        	//创建Looper对象
            Looper.prepareMainLooper();
            // 加载系统android_servers的库
            System.loadLibrary("android_servers")；
            //创建系统的Context
            createSystemContext()
			mSystemServiceManager = new SystemServiceManager(mSystemContext);
            mSystemServiceManager.setRuntimeRestarted(mRuntimeRestart);
            LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
	 		//省略。。
            //启动引导服务
            startBootstrapServices();
            //启动核心服务
            startCoreServices();
            //启动其他服务
            startOtherServices();
           //省略。。
           Looper.loop();     
}

run方法中内容也比较多，这里分析几个重要部分既可以：
Looper.prepareMainLooper();主要目的就是创建好Looper对象，因为system server的主线程和普通app主线程一样是一个Loop管理的消息循环

createSystemContext()表示创建一个systemContext，Context不仅仅在普通app中非常重要，在system server中也一样，需要通过Context这个纽带来，获取一些进程的信息环境。

mSystemServiceManager = new SystemServiceManager(mSystemContext);这里创建了一个SystemServiceManager的类对象，而且放入了LocalServices中，其实这里的SystemServiceManager和常见binder中的ServiceManager还是不一样的，SystemServiceManager只是System Server中一个普通的类，他负责保存了各个SystemService的全局变量角色，本身不涉及跨进程，而ServiceManager可以与binder跨进除等是强关联

再接下来就是重点中重点：
//启动引导服务
startBootstrapServices();
//启动核心服务
startCoreServices();
//启动其他服务
startOtherServices();

system server把系统的所有服务分了3类进行启动
第一个：startBootstrapServices();
这一部分看注释可以大概得出，系统服务之间存在着非常复杂的依赖关系，所以需要把一些重要的系统服务进行第一位启动

 /**
     * Starts the small tangle of critical services that are needed to get
     * the system off the ground.  These services have complex mutual dependencies
     * which is why we initialize them all in one place here.  Unless your service
     * is also entwined in these dependencies, it should be initialized in one of
     * the other functions.
     */
    private void startBootstrapServices() {
      //省略。。
        Installer installer = mSystemServiceManager.startService(Installer.class);
        //省略。。
        mSystemServiceManager.startService(DeviceIdentifiersPolicyService.class);
        //省略。。
        mActivityManagerService = mSystemServiceManager.startService(
                ActivityManagerService.Lifecycle.class).getService();
        mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
        mActivityManagerService.setInstaller(installer);
        //省略。。
        mPowerManagerService = mSystemServiceManager.startService(PowerManagerService.class);
        //省略。。
        mActivityManagerService.initPowerManagement();
        //省略。。
        if (!SystemProperties.getBoolean("config.disable_noncore", false)) {
            traceBeginAndSlog("StartRecoverySystemService");
            mSystemServiceManager.startService(RecoverySystemService.class);
            traceEnd();
        }

       //省略。。
        mSystemServiceManager.startService(LightsService.class);
        //省略。。
        mDisplayManagerService = mSystemServiceManager.startService(DisplayManagerService.class);
       //省略。。
        mSystemServiceManager.startBootPhase(SystemService.PHASE_WAIT_FOR_DEFAULT_DISPLAY);
       //省略。。
        mPackageManagerService = PackageManagerService.main(mSystemContext, installer,
                mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF, mOnlyCore);
        mFirstBoot = mPackageManagerService.isFirstBoot();
        mPackageManager = mSystemContext.getPackageManager();
        //省略。。
           OtaDexoptService.main(mSystemContext, mPackageManagerService);
         //省略。。
        mSystemServiceManager.startService(UserManagerService.LifeCycle.class);
      //省略。。
        mActivityManagerService.setSystemProcess();
       //省略。。
        mDisplayManagerService.setupSchedulerPolicies();

      //省略。。
        mSystemServiceManager.startService(new OverlayManagerService(mSystemContext, installer));
		 //省略。。
            startSensorService();
         //省略。。
        }, START_SENSOR_SERVICE);
    }

这个里面代码主要就是启动一些服务，这些服务需要放在第一位进行启动，因为很可能后面服务对这些都是有依赖关系。
这里只对ActivityManagerService的启动进行一个例子分析，其他的服务就大概思路一样，不再单独分析：

 mActivityManagerService = mSystemServiceManager.startService(
                ActivityManagerService.Lifecycle.class).getService();

接下来分析 mSystemServiceManager.startService方法：

 public <T extends SystemService> T startService(Class<T> serviceClass) {
         //省略
                Constructor<T> constructor = serviceClass.getConstructor(Context.class);
                service = constructor.newInstance(mContext);
         //省略
            startService(service);//调用自己的startService
            return service;
    //省略
    }
    
    public void startService(@NonNull final SystemService service) {
        // Register it.
        mServices.add(service);
      //省略
            service.onStart();
        //省略
    }

最后分析其实师调用了serviceClass的onStart方法，这里的serviceClass是 ActivityManagerService.Lifecycle.class

 public static final class Lifecycle extends SystemService {
        private final ActivityManagerService mService;

        public Lifecycle(Context context) {
            super(context);
            mService = new ActivityManagerService(context);
        }

        @Override
        public void onStart() {
            mService.start();
        }

        @Override
        public void onCleanupUser(int userId) {
            mService.mBatteryStatsService.onCleanupUser(userId);
        }

        public ActivityManagerService getService() {
            return mService;
        }
    }

这里看到构造时候 mService = new ActivityManagerService(context);把ActivityManagerService构造了，getService()也是直接返回的ActivityManagerService对象，onStart也是调用了ActivityManagerService的start方法

其他的另外两个也是和第一个类是启动服务，只是构造service方法上有细微差别，这里就不挨个具体分析了
//启动核心服务
startCoreServices();
//启动其他服务
startOtherServices();

这里最后一步的startOtherServices不仅仅只启动了一些Service，在启动完了各个Service后，它还会调用各个Service的systemReady方法：

// It is now time to start up the app processes...
  vibrator.systemReady();
  lockSettings.systemReady();
  wm.systemReady();
  mPowerManagerService.systemReady(mActivityManagerService.getAppOpsService());
  mPackageManagerService.systemReady();
  mDisplayManagerService.systemReady(safeMode, mOnlyCore);
   mActivityManagerService.systemReady(..)

这里只列出了主要的几个systemReady方法