Switch to dispatchKeyEvent instead of dispatchKeyEventPreIme

Author: gspencergoog

shell/platform/android/io/flutter/embedding/android/AndroidKeyProcessor.java

@@ -91,8 +91,9 @@ public void destroy() {
   public boolean onKeyEvent(@NonNull KeyEvent keyEvent) {
     int action = keyEvent.getAction();
     if (action != KeyEvent.ACTION_DOWN && action != KeyEvent.ACTION_UP) {
-      // There is theoretically a KeyEvent.ACTION_MULTIPLE, but that shouldn't
-      // be sent anymore anyhow.
+      // There is theoretically a KeyEvent.ACTION_MULTIPLE, but theoretically
+      // that isn't sent by Android anymore, so this is just for protection in
+      // case the theory is wrong.
       return false;
     }
     if (eventResponder.dispatchingKeyEvent) {
@@ -109,14 +110,7 @@ public boolean onKeyEvent(@NonNull KeyEvent keyEvent) {
       keyEventChannel.keyUp(flutterEvent);
     }
     eventResponder.addEvent(flutterEvent.eventId, keyEvent);
-
-    // We can't return "true" for system keys, since Android won't re-dispatch
-    // it later to the IME when we call dispatchKeyEventPreIme with it, even if
-    // we send it to our root view. Sadly, this means that even if you handle a
-    // system key (like the back button) in Flutter, the button press still gets
-    // propagated to the IME, etc., and you can't block the soft keyboard from
-    // being dismissed.
-    return !keyEvent.isSystem();
+    return true;
   }
 
   /**
@@ -270,10 +264,8 @@ public void dispatchKeyEvent(KeyEvent event) {
         }
       }
 
-      // Since the framework didn't handle it, dispatch the event again, unless
-      // it's a system key, which has already been returned to the system as not
-      // handled in onKeyEvent, above.
-      if (view != null && !event.isSystem()) {
+      // Since the framework didn't handle it, dispatch the event again.
+      if (view != null) {
         // Turn on dispatchingKeyEvent so that we don't dispatch to ourselves and
         // send it to the framework again.
         dispatchingKeyEvent = true;

shell/platform/android/io/flutter/embedding/android/FlutterView.java

@@ -721,36 +721,36 @@ public boolean checkInputConnectionProxy(View view) {
   }
 
   /**
-   * Invoked when a hardware key is pressed or released, before the IME receives the key.
+   * Invoked when a hardware key is pressed or released.
    *
    * <p>This method is typically invoked in response to the press of a physical keyboard key or a
    * D-pad button. It is generally not invoked when a virtual software keyboard is used, though a
-   * software keyboard may choose to invoke this method in some situations,
-   * notably the back button often causes this function to be invoked.
+   * software keyboard may choose to invoke this method in some situations.
    *
    * <p>{@link KeyEvent}s are sent from Android to Flutter. {@link AndroidKeyProcessor} may do some
    * additional work with the given {@link KeyEvent}, e.g., combine this {@code keyCode} with the
    * previous {@code keyCode} to generate a unicode combined character.
    */
   @Override
-  public boolean dispatchKeyEventPreIme(KeyEvent event) {
+  public boolean dispatchKeyEvent(KeyEvent event) {
     if (event.getAction() == KeyEvent.ACTION_DOWN && event.getRepeatCount() == 0) {
       // Tell Android to start tracking this event.
       getKeyDispatcherState().startTracking(event, this);
     } else if (event.getAction() == KeyEvent.ACTION_UP) {
+      // Stop tracking the event.
       getKeyDispatcherState().handleUpEvent(event);
       if (!event.isTracking() || event.isCanceled()) {
         // Don't send the event to the key processor if it was canceled, or no
         // longer being tracked.
-        return super.dispatchKeyEventPreIme(event);
+        return super.dispatchKeyEvent(event);
       }
     }
     // If the key processor doesn't handle it, then send it on to the
     // superclass. The key processor will typically handle all events except
     // those where it has re-dispatched the event after receiving a reply from
     // the framework that the framework did not handle it.
     return (isAttachedToFlutterEngine() && androidKeyProcessor.onKeyEvent(event))
-        || super.dispatchKeyEventPreIme(event);
+        || super.dispatchKeyEvent(event);
   }
 
   /**