src/com/android/settings/WirelessSettings.java

   1 /*
   2  * Copyright (C) 2009 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
  17 package com.android.settings;
  18
  19
  20 import android.app.Activity;
  21 import android.app.AlertDialog;
  22 import android.app.Dialog;
  23 import android.app.admin.DevicePolicyManager;
  24 import android.content.ActivityNotFoundException;
  25 import android.content.ComponentName;
  26 import android.content.Context;
  27 import android.content.DialogInterface;
  28 import android.content.Intent;
  29 import android.content.pm.PackageManager;
  30 import android.content.res.Resources;
  31 import android.net.ConnectivityManager;
  32 import android.net.NetworkInfo;
  33 import android.net.Uri;
  34 import android.nfc.NfcAdapter;
  35 import android.nfc.NfcManager;
  36 import android.os.Bundle;
  37 import android.os.SystemProperties;
  38 import android.os.UserHandle;
  39 import android.os.UserManager;
  40 import android.preference.Preference;
  41 import android.preference.Preference.OnPreferenceChangeListener;
  42 import android.preference.PreferenceScreen;
  43 import android.preference.SwitchPreference;
  44 import android.provider.SearchIndexableResource;
  45 import android.provider.Settings;
  46 import android.telephony.TelephonyManager;
  47 import android.text.TextUtils;
  48 import android.util.Log;
  49
  50 import com.android.internal.telephony.SmsApplication;
  51 import com.android.internal.telephony.SmsApplication.SmsApplicationData;
  52 import com.android.internal.telephony.TelephonyIntents;
  53 import com.android.internal.telephony.TelephonyProperties;
  54 import com.android.settings.nfc.NfcEnabler;
  55 import com.android.settings.search.BaseSearchIndexProvider;
  56 import com.android.settings.search.Indexable;
  57
  58 import java.util.ArrayList;
  59 import java.util.Arrays;
  60 import java.util.Collection;
  61 import java.util.List;
  62
  63 public class WirelessSettings extends SettingsPreferenceFragment
  64         implements OnPreferenceChangeListener, Indexable {
  65     private static final String TAG = "WirelessSettings";
  66
  67     private static final String KEY_TOGGLE_AIRPLANE = "toggle_airplane";
  68     private static final String KEY_TOGGLE_NFC = "toggle_nfc";
  69     private static final String KEY_WIMAX_SETTINGS = "wimax_settings";
  70     private static final String KEY_ANDROID_BEAM_SETTINGS = "android_beam_settings";
  71     private static final String KEY_VPN_SETTINGS = "vpn_settings";
  72     private static final String KEY_TETHER_SETTINGS = "tether_settings";
  73     private static final String KEY_PROXY_SETTINGS = "proxy_settings";
  74     private static final String KEY_MOBILE_NETWORK_SETTINGS = "mobile_network_settings";
  75     private static final String KEY_MANAGE_MOBILE_PLAN = "manage_mobile_plan";
  76     private static final String KEY_SMS_APPLICATION = "sms_application";
  77     private static final String KEY_TOGGLE_NSD = "toggle_nsd"; //network service discovery
  78     private static final String KEY_CELL_BROADCAST_SETTINGS = "cell_broadcast_settings";
  79
  80     public static final String EXIT_ECM_RESULT = "exit_ecm_result";
  81     public static final int REQUEST_CODE_EXIT_ECM = 1;
  82
  83     private AirplaneModeEnabler mAirplaneModeEnabler;
  84     private SwitchPreference mAirplaneModePreference;
  85     private NfcEnabler mNfcEnabler;
  86     private NfcAdapter mNfcAdapter;
  87     private NsdEnabler mNsdEnabler;
  88
  89     private ConnectivityManager mCm;
  90     private TelephonyManager mTm;
  91     private PackageManager mPm;
  92     private UserManager mUm;
  93
  94     private static final int MANAGE_MOBILE_PLAN_DIALOG_ID = 1;
  95     private static final String SAVED_MANAGE_MOBILE_PLAN_MSG = "mManageMobilePlanMessage";
  96
  97     private AppListPreference mSmsApplicationPreference;
  98
  99     /**
 100      * Invoked on each preference click in this hierarchy, overrides
 101      * PreferenceFragment's implementation.  Used to make sure we track the
 102      * preference click events.
 103      */
 104     @Override
 105     public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) {
 106         log("onPreferenceTreeClick: preference=" + preference);
 107         if (preference == mAirplaneModePreference && Boolean.parseBoolean(
 108                 SystemProperties.get(TelephonyProperties.PROPERTY_INECM_MODE))) {
 109             // In ECM mode launch ECM app dialog
 110             startActivityForResult(
 111                 new Intent(TelephonyIntents.ACTION_SHOW_NOTICE_ECM_BLOCK_OTHERS, null),
 112                 REQUEST_CODE_EXIT_ECM);
 113             return true;
 114         } else if (preference == findPreference(KEY_MANAGE_MOBILE_PLAN)) {
 115             onManageMobilePlanClick();
 116         }
 117         // Let the intents be launched by the Preference manager
 118         return super.onPreferenceTreeClick(preferenceScreen, preference);
 119     }
 120
 121     private String mManageMobilePlanMessage;
 122     public void onManageMobilePlanClick() {
 123         log("onManageMobilePlanClick:");
 124         mManageMobilePlanMessage = null;
 125         Resources resources = getActivity().getResources();
 126
 127         NetworkInfo ni = mCm.getProvisioningOrActiveNetworkInfo();
 128         if (mTm.hasIccCard() && (ni != null)) {
 129             // Check for carrier apps that can handle provisioning first
 130             Intent provisioningIntent = new Intent(TelephonyIntents.ACTION_CARRIER_SETUP);
 131             List<String> carrierPackages =
 132                     mTm.getCarrierPackageNamesForIntent(provisioningIntent);
 133             if (carrierPackages != null && !carrierPackages.isEmpty()) {
 134                 if (carrierPackages.size() != 1) {
 135                     Log.w(TAG, "Multiple matching carrier apps found, launching the first.");
 136                 }
 137                 provisioningIntent.setPackage(carrierPackages.get(0));
 138                 startActivity(provisioningIntent);
 139                 return;
 140             }
 141
 142             // Get provisioning URL
 143             String url = mCm.getMobileProvisioningUrl();
 144             if (!TextUtils.isEmpty(url)) {
 145                 Intent intent = Intent.makeMainSelectorActivity(Intent.ACTION_MAIN,
 146                         Intent.CATEGORY_APP_BROWSER);
 147                 intent.setData(Uri.parse(url));
 148                 intent.setFlags(Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT |
 149                         Intent.FLAG_ACTIVITY_NEW_TASK);
 150                 try {
 151                     startActivity(intent);
 152                 } catch (ActivityNotFoundException e) {
 153                     Log.w(TAG, "onManageMobilePlanClick: startActivity failed" + e);
 154                 }
 155             } else {
 156                 // No provisioning URL
 157                 String operatorName = mTm.getSimOperatorName();
 158                 if (TextUtils.isEmpty(operatorName)) {
 159                     // Use NetworkOperatorName as second choice in case there is no
 160                     // SPN (Service Provider Name on the SIM). Such as with T-mobile.
 161                     operatorName = mTm.getNetworkOperatorName();
 162                     if (TextUtils.isEmpty(operatorName)) {
 163                         mManageMobilePlanMessage = resources.getString(
 164                                 R.string.mobile_unknown_sim_operator);
 165                     } else {
 166                         mManageMobilePlanMessage = resources.getString(
 167                                 R.string.mobile_no_provisioning_url, operatorName);
 168                     }
 169                 } else {
 170                     mManageMobilePlanMessage = resources.getString(
 171                             R.string.mobile_no_provisioning_url, operatorName);
 172                 }
 173             }
 174         } else if (mTm.hasIccCard() == false) {
 175             // No sim card
 176             mManageMobilePlanMessage = resources.getString(R.string.mobile_insert_sim_card);
 177         } else {
 178             // NetworkInfo is null, there is no connection
 179             mManageMobilePlanMessage = resources.getString(R.string.mobile_connect_to_internet);
 180         }
 181         if (!TextUtils.isEmpty(mManageMobilePlanMessage)) {
 182             log("onManageMobilePlanClick: message=" + mManageMobilePlanMessage);
 183             showDialog(MANAGE_MOBILE_PLAN_DIALOG_ID);
 184         }
 185     }
 186
 187     private void initSmsApplicationSetting() {
 188         log("initSmsApplicationSetting:");
 189         Collection<SmsApplicationData> smsApplications =
 190                 SmsApplication.getApplicationCollection(getActivity());
 191
 192         // If the list is empty the dialog will be empty, but we will not crash.
 193         int count = smsApplications.size();
 194         String[] packageNames = new String[count];
 195         int i = 0;
 196         for (SmsApplicationData smsApplicationData : smsApplications) {
 197             packageNames[i] = smsApplicationData.mPackageName;
 198             i++;
 199         }
 200         String defaultPackageName = null;
 201         ComponentName appName = SmsApplication.getDefaultSmsApplication(getActivity(), true);
 202         if (appName != null) {
 203             defaultPackageName = appName.getPackageName();
 204         }
 205         mSmsApplicationPreference.setPackageNames(packageNames, defaultPackageName);
 206     }
 207
 208     @Override
 209     public Dialog onCreateDialog(int dialogId) {
 210         log("onCreateDialog: dialogId=" + dialogId);
 211         switch (dialogId) {
 212             case MANAGE_MOBILE_PLAN_DIALOG_ID:
 213                 return new AlertDialog.Builder(getActivity())
 214                             .setMessage(mManageMobilePlanMessage)
 215                             .setCancelable(false)
 216                             .setPositiveButton(com.android.internal.R.string.ok,
 217                                     new DialogInterface.OnClickListener() {
 218                                 @Override
 219                                 public void onClick(DialogInterface dialog, int id) {
 220                                     log("MANAGE_MOBILE_PLAN_DIALOG.onClickListener id=" + id);
 221                                     mManageMobilePlanMessage = null;
 222                                 }
 223                             })
 224                             .create();
 225         }
 226         return super.onCreateDialog(dialogId);
 227     }
 228
 229     private void log(String s) {
 230         Log.d(TAG, s);
 231     }
 232
 233     public static boolean isRadioAllowed(Context context, String type) {
 234         if (!AirplaneModeEnabler.isAirplaneModeOn(context)) {
 235             return true;
 236         }
 237         // Here we use the same logic in onCreate().
 238         String toggleable = Settings.Global.getString(context.getContentResolver(),
 239                 Settings.Global.AIRPLANE_MODE_TOGGLEABLE_RADIOS);
 240         return toggleable != null && toggleable.contains(type);
 241     }
 242
 243     private boolean isSmsSupported() {
 244         // Some tablet has sim card but could not do telephony operations. Skip those.
 245         return mTm.isSmsCapable();
 246     }
 247
 248     @Override
 249     public void onCreate(Bundle savedInstanceState) {
 250         super.onCreate(savedInstanceState);
 251         if (savedInstanceState != null) {
 252             mManageMobilePlanMessage = savedInstanceState.getString(SAVED_MANAGE_MOBILE_PLAN_MSG);
 253         }
 254         log("onCreate: mManageMobilePlanMessage=" + mManageMobilePlanMessage);
 255
 256         mCm = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
 257         mTm = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
 258         mPm = getPackageManager();
 259         mUm = (UserManager) getSystemService(Context.USER_SERVICE);
 260
 261         addPreferencesFromResource(R.xml.wireless_settings);
 262
 263         final int myUserId = UserHandle.myUserId();
 264         final boolean isSecondaryUser = myUserId != UserHandle.USER_OWNER;
 265         final boolean isRestrictedUser = mUm.getUserInfo(myUserId).isRestricted();
 266
 267         final Activity activity = getActivity();
 268         mAirplaneModePreference = (SwitchPreference) findPreference(KEY_TOGGLE_AIRPLANE);
 269         SwitchPreference nfc = (SwitchPreference) findPreference(KEY_TOGGLE_NFC);
 270         PreferenceScreen androidBeam = (PreferenceScreen) findPreference(KEY_ANDROID_BEAM_SETTINGS);
 271         SwitchPreference nsd = (SwitchPreference) findPreference(KEY_TOGGLE_NSD);
 272
 273         mAirplaneModeEnabler = new AirplaneModeEnabler(activity, mAirplaneModePreference);
 274         mNfcEnabler = new NfcEnabler(activity, nfc, androidBeam);
 275
 276         mSmsApplicationPreference = (AppListPreference) findPreference(KEY_SMS_APPLICATION);
 277         // Restricted users cannot currently read/write SMS.
 278         if (isRestrictedUser) {
 279             removePreference(KEY_SMS_APPLICATION);
 280         } else {
 281             mSmsApplicationPreference.setOnPreferenceChangeListener(this);
 282             initSmsApplicationSetting();
 283         }
 284
 285         // Remove NSD checkbox by default
 286         getPreferenceScreen().removePreference(nsd);
 287         //mNsdEnabler = new NsdEnabler(activity, nsd);
 288
 289         String toggleable = Settings.Global.getString(activity.getContentResolver(),
 290                 Settings.Global.AIRPLANE_MODE_TOGGLEABLE_RADIOS);
 291
 292         //enable/disable wimax depending on the value in config.xml
 293         final boolean isWimaxEnabled = !isSecondaryUser && this.getResources().getBoolean(
 294                 com.android.internal.R.bool.config_wimaxEnabled);
 295         if (!isWimaxEnabled
 296                 || mUm.hasUserRestriction(UserManager.DISALLOW_CONFIG_MOBILE_NETWORKS)) {
 297             PreferenceScreen root = getPreferenceScreen();
 298             Preference ps = (Preference) findPreference(KEY_WIMAX_SETTINGS);
 299             if (ps != null) root.removePreference(ps);
 300         } else {
 301             if (toggleable == null || !toggleable.contains(Settings.Global.RADIO_WIMAX )
 302                     && isWimaxEnabled) {
 303                 Preference ps = (Preference) findPreference(KEY_WIMAX_SETTINGS);
 304                 ps.setDependency(KEY_TOGGLE_AIRPLANE);
 305             }
 306         }
 307
 308         // Manually set dependencies for Wifi when not toggleable.
 309         if (toggleable == null || !toggleable.contains(Settings.Global.RADIO_WIFI)) {
 310             findPreference(KEY_VPN_SETTINGS).setDependency(KEY_TOGGLE_AIRPLANE);
 311         }
 312         // Disable VPN.
 313         if (isSecondaryUser || mUm.hasUserRestriction(UserManager.DISALLOW_CONFIG_VPN)) {
 314             removePreference(KEY_VPN_SETTINGS);
 315         }
 316
 317         // Manually set dependencies for Bluetooth when not toggleable.
 318         if (toggleable == null || !toggleable.contains(Settings.Global.RADIO_BLUETOOTH)) {
 319             // No bluetooth-dependent items in the list. Code kept in case one is added later.
 320         }
 321
 322         // Manually set dependencies for NFC when not toggleable.
 323         if (toggleable == null || !toggleable.contains(Settings.Global.RADIO_NFC)) {
 324             findPreference(KEY_TOGGLE_NFC).setDependency(KEY_TOGGLE_AIRPLANE);
 325             findPreference(KEY_ANDROID_BEAM_SETTINGS).setDependency(KEY_TOGGLE_AIRPLANE);
 326         }
 327
 328         // Remove NFC if not available
 329         mNfcAdapter = NfcAdapter.getDefaultAdapter(activity);
 330         if (mNfcAdapter == null) {
 331             getPreferenceScreen().removePreference(nfc);
 332             getPreferenceScreen().removePreference(androidBeam);
 333             mNfcEnabler = null;
 334         }
 335
 336         // Remove Mobile Network Settings and Manage Mobile Plan for secondary users,
 337         // if it's a wifi-only device, or if the settings are restricted.
 338         if (isSecondaryUser || Utils.isWifiOnly(getActivity())
 339                 || mUm.hasUserRestriction(UserManager.DISALLOW_CONFIG_MOBILE_NETWORKS)) {
 340             removePreference(KEY_MOBILE_NETWORK_SETTINGS);
 341             removePreference(KEY_MANAGE_MOBILE_PLAN);
 342         }
 343         // Remove Mobile Network Settings and Manage Mobile Plan
 344         // if config_show_mobile_plan sets false.
 345         final boolean isMobilePlanEnabled = this.getResources().getBoolean(
 346                 R.bool.config_show_mobile_plan);
 347         if (!isMobilePlanEnabled) {
 348             Preference pref = findPreference(KEY_MANAGE_MOBILE_PLAN);
 349             if (pref != null) {
 350                 removePreference(KEY_MANAGE_MOBILE_PLAN);
 351             }
 352         }
 353
 354         // Remove SMS Application if the device does not support SMS
 355         if (!isSmsSupported()) {
 356             removePreference(KEY_SMS_APPLICATION);
 357         }
 358
 359         // Remove Airplane Mode settings if it's a stationary device such as a TV.
 360         if (mPm.hasSystemFeature(PackageManager.FEATURE_TELEVISION)) {
 361             removePreference(KEY_TOGGLE_AIRPLANE);
 362         }
 363
 364         // Enable Proxy selector settings if allowed.
 365         Preference mGlobalProxy = findPreference(KEY_PROXY_SETTINGS);
 366         final DevicePolicyManager mDPM = (DevicePolicyManager)
 367                 activity.getSystemService(Context.DEVICE_POLICY_SERVICE);
 368         // proxy UI disabled until we have better app support
 369         getPreferenceScreen().removePreference(mGlobalProxy);
 370         mGlobalProxy.setEnabled(mDPM.getGlobalProxyAdmin() == null);
 371
 372         // Disable Tethering if it's not allowed or if it's a wifi-only device
 373         final ConnectivityManager cm =
 374                 (ConnectivityManager) activity.getSystemService(Context.CONNECTIVITY_SERVICE);
 375         if (isSecondaryUser || !cm.isTetheringSupported()
 376                 || mUm.hasUserRestriction(UserManager.DISALLOW_CONFIG_TETHERING)) {
 377             getPreferenceScreen().removePreference(findPreference(KEY_TETHER_SETTINGS));
 378         } else {
 379             Preference p = findPreference(KEY_TETHER_SETTINGS);
 380             p.setTitle(Utils.getTetheringLabel(cm));
 381
 382             // Grey out if provisioning is not available.
 383             p.setEnabled(!TetherSettings
 384                     .isProvisioningNeededButUnavailable(getActivity()));
 385         }
 386
 387         // Enable link to CMAS app settings depending on the value in config.xml.
 388         boolean isCellBroadcastAppLinkEnabled = this.getResources().getBoolean(
 389                 com.android.internal.R.bool.config_cellBroadcastAppLinks);
 390         try {
 391             if (isCellBroadcastAppLinkEnabled) {
 392                 if (mPm.getApplicationEnabledSetting("com.android.cellbroadcastreceiver")
 393                         == PackageManager.COMPONENT_ENABLED_STATE_DISABLED) {
 394                     isCellBroadcastAppLinkEnabled = false;  // CMAS app disabled
 395                 }
 396             }
 397         } catch (IllegalArgumentException ignored) {
 398             isCellBroadcastAppLinkEnabled = false;  // CMAS app not installed
 399         }
 400         if (isSecondaryUser || !isCellBroadcastAppLinkEnabled
 401                 || mUm.hasUserRestriction(UserManager.DISALLOW_CONFIG_CELL_BROADCASTS)) {
 402             PreferenceScreen root = getPreferenceScreen();
 403             Preference ps = findPreference(KEY_CELL_BROADCAST_SETTINGS);
 404             if (ps != null) root.removePreference(ps);
 405         }
 406     }
 407
 408     @Override
 409     public void onStart() {
 410         super.onStart();
 411
 412         initSmsApplicationSetting();
 413     }
 414
 415     @Override
 416     public void onResume() {
 417         super.onResume();
 418
 419         mAirplaneModeEnabler.resume();
 420         if (mNfcEnabler != null) {
 421             mNfcEnabler.resume();
 422         }
 423         if (mNsdEnabler != null) {
 424             mNsdEnabler.resume();
 425         }
 426     }
 427
 428     @Override
 429     public void onSaveInstanceState(Bundle outState) {
 430         super.onSaveInstanceState(outState);
 431
 432         if (!TextUtils.isEmpty(mManageMobilePlanMessage)) {
 433             outState.putString(SAVED_MANAGE_MOBILE_PLAN_MSG, mManageMobilePlanMessage);
 434         }
 435     }
 436
 437     @Override
 438     public void onPause() {
 439         super.onPause();
 440
 441         mAirplaneModeEnabler.pause();
 442         if (mNfcEnabler != null) {
 443             mNfcEnabler.pause();
 444         }
 445         if (mNsdEnabler != null) {
 446             mNsdEnabler.pause();
 447         }
 448     }
 449
 450     @Override
 451     public void onActivityResult(int requestCode, int resultCode, Intent data) {
 452         if (requestCode == REQUEST_CODE_EXIT_ECM) {
 453             Boolean isChoiceYes = data.getBooleanExtra(EXIT_ECM_RESULT, false);
 454             // Set Airplane mode based on the return value and checkbox state
 455             mAirplaneModeEnabler.setAirplaneModeInECM(isChoiceYes,
 456                     mAirplaneModePreference.isChecked());
 457         }
 458         super.onActivityResult(requestCode, resultCode, data);
 459     }
 460
 461     @Override
 462     protected int getHelpResource() {
 463         return R.string.help_url_more_networks;
 464     }
 465
 466     @Override
 467     public boolean onPreferenceChange(Preference preference, Object newValue) {
 468         if (preference == mSmsApplicationPreference && newValue != null) {
 469             SmsApplication.setDefaultApplication(newValue.toString(), getActivity());
 470             return true;
 471         }
 472         return false;
 473     }
 474
 475     /**
 476      * For Search.
 477      */
 478     public static final Indexable.SearchIndexProvider SEARCH_INDEX_DATA_PROVIDER =
 479         new BaseSearchIndexProvider() {
 480             @Override
 481             public List<SearchIndexableResource> getXmlResourcesToIndex(
 482                     Context context, boolean enabled) {
 483                 SearchIndexableResource sir = new SearchIndexableResource(context);
 484                 sir.xmlResId = R.xml.wireless_settings;
 485                 return Arrays.asList(sir);
 486             }
 487
 488             @Override
 489             public List<String> getNonIndexableKeys(Context context) {
 490                 final ArrayList<String> result = new ArrayList<String>();
 491
 492                 result.add(KEY_TOGGLE_NSD);
 493
 494                 final UserManager um = (UserManager) context.getSystemService(Context.USER_SERVICE);
 495                 final int myUserId = UserHandle.myUserId();
 496                 final boolean isSecondaryUser = myUserId != UserHandle.USER_OWNER;
 497                 final boolean isRestrictedUser = um.getUserInfo(myUserId).isRestricted();
 498                 final boolean isWimaxEnabled = !isSecondaryUser
 499                         && context.getResources().getBoolean(
 500                         com.android.internal.R.bool.config_wimaxEnabled);
 501                 if (!isWimaxEnabled
 502                         || um.hasUserRestriction(UserManager.DISALLOW_CONFIG_MOBILE_NETWORKS)) {
 503                     result.add(KEY_WIMAX_SETTINGS);
 504                 }
 505
 506                 if (isSecondaryUser) { // Disable VPN
 507                     result.add(KEY_VPN_SETTINGS);
 508                 }
 509
 510                 // Remove NFC if not available
 511                 final NfcManager manager = (NfcManager)
 512                         context.getSystemService(Context.NFC_SERVICE);
 513                 if (manager != null) {
 514                     NfcAdapter adapter = manager.getDefaultAdapter();
 515                     if (adapter == null) {
 516                         result.add(KEY_TOGGLE_NFC);
 517                         result.add(KEY_ANDROID_BEAM_SETTINGS);
 518                     }
 519                 }
 520
 521                 // Remove Mobile Network Settings and Manage Mobile Plan if it's a wifi-only device.
 522                 if (isSecondaryUser || Utils.isWifiOnly(context)) {
 523                     result.add(KEY_MOBILE_NETWORK_SETTINGS);
 524                     result.add(KEY_MANAGE_MOBILE_PLAN);
 525                 }
 526
 527                 // Remove Mobile Network Settings and Manage Mobile Plan
 528                 // if config_show_mobile_plan sets false.
 529                 final boolean isMobilePlanEnabled = context.getResources().getBoolean(
 530                         R.bool.config_show_mobile_plan);
 531                 if (!isMobilePlanEnabled) {
 532                     result.add(KEY_MANAGE_MOBILE_PLAN);
 533                 }
 534
 535                 // Remove SMS Application if the device does not support SMS
 536                 TelephonyManager tm =
 537                         (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
 538                 if (!tm.isSmsCapable() || isRestrictedUser) {
 539                     result.add(KEY_SMS_APPLICATION);
 540                 }
 541
 542                 final PackageManager pm = context.getPackageManager();
 543
 544                 // Remove Airplane Mode settings if it's a stationary device such as a TV.
 545                 if (pm.hasSystemFeature(PackageManager.FEATURE_TELEVISION)) {
 546                     result.add(KEY_TOGGLE_AIRPLANE);
 547                 }
 548
 549                 // proxy UI disabled until we have better app support
 550                 result.add(KEY_PROXY_SETTINGS);
 551
 552                 // Disable Tethering if it's not allowed or if it's a wifi-only device
 553                 ConnectivityManager cm = (ConnectivityManager)
 554                         context.getSystemService(Context.CONNECTIVITY_SERVICE);
 555                 if (isSecondaryUser || !cm.isTetheringSupported()) {
 556                     result.add(KEY_TETHER_SETTINGS);
 557                 }
 558
 559                 // Enable link to CMAS app settings depending on the value in config.xml.
 560                 boolean isCellBroadcastAppLinkEnabled = context.getResources().getBoolean(
 561                         com.android.internal.R.bool.config_cellBroadcastAppLinks);
 562                 try {
 563                     if (isCellBroadcastAppLinkEnabled) {
 564                         if (pm.getApplicationEnabledSetting("com.android.cellbroadcastreceiver")
 565                                 == PackageManager.COMPONENT_ENABLED_STATE_DISABLED) {
 566                             isCellBroadcastAppLinkEnabled = false;  // CMAS app disabled
 567                         }
 568                     }
 569                 } catch (IllegalArgumentException ignored) {
 570                     isCellBroadcastAppLinkEnabled = false;  // CMAS app not installed
 571                 }
 572                 if (isSecondaryUser || !isCellBroadcastAppLinkEnabled) {
 573                     result.add(KEY_CELL_BROADCAST_SETTINGS);
 574                 }
 575
 576                 return result;
 577             }
 578         };
 579 }