From 767f58785acff744ff3b088ddb6c6fed10a1e7be Mon Sep 17 00:00:00 2001 From: Chun-Ku Lin Date: Tue, 30 Jul 2024 22:06:46 +0000 Subject: [PATCH] Physical keyboard related options shouldn't be searchable when invisible Physical keyboard options category is hidden when there is no hardware keyboard. It's related preferences are hidden in this case. Hence those preferences shouldn't be searchable. Bug: 351047456 Test: manually search "bounce keys", "sticky keys" and "slow keys", they're not searchable when invisible on Accessibility page Test: atest Flag: com.android.settings.accessibility.fix_a11y_settings_search Change-Id: I1eb465dd34e59d856bb1fa7c06bc253971a8c8d0 --- .../accessibility/accessibility_flags.aconfig | 10 ++++++ .../accessibility/AccessibilitySettings.java | 2 +- ...KeyboardBounceKeyPreferenceController.java | 20 +++++++++++- .../KeyboardSlowKeyPreferenceController.java | 19 ++++++++++++ ...KeyboardStickyKeyPreferenceController.java | 20 +++++++++++- ...oardBounceKeyPreferenceControllerTest.java | 31 ++++++++++++++++++- ...yboardSlowKeyPreferenceControllerTest.java | 31 ++++++++++++++++++- ...oardStickyKeyPreferenceControllerTest.java | 31 ++++++++++++++++++- 8 files changed, 158 insertions(+), 6 deletions(-) diff --git a/aconfig/accessibility/accessibility_flags.aconfig b/aconfig/accessibility/accessibility_flags.aconfig index 3092b8fe72b..0338ed8c09c 100644 --- a/aconfig/accessibility/accessibility_flags.aconfig +++ b/aconfig/accessibility/accessibility_flags.aconfig @@ -51,6 +51,16 @@ flag { bug: "301198830" } +flag { + name: "fix_a11y_settings_search" + namespace: "accessibility" + description: "Fix the a11y related search items in Settings app" + bug: "333437173" + metadata { + purpose: PURPOSE_BUGFIX + } +} + flag { name: "hide_magnification_always_on_toggle_when_window_mode_only" namespace: "accessibility" diff --git a/src/com/android/settings/accessibility/AccessibilitySettings.java b/src/com/android/settings/accessibility/AccessibilitySettings.java index 92bf1257605..f3eab935e91 100644 --- a/src/com/android/settings/accessibility/AccessibilitySettings.java +++ b/src/com/android/settings/accessibility/AccessibilitySettings.java @@ -613,7 +613,7 @@ public class AccessibilitySettings extends DashboardFragment implements } } - private boolean isAnyHardKeyboardsExist() { + static boolean isAnyHardKeyboardsExist() { for (int deviceId : InputDevice.getDeviceIds()) { final InputDevice device = InputDevice.getDevice(deviceId); if (device != null && !device.isVirtual() && device.isFullKeyboard()) { diff --git a/src/com/android/settings/accessibility/KeyboardBounceKeyPreferenceController.java b/src/com/android/settings/accessibility/KeyboardBounceKeyPreferenceController.java index 6d988ac13be..840caa6fa6c 100644 --- a/src/com/android/settings/accessibility/KeyboardBounceKeyPreferenceController.java +++ b/src/com/android/settings/accessibility/KeyboardBounceKeyPreferenceController.java @@ -19,16 +19,21 @@ package com.android.settings.accessibility; import android.content.Context; import android.hardware.input.InputSettings; +import android.util.Log; + +import androidx.annotation.NonNull; import com.android.settings.R; import com.android.settings.core.TogglePreferenceController; import com.android.settings.inputmethod.PhysicalKeyboardFragment; +import java.util.List; + /** * A toggle preference controller for keyboard bounce key. */ public class KeyboardBounceKeyPreferenceController extends TogglePreferenceController { - + private static final String TAG = "BounceKeyPrefController"; static final String PREF_KEY = "toggle_keyboard_bounce_keys"; public KeyboardBounceKeyPreferenceController(Context context, String preferenceKey) { @@ -58,4 +63,17 @@ public class KeyboardBounceKeyPreferenceController extends TogglePreferenceContr public int getSliceHighlightMenuRes() { return R.string.menu_key_accessibility; } + + @Override + public void updateNonIndexableKeys(@NonNull List keys) { + super.updateNonIndexableKeys(keys); + + if (Flags.fixA11ySettingsSearch() && !AccessibilitySettings.isAnyHardKeyboardsExist()) { + if (keys.contains(getPreferenceKey())) { + Log.w(TAG, "Skipping updateNonIndexableKeys, key already in list."); + return; + } + keys.add(getPreferenceKey()); + } + } } diff --git a/src/com/android/settings/accessibility/KeyboardSlowKeyPreferenceController.java b/src/com/android/settings/accessibility/KeyboardSlowKeyPreferenceController.java index 8bd231680ee..bb9d95049ad 100644 --- a/src/com/android/settings/accessibility/KeyboardSlowKeyPreferenceController.java +++ b/src/com/android/settings/accessibility/KeyboardSlowKeyPreferenceController.java @@ -19,15 +19,21 @@ package com.android.settings.accessibility; import android.content.Context; import android.hardware.input.InputSettings; +import android.util.Log; + +import androidx.annotation.NonNull; import com.android.settings.R; import com.android.settings.core.TogglePreferenceController; import com.android.settings.inputmethod.PhysicalKeyboardFragment; +import java.util.List; + /** * A toggle preference controller for keyboard slow key. */ public class KeyboardSlowKeyPreferenceController extends TogglePreferenceController { + private static final String TAG = "SlowKeyPrefController"; static final String PREF_KEY = "toggle_keyboard_slow_keys"; @@ -58,4 +64,17 @@ public class KeyboardSlowKeyPreferenceController extends TogglePreferenceControl public int getSliceHighlightMenuRes() { return R.string.menu_key_accessibility; } + + @Override + public void updateNonIndexableKeys(@NonNull List keys) { + super.updateNonIndexableKeys(keys); + + if (Flags.fixA11ySettingsSearch() && !AccessibilitySettings.isAnyHardKeyboardsExist()) { + if (keys.contains(getPreferenceKey())) { + Log.w(TAG, "Skipping updateNonIndexableKeys, key already in list."); + return; + } + keys.add(getPreferenceKey()); + } + } } diff --git a/src/com/android/settings/accessibility/KeyboardStickyKeyPreferenceController.java b/src/com/android/settings/accessibility/KeyboardStickyKeyPreferenceController.java index ee5559df084..c896c9c0d27 100644 --- a/src/com/android/settings/accessibility/KeyboardStickyKeyPreferenceController.java +++ b/src/com/android/settings/accessibility/KeyboardStickyKeyPreferenceController.java @@ -19,15 +19,20 @@ package com.android.settings.accessibility; import android.content.Context; import android.hardware.input.InputSettings; +import android.util.Log; + +import androidx.annotation.NonNull; import com.android.settings.R; import com.android.settings.core.TogglePreferenceController; +import java.util.List; + /** * A toggle preference controller for keyboard sticky key. */ public class KeyboardStickyKeyPreferenceController extends TogglePreferenceController { - + private static final String TAG = "StickyKeyPrefController"; static final String PREF_KEY = "toggle_keyboard_sticky_keys"; public KeyboardStickyKeyPreferenceController(Context context, String preferenceKey) { @@ -55,4 +60,17 @@ public class KeyboardStickyKeyPreferenceController extends TogglePreferenceContr public int getSliceHighlightMenuRes() { return R.string.menu_key_accessibility; } + + @Override + public void updateNonIndexableKeys(@NonNull List keys) { + super.updateNonIndexableKeys(keys); + + if (Flags.fixA11ySettingsSearch() && !AccessibilitySettings.isAnyHardKeyboardsExist()) { + if (keys.contains(getPreferenceKey())) { + Log.w(TAG, "Skipping updateNonIndexableKeys, key already in list."); + return; + } + keys.add(getPreferenceKey()); + } + } } diff --git a/tests/robotests/src/com/android/settings/accessibility/KeyboardBounceKeyPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/accessibility/KeyboardBounceKeyPreferenceControllerTest.java index 96beb43dd1c..bf6efd097d7 100644 --- a/tests/robotests/src/com/android/settings/accessibility/KeyboardBounceKeyPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/accessibility/KeyboardBounceKeyPreferenceControllerTest.java @@ -25,6 +25,8 @@ import static org.mockito.Mockito.spy; import static org.mockito.Mockito.verify; import android.content.Context; +import android.platform.test.annotations.EnableFlags; +import android.platform.test.flag.junit.SetFlagsRule; import android.provider.Settings; import androidx.preference.PreferenceManager; @@ -34,19 +36,24 @@ import androidx.test.core.app.ApplicationProvider; import com.android.settings.core.BasePreferenceController; +import org.junit.Assume; import org.junit.Before; +import org.junit.Rule; import org.junit.Test; import org.junit.runner.RunWith; import org.robolectric.RobolectricTestRunner; +import java.util.ArrayList; +import java.util.List; @RunWith(RobolectricTestRunner.class) public class KeyboardBounceKeyPreferenceControllerTest { - private static final String KEY_ACCESSIBILITY_BOUNCE_KEYS = Settings.Secure.ACCESSIBILITY_BOUNCE_KEYS; private static final int UNKNOWN = -1; + @Rule + public final SetFlagsRule mSetFlagRule = new SetFlagsRule(); private final Context mContext = ApplicationProvider.getApplicationContext(); private final SwitchPreference mSwitchPreference = spy(new SwitchPreference(mContext)); private final KeyboardBounceKeyPreferenceController mController = @@ -131,4 +138,26 @@ public class KeyboardBounceKeyPreferenceControllerTest { mContext.getContentResolver(), KEY_ACCESSIBILITY_BOUNCE_KEYS, UNKNOWN)).isNotEqualTo(OFF); } + + @Test + @EnableFlags(Flags.FLAG_FIX_A11Y_SETTINGS_SEARCH) + public void updateNonIndexableKeys_physicalKeyboardExists_returnEmptyList() { + Assume.assumeTrue(AccessibilitySettings.isAnyHardKeyboardsExist()); + + List nonIndexableKeys = new ArrayList<>(); + mController.updateNonIndexableKeys(nonIndexableKeys); + + assertThat(nonIndexableKeys).isEmpty(); + } + + @Test + @EnableFlags(Flags.FLAG_FIX_A11Y_SETTINGS_SEARCH) + public void updateNonIndexableKeys_noPhysicalKeyboard_returnPreKey() { + Assume.assumeFalse(AccessibilitySettings.isAnyHardKeyboardsExist()); + + List nonIndexableKeys = new ArrayList<>(); + mController.updateNonIndexableKeys(nonIndexableKeys); + + assertThat(nonIndexableKeys).contains(mController.getPreferenceKey()); + } } diff --git a/tests/robotests/src/com/android/settings/accessibility/KeyboardSlowKeyPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/accessibility/KeyboardSlowKeyPreferenceControllerTest.java index 321b69fa834..2721a64874c 100644 --- a/tests/robotests/src/com/android/settings/accessibility/KeyboardSlowKeyPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/accessibility/KeyboardSlowKeyPreferenceControllerTest.java @@ -25,6 +25,8 @@ import static org.mockito.Mockito.spy; import static org.mockito.Mockito.verify; import android.content.Context; +import android.platform.test.annotations.EnableFlags; +import android.platform.test.flag.junit.SetFlagsRule; import android.provider.Settings; import androidx.preference.PreferenceManager; @@ -34,19 +36,24 @@ import androidx.test.core.app.ApplicationProvider; import com.android.settings.core.BasePreferenceController; +import org.junit.Assume; import org.junit.Before; +import org.junit.Rule; import org.junit.Test; import org.junit.runner.RunWith; import org.robolectric.RobolectricTestRunner; +import java.util.ArrayList; +import java.util.List; @RunWith(RobolectricTestRunner.class) public class KeyboardSlowKeyPreferenceControllerTest { - private static final String KEY_ACCESSIBILITY_SLOW_KEYS = Settings.Secure.ACCESSIBILITY_SLOW_KEYS; private static final int UNKNOWN = -1; + @Rule + public final SetFlagsRule mSetFlagRule = new SetFlagsRule(); private final Context mContext = ApplicationProvider.getApplicationContext(); private final SwitchPreference mSwitchPreference = spy(new SwitchPreference(mContext)); private final KeyboardSlowKeyPreferenceController mController = @@ -131,4 +138,26 @@ public class KeyboardSlowKeyPreferenceControllerTest { mContext.getContentResolver(), KEY_ACCESSIBILITY_SLOW_KEYS, UNKNOWN)).isNotEqualTo( OFF); } + + @Test + @EnableFlags(Flags.FLAG_FIX_A11Y_SETTINGS_SEARCH) + public void updateNonIndexableKeys_physicalKeyboardExists_returnEmptyList() { + Assume.assumeTrue(AccessibilitySettings.isAnyHardKeyboardsExist()); + + List nonIndexableKeys = new ArrayList<>(); + mController.updateNonIndexableKeys(nonIndexableKeys); + + assertThat(nonIndexableKeys).isEmpty(); + } + + @Test + @EnableFlags(Flags.FLAG_FIX_A11Y_SETTINGS_SEARCH) + public void updateNonIndexableKeys_noPhysicalKeyboard_returnPreKey() { + Assume.assumeFalse(AccessibilitySettings.isAnyHardKeyboardsExist()); + + List nonIndexableKeys = new ArrayList<>(); + mController.updateNonIndexableKeys(nonIndexableKeys); + + assertThat(nonIndexableKeys).contains(mController.getPreferenceKey()); + } } diff --git a/tests/robotests/src/com/android/settings/accessibility/KeyboardStickyKeyPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/accessibility/KeyboardStickyKeyPreferenceControllerTest.java index 31d46b76eab..0001e8552d1 100644 --- a/tests/robotests/src/com/android/settings/accessibility/KeyboardStickyKeyPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/accessibility/KeyboardStickyKeyPreferenceControllerTest.java @@ -25,6 +25,8 @@ import static org.mockito.Mockito.spy; import static org.mockito.Mockito.verify; import android.content.Context; +import android.platform.test.annotations.EnableFlags; +import android.platform.test.flag.junit.SetFlagsRule; import android.provider.Settings; import androidx.preference.PreferenceManager; @@ -34,19 +36,24 @@ import androidx.test.core.app.ApplicationProvider; import com.android.settings.core.BasePreferenceController; +import org.junit.Assume; import org.junit.Before; +import org.junit.Rule; import org.junit.Test; import org.junit.runner.RunWith; import org.robolectric.RobolectricTestRunner; +import java.util.ArrayList; +import java.util.List; @RunWith(RobolectricTestRunner.class) public class KeyboardStickyKeyPreferenceControllerTest { - private static final String KEY_ACCESSIBILITY_STICKY_KEYS = Settings.Secure.ACCESSIBILITY_STICKY_KEYS; private static final int UNKNOWN = -1; + @Rule + public final SetFlagsRule mSetFlagRule = new SetFlagsRule(); private final Context mContext = ApplicationProvider.getApplicationContext(); private final SwitchPreference mSwitchPreference = spy(new SwitchPreference(mContext)); private final KeyboardStickyKeyPreferenceController mController = @@ -129,4 +136,26 @@ public class KeyboardStickyKeyPreferenceControllerTest { assertThat(Settings.Secure.getInt( mContext.getContentResolver(), KEY_ACCESSIBILITY_STICKY_KEYS, UNKNOWN)).isEqualTo(ON); } + + @Test + @EnableFlags(Flags.FLAG_FIX_A11Y_SETTINGS_SEARCH) + public void updateNonIndexableKeys_physicalKeyboardExists_returnEmptyList() { + Assume.assumeTrue(AccessibilitySettings.isAnyHardKeyboardsExist()); + + List nonIndexableKeys = new ArrayList<>(); + mController.updateNonIndexableKeys(nonIndexableKeys); + + assertThat(nonIndexableKeys).isEmpty(); + } + + @Test + @EnableFlags(Flags.FLAG_FIX_A11Y_SETTINGS_SEARCH) + public void updateNonIndexableKeys_noPhysicalKeyboard_returnPreKey() { + Assume.assumeFalse(AccessibilitySettings.isAnyHardKeyboardsExist()); + + List nonIndexableKeys = new ArrayList<>(); + mController.updateNonIndexableKeys(nonIndexableKeys); + + assertThat(nonIndexableKeys).contains(mController.getPreferenceKey()); + } }