Re enable IME tests for show/hide flags

Previously we disabled IME tests that relied on behaviour specific to
flags like SHOW_IMPLICIT, SHOW_FORCED, HIDE_IMPLICIT_ONLY or
HIDE_NOT_ALWAYS, as the IME insets controller refactor made it so we
lose this flag information.

This re-enables the tests, verifying that having the flags passed has
the same behaviour as having no flags set, when the refactor is enabled.

Flag: EXEMPT testfix
Bug: 394328311
Test: atest InputMethodServiceTest
Change-Id: I29a01e1bb00ae841270a24465cbcbb1a031c0f3b

2 files changed, 187 insertions, 139 deletions

diff --git a/services/tests/InputMethodSystemServerTests/src/com/android/inputmethodservice/InputMethodServiceTest.java b/services/tests/InputMethodSystemServerTests/src/com/android/inputmethodservice/InputMethodServiceTest.java
index 5d64cb638702..56ca81b47c75 100644
--- a/services/tests/InputMethodSystemServerTests/src/com/android/inputmethodservice/InputMethodServiceTest.java
+++ b/services/tests/InputMethodSystemServerTests/src/com/android/inputmethodservice/InputMethodServiceTest.java
@@ -38,8 +38,6 @@ import android.app.Instrumentation;
 import android.content.res.Configuration;
 import android.graphics.Insets;
 import android.os.RemoteException;
-import android.platform.test.annotations.RequiresFlagsDisabled;
-import android.platform.test.flag.junit.CheckFlagsRule;
 import android.platform.test.flag.junit.DeviceFlagsValueProvider;
 import android.provider.Settings;
 import android.server.wm.WindowManagerStateHelper;
@@ -95,16 +93,13 @@ public class InputMethodServiceTest {
     /** The ids of the subtypes of SimpleIme. */
     private static final int[] SUBTYPE_IDS = new int[]{1, 2};
 
-    private final WindowManagerStateHelper mWmState =  new WindowManagerStateHelper();
+    private final WindowManagerStateHelper mWmState = new WindowManagerStateHelper();
 
     private final GestureNavSwitchHelper mGestureNavSwitchHelper = new GestureNavSwitchHelper();
 
     private final DeviceFlagsValueProvider mFlagsValueProvider = new DeviceFlagsValueProvider();
 
     @Rule
-    public final CheckFlagsRule mCheckFlagsRule = new CheckFlagsRule(mFlagsValueProvider);
-
-    @Rule
     public final TestName mName = new TestName();
 
     private Instrumentation mInstrumentation;
@@ -203,12 +198,10 @@ public class InputMethodServiceTest {
     public void testShowHideKeyboard_byInputMethodManager() {
         setShowImeWithHardKeyboard(true /* enabled */);
 
-        // Triggers to show IME via public API.
         verifyInputViewStatusOnMainSync(
                 () -> assertThat(mActivity.showImeWithInputMethodManager(0 /* flags */)).isTrue(),
                 EVENT_SHOW, true /* eventExpected */, true /* shown */, "IME is shown");
 
-        // Triggers to hide IME via public API.
         verifyInputViewStatusOnMainSync(
                 () -> assertThat(mActivity.hideImeWithInputMethodManager(0 /* flags */)).isTrue(),
                 EVENT_HIDE, true /* eventExpected */, false /* shown */, "IME is not shown");
@@ -221,12 +214,10 @@ public class InputMethodServiceTest {
     public void testShowHideKeyboard_byInsetsController() {
         setShowImeWithHardKeyboard(true /* enabled */);
 
-        // Triggers to show IME via public API.
         verifyInputViewStatusOnMainSync(
                 () -> mActivity.showImeWithWindowInsetsController(),
                 EVENT_SHOW, true /* eventExpected */, true /* shown */, "IME is shown");
 
-        // Triggers to hide IME via public API.
         verifyInputViewStatusOnMainSync(
                 () -> mActivity.hideImeWithWindowInsetsController(),
                 EVENT_HIDE, true /* eventExpected */, false /* shown */, "IME is not shown");
@@ -234,53 +225,18 @@ public class InputMethodServiceTest {
 
     /**
      * This checks the result of calling IMS#requestShowSelf and IMS#requestHideSelf.
-     *
-     * <p>With the refactor in b/298172246, all calls to IMMS#{show,hide}MySoftInputLocked
-     * will be just apply the requested visibility (by using the callback). Therefore, we will
-     * lose flags like HIDE_IMPLICIT_ONLY.
      */
     @Test
     public void testShowHideSelf() {
         setShowImeWithHardKeyboard(true /* enabled */);
 
-        // IME request to show itself without any flags, expect shown.
-        Log.i(TAG, "Call IMS#requestShowSelf(0)");
         verifyInputViewStatusOnMainSync(
                 () -> mInputMethodService.requestShowSelf(0 /* flags */),
                 EVENT_SHOW, true /* eventExpected */, true /* shown */, "IME is shown");
 
-        if (!mFlagsValueProvider.getBoolean(Flags.FLAG_REFACTOR_INSETS_CONTROLLER)) {
-            // IME request to hide itself with flag HIDE_IMPLICIT_ONLY, expect not hide (shown).
-            Log.i(TAG, "Call IMS#requestHideSelf(InputMethodManager.HIDE_IMPLICIT_ONLY)");
-            verifyInputViewStatusOnMainSync(
-                    () -> mInputMethodService.requestHideSelf(
-                            InputMethodManager.HIDE_IMPLICIT_ONLY),
-                    EVENT_HIDE, false /* eventExpected */, true /* shown */,
-                    "IME is still shown after HIDE_IMPLICIT_ONLY");
-        }
-
-        // IME request to hide itself without any flags, expect hidden.
-        Log.i(TAG, "Call IMS#requestHideSelf(0)");
         verifyInputViewStatusOnMainSync(
                 () -> mInputMethodService.requestHideSelf(0 /* flags */),
                 EVENT_HIDE, true /* eventExpected */, false /* shown */, "IME is not shown");
-
-        if (!mFlagsValueProvider.getBoolean(Flags.FLAG_REFACTOR_INSETS_CONTROLLER)) {
-            // IME request to show itself with flag SHOW_IMPLICIT, expect shown.
-            Log.i(TAG, "Call IMS#requestShowSelf(InputMethodManager.SHOW_IMPLICIT)");
-            verifyInputViewStatusOnMainSync(
-                    () -> mInputMethodService.requestShowSelf(InputMethodManager.SHOW_IMPLICIT),
-                    EVENT_SHOW, true /* eventExpected */, true /* shown */,
-                    "IME is shown with SHOW_IMPLICIT");
-
-            // IME request to hide itself with flag HIDE_IMPLICIT_ONLY, expect hidden.
-            Log.i(TAG, "Call IMS#requestHideSelf(InputMethodManager.HIDE_IMPLICIT_ONLY)");
-            verifyInputViewStatusOnMainSync(
-                    () -> mInputMethodService.requestHideSelf(
-                            InputMethodManager.HIDE_IMPLICIT_ONLY),
-                    EVENT_HIDE, true /* eventExpected */, false /* shown */,
-                    "IME is not shown after HIDE_IMPLICIT_ONLY");
-        }
     }
 
     /**
@@ -310,7 +266,7 @@ public class InputMethodServiceTest {
             config.hardKeyboardHidden = Configuration.HARDKEYBOARDHIDDEN_YES;
             eventually(() ->
                     assertWithMessage("InputView should show with hidden hardware keyboard")
-                         .that(mInputMethodService.onEvaluateInputViewShown()).isTrue());
+                            .that(mInputMethodService.onEvaluateInputViewShown()).isTrue());
         } finally {
             mInputMethodService.getResources()
                     .updateConfiguration(initialConfig, null /* metrics */, null /* compat */);
@@ -386,34 +342,6 @@ public class InputMethodServiceTest {
     }
 
     /**
-     * This checks that an explicit show request results in the IME being shown.
-     */
-    @Test
-    public void testShowSoftInputExplicitly() {
-        setShowImeWithHardKeyboard(true /* enabled */);
-
-        // When InputMethodService#onEvaluateInputViewShown() returns true and flag is EXPLICIT, the
-        // IME should be shown.
-        verifyInputViewStatusOnMainSync(
-                () -> assertThat(mActivity.showImeWithInputMethodManager(0 /* flags */)).isTrue(),
-                EVENT_SHOW, true /* eventExpected */, true /* shown */, "IME is shown");
-    }
-
-    /**
-     * This checks that an implicit show request results in the IME being shown.
-     */
-    @Test
-    public void testShowSoftInputImplicitly() {
-        setShowImeWithHardKeyboard(true /* enabled */);
-
-        // When InputMethodService#onEvaluateInputViewShown() returns true and flag is IMPLICIT,
-        // the IME should be shown.
-        verifyInputViewStatusOnMainSync(() -> assertThat(
-                mActivity.showImeWithInputMethodManager(InputMethodManager.SHOW_IMPLICIT)).isTrue(),
-                EVENT_SHOW, true /* eventExpected */, true /* shown */, "IME is shown");
-    }
-
-    /**
      * This checks that an explicit show request when the IME is not previously shown,
      * and it should be shown in fullscreen mode, results in the IME being shown.
      */
@@ -425,10 +353,8 @@ public class InputMethodServiceTest {
         setOrientation(2);
         eventually(() -> assertWithMessage("No longer in natural orientation")
                 .that(mUiDevice.isNaturalOrientation()).isFalse());
-        // Wait for the TestActivity to be recreated.
         eventually(() -> assertWithMessage("Activity was re-created after rotation")
                 .that(TestActivity.getInstance()).isNotEqualTo(mActivity));
-        // Get the new TestActivity.
         mActivity = TestActivity.getInstance();
         assertWithMessage("Re-created activity is not null").that(mActivity).isNotNull();
         // Wait for the new EditText to be served by InputMethodManager.
@@ -442,14 +368,14 @@ public class InputMethodServiceTest {
 
     /**
      * This checks that an implicit show request when the IME is not previously shown,
-     * and it should be shown in fullscreen mode, results in the IME not being shown.
+     * and it should be shown in fullscreen mode behaves like an explicit show request, resulting
+     * in the IME being shown. This is due to the refactor in b/298172246, causing us to lose flag
+     * information like {@link InputMethodManager#SHOW_IMPLICIT}.
      *
-     * <p>With the refactor in b/298172246, all calls from InputMethodManager#{show,hide}SoftInput
-     * will be redirected to InsetsController#{show,hide}. Therefore, we will lose flags like
-     * SHOW_IMPLICIT.
+     * <p>Previously, an implicit show request when the IME is not previously shown,
+     * and it should be shown in fullscreen mode, would result in the IME not being shown.
      */
     @Test
-    @RequiresFlagsDisabled(Flags.FLAG_REFACTOR_INSETS_CONTROLLER)
     public void testShowSoftInputImplicitly_fullScreenMode() {
         setShowImeWithHardKeyboard(true /* enabled */);
 
@@ -457,19 +383,27 @@ public class InputMethodServiceTest {
         setOrientation(2);
         eventually(() -> assertWithMessage("No longer in natural orientation")
                 .that(mUiDevice.isNaturalOrientation()).isFalse());
-        // Wait for the TestActivity to be recreated.
         eventually(() -> assertWithMessage("Activity was re-created after rotation")
                 .that(TestActivity.getInstance()).isNotEqualTo(mActivity));
-        // Get the new TestActivity.
         mActivity = TestActivity.getInstance();
         assertWithMessage("Re-created activity is not null").that(mActivity).isNotNull();
         // Wait for the new EditText to be served by InputMethodManager.
         eventually(() -> assertWithMessage("Has an input connection to the re-created Activity")
                 .that(mImm.hasActiveInputConnection(mActivity.getEditText())).isTrue());
 
-        verifyInputViewStatusOnMainSync(() -> assertThat(
-                mActivity.showImeWithInputMethodManager(InputMethodManager.SHOW_IMPLICIT)).isTrue(),
-                EVENT_SHOW, false /* eventExpected */, false /* shown */, "IME is not shown");
+        if (mFlagsValueProvider.getBoolean(Flags.FLAG_REFACTOR_INSETS_CONTROLLER)) {
+            verifyInputViewStatusOnMainSync(() -> assertThat(
+                            mActivity.showImeWithInputMethodManager(
+                                    InputMethodManager.SHOW_IMPLICIT))
+                            .isTrue(),
+                    EVENT_SHOW, true /* eventExpected */, true /* shown */, "IME is shown");
+        } else {
+            verifyInputViewStatusOnMainSync(() -> assertThat(
+                            mActivity.showImeWithInputMethodManager(
+                                    InputMethodManager.SHOW_IMPLICIT))
+                            .isTrue(),
+                    EVENT_SHOW, false /* eventExpected */, false /* shown */, "IME is not shown");
+        }
     }
 
     /**
@@ -497,15 +431,15 @@ public class InputMethodServiceTest {
     }
 
     /**
-     * This checks that an implicit show request when a hardware keyboard is connected,
-     * results in the IME not being shown.
+     * This checks that an implicit show request when a hardware keyboard is connected behaves
+     * like an explicit show request, resulting in the IME being shown. This is due to the
+     * refactor in b/298172246, causing us to lose flag information like
+     * {@link InputMethodManager#SHOW_IMPLICIT}.
      *
-     * <p>With the refactor in b/298172246, all calls from InputMethodManager#{show,hide}SoftInput
-     * will be redirected to InsetsController#{show,hide}. Therefore, we will lose flags like
-     * SHOW_IMPLICIT.
+     * <p>Previously, an implicit show request when a hardware keyboard is connected would
+     * result in the IME not being shown.
      */
     @Test
-    @RequiresFlagsDisabled(Flags.FLAG_REFACTOR_INSETS_CONTROLLER)
     public void testShowSoftInputImplicitly_withHardKeyboard() {
         setShowImeWithHardKeyboard(false /* enabled */);
 
@@ -516,10 +450,20 @@ public class InputMethodServiceTest {
             config.keyboard = Configuration.KEYBOARD_QWERTY;
             config.hardKeyboardHidden = Configuration.HARDKEYBOARDHIDDEN_YES;
 
-            verifyInputViewStatusOnMainSync(() ->assertThat(
-                    mActivity.showImeWithInputMethodManager(InputMethodManager.SHOW_IMPLICIT))
-                            .isTrue(),
-                    EVENT_SHOW, false /* eventExpected */, false /* shown */, "IME is not shown");
+            if (mFlagsValueProvider.getBoolean(Flags.FLAG_REFACTOR_INSETS_CONTROLLER)) {
+                verifyInputViewStatusOnMainSync(() -> assertThat(
+                                mActivity.showImeWithInputMethodManager(
+                                        InputMethodManager.SHOW_IMPLICIT))
+                                .isTrue(),
+                        EVENT_SHOW, true /* eventExpected */, true /* shown */, "IME is shown");
+            } else {
+                verifyInputViewStatusOnMainSync(() -> assertThat(
+                                mActivity.showImeWithInputMethodManager(
+                                        InputMethodManager.SHOW_IMPLICIT))
+                                .isTrue(),
+                        EVENT_SHOW, false /* eventExpected */, false /* shown */,
+                        "IME is not shown");
+            }
         } finally {
             mInputMethodService.getResources()
                     .updateConfiguration(initialConfig, null /* metrics */, null /* compat */);
@@ -565,15 +509,15 @@ public class InputMethodServiceTest {
 
     /**
      * This checks that an implicit show request followed by connecting a hardware keyboard
-     * and a configuration change, does not trigger IMS#onFinishInputView,
-     * but results in the IME being hidden.
+     * and a configuration change behaves like an explicit show request, resulting in the IME
+     * still being shown. This is due to the refactor in b/298172246, causing us to lose flag
+     * information like {@link InputMethodManager#SHOW_IMPLICIT}.
      *
-     * <p>With the refactor in b/298172246, all calls from InputMethodManager#{show,hide}SoftInput
-     * will be redirected to InsetsController#{show,hide}. Therefore, we will lose flags like
-     * SHOW_IMPLICIT.
+     * <p>Previously, an implicit show request followed by connecting a hardware keyboard
+     * and a configuration change, would not trigger IMS#onFinishInputView, but resulted in the
+     * IME being hidden.
      */
     @Test
-    @RequiresFlagsDisabled(Flags.FLAG_REFACTOR_INSETS_CONTROLLER)
     public void testShowSoftInputImplicitly_thenConfigurationChanged() {
         setShowImeWithHardKeyboard(false /* enabled */);
 
@@ -596,16 +540,23 @@ public class InputMethodServiceTest {
             // Simulate a fake configuration change to avoid the recreation of TestActivity.
             config.orientation = Configuration.ORIENTATION_LANDSCAPE;
 
-            // Normally, IMS#onFinishInputView will be called when finishing the input view by
-            // the user. But if IMS#hideWindow is called when receiving a new configuration change,
-            // we don't expect that it's user-driven to finish the lifecycle of input view with
-            // IMS#onFinishInputView, because the input view will be re-initialized according
-            // to the last #mShowInputRequested state. So in this case we treat the input view as
-            // still alive.
-            verifyInputViewStatusOnMainSync(
-                    () -> mInputMethodService.onConfigurationChanged(config),
-                    EVENT_CONFIG, true /* eventExpected */, true /* inputViewStarted */,
-                    false /* shown */, "IME is not shown after a configuration change");
+            if (mFlagsValueProvider.getBoolean(Flags.FLAG_REFACTOR_INSETS_CONTROLLER)) {
+                verifyInputViewStatusOnMainSync(
+                        () -> mInputMethodService.onConfigurationChanged(config),
+                        EVENT_CONFIG, true /* eventExpected */, true /* shown */,
+                        "IME is still shown after a configuration change");
+            } else {
+                // Normally, IMS#onFinishInputView will be called when finishing the input view by
+                // the user. But if IMS#hideWindow is called when receiving a new configuration
+                // change, we don't expect that it's user-driven to finish the lifecycle of input
+                // view with IMS#onFinishInputView, because the input view will be re-initialized
+                // according to the last #mShowInputRequested state. So in this case we treat the
+                // input view as still alive.
+                verifyInputViewStatusOnMainSync(
+                        () -> mInputMethodService.onConfigurationChanged(config),
+                        EVENT_CONFIG, true /* eventExpected */, true /* inputViewStarted */,
+                        false /* shown */, "IME is not shown after a configuration change");
+            }
         } finally {
             mInputMethodService.getResources()
                     .updateConfiguration(initialConfig, null /* metrics */, null /* compat */);
@@ -628,12 +579,10 @@ public class InputMethodServiceTest {
             config.keyboard = Configuration.KEYBOARD_QWERTY;
             config.hardKeyboardHidden = Configuration.HARDKEYBOARDHIDDEN_YES;
 
-            // Explicit show request.
             verifyInputViewStatusOnMainSync(() -> assertThat(
                             mActivity.showImeWithInputMethodManager(0 /* flags */)).isTrue(),
                     EVENT_SHOW, true /* eventExpected */, true /* shown */, "IME is shown");
 
-            // Implicit show request.
             verifyInputViewStatusOnMainSync(() -> assertThat(
                             mActivity.showImeWithInputMethodManager(
                                     InputMethodManager.SHOW_IMPLICIT)).isTrue(),
@@ -654,15 +603,16 @@ public class InputMethodServiceTest {
 
     /**
      * This checks that a forced show request directly followed by an explicit show request,
-     * and then a hide not always request, still results in the IME being shown
-     * (i.e. the explicit show request retains the forced state).
+     * and then a not always hide request behaves like a normal hide request, resulting in the
+     * IME being hidden (i.e. the explicit show request does not retain the forced state). This is
+     * due to the refactor in b/298172246, causing us to lose flag information like
+     * {@link InputMethodManager#SHOW_FORCED}.
      *
-     * <p>With the refactor in b/298172246, all calls from InputMethodManager#{show,hide}SoftInput
-     * will be redirected to InsetsController#{show,hide}. Therefore, we will lose flags like
-     * HIDE_NOT_ALWAYS.
+     * <p>Previously, a forced show request directly followed by an explicit show request,
+     * and then a not always hide request, would result in the IME still being shown
+     * (i.e. the explicit show request would retain the forced state).
      */
     @Test
-    @RequiresFlagsDisabled(Flags.FLAG_REFACTOR_INSETS_CONTROLLER)
     public void testShowSoftInputForced_testShowSoftInputExplicitly_thenHideSoftInputNotAlways() {
         setShowImeWithHardKeyboard(true /* enabled */);
 
@@ -674,11 +624,123 @@ public class InputMethodServiceTest {
                         mActivity.showImeWithInputMethodManager(0 /* flags */)).isTrue(),
                 EVENT_SHOW, false /* eventExpected */, true /* shown */, "IME is still shown");
 
-        verifyInputViewStatusOnMainSync(() -> assertThat(
-                        mActivity.hideImeWithInputMethodManager(InputMethodManager.HIDE_NOT_ALWAYS))
-                        .isTrue(),
-                EVENT_HIDE, false /* eventExpected */, true /* shown */,
-                "IME is still shown after HIDE_NOT_ALWAYS");
+        if (mFlagsValueProvider.getBoolean(Flags.FLAG_REFACTOR_INSETS_CONTROLLER)) {
+            verifyInputViewStatusOnMainSync(() -> assertThat(mActivity
+                            .hideImeWithInputMethodManager(InputMethodManager.HIDE_NOT_ALWAYS))
+                            .isTrue(),
+                    EVENT_HIDE, true /* eventExpected */, false /* shown */,
+                    "IME is not shown after HIDE_NOT_ALWAYS");
+        } else {
+            verifyInputViewStatusOnMainSync(() -> assertThat(mActivity
+                            .hideImeWithInputMethodManager(InputMethodManager.HIDE_NOT_ALWAYS))
+                            .isTrue(),
+                    EVENT_HIDE, false /* eventExpected */, true /* shown */,
+                    "IME is still shown after HIDE_NOT_ALWAYS");
+        }
+    }
+
+    /**
+     * This checks that an explicit show request followed by an implicit only hide request
+     * behaves like a normal hide request, resulting in the IME being hidden. This is due to
+     * the refactor in b/298172246, causing us to lose flag information like
+     * {@link InputMethodManager#SHOW_IMPLICIT} and {@link InputMethodManager#HIDE_IMPLICIT_ONLY}.
+     *
+     * <p>Previously, an explicit show request followed by an implicit only hide request
+     * would result in the IME still being shown.
+     */
+    @Test
+    public void testShowSoftInputExplicitly_thenHideSoftInputImplicitOnly() {
+        setShowImeWithHardKeyboard(true /* enabled */);
+
+        verifyInputViewStatusOnMainSync(
+                () -> mActivity.showImeWithInputMethodManager(0 /* flags */),
+                EVENT_SHOW, true /* eventExpected */, true /* shown */, "IME is shown");
+
+        if (mFlagsValueProvider.getBoolean(Flags.FLAG_REFACTOR_INSETS_CONTROLLER)) {
+            verifyInputViewStatusOnMainSync(
+                    () -> mActivity.hideImeWithInputMethodManager(
+                            InputMethodManager.HIDE_IMPLICIT_ONLY),
+                    EVENT_HIDE, true /* eventExpected */, false /* shown */,
+                    "IME is not shown after HIDE_IMPLICIT_ONLY");
+        } else {
+            verifyInputViewStatusOnMainSync(
+                    () -> mActivity.hideImeWithInputMethodManager(
+                            InputMethodManager.HIDE_IMPLICIT_ONLY),
+                    EVENT_HIDE, false /* eventExpected */, true /* shown */,
+                    "IME is still shown after HIDE_IMPLICIT_ONLY");
+        }
+    }
+
+    /**
+     * This checks that an implicit show request followed by an implicit only hide request
+     * results in the IME being hidden.
+     */
+    @Test
+    public void testShowSoftInputImplicitly_thenHideSoftInputImplicitOnly() {
+        setShowImeWithHardKeyboard(true /* enabled */);
+
+        verifyInputViewStatusOnMainSync(
+                () -> mActivity.showImeWithInputMethodManager(InputMethodManager.SHOW_IMPLICIT),
+                EVENT_SHOW, true /* eventExpected */, true /* shown */,
+                "IME is shown with SHOW_IMPLICIT");
+
+        verifyInputViewStatusOnMainSync(
+                () -> mActivity.hideImeWithInputMethodManager(
+                        InputMethodManager.HIDE_IMPLICIT_ONLY),
+                EVENT_HIDE, true /* eventExpected */, false /* shown */,
+                "IME is not shown after HIDE_IMPLICIT_ONLY");
+    }
+
+    /**
+     * This checks that an explicit show self request followed by an implicit only hide self request
+     * behaves like a normal hide self request, resulting in the IME being hidden. This is due to
+     * the refactor in b/298172246, causing us to lose flag information like
+     * {@link InputMethodManager#SHOW_IMPLICIT} and {@link InputMethodManager#HIDE_IMPLICIT_ONLY}.
+     *
+     * <p>Previously, an explicit show self request followed by an implicit only hide self request
+     * would result in the IME still being shown.
+     */
+    @Test
+    public void testShowSelfExplicitly_thenHideSelfImplicitOnly() {
+        setShowImeWithHardKeyboard(true /* enabled */);
+
+        verifyInputViewStatusOnMainSync(
+                () -> mInputMethodService.requestShowSelf(0 /* flags */),
+                EVENT_SHOW, true /* eventExpected */, true /* shown */, "IME is shown");
+
+        if (mFlagsValueProvider.getBoolean(Flags.FLAG_REFACTOR_INSETS_CONTROLLER)) {
+            verifyInputViewStatusOnMainSync(
+                    () -> mInputMethodService.requestHideSelf(
+                            InputMethodManager.HIDE_IMPLICIT_ONLY),
+                    EVENT_HIDE, true /* eventExpected */, false /* shown */,
+                    "IME is not shown after HIDE_IMPLICIT_ONLY");
+        } else {
+            verifyInputViewStatusOnMainSync(
+                    () -> mInputMethodService.requestHideSelf(
+                            InputMethodManager.HIDE_IMPLICIT_ONLY),
+                    EVENT_HIDE, false /* eventExpected */, true /* shown */,
+                    "IME is still shown after HIDE_IMPLICIT_ONLY");
+        }
+    }
+
+    /**
+     * This checks that an implicit show self request followed by an implicit only hide self request
+     * results in the IME being hidden.
+     */
+    @Test
+    public void testShowSelfImplicitly_thenHideSelfImplicitOnly() {
+        setShowImeWithHardKeyboard(true /* enabled */);
+
+        verifyInputViewStatusOnMainSync(
+                () -> mInputMethodService.requestShowSelf(InputMethodManager.SHOW_IMPLICIT),
+                EVENT_SHOW, true /* eventExpected */, true /* shown */,
+                "IME is shown with SHOW_IMPLICIT");
+
+        verifyInputViewStatusOnMainSync(
+                () -> mInputMethodService.requestHideSelf(
+                        InputMethodManager.HIDE_IMPLICIT_ONLY),
+                EVENT_HIDE, true /* eventExpected */, false /* shown */,
+                "IME is not shown after HIDE_IMPLICIT_ONLY");
     }
 
     /**
@@ -725,7 +787,6 @@ public class InputMethodServiceTest {
 
         setShowImeWithHardKeyboard(true /* enabled */);
 
-        // Show IME
         verifyInputViewStatusOnMainSync(
                 () -> {
                     setDrawsImeNavBarAndSwitcherButton(true /* enabled */);
@@ -735,13 +796,11 @@ public class InputMethodServiceTest {
         assertWithMessage("IME navigation bar is initially shown")
                 .that(mInputMethodService.isImeNavigationBarShownForTesting()).isTrue();
 
-        // Try to hide IME nav bar
         mInstrumentation.runOnMainSync(() -> setShowImeNavigationBar(false /* show */));
         mInstrumentation.waitForIdleSync();
         assertWithMessage("IME navigation bar is not shown after hide request")
                 .that(mInputMethodService.isImeNavigationBarShownForTesting()).isFalse();
 
-        // Try to show IME nav bar
         mInstrumentation.runOnMainSync(() -> setShowImeNavigationBar(true /* show */));
         mInstrumentation.waitForIdleSync();
         assertWithMessage("IME navigation bar is shown after show request")
@@ -760,7 +819,6 @@ public class InputMethodServiceTest {
 
         setShowImeWithHardKeyboard(true /* enabled */);
 
-        // Show IME
         verifyInputViewStatusOnMainSync(
                 () -> {
                     setDrawsImeNavBarAndSwitcherButton(false /* enabled */);
@@ -770,13 +828,11 @@ public class InputMethodServiceTest {
         assertWithMessage("IME navigation bar is initially not shown")
                 .that(mInputMethodService.isImeNavigationBarShownForTesting()).isFalse();
 
-        // Try to hide IME nav bar
         mInstrumentation.runOnMainSync(() -> setShowImeNavigationBar(false /* show */));
         mInstrumentation.waitForIdleSync();
         assertWithMessage("IME navigation bar is not shown after hide request")
                 .that(mInputMethodService.isImeNavigationBarShownForTesting()).isFalse();
 
-        // Try to show IME nav bar
         mInstrumentation.runOnMainSync(() -> setShowImeNavigationBar(true /* show */));
         mInstrumentation.waitForIdleSync();
         assertWithMessage("IME navigation bar is not shown after show request")
@@ -1016,10 +1072,8 @@ public class InputMethodServiceTest {
         verifyInputViewStatus(runnable, EVENT_CONFIG, eventExpected, false /* shown */,
                 "IME is not shown");
         if (eventExpected) {
-            // Wait for the TestActivity to be recreated.
             eventually(() -> assertWithMessage("Activity was re-created after rotation")
                     .that(TestActivity.getInstance()).isNotEqualTo(mActivity));
-            // Get the new TestActivity.
             mActivity = TestActivity.getInstance();
             assertWithMessage("Re-created activity is not null").that(mActivity).isNotNull();
             // Wait for the new EditText to be served by InputMethodManager.
diff --git a/services/tests/InputMethodSystemServerTests/test-apps/SimpleTestIme/src/com/android/apps/inputmethod/simpleime/ims/InputMethodServiceWrapper.java b/services/tests/InputMethodSystemServerTests/test-apps/SimpleTestIme/src/com/android/apps/inputmethod/simpleime/ims/InputMethodServiceWrapper.java
index 558d1a7c4e8b..d4d4dcaa4f48 100644
--- a/services/tests/InputMethodSystemServerTests/test-apps/SimpleTestIme/src/com/android/apps/inputmethod/simpleime/ims/InputMethodServiceWrapper.java
+++ b/services/tests/InputMethodSystemServerTests/test-apps/SimpleTestIme/src/com/android/apps/inputmethod/simpleime/ims/InputMethodServiceWrapper.java
@@ -111,12 +111,6 @@ public class InputMethodServiceWrapper extends InputMethodService {
     }
 
     @Override
-    public void requestHideSelf(int flags) {
-        Log.i(TAG, "requestHideSelf() " + flags);
-        super.requestHideSelf(flags);
-    }
-
-    @Override
     public void onConfigurationChanged(Configuration newConfig) {
         Log.i(TAG, "onConfigurationChanged() " + newConfig);
         super.onConfigurationChanged(newConfig);