SystemServer进程——发育篇

最新推荐文章于 2024-08-22 17:07:46 发布
最新推荐文章于 2024-08-22 17:07:46 发布
阅读量338 收藏 1
点赞数
分类专栏： Android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zaojian0848/article/details/101675679
版权
  1. 通过上篇文章的梳理。我们已经了解到，SystemServer 进程启动，是从Zygote 进程的 forkSystemServer () 方法开始，最终走到了，自己的main（入口） 方法。
  2. 接下来，一起看下main中 ，都做了哪些骚操作？

SystemServer 入口 main方法

//SystemServer.java
public static void main(String[] args) {
        new SystemServer().run();
    }
//SystemServer.java
 public SystemServer() {
        // Check for factory test mode.
        mFactoryTestMode = FactoryTest.getMode();
        // Remember if it's runtime restart(when sys.boot_completed is already set) or reboot
        mRuntimeRestart = "1".equals(SystemProperties.get("sys.boot_completed"));

        mRuntimeStartElapsedTime = SystemClock.elapsedRealtime();
        mRuntimeStartUptime = SystemClock.uptimeMillis();
    }
//SystemServer.java    
      private void run() {
        try {
            traceBeginAndSlog("InitBeforeStartServices");
            // If a device's clock is before 1970 (before 0), a lot of
            // APIs crash dealing with negative numbers, notably
            // java.io.File#setLastModified, so instead we fake it and
            // hope that time from cell towers or NTP fixes it shortly.
            //系统时间早于1970 则设置为1970
            if (System.currentTimeMillis() < EARLIEST_SUPPORTED_TIME) {
                Slog.w(TAG, "System clock is before 1970; setting to 1970.");
                SystemClock.setCurrentTimeMillis(EARLIEST_SUPPORTED_TIME);
            }

            //
            // Default the timezone property to GMT if not set.
            //
            //如果没有时区，默认设置为GMT
            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 the system has "persist.sys.language" and friends set, replace them with
            // "persist.sys.locale". Note that the default locale at this point is calculated
            // using the "-Duser.locale" command line flag. That flag is usually populated by
            // AndroidRuntime using the same set of system properties, but only the system_server
            // and system apps are allowed to set them.
            //
            // NOTE: Most changes made here will need an equivalent change to
            // 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", "");
            }

            // The system server should never make non-oneway calls
            Binder.setWarnOnBlocking(true);
            // The system server should always load safe labels
            PackageItemInfo.setForceSafeLabels(true);
            // Deactivate SQLiteCompatibilityWalFlags until settings provider is initialized
            SQLiteCompatibilityWalFlags.init(null);

            // 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);
            }

            // In case the runtime switched since last boot (such as when
            // the old runtime was removed in an OTA), set the system
            // property so that it is in sync. We can | xq oqi't do this in
            // libnativehelper's JniInvocation::Init code where we already
            // had to fallback to a different runtime because it is
            // running as root and we need to be the system user to set
            // the property. http://b/11463182
            //设置当前虚拟机的运行库路径
            SystemProperties.set("persist.sys.dalvik.vm.lib.2", VMRuntime.getRuntime().vmLibrary());

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

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

            // Some devices rely on runtime fingerprint generation, so make sure
            // we've defined it before booting further.
         // 针对部分设备依赖于运行时就产生指纹信息，因此需要在开机完成前已经定义
            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);

            // Within the system server, when parceling exceptions, include the stack trace
            Parcel.setStackTraceParceling(true);

            // Ensure binder calls into the system always run at foreground priority.
            //确保当前系统进程的binder调用，总是运行在前台优先级(foreground priority)
            BinderInternal.disableBackgroundScheduling(true);

            // 增加system_server中绑定器线程的数量 31
            BinderInternal.setMaxThreads(sMaxBinderThreads);
            /****************************looper 设置************************************/ 
            // Prepare the main looper thread (this thread).
            //线程的优先级
            android.os.Process.setThreadPriority(
                android.os.Process.THREAD_PRIORITY_FOREGROUND);
            android.os.Process.setCanSelfBackground(false);
            //主线程Looper
            Looper.prepareMainLooper();
            Looper.getMainLooper().setSlowLogThresholdMs(
                    SLOW_DISPATCH_THRESHOLD_MS, SLOW_DELIVERY_THRESHOLD_MS);

            // Initialize native services.
             //加载android_servers.so库，该库包含的源码在frameworks/base/services/目录下
            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.
            //创建系统上下文
            createSystemContext();

            // Create the system service manager.
            //创建  SystemSerViceManager 
            mSystemServiceManager = new SystemServiceManager(mSystemContext);
            mSystemServiceManager.setStartInfo(mRuntimeRestart,
                    mRuntimeStartElapsedTime, mRuntimeStartUptime);
            //创建的SystemServicemanager 加入到  LocalServices sLocalServiceObjects（ArrayMap<Class<?>, Object>）中
            LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
            // Prepare the thread pool for init tasks that can be parallelized
            //初始化SystemServer 线程池
            SystemServerInitThreadPool.get();
        } finally {
            traceEnd();  // InitBeforeStartServices
        }

        // Start services.
        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();
        }

        StrictMode.initVmDefaults(null);

        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 forever.
        Looper.loop();
        throw new RuntimeException("Main thread loop unexpectedly exited");
    }

Looper.prepareMainLooper()

创建主线程的Looper

createSystemContext

  private void createSystemContext() {
        ActivityThread activityThread = ActivityThread.systemMain();
      //创建系统上下文
        mSystemContext = activityThread.getSystemContext();
        //设置默认主题
        mSystemContext.setTheme(DEFAULT_SYSTEM_THEME);
      

//用于UI的系统上下文。此上下文包含可以主题化的资源。
//确保创建的系统UI上下文与系统上下文共享相同的LoadedApk。
       //创建UI系统上下文
        final Context systemUiContext = activityThread.getSystemUiContext();
        systemUiContext.setTheme(DEFAULT_SYSTEM_THEME);
    }

ActivityThread.systemMain()

创建ActivityThread

//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 并 attach
        ActivityThread thread = new ActivityThread();
        thread.attach(true, 0);
        return thread;
    }
//ActivityThread.java
 private void attach(boolean system, long startSeq) {
        sCurrentActivityThread = this;
        mSystemThread = system;
        if (!system) {
           //XX目前只看else 下代码即可。。
        } 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 {
                mInstrumentation = new Instrumentation();
                //将acitivyThread 赋值给 Instrumentation 对象的 mThread 变量
                mInstrumentation.basicInit(this);
                //创建context的实现类 ContextImpl 
                ContextImpl context = ContextImpl.createAppContext(
                        this, getSystemContext().mPackageInfo);
                //创建application 对象
                mInitialApplication = context.mPackageInfo.makeApplication(true, null);
                //执行application的onCreate() 方法
                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;
                        sendMessage(H.CONFIGURATION_CHANGED, globalConfig);
                    }
                }
            }
        };
        ViewRootImpl.addConfigCallback(configChangedCallback);
    }
private void attach(boolean system, long startSeq)
  1. 创建 Instrumentation 对象
  2. 创建 ContextImpl 对象
  3. 生成Application 对象
  4. 执行Application 的onCreate() 方法
                               attatch()   —— start

在这里插入图片描述

ContextImpl context = ContextImpl.createAppContext(this, getSystemContext().mPackageInfo);

ContextImpl 是 context抽象类 的实现类。包括，activity，Application，Service ，都有它的身影。

//ActivityThread.java
 public ContextImpl getSystemContext() {
        synchronized (this) {
            if (mSystemContext == null) {
                mSystemContext = ContextImpl.createSystemContext(this);
            }
            return mSystemContext;
        }
    }
//ContextImpl.java
 static ContextImpl createSystemContext(ActivityThread mainThread) {
      //创建关于系统包的信息，初始化了部分信息
        LoadedApk packageInfo = new LoadedApk(mainThread);
        //创建 ContextImpl 
        ContextImpl context = new ContextImpl(null, mainThread, packageInfo, null, null, null, 0,
                null);
                //设置资源
        context.setResources(packageInfo.getResources());//更新配置
        context.mResources.updateConfiguration(context.mResourcesManager.getConfiguration(),
        //设置显示尺寸
        context.mResourcesManager.getDisplayMetrics());
        return context;
    }
//ContextImpl.java
static ContextImpl createAppContext(ActivityThread mainThread, LoadedApk packageInfo) {
        if (packageInfo == null) throw new IllegalArgumentException("packageInfo");
        ContextImpl context = new ContextImpl(null, mainThread, packageInfo, null, null, null, 0,
                null);
        context.setResources(packageInfo.getResources());
        return context;
    }

createSystemContext () 和 createAppContext 的区别

  1. createSystemContext —— 默认生成一个 LoadedApk 包对象
  2. createAppContext ——需要一个外界传入 LoadedApk 参数
context.mPackageInfo.makeApplication(true, null);
//LoadApk.java
public Application makeApplication(boolean forceDefaultAppClass,
            Instrumentation instrumentation) {
        if (mApplication != null) {
            return mApplication;
        }

        Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "makeApplication");

        Application app = null;
       
        String appClass = mApplicationInfo.className;
        if (forceDefaultAppClass || (appClass == null)) {
          //类名
            appClass = "android.app.Application";
        }

        try {
        //获取类的classLoader
            java.lang.ClassLoader cl = getClassLoader();
            if (!mPackageName.equals("android")) {
                Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER,
                        "initializeJavaContextClassLoader");
                initializeJavaContextClassLoader();
                Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
            }
            //创建ContextImpl 对象 
            ContextImpl appContext = ContextImpl.createAppContext(mActivityThread, this);
            //创建Application
            app = mActivityThread.mInstrumentation.newApplication(
                    cl, appClass, appContext);
            //contextImpl 是context 的实现类
            //contextImpl 的成员变量 mOuterContext==application        
            appContext.setOuterContext(app);
        } catch (Exception e) {
            if (!mActivityThread.mInstrumentation.onException(app, e)) {
                Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                throw new RuntimeException(
                    "Unable to instantiate application " + appClass
                    + ": " + e.toString(), e);
            }
        }
        //AcitivityThread 维持着一个 集合 ArrayList<Application> mAllApplications
        mActivityThread.mAllApplications.add(app);
        mApplication = app;

        if (instrumentation != null) {
            try {
            // 调动application onCreate() 方法
                instrumentation.callApplicationOnCreate(app);
            } catch (Exception e) {
                if (!instrumentation.onException(app, e)) {
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                    throw new RuntimeException(
                        "Unable to create application " + app.getClass().getName()
                        + ": " + e.toString(), e);
                }
            }
        }

        // Rewrite the R 'constants' for all library apks.
        SparseArray<String> packageIdentifiers = getAssets().getAssignedPackageIdentifiers();
        final int N = packageIdentifiers.size();
        for (int i = 0; i < N; i++) {
            final int id = packageIdentifiers.keyAt(i);
            if (id == 0x01 || id == 0x7f) {
                continue;
            }

            rewriteRValues(getClassLoader(), packageIdentifiers.valueAt(i), id);
        }

        Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);

        return app;
    }

mActivityThread.mInstrumentation.newApplication(
cl, appClass, appContext)

//Instrumenttaion
public Application newApplication(ClassLoader cl, String className, Context context)
            throws InstantiationException, IllegalAccessException, 
            ClassNotFoundException {
            //生成application 对象
        Application app = getFactory(context.getPackageName())
                .instantiateApplication(cl, className);
          //application 关联contextImpl (典型代理模式)
        app.attach(context);
        return app;
    }

1.getFactory(context.getPackageName()) ——通过包名，获取工厂类AppComponentFactory
2.AppComponentFactory.instantiateApplication() ——通过反射 ，生成application 对象实例

                               attatch()  —— end

startBootstrapServices 启动引导服务 service

 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();

        // Wait for installd to finish starting up so that it has a chance to
        // create critical directories such as /data/user with the appropriate
        // permissions.  We need this to complete before we initialize other services.
        traceBeginAndSlog("StartInstaller");
        Installer installer = mSystemServiceManager.startService(Installer.class);
        traceEnd();

        // In some cases after launching an app we need to access device identifiers,
        // therefore register the device identifier policy before the activity manager.
        //注册设备标识符策略   
        traceBeginAndSlog("DeviceIdentifiersPolicyService");
        mSystemServiceManager.startService(DeviceIdentifiersPolicyService.class);
        traceEnd();

        // Activity manager runs the show.
        traceBeginAndSlog("StartActivityManager");
        //启动ActivityManagerService
        mActivityManagerService = mSystemServiceManager.startService(
                ActivityManagerService.Lifecycle.class).getService();
        mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
        mActivityManagerService.setInstaller(installer);
        traceEnd();

        // Power manager needs to be started early because other services need it.
        // Native daemons may be watching for it to be registered so it must be ready
        // to handle incoming binder calls immediately (including being able to verify
        // the permissions for those calls).
          //启动服务PowerManagerService
        traceBeginAndSlog("StartPowerManager");
        mPowerManagerService = mSystemServiceManager.startService(PowerManagerService.class);
        traceEnd();

        // Now that the power manager has been started, let the activity manager
        // initialize power management features.
        traceBeginAndSlog("InitPowerManagement");
        mActivityManagerService.initPowerManagement();
        traceEnd();

        // Bring up recovery system in case a rescue party needs a reboot
        //启动恢复系统，以防救援队伍需要重新启动
        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.
          //启动服务LightsService  管理led和显示背光，所以我们需要它来打开显示
        traceBeginAndSlog("StartLightsService");
        mSystemServiceManager.startService(LightsService.class);
        traceEnd();

        traceBeginAndSlog("StartSidekickService");
        // Package manager isn't started yet; need to use SysProp not hardware feature
        //包管理器尚未启动;需要使用SysProp而不是硬件特性
        if (SystemProperties.getBoolean("config.enable_sidekick_graphics", false)) {
            mSystemServiceManager.startService(WEAR_SIDEKICK_SERVICE_CLASS);
        }
        traceEnd();

        // Display manager is needed to provide display metrics before package manager
        // starts up.
        //显示管理器需要在包管理器之前提供显示指标
          //启动服务DisplayManagerService
        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();

        // Only run "core" apps if we're encrypting the device.
          //当设备正在加密时，仅运行核心
        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.
        if (!mRuntimeRestart) {
            MetricsLogger.histogram(null, "boot_package_manager_init_start",
                    (int) SystemClock.elapsedRealtime());
        }
        traceBeginAndSlog("StartPackageManagerService");
       //启动服务PackageManagerService
        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");
        //启动服务UserManagerService，新建目录/data/user/
        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");
       //设置AMS
        mActivityManagerService.setSystemProcess();
        traceEnd();

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

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

        // The sensor service needs access to package manager service, app ops
        // service, and permissions service, therefore we start it after them.
        // Start sensor service in a separate thread. Completion should be checked
        // before using it.
       //启动传感器服务。这是一个阻塞调用，可能需要时间 所以在子线程中启动
        mSensorServiceStart = SystemServerInitThreadPool.get().submit(() -> {
            TimingsTraceLog traceLog = new TimingsTraceLog(
                    SYSTEM_SERVER_TIMING_ASYNC_TAG, Trace.TRACE_TAG_SYSTEM_SERVER);
            traceLog.traceBegin(START_SENSOR_SERVICE);
            startSensorService();
            traceLog.traceEnd();
        }, START_SENSOR_SERVICE);
    }

该方法启动的service有：

  1. Installer
  2. DeviceIdentifiersPolicyService
  3. ActivityManagerService
  4. PowerManagerService
  5. RecoverySystemService
  6. LightsService
  7. com.google.android.clockwork.sidekick.SidekickService( 可选，由配置决定)
  8. DisplayManagerService
  9. PackageManagerService
  10. UserManagerService
  11. OverlayManagerService
  12. SensorService

startCoreServices 启动核心 service

 private void startCoreServices() {
        traceBeginAndSlog("StartBatteryService");
        // Tracks the battery level.  Requires LightService.
       //启动服务BatteryService，用于统计电池电量，需要LightService.
        mSystemServiceManager.startService(BatteryService.class);
        traceEnd();

        // Tracks application usage stats.
        traceBeginAndSlog("StartUsageService");
          //启动服务UsageStatsService，用于统计应用使用情况
        mSystemServiceManager.startService(UsageStatsService.class);
        mActivityManagerService.setUsageStatsManager(
                LocalServices.getService(UsageStatsManagerInternal.class));
        traceEnd();

        // Tracks whether the updatable WebView is in a ready state and watches for update installs.
          //启动服务WebViewUpdateService
        if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_WEBVIEW)) {
            traceBeginAndSlog("StartWebViewUpdateService");
            mWebViewUpdateService = mSystemServiceManager.startService(WebViewUpdateService.class);
            traceEnd();
        }

        // Tracks cpu time spent in binder calls
        traceBeginAndSlog("StartBinderCallsStatsService");
        BinderCallsStatsService.start();
        traceEnd();
    }

该方法启动的Service 有：

  1. BatteryService
  2. UsageStatsService
  3. WebViewUpdateService

startOtherServices 启动其它服务

该方法中代码太多 ，就不贴了。方法里面：

  1. 是启动的一系列服务
  2. 执行部分启动服务 的systemReady（ ） 方法

Looper.loop()

开始 loop 循环 ，接受 处理 主线程 handler 发送的message
到此为止 ，SystemServer的 创建流程已经结束了。

参考博客

Boyikia
关注
专栏目录
Android 10.0 SystemServer进程读写sdcard权限的修改
安卓兼职framework和app工程师的博客
08-21 893
在10.0的系统开发中，在一些系统进程中，也就是在SystemServer的进程中，其中系统服务中会要求读写Sdcard的一些功能，然后 默认是没有读取sdcard权限的，而在app中可以申请sdcard读写权限在系统服务中就不能申请权限，接下来看怎么授权实现sdcard授权
SystemServer 进程启动过程
droidYu
02-28 246
之前的文章《浅析Android系统启动过程》简要讲解了Android系统整体启动过程，今天我们看一下其中一个重要的过程：SystemServer进程是如何启动的。 文中源码基于Android 8.0 上篇文章《Zygote进程启动过程》提到Zygote启动过程中调用了startSystemServer启动SystemServer进程，我们继续跟进里面的代码看SystemServer进程是如何启动的。 在startSystemServer中通过fork方式创建了SystemServer进程，并调用hand
(四) SystemServer进程
Leslie_LN的博客
08-12 442
SystemServer处理过程 作用：创建系统，我们所熟悉的AMS、WMS、PMS等都是由其创建的; 前面我们说了在ZygoteInit.main()方法中调用startSystemServer()启动了SystemServer进程后，进入SystemServer进程完成剩余处理工作： 启动Binder线程池 执行SystemServer.main() 在创建SystemServer进程后，会调用handleSystemProcess()方法来完成处理过程： private static void
SystemServer进程
许浑的博客
06-27 969
init进程 -> Zygote进程 -> system_server进程 SystemServer进程参数信息为uid=1000,gid=1000,进程名为 fork出 JNI 调用到创建新进程，采用copy on write方式，这是linux创建进程的标准方法，会有两次return。 返回值有3种类型：父进程中，fork返回新创建的子进程的pid；子进程中，fork返回0；当出现错误时，fork返回负数。 当system_server进程死亡后，重启zy...
Android EventLog含义
最新发布
qq_25815655的博客
08-22 51
battery_level: [19,3660,352] //剩余电量19%, 电池电压3.66v, 电池温度35.2℃ power_screen_state: [0,3,0,0] // 灭屏状态(0), 屏幕超时(3). 当然还有其他设备管理策略(1),其他理由都为用户行为(2) power_screen_state: [1,0,0,0] // 亮屏状态(1),通过字面意思，就能得到不少信息量，比如am_create_service，创建service，但是后面括号中内容的具体含义，其实有很高的价值。
【转】Android 内核初识(6)SystemServer进程
weixin_34417635的博客
03-03 271
简介 　　SystemServer的进程名实际上叫做“system_server”,通常简称为SS。 　　系统中的服务驻留在其中,常见的比如WindowManagerServer（Wms）、ActivityManagerSystemService（AmS）、 PackageManagerServer（PmS）等，这些系统服务都是以一个线程的方式存在于SystemServer进程中。 　　SS是由Z...
android优化 清除无效代码 UCDetector
2401_84910072的博客
05-11 828
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此我收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点！
Android 10.0 系统启动之SystemServer进程-[Android取经之路]
纸上得来终觉浅，绝知此事要躬行
05-01 3100
[Android取经之路] 的源码都基于Android-Q（10.0） 进行分析 [Android取经之路] 系列文章： 《系统启动篇》 Android系统架构 Android是怎么启动的 Android 10.0系统启动之init进程 Android10.0系统启动之Zygote进程 Android 10.0 系统启动之SystemServer进程 Android 10.0 系统服务之ActivityMnagerService Android10.0系统启动之Launcher(桌面)启动流程 And
Android Framework——zygote 启动 SystemServer
m0_71524094的博客
03-10 912
在Android系统中，所有的应用程序进程以及系统服务进程SystemServer都是由Zygote进程孕育（fork）出来的，这也许就是为什么要把它称为Zygote（受精卵）的原因吧。由于Zygote进程在Android系统中有着如此重要的地位，本文将详细分析它的启动过程1、启动Binder线程池，这样就可以与其他进程进行Binder跨进程通信。2、创建SystemServiceManager，它用来对系统服务进行创建、启动和生命周期管理。
从源码角度看Android系统SystemServer进程启动过程
张许平的博客
06-21 2055
SystemServer进程是由Zygote进程fork生成，进程名为system_server，主要用于创建系统服务。 备注：本文将结合Android8.0的源码看SystemServer进程的启动过程以及SystemServer进程做了哪些重要工作。 1. SystemServer进程启动的起点 从《从源码角度看Android系统Zygote进程启动过程》一文中可知：Zygote进程启动过程中...
Android启动-SystemServer的启动过程介绍
01-12
Android启动，第三阶段，SystemServer创建。 紧接上两篇《 Android启动-init介绍》和《Android启动-Zygote启动介绍》Linux内核启动之后,执行第一个进程 Init-->init创建Zygote-->fork出SystemServer。 这里我们就来研究一下SystemServer的创建过程。
Android Framework分析SystemServer进程
工宗浩生财指南针
06-16 586
如上所示，SystemServer主要由三个部分组成：main()方法、启动各种系统服务的run()方法，以及三个启动服务的方法：startCoreServices()、startOtherServices()和startBootstrapServices()。如上所示，在“run”方法中，首先调用“startCoreServices”方法以启动核心服务，接着调用“startOtherServices”方法以启动其他服务，最后调用“startBootstrapServices”方法以启动引导服务。
Android大脑--systemserver进程
niurenwo的专栏
08-17 1060
系统native进程的文章就先告一段落了，从这篇文章开始写Java层的文章，本文同样延续自述的方式来介绍**systemserver**进程，通过本文您将了解到**systemserver**进程是啥？它包含那么多的服务，是如何管理它们的？如何启动它们的
Android系统启动系列5 SystemServer进程下
liuwg1226的专栏
11-10 1548
一　概述 上一篇文章介绍了 SystemServer 的 main 函数是怎么被调用的，本篇主要分析 SystemServer 进程启动的时候，主要做了哪些事情，SystemServer 中运行的服务有八十多种，包括 ActivityManagerService(AMS)，WindowManagerService(WMS)，PackagManagerService(PMS)等，这些系统服务都是以一个线程的方式存在 Systemserver 进程中。接下来我们来看这些服务是怎么被启动的． 二　SystemSe
SystemServer进程启动
freelander_j的博客
01-17 491
文章已同步Github博客：SystemServer进程启动 使用到的相关源码：https://github.com/JesusYoung/AndroidResourceCode9.0/tree/master 基于Android 9.0 1、SystemServer进程作用 SystemServer进程主要是用于创建系统服务的，例如AMS、WMS、PMS； SystemService进程被创建后，...
Android5.1--SystemServer进程
Kitty_Landon的专栏
10-13 2213
这篇博客作为自己的学习心得记录下来，欢迎提出问题，一起学习进步。 SystemServer是Android系统的核心之一，大部分Android提供的服务都运行在这个进程里，SystemServer中运行的服务总共有60多种。为了防止应用进程对系统造成破坏，Android的应用进程没有权限访问设备的底层资源，只能通过SystemServer中的服务代理访问。
SystemServer进程浅析
fengluoye2012的博客
05-02 5914
前言 从上一篇文章Zygote进程浅析我们知道Zygote是孵化器，所有其他Dalvik虚拟机进程都是通过zygote孵化（fock）出来的；所以SystemServer进程是由Zygote进程fock(孵化)出来的，详见XXX。SystemServer进程是Android系统的核心之一，大部分Android提供的服务都在该进程中，SystemServer中运行的进程公共有六十多种，主要包括：A...
Android框架启动详解：zygote与SystemServer进程
5. **app_process与SystemServer**：实际执行Zygote任务的程序app_process位于system/bin目录下，它包含了SystemServer进程。SystemServer虽然名字特殊，但其实只是app_process的一个实例，它负责初始化关键服务并...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值