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();
}
