SystemServer.java revision b325345ef0adf2849350d339de1ec5f92b67b7ae
1/* 2 * Copyright (C) 2006 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17package com.android.server; 18 19import android.app.ActivityManagerNative; 20import android.app.ActivityThread; 21import android.app.IAlarmManager; 22import android.app.INotificationManager; 23import android.bluetooth.BluetoothAdapter; 24import android.content.ComponentName; 25import android.content.ContentResolver; 26import android.content.Context; 27import android.content.Intent; 28import android.content.pm.IPackageManager; 29import android.content.pm.PackageManager; 30import android.content.res.Configuration; 31import android.media.AudioService; 32import android.os.Environment; 33import android.os.FactoryTest; 34import android.os.Handler; 35import android.os.IBinder; 36import android.os.IPowerManager; 37import android.os.Looper; 38import android.os.RemoteException; 39import android.os.ServiceManager; 40import android.os.StrictMode; 41import android.os.SystemClock; 42import android.os.SystemProperties; 43import android.os.UserHandle; 44import android.service.dreams.DreamService; 45import android.util.DisplayMetrics; 46import android.util.EventLog; 47import android.util.Log; 48import android.util.Slog; 49import android.view.WindowManager; 50 51import com.android.internal.R; 52import com.android.internal.os.BinderInternal; 53import com.android.internal.os.Zygote; 54import com.android.internal.os.SamplingProfilerIntegration; 55import com.android.server.accessibility.AccessibilityManagerService; 56import com.android.server.accounts.AccountManagerService; 57import com.android.server.am.ActivityManagerService; 58import com.android.server.am.BatteryStatsService; 59import com.android.server.clipboard.ClipboardService; 60import com.android.server.content.ContentService; 61import com.android.server.display.DisplayManagerService; 62import com.android.server.dreams.DreamManagerService; 63import com.android.server.input.InputManagerService; 64import com.android.server.lights.LightsManager; 65import com.android.server.lights.LightsService; 66import com.android.server.media.MediaRouterService; 67import com.android.server.media.MediaSessionService; 68import com.android.server.net.NetworkPolicyManagerService; 69import com.android.server.net.NetworkStatsService; 70import com.android.server.notification.NotificationManagerService; 71import com.android.server.os.SchedulingPolicyService; 72import com.android.server.pm.Installer; 73import com.android.server.pm.PackageManagerService; 74import com.android.server.pm.UserManagerService; 75import com.android.server.power.PowerManagerService; 76import com.android.server.power.ShutdownThread; 77import com.android.server.search.SearchManagerService; 78import com.android.server.statusbar.StatusBarManagerService; 79import com.android.server.storage.DeviceStorageMonitorService; 80import com.android.server.trust.TrustManagerService; 81import com.android.server.twilight.TwilightService; 82import com.android.server.usb.UsbService; 83import com.android.server.wallpaper.WallpaperManagerService; 84import com.android.server.wm.WindowManagerService; 85 86import dalvik.system.VMRuntime; 87 88import java.io.File; 89import java.util.Timer; 90import java.util.TimerTask; 91 92public final class SystemServer { 93 private static final String TAG = "SystemServer"; 94 95 private static final String ENCRYPTING_STATE = "trigger_restart_min_framework"; 96 private static final String ENCRYPTED_STATE = "1"; 97 98 private static final long SNAPSHOT_INTERVAL = 60 * 60 * 1000; // 1hr 99 100 // The earliest supported time. We pick one day into 1970, to 101 // give any timezone code room without going into negative time. 102 private static final long EARLIEST_SUPPORTED_TIME = 86400 * 1000; 103 104 /* 105 * Implementation class names. TODO: Move them to a codegen class or load 106 * them from the build system somehow. 107 */ 108 private static final String BACKUP_MANAGER_SERVICE_CLASS = 109 "com.android.server.backup.BackupManagerService$Lifecycle"; 110 private static final String DEVICE_POLICY_MANAGER_SERVICE_CLASS = 111 "com.android.server.devicepolicy.DevicePolicyManagerService$Lifecycle"; 112 private static final String APPWIDGET_SERVICE_CLASS = 113 "com.android.server.appwidget.AppWidgetService"; 114 private static final String PRINT_MANAGER_SERVICE_CLASS = 115 "com.android.server.print.PrintManagerService"; 116 private static final String USB_SERVICE_CLASS = 117 "com.android.server.usb.UsbService$Lifecycle"; 118 private static final String WIFI_SERVICE_CLASS = 119 "com.android.server.wifi.WifiService"; 120 private static final String WIFI_HOTSPOT_SERVICE_CLASS = 121 "com.android.server.wifi.hotspot.WifiHotspotService"; 122 private static final String WIFI_P2P_SERVICE_CLASS = 123 "com.android.server.wifi.p2p.WifiP2pService"; 124 private static final String HDMI_CEC_SERVICE_CLASS = 125 "com.android.server.hdmi.HdmiCecService"; 126 127 private final int mFactoryTestMode; 128 private Timer mProfilerSnapshotTimer; 129 130 private Context mSystemContext; 131 private SystemServiceManager mSystemServiceManager; 132 133 // TODO: remove all of these references by improving dependency resolution and boot phases 134 private Installer mInstaller; 135 private PowerManagerService mPowerManagerService; 136 private ActivityManagerService mActivityManagerService; 137 private DisplayManagerService mDisplayManagerService; 138 private ContentResolver mContentResolver; 139 140 /** 141 * Called to initialize native system services. 142 */ 143 private static native void nativeInit(); 144 145 /** 146 * The main entry point from zygote. 147 */ 148 public static void main(String[] args) { 149 new SystemServer().run(); 150 } 151 152 public SystemServer() { 153 mFactoryTestMode = FactoryTest.getMode(); 154 } 155 156 private void run() { 157 // If a device's clock is before 1970 (before 0), a lot of 158 // APIs crash dealing with negative numbers, notably 159 // java.io.File#setLastModified, so instead we fake it and 160 // hope that time from cell towers or NTP fixes it shortly. 161 if (System.currentTimeMillis() < EARLIEST_SUPPORTED_TIME) { 162 Slog.w(TAG, "System clock is before 1970; setting to 1970."); 163 SystemClock.setCurrentTimeMillis(EARLIEST_SUPPORTED_TIME); 164 } 165 166 // Here we go! 167 Slog.i(TAG, "Entered the Android system server!"); 168 EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_SYSTEM_RUN, SystemClock.uptimeMillis()); 169 170 // In case the runtime switched since last boot (such as when 171 // the old runtime was removed in an OTA), set the system 172 // property so that it is in sync. We can't do this in 173 // libnativehelper's JniInvocation::Init code where we already 174 // had to fallback to a different runtime because it is 175 // running as root and we need to be the system user to set 176 // the property. http://b/11463182 177 SystemProperties.set("persist.sys.dalvik.vm.lib.1", VMRuntime.getRuntime().vmLibrary()); 178 179 // Enable the sampling profiler. 180 if (SamplingProfilerIntegration.isEnabled()) { 181 SamplingProfilerIntegration.start(); 182 mProfilerSnapshotTimer = new Timer(); 183 mProfilerSnapshotTimer.schedule(new TimerTask() { 184 @Override 185 public void run() { 186 SamplingProfilerIntegration.writeSnapshot("system_server", null); 187 } 188 }, SNAPSHOT_INTERVAL, SNAPSHOT_INTERVAL); 189 } 190 191 // Mmmmmm... more memory! 192 VMRuntime.getRuntime().clearGrowthLimit(); 193 194 // The system server has to run all of the time, so it needs to be 195 // as efficient as possible with its memory usage. 196 VMRuntime.getRuntime().setTargetHeapUtilization(0.8f); 197 198 // Within the system server, it is an error to access Environment paths without 199 // explicitly specifying a user. 200 Environment.setUserRequired(true); 201 202 // Ensure binder calls into the system always run at foreground priority. 203 BinderInternal.disableBackgroundScheduling(true); 204 205 // Prepare the main looper thread (this thread). 206 android.os.Process.setThreadPriority( 207 android.os.Process.THREAD_PRIORITY_FOREGROUND); 208 android.os.Process.setCanSelfBackground(false); 209 Looper.prepareMainLooper(); 210 211 // Initialize native services. 212 System.loadLibrary("android_servers"); 213 nativeInit(); 214 215 // Check whether we failed to shut down last time we tried. 216 // This call may not return. 217 performPendingShutdown(); 218 219 // Initialize the system context. 220 createSystemContext(); 221 222 // Create the system service manager. 223 mSystemServiceManager = new SystemServiceManager(mSystemContext); 224 LocalServices.addService(SystemServiceManager.class, mSystemServiceManager); 225 226 // Start services. 227 try { 228 startBootstrapServices(); 229 startCoreServices(); 230 startOtherServices(); 231 } catch (RuntimeException ex) { 232 Slog.e("System", "******************************************"); 233 Slog.e("System", "************ Failure starting system services", ex); 234 throw ex; 235 } 236 237 // For debug builds, log event loop stalls to dropbox for analysis. 238 if (StrictMode.conditionallyEnableDebugLogging()) { 239 Slog.i(TAG, "Enabled StrictMode for system server main thread."); 240 } 241 242 // Loop forever. 243 Looper.loop(); 244 throw new RuntimeException("Main thread loop unexpectedly exited"); 245 } 246 247 private void reportWtf(String msg, Throwable e) { 248 Slog.w(TAG, "***********************************************"); 249 Log.wtf(TAG, "BOOT FAILURE " + msg, e); 250 } 251 252 private void performPendingShutdown() { 253 final String shutdownAction = SystemProperties.get( 254 ShutdownThread.SHUTDOWN_ACTION_PROPERTY, ""); 255 if (shutdownAction != null && shutdownAction.length() > 0) { 256 boolean reboot = (shutdownAction.charAt(0) == '1'); 257 258 final String reason; 259 if (shutdownAction.length() > 1) { 260 reason = shutdownAction.substring(1, shutdownAction.length()); 261 } else { 262 reason = null; 263 } 264 265 ShutdownThread.rebootOrShutdown(reboot, reason); 266 } 267 } 268 269 private void createSystemContext() { 270 ActivityThread activityThread = ActivityThread.systemMain(); 271 mSystemContext = activityThread.getSystemContext(); 272 mSystemContext.setTheme(android.R.style.Theme_DeviceDefault_Light_DarkActionBar); 273 } 274 275 private void startBootstrapServices() { 276 // Wait for installd to finish starting up so that it has a chance to 277 // create critical directories such as /data/user with the appropriate 278 // permissions. We need this to complete before we initialize other services. 279 mInstaller = mSystemServiceManager.startService(Installer.class); 280 281 // Power manager needs to be started early because other services need it. 282 // TODO: The conversion to the new pattern is incomplete. We need to switch 283 // the power manager's dependencies over then we can use boot phases to arrange 284 // initialization order and remove the mPowerManagerService field. 285 mPowerManagerService = mSystemServiceManager.startService(PowerManagerService.class); 286 287 // Activity manager runs the show. 288 mActivityManagerService = mSystemServiceManager.startService( 289 ActivityManagerService.Lifecycle.class).getService(); 290 } 291 292 private void startCoreServices() { 293 // Display manager is needed to provide display metrics before package manager 294 // starts up. 295 mDisplayManagerService = mSystemServiceManager.startService(DisplayManagerService.class); 296 } 297 298 private void startOtherServices() { 299 final Context context = mSystemContext; 300 AccountManagerService accountManager = null; 301 ContentService contentService = null; 302 LightsManager lights = null; 303 BatteryService battery = null; 304 VibratorService vibrator = null; 305 IAlarmManager alarm = null; 306 MountService mountService = null; 307 NetworkManagementService networkManagement = null; 308 NetworkStatsService networkStats = null; 309 NetworkPolicyManagerService networkPolicy = null; 310 ConnectivityService connectivity = null; 311 NsdService serviceDiscovery= null; 312 IPackageManager pm = null; 313 WindowManagerService wm = null; 314 BluetoothManagerService bluetooth = null; 315 DockObserver dock = null; 316 UsbService usb = null; 317 SerialService serial = null; 318 RecognitionManagerService recognition = null; 319 NetworkTimeUpdateService networkTimeUpdater = null; 320 CommonTimeManagementService commonTimeMgmtService = null; 321 InputManagerService inputManager = null; 322 TelephonyRegistry telephonyRegistry = null; 323 ConsumerIrService consumerIr = null; 324 325 boolean onlyCore = false; 326 boolean firstBoot = false; 327 boolean disableStorage = SystemProperties.getBoolean("config.disable_storage", false); 328 boolean disableMedia = SystemProperties.getBoolean("config.disable_media", false); 329 boolean disableBluetooth = SystemProperties.getBoolean("config.disable_bluetooth", false); 330 boolean disableTelephony = SystemProperties.getBoolean("config.disable_telephony", false); 331 boolean disableLocation = SystemProperties.getBoolean("config.disable_location", false); 332 boolean disableSystemUI = SystemProperties.getBoolean("config.disable_systemui", false); 333 boolean disableNonCoreServices = SystemProperties.getBoolean("config.disable_noncore", false); 334 boolean disableNetwork = SystemProperties.getBoolean("config.disable_network", false); 335 336 try { 337 Slog.i(TAG, "Telephony Registry"); 338 telephonyRegistry = new TelephonyRegistry(context); 339 ServiceManager.addService("telephony.registry", telephonyRegistry); 340 341 Slog.i(TAG, "Scheduling Policy"); 342 ServiceManager.addService("scheduling_policy", new SchedulingPolicyService()); 343 344 AttributeCache.init(context); 345 346 // We need the default display before we can initialize the package manager. 347 mSystemServiceManager.startBootPhase(SystemService.PHASE_WAIT_FOR_DEFAULT_DISPLAY); 348 349 Slog.i(TAG, "Package Manager"); 350 // Only run "core" apps if we're encrypting the device. 351 String cryptState = SystemProperties.get("vold.decrypt"); 352 if (ENCRYPTING_STATE.equals(cryptState)) { 353 Slog.w(TAG, "Detected encryption in progress - only parsing core apps"); 354 onlyCore = true; 355 } else if (ENCRYPTED_STATE.equals(cryptState)) { 356 Slog.w(TAG, "Device encrypted - only parsing core apps"); 357 onlyCore = true; 358 } 359 360 pm = PackageManagerService.main(context, mInstaller, 361 mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF, 362 onlyCore); 363 try { 364 firstBoot = pm.isFirstBoot(); 365 } catch (RemoteException e) { 366 } 367 368 mActivityManagerService.setSystemProcess(); 369 370 Slog.i(TAG, "Entropy Mixer"); 371 ServiceManager.addService("entropy", new EntropyMixer(context)); 372 373 Slog.i(TAG, "User Service"); 374 ServiceManager.addService(Context.USER_SERVICE, 375 UserManagerService.getInstance()); 376 377 mContentResolver = context.getContentResolver(); 378 379 // The AccountManager must come before the ContentService 380 try { 381 // TODO: seems like this should be disable-able, but req'd by ContentService 382 Slog.i(TAG, "Account Manager"); 383 accountManager = new AccountManagerService(context); 384 ServiceManager.addService(Context.ACCOUNT_SERVICE, accountManager); 385 } catch (Throwable e) { 386 Slog.e(TAG, "Failure starting Account Manager", e); 387 } 388 389 Slog.i(TAG, "Content Manager"); 390 contentService = ContentService.main(context, 391 mFactoryTestMode == FactoryTest.FACTORY_TEST_LOW_LEVEL); 392 393 Slog.i(TAG, "System Content Providers"); 394 mActivityManagerService.installSystemProviders(); 395 396 mSystemServiceManager.startService(LightsService.class); 397 lights = LocalServices.getService(LightsManager.class); 398 399 Slog.i(TAG, "Battery Service"); 400 battery = new BatteryService(context, lights); 401 ServiceManager.addService("battery", battery); 402 403 Slog.i(TAG, "Vibrator Service"); 404 vibrator = new VibratorService(context); 405 ServiceManager.addService("vibrator", vibrator); 406 407 // TODO: use boot phase 408 // only initialize the power service after we have started the 409 // lights service, content providers and the battery service. 410 mPowerManagerService.init(lights, battery, 411 BatteryStatsService.getService(), 412 mActivityManagerService.getAppOpsService()); 413 414 Slog.i(TAG, "Consumer IR Service"); 415 consumerIr = new ConsumerIrService(context); 416 ServiceManager.addService(Context.CONSUMER_IR_SERVICE, consumerIr); 417 418 mSystemServiceManager.startService(AlarmManagerService.class); 419 alarm = IAlarmManager.Stub.asInterface( 420 ServiceManager.getService(Context.ALARM_SERVICE)); 421 422 Slog.i(TAG, "Init Watchdog"); 423 final Watchdog watchdog = Watchdog.getInstance(); 424 watchdog.init(context, mActivityManagerService); 425 426 Slog.i(TAG, "Input Manager"); 427 inputManager = new InputManagerService(context); 428 429 Slog.i(TAG, "Window Manager"); 430 wm = WindowManagerService.main(context, inputManager, 431 mFactoryTestMode != FactoryTest.FACTORY_TEST_LOW_LEVEL, 432 !firstBoot, onlyCore); 433 ServiceManager.addService(Context.WINDOW_SERVICE, wm); 434 ServiceManager.addService(Context.INPUT_SERVICE, inputManager); 435 436 mActivityManagerService.setWindowManager(wm); 437 438 inputManager.setWindowManagerCallbacks(wm.getInputMonitor()); 439 inputManager.start(); 440 441 // TODO: Use service dependencies instead. 442 mDisplayManagerService.windowManagerAndInputReady(); 443 444 // Skip Bluetooth if we have an emulator kernel 445 // TODO: Use a more reliable check to see if this product should 446 // support Bluetooth - see bug 988521 447 if (SystemProperties.get("ro.kernel.qemu").equals("1")) { 448 Slog.i(TAG, "No Bluetooh Service (emulator)"); 449 } else if (mFactoryTestMode == FactoryTest.FACTORY_TEST_LOW_LEVEL) { 450 Slog.i(TAG, "No Bluetooth Service (factory test)"); 451 } else if (!context.getPackageManager().hasSystemFeature 452 (PackageManager.FEATURE_BLUETOOTH)) { 453 Slog.i(TAG, "No Bluetooth Service (Bluetooth Hardware Not Present)"); 454 } else if (disableBluetooth) { 455 Slog.i(TAG, "Bluetooth Service disabled by config"); 456 } else { 457 Slog.i(TAG, "Bluetooth Manager Service"); 458 bluetooth = new BluetoothManagerService(context); 459 ServiceManager.addService(BluetoothAdapter.BLUETOOTH_MANAGER_SERVICE, bluetooth); 460 } 461 } catch (RuntimeException e) { 462 Slog.e("System", "******************************************"); 463 Slog.e("System", "************ Failure starting core service", e); 464 } 465 466 StatusBarManagerService statusBar = null; 467 INotificationManager notification = null; 468 InputMethodManagerService imm = null; 469 WallpaperManagerService wallpaper = null; 470 LocationManagerService location = null; 471 CountryDetectorService countryDetector = null; 472 TextServicesManagerService tsms = null; 473 LockSettingsService lockSettings = null; 474 AssetAtlasService atlas = null; 475 MediaRouterService mediaRouter = null; 476 477 // Bring up services needed for UI. 478 if (mFactoryTestMode != FactoryTest.FACTORY_TEST_LOW_LEVEL) { 479 //if (!disableNonCoreServices) { // TODO: View depends on these; mock them? 480 if (true) { 481 try { 482 Slog.i(TAG, "Input Method Service"); 483 imm = new InputMethodManagerService(context, wm); 484 ServiceManager.addService(Context.INPUT_METHOD_SERVICE, imm); 485 } catch (Throwable e) { 486 reportWtf("starting Input Manager Service", e); 487 } 488 489 try { 490 Slog.i(TAG, "Accessibility Manager"); 491 ServiceManager.addService(Context.ACCESSIBILITY_SERVICE, 492 new AccessibilityManagerService(context)); 493 } catch (Throwable e) { 494 reportWtf("starting Accessibility Manager", e); 495 } 496 } 497 } 498 499 try { 500 wm.displayReady(); 501 } catch (Throwable e) { 502 reportWtf("making display ready", e); 503 } 504 505 try { 506 pm.performBootDexOpt(); 507 } catch (Throwable e) { 508 reportWtf("performing boot dexopt", e); 509 } 510 511 try { 512 ActivityManagerNative.getDefault().showBootMessage( 513 context.getResources().getText( 514 com.android.internal.R.string.android_upgrading_starting_apps), 515 false); 516 } catch (RemoteException e) { 517 } 518 519 if (mFactoryTestMode != FactoryTest.FACTORY_TEST_LOW_LEVEL) { 520 if (!disableStorage && 521 !"0".equals(SystemProperties.get("system_init.startmountservice"))) { 522 try { 523 /* 524 * NotificationManagerService is dependant on MountService, 525 * (for media / usb notifications) so we must start MountService first. 526 */ 527 Slog.i(TAG, "Mount Service"); 528 mountService = new MountService(context); 529 ServiceManager.addService("mount", mountService); 530 } catch (Throwable e) { 531 reportWtf("starting Mount Service", e); 532 } 533 } 534 535 if (!disableNonCoreServices) { 536 try { 537 Slog.i(TAG, "LockSettingsService"); 538 lockSettings = new LockSettingsService(context); 539 ServiceManager.addService("lock_settings", lockSettings); 540 } catch (Throwable e) { 541 reportWtf("starting LockSettingsService service", e); 542 } 543 544 try { 545 if (pm.hasSystemFeature(PackageManager.FEATURE_DEVICE_ADMIN)) { 546 mSystemServiceManager.startService(DEVICE_POLICY_MANAGER_SERVICE_CLASS); 547 } 548 } catch (Throwable e) { 549 reportWtf("starting DevicePolicyService", e); 550 } 551 } 552 553 if (!disableSystemUI) { 554 try { 555 Slog.i(TAG, "Status Bar"); 556 statusBar = new StatusBarManagerService(context, wm); 557 ServiceManager.addService(Context.STATUS_BAR_SERVICE, statusBar); 558 } catch (Throwable e) { 559 reportWtf("starting StatusBarManagerService", e); 560 } 561 } 562 563 if (!disableNonCoreServices) { 564 try { 565 Slog.i(TAG, "Clipboard Service"); 566 ServiceManager.addService(Context.CLIPBOARD_SERVICE, 567 new ClipboardService(context)); 568 } catch (Throwable e) { 569 reportWtf("starting Clipboard Service", e); 570 } 571 } 572 573 if (!disableNetwork) { 574 try { 575 Slog.i(TAG, "NetworkManagement Service"); 576 networkManagement = NetworkManagementService.create(context); 577 ServiceManager.addService(Context.NETWORKMANAGEMENT_SERVICE, networkManagement); 578 } catch (Throwable e) { 579 reportWtf("starting NetworkManagement Service", e); 580 } 581 } 582 583 if (!disableNonCoreServices) { 584 try { 585 Slog.i(TAG, "Text Service Manager Service"); 586 tsms = new TextServicesManagerService(context); 587 ServiceManager.addService(Context.TEXT_SERVICES_MANAGER_SERVICE, tsms); 588 } catch (Throwable e) { 589 reportWtf("starting Text Service Manager Service", e); 590 } 591 } 592 593 if (!disableNetwork) { 594 try { 595 Slog.i(TAG, "NetworkStats Service"); 596 networkStats = new NetworkStatsService(context, networkManagement, alarm); 597 ServiceManager.addService(Context.NETWORK_STATS_SERVICE, networkStats); 598 } catch (Throwable e) { 599 reportWtf("starting NetworkStats Service", e); 600 } 601 602 try { 603 Slog.i(TAG, "NetworkPolicy Service"); 604 networkPolicy = new NetworkPolicyManagerService( 605 context, mActivityManagerService, 606 (IPowerManager)ServiceManager.getService(Context.POWER_SERVICE), 607 networkStats, networkManagement); 608 ServiceManager.addService(Context.NETWORK_POLICY_SERVICE, networkPolicy); 609 } catch (Throwable e) { 610 reportWtf("starting NetworkPolicy Service", e); 611 } 612 613 try { 614 mSystemServiceManager.startService(WIFI_P2P_SERVICE_CLASS); 615 } catch (Throwable e) { 616 reportWtf("starting Wi-Fi P2pService", e); 617 } 618 619 try { 620 mSystemServiceManager.startService(WIFI_HOTSPOT_SERVICE_CLASS); 621 } catch (Throwable e) { 622 reportWtf("starting Wi-Fi HotspotService", e); 623 } 624 625 try { 626 mSystemServiceManager.startService(WIFI_SERVICE_CLASS); 627 } catch (Throwable e) { 628 reportWtf("starting Wi-Fi Service", e); 629 } 630 631 try { 632 Slog.i(TAG, "Connectivity Service"); 633 connectivity = new ConnectivityService( 634 context, networkManagement, networkStats, networkPolicy); 635 ServiceManager.addService(Context.CONNECTIVITY_SERVICE, connectivity); 636 networkStats.bindConnectivityManager(connectivity); 637 networkPolicy.bindConnectivityManager(connectivity); 638 } catch (Throwable e) { 639 reportWtf("starting Connectivity Service", e); 640 } 641 642 try { 643 Slog.i(TAG, "Network Service Discovery Service"); 644 serviceDiscovery = NsdService.create(context); 645 ServiceManager.addService( 646 Context.NSD_SERVICE, serviceDiscovery); 647 } catch (Throwable e) { 648 reportWtf("starting Service Discovery Service", e); 649 } 650 } 651 652 if (!disableNonCoreServices) { 653 try { 654 Slog.i(TAG, "UpdateLock Service"); 655 ServiceManager.addService(Context.UPDATE_LOCK_SERVICE, 656 new UpdateLockService(context)); 657 } catch (Throwable e) { 658 reportWtf("starting UpdateLockService", e); 659 } 660 } 661 662 /* 663 * MountService has a few dependencies: Notification Manager and 664 * AppWidget Provider. Make sure MountService is completely started 665 * first before continuing. 666 */ 667 if (mountService != null && !onlyCore) { 668 mountService.waitForAsecScan(); 669 } 670 671 try { 672 if (accountManager != null) 673 accountManager.systemReady(); 674 } catch (Throwable e) { 675 reportWtf("making Account Manager Service ready", e); 676 } 677 678 try { 679 if (contentService != null) 680 contentService.systemReady(); 681 } catch (Throwable e) { 682 reportWtf("making Content Service ready", e); 683 } 684 685 mSystemServiceManager.startService(NotificationManagerService.class); 686 notification = INotificationManager.Stub.asInterface( 687 ServiceManager.getService(Context.NOTIFICATION_SERVICE)); 688 networkPolicy.bindNotificationManager(notification); 689 690 mSystemServiceManager.startService(DeviceStorageMonitorService.class); 691 692 if (!disableLocation) { 693 try { 694 Slog.i(TAG, "Location Manager"); 695 location = new LocationManagerService(context); 696 ServiceManager.addService(Context.LOCATION_SERVICE, location); 697 } catch (Throwable e) { 698 reportWtf("starting Location Manager", e); 699 } 700 701 try { 702 Slog.i(TAG, "Country Detector"); 703 countryDetector = new CountryDetectorService(context); 704 ServiceManager.addService(Context.COUNTRY_DETECTOR, countryDetector); 705 } catch (Throwable e) { 706 reportWtf("starting Country Detector", e); 707 } 708 } 709 710 if (!disableNonCoreServices) { 711 try { 712 Slog.i(TAG, "Search Service"); 713 ServiceManager.addService(Context.SEARCH_SERVICE, 714 new SearchManagerService(context)); 715 } catch (Throwable e) { 716 reportWtf("starting Search Service", e); 717 } 718 } 719 720 try { 721 Slog.i(TAG, "DropBox Service"); 722 ServiceManager.addService(Context.DROPBOX_SERVICE, 723 new DropBoxManagerService(context, new File("/data/system/dropbox"))); 724 } catch (Throwable e) { 725 reportWtf("starting DropBoxManagerService", e); 726 } 727 728 if (!disableNonCoreServices && context.getResources().getBoolean( 729 R.bool.config_enableWallpaperService)) { 730 try { 731 Slog.i(TAG, "Wallpaper Service"); 732 wallpaper = new WallpaperManagerService(context); 733 ServiceManager.addService(Context.WALLPAPER_SERVICE, wallpaper); 734 } catch (Throwable e) { 735 reportWtf("starting Wallpaper Service", e); 736 } 737 } 738 739 if (!disableMedia && !"0".equals(SystemProperties.get("system_init.startaudioservice"))) { 740 try { 741 Slog.i(TAG, "Audio Service"); 742 ServiceManager.addService(Context.AUDIO_SERVICE, new AudioService(context)); 743 } catch (Throwable e) { 744 reportWtf("starting Audio Service", e); 745 } 746 } 747 748 if (!disableNonCoreServices) { 749 try { 750 Slog.i(TAG, "Dock Observer"); 751 // Listen for dock station changes 752 dock = new DockObserver(context); 753 } catch (Throwable e) { 754 reportWtf("starting DockObserver", e); 755 } 756 } 757 758 if (!disableMedia) { 759 try { 760 Slog.i(TAG, "Wired Accessory Manager"); 761 // Listen for wired headset changes 762 inputManager.setWiredAccessoryCallbacks( 763 new WiredAccessoryManager(context, inputManager)); 764 } catch (Throwable e) { 765 reportWtf("starting WiredAccessoryManager", e); 766 } 767 } 768 769 if (!disableNonCoreServices) { 770 try { 771 if (pm.hasSystemFeature(PackageManager.FEATURE_USB_HOST) || 772 pm.hasSystemFeature(PackageManager.FEATURE_USB_ACCESSORY)) { 773 // Manage USB host and device support 774 mSystemServiceManager.startService(USB_SERVICE_CLASS); 775 } 776 } catch (Throwable e) { 777 reportWtf("starting UsbService", e); 778 } 779 780 try { 781 Slog.i(TAG, "Serial Service"); 782 // Serial port support 783 serial = new SerialService(context); 784 ServiceManager.addService(Context.SERIAL_SERVICE, serial); 785 } catch (Throwable e) { 786 Slog.e(TAG, "Failure starting SerialService", e); 787 } 788 } 789 790 mSystemServiceManager.startService(TwilightService.class); 791 792 mSystemServiceManager.startService(UiModeManagerService.class); 793 794 if (!disableNonCoreServices) { 795 try { 796 if (pm.hasSystemFeature(PackageManager.FEATURE_BACKUP)) { 797 mSystemServiceManager.startService(BACKUP_MANAGER_SERVICE_CLASS); 798 } 799 } catch (Throwable e) { 800 Slog.e(TAG, "Failure starting Backup Service", e); 801 } 802 803 try { 804 if (pm.hasSystemFeature(PackageManager.FEATURE_APP_WIDGETS)) { 805 mSystemServiceManager.startService(APPWIDGET_SERVICE_CLASS); 806 } 807 } catch (Throwable e) { 808 reportWtf("starting AppWidget Service", e); 809 } 810 811 try { 812 Slog.i(TAG, "Recognition Service"); 813 recognition = new RecognitionManagerService(context); 814 } catch (Throwable e) { 815 reportWtf("starting Recognition Service", e); 816 } 817 } 818 819 try { 820 Slog.i(TAG, "DiskStats Service"); 821 ServiceManager.addService("diskstats", new DiskStatsService(context)); 822 } catch (Throwable e) { 823 reportWtf("starting DiskStats Service", e); 824 } 825 826 try { 827 // need to add this service even if SamplingProfilerIntegration.isEnabled() 828 // is false, because it is this service that detects system property change and 829 // turns on SamplingProfilerIntegration. Plus, when sampling profiler doesn't work, 830 // there is little overhead for running this service. 831 Slog.i(TAG, "SamplingProfiler Service"); 832 ServiceManager.addService("samplingprofiler", 833 new SamplingProfilerService(context)); 834 } catch (Throwable e) { 835 reportWtf("starting SamplingProfiler Service", e); 836 } 837 838 if (!disableNetwork) { 839 try { 840 Slog.i(TAG, "NetworkTimeUpdateService"); 841 networkTimeUpdater = new NetworkTimeUpdateService(context); 842 } catch (Throwable e) { 843 reportWtf("starting NetworkTimeUpdate service", e); 844 } 845 } 846 847 if (!disableMedia) { 848 try { 849 Slog.i(TAG, "CommonTimeManagementService"); 850 commonTimeMgmtService = new CommonTimeManagementService(context); 851 ServiceManager.addService("commontime_management", commonTimeMgmtService); 852 } catch (Throwable e) { 853 reportWtf("starting CommonTimeManagementService service", e); 854 } 855 } 856 857 if (!disableNetwork) { 858 try { 859 Slog.i(TAG, "CertBlacklister"); 860 CertBlacklister blacklister = new CertBlacklister(context); 861 } catch (Throwable e) { 862 reportWtf("starting CertBlacklister", e); 863 } 864 } 865 866 if (!disableNonCoreServices) { 867 // Dreams (interactive idle-time views, a/k/a screen savers, and doze mode) 868 mSystemServiceManager.startService(DreamManagerService.class); 869 } 870 871 if (!disableNonCoreServices) { 872 try { 873 Slog.i(TAG, "Assets Atlas Service"); 874 atlas = new AssetAtlasService(context); 875 ServiceManager.addService(AssetAtlasService.ASSET_ATLAS_SERVICE, atlas); 876 } catch (Throwable e) { 877 reportWtf("starting AssetAtlasService", e); 878 } 879 } 880 881 try { 882 Slog.i(TAG, "IdleMaintenanceService"); 883 new IdleMaintenanceService(context, battery); 884 } catch (Throwable e) { 885 reportWtf("starting IdleMaintenanceService", e); 886 } 887 888 try { 889 if (pm.hasSystemFeature(PackageManager.FEATURE_PRINTING)) { 890 mSystemServiceManager.startService(PRINT_MANAGER_SERVICE_CLASS); 891 } 892 } catch (Throwable e) { 893 reportWtf("starting Print Service", e); 894 } 895 896 try { 897 Slog.i(TAG, "MediaSessionService"); 898 mSystemServiceManager.startService(MediaSessionService.class); 899 } catch (Throwable e) { 900 reportWtf("starting MediaSessionService", e); 901 } 902 903 try { 904 mSystemServiceManager.startService(HDMI_CEC_SERVICE_CLASS); 905 } catch (Throwable e) { 906 reportWtf("starting HdmiCec Service", e); 907 } 908 909 if (!disableNonCoreServices) { 910 try { 911 Slog.i(TAG, "Media Router Service"); 912 mediaRouter = new MediaRouterService(context); 913 ServiceManager.addService(Context.MEDIA_ROUTER_SERVICE, mediaRouter); 914 } catch (Throwable e) { 915 reportWtf("starting MediaRouterService", e); 916 } 917 918 try { 919 Slog.i(TAG, "Trust Manager"); 920 mSystemServiceManager.startService(TrustManagerService.class); 921 } catch (Throwable e) { 922 Slog.e(TAG, "Failure starting TrustManagerService", e); 923 } 924 } 925 } 926 927 // Before things start rolling, be sure we have decided whether 928 // we are in safe mode. 929 final boolean safeMode = wm.detectSafeMode(); 930 if (safeMode) { 931 mActivityManagerService.enterSafeMode(); 932 // Disable the JIT for the system_server process 933 VMRuntime.getRuntime().disableJitCompilation(); 934 } else { 935 // Enable the JIT for the system_server process 936 VMRuntime.getRuntime().startJitCompilation(); 937 } 938 939 // It is now time to start up the app processes... 940 941 try { 942 vibrator.systemReady(); 943 } catch (Throwable e) { 944 reportWtf("making Vibrator Service ready", e); 945 } 946 947 if (lockSettings != null) { 948 try { 949 lockSettings.systemReady(); 950 } catch (Throwable e) { 951 reportWtf("making Lock Settings Service ready", e); 952 } 953 } 954 955 // Needed by DevicePolicyManager for initialization 956 mSystemServiceManager.startBootPhase(SystemService.PHASE_LOCK_SETTINGS_READY); 957 958 mSystemServiceManager.startBootPhase(SystemService.PHASE_SYSTEM_SERVICES_READY); 959 960 try { 961 wm.systemReady(); 962 } catch (Throwable e) { 963 reportWtf("making Window Manager Service ready", e); 964 } 965 966 if (safeMode) { 967 mActivityManagerService.showSafeModeOverlay(); 968 } 969 970 // Update the configuration for this context by hand, because we're going 971 // to start using it before the config change done in wm.systemReady() will 972 // propagate to it. 973 Configuration config = wm.computeNewConfiguration(); 974 DisplayMetrics metrics = new DisplayMetrics(); 975 WindowManager w = (WindowManager)context.getSystemService(Context.WINDOW_SERVICE); 976 w.getDefaultDisplay().getMetrics(metrics); 977 context.getResources().updateConfiguration(config, metrics); 978 979 try { 980 // TODO: use boot phase 981 mPowerManagerService.systemReady(); 982 } catch (Throwable e) { 983 reportWtf("making Power Manager Service ready", e); 984 } 985 986 try { 987 pm.systemReady(); 988 } catch (Throwable e) { 989 reportWtf("making Package Manager Service ready", e); 990 } 991 992 try { 993 // TODO: use boot phase and communicate these flags some other way 994 mDisplayManagerService.systemReady(safeMode, onlyCore); 995 } catch (Throwable e) { 996 reportWtf("making Display Manager Service ready", e); 997 } 998 999 // These are needed to propagate to the runnable below. 1000 final MountService mountServiceF = mountService; 1001 final BatteryService batteryF = battery; 1002 final NetworkManagementService networkManagementF = networkManagement; 1003 final NetworkStatsService networkStatsF = networkStats; 1004 final NetworkPolicyManagerService networkPolicyF = networkPolicy; 1005 final ConnectivityService connectivityF = connectivity; 1006 final DockObserver dockF = dock; 1007 final WallpaperManagerService wallpaperF = wallpaper; 1008 final InputMethodManagerService immF = imm; 1009 final RecognitionManagerService recognitionF = recognition; 1010 final LocationManagerService locationF = location; 1011 final CountryDetectorService countryDetectorF = countryDetector; 1012 final NetworkTimeUpdateService networkTimeUpdaterF = networkTimeUpdater; 1013 final CommonTimeManagementService commonTimeMgmtServiceF = commonTimeMgmtService; 1014 final TextServicesManagerService textServiceManagerServiceF = tsms; 1015 final StatusBarManagerService statusBarF = statusBar; 1016 final AssetAtlasService atlasF = atlas; 1017 final InputManagerService inputManagerF = inputManager; 1018 final TelephonyRegistry telephonyRegistryF = telephonyRegistry; 1019 final MediaRouterService mediaRouterF = mediaRouter; 1020 1021 // We now tell the activity manager it is okay to run third party 1022 // code. It will call back into us once it has gotten to the state 1023 // where third party code can really run (but before it has actually 1024 // started launching the initial applications), for us to complete our 1025 // initialization. 1026 mActivityManagerService.systemReady(new Runnable() { 1027 @Override 1028 public void run() { 1029 Slog.i(TAG, "Making services ready"); 1030 mSystemServiceManager.startBootPhase( 1031 SystemService.PHASE_ACTIVITY_MANAGER_READY); 1032 1033 try { 1034 mActivityManagerService.startObservingNativeCrashes(); 1035 } catch (Throwable e) { 1036 reportWtf("observing native crashes", e); 1037 } 1038 try { 1039 startSystemUi(context); 1040 } catch (Throwable e) { 1041 reportWtf("starting System UI", e); 1042 } 1043 try { 1044 if (mountServiceF != null) mountServiceF.systemReady(); 1045 } catch (Throwable e) { 1046 reportWtf("making Mount Service ready", e); 1047 } 1048 try { 1049 if (batteryF != null) batteryF.systemReady(); 1050 } catch (Throwable e) { 1051 reportWtf("making Battery Service ready", e); 1052 } 1053 try { 1054 if (networkManagementF != null) networkManagementF.systemReady(); 1055 } catch (Throwable e) { 1056 reportWtf("making Network Managment Service ready", e); 1057 } 1058 try { 1059 if (networkStatsF != null) networkStatsF.systemReady(); 1060 } catch (Throwable e) { 1061 reportWtf("making Network Stats Service ready", e); 1062 } 1063 try { 1064 if (networkPolicyF != null) networkPolicyF.systemReady(); 1065 } catch (Throwable e) { 1066 reportWtf("making Network Policy Service ready", e); 1067 } 1068 try { 1069 if (connectivityF != null) connectivityF.systemReady(); 1070 } catch (Throwable e) { 1071 reportWtf("making Connectivity Service ready", e); 1072 } 1073 try { 1074 if (dockF != null) dockF.systemReady(); 1075 } catch (Throwable e) { 1076 reportWtf("making Dock Service ready", e); 1077 } 1078 try { 1079 if (recognitionF != null) recognitionF.systemReady(); 1080 } catch (Throwable e) { 1081 reportWtf("making Recognition Service ready", e); 1082 } 1083 Watchdog.getInstance().start(); 1084 1085 // It is now okay to let the various system services start their 1086 // third party code... 1087 mSystemServiceManager.startBootPhase( 1088 SystemService.PHASE_THIRD_PARTY_APPS_CAN_START); 1089 1090 try { 1091 if (wallpaperF != null) wallpaperF.systemRunning(); 1092 } catch (Throwable e) { 1093 reportWtf("Notifying WallpaperService running", e); 1094 } 1095 try { 1096 if (immF != null) immF.systemRunning(statusBarF); 1097 } catch (Throwable e) { 1098 reportWtf("Notifying InputMethodService running", e); 1099 } 1100 try { 1101 if (locationF != null) locationF.systemRunning(); 1102 } catch (Throwable e) { 1103 reportWtf("Notifying Location Service running", e); 1104 } 1105 try { 1106 if (countryDetectorF != null) countryDetectorF.systemRunning(); 1107 } catch (Throwable e) { 1108 reportWtf("Notifying CountryDetectorService running", e); 1109 } 1110 try { 1111 if (networkTimeUpdaterF != null) networkTimeUpdaterF.systemRunning(); 1112 } catch (Throwable e) { 1113 reportWtf("Notifying NetworkTimeService running", e); 1114 } 1115 try { 1116 if (commonTimeMgmtServiceF != null) { 1117 commonTimeMgmtServiceF.systemRunning(); 1118 } 1119 } catch (Throwable e) { 1120 reportWtf("Notifying CommonTimeManagementService running", e); 1121 } 1122 try { 1123 if (textServiceManagerServiceF != null) 1124 textServiceManagerServiceF.systemRunning(); 1125 } catch (Throwable e) { 1126 reportWtf("Notifying TextServicesManagerService running", e); 1127 } 1128 try { 1129 if (atlasF != null) atlasF.systemRunning(); 1130 } catch (Throwable e) { 1131 reportWtf("Notifying AssetAtlasService running", e); 1132 } 1133 try { 1134 // TODO(BT) Pass parameter to input manager 1135 if (inputManagerF != null) inputManagerF.systemRunning(); 1136 } catch (Throwable e) { 1137 reportWtf("Notifying InputManagerService running", e); 1138 } 1139 try { 1140 if (telephonyRegistryF != null) telephonyRegistryF.systemRunning(); 1141 } catch (Throwable e) { 1142 reportWtf("Notifying TelephonyRegistry running", e); 1143 } 1144 try { 1145 if (mediaRouterF != null) mediaRouterF.systemRunning(); 1146 } catch (Throwable e) { 1147 reportWtf("Notifying MediaRouterService running", e); 1148 } 1149 1150 mSystemServiceManager.startBootPhase(SystemService.PHASE_BOOT_COMPLETE); 1151 } 1152 }); 1153 } 1154 1155 static final void startSystemUi(Context context) { 1156 Intent intent = new Intent(); 1157 intent.setComponent(new ComponentName("com.android.systemui", 1158 "com.android.systemui.SystemUIService")); 1159 //Slog.d(TAG, "Starting service: " + intent); 1160 context.startServiceAsUser(intent, UserHandle.OWNER); 1161 } 1162} 1163