private void addOtherUserItem(
     Context context,
     ArrayList<MergedItem> newMergedItems,
     SparseArray<MergedItem> userItems,
     MergedItem newItem) {
   MergedItem userItem = userItems.get(newItem.mUserId);
   boolean first = userItem == null || userItem.mCurSeq != mSequence;
   if (first) {
     UserInfo info = mUm.getUserInfo(newItem.mUserId);
     if (info == null) {
       // The user no longer exists, skip
       return;
     }
     if (mHideManagedProfiles && info.isManagedProfile()) {
       return;
     }
     if (userItem == null) {
       userItem = new MergedItem(newItem.mUserId);
       userItems.put(newItem.mUserId, userItem);
     } else {
       userItem.mChildren.clear();
     }
     userItem.mCurSeq = mSequence;
     userItem.mUser = new UserState();
     userItem.mUser.mInfo = info;
     userItem.mUser.mIcon = Utils.getUserIcon(context, mUm, info);
     userItem.mUser.mLabel = Utils.getUserLabel(context, info);
     newMergedItems.add(userItem);
   }
   userItem.mChildren.add(newItem);
 }
  @Override
  public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    if (savedInstanceState != null) {
      mManageMobilePlanMessage = savedInstanceState.getString(SAVED_MANAGE_MOBILE_PLAN_MSG);
    }
    log("onCreate: mManageMobilePlanMessage=" + mManageMobilePlanMessage);

    mCm = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
    mTm = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
    mPm = getPackageManager();
    mUm = (UserManager) getSystemService(Context.USER_SERVICE);

    addPreferencesFromResource(R.xml.wireless_settings);

    final int myUserId = UserHandle.myUserId();
    final boolean isSecondaryUser = myUserId != UserHandle.USER_OWNER;

    final Activity activity = getActivity();
    mAirplaneModePreference = (SwitchPreference) findPreference(KEY_TOGGLE_AIRPLANE);
    SwitchPreference nfc = (SwitchPreference) findPreference(KEY_TOGGLE_NFC);
    PreferenceScreen androidBeam = (PreferenceScreen) findPreference(KEY_ANDROID_BEAM_SETTINGS);
    SwitchPreference nsd = (SwitchPreference) findPreference(KEY_TOGGLE_NSD);

    mAirplaneModeEnabler = new AirplaneModeEnabler(activity, mAirplaneModePreference);
    mNfcEnabler = new NfcEnabler(activity, nfc, androidBeam);

    mButtonWfc = (PreferenceScreen) findPreference(KEY_WFC_SETTINGS);

    // Remove NSD checkbox by default
    getPreferenceScreen().removePreference(nsd);
    // mNsdEnabler = new NsdEnabler(activity, nsd);

    String toggleable =
        Settings.Global.getString(
            activity.getContentResolver(), Settings.Global.AIRPLANE_MODE_TOGGLEABLE_RADIOS);

    // enable/disable wimax depending on the value in config.xml
    final boolean isWimaxEnabled =
        !isSecondaryUser
            && this.getResources().getBoolean(com.android.internal.R.bool.config_wimaxEnabled);
    if (!isWimaxEnabled || mUm.hasUserRestriction(UserManager.DISALLOW_CONFIG_MOBILE_NETWORKS)) {
      PreferenceScreen root = getPreferenceScreen();
      Preference ps = (Preference) findPreference(KEY_WIMAX_SETTINGS);
      if (ps != null) root.removePreference(ps);
    } else {
      if (toggleable == null
          || !toggleable.contains(Settings.Global.RADIO_WIMAX) && isWimaxEnabled) {
        Preference ps = (Preference) findPreference(KEY_WIMAX_SETTINGS);
        ps.setDependency(KEY_TOGGLE_AIRPLANE);
      }
    }

    // Manually set dependencies for Wifi when not toggleable.
    if (toggleable == null || !toggleable.contains(Settings.Global.RADIO_WIFI)) {
      findPreference(KEY_VPN_SETTINGS).setDependency(KEY_TOGGLE_AIRPLANE);
    }
    // Disable VPN.
    if (isSecondaryUser || mUm.hasUserRestriction(UserManager.DISALLOW_CONFIG_VPN)) {
      removePreference(KEY_VPN_SETTINGS);
    }

    // Manually set dependencies for Bluetooth when not toggleable.
    if (toggleable == null || !toggleable.contains(Settings.Global.RADIO_BLUETOOTH)) {
      // No bluetooth-dependent items in the list. Code kept in case one is added later.
    }

    // Manually set dependencies for NFC when not toggleable.
    if (toggleable == null || !toggleable.contains(Settings.Global.RADIO_NFC)) {
      findPreference(KEY_TOGGLE_NFC).setDependency(KEY_TOGGLE_AIRPLANE);
      findPreference(KEY_ANDROID_BEAM_SETTINGS).setDependency(KEY_TOGGLE_AIRPLANE);
    }

    // Remove NFC if not available
    mNfcAdapter = NfcAdapter.getDefaultAdapter(activity);
    if (mNfcAdapter == null) {
      getPreferenceScreen().removePreference(nfc);
      getPreferenceScreen().removePreference(androidBeam);
      mNfcEnabler = null;
    }

    // Remove Mobile Network Settings and Manage Mobile Plan for secondary users,
    // if it's a wifi-only device, or if the settings are restricted.
    if (isSecondaryUser
        || Utils.isWifiOnly(getActivity())
        || mUm.hasUserRestriction(UserManager.DISALLOW_CONFIG_MOBILE_NETWORKS)) {
      removePreference(KEY_MOBILE_NETWORK_SETTINGS);
      removePreference(KEY_MANAGE_MOBILE_PLAN);
    }
    // Remove Mobile Network Settings and Manage Mobile Plan
    // if config_show_mobile_plan sets false.
    final boolean isMobilePlanEnabled =
        this.getResources().getBoolean(R.bool.config_show_mobile_plan);
    if (!isMobilePlanEnabled) {
      Preference pref = findPreference(KEY_MANAGE_MOBILE_PLAN);
      if (pref != null) {
        removePreference(KEY_MANAGE_MOBILE_PLAN);
      }
    }

    // Remove Airplane Mode settings if it's a stationary device such as a TV.
    if (mPm.hasSystemFeature(PackageManager.FEATURE_TELEVISION)) {
      removePreference(KEY_TOGGLE_AIRPLANE);
    }

    // Enable Proxy selector settings if allowed.
    Preference mGlobalProxy = findPreference(KEY_PROXY_SETTINGS);
    final DevicePolicyManager mDPM =
        (DevicePolicyManager) activity.getSystemService(Context.DEVICE_POLICY_SERVICE);
    // proxy UI disabled until we have better app support
    getPreferenceScreen().removePreference(mGlobalProxy);
    mGlobalProxy.setEnabled(mDPM.getGlobalProxyAdmin() == null);

    // Disable Tethering if it's not allowed or if it's a wifi-only device
    final ConnectivityManager cm =
        (ConnectivityManager) activity.getSystemService(Context.CONNECTIVITY_SERVICE);
    if (isSecondaryUser
        || !cm.isTetheringSupported()
        || mUm.hasUserRestriction(UserManager.DISALLOW_CONFIG_TETHERING)) {
      getPreferenceScreen().removePreference(findPreference(KEY_TETHER_SETTINGS));
    } else {
      Preference p = findPreference(KEY_TETHER_SETTINGS);
      p.setTitle(com.android.settingslib.Utils.getTetheringLabel(cm));

      // Grey out if provisioning is not available.
      p.setEnabled(!TetherSettings.isProvisioningNeededButUnavailable(getActivity()));
    }

    // Enable link to CMAS app settings depending on the value in config.xml.
    boolean isCellBroadcastAppLinkEnabled =
        this.getResources().getBoolean(com.android.internal.R.bool.config_cellBroadcastAppLinks);
    try {
      if (isCellBroadcastAppLinkEnabled) {
        if (mPm.getApplicationEnabledSetting("com.android.cellbroadcastreceiver")
            == PackageManager.COMPONENT_ENABLED_STATE_DISABLED) {
          isCellBroadcastAppLinkEnabled = false; // CMAS app disabled
        }
      }
    } catch (IllegalArgumentException ignored) {
      isCellBroadcastAppLinkEnabled = false; // CMAS app not installed
    }
    if (isSecondaryUser
        || !isCellBroadcastAppLinkEnabled
        || mUm.hasUserRestriction(UserManager.DISALLOW_CONFIG_CELL_BROADCASTS)) {
      PreferenceScreen root = getPreferenceScreen();
      Preference ps = findPreference(KEY_CELL_BROADCAST_SETTINGS);
      if (ps != null) root.removePreference(ps);
    }
  }