diff --git a/java/src/com/android/inputmethod/accessibility/AccessibleKeyboardViewProxy.java b/java/src/com/android/inputmethod/accessibility/AccessibleKeyboardViewProxy.java
index 3dca9aa..8185619 100644
--- a/java/src/com/android/inputmethod/accessibility/AccessibleKeyboardViewProxy.java
+++ b/java/src/com/android/inputmethod/accessibility/AccessibleKeyboardViewProxy.java
@@ -35,7 +35,7 @@
 import com.android.inputmethod.compat.MotionEventCompatUtils;
 import com.android.inputmethod.keyboard.Key;
 import com.android.inputmethod.keyboard.KeyDetector;
-import com.android.inputmethod.keyboard.LatinKeyboardBaseView;
+import com.android.inputmethod.keyboard.LatinKeyboardView;
 import com.android.inputmethod.keyboard.PointerTracker;
 
 public class AccessibleKeyboardViewProxy {
@@ -47,7 +47,7 @@
 
     private InputMethodService mInputMethod;
     private FlickGestureDetector mGestureDetector;
-    private LatinKeyboardBaseView mView;
+    private LatinKeyboardView mView;
     private AccessibleKeyboardActionListener mListener;
     private AudioManagerCompatWrapper mAudioManager;
 
@@ -65,7 +65,7 @@
         return sInstance;
     }
 
-    public static void setView(LatinKeyboardBaseView view) {
+    public static void setView(LatinKeyboardView view) {
         sInstance.mView = view;
     }
 
diff --git a/java/src/com/android/inputmethod/keyboard/KeyDetector.java b/java/src/com/android/inputmethod/keyboard/KeyDetector.java
index 0a3acb4..3298c41 100644
--- a/java/src/com/android/inputmethod/keyboard/KeyDetector.java
+++ b/java/src/com/android/inputmethod/keyboard/KeyDetector.java
@@ -91,6 +91,10 @@
         mProximityThresholdSquare = threshold * threshold;
     }
 
+    public boolean alwaysAllowsSlidingInput() {
+        return false;
+    }
+
     /**
      * Computes maximum size of the array that can contain all nearby key indices returned by
      * {@link #getKeyIndexAndNearbyCodes}.
diff --git a/java/src/com/android/inputmethod/keyboard/KeyboardSwitcher.java b/java/src/com/android/inputmethod/keyboard/KeyboardSwitcher.java
index ec19cce..8bf8280 100644
--- a/java/src/com/android/inputmethod/keyboard/KeyboardSwitcher.java
+++ b/java/src/com/android/inputmethod/keyboard/KeyboardSwitcher.java
@@ -61,7 +61,7 @@
     private SharedPreferences mPrefs;
 
     private View mCurrentInputView;
-    private LatinKeyboardBaseView mKeyboardView;
+    private LatinKeyboardView mKeyboardView;
     private LatinIME mInputMethodService;
     private String mPackageName;
     private Resources mResources;
@@ -745,7 +745,7 @@
         }
     }
 
-    public LatinKeyboardBaseView getKeyboardView() {
+    public LatinKeyboardView getKeyboardView() {
         return mKeyboardView;
     }
 
@@ -781,7 +781,7 @@
             }
         }
 
-        mKeyboardView = (LatinKeyboardBaseView) mCurrentInputView.findViewById(R.id.keyboard_view);
+        mKeyboardView = (LatinKeyboardView) mCurrentInputView.findViewById(R.id.keyboard_view);
         mKeyboardView.setKeyboardActionListener(mInputMethodService);
 
         // This always needs to be set since the accessibility state can
@@ -819,7 +819,7 @@
             final LatinKeyboard keyboard = getLatinKeyboard();
             if (keyboard != null && keyboard.needsAutoCorrectionSpacebarLed()) {
                 final Key invalidatedKey = keyboard.onAutoCorrectionStateChanged(isAutoCorrection);
-                final LatinKeyboardBaseView keyboardView = getKeyboardView();
+                final LatinKeyboardView keyboardView = getKeyboardView();
                 if (keyboardView != null)
                     keyboardView.invalidateKey(invalidatedKey);
             }
diff --git a/java/src/com/android/inputmethod/keyboard/LatinKeyboard.java b/java/src/com/android/inputmethod/keyboard/LatinKeyboard.java
index d31d3e3..1b6f57b 100644
--- a/java/src/com/android/inputmethod/keyboard/LatinKeyboard.java
+++ b/java/src/com/android/inputmethod/keyboard/LatinKeyboard.java
@@ -141,7 +141,7 @@
         }
     }
 
-    public void setSpacebarTextFadeFactor(float fadeFactor, LatinKeyboardBaseView view) {
+    public void setSpacebarTextFadeFactor(float fadeFactor, LatinKeyboardView view) {
         mSpacebarTextFadeFactor = fadeFactor;
         updateSpacebarForLocale(false);
         if (view != null)
@@ -154,7 +154,7 @@
         return newColor;
     }
 
-    public void updateShortcutKey(boolean available, LatinKeyboardBaseView view) {
+    public void updateShortcutKey(boolean available, LatinKeyboardView view) {
         if (mShortcutKey == null)
             return;
         mShortcutKey.setEnabled(available);
diff --git a/java/src/com/android/inputmethod/keyboard/LatinKeyboardBaseView.java b/java/src/com/android/inputmethod/keyboard/LatinKeyboardView.java
similarity index 97%
rename from java/src/com/android/inputmethod/keyboard/LatinKeyboardBaseView.java
rename to java/src/com/android/inputmethod/keyboard/LatinKeyboardView.java
index 4b85bcb..be04b5a 100644
--- a/java/src/com/android/inputmethod/keyboard/LatinKeyboardBaseView.java
+++ b/java/src/com/android/inputmethod/keyboard/LatinKeyboardView.java
@@ -38,7 +38,6 @@
 import com.android.inputmethod.deprecated.VoiceProxy;
 import com.android.inputmethod.keyboard.PointerTracker.DrawingProxy;
 import com.android.inputmethod.keyboard.PointerTracker.TimerProxy;
-import com.android.inputmethod.keyboard.internal.MiniKeyboardBuilder;
 import com.android.inputmethod.latin.LatinIME;
 import com.android.inputmethod.latin.R;
 import com.android.inputmethod.latin.StaticInnerHandlerWrapper;
@@ -53,9 +52,9 @@
  * @attr ref R.styleable#KeyboardView_verticalCorrection
  * @attr ref R.styleable#KeyboardView_popupLayout
  */
-public class LatinKeyboardBaseView extends KeyboardView implements PointerTracker.KeyEventHandler,
+public class LatinKeyboardView extends KeyboardView implements PointerTracker.KeyEventHandler,
         SuddenJumpingTouchEventHandler.ProcessMotionEvent {
-    private static final String TAG = LatinKeyboardBaseView.class.getSimpleName();
+    private static final String TAG = LatinKeyboardView.class.getSimpleName();
 
     private static final boolean ENABLE_CAPSLOCK_BY_DOUBLETAP = true;
 
@@ -89,7 +88,7 @@
 
     private final KeyTimerHandler mKeyTimerHandler = new KeyTimerHandler(this);
 
-    private static class KeyTimerHandler extends StaticInnerHandlerWrapper<LatinKeyboardBaseView>
+    private static class KeyTimerHandler extends StaticInnerHandlerWrapper<LatinKeyboardView>
             implements TimerProxy {
         private static final int MSG_REPEAT_KEY = 1;
         private static final int MSG_LONGPRESS_KEY = 2;
@@ -97,13 +96,13 @@
 
         private boolean mInKeyRepeat;
 
-        public KeyTimerHandler(LatinKeyboardBaseView outerInstance) {
+        public KeyTimerHandler(LatinKeyboardView outerInstance) {
             super(outerInstance);
         }
 
         @Override
         public void handleMessage(Message msg) {
-            final LatinKeyboardBaseView keyboardView = getOuterInstance();
+            final LatinKeyboardView keyboardView = getOuterInstance();
             final PointerTracker tracker = (PointerTracker) msg.obj;
             switch (msg.what) {
             case MSG_REPEAT_KEY:
@@ -209,11 +208,11 @@
         }
     }
 
-    public LatinKeyboardBaseView(Context context, AttributeSet attrs) {
+    public LatinKeyboardView(Context context, AttributeSet attrs) {
         this(context, attrs, R.attr.keyboardViewStyle);
     }
 
-    public LatinKeyboardBaseView(Context context, AttributeSet attrs, int defStyle) {
+    public LatinKeyboardView(Context context, AttributeSet attrs, int defStyle) {
         super(context, attrs, defStyle);
 
         mTouchScreenRegulator = new SuddenJumpingTouchEventHandler(getContext(), this);
@@ -374,7 +373,7 @@
         final PopupMiniKeyboardView miniKeyboardView =
                 (PopupMiniKeyboardView)container.findViewById(R.id.mini_keyboard_view);
         final Keyboard parentKeyboard = getKeyboard();
-        final Keyboard miniKeyboard = new MiniKeyboardBuilder(
+        final Keyboard miniKeyboard = new MiniKeyboard.Builder(
                 this, parentKeyboard.mPopupKeyboardResId, parentKey, parentKeyboard).build();
         miniKeyboardView.setKeyboard(miniKeyboard);
 
diff --git a/java/src/com/android/inputmethod/keyboard/MiniKeyboard.java b/java/src/com/android/inputmethod/keyboard/MiniKeyboard.java
index 08e7d7e..17c2539 100644
--- a/java/src/com/android/inputmethod/keyboard/MiniKeyboard.java
+++ b/java/src/com/android/inputmethod/keyboard/MiniKeyboard.java
@@ -16,12 +16,18 @@
 
 package com.android.inputmethod.keyboard;
 
-import com.android.inputmethod.keyboard.internal.MiniKeyboardBuilder.MiniKeyboardParams;
+import android.graphics.Paint;
+import android.graphics.Rect;
+
+import com.android.inputmethod.keyboard.internal.KeyboardBuilder;
+import com.android.inputmethod.keyboard.internal.KeyboardParams;
+import com.android.inputmethod.keyboard.internal.PopupCharactersParser;
+import com.android.inputmethod.latin.R;
 
 public class MiniKeyboard extends Keyboard {
     private final int mDefaultKeyCoordX;
 
-    public MiniKeyboard(MiniKeyboardParams params) {
+    private MiniKeyboard(Builder.MiniKeyboardParams params) {
         super(params);
         mDefaultKeyCoordX = params.getDefaultKeyCoordX() + params.mDefaultKeyWidth / 2;
     }
@@ -29,4 +35,244 @@
     public int getDefaultCoordX() {
         return mDefaultKeyCoordX;
     }
+
+    public static class Builder extends KeyboardBuilder<Builder.MiniKeyboardParams> {
+        private final CharSequence[] mPopupCharacters;
+
+        public static class MiniKeyboardParams extends KeyboardParams {
+            /* package */int mTopRowAdjustment;
+            public int mNumRows;
+            public int mNumColumns;
+            public int mLeftKeys;
+            public int mRightKeys; // includes default key.
+
+            public MiniKeyboardParams() {
+                super();
+            }
+
+            /* package for test */MiniKeyboardParams(int numKeys, int maxColumns, int keyWidth,
+                    int rowHeight, int coordXInParent, int parentKeyboardWidth) {
+                super();
+                setParameters(numKeys, maxColumns, keyWidth, rowHeight, coordXInParent,
+                        parentKeyboardWidth);
+            }
+
+            /**
+             * 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.
+             * @param keyWidth mini keyboard key width in pixel, including horizontal gap.
+             * @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.
+             */
+            public void setParameters(int numKeys, int maxColumns, int keyWidth, int rowHeight,
+                    int coordXInParent, int parentKeyboardWidth) {
+                if (parentKeyboardWidth / keyWidth < maxColumns) {
+                    throw new IllegalArgumentException(
+                            "Keyboard is too small to hold mini keyboard: " + parentKeyboardWidth
+                                    + " " + keyWidth + " " + maxColumns);
+                }
+                mDefaultKeyWidth = keyWidth;
+                mDefaultRowHeight = rowHeight;
+
+                final int numRows = (numKeys + maxColumns - 1) / maxColumns;
+                mNumRows = numRows;
+                final int numColumns = getOptimizedColumns(numKeys, maxColumns);
+                mNumColumns = numColumns;
+
+                final int numLeftKeys = (numColumns - 1) / 2;
+                final int numRightKeys = numColumns - numLeftKeys; // including default key.
+                final int maxLeftKeys = coordXInParent / keyWidth;
+                final int maxRightKeys = Math.max(1, (parentKeyboardWidth - coordXInParent)
+                        / keyWidth);
+                int leftKeys, rightKeys;
+                if (numLeftKeys > maxLeftKeys) {
+                    leftKeys = maxLeftKeys;
+                    rightKeys = numColumns - maxLeftKeys;
+                } else if (numRightKeys > maxRightKeys) {
+                    leftKeys = numColumns - maxRightKeys;
+                    rightKeys = maxRightKeys;
+                } else {
+                    leftKeys = numLeftKeys;
+                    rightKeys = numRightKeys;
+                }
+                // Shift right if the left edge of mini keyboard is on the edge of parent keyboard
+                // unless the parent key is on the left edge.
+                if (leftKeys * keyWidth >= coordXInParent && leftKeys > 0) {
+                    leftKeys--;
+                    rightKeys++;
+                }
+                // Shift left if the right edge of mini keyboard is on the edge of parent keyboard
+                // unless the parent key is on the right edge.
+                if (rightKeys * keyWidth + coordXInParent >= parentKeyboardWidth && rightKeys > 1) {
+                    leftKeys++;
+                    rightKeys--;
+                }
+                mLeftKeys = leftKeys;
+                mRightKeys = rightKeys;
+
+                // Centering of the top row.
+                final boolean onEdge = (leftKeys == 0 || rightKeys == 1);
+                if (numRows < 2 || onEdge || getTopRowEmptySlots(numKeys, numColumns) % 2 == 0) {
+                    mTopRowAdjustment = 0;
+                } else if (mLeftKeys < mRightKeys - 1) {
+                    mTopRowAdjustment = 1;
+                } else {
+                    mTopRowAdjustment = -1;
+                }
+
+                mWidth = mOccupiedWidth = mNumColumns * mDefaultKeyWidth;
+                mHeight = mOccupiedHeight = mNumRows * mDefaultRowHeight + mVerticalGap;
+            }
+
+            // Return key position according to column count (0 is default).
+            /* package */int getColumnPos(int n) {
+                final int col = n % mNumColumns;
+                if (col == 0) {
+                    // default position.
+                    return 0;
+                }
+                int pos = 0;
+                int right = 1; // include default position key.
+                int left = 0;
+                int i = 0;
+                while (true) {
+                    // Assign right key if available.
+                    if (right < mRightKeys) {
+                        pos = right;
+                        right++;
+                        i++;
+                    }
+                    if (i >= col)
+                        break;
+                    // Assign left key if available.
+                    if (left < mLeftKeys) {
+                        left++;
+                        pos = -left;
+                        i++;
+                    }
+                    if (i >= col)
+                        break;
+                }
+                return pos;
+            }
+
+            private static int getTopRowEmptySlots(int numKeys, int numColumns) {
+                final int remainingKeys = numKeys % numColumns;
+                if (remainingKeys == 0) {
+                    return 0;
+                } else {
+                    return numColumns - remainingKeys;
+                }
+            }
+
+            private int getOptimizedColumns(int numKeys, int maxColumns) {
+                int numColumns = Math.min(numKeys, maxColumns);
+                while (getTopRowEmptySlots(numKeys, numColumns) >= mNumRows) {
+                    numColumns--;
+                }
+                return numColumns;
+            }
+
+            public int getDefaultKeyCoordX() {
+                return mLeftKeys * mDefaultKeyWidth;
+            }
+
+            public int getX(int n, int row) {
+                final int x = getColumnPos(n) * mDefaultKeyWidth + getDefaultKeyCoordX();
+                if (isTopRow(row)) {
+                    return x + mTopRowAdjustment * (mDefaultKeyWidth / 2);
+                }
+                return x;
+            }
+
+            public int getY(int row) {
+                return (mNumRows - 1 - row) * mDefaultRowHeight + mTopPadding;
+            }
+
+            public int getRowFlags(int row) {
+                int rowFlags = 0;
+                if (row == 0)
+                    rowFlags |= Keyboard.EDGE_TOP;
+                if (isTopRow(row))
+                    rowFlags |= Keyboard.EDGE_BOTTOM;
+                return rowFlags;
+            }
+
+            private boolean isTopRow(int rowCount) {
+                return rowCount == mNumRows - 1;
+            }
+        }
+
+        public Builder(KeyboardView view, int xmlId, Key parentKey, Keyboard parentKeyboard) {
+            super(view.getContext(), new MiniKeyboardParams());
+            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, mParams.mDefaultKeyWidth);
+            mParams.setParameters(mPopupCharacters.length, parentKey.mMaxPopupColumn, keyWidth,
+                    parentKeyboard.mDefaultRowHeight, parentKey.mX
+                            + (mParams.mDefaultKeyWidth - keyWidth) / 2, view.getMeasuredWidth());
+        }
+
+        private static int getMaxKeyWidth(KeyboardView view, CharSequence[] popupCharacters,
+                int minKeyWidth) {
+            Paint paint = null;
+            Rect bounds = null;
+            int maxWidth = 0;
+            for (CharSequence popupSpec : popupCharacters) {
+                final CharSequence label = PopupCharactersParser.getLabel(popupSpec.toString());
+                // If the label is single letter, minKeyWidth is enough to hold
+                // the label.
+                if (label != null && label.length() > 1) {
+                    if (paint == null) {
+                        paint = new Paint();
+                        paint.setAntiAlias(true);
+                    }
+                    final int labelSize = view.getDefaultLabelSizeAndSetPaint(paint);
+                    paint.setTextSize(labelSize);
+                    if (bounds == null)
+                        bounds = new Rect();
+                    paint.getTextBounds(label.toString(), 0, label.length(), bounds);
+                    if (maxWidth < bounds.width())
+                        maxWidth = bounds.width();
+                }
+            }
+            final int horizontalPadding = (int) view.getContext().getResources()
+                    .getDimension(R.dimen.mini_keyboard_key_horizontal_padding);
+            return Math.max(minKeyWidth, maxWidth + horizontalPadding);
+        }
+
+        @Override
+        public MiniKeyboard build() {
+            final MiniKeyboardParams 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(mResources, params, label, params.getX(n, row),
+                        params.getY(row), params.mDefaultKeyWidth, params.mDefaultRowHeight,
+                        params.getRowFlags(row));
+                params.onAddKey(key);
+            }
+            return new MiniKeyboard(params);
+        }
+    }
 }
diff --git a/java/src/com/android/inputmethod/keyboard/MiniKeyboardKeyDetector.java b/java/src/com/android/inputmethod/keyboard/MiniKeyboardKeyDetector.java
deleted file mode 100644
index 84bd44c..0000000
--- a/java/src/com/android/inputmethod/keyboard/MiniKeyboardKeyDetector.java
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- * Copyright (C) 2010 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 java.util.List;
-
-public class MiniKeyboardKeyDetector extends KeyDetector {
-    private final int mSlideAllowanceSquare;
-    private final int mSlideAllowanceSquareTop;
-
-    public MiniKeyboardKeyDetector(float slideAllowance) {
-        super(/* keyHysteresisDistance */0);
-        mSlideAllowanceSquare = (int)(slideAllowance * slideAllowance);
-        // Top slide allowance is slightly longer (sqrt(2) times) than other edges.
-        mSlideAllowanceSquareTop = mSlideAllowanceSquare * 2;
-    }
-
-    @Override
-    protected int getMaxNearbyKeys() {
-        // No nearby key will be returned.
-        return 1;
-    }
-
-    @Override
-    public int getKeyIndexAndNearbyCodes(int x, int y, final int[] allCodes) {
-        final List<Key> keys = getKeyboard().mKeys;
-        final int touchX = getTouchX(x);
-        final int touchY = getTouchY(y);
-
-        int nearestIndex = NOT_A_KEY;
-        int nearestDist = (y < 0) ? mSlideAllowanceSquareTop : mSlideAllowanceSquare;
-        final int keyCount = keys.size();
-        for (int index = 0; index < keyCount; index++) {
-            final int dist = keys.get(index).squaredDistanceToEdge(touchX, touchY);
-            if (dist < nearestDist) {
-                nearestIndex = index;
-                nearestDist = dist;
-            }
-        }
-
-        if (allCodes != null && nearestIndex != NOT_A_KEY)
-            allCodes[0] = keys.get(nearestIndex).mCode;
-        return nearestIndex;
-    }
-}
diff --git a/java/src/com/android/inputmethod/keyboard/PointerTracker.java b/java/src/com/android/inputmethod/keyboard/PointerTracker.java
index 1f8119a..d33cb44 100644
--- a/java/src/com/android/inputmethod/keyboard/PointerTracker.java
+++ b/java/src/com/android/inputmethod/keyboard/PointerTracker.java
@@ -438,9 +438,9 @@
     private void onDownEventInternal(int x, int y, long eventTime) {
         int keyIndex = onDownKey(x, y, eventTime);
         // Sliding key is allowed when 1) enabled by configuration, 2) this pointer starts sliding
-        // from modifier key, or 3) this pointer is on mini-keyboard.
+        // from modifier key, or 3) this pointer's KeyDetector always allows sliding input.
         mIsAllowedSlidingKeyInput = sConfigSlidingKeyInputEnabled || isModifierInternal(keyIndex)
-                || mKeyDetector instanceof MiniKeyboardKeyDetector;
+                || mKeyDetector.alwaysAllowsSlidingInput();
         mKeyboardLayoutHasBeenChanged = false;
         mKeyAlreadyProcessed = false;
         mIsRepeatableKey = false;
diff --git a/java/src/com/android/inputmethod/keyboard/PopupMiniKeyboardView.java b/java/src/com/android/inputmethod/keyboard/PopupMiniKeyboardView.java
index fb932e3..2396222 100644
--- a/java/src/com/android/inputmethod/keyboard/PopupMiniKeyboardView.java
+++ b/java/src/com/android/inputmethod/keyboard/PopupMiniKeyboardView.java
@@ -28,6 +28,8 @@
 import com.android.inputmethod.keyboard.PointerTracker.TimerProxy;
 import com.android.inputmethod.latin.R;
 
+import java.util.List;
+
 /**
  * A view that renders a virtual {@link MiniKeyboard}. It handles rendering of keys and detecting
  * key presses and touch movements.
@@ -39,10 +41,55 @@
     private final KeyDetector mKeyDetector;
     private final int mVerticalCorrection;
 
-    private LatinKeyboardBaseView mParentKeyboardView;
+    private LatinKeyboardView mParentKeyboardView;
     private int mOriginX;
     private int mOriginY;
 
+    private static class MiniKeyboardKeyDetector extends KeyDetector {
+        private final int mSlideAllowanceSquare;
+        private final int mSlideAllowanceSquareTop;
+
+        public MiniKeyboardKeyDetector(float slideAllowance) {
+            super(/* keyHysteresisDistance */0);
+            mSlideAllowanceSquare = (int)(slideAllowance * slideAllowance);
+            // Top slide allowance is slightly longer (sqrt(2) times) than other edges.
+            mSlideAllowanceSquareTop = mSlideAllowanceSquare * 2;
+        }
+
+        @Override
+        public boolean alwaysAllowsSlidingInput() {
+            return true;
+        }
+
+        @Override
+        protected int getMaxNearbyKeys() {
+            // No nearby key will be returned.
+            return 1;
+        }
+
+        @Override
+        public int getKeyIndexAndNearbyCodes(int x, int y, final int[] allCodes) {
+            final List<Key> keys = getKeyboard().mKeys;
+            final int touchX = getTouchX(x);
+            final int touchY = getTouchY(y);
+
+            int nearestIndex = NOT_A_KEY;
+            int nearestDist = (y < 0) ? mSlideAllowanceSquareTop : mSlideAllowanceSquare;
+            final int keyCount = keys.size();
+            for (int index = 0; index < keyCount; index++) {
+                final int dist = keys.get(index).squaredDistanceToEdge(touchX, touchY);
+                if (dist < nearestDist) {
+                    nearestIndex = index;
+                    nearestDist = dist;
+                }
+            }
+
+            if (allCodes != null && nearestIndex != NOT_A_KEY)
+                allCodes[0] = keys.get(nearestIndex).mCode;
+            return nearestIndex;
+        }
+    }
+
     private static final TimerProxy EMPTY_TIMER_PROXY = new TimerProxy() {
         @Override
         public void startKeyRepeatTimer(long delay, int keyIndex, PointerTracker tracker) {}
@@ -146,11 +193,6 @@
     }
 
     @Override
-    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
-        // Do nothing for the mini keyboard.
-    }
-
-    @Override
     public void setKeyPreviewPopupEnabled(boolean previewEnabled, int delay) {
         // Mini keyboard needs no pop-up key preview displayed, so we pass always false with a
         // delay of 0. The delay does not matter actually since the popup is not shown anyway.
@@ -158,7 +200,7 @@
     }
 
     @Override
-    public void showPopupPanel(LatinKeyboardBaseView parentKeyboardView, Key parentKey,
+    public void showPopupPanel(LatinKeyboardView parentKeyboardView, Key parentKey,
             PointerTracker tracker, PopupWindow window) {
         mParentKeyboardView = parentKeyboardView;
         final View container = (View)getParent();
diff --git a/java/src/com/android/inputmethod/keyboard/PopupPanel.java b/java/src/com/android/inputmethod/keyboard/PopupPanel.java
index dc526e7..db637c5 100644
--- a/java/src/com/android/inputmethod/keyboard/PopupPanel.java
+++ b/java/src/com/android/inputmethod/keyboard/PopupPanel.java
@@ -26,7 +26,7 @@
      * @param tracker the pointer tracker that pressesd the parent key
      * @param window PopupWindow to be used to show this popup panel
      */
-    public void showPopupPanel(LatinKeyboardBaseView parentKeyboardView, Key parentKey,
+    public void showPopupPanel(LatinKeyboardView parentKeyboardView, Key parentKey,
             PointerTracker tracker, PopupWindow window);
 
     /**
diff --git a/java/src/com/android/inputmethod/keyboard/SuddenJumpingTouchEventHandler.java b/java/src/com/android/inputmethod/keyboard/SuddenJumpingTouchEventHandler.java
index 5344c27..c4251cc 100644
--- a/java/src/com/android/inputmethod/keyboard/SuddenJumpingTouchEventHandler.java
+++ b/java/src/com/android/inputmethod/keyboard/SuddenJumpingTouchEventHandler.java
@@ -78,7 +78,7 @@
      * the sudden moves subside, a DOWN event is simulated for the second key.
      * @param me the motion event
      * @return true if the event was consumed, so that it doesn't continue to be handled by
-     * {@link LatinKeyboardBaseView}.
+     * {@link LatinKeyboardView}.
      */
     private boolean handleSuddenJumping(MotionEvent me) {
         if (!mNeedsSuddenJumpingHack)
diff --git a/java/src/com/android/inputmethod/keyboard/internal/MiniKeyboardBuilder.java b/java/src/com/android/inputmethod/keyboard/internal/MiniKeyboardBuilder.java
deleted file mode 100644
index 31a291c..0000000
--- a/java/src/com/android/inputmethod/keyboard/internal/MiniKeyboardBuilder.java
+++ /dev/null
@@ -1,259 +0,0 @@
-/*
- * Copyright (C) 2010 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.internal;
-
-import android.graphics.Paint;
-import android.graphics.Rect;
-
-import com.android.inputmethod.keyboard.Key;
-import com.android.inputmethod.keyboard.Keyboard;
-import com.android.inputmethod.keyboard.KeyboardView;
-import com.android.inputmethod.keyboard.MiniKeyboard;
-import com.android.inputmethod.latin.R;
-
-public class MiniKeyboardBuilder extends
-        KeyboardBuilder<MiniKeyboardBuilder.MiniKeyboardParams> {
-    private final CharSequence[] mPopupCharacters;
-
-    public static class MiniKeyboardParams extends KeyboardParams {
-        /* package */ int mTopRowAdjustment;
-        public int mNumRows;
-        public int mNumColumns;
-        public int mLeftKeys;
-        public int mRightKeys; // includes default key.
-
-        public MiniKeyboardParams() {
-            super();
-        }
-
-        /* package for test */ MiniKeyboardParams(int numKeys, int maxColumns, int keyWidth,
-                int rowHeight, int coordXInParent, int parentKeyboardWidth) {
-            super();
-            setParameters(
-                    numKeys, maxColumns, keyWidth, rowHeight, coordXInParent, parentKeyboardWidth);
-        }
-
-        /**
-         * 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.
-         * @param keyWidth mini keyboard key width in pixel, including horizontal gap.
-         * @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.
-         */
-        public void setParameters(int numKeys, int maxColumns, int keyWidth, int rowHeight,
-                int coordXInParent, int parentKeyboardWidth) {
-            if (parentKeyboardWidth / keyWidth < maxColumns) {
-                throw new IllegalArgumentException("Keyboard is too small to hold mini keyboard: "
-                        + parentKeyboardWidth + " " + keyWidth + " " + maxColumns);
-            }
-            mDefaultKeyWidth = keyWidth;
-            mDefaultRowHeight = rowHeight;
-
-            final int numRows = (numKeys + maxColumns - 1) / maxColumns;
-            mNumRows = numRows;
-            final int numColumns = getOptimizedColumns(numKeys, maxColumns);
-            mNumColumns = numColumns;
-
-            final int numLeftKeys = (numColumns - 1) / 2;
-            final int numRightKeys = numColumns - numLeftKeys; // including default key.
-            final int maxLeftKeys = coordXInParent / keyWidth;
-            final int maxRightKeys = Math.max(1, (parentKeyboardWidth - coordXInParent) / keyWidth);
-            int leftKeys, rightKeys;
-            if (numLeftKeys > maxLeftKeys) {
-                leftKeys = maxLeftKeys;
-                rightKeys = numColumns - maxLeftKeys;
-            } else if (numRightKeys > maxRightKeys) {
-                leftKeys = numColumns - maxRightKeys;
-                rightKeys = maxRightKeys;
-            } else {
-                leftKeys = numLeftKeys;
-                rightKeys = numRightKeys;
-            }
-            // Shift right if the left edge of mini keyboard is on the edge of parent keyboard
-            // unless the parent key is on the left edge.
-            if (leftKeys * keyWidth >= coordXInParent && leftKeys > 0) {
-                leftKeys--;
-                rightKeys++;
-            }
-            // Shift left if the right edge of mini keyboard is on the edge of parent keyboard
-            // unless the parent key is on the right edge.
-            if (rightKeys * keyWidth + coordXInParent >= parentKeyboardWidth && rightKeys > 1) {
-                leftKeys++;
-                rightKeys--;
-            }
-            mLeftKeys = leftKeys;
-            mRightKeys = rightKeys;
-
-            // Centering of the top row.
-            final boolean onEdge = (leftKeys == 0 || rightKeys == 1);
-            if (numRows < 2 || onEdge || getTopRowEmptySlots(numKeys, numColumns) % 2 == 0) {
-                mTopRowAdjustment = 0;
-            } else if (mLeftKeys < mRightKeys - 1) {
-                mTopRowAdjustment = 1;
-            } else {
-                mTopRowAdjustment = -1;
-            }
-
-            mWidth = mOccupiedWidth = mNumColumns * mDefaultKeyWidth;
-            mHeight = mOccupiedHeight = mNumRows * mDefaultRowHeight + mVerticalGap;
-        }
-
-        // Return key position according to column count (0 is default).
-        /* package */ int getColumnPos(int n) {
-            final int col = n % mNumColumns;
-            if (col == 0) {
-                // default position.
-                return 0;
-            }
-            int pos = 0;
-            int right = 1; // include default position key.
-            int left = 0;
-            int i = 0;
-            while (true) {
-                // Assign right key if available.
-                if (right < mRightKeys) {
-                    pos = right;
-                    right++;
-                    i++;
-                }
-                if (i >= col)
-                    break;
-                // Assign left key if available.
-                if (left < mLeftKeys) {
-                    left++;
-                    pos = -left;
-                    i++;
-                }
-                if (i >= col)
-                    break;
-            }
-            return pos;
-        }
-
-        private static int getTopRowEmptySlots(int numKeys, int numColumns) {
-            final int remainingKeys = numKeys % numColumns;
-            if (remainingKeys == 0) {
-                return 0;
-            } else {
-                return numColumns - remainingKeys;
-            }
-        }
-
-        private int getOptimizedColumns(int numKeys, int maxColumns) {
-            int numColumns = Math.min(numKeys, maxColumns);
-            while (getTopRowEmptySlots(numKeys, numColumns) >= mNumRows) {
-                numColumns--;
-            }
-            return numColumns;
-        }
-
-        public int getDefaultKeyCoordX() {
-            return mLeftKeys * mDefaultKeyWidth;
-        }
-
-        public int getX(int n, int row) {
-            final int x = getColumnPos(n) * mDefaultKeyWidth + getDefaultKeyCoordX();
-            if (isTopRow(row)) {
-                return x + mTopRowAdjustment * (mDefaultKeyWidth / 2);
-            }
-            return x;
-        }
-
-        public int getY(int row) {
-            return (mNumRows - 1 - row) * mDefaultRowHeight + mTopPadding;
-        }
-
-        public int getRowFlags(int row) {
-            int rowFlags = 0;
-            if (row == 0) rowFlags |= Keyboard.EDGE_TOP;
-            if (isTopRow(row)) rowFlags |= Keyboard.EDGE_BOTTOM;
-            return rowFlags;
-        }
-
-        private boolean isTopRow(int rowCount) {
-            return rowCount == mNumRows - 1;
-        }
-    }
-
-    public MiniKeyboardBuilder(KeyboardView view, int xmlId, Key parentKey,
-            Keyboard parentKeyboard) {
-        super(view.getContext(), new MiniKeyboardParams());
-        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, mParams.mDefaultKeyWidth);
-        mParams.setParameters(
-                mPopupCharacters.length, parentKey.mMaxPopupColumn,
-                keyWidth, parentKeyboard.mDefaultRowHeight,
-                parentKey.mX + (mParams.mDefaultKeyWidth - keyWidth) / 2,
-                view.getMeasuredWidth());
-    }
-
-    private static int getMaxKeyWidth(KeyboardView view, CharSequence[] popupCharacters,
-            int minKeyWidth) {
-        Paint paint = null;
-        Rect bounds = null;
-        int maxWidth = 0;
-        for (CharSequence popupSpec : popupCharacters) {
-            final CharSequence label = PopupCharactersParser.getLabel(popupSpec.toString());
-            // If the label is single letter, minKeyWidth is enough to hold the label.
-            if (label != null && label.length() > 1) {
-                if (paint == null) {
-                    paint = new Paint();
-                    paint.setAntiAlias(true);
-                }
-                final int labelSize = view.getDefaultLabelSizeAndSetPaint(paint);
-                paint.setTextSize(labelSize);
-                if (bounds == null) bounds = new Rect();
-                paint.getTextBounds(label.toString(), 0, label.length(), bounds);
-                if (maxWidth < bounds.width())
-                    maxWidth = bounds.width();
-            }
-        }
-        final int horizontalPadding = (int)view.getContext().getResources().getDimension(
-                R.dimen.mini_keyboard_key_horizontal_padding);
-        return Math.max(minKeyWidth, maxWidth + horizontalPadding);
-    }
-
-    @Override
-    public MiniKeyboard build() {
-        final MiniKeyboardParams 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(mResources, params, label, params.getX(n, row), params.getY(row),
-                    params.mDefaultKeyWidth, params.mDefaultRowHeight, params.getRowFlags(row));
-            params.onAddKey(key);
-        }
-        return new MiniKeyboard(params);
-    }
-}
diff --git a/java/src/com/android/inputmethod/latin/LatinIME.java b/java/src/com/android/inputmethod/latin/LatinIME.java
index 48bcd3b..394414d 100644
--- a/java/src/com/android/inputmethod/latin/LatinIME.java
+++ b/java/src/com/android/inputmethod/latin/LatinIME.java
@@ -67,7 +67,7 @@
 import com.android.inputmethod.keyboard.KeyboardSwitcher.KeyboardLayoutState;
 import com.android.inputmethod.keyboard.KeyboardView;
 import com.android.inputmethod.keyboard.LatinKeyboard;
-import com.android.inputmethod.keyboard.LatinKeyboardBaseView;
+import com.android.inputmethod.keyboard.LatinKeyboardView;
 
 import java.io.FileDescriptor;
 import java.io.PrintWriter;
@@ -229,7 +229,7 @@
         public void handleMessage(Message msg) {
             final LatinIME latinIme = getOuterInstance();
             final KeyboardSwitcher switcher = latinIme.mKeyboardSwitcher;
-            final LatinKeyboardBaseView inputView = switcher.getKeyboardView();
+            final LatinKeyboardView inputView = switcher.getKeyboardView();
             switch (msg.what) {
             case MSG_UPDATE_SUGGESTIONS:
                 latinIme.updateSuggestions();
@@ -330,7 +330,7 @@
             final LatinIME latinIme = getOuterInstance();
             removeMessages(MSG_FADEOUT_LANGUAGE_ON_SPACEBAR);
             removeMessages(MSG_DISMISS_LANGUAGE_ON_SPACEBAR);
-            final LatinKeyboardBaseView inputView = latinIme.mKeyboardSwitcher.getKeyboardView();
+            final LatinKeyboardView inputView = latinIme.mKeyboardSwitcher.getKeyboardView();
             if (inputView != null) {
                 final LatinKeyboard keyboard = latinIme.mKeyboardSwitcher.getLatinKeyboard();
                 // The language is always displayed when the delay is negative.
@@ -610,7 +610,7 @@
         }
 
         final KeyboardSwitcher switcher = mKeyboardSwitcher;
-        LatinKeyboardBaseView inputView = switcher.getKeyboardView();
+        LatinKeyboardView inputView = switcher.getKeyboardView();
 
         if (DEBUG) {
             Log.d(TAG, "onStartInputView: attribute:" + ((attribute == null) ? "none"
@@ -1498,7 +1498,7 @@
         commitTyped(getCurrentInputConnection());
         mVoiceProxy.handleClose();
         requestHideSelf(0);
-        LatinKeyboardBaseView inputView = mKeyboardSwitcher.getKeyboardView();
+        LatinKeyboardView inputView = mKeyboardSwitcher.getKeyboardView();
         if (inputView != null)
             inputView.closing();
     }
@@ -2070,7 +2070,7 @@
         if (!mSettingsValues.mVibrateOn) {
             return;
         }
-        LatinKeyboardBaseView inputView = mKeyboardSwitcher.getKeyboardView();
+        LatinKeyboardView inputView = mKeyboardSwitcher.getKeyboardView();
         if (inputView != null) {
             inputView.performHapticFeedback(
                     HapticFeedbackConstants.KEYBOARD_TAP,
diff --git a/tests/src/com/android/inputmethod/keyboard/internal/MiniKeyboardBuilderTests.java b/tests/src/com/android/inputmethod/keyboard/MiniKeyboardBuilderTests.java
similarity index 99%
rename from tests/src/com/android/inputmethod/keyboard/internal/MiniKeyboardBuilderTests.java
rename to tests/src/com/android/inputmethod/keyboard/MiniKeyboardBuilderTests.java
index 1c5661b..a143bba 100644
--- a/tests/src/com/android/inputmethod/keyboard/internal/MiniKeyboardBuilderTests.java
+++ b/tests/src/com/android/inputmethod/keyboard/MiniKeyboardBuilderTests.java
@@ -14,9 +14,9 @@
  * the License.
  */
 
-package com.android.inputmethod.keyboard.internal;
+package com.android.inputmethod.keyboard;
 
-import com.android.inputmethod.keyboard.internal.MiniKeyboardBuilder.MiniKeyboardParams;
+import com.android.inputmethod.keyboard.MiniKeyboard.Builder.MiniKeyboardParams;
 
 import android.test.AndroidTestCase;