---
# System prepended metadata

title: Android 啟動過程 - SystemServer 進程
tags: [Android 系統]

---

---
title: 'Android 啟動過程 - SystemServer 進程'
disqus: kyleAlien
---

SystemServer 進程
===

## OverView of Content

[TOC]

## 系統進程之間 - 關係
這個章節著重講解的是 **++SystemServer 進程++**，但了解它的來源也是相當重要的，請參考下圖
> ![](https://i.imgur.com/2jh6Kcr.png)

### ZygoteInit 啟動 SystemServer 進程
* 關於 Zygote 啟動 SystemServer 詳細請看 [**Android 啟動過程 - Zygote**](https://hackmd.io/Yw1s2x32QoqawvOsW039ZA?both)

* 簡單來說必須經過以下步驟
    1. init 進程分析 init.rc 檔案
    2. 啟動 Zygote 服務 (app_main.cpp)
    3. 分析帶入的參數 (也就是 init.rc 傳入的參數)
    4. 啟動該進程的 Binder 線程池
    5. fork Zygote 進程，啟動 SystemServer 進程

## 系統服務 [SystemServer](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/services/java/com/android/server/SystemServer.java)

System Server 是進入 Launcher 前的最後準備，它提供了許多 Java 所撰寫的 系統服務，這些服務大份都透過 SystemServiceManager 管理

1. 初始化 Native 的服務（加載 `android_servers` Library）

2. 創建 SystemService，可以用它來啟動其他不同的服務

    ```java=
    // /android/server/SystemServer.java

        /**
         * The main entry point from zygote. (從 zygote 服務來)
         */
        public static void main(String[] args) {
            new SystemServer().run();
        }

        private void run() {
            TimingsTraceAndSlog t = new TimingsTraceAndSlog();
            ...省略部分

            try {
                ... 省略部分
                // 1. 初始化 Native 的服務
                System.loadLibrary("android_servers");

                ... 省略部分

                // 2. 創建 SystemService，可以用它來啟動其他不同的服務
                mSystemServiceManager = new SystemServiceManager(mSystemContext);

            } finally {
                t.traceEnd();  // InitBeforeStartServices
            }

            try {
                // 3. 啟動系統多個服務
                startBootstrapServices(t);

                startCoreServices(t);

                startOtherServices(t);

            } /* 省略 catch */

            ...省略部分
        }
    ```
3. 啟動 Java 層服務：這些服務分有三種分類 `Bootstrap`、`Core`、`Other`，以下舉例幾種常見的服務

    * Bootstrap
        | 服務 | 功能 |
        | -------- | -------- |
        | Installer | 安裝所有 APK 的服務，啟動完 Install 服務後才能啟動其他服務 |
        | ActivityManagerService | 負責管理 4 大零組件 |
        | PowerManagerService | 計算系統中 Power 相關，以及對應策略 |
        | LigthsService | 管理、顯示 LED |
        | DisplayManagerService | 與 WMS 有關，用來管理該設備的顯示 |
        | UserManagerService | 多用戶模式管理 |
        | SensorService | 各種傳感器服務 |
        | PackageManagerService | APK 卸載、安裝、解析等等操作 |
        
        
    * Core
        | 服務 | 功能 |
        | -------- | -------- |
        | DropBoxManagerService | 生成、管理系統運行時的日誌文件 |
        | BatteryService | 管理電池相關的服務 |
        | UsageStatsService | 收集用戶使用每個 APP 的頻率、時長 |
        | WebViewUpdateService | WebView 更新服務 |
        
        
    * Other
        | 服務 | 功能 |
        | -------- | -------- |
        | CameraService | 相機相關服務 |
        | AlertManagerService | 定時器服務 |
        | InputManagerService | 管理輸入事件 |
        | WindowManagerService | 窗口管理 |
        | VrManagerService | Vr 模式管理服務 |
        | BluetoothManagerService | 藍芽管理服務 |
        | NotificationManagerService | 通知管理服務 |
        | DeviceStorageMonitorService | 裝置儲存管理 |
        | LocalManagerService | 定位管理 |
        | AudioService | 音頻管理 |

### [SystemService](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/services/core/java/com/android/server/SystemService.java) 生命週期

* SystemService 類提供系統服務生命週期的回調函數（就像是 Activity#onCreate、onStart、onResume... 等等）
    
    > 這跟上面的 SystemService 不同，這是抽象類
    > 路徑：`frameworks/base/services/core/java/com/android/server/SystemService.java`


    * SystemService 生命週期回調方法

        | 生命週期 - 方法 | 說明 |
        | - | - |
        | onStart | 服務初次啟動，**通過這個回調註冊到 Binder 驅動中** |
        | onBootPhase | 傳給每個服務 SystemService 的啟動常量，讓服務自己對有興趣的階段處理 |
        
        ```java=
        // SystemService.java

        public abstract void onStart();

        public void onBootPhase(@BootPhase int phase) {}
        ```
        
    * SystemService 生命週期常量

        | 生命週期 - 常量 | 意義 |
        | -------- | -------- |
        | PHASE_WAIT_FOR_DEFAULT_DISPLAY（100） | 等待顯示器 |
        | PHASE_WAIT_FOR_SENSOR_SERVICE（200） | 等待感應器服務 |
        | PHASE_LOCK_SETTINGS_READY（480） | Lock Settings 就緒 |
        | PHASE_SYSTEM_SERVICES_READY（500） | 系統服務就緒 |
        | PHASE_DEVICE_SPECIFIC_SERVICES_READY（520） | 特殊服務就緒 |
        | PHASE_ACTIVITY_MANAGER_READY（550） | AMS 就緒 |
        | PHASE_THIRD_PARTY_APPS_CAN_START (600) | 第三方 APP 可以啟動 |
        | PHASE_BOOT_COMPLETED (1000) | 系統啟動完成 |


### 註冊 SystemService 服務

* 我們知道大部分 Service 都需註冊到 ServiceManager 中（Binder 驅動），而 **SystemService 中的服務也需要註冊到 ServiceManager 中（Binder 驅動）**

*  繼承 `SystemService` 類：透過包裝好的 `publishBinderService` 註冊 (其實最終仍會使用 ServiceManager.addService 方法)
    * `BatteryService` 服務：它就是 ^1.^ 繼承 `SystemService`、^2.^ 覆寫 `onStart` 方法，在方法中註冊 battery、batteryproperties 服務

        ```java=
        // BatteryService.java

        public final class BatteryService extends SystemService {

            @Override
            public void onStart() {
                registerHealthCallback();

                mBinderService = new BinderService();

                // 註冊 battery
                publishBinderService("battery", mBinderService);

                // 註冊 batteryproperties
                mBatteryPropertiesRegistrar = new BatteryPropertiesRegistrar();
                // @ 追蹤 publishBinderService 方法
                publishBinderService("batteryproperties", mBatteryPropertiesRegistrar);

                publishLocalService(BatteryManagerInternal.class, new LocalService());
            }

        }
        ```

        * publishBinderService 方法：最終會呼叫 ServiceManager#addService 方法

            ```java=
            // ServiceManager.java

                protected final void publishBinderService(@NonNull String name, @NonNull IBinder service) {
                    publishBinderService(name, service, false);
                }

                protected final void publishBinderService(@NonNull String name, @NonNull IBinder service,
                        boolean allowIsolated) {
                    publishBinderService(name, service, allowIsolated, DUMP_FLAG_PRIORITY_DEFAULT);
                }


                protected final void publishBinderService(String name, IBinder service,
                        boolean allowIsolated, int dumpPriority) {

                    // 呼叫 ServiceManager#addService 方法
                    ServiceManager.addService(name, service, allowIsolated, dumpPriority);
                }
            ```
* [**ServiceManager**](https://android.googlesource.com/platform/frameworks/base/+/master/core/java/android/os/ServiceManager.java)#addService 方法：透過 [**ServiceManagerNative**](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/os/ServiceManagerNative.java)  取得 ServiceManager 的代理類並添加服務
        
    ```java=
    // ServiceManager.java

    public static void addService(String name, IBinder service) {
        addService(name, service, false, IServiceManager.DUMP_FLAG_PRIORITY_DEFAULT);
    }

    // 最終呼叫到這個方法
    public static void addService(String name, IBinder service, boolean allowIsolated,
            int dumpPriority) {
        try {
            // getIServiceManager 返回 ServiceManagerNative
            getIServiceManager().addService(name, service, allowIsolated, dumpPriority);
        } /* 省略 catch */
    }

    private static IServiceManager getIServiceManager() {
        if (sServiceManager != null) {
            return sServiceManager;
        }

        // Find the service manager
        sServiceManager = ServiceManagerNative
                .asInterface(Binder.allowBlocking(BinderInternal.getContextObject()));
        return sServiceManager;
    }
    ```

    * PackageManagerService 就是使用 ServiceManager#addService 方法註冊 `package`、`package_native` 服務

        ```java=
        // PackageManagerService.java

            public static PackageManagerService main(Context context, Installer installer,
                    @NonNull DomainVerificationService domainVerificationService, boolean factoryTest,
                    boolean onlyCore) {
                ... 省略

                PackageManagerService m = new PackageManagerService(injector, onlyCore, factoryTest,
                        Build.FINGERPRINT, Build.IS_ENG, Build.IS_USERDEBUG, Build.VERSION.SDK_INT,
                        Build.VERSION.INCREMENTAL);

                ... 省略

                ServiceManager.addService("package", m);
                final PackageManagerNative pmn = m.new PackageManagerNative();
                ServiceManager.addService("package_native", pmn);

                return m;
            }
        ```


### 管理 Java 服務 - [SystemServiceManager](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/services/core/java/com/android/server/SystemServiceManager.java)

* 啟動 Java 服務大多是靠 SystemServiceManager 類管理：透過 `SystemServiceManager` 就可以找到 `SystemService` 中 的服務 (類似於 DNS 功能)

    ```java=
    // SystemServiceManager.java

        private final ArrayList<SystemService> mServices = new ArrayList<SystemService>();

        public <T extends SystemService> T startService(Class<T> serviceClass) {
            try {
                final String name = serviceClass.getName();

                // 判斷傳入的 class 是否繼承於 SystemService
                if (!SystemService.class.isAssignableFrom(serviceClass)) {
                    throw new RuntimeException("Failed to create " + name
                            + ": service must extend " + SystemService.class.getName());
                }

                final T service;
                try {
                    Constructor<T> constructor = serviceClass.getConstructor(Context.class);
                    service = constructor.newInstance(mContext);
                } /* 省略 catch */

                // @ 追蹤 startService 方法
                startService(service);
                return service;
            } finally {
                Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
            }
        }

        public void startService(@NonNull final SystemService service) {
            // 緩存
            mServices.add(service);

            // 啟動時間
            long time = SystemClock.elapsedRealtime();
            try {
                // 呼叫生命週期 onStart
                service.onStart();
            } /* 省略 catch */
            warnIfTooLong(SystemClock.elapsedRealtime() - time, service, "onStart");
        }
    ```
    :::info
    * 像是 **LightsService**、**DisplayManager**... 就是使用這種方式
        
        ```java=
        mSystemServiceManager.startService(LightsService.class);

        mDisplayManagerService = mSystemServiceManager.startService(DisplayManagerService.class);
        ```
    :::
    
* 透過 SystemServiceManager#startBootPhase 方法通知其他服務，狀態改變
    :::success
    * SystemServiceManager 是觀察者模式
    :::
    
    ```java=
    // SystemServiceManager.java

        // 管理所有服務！
        private final ArrayList<SystemService> mServices = new ArrayList<SystemService>();

        public void startBootPhase(@NonNull TimingsTraceAndSlog t, int phase) {
        if (phase <= mCurrentPhase) {
            throw new IllegalArgumentException("Next phase must be larger than previous");
        }
        mCurrentPhase = phase;

        Slog.i(TAG, "Starting phase " + mCurrentPhase);
        try {
            t.traceBegin("OnBootPhase_" + phase);
            final int serviceLen = mServices.size();
            for (int i = 0; i < serviceLen; i++) {
                final SystemService service = mServices.get(i);
                long time = SystemClock.elapsedRealtime();
                
                t.traceBegin("OnBootPhase_" + phase + "_" + service.getClass().getName());
                try {
                    // 通知目標服務
                    service.onBootPhase(mCurrentPhase);
                } /* 省略 catch */
                
            }
        } finally {
            t.traceEnd();
        }

        if (phase == SystemService.PHASE_BOOT_COMPLETED) {
            final long totalBootTime = SystemClock.uptimeMillis() - mRuntimeStartUptime;
            t.logDuration("TotalBootTime", totalBootTime);
            SystemServerInitThreadPool.shutdown();
        }
    }
    ```
    

## SystemServer 啟動

這裡主要是要看 SystemServer 在啟動的過程中，註冊哪些服務

### SystemServer - Bootstrap 系統服務

* SystemServer#startBootstrapServices 這個函數中會啟動許多服務，**這些服務都是由 ++SystemServiceManager 來統一管理++**，以下介紹幾種常見的

    | 服務 | 功能 |
    | -------- | -------- |
    | Installer | 安裝所有 APK 的服務，啟動完 Install 服務後才能啟動其他服務 |
    | ActivityManagerService | 負責管理 4 大零組件 |
    | PowerManagerService | 計算系統中 Power 相關，以及對應策略 |
    | LigthsService | 管理、顯示 LED |
    | DisplayManagerService | 與 WMS 有關，用來管理該設備的顯示 |
    | UserManagerService | 多用戶模式管理 |
    | SensorService | 各種傳感器服務 |
    | PackageManagerService | APK 卸載、安裝、解析等等操作 |

    最後透過 **AMS#setSystemProcess** 來添加進程相關的服務 (meminfo、gfxinfo、dbinfo、cpuinfo...  等等)，這些服務都可以透過 adb 調用
    ```java=
    // /android/server/SystemServer.java

        private void startBootstrapServices(@NonNull TimingsTraceAndSlog t) {
            ... 省略部分

            mSystemServiceManager.startService(FileIntegrityService.class);

            Installer installer = mSystemServiceManager.startService(Installer.class);

            mSystemServiceManager.startService(DeviceIdentifiersPolicyService.class);
            t.traceEnd();

            mSystemServiceManager.startService(UriGrantsManagerService.Lifecycle.class);
            startMemtrackProxyService();
            
            ActivityTaskManagerService atm = mSystemServiceManager.startService(
                    ActivityTaskManagerService.Lifecycle.class).getService();
            mActivityManagerService = ActivityManagerService.Lifecycle.startService(
                    mSystemServiceManager, atm);
            mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
            mActivityManagerService.setInstaller(installer);
            mWindowManagerGlobalLock = atm.getGlobalLock();
            
            mDataLoaderManagerService = mSystemServiceManager.startService(
                    DataLoaderManagerService.class);

            mIncrementalServiceHandle = startIncrementalService();

            mPowerManagerService = mSystemServiceManager.startService(PowerManagerService.class);

            mSystemServiceManager.startService(ThermalManagerService.class);

            mActivityManagerService.initPowerManagement();

             mSystemServiceManager.startService(RecoverySystemService.Lifecycle.class);

            
            
            ... 省略部分
            mDisplayManagerService = mSystemServiceManager.startService(DisplayManagerService.class);
            t.traceEnd();
            
            ... 省略部分
                
            mActivityManagerService.setSystemProcess();
            
            ...省略部分
        }
    ```
    
## Appendix & FAQ

:::info
:::

###### tags: `Android 系統`
