Android Framework实战视频--SystemServer启动篇
作者：互联网
在线学习课程，课程咨询答疑和新课信息：QQ交流群：422901085进行课程讨论
转自于：https://blog.csdn.net/learnframework/article/details/116310690
课程答疑和新课信息：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方法
标签：省略,启动,--,mSystemServiceManager,Framework,startService,Android,class 来源： https://www.cnblogs.com/qianlima-android/p/15482079.html