From 0e1f656c1be7f2916cf57c94d99b001795856270 Mon Sep 17 00:00:00 2001 From: Yusuke Nojima Date: Wed, 21 Sep 2011 12:02:47 +0900 Subject: [PATCH] Extend JNI interface to pass the key coordinate information Change-Id: Iec0d1415d6abba43b775a014516b961b167597b7 --- .../inputmethod/keyboard/ProximityInfo.java | 24 +++++++- ...oid_inputmethod_keyboard_ProximityInfo.cpp | 20 +++++- .../src/defines_touch_position_correction.h | 61 +++++++++++++++++++ native/src/proximity_info.cpp | 51 +++++++++++++++- native/src/proximity_info.h | 19 +++++- 5 files changed, 166 insertions(+), 9 deletions(-) create mode 100644 native/src/defines_touch_position_correction.h diff --git a/java/src/com/android/inputmethod/keyboard/ProximityInfo.java b/java/src/com/android/inputmethod/keyboard/ProximityInfo.java index a82bcbed0..0e2d28024 100644 --- a/java/src/com/android/inputmethod/keyboard/ProximityInfo.java +++ b/java/src/com/android/inputmethod/keyboard/ProximityInfo.java @@ -65,7 +65,8 @@ public class ProximityInfo { spellCheckerProximityInfo.mNativeProximityInfo = spellCheckerProximityInfo.setProximityInfoNative( SpellCheckerProximityInfo.ROW_SIZE, - 480, 300, 10, 3, SpellCheckerProximityInfo.PROXIMITY); + 480, 300, 10, 3, SpellCheckerProximityInfo.PROXIMITY, + 0, null, null, null, null, null); return spellCheckerProximityInfo; } @@ -74,7 +75,9 @@ public class ProximityInfo { Utils.loadNativeLibrary(); } private native int setProximityInfoNative(int maxProximityCharsSize, int displayWidth, - int displayHeight, int gridWidth, int gridHeight, int[] proximityCharsArray); + int displayHeight, int gridWidth, int gridHeight, int[] proximityCharsArray, + int keyCount, int[] keyXCoordinates, int[] keyYCoordinates, + int[] keyWidths, int[] keyHeights, int[] keyCharCodes); private native void releaseProximityInfoNative(int nativeProximityInfo); private final void setProximityInfo(int[][] gridNeighborKeyIndexes, int keyboardWidth, @@ -88,8 +91,23 @@ public class ProximityInfo { keys.get(gridNeighborKeyIndexes[i][j]).mCode; } } + final int keyCount = keys.size(); + int[] keyXCoordinates = new int[keyCount]; + int[] keyYCoordinates = new int[keyCount]; + int[] keyWidths = new int[keyCount]; + int[] keyHeights = new int[keyCount]; + int[] keyCharCodes = new int[keyCount]; + for (int i = 0; i < keyCount; ++i) { + final Key key = keys.get(i); + keyXCoordinates[i] = key.mX; + keyYCoordinates[i] = key.mY; + keyWidths[i] = key.mWidth; + keyHeights[i] = key.mHeight; + keyCharCodes[i] = key.mCode; + } mNativeProximityInfo = setProximityInfoNative(MAX_PROXIMITY_CHARS_SIZE, - keyboardWidth, keyboardHeight, mGridWidth, mGridHeight, proximityCharsArray); + keyboardWidth, keyboardHeight, mGridWidth, mGridHeight, proximityCharsArray, + keyCount, keyXCoordinates, keyYCoordinates, keyWidths, keyHeights, keyCharCodes); } public int getNativeProximityInfo() { diff --git a/native/jni/com_android_inputmethod_keyboard_ProximityInfo.cpp b/native/jni/com_android_inputmethod_keyboard_ProximityInfo.cpp index f3e2a7e60..d4fa436cc 100644 --- a/native/jni/com_android_inputmethod_keyboard_ProximityInfo.cpp +++ b/native/jni/com_android_inputmethod_keyboard_ProximityInfo.cpp @@ -30,10 +30,24 @@ namespace latinime { static jint latinime_Keyboard_setProximityInfo(JNIEnv *env, jobject object, jint maxProximityCharsSize, jint displayWidth, jint displayHeight, jint gridWidth, - jint gridHeight, jintArray proximityCharsArray) { + jint gridHeight, jintArray proximityCharsArray, jint keyCount, + jintArray keyXCoordinateArray, jintArray keyYCoordinateArray, jintArray keyWidthArray, + jintArray keyHeightArray, jintArray keyCharCodeArray) { jint* proximityChars = env->GetIntArrayElements(proximityCharsArray, NULL); + jint* keyXCoordinates = env->GetIntArrayElements(keyXCoordinateArray, NULL); + jint* keyYCoordinates = env->GetIntArrayElements(keyYCoordinateArray, NULL); + jint* keyWidths = env->GetIntArrayElements(keyWidthArray, NULL); + jint* keyHeights = env->GetIntArrayElements(keyHeightArray, NULL); + jint* keyCharCodes = env->GetIntArrayElements(keyCharCodeArray, NULL); ProximityInfo *proximityInfo = new ProximityInfo(maxProximityCharsSize, displayWidth, - displayHeight, gridWidth, gridHeight, (const uint32_t *)proximityChars); + displayHeight, gridWidth, gridHeight, (const uint32_t *)proximityChars, + keyCount, (const int32_t *)keyXCoordinates, (const int32_t *)keyYCoordinates, + (const int32_t *)keyWidths, (const int32_t *)keyHeights, (const int32_t *)keyCharCodes); + env->ReleaseIntArrayElements(keyCharCodeArray, keyCharCodes, 0); + env->ReleaseIntArrayElements(keyHeightArray, keyHeights, 0); + env->ReleaseIntArrayElements(keyWidthArray, keyWidths, 0); + env->ReleaseIntArrayElements(keyYCoordinateArray, keyYCoordinates, 0); + env->ReleaseIntArrayElements(keyXCoordinateArray, keyXCoordinates, 0); env->ReleaseIntArrayElements(proximityCharsArray, proximityChars, 0); return (jint)proximityInfo; } @@ -45,7 +59,7 @@ static void latinime_Keyboard_release(JNIEnv *env, jobject object, jint proximit } static JNINativeMethod sKeyboardMethods[] = { - {"setProximityInfoNative", "(IIIII[I)I", (void*)latinime_Keyboard_setProximityInfo}, + {"setProximityInfoNative", "(IIIII[II[I[I[I[I[I)I", (void*)latinime_Keyboard_setProximityInfo}, {"releaseProximityInfoNative", "(I)V", (void*)latinime_Keyboard_release} }; diff --git a/native/src/defines_touch_position_correction.h b/native/src/defines_touch_position_correction.h new file mode 100644 index 000000000..122906804 --- /dev/null +++ b/native/src/defines_touch_position_correction.h @@ -0,0 +1,61 @@ +/* +** +** 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 LATINIME_DEFINES_TOUCH_POSITION_CORRECTION_H +#define LATINIME_DEFINES_TOUCH_POSITION_CORRECTION_H + +#define OUTER_SWEET_SPOT_RADIUS_RATIO 1.3 + +static const char* TOUCH_POSITION_CORRECTION_GROUPS[] = { + "qwertyuiop", + "a", + "sdfghjk", + "l", + "zxcvbnm", +}; + +// (center X) / (key width) +static const float RELATIVE_TOUCH_CENTER_X[] = { + 0, // qwertyuiop + -0.26871, // a + 0, // sdfghjk + 0.028050, // l + 0, // zxcvbnm +}; + +// (center Y) / (key height) +static const float RELATIVE_TOUCH_CENTER_Y[] = { + 0.192088, // qwertyuiop + 0.214100, // a + 0.216640, // sdfghjk + 0.233288, // l + 0.286598, // zxcvbnm +}; + +// (sweet spot radius) / ((key width) + (key height)) +static const float SWEET_SPOT_RADIUS[] = { + 0.148955, // qwertyuiop + 0.185437, // a + 0.145522, // sdfghjk + 0.156882, // l + 0.144211, // zxcvbnm +}; + +#define CORRECTION_GROUP_COUNT \ + ((int)(sizeof(TOUCH_POSITION_CORRECTION_GROUPS) / sizeof(TOUCH_POSITION_CORRECTION_GROUPS[0]))) + +#endif // LATINIME_DEFINES_TOUCH_POSITION_CORRECTION_H diff --git a/native/src/proximity_info.cpp b/native/src/proximity_info.cpp index 361bdacbf..94cccc382 100644 --- a/native/src/proximity_info.cpp +++ b/native/src/proximity_info.cpp @@ -14,11 +14,13 @@ * limitations under the License. */ +#include #include #include #define LOG_TAG "LatinIME: proximity_info.cpp" +#include "defines_touch_position_correction.h" #include "dictionary.h" #include "proximity_info.h" @@ -26,17 +28,59 @@ namespace latinime { ProximityInfo::ProximityInfo(const int maxProximityCharsSize, const int keyboardWidth, const int keyboardHeight, const int gridWidth, const int gridHeight, - const uint32_t *proximityCharsArray) + const uint32_t *proximityCharsArray, const int keyCount, const int32_t *keyXCoordinates, + const int32_t *keyYCoordinates, const int32_t *keyWidths, const int32_t *keyHeights, + const int32_t *keyCharCodes) : MAX_PROXIMITY_CHARS_SIZE(maxProximityCharsSize), KEYBOARD_WIDTH(keyboardWidth), KEYBOARD_HEIGHT(keyboardHeight), GRID_WIDTH(gridWidth), GRID_HEIGHT(gridHeight), CELL_WIDTH((keyboardWidth + gridWidth - 1) / gridWidth), - CELL_HEIGHT((keyboardHeight + gridHeight - 1) / gridHeight) { + CELL_HEIGHT((keyboardHeight + gridHeight - 1) / gridHeight), + KEY_COUNT(min(keyCount, MAX_KEY_COUNT_IN_A_KEYBOARD)) { const int len = GRID_WIDTH * GRID_HEIGHT * MAX_PROXIMITY_CHARS_SIZE; mProximityCharsArray = new uint32_t[len]; if (DEBUG_PROXIMITY_INFO) { LOGI("Create proximity info array %d", len); } memcpy(mProximityCharsArray, proximityCharsArray, len * sizeof(mProximityCharsArray[0])); + + if (KEY_COUNT > 0) { + if (DEBUG_PROXIMITY_INFO) { + LOGI("Create key coordinate array %d", keyCount); + } + memcpy(mKeyXCoordinates, keyXCoordinates, KEY_COUNT * sizeof(mKeyXCoordinates[0])); + memcpy(mKeyYCoordinates, keyYCoordinates, KEY_COUNT * sizeof(mKeyYCoordinates[0])); + memcpy(mKeyWidths, keyWidths, KEY_COUNT * sizeof(mKeyWidths[0])); + memcpy(mKeyHeights, keyHeights, KEY_COUNT * sizeof(mKeyHeights[0])); + memcpy(mKeyCharCodes, keyCharCodes, KEY_COUNT * sizeof(mKeyCharCodes[0])); + } + + initializeCodeToGroup(); + initializeCodeToKeyIndex(); +} + +// Build the reversed look up table from the char code to the index in its group. +// see TOUCH_POSITION_CORRECTION_GROUPS +void ProximityInfo::initializeCodeToGroup() { + memset(mCodeToGroup, -1, (MAX_GROUPED_CHAR_CODE + 1) * sizeof(mCodeToGroup[0])); + for (int i = 0; i < CORRECTION_GROUP_COUNT; ++i) { + const char *group = TOUCH_POSITION_CORRECTION_GROUPS[i]; + for (int j = 0; group[j]; ++j) { + const int code = group[j]; + if (0 <= code && code <= MAX_GROUPED_CHAR_CODE) + mCodeToGroup[code] = i; + } + } +} + +// Build the reversed look up table from the char code to the index in mKeyXCoordinates, +// mKeyYCoordinates, mKeyWidths, mKeyHeights, mKeyCharCodes. +void ProximityInfo::initializeCodeToKeyIndex() { + memset(mCodeToKeyIndex, -1, (MAX_GROUPED_CHAR_CODE + 1) * sizeof(mCodeToKeyIndex[0])); + for (int i = 0; i < KEY_COUNT; ++i) { + const int code = mKeyCharCodes[i]; + if (0 <= code && code <= MAX_GROUPED_CHAR_CODE) + mCodeToKeyIndex[code] = i; + } } ProximityInfo::~ProximityInfo() { @@ -162,4 +206,7 @@ bool ProximityInfo::sameAsTyped(const unsigned short *word, int length) const { return true; } +const int ProximityInfo::MAX_KEY_COUNT_IN_A_KEYBOARD; +const int ProximityInfo::MAX_GROUPED_CHAR_CODE; + } // namespace latinime diff --git a/native/src/proximity_info.h b/native/src/proximity_info.h index 75fc8fb63..834997fb9 100644 --- a/native/src/proximity_info.h +++ b/native/src/proximity_info.h @@ -35,7 +35,9 @@ public: ProximityInfo(const int maxProximityCharsSize, const int keyboardWidth, const int keybaordHeight, const int gridWidth, const int gridHeight, - const uint32_t *proximityCharsArray); + const uint32_t *proximityCharsArray, const int keyCount, const int32_t *keyXCoordinates, + const int32_t *keyYCoordinates, const int32_t *keyWidths, const int32_t *keyHeights, + const int32_t *keyCharCodes); ~ProximityInfo(); bool hasSpaceProximity(const int x, const int y) const; void setInputParams(const int* inputCodes, const int inputLength); @@ -51,7 +53,14 @@ public: } private: + // The max number of the keys in one keyboard layout + static const int MAX_KEY_COUNT_IN_A_KEYBOARD = 64; + // The upper limit of the char code in TOUCH_POSITION_CORRECTION_GROUP + static const int MAX_GROUPED_CHAR_CODE = 127; + int getStartIndexFromCoordinates(const int x, const int y) const; + void initializeCodeToGroup(); + void initializeCodeToKeyIndex(); const int MAX_PROXIMITY_CHARS_SIZE; const int KEYBOARD_WIDTH; const int KEYBOARD_HEIGHT; @@ -59,10 +68,18 @@ private: const int GRID_HEIGHT; const int CELL_WIDTH; const int CELL_HEIGHT; + const int KEY_COUNT; const int *mInputCodes; uint32_t *mProximityCharsArray; + int32_t mKeyXCoordinates[MAX_KEY_COUNT_IN_A_KEYBOARD]; + int32_t mKeyYCoordinates[MAX_KEY_COUNT_IN_A_KEYBOARD]; + int32_t mKeyWidths[MAX_KEY_COUNT_IN_A_KEYBOARD]; + int32_t mKeyHeights[MAX_KEY_COUNT_IN_A_KEYBOARD]; + int32_t mKeyCharCodes[MAX_KEY_COUNT_IN_A_KEYBOARD]; int mInputLength; unsigned short mPrimaryInputWord[MAX_WORD_LENGTH_INTERNAL]; + int mCodeToGroup[MAX_GROUPED_CHAR_CODE + 1]; + int mCodeToKeyIndex[MAX_GROUPED_CHAR_CODE + 1]; }; } // namespace latinime