Android SystemServer启动流程源码解析

来源：互联网发布：tomcat连不上mysql 编辑：程序博客网时间：2024/06/14 05:27

简介

Android系统中各个进程的先后顺序为：

init进程 –-> Zygote进程 –> SystemServer进程 –>应用进程

其中Zygote进程由init进程启动，SystemServer进程和应用进程由Zygote进程启动。

本文依据6.0源码，主要分析SystemServer进程的启动流程。注意，是启动流程，不是启动过程。启动过程的解析可以移步我的另一片博文Zygote启动流程源码解析。SystemServer进程的作用是启动各种核心服务，例如Installer、ActivityManagerService、WindowManagerService、PowerManagerService等等。这些服务会在开机时启动。由于加载的服务很多，相对很耗时，所以Android系统在开机时速度很慢，但是一次加载之后，方便后续所有应用程序调用，所以这个代价还是非常值得的。由于加载的服务实在太多，故本文不可能分析所有的服务。分析完主要流程后，会适当举例分析，其余服务还请自行查看。从Android Zygote启动流程源码解析一文中可以看到：Zygote进程fork出SystemServer进程后，通过反射调用SystemServer#main()。以此为切入点，一步步分析。

启动流程概览

源码位置：frameworks/base/services/java/com/android/server/SystemServer.java
SystemServer#main()

    /**     * The main entry point from zygote.     */    public static void main(String[] args) {        new SystemServer().run();    }    public SystemServer() {        // Check for factory test mode.        mFactoryTestMode = FactoryTest.getMode();    }    private void run() {        ...        // 创建主线程Looper        Looper.prepareMainLooper();        // 加载android_servers.so        System.loadLibrary("android_servers");        // 创建Context对象        createSystemContext();        // 创建SystemServiceManager对象        mSystemServiceManager = new SystemServiceManager(mSystemContext);        // 将刚创建的SystemServiceManager对象添加进LocalServices属性sLocalServiceObjects        LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);        // Start services.        try {            // 启动系统引导相关服务            startBootstrapServices();            // 启动系统核心服务            startCoreServices();            // 启动应用或系统相关的服务            startOtherServices();        } catch (Throwable ex) {...}        ...        // Loop forever.        Looper.loop();        throw new RuntimeException("Main thread loop unexpectedly exited");    }

上面截取了最关键的代码，也是本文重点要分析的内容。可以看到，在Main（）方法中实例化之后直接调用了run()方法。在run()方法中首先获取主线程的Looper对象，这也就意味着SystemServer后续是可以获取主线程中的消息。下面先分析createSystemContext()。

创建Context对象

SystemServer#createSystemContext()

    private void createSystemContext() {        ActivityThread activityThread = ActivityThread.systemMain();        mSystemContext = activityThread.getSystemContext();        mSystemContext.setTheme(android.R.style.Theme_DeviceDefault_Light_DarkActionBar);    }

在createSystemContext()中首先获取了一个ActivityThread对象，紧接着根据ActivityThread对象获取了mSystemContext，mSystemContext是Context对象。这可不得了。我们知道，ActivityThread其实就是所谓的主线程，看来ActivityThread#systemMain()这个方法大有搞头。跟进。

源码位置：frameworks/base/core/java/android/app/ActivityThread.java
ActivityThread#systemMain()

    public static ActivityThread systemMain() {        ...        ActivityThread thread = new ActivityThread();        thread.attach(true);        return thread;    }

在ActivityThread#systemMain()中直接new了一个ActivityThread对象，然后调用ActivityThread#attach()方法。跟进。

    ActivityThread() {        mResourcesManager = ResourcesManager.getInstance();    }    private void attach(boolean system) {        sCurrentActivityThread = this;        mSystemThread = system;        if (!system) {           ...        } else {            ...                mInstrumentation = new Instrumentation();                ContextImpl context = ContextImpl.createAppContext(this, getSystemContext().mPackageInfo);                mInitialApplication = context.mPackageInfo.makeApplication(true, null);                mInitialApplication.onCreate();           ...        }       ...

可以看到，调用ContextImpl的静态方法createAppContext()获取一个ContextImpl对象，然后调用LoadedApk（mPackageInfo是LoadedApk的一个对象）#makeApplication()创建了Application，最后调用Application#onCreate()方法。SystemServer也是一个Android进程，由此可以看出，进程创建后最先被调用的是ActivityThread#attach()，其次才是Application#onCreate()。

创建SystemServiceManager

回到SystemServer#run()。

    private void run() {        ...         createSystemContext();        // 创建SystemServiceManager对象        mSystemServiceManager = new SystemServiceManager(mSystemContext);        // 将刚创建的SystemServiceManager对象添加进LocalServices属性sLocalServiceObjects        LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);        ...    }

获取到Context对象后，创建mSystemServiceManager用于管理各种系统服务。接下来就开始启动各种系统服务。文章有限，这里以启动Installer、ActivityManagerService和WindowManagerService为例进行分析，其余还请自行查看。

启动各种服务

ActivityThread#startBootstrapServices()

  startBootstrapServices();  startCoreServices();  startOtherServices();

启动Installer

    private void startBootstrapServices() {        Installer installer = mSystemServiceManager.startService(Installer.class);    }

通过SystemServiceManager#startService()方法，就启动了Installer。跟进。

源码位置：frameworks/base/services/core/java/com/android/server/SystemServerManager.java
SystemServiceManager#startService()

    public <T extends SystemService> T startService(Class<T> serviceClass) {        if (!SystemService.class.isAssignableFrom(serviceClass)) {            throw new RuntimeException("Failed to create " + name                    + ": service must extend " + SystemService.class.getName());        }        final T service;        Constructor<T> constructor = serviceClass.getConstructor(Context.class);        service = constructor.newInstance(mContext);        mServices.add(service);        service.onStart();        return service;    }

传入的泛型必须是抽象类SystemService的子类，并且通过反射得到实例。最后添加进ArrayList<SystemService> mServices中以便管理。最后调用泛型Service中抽象父类的抽象方法onStart()的具体实现。跟进。

源码位置：frameworks/base/services/core/java/com/android/server/pm/Installer.java
Installer#onStart()

    public void onStart() {        mInstaller.waitForConnection();    }

mInstaller是InstallerConnection对象。跟进。

源码位置：frameworks/base/services/core/java/com/android/internal/os/InstallerConnection.java
InstallerConnection#waitForConnection()

    public void waitForConnection() {        for (;;) {            if (execute("ping") >= 0) {                return;            }            Slog.w(TAG, "installd not ready");            SystemClock.sleep(1000);        }    }

这里有个死循环，说明只有execute()方法执行成功并且返回值大于0之后才会继续启动其他服务。否则一直卡在这里。跟进。

    public int execute(String cmd) {        String res = transact(cmd);        try {            return Integer.parseInt(res);        } catch (NumberFormatException ex) {            return -1;        }    }    public synchronized String transact(String cmd) {        if (!connect()) {            return "-1";        }        if (!writeCommand(cmd)) {            if (!connect() || !writeCommand(cmd)) {                return "-1";            }        }        final int replyLength = readReply();        if (replyLength > 0) {            String s = new String(buf, 0, replyLength);            return s;        } else {            return "-1";        }    }    private boolean connect() {        if (mSocket != null) {            return true;        }        Slog.i(TAG, "connecting...");        try {            mSocket = new LocalSocket();            LocalSocketAddress address = new LocalSocketAddress("installd",                    LocalSocketAddress.Namespace.RESERVED);            mSocket.connect(address);            mIn = mSocket.getInputStream();            mOut = mSocket.getOutputStream();        } catch (IOException ex) {            disconnect();            return false;        }        return true;    }    private boolean writeCommand(String cmdString) {        final byte[] cmd = cmdString.getBytes();        final int len = cmd.length;        if ((len < 1) || (len > buf.length)) {            return false;        }        buf[0] = (byte) (len & 0xff);        buf[1] = (byte) ((len >> 8) & 0xff);        try {            mOut.write(buf, 0, 2);            mOut.write(cmd, 0, len);        } catch (IOException ex) {            Slog.e(TAG, "write error");            disconnect();            return false;        }        return true;    }

为了方便查看，连续贴了三个相关的方法。稍微显得有些长，没关系，我们一个个去分析。首先调用connect()方法通过Socket连接installd服务端。接着调用writeCommand()方法写入要发送的数据，这里参数cmdString是ping，所以len=4。最后通过readReply()方法，读取服务端返回的数据，转换成String形式返回。之后启动其它服务。

启动ActivityManagerService

    private void startBootstrapServices() {        mActivityManagerService = mSystemServiceManager.startService(        ActivityManagerService.Lifecycle.class).getService();        mActivityManagerService.setSystemServiceManager(mSystemServiceManager);        mActivityManagerService.setInstaller(installer);    }

这里和启动Installer不同，startService()传入的是ActivityManagerService.Lifecycle.class，之后调用startService()返回值的getService()方法。跟进。

源码位置：frameworks/base/services/core/java/com/android/servicer/am/ActivityManagerService.java
ActivityManagerService$Lifecycle

    public static final class Lifecycle extends SystemService {        private final ActivityManagerService mService;        public Lifecycle(Context context) {            super(context);            mService = new ActivityManagerService(context);        }        @Override        public void onStart() {            mService.start();        }        public ActivityManagerService getService() {            return mService;        }    }

Lifecycle是ActivityManagerService的一个final类型的静态内部类。在分析SystemServiceManager#startService()说道：通过反射得到实例。最后添加进ArrayList<SystemService> mServices中以便管理。最后调用泛型Service中抽象父类的抽象方法onStart()的具体实现。所以这里首先会实例化ActivityManagerService对象，然后调用Lifecycle#onStart()。在Lifecycle#onStart()中调用ActivityManagerService#start()。最后getService()返回实例化过的ActivityManagerService对象。由于ActivityManagerService#start()相关代码太多，这里就不详细展开了。有时间单独写一篇博文解析。

启动WindowManagerService

    private void startOtherServices() {          wm = WindowManagerService.main(context, inputManager,                    mFactoryTestMode != FactoryTest.FACTORY_TEST_LOW_LEVEL,                    !mFirstBoot, mOnlyCore);    }

这里和启动Installer、ActivityManagerService又有些不同，直接调用WindowManagerService#main()。真的是简单粗暴。跟进。

    public static WindowManagerService main(final Context context,            final InputManagerService im,            final boolean haveInputMethods, final boolean showBootMsgs,            final boolean onlyCore) {        final WindowManagerService[] holder = new WindowManagerService[1];        DisplayThread.getHandler().runWithScissors(new Runnable() {            @Override            public void run() {                holder[0] = new WindowManagerService(context, im,                        haveInputMethods, showBootMsgs, onlyCore);            }        }, 0);        return holder[0];    }

相关代码太长，有时间单独再写一篇。其它服务的启动和上面三种服务启动大相径庭，感兴趣的同学请自行查看。2点多，有些困。明天还要上班，古耐~

更多Framework源码解析，请移步 Framework源码解析系列[目录]

2 0