Send correct key-codes when doing composition events instead of always 0.

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

 // Copyright 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.input;
 
 import android.os.Handler;
 import android.os.ResultReceiver;
 import android.os.SystemClock;
 import android.text.Editable;
@@ skipping 98 matching lines @@
     static int sTextInputTypeUrl;
     static int sTextInputTypeEmail;
     static int sTextInputTypeTel;
     static int sTextInputTypeNumber;
     static int sTextInputTypeContentEditable;
     static int sModifierShift;
     static int sModifierAlt;
     static int sModifierCtrl;
     static int sModifierCapsLockOn;
     static int sModifierNumLockOn;
+    static KeyCharacterMap sKeyCharacterMap;
 
     private long mNativeImeAdapterAndroid;
     private InputMethodManagerWrapper mInputMethodManagerWrapper;
     private AdapterInputConnection mInputConnection;
     private final ImeAdapterDelegate mViewEmbedder;
     private final Handler mHandler;
     private DelayedDismissInput mDismissInput = null;
     private int mTextInputType;
+    private String mLastComposeText;
+
+    @VisibleForTesting
+    int mLastSyntheticKeyCode;
 
     @VisibleForTesting
     boolean mIsShowWithoutHideOutstanding = false;
 
     /**
      * @param wrapper InputMethodManagerWrapper that should receive all the call directed to
      *                InputMethodManager.
      * @param embedder The view that is used for callbacks from ImeAdapter.
      */
     public ImeAdapter(InputMethodManagerWrapper wrapper, ImeAdapterDelegate embedder) {
@@ skipping 173 matching lines @@
     }
 
     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 static int androidKeyCodeForCharacter(char chr) {
+        if (sKeyCharacterMap == null) {
+            sKeyCharacterMap = KeyCharacterMap.load(KeyCharacterMap.VIRTUAL_KEYBOARD);
+        }
+        char[] chars = new char[1];

[jdduke (slow), 2014/07/21 16:08:26]

Can we avoid new'ing a character array here? A static char[1] array should be
sufficient.

[bcwhite, 2014/07/21 19:43:13]

Done.

+        chars[0] = chr;
+        KeyEvent[] events = sKeyCharacterMap.getEvents(chars);
+        return events[0].getKeyCode();
+    }
+
+    @VisibleForTesting
+    public static int getTypedKeycodeGuess(String oldtext, String newtext) {
+        // Starting typing a new composition should add only a single character.  Any composition
+        // beginning with text longer than that must come from something other than typing so
+        // return 0.
+        if (oldtext == null) {
+            if (newtext.length() == 1) {
+                return androidKeyCodeForCharacter(newtext.charAt(0));
+            } else {
+                return 0;
+            }
+        }
+
+        // The content has grown in length: assume the last character is the key that caused it.
+        if (newtext.length() > oldtext.length() && newtext.startsWith(oldtext))
+            return androidKeyCodeForCharacter(newtext.charAt(newtext.length() - 1));
+
+        // The content has shrunk in length: assume that backspace was pressed.
+        if (oldtext.length() > newtext.length() && oldtext.startsWith(newtext))
+            return KeyEvent.KEYCODE_DEL;
+
+        // The content is unchanged or has undergone a complex change (i.e. not a simple tail
+        // modification) so return an unknown key-code.
+        return 0;
+    }
+
     void sendKeyEventWithKeyCode(int keyCode, int flags) {
         long eventTime = SystemClock.uptimeMillis();
+        mLastSyntheticKeyCode = keyCode;
         translateAndSendNativeEvents(new KeyEvent(eventTime, eventTime,
                 KeyEvent.ACTION_DOWN, keyCode, 0, 0,
                 KeyCharacterMap.VIRTUAL_KEYBOARD, 0,
                 flags));
         translateAndSendNativeEvents(new KeyEvent(SystemClock.uptimeMillis(), eventTime,
                 KeyEvent.ACTION_UP, keyCode, 0, 0,
                 KeyCharacterMap.VIRTUAL_KEYBOARD, 0,
                 flags));
     }
 
     // Calls from Java to C++
 
     boolean checkCompositionQueueAndCallNative(CharSequence text, int newCursorPosition,
             boolean isCommit) {
         if (mNativeImeAdapterAndroid == 0) return false;
         String textStr = text.toString();
 
         // Committing an empty string finishes the current composition.
         boolean isFinish = textStr.isEmpty();
         mViewEmbedder.onImeEvent(isFinish);
         int keyCode = shouldSendKeyEventWithKeyCode(textStr);
         long timeStampMs = SystemClock.uptimeMillis();
 
         if (keyCode != COMPOSITION_KEY_CODE) {
             sendKeyEventWithKeyCode(keyCode,
                     KeyEvent.FLAG_SOFT_KEYBOARD | KeyEvent.FLAG_KEEP_TOUCH_MODE);
         } else {
+            keyCode = getTypedKeycodeGuess(mLastComposeText, textStr);
+            mLastComposeText = textStr;
+            mLastSyntheticKeyCode = keyCode;
+
+            // When typing, there is no issue sending KeyDown and KeyUp events around the
+            // composition event because those key events do nothing (other than call JS
+            // handlers).  Tying does not cause changes outside of a KeyPress event which
+            // we don't call here.  However, if the key-code is a control key such as
+            // KEYCODE_DEL then there never is an associated KeyPress event and the KeyDown
+            // event itself causes the action.  The net result below is that the Renderer calls
+            // cancelComposition() and then Android starts anew with setComposingRegion().
+            // This stopping and restarting of composition could be a source of problems
+            // with 3rd party keyboards.
+            //
+            // An alternative is to *not* call nativeSetComposingText() in the non-commit case
+            // below.  This avoids the restart of composition described above but fails to send
+            // an update to the composition while in composition which, strictly speaking,
+            // does not match the spec.
+            //
+            // For now, the solution is to endure the restarting of composition and only dive
+            // into the alternate solution should there be problems in the field.  --bcwhite
+
             nativeSendSyntheticKeyEvent(mNativeImeAdapterAndroid, sEventTypeRawKeyDown,
                     timeStampMs, keyCode, 0);
+
             if (isCommit) {
                 nativeCommitText(mNativeImeAdapterAndroid, textStr);
+                mLastComposeText = null;
             } else {
                 nativeSetComposingText(mNativeImeAdapterAndroid, text, textStr, newCursorPosition);
             }
+
             nativeSendSyntheticKeyEvent(mNativeImeAdapterAndroid, sEventTypeKeyUp,
                     timeStampMs, keyCode, 0);
         }
 
         return true;
     }
 
     void finishComposingText() {
         if (mNativeImeAdapterAndroid == 0) return;
+        /*int keyCode = mLastComposeText != null && mLastComposeText.length() == 1 ?

[jdduke (slow), 2014/07/21 16:08:26]

Should this commented code be deleted?

[bcwhite, 2014/07/21 19:43:13]

Oops!  Done.

+                KeyEvent.KEYCODE_DEL : 0;
+        long timeStampMs = SystemClock.uptimeMillis();
+        mLastComposeText = null;
+
+        if (keyCode != 0)
+            nativeSendSyntheticKeyEvent(mNativeImeAdapterAndroid, sEventTypeRawKeyDown,
+                    timeStampMs, keyCode, 0);*/
         nativeFinishComposingText(mNativeImeAdapterAndroid);
+        /*if (keyCode != 0)
+            nativeSendSyntheticKeyEvent(mNativeImeAdapterAndroid, sEventTypeKeyUp,
+                    timeStampMs, keyCode, 0);*/
     }
 
     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:
@@ skipping 42 matching lines @@
      * @param end Selection end index.
      * @return Whether the native counterpart of ImeAdapter received the call.
      */
     boolean setEditableSelectionOffsets(int start, int end) {
         if (mNativeImeAdapterAndroid == 0) return false;
         nativeSetEditableSelectionOffsets(mNativeImeAdapterAndroid, start, end);
         return true;
     }
 
     /**
-     * Send a request to the native counterpart to set compositing region to given indices.
+     * Send a request to the native counterpart to set composing region to given indices.
      * @param start The start of the composition.
      * @param end The end of the composition.
      * @return Whether the native counterpart of ImeAdapter received the call.
      */
-    boolean setComposingRegion(int start, int end) {
+    boolean setComposingRegion(CharSequence text, int start, int end) {
         if (mNativeImeAdapterAndroid == 0) return false;
         nativeSetComposingRegion(mNativeImeAdapterAndroid, start, end);
+        mLastComposeText = text != null ? text.toString() : null;
         return true;
     }
 
     /**
      * Send a request to the native counterpart to unselect text.
      * @return Whether the native counterpart of ImeAdapter received the call.
      */
     public boolean unselect() {
         if (mNativeImeAdapterAndroid == 0) return false;
         nativeUnselect(mNativeImeAdapterAndroid);
@@ skipping 93 matching lines @@
             } else if (span instanceof UnderlineSpan) {
                 nativeAppendUnderlineSpan(underlines, spannableString.getSpanStart(span),
                         spannableString.getSpanEnd(span));
             }
         }
     }
 
     @CalledByNative
     private void cancelComposition() {
         if (mInputConnection != null) mInputConnection.restartInput();
+        mLastComposeText = null;
     }
 
     @CalledByNative
     void detach() {
         if (mDismissInput != null) mHandler.removeCallbacks(mDismissInput);
         mNativeImeAdapterAndroid = 0;
         mTextInputType = 0;
     }
 
     private native boolean nativeSendSyntheticKeyEvent(long nativeImeAdapterAndroid,
@@ skipping 25 matching lines @@
     private native void nativeDeleteSurroundingText(long nativeImeAdapterAndroid,
             int before, int after);
 
     private native void nativeUnselect(long nativeImeAdapterAndroid);
     private native void nativeSelectAll(long nativeImeAdapterAndroid);
     private native void nativeCut(long nativeImeAdapterAndroid);
     private native void nativeCopy(long nativeImeAdapterAndroid);
     private native void nativePaste(long nativeImeAdapterAndroid);
     private native void nativeResetImeAdapter(long nativeImeAdapterAndroid);
 }