mKeys = new ArrayList<>();
+
+ /**
+ * Edge flags for this row of keys. Possible values that can be assigned are
+ * {@link Keyboard#EDGE_TOP EDGE_TOP} and {@link Keyboard#EDGE_BOTTOM EDGE_BOTTOM}
+ */
+ public int rowEdgeFlags;
+
+ /** The keyboard mode for this row */
+ public int mode;
+
+ private Keyboard parent;
+
+ public Row(Keyboard parent) {
+ this.parent = parent;
+ }
+
+ public Row(Resources res, Keyboard parent, XmlResourceParser parser) {
+ this.parent = parent;
+ TypedArray a = res.obtainAttributes(Xml.asAttributeSet(parser),
+ R.styleable.King_Keyboard);
+ defaultWidth = getDimensionOrFraction(a,
+ R.styleable.King_Keyboard_android_keyWidth,
+ parent.mDisplayWidth, parent.mDefaultWidth);
+ defaultHeight = getDimensionOrFraction(a,
+ R.styleable.King_Keyboard_android_keyHeight,
+ parent.mDisplayHeight, parent.mDefaultHeight);
+ defaultHorizontalGap = getDimensionOrFraction(a,
+ R.styleable.King_Keyboard_android_horizontalGap,
+ parent.mDisplayWidth, parent.mDefaultHorizontalGap);
+ verticalGap = getDimensionOrFraction(a,
+ R.styleable.King_Keyboard_android_verticalGap,
+ parent.mDisplayHeight, parent.mDefaultVerticalGap);
+ a.recycle();
+ a = res.obtainAttributes(Xml.asAttributeSet(parser),
+ R.styleable.King_Keyboard_Row);
+ rowEdgeFlags = a.getInt(R.styleable.King_Keyboard_Row_android_rowEdgeFlags, 0);
+ mode = a.getResourceId(R.styleable.King_Keyboard_Row_android_keyboardMode,
+ 0);
+ }
+ }
+
+ /**
+ * Class for describing the position and characteristics of a single key in the keyboard.
+ *
+ * @attr ref android.R.styleable#King_Keyboard_keyWidth
+ * @attr ref android.R.styleable#King_Keyboard_keyHeight
+ * @attr ref android.R.styleable#King_Keyboard_horizontalGap
+ * @attr ref android.R.styleable#King_Keyboard_Key_codes
+ * @attr ref android.R.styleable#King_Keyboard_Key_keyIcon
+ * @attr ref android.R.styleable#King_Keyboard_Key_keyLabel
+ * @attr ref android.R.styleable#King_Keyboard_Key_iconPreview
+ * @attr ref android.R.styleable#King_Keyboard_Key_isSticky
+ * @attr ref android.R.styleable#King_Keyboard_Key_isRepeatable
+ * @attr ref android.R.styleable#King_Keyboard_Key_isModifier
+ * @attr ref android.R.styleable#King_Keyboard_Key_popupKeyboard
+ * @attr ref android.R.styleable#King_Keyboard_Key_popupCharacters
+ * @attr ref android.R.styleable#King_Keyboard_Key_keyOutputText
+ * @attr ref android.R.styleable#King_Keyboard_Key_keyEdgeFlags
+ */
+ public static class Key {
+ /**
+ * All the key codes (unicode or custom code) that this key could generate, zero'th
+ * being the most important.
+ */
+ public int[] codes;
+
+ /** Label to display */
+ public CharSequence label;
+
+ /** Icon to display instead of a label. Icon takes precedence over a label */
+ public Drawable icon;
+ /** Preview version of the icon, for the preview popup */
+ public Drawable iconPreview;
+ /** Width of the key, not including the gap */
+ public int width;
+ /** Height of the key, not including the gap */
+ public int height;
+ /** The horizontal gap before this key */
+ public int gap;
+ /** Whether this key is sticky, i.e., a toggle key */
+ public boolean sticky;
+ /** X coordinate of the key in the keyboard layout */
+ public int x;
+ /** Y coordinate of the key in the keyboard layout */
+ public int y;
+ /** The current pressed state of this key */
+ public boolean pressed;
+ /** If this is a sticky key, is it on? */
+ public boolean on;
+ /** Text to output when pressed. This can be multiple characters, like ".com" */
+ public CharSequence text;
+ /** Popup characters */
+ public CharSequence popupCharacters;
+
+ /**
+ * Flags that specify the anchoring to edges of the keyboard for detecting touch events
+ * that are just out of the boundary of the key. This is a bit mask of
+ * {@link Keyboard#EDGE_LEFT}, {@link Keyboard#EDGE_RIGHT}, {@link Keyboard#EDGE_TOP} and
+ * {@link Keyboard#EDGE_BOTTOM}.
+ */
+ public int edgeFlags;
+ /** Whether this is a modifier key, such as Shift or Alt */
+ public boolean modifier;
+ /** The keyboard that this key belongs to */
+ private Keyboard keyboard;
+ /**
+ * If this key pops up a mini keyboard, this is the resource id for the XML layout for that
+ * keyboard.
+ */
+ public int popupResId;
+ /** Whether this key repeats itself when held down */
+ public boolean repeatable;
+
+
+ private final static int[] KEY_STATE_NORMAL_ON = {
+ android.R.attr.state_checkable,
+ android.R.attr.state_checked
+ };
+
+ private final static int[] KEY_STATE_PRESSED_ON = {
+ android.R.attr.state_pressed,
+ android.R.attr.state_checkable,
+ android.R.attr.state_checked
+ };
+
+ private final static int[] KEY_STATE_NORMAL_OFF = {
+ android.R.attr.state_checkable
+ };
+
+ private final static int[] KEY_STATE_PRESSED_OFF = {
+ android.R.attr.state_pressed,
+ android.R.attr.state_checkable
+ };
+
+ private final static int[] KEY_STATE_NORMAL = {
+ };
+
+ private final static int[] KEY_STATE_PRESSED = {
+ android.R.attr.state_pressed
+ };
+
+ /** Create an empty key with no attributes. */
+ public Key(Row parent) {
+ keyboard = parent.parent;
+ height = parent.defaultHeight;
+ width = parent.defaultWidth;
+ gap = parent.defaultHorizontalGap;
+ edgeFlags = parent.rowEdgeFlags;
+ }
+
+ /** 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 parent the row that this key belongs to. The row must already be attached to
+ * a {@link Keyboard}.
+ * @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
+ */
+ public Key(Resources res, Row parent, int x, int y, XmlResourceParser parser) {
+ this(parent);
+
+ this.x = x;
+ this.y = y;
+
+ TypedArray a = res.obtainAttributes(Xml.asAttributeSet(parser),
+ R.styleable.King_Keyboard);
+
+ width = getDimensionOrFraction(a,
+ R.styleable.King_Keyboard_android_keyWidth,
+ keyboard.mDisplayWidth, parent.defaultWidth);
+ height = getDimensionOrFraction(a,
+ R.styleable.King_Keyboard_android_keyHeight,
+ keyboard.mDisplayHeight, parent.defaultHeight);
+ gap = getDimensionOrFraction(a,
+ R.styleable.King_Keyboard_android_horizontalGap,
+ keyboard.mDisplayWidth, parent.defaultHorizontalGap);
+ a.recycle();
+ a = res.obtainAttributes(Xml.asAttributeSet(parser),
+ R.styleable.King_Keyboard_Key);
+ this.x += gap;
+ TypedValue codesValue = new TypedValue();
+ a.getValue(R.styleable.King_Keyboard_Key_android_codes,
+ codesValue);
+ if (codesValue.type == TypedValue.TYPE_INT_DEC
+ || codesValue.type == TypedValue.TYPE_INT_HEX) {
+ codes = new int[] { codesValue.data };
+ } else if (codesValue.type == TypedValue.TYPE_STRING) {
+ codes = parseCSV(codesValue.string.toString());
+ }
+
+ iconPreview = a.getDrawable(R.styleable.King_Keyboard_Key_android_iconPreview);
+ if (iconPreview != null) {
+ iconPreview.setBounds(0, 0, iconPreview.getIntrinsicWidth(),
+ iconPreview.getIntrinsicHeight());
+ }
+ popupCharacters = a.getText(
+ R.styleable.King_Keyboard_Key_android_popupCharacters);
+ popupResId = a.getResourceId(
+ R.styleable.King_Keyboard_Key_android_popupKeyboard, 0);
+ repeatable = a.getBoolean(
+ R.styleable.King_Keyboard_Key_android_isRepeatable, false);
+ modifier = a.getBoolean(
+ R.styleable.King_Keyboard_Key_android_isModifier, false);
+ sticky = a.getBoolean(
+ R.styleable.King_Keyboard_Key_android_isSticky, false);
+ edgeFlags = a.getInt(R.styleable.King_Keyboard_Key_android_keyEdgeFlags, 0);
+ edgeFlags |= parent.rowEdgeFlags;
+
+ icon = a.getDrawable(
+ R.styleable.King_Keyboard_Key_android_keyIcon);
+ if (icon != null) {
+ icon.setBounds(0, 0, icon.getIntrinsicWidth(), icon.getIntrinsicHeight());
+ }
+ label = a.getText(R.styleable.King_Keyboard_Key_android_keyLabel);
+ text = a.getText(R.styleable.King_Keyboard_Key_android_keyOutputText);
+
+ if (codes == null && !TextUtils.isEmpty(label)) {
+ codes = new int[] { label.charAt(0) };
+ }
+ a.recycle();
+ }
+
+ /**
+ * Informs the key that it has been pressed, in case it needs to change its appearance or
+ * state.
+ * @see #onReleased(boolean)
+ */
+ public void onPressed() {
+ pressed = !pressed;
+ }
+
+ /**
+ * Changes the pressed state of the key.
+ *
+ * Toggled state of the key will be flipped when all the following conditions are
+ * fulfilled:
+ *
+ *
+ * - This is a sticky key, that is, {@link #sticky} is {@code true}.
+ *
- The parameter {@code inside} is {@code true}.
+ *
- {@link android.os.Build.VERSION#SDK_INT} is greater than
+ * {@link android.os.Build.VERSION_CODES#LOLLIPOP_MR1}.
+ *
+ *
+ * @param inside whether the finger was released inside the key. Works only on Android M and
+ * later. See the method document for details.
+ * @see #onPressed()
+ */
+ public void onReleased(boolean inside) {
+ pressed = !pressed;
+ if (sticky && inside) {
+ on = !on;
+ }
+ }
+
+ int[] parseCSV(String value) {
+ int count = 0;
+ int lastIndex = 0;
+ if (value.length() > 0) {
+ count++;
+ while ((lastIndex = value.indexOf(",", lastIndex + 1)) > 0) {
+ count++;
+ }
+ }
+ int[] values = new int[count];
+ count = 0;
+ StringTokenizer st = new StringTokenizer(value, ",");
+ while (st.hasMoreTokens()) {
+ try {
+ values[count++] = Integer.parseInt(st.nextToken());
+ } catch (NumberFormatException nfe) {
+ Log.e(TAG, "Error parsing keycodes " + value);
+ }
+ }
+ return values;
+ }
+
+ /**
+ * Detects if a point falls inside this key.
+ * @param x the x-coordinate of the point
+ * @param y the y-coordinate of the point
+ * @return whether or not the point falls inside the key. If the key is attached to an edge,
+ * it will assume that all points between the key and the edge are considered to be inside
+ * the key.
+ */
+ public boolean isInside(int x, int y) {
+ boolean leftEdge = (edgeFlags & EDGE_LEFT) > 0;
+ boolean rightEdge = (edgeFlags & EDGE_RIGHT) > 0;
+ boolean topEdge = (edgeFlags & EDGE_TOP) > 0;
+ boolean bottomEdge = (edgeFlags & EDGE_BOTTOM) > 0;
+ if ((x >= this.x || (leftEdge && x <= this.x + this.width))
+ && (x < this.x + this.width || (rightEdge && x >= this.x))
+ && (y >= this.y || (topEdge && y <= this.y + this.height))
+ && (y < this.y + this.height || (bottomEdge && y >= this.y))) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ /**
+ * Returns the square of the distance between the center of the key and the given point.
+ * @param x the x-coordinate of the point
+ * @param y the y-coordinate of the point
+ * @return the square of the distance of the point from the center of the key
+ */
+ public int squaredDistanceFrom(int x, int y) {
+ int xDist = this.x + width / 2 - x;
+ int yDist = this.y + height / 2 - y;
+ return xDist * xDist + yDist * yDist;
+ }
+
+ /**
+ * Returns the drawable state for the key, based on the current state and type of the key.
+ * @return the drawable state of the key.
+ * @see android.graphics.drawable.StateListDrawable#setState(int[])
+ */
+ public int[] getCurrentDrawableState() {
+ int[] states = KEY_STATE_NORMAL;
+
+ if (on) {
+ if (pressed) {
+ states = KEY_STATE_PRESSED_ON;
+ } else {
+ states = KEY_STATE_NORMAL_ON;
+ }
+ } else {
+ if (sticky) {
+ if (pressed) {
+ states = KEY_STATE_PRESSED_OFF;
+ } else {
+ states = KEY_STATE_NORMAL_OFF;
+ }
+ } else {
+ if (pressed) {
+ states = KEY_STATE_PRESSED;
+ }
+ }
+ }
+ return states;
+ }
+ }
+
+ /**
+ * 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.
+ */
+ public Keyboard(Context context, int xmlLayoutResId) {
+ this(context, xmlLayoutResId, 0);
+ }
+
+ /**
+ * Creates a keyboard from the given xml key layout file. Weeds out rows
+ * that have a keyboard mode defined but don't match the specified mode.
+ * @param context the application or service context
+ * @param xmlLayoutResId the resource file that contains the keyboard layout and keys.
+ * @param modeId keyboard mode identifier
+ * @param width sets width of keyboard
+ * @param height sets height of keyboard
+ */
+ public Keyboard(Context context, @XmlRes int xmlLayoutResId, int modeId, int width,
+ int height) {
+ mDisplayWidth = width;
+ mDisplayHeight = height;
+
+ mDefaultHorizontalGap = 0;
+ mDefaultWidth = mDisplayWidth / 10;
+ mDefaultVerticalGap = 0;
+ mDefaultHeight = mDefaultWidth;
+ mKeys = new ArrayList<>();
+ mModifierKeys = new ArrayList<>();
+ mKeyboardMode = modeId;
+ loadKeyboard(context, context.getResources().getXml(xmlLayoutResId));
+ }
+
+ /**
+ * Creates a keyboard from the given xml key layout file. Weeds out rows
+ * that have a keyboard mode defined but don't match the specified mode.
+ * @param context the application or service context
+ * @param xmlLayoutResId the resource file that contains the keyboard layout and keys.
+ * @param modeId keyboard mode identifier
+ */
+ public Keyboard(Context context, @XmlRes int xmlLayoutResId, int modeId) {
+ DisplayMetrics dm = context.getResources().getDisplayMetrics();
+ mDisplayWidth = dm.widthPixels;
+ mDisplayHeight = dm.heightPixels;
+ //Log.v(TAG, "keyboard's display metrics:" + dm);
+
+ mDefaultHorizontalGap = 0;
+ mDefaultWidth = mDisplayWidth / 10;
+ mDefaultVerticalGap = 0;
+ mDefaultHeight = mDefaultWidth;
+ mKeys = new ArrayList<>();
+ mModifierKeys = new ArrayList<>();
+ mKeyboardMode = modeId;
+ loadKeyboard(context, context.getResources().getXml(xmlLayoutResId));
+ }
+
+ /**
+ * Creates a blank keyboard from the given resource file and populates it with the specified
+ * characters in left-to-right, top-to-bottom fashion, using the specified number of columns.
+ *
+ * If the specified number of columns is -1, then the keyboard will fit as many keys as
+ * possible in each row.
+ * @param context the application or service context
+ * @param layoutTemplateResId the layout template file, containing no keys.
+ * @param characters the list of characters to display on the keyboard. One key will be created
+ * for each character.
+ * @param columns the number of columns of keys to display. If this number is greater than the
+ * number of keys that can fit in a row, it will be ignored. If this number is -1, the
+ * keyboard will fit as many keys as possible in each row.
+ */
+ public Keyboard(Context context, int layoutTemplateResId,
+ CharSequence characters, int columns, int horizontalPadding) {
+ this(context, layoutTemplateResId);
+ int x = 0;
+ int y = 0;
+ int column = 0;
+ mTotalWidth = 0;
+
+ Row row = new Row(this);
+ row.defaultHeight = mDefaultHeight;
+ row.defaultWidth = mDefaultWidth;
+ row.defaultHorizontalGap = mDefaultHorizontalGap;
+ row.verticalGap = mDefaultVerticalGap;
+ row.rowEdgeFlags = EDGE_TOP | EDGE_BOTTOM;
+ final int maxColumns = columns == -1 ? Integer.MAX_VALUE : columns;
+ for (int i = 0; i < characters.length(); i++) {
+ char c = characters.charAt(i);
+ if (column >= maxColumns
+ || x + mDefaultWidth + horizontalPadding > mDisplayWidth) {
+ x = 0;
+ y += mDefaultVerticalGap + mDefaultHeight;
+ column = 0;
+ }
+ final Key key = new Key(row);
+ key.x = x;
+ key.y = y;
+ key.label = String.valueOf(c);
+ key.codes = new int[] { c };
+ column++;
+ x += key.width + key.gap;
+ mKeys.add(key);
+ row.mKeys.add(key);
+ if (x > mTotalWidth) {
+ mTotalWidth = x;
+ }
+ }
+ mTotalHeight = y + mDefaultHeight;
+ rows.add(row);
+ }
+
+ final void resize(int newWidth, int newHeight) {
+ int numRows = rows.size();
+ for (int rowIndex = 0; rowIndex < numRows; ++rowIndex) {
+ Row row = rows.get(rowIndex);
+ int numKeys = row.mKeys.size();
+ int totalGap = 0;
+ int totalWidth = 0;
+ for (int keyIndex = 0; keyIndex < numKeys; ++keyIndex) {
+ Key key = row.mKeys.get(keyIndex);
+ if (keyIndex > 0) {
+ totalGap += key.gap;
+ }
+ totalWidth += key.width;
+ }
+ if (totalGap + totalWidth > newWidth) {
+ int x = 0;
+ float scaleFactor = (float)(newWidth - totalGap) / totalWidth;
+ for (int keyIndex = 0; keyIndex < numKeys; ++keyIndex) {
+ Key key = row.mKeys.get(keyIndex);
+ key.width *= scaleFactor;
+ key.x = x;
+ x += key.width + key.gap;
+ }
+ }
+ }
+ mTotalWidth = newWidth;
+ // TODO: This does not adjust the vertical placement according to the new size.
+ // The main problem in the previous code was horizontal placement/size, but we should
+ // also recalculate the vertical sizes/positions when we get this resize call.
+ }
+
+ public List getKeys() {
+ return mKeys;
+ }
+
+ public List getModifierKeys() {
+ return mModifierKeys;
+ }
+
+ protected int getHorizontalGap() {
+ return mDefaultHorizontalGap;
+ }
+
+ protected void setHorizontalGap(int gap) {
+ mDefaultHorizontalGap = gap;
+ }
+
+ protected int getVerticalGap() {
+ return mDefaultVerticalGap;
+ }
+
+ protected void setVerticalGap(int gap) {
+ mDefaultVerticalGap = gap;
+ }
+
+ protected int getKeyHeight() {
+ return mDefaultHeight;
+ }
+
+ protected void setKeyHeight(int height) {
+ mDefaultHeight = height;
+ }
+
+ protected int getKeyWidth() {
+ return mDefaultWidth;
+ }
+
+ protected void setKeyWidth(int width) {
+ mDefaultWidth = width;
+ }
+
+ /**
+ * Returns the total height of the keyboard
+ * @return the total height of the keyboard
+ */
+ public int getHeight() {
+ return mTotalHeight;
+ }
+
+ public int getMinWidth() {
+ return mTotalWidth;
+ }
+
+ public boolean setShifted(boolean shiftState) {
+ for (Key shiftKey : mShiftKeys) {
+ if (shiftKey != null) {
+ shiftKey.on = shiftState;
+ }
+ }
+ if (mShifted != shiftState) {
+ mShifted = shiftState;
+ return true;
+ }
+ return false;
+ }
+
+ public boolean isShifted() {
+ return mShifted;
+ }
+
+ /**
+ * @hide
+ */
+ public int[] getShiftKeyIndices() {
+ return mShiftKeyIndices;
+ }
+
+ public int getShiftKeyIndex() {
+ return mShiftKeyIndices[0];
+ }
+
+ private void computeNearestNeighbors() {
+ // Round-up so we don't have any pixels outside the grid
+ mCellWidth = (getMinWidth() + GRID_WIDTH - 1) / GRID_WIDTH;
+ mCellHeight = (getHeight() + GRID_HEIGHT - 1) / GRID_HEIGHT;
+ mGridNeighbors = new int[GRID_SIZE][];
+ int[] indices = new int[mKeys.size()];
+ final int gridWidth = GRID_WIDTH * mCellWidth;
+ final int gridHeight = GRID_HEIGHT * mCellHeight;
+ for (int x = 0; x < gridWidth; x += mCellWidth) {
+ for (int y = 0; y < gridHeight; y += mCellHeight) {
+ int count = 0;
+ for (int i = 0; i < mKeys.size(); i++) {
+ final Key key = mKeys.get(i);
+ if (key.squaredDistanceFrom(x, y) < mProximityThreshold ||
+ key.squaredDistanceFrom(x + mCellWidth - 1, y) < mProximityThreshold ||
+ key.squaredDistanceFrom(x + mCellWidth - 1, y + mCellHeight - 1)
+ < mProximityThreshold ||
+ key.squaredDistanceFrom(x, y + mCellHeight - 1) < mProximityThreshold) {
+ indices[count++] = i;
+ }
+ }
+ int [] cell = new int[count];
+ System.arraycopy(indices, 0, cell, 0, count);
+ mGridNeighbors[(y / mCellHeight) * GRID_WIDTH + (x / mCellWidth)] = cell;
+ }
+ }
+ }
+
+ /**
+ * Returns the indices of the keys that are closest to the given point.
+ * @param x the x-coordinate of the point
+ * @param y the y-coordinate of the point
+ * @return the array of integer indices for the nearest keys to the given point. If the given
+ * point is out of range, then an array of size zero is returned.
+ */
+ public int[] getNearestKeys(int x, int y) {
+ if (mGridNeighbors == null) computeNearestNeighbors();
+ if (x >= 0 && x < getMinWidth() && y >= 0 && y < getHeight()) {
+ int index = (y / mCellHeight) * GRID_WIDTH + (x / mCellWidth);
+ if (index < GRID_SIZE) {
+ return mGridNeighbors[index];
+ }
+ }
+ return new int[0];
+ }
+
+ protected Row createRowFromXml(Resources res, XmlResourceParser parser) {
+ return new Row(res, this, parser);
+ }
+
+ protected Key createKeyFromXml(Resources res, Row parent, int x, int y,
+ XmlResourceParser parser) {
+ return new Key(res, parent, x, y, parser);
+ }
+
+ private void loadKeyboard(Context context, XmlResourceParser parser) {
+ boolean inKey = false;
+ boolean inRow = false;
+ boolean leftMostKey = false;
+ int row = 0;
+ int x = 0;
+ int y = 0;
+ Key key = null;
+ Row currentRow = null;
+ Resources res = context.getResources();
+ boolean skipRow = false;
+
+ try {
+ int event;
+ while ((event = parser.next()) != XmlResourceParser.END_DOCUMENT) {
+ if (event == XmlResourceParser.START_TAG) {
+ String tag = parser.getName();
+ if (TAG_ROW.equals(tag)) {
+ inRow = true;
+ x = 0;
+ currentRow = createRowFromXml(res, parser);
+ rows.add(currentRow);
+ skipRow = currentRow.mode != 0 && currentRow.mode != mKeyboardMode;
+ if (skipRow) {
+ skipToEndOfRow(parser);
+ inRow = false;
+ }
+ } else if (TAG_KEY.equals(tag)) {
+ inKey = true;
+ key = createKeyFromXml(res, currentRow, x, y, parser);
+ mKeys.add(key);
+ if (key.codes[0] == KEYCODE_SHIFT) {
+ // Find available shift key slot and put this shift key in it
+ for (int i = 0; i < mShiftKeys.length; i++) {
+ if (mShiftKeys[i] == null) {
+ mShiftKeys[i] = key;
+ mShiftKeyIndices[i] = mKeys.size()-1;
+ break;
+ }
+ }
+ mModifierKeys.add(key);
+ } else if (key.codes[0] == KEYCODE_ALT) {
+ mModifierKeys.add(key);
+ }
+ currentRow.mKeys.add(key);
+ } else if (TAG_KEYBOARD.equals(tag)) {
+ parseKeyboardAttributes(res, parser);
+ }
+ } else if (event == XmlResourceParser.END_TAG) {
+ if (inKey) {
+ inKey = false;
+ x += key.gap + key.width;
+ if (x > mTotalWidth) {
+ mTotalWidth = x;
+ }
+ } else if (inRow) {
+ inRow = false;
+ y += currentRow.verticalGap;
+ y += currentRow.defaultHeight;
+ row++;
+ } else {
+ // TODO: error or extend?
+ }
+ }
+ }
+ } catch (Exception e) {
+ Log.e(TAG, "Parse error:" + e);
+ e.printStackTrace();
+ }
+ mTotalHeight = y - mDefaultVerticalGap;
+ }
+
+ private void skipToEndOfRow(XmlResourceParser parser)
+ throws XmlPullParserException, IOException {
+ int event;
+ while ((event = parser.next()) != XmlResourceParser.END_DOCUMENT) {
+ if (event == XmlResourceParser.END_TAG
+ && parser.getName().equals(TAG_ROW)) {
+ break;
+ }
+ }
+ }
+
+ private void parseKeyboardAttributes(Resources res, XmlResourceParser parser) {
+ TypedArray a = res.obtainAttributes(Xml.asAttributeSet(parser),
+ R.styleable.King_Keyboard);
+
+ mDefaultWidth = getDimensionOrFraction(a,
+ R.styleable.King_Keyboard_android_keyWidth,
+ mDisplayWidth, mDisplayWidth / 10);
+ mDefaultHeight = getDimensionOrFraction(a,
+ R.styleable.King_Keyboard_android_keyHeight,
+ mDisplayHeight, 50);
+ mDefaultHorizontalGap = getDimensionOrFraction(a,
+ R.styleable.King_Keyboard_android_horizontalGap,
+ mDisplayWidth, 0);
+ mDefaultVerticalGap = getDimensionOrFraction(a,
+ R.styleable.King_Keyboard_android_verticalGap,
+ mDisplayHeight, 0);
+ mProximityThreshold = (int) (mDefaultWidth * SEARCH_DISTANCE);
+ mProximityThreshold = mProximityThreshold * mProximityThreshold; // Square it for comparison
+ a.recycle();
+ }
+
+ static int getDimensionOrFraction(TypedArray a, int index, int base, int defValue) {
+ TypedValue value = a.peekValue(index);
+ if (value == null) return defValue;
+ if (value.type == TypedValue.TYPE_DIMENSION) {
+ return a.getDimensionPixelOffset(index, defValue);
+ } else if (value.type == TypedValue.TYPE_FRACTION) {
+ // Round it to avoid values like 47.9999 from getting truncated
+ return Math.round(a.getFraction(index, base, base, defValue));
+ }
+ return defValue;
+ }
+}
+
diff --git a/keybordlib/src/main/java/com/king/keyboard/KeyboardView.java b/keybordlib/src/main/java/com/king/keyboard/KeyboardView.java
new file mode 100644
index 0000000..89c3a64
--- /dev/null
+++ b/keybordlib/src/main/java/com/king/keyboard/KeyboardView.java
@@ -0,0 +1,1505 @@
+package com.king.keyboard;
+
+/*
+ * Copyright (C) 2008-2009 Google Inc.
+ *
+ * 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.
+ */
+
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.Paint.Align;
+import android.graphics.PorterDuff;
+import android.graphics.Rect;
+import android.graphics.Typeface;
+import android.graphics.drawable.Drawable;
+import android.media.AudioManager;
+import android.os.Handler;
+import android.os.Message;
+import android.util.AttributeSet;
+import android.util.TypedValue;
+import android.view.GestureDetector;
+import android.view.Gravity;
+import android.view.LayoutInflater;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewConfiguration;
+import android.view.ViewGroup.LayoutParams;
+import android.widget.PopupWindow;
+import android.widget.TextView;
+
+import com.king.keyboard.Keyboard.Key;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+
+/**
+ * A view that renders a virtual {@link Keyboard}. It handles rendering of keys and
+ * detecting key presses and touch movements.
+ *
+ * @attr ref android.R.styleable#King_KeyboardView_keyBackground
+ * @attr ref android.R.styleable#King_KeyboardView_keyPreviewLayout
+ * @attr ref android.R.styleable#King_KeyboardView_keyPreviewOffset
+ * @attr ref android.R.styleable#King_KeyboardView_keyPreviewHeight
+ * @attr ref android.R.styleable#King_KeyboardView_labelTextSize
+ * @attr ref android.R.styleable#King_KeyboardView_keyTextSize
+ * @attr ref android.R.styleable#King_KeyboardView_keyTextColor
+ * @attr ref android.R.styleable#King_KeyboardView_verticalCorrection
+ * @attr ref android.R.styleable#King_KeyboardView_popupLayout
+ *
+ * This class is deprecated because this is just a convenient UI widget class that
+ * application developers can re-implement on top of existing public APIs. If you have
+ * already depended on this class, consider copying the implementation from AOSP into
+ * your project or re-implementing a similar widget by yourselves
+ */
+
+public class KeyboardView extends View implements View.OnClickListener {
+
+ /**
+ * Listener for virtual keyboard events.
+ */
+ public interface OnKeyboardActionListener {
+
+ /**
+ * Called when the user presses a key. This is sent before the {@link #onKey} is called.
+ * For keys that repeat, this is only called once.
+ * @param primaryCode the unicode of the key being pressed. If the touch is not on a valid
+ * key, the value will be zero.
+ */
+ void onPress(int primaryCode);
+
+ /**
+ * Called when the user releases a key. This is sent after the {@link #onKey} is called.
+ * For keys that repeat, this is only called once.
+ * @param primaryCode the code of the key that was released
+ */
+ void onRelease(int primaryCode);
+
+ /**
+ * Send a key press to the listener.
+ * @param primaryCode this is the key that was pressed
+ * @param keyCodes the codes for all the possible alternative keys
+ * with the primary code being the first. If the primary key code is
+ * a single character such as an alphabet or number or symbol, the alternatives
+ * will include other characters that may be on the same key or adjacent keys.
+ * These codes are useful to correct for accidental presses of a key adjacent to
+ * the intended key.
+ */
+ void onKey(int primaryCode, int[] keyCodes);
+
+ /**
+ * Sends a sequence of characters to the listener.
+ * @param text the sequence of characters to be displayed.
+ */
+ void onText(CharSequence text);
+
+ /**
+ * Called when the user quickly moves the finger from right to left.
+ */
+ void swipeLeft();
+
+ /**
+ * Called when the user quickly moves the finger from left to right.
+ */
+ void swipeRight();
+
+ /**
+ * Called when the user quickly moves the finger from up to down.
+ */
+ void swipeDown();
+
+ /**
+ * Called when the user quickly moves the finger from down to up.
+ */
+ void swipeUp();
+ }
+
+ private static final boolean DEBUG = false;
+ private static final int NOT_A_KEY = -1;
+ private static final int[] KEY_DELETE = { Keyboard.KEYCODE_DELETE };
+ private static final int[] LONG_PRESSABLE_STATE_SET = { R.styleable.King_KeyboardViewPreviewState_android_state_long_pressable };
+
+ private Context mContext;
+ private Keyboard mKeyboard;
+ private int mCurrentKeyIndex = NOT_A_KEY;
+
+ private int mLabelTextSize;
+ private int mKeyTextSize;
+ private int mKeyTextColor;
+ private float mShadowRadius;
+ private int mShadowColor;
+ private float mBackgroundDimAmount;
+
+ private TextView mPreviewText;
+ private PopupWindow mPreviewPopup;
+ private int mPreviewTextSizeLarge;
+ private int mPreviewOffset;
+ private int mPreviewHeight;
+ // Working variable
+ private final int[] mCoordinates = new int[2];
+
+ private PopupWindow mPopupKeyboard;
+ private View mMiniKeyboardContainer;
+ private KeyboardView mMiniKeyboard;
+ private boolean mMiniKeyboardOnScreen;
+ private View mPopupParent;
+ private int mMiniKeyboardOffsetX;
+ private int mMiniKeyboardOffsetY;
+ private Map mMiniKeyboardCache;
+ private Key[] mKeys;
+
+ /** Listener for {@link OnKeyboardActionListener}. */
+ private OnKeyboardActionListener mKeyboardActionListener;
+
+ private static final int MSG_SHOW_PREVIEW = 1;
+ private static final int MSG_REMOVE_PREVIEW = 2;
+ private static final int MSG_REPEAT = 3;
+ private static final int MSG_LONGPRESS = 4;
+
+ private static final int DELAY_BEFORE_PREVIEW = 0;
+ private static final int DELAY_AFTER_PREVIEW = 70;
+ private static final int DEBOUNCE_TIME = 70;
+
+ private int mVerticalCorrection;
+ private int mProximityThreshold;
+
+ private boolean mPreviewCentered = false;
+ private boolean mShowPreview = true;
+ private boolean mShowTouchPoints = true;
+ private int mPopupPreviewX;
+ private int mPopupPreviewY;
+
+ private int mLastX;
+ private int mLastY;
+ private int mStartX;
+ private int mStartY;
+
+ private boolean mProximityCorrectOn;
+
+ private Paint mPaint;
+ private Rect mPadding;
+
+ private long mDownTime;
+ private long mLastMoveTime;
+ private int mLastKey;
+ private int mLastCodeX;
+ private int mLastCodeY;
+ private int mCurrentKey = NOT_A_KEY;
+ private int mDownKey = NOT_A_KEY;
+ private long mLastKeyTime;
+ private long mCurrentKeyTime;
+ private int[] mKeyIndices = new int[12];
+ private GestureDetector mGestureDetector;
+ private int mPopupX;
+ private int mPopupY;
+ private int mRepeatKeyIndex = NOT_A_KEY;
+ private int mPopupLayout;
+ private boolean mAbortKey;
+ private Key mInvalidatedKey;
+ private Rect mClipRegion = new Rect(0, 0, 0, 0);
+ private boolean mPossiblePoly;
+ private SwipeTracker mSwipeTracker = new SwipeTracker();
+ private int mSwipeThreshold;
+ private boolean mDisambiguateSwipe;
+
+ // Variables for dealing with multiple pointers
+ private int mOldPointerCount = 1;
+ private float mOldPointerX;
+ private float mOldPointerY;
+
+ private Drawable mKeyBackground;
+
+ private static final int REPEAT_INTERVAL = 50; // ~20 keys per second
+ private static final int REPEAT_START_DELAY = 400;
+ private static final int LONGPRESS_TIMEOUT = ViewConfiguration.getLongPressTimeout();
+
+ private static int MAX_NEARBY_KEYS = 12;
+ private int[] mDistances = new int[MAX_NEARBY_KEYS];
+
+ // For multi-tap
+ private int mLastSentIndex;
+ private int mTapCount;
+ private long mLastTapTime;
+ private boolean mInMultiTap;
+ private static final int MULTITAP_INTERVAL = 800; // milliseconds
+ private StringBuilder mPreviewLabel = new StringBuilder(1);
+
+ /** Whether the keyboard bitmap needs to be redrawn before it's blitted. **/
+ private boolean mDrawPending;
+ /** The dirty region in the keyboard bitmap */
+ private Rect mDirtyRect = new Rect();
+ /** The keyboard bitmap for faster updates */
+ private Bitmap mBuffer;
+ /** Notes if the keyboard just changed, so that we could possibly reallocate the mBuffer. */
+ private boolean mKeyboardChanged;
+ /** The canvas for the above mutable keyboard bitmap */
+ private Canvas mCanvas;
+ /** The accessibility manager for accessibility support */
+// private AccessibilityManager mAccessibilityManager;
+ /** The audio manager for accessibility support */
+ private AudioManager mAudioManager;
+ /** Whether the requirement of a headset to hear passwords if accessibility is enabled is announced. */
+ private boolean mHeadsetRequiredToHearPasswordsAnnounced;
+
+ Handler mHandler;
+
+ public KeyboardView(Context context, AttributeSet attrs) {
+ this(context, attrs, 0);
+ }
+
+ public KeyboardView(Context context, AttributeSet attrs, int defStyleAttr) {
+ this(context, attrs, defStyleAttr, 0);
+ }
+
+ public KeyboardView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
+ super(context, attrs, defStyleAttr, defStyleRes);
+ mContext = context;
+ TypedArray a = context.obtainStyledAttributes(
+ attrs, R.styleable.King_KeyboardView, defStyleAttr, defStyleRes);
+
+ LayoutInflater inflate =
+ (LayoutInflater) context
+ .getSystemService(Context.LAYOUT_INFLATER_SERVICE);
+
+ int previewLayout = 0;
+ int keyTextSize = 0;
+
+ int n = a.getIndexCount();
+
+ for (int i = 0; i < n; i++) {
+ int attr = a.getIndex(i);
+
+ if (attr == R.styleable.King_KeyboardView_android_keyBackground) {
+ mKeyBackground = a.getDrawable(attr);
+ } else if (attr == R.styleable.King_KeyboardView_android_verticalCorrection) {
+ mVerticalCorrection = a.getDimensionPixelOffset(attr, 0);
+ } else if (attr == R.styleable.King_KeyboardView_android_keyPreviewLayout) {
+ previewLayout = a.getResourceId(attr, 0);
+ } else if (attr == R.styleable.King_KeyboardView_android_keyPreviewOffset) {
+ mPreviewOffset = a.getDimensionPixelOffset(attr, 0);
+ } else if (attr == R.styleable.King_KeyboardView_android_keyPreviewHeight) {
+ mPreviewHeight = a.getDimensionPixelSize(attr, 80);
+ } else if (attr == R.styleable.King_KeyboardView_android_keyTextSize) {
+ mKeyTextSize = a.getDimensionPixelSize(attr, 18);
+ } else if (attr == R.styleable.King_KeyboardView_android_keyTextColor) {
+ mKeyTextColor = a.getColor(attr, 0xFF000000);
+ } else if (attr == R.styleable.King_KeyboardView_android_labelTextSize) {
+ mLabelTextSize = a.getDimensionPixelSize(attr, 14);
+ } else if (attr == R.styleable.King_KeyboardView_android_popupLayout) {
+ mPopupLayout = a.getResourceId(attr, 0);
+ } else if (attr == R.styleable.King_KeyboardView_android_shadowColor) {
+ mShadowColor = a.getColor(attr, 0);
+ } else if (attr == R.styleable.King_KeyboardView_android_shadowRadius) {
+ mShadowRadius = a.getFloat(attr, 0f);
+ }
+ }
+
+ mPreviewPopup = new PopupWindow(context);
+ if (previewLayout != 0) {
+ mPreviewText = (TextView) inflate.inflate(previewLayout, null);
+ mPreviewTextSizeLarge = (int) mPreviewText.getTextSize();
+ mPreviewPopup.setContentView(mPreviewText);
+ mPreviewPopup.setBackgroundDrawable(null);
+ } else {
+ mShowPreview = false;
+ }
+
+ mPreviewPopup.setTouchable(false);
+
+ mPopupKeyboard = new PopupWindow(context);
+ mPopupKeyboard.setBackgroundDrawable(null);
+ //mPopupKeyboard.setClippingEnabled(false);
+
+ mPopupParent = this;
+ //mPredicting = true;
+
+ mPaint = new Paint();
+ mPaint.setAntiAlias(true);
+ mPaint.setTextSize(keyTextSize);
+ mPaint.setTextAlign(Align.CENTER);
+ mPaint.setAlpha(255);
+
+ mPadding = new Rect(0, 0, 0, 0);
+ mMiniKeyboardCache = new HashMap();
+ mKeyBackground.getPadding(mPadding);
+
+ mSwipeThreshold = (int) (500 * getResources().getDisplayMetrics().density);
+// mDisambiguateSwipe = getResources().getBoolean(
+// R.bool.config_swipeDisambiguation);
+
+ mAudioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
+
+ resetMultiTap();
+ }
+
+ @Override
+ protected void onAttachedToWindow() {
+ super.onAttachedToWindow();
+ initGestureDetector();
+ if (mHandler == null) {
+ mHandler = new Handler() {
+ @Override
+ public void handleMessage(Message msg) {
+ switch (msg.what) {
+ case MSG_SHOW_PREVIEW:
+ showKey(msg.arg1);
+ break;
+ case MSG_REMOVE_PREVIEW:
+ mPreviewText.setVisibility(INVISIBLE);
+ break;
+ case MSG_REPEAT:
+ if (repeatKey()) {
+ Message repeat = Message.obtain(this, MSG_REPEAT);
+ sendMessageDelayed(repeat, REPEAT_INTERVAL);
+ }
+ break;
+ case MSG_LONGPRESS:
+ openPopupIfRequired((MotionEvent) msg.obj);
+ break;
+ }
+ }
+ };
+ }
+ }
+
+ private void initGestureDetector() {
+ if (mGestureDetector == null) {
+ mGestureDetector = new GestureDetector(getContext(), new GestureDetector.SimpleOnGestureListener() {
+ @Override
+ public boolean onFling(MotionEvent me1, MotionEvent me2,
+ float velocityX, float velocityY) {
+ if (mPossiblePoly) return false;
+ final float absX = Math.abs(velocityX);
+ final float absY = Math.abs(velocityY);
+ float deltaX = me2.getX() - me1.getX();
+ float deltaY = me2.getY() - me1.getY();
+ int travelX = getWidth() / 2; // Half the keyboard width
+ int travelY = getHeight() / 2; // Half the keyboard height
+ mSwipeTracker.computeCurrentVelocity(1000);
+ final float endingVelocityX = mSwipeTracker.getXVelocity();
+ final float endingVelocityY = mSwipeTracker.getYVelocity();
+ boolean sendDownKey = false;
+ if (velocityX > mSwipeThreshold && absY < absX && deltaX > travelX) {
+ if (mDisambiguateSwipe && endingVelocityX < velocityX / 4) {
+ sendDownKey = true;
+ } else {
+ swipeRight();
+ return true;
+ }
+ } else if (velocityX < -mSwipeThreshold && absY < absX && deltaX < -travelX) {
+ if (mDisambiguateSwipe && endingVelocityX > velocityX / 4) {
+ sendDownKey = true;
+ } else {
+ swipeLeft();
+ return true;
+ }
+ } else if (velocityY < -mSwipeThreshold && absX < absY && deltaY < -travelY) {
+ if (mDisambiguateSwipe && endingVelocityY > velocityY / 4) {
+ sendDownKey = true;
+ } else {
+ swipeUp();
+ return true;
+ }
+ } else if (velocityY > mSwipeThreshold && absX < absY / 2 && deltaY > travelY) {
+ if (mDisambiguateSwipe && endingVelocityY < velocityY / 4) {
+ sendDownKey = true;
+ } else {
+ swipeDown();
+ return true;
+ }
+ }
+
+ if (sendDownKey) {
+ detectAndSendKey(mDownKey, mStartX, mStartY, me1.getEventTime());
+ }
+ return false;
+ }
+ });
+
+ mGestureDetector.setIsLongpressEnabled(false);
+ }
+ }
+
+ public void setOnKeyboardActionListener(OnKeyboardActionListener listener) {
+ mKeyboardActionListener = listener;
+ }
+
+ /**
+ * Returns the {@link OnKeyboardActionListener} object.
+ * @return the listener attached to this keyboard
+ */
+ protected OnKeyboardActionListener getOnKeyboardActionListener() {
+ return mKeyboardActionListener;
+ }
+
+ /**
+ * Attaches a keyboard to this view. The keyboard can be switched at any time and the
+ * view will re-layout itself to accommodate the keyboard.
+ * @see Keyboard
+ * @see #getKeyboard()
+ * @param keyboard the keyboard to display in this view
+ */
+ public void setKeyboard(Keyboard keyboard) {
+ if (mKeyboard != null) {
+ showPreview(NOT_A_KEY);
+ }
+ // Remove any pending messages
+ removeMessages();
+ mKeyboard = keyboard;
+ List keys = mKeyboard.getKeys();
+ mKeys = keys.toArray(new Key[keys.size()]);
+ requestLayout();
+ // Hint to reallocate the buffer if the size changed
+ mKeyboardChanged = true;
+ invalidateAllKeys();
+ computeProximityThreshold(keyboard);
+ mMiniKeyboardCache.clear(); // Not really necessary to do every time, but will free up views
+ // Switching to a different keyboard should abort any pending keys so that the key up
+ // doesn't get delivered to the old or new keyboard
+ mAbortKey = true; // Until the next ACTION_DOWN
+ }
+
+ /**
+ * Returns the current keyboard being displayed by this view.
+ * @return the currently attached keyboard
+ * @see #setKeyboard(Keyboard)
+ */
+ public Keyboard getKeyboard() {
+ return mKeyboard;
+ }
+
+ /**
+ * Sets the state of the shift key of the keyboard, if any.
+ * @param shifted whether or not to enable the state of the shift key
+ * @return true if the shift key state changed, false if there was no change
+ * @see KeyboardView#isShifted()
+ */
+ public boolean setShifted(boolean shifted) {
+ if (mKeyboard != null) {
+ if (mKeyboard.setShifted(shifted)) {
+ // The whole keyboard probably needs to be redrawn
+ invalidateAllKeys();
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Returns the state of the shift key of the keyboard, if any.
+ * @return true if the shift is in a pressed state, false otherwise. If there is
+ * no shift key on the keyboard or there is no keyboard attached, it returns false.
+ * @see KeyboardView#setShifted(boolean)
+ */
+ public boolean isShifted() {
+ if (mKeyboard != null) {
+ return mKeyboard.isShifted();
+ }
+ return false;
+ }
+
+ /**
+ * Enables or disables the key feedback popup. This is a popup that shows a magnified
+ * version of the depressed key. By default the preview is enabled.
+ * @param previewEnabled whether or not to enable the key feedback popup
+ * @see #isPreviewEnabled()
+ */
+ public void setPreviewEnabled(boolean previewEnabled) {
+ mShowPreview = previewEnabled;
+ }
+
+ /**
+ * Returns the enabled state of the key feedback popup.
+ * @return whether or not the key feedback popup is enabled
+ * @see #setPreviewEnabled(boolean)
+ */
+ public boolean isPreviewEnabled() {
+ return mShowPreview;
+ }
+
+ public void setVerticalCorrection(int verticalOffset) {
+
+ }
+ public void setPopupParent(View v) {
+ mPopupParent = v;
+ }
+
+ public void setPopupOffset(int x, int y) {
+ mMiniKeyboardOffsetX = x;
+ mMiniKeyboardOffsetY = y;
+ if (mPreviewPopup.isShowing()) {
+ mPreviewPopup.dismiss();
+ }
+ }
+
+ /**
+ * When enabled, calls to {@link OnKeyboardActionListener#onKey} will include key
+ * codes for adjacent keys. When disabled, only the primary key code will be
+ * reported.
+ * @param enabled whether or not the proximity correction is enabled
+ */
+ public void setProximityCorrectionEnabled(boolean enabled) {
+ mProximityCorrectOn = enabled;
+ }
+
+ /**
+ * Returns true if proximity correction is enabled.
+ */
+ public boolean isProximityCorrectionEnabled() {
+ return mProximityCorrectOn;
+ }
+
+ /**
+ * Popup keyboard close button clicked.
+ * @hide
+ */
+ public void onClick(View v) {
+ dismissPopupKeyboard();
+ }
+
+ private CharSequence adjustCase(CharSequence label) {
+ if (mKeyboard.isShifted() && label != null && label.length() < 3
+ && Character.isLowerCase(label.charAt(0))) {
+ label = label.toString().toUpperCase();
+ }
+ return label;
+ }
+
+ @Override
+ public void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+ // Round up a little
+ if (mKeyboard == null) {
+ setMeasuredDimension(getPaddingLeft() + getPaddingRight(), getPaddingTop() + getPaddingBottom());
+ } else {
+ int width = mKeyboard.getMinWidth() + getPaddingLeft() + getPaddingRight();
+ if (MeasureSpec.getSize(widthMeasureSpec) < width + 10) {
+ width = MeasureSpec.getSize(widthMeasureSpec);
+ }
+ setMeasuredDimension(width, mKeyboard.getHeight() + getPaddingTop() + getPaddingBottom());
+ }
+ }
+
+ /**
+ * Compute the average distance between adjacent keys (horizontally and vertically)
+ * and square it to get the proximity threshold. We use a square here and in computing
+ * the touch distance from a key's center to avoid taking a square root.
+ * @param keyboard
+ */
+ private void computeProximityThreshold(Keyboard keyboard) {
+ if (keyboard == null) return;
+ final Key[] keys = mKeys;
+ if (keys == null) return;
+ int length = keys.length;
+ int dimensionSum = 0;
+ for (int i = 0; i < length; i++) {
+ Key key = keys[i];
+ dimensionSum += Math.min(key.width, key.height) + key.gap;
+ }
+ if (dimensionSum < 0 || length == 0) return;
+ mProximityThreshold = (int) (dimensionSum * 1.4f / length);
+ mProximityThreshold *= mProximityThreshold; // Square it
+ }
+
+ @Override
+ public void onSizeChanged(int w, int h, int oldw, int oldh) {
+ super.onSizeChanged(w, h, oldw, oldh);
+ if (mKeyboard != null) {
+ mKeyboard.resize(w, h);
+ }
+ // Release the buffer, if any and it will be reallocated on the next draw
+ mBuffer = null;
+ }
+
+ @Override
+ public void onDraw(Canvas canvas) {
+ super.onDraw(canvas);
+ if (mDrawPending || mBuffer == null || mKeyboardChanged) {
+ onBufferDraw();
+ }
+ canvas.drawBitmap(mBuffer, 0, 0, null);
+ }
+
+ private void onBufferDraw() {
+ if (mBuffer == null || mKeyboardChanged) {
+ if (mBuffer == null || mKeyboardChanged &&
+ (mBuffer.getWidth() != getWidth() || mBuffer.getHeight() != getHeight())) {
+ // Make sure our bitmap is at least 1x1
+ final int width = Math.max(1, getWidth());
+ final int height = Math.max(1, getHeight());
+ mBuffer = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
+ mCanvas = new Canvas(mBuffer);
+ }
+ invalidateAllKeys();
+ mKeyboardChanged = false;
+ }
+
+ if (mKeyboard == null) return;
+
+ mCanvas.save();
+ final Canvas canvas = mCanvas;
+ canvas.clipRect(mDirtyRect);
+
+ final Paint paint = mPaint;
+ final Drawable keyBackground = mKeyBackground;
+ final Rect clipRegion = mClipRegion;
+ final Rect padding = mPadding;
+ final int kbdPaddingLeft = getPaddingLeft();
+ final int kbdPaddingTop = getPaddingTop();
+ final Key[] keys = mKeys;
+ final Key invalidKey = mInvalidatedKey;
+
+ paint.setColor(mKeyTextColor);
+ boolean drawSingleKey = false;
+ if (invalidKey != null && canvas.getClipBounds(clipRegion)) {
+ // Is clipRegion completely contained within the invalidated key?
+ if (invalidKey.x + kbdPaddingLeft - 1 <= clipRegion.left &&
+ invalidKey.y + kbdPaddingTop - 1 <= clipRegion.top &&
+ invalidKey.x + invalidKey.width + kbdPaddingLeft + 1 >= clipRegion.right &&
+ invalidKey.y + invalidKey.height + kbdPaddingTop + 1 >= clipRegion.bottom) {
+ drawSingleKey = true;
+ }
+ }
+ canvas.drawColor(0x00000000, PorterDuff.Mode.CLEAR);
+ final int keyCount = keys.length;
+ for (int i = 0; i < keyCount; i++) {
+ final Key key = keys[i];
+ if (drawSingleKey && invalidKey != key) {
+ continue;
+ }
+ int[] drawableState = key.getCurrentDrawableState();
+ keyBackground.setState(drawableState);
+
+ // Switch the character to uppercase if shift is pressed
+ String label = key.label == null? null : adjustCase(key.label).toString();
+
+ final Rect bounds = keyBackground.getBounds();
+ if (key.width != bounds.right ||
+ key.height != bounds.bottom) {
+ keyBackground.setBounds(0, 0, key.width, key.height);
+ }
+ canvas.translate(key.x + kbdPaddingLeft, key.y + kbdPaddingTop);
+ keyBackground.draw(canvas);
+
+ if (label != null) {
+ // For characters, use large font. For labels like "Done", use small font.
+ if (label.length() > 1 && key.codes.length < 2) {
+ paint.setTextSize(mLabelTextSize);
+ paint.setTypeface(Typeface.DEFAULT_BOLD);
+ } else {
+ paint.setTextSize(mKeyTextSize);
+ paint.setTypeface(Typeface.DEFAULT);
+ }
+ // Draw a drop shadow for the text
+ paint.setShadowLayer(mShadowRadius, 0, 0, mShadowColor);
+ // Draw the text
+ canvas.drawText(label,
+ (key.width - padding.left - padding.right) / 2
+ + padding.left,
+ (key.height - padding.top - padding.bottom) / 2
+ + (paint.getTextSize() - paint.descent()) / 2 + padding.top,
+ paint);
+ // Turn off drop shadow
+ paint.setShadowLayer(0, 0, 0, 0);
+ } else if (key.icon != null) {
+ final int drawableX = (key.width - padding.left - padding.right
+ - key.icon.getIntrinsicWidth()) / 2 + padding.left;
+ final int drawableY = (key.height - padding.top - padding.bottom
+ - key.icon.getIntrinsicHeight()) / 2 + padding.top;
+ canvas.translate(drawableX, drawableY);
+ key.icon.setBounds(0, 0,
+ key.icon.getIntrinsicWidth(), key.icon.getIntrinsicHeight());
+ key.icon.draw(canvas);
+ canvas.translate(-drawableX, -drawableY);
+ }
+ canvas.translate(-key.x - kbdPaddingLeft, -key.y - kbdPaddingTop);
+ }
+ mInvalidatedKey = null;
+ // Overlay a dark rectangle to dim the keyboard
+ if (mMiniKeyboardOnScreen) {
+// paint.setColor((int) (mBackgroundDimAmount * 0xFF) << 24);
+ canvas.drawRect(0, 0, getWidth(), getHeight(), paint);
+ }
+
+ if (DEBUG && mShowTouchPoints) {
+ paint.setAlpha(128);
+ paint.setColor(0xFFFF0000);
+ canvas.drawCircle(mStartX, mStartY, 3, paint);
+ canvas.drawLine(mStartX, mStartY, mLastX, mLastY, paint);
+ paint.setColor(0xFF0000FF);
+ canvas.drawCircle(mLastX, mLastY, 3, paint);
+ paint.setColor(0xFF00FF00);
+ canvas.drawCircle((mStartX + mLastX) / 2, (mStartY + mLastY) / 2, 2, paint);
+ }
+ mCanvas.restore();
+ mDrawPending = false;
+ mDirtyRect.setEmpty();
+ }
+
+ private int getKeyIndices(int x, int y, int[] allKeys) {
+ final Key[] keys = mKeys;
+ int primaryIndex = NOT_A_KEY;
+ int closestKey = NOT_A_KEY;
+ int closestKeyDist = mProximityThreshold + 1;
+ java.util.Arrays.fill(mDistances, Integer.MAX_VALUE);
+ int [] nearestKeyIndices = mKeyboard.getNearestKeys(x, y);
+ final int keyCount = nearestKeyIndices.length;
+ for (int i = 0; i < keyCount; i++) {
+ final Key key = keys[nearestKeyIndices[i]];
+ int dist = 0;
+ boolean isInside = key.isInside(x,y);
+ if (isInside) {
+ primaryIndex = nearestKeyIndices[i];
+ }
+
+ if (((mProximityCorrectOn
+ && (dist = key.squaredDistanceFrom(x, y)) < mProximityThreshold)
+ || isInside)
+ && key.codes[0] > 32) {
+ // Find insertion point
+ final int nCodes = key.codes.length;
+ if (dist < closestKeyDist) {
+ closestKeyDist = dist;
+ closestKey = nearestKeyIndices[i];
+ }
+
+ if (allKeys == null) continue;
+
+ for (int j = 0; j < mDistances.length; j++) {
+ if (mDistances[j] > dist) {
+ // Make space for nCodes codes
+ System.arraycopy(mDistances, j, mDistances, j + nCodes,
+ mDistances.length - j - nCodes);
+ System.arraycopy(allKeys, j, allKeys, j + nCodes,
+ allKeys.length - j - nCodes);
+ for (int c = 0; c < nCodes; c++) {
+ allKeys[j + c] = key.codes[c];
+ mDistances[j + c] = dist;
+ }
+ break;
+ }
+ }
+ }
+ }
+ if (primaryIndex == NOT_A_KEY) {
+ primaryIndex = closestKey;
+ }
+ return primaryIndex;
+ }
+
+ private void detectAndSendKey(int index, int x, int y, long eventTime) {
+ if (index != NOT_A_KEY && index < mKeys.length) {
+ final Key key = mKeys[index];
+ if (key.text != null) {
+ mKeyboardActionListener.onText(key.text);
+ mKeyboardActionListener.onRelease(NOT_A_KEY);
+ } else {
+ int code = key.codes[0];
+ //TextEntryState.keyPressedAt(key, x, y);
+ int[] codes = new int[MAX_NEARBY_KEYS];
+ Arrays.fill(codes, NOT_A_KEY);
+ getKeyIndices(x, y, codes);
+ // Multi-tap
+ if (mInMultiTap) {
+ if (mTapCount != -1) {
+ mKeyboardActionListener.onKey(Keyboard.KEYCODE_DELETE, KEY_DELETE);
+ } else {
+ mTapCount = 0;
+ }
+ code = key.codes[mTapCount];
+ }
+ mKeyboardActionListener.onKey(code, codes);
+ mKeyboardActionListener.onRelease(code);
+ }
+ mLastSentIndex = index;
+ mLastTapTime = eventTime;
+ }
+ }
+
+ /**
+ * Handle multi-tap keys by producing the key label for the current multi-tap state.
+ */
+ private CharSequence getPreviewText(Key key) {
+ if (mInMultiTap) {
+ // Multi-tap
+ mPreviewLabel.setLength(0);
+ mPreviewLabel.append((char) key.codes[mTapCount < 0 ? 0 : mTapCount]);
+ return adjustCase(mPreviewLabel);
+ } else {
+ return adjustCase(key.label);
+ }
+ }
+
+ private void showPreview(int keyIndex) {
+ int oldKeyIndex = mCurrentKeyIndex;
+ final PopupWindow previewPopup = mPreviewPopup;
+
+ mCurrentKeyIndex = keyIndex;
+ // Release the old key and press the new key
+ final Key[] keys = mKeys;
+ if (oldKeyIndex != mCurrentKeyIndex) {
+ if (oldKeyIndex != NOT_A_KEY && keys.length > oldKeyIndex) {
+ Key oldKey = keys[oldKeyIndex];
+ oldKey.onReleased(mCurrentKeyIndex == NOT_A_KEY);
+ invalidateKey(oldKeyIndex);
+ final int keyCode = oldKey.codes[0];
+ }
+ if (mCurrentKeyIndex != NOT_A_KEY && keys.length > mCurrentKeyIndex) {
+ Key newKey = keys[mCurrentKeyIndex];
+ newKey.onPressed();
+ invalidateKey(mCurrentKeyIndex);
+ final int keyCode = newKey.codes[0];
+ }
+ }
+ // If key changed and preview is on ...
+ if (oldKeyIndex != mCurrentKeyIndex && mShowPreview) {
+ mHandler.removeMessages(MSG_SHOW_PREVIEW);
+ if (previewPopup.isShowing()) {
+ if (keyIndex == NOT_A_KEY) {
+ mHandler.sendMessageDelayed(mHandler
+ .obtainMessage(MSG_REMOVE_PREVIEW),
+ DELAY_AFTER_PREVIEW);
+ }
+ }
+ if (keyIndex != NOT_A_KEY) {
+ if (previewPopup.isShowing() && mPreviewText.getVisibility() == VISIBLE) {
+ // Show right away, if it's already visible and finger is moving around
+ showKey(keyIndex);
+ } else {
+ mHandler.sendMessageDelayed(
+ mHandler.obtainMessage(MSG_SHOW_PREVIEW, keyIndex, 0),
+ DELAY_BEFORE_PREVIEW);
+ }
+ }
+ }
+ }
+
+ private void showKey(final int keyIndex) {
+ final PopupWindow previewPopup = mPreviewPopup;
+ final Key[] keys = mKeys;
+ if (keyIndex < 0 || keyIndex >= mKeys.length) return;
+ Key key = keys[keyIndex];
+ if (key.icon != null) {
+ mPreviewText.setCompoundDrawables(null, null, null,
+ key.iconPreview != null ? key.iconPreview : key.icon);
+ mPreviewText.setText(null);
+ } else {
+ mPreviewText.setCompoundDrawables(null, null, null, null);
+ mPreviewText.setText(getPreviewText(key));
+ if (key.label!=null && key.label.length() > 1 && key.codes.length < 2) {
+ mPreviewText.setTextSize(TypedValue.COMPLEX_UNIT_PX, mKeyTextSize);
+ mPreviewText.setTypeface(Typeface.DEFAULT_BOLD);
+ } else {
+ mPreviewText.setTextSize(TypedValue.COMPLEX_UNIT_PX, mPreviewTextSizeLarge);
+ mPreviewText.setTypeface(Typeface.DEFAULT);
+ }
+ }
+ mPreviewText.measure(MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED),
+ MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED));
+ int popupWidth = Math.max(mPreviewText.getMeasuredWidth(), key.width
+ + mPreviewText.getPaddingLeft() + mPreviewText.getPaddingRight());
+ final int popupHeight = mPreviewHeight;
+ LayoutParams lp = mPreviewText.getLayoutParams();
+ if (lp != null) {
+ lp.width = popupWidth;
+ lp.height = popupHeight;
+ }
+ if (!mPreviewCentered) {
+ mPopupPreviewX = key.x - mPreviewText.getPaddingLeft() + getPaddingLeft();
+ mPopupPreviewY = key.y - popupHeight + mPreviewOffset;
+ } else {
+ // TODO: Fix this if centering is brought back
+ mPopupPreviewX = 160 - mPreviewText.getMeasuredWidth() / 2;
+ mPopupPreviewY = - mPreviewText.getMeasuredHeight();
+ }
+ mHandler.removeMessages(MSG_REMOVE_PREVIEW);
+ getLocationInWindow(mCoordinates);
+ mCoordinates[0] += mMiniKeyboardOffsetX; // Offset may be zero
+ mCoordinates[1] += mMiniKeyboardOffsetY; // Offset may be zero
+
+ // Set the preview background state
+ mPreviewText.getBackground().setState(
+ key.popupResId != 0 ? LONG_PRESSABLE_STATE_SET : EMPTY_STATE_SET);
+ mPopupPreviewX += mCoordinates[0];
+ mPopupPreviewY += mCoordinates[1];
+
+ // If the popup cannot be shown above the key, put it on the side
+ getLocationOnScreen(mCoordinates);
+ if (mPopupPreviewY + mCoordinates[1] < 0) {
+ // If the key you're pressing is on the left side of the keyboard, show the popup on
+ // the right, offset by enough to see at least one key to the left/right.
+ if (key.x + key.width <= getWidth() / 2) {
+ mPopupPreviewX += (int) (key.width * 2.5);
+ } else {
+ mPopupPreviewX -= (int) (key.width * 2.5);
+ }
+ mPopupPreviewY += popupHeight;
+ }
+
+ if (previewPopup.isShowing()) {
+ previewPopup.update(mPopupPreviewX, mPopupPreviewY,
+ popupWidth, popupHeight);
+ } else {
+ previewPopup.setWidth(popupWidth);
+ previewPopup.setHeight(popupHeight);
+ previewPopup.showAtLocation(mPopupParent, Gravity.NO_GRAVITY,
+ mPopupPreviewX, mPopupPreviewY);
+ }
+ mPreviewText.setVisibility(VISIBLE);
+ }
+
+
+ /**
+ * Requests a redraw of the entire keyboard. Calling {@link #invalidate} is not sufficient
+ * because the keyboard renders the keys to an off-screen buffer and an invalidate() only
+ * draws the cached buffer.
+ * @see #invalidateKey(int)
+ */
+ public void invalidateAllKeys() {
+ mDirtyRect.union(0, 0, getWidth(), getHeight());
+ mDrawPending = true;
+ invalidate();
+ }
+
+ /**
+ * Invalidates a key so that it will be redrawn on the next repaint. Use this method if only
+ * one key is changing it's content. Any changes that affect the position or size of the key
+ * may not be honored.
+ * @param keyIndex the index of the key in the attached {@link Keyboard}.
+ * @see #invalidateAllKeys
+ */
+ public void invalidateKey(int keyIndex) {
+ if (mKeys == null) return;
+ if (keyIndex < 0 || keyIndex >= mKeys.length) {
+ return;
+ }
+ final Key key = mKeys[keyIndex];
+ mInvalidatedKey = key;
+ mDirtyRect.union(key.x + getPaddingLeft(), key.y + getPaddingTop(),
+ key.x + key.width + getPaddingLeft(), key.y + key.height + getPaddingTop());
+ onBufferDraw();
+ invalidate(key.x + getPaddingLeft(), key.y + getPaddingTop(),
+ key.x + key.width + getPaddingLeft(), key.y + key.height + getPaddingTop());
+ }
+
+ private boolean openPopupIfRequired(MotionEvent me) {
+ // Check if we have a popup layout specified first.
+ if (mPopupLayout == 0) {
+ return false;
+ }
+ if (mCurrentKey < 0 || mCurrentKey >= mKeys.length) {
+ return false;
+ }
+
+ Key popupKey = mKeys[mCurrentKey];
+ boolean result = onLongPress(popupKey);
+ if (result) {
+ mAbortKey = true;
+ showPreview(NOT_A_KEY);
+ }
+ return result;
+ }
+
+ /**
+ * Called when a key is long pressed. By default this will open any popup keyboard associated
+ * with this key through the attributes popupLayout and popupCharacters.
+ * @param popupKey the key that was long pressed
+ * @return true if the long press is handled, false otherwise. Subclasses should call the
+ * method on the base class if the subclass doesn't wish to handle the call.
+ */
+ protected boolean onLongPress(Key popupKey) {
+ int popupKeyboardId = popupKey.popupResId;
+
+ if (popupKeyboardId != 0) {
+ mMiniKeyboardContainer = mMiniKeyboardCache.get(popupKey);
+ if (mMiniKeyboardContainer == null) {
+ LayoutInflater inflater = (LayoutInflater) getContext().getSystemService(
+ Context.LAYOUT_INFLATER_SERVICE);
+ mMiniKeyboardContainer = inflater.inflate(mPopupLayout, null);
+ mMiniKeyboard = mMiniKeyboardContainer.findViewById(
+ R.id.keyboardView);
+// View closeButton = mMiniKeyboardContainer.findViewById(
+// R.id.closeButton);
+// if (closeButton != null) closeButton.setOnClickListener(this);
+ mMiniKeyboard.setOnKeyboardActionListener(new OnKeyboardActionListener() {
+ public void onKey(int primaryCode, int[] keyCodes) {
+ mKeyboardActionListener.onKey(primaryCode, keyCodes);
+ dismissPopupKeyboard();
+ }
+
+ public void onText(CharSequence text) {
+ mKeyboardActionListener.onText(text);
+ dismissPopupKeyboard();
+ }
+
+ public void swipeLeft() { }
+ public void swipeRight() { }
+ public void swipeUp() { }
+ public void swipeDown() { }
+ public void onPress(int primaryCode) {
+ mKeyboardActionListener.onPress(primaryCode);
+ }
+ public void onRelease(int primaryCode) {
+ mKeyboardActionListener.onRelease(primaryCode);
+ }
+ });
+ //mInputView.setSuggest(mSuggest);
+ Keyboard keyboard;
+ if (popupKey.popupCharacters != null) {
+ keyboard = new Keyboard(getContext(), popupKeyboardId,
+ popupKey.popupCharacters, -1, getPaddingLeft() + getPaddingRight());
+ } else {
+ keyboard = new Keyboard(getContext(), popupKeyboardId);
+ }
+ mMiniKeyboard.setKeyboard(keyboard);
+ mMiniKeyboard.setPopupParent(this);
+ mMiniKeyboardContainer.measure(
+ MeasureSpec.makeMeasureSpec(getWidth(), MeasureSpec.AT_MOST),
+ MeasureSpec.makeMeasureSpec(getHeight(), MeasureSpec.AT_MOST));
+
+ mMiniKeyboardCache.put(popupKey, mMiniKeyboardContainer);
+ } else {
+ mMiniKeyboard = mMiniKeyboardContainer.findViewById(
+ R.id.keyboardView);
+ }
+ getLocationInWindow(mCoordinates);
+ mPopupX = popupKey.x + getPaddingLeft();
+ mPopupY = popupKey.y + getPaddingTop();
+ mPopupX = mPopupX + popupKey.width - mMiniKeyboardContainer.getMeasuredWidth();
+ mPopupY = mPopupY - mMiniKeyboardContainer.getMeasuredHeight();
+ final int x = mPopupX + mMiniKeyboardContainer.getPaddingRight() + mCoordinates[0];
+ final int y = mPopupY + mMiniKeyboardContainer.getPaddingBottom() + mCoordinates[1];
+ mMiniKeyboard.setPopupOffset(x < 0 ? 0 : x, y);
+ mMiniKeyboard.setShifted(isShifted());
+ mPopupKeyboard.setContentView(mMiniKeyboardContainer);
+ mPopupKeyboard.setWidth(mMiniKeyboardContainer.getMeasuredWidth());
+ mPopupKeyboard.setHeight(mMiniKeyboardContainer.getMeasuredHeight());
+ mPopupKeyboard.showAtLocation(this, Gravity.NO_GRAVITY, x, y);
+ mMiniKeyboardOnScreen = true;
+ //mMiniKeyboard.onTouchEvent(getTranslatedEvent(me));
+ invalidateAllKeys();
+ return true;
+ }
+ return false;
+ }
+
+// @Override
+// public boolean onHoverEvent(MotionEvent event) {
+// if (AccessibilityManager.isTouchExplorationEnabled() && event.getPointerCount() == 1) {
+// final int action = event.getAction();
+// switch (action) {
+// case MotionEvent.ACTION_HOVER_ENTER: {
+// event.setAction(MotionEvent.ACTION_DOWN);
+// } break;
+// case MotionEvent.ACTION_HOVER_MOVE: {
+// event.setAction(MotionEvent.ACTION_MOVE);
+// } break;
+// case MotionEvent.ACTION_HOVER_EXIT: {
+// event.setAction(MotionEvent.ACTION_UP);
+// } break;
+// }
+// return onTouchEvent(event);
+// }
+// return true;
+// }
+
+ @Override
+ public boolean onTouchEvent(MotionEvent me) {
+ // Convert multi-pointer up/down events to single up/down events to
+ // deal with the typical multi-pointer behavior of two-thumb typing
+ final int pointerCount = me.getPointerCount();
+ final int action = me.getAction();
+ boolean result = false;
+ final long now = me.getEventTime();
+
+ if (pointerCount != mOldPointerCount) {
+ if (pointerCount == 1) {
+ // Send a down event for the latest pointer
+ MotionEvent down = MotionEvent.obtain(now, now, MotionEvent.ACTION_DOWN,
+ me.getX(), me.getY(), me.getMetaState());
+ result = onModifiedTouchEvent(down, false);
+ down.recycle();
+ // If it's an up action, then deliver the up as well.
+ if (action == MotionEvent.ACTION_UP) {
+ result = onModifiedTouchEvent(me, true);
+ }
+ } else {
+ // Send an up event for the last pointer
+ MotionEvent up = MotionEvent.obtain(now, now, MotionEvent.ACTION_UP,
+ mOldPointerX, mOldPointerY, me.getMetaState());
+ result = onModifiedTouchEvent(up, true);
+ up.recycle();
+ }
+ } else {
+ if (pointerCount == 1) {
+ result = onModifiedTouchEvent(me, false);
+ mOldPointerX = me.getX();
+ mOldPointerY = me.getY();
+ } else {
+ // Don't do anything when 2 pointers are down and moving.
+ result = true;
+ }
+ }
+ mOldPointerCount = pointerCount;
+
+ return result;
+ }
+
+ private boolean onModifiedTouchEvent(MotionEvent me, boolean possiblePoly) {
+ int touchX = (int) me.getX() - getPaddingLeft();
+ int touchY = (int) me.getY() - getPaddingTop();
+ if (touchY >= -mVerticalCorrection)
+ touchY += mVerticalCorrection;
+ final int action = me.getAction();
+ final long eventTime = me.getEventTime();
+ int keyIndex = getKeyIndices(touchX, touchY, null);
+ mPossiblePoly = possiblePoly;
+
+ // Track the last few movements to look for spurious swipes.
+ if (action == MotionEvent.ACTION_DOWN) mSwipeTracker.clear();
+ mSwipeTracker.addMovement(me);
+
+ // Ignore all motion events until a DOWN.
+ if (mAbortKey
+ && action != MotionEvent.ACTION_DOWN && action != MotionEvent.ACTION_CANCEL) {
+ return true;
+ }
+
+ if (mGestureDetector.onTouchEvent(me)) {
+ showPreview(NOT_A_KEY);
+ mHandler.removeMessages(MSG_REPEAT);
+ mHandler.removeMessages(MSG_LONGPRESS);
+ return true;
+ }
+
+ // Needs to be called after the gesture detector gets a turn, as it may have
+ // displayed the mini keyboard
+ if (mMiniKeyboardOnScreen && action != MotionEvent.ACTION_CANCEL) {
+ return true;
+ }
+
+ switch (action) {
+ case MotionEvent.ACTION_DOWN:
+ mAbortKey = false;
+ mStartX = touchX;
+ mStartY = touchY;
+ mLastCodeX = touchX;
+ mLastCodeY = touchY;
+ mLastKeyTime = 0;
+ mCurrentKeyTime = 0;
+ mLastKey = NOT_A_KEY;
+ mCurrentKey = keyIndex;
+ mDownKey = keyIndex;
+ mDownTime = me.getEventTime();
+ mLastMoveTime = mDownTime;
+ checkMultiTap(eventTime, keyIndex);
+ mKeyboardActionListener.onPress(keyIndex != NOT_A_KEY ?
+ mKeys[keyIndex].codes[0] : 0);
+ if (mCurrentKey >= 0 && mKeys[mCurrentKey].repeatable) {
+ mRepeatKeyIndex = mCurrentKey;
+ Message msg = mHandler.obtainMessage(MSG_REPEAT);
+ mHandler.sendMessageDelayed(msg, REPEAT_START_DELAY);
+ repeatKey();
+ // Delivering the key could have caused an abort
+ if (mAbortKey) {
+ mRepeatKeyIndex = NOT_A_KEY;
+ break;
+ }
+ }
+ if (mCurrentKey != NOT_A_KEY) {
+ Message msg = mHandler.obtainMessage(MSG_LONGPRESS, me);
+ mHandler.sendMessageDelayed(msg, LONGPRESS_TIMEOUT);
+ }
+ showPreview(keyIndex);
+ break;
+
+ case MotionEvent.ACTION_MOVE:
+ boolean continueLongPress = false;
+ if (keyIndex != NOT_A_KEY) {
+ if (mCurrentKey == NOT_A_KEY) {
+ mCurrentKey = keyIndex;
+ mCurrentKeyTime = eventTime - mDownTime;
+ } else {
+ if (keyIndex == mCurrentKey) {
+ mCurrentKeyTime += eventTime - mLastMoveTime;
+ continueLongPress = true;
+ } else if (mRepeatKeyIndex == NOT_A_KEY) {
+ resetMultiTap();
+ mLastKey = mCurrentKey;
+ mLastCodeX = mLastX;
+ mLastCodeY = mLastY;
+ mLastKeyTime =
+ mCurrentKeyTime + eventTime - mLastMoveTime;
+ mCurrentKey = keyIndex;
+ mCurrentKeyTime = 0;
+ }
+ }
+ }
+ if (!continueLongPress) {
+ // Cancel old longpress
+ mHandler.removeMessages(MSG_LONGPRESS);
+ // Start new longpress if key has changed
+ if (keyIndex != NOT_A_KEY) {
+ Message msg = mHandler.obtainMessage(MSG_LONGPRESS, me);
+ mHandler.sendMessageDelayed(msg, LONGPRESS_TIMEOUT);
+ }
+ }
+ showPreview(mCurrentKey);
+ mLastMoveTime = eventTime;
+ break;
+
+ case MotionEvent.ACTION_UP:
+ removeMessages();
+ if (keyIndex == mCurrentKey) {
+ mCurrentKeyTime += eventTime - mLastMoveTime;
+ } else {
+ resetMultiTap();
+ mLastKey = mCurrentKey;
+ mLastKeyTime = mCurrentKeyTime + eventTime - mLastMoveTime;
+ mCurrentKey = keyIndex;
+ mCurrentKeyTime = 0;
+ }
+ if (mCurrentKeyTime < mLastKeyTime && mCurrentKeyTime < DEBOUNCE_TIME
+ && mLastKey != NOT_A_KEY) {
+ mCurrentKey = mLastKey;
+ touchX = mLastCodeX;
+ touchY = mLastCodeY;
+ }
+ showPreview(NOT_A_KEY);
+ Arrays.fill(mKeyIndices, NOT_A_KEY);
+ // If we're not on a repeating key (which sends on a DOWN event)
+ if (mRepeatKeyIndex == NOT_A_KEY && !mMiniKeyboardOnScreen && !mAbortKey) {
+ detectAndSendKey(mCurrentKey, touchX, touchY, eventTime);
+ }
+ invalidateKey(keyIndex);
+ mRepeatKeyIndex = NOT_A_KEY;
+ break;
+ case MotionEvent.ACTION_CANCEL:
+ removeMessages();
+ dismissPopupKeyboard();
+ mAbortKey = true;
+ showPreview(NOT_A_KEY);
+ invalidateKey(mCurrentKey);
+ break;
+ }
+ mLastX = touchX;
+ mLastY = touchY;
+ return true;
+ }
+
+ private boolean repeatKey() {
+ Key key = mKeys[mRepeatKeyIndex];
+ detectAndSendKey(mCurrentKey, key.x, key.y, mLastTapTime);
+ return true;
+ }
+
+ protected void swipeRight() {
+ mKeyboardActionListener.swipeRight();
+ }
+
+ protected void swipeLeft() {
+ mKeyboardActionListener.swipeLeft();
+ }
+
+ protected void swipeUp() {
+ mKeyboardActionListener.swipeUp();
+ }
+
+ protected void swipeDown() {
+ mKeyboardActionListener.swipeDown();
+ }
+
+ public void closing() {
+ if (mPreviewPopup.isShowing()) {
+ mPreviewPopup.dismiss();
+ }
+ removeMessages();
+
+ dismissPopupKeyboard();
+ mBuffer = null;
+ mCanvas = null;
+ mMiniKeyboardCache.clear();
+ }
+
+ private void removeMessages() {
+ if (mHandler != null) {
+ mHandler.removeMessages(MSG_REPEAT);
+ mHandler.removeMessages(MSG_LONGPRESS);
+ mHandler.removeMessages(MSG_SHOW_PREVIEW);
+ }
+ }
+
+ @Override
+ public void onDetachedFromWindow() {
+ super.onDetachedFromWindow();
+ closing();
+ }
+
+ private void dismissPopupKeyboard() {
+ if (mPopupKeyboard.isShowing()) {
+ mPopupKeyboard.dismiss();
+ mMiniKeyboardOnScreen = false;
+ invalidateAllKeys();
+ }
+ }
+
+ public boolean handleBack() {
+ if (mPopupKeyboard.isShowing()) {
+ dismissPopupKeyboard();
+ return true;
+ }
+ return false;
+ }
+
+ private void resetMultiTap() {
+ mLastSentIndex = NOT_A_KEY;
+ mTapCount = 0;
+ mLastTapTime = -1;
+ mInMultiTap = false;
+ }
+
+ private void checkMultiTap(long eventTime, int keyIndex) {
+ if (keyIndex == NOT_A_KEY) return;
+ Key key = mKeys[keyIndex];
+ if (key.codes.length > 1) {
+ mInMultiTap = true;
+ if (eventTime < mLastTapTime + MULTITAP_INTERVAL
+ && keyIndex == mLastSentIndex) {
+ mTapCount = (mTapCount + 1) % key.codes.length;
+ return;
+ } else {
+ mTapCount = -1;
+ return;
+ }
+ }
+ if (eventTime > mLastTapTime + MULTITAP_INTERVAL || keyIndex != mLastSentIndex) {
+ resetMultiTap();
+ }
+ }
+
+ private static class SwipeTracker {
+
+ static final int NUM_PAST = 4;
+ static final int LONGEST_PAST_TIME = 200;
+
+ final float mPastX[] = new float[NUM_PAST];
+ final float mPastY[] = new float[NUM_PAST];
+ final long mPastTime[] = new long[NUM_PAST];
+
+ float mYVelocity;
+ float mXVelocity;
+
+ public void clear() {
+ mPastTime[0] = 0;
+ }
+
+ public void addMovement(MotionEvent ev) {
+ long time = ev.getEventTime();
+ final int N = ev.getHistorySize();
+ for (int i=0; i= 0) {
+ final int start = drop+1;
+ final int count = NUM_PAST-drop-1;
+ System.arraycopy(pastX, start, pastX, 0, count);
+ System.arraycopy(pastY, start, pastY, 0, count);
+ System.arraycopy(pastTime, start, pastTime, 0, count);
+ i -= (drop+1);
+ }
+ pastX[i] = x;
+ pastY[i] = y;
+ pastTime[i] = time;
+ i++;
+ if (i < NUM_PAST) {
+ pastTime[i] = 0;
+ }
+ }
+
+ public void computeCurrentVelocity(int units) {
+ computeCurrentVelocity(units, Float.MAX_VALUE);
+ }
+
+ public void computeCurrentVelocity(int units, float maxVelocity) {
+ final float[] pastX = mPastX;
+ final float[] pastY = mPastY;
+ final long[] pastTime = mPastTime;
+
+ final float oldestX = pastX[0];
+ final float oldestY = pastY[0];
+ final long oldestTime = pastTime[0];
+ float accumX = 0;
+ float accumY = 0;
+ int N=0;
+ while (N < NUM_PAST) {
+ if (pastTime[N] == 0) {
+ break;
+ }
+ N++;
+ }
+
+ for (int i=1; i < N; i++) {
+ final int dur = (int)(pastTime[i] - oldestTime);
+ if (dur == 0) continue;
+ float dist = pastX[i] - oldestX;
+ float vel = (dist/dur) * units; // pixels/frame.
+ if (accumX == 0) accumX = vel;
+ else accumX = (accumX + vel) * .5f;
+
+ dist = pastY[i] - oldestY;
+ vel = (dist/dur) * units; // pixels/frame.
+ if (accumY == 0) accumY = vel;
+ else accumY = (accumY + vel) * .5f;
+ }
+ mXVelocity = accumX < 0.0f ? Math.max(accumX, -maxVelocity)
+ : Math.min(accumX, maxVelocity);
+ mYVelocity = accumY < 0.0f ? Math.max(accumY, -maxVelocity)
+ : Math.min(accumY, maxVelocity);
+ }
+
+ public float getXVelocity() {
+ return mXVelocity;
+ }
+
+ public float getYVelocity() {
+ return mYVelocity;
+ }
+ }
+}
+
diff --git a/keybordlib/src/main/java/com/king/keyboard/KingKeyboard.kt b/keybordlib/src/main/java/com/king/keyboard/KingKeyboard.kt
new file mode 100644
index 0000000..d7bd16c
--- /dev/null
+++ b/keybordlib/src/main/java/com/king/keyboard/KingKeyboard.kt
@@ -0,0 +1,1141 @@
+package com.king.keyboard
+
+import android.app.Activity
+import android.content.Context
+import android.graphics.drawable.Drawable
+import android.media.AudioManager
+import android.os.Build
+import android.os.VibrationEffect
+import android.os.Vibrator
+import android.provider.Settings
+import android.text.InputType
+import android.util.Log
+import android.util.SparseArray
+import android.view.*
+import android.view.animation.Animation
+import android.view.animation.TranslateAnimation
+import android.widget.EditText
+import androidx.annotation.IdRes
+import androidx.annotation.XmlRes
+
+
+/**
+ * @author Jenly
+ */
+open class KingKeyboard {
+
+ private lateinit var context: Context
+
+ private var isCap = false
+
+ private var isAllCaps = false
+
+ private var keyboardType = KeyboardType.NORMAL
+
+ private val keyboardNormal by lazy { Keyboard(context, R.xml.king_keyboard_normal) }
+ private val keyboardNormalModeChange by lazy { Keyboard(context, R.xml.king_keyboard_normal_mode_change) }
+ private val keyboardNormalMore by lazy { Keyboard(context, R.xml.king_keyboard_normal_more_symbol) }
+
+ private val keyboardLetter by lazy { Keyboard(context, R.xml.king_keyboard_letter) }
+
+ private val keyboardLowercaseLetter by lazy { Keyboard(context, R.xml.king_keyboard_lowercase_letter_only) }
+
+ private val keyboardUppercaseLetter by lazy { Keyboard(context, R.xml.king_keyboard_uppercase_letter_only) }
+
+ private val keyboardLetterNumber by lazy { Keyboard(context, R.xml.king_keyboard_letter_number) }
+
+ private val keyboardNumber by lazy { Keyboard(context, R.xml.king_keyboard_number) }
+
+ private val keyboardNumberDecimal by lazy { Keyboard(context, R.xml.king_keyboard_number_decimal) }
+
+ private val keyboardPhone by lazy { Keyboard(context, R.xml.king_keyboard_phone) }
+
+ private val keyboardIDCard by lazy { Keyboard(context, R.xml.king_keyboard_id_card) }
+
+ private val keyboardLicensePlate by lazy { Keyboard(context, R.xml.king_keyboard_license_plate) }
+
+ /**
+ * LICENSE_PLATE_MODE_CHANGE 与 LICENSE_PLATE_MODE_NUMBER
+ */
+ private val keyboardLicensePlateNumber by lazy { Keyboard(context, R.xml.king_keyboard_license_plate_number) }
+
+ private val keyboardLicensePlateMore by lazy { Keyboard(context, R.xml.king_keyboard_license_plate_more) }
+
+ private val keyboardLicensePlateProvince by lazy { Keyboard(context, R.xml.king_keyboard_license_plate_province) }
+
+
+ private var keyboardCustom: Keyboard? = null
+ private var keyboardCustomModeChange: Keyboard? = null
+ private var keyboardCustomMore: Keyboard? = null
+
+ private var currentKeyboard: Keyboard
+
+ private lateinit var keyboardViewGroup: View
+ private var keyboardView: KingKeyboardView? = null
+
+ private var currentEditText: EditText? = null
+
+ /**
+ * SparseArray存储 EditText,SparseArray 的key为 EditText的 ID，value为 EditText
+ */
+ private val editTextArray by lazy {
+ SparseArray()
+ }
+
+ /**
+ * 键盘类型，SparseArray的key为EditText的ID，value为键盘类型
+ */
+ private val keyboardTypeArray by lazy {
+ SparseArray()
+ }
+ /**
+ * 键盘显示动画
+ */
+ private lateinit var showAnimation: Animation
+ /**
+ * 键盘隐藏动画
+ */
+ private lateinit var hideAnimation: Animation
+
+ private lateinit var onTouchListener: View.OnTouchListener
+ private lateinit var globalFocusChangeListener: ViewTreeObserver.OnGlobalFocusChangeListener
+
+ private var onKeyboardActionListener: KeyboardView.OnKeyboardActionListener? = null
+ private var onKeyDoneListener: OnKeyListener? = null
+ private var onKeyCancelListener: OnKeyListener? = null
+ private var onKeyExtraListener: OnKeyListener? = null
+
+ private var vibrator: Vibrator? = null
+
+ private var audioManager: AudioManager? = null
+
+ /**
+ * 是否震动
+ */
+ private var isVibrationEffect = false
+ /**
+ * 是否播放音效
+ */
+ private var isPlaySoundEffect = false
+
+ companion object{
+
+ private const val TAG = "KingKeyboard"
+
+ private const val ANIM_DURATION_TIME = 200L
+
+ //------------------------------ 下面是定义的一些公用功能按键值
+ /**
+ * Shift键 -> 一般用来切换键盘大小写字母
+ */
+ const val KEYCODE_SHIFT = -1
+ /**
+ * 模式改变 -> 切换键盘输入法
+ */
+ const val KEYCODE_MODE_CHANGE = -2
+ /**
+ * 取消键 -> 关闭输入法
+ */
+ const val KEYCODE_CANCEL = -3
+ /**
+ * 完成键 -> 长出现在右下角蓝色的完成按钮
+ */
+ const val KEYCODE_DONE = -4
+ /**
+ * 删除键 -> 删除输入框内容
+ */
+ const val KEYCODE_DELETE = -5
+ /**
+ * Alt键 -> 预留，暂时未使用
+ */
+ const val KEYCODE_ALT = -6
+ /**
+ * 空格键
+ */
+ const val KEYCODE_SPACE = 32
+
+ /**
+ * 无作用键 -> 一般用来占位或者禁用按键
+ */
+ const val KEYCODE_NONE = 0
+
+ //------------------------------
+
+ /**
+ * 键盘按键 -> 返回（返回，适用于切换键盘后界面使用，如：NORMAL_MODE_CHANGE或CUSTOM_MODE_CHANGE键盘）
+ */
+ const val KEYCODE_MODE_BACK = -101
+
+ /**
+ * 键盘按键 ->返回（直接返回到最初,直接返回到NORMAL或CUSTOM键盘）
+ */
+ const val KEYCODE_BACK = -102
+
+ /**
+ * 键盘按键 ->更多
+ */
+ const val KEYCODE_MORE = -103
+
+ //------------------------------ 下面是自定义的一些预留按键值，与共用按键功能一致,但会使用默认的背景按键
+
+ const val KEYCODE_KING_SHIFT = -201
+ const val KEYCODE_KING_MODE_CHANGE = -202
+ const val KEYCODE_KING_CANCEL = -203
+ const val KEYCODE_KING_DONE = -204
+ const val KEYCODE_KING_DELETE = -205
+ const val KEYCODE_KING_ALT = -206
+
+ //------------------------------ 下面是自定义的一些功能按键值，与共用按键功能一致,但会使用默认背景颜色
+
+ /**
+ * 键盘按键 -> 返回（返回，适用于切换键盘后界面使用，如：NORMAL_MODE_CHANGE或CUSTOM_MODE_CHANGE键盘）
+ */
+ const val KEYCODE_KING_MODE_BACK = -251
+
+ /**
+ * 键盘按键 ->返回（直接返回到最初,直接返回到NORMAL或CUSTOM键盘）
+ */
+ const val KEYCODE_KING_BACK = -252
+
+ /**
+ * 键盘按键 ->更多
+ */
+ const val KEYCODE_KING_MORE = -253
+
+ /*
+ 用户也可自定义按键值，primaryCode范围区间为-999 ~ -300时，表示预留可扩展按键值。
+ 其中-399~-300区间为功能型按键，使用Special背景色，-999~-400自定义按键为默认背景色
+ */
+
+ }
+
+ /**
+ * 构造
+ * @param activity 上下文
+ * @param keyboardParentView 键盘的父布局容器 -> 一般在界面底部，用来容纳键盘布局
+ *
+ */
+ constructor(activity: Activity, keyboardParentView: ViewGroup):
+ this(activity,
+ activity.window.decorView.findViewById(android.R.id.content).getChildAt(0) as ViewGroup,
+ keyboardParentView
+ )
+
+ /**
+ * 构造
+ * @param context 上下文
+ * @param rootView 界面的根布局 -> 也可以是当前界面包含所有的EditText的公共父布局
+ * @param keyboardParentView 键盘的父布局容器 -> 一般在界面底部，用来容纳键盘布局
+ */
+ constructor(context: Context, rootView: ViewGroup,keyboardParentView: ViewGroup):
+ this(context,
+ rootView,
+ keyboardParentView,
+ LayoutInflater.from(context).inflate(R.layout.king_keyboard_container, null),
+ R.id.keyboardView
+ )
+ /**
+ * 构造
+ * @param context 上下文
+ * @param rootView 界面的根布局 -> 也可以是当前界面包含所有的EditText的公共父布局
+ * @param keyboardParentView 键盘的父布局容器 -> 一般在界面底部，用来容纳键盘布局
+ * @param keyboardContainer 键盘的容器
+ * @param keyboardViewId KingKeyboard视图控件的ID
+ */
+ constructor(context: Context, rootView: ViewGroup,keyboardParentView: ViewGroup,keyboardContainer: View,@IdRes keyboardViewId: Int) {
+ this.context = context
+ currentKeyboard = keyboardNormal
+ intKeyboard(context)
+ intKeyboardView(rootView,keyboardParentView,keyboardContainer,keyboardViewId)
+
+ }
+
+ open fun intKeyboard(context: Context){
+
+ }
+
+ /**
+ * 初始化KeyboardView
+ */
+ private fun intKeyboardView(rootView: ViewGroup,keyboardParentView: ViewGroup,keyboardContainer: View,@IdRes keyboardViewId: Int){
+ //初始化键盘相关
+ keyboardViewGroup = keyboardContainer
+ keyboardView = keyboardViewGroup.findViewById(keyboardViewId)
+
+ keyboardView?.let {
+ it.keyboard = currentKeyboard
+ it.isEnabled = true
+ it.isPreviewEnabled = false
+ it.onKeyboardActionListener = object: KeyboardView.OnKeyboardActionListener{
+
+ override fun swipeRight() {
+ onKeyboardActionListener?.swipeRight()
+ }
+
+ override fun onPress(primaryCode: Int) {
+ onKeyboardActionListener?.onPress(primaryCode)
+ }
+
+ override fun onRelease(primaryCode: Int) {
+ onKeyboardActionListener?.onRelease(primaryCode)
+ }
+
+ override fun swipeLeft() {
+ onKeyboardActionListener?.swipeLeft()
+ }
+
+ override fun swipeUp() {
+ onKeyboardActionListener?.swipeUp()
+ }
+
+ override fun swipeDown() {
+ onKeyboardActionListener?.swipeDown()
+ }
+
+ override fun onKey(primaryCode: Int, keyCodes: IntArray?) {
+ if(primaryCode != 0){
+ playSoundEffect()
+ sendVibrationEffect()
+ }
+ //根据不同的按键值去处理
+ when(primaryCode){
+ KEYCODE_SHIFT -> keyShift()
+ KEYCODE_MODE_CHANGE -> keyModeChange()
+ KEYCODE_CANCEL -> keyCancel(primaryCode)
+ KEYCODE_DONE -> keyDone(primaryCode)
+ KEYCODE_DELETE -> keyDelete()
+ KEYCODE_ALT -> keyAlt()
+ KEYCODE_MODE_BACK -> keyBack(false)
+ KEYCODE_BACK -> keyBack(true)
+ KEYCODE_MORE -> keyMore()
+ //预留值，具有相同的作用
+ KEYCODE_KING_SHIFT -> keyShift()
+ KEYCODE_KING_MODE_CHANGE -> keyModeChange()
+ KEYCODE_KING_CANCEL -> keyCancel(primaryCode)
+ KEYCODE_KING_DONE -> keyDone(primaryCode)
+ KEYCODE_KING_DELETE -> keyDelete()
+ KEYCODE_KING_ALT -> keyAlt()
+ KEYCODE_KING_MODE_BACK -> keyBack(false)
+ KEYCODE_KING_BACK -> keyBack(true)
+ KEYCODE_KING_MORE -> keyMore()
+ //预留的自定义可扩展按键
+ in -999..-300 -> keyExtra(primaryCode)
+ //直接输入按键值
+ in 32..Int.MAX_VALUE -> keyInput(primaryCode)
+ //无效的按键值，打印相关日志
+ else -> Log.d(TAG,"primaryCode:$primaryCode")
+ }
+ onKeyboardActionListener?.onKey(primaryCode,keyCodes)
+
+ }
+
+ override fun onText(text: CharSequence?) {
+ onKeyboardActionListener?.onText(text)
+ }
+ }
+
+ isCap = it.isCap()
+ isAllCaps = it.isAllCaps()
+
+ keyboardViewGroup.isVisible = false
+ }
+
+ //初始化动画
+ showAnimation = TranslateAnimation(Animation.RELATIVE_TO_SELF, 0.0f, Animation.RELATIVE_TO_SELF,
+ 0.0f, Animation.RELATIVE_TO_SELF, 1.0f, Animation.RELATIVE_TO_SELF, 0.0f)
+ showAnimation.duration = ANIM_DURATION_TIME
+
+ hideAnimation = TranslateAnimation(Animation.RELATIVE_TO_SELF, 0.0f, Animation.RELATIVE_TO_SELF,
+ 0.0f, Animation.RELATIVE_TO_SELF, 0.0f, Animation.RELATIVE_TO_SELF, 1.0f)
+ hideAnimation.duration = ANIM_DURATION_TIME
+
+ hideAnimation.setAnimationListener(object : Animation.AnimationListener{
+ override fun onAnimationRepeat(animation: Animation?) {
+
+ }
+
+ override fun onAnimationEnd(animation: Animation?) {
+ if(keyboardViewGroup.isVisible){
+ keyboardViewGroup.isVisible = false
+ }
+ }
+
+ override fun onAnimationStart(animation: Animation?) {
+
+ }
+
+ })
+
+ onTouchListener = View.OnTouchListener { v, event ->
+ if(event.action == MotionEvent.ACTION_UP){
+ viewFocus(v)
+ }
+
+ false
+ }
+
+ globalFocusChangeListener = ViewTreeObserver.OnGlobalFocusChangeListener {oldFocus, newFocus ->
+ if(newFocus is EditText){
+ if(editTextArray.containsKey(newFocus.id)){//newFocus使用的是KingKeyboard
+ viewFocus(newFocus)
+ }else{//没有使用KingKeyboard，可能使用的是系统输入法，则隐藏KingKeyboard
+ hide()
+ }
+ }
+ }
+
+ //将键盘布局添加到父布局
+ keyboardParentView.addView(keyboardViewGroup)
+
+ rootView.viewTreeObserver.addOnGlobalFocusChangeListener(globalFocusChangeListener)
+ }
+
+ /**
+ * 自定义键盘Custom，键盘类型为{@link KeyboardType#CUSTOM}
+ *
+ * 当默认已有的键盘类型满足不了您的需求时，可通过此方法来自定义键盘。
+ *
+ * 与之相关的方法有{@code setKeyboardCustomModeChange(Keyboard)}和{@code setKeyboardCustomMore(Keyboard)}
+ *
+ * @param keyboard 键盘
+ */
+ fun setKeyboardCustom(keyboard: Keyboard){
+ this.keyboardCustom = keyboard
+ }
+
+ /**
+ * 自定义键盘CustomModeChange，键盘类型为{@link KeyboardType#CUSTOM_MODE_CHANGE}
+ *
+ * 当需要自定义键盘的按键太多，一个自定义键盘布局满足不了你的需求时，即Custom不够用时，你可以通过
+ * 自定义CustomModeChange来扩展，通过键盘切换，来满足您的需求。
+ *
+ * 与之相关的方法有{@code setKeyboardCustom(Keyboard)}和{@code setKeyboardCustomMore(Keyboard)}
+ *
+ * @param keyboard 键盘
+ */
+ fun setKeyboardCustomModeChange(keyboard: Keyboard){
+ this.keyboardCustomModeChange = keyboard
+ }
+
+ /**
+ * 自定义键盘CustomMore，键盘类型为{@link KeyboardType#CUSTOM_MORE}
+ *
+ * 当需要自定义键盘的按键太多，两个自定义键盘布局满足不了你的需求时，即Custom加上CustomModeChange还不够用时，
+ * 你可以通过自定义CustomModeChange来扩展，通过键盘切换，来满足您的需求。
+ *
+ * 与之相关的方法有{@code setKeyboardCustom(Keyboard)}和{@code setKeyboardCustomModeChange(Keyboard)}
+ *
+ * @param keyboard 键盘
+ */
+ fun setKeyboardCustomMore(keyboard: Keyboard){
+ this.keyboardCustomMore = keyboard
+ }
+
+ /**
+ * 自定义键盘Custom，键盘类型为{@link KeyboardType#CUSTOM}
+ *
+ * 当默认已有的键盘类型满足不了您的需求时，可通过此方法来自定义键盘。
+ *
+ * 与之相关的方法有{@code setKeyboardCustomModeChange(Int)}和{@code setKeyboardCustomMore(Int)}
+ *
+ * @param xmlLayoutResId 键盘布局的资源文件，其中包含键盘布局和键值码等相关信息
+ */
+ fun setKeyboardCustom(@XmlRes xmlLayoutResId: Int){
+ this.keyboardCustom = Keyboard(context,xmlLayoutResId)
+ }
+
+ /**
+ * 自定义键盘CustomModeChange，键盘类型为{@link KeyboardType#CUSTOM_MODE_CHANGE}
+ *
+ * 当需要自定义键盘的按键太多，一个自定义键盘布局满足不了你的需求时，即Custom不够用时，你可以通过
+ * 自定义CustomModeChange来扩展，通过键盘切换，来满足您的需求。
+ *
+ * 与之相关的方法有{@code setKeyboardCustom(Int)}和{@code setKeyboardCustomMore(Int)}
+ *
+ * @param xmlLayoutResId 键盘布局的资源文件，其中包含键盘布局和键值码等相关信息
+ */
+ fun setKeyboardCustomModeChange(@XmlRes xmlLayoutResId: Int){
+ this.keyboardCustomModeChange = Keyboard(context,xmlLayoutResId)
+ }
+
+ /**
+ * 自定义键盘CustomMore，键盘类型为{@link KeyboardType#CUSTOM_MORE}
+ *
+ * 当需要自定义键盘的按键太多，两个自定义键盘布局满足不了你的需求时，即Custom加上CustomModeChange还不够用时，
+ * 你可以通过自定义CustomModeChange来扩展，通过键盘切换，来满足您的需求。
+ *
+ * 与之相关的方法有{@code setKeyboardCustom(Int)}和{@code setKeyboardCustomModeChange(Int)}
+ *
+ * @param xmlLayoutResId 键盘布局的资源文件，其中包含键盘布局和键值码等相关信息
+ */
+ fun setKeyboardCustomMore(@XmlRes xmlLayoutResId: Int){
+ this.keyboardCustomMore = Keyboard(context,xmlLayoutResId)
+ }
+
+ /**
+ * 获取当前键盘输入法类型
+ * return 返回当前键盘输入法类型
+ */
+ fun getKeyboardType(): Int{
+ return keyboardType
+ }
+
+ private fun disableShowSoftInput(editText: EditText){
+ try {
+ val method = EditText::class.java.getMethod("setShowSoftInputOnFocus", Boolean::class.java)
+ method.isAccessible = true
+ method.invoke(editText, false)
+ } catch (e: Exception) {
+ editText.inputType = InputType.TYPE_NULL
+ }
+ }
+
+ /**
+ * 执行当获View获取焦点时的一些逻辑，如：显示键盘
+ */
+ private fun viewFocus(v: View){
+ if(v is EditText){
+ v.hideSystemInputMethod()
+ disableShowSoftInput(v)
+ if(v.hasFocus()){
+ currentEditText = v
+ keyboardType = keyboardTypeArray[v.id]!!
+ switchKeyboard()
+ show()
+ }
+ }
+ }
+
+
+ /**
+ * 注册
+ * @param editText 要注册的EditText
+ * @param keyboardType 键盘输入法类型
+ */
+ fun register(editText: EditText,keyboardType: Int) {
+ editTextArray[editText.id] = editText
+ keyboardTypeArray[editText.id] = keyboardType
+ editText.setOnTouchListener(onTouchListener)
+ }
+
+ fun onResume(){
+ currentEditText?.let {
+ if(it.hasFocus()){
+ it.postDelayed({ it.hideSystemInputMethod() },100)
+ }
+ }
+ isPlaySoundEffect = querySoundEffectsEnabled()
+ }
+
+ fun onDestroy(){
+ currentEditText?.let {
+ it.clearAnimation()
+ currentEditText = null
+ }
+ editTextArray.clear()
+ keyboardTypeArray.clear()
+ }
+
+ /**
+ * 键盘输入法是否显示
+ */
+ fun isShow(): Boolean{
+ return keyboardViewGroup.isVisible
+ }
+
+ /**
+ * 显示键盘输入法
+ */
+ private fun show(){
+ if(!keyboardViewGroup.isVisible){
+ keyboardViewGroup.apply {
+ isVisible = true
+ clearAnimation()
+ startAnimation(showAnimation)
+ }
+ }
+ }
+
+ /**
+ * 隐藏键盘输入法
+ */
+ open fun hide(){
+ if(keyboardViewGroup.isVisible){
+ keyboardViewGroup.apply {
+ clearAnimation()
+ startAnimation(hideAnimation)
+ }
+ }
+ }
+
+ /**
+ * 设置背景
+ */
+ fun setBackground(drawable: Drawable?){
+ drawable?.let {
+ keyboardViewGroup.background = drawable
+ }
+ }
+
+ /**
+ * 设置背景
+ */
+ fun setBackgroundResource(drawableId: Int){
+ keyboardViewGroup.setBackgroundResource(drawableId)
+ }
+
+ /**
+ * 对外提供获取KingKeyboardView
+ */
+ fun getKeyboardView(): KingKeyboardView? {
+ return keyboardView
+ }
+
+ /**
+ * 对外提供获取KingKeyboardView的配置
+ */
+ fun getKeyboardViewConfig(): KingKeyboardView.Config?{
+ return keyboardView?.getConfig()
+ }
+
+ /**
+ * 对外提供设置KingKeyboardView的配置
+ */
+ fun setKeyboardViewConfig(config: KingKeyboardView.Config){
+ keyboardView?.setConfig(config)
+ }
+
+ //----------------------------------
+
+ /**
+ * 是否开启音效 -> 由系统设置决定，暂不对外提供
+ */
+ private fun isSoundEffectsEnabled(): Boolean{
+ return isPlaySoundEffect
+ }
+
+ /**
+ * 设置是否开启音效 -> 由系统设置决定，暂不对外提供
+ */
+ private fun setSoundEffectEnabled(soundEffectEnabled: Boolean){
+ this.isPlaySoundEffect = soundEffectEnabled
+ setSoundEffectsEnabled(isPlaySoundEffect)
+ }
+
+ /**
+ * 是否开启震动
+ */
+ fun isVibrationEffectEnabled(): Boolean{
+ return isVibrationEffect
+ }
+
+ /**
+ * 设置是否开启震动
+ */
+ fun setVibrationEffectEnabled(vibrationEffectEnabled: Boolean){
+ this.isVibrationEffect = vibrationEffectEnabled
+ }
+
+ /**
+ * 对外提供监听键盘相关动作
+ */
+ fun setOnKeyboardActionListener(listener: KeyboardView.OnKeyboardActionListener?){
+ this.onKeyboardActionListener = listener
+ }
+
+ /**
+ * 对外提供监听“完成”按键
+ */
+ fun setOnKeyDoneListener(listener: OnKeyListener?){
+ this.onKeyDoneListener = listener
+ }
+
+ /**
+ * 对外提供监听“关闭键盘”按键
+ */
+ fun setOnKeyCancelListener(listener: OnKeyListener?){
+ this.onKeyCancelListener = listener
+ }
+
+ /**
+ * 对外提供监听扩展自定义的按键
+ */
+ fun setOnKeyExtraListener(listener: OnKeyListener?){
+ this.onKeyExtraListener = listener
+ }
+
+ /**
+ * 监听“完成”按键接口
+ */
+ interface OnKeyListener{
+ /**
+ * 点击触发按键时，触发此回调方法
+ * @param primaryCode 为原始code值，即Key的code
+ */
+ fun onKey(editText: View?,primaryCode: Int)
+ }
+
+ //----------------------------------
+
+ /**
+ * 切换键盘输入法
+ */
+ private fun switchKeyboard(){
+ when(keyboardType){
+ KeyboardType.NORMAL -> {
+ currentKeyboard = keyboardNormal
+ }
+ KeyboardType.NORMAL_MODE_CHANGE -> {
+ currentKeyboard = keyboardNormalModeChange
+ }
+ KeyboardType.NORMAL_MORE -> {
+ currentKeyboard = keyboardNormalMore
+ }
+ KeyboardType.LETTER -> {
+ currentKeyboard = keyboardLetter
+ }
+ KeyboardType.LOWERCASE_LETTER_ONLY -> {
+ currentKeyboard = keyboardLowercaseLetter
+ }
+ KeyboardType.UPPERCASE_LETTER_ONLY -> {
+ currentKeyboard = keyboardUppercaseLetter
+ }
+ KeyboardType.LETTER_NUMBER -> {
+ currentKeyboard = keyboardLetterNumber
+ }
+ KeyboardType.NUMBER -> {
+ currentKeyboard = keyboardNumber
+ }
+ KeyboardType.NUMBER_DECIMAL -> {
+ currentKeyboard = keyboardNumberDecimal
+ }
+ KeyboardType.PHONE -> {
+ currentKeyboard = keyboardPhone
+ }
+ KeyboardType.ID_CARD -> {
+ currentKeyboard = keyboardIDCard
+ }
+ KeyboardType.LICENSE_PLATE -> {
+ currentKeyboard = keyboardLicensePlate
+ }
+ KeyboardType.LICENSE_PLATE_MODE_CHANGE -> {
+ currentKeyboard = keyboardLicensePlateNumber
+ }
+ KeyboardType.LICENSE_PLATE_MORE -> {
+ currentKeyboard = keyboardLicensePlateMore
+ }
+ KeyboardType.LICENSE_PLATE_PROVINCE -> {
+ currentKeyboard = keyboardLicensePlateProvince
+ }
+ KeyboardType.LICENSE_PLATE_NUMBER -> {
+ currentKeyboard = keyboardLicensePlateNumber
+ }
+ KeyboardType.CUSTOM -> {//当自定义了键盘，但没有自定义相关布局时，使用默认键盘keyboardNormal
+ currentKeyboard = keyboardCustom ?: keyboardNormal
+ }
+ KeyboardType.CUSTOM_MODE_CHANGE -> {//当自定义了键盘，但没有自定义相关布局时，使用默认键盘keyboardNormalModeChange
+ currentKeyboard = keyboardCustomModeChange ?: keyboardNormalModeChange
+ }
+ KeyboardType.CUSTOM_MORE -> {//当自定义了键盘，但没有自定义相关布局时，使用默认键盘keyboardNormalMore
+ currentKeyboard = keyboardCustomMore ?: keyboardNormalMore
+ }
+
+ }
+
+ keyboardView?.run {
+ keyboard = currentKeyboard
+ }
+
+ }
+
+ /**
+ * 模式改变，切换键盘
+ */
+ private fun keyModeChange(){
+ when(keyboardType){
+ KeyboardType.NORMAL -> {
+ keyboardType = KeyboardType.NORMAL_MODE_CHANGE
+ }
+ KeyboardType.LICENSE_PLATE -> {
+ keyboardType = KeyboardType.LICENSE_PLATE_MODE_CHANGE
+ }
+ KeyboardType.LICENSE_PLATE_MORE -> {
+ keyboardType = KeyboardType.LICENSE_PLATE_MODE_CHANGE
+ }
+ KeyboardType.LICENSE_PLATE_PROVINCE -> {
+ keyboardType = KeyboardType.LICENSE_PLATE_NUMBER
+ }
+ KeyboardType.CUSTOM -> {
+ keyboardType = KeyboardType.CUSTOM_MODE_CHANGE
+ }
+ KeyboardType.CUSTOM_MORE -> {
+ keyboardType = KeyboardType.CUSTOM_MODE_CHANGE
+ }
+ }
+
+ switchKeyboard()
+ }
+
+ /**
+ * 取消，关闭键盘
+ */
+ private fun keyCancel(primaryCode: Int){
+ hide()
+ onKeyCancelListener?.onKey(currentEditText,primaryCode)
+ }
+
+ /**
+ * 完成
+ */
+ private fun keyDone(primaryCode: Int){
+ hide()
+ onKeyDoneListener?.onKey(currentEditText,primaryCode)
+ }
+
+ /**
+ * Alt键，暂时未用到
+ */
+ private fun keyAlt(){
+
+ }
+
+ /**
+ * 返回
+ */
+ private fun keyBack(isBack: Boolean){
+ when(keyboardType){
+ KeyboardType.NORMAL_MODE_CHANGE -> {
+ keyboardType = KeyboardType.NORMAL
+ }
+ KeyboardType.NORMAL_MORE -> {
+ keyboardType = if(isBack) KeyboardType.NORMAL else KeyboardType.NORMAL_MODE_CHANGE
+ }
+ KeyboardType.CUSTOM_MODE_CHANGE -> {
+ keyboardType = KeyboardType.CUSTOM
+ }
+ KeyboardType.CUSTOM_MORE -> {
+ keyboardType = if(isBack) KeyboardType.CUSTOM else KeyboardType.CUSTOM_MODE_CHANGE
+ }
+ KeyboardType.LICENSE_PLATE -> {
+ keyboardType = KeyboardType.LICENSE_PLATE_NUMBER
+ }
+ KeyboardType.LICENSE_PLATE_MODE_CHANGE -> {
+ keyboardType = KeyboardType.LICENSE_PLATE
+ }
+ KeyboardType.LICENSE_PLATE_MORE -> {
+ keyboardType = if(isBack) KeyboardType.LICENSE_PLATE else KeyboardType.LICENSE_PLATE_MODE_CHANGE
+ }
+ KeyboardType.LICENSE_PLATE_PROVINCE -> {
+ keyboardType = KeyboardType.LICENSE_PLATE_NUMBER
+ }
+ KeyboardType.LICENSE_PLATE_NUMBER -> {
+ keyboardType = KeyboardType.LICENSE_PLATE_PROVINCE
+ }
+ }
+
+ switchKeyboard()
+ }
+
+ /**
+ * 更多
+ */
+ private fun keyMore(){
+
+ when(keyboardType){
+ KeyboardType.NORMAL -> {
+ keyboardType = KeyboardType.NORMAL_MORE
+ }
+ KeyboardType.NORMAL_MODE_CHANGE -> {
+ keyboardType = KeyboardType.NORMAL_MORE
+ }
+ KeyboardType.LICENSE_PLATE -> {
+ keyboardType = KeyboardType.LICENSE_PLATE_MORE
+ }
+ KeyboardType.LICENSE_PLATE_MODE_CHANGE -> {
+ keyboardType = KeyboardType.LICENSE_PLATE_MORE
+ }
+ KeyboardType.CUSTOM -> {
+ keyboardType = KeyboardType.CUSTOM_MORE
+ }
+ KeyboardType.CUSTOM_MODE_CHANGE -> {
+ keyboardType = KeyboardType.CUSTOM_MORE
+ }
+
+ }
+
+ switchKeyboard()
+ }
+
+ /**
+ * 输入
+ */
+ private fun keyInput(primaryCode: Int){
+ currentEditText?.let {
+ val start = it.selectionStart
+ val end = it.selectionEnd
+
+ it.text?.replace(start,end, primaryCode.toChar().toString())
+ if(isCap && !isAllCaps){//如果当前是大写键盘，并且并且没有锁定，则自动变换成小写键盘
+ isCap = false
+ isAllCaps = false
+ toLowerCaseKey(currentKeyboard)
+
+ keyboardView?.run {
+ setCap(isCap)
+ setAllCaps(isAllCaps)
+ keyboard = currentKeyboard
+ }
+
+ }
+
+ }
+ }
+
+ private fun querySoundEffectsEnabled(): Boolean {
+ return Settings.System.getInt(context.contentResolver,
+ Settings.System.SOUND_EFFECTS_ENABLED, 0) != 0
+ }
+
+ private fun setSoundEffectsEnabled(enabled: Boolean){
+ Settings.System.putInt(context.contentResolver,
+ Settings.System.SOUND_EFFECTS_ENABLED, if(enabled) 1 else 0)
+ }
+
+ /**
+ * 播放音效
+ */
+ private fun playSoundEffect(effectType: Int = AudioManager.FX_KEYPRESS_STANDARD){
+ if(isPlaySoundEffect){
+ try{
+ if(audioManager == null){
+ audioManager = (context.getSystemService(Context.AUDIO_SERVICE) as? AudioManager)
+ }
+ audioManager?.playSoundEffect(effectType)
+ }catch (e: Exception){
+ Log.w(TAG,e)
+ }
+ }
+ }
+
+ /**
+ * 震动
+ */
+ private fun sendVibrationEffect(){
+ if(isVibrationEffect){
+ try {
+ if(vibrator == null){
+ vibrator = (context.getSystemService(Context.VIBRATOR_SERVICE) as? Vibrator)
+ }
+ //震动
+ vibrator?.let {
+ if (Build.VERSION.SDK_INT >= 26) {
+ it.vibrate(VibrationEffect.createPredefined(VibrationEffect.EFFECT_CLICK))
+ }else{
+ it.vibrate(16L)
+ }
+ }
+ }catch (e: Exception){
+ Log.w(TAG,e)
+ }
+ }
+ }
+
+
+ /**
+ * 按下
+ */
+ private fun keyDown(keycode: Int,action: Int = KeyEvent.ACTION_DOWN){
+ currentEditText?.let {
+ it.onKeyDown(keycode, KeyEvent(action,keycode))
+ }
+ }
+
+ /**
+ * 触发删除
+ */
+ private fun keyDelete(){
+ keyDown(KeyEvent.KEYCODE_DEL)
+ }
+
+ /**
+ * 触发自定义可扩展按键
+ */
+ private fun keyExtra(primaryCode: Int){
+ Log.d(TAG,"primaryCode:$primaryCode")
+ onKeyExtraListener?.onKey(currentEditText,primaryCode)
+ }
+
+ /**
+ * 触发Shift，切换大小字母键盘
+ */
+ private fun keyShift(){
+
+ //将键盘进行大小写键盘切换
+
+ if(isAllCaps){//上次状态为大写锁定时，转换为小写
+ toLowerCaseKey(currentKeyboard)
+ }else{//反之上次状态即为小写时，转换为大写
+ toUpperCaseKey(currentKeyboard)
+ }
+
+ when {
+ isAllCaps -> {//上次状态为锁定时，此次状态将改变为小写，将变量状态改变
+ isAllCaps = false
+ isCap = false
+ }
+ isCap -> {//上次状态为非锁定，此次状态改变为锁定
+ isAllCaps = true
+ }
+ else -> {//上次状态为小写（默认）,此次状态改变为大写
+ isCap = true
+ isAllCaps = false
+ }
+ }
+
+ keyboardView?.let {
+ it.setCap(isCap)
+ it.setAllCaps(isAllCaps)
+ it.keyboard = currentKeyboard
+ }
+
+
+
+ }
+
+ /**
+ * 转换为大写
+ */
+ private fun toUpperCaseKey(keyboard: Keyboard){
+ keyboard.run {
+ for(key in keys){
+ if(key.label?.length == 1){// 一个字符
+ var c = key.label.toString()[0]
+ if(c.isLowerCase()){ //是小写字母
+ //转换为大写
+ val letter = c.toUpperCase()
+ key.label = letter.toString()
+ key.codes[0] = letter.toInt()
+ }
+
+ }
+ }
+ }
+
+ }
+
+ /**
+ * 转换为小写
+ */
+ private fun toLowerCaseKey(keyboard: Keyboard){
+ keyboard.run {
+ for(key in keys){
+ if(key.label?.length == 1){// 一个字符
+ var c = key.label.toString()[0]
+ if(c.isUpperCase()){ //是大写字母
+ //转换为小写
+ val letter = c.toLowerCase()
+ key.label = letter.toString()
+ key.codes[0] = letter.toInt()
+ }
+
+ }
+ }
+ }
+
+ }
+
+
+ /**
+ * 键盘类型
+ */
+ object KeyboardType{
+ /**
+ * 默认键盘 - 字母带符号
+ */
+ const val NORMAL = 0x00000001
+ /**
+ * 默认键盘 - 切换键盘
+ */
+ internal const val NORMAL_MODE_CHANGE = 0x00000002
+ /**
+ * 默认键盘 - 更多
+ */
+ internal const val NORMAL_MORE = 0x00000003
+
+ /**
+ * 字母键盘
+ */
+ const val LETTER = 0x00000011
+
+ /**
+ * 仅小写字母键盘
+ */
+ const val LOWERCASE_LETTER_ONLY = 0x00000101
+ /**
+ * 仅大写字母键盘
+ */
+ const val UPPERCASE_LETTER_ONLY = 0x00000102
+
+ /**
+ * 字母+数字键盘
+ */
+ const val LETTER_NUMBER = 0x00000201
+
+ /**
+ * 数字键盘
+ */
+ const val NUMBER = 0x00000301
+ /**
+ * 浮点数键盘（数字加“.”符号）
+ */
+ const val NUMBER_DECIMAL = 0x00000302
+
+ /**
+ * 电话拨号键盘（数字加“-”符号）
+ */
+ const val PHONE = 0x00000303
+
+ /**
+ * 身份证键盘
+ */
+ const val ID_CARD = 0x00000304
+ /**
+ * 车牌键盘 - 车牌 -> 归属地 + 切换车牌号
+ */
+ const val LICENSE_PLATE = 0x00000401
+
+ /**
+ * 车牌键盘- 切换 -> 车牌号
+ */
+ internal const val LICENSE_PLATE_MODE_CHANGE = 0x00000402
+
+ /**
+ * 车牌键盘 - 更多
+ */
+ internal const val LICENSE_PLATE_MORE = 0x00000403
+
+ /**
+ * 车牌键盘 - 车牌 相对于 LICENSE_PLATE 少了更多相关的
+ */
+ const val LICENSE_PLATE_PROVINCE = 0x00000404
+
+ /**
+ * 车牌键盘 - 车牌号
+ */
+ internal const val LICENSE_PLATE_NUMBER = 0x00000405
+
+ /**
+ * 预留自定义键盘类型
+ */
+ const val CUSTOM = 0x00001001
+ /**
+ * 预留自定义键盘类型 - 键盘模式切换
+ */
+ const val CUSTOM_MODE_CHANGE = 0x00001002
+ /**
+ * 预留自定义键盘类型 - 更多
+ */
+ const val CUSTOM_MORE = 0x00001003
+
+ }
+}
\ No newline at end of file
diff --git a/keybordlib/src/main/java/com/king/keyboard/KingKeyboardUtil.kt b/keybordlib/src/main/java/com/king/keyboard/KingKeyboardUtil.kt
new file mode 100644
index 0000000..dcbe572
--- /dev/null
+++ b/keybordlib/src/main/java/com/king/keyboard/KingKeyboardUtil.kt
@@ -0,0 +1,55 @@
+package com.king.keyboard
+
+import android.content.Context
+import android.util.SparseArray
+import android.view.View
+import android.view.inputmethod.InputMethodManager
+import androidx.annotation.RequiresApi
+
+/**
+ * @author Jenly
+ */
+
+/**
+ * 判断是否是小写字母
+ */
+fun Char.isLowerCase(c: Char): Boolean{
+ return c.toInt() in 97..122
+}
+
+/**
+ * 判断是否是大写字母
+ */
+fun Char.isUpperCase(c: Char): Boolean{
+ return c.toInt() in 65..90
+}
+
+/**
+ * 显示系统输入法
+ */
+fun View.showSystemInputMethod(){
+ val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
+ imm.showSoftInput(this,InputMethodManager.SHOW_IMPLICIT)
+}
+
+/**
+ * 隐藏系统输入法
+ */
+fun View.hideSystemInputMethod(){
+ val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
+ imm.hideSoftInputFromWindow(windowToken,0)
+}
+
+var View.isVisible: Boolean
+ get() = visibility == View.VISIBLE
+ set(value) {
+ visibility = if (value) View.VISIBLE else View.GONE
+ }
+
+/** Returns true if the collection contains [key]. */
+@RequiresApi(16)
+fun SparseArray.containsKey(key: Int) = indexOfKey(key) >= 0
+
+/** Allows the use of the index operator for storing values in the collection. */
+@RequiresApi(16)
+operator fun SparseArray.set(key: Int, value: T) = put(key, value)
diff --git a/keybordlib/src/main/java/com/king/keyboard/KingKeyboardView.kt b/keybordlib/src/main/java/com/king/keyboard/KingKeyboardView.kt
new file mode 100644
index 0000000..1e6b55f
--- /dev/null
+++ b/keybordlib/src/main/java/com/king/keyboard/KingKeyboardView.kt
@@ -0,0 +1,316 @@
+package com.king.keyboard
+
+import android.content.Context
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.graphics.Typeface
+import android.graphics.drawable.Drawable
+import android.util.AttributeSet
+import androidx.core.content.ContextCompat
+import androidx.core.graphics.drawable.DrawableCompat
+
+/**
+ * @author Jenly
+ */
+open class KingKeyboardView : KeyboardView {
+
+
+ private var isCap = false
+
+ private var isAllCaps = false
+
+ private lateinit var config: Config
+
+ private val paint by lazy { Paint() }
+
+ companion object {
+ const val iconRatio = 0.5f
+
+ }
+
+
+ constructor(context: Context, attrs: AttributeSet?) : super(context, attrs) {
+ init(context, attrs)
+ }
+
+ constructor(context: Context, attrs: AttributeSet?, defStyleAttr: Int) : super(context, attrs, defStyleAttr) {
+ init(context, attrs)
+ }
+
+ constructor(context: Context, attrs: AttributeSet?, defStyleAttr: Int, defStyleRes: Int) : super(context, attrs, defStyleAttr, defStyleRes){
+ init(context, attrs)
+ }
+
+
+ private fun init(context: Context, attrs: AttributeSet?) {
+ config = Config(context)
+
+ var a = context.obtainStyledAttributes(attrs, R.styleable.KingKeyboardView)
+
+ a.indexCount.let {
+ config.run {
+ for (i in 0 until it) {
+ when (val attr = a.getIndex(i)) {
+ R.styleable.KingKeyboardView_kkbDeleteDrawable -> deleteDrawable = a.getDrawable(attr)
+ R.styleable.KingKeyboardView_kkbCapitalDrawable -> capitalDrawable = a.getDrawable(attr)
+ R.styleable.KingKeyboardView_kkbCapitalLockDrawable -> capitalLockDrawable = a.getDrawable(attr)
+ R.styleable.KingKeyboardView_kkbCancelDrawable -> cancelDrawable = a.getDrawable(attr)
+ R.styleable.KingKeyboardView_kkbCancelDrawable -> spaceDrawable = a.getDrawable(attr)
+ R.styleable.KingKeyboardView_android_labelTextSize -> labelTextSize = a.getDimensionPixelSize(attr, labelTextSize)
+ R.styleable.KingKeyboardView_android_keyTextSize -> keyTextSize = a.getDimensionPixelSize(attr, keyTextSize)
+ R.styleable.KingKeyboardView_android_keyTextColor -> keyTextColor = a.getColor(attr, keyTextColor)
+ R.styleable.KingKeyboardView_kkbKeyIconColor -> keyIconColor = a.getColor(attr, ContextCompat.getColor(context, R.color.king_keyboard_key_icon_color))
+ R.styleable.KingKeyboardView_kkbKeySpecialTextColor -> keySpecialTextColor = a.getColor(attr, keySpecialTextColor)
+ R.styleable.KingKeyboardView_kkbKeyDoneTextColor -> keyDoneTextColor = a.getColor(attr, keyDoneTextColor)
+ R.styleable.KingKeyboardView_kkbKeyNoneTextColor -> keyNoneTextColor = a.getColor(attr, keyNoneTextColor)
+ R.styleable.KingKeyboardView_android_keyBackground -> keyBackground = a.getDrawable(attr)
+ R.styleable.KingKeyboardView_kkbSpecialKeyBackground -> specialKeyBackground = a.getDrawable(attr)
+ R.styleable.KingKeyboardView_kkbDoneKeyBackground -> doneKeyBackground = a.getDrawable(attr)
+ R.styleable.KingKeyboardView_kkbNoneKeyBackground -> noneKeyBackground = a.getDrawable(attr)
+ R.styleable.KingKeyboardView_kkbKeyDoneTextSize -> keyDoneTextSize = a.getDimensionPixelSize(attr, keyDoneTextSize)
+ R.styleable.KingKeyboardView_kkbKeyDoneText -> keyDoneText = a.getString(attr)
+ }
+ }
+ }
+ a.recycle()
+ }
+
+ paint.textAlign = Paint.Align.CENTER
+ paint.isAntiAlias = true
+
+ }
+
+ fun getConfig(): Config {
+ return config
+ }
+
+ fun setConfig(config: Config) {
+ this.config = config
+ invalidate()
+ }
+
+ override fun onDraw(canvas: Canvas) {
+ super.onDraw(canvas)
+ drawKeyboard(canvas, keyboard?.keys)
+ }
+
+ /**
+ * 绘制键盘
+ */
+ private fun drawKeyboard(canvas: Canvas,keys: List?){
+ keys?.let {
+ for (key in it) {
+ drawKey(canvas, key)
+ }
+ }
+ }
+
+ /**
+ * 绘制键盘按键
+ */
+ private fun drawKey(canvas: Canvas, key: Keyboard.Key) {
+ when (key.codes[0]) {
+ KingKeyboard.KEYCODE_SHIFT -> drawShiftKey(canvas, key)
+ KingKeyboard.KEYCODE_MODE_CHANGE -> drawKey(canvas, key, config.specialKeyBackground, config.keySpecialTextColor)
+ KingKeyboard.KEYCODE_CANCEL -> drawCancelKey(canvas, key)
+ KingKeyboard.KEYCODE_DONE -> drawDoneKey(canvas, key)
+ KingKeyboard.KEYCODE_DELETE -> drawDeleteKey(canvas, key)
+ KingKeyboard.KEYCODE_ALT -> drawAltKey(canvas, key)
+ KingKeyboard.KEYCODE_SPACE -> drawKey(canvas, key, config.keyBackground, config.keyTextColor, config.spaceDrawable)
+ KingKeyboard.KEYCODE_NONE -> drawNoneKey(canvas, key)
+ KingKeyboard.KEYCODE_MODE_BACK -> drawKey(canvas, key, config.specialKeyBackground, config.keySpecialTextColor)
+ KingKeyboard.KEYCODE_BACK -> drawKey(canvas, key, config.specialKeyBackground, config.keySpecialTextColor)
+ KingKeyboard.KEYCODE_MORE -> drawKey(canvas, key, config.specialKeyBackground, config.keySpecialTextColor)
+ in -399..-300 -> drawKey(canvas, key, config.specialKeyBackground, config.keySpecialTextColor)
+// else -> drawKey(canvas,key,keyBackground)
+ }
+ }
+
+ /**
+ * 绘制Cancel键，常见于关闭键盘键
+ */
+ private fun drawCancelKey(canvas: Canvas, key: Keyboard.Key) {
+ drawKey(canvas, key, config.specialKeyBackground, config.keySpecialTextColor, config.cancelDrawable)
+ }
+
+ /**
+ * 绘制Done键，常见于右下角蓝色的“确定”按键
+ */
+ private fun drawDoneKey(canvas: Canvas, key: Keyboard.Key) {
+ config.keyDoneText?.let {
+ key.label = it
+ }
+ drawKey(canvas, key, config.doneKeyBackground, config.keyDoneTextColor, null, true)
+ }
+
+ /**
+ * 绘制Delete键
+ */
+ private fun drawNoneKey(canvas: Canvas, key: Keyboard.Key) {
+ drawKey(canvas, key, config.noneKeyBackground, config.keyNoneTextColor)
+ }
+
+ /**
+ * 绘制Alt键
+ */
+ private fun drawAltKey(canvas: Canvas, key: Keyboard.Key) {
+ drawKey(canvas, key, config.specialKeyBackground, config.keySpecialTextColor)
+ }
+
+ /**
+ * 绘制Delete键
+ */
+ private fun drawDeleteKey(canvas: Canvas, key: Keyboard.Key) {
+ drawKey(canvas, key, config.specialKeyBackground, config.keySpecialTextColor, config.deleteDrawable)
+ }
+
+ /**
+ * 绘制Shift键
+ */
+ private fun drawShiftKey(canvas: Canvas, key: Keyboard.Key) {
+ when {
+ isAllCaps -> drawKey(canvas, key, config.specialKeyBackground, config.keySpecialTextColor, config.capitalLockDrawable)
+ isCap -> drawKey(canvas, key, config.specialKeyBackground, config.keySpecialTextColor, config.capitalDrawable)
+ else -> drawKey(canvas, key, config.specialKeyBackground, config.keySpecialTextColor, config.lowerDrawable)
+ }
+ }
+
+ /**
+ * 绘制键盘按键
+ */
+ private fun drawKey(canvas: Canvas, key: Keyboard.Key, keyBackground: Drawable?, textColor: Int, iconDrawable: Drawable? = key.icon, isDone: Boolean = false) {
+ //绘制按键背景
+ keyBackground?.run {
+ if (key.codes[0] != 0) {
+ state = key.currentDrawableState
+ }
+
+ setBounds(
+ key.x.plus(paddingLeft),
+ key.y.plus(paddingTop),
+ key.x.plus(paddingLeft).plus(key.width),
+ key.y.plus(paddingTop).plus(key.height)
+ )
+ draw(canvas)
+ }
+
+ //绘制键盘图标
+ iconDrawable?.run {
+
+ val drawable = DrawableCompat.wrap(this)
+ config.keyIconColor?.takeIf { it != 0 }?.let {
+ drawable.setTint(it)
+ }
+
+ key.icon = drawable
+
+ var iconWidth = key.icon.intrinsicWidth.toFloat()
+ var iconHeight = key.icon.intrinsicHeight.toFloat()
+
+ val widthRatio = iconWidth.div(key.width.toFloat())
+ val heightRatio = iconHeight.div(key.height.toFloat())
+
+ if (widthRatio <= heightRatio) {//当图标的宽占比小于等于高占比时，以高度比例为基准并控制在iconRatio比例范围内，进行同比例缩放
+
+ val ratio = heightRatio.coerceAtMost(iconRatio)
+ iconWidth = iconWidth.div(heightRatio).times(ratio)
+ iconHeight = iconHeight.div(heightRatio).times(ratio)
+
+ } else {//反之，则以宽度比例为基准并控制在iconRatio比例范围内，进行同比例缩放
+
+ val ratio = widthRatio.coerceAtMost(iconRatio)
+ iconWidth = iconWidth.div(widthRatio).times(ratio)
+ iconHeight = iconHeight.div(widthRatio).times(ratio)
+
+ }
+
+ val left = key.x.plus(paddingLeft).plus(key.width.minus(iconWidth).div(2f)).toInt()
+ val top = key.y.plus(paddingTop).plus(key.height.minus(iconHeight).div(2f)).toInt()
+ val right = left.plus(iconWidth).toInt()
+ val bottom = top.plus(iconHeight).toInt()
+ key.icon.setBounds(left, top, right, bottom)
+ key.icon.draw(canvas)
+
+ } ?: key.label?.let {
+ //绘制键盘文字
+ if (isDone) {
+ paint.textSize = config.keyDoneTextSize.toFloat()
+ } else if (it.length > 1 && key.codes.size < 2) {// 键盘key内容多个字符
+ paint.textSize = config.labelTextSize.toFloat()
+ } else {
+ paint.textSize = config.keyTextSize.toFloat()
+ }
+ paint.color = textColor
+ paint.typeface = Typeface.DEFAULT
+
+ canvas.drawText(
+ it.toString(),
+ key.x.plus(paddingLeft).plus(key.width.div(2f)),
+ key.y.plus(paddingTop).plus(key.height.div(2.0f)).plus(
+ paint.textSize.minus(paint.descent()).div(2.0f)
+ ),
+ paint
+ )
+
+ }
+
+ }
+
+
+ fun setCap(isCap: Boolean) {
+ this.isCap = isCap
+ }
+
+ fun isCap(): Boolean {
+ return isCap
+ }
+
+ fun setAllCaps(isAllCaps: Boolean) {
+ this.isAllCaps = isAllCaps
+ }
+
+ fun isAllCaps(): Boolean {
+ return isAllCaps
+ }
+
+ /**
+ * Config为KingKeyboard的配置类，方便统一管理配置信息
+ */
+ open class Config(context: Context) {
+
+ var deleteDrawable = context.getDrawable(R.drawable.king_keyboard_key_delete)
+ var lowerDrawable = context.getDrawable(R.drawable.king_keyboard_key_lower)
+ var capitalDrawable = context.getDrawable(R.drawable.king_keyboard_key_cap)
+ var capitalLockDrawable = context.getDrawable(R.drawable.king_keyboard_key_all_caps)
+ var cancelDrawable = context.getDrawable(R.drawable.king_keyboard_key_cancel)
+ var spaceDrawable = context.getDrawable(R.drawable.king_keyboard_key_space)
+
+ var labelTextSize = context.resources.getDimensionPixelSize(R.dimen.king_keyboard_label_text_size)
+
+ var keyTextSize = context.resources.getDimensionPixelSize(R.dimen.king_keyboard_text_size)
+
+ var keyTextColor = ContextCompat.getColor(context, R.color.king_keyboard_key_text_color)
+
+ var keyIconColor: Int? = null
+
+ var keySpecialTextColor = ContextCompat.getColor(context, R.color.king_keyboard_key_special_text_color)
+
+ var keyDoneTextColor = ContextCompat.getColor(context, R.color.king_keyboard_key_done_text_color)
+
+ var keyNoneTextColor = ContextCompat.getColor(context, R.color.king_keyboard_key_none_text_color)
+
+ var keyBackground = context.getDrawable(R.drawable.king_keyboard_key_bg)
+
+ var specialKeyBackground = context.getDrawable(R.drawable.king_keyboard_special_key_bg)
+
+ var doneKeyBackground = context.getDrawable(R.drawable.king_keyboard_done_key_bg)
+ var noneKeyBackground = context.getDrawable(R.drawable.king_keyboard_none_key_bg)
+
+ var keyDoneTextSize = context.resources.getDimensionPixelSize(R.dimen.king_keyboard_done_text_size)
+
+ var keyDoneText: CharSequence? = context.getString(R.string.king_keyboard_key_done_text)
+
+ }
+
+
+}
\ No newline at end of file
diff --git a/keybordlib/src/main/res/drawable-xxhdpi/king_keyboard_key_all_caps.png b/keybordlib/src/main/res/drawable-xxhdpi/king_keyboard_key_all_caps.png
new file mode 100644
index 0000000..e53dd00
Binary files /dev/null and b/keybordlib/src/main/res/drawable-xxhdpi/king_keyboard_key_all_caps.png differ
diff --git a/keybordlib/src/main/res/drawable-xxhdpi/king_keyboard_key_cancel.png b/keybordlib/src/main/res/drawable-xxhdpi/king_keyboard_key_cancel.png
new file mode 100644
index 0000000..a5f18e1
Binary files /dev/null and b/keybordlib/src/main/res/drawable-xxhdpi/king_keyboard_key_cancel.png differ
diff --git a/keybordlib/src/main/res/drawable-xxhdpi/king_keyboard_key_cap.png b/keybordlib/src/main/res/drawable-xxhdpi/king_keyboard_key_cap.png
new file mode 100644
index 0000000..18ebe8a
Binary files /dev/null and b/keybordlib/src/main/res/drawable-xxhdpi/king_keyboard_key_cap.png differ
diff --git a/keybordlib/src/main/res/drawable-xxhdpi/king_keyboard_key_delete.png b/keybordlib/src/main/res/drawable-xxhdpi/king_keyboard_key_delete.png
new file mode 100644
index 0000000..8cbc449
Binary files /dev/null and b/keybordlib/src/main/res/drawable-xxhdpi/king_keyboard_key_delete.png differ
diff --git a/keybordlib/src/main/res/drawable-xxhdpi/king_keyboard_key_license_plate.png b/keybordlib/src/main/res/drawable-xxhdpi/king_keyboard_key_license_plate.png
new file mode 100644
index 0000000..62a4eda
Binary files /dev/null and b/keybordlib/src/main/res/drawable-xxhdpi/king_keyboard_key_license_plate.png differ
diff --git a/keybordlib/src/main/res/drawable-xxhdpi/king_keyboard_key_license_plate_number.png b/keybordlib/src/main/res/drawable-xxhdpi/king_keyboard_key_license_plate_number.png
new file mode 100644
index 0000000..d437ea4
Binary files /dev/null and b/keybordlib/src/main/res/drawable-xxhdpi/king_keyboard_key_license_plate_number.png differ
diff --git a/keybordlib/src/main/res/drawable-xxhdpi/king_keyboard_key_lower.png b/keybordlib/src/main/res/drawable-xxhdpi/king_keyboard_key_lower.png
new file mode 100644
index 0000000..6842e3e
Binary files /dev/null and b/keybordlib/src/main/res/drawable-xxhdpi/king_keyboard_key_lower.png differ
diff --git a/keybordlib/src/main/res/drawable-xxhdpi/king_keyboard_key_space.png b/keybordlib/src/main/res/drawable-xxhdpi/king_keyboard_key_space.png
new file mode 100644
index 0000000..4ecade1
Binary files /dev/null and b/keybordlib/src/main/res/drawable-xxhdpi/king_keyboard_key_space.png differ
diff --git a/keybordlib/src/main/res/drawable-xxhdpi/king_keyboard_view_bg.9.png b/keybordlib/src/main/res/drawable-xxhdpi/king_keyboard_view_bg.9.png
new file mode 100644
index 0000000..c8dfb1d
Binary files /dev/null and b/keybordlib/src/main/res/drawable-xxhdpi/king_keyboard_view_bg.9.png differ
diff --git a/keybordlib/src/main/res/drawable/king_keyboard_done_key_bg.xml b/keybordlib/src/main/res/drawable/king_keyboard_done_key_bg.xml
new file mode 100644
index 0000000..06268a7
--- /dev/null
+++ b/keybordlib/src/main/res/drawable/king_keyboard_done_key_bg.xml
@@ -0,0 +1,17 @@
+
+
+ -
+
+
+
+
+
+
+ -
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/keybordlib/src/main/res/drawable/king_keyboard_key_bg.xml b/keybordlib/src/main/res/drawable/king_keyboard_key_bg.xml
new file mode 100644
index 0000000..06b04c6
--- /dev/null
+++ b/keybordlib/src/main/res/drawable/king_keyboard_key_bg.xml
@@ -0,0 +1,17 @@
+
+
+ -
+
+
+
+
+
+
+ -
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/keybordlib/src/main/res/drawable/king_keyboard_none_key_bg.xml b/keybordlib/src/main/res/drawable/king_keyboard_none_key_bg.xml
new file mode 100644
index 0000000..fbcb125
--- /dev/null
+++ b/keybordlib/src/main/res/drawable/king_keyboard_none_key_bg.xml
@@ -0,0 +1,17 @@
+
+
+ -
+
+
+
+
+
+
+ -
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/keybordlib/src/main/res/drawable/king_keyboard_special_key_bg.xml b/keybordlib/src/main/res/drawable/king_keyboard_special_key_bg.xml
new file mode 100644
index 0000000..8ee8cb6
--- /dev/null
+++ b/keybordlib/src/main/res/drawable/king_keyboard_special_key_bg.xml
@@ -0,0 +1,17 @@
+
+
+ -
+
+
+
+
+
+
+ -
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/keybordlib/src/main/res/layout/king_keyboard_container.xml b/keybordlib/src/main/res/layout/king_keyboard_container.xml
new file mode 100644
index 0000000..07bb908
--- /dev/null
+++ b/keybordlib/src/main/res/layout/king_keyboard_container.xml
@@ -0,0 +1,20 @@
+
+
+
+
\ No newline at end of file
diff --git a/keybordlib/src/main/res/values-zh/strings.xml b/keybordlib/src/main/res/values-zh/strings.xml
new file mode 100644
index 0000000..6be2a21
--- /dev/null
+++ b/keybordlib/src/main/res/values-zh/strings.xml
@@ -0,0 +1,6 @@
+
+
+ 完成
+ 更多
+ 返回
+
\ No newline at end of file
diff --git a/keybordlib/src/main/res/values/attrs.xml b/keybordlib/src/main/res/values/attrs.xml
new file mode 100644
index 0000000..21ad7eb
--- /dev/null
+++ b/keybordlib/src/main/res/values/attrs.xml
@@ -0,0 +1,106 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/keybordlib/src/main/res/values/colors.xml b/keybordlib/src/main/res/values/colors.xml
new file mode 100644
index 0000000..bbee4be
--- /dev/null
+++ b/keybordlib/src/main/res/values/colors.xml
@@ -0,0 +1,26 @@
+
+
+
+ #ff333333
+
+ #ff333333
+
+ #ffeeeeee
+
+ #7f999999
+
+ #ff333333
+
+ #ffffffff
+ #ffbbbbbb
+
+ #ffa8afbf
+ #ff989faf
+
+ #ff0477ff
+ #ff0467ef
+
+ #ffefefef
+ #ffefefef
+
+
\ No newline at end of file
diff --git a/keybordlib/src/main/res/values/dimens.xml b/keybordlib/src/main/res/values/dimens.xml
new file mode 100644
index 0000000..921a721
--- /dev/null
+++ b/keybordlib/src/main/res/values/dimens.xml
@@ -0,0 +1,22 @@
+
+
+
+ 48dp
+ 101dp
+ 154dp
+
+ 5dp
+ 10dp
+
+ 6dp
+ 6dp
+
+ 56dp
+
+ 20sp
+
+ 20sp
+
+ 16sp
+
+
\ No newline at end of file
diff --git a/keybordlib/src/main/res/values/strings.xml b/keybordlib/src/main/res/values/strings.xml
new file mode 100644
index 0000000..c77cb45
--- /dev/null
+++ b/keybordlib/src/main/res/values/strings.xml
@@ -0,0 +1,5 @@
+
+ Done
+ More
+ Back
+
diff --git a/keybordlib/src/main/res/xml/king_keyboard_id_card.xml b/keybordlib/src/main/res/xml/king_keyboard_id_card.xml
new file mode 100644
index 0000000..73b79b1
--- /dev/null
+++ b/keybordlib/src/main/res/xml/king_keyboard_id_card.xml
@@ -0,0 +1,71 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/keybordlib/src/main/res/xml/king_keyboard_letter.xml b/keybordlib/src/main/res/xml/king_keyboard_letter.xml
new file mode 100644
index 0000000..cffe8c3
--- /dev/null
+++ b/keybordlib/src/main/res/xml/king_keyboard_letter.xml
@@ -0,0 +1,125 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/keybordlib/src/main/res/xml/king_keyboard_letter_number.xml b/keybordlib/src/main/res/xml/king_keyboard_letter_number.xml
new file mode 100644
index 0000000..e8babb9
--- /dev/null
+++ b/keybordlib/src/main/res/xml/king_keyboard_letter_number.xml
@@ -0,0 +1,183 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/keybordlib/src/main/res/xml/king_keyboard_license_plate.xml b/keybordlib/src/main/res/xml/king_keyboard_license_plate.xml
new file mode 100644
index 0000000..d71089e
--- /dev/null
+++ b/keybordlib/src/main/res/xml/king_keyboard_license_plate.xml
@@ -0,0 +1,163 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/keybordlib/src/main/res/xml/king_keyboard_license_plate_more.xml b/keybordlib/src/main/res/xml/king_keyboard_license_plate_more.xml
new file mode 100644
index 0000000..4ab62f2
--- /dev/null
+++ b/keybordlib/src/main/res/xml/king_keyboard_license_plate_more.xml
@@ -0,0 +1,163 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/keybordlib/src/main/res/xml/king_keyboard_license_plate_number.xml b/keybordlib/src/main/res/xml/king_keyboard_license_plate_number.xml
new file mode 100644
index 0000000..f0443a3
--- /dev/null
+++ b/keybordlib/src/main/res/xml/king_keyboard_license_plate_number.xml
@@ -0,0 +1,154 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/keybordlib/src/main/res/xml/king_keyboard_license_plate_province.xml b/keybordlib/src/main/res/xml/king_keyboard_license_plate_province.xml
new file mode 100644
index 0000000..8a2ee0c
--- /dev/null
+++ b/keybordlib/src/main/res/xml/king_keyboard_license_plate_province.xml
@@ -0,0 +1,154 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/keybordlib/src/main/res/xml/king_keyboard_lowercase_letter_only.xml b/keybordlib/src/main/res/xml/king_keyboard_lowercase_letter_only.xml
new file mode 100644
index 0000000..9a426c1
--- /dev/null
+++ b/keybordlib/src/main/res/xml/king_keyboard_lowercase_letter_only.xml
@@ -0,0 +1,118 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/keybordlib/src/main/res/xml/king_keyboard_normal.xml b/keybordlib/src/main/res/xml/king_keyboard_normal.xml
new file mode 100644
index 0000000..4b4ca21
--- /dev/null
+++ b/keybordlib/src/main/res/xml/king_keyboard_normal.xml
@@ -0,0 +1,141 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/keybordlib/src/main/res/xml/king_keyboard_normal_mode_change.xml b/keybordlib/src/main/res/xml/king_keyboard_normal_mode_change.xml
new file mode 100644
index 0000000..7997424
--- /dev/null
+++ b/keybordlib/src/main/res/xml/king_keyboard_normal_mode_change.xml
@@ -0,0 +1,147 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/keybordlib/src/main/res/xml/king_keyboard_normal_more_symbol.xml b/keybordlib/src/main/res/xml/king_keyboard_normal_more_symbol.xml
new file mode 100644
index 0000000..09ba3a8
--- /dev/null
+++ b/keybordlib/src/main/res/xml/king_keyboard_normal_more_symbol.xml
@@ -0,0 +1,147 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/keybordlib/src/main/res/xml/king_keyboard_number.xml b/keybordlib/src/main/res/xml/king_keyboard_number.xml
new file mode 100644
index 0000000..8674ef8
--- /dev/null
+++ b/keybordlib/src/main/res/xml/king_keyboard_number.xml
@@ -0,0 +1,71 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/keybordlib/src/main/res/xml/king_keyboard_number_decimal.xml b/keybordlib/src/main/res/xml/king_keyboard_number_decimal.xml
new file mode 100644
index 0000000..5ffc8e6
--- /dev/null
+++ b/keybordlib/src/main/res/xml/king_keyboard_number_decimal.xml
@@ -0,0 +1,71 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/keybordlib/src/main/res/xml/king_keyboard_phone.xml b/keybordlib/src/main/res/xml/king_keyboard_phone.xml
new file mode 100644
index 0000000..ffca546
--- /dev/null
+++ b/keybordlib/src/main/res/xml/king_keyboard_phone.xml
@@ -0,0 +1,71 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/keybordlib/src/main/res/xml/king_keyboard_uppercase_letter_only.xml b/keybordlib/src/main/res/xml/king_keyboard_uppercase_letter_only.xml
new file mode 100644
index 0000000..00dd27a
--- /dev/null
+++ b/keybordlib/src/main/res/xml/king_keyboard_uppercase_letter_only.xml
@@ -0,0 +1,118 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/keybordlib/src/test/java/com/king/keyboard/ExampleUnitTest.kt b/keybordlib/src/test/java/com/king/keyboard/ExampleUnitTest.kt
new file mode 100644
index 0000000..3fa56f9
--- /dev/null
+++ b/keybordlib/src/test/java/com/king/keyboard/ExampleUnitTest.kt
@@ -0,0 +1,18 @@
+package com.king.keyboard
+
+import org.junit.Test
+
+import org.junit.Assert.*
+
+/**
+ * Example local unit test, which will execute on the development machine (host).
+ *
+ * See [testing documentation](http://d.android.com/tools/testing).
+ */
+class ExampleUnitTest {
+ @Test
+ fun addition_isCorrect() {
+ assertEquals(4, 2 + 2)
+ }
+
+}
diff --git a/settings.gradle b/settings.gradle
index e0fc324..340c83a 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -1,3 +1,4 @@
rootProject.name = "Pass"
include ':app'
include ':mylibrary'
+include ':keybordlib'