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;
 import android.text.InputType;
 import android.text.Selection;
+import android.view.KeyCharacterMap;
 import android.view.KeyEvent;
 import android.view.View;
 import android.view.inputmethod.BaseInputConnection;
 import android.view.inputmethod.EditorInfo;
 import android.view.inputmethod.ExtractedText;
 import android.view.inputmethod.ExtractedTextRequest;
 import android.view.inputmethod.InputMethodManager;
 
 import org.chromium.base.CalledByNative;
 import org.chromium.base.JNINamespace;
 
 // We have to adapt and plumb android IME service and chrome text input API.
 // ImeAdapter provides an interface in both ways native <-> java:
 // 1. InputConnectionAdapter notifies native code of text composition state and
 //    dispatch key events from java -> WebKit.
 // 2. Native ImeAdapter notifies java side to clear composition text.
 //
 // The basic flow is:
-// 1. Intercept dispatchKeyEventPreIme() to record the current key event, but do
-//    nothing else.
-// 2. When InputConnectionAdapter gets called with composition or result text:
+// 1. When InputConnectionAdapter gets called with composition or result text:
 //    a) If a key event has been recorded in dispatchKeyEventPreIme() and we

[aurimas (slooooooooow), 2013/01/16 23:54:46]

Should this dispatchKeyEventPreIme() comment change too?

[Yusuf, 2013/01/17 00:44:19]

Done.

 //       receive a result text with single character, then we probably need to
 //       send the result text as a Char event rather than a ConfirmComposition
 //       event. So we need to dispatch the recorded key event followed by a
 //       synthetic Char event.
 //    b) If we receive a composition text or a result text with more than one
 //       characters, then no matter if we recorded a key event or not in
 //       dispatchKeyEventPreIme(), we just need to dispatch a synthetic key
 //       event with special keycode 229, and then dispatch the composition or
 //       result text.
-// 3. Intercept dispatchKeyEvent() method for key events not handled by IME, we
+// 2. Intercept dispatchKeyEvent() method for key events not handled by IME, we
 //    need to dispatch them to webkit and check webkit's reply. Then inject a
 //    new key event for further processing if webkit didn't handle it.
 @JNINamespace("content")
 class ImeAdapter {
     interface ViewEmbedder {
         /**
          * @param isFinish whether the event is occuring because input is finished.
          */
         public void onImeEvent(boolean isFinish);
         public void onSetFieldValue();
@@ skipping 55 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;
+        int keyCode = shouldSendKeyEventWithKeyCode(text);
         long timeStampMs = System.currentTimeMillis();
-        nativeSendSyntheticKeyEvent(mNativeImeAdapterAndroid, sEventTypeRawKeyDown,
-                timeStampMs, keyCode,  keyChar);
-        if (hasSingleChar) {
-            nativeSendSyntheticKeyEvent(mNativeImeAdapterAndroid, sEventTypeChar,
-                    timeStampMs, text.codePointAt(0), text.codePointAt(0));
+
+        if (keyCode != COMPOSITION_KEY_CODE) {
+            sendKeyEventWithKeyCode(keyCode,
+                    KeyEvent.FLAG_SOFT_KEYBOARD | KeyEvent.FLAG_KEEP_TOUCH_MODE);
         } else {
+            nativeSendSyntheticKeyEvent(mNativeImeAdapterAndroid, sEventTypeRawKeyDown,
+                    timeStampMs, keyCode, 0);
             if (isCommit) {
                 nativeCommitText(mNativeImeAdapterAndroid, text);
             } else {
                 nativeSetComposingText(mNativeImeAdapterAndroid, text, newCursorPosition);
             }
+            nativeSendSyntheticKeyEvent(mNativeImeAdapterAndroid, sEventTypeKeyUp,
+                    timeStampMs, keyCode, 0);
         }
-        nativeSendSyntheticKeyEvent(mNativeImeAdapterAndroid, sEventTypeKeyUp,
-                timeStampMs, keyCode, keyChar);
-        mPreImeEventCount = 0;
+
         return true;
     }
 
+    private int shouldSendKeyEventWithKeyCode(String text) {
+        if (text.length() != 1) return COMPOSITION_KEY_CODE;
+
+        if (text.equals("\n")) return KeyEvent.KEYCODE_ENTER;
+        else if (text.equals("\t")) return KeyEvent.KEYCODE_TAB;
+        else return COMPOSITION_KEY_CODE;
+    }
+
+    private void sendKeyEventWithKeyCode(int KeyCode, int flags) {

[Ted C, 2013/01/16 23:48:57]

s/KeyCode/keyCode

[Yusuf, 2013/01/17 00:44:19]

Done.

[Yusuf, 2013/01/17 00:44:19]

Done.

+        long eventTime = System.currentTimeMillis();
+        translateAndSendNativeEvents(new KeyEvent(eventTime, eventTime,
+                KeyEvent.ACTION_DOWN, KeyCode, 0, 0,
+                KeyCharacterMap.VIRTUAL_KEYBOARD, 0,
+                flags));
+        translateAndSendNativeEvents(new KeyEvent(System.currentTimeMillis(), eventTime,
+                KeyEvent.ACTION_UP, KeyCode, 0, 0,
+                KeyCharacterMap.VIRTUAL_KEYBOARD, 0,
+                flags));
+    }
+
     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 214 matching lines @@
                     // Send TAB key event
                     long timeStampMs = System.currentTimeMillis();
                     mImeAdapter.sendSyntheticKeyEvent(
                             sEventTypeRawKeyDown, timeStampMs, KeyEvent.KEYCODE_TAB, 0);
                     return true;
                 case EditorInfo.IME_ACTION_GO:
                 case EditorInfo.IME_ACTION_SEARCH:
                     mImeAdapter.dismissInput(true);
                     break;
             }
-
-            return super.performEditorAction(actionCode);
+            mImeAdapter.sendKeyEventWithKeyCode(KeyEvent.KEYCODE_ENTER,

[Ted C, 2013/01/16 23:48:57]

Hmm...it seems odd that we are treating a search as a enter key to me.

[aurimas (slooooooooow), 2013/01/16 23:54:46]

There is KeyEvent.KEYCODE_SEARCH. Should we be using that?

[Yusuf, 2013/01/17 00:44:19]

I dont think KEY_CODE_SEARCH will have any corresponding mapping on WebKit side.
Sending ENTER was previously done by calling super.performEditorAction here. So
I am essentially shorcircuiting that mechanism to start from ImeAdapter and go
to native rather than trickling down from the dispatch codepath that starts from
the activity and then the top view and ContentViewCore to ImeAdapter and native.

As far as native is concerned we are doing the exact same thing. I think using
ENTER was done because it sends a commit with empty text and all editor actions
need a commit at the end.

On 2013/01/16 23:54:46, aurimas wrote:

+                    KeyEvent.FLAG_SOFT_KEYBOARD | KeyEvent.FLAG_KEEP_TOUCH_MODE
+                    | KeyEvent.FLAG_EDITOR_ACTION);
+            return true;
         }
 
         @Override
         public boolean performContextMenuAction(int id) {
             switch (id) {
                 case android.R.id.selectAll:
                     return mImeAdapter.selectAll();
                 case android.R.id.cut:
                     return mImeAdapter.cut();
                 case android.R.id.copy:
@@ skipping 177 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);
 }