Android自定义安全键盘

最新推荐文章于 2025-04-01 11:46:43 发布
最新推荐文章于 2025-04-01 11:46:43 发布
阅读量2.7k 收藏 3
点赞数
分类专栏： Android 文章标签： android 自定义键盘
本文详细介绍了一个自定义键盘的实现过程，包括定义键盘布局、创建键盘视图、处理按键事件及切换键盘类型等功能。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

在银行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
android 自定义键盘的安全性,自定义安全键盘——仿民生银行
weixin_42640676的博客
05-25 886
系统自带键盘和第三方的键盘不管是从性能还是从体验上来说都要胜于我们自己写的，但我们为什么还要去自定义键盘呢？其实就为了安全性，比如用户在输入账户密码，支付密码的时候，防止键盘获取到我们的数据；或者说美工要求Android的键盘需要和IOS的一样，那我们就得自己去写个键盘了。效果图：keyboardView.gif一：键盘布局XML布局属性Keyboard.Key的属性.pngKeyboardVie...
Android自定义安全软键盘项目常见问题解决方案
gitblog_00597的博客
01-22 938
Android自定义安全软键盘项目常见问题解决方案 SafeKeyboard Android自定义安全软键盘，完全自定义，方便、安全、可靠 项目地址: https://gitcode.com/gh_mirrors/sa/SafeK...
仿微信实现自定义安全数字键盘
weixin_33929309的博客
09-25 1196
背景 大部分的金融App会对默认的数字键盘进行处理，以实现自定义的数字安全键盘。基于此，本文对对微信数字键盘样式进行了仿写，实现了一套自定义的数字安全键盘（支持随机数字分布）。 一.图示效果 二.需要考虑的问题 布局的实现方式； demo中使用了popupwindow，通过xml文件进行Tablayout布局。 禁掉EditText默认软键盘的弹出，替换为自定义的数字键盘及与其它EditTex...
android 自定义输入法实现数字键盘、符号键盘、字母键盘
最新发布
chenzhirong520的博客
04-01 892
以上就是我实现输入法的大概思路以及效果。如需获取源代码请联系我vx；提前声明此源码需要为知识付费一包yan钱就能为你提供完整的思路，节省你的时间，提升你的效率；时间和效率最宝贵啊，探索不易啊，介意着勿扰。[添加时请备注"CSDN读者"，可快速通过审核」
Andorid 自定义安全键盘
09-23
Android 自定义安全键盘
Android 自定组件（安全键盘）
斯旺森swanson
09-14 497
常见的安全键盘，随机排列数字，点击状态的回调。 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自定义安全软键盘开发详细步骤
我的专栏
03-05 3114
源码地址：GitHub:https://github.com/SValence/SafeKeyboard 在一些比较敏感的输入场合，我们不能调用系统的软键盘进行输入信息，这时候就需要自定义一个软键盘来完成输入工作，由此就需要下面 Android 安全软键盘开发 的工作，本文主要从项目需求出发，梳理开发流程，并给出一个实际开发的例子作为参考。 一、Android 安全软键...
自定义键盘
qq906786621的专栏
06-01 625
简单自定义安全键盘（只能输入字母，数字，部分符号） 标签： android自定义键盘 2016-06-01 16:04 239人阅读 评论(0) 收藏 举报  分类：   笔记（14）  以前知道有个KeyboardView这个东西可以自定义键盘，但因为一直没涉及到，所以没研究过，今天看到工商银行密码输入的键盘觉得挺好看，就来研究一下。 先
Android代码-自定义安全键盘
08-07
LazyKeyboard A SecurityKeyBoard for Android. Supporting three kinds of keyboard: Letter, Number, Symbol. 中文版 Installation Gradle Step 1. Add it in your root build.gradle at the end of repositories: allprojects { repositories { ... maven { url 'https://jitpack.io' } } } Step 2. Add the dependency dependencies { implementation 'com.github.onlyloveyd:LazyKeyboard:v1.3' } Basic Usage Step 1. Add SecurityEditText into your layout Step 2. init SecurityKeyboard with the layout
Android-Android自定义键盘数字键盘和字母键盘
08-13
在Android应用开发中，有时需要实现自定义键盘以满足特定输入需求，比如金融应用中的数字键盘或聊天应用中的字母键盘。本篇文章将深入探讨如何在Android中创建自定义的数字键盘和字母键盘。 首先，我们需要了解...
自定义安全键盘
08-16
自定义漂亮键盘的完整demo，里面包括随机键盘加密码输入框，还有正序键盘，可以直接下载运行
Android-KeyboardView自定义安全键盘
08-13
KeyboardView 自定义安全键盘
Android 自定义键盘（完全定制，向上顶布局，点击按钮进行隐藏）
09-18
之前上传的另外一个自定义键盘，并没有实现键盘弹出的时候，布局向上自动调整。（网络上所有的自定义键盘都没有添加自适应的功能，而且布局没这么好看，上一个例子资源链接为：http://download.csdn.net/detail/omayyouhappy/9111809），这个资源绝对值10分，真的全网络唯一完美的自定义定制键盘。
android安全键盘
11-27
android 安全键盘 博客地址:http://blog.csdn.net/wishes222/article/details/16979581
Android 安全键盘 字母和数字和符号
09-27
Android 安全键盘 字母和数字和符号，安全键盘，可以随机生成。为了Android工程的密码输入的安全性。自己测试过，可以使用的。
Android自定义安全软键盘开发详细说明
热门推荐
SValence的博客
06-27 1万+
移步新博客 https://blog.csdn.net/SValence/article/details/93901651 源码地址：GitHub:https://github.com/SValence/SafeKeyboard 在一些比较敏感的输入场合，我们不能调用系统的软键盘进行输入信息，这时候就需要自定义一个软键盘来完成输入工作，由此就需要下面 Andr...
Android自定义键盘的实现（数字键盘和字母键盘）
08-29
Android自定义键盘的实现（数字键盘和字母键盘） Android自定义键盘是指在Android系统中创建一个自定义的键盘，满足特定的输入需求。自定义键盘可以根据项目的需求，实现特定的输入方式，例如数字键盘和字母键盘。...
自定义Android键盘
dzqxwzoe的博客
02-25 3878
前段时间改造了公司的安全键盘，是基于Dialog和Button自定义的。也因此借机了解下 Android 平台提供的自定义键盘接口。Keyboard和。很搞笑的是，百度出来自定义Android键盘（与自定义Android输入法不同）的文章千篇一律。这里讲的自定义键盘同公司安全键盘是两种实现方式，不存在泄露公司内部技术的问题！！！不去吐槽别人，楼主秉持只原创和翻译的作风，输出这第50篇博客。相关属性部分是对照官方文档和Demo实践翻译的，若有瑕疵，请见谅。楼主csdn主页请点击flueky专栏。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值