Fix previous text input connection interrupts enter/space (flutter#171973)

Fixes an issue where a previously closed text input connection may cause
interference with hardware keyboard on Samsung devices.

On the Samsung Galaxy S10 Tab the Samsung IME will request the operating
system to show the IME when pressing enter/space on components like a
radio option or a checkbox if there was a previously opened text input
connection. It seems the Samsung Keyboard is caching some text input
related state, and when it detects an enter/space key it acts on this
previously cached state even if the text input connection has been
closed. This prevents the radio option/checkbox and framework as a whole
from responding to the key events. To solve this issue we should reset
the input method manager when the IME has been hidden, and when the
framework closes the input connection we should also reset the input
method manager if the IME is hidden at the time of closing. This
effectively resets any state cached by the Samsung keyboard and it no
longer acts on stale state.

Fixes flutter#168099
Fixes flutter#51478
Fixes flutter#70546

Related:
flutter#136745

## Pre-launch Checklist

- [x] I read the [Contributor Guide] and followed the process outlined
there for submitting PRs.
- [x] I read the [Tree Hygiene] wiki page, which explains my
responsibilities.
- [x] I read and followed the [Flutter Style Guide], including [Features
we expect every widget to implement].
- [x] I signed the [CLA].
- [x] I listed at least one issue that this PR fixes in the description
above.
- [x] I updated/added relevant documentation (doc comments with `///`).
- [x] I added new tests to check the change I am making, or this PR is
[test-exempt].
- [x] I followed the [breaking change policy] and added [Data Driven
Fixes] where supported.
- [x] All existing and new tests are passing.

---------

Co-authored-by: Renzo Olivares <roliv@google.com>

Author: Renzo-Olivares

engine/src/flutter/shell/platform/android/io/flutter/plugin/editing/ImeSyncDeferringInsetsCallback.java

@@ -15,6 +15,8 @@
 import androidx.annotation.NonNull;
 import androidx.annotation.RequiresApi;
 import androidx.annotation.VisibleForTesting;
+import androidx.core.view.ViewCompat;
+import androidx.core.view.WindowInsetsCompat;
 import java.util.List;
 
 // Loosely based off of
@@ -52,6 +54,7 @@ class ImeSyncDeferringInsetsCallback {
   private WindowInsets lastWindowInsets;
   private AnimationCallback animationCallback;
   private InsetsListener insetsListener;
+  private ImeVisibilityListener imeVisibilityListener;
 
   // True when an animation that matches deferredInsetTypes is active.
   //
@@ -89,6 +92,11 @@ void remove() {
     view.setOnApplyWindowInsetsListener(null);
   }
 
+  // Set a listener to be notified when the IME visibility changes.
+  void setImeVisibilityListener(ImeVisibilityListener imeVisibilityListener) {
+    this.imeVisibilityListener = imeVisibilityListener;
+  }
+
   @VisibleForTesting
   View.OnApplyWindowInsetsListener getInsetsListener() {
     return insetsListener;
@@ -99,6 +107,11 @@ WindowInsetsAnimation.Callback getAnimationCallback() {
     return animationCallback;
   }
 
+  @VisibleForTesting
+  ImeVisibilityListener getImeVisibilityListener() {
+    return imeVisibilityListener;
+  }
+
   // WindowInsetsAnimation.Callback was introduced in API level 30.  The callback
   // subclass is separated into an inner class in order to avoid warnings from
   // the Android class loader on older platforms.
@@ -173,6 +186,11 @@ public void onEnd(WindowInsetsAnimation animation) {
           view.dispatchApplyWindowInsets(lastWindowInsets);
         }
       }
+      WindowInsetsCompat insets = ViewCompat.getRootWindowInsets(view);
+      if (insets != null && imeVisibilityListener != null) {
+        boolean imeVisible = insets.isVisible(WindowInsetsCompat.Type.ime());
+        imeVisibilityListener.onImeVisibilityChanged(imeVisible);
+      }
     }
   }
 
@@ -200,4 +218,9 @@ public WindowInsets onApplyWindowInsets(View view, WindowInsets windowInsets) {
       return view.onApplyWindowInsets(windowInsets);
     }
   }
+
+  // Listener for IME visibility changes.
+  public interface ImeVisibilityListener {
+    void onImeVisibilityChanged(boolean visible);
+  }
 }

engine/src/flutter/shell/platform/android/io/flutter/plugin/editing/TextInputPlugin.java

@@ -27,6 +27,8 @@
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.annotation.VisibleForTesting;
+import androidx.core.view.ViewCompat;
+import androidx.core.view.WindowInsetsCompat;
 import androidx.core.view.inputmethod.EditorInfoCompat;
 import io.flutter.Log;
 import io.flutter.embedding.android.KeyboardManager;
@@ -90,6 +92,18 @@ public TextInputPlugin(
     if (Build.VERSION.SDK_INT >= API_LEVELS.API_30) {
       imeSyncCallback = new ImeSyncDeferringInsetsCallback(view);
       imeSyncCallback.install();
+
+      // When the IME is hidden, we need to restart the input method manager to accomodate
+      // some keyboards like the Samsung keyboard that may be caching old state.
+      imeSyncCallback.setImeVisibilityListener(
+          new ImeSyncDeferringInsetsCallback.ImeVisibilityListener() {
+            @Override
+            public void onImeVisibilityChanged(boolean visible) {
+              if (!visible) {
+                mImm.restartInput(mView);
+              }
+            }
+          });
     }
 
     this.textInputChannel = textInputChannel;
@@ -583,6 +597,12 @@ void clearTextInputClient() {
     inputTarget = new InputTarget(InputTarget.Type.NO_TARGET, 0);
     unlockPlatformViewInputConnection();
     lastClientRect = null;
+    // When the IME is hidden, we need to restart the input method manager to accomodate
+    // some keyboards like the Samsung keyboard that may be caching old state.
+    WindowInsetsCompat insets = ViewCompat.getRootWindowInsets(mView);
+    if (insets != null && !insets.isVisible(WindowInsetsCompat.Type.ime())) {
+      mImm.restartInput(mView);
+    }
   }
 
   private static class InputTarget {

engine/src/flutter/shell/platform/android/test/io/flutter/plugin/editing/TextInputPluginTest.java

@@ -1230,6 +1230,121 @@ public void setTextInputEditingState_nullInputMethodSubtype() {
     assertEquals(1, testImm.getRestartCount(testView));
   }
 
+  @Test
+  public void imeVisibilityListener_restartsImmWhenIMEHidden() {
+    // Initialize a general TextInputPlugin.
+    InputMethodSubtype inputMethodSubtype = mock(InputMethodSubtype.class);
+    TestImm testImm = Shadow.extract(ctx.getSystemService(Context.INPUT_METHOD_SERVICE));
+    testImm.setCurrentInputMethodSubtype(inputMethodSubtype);
+    View testView = new View(ctx);
+    TextInputChannel textInputChannel = new TextInputChannel(mock(DartExecutor.class));
+    ScribeChannel scribeChannel = new ScribeChannel(mock(DartExecutor.class));
+    TextInputPlugin textInputPlugin =
+        new TextInputPlugin(
+            testView,
+            textInputChannel,
+            scribeChannel,
+            mock(PlatformViewsController.class),
+            mock(PlatformViewsController2.class));
+    textInputPlugin.setTextInputClient(
+        0,
+        new TextInputChannel.Configuration(
+            false,
+            false,
+            true,
+            true,
+            false,
+            TextInputChannel.TextCapitalization.NONE,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null));
+    // There's a pending restart since we initialized the text input client. Flush that now.
+    textInputPlugin.setTextInputEditingState(
+        testView, new TextInputChannel.TextEditState("", 0, 0, -1, -1));
+    assertEquals(1, testImm.getRestartCount(testView));
+
+    // Imm restarts when IME is hidden.
+    ImeSyncDeferringInsetsCallback imeSyncCallback = textInputPlugin.getImeSyncCallback();
+    imeSyncCallback.getImeVisibilityListener().onImeVisibilityChanged(false);
+    assertEquals(2, testImm.getRestartCount(testView));
+  }
+
+  @Test
+  public void clearTextInputClient_restartsImmWhenIMEHidden() {
+    try (ActivityScenario<Activity> scenario = ActivityScenario.launch(Activity.class)) {
+      scenario.onActivity(
+          activity -> {
+            FlutterView testView = spy(new FlutterView(activity));
+
+            InputMethodSubtype inputMethodSubtype = mock(InputMethodSubtype.class);
+            TestImm testImm = Shadow.extract(ctx.getSystemService(Context.INPUT_METHOD_SERVICE));
+            testImm.setCurrentInputMethodSubtype(inputMethodSubtype);
+            TextInputChannel textInputChannel = new TextInputChannel(mock(DartExecutor.class));
+            ScribeChannel scribeChannel = new ScribeChannel(mock(DartExecutor.class));
+            TextInputPlugin textInputPlugin =
+                new TextInputPlugin(
+                    testView,
+                    textInputChannel,
+                    scribeChannel,
+                    mock(PlatformViewsController.class),
+                    mock(PlatformViewsController2.class));
+            textInputPlugin.setTextInputClient(
+                0,
+                new TextInputChannel.Configuration(
+                    false,
+                    false,
+                    true,
+                    true,
+                    false,
+                    TextInputChannel.TextCapitalization.NONE,
+                    null,
+                    null,
+                    null,
+                    null,
+                    null,
+                    null,
+                    null));
+            ImeSyncDeferringInsetsCallback imeSyncCallback = textInputPlugin.getImeSyncCallback();
+            FlutterEngine flutterEngine =
+                spy(new FlutterEngine(ctx, mockFlutterLoader, mockFlutterJni));
+            FlutterRenderer flutterRenderer = spy(new FlutterRenderer(mockFlutterJni));
+            when(flutterEngine.getRenderer()).thenReturn(flutterRenderer);
+            assertEquals(0, testImm.getRestartCount(testView));
+            // FlutterView restarts the input method to inform the Android framework that an engine
+            // has
+            // been attached.
+            testView.attachToFlutterEngine(flutterEngine);
+            assertEquals(1, testImm.getRestartCount(testView));
+
+            ArgumentCaptor<FlutterRenderer.ViewportMetrics> viewportMetricsCaptor =
+                ArgumentCaptor.forClass(FlutterRenderer.ViewportMetrics.class);
+
+            WindowInsets.Builder builder = new WindowInsets.Builder();
+
+            // There's a pending restart since we initialized the text input client. Flush that now.
+            textInputPlugin.setTextInputEditingState(
+                testView, new TextInputChannel.TextEditState("", 0, 0, -1, -1));
+            assertEquals(2, testImm.getRestartCount(testView));
+
+            // Set the initial insets and verify that they were set and the bottom view inset is
+            // correct.
+            builder.setInsets(WindowInsets.Type.ime(), Insets.of(0, 0, 0, 0));
+            when(testView.getRootWindowInsets()).thenReturn(builder.build());
+            imeSyncCallback.getInsetsListener().onApplyWindowInsets(testView, builder.build());
+            verify(flutterRenderer, atLeast(1)).setViewportMetrics(viewportMetricsCaptor.capture());
+            assertEquals(0, viewportMetricsCaptor.getValue().viewInsetBottom);
+
+            // Imm restarts when clearTextInputClient is called while the IME is hidden.
+            textInputPlugin.clearTextInputClient();
+            assertEquals(3, testImm.getRestartCount(testView));
+          });
+    }
+  }
+
   @Test
   public void destroy_clearTextInputMethodHandler() {
     View testView = new View(ctx);