首页 > 其他分享 >Android系统之System Server大纲

Android系统之System Server大纲

时间：2024-07-01 10:33:43浏览次数：15  
标签：mSystemServiceManager System Server try Throwable catch startService Android cla

前言

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 $LifecycleContentService$Lifecycle

  • VibratorService

  • ConsumerIrService

  • AlarmManagerService

  • InputManagerService

  • WindowManagerService

  • VrManagerService

  • MetricsLoggerService

  • PinnerService

  • InputMethodManagerService

  • AccessibilityManagerService

  • MountService \(LifecycleUiModeManagerServiceLockSettingsService\)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\(LifecycleDropBoxManagerServiceWallpaperManagerService\)Lifecycle

  • AudioService.Lifecycle

  • DockObserver

  • ThermalObserver

  • MidiService\(LifecycleUsbService\)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

    ShortcutService.Lifecycle

    LauncherAppsService

    MediaProjectionManagerService

    WearBluetoothService

    MmsServiceBroke

所列的这些服务，不一定全部都启动，系统会依照一些配置，选择性启动某些服务。如，因为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的事件

标签：mSystemServiceManager,System,Server,try,Throwable,catch,startService,Android,cla
From： https://www.cnblogs.com/linhaostudy/p/18277525

相关文章

  • Windows11系统System.Workflow.Activities.resources.dll文件丢失问题
    其实很多用户玩单机游戏或者安装软件的时候就出现过这种问题，如果是新手第一时间会认为是软件或游戏出错了，其实并不是这样，其主要原因就是你电脑系统的该dll文件丢失了或没有安装一些系统软件平台所需要的动态链接库，这时你可以下载这个System.Workflow.Activities.resources.dll......
  • Windows11系统System.Windows.Controls.Ribbon.resources.dll文件丢失问题
    其实很多用户玩单机游戏或者安装软件的时候就出现过这种问题，如果是新手第一时间会认为是软件或游戏出错了，其实并不是这样，其主要原因就是你电脑系统的该dll文件丢失了或没有安装一些系统软件平台所需要的动态链接库，这时你可以下载这个System.Windows.Controls.Ribbon.resources.......
  • Windows11系统System.Windows.dll文件丢失问题
    其实很多用户玩单机游戏或者安装软件的时候就出现过这种问题，如果是新手第一时间会认为是软件或游戏出错了，其实并不是这样，其主要原因就是你电脑系统的该dll文件丢失了或没有安装一些系统软件平台所需要的动态链接库，这时你可以下载这个System.Windows.dll文件(挑选合适的版本文件......
  • webAPI连接SQLserver，并快速建立数据模型
    首先，你需要有一个webAPI来作为Android应用和SQLserver数据库之间的中间件，创建该api在项目中导入三个NuGet包通过服务器资源管理器连接数据库，获取数据库连接的字符串 快速建立数据模型思路：通过数据库创建数据类：导入包=>打开程序包管理器控制台=>选择项目=>Scaffold-DbCont......
  • Linux进程间的通信方式（一）System V 消息队列
    文章目录前言1.消息队列概念2.消息队列的应用场景3.消息队列接口分类3.1SystemV消息队列3.2POSIX消息队列4.消息队列相关操作函数4.1ftok函数(获取一个key值)4.2msgget函数(根据key值获取一个消息队列操作符)4.3msgctl函数(设置消息队列属性)4.4msgsnd函......
  • Android Gradle 开发与应用 (三): 依赖管理与版本控制
    目录1.依赖管理的重要性1.1依赖的类型1.2Gradle中的依赖声明2.版本控制的策略2.1固定版本与动态版本2.2版本冲突的解决3.Gradle插件的使用3.1常用的Gradle插件3.2自定义插件4.多模块项目中的依赖管理4.1模块间依赖4.2公共依赖5.依赖版本管理的最......
  • 乌班图Ubuntu 24.04 SSH Server 修改默认端口重启无效
    试用最新的乌班图版本，常规修改ssh端口，修改完毕后重启sshd提示没有找到service，然后尝试去掉d重启ssh后查看状态，端口仍然是默认的22，各种尝试都试了不行，重启服务器后倒是端口修改成功了，心想着不能每台机器都重启吧。百思不得其解后查看官网相关（机翻）意思就是22.10之后的版本使用方......
  • 【转】Androidstudio报错Algorithm HmacPBESHA256 not available
     删除debug.keystone这个文件就可以了。 https://blog.csdn.net/O_PUTI/article/details/138227534 -----参考了更改GradleJDK等的办法都没有用，最终通过一个一个问题拍错解决。第一个问题：版本不一致 第二个问题秘钥获取不成功：删除这个文件 然后就编译成功了。......
  • 猫头虎分享已解决Bug || 服务器配置错误（Server Configuration Error）: ServerMisconfig
    ......
  • SQL Server的隐私盾牌：动态数据屏蔽(DMS)全面解析
    ......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99