Merge "Add proximity info to native"

This commit is contained in:
satok 2011-02-23 18:28:14 -08:00 committed by Android (Google) Code Review
commit 10c169a44d
20 changed files with 499 additions and 86 deletions

View file

@ -132,6 +132,7 @@ public class Keyboard {
// Variables for pre-computing nearest keys. // Variables for pre-computing nearest keys.
// TODO: Change GRID_WIDTH and GRID_HEIGHT to private.
public final int GRID_WIDTH; public final int GRID_WIDTH;
public final int GRID_HEIGHT; public final int GRID_HEIGHT;
private final int GRID_SIZE; 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. */ /** Number of key widths from current touch point to search for nearest keys. */
private static float SEARCH_DISTANCE = 1.2f; private static float SEARCH_DISTANCE = 1.2f;
private final ProximityInfo mProximityInfo;
/** /**
* Creates a keyboard from the given xml key layout file. * Creates a keyboard from the given xml key layout file.
* @param context the application or service context * @param context the application or service context
@ -171,6 +174,11 @@ public class Keyboard {
mDefaultHeight = mDefaultWidth; mDefaultHeight = mDefaultWidth;
mId = id; mId = id;
loadKeyboard(context, xmlLayoutResId); loadKeyboard(context, xmlLayoutResId);
mProximityInfo = new ProximityInfo(mDisplayWidth, mDisplayHeight, GRID_WIDTH, GRID_HEIGHT);
}
public int getProximityInfo() {
return mProximityInfo.getNativeProximityInfo(this);
} }
public List<Key> getKeys() { public List<Key> getKeys() {
@ -345,7 +353,8 @@ public class Keyboard {
return mId != null && mId.isNumberKeyboard(); 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 // Round-up so we don't have any pixels outside the grid
mCellWidth = (getMinWidth() + GRID_WIDTH - 1) / GRID_WIDTH; mCellWidth = (getMinWidth() + GRID_WIDTH - 1) / GRID_WIDTH;
mCellHeight = (getHeight() + GRID_HEIGHT - 1) / GRID_HEIGHT; mCellHeight = (getHeight() + GRID_HEIGHT - 1) / GRID_HEIGHT;
@ -369,6 +378,7 @@ public class Keyboard {
mGridNeighbors[(y / mCellHeight) * GRID_WIDTH + (x / mCellWidth)] = cell; mGridNeighbors[(y / mCellHeight) * GRID_WIDTH + (x / mCellWidth)] = cell;
} }
} }
mProximityInfo.setProximityInfo(mGridNeighbors);
} }
public boolean isInside(Key key, int x, int y) { public boolean isInside(Key key, int x, int y) {

View file

@ -762,6 +762,8 @@ public class KeyboardView extends View implements PointerTracker.UIProxy {
canvas.translate(-key.mX - kbdPaddingLeft, -key.mY - kbdPaddingTop); 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) { if (DEBUG_KEYBOARD_GRID) {
Paint p = new Paint(); Paint p = new Paint();
p.setStyle(Paint.Style.STROKE); 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); 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 // 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 // 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. // calling setAlreadyProcessed() nor remove the tracker from mPointerQueueueue.

View file

@ -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();
}
}
}

View file

@ -16,6 +16,9 @@
package com.android.inputmethod.latin; package com.android.inputmethod.latin;
import com.android.inputmethod.keyboard.KeyboardSwitcher;
import com.android.inputmethod.keyboard.ProximityInfo;
import android.content.Context; import android.content.Context;
import android.content.res.AssetFileDescriptor; import android.content.res.AssetFileDescriptor;
import android.util.Log; 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 * It is necessary to keep it at this value because some languages e.g. German have
* really long words. * 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 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_WORDS = 18;
private static final int MAX_BIGRAMS = 60; private static final int MAX_BIGRAMS = 60;
@ -47,19 +50,13 @@ public class BinaryDictionary extends Dictionary {
private int mDicTypeId; private int mDicTypeId;
private int mNativeDict; private int mNativeDict;
private long mDictLength; 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 = new char[MAX_WORD_LENGTH * MAX_WORDS];
private final char[] mOutputChars_bigrams = new char[MAX_WORD_LENGTH * MAX_BIGRAMS]; private final char[] mOutputChars_bigrams = new char[MAX_WORD_LENGTH * MAX_BIGRAMS];
private final int[] mFrequencies = new int[MAX_WORDS]; private final int[] mFrequencies = new int[MAX_WORDS];
private final int[] mFrequencies_bigrams = new int[MAX_BIGRAMS]; private final int[] mFrequencies_bigrams = new int[MAX_BIGRAMS];
static { private final KeyboardSwitcher mKeyboardSwitcher = KeyboardSwitcher.getInstance();
try {
System.loadLibrary("jni_latinime");
} catch (UnsatisfiedLinkError ule) {
Log.e(TAG, "Could not load native library jni_latinime");
}
}
private BinaryDictionary() { private BinaryDictionary() {
} }
@ -117,8 +114,9 @@ public class BinaryDictionary extends Dictionary {
int maxWords, int maxAlternatives); int maxWords, int maxAlternatives);
private native void closeNative(int dict); private native void closeNative(int dict);
private native boolean isValidWordNative(int nativeData, char[] word, int wordLength); private native boolean isValidWordNative(int nativeData, char[] word, int wordLength);
private native int getSuggestionsNative(int dict, int[] inputCodes, int codesSize, private native int getSuggestionsNative(int dict, int proximityInfo, int[] xCoordinates,
char[] outputChars, int[] frequencies); int[] yCoordinates, int[] inputCodes, int codesSize, char[] outputChars,
int[] frequencies);
private native int getBigramsNative(int dict, char[] prevWord, int prevWordLength, private native int getBigramsNative(int dict, char[] prevWord, int prevWordLength,
int[] inputCodes, int inputCodesLength, char[] outputChars, int[] frequencies, int[] inputCodes, int inputCodesLength, char[] outputChars, int[] frequencies,
int maxWordLength, int maxBigrams, int maxAlternatives); 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) { private final void loadDictionary(String path, long startOffset, long length) {
mNativeDict = openNative(path, startOffset, length, mNativeDict = openNative(path, startOffset, length,
TYPED_LETTER_MULTIPLIER, FULL_WORD_FREQ_MULTIPLIER, 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; mDictLength = length;
} }
@ -143,11 +141,11 @@ public class BinaryDictionary extends Dictionary {
Arrays.fill(mInputCodes, -1); Arrays.fill(mInputCodes, -1);
int[] alternatives = codes.getCodesAt(0); int[] alternatives = codes.getCodesAt(0);
System.arraycopy(alternatives, 0, mInputCodes, 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, int count = getBigramsNative(mNativeDict, chars, chars.length, mInputCodes, codesSize,
mOutputChars_bigrams, mFrequencies_bigrams, MAX_WORD_LENGTH, MAX_BIGRAMS, mOutputChars_bigrams, mFrequencies_bigrams, MAX_WORD_LENGTH, MAX_BIGRAMS,
MAX_ALTERNATIVES); MAX_PROXIMITY_CHARS_SIZE);
for (int j = 0; j < count; ++j) { for (int j = 0; j < count; ++j) {
if (mFrequencies_bigrams[j] < 1) break; if (mFrequencies_bigrams[j] < 1) break;
@ -174,14 +172,16 @@ public class BinaryDictionary extends Dictionary {
Arrays.fill(mInputCodes, WordComposer.NOT_A_CODE); Arrays.fill(mInputCodes, WordComposer.NOT_A_CODE);
for (int i = 0; i < codesSize; i++) { for (int i = 0; i < codesSize; i++) {
int[] alternatives = codes.getCodesAt(i); int[] alternatives = codes.getCodesAt(i);
System.arraycopy(alternatives, 0, mInputCodes, i * MAX_ALTERNATIVES, System.arraycopy(alternatives, 0, mInputCodes, i * MAX_PROXIMITY_CHARS_SIZE,
Math.min(alternatives.length, MAX_ALTERNATIVES)); Math.min(alternatives.length, MAX_PROXIMITY_CHARS_SIZE));
} }
Arrays.fill(mOutputChars, (char) 0); Arrays.fill(mOutputChars, (char) 0);
Arrays.fill(mFrequencies, 0); Arrays.fill(mFrequencies, 0);
int count = getSuggestionsNative(mNativeDict, mInputCodes, codesSize, mOutputChars, int count = getSuggestionsNative(
mFrequencies); mNativeDict, mKeyboardSwitcher.getLatinKeyboard().getProximityInfo(),
codes.getXCoordinates(), codes.getYCoordinates(), mInputCodes, codesSize,
mOutputChars, mFrequencies);
for (int j = 0; j < count; ++j) { for (int j = 0; j < count; ++j) {
if (mFrequencies[j] < 1) break; if (mFrequencies[j] < 1) break;

View file

@ -203,6 +203,14 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
private final ArrayList<WordAlternatives> mWordHistory = new ArrayList<WordAlternatives>(); 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 { public abstract static class WordAlternatives {
protected CharSequence mChosenWord; protected CharSequence mChosenWord;
@ -1125,7 +1133,7 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
if (isWordSeparator(primaryCode)) { if (isWordSeparator(primaryCode)) {
handleSeparator(primaryCode); handleSeparator(primaryCode);
} else { } else {
handleCharacter(primaryCode, keyCodes); handleCharacter(primaryCode, keyCodes, x, y);
} }
// Cancel the just reverted state // Cancel the just reverted state
mJustReverted = false; mJustReverted = false;
@ -1250,7 +1258,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(); mVoiceConnector.handleCharacter();
if (mLastSelectionStart == mLastSelectionEnd && TextEntryState.isCorrecting()) { if (mLastSelectionStart == mLastSelectionEnd && TextEntryState.isCorrecting()) {
@ -1291,7 +1299,7 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
mWord.setFirstCharCapitalized(true); mWord.setFirstCharCapitalized(true);
} }
mComposing.append((char) code); mComposing.append((char) code);
mWord.add(code, keyCodes); mWord.add(code, keyCodes, x, y);
InputConnection ic = getCurrentInputConnection(); InputConnection ic = getCurrentInputConnection();
if (ic != null) { if (ic != null) {
// If it's the first letter, make note of auto-caps state // If it's the first letter, make note of auto-caps state
@ -1698,7 +1706,7 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
for (int i = 0; i < touching.mWord.length(); i++) { for (int i = 0; i < touching.mWord.length(); i++) {
foundWord.add(touching.mWord.charAt(i), new int[] { foundWord.add(touching.mWord.charAt(i), new int[] {
touching.mWord.charAt(i) touching.mWord.charAt(i)
}); }, WordComposer.NOT_A_COORDINATE, WordComposer.NOT_A_COORDINATE);
} }
foundWord.setFirstCharCapitalized(Character.isUpperCase(touching.mWord.charAt(0))); foundWord.setFirstCharCapitalized(Character.isUpperCase(touching.mWord.charAt(0)));
} }

View file

@ -24,13 +24,19 @@ import java.util.ArrayList;
* A place to store the currently composing word with information such as adjacent key codes as well * A place to store the currently composing word with information such as adjacent key codes as well
*/ */
public class WordComposer { public class WordComposer {
public static final int NOT_A_CODE = KeyDetector.NOT_A_CODE; 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) * The list of unicode values for each keystroke (including surrounding keys)
*/ */
private final ArrayList<int[]> mCodes; 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. * The word chosen from the candidate list, until it is committed.
*/ */
@ -48,17 +54,24 @@ public class WordComposer {
private boolean mIsFirstCharCapitalized; private boolean mIsFirstCharCapitalized;
public WordComposer() { public WordComposer() {
mCodes = new ArrayList<int[]>(12); final int N = BinaryDictionary.MAX_WORD_LENGTH;
mTypedWord = new StringBuilder(20); mCodes = new ArrayList<int[]>(N);
mTypedWord = new StringBuilder(N);
mTypedLength = 0;
mXCoordinates = new int[N];
mYCoordinates = new int[N];
} }
WordComposer(WordComposer copy) { WordComposer(WordComposer source) {
mCodes = new ArrayList<int[]>(copy.mCodes); mCodes = new ArrayList<int[]>(source.mCodes);
mPreferredWord = copy.mPreferredWord; mPreferredWord = source.mPreferredWord;
mTypedWord = new StringBuilder(copy.mTypedWord); mTypedWord = new StringBuilder(source.mTypedWord);
mCapsCount = copy.mCapsCount; mCapsCount = source.mCapsCount;
mAutoCapitalized = copy.mAutoCapitalized; mAutoCapitalized = source.mAutoCapitalized;
mIsFirstCharCapitalized = copy.mIsFirstCharCapitalized; mIsFirstCharCapitalized = source.mIsFirstCharCapitalized;
mTypedLength = source.mTypedLength;
mXCoordinates = source.mXCoordinates;
mYCoordinates = source.mYCoordinates;
} }
/** /**
@ -66,6 +79,7 @@ public class WordComposer {
*/ */
public void reset() { public void reset() {
mCodes.clear(); mCodes.clear();
mTypedLength = 0;
mIsFirstCharCapitalized = false; mIsFirstCharCapitalized = false;
mPreferredWord = null; mPreferredWord = null;
mTypedWord.setLength(0); mTypedWord.setLength(0);
@ -89,15 +103,28 @@ public class WordComposer {
return mCodes.get(index); 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 * 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. * the array containing unicode for adjacent keys, sorted by reducing probability/proximity.
* @param codes the array of unicode values * @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); mTypedWord.append((char) primaryCode);
correctPrimaryJuxtapos(primaryCode, codes); correctPrimaryJuxtapos(primaryCode, codes);
mCodes.add(codes); mCodes.add(codes);
if (mTypedLength < BinaryDictionary.MAX_WORD_LENGTH) {
mXCoordinates[mTypedLength] = x;
mYCoordinates[mTypedLength] = y;
}
++mTypedLength;
if (Character.isUpperCase((char) primaryCode)) mCapsCount++; if (Character.isUpperCase((char) primaryCode)) mCapsCount++;
} }
@ -128,6 +155,9 @@ public class WordComposer {
mTypedWord.deleteCharAt(lastPos); mTypedWord.deleteCharAt(lastPos);
if (Character.isUpperCase(last)) mCapsCount--; if (Character.isUpperCase(last)) mCapsCount--;
} }
if (mTypedLength > 0) {
--mTypedLength;
}
} }
/** /**

View file

@ -4,10 +4,13 @@ include $(CLEAR_VARS)
LOCAL_C_INCLUDES += $(LOCAL_PATH)/src LOCAL_C_INCLUDES += $(LOCAL_PATH)/src
LOCAL_SRC_FILES := \ LOCAL_SRC_FILES := \
jni/com_android_inputmethod_keyboard_ProximityInfo.cpp \
jni/com_android_inputmethod_latin_BinaryDictionary.cpp \ jni/com_android_inputmethod_latin_BinaryDictionary.cpp \
jni/onload.cpp \
src/bigram_dictionary.cpp \ src/bigram_dictionary.cpp \
src/char_utils.cpp \ src/char_utils.cpp \
src/dictionary.cpp \ src/dictionary.cpp \
src/proximity_info.cpp \
src/unigram_dictionary.cpp src/unigram_dictionary.cpp
#FLAG_DBG := true #FLAG_DBG := true

View file

@ -0,0 +1,90 @@
/*
**
** Copyright 2011, The Android Open Source Project
**
** 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.
*/
#define LOG_TAG "LatinIME: jni: ProximityInfo"
#include "com_android_inputmethod_keyboard_ProximityInfo.h"
#include "jni.h"
#include "proximity_info.h"
#include <assert.h>
#include <errno.h>
#include <stdio.h>
// ----------------------------------------------------------------------------
namespace latinime {
//
// helper function to throw an exception
//
static void throwException(JNIEnv *env, const char* ex, const char* fmt, int data) {
if (jclass cls = env->FindClass(ex)) {
char msg[1000];
snprintf(msg, sizeof(msg), fmt, data);
env->ThrowNew(cls, msg);
env->DeleteLocalRef(cls);
}
}
static jint latinime_Keyboard_setProximityInfo(JNIEnv *env, jobject object,
jint maxProximityCharsSize, jint displayWidth, jint displayHeight, jint gridWidth,
jint gridHeight, jintArray proximityCharsArray) {
jint* proximityChars = env->GetIntArrayElements(proximityCharsArray, NULL);
ProximityInfo *proximityInfo = new ProximityInfo(maxProximityCharsSize, displayWidth,
displayHeight, gridWidth, gridHeight, (const uint32_t *)proximityChars);
env->ReleaseIntArrayElements(proximityCharsArray, proximityChars, 0);
return (jint)proximityInfo;
}
static void latinime_Keyboard_release(JNIEnv *env, jobject object, jint proximityInfo) {
ProximityInfo *pi = (ProximityInfo*)proximityInfo;
if (!pi) return;
delete pi;
}
// ----------------------------------------------------------------------------
static JNINativeMethod sKeyboardMethods[] = {
{"setProximityInfoNative", "(IIIII[I)I", (void*)latinime_Keyboard_setProximityInfo},
{"releaseProximityInfoNative", "(I)V", (void*)latinime_Keyboard_release}
};
static int registerNativeMethods(JNIEnv* env, const char* className, JNINativeMethod* gMethods,
int numMethods) {
jclass clazz;
clazz = env->FindClass(className);
if (clazz == NULL) {
LOGE("Native registration unable to find class '%s'", className);
return JNI_FALSE;
}
if (env->RegisterNatives(clazz, gMethods, numMethods) < 0) {
LOGE("RegisterNatives failed for '%s'", className);
return JNI_FALSE;
}
return JNI_TRUE;
}
int register_ProximityInfo(JNIEnv *env) {
const char* const kClassPathName = "com/android/inputmethod/keyboard/ProximityInfo";
return registerNativeMethods(env, kClassPathName, sKeyboardMethods,
sizeof(sKeyboardMethods) / sizeof(sKeyboardMethods[0]));
}
}; // namespace latinime

View file

@ -0,0 +1,27 @@
/*
**
** Copyright 2011, The Android Open Source Project
**
** 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.
*/
#ifndef _COM_ANDROID_INPUTMETHOD_KEYBOARD_PROXIMITYINFO_H
#define _COM_ANDROID_INPUTMETHOD_KEYBOARD_PROXIMITYINFO_H
#include "jni.h"
namespace latinime {
int register_ProximityInfo(JNIEnv *env);
}
#endif // _COM_ANDROID_INPUTMETHOD_KEYBOARD_PROXIMITYINFO_H

View file

@ -15,10 +15,12 @@
** limitations under the License. ** limitations under the License.
*/ */
#define LOG_TAG "LatinIME: jni" #define LOG_TAG "LatinIME: jni: BinaryDictionary"
#include "com_android_inputmethod_latin_BinaryDictionary.h"
#include "dictionary.h" #include "dictionary.h"
#include "jni.h" #include "jni.h"
#include "proximity_info.h"
#include <assert.h> #include <assert.h>
#include <errno.h> #include <errno.h>
@ -35,7 +37,7 @@
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
using namespace latinime; namespace latinime {
// //
// helper function to throw an exception // helper function to throw an exception
@ -43,7 +45,7 @@ using namespace latinime;
static void throwException(JNIEnv *env, const char* ex, const char* fmt, int data) { static void throwException(JNIEnv *env, const char* ex, const char* fmt, int data) {
if (jclass cls = env->FindClass(ex)) { if (jclass cls = env->FindClass(ex)) {
char msg[1000]; char msg[1000];
sprintf(msg, fmt, data); snprintf(msg, sizeof(msg), fmt, data);
env->ThrowNew(cls, msg); env->ThrowNew(cls, msg);
env->DeleteLocalRef(cls); env->DeleteLocalRef(cls);
} }
@ -123,19 +125,27 @@ static jint latinime_BinaryDictionary_open(JNIEnv *env, jobject object,
} }
static int latinime_BinaryDictionary_getSuggestions(JNIEnv *env, jobject object, jint dict, static int latinime_BinaryDictionary_getSuggestions(JNIEnv *env, jobject object, jint dict,
jint proximityInfo, jintArray xCoordinatesArray, jintArray yCoordinatesArray,
jintArray inputArray, jint arraySize, jcharArray outputArray, jintArray frequencyArray) { jintArray inputArray, jint arraySize, jcharArray outputArray, jintArray frequencyArray) {
Dictionary *dictionary = (Dictionary*)dict; Dictionary *dictionary = (Dictionary*)dict;
if (!dictionary) return 0; if (!dictionary) return 0;
ProximityInfo *pInfo = (ProximityInfo*)proximityInfo;
if (!pInfo) return 0;
int *xCoordinates = env->GetIntArrayElements(xCoordinatesArray, NULL);
int *yCoordinates = env->GetIntArrayElements(yCoordinatesArray, NULL);
int *frequencies = env->GetIntArrayElements(frequencyArray, NULL); int *frequencies = env->GetIntArrayElements(frequencyArray, NULL);
int *inputCodes = env->GetIntArrayElements(inputArray, NULL); int *inputCodes = env->GetIntArrayElements(inputArray, NULL);
jchar *outputChars = env->GetCharArrayElements(outputArray, NULL); jchar *outputChars = env->GetCharArrayElements(outputArray, NULL);
int count = dictionary->getSuggestions(inputCodes, arraySize, (unsigned short*) outputChars, int count = dictionary->getSuggestions(pInfo, xCoordinates, yCoordinates, inputCodes,
frequencies); arraySize, (unsigned short*) outputChars, frequencies);
env->ReleaseIntArrayElements(frequencyArray, frequencies, 0); env->ReleaseIntArrayElements(frequencyArray, frequencies, 0);
env->ReleaseIntArrayElements(inputArray, inputCodes, JNI_ABORT); env->ReleaseIntArrayElements(inputArray, inputCodes, JNI_ABORT);
env->ReleaseIntArrayElements(xCoordinatesArray, xCoordinates, 0);
env->ReleaseIntArrayElements(yCoordinatesArray, yCoordinates, 0);
env->ReleaseCharArrayElements(outputArray, outputChars, 0); env->ReleaseCharArrayElements(outputArray, outputChars, 0);
return count; return count;
@ -200,10 +210,10 @@ static void latinime_BinaryDictionary_close(JNIEnv *env, jobject object, jint di
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
static JNINativeMethod gMethods[] = { static JNINativeMethod sMethods[] = {
{"openNative", "(Ljava/lang/String;JJIIIII)I", (void*)latinime_BinaryDictionary_open}, {"openNative", "(Ljava/lang/String;JJIIIII)I", (void*)latinime_BinaryDictionary_open},
{"closeNative", "(I)V", (void*)latinime_BinaryDictionary_close}, {"closeNative", "(I)V", (void*)latinime_BinaryDictionary_close},
{"getSuggestionsNative", "(I[II[C[I)I", (void*)latinime_BinaryDictionary_getSuggestions}, {"getSuggestionsNative", "(II[I[I[II[C[I)I", (void*)latinime_BinaryDictionary_getSuggestions},
{"isValidWordNative", "(I[CI)Z", (void*)latinime_BinaryDictionary_isValidWord}, {"isValidWordNative", "(I[CI)Z", (void*)latinime_BinaryDictionary_isValidWord},
{"getBigramsNative", "(I[CI[II[C[IIII)I", (void*)latinime_BinaryDictionary_getBigrams} {"getBigramsNative", "(I[CI[II[C[IIII)I", (void*)latinime_BinaryDictionary_getBigrams}
}; };
@ -225,33 +235,10 @@ static int registerNativeMethods(JNIEnv* env, const char* className, JNINativeMe
return JNI_TRUE; return JNI_TRUE;
} }
static int registerNatives(JNIEnv *env) { int register_BinaryDictionary(JNIEnv *env) {
const char* const kClassPathName = "com/android/inputmethod/latin/BinaryDictionary"; const char* const kClassPathName = "com/android/inputmethod/latin/BinaryDictionary";
return registerNativeMethods(env, kClassPathName, gMethods, return registerNativeMethods(env, kClassPathName, sMethods,
sizeof(gMethods) / sizeof(gMethods[0])); sizeof(sMethods) / sizeof(sMethods[0]));
} }
/* }; // namespace latinime
* Returns the JNI version on success, -1 on failure.
*/
jint JNI_OnLoad(JavaVM* vm, void* reserved) {
JNIEnv* env = NULL;
jint result = -1;
if (vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) {
LOGE("ERROR: GetEnv failed");
goto bail;
}
assert(env != NULL);
if (!registerNatives(env)) {
LOGE("ERROR: BinaryDictionary native registration failed");
goto bail;
}
/* success -- return valid version number */
result = JNI_VERSION_1_4;
bail:
return result;
}

View file

@ -0,0 +1,27 @@
/*
**
** Copyright 2011, The Android Open Source Project
**
** 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.
*/
#ifndef _COM_ANDROID_INPUTMETHOD_LATIN_BINARYDICTIONARY_H
#define _COM_ANDROID_INPUTMETHOD_LATIN_BINARYDICTIONARY_H
#include "jni.h"
namespace latinime {
int register_BinaryDictionary(JNIEnv *env);
}
#endif // _COM_ANDROID_INPUTMETHOD_LATIN_BINARYDICTIONARY_H

62
native/jni/onload.cpp Normal file
View file

@ -0,0 +1,62 @@
/*
**
** Copyright 2011, The Android Open Source Project
**
** 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.
*/
#define LOG_TAG "LatinIME: jni"
#include "com_android_inputmethod_keyboard_ProximityInfo.h"
#include "com_android_inputmethod_latin_BinaryDictionary.h"
#include "jni.h"
#include "proximity_info.h"
#include <assert.h>
#include <errno.h>
#include <stdio.h>
// ----------------------------------------------------------------------------
using namespace latinime;
/*
* Returns the JNI version on success, -1 on failure.
*/
jint JNI_OnLoad(JavaVM* vm, void* reserved) {
JNIEnv* env = NULL;
jint result = -1;
if (vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) {
LOGE("ERROR: GetEnv failed");
goto bail;
}
assert(env != NULL);
if (!register_BinaryDictionary(env)) {
LOGE("ERROR: BinaryDictionary native registration failed");
goto bail;
}
if (!register_ProximityInfo(env)) {
LOGE("ERROR: ProximityInfo native registration failed");
goto bail;
}
/* success -- return valid version number */
result = JNI_VERSION_1_4;
bail:
return result;
}

View file

@ -28,6 +28,7 @@
#define DEBUG_SHOW_FOUND_WORD DEBUG_DICT_FULL #define DEBUG_SHOW_FOUND_WORD DEBUG_DICT_FULL
#define DEBUG_NODE DEBUG_DICT_FULL #define DEBUG_NODE DEBUG_DICT_FULL
#define DEBUG_TRACE DEBUG_DICT_FULL #define DEBUG_TRACE DEBUG_DICT_FULL
#define DEBUG_PROXIMITY_INFO true
// Profiler // Profiler
#include <time.h> #include <time.h>
@ -83,6 +84,7 @@ static void prof_out(void) {
#define DEBUG_SHOW_FOUND_WORD false #define DEBUG_SHOW_FOUND_WORD false
#define DEBUG_NODE false #define DEBUG_NODE false
#define DEBUG_TRACE false #define DEBUG_TRACE false
#define DEBUG_PROXIMITY_INFO false
#define PROF_BUF_SIZE 0 #define PROF_BUF_SIZE 0
#define PROF_RESET #define PROF_RESET

View file

@ -23,6 +23,7 @@
namespace latinime { namespace latinime {
// TODO: Change the type of all keyCodes to uint32_t
Dictionary::Dictionary(void *dict, int dictSize, int mmapFd, int dictBufAdjust, Dictionary::Dictionary(void *dict, int dictSize, int mmapFd, int dictBufAdjust,
int typedLetterMultiplier, int fullWordMultiplier, int typedLetterMultiplier, int fullWordMultiplier,
int maxWordLength, int maxWords, int maxAlternatives) int maxWordLength, int maxWords, int maxAlternatives)
@ -53,8 +54,7 @@ bool Dictionary::hasBigram() {
} }
// TODO: use uint16_t instead of unsigned short // TODO: use uint16_t instead of unsigned short
bool Dictionary::isValidWord(unsigned short *word, int length) bool Dictionary::isValidWord(unsigned short *word, int length) {
{
if (IS_LATEST_DICT_VERSION) { if (IS_LATEST_DICT_VERSION) {
return (isValidWordRec(DICTIONARY_HEADER_SIZE, word, 0, length) != NOT_VALID_WORD); return (isValidWordRec(DICTIONARY_HEADER_SIZE, word, 0, length) != NOT_VALID_WORD);
} else { } else {

View file

@ -19,6 +19,7 @@
#include "bigram_dictionary.h" #include "bigram_dictionary.h"
#include "defines.h" #include "defines.h"
#include "proximity_info.h"
#include "unigram_dictionary.h" #include "unigram_dictionary.h"
namespace latinime { namespace latinime {
@ -27,8 +28,10 @@ class Dictionary {
public: public:
Dictionary(void *dict, int dictSize, int mmapFd, int dictBufAdjust, int typedLetterMultipler, Dictionary(void *dict, int dictSize, int mmapFd, int dictBufAdjust, int typedLetterMultipler,
int fullWordMultiplier, int maxWordLength, int maxWords, int maxAlternatives); int fullWordMultiplier, int maxWordLength, int maxWords, int maxAlternatives);
int getSuggestions(int *codes, int codesSize, unsigned short *outWords, int *frequencies) { int getSuggestions(ProximityInfo *proximityInfo, int *xcoordinates, int *ycoordinates,
return mUnigramDictionary->getSuggestions(codes, codesSize, outWords, frequencies); int *codes, int codesSize, unsigned short *outWords, int *frequencies) {
return mUnigramDictionary->getSuggestions(proximityInfo, xcoordinates, ycoordinates, codes,
codesSize, outWords, frequencies);
} }
// TODO: Call mBigramDictionary instead of mUnigramDictionary // TODO: Call mBigramDictionary instead of mUnigramDictionary
@ -38,6 +41,7 @@ public:
return mBigramDictionary->getBigrams(word, length, codes, codesSize, outWords, frequencies, return mBigramDictionary->getBigrams(word, length, codes, codesSize, outWords, frequencies,
maxWordLength, maxBigrams, maxAlternatives); maxWordLength, maxBigrams, maxAlternatives);
} }
bool isValidWord(unsigned short *word, int length); bool isValidWord(unsigned short *word, int length);
int isValidWordRec(int pos, unsigned short *word, int offset, int length); int isValidWordRec(int pos, unsigned short *word, int offset, int length);
void *getDict() { return (void *)mDict; } void *getDict() { return (void *)mDict; }

View file

@ -0,0 +1,34 @@
/*
* Copyright (C) 2011 The Android Open Source Project
*
* 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.
*/
#include <stdio.h>
#include <string.h>
#include "proximity_info.h"
namespace latinime {
ProximityInfo::ProximityInfo(int maxProximityCharsSize, int displayWidth, int displayHeight,
int gridWidth, int gridHeight, uint32_t const *proximityCharsArray)
: MAX_PROXIMITY_CHARS_SIZE(maxProximityCharsSize), DISPLAY_WIDTH(displayWidth),
DISPLAY_HEIGHT(displayHeight), GRID_WIDTH(gridWidth), GRID_HEIGHT(gridHeight) {
mProximityCharsArray = new uint32_t[GRID_WIDTH * GRID_HEIGHT * MAX_PROXIMITY_CHARS_SIZE];
memcpy(mProximityCharsArray, proximityCharsArray, sizeof(mProximityCharsArray));
}
ProximityInfo::~ProximityInfo() {
delete[] mProximityCharsArray;
}
}

View file

@ -0,0 +1,40 @@
/*
* Copyright (C) 2011 The Android Open Source Project
*
* 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.
*/
#ifndef LATINIME_PROXIMITY_INFO_H
#define LATINIME_PROXIMITY_INFO_H
#include <stdint.h>
#include "defines.h"
namespace latinime {
class ProximityInfo {
public:
ProximityInfo(int maxProximityCharsSize, int displayWidth, int displayHeight, int gridWidth,
int gridHeight, uint32_t const *proximityCharsArray);
~ProximityInfo();
private:
const int MAX_PROXIMITY_CHARS_SIZE;
const int DISPLAY_WIDTH;
const int DISPLAY_HEIGHT;
const int GRID_WIDTH;
const int GRID_HEIGHT;
uint32_t *mProximityCharsArray;
};
}; // namespace latinime
#endif // LATINIME_PROXIMITY_INFO_H

View file

@ -41,13 +41,19 @@ UnigramDictionary::UnigramDictionary(const unsigned char *dict, int typedLetterM
UnigramDictionary::~UnigramDictionary() {} UnigramDictionary::~UnigramDictionary() {}
int UnigramDictionary::getSuggestions(int *codes, int codesSize, unsigned short *outWords, int UnigramDictionary::getSuggestions(ProximityInfo *proximityInfo, int *xcoordinates,
int *frequencies) { int *ycoordinates, int *codes, int codesSize, unsigned short *outWords, int *frequencies) {
PROF_OPEN; PROF_OPEN;
PROF_START(0); PROF_START(0);
initSuggestions(codes, codesSize, outWords, frequencies); initSuggestions(codes, codesSize, outWords, frequencies);
if (DEBUG_DICT) assert(codesSize == mInputLength); if (DEBUG_DICT) assert(codesSize == mInputLength);
if (DEBUG_PROXIMITY_INFO) {
for (int i = 0; i < codesSize; ++i) {
LOGI("Input[%d] x = %d, y = %d", i, xcoordinates[i], ycoordinates[i]);
}
}
const int MAX_DEPTH = min(mInputLength * MAX_DEPTH_MULTIPLIER, MAX_WORD_LENGTH); const int MAX_DEPTH = min(mInputLength * MAX_DEPTH_MULTIPLIER, MAX_WORD_LENGTH);
PROF_END(0); PROF_END(0);
@ -406,7 +412,7 @@ inline void UnigramDictionary::onTerminalWhenUserTypedLengthIsSameAsInputLength(
inline bool UnigramDictionary::needsToSkipCurrentNode(const unsigned short c, inline bool UnigramDictionary::needsToSkipCurrentNode(const unsigned short c,
const int inputIndex, const int skipPos, const int depth) { const int inputIndex, const int skipPos, const int depth) {
const unsigned short userTypedChar = (mInputCodes + (inputIndex * MAX_PROXIMITY_CHARS))[0]; const unsigned short userTypedChar = getInputCharsAt(inputIndex)[0];
// Skip the ' or other letter and continue deeper // Skip the ' or other letter and continue deeper
return (c == QUOTE && userTypedChar != QUOTE) || skipPos == depth; return (c == QUOTE && userTypedChar != QUOTE) || skipPos == depth;
} }
@ -517,7 +523,7 @@ inline bool UnigramDictionary::processCurrentNode(const int pos, const int depth
*newDiffs = diffs; *newDiffs = diffs;
*newInputIndex = inputIndex; *newInputIndex = inputIndex;
} else { } else {
int *currentChars = mInputCodes + (inputIndex * MAX_PROXIMITY_CHARS); int *currentChars = getInputCharsAt(inputIndex);
if (transposedPos >= 0) { if (transposedPos >= 0) {
if (inputIndex == transposedPos) currentChars += MAX_PROXIMITY_CHARS; if (inputIndex == transposedPos) currentChars += MAX_PROXIMITY_CHARS;
@ -620,7 +626,7 @@ inline bool UnigramDictionary::processCurrentNodeForExactMatch(const int firstCh
const int startInputIndex, const int depth, unsigned short *word, int *newChildPosition, const int startInputIndex, const int depth, unsigned short *word, int *newChildPosition,
int *newCount, bool *newTerminal, int *newFreq, int *siblingPos) { int *newCount, bool *newTerminal, int *newFreq, int *siblingPos) {
const int inputIndex = startInputIndex + depth; const int inputIndex = startInputIndex + depth;
const int *currentChars = mInputCodes + (inputIndex * MAX_PROXIMITY_CHARS); const int *currentChars = getInputCharsAt(inputIndex);
unsigned short c; unsigned short c;
*siblingPos = Dictionary::setDictionaryValues(DICT, IS_LATEST_DICT_VERSION, firstChildPos, &c, *siblingPos = Dictionary::setDictionaryValues(DICT, IS_LATEST_DICT_VERSION, firstChildPos, &c,
newChildPosition, newTerminal, newFreq); newChildPosition, newTerminal, newFreq);

View file

@ -18,6 +18,7 @@
#define LATINIME_UNIGRAM_DICTIONARY_H #define LATINIME_UNIGRAM_DICTIONARY_H
#include "defines.h" #include "defines.h"
#include "proximity_info.h"
namespace latinime { namespace latinime {
@ -32,7 +33,8 @@ class UnigramDictionary {
public: public:
UnigramDictionary(const unsigned char *dict, int typedLetterMultipler, int fullWordMultiplier, UnigramDictionary(const unsigned char *dict, int typedLetterMultipler, int fullWordMultiplier,
int maxWordLength, int maxWords, int maxProximityChars, const bool isLatestDictVersion); int maxWordLength, int maxWords, int maxProximityChars, const bool isLatestDictVersion);
int getSuggestions(int *codes, int codesSize, unsigned short *outWords, int *frequencies); int getSuggestions(ProximityInfo *proximityInfo, int *xcoordinates, int *ycoordinates,
int *codes, int codesSize, unsigned short *outWords, int *frequencies);
~UnigramDictionary(); ~UnigramDictionary();
private: private:
@ -84,7 +86,9 @@ private:
const int startInputIndex, const int depth, unsigned short *word, const int startInputIndex, const int depth, unsigned short *word,
int *newChildPosition, int *newCount, bool *newTerminal, int *newFreq, int *siblingPos); int *newChildPosition, int *newCount, bool *newTerminal, int *newFreq, int *siblingPos);
bool existsAdjacentProximityChars(const int inputIndex, const int inputLength); bool existsAdjacentProximityChars(const int inputIndex, const int inputLength);
int* getInputCharsAt(const int index) {return mInputCodes + (index * MAX_PROXIMITY_CHARS);} inline int* getInputCharsAt(const int index) {
return mInputCodes + (index * MAX_PROXIMITY_CHARS);
}
const unsigned char *DICT; const unsigned char *DICT;
const int MAX_WORD_LENGTH; const int MAX_WORD_LENGTH;
const int MAX_WORDS; const int MAX_WORDS;

View file

@ -64,7 +64,7 @@ public class SuggestHelper {
return mSuggest.hasMainDictionary(); return mSuggest.hasMainDictionary();
} }
private int[] getProximityCodes(char c) { private void addKeyInfo(WordComposer word, char c) {
final List<Key> keys = mKeyboard.getKeys(); final List<Key> keys = mKeyboard.getKeys();
for (final Key key : keys) { for (final Key key : keys) {
if (key.mCode == c) { if (key.mCode == c) {
@ -72,17 +72,17 @@ public class SuggestHelper {
final int y = key.mY + key.mHeight / 2; final int y = key.mY + key.mHeight / 2;
final int[] codes = mKeyDetector.newCodeArray(); final int[] codes = mKeyDetector.newCodeArray();
mKeyDetector.getKeyIndexAndNearbyCodes(x, y, codes); mKeyDetector.getKeyIndexAndNearbyCodes(x, y, codes);
return codes; word.add(c, codes, x, y);
} }
} }
return new int[] { c }; word.add(c, new int[] { c }, WordComposer.NOT_A_COORDINATE, WordComposer.NOT_A_COORDINATE);
} }
protected WordComposer createWordComposer(CharSequence s) { protected WordComposer createWordComposer(CharSequence s) {
WordComposer word = new WordComposer(); WordComposer word = new WordComposer();
for (int i = 0; i < s.length(); i++) { for (int i = 0; i < s.length(); i++) {
final char c = s.charAt(i); final char c = s.charAt(i);
word.add(c, getProximityCodes(c)); addKeyInfo(word, c);
} }
return word; return word;
} }