Handle accent keys from physical keyboards.

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

 // Copyright 2013 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.SystemClock;
 import android.text.Editable;
 import android.text.InputType;
 import android.text.Selection;
 import android.text.TextUtils;
 import android.util.Log;
+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 org.chromium.base.VisibleForTesting;
 
 /**
  * InputConnection is created by ContentView.onCreateInputConnection.
  * It then adapts android's IME to chrome's RenderWidgetHostView using the
  * native ImeAdapterAndroid via the class ImeAdapter.
  */
 public class AdapterInputConnection extends BaseInputConnection {
     private static final String TAG = "AdapterInputConnection";
     private static final boolean DEBUG = false;
     /**
      * Selection value should be -1 if not known. See EditorInfo.java for details.
      */
     public static final int INVALID_SELECTION = -1;
     public static final int INVALID_COMPOSITION = -1;
 
     private final View mInternalView;
     private final ImeAdapter mImeAdapter;
     private final Editable mEditable;
 
     private boolean mSingleLine;
     private int mNumNestedBatchEdits = 0;
+    private int mPendingAccent;
 
     private int mLastUpdateSelectionStart = INVALID_SELECTION;
     private int mLastUpdateSelectionEnd = INVALID_SELECTION;
     private int mLastUpdateCompositionStart = INVALID_COMPOSITION;
     private int mLastUpdateCompositionEnd = INVALID_COMPOSITION;
 
     @VisibleForTesting
     AdapterInputConnection(View view, ImeAdapter imeAdapter, Editable editable,
             EditorInfo outAttrs) {
         super(view, true);
@@ skipping 156 matching lines @@
                     + compositionStart + " " + compositionEnd + "]");
         }
         // updateSelection should be called every time the selection or composition changes
         // if it happens not within a batch edit, or at the end of each top level batch edit.
         getInputMethodManagerWrapper().updateSelection(mInternalView,
                 selectionStart, selectionEnd, compositionStart, compositionEnd);
         mLastUpdateSelectionStart = selectionStart;
         mLastUpdateSelectionEnd = selectionEnd;
         mLastUpdateCompositionStart = compositionStart;
         mLastUpdateCompositionEnd = compositionEnd;
+        // Change in selection or cursor position invalidates any pending accent.
+        mPendingAccent = 0;

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

do we need to do this as well on restartInput (or whatever it is called today)?

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

Seems the smart thing to do.  Done.

     }
 
     /**
      * @see BaseInputConnection#setComposingText(java.lang.CharSequence, int)
      */
     @Override
     public boolean setComposingText(CharSequence text, int newCursorPosition) {
         if (DEBUG) Log.w(TAG, "setComposingText [" + text + "] [" + newCursorPosition + "]");
         if (maybePerformEmptyCompositionWorkaround(text)) return true;
         super.setComposingText(text, newCursorPosition);
@@ skipping 133 matching lines @@
     }
 
     /**
      * @see BaseInputConnection#sendKeyEvent(android.view.KeyEvent)
      */
     @Override
     public boolean sendKeyEvent(KeyEvent event) {
         if (DEBUG) {
             Log.w(TAG, "sendKeyEvent [" + event.getAction() + "] [" + event.getKeyCode() + "]");
         }
+
+        if (KeyEvent.isModifierKey(event.getKeyCode())) {
+            return mImeAdapter.translateAndSendNativeEvents(event, 0);
+        }
+
+        // Physical keyboards also have their events come through here though not
+        // by BaseInputConnection.  In order to support "accent" key sequences
+        // such as "~n" or "^o" we have to record that one has been pressed
+        // and, if an accentable letter follows, delete the accent glyph and
+        // insert the composed character.
+
+        int unicodeChar = event.getUnicodeChar();
+        int pendingAccent = mPendingAccent;
+        int nextAccent = pendingAccent;

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

In what cases is this used?  Just wondering what combination of key strokes
would not result in it either being consumed or discarded on the following
keystroke?

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

It's used to keep all the accent-processing code at the top and the
non-accent-processing code at the bottom.  But thinking about it some more...  I
should be able to just switch the two blocks and simplify this.

+
+        if ((unicodeChar & KeyCharacterMap.COMBINING_ACCENT) != 0) {
+            pendingAccent = 0;
+            nextAccent = unicodeChar & KeyCharacterMap.COMBINING_ACCENT_MASK;
+        } else if (pendingAccent != 0) {
+            if (event.getAction() == KeyEvent.ACTION_DOWN) {
+                int combined = KeyEvent.getDeadChar(pendingAccent, unicodeChar);
+                if (combined != 0) {
+                    // Previous accent combines with new character to create
+                    // a new accented character.  First delete the displayed
+                    // accent so it appears overwritten by the composition.
+                    // Note that deleting the displayed accent will cause an
+                    // update and clearing of mPendingAccent which is why we've
+                    // copied it to a local variable above.
+                    super.deleteSurroundingText(1, 0);
+                    mImeAdapter.deleteSurroundingText(1, 0);
+                } else {
+                    // Previous accent doesn't combine with this character
+                    // so assume both are completely independent.
+                    pendingAccent = 0;
+                    nextAccent = 0;
+                }
+            }
+
+            if (event.getAction() == KeyEvent.ACTION_UP) {
+                // Forget accent after release of key being accented.
+                nextAccent = 0;
+            }
+        }
+
         // If this is a key-up, and backspace/del or if the key has a character representation,
         // need to update the underlying Editable (i.e. the local representation of the text
         // being edited).
         if (event.getAction() == KeyEvent.ACTION_UP) {
             if (event.getKeyCode() == KeyEvent.KEYCODE_DEL) {
                 deleteSurroundingText(1, 0);
                 return true;
             } else if (event.getKeyCode() == KeyEvent.KEYCODE_FORWARD_DEL) {
                 deleteSurroundingText(0, 1);
                 return true;
-            } else {
-                int unicodeChar = event.getUnicodeChar();
-                if (unicodeChar != 0) {
-                    int selectionStart = Selection.getSelectionStart(mEditable);
-                    int selectionEnd = Selection.getSelectionEnd(mEditable);
-                    if (selectionStart > selectionEnd) {
-                        int temp = selectionStart;
-                        selectionStart = selectionEnd;
-                        selectionEnd = temp;
+            } else if (unicodeChar != 0) {
+                int combinedChar = unicodeChar;
+                if (pendingAccent != 0) {
+                    combinedChar = KeyEvent.getDeadChar(pendingAccent, unicodeChar);
+                    if (combinedChar == 0) {
+                        combinedChar = unicodeChar;
                     }
-                    mEditable.replace(selectionStart, selectionEnd,
-                            Character.toString((char) unicodeChar));
                 }
+                int selectionStart = Selection.getSelectionStart(mEditable);
+                int selectionEnd = Selection.getSelectionEnd(mEditable);
+                if (selectionStart > selectionEnd) {
+                    int temp = selectionStart;
+                    selectionStart = selectionEnd;
+                    selectionEnd = temp;
+                }
+                mEditable.replace(selectionStart, selectionEnd,
+                        Character.toString((char) combinedChar));
             }
         } else if (event.getAction() == KeyEvent.ACTION_DOWN) {
             // TODO(aurimas): remove this workaround when crbug.com/278584 is fixed.
             if (event.getKeyCode() == KeyEvent.KEYCODE_ENTER) {
                 beginBatchEdit();
                 finishComposingText();
-                mImeAdapter.translateAndSendNativeEvents(event);
+                mImeAdapter.translateAndSendNativeEvents(event, 0);
                 endBatchEdit();
                 return true;
             } else if (event.getKeyCode() == KeyEvent.KEYCODE_DEL) {
                 return true;
             } else if (event.getKeyCode() == KeyEvent.KEYCODE_FORWARD_DEL) {
                 return true;
             }
         }
-        mImeAdapter.translateAndSendNativeEvents(event);
+        mImeAdapter.translateAndSendNativeEvents(event, pendingAccent);
+        mPendingAccent = nextAccent;
         return true;
     }
 
     /**
      * @see BaseInputConnection#finishComposingText()
      */
     @Override
     public boolean finishComposingText() {
         if (DEBUG) Log.w(TAG, "finishComposingText");
         if (getComposingSpanStart(mEditable) == getComposingSpanEnd(mEditable)) {
@@ skipping 114 matching lines @@
     @VisibleForTesting
     ImeState getImeStateForTesting() {
         String text = mEditable.toString();
         int selectionStart = Selection.getSelectionStart(mEditable);
         int selectionEnd = Selection.getSelectionEnd(mEditable);
         int compositionStart = getComposingSpanStart(mEditable);
         int compositionEnd = getComposingSpanEnd(mEditable);
         return new ImeState(text, selectionStart, selectionEnd, compositionStart, compositionEnd);
     }
 }