/* * 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 sInstalledServices = new HashSet<>(); private final Map 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 installedServices = accessibilityManager.getInstalledAccessibilityServiceList(); Set enabledServices = AccessibilityUtils.getEnabledServicesFromSettings( getActivity()); List 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 getRawDataToIndex(Context context, boolean enabled) { List indexables = new ArrayList(); 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 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 getXmlResourcesToIndex(Context context, boolean enabled) { List indexables = new ArrayList(); SearchIndexableResource indexable = new SearchIndexableResource(context); indexable.xmlResId = R.xml.accessibility_settings; indexables.add(indexable); return indexables; } }; }