Start sending synthetic keyevents for enter and tab in Android IME

content/public/android/java/src/org/chromium/content/browser/ImeAdapter.java

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.content.browser;
 
 import android.content.Context;
 import android.os.Handler;
 import android.os.ResultReceiver;
 import android.text.Editable;
@@ skipping 99 matching lines @@
         sTextInputTypeTel = textInputTypeTel;
         sTextInputTypeNumber = textInputTypeNumber;
         sTextInputTypeWeek = textInputTypeWeek;
         sTextInputTypeContentEditable = textInputTypeContentEditable;
         InputDialogContainer.initializeInputTypes(textInputTypeDate, textInputTypeDateTime,
                 textInputTypeDateTimeLocal, textInputTypeMonth, textInputTypeTime);
     }
 
     private int mNativeImeAdapterAndroid;
     private int mTextInputType;
-    private int mPreImeEventCount;
 
     private Context mContext;
     private SelectionHandleController mSelectionHandleController;
     private InsertionHandleController mInsertionHandleController;
     private AdapterInputConnection mInputConnection;
     private ViewEmbedder mViewEmbedder;
     private Handler mHandler;
     private InputDialogContainer mInputDialogContainer;
 
     private class DelayedDismissInput implements Runnable {
@@ skipping 14 matching lines @@
 
     // Delay introduced to avoid hiding the keyboard if new show requests are received.
     // The time required by the unfocus-focus events triggered by tab has been measured in soju:
     // Mean: 18.633 ms, Standard deviation: 7.9837 ms.
     // The value here should be higher enough to cover these cases, but not too high to avoid
     // letting the user perceiving important delays.
     private static final int INPUT_DISMISS_DELAY = 150;
 
     ImeAdapter(Context context, SelectionHandleController selectionHandleController,
             InsertionHandleController insertionHandleController, ViewEmbedder embedder) {
-        mPreImeEventCount = 0;
         mContext = context;
         mSelectionHandleController = selectionHandleController;
         mInsertionHandleController = insertionHandleController;
         mViewEmbedder = embedder;
         mHandler = new Handler();
         mInputDialogContainer = new InputDialogContainer(context,
                 new InputDialogContainer.InputActionDelegate() {
 
                     @Override
                     public void replaceDateTime(String text) {
@@ skipping 129 matching lines @@
     }
 
     boolean hasTextInputType() {
         return isTextInputType(mTextInputType);
     }
 
     boolean hasDialogInputType() {
         return InputDialogContainer.isDialogInputType(mTextInputType);
     }
 
-    void dispatchKeyEventPreIme(KeyEvent event) {
-        // We only register that a key was pressed, but we don't actually intercept
-        // it.
-        ++mPreImeEventCount;
-    }
-
     boolean dispatchKeyEvent(KeyEvent event) {
-        mPreImeEventCount = 0;
         return translateAndSendNativeEvents(event);
     }
 
     void commitText() {
         cancelComposition();
         if (mNativeImeAdapterAndroid != 0) {
             nativeCommitText(mNativeImeAdapterAndroid, "");
         }
     }
 
@@ skipping 11 matching lines @@
             return false;
         }
 
         // Committing an empty string finishes the current composition.
         boolean isFinish = text.isEmpty();
         if (!isFinish) {
             mSelectionHandleController.hideAndDisallowAutomaticShowing();
             mInsertionHandleController.hideAndDisallowAutomaticShowing();
         }
         mViewEmbedder.onImeEvent(isFinish);
-        boolean hasSingleChar = mPreImeEventCount == 1 && text.length() == 1;
-        int keyCode = hasSingleChar ? text.codePointAt(0) : COMPOSITION_KEY_CODE;
-        int keyChar = hasSingleChar ? text.codePointAt(0) : 0;
+        boolean hasSingleChar = text.length() == 1;

[aurimas (slooooooooow), 2013/01/16 00:39:57]

This is not needed anymore since shouldSendKeyEventWithKeyCode() checks for
that.

[Yusuf, 2013/01/16 08:07:57]

Done.

+        int keyCode = shouldSendKeyEventWithKeyCode(text);
+        int keyChar = keyCode == COMPOSITION_KEY_CODE ? 0 : text.codePointAt(0);
         long timeStampMs = System.currentTimeMillis();
+
         nativeSendSyntheticKeyEvent(mNativeImeAdapterAndroid, sEventTypeRawKeyDown,
-                timeStampMs, keyCode,  keyChar);
-        if (hasSingleChar) {
+                timeStampMs, keyCode, keyChar);
+        if (hasSingleChar && keyCode != COMPOSITION_KEY_CODE) {
             nativeSendSyntheticKeyEvent(mNativeImeAdapterAndroid, sEventTypeChar,
-                    timeStampMs, text.codePointAt(0), text.codePointAt(0));
+                    timeStampMs, keyCode, keyChar);

[Ted C, 2013/01/16 02:13:30]

previously this sent the same two values...now you are sending

(KeyEvent.ENTER|TAB, text.codePointAt(0))

Are they the same values?  Is this dependent on another change?  Was it wrong
before?

[Yusuf, 2013/01/16 08:07:57]

Sadly this part of the code never really worked for months after some changes in
the framework, but the IME kept on working because the way it wasn't working was
still OK. So I thought I should do a bit of a clean up and make it clear that we
should not be sending these KeyEvents in all cases.

On 2013/01/16 02:13:30, Ted C wrote:

         } else {
             if (isCommit) {
                 nativeCommitText(mNativeImeAdapterAndroid, text);
             } else {
                 nativeSetComposingText(mNativeImeAdapterAndroid, text, newCursorPosition);
             }
         }
         nativeSendSyntheticKeyEvent(mNativeImeAdapterAndroid, sEventTypeKeyUp,
                 timeStampMs, keyCode, keyChar);
-        mPreImeEventCount = 0;
         return true;
     }
 
+    private int shouldSendKeyEventWithKeyCode(String singleChar) {

[aurimas (slooooooooow), 2013/01/16 00:39:57]

Might not be a single char, should call it some other way

[Yusuf, 2013/01/16 08:07:57]

Done.

+        if (singleChar.equals("\n")) return KeyEvent.KEYCODE_ENTER;
+        else if (singleChar.equals("\t")) return KeyEvent.KEYCODE_TAB;
+        else return COMPOSITION_KEY_CODE;
+    }
+
     private boolean translateAndSendNativeEvents(KeyEvent event) {
         if (mNativeImeAdapterAndroid == 0) {
             return false;
         }
         int action = event.getAction();
         if (action != KeyEvent.ACTION_DOWN &&
             action != KeyEvent.ACTION_UP) {
             // action == KeyEvent.ACTION_MULTIPLE
             // TODO(bulach): confirm the actual behavior. Apparently:
             // If event.getKeyCode() == KEYCODE_UNKNOWN, we can send a
@@ skipping 413 matching lines @@
 
     private native void nativeDeleteSurroundingText(int nativeImeAdapterAndroid,
             int before, int after);
 
     private native void nativeUnselect(int nativeImeAdapterAndroid);
     private native void nativeSelectAll(int nativeImeAdapterAndroid);
     private native void nativeCut(int nativeImeAdapterAndroid);
     private native void nativeCopy(int nativeImeAdapterAndroid);
     private native void nativePaste(int nativeImeAdapterAndroid);
 }