Create a new KeyboardLayout class to represent the layout.

Change-Id: Ia08c8194f460271c831702675cfb687ab9f6678b

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 { *; }
+

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.

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);
+    }
+}

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;
     }

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);
+    }
+}