Merge 177774

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:
-//    a) If a key event has been recorded in dispatchKeyEventPreIme() and we
-//       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
-//    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.
+/**
+ 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. When InputConnectionAdapter gets called with composition or result text:
+    If we receive a composition text or a result text, then we just need to
+    dispatch a synthetic key event with special keycode 229, and then dispatch
+    the composition or result text.
+ 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();
         public void onDismissInput();
         public View getAttachedView();
@@ skipping 53 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) {
+        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 226 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,
+                    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 50 matching lines @@
                         if (selectionStart > selectionEnd) {
                             int temp = selectionStart;
                             selectionStart = selectionEnd;
                             selectionEnd = temp;
                         }
                         editable.replace(selectionStart, selectionEnd,
                                 Character.toString((char)unicodeChar));
                     }
                 }
             }
-            return super.sendKeyEvent(event);
+            mImeAdapter.translateAndSendNativeEvents(event);
+            return true;
         }
 
         @Override
         public boolean finishComposingText() {
             if (mEditable == null
                     || (getComposingSpanStart(mEditable) == getComposingSpanEnd(mEditable))) {
                 return true;
             }
             super.finishComposingText();
             return mImeAdapter.checkCompositionQueueAndCallNative("", 0, true);
@@ skipping 109 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);
 }