一、软键盘介绍

　　实现软键盘主要用到了系统的两个类：Keyboard和KeyboardView。

　　Keyboard类源码的介绍是： Listener for virtual keyboard events.即用于监听虚拟键盘。

　　KeyboardView类源码的介绍是： A view that renders a virtual {@link Keyboard}. It handles rendering of keys and detecting key presses and touch movements.即它处理绘制键盘和检测按键和触摸动作。

　　它里面有很多方法，在我们自定义的软键盘很多属性，就需要我们用这个类来设置。比如：

Java代码
  1. keyboardView = (KeyboardView) act.findViewById(R.id.keyboard_view);    
  2. keyboardView.setKeyboard(k);    
  3. keyboardView.setEnabled(true);    
  4. keyboardView.setPreviewEnabled(true);  
  5. keyboardView.setVisibility(View.VISIBLE);  
  6. keyboardView.setOnKeyboardActionListener(listener);  

　　了解一些源码，就可以是我们知道我们为什么要这样写，为什么要这样做了！

　　二、数字软键盘的布局

　　首先在res下新建xml文件夹，在xml文件夹中新建symbols.xml文件，这个布局文件主要是实现数字软键盘的布局，每一个按键都有一个codes值，在类中就是通过codes值来监听每一个按钮。

XML/HTML代码
  1. <?xml version="1.0" encoding="utf-8"?>  
  2. <Keyboard xmlns:android="http://schemas.android.com/apk/res/android"  
  3.     android:keyWidth="20%p" android:horizontalGap="0px"  
  4.     android:verticalGap="0px" android:keyHeight="@dimen/key_height">  
  5.   
  6.     <Row>  
  7.         <Key android:codes="49" android:keyLabel="1" />  
  8.         <Key android:codes="50" android:keyLabel="2" />  
  9.         <Key android:codes="51" android:keyLabel="3" />  
  10.         <Key android:codes="52" android:keyLabel="4" />  
  11.         <Key android:codes="-5" android:keyIcon="@drawable/sym_keyboard_delete" />  
  12.     </Row>  
  13.   
  14.     <Row>         
  15.         <Key android:codes="53" android:keyLabel="5" />  
  16.         <Key android:codes="54" android:keyLabel="6" />  
  17.         <Key android:codes="55" android:keyLabel="7" />  
  18.         <Key android:codes="56" android:keyLabel="8" />  
  19.         <Key android:codes="-2" android:keyLabel="中文" />  
  20.     </Row>  
  21.   
  22.     <Row>         
  23.         <Key android:codes="57" android:keyLabel="9" />  
  24.         <Key android:codes="48" android:keyLabel="0" />  
  25.         <Key android:codes="46" android:keyLabel="." />  
  26.         <Key android:codes="-3" android:keyWidth="40%p"  
  27.             android:isRepeatable="true" android:keyLabel="完成" />  
  28.     </Row>  
  29.   
  30. </Keyboard>  

　　数字键盘界面如下：

Android自定义键盘之汉字键盘

　　在上面的键盘定义中，通过Keyboard说明是一个软键盘定义文件，Row元素说明这是一行按键的定义，Key元素说明这是一个按键的定义。Key元素通过一些属性来定义每个按键，下面是一些常用的属性介绍：

　　Codes：代表按键对应的输出值，可以为unicode值或者逗号(,)分割的多个值，也可以为一个字符串。在字符串中通过“\”来转义特殊字符，例如 ‘\n’ 或则 ‘\uxxxx’ 。Codes通常用来定义该键的键码，例如上图中的数字按键1对应的为49；如果提供的是逗号分割的多个值则和普通手机输入键盘一样在多个值之间切换。

　　keyLabel：代表按键显示的文本内容。

　　keyIcon：代表按键显示的图标内容，如果指定了该值则在显示的时候显示为图片不显示文本。

　　keyWidth：代表按键的宽度，可以为精确值或则相对值，对于精确值支持多种单位，例如：像素，英寸 等；相对值为相对于基础取值的百分比，为以% 或%p 结尾，其中%p表示相对于父容器。

　　keyHeight：代表按键的高度，取值同上。

　　horizontalGap：代表按键前的间隙（水平方向），取值同上。

　　isSticky：指定按键是否为sticky的。例如Shift大小写切换按键，具有两种状态，按下状态和正常状态，取值为true或者false。

　　isModifier：指定按键是否为功能键( modifier key ) ，例如 Alt 或者 Shift ，取值为true或false。

　　keyOutputText：指定按键输出的文本内容，取值为字符串。

　　isRepeatable：指定按键是否是可重复的，如果长按该键可以触发重复按键事件则为true，否则为false。

　　keyEdgeFlags：指定按键的对齐指令，取值为left或right。

　　我们在设置每一个按键的code时，就是根据keyboard类中定义的一些属性，比如回退，切换，完成等都是固定的。

Java代码
  1. public static final int KEYCODE_SHIFT = -1;    
  2. public static final int KEYCODE_MODE_CHANGE = -2;    
  3. public static final int KEYCODE_CANCEL = -3;    
  4. public static final int KEYCODE_DONE = -4;    
  5. public static final int KEYCODE_DELETE = -5;    
  6. public static final int KEYCODE_ALT = -6;  

　　知道了这些，我们就不会有太多的疑惑了！也是说，我们自定义的每一个按键都将会有一个codes值，比如回退我们就写成：

XML/HTML代码
  1. <Key android:codes="-5" android:keyIcon="@drawable/sym_keyboard_delete" />  

　　在监听处就是：

Java代码
  1. if (primaryCode == Keyboard.KEYCODE_DELETE){}  

　　这就表示，监听回退事件了！

　　三、中文软键盘的布局

　　然后在xml文件夹中新建chinese.xml文件，这个布局文件主要是实现中文软键盘的布局，每一个按键都有一个codes值，这个codes就是一个汉字在utf16标准中的编码值。

　　查找汉字的编码，有两种方法：

　　1，直接查找utf16表，可以参考：http://blog.csdn.net/lintax/article/details/51866861

　　如果汉字个数比较多，需要将汉字与编码值一个个准确对应的键入xml中，也是一个挺费神的事情。

　　2，使用程序员的办法，用代码来帮我们实现：

Java代码
  1. //get the codes for xml  
  2. char c;  
  3. int i;  
  4. String[] strings = { "一",  "二", "三", "四", "五", "六", "年", "级", "班", "."};  
  5. for(String str : strings){  
  6.     c=str.toCharArray()[0];  
  7.     i=c;  
  8.     //xml中格式：<Key android:codes="19968" android:keyLabel="一" />  
  9.     Log.i("key","<Key android:codes=\""+i+"\" android:keyLabel=\""+c+"\" />");  
  10. }  

　　这样，就按照xml中的格式，写好了汉字与编码值的关联语句。

　　剩下还有一个小问题：在logcat的输出中，还有其他的信息，如时间、log等级等，如下：

XML/HTML代码
  1. 07-16 18:20:12.220: I/key(5200): <Key android:codes="29677" android:keyLabel="班" />  

　　我们可以将logcat信息保存到文本文件中，使用一个文本编辑器将前面的不想要的信息（此处是“07-16 18:20:12.220: I/key(5200): ”）全部替换为8个空格即可。

　　为何是8个空格？是为了xml中的格式对齐。

　　最终，xml中文件内容如下：

XML/HTML代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <Keyboard android:keyWidth="25.000002%p" android:keyHeight="@dimen/key_height"  
  3.     android:horizontalGap="0.0px" android:verticalGap="0.0px"  
  4.     xmlns:android="http://schemas.android.com/apk/res/android">  
  5.   
  6.     <Row>  
  7.         <Key android:codes="19968" android:keyLabel="一" />  
  8.         <Key android:codes="20108" android:keyLabel="二" />  
  9.         <Key android:codes="19977" android:keyLabel="三" />  
  10.         <Key android:codes="-5" android:isRepeatable="true"  
  11.             android:keyIcon="@drawable/sym_keyboard_delete" />  
  12.     </Row>  
  13.   
  14.     <Row>  
  15.         <Key android:codes="22235" android:keyLabel="四" />  
  16.         <Key android:codes="20116" android:keyLabel="五" />  
  17.         <Key android:codes="20845" android:keyLabel="六" />  
  18.         <Key android:codes="-2" android:keyLabel="数字" />  
  19.     </Row>  
  20.   
  21.     <Row>  
  22.         <Key android:codes="24180" android:keyLabel="年" />  
  23.         <Key android:codes="32423" android:keyLabel="级" />  
  24.         <Key android:codes="29677" android:keyLabel="班" />  
  25.         <Key android:keyWidth="25.000004%p" android:codes="-3"  
  26.             android:keyEdgeFlags="right" android:keyLabel="完成" />     
  27.     </Row>  
  28.   
  29. </Keyboard>  

　　中文键盘最终画面如下：

Android自定义键盘之汉字键盘

　　四、键盘事件处理

　　然后创建一个类，用于处理软键盘事件，文件名为KeyboardUtil.Java,内容如下：

Java代码
  1. package cn.key;  
  2.   
  3. import java.util.List;  
  4.   
  5. import android.app.Activity;  
  6. import android.content.Context;  
  7. import android.inputmethodservice.Keyboard;  
  8. import android.inputmethodservice.KeyboardView;  
  9. import android.inputmethodservice.Keyboard.Key;  
  10. import android.inputmethodservice.KeyboardView.OnKeyboardActionListener;  
  11. import android.text.Editable;  
  12. import android.view.View;  
  13. import android.widget.EditText;  
  14.   
  15. public class KeyboardUtil {  
  16.     private Context ctx;  
  17.     private Activity act;  
  18.     private KeyboardView keyboardView;  
  19.     private Keyboard k1;// 中文键盘  
  20.     private Keyboard k2;// 数字键盘  
  21.     public boolean isNumber = false;// 是否数字键盘  
  22.     public boolean isUpper = false;// 是否大写  
  23.   
  24.     private EditText ed;  
  25.   
  26.     public KeyboardUtil(Activity act, Context ctx, EditText edit) {  
  27.         this.act = act;  
  28.         this.ctx = ctx;  
  29.         this.ed = edit;  
  30.         k1 = new Keyboard(ctx, R.xml.chinese);  
  31.         k2 = new Keyboard(ctx, R.xml.symbols);  
  32.         keyboardView = (KeyboardView) act.findViewById(R.id.keyboard_view);  
  33.         keyboardView.setKeyboard(k1);  
  34.         keyboardView.setEnabled(true);  
  35.         keyboardView.setPreviewEnabled(true);  
  36.         keyboardView.setOnKeyboardActionListener(listener);  
  37.     }  
  38.   
  39.     private OnKeyboardActionListener listener = new OnKeyboardActionListener() {  
  40.         @Override  
  41.         public void swipeUp() {  
  42. //          super.swipeUp();  
  43.   
  44.         }  
  45.   
  46.         @Override  
  47.         public void swipeRight() {  
  48.         }  
  49.   
  50.         @Override  
  51.         public void swipeLeft() {  
  52.         }  
  53.   
  54.         @Override  
  55.         public void swipeDown() {  
  56.         }  
  57.   
  58.         @Override  
  59.         public void onText(CharSequence text) {  
  60. //          super.onText(text);  
  61.         }  
  62.   
  63.         @Override  
  64.         public void onRelease(int primaryCode) {  
  65.         }  
  66.   
  67.         @Override  
  68.         public void onPress(int primaryCode) {  
  69.         }  
  70.   
  71.         @Override  
  72.         public void onKey(int primaryCode, int[] keyCodes) {  
  73.             Editable editable = ed.getText();  
  74.             int start = ed.getSelectionStart();  
  75.             if (primaryCode == Keyboard.KEYCODE_CANCEL) {//完成  
  76.                 hideKeyboard();  
  77.             } else if (primaryCode == Keyboard.KEYCODE_DELETE) {//回退  
  78.                 if (editable != null && editable.length() > 0) {  
  79.                     if (start > 0) {  
  80.                         editable.delete(start - 1, start);  
  81.                     }  
  82.                 }  
  83.             } else if (primaryCode == Keyboard.KEYCODE_SHIFT) {//大小写切换  
  84.   
  85.   
  86.     changeKey();  
  87.                 keyboardView.setKeyboard(k1);  
  88.   
  89.             } else if (primaryCode == Keyboard.KEYCODE_MODE_CHANGE) {//数字键盘切换  
  90.                 if (isNumber) {  
  91.                     isNumber = false;  
  92.                     keyboardView.setKeyboard(k1);  
  93.                 } else {  
  94.                     isNumber = true;  
  95.                     keyboardView.setKeyboard(k2);  
  96.                 }  
  97.             } else if (primaryCode == 57419) { // go left  
  98.                 if (start > 0) {  
  99.                     ed.setSelection(start - 1);  
  100.                 }  
  101.             } else if (primaryCode == 57421) { // go right  
  102.                 if (start < ed.length()) {  
  103.                     ed.setSelection(start + 1);  
  104.                 }  
  105.             } else {  
  106.                 editable.insert(start, Character.toString((char) primaryCode));  
  107.             }  
  108.         }  
  109.     };  
  110.   
  111.     /** 
  112.      * 键盘大小写切换 
  113.      */  
  114.     private void changeKey() {  
  115.         List<Key> keylist = k1.getKeys();  
  116.         if (isUpper) {//大写切换小写  
  117.             isUpper = false;  
  118.             for(Key key:keylist){  
  119.                 if (key.label!=null && isword(key.label.toString())) {  
  120.                     key.label = key.label.toString().toLowerCase();  
  121.                     key.codes[0] = key.codes[0]+32;  
  122.                 }  
  123.             }  
  124.         } else {//小写切换大写  
  125.             isUpper = true;  
  126.             for(Key key:keylist){  
  127.                 if (key.label!=null && isword(key.label.toString())) {  
  128.                     key.label = key.label.toString().toUpperCase();  
  129.                     key.codes[0] = key.codes[0]-32;  
  130.                 }  
  131.             }  
  132.         }  
  133.     }  
  134.   
  135.     public void showKeyboard() {  
  136.         int visibility = keyboardView.getVisibility();  
  137.         if (visibility == View.GONE || visibility == View.INVISIBLE) {  
  138.             keyboardView.setVisibility(View.VISIBLE);  
  139.         }  
  140.     }  
  141.   
  142.     public void hideKeyboard() {  
  143.         int visibility = keyboardView.getVisibility();  
  144.         if (visibility == View.VISIBLE) {  
  145.             keyboardView.setVisibility(View.INVISIBLE);  
  146.         }  
  147.     }  
  148.   
  149.     private boolean isword(String str){  
  150.         String wordstr = "abcdefghijklmnopqrstuvwxyz";  
  151.         if (wordstr.indexOf(str.toLowerCase())>-1) {  
  152.             return true;  
  153.         }  
  154.         return false;  
  155.     }  
  156.   
  157.     public void showChinese() {  
  158.         showKeyboard();       
  159.         isNumber = false;  
  160.         keyboardView.setKeyboard(k1);         
  161.     }  
  162.   
  163.     public void showNumber() {  
  164.         showKeyboard();  
  165.         isNumber = true;  
  166.         keyboardView.setKeyboard(k2);                 
  167.     }  
  168.   
  169. }  

　　五、主界面布局

　　接下来就是实现activity的视图布局文件了，文件名为main.xml，内容如下：

XML/HTML代码
  1. <?xml version="1.0" encoding="utf-8"?>  
  2. <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"  
  3.     android:layout_width="fill_parent"  
  4.     android:layout_height="fill_parent"  
  5.     android:orientation="vertical" >  
  6.   
  7.     <LinearLayout  
  8.         android:id="@+id/ll_hint"  
  9.         android:layout_width="fill_parent"  
  10.         android:layout_height="wrap_content"  
  11.         android:orientation="horizontal" >  
  12.   
  13.         <TextView  
  14.             android:id="@+id/tv_class"  
  15.             android:layout_width="wrap_content"  
  16.             android:layout_height="wrap_content"  
  17.             android:layout_weight="1"  
  18.             android:layout_marginLeft="10dp"              
  19.             android:text="班级"              
  20.             android:textSize="20dip" />  
  21.   
  22.         <TextView  
  23.             android:id="@+id/tv_scrore"  
  24.             android:layout_width="0dp"  
  25.             android:layout_height="wrap_content"  
  26.             android:layout_weight="1"  
  27.             android:layout_marginRight="20dp"  
  28.             android:text="得分"  
  29.             android:textSize="20dip" />  
  30.     </LinearLayout>  
  31.   
  32.     <LinearLayout  
  33.         android:id="@+id/ll_content"  
  34.         android:layout_width="fill_parent"  
  35.         android:layout_height="wrap_content"  
  36.         android:layout_below="@id/ll_hint"  
  37.         android:layout_marginTop="10dp"  
  38.         android:orientation="horizontal" >  
  39.   
  40.         <EditText  
  41.             android:id="@+id/edit_class"  
  42.             android:layout_width="0dp"  
  43.             android:layout_height="wrap_content"  
  44.             android:layout_weight="1"  
  45.             android:hint="请输入班级" />  
  46.   
  47.         <EditText  
  48.             android:id="@+id/edit_score"  
  49.             android:layout_width="0dp"  
  50.             android:layout_height="wrap_content"  
  51.             android:layout_weight="1"  
  52.             android:hint="请输入分数" />  
  53.     </LinearLayout>  
  54.   
  55.   
  56.     <RelativeLayout  
  57.         android:layout_width="fill_parent"  
  58.         android:layout_height="wrap_content" >  
  59.   
  60.         <android.inputmethodservice.KeyboardView  
  61.             android:id="@+id/keyboard_view"  
  62.             android:layout_width="fill_parent"  
  63.             android:layout_height="wrap_content"  
  64.             android:layout_alignParentBottom="true"  
  65.             android:background="@color/lightblack"  
  66.             android:focusable="true"  
  67.             android:focusableInTouchMode="true"  
  68.             android:keyBackground="@drawable/btn_keyboard_chinese"  
  69.             android:keyTextColor="@color/white"  
  70.             android:visibility="gone" />  
  71.     </RelativeLayout>  
  72.   
  73. </RelativeLayout>  

　　界面比较简单，主要是两个文本输入框，一个是班级（输入汉字），一个是分数（输入数字）。另外有一个隐藏的KeyboardView，在我们点击文本输入框时，会显示出来。

　　六、主类的实现

　　最后就在你要执行的activity中，添加一些代码就行了，剩下的就和其他控件使用方式一样了，类名为KeydemoActivity.java,内容如下：

Java代码
  1. package cn.key;  
  2.   
  3. import java.lang.reflect.Method;  
  4. import android.app.Activity;  
  5. import android.content.Context;  
  6. import android.os.Bundle;  
  7. import android.text.InputType;  
  8. import android.util.Log;  
  9. import android.view.ActionMode;  
  10. import android.view.ActionMode.Callback;  
  11. import android.view.Menu;  
  12. import android.view.MenuItem;  
  13. import android.view.MotionEvent;  
  14. import android.view.View;  
  15. import android.view.View.OnTouchListener;  
  16. import android.view.WindowManager;  
  17. import android.widget.EditText;  
  18.   
  19. public class KeydemoActivity extends Activity {  
  20.     private Context ctx;  
  21.     private Activity act;  
  22.     private EditText edit_class;  
  23.     private EditText edit_score;  
  24.   
  25.     @Override  
  26.     public void onCreate(Bundle savedInstanceState) {  
  27.         super.onCreate(savedInstanceState);  
  28.         setContentView(R.layout.main);  
  29.   
  30.         //get the codes for xml  
  31.         char c;  
  32.         int i;  
  33.         String[] strings = { "一",  "二", "三", "四", "五", "六", "年", "级", "班", "."};  
  34.         for(String str : strings){  
  35.             c=str.toCharArray()[0];  
  36.             i=c;  
  37.             //xml中格式：<Key android:codes="19968" android:keyLabel="一" />  
  38.             Log.i("key","<Key android:codes=\""+i+"\" android:keyLabel=\""+c+"\" />");  
  39.         }  
  40.   
  41.   
  42.         edit_class = (EditText) this.findViewById(R.id.edit_class);  
  43.         edit_score = (EditText) this.findViewById(R.id.edit_score);  
  44.   
  45.   
  46.         //禁止弹出系统默认的软键盘  
  47.         if (android.os.Build.VERSION.SDK_INT <= 10) {  
  48.             edit_class.setInputType(InputType.TYPE_NULL);  
  49.         } else {  
  50.             this.getWindow().setSoftInputMode  
  51.   
  52. (WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);  
  53.             try {  
  54.                 Class<EditText> cls = EditText.class;  
  55.                 Method setSoftInputShownOnFocus;  
  56.                 setSoftInputShownOnFocus = cls.getMethod("setShowSoftInputOnFocus",   
  57.   
  58. boolean.class);  
  59.                 setSoftInputShownOnFocus.setAccessible(true);  
  60.                 setSoftInputShownOnFocus.invoke(edit_class, false);  
  61.                 setSoftInputShownOnFocus.invoke(edit_score, false);  
  62.             } catch (Exception e) {  
  63.                 e.printStackTrace();  
  64.             }  
  65.         }  
  66.   
  67.   
  68.         //禁止长按选择  
  69.         edit_class.setCustomSelectionActionModeCallback(new Callback() {   
  70.             @Override  
  71.             public boolean onPrepareActionMode(ActionMode mode, Menu menu) {   
  72.                 return false;  
  73.             }   
  74.             @Override  
  75.             public void onDestroyActionMode(ActionMode mode) {    
  76.             }   
  77.             @Override  
  78.             public boolean onCreateActionMode(ActionMode mode, Menu menu) {   
  79.                 //这里可以添加自己的菜单选项（前提是要返回true的）  
  80.                 return false;//返回false 就是屏蔽ActionMode菜单  
  81.             }   
  82.             @Override  
  83.             public boolean onActionItemClicked(ActionMode mode, MenuItem item) {   
  84.                 return false;  
  85.             }  
  86.         });  
  87.   
  88.         edit_score.setCustomSelectionActionModeCallback(new Callback() {   
  89.             @Override  
  90.             public boolean onPrepareActionMode(ActionMode mode, Menu menu) {   
  91.                 return false;  
  92.             }   
  93.             @Override  
  94.             public void onDestroyActionMode(ActionMode mode) {    
  95.             }   
  96.             @Override  
  97.             public boolean onCreateActionMode(ActionMode mode, Menu menu) {   
  98.                 //这里可以添加自己的菜单选项（前提是要返回true的）  
  99.                 return false;//返回false 就是屏蔽ActionMode菜单  
  100.             }   
  101.             @Override  
  102.             public boolean onActionItemClicked(ActionMode mode, MenuItem item) {   
  103.                 return false;  
  104.             }  
  105.         });  
  106.   
  107.   
  108.         //设置监听动作，弹出自定义键盘  
  109.         ctx = this;  
  110.         act = this;  
  111.         edit_class.setOnTouchListener(new OnTouchListener() {  
  112.             @Override  
  113.             public boolean onTouch(View v, MotionEvent event) {  
  114.                 new KeyboardUtil(act, ctx, edit_class).showChinese();  
  115.                 return false;  
  116.             }  
  117.         });  
  118.   
  119.         edit_score.setOnTouchListener(new OnTouchListener() {  
  120.             @Override  
  121.             public boolean onTouch(View v, MotionEvent event) {               
  122.                 new KeyboardUtil(act, ctx, edit_score).showNumber();  
  123.                 return false;  
  124.             }  
  125.         });  
  126.   
  127.     }  
  128. }  

　　最后的运行界面如下：

Android自定义键盘之汉字键盘

　　七、demo地址

　　http://download.csdn.net/detail/lintax/9577994

本文发布：Android开发网
本文地址：http://www.jizhuomi.com/android/example/596.html
2016年7月18日
发布:鸡啄米 分类:Android开发实例 浏览: 评论:0