diff --git a/java/proguard.flags b/java/proguard.flags
index 7ce6f41..44416ec 100644
--- a/java/proguard.flags
+++ b/java/proguard.flags
@@ -30,3 +30,7 @@
 -keep class com.android.inputmethod.latin.SettingsActivity {
   *;
 }
+
+-keep class com.android.inputmethod.keyboard.internal.MiniKeyboardBuilder$MiniKeyboardLayoutParams {
+  <init>(...);
+}
diff --git a/java/src/com/android/inputmethod/keyboard/Key.java b/java/src/com/android/inputmethod/keyboard/Key.java
index a4aa0c1..8bc7e43 100644
--- a/java/src/com/android/inputmethod/keyboard/Key.java
+++ b/java/src/com/android/inputmethod/keyboard/Key.java
@@ -27,6 +27,7 @@
 import com.android.inputmethod.keyboard.internal.KeyStyles;
 import com.android.inputmethod.keyboard.internal.KeyStyles.KeyStyle;
 import com.android.inputmethod.keyboard.internal.KeyboardIconsSet;
+import com.android.inputmethod.keyboard.internal.KeyboardParams;
 import com.android.inputmethod.keyboard.internal.KeyboardParser;
 import com.android.inputmethod.keyboard.internal.KeyboardParser.ParseException;
 import com.android.inputmethod.keyboard.internal.PopupCharactersParser;
@@ -190,11 +191,11 @@
     /**
      * This constructor is being used only for key in popup mini keyboard.
      */
-    public Key(Resources res, Keyboard keyboard, CharSequence popupCharacter, int x, int y,
+    public Key(Resources res, KeyboardParams params, CharSequence popupCharacter, int x, int y,
             int width, int height, int edgeFlags) {
-        mHeight = height - keyboard.getVerticalGap();
-        mHorizontalGap = keyboard.getHorizontalGap();
-        mVerticalGap = keyboard.getVerticalGap();
+        mHeight = height - params.mVerticalGap;
+        mHorizontalGap = params.mHorizontalGap;
+        mVerticalGap = params.mVerticalGap;
         mVisualInsetsLeft = mVisualInsetsRight = 0;
         mWidth = width - mHorizontalGap;
         mEdgeFlags = edgeFlags;
@@ -209,8 +210,8 @@
         mLabel = PopupCharactersParser.getLabel(popupSpecification);
         mOutputText = PopupCharactersParser.getOutputText(popupSpecification);
         final int code = PopupCharactersParser.getCode(res, popupSpecification);
-        mCode = keyboard.isRtlKeyboard() ? getRtlParenthesisCode(code) : code;
-        mIcon = keyboard.mIconsSet.getIcon(PopupCharactersParser.getIconId(popupSpecification));
+        mCode = params.mIsRtlKeyboard ? getRtlParenthesisCode(code) : code;
+        mIcon = params.mIconsSet.getIcon(PopupCharactersParser.getIconId(popupSpecification));
         // Horizontal gap is divided equally to both sides of the key.
         mX = x + mHorizontalGap / 2;
         mY = y;
@@ -220,16 +221,15 @@
      * Create a key with the given top-left coordinate and extract its attributes from the XML
      * parser.
      * @param res resources associated with the caller's context
-     * @param row the row that this key belongs to. The row must already be attached to
-     * a {@link Keyboard}.
+     * @param params the keyboard building parameters.
+     * @param row the row that this key belongs to.
      * @param x the x coordinate of the top-left
      * @param y the y coordinate of the top-left
      * @param parser the XML parser containing the attributes for this key
      * @param keyStyles active key styles set
      */
-    public Key(Resources res, Row row, int x, int y, XmlResourceParser parser,
-            KeyStyles keyStyles) {
-        final Keyboard keyboard = row.getKeyboard();
+    public Key(Resources res, KeyboardParams params, Row row, int x, int y,
+            XmlResourceParser parser, KeyStyles keyStyles) {
 
         final TypedArray keyboardAttr = res.obtainAttributes(Xml.asAttributeSet(parser),
                 R.styleable.Keyboard);
@@ -237,14 +237,14 @@
         try {
             mHeight = KeyboardParser.getDimensionOrFraction(keyboardAttr,
                     R.styleable.Keyboard_rowHeight,
-                    keyboard.getKeyboardHeight(), row.mDefaultHeight) - keyboard.getVerticalGap();
+                    params.mHeight, row.mRowHeight) - params.mVerticalGap;
             mHorizontalGap = KeyboardParser.getDimensionOrFraction(keyboardAttr,
                     R.styleable.Keyboard_horizontalGap,
-                    keyboard.getDisplayWidth(), keyboard.getHorizontalGap());
-            mVerticalGap = keyboard.getVerticalGap();
+                    params.mWidth, params.mHorizontalGap);
+            mVerticalGap = params.mVerticalGap;
             keyWidth = KeyboardParser.getDimensionOrFraction(keyboardAttr,
                     R.styleable.Keyboard_keyWidth,
-                    keyboard.getDisplayWidth(), row.mDefaultWidth);
+                    params.mWidth, row.mDefaultKeyWidth);
         } finally {
             keyboardAttr.recycle();
         }
@@ -262,7 +262,7 @@
                 style = keyStyles.getEmptyKeyStyle();
             }
 
-            final int keyboardWidth = keyboard.getDisplayWidth();
+            final int keyboardWidth = params.mOccupiedWidth;
             int keyXPos = KeyboardParser.getDimensionOrFraction(keyAttr,
                     R.styleable.Keyboard_Key_keyXPos, keyboardWidth, x);
             if (keyXPos < 0) {
@@ -293,13 +293,13 @@
 
             CharSequence[] popupCharacters = style.getTextArray(
                     keyAttr, R.styleable.Keyboard_Key_popupCharacters);
-            if (keyboard.mId.mPasswordInput) {
+            if (params.mId.mPasswordInput) {
                 popupCharacters = PopupCharactersParser.filterOut(
                         res, popupCharacters, PopupCharactersParser.NON_ASCII_FILTER);
             }
             // In Arabic symbol layouts, we'd like to keep digits in popup characters regardless of
             // config_digit_popup_characters_enabled.
-            if (keyboard.mId.isAlphabetKeyboard() && !res.getBoolean(
+            if (params.mId.isAlphabetKeyboard() && !res.getBoolean(
                     R.bool.config_digit_popup_characters_enabled)) {
                 mPopupCharacters = PopupCharactersParser.filterOut(
                         res, popupCharacters, PopupCharactersParser.DIGIT_FILTER);
@@ -308,7 +308,7 @@
             }
             mMaxPopupColumn = style.getInt(keyboardAttr,
                     R.styleable.Keyboard_Key_maxPopupKeyboardColumn,
-                    keyboard.getMaxPopupKeyboardColumn());
+                    params.mMaxPopupColumn);
 
             mRepeatable = style.getBoolean(keyAttr, R.styleable.Keyboard_Key_isRepeatable, false);
             mFunctional = style.getBoolean(keyAttr, R.styleable.Keyboard_Key_isFunctional, false);
@@ -316,7 +316,7 @@
             mEnabled = style.getBoolean(keyAttr, R.styleable.Keyboard_Key_enabled, true);
             mEdgeFlags = 0;
 
-            final KeyboardIconsSet iconsSet = keyboard.mIconsSet;
+            final KeyboardIconsSet iconsSet = params.mIconsSet;
             mVisualInsetsLeft = KeyboardParser.getDimensionOrFraction(keyAttr,
                     R.styleable.Keyboard_Key_visualInsetsLeft, keyboardWidth, 0);
             mVisualInsetsRight = KeyboardParser.getDimensionOrFraction(keyAttr,
@@ -331,7 +331,7 @@
                     KeyboardIconsSet.ICON_UNDEFINED);
             if (shiftedIconId != KeyboardIconsSet.ICON_UNDEFINED) {
                 final Drawable shiftedIcon = iconsSet.getIcon(shiftedIconId);
-                keyboard.addShiftedIcon(this, shiftedIcon);
+                params.addShiftedIcon(this, shiftedIcon);
             }
             mHintLabel = style.getText(keyAttr, R.styleable.Keyboard_Key_keyHintLabel);
 
@@ -344,15 +344,12 @@
                     Keyboard.CODE_UNSPECIFIED);
             if (code == Keyboard.CODE_UNSPECIFIED && !TextUtils.isEmpty(mLabel)) {
                 final int firstChar = mLabel.charAt(0);
-                mCode = keyboard.isRtlKeyboard() ? getRtlParenthesisCode(firstChar) : firstChar;
+                mCode = params.mIsRtlKeyboard ? getRtlParenthesisCode(firstChar) : firstChar;
             } else if (code != Keyboard.CODE_UNSPECIFIED) {
                 mCode = code;
             } else {
                 mCode = Keyboard.CODE_DUMMY;
             }
-            if (mCode == Keyboard.CODE_SHIFT) {
-                keyboard.addShiftKey(this);
-            }
         } finally {
             keyAttr.recycle();
         }
diff --git a/java/src/com/android/inputmethod/keyboard/KeyDetector.java b/java/src/com/android/inputmethod/keyboard/KeyDetector.java
index 6d25025..53d46a3 100644
--- a/java/src/com/android/inputmethod/keyboard/KeyDetector.java
+++ b/java/src/com/android/inputmethod/keyboard/KeyDetector.java
@@ -57,7 +57,7 @@
         mCorrectionX = (int)correctionX;
         mCorrectionY = (int)correctionY;
         mKeyboard = keyboard;
-        final int threshold = keyboard.getMostCommonKeyWidth();
+        final int threshold = keyboard.mMostCommonKeyWidth;
         mProximityThresholdSquare = threshold * threshold;
     }
 
diff --git a/java/src/com/android/inputmethod/keyboard/Keyboard.java b/java/src/com/android/inputmethod/keyboard/Keyboard.java
index ae5bc95..809c949 100644
--- a/java/src/com/android/inputmethod/keyboard/Keyboard.java
+++ b/java/src/com/android/inputmethod/keyboard/Keyboard.java
@@ -16,23 +16,14 @@
 
 package com.android.inputmethod.keyboard;
 
-import android.content.Context;
-import android.content.res.Resources;
 import android.graphics.drawable.Drawable;
 import android.text.TextUtils;
-import android.util.Log;
 
 import com.android.inputmethod.keyboard.internal.KeyboardIconsSet;
-import com.android.inputmethod.keyboard.internal.KeyboardParser;
+import com.android.inputmethod.keyboard.internal.KeyboardParams;
 import com.android.inputmethod.keyboard.internal.KeyboardShiftState;
-import com.android.inputmethod.latin.R;
 
-import org.xmlpull.v1.XmlPullParserException;
-
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.HashSet;
+import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -56,8 +47,6 @@
  * </pre>
  */
 public class Keyboard {
-    private static final String TAG = Keyboard.class.getSimpleName();
-
     public static final int EDGE_LEFT = 0x01;
     public static final int EDGE_RIGHT = 0x02;
     public static final int EDGE_TOP = 0x04;
@@ -98,209 +87,77 @@
     public final KeyboardId mId;
 
     /** Total height of the keyboard, including the padding and keys */
-    private int mTotalHeight;
+    public final int mOccupiedHeight;
+    /** Total width of the keyboard, including the padding and keys */
+    public final int mOccupiedWidth;
 
-    /**
-     * Total width (minimum width) of the keyboard, including left side gaps and keys, but not any
-     * gaps on the right side.
-     */
-    private int mMinWidth;
-
-    /** Horizontal gap default for all rows */
-    private int mHorizontalGap;
-
-    /** Default key width */
-    private int mDefaultKeyWidth;
+    public final int mHeight;
+    public final int mWidth;
 
     /** Default row height */
-    private int mDefaultRowHeight;
+    public final int mDefaultRowHeight;
 
     /** Default gap between rows */
-    private int mVerticalGap;
+    public final int mVerticalGap;
+
+    public final int mMostCommonKeyWidth;
 
     /** Popup keyboard template */
-    private int mPopupKeyboardResId;
+    public final int mPopupKeyboardResId;
 
     /** Maximum column for popup keyboard */
-    private int mMaxPopupColumn;
+    public final int mMaxPopupColumn;
 
     /** True if Right-To-Left keyboard */
-    private boolean mIsRtlKeyboard;
+    public final boolean mIsRtlKeyboard;
 
-    /** List of keys in this keyboard */
-    private final List<Key> mKeys = new ArrayList<Key>();
-    /** List of shift keys in this keyboard and its icons and state */
-    private final List<Key> mShiftKeys = new ArrayList<Key>();
-    private final Map<Key, Drawable> mShiftedIcons = new HashMap<Key, Drawable>();
-    private final Map<Key, Drawable> mUnshiftedIcons = new HashMap<Key, Drawable>();
-    private final Set<Key> mShiftLockKeys = new HashSet<Key>();
-    public final KeyboardIconsSet mIconsSet = new KeyboardIconsSet();
-
-
-    /** Width of the screen available to fit the keyboard */
-    private final int mDisplayWidth;
-
-    /** Height of the screen */
-    private final int mDisplayHeight;
-
-    /** Height of keyboard */
-    private int mKeyboardHeight;
-
-    private int mMostCommonKeyWidth = 0;
+    /** List of keys and icons in this keyboard */
+    public final List<Key> mKeys;
+    public final List<Key> mShiftKeys;
+    public final Set<Key> mShiftLockKeys;
+    public final Map<Key, Drawable> mShiftedIcons;
+    public final Map<Key, Drawable> mUnshiftedIcons;
+    public final KeyboardIconsSet mIconsSet;
 
     private final KeyboardShiftState mShiftState = new KeyboardShiftState();
 
-    // Variables for pre-computing nearest keys.
-
-    // TODO: Change GRID_WIDTH and GRID_HEIGHT to private.
-    public final int GRID_WIDTH;
-    public final int GRID_HEIGHT;
-
     private final ProximityInfo mProximityInfo;
 
-    /**
-     * Creates a keyboard from the given xml key layout file.
-     * @param context the application or service context
-     * @param xmlLayoutResId the resource file that contains the keyboard layout and keys.
-     * @param id keyboard identifier
-     * @param width keyboard width
-     */
+    public Keyboard(KeyboardParams params) {
+        mId = params.mId;
+        mOccupiedHeight = params.mOccupiedHeight;
+        mOccupiedWidth = params.mOccupiedWidth;
+        mHeight = params.mHeight;
+        mWidth = params.mWidth;
+        mMostCommonKeyWidth = params.mMostCommonKeyWidth;
+        mIsRtlKeyboard = params.mIsRtlKeyboard;
+        mPopupKeyboardResId = params.mPopupKeyboardResId;
+        mMaxPopupColumn = params.mMaxPopupColumn;
 
-    public Keyboard(Context context, int xmlLayoutResId, KeyboardId id, int width) {
-        final Resources res = context.getResources();
-        GRID_WIDTH = res.getInteger(R.integer.config_keyboard_grid_width);
-        GRID_HEIGHT = res.getInteger(R.integer.config_keyboard_grid_height);
+        mDefaultRowHeight = params.mDefaultRowHeight;
+        mVerticalGap = params.mVerticalGap;
 
-        final int horizontalEdgesPadding = (int)res.getDimension(
-                R.dimen.keyboard_horizontal_edges_padding);
-        mDisplayWidth = width - horizontalEdgesPadding * 2;
-        // TODO: Adjust the height by referring to the height of area available for drawing as well.
-        mDisplayHeight = res.getDisplayMetrics().heightPixels;
+        mKeys = Collections.unmodifiableList(params.mKeys);
+        mShiftKeys = Collections.unmodifiableList(params.mShiftKeys);
+        mShiftLockKeys = Collections.unmodifiableSet(params.mShiftLockKeys);
+        mShiftedIcons = Collections.unmodifiableMap(params.mShiftedIcons);
+        mUnshiftedIcons = Collections.unmodifiableMap(params.mUnshiftedIcons);
+        mIconsSet = params.mIconsSet;
 
-        mHorizontalGap = 0;
-        setKeyWidth(mDisplayWidth / 10);
-        mVerticalGap = 0;
-        mDefaultRowHeight = mDefaultKeyWidth;
-        mId = id;
-        loadKeyboard(context, xmlLayoutResId);
         mProximityInfo = new ProximityInfo(
-                GRID_WIDTH, GRID_HEIGHT, getMinWidth(), getHeight(), getKeyWidth(), mKeys);
+                params.GRID_WIDTH, params.GRID_HEIGHT, mOccupiedWidth, mOccupiedHeight,
+                mMostCommonKeyWidth, mKeys);
     }
 
     public int getProximityInfo() {
         return mProximityInfo.getNativeProximityInfo();
     }
 
+    // TODO: Access mKeys directly
     public List<Key> getKeys() {
         return mKeys;
     }
 
-    public int getHorizontalGap() {
-        return mHorizontalGap;
-    }
-
-    public void setHorizontalGap(int gap) {
-        mHorizontalGap = gap;
-    }
-
-    public int getVerticalGap() {
-        return mVerticalGap;
-    }
-
-    public void setVerticalGap(int gap) {
-        mVerticalGap = gap;
-    }
-
-    public int getRowHeight() {
-        return mDefaultRowHeight;
-    }
-
-    public void setRowHeight(int height) {
-        mDefaultRowHeight = height;
-    }
-
-    public int getKeyWidth() {
-        return mDefaultKeyWidth;
-    }
-
-    public void setKeyWidth(int width) {
-        mDefaultKeyWidth = width;
-    }
-
-    /**
-     * Returns the total height of the keyboard
-     * @return the total height of the keyboard
-     */
-    public int getHeight() {
-        return mTotalHeight;
-    }
-
-    public void setHeight(int height) {
-        mTotalHeight = height;
-    }
-
-    public int getMinWidth() {
-        return mMinWidth;
-    }
-
-    public void setMinWidth(int minWidth) {
-        mMinWidth = minWidth;
-    }
-
-    public int getDisplayHeight() {
-        return mDisplayHeight;
-    }
-
-    public int getDisplayWidth() {
-        return mDisplayWidth;
-    }
-
-    public int getKeyboardHeight() {
-        return mKeyboardHeight;
-    }
-
-    public void setKeyboardHeight(int height) {
-        mKeyboardHeight = height;
-    }
-
-    public boolean isRtlKeyboard() {
-        return mIsRtlKeyboard;
-    }
-
-    public void setRtlKeyboard(boolean isRtl) {
-        mIsRtlKeyboard = isRtl;
-    }
-
-    public int getPopupKeyboardResId() {
-        return mPopupKeyboardResId;
-    }
-
-    public void setPopupKeyboardResId(int resId) {
-        mPopupKeyboardResId = resId;
-    }
-
-    public int getMaxPopupKeyboardColumn() {
-        return mMaxPopupColumn;
-    }
-
-    public void setMaxPopupKeyboardColumn(int column) {
-        mMaxPopupColumn = column;
-    }
-
-    public void addShiftKey(Key key) {
-        if (key == null) return;
-        mShiftKeys.add(key);
-        if (key.mSticky) {
-            mShiftLockKeys.add(key);
-        }
-    }
-
-    public void addShiftedIcon(Key key, Drawable icon) {
-        if (key == null) return;
-        mUnshiftedIcons.put(key, key.getIcon());
-        mShiftedIcons.put(key, icon);
-    }
-
     public boolean hasShiftLockKey() {
         return !mShiftLockKeys.isEmpty();
     }
@@ -391,46 +248,4 @@
     public int[] getNearestKeys(int x, int y) {
         return mProximityInfo.getNearestKeys(x, y);
     }
-
-    /**
-     * Compute the most common key width in order to use it as proximity key detection threshold.
-     *
-     * @return The most common key width in the keyboard
-     */
-    public int getMostCommonKeyWidth() {
-        if (mMostCommonKeyWidth == 0) {
-            final HashMap<Integer, Integer> histogram = new HashMap<Integer, Integer>();
-            int maxCount = 0;
-            int mostCommonWidth = 0;
-            for (final Key key : mKeys) {
-                final Integer width = key.mWidth + key.mHorizontalGap;
-                Integer count = histogram.get(width);
-                if (count == null)
-                    count = 0;
-                histogram.put(width, ++count);
-                if (count > maxCount) {
-                    maxCount = count;
-                    mostCommonWidth = width;
-                }
-            }
-            mMostCommonKeyWidth = mostCommonWidth;
-        }
-        return mMostCommonKeyWidth;
-    }
-
-    private void loadKeyboard(Context context, int xmlLayoutResId) {
-        try {
-            KeyboardParser parser = new KeyboardParser(this, context);
-            parser.parseKeyboard(xmlLayoutResId);
-            // mMinWidth is the width of this keyboard which is maximum width of row.
-            mMinWidth = parser.getMaxRowWidth();
-            mTotalHeight = parser.getTotalHeight();
-        } catch (XmlPullParserException e) {
-            Log.w(TAG, "keyboard XML parse error: " + e);
-            throw new IllegalArgumentException(e);
-        } catch (IOException e) {
-            Log.w(TAG, "keyboard XML parse error: " + e);
-            throw new RuntimeException(e);
-        }
-    }
 }
diff --git a/java/src/com/android/inputmethod/keyboard/KeyboardId.java b/java/src/com/android/inputmethod/keyboard/KeyboardId.java
index 9299c6c..d0a2f86 100644
--- a/java/src/com/android/inputmethod/keyboard/KeyboardId.java
+++ b/java/src/com/android/inputmethod/keyboard/KeyboardId.java
@@ -42,8 +42,6 @@
     public static final int F2KEY_MODE_SHORTCUT_IME = 2;
     public static final int F2KEY_MODE_SHORTCUT_IME_OR_SETTINGS = 3;
 
-    private static final int MINI_KEYBOARD_ID_MARKER = -1;
-
     public final Locale mLocale;
     public final int mOrientation;
     public final int mWidth;
@@ -110,9 +108,9 @@
         });
     }
 
-    public KeyboardId cloneAsMiniKeyboard() {
-        return new KeyboardId("mini popup keyboard", MINI_KEYBOARD_ID_MARKER, mLocale, mOrientation,
-                mWidth, mMode, mAttribute, false, F2KEY_MODE_NONE, false, false, false);
+    public KeyboardId cloneWithNewXml(String xmlName, int xmlId) {
+        return new KeyboardId(xmlName, xmlId, mLocale, mOrientation, mWidth, mMode, mAttribute,
+                false, F2KEY_MODE_NONE, false, false, false);
     }
 
     public KeyboardId cloneWithNewGeometry(int orientation, int width) {
@@ -127,10 +125,6 @@
         return mXmlId;
     }
 
-    public boolean isMiniKeyboard() {
-        return mXmlId == MINI_KEYBOARD_ID_MARKER;
-    }
-
     public boolean isAlphabetKeyboard() {
         return mXmlId == R.xml.kbd_qwerty;
     }
diff --git a/java/src/com/android/inputmethod/keyboard/KeyboardSwitcher.java b/java/src/com/android/inputmethod/keyboard/KeyboardSwitcher.java
index 17fdd0c..f45e810 100644
--- a/java/src/com/android/inputmethod/keyboard/KeyboardSwitcher.java
+++ b/java/src/com/android/inputmethod/keyboard/KeyboardSwitcher.java
@@ -29,7 +29,6 @@
 import android.view.inputmethod.EditorInfo;
 
 import com.android.inputmethod.accessibility.AccessibleKeyboardViewProxy;
-import com.android.inputmethod.compat.InputMethodManagerCompatWrapper;
 import com.android.inputmethod.keyboard.internal.ModifierKeyState;
 import com.android.inputmethod.keyboard.internal.ShiftKeyState;
 import com.android.inputmethod.latin.LatinIME;
@@ -270,14 +269,17 @@
         if (keyboard == null) {
             final Locale savedLocale = Utils.setSystemLocale(
                     mResources, mSubtypeSwitcher.getInputLocale());
-
-            keyboard = new LatinKeyboard(mThemeContext, id, id.mWidth);
+            try {
+                keyboard = new LatinKeyboard.Builder(mThemeContext).load(id).build();
+            } finally {
+                Utils.setSystemLocale(mResources, savedLocale);
+            }
             mKeyboardCache.put(id, new SoftReference<LatinKeyboard>(keyboard));
-            if (DEBUG_CACHE)
+
+            if (DEBUG_CACHE) {
                 Log.d(TAG, "keyboard cache size=" + mKeyboardCache.size() + ": "
                         + ((ref == null) ? "LOAD" : "GCed") + " id=" + id);
-
-            Utils.setSystemLocale(mResources, savedLocale);
+            }
         } else if (DEBUG_CACHE) {
             Log.d(TAG, "keyboard cache size=" + mKeyboardCache.size() + ": HIT  id=" + id);
         }
diff --git a/java/src/com/android/inputmethod/keyboard/KeyboardView.java b/java/src/com/android/inputmethod/keyboard/KeyboardView.java
index e237258..0fb5109 100644
--- a/java/src/com/android/inputmethod/keyboard/KeyboardView.java
+++ b/java/src/com/android/inputmethod/keyboard/KeyboardView.java
@@ -357,7 +357,7 @@
         mDirtyRect.set(0, 0, getWidth(), getHeight());
         mBufferNeedsUpdate = true;
         invalidateAllKeys();
-        final int keyHeight = keyboard.getRowHeight() - keyboard.getVerticalGap();
+        final int keyHeight = keyboard.mDefaultRowHeight - keyboard.mVerticalGap;
         mKeyDrawParams.updateKeyHeight(keyHeight);
         mKeyPreviewDrawParams.updateKeyHeight(keyHeight);
     }
@@ -396,7 +396,7 @@
     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
         if (mKeyboard != null) {
             // The main keyboard expands to the display width.
-            final int height = mKeyboard.getKeyboardHeight() + getPaddingTop() + getPaddingBottom();
+            final int height = mKeyboard.mOccupiedHeight + getPaddingTop() + getPaddingBottom();
             setMeasuredDimension(widthMeasureSpec, height);
         } else {
             super.onMeasure(widthMeasureSpec, heightMeasureSpec);
diff --git a/java/src/com/android/inputmethod/keyboard/LatinKeyboard.java b/java/src/com/android/inputmethod/keyboard/LatinKeyboard.java
index 3c27129..9a13608 100644
--- a/java/src/com/android/inputmethod/keyboard/LatinKeyboard.java
+++ b/java/src/com/android/inputmethod/keyboard/LatinKeyboard.java
@@ -31,13 +31,14 @@
 import android.graphics.drawable.Drawable;
 import android.text.TextUtils;
 
+import com.android.inputmethod.keyboard.internal.KeyboardParams;
+import com.android.inputmethod.keyboard.internal.KeyboardParser;
 import com.android.inputmethod.latin.R;
 import com.android.inputmethod.latin.SubtypeSwitcher;
 
 import java.lang.ref.SoftReference;
 import java.util.Arrays;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Locale;
 
 // TODO: We should remove this class
@@ -73,32 +74,16 @@
     private static final String SMALL_TEXT_SIZE_OF_LANGUAGE_ON_SPACEBAR = "small";
     private static final String MEDIUM_TEXT_SIZE_OF_LANGUAGE_ON_SPACEBAR = "medium";
 
-    public LatinKeyboard(Context context, KeyboardId id, int width) {
-        super(context, id.getXmlId(), id, width);
+    private LatinKeyboard(Context context, LatinKeyboardParams params) {
+        super(params);
         mRes = context.getResources();
         mTheme = context.getTheme();
 
-        final List<Key> keys = getKeys();
-        int spaceKeyIndex = -1;
-        int shortcutKeyIndex = -1;
-        final int keyCount = keys.size();
-        for (int index = 0; index < keyCount; index++) {
-            // For now, assuming there are up to one space key and one shortcut key respectively.
-            switch (keys.get(index).mCode) {
-            case CODE_SPACE:
-                spaceKeyIndex = index;
-                break;
-            case CODE_SHORTCUT:
-                shortcutKeyIndex = index;
-                break;
-            }
-        }
-
         // The index of space key is available only after Keyboard constructor has finished.
-        mSpaceKey = (spaceKeyIndex >= 0) ? keys.get(spaceKeyIndex) : null;
+        mSpaceKey = params.mSpaceKey;
         mSpaceIcon = (mSpaceKey != null) ? mSpaceKey.getIcon() : null;
 
-        mShortcutKey = (shortcutKeyIndex >= 0) ? keys.get(shortcutKeyIndex) : null;
+        mShortcutKey = params.mShortcutKey;
         mEnabledShortcutIcon = (mShortcutKey != null) ? mShortcutKey.getIcon() : null;
 
         final TypedArray a = context.obtainStyledAttributes(
@@ -114,6 +99,42 @@
         a.recycle();
     }
 
+    private static class LatinKeyboardParams extends KeyboardParams {
+        public Key mSpaceKey = null;
+        public Key mShortcutKey = null;
+
+        @Override
+        public void onAddKey(Key key) {
+            super.onAddKey(key);
+
+            switch (key.mCode) {
+            case Keyboard.CODE_SPACE:
+                mSpaceKey = key;
+                break;
+            case Keyboard.CODE_SHORTCUT:
+                mShortcutKey = key;
+                break;
+            }
+        }
+    }
+
+    public static class Builder extends KeyboardParser<LatinKeyboardParams> {
+        public Builder(Context context) {
+            super(context, new LatinKeyboardParams());
+        }
+
+        @Override
+        public Builder load(KeyboardId id) {
+            super.load(id);
+            return this;
+        }
+
+        @Override
+        public LatinKeyboard build() {
+            return new LatinKeyboard(mContext, mParams);
+        }
+    }
+
     public void setSpacebarTextFadeFactor(float fadeFactor, LatinKeyboardView view) {
         mSpacebarTextFadeFactor = fadeFactor;
         updateSpacebarForLocale(false);
@@ -294,8 +315,8 @@
     @Override
     public int[] getNearestKeys(int x, int y) {
         // Avoid dead pixels at edges of the keyboard
-        return super.getNearestKeys(Math.max(0, Math.min(x, getMinWidth() - 1)),
-                Math.max(0, Math.min(y, getHeight() - 1)));
+        return super.getNearestKeys(Math.max(0, Math.min(x, mOccupiedWidth - 1)),
+                Math.max(0, Math.min(y, mOccupiedHeight - 1)));
     }
 
     public static int getTextSizeFromTheme(Theme theme, int style, int defValue) {
diff --git a/java/src/com/android/inputmethod/keyboard/LatinKeyboardBaseView.java b/java/src/com/android/inputmethod/keyboard/LatinKeyboardBaseView.java
index b397ca7..abf28c7 100644
--- a/java/src/com/android/inputmethod/keyboard/LatinKeyboardBaseView.java
+++ b/java/src/com/android/inputmethod/keyboard/LatinKeyboardBaseView.java
@@ -289,7 +289,7 @@
         super.setKeyboard(keyboard);
         mKeyDetector.setKeyboard(
                 keyboard, -getPaddingLeft(), -getPaddingTop() + mVerticalCorrection);
-        mKeyDetector.setProximityThreshold(keyboard.getMostCommonKeyWidth());
+        mKeyDetector.setProximityThreshold(keyboard.mMostCommonKeyWidth);
         PointerTracker.setKeyDetector(mKeyDetector);
         mPopupPanelCache.clear();
     }
@@ -360,7 +360,7 @@
                 (PopupMiniKeyboardView)container.findViewById(R.id.mini_keyboard_view);
         final Keyboard parentKeyboard = getKeyboard();
         final Keyboard miniKeyboard = new MiniKeyboardBuilder(
-                this, parentKeyboard.getPopupKeyboardResId(), parentKey, parentKeyboard).build();
+                this, parentKeyboard.mPopupKeyboardResId, parentKey, parentKeyboard).build();
         miniKeyboardView.setKeyboard(miniKeyboard);
 
         container.measure(MeasureSpec.makeMeasureSpec(getWidth(), MeasureSpec.AT_MOST),
diff --git a/java/src/com/android/inputmethod/keyboard/LatinKeyboardView.java b/java/src/com/android/inputmethod/keyboard/LatinKeyboardView.java
index b78fd94..0409677 100644
--- a/java/src/com/android/inputmethod/keyboard/LatinKeyboardView.java
+++ b/java/src/com/android/inputmethod/keyboard/LatinKeyboardView.java
@@ -69,7 +69,7 @@
     public void setKeyboard(Keyboard newKeyboard) {
         super.setKeyboard(newKeyboard);
         // One-seventh of the keyboard width seems like a reasonable threshold
-        final int jumpThreshold = newKeyboard.getMinWidth() / 7;
+        final int jumpThreshold = newKeyboard.mOccupiedWidth / 7;
         mJumpThresholdSquare = jumpThreshold * jumpThreshold;
     }
 
diff --git a/java/src/com/android/inputmethod/keyboard/MiniKeyboard.java b/java/src/com/android/inputmethod/keyboard/MiniKeyboard.java
index 95e3275..7f5339d 100644
--- a/java/src/com/android/inputmethod/keyboard/MiniKeyboard.java
+++ b/java/src/com/android/inputmethod/keyboard/MiniKeyboard.java
@@ -16,30 +16,14 @@
 
 package com.android.inputmethod.keyboard;
 
-import android.content.Context;
+import com.android.inputmethod.keyboard.internal.MiniKeyboardBuilder.MiniKeyboardLayoutParams;
 
 public class MiniKeyboard extends Keyboard {
-    private int mDefaultKeyCoordX;
+    private final int mDefaultKeyCoordX;
 
-    public MiniKeyboard(Context context, int xmlLayoutResId, Keyboard parentKeyboard) {
-        super(context, xmlLayoutResId, parentKeyboard.mId.cloneAsMiniKeyboard(),
-                parentKeyboard.getMinWidth());
-        // HACK: Current mini keyboard design totally relies on the 9-patch padding about horizontal
-        // and vertical key spacing. To keep the visual of mini keyboard as is, these hacks are
-        // needed to keep having the same horizontal and vertical key spacing.
-        setHorizontalGap(0);
-        setVerticalGap(parentKeyboard.getVerticalGap() / 2);
-
-        // TODO: When we have correctly padded key background 9-patch drawables for mini keyboard,
-        // revert the above hacks and uncomment the following lines.
-        //setHorizontalGap(parentKeyboard.getHorizontalGap());
-        //setVerticalGap(parentKeyboard.getVerticalGap());
-
-        setRtlKeyboard(parentKeyboard.isRtlKeyboard());
-    }
-
-    public void setDefaultCoordX(int pos) {
-        mDefaultKeyCoordX = pos;
+    public MiniKeyboard(MiniKeyboardLayoutParams params) {
+        super(params);
+        mDefaultKeyCoordX = params.getDefaultKeyCoordX() + params.mDefaultKeyWidth / 2;
     }
 
     public int getDefaultCoordX() {
diff --git a/java/src/com/android/inputmethod/keyboard/PointerTracker.java b/java/src/com/android/inputmethod/keyboard/PointerTracker.java
index b25754d..3d8a9cf 100644
--- a/java/src/com/android/inputmethod/keyboard/PointerTracker.java
+++ b/java/src/com/android/inputmethod/keyboard/PointerTracker.java
@@ -286,7 +286,7 @@
         mKeyDetector = keyDetector;
         mKeyboard = keyDetector.getKeyboard();
         mKeys = mKeyboard.getKeys();
-        final int keyQuarterWidth = mKeyboard.getKeyWidth() / 4;
+        final int keyQuarterWidth = mKeyboard.mMostCommonKeyWidth / 4;
         mKeyQuarterWidthSquared = keyQuarterWidth * keyQuarterWidth;
     }
 
diff --git a/java/src/com/android/inputmethod/keyboard/PopupMiniKeyboardView.java b/java/src/com/android/inputmethod/keyboard/PopupMiniKeyboardView.java
index 2741ee8..dfaaa70 100644
--- a/java/src/com/android/inputmethod/keyboard/PopupMiniKeyboardView.java
+++ b/java/src/com/android/inputmethod/keyboard/PopupMiniKeyboardView.java
@@ -108,8 +108,8 @@
     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
         final Keyboard keyboard = getKeyboard();
         if (keyboard != null) {
-            final int width = keyboard.getMinWidth() + getPaddingLeft() + getPaddingRight();
-            final int height = keyboard.getKeyboardHeight() + getPaddingTop() + getPaddingBottom();
+            final int width = keyboard.mOccupiedWidth + getPaddingLeft() + getPaddingRight();
+            final int height = keyboard.mOccupiedHeight + getPaddingTop() + getPaddingBottom();
             setMeasuredDimension(width, height);
         } else {
             super.onMeasure(widthMeasureSpec, heightMeasureSpec);
@@ -170,9 +170,9 @@
         final int miniKeyboardLeft = pointX - miniKeyboard.getDefaultCoordX()
                 + parentKeyboardView.getPaddingLeft();
         final int x = Math.max(0, Math.min(miniKeyboardLeft,
-                parentKeyboardView.getWidth() - miniKeyboard.getMinWidth()))
+                parentKeyboardView.getWidth() - miniKeyboard.mOccupiedWidth))
                 - container.getPaddingLeft() + mCoordinates[0];
-        final int y = pointY - parentKeyboard.getVerticalGap()
+        final int y = pointY - parentKeyboard.mVerticalGap
                 - (container.getMeasuredHeight() - container.getPaddingBottom())
                 + parentKeyboardView.getPaddingTop() + mCoordinates[1];
 
diff --git a/java/src/com/android/inputmethod/keyboard/internal/KeyboardParams.java b/java/src/com/android/inputmethod/keyboard/internal/KeyboardParams.java
index 58d7420..4ccaa72 100644
--- a/java/src/com/android/inputmethod/keyboard/internal/KeyboardParams.java
+++ b/java/src/com/android/inputmethod/keyboard/internal/KeyboardParams.java
@@ -19,6 +19,7 @@
 import android.graphics.drawable.Drawable;
 
 import com.android.inputmethod.keyboard.Key;
+import com.android.inputmethod.keyboard.Keyboard;
 import com.android.inputmethod.keyboard.KeyboardId;
 
 import java.util.ArrayList;
@@ -31,8 +32,8 @@
 public class KeyboardParams {
     public KeyboardId mId;
 
-    public int mTotalHeight;
-    public int mTotalWidth;
+    public int mOccupiedHeight;
+    public int mOccupiedWidth;
 
     public int mHeight;
     public int mWidth;
@@ -61,40 +62,34 @@
     public final Map<Key, Drawable> mUnshiftedIcons = new HashMap<Key, Drawable>();
     public final KeyboardIconsSet mIconsSet = new KeyboardIconsSet();
 
-    public void addShiftKey(Key key) {
-        if (key == null) return;
-        mShiftKeys.add(key);
-        if (key.mSticky) {
-            mShiftLockKeys.add(key);
+    public int mMostCommonKeyWidth = 0;
+
+    public void onAddKey(Key key) {
+        mKeys.add(key);
+        updateHistogram(key);
+        if (key.mCode == Keyboard.CODE_SHIFT) {
+            mShiftKeys.add(key);
+            if (key.mSticky) {
+                mShiftLockKeys.add(key);
+            }
         }
     }
 
     public void addShiftedIcon(Key key, Drawable icon) {
-        if (key == null) return;
         mUnshiftedIcons.put(key, key.getIcon());
         mShiftedIcons.put(key, icon);
     }
 
-    /**
-     * Compute the most common key width in order to use it as proximity key detection threshold.
-     *
-     * @return The most common key width in the keyboard
-     */
-    public int getMostCommonKeyWidth() {
-        final HashMap<Integer, Integer> histogram = new HashMap<Integer, Integer>();
-        int maxCount = 0;
-        int mostCommonWidth = 0;
-        for (final Key key : mKeys) {
-            final Integer width = key.mWidth + key.mHorizontalGap;
-            Integer count = histogram.get(width);
-            if (count == null)
-                count = 0;
-            histogram.put(width, ++count);
-            if (count > maxCount) {
-                maxCount = count;
-                mostCommonWidth = width;
-            }
+    private int mMaxCount = 0;
+    private final Map<Integer, Integer> mHistogram = new HashMap<Integer, Integer>();
+
+    private void updateHistogram(Key key) {
+        final Integer width = key.mWidth + key.mHorizontalGap;
+        final int count = (mHistogram.containsKey(width) ? mHistogram.get(width) : 0) + 1;
+        mHistogram.put(width, count);
+        if (count > mMaxCount) {
+            mMaxCount = count;
+            mMostCommonKeyWidth = width;
         }
-        return mostCommonWidth;
     }
 }
diff --git a/java/src/com/android/inputmethod/keyboard/internal/KeyboardParser.java b/java/src/com/android/inputmethod/keyboard/internal/KeyboardParser.java
index e3238c3..42e290f 100644
--- a/java/src/com/android/inputmethod/keyboard/internal/KeyboardParser.java
+++ b/java/src/com/android/inputmethod/keyboard/internal/KeyboardParser.java
@@ -20,6 +20,7 @@
 import android.content.res.Resources;
 import android.content.res.TypedArray;
 import android.content.res.XmlResourceParser;
+import android.util.DisplayMetrics;
 import android.util.Log;
 import android.util.TypedValue;
 import android.util.Xml;
@@ -107,7 +108,7 @@
  * </pre>
  */
 
-public class KeyboardParser {
+public class KeyboardParser<KP extends KeyboardParams> {
     private static final String TAG = KeyboardParser.class.getSimpleName();
     private static final boolean DEBUG = false;
 
@@ -123,40 +124,52 @@
     private static final String TAG_DEFAULT = "default";
     public static final String TAG_KEY_STYLE = "key-style";
 
-    private final Keyboard mKeyboard;
-    private final Context mContext;
-    private final Resources mResources;
+    protected final KP mParams;
+    protected final Context mContext;
+    protected final Resources mResources;
+    private final DisplayMetrics mDisplayMetrics;
 
-    private int mKeyboardTopPadding;
-    private int mKeyboardBottomPadding;
-    private int mHorizontalEdgesPadding;
     private int mCurrentX = 0;
     private int mCurrentY = 0;
-    private int mMaxRowWidth = 0;
-    private int mTotalHeight = 0;
     private Row mCurrentRow = null;
     private boolean mLeftEdge;
     private Key mRightEdgeKey = null;
     private final KeyStyles mKeyStyles = new KeyStyles();
 
-    public KeyboardParser(Keyboard keyboard, Context context) {
-        mKeyboard = keyboard;
+    public KeyboardParser(Context context, KP params) {
         mContext = context;
         final Resources res = context.getResources();
         mResources = res;
-        mHorizontalEdgesPadding = (int)res.getDimension(R.dimen.keyboard_horizontal_edges_padding);
+        mDisplayMetrics = res.getDisplayMetrics();
+
+        mParams = params;
+        mParams.mHorizontalEdgesPadding = (int)res.getDimension(
+                R.dimen.keyboard_horizontal_edges_padding);
+
+        mParams.GRID_WIDTH = res.getInteger(R.integer.config_keyboard_grid_width);
+        mParams.GRID_HEIGHT = res.getInteger(R.integer.config_keyboard_grid_height);
     }
 
-    public int getMaxRowWidth() {
-        return mMaxRowWidth;
+    public KeyboardParser<KP> load(KeyboardId id) {
+        mParams.mId = id;
+        try {
+            parseKeyboard(id.getXmlId());
+        } catch (XmlPullParserException e) {
+            Log.w(TAG, "keyboard XML parse error: " + e);
+            throw new IllegalArgumentException(e);
+        } catch (IOException e) {
+            Log.w(TAG, "keyboard XML parse error: " + e);
+            throw new RuntimeException(e);
+        }
+        return this;
     }
 
-    public int getTotalHeight() {
-        return mTotalHeight;
+    public Keyboard build() {
+        return new Keyboard(mParams);
     }
 
-    public void parseKeyboard(int resId) throws XmlPullParserException, IOException {
-        if (DEBUG) Log.d(TAG, String.format("<%s> %s", TAG_KEYBOARD, mKeyboard.mId));
+    private void parseKeyboard(int resId) throws XmlPullParserException, IOException {
+        if (DEBUG) Log.d(TAG, String.format("<%s> %s", TAG_KEYBOARD, mParams.mId));
         final XmlResourceParser parser = mResources.getXml(resId);
         int event;
         while ((event = parser.next()) != XmlPullParser.END_DOCUMENT) {
@@ -165,7 +178,7 @@
                 if (TAG_KEYBOARD.equals(tag)) {
                     parseKeyboardAttributes(parser);
                     startKeyboard();
-                    parseKeyboardContent(parser, mKeyboard.getKeys());
+                    parseKeyboardContent(parser, false);
                     break;
                 } else {
                     throw new IllegalStartTag(parser, TAG_KEYBOARD);
@@ -196,15 +209,14 @@
     }
 
     private void parseKeyboardAttributes(XmlResourceParser parser) {
-        final Keyboard keyboard = mKeyboard;
-        final int displayWidth = keyboard.getDisplayWidth();
+        final int displayWidth = mDisplayMetrics.widthPixels;
         final TypedArray keyboardAttr = mContext.obtainStyledAttributes(
                 Xml.asAttributeSet(parser), R.styleable.Keyboard, R.attr.keyboardStyle,
                 R.style.Keyboard);
         final TypedArray keyAttr = mResources.obtainAttributes(Xml.asAttributeSet(parser),
                 R.styleable.Keyboard_Key);
         try {
-            final int displayHeight = keyboard.getDisplayHeight();
+            final int displayHeight = mDisplayMetrics.heightPixels;
             final int keyboardHeight = (int)keyboardAttr.getDimension(
                     R.styleable.Keyboard_keyboardHeight, displayHeight / 2);
             final int maxKeyboardHeight = getDimensionOrFraction(keyboardAttr,
@@ -219,37 +231,41 @@
             }
             // Keyboard height will not exceed maxKeyboardHeight and will not be less than
             // minKeyboardHeight.
-            final int height = Math.max(
+            mParams.mOccupiedHeight = Math.max(
                     Math.min(keyboardHeight, maxKeyboardHeight), minKeyboardHeight);
+            mParams.mOccupiedWidth = mParams.mId.mWidth;
+            mParams.mTopPadding = getDimensionOrFraction(keyboardAttr,
+                    R.styleable.Keyboard_keyboardTopPadding, mParams.mOccupiedHeight, 0);
+            mParams.mBottomPadding = getDimensionOrFraction(keyboardAttr,
+                    R.styleable.Keyboard_keyboardBottomPadding, mParams.mOccupiedHeight, 0);
 
-            keyboard.setKeyboardHeight(height);
-            keyboard.setRtlKeyboard(keyboardAttr.getBoolean(
-                    R.styleable.Keyboard_isRtlKeyboard, false));
-            keyboard.setKeyWidth(getDimensionOrFraction(keyboardAttr,
-                    R.styleable.Keyboard_keyWidth, displayWidth, displayWidth / 10));
-            keyboard.setRowHeight(getDimensionOrFraction(keyboardAttr,
-                    R.styleable.Keyboard_rowHeight, height, 50));
-            keyboard.setHorizontalGap(getDimensionOrFraction(keyboardAttr,
-                    R.styleable.Keyboard_horizontalGap, displayWidth, 0));
-            keyboard.setVerticalGap(getDimensionOrFraction(keyboardAttr,
-                    R.styleable.Keyboard_verticalGap, height, 0));
-            keyboard.setPopupKeyboardResId(keyboardAttr.getResourceId(
-                    R.styleable.Keyboard_popupKeyboardTemplate, 0));
-            keyboard.setMaxPopupKeyboardColumn(keyAttr.getInt(
-                    R.styleable.Keyboard_Key_maxPopupKeyboardColumn, 5));
+            final int height = mParams.mOccupiedHeight;
+            final int width = mParams.mOccupiedWidth - mParams.mHorizontalEdgesPadding * 2
+                    - mParams.mHorizontalCenterPadding;
+            mParams.mHeight = height;
+            mParams.mWidth = width;
+            mParams.mDefaultKeyWidth = getDimensionOrFraction(keyboardAttr,
+                    R.styleable.Keyboard_keyWidth, width, width / 10);
+            mParams.mDefaultRowHeight = getDimensionOrFraction(keyboardAttr,
+                    R.styleable.Keyboard_rowHeight, height, height / 4);
+            mParams.mHorizontalGap = getDimensionOrFraction(keyboardAttr,
+                    R.styleable.Keyboard_horizontalGap, width, 0);
+            mParams.mVerticalGap = getDimensionOrFraction(keyboardAttr,
+                    R.styleable.Keyboard_verticalGap, height, 0);
 
-            mKeyboard.mIconsSet.loadIcons(keyboardAttr);
-            mKeyboardTopPadding = getDimensionOrFraction(keyboardAttr,
-                    R.styleable.Keyboard_keyboardTopPadding, height, 0);
-            mKeyboardBottomPadding = getDimensionOrFraction(keyboardAttr,
-                    R.styleable.Keyboard_keyboardBottomPadding, height, 0);
+            mParams.mIsRtlKeyboard = keyboardAttr.getBoolean(R.styleable.Keyboard_isRtlKeyboard, false);
+            mParams.mPopupKeyboardResId = keyboardAttr.getResourceId(
+                    R.styleable.Keyboard_popupKeyboardTemplate, 0);
+            mParams.mMaxPopupColumn = keyAttr.getInt(R.styleable.Keyboard_Key_maxPopupKeyboardColumn, 5);
+
+            mParams.mIconsSet.loadIcons(keyboardAttr);
         } finally {
             keyAttr.recycle();
             keyboardAttr.recycle();
         }
     }
 
-    private void parseKeyboardContent(XmlResourceParser parser, List<Key> keys)
+    private void parseKeyboardContent(XmlResourceParser parser, boolean skip)
             throws XmlPullParserException, IOException {
         int event;
         while ((event = parser.next()) != XmlPullParser.END_DOCUMENT) {
@@ -258,22 +274,22 @@
                 if (TAG_ROW.equals(tag)) {
                     Row row = parseRowAttributes(parser);
                     if (DEBUG) Log.d(TAG, String.format("<%s>", TAG_ROW));
-                    if (keys != null)
+                    if (!skip)
                         startRow(row);
-                    parseRowContent(parser, row, keys);
+                    parseRowContent(parser, row, skip);
                 } else if (TAG_INCLUDE.equals(tag)) {
-                    parseIncludeKeyboardContent(parser, keys);
+                    parseIncludeKeyboardContent(parser, skip);
                 } else if (TAG_SWITCH.equals(tag)) {
-                    parseSwitchKeyboardContent(parser, keys);
+                    parseSwitchKeyboardContent(parser, skip);
                 } else if (TAG_KEY_STYLE.equals(tag)) {
-                    parseKeyStyle(parser, keys);
+                    parseKeyStyle(parser, skip);
                 } else {
                     throw new IllegalStartTag(parser, TAG_ROW);
                 }
             } else if (event == XmlPullParser.END_TAG) {
                 final String tag = parser.getName();
                 if (TAG_KEYBOARD.equals(tag)) {
-                    endKeyboard(mKeyboard.getVerticalGap());
+                    endKeyboard();
                     break;
                 } else if (TAG_CASE.equals(tag) || TAG_DEFAULT.equals(tag)
                         || TAG_MERGE.equals(tag)) {
@@ -296,28 +312,28 @@
                 throw new IllegalAttribute(parser, "horizontalGap");
             if (a.hasValue(R.styleable.Keyboard_verticalGap))
                 throw new IllegalAttribute(parser, "verticalGap");
-            return new Row(mResources, mKeyboard, parser);
+            return new Row(mResources, mParams, parser);
         } finally {
             a.recycle();
         }
     }
 
-    private void parseRowContent(XmlResourceParser parser, Row row, List<Key> keys)
+    private void parseRowContent(XmlResourceParser parser, Row row, boolean skip)
             throws XmlPullParserException, IOException {
         int event;
         while ((event = parser.next()) != XmlPullParser.END_DOCUMENT) {
             if (event == XmlPullParser.START_TAG) {
                 final String tag = parser.getName();
                 if (TAG_KEY.equals(tag)) {
-                    parseKey(parser, row, keys);
+                    parseKey(parser, row, skip);
                 } else if (TAG_SPACER.equals(tag)) {
-                    parseSpacer(parser, row, keys);
+                    parseSpacer(parser, row, skip);
                 } else if (TAG_INCLUDE.equals(tag)) {
-                    parseIncludeRowContent(parser, row, keys);
+                    parseIncludeRowContent(parser, row, skip);
                 } else if (TAG_SWITCH.equals(tag)) {
-                    parseSwitchRowContent(parser, row, keys);
+                    parseSwitchRowContent(parser, row, skip);
                 } else if (TAG_KEY_STYLE.equals(tag)) {
-                    parseKeyStyle(parser, keys);
+                    parseKeyStyle(parser, skip);
                 } else {
                     throw new IllegalStartTag(parser, TAG_KEY);
                 }
@@ -325,7 +341,7 @@
                 final String tag = parser.getName();
                 if (TAG_ROW.equals(tag)) {
                     if (DEBUG) Log.d(TAG, String.format("</%s>", TAG_ROW));
-                    if (keys != null)
+                    if (!skip)
                         endRow();
                     break;
                 } else if (TAG_CASE.equals(tag) || TAG_DEFAULT.equals(tag)
@@ -341,24 +357,24 @@
         }
     }
 
-    private void parseKey(XmlResourceParser parser, Row row, List<Key> keys)
+    private void parseKey(XmlResourceParser parser, Row row, boolean skip)
             throws XmlPullParserException, IOException {
-        if (keys == null) {
+        if (skip) {
             checkEndTag(TAG_KEY, parser);
         } else {
-            Key key = new Key(mResources, row, mCurrentX, mCurrentY, parser, mKeyStyles);
+            Key key = new Key(mResources, mParams, row, mCurrentX, mCurrentY, parser, mKeyStyles);
             if (DEBUG) Log.d(TAG, String.format("<%s%s keyLabel=%s code=%d popupCharacters=%s />",
                     TAG_KEY, (key.isEnabled() ? "" : " disabled"), key.mLabel, key.mCode,
                     Arrays.toString(key.mPopupCharacters)));
             checkEndTag(TAG_KEY, parser);
-            keys.add(key);
+            mParams.onAddKey(key);
             endKey(key);
         }
     }
 
-    private void parseSpacer(XmlResourceParser parser, Row row, List<Key> keys)
+    private void parseSpacer(XmlResourceParser parser, Row row, boolean skip)
             throws XmlPullParserException, IOException {
-        if (keys == null) {
+        if (skip) {
             checkEndTag(TAG_SPACER, parser);
         } else {
             if (DEBUG) Log.d(TAG, String.format("<%s />", TAG_SPACER));
@@ -366,9 +382,9 @@
                     R.styleable.Keyboard);
             if (keyboardAttr.hasValue(R.styleable.Keyboard_horizontalGap))
                 throw new IllegalAttribute(parser, "horizontalGap");
-            final int keyboardWidth = mKeyboard.getDisplayWidth();
+            final int keyboardWidth = mParams.mWidth;
             final int keyWidth = getDimensionOrFraction(keyboardAttr, R.styleable.Keyboard_keyWidth,
-                    keyboardWidth, row.mDefaultWidth);
+                    keyboardWidth, row.mDefaultKeyWidth);
             keyboardAttr.recycle();
 
             final TypedArray keyAttr = mResources.obtainAttributes(Xml.asAttributeSet(parser),
@@ -385,19 +401,19 @@
         }
     }
 
-    private void parseIncludeKeyboardContent(XmlResourceParser parser, List<Key> keys)
+    private void parseIncludeKeyboardContent(XmlResourceParser parser, boolean skip)
             throws XmlPullParserException, IOException {
-        parseIncludeInternal(parser, null, keys);
+        parseIncludeInternal(parser, null, skip);
     }
 
-    private void parseIncludeRowContent(XmlResourceParser parser, Row row, List<Key> keys)
+    private void parseIncludeRowContent(XmlResourceParser parser, Row row, boolean skip)
             throws XmlPullParserException, IOException {
-        parseIncludeInternal(parser, row, keys);
+        parseIncludeInternal(parser, row, skip);
     }
 
-    private void parseIncludeInternal(XmlResourceParser parser, Row row, List<Key> keys)
+    private void parseIncludeInternal(XmlResourceParser parser, Row row, boolean skip)
             throws XmlPullParserException, IOException {
-        if (keys == null) {
+        if (skip) {
             checkEndTag(TAG_INCLUDE, parser);
         } else {
             final TypedArray a = mResources.obtainAttributes(Xml.asAttributeSet(parser),
@@ -411,11 +427,11 @@
                 throw new ParseException("No keyboardLayout attribute in <include/>", parser);
             if (DEBUG) Log.d(TAG, String.format("<%s keyboardLayout=%s />",
                     TAG_INCLUDE, mResources.getResourceEntryName(keyboardLayout)));
-            parseMerge(mResources.getLayout(keyboardLayout), row, keys);
+            parseMerge(mResources.getLayout(keyboardLayout), row, skip);
         }
     }
 
-    private void parseMerge(XmlResourceParser parser, Row row, List<Key> keys)
+    private void parseMerge(XmlResourceParser parser, Row row, boolean skip)
             throws XmlPullParserException, IOException {
         int event;
         while ((event = parser.next()) != XmlPullParser.END_DOCUMENT) {
@@ -423,9 +439,9 @@
                 final String tag = parser.getName();
                 if (TAG_MERGE.equals(tag)) {
                     if (row == null) {
-                        parseKeyboardContent(parser, keys);
+                        parseKeyboardContent(parser, skip);
                     } else {
-                        parseRowContent(parser, row, keys);
+                        parseRowContent(parser, row, skip);
                     }
                     break;
                 } else {
@@ -436,28 +452,28 @@
         }
     }
 
-    private void parseSwitchKeyboardContent(XmlResourceParser parser, List<Key> keys)
+    private void parseSwitchKeyboardContent(XmlResourceParser parser, boolean skip)
             throws XmlPullParserException, IOException {
-        parseSwitchInternal(parser, null, keys);
+        parseSwitchInternal(parser, null, skip);
     }
 
-    private void parseSwitchRowContent(XmlResourceParser parser, Row row, List<Key> keys)
+    private void parseSwitchRowContent(XmlResourceParser parser, Row row, boolean skip)
             throws XmlPullParserException, IOException {
-        parseSwitchInternal(parser, row, keys);
+        parseSwitchInternal(parser, row, skip);
     }
 
-    private void parseSwitchInternal(XmlResourceParser parser, Row row, List<Key> keys)
+    private void parseSwitchInternal(XmlResourceParser parser, Row row, boolean skip)
             throws XmlPullParserException, IOException {
-        if (DEBUG) Log.d(TAG, String.format("<%s> %s", TAG_SWITCH, mKeyboard.mId));
+        if (DEBUG) Log.d(TAG, String.format("<%s> %s", TAG_SWITCH, mParams.mId));
         boolean selected = false;
         int event;
         while ((event = parser.next()) != XmlPullParser.END_DOCUMENT) {
             if (event == XmlPullParser.START_TAG) {
                 final String tag = parser.getName();
                 if (TAG_CASE.equals(tag)) {
-                    selected |= parseCase(parser, row, selected ? null : keys);
+                    selected |= parseCase(parser, row, selected ? true : skip);
                 } else if (TAG_DEFAULT.equals(tag)) {
-                    selected |= parseDefault(parser, row, selected ? null : keys);
+                    selected |= parseDefault(parser, row, selected ? true : skip);
                 } else {
                     throw new IllegalStartTag(parser, TAG_KEY);
                 }
@@ -473,21 +489,21 @@
         }
     }
 
-    private boolean parseCase(XmlResourceParser parser, Row row, List<Key> keys)
+    private boolean parseCase(XmlResourceParser parser, Row row, boolean skip)
             throws XmlPullParserException, IOException {
         final boolean selected = parseCaseCondition(parser);
         if (row == null) {
             // Processing Rows.
-            parseKeyboardContent(parser, selected ? keys : null);
+            parseKeyboardContent(parser, selected ? skip : true);
         } else {
             // Processing Keys.
-            parseRowContent(parser, row, selected ? keys : null);
+            parseRowContent(parser, row, selected ? skip : true);
         }
         return selected;
     }
 
     private boolean parseCaseCondition(XmlResourceParser parser) {
-        final KeyboardId id = mKeyboard.mId;
+        final KeyboardId id = mParams.mId;
         if (id == null)
             return true;
 
@@ -596,18 +612,18 @@
         return false;
     }
 
-    private boolean parseDefault(XmlResourceParser parser, Row row, List<Key> keys)
+    private boolean parseDefault(XmlResourceParser parser, Row row, boolean skip)
             throws XmlPullParserException, IOException {
         if (DEBUG) Log.d(TAG, String.format("<%s>", TAG_DEFAULT));
         if (row == null) {
-            parseKeyboardContent(parser, keys);
+            parseKeyboardContent(parser, skip);
         } else {
-            parseRowContent(parser, row, keys);
+            parseRowContent(parser, row, skip);
         }
         return true;
     }
 
-    private void parseKeyStyle(XmlResourceParser parser, List<Key> keys) {
+    private void parseKeyStyle(XmlResourceParser parser, boolean skip) {
         TypedArray keyStyleAttr = mResources.obtainAttributes(Xml.asAttributeSet(parser),
                 R.styleable.Keyboard_KeyStyle);
         TypedArray keyAttrs = mResources.obtainAttributes(Xml.asAttributeSet(parser),
@@ -616,7 +632,7 @@
             if (!keyStyleAttr.hasValue(R.styleable.Keyboard_KeyStyle_styleName))
                 throw new ParseException("<" + TAG_KEY_STYLE
                         + "/> needs styleName attribute", parser);
-            if (keys != null)
+            if (!skip)
                 mKeyStyles.parseKeyStyleAttributes(keyStyleAttr, keyAttrs, parser);
         } finally {
             keyStyleAttr.recycle();
@@ -632,12 +648,12 @@
     }
 
     private void startKeyboard() {
-        mCurrentY += mKeyboardTopPadding;
+        mCurrentY += mParams.mTopPadding;
     }
 
     private void startRow(Row row) {
         mCurrentX = 0;
-        setSpacer(mCurrentX, mHorizontalEdgesPadding);
+        setSpacer(mCurrentX, mParams.mHorizontalEdgesPadding);
         mCurrentRow = row;
         mLeftEdge = true;
         mRightEdgeKey = null;
@@ -650,10 +666,8 @@
             mRightEdgeKey.addEdgeFlags(Keyboard.EDGE_RIGHT);
             mRightEdgeKey = null;
         }
-        setSpacer(mCurrentX, mHorizontalEdgesPadding);
-        if (mCurrentX > mMaxRowWidth)
-            mMaxRowWidth = mCurrentX;
-        mCurrentY += mCurrentRow.mDefaultHeight;
+        setSpacer(mCurrentX, mParams.mHorizontalEdgesPadding);
+        mCurrentY += mCurrentRow.mRowHeight;
         mCurrentRow = null;
     }
 
@@ -666,9 +680,7 @@
         mRightEdgeKey = key;
     }
 
-    private void endKeyboard(int defaultVerticalGap) {
-        mCurrentY += mKeyboardBottomPadding;
-        mTotalHeight = mCurrentY - defaultVerticalGap;
+    private void endKeyboard() {
     }
 
     private void setSpacer(int keyXPos, int width) {
diff --git a/java/src/com/android/inputmethod/keyboard/internal/MiniKeyboardBuilder.java b/java/src/com/android/inputmethod/keyboard/internal/MiniKeyboardBuilder.java
index 58862f8..bad7a17 100644
--- a/java/src/com/android/inputmethod/keyboard/internal/MiniKeyboardBuilder.java
+++ b/java/src/com/android/inputmethod/keyboard/internal/MiniKeyboardBuilder.java
@@ -16,8 +16,6 @@
 
 package com.android.inputmethod.keyboard.internal;
 
-import android.content.Context;
-import android.content.res.Resources;
 import android.graphics.Paint;
 import android.graphics.Rect;
 
@@ -27,26 +25,30 @@
 import com.android.inputmethod.keyboard.MiniKeyboard;
 import com.android.inputmethod.latin.R;
 
-import java.util.List;
-
-public class MiniKeyboardBuilder {
-    private final Resources mRes;
-    private final MiniKeyboard mKeyboard;
+public class MiniKeyboardBuilder extends
+        KeyboardParser<MiniKeyboardBuilder.MiniKeyboardLayoutParams> {
     private final CharSequence[] mPopupCharacters;
-    private final MiniKeyboardLayoutParams mParams;
 
-    /* package */ static class MiniKeyboardLayoutParams {
-        public final int mKeyWidth;
-        public final int mRowHeight;
-        /* package */ final int mTopRowAdjustment;
-        public final int mNumRows;
-        public final int mNumColumns;
-        public final int mLeftKeys;
-        public final int mRightKeys; // includes default key.
-        public int mTopPadding;
+    public static class MiniKeyboardLayoutParams extends KeyboardParams {
+        /* package */ int mTopRowAdjustment;
+        public int mNumRows;
+        public int mNumColumns;
+        public int mLeftKeys;
+        public int mRightKeys; // includes default key.
+
+        public MiniKeyboardLayoutParams() {
+            super();
+        }
+
+        /* package for test */ MiniKeyboardLayoutParams(int numKeys, int maxColumns, int keyWidth,
+                int rowHeight, int coordXInParent, int parentKeyboardWidth) {
+            super();
+            setParameters(
+                    numKeys, maxColumns, keyWidth, rowHeight, coordXInParent, parentKeyboardWidth);
+        }
 
         /**
-         * The object holding mini keyboard layout parameters.
+         * Set keyboard parameters of mini keyboard.
          *
          * @param numKeys number of keys in this mini keyboard.
          * @param maxColumns number of maximum columns of this mini keyboard.
@@ -54,15 +56,15 @@
          * @param rowHeight mini keyboard row height in pixel, including vertical gap.
          * @param coordXInParent coordinate x of the popup key in parent keyboard.
          * @param parentKeyboardWidth parent keyboard width in pixel.
-         * parent keyboard.
          */
-        public MiniKeyboardLayoutParams(int numKeys, int maxColumns, int keyWidth, int rowHeight,
+        public void setParameters(int numKeys, int maxColumns, int keyWidth, int rowHeight,
                 int coordXInParent, int parentKeyboardWidth) {
-            if (parentKeyboardWidth / keyWidth < maxColumns)
+            if (parentKeyboardWidth / keyWidth < maxColumns) {
                 throw new IllegalArgumentException("Keyboard is too small to hold mini keyboard: "
                         + parentKeyboardWidth + " " + keyWidth + " " + maxColumns);
-            mKeyWidth = keyWidth;
-            mRowHeight = rowHeight;
+            }
+            mDefaultKeyWidth = keyWidth;
+            mDefaultRowHeight = rowHeight;
 
             final int numRows = (numKeys + maxColumns - 1) / maxColumns;
             mNumRows = numRows;
@@ -108,6 +110,9 @@
             } else {
                 mTopRowAdjustment = -1;
             }
+
+            mWidth = mOccupiedWidth = mNumColumns * mDefaultKeyWidth;
+            mHeight = mOccupiedHeight = mNumRows * mDefaultRowHeight + mVerticalGap;
         }
 
         // Return key position according to column count (0 is default).
@@ -160,19 +165,19 @@
         }
 
         public int getDefaultKeyCoordX() {
-            return mLeftKeys * mKeyWidth;
+            return mLeftKeys * mDefaultKeyWidth;
         }
 
         public int getX(int n, int row) {
-            final int x = getColumnPos(n) * mKeyWidth + getDefaultKeyCoordX();
+            final int x = getColumnPos(n) * mDefaultKeyWidth + getDefaultKeyCoordX();
             if (isTopRow(row)) {
-                return x + mTopRowAdjustment * (mKeyWidth / 2);
+                return x + mTopRowAdjustment * (mDefaultKeyWidth / 2);
             }
             return x;
         }
 
         public int getY(int row) {
-            return (mNumRows - 1 - row) * mRowHeight + mTopPadding;
+            return (mNumRows - 1 - row) * mDefaultRowHeight + mTopPadding;
         }
 
         public int getRowFlags(int row) {
@@ -185,42 +190,32 @@
         private boolean isTopRow(int rowCount) {
             return rowCount == mNumRows - 1;
         }
-
-        public void setTopPadding (int topPadding) {
-            mTopPadding = topPadding;
-        }
-
-        public int getKeyboardHeight() {
-            return mNumRows * mRowHeight + mTopPadding;
-        }
-
-        public int getKeyboardWidth() {
-            return mNumColumns * mKeyWidth;
-        }
     }
 
-    public MiniKeyboardBuilder(KeyboardView view, int layoutTemplateResId, Key parentKey,
+    public MiniKeyboardBuilder(KeyboardView view, int xmlId, Key parentKey,
             Keyboard parentKeyboard) {
-        final Context context = view.getContext();
-        mRes = context.getResources();
-        final MiniKeyboard keyboard = new MiniKeyboard(
-                context, layoutTemplateResId, parentKeyboard);
-        mKeyboard = keyboard;
+        super(view.getContext(), new MiniKeyboardLayoutParams());
+        load(parentKeyboard.mId.cloneWithNewXml(mResources.getResourceEntryName(xmlId), xmlId));
+
+        // HACK: Current mini keyboard design totally relies on the 9-patch padding about horizontal
+        // and vertical key spacing. To keep the visual of mini keyboard as is, these hacks are
+        // needed to keep having the same horizontal and vertical key spacing.
+        mParams.mHorizontalGap = 0;
+        mParams.mVerticalGap = mParams.mTopPadding = parentKeyboard.mVerticalGap / 2;
+        // TODO: When we have correctly padded key background 9-patch drawables for mini keyboard,
+        // revert the above hacks and uncomment the following lines.
+        //mParams.mHorizontalGap = parentKeyboard.mHorizontalGap;
+        //mParams.mVerticalGap = parentKeyboard.mVerticalGap;
+
+        mParams.mIsRtlKeyboard = parentKeyboard.mIsRtlKeyboard;
         mPopupCharacters = parentKey.mPopupCharacters;
 
-        final int keyWidth = getMaxKeyWidth(view, mPopupCharacters, keyboard.getKeyWidth());
-        final MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(
+        final int keyWidth = getMaxKeyWidth(view, mPopupCharacters, mParams.mDefaultKeyWidth);
+        mParams.setParameters(
                 mPopupCharacters.length, parentKey.mMaxPopupColumn,
-                keyWidth, parentKeyboard.getRowHeight(),
-                parentKey.mX + (parentKey.mWidth + parentKey.mHorizontalGap) / 2 - keyWidth / 2,
+                keyWidth, parentKeyboard.mDefaultRowHeight,
+                parentKey.mX + (mParams.mDefaultKeyWidth - keyWidth) / 2,
                 view.getMeasuredWidth());
-        params.setTopPadding(keyboard.getVerticalGap());
-        mParams = params;
-
-        keyboard.setRowHeight(params.mRowHeight);
-        keyboard.setKeyboardHeight(params.getKeyboardHeight());
-        keyboard.setMinWidth(params.getKeyboardWidth());
-        keyboard.setDefaultCoordX(params.getDefaultKeyCoordX() + params.mKeyWidth / 2);
     }
 
     private static int getMaxKeyWidth(KeyboardView view, CharSequence[] popupCharacters,
@@ -249,17 +244,16 @@
         return Math.max(minKeyWidth, maxWidth + horizontalPadding);
     }
 
+    @Override
     public MiniKeyboard build() {
-        final MiniKeyboard keyboard = mKeyboard;
-        final List<Key> keys = keyboard.getKeys();
         final MiniKeyboardLayoutParams params = mParams;
         for (int n = 0; n < mPopupCharacters.length; n++) {
             final CharSequence label = mPopupCharacters[n];
             final int row = n / params.mNumColumns;
-            final Key key = new Key(mRes, keyboard, label, params.getX(n, row), params.getY(row),
-                    params.mKeyWidth, params.mRowHeight, params.getRowFlags(row));
-            keys.add(key);
+            final Key key = new Key(mResources, params, label, params.getX(n, row), params.getY(row),
+                    params.mDefaultKeyWidth, params.mDefaultRowHeight, params.getRowFlags(row));
+            params.onAddKey(key);
         }
-        return keyboard;
+        return new MiniKeyboard(params);
     }
 }
diff --git a/java/src/com/android/inputmethod/keyboard/internal/Row.java b/java/src/com/android/inputmethod/keyboard/internal/Row.java
index 34b8d91..9299cc2 100644
--- a/java/src/com/android/inputmethod/keyboard/internal/Row.java
+++ b/java/src/com/android/inputmethod/keyboard/internal/Row.java
@@ -31,26 +31,19 @@
  */
 public class Row {
     /** Default width of a key in this row. */
-    public final int mDefaultWidth;
+    public final int mDefaultKeyWidth;
     /** Default height of a key in this row. */
-    public final int mDefaultHeight;
+    public final int mRowHeight;
 
-    private final Keyboard mKeyboard;
-
-    public Row(Resources res, Keyboard keyboard, XmlResourceParser parser) {
-        this.mKeyboard = keyboard;
-        final int keyboardWidth = keyboard.getDisplayWidth();
-        final int keyboardHeight = keyboard.getKeyboardHeight();
+    public Row(Resources res, KeyboardParams params, XmlResourceParser parser) {
+        final int keyboardWidth = params.mWidth;
+        final int keyboardHeight = params.mHeight;
         TypedArray a = res.obtainAttributes(Xml.asAttributeSet(parser),
                 R.styleable.Keyboard);
-        mDefaultWidth = KeyboardParser.getDimensionOrFraction(a,
-                R.styleable.Keyboard_keyWidth, keyboardWidth, keyboard.getKeyWidth());
-        mDefaultHeight = KeyboardParser.getDimensionOrFraction(a,
-                R.styleable.Keyboard_rowHeight, keyboardHeight, keyboard.getRowHeight());
+        mDefaultKeyWidth = KeyboardParser.getDimensionOrFraction(a,
+                R.styleable.Keyboard_keyWidth, keyboardWidth, params.mDefaultKeyWidth);
+        mRowHeight = KeyboardParser.getDimensionOrFraction(a,
+                R.styleable.Keyboard_rowHeight, keyboardHeight, params.mDefaultRowHeight);
         a.recycle();
     }
-
-    public Keyboard getKeyboard() {
-        return mKeyboard;
-    }
 }
diff --git a/java/src/com/android/inputmethod/latin/LatinIME.java b/java/src/com/android/inputmethod/latin/LatinIME.java
index bdcbfbc..b2af6f9 100644
--- a/java/src/com/android/inputmethod/latin/LatinIME.java
+++ b/java/src/com/android/inputmethod/latin/LatinIME.java
@@ -1685,7 +1685,7 @@
             final int rawPrimaryCode = suggestion.charAt(0);
             // Maybe apply the "bidi mirrored" conversions for parentheses
             final LatinKeyboard keyboard = mKeyboardSwitcher.getLatinKeyboard();
-            final int primaryCode = keyboard.isRtlKeyboard()
+            final int primaryCode = keyboard.mIsRtlKeyboard
                     ? Key.getRtlParenthesisCode(rawPrimaryCode) : rawPrimaryCode;
 
             final CharSequence beforeText = ic != null ? ic.getTextBeforeCursor(1, 0) : "";