android 自定义软键盘 例子源码下载

【实例简介】

【实例截图】

【核心代码】

package com.example.keyboard;

import java.lang.reflect.Method;

import android.app.Activity;
import android.content.Context;
import android.os.Bundle;
import android.text.InputType;
import android.view.KeyEvent;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.WindowManager;
import android.view.inputmethod.InputMethodManager;
import android.widget.EditText;
import android.widget.RelativeLayout;

public class HomeActivity extends Activity {
private Activity act;
private EditText edit;
private RelativeLayout keyboardContent;
private KeyboardUtil keyboardUtil;

// private PopupWindow popupWindow;

@Override
public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.home);

act = this;

edit = (EditText) findViewById(R.id.edit);

keyboardContent = (RelativeLayout) findViewById(R.id.keyboardContent);

disableSysKeyboard(edit);

edit.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
showKeyboard();
return;
}
});

}

// 打开软键盘
private void showKeyboard() {
if (keyboardUtil == null) {
keyboardUtil = new KeyboardUtil(act, edit, keyboardContent);
keyboardUtil.showKeyboard();
} else if (!keyboardUtil.isShowing()) {
keyboardUtil.showKeyboard();
}
}

// 禁用系统键盘
private void disableSysKeyboard(EditText editText) {
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(editText.getWindowToken(), 0);

if (android.os.Build.VERSION.SDK_INT <= 10) {
editText.setInputType(InputType.TYPE_NULL);
} else { // 解决4.0中屏蔽掉系统键盘光标丢失问题
getWindow().setSoftInputMode(
WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
try {
Class<EditText> cls = EditText.class;
Method setSoftInputShownOnFocus;
setSoftInputShownOnFocus = cls.getMethod(
"setSoftInputShownOnFocus", boolean.class);
setSoftInputShownOnFocus.setAccessible(true);
setSoftInputShownOnFocus.invoke(editText, false);
} catch (Exception e) {
e.printStackTrace();
}
}
}

@Override
public boolean dispatchKeyEvent(KeyEvent event) {

// 按下动作监听
if (event.getAction() == KeyEvent.ACTION_DOWN) {

// 判断当前是否已经显示了软键盘,如果已经显示则执行软键盘的监听事件
if (keyboardUtil != null && keyboardUtil.isShowing()) {
keyboardUtil.performOnKey(event);
return true;
}

// 当文本框获得焦点
if (edit.hasFocus()) {
if (event.getKeyCode() == KeyEvent.KEYCODE_ENTER) { // 执行按下操作
// 显示软键盘
showKeyboard();
return true;
}
}
}
return super.dispatchKeyEvent(event);
}

// private void showPopupWindow() {
// if (popupWindow == null) {
// LinearLayout layout = (LinearLayout) getLayoutInflater().inflate(
// R.layout.key_pop, null);
// popupWindow = new PopupWindow(layout, LayoutParams.WRAP_CONTENT,
// LayoutParams.WRAP_CONTENT);
// new KeyboardUtil(this, edit,layout);
// popupWindow.showAtLocation(this.findViewById(R.id.root),
// Gravity.CENTER, 0, 0);
// popupWindow.setFocusable(true);
// }
// // popupWindow.update();
// }

}


package com.example.keyboard;

import java.util.List;

import android.app.Activity;
import android.inputmethodservice.Keyboard;
import android.inputmethodservice.Keyboard.Key;
import android.inputmethodservice.KeyboardView.OnKeyboardActionListener;
import android.text.Editable;
import android.view.KeyEvent;
import android.view.View;
import android.view.View.OnKeyListener;
import android.widget.EditText;

public class KeyboardUtil {

private MyKeyboardView keyboardView;
private Keyboard k1; // 字母键盘
private Keyboard k2; // 数字键盘
private View view;

public boolean isnun = false;// 是否数据键盘
public boolean isupper = false;// 是否大写

private EditText ed;

private int nCurKeyboardKeyNums;
private Keyboard nCurrentKeyboard;
private List<Keyboard.Key> nKeys;
private int nLastKeyIndex = 0;

public KeyboardUtil(Activity act, EditText edit, View view) {

this.ed = edit;

this.view = view;

k1 = new Keyboard(act, R.xml.qwerty);
k2 = new Keyboard(act, R.xml.symbols);

keyboardView = (MyKeyboardView) view.findViewById(R.id.keyboard_view);

keyboardView.setKeyboard(k1);

keyboardView.setEnabled(true);
keyboardView.setPreviewEnabled(false);
keyboardView.setOnKeyboardActionListener(listener2);
keyboardView.setOnKeyListener(onKeyListener);

}

// 遥控器操作监听
private OnKeyListener onKeyListener = new OnKeyListener() {

@Override
public boolean onKey(View v, int keyCode, KeyEvent event) {
if (event.getAction() == KeyEvent.ACTION_DOWN) {
switch (keyCode) {

// 返回操作
case KeyEvent.KEYCODE_BACK:
if (event.getRepeatCount() == 0 && keyboardView != null) {
if (keyboardView.handleBack()) {
return true;
}
}
break;

// 下键操作
case KeyEvent.KEYCODE_DPAD_DOWN:
setFields();
if (nLastKeyIndex >= nCurKeyboardKeyNums - 1) {
if (null == keyboardView)
return false;
keyboardView.setLastKeyIndex(0);
} else {
int[] nearestKeyIndices = nCurrentKeyboard
.getNearestKeys(nKeys.get(nLastKeyIndex).x,
nKeys.get(nLastKeyIndex).y);

for (int index : nearestKeyIndices) {
if (nLastKeyIndex < index) {
Key nearKey = nKeys.get(index);
Key lastKey = nKeys.get(nLastKeyIndex);
if (((lastKey.x >= nearKey.x) // left side
// compare
&& (lastKey.x < (nearKey.x nearKey.width)))
|| (((lastKey.x lastKey.width) > nearKey.x) // right
// side
// compare
&& ((lastKey.x lastKey.width) <= (nearKey.x nearKey.width)))) {
keyboardView.setLastKeyIndex(index);
break;
}
}
}// end for loop

}
keyboardView.invalidate();
// break;
return true;

case KeyEvent.KEYCODE_DPAD_UP:

setFields();
if (nLastKeyIndex <= 0) {
if (null == keyboardView)
return false;
keyboardView.setLastKeyIndex(nCurKeyboardKeyNums - 1);
} else {
int[] nearestKeyIndices = nCurrentKeyboard
.getNearestKeys(nKeys.get(nLastKeyIndex).x,
nKeys.get(nLastKeyIndex).y);

for (int i = nearestKeyIndices.length - 1; i >= 0; i--) {
int index = nearestKeyIndices[i];
if (nLastKeyIndex > index) {
// 获得下一个键
Key nearKey = nKeys.get(index);
Key nextNearKey = nKeys.get(index 1);
// 获取当前显示的
Key lastKey = nKeys.get(nLastKeyIndex);
if (((lastKey.x >= nearKey.x)
&& (lastKey.x < (nearKey.x nearKey.width)) && (((lastKey.x lastKey.width) <= (nextNearKey.x nextNearKey.width)) || ((lastKey.x lastKey.width) > nextNearKey.x)))) {
keyboardView.setLastKeyIndex(index);
break;
}
}
}
}
keyboardView.invalidate();
// break;
return true;

// 左键操作
case KeyEvent.KEYCODE_DPAD_LEFT:

setFields();
if (nLastKeyIndex <= 0) {
if (null == keyboardView)
return false;
keyboardView.setLastKeyIndex(nCurKeyboardKeyNums - 1);
} else {
nLastKeyIndex--;
keyboardView.setLastKeyIndex(nLastKeyIndex);
}
keyboardView.invalidate();
// break;
return true;

// 右键操作
case KeyEvent.KEYCODE_DPAD_RIGHT:
setFields();
if (nLastKeyIndex >= nCurKeyboardKeyNums - 1) {
if (null == keyboardView)
return false;
keyboardView.setLastKeyIndex(0);
} else {
nLastKeyIndex ;
keyboardView.setLastKeyIndex(nLastKeyIndex);
}
keyboardView.invalidate();
// break;
return true;

// 按下确定键
case KeyEvent.KEYCODE_ENTER:
if (null == keyboardView) {
return false;
}
setFields();
Editable editable = ed.getText();
int start = ed.getSelectionStart();
int curKeyCode = nKeys.get(nLastKeyIndex).codes[0];

switch (curKeyCode) {

case Keyboard.KEYCODE_SHIFT: // 按下shift键
changeKey();
keyboardView.setKeyboard(k1);
break;

case -2: // 数字字母键盘切换
if (isnun) {
isnun = false;
keyboardView.setKeyboard(k1);
} else {
isnun = true;
keyboardView.setKeyboard(k2);
}
keyboardView.setLastKeyIndex(0); // 重置上一个键的index
break;

case Keyboard.KEYCODE_CANCEL: // 关闭键盘
hideKeyboard();
break;

case Keyboard.KEYCODE_DELETE: // 回退
if (editable != null && editable.length() > 0) {
if (start > 0) {
editable.delete(start - 1, start);
}
}
break;

case 57419: // 向左
if (start > 0) {
ed.setSelection(start - 1);
}
break;

case 57421: // 向右
if (start < ed.length()) {
ed.setSelection(start 1);
}
break;

default:
editable.insert(start,
Character.toString((char) curKeyCode));
return true;
}
default:
break;
}
}
return false;
}

};

private OnKeyboardActionListener listener2 = new OnKeyboardActionListener() {
@Override
public void swipeUp() {
}

@Override
public void swipeRight() {
}

@Override
public void swipeLeft() {
}

@Override
public void swipeDown() {
}

@Override
public void onText(CharSequence text) {
}

@Override
public void onRelease(int primaryCode) {
}

@Override
public void onPress(int primaryCode) {
}

@Override
public void onKey(int primaryCode, int[] keyCodes) {
Editable editable = ed.getText();
int start = ed.getSelectionStart();
if (primaryCode == Keyboard.KEYCODE_CANCEL) {// 完成
hideKeyboard();
} else if (primaryCode == Keyboard.KEYCODE_DELETE) {// 回退
if (editable != null && editable.length() > 0) {
if (start > 0) {
editable.delete(start - 1, start);
}
}
} else if (primaryCode == Keyboard.KEYCODE_SHIFT) {// 大小写切换
changeKey();
keyboardView.setKeyboard(k1);
} else if (primaryCode == Keyboard.KEYCODE_MODE_CHANGE) {// 数字键盘切换
if (isnun) {
isnun = false;
keyboardView.setKeyboard(k1);
} else {
isnun = true;
keyboardView.setKeyboard(k2);
}
keyboardView.setLastKeyIndex(0); // 重置上一个键的index
} else if (primaryCode == 57419) { // go left
if (start > 0) {
ed.setSelection(start - 1);
}
} else if (primaryCode == 57421) { // go right
if (start < ed.length()) {
ed.setSelection(start 1);
}
} else {
editable.insert(start, Character.toString((char) primaryCode));
}
}
};

// 键盘大小写切换
private void changeKey() {
List<Key> keylist = k1.getKeys();
if (isupper) {// 大写切换小写
isupper = false;
for (Key key : keylist) {
if (key.label != null && isword(key.label.toString())) {
key.label = key.label.toString().toLowerCase();
key.codes[0] = key.codes[0] 32;
}
}
} else {// 小写切换大写
isupper = true;
for (Key key : keylist) {
if (key.label != null && isword(key.label.toString())) {
key.label = key.label.toString().toUpperCase();
key.codes[0] = key.codes[0] - 32;
}
}
}
}

private boolean isword(String str) {
String wordstr = "abcdefghijklmnopqrstuvwxyz";
if (wordstr.indexOf(str.toLowerCase()) > -1) {
return true;
}
return false;
}

// 重置变量
private void setFields() {
if (null == keyboardView)
return;
nCurrentKeyboard = keyboardView.getKeyboard();
nKeys = nCurrentKeyboard.getKeys();
nCurKeyboardKeyNums = nKeys.size();
nLastKeyIndex = keyboardView.getLastKeyIndex();
}

// 显示软键盘
public void showKeyboard() {
int visibility = view.getVisibility();
if (visibility == View.GONE) {
view.setVisibility(View.VISIBLE);
keyboardView.setVisibility(View.VISIBLE);
keyboardView.setKeyboard(k1); // 重置成小写键盘
keyboardView.setLastKeyIndex(0); // 重置索引为成第一个键
}
}

// 隐藏软键盘
public void hideKeyboard() {
int visibility = view.getVisibility();
if (visibility == View.VISIBLE) {
view.setVisibility(View.GONE);
keyboardView.setVisibility(View.GONE);
}
}

// 判断软键盘是否显示
public boolean isShowing() {
if (keyboardView.getVisibility() == View.VISIBLE) {
return true;
}
return false;
}

public void performOnKey(KeyEvent event) {
onKeyListener.onKey(keyboardView, event.getKeyCode(), event);
}

}




package com.example.keyboard;

import java.util.ArrayList;
import java.util.List;

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Paint.Align;
import android.graphics.Paint.FontMetrics;
import android.graphics.Rect;
import android.graphics.Typeface;
import android.graphics.drawable.NinePatchDrawable;
import android.inputmethodservice.Keyboard;
import android.inputmethodservice.Keyboard.Key;
import android.inputmethodservice.KeyboardView;
import android.util.AttributeSet;

public class MyKeyboardView extends KeyboardView {

private Keyboard currentKeyboard;
private List<Key> keys = new ArrayList<Key>();
private int lastKeyIndex = 0;
private Key focusedKey;

public MyKeyboardView(Context context, AttributeSet attrs) {
super(context, attrs);
}

@Override
public void onDraw(Canvas canvas) {

super.onDraw(canvas);

currentKeyboard = this.getKeyboard();

keys = currentKeyboard.getKeys();

focusedKey = keys.get(lastKeyIndex);

String label = focusedKey.label == null ? null : adjustCase(
focusedKey.label).toString();

//获取得到焦点时的.9格式背景图片
NinePatchDrawable keyBackground = (NinePatchDrawable) getResources()
.getDrawable(R.drawable.keyboard_letter_focus);

final Rect bounds = keyBackground.getBounds();
if (focusedKey.width != bounds.right
|| focusedKey.height != bounds.bottom) {
keyBackground.setBounds(0, 0, focusedKey.width, focusedKey.height);
}

canvas.translate(focusedKey.x, focusedKey.y);

keyBackground.draw(canvas);

Paint paint = new Paint();

if (label != null) {

paint.setTextSize((float) 28); // 设置文字大小

if (label.toString().length() > 1) {
paint.setTextSize((float) 21); // 设置文字大小
paint.setTypeface(Typeface.DEFAULT_BOLD);
}

paint.setTextAlign(Align.CENTER); // 设置文字水平居中

paint.setColor(Color.WHITE); // 设置文字颜色

FontMetrics fontMetrics = paint.getFontMetrics();
// 计算文字高度
float fontHeight = fontMetrics.bottom - fontMetrics.top;

// 计算文字baseline
float textBaseY = focusedKey.height
- (focusedKey.height - fontHeight) / 2 - fontMetrics.bottom;

// 重绘文字
canvas.drawText(label, (focusedKey.width) / 2, textBaseY, paint);
}

}

private CharSequence adjustCase(CharSequence label) {
if (currentKeyboard.isShifted() && label != null && label.length() < 3
&& Character.isLowerCase(label.charAt(0))) {
label = label.toString().toUpperCase();
}
return label;
}

public int getLastKeyIndex() {
return lastKeyIndex;
}

public void setLastKeyIndex(int index) {
this.lastKeyIndex = index;
}

}