Android自定义安全键盘

最新推荐文章于 2024-06-20 12:09:36 发布
最新推荐文章于 2024-06-20 12:09:36 发布
阅读量2.6k 收藏 3
点赞数
分类专栏： Android 文章标签： android 自定义键盘

在银行APP里经常要自定义键盘，例如实现下面这样的效果

 
 
 

 

首先在xml文件里定义键盘

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
<Keyboard xmlns:android= "http://schemas.android.com/apk/res/android"
           android:keyWidth= "30%p"
           android:horizontalGap= "@dimen/keyboard_horizontalGap"
           android:verticalGap= "@dimen/keyboard_verticalGap"
           android:keyHeight= "47dp" >
     <Row>
         <Key android:codes= "49" android:keyLabel= "1" />
         <Key android:codes= "50" android:keyLabel= "2" />
         <Key android:codes= "51" android:keyLabel= "3" />
     </Row>
 
     <Row>
         <Key android:codes= "52" android:keyLabel= "4" />
         <Key android:codes= "53" android:keyLabel= "5" />
         <Key android:codes= "54" android:keyLabel= "6" />
     </Row>
 
     <Row>
         <Key android:codes= "55" android:keyLabel= "7" />
         <Key android:codes= "56" android:keyLabel= "8" />
         <Key android:codes= "57" android:keyLabel= "9" />
     </Row>
 
     <Row>
         <Key android:codes= "-2" android:keyLabel= "ABC" />
         <Key android:codes= "48" android:keyLabel= "0" />
         <Key android:codes= "-35"
             android:isRepeatable= "true" />
     </Row>
</Keyboard>

keyWidth：每一个按钮的宽度

keyHeight：每一个按钮高度，可以设置百分比

horizontalGap：水平间隔

verticalGap：竖直间隔

Row：一行

每一个按键都将会有一个 codes 值，代表键盘上的按键

KhKeyboardView
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
public class KhKeyboardView {
     private Activity mContext;
     private View parentView;
     private KeyboardView mLetterView;   //字母键盘view
     private KeyboardView mNumberView;   //数字键盘View
     private Keyboard mNumberKeyboard;   // 数字键盘
     private Keyboard mLetterKeyboard;   // 字母键盘
     private Keyboard mSymbolKeyboard;   // 符号键盘
 
     private boolean isNumber = true ;    // 是否数字键盘
     public static   boolean isUpper = false ;    // 是否大写
     private boolean isSymbol = false ;   // 是否是符号
     private EditText mEditText;
     private View headerView;
 
     public void setEditText(EditText text) {
         mEditText = text;
     }
 
     public KhKeyboardView(Activity context, View view) {
         mContext = context;
         parentView = view;
 
         mNumberKeyboard = new Keyboard(mContext, R.xml.keyboard_numbers);
         mLetterKeyboard = new Keyboard(mContext, R.xml.keyboard_word);
         mSymbolKeyboard = new Keyboard(mContext, R.xml.keyboard_symbol);
         mNumberView = (KeyboardView) parentView.findViewById(R.id.keyboard_view);
         mLetterView = (KeyboardView) parentView.findViewById(R.id.keyboard_view_2);
 
         mNumberView.setKeyboard(mNumberKeyboard);
         mNumberView.setEnabled( true );
         mNumberView.setPreviewEnabled( false );
         mNumberView.setOnKeyboardActionListener(listener);
         mLetterView.setKeyboard(mLetterKeyboard);
         mLetterView.setEnabled( true );
         mLetterView.setPreviewEnabled( true );
         mLetterView.setOnKeyboardActionListener(listener);
         headerView = parentView.findViewById(R.id.keyboard_header);
 
     }
 
     private KeyboardView.OnKeyboardActionListener listener = new KeyboardView.OnKeyboardActionListener() {
         /**
          * 按下，在onKey之前，可以在这里做一些操作，这里让有的没有按下的悬浮提示
          * @param primaryCode
          */
         @Override
         public void onPress( int primaryCode) {
             Log.d( "primaryCode" , "onPress--" +primaryCode);
             if (primaryCode == Keyboard.KEYCODE_SHIFT) {
                 mLetterView.setPreviewEnabled( false );
             } else if (primaryCode == Keyboard.KEYCODE_DELETE) {
                 mLetterView.setPreviewEnabled( false );
             } else if (primaryCode == 32) {
                 mLetterView.setPreviewEnabled( false );
             } else {
                 mLetterView.setPreviewEnabled( true );
             }
 
         }
 
         /**
          * 松开
          * @param primaryCode
          */
         @Override
         public void onRelease( int primaryCode) {
             Log.d( "primaryCode" , "onRelease--" +primaryCode);
         }
 
         /**
          * 按下
          * @param primaryCode
          * @param keyCodes
          */
         @Override
         public void onKey( int primaryCode, int [] keyCodes) {
             Log.d( "primaryCode" , "onKey--" +primaryCode);
             try {
                 if (mEditText == null )
                     return ;
                 Editable editable = mEditText.getText();
                 int start = mEditText.getSelectionStart();
                 if (primaryCode == Keyboard.KEYCODE_CANCEL) {
                     // 隐藏键盘
                     hideKeyboard();
                 } else if (primaryCode == Keyboard.KEYCODE_DELETE || primaryCode == -35) {
 
                     // 回退键,删除字符
                     if (editable != null && editable.length() > 0) {
                         if (start > 0) {
                             editable.delete(start - 1, start);
                         }
                     }
                 } else if (primaryCode == Keyboard.KEYCODE_SHIFT) {
                     // 大小写切换
                     changeKeyboart();
                     mLetterView.setKeyboard(mLetterKeyboard);
 
                 } else if (primaryCode == Keyboard.KEYCODE_MODE_CHANGE) {
                     // 数字与字母键盘互换
                     if (isNumber) {
                         showLetterView();
                         showLetterView2();
                     } else {
                         showNumberView();
                     }
 
                 } else if (primaryCode == 90001) {
//                  字母与符号切换
                     if (isSymbol) {
                         showLetterView2();
                     } else {
                         showSymbolView();
                     }
 
                 } else {
                     // 输入键盘值
                     editable.insert(start, Character.toString(( char ) primaryCode));
                 }
             } catch (Exception e) {
                 e.printStackTrace();
             }
 
         }
 
         @Override
         public void onText(CharSequence text) {
 
         }
 
         @Override
         public void swipeLeft() {
 
         }
 
         @Override
         public void swipeRight() {
 
         }
 
         @Override
         public void swipeDown() {
 
         }
 
         @Override
         public void swipeUp() {
 
         }
     };
 
     //  字母-符号,显示字母
     private void showLetterView2() {
         if (mLetterView != null ) {
             isSymbol = false ;
             mLetterView.setKeyboard(mLetterKeyboard);
         }
     }
 
     //  字母-符号,显示符号
     private void showSymbolView() {
         try {
             if (mLetterKeyboard != null ) {
                 isSymbol = true ;
                 mLetterView.setKeyboard(mSymbolKeyboard);
             }
         } catch (Exception e) {
         }
     }
 
     //  数字-字母,显示字母键盘
     private void showLetterView() {
         try {
             if (mLetterView != null && mNumberView != null ) {
                 isNumber = false ;
                 mLetterView.setVisibility(View.VISIBLE);
                 mNumberView.setVisibility(View.INVISIBLE);
             }
         } catch (Exception e) {
             e.printStackTrace();
         }
 
     }
 
     // 数字-字母, 显示数字键盘
     private void showNumberView() {
         try {
             if (mLetterView != null && mNumberView != null ) {
                 isNumber = true ;
                 mLetterView.setVisibility(View.INVISIBLE);
                 mNumberView.setVisibility(View.VISIBLE);
             }
         } catch (Exception e) {
             e.printStackTrace();
         }
 
     }
 
     /**
      * 切换大小写
      */
     private void changeKeyboart() {
         List<Keyboard.Key> keyList = mLetterKeyboard.getKeys();
         if (isUpper) {
             // 大写切换小写
             isUpper = false ;
             for (Keyboard.Key key : keyList) {
                 Drawable icon = key.icon;
 
                 if (key.label != null && isLetter(key.label.toString())) {
                     key.label = key.label.toString().toLowerCase();
                     key.codes[0] = key.codes[0] + 32;
                 }
             }
         } else {
             // 小写切换成大写
             isUpper = true ;
             for (Keyboard.Key key : keyList) {
                 if (key.label != null && isLetter(key.label.toString())) {
                     key.label = key.label.toString().toUpperCase();
                     key.codes[0] = key.codes[0] - 32;
                 }
             }
         }
     }
 
     /**
      * 判断是否是字母
      */
     private boolean isLetter(String str) {
         String wordStr = "abcdefghijklmnopqrstuvwxyz" ;
         return wordStr.contains(str.toLowerCase());
     }
 
     public void hideKeyboard() {
         try {
             int visibility = mLetterView.getVisibility();
             if (visibility == View.VISIBLE) {
                 headerView.setVisibility(View.GONE);
                 mLetterView.setVisibility(View.GONE);
             }
             visibility = mNumberView.getVisibility();
             if (visibility == View.VISIBLE) {
                 headerView.setVisibility(View.GONE);
                 mNumberView.setVisibility(View.GONE);
             }
         } catch (Exception e) {
             e.printStackTrace();
         }
 
     }
 
     /**
      * 显示键盘
      *
      * @param editText
      */
     public void showKeyboard(EditText editText) {
         try {
             this .mEditText = editText;
             int visibility = 0;
             int inputText = mEditText.getInputType();
             headerView.setVisibility(View.VISIBLE);
             switch (inputText) {
                 case InputType.TYPE_CLASS_NUMBER:
                     showNumberView();
                     break ;
                 case InputType.TYPE_CLASS_PHONE:
                     showNumberView();
                     break ;
                 case InputType.TYPE_NUMBER_FLAG_DECIMAL:
                     showNumberView();
                     break ;
                 default :
                     showLetterView();
                     break ;
             }
         } catch (Exception e) {
             e.printStackTrace();
         }
 
     }
}

　

布局

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
<?xml version= "1.0" encoding= "utf-8" ?>
<RelativeLayout xmlns:android= "http://schemas.android.com/apk/res/android"
     xmlns:tools= "http://schemas.android.com/tools"
     android:id= "@+id/rl_key"
     android:layout_width= "match_parent"
     android:layout_height= "wrap_content"
     android:background= "#00000000"
     android:orientation= "vertical" >
 
     <View
         android:id= "@+id/keyboard_back_hide"
         android:layout_width= "match_parent"
         android:layout_height= "match_parent"
         android:visibility= "gone" />
 
     <LinearLayout
         android:layout_width= "match_parent"
         android:layout_height= "wrap_content"
         android:background= "#7d7d7d"
         android:orientation= "vertical" >
 
         <RelativeLayout
             android:id= "@+id/keyboard_header"
             android:layout_width= "match_parent"
             android:layout_height= "wrap_content"
             android:visibility= "visible" >
 
             <TextView
                 android:layout_width= "wrap_content"
                 android:layout_height= "wrap_content"
                 android:layout_centerInParent= "true"
                 android:text= "智能安全加密键盘"
                 android:textColor= "#bfbfbf"
                 android:textSize= "15sp" />
 
             <TextView
                 android:id= "@+id/keyboard_finish"
                 android:layout_width= "wrap_content"
                 android:layout_height= "wrap_content"
                 android:layout_alignParentRight= "true"
                 android:layout_centerVertical= "true"
                 android:layout_marginRight= "10dp"
                 android:padding= "14dp"
                 android:text= "完成"
                 android:textColor= "#ffffff"
                 android:textSize= "15sp" />
         </RelativeLayout>
 
         <ImageView
             android:layout_width= "match_parent"
             android:layout_height= "1dp"
             android:layout_marginBottom= "10dp"
             android:background= "#555457" />
 
         <FrameLayout
             android:id= "@+id/keyboard_layer"
             android:layout_width= "match_parent"
             android:layout_height= "wrap_content" >
 
             <com.kh.keyboard.CustomKeyboardView
                 android:id= "@+id/keyboard_view"
                 android:layout_width= "match_parent"
                 android:layout_height= "wrap_content"
                 android:background= "#7d7d7d"
                 android:focusable= "true"
                 android:focusableInTouchMode= "true"
                 android:keyBackground= "@drawable/keyboard_number_selector_bg"
                 android:keyPreviewLayout= "@null"
                 android:keyTextColor= "#ffffff"
                 android:visibility= "gone" />
 
             <com.kh.keyboard.CustomKeyboardView
                 android:id= "@+id/keyboard_view_2"
                 android:layout_width= "match_parent"
                 android:layout_height= "wrap_content"
                 android:background= "#7d7d7d"
                 android:focusable= "true"
                 android:focusableInTouchMode= "true"
                 android:keyBackground= "@drawable/keyboard_selector_bg"
                 android:keyPreviewHeight= "90dp"
                 android:keyPreviewLayout= "@layout/keyboard_key_preview_layout"
                 android:keyPreviewOffset= "45dp"
                 android:keyTextColor= "#ffffff"
                 android:visibility= "gone" />
         </FrameLayout>
 
     </LinearLayout>
</RelativeLayout>

　　

 
keyPreviewLayout就是点击时键盘按键上的悬浮效果
 
这里自定义了KeyboardView，因为我需要按钮的背景颜色不一样，而使用 keyBackground都是一样的
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
public class CustomKeyboardView extends KeyboardView {
     private Context context;
 
     public CustomKeyboardView(Context context, AttributeSet attrs) {
         super(context, attrs);
         this .context = context;
     }
 
     @Override
     public void onDraw(Canvas canvas) {
         super.onDraw(canvas);
         try {
             List<Keyboard.Key> keys = getKeyboard().getKeys();
             for (Keyboard.Key key : keys) {
                 //   Log.e("KEY", "Drawing key with code " + key.codes[0]);
                 if (key.codes[0] == -5) {
                     Drawable dr = (Drawable) context.getResources().getDrawable(R.drawable.keyboard_word_del_layerlist);
                     dr.setBounds(key.x, key.y, key.x + key.width, key.y + key.height);
                     dr.draw(canvas);
                 } else if (key.codes[0] == -35) {
                     Drawable dr = (Drawable) context.getResources().getDrawable(R.drawable.keyboard_word_del_layerlist2);
                     dr.setBounds(key.x, key.y, key.x + key.width, key.y + key.height);
                     dr.draw(canvas);
                 } else if (key.codes[0] == -1) {
                     Drawable dr = (Drawable) context.getResources().getDrawable(R.drawable.keyboard_word_shift_layerlist);
                     Drawable dr_da = (Drawable) context.getResources().getDrawable(R.drawable.keyboard_word_shift_layerlist_da);
                     dr.setBounds(key.x, key.y, key.x + key.width, key.y + key.height);
                     dr_da.setBounds(key.x, key.y, key.x + key.width, key.y + key.height);
 
                     if (KhKeyboardView.isUpper) {
                         dr_da.draw(canvas);
                     } else {
                         dr.draw(canvas);
                     }
 
                 } else if (key.codes[0] == -2 || key.codes[0] == 90001) {
                     Drawable dr = (Drawable) context.getResources().getDrawable(R.drawable.keyboard_selector_blue_bg);
                     dr.setBounds(key.x, key.y, key.x + key.width, key.y + key.height);
                     dr.draw(canvas);
                     drawText(canvas, key);
                 } else {
 
                 }
             }
         } catch (Exception e) {
             e.printStackTrace();
         }
     }
 
 
     private void drawText(Canvas canvas, Keyboard.Key key) {
         try {
             Rect bounds = new Rect();
             Paint paint = new Paint();
             paint.setTextAlign(Paint.Align.CENTER);
 
 
             paint.setAntiAlias( true );
 
             paint.setColor(Color.WHITE);
 
             if (key.label != null ) {
                 String label = key.label.toString();
 
                 Field field;
 
                 if (label.length() > 1 && key.codes.length < 2) {
                     int labelTextSize = 0;
                     try {
                         field = KeyboardView. class .getDeclaredField( "mLabelTextSize" );
                         field.setAccessible( true );
                         labelTextSize = ( int ) field. get ( this );
                     } catch (NoSuchFieldException e) {
                         e.printStackTrace();
                     } catch (IllegalAccessException e) {
                         e.printStackTrace();
                     }
                     paint.setTextSize(labelTextSize);
                     paint.setTypeface(Typeface.DEFAULT_BOLD);
                 } else {
                     int keyTextSize = 0;
                     try {
                         field = KeyboardView. class .getDeclaredField( "mLabelTextSize" );
                         field.setAccessible( true );
                         keyTextSize = ( int ) field. get ( this );
                     } catch (NoSuchFieldException e) {
                         e.printStackTrace();
                     } catch (IllegalAccessException e) {
                         e.printStackTrace();
                     }
                     paint.setTextSize(keyTextSize);
                     paint.setTypeface(Typeface.DEFAULT);
                 }
 
                 paint.getTextBounds(key.label.toString(), 0, key.label.toString()
                         .length(), bounds);
                 canvas.drawText(key.label.toString(), key.x + (key.width / 2),
                         (key.y + key.height / 2) + bounds.height() / 2, paint);
             } else if (key.icon != null ) {
                 key.icon.setBounds(key.x + (key.width - key.icon.getIntrinsicWidth()) / 2, key.y + (key.height - key.icon.getIntrinsicHeight()) / 2,
                         key.x + (key.width - key.icon.getIntrinsicWidth()) / 2 + key.icon.getIntrinsicWidth(), key.y + (key.height - key.icon.getIntrinsicHeight()) / 2 + key.icon.getIntrinsicHeight());
                 key.icon.draw(canvas);
             }
 
         } catch (Exception e) {
             e.printStackTrace();
         }
 
 
     }
}
 
最后
还需要一个工具类来显示自定义的键盘，这里我使用了dialog
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
public class KeyBoardDialogUtils implements View.OnClickListener {
     protected View view;
     protected Dialog popWindow;
     protected Activity mContext;
     private EditText contentView;
     private List<String> contentList;
     private KhKeyboardView keyboardUtil;
 
     public KeyBoardDialogUtils(Activity mContext) {
         try {
             this .mContext = mContext;
             if (contentList == null ) {
                 contentList = new ArrayList<>();
             }
 
             if (popWindow == null ) {
                 view = LayoutInflater. from (mContext).inflate(R.layout.keyboard_key_board_popu, null );
                 view.findViewById(R.id.keyboard_finish).setOnClickListener( this );
                 view.findViewById(R.id.keyboard_back_hide).setOnClickListener( this );
             }
             popWindow.setContentView(view);
             popWindow.setCanceledOnTouchOutside( true );
             Window mWindow = popWindow.getWindow();
             mWindow.setWindowAnimations(R.style.keyboard_popupAnimation);
             mWindow.setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
             mWindow.setGravity(Gravity.BOTTOM | Gravity.FILL_HORIZONTAL);
             mWindow.setLayout(ViewGroup.LayoutParams.MATCH_PARENT,
                     ViewGroup.LayoutParams.WRAP_CONTENT);
             popWindow.setOnDismissListener( new DialogInterface.OnDismissListener() {
 
                 @Override
                 public void onDismiss(DialogInterface dialog) {
                     if (contentView != null && contentView.isFocused()) {
                         contentView.clearFocus();
                     }
                 }
             });
             initView();
 
 
         } catch (Exception e) {
             e.printStackTrace();
         }
 
     }
 
     private void initView() {
         try {
             if (keyboardUtil == null )
                 keyboardUtil = new KhKeyboardView(mContext, view);
 
         } catch (Exception e) {
             e.printStackTrace();
         }
 
     }
     
 
     public void show(final EditText editText) {
         editText.setFocusable( true );
         editText.setFocusableInTouchMode( true );
         editText.requestFocus();
         popWindow.show();
         keyboardUtil.showKeyboard(editText);
     }
 
     public void dismiss() {
         if (popWindow != null && popWindow.isShowing()) {
             popWindow.dismiss();
 
         }
 
     }
 
     @Override
     public void onClick(View v) {
         try {
             int i = v.getId();
             if (i == R.id.keyboard_finish) {
                 keyboardUtil.hideKeyboard();
                 dismiss();
 
             } else if (i == R.id.keyboard_back_hide) {
                 keyboardUtil.hideKeyboard();
                 dismiss();
 
             }
 
         } catch (Exception e) {
             e.printStackTrace();
         }
     }
 
 
}

　　

使用

1
2
3
4
5
6
7
8
et = (EditText) findViewById(R.id.et);
keyBoardDialogUtils = new KeyBoardDialogUtils( this );
et.setOnClickListener( new View.OnClickListener() {
     @Override
     public void onClick(View v) {
         keyBoardDialogUtils.show(et);
     }
});
注意这里点击会先弹出系统键盘，因为弹出键盘会先于 keyBoardDialogUtils . show ( et )执行，所以设置EditText的focusableInTouchMode="false"，在keyutil里我们再把它设为true。
 
 
项目源码：
https://github.com/peiniwan/SafeKeyBoard
不抓老鼠的喵
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Android 安全键盘
滴水穿石，厚积薄发
11-27 3070
自定义键盘，游戏键盘，安全键盘在安卓应用中屡见不鲜，其中安全键盘是为防止其它程序获得当前账户输入密码账号时候被读取，在金钱交易的程序中经常能看到，当然也不能完全安全的，鄙人蛋疼，做了个安全键盘Demo,欢迎拍砖。 安全键盘的要求很简单，数字位置要求随机变化，如何能实现这一点呢，我们可以让我们添加进的数字键盘资源顺序是连续的，每次生成键盘时，用0-10随机生成的一组随机数资源ID+随机数就能打乱每
Android 自定义键盘
yancyang的博客
02-18 4444
对于许久不用的东西，容易忘记。百度许久，也未能找到自己所要。 从今日起，有些东西就记载下来，不仅方便自己，希望能帮到他人吧！ 系统弹窗 键盘布局 回调 后续完善 许多应用都使用自定义的键盘，我自己也来撸一把，我等了三年，我不是证明我自己有多厉害，只是使用自己定义的键盘方便一些(嘿嘿)。 想想，你平时输入很多东西，要按很多按键，现在一个按键就搞定了。 比如：yancyang 需要一个字母一个字母...
Android自定义安全软键盘开发详细步骤
我的专栏
03-05 2886
源码地址：GitHub:https://github.com/SValence/SafeKeyboard 在一些比较敏感的输入场合，我们不能调用系统的软键盘进行输入信息，这时候就需要自定义一个软键盘来完成输入工作，由此就需要下面 Android 安全软键盘开发 的工作，本文主要从项目需求出发，梳理开发流程，并给出一个实际开发的例子作为参考。 一、Android 安全软键...
整个网络可能最完善的 Android 自定义键盘 问题汇总以及解决方案
你好邱林和的专栏
09-15 8075
系统自带的键盘，键值太多，不符合客户的需求，需要自定义键盘，如下图：       分别是字母和数字的键盘，感谢很多前辈提供的例子，朋友们可以到这个链接下载资源：前辈android 自定义键盘详解讲的非常清楚，我下了他的代码，在这基础上进行修改，遇到的第一个问题就是第一个图上的： “  .?&”  ,如何在键盘上显示这样的文本，假设采用楼主设置文本的形式进行设置的时
Android 中自定义软键盘
最新发布
2401_85122756的博客
06-20 571
现在新技术层出不穷，如果每次出新的技术，我们都深入的研究的话，很容易分散精力。新的技术可能很久之后我们才会在工作中用得上，当学的新技术无法学以致用，很容易被我们遗忘，到最后真的需要使用的时候，又要从头来过（虽然上手会更快）。我觉得身为技术人，针对新技术应该是持拥抱态度的，入了这一行你就应该知道这是一个活到老学到老的行业，所以面对新技术，不要抵触，拥抱变化就好了。Flutter 明显是一种全新的技术，而对于这个新技术在发布之初，花一个月的时间学习它，成本确实过高。
Android 自定组件（安全键盘）
斯旺森swanson
09-14 420
常见的安全键盘，随机排列数字，点击状态的回调。 import android.content.Context; import android.content.res.TypedArray; import android.graphics.Canvas; import android.graphics.Color; import android.graphics.Paint; import android.graphics.RectF; import android.util.AttributeSet; im
自定义Android键盘
dzqxwzoe的博客
02-25 3148
前段时间改造了公司的安全键盘，是基于Dialog和Button自定义的。也因此借机了解下 Android 平台提供的自定义键盘接口。Keyboard和。很搞笑的是，百度出来自定义Android键盘（与自定义Android输入法不同）的文章千篇一律。这里讲的自定义键盘同公司安全键盘是两种实现方式，不存在泄露公司内部技术的问题！！！不去吐槽别人，楼主秉持只原创和翻译的作风，输出这第50篇博客。相关属性部分是对照官方文档和Demo实践翻译的，若有瑕疵，请见谅。楼主csdn主页请点击flueky专栏。
android软键盘汉字的codes如何确定
蜉蝣DG的博客
07-13 552
找了好多自定义软键盘的博客，但是都没说明白汉字是怎么转换成codes的，我记录一下我的方法。 1、http://www.msxindl.com/tools/unicode16.asp输入汉字转换Unicode，例如“浙”转换成“\u6d59”。 2、https://tool.oschina.net/hexconvert/选16进制转10进制，输入上面的“6d59”，转换结果为“27993”。 <Key android:codes="27993" android:keyLabel="浙"
android自定义键盘
09-25
总结来说，自定义键盘在Android开发中是一种常见的需求，通过理解并实践"android自定义键盘"这个Demo，开发者可以学习到布局设计、事件处理、自定义控件封装以及数据安全等相关知识，从而提高自己的技能水平。
android 自定义软键盘
05-06
最后，为了在应用中切换到这个自定义键盘，需要在输入框上设置输入法属性，指定我们的`InputMethodService`： ```xml android:id="@+id/numeric_input" android:layout_width="match_parent" android:layout_...
Android自定义软键盘
08-29
在Android开发中，有时我们需要为特定应用或者输入场景创建自定义的软键盘，以满足个性化需求或增强用户体验。本文将详细讲解如何利用Android的`KeyboardView`组件来实现这一功能。 `KeyboardView`是Android SDK...
Android 强行夺取EditText系统键盘输入改为自定义安全键盘输入
06-26
Android 强行夺取EditText系统键盘输入改为自定义安全键盘输入
android自定义数字键盘
02-02
以上就是实现一个简单的Android自定义数字键盘的基本步骤。这个键盘可以根据实际需求进行扩展，例如添加更多特殊功能按钮，如加减乘除符号，或者增加对多行文本的支持。同时，也可以考虑优化键盘的视觉样式，使其与...
Android：安全键盘
a526001650a的专栏
11-08 2566
Android：安全键盘
Android自定义控件（七) Android仿微信支付密码输入框
Ho博客
10-24 1748
早上在使用微信支付买东西时候注意到了支付的密码输入框，今天正好是10月24，就使用自定义方式来实现下。绘制分析 : 1、绘制圆角矩形 2、绘制黑色小圆点drawCircle 3、键盘自动调起处理输入和回删事件 4、输入完成后事件回调。
Android 总结：自定义键盘实现原理和三种实例详解
2401_83739727的博客
04-03 982
创建一个方法，这个方法的作用就是当我们按下某个键时发出一个声音，我们使用来播放这个声音，Android SDK给我们提供了一些键盘的声效，我们在自己定义的playClick()方法中使用。break;
Android自定义键盘（KeyboardView）
热门推荐
lwh1212的博客
06-28 1万+
Android自定义键盘（KeyboardView）
仿微信实现自定义安全数字键盘
weixin_33929309的博客
09-25 1151
背景 大部分的金融App会对默认的数字键盘进行处理，以实现自定义的数字安全键盘。基于此，本文对对微信数字键盘样式进行了仿写，实现了一套自定义的数字安全键盘（支持随机数字分布）。 一.图示效果 二.需要考虑的问题 布局的实现方式； demo中使用了popupwindow，通过xml文件进行Tablayout布局。 禁掉EditText默认软键盘的弹出，替换为自定义的数字键盘及与其它EditTex...
android 自定义数字键盘
06-10
要自定义 Android 数字键盘，你可以使用自定义视图来替代默认的数字键盘。以下是一些步骤： 1.创建一个 XML 文件来定义你的自定义数字键盘的布局。例如，你可以在这个文件中添加按钮和其他视图，来表示数字键盘上的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值