android启动流程-SystemServer

anhuilee

已于 2024-03-13 23:20:53 修改

阅读量950

点赞数 38

分类专栏： android framework 文章标签： android 开发语言 zygote java

于 2024-03-12 18:34:22 首次发布

本文链接：https://blog.csdn.net/anhuilee/article/details/136646085

版权

android framework 专栏收录该内容

11 篇文章 3 订阅

订阅专栏

整体流程图

forkSystemServer

SystemServer进程主要是用于创建和管理系统服务的，例如AMS、WMS、PMS。上一章我们说到Zygote的进程的创建，在执行java层代码时，Zygote会创建SystemServer进程。

public static void main(String argv[]) {   
        
        ...

            if (startSystemServer) {
                //fork SystemServer进程,AMS由SystemServer启动
                Runnable r = forkSystemServer(abiList, zygoteSocketName, zygoteServer); 
                if (r != null) {
                    // 启动SystemServer
                    r.run();
                    return;
                }
            
            }
            
        ...
        
    }

文件路径：frameworks/base/core/java/com/android/internal/os/ZygoteInit.java；

执行方法：forkSystemServer

private static Runnable forkSystemServer(String abiList, String socketName, 
ZygoteServer zygoteServer) { 
        try { 
            // 1.创建SystemServer进程，并返回当前进程的pid 
            pid = Zygote.forkSystemServer( 
                    parsedArgs.mUid, parsedArgs.mGid, 
                    parsedArgs.mGids, 
                    parsedArgs.mRuntimeFlags, 
                    null, 
                    parsedArgs.mPermittedCapabilities, 
                    parsedArgs.mEffectiveCapabilities); 
        } catch (IllegalArgumentException ex) { 
            throw new RuntimeException(ex); 
        } 
 
        // 2.如果pid==0则说明Zygote进程创建SystemServer进程成功，当前运行在SystemServer进程中 
        if (pid == 0) { 
            // 3.由于SystemServer进程fork了Zygote进程的地址空间，所以会得到Zygote进程创建Socket， 
            // 而这个Socket对于SystemServer进程是无用的，因此，在此处关闭了该Socket。 
            zygoteServer.closeServerSocket(); 
            // 4.启动SystemServer进程 
            return handleSystemServerProcess(parsedArgs); 
        } 
    }

在代码1 处可知，Zygote.forkSystemServer()执行的过程中会fork一个进程，这个进程就是systemServer进程。那么fork完成后，此处的代码会返回两次，一次返回是执行 fork新创建的代码，另外一次是zygote自己的代码。第一次返回值如果是0 ，说明当前运行的是新的创建的进程的代码也就是systemServer进程的代码，第二次返回的值是一个大于0的值，说明当前运行的代码是zygote进程的代码。

然后在代码2处，如果 pid 等于0 ，说明当前进程是运行在systemServer进程中。 systemServer进程是不需要zygoteServer的，所以关闭掉 closeServerSocket。然后，再执行 handleSystemServerProcess，运行systemServer进程。

private static Runnable handleSystemServerProcess(ZygoteArguments parsedArgs) { 
        if (parsedArgs.mInvokeWith != null) { 
            ... 
        } else { 
            ClassLoader cl = null; 
            if (systemServerClasspath != null) { 
                // 1.使用了systemServerClassPath和targetSdkVersion创建了一个PathClassLoader 
                cl = createPathClassLoader(systemServerClasspath, 
parsedArgs.mTargetSdkVersion); 
            } 
 
            // 2.调用 ZygoteInit.zygoteInit 方法 
            return ZygoteInit.zygoteInit(parsedArgs.mTargetSdkVersion, 
                    parsedArgs.mDisabledCompatChanges, 
                    parsedArgs.mRemainingArgs, cl); 
        } 
    }

以上代码做了两件事：

基于sdk版本创建了一个ClassLoader；
执行zygoteInit方法。

public static final Runnable zygoteInit(int targetSdkVersion, long[] disabledCompatChanges, 
        String[] argv, ClassLoader classLoader) { 
    // 1.进入native方法 
    ZygoteInit.nativeZygoteInit(); 
    // 2.获取封装了SystemServer的main方法的runnable 
    return RuntimeInit.applicationInit(targetSdkVersion, disabledCompatChanges, argv, 
        classLoader); 
}

继续往下看，在zygoteInit方法中，首先是调用nativeZygoteinit方法来初始化进程环境，然后再执行applicationInit方法获取封装了SystemServer的main方法的Runnable。

在上一篇说过，在zygote初始化的时候会注册JNI，其中就将 nativeZygoteInit()方法和native函数com_android_internal_os_ZygoteInit_nativeZygoteInit()建立了映射关系。所以此时调用nativeZygoteInit()会调用到AndroidRuntime的下面的代码。

static AndroidRuntime* gCurRuntime = NULL; 
static void com_android_internal_os_ZygoteInit_nativeZygoteInit(JNIEnv* env, jobject clazz) 
{ 
    gCurRuntime->onZygoteInit(); 
}

gCurRuntime是AndroidRuntime的指针，具体指向的是其子类AppRuntime，它在app_main.cpp中定义如下：

// frameworks/base/cmds/app_process/app_main.cpp 
virtual void onZygoteInit() { 
    // 1.创建了一个ProcessState实例 
    sp<ProcessState> proc = ProcessState::self(); 
    // 2.启动了一个Binder线程池 
    proc->startThreadPool(); 
}

在这个代码中执行的是进程的初始化，首先在代码1处，创建了一个进程ProcessState，其中就会创建一个binder；然后在代码2处启动了Binder线程池，为Binder线程的运行提供了动力。

现在我们回到 RuntimeInit.applicationInit方法中进行分析。

// frameworks/base/core/java/com/android/internal/os/RuntimeInit.java 
protected static Runnable applicationInit(int targetSdkVersion, long[] 
        disabledCompatChanges, String[] argv, ClassLoader classLoader) { 
    return findStaticMain(args.startClass, args.startArgs, classLoader); 
}

protected static Runnable findStaticMain(String className, String[] argv, 
            ClassLoader classLoader) { 
        Class<?> cl; 
        try { 
            // 1.通过反射得到了SystemServer类 
            cl = Class.forName(className, true, classLoader); 
        } 
 
        Method m; 
        try { 
            // 2.找到了 SystemServer中的main方法 
            m = cl.getMethod("main", new Class[] { String[].class }); 
        } 
 
        // 3.将main()方法传入MethodAndArgsCaller()方法中 
        return new MethodAndArgsCaller(m, argv); 
    }

通过上面代码可知，findStaticMain执行反射，拿到systemServer的main方法，然后调用MethodAndArgsCaller，将main方法的调用封装到一个Runnable中，方便后期的执行。

static class MethodAndArgsCaller implements Runnable { 
        private final Method mMethod; 
        public MethodAndArgsCaller(Method method, String[] args) { 
            mMethod = method; 
            mArgs = args; 
        } 
 
        public void run() { 
            try { 
                // 执行SystemServer的main()方法 
                mMethod.invoke(null, new Object[] { mArgs }); 
            } 
        } 
    }

可以看到这里通过反射，执行这个run方法，就是执行SystemServer的main()方法。

这个Runnable的run方法是在ZygoteInit的main()方法中被执行。

SystemServer.main

此时，我们回到最外层，forkSystemServer方法返回了一个Runnable。执行这个Runnable.run()，就相当于执行了SystemServer.main()；


public static void main(String argv[]) {   
        
        ...

            if (startSystemServer) {
                //fork SystemServer进程,AMS由SystemServer启动
                Runnable r = forkSystemServer(abiList, zygoteSocketName, zygoteServer); 
                if (r != null) {
                    // 启动SystemServer
                    r.run();
                    return;
                }
            
            }
            
        ...
        
    }

所以，此时执行SystemServer.main()：

文件路径：frameworks/base/services/java/com/android/server/SystemServer.java ；

执行方法：main

public static void main(String[] args) { 
        new SystemServer().run(); 
}

main方法就一行代码执行SystemServer进程的run方法：

private void run() { 
        try { 
            Looper.prepareMainLooper(); 
 
            // 1.加载动态库libandroid_servers.so 
            System.loadLibrary("android_servers"); 
 
            // 2.创建SystemServerManager 
            mSystemServiceManager = new SystemServiceManager(mSystemContext); 
             
            // 3.初始化系统上下文 
            createSystemContext(); 
 
        } 
 
        try { 
            // 3.使用SystemServiceManager启动引导服务 
            startBootstrapServices(t); 
            // 4.启动核心服务 
            startCoreServices(t); 
            // 5.启动其他服务 
            startOtherServices(t); 
        } 
 
        // Loop forever. 
        Looper.loop(); 
}

通过上面的代码不难发现，启动过程中，在大流程上SystemServer和app进程的启动很像，初始化了很多资源，也加载了很多资源，还创建了上下文，同时构建了进程的Looper 死循环确保进程不会退出。

SystemServer通过代码3，4，5启动了非常多的服务，大概有90多个服务，这些服务包括AMS，ATMS，WMS， PKMS，BMS等等一系列的服务。另外，在代码2处创建了一个systemServiceManager对象，这个对象是用于在 SystemServer进程中管理90多个服务的启动的。

createSystemContext

private void createSystemContext() {
        ActivityThread activityThread = ActivityThread.systemMain();
        // 初始化系统上下文，加载资源
        mSystemContext = activityThread.getSystemContext();
        // 设置主题
        mSystemContext.setTheme(DEFAULT_SYSTEM_THEME);


        final Context systemUiContext = activityThread.getSystemUiContext();
        // 设置SystemUI主题
        systemUiContext.setTheme(DEFAULT_SYSTEM_THEME);
    }

在调用ActivityThread.systemMain方法时，这个过程会创建对象有ActivityThread，Instrumentation, ContextImpl，LoadedApk，Application等等。

startBootstrapServices

在这个方法中会启动系统的一些关键服务，这些服务是系统运行的基石。比如ATMS，AMS等等。

 private void startBootstrapServices() {
        // 尽早启动看门狗，这样我们在早期启动陷入死锁时就可以使system server崩溃重启。
        final Watchdog watchdog = Watchdog.getInstance();
        watchdog.start();
           
        //启动Installer Service，这个Service 通过binder与installd进程通讯，负责apk安装相关的工作
        Installer installer = mSystemServiceManager.startService(Installer.class);

        //设备标识符策略服务
        mSystemServiceManager.startService(DeviceIdentifiersPolicyService.class);

        // 管理uri授权
        mSystemServiceManager.startService(UriGrantsManagerService.Lifecycle.class);

        //启动ActivityTaskManagerService和ActivityManagerService
        ActivityTaskManagerService atm = mSystemServiceManager.startService(
                ActivityTaskManagerService.Lifecycle.class).getService();
        mActivityManagerService = ActivityManagerService.Lifecycle.startService(
                mSystemServiceManager, atm);
        mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
        mActivityManagerService.setInstaller(installer);
        mWindowManagerGlobalLock = atm.getGlobalLock();
        
        //电源管理器需要尽早启动，因为其他服务需要它。
        mPowerManagerService = mSystemServiceManager.startService(PowerManagerService.class);

        //启动热缓解服务，目的是在手机开始过热时进行有效的热缓解
        mSystemServiceManager.startService(ThermalManagerService.class);

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

        //启动系统恢复服务，负责协调设备上与恢复有关的功能。
        mSystemServiceManager.startService(RecoverySystemService.class);
        
        //到这里为止，系统启动的必须服务已经加载完毕
        RescueParty.noteBoot(mSystemContext);

        //管理LED和屏幕背光，我们需要它来显示
        mSystemServiceManager.startService(LightsService.class);

        //管理显示设备
        //在package manager 启动之前，需要启动display manager 提供display metrics
        mDisplayManagerService = mSystemServiceManager.startService(DisplayManagerService.class);

     //只有DisplayManagerService会对PHASE_WAIT_FOR_DEFAULT_DISPLAY做处理
     //目的是在初始化包管理器之前，首先需要获取一个默认的显示设备
     mSystemServiceManager.startBootPhase(SystemService.PHASE_WAIT_FOR_DEFAULT_DISPLAY);

        // 启动 package manager.
        if (!mRuntimeRestart) {
            MetricsLogger.histogram(null, "boot_package_manager_init_start",
                    (int) SystemClock.elapsedRealtime());
        }
        try {
            Watchdog.getInstance().pauseWatchingCurrentThread("packagemanagermain");
            mPackageManagerService = PackageManagerService.main(mSystemContext, installer,
                    mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF, mOnlyCore);
        } finally {
            Watchdog.getInstance().resumeWatchingCurrentThread("packagemanagermain");
        }
        mFirstBoot = mPackageManagerService.isFirstBoot();
        mPackageManager = mSystemContext.getPackageManager();
       
        //启动UserManager Service
        mSystemServiceManager.startService(UserManagerService.LifeCycle.class);
     

       //为系统进程设置应用程序实例并启动
        mActivityManagerService.setSystemProcess();

        //使用ActivityManager实例完成看门狗设置并监听是否重启
        watchdog.init(mSystemContext, mActivityManagerService);

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

        //负责动态资源overlay
        mSystemServiceManager.startService(new OverlayManagerService(mSystemContext, installer));

        mSystemServiceManager.startService(new SensorPrivacyService(mSystemContext));

        if (SystemProperties.getInt("persist.sys.displayinset.top", 0) > 0) {
            // DisplayManager needs the overlay immediately.
            mActivityManagerService.updateSystemUiContext();
            LocalServices.getService(DisplayManagerInternal.class).onOverlayChanged();
        }

          //传感器服务需要访问包管理器服务、app ops服务和权限服务，
         //因此我们在它们之后启动它。
         //在单独的线程中启动传感器服务。在使用它之前应该检查完成情况。
        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);
    }

startCoreServices

用来处理系统的核心服务，比如电池服务，webview相关服务等等。

 private void startCoreServices() {
        // 追踪电池充电状态和电量。需要LightService
        mSystemServiceManager.startService(BatteryService.class);

         //跟踪应用程序使用状态
        mSystemServiceManager.startService(UsageStatsService.class);
        mActivityManagerService.setUsageStatsManager(
                LocalServices.getService(UsageStatsManagerInternal.class));

        // 跟踪可更新的WebView是否处于就绪状态，并监视更新安装。
        if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_WEBVIEW)) {
            traceBeginAndSlog("StartWebViewUpdateService");
            mWebViewUpdateService = mSystemServiceManager.startService(WebViewUpdateService.class);
            traceEnd();
        }

       //跟踪并缓存设备状态。
        mSystemServiceManager.startService(CachedDeviceStateService.class);

        // 跟踪在Binder调用中花费的cpu时间
        mSystemServiceManager.startService(BinderCallsStatsService.LifeCycle.class);

        // 跟踪handlers中处理messages所花费的时间。
        mSystemServiceManager.startService(LooperStatsService.Lifecycle.class);

        //管理apk回滚
        mSystemServiceManager.startService(RollbackManagerService.class);

        // 用于捕获bugreport,adb bugreport 命令调用的就是这个服务
        mSystemServiceManager.startService(BugreportManagerService.class);

        // 管理Gpu和Gpu驱动的服务
        mSystemServiceManager.startService(GpuService.class);
    }

startOtherServices

这个方法负责启动剩下的服务，共计有70多个。

/**
     * Starts a miscellaneous grab bag of stuff that has yet to be refactored and organized.
     */
    private void startOtherServices(@NonNull TimingsTraceAndSlog t) {
        t.traceBegin("startOtherServices");

        // 代码省略...

        // We now tell the activity manager it is okay to run third party
        // code.  It will call back into us once it has gotten to the state
        // where third party code can really run (but before it has actually
        // started launching the initial applications), for us to complete our
        // initialization.
        mActivityManagerService.systemReady(() -> {


            //开始启动systemUI
            t.traceBegin("StartSystemUI");
            try {
                startSystemUi(context, windowManagerF);
            } catch (Throwable e) {
                reportWtf("starting System UI", e);
            }
            t.traceEnd();
            
            // 代码省略...
        }, t);

        t.traceEnd(); // startOtherServices
    }

最终通过startOtherServices中的mActivityManagerService.systemReady->RootWindowContainer.startHomeOnDisplay->RootWindowContainer.startHomeOnTaskDisplayArea->ActivityStartController.startHomeActivity()，启动Launcher app。

总结

SystemService进程被创建后，主要的处理如下：

1. 启动Binder线程池，这样就可以与其他进程进行Binder跨进程通信。

2. SystemServer在启动过程中，先初始化一些系统变量，加载类库，创建Context对象。

3. 创建SystemServiceManager，它用来对系统服务进行创建、启动和生命周期管理。

4. 启动各种系统服务：引导服务、核心服务、其他服务，共90多种。应用开发主要关注引导服务 ActivityManagerService、PackageManagerService和其他服务WindowManagerService、 InputManagerService即可。

5. 启动的服务都单独运行在SystemServer的各自线程中，同属于SystemServer进程。

anhuilee

关注

38
点赞
踩
12

收藏

觉得还不错? 一键收藏
1
评论
android启动流程-SystemServer

SystemService进程被创建后，主要的处理如下：1. 启动Binder线程池，这样就可以与其他进程进行Binder跨进程通信。2. SystemServer在启动过程中，先初始化一些系统变量，加载类库，创建Context对象。3. 创建SystemServiceManager，它用来对系统服务进行创建、启动和生命周期管理。4. 启动各种系统服务：引导服务、核心服务、其他服务，共90多种。
复制链接

扫一扫