private void checkStorageUsersAsync() {
   IMountService ims = getMountService();
   if (ims == null) {
     // Display error dialog
     scheduleShowDialog(DLG_ERROR_SHARING);
   }
   String extStoragePath = Environment.getExternalStorageDirectory().toString();
   boolean showDialog = false;
   try {
     int[] stUsers = ims.getStorageUsers(extStoragePath);
     if (stUsers != null && stUsers.length > 0) {
       showDialog = true;
     } else {
       // List of applications on sdcard.
       ActivityManager am = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
       List<ApplicationInfo> infoList = am.getRunningExternalApplications();
       if (infoList != null && infoList.size() > 0) {
         showDialog = true;
       }
     }
   } catch (RemoteException e) {
     // Display error dialog
     scheduleShowDialog(DLG_ERROR_SHARING);
   }
   if (showDialog) {
     // Display dialog to user
     scheduleShowDialog(DLG_CONFIRM_KILL_STORAGE_USERS);
   } else {
     if (localLOGV) Log.i(TAG, "Enabling UMS");
     switchUsbMassStorage(true);
   }
 }
Beispiel #2
0
 // luwenchao fix bug 0002953
 // support /mnt/sdcard and /mnt/sdcardEx for ums
 public static String getTFcardStorageState() {
   try {
     IMountService mountService =
         IMountService.Stub.asInterface(ServiceManager.getService("mount"));
     return mountService.getVolumeState(getTFcardStorageDirectory().toString());
   } catch (Exception rex) {
     return Environment.MEDIA_REMOVED;
   }
 }
Beispiel #3
0
 private static StorageVolume getPrimaryVolume() {
   if (mPrimaryVolume == null) {
     synchronized (mLock) {
       if (mPrimaryVolume == null) {
         try {
           IMountService mountService =
               IMountService.Stub.asInterface(ServiceManager.getService("mount"));
           Parcelable[] volumes = mountService.getVolumeList();
           mPrimaryVolume = (StorageVolume) volumes[0];
         } catch (Exception e) {
           Log.e(TAG, "couldn't talk to MountService", e);
         }
       }
     }
   }
   return mPrimaryVolume;
 }
  /** Update the encryption password if it is enabled * */
  private void updateEncryptionPassword(String password) {
    DevicePolicyManager dpm = getDevicePolicyManager();
    if (dpm.getStorageEncryptionStatus() != DevicePolicyManager.ENCRYPTION_STATUS_ACTIVE) {
      return;
    }

    IBinder service = ServiceManager.getService("mount");
    if (service == null) {
      Log.e(TAG, "Could not find the mount service to update the encryption password");
      return;
    }

    IMountService mountService = IMountService.Stub.asInterface(service);
    try {
      mountService.changeEncryptionPassword(password);
    } catch (RemoteException e) {
      Log.e(TAG, "Error changing encryption password", e);
    }
  }
 private boolean isUMSEnabled() {
   if (mMountService == null) {
     Xlog.d(TAG, " mMountService is null, return");
     return false;
   }
   try {
     return mMountService.isUsbMassStorageEnabled();
   } catch (RemoteException e) {
     Xlog.e(TAG, "Util:RemoteException when isUsbMassStorageEnabled: " + e);
     return false;
   }
 }
        public void onClick(View v) {
          if (Utils.isMonkeyRunning()) {
            return;
          }

          /* WARNING - nasty hack!
            Settings for the lock screen are not available to the crypto
            screen (CryptKeeper) at boot. We duplicate the ones that
            CryptKeeper needs to the crypto key/value store when they are
            modified (see LockPatternUtils).
            However, prior to encryption, the crypto key/value store is not
            persisted across reboots, thus modified settings are lost to
            CryptKeeper.
            In order to make sure CryptKeeper had the correct settings after
            first encrypting, we thus need to rewrite them, which ensures the
            crypto key/value store is up to date. On encryption, this store
            is then persisted, and the settings will be there on future
            reboots.
          */

          // 1. The owner info.
          LockPatternUtils utils = new LockPatternUtils(getActivity());
          utils.setVisiblePatternEnabled(utils.isVisiblePatternEnabled());
          if (utils.isOwnerInfoEnabled()) {
            utils.setOwnerInfo(utils.getOwnerInfo(UserHandle.USER_OWNER), UserHandle.USER_OWNER);
          }
          Intent intent = new Intent(getActivity(), Blank.class);
          intent.putExtras(getArguments());
          startActivity(intent);

          // 2. The system locale.
          try {
            IBinder service = ServiceManager.getService("mount");
            IMountService mountService = IMountService.Stub.asInterface(service);
            mountService.setField("SystemLocale", Locale.getDefault().toLanguageTag());
          } catch (Exception e) {
            Log.e(TAG, "Error storing locale for decryption UI", e);
          }
        }
  /**
   * Makes sure we handle the shutdown gracefully. Shuts off power regardless of radio and bluetooth
   * state if the alloted time has passed.
   */
  public void run() {
    BroadcastReceiver br =
        new BroadcastReceiver() {
          @Override
          public void onReceive(Context context, Intent intent) {
            // We don't allow apps to cancel this, so ignore the result.
            actionDone();
          }
        };

    /*
     * Write a system property in case the system_server reboots before we
     * get to the actual hardware restart. If that happens, we'll retry at
     * the beginning of the SystemServer startup.
     */
    {
      String reason = (mReboot ? "1" : "0") + (mRebootReason != null ? mRebootReason : "");
      SystemProperties.set(SHUTDOWN_ACTION_PROPERTY, reason);
    }

    /*
     * If we are rebooting into safe mode, write a system property
     * indicating so.
     */
    if (mRebootSafeMode) {
      SystemProperties.set(REBOOT_SAFEMODE_PROPERTY, "1");
    }

    Log.i(TAG, "Sending shutdown broadcast...");

    // First send the high-level shut down broadcast.
    mActionDone = false;
    mContext.sendOrderedBroadcastAsUser(
        new Intent(Intent.ACTION_SHUTDOWN), UserHandle.ALL, null, br, mHandler, 0, null, null);

    final long endTime = SystemClock.elapsedRealtime() + MAX_BROADCAST_TIME;
    synchronized (mActionDoneSync) {
      while (!mActionDone) {
        long delay = endTime - SystemClock.elapsedRealtime();
        if (delay <= 0) {
          Log.w(TAG, "Shutdown broadcast timed out");
          break;
        }
        try {
          mActionDoneSync.wait(delay);
        } catch (InterruptedException e) {
        }
      }
    }

    Log.i(TAG, "Shutting down activity manager...");

    final IActivityManager am =
        ActivityManagerNative.asInterface(ServiceManager.checkService("activity"));
    if (am != null) {
      try {
        am.shutdown(MAX_BROADCAST_TIME);
      } catch (RemoteException e) {
      }
    }

    // Shutdown radios.
    shutdownRadios(MAX_RADIO_WAIT_TIME);

    // Shutdown MountService to ensure media is in a safe state
    IMountShutdownObserver observer =
        new IMountShutdownObserver.Stub() {
          public void onShutDownComplete(int statusCode) throws RemoteException {
            Log.w(TAG, "Result code " + statusCode + " from MountService.shutdown");
            actionDone();
          }
        };

    Log.i(TAG, "Shutting down MountService");

    // Set initial variables and time out time.
    mActionDone = false;
    final long endShutTime = SystemClock.elapsedRealtime() + MAX_SHUTDOWN_WAIT_TIME;
    synchronized (mActionDoneSync) {
      try {
        final IMountService mount =
            IMountService.Stub.asInterface(ServiceManager.checkService("mount"));
        if (mount != null) {
          mount.shutdown(observer);
        } else {
          Log.w(TAG, "MountService unavailable for shutdown");
        }
      } catch (Exception e) {
        Log.e(TAG, "Exception during MountService shutdown", e);
      }
      while (!mActionDone) {
        long delay = endShutTime - SystemClock.elapsedRealtime();
        if (delay <= 0) {
          Log.w(TAG, "Shutdown wait timed out");
          break;
        }
        try {
          mActionDoneSync.wait(delay);
        } catch (InterruptedException e) {
        }
      }
    }

    rebootOrShutdown(mReboot, mRebootReason);
  }
  /** Starts a miscellaneous grab bag of stuff that has yet to be refactored and organized. */
  private void startOtherServices() {
    final Context context = mSystemContext;
    AccountManagerService accountManager = null;
    ContentService contentService = null;
    VibratorService vibrator = null;
    IAlarmManager alarm = null;
    IMountService mountService = null;
    NetworkManagementService networkManagement = null;
    NetworkStatsService networkStats = null;
    NetworkPolicyManagerService networkPolicy = null;
    ConnectivityService connectivity = null;
    NetworkScoreService networkScore = null;
    NsdService serviceDiscovery = null;
    WindowManagerService wm = null;
    BluetoothManagerService bluetooth = null;
    UsbService usb = null;
    SerialService serial = null;
    NetworkTimeUpdateService networkTimeUpdater = null;
    CommonTimeManagementService commonTimeMgmtService = null;
    InputManagerService inputManager = null;
    TelephonyRegistry telephonyRegistry = null;
    ConsumerIrService consumerIr = null;
    AudioService audioService = null;
    MmsServiceBroker mmsService = null;
    EntropyMixer entropyMixer = null;
    CameraService cameraService = null;

    boolean disableStorage = SystemProperties.getBoolean("config.disable_storage", false);
    boolean disableBluetooth = SystemProperties.getBoolean("config.disable_bluetooth", false);
    boolean disableLocation = SystemProperties.getBoolean("config.disable_location", false);
    boolean disableSystemUI = SystemProperties.getBoolean("config.disable_systemui", false);
    boolean disableNonCoreServices = SystemProperties.getBoolean("config.disable_noncore", false);
    boolean disableNetwork = SystemProperties.getBoolean("config.disable_network", false);
    boolean disableNetworkTime = SystemProperties.getBoolean("config.disable_networktime", false);
    boolean isEmulator = SystemProperties.get("ro.kernel.qemu").equals("1");

    try {
      Slog.i(TAG, "Reading configuration...");
      SystemConfig.getInstance();

      Slog.i(TAG, "Scheduling Policy");
      ServiceManager.addService("scheduling_policy", new SchedulingPolicyService());

      mSystemServiceManager.startService(TelecomLoaderService.class);

      Slog.i(TAG, "Telephony Registry");
      telephonyRegistry = new TelephonyRegistry(context);
      ServiceManager.addService("telephony.registry", telephonyRegistry);

      Slog.i(TAG, "Entropy Mixer");
      entropyMixer = new EntropyMixer(context);

      mContentResolver = context.getContentResolver();

      Slog.i(TAG, "Camera Service");
      mSystemServiceManager.startService(CameraService.class);

      // The AccountManager must come before the ContentService
      try {
        // TODO: seems like this should be disable-able, but req'd by ContentService
        Slog.i(TAG, "Account Manager");
        accountManager = new AccountManagerService(context);
        ServiceManager.addService(Context.ACCOUNT_SERVICE, accountManager);
      } catch (Throwable e) {
        Slog.e(TAG, "Failure starting Account Manager", e);
      }

      Slog.i(TAG, "Content Manager");
      contentService =
          ContentService.main(context, mFactoryTestMode == FactoryTest.FACTORY_TEST_LOW_LEVEL);

      Slog.i(TAG, "System Content Providers");
      mActivityManagerService.installSystemProviders();

      Slog.i(TAG, "Vibrator Service");
      vibrator = new VibratorService(context);
      ServiceManager.addService("vibrator", vibrator);

      Slog.i(TAG, "Consumer IR Service");
      consumerIr = new ConsumerIrService(context);
      ServiceManager.addService(Context.CONSUMER_IR_SERVICE, consumerIr);

      mSystemServiceManager.startService(AlarmManagerService.class);
      alarm = IAlarmManager.Stub.asInterface(ServiceManager.getService(Context.ALARM_SERVICE));

      Slog.i(TAG, "Init Watchdog");
      final Watchdog watchdog = Watchdog.getInstance();
      watchdog.init(context, mActivityManagerService);

      Slog.i(TAG, "Input Manager");
      inputManager = new InputManagerService(context);

      Slog.i(TAG, "Window Manager");
      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);

      mActivityManagerService.setWindowManager(wm);

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

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

      // Skip Bluetooth if we have an emulator kernel
      // TODO: Use a more reliable check to see if this product should
      // support Bluetooth - see bug 988521
      if (isEmulator) {
        Slog.i(TAG, "No Bluetooh Service (emulator)");
      } else if (mFactoryTestMode == FactoryTest.FACTORY_TEST_LOW_LEVEL) {
        Slog.i(TAG, "No Bluetooth Service (factory test)");
      } else if (!context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_BLUETOOTH)) {
        Slog.i(TAG, "No Bluetooth Service (Bluetooth Hardware Not Present)");
      } else if (disableBluetooth) {
        Slog.i(TAG, "Bluetooth Service disabled by config");
      } else {
        Slog.i(TAG, "Bluetooth Manager Service");
        bluetooth = new BluetoothManagerService(context);
        ServiceManager.addService(BluetoothAdapter.BLUETOOTH_MANAGER_SERVICE, bluetooth);
      }
    } catch (RuntimeException e) {
      Slog.e("System", "******************************************");
      Slog.e("System", "************ Failure starting core service", e);
    }

    StatusBarManagerService statusBar = null;
    INotificationManager notification = null;
    InputMethodManagerService imm = null;
    WallpaperManagerService wallpaper = null;
    LocationManagerService location = null;
    CountryDetectorService countryDetector = null;
    TextServicesManagerService tsms = null;
    LockSettingsService lockSettings = null;
    AssetAtlasService atlas = null;
    MediaRouterService mediaRouter = null;

    // Bring up services needed for UI.
    if (mFactoryTestMode != FactoryTest.FACTORY_TEST_LOW_LEVEL) {
      try {
        Slog.i(TAG, "Input Method Service");
        imm = new InputMethodManagerService(context, wm);
        ServiceManager.addService(Context.INPUT_METHOD_SERVICE, imm);
      } catch (Throwable e) {
        reportWtf("starting Input Manager Service", e);
      }

      try {
        Slog.i(TAG, "Accessibility Manager");
        ServiceManager.addService(
            Context.ACCESSIBILITY_SERVICE, new AccessibilityManagerService(context));
      } catch (Throwable e) {
        reportWtf("starting Accessibility Manager", e);
      }
    }

    try {
      wm.displayReady();
    } catch (Throwable e) {
      reportWtf("making display ready", e);
    }

    if (mFactoryTestMode != FactoryTest.FACTORY_TEST_LOW_LEVEL) {
      if (!disableStorage && !"0".equals(SystemProperties.get("system_init.startmountservice"))) {
        try {
          /*
           * NotificationManagerService is dependant on MountService,
           * (for media / usb notifications) so we must start MountService first.
           */
          mSystemServiceManager.startService(MOUNT_SERVICE_CLASS);
          mountService = IMountService.Stub.asInterface(ServiceManager.getService("mount"));
        } catch (Throwable e) {
          reportWtf("starting Mount Service", e);
        }
      }
    }

    // We start this here so that we update our configuration to set watch or television
    // as appropriate.
    mSystemServiceManager.startService(UiModeManagerService.class);

    try {
      mPackageManagerService.performBootDexOpt();
    } catch (Throwable e) {
      reportWtf("performing boot dexopt", e);
    }

    try {
      ActivityManagerNative.getDefault()
          .showBootMessage(
              context
                  .getResources()
                  .getText(com.android.internal.R.string.android_upgrading_starting_apps),
              false);
    } catch (RemoteException e) {
    }

    if (mFactoryTestMode != FactoryTest.FACTORY_TEST_LOW_LEVEL) {
      if (!disableNonCoreServices) {
        try {
          Slog.i(TAG, "LockSettingsService");
          lockSettings = new LockSettingsService(context);
          ServiceManager.addService("lock_settings", lockSettings);
        } catch (Throwable e) {
          reportWtf("starting LockSettingsService service", e);
        }

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

        mSystemServiceManager.startService(DeviceIdleController.class);

        // Always start the Device Policy Manager, so that the API is compatible with
        // API8.
        mSystemServiceManager.startService(DevicePolicyManagerService.Lifecycle.class);
      }

      if (!disableSystemUI) {
        try {
          Slog.i(TAG, "Status Bar");
          statusBar = new StatusBarManagerService(context, wm);
          ServiceManager.addService(Context.STATUS_BAR_SERVICE, statusBar);
        } catch (Throwable e) {
          reportWtf("starting StatusBarManagerService", e);
        }
      }

      if (!disableNonCoreServices) {
        try {
          Slog.i(TAG, "Clipboard Service");
          ServiceManager.addService(Context.CLIPBOARD_SERVICE, new ClipboardService(context));
        } catch (Throwable e) {
          reportWtf("starting Clipboard Service", e);
        }
      }

      if (!disableNetwork) {
        try {
          Slog.i(TAG, "NetworkManagement Service");
          networkManagement = NetworkManagementService.create(context);
          ServiceManager.addService(Context.NETWORKMANAGEMENT_SERVICE, networkManagement);
        } catch (Throwable e) {
          reportWtf("starting NetworkManagement Service", e);
        }
      }

      if (!disableNonCoreServices) {
        try {
          Slog.i(TAG, "Text Service Manager Service");
          tsms = new TextServicesManagerService(context);
          ServiceManager.addService(Context.TEXT_SERVICES_MANAGER_SERVICE, tsms);
        } catch (Throwable e) {
          reportWtf("starting Text Service Manager Service", e);
        }
      }

      if (!disableNetwork) {
        try {
          Slog.i(TAG, "Network Score Service");
          networkScore = new NetworkScoreService(context);
          ServiceManager.addService(Context.NETWORK_SCORE_SERVICE, networkScore);
        } catch (Throwable e) {
          reportWtf("starting Network Score Service", e);
        }

        try {
          Slog.i(TAG, "NetworkStats Service");
          networkStats = new NetworkStatsService(context, networkManagement, alarm);
          ServiceManager.addService(Context.NETWORK_STATS_SERVICE, networkStats);
        } catch (Throwable e) {
          reportWtf("starting NetworkStats Service", e);
        }

        try {
          Slog.i(TAG, "NetworkPolicy Service");
          networkPolicy =
              new NetworkPolicyManagerService(
                  context,
                  mActivityManagerService,
                  (IPowerManager) ServiceManager.getService(Context.POWER_SERVICE),
                  networkStats,
                  networkManagement);
          ServiceManager.addService(Context.NETWORK_POLICY_SERVICE, networkPolicy);
        } catch (Throwable e) {
          reportWtf("starting NetworkPolicy Service", e);
        }

        mSystemServiceManager.startService(WIFI_P2P_SERVICE_CLASS);
        mSystemServiceManager.startService(WIFI_SERVICE_CLASS);
        mSystemServiceManager.startService("com.android.server.wifi.WifiScanningService");

        mSystemServiceManager.startService("com.android.server.wifi.RttService");

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

        try {
          Slog.i(TAG, "Connectivity Service");
          connectivity =
              new ConnectivityService(context, networkManagement, networkStats, networkPolicy);
          ServiceManager.addService(Context.CONNECTIVITY_SERVICE, connectivity);
          networkStats.bindConnectivityManager(connectivity);
          networkPolicy.bindConnectivityManager(connectivity);
        } catch (Throwable e) {
          reportWtf("starting Connectivity Service", e);
        }

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

      if (!disableNonCoreServices) {
        try {
          Slog.i(TAG, "UpdateLock Service");
          ServiceManager.addService(Context.UPDATE_LOCK_SERVICE, new UpdateLockService(context));
        } catch (Throwable e) {
          reportWtf("starting UpdateLockService", e);
        }
      }

      /*
       * MountService has a few dependencies: Notification Manager and
       * AppWidget Provider. Make sure MountService is completely started
       * first before continuing.
       */
      if (mountService != null && !mOnlyCore) {
        try {
          mountService.waitForAsecScan();
        } catch (RemoteException ignored) {
        }
      }

      try {
        if (accountManager != null) accountManager.systemReady();
      } catch (Throwable e) {
        reportWtf("making Account Manager Service ready", e);
      }

      try {
        if (contentService != null) contentService.systemReady();
      } catch (Throwable e) {
        reportWtf("making Content Service ready", e);
      }

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

      mSystemServiceManager.startService(DeviceStorageMonitorService.class);

      if (!disableLocation) {
        try {
          Slog.i(TAG, "Location Manager");
          location = new LocationManagerService(context);
          ServiceManager.addService(Context.LOCATION_SERVICE, location);
        } catch (Throwable e) {
          reportWtf("starting Location Manager", e);
        }

        try {
          Slog.i(TAG, "Country Detector");
          countryDetector = new CountryDetectorService(context);
          ServiceManager.addService(Context.COUNTRY_DETECTOR, countryDetector);
        } catch (Throwable e) {
          reportWtf("starting Country Detector", e);
        }
      }

      if (!disableNonCoreServices) {
        try {
          Slog.i(TAG, "Search Service");
          ServiceManager.addService(Context.SEARCH_SERVICE, new SearchManagerService(context));
        } catch (Throwable e) {
          reportWtf("starting Search Service", e);
        }
      }

      try {
        Slog.i(TAG, "DropBox Service");
        ServiceManager.addService(
            Context.DROPBOX_SERVICE,
            new DropBoxManagerService(context, new File("/data/system/dropbox")));
      } catch (Throwable e) {
        reportWtf("starting DropBoxManagerService", e);
      }

      if (!disableNonCoreServices
          && context.getResources().getBoolean(R.bool.config_enableWallpaperService)) {
        try {
          Slog.i(TAG, "Wallpaper Service");
          wallpaper = new WallpaperManagerService(context);
          ServiceManager.addService(Context.WALLPAPER_SERVICE, wallpaper);
        } catch (Throwable e) {
          reportWtf("starting Wallpaper Service", e);
        }
      }

      try {
        Slog.i(TAG, "Audio Service");
        audioService = new AudioService(context);
        ServiceManager.addService(Context.AUDIO_SERVICE, audioService);
      } catch (Throwable e) {
        reportWtf("starting Audio Service", e);
      }

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

      try {
        Slog.i(TAG, "Wired Accessory Manager");
        // Listen for wired headset changes
        inputManager.setWiredAccessoryCallbacks(new WiredAccessoryManager(context, inputManager));
      } catch (Throwable e) {
        reportWtf("starting WiredAccessoryManager", 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)) {
          // Manage USB host and device support
          mSystemServiceManager.startService(USB_SERVICE_CLASS);
        }

        try {
          Slog.i(TAG, "Serial Service");
          // Serial port support
          serial = new SerialService(context);
          ServiceManager.addService(Context.SERIAL_SERVICE, serial);
        } catch (Throwable e) {
          Slog.e(TAG, "Failure starting SerialService", e);
        }
      }

      mSystemServiceManager.startService(TwilightService.class);

      mSystemServiceManager.startService(JobSchedulerService.class);

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

        if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_APP_WIDGETS)) {
          mSystemServiceManager.startService(APPWIDGET_SERVICE_CLASS);
        }

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

      try {
        Slog.i(TAG, "DiskStats Service");
        ServiceManager.addService("diskstats", new DiskStatsService(context));
      } catch (Throwable e) {
        reportWtf("starting DiskStats Service", e);
      }

      try {
        // need to add this service even if SamplingProfilerIntegration.isEnabled()
        // is false, because it is this service that detects system property change and
        // turns on SamplingProfilerIntegration. Plus, when sampling profiler doesn't work,
        // there is little overhead for running this service.
        Slog.i(TAG, "SamplingProfiler Service");
        ServiceManager.addService("samplingprofiler", new SamplingProfilerService(context));
      } catch (Throwable e) {
        reportWtf("starting SamplingProfiler Service", e);
      }

      if (!disableNetwork && !disableNetworkTime) {
        try {
          Slog.i(TAG, "NetworkTimeUpdateService");
          networkTimeUpdater = new NetworkTimeUpdateService(context);
        } catch (Throwable e) {
          reportWtf("starting NetworkTimeUpdate service", e);
        }
      }

      try {
        Slog.i(TAG, "CommonTimeManagementService");
        commonTimeMgmtService = new CommonTimeManagementService(context);
        ServiceManager.addService("commontime_management", commonTimeMgmtService);
      } catch (Throwable e) {
        reportWtf("starting CommonTimeManagementService service", e);
      }

      if (!disableNetwork) {
        try {
          Slog.i(TAG, "CertBlacklister");
          CertBlacklister blacklister = new CertBlacklister(context);
        } catch (Throwable e) {
          reportWtf("starting CertBlacklister", e);
        }
      }

      if (!disableNonCoreServices) {
        // Dreams (interactive idle-time views, a/k/a screen savers, and doze mode)
        mSystemServiceManager.startService(DreamManagerService.class);
      }

      if (!disableNonCoreServices) {
        try {
          Slog.i(TAG, "Assets Atlas Service");
          atlas = new AssetAtlasService(context);
          ServiceManager.addService(AssetAtlasService.ASSET_ATLAS_SERVICE, atlas);
        } catch (Throwable e) {
          reportWtf("starting AssetAtlasService", 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 (!disableNonCoreServices) {
        try {
          Slog.i(TAG, "Media Router Service");
          mediaRouter = new MediaRouterService(context);
          ServiceManager.addService(Context.MEDIA_ROUTER_SERVICE, mediaRouter);
        } catch (Throwable e) {
          reportWtf("starting MediaRouterService", e);
        }

        mSystemServiceManager.startService(TrustManagerService.class);

        mSystemServiceManager.startService(FingerprintService.class);

        try {
          Slog.i(TAG, "BackgroundDexOptService");
          BackgroundDexOptService.schedule(context);
        } catch (Throwable e) {
          reportWtf("starting BackgroundDexOptService", e);
        }
      }

      mSystemServiceManager.startService(LauncherAppsService.class);
    }

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

    // Before things start rolling, be sure we have decided whether
    // we are in safe mode.
    final boolean safeMode = wm.detectSafeMode();
    if (safeMode) {
      mActivityManagerService.enterSafeMode();
      // Disable the JIT for the system_server process
      VMRuntime.getRuntime().disableJitCompilation();
    } else {
      // Enable the JIT for the system_server process
      VMRuntime.getRuntime().startJitCompilation();
    }

    // MMS service broker
    mmsService = mSystemServiceManager.startService(MmsServiceBroker.class);

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

    try {
      vibrator.systemReady();
    } catch (Throwable e) {
      reportWtf("making Vibrator Service ready", e);
    }

    if (lockSettings != null) {
      try {
        lockSettings.systemReady();
      } catch (Throwable e) {
        reportWtf("making Lock Settings Service ready", e);
      }
    }

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

    mSystemServiceManager.startBootPhase(SystemService.PHASE_SYSTEM_SERVICES_READY);

    try {
      wm.systemReady();
    } catch (Throwable e) {
      reportWtf("making Window Manager Service ready", e);
    }

    if (safeMode) {
      mActivityManagerService.showSafeModeOverlay();
    }

    // Update the configuration for this context by hand, because we're going
    // to start using it before the config change done in wm.systemReady() will
    // propagate to it.
    Configuration config = wm.computeNewConfiguration();
    DisplayMetrics metrics = new DisplayMetrics();
    WindowManager w = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
    w.getDefaultDisplay().getMetrics(metrics);
    context.getResources().updateConfiguration(config, metrics);

    // The system context's theme may be configuration-dependent.
    final Theme systemTheme = context.getTheme();
    if (systemTheme.getChangingConfigurations() != 0) {
      systemTheme.rebase();
    }

    try {
      // TODO: use boot phase
      mPowerManagerService.systemReady(mActivityManagerService.getAppOpsService());
    } catch (Throwable e) {
      reportWtf("making Power Manager Service ready", e);
    }

    try {
      mPackageManagerService.systemReady();
    } catch (Throwable e) {
      reportWtf("making Package Manager Service ready", e);
    }

    try {
      // TODO: use boot phase and communicate these flags some other way
      mDisplayManagerService.systemReady(safeMode, mOnlyCore);
    } catch (Throwable e) {
      reportWtf("making Display Manager Service ready", e);
    }

    // These are needed to propagate to the runnable below.
    final NetworkManagementService networkManagementF = networkManagement;
    final NetworkStatsService networkStatsF = networkStats;
    final NetworkPolicyManagerService networkPolicyF = networkPolicy;
    final ConnectivityService connectivityF = connectivity;
    final NetworkScoreService networkScoreF = networkScore;
    final WallpaperManagerService wallpaperF = wallpaper;
    final InputMethodManagerService immF = imm;
    final LocationManagerService locationF = location;
    final CountryDetectorService countryDetectorF = countryDetector;
    final NetworkTimeUpdateService networkTimeUpdaterF = networkTimeUpdater;
    final CommonTimeManagementService commonTimeMgmtServiceF = commonTimeMgmtService;
    final TextServicesManagerService textServiceManagerServiceF = tsms;
    final StatusBarManagerService statusBarF = statusBar;
    final AssetAtlasService atlasF = atlas;
    final InputManagerService inputManagerF = inputManager;
    final TelephonyRegistry telephonyRegistryF = telephonyRegistry;
    final MediaRouterService mediaRouterF = mediaRouter;
    final AudioService audioServiceF = audioService;
    final MmsServiceBroker mmsServiceF = mmsService;

    // We now tell the activity manager it is okay to run third party
    // code.  It will call back into us once it has gotten to the state
    // where third party code can really run (but before it has actually
    // started launching the initial applications), for us to complete our
    // initialization.
    mActivityManagerService.systemReady(
        new Runnable() {
          @Override
          public void run() {
            Slog.i(TAG, "Making services ready");
            mSystemServiceManager.startBootPhase(SystemService.PHASE_ACTIVITY_MANAGER_READY);

            try {
              mActivityManagerService.startObservingNativeCrashes();
            } catch (Throwable e) {
              reportWtf("observing native crashes", e);
            }

            Slog.i(TAG, "WebViewFactory preparation");
            WebViewFactory.prepareWebViewInSystemServer();

            try {
              startSystemUi(context);
            } catch (Throwable e) {
              reportWtf("starting System UI", e);
            }
            try {
              if (networkScoreF != null) networkScoreF.systemReady();
            } catch (Throwable e) {
              reportWtf("making Network Score Service ready", e);
            }
            try {
              if (networkManagementF != null) networkManagementF.systemReady();
            } catch (Throwable e) {
              reportWtf("making Network Managment Service ready", e);
            }
            try {
              if (networkStatsF != null) networkStatsF.systemReady();
            } catch (Throwable e) {
              reportWtf("making Network Stats Service ready", e);
            }
            try {
              if (networkPolicyF != null) networkPolicyF.systemReady();
            } catch (Throwable e) {
              reportWtf("making Network Policy Service ready", e);
            }
            try {
              if (connectivityF != null) connectivityF.systemReady();
            } catch (Throwable e) {
              reportWtf("making Connectivity Service ready", e);
            }
            try {
              if (audioServiceF != null) audioServiceF.systemReady();
            } catch (Throwable e) {
              reportWtf("Notifying AudioService running", e);
            }
            Watchdog.getInstance().start();

            // It is now okay to let the various system services start their
            // third party code...
            mSystemServiceManager.startBootPhase(SystemService.PHASE_THIRD_PARTY_APPS_CAN_START);

            try {
              if (wallpaperF != null) wallpaperF.systemRunning();
            } catch (Throwable e) {
              reportWtf("Notifying WallpaperService running", e);
            }
            try {
              if (immF != null) immF.systemRunning(statusBarF);
            } catch (Throwable e) {
              reportWtf("Notifying InputMethodService running", e);
            }
            try {
              if (locationF != null) locationF.systemRunning();
            } catch (Throwable e) {
              reportWtf("Notifying Location Service running", e);
            }
            try {
              if (countryDetectorF != null) countryDetectorF.systemRunning();
            } catch (Throwable e) {
              reportWtf("Notifying CountryDetectorService running", e);
            }
            try {
              if (networkTimeUpdaterF != null) networkTimeUpdaterF.systemRunning();
            } catch (Throwable e) {
              reportWtf("Notifying NetworkTimeService running", e);
            }
            try {
              if (commonTimeMgmtServiceF != null) {
                commonTimeMgmtServiceF.systemRunning();
              }
            } catch (Throwable e) {
              reportWtf("Notifying CommonTimeManagementService running", e);
            }
            try {
              if (textServiceManagerServiceF != null) textServiceManagerServiceF.systemRunning();
            } catch (Throwable e) {
              reportWtf("Notifying TextServicesManagerService running", e);
            }
            try {
              if (atlasF != null) atlasF.systemRunning();
            } catch (Throwable e) {
              reportWtf("Notifying AssetAtlasService running", e);
            }
            try {
              // TODO(BT) Pass parameter to input manager
              if (inputManagerF != null) inputManagerF.systemRunning();
            } catch (Throwable e) {
              reportWtf("Notifying InputManagerService running", e);
            }
            try {
              if (telephonyRegistryF != null) telephonyRegistryF.systemRunning();
            } catch (Throwable e) {
              reportWtf("Notifying TelephonyRegistry running", e);
            }
            try {
              if (mediaRouterF != null) mediaRouterF.systemRunning();
            } catch (Throwable e) {
              reportWtf("Notifying MediaRouterService running", e);
            }

            try {
              if (mmsServiceF != null) mmsServiceF.systemRunning();
            } catch (Throwable e) {
              reportWtf("Notifying MmsService running", e);
            }
          }
        });
  }