/* * 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 static android.os.Vibrator.VibrationIntensity; import static com.android.settingslib.TwoTargetPreference.ICON_SIZE_MEDIUM; import android.accessibilityservice.AccessibilityServiceInfo; import android.app.admin.DevicePolicyManager; import android.app.settings.SettingsEnums; import android.content.ComponentName; import android.content.ContentResolver; import android.content.Context; import android.content.pm.ResolveInfo; import android.content.pm.ServiceInfo; import android.content.res.Resources; import android.graphics.drawable.Drawable; import android.hardware.display.ColorDisplayManager; import android.net.Uri; import android.os.Bundle; import android.os.Handler; import android.os.UserHandle; import android.os.Vibrator; import android.provider.DeviceConfig; import android.provider.SearchIndexableResource; import android.provider.Settings; import android.text.TextUtils; import android.util.ArrayMap; import android.view.KeyCharacterMap; import android.view.KeyEvent; import android.view.accessibility.AccessibilityManager; import androidx.annotation.VisibleForTesting; import androidx.core.content.ContextCompat; import androidx.preference.ListPreference; import androidx.preference.Preference; import androidx.preference.PreferenceCategory; import androidx.preference.PreferenceScreen; import androidx.preference.SwitchPreference; import com.android.internal.accessibility.AccessibilityShortcutController; import com.android.internal.content.PackageMonitor; import com.android.internal.view.RotationPolicy; import com.android.internal.view.RotationPolicy.RotationPolicyListener; import com.android.settings.R; import com.android.settings.SettingsPreferenceFragment; import com.android.settings.Utils; import com.android.settings.display.DarkUIPreferenceController; import com.android.settings.display.ToggleFontSizePreferenceFragment; import com.android.settings.search.BaseSearchIndexProvider; import com.android.settingslib.RestrictedLockUtils.EnforcedAdmin; import com.android.settingslib.RestrictedLockUtilsInternal; import com.android.settingslib.RestrictedPreference; import com.android.settingslib.accessibility.AccessibilityUtils; import com.android.settingslib.search.SearchIndexable; import com.google.common.primitives.Ints; import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Set; /** * Activity with the accessibility settings. */ @SearchIndexable public class AccessibilitySettings extends SettingsPreferenceFragment implements Preference.OnPreferenceChangeListener { // Index of the first preference in a preference category. private static final int FIRST_PREFERENCE_IN_CATEGORY_INDEX = -1; // Preference categories private static final String CATEGORY_SCREEN_READER = "screen_reader_category"; private static final String CATEGORY_AUDIO_AND_CAPTIONS = "audio_and_captions_category"; private static final String CATEGORY_DISPLAY = "display_category"; private static final String CATEGORY_INTERACTION_CONTROL = "interaction_control_category"; private static final String CATEGORY_EXPERIMENTAL = "experimental_category"; private static final String CATEGORY_DOWNLOADED_SERVICES = "user_installed_services_category"; private static final String[] CATEGORIES = new String[] { CATEGORY_SCREEN_READER, CATEGORY_AUDIO_AND_CAPTIONS, CATEGORY_DISPLAY, CATEGORY_INTERACTION_CONTROL, CATEGORY_EXPERIMENTAL, CATEGORY_DOWNLOADED_SERVICES }; // 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_LARGE_POINTER_ICON = "toggle_large_pointer_icon"; private static final String TOGGLE_DISABLE_ANIMATIONS = "toggle_disable_animations"; 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 ACCESSIBILITY_SHORTCUT_PREFERENCE = "accessibility_shortcut_preference"; private static final String HEARING_AID_PREFERENCE = "hearing_aid_preference"; private static final String CAPTIONING_PREFERENCE_SCREEN = "captioning_preference_screen"; private static final String DISPLAY_MAGNIFICATION_PREFERENCE_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"; private static final String VIBRATION_PREFERENCE_SCREEN = "vibration_preference_screen"; private static final String DISPLAY_DALTONIZER_PREFERENCE_SCREEN = "daltonizer_preference"; private static final String ACCESSIBILITY_CONTROL_TIMEOUT_PREFERENCE = "accessibility_control_timeout_preference_fragment"; private static final String DARK_UI_MODE_PREFERENCE = "dark_ui_mode_accessibility"; private static final String LIVE_CAPTION_PREFERENCE_KEY = "live_caption"; // 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_TITLE_RES = "title_res"; static final String EXTRA_RESOLVE_INFO = "resolve_info"; static final String EXTRA_SUMMARY = "summary"; static final String EXTRA_SUMMARY_RES = "summary_res"; 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"; static final String EXTRA_VIDEO_RAW_RESOURCE_ID = "video_resource"; static final String EXTRA_LAUNCHED_FROM_SUW = "from_suw"; // 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; // Settings that should be changed when toggling animations private static final String[] TOGGLE_ANIMATION_TARGETS = { Settings.Global.WINDOW_ANIMATION_SCALE, Settings.Global.TRANSITION_ANIMATION_SCALE, Settings.Global.ANIMATOR_DURATION_SCALE }; private static final String ANIMATION_ON_VALUE = "1"; private static final String ANIMATION_OFF_VALUE = "0"; static final String RAMPING_RINGER_ENABLED = "ramping_ringer_enabled"; 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) { updateServicePreferences(); } } }; 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; private final RotationPolicyListener mRotationPolicyListener = new RotationPolicyListener() { @Override public void onChange() { updateLockScreenRotationCheckbox(); } }; private final Map mCategoryToPrefCategoryMap = new ArrayMap<>(); private final Map mServicePreferenceToPreferenceCategoryMap = new ArrayMap<>(); private final Map mPreBundledServiceComponentToCategoryMap = new ArrayMap<>(); private SwitchPreference mToggleHighTextContrastPreference; private SwitchPreference mTogglePowerButtonEndsCallPreference; private SwitchPreference mToggleLockScreenRotationPreference; private SwitchPreference mToggleLargePointerIconPreference; private SwitchPreference mToggleDisableAnimationsPreference; private SwitchPreference mToggleMasterMonoPreference; private ListPreference mSelectLongPressTimeoutPreference; private Preference mCaptioningPreferenceScreen; private Preference mDisplayMagnificationPreferenceScreen; private Preference mFontSizePreferenceScreen; private Preference mAutoclickPreferenceScreen; private Preference mAccessibilityShortcutPreferenceScreen; private Preference mDisplayDaltonizerPreferenceScreen; private Preference mHearingAidPreference; private Preference mVibrationPreferenceScreen; private Preference mLiveCaptionPreference; private SwitchPreference mToggleInversionPreference; private ColorInversionPreferenceController mInversionPreferenceController; private AccessibilityHearingAidPreferenceController mHearingAidPreferenceController; private SwitchPreference mDarkUIModePreference; private DarkUIPreferenceController mDarkUIPreferenceController; private LiveCaptionPreferenceController mLiveCaptionPreferenceController; private int mLongPressTimeoutDefault; private DevicePolicyManager mDpm; /** * Check if the color transforms are color accelerated. Some transforms are experimental only * on non-accelerated platforms due to the performance implications. * * @param context The current context */ public static boolean isColorTransformAccelerated(Context context) { return context.getResources() .getBoolean(com.android.internal.R.bool.config_setColorTransformAccelerated); } public AccessibilitySettings() { // Observe changes to anything that the shortcut can toggle, so we can reflect updates final Collection features = AccessibilityShortcutController.getFrameworkShortcutFeaturesMap().values(); final List shortcutFeatureKeys = new ArrayList<>(features.size()); for (AccessibilityShortcutController.ToggleableFrameworkFeatureInfo feature : features) { shortcutFeatureKeys.add(feature.getSettingKey()); } mSettingsContentObserver = new SettingsContentObserver(mHandler, shortcutFeatureKeys) { @Override public void onChange(boolean selfChange, Uri uri) { updateAllPreferences(); } }; } @Override public int getMetricsCategory() { return SettingsEnums.ACCESSIBILITY; } @Override public 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 onAttach(Context context) { super.onAttach(context); mHearingAidPreferenceController = new AccessibilityHearingAidPreferenceController (context, HEARING_AID_PREFERENCE); mHearingAidPreferenceController.setFragmentManager(getFragmentManager()); getLifecycle().addObserver(mHearingAidPreferenceController); mLiveCaptionPreferenceController = new LiveCaptionPreferenceController(context, LIVE_CAPTION_PREFERENCE_KEY); } @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; } return false; } private void handleLongPressTimeoutPreferenceChange(String stringValue) { Settings.Secure.putInt(getContentResolver(), Settings.Secure.LONG_PRESS_TIMEOUT, Integer.parseInt(stringValue)); mSelectLongPressTimeoutPreference.setSummary( mLongPressTimeoutValueToTitleMap.get(stringValue)); } @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 (mToggleLargePointerIconPreference == preference) { handleToggleLargePointerIconPreferenceClick(); return true; } else if (mToggleDisableAnimationsPreference == preference) { handleToggleDisableAnimations(); return true; } else if (mToggleMasterMonoPreference == preference) { handleToggleMasterMonoPreferenceClick(); return true; } else if (mHearingAidPreferenceController.handlePreferenceTreeClick(preference)) { return true; } return super.onPreferenceTreeClick(preference); } public static CharSequence getServiceSummary(Context context, AccessibilityServiceInfo info, boolean serviceEnabled) { final String serviceState = serviceEnabled ? context.getString(R.string.accessibility_summary_state_enabled) : context.getString(R.string.accessibility_summary_state_disabled); final CharSequence serviceSummary = info.loadSummary(context.getPackageManager()); final String stateSummaryCombo = context.getString( R.string.preference_summary_default_combination, serviceState, serviceSummary); return (TextUtils.isEmpty(serviceSummary)) ? serviceState : stateSummaryCombo; } @VisibleForTesting static boolean isRampingRingerEnabled(final Context context) { return (Settings.Global.getInt( context.getContentResolver(), Settings.Global.APPLY_RAMPING_RINGER, 0) == 1) && DeviceConfig.getBoolean( DeviceConfig.NAMESPACE_TELEPHONY, RAMPING_RINGER_ENABLED, false); } 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 handleToggleLargePointerIconPreferenceClick() { Settings.Secure.putInt(getContentResolver(), Settings.Secure.ACCESSIBILITY_LARGE_POINTER_ICON, mToggleLargePointerIconPreference.isChecked() ? 1 : 0); } private void handleToggleDisableAnimations() { String newAnimationValue = mToggleDisableAnimationsPreference.isChecked() ? ANIMATION_OFF_VALUE : ANIMATION_ON_VALUE; for (String animationPreference : TOGGLE_ANIMATION_TARGETS) { Settings.Global.putString(getContentResolver(), animationPreference, newAnimationValue); } } private void handleToggleMasterMonoPreferenceClick() { Settings.System.putIntForUser(getContentResolver(), Settings.System.MASTER_MONO, mToggleMasterMonoPreference.isChecked() ? 1 : 0, UserHandle.USER_CURRENT); } private void initializeAllPreferences() { for (int i = 0; i < CATEGORIES.length; i++) { PreferenceCategory prefCategory = (PreferenceCategory) findPreference(CATEGORIES[i]); mCategoryToPrefCategoryMap.put(CATEGORIES[i], prefCategory); } // Text contrast. mToggleHighTextContrastPreference = (SwitchPreference) findPreference(TOGGLE_HIGH_TEXT_CONTRAST_PREFERENCE); // Display inversion. mToggleInversionPreference = (SwitchPreference) findPreference(TOGGLE_INVERSION_PREFERENCE); mInversionPreferenceController = new ColorInversionPreferenceController(getContext(), TOGGLE_INVERSION_PREFERENCE); mInversionPreferenceController.displayPreference(getPreferenceScreen()); // Power button ends calls. mTogglePowerButtonEndsCallPreference = (SwitchPreference) findPreference(TOGGLE_POWER_BUTTON_ENDS_CALL_PREFERENCE); if (!KeyCharacterMap.deviceHasKey(KeyEvent.KEYCODE_POWER) || !Utils.isVoiceCapable(getActivity())) { mCategoryToPrefCategoryMap.get(CATEGORY_INTERACTION_CONTROL) .removePreference(mTogglePowerButtonEndsCallPreference); } // Lock screen rotation. mToggleLockScreenRotationPreference = (SwitchPreference) findPreference(TOGGLE_LOCK_SCREEN_ROTATION_PREFERENCE); if (!RotationPolicy.isRotationSupported(getActivity())) { mCategoryToPrefCategoryMap.get(CATEGORY_INTERACTION_CONTROL) .removePreference(mToggleLockScreenRotationPreference); } // Large pointer icon. mToggleLargePointerIconPreference = (SwitchPreference) findPreference(TOGGLE_LARGE_POINTER_ICON); mToggleDisableAnimationsPreference = (SwitchPreference) findPreference(TOGGLE_DISABLE_ANIMATIONS); // 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]); } } // Hearing Aid. mHearingAidPreference = findPreference(HEARING_AID_PREFERENCE); mHearingAidPreferenceController.displayPreference(getPreferenceScreen()); // Captioning. mCaptioningPreferenceScreen = findPreference(CAPTIONING_PREFERENCE_SCREEN); // Live caption mLiveCaptionPreference = findPreference(LIVE_CAPTION_PREFERENCE_KEY); mLiveCaptionPreferenceController.displayPreference(getPreferenceScreen()); // Display magnification. mDisplayMagnificationPreferenceScreen = findPreference( DISPLAY_MAGNIFICATION_PREFERENCE_SCREEN); configureMagnificationPreferenceIfNeeded(mDisplayMagnificationPreferenceScreen); // Font size. mFontSizePreferenceScreen = findPreference(FONT_SIZE_PREFERENCE_SCREEN); // Autoclick after pointer stops. mAutoclickPreferenceScreen = findPreference(AUTOCLICK_PREFERENCE_SCREEN); // Display color adjustments. mDisplayDaltonizerPreferenceScreen = findPreference(DISPLAY_DALTONIZER_PREFERENCE_SCREEN); // Accessibility shortcut. mAccessibilityShortcutPreferenceScreen = findPreference(ACCESSIBILITY_SHORTCUT_PREFERENCE); // Vibrations. mVibrationPreferenceScreen = findPreference(VIBRATION_PREFERENCE_SCREEN); // Dark Mode. mDarkUIModePreference = findPreference(DARK_UI_MODE_PREFERENCE); mDarkUIPreferenceController = new DarkUIPreferenceController(getContext(), DARK_UI_MODE_PREFERENCE); mDarkUIPreferenceController.setParentFragment(this); mDarkUIPreferenceController.displayPreference(getPreferenceScreen()); } private void updateAllPreferences() { updateSystemPreferences(); updateServicePreferences(); } protected void updateServicePreferences() { // 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. ArrayList servicePreferences = new ArrayList<>(mServicePreferenceToPreferenceCategoryMap.keySet()); for (int i = 0; i < servicePreferences.size(); i++) { Preference service = servicePreferences.get(i); PreferenceCategory category = mServicePreferenceToPreferenceCategoryMap.get(service); category.removePreference(service); } initializePreBundledServicesMapFromArray(CATEGORY_SCREEN_READER, R.array.config_preinstalled_screen_reader_services); initializePreBundledServicesMapFromArray(CATEGORY_AUDIO_AND_CAPTIONS, R.array.config_preinstalled_audio_and_caption_services); initializePreBundledServicesMapFromArray(CATEGORY_DISPLAY, R.array.config_preinstalled_display_services); initializePreBundledServicesMapFromArray(CATEGORY_INTERACTION_CONTROL, R.array.config_preinstalled_interaction_control_services); AccessibilityManager accessibilityManager = AccessibilityManager.getInstance(getActivity()); List installedServices = accessibilityManager.getInstalledAccessibilityServiceList(); List enabledServiceInfos = accessibilityManager .getEnabledAccessibilityServiceList(AccessibilityServiceInfo.FEEDBACK_ALL_MASK); Set enabledServices = AccessibilityUtils.getEnabledServicesFromSettings( getActivity()); List permittedServices = mDpm.getPermittedAccessibilityServices( UserHandle.myUserId()); PreferenceCategory downloadedServicesCategory = mCategoryToPrefCategoryMap.get(CATEGORY_DOWNLOADED_SERVICES); // Temporarily add the downloaded services category back if it was previously removed. if (findPreference(CATEGORY_DOWNLOADED_SERVICES) == null) { getPreferenceScreen().addPreference(downloadedServicesCategory); } for (int i = 0, count = installedServices.size(); i < count; ++i) { final AccessibilityServiceInfo info = installedServices.get(i); final ResolveInfo resolveInfo = info.getResolveInfo(); final RestrictedPreference preference = new RestrictedPreference(downloadedServicesCategory.getContext()); final String title = resolveInfo.loadLabel(getPackageManager()).toString(); Drawable icon; if (resolveInfo.getIconResource() == 0) { icon = ContextCompat.getDrawable(getContext(), R.drawable.ic_accessibility_generic); } else { icon = resolveInfo.loadIcon(getPackageManager()); } final ServiceInfo serviceInfo = resolveInfo.serviceInfo; final String packageName = serviceInfo.packageName; final ComponentName componentName = new ComponentName(packageName, serviceInfo.name); preference.setKey(componentName.flattenToString()); preference.setTitle(title); preference.setIconSize(ICON_SIZE_MEDIUM); Utils.setSafeIcon(preference, icon); final boolean serviceEnabled = enabledServices.contains(componentName); String description = info.loadDescription(getPackageManager()); if (TextUtils.isEmpty(description)) { description = getString(R.string.accessibility_service_default_description); } if (serviceEnabled && AccessibilityUtils.hasServiceCrashed( packageName, serviceInfo.name, enabledServiceInfos)) { // Update the summaries for services that have crashed. preference.setSummary(R.string.accessibility_summary_state_stopped); description = getString(R.string.accessibility_description_state_stopped); } else { final CharSequence serviceSummary = getServiceSummary(getContext(), info, serviceEnabled); preference.setSummary(serviceSummary); } // Disable all accessibility services that are not permitted. final boolean serviceAllowed = permittedServices == null || permittedServices.contains(packageName); if (!serviceAllowed && !serviceEnabled) { final EnforcedAdmin admin = RestrictedLockUtilsInternal.checkIfAccessibilityServiceDisallowed( getActivity(), packageName, UserHandle.myUserId()); if (admin != null) { preference.setDisabledByAdmin(admin); } else { preference.setEnabled(false); } } else { preference.setEnabled(true); } preference.setFragment(ToggleAccessibilityServicePreferenceFragment.class.getName()); preference.setPersistent(true); final Bundle extras = preference.getExtras(); extras.putString(EXTRA_PREFERENCE_KEY, preference.getKey()); extras.putBoolean(EXTRA_CHECKED, serviceEnabled); extras.putString(EXTRA_TITLE, title); extras.putParcelable(EXTRA_RESOLVE_INFO, resolveInfo); extras.putString(EXTRA_SUMMARY, description); final 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(packageName, settingsClassName).flattenToString()); } extras.putParcelable(EXTRA_COMPONENT_NAME, componentName); PreferenceCategory prefCategory = downloadedServicesCategory; // Set the appropriate category if the service comes pre-installed. if (mPreBundledServiceComponentToCategoryMap.containsKey(componentName)) { prefCategory = mPreBundledServiceComponentToCategoryMap.get(componentName); } preference.setOrder(FIRST_PREFERENCE_IN_CATEGORY_INDEX); prefCategory.addPreference(preference); mServicePreferenceToPreferenceCategoryMap.put(preference, prefCategory); } // Update the order of all the category according to the order defined in xml file. updateCategoryOrderFromArray(CATEGORY_SCREEN_READER, R.array.config_order_screen_reader_services); updateCategoryOrderFromArray(CATEGORY_AUDIO_AND_CAPTIONS, R.array.config_order_audio_and_caption_services); updateCategoryOrderFromArray(CATEGORY_INTERACTION_CONTROL, R.array.config_order_interaction_control_services); updateCategoryOrderFromArray(CATEGORY_DISPLAY, R.array.config_order_display_services); // If the user has not installed any additional services, hide the category. if (downloadedServicesCategory.getPreferenceCount() == 0) { final PreferenceScreen screen = getPreferenceScreen(); screen.removePreference(downloadedServicesCategory); } } private void initializePreBundledServicesMapFromArray(String categoryKey, int key) { String[] services = getResources().getStringArray(key); PreferenceCategory category = mCategoryToPrefCategoryMap.get(categoryKey); for (int i = 0; i < services.length; i++) { ComponentName component = ComponentName.unflattenFromString(services[i]); mPreBundledServiceComponentToCategoryMap.put(component, category); } } /** * Update the order of perferences in the category by matching their preference * key with the string array of preference order which is defined in the xml. * * @param categoryKey The key of the category need to update the order * @param key The key of the string array which defines the order of category */ private void updateCategoryOrderFromArray(String categoryKey, int key) { String[] services = getResources().getStringArray(key); PreferenceCategory category = mCategoryToPrefCategoryMap.get(categoryKey); int preferenceCount = category.getPreferenceCount(); int serviceLength = services.length; for (int preferenceIndex = 0; preferenceIndex < preferenceCount; preferenceIndex++) { for (int serviceIndex = 0; serviceIndex < serviceLength; serviceIndex++) { if (category.getPreference(preferenceIndex).getKey() .equals(services[serviceIndex])) { category.getPreference(preferenceIndex).setOrder(serviceIndex); break; } } } } protected void updateSystemPreferences() { // Move color inversion and color correction preferences to Display category if device // supports HWC hardware-accelerated color transform. if (ColorDisplayManager.isColorTransformAccelerated(getContext())) { PreferenceCategory experimentalCategory = mCategoryToPrefCategoryMap.get(CATEGORY_EXPERIMENTAL); PreferenceCategory displayCategory = mCategoryToPrefCategoryMap.get(CATEGORY_DISPLAY); experimentalCategory.removePreference(mToggleInversionPreference); experimentalCategory.removePreference(mDisplayDaltonizerPreferenceScreen); mDisplayDaltonizerPreferenceScreen.setOrder( mDisplayMagnificationPreferenceScreen.getOrder() + 1); mToggleInversionPreference.setOrder( mDisplayDaltonizerPreferenceScreen.getOrder() + 1); mToggleLargePointerIconPreference.setOrder( mToggleInversionPreference.getOrder() + 1); mToggleDisableAnimationsPreference.setOrder( mToggleLargePointerIconPreference.getOrder() + 1); mToggleInversionPreference.setSummary(R.string.summary_empty); displayCategory.addPreference(mToggleInversionPreference); displayCategory.addPreference(mDisplayDaltonizerPreferenceScreen); } // 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. mInversionPreferenceController.updateState(mToggleInversionPreference); // Dark Mode mDarkUIPreferenceController.updateState(mDarkUIModePreference); // 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(); // Large pointer icon. mToggleLargePointerIconPreference.setChecked(Settings.Secure.getInt(getContentResolver(), Settings.Secure.ACCESSIBILITY_LARGE_POINTER_ICON, 0) != 0); updateDisableAnimationsToggle(); // 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)); updateVibrationSummary(mVibrationPreferenceScreen); mHearingAidPreferenceController.updateState(mHearingAidPreference); mLiveCaptionPreferenceController.updateState(mLiveCaptionPreference); updateFeatureSummary(Settings.Secure.ACCESSIBILITY_CAPTIONING_ENABLED, mCaptioningPreferenceScreen); updateFeatureSummary(Settings.Secure.ACCESSIBILITY_DISPLAY_DALTONIZER_ENABLED, mDisplayDaltonizerPreferenceScreen); updateMagnificationSummary(mDisplayMagnificationPreferenceScreen); updateFontSizeSummary(mFontSizePreferenceScreen); updateAutoclickSummary(mAutoclickPreferenceScreen); updateAccessibilityShortcut(mAccessibilityShortcutPreferenceScreen); updateAccessibilityTimeoutSummary(getContentResolver(), findPreference(ACCESSIBILITY_CONTROL_TIMEOUT_PREFERENCE)); } void updateAccessibilityTimeoutSummary(ContentResolver resolver, Preference pref) { String[] timeoutSummarys = getResources().getStringArray( R.array.accessibility_timeout_summaries); int[] timeoutValues = getResources().getIntArray( R.array.accessibility_timeout_selector_values); int timeoutValue = AccessibilityTimeoutController.getSecureAccessibilityTimeoutValue( resolver, AccessibilityTimeoutController.CONTROL_TIMEOUT_SETTINGS_SECURE); int idx = Ints.indexOf(timeoutValues, timeoutValue); pref.setSummary(timeoutSummarys[idx == -1 ? 0 : idx]); } private void updateMagnificationSummary(Preference pref) { final boolean tripleTapEnabled = Settings.Secure.getInt(getContentResolver(), Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED, 0) == 1; final boolean buttonEnabled = Settings.Secure.getInt(getContentResolver(), Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_NAVBAR_ENABLED, 0) == 1; int summaryResId = 0; if (!tripleTapEnabled && !buttonEnabled) { summaryResId = R.string.accessibility_feature_state_off; } else if (!tripleTapEnabled && buttonEnabled) { summaryResId = R.string.accessibility_screen_magnification_navbar_title; } else if (tripleTapEnabled && !buttonEnabled) { summaryResId = R.string.accessibility_screen_magnification_gestures_title; } else { summaryResId = R.string.accessibility_screen_magnification_state_navbar_gesture; } pref.setSummary(summaryResId); } 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]); } @VisibleForTesting void updateVibrationSummary(Preference pref) { final Context context = getContext(); final Vibrator vibrator = context.getSystemService(Vibrator.class); int ringIntensity = Settings.System.getInt(context.getContentResolver(), Settings.System.RING_VIBRATION_INTENSITY, vibrator.getDefaultRingVibrationIntensity()); if (Settings.System.getInt(context.getContentResolver(), Settings.System.VIBRATE_WHEN_RINGING, 0) == 0 && !isRampingRingerEnabled(context)) { ringIntensity = Vibrator.VIBRATION_INTENSITY_OFF; } CharSequence ringIntensityString = VibrationIntensityPreferenceController.getIntensityString(context, ringIntensity); int notificationIntensity = Settings.System.getInt(context.getContentResolver(), Settings.System.NOTIFICATION_VIBRATION_INTENSITY, vibrator.getDefaultNotificationVibrationIntensity()); CharSequence notificationIntensityString = VibrationIntensityPreferenceController.getIntensityString(context, notificationIntensity); int touchIntensity = Settings.System.getInt(context.getContentResolver(), Settings.System.HAPTIC_FEEDBACK_INTENSITY, vibrator.getDefaultHapticFeedbackIntensity()); if (Settings.System.getInt(context.getContentResolver(), Settings.System.HAPTIC_FEEDBACK_ENABLED, 0) == 0) { touchIntensity = Vibrator.VIBRATION_INTENSITY_OFF; } CharSequence touchIntensityString = VibrationIntensityPreferenceController.getIntensityString(context, touchIntensity); if (mVibrationPreferenceScreen == null) { mVibrationPreferenceScreen = findPreference(VIBRATION_PREFERENCE_SCREEN); } if (ringIntensity == touchIntensity && ringIntensity == notificationIntensity) { mVibrationPreferenceScreen.setSummary(ringIntensityString); } else { mVibrationPreferenceScreen.setSummary( getString(R.string.accessibility_vibration_summary, ringIntensityString, notificationIntensityString, touchIntensityString)); } } private String getVibrationSummary(Context context, @VibrationIntensity int intensity) { final boolean supportsMultipleIntensities = context.getResources().getBoolean( R.bool.config_vibration_supports_multiple_intensities); if (supportsMultipleIntensities) { switch (intensity) { case Vibrator.VIBRATION_INTENSITY_OFF: return context.getString(R.string.accessibility_vibration_summary_off); case Vibrator.VIBRATION_INTENSITY_LOW: return context.getString(R.string.accessibility_vibration_summary_low); case Vibrator.VIBRATION_INTENSITY_MEDIUM: return context.getString(R.string.accessibility_vibration_summary_medium); case Vibrator.VIBRATION_INTENSITY_HIGH: return context.getString(R.string.accessibility_vibration_summary_high); default: return ""; } } else { if (intensity == Vibrator.VIBRATION_INTENSITY_OFF) { return context.getString(R.string.switch_on_text); } else { return context.getString(R.string.switch_off_text); } } } private void updateLockScreenRotationCheckbox() { Context context = getActivity(); if (context != null) { mToggleLockScreenRotationPreference.setChecked( !RotationPolicy.isRotationLocked(context)); } } private void updateDisableAnimationsToggle() { boolean allAnimationsDisabled = true; for (String animationSetting : TOGGLE_ANIMATION_TARGETS) { if (!TextUtils.equals( Settings.Global.getString(getContentResolver(), animationSetting), ANIMATION_OFF_VALUE)) { allAnimationsDisabled = false; break; } } mToggleDisableAnimationsPreference.setChecked(allAnimationsDisabled); } private void updateMasterMono() { final boolean masterMono = Settings.System.getIntForUser( getContentResolver(), Settings.System.MASTER_MONO, 0 /* default */, UserHandle.USER_CURRENT) == 1; mToggleMasterMonoPreference.setChecked(masterMono); } private void updateAccessibilityShortcut(Preference preference) { if (AccessibilityManager.getInstance(getActivity()) .getInstalledAccessibilityServiceList().isEmpty()) { mAccessibilityShortcutPreferenceScreen .setSummary(getString(R.string.accessibility_no_services_installed)); mAccessibilityShortcutPreferenceScreen.setEnabled(false); } else { mAccessibilityShortcutPreferenceScreen.setEnabled(true); boolean shortcutEnabled = AccessibilityUtils.isShortcutEnabled(getContext(), UserHandle.myUserId()); CharSequence summary = shortcutEnabled ? AccessibilityShortcutPreferenceFragment.getServiceName(getContext()) : getString(R.string.accessibility_feature_state_off); mAccessibilityShortcutPreferenceScreen.setSummary(summary); } } private static void configureMagnificationPreferenceIfNeeded(Preference preference) { // Some devices support only a single magnification mode. In these cases, we redirect to // the magnification mode's UI directly, rather than showing a PreferenceScreen with a // single list item. final Context context = preference.getContext(); if (!MagnificationPreferenceFragment.isApplicable(context.getResources())) { preference.setFragment(ToggleScreenMagnificationPreferenceFragment.class.getName()); final Bundle extras = preference.getExtras(); MagnificationGesturesPreferenceController .populateMagnificationGesturesPreferenceExtras(extras, context); } } public static final SearchIndexProvider SEARCH_INDEX_DATA_PROVIDER = new BaseSearchIndexProvider() { @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; } }; }