Merge "Add Key.altCode attribute"

4 files changed, 96 insertions, 53 deletions

diff --git a/java/src/com/android/inputmethod/keyboard/Key.java b/java/src/com/android/inputmethod/keyboard/Key.java
index 84f2be585..b2b68f0ad 100644
--- a/java/src/com/android/inputmethod/keyboard/Key.java
+++ b/java/src/com/android/inputmethod/keyboard/Key.java
@@ -46,6 +46,7 @@ public class Key {
      * The key code (unicode or custom code) that this key generates.
      */
     public final int mCode;
+    public final int mAltCode;
 
     /** Label to display */
     public final CharSequence mLabel;
@@ -108,7 +109,7 @@ public class Key {
     private final int mActionFlags;
     private static final int ACTION_FLAGS_IS_REPEATABLE = 0x01;
     private static final int ACTION_FLAGS_NO_KEY_PREVIEW = 0x02;
-    private static final int ACTION_FLAGS_IGNORE_WHILE_TYPING = 0x04;
+    private static final int ACTION_FLAGS_ALT_CODE_WHILE_TYPING = 0x04;
 
     /** The current pressed state of this key */
     private boolean mPressed;
@@ -191,6 +192,7 @@ public class Key {
         mLabel = label;
         mOutputText = outputText;
         mCode = code;
+        mAltCode = Keyboard.CODE_DUMMY;
         mIcon = icon;
         // Horizontal gap is divided equally to both sides of the key.
         mX = x + mHorizontalGap / 2;
@@ -290,6 +292,8 @@ public class Key {
         } else {
             mCode = Keyboard.CODE_DUMMY;
         }
+        mAltCode = style.getInt(keyAttr,
+                R.styleable.Keyboard_Key_altCode, Keyboard.CODE_DUMMY);
 
         keyAttr.recycle();
     }
@@ -334,8 +338,8 @@ public class Key {
         return (mActionFlags & ACTION_FLAGS_NO_KEY_PREVIEW) != 0;
     }
 
-    public boolean ignoreWhileTyping() {
-        return (mActionFlags & ACTION_FLAGS_IGNORE_WHILE_TYPING) != 0;
+    public boolean altCodeWhileTyping() {
+        return (mActionFlags & ACTION_FLAGS_ALT_CODE_WHILE_TYPING) != 0;
     }
 
     public Typeface selectTypeface(Typeface defaultTypeface) {
diff --git a/java/src/com/android/inputmethod/keyboard/Keyboard.java b/java/src/com/android/inputmethod/keyboard/Keyboard.java
index 4a28bf1de..b3b20ca21 100644
--- a/java/src/com/android/inputmethod/keyboard/Keyboard.java
+++ b/java/src/com/android/inputmethod/keyboard/Keyboard.java
@@ -24,6 +24,7 @@ import com.android.inputmethod.keyboard.internal.KeyboardParams;
 import com.android.inputmethod.keyboard.internal.KeyboardShiftState;
 
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -65,7 +66,6 @@ public class Keyboard {
     public static final int CODE_DIGIT0 = '0';
     public static final int CODE_PLUS = '+';
 
-
     /** Special keys code.  These should be aligned with values/keycodes.xml */
     public static final int CODE_DUMMY = 0;
     public static final int CODE_SHIFT = -1;
@@ -111,6 +111,7 @@ public class Keyboard {
     public final Map<Key, Drawable> mUnshiftedIcons;
     public final KeyboardIconsSet mIconsSet;
 
+    private final Map<Integer, Key> mKeyCache = new HashMap<Integer, Key>();
     private final KeyboardShiftState mShiftState = new KeyboardShiftState();
 
     private final ProximityInfo mProximityInfo;
@@ -145,6 +146,22 @@ public class Keyboard {
         return mProximityInfo;
     }
 
+    public Key getKey(int code) {
+        final Integer keyCode = code;
+        if (mKeyCache.containsKey(keyCode)) {
+            return mKeyCache.get(keyCode);
+        }
+
+        for (final Key key : mKeys) {
+            if (key.mCode == code) {
+                mKeyCache.put(keyCode, key);
+                return key;
+            }
+        }
+        mKeyCache.put(keyCode, null);
+        return null;
+    }
+
     public boolean hasShiftLockKey() {
         return !mShiftLockKeys.isEmpty();
     }
diff --git a/java/src/com/android/inputmethod/keyboard/PointerTracker.java b/java/src/com/android/inputmethod/keyboard/PointerTracker.java
index da60af3be..4e8765dcc 100644
--- a/java/src/com/android/inputmethod/keyboard/PointerTracker.java
+++ b/java/src/com/android/inputmethod/keyboard/PointerTracker.java
@@ -258,23 +258,27 @@ public class PointerTracker {
     // primaryCode is different from {@link Key#mCode}.
     private void callListenerOnCodeInput(Key key, int primaryCode, int[] keyCodes, int x, int y) {
         final boolean ignoreModifierKey = mIgnoreModifierKey && key.isModifier();
-        if (DEBUG_LISTENER)
-            Log.d(TAG, "onCodeInput: " + keyCodePrintable(primaryCode)
+        final boolean alterCode = key.altCodeWhileTyping() && mTimerProxy.isTyping();
+        final int code = alterCode ? key.mAltCode : primaryCode;
+        // If code is CODE_DUMMY here, this key will be ignored or generate text.
+        final CharSequence text = (code != Keyboard.CODE_DUMMY) ? null : key.mOutputText;
+        if (DEBUG_LISTENER) {
+            Log.d(TAG, "onCodeInput: " + keyCodePrintable(code) + " text=" + text
                     + " codes="+ Arrays.toString(keyCodes) + " x=" + x + " y=" + y
-                    + " ignoreModifier=" + ignoreModifierKey);
+                    + " ignoreModifier=" + ignoreModifierKey + " alterCode=" + alterCode);
+        }
         if (ignoreModifierKey) {
             return;
         }
         if (key.isEnabled()) {
-            mListener.onCodeInput(primaryCode, keyCodes, x, y);
-        }
-    }
-
-    private void callListenerOnTextInput(Key key) {
-        if (DEBUG_LISTENER)
-            Log.d(TAG, "onTextInput: text=" + key.mOutputText);
-        if (key.isEnabled()) {
-            mListener.onTextInput(key.mOutputText);
+            if (code != Keyboard.CODE_DUMMY) {
+                mListener.onCodeInput(code, keyCodes, x, y);
+            } else if (text != null) {
+                mListener.onTextInput(text);
+            }
+            if (!key.altCodeWhileTyping() && !key.isModifier()) {
+                mTimerProxy.startKeyTypedTimer(sIgnoreSpecialKeyTimeout);
+            }
         }
     }
 
@@ -328,6 +332,23 @@ public class PointerTracker {
         if (key != null && key.isEnabled()) {
             key.onReleased();
             mDrawingProxy.invalidateKey(key);
+
+            if (key.isShift()) {
+                for (final Key shiftKey : mKeyboard.mShiftKeys) {
+                    if (shiftKey != key) {
+                        shiftKey.onReleased();
+                        mDrawingProxy.invalidateKey(shiftKey);
+                    }
+                }
+            }
+
+            if (key.altCodeWhileTyping()) {
+                final Key altKey = mKeyboard.getKey(key.mAltCode);
+                if (altKey != null) {
+                    altKey.onReleased();
+                    mDrawingProxy.invalidateKey(altKey);
+                }
+            }
         }
     }
 
@@ -338,6 +359,24 @@ public class PointerTracker {
             }
             key.onPressed();
             mDrawingProxy.invalidateKey(key);
+
+            if (key.isShift()) {
+                for (final Key shiftKey : mKeyboard.mShiftKeys) {
+                    if (shiftKey != key) {
+                        shiftKey.onPressed();
+                        mDrawingProxy.invalidateKey(shiftKey);
+                    }
+                }
+            }
+
+            if (key.altCodeWhileTyping() && mTimerProxy.isTyping()) {
+                final Key altKey = mKeyboard.getKey(key.mAltCode);
+                if (altKey != null) {
+                    // TODO: Show altKey's preview.
+                    altKey.onPressed();
+                    mDrawingProxy.invalidateKey(altKey);
+                }
+            }
         }
     }
 
@@ -696,45 +735,27 @@ public class PointerTracker {
             callListenerOnCancelInput();
             return;
         }
-        if (key.mOutputText != null) {
-            final boolean ignoreText = key.ignoreWhileTyping() && mTimerProxy.isTyping();
-            if (!ignoreText) {
-                callListenerOnTextInput(key);
-            }
-            callListenerOnRelease(key, key.mCode, false);
-            if (!ignoreText) {
-                mTimerProxy.startKeyTypedTimer(sIgnoreSpecialKeyTimeout);
-            }
-        } else {
-            int code = key.mCode;
-            final int[] codes = mKeyDetector.newCodeArray();
-            mKeyDetector.getKeyAndNearbyCodes(x, y, codes);
-
-            // If keyboard is in manual temporary upper case state and key has manual temporary
-            // uppercase letter as key hint letter, alternate character code should be sent.
-            if (mKeyboard.isManualTemporaryUpperCase() && key.hasUppercaseLetter()) {
-                code = key.mHintLabel.charAt(0);
-                codes[0] = code;
-            }
 
-            // Swap the first and second values in the codes array if the primary code is not the
-            // first value but the second value in the array. This happens when key debouncing is
-            // in effect.
-            if (codes.length >= 2 && codes[0] != code && codes[1] == code) {
-                codes[1] = codes[0];
-                codes[0] = code;
-            }
-            final boolean ignoreCode = key.ignoreWhileTyping() && mTimerProxy.isTyping();
-            if (!ignoreCode) {
-                // TODO: It might be useful to register the nearest key code in codes[] instead of
-                // just ignoring.
-                callListenerOnCodeInput(key, code, codes, x, y);
-            }
-            callListenerOnRelease(key, code, false);
-            if (!key.ignoreWhileTyping() && !key.isModifier()) {
-                mTimerProxy.startKeyTypedTimer(sIgnoreSpecialKeyTimeout);
-            }
+        int code = key.mCode;
+        final int[] codes = mKeyDetector.newCodeArray();
+        mKeyDetector.getKeyAndNearbyCodes(x, y, codes);
+
+        // If keyboard is in manual temporary upper case state and key has manual temporary
+        // uppercase letter as key hint letter, alternate character code should be sent.
+        if (mKeyboard.isManualTemporaryUpperCase() && key.hasUppercaseLetter()) {
+            code = key.mHintLabel.charAt(0);
+            codes[0] = code;
+        }
+
+        // Swap the first and second values in the codes array if the primary code is not the
+        // first value but the second value in the array. This happens when key debouncing is
+        // in effect.
+        if (codes.length >= 2 && codes[0] != code && codes[1] == code) {
+            codes[1] = codes[0];
+            codes[0] = code;
         }
+        callListenerOnCodeInput(key, code, codes, x, y);
+        callListenerOnRelease(key, code, false);
     }
 
     private long mPreviousEventTime;
diff --git a/java/src/com/android/inputmethod/keyboard/internal/KeyStyles.java b/java/src/com/android/inputmethod/keyboard/internal/KeyStyles.java
index 565edb901..218793500 100644
--- a/java/src/com/android/inputmethod/keyboard/internal/KeyStyles.java
+++ b/java/src/com/android/inputmethod/keyboard/internal/KeyStyles.java
@@ -152,6 +152,7 @@ public class KeyStyles {
         private void parseKeyStyleAttributes(TypedArray keyAttr) {
             // TODO: Currently not all Key attributes can be declared as style.
             readInt(keyAttr, R.styleable.Keyboard_Key_code);
+            readInt(keyAttr, R.styleable.Keyboard_Key_altCode);
             readText(keyAttr, R.styleable.Keyboard_Key_keyLabel);
             readText(keyAttr, R.styleable.Keyboard_Key_keyOutputText);
             readText(keyAttr, R.styleable.Keyboard_Key_keyHintLabel);