| /* |
| * 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.ActivityManagerNative; |
| import android.app.AlertDialog; |
| import android.app.Dialog; |
| import android.content.ActivityNotFoundException; |
| import android.content.ComponentName; |
| import android.content.Context; |
| import android.content.DialogInterface; |
| import android.content.Intent; |
| import android.content.SharedPreferences; |
| import android.content.pm.ResolveInfo; |
| import android.content.pm.ServiceInfo; |
| import android.content.res.Configuration; |
| import android.net.Uri; |
| import android.os.Bundle; |
| import android.os.Handler; |
| import android.os.RemoteException; |
| import android.os.SystemProperties; |
| import android.preference.CheckBoxPreference; |
| import android.preference.ListPreference; |
| import android.preference.Preference; |
| import android.preference.PreferenceCategory; |
| import android.preference.PreferenceScreen; |
| import android.provider.Settings; |
| import android.text.TextUtils; |
| import android.text.TextUtils.SimpleStringSplitter; |
| import android.util.Log; |
| import android.view.KeyCharacterMap; |
| import android.view.KeyEvent; |
| import android.view.View; |
| import android.view.accessibility.AccessibilityManager; |
| import android.widget.TextView; |
| |
| import com.android.internal.content.PackageMonitor; |
| 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 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 { |
| private static final String LOG_TAG = "AccessibilitySettings"; |
| |
| private static final String DEFAULT_SCREENREADER_MARKET_LINK = |
| "market://search?q=pname:com.google.android.marvin.talkback"; |
| |
| private static final float LARGE_FONT_SCALE = 1.3f; |
| |
| private static final String SYSTEM_PROPERTY_MARKET_URL = "ro.screenreader.market"; |
| |
| static final char ENABLED_ACCESSIBILITY_SERVICES_SEPARATOR = ':'; |
| |
| private static final String KEY_INSTALL_ACCESSIBILITY_SERVICE_OFFERED_ONCE = |
| "key_install_accessibility_service_offered_once"; |
| |
| // Preference categories |
| private static final String SERVICES_CATEGORY = "services_category"; |
| private static final String SYSTEM_CATEGORY = "system_category"; |
| |
| // Preferences |
| private static final String TOGGLE_LARGE_TEXT_PREFERENCE = |
| "toggle_large_text_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 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"; |
| |
| // 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; |
| |
| // Dialog IDs. |
| private static final int DIALOG_ID_NO_ACCESSIBILITY_SERVICES = 1; |
| |
| // Auxiliary members. |
| final static SimpleStringSplitter sStringColonSplitter = |
| new SimpleStringSplitter(ENABLED_ACCESSIBILITY_SERVICES_SEPARATOR); |
| |
| static final Set<ComponentName> sInstalledServices = new HashSet<ComponentName>(); |
| |
| private final Map<String, String> mLongPressTimeoutValuetoTitleMap = |
| new HashMap<String, String>(); |
| |
| private final Configuration mCurConfig = new Configuration(); |
| |
| private final Handler mHandler = new Handler(); |
| |
| private final Runnable mUpdateRunnable = new Runnable() { |
| @Override |
| public void run() { |
| loadInstalledServices(); |
| 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) { |
| loadInstalledServices(); |
| updateServicesPreferences(); |
| } |
| }; |
| |
| private final RotationPolicyListener mRotationPolicyListener = new RotationPolicyListener() { |
| @Override |
| public void onChange() { |
| updateLockScreenRotationCheckbox(); |
| } |
| }; |
| |
| // Preference controls. |
| private PreferenceCategory mServicesCategory; |
| private PreferenceCategory mSystemsCategory; |
| |
| private CheckBoxPreference mToggleLargeTextPreference; |
| private CheckBoxPreference mTogglePowerButtonEndsCallPreference; |
| private CheckBoxPreference mToggleLockScreenRotationPreference; |
| private CheckBoxPreference mToggleSpeakPasswordPreference; |
| private ListPreference mSelectLongPressTimeoutPreference; |
| private Preference mNoServicesMessagePreference; |
| private PreferenceScreen mCaptioningPreferenceScreen; |
| private PreferenceScreen mDisplayMagnificationPreferenceScreen; |
| private PreferenceScreen mGlobalGesturePreferenceScreen; |
| |
| private int mLongPressTimeoutDefault; |
| |
| @Override |
| public void onCreate(Bundle icicle) { |
| super.onCreate(icicle); |
| addPreferencesFromResource(R.xml.accessibility_settings); |
| initializeAllPreferences(); |
| } |
| |
| @Override |
| public void onResume() { |
| super.onResume(); |
| loadInstalledServices(); |
| updateAllPreferences(); |
| |
| offerInstallAccessibilitySerivceOnce(); |
| |
| 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 (preference == mSelectLongPressTimeoutPreference) { |
| String stringValue = (String) newValue; |
| Settings.Secure.putInt(getContentResolver(), |
| Settings.Secure.LONG_PRESS_TIMEOUT, Integer.parseInt(stringValue)); |
| mSelectLongPressTimeoutPreference.setSummary( |
| mLongPressTimeoutValuetoTitleMap.get(stringValue)); |
| return true; |
| } |
| return false; |
| } |
| |
| @Override |
| public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) { |
| if (mToggleLargeTextPreference == preference) { |
| handleToggleLargeTextPreferenceClick(); |
| 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 (mGlobalGesturePreferenceScreen == preference) { |
| handleTogglEnableAccessibilityGesturePreferenceClick(); |
| return true; |
| } else if (mDisplayMagnificationPreferenceScreen == preference) { |
| handleDisplayMagnificationPreferenceScreenClick(); |
| return true; |
| } |
| return super.onPreferenceTreeClick(preferenceScreen, preference); |
| } |
| |
| private void handleToggleLargeTextPreferenceClick() { |
| try { |
| mCurConfig.fontScale = mToggleLargeTextPreference.isChecked() ? LARGE_FONT_SCALE : 1; |
| ActivityManagerNative.getDefault().updatePersistentConfiguration(mCurConfig); |
| } catch (RemoteException re) { |
| /* ignore */ |
| } |
| } |
| |
| 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 handleTogglEnableAccessibilityGesturePreferenceClick() { |
| 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, |
| 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, |
| mDisplayMagnificationPreferenceScreen); |
| } |
| |
| private void initializeAllPreferences() { |
| mServicesCategory = (PreferenceCategory) findPreference(SERVICES_CATEGORY); |
| mSystemsCategory = (PreferenceCategory) findPreference(SYSTEM_CATEGORY); |
| |
| // Large text. |
| mToggleLargeTextPreference = |
| (CheckBoxPreference) findPreference(TOGGLE_LARGE_TEXT_PREFERENCE); |
| |
| // Power button ends calls. |
| mTogglePowerButtonEndsCallPreference = |
| (CheckBoxPreference) findPreference(TOGGLE_POWER_BUTTON_ENDS_CALL_PREFERENCE); |
| if (!KeyCharacterMap.deviceHasKey(KeyEvent.KEYCODE_POWER) |
| || !Utils.isVoiceCapable(getActivity())) { |
| mSystemsCategory.removePreference(mTogglePowerButtonEndsCallPreference); |
| } |
| |
| // Lock screen rotation. |
| mToggleLockScreenRotationPreference = |
| (CheckBoxPreference) findPreference(TOGGLE_LOCK_SCREEN_ROTATION_PREFERENCE); |
| if (!RotationPolicy.isRotationSupported(getActivity())) { |
| mSystemsCategory.removePreference(mToggleLockScreenRotationPreference); |
| } |
| |
| // Speak passwords. |
| mToggleSpeakPasswordPreference = |
| (CheckBoxPreference) findPreference(TOGGLE_SPEAK_PASSWORD_PREFERENCE); |
| |
| // 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); |
| |
| // 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()); |
| |
| 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); |
| |
| PreferenceScreen preference = getPreferenceManager().createPreferenceScreen( |
| 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); |
| if (serviceEnabled) { |
| preference.setSummary(getString(R.string.accessibility_feature_state_on)); |
| } else { |
| preference.setSummary(getString(R.string.accessibility_feature_state_off)); |
| } |
| |
| 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(getActivity()) { |
| @Override |
| protected void onBindView(View view) { |
| super.onBindView(view); |
| TextView summaryView = (TextView) view.findViewById(R.id.summary); |
| String title = getString(R.string.accessibility_no_services_installed); |
| summaryView.setText(title); |
| } |
| }; |
| mNoServicesMessagePreference.setPersistent(false); |
| mNoServicesMessagePreference.setLayoutResource( |
| R.layout.text_description_preference); |
| mNoServicesMessagePreference.setSelectable(false); |
| } |
| mServicesCategory.addPreference(mNoServicesMessagePreference); |
| } |
| } |
| |
| private void updateSystemPreferences() { |
| // Large text. |
| try { |
| mCurConfig.updateFrom(ActivityManagerNative.getDefault().getConfiguration()); |
| } catch (RemoteException re) { |
| /* ignore */ |
| } |
| mToggleLargeTextPreference.setChecked(mCurConfig.fontScale == LARGE_FONT_SCALE); |
| |
| // 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); |
| |
| // 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)); |
| |
| // Captioning. |
| final boolean captioningEnabled = Settings.Secure.getInt(getContentResolver(), |
| Settings.Secure.ACCESSIBILITY_CAPTIONING_ENABLED, 0) == 1; |
| if (captioningEnabled) { |
| mCaptioningPreferenceScreen.setSummary(R.string.accessibility_feature_state_on); |
| } else { |
| mCaptioningPreferenceScreen.setSummary(R.string.accessibility_feature_state_off); |
| } |
| |
| // Screen magnification. |
| final boolean magnificationEnabled = Settings.Secure.getInt(getContentResolver(), |
| Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED, 0) == 1; |
| if (magnificationEnabled) { |
| mDisplayMagnificationPreferenceScreen.setSummary( |
| R.string.accessibility_feature_state_on); |
| } else { |
| mDisplayMagnificationPreferenceScreen.setSummary( |
| R.string.accessibility_feature_state_off); |
| } |
| |
| // 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 updateLockScreenRotationCheckbox() { |
| Context context = getActivity(); |
| if (context != null) { |
| mToggleLockScreenRotationPreference.setChecked( |
| !RotationPolicy.isRotationLocked(context)); |
| } |
| } |
| |
| private void offerInstallAccessibilitySerivceOnce() { |
| // There is always one preference - if no services it is just a message. |
| if (mServicesCategory.getPreference(0) != mNoServicesMessagePreference) { |
| return; |
| } |
| SharedPreferences preferences = getActivity().getPreferences(Context.MODE_PRIVATE); |
| final boolean offerInstallService = !preferences.getBoolean( |
| KEY_INSTALL_ACCESSIBILITY_SERVICE_OFFERED_ONCE, false); |
| if (offerInstallService) { |
| String screenreaderMarketLink = SystemProperties.get( |
| SYSTEM_PROPERTY_MARKET_URL, |
| DEFAULT_SCREENREADER_MARKET_LINK); |
| Uri marketUri = Uri.parse(screenreaderMarketLink); |
| Intent marketIntent = new Intent(Intent.ACTION_VIEW, marketUri); |
| |
| if (getPackageManager().resolveActivity(marketIntent, 0) == null) { |
| // Don't show the dialog if no market app is found/installed. |
| return; |
| } |
| |
| preferences.edit().putBoolean(KEY_INSTALL_ACCESSIBILITY_SERVICE_OFFERED_ONCE, |
| true).commit(); |
| // Notify user that they do not have any accessibility |
| // services installed and direct them to Market to get TalkBack. |
| showDialog(DIALOG_ID_NO_ACCESSIBILITY_SERVICES); |
| } |
| } |
| |
| @Override |
| public Dialog onCreateDialog(int dialogId) { |
| switch (dialogId) { |
| case DIALOG_ID_NO_ACCESSIBILITY_SERVICES: |
| return new AlertDialog.Builder(getActivity()) |
| .setTitle(R.string.accessibility_service_no_apps_title) |
| .setMessage(R.string.accessibility_service_no_apps_message) |
| .setPositiveButton(android.R.string.ok, |
| new DialogInterface.OnClickListener() { |
| @Override |
| public void onClick(DialogInterface dialog, int which) { |
| // dismiss the dialog before launching |
| // the activity otherwise the dialog |
| // removal occurs after |
| // onSaveInstanceState which triggers an |
| // exception |
| removeDialog(DIALOG_ID_NO_ACCESSIBILITY_SERVICES); |
| String screenreaderMarketLink = SystemProperties.get( |
| SYSTEM_PROPERTY_MARKET_URL, |
| DEFAULT_SCREENREADER_MARKET_LINK); |
| Uri marketUri = Uri.parse(screenreaderMarketLink); |
| Intent marketIntent = new Intent(Intent.ACTION_VIEW, |
| marketUri); |
| try { |
| startActivity(marketIntent); |
| } catch (ActivityNotFoundException anfe) { |
| Log.w(LOG_TAG, "Couldn't start play store activity", |
| anfe); |
| } |
| } |
| }) |
| .setNegativeButton(android.R.string.cancel, null) |
| .create(); |
| default: |
| return null; |
| } |
| } |
| |
| private void loadInstalledServices() { |
| Set<ComponentName> installedServices = sInstalledServices; |
| installedServices.clear(); |
| |
| List<AccessibilityServiceInfo> installedServiceInfos = |
| AccessibilityManager.getInstance(getActivity()) |
| .getInstalledAccessibilityServiceList(); |
| if (installedServiceInfos == null) { |
| return; |
| } |
| |
| final int installedServiceInfoCount = installedServiceInfos.size(); |
| for (int i = 0; i < installedServiceInfoCount; i++) { |
| ResolveInfo resolveInfo = installedServiceInfos.get(i).getResolveInfo(); |
| ComponentName installedService = new ComponentName( |
| resolveInfo.serviceInfo.packageName, |
| resolveInfo.serviceInfo.name); |
| installedServices.add(installedService); |
| } |
| } |
| } |
