Android系统之System Server大纲

最新推荐文章于 2024-09-23 08:03:27 发布
最新推荐文章于 2024-09-23 08:03:27 发布
阅读量1.8w 收藏 43
点赞数 12
分类专栏： Android system server area Android系统服务 文章标签： android server
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/myfriend0/article/details/55098173
版权

Android系统之System Server大纲

System Server content

前言

System Server是android 基本服务的提供者，是android系统运行的最基本需求，所有server运行在一个叫system_process的进程中，system_process进程是android java虚拟机跑的第一个进程，从Zygote 创建而来，是andorid系统最重要的java虚拟机。可以说，整个android系统的业务都是围绕system server而展开，所以，当system_process死掉了，手机必须重启。

System server概要

System server主要包含以下服务：

  • 1、 EntropyService， 熵服务，用于产生随机数；
  • 2、 PowerManagerService， 电源管理服务；
  • 3、 ActivityMangerService Activity，管理服务；
  • 4、 TelephonyRegistry， 电话服务，电话底层通知服务；
  • 5、 PackageManagerService， 程序包管理服务；
  • 6、 AccountManagerService， 联系人账户管理服务；
  • 7、 ContentService， 内容提供器服务，提供跨进程数据交换；
  • 8、 LightService， 光感应传感器服务；
  • 9、 BatteryService，电池服务；
  • 10、 VibrateService，震动器服务；
  • 11、 AlarmManagerService，闹钟服务；
  • 12、 WindowManagerService，窗口管理服务；
  • 13、 BluetoothService，蓝牙服务；
  • 14、 InputMethodManagerService，输入法服务；
  • 15、 AccessibilityManagerService， 辅助器管理程序服务；
  • 16、 DevicePolicyManagerService，提供系统级别的设置及属性；
  • 17、 StatusBarManagerService，状态栏管理服务；
  • 18、 ClipboardService，粘贴板服务；
  • 19、 NetworkManagerService，网络管理服务；
  • 20、 TextServicesManagerService，用户管理服务；
  • 21、 NetworkStatsService，手机网络状态服务；
  • 22、 NetworkPolicyManagerService，low-level网络策略服务；
  • 23、 WifiP2pService，Wifi点对点服务；
  • 24、 WifiService，Wifi服务；
  • 25、 ConnectivityService，网络连接状态服务；
  • 26、 MountService，磁盘加载服务；
  • 27、 NotificationManagerService，通知管理服务；
  • 28、 DeviceStorageMonitorService，存储设备容量监听服务；
  • 29、 LocationManagerService，位置管理服务；
  • 30、 CountryDetectorService，检查用户当前所在国家服务；
  • 31、 SearchManagerService，搜索管理服务；
  • 32、 DropBoxManagerService，系统日志文件管理服务；
  • 33、 WallpaperManagerService，壁纸管理服务；
  • 34、 AudioService，AudioFlinger上层封装音频管理服务；
  • 35、 UsbService，USB Host 和 device管理服务；
  • 36、 UiModeManagerService，UI模式管理服务；
  • 37、 BackupManagerService，备份服务；
  • 38、 AppWidgetService，应用桌面部件服务；
  • 39、 RecognitionManagerService，身份识别服务；
  • 40、 DiskStatsService，磁盘统计服务；
  • 41、 SamplingProfilerService，性能统计服务；
  • 42、 NetworkTimeUpdateService，网络时间更新服务；
  • 43、 InputManagerService，输入管理服务；
  • 44、 FingerprintService，指纹服务；
  • 45、 DreamManagerService， dreams服务；
  • 46、 HdmiControlService， HDMI控制服务；
  • 47、 SsvService，SIM卡状态和转换服务；

以上所列系统服务不代表最新Android系统的所有系统服务。

System server启动的入口

这些服务那么重要，它们什么时候启动？都做了些什么事情？等等这些问题是本文以及大纲下面的文章将会一一道来。

了解这些系统服务之前，先来了解一个重量级的超级类SystemServer.java， 这个类在AOSP中的路径是：frameworks/base/services/java/com/android/server/SystemServer.java，在上文中提到，从Zygote创建system_process进程时，便实例化了该类。熟悉java的开发者都知道，启动某个java程序时，最先调用的就是声明了main()方法的类。所以SystemServer.java被实例化后，便调用了main()方法。首先看看SystemServer.java的构造方法：

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

构造方法里面只做了从属性系统中读取了工厂测试模式，这个不在本文以及本大纲的文章中赘述的内容，这里就不在叙述了。

下面直接进入main()方法：

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

直接调用了类内的run()方法，继续跟踪：

private void run() {
    try {
        // AndroidRuntime using the same set of system properties, but only the system_server
        // Initialize the system context.
        createSystemContext();

        // Create the system service manager.
        mSystemServiceManager = new SystemServiceManager(mSystemContext);
        LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
    } finally {
        Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
    }

    // Start services.
    try {
        Trace.traceBegin(Trace.TRACE_TAG_SYSTEM_SERVER, "StartServices");
        startBootstrapServices();
        startCoreServices();
        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);
    }
    .....
}

上述代码中，首先创建一个system context，这个对象在整个system server中使用非常频繁。接着创建一个SystemServiceManager.java的实例，顾名思义就是SystemService的管理者，管理所有的SystemService。代码中把接着创建一个SystemServiceManager的实例通过LocalServices.addService(SystemServiceManager.class, mSystemServiceManager)语句设置到LocalService中，LocalServices的功能类似SystemServiceManager，不同点在于LocalServices专门用来管理system_process进程中的SystemService，也就没有真正的跨进程通信，也就没有Binder对象。

System server启动的过程

接着就是启动各种系统服务，在这里分三种类型的SystemService，依次启动，分别对应三个方法：

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

这三个方法的顺序不能混乱，一定要按照上述顺序依次执行，先看startBootstrapServices()中启动了那些系统服务

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

    // Activity manager runs the show.
    mActivityManagerService = mSystemServiceManager.startService(
            ActivityManagerService.Lifecycle.class).getService();
    mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
    mActivityManagerService.setInstaller(installer);


    mPowerManagerService = mSystemServiceManager.startService(PowerManagerService.class);

    Trace.traceBegin(Trace.TRACE_TAG_SYSTEM_SERVER, "InitPowerManagement");
    mActivityManagerService.initPowerManagement();
    Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);

    // Manages LEDs and display backlight so we need it to bring up the display.
    mSystemServiceManager.startService(LightsService.class);

    // Display manager is needed to provide display metrics before package manager
    // starts up.
    mDisplayManagerService = mSystemServiceManager.startService(DisplayManagerService.class);

    // We need the default display before we can initialize the package manager.
    mSystemServiceManager.startBootPhase(SystemService.PHASE_WAIT_FOR_DEFAULT_DISPLAY);

    ......

    // Start the package manager.
    .....

    traceBeginAndSlog("StartUserManagerService");
    mSystemServiceManager.startService(UserManagerService.LifeCycle.class);
    ......
}

上述代码可以看到，这里启动了

  • Installer
  • ActivityManagerService.Lifecycle
  • PowerManagerService
  • LightsService
  • DisplayManagerService
  • UserManagerService

启动这些SystemService都是通过SystemServiceManager的startService()的方式启动，启动完成后会回调SystemService的onStart()方法。
继续看第二个方法startCoreServices()启动了那些系统服务

private void startCoreServices() {
    // Tracks the battery level.  Requires LightService.
    mSystemServiceManager.startService(BatteryService.class);

    // Tracks application usage stats.
    mSystemServiceManager.startService(UsageStatsService.class);
    mActivityManagerService.setUsageStatsManager(
            LocalServices.getService(UsageStatsManagerInternal.class));

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

startCoreServices()中启动了

  • BatteryService
  • UsageStatsService
  • WebViewUpdateService

上文中提到，startBootstrapServices()必须在startCoreServices()前面执行，这里就能找到一个原因，startCoreServices()中用到mActivityManagerService对象，而该对象在startBootstrapServices()中被实例化，如果先调用startCoreServices()，mActivityManagerService对象便会发生NullPointerException的RuntimeException异常。

接着就是startOtherServices()中启动的service了，先看代码

private void startOtherServices() {
    try {
        ServiceManager.addService("scheduling_policy", new SchedulingPolicyService());

        mSystemServiceManager.startService(TelecomLoaderService.class);

        traceBeginAndSlog("StartTelephonyRegistry");
        telephonyRegistry = new TelephonyRegistry(context);
        ServiceManager.addService("telephony.registry", telephonyRegistry);
        Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);

        mEntropyMixer = new EntropyMixer(context);

        mContentResolver = context.getContentResolver();

        mSystemServiceManager.startService(CameraService.class);

        mSystemServiceManager.startService(ACCOUNT_SERVICE_CLASS);

        mSystemServiceManager.startService(CONTENT_SERVICE_CLASS);

        mActivityManagerService.installSystemProviders();

        vibrator = new VibratorService(context);
        ServiceManager.addService("vibrator", vibrator);

        consumerIr = new ConsumerIrService(context);
        ServiceManager.addService(Context.CONSUMER_IR_SERVICE, consumerIr);

        mSystemServiceManager.startService(AlarmManagerService.class);

        final Watchdog watchdog = Watchdog.getInstance();
        watchdog.init(context, mActivityManagerService);

        traceBeginAndSlog("StartInputManagerService");
        inputManager = new InputManagerService(context);
        Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);

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

        mSystemServiceManager.startService(VrManagerService.class);

        mActivityManagerService.setWindowManager(wm);

        inputManager.setWindowManagerCallbacks(wm.getInputMonitor());
        inputManager.start();

        // TODO: Use service dependencies instead.
        mDisplayManagerService.windowManagerAndInputReady();

        .....
            mSystemServiceManager.startService(BluetoothService.class);
        .....

        mSystemServiceManager.startService(MetricsLoggerService.class);

        mSystemServiceManager.startService(PinnerService.class);
    } catch (RuntimeException e) {
    }
    // Bring up services needed for UI.
    if (mFactoryTestMode != FactoryTest.FACTORY_TEST_LOW_LEVEL) {
        mSystemServiceManager.startService(InputMethodManagerService.Lifecycle.class);

        traceBeginAndSlog("StartAccessibilityManagerService");
        try {
            ServiceManager.addService(Context.ACCESSIBILITY_SERVICE,
                    new AccessibilityManagerService(context));
        } catch (Throwable e) {
        }
    }
    if (mFactoryTestMode != FactoryTest.FACTORY_TEST_LOW_LEVEL) {
        if (!disableStorage &&
            !"0".equals(SystemProperties.get("system_init.startmountservice"))) {
            try {
                mSystemServiceManager.startService(MOUNT_SERVICE_CLASS);
                mountService = IMountService.Stub.asInterface(
                        ServiceManager.getService("mount"));
            } catch (Throwable e) {
                reportWtf("starting Mount Service", e);
            }
        }
    }
    mSystemServiceManager.startService(UiModeManagerService.class);
    .....

    if (mFactoryTestMode != FactoryTest.FACTORY_TEST_LOW_LEVEL) {
        if (!disableNonCoreServices) {
            try {
                mSystemServiceManager.startService(LOCK_SETTINGS_SERVICE_CLASS);
                lockSettings = ILockSettings.Stub.asInterface(
                        ServiceManager.getService("lock_settings"));
            } catch (Throwable e) {
            }

            if (!SystemProperties.get(PERSISTENT_DATA_BLOCK_PROP).equals("")) {
                mSystemServiceManager.startService(PersistentDataBlockService.class);
            }

            mSystemServiceManager.startService(DeviceIdleController.class);
            mSystemServiceManager.startService(DevicePolicyManagerService.Lifecycle.class);
        }

        if (!disableSystemUI) {
            try {
                statusBar = new StatusBarManagerService(context, wm);
                ServiceManager.addService(Context.STATUS_BAR_SERVICE, statusBar);
            } catch (Throwable e) {
            }
        }

        if (!disableNonCoreServices) {
            try {
                ServiceManager.addService(Context.CLIPBOARD_SERVICE,
                        new ClipboardService(context));
            } catch (Throwable e) {
            }
        }

        if (!disableNetwork) {
            try {
                networkManagement = NetworkManagementService.create(context);
                ServiceManager.addService(Context.NETWORKMANAGEMENT_SERVICE, networkManagement);
            } catch (Throwable e) {
            }
        }

        if (!disableNonCoreServices && !disableTextServices) {
            mSystemServiceManager.startService(TextServicesManagerService.Lifecycle.class);
        }

        if (!disableNetwork) {
            traceBeginAndSlog("StartNetworkScoreService");
            try {
                networkScore = new NetworkScoreService(context);
                ServiceManager.addService(Context.NETWORK_SCORE_SERVICE, networkScore);
            } catch (Throwable e) {
            }
            try {
                networkStats = NetworkStatsService.create(context, networkManagement);
                ServiceManager.addService(Context.NETWORK_STATS_SERVICE, networkStats);
            } catch (Throwable e) {
            }

            try {
                networkPolicy = new NetworkPolicyManagerService(
                        context, mActivityManagerService,
                        (IPowerManager)ServiceManager.getService(Context.POWER_SERVICE),
                        networkStats, networkManagement);
                ServiceManager.addService(Context.NETWORK_POLICY_SERVICE, networkPolicy);
            } catch (Throwable e) {
            }

            if (context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_WIFI_NAN)) {
                mSystemServiceManager.startService(WIFI_NAN_SERVICE_CLASS);
            } else {
                Slog.i(TAG, "No Wi-Fi NAN Service (NAN support Not Present)");
            }
            mSystemServiceManager.startService(WIFI_P2P_SERVICE_CLASS);
            mSystemServiceManager.startService(WIFI_SERVICE_CLASS);
            mSystemServiceManager.startService(
                        "com.android.server.wifi.scanner.WifiScanningService");

            if (!disableRtt) {
                mSystemServiceManager.startService("com.android.server.wifi.RttService");
            }

            if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_ETHERNET) ||
                mPackageManager.hasSystemFeature(PackageManager.FEATURE_USB_HOST)) {
                mSystemServiceManager.startService(ETHERNET_SERVICE_CLASS);
            }

            traceBeginAndSlog("StartConnectivityService");
            try {
                connectivity = new ConnectivityService(
                        context, networkManagement, networkStats, networkPolicy);
                ServiceManager.addService(Context.CONNECTIVITY_SERVICE, connectivity);
                networkStats.bindConnectivityManager(connectivity);
                networkPolicy.bindConnectivityManager(connectivity);
            } catch (Throwable e) {
            }

            try {
                serviceDiscovery = NsdService.create(context);
                ServiceManager.addService(
                        Context.NSD_SERVICE, serviceDiscovery);
            } catch (Throwable e) {
                reportWtf("starting Service Discovery Service", e);
        }

        if (!disableNonCoreServices) {
            try {
                ServiceManager.addService(Context.UPDATE_LOCK_SERVICE,
                        new UpdateLockService(context));
            } catch (Throwable e) {
            }
        }

        if (!disableNonCoreServices) {
            mSystemServiceManager.startService(RecoverySystemService.class);
        }
        ......

        mSystemServiceManager.startService(NotificationManagerService.class);
        notification = INotificationManager.Stub.asInterface(
                ServiceManager.getService(Context.NOTIFICATION_SERVICE));
        networkPolicy.bindNotificationManager(notification);

        mSystemServiceManager.startService(DeviceStorageMonitorService.class);

        if (!disableLocation) {
            try {
                location = new LocationManagerService(context);
                ServiceManager.addService(Context.LOCATION_SERVICE, location);
            } catch (Throwable e) {
            }
            try {
                countryDetector = new CountryDetectorService(context);
                ServiceManager.addService(Context.COUNTRY_DETECTOR, countryDetector);
            } catch (Throwable e) {
            }
        }

        if (!disableNonCoreServices && !disableSearchManager) {
            traceBeginAndSlog("StartSearchManagerService");
            try {
                mSystemServiceManager.startService(SEARCH_MANAGER_SERVICE_CLASS);
            } catch (Throwable e) {
            }
        }

        mSystemServiceManager.startService(DropBoxManagerService.class);

        if (!disableNonCoreServices && context.getResources().getBoolean(
                    R.bool.config_enableWallpaperService)) {
            mSystemServiceManager.startService(WALLPAPER_SERVICE_CLASS);
        }

        mSystemServiceManager.startService(AudioService.Lifecycle.class);

        if (!disableNonCoreServices) {
            mSystemServiceManager.startService(DockObserver.class);

            if (context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_WATCH)) {
                mSystemServiceManager.startService(THERMAL_OBSERVER_CLASS);
            }
        }
        try {
            // Listen for wired headset changes
            inputManager.setWiredAccessoryCallbacks(
                    new WiredAccessoryManager(context, inputManager));
        } catch (Throwable e) {
        }

        if (!disableNonCoreServices) {
            if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_MIDI)) {
                // Start MIDI Manager service
                mSystemServiceManager.startService(MIDI_SERVICE_CLASS);
            }

            if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_USB_HOST)
                    || mPackageManager.hasSystemFeature(
                            PackageManager.FEATURE_USB_ACCESSORY)) {
                mSystemServiceManager.startService(USB_SERVICE_CLASS);
            }

            if (!disableSerial) {
                try {
                    // Serial port support
                    serial = new SerialService(context);
                    ServiceManager.addService(Context.SERIAL_SERVICE, serial);
                } catch (Throwable e) {
                }
            }

                    "StartHardwarePropertiesManagerService");
            try {
                hardwarePropertiesService = new HardwarePropertiesManagerService(context);
                ServiceManager.addService(Context.HARDWARE_PROPERTIES_SERVICE,
                        hardwarePropertiesService);
            } catch (Throwable e) {
                Slog.e(TAG, "Failure starting HardwarePropertiesManagerService", e);
            }
        }

        mSystemServiceManager.startService(TwilightService.class);

        mSystemServiceManager.startService(JobSchedulerService.class);

        mSystemServiceManager.startService(SoundTriggerService.class);

        if (!disableNonCoreServices) {
            if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_BACKUP)) {
                mSystemServiceManager.startService(BACKUP_MANAGER_SERVICE_CLASS);
            }

            if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_APP_WIDGETS)
                || context.getResources().getBoolean(R.bool.config_enableAppWidgetService)) {
                mSystemServiceManager.startService(APPWIDGET_SERVICE_CLASS);
            }

            if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_VOICE_RECOGNIZERS)) {
                mSystemServiceManager.startService(VOICE_RECOGNITION_MANAGER_SERVICE_CLASS);
            }

            if (GestureLauncherService.isGestureLauncherEnabled(context.getResources())) {
                Slog.i(TAG, "Gesture Launcher Service");
                mSystemServiceManager.startService(GestureLauncherService.class);
            }
            mSystemServiceManager.startService(SensorNotificationService.class);
            mSystemServiceManager.startService(ContextHubSystemService.class);
        }

        try {
            ServiceManager.addService("diskstats", new DiskStatsService(context));
        } catch (Throwable e) {
        }

        if (!disableSamplingProfiler) {
            traceBeginAndSlog("StartSamplingProfilerService");
            try {
                ServiceManager.addService("samplingprofiler",
                            new SamplingProfilerService(context));
            } catch (Throwable e) {
            }
        }

        if (!disableNetwork && !disableNetworkTime) {
            traceBeginAndSlog("StartNetworkTimeUpdateService");
            try {
                networkTimeUpdater = new NetworkTimeUpdateService(context);
                ServiceManager.addService("network_time_update_service", networkTimeUpdater);
            } catch (Throwable e) {
            }
        }

        traceBeginAndSlog("StartCommonTimeManagementService");
        try {
            commonTimeMgmtService = new CommonTimeManagementService(context);
            ServiceManager.addService("commontime_management", commonTimeMgmtService);
        } catch (Throwable e) {
        }
        Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);

        if (!disableNetwork) {
            try {
                CertBlacklister blacklister = new CertBlacklister(context);
            } catch (Throwable e) {
            }
        }

        if (!disableNonCoreServices) {
            mSystemServiceManager.startService(DreamManagerService.class);
        }

        if (!disableNonCoreServices && ZygoteInit.PRELOAD_RESOURCES) {
            traceBeginAndSlog("StartAssetAtlasService");
            try {
                atlas = new AssetAtlasService(context);
                ServiceManager.addService(AssetAtlasService.ASSET_ATLAS_SERVICE, atlas);
            } catch (Throwable e) {
            }
        }

        if (!disableNonCoreServices) {
            ServiceManager.addService(GraphicsStatsService.GRAPHICS_STATS_SERVICE,
                    new GraphicsStatsService(context));
        }

        if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_PRINTING)) {
            mSystemServiceManager.startService(PRINT_MANAGER_SERVICE_CLASS);
        }

        mSystemServiceManager.startService(RestrictionsManagerService.class);

        mSystemServiceManager.startService(MediaSessionService.class);

        if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_HDMI_CEC)) {
            mSystemServiceManager.startService(HdmiControlService.class);
        }

        if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_LIVE_TV)) {
            mSystemServiceManager.startService(TvInputManagerService.class);
        }

        if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_PICTURE_IN_PICTURE)) {
            mSystemServiceManager.startService(MediaResourceMonitorService.class);
        }

        if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_LEANBACK)) {
            mSystemServiceManager.startService(TvRemoteService.class);
        }

        if (!disableNonCoreServices) {
            traceBeginAndSlog("StartMediaRouterService");
            try {
                mediaRouter = new MediaRouterService(context);
                ServiceManager.addService(Context.MEDIA_ROUTER_SERVICE, mediaRouter);
            } catch (Throwable e) {
            }

            if (!disableTrustManager) {
                mSystemServiceManager.startService(TrustManagerService.class);
            }

            if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_FINGERPRINT)) {
                mSystemServiceManager.startService(FingerprintService.class);
            }
        }
        // LauncherAppsService uses ShortcutService.
        mSystemServiceManager.startService(ShortcutService.Lifecycle.class);

        mSystemServiceManager.startService(LauncherAppsService.class);
    }

    if (!disableNonCoreServices && !disableMediaProjection) {
        mSystemServiceManager.startService(MediaProjectionManagerService.class);
    }

    if (context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_WATCH)) {
        mSystemServiceManager.startService(WEAR_BLUETOOTH_SERVICE_CLASS);
    }
    mmsService = mSystemServiceManager.startService(MmsServiceBroker.class);

    // It is now time to start up the app processes...

    try {
        vibrator.systemReady();
    } catch (Throwable e) {
    }

    if (lockSettings != null) {
        try {
            lockSettings.systemReady();
        } catch (Throwable e) {
        }
    }

    // Needed by DevicePolicyManager for initialization
    mSystemServiceManager.startBootPhase(SystemService.PHASE_LOCK_SETTINGS_READY);

    mSystemServiceManager.startBootPhase(SystemService.PHASE_SYSTEM_SERVICES_READY);

    Trace.traceBegin(Trace.TRACE_TAG_SYSTEM_SERVER, "MakeWindowManagerServiceReady");
    try {
        wm.systemReady();
    } catch (Throwable e) {
    }
    try {
        // TODO: use boot phase
        mPowerManagerService.systemReady(mActivityManagerService.getAppOpsService());
    } catch (Throwable e) {
    }

    try {
        mPackageManagerService.systemReady();
    } catch (Throwable e) {
    }

    try {
        // TODO: use boot phase and communicate these flags some other way
        mDisplayManagerService.systemReady(safeMode, mOnlyCore);
    } catch (Throwable e) {
    }
    mActivityManagerService.systemReady(new Runnable() {
        @Override
        public void run() {
            try {
                startSystemUi(context);
            } catch (Throwable e) {
            }
            "MakeNetworkManagementServiceReady");
            try {
                if (networkManagementF != null) networkManagementF.systemReady();
            } catch (Throwable e) {
                reportWtf("making Network Managment Service ready", e);
            }
            "MakeNetworkStatsServiceReady");
            try {
                if (networkStatsF != null) networkStatsF.systemReady();
            } catch (Throwable e) {
            }
            try {
                if (networkPolicyF != null) networkPolicyF.systemReady();
            } catch (Throwable e) {
                reportWtf("making Network Policy Service ready", e);
            }
            "MakeConnectivityServiceReady");
            try {
                if (connectivityF != null) connectivityF.systemReady();
            } catch (Throwable e) {
            }
            Watchdog.getInstance().start();

            try {
                if (locationF != null) locationF.systemRunning();
            } catch (Throwable e) {
            }
            try {
                if (countryDetectorF != null) countryDetectorF.systemRunning();
            } catch (Throwable e) {
            }
            try {
                if (networkTimeUpdaterF != null) networkTimeUpdaterF.systemRunning();
            } catch (Throwable e) {
            }
            try {
                if (commonTimeMgmtServiceF != null) {
                    commonTimeMgmtServiceF.systemRunning();
                }
            } catch (Throwable e) {
            }
            try {
                if (atlasF != null) atlasF.systemRunning();
            } catch (Throwable e) {
            }
            try {
                // TODO(BT) Pass parameter to input manager
                if (inputManagerF != null) inputManagerF.systemRunning();
            } catch (Throwable e) {
            }
            try {
                if (telephonyRegistryF != null) telephonyRegistryF.systemRunning();
            } catch (Throwable e) {
                reportWtf("Notifying TelephonyRegistry running", e);
            }
            try {
                if (mediaRouterF != null) mediaRouterF.systemRunning();
            } catch (Throwable e) {
            }

            try {
                if (mmsServiceF != null) mmsServiceF.systemRunning();
            } catch (Throwable e) {
            }

            try {
                if (networkScoreF != null) networkScoreF.systemRunning();
            } catch (Throwable e) {
            }
        }
    });
}

这个方法中启动的service非常多，代码量非常巨大，所以可见，这个方法对于Android系统而言，不言也可知其重要性。由于代码量巨大，将startOtherServices()分成三部分解说：

1.startOtherServices()中启动了那些服务

  • SchedulingPolicyService
  • TelecomLoaderService
  • TelephonyRegistry
  • CameraService
  • AccountManagerService$Lifecycle
  • ContentService$Lifecycle
  • VibratorService
  • ConsumerIrService
  • AlarmManagerService
  • InputManagerService
  • WindowManagerService
  • VrManagerService
  • MetricsLoggerService
  • PinnerService
  • InputMethodManagerService
  • AccessibilityManagerService
  • MountService$Lifecycle
  • UiModeManagerService
  • LockSettingsService$Lifecycle
  • PersistentDataBlockService
  • DeviceIdleController
  • DevicePolicyManagerService
  • StatusBarManagerService
  • ClipboardService
  • NetworkManagementService
  • TextServicesManagerService
  • NetworkScoreService
  • NetworkStatsService
  • NetworkPolicyManagerService
  • WifiNanService
  • WifiP2pService
  • WifiService
  • WifiScanningService
  • RttService
  • EthernetService
  • ConnectivityService
  • NsdService
  • UpdateLockService
  • RecoverySystemService
  • NotificationManagerService
  • DeviceStorageMonitorService
  • LocationManagerService
  • CountryDetectorService
  • SearchManagerService$Lifecycle
  • DropBoxManagerService
  • WallpaperManagerService$Lifecycle
  • AudioService.Lifecycle
  • DockObserver
  • ThermalObserver
  • MidiService$Lifecycle
  • UsbService$Lifecycle
  • SerialService
  • HardwarePropertiesManagerService
  • TwilightService
  • JobSchedulerService
  • SoundTriggerService
  • BackupManagerService$Lifecycle
  • AppWidgetService
  • VoiceInteractionManagerService
  • GestureLauncherService
  • SensorNotificationService
  • ContextHubSystemService
  • DiskStatsService
  • SamplingProfilerService
  • NetworkTimeUpdateService
  • CommonTimeManagementService
  • DreamManagerService
  • AssetAtlasService
  • GraphicsStatsService
  • PrintManagerService
  • RestrictionsManagerService
  • MediaSessionService
  • HdmiControlService
  • TvInputManagerService
  • MediaResourceMonitorService
  • TvRemoteService
  • MediaRouterService
  • TrustManagerService
  • FingerprintService
  • ShortcutService.Lifecycle
  • LauncherAppsService
  • MediaProjectionManagerService
  • WearBluetoothService
  • MmsServiceBroker

所列的这些服务，不一定全部都启动，系统会依照一些配置，选择性启动某些服务。如，因为Android系统会用于众多设备，手机，电视等等，当Android安装到电视设备是，TvInputManagerService、TvRemoteService这些service才会被启动，相反，手机设备时，这两个服务就不会被启动了。

2.不同的启动服务的方式

不知读者是否注意到，在startOtherServices()中存在和startBootstrapServices()、startCoreServices()中不同的启动service的方法，在startBootstrapServices()、startCoreServices()中见到SystemServiceManager.startService()和LocalServices.addService()的方式，而startOtherServices()中又多了ServiceManager.addService()，这三种方式有什么不同呢？

  1. 类型不同
    SystemServiceManager.startService()和LocalServices.addService()启动的系统服务是SystemService的子类，启动这些服务后会回调SystemService的onStart()方法。ServiceManager.addService()启动的系统服务是实现了Android IPC 的Binder的子类，这些服务启动后会调用systemReady()或systemRunning()方法。

  2. SystemServiceManager.startService()和ServiceManager.addService()中启动的服务需要Binder对象，而LocalServices.addService()却没有Binder对象。

  3. SystemServiceManager.startService()中启动的是需要关心lifecycle events的服务，而ServiceManager.addService()和LocalServices.addService()不关心lifecycle events。

  4. ServiceManager.addService()启动的服务本身是实现Binder通信的子类，而一般SystemServiceManager.startService()启动的服务是某个服务的内部类且这个内部类是SystemService的子类，如BackupManagerService$Lifecycle，在启动这个Lifecycle的内部类服务时，当回调onStart()方法时通过SystemService的publishBinderService()方法应用某个服务的Binder对象，且这个Binder的实现类也是某个服务的内部类。也就是说需要启动服务，而这个服务需要关心lifecycle events，所以不能通过ServiceManager.addService()的方式启动，然后在这个服务中声明一个实现了SystemService的子类Lifecycle，来接受lifecycle events，通过SystemServiceManager.startService()的方式启动这个服务，在SystemService的回调方法onStart()中应用这个服务的Binder对象。所以通过SystemServiceManager.startService()启动的服务，实际是启动了一个即需要关心lifecycle events，也需要像ServiceManager.addService()那样需要Binder对象的服务。

所以，其实在startBootstrapServices()中就已经通过ServiceManager.addService()的方式启动了一些特别特别重要的服务，如：

    private void startBootstrapServices() {
        mPackageManagerService = PackageManagerService.main(mSystemContext, installer,
            mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF, mOnlyCore);
    }


    public static PackageManagerService main(Context context, Installer installer,
        boolean factoryTest, boolean onlyCore) {
        ......
        ServiceManager.addService("package", m);
        return m;
    }

3.通过ServiceManager.addService()启动的服务，会调用服务的systemReady()或systemRunning()方法，初始化一些需要在系统服务启动后的其它代码。如启动SystemUI。

全部启动所需要的服务以后，SystemServer便要进入了接受Message的循环中，等待Message的事件。

总结

在本大纲中，认识了Android系统启动时需要启动的服务，以及

  • SystemServiceManager.startService()
  • ServiceManager.addService()
  • LocalServices.addService()

三种不同的启动系统服务的方式，通过这三种启动的服务各有什么不同。另外，Android系统除了在启动的时候可以初始化服务，在运行中，也可能有新的服务被加进来，如某些APP启动时，会增加一些服务，如Phone APP（Telephony）

public void onCreate() {
        phoneMgr = PhoneInterfaceManager.init(this, PhoneFactory.getDefaultPhone());
}

static PhoneInterfaceManager init(PhoneGlobals app, Phone phone) {
    synchronized (PhoneInterfaceManager.class) {
        if (sInstance == null) {
            sInstance = new PhoneInterfaceManager(app, phone);
        ......
        return sInstance;
    }
}

private PhoneInterfaceManager(PhoneGlobals app, Phone phone) {
    publish();
}

private void publish() {
    ServiceManager.addService("phone", this);
}

到此，System Server的大纲介绍到这里，在本大纲的牵引下，一一以分文章（文档）的形式对各个系统服务进入全面的了解。

FamilyYuan
关注
专栏目录
Android SystemServer 启动流程分析
程序员Android
07-09 1699
和你一起终身学习，这里是程序员Android经典好文推荐，通过阅读本文，您将收获以下知识点:一、SystemServer 启动的服务有哪些二、SystemServer启动总体流程概述三、SystemServer 如何启动，是谁启动的？四、 SystemServer 启动入门 main 方法五、SystemServer Run 方法初始与启动六、SystemServer 的引导服务有哪些七、Syst...
Android 进阶——系统启动之SystemServer创建并启动Installer服务（八）_android 12 installapkverity
2401_84150320的博客
04-20 814
frameworks\base\services\core\java\com\android\server\pm\Installer.java继承自com.android.server.SystemService，同时持有installd守护进程对应Binder服务的代理对象，本质上就是通过Binder调用去与Linux底层installd守护进程通信完成真正的完成Apk文件格式的优化和转换建立相关的数据目录删除文件安装应用等工作。因此在其他系统核心服务启动前首先被启动，当触发。
System Server 分析
热门推荐
杜文涛的专栏
05-13 2万+
SystemServer 是 Android JAVA 层的系统服务模块，这个模块主要功能就是管理供 Android 应用开发的 system service.
android system_server进程
最新发布
轻口味的专栏
09-23 1031
system_server进程是系统进程，java framework框架的核心载体，里面运行了大量的系统服务，比如这里提供ApplicationThreadProxy（简称ATP），ActivityManagerService（简称AMS），这个两个服务都运行在system_server进程的不同线程中，由于ATP和AMS都是基于IBinder接口，都是binder线程，binder线程的创建与销毁都是由binder驱动来决定的。系统为什么不允许在子线程中访问UI？
Android System Server
Zeng_xq的博客
08-31 1388
Android System Server 入门学习学习资料来源 学习资料来源 《深入理解Android卷1》
Android system server
邢学智的专栏
04-20 232
<br /> <br /> <br />
SystemServer简述
bosswcz的博客
06-28 4658
关于systemserver的一些学习总结
android SystemServer进程的作用
wang_you189959的专栏
08-26 1275
SystemServer进程是android中一个很重要的进程由Zygote进程启动SystemServer进程主要用于启动系统中的服务SystemServer进程启动服务的启动函数为main函数SystemServer在执行过程中首先会初始化一些系统变量，加载类库，创建Context对象，创建SystemServiceManager对象等之后才开始启动系统服务SystemServer进程将系统服
Android系统之SystemServer
Goach的专栏
01-15 626
在上一文Android 系统的Zygote初始化过程说到，Zygote初始化的时候会调用RuntimeInit里面的zygoteInit()方法，在该方法里面调用了applicationInit()方法，然后通过反射调用了SystemServer的main()函数。 SystemServer SystemServer的main函数如下 //frameworks/base/ andro
Android 系统架构图
墨鱼菜鸡
07-11 5440
Android 操作系统架构开篇：http://gityuan.com/android/https://cloud.tencent.com/developer/article/1429122 Android架构图(五层框架)：https://www.cnblogs.com/pengdonglin137/p/3858254.html 官方系统架构图：h...
Android Framework 添加新的系统服务_android framework 新建一个系统服务
2401_84102892的博客
04-21 903
如果你想要深入系统的学习Android Framework框架，这里可以分享一份《Android Framework源码开发揭秘》，其中记录了从系统启动流程到WMS全部源码解析，相信你能优秀地学习整个Framework框架。扫描下方二维码直接领取！
探索Android FrameWork底层开发视频全套
04-18
16.Zygote剖析与system_server启动 17.Zygote创建APP分析 18.zygote_load系统资源分析及优化 19.开机界面分析 20.systemserver服务分析 21.ServiceManager服务分析 22.packageMangerService服务分析 23.Android...
Tiny4412——Android灯光系统
hceng_linux
06-09 1294
CSDN仅用于增加百度收录权重，排版未优化，日常不维护。请访问：www.hceng.cn 查看、评论。 本博文对应地址: https://hceng.cn/2019/05/09/Tiny4412——Android灯光系统/#more 继续学习Android驱动，Android灯光系统。 1.思路分析 前面对3.2 Android硬件访问服务进行了详细的分析，知道了Android大致可以分为四层：...
android_systemServer进程启动流程
博客
05-04 456
在startBootstrapServices、startCoreServices、startOtherServices、startApexServices中，对各类服务进行了启动，比如我们常见的ActivityManagerService、PackageManagerService、BatteryService等等，共近百个Service。一，systemServer进程是被Zygote进程fork出来的，具体代码，五，Android系统运行时架构图- systemserver进程所在位置图。
Android SystemServer解析
u012545728的博客
06-07 5493
概述    理解该文章，需要阅读者对Android进程间通信方式Binder有一定了解，理解Binder的方式之一便是找到一个系统中binder通信的例子，例如activity启动过程，该过程描述了应用进程的activity和系统进程，准确的说是SystemServer进程中的ActivityManagerService通信。其实，SystemServer进程中不仅仅运行着AMS，还运行着其他各种...
Android SystemServer介绍
liuning1985622的博客
05-02 367
SystemServer是Android系统中的一个重要进程，它负责启动和管理系统中的各种服务。这些服务包括WindowManagerServer(WMS)、ActivityManagerService(AMS)和PackageManagerServer(PMS)等。SystemServer进程在系统中的名称为"system_server"。SystemServer的主要职责是启动和管理系统服务。它在系统启动时被启动，并负责创建和初始化系统服务。
SystemServer的含义和作用
冯旭的博客
12-23 2689
1.SystemServer是一个进程，并且是由zygote进程fork出来的 [zygote进程] 2.Android Framework里面两大非常重要的进程： 1.SystemServer进程 2.zygote进程 3.SystemServer比较重要的原因为： 1.系统级的重要服务都是在这个进程里开启的 比如: ActivityManageService、 PackgeManageService、WindowManageService等...
SystemServer启动分析
weixin_42190174的博客
02-18 567
 简单来说，systemServer就是系统用来启动各种service的入口，安卓系统在启动的时候， 会初 始化两个重要的部分，一个是zygote进程，另一个是由zygote进程fork出来的SystemServer进程，SystemServer会启动我们系统中所需要的一系列service，下面会做分析。         SystemServer由zygote进程启动。启动后，会调用SystemS...
SystemServer源码分析
厚积薄发
11-03 2420
从SystemServer的main函数入手/** * The main entry point from zygote. */ public static void main(String[] args) { new SystemServer().run(); }这里创建了一个SystemServer并调用了它的run()函数，进入run()函数，这个方法内部比较多，分段分析：时间处理
Android系统开发之修改调试SystemUI
05-26
要修改和调试 Android 系统中的 SystemUI，需要先了解 SystemUI 是什么以及它的作用。SystemUI 是 Android 系统中的一个重要组件，它负责管理状态栏、导航栏、通知栏等 UI 元素。如果想要修改 SystemUI，需要进行以下步骤： 1. 下载 Android 系统源码，并编译出 SystemUI 的 APK 文件。 2. 将 APK 文件安装到手机上，并启用开发者选项中的 USB 调试模式。 3. 使用 Android Studio 或其他 IDE 连接手机进行调试。 4. 根据需要进行代码修改或添加新的功能，并编译出新的 APK 文件。 5. 将修改后的 APK 文件重新安装到手机上，并测试修改效果。 需要注意的是，修改 SystemUI 需要有一定的 Android 系统开发经验和相关技能。同时，在修改过程中需要格外小心，以防意外破坏系统或造成其他问题。因此，建议在实践前充分了解相关知识和技能，并备份好系统数据。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值