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;
+    private static final int NO_ACCENT = 0;
     /**
      * 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 66 matching lines @@
         }
         outAttrs.initialSelStart = Selection.getSelectionStart(mEditable);
         outAttrs.initialSelEnd = Selection.getSelectionEnd(mEditable);
         mLastUpdateSelectionStart = Selection.getSelectionStart(mEditable);
         mLastUpdateSelectionEnd = Selection.getSelectionEnd(mEditable);
 
         Selection.setSelection(mEditable, outAttrs.initialSelStart, outAttrs.initialSelEnd);
         updateSelectionIfRequired();
     }
 
+    public static int maybeAddAccentToCharacter(int accentChar, int unicodeChar) {
+        if (accentChar != NO_ACCENT) {
+            int combinedChar = KeyEvent.getDeadChar(accentChar, unicodeChar);
+            if (combinedChar != 0) {
+                return combinedChar;
+            }
+        }
+        return unicodeChar;
+    }
+
     /**
      * Updates the AdapterInputConnection's internal representation of the text being edited and
      * its selection and composition properties. The resulting Editable is accessible through the
      * getEditable() method. If the text has not changed, this also calls updateSelection on the
      * InputMethodManager.
      *
      * @param text The String contents of the field being edited.
      * @param selectionStart The character offset of the selection start, or the caret position if
      *                       there is no selection.
      * @param selectionEnd The character offset of the selection end, or the caret position if there
@@ skipping 70 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 = NO_ACCENT;
     }
 
     /**
      * @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() + "]");
         }
+
+        // Short-cut modifier keys so they're not affected by accents.
+        if (KeyEvent.isModifierKey(event.getKeyCode())) {
+            return mImeAdapter.translateAndSendNativeEvents(event, NO_ACCENT);
+        }
+
+        // Some keys we just want to pass events straight through.  This allows
+        // proper "repeating key" behavior with physical keyboards.
+        int eventKeyCode = event.getKeyCode();
+        if (eventKeyCode == KeyEvent.KEYCODE_DEL || eventKeyCode == KeyEvent.KEYCODE_FORWARD_DEL) {
+            mPendingAccent = 0;
+            return mImeAdapter.translateAndSendNativeEvents(event, NO_ACCENT);
+        }
+
+        int unicodeChar = event.getUnicodeChar();
+
         // 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;
-                    }
-                    mEditable.replace(selectionStart, selectionEnd,
-                            Character.toString((char) unicodeChar));
+            } else if (unicodeChar != 0) {
+                int selectionStart = Selection.getSelectionStart(mEditable);
+                int selectionEnd = Selection.getSelectionEnd(mEditable);
+                if (selectionStart > selectionEnd) {
+                    int temp = selectionStart;
+                    selectionStart = selectionEnd;
+                    selectionEnd = temp;
                 }
+                int combinedChar = maybeAddAccentToCharacter(mPendingAccent, unicodeChar);
+                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);
+
+        // 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.
+
+        // Copy class variable to local because class version may get indirectly
+        // cleared by the deleteSurroundingText() call below.
+        int pendingAccent = mPendingAccent;
+        int nextAccent = mPendingAccent;
+
+        if ((unicodeChar & KeyCharacterMap.COMBINING_ACCENT) != 0) {
+            pendingAccent = NO_ACCENT;
+            nextAccent = unicodeChar & KeyCharacterMap.COMBINING_ACCENT_MASK;
+        } else if (pendingAccent != NO_ACCENT) {
+            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.
+                    super.deleteSurroundingText(1, 0);
+                    mImeAdapter.deleteSurroundingText(1, 0);
+                } else {
+                    // Previous accent doesn't combine with this character
+                    // so assume both are completely independent.
+                    pendingAccent = NO_ACCENT;
+                    nextAccent = NO_ACCENT;
+                }
+            }
+
+            if (event.getAction() == KeyEvent.ACTION_UP) {
+                // Forget accent after release of key being accented.
+                nextAccent = NO_ACCENT;
+            }
+        }
+
+        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 21 matching lines @@
     }
 
     /**
      * Informs the InputMethodManager and InputMethodSession (i.e. the IME) that the text
      * state is no longer what the IME has and that it needs to be updated.
      */
     void restartInput() {
         if (DEBUG) Log.w(TAG, "restartInput");
         getInputMethodManagerWrapper().restartInput(mInternalView);
         mNumNestedBatchEdits = 0;
+        mPendingAccent = NO_ACCENT;
     }
 
     /**
      * @see BaseInputConnection#setComposingRegion(int, int)
      */
     @Override
     public boolean setComposingRegion(int start, int end) {
         if (DEBUG) Log.w(TAG, "setComposingRegion [" + start + " " + end + "]");
         int textLength = mEditable.length();
         int a = Math.min(start, end);
@@ skipping 73 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);
     }
 }