Android 8.0 源碼分析 (一) SystemServer 進程啓動
前言
咱們熟知通常 Android 工程師都是基於 SDK 在應用層上開發，不會涉及系統源碼，可是若是你想往底層發展，或者深刻插件化、Framework 系統層等開發工做，若是不瞭解 Android 源碼但是不行的，那麼接下來我基於本身的理解跟學習來記錄跟 Android 開發息息相關的源碼分析，大概從 Android 中的 SystemServer 啓動、四大組件啓動、AMS、PMS 等幾個維度來介紹，下面是個人計劃，固然在將來也有可能改變。java
尚未關注的小夥伴，能夠先關注一波，系列文章會持續更新。android
Android 8.0 源碼分析 (一) SystemServer 進程啓動數組
Android 8.0 源碼分析 (二) Launcher 啓動服務器
Android 8.0 源碼分析 (三) 應用程序進程建立到應用程序啓動的過程app
Android 8.0 源碼分析 (四) Activity 啓動框架
Android 8.0 源碼分析 (五) Service 啓動socket
Android 8.0 源碼分析 (六) BroadcastReceiver 啓動ide
Android 8.0 源碼分析 (七) ContentProvider 啓動函數
介紹
Android 中的 SystemServer 能夠說是最爲重要的進程也不爲過，由於咱們熟知的 AMS、WMS、PMS 等等都是經過它來啓動的，所以掌握 SystemServer 進程是如何啓動，它在啓動又幹了什麼，這些都是咱們本章須要學習的。oop
源碼分析
在分析 SystemServer 啓動源碼以前，咱們先看一下 SystemServer 啓動時序圖
1. Zygote 開創 Java 框架層入口
根據上面時序圖咱們知道是 Zygote 是 Java 框架端的入口，那麼 Zygote 是什麼呢？它有一箇中文名稱咱們叫它 孵化器，顧名思義它就是爲應用程序或者系統程序來建立它們對應進程的，Zygote 經過 init.rc 腳本啓動，Zygote 啓動過程打算後面單獨寫一篇來介紹，這裏就直接跳到 JNI 層啓動 Zygote 的入口，其實就是 ZygoteInit.java 文件，咱們直接看它的 main 函數實現。
//com.android.internal.os.ZygoteInit.java
public static void main(String argv[]) {
....
try {
...
//是否開啓 SystemServer 標記
boolean startSystemServer = false;
//服務端 Socket 名稱
String socketName = "zygote";
//根據 JNI 層傳遞過來的信息，來判斷是否啓動系統服務
for (int i = 1; i < argv.length; i++) {
if ("start-system-server".equals(argv[i])) {
startSystemServer = true;
} else if ("--enable-lazy-preload".equals(argv[i])) {
enableLazyPreload = true;
} else if (argv[i].startsWith(ABI_LIST_ARG)) {
abiList = argv[i].substring(ABI_LIST_ARG.length());
} else if (argv[i].startsWith(SOCKET_NAME_ARG)) {
socketName = argv[i].substring(SOCKET_NAME_ARG.length());
} else {
throw new RuntimeException("Unknown command line argument: " + argv[i]);
}
}
/** * 1. 建立服務端的 Socket ,名稱爲 "zygote" */
zygoteServer.registerServerSocket(socketName);
if (!enableLazyPreload) {
bootTimingsTraceLog.traceBegin("ZygotePreload");
EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_START,
SystemClock.uptimeMillis());
/** * 2. 用來預加載資源 */
preload(bootTimingsTraceLog);
EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_END,
SystemClock.uptimeMillis());
bootTimingsTraceLog.traceEnd(); // ZygotePreload
} else {
Zygote.resetNicePriority();
}
...
if (startSystemServer) {
/** * 3. 啓動 SystemServer 進程 * */
startSystemServer(abiList, socketName, zygoteServer);
}
Log.i(TAG, "Accepting command socket connections");
/** * 4. 等待 AMS 請求 */
zygoteServer.runSelectLoop(abiList);
//清理或者關閉對應的 Socket
zygoteServer.closeServerSocket();
} catch (Zygote.MethodAndArgsCaller caller) {
caller.run();
} catch (Throwable ex) {
Log.e(TAG, "System zygote died with exception", ex);
zygoteServer.closeServerSocket();
throw ex;
}
}
複製代碼
經過上面代碼咱們能夠把 ZygoteInit.main() 作的工做分爲四大步
-
- 建立一個 Server 端爲 」zygote「 名稱的 Socket，用於等待 AMS 請求 Zygote 來建立新的應用程序進程。
-
- 預處理加載類跟資源。
-
- 根據 JNI 傳遞過來的信息來判斷是否啓動 SystemServer 進程。
-
- 等待 AMS 請求，用於建立新的應用程序進程。
1. zygoteServer.registerServerSocket(socketName);
咱們首先來分析第一步具體作了什麼，看下面函數代碼
//com.android.internal.os ZygoteServer.java
void registerServerSocket(String socketName) {
if (mServerSocket == null) {
int fileDesc;
/** * 1. 拿到 Socket 名稱 */
final String fullSocketName = ANDROID_SOCKET_PREFIX + socketName;
try {
/** * 2. 獲得 Socket 環境變量的值 */
String env = System.getenv(fullSocketName);
/** * 3. 將 Socket 環境變量的值轉換爲文件描述符的參數 */
fileDesc = Integer.parseInt(env);
} catch (RuntimeException ex) {
throw new RuntimeException(fullSocketName + " unset or invalid", ex);
}
try {
/** * 4. 建立文件描述符 */
FileDescriptor fd = new FileDescriptor();
//將 Socket 轉換出來的信息傳遞給文件描述符，用於獲取具體信息
fd.setInt$(fileDesc);
/** *5. 建立服務端 Socket */
mServerSocket = new LocalServerSocket(fd);
} catch (IOException ex) {
throw new RuntimeException(
"Error binding to local socket '" + fileDesc + "'", ex);
}
}
}
複製代碼
根據上面註釋咱們來總結下 registerServerSocket 函數幹了哪些事兒？
-
- 拿到拼接以後的 Socket 名稱（ANDROID_SOCKET_zygote）
-
- 經過 funSocketName Socket 名稱轉換爲系統環境變量的值
-
- 將 Socket 的系統環境變量的值轉換爲文件描述符的參數
-
- 建立 FileDescriptor 文件描述符
-
- 建立服務端 Socket 並將拿到對應的文件描述符做爲參數傳遞給服務端 Socket
最後服務端 Socket 就建立成功了，並處於等待 AMS 請求 zygote 進程來建立新的應用程序進程。
2. 啓動 SystemServer 進程
接下來請繼續回到 ZygoteInit main 函數的註釋 3 處具體實現，以下：
//com.android.internal.os ZygoteInit.main->startSystemServer
private static boolean startSystemServer(String abiList, String socketName, ZygoteServer zygoteServer) throws Zygote.MethodAndArgsCaller, RuntimeException {
long capabilities = posixCapabilitiesAsBits(
OsConstants.CAP_IPC_LOCK,
OsConstants.CAP_KILL,
OsConstants.CAP_NET_ADMIN,
OsConstants.CAP_NET_BIND_SERVICE,
OsConstants.CAP_NET_BROADCAST,
OsConstants.CAP_NET_RAW,
OsConstants.CAP_SYS_MODULE,
OsConstants.CAP_SYS_NICE,
OsConstants.CAP_SYS_PTRACE,
OsConstants.CAP_SYS_TIME,
OsConstants.CAP_SYS_TTY_CONFIG,
OsConstants.CAP_WAKE_ALARM
);
...
/* Hardcoded command line to start the system server */
/** * 1. 啓動 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);
/* Request to fork the system server process */
/** * 建立一個子進程，也就是 SystemServer 進程 */
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 */
/** * 若是當前代碼運行在子進程中 ，也就是 SystemServer 進程中 */
if (pid == 0) {
if (hasSecondZygote(abiList)) {
waitForSecondaryZygote(socketName);
}
//關閉 Zygote 進程建立的 Socket
zygoteServer.closeServerSocket();
/** * 處理 SystemServer 進程 */
handleSystemServerProcess(parsedArgs);
}
return true;
}
複製代碼
根據上面代碼咱們仍是來分析下當前函數到底幹了些什麼
-
- 根據定義的 args ，做爲啓動 SystemServer 進程的參數。
-
- 經過 Zygote.forkSystemServer 函數來建立 SystemServer 進程(其內部也是在 native 建立)，返回進程 pid
-
- 若是 pid 爲 0 那麼就表示已經運行在 SystemServer 進程中了，執行 handleSystemServerProcess 函數
handleSystemServerProcess() 具體處理 SystemServer 邏輯，在文章中第二大點中介紹。
3. zygoteServer.runSelectLoop(abiList);
SystemServer 進程啓動成功以後，會繼續回到 ZygoteInit.Main() 中執行 runSelectLoop 函數，下面看下具體實現：
// com.android.internal.os ZygoteInit.main->runSelectLoop
void runSelectLoop(String abiList) throws Zygote.MethodAndArgsCaller {
ArrayList<FileDescriptor> fds = new ArrayList<FileDescriptor>();
ArrayList<ZygoteConnection> peers = new ArrayList<ZygoteConnection>();
/** * 1. 添加得到該 Socket 的 fd 字段的值 */
fds.add(mServerSocket.getFileDescriptor());
peers.add(null);
/** * 死循環等待 AMS 的請求 */
while (true) {
StructPollfd[] pollFds = new StructPollfd[fds.size()];
/** * 2. 將 fds 信息轉存到 pollFds 數組中。 */
for (int i = 0; i < pollFds.length; ++i) {
pollFds[i] = new StructPollfd();
pollFds[i].fd = fds.get(i);
pollFds[i].events = (short) POLLIN;
}
try {
Os.poll(pollFds, -1);
} catch (ErrnoException ex) {
throw new RuntimeException("poll failed", ex);
}
/** * 3.對 pollFds 信息進行遍歷 */
for (int i = pollFds.length - 1; i >= 0; --i) {
if ((pollFds[i].revents & POLLIN) == 0) {
continue;
}
//若是 i == 0 那麼就認爲 服務端 Socket 與客戶端鏈接上了，就是與 AMS 創建了鏈接
if (i == 0) {
/** * 4. */
ZygoteConnection newPeer = acceptCommandPeer(abiList);
//將 ZygoteConnection 添加到 Socket 鏈接列表中
peers.add(newPeer);
//將 ZygoteConnection 的文件描述符 添加到 fds 列表中
fds.add(newPeer.getFileDesciptor());
} else {//若是不等於 0 ，那麼就說明 AMS 向 Zygote 發送了一個建立應用進程的請求
/** * 5. 調用 ZygoteConnection 的 runOnce 函數來建立一個新的應用進程，並在成功建立後將這個鏈接從 Socket 鏈接列表中 peers、fd 列表中關閉 */
boolean done = peers.get(i).runOnce(this);
if (done) {
peers.remove(i);
fds.remove(i);
}
}
}
}
}
複製代碼
經過上面代碼咱們分析該函數主要作了些什麼
-
- mServerSocket 就是咱們在 registerZygoteSocket 函數中建立的服務器端 Socket,調用 mServerSocket.getFileDescriptor() 函數用來得到該 Socket 的 fd 字段的值並添加到 fds 列表中。接下來就無限循環用來等待 AMS 請求 Zygote 進程建立的新的應用程序進程。
-
- 將 fds 信息轉存到 pollFds 數組中。
-
- 對 pollFds 信息進行遍歷,若是 i == 0 那麼就認爲 服務端 Socket 與客戶端鏈接上了，就是與 AMS 創建了鏈接，不然就說明 AMS 向 Zygote 發送了一個建立應用進程的請求,並在成功建立後將這個鏈接從 Socket 鏈接列表中 peers、fd 列表中關閉。
小結
經過 ZygoteInit main 函數的實現，作一個小總結
-
- 經過 JNI 調用 ZygoteInit 的 main 函數進入 Zygote 的 Java 框架層；
-
- 經過 registerZygoteSocket 函數建立服務端 Socket,並經過 runSelectLoop 函數等待 AMS 的請求來建立新的應用程序進程。
-
- 啓動 SystemServer 進程
這一小節至關於給 SystemServer 啓動作一個鋪墊，知道在哪裏調用啓動，而後在具體分析。
2. SystemServer 進程處理過程
經過上一小節的第二點咱們知道最後進入處理 SystemServer 是在 ZygoteInit.main() -> startSystemServer() 函數的 handleSystemServerProcess 中，那麼咱們直接看該函數實現
//com.android.internal.os ZygoteInit.main
private static void handleSystemServerProcess( ZygoteConnection.Arguments parsedArgs) throws Zygote.MethodAndArgsCaller {
...
if (parsedArgs.invokeWith != null) {
...
} else {
ClassLoader cl = null;
if (systemServerClasspath != null) {
/** * 1. 建立了 PathClassLoader */
cl = createPathClassLoader(systemServerClasspath, parsedArgs.targetSdkVersion);
Thread.currentThread().setContextClassLoader(cl);
}
/** * 2. 調用本身的 zygoteInit 函數 */
ZygoteInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, cl);
}
/* should never reach here */
}
複製代碼
在註釋 1 處建立了 PathClassLoader 作過熱修復跟插件化的相信對它一點不陌生，這裏不作詳細講解，能夠把它理解爲能夠動態加載 JAR/ZIP/APK, 註釋 2 調用了 ZygoteInit.zygoteInit ，代碼以下
// com.android.internal.os ZygoteInit
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();
/** * 1. 啓動 Binder 線程池 */
ZygoteInit.nativeZygoteInit();
/** * 2. 進入 SystemServer 的 main 方法 */
RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader);
}
複製代碼
註釋 1 處調用 ZygoteInit 的 nativeZygoteInit() 函數，其底層就是調用 native 層代碼，用於啓動 Binder 線程池，這樣 SystemServer 就能經過 Binder 與其它進程進行通訊了。註釋 2 處做用就是反射調用 SystemServer main 函數。
1. Binder 線程池啓動
由於當前文章主要將 SystemServer 內容，對啓動 Binder 源碼能夠參考 AndroidRuntime.cpp ，app_main.cpp 。
啓動成功以後就可使用 Binder 與其它進程進行通訊了。
2. 進入 SystemServer.java main() 入口
咱們繼續回到 ZygoteInit.java 的 zygoteInit 中的 RuntimeInit.applicationInit 調用，代碼以下
//com.android.internal.os RuntimeInit.java
protected static void applicationInit(int targetSdkVersion, String[] argv, ClassLoader classLoader) throws Zygote.MethodAndArgsCaller {
....
invokeStaticMain(args.startClass, args.startArgs, classLoader);
}
複製代碼
private static void invokeStaticMain(String className, String[] argv, ClassLoader classLoader) throws Zygote.MethodAndArgsCaller {
Class<?> cl;
try {
/** *1. 經過 className(com.android.server.SystemServer )反射獲得SystemServer 類 * className 經過 AMS 等其它地方傳遞過來的，並非惟一 */
cl = Class.forName(className, true, classLoader);
} catch (ClassNotFoundException ex) {
throw new RuntimeException(
"Missing class when invoking static main " + className,
ex);
}
Method m;
try {
/** * 2. 拿到 SystemServer main 函數 */
m = cl.getMethod("main", new Class[] { String[].class });
} catch (NoSuchMethodException ex) {
...
} catch (SecurityException ex) {
...
}
int modifiers = m.getModifiers();
if (! (Modifier.isStatic(modifiers) && Modifier.isPublic(modifiers))) {
...
}
/** * 3. 將 m 、argv 傳入 MethodAndArgsCaller，而後拋一個異常，並在 ZygoteInit.main 中進行捕獲異常 */
throw new Zygote.MethodAndArgsCaller(m, argv);
}
複製代碼
經過上面代碼咱們知道首先經過 com.android.server.SystemServer 反射拿到 Class ，其次在經過當前獲取到的 Class 拿到它的 main 方法，最後拋了一個 Zygote.MethodAndArgsCaller(m, argv) 異常。
//com.android.internal.os Zygote.java
public static class MethodAndArgsCaller extends Exception implements Runnable {
...
}
複製代碼
，經過上面代碼咱們知道，它就是繼承的 Java 異常父類 Exception ，而後是實現 Runnable 函數。這裏寫其實頗有意思。這裏的異常是在 ZygoteInit.java main 函數進行捕獲，咱們看代碼實現
//com.android.internal.os ZygoteInit.java
public static void main(String argv[]) {
...
if (startSystemServer) {
/** * 1. 啓動 SystemServer 進程 * */
startSystemServer(abiList, socketName, zygoteServer);
}
....
//2. 捕獲異常
} catch (Zygote.MethodAndArgsCaller caller) {
//3. 執行 run 函數
caller.run();
} catch (Throwable ex) {
Log.e(TAG, "System zygote died with exception", ex);
zygoteServer.closeServerSocket();
throw ex;
}
}
複製代碼
經過上面代碼最後會執行到註釋 3 處，咱們看內部代碼實現
////com.android.internal.os Zygote.java
public static class MethodAndArgsCaller extends Exception implements Runnable {
/** method to call */
private final Method mMethod;
/** argument array */
private final String[] mArgs;
public MethodAndArgsCaller(Method method, String[] args) {
mMethod = method;
mArgs = args;
}
public void run() {
try {
/** * 1. 這裏就開始執行 SystemServer main 方法了 */
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);
}
}
}
複製代碼
經過註釋 1 ，咱們知道這裏經過反射直接調用 SystemServer.java main() 函數，咱們直接看它的 main 實現吧。
//com.android.server SystemServer.java
/** * 這裏的 main 函數 主要是 zygote 經過反射調用 */
public static void main(String[] args) {
//調用內部 run 函數
new SystemServer().run();
}
複製代碼
//com.android.server SystemServer.java
private void run() {
try {
...
/** * 建立 主線程的消息 Looper */
Looper.prepareMainLooper();
// Initialize native services.
/** * 1. 加載動態庫 libandroid_servers .so */
System.loadLibrary("android_servers");
// Check whether we failed to shut down last time we tried.
// This call may not return.
performPendingShutdown();
// Initialize the system context.
/** * 建立系統級別的 Context */
createSystemContext();
// Create the system service manager.
/** * 2. 建立 SystemServiceManager 它會對系統服務進行建立、啓動和生命週期管理 */
mSystemServiceManager = new SystemServiceManager(mSystemContext);
mSystemServiceManager.setRuntimeRestarted(mRuntimeRestart);
LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
// Prepare the thread pool for init tasks that can be parallelized
SystemServerInitThreadPool.get();
} finally {
traceEnd(); // InitBeforeStartServices
}
// Start services.
try {
traceBeginAndSlog("StartServices");
/** * 3. SystemServiceManager啓動了 AMS 、PowerMS、PackageMS 等服務 */
startBootstrapServices();
/** * 4. 啓動了 DropBoxManagerService、BatteryService、UsageStatsService 和 WebViewUpdateService */
startCoreServices();
/** * 5. 啓動了CameraService、AlarmManagerService、VrManagerService 等服務。 */
startOtherServices();
SystemServerInitThreadPool.shutdown();
} catch (Throwable ex) {
Slog.e("System", "******************************************");
Slog.e("System", "************ Failure starting system services", ex);
throw ex;
} finally {
traceEnd();
}
...
// Loop forever.
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
複製代碼
經過上面代碼主要作了哪些事兒，請看下面總結
-
- 建立消息 Looper
-
- 加載動態庫 libandroid_servers .so
-
- 建立系統級別的 Context
-
- 建立 SystemServiceManager 它會對系統服務進行建立、啓動和生命週期管理
-
- 經過 SystemServiceManager 啓動 AMS 、PowerMS、PackageMS 等服務
-
- 啓動 DropBoxManagerService、BatteryService、UsageStatsService 和 WebViewUpdateService 等核心服務，他們父類都是 SystemServer
-
- 啓動 CameraService、AlarmManagerService、VrManagerService 等服務
從上面代碼中的註釋 3，4，5 的函數中能夠看出，官方把系統分爲了 三種類型，分別是引導服務，核心服務和其它服務, 其中其它服務是一些非緊要和不須要當即啓動的服務。這 三種類型的服務總有 100 多個，下面列出部分系統服務及其做用。
| 引導服務 | 做用 |
|---|---|
| Installer | 系統安裝 APK 的一個服務類，啓動完成 Installer 服務以後才能啓動其它系統服務 |
| ActivityManagerService | 負責四大組件的啓動、切換、調度 |
| PowerManagerService | 計算系統中和 Power 相關的計算，而後決策系統應該如何反應 |
| LightsService | 管理和顯示背光 LED |
| DisplayManagerService | 用來管理全部顯示設備 |
| UserManagerService | 多用戶模式管理 |
| SensorService | 爲系統提供各類感應器服務 |
| PackageManagerService | 用來對 APK 進行安裝、解析、刪除、卸載等操做 |
| ...... | ...... |
| 核心服務 | 做用 |
|---|---|
| DropBoxManagerService | 用於生成和管理系統運行時的一些日誌文件 |
| BatteryService | 管理電池相關服務 |
| UsageStatsService | 手機用戶使用每個 APP 的頻率、使用時長 |
| WebViewUpdateService | WebView 更新服務 |
| 其它服務 | 做用 |
|---|---|
| CameraService | 攝像頭相關服務 |
| AlarmManagerService | 全局定時器管理服務 |
| InputManagerService | 管理輸入事件 |
| WindowManagerService | 窗口管理服務 |
| VrManagerService | VR 模式管理服務 |
| BluetoothService | 藍牙管理服務 |
| NotificationManagerService | 通知管理服務 |
| DeviceStorageMonitorService | 存儲相關管理服務 |
| LocationManagerService | 定位管理服務 |
| AudioService | 音頻相關管理服務 |
| ...... | ...... |
3. 舉例說明 ActivityManagerService 服務啓動
由於這些服務啓動邏輯都是類似的，因此這裏以啓動 ActivityManagerService 來進行舉例，代碼以下
//com.android.server SystemServer.java
private void startBootstrapServices() {
...
//1. 調用 SystemServiceManager 的統一啓動服務接口 startService
mActivityManagerService = mSystemServiceManager.startService(
ActivityManagerService.Lifecycle.class).getService();
//2. AMS 與 系統服務管理類進行綁定
mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
//3. AMS 與 APK 安裝服務進行綁定
mActivityManagerService.setInstaller(installer);
...
}
複製代碼
咱們先看 SystemServiceManager.startService 實現
//com.android.server SystemServiceManager.java
public <T extends SystemService> T startService(Class<T> serviceClass) {
try {
....
try {
//1. 反射實例化對象
Constructor<T> constructor = serviceClass.getConstructor(Context.class);
service = constructor.newInstance(mContext);
} catch (InstantiationException ex) {
....
//2.
startService(service);
return service;
} finally {
Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
}
}
複製代碼
public void startService(@NonNull final SystemService service) {
// 1.
mServices.add(service);
// Start it.
long time = System.currentTimeMillis();
try {
//2.
service.onStart();
} catch (RuntimeException ex) {
...
}
...
}
複製代碼
經過代碼咱們知道 serviceClass 就是以參數傳遞進來的 ActivityManagerService.Lifecycle.class 拿到該 class 而後反射實例化 Lifecycle 對象，最後調用 Lifecycle 的 onStart 函數。代碼以下
//com.android.server.am ActivityManagerService.java
public static final class Lifecycle extends SystemService {
private final ActivityManagerService mService;
public Lifecycle(Context context) {
super(context);
//1.
mService = new ActivityManagerService(context);
}
@Override
public void onStart() {
//2.
mService.start();
}
public ActivityManagerService getService() {
//3.
return mService;
}
}
複製代碼
Lifecycle 是 AMS 中的靜態內部類，繼承系統服務 SystemService , 根據上面註釋咱們獲得，當調用 serviceClass 反射實例化的時候會執行上面註釋 1，而後 service.onStart(); 對應的是 service 子類 Lifecycle 的 onStart 函數，最後 getService 就是 mSystemServiceManager.startService(ActivityManagerService.Lifecycle.class).getService() 該函數調用。
到這裏 ActivityManagerService 就被 SystemServiceManager 給實例化了。
小結
大概總結一下 SystemServer 主要作了就是啓動 三種類型 的服務，由於各個服務啓動邏輯類似，因此最後以 AMS 來舉例說明啓動流程。最後 SystemServer 進程啓動跟 其它服務啓動也講解完了，最後到了咱們總結環節了。
總結
我這裏就從 Java 框架入口 ZygoteInit.main() 函數到 SystemServer 進程啓動和處理服務啓動的邏輯執行流程大概總結說明下：
-
- 建立一個 Server 端爲 」zygote「 名稱的 Socket，用於等待 AMS 請求 Zygote 來建立新的應用程序進程。
-
- 預處理加載類跟資源。
-
- 根據 JNI 傳遞過來的信息來判斷是否建立 SystemServer 進程。
-
- 啓動 Binder 線程池，與其它進程進行通訊。
-
- 進入 SystemServer.java main() 函數並建立 SystemServiceManager ，用於對各類服務的建立、啓動和生命週期的管理。
-
- 啓動各類系統服務。
-
- 等待 AMS 請求，用於建立新的應用程序進程。
AMS 和四大組件工做原理等文章會在後面陸續更新
參考
- 《Android 進階解密》
相關文章
- 1. Android SystemServer啓動流程源碼解析
- 2. Android 8.0 源碼分析 (二) Launcher 啓動
- 3. Android 8.0 源碼分析 (四) Activity 啓動
- 4. Android 8.0 源碼分析 (五) Service 啓動
- 5. Android 8.0 源碼分析 (六) BroadcastReceiver 啓動
- 6. Android 8.0 源碼分析 (七) ContentProvider 啓動
- 7. Android進階3：Activity源碼分析（1） —— Activity啓動流程（8.0）
- 8. Android系統源碼分析--Zygote和SystemServer啓動過程
- 9. Android7.0啓動SystemServer進程
- 10. Android 應用程序進程啓動過程源碼分析
- 更多相關文章...
- • SVN 啓動模式 - SVN 教程
- • 啓動MySQL服務 - MySQL教程
- • Git五分鐘教程
- • 互聯網組織的未來：剖析GitHub員工的任性之源
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. Android SystemServer啓動流程源碼解析
- 2. Android 8.0 源碼分析 (二) Launcher 啓動
- 3. Android 8.0 源碼分析 (四) Activity 啓動
- 4. Android 8.0 源碼分析 (五) Service 啓動
- 5. Android 8.0 源碼分析 (六) BroadcastReceiver 啓動
- 6. Android 8.0 源碼分析 (七) ContentProvider 啓動
- 7. Android進階3：Activity源碼分析（1） —— Activity啓動流程（8.0）
- 8. Android系統源碼分析--Zygote和SystemServer啓動過程
- 9. Android7.0啓動SystemServer進程
- 10. Android 應用程序進程啓動過程源碼分析