源码分析之SystemServer流程分析2

发表于 | 更新于 | 分类于
本文字数： 15k | 阅读时长 ≈ 14 分钟

SystemServer启动流程分析2

前言

  • 由 Zygote 启动到 SystemServer 的过程主要如下：在 RuntimeInit.java 中invokeStaticMain方法通过创建并抛出异常 ZygoteInit.MethodAndArgsCaller ，在 ZygoteInit.java 中的 main() 方法会捕捉该异常，并调用 caller.run() ，再通过反射便会调用到 SystemServer.main() 方法，该方法主要执行流程：

    SystemServer.main
    SystemServer.run
        createSystemContext();
        startBootstrapServices();
        startCoreServices();
        startOtherServices();
        Looper.loop();

具体流程

  • 服务的具体启动流程一览图如下：

  • main

    –> frameworks/base/services/java/com/android/server/SystemServer.java

    public static void main(String[] args) {
        // 先初始化SystemServer对象，在调用器run()方法
        new SystemServer().run();
    }
ZygoteInit 通过反射调用 SystemServer 的 main 方法，执行到此。

  • run()

    private void run() {

    // 系统时间早于1970，设置系统时间1970
    if (System.currentTimeMillis() < EARLIEST_SUPPORTED_TIME) {
        Slog.w(TAG, "System clock is before 1970; setting to 1970.");
        SystemClock.setCurrentTimeMillis(EARLIEST_SUPPORTED_TIME);
    }

    // core/jni/AndroidRuntime.cpp
    if (!SystemProperties.get("persist.sys.language").isEmpty()) {
        final String languageTag = Locale.getDefault().toLanguageTag();

        SystemProperties.set("persist.sys.locale", languageTag);
        SystemProperties.set("persist.sys.language", "");
        SystemProperties.set("persist.sys.country", "");
        SystemProperties.set("persist.sys.localevar", "");
    }

    // 变更虚拟机的库文件，对于Android6.0默认采用libart.so
    SystemProperties.set("persist.sys.dalvik.vm.lib.2", VMRuntime.getRuntime().vmLibrary());

    // 启用性能统计
    if (SamplingProfilerIntegration.isEnabled()) {
        SamplingProfilerIntegration.start();
        mProfilerSnapshotTimer = new Timer();
        mProfilerSnapshotTimer.schedule(new TimerTask() {
            @Override
            public void run() {
                SamplingProfilerIntegration.writeSnapshot("system_server", null);
            }
        }, SNAPSHOT_INTERVAL, SNAPSHOT_INTERVAL);
    }

    // 清除vm内存增长上限，由于启动过程需要更多的虚拟机内存空间
    VMRuntime.getRuntime().clearGrowthLimit();

    // The system server has to run all of the time, so it needs to be
    // 设置内存可能有效使用率0.8
    VMRuntime.getRuntime().setTargetHeapUtilization(0.8f);

    // 针对部分设备依赖运行时就产生指纹信息，因此需要在开机完成前已经定义
    Build.ensureFingerprintProperty();

    // 访问环境变量前，需要明确的指定用户
    Environment.setUserRequired(true);

    // 确保当前系统进程的binder调用，总是在运行在前台优先级
    BinderInternal.disableBackgroundScheduling(true);

    android.os.Process.setThreadPriority(
            android.os.Process.THREAD_PRIORITY_FOREGROUND);
    android.os.Process.setCanSelfBackground(false);

    // 主线程looper就在当前线程运行
    Looper.prepareMainLooper();

    // 加载Android.servers.so库
    System.loadLibrary("android_servers");

    // 检测上次关机过程是否失败
    performPendingShutdown();

    // 初始化系统上下文
    createSystemContext();

    // 创建系统服务管理通过反射开启相应类的服务
    mSystemServiceManager = new SystemServiceManager(mSystemContext);
    // 将mSystemServiceManager添加到本地服务的成员sLocalServiceObjects
    LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);

    // Start services.
    try {
        // 启动引导服务
        startBootstrapServices();

        // 启动核心服务
        startCoreServices();

        // 启动其他服务
        startOtherServices();

    } catch (Throwable ex) {
        Slog.e("System", "******************************************");
        Slog.e("System", "************ Failure starting system services", ex);
        throw ex;
    }

    // 用于debug版本，将log事件不断循环地输出到dropbox（用于分析）
    if (StrictMode.conditionallyEnableDebugLogging()) {
        Slog.i(TAG, "Enabled StrictMode for system server main thread.");
    }

    // 一直循环执行
    Looper.loop();
    throw new RuntimeException("Main thread loop unexpectedly exited");
}

    通过代码我们发现其主要方法如下：

    1. 监测异常关机 performPendingShutdown()
    2. 创建系统上下文 createSystemContext()
    3. 启动引导服务 startBootstrapServices()
    4. 启动核心服务 startCoreServices()
    5. 启动其他服务 startOtherServices()
    6. 消息循环，等待处理 Looper.loop()

  • 异常关机监测处理

    private void performPendingShutdown() {
    final String shutdownAction = SystemProperties.get(
            ShutdownThread.SHUTDOWN_ACTION_PROPERTY, "");
    if (shutdownAction != null && shutdownAction.length() > 0) {
        boolean reboot = (shutdownAction.charAt(0) == '1');

        final String reason;
        if (shutdownAction.length() > 1) {
            reason = shutdownAction.substring(1, shutdownAction.length());
        } else {
            reason = null;
        }
        // 当"sys.shutdown.requested"的值不为空，则重启或者关机
        ShutdownThread.rebootOrShutdown(null, reboot, reason);
    }
}

    通过系统属性值 “sys.shutdown.requested” 来监测关机是否异常。

  • createSystemContext

    private void createSystemContext() {
    // 创建system_server进程的上下文信息
    ActivityThread activityThread = ActivityThread.systemMain();
    mSystemContext = activityThread.getSystemContext();
    // 设置主题
    mSystemContext.setTheme(android.R.style.Theme_DeviceDefault_Light_DarkActionBar);
}

    系统上下文通过 ActivityThread 实例创建，该过程会创建对象有 Instrumentation, ContextImpl，LoadedApk，Application 等。

  • 启动相关引导服务

    private void startBootstrapServices() {

    // 阻塞等待与installd建立socket通道
    Installer installer = mSystemServiceManager.startService(Installer.class);

    mActivityManagerService = mSystemServiceManager.startService(
            ActivityManagerService.Lifecycle.class).getService();
    mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
    mActivityManagerService.setInstaller(installer);

    mPowerManagerService = mSystemServiceManager.startService(PowerManagerService.class);

    mActivityManagerService.initPowerManagement();

    mSystemServiceManager.startService(LightsService.class);

    mDisplayManagerService = mSystemServiceManager.startService(DisplayManagerService.class);
    mSystemServiceManager.startBootPhase(SystemService.PHASE_WAIT_FOR_DEFAULT_DISPLAY);

    // 当设备正在加密时，仅运行核心
    String cryptState = SystemProperties.get("vold.decrypt");
    if (ENCRYPTING_STATE.equals(cryptState)) {
        Slog.w(TAG, "Detected encryption in progress - only parsing core apps");
        mOnlyCore = true;
    } else if (ENCRYPTED_STATE.equals(cryptState)) {
        Slog.w(TAG, "Device encrypted - only parsing core apps");
        mOnlyCore = true;
    }

    // Start the package manager.
    Slog.i(TAG, "Package Manager");
    mPackageManagerService = PackageManagerService.main(mSystemContext, installer,
            mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF, mOnlyCore);
    mFirstBoot = mPackageManagerService.isFirstBoot();
    mPackageManager = mSystemContext.getPackageManager();

    Slog.i(TAG, "User Service");
    ServiceManager.addService(Context.USER_SERVICE, UserManagerService.getInstance());

    AttributeCache.init(mSystemContext);

    // 设置AMS
    mActivityManagerService.setSystemProcess();

    // 启动传感器服务
    startSensorService();
}

    通览代码，其主要启动以下几个系统关键服务：

    1. ActivityManagerService
    2. PowerManagerService
    3. LightsService
    4. DisplayManagerService
    5. PackageManagerService
    6. UserManagerService

    7. sensor传感器服务

  • 启动系统关键服务

    private void startCoreServices() {
    // 用于统计电池电量
    mSystemServiceManager.startService(BatteryService.class);

    //用于统计应用使用情况
    mSystemServiceManager.startService(UsageStatsService.class);
    mActivityManagerService.setUsageStatsManager(
            LocalServices.getService(UsageStatsManagerInternal.class));

    mPackageManagerService.getUsageStatsIfNoPackageUsageInfo();

    // Tracks whether the updatable WebView is in a ready state and watches for update installs.
    mSystemServiceManager.startService(WebViewUpdateService.class);
}

    以上主要启动服务有： BatteryService，UsageStatsService，WebViewUpdateService。

  • 启动其他相关服务

    待系统关键服务启动起来之后，就需要将其他相关服务启动起来，例如：窗口管理，网络服务，电话服务等。

    private void startOtherServices() {

 // 若干服务变量声明
 final Context context = mSystemContext;
 AccountManagerService accountManager = null;
 ContentService contentService = null;

 ...

 // 若干配置量获取
 boolean disableStorage = SystemProperties.getBoolean("config.disable_storage", false);
 boolean disableBluetooth = SystemProperties.getBoolean("config.disable_bluetooth", false);
 boolean disableLocation = SystemProperties.getBoolean("config.disable_location", false);

 // 启动相关服务
 try {
     SystemConfig.getInstance();

     ServiceManager.addService("scheduling_policy", new SchedulingPolicyService());
     mSystemServiceManager.startService(TelecomLoaderService.class);

     ...

     // 初始化看门狗服务
     final Watchdog watchdog = Watchdog.getInstance();
     watchdog.init(context, mActivityManagerService);

     //创建InputManager，用于下面初始化WindowManagerService
     inputManager = new InputManagerService(context);

     //调用WindowManagerService的main方法初始化
     wm = WindowManagerService.main(context, inputManager,
             mFactoryTestMode != FactoryTest.FACTORY_TEST_LOW_LEVEL,
             !mFirstBoot, mOnlyCore);
     ServiceManager.addService(Context.WINDOW_SERVICE, wm);
     ServiceManager.addService(Context.INPUT_SERVICE, inputManager);

     mActivityManagerService.setWindowManager(wm);

     inputManager.setWindowManagerCallbacks(wm.getInputMonitor());
     // 启动InputManager
     inputManager.start();

 try {
     wm.displayReady();
 } catch (Throwable e) {
     reportWtf("making display ready", e);
 }

 ...

     // 根据配置，初始化若干服务
     if (!disableNetwork) {
         try {
             Slog.i(TAG, "NetworkManagement Service");
             networkManagement = NetworkManagementService.create(context);
             ServiceManager.addService(Context.NETWORKMANAGEMENT_SERVICE, networkManagement);
         } catch (Throwable e) {
             reportWtf("starting NetworkManagement Service", e);
         }
     }

   ...

     // 安全模式判定
        final boolean safeMode = wm.detectSafeMode();
 if (safeMode) {
     mActivityManagerService.enterSafeMode();
     VMRuntime.getRuntime().disableJitCompilation();
 } else {

     VMRuntime.getRuntime().startJitCompilation();
 }

 try {
     vibrator.systemReady();
     } catch (Throwable e) {
         reportWtf("making Vibrator Service ready", e);
     }
 mSystemServiceManager.startBootPhase(SystemService.PHASE_LOCK_SETTINGS_READY);

 mSystemServiceManager.startBootPhase(SystemService.PHASE_SYSTEM_SERVICES_READY);

 try {
     wm.systemReady();
 } catch (Throwable e) {
     reportWtf("making Window Manager Service ready", e);
 }

 if (safeMode) {
     mActivityManagerService.showSafeModeOverlay();
 }

...

mActivityManagerService.systemReady(new Runnable() {
     @Override
     public void run() {

         //启动到阶段550
         mSystemServiceManager.startBootPhase(
                 SystemService.PHASE_ACTIVITY_MANAGER_READY);

         try {
             mActivityManagerService.startObservingNativeCrashes();
         } catch (Throwable e) {
             reportWtf("observing native crashes", e);
         }

        WebViewFactory.prepareWebViewInSystemServer();

         // 启动SystemUI
         try {
             startSystemUi(context);
         } catch (Throwable e) {
             reportWtf("starting System UI", e);
         }

         // 相关服务回掉进入 systemReady() 状态
         try {
             if (networkScoreF != null) networkScoreF.systemReady();
         } catch (Throwable e) {
             reportWtf("making Network Score Service ready", e);
         }

        ...

         // 开启看门狗服务
         Watchdog.getInstance().start();

                mSystemServiceManager.startBootPhase(
                        SystemService.PHASE_THIRD_PARTY_APPS_CAN_START);

                // 相关服务回掉进入 systemRunning() 状态
                try {
                    if (wallpaperF != null) wallpaperF.systemRunning();
                } catch (Throwable e) {
                    reportWtf("Notifying WallpaperService running", e);
                }

               ...

            }
        });
    }

在启动其他服务时，SystemServiceManager的startBootPhase()贯穿system_server进程的整个启动过程。执行到此, System_server主线程的启动工作总算完成, 进入Looper.loop()状态,等待其他线程通过handler发送消息到主线再处理。

服务启动阶段分析

  • 系统服务的启动过程中，全程由 SystemServiceManager的startBootPhase()贯穿， 具体阶段内容引用 Gityuan博客中的图片：

  1. PHASE_WAIT_FOR_DEFAULT_DISPLAY = 100

    启动系统四大引导服务：

    ActivityManagerService
PowerManagerService
LightsService
DisplayManagerService

  2. PHASE_SYSTEM_SERVICES_READY = 100

    进入阶段 PHASE_WAIT_FOR_DEFAULT_DISPLAY = 100 回调服务 DisplayManagerService ，然后创建大量服务下面列举部分:

    PackageManagerService
    WindowManagerService
    InputManagerService
    NetworkManagerService
    …

  3. PHASE_LOCK_SETTINGS_READY = 480

    进入阶段 PHASE_LOCK_SETTINGS_READY = 480 回调服务 DevicePolicyManagerService，此部分服务可以获取系统配置数据，然后立即进入 500 状态

  4. PHASE_SYSTEM_SERVICES_READY = 500

    进入该阶段服务能安全地调用核心系统服务，例如 PowerManager 或者 PackageManager

    AlarmManagerService
JobSchedulerService
NotificationManagerService
BackupManagerService
UsageStatsService
DeviceIdleController
TrustManagerService

UiModeManagerService
BluetoothService
BluetoothManagerService
EthernetService
WifiP2pService
WifiScanningService
WifiService
...

    各大服务执行systemReady():

    WindowManagerService.systemReady();
PowerManagerService.systemReady();
PackageManagerService.systemReady();
DisplayManagerService.systemReady();

    接下来就绪 AMS.systemReady 方法

  • PHASE_ACTIVITY_MANAGER_READY

    进入 PHASE_ACTIVITY_MANAGER_READY = 550， AMS.mSystemReady = true, 已准备就绪,进入该阶段服务能广播Intent;但是system_server主线程并没有就绪

    MountService
TelecomLoaderService
UsbService
WebViewUpdateService
DockObserver
BatteryService

    接下来执行: (AMS启动native crash监控, 加载WebView，启动SystemUi等),如下

    mActivityManagerService.startObservingNativeCrashes();
WebViewFactory.prepareWebViewInSystemServer();

startSystemUi(context);
networkScoreF.systemReady();
networkManagementF.systemReady();
networkStatsF.systemReady();
networkPolicyF.systemReady();
connectivityF.systemReady();
audioServiceF.systemReady();
Watchdog.getInstance().start();

  • PHASE_THIRD_PARTY_APPS_CAN_START

    进入此阶段 PHASE_THIRD_PARTY_APPS_CAN_START = 600， 服务可以开启绑定其他app，Apps可以通过Binder与客户端服务通信。

    JobSchedulerService
NotificationManagerService
BackupManagerService
AppWidgetService
GestureLauncherService
DreamManagerService
TrustManagerService
VoiceInteractionManagerService

    接下来,进入各种服务的 systemRunning 过程:

    WallpaperManagerService
InputMethodManagerService
LocationManagerService
CountryDetectorService
...

  • PHASE_BOOT_COMPLETED

    经过一系列流程，再调用AMS.finishBooting()时，进入 PHASE_BOOT_COMPLETED = 1000 阶段，此阶段内服务可以与设备交互，设备完成启动，进入主页程序。

到此，系统服务启动阶段完成就绪，system_server进程启动完成则进入Looper.loop()状态，随时待命，等待消息队列MessageQueue中的消息到来，则马上进入执行状态。

相关说明

在学习源码中，参考了各位大神的博客内容。安卓源码本来就庞大无比，耐着性子慢慢钻研，还是可以消化掉的。这里推荐Gityuan的博客，博客内容针对6.0源码解析，详细周到，十分到位，很适合作为一手的学习资料。

Gityuan博客

坚持原创技术分享，您的支持将鼓励我继续创作！