Add proximity info to native

Bug: 3311719

Change-Id: Ie596304070e321ad23fb67a13bf05e2b6af1b54b

6 files changed, 164 insertions, 37 deletions

diff --git a/java/src/com/android/inputmethod/keyboard/Keyboard.java b/java/src/com/android/inputmethod/keyboard/Keyboard.java
index 3a0bf53ab..3005920b1 100644
--- a/java/src/com/android/inputmethod/keyboard/Keyboard.java
+++ b/java/src/com/android/inputmethod/keyboard/Keyboard.java
@@ -132,6 +132,7 @@ public class Keyboard {
 
     // Variables for pre-computing nearest keys.
 
+    // TODO: Change GRID_WIDTH and GRID_HEIGHT to private.
     public final int GRID_WIDTH;
     public final int GRID_HEIGHT;
     private final int GRID_SIZE;
@@ -143,6 +144,8 @@ public class Keyboard {
     /** Number of key widths from current touch point to search for nearest keys. */
     private static float SEARCH_DISTANCE = 1.2f;
 
+    private final ProximityInfo mProximityInfo;
+
     /**
      * Creates a keyboard from the given xml key layout file.
      * @param context the application or service context
@@ -171,6 +174,11 @@ public class Keyboard {
         mDefaultHeight = mDefaultWidth;
         mId = id;
         loadKeyboard(context, xmlLayoutResId);
+        mProximityInfo = new ProximityInfo(mDisplayWidth, mDisplayHeight, GRID_WIDTH, GRID_HEIGHT);
+    }
+
+    public int getProximityInfo() {
+        return mProximityInfo.getNativeProximityInfo(this);
     }
 
     public List<Key> getKeys() {
@@ -345,7 +353,8 @@ public class Keyboard {
         return mId != null && mId.isNumberKeyboard();
     }
 
-    private void computeNearestNeighbors() {
+    // TODO: Move this function to ProximityInfo and make this private.
+    public void computeNearestNeighbors() {
         // Round-up so we don't have any pixels outside the grid
         mCellWidth = (getMinWidth() + GRID_WIDTH - 1) / GRID_WIDTH;
         mCellHeight = (getHeight() + GRID_HEIGHT - 1) / GRID_HEIGHT;
@@ -369,6 +378,7 @@ public class Keyboard {
                 mGridNeighbors[(y / mCellHeight) * GRID_WIDTH + (x / mCellWidth)] = cell;
             }
         }
+        mProximityInfo.setProximityInfo(mGridNeighbors);
     }
 
     public boolean isInside(Key key, int x, int y) {
diff --git a/java/src/com/android/inputmethod/keyboard/KeyboardView.java b/java/src/com/android/inputmethod/keyboard/KeyboardView.java
index 7fee022e0..25bf0e0b6 100644
--- a/java/src/com/android/inputmethod/keyboard/KeyboardView.java
+++ b/java/src/com/android/inputmethod/keyboard/KeyboardView.java
@@ -762,6 +762,8 @@ public class KeyboardView extends View implements PointerTracker.UIProxy {
             canvas.translate(-key.mX - kbdPaddingLeft, -key.mY - kbdPaddingTop);
         }
 
+        // TODO: Move this function to ProximityInfo for getting rid of public declarations for
+        // GRID_WIDTH and GRID_HEIGHT
         if (DEBUG_KEYBOARD_GRID) {
             Paint p = new Paint();
             p.setStyle(Paint.Style.STROKE);
@@ -1028,7 +1030,7 @@ public class KeyboardView extends View implements PointerTracker.UIProxy {
         mKeyboardActionListener.onCodeInput(Keyboard.CODE_CAPSLOCK, null, 0, 0);
     }
 
-    private void onDoubleTapShiftKey(@SuppressWarnings("unused") PointerTracker tracker) {
+    private void onDoubleTapShiftKey(PointerTracker tracker) {
         // When shift key is double tapped, the first tap is correctly processed as usual tap. And
         // the second tap is treated as this double tap event, so that we need not mark tracker
         // calling setAlreadyProcessed() nor remove the tracker from mPointerQueueueue.
diff --git a/java/src/com/android/inputmethod/keyboard/ProximityInfo.java b/java/src/com/android/inputmethod/keyboard/ProximityInfo.java
new file mode 100644
index 000000000..fe836c1e2
--- /dev/null
+++ b/java/src/com/android/inputmethod/keyboard/ProximityInfo.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2011 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.android.inputmethod.keyboard;
+
+public class ProximityInfo {
+    public static final int MAX_PROXIMITY_CHARS_SIZE = 16;
+
+    private final int mDisplayWidth;
+    private final int mDisplayHeight;
+    private final int mGridWidth;
+    private final int mGridHeight;
+    private final int mGridSize;
+
+    ProximityInfo(int displayWidth, int displayHeight, int gridWidth, int gridHeight) {
+        mDisplayWidth = displayWidth;
+        mDisplayHeight = displayHeight;
+        mGridWidth = gridWidth;
+        mGridHeight = gridHeight;
+        mGridSize = mGridWidth * mGridHeight;
+    }
+
+    private int mNativeProximityInfo;
+    private native int setProximityInfoNative(int maxProximityCharsSize, int displayWidth,
+            int displayHeight, int gridWidth, int gridHeight, int[] proximityCharsArray);
+    private native void releaseProximityInfoNative(int nativeProximityInfo);
+
+    public final void setProximityInfo(int[][] gridNeighbors) {
+        int[] proximityCharsArray = new int[mGridSize * MAX_PROXIMITY_CHARS_SIZE];
+        for (int i = 0; i < mGridSize; ++i) {
+            final int proximityCharsLength = gridNeighbors[i].length;
+            for (int j = 0; j < MAX_PROXIMITY_CHARS_SIZE; ++j) {
+                int charCode = KeyDetector.NOT_A_KEY;
+                if (j < proximityCharsLength) {
+                    charCode = gridNeighbors[i][j];
+                }
+                proximityCharsArray[i * MAX_PROXIMITY_CHARS_SIZE + j] = charCode;
+            }
+        }
+        mNativeProximityInfo = setProximityInfoNative(MAX_PROXIMITY_CHARS_SIZE,
+                mDisplayWidth, mDisplayHeight, mGridWidth, mGridHeight, proximityCharsArray);
+    }
+
+    // TODO: Get rid of this function's input (keyboard).
+    public int getNativeProximityInfo(Keyboard keyboard) {
+        if (mNativeProximityInfo == 0) {
+            // TODO: Move this function to ProximityInfo and make this private.
+            keyboard.computeNearestNeighbors();
+        }
+        return mNativeProximityInfo;
+    }
+
+    @Override
+    protected void finalize() throws Throwable {
+        try {
+            if (mNativeProximityInfo != 0) {
+                releaseProximityInfoNative(mNativeProximityInfo);
+                mNativeProximityInfo = 0;
+            }
+        } finally {
+            super.finalize();
+        }
+    }
+}
diff --git a/java/src/com/android/inputmethod/latin/BinaryDictionary.java b/java/src/com/android/inputmethod/latin/BinaryDictionary.java
index ff7e2b88a..33b8c7af6 100644
--- a/java/src/com/android/inputmethod/latin/BinaryDictionary.java
+++ b/java/src/com/android/inputmethod/latin/BinaryDictionary.java
@@ -16,6 +16,9 @@
 
 package com.android.inputmethod.latin;
 
+import com.android.inputmethod.keyboard.KeyboardSwitcher;
+import com.android.inputmethod.keyboard.ProximityInfo;
+
 import android.content.Context;
 import android.content.res.AssetFileDescriptor;
 import android.util.Log;
@@ -34,10 +37,10 @@ public class BinaryDictionary extends Dictionary {
      * It is necessary to keep it at this value because some languages e.g. German have
      * really long words.
      */
-    protected static final int MAX_WORD_LENGTH = 48;
+    public static final int MAX_WORD_LENGTH = 48;
 
     private static final String TAG = "BinaryDictionary";
-    private static final int MAX_ALTERNATIVES = 16;
+    private static final int MAX_PROXIMITY_CHARS_SIZE = ProximityInfo.MAX_PROXIMITY_CHARS_SIZE;
     private static final int MAX_WORDS = 18;
     private static final int MAX_BIGRAMS = 60;
 
@@ -47,19 +50,13 @@ public class BinaryDictionary extends Dictionary {
     private int mDicTypeId;
     private int mNativeDict;
     private long mDictLength;
-    private final int[] mInputCodes = new int[MAX_WORD_LENGTH * MAX_ALTERNATIVES];
+    private final int[] mInputCodes = new int[MAX_WORD_LENGTH * MAX_PROXIMITY_CHARS_SIZE];
     private final char[] mOutputChars = new char[MAX_WORD_LENGTH * MAX_WORDS];
     private final char[] mOutputChars_bigrams = new char[MAX_WORD_LENGTH * MAX_BIGRAMS];
     private final int[] mFrequencies = new int[MAX_WORDS];
     private final int[] mFrequencies_bigrams = new int[MAX_BIGRAMS];
 
-    static {
-        try {
-            System.loadLibrary("jni_latinime");
-        } catch (UnsatisfiedLinkError ule) {
-            Log.e(TAG, "Could not load native library jni_latinime");
-        }
-    }
+    private final KeyboardSwitcher mKeyboardSwitcher = KeyboardSwitcher.getInstance();
 
     private BinaryDictionary() {
     }
@@ -117,8 +114,9 @@ public class BinaryDictionary extends Dictionary {
             int maxWords, int maxAlternatives);
     private native void closeNative(int dict);
     private native boolean isValidWordNative(int nativeData, char[] word, int wordLength);
-    private native int getSuggestionsNative(int dict, int[] inputCodes, int codesSize,
-            char[] outputChars, int[] frequencies);
+    private native int getSuggestionsNative(int dict, int proximityInfo, int[] xCoordinates,
+            int[] yCoordinates, int[] inputCodes, int codesSize, char[] outputChars,
+            int[] frequencies);
     private native int getBigramsNative(int dict, char[] prevWord, int prevWordLength,
             int[] inputCodes, int inputCodesLength, char[] outputChars, int[] frequencies,
             int maxWordLength, int maxBigrams, int maxAlternatives);
@@ -126,7 +124,7 @@ public class BinaryDictionary extends Dictionary {
     private final void loadDictionary(String path, long startOffset, long length) {
         mNativeDict = openNative(path, startOffset, length,
                     TYPED_LETTER_MULTIPLIER, FULL_WORD_FREQ_MULTIPLIER,
-                    MAX_WORD_LENGTH, MAX_WORDS, MAX_ALTERNATIVES);
+                    MAX_WORD_LENGTH, MAX_WORDS, MAX_PROXIMITY_CHARS_SIZE);
         mDictLength = length;
     }
 
@@ -143,11 +141,11 @@ public class BinaryDictionary extends Dictionary {
         Arrays.fill(mInputCodes, -1);
         int[] alternatives = codes.getCodesAt(0);
         System.arraycopy(alternatives, 0, mInputCodes, 0,
-                Math.min(alternatives.length, MAX_ALTERNATIVES));
+                Math.min(alternatives.length, MAX_PROXIMITY_CHARS_SIZE));
 
         int count = getBigramsNative(mNativeDict, chars, chars.length, mInputCodes, codesSize,
                 mOutputChars_bigrams, mFrequencies_bigrams, MAX_WORD_LENGTH, MAX_BIGRAMS,
-                MAX_ALTERNATIVES);
+                MAX_PROXIMITY_CHARS_SIZE);
 
         for (int j = 0; j < count; ++j) {
             if (mFrequencies_bigrams[j] < 1) break;
@@ -174,14 +172,16 @@ public class BinaryDictionary extends Dictionary {
         Arrays.fill(mInputCodes, WordComposer.NOT_A_CODE);
         for (int i = 0; i < codesSize; i++) {
             int[] alternatives = codes.getCodesAt(i);
-            System.arraycopy(alternatives, 0, mInputCodes, i * MAX_ALTERNATIVES,
-                    Math.min(alternatives.length, MAX_ALTERNATIVES));
+            System.arraycopy(alternatives, 0, mInputCodes, i * MAX_PROXIMITY_CHARS_SIZE,
+                    Math.min(alternatives.length, MAX_PROXIMITY_CHARS_SIZE));
         }
         Arrays.fill(mOutputChars, (char) 0);
         Arrays.fill(mFrequencies, 0);
 
-        int count = getSuggestionsNative(mNativeDict, mInputCodes, codesSize, mOutputChars,
-                mFrequencies);
+        int count = getSuggestionsNative(
+                mNativeDict, mKeyboardSwitcher.getLatinKeyboard().getProximityInfo(),
+                codes.getXCoordinates(), codes.getYCoordinates(), mInputCodes, codesSize,
+                mOutputChars, mFrequencies);
 
         for (int j = 0; j < count; ++j) {
             if (mFrequencies[j] < 1) break;
diff --git a/java/src/com/android/inputmethod/latin/LatinIME.java b/java/src/com/android/inputmethod/latin/LatinIME.java
index 38ee82626..638578a1a 100644
--- a/java/src/com/android/inputmethod/latin/LatinIME.java
+++ b/java/src/com/android/inputmethod/latin/LatinIME.java
@@ -187,6 +187,14 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
 
     private final ArrayList<WordAlternatives> mWordHistory = new ArrayList<WordAlternatives>();
 
+    static {
+        try {
+            System.loadLibrary("jni_latinime");
+        } catch (UnsatisfiedLinkError ule) {
+            Log.e(TAG, "Could not load native library jni_latinime");
+        }
+    }
+
     public abstract static class WordAlternatives {
         protected CharSequence mChosenWord;
 
@@ -1119,7 +1127,7 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
             if (isWordSeparator(primaryCode)) {
                 handleSeparator(primaryCode);
             } else {
-                handleCharacter(primaryCode, keyCodes);
+                handleCharacter(primaryCode, keyCodes, x, y);
             }
             // Cancel the just reverted state
             mJustReverted = false;
@@ -1244,7 +1252,7 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
         }
     }
 
-    private void handleCharacter(int primaryCode, int[] keyCodes) {
+    private void handleCharacter(int primaryCode, int[] keyCodes, int x, int y) {
         mVoiceConnector.handleCharacter();
 
         if (mLastSelectionStart == mLastSelectionEnd && TextEntryState.isCorrecting()) {
@@ -1285,7 +1293,7 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
                 mWord.setFirstCharCapitalized(true);
             }
             mComposing.append((char) code);
-            mWord.add(code, keyCodes);
+            mWord.add(code, keyCodes, x, y);
             InputConnection ic = getCurrentInputConnection();
             if (ic != null) {
                 // If it's the first letter, make note of auto-caps state
@@ -1692,7 +1700,7 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
             for (int i = 0; i < touching.mWord.length(); i++) {
                 foundWord.add(touching.mWord.charAt(i), new int[] {
                     touching.mWord.charAt(i)
-                });
+                }, WordComposer.NOT_A_COORDINATE, WordComposer.NOT_A_COORDINATE);
             }
             foundWord.setFirstCharCapitalized(Character.isUpperCase(touching.mWord.charAt(0)));
         }
diff --git a/java/src/com/android/inputmethod/latin/WordComposer.java b/java/src/com/android/inputmethod/latin/WordComposer.java
index e003dcd5b..02583895b 100644
--- a/java/src/com/android/inputmethod/latin/WordComposer.java
+++ b/java/src/com/android/inputmethod/latin/WordComposer.java
@@ -24,18 +24,24 @@ import java.util.ArrayList;
  * A place to store the currently composing word with information such as adjacent key codes as well
  */
 public class WordComposer {
+
     public static final int NOT_A_CODE = KeyDetector.NOT_A_CODE;
+    public static final int NOT_A_COORDINATE = -1;
 
     /**
      * The list of unicode values for each keystroke (including surrounding keys)
      */
     private final ArrayList<int[]> mCodes;
-    
+
+    private int mTypedLength;
+    private final int[] mXCoordinates;
+    private final int[] mYCoordinates;
+
     /**
      * The word chosen from the candidate list, until it is committed.
      */
     private String mPreferredWord;
-    
+
     private final StringBuilder mTypedWord;
 
     private int mCapsCount;
@@ -48,17 +54,24 @@ public class WordComposer {
     private boolean mIsFirstCharCapitalized;
 
     public WordComposer() {
-        mCodes = new ArrayList<int[]>(12);
-        mTypedWord = new StringBuilder(20);
+        final int N = BinaryDictionary.MAX_WORD_LENGTH;
+        mCodes = new ArrayList<int[]>(N);
+        mTypedWord = new StringBuilder(N);
+        mTypedLength = 0;
+        mXCoordinates = new int[N];
+        mYCoordinates = new int[N];
     }
 
-    WordComposer(WordComposer copy) {
-        mCodes = new ArrayList<int[]>(copy.mCodes);
-        mPreferredWord = copy.mPreferredWord;
-        mTypedWord = new StringBuilder(copy.mTypedWord);
-        mCapsCount = copy.mCapsCount;
-        mAutoCapitalized = copy.mAutoCapitalized;
-        mIsFirstCharCapitalized = copy.mIsFirstCharCapitalized;
+    WordComposer(WordComposer source) {
+        mCodes = new ArrayList<int[]>(source.mCodes);
+        mPreferredWord = source.mPreferredWord;
+        mTypedWord = new StringBuilder(source.mTypedWord);
+        mCapsCount = source.mCapsCount;
+        mAutoCapitalized = source.mAutoCapitalized;
+        mIsFirstCharCapitalized = source.mIsFirstCharCapitalized;
+        mTypedLength = source.mTypedLength;
+        mXCoordinates = source.mXCoordinates;
+        mYCoordinates = source.mYCoordinates;
     }
 
     /**
@@ -66,6 +79,7 @@ public class WordComposer {
      */
     public void reset() {
         mCodes.clear();
+        mTypedLength = 0;
         mIsFirstCharCapitalized = false;
         mPreferredWord = null;
         mTypedWord.setLength(0);
@@ -89,15 +103,28 @@ public class WordComposer {
         return mCodes.get(index);
     }
 
+    public int[] getXCoordinates() {
+        return mXCoordinates;
+    }
+
+    public int[] getYCoordinates() {
+        return mYCoordinates;
+    }
+
     /**
      * Add a new keystroke, with codes[0] containing the pressed key's unicode and the rest of
      * the array containing unicode for adjacent keys, sorted by reducing probability/proximity.
      * @param codes the array of unicode values
      */
-    public void add(int primaryCode, int[] codes) {
+    public void add(int primaryCode, int[] codes, int x, int y) {
         mTypedWord.append((char) primaryCode);
         correctPrimaryJuxtapos(primaryCode, codes);
         mCodes.add(codes);
+        if (mTypedLength < BinaryDictionary.MAX_WORD_LENGTH) {
+            mXCoordinates[mTypedLength] = x;
+            mYCoordinates[mTypedLength] = y;
+        }
+        ++mTypedLength;
         if (Character.isUpperCase((char) primaryCode)) mCapsCount++;
     }
 
@@ -128,6 +155,9 @@ public class WordComposer {
             mTypedWord.deleteCharAt(lastPos);
             if (Character.isUpperCase(last)) mCapsCount--;
         }
+        if (mTypedLength > 0) {
+            --mTypedLength;
+        }
     }
 
     /**