Android 中自定义软键盘

2401_85122756

于 2024-06-20 12:09:36 发布

阅读量553

点赞数 22

文章标签： android java 开发语言

本文链接：https://blog.csdn.net/2401_85122756/article/details/139828893

版权

}

String password_ = “password”;

@Override

protected void onFocusChanged(boolean focused, int direction,

Rect previouslyFocusedRect) {

// TODO Auto-generated method stub

super.onFocusChanged(focused, direction, previouslyFocusedRect);

}

public boolean dispatchTouchEvent(MotionEvent event) {

// TODO Auto-generated method stub

this.requestFocus();

boolean rt = false;

if(null != password_ && password_.equalsIgnoreCase(“password”)){

bv_.inputManager_.hideSoftInputFromWindow(this.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);

if(bv_.dlg == null || !bv_.dlg.isShowing()){

if(this.isEnabled()){

bv_.OnCreateInputWindow(this);

rt = true;

}

return super.dispatchTouchEvent(event);

}

public String getContentText() {

return super.getText().toString();

}

public String getLabel() {

// TODO Auto-generated method stub

// 由于国航项目取消了输入框的label。

// 改为将label作hint显示，嵌入到输入框中，所以作此改动

String str = “”;

if (null != this.getHint()) {

str = this.getHint().toString();

if ((null == str) || (str.equals(“”)))

str = “”;

}

return str;

}

/**

public boolean onKeyDown(int keyCode, KeyEvent event) {

return super.onKeyDown(keyCode, event);

}

@Override

protected void onTextChanged(CharSequence text, int start,

int lengthBefore, int lengthAfter) {

super.onTextChanged(text, start, lengthBefore, lengthAfter);

}

String checkText(String text) {

if (minValue_ == -1 && maxValue_ == -1)

return text;

if (text == null || text.equals(“”))

return text;

Double sour = Double.parseDouble(text);

if ((maxValue_ != -1) && sour >= maxValue_) {

alartInfo = hint_ + “不能大于” + maxValue_;

sour = maxValue_;

}

if ((minValue_ != -1) && sour <= minValue_) {

alartInfo = hint_ + “不能小于” + minValue_;

sour = minValue_;

}

String destext = null;

// 判断输入的内容是否有小数。

if (sour % 1 < 0.001) {

destext = (sour + “”).substring(0, (sour + “”).indexOf(“.”));

}

if (sour % 1 > 0.001) {

destext = sour.toString();

}

return destext;

}

public boolean getPasswordMark() {

return isPasswordWidget_;

}

// 设置密码输入框标志，如果控件是密码输入框，则该方法一定要执行

public void setPasswordMark(boolean iswork) {

isPasswordWidget_ = iswork;

}

public void setContentText(String text) {

// TODO Auto-generated method stub

this.setText(text);

}

public void setEditable_(boolean editable_) {

this.editable_ = editable_;

}

public void shrinkWidth() {

// TODO Auto-generated method stub

}

public void cleanText() {

// TODO Auto-generated method stub

}

public void setLPHeidht(int height) {

// TODO Auto-generated method stub

}

public void setLPWidth(int width) {

// TODO Auto-generated method stub

}

public View getLPView() {

return this;

}

public int getLPHeight() {

return height_;

}

public int getLPWidth() {

return width_;

}

public void setInTable(boolean inTable) {

// TODO Auto-generated method stub

}

public boolean isInTable() {

// TODO Auto-generated method stub

return false;

}

/**

密码键盘，字母、数字随机排列显示

public class LPKeyBoard extends LinearLayout {

private PopupWindow popWindow_;

Dialog dlg_;

boolean isShow_ = false;

LPImfView imfView;

MainActivity bv_;

EditText tempEdit_;

buttonOk btnOK_; // 确定按钮

// 判断当前输入框输入类型是否是数字

boolean inputTypeNumber_ = false;

// cs模板定义的输入长度限制

int maxSize;

private Vibrator vibrator_;

private static final long VIBRATE_DURATION = 30L;

public LPKeyBoard(Context context, LPTextField text) {

super(context);

// TODO Auto-generated constructor stub

bv_ = (MainActivity) context;

btnOK_ = new buttonOk(context, false);

tempEdit_ = new EditText(context);

tempEdit_.setTextSize(15);

tempEdit_.setHeight(text.getHeight() - 10);

// tempEdit_.setWidth(LPUtils.screenWidth_);

tempEdit_.setFocusable(false);

tempEdit_.setBackgroundResource(R.drawable.bg_edittext);

vibrator_ = (Vibrator) bv_.getSystemService(Context.VIBRATOR_SERVICE);

tempEdit_.setGravity(Gravity.RIGHT | Gravity.CENTER_VERTICAL);

if (text.getInputType() == android.text.InputType.TYPE_CLASS_NUMBER) {

inputTypeNumber_ = true;

}

if (inputTypeNumber_) {

tempEdit_.setLayoutParams(new LinearLayout.LayoutParams(

LPUtils.screenWidth_, LayoutParams.WRAP_CONTENT));

this.addView(tempEdit_);

} else {

tempEdit_.setLayoutParams(new LinearLayout.LayoutParams(

LPUtils.screenWidth_ * 4 / 5, LayoutParams.WRAP_CONTENT));

LinearLayout ll = new LinearLayout(context);

ll.setOrientation(LinearLayout.HORIZONTAL);

ll.setLayoutParams(new LayoutParams(LayoutParams.FILL_PARENT,

LayoutParams.WRAP_CONTENT));

ll.addView(tempEdit_);

LayoutParams lp = new LayoutParams(LPUtils.screenWidth_ / 5

LPUtils.getScaledValue(6), text.getHeight() - 10);

ll.addView(btnOK_, lp);

lp.setMargins(LPUtils.getScaledValue(4), 0, 0, 0);

this.addView(ll);

}

if (null != text.getHint()) {

tempEdit_.setHint(text.getHint());

}

imfView = new LPImfView(context, text);

this.addView(imfView);

requestFocus();

this.setClickable(true);

this.setBackgroundResource(R.drawable.keyboard_bg);

this.setLayoutParams(new LinearLayout.LayoutParams(

LayoutParams.FILL_PARENT, LayoutParams.WRAP_CONTENT));

this.setOrientation(LinearLayout.VERTICAL);

}

class LPImfView extends TextView {

private int PAINT_SIZE = 22;

private int BORDER = LPUtils.getScaledValue(2);

private int BORDER_TOP = LPUtils.getScaledValue(4);

private int BORDER_CENTER = LPUtils.getScaledValue(5);

private int colW_one = LPUtils.getScaledValue(4);

private int colW_two = LPUtils.getScaledValue(6);

private int BORDER_TWO = LPUtils.getScaledValue(6);

private int windownShow_W = LPUtils.getScaledValue(1);

private int BORDER_NUMBER_CENTER = LPUtils.getScaledValue(4);

private EditText edit_;

private static final int FONT_H = 5;

int height_, width_, qwertyW_, qwertyH_, numW_, numH_;

private Paint paint_, textPaint_;

// 标记按键行数、列数

private int key_row = -1;

private int key_column = -1;

private long keyDownTime;

// 用来保存字符串的

private StringBuffer textBuffer_;

private Bitmap keyBoard_bg, keyBoard_one, keyBoard_one_down,

keyBoard_jsbank, keyBoard_gray_enter, keyBoard_del_down,

keyBoard_white_enter, keyBoard_gray_del, keyBoard_shift_normal,

keyBoard_shift_down, keyBoard_jsbank_logo, keyboard_num,

keyboard_num_down, keyboard_num_del, keyboard_num_downdel,

keyboard_abc_up, keyboard_abc_down;

private Bitmap keyOne_, keyTwo_, keyThree_, keyFour_;

private int[] resultAbc, resultNum;

// 键盘字母表

private final char[] keyAbc_ = {

‘q’, ‘w’, ‘e’, ‘r’, ‘t’, ‘y’, ‘u’, ‘i’, ‘o’, ‘p’, ‘a’, ‘s’,

‘d’, ‘f’, ‘g’, ‘h’, ‘j’, ‘k’, ‘l’, ‘z’, ‘x’, ‘c’, ‘v’, ‘b’,

‘n’, ‘m’

};

isABC_:true-大写，false-小写 isNum_:true-数字，false-字母
keyEnter_:true-按下，false-抬起 isDel_: true - 按下，false-抬起
isDelete_:true-最后一个字符显示为*，false-最后一个字符显示实际字符

boolean isABC_, isNum_, keyEnter_, isDel_, isSpace_, isDelete_;

// 标记字母、数字键第一行的横坐标位置

private int column1 = -1;

// 标记字母键第二行的横坐标位置

private int column2 = -1;

// 标记字母键第三行的横坐标位置

private int column3 = -1;

// 标记数字键第二行的横坐标位置

private int column4 = -1;

// 标记数字键第三行的横坐标位置

private int column5 = -1;

public LPImfView(Context context, LPTextField text) {

super(context);

// TODO Auto-generated constructor stub

edit_ = text;

maxSize = text.maxSize_;

setFocusable(true);

requestFocus();

init();

}

private void init() {

// TODO Auto-generated method stub

// resultAbc = getRandomNumber(26);

resultAbc = new int[26];

for (int i = 0; i < 26; i++) {

resultAbc[i] = i;

}

resultNum = getRandomNumber(10);

String text = edit_.getText().toString();

if (text != null) {

textBuffer_ = new StringBuffer(text);

tempEdit_.setText(getStringBuffer(textBuffer_, false));

// edit_.setText(“”);

}

textBuffer_ = new StringBuffer();

if (inputTypeNumber_) {

// 如果输入类型为数字的话，弹出的时数字键盘

isNum_ = true;

}

PAINT_SIZE = LPUtils.getScaledValue(PAINT_SIZE);

paint_ = new Paint();

paint_.setAntiAlias(true);

paint_.setTextSize(PAINT_SIZE);

textPaint_ = new Paint();

textPaint_.setAntiAlias(true);

// textPaint_.setTypeface(Typeface.DEFAULT_BOLD);

textPaint_.setTextSize(PAINT_SIZE);

keyBoard_bg = BitmapFactory.decodeResource(getResources(),

R.drawable.keyboard_bg);

keyBoard_jsbank_logo = BitmapFactory.decodeResource(getResources(),

R.drawable.logo);

keyBoard_jsbank = BitmapFactory.decodeResource(getResources(),

R.drawable.keyboard_czbank);

keyBoard_one = BitmapFactory.decodeResource(getResources(),

R.drawable.keyboard_one);

keyBoard_one_down = BitmapFactory.decodeResource(getResources(),

R.drawable.keyboard_one_down);

keyBoard_shift_normal = BitmapFactory.decodeResource(

getResources(), R.drawable.keyboard_shift_normal);

keyBoard_shift_down = BitmapFactory.decodeResource(getResources(),

R.drawable.keyboard_shift_down);

keyBoard_gray_del = BitmapFactory.decodeResource(getResources(),

R.drawable.keyboard_gray_del);

keyBoard_del_down = BitmapFactory.decodeResource(getResources(),

R.drawable.keyboard_gray_del_down);

keyBoard_gray_enter = BitmapFactory.decodeResource(getResources(),

R.drawable.keyboard_gray_enter);

keyBoard_white_enter = BitmapFactory.decodeResource(getResources(),

R.drawable.keyboard_white_enter);

keyboard_num = BitmapFactory.decodeResource(getResources(),

R.drawable.keyboard_num);

keyboard_num_down = BitmapFactory.decodeResource(getResources(),

R.drawable.keyboard_num_down);

keyboard_num_del = BitmapFactory.decodeResource(getResources(),

R.drawable.keyboard_num_del);

keyboard_num_downdel = BitmapFactory.decodeResource(getResources(),

R.drawable.keyboard_num_downdel);

keyboard_abc_up = BitmapFactory.decodeResource(getResources(),

R.drawable.keyboard_abc_up);

keyboard_abc_down = BitmapFactory.decodeResource(getResources(),

R.drawable.keyboard_abc_down);

// 根据屏幕大小缩放图片

int w = LPUtils.screenWidth_ / 3 - BORDER_NUMBER_CENTER;

int h = ((keyBoard_bg.getHeight() - BORDER_TOP) / 4) - BORDER_TOP;

keyboard_num = Bitmap.createScaledBitmap(keyboard_num, w, h, true);

keyboard_num_down = Bitmap.createScaledBitmap(keyboard_num_down, w,

h, true);

keyboard_num_del = Bitmap.createScaledBitmap(keyboard_num_del, w,

h, true);

keyboard_num_downdel = Bitmap.createScaledBitmap(

keyboard_num_downdel, w, h, true);

keyboard_abc_up = Bitmap.createScaledBitmap(keyboard_abc_up, w, h,

true);

keyboard_abc_down = Bitmap.createScaledBitmap(keyboard_abc_down, w,

h, true);

// 缩放字母键的图片

int abc_W = (LPUtils.screenWidth_ / 10 - colW_one);

int abc_H = ((keyBoard_bg.getHeight() - BORDER_TOP) / 4)

BORDER_TOP;

keyBoard_one = Bitmap.createScaledBitmap(keyBoard_one, abc_W,

abc_H, true);

keyBoard_one_down = Bitmap.createScaledBitmap(keyBoard_one_down,

abc_W, abc_H, true);

keyBoard_shift_normal = Bitmap.createScaledBitmap(

keyBoard_shift_normal, abc_W + abc_W / 2, abc_H, true);

keyBoard_shift_down = Bitmap.createScaledBitmap(

keyBoard_shift_down, abc_W + abc_W / 2, abc_H, true);

keyBoard_gray_del = Bitmap.createScaledBitmap(keyBoard_gray_del,

abc_W << 1, abc_H, true);

keyBoard_del_down = Bitmap.createScaledBitmap(keyBoard_del_down,

abc_W << 1, abc_H, true);

keyBoard_gray_enter = Bitmap.createScaledBitmap(

keyBoard_gray_enter, abc_W << 1, abc_H, true);

keyBoard_white_enter = Bitmap.createScaledBitmap(

keyBoard_white_enter, abc_W << 1, abc_H, true);

keyBoard_jsbank = Bitmap.createScaledBitmap(keyBoard_jsbank,

(abc_W + colW_one) * 6, abc_H, true);

keyBoard_jsbank_logo = Bitmap.createScaledBitmap(

keyBoard_jsbank_logo, (abc_W + colW_one) * 4, abc_H

LPUtils.getScaledValue(8), true);

// 弹出键盘的高度

height_ = keyBoard_bg.getHeight();

// 弹出键盘的宽度

width_ = LPUtils.screenWidth_;

// 字母键的宽度

qwertyW_ = keyBoard_one.getWidth();

// 字母键的高度

qwertyH_ = keyBoard_one.getHeight();

// 数字键的宽度

numW_ = keyboard_num.getWidth();

// 数字键的高度

numH_ = keyboard_num.getHeight();

BORDER_TWO = BORDER + qwertyW_ / 2;

colW_two = qwertyW_ / 3;

windownShow_W = Math.abs((qwertyW_ - LPUtils.screenWidth_ / 8) / 2);

// colW_one = LPUtils.getScaledValue(colW_one);

// colW_two = LPUtils.getScaledValue(colW_two);

// BORDER_TWO = LPUtils.getScaledValue(BORDER_TWO);

// BORDER = LPUtils.getScaledValue(BORDER);

// BORDER_TOP = LPUtils.getScaledValue(BORDER_TOP);

// BORDER_CENTER = LPUtils.getScaledValue(BORDER_CENTER);

LayoutParams lp = (android.widget.LinearLayout.LayoutParams) this

.getLayoutParams();

if (lp == null) {

setLayoutParams(new LayoutParams(width_, height_));

} else {

lp.height = height_;

lp.width = LPUtils.screenWidth_;

setLayoutParams(lp);

}

public void onDraw(Canvas g) {

画键盘的背景

// g.drawBitmap(keyBoard_bg, 0, 0, paint_);

drawKeyBoard(g);

}

画出字母键盘的布局键

private void drawKeyBoard(Canvas g) {

// TODO Auto-generated method stub

使得原先的按下去效果无效

// column1 = -1;

// column2 = -1;

// column3 = -1;

// column4 = -1;

// column5 = -1;

画字母键的第一行

textPaint_.setColor(Color.BLACK);

int startX = 0;

int startY = 0;

String temp;

if (isNum_) {

textPaint_.setTextSize(PAINT_SIZE + 2);

// 画数字键（4行3列）

startX = (int) (((numW_ + BORDER_NUMBER_CENTER) - textPaint_

.measureText(“1”)) / 2);

startY = (int) (((numH_ + BORDER_NUMBER_CENTER) >> 1) + FONT_H + LPUtils

.getScaledValue(3));

for (int i = 0; i < 3; i++) {

for (int j = 0; j < 3; j++) {

if (key_row == i) {

if (j == key_column) {

keyOne_ = keyboard_num_down;

} else {

keyOne_ = keyboard_num;

}

} else {

keyOne_ = keyboard_num;

}

g.drawBitmap(keyOne_, BORDER

(numW_ + BORDER_NUMBER_CENTER) * j,

BORDER_TOP

((numH_ + BORDER_NUMBER_CENTER) * i),

paint_);

g.drawText(String.valueOf(resultNum[j + (i * 3)]),

startX + BORDER

(numW_ + BORDER_NUMBER_CENTER) * j,

startY + BORDER_TOP

((numH_ + BORDER_NUMBER_CENTER) * i),

textPaint_);

}

// 画第4行功能键

if (key_row == 3 && key_column == 0) {

g.drawBitmap(keyboard_abc_down, BORDER, BORDER_TOP

((numH_ + BORDER_NUMBER_CENTER) * 3), paint_);

} else {

g.drawBitmap(inputTypeNumber_ ? keyboard_num_down

keyboard_abc_up, BORDER, BORDER_TOP

((numH_ + BORDER_NUMBER_CENTER) * 3), paint_);

}

// textPaint_.setColor(Color.WHITE);

g.drawText(!inputTypeNumber_ ? “ABC” : “确定”, BORDER

(numW_ - textPaint_.measureText(“ABC”)) / 2,

BORDER_TOP + ((numH_ + BORDER_NUMBER_CENTER) * 3)

startY, textPaint_);

if (key_row == 3 && key_column == 1) {

g.drawBitmap(keyboard_num_down, BORDER + numW_

BORDER_NUMBER_CENTER, BORDER_TOP
((numH_ + BORDER_NUMBER_CENTER) * 3), paint_);

} else {

g.drawBitmap(keyboard_num, BORDER + numW_

BORDER_NUMBER_CENTER, BORDER_TOP
((numH_ + BORDER_NUMBER_CENTER) * 3), paint_);

}

textPaint_.setColor(Color.BLACK);

g.drawText(String.valueOf(resultNum[9]), startX + BORDER

numW_ + BORDER_NUMBER_CENTER, BORDER_TOP
((numH_ + BORDER_NUMBER_CENTER) * 3) + startY,

textPaint_);

if (key_row == 3 && key_column == 2) {

g.drawBitmap(inputTypeNumber_ ? keyboard_num_del

keyboard_num_downdel, BORDER

((numW_ + BORDER_NUMBER_CENTER) << 1), BORDER_TOP
((numH_ + BORDER_NUMBER_CENTER) * 3), paint_);

delEditAgainValue();

} else {

g.drawBitmap(inputTypeNumber_ ? keyboard_num_downdel

keyboard_num_del, BORDER

((numW_ + BORDER_NUMBER_CENTER) << 1), BORDER_TOP
((numH_ + BORDER_NUMBER_CENTER) * 3), paint_);

}

} else {

textPaint_.setTextSize(PAINT_SIZE);

startY = (int) (BORDER_TOP + qwertyH_ / 2 + LPUtils

.getScaledValue(5));

for (int i = 0; i <= 9; i++) {

if (!isABC_) {

temp = String.valueOf(keyAbc_[resultAbc[i]]);

} else {

temp = String.valueOf(keyAbc_[resultAbc[i]])

.toUpperCase();

}

startX = getIntX(BORDER, String.valueOf(temp))

(colW_one + qwertyW_) * i;

if (column1 >= 0) {

if (i == column1) {

keyOne_ = keyBoard_one_down;

} else {

keyOne_ = keyBoard_one;

}

} else {

keyOne_ = keyBoard_one;

}

g.drawBitmap(keyOne_, BORDER + (qwertyW_ + colW_one) * i,

BORDER_TOP, paint_);

if (!isABC_) {

g.drawText(String.valueOf(keyAbc_[resultAbc[i]]),

startX, startY, textPaint_);

} else {

g.drawText(String.valueOf(keyAbc_[resultAbc[i]])

.toUpperCase(), startX, startY, textPaint_);

}

画字母键的第二行

int startX1 = 0;

String temp1;

for (int i = 0; i <= 8; i++) {

if (!isABC_) {

temp1 = String.valueOf(keyAbc_[resultAbc[10 + i]]);

} else {

temp1 = String.valueOf(keyAbc_[resultAbc[10 + i]])

.toUpperCase();

}

startX1 = getIntX(BORDER_TWO, temp1)

(colW_one + qwertyW_) * i;

if (column2 >= 0) {

if (column2 == i) {

keyTwo_ = keyBoard_one_down;

} else {

keyTwo_ = keyBoard_one;

}

} else {

keyTwo_ = keyBoard_one;

}

g.drawBitmap(keyTwo_, BORDER_TWO + (qwertyW_ + colW_one)

i, BORDER_CENTER + BORDER_TOP + qwertyH_, paint_);

if (!isABC_) {

g.drawText(String.valueOf(keyAbc_[resultAbc[10 + i]]),

startX1, startY + BORDER_CENTER + qwertyH_,

textPaint_);

} else {

g.drawText(String.valueOf(keyAbc_[resultAbc[10 + i]])

.toUpperCase(), startX1, startY + BORDER_CENTER

qwertyH_, textPaint_);

}

画字母键的第三行

int startX2 = 0;

String temp2;

for (int i = 0; i <= 6; i++) {

if (!isABC_) {

temp2 = String.valueOf(keyAbc_[resultAbc[19 + i]]);

} else {

temp2 = String.valueOf(keyAbc_[resultAbc[19 + i]])

.toUpperCase();

}

startX2 = getIntX(BORDER + qwertyW_ - qwertyW_ / 4, temp2)

(colW_one + qwertyW_) * i;

if (column3 >= 0) {

if (i == column3) {

keyThree_ = keyBoard_one_down;

} else {

keyThree_ = keyBoard_one;

}

} else {

keyThree_ = keyBoard_one;

}

g.drawBitmap(keyThree_, BORDER + qwertyW_ - qwertyW_ / 4

(qwertyW_ + colW_one) * i, BORDER_TOP + 2

BORDER_CENTER + 2 * qwertyH_, paint_);

if (!isABC_) {

g.drawText(String.valueOf(keyAbc_[resultAbc[19 + i]]),

startX2, startY + 2

(BORDER_CENTER + qwertyH_),

textPaint_);

} else {

g.drawText(String.valueOf(keyAbc_[resultAbc[19 + i]])

.toUpperCase(), startX2, startY + 2

(BORDER_CENTER + qwertyH_), textPaint_);

}

画字母键盘功能键的切换大小写

// if (!isABC_) {

// g.drawBitmap(keyBoard_shift_normal, BORDER, BORDER_TOP + 2

// * BORDER_CENTER + 2 * qwertyH_, paint_);

// } else {

// g.drawBitmap(keyBoard_shift_down, BORDER, BORDER_TOP + 2

// * BORDER_CENTER + 2 * qwertyH_, paint_);

// }

画字母键盘功能键的切换大小写

if (!isABC_) {

g.drawBitmap(keyBoard_shift_normal, BORDER + qwertyW_

qwertyW_ / 4 + (qwertyW_ + colW_one) * 7,

BORDER_TOP + 2 * BORDER_CENTER + 2 * qwertyH_,

paint_);

} else {

g.drawBitmap(keyBoard_shift_down, BORDER + qwertyW_

qwertyW_ / 4 + (qwertyW_ + colW_one) * 7,

BORDER_TOP + 2 * BORDER_CENTER + 2 * qwertyH_,

paint_);

}

画功能键的切换数字键

g.drawBitmap(keyBoard_gray_enter, BORDER, BORDER_TOP

(BORDER_CENTER + qwertyH_) * 3, paint_);

// textPaint_.setColor(Color.WHITE);

g.drawText(

“123”,

BORDER

(keyBoard_gray_enter.getWidth() - textPaint_

.measureText(“123”)) / 2,

(qwertyH_ + BORDER_CENTER) * 3 + BORDER_TOP

keyBoard_gray_enter.getHeight() / 2
LPUtils.getScaledValue(8), textPaint_);

画logo

g.drawBitmap(keyBoard_jsbank,

(width_ - keyBoard_jsbank.getWidth()) >> 1, BORDER_TOP

3 * BORDER_CENTER + 3 * qwertyH_, paint_);

g.drawBitmap(

keyBoard_jsbank_logo,

(width_ - keyBoard_jsbank_logo.getWidth()) >> 1,

BORDER_TOP + 3 * BORDER_CENTER + 3 * qwertyH_

LPUtils.getScaledValue(4), paint_);

// g.drawText(“江苏银行”, (width_ + keyBoard_jsbank_logo.getWidth()

// - textPaint_.measureText(“江苏银行”)) / 2,

// (qwertyH_ + BORDER_CENTER) * 3 + BORDER_TOP +

// keyBoard_gray_enter.getHeight() / 2 +

// LPUtils.getScaledValue(5),

// textPaint_);

画功能键的删除键

textPaint_.setTextSize(PAINT_SIZE);

if (isDel_) {

g.drawBitmap(keyBoard_del_down,

width_ - keyBoard_del_down.getWidth() - BORDER,

BORDER_TOP + 3 * BORDER_CENTER + 3 * qwertyH_,

paint_);

delEditAgainValue();

} else {

g.drawBitmap(keyBoard_gray_del,

width_ - keyBoard_gray_del.getWidth() - BORDER,

BORDER_TOP + 3 * BORDER_CENTER + 3 * qwertyH_,

paint_);

}

// textPaint_.setColor(Color.WHITE);

// g.drawText(“确定”, width_

// - BORDER

// - keyBoard_gray_enter.getWidth()

// + (keyBoard_gray_enter.getWidth() - textPaint_

// .measureText(“确定”)) / 2, BORDER_TOP + 3

// * BORDER_CENTER + 3 * qwertyH_ + LPUtils.getScaledValue(25),

// textPaint_);

}

@Override

public boolean onTouchEvent(MotionEvent event) {

// TODO Auto-generated method stub

// 按下去的横坐标

int x = (int) event.getX();

// 按下去的纵坐标

int y = (int) event.getY();

int rowFirst = BORDER_TOP + qwertyH_;

int rowSecond = rowFirst + BORDER_CENTER + qwertyH_;

int rowThird = rowSecond + BORDER_CENTER + qwertyH_;

int rowFourth = rowThird + BORDER_CENTER + qwertyH_;

// 触摸的方式

int toucheEvent = event.getAction();

switch (toucheEvent) {

case MotionEvent.ACTION_DOWN:

String isWhat_ = null;

String isOut_ = null;

keyDownTime = System.currentTimeMillis();

if (isNum_) {

y = y - BORDER_TOP;

if (y >= 0 && y <= (numH_ + BORDER_NUMBER_CENTER) * 4) {

key_row = y / (numH_ + BORDER_NUMBER_CENTER);

key_column = x / (numW_ + BORDER_NUMBER_CENTER);

}

} else {

if (y > BORDER_TOP && y <= rowFirst) {

// 第一行

if (x > BORDER && x < width_) {

column1 = x / (qwertyW_ + colW_one);

if (isABC_) {

// 大写字母

isWhat_ = String.valueOf(

keyAbc_[resultAbc[column1]])

.toUpperCase();

} else {

// 小写字母

isWhat_ = String

.valueOf(keyAbc_[resultAbc[column1]]);

}

if (column1 == 0) {

isOut_ = “left”;

} else if (column1 == 9) {

isOut_ = “right”;

}

// showPopWindow(BORDER + (column1) * (qwertyW_

// + colW_one) - (column1 == 0 ? qwertyW_ :

// windownShow_W),

// BORDER_TOP + qwertyH_ / 2, isWhat_,isOut_);

}

} else if (y > (rowFirst + BORDER_CENTER)

&& y < rowSecond) {

// 第二行

if (x > BORDER_TWO && x < (width_ - BORDER_TWO)) {

column2 = (x - BORDER_TWO)

/ (qwertyW_ + colW_one);

if (isABC_) {

isWhat_ = String.valueOf(

keyAbc_[resultAbc[10

(x - BORDER_TWO)

/ (qwertyW_ + colW_one)]])

.toUpperCase();

} else {

isWhat_ = String

.valueOf(keyAbc_[resultAbc[10

(x - BORDER_TWO)

/ (qwertyW_ + colW_one)]]);

}

// showPopWindow(BORDER_TWO + (column2) *

// (qwertyW_ + colW_one) - windownShow_W,

// BORDER_TOP + BORDER_CENTER + qwertyH_

// + qwertyH_ / 2, isWhat_,isOut_);

}

} else if (y > (rowSecond + BORDER_CENTER)

&& y < rowThird) {

// 第三行

if (x > (BORDER + qwertyW_ - qwertyW_ / 4 + (qwertyW_ + colW_one) * 7)

&& x < (BORDER + qwertyW_ - qwertyW_ / 4

(qwertyW_ + colW_one) * 7 + keyBoard_shift_normal

.getWidth())) {

isABC_ = !isABC_;

} else if (x > (BORDER + qwertyW_ - qwertyW_ / 4)

&& x < (BORDER + qwertyW_ - qwertyW_ / 4 + (qwertyW_ + colW_one) * 7)) {

column3 = (x - (BORDER + qwertyW_ - qwertyW_ / 4))

/ (qwertyW_ + colW_one);

if (isABC_) {

isWhat_ = String.valueOf(

keyAbc_[resultAbc[19 + column3]])

.toUpperCase();

} else {

isWhat_ = String

.valueOf(keyAbc_[resultAbc[19 + column3]]);

}

// showPopWindow(

// column3

// * (qwertyW_ + colW_one)

// + (BORDER

// + qwertyW_ - qwertyW_ / 4) - windownShow_W

// , BORDER_TOP + qwertyH_ * 2

// + BORDER_CENTER * 2 + qwertyH_ / 2,

// isWhat_,isOut_);

}

} else if (y > (rowThird + BORDER_CENTER)

&& y < rowFourth) {

// 第四行

if (x > BORDER

&& x < (BORDER + keyBoard_gray_enter

.getWidth())) {

isNum_ = true;

} else if (x > (width_ - BORDER - keyBoard_gray_enter

.getWidth()) && x < (width_ - BORDER)) {

isDel_ = true;

keyEnter_ = true;

}

invalidate();

return true;

case MotionEvent.ACTION_MOVE:

// if(Math.abs(x - 2) > 2 || Math.abs(y - 2) > 2 ){

// column1 = -1;

// column2 = -1;

// column3 = -1;

// column4 = -1;

// column5 = -1;

// }

invalidate();

return true;

case MotionEvent.ACTION_UP:

if (isNum_) {

if (key_row != -1 && key_column != -1) {

isDelete_ = false;

if (key_row == 3) {

switch (key_column) {

case 0:

if (inputTypeNumber_) {

keyEnter_ = false;

dlg_.dismiss();

} else {

isDelete_ = true;

isNum_ = false;

}

break;

case 1:

textBuffer_ = appendBuffer(

String.valueOf(resultNum[9]),

true);

break;

case 2:

isDel_ = false;

isDelete_ = true;

if (null != textBuffer_

&& textBuffer_.length() > 0

&& tempEdit_.getText() != null

&& tempEdit_.getText()

.toString().trim()

.length() > 0) {

try {

int k = tempEdit_

.getSelectionEnd();

textBuffer_ = textBuffer_

.deleteCharAt(k - 1);

} catch (Exception e) {

// TODO: handle exception

}

break;

default:

break;

}

} else {

int index = key_row * 3 + key_column;

if (index < resultNum.length) {

textBuffer_ = appendBuffer(

String.valueOf(resultNum[index]),

true);

}

key_row = -1;

key_column = -1;

} else {

isDelete_ = true;

}

} else {

isDel_ = false;

keyEnter_ = false;

if (column1 != -1) {

// 第一行

if (isABC_) {

// 大写字母

textBuffer_ = appendBuffer(

String.valueOf(

keyAbc_[resultAbc[column1]])

.toUpperCase(), false);

} else {

// 小写字母

textBuffer_ = appendBuffer(

String.valueOf(keyAbc_[resultAbc[column1]]),

false);

}

} else if (column2 != -1) {

// 第二行

if (isABC_) {

textBuffer_ = appendBuffer(

String.valueOf(

keyAbc_[resultAbc[10 + column2]])

.toUpperCase(), false);

} else {

textBuffer_ = appendBuffer(

String.valueOf(keyAbc_[resultAbc[10 + column2]]),

false);

}

} else if (column3 != -1) {

// 第三行

if (isABC_) {

textBuffer_ = appendBuffer(

String.valueOf(

keyAbc_[resultAbc[19 + column3]])

.toUpperCase(), false);

} else {

textBuffer_ = appendBuffer(

String.valueOf(keyAbc_[resultAbc[19 + column3]]),

false);

}

} else if (y > (rowThird + BORDER_CENTER)

&& y < rowFourth) {

isDelete_ = true;

// 第四行

if (x > (width_ - BORDER - keyBoard_gray_del

.getWidth()) && x < (width_ - BORDER)) {

isDel_ = false;

isDelete_ = true;

if (null != textBuffer_

&& textBuffer_.length() > 0

&& tempEdit_.getText() != null

&& tempEdit_.getText().toString()

.trim().length() > 0) {

try {

int k = tempEdit_.getSelectionEnd();

textBuffer_ = textBuffer_

.deleteCharAt(k - 1);

} catch (Exception e) {

// TODO: handle exception

}

总结

现在新技术层出不穷，如果每次出新的技术，我们都深入的研究的话，很容易分散精力。新的技术可能很久之后我们才会在工作中用得上，当学的新技术无法学以致用，很容易被我们遗忘，到最后真的需要使用的时候，又要从头来过（虽然上手会更快）。

我觉得身为技术人，针对新技术应该是持拥抱态度的，入了这一行你就应该知道这是一个活到老学到老的行业，所以面对新技术，不要抵触，拥抱变化就好了。

Flutter 明显是一种全新的技术，而对于这个新技术在发布之初，花一个月的时间学习它，成本确实过高。但是周末花一天时间体验一下它的开发流程，了解一下它的优缺点、能干什么或者不能干什么。这个时间，并不是我们不能接受的。

如果有时间，其实通读一遍 Flutter 的文档，是最全面的一次对 Flutter 的了解过程。但是如果我们只有 8 小时的时间，我希望能关注一些最值得关注的点。

（跨平台开发(Flutter)、java基础与原理，自定义view、NDK、架构设计、性能优化、完整商业项目开发等）

_column = -1;

} else {

isDelete_ = true;

}

} else {

isDel_ = false;

keyEnter_ = false;

if (column1 != -1) {

// 第一行

if (isABC_) {

// 大写字母

textBuffer_ = appendBuffer(

String.valueOf(

keyAbc_[resultAbc[column1]])

.toUpperCase(), false);

} else {

// 小写字母

textBuffer_ = appendBuffer(

String.valueOf(keyAbc_[resultAbc[column1]]),

false);

}

} else if (column2 != -1) {

// 第二行

if (isABC_) {

textBuffer_ = appendBuffer(

String.valueOf(

keyAbc_[resultAbc[10 + column2]])

.toUpperCase(), false);

} else {

textBuffer_ = appendBuffer(

String.valueOf(keyAbc_[resultAbc[10 + column2]]),

false);

}

} else if (column3 != -1) {

// 第三行

if (isABC_) {

textBuffer_ = appendBuffer(

String.valueOf(

keyAbc_[resultAbc[19 + column3]])

.toUpperCase(), false);

} else {

textBuffer_ = appendBuffer(

String.valueOf(keyAbc_[resultAbc[19 + column3]]),

false);

}

} else if (y > (rowThird + BORDER_CENTER)

&& y < rowFourth) {

isDelete_ = true;

// 第四行

if (x > (width_ - BORDER - keyBoard_gray_del

.getWidth()) && x < (width_ - BORDER)) {

isDel_ = false;

isDelete_ = true;

if (null != textBuffer_

&& textBuffer_.length() > 0

&& tempEdit_.getText() != null

&& tempEdit_.getText().toString()

.trim().length() > 0) {

try {

int k = tempEdit_.getSelectionEnd();

textBuffer_ = textBuffer_

.deleteCharAt(k - 1);

} catch (Exception e) {

// TODO: handle exception

}

总结

（跨平台开发(Flutter)、java基础与原理，自定义view、NDK、架构设计、性能优化、完整商业项目开发等）

[外链图片转存中…(img-bXkO8NdP-1718856564176)]

2401_85122756

关注

22
点赞
踩
15

收藏

觉得还不错? 一键收藏
0
评论
Android 中自定义软键盘

现在新技术层出不穷，如果每次出新的技术，我们都深入的研究的话，很容易分散精力。新的技术可能很久之后我们才会在工作中用得上，当学的新技术无法学以致用，很容易被我们遗忘，到最后真的需要使用的时候，又要从头来过（虽然上手会更快）。我觉得身为技术人，针对新技术应该是持拥抱态度的，入了这一行你就应该知道这是一个活到老学到老的行业，所以面对新技术，不要抵触，拥抱变化就好了。Flutter 明显是一种全新的技术，而对于这个新技术在发布之初，花一个月的时间学习它，成本确实过高。
复制链接

扫一扫