菜鸟追梦旅行

这个屌丝很懒，什么也没留下！

热门标签

Android源码解析之带你看system server进程启动流程及系统服务启动_android startotherservice

作者：菜鸟追梦旅行 | 2024-03-13 04:45:33

踩

android startotherservice

system server

前言
System Server
总结

前言

在平时的开发中或多或少会了解过ActivityManagerService，WindowManagerService，PowerManagerService等服务，那你有想过这些服务如何产生的吗，它们运行在哪呢？我们是如何获取到这些服务的呢？要想了解这些就要看System Server进程了

本篇博客源码基于API24

System Server

System Server进程和Zygote进程可以说是Android世界中的两大最重要的进程，离开其中之一基本上系统就玩完了（这里还有一个Media Server进程，是由init进程fork而来，负责启动和管理整个C++ framework，包含AudioFlinger，Camera Service等服务）；System Server负责启动和管理整个framework，基本上在Framework中的大多数服务都是在system server进程中以一个线程的方式存在的，比如平时开发接触比较多的ActivityManagerService，PackageManagerService ，WindowManagerService等。

System Server进程的进程名是system_server，大家可以通过adb shell ps查看当前手机存在的进程信息，可以看到这几条

USER     PID   PPID   VSIZE    RSS     WCHAN    PC         NAME
root      1     0     9048     1012    ffffffff 00000000 S /init

root      349   1     2118552  17464   ffffffff 00000000 S zygote64
root      350   1     1526172  16800   ffffffff 00000000 S zygote

system    793   349   2792784  109876  ffffffff 00000000 S system_server
1
2
3
4
5
6
7

最后一条就是system server进程信息

fork SystemServer

System Server进程是由Zygote进程fork出来的，至于如何被Zygote进程fork出来的可以参考下面博客，本篇文章介绍Java层的工作原理
Android系统启动流程概述 init进程启动 zygote进程启动 system server进程启动

zygote进程fork成功后，会反射调用SystemServer.main()方法，至此进入system server进程的工作空间

SystemServer.main()

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

private void run() {
        try {
           	//若当前时间小于1970年1月1日，那就设置为1970年1月1日
            if (System.currentTimeMillis() < EARLIEST_SUPPORTED_TIME) {
                SystemClock.setCurrentTimeMillis(EARLIEST_SUPPORTED_TIME);
            }
            //设置系统的语言环境
			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", "");
            }
            
            //变更虚拟机的库文件，对于Android 6.0默认采用的是libart.so
            SystemProperties.set("persist.sys.dalvik.vm.lib.2", VMRuntime.getRuntime().vmLibrary());

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

            //设置内存的可能有效使用率为0.8
            VMRuntime.getRuntime().setTargetHeapUtilization(0.8f);

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

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

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

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

            // 增加system_server中的binder线程数
            BinderInternal.setMaxThreads(sMaxBinderThreads);

            // 创建主线程looper 在当前线程运行
            android.os.Process.setThreadPriority(
                android.os.Process.THREAD_PRIORITY_FOREGROUND);
            android.os.Process.setCanSelfBackground(false);
            Looper.prepareMainLooper();

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

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

            //初始化系统上下文
            //初始化系统上下文对象mSystemContext，并设置默认的主题,mSystemContext实际上是一个ContextImpl对象。
            //调用ActivityThread.systemMain()的时候，会调用ActivityThread.attach(true)，而在attach()里面，则创建了Application对象，并调用了Application.onCreate()。
            createSystemContext();

            //创建系统服务管理
            mSystemServiceManager = new SystemServiceManager(mSystemContext);
            LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
        } finally {
            Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
        }

        //启动各种系统服务
        try {
	        //引导服务
            startBootstrapServices();
            //核心服务
            startCoreServices();
            //其它服务
            startOtherServices();
        } catch (Throwable ex) {
            throw ex;
        } finally {
            Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
        }

        //开启消息循环
        Looper.loop();
        throw new RuntimeException("Main thread loop unexpectedly exited");
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

这个main方法做了很多事情：设置系统时间，设置语言环境，设置虚拟机内存，设置binder线程数，初始化Loop，加载运行库等

除了这些操作外，接下来继续往下看main方法后半段

SystemServer.createSystemContext

private Context mSystemContext;

private void createSystemContext() {
        ActivityThread activityThread = ActivityThread.systemMain();
        mSystemContext = activityThread.getSystemContext();
        mSystemContext.setTheme(DEFAULT_SYSTEM_THEME);
}
1
2
3
4
5
6
7

没想到啊，原来System Server中也有Context对象，这个方法就是初始化system context；可能有人不太理解Context到底是个什么玩意

Context英文原意是上下文的意思，在平时开发中涉及到的四大组件及资源操作基本上都离不开Context对象；你可以想象它是一团神秘的漂浮的物质，在一个生活场景中，不管你在哪，在干什么，你都可以通过这团神秘物质获取到一些属于这个场景的隐性信息

比如你在吃一条鱼这个场景，你能知道的就是这条鱼多大，多好吃，但是假如你有Context这个上下文信息，你就能获取到更多信息，比如鱼的重量，鱼的种类，鱼的年龄等，用代码表示就是Context.getFishType()，你就知道这条鱼的种类了

这就是上下文的意思，某一个场景下一些隐藏的信息

其实Context家族很复杂，Context本身是一个抽象类，而ContextImpl，ContextWrapper，Activity，Service，Application等都是它的直接或间接子类

接下来我们看下方法后续调用

public static ActivityThread systemMain() {
        // 低内存设备上的系统进程无法使用硬件加速绘图，因为这会给进程增加太多开销
        if (!ActivityManager.isHighEndGfx()) {
            ThreadedRenderer.disable(true);
        } else {
            ThreadedRenderer.enableForegroundTrimming();
        }
        ActivityThread thread = new ActivityThread();
        thread.attach(true);
        return thread;
}

public ContextImpl getSystemContext() {
        synchronized (this) {
            if (mSystemContext == null) {
                mSystemContext = ContextImpl.createSystemContext(this);
            }
            return mSystemContext;
        }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

其中 thread.attach(true)这句话经过一系列调用后会创建很多对象，比如ActivityThread，Instrumentation, ContextImpl，LoadedApk，Application等

具体执行过程可查看博主博客

从Activity加载源码深入理解ActivityThrad的工作逻辑

执行完后System Server后续就能用到这些对象了

SystemServiceManager

继续往下看

//创建系统服务管理
mSystemServiceManager = new SystemServiceManager(mSystemContext);
LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
1
2
3

这里是实例化SystemServiceManager对象，这个类主要是用来对System server中的一些系统服务的创建，启动和其它的一些生命周期事件进行管理；SystemServiceManager内部维护了一个集合

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

SystemServer启动的很多服务都保存在这个集合里，这样就可以正式启动其它服务了

启动服务三连

		//启动各种系统服务
        try {
	        //引导服务
            startBootstrapServices();
            //核心服务
            startCoreServices();
            //其它服务
            startOtherServices();
        } catch (Throwable ex) {
            throw ex;
        } finally {
            Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
        }
1
2
3
4
5
6
7
8
9
10
11
12
13

main方法最后会执行这三个重要的启动服务方法，先看第一个

SystemServer.startBootstrapServices

这个方法将会启动一些引导服务

	private PowerManagerService mPowerManagerService;
    private ActivityManagerService mActivityManagerService;
    private WebViewUpdateService mWebViewUpdateService;
    private DisplayManagerService mDisplayManagerService;
    private PackageManagerService mPackageManagerService;
    private PackageManager mPackageManager;
		
	/**
     * 启动一些系统运行必须的关键服务，这些服务具有复杂的相互依赖性，所以就在这里全部初始化
     */
    private void startBootstrapServices() {
        // 阻塞等待installd完成启动，与其建立socket通道
        // 以便它有机会使用适当的权限创建关键目录，例如/ data / user
        // 在初始化其他服务之前，我们需要完成此操作
        Installer installer = mSystemServiceManager.startService(Installer.class);

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

        // PowerManagerService需要尽早启动，因为其他服务需要它。 本机守护程序可能正在监视它是否已注册
        // 因为它要立即准备好处理传入进来的binder调用（包括能够验证这些调用的权限）
        mPowerManagerService = mSystemServiceManager.startService(PowerManagerService.class);

        // 现在电源管理器已经启动，让ActivityManagerService初始化电源管理功能
        mActivityManagerService.initPowerManagement();

        // 启动服务LightsService 管理LED并显示背光
        mSystemServiceManager.startService(LightsService.class);

        // 启动服务DisplayManagerService
        mDisplayManagerService = mSystemServiceManager.startService(DisplayManagerService.class);

        // 在初始化package manager之前，需要默认的显示
        mSystemServiceManager.startBootPhase(SystemService.PHASE_WAIT_FOR_DEFAULT_DISPLAY);

        // 如果我们正在加密设备，则只运行“核心”应用程序.
        String cryptState = SystemProperties.get("vold.decrypt");
        if (ENCRYPTING_STATE.equals(cryptState)) {
            //加密程序正在运行
            mOnlyCore = true;
        } else if (ENCRYPTED_STATE.equals(cryptState)) {
            //已经被加密了
            mOnlyCore = true;
        }

        // 启动PackageManagerService
        mPackageManagerService = PackageManagerService.main(mSystemContext, installer,
                mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF, mOnlyCore);
        mFirstBoot = mPackageManagerService.isFirstBoot();
        mPackageManager = mSystemContext.getPackageManager();

        // 没有加密的话进行odex优化
        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 {
                    Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
                }
            }
        }

        //启动服务UserManagerService，新建目录/data/user/
        mSystemServiceManager.startService(UserManagerService.LifeCycle.class);

        //初始化属性缓存用来缓存包资源.
        AttributeCache.init(mSystemContext);

        // 为系统进程设置Application实例并开始使用
        mActivityManagerService.setSystemProcess();

        // 启动传感器服务
        // 传感器服务需要访问包管理器服务，app ops服务和权限服务，因此我们在它们之后启动它
        startSensorService();
    }
    
    //这是native方法
    private static native void startSensorService();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

可以看到这里启动了很多系统关键性服务，比如ActivityManagerService，这就是平时所说的AMS，它就是在system server进程中创建的，它们都是通过SystemServiceManager实例去操作，具体执行方法是其startService方法

SystemServiceManager.startService

/**
     * 创建并启动 system service. 且这些服务必须是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();

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

            // 添加到list集合
            mServices.add(service);

            try {
            		//启动
                service.onStart();
            } catch (RuntimeException ex) {
                throw new RuntimeException("Failed to start service " + name
                        + ": onStart threw an exception", ex);
            }
            return service;
        } finally {
            Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

这里都是通过反射构造出这些服务的实例，然后调用它们的onStart方法启动，以Installer服务为例看一下

Installer.onStart

public final class Installer extends SystemService {

		private final InstallerConnection mInstaller;
		
		public Installer(Context context) {
	        super(context);
	        mInstaller = new InstallerConnection();
    	}
		
		@Override
    	public void onStart() {
        	//等待installd准备完毕
        	mInstaller.waitForConnection();
    	}
    
}
    
public class InstallerConnection {

    public void waitForConnection() {
        for (;;) {
            try {
                execute("ping");
                return;
            } catch (InstallerException ignored) {
            }
            //还没准备好，休息一秒继续尝试
            SystemClock.sleep(1000);
        }
    }
    
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

其实就是不断的通过ping命令连接Zygote进程（SystemServer和Zygote进程通过socket方式通讯，其他进程通过Binder方式通讯），成功连接之后才会开始启动其他服务

SystemServer.startCoreServices

接下来看第二个启动方法

	/**
     * 启动一些与引导服务没有复杂依赖的基本服务
     */
    private void startCoreServices() {
        // 启动BatteryService 跟踪电池电量
        mSystemServiceManager.startService(BatteryService.class);

        // 启动UsageStatsService 跟踪应用程序使用统计信息
        mSystemServiceManager.startService(UsageStatsService.class);
        mActivityManagerService.setUsageStatsManager(
                LocalServices.getService(UsageStatsManagerInternal.class));

        // 启动WebViewUpdateService 跟踪可更新的WebView是否处于就绪状态并监视更新安装。
        mWebViewUpdateService = mSystemServiceManager.startService(WebViewUpdateService.class);   
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

SystemServer.startOtherServices

这个方法着实有点长，将近一千行，不过做的事情不复杂，主要是启动服务；这里就不一一列举了

private void startOtherServices() {
        final Context context = mSystemContext;
        //这里会启动一堆杂七杂八的服务
        VibratorService vibrator = null;
        IMountService mountService = null;
        NetworkManagementService networkManagement = null;
        NetworkStatsService networkStats = null;
        NetworkPolicyManagerService networkPolicy = null;
        ConnectivityService connectivity = null;
        NetworkScoreService networkScore = null;
        NsdService serviceDiscovery= null;
        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);
        boolean disableNetwork = SystemProperties.getBoolean("config.disable_network", false);
        boolean disableNetworkTime = SystemProperties.getBoolean("config.disable_networktime", false);
        boolean disableRtt = SystemProperties.getBoolean("config.disable_rtt", false);
        boolean disableMediaProjection = SystemProperties.getBoolean("config.disable_mediaproj",
                false);
        boolean disableSerial = SystemProperties.getBoolean("config.disable_serial", false);
        boolean disableSearchManager = SystemProperties.getBoolean("config.disable_searchmanager",
                false);
        boolean disableTrustManager = SystemProperties.getBoolean("config.disable_trustmanager",
                false);
        boolean disableTextServices = SystemProperties.getBoolean("config.disable_textservices", false);
        boolean disableSamplingProfiler = SystemProperties.getBoolean("config.disable_samplingprof",
                false);
        boolean isEmulator = SystemProperties.get("ro.kernel.qemu").equals("1");

        try {
            SystemConfig.getInstance();

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

            telephonyRegistry = new TelephonyRegistry(context);
            ServiceManager.addService("telephony.registry", telephonyRegistry);

			......
						
        } catch (RuntimeException e) {
            Slog.e("System", "************ Failure starting core service", e);
        }

        StatusBarManagerService statusBar = null;
        INotificationManager notification = null;
        LocationManagerService location = null;
        CountryDetectorService countryDetector = null;
        ILockSettings lockSettings = null;
        AssetAtlasService atlas = null;
        MediaRouterService mediaRouter = null;
				
		......

		ActivityManagerNative.getDefault().showBootMessage(...); //显示启动界面

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

		......

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

                mSystemServiceManager.startBootPhase(
                        SystemService.PHASE_ACTIVITY_MANAGER_READY);
								
				......

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


                mSystemServiceManager.startBootPhase(
                        SystemService.PHASE_THIRD_PARTY_APPS_CAN_START);

               ......
            }
        });
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

这里会启动大量的服务，到这里系统服务基本上启动完成，system_server进程随后进入Looper.loop()状态，随时等待消息到来

总结

SystemServer进程启动后会设置系统时间，设置语言环境，设置虚拟机内存，设置binder线程数，初始化Loop，加载运行库等
接下来创建Context对象，SystemServiceManager对象
最后启动三类服务：引导服务，核心服务，其它服务；其中引导服务有7个，核心服务有三个，其他服务有70+
进行消息循环，随时处理接收到的事件

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/菜鸟追梦旅行/article/detail/227846