nyancrimew/LatinIME
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Cleanup proximity related code

Browse source 
Bug: 4343280
Change-Id: I57c0f9e20d9d8911009ea97057251a7f7a81512f
This commit is contained in:
satok 2012-03-19 14:47:38 +09:00
parent f9c2773b09
commit 728d1c884e
12 changed files with 13 additions and 372 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

62
java/res/values-en/additional-proximitychars.xml
View file

@ -1,62 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<!--
/*
**
** Copyright 2012, 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.
*/
-->
<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
<string-array name="additional_proximitychars">
<!-- Empty entry terminates the proximity chars array. -->
<!-- Additional proximity chars for a -->
<item>a</item>
<item>e</item>
<item>i</item>
<item>o</item>
<item>u</item>
<item></item>
<!-- Additional proximity chars for e -->
<item>e</item>
<item>a</item>
<item>i</item>
<item>o</item>
<item>u</item>
<item></item>
<!-- Additional proximity chars for i -->
<item>i</item>
<item>a</item>
<item>e</item>
<item>o</item>
<item>u</item>
<item></item>
<!-- Additional proximity chars for o -->
<item>o</item>
<item>a</item>
<item>e</item>
<item>i</item>
<item>u</item>
<item></item>
<!-- Additional proximity chars for u -->
<item>u</item>
<item>a</item>
<item>e</item>
<item>i</item>
<item>o</item>
<item></item>
</string-array>
</resources>

23
java/res/values/additional-proximitychars.xml
View file

@ -1,23 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<!--
/*
**
** Copyright 2012, 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.
*/
-->
<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
<string-array name="additional_proximitychars">
</string-array>
</resources>

185
java/src/com/android/inputmethod/keyboard/KeyDetector.java
View file

@ -16,17 +16,9 @@
package com.android.inputmethod.keyboard;
import android.util.Log;
import java.util.Arrays;
import java.util.List;
public class KeyDetector {
private static final String TAG = KeyDetector.class.getSimpleName();
private static final boolean DEBUG = false;
public static final int NOT_A_CODE = -1;
private static final int ADDITIONAL_PROXIMITY_CHAR_DELIMITER_CODE = 2;
private final int mKeyHysteresisDistanceSquared;
@ -34,12 +26,6 @@ public class KeyDetector {
private int mCorrectionX;
private int mCorrectionY;
private boolean mProximityCorrectOn;
private int mProximityThresholdSquare;
// working area
private static final int MAX_NEARBY_KEYS = 12;
private final int[] mDistances = new int[MAX_NEARBY_KEYS];
private final Key[] mNeighborKeys = new Key[MAX_NEARBY_KEYS];
/**
* This class handles key detection.
@ -57,8 +43,6 @@ public class KeyDetector {
mCorrectionX = (int)correctionX;
mCorrectionY = (int)correctionY;
mKeyboard = keyboard;
final int threshold = keyboard.mMostCommonKeyWidth;
mProximityThresholdSquare = threshold * threshold;
}
public int getKeyHysteresisDistanceSquared() {
@ -87,168 +71,10 @@ public class KeyDetector {
return mProximityCorrectOn;
}
public void setProximityThreshold(int threshold) {
mProximityThresholdSquare = threshold * threshold;
}
public boolean alwaysAllowsSlidingInput() {
return false;
}
/**
* Computes maximum size of the array that can contain all nearby key codes returned by
* {@link #getNearbyCodes}.
*
* @return Returns maximum size of the array that can contain all nearby key codes returned
* by {@link #getNearbyCodes}.
*/
protected int getMaxNearbyKeys() {
return MAX_NEARBY_KEYS;
}
/**
* Allocates array that can hold all key codes returned by {@link #getNearbyCodes}
* method. The maximum size of the array should be computed by {@link #getMaxNearbyKeys}.
*
* @return Allocates and returns an array that can hold all key codes returned by
* {@link #getNearbyCodes} method. All elements in the returned array are
* initialized by {@link #NOT_A_CODE} value.
*/
public int[] newCodeArray() {
int[] codes = new int[getMaxNearbyKeys()];
Arrays.fill(codes, NOT_A_CODE);
return codes;
}
private void initializeNearbyKeys() {
Arrays.fill(mDistances, Integer.MAX_VALUE);
Arrays.fill(mNeighborKeys, null);
}
/**
* Insert the key into nearby keys buffer and sort nearby keys by ascending order of distance.
* If the distance of two keys are the same, the key which the point is on should be considered
* as a closer one.
*
* @param key the key to be inserted into the nearby keys buffer.
* @param distance distance between the key's edge and user touched point.
* @param isOnKey true if the point is on the key.
* @return order of the key in the nearby buffer, 0 if it is the nearest key.
*/
private int sortNearbyKeys(Key key, int distance, boolean isOnKey) {
final int[] distances = mDistances;
final Key[] neighborKeys = mNeighborKeys;
for (int insertPos = 0; insertPos < distances.length; insertPos++) {
final int comparingDistance = distances[insertPos];
if (distance < comparingDistance || (distance == comparingDistance && isOnKey)) {
final int nextPos = insertPos + 1;
if (nextPos < distances.length) {
System.arraycopy(distances, insertPos, distances, nextPos,
distances.length - nextPos);
System.arraycopy(neighborKeys, insertPos, neighborKeys, nextPos,
neighborKeys.length - nextPos);
}
distances[insertPos] = distance;
neighborKeys[insertPos] = key;
return insertPos;
}
}
return distances.length;
}
private void getNearbyKeyCodes(final int primaryCode, final int[] allCodes) {
final Key[] neighborKeys = mNeighborKeys;
final int maxCodesSize = allCodes.length;
// allCodes[0] should always have the key code even if it is a non-letter key.
if (neighborKeys[0] == null) {
allCodes[0] = NOT_A_CODE;
return;
}
int numCodes = 0;
for (int j = 0; j < neighborKeys.length && numCodes < maxCodesSize; j++) {
final Key key = neighborKeys[j];
if (key == null)
break;
final int code = key.mCode;
// filter out a non-letter key from nearby keys
if (code < Keyboard.CODE_SPACE)
continue;
allCodes[numCodes++] = code;
}
if (maxCodesSize <= numCodes) {
return;
}
final int code = (primaryCode == NOT_A_CODE) ? allCodes[0] : primaryCode;
if (code == NOT_A_CODE) {
return;
}
final List<Integer> additionalChars = mKeyboard.getAdditionalProximityChars().get(code);
if (additionalChars == null || additionalChars.size() == 0) {
return;
}
int currentCodesSize = numCodes;
allCodes[numCodes++] = ADDITIONAL_PROXIMITY_CHAR_DELIMITER_CODE;
if (maxCodesSize <= numCodes) {
return;
}
// TODO: This is O(N^2). Assuming additionalChars.size() is up to 4 or 5.
for (int i = 0; i < additionalChars.size(); ++i) {
final int additionalChar = additionalChars.get(i);
boolean contains = false;
for (int j = 0; j < currentCodesSize; ++j) {
if (additionalChar == allCodes[j]) {
contains = true;
break;
}
}
if (!contains) {
allCodes[numCodes++] = additionalChar;
if (maxCodesSize <= numCodes) {
return;
}
}
}
}
/**
* Finds all possible nearby key codes around a touch event point and returns the nearest key.
* The algorithm to determine the nearby keys depends on the threshold set by
* {@link #setProximityThreshold(int)} and the mode set by
* {@link #setProximityCorrectionEnabled(boolean)}.
*
* @param x The x-coordinate of a touch point
* @param y The y-coordinate of a touch point
* @param allCodes All nearby key codes except functional key are returned in this array
*/
// TODO: Move this method to native code.
public void getNearbyCodes(int x, int y, final int[] allCodes) {
final int touchX = getTouchX(x);
final int touchY = getTouchY(y);
initializeNearbyKeys();
Key primaryKey = null;
for (final Key key : mKeyboard.getNearestKeys(touchX, touchY)) {
final boolean isOnKey = key.isOnKey(touchX, touchY);
final int distance = key.squaredDistanceToEdge(touchX, touchY);
if (isOnKey || (mProximityCorrectOn && distance < mProximityThresholdSquare)) {
final int insertedPosition = sortNearbyKeys(key, distance, isOnKey);
if (insertedPosition == 0 && isOnKey) {
primaryKey = key;
}
}
}
getNearbyKeyCodes(primaryKey != null ? primaryKey.mCode : NOT_A_CODE, allCodes);
if (DEBUG) {
Log.d(TAG, "x=" + x + " y=" + y
+ " primary=" + printableCode(primaryKey)
+ " codes=" + printableCodes(allCodes));
}
}
/**
* Detect the key whose hitbox the touch point is in.
*
@ -284,14 +110,9 @@ public class KeyDetector {
boolean addDelimiter = false;
for (final int code : codes) {
if (code == NOT_A_CODE) break;
if (code == ADDITIONAL_PROXIMITY_CHAR_DELIMITER_CODE) {
sb.append(" | ");
addDelimiter = false;
} else {
if (addDelimiter) sb.append(", ");
sb.append(Keyboard.printableCode(code));
addDelimiter = true;
}
if (addDelimiter) sb.append(", ");
sb.append(Keyboard.printableCode(code));
addDelimiter = true;
}
return "[" + sb + "]";
}

36
java/src/com/android/inputmethod/keyboard/Keyboard.java
View file

@ -20,7 +20,6 @@ import android.content.Context;
import android.content.res.Resources;
import android.content.res.TypedArray;
import android.content.res.XmlResourceParser;
import android.text.TextUtils;
import android.util.AttributeSet;
import android.util.DisplayMetrics;
import android.util.Log;
@ -42,8 +41,6 @@ import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
/**
* Loads an XML description of a keyboard and stores the attributes of the keys. A keyboard
@ -133,8 +130,6 @@ public class Keyboard {
private final ProximityInfo mProximityInfo;
private final Map<Integer, List<Integer>> mAdditionalProximityChars;
public Keyboard(Params params) {
mId = params.mId;
mThemeId = params.mThemeId;
@ -153,12 +148,10 @@ public class Keyboard {
mAltCodeKeysWhileTyping = params.mAltCodeKeysWhileTyping.toArray(
new Key[params.mAltCodeKeysWhileTyping.size()]);
mIconsSet = params.mIconsSet;
mAdditionalProximityChars = params.mAdditionalProximityChars;
mProximityInfo = new ProximityInfo(params.mId.mLocale.toString(),
params.GRID_WIDTH, params.GRID_HEIGHT, mOccupiedWidth, mOccupiedHeight,
mMostCommonKeyWidth, mMostCommonKeyHeight, mKeys, params.mTouchPositionCorrection,
params.mAdditionalProximityChars);
mMostCommonKeyWidth, mMostCommonKeyHeight, mKeys, params.mTouchPositionCorrection);
}
public ProximityInfo getProximityInfo() {
@ -230,9 +223,6 @@ public class Keyboard {
public final ArrayList<Key> mShiftKeys = new ArrayList<Key>();
public final ArrayList<Key> mAltCodeKeysWhileTyping = new ArrayList<Key>();
public final KeyboardIconsSet mIconsSet = new KeyboardIconsSet();
// TODO: Should be in Key instead of Keyboard.Params?
public final Map<Integer, List<Integer>> mAdditionalProximityChars =
new HashMap<Integer, List<Integer>>();
public KeyboardSet.KeysCache mKeysCache;
@ -368,10 +358,6 @@ public class Keyboard {
return mProximityInfo.getNearestKeys(adjustedX, adjustedY);
}
public Map<Integer, List<Integer>> getAdditionalProximityChars() {
return mAdditionalProximityChars;
}
public static String printableCode(int code) {
switch (code) {
case CODE_SHIFT: return "shift";
@ -630,7 +616,6 @@ public class Keyboard {
mParams = params;
setTouchPositionCorrectionData(context, params);
setAdditionalProximityChars(context, params);
params.GRID_WIDTH = res.getInteger(R.integer.config_keyboard_grid_width);
params.GRID_HEIGHT = res.getInteger(R.integer.config_keyboard_grid_height);
@ -653,25 +638,6 @@ public class Keyboard {
params.mTouchPositionCorrection.load(data);
}
private static void setAdditionalProximityChars(Context context, Params params) {
final String[] additionalChars =
context.getResources().getStringArray(R.array.additional_proximitychars);
int currentPrimaryIndex = 0;
for (int i = 0; i < additionalChars.length; ++i) {
final String additionalChar = additionalChars[i];
if (TextUtils.isEmpty(additionalChar)) {
currentPrimaryIndex = 0;
} else if (currentPrimaryIndex == 0) {
currentPrimaryIndex = additionalChar.charAt(0);
params.mAdditionalProximityChars.put(
currentPrimaryIndex, new ArrayList<Integer>());
} else if (currentPrimaryIndex != 0) {
final int c = additionalChar.charAt(0);
params.mAdditionalProximityChars.get(currentPrimaryIndex).add(c);
}
}
}
public void setAutoGenerate(KeyboardSet.KeysCache keysCache) {
mParams.mKeysCache = keysCache;
}

1
java/src/com/android/inputmethod/keyboard/LatinKeyboardView.java
View file

@ -480,7 +480,6 @@ public class LatinKeyboardView extends KeyboardView implements PointerTracker.Ke
super.setKeyboard(keyboard);
mKeyDetector.setKeyboard(
keyboard, -getPaddingLeft(), -getPaddingTop() + mVerticalCorrection);
mKeyDetector.setProximityThreshold(keyboard.mMostCommonKeyWidth);
PointerTracker.setKeyDetector(mKeyDetector);
mTouchScreenRegulator.setKeyboard(keyboard);
mMoreKeysPanelCache.clear();

28
java/src/com/android/inputmethod/keyboard/MoreKeysDetector.java
View file

@ -32,34 +32,6 @@ public class MoreKeysDetector extends KeyDetector {
return true;
}
@Override
protected int getMaxNearbyKeys() {
// No nearby key will be returned.
return 1;
}
@Override
public void getNearbyCodes(int x, int y, final int[] allCodes) {
final int touchX = getTouchX(x);
final int touchY = getTouchY(y);
Key nearestKey = null;
int nearestDist = (y < 0) ? mSlideAllowanceSquareTop : mSlideAllowanceSquare;
for (final Key key : getKeyboard().mKeys) {
final int dist = key.squaredDistanceToEdge(touchX, touchY);
if (dist < nearestDist) {
nearestKey = key;
nearestDist = dist;
}
}
if (nearestKey != null) {
allCodes[0] = nearestKey.mCode;
} else {
allCodes[0] = NOT_A_CODE;
}
}
@Override
public Key detectHitKey(int x, int y) {
final int touchX = getTouchX(x);

35
java/src/com/android/inputmethod/keyboard/ProximityInfo.java
View file

@ -24,10 +24,7 @@ import com.android.inputmethod.latin.JniUtils;
import com.android.inputmethod.latin.spellcheck.SpellCheckerProximityInfo;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class ProximityInfo {
public static final int MAX_PROXIMITY_CHARS_SIZE = 16;
@ -50,8 +47,7 @@ public class ProximityInfo {
ProximityInfo(String localeStr, int gridWidth, int gridHeight, int minWidth, int height,
int mostCommonKeyWidth, int mostCommonKeyHeight, final Key[] keys,
TouchPositionCorrection touchPositionCorrection,
Map<Integer, List<Integer>> additionalProximityChars) {
TouchPositionCorrection touchPositionCorrection) {
if (TextUtils.isEmpty(localeStr)) {
mLocaleStr = "";
} else {
@ -72,12 +68,11 @@ public class ProximityInfo {
return;
}
computeNearestNeighbors(
mostCommonKeyWidth, keys, touchPositionCorrection, additionalProximityChars);
mostCommonKeyWidth, keys, touchPositionCorrection);
}
public static ProximityInfo createDummyProximityInfo() {
return new ProximityInfo("", 1, 1, 1, 1, 1, 1, EMPTY_KEY_ARRAY, null,
Collections.<Integer, List<Integer>> emptyMap());
return new ProximityInfo("", 1, 1, 1, 1, 1, 1, EMPTY_KEY_ARRAY, null);
}
public static ProximityInfo createSpellCheckerProximityInfo(final int[] proximity) {
@ -184,8 +179,7 @@ public class ProximityInfo {
}
private void computeNearestNeighbors(int defaultWidth, final Key[] keys,
TouchPositionCorrection touchPositionCorrection,
Map<Integer, List<Integer>> additionalProximityChars) {
TouchPositionCorrection touchPositionCorrection) {
final HashMap<Integer, Key> keyCodeMap = new HashMap<Integer, Key>();
for (final Key key : keys) {
keyCodeMap.put(key.mCode, key);
@ -207,27 +201,6 @@ public class ProximityInfo {
neighborKeys[count++] = key;
}
}
int currentCodesSize = count;
for (int i = 0; i < currentCodesSize; ++i) {
final int c = neighborKeys[i].mCode;
final List<Integer> additionalChars = additionalProximityChars.get(c);
if (additionalChars == null || additionalChars.size() == 0) {
continue;
}
for (int j = 0; j < additionalChars.size(); ++j) {
final int additionalChar = additionalChars.get(j);
boolean contains = false;
for (int k = 0; k < count; ++k) {
if(additionalChar == neighborKeys[k].mCode) {
contains = true;
break;
}
}
if (!contains) {
neighborKeys[count++] = keyCodeMap.get(additionalChar);
}
}
}
mGridNeighbors[(y / mCellHeight) * mGridWidth + (x / mCellWidth)] =
Arrays.copyOfRange(neighborKeys, 0, count);
}

1
java/src/com/android/inputmethod/latin/InputAttributes.java
View file

@ -95,6 +95,7 @@ public class InputAttributes {
}
}
@SuppressWarnings("unused")
private void dumpFlags(final int inputType) {
Log.i(TAG, "Input class:");
final int inputClass = inputType & InputType.TYPE_MASK_CLASS;

1
java/src/com/android/inputmethod/latin/SettingsValues.java
View file

@ -23,7 +23,6 @@ import android.os.Build;
import android.util.Log;
import android.view.inputmethod.EditorInfo;
import com.android.inputmethod.compat.InputMethodInfoCompatWrapper;
import com.android.inputmethod.compat.InputTypeCompatUtils;
import com.android.inputmethod.compat.VibratorCompatWrapper;
import com.android.inputmethod.keyboard.internal.KeySpecParser;

9
java/src/com/android/inputmethod/latin/WordComposer.java
View file

@ -141,6 +141,7 @@ public class WordComposer {
keyY = y;
} else {
final Key key = keyDetector.detectHitKey(x, y);
// TODO: Pass an integer instead of an integer array
codes = new int[] { key != null ? key.mCode : NOT_A_CODE };
keyX = keyDetector.getTouchX(x);
keyY = keyDetector.getTouchY(y);
@ -202,9 +203,8 @@ public class WordComposer {
if (key.mCode == codePoint) {
final int x = key.mX + key.mWidth / 2;
final int y = key.mY + key.mHeight / 2;
final int[] codes = keyDetector.newCodeArray();
keyDetector.getNearbyCodes(x, y, codes);
add(codePoint, codes, x, y);
// TODO: Pass an integer instead of an integer array
add(codePoint, new int[] { key.mCode }, x, y);
return;
}
}
@ -216,7 +216,7 @@ public class WordComposer {
* Set the currently composing word to the one passed as an argument.
* This will register NOT_A_COORDINATE for X and Ys, and use the passed keyboard for proximity.
*/
public void setComposingWord(final CharSequence word, final Keyboard keyboard,
private void setComposingWord(final CharSequence word, final Keyboard keyboard,
final KeyDetector keyDetector) {
reset();
final int length = word.length();
@ -233,7 +233,6 @@ public class WordComposer {
final KeyDetector keyDetector = new KeyDetector(0);
keyDetector.setKeyboard(keyboard, 0, 0);
keyDetector.setProximityCorrectionEnabled(true);
keyDetector.setProximityThreshold(keyboard.mMostCommonKeyWidth);
setComposingWord(word, keyboard, keyDetector);
}

3
java/src/com/android/inputmethod/latin/suggestions/MoreSuggestions.java
View file

@ -25,7 +25,6 @@ import com.android.inputmethod.keyboard.Keyboard;
import com.android.inputmethod.keyboard.KeyboardSwitcher;
import com.android.inputmethod.keyboard.KeyboardView;
import com.android.inputmethod.keyboard.internal.KeyboardIconsSet;
import com.android.inputmethod.latin.LatinImeLogger;
import com.android.inputmethod.latin.R;
import com.android.inputmethod.latin.SuggestedWords;
import com.android.inputmethod.latin.Utils;
@ -38,8 +37,6 @@ public class MoreSuggestions extends Keyboard {
}
public static class Builder extends Keyboard.Builder<Builder.MoreSuggestionsParam> {
private static final boolean DBG = LatinImeLogger.sDBG;
private final MoreSuggestionsView mPaneView;
private SuggestedWords mSuggestions;
private int mFromPos;

1
java/src/com/android/inputmethod/latin/suggestions/SuggestionsView.java
View file

@ -62,7 +62,6 @@ import com.android.inputmethod.latin.R;
import com.android.inputmethod.latin.StaticInnerHandlerWrapper;
import com.android.inputmethod.latin.Suggest;
import com.android.inputmethod.latin.SuggestedWords;
import com.android.inputmethod.latin.SuggestedWords.SuggestedWordInfo;
import com.android.inputmethod.latin.Utils;
import java.util.ArrayList;