主要流程
init進程啓動過程
init進程是Android系統中用戶空間的第一個進程。進程號爲1。
第一步：啓動電源
當電源按下，引導芯片代碼開始從預定義的地方（固化在ROM）開始執行。加載引導程序到RAM，然後執行。
第二步：執行引導程序（Boot Loader）
通常在運行Android系統之前會先執行Boot Loader引導程序，它不屬於Android系統，常見的引導程序有：redboot、uboot、qi bootloader等等。或者自行開發引導程序，它是針對特定主板和芯片的，OEM製造廠商或者運營商在加鎖的時候就對這個引導程序做修改，比如魅族就是修改了引導程序，所以刷不了機。
第三步：內核
當內核完成系統設置後，在系統文件中尋找init.rc文件，並啓動init進程
第四步：執行init進程
system/core/init/init.cpp
int main(int argc, char** argv) {
......
if (is_first_stage) {
boot_clock::time_point start_time = boot_clock::now();
umask(0);
//創建和掛載啓動所需要的文件目錄
mount("tmpfs", "/dev", "tmpfs", MS_NOSUID, "mode=0755");
mkdir("/dev/pts", 0755);
mkdir("/dev/socket", 0755);
mount("devpts", "/dev/pts", "devpts", 0, NULL);
#define MAKE_STR(x) __STRING(x)
mount("proc", "/proc", "proc", 0, "hidepid=2,gid=" MAKE_STR(AID_READPROC));
chmod("/proc/cmdline", 0440);
gid_t groups[] = { AID_READPROC };
setgroups(arraysize(groups), groups);
mount("sysfs", "/sys", "sysfs", 0, NULL);
mount("selinuxfs", "/sys/fs/selinux", "selinuxfs", 0, NULL);
mknod("/dev/kmsg", S_IFCHR | 0600, makedev(1, 11));
mknod("/dev/random", S_IFCHR | 0666, makedev(1, 8));
mknod("/dev/urandom", S_IFCHR | 0666, makedev(1, 9));
......
}
......
//對屬性服務進行初始化
property_init();
......
epoll_fd = epoll_create1(EPOLL_CLOEXEC);
if (epoll_fd == -1) {
PLOG(ERROR) << "epoll_create1 failed";
exit(1);
}
//用於設置子進程信號處理函數，如果子進程異常退出，init進程會調用該函
//數中設置的信號處理函數進行處理。
signal_handler_init();
......
//啓動屬性服務
start_property_service();
......
if (bootscript.empty()) {
//解析init.rc配置文件
parser.ParseConfig("/init.rc");
parser.set_is_system_etc_init_loaded(
parser.ParseConfig("/system/etc/init"));
parser.set_is_vendor_etc_init_loaded(
parser.ParseConfig("/vendor/etc/init"));
parser.set_is_odm_etc_init_loaded(parser.ParseConfig("/odm/etc/init"));
}
......
while (true) {
......
if (!(waiting_for_prop || ServiceManager::GetInstance().IsWaitingForExec())) {
am.ExecuteOneCommand();
}
if (!(waiting_for_prop || ServiceManager::GetInstance().IsWaitingForExec())) {
//重啓死去的服務
restart_processes();
}
......
}
return 0;}
從上述代碼中可以看出，init進程主要做了三件事：
-
從上述代碼中可以看出，init進程主要做了三件事：
啓動掛載了tmpfs、devpts、proc、sysfs和selinuxfs共5種文件系統，這些是系統運行時目錄，也就是說只有在系統運行的時候纔會存在。 -
初始化和啓動屬性服務。
屬性服務類似Windows平臺上的註冊表管理器，註冊表中以key-value的形式來記錄用戶、軟件的一些使用信息。即使系統或軟件重啓，也能夠根據之前註冊表中的記錄，進行相應的初始化工作。 -
解析init.rc文件，創建Zygote進程
該文件的路徑爲：system/core/rootdir/init.rc。它是一個非常重要的配置文件，是由Android初始化語言編寫的腳本。Android8.0對該文件進行來拆分，每個服務對應一個rc文件，啓動Zygote的腳本在init.zygoteXX.rc中定義，代表多少位處理器。這裏以64位爲例。
system/core/rootdir/init.zygote64.rc
service zygote /system/bin/app_process64 -Xzygote /system/bin --zygote --start-system-server
class main
priority -20
user root
group root readproc
socket zygote stream 660 root system
onrestart write /sys/android_power/request_state wake
onrestart write /sys/power/state on
onrestart restart audioserver
onrestart restart cameraserver
onrestart restart media
onrestart restart netd
onrestart restart wificond
writepid /dev/cpuset/foreground/tasks
這裏我們只分析zygote進程的創建，所以只貼出了init.rc文件中的Serivice類型的語句，省略了其他語句；這是由Android初始化語言編寫的。它的格式如下：
service [ ]* //名字 執行程序路徑 傳遞參數
< option > //修飾詞，影響什麼時候啓動，如何啓動service。
< option >
…
上面的代碼的含義就是：通知init進程創建名爲zygote的進程，這個進程的執行路徑爲：/system/bin/app/_process64，其後面的代碼是傳遞給app_process64的參數。class main指的是zygote的classname爲main。
init.rc中的Service類型的語句有相應的類來進行解析，Service語句採用ServiceParser來進行解析，該實現代碼在system/core/init/service.app中，代碼在這不再貼出，大概的解析過程就是：根據參數創建出Service對象，然後根據選項域中的內容填充Service對象，最後將該對象加入vector類型的Service鏈表中。(就是把上面傳參要啓動服務存在Vector鏈表中)
繼續看 在init.rc中有如下代碼：
......
on nonencrypted
class_start main
class_start late_start
......
class_start是Android初始化語言中的Command類型的語句，對應的函數爲do_class_start，含義就是啓動classname爲main的Service。，從上述代碼我們知道zygote的classname爲main。
do_class_start函數是在system/core/bin/builtins.cpp中，代碼如下：
static int do_class_start(const std::vector<std::string>& args) {
ServiceManager::GetInstance().
ForEachServiceInClass(args[1], [] (Service* s) { s->StartIfNotDisabled(); });
return 0;}
ForEachServiceInClass函數會遍歷Service鏈表，找到classname爲main的Zygote，並執行**StartIfNotDisabled ()**函數。
StartIfNotDisabled ()函數的代碼是在system/core/init/service.cpp中定義的，代碼如下：
bool Service::StartIfNotDisabled() {
if (!(flags_ & SVC_DISABLED)) {
return Start();
} else {
flags_ |= SVC_DISABLED_START;
}
return true;}
如果Service沒有在其對應的rc文件中設置disabled選項，就會執行Start()函數，Zygote對應的文件沒有設置disabled選項。
Start() 函數：system/core/init/service.cpp
bool Service::Start() {
flags_ &= (~(SVC_DISABLED|SVC_RESTARTING|SVC_RESET|SVC_RESTART|SVC_DISABLED_START));
//如果已運行，直接返回
if (flags_ & SVC_RUNNING) {
return false;
}
......
struct stat sb;
//判斷需要啓動的Service對應的執行文件是否存在，存在纔會執行。
if (stat(args_[0].c_str(), &sb) == -1) {
PLOG(ERROR) << "cannot find '" << args_[0] << "', disabling '" << name_ << "'";
flags_ |= SVC_DISABLED;
return false;
}
......
pid_t pid = -1;
if (namespace_flags_) {
pid = clone(nullptr, nullptr, namespace_flags_ | SIGCHLD, nullptr);
} else {
//如果沒有啓動，調用fork函數創建子進程
pid = fork();
}
if (pid == 0) {
umask(077);
......
//調用execve函數，子進程就會被啓動
if (execve(strs[0], (char**) &strs[0], (char**) ENV) < 0) {
PLOG(ERROR) << "cannot execve('" << strs[0] << "')";
}
_exit(127);
}
......
return true;}
調用execve 函數，子進程就會被啓動，就是執行對應的main函數，Zygote的執行路徑爲：system/bin/app_process64，對應的文件爲app_main.cpp。
frameworks/base/cmds/app_process/app_main.cpp：
int main(int argc, char* const argv[]){
......
while (i < argc) {
const char* arg = argv[i++];
if (strcmp(arg, "--zygote") == 0) {
zygote = true;
niceName = ZYGOTE_NICE_NAME;
} 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.setTo(arg + 12);
} else if (strncmp(arg, "--", 2) != 0) {
className.setTo(arg);
break;
} else {
--i;
break;
}
}
......
if (zygote) {
runtime.start("com.android.internal.os.ZygoteInit", args, zygote);
} else if (className) {
runtime.start("com.android.internal.os.RuntimeInit", args, zygote);
} else {
fprintf(stderr, "Error: no class name or --zygote supplied.\n");
app_usage();
LOG_ALWAYS_FATAL("app_process: no class name or --zygote supplied.");
}}
調用runtime.start函數就啓動了Zygote進程。
以上總結：
- 手機按下電源後，加載引導程序到內存中。
- 執行引導程序
- 啓動內核，設置緩存、被保護存儲器、計劃列表，加載驅動，查找/system/core/bin中init程序文件。
- 啓動init程序，掛載/sys /dev /proc等等目錄，加載和解析init.rc腳本。
- 在加載init.rc腳本的時候，啓動app_process進程。
- 在app_process進程中，根據init.zygote64.rc腳本配置的參數，啓動zygote進程
Zygote進程
在Android系統中，DVM和ART、應用程序進程以及運行系統的關鍵服務SystemServer進程都是有Zygote進程創建的，我們也稱它爲孵化器。它通過 fock（複製進程） 的形式來創建應用程序進程和SystemServer進程，由於Zygote進程在啓動的時候會創建DVM或者ART，因此通過fock而創建的應用程序進程和SystemServer進程可以在內部獲取一個DVM或者ART的實例副本（也就是說一個Android應用程序對應這一個DVM或者ART）。
Zygote進程都是通過fock自身來創建子進程的，這樣Zygote進程以及子進程都會進入app_main.cpp的main函數，所以在上述代碼中先區分來當前運行在哪個進程中。運行Zygote進程就會執行AndroidRuntime.start函數。
frameworks/base/core/jni/AndroidRuntime.cpp代碼如下：
void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote){
......
JniInvocation jni_invocation;
jni_invocation.Init(NULL);
JNIEnv* env;
//啓動Java虛擬機
if (startVm(&mJavaVM, &env, zygote) != 0) {
return;
}
onVmCreated(env);
//爲JVM註冊JNI方法
if (startReg(env) < 0) {
ALOGE("Unable to register all android natives\n");
return;
}
......
//從app_main傳過來的參數classname值爲：“com.android.internal.os.ZygoteInit”
classNameStr = env->NewStringUTF(className);
assert(classNameStr != NULL);
env->SetObjectArrayElement(strArray, 0, classNameStr);
for (size_t i = 0; i < options.size(); ++i) {
jstring optionsStr = env->NewStringUTF(options.itemAt(i).string());
assert(optionsStr != NULL);
env->SetObjectArrayElement(strArray, i + 1, optionsStr);
}
//將classname的“.”替換成“/”
char* slashClassName = toSlashClassName(className);
//找到ZygoteInit
jclass startClass = env->FindClass(slashClassName);
if (startClass == NULL) {
ALOGE("JavaVM unable to locate class '%s'\n", slashClassName);
} else {
//找到ZygoteInit的main函數
jmethodID startMeth = env->GetStaticMethodID(startClass, "main",
"([Ljava/lang/String;)V");
if (startMeth == NULL) {
ALOGE("JavaVM unable to find main() in '%s'\n", className);
} else {
//通過JNI調用ZygoteInit的main函數
env->CallStaticVoidMethod(startClass, startMeth, strArray);
#if 0
if (env->ExceptionCheck())
threadExitUncaughtException(env);#endif
}
}
......}
上述代碼最後會調用ZygoteInit的main方法，該方法是由Java語言編寫的，當前的運行邏輯在Native中，這就需要通過JNI來調用Java。這樣Zygote就從Native層近入了Java框架層。
/frameworks/base/core/java/com/android/internal/os/ZygoteInit.java的main方法代碼如下：
public static void main(String argv[]) {
......
try {
......
//創建一個Server端的socket，socketName = “zygote”
//在這個socket上會等待AMS的請求
zygoteServer.registerServerSocket(socketName);
if (!enableLazyPreload) {
bootTimingsTraceLog.traceBegin("ZygotePreload");
EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_START,
SystemClock.uptimeMillis());
//預加載類和資源
preload(bootTimingsTraceLog);
EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_END,
SystemClock.uptimeMillis());
bootTimingsTraceLog.traceEnd(); // ZygotePreload
} else {
Zygote.resetNicePriority();
}
//啓動SystemServer進程
if (startSystemServer) {
startSystemServer(abiList, socketName, zygoteServer);
}
//等待AMS請求，裏面是一個while(true)循環
zygoteServer.runSelectLoop(abiList);
zygoteServer.closeServerSocket();
}......}
該方法中主要做了4件事：
1.創建一個Server端的socket（LocalServerSocket）。
2.預加載類和資源。
3.啓動SystemServer進程。
4.等待AMS請求創建新的應用程序進程。
SystemServer進程
SystemServer進程主要用於創建系統服務，AMS、WMS、PMS都是由它來創建的。從上面得知通過調用ZygoteInit的startSystemServer 方法來啓動SystemServer進程，下面就看一下該方法的代碼：
private static boolean startSystemServer(String abiList, String socketName, ZygoteServer zygoteServer)
throws Zygote.MethodAndArgsCaller, RuntimeException {
......
//創建args數組，該數組用來保存啓動SystemServer的啓動參數
String args[] = {
"--setuid=1000",
"--setgid=1000",
"--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1021,1023,1032,3001,3002,3003,3006,3007,3009,3010",
"--capabilities=" + capabilities + "," + capabilities,
"--nice-name=system_server",
"--runtime-args",
"com.android.server.SystemServer",
};
ZygoteConnection.Arguments parsedArgs = null;
int pid;
try {
parsedArgs = new ZygoteConnection.Arguments(args);
ZygoteConnection.applyDebuggerSystemProperty(parsedArgs);
ZygoteConnection.applyInvokeWithSystemProperty(parsedArgs);
//創建一個子進程，也就是SystemServer進程
pid = Zygote.forkSystemServer(
parsedArgs.uid, parsedArgs.gid,
parsedArgs.gids,
parsedArgs.debugFlags,
null,
parsedArgs.permittedCapabilities,
parsedArgs.effectiveCapabilities);
} catch (IllegalArgumentException ex) {
throw new RuntimeException(ex);
}
//當前代碼運行在子進程中，也就是SystemServer進程
if (pid == 0) {
if (hasSecondZygote(abiList)) {
waitForSecondaryZygote(socketName);
}
//SystemServer進程複製了Zygote進程的地址空間，因此也會得到Zygote創建的Socket。
//該Socket對SystemServer進程沒有用，所以要關閉。
zygoteServer.closeServerSocket();
//處理SystemServer進程
handleSystemServerProcess(parsedArgs);
}
return true;}
從上面代碼可以看出，SystemServer進程的用戶id和用戶組id被設置爲1000，並且擁有1001～1010、1018、1021、1032、3001～3010的權限；進程名字爲system_server；啓動的類名爲：com.android.server.SystemServer。
創建出SystemServer進程之後就會在該進程調用ZygoteInit.handleSystemServerProcess 方法，下面看一下該方法的代碼：
private static void handleSystemServerProcess(
ZygoteConnection.Arguments parsedArgs)
throws Zygote.MethodAndArgsCaller {
......
if (parsedArgs.invokeWith != null) {
......
} else {
ClassLoader cl = null;
if (systemServerClasspath != null) {
//創建PathClassLoader
cl = createPathClassLoader(systemServerClasspath, parsedArgs.targetSdkVersion);
Thread.currentThread().setContextClassLoader(cl);
}
//調用zygoteInit方法
ZygoteInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, cl);
}}
public static final void zygoteInit(int targetSdkVersion, String[] argv,
ClassLoader classLoader) throws Zygote.MethodAndArgsCaller {
if (RuntimeInit.DEBUG) {
Slog.d(RuntimeInit.TAG, "RuntimeInit: Starting application from zygote");
}
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ZygoteInit");
RuntimeInit.redirectLogStreams();
RuntimeInit.commonInit();
//啓動Binder線程池
ZygoteInit.nativeZygoteInit();
//執行SystemServer的main方法
RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader);}
在zygoteInit方法中創建了Binder線程池，這樣SystemServer進程就可以使用Binder於其他進程進行通信了。
創建Binder線程池後會調用RuntimeInit.applicationInit方法，下面就接着看下該方法的代碼：
/frameworks/base/core/java/com/android/internal/os/RuntimeInit.java
protected static void applicationInit(int targetSdkVersion, String[] argv, ClassLoader classLoader)
throws Zygote.MethodAndArgsCaller {
......
// Remaining arguments are passed to the start class's static main
invokeStaticMain(args.startClass, args.startArgs, classLoader);}
private static void invokeStaticMain(String className, String[] argv, ClassLoader classLoader)
throws Zygote.MethodAndArgsCaller {
Class<?> cl;
try {
//通過反射得到SystemServer類
cl = Class.forName(className, true, classLoader);
}......
Method m;
try {
//找到SystemServer的main方法
m = cl.getMethod("main", new Class[] { String[].class });
}......
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.
*/
throw new Zygote.MethodAndArgsCaller(m, argv);}
通過反射得到SystemServer，className的值就是上面提到的com.android.server.SystemServer，然後再找到main方法，最後將main方法傳入Zygote .MethodAndArgsCaller異常中並拋出該異常。捕獲該異常的代碼在ZygoteInit.main方法中，該main方法會調用SystemServer的main方法。
那爲什麼不直接在invokeStaticMain方法中調用呢？而是在異常捕獲中調用？
原因是異常處理會清楚所有設置過程中需要的堆棧幀，讓SystemServer的main方法看起來像是SystemServer進程的入口。（在Zygote啓動SystemServer進程之後，SystemServer進程做了很多準備工作，這些工作都是在main方法調用之前做的。）
/frameworks/base/core/java/com/android/internal/os/ZygoteInit.java的main方法代碼
public static void main(String argv[]) {
......
try {
......
//捕獲MethodAndArgsCaller異常
} catch (Zygote.MethodAndArgsCaller caller) {
caller.run();
} catch (Throwable ex) {
Log.e(TAG, "System zygote died with exception", ex);
zygoteServer.closeServerSocket();
throw ex;
}}
此處的mMethod就是SystemServer的main方法。
這樣就進入了SystemServer的main方法：
/frameworks/base/services/java/com/android/server/SystemServer.java
public static void main(String[] args) {
new SystemServer().run();}
private void run() {
try {
......
//創建Looper
Looper.prepareMainLooper();
//加載動態庫“libandroid_servers.so”
System.loadLibrary("android_servers");
performPendingShutdown();
//創建系統的上下文Context
createSystemContext();
// 創建SystemServiceManager
mSystemServiceManager = new SystemServiceManager(mSystemContext);
mSystemServiceManager.setRuntimeRestarted(mRuntimeRestart);
LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
SystemServerInitThreadPool.get();
} finally {
traceEnd(); // InitBeforeStartServices
}
// Start services.
try {
traceBeginAndSlog("StartServices");
//啓動引導服務
startBootstrapServices();
//啓動核心服務
startCoreServices();
//啓動其他服務
startOtherServices();
SystemServerInitThreadPool.shutdown();
}......}
通過上面可以看出系統服務分爲三種：
1.引導服務。
2.核心服務。
3.其他服務。
private void startBootstrapServices() {
......
Installer installer = mSystemServiceManager.startService(Installer.class);
......
mSystemServiceManager.startService(DeviceIdentifiersPolicyService.class);
......
//需要注意的是 ActivityManagerService.Lifecycle實現了SystemService
mActivityManagerService = mSystemServiceManager.startService(
ActivityManagerService.Lifecycle.class).getService();
......
mPackageManagerService = PackageManagerService.main(mSystemContext, installer,
mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF, mOnlyCore);
......
//在該方法中會把ActivityManagerService添加到ServiceManager中
mActivityManagerService.setSystemProcess();
......}private void startCoreServices() {
......
mSystemServiceManager.startService(DropBoxManagerService.class);
traceEnd();
......
mSystemServiceManager.startService(BatteryService.class);
......}private void startOtherServices() {
......
mSystemServiceManager.startService(KeyChainSystemService.class);
......
mSystemServiceManager.startService(TelecomLoaderService.class);
......}
部分服務表：
我們從上面看出相關的服務一種是通過SystemServiceManager的startService方法來啓動的；另一種是直接調用服務的main方法，比如：PackageManagerService。下面分別看一下這兩種方式的代碼實現：
/frameworks/base/services/core/java/com/android/server/SystemServiceManager.java
public class SystemServiceManager {
......
private final ArrayList<SystemService> mServices = new ArrayList<SystemService>();
......
//startService方法有幾個重載，最終都會調用該方法
public void startService(@NonNull final SystemService service) {
//註冊服務
mServices.add(service);
// Start it.
long time = System.currentTimeMillis();
try {
//調用服務自身的onStart方法
service.onStart();
}......
}}public abstract class SystemService {
......}
先將服務添加到mService中，它是一個存儲SystemService類型的ArrayList，這樣就完成來該服務的註冊工作。然後調用服務自身的onStart()方法來啓動服務。由SystemServiceManager創建並啓動的服務，都是繼承了SystemService，但是並沒有實現IBinder，所以是不可以進行Binder通信的，也就是由它管理的服務是用於進程內部通信的。
/frameworks/base/services/core/java/com/android/server/pm/PackageManagerService.java
public class PackageManagerService extends IPackageManager.Stub
implements PackageSender {
......
public static PackageManagerService main(Context context, Installer installer,
boolean factoryTest, boolean onlyCore) {
PackageManagerServiceCompilerMapping.checkProperties();
PackageManagerService m = new PackageManagerService(context, installer,
factoryTest, onlyCore);
m.enableSystemUserPackages();
//註冊
ServiceManager.addService("package", m);
return m;
}
......}
創建對象後添加到ServiceManager中，它是用來管理系統中各種Service的，由它管理的服務都實現了IBinder，所以在ServiceManager中註冊的服務是用於進程間通信的：用於系統C/S架構中的Binder通信機制。客戶端要使用某個Service，需要先到ServiceManager中查詢Service的信息，然後根據該信息與Service所在的Server進程建立通信，這樣客戶端就可以使用Service了。
從上面的代碼我們看出SystemServer進程主要做了如下幾件事情：
- 啓動Binder線程池，這樣就可以與其他進程進行通信了。
- 創建SystemServiceManager，用於對系統其他服務進行創建、啓動和聲明週期管理。
- 啓動各種系統服務
SystemServer進程是Zygote進程fork的第一個進程。其中WindowManagerService、ActivityManagerService、PackageManagerService等重要的可以binder通信的服務都運行在這個SystemServer進程。
整體總結：
- 手機按下電源後，加載引導程序到內存中。（通過bootloder加載芯片的引導程序）
- 執行引導程序
- 啓動內核，設置緩存、被保護存儲器、計劃列表，加載驅動，查找/system/core/bin中init程序文件。
- 啓動init程序，掛載/sys /dev /proc等等目錄，加載和解析init.rc腳本。
- 在加載init.rc腳本的時候，啓動app_process進程。
- 在app_process進程中，根據init.zygote64.rc腳本配置的參數，啓動zygote進程
- 創建Java虛擬機併爲Java虛擬機註冊JNI方法
- 由AndroidRuntime通過JNI的方式調用 ZygoteInit的main函數進入Zygote的Java框架層
- 通過registerServerSocket 方法創建服務端Socket，並通過runSelectLoop 方法等待AMS的請求來創建新的應用程序進程。
- 啓動SystemServer進程。
- 啓動Binder線程池，這樣就可以與其他進程進行通信了。
- 創建SystemServiceManager，用於對系統其他服務進行創建、啓動和聲明週期管理。
- 啓動各種系統服務。
