问Android应用启动流程

EN

(entry point of app_process)int main
    ->void AndroidRuntime::start
        startVm    //start Java VM
        startReg    //register common native functions
        //call java method ZygoteInit.main from native code
        env->CallStaticVoidMethod  

//Java code
->ZygoteInit.main  
    //Android application never get here(the beginning)
    //start system server process which contains AMS/WMS,etc
    forkSystemServer  

    //for Zygote, runSelectLoop never return
    //for Android application, runSelectLoop returns a Runnable 
    //whose run() method will just execute ActivityThread.main 
    //which is considered as the real main entry of Android application
    //since it contains the message loop
    caller = zygoteServer.runSelectLoop
    ->zygoteServer.runSelectLoop
        //this is the main loop of Zygote who is a 
        //server that receive process-creating requests
        //from client processes and fork them
        loop forever

            //Zygote wait here for other process's requests to start new Java process
            Os.poll(pollFds, -1);

            //after wake up upon requests arrive, process the request
            final Runnable command = connection.processOneCommand(this);
            ->ZygoteConnection.processOneCommand
                 read and parse process-start request command from client process

                 //the native linux fork() is executed in this methdod
                 //after it returns, we can decide which process we are in 
                 //from pid's value just like the native fork()
                 pid = Zygote.forkAndSpecialize

                 //if in child                        
                 return handleChildProc
                 ->ZygoteConnection.handleChildProc
                     return ZygoteInit.zygoteInit
                     ->ZygoteInit.zygoteInit
                         RuntimeInit.commonInit();
                         ZygoteInit.nativeZygoteInit();//JNI method
                             //native code
                             ->AppRuntime::onZygoteInit()
                                 sp<ProcessState> proc = ProcessState::self();
                                 //starting thread pool which contains binder threads
                                 proc->startThreadPool();
                         return RuntimeInit.applicationInit
                         ->RuntimeInit.applicationInit
                             return findStaticMain
                             ->RuntimeInit.findStaticMain
                                 //MethodAndArgsCaller is a Runnable, 
                                 //whose run() is constructed so that 
                                 //it just call ActivityThread.main()
                                 //it is ActivityThread since there is a string parameter 
                                 //whose content is "android.app.ActivityThread" from the client process's request
                                 return new MethodAndArgsCaller
                 //if in parent process i.e. Zygote
                 return null

            //if in forked child process
            return command;
            //if in parent process i.e. Zygote
            continue to run the loop

    //Zygote never get here
    //for Android application, now caller contains a MethodAndArgsCaller which is a Runnable
    //whose run() calls ActivityThread.main and never return
    //since ActivityThread.main runs the main message loop        
    caller.run();

//in AMS (system server process)
final String entryPoint = "android.app.ActivityThread";
return startProcessLocked(....,entryPoint, ....);
->startProcessLocked        
    ->Process.start
        ->ZygoteProcess.start
            ->ZygoteProcess.startViaZygote
                ->ZygoteProcess.zygoteSendArgsAndGetResult
                    //send the request to Zygote server through sockets
                    //note that "android.app.ActivityThread" is send to Zygote server as a parameter

Os.poll(pollFds, -1);

caller = zygoteServer.runSelectLoop