private PreferenceScreen createPreferenceHierarchy() { PreferenceScreen root = getPreferenceScreen(); if (root != null) { root.removeAll(); } // Location Settings addPreferencesFromResource(R.xml.location_settings); addPreferencesFromResource(R.xml.security_settings); root = getPreferenceScreen(); // Location Settings mNetwork = (CheckBoxPreference) root.findPreference(KEY_LOCATION_NETWORK); mGps = (CheckBoxPreference) root.findPreference(KEY_LOCATION_GPS); mAssistedGps = (CheckBoxPreference) root.findPreference(KEY_ASSISTED_GPS); if (GoogleLocationSettingHelper.isAvailable(getActivity())) { // GSF present, Add setting for 'Use My Location' CheckBoxPreference useLocation = new CheckBoxPreference(getActivity()); useLocation.setKey(KEY_USE_LOCATION); useLocation.setTitle(R.string.use_location_title); useLocation.setSummary(R.string.use_location_summary); useLocation.setChecked( GoogleLocationSettingHelper.getUseLocationForServices(getActivity()) == GoogleLocationSettingHelper.USE_LOCATION_FOR_SERVICES_ON); useLocation.setPersistent(false); useLocation.setOnPreferenceChangeListener(this); getPreferenceScreen().addPreference(useLocation); mUseLocation = useLocation; } // Change the summary for wifi-only devices if (Utils.isWifiOnly(getActivity())) { mNetwork.setSummaryOn(R.string.location_neighborhood_level_wifi); } // Security Settings // Add options for lock/unlock screen int resid = 0; if (!mLockPatternUtils.isSecure()) { if (mLockPatternUtils.isLockScreenDisabled()) { resid = R.xml.security_settings_lockscreen; } else { resid = R.xml.security_settings_chooser; } } else if (mLockPatternUtils.usingBiometricWeak() && mLockPatternUtils.isBiometricWeakInstalled()) { resid = R.xml.security_settings_biometric_weak; } else { switch (mLockPatternUtils.getKeyguardStoredPasswordQuality()) { case DevicePolicyManager.PASSWORD_QUALITY_SOMETHING: resid = R.xml.security_settings_pattern; break; case DevicePolicyManager.PASSWORD_QUALITY_NUMERIC: resid = R.xml.security_settings_pin; break; case DevicePolicyManager.PASSWORD_QUALITY_ALPHABETIC: case DevicePolicyManager.PASSWORD_QUALITY_ALPHANUMERIC: case DevicePolicyManager.PASSWORD_QUALITY_COMPLEX: resid = R.xml.security_settings_password; break; } } addPreferencesFromResource(resid); boolean isSystemEmmcDetect = false; try { Class c = Class.forName(SYSTEM_DETECT_HANDLER); ISystemInfoDetectHandler handler = (ISystemInfoDetectHandler) c.newInstance(); isSystemEmmcDetect = handler.isFileSystemAutoDetect(); Log.i("SecuritySettings", "isSystemEmmcDetect = " + isSystemEmmcDetect); } catch (Exception e) { Log.i("SecuritySettings", "exception " + e); isSystemEmmcDetect = false; } if ((DefaultQuery.SYSTEM_INFO_DETECT_ENABLED == 1) || ((DefaultQuery.SYSTEM_INFO_DETECT_ENABLED == 2) && isSystemEmmcDetect)) { // Add options for device encryption DevicePolicyManager dpm = (DevicePolicyManager) getSystemService(Context.DEVICE_POLICY_SERVICE); switch (dpm.getStorageEncryptionStatus()) { case DevicePolicyManager.ENCRYPTION_STATUS_ACTIVE: // The device is currently encrypted. addPreferencesFromResource(R.xml.security_settings_encrypted); break; case DevicePolicyManager.ENCRYPTION_STATUS_INACTIVE: // This device supports encryption but isn't encrypted. addPreferencesFromResource(R.xml.security_settings_unencrypted); break; } } // lock after preference mLockAfter = (ListPreference) root.findPreference(KEY_LOCK_AFTER_TIMEOUT); if (mLockAfter != null) { setupLockAfterPreference(); updateLockAfterPreferenceSummary(); } // visible pattern mVisiblePattern = (CheckBoxPreference) root.findPreference(KEY_VISIBLE_PATTERN); // lock instantly on power key press mPowerButtonInstantlyLocks = (CheckBoxPreference) root.findPreference(KEY_POWER_INSTANTLY_LOCKS); // don't display visible pattern if biometric and backup is not // pattern if (resid == R.xml.security_settings_biometric_weak && mLockPatternUtils.getKeyguardStoredPasswordQuality() != DevicePolicyManager.PASSWORD_QUALITY_SOMETHING) { PreferenceGroup securityCategory = (PreferenceGroup) root.findPreference(KEY_SECURITY_CATEGORY); if (securityCategory != null && mVisiblePattern != null) { securityCategory.removePreference(root.findPreference(KEY_VISIBLE_PATTERN)); } } // tactile feedback. Should be common to all unlock preference // screens. mTactileFeedback = (CheckBoxPreference) root.findPreference(KEY_TACTILE_FEEDBACK_ENABLED); if (!((Vibrator) getSystemService(Context.VIBRATOR_SERVICE)).hasVibrator()) { PreferenceGroup securityCategory = (PreferenceGroup) root.findPreference(KEY_SECURITY_CATEGORY); if (securityCategory != null && mTactileFeedback != null) { securityCategory.removePreference(mTactileFeedback); } } // Append the rest of the settings addPreferencesFromResource(R.xml.security_settings_misc); MSimTelephonyManager tm = MSimTelephonyManager.getDefault(); int numPhones = TelephonyManager.getDefault().getPhoneCount(); boolean disableLock = false; for (int i = 0; i < numPhones; i++) { // Disable SIM lock if sim card is missing or unknown // notice:cdma can also set sim lock if ((tm.getSimState(i) == TelephonyManager.SIM_STATE_ABSENT) || (tm.getSimState(i) == TelephonyManager.SIM_STATE_UNKNOWN)) { disableLock = true; } else { disableLock = false; break; } } if (disableLock) { root.findPreference(KEY_SIM_LOCK).setEnabled(false); } // Show password mShowPassword = (CheckBoxPreference) root.findPreference(KEY_SHOW_PASSWORD); // SIM/RUIM lock Preference iccLock = (Preference) root.findPreference(KEY_SIM_LOCK_SETTINGS); Intent intent = new Intent(); if (tm.isMultiSimEnabled()) { intent.setClassName( "com.android.settings", "com.android.settings.multisimsettings.MultiSimSettingTab"); intent.putExtra(SelectSubscription.PACKAGE, "com.android.settings"); intent.putExtra(SelectSubscription.TARGET_CLASS, "com.android.settings.IccLockSettings"); } else { intent.setClassName("com.android.settings", "com.android.settings.IccLockSettings"); } iccLock.setIntent(intent); // Credential storage mResetCredentials = root.findPreference(KEY_RESET_CREDENTIALS); mToggleAppInstallation = (CheckBoxPreference) findPreference(KEY_TOGGLE_INSTALL_APPLICATIONS); mToggleAppInstallation.setChecked(isNonMarketAppsAllowed()); return root; }
@Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); addPreferencesFromResource(R.xml.settings_more_fragment); syncPreference( Config.KEY_PRIVACY, new MultiSelectListPreferenceSetter( getActivity(), 0, R.string.settings_privacy_mode_disabled)); syncPreference(Config.KEY_ONLY_WHILE_CHARGING); syncPreference(Config.KEY_FEEL_SCREEN_OFF_AFTER_LAST_NOTIFY); syncPreference(Config.KEY_DOUBLE_TAP_TO_SLEEP); syncPreference(Config.KEY_FEEL_WIDGET_PINNABLE); syncPreference(Config.KEY_FEEL_WIDGET_READABLE); mInactiveHoursPreference = findPreference("inactive_hours"); mTimeoutPreference = findPreference("timeout"); // Back-up & restore mDataRestoreDefaultsPreference = findPreference("data_restore_defaults"); mDataBackupPreference = findPreference("data_backup"); mDataRestorePreference = findPreference("data_restore"); mDataRestoreDefaultsPreference.setOnPreferenceClickListener(this); mDataBackupPreference.setOnPreferenceClickListener(this); mDataRestorePreference.setOnPreferenceClickListener(this); if (!DEBUG) { PreferenceGroup pg = (PreferenceGroup) findPreference("data_category"); pg.removePreference(mDataBackupPreference); pg.removePreference(mDataRestorePreference); } }
/** * Shows TalkBack's abbreviated version number in the action bar, and the full version number in * the Play Store button. */ private void showTalkBackVersion() { try { final PackageInfo packageInfo = getPackageManager().getPackageInfo(getPackageName(), 0); final ActionBar actionBar = getActionBar(); if (actionBar != null) { actionBar.setSubtitle( getString(R.string.talkback_preferences_subtitle, packageInfo.versionName)); } final Preference playStoreButton = findPreferenceByResId(R.string.pref_play_store_key); if (playStoreButton == null) { return; } if (GooglePlayServicesUtil.isGooglePlayServicesAvailable(this) != ConnectionResult.SUCCESS) { // Not needed, but playing safe since this is hard to test outside of China playStoreButton.setIntent(null); final PreferenceGroup category = (PreferenceGroup) findPreferenceByResId(R.string.pref_category_miscellaneous_key); if (category != null) { category.removePreference(playStoreButton); } } if (playStoreButton.getIntent() != null && getPackageManager().queryIntentActivities(playStoreButton.getIntent(), 0).size() == 0) { // Not needed, but playing safe since this is hard to test outside of China playStoreButton.setIntent(null); final PreferenceGroup category = (PreferenceGroup) findPreferenceByResId(R.string.pref_category_miscellaneous_key); if (category != null) { category.removePreference(playStoreButton); } } else { final String versionNumber = String.valueOf(packageInfo.versionCode); final int length = versionNumber.length(); playStoreButton.setSummary( getString( R.string.summary_pref_play_store, String.valueOf(Integer.parseInt(versionNumber.substring(0, length - 7))) + "." + String.valueOf( Integer.parseInt(versionNumber.substring(length - 7, length - 5))) + "." + String.valueOf( Integer.parseInt(versionNumber.substring(length - 5, length - 3))) + "." + String.valueOf(Integer.parseInt(versionNumber.substring(length - 3))))); } } catch (NameNotFoundException e) { // Nothing to do if we can't get the package name. } }
@Override public void onRemovePressed(SubtypePreference subtypePref) { mIsAddingNewSubtype = false; final PreferenceGroup group = getPreferenceScreen(); group.removePreference(subtypePref); ImfUtils.setAdditionalInputMethodSubtypes(getActivity(), getSubtypes()); }
/** * Touch exploration preference management code specific to devices running Jelly Bean and above. * * @param category The touch exploration category. */ @TargetApi(Build.VERSION_CODES.JELLY_BEAN) private void checkTouchExplorationSupportInner(PreferenceGroup category) { final CheckBoxPreference prefTouchExploration = (CheckBoxPreference) findPreferenceByResId(R.string.pref_explore_by_touch_reflect_key); if (prefTouchExploration == null) { return; } // Remove single-tap preference if it's not supported on this device. final CheckBoxPreference prefSingleTap = (CheckBoxPreference) findPreferenceByResId(R.string.pref_single_tap_key); if ((prefSingleTap != null) && (Build.VERSION.SDK_INT < ProcessorFocusAndSingleTap.MIN_API_LEVEL_SINGLE_TAP)) { category.removePreference(prefSingleTap); } // Ensure that changes to the reflected preference's checked state never // trigger content observers. prefTouchExploration.setPersistent(false); // Synchronize the reflected state. updateTouchExplorationState(); // Set up listeners that will keep the state synchronized. prefTouchExploration.setOnPreferenceChangeListener(mTouchExplorationChangeListener); // Hook in the external PreferenceActivity for gesture management final Preference shortcutsScreen = findPreferenceByResId(R.string.pref_category_manage_gestures_key); final Intent shortcutsIntent = new Intent(this, TalkBackShortcutPreferencesActivity.class); shortcutsScreen.setIntent(shortcutsIntent); }
/** * Ensure that web script injection settings do not appear on devices before user-customization of * web-scripts were available in the framework. */ private void checkWebScriptsSupport() { // TalkBack can control web script injection on API 18+ only. final PreferenceGroup category = (PreferenceGroup) findPreferenceByResId(R.string.pref_category_developer_key); final Preference prefWebScripts = findPreferenceByResId(R.string.pref_web_scripts_key); if (prefWebScripts != null) { category.removePreference(prefWebScripts); } }
/** * Ensure that sound and vibration preferences are removed if the latest versions of KickBack and * SoundBack are installed. */ private void checkInstalledBacks() { final PreferenceGroup category = (PreferenceGroup) findPreferenceByResId(R.string.pref_category_feedback_key); final CheckBoxPreference prefVibration = (CheckBoxPreference) findPreferenceByResId(R.string.pref_vibration_key); final int kickBackVersionCode = PackageManagerUtils.getVersionCode(this, TalkBackUpdateHelper.KICKBACK_PACKAGE); final boolean removeKickBack = (kickBackVersionCode >= TalkBackUpdateHelper.KICKBACK_REQUIRED_VERSION); if (removeKickBack) { if (prefVibration != null) { category.removePreference(prefVibration); } } final CheckBoxPreference prefSoundBack = (CheckBoxPreference) findPreferenceByResId(R.string.pref_soundback_key); final Preference prefSoundBackVolume = findPreferenceByResId(R.string.pref_soundback_volume_key); final int soundBackVersionCode = PackageManagerUtils.getVersionCode(this, TalkBackUpdateHelper.SOUNDBACK_PACKAGE); final boolean removeSoundBack = (soundBackVersionCode >= TalkBackUpdateHelper.SOUNDBACK_REQUIRED_VERSION); if (removeSoundBack) { if (prefSoundBackVolume != null) { category.removePreference(prefSoundBackVolume); } if (prefSoundBack != null) { category.removePreference(prefSoundBack); } } if (removeKickBack && removeSoundBack) { if (category != null) { getPreferenceScreen().removePreference(category); } } }
private void removePreferenceIfPropertyMissing( PreferenceGroup preferenceGroup, String preference, String property) { if (SystemProperties.get(property).equals("")) { // Property is missing so remove preference from group try { preferenceGroup.removePreference(findPreference(preference)); } catch (RuntimeException e) { Log.d( LOG_TAG, "Property '" + property + "' missing and no '" + preference + "' preference"); } } }
/** * Hide a preference from the screen so that user can't see and modify it * * @param parent the parent group preference if any, leave null if preference is a root pref * @param fieldName the preference key name to hide */ public void hidePreference(String parent, String fieldName) { PreferenceScreen pfs = getPreferenceScreen(); PreferenceGroup parentPref = pfs; if (parent != null) { parentPref = (PreferenceGroup) pfs.findPreference(parent); } Preference toRemovePref = pfs.findPreference(fieldName); if (toRemovePref != null && parentPref != null) { parentPref.removePreference(toRemovePref); } else { Log.w("Generic prefs", "Not able to find" + parent + " " + fieldName); } }
/** Ensure that telephony-related settings do not appear on devices without telephony. */ private void checkTelephonySupport() { final TelephonyManager telephony = (TelephonyManager) getSystemService(TELEPHONY_SERVICE); final int phoneType = telephony.getPhoneType(); if (phoneType != TelephonyManager.PHONE_TYPE_NONE) { return; } final PreferenceGroup category = (PreferenceGroup) findPreferenceByResId(R.string.pref_category_when_to_speak_key); final Preference prefCallerId = findPreferenceByResId(R.string.pref_caller_id_key); if (prefCallerId != null) { category.removePreference(prefCallerId); } }
/** * Hide a preference from the preference screen. * * @param parentGroup key for parent group if any. If null no parent group are searched * @param fieldName key for the field to remove */ protected void hidePreference(String parentGroup, String fieldName) { PreferenceScreen pfs = parent.getPreferenceScreen(); PreferenceGroup parentPref = pfs; if (parentGroup != null) { parentPref = (PreferenceGroup) pfs.findPreference(parentGroup); } Preference toRemovePref = pfs.findPreference(fieldName); if (toRemovePref != null && parentPref != null) { boolean rem = parentPref.removePreference(toRemovePref); Log.d("Generic prefs", "Has removed it : " + rem); } else { Log.d("Generic prefs", "Not able to find" + parent + " " + fieldName); } }
/** * Recursively traverses the tree from the given group as the route and tries to delete the * preference. Traversal stops once the preference was found and removed. */ private boolean recursiveDelete(PreferenceGroup group, Preference preference) { if (group.removePreference(preference)) { // Removal was successful. return true; } for (int i = 0; i < group.getPreferenceCount(); ++i) { Preference pref = group.getPreference(i); if (pref instanceof PreferenceGroup) { if (recursiveDelete((PreferenceGroup) pref, preference)) { return true; } } } return false; }
@Override public void onAddPressed(SubtypePreference subtypePref) { mIsAddingNewSubtype = false; final InputMethodSubtype subtype = subtypePref.getSubtype(); if (findDuplicatedSubtype(subtype) == null) { ImfUtils.setAdditionalInputMethodSubtypes(getActivity(), getSubtypes()); mSubtypePreferenceKeyForSubtypeEnabler = subtypePref.getKey(); mSubtypeEnablerNotificationDialog = createDialog(subtypePref); mSubtypeEnablerNotificationDialog.show(); return; } // Newly added subtype is duplicated. final PreferenceGroup group = getPreferenceScreen(); group.removePreference(subtypePref); showSubtypeAlreadyExistsToast(subtype); }
/** * Ensure that the shake to start continuous reading setting does not appear on devices without a * proximity sensor. */ private void checkAccelerometerSupport() { final SensorManager manager = (SensorManager) getSystemService(SENSOR_SERVICE); final Sensor accel = manager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER); if (accel != null) { return; } final PreferenceGroup category = (PreferenceGroup) findPreferenceByResId(R.string.pref_category_when_to_speak_key); final ListPreference prefShake = (ListPreference) findPreferenceByResId(R.string.pref_shake_to_read_threshold_key); if (prefShake != null) { category.removePreference(prefShake); } }
/** Ensure that the vibration setting does not appear on devices without a vibrator. */ private void checkVibrationSupport() { final Vibrator vibrator = (Vibrator) getSystemService(VIBRATOR_SERVICE); if (vibrator != null && vibrator.hasVibrator()) { return; } final PreferenceGroup category = (PreferenceGroup) findPreferenceByResId(R.string.pref_category_feedback_key); final CheckBoxPreference prefVibration = (CheckBoxPreference) findPreferenceByResId(R.string.pref_vibration_key); if (prefVibration != null) { prefVibration.setChecked(false); category.removePreference(prefVibration); } }
private void updateDimingPreferenceStatus() { final CheckBoxPreference dimPreference = (CheckBoxPreference) findPreferenceByResId(R.string.pref_dim_when_talkback_enabled_key); if (dimPreference == null) { return; } if (Build.VERSION.SDK_INT < ProcessorVolumeStream.MIN_API_LEVEL) { final PreferenceGroup category = (PreferenceGroup) findPreferenceByResId(R.string.pref_category_miscellaneous_key); if (category == null) { return; } category.removePreference(dimPreference); return; } dimPreference.setEnabled(MyAccessibilityService.isServiceActive() || dimPreference.isChecked()); dimPreference.setOnPreferenceChangeListener( new OnPreferenceChangeListener() { @Override public boolean onPreferenceChange(Preference preference, Object newValue) { if (newValue == null || !(newValue instanceof Boolean)) { return true; } boolean boolValue = (Boolean) newValue; if (!boolValue && !MyAccessibilityService.isServiceActive()) { dimPreference.setEnabled(false); } else if (boolValue && mPrefs.getBoolean( getString(R.string.pref_show_dim_screen_confirmation_dialog), true)) { showDimScreenDialog( new DialogInterface.OnClickListener() { @Override public void onClick(DialogInterface dialog, int which) { dimPreference.setChecked(true); } }); return false; } return true; } }); }
private void updateTalkBackShortcutStatus() { final CheckBoxPreference preference = (CheckBoxPreference) findPreferenceByResId(R.string.pref_two_volume_long_press_key); if (preference == null) { return; } if (Build.VERSION.SDK_INT >= ProcessorVolumeStream.MIN_API_LEVEL) { preference.setEnabled(MyAccessibilityService.getInstance() != null || preference.isChecked()); } else { final PreferenceGroup category = (PreferenceGroup) findPreferenceByResId(R.string.pref_category_miscellaneous_key); if (category == null) { return; } category.removePreference(preference); } }
@Override public void onSavePressed(SubtypePreference subtypePref) { final InputMethodSubtype subtype = subtypePref.getSubtype(); if (!subtypePref.hasBeenModified()) { return; } if (findDuplicatedSubtype(subtype) == null) { ImfUtils.setAdditionalInputMethodSubtypes(getActivity(), getSubtypes()); return; } // Saved subtype is duplicated. final PreferenceGroup group = getPreferenceScreen(); group.removePreference(subtypePref); subtypePref.revert(); group.addPreference(subtypePref); showSubtypeAlreadyExistsToast(subtype); }
/** * Ensure that the proximity sensor setting does not appear on devices without a proximity sensor. */ private void checkProximitySupport() { final SensorManager manager = (SensorManager) getSystemService(SENSOR_SERVICE); final Sensor proximity = manager.getDefaultSensor(Sensor.TYPE_PROXIMITY); if (proximity != null) { return; } final PreferenceGroup category = (PreferenceGroup) findPreferenceByResId(R.string.pref_category_when_to_speak_key); final CheckBoxPreference prefProximity = (CheckBoxPreference) findPreferenceByResId(R.string.pref_proximity_key); if (prefProximity != null) { prefProximity.setChecked(false); category.removePreference(prefProximity); } }
/** Assigns the appropriate intent to the label manager preference. */ private void assignLabelManagerIntent() { final PreferenceGroup category = (PreferenceGroup) findPreferenceByResId(R.string.pref_category_touch_exploration_key); final Preference prefManageLabels = findPreferenceByResId(R.string.pref_manage_labels_key); if ((category == null) || (prefManageLabels == null)) { return; } if (Build.VERSION.SDK_INT < LabelManagerSummaryActivity.MIN_API_LEVEL) { category.removePreference(prefManageLabels); return; } final Intent labelManagerIntent = new Intent(this, LabelManagerSummaryActivity.class); labelManagerIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); labelManagerIntent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP); prefManageLabels.setIntent(labelManagerIntent); }
/** Assigns the appropriate intent to the tutorial preference. */ private void assignTutorialIntent() { final PreferenceGroup category = (PreferenceGroup) findPreferenceByResId(R.string.pref_category_miscellaneous_key); final Preference prefTutorial = findPreferenceByResId(R.string.pref_tutorial_key); if ((category == null) || (prefTutorial == null)) { return; } final int touchscreenState = getResources().getConfiguration().touchscreen; if (touchscreenState == Configuration.TOUCHSCREEN_NOTOUCH) { category.removePreference(prefTutorial); return; } final Intent tutorialIntent = new Intent(this, AccessibilityTutorialActivity.class); tutorialIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); tutorialIntent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP); prefTutorial.setIntent(tutorialIntent); }
/** Assigns the appropriate intent to the keyboard shortcut preference. */ private void assignKeyboardShortcutIntent() { final PreferenceGroup category = (PreferenceGroup) findPreferenceByResId(R.string.pref_category_miscellaneous_key); final Preference keyboardShortcutPref = findPreferenceByResId(R.string.pref_category_manage_keyboard_shortcut_key); if ((category == null) || (keyboardShortcutPref == null)) { return; } if (Build.VERSION.SDK_INT < KeyComboManager.MIN_API_LEVEL) { category.removePreference(keyboardShortcutPref); return; } final Intent labelManagerIntent = new Intent(this, TalkBackKeyboardShortcutPreferencesActivity.class); labelManagerIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); labelManagerIntent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP); keyboardShortcutPref.setIntent(labelManagerIntent); }
@Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); addPreferencesFromResource(R.xml.settings); int activePhoneType = TelephonyManager.getDefault().getPhoneType(); PreferenceGroup parent = (PreferenceGroup) findPreference(KEY_PARENT); Utils.updatePreferenceToSpecificActivityOrRemove(this, parent, KEY_SYNC_SETTINGS, 0); Preference dockSettings = parent.findPreference(KEY_DOCK_SETTINGS); if (getResources().getBoolean(R.bool.has_dock_settings) == false && dockSettings != null) { parent.removePreference(dockSettings); } Utils.updatePreferenceToSpecificActivityFromMetaDataOrRemove( this, parent, KEY_OPERATOR_SETTINGS); Utils.updatePreferenceToSpecificActivityFromMetaDataOrRemove( this, parent, KEY_MANUFACTURER_SETTINGS); }
@Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); ContentResolver resolver = getContentResolver(); int activePhoneType = TelephonyManager.getDefault().getCurrentPhoneType(); mAudioManager = (AudioManager) getSystemService(Context.AUDIO_SERVICE); addPreferencesFromResource(R.xml.sound_settings); if (TelephonyManager.PHONE_TYPE_CDMA != activePhoneType) { // device is not CDMA, do not display CDMA emergency_tone getPreferenceScreen().removePreference(findPreference(KEY_EMERGENCY_TONE)); } if (!getResources().getBoolean(R.bool.has_silent_mode)) { findPreference(KEY_RING_VOLUME).setDependency(null); } if (getResources().getBoolean(com.android.internal.R.bool.config_useFixedVolume)) { // device with fixed volume policy, do not display volumes submenu getPreferenceScreen().removePreference(findPreference(KEY_RING_VOLUME)); } mVibrateWhenRinging = (CheckBoxPreference) findPreference(KEY_VIBRATE); mVibrateWhenRinging.setPersistent(false); mVibrateWhenRinging.setChecked( Settings.System.getInt(resolver, Settings.System.VIBRATE_WHEN_RINGING, 0) != 0); mDtmfTone = (CheckBoxPreference) findPreference(KEY_DTMF_TONE); mDtmfTone.setPersistent(false); mDtmfTone.setChecked( Settings.System.getInt(resolver, Settings.System.DTMF_TONE_WHEN_DIALING, 1) != 0); mSoundEffects = (CheckBoxPreference) findPreference(KEY_SOUND_EFFECTS); mSoundEffects.setPersistent(false); mSoundEffects.setChecked( Settings.System.getInt(resolver, Settings.System.SOUND_EFFECTS_ENABLED, 1) != 0); mHapticFeedback = (CheckBoxPreference) findPreference(KEY_HAPTIC_FEEDBACK); mHapticFeedback.setPersistent(false); mHapticFeedback.setChecked( Settings.System.getInt(resolver, Settings.System.HAPTIC_FEEDBACK_ENABLED, 1) != 0); mLockSounds = (CheckBoxPreference) findPreference(KEY_LOCK_SOUNDS); mLockSounds.setPersistent(false); mLockSounds.setChecked( Settings.System.getInt(resolver, Settings.System.LOCKSCREEN_SOUNDS_ENABLED, 1) != 0); mRingtonePreference = findPreference(KEY_RINGTONE); mNotificationPreference = findPreference(KEY_NOTIFICATION_SOUND); Vibrator vibrator = (Vibrator) getSystemService(Context.VIBRATOR_SERVICE); if (vibrator == null || !vibrator.hasVibrator()) { removePreference(KEY_VIBRATE); removePreference(KEY_HAPTIC_FEEDBACK); } if (TelephonyManager.PHONE_TYPE_CDMA == activePhoneType) { ListPreference emergencyTonePreference = (ListPreference) findPreference(KEY_EMERGENCY_TONE); emergencyTonePreference.setValue( String.valueOf( Settings.Global.getInt( resolver, Settings.Global.EMERGENCY_TONE, FALLBACK_EMERGENCY_TONE_VALUE))); emergencyTonePreference.setOnPreferenceChangeListener(this); } mSoundSettings = (PreferenceGroup) findPreference(KEY_SOUND_SETTINGS); mMusicFx = mSoundSettings.findPreference(KEY_MUSICFX); Intent i = new Intent(AudioEffect.ACTION_DISPLAY_AUDIO_EFFECT_CONTROL_PANEL); PackageManager p = getPackageManager(); List<ResolveInfo> ris = p.queryIntentActivities(i, PackageManager.GET_DISABLED_COMPONENTS); if (ris.size() <= 2) { // no need to show the item if there is no choice for the user to make // note: the built in musicfx panel has two activities (one being a // compatibility shim that launches either the other activity, or a // third party one), hence the check for <=2. If the implementation // of the compatbility layer changes, this check may need to be updated. mSoundSettings.removePreference(mMusicFx); } if (!Utils.isVoiceCapable(getActivity())) { for (String prefKey : NEED_VOICE_CAPABILITY) { Preference pref = findPreference(prefKey); if (pref != null) { getPreferenceScreen().removePreference(pref); } } } mRingtoneLookupRunnable = new Runnable() { public void run() { if (mRingtonePreference != null) { updateRingtoneName( RingtoneManager.TYPE_RINGTONE, mRingtonePreference, MSG_UPDATE_RINGTONE_SUMMARY); } if (mNotificationPreference != null) { updateRingtoneName( RingtoneManager.TYPE_NOTIFICATION, mNotificationPreference, MSG_UPDATE_NOTIFICATION_SUMMARY); } } }; initDockSettings(); // add by lixd start---------------------------- getPreferenceScreen().removePreference(findPreference(KEY_VIBRATE)); getPreferenceScreen().removePreference(findPreference(KEY_RINGTONE)); getPreferenceScreen().removePreference(findPreference(KEY_DTMF_TONE)); getPreferenceScreen().removePreference(findPreference(KEY_SOUND_EFFECTS)); getPreferenceScreen().removePreference(findPreference(KEY_HAPTIC_FEEDBACK)); getPreferenceScreen().removePreference(findPreference(KEY_CATEGORY_CALLS)); // getPreferenceScreen().removePreference(findPreference(KEY_SOUND_SETTINGS)); getPreferenceScreen().removePreference(findPreference(KEY_LOCK_SOUNDS)); getPreferenceScreen().removePreference(findPreference(KEY_NOTIFICATION_SOUND)); // getPreferenceScreen().removePreference(findPreference(KEY_CATEGORY_CALLS)); // getPreferenceScreen().removePreference(findPreference(KEY_DOCK_CATEGORY)); // getPreferenceScreen().removePreference(findPreference(KEY_DOCK_AUDIO_SETTINGS)); // getPreferenceScreen().removePreference(findPreference(KEY_DOCK_SOUNDS)); // getPreferenceScreen().removePreference(findPreference(KEY_DOCK_AUDIO_MEDIA_ENABLED)); // --------------end-------------------- }
@Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setTitle(R.string.title_navbar); // Load the preferences from an XML resource addPreferencesFromResource(R.xml.navbar_settings); PreferenceScreen prefs = getPreferenceScreen(); mPicker = new ShortcutPickerHelper(this, this); mPackMan = getPackageManager(); mResources = mContext.getResources(); // Get NavBar Actions mActionCodes = NavBarHelpers.getNavBarActions(); mActions = new String[mActionCodes.length]; int actionqty = mActions.length; for (int i = 0; i < actionqty; i++) { mActions[i] = AwesomeConstants.getProperName(mContext, mActionCodes[i]); } menuDisplayLocation = (ListPreference) findPreference(PREF_MENU_UNLOCK); menuDisplayLocation.setOnPreferenceChangeListener(this); menuDisplayLocation.setValue( Settings.System.getInt(mContentRes, Settings.System.MENU_LOCATION, 0) + ""); mNavBarMenuDisplay = (ListPreference) findPreference(PREF_NAVBAR_MENU_DISPLAY); mNavBarMenuDisplay.setOnPreferenceChangeListener(this); mNavBarMenuDisplay.setValue( Settings.System.getInt(mContentRes, Settings.System.MENU_VISIBILITY, 0) + ""); mNavBarHideEnable = (CheckBoxPreference) findPreference(NAVBAR_HIDE_ENABLE); mNavBarHideEnable.setChecked( Settings.System.getBoolean(mContentRes, Settings.System.NAV_HIDE_ENABLE, false)); final int defaultDragOpacity = Settings.System.getInt(mContentRes, Settings.System.DRAG_HANDLE_OPACITY, 50); mDragHandleOpacity = (SeekBarPreference) findPreference(DRAG_HANDLE_OPACITY); mDragHandleOpacity.setInitValue((int) (defaultDragOpacity)); mDragHandleOpacity.setOnPreferenceChangeListener(this); final int defaultDragWidth = Settings.System.getInt(mContentRes, Settings.System.DRAG_HANDLE_WEIGHT, 5); mDragHandleWidth = (SeekBarPreference) findPreference(DRAG_HANDLE_WIDTH); mDragHandleWidth.setInitValue((int) (defaultDragWidth)); mDragHandleWidth.setOnPreferenceChangeListener(this); mNavBarHideTimeout = (ListPreference) findPreference(NAVBAR_HIDE_TIMEOUT); mNavBarHideTimeout.setOnPreferenceChangeListener(this); mNavBarHideTimeout.setValue( Settings.System.getInt(mContentRes, Settings.System.NAV_HIDE_TIMEOUT, 3000) + ""); boolean hasNavBarByDefault = mContext.getResources().getBoolean(com.android.internal.R.bool.config_showNavigationBar); mEnableNavigationBar = (CheckBoxPreference) findPreference(ENABLE_NAVIGATION_BAR); mEnableNavigationBar.setChecked( Settings.System.getBoolean( mContentRes, Settings.System.NAVIGATION_BAR_SHOW, hasNavBarByDefault)); mNavigationColor = (ColorPickerPreference) findPreference(NAVIGATION_BAR_COLOR); mNavigationColor.setOnPreferenceChangeListener(this); mNavigationBarColor = (ColorPickerPreference) findPreference(PREF_NAV_COLOR); mNavigationBarColor.setOnPreferenceChangeListener(this); mColorizeAllIcons = (CheckBoxPreference) findPreference("navigation_bar_allcolor"); mColorizeAllIcons.setChecked( Settings.System.getBoolean(mContentRes, Settings.System.NAVIGATION_BAR_ALLCOLOR, false)); mNavigationBarGlowColor = (ColorPickerPreference) findPreference(PREF_NAV_GLOW_COLOR); mNavigationBarGlowColor.setOnPreferenceChangeListener(this); mGlowTimes = (ListPreference) findPreference(PREF_GLOW_TIMES); mGlowTimes.setOnPreferenceChangeListener(this); final float defaultButtonAlpha = Settings.System.getFloat(mContentRes, Settings.System.NAVIGATION_BAR_BUTTON_ALPHA, 0.6f); mButtonAlpha = (SeekBarPreference) findPreference("button_transparency"); mButtonAlpha.setInitValue((int) (defaultButtonAlpha * 100)); mButtonAlpha.setOnPreferenceChangeListener(this); mWidthHelp = (Preference) findPreference("width_help"); float defaultPort = Settings.System.getFloat(mContentRes, Settings.System.NAVIGATION_BAR_WIDTH_PORT, 0f); mWidthPort = (SeekBarPreference) findPreference("width_port"); mWidthPort.setInitValue((int) (defaultPort * 2.5f)); mWidthPort.setOnPreferenceChangeListener(this); float defaultLand = Settings.System.getFloat(mContentRes, Settings.System.NAVIGATION_BAR_WIDTH_LAND, 0f); mWidthLand = (SeekBarPreference) findPreference("width_land"); mWidthLand.setInitValue((int) (defaultLand * 2.5f)); mWidthLand.setOnPreferenceChangeListener(this); mNavigationBarHeight = (ListPreference) findPreference("navigation_bar_height"); mNavigationBarHeight.setOnPreferenceChangeListener(this); mNavigationBarHeightLandscape = (ListPreference) findPreference("navigation_bar_height_landscape"); mNavigationBarHeightLandscape.setOnPreferenceChangeListener(this); mNavigationBarWidth = (ListPreference) findPreference("navigation_bar_width"); mNavigationBarWidth.setOnPreferenceChangeListener(this); mConfigureWidgets = findPreference(NAVIGATION_BAR_WIDGETS); mMenuArrowKeysCheckBox = (CheckBoxPreference) findPreference(PREF_MENU_ARROWS); mMenuArrowKeysCheckBox.setChecked( Settings.System.getBoolean( mContentRes, Settings.System.NAVIGATION_BAR_MENU_ARROW_KEYS, true)); // don't allow devices that must use a navigation bar to disable it if (hasNavBarByDefault) { prefs.removePreference(mEnableNavigationBar); } PreferenceGroup pg = (PreferenceGroup) prefs.findPreference("advanced_cat"); if (isTablet(mContext)) { mNavigationBarHeight.setTitle(R.string.system_bar_height_title); mNavigationBarHeight.setSummary(R.string.system_bar_height_summary); mNavigationBarHeightLandscape.setTitle(R.string.system_bar_height_landscape_title); mNavigationBarHeightLandscape.setSummary(R.string.system_bar_height_landscape_summary); pg.removePreference(mNavigationBarWidth); mNavBarHideEnable.setEnabled(false); mDragHandleOpacity.setEnabled(false); mDragHandleWidth.setEnabled(false); mNavBarHideTimeout.setEnabled(false); } else { // Phones&Phablets don't have SystemBar pg.removePreference(mWidthPort); pg.removePreference(mWidthLand); pg.removePreference(mWidthHelp); } if (Integer.parseInt(menuDisplayLocation.getValue()) == 4) { mNavBarMenuDisplay.setEnabled(false); } // Only show the hardware keys config on a device that does not have a navbar IWindowManager windowManager = IWindowManager.Stub.asInterface(ServiceManager.getService(Context.WINDOW_SERVICE)); if (hasNavBarByDefault) { // Let's assume they don't have hardware keys getPreferenceScreen().removePreference(findPreference(KEY_HARDWARE_KEYS)); } refreshSettings(); setHasOptionsMenu(true); updateGlowTimesSummary(); }
@Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); ContentResolver resolver = getContentResolver(); int activePhoneType = TelephonyManager.getDefault().getCurrentPhoneType(); mAudioManager = (AudioManager) getSystemService(Context.AUDIO_SERVICE); addPreferencesFromResource(R.xml.sound_settings); if (TelephonyManager.PHONE_TYPE_CDMA != activePhoneType) { // device is not CDMA, do not display CDMA emergency_tone getPreferenceScreen().removePreference(findPreference(KEY_EMERGENCY_TONE)); } // mzikun add for settings menu // mPhone = PhoneApp.getInstance().getPhone(); mSilentMode = (ListPreference) findPreference(KEY_SILENT_MODE); if (!getResources().getBoolean(R.bool.has_silent_mode)) { getPreferenceScreen().removePreference(mSilentMode); findPreference(KEY_RING_VOLUME).setDependency(null); } else { mSilentMode.setOnPreferenceChangeListener(this); } mVibrateOnRing = (CheckBoxPreference) findPreference(KEY_VIBRATE); mVibrateOnRing.setOnPreferenceChangeListener(this); mDtmfTone = (CheckBoxPreference) findPreference(KEY_DTMF_TONE); mDtmfTone.setPersistent(false); mDtmfTone.setChecked( Settings.System.getInt(resolver, Settings.System.DTMF_TONE_WHEN_DIALING, 1) != 0); mSoundEffects = (CheckBoxPreference) findPreference(KEY_SOUND_EFFECTS); mSoundEffects.setPersistent(false); mSoundEffects.setChecked( Settings.System.getInt(resolver, Settings.System.SOUND_EFFECTS_ENABLED, 1) != 0); mHapticFeedback = (CheckBoxPreference) findPreference(KEY_HAPTIC_FEEDBACK); mHapticFeedback.setPersistent(false); mHapticFeedback.setChecked( Settings.System.getInt(resolver, Settings.System.HAPTIC_FEEDBACK_ENABLED, 1) != 0); mLockSounds = (CheckBoxPreference) findPreference(KEY_LOCK_SOUNDS); mLockSounds.setPersistent(false); mLockSounds.setChecked( Settings.System.getInt(resolver, Settings.System.LOCKSCREEN_SOUNDS_ENABLED, 1) != 0); mRingtonePreference = findPreference(KEY_RINGTONE); mMultiSimRingtonePreference = findPreference(KEY_MULTISIM_RINGTONE); if (TelephonyManager.getDefault().isMultiSimEnabled()) { // if it support multi sim, remove ringtone setting, show multi sim ringtone setting getPreferenceScreen().removePreference(mRingtonePreference); mRingtonePreference = null; } else { // if it is not multi sim, remove multi sim ringtone setting, and show ringtone setting getPreferenceScreen().removePreference(mMultiSimRingtonePreference); mMultiSimRingtonePreference = null; } mNotificationPreference = findPreference(KEY_NOTIFICATION_SOUND); if (!((Vibrator) getSystemService(Context.VIBRATOR_SERVICE)).hasVibrator()) { getPreferenceScreen().removePreference(mVibrateOnRing); getPreferenceScreen().removePreference(mHapticFeedback); } if (TelephonyManager.PHONE_TYPE_CDMA == activePhoneType) { ListPreference emergencyTonePreference = (ListPreference) findPreference(KEY_EMERGENCY_TONE); emergencyTonePreference.setValue( String.valueOf( Settings.System.getInt( resolver, Settings.System.EMERGENCY_TONE, FALLBACK_EMERGENCY_TONE_VALUE))); emergencyTonePreference.setOnPreferenceChangeListener(this); } mSoundSettings = (PreferenceGroup) findPreference(KEY_SOUND_SETTINGS); mMusicFx = mSoundSettings.findPreference(KEY_MUSICFX); Intent i = new Intent(AudioEffect.ACTION_DISPLAY_AUDIO_EFFECT_CONTROL_PANEL); PackageManager p = getPackageManager(); List<ResolveInfo> ris = p.queryIntentActivities(i, PackageManager.GET_DISABLED_COMPONENTS); if (ris.size() <= 2) { // no need to show the item if there is no choice for the user to make // note: the built in musicfx panel has two activities (one being a // compatibility shim that launches either the other activity, or a // third party one), hence the check for <=2. If the implementation // of the compatbility layer changes, this check may need to be updated. mSoundSettings.removePreference(mMusicFx); } if (!Utils.isVoiceCapable(getActivity())) { for (String prefKey : NEED_VOICE_CAPABILITY) { Preference pref = findPreference(prefKey); if (pref != null) { getPreferenceScreen().removePreference(pref); } } } /*Begin: mzikun add for settings menu*/ mReverseCallMute = (CheckBoxPreference) findPreference(KEY_REVERSE_CALL_MUTE); if (mReverseCallMute != null) { mReverseCallMute.setPersistent(false); mReverseCallMute.setOnPreferenceChangeListener(this); } else { getPreferenceScreen().removePreference(mReverseCallMute); mReverseCallMute = null; } mReverseMP3Mute = (CheckBoxPreference) findPreference(KEY_REVERSE_MP3_MUTE); if (mReverseMP3Mute != null) { mReverseMP3Mute.setPersistent(false); mReverseMP3Mute.setOnPreferenceChangeListener(this); } else { getPreferenceScreen().removePreference(mReverseMP3Mute); mReverseMP3Mute = null; } mReverseMP4Mute = (CheckBoxPreference) findPreference(KEY_REVERSE_MP4_MUTE); if (mReverseMP4Mute != null) { mReverseMP4Mute.setPersistent(false); mReverseMP4Mute.setOnPreferenceChangeListener(this); } else { getPreferenceScreen().removePreference(mReverseMP4Mute); mReverseMP4Mute = null; } /*End: mzikun add for settings menu*/ mRingtoneLookupRunnable = new Runnable() { public void run() { if (mRingtonePreference != null) { updateRingtoneName( RingtoneManager.TYPE_RINGTONE, mRingtonePreference, MSG_UPDATE_RINGTONE_SUMMARY); } if (mNotificationPreference != null) { updateRingtoneName( RingtoneManager.TYPE_NOTIFICATION, mNotificationPreference, MSG_UPDATE_NOTIFICATION_SUMMARY); } } }; }
@Override public void onCreate(Bundle icicle) { super.onCreate(icicle); mWindowManager = IWindowManager.Stub.asInterface(ServiceManager.getService("window")); mBackupManager = IBackupManager.Stub.asInterface(ServiceManager.getService(Context.BACKUP_SERVICE)); mDpm = (DevicePolicyManager) getActivity().getSystemService(Context.DEVICE_POLICY_SERVICE); addPreferencesFromResource(R.xml.development_prefs); mEnableAdb = findAndInitCheckboxPref(ENABLE_ADB); mBugreport = findPreference(BUGREPORT); mBugreportInPower = findAndInitCheckboxPref(BUGREPORT_IN_POWER_KEY); mKeepScreenOn = findAndInitCheckboxPref(KEEP_SCREEN_ON); mEnforceReadExternal = findAndInitCheckboxPref(ENFORCE_READ_EXTERNAL); mAllowMockLocation = findAndInitCheckboxPref(ALLOW_MOCK_LOCATION); mPassword = (PreferenceScreen) findPreference(LOCAL_BACKUP_PASSWORD); mAllPrefs.add(mPassword); mDebugAppPref = findPreference(DEBUG_APP_KEY); mAllPrefs.add(mDebugAppPref); mWaitForDebugger = findAndInitCheckboxPref(WAIT_FOR_DEBUGGER_KEY); mVerifyAppsOverUsb = findAndInitCheckboxPref(VERIFY_APPS_OVER_USB_KEY); if (!showVerifierSetting()) { PreferenceGroup debugDebuggingCategory = (PreferenceGroup) findPreference(DEBUG_DEBUGGING_CATEGORY_KEY); if (debugDebuggingCategory != null) { debugDebuggingCategory.removePreference(mVerifyAppsOverUsb); } else { mVerifyAppsOverUsb.setEnabled(false); } } mStrictMode = findAndInitCheckboxPref(STRICT_MODE_KEY); mPointerLocation = findAndInitCheckboxPref(POINTER_LOCATION_KEY); mShowTouches = findAndInitCheckboxPref(SHOW_TOUCHES_KEY); mShowScreenUpdates = findAndInitCheckboxPref(SHOW_SCREEN_UPDATES_KEY); mDisableOverlays = findAndInitCheckboxPref(DISABLE_OVERLAYS_KEY); mShowCpuUsage = findAndInitCheckboxPref(SHOW_CPU_USAGE_KEY); mForceHardwareUi = findAndInitCheckboxPref(FORCE_HARDWARE_UI_KEY); mForceMsaa = findAndInitCheckboxPref(FORCE_MSAA_KEY); mTrackFrameTime = findAndInitCheckboxPref(TRACK_FRAME_TIME_KEY); mShowHwScreenUpdates = findAndInitCheckboxPref(SHOW_HW_SCREEN_UPDATES_KEY); mShowHwLayersUpdates = findAndInitCheckboxPref(SHOW_HW_LAYERS_UPDATES_KEY); mShowHwOverdraw = findAndInitCheckboxPref(SHOW_HW_OVERDRAW_KEY); mDebugLayout = findAndInitCheckboxPref(DEBUG_LAYOUT_KEY); mWindowAnimationScale = (ListPreference) findPreference(WINDOW_ANIMATION_SCALE_KEY); mAllPrefs.add(mWindowAnimationScale); mWindowAnimationScale.setOnPreferenceChangeListener(this); mTransitionAnimationScale = (ListPreference) findPreference(TRANSITION_ANIMATION_SCALE_KEY); mAllPrefs.add(mTransitionAnimationScale); mTransitionAnimationScale.setOnPreferenceChangeListener(this); mAnimatorDurationScale = (ListPreference) findPreference(ANIMATOR_DURATION_SCALE_KEY); mAllPrefs.add(mAnimatorDurationScale); mAnimatorDurationScale.setOnPreferenceChangeListener(this); mOverlayDisplayDevices = (ListPreference) findPreference(OVERLAY_DISPLAY_DEVICES_KEY); mAllPrefs.add(mOverlayDisplayDevices); mOverlayDisplayDevices.setOnPreferenceChangeListener(this); mOpenGLTraces = (ListPreference) findPreference(OPENGL_TRACES_KEY); mAllPrefs.add(mOpenGLTraces); mOpenGLTraces.setOnPreferenceChangeListener(this); mEnableTracesPref = (MultiCheckPreference) findPreference(ENABLE_TRACES_KEY); String[] traceValues = new String[Trace.TRACE_TAGS.length]; for (int i = Trace.TRACE_FLAGS_START_BIT; i < traceValues.length; i++) { traceValues[i] = Integer.toString(1 << i); } mEnableTracesPref.setEntries(Trace.TRACE_TAGS); mEnableTracesPref.setEntryValues(traceValues); mAllPrefs.add(mEnableTracesPref); mEnableTracesPref.setOnPreferenceChangeListener(this); mImmediatelyDestroyActivities = (CheckBoxPreference) findPreference(IMMEDIATELY_DESTROY_ACTIVITIES_KEY); mAllPrefs.add(mImmediatelyDestroyActivities); mResetCbPrefs.add(mImmediatelyDestroyActivities); mAppProcessLimit = (ListPreference) findPreference(APP_PROCESS_LIMIT_KEY); mAllPrefs.add(mAppProcessLimit); mAppProcessLimit.setOnPreferenceChangeListener(this); mShowAllANRs = (CheckBoxPreference) findPreference(SHOW_ALL_ANRS_KEY); mAllPrefs.add(mShowAllANRs); mResetCbPrefs.add(mShowAllANRs); mKillAppLongpressBack = findAndInitCheckboxPref(KILL_APP_LONGPRESS_BACK); Preference hdcpChecking = findPreference(HDCP_CHECKING_KEY); if (hdcpChecking != null) { mAllPrefs.add(hdcpChecking); } removeHdcpOptionsForProduction(); }
@Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); ContentResolver resolver = getContentResolver(); int activePhoneType = TelephonyManager.getDefault().getPhoneType(); mAudioManager = (AudioManager) getSystemService(Context.AUDIO_SERVICE); addPreferencesFromResource(R.xml.sound_settings); if (TelephonyManager.PHONE_TYPE_CDMA != activePhoneType) { // device is not CDMA, do not display CDMA emergency_tone getPreferenceScreen().removePreference(findPreference(KEY_EMERGENCY_TONE)); } mSilent = (CheckBoxPreference) findPreference(KEY_SILENT); mVibrate = (ListPreference) findPreference(KEY_VIBRATE); mVibrate.setOnPreferenceChangeListener(this); mDtmfTone = (CheckBoxPreference) findPreference(KEY_DTMF_TONE); mDtmfTone.setPersistent(false); mDtmfTone.setChecked( Settings.System.getInt(resolver, Settings.System.DTMF_TONE_WHEN_DIALING, 1) != 0); mSoundEffects = (CheckBoxPreference) findPreference(KEY_SOUND_EFFECTS); mSoundEffects.setPersistent(false); mSoundEffects.setChecked( Settings.System.getInt(resolver, Settings.System.SOUND_EFFECTS_ENABLED, 0) != 0); mHapticFeedback = (CheckBoxPreference) findPreference(KEY_HAPTIC_FEEDBACK); mHapticFeedback.setPersistent(false); mHapticFeedback.setChecked( Settings.System.getInt(resolver, Settings.System.HAPTIC_FEEDBACK_ENABLED, 0) != 0); mLockSounds = (CheckBoxPreference) findPreference(KEY_LOCK_SOUNDS); mLockSounds.setPersistent(false); mLockSounds.setChecked( Settings.System.getInt(resolver, Settings.System.LOCKSCREEN_SOUNDS_ENABLED, 1) != 0); mPowerSounds = (CheckBoxPreference) findPreference(KEY_POWER_SOUNDS); mPowerSounds.setPersistent(false); mPowerSounds.setChecked( Settings.System.getInt(resolver, Settings.System.POWER_SOUNDS_ENABLED, 1) != 0); if (TelephonyManager.PHONE_TYPE_CDMA == activePhoneType) { ListPreference emergencyTonePreference = (ListPreference) findPreference(KEY_EMERGENCY_TONE); emergencyTonePreference.setValue( String.valueOf( Settings.System.getInt( resolver, Settings.System.EMERGENCY_TONE, FALLBACK_EMERGENCY_TONE_VALUE))); emergencyTonePreference.setOnPreferenceChangeListener(this); } mSoundSettings = (PreferenceGroup) findPreference(KEY_SOUND_SETTINGS); mNotificationPulse = (CheckBoxPreference) mSoundSettings.findPreference(KEY_NOTIFICATION_PULSE); mNotificationBlink = (CheckBoxPreference) mSoundSettings.findPreference(KEY_NOTIFICATION_BLINK); mNotificationAlwaysOn = (CheckBoxPreference) mSoundSettings.findPreference(KEY_NOTIFICATION_ALWAYS_ON); mNotificationCharging = (CheckBoxPreference) mSoundSettings.findPreference(KEY_NOTIFICATION_CHARGING); boolean amberGreenLight = getResources().getBoolean(com.android.internal.R.bool.config_amber_green_light); if (amberGreenLight) { mSoundSettings.removePreference(mNotificationPulse); mNotificationBlink.setChecked( Settings.System.getInt(resolver, Settings.System.NOTIFICATION_LIGHT_BLINK, 1) == 1); mNotificationBlink.setOnPreferenceChangeListener(this); mNotificationAlwaysOn.setChecked( Settings.System.getInt(resolver, Settings.System.NOTIFICATION_LIGHT_ALWAYS_ON, 1) == 1); mNotificationAlwaysOn.setOnPreferenceChangeListener(this); mNotificationCharging.setChecked( Settings.System.getInt(resolver, Settings.System.NOTIFICATION_LIGHT_CHARGING, 1) == 1); mNotificationCharging.setOnPreferenceChangeListener(this); } else { mSoundSettings.removePreference(mNotificationBlink); mSoundSettings.removePreference(mNotificationAlwaysOn); mSoundSettings.removePreference(mNotificationCharging); if (mNotificationPulse != null && getResources().getBoolean(R.bool.has_intrusive_led) == false) { mSoundSettings.removePreference(mNotificationPulse); } else { try { mNotificationPulse.setChecked( Settings.System.getInt(resolver, Settings.System.NOTIFICATION_LIGHT_PULSE) == 1); mNotificationPulse.setOnPreferenceChangeListener(this); } catch (SettingNotFoundException snfe) { Log.e(TAG, Settings.System.NOTIFICATION_LIGHT_PULSE + " not found"); } } } }
/** * Recursively loop through a PreferenceGroup. Initialize native Android prefs, and build a list * of Gecko preferences in the passed in prefs array * * @param preferences The android.preference.PreferenceGroup to initialize * @param prefs An ArrayList to fill with Gecko preferences that need to be initialized * @return The integer id for the PrefsHelper.PrefHandlerBase listener added to monitor changes to * Gecko prefs. */ private void setupPreferences(PreferenceGroup preferences, ArrayList<String> prefs) { for (int i = 0; i < preferences.getPreferenceCount(); i++) { Preference pref = preferences.getPreference(i); String key = pref.getKey(); if (pref instanceof PreferenceGroup) { // If no datareporting is enabled, remove UI. if (PREFS_DATA_REPORTING_PREFERENCES.equals(key)) { if (!AppConstants.MOZ_DATA_REPORTING) { preferences.removePreference(pref); i--; continue; } } else if (pref instanceof PanelsPreferenceCategory) { mPanelsPreferenceCategory = (PanelsPreferenceCategory) pref; } setupPreferences((PreferenceGroup) pref, prefs); } else { pref.setOnPreferenceChangeListener(this); if (!AppConstants.MOZ_UPDATER && PREFS_UPDATER_AUTODOWNLOAD.equals(key)) { preferences.removePreference(pref); i--; continue; } else if (AppConstants.RELEASE_BUILD && PREFS_DISPLAY_REFLOW_ON_ZOOM.equals(key)) { // Remove UI for reflow on release builds. preferences.removePreference(pref); i--; continue; } else if (!AppConstants.MOZ_TELEMETRY_REPORTING && PREFS_TELEMETRY_ENABLED.equals(key)) { preferences.removePreference(pref); i--; continue; } else if (!AppConstants.MOZ_SERVICES_HEALTHREPORT && (PREFS_HEALTHREPORT_UPLOAD_ENABLED.equals(key) || PREFS_HEALTHREPORT_LINK.equals(key))) { preferences.removePreference(pref); i--; continue; } else if (!AppConstants.MOZ_CRASHREPORTER && PREFS_CRASHREPORTER_ENABLED.equals(key)) { preferences.removePreference(pref); i--; continue; } else if (AppConstants.RELEASE_BUILD && PREFS_GEO_REPORTING.equals(key)) { // We don't build wifi/cell tower collection in release builds, so hide the UI. preferences.removePreference(pref); i--; continue; } else if (PREFS_DEVTOOLS_REMOTE_ENABLED.equals(key)) { final Context thisContext = this; pref.setOnPreferenceClickListener( new OnPreferenceClickListener() { @Override public boolean onPreferenceClick(Preference preference) { // Display toast to remind setting up tcp forwarding. if (((CheckBoxPreference) preference).isChecked()) { Toast.makeText( thisContext, R.string.devtools_remote_debugging_forward, Toast.LENGTH_SHORT) .show(); } return true; } }); } else if (PREFS_RESTORE_SESSION.equals(key)) { // Set the summary string to the current entry. The summary // for other list prefs will be set in the PrefsHelper // callback, but since this pref doesn't live in Gecko, we // need to handle it separately. ListPreference listPref = (ListPreference) pref; CharSequence selectedEntry = listPref.getEntry(); listPref.setSummary(selectedEntry); continue; } else if (PREFS_SYNC.equals(key) && GeckoProfile.get(this).inGuestMode()) { // Don't show sync prefs while in guest mode. preferences.removePreference(pref); i--; continue; } else if (PREFS_SEARCH_RESTORE_DEFAULTS.equals(key)) { pref.setOnPreferenceClickListener( new OnPreferenceClickListener() { @Override public boolean onPreferenceClick(Preference preference) { GeckoPreferences.this.restoreDefaultSearchEngines(); return true; } }); } else if (PREFS_HOME_ADD_PANEL.equals(key)) { pref.setOnPreferenceClickListener( new OnPreferenceClickListener() { @Override public boolean onPreferenceClick(Preference preference) { Intent dialogIntent = new Intent(GeckoPreferences.this, HomePanelPicker.class); startActivityForResult(dialogIntent, HomePanelPicker.REQUEST_CODE_ADD_PANEL); return true; } }); } // Some Preference UI elements are not actually preferences, // but they require a key to work correctly. For example, // "Clear private data" requires a key for its state to be // saved when the orientation changes. It uses the // "android.not_a_preference.privacy.clear" key - which doesn't // exist in Gecko - to satisfy this requirement. if (key != null && !key.startsWith(NON_PREF_PREFIX)) { prefs.add(key); } } } }
@Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); ContentResolver resolver = getContentResolver(); int activePhoneType = TelephonyManager.getDefault().getCurrentPhoneType(); mAudioManager = (AudioManager) getSystemService(Context.AUDIO_SERVICE); addPreferencesFromResource(R.xml.sound_settings); if (TelephonyManager.PHONE_TYPE_CDMA != activePhoneType) { // device is not CDMA, do not display CDMA emergency_tone getPreferenceScreen().removePreference(findPreference(KEY_EMERGENCY_TONE)); } mVolumeOverlay = (ListPreference) findPreference(KEY_VOLUME_OVERLAY); mVolumeOverlay.setOnPreferenceChangeListener(this); int volumeOverlay = Settings.System.getInt( getContentResolver(), Settings.System.MODE_VOLUME_OVERLAY, VolumePanel.VOLUME_OVERLAY_EXPANDABLE); mVolumeOverlay.setValue(Integer.toString(volumeOverlay)); mVolumeOverlay.setSummary(mVolumeOverlay.getEntry()); mRingMode = (ListPreference) findPreference(KEY_RING_MODE); if (!getResources().getBoolean(R.bool.has_silent_mode)) { getPreferenceScreen().removePreference(mRingMode); findPreference(KEY_RING_VOLUME).setDependency(null); } else { mRingMode.setOnPreferenceChangeListener(this); } if (getResources().getBoolean(com.android.internal.R.bool.config_useFixedVolume)) { // device with fixed volume policy, do not display volumes submenu getPreferenceScreen().removePreference(findPreference(KEY_RING_VOLUME)); } mQuietHours = (PreferenceScreen) findPreference(KEY_QUIET_HOURS); updateQuietHoursSummary(); mSoundEffects = (CheckBoxPreference) findPreference(KEY_SOUND_EFFECTS); if (!Utils.hasVolumeRocker(getActivity())) { getPreferenceScreen().removePreference(findPreference(KEY_VOLUME_ADJUST_SOUNDS)); } mRingtonePreference = findPreference(KEY_RINGTONE); mNotificationPreference = findPreference(KEY_NOTIFICATION_SOUND); Vibrator vibrator = (Vibrator) getSystemService(Context.VIBRATOR_SERVICE); if (vibrator == null || !vibrator.hasVibrator()) { removePreference(KEY_VIBRATE); removePreference(KEY_HAPTIC_FEEDBACK); removePreference(KEY_VIBRATION_INTENSITY); removePreference(KEY_CONVERT_SOUND_TO_VIBRATE); removePreference(KEY_VIBRATE_DURING_CALLS); } else if (!VibratorIntensity.isSupported()) { removePreference(KEY_VIBRATION_INTENSITY); } if (TelephonyManager.PHONE_TYPE_CDMA == activePhoneType) { ListPreference emergencyTonePreference = (ListPreference) findPreference(KEY_EMERGENCY_TONE); emergencyTonePreference.setValue( String.valueOf( Settings.Global.getInt( resolver, Settings.Global.EMERGENCY_TONE, FALLBACK_EMERGENCY_TONE_VALUE))); emergencyTonePreference.setOnPreferenceChangeListener(this); } mSoundSettings = (PreferenceGroup) findPreference(KEY_SOUND_SETTINGS); mMusicFx = mSoundSettings.findPreference(KEY_MUSICFX); Intent i = new Intent(AudioEffect.ACTION_DISPLAY_AUDIO_EFFECT_CONTROL_PANEL); mMusicFx.setIntent(i); PackageManager p = getPackageManager(); List<ResolveInfo> ris = p.queryIntentActivities(i, 0); if (ris.size() == 0) { mSoundSettings.removePreference(mMusicFx); } else if (ris.size() == 1) { mMusicFx.setSummary(ris.get(0).loadLabel(p)); } if (!Utils.isVoiceCapable(getActivity())) { for (String prefKey : NEED_VOICE_CAPABILITY) { Preference pref = findPreference(prefKey); if (pref != null) { getPreferenceScreen().removePreference(pref); } } mRingtonePreference = null; } mRingtoneLookupRunnable = new Runnable() { public void run() { if (mRingtonePreference != null) { updateRingtoneName( RingtoneManager.TYPE_RINGTONE, mRingtonePreference, MSG_UPDATE_RINGTONE_SUMMARY); } if (mNotificationPreference != null) { updateRingtoneName( RingtoneManager.TYPE_NOTIFICATION, mNotificationPreference, MSG_UPDATE_NOTIFICATION_SUMMARY); } } }; // power state change notification sounds mPowerSounds = (CheckBoxPreference) findPreference(KEY_POWER_NOTIFICATIONS); mPowerSounds.setChecked( Settings.Global.getInt(resolver, Settings.Global.POWER_NOTIFICATIONS_ENABLED, 0) != 0); mPowerSoundsVibrate = (CheckBoxPreference) findPreference(KEY_POWER_NOTIFICATIONS_VIBRATE); mPowerSoundsVibrate.setChecked( Settings.Global.getInt(resolver, Settings.Global.POWER_NOTIFICATIONS_VIBRATE, 0) != 0); if (vibrator == null || !vibrator.hasVibrator()) { removePreference(KEY_POWER_NOTIFICATIONS_VIBRATE); } mPowerSoundsRingtone = findPreference(KEY_POWER_NOTIFICATIONS_RINGTONE); String currentPowerRingtonePath = Settings.Global.getString(resolver, Settings.Global.POWER_NOTIFICATIONS_RINGTONE); // set to default notification if we don't yet have one if (currentPowerRingtonePath == null) { currentPowerRingtonePath = Settings.System.DEFAULT_NOTIFICATION_URI.toString(); Settings.Global.putString( getContentResolver(), Settings.Global.POWER_NOTIFICATIONS_RINGTONE, currentPowerRingtonePath); } // is it silent ? if (currentPowerRingtonePath.equals(POWER_NOTIFICATIONS_SILENT_URI)) { mPowerSoundsRingtone.setSummary(getString(R.string.power_notifications_ringtone_silent)); } else { final Ringtone ringtone = RingtoneManager.getRingtone(getActivity(), Uri.parse(currentPowerRingtonePath)); if (ringtone != null) { mPowerSoundsRingtone.setSummary(ringtone.getTitle(getActivity())); } } initDockSettings(); }