Merge changes from topic "open_shortcut"

* changes:
  Accessibility shortcut primary action - implement launched type fragment.
  Accessibility shortcut primary action - setup entry for launched type fragment.

res/values/strings.xml

@@ -5005,6 +5005,8 @@
     <string name="accessibility_touch_vibration_title">Touch feedback</string>
     <!-- Used in the accessibility service settings to control turning on/off the service entirely -->
     <string name="accessibility_service_master_switch_title">Use <xliff:g id="accessibility_app_name" example="TalkBack">%1$s</xliff:g></string>
+    <!-- Used in the accessibility service settings to open the activity. [CHAR LIMIT=NONE] -->
+    <string name="accessibility_service_master_open_title">Open <xliff:g id="accessibility_app_name" example="TalkBack">%1$s</xliff:g></string>
     <!-- Used in the Color correction settings screen to control turning on/off the feature entirely -->
     <string name="accessibility_daltonizer_master_switch_title">Use color correction</string>
     <!-- Used in the Captions settings screen to control turning on/off the feature entirely -->

src/com/android/settings/accessibility/AccessibilitySettings.java

@@ -19,10 +19,13 @@ package com.android.settings.accessibility;
 import static com.android.settingslib.TwoTargetPreference.ICON_SIZE_MEDIUM;
 
 import android.accessibilityservice.AccessibilityServiceInfo;
+import android.accessibilityservice.AccessibilityShortcutInfo;
 import android.app.admin.DevicePolicyManager;
 import android.app.settings.SettingsEnums;
 import android.content.ComponentName;
 import android.content.Context;
+import android.content.pm.ActivityInfo;
+import android.content.pm.PackageManager;
 import android.content.pm.ResolveInfo;
 import android.content.pm.ServiceInfo;
 import android.graphics.drawable.Drawable;
@@ -40,7 +43,6 @@ import androidx.annotation.VisibleForTesting;
 import androidx.core.content.ContextCompat;
 import androidx.preference.Preference;
 import androidx.preference.PreferenceCategory;
-import androidx.preference.PreferenceScreen;
 import androidx.preference.SwitchPreference;
 
 import com.android.internal.accessibility.AccessibilityShortcutController;
@@ -174,8 +176,6 @@ public class AccessibilitySettings extends DashboardFragment {
     private Preference mDisplayDaltonizerPreferenceScreen;
     private Preference mToggleInversionPreference;
 
-    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.
@@ -217,8 +217,6 @@ public class AccessibilitySettings extends DashboardFragment {
     public void onCreate(Bundle icicle) {
         super.onCreate(icicle);
         initializeAllPreferences();
-        mDpm = (DevicePolicyManager) (getActivity()
-                .getSystemService(Context.DEVICE_POLICY_SERVICE));
     }
 
     @Override
@@ -255,27 +253,60 @@ public class AccessibilitySettings extends DashboardFragment {
         return TAG;
     }
 
-    public static CharSequence getServiceSummary(Context context, AccessibilityServiceInfo info,
+    /**
+     * Returns the summary for the current state of this accessibilityService.
+     *
+     * @param context A valid context
+     * @param info The accessibilityService's info
+     * @param serviceEnabled Whether the accessibility service is enabled.
+     * @return The service summary
+     */
+    @VisibleForTesting
+    static CharSequence getServiceSummary(Context context, AccessibilityServiceInfo info,
             boolean serviceEnabled) {
-        final CharSequence serviceSummary = info.loadSummary(context.getPackageManager());
+        if (serviceEnabled && info.crashed) {
-        final int fragmentType = AccessibilityUtil.getAccessibilityServiceFragmentType(info);
+            return context.getText(R.string.accessibility_summary_state_stopped);
+        }
 
+        final CharSequence serviceSummary = info.loadSummary(context.getPackageManager());
+
+        final int fragmentType = AccessibilityUtil.getAccessibilityServiceFragmentType(info);
         if (fragmentType == AccessibilityServiceFragmentType.INVISIBLE) {
             return TextUtils.isEmpty(serviceSummary) ? EMPTY_STRING : serviceSummary;
         }
 
-        final String serviceState = serviceEnabled
+        final CharSequence serviceState = serviceEnabled
-                ? context.getString(R.string.accessibility_summary_state_enabled)
+                ? context.getText(R.string.accessibility_summary_state_enabled)
-                : context.getString(R.string.accessibility_summary_state_disabled);
+                : context.getText(R.string.accessibility_summary_state_disabled);
         final String stateSummaryCombo = context.getString(
                 R.string.preference_summary_default_combination,
                 serviceState, serviceSummary);
 
-        return (TextUtils.isEmpty(serviceSummary)) ? serviceState : stateSummaryCombo;
+        return TextUtils.isEmpty(serviceSummary) ? serviceState : stateSummaryCombo;
-
     }
 
+    /**
+     * Returns the description for the current state of this accessibilityService.
+     *
+     * @param context A valid context
+     * @param info The accessibilityService's info
+     * @param serviceEnabled Whether the accessibility service is enabled.
+     * @return The service description
+     */
     @VisibleForTesting
+    static CharSequence getServiceDescription(Context context, AccessibilityServiceInfo info,
+            boolean serviceEnabled) {
+        if (serviceEnabled && info.crashed) {
+            return context.getText(R.string.accessibility_description_state_stopped);
+        }
+
+        final String description = info.loadDescription(context.getPackageManager());
+
+        return TextUtils.isEmpty(description)
+                ? context.getText(R.string.accessibility_service_default_description)
+                : description;
+    }
+
     static boolean isRampingRingerEnabled(final Context context) {
         return Settings.Global.getInt(
                 context.getContentResolver(), Settings.Global.APPLY_RAMPING_RINGER, 0) == 1;
@@ -283,7 +314,7 @@ public class AccessibilitySettings extends DashboardFragment {
 
     private void initializeAllPreferences() {
         for (int i = 0; i < CATEGORIES.length; i++) {
-            PreferenceCategory prefCategory = (PreferenceCategory) findPreference(CATEGORIES[i]);
+            PreferenceCategory prefCategory = findPreference(CATEGORIES[i]);
             mCategoryToPrefCategoryMap.put(CATEGORIES[i], prefCategory);
         }
 
@@ -293,8 +324,7 @@ public class AccessibilitySettings extends DashboardFragment {
         // Large pointer icon.
         mToggleLargePointerIconPreference = findPreference(TOGGLE_LARGE_POINTER_ICON);
 
-        mToggleDisableAnimationsPreference =
+        mToggleDisableAnimationsPreference = findPreference(TOGGLE_DISABLE_ANIMATIONS);
-                (SwitchPreference) findPreference(TOGGLE_DISABLE_ANIMATIONS);
 
         // Display magnification.
         mDisplayMagnificationPreferenceScreen = findPreference(
@@ -313,9 +343,7 @@ public class AccessibilitySettings extends DashboardFragment {
         // 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.
-
+        final ArrayList<Preference> servicePreferences =
-        // Generate.
-        ArrayList<Preference> servicePreferences =
                 new ArrayList<>(mServicePreferenceToPreferenceCategoryMap.keySet());
         for (int i = 0; i < servicePreferences.size(); i++) {
             Preference service = servicePreferences.get(i);
@@ -332,125 +360,21 @@ public class AccessibilitySettings extends DashboardFragment {
         initializePreBundledServicesMapFromArray(CATEGORY_INTERACTION_CONTROL,
                 R.array.config_preinstalled_interaction_control_services);
 
-        AccessibilityManager accessibilityManager = AccessibilityManager.getInstance(getActivity());
+        final List<RestrictedPreference> preferenceList = getInstalledAccessibilityList(
+                getPrefContext());
 
-        List<AccessibilityServiceInfo> installedServices =
+        final PreferenceCategory downloadedServicesCategory =
-                accessibilityManager.getInstalledAccessibilityServiceList();
-        Set<ComponentName> enabledServices = AccessibilityUtils.getEnabledServicesFromSettings(
-                getActivity());
-        List<String> 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 && info.crashed) {
-                // 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);
-            }
-
-            final int fragmentType = AccessibilityUtil.getAccessibilityServiceFragmentType(info);
-            switch (fragmentType) {
-                case AccessibilityServiceFragmentType.LEGACY:
-                    preference.setFragment(
-                            LegacyAccessibilityServicePreferenceFragment.class.getName());
-                    break;
-                case AccessibilityServiceFragmentType.INVISIBLE:
-                    preference.setFragment(
-                            InvisibleToggleAccessibilityServicePreferenceFragment.class.getName());
-                    break;
-                case AccessibilityServiceFragmentType.INTUITIVE:
-                    preference.setFragment(
-                            ToggleAccessibilityServicePreferenceFragment.class.getName());
-                    break;
-                default:
-                    // impossible status
-                    throw new AssertionError();
-            }
-
-            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);
-            extras.putInt(EXTRA_ANIMATED_IMAGE_RES, info.getAnimatedImageRes());
-
-            final String htmlDescription = info.loadHtmlDescription(getPackageManager());
-            extras.putString(AccessibilitySettings.EXTRA_HTML_DESCRIPTION, htmlDescription);
-
-            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);
 
+        for (int i = 0, count = preferenceList.size(); i < count; ++i) {
+            final RestrictedPreference preference = preferenceList.get(i);
+            final ComponentName componentName = preference.getExtras().getParcelable(
+                    EXTRA_COMPONENT_NAME);
             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);
         }
@@ -465,13 +389,60 @@ public class AccessibilitySettings extends DashboardFragment {
         updateCategoryOrderFromArray(CATEGORY_DISPLAY,
             R.array.config_order_display_services);
 
-        // If the user has not installed any additional services, hide the category.
+        // Need to check each time when updateServicePreferences() called.
         if (downloadedServicesCategory.getPreferenceCount() == 0) {
-            final PreferenceScreen screen = getPreferenceScreen();
+            getPreferenceScreen().removePreference(downloadedServicesCategory);
-            screen.removePreference(downloadedServicesCategory);
+        } else {
+            getPreferenceScreen().addPreference(downloadedServicesCategory);
         }
     }
 
+    private List<RestrictedPreference> getInstalledAccessibilityList(Context context) {
+        final AccessibilityManager a11yManager = AccessibilityManager.getInstance(context);
+        final RestrictedPreferenceHelper preferenceHelper = new RestrictedPreferenceHelper(context);
+
+        final List<AccessibilityShortcutInfo> installedShortcutList =
+                a11yManager.getInstalledAccessibilityShortcutListAsUser(context,
+                        UserHandle.myUserId());
+
+        // Remove duplicate item here, new a ArrayList to copy unmodifiable list result
+        // (getInstalledAccessibilityServiceList).
+        final List<AccessibilityServiceInfo> installedServiceList = new ArrayList<>(
+                a11yManager.getInstalledAccessibilityServiceList());
+        installedServiceList.removeIf(
+                target -> containsTargetNameInList(installedShortcutList, target));
+
+        final List<RestrictedPreference> activityList =
+                preferenceHelper.createAccessibilityActivityPreferenceList(installedShortcutList);
+
+        final List<RestrictedPreference> serviceList =
+                preferenceHelper.createAccessibilityServicePreferenceList(installedServiceList);
+
+        final List<RestrictedPreference> preferenceList = new ArrayList<>();
+        preferenceList.addAll(activityList);
+        preferenceList.addAll(serviceList);
+
+        return preferenceList;
+    }
+
+    private boolean containsTargetNameInList(List<AccessibilityShortcutInfo> shortcutInfos,
+            AccessibilityServiceInfo targetServiceInfo) {
+        final ServiceInfo serviceInfo = targetServiceInfo.getResolveInfo().serviceInfo;
+        final String servicePackageName = serviceInfo.packageName;
+        final CharSequence serviceLabel = serviceInfo.loadLabel(getPackageManager());
+
+        for (int i = 0, count = shortcutInfos.size(); i < count; ++i) {
+            final ActivityInfo activityInfo = shortcutInfos.get(i).getActivityInfo();
+            final String activityPackageName = activityInfo.packageName;
+            final CharSequence activityLabel = activityInfo.loadLabel(getPackageManager());
+            if (servicePackageName.equals(activityPackageName)
+                    && serviceLabel.equals(activityLabel)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
     private void initializePreBundledServicesMapFromArray(String categoryKey, int key) {
         String[] services = getResources().getStringArray(key);
         PreferenceCategory category = mCategoryToPrefCategoryMap.get(categoryKey);
@@ -533,4 +504,236 @@ public class AccessibilitySettings extends DashboardFragment {
 
     public static final BaseSearchIndexProvider SEARCH_INDEX_DATA_PROVIDER =
             new BaseSearchIndexProvider(R.xml.accessibility_settings);
+
+    /**
+     * This class helps setup RestrictedPreference.
+     */
+    @VisibleForTesting
+    static class RestrictedPreferenceHelper {
+        private final Context mContext;
+        private final DevicePolicyManager mDpm;
+        private final PackageManager mPm;
+
+        RestrictedPreferenceHelper(Context context) {
+            mContext = context;
+            mDpm = context.getSystemService(DevicePolicyManager.class);
+            mPm = context.getPackageManager();
+        }
+
+        /**
+         * Creates the list of {@link RestrictedPreference} with the installedServices arguments.
+         *
+         * @param installedServices The list of {@link AccessibilityServiceInfo}s of the
+         *                          installed accessibility services
+         * @return The list of {@link RestrictedPreference}
+         */
+        List<RestrictedPreference> createAccessibilityServicePreferenceList(
+                List<AccessibilityServiceInfo> installedServices) {
+
+            final Set<ComponentName> enabledServices =
+                    AccessibilityUtils.getEnabledServicesFromSettings(mContext);
+            final List<String> permittedServices = mDpm.getPermittedAccessibilityServices(
+                    UserHandle.myUserId());
+            final int installedServicesSize = installedServices.size();
+
+            final List<RestrictedPreference> preferenceList = new ArrayList<>(
+                    installedServicesSize);
+
+            for (int i = 0; i < installedServicesSize; ++i) {
+                final AccessibilityServiceInfo info = installedServices.get(i);
+                final ResolveInfo resolveInfo = info.getResolveInfo();
+                final String packageName = resolveInfo.serviceInfo.packageName;
+                final ComponentName componentName = new ComponentName(packageName,
+                        resolveInfo.serviceInfo.name);
+
+                final String key = componentName.flattenToString();
+                final CharSequence title = resolveInfo.loadLabel(mPm);
+                final boolean serviceEnabled = enabledServices.contains(componentName);
+                final CharSequence summary = getServiceSummary(mContext, info, serviceEnabled);
+                final String fragment = getAccessibilityServiceFragmentTypeName(info);
+
+                Drawable icon = resolveInfo.loadIcon(mPm);
+                if (resolveInfo.getIconResource() == 0) {
+                    icon = ContextCompat.getDrawable(mContext,
+                            R.drawable.ic_accessibility_generic);
+                }
+
+                final RestrictedPreference preference = createRestrictedPreference(key, title,
+                        summary, icon, fragment);
+
+                // permittedServices null means all accessibility services are allowed.
+                final boolean serviceAllowed =
+                        permittedServices == null || permittedServices.contains(packageName);
+
+                setRestrictedPreferenceEnabled(preference, packageName, serviceAllowed,
+                        serviceEnabled);
+
+                final String prefKey = preference.getKey();
+                final int imageRes = info.getAnimatedImageRes();
+                final CharSequence description = getServiceDescription(mContext, info,
+                        serviceEnabled);
+                final String htmlDescription = info.loadHtmlDescription(mPm);
+                final String settingsClassName = info.getSettingsActivityName();
+
+                putBasicExtras(preference, prefKey, title, description, imageRes, htmlDescription,
+                        componentName);
+                putServiceExtras(preference, resolveInfo, serviceEnabled);
+                putSettingsExtras(preference, packageName, settingsClassName);
+
+                preferenceList.add(preference);
+            }
+            return preferenceList;
+        }
+
+        /**
+         * Create the list of {@link RestrictedPreference} with the installedShortcuts arguments.
+         *
+         * @param installedShortcuts The list of {@link AccessibilityShortcutInfo}s of the
+         *                           installed accessibility shortcuts
+         * @return The list of {@link RestrictedPreference}
+         */
+        List<RestrictedPreference> createAccessibilityActivityPreferenceList(
+                List<AccessibilityShortcutInfo> installedShortcuts) {
+            final Set<ComponentName> enabledServices =
+                    AccessibilityUtils.getEnabledServicesFromSettings(mContext);
+            final List<String> permittedServices = mDpm.getPermittedAccessibilityServices(
+                    UserHandle.myUserId());
+
+            final int installedShortcutsSize = installedShortcuts.size();
+            final List<RestrictedPreference> preferenceList = new ArrayList<>(
+                    installedShortcutsSize);
+
+            for (int i = 0; i < installedShortcutsSize; ++i) {
+                final AccessibilityShortcutInfo info = installedShortcuts.get(i);
+                final ActivityInfo activityInfo = info.getActivityInfo();
+                final ComponentName componentName = info.getComponentName();
+
+                final String key = componentName.flattenToString();
+                final CharSequence title = activityInfo.loadLabel(mPm);
+                final String summary = info.loadSummary(mPm);
+                final String fragment =
+                        LaunchAccessibilityActivityPreferenceFragment.class.getName();
+
+                Drawable icon = activityInfo.loadIcon(mPm);
+                if (activityInfo.getIconResource() == 0) {
+                    icon = ContextCompat.getDrawable(mContext, R.drawable.ic_accessibility_generic);
+                }
+
+                final RestrictedPreference preference = createRestrictedPreference(key, title,
+                        summary, icon, fragment);
+
+                final String packageName = componentName.getPackageName();
+                // permittedServices null means all accessibility services are allowed.
+                final boolean serviceAllowed =
+                        permittedServices == null || permittedServices.contains(packageName);
+                final boolean serviceEnabled = enabledServices.contains(componentName);
+
+                setRestrictedPreferenceEnabled(preference, packageName, serviceAllowed,
+                        serviceEnabled);
+
+                final String prefKey = preference.getKey();
+                final String description = info.loadDescription(mPm);
+                final int imageRes = info.getAnimatedImageRes();
+                final String htmlDescription = info.loadHtmlDescription(mPm);
+
+                putBasicExtras(preference, prefKey, title, description, imageRes, htmlDescription,
+                        componentName);
+
+                preferenceList.add(preference);
+            }
+            return preferenceList;
+        }
+
+        private String getAccessibilityServiceFragmentTypeName(AccessibilityServiceInfo info) {
+            switch (AccessibilityUtil.getAccessibilityServiceFragmentType(
+                    info)) {
+                case AccessibilityServiceFragmentType.LEGACY:
+                    return LegacyAccessibilityServicePreferenceFragment.class.getName();
+                case AccessibilityServiceFragmentType.INVISIBLE:
+                    return InvisibleToggleAccessibilityServicePreferenceFragment.class.getName();
+                case AccessibilityServiceFragmentType.INTUITIVE:
+                    return ToggleAccessibilityServicePreferenceFragment.class.getName();
+                default:
+                    // impossible status
+                    throw new AssertionError();
+            }
+        }
+
+        private RestrictedPreference createRestrictedPreference(String key, CharSequence title,
+                CharSequence summary, Drawable icon, String fragment) {
+            final RestrictedPreference preference = new RestrictedPreference(mContext);
+
+            preference.setKey(key);
+            preference.setTitle(title);
+            preference.setSummary(summary);
+            Utils.setSafeIcon(preference, icon);
+            preference.setFragment(fragment);
+            preference.setIconSize(ICON_SIZE_MEDIUM);
+            preference.setPersistent(false); // Disable SharedPreferences.
+            preference.setOrder(FIRST_PREFERENCE_IN_CATEGORY_INDEX);
+
+            return preference;
+        }
+
+        private void setRestrictedPreferenceEnabled(RestrictedPreference preference,
+                String packageName, boolean serviceAllowed, boolean serviceEnabled) {
+            if (serviceAllowed || serviceEnabled) {
+                preference.setEnabled(true);
+            } else {
+                // Disable accessibility service that are not permitted.
+                final EnforcedAdmin admin =
+                        RestrictedLockUtilsInternal.checkIfAccessibilityServiceDisallowed(
+                                mContext, packageName, UserHandle.myUserId());
+                if (admin != null) {
+                    preference.setDisabledByAdmin(admin);
+                } else {
+                    preference.setEnabled(false);
+                }
+            }
+        }
+
+        /** Puts the basic extras into {@link RestrictedPreference}'s getExtras(). */
+        private void putBasicExtras(RestrictedPreference preference, String prefKey,
+                CharSequence title, CharSequence summary, int imageRes, String htmlDescription,
+                ComponentName componentName) {
+            final Bundle extras = preference.getExtras();
+
+            extras.putString(EXTRA_PREFERENCE_KEY, prefKey);
+            extras.putString(EXTRA_TITLE, title.toString());
+            extras.putString(EXTRA_SUMMARY, summary.toString());
+            extras.putParcelable(EXTRA_COMPONENT_NAME, componentName);
+            extras.putInt(EXTRA_ANIMATED_IMAGE_RES, imageRes);
+            extras.putString(AccessibilitySettings.EXTRA_HTML_DESCRIPTION, htmlDescription);
+        }
+
+        /**
+         * Puts the service extras into {@link RestrictedPreference}'s getExtras().
+         *
+         * Called by {@link AccessibilityServiceInfo} for now.
+         */
+        private void putServiceExtras(RestrictedPreference preference, ResolveInfo resolveInfo,
+                Boolean serviceEnabled) {
+            final Bundle extras = preference.getExtras();
+
+            extras.putParcelable(EXTRA_RESOLVE_INFO, resolveInfo);
+            extras.putBoolean(EXTRA_CHECKED, serviceEnabled);
+        }
+
+        /**
+         * Puts the settings extras into {@link RestrictedPreference}'s getExtras().
+         *
+         * Called when settings UI is needed.
+         */
+        private void putSettingsExtras(RestrictedPreference preference, String packageName,
+                String settingsClassName) {
+            final Bundle extras = preference.getExtras();
+
+            if (!TextUtils.isEmpty(settingsClassName)) {
+                extras.putString(EXTRA_SETTINGS_TITLE,
+                        mContext.getText(R.string.accessibility_menu_item_settings).toString());
+                extras.putString(EXTRA_SETTINGS_COMPONENT_NAME,
+                        new ComponentName(packageName, settingsClassName).flattenToString());
+            }
+        }
+    }
 }

src/com/android/settings/accessibility/DividerSwitchPreference.java

@@ -17,6 +17,7 @@
 package com.android.settings.accessibility;
 
 import android.content.Context;
+import android.view.View;
 
 import androidx.preference.PreferenceViewHolder;
 import androidx.preference.SwitchPreference;
@@ -29,11 +30,25 @@ public final class DividerSwitchPreference extends SwitchPreference {
 
     private Boolean mDividerAllowedAbove;
     private Boolean mDividerAllowBelow;
+    private int mSwitchVisibility;
 
     public DividerSwitchPreference(Context context) {
         super(context);
         mDividerAllowedAbove = true;
         mDividerAllowBelow = true;
+        mSwitchVisibility = View.VISIBLE;
+    }
+
+    @Override
+    public void onBindViewHolder(PreferenceViewHolder holder) {
+        super.onBindViewHolder(holder);
+        holder.setDividerAllowedAbove(mDividerAllowedAbove);
+        holder.setDividerAllowedBelow(mDividerAllowBelow);
+
+        final View switchView = holder.itemView.findViewById(android.R.id.widget_frame);
+        if (switchView != null) {
+            switchView.setVisibility(mSwitchVisibility);
+        }
     }
 
     /**
@@ -60,10 +75,15 @@ public final class DividerSwitchPreference extends SwitchPreference {
         }
     }
 
-    @Override
+    /**
-    public void onBindViewHolder(PreferenceViewHolder holder) {
+     * Sets the visibility state of Settings view.
-        super.onBindViewHolder(holder);
+     *
-        holder.setDividerAllowedAbove(mDividerAllowedAbove);
+     * @param visibility one of {@link View#VISIBLE}, {@link View#INVISIBLE}, or {@link View#GONE}.
-        holder.setDividerAllowedBelow(mDividerAllowBelow);
+     */
+    public void setSwitchVisibility(@View.Visibility int visibility) {
+        if (mSwitchVisibility != visibility) {
+            mSwitchVisibility = visibility;
+            notifyChanged();
+        }
     }
 }

src/com/android/settings/accessibility/LaunchAccessibilityActivityPreferenceFragment.java

@@ -0,0 +1,134 @@
+/*
+ * Copyright (C) 2020 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.AccessibilityShortcutInfo;
+import android.app.ActivityOptions;
+import android.content.ActivityNotFoundException;
+import android.content.ComponentName;
+import android.content.ContentResolver;
+import android.content.Intent;
+import android.content.pm.ActivityInfo;
+import android.net.Uri;
+import android.os.Bundle;
+import android.os.UserHandle;
+import android.util.Log;
+import android.view.View;
+import android.view.accessibility.AccessibilityManager;
+
+import androidx.preference.SwitchPreference;
+
+import com.android.settings.R;
+
+import java.util.List;
+
+/** Fragment for providing open activity button. */
+public class LaunchAccessibilityActivityPreferenceFragment extends
+        ToggleFeaturePreferenceFragment {
+    private static final String TAG = "LaunchA11yActivity";
+    private static final String EMPTY_STRING = "";
+
+    @Override
+    public void onViewCreated(View view, Bundle savedInstanceState) {
+        super.onViewCreated(view, savedInstanceState);
+
+        mToggleServiceDividerSwitchPreference.setSwitchVisibility(View.GONE);
+    }
+
+    @Override
+    protected void onPreferenceToggled(String preferenceKey, boolean enabled) {
+        launchShortcutTargetActivity(getPrefContext().getDisplayId(), mComponentName);
+    }
+
+    @Override
+    protected void onInstallSwitchPreferenceToggleSwitch() {
+        super.onInstallSwitchPreferenceToggleSwitch();
+        mToggleServiceDividerSwitchPreference.setOnPreferenceClickListener((preference) -> {
+            final boolean checked = ((DividerSwitchPreference) preference).isChecked();
+            onPreferenceToggled(mPreferenceKey, checked);
+            return false;
+        });
+    }
+
+    @Override
+    protected void onProcessArguments(Bundle arguments) {
+        super.onProcessArguments(arguments);
+
+        mComponentName = arguments.getParcelable(AccessibilitySettings.EXTRA_COMPONENT_NAME);
+        final ActivityInfo info = getAccessibilityShortcutInfo().getActivityInfo();
+        mPackageName = info.loadLabel(getPackageManager()).toString();
+
+        // Settings animated image.
+        final int animatedImageRes = arguments.getInt(
+                AccessibilitySettings.EXTRA_ANIMATED_IMAGE_RES);
+        mImageUri = new Uri.Builder().scheme(ContentResolver.SCHEME_ANDROID_RESOURCE)
+                .authority(mComponentName.getPackageName())
+                .appendPath(String.valueOf(animatedImageRes))
+                .build();
+
+        // Settings html description.
+        mHtmlDescription = arguments.getCharSequence(AccessibilitySettings.EXTRA_HTML_DESCRIPTION);
+    }
+
+    @Override
+    public void onSettingsClicked(ShortcutPreference preference) {
+        super.onSettingsClicked(preference);
+        showDialog(DialogEnums.EDIT_SHORTCUT);
+    }
+
+    @Override
+    protected void updateToggleServiceTitle(SwitchPreference switchPreference) {
+        final AccessibilityShortcutInfo info = getAccessibilityShortcutInfo();
+        final String switchBarText = (info == null) ? EMPTY_STRING : getString(
+                R.string.accessibility_service_master_open_title,
+                info.getActivityInfo().loadLabel(getPackageManager()));
+
+        switchPreference.setTitle(switchBarText);
+    }
+
+    // IMPORTANT: Refresh the info since there are dynamically changing capabilities.
+    private AccessibilityShortcutInfo getAccessibilityShortcutInfo() {
+        final List<AccessibilityShortcutInfo> infos = AccessibilityManager.getInstance(
+                getPrefContext()).getInstalledAccessibilityShortcutListAsUser(getPrefContext(),
+                UserHandle.myUserId());
+
+        for (int i = 0, count = infos.size(); i < count; i++) {
+            AccessibilityShortcutInfo shortcutInfo = infos.get(i);
+            ActivityInfo activityInfo = shortcutInfo.getActivityInfo();
+            if (mComponentName.getPackageName().equals(activityInfo.packageName)
+                    && mComponentName.getClassName().equals(activityInfo.name)) {
+                return shortcutInfo;
+            }
+        }
+        return null;
+    }
+
+    private void launchShortcutTargetActivity(int displayId, ComponentName name) {
+        final Intent intent = new Intent();
+        final Bundle bundle = ActivityOptions.makeBasic().setLaunchDisplayId(displayId).toBundle();
+
+        intent.setComponent(name);
+        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
+        try {
+            final int userId = UserHandle.myUserId();
+            getPrefContext().startActivityAsUser(intent, bundle, UserHandle.of(userId));
+        } catch (ActivityNotFoundException ignore) {
+            // ignore the exception
+            Log.w(TAG, "Target activity not found.");
+        }
+    }
+}

src/com/android/settings/accessibility/ToggleAccessibilityServicePreferenceFragment.java

@@ -59,6 +59,8 @@ public class ToggleAccessibilityServicePreferenceFragment extends
     private LockPatternUtils mLockPatternUtils;
     private AtomicBoolean mIsDialogShown = new AtomicBoolean(/* initialValue= */ false);
 
+    private static final String EMPTY_STRING = "";
+
     private final SettingsContentObserver mSettingsContentObserver =
             new SettingsContentObserver(new Handler()) {
                 @Override
@@ -84,7 +86,7 @@ public class ToggleAccessibilityServicePreferenceFragment extends
     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
-        mLockPatternUtils = new LockPatternUtils(getActivity());
+        mLockPatternUtils = new LockPatternUtils(getPrefContext());
     }
 
     @Override
@@ -105,11 +107,11 @@ public class ToggleAccessibilityServicePreferenceFragment extends
     // example, before JellyBean MR2 the user was granting the explore by touch
     // one.
     private AccessibilityServiceInfo getAccessibilityServiceInfo() {
-        List<AccessibilityServiceInfo> serviceInfos = AccessibilityManager.getInstance(
+        final List<AccessibilityServiceInfo> infos = AccessibilityManager.getInstance(
-                getActivity()).getInstalledAccessibilityServiceList();
+                getPrefContext()).getInstalledAccessibilityServiceList();
-        final int serviceInfoCount = serviceInfos.size();
+
-        for (int i = 0; i < serviceInfoCount; i++) {
+        for (int i = 0, count = infos.size(); i < count; i++) {
-            AccessibilityServiceInfo serviceInfo = serviceInfos.get(i);
+            AccessibilityServiceInfo serviceInfo = infos.get(i);
             ResolveInfo resolveInfo = serviceInfo.getResolveInfo();
             if (mComponentName.getPackageName().equals(resolveInfo.serviceInfo.packageName)
                     && mComponentName.getClassName().equals(resolveInfo.serviceInfo.name)) {
@@ -191,7 +193,7 @@ public class ToggleAccessibilityServicePreferenceFragment extends
         final AccessibilityServiceInfo info = getAccessibilityServiceInfo();
         final String switchBarText = (info == null) ? "" :
                 getString(R.string.accessibility_service_master_switch_title,
-                info.getResolveInfo().loadLabel(getPackageManager()));
+                        info.getResolveInfo().loadLabel(getPackageManager()));
         switchPreference.setTitle(switchBarText);
     }
 

tests/robotests/src/com/android/settings/accessibility/AccessibilitySettingsTest.java

@@ -18,49 +18,82 @@ package com.android.settings.accessibility;
 
 import static com.google.common.truth.Truth.assertThat;
 
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.when;
 
+import android.accessibilityservice.AccessibilityServiceInfo;
+import android.accessibilityservice.AccessibilityShortcutInfo;
+import android.content.ComponentName;
 import android.content.Context;
+import android.content.pm.ActivityInfo;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.ResolveInfo;
+import android.content.pm.ServiceInfo;
+import android.os.Build;
 import android.provider.Settings;
 import android.view.accessibility.AccessibilityManager;
 
 import com.android.settings.R;
 import com.android.settings.testutils.XmlTestUtils;
 import com.android.settings.testutils.shadow.ShadowDeviceConfig;
+import com.android.settingslib.RestrictedPreference;
 
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.Mockito;
 import org.mockito.MockitoAnnotations;
 import org.robolectric.RobolectricTestRunner;
 import org.robolectric.RuntimeEnvironment;
 import org.robolectric.annotation.Config;
 import org.robolectric.shadow.api.Shadow;
 import org.robolectric.shadows.ShadowAccessibilityManager;
+import org.xmlpull.v1.XmlPullParserException;
 
+import java.io.IOException;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 
 @RunWith(RobolectricTestRunner.class)
 public class AccessibilitySettingsTest {
+    private static final String DUMMY_PACKAGE_NAME = "com.dummy.example";
+    private static final String DUMMY_CLASS_NAME = DUMMY_PACKAGE_NAME + ".dummy_a11y_service";
+    private static final ComponentName DUMMY_COMPONENT_NAME = new ComponentName(DUMMY_PACKAGE_NAME,
+            DUMMY_CLASS_NAME);
+    private static final int ON = 1;
+    private static final int OFF = 0;
+    private static final String EMPTY_STRING = "";
+    private static final String DEFAULT_SUMMARY = "default summary";
+    private static final String DEFAULT_DESCRIPTION = "default description";
+    private static final String DEFAULT_LABEL = "default label";
+    private static final Boolean SERVICE_ENABLED = true;
+    private static final Boolean SERVICE_DISABLED = false;
 
     private Context mContext;
     private AccessibilitySettings mSettings;
     private ShadowAccessibilityManager mShadowAccessibilityManager;
+    private AccessibilityServiceInfo mServiceInfo;
+    @Mock
+    private AccessibilityShortcutInfo mShortcutInfo;
 
     @Before
     public void setup() {
         MockitoAnnotations.initMocks(this);
-        mContext = RuntimeEnvironment.application;
+
+        mContext = spy(RuntimeEnvironment.application);
         mSettings = spy(new AccessibilitySettings());
+        mServiceInfo = spy(getMockAccessibilityServiceInfo());
         mShadowAccessibilityManager = Shadow.extract(AccessibilityManager.getInstance(mContext));
         mShadowAccessibilityManager.setInstalledAccessibilityServiceList(new ArrayList<>());
         doReturn(mContext).when(mSettings).getContext();
     }
 
     @Test
-    public void testNonIndexableKeys_existInXmlLayout() {
+    public void getNonIndexableKeys_existInXmlLayout() {
         final List<String> niks = AccessibilitySettings.SEARCH_INDEX_DATA_PROVIDER
                 .getNonIndexableKeys(mContext);
         final List<String> keys =
@@ -71,17 +104,189 @@ public class AccessibilitySettingsTest {
 
     @Test
     @Config(shadows = {ShadowDeviceConfig.class})
-    public void testIsRampingRingerEnabled_settingsFlagOn_Enabled() {
+    public void isRampingRingerEnabled_settingsFlagOn_Enabled() {
         Settings.Global.putInt(
-                mContext.getContentResolver(), Settings.Global.APPLY_RAMPING_RINGER, 1 /* ON */);
+                mContext.getContentResolver(), Settings.Global.APPLY_RAMPING_RINGER, ON);
         assertThat(AccessibilitySettings.isRampingRingerEnabled(mContext)).isTrue();
     }
 
     @Test
     @Config(shadows = {ShadowDeviceConfig.class})
-    public void testIsRampingRingerEnabled_settingsFlagOff_Disabled() {
+    public void isRampingRingerEnabled_settingsFlagOff_Disabled() {
         Settings.Global.putInt(
-                mContext.getContentResolver(), Settings.Global.APPLY_RAMPING_RINGER, 0 /* OFF */);
+                mContext.getContentResolver(), Settings.Global.APPLY_RAMPING_RINGER, OFF);
         assertThat(AccessibilitySettings.isRampingRingerEnabled(mContext)).isFalse();
     }
+
+    @Test
+    public void getServiceSummary_serviceCrash_showsStopped() {
+        mServiceInfo.crashed = true;
+
+        final CharSequence summary = AccessibilitySettings.getServiceSummary(mContext,
+                mServiceInfo, SERVICE_ENABLED);
+
+        assertThat(summary).isEqualTo(
+                mContext.getString(R.string.accessibility_summary_state_stopped));
+    }
+
+    @Test
+    public void getServiceSummary_invisibleType_showsDefaultSummary() {
+        setInvisibleFragmentType(mServiceInfo);
+        doReturn(DEFAULT_SUMMARY).when(mServiceInfo).loadSummary(any());
+
+        final CharSequence summary = AccessibilitySettings.getServiceSummary(mContext,
+                mServiceInfo, SERVICE_ENABLED);
+
+        assertThat(summary).isEqualTo(DEFAULT_SUMMARY);
+    }
+
+    @Test
+    public void getServiceSummary_enableService_showsEnabled() {
+        doReturn(EMPTY_STRING).when(mServiceInfo).loadSummary(any());
+
+        final CharSequence summary = AccessibilitySettings.getServiceSummary(mContext,
+                mServiceInfo, SERVICE_ENABLED);
+
+        assertThat(summary).isEqualTo(
+                mContext.getString(R.string.accessibility_summary_state_enabled));
+    }
+
+    @Test
+    public void getServiceSummary_disableService_showsDisabled() {
+        doReturn(EMPTY_STRING).when(mServiceInfo).loadSummary(any());
+
+        final CharSequence summary = AccessibilitySettings.getServiceSummary(mContext,
+                mServiceInfo, SERVICE_DISABLED);
+
+        assertThat(summary).isEqualTo(
+                mContext.getString(R.string.accessibility_summary_state_disabled));
+    }
+
+    @Test
+    public void getServiceSummary_enableServiceAndHasSummary_showsEnabledSummary() {
+        final String service_enabled = mContext.getString(
+                R.string.accessibility_summary_state_enabled);
+        doReturn(DEFAULT_SUMMARY).when(mServiceInfo).loadSummary(any());
+
+        final CharSequence summary = AccessibilitySettings.getServiceSummary(mContext,
+                mServiceInfo, SERVICE_ENABLED);
+
+        assertThat(summary).isEqualTo(
+                mContext.getString(R.string.preference_summary_default_combination, service_enabled,
+                        DEFAULT_SUMMARY));
+    }
+
+    @Test
+    public void getServiceSummary_disableServiceAndHasSummary_showsCombineDisabledSummary() {
+        final String service_disabled = mContext.getString(
+                R.string.accessibility_summary_state_disabled);
+        doReturn(DEFAULT_SUMMARY).when(mServiceInfo).loadSummary(any());
+
+        final CharSequence summary = AccessibilitySettings.getServiceSummary(mContext,
+                mServiceInfo, SERVICE_DISABLED);
+
+        assertThat(summary).isEqualTo(
+                mContext.getString(R.string.preference_summary_default_combination,
+                        service_disabled, DEFAULT_SUMMARY));
+    }
+
+    @Test
+    public void getServiceDescription_serviceCrash_showsStopped() {
+        mServiceInfo.crashed = true;
+
+        final CharSequence description = AccessibilitySettings.getServiceDescription(mContext,
+                mServiceInfo, SERVICE_ENABLED);
+
+        assertThat(description).isEqualTo(
+                mContext.getString(R.string.accessibility_description_state_stopped));
+    }
+
+    @Test
+    public void getServiceDescription_haveDescription_showsDescription() {
+        doReturn(DEFAULT_DESCRIPTION).when(mServiceInfo).loadDescription(any());
+
+        final CharSequence description = AccessibilitySettings.getServiceDescription(mContext,
+                mServiceInfo, SERVICE_ENABLED);
+
+        assertThat(description).isEqualTo(DEFAULT_DESCRIPTION);
+    }
+
+    @Test
+    public void getServiceDescription_noDescription_showsDefaultString() {
+        doReturn(EMPTY_STRING).when(mServiceInfo).loadDescription(any());
+
+        final CharSequence description = AccessibilitySettings.getServiceDescription(mContext,
+                mServiceInfo, SERVICE_ENABLED);
+
+        assertThat(description).isEqualTo(
+                mContext.getString(R.string.accessibility_service_default_description));
+    }
+
+    @Test
+    public void createAccessibilityServicePreferenceList_hasOneInfo_containsSameKey() {
+        final String key = DUMMY_COMPONENT_NAME.flattenToString();
+        final AccessibilitySettings.RestrictedPreferenceHelper helper =
+                new AccessibilitySettings.RestrictedPreferenceHelper(mContext);
+        final List<AccessibilityServiceInfo> infoList = new ArrayList<>(
+                Collections.singletonList(mServiceInfo));
+
+        final List<RestrictedPreference> preferenceList =
+                helper.createAccessibilityServicePreferenceList(infoList);
+        RestrictedPreference preference = preferenceList.get(0);
+
+        assertThat(preference.getKey()).isEqualTo(key);
+    }
+
+    @Test
+    public void createAccessibilityActivityPreferenceList_hasOneInfo_containsSameKey() {
+        final String key = DUMMY_COMPONENT_NAME.flattenToString();
+        final AccessibilitySettings.RestrictedPreferenceHelper helper =
+                new AccessibilitySettings.RestrictedPreferenceHelper(mContext);
+        setMockAccessibilityShortcutInfo(mShortcutInfo);
+        final List<AccessibilityShortcutInfo> infoList = new ArrayList<>(
+                Collections.singletonList(mShortcutInfo));
+
+        final List<RestrictedPreference> preferenceList =
+                helper.createAccessibilityActivityPreferenceList(infoList);
+        RestrictedPreference preference = preferenceList.get(0);
+
+        assertThat(preference.getKey()).isEqualTo(key);
+    }
+
+    private AccessibilityServiceInfo getMockAccessibilityServiceInfo() {
+        final ApplicationInfo applicationInfo = new ApplicationInfo();
+        final ServiceInfo serviceInfo = new ServiceInfo();
+        applicationInfo.packageName = DUMMY_PACKAGE_NAME;
+        serviceInfo.packageName = DUMMY_PACKAGE_NAME;
+        serviceInfo.name = DUMMY_CLASS_NAME;
+        serviceInfo.applicationInfo = applicationInfo;
+
+        final ResolveInfo resolveInfo = new ResolveInfo();
+        resolveInfo.serviceInfo = serviceInfo;
+
+        try {
+            final AccessibilityServiceInfo info = new AccessibilityServiceInfo(resolveInfo,
+                    mContext);
+            info.setComponentName(DUMMY_COMPONENT_NAME);
+            return info;
+        } catch (XmlPullParserException | IOException e) {
+            // Do nothing
+        }
+
+        return null;
+    }
+
+    private void setMockAccessibilityShortcutInfo(AccessibilityShortcutInfo mockInfo) {
+        final ActivityInfo activityInfo = Mockito.mock(ActivityInfo.class);
+        when(mockInfo.getActivityInfo()).thenReturn(activityInfo);
+        when(activityInfo.loadLabel(any())).thenReturn(DEFAULT_LABEL);
+        when(mockInfo.loadSummary(any())).thenReturn(DEFAULT_SUMMARY);
+        when(mockInfo.loadDescription(any())).thenReturn(DEFAULT_DESCRIPTION);
+        when(mockInfo.getComponentName()).thenReturn(DUMMY_COMPONENT_NAME);
+    }
+
+    private void setInvisibleFragmentType(AccessibilityServiceInfo info) {
+        info.getResolveInfo().serviceInfo.applicationInfo.targetSdkVersion = Build.VERSION_CODES.R;
+        info.flags |= AccessibilityServiceInfo.FLAG_REQUEST_ACCESSIBILITY_BUTTON;
+    }
 }