Android进程系列第四篇---SystemServer进程的启动流程

一、内容预览

《Android进程系列第四篇---SystemServer进程的启动流程》 内容预览.png

二、概述

前面进程系列已经更新了三篇,本文(基于Android O源码),第三篇中System进程已经创建好了,本篇主要讲解SystemServer进程启动做了哪些事情,SystemServer中运行的服务有八十多种,包括ActivityManagerService(AMS),WindowManagerService(WMS),PackagManagerService(PMS)等;这些系统服务都是以一个线程的方式存在Systemserver进程中。

Android进程系列第一篇—进程基础
Android进程系列第二篇—Zygote进程的创建流程
Android进程系列第三篇—SystemServer进程创建流程

简要回顾上一篇的重点的内容

  • SystemServer进程是Zygote进程的大弟子,是Zygote进程fork的第一个进程,因注册了SigChldHandler,SystemServer和Zygote共存亡。
  • 在fork新进程的基础上,第一步:调用redirectLogStreams初始化Android LOG输出流,将system.out, system.err关闭, 将两者重新定向到Android log中 。
  • 在fork新进程的基础上,第二步:调用redirectLogStreams初始化Android LOG输出流,将system.out, system.err关闭, 将两者重新定向到Android log中 。
  • 在fork新进程的基础上,第三步:调用nativeZygoteInit,开启Binder线程池 。
  • 在fork新进程的基础上,第四步:调用applicationInit,来到invokeStaticMain方法,抛出一个Zygote.MethodAndArgsCaller异常,以此调用SytemServer的main方法。

三、SystemServer进程的启动流程

3.1、SystemServer类的main方法
/frameworks/base/services/java/com/android/server/SystemServer.java
256    /**
257     * The main entry point from zygote.
258     */
259    public static void main(String[] args) {
260        new SystemServer().run();
261    }
/frameworks/base/services/java/com/android/server/SystemServer.java
270    private void run() {
271        try {
272            traceBeginAndSlog("InitBeforeStartServices");
273            // If a device's clock is before 1970 (before 0), a lot of
274            // APIs crash dealing with negative numbers, notably
275            // java.io.File#setLastModified, so instead we fake it and
276            // hope that time from cell towers or NTP fixes it shortly.
               //1、首先判断系统当前时间,为防止一些和时间相关的初始化出错,若当前时间小于1970年1月1日,设置系统当前时间为该时间点。
277            if (System.currentTimeMillis() < EARLIEST_SUPPORTED_TIME) {
278                Slog.w(TAG, "System clock is before 1970; setting to 1970.");
279                SystemClock.setCurrentTimeMillis(EARLIEST_SUPPORTED_TIME);
280            }
281
...
291            // If the system has "persist.sys.language" and friends set, replace them with
292            // "persist.sys.locale". Note that the default locale at this point is calculated
293            // using the "-Duser.locale" command line flag. That flag is usually populated by
294            // AndroidRuntime using the same set of system properties, but only the system_server
295            // and system apps are allowed to set them.
296            //
297            // NOTE: Most changes made here will need an equivalent change to
298            // core/jni/AndroidRuntime.cpp
                //2、设置系统的语言环境等 
299            if (!SystemProperties.get("persist.sys.language").isEmpty()) {
300                final String languageTag = Locale.getDefault().toLanguageTag();
301
302                SystemProperties.set("persist.sys.locale", languageTag);
303                SystemProperties.set("persist.sys.language", "");
304                SystemProperties.set("persist.sys.country", "");
305                SystemProperties.set("persist.sys.localevar", "");
306            }
307
...
              //3、设置当前虚拟机的运行库路径
326            SystemProperties.set("persist.sys.dalvik.vm.lib.2", VMRuntime.getRuntime().vmLibrary());
327
...
340            // Mmmmmm... more memory!
341            VMRuntime.getRuntime().clearGrowthLimit();
342
343            // The system server has to run all of the time, so it needs to be
344            // as efficient as possible with its memory usage.
                 //4、 设置虚拟机堆内存
345            VMRuntime.getRuntime().setTargetHeapUtilization(0.8f);
346
347            // Some devices rely on runtime fingerprint generation, so make sure
348            // we've defined it before booting further.
349            Build.ensureFingerprintProperty();
350
351            // Within the system server, it is an error to access Environment paths without
352            // explicitly specifying a user.
353            Environment.setUserRequired(true);
354
355            // Within the system server, any incoming Bundles should be defused
356            // to avoid throwing BadParcelableException.
357            BaseBundle.setShouldDefuse(true);
358
359            // Ensure binder calls into the system always run at foreground priority.
360            BinderInternal.disableBackgroundScheduling(true);
361
362            // Increase the number of binder threads in system_server
363            BinderInternal.setMaxThreads(sMaxBinderThreads);
364
365            // Prepare the main looper thread (this thread).
                  //5、设置线程优先级
366            android.os.Process.setThreadPriority(
367                android.os.Process.THREAD_PRIORITY_FOREGROUND);
368            android.os.Process.setCanSelfBackground(false);
                  //6、 初始化主线程Looper
369            Looper.prepareMainLooper();
370
371            // Initialize native services.
                 //7、 装载libandroid_servers.so库
372            System.loadLibrary("android_servers");
373
374            // Check whether we failed to shut down last time we tried.
375            // This call may not return.
376            performPendingShutdown();
377
378            // Initialize the system context.
                 //8、 创建System的context
379            createSystemContext();
380
381            // Create the system service manager.
                //9、 创建SystemServiceManager,负责服务的启动
382            mSystemServiceManager = new SystemServiceManager(mSystemContext);
383            mSystemServiceManager.setRuntimeRestarted(mRuntimeRestart);
384            LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
385            // Prepare the thread pool for init tasks that can be parallelized
386            SystemServerInitThreadPool.get();
387        } finally {
388            traceEnd();  // InitBeforeStartServices
389        }
390
391        //10、Start services. 真正的开启服务了
392        try {
393            traceBeginAndSlog("StartServices");
394            startBootstrapServices();
395            startCoreServices();
396            startOtherServices();
397            SystemServerInitThreadPool.shutdown();
398        } catch (Throwable ex) {
399            Slog.e("System", "******************************************");
400            Slog.e("System", "************ Failure starting system services", ex);
401            throw ex;
402        } finally {
403            traceEnd();
404        }
405
...
419
420        //11、 进入Loop循环,处理消息循环
421        Looper.loop();
422        throw new RuntimeException("Main thread loop unexpectedly exited");
423    }

main里面做的事情大概如下。

  • 检验时间:如果当前时间早于1970年,则设置当前时间为1970年,防止初始化出错。
  • 设置系统的语言环境等
  • 设置当前虚拟机的运行库路径为persist.sys.dalvik.vm.lib.2
  • 设置虚拟机的堆内存,虚拟机堆利用率为0.8
  • 调用prepareMainLooper()初始化当前线程的Looper
  • 加载libandroid_servers.so库
  • 调用createSystemContext()创建System的context,见【3.1.1小节】
  • 创建大管家SystemServiceManager的对象mSystemServiceManager,负责系统Service的管理,见【3.1.2小节】
  • 调用startBootstrapServices();startCoreServices();startOtherServices(),创建和运行系统中所有的服务,见【3.1.3小节】
  • 调用Looper.loop(),开启消息循环;
3.1.1、调用createSystemContext创建Context

createSystemContext中创建了2个Context,一个是mSystemContext,另一个是systemUiContext。

/frameworks/base/services/java/com/android/server/SystemServer.java
475    private void createSystemContext() {
476        ActivityThread activityThread = ActivityThread.systemMain();
477        mSystemContext = activityThread.getSystemContext();
478        mSystemContext.setTheme(DEFAULT_SYSTEM_THEME);
479
480        final Context systemUiContext = activityThread.getSystemUiContext();
481        systemUiContext.setTheme(DEFAULT_SYSTEM_THEME);
482    }
/frameworks/base/core/java/android/app/ActivityThread.java
6444    public static ActivityThread systemMain() {
6445        // The system process on low-memory devices do not get to use hardware
6446        // accelerated drawing, since this can add too much overhead to the
6447        // process.
6448        if (!ActivityManager.isHighEndGfx()) {
6449            ThreadedRenderer.disable(true);
6450        } else {
6451            ThreadedRenderer.enableForegroundTrimming();
6452        }
6453        ActivityThread thread = new ActivityThread();
6454        thread.attach(true);
6455        return thread;
6456    }
/frameworks/base/core/java/android/app/ActivityThread.java
6361    private void attach(boolean system) {
6362        sCurrentActivityThread = this;
6363        mSystemThread = system;
6364        if (!system) {
                //如果是个应用,走这里
6402        } else {
6403            // Don't set application object here -- if the system crashes,
6404            // we can't display an alert, we just want to die die die.
6405            android.ddm.DdmHandleAppName.setAppName("system_process",
6406                    UserHandle.myUserId());
6407            try {
                   //对于一个应用进程,该类会优先被创建出来,然后通过他来创建其他组件;另外,它还是系统与组件交互的桥梁,因而通过他可以监听组件和系统之间的各种交互了。
6408                mInstrumentation = new Instrumentation();
                   //mPackageInfo是一个LoadedApk对象
6409                ContextImpl context = ContextImpl.createAppContext(
6410                        this, getSystemContext().mPackageInfo);
6411                mInitialApplication = context.mPackageInfo.makeApplication(true, null);
                       //Application的onCreate回调,这个Application代表什么呢?
6412                mInitialApplication.onCreate();
6413            } catch (Exception e) {
6414                throw new RuntimeException(
6415                        "Unable to instantiate Application():" + e.toString(), e);
6416            }
6417        }
.......
6442    }

Instrumentation:对于一个应用进程,该类会优先被创建出来,然后通过他来创建其他组件;另外,它还是系统与组件交互的桥梁,因而通过他可以监听组件和系统之间的各种交互。

/frameworks/base/core/java/android/app/ActivityThread.java
2192    public ContextImpl getSystemContext() {
2193        synchronized (this) {
2194            if (mSystemContext == null) {
2195                mSystemContext = ContextImpl.createSystemContext(this);
2196            }
2197            return mSystemContext;
2198        }
2199    }
 /frameworks/base/core/java/android/app/ContextImpl.java
2215    static ContextImpl createSystemContext(ActivityThread mainThread) {
            //创建LoadedApk
2216        LoadedApk packageInfo = new LoadedApk(mainThread);
2217        ContextImpl context = new ContextImpl(null, mainThread, packageInfo, null, null, null, 0,
2218                null);
2219        context.setResources(packageInfo.getResources());
2220        context.mResources.updateConfiguration(context.mResourcesManager.getConfiguration(),
2221                context.mResourcesManager.getDisplayMetrics());
2222        return context;
2223    }

LoadedApk的构造方法如下:

 /frameworks/base/core/java/android/app/LoadedApk.java
182    /**
183     * Create information about the system package.
184     * Must call {@link #installSystemApplicationInfo} later.
185     */
186    LoadedApk(ActivityThread activityThread) {
187        mActivityThread = activityThread;
188        mApplicationInfo = new ApplicationInfo();
189        mApplicationInfo.packageName = "android";
190        mPackageName = "android";
......
208    }

LoadedAPK对象使用来保存一个apk文件的信息,这个构造方法中会将使用的包名指定为”android”,而framework-res.apk的包名正是”android”。意味着getSystemContext中创建的mSystemContext对象对应的apk文件是framework-res.apk。framework-res.apk文件位于/system/framework文件夹中,里面有着系统大部分的图片,包括图标,弹出对话框的样式,动作特效,界面布局。

《Android进程系列第四篇---SystemServer进程的启动流程》 framework-res.apk.png

更多的了解framework-res.apk请移步到ROM美化课堂之 framework-res.apk文件详解,介绍了framework-res.apk文件的具体包含的东西。同时我们也可以对这个framework-res.apk进行资源的修改,达到美化Rom的效果。

             //mPackageInfo是一个LoadedApk对象
6409       ContextImpl context = ContextImpl.createAppContext(this, getSystemContext().mPackageInfo);
6411       mInitialApplication = context.mPackageInfo.makeApplication(true, null);
           //Application的onCreate回调,这个Application代表什么呢?
6412       mInitialApplication.onCreate();

所以,getSystemContext().mPackageInfo是LoadedApk对象,对应的apk文件就是framework-res.apk。那么由mPackageInfo这个对象创建的mInitialApplication,代表的就是framework-res.apk的Application。

3.1.2、创建SystemServiceManager

System进程中运行的Service很多,有八十多种,每一个服务都要经历创建、启动。所以google搞了一个SystemServiceManager(系统服务管理者)一个人把这些事情都干完了。被SystemServiceManager管理的服务都必须继承com.android.server.SystemService或者该服务中的Lifecycle要继承com.android.server.SystemService。

    mSystemServiceManager = new SystemServiceManager(mSystemContext);

比如启动电源服务,只要传PowerManagerService的字节码就可以了,内部帮忙创建并且启动。这种设计确实可以学习一波。

  mPowerManagerService = mSystemServiceManager.startService(PowerManagerService.class);
/frameworks/base/services/core/java/com/android/server/SystemServiceManager.java
72    /**
73     * Creates and starts a system service. The class must be a subclass of
74     * {@link com.android.server.SystemService}.
75     *
76     * @param serviceClass A Java class that implements the SystemService interface.
77     * @return The service instance, never null.
78     * @throws RuntimeException if the service fails to start.
79     */
80    @SuppressWarnings("unchecked")
81    public <T extends SystemService> T startService(Class<T> serviceClass) {
82        try {
83            final String name = serviceClass.getName();
....
92            final T service;
93            try {
94                Constructor<T> constructor = serviceClass.getConstructor(Context.class);
95                service = constructor.newInstance(mContext);
96            } catch (InstantiationException ex) {
97                throw new RuntimeException("Failed to create service " + name
98                        + ": service could not be instantiated", ex);
99            } catch (IllegalAccessException ex) {
100                throw new RuntimeException("Failed to create service " + name
101                        + ": service must have a public constructor with a Context argument", ex);
102            } catch (NoSuchMethodException ex) {
103                throw new RuntimeException("Failed to create service " + name
104                        + ": service must have a public constructor with a Context argument", ex);
105            } catch (InvocationTargetException ex) {
106                throw new RuntimeException("Failed to create service " + name
107                        + ": service constructor threw an exception", ex);
108            }
109           //启动服务
110            startService(service);
111            return service;
112        } finally {
113            Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
114        }
115    }
/frameworks/base/services/core/java/com/android/server/SystemServiceManager.java
117    public void startService(@NonNull final SystemService service) {
118        // Register it.
119        mServices.add(service);
120        // Start it.
121        long time = System.currentTimeMillis();
122        try {
                 //回调服务的onStart方法
123            service.onStart();
124        } catch (RuntimeException ex) {
125            throw new RuntimeException("Failed to start service " + service.getClass().getName()
126                    + ": onStart threw an exception", ex);
127        }
128        warnIfTooLong(System.currentTimeMillis() - time, service, "onStart");
129    }

当服务创建成功并且启动之后,就会回调这个服务的onStart方法。

/frameworks/base/services/core/java/com/android/server/power/PowerManagerService.java
681    @Override
682    public void onStart() {
             //将服务发布出去,交给ServiceManager大管家。
683        publishBinderService(Context.POWER_SERVICE, new BinderService());
684        publishLocalService(PowerManagerInternal.class, new LocalService());
685       //加入Watchdog监控
686        Watchdog.getInstance().addMonitor(this);
687        Watchdog.getInstance().addThread(mHandler);
688    }
/frameworks/base/services/core/java/com/android/server/SystemService.java
202    /**
203     * Publish the service so it is accessible to other services and apps.
204     */
205    protected final void publishBinderService(String name, IBinder service,
206            boolean allowIsolated) {
207        ServiceManager.addService(name, service, allowIsolated);
208    }

经过了上面的过程,一个服务才能说的上被创建完成,对于其他的服务如此,和上面是一样的套路!拿AMS举例。

《Android进程系列第四篇---SystemServer进程的启动流程》 SystemServer服务管理.png

  • 创建服务:SystemServiceManager把AMS通过反射创建出来
  • 注册服务:首先AMS注册到ServiceManager。AMS所在进程(SystemServer)是客户端,ServiceManager是服务端。
  • 获取服务:Client进程使用AMS前,须先向ServiceManager中获取AMS的代理类AMP。该过程。AMP所在进程(应用进程)是客户端,ServiceManager是服务端。
  • 使用服务: app进程根据得到的代理类AMP,便可以直接与AMS所在进程交互。该过程,AMP所在进程(应用进程)是客户端,AMS所在进程(SystemServer)是服务端。

区别:
ServiceManager这个类的主要方法有addService(),getService(),listServices()。所以这个类的主要职责是控制用户访问服务,而SystemServiceManager负责服务的创建和启动。

延伸阅读:ServiceManager是在什么时候创建的?
和Zygote进程一样,也是init进程解析servicemanager.rc文件创建的,具体的在本文不深究了。

service servicemanager /system/bin/servicemanager
    class core animation
    user system
    group system readproc
    critical
    onrestart restart healthd
    onrestart restart zygote
    onrestart restart audioserver
    onrestart restart media
    onrestart restart surfaceflinger
    onrestart restart inputflinger
    onrestart restart drm
    onrestart restart cameraserver
    writepid /dev/cpuset/system-background/tasks
3.1.3、核心服务的启动

上面介绍System中服务的启动方式,现在就到了启动一个个服务了。系统服务大概分成三类,引导服务,核心服务,其他服务,分别对于三个方法,startBootstrapServices、startCoreServices、startOtherServices。
启动引导服务

/frameworks/base/services/java/com/android/server/SystemServer.java
491    private void startBootstrapServices() {
.......
501        traceBeginAndSlog("StartInstaller");
502        Installer installer = mSystemServiceManager.startService(Installer.class);
503        traceEnd();
504
505        // In some cases after launching an app we need to access device identifiers,
506        // therefore register the device identifier policy before the activity manager.
507        traceBeginAndSlog("DeviceIdentifiersPolicyService");
508        mSystemServiceManager.startService(DeviceIdentifiersPolicyService.class);
509        traceEnd();
510
511        // Activity manager runs the show.
512        traceBeginAndSlog("StartActivityManager");
513        mActivityManagerService = mSystemServiceManager.startService(
514                ActivityManagerService.Lifecycle.class).getService();
515        mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
516        mActivityManagerService.setInstaller(installer);
517        traceEnd();
.......
523        traceBeginAndSlog("StartPowerManager");
524        mPowerManagerService = mSystemServiceManager.startService(PowerManagerService.class);
525        traceEnd();
.......

545        // Manages LEDs and display backlight so we need it to bring up the display.
546        traceBeginAndSlog("StartLightsService");
547        mSystemServiceManager.startService(LightsService.class);
548        traceEnd();
549
550        // Display manager is needed to provide display metrics before package manager
551        // starts up.
552        traceBeginAndSlog("StartDisplayManager");
553        mDisplayManagerService = mSystemServiceManager.startService(DisplayManagerService.class);
554        traceEnd();
555
556        // We need the default display before we can initialize the package manager.
557        traceBeginAndSlog("WaitForDisplay");
558        mSystemServiceManager.startBootPhase(SystemService.PHASE_WAIT_FOR_DEFAULT_DISPLAY);
559        traceEnd();
560
.......
577        mPackageManagerService = PackageManagerService.main(mSystemContext, installer,
578                mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF, mOnlyCore);
579        mFirstBoot = mPackageManagerService.isFirstBoot();
580        mPackageManager = mSystemContext.getPackageManager();
.......
604        traceBeginAndSlog("StartUserManagerService");
605        mSystemServiceManager.startService(UserManagerService.LifeCycle.class);
606        traceEnd();
607
608        // Initialize attribute cache used to cache resources from packages.
609        traceBeginAndSlog("InitAttributerCache");
610        AttributeCache.init(mSystemContext);
611        traceEnd();
612
613        // Set up the Application instance for the system process and get started.
614        traceBeginAndSlog("SetSystemProcess");
615        mActivityManagerService.setSystemProcess();
616        traceEnd();
617
618        // DisplayManagerService needs to setup android.display scheduling related policies
619        // since setSystemProcess() would have overridden policies due to setProcessGroup
620        mDisplayManagerService.setupSchedulerPolicies();
621
622        // Manages Overlay packages
623        traceBeginAndSlog("StartOverlayManagerService");
624        mSystemServiceManager.startService(new OverlayManagerService(mSystemContext, installer));
.......
638    }

大概知道哪些是属于引导服务,比如ActivityManagerService, PowerManagerService, LightsService, DisplayManagerService, PackageManagerService, UserManagerService, Sensor等,WMS是在other中启动的。

/frameworks/base/services/java/com/android/server/SystemServer.java
641     * Starts some essential services that are not tangled up in the bootstrap process.
642     */
643    private void startCoreServices() {
644        // Records errors and logs, for example wtf()
645        traceBeginAndSlog("StartDropBoxManager");
646        mSystemServiceManager.startService(DropBoxManagerService.class);
647        traceEnd();
648
649        traceBeginAndSlog("StartBatteryService");
650        // Tracks the battery level.  Requires LightService.
651        mSystemServiceManager.startService(BatteryService.class);
652        traceEnd();
653
654        // Tracks application usage stats.
655        traceBeginAndSlog("StartUsageService");
656        mSystemServiceManager.startService(UsageStatsService.class);
657        mActivityManagerService.setUsageStatsManager(
658                LocalServices.getService(UsageStatsManagerInternal.class));
659        traceEnd();
660
661        // Tracks whether the updatable WebView is in a ready state and watches for update installs.
662        traceBeginAndSlog("StartWebViewUpdateService");
663        mWebViewUpdateService = mSystemServiceManager.startService(WebViewUpdateService.class);
664        traceEnd();
665    }

CoreService中比较少,主要有BatteryService,UsageStatsService,WebViewUpdateService

 /**
668     * Starts a miscellaneous grab bag of stuff that has yet to be refactored
669     * and organized.
670     */
671    private void startOtherServices() {
......
722        try {
......
778            // The AccountManager must come before the ContentService
779            traceBeginAndSlog("StartAccountManagerService");
780            mSystemServiceManager.startService(ACCOUNT_SERVICE_CLASS);
781            traceEnd();
782
783            traceBeginAndSlog("StartContentService");
784            mSystemServiceManager.startService(CONTENT_SERVICE_CLASS);
785            traceEnd();
786
787            traceBeginAndSlog("InstallSystemProviders");
788            mActivityManagerService.installSystemProviders();
789            traceEnd();
790
791            traceBeginAndSlog("StartVibratorService");
792            vibrator = new VibratorService(context);
793            ServiceManager.addService("vibrator", vibrator);
794            traceEnd();
......
802
803            traceBeginAndSlog("StartAlarmManagerService");
804            mSystemServiceManager.startService(AlarmManagerService.class);
805            traceEnd();
806
807            traceBeginAndSlog("InitWatchdog");
808            final Watchdog watchdog = Watchdog.getInstance();
809            watchdog.init(context, mActivityManagerService);
810            traceEnd();
811
812            traceBeginAndSlog("StartInputManagerService");
813            inputManager = new InputManagerService(context);
814            traceEnd();
815
816            traceBeginAndSlog("StartWindowManagerService");
817            // WMS needs sensor service ready
818            ConcurrentUtils.waitForFutureNoInterrupt(mSensorServiceStart, START_SENSOR_SERVICE);
819            mSensorServiceStart = null;
820            wm = WindowManagerService.main(context, inputManager,
821                    mFactoryTestMode != FactoryTest.FACTORY_TEST_LOW_LEVEL,
822                    !mFirstBoot, mOnlyCore, new PhoneWindowManager());
823            ServiceManager.addService(Context.WINDOW_SERVICE, wm);
824            ServiceManager.addService(Context.INPUT_SERVICE, inputManager);
825            traceEnd();
826
827            // Start receiving calls from HIDL services. Start in in a separate thread
828            // because it need to connect to SensorManager. This have to start
829            // after START_SENSOR_SERVICE is done.
830            SystemServerInitThreadPool.get().submit(() -> {
831                traceBeginAndSlog(START_HIDL_SERVICES);
832                startHidlServices();
833                traceEnd();
834            }, START_HIDL_SERVICES);
835
......
1561        // Needed by DevicePolicyManager for initialization
1562        traceBeginAndSlog("StartBootPhaseLockSettingsReady");
1563        mSystemServiceManager.startBootPhase(SystemService.PHASE_LOCK_SETTINGS_READY);
1564        traceEnd();
1565
1566        traceBeginAndSlog("StartBootPhaseSystemServicesReady");
1567        mSystemServiceManager.startBootPhase(SystemService.PHASE_SYSTEM_SERVICES_READY);
1568        traceEnd();
1569
......
}

这里面启动的服务是最多的,不一一列举了,它的最后的一个环节是AMS.systemReady(),紧接着Home就被启动了。

虽然上面的逻辑简单,但是毕竟启动了这么多的服务,为了出了问题可以快速定位,也可以看见打印了不少log,此外不知道是否注意到startBootPhase这个方法,因为Sytem启动被划分成几个阶段,不同的阶段干了不同的事情,前面一个阶段的事情完成了才可以进入下一个阶段。这样在开不了机器,我们首先可以根据phase确定启动到哪一步的工作了。

131    /**
132     * Starts the specified boot phase for all system services that have been started up to
133     * this point.
134     *
135     * @param phase The boot phase to start.
136     */
137    public void startBootPhase(final int phase) {
138        if (phase <= mCurrentPhase) {
139            throw new IllegalArgumentException("Next phase must be larger than previous");
140        }
141        mCurrentPhase = phase;
142
143        Slog.i(TAG, "Starting phase " + mCurrentPhase);
144        try {
145            Trace.traceBegin(Trace.TRACE_TAG_SYSTEM_SERVER, "OnBootPhase " + phase);
146            final int serviceLen = mServices.size();
147            for (int i = 0; i < serviceLen; i++) {
148                final SystemService service = mServices.get(i);
149                long time = System.currentTimeMillis();
150                Trace.traceBegin(Trace.TRACE_TAG_SYSTEM_SERVER, service.getClass().getName());
151                try {
                         //回调每个Service中的onBootPhase方法
152                    service.onBootPhase(mCurrentPhase);
153                } catch (Exception ex) {
154                    throw new RuntimeException("Failed to boot service "
155                            + service.getClass().getName()
156                            + ": onBootPhase threw an exception during phase "
157                            + mCurrentPhase, ex);
158                }
159                warnIfTooLong(System.currentTimeMillis() - time, service, "onBootPhase");
160                Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
161            }
162        } finally {
163            Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
164        }
165    }

SystemServer中定义了如下几个阶段。

 /frameworks/base/services/java/com/android/server/SystemServer.java
  
/* 
 * Boot Phases 
 */  
public static final int PHASE_WAIT_FOR_DEFAULT_DISPLAY = 100; // maybe should be a dependency?  
  
/** 
 * After receiving this boot phase, services can obtain lock settings data. 
  
 */  
在接收到这个引导阶段之后,服务可以获得锁设置数据。
public static final int PHASE_LOCK_SETTINGS_READY = 480;  
  
/** 
 * After receiving this boot phase, services can safely call into core system services 
 * such as the PowerManager or PackageManager. 
 
 */  
 接收这个启动阶段后,服务可以安全地调用核心系统服务,如PowerManager或器
public static final int PHASE_SYSTEM_SERVICES_READY = 500;  
  
/** 
 * After receiving this boot phase, services can broadcast Intents. 
   
 */  
在接收到这个引导阶段后,服务可以广播意图。
public static final int PHASE_ACTIVITY_MANAGER_READY = 550;  
  
/** 
 * After receiving this boot phase, services can start/bind to third party apps. 
 * Apps will be able to make Binder calls into services at this point. 
 */  
在接收到这个引导阶段之后,服务可以启动/绑定到第三方应用程序,此时应用程序将能够将绑定调用变成服务。
public static final int PHASE_THIRD_PARTY_APPS_CAN_START = 600;  
  
/** 
 * After receiving this boot phase, services can allow user interaction with the device. 
 * This phase occurs when boot has completed and the home application has started. 
 * System services may prefer to listen to this phase rather than registering a 
 * broadcast receiver for ACTION_BOOT_COMPLETED to reduce overall latency. 
 */ 
在接收到这个引导阶段之后,服务可以允许用户与设备交互。
此阶段发生在启动完成和家庭应用程序启动时。
系统服务可能更喜欢听这个阶段而不是注册的广播接收器,action_boot_completed降低整体延迟。

public static final int PHASE_BOOT_COMPLETED = 1000;  

每个阶段做的事情都必须完成,假设某一个阶段执行的任务失败了,就会抛出异常。下面是启动网络服务失败的log。

E/AndroidRuntime( 5899): *** FATAL EXCEPTION IN SYSTEM PROCESS: main
E/AndroidRuntime( 5899): java.lang.RuntimeException: Failed to boot service com.android.server.ethernet.EthernetService: onBootPhase threw an exception during phase 500
E/AndroidRuntime( 5899): at com.android.server.SystemServiceManager.startBootPhase(SystemServiceManager.java:137)
E/AndroidRuntime( 5899): at com.android.server.SystemServer.startOtherServices(SystemServer.java:1071)
E/AndroidRuntime( 5899): at com.android.server.SystemServer.run(SystemServer.java:274)
E/AndroidRuntime( 5899): at com.android.server.SystemServer.main(SystemServer.java:186)
E/AndroidRuntime( 5899): at java.lang.reflect.Method.invoke(Native Method)
E/AndroidRuntime( 5899): at java.lang.reflect.Method.invoke(Method.java:372)
E/AndroidRuntime( 5899): at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:909)
E/AndroidRuntime( 5899): at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:704)
E/AndroidRuntime( 5899): Caused by: java.lang.IllegalStateException: command '1 interface list' failed with 'null'
E/AndroidRuntime( 5899): at com.android.server.NetworkManagementService.listInterfaces(NetworkManagementService.java:813)
E/AndroidRuntime( 5899): at com.android.server.ethernet.EthernetNetworkFactory.start(EthernetNetworkFactory.java:377)
E/AndroidRuntime( 5899): at com.android.server.ethernet.EthernetServiceImpl.start(EthernetServiceImpl.java:95)
E/AndroidRuntime( 5899): at com.android.server.ethernet.EthernetService.onBootPhase(EthernetService.java:42)
E/AndroidRuntime( 5899): at com.android.server.SystemServiceManager.startBootPhase(SystemServiceManager.java:135)
E/AndroidRuntime( 5899): ... 7 more
E/AndroidRuntime( 5899): Caused by: com.android.server.NativeDaemonConnector$NativeDaemonFailureException: command '1 interface list' failed with 'null'
E/AndroidRuntime( 5899): at com.android.server.NativeDaemonConnector.execute(NativeDaemonConnector.java:416)
E/AndroidRuntime( 5899): at com.android.server.NativeDaemonConnector.executeForList(NativeDaemonConnector.java:367)
E/AndroidRuntime( 5899): at com.android.server.NetworkManagementService.listInterfaces(NetworkManagementService.java:810)
E/AndroidRuntime( 5899): ... 11 more

最后拿一张我们组的大神辉辉老师的图,每个阶段干的主要的事情一目了然。

《Android进程系列第四篇---SystemServer进程的启动流程》

SystemServer进程的启动流程的大概总结:

  • SystemServer进程由Zygote进程启动

  • SystemServer进程的main入口中,首先会初始化一些系统变量,加载类库,创建Context对象,创建SystemServiceManager对象等,不要混淆SystemServiceManager和ServiceManager。

  • 做完上面的事情之后,启动系统中的服务,高达八十多种

  • SystemServer进程将系统服务分为三类:boot服务,core服务、other服务,并逐步启动

  • 把握启动阶段,方便定位问题

参考链接:
https://github.com/yipianfengye/androidSource
http://gityuan.com/2016/02/20/android-system-server-2/

    原文作者:LooperJing
    原文地址: https://www.jianshu.com/p/99e0b480666a
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞