@Override public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) { final ContentResolver cr = getContentResolver(); final UserManager um = (UserManager) getActivity().getSystemService(Context.USER_SERVICE); if (preference == mNetwork) { if (!um.hasUserRestriction(UserManager.DISALLOW_SHARE_LOCATION)) { Settings.Secure.setLocationProviderEnabled( cr, LocationManager.NETWORK_PROVIDER, mNetwork.isChecked()); } } else if (preference == mGps) { boolean enabled = mGps.isChecked(); if (!um.hasUserRestriction(UserManager.DISALLOW_SHARE_LOCATION)) { Settings.Secure.setLocationProviderEnabled(cr, LocationManager.GPS_PROVIDER, enabled); if (mAssistedGps != null) { mAssistedGps.setEnabled(enabled); } } } else if (preference == mAssistedGps) { Settings.Global.putInt( cr, Settings.Global.ASSISTED_GPS_ENABLED, mAssistedGps.isChecked() ? 1 : 0); } else { // If we didn't handle it, let preferences handle it. return super.onPreferenceTreeClick(preferenceScreen, preference); } return true; }
/** Enable or disable all providers when the master toggle is changed. */ private void onToggleLocationAccess(boolean checked) { final UserManager um = (UserManager) getActivity().getSystemService(Context.USER_SERVICE); if (um.hasUserRestriction(UserManager.DISALLOW_SHARE_LOCATION)) { return; } final ContentResolver cr = getContentResolver(); Settings.Secure.setLocationProviderEnabled(cr, LocationManager.GPS_PROVIDER, checked); Settings.Secure.setLocationProviderEnabled(cr, LocationManager.NETWORK_PROVIDER, checked); updateLocationToggles(); updateLtoServiceStatus(getActivity(), checked); }
@Override public boolean onOptionsItemSelected(MenuItem item) { // If the user is not allowed to configure wifi, do not handle menu selections. if (mUserManager.hasUserRestriction(DISALLOW_CONFIG_WIFI)) return false; switch (item.getItemId()) { case MENU_ID_WPS_PBC: showDialog(WPS_PBC_DIALOG_ID); return true; case MENU_ID_P2P: if (getActivity() instanceof PreferenceActivity) { ((PreferenceActivity) getActivity()) .startPreferencePanel( WifiP2pSettings.class.getCanonicalName(), null, R.string.wifi_p2p_settings_title, null, this, 0); } else { startFragment(this, WifiP2pSettings.class.getCanonicalName(), -1, null); } return true; case MENU_ID_WPS_PIN: showDialog(WPS_PIN_DIALOG_ID); return true; case MENU_ID_SCAN: if (mWifiManager.isWifiEnabled()) { mScanner.forceScan(); } return true; case MENU_ID_ADD_NETWORK: if (mWifiManager.isWifiEnabled()) { onAddNetworkPressed(); } return true; case MENU_ID_ADVANCED: if (getActivity() instanceof PreferenceActivity) { ((PreferenceActivity) getActivity()) .startPreferencePanel( AdvancedWifiSettings.class.getCanonicalName(), null, R.string.wifi_advanced_titlebar, null, this, 0); } else { startFragment(this, AdvancedWifiSettings.class.getCanonicalName(), -1, null); } return true; } return super.onOptionsItemSelected(item); }
@Override public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) { // If the user is not allowed to configure wifi, do not show the menu. if (mUserManager.hasUserRestriction(DISALLOW_CONFIG_WIFI)) return; final boolean wifiIsEnabled = mWifiManager.isWifiEnabled(); if (mSetupWizardMode) { // FIXME: add setIcon() when graphics are available menu.add(Menu.NONE, MENU_ID_WPS_PBC, 0, R.string.wifi_menu_wps_pbc) .setIcon(R.drawable.ic_wps) .setEnabled(wifiIsEnabled) .setShowAsAction(MenuItem.SHOW_AS_ACTION_ALWAYS); menu.add(Menu.NONE, MENU_ID_ADD_NETWORK, 0, R.string.wifi_add_network) .setEnabled(wifiIsEnabled) .setShowAsAction(MenuItem.SHOW_AS_ACTION_ALWAYS); } else { menu.add(Menu.NONE, MENU_ID_WPS_PBC, 0, R.string.wifi_menu_wps_pbc) .setIcon(R.drawable.ic_wps) .setEnabled(wifiIsEnabled) .setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM); menu.add(Menu.NONE, MENU_ID_ADD_NETWORK, 0, R.string.wifi_add_network) .setIcon(R.drawable.ic_menu_add) .setEnabled(wifiIsEnabled) .setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM); menu.add(Menu.NONE, MENU_ID_SCAN, 0, R.string.wifi_menu_scan) // .setIcon(R.drawable.ic_menu_scan_network) .setEnabled(wifiIsEnabled) .setShowAsAction(MenuItem.SHOW_AS_ACTION_NEVER); menu.add(Menu.NONE, MENU_ID_WPS_PIN, 0, R.string.wifi_menu_wps_pin) .setEnabled(wifiIsEnabled) .setShowAsAction(MenuItem.SHOW_AS_ACTION_NEVER); if (mP2pSupported) { menu.add(Menu.NONE, MENU_ID_P2P, 0, R.string.wifi_menu_p2p) .setEnabled(wifiIsEnabled) .setShowAsAction(MenuItem.SHOW_AS_ACTION_NEVER); } menu.add(Menu.NONE, MENU_ID_ADVANCED, 0, R.string.wifi_menu_advanced) // .setIcon(android.R.drawable.ic_menu_manage) .setShowAsAction(MenuItem.SHOW_AS_ACTION_NEVER); } super.onCreateOptionsMenu(menu, inflater); }
private PreferenceScreen createPreferenceHierarchy() { PreferenceScreen root = getPreferenceScreen(); if (root != null) { root.removeAll(); } addPreferencesFromResource(R.xml.location_settings); root = getPreferenceScreen(); mLocationAccess = (SwitchPreference) root.findPreference(KEY_LOCATION_TOGGLE); mNetwork = (CheckBoxPreference) root.findPreference(KEY_LOCATION_NETWORK); mGps = (CheckBoxPreference) root.findPreference(KEY_LOCATION_GPS); mAssistedGps = (CheckBoxPreference) root.findPreference(KEY_ASSISTED_GPS); mGpsDownloadDataWifiOnly = (CheckBoxPreference) root.findPreference(KEY_GPS_DOWNLOAD_DATA_WIFI_ONLY); // Only enable these controls if this user is allowed to change location // sharing settings. final UserManager um = (UserManager) getActivity().getSystemService(Context.USER_SERVICE); boolean isToggleAllowed = !um.hasUserRestriction(UserManager.DISALLOW_SHARE_LOCATION); if (mLocationAccess != null) mLocationAccess.setEnabled(isToggleAllowed); if (mNetwork != null) mNetwork.setEnabled(isToggleAllowed); if (mGps != null) mGps.setEnabled(isToggleAllowed); if (mAssistedGps != null) mAssistedGps.setEnabled(isToggleAllowed); if (mGpsDownloadDataWifiOnly != null) mGpsDownloadDataWifiOnly.setEnabled(isToggleAllowed); if (!LongTermOrbits.isSupported()) { root.removePreference(mGpsDownloadDataWifiOnly); mGpsDownloadDataWifiOnly = null; } else { if (saveDownloadDataWifiOnlyPref(getActivity())) { root.removePreference(mGpsDownloadDataWifiOnly); mGpsDownloadDataWifiOnly = null; } } mLocationAccess.setOnPreferenceChangeListener(this); return root; }
/** * Shows the latest access points available with supplimental information like the strength of * network and the security for it. */ private void updateAccessPoints() { // Safeguard from some delayed event handling if (getActivity() == null) return; if (mUserManager.hasUserRestriction(UserManager.DISALLOW_CONFIG_WIFI)) { addMessagePreference(R.string.wifi_empty_list_user_restricted); return; } final int wifiState = mWifiManager.getWifiState(); switch (wifiState) { case WifiManager.WIFI_STATE_ENABLED: // AccessPoints are automatically sorted with TreeSet. final Collection<AccessPoint> accessPoints = constructAccessPoints(); getPreferenceScreen().removeAll(); if (accessPoints.size() == 0) { addMessagePreference(R.string.wifi_empty_list_wifi_on); } for (AccessPoint accessPoint : accessPoints) { getPreferenceScreen().addPreference(accessPoint); } break; case WifiManager.WIFI_STATE_ENABLING: getPreferenceScreen().removeAll(); break; case WifiManager.WIFI_STATE_DISABLING: addMessagePreference(R.string.wifi_stopping); break; case WifiManager.WIFI_STATE_DISABLED: setOffMessage(); break; } }
private boolean isUsbTransferAllowed() { UserManager userManager = (UserManager) mContext.getSystemService(Context.USER_SERVICE); return !userManager.hasUserRestriction(UserManager.DISALLOW_USB_FILE_TRANSFER); }
/** Returns true if the current user is restricted from using location. */ private boolean isUserLocationRestricted(int userId) { final UserManager um = (UserManager) mContext.getSystemService(Context.USER_SERVICE); return um.hasUserRestriction(UserManager.DISALLOW_SHARE_LOCATION, new UserHandle(userId)); }
@Override public List<String> getNonIndexableKeys(Context context) { final ArrayList<String> result = new ArrayList<String>(); result.add(KEY_TOGGLE_NSD); final UserManager um = (UserManager) context.getSystemService(Context.USER_SERVICE); final int myUserId = UserHandle.myUserId(); final boolean isSecondaryUser = myUserId != UserHandle.USER_OWNER; final boolean isWimaxEnabled = !isSecondaryUser && context .getResources() .getBoolean(com.android.internal.R.bool.config_wimaxEnabled); if (!isWimaxEnabled || um.hasUserRestriction(UserManager.DISALLOW_CONFIG_MOBILE_NETWORKS)) { result.add(KEY_WIMAX_SETTINGS); } if (isSecondaryUser) { // Disable VPN result.add(KEY_VPN_SETTINGS); } // Remove NFC if not available final NfcManager manager = (NfcManager) context.getSystemService(Context.NFC_SERVICE); if (manager != null) { NfcAdapter adapter = manager.getDefaultAdapter(); if (adapter == null) { result.add(KEY_TOGGLE_NFC); result.add(KEY_ANDROID_BEAM_SETTINGS); } } // Remove Mobile Network Settings and Manage Mobile Plan if it's a wifi-only device. if (isSecondaryUser || Utils.isWifiOnly(context)) { result.add(KEY_MOBILE_NETWORK_SETTINGS); result.add(KEY_MANAGE_MOBILE_PLAN); } // Remove Mobile Network Settings and Manage Mobile Plan // if config_show_mobile_plan sets false. final boolean isMobilePlanEnabled = context.getResources().getBoolean(R.bool.config_show_mobile_plan); if (!isMobilePlanEnabled) { result.add(KEY_MANAGE_MOBILE_PLAN); } final PackageManager pm = context.getPackageManager(); // Remove Airplane Mode settings if it's a stationary device such as a TV. if (pm.hasSystemFeature(PackageManager.FEATURE_TELEVISION)) { result.add(KEY_TOGGLE_AIRPLANE); } // proxy UI disabled until we have better app support result.add(KEY_PROXY_SETTINGS); // Disable Tethering if it's not allowed or if it's a wifi-only device ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE); if (isSecondaryUser || !cm.isTetheringSupported()) { result.add(KEY_TETHER_SETTINGS); } // Enable link to CMAS app settings depending on the value in config.xml. boolean isCellBroadcastAppLinkEnabled = context .getResources() .getBoolean(com.android.internal.R.bool.config_cellBroadcastAppLinks); try { if (isCellBroadcastAppLinkEnabled) { if (pm.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) { result.add(KEY_CELL_BROADCAST_SETTINGS); } return result; }
@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); } }