总体流程
Android系统启动.png
源码解析
Zygote进程启动
首先，启动触发是在linux环境的C++文件内。
- bootloader启动
- init.app # main
init.app有兴趣的可以研究一下，我仅梳理了一个流程
if (bootscript.empty()) {
parser.ParseConfig("/init.rc");
parser.set_is_system_etc_init_loaded(parser.ParseConfig("/system/etc/init"));
parser.set_is_vendor_etc_init_loaded(parser.ParseConfig("/vendor/etc/init"));
parser.set_is_odm_etc_init_loaded(parser.ParseConfig("/odm/etc/init"));
} else {
parser.ParseConfig(bootscript);
parser.set_is_system_etc_init_loaded(true);
parser.set_is_vendor_etc_init_loaded(true);
parser.set_is_odm_etc_init_loaded(true);
}
在这个方法中会解析init.rc
...
import /init.${ro.zygote}.rc
...
针对系统引入不同的zygote.rc 文件
- init.zygote32.rc
- init.zygote32_64.rc
- init.zygote64.rc
- init.zygote64_32.rc
# init.zygote32.rc
# 启动zygote服务 该服务的绝对路径 ..参数（ 最后一个参数是告诉Zygote服务，自身启动后要启动systemServer）
service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server
class main
priority -20
user root
group root readproc
socket zygote stream 660 root system
onrestart write /sys/android_power/request_state wake
onrestart write /sys/power/state on
onrestart restart audioserver
onrestart restart cameraserver
onrestart restart media
onrestart restart netd
onrestart restart wificond
writepid /dev/cpuset/foreground/tasks
- 启动Zygote进程的入口函数是app_main.cpp
app_main.cpp#main
int main(int argc, char* const argv[]){
...
AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));
...
// 解析参数，参数都会塞到 args[] 内
while (i < argc) {
const char* arg = argv[i++];
if (strcmp(arg, "--zygote") == 0) { // 是否是要启动zygote进程
zygote = true;
niceName = ZYGOTE_NICE_NAME;
} else if (strcmp(arg, "--start-system-server") == 0) { // 启动后是否需要开启SystemServer
startSystemServer = true;
}
...
}
...
if (zygote) { // 如果是zygote进程，则启动ZygoteInit.java
runtime.start("com.android.internal.os.ZygoteInit", args, zygote);
} else if (className) { // 这个是启动 RuntimeInit.java
runtime.start("com.android.internal.os.RuntimeInit", args, zygote);
}
}
- AppRuntime#start()
class AppRuntime : public AndroidRuntime
因为AppRuntime是继承自AndroidRuntime，所以这里我们直接看AndroidRuntime#start()
- AndroidRuntime#start()
AndroidRuntime.cpp
void AndroidRuntime::start(const char* className, const Vector& options, bool zygote){
...
JNIEnv* env;
// 启动虚拟机 for Zygote
if (startVm(&mJavaVM, &env, zygote) != 0) {
return;
}
onVmCreated(env);
//注册android的native方法
if (startReg(env) < 0) {
ALOGE("Unable to register all android natives\n");
return;
}
...
// 找入口类（ZygoteInit.java）
jclass startClass = env->FindClass(slashClassName);
// 找入口 main 方法
jmethodID startMeth = env->GetStaticMethodID(startClass, "main","([Ljava/lang/String;)V");
// 执行 ZygoteInit#main()
env->CallStaticVoidMethod(startClass, startMeth, strArray);
...
}
下面的逻辑就走到Java环境了，java的源码文件路径就不贴了，在Android Studio中都可以直接看到
- ZygoteInit#main
public static void main(String argv[]) {
ZygoteServer zygoteServer = new ZygoteServer();
...
// 标记 zygote 启动开始. 确保在这个期间创建新线程会抛出错误.
ZygoteHooks.startZygoteNoThreadCreation();
final Runnable caller;
try {
// 开启DDMS
RuntimeInit.enableDdms();
// 解析参数
boolean startSystemServer = false;
String socketName = "zygote";
String abiList = null;
boolean enableLazyPreload = false;
for (int i = 1; i < argv.length; i++) {
if ("start-system-server".equals(argv[i])) {
startSystemServer = true; // 需要在Zygote完成后启动SystemServer
} else if ("--enable-lazy-preload".equals(argv[i])) {
enableLazyPreload = true; // 支持懒加载
} else if (argv[i].startsWith(ABI_LIST_ARG)) {
abiList = argv[i].substring(ABI_LIST_ARG.length());
} else if (argv[i].startsWith(SOCKET_NAME_ARG)) {
socketName = argv[i].substring(SOCKET_NAME_ARG.length());
} else {
throw new RuntimeException("Unknown command line argument: " + argv[i]);
}
}
// 注册名字为：zygote 的Socket服务，其他进程籍此与其通信
zygoteServer.registerServerSocket(socketName);
if (!enableLazyPreload) {
/* 开启预加载
beginIcuCachePinning();
preloadClasses();
preloadResources();
nativePreloadAppProcessHALs();
preloadOpenGL();
preloadSharedLibraries();
preloadTextResources();
WebViewFactory.prepareWebViewInZygote();
endIcuCachePinning();
warmUpJcaProviders();
*/
preload(bootTimingsTraceLog);
} else {
Zygote.resetNicePriority();
}
// 清理一些内存出来，一般只在fork新进程前有效
gcAndFinalize();
// 放开线程创建的报错限制，取消Zygote启动的标记，与方法开始时的标记对应
ZygoteHooks.stopZygoteNoThreadCreation();
// 开始创建SystemServer进程
if (startSystemServer) {
Runnable r = forkSystemServer(abiList, socketName, zygoteServer);
if (r != null) {
r.run();
return;
}
}
// 开启一个SelectLoop，用来处理Socket传递过来的消息 — fork 新进程的消息
// Zygote主进程在上面startSystemServer内就已经退出了，所以是在子进程fork完成后才走到这里的
// loop一直都在Zygote的主进程内
caller = zygoteServer.runSelectLoop(abiList);
} catch (Throwable ex) {
throw ex;
} finally {
zygoteServer.closeServerSocket();
}
// 在子进程中才能走到这里，Zygote的主进程是不会走到这里的。
if (caller != null) {
caller.run();
}
}
SystemServer 进程启动
现在我们来看下forkSystemServer的过程
- ZygoteInit#forkSystemServer()
private static Runnable forkSystemServer(String abiList, String socketName, ZygoteServer zygoteServer) {
...
// 硬编码的命令行去启动SystemServer
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", // 留意这里，后面会直接启动这个类
};
ZygoteConnection.Arguments parsedArgs = null;
int pid;
try {
parsedArgs = new ZygoteConnection.Arguments(args);
ZygoteConnection.applyDebuggerSystemProperty(parsedArgs);
ZygoteConnection.applyInvokeWithSystemProperty(parsedArgs);
// fork SystemServer 进程
pid = Zygote.forkSystemServer(
parsedArgs.uid, parsedArgs.gid,
parsedArgs.gids,
parsedArgs.debugFlags,
null,
parsedArgs.permittedCapabilities,
parsedArgs.effectiveCapabilities);
} catch (IllegalArgumentException ex) {
throw new RuntimeException(ex);
}
/* For child process */
if (pid == 0) {
if (hasSecondZygote(abiList)) {
waitForSecondaryZygote(socketName);
}
zygoteServer.closeServerSocket();
// 看这里，返回的是个啥呢？
return handleSystemServerProcess(parsedArgs);
}
return null;
}
- ZygoteInit#handleSystemServerProcess()
private static Runnable handleSystemServerProcess(ZygoteConnection.Arguments parsedArgs) {
...
return ZygoteInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, cl);
}
- ZygoteInit#zygoteInit()
public static final Runnable zygoteInit(int targetSdkVersion, String[] argv, ClassLoader classLoader) {
...
return RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader);
}
- RuntimeInit#applicationInit()
protected static Runnable applicationInit(int targetSdkVersion, String[] argv,ClassLoader classLoader) {
...
// startClass = com.android.server.SystemServer 有兴趣的同学，可以看看详细的参数解析逻辑
return findStaticMain(args.startClass, args.startArgs, classLoader);
}
- RuntimeInit#findStaticMain
// 实际就是找 com.android.server.SystemServer 的main方法
private static Runnable findStaticMain(String className, String[] argv, ClassLoader classLoader) {
Class cl = Class.forName(className, true, classLoader);
...
Method m = cl.getMethod("main", new Class[] { String[].class });
...
return new MethodAndArgsCaller(m, argv);
}
static class MethodAndArgsCaller implements Runnable {
/** method to call */
private final Method mMethod;
/** argument array */
private final String[] mArgs;
public MethodAndArgsCaller(Method method, String[] args) {
mMethod = method;
mArgs = args;
}
public void run() {
// 无处不在的反射调用
mMethod.invoke(null, new Object[] { mArgs });
}
}
可以看到这一些列的操作都是在SystemServer进程fork完成后，去执行SystemServer#main方法
- SystemServer#main
public static void main(String[] args) {
new SystemServer().run();
}
private void run() {
try {
// 设置系统属性
...
// 创建looper
Looper.prepareMainLooper();
// 初始化 mSystemContext
createSystemContext();
// 创建 systemServiceManager. 用来管理系统服务的创建及生命周期
mSystemServiceManager = new SystemServiceManager(mSystemContext);
mSystemServiceManager.setRuntimeRestarted(mRuntimeRestart);
...
}
// 启动服务
try {
// 开启BootStrap服务，AMS就是在这里启动的，有兴趣可以看下源码
startBootstrapServices();
// 启动核心服务，绑定AMS
startCoreServices();
// 这里也是启动一些非交叉的服务，绑定AMS，并在这里启动Launcher应用，我们继续往下看
startOtherServices();
}
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
Launcher 启动
我们来看下Launcher应用是怎么启动的哈
- SystemServer#startOtherServices
private void startOtherServices() {
...
// 很长很长很长的服务启动逻辑，有兴趣的可以看下，电话、输入输出、闹铃的等等服务器都在这里启动的
...
// 最后一个方法
mActivityManagerService.systemReady(() -> {
// 这里是做了一些后续的服务启动逻辑
mActivityManagerService.startObservingNativeCrashes(); // Native崩溃
mWebViewUpdateService.prepareWebViewInSystemServer(); // 浏览器
mSystemServiceManager.startService(CarServiceHelperService.class); // 汽车服务
startSystemUi(context, windowManagerF); // 系统UI
Watchdog.getInstance().start(); // 看门狗
...
}
}
- ActivityManagerService#systemReady()
public void systemReady(final Runnable goingCallback, TimingsTraceLog traceLog) {
...
// 开始启动桌面应用
startHomeActivityLocked(currentUserId, "systemReady");
}
到这里就开始启动桌面应用了，后面就是Activity的启动逻辑了。