| /* |
| * Copyright (C) 2009 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.settings.accessibility; |
| |
| import android.accessibilityservice.AccessibilityServiceInfo; |
| import android.app.admin.DevicePolicyManager; |
| import android.content.ComponentName; |
| import android.content.Context; |
| import android.content.pm.PackageManager; |
| import android.content.pm.ServiceInfo; |
| import android.content.res.Resources; |
| import android.net.Uri; |
| import android.os.Bundle; |
| import android.os.Handler; |
| import android.os.RemoteException; |
| import android.os.UserHandle; |
| import android.provider.SearchIndexableResource; |
| import android.provider.Settings; |
| import android.support.v14.preference.SwitchPreference; |
| import android.support.v7.preference.ListPreference; |
| import android.support.v7.preference.Preference; |
| import android.support.v7.preference.PreferenceCategory; |
| import android.support.v7.preference.PreferenceScreen; |
| import android.text.TextUtils; |
| import android.view.KeyCharacterMap; |
| import android.view.KeyEvent; |
| import android.view.accessibility.AccessibilityManager; |
| |
| import com.android.internal.content.PackageMonitor; |
| import com.android.internal.logging.MetricsProto.MetricsEvent; |
| import com.android.internal.view.RotationPolicy; |
| import com.android.internal.view.RotationPolicy.RotationPolicyListener; |
| import com.android.settings.DialogCreatable; |
| import com.android.settings.R; |
| import com.android.settings.SettingsPreferenceFragment; |
| import com.android.settings.Utils; |
| import com.android.settings.search.BaseSearchIndexProvider; |
| import com.android.settings.search.Indexable; |
| import com.android.settings.search.SearchIndexableRaw; |
| import com.android.settingslib.RestrictedLockUtils; |
| import com.android.settingslib.RestrictedLockUtils.EnforcedAdmin; |
| import com.android.settingslib.RestrictedPreference; |
| import com.android.settingslib.accessibility.AccessibilityUtils; |
| |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| /** |
| * Activity with the accessibility settings. |
| */ |
| public class AccessibilitySettings extends SettingsPreferenceFragment implements DialogCreatable, |
| Preference.OnPreferenceChangeListener, Indexable { |
| |
| // Preference categories |
| private static final String SERVICES_CATEGORY = "services_category"; |
| private static final String SYSTEM_CATEGORY = "system_category"; |
| |
| // Preferences |
| private static final String TOGGLE_HIGH_TEXT_CONTRAST_PREFERENCE = |
| "toggle_high_text_contrast_preference"; |
| private static final String TOGGLE_INVERSION_PREFERENCE = |
| "toggle_inversion_preference"; |
| private static final String TOGGLE_POWER_BUTTON_ENDS_CALL_PREFERENCE = |
| "toggle_power_button_ends_call_preference"; |
| private static final String TOGGLE_LOCK_SCREEN_ROTATION_PREFERENCE = |
| "toggle_lock_screen_rotation_preference"; |
| private static final String TOGGLE_SPEAK_PASSWORD_PREFERENCE = |
| "toggle_speak_password_preference"; |
| private static final String TOGGLE_LARGE_POINTER_ICON = |
| "toggle_large_pointer_icon"; |
| private static final String TOGGLE_MASTER_MONO = |
| "toggle_master_mono"; |
| private static final String SELECT_LONG_PRESS_TIMEOUT_PREFERENCE = |
| "select_long_press_timeout_preference"; |
| private static final String ENABLE_ACCESSIBILITY_GESTURE_PREFERENCE_SCREEN = |
| "enable_global_gesture_preference_screen"; |
| private static final String CAPTIONING_PREFERENCE_SCREEN = |
| "captioning_preference_screen"; |
| private static final String DISPLAY_MAGNIFICATION_PREFERENCE_SCREEN = |
| "screen_magnification_preference_screen"; |
| private static final String FONT_SIZE_PREFERENCE_SCREEN = |
| "font_size_preference_screen"; |
| private static final String AUTOCLICK_PREFERENCE_SCREEN = |
| "autoclick_preference_screen"; |
| private static final String DISPLAY_DALTONIZER_PREFERENCE_SCREEN = |
| "daltonizer_preference_screen"; |
| |
| // Extras passed to sub-fragments. |
| static final String EXTRA_PREFERENCE_KEY = "preference_key"; |
| static final String EXTRA_CHECKED = "checked"; |
| static final String EXTRA_TITLE = "title"; |
| static final String EXTRA_SUMMARY = "summary"; |
| static final String EXTRA_SETTINGS_TITLE = "settings_title"; |
| static final String EXTRA_COMPONENT_NAME = "component_name"; |
| static final String EXTRA_SETTINGS_COMPONENT_NAME = "settings_component_name"; |
| |
| // Timeout before we update the services if packages are added/removed |
| // since the AccessibilityManagerService has to do that processing first |
| // to generate the AccessibilityServiceInfo we need for proper |
| // presentation. |
| private static final long DELAY_UPDATE_SERVICES_MILLIS = 1000; |
| |
| // Auxiliary members. |
| static final Set<ComponentName> sInstalledServices = new HashSet<>(); |
| |
| private final Map<String, String> mLongPressTimeoutValuetoTitleMap = new HashMap<>(); |
| |
| private final Handler mHandler = new Handler(); |
| |
| private final Runnable mUpdateRunnable = new Runnable() { |
| @Override |
| public void run() { |
| if (getActivity() != null) { |
| updateServicesPreferences(); |
| } |
| } |
| }; |
| |
| private final PackageMonitor mSettingsPackageMonitor = new PackageMonitor() { |
| @Override |
| public void onPackageAdded(String packageName, int uid) { |
| sendUpdate(); |
| } |
| |
| @Override |
| public void onPackageAppeared(String packageName, int reason) { |
| sendUpdate(); |
| } |
| |
| @Override |
| public void onPackageDisappeared(String packageName, int reason) { |
| sendUpdate(); |
| } |
| |
| @Override |
| public void onPackageRemoved(String packageName, int uid) { |
| sendUpdate(); |
| } |
| |
| private void sendUpdate() { |
| mHandler.postDelayed(mUpdateRunnable, DELAY_UPDATE_SERVICES_MILLIS); |
| } |
| }; |
| |
| private final SettingsContentObserver mSettingsContentObserver = |
| new SettingsContentObserver(mHandler) { |
| @Override |
| public void onChange(boolean selfChange, Uri uri) { |
| updateServicesPreferences(); |
| } |
| }; |
| |
| private final RotationPolicyListener mRotationPolicyListener = new RotationPolicyListener() { |
| @Override |
| public void onChange() { |
| updateLockScreenRotationCheckbox(); |
| } |
| }; |
| |
| // Preference controls. |
| private PreferenceCategory mServicesCategory; |
| private PreferenceCategory mSystemsCategory; |
| |
| private SwitchPreference mToggleHighTextContrastPreference; |
| private SwitchPreference mTogglePowerButtonEndsCallPreference; |
| private SwitchPreference mToggleLockScreenRotationPreference; |
| private SwitchPreference mToggleSpeakPasswordPreference; |
| private SwitchPreference mToggleLargePointerIconPreference; |
| private SwitchPreference mToggleMasterMonoPreference; |
| private ListPreference mSelectLongPressTimeoutPreference; |
| private Preference mNoServicesMessagePreference; |
| private PreferenceScreen mCaptioningPreferenceScreen; |
| private PreferenceScreen mDisplayMagnificationPreferenceScreen; |
| private PreferenceScreen mFontSizePreferenceScreen; |
| private PreferenceScreen mAutoclickPreferenceScreen; |
| private PreferenceScreen mGlobalGesturePreferenceScreen; |
| private PreferenceScreen mDisplayDaltonizerPreferenceScreen; |
| private SwitchPreference mToggleInversionPreference; |
| |
| private int mLongPressTimeoutDefault; |
| |
| private DevicePolicyManager mDpm; |
| |
| @Override |
| protected int getMetricsCategory() { |
| return MetricsEvent.ACCESSIBILITY; |
| } |
| |
| @Override |
| protected int getHelpResource() { |
| return R.string.help_uri_accessibility; |
| } |
| |
| @Override |
| public void onCreate(Bundle icicle) { |
| super.onCreate(icicle); |
| addPreferencesFromResource(R.xml.accessibility_settings); |
| initializeAllPreferences(); |
| mDpm = (DevicePolicyManager) (getActivity() |
| .getSystemService(Context.DEVICE_POLICY_SERVICE)); |
| } |
| |
| @Override |
| public void onResume() { |
| super.onResume(); |
| updateAllPreferences(); |
| |
| mSettingsPackageMonitor.register(getActivity(), getActivity().getMainLooper(), false); |
| mSettingsContentObserver.register(getContentResolver()); |
| if (RotationPolicy.isRotationSupported(getActivity())) { |
| RotationPolicy.registerRotationPolicyListener(getActivity(), |
| mRotationPolicyListener); |
| } |
| } |
| |
| @Override |
| public void onPause() { |
| mSettingsPackageMonitor.unregister(); |
| mSettingsContentObserver.unregister(getContentResolver()); |
| if (RotationPolicy.isRotationSupported(getActivity())) { |
| RotationPolicy.unregisterRotationPolicyListener(getActivity(), |
| mRotationPolicyListener); |
| } |
| super.onPause(); |
| } |
| |
| @Override |
| public boolean onPreferenceChange(Preference preference, Object newValue) { |
| if (mSelectLongPressTimeoutPreference == preference) { |
| handleLongPressTimeoutPreferenceChange((String) newValue); |
| return true; |
| } else if (mToggleInversionPreference == preference) { |
| handleToggleInversionPreferenceChange((Boolean) newValue); |
| return true; |
| } |
| return false; |
| } |
| |
| private void handleLongPressTimeoutPreferenceChange(String stringValue) { |
| Settings.Secure.putInt(getContentResolver(), |
| Settings.Secure.LONG_PRESS_TIMEOUT, Integer.parseInt(stringValue)); |
| mSelectLongPressTimeoutPreference.setSummary( |
| mLongPressTimeoutValuetoTitleMap.get(stringValue)); |
| } |
| |
| private void handleToggleInversionPreferenceChange(boolean checked) { |
| Settings.Secure.putInt(getContentResolver(), |
| Settings.Secure.ACCESSIBILITY_DISPLAY_INVERSION_ENABLED, (checked ? 1 : 0)); |
| } |
| |
| @Override |
| public boolean onPreferenceTreeClick(Preference preference) { |
| if (mToggleHighTextContrastPreference == preference) { |
| handleToggleTextContrastPreferenceClick(); |
| return true; |
| } else if (mTogglePowerButtonEndsCallPreference == preference) { |
| handleTogglePowerButtonEndsCallPreferenceClick(); |
| return true; |
| } else if (mToggleLockScreenRotationPreference == preference) { |
| handleLockScreenRotationPreferenceClick(); |
| return true; |
| } else if (mToggleSpeakPasswordPreference == preference) { |
| handleToggleSpeakPasswordPreferenceClick(); |
| return true; |
| } else if (mToggleLargePointerIconPreference == preference) { |
| handleToggleLargePointerIconPreferenceClick(); |
| return true; |
| } else if (mToggleMasterMonoPreference == preference) { |
| handleToggleMasterMonoPreferenceClick(); |
| return true; |
| } else if (mGlobalGesturePreferenceScreen == preference) { |
| handleToggleEnableAccessibilityGesturePreferenceClick(); |
| return true; |
| } else if (mDisplayMagnificationPreferenceScreen == preference) { |
| handleDisplayMagnificationPreferenceScreenClick(); |
| return true; |
| } |
| return super.onPreferenceTreeClick(preference); |
| } |
| |
| private void handleToggleTextContrastPreferenceClick() { |
| Settings.Secure.putInt(getContentResolver(), |
| Settings.Secure.ACCESSIBILITY_HIGH_TEXT_CONTRAST_ENABLED, |
| (mToggleHighTextContrastPreference.isChecked() ? 1 : 0)); |
| } |
| |
| private void handleTogglePowerButtonEndsCallPreferenceClick() { |
| Settings.Secure.putInt(getContentResolver(), |
| Settings.Secure.INCALL_POWER_BUTTON_BEHAVIOR, |
| (mTogglePowerButtonEndsCallPreference.isChecked() |
| ? Settings.Secure.INCALL_POWER_BUTTON_BEHAVIOR_HANGUP |
| : Settings.Secure.INCALL_POWER_BUTTON_BEHAVIOR_SCREEN_OFF)); |
| } |
| |
| private void handleLockScreenRotationPreferenceClick() { |
| RotationPolicy.setRotationLockForAccessibility(getActivity(), |
| !mToggleLockScreenRotationPreference.isChecked()); |
| } |
| |
| private void handleToggleSpeakPasswordPreferenceClick() { |
| Settings.Secure.putInt(getContentResolver(), |
| Settings.Secure.ACCESSIBILITY_SPEAK_PASSWORD, |
| mToggleSpeakPasswordPreference.isChecked() ? 1 : 0); |
| } |
| |
| private void handleToggleLargePointerIconPreferenceClick() { |
| Settings.Secure.putInt(getContentResolver(), |
| Settings.Secure.ACCESSIBILITY_LARGE_POINTER_ICON, |
| mToggleLargePointerIconPreference.isChecked() ? 1 : 0); |
| } |
| |
| private void handleToggleMasterMonoPreferenceClick() { |
| Settings.System.putIntForUser(getContentResolver(), Settings.System.MASTER_MONO, |
| mToggleMasterMonoPreference.isChecked() ? 1 : 0, UserHandle.USER_CURRENT); |
| } |
| |
| private void handleToggleEnableAccessibilityGesturePreferenceClick() { |
| Bundle extras = mGlobalGesturePreferenceScreen.getExtras(); |
| extras.putString(EXTRA_TITLE, getString( |
| R.string.accessibility_global_gesture_preference_title)); |
| extras.putString(EXTRA_SUMMARY, getString( |
| R.string.accessibility_global_gesture_preference_description)); |
| extras.putBoolean(EXTRA_CHECKED, Settings.Global.getInt(getContentResolver(), |
| Settings.Global.ENABLE_ACCESSIBILITY_GLOBAL_GESTURE_ENABLED, 0) == 1); |
| super.onPreferenceTreeClick(mGlobalGesturePreferenceScreen); |
| } |
| |
| private void handleDisplayMagnificationPreferenceScreenClick() { |
| Bundle extras = mDisplayMagnificationPreferenceScreen.getExtras(); |
| extras.putString(EXTRA_TITLE, getString( |
| R.string.accessibility_screen_magnification_title)); |
| extras.putCharSequence(EXTRA_SUMMARY, getActivity().getResources().getText( |
| R.string.accessibility_screen_magnification_summary)); |
| extras.putBoolean(EXTRA_CHECKED, Settings.Secure.getInt(getContentResolver(), |
| Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED, 0) == 1); |
| super.onPreferenceTreeClick(mDisplayMagnificationPreferenceScreen); |
| } |
| |
| private void initializeAllPreferences() { |
| mServicesCategory = (PreferenceCategory) findPreference(SERVICES_CATEGORY); |
| mSystemsCategory = (PreferenceCategory) findPreference(SYSTEM_CATEGORY); |
| |
| // Text contrast. |
| mToggleHighTextContrastPreference = |
| (SwitchPreference) findPreference(TOGGLE_HIGH_TEXT_CONTRAST_PREFERENCE); |
| |
| // Display inversion. |
| mToggleInversionPreference = (SwitchPreference) findPreference(TOGGLE_INVERSION_PREFERENCE); |
| mToggleInversionPreference.setOnPreferenceChangeListener(this); |
| |
| // Power button ends calls. |
| mTogglePowerButtonEndsCallPreference = |
| (SwitchPreference) findPreference(TOGGLE_POWER_BUTTON_ENDS_CALL_PREFERENCE); |
| if (!KeyCharacterMap.deviceHasKey(KeyEvent.KEYCODE_POWER) |
| || !Utils.isVoiceCapable(getActivity())) { |
| mSystemsCategory.removePreference(mTogglePowerButtonEndsCallPreference); |
| } |
| |
| // Lock screen rotation. |
| mToggleLockScreenRotationPreference = |
| (SwitchPreference) findPreference(TOGGLE_LOCK_SCREEN_ROTATION_PREFERENCE); |
| if (!RotationPolicy.isRotationSupported(getActivity())) { |
| mSystemsCategory.removePreference(mToggleLockScreenRotationPreference); |
| } |
| |
| // Speak passwords. |
| mToggleSpeakPasswordPreference = |
| (SwitchPreference) findPreference(TOGGLE_SPEAK_PASSWORD_PREFERENCE); |
| |
| // Large pointer icon. |
| mToggleLargePointerIconPreference = |
| (SwitchPreference) findPreference(TOGGLE_LARGE_POINTER_ICON); |
| |
| // Master Mono |
| mToggleMasterMonoPreference = |
| (SwitchPreference) findPreference(TOGGLE_MASTER_MONO); |
| |
| // Long press timeout. |
| mSelectLongPressTimeoutPreference = |
| (ListPreference) findPreference(SELECT_LONG_PRESS_TIMEOUT_PREFERENCE); |
| mSelectLongPressTimeoutPreference.setOnPreferenceChangeListener(this); |
| if (mLongPressTimeoutValuetoTitleMap.size() == 0) { |
| String[] timeoutValues = getResources().getStringArray( |
| R.array.long_press_timeout_selector_values); |
| mLongPressTimeoutDefault = Integer.parseInt(timeoutValues[0]); |
| String[] timeoutTitles = getResources().getStringArray( |
| R.array.long_press_timeout_selector_titles); |
| final int timeoutValueCount = timeoutValues.length; |
| for (int i = 0; i < timeoutValueCount; i++) { |
| mLongPressTimeoutValuetoTitleMap.put(timeoutValues[i], timeoutTitles[i]); |
| } |
| } |
| |
| // Captioning. |
| mCaptioningPreferenceScreen = (PreferenceScreen) findPreference( |
| CAPTIONING_PREFERENCE_SCREEN); |
| |
| // Display magnification. |
| mDisplayMagnificationPreferenceScreen = (PreferenceScreen) findPreference( |
| DISPLAY_MAGNIFICATION_PREFERENCE_SCREEN); |
| |
| // Font size. |
| mFontSizePreferenceScreen = (PreferenceScreen) findPreference( |
| FONT_SIZE_PREFERENCE_SCREEN); |
| |
| // Autoclick after pointer stops. |
| mAutoclickPreferenceScreen = (PreferenceScreen) findPreference( |
| AUTOCLICK_PREFERENCE_SCREEN); |
| |
| // Display color adjustments. |
| mDisplayDaltonizerPreferenceScreen = (PreferenceScreen) findPreference( |
| DISPLAY_DALTONIZER_PREFERENCE_SCREEN); |
| |
| // Global gesture. |
| mGlobalGesturePreferenceScreen = |
| (PreferenceScreen) findPreference(ENABLE_ACCESSIBILITY_GESTURE_PREFERENCE_SCREEN); |
| final int longPressOnPowerBehavior = getActivity().getResources().getInteger( |
| com.android.internal.R.integer.config_longPressOnPowerBehavior); |
| final int LONG_PRESS_POWER_GLOBAL_ACTIONS = 1; |
| if (!KeyCharacterMap.deviceHasKey(KeyEvent.KEYCODE_POWER) |
| || longPressOnPowerBehavior != LONG_PRESS_POWER_GLOBAL_ACTIONS) { |
| // Remove accessibility shortcut if power key is not present |
| // nor long press power does not show global actions menu. |
| mSystemsCategory.removePreference(mGlobalGesturePreferenceScreen); |
| } |
| } |
| |
| private void updateAllPreferences() { |
| updateServicesPreferences(); |
| updateSystemPreferences(); |
| } |
| |
| private void updateServicesPreferences() { |
| // Since services category is auto generated we have to do a pass |
| // to generate it since services can come and go and then based on |
| // the global accessibility state to decided whether it is enabled. |
| |
| // Generate. |
| mServicesCategory.removeAll(); |
| |
| AccessibilityManager accessibilityManager = AccessibilityManager.getInstance(getActivity()); |
| |
| List<AccessibilityServiceInfo> installedServices = |
| accessibilityManager.getInstalledAccessibilityServiceList(); |
| Set<ComponentName> enabledServices = AccessibilityUtils.getEnabledServicesFromSettings( |
| getActivity()); |
| List<String> permittedServices = mDpm.getPermittedAccessibilityServices( |
| UserHandle.myUserId()); |
| final boolean accessibilityEnabled = Settings.Secure.getInt(getContentResolver(), |
| Settings.Secure.ACCESSIBILITY_ENABLED, 0) == 1; |
| |
| for (int i = 0, count = installedServices.size(); i < count; ++i) { |
| AccessibilityServiceInfo info = installedServices.get(i); |
| |
| RestrictedPreference preference = new RestrictedPreference(getActivity()); |
| String title = info.getResolveInfo().loadLabel(getPackageManager()).toString(); |
| |
| ServiceInfo serviceInfo = info.getResolveInfo().serviceInfo; |
| ComponentName componentName = new ComponentName(serviceInfo.packageName, |
| serviceInfo.name); |
| |
| preference.setKey(componentName.flattenToString()); |
| |
| preference.setTitle(title); |
| final boolean serviceEnabled = accessibilityEnabled |
| && enabledServices.contains(componentName); |
| String serviceEnabledString; |
| if (serviceEnabled) { |
| serviceEnabledString = getString(R.string.accessibility_feature_state_on); |
| } else { |
| serviceEnabledString = getString(R.string.accessibility_feature_state_off); |
| } |
| |
| // Disable all accessibility services that are not permitted. |
| String packageName = serviceInfo.packageName; |
| boolean serviceAllowed = |
| permittedServices == null || permittedServices.contains(packageName); |
| if (!serviceAllowed && !serviceEnabled) { |
| EnforcedAdmin admin = RestrictedLockUtils.checkIfAccessibilityServiceDisallowed( |
| getActivity(), serviceInfo.packageName, UserHandle.myUserId()); |
| if (admin != null) { |
| preference.setDisabledByAdmin(admin); |
| } else { |
| preference.setEnabled(false); |
| } |
| } else { |
| preference.setEnabled(true); |
| } |
| |
| preference.setSummary(serviceEnabledString); |
| |
| preference.setOrder(i); |
| preference.setFragment(ToggleAccessibilityServicePreferenceFragment.class.getName()); |
| preference.setPersistent(true); |
| |
| Bundle extras = preference.getExtras(); |
| extras.putString(EXTRA_PREFERENCE_KEY, preference.getKey()); |
| extras.putBoolean(EXTRA_CHECKED, serviceEnabled); |
| extras.putString(EXTRA_TITLE, title); |
| |
| String description = info.loadDescription(getPackageManager()); |
| if (TextUtils.isEmpty(description)) { |
| description = getString(R.string.accessibility_service_default_description); |
| } |
| extras.putString(EXTRA_SUMMARY, description); |
| |
| String settingsClassName = info.getSettingsActivityName(); |
| if (!TextUtils.isEmpty(settingsClassName)) { |
| extras.putString(EXTRA_SETTINGS_TITLE, |
| getString(R.string.accessibility_menu_item_settings)); |
| extras.putString(EXTRA_SETTINGS_COMPONENT_NAME, |
| new ComponentName(info.getResolveInfo().serviceInfo.packageName, |
| settingsClassName).flattenToString()); |
| } |
| |
| extras.putParcelable(EXTRA_COMPONENT_NAME, componentName); |
| |
| mServicesCategory.addPreference(preference); |
| } |
| |
| if (mServicesCategory.getPreferenceCount() == 0) { |
| if (mNoServicesMessagePreference == null) { |
| mNoServicesMessagePreference = new Preference(getPrefContext()); |
| mNoServicesMessagePreference.setPersistent(false); |
| mNoServicesMessagePreference.setLayoutResource( |
| R.layout.text_description_preference); |
| mNoServicesMessagePreference.setSelectable(false); |
| mNoServicesMessagePreference.setSummary( |
| getString(R.string.accessibility_no_services_installed)); |
| } |
| mServicesCategory.addPreference(mNoServicesMessagePreference); |
| } |
| } |
| |
| private void updateSystemPreferences() { |
| // Text contrast. |
| mToggleHighTextContrastPreference.setChecked( |
| Settings.Secure.getInt(getContentResolver(), |
| Settings.Secure.ACCESSIBILITY_HIGH_TEXT_CONTRAST_ENABLED, 0) == 1); |
| |
| // If the quick setting is enabled, the preference MUST be enabled. |
| mToggleInversionPreference.setChecked(Settings.Secure.getInt(getContentResolver(), |
| Settings.Secure.ACCESSIBILITY_DISPLAY_INVERSION_ENABLED, 0) == 1); |
| |
| // Power button ends calls. |
| if (KeyCharacterMap.deviceHasKey(KeyEvent.KEYCODE_POWER) |
| && Utils.isVoiceCapable(getActivity())) { |
| final int incallPowerBehavior = Settings.Secure.getInt(getContentResolver(), |
| Settings.Secure.INCALL_POWER_BUTTON_BEHAVIOR, |
| Settings.Secure.INCALL_POWER_BUTTON_BEHAVIOR_DEFAULT); |
| final boolean powerButtonEndsCall = |
| (incallPowerBehavior == Settings.Secure.INCALL_POWER_BUTTON_BEHAVIOR_HANGUP); |
| mTogglePowerButtonEndsCallPreference.setChecked(powerButtonEndsCall); |
| } |
| |
| // Auto-rotate screen |
| updateLockScreenRotationCheckbox(); |
| |
| // Speak passwords. |
| final boolean speakPasswordEnabled = Settings.Secure.getInt(getContentResolver(), |
| Settings.Secure.ACCESSIBILITY_SPEAK_PASSWORD, 0) != 0; |
| mToggleSpeakPasswordPreference.setChecked(speakPasswordEnabled); |
| |
| // Large pointer icon. |
| mToggleLargePointerIconPreference.setChecked(Settings.Secure.getInt(getContentResolver(), |
| Settings.Secure.ACCESSIBILITY_LARGE_POINTER_ICON, 0) != 0); |
| |
| // Master mono |
| updateMasterMono(); |
| |
| // Long press timeout. |
| final int longPressTimeout = Settings.Secure.getInt(getContentResolver(), |
| Settings.Secure.LONG_PRESS_TIMEOUT, mLongPressTimeoutDefault); |
| String value = String.valueOf(longPressTimeout); |
| mSelectLongPressTimeoutPreference.setValue(value); |
| mSelectLongPressTimeoutPreference.setSummary(mLongPressTimeoutValuetoTitleMap.get(value)); |
| |
| updateFeatureSummary(Settings.Secure.ACCESSIBILITY_CAPTIONING_ENABLED, |
| mCaptioningPreferenceScreen); |
| updateFeatureSummary(Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED, |
| mDisplayMagnificationPreferenceScreen); |
| updateFeatureSummary(Settings.Secure.ACCESSIBILITY_DISPLAY_DALTONIZER_ENABLED, |
| mDisplayDaltonizerPreferenceScreen); |
| |
| updateFontSizeSummary(mFontSizePreferenceScreen); |
| |
| updateAutoclickSummary(mAutoclickPreferenceScreen); |
| |
| // Global gesture |
| final boolean globalGestureEnabled = Settings.Global.getInt(getContentResolver(), |
| Settings.Global.ENABLE_ACCESSIBILITY_GLOBAL_GESTURE_ENABLED, 0) == 1; |
| if (globalGestureEnabled) { |
| mGlobalGesturePreferenceScreen.setSummary( |
| R.string.accessibility_global_gesture_preference_summary_on); |
| } else { |
| mGlobalGesturePreferenceScreen.setSummary( |
| R.string.accessibility_global_gesture_preference_summary_off); |
| } |
| } |
| |
| private void updateFeatureSummary(String prefKey, Preference pref) { |
| final boolean enabled = Settings.Secure.getInt(getContentResolver(), prefKey, 0) == 1; |
| pref.setSummary(enabled ? R.string.accessibility_feature_state_on |
| : R.string.accessibility_feature_state_off); |
| } |
| |
| private void updateAutoclickSummary(Preference pref) { |
| final boolean enabled = Settings.Secure.getInt( |
| getContentResolver(), Settings.Secure.ACCESSIBILITY_AUTOCLICK_ENABLED, 0) == 1; |
| if (!enabled) { |
| pref.setSummary(R.string.accessibility_feature_state_off); |
| return; |
| } |
| int delay = Settings.Secure.getInt( |
| getContentResolver(), Settings.Secure.ACCESSIBILITY_AUTOCLICK_DELAY, |
| AccessibilityManager.AUTOCLICK_DELAY_DEFAULT); |
| pref.setSummary(ToggleAutoclickPreferenceFragment.getAutoclickPreferenceSummary( |
| getResources(), delay)); |
| } |
| |
| private void updateFontSizeSummary(Preference pref) { |
| final float currentScale = Settings.System.getFloat(getContext().getContentResolver(), |
| Settings.System.FONT_SCALE, 1.0f); |
| final Resources res = getContext().getResources(); |
| final String[] entries = res.getStringArray(R.array.entries_font_size); |
| final String[] strEntryValues = res.getStringArray(R.array.entryvalues_font_size); |
| final int index = ToggleFontSizePreferenceFragment.fontSizeValueToIndex(currentScale, |
| strEntryValues); |
| pref.setSummary(entries[index]); |
| } |
| |
| private void updateLockScreenRotationCheckbox() { |
| Context context = getActivity(); |
| if (context != null) { |
| mToggleLockScreenRotationPreference.setChecked( |
| !RotationPolicy.isRotationLocked(context)); |
| } |
| } |
| |
| private void updateMasterMono() { |
| final boolean masterMono = Settings.System.getIntForUser( |
| getContentResolver(), Settings.System.MASTER_MONO, |
| 0 /* default */, UserHandle.USER_CURRENT) == 1; |
| mToggleMasterMonoPreference.setChecked(masterMono); |
| } |
| |
| public static final SearchIndexProvider SEARCH_INDEX_DATA_PROVIDER = |
| new BaseSearchIndexProvider() { |
| @Override |
| public List<SearchIndexableRaw> getRawDataToIndex(Context context, boolean enabled) { |
| List<SearchIndexableRaw> indexables = new ArrayList<SearchIndexableRaw>(); |
| |
| PackageManager packageManager = context.getPackageManager(); |
| AccessibilityManager accessibilityManager = (AccessibilityManager) |
| context.getSystemService(Context.ACCESSIBILITY_SERVICE); |
| |
| String screenTitle = context.getResources().getString( |
| R.string.accessibility_services_title); |
| |
| // Indexing all services, regardless if enabled. |
| List<AccessibilityServiceInfo> services = accessibilityManager |
| .getInstalledAccessibilityServiceList(); |
| final int serviceCount = services.size(); |
| for (int i = 0; i < serviceCount; i++) { |
| AccessibilityServiceInfo service = services.get(i); |
| if (service == null || service.getResolveInfo() == null) { |
| continue; |
| } |
| |
| ServiceInfo serviceInfo = service.getResolveInfo().serviceInfo; |
| ComponentName componentName = new ComponentName(serviceInfo.packageName, |
| serviceInfo.name); |
| |
| SearchIndexableRaw indexable = new SearchIndexableRaw(context); |
| indexable.key = componentName.flattenToString(); |
| indexable.title = service.getResolveInfo().loadLabel(packageManager).toString(); |
| indexable.summaryOn = context.getString(R.string.accessibility_feature_state_on); |
| indexable.summaryOff = context.getString(R.string.accessibility_feature_state_off); |
| indexable.screenTitle = screenTitle; |
| indexables.add(indexable); |
| } |
| |
| return indexables; |
| } |
| |
| @Override |
| public List<SearchIndexableResource> getXmlResourcesToIndex(Context context, |
| boolean enabled) { |
| List<SearchIndexableResource> indexables = new ArrayList<SearchIndexableResource>(); |
| SearchIndexableResource indexable = new SearchIndexableResource(context); |
| indexable.xmlResId = R.xml.accessibility_settings; |
| indexables.add(indexable); |
| return indexables; |
| } |
| }; |
| } |
