Android系统启动——SystemServer

Posted 2022-02-01 cao_null

继续分析SystemServer

基于android Oreo 8

涉及代码位置

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

/frameworks/base/core/java/android/app/ActivityThread.java

/frameworks/base/core/java/android/app/ActivityManager.java

/frameworks/base/services/core/java/com/android/server/SystemServiceManager.java

/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java

上一次说到了SystemServer的main方法

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


public final class SystemServer 


    private void run() 
        try 
            traceBeginAndSlog("InitBeforeStartServices");
            //检查时间，不能比1970年更早
            if (System.currentTimeMillis() < EARLIEST_SUPPORTED_TIME) 
                Slog.w(TAG, "System clock is before 1970; setting to 1970.");
                SystemClock.setCurrentTimeMillis(EARLIEST_SUPPORTED_TIME);
            

            //设置默认时区
            String timezoneProperty =  SystemProperties.get("persist.sys.timezone");
            if (timezoneProperty == null || timezoneProperty.isEmpty()) 
                Slog.w(TAG, "Timezone not set; setting to GMT.");
                SystemProperties.set("persist.sys.timezone", "GMT");
            

            //语言
            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", "");
            

            // The system server should never make non-oneway calls
            Binder.setWarnOnBlocking(true);

            // Here we go!
            Slog.i(TAG, "Entered the Android system server!");
            int uptimeMillis = (int) SystemClock.elapsedRealtime();
            EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_SYSTEM_RUN, uptimeMillis);
            if (!mRuntimeRestart) 
                MetricsLogger.histogram(null, "boot_system_server_init", uptimeMillis);
            

            // 虚拟机库文件
            SystemProperties.set("persist.sys.dalvik.vm.lib.2", VMRuntime.getRuntime().vmLibrary());

            //开启性能profiler
            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);
            

            // Mmmmmm... more memory!
            //注释很清楚了，清楚内存增长上限
            VMRuntime.getRuntime().clearGrowthLimit();

            // system server常驻内存，所以设置内存利用率0.8
            VMRuntime.getRuntime().setTargetHeapUtilization(0.8f);

            // 先生成指纹
            Build.ensureFingerprintProperty();

            // Within the system server, it is an error to access Environment paths without
            // explicitly specifying a user.
            Environment.setUserRequired(true);

            // Within the system server, any incoming Bundles should be defused
            // to avoid throwing BadParcelableException.
            BaseBundle.setShouldDefuse(true);

            // 确保binder优先级运行再前台.
            BinderInternal.disableBackgroundScheduling(true);

            //binder线程池最大数量
            BinderInternal.setMaxThreads(sMaxBinderThreads);

            // 准备main looper线程
            android.os.Process.setThreadPriority(
                android.os.Process.THREAD_PRIORITY_FOREGROUND);
            android.os.Process.setCanSelfBackground(false);
            Looper.prepareMainLooper();

            // 初始化 native services.
            System.loadLibrary("android_servers");

            //检查上次关机是否失败，可能不会返回
            performPendingShutdown();

            // 初始化system context.
            createSystemContext();

            // 创建system service manager.
            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
        

        //启动各种需要的服务
        try 
            traceBeginAndSlog("StartServices");
            //引导服务
            startBootstrapServices();
            //核心服务
            startCoreServices();
            //其他服务
            startOtherServices();
            SystemServerInitThreadPool.shutdown();
         catch (Throwable ex) 
            Slog.e("System", "******************************************");
            Slog.e("System", "************ Failure starting system services", ex);
            throw ex;
         finally 
            traceEnd();
        

        // For debug builds, log event loop stalls to dropbox for analysis.
        if (StrictMode.conditionallyEnableDebugLogging()) 
            Slog.i(TAG, "Enabled StrictMode for system server main thread.");
        
        //打印启动时间
        if (!mRuntimeRestart && !isFirstBootOrUpgrade()) 
            int uptimeMillis = (int) SystemClock.elapsedRealtime();
            MetricsLogger.histogram(null, "boot_system_server_ready", uptimeMillis);
            final int MAX_UPTIME_MILLIS = 60 * 1000;
            if (uptimeMillis > MAX_UPTIME_MILLIS) 
                Slog.wtf(SYSTEM_SERVER_TIMING_TAG,
                        "SystemServer init took too long. uptimeMillis=" + uptimeMillis);
            
        

        //永远在Loop
        Looper.loop();
        //走到这说明出异常了
        throw new RuntimeException("Main thread loop unexpectedly exited");
    

createSystemContext

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

private void createSystemContext() 
        ActivityThread activityThread = ActivityThread.systemMain();
        
        mSystemContext = activityThread.getSystemContext();
        //设置主题
        mSystemContext.setTheme(DEFAULT_SYSTEM_THEME);

        final Context systemUiContext = activityThread.getSystemUiContext();
        systemUiContext.setTheme(DEFAULT_SYSTEM_THEME);
    

//frameworks/base/core/java/android/app/ActivityThread.java

public static ActivityThread systemMain() 
        // The system process on low-memory devices do not get to use hardware
        // accelerated drawing, since this can add too much overhead to the
        // process.
        //根据内存大小判断是否开启硬件加速
        if (!ActivityManager.isHighEndGfx()) 
            ThreadedRenderer.disable(true);
         else 
            ThreadedRenderer.enableForegroundTrimming();
        
        ActivityThread thread = new ActivityThread();
        //这个重点分析
        thread.attach(true);
        return thread;
    

//frameworks/base/core/java/android/app/ActivityManager.java

/**
     * Used by persistent processes to determine if they are running on a
     * higher-end device so should be okay using hardware drawing acceleration
     * (which tends to consume a lot more RAM).
     * @hide
     */
    static public boolean isHighEndGfx() 
        return !isLowRamDeviceStatic() &&
                !Resources.getSystem().getBoolean(com.android.internal.R.bool.config_avoidGfxAccel);
    


//frameworks/base/core/java/android/app/ActivityThread.java
//返回一个SystemContext
public ContextImpl getSystemContext() 
        synchronized (this) 
            if (mSystemContext == null) 
                mSystemContext = ContextImpl.createSystemContext(this);
            
            return mSystemContext;
        
    

SystemServer在这初始化了一些UI相关的设置，然后看thread.attach(true);

/frameworks/base/core/java/android/app/ActivityThread.java


private void attach(boolean system) 
        sCurrentActivityThread = this;
        mSystemThread = system;
        if (!system) 
            ...//普通进程省略
         else 
            // Don't set application object here -- if the system crashes,
            // we can't display an alert, we just want to die die die.
            android.ddm.DdmHandleAppName.setAppName("system_process",
                    UserHandle.myUserId());
            try 
                //创建Instrumentation
                mInstrumentation = new Instrumentation();
                //创建ContextImpl
                ContextImpl context = ContextImpl.createAppContext(
                        this, getSystemContext().mPackageInfo);
                //创建InitialApplication
                mInitialApplication = context.mPackageInfo.makeApplication(true, null);
                mInitialApplication.onCreate();
             catch (Exception e) 
                throw new RuntimeException(
                        "Unable to instantiate Application():" + e.toString(), e);
            
        

        // add dropbox logging to libcore
        DropBox.setReporter(new DropBoxReporter());
        //配置变化回调
        ViewRootImpl.ConfigChangedCallback configChangedCallback
                = (Configuration globalConfig) -> 
            synchronized (mResourcesManager) 
                // We need to apply this change to the resources immediately, because upon returning
                // the view hierarchy will be informed about it.
                if (mResourcesManager.applyConfigurationToResourcesLocked(globalConfig,
                        null /* compat */)) 
                    updateLocaleListFromAppContext(mInitialApplication.getApplicationContext(),
                            mResourcesManager.getConfiguration().getLocales());

                    // This actually changed the resources! Tell everyone about it.
                    if (mPendingConfiguration == null
                            || mPendingConfiguration.isOtherSeqNewer(globalConfig)) 
                        mPendingConfiguration = globalConfig;
                        //handler发消息
                        sendMessage(H.CONFIGURATION_CHANGED, globalConfig);
                    
                
            
        ;
        ViewRootImpl.addConfigCallback(configChangedCallback);
    

接下来是startBootstrapServices

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


    private void startBootstrapServices() 
        Slog.i(TAG, "Reading configuration...");
        final String TAG_SYSTEM_CONFIG = "ReadingSystemConfig";
        traceBeginAndSlog(TAG_SYSTEM_CONFIG);
        SystemServerInitThreadPool.get().submit(SystemConfig::getInstance, TAG_SYSTEM_CONFIG);
        traceEnd();

        //等待Installer启动完成，因为需要它的权限创建关键目录例如/data/user。初始化其他服务需要等待Installer操作完成
        traceBeginAndSlog("StartInstaller");
        Installer installer = mSystemServiceManager.startService(Installer.class);
        traceEnd();

        // 在某些情况下启动一个应用程序后,我们需要访问设备标识符,
        // 所以在启动AMS之前需要先注册设备标识符
        traceBeginAndSlog("DeviceIdentifiersPolicyService");
        mSystemServiceManager.startService(DeviceIdentifiersPolicyService.class);
        traceEnd();

        // AMS启动
        traceBeginAndSlog("StartActivityManager");
        mActivityManagerService = mSystemServiceManager.startService(
                ActivityManagerService.Lifecycle.class).getService();
        mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
        mActivityManagerService.setInstaller(installer);
        traceEnd();

        // Power 管理启动
        traceBeginAndSlog("StartPowerManager");
        mPowerManagerService = mSystemServiceManager.startService(PowerManagerService.class);
        traceEnd();

        // 跟AMS关联
        traceBeginAndSlog("InitPowerManagement");
        mActivityManagerService.initPowerManagement();
        traceEnd();

        //recovery Service
        if (!SystemProperties.getBoolean("config.disable_noncore", false)) 
            traceBeginAndSlog("StartRecoverySystemService");
            mSystemServiceManager.startService(RecoverySystemService.class);
            traceEnd();
        

        // Now that we have the bare essentials of the OS up and running, take
        // note that we just booted, which might send out a rescue party if
        // we're stuck in a runtime restart loop.
        RescueParty.noteBoot(mSystemContext);

        // Manages LEDs and display backlight so we need it to bring up the display.
        traceBeginAndSlog("StartLightsService");
        mSystemServiceManager.startService(LightsService.class);
        traceEnd();

        // Display manager is needed to provide display metrics before package manager
        // starts up.
        traceBeginAndSlog("StartDisplayManager");
        mDisplayManagerService = mSystemServiceManager.startService(DisplayManagerService.class);
        traceEnd();

        // We need the default display before we can initialize the package manager.
        traceBeginAndSlog("WaitForDisplay");
        mSystemServiceManager.startBootPhase(SystemService.PHASE_WAIT_FOR_DEFAULT_DISPLAY);
        traceEnd();

        // 加密时只运行core
        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;
        

        // 启动PMS
        if (!mRuntimeRestart) 
            MetricsLogger.histogram(null, "boot_package_manager_init_start",
                    (int) SystemClock.elapsedRealtime());
        
        traceBeginAndSlog("StartPackageManagerService");
        mPackageManagerService = PackageManagerService.main(mSystemContext, installer,
                mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF, mOnlyCore);
        mFirstBoot = mPackageManagerService.isFirstBoot();
        mPackageManager = mSystemContext.getPackageManager();
        traceEnd();
        if (!mRuntimeRestart && !isFirstBootOrUpgrade()) 
            MetricsLogger.histogram(null, "boot_package_manager_init_ready",
                    (int) SystemClock.elapsedRealtime());
        
        // Manages A/B OTA dexopting. This is a bootstrap service as we need it to rename
        // A/B artifacts after boot, before anything else might touch/need them.
        // Note: this isn't needed during decryption (we don't have /data anyways).
        if (!mOnlyCore) 
            boolean disableOtaDexopt = SystemProperties.getBoolean("config.disable_otadexopt",
                    false);
            if (!disableOtaDexopt) 
                traceBeginAndSlog("StartOtaDexOptService");
                try 
                    OtaDexoptService.main(mSystemContext, mPackageManagerService);
                 catch (Throwable e) 
                    reportWtf("starting OtaDexOptService", e);
                 finally 
                    traceEnd();
                
            
        

        traceBeginAndSlog("StartUserManagerService");
        mSystemServiceManager.startService(UserManagerService.LifeCycle.class);
        traceEnd();

        // Initialize attribute cache used to cache resources from packages.
        traceBeginAndSlog("InitAttributerCache");
        AttributeCache.init(mSystemContext);
        traceEnd();

        // Set up the Application instance for the system process and get started.
        traceBeginAndSlog("SetSystemProcess");
        mActivityManagerService.setSystemProcess();
        traceEnd();

        // DisplayManagerService needs to setup android.display scheduling related policies
        // since setSystemProcess() would have overridden policies due to setProcessGroup
        mDisplayManagerService.setupSchedulerPolicies();

        // Overlay服务
        traceBeginAndSlog("StartOverlayManagerService");
        mSystemServiceManager.startService(new OverlayManagerService(mSystemContext, installer));
        traceEnd();

        // 启动Sensor
        mSensorServiceStart = SystemServerInitThreadPool.get().submit(() -> 
            BootTimingsTraceLog traceLog = new BootTimingsTraceLog(
                    SYSTEM_SERVER_TIMING_ASYNC_TAG, Trace.TRACE_TAG_SYSTEM_SERVER);
            traceLog.traceBegin(START_SENSOR_SERVICE);
            startSensorService();
            traceLog.traceEnd();
        , START_SENSOR_SERVICE);
    

    

然后是CoreServices

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


/**
     * Starts some essential services that are not tangled up in the bootstrap process.
     */
    private void startCoreServices() 
        // Records errors and logs, for example wtf()
        traceBeginAndSlog("StartDropBoxManager");
        mSystemServiceManager.startService(DropBoxManagerService.class);
        traceEnd();

        traceBeginAndSlog("StartBatteryService");
        // 电池服务
        mSystemServiceManager.startService(BatteryService.class);
        traceEnd();

        // 用户统计
        traceBeginAndSlog("StartUsageService");
        mSystemServiceManager.startService(UsageStatsService.class);
        mActivityManagerService.setUsageStatsManager(
                LocalServices.getService(UsageStatsManagerInternal.class));
        traceEnd();

        // WebView相关
        traceBeginAndSlog("StartWebViewUpdateService");
        mWebViewUpdateService = mSystemServiceManager.startService(WebViewUpdateService.class);
        traceEnd();
    

最后是OtherServices

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


/**
     * Starts a miscellaneous grab bag of stuff that has yet to be refactored
     * and organized.
     */
    private void startOtherServices() 
        final Context context = mSystemContext;
        VibratorService vibrator = null;
        IStorageManager storageManager = null;
        NetworkManagementService networkManagement = null;
        NetworkStatsService networkStats = null;
        NetworkPolicyManagerService networkPolicy = null;
        ConnectivityService connectivity = null;
        NetworkScoreService networkScore = null;
        NsdService serviceDiscovery= null;
        //熟悉的WMS这时候才启动
        WindowManagerService wm = null;
        SerialService serial = null;
        NetworkTimeUpdateService networkTimeUpdater = null;
        CommonTimeManagementService commonTimeMgmtService = null;
        InputManagerService inputManager = null;
        TelephonyRegistry telephonyRegistry = null;
        ConsumerIrService consumerIr = null;
        MmsServiceBroker mmsService = null;
        HardwarePropertiesManagerService hardwarePropertiesService = 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);
        boolean disableSystemUI = SystemProperties.getBoolean("config.disable_systemui", false);
        boolean disableNonCoreServices = SystemProperties.getBoolean("config.disable_noncore", false);

...

看下具体启动的方法

//frameworks/base/services/core/java/com/android/server/SystemServiceManager.java



@SuppressWarnings("unchecked")
    public SystemService startService(String className) 
        final Class<SystemService> serviceClass;
        try 
            serviceClass = (Class<SystemService>)Class.forName(className);
         catch (ClassNotFoundException ex) 
            Slog.i(TAG, "Starting " + className);
            throw new RuntimeException("Failed to create service " + className
                    + ": service class not found, usually indicates that the caller should "
                    + "have called PackageManager.hasSystemFeature() to check whether the "
                    + "feature is available on this device before trying to start the "
                    + "services that implement it", ex);
        
        return startService(serviceClass);
    

    /**
     * Creates and starts a system service. The class must be a subclass of
     * @link com.android.server.SystemService.
     *
     * @param serviceClass A Java class that implements the SystemService interface.
     * @return The service instance, never null.
     * @throws RuntimeException if the service fails to start.
     */
    @SuppressWarnings("unchecked")
    public <T extends SystemService> T startService(Class<T> serviceClass) 
        try 
            final String name = serviceClass.getName();
            Slog.i(TAG, "Starting " + name);
            Trace.traceBegin(Trace.TRACE_TAG_SYSTEM_SERVER, "StartService " + name);

            // Create the service.
            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 (InstantiationException ex) 
                throw new RuntimeException("Failed to create service " + name
                        + ": service could not be instantiated", ex);
             catch (IllegalAccessException ex) 
                throw new RuntimeException("Failed to create service " + name
                        + ": service must have a public constructor with a Context argument", ex);
             catch (NoSuchMethodException ex) 
                throw new RuntimeException("Failed to create service " + name
                        + ": service must have a public constructor with a Context argument", ex);
             catch (InvocationTargetException ex) 
                throw new RuntimeException("Failed to create service " + name
                        + ": service constructor threw an exception", ex);
            

            startService(service);
            return service;
         finally 
            Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
        
    

    public void startService(@NonNull final SystemService service) 
        // Register it.
        mServices.add(service);
        // Start it.
        long time = System.currentTimeMillis();
        try 
            //调用onStart
            service.onStart();
         catch (RuntimeException ex) 
            throw new RuntimeException("Failed to start service " + service.getClass().getName()
                    + ": onStart threw an exception", ex);
        
        warnIfTooLong(System.currentTimeMillis() - time, service, "onStart");
    

AMS本身没有继承

//frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java

public static final class Lifecycle extends SystemService 
        private final ActivityManagerService mService;

        public Lifecycle(Context context) 
            super(context);
            mService = new ActivityManagerService(context);
        

        //调用AMS的start
        @Override
        public void onStart() 
            mService.start();
        

        @Override
        public void onBootPhase(int phase) 
            mService.mBootPhase = phase;
            if (phase == PHASE_SYSTEM_SERVICES_READY) 
                mService.mBatteryStatsService.systemServicesReady();
                mService.mServices.systemServicesReady();
            
        

        @Override
        public void onCleanupUser(int userId) 
            mService.mBatteryStatsService.onCleanupUser(userId);
        

        //返回AMS
        public ActivityManagerService getService() 
            return mService;
        
    

至此SystemServer启动流程基本分析完毕