Android系統程式Zygote啟動過程的原始碼分析（3）

 Step 5. ZygoteInit.startSystemServer
       這個函式定義在frameworks/base/core/java/com/android/internal/os/ZygoteInit.java檔案中：

1. public class ZygoteInit {   
2.     ......   
3.    
4.     private static boolean startSystemServer()   
5.             throws MethodAndArgsCaller, RuntimeException {   
6.         /* Hardcoded command line to start the system server */   
7.         String args[] = {   
8.             "--setuid=1000",   
9.             "--setgid=1000",   
10.             "--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,3001,3002,3003",   
11.             "--capabilities=130104352,130104352",   
12.             "--runtime-init",   
13.             "--nice-name=system_server",   
14.             "com.android.server.SystemServer",   
15.         };   
16.         ZygoteConnection.Arguments parsedArgs = null;   
17.    
18.         int pid;   
19.    
20.         try {   
21.             parsedArgs = new ZygoteConnection.Arguments(args);   
22.    
23.             ......   
24.    
25.             /* Request to fork the system server process */   
26.             pid = Zygote.forkSystemServer(   
27.                 parsedArgs.uid, parsedArgs.gid,   
28.                 parsedArgs.gids, debugFlags, null,   
29.                 parsedArgs.permittedCapabilities,   
30.                 parsedArgs.effectiveCapabilities);   
31.         } catch (IllegalArgumentException ex) {   
32.             ......   
33.         }   
34.    
35.         /* For child process */   
36.         if (pid == 0) {   
37.             handleSystemServerProcess(parsedArgs);   
38.         }   
39.    
40.         return true;   
41.     }   
42.        
43.     ......   
44. }   

   這裡我們可以看到，Zygote程式通過Zygote.forkSystemServer函式來建立一個新的程式來啟動SystemServer元件，返回值pid等0的地方就是新的程式要執行的路徑，即新建立的程式會執行handleSystemServerProcess函式。

 

        Step 6. ZygoteInit.handleSystemServerProcess
  這個函式定義在frameworks/base/core/java/com/android/internal/os/ZygoteInit.java檔案中：

1. 這裡我們可以看到，Zygote程式通過Zygote.forkSystemServer函式來建立一個新的程式來啟動SystemServer元件，返回值pid等0的地方就是新的程式要執行的路徑，即新建立的程式會執行handleSystemServerProcess函式。 
2. Step 6. ZygoteInit.handleSystemServerProcess 
3. 這個函式定義在frameworks/base/core/java/com/android/internal/os/ZygoteInit.java檔案中： 

 由於由Zygote程式建立的子程式會繼承Zygote程式在前面Step 4中建立的Socket檔案描述符，而這裡的子程式又不會用到它，因此，這裡就呼叫closeServerSocket函式來關閉它。這個函式接著呼叫RuntimeInit.zygoteInit函式來進一步執行啟動SystemServer元件的操作。

 

        Step 7. RuntimeInit.zygoteInit
 這個函式定義在frameworks/base/core/java/com/android/internal/os/RuntimeInit.java檔案中：

1. public class RuntimeInit {     
2.     ......     
3.    
4.     public static final void zygoteInit(String[] argv)     
5.             throws ZygoteInit.MethodAndArgsCaller {     
6.         ......     
7.      
8.         zygoteInitNative();     
9.    
10.         ......     
11.    
12.    
13.         // Remaining arguments are passed to the start class's static main     
14.    
15.         String startClass = argv[curArg++];     
16.         String[] startArgs = new String[argv.length - curArg];     
17.    
18.         System.arraycopy(argv, curArg, startArgs, 0, startArgs.length);     
19.         invokeStaticMain(startClass, startArgs);     
20.     }     
21.    
22.     ......     
23. }   

 

 這個函式會執行兩個操作，一個是呼叫zygoteInitNative函式來執行一個Binder程式間通訊機制的初始化工作，這個工作完成之後，這個程式中的Binder物件就可以方便地進行程式間通訊了，另一個是呼叫上面Step 5傳進來的com.android.server.SystemServer類的main函式。

 

         Step 8. RuntimeInit.zygoteInitNative
這個函式定義在frameworks/base/core/java/com/android/internal/os/RuntimeInit.java檔案中：

1. public class RuntimeInit {    
2.     ......    
3.   
4.     public static final native void zygoteInitNative();    
5.   
6.     ......    
7. }  

 

這裡可以看出，函式zygoteInitNative是一個Native函式，實現在frameworks/base/core/jni/AndroidRuntime.cpp檔案中，這裡我們就不再細看了，具體可以參考Android應用程式程式啟動過程的原始碼分析一文的Step 9，完成這一步後，這個程式的Binder程式間通訊機制基礎設施就準備好了。

 

        回到Step 7中的RuntimeInit.zygoteInitNative函式，下一步它就要執行com.android.server.SystemServer類的main函式了。

        Step 9. SystemServer.main
 這個函式定義在frameworks/base/services/java/com/android/server/SystemServer.java檔案中：

1. public class SystemServer     
2. {     
3.     ......     
4.    
5.     native public static void init1(String[] args);     
6.    
7.     ......     
8.    
9.     public static void main(String[] args) {     
10.         ......     
11.    
12.         init1(args);     
13.    
14.         ......     
15.     }    
16.    
17.     public static final void init2() {     
18.         Slog.i(TAG, "Entered the Android system server!");     
19.         Thread thr = new ServerThread();     
20.         thr.setName("android.server.ServerThread");     
21.         thr.start();     
22.     }     
23.    
24.     ......     
25. }   

 這裡的main函式首先會執行JNI方法init1，然後init1會呼叫這裡的init2函式，在init2函式裡面，會建立一個ServerThread執行緒物件來執行一些系統關鍵服務的啟動操作，例如我們在前面兩篇文章Android應用程式安裝過程原始碼分析和Android系統預設Home應用程式（Launcher）的啟動過程原始碼分析中提到的PackageManagerService和ActivityManagerService。
        這一步的具體執行過程可以參考Android應用程式安裝過程原始碼分析一文，這裡就不再詳述了。

 

        這裡執行完成後，層層返回，最後回到上面的Step 3中的ZygoteInit.main函式中，接下來它就要呼叫runSelectLoopMode函式進入一個無限迴圈在前面Step 4中建立的socket介面上等待ActivityManagerService請求建立新的應用程式程式了。

        Step 10. ZygoteInit.runSelectLoopMode
 這個函式定義在frameworks/base/core/java/com/android/internal/os/ZygoteInit.java檔案中：

1. public class ZygoteInit {   
2.     ......   
3.    
4.     private static void runSelectLoopMode() throws MethodAndArgsCaller {   
5.         ArrayList<FileDescriptor> fds = new ArrayList();   
6.         ArrayList<ZygoteConnection> peers = new ArrayList();   
7.         FileDescriptor[] fdArray = new FileDescriptor[4];   
8.    
9.         fds.add(sServerSocket.getFileDescriptor());   
10.         peers.add(null);   
11.    
12.         int loopCount = GC_LOOP_COUNT;   
13.         while (true) {   
14.             int index;   
15.    
16.             ......   
17.    
18.    
19.             try {   
20.                 fdArray = fds.toArray(fdArray);   
21.                 index = selectReadable(fdArray);   
22.             } catch (IOException ex) {   
23.                 throw new RuntimeException("Error in select()", ex);   
24.             }   
25.    
26.             if (index < 0) {   
27.                 throw new RuntimeException("Error in select()");   
28.             } else if (index == 0) {   
29.                 ZygoteConnection newPeer = acceptCommandPeer();   
30.                 peers.add(newPeer);   
31.                 fds.add(newPeer.getFileDesciptor());   
32.             } else {   
33.                 boolean done;   
34.                 done = peers.get(index).runOnce();   
35.    
36.                 if (done) {   
37.                     peers.remove(index);   
38.                     fds.remove(index);   
39.                 }   
40.             }   
41.         }   
42.     }   
43.    
44.     ......   
45. }         

這個函式我們已經在Android應用程式程式啟動過程的原始碼分析一文的Step 5中分析過了，這就是在等待ActivityManagerService來連線這個Socket，然後呼叫ZygoteConnection.runOnce函式來建立新的應用程式，有興趣的讀者可以參考Android應用程式程式啟動過程的原始碼分析這篇文章，這裡就不再詳述了。

        這樣，Zygote程式就啟動完成了，學習到這裡，我們終於都對Android系統中的程式有了一個深刻的認識了，這裡總結一下：

        1. 系統啟動時init程式會建立Zygote程式，Zygote程式負責後續Android應用程式框架層的其它程式的建立和啟動工作。

        2. Zygote程式會首先建立一個SystemServer程式，SystemServer程式負責啟動系統的關鍵服務，如包管理服務PackageManagerService和應用程式元件管理服務ActivityManagerService。

        3. 當我們需要啟動一個Android應用程式時，ActivityManagerService會通過Socket程式間通訊機制，通知Zygote程式為這個應用程式建立一個新的程式。