android 启动的流程

android 启动的流程 

Linux  

BootLoader 作用->  加载驱动 启动硬件 加载linux内核 

系统的第一个进程 init 进程 对应的启动的代码 init.c

system/core/init/init.c

main方法

创建重要的系统目录 并且加载进来

   mkdir("/dev", 0755);

   mkdir("/proc", 0755);

   mkdir("/sys", 0755);

   mount("tmpfs", "/dev", "tmpfs", MS_NOSUID, "mode=0755");

   mkdir("/dev/pts", 0755);

   mkdir("/dev/socket", 0755);

   mount("devpts", "/dev/pts", "devpts", 0, NULL);

   mount("proc", "/proc", "proc", 0, NULL);

   mount("sysfs", "/sys", "sysfs", 0, NULL);

   init_parse_config_file("/init.rc"); //解析init.rc配置文件 这个配置文件中都是linux命令 解析这些命令并且执行

system/core/rootdir/init.rc

跟启动相关 比较重要的部分

service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server

    class main

    socket zygote stream 660 root system

    onrestart write /sys/android_power/request_state wake

    onrestart write /sys/power/state on

    onrestart restart media

    onrestart restart netd

以服务的形式启动 zygote进程   

zygote进程 是android中十分重要的进程 孵化器进程(受精卵) 所有的android应用进程以及重要的系统进程都是有这个zygote进程 通过fork

以复制自身的形式创建的

1.service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server

2.service zygote 以服务的形式启动zygote 

3./system/bin/app_process 启动的时候对应的文件路径   

 --zygote --start-system-server启动是传入的参数

App_main.cpp

main方法

...... 

const char* className = NULL;

    while (i < argc) {

        const char* arg = argv[i++];

        if (!parentDir) {

            parentDir = arg;

        } else if (strcmp(arg, "--zygote") == 0) {//遍历传入的字符串数组  --zygote --start-system-server

            zygote = true;

            niceName = "zygote"; //这里会被执行

      } else if (strcmp(arg, "--start-system-server") == 0) {

          startSystemServer = true;   //这里会被执行

      } else if (strcmp(arg, "--application") == 0) {

          application = true;

      } else if (strncmp(arg, "--nice-name=", 12) == 0) {

          niceName = arg + 12;

      } else {

          className = arg;

          break;

      }

  }

  if (niceName && *niceName) {

      setArgv0(argv0, niceName);

      set_process_name(niceName); //给当前进程起名字为zygote

  }

  runtime.mParentDir = parentDir;

  if (zygote) {

      runtime.start("com.android.internal.os.ZygoteInit",

              startSystemServer ? "start-system-server" : "");  //调用runtime.start方法(ZygoteInit start-system-server)

  } 

....

runtime.start("com.android.internal.os.ZygoteInit", "start-system-server" );

runtime.start  ①给当前的进程创建了一个java虚拟机 ②通过jni的调用 启动了ZygoteInit.java的main方法 启动了第一个java程序

void AndroidRuntime::start(const char* className, const char* options)

{

    ALOGD("\n>>>>>> AndroidRuntime START %s <<<<<<\n",

            className != NULL ? className : "(unknown)");

    blockSigpipe();

    if (strcmp(options, "start-system-server") == 0) {

        const int LOG_BOOT_PROGRESS_START = 3000;

        LOG_EVENT_LONG(LOG_BOOT_PROGRESS_START,

                       ns2ms(systemTime(SYSTEM_TIME_MONOTONIC)));

    }

    const char* rootDir = getenv("ANDROID_ROOT");

    if (rootDir == NULL) {

        rootDir = "/system";

        if (!hasDir("/system")) {

            LOG_FATAL("No root directory specified, and /android does not exist.");

            return;

        }

        setenv("ANDROID_ROOT", rootDir, 1);

    }

    //const char* kernelHack = getenv("LD_ASSUME_KERNEL");

    //ALOGD("Found LD_ASSUME_KERNEL='%s'\n", kernelHack);

    JNIEnv* env;             //启动java虚拟机

    if (startVm(&mJavaVM, &env) != 0) {

        return;

    }

    onVmCreated(env);

    if (startReg(env) < 0) {

        ALOGE("Unable to register all android natives\n");

        return;

    }

    jclass stringClass;

    jobjectArray strArray;

    jstring classNameStr;

    jstring optionsStr;

    stringClass = env->FindClass("java/lang/String");   通过jni调用 创建了一个java的String[] = {"com.android.internal.os.ZygoteInit", "start-system-server"}

    assert(stringClass != NULL);

    strArray = env->NewObjectArray(2, stringClass, NULL);

    assert(strArray != NULL);

    classNameStr = env->NewStringUTF(className);

    assert(classNameStr != NULL);

    env->SetObjectArrayElement(strArray, 0, classNameStr);

    optionsStr = env->NewStringUTF(options);

 env->SetObjectArrayElement(strArray, 1, optionsStr);

    char* slashClassName = toSlashClassName(className); //通过Jni调用 找到zygoteInit.java的字节码 找到main方法 执行

    jclass startClass = env->FindClass(slashClassName);  

    if (startClass == NULL) {

        ALOGE("JavaVM unable to locate class '%s'\n", slashClassName);

    } else {

        jmethodID startMeth = env->GetStaticMethodID(startClass, "main", //执行main方法的时候 把刚创建的String[]作为参数穿进去

            "([Ljava/lang/String;)V");

        if (startMeth == NULL) {

            ALOGE("JavaVM unable to find main() in '%s'\n", className);

        } else {

            env->CallStaticVoidMethod(startClass, startMeth, strArray);

#if 0

            if (env->ExceptionCheck())

                threadExitUncaughtException(env);

#endif

        }

    }

    free(slashClassName);

    ALOGD("Shutting down VM\n");

    if (mJavaVM->DetachCurrentThread() != JNI_OK)

        ALOGW("Warning: unable to detach main thread\n");

    if (mJavaVM->DestroyJavaVM() != 0)

        ALOGW("Warning: VM did not shut down cleanly\n");

}

到这儿 从native世界 来到了java的程序中

zygoteInit main方法

public static void main(String argv[]) {

        try {

           // Start profiling the zygote initialization.

           SamplingProfilerIntegration.start();

           registerZygoteSocket();  //创建一个socket服务端

           EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_START,

               SystemClock.uptimeMillis());

           preload();                  //预加载资源 包括 两千多个字节码对象  用到的系统图片 颜色资源

            EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_END,

                SystemClock.uptimeMillis());

            // Finish profiling the zygote initialization.

            SamplingProfilerIntegration.writeZygoteSnapshot();

            // Do an initial gc to clean up after startup

            gc();

            // If requested, start system server directly from Zygote

            if (argv.length != 2) {

                throw new RuntimeException(argv[0] + USAGE_STRING);

            }

            if (argv[1].equals("start-system-server")) {

                startSystemServer();                                //开启SystemServer 系统服务

            } else if (!argv[1].equals("")) {

                throw new RuntimeException(argv[0] + USAGE_STRING);

            }

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

            if (ZYGOTE_FORK_MODE) {

                runForkMode();

            } else {

                runSelectLoopMode();                                     //开启死循环 等待socket客户端访问

            }

            closeServerSocket();

        } catch (MethodAndArgsCaller caller) {

            caller.run();

        } catch (RuntimeException ex) {

            Log.e(TAG, "Zygote died with exception", ex);

            closeServerSocket();

            throw ex;

        }

    }

zygote启动到这儿就结束了

zygote在启动的过程中 做了如下几件事儿

① zygote进程创建了一个jvm

② zygote创建了一个socket服务端 等待ams给它发消息 分叉新的进程

③ 预加载了资源包括 字节码 图片 颜色

④ 跑起死循环 等待客户端连接

⑤ 创建了SystemServer进程

SystemServer启动的过程

    private static boolean startSystemServer()

            throws MethodAndArgsCaller, RuntimeException {

        String args[] = {

           "--setuid=1000",

           "--setgid=1000",

            "--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,3001,3002,3003,3006,3007",

            "--capabilities=130104352,130104352",

            "--runtime-init",

            "--nice-name=system_server",

            "com.android.server.SystemServer",

        };

        ZygoteConnection.Arguments parsedArgs = null;

        int pid;

        try {

            parsedArgs = new ZygoteConnection.Arguments(args);  //zygote进程 分叉出systemserver进程

            ZygoteConnection.applyDebuggerSystemProperty(parsedArgs);

            ZygoteConnection.applyInvokeWithSystemProperty(parsedArgs);

            pid = Zygote.forkSystemServer(

                    parsedArgs.uid, parsedArgs.gid,

                    parsedArgs.gids,

                    parsedArgs.debugFlags,

                    null,

                    parsedArgs.permittedCapabilities,

                    parsedArgs.effectiveCapabilities);

        } catch (IllegalArgumentException ex) {

            throw new RuntimeException(ex);

        }

        if (pid == 0) {

            handleSystemServerProcess(parsedArgs); //pid为0说明当前的代码执行在子进程中 这个进程就是system_server进程

        }

        return true;

    }

hanldeSystemServerProess->RuntimeInit.zygoteInit->applicationInit->invokestaticMain()->调用了SystemServer.java的main方法

systemServer的main方法 通过jni调用到 systemserver.cpp的init1方法

init1方法 调用了system_init() 在这个方法中 把 显示的驱动和传感器的驱动启动起来

只有这些驱动加载进来了 在java层才能启动相应的服务

通过jni system_init() 方法又调用到systemServer.java的 init2方法

public static final void init2() {

        Slog.i(TAG, "Entered the Android system server!");

        Thread thr = new ServerThread();

        thr.setName("android.server.ServerThread");

        thr.start(); //执行serverThread的run方法

    }

在run方法中 创建了系统服务对象 通过ServiceManager保存起来

.....//声明各种服务

Installer installer = null;

       AccountManagerService accountManager = null;

       ContentService contentService = null;

       LightsService lights = null;

       PowerManagerService power = null;

       DisplayManagerService display = null;

       BatteryService battery = null;

       VibratorService vibrator = null;

        AlarmManagerService alarm = null;

        MountService mountService = null;

        NetworkManagementService networkManagement = null;

        NetworkStatsService networkStats = null;

        NetworkPolicyManagerService networkPolicy = null;

        ConnectivityService connectivity = null;

        WifiP2pService wifiP2p = null;

        WifiService wifi = null;

        NsdService serviceDiscovery= null;

//创建服务 通过ServiceManager管理 以key-value的形式添加到ServiceManger中

//所以 getSystemService(传入一个字符串) 返回服务 

            Slog.i(TAG, "Power Manager");

            power = new PowerManagerService();

            ServiceManager.addService(Context.POWER_SERVICE, power);

            Slog.i(TAG, "Activity Manager");

            context = ActivityManagerService.main(factoryTest);

            Slog.i(TAG, "Display Manager");

            display = new DisplayManagerService(context, wmHandler, uiHandler);

            ServiceManager.addService(Context.DISPLAY_SERVICE, display, true);

            Slog.i(TAG, "Telephony Registry");

            telephonyRegistry = new TelephonyRegistry(context);

            ServiceManager.addService("telephony.registry", telephonyRegistry);

            Slog.i(TAG, "Scheduling Policy");

            ServiceManager.addService(Context.SCHEDULING_POLICY_SERVICE,

                    new SchedulingPolicyService());

当所有的服务都添加进去之后 会执行ActivityManagerService的systemready方法

mMainStack.resumeTopActivityLocked(null);//判断当前的主任务栈是否有activity 如果没有就启动桌面

final boolean resumeTopActivityLocked(ActivityRecord prev, Bundle options) {

       // Find the first activity that is not finishing.

       ActivityRecord next = topRunningActivityLocked(null);

       // Remember how we'll process this pause/resume situation, and ensure

       // that the state is reset however we wind up proceeding.

        final boolean userLeaving = mUserLeaving;

        mUserLeaving = false;

        if (next == null) {

            // There are no more activities!  Let's just start up the

            // Launcher...

            if (mMainStack) {

                ActivityOptions.abort(options);

                return mService.startHomeActivityLocked(mCurrentUser);

            }

        }