android TV海思方案系统启动流程

android TV海思方案系统启动流程

1，Linux内核启动init进程；
2，init进程启动android系统SystemServer进程；
（1）在system/core/init/init.c文件中，main函数中init_parse_config_file(“/init.rc”)解析init.rc（init.rc文件为device/hisilicon/bigfish/etc/init.defau.rc:root/init.rc编译而来）文件；

init_parse_config_file("/init.rc");

（2）init.rc文件中描述了要启动进程的，最为重要的进程为zygote：

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

（3）zygote进程启动过程实在app_main.cpp，由上面过程传入两个参数，“–zygote”,”–start-system-server”,首先在mian启动ZygoteInit的类，

/*解析argc参数*/
while (i < argc) {
        const char* arg = argv[i++];
        if (!parentDir) {
            parentDir = arg;
        } else if (strcmp(arg, "--zygote") == 0) {
            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);
    }

    runtime.mParentDir = parentDir;

    /*启动ZygoteInit类*/
    if (zygote) {
        runtime.start("com.android.internal.os.ZygoteInit",
                startSystemServer ? "start-system-server" : "");
    } else if (className) {
        // Remainder of args get passed to startup class main()
        runtime.mClassName = className;
        runtime.mArgC = argc - i;
        runtime.mArgV = argv + i;
        runtime.start("com.android.internal.os.RuntimeInit",
                application ? "application" : "tool");
    } else {
        fprintf(stderr, "Error: no class name or --zygote supplied.\n");
        app_usage();
        LOG_ALWAYS_FATAL("app_process: no class name or --zygote supplied.");
        return 10;
    }

在ZygoteInit.java文件main中，有如下代码

if (argv[1].equals("start-system-server")) {
                /*在这里启动了android系统重要的进程system_server*/
                startSystemServer();
            } else if (!argv[1].equals("")) {
                throw new RuntimeException(argv[0] + USAGE_STRING);
            }

再看看startSystemServer()方法启动system_server进程，

try {
            parsedArgs = new  ZygoteConnection.Arguments(args);
            ZygoteConnection.applyDebuggerSystemProperty(parsedArgs);
            ZygoteConnection.applyInvokeWithSystemProperty(parsedArgs);

            /* Request to fork the system server process */
            /*在这真正的启动system_server进程*/
            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) {
            /*启动SystemServer类*/
            handleSystemServerProcess(parsedArgs);
        }

在handleSystemServerProcess()方法中启动SystemServer类，并开始启动一系列的服务；

        closeServerSocket();

        // set umask to 0077 so new files and directories will default to owner-only permissions.
        Libcore.os.umask(S_IRWXG | S_IRWXO);

        if (parsedArgs.niceName != null) {
        /*设置进程名字为system_server*/
            Process.setArgV0(parsedArgs.niceName);
        }

        if (parsedArgs.invokeWith != null) {
            WrapperInit.execApplication(parsedArgs.invokeWith,
                    parsedArgs.niceName, parsedArgs.targetSdkVersion,
                    null, parsedArgs.remainingArgs);
        } else {
            /*
             * Pass the remaining arguments to SystemServer.
             */
            /*初始化zygoteInit*/
            RuntimeInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs);
        }

在zygoteInit()方法中实现了zygote的一些初始化

public static final void zygoteInit(int targetSdkVersion, String[] argv)
            throws ZygoteInit.MethodAndArgsCaller {
        if (DEBUG) Slog.d(TAG, "RuntimeInit: Starting application from zygote");

        redirectLogStreams();
        /*常规初始化*/
        commonInit();

        /*native层初始化*/
        nativeZygoteInit();

        /*java层的初始化*/
        applicationInit(targetSdkVersion, argv);
    }

applicationInit()方法初始化过程其实是保存m, argc变量，并且抛出一个异常；

try {
            cl = Class.forName(className);
        } catch (ClassNotFoundException ex) {
            throw new RuntimeException(
                    "Missing class when invoking static main " + className,
                    ex);
        }

        Method m;
        try {
            m = cl.getMethod("main", new Class[] { String[].class });
        } catch (NoSuchMethodException ex) {
            throw new RuntimeException(
                    "Missing static main on " + className, ex);
        } catch (SecurityException ex) {
            throw new RuntimeException(
                    "Problem getting static main on " + className, ex);
        }
        int modifiers = m.getModifiers();
        if (! (Modifier.isStatic(modifiers) && Modifier.isPublic(modifiers))) {
            throw new RuntimeException(
                    "Main method is not public and static on " + className);
        }

        /*
         * This throw gets caught in ZygoteInit.main(), which responds
         * by invoking the exception's run() method. This arrangement
         * clears up all the stack frames that were required in setting
         * up the process.
         */
         /*抛了一个异常，实在通过catch方法传递m,argv参数*/
        throw new ZygoteInit.MethodAndArgsCaller(m, argv);

在ZegoteInit类的main方法中catch了MethodAndArgsCaller异常

catch (MethodAndArgsCaller caller) {
        /*运行MethodAndArgsCaller 的run方法*/
            caller.run();
        } catch (RuntimeException ex) {
            Log.e(TAG, "Zygote died with exception", ex);
            closeServerSocket();
            throw ex;
        }

在MethodAndArgsCaller 的run方法中运用java的反射机制最终，程序运行到com.android.server.SystemServer类；

        public void run() {
            try {
                mMethod.invoke(null, new Object[] { mArgs });
            } catch (IllegalAccessException ex) {
                throw new RuntimeException(ex);
            } catch (InvocationTargetException ex) {
                Throwable cause = ex.getCause();
                if (cause instanceof RuntimeException) {
                    throw (RuntimeException) cause;
                } else if (cause instanceof Error) {
                    throw (Error) cause;
                }
                throw new RuntimeException(ex);
            }
        }

（4）进入SystemServer中开始初始化android系统的重要service

ServerThread thr = new ServerThread();
        /*初始化一系列的service*/
        thr.initAndLoop();