SystemServer简介

系统启动过程：由init进程->Zygote进程->SystemServer进程。

SystemServer由zygote进程启动。启动后，会调用SystemServer.main()方法：

SystemServer.java
public final class SystemServer {
    public static void main(String[] args) {
        //创建SystemServer实例并调用run()方法
        new SystemServer().run();
    }

    public SystemServer() {
        // Check for factory test mode.
        mFactoryTestMode = FactoryTest.getMode();
    }

    //初始化开始
    private void run() {
        try {
            //初始化时间
            if (System.currentTimeMillis() < EARLIEST_SUPPORTED_TIME) {
                Slog.w(TAG, "System clock is before 1970; setting to 1970.");
                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 systemserver
            Slog.i(TAG, "Entered the Android system server!");
            EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_SYSTEM_RUN, SystemClock.uptimeMillis());

            SystemProperties.set("persist.sys.dalvik.vm.lib.2", VMRuntime.getRuntime().vmLibrary());

            // Enable the sampling profiler.
            if (SamplingProfilerIntegration.isEnabled()) {
                SamplingProfilerIntegration.start();
                mProfilerSnapshotTimer = new Timer();
                mProfilerSnapshotTimer.schedule(new TimerTask() {
                        @Override
                        public void run() {
                            SamplingProfilerIntegration.writeSnapshot("system_server", null);
                        }
                    }, SNAPSHOT_INTERVAL, SNAPSHOT_INTERVAL);
            }

            // Mmmmmm... more memory!
            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.
            VMRuntime.getRuntime().setTargetHeapUtilization(0.8f);
          
            //如果支持指纹，需初始化指纹ro.build.fingerprint
            Build.ensureFingerprintProperty();
  
            Environment.setUserRequired(true);

            // Ensure binder calls into the system always run at foreground priority.
            BinderInternal.disableBackgroundScheduling(true);

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

            // Initialize native services.
            System.loadLibrary("android_servers");
      
            // 检查最近一次关机是否失败
            performPendingShutdown();
         
            // 初始化system context.
            createSystemContext();

            // 创建 SystemServiceManager
            mSystemServiceManager = new SystemServiceManager(mSystemContext);
            LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
        } finally {
            Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
        }

        // 开始启动 services.
        try {
            Trace.traceBegin(Trace.TRACE_TAG_SYSTEM_SERVER, "StartServices");
            // 1. 启动引导服务
            startBootstrapServices();
            // 2. 启动核心服务
            startCoreServices();
            // 3.启动其他服务
            startOtherServices();
        } catch (Throwable ex) {
            Slog.e("System", "******************************************");
            Slog.e("System", "************ Failure starting system services", ex);
            throw ex;
        } finally {
            Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
        }

        // For debug builds, log event loop stalls to dropbox for analysis.
        if (StrictMode.conditionallyEnableDebugLogging()) {
            Slog.i(TAG, "Enabled StrictMode for system server main thread.");
        }

        // Loop forever.
        //Looper开始循环
        Looper.loop();
        throw new RuntimeException("Main thread loop unexpectedly exited");
    }

}

可以看到，SystemServer.main()方法主要是做初始化操作，并且开启服务:

SystemServer.java
public final class SystemServer {
    //启动引导服务
     private void startBootstrapServices() {
        //启动Installer
        Installer installer = mSystemServiceManager.startService(Installer.class);

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

        //启动PMS
        mPowerManagerService = mSystemServiceManager.startService(PowerManagerService.class);
      
        Trace.traceBegin(Trace.TRACE_TAG_SYSTEM_SERVER, "InitPowerManagement");
        mActivityManagerService.initPowerManagement();
        Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);

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

        
        // Start the package manager.
        traceBeginAndSlog("StartPackageManagerService");
        //启动PackageManagerService
        mPackageManagerService = PackageManagerService.main(mSystemContext, installer,
                mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF, mOnlyCore);
        mFirstBoot = mPackageManagerService.isFirstBoot();
        mPackageManager = mSystemContext.getPackageManager();
        Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);

        traceBeginAndSlog("StartUserManagerService");
        //启动UserManagerService
        ServiceManager.addService(Context.USER_SERVICE, UserManagerService.getInstance());
        Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);

        // Initialize attribute cache used to cache resources from packages.
        AttributeCache.init(mSystemContext);

        // Set up the Application instance for the system process and get started.
        mActivityManagerService.setSystemProcess();

        // The sensor service needs access to package manager service, app ops
        // service, and permissions service, therefore we start it after them.
        startSensorService();
    }

    //开启核心服务
    private void startCoreServices() {
        // Tracks the battery level.  Requires LightService.
        //启动BatteryService，跟踪电池电量
        mSystemServiceManager.startService(BatteryService.class);

        // Tracks application usage stats.
        //跟踪应用程序使用情况统计信息
        mSystemServiceManager.startService(UsageStatsService.class);
        mActivityManagerService.setUsageStatsManager(
                LocalServices.getService(UsageStatsManagerInternal.class));
        // Update after UsageStatsService is available, needed before performBootDexOpt.
        mPackageManagerService.getUsageStatsIfNoPackageUsageInfo();

        // Tracks whether the updatable WebView is in a ready state and watches for update installs.
        //启动WebViewUpdateService
        mSystemServiceManager.startService(WebViewUpdateService.class);
    }

    //开启其他服务
    private void startOtherServices() {
        traceBeginAndSlog("StartSchedulingPolicyService");
        ServiceManager.addService("scheduling_policy", new SchedulingPolicyService());
        Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);

        ......        

        traceBeginAndSlog("StartWindowManagerService");
        wm = WindowManagerService.main(context, inputManager,
                    mFactoryTestMode != FactoryTest.FACTORY_TEST_LOW_LEVEL,
                    !mFirstBoot, mOnlyCore);
        ServiceManager.addService(Context.WINDOW_SERVICE, wm);
        ServiceManager.addService(Context.INPUT_SERVICE, inputManager);
        Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
        
        ......

         if (!disableSystemUI) {
                traceBeginAndSlog("StartStatusBarManagerService");
            try {
                statusBar = new StatusBarManagerService(context, wm);
                ServiceManager.addService(Context.STATUS_BAR_SERVICE, statusBar);
            } catch (Throwable e) {
                reportWtf("starting StatusBarManagerService", e);
            }
            Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
        }

        ......

        mActivityManagerService.systemReady(new Runnable() {
            @Override
            public void run() {
                Slog.i(TAG, "Making services ready");
                mSystemServiceManager.startBootPhase(
                        SystemService.PHASE_ACTIVITY_MANAGER_READY);
                Trace.traceBegin(Trace.TRACE_TAG_SYSTEM_SERVER, "PhaseActivityManagerReady");

                Trace.traceBegin(Trace.TRACE_TAG_SYSTEM_SERVER, "StartObservingNativeCrashes");
                try {
                    mActivityManagerService.startObservingNativeCrashes();
                } catch (Throwable e) {
                    reportWtf("observing native crashes", e);
                }
                Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
           ......
        }

        ......
    }

}

服务的开启可以分为：

①开启引导服务，AMS,PKMS，PMS等；

②开启核心服务，BatteryService等；

③开启其他服务，比如WMS等，当核心系统服务启动完成后调用AMS.systemReady()方法，再启动一些服务，比如SystemUIService等；

 

服务的开启有以下几种方式：

1.通过SystemServiceManager.startService()：

以mPowerManagerService = mSystemServiceManager.startService(PowerManagerService.class)为例：

public class SystemServiceManager {
    public SystemService startService(String className) {
        final Class<SystemService> serviceClass;
        try {
            //通过类名反射拿到service类的class对象
            serviceClass = (Class<SystemService>)Class.forName(className);
        } catch (ClassNotFoundException ex) {
            Slog.i(TAG, "Starting " + className);
            throw new RuntimeException("Failed to create service " + className
                    + ": service class not found, usually indicates that the caller should "
                    + "have called PackageManager.hasSystemFeature() to check whether the "
                    + "feature is available on this device before trying to start the "
                    + "services that implement it", ex);
        }
        return startService(serviceClass);
    }

    public <T extends SystemService> T startService(Class<T> serviceClass) {
        try {
            final String name = serviceClass.getName();
            Slog.i(TAG, "Starting " + name);
            Trace.traceBegin(Trace.TRACE_TAG_SYSTEM_SERVER, "StartService " + name);

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

            // Register it.
            //将服务注册到SystemServiceManager中
            mServices.add(service);

            // Start it.
            try {
                //调用服务的onStart()方法
                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);
        }
    }

}

通过反射来实例化Service类，并调用Servcie的onStart()方法，能享受此待遇的service一般都是核心service；

2.创建service对象，并添加到ServiceManager中；

InputManagerService inputManager = new InputManagerService(context);
ServiceManager.addService(Context.INPUT_SERVICE, inputManager);

ServiceManager.addService(Context.USER_SERVICE, UserManagerService.getInstance());

ServiceManager.java
public static void addService(String name, IBinder service) {
    try {
        getIServiceManager().addService(name, service, false);
    } catch (RemoteException e) {
        Log.e(TAG, "error in addService", e);
    }
}

private static IServiceManager getIServiceManager() {
    if (sServiceManager != null) {
        return sServiceManager;
    }

    // Find the service manager
    sServiceManager = ServiceManagerNative.asInterface(BinderInternal.getContextObject());
    return sServiceManager;
}

现在暂时可以这样理解，通过Context.USER_SERVICE将UserManagerService保存在了ServiceManager当中，后面到了进程间通信再详细解释。

把UserManagerService保存在了ServiceManager当中有什么作用呢？

我们在客户端获取一个系统服务，一般是用：

UserManager um = (UserManager) context.getSystemService(Context.USER_SERVICE);

context的getSystemService(）由ComtextImpl来实现：

ComtextImpl.java
 public Object getSystemService(String name) {
    return SystemServiceRegistry.getSystemService(this, name);
}


SystemServiceRegistry.java
//获取service
public static Object getSystemService(ContextImpl ctx, String name) {
    ServiceFetcher<?> fetcher = SYSTEM_SERVICE_FETCHERS.get(name);
    return fetcher != null ? fetcher.getService(ctx) : null;
}


//看看Context.USER_SERVICE是怎么注册的
//SystemServiceRegistry在静态static代码块中完成了注册
registerService(Context.USER_SERVICE, UserManager.class,
                new CachedServiceFetcher<UserManager>() {
        @Override
        public UserManager createService(ContextImpl ctx) {
            //这个就是保存在ServiceManager中UserManagerService
            IBinder b = ServiceManager.getService(Context.USER_SERVICE);
            //将b作为代理
            IUserManager service = IUserManager.Stub.asInterface(b);
            //UserManager与UserManagerService进行通信
            return new UserManager(ctx, service);
        }});

也就是说，注册到ServiceManager的服务，可以在客户端被使用；

 

3.手动启动服务

比如：

SystemService.java
startSystemUi(context);

static final void startSystemUi(Context context) {
        Intent intent = new Intent();
        intent.setComponent(new ComponentName("com.android.systemui",
                    "com.android.systemui.SystemUIService"));
        //Slog.d(TAG, "Starting service: " + intent);
        context.startServiceAsUser(intent, UserHandle.OWNER);
    }