Android系统启动过程

int main(){
　　　　 ……
       for(;;){

              execute_one_command();

              restart_processes();

              for (i = 0; i < fd_count; i++) {

            if (ufds[i].revents == POLLIN) {

                if (ufds[i].fd == get_property_set_fd())

                    handle_property_set_fd();

                else if (ufds[i].fd == get_keychord_fd())

                    handle_keychord();

                else if (ufds[i].fd == get_signal_fd())

                    handle_signal();
            }
        }

       }
}

service servicemanager /system/bin/servicemanager
　　class core
　　user system
　　group system
　　critical
　　onrestart restart zygote
　　onrestart restart media
　　onrestart restart surfaceflinger
　　onrestart restart drm

service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server
　　class main
　　socket zygote stream 666
　　onrestart write /sys/android_power/request_state wake
　　onrestart write /sys/power/state on
　　onrestart restart media
　　onrestart restart netd

参数：--zygote --start-system-server

int main( ){
       AppRuntime runtime;
       if (zygote) {
              runtime.start("com.android.internal.os.ZygoteInit",
                startSystemServer ? "start-system-server" : "");
       }
}

class AppRuntime : public AndroidRuntime{}；

void start(const char* className, const char* options){

       // start the virtual machine Java在虚拟机中运行的
       JNIEnv* env;
       if (startVm(&mJavaVM, &env) != 0) {
              return;
       }

       //向刚刚新建的虚拟机注册JNI本地接口
       if (startReg(env) < 0) {
              return;
       }

　　　　// jni 调用 java 方法，获取对应类的静态main方法
　　　　jmethodID startMeth = env->GetStaticMethodID(startClass,
       　　"main","([Ljava/lang/String;)V");

       // jni调用 java方法，调用到ZygoteInit类的main函数

       jclass startClass = env->FindClass(className);

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

public static void main(String argv[]) {
       //Registers a server socket for zygote command connections
       registerZygoteSocket();

       //Loads and initializes commonly used classes and
       //used resources that can be shared across processes
       preload();

       // Do an initial gc to clean up after startup
       gc();

       if (argv[1].equals("start-system-server")) {
              startSystemServer();
       }
/**
       * Runs the zygote process's select loop. Accepts new connections as
       * they happen, and reads commands from connections one spawn-request's
       * worth at a time.
       */

       runSelectLoopMode();    //loop中
       /**
       * Close and clean up zygote sockets. Called on shutdown and on the
       * child's exit path.
       */
       closeServerSocket();
}

private static boolean startSystemServer(){
       /* Request to fork the system server process 孵化新的进程 */
　　　　ZygoteConnection.Arguments parsedArgs = null;
       pid = Zygote.forkSystemServer(
              parsedArgs.uid, parsedArgs.gid,
              parsedArgs.gids,
              parsedArgs.debugFlags,
              null,
              parsedArgs.permittedCapabilities,
              parsedArgs.effectiveCapabilities);
 
              /* For child process 对新的子进程设置 */
       if (pid == 0) {
              handleSystemServerProcess(parsedArgs);
       }
}

void handleSystemServerProcess(parsedArgs){
       closeServerSocket();
       //"system_server"
       Process.setArgV0(parsedArgs.niceName);

       //Pass the remaining arguments to SystemServer.
　　　　RuntimeInit.zygoteInit(parsedArgs.targetSdkVersion,
　　　　　　parsedArgs.remainingArgs);
       /* should never reach here */
}

//The main function called when started through the zygote process.
void zygoteInit(int targetSdkVersion, String[] argv){
        applicationInit(targetSdkVersion, argv);
}

void applicationInit(int targetSdkVersion, String[] argv){
    // Remaining arguments are passed to the start class's static main
    invokeStaticMain(args.startClass, args.startArgs);
}
void invokeStaticMain(String className, String[] argv){
    Class<?> cl;
    cl = Class.forName(className);
 
    //获取SystemServer的main方法，抛出MethodAndArgsCaller异常
    Method m;
    m = cl.getMethod("main", new Class[] { String[].class });
    int modifiers = m.getModifiers();
    throw new ZygoteInit.MethodAndArgsCaller(m, argv);
}

public static void main(String argv[]) {
       try {
              ……
              if (argv[1].equals("start-system-server")) {
                  startSystemServer();       //这里如果抛出异常，跳过下面流程
              }
          
　　　　　　　　runSelectLoopMode();    //loop中
              ……


       } catch (MethodAndArgsCaller caller) {
              caller.run();        //处理的异常
       }
}

public static void main(String[] args) {

       　　System.loadLibrary("android_servers");    

       　　/*

       　　* This method is called from Zygote to initialize the system.
       　　* This will cause the native services (SurfaceFlinger, AudioFlinger, etc..)
       　　* to be started. After that it will call back
       　　* up into init2() to start the Android services.
      　　 */
      　　 init1(args);    //native 完了回调init2( )
　　}

//init1:
　　frameworks/base/services/jni/com_android_server_SystemServer.cpp:: android_server_SystemServer_init1( ) 
　　中调用：system_init
extern "C" status_t system_init()
{
       sp<ProcessState> proc(ProcessState::self());
       sp<IServiceManager> sm = defaultServiceManager();

       //启动SurfaceFlinger 和传感器
       property_get("system_init.startsurfaceflinger", propBuf, "1");
       SurfaceFlinger::instantiate();

       property_get("system_init.startsensorservice", propBuf, "1");
       SensorService::instantiate();

       // And now start the Android runtime.  We have to do this bit
       // of nastiness because the Android runtime initialization requires
       // some of the core system services to already be started.
　　　　// All other servers should just start the Android runtime at
       // the beginning of their processes's main(), before calling
       // the init function.
       AndroidRuntime* runtime = AndroidRuntime::getRuntime();


       //回调 com.android.server.SystemServer init2 方法      

       JNIEnv* env = runtime->getJNIEnv();

       jclass clazz = env->FindClass("com/android/server/SystemServer");

       jmethodID methodId = env->GetStaticMethodID(clazz, "init2", "()V");

       env->CallStaticVoidMethod(clazz, methodId);
    

       //启动线程池 做为binder 服务
       ProcessState::self()->startThreadPool();
       IPCThreadState::self()->joinThreadPool();
       return NO_ERROR;

}

public static final void init2() {   
　　　　//建立线程来处理
       Thread thr = new ServerThread();      
       thr.setName("android.server.ServerThread");
       thr.start();
}

//看看线程ServerThread里面都做了什么事情？
public void run() {
    addBootEvent(new String("Android:SysServerInit_START"));
    Looper.prepare();
    android.os.Process.setThreadPriority(
    android.os.Process.THREAD_PRIORITY_FOREGROUND);

    //初始化服务，创建各种服务实例，如：电源、网络、Wifi、蓝牙，USB等，
　　//初始化完成以后加入到 ServiceManager中，
    //事我们用 Context.getSystemService (String name) 才获取到相应的服务
    PowerManagerService power = null;
    NetworkManagementService networkManagement = null;
    WifiP2pService wifiP2p = null;
    WindowManagerService wm = null;
    BluetoothService bluetooth = null;
    UsbService usb = null;
    NotificationManagerService notification = null;
    StatusBarManagerService statusBar = null;
    ……

    power = new PowerManagerService();
    ServiceManager.addService(Context.POWER_SERVICE, power);
    ……

    // ActivityManagerService作为ApplicationFramework最重要的服务
    ActivityManagerService.setSystemProcess();
    ActivityManagerService.installSystemProviders();
    ActivityManagerService.self().setWindowManager(wm);   
　　// We now tell the activity manager it is okay to run third party
　　// code.  It will call back into us once it has gotten to the state
　　// where third party code can really run (but before it has actually
　　// started launching the initial applications), for us to complete our
　　// initialization.
　　//系统服务初始化准备就绪，通知各个模块
    ActivityManagerService.self().systemReady(new Runnable() {

           public void run() {
                  startSystemUi(contextF);
                  batteryF.systemReady();
                  networkManagementF.systemReady();
                  usbF.systemReady();
                  ……

                  // It is now okay to let the various system services start their
                  // third party code...
                  appWidgetF.systemReady(safeMode);
                  wallpaperF.systemReady();
           }
    });

    //
    //BOOTPROF
    addBootEvent(new String("Android:SysServerInit_END"));
    Looper.loop();
}

public void systemReady(final Runnable goingCallback) {
　　　　……
　　　　//ready callback
       if (goingCallback != null)
              goingCallback.run();
synchronized (this) {
              // Start up initial activity.
              // ActivityStack mMainStack;
              mMainStack.resumeTopActivityLocked(null);
       }
……

}

final boolean resumeTopActivityLocked(ActivityRecord prev) {
　　// Find the first activity that is not finishing.
　　ActivityRecord next = topRunningActivityLocked(null);
　　if (next == null) {
　　　　// There are no more activities!  Let's just start up the
　　　　// Launcher...
　　　　if (mMainStack) {
　　　　　　//ActivityManagerService mService;
　　　　　　return mService.startHomeActivityLocked();
　　　　}
　　}
　　……
}