系统初始化init到（zygote）后启动桌面

zygote启动

所有进程初始化点：init.rc (system/core/rootdir/init.rc)

zygote初始化点：init.zygote32.rc(system/core/rootdir/init.zygote32.rc)

///system/bin/app_process为zygote编译的二进制文件地方
service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server

根据字符串查找app_process找到待编译的源文件：frameworks\base\cmds\app_process\app_main.cpp

//app_main.cpp
//关键代码，根据设置的参数，通过AndroidRuntime 设置参数，然后启动
if (zygote) {
   
        runtime.start("com.android.internal.os.ZygoteInit", args, zygote);
    } else if (className) {
   
        runtime.start("com.android.internal.os.RuntimeInit", args, zygote);
    } else {
   
        fprintf(stderr, "Error: no class name or --zygote supplied.\n");
        app_usage();
        LOG_ALWAYS_FATAL("app_process: no class name or --zygote supplied.");
    }

AndroidRuntime.cpp

//   frameworks\base\core\jni\AndroidRuntime.cpp

//主要作用，检测参数，通过JNI调用java方法（C++和java互相调用），使用反射来进行调用类方法
//com.android.internal.os.ZygoteInit   和     com.android.internal.os.RuntimeInit

//start方法内关键内容
jclass startClass = env->FindClass(slashClassName);
    if (startClass == NULL) {
   
        ALOGE("JavaVM unable to locate class '%s'\n", slashClassName);
        /* keep going */
    } else {
   
        jmethodID startMeth = env->GetStaticMethodID(startClass, "main",
            "([Ljava/lang/String;)V");
        if (startMeth == NULL) {
   
            ALOGE("JavaVM unable to find main() in '%s'\n", className);
            /* keep going */
        } else {
   
            env->CallStaticVoidMethod(startClass, startMeth, strArray);

ZygoteInit.java

// 通过查找字符串文件，找到文件路径
// frameworks\base\core\java\com\android\internal\os\ZygoteInit.java

//main函数关键内容
zygoteServer = new ZygoteServer(isPrimaryZygote);

            if (startSystemServer) {
   
                Runnable r = forkSystemServer(abiList, zygoteSocketName, zygoteServer);

                // {@code r == null} in the parent (zygote) process, and {@code r != null} in the
                // child (system_server) process.
                if (r != null) {
   
                    r.run();
                    return;
                }
            }

            Log.i(TAG, "Accepting command socket connections");

            // The select loop returns early in the child process after a fork and
            // loops forever in the zygote.
			//服务器循环监听
            caller = zygoteServer.runSelectLoop(abiList);


//  runnable的运行内容，forkSystemServer
 /* Hardcoded command line to start the system server */
        String args[] = {
   
                "--setuid=1000",
                "--setgid=1000",
                "--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1021,1023,"
                        + "1024,1032,1065,3001,3002,3003,3006,3007,3009,3010,3011",
                "--capabilities=" + capabilities + "," + capabilities,
                "--nice-name=system_server",
                "--runtime-args",
                "--target-sdk-version=" + VMRuntime.SDK_VERSION_CUR_DEVELOPMENT,
                "com.android.server.SystemServer",
        };
        ZygoteArguments parsedArgs = null;

int pid;

        try {
   
            parsedArgs = new ZygoteArguments(args);
            Zygote.applyDebuggerSystemProperty(parsedArgs);
            Zygote.applyInvokeWithSystemProperty(parsedArgs);

            if (Zygote.nativeSupportsTaggedPointers()) {
   
                /* Enable pointer tagging in the system server. Hardware support for this is present
                 * in all ARMv8 CPUs. */
                parsedArgs.mRuntimeFlags |= Zygote.MEMORY_TAG_LEVEL_TBI;
            }

            /* Enable gwp-asan on the system server with a small probability. This is the same
             * policy as applied to native processes and system apps. */
            parsedArgs.mRuntimeFlags |= Zygote.GWP_ASAN_LEVEL_LOTTERY;

            if (shouldProfileSystemServer()) {
   
                parsedArgs.mRuntimeFlags |= Zygote.PROFILE_SYSTEM_SERVER;
            }

            /* Request to fork the system server process */
            //进行fork  system server process
           	//调用Zygote进行产生进程。
            pid = Zygote.forkSystemServer(
                    parsedArgs.mUid, parsedArgs.mGid,
                    parsedArgs.mGids,
                    parsedArgs.mRuntimeFlags,
                    null,
                    parsedArgs.mPermittedCapabilities,
                    parsedArgs.mEffectiveCapabilities);
        } catch (IllegalArgumentException ex) {
   
            throw new RuntimeException(ex);
        }

        /* For child process */
		//为子进程时
        if (pid == 0) {
   
            if (hasSecondZygote(abiList)) {
   
                waitForSecondaryZygote(socketName);
            }

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

zygote.java

//   frameworks\base\core\java\com\android\internal\os\Zygote.java
static int forkSystemServer(int uid, int gid, int[] gids, int runtimeFlags,
            int[][] rlimits, long permittedCapabilities, long effectiveCapabilities) {
   
        ZygoteHooks.preFork();

        int pid = nativeForkSystemServer(
                uid, gid, gids, runtimeFlags, rlimits,
                permittedCapabilities, effectiveCapabilities);

        // Set the Java Language thread priority to the default value for new apps.
        Thread.currentThread().setPriority(Thread.NORM_PRIORITY);

        ZygoteHooks.postForkCommon();
        return pid;
    }

//核心方法，jni
private static native int nativeForkSystemServer(int uid, int gid, int[] gids, int runtimeFlags,
            int[][] rlimits, long permittedCapabilities, long effectiveCapabilities);

com_android_internal_os_Zygote.cpp

进行关键词查找zygote文件

frameworks\base\core\jni\com_android_internal_os_Zygote.cpp

//最终实现方法
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 permitted_capabilities,
        jlong effective_capabilities) {
   
  std::vector<int> fds_to_close(MakeUsapPipeReadFDVector()),
                   fds_to_ignore(fds_to_close);

  fds_to_close.push_back(gUsapPoolSocketFD);

  if (gUsapPoolEventFD != -1) {
   
    fds_to_close.push_back(gUsapPoolEventFD);
    fds_to_ignore.push_back(gUsapPoolEventFD);
  }

  if (gSystemServerSocketFd != -1) {
   
      fds_to_close.push_back(gSystemServerSocketFd);
      fds_to_ignore.push_back(gSystemServerSocketFd);
  }

  pid_t pid = ForkCommon(env, true,
                         fds_to_close,
                         fds_to_ignore,
                         true);
  if (pid == 0) {
   
      // System server prcoess does not need data isolation so no need to
      // know pkg_data_info_list.
      SpecializeCommon(env, uid, gid, gids, runtime_flags, rlimits,
                       permitted_capabilities, effective_capabilities,
                       MOUNT_EXTERNAL_DEFAULT, nullptr, nullptr, true,
                       false, nullptr, nullptr, /* is_top_app= */ false,
                       /* pkg_data_info_list */ nullptr,
                       /* whitelisted_data_info_list */ nullptr, false, false);
  } else if (pid > 0) {
   
      // The zygote process checks whether the child process has died or not.
      ALOGI("System server process %d has been created", pid);
      gSystemServerPid = pid;
      // There is a slight window that the system server process has crashed
      // but it went unnoticed because we haven't published its pid yet. So
      // we recheck here just to make sure that all is well.
      int status;
      if (waitpid(pid, &status, WNOHANG) == pid) {
   
          ALOGE("System server process %d has died. Restarting Zygote!", pid);
          RuntimeAbort(env, __LINE__, "System server process has died. Restarting Zygote!");
      }

      if (UsePerAppMemcg()) {
   
          // Assign system_server to the correct memory cgroup.
          // Not all devices mount memcg so check if it is mounted first
          // to avoid unnecessarily printing errors and denials in the logs.
          if (!SetTaskProfiles(pid, std::vector<std::string>{
   "SystemMemoryProcess"})) {
   
              ALOGE("couldn't add process %d into system memcg group", pid);
          }
      }
  }
  return pid;
}

zytogeServer.java

frameworks\base\core\java\com\android\internal\os\ZygoteServer.java

//进行接收连接提供服务
Runnable runSelectLoop(String abiList)