Handle accent keys from physical keyboards.

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 320 matching lines @@
     }
 
     /**
      * @return true if the selected text is of password.
      */
     public boolean isSelectionPassword() {
         return mTextInputType == sTextInputTypePassword;
     }
 
     public boolean dispatchKeyEvent(KeyEvent event) {
-        return translateAndSendNativeEvents(event);
+        // Physical keyboards have their events come through here instead of
+        // AdapterInputConnection.
+        if (mInputConnection != null) {
+            return mInputConnection.sendKeyEvent(event);
+        }
+        return translateAndSendNativeEvents(event, 0);
     }
 
     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;
     }
 
@@ skipping 48 matching lines @@
         // modification) so return an unknown key-code.
         return null;
     }
 
     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));
+                flags), 0);
         translateAndSendNativeEvents(new KeyEvent(SystemClock.uptimeMillis(), eventTime,
                 KeyEvent.ACTION_UP, keyCode, 0, 0,
                 KeyCharacterMap.VIRTUAL_KEYBOARD, 0,
-                flags));
+                flags), 0);
     }
 
     // Calls from Java to C++
     // TODO: Add performance tracing to more complicated functions.
 
     boolean checkCompositionQueueAndCallNative(CharSequence text, int newCursorPosition,
             boolean isCommit) {
         if (mNativeImeAdapterAndroid == 0) return false;
         mViewEmbedder.onImeEvent();
 
@@ skipping 14 matching lines @@
                 keyCode = KeyEvent.KEYCODE_UNKNOWN;
             } else {
                 keyCode = -1;
             }
 
             // If this is a commit with no previous composition, then treat it as a native
             // KeyDown/KeyUp pair with no composition rather than a synthetic pair with
             // composition below.
             if (keyCode > 0 && isCommit && mLastComposeText == null) {
                 mLastSyntheticKeyCode = keyCode;
-                return translateAndSendNativeEvents(keyEvent)
+                return translateAndSendNativeEvents(keyEvent, 0)
                         && translateAndSendNativeEvents(
-                                KeyEvent.changeAction(keyEvent, KeyEvent.ACTION_UP));
+                                KeyEvent.changeAction(keyEvent, KeyEvent.ACTION_UP), 0);
             }
 
             // 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).  Typing 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
@@ skipping 30 matching lines @@
         mLastComposeText = textStr;
         return true;
     }
 
     void finishComposingText() {
         mLastComposeText = null;
         if (mNativeImeAdapterAndroid == 0) return;
         nativeFinishComposingText(mNativeImeAdapterAndroid);
     }
 
-    boolean translateAndSendNativeEvents(KeyEvent event) {
+    boolean translateAndSendNativeEvents(KeyEvent event, int accentChar) {
         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
             // composition key down (229) followed by a commit text with the
             // string from event.getUnicodeChars().
             // Otherwise, we'd need to send an event with a
             // WebInputEvent::IsAutoRepeat modifier. We also need to verify when
             // we receive ACTION_MULTIPLE: we may receive it after an ACTION_DOWN,
             // and if that's the case, we'll need to review when to send the Char
             // event.
             return false;
         }
         mViewEmbedder.onImeEvent();
+        int unichar = event.getUnicodeChar();

[Ted C, 2014/12/03 02:30:14]

The other file called them unicodeChar, so I would do that here for consistency.

[bcwhite, 2014/12/03 15:49:09]

Done.

+        if (accentChar != 0) {
+            int combined = KeyCharacterMap.getDeadChar(accentChar, unichar);

[Ted C, 2014/12/03 02:30:14]

Any reason to use KeyCharacterMap instead of KeyEvent like in the other file?

And just for sanity, this really is a map lookup right?  We call this a few
times per key stroke, but I suspect it's pretty much "free".

[bcwhite, 2014/12/03 15:49:10]

Not particularly.  I was typing both names in different places and probably just
got the wrong one here (which happens to also work).
The Android code I looked at doesn't seem to cache the information, at least not
at the KeyEvent/KeyCharacterMap level.  The lower levels may.  Assuming a human
typing, it shouldn't be an issue.

+            if (combined != 0) {
+                unichar = combined;
+            }
+        }
         return nativeSendKeyEvent(mNativeImeAdapterAndroid, event, event.getAction(),
                 getModifiers(event.getMetaState()), event.getEventTime(), event.getKeyCode(),
-                             /*isSystemKey=*/false, event.getUnicodeChar());
+                             /*isSystemKey=*/false, unichar);
     }
 
     boolean sendSyntheticKeyEvent(int eventType, long timestampMs, int keyCode, int modifiers,
             int unicodeChar) {
         if (mNativeImeAdapterAndroid == 0) return false;
 
         nativeSendSyntheticKeyEvent(
                 mNativeImeAdapterAndroid, eventType, timestampMs, keyCode, modifiers, unicodeChar);
         return true;
     }
@@ skipping 208 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);
 }