diff options
5 files changed, 201 insertions, 1 deletions
diff --git a/java/proguard.flags b/java/proguard.flags index 0c5ad9fe8..c832a88e3 100644 --- a/java/proguard.flags +++ b/java/proguard.flags @@ -22,3 +22,7 @@ -keep class com.android.inputmethod.latin.NgramContext -keep class com.android.inputmethod.latin.makedict.ProbabilityInfo -keep class com.android.inputmethod.latin.utils.LanguageModelParam + +# TODO: remove once used in code. +-keep class com.android.inputmethod.keyboard.KeyboardLayout { *; } + diff --git a/java/src/com/android/inputmethod/keyboard/Keyboard.java b/java/src/com/android/inputmethod/keyboard/Keyboard.java index 2055a59bb..7318d4738 100644 --- a/java/src/com/android/inputmethod/keyboard/Keyboard.java +++ b/java/src/com/android/inputmethod/keyboard/Keyboard.java @@ -95,6 +95,9 @@ public class Keyboard { @Nonnull private final ProximityInfo mProximityInfo; + @Nonnull + private final KeyboardLayout mKeyboardLayout; + private final boolean mProximityCharsCorrectionEnabled; public Keyboard(@Nonnull final KeyboardParams params) { @@ -121,6 +124,8 @@ public class Keyboard { mOccupiedWidth, mOccupiedHeight, mMostCommonKeyWidth, mMostCommonKeyHeight, mSortedKeys, params.mTouchPositionCorrection); mProximityCharsCorrectionEnabled = params.mProximityCharsCorrectionEnabled; + mKeyboardLayout = KeyboardLayout.newKeyboardLayout(mSortedKeys, mMostCommonKeyWidth, + mMostCommonKeyHeight, mOccupiedWidth, mOccupiedHeight); } protected Keyboard(@Nonnull final Keyboard keyboard) { @@ -145,6 +150,7 @@ public class Keyboard { mProximityInfo = keyboard.mProximityInfo; mProximityCharsCorrectionEnabled = keyboard.mProximityCharsCorrectionEnabled; + mKeyboardLayout = keyboard.mKeyboardLayout; } public boolean hasProximityCharsCorrection(final int code) { @@ -164,6 +170,11 @@ public class Keyboard { return mProximityInfo; } + @Nonnull + public KeyboardLayout getKeyboardLayout() { + return mKeyboardLayout; + } + /** * Return the sorted list of keys of this keyboard. * The keys are sorted from top-left to bottom-right order. diff --git a/java/src/com/android/inputmethod/keyboard/KeyboardLayout.java b/java/src/com/android/inputmethod/keyboard/KeyboardLayout.java new file mode 100644 index 000000000..d0f32078e --- /dev/null +++ b/java/src/com/android/inputmethod/keyboard/KeyboardLayout.java @@ -0,0 +1,124 @@ +/* + * Copyright (C) 2015 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 + */ + +package com.android.inputmethod.keyboard; + +import com.android.inputmethod.annotations.UsedForTesting; + +import java.util.ArrayList; +import java.util.List; + +import javax.annotation.Nonnull; + +/** + * KeyboardLayout maintains the keyboard layout information. + */ +public class KeyboardLayout { + + private final int[] mKeyCodes; + + private final int[] mKeyXCoordinates; + private final int[] mKeyYCoordinates; + + private final int[] mKeyWidths; + private final int[] mKeyHeights; + + public final int mMostCommonKeyWidth; + public final int mMostCommonKeyHeight; + + public final int mKeyboardWidth; + public final int mKeyboardHeight; + + public KeyboardLayout(ArrayList<Key> layoutKeys, int mostCommonKeyWidth, + int mostCommonKeyHeight, int keyboardWidth, int keyboardHeight) { + mMostCommonKeyWidth = mostCommonKeyWidth; + mMostCommonKeyHeight = mostCommonKeyHeight; + mKeyboardWidth = keyboardWidth; + mKeyboardHeight = keyboardHeight; + + mKeyCodes = new int[layoutKeys.size()]; + mKeyXCoordinates = new int[layoutKeys.size()]; + mKeyYCoordinates = new int[layoutKeys.size()]; + mKeyWidths = new int[layoutKeys.size()]; + mKeyHeights = new int[layoutKeys.size()]; + + for (int i = 0; i < layoutKeys.size(); i++) { + Key key = layoutKeys.get(i); + mKeyCodes[i] = Character.toLowerCase(key.getCode()); + mKeyXCoordinates[i] = key.getX(); + mKeyYCoordinates[i] = key.getY(); + mKeyWidths[i] = key.getWidth(); + mKeyHeights[i] = key.getHeight(); + } + } + + @UsedForTesting + public int[] getKeyCodes() { + return mKeyCodes; + } + + /** + * The x-coordinate for the top-left corner of the keys. + * + */ + public int[] getKeyXCoordinates() { + return mKeyXCoordinates; + } + + /** + * The y-coordinate for the top-left corner of the keys. + */ + public int[] getKeyYCoordinates() { + return mKeyYCoordinates; + } + + /** + * The widths of the keys which are smaller than the true hit-area due to the gaps + * between keys. The mostCommonKey(Width/Height) represents the true key width/height + * including the gaps. + */ + public int[] getKeyWidths() { + return mKeyWidths; + } + + /** + * The heights of the keys which are smaller than the true hit-area due to the gaps + * between keys. The mostCommonKey(Width/Height) represents the true key width/height + * including the gaps. + */ + public int[] getKeyHeights() { + return mKeyHeights; + } + + /** + * Factory method to create {@link KeyboardLayout} objects. + */ + public static KeyboardLayout newKeyboardLayout(@Nonnull final List<Key> sortedKeys, + int mostCommonKeyWidth, int mostCommonKeyHeight, + int occupiedWidth, int occupiedHeight) { + final ArrayList<Key> layoutKeys = new ArrayList<Key>(); + for (final Key key : sortedKeys) { + if (!ProximityInfo.needsProximityInfo(key)) { + continue; + } + if (key.getCode() != ',') { + layoutKeys.add(key); + } + } + return new KeyboardLayout(layoutKeys, mostCommonKeyWidth, + mostCommonKeyHeight, occupiedWidth, occupiedHeight); + } +} diff --git a/java/src/com/android/inputmethod/keyboard/ProximityInfo.java b/java/src/com/android/inputmethod/keyboard/ProximityInfo.java index 228b964ea..b9a5eaefb 100644 --- a/java/src/com/android/inputmethod/keyboard/ProximityInfo.java +++ b/java/src/com/android/inputmethod/keyboard/ProximityInfo.java @@ -95,7 +95,7 @@ public class ProximityInfo { private static native void releaseProximityInfoNative(long nativeProximityInfo); - private static boolean needsProximityInfo(final Key key) { + static boolean needsProximityInfo(final Key key) { // Don't include special keys into ProximityInfo. return key.getCode() >= Constants.CODE_SPACE; } diff --git a/tests/src/com/android/inputmethod/keyboard/KeyboardLayoutTest.java b/tests/src/com/android/inputmethod/keyboard/KeyboardLayoutTest.java new file mode 100644 index 000000000..9aced5cea --- /dev/null +++ b/tests/src/com/android/inputmethod/keyboard/KeyboardLayoutTest.java @@ -0,0 +1,61 @@ +/* + * Copyright (C) 2015 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 + */ + +package com.android.inputmethod.keyboard; + +import static org.junit.Assert.assertEquals; + +import android.test.suitebuilder.annotation.SmallTest; + +import java.util.ArrayList; + +import org.junit.Test; + +@SmallTest +public class KeyboardLayoutTest { + + private KeyboardLayout mKeyboardLayout; + + @Test + public void testNewKeyboardLayout() { + KeyboardLayout keyboardLayout = KeyboardLayout + .newKeyboardLayout(new ArrayList<Key>(), 11, 12, 13, 14); + + assertEquals(11, keyboardLayout.mMostCommonKeyWidth); + assertEquals(12, keyboardLayout.mMostCommonKeyHeight); + assertEquals(13, keyboardLayout.mKeyboardWidth); + assertEquals(14, keyboardLayout.mKeyboardHeight); + + assertEquals(0, keyboardLayout.getKeyCodes().length); + assertEquals(0, keyboardLayout.getKeyWidths().length); + assertEquals(0, keyboardLayout.getKeyHeights().length); + assertEquals(0, keyboardLayout.getKeyXCoordinates().length); + assertEquals(0, keyboardLayout.getKeyYCoordinates().length); + + Key key1 = new Key("label1", 101, 102, "101", "101hint", 103, 104, 105, 106, 1100, 1101, 2, 2); + Key key2 = new Key("label2", 201, 202, "201", "201hint", 203, 204, 205, 206, 2100, 2201, 2, 2); + + ArrayList<Key> sortedKeys = new ArrayList<>(2); + sortedKeys.add(key1); + sortedKeys.add(key2); + keyboardLayout = KeyboardLayout.newKeyboardLayout(sortedKeys, 11, 12, 13, 14); + assertEquals(2, keyboardLayout.getKeyCodes().length); + assertEquals(2, keyboardLayout.getKeyWidths().length); + assertEquals(2, keyboardLayout.getKeyHeights().length); + assertEquals(2, keyboardLayout.getKeyXCoordinates().length); + assertEquals(2, keyboardLayout.getKeyYCoordinates().length); + } +} |