Android用户空间的处理及移植需要注意的情况

第8章
用户输入系统
8.1 用户输入系统结构和移植内容
Android中，用户输入系统的结构相对简单，主要的输入硬件设备是键盘、触摸屏、轨迹球等。
在Android的上层中，可以通过获得这些设备产生的事件，并对设备的事件做出响应。在Java框架和应用程序层，通常使用运动事件获得触摸屏、轨迹球等设备的信息，用按键事件获得各种键盘的信息。
Android用户输入系统的基本层次结构如图8-1所示。
8.1.1 用户输入系统的结构
Android用户输入系统的结构比较简单，自下而上包含了驱动程序、本地库处理部分、Java类对输入事件的处理、对Java程序的接口。Android用户输入系统的结构如图8-2所示。
图8-2 用户输入系统的结构
如图8-2所示，自下而上，Android的用户输入系统分成几个部分：
· 驱动程序：在/dev/input目录中，通常是Event类型的驱动程序
· EventHub：本地框架层的EventHub是libui中的一部分，它实现了对驱动程序的控制，并从中获得信息
· KeyLayout（按键布局）和KeyCharacterMap（按键字符映射）文件。同时，libui中有相应的代码对其操作。定义按键布局和按键字符映射需要运行时配置文件的支持，它们的后缀名分别为kl和kcm
· Java 框架层的处理：在Java框架层具有KeyInputDevice等类用于处理由EventHub传送上来的信息，通常信息由数据结构 RawInputEvent和KeyEvent来表示。通常情况下，对于按键事件，则直接使用KeyEvent来传送给应用程序层，对于触摸屏和轨迹球等 事件，则由RawInputEvent经过转换后，形成MotionEvent时间传送给应用程序层
· 在 Android的应用程序层中，通过重新实现onTouchEvent和onTrackballEvent等函数来接收运动事件 （MotionEvent），通过重新实现&111nKeyDown和&111nKeyUp等函数来接收按键事件（KeyEvent）。 这些类包含在android.view包中
8.1.2 移植的内容
移植Android的用户输入系统，主要的工作分成以下两个部分：
· 输入（input）驱动程序
· 用户空间中动态配置的kl和kcm文件
由于Android用户输入部分的“硬件抽象层”就是libui库中的EventHub，这部分是系统标准的部分。因此，在实现特定硬件平台的Android系统的时候，用户输入的硬件抽象层通常情况下不做改变。
EventHub使用Linux标准的input设备作为输入设备，其中又以实用Event设备居多。在这种情况下，为了实现Android系统的输入，也必须使用Linux标准input驱动程序作为标准的输入。
由于标准化程度比较高，实现用户输入系统，在用户空间一般不需要更改代码。唯一的情况是使用不同的kl和kcm文件，使用按键的布局和按键字符映射关系。
8.2 移植的要点
8.2.1 input驱动程序
Input驱动程序是Linux输入设备的驱动程序，分成游戏杆（joystick）、鼠标（mouse和mice）和事件设备（Event queue）3种驱动程序。其中事件驱动程序是目前通用的驱动程序，可支持键盘、鼠标、触摸屏等多种输入设备。
Input驱动程序的主设备号是13，3种驱动程序的设备号分配如下所示。
· joystick游戏杆：0～31
· mouse鼠标：32～62
· mice鼠标：63
· 事件（Event）设备：64～95
实际上，每一种Input设备占用5位，因此每种设备包含的个数是32个。
Event 设备在用户空间大多使用read、ioctl、poll等文件系统的接口进行操作，read用于读取输入信息，ioctl用于获得和设置信息，poll调 用可以进行用户空间的阻塞，当内核有按键等中断时，通过在中断中唤醒poll的内核实现，这样在用户空间的poll调用也可以返回。
Event设备在文件系统中的设备节点为：/dev/input/eventX。
主设备号为13，次设备号递增生成，为64～95，各个具体的设备在misc、touchscreen，keyboard等目录中。
Event输入驱动的架构如图8-3所示。
输入设备驱动程序的头文件：include/linux/input.h。
输入设备驱动程序的核心和Event部分代码分别是：drivers/input/input.c和drivers/input/ evdev.c。
图8-3 Event设备驱动的架构
input.h中定义了struct input_dev结构，它表示Input驱动程序的各种信息，对于Event设备分为同步设备、键盘、相对设备（鼠标）、绝对设备（触摸屏）等。
input_dev中定义并归纳了各种设备的信息，例如按键、相对设备、绝对设备、杂项设备、LED、声音设备，强制反馈设备、开关设备等。
1. struct input_dev {
2. const char *name; // 设备名称
3. const char *phys; // 设备在系统的物理路径
4. const char *uniq; // 统一的ID
5. struct input_id id; // 设备ID
6. unsigned long evbit[BITS_TO_LONGS(EV_CNT)]; // 事件
7. unsigned long keybit[BITS_TO_LONGS(KEY_CNT)]; // 按键
8. unsigned long relbit[BITS_TO_LONGS(REL_CNT)]; // 相对设备
9. unsigned long absbit[BITS_TO_LONGS(ABS_CNT)]; // 绝对设备
10. unsigned long mscbit[BITS_TO_LONGS(MSC_CNT)]; // 杂项设备
11. unsigned long ledbit[BITS_TO_LONGS(LED_CNT)]; // LED
12. unsigned long sndbit[BITS_TO_LONGS(SND_CNT)]; // 声音设备
13. unsigned long ffbit[BITS_TO_LONGS(FF_CNT)]; // 强制反馈备
14. unsigned long swbit[BITS_TO_LONGS(SW_CNT)]; // 开关设备
15. unsigned int keycodemax; // 按键码的最大值
16. unsigned int keycodesize; // 按键码的大小
17. void *keycode; // 按键码
18. int (*setkeycode)(struct input_dev *dev, int scancode, int keycode);
19. int (*getkeycode)(struct input_dev *dev, int scancode, int *keycode);
20. struct ff_device *ff;
21. unsigned int repeat_key;
22. struct timer_list timer;
23. int sync;
24. int abs[ABS_MAX + 1];
25. int rep[REP_MAX + 1];
26. unsigned long key[BITS_TO_LONGS(KEY_CNT)];
27. unsigned long led[BITS_TO_LONGS(LED_CNT)];
28. unsigned long snd[BITS_TO_LONGS(SND_CNT)];
29. unsigned long sw[BITS_TO_LONGS(SW_CNT)];
30. int absmax[ABS_MAX + 1]; // 绝对设备相关内容
31. int absmin[ABS_MAX + 1];
32. int absfuzz[ABS_MAX + 1];
33. int absflat[ABS_MAX + 1]; // 设备相关的操作
34. int (*open)(struct input_dev *dev);
35. void (*close)(struct input_dev *dev);
36. int (*flush)(struct input_dev *dev, struct file *file);
37. int (*event)(struct input_dev *dev, unsigned int type,
38. unsigned int code, int value);
39. struct input_handle *grab;
40. spinlock_t event_lock;
41. struct mutex mutex;
42. unsigned int users;
43. int going_away;
44. struct device dev;
45. struct list_head h_list;
46. struct list_head node;
47. };
在具体的Event驱动程序的实现中，如果得到按键的事件，通常需要通过以下的接口向上进行通知，这些内容也在input.h中定义如下所示：
1. void input_event(struct input_dev *dev, unsigned int type,
2.
3. unsigned int code, int value);
4.
5. void input_inject_event(struct input_handle *handle,
6.
7. unsigned int type, unsigned int code, int value);
8.
9. static inline void input_report_key(struct input_dev *dev,
10.
11. unsigned int code, int value)
12.
13. { input_event(dev, EV_KEY, code, !!value); }
14.
15. static inline void input_report_rel(struct input_dev *dev,
16.
17. unsigned int code, int value)
18.
19. { input_event(dev, EV_REL, code, value); }
20.
21. static inline void input_report_abs(struct input_dev *dev,
22.
23. unsigned int code, int value)
24.
25. { input_event(dev, EV_ABS, code, value); }
26.
27. static inline void input_report_ff_status(struct input_dev *dev,
28.
29. unsigned int code, int value)
30.
31. { input_event(dev, EV_FF_STATUS, code, value); }
32.
33. static inline void input_report_switch(struct input_dev *dev,
34.
35. unsigned int code, int value)
36.
37. { input_event(dev, EV_SW, code, !!value); }
38.
39. static inline void input_sync(struct input_dev *dev)
40.
41. { input_event(dev, EV_SYN, SYN_REPORT, 0); }

事实上，对不同设备内容的报告均是通过input_event()函数来完成的，选择使用了不同参数而已。
在手机系统中经常使用的键盘（keyboard）和小键盘（kaypad）属于按键设备EV_KEY，轨迹球属于相对设备EV_REL，触摸屏属于绝对设备EV_ABS。
关于按键数值的定义的片断如下所示：
1. #define KEY_RESERVED 0
2. #define KEY_ESC 1
3. #define KEY_1 2
4. #define KEY_2 3
5. #define KEY_3 4
6. #define KEY_4 5
7. #define KEY_5 6
8. #define KEY_6 7
9. #define KEY_7 8
10. #define KEY_8 9
11. #define KEY_9 10
12. #define KEY_0 11
13. #define KEY_MINUS 12
14. #define KEY_EQUAL 13
15. #define KEY_BACKSPACE 14
16. #define KEY_TAB 15
17. #define KEY_Q 16
18. #define KEY_W 17
19. #define KEY_E 18
20. #define KEY_R 19
21. #define KEY_T 20
可以使用getevent对Event设备进行调试，在Android的模拟器环境中，使用getevent的情况如下所示：
1. # getevent
2. add device 1: /dev/input/event0
3. name: "qwerty2"
4. could not get driver version for /dev/input/mouse0, Not a typewriter
5. could not get driver version for /dev/input/mice, Not a typewriter
6. /dev/input/event0: 0001 0002 00000001
7. /dev/input/event0: 0001 0002 00000000
点击数字按键1，出现了上面的信息，0002是按键的扫描码，00000001和00000000分别是按下和抬起的附加信息。最前面的0001实际上是输入设备的类型。
使用getevent可以最直接地获得按键的扫描码，对于Android系统中用户输入设备的调试，可以从源头确定底层输入设备传递上来的信息。
8.2.2 用户空间的处理
1．处理的内容和流程
触摸屏和轨迹球上报的是坐标、按下、抬起等信息，信息量比较少。按键处理的过程稍微复杂，从驱动程序到Android的Java层受到的信息，键表示方式经过了两次转化，如图8-4所示。
键 扫描码Scancode是由Linux的Input驱动框架定义的整数类型。键扫描码Scancode经过一次转化后，形成按键的标签 KeycodeLabel，是一个字符串的表示形式。按键的标签KeycodeLabel经过转换后，再次形成整数型的按键码keycode。在 Android应用程序层，主要使用按键码keycode来区分。
图8-4 Android按键输入的两次转化
在本地框架层libui的头文件中KeycodeLabels.h，按键码为整数值的格式，其定义KeyCode（枚举值）如下所示：
1. typedef enum KeyCode {
2. kKeyCodeUnknown = 0,
3. kKeyCodeSoftLeft = 1,
4. kKeyCodeSoftRight = 2,
5. kKeyCodeHome = 3,
6. kKeyCodeBack = 4,
7. // ...... 省略中间按键码
8. } KeyCode;
进而在定义了KeycodeLabels.h中定义了从字符串到整数的映射关系，数组KEYCODES，定义如下所示：
1. static const KeycodeLabel KEYCODES[] = { // {字符串，整数}
2. { "SOFT_LEFT", 1 },
3. { "SOFT_RIGHT", 2 },
4. { "HOME", 3 },
5. { "BACK", 4 },
6. { "CALL", 5 },
7. { "ENDCALL", 6 },
8. { "0", 7 }, // ...... 数字按键
9. { "1", 8 },
10. { "2", 9 },
11. { "3", 10 },
12. { "4", 11 },
13. { "5", 12 },
14. { "6", 13 },
15. { "7", 14 },
16. { "8", 15 },
17. { "9", 16 },
18. { "STAR", 17 },
19. // ...... 省略中间按键映射
20. { "MENU", 82 },
21. // ...... 省略中间按键映射
22. { NULL, 0 }
23. };
数组KEYCODES表示的映射关系，左列的内容即表示按键标签KeyCodeLabel，右列的内容为按键码KeyCode（与KeyCode的数值对应）。实际上，在按键信息第二次转化的时候就是将字符串类型KeyCodeLabel转化成整数的KeyCode。
KeycodeLabel的Flags的定义如下所示：
1. static const KeycodeLabel FLAGS[] = {
2. { "WAKE", 0x00000001 }, // 可以唤醒睡眠，并通知应用层
3. { "WAKE_DROPPED", 0x00000002 }, // 可以唤醒睡眠，不通知应用层
4. { "SHIFT", 0x00000004 }, // 自动附加SHIFT
5. { "CAPS_LOCK", 0x00000008 }, // 自动附加CAPS_LOCK
6. { "ALT", 0x00000010 }, // 自动附加ALT
7. { "ALT_GR", 0x00000020 },
8. { "MENU", 0x00000040 },
9. { "LAUNCHER", 0x00000080 },
10. { NULL, 0 }
11. };
KeycodeLabel表示按键的附属标识。
提示：frameworks/base/core/Java/android/view/KeyEvent.Java中定义了类 android.view. KeyEvent类，其中定义整数类型的数值与KeycodeLabels.h中定义的KeyCode枚举值是对应的。
在本地框架层libui的头文件中KeyCharacterMap.h，定义了按键的字符映射关系，KeyCharacterMap类的定义如下所示：
1. class KeyCharacterMap
2. {
3. public:
4. ~KeyCharacterMap();
5. unsigned short get(int keycode, int meta);
6. unsigned short getNumber(int keycode);
7. unsigned short getMatch(int keycode, const unsigned short* chars,
8. int charsize, uint32_t modifiers);
9. unsigned short getDisplayLabel(int keycode);
10. bool getKeyData(int keycode, unsigned short *displayLabel,
11. unsigned short *number, unsigned short* results);
12. inline unsigned int getKeyboardType() { return m_type; }
13. bool getEvents(uint16_t* chars, size_t len,
14. Vector* keys, Vector* modifiers);
15. static KeyCharacterMap* load(int id);
16. enum {
17. NUMERIC = 1,
18. Q14 = 2,
19. QWERTY = 3 // or AZERTY or whatever
20. };
21. }
KeyCharacterMap 用于将按键的码映射为文本可识别的字符串（例如，显示的标签等）。KeyCharacterMap是一个辅助的功能：由于按键码只是一个与UI无关整数， 通常用程序对其进行捕获处理，然而如果将按键事件转换为用户可见的内容，就需要经过这个层次的转换了。
KeyCharacterMap需要从本地层传送到Java层，JNI的代码路径如下所示：
frameworks/base/core/jni/android_text_KeyCharacterMap.cpp
KeyCharacterMap Java框架层次的代码如下所示：
frameworks/base/core/Java/android/view/KeyCharacterMap.Java
android.view.KeyCharacterMap类是Android平台的API可以在应用程序中使用这个类。
android.text.method中有各种Linstener，可以之间监听KeyCharacterMap相关的信息。DigitsKeyListener NumberKeyListener TextKeyListener。
以上关于按键码和按键字符映射的内容是在代码中实现的内容，还需要配合动态的配置文件来使用。在实现Android系统的时候，有可能需要更改这两种文件。
动态的配置文件包括：
· KL（Keycode Layout）：后缀名为kl的配置文件
· KCM（KeyCharacterMap）：后缀名为kcm的配置文件
Donut及其之前配置文件的路径为：
development/emulator/keymaps/
Eclair及其之后配置文件的路径为：
sdk/emulator/keymaps/
这些配置文件经过系统生成后，将被放置在目标文件系统的/system/usr/keylayout/目录或者/system/usr/keychars/目录中。
提示：kl文件将被直接复职到目标文件系统中；由于尺寸较大，kcm文件放置在目标文件系统中之前，需要经过压缩处理。KeyLayoutMap.cpp负责解析处理kl文件，KeyCharacterMap.cpp负责解析kcm文件。
2．kl：按键布局文件
Android 默认提供的按键布局文件主要包括qwerty.kl和AVRCP.kl。qwerty.kl为全键盘的布局文件，是系统中主要按键使用的布局文件；AVRCP.kl用于多媒体的控制，ACRCP的含义为Audio/Video Remote Control Profile。
qwerty.kl文件的片断如下所示：
1. key 399 GRAVE
2. key 2 1
3. key 3 2
4. key 4 3
5. key 5 4
6. key 6 5
7. key 7 6
8. key 8 7
9. key 10 9
10. key 11 0
11. key 158 BACK WAKE_DROPPED
12. key 230 SOFT_RIGHT WAKE
13. key 60 SOFT_RIGHT WAKE
14. key 107 ENDCALL WAKE_DROPPED
15. key 62 ENDCALL WAKE_DROPPED
16. key 229 MENU WAKE_DROPPED
17. # 省略部分按键的对应内容
18. key 16 Q
19. key 17 W
20. key 18 E
21. key 19 R
22. key 20 T
23. key 115 VOLUME_UP
24. key 114 VOLUME_DOWN
在按键布局文件中，第1列为按键的扫描码，是一个整数值；第2列为按键的标签，是一个字符串。即完成了按键信息的第1次转化，将整型的扫描码，转换成字符串类型的按键标签。第3列表示按键的Flag，带有WAKE字符，表示这个按键可以唤醒系统。
扫描码来自驱动程序，显然不同的扫描码可以对应一个按键标签。表示物理上的两个按键可以对应同一个功能按键。
例如，上面的扫描码为158的时候，对应的标签为 BACK ，再经过第二次转换，根据KeycodeLabels.h的KEYCODES数组，其对应的按键码为4。
提示：按键布局文件其实同时兼顾了input驱动程序的定义和Android中按键的定义。例如：input驱动程序中定义的数字扫描码KEY_1的数值为 2，这里2对应的按键标签也为“1”；input驱动程序中定义字母扫描码KEY_Q的数值为16，这里对应的按键标签也为“Q”。然而移动电话的全键盘 毕竟有所不同，因此有一些按键是和input驱动程序的定义没有对应关系的。
kl文件将以原始的文本文件的形式，放置于目标文件系统的/system/usr/keylayout/目录或者/system/usr/keychars/目录中。
3．kcm：按键字符映射文件
kcm表示按键字符的映射关系，主要功能是将整数类型按键码（keycode）转化成可以显示的字符。
qwerty.kcm表示全键盘的字符映射关系，其片断如下所示：
1. [type=QWERTY]
2. # keycode display number base caps fn caps_fn
3.
4. A 'A' '2' 'a' 'A' '#' 0x00
5.
6. B 'B' '2' 'b' 'B' '<' 0x00
7.
8. C 'C' '2' 'c' 'C' '9' 0x00E7
9.
10. D 'D' '3' 'd' 'D' '5' 0x00
11.
12. E 'E' '3' 'e' 'E' '2' 0x0301
13.
14. F 'F' '3' 'f' 'F' '6' 0x00A5
15.
16. G 'G' '4' 'g' 'G' '-' '_'
17.
18. H 'H' '4' 'h' 'H' '[' '{'
19.
20. I 'I' '4' 'i' 'I' '$' 0x0302
21.
22. J 'J' '5' 'j' 'J' ']' '}'
23.
24. K 'K' '5' 'k' 'K' '"' '~'
25.
26. L 'L' '5' 'l' 'L' ''' '`'
27.
28. M 'M' '6' 'm' 'M' '!' 0x00
29.
30. N 'N' '6' 'n' 'N' '>' 0x0303
第一列是转换之前的按键码，第二列之后分别表示转换成为的显示内容（display），数字（number）等内容。这些转化的内容和KeyCharacterMap.h中定义的getDisplayLabel()，getNumber()等函数相对应。
这里的类型，除了QWERTY之外，还可以是Q14（单键多字符对应的键盘），NUMERIC（12键的数字键盘）。
kcm文件将被makekcharmap工具转化成二进制的格式，放在目标系统的/system/usr/keychars/目录中。
8.2.3 移植需要注意的情况
1．EventHub中基本的处理
libui库中frameworks/base/libs/ui中的EventHub.cpp文件是用户输入系统的中枢，主要的功能都是在这个文件中实现的。
EventHub.cpp中定义设备节点所在的路径，内容如下所示：
1. static const char *device_path = "/dev/input"; // 输入设备的目录
在处理过程中，将搜索路径下面的所有Input驱动的设备节点，这在openPlatformInput()中通过调用scan_dir()来实现，scan_dir()将会从目录中查找设备，找到后调用open_device()将其打开。
1. bool EventHub::openPlatformInput(void)
2.
3. {
4.
5. // ...... 省略其他部分的内容
6.
7. res = scan_dir(device_path);
8.
9. return true;
10.
11. }
EventHub的getEvent()函数负责处理中完成，处理过程是在一个无限循环之内，调用阻塞的函数等待事件到来。
1. bool EventHub::getEvent(int32_t* outDeviceId, int32_t* outType,
2.
3. int32_t* outScancode, int32_t* outKeycode, uint32_t *outFlags,
4.
5. int32_t* outValue, nsecs_t* outWhen)
6.
7. {
8.
9. while(1) {
10.
11. // ...... 省略部分内容
12.
13. pollres = poll(mFDs, mFDCount, -1); // 使用poll处理设备节点，进行阻塞
14.
15. // ...... 省略部分内容
16.
17. for(i = 1; i < mFDCount; i++) {
18.
19. if(mFDs[i].revents) {
20.
21. if(mFDs[i].revents & POLLIN) {
22.
23. res = read(mFDs[i].fd, &iev, sizeof(iev)); // 读取信息
24.
25. // ...... 省略部分内容
26.
27. }
28.
29. }
30.
31. }
32.
33. }
poll()函数将会阻塞程序的运行，此时为等待状态，无开销，直到Input设备的相应事件发生，事件发生后poll()将返回，然后通过read()函数读取Input设备发生的事件代码。
注意，EventHub默认情况可以在/dev/input之中扫描各个设备进行处理，通常情况下所有的输入设备均在这个目录中。
实 际上，系统中可能有一些input设备可能不需要被Android整个系统使用，也就是说不需要经过EventHub的处理，在这种情况下可以根据 EventHub中open_device()函数的处理，设置驱动程序中的一些标志，屏蔽一些设备。open_device()中处理了键盘，轨迹球和 触摸屏等几种设备，对其他设备可以略过。另外一个简单的方法就是将不需要EventHub处理的设备的设备节点不放置在/dev/input之中。
open_device()函数还将打开system/usr/keylayout/中的kl文件来处理，处理的过程如下所示：
1. int EventHub::open_device(const char *deviceName) {
2.
3. // ...... 省略部分内容
4.
5. const char* root = getenv("ANDROID_ROOT");
6.
7. snprintf(keylayoutFilename, sizeof(keylayoutFilename),
8.
9. "%s/usr/keylayout/%s.kl", root, tmpfn);
10.
11. bool defaultKeymap = false;
12.
13. if (access(keylayoutFilename, R_OK)) {
14.
15. snprintf(keylayoutFilename, sizeof(keylayoutFilename),
16.
17. "%s/usr/keylayout/%s", root, "qwerty.kl");
18.
19. defaultKeymap = true;
20.
21. }
22.
23. // ...... 省略部分内容
24.
25. }
由此可见，默认情况下使用的就是qwerty.kl，这里只是扫描各个后缀名为kl的文件，然后交由KeyLayoutMap去解析处理，KeyLayoutMap是一个内部使用的类。
2．按键的增加
Android已经定义了比较丰富、完整的标准按键。在一般情况下，不需要为Android系统增加按键，只需要根据kl配置按键即可。在系统中有比较奇特按键的时候，需要更改Android系统的框架层来更改按键。
增加按键需要更改的文件较多，主要的文件如下所示。
· frameworks/base/include/ui/KeycodeLabels.h：中的KeyCode枚举数值和KeycodeLabel 类型Code数组（以NULL为结尾）
· frameworks/base/core/Java/android/view/KeyEvent.Java：定义整数值，作为平台的API供Java应用程序使用
· frameworks/base/core/res/res/values/attrs.xml：表示属性的资源文件，需要修改其中的name="keycode"的attr。
框架层增加完成后，只需要更改kl文件，增加按键的映射关系即可。
提示：在系统需要增加按键的时候，一种简易的做法是使用Android中已经定义的“生僻”按键码作为这个新增按键的键码。使用这种方式Android的框 架层不需要做任何改动。这种方式的潜在问题是当某些第三方的应用可能已经使用那些生僻按键时，将意外激发系统的这种新增的按键。
8.3 模拟器中的实现
8.3.1 驱动程序
GoldFish虚拟处理器键盘输入部分的驱动程序是event驱动程序，在标准的路径中，相关文件如下所示：
drivers/input/keyboard/goldfish_events.c
这个驱动程序是一个标准的event驱动程序，在用户空间的设备节点为/dev/event/ event0，其核心的内容为：
1. static irqreturn_t events_interrupt(int irq, void *dev_id)
2.
3. {
4.
5. struct event_dev *edev = dev_id;
6.
7. unsigned type, code, value;
8.
9. type = __raw_readl(edev->addr + REG_READ); // 类型
10.
11. code = __raw_readl(edev->addr + REG_READ); // 码
12.
13. value = __raw_readl(edev->addr + REG_READ); // 数值
14.
15. input_event(edev->input, type, code, value);
16.
17. return IRQ_HANDLED;
18.
19. }
events_interrupt实现的是按键事件的中断处理函数，当中断发生后，读取虚拟寄存器的内容，将信息上报。实际上，虚拟寄存器中的内容由模拟器根据主机环境键盘按下的情况得到。
8.3.2 用户空间的配置文件
在 模拟器环境中，使用了默认的所有的KL和KCM文件，由于模拟器环境支持全键盘，因此基本上包含了大部分的功能。在模拟器环境中，实际上按键的扫描码对应的是桌面电脑的键盘（效果和鼠标点击模拟器的控制面板类似），键盘的某些按键按下后，转化为驱动程序中的扫描码，然后再由上层的用户空间处理。这个过程和实际系统中是类似的。显然，通过更改默认的KL文件，又可以更改实际按键的映射关系。
8.4 MSM中的实现
MSM的mahimahi平台具有触摸屏，轨迹球和简易的按键，这些功能在Android中的实现包括了驱动程序和用户空间的内容。
8.4.1 触摸屏，轨迹球和按键驱动程序
MSM的Mahimahi平台的用户输入设备包括了以下几个Event设备。
· /dev/input/event4：几个按键
· /dev/input/event2：触摸屏
· /dev/input/event5：轨迹球
MSM触摸屏的驱动程序在drivers/input/touchscreen目录中的synaptics_i2c_rmi.c，这是一个i2c触摸屏的驱动程序。
MSM系统包含了按键和轨迹球的功能，具体的驱动程序在arch/arm/mach-msm/目录board-mahimahi-keypad.c文件中实现。
board-mahimahi-keypad.c中的全局定义如下所示：
1. static struct gpio_event_info *mahimahi_input_info[] = {
2.
3. &mahimahi_keypad_matrix_info.info, // 键盘矩阵
4.
5. &mahimahi_keypad_key_info.info, // 键盘信息
6.
7. &jogball_x_axis.info.info, // 轨迹球X方向信息
8.
9. &jogball_y_axis.info.info, // 轨迹球Y方向信息
10.
11. };
12.
13. static struct gpio_event_platform_data mahimahi_input_data = {
14.
15. .names = {
16.
17. "mahimahi-keypad", // 按键设备
18.
19. "mahimahi-nav", // 轨迹球设备
20.
21. NULL,
22.
23. },
24.
25. .info = mahimahi_input_info,
26.
27. .info_count = ARRAY_SIZE(mahimahi_input_info),
28.
29. .power = jogball_power,
30.
31. };
32.
33. static struct platform_device mahimahi_input_device = {
34.
35. .name = GPIO_EVENT_DEV_NAME,
36.
37. .id = 0,
38.
39. .dev = {
40.
41. .platform_data = &mahimahi_input_data,
42.
43. },
44.
45. };
按 键和轨迹球是通过GPIO系统来实现的，因此定义了gpio_event_info类型的数组。"mahimahi-keypad" 和"mahimahi-nav"分别是两个设备的名称。gpio_event_info 指针各式的数组mahimahi_input_info中包含了 mahimahi_keypad_matrix_info.info，mahimahi_keypad_key_ info.info，jogball_x_axis.info.info 和jogball_y_axis.info.info。
按键驱动是一个利用GPIO矩阵的驱动，由gpio_event_matrix_info矩阵定义，定义还需要包含按键的GPIO矩阵和input设备的信息，内容如下所示：
1. static unsigned int mahimahi_col_gpios[] = { 33, 32, 31 };
2.
3. static unsigned int mahimahi_row_gpios[] = { 42, 41, 40 };
4.
5. #define KEYMAP_INDEX(col, row) ((col)*ARRAY_SIZE(mahimahi_row_gpios) + (row))
6.
7. #define KEYMAP_SIZE (ARRAY_SIZE(mahimahi_col_gpios) * \
8.
9. ARRAY_SIZE(mahimahi_row_gpios))
10.
11. static const unsigned short mahimahi_keymap[KEYMAP_SIZE] = { // 按键映射关系
12.
13. [KEYMAP_INDEX(0, 0)] = KEY_VOLUMEUP, /* 115 */
14.
15. [KEYMAP_INDEX(0, 1)] = KEY_VOLUMEDOWN, /* 114 */
16.
17. [KEYMAP_INDEX(1, 1)] = MATRIX_KEY(1, BTN_MOUSE),
18.
19. };
20.
21. static struct gpio_event_matrix_info mahimahi_keypad_matrix_info = {
22.
23. .info.func = gpio_event_matrix_func, // 关键函数实现
24.
25. .keymap = mahimahi_keymap,
26.
27. .output_gpios = mahimahi_col_gpios,
28.
29. .input_gpios = mahimahi_row_gpios,
30.
31. .noutputs = ARRAY_SIZE(mahimahi_col_gpios),
32.
33. .ninputs = ARRAY_SIZE(mahimahi_row_gpios),
34.
35. .settle_time.tv.nsec = 40 * NSEC_PER_USEC,
36.
37. .poll_time.tv.nsec = 20 * NSEC_PER_MSEC,
38.
39. .flags = (GPIOKPF_LEVEL_TRIGGERED_IRQ |
40.
41. GPIOKPF_REMOVE_PHANTOM_KEYS |
42.
43. GPIOKPF_PRINT_UNMAPPED_KEYS),
44.
45. };
46.
47. static struct gpio_event_direct_entry mahimahi_keypad_key_map[] = { // Power按键
48.
49. {
50.
51. .gpio = MAHIMAHI_GPIO_POWER_KEY,
52.
53. .code = KEY_POWER,
54.
55. },
56.
57. };
58.
59. static struct gpio_event_input_info mahimahi_keypad_key_info = {
60.
61. .info.func = gpio_event_input_func, // 关键函数实现
62.
63. .info.no_suspend = true,
64.
65. .flags = 0,
66.
67. .type = EV_KEY,
68.
69. .keymap = mahimahi_keypad_key_map,
70.
71. .keymap_size = ARRAY_SIZE(mahimahi_keypad_key_map)
72.
73. };
mahimahi_keypad_key_matrix _info 和mahimahi_keypad _info是gpio_event_matrix_info类型的结构体，分别负责两个和一个按键的处理，实际 上，MSM的Mahimahi平台基本上只有三个按键：Power，音量增加按键和音量减少按键。音量增加和音量减少的扫描码分别是 KEY_VOLUMEUP（=115）和KEY_VOLUMEDOWN（=114）。
提示：音量控制的两个按键在全键盘的qwerty.kl有所定义，同时符合Linux的input设备和Android的按键标准。
轨迹球部分也是由GPIO实现的，由X方向和Y方向两部分组成，内容如下所示：
1. static uint32_t jogball_x_gpios[] = {
2.
3. MAHIMAHI_GPIO_BALL_LEFT, MAHIMAHI_GPIO_BALL_RIGHT,
4.
5. };
6.
7. static uint32_t jogball_y_gpios[] = {
8.
9. MAHIMAHI_GPIO_BALL_UP, MAHIMAHI_GPIO_BALL_DOWN,
10.
11. };
12.
13. static struct jog_axis_info jogball_x_axis = { // X轴的内容
14.
15. .info = {
16.
17. .info.func = gpio_event_axis_func, // 关键函数实现
18.
19. .count = ARRAY_SIZE(jogball_x_gpios),
20.
21. .dev = 1,
22.
23. .type = EV_REL,
24.
25. .code = REL_X,
26.
27. .decoded_size = 1U << ARRAY_SIZE(jogball_x_gpios),
28.
29. .map = jogball_axis_map,
30.
31. .gpio = jogball_x_gpios,
32.
33. .flags = GPIOEAF_PRINT_UNKNOWN_DIRECTION,
34.
35. }
36.
37. };
38.
39. static struct jog_axis_info jogball_y_axis = { // Y轴的内容
40.
41. .info = {
42.
43. .info.func = gpio_event_axis_func, // 关键函数实现
44.
45. .count = ARRAY_SIZE(jogball_y_gpios)
46.
47. .dev = 1,
48.
49. .type = EV_REL,
50.
51. .code = REL_Y,
52.
53. .decoded_size = 1U << ARRAY_SIZE(jogball_y_gpios),
54.
55. .map = jogball_axis_map,
56.
57. .gpio = jogball_y_gpios,
58.
59. .flags = GPIOEAF_PRINT_UNKNOWN_DIRECTION,
60.
61. }
62.
63. };
这里的轨迹球是用jog_axis_info类型的结构体进行定义的，这种设备的类型（type）是相对设备EV_REL。
8.4.2 用户空间的配置文件
除了默认的AVRCP.kl和qwerty.kl之外，MSM的mahimahi平台增加了h2w_headset.kl和mahimahi-keypad.kl。
8.5 OMAP中的实现
8.5.1 触摸屏和键盘的驱动程序
Omap的Zoom平台的输入设备包含了触摸屏和键盘（Qwerty全键盘）。
Omap的Zoom平台的触摸屏驱动程序在drivers/input/touchscreen目录中的synaptics_ i2c_rmi.c，这是一个i2c的触摸屏的驱动程序。
Omap的Zoom平台的键盘驱动程序在drivers/input/keyboard/目录的twl4030_keypad.c文件中实现。twl4030 使用的是i2c的接口。因此这个驱动程序本身是经过一次封装。
twl4030_keypad.c中核心的内容是中断处理的相关内容，do_kp_irq就是标准Linux的中断的处理函数，其内容如下所示：
1. static irqreturn_t do_kp_irq(int irq, void *_kp)
2.
3. {
4.
5. struct twl4030_keypad *kp = _kp;
6.
7. u8 reg;
8.
9. int ret;
10.
11. ret = twl4030_kpread(kp, ®, KEYP_ISR1, 1); // 调用twl4030_i2c_read
12.
13. if ((ret >= 0) && (reg & KEYP_IMR1_KP))
14.
15. twl4030_kp_scan(kp, 0); // 非释放所有的处理
16.
17. else
18.
19. twl4030_kp_scan(kp, 1); // 释放所有的处理
20.
21. return IRQ_HANDLED;
22.
23. }
twl4030_kp_scan()函数是核心的处理功能，它负责找到按键的行列，然后调用input_report_key()汇报信息，其主要的实现部分如下所示：
1. static void twl4030_kp_scan(struct twl4030_keypad *kp, int release_all)
2.
3. {
4.
5. u16 new_state[MAX_ROWS];
6.
7. int col, row;
8.
9. // ...... 省略部分内容
10.
11. for (row = 0; row < kp->n_rows; row++) {
12.
13. int changed = new_state[row] ^ kp->kp_state[row];
14.
15. // ...... 省略部分内容
16.
17. for (col = 0; col < kp->n_cols; col++) {
18.
19. int key;
20.
21. key = twl4030_find_key(kp, col, row);
22.
23. // ...... 省略部分内容
24.
25. input_report_key(kp->input, key, // 上报按键消息
26.
27. new_state[row] & (1 << col));
28.
29. }
30.
31. kp->kp_state[row] = new_state[row];
32.
33. }
34.
35. input_sync(kp->input);
36.
37. }
根据行列进行键盘信息的扫描，其中twl4030_find_key()是核心处理的功能，其实现如下所示：
1. static int twl4030_find_key(struct twl4030_keypad *kp, int col, int row)
2.
3. {
4.
5. int i, rc;
6.
7. rc = KEY(col, row, 0);
8.
9. for (i = 0; i < kp->keymapsize; i++)
10.
11. if ((kp->keymap[i] & ROWCOL_MASK) == rc)
12.
13. return kp->keymap[i] & (KEYNUM_MASK | KEY_PERSISTENT);
14.
15. return -EINVAL;
16.
17. }
以上实用的kp->keymap 数组是定义的按键映射关系，这个数组就是定义于arch/arm/mach-omap2/board-zoom2.c中的zoom2_twl4030_keymap数组，这个数组的内容如下所示：
1. static int zoom2_twl4030_keymap[] = {
2.
3. KEY(0, 0, KEY_E),
4.
5. KEY(1, 0, KEY_R),
6.
7. KEY(2, 0, KEY_T),
8.
9. KEY(3, 0, KEY_HOME),
10.
11. KEY(6, 0, KEY_I),
12.
13. KEY(7, 0, KEY_LEFTSHIFT),
14.
15. // ……省略部分内容
16.
17. KEY(7, 7, KEY_DOWN),
18.
19. KEY(0, 7, KEY_PROG1),
20.
21. KEY(1, 7, KEY_PROG2),
22.
23. KEY(2, 7, KEY_PROG3),
24.
25. KEY(3, 7, KEY_PROG4),
26.
27. 0
28.
29. };
twl4030_keypad.c文件中调用的twl4030_i2c_read和twl4030_i2c_write 是在drivers/ mfd/twl4030-core.c中实现的，实际上就是对i2c总线的操作的封装。
8.5.2 用户空间的配置文件
Omap的Zoom平台的键盘基本上是全键盘，但是其数字键和字母键是共用的。因此使用全键盘的配置文件基本上可以。
8.6 虚拟按键的实现
虚拟按键（Virtual Key）是Eclair版本开始增加的新特性。Virtual Key的功能是利用触摸屏，模拟按键发生的事件，这样就可以利用触摸屏的边缘，实现一些可以自定义的按键效果。
虚拟按键的实现效果如图8-5所示。
图8-5 虚拟按键的实现效果
在 Android系统中，触摸屏设备发送的是RawInputEvent（原始输入事件），而按键发送的是KeyEvent（按键事件）。KeyEvent 直接发送给应用程序层，RawInputEvent在Android的Java框架中被转换成MotionEvent发送给应用程序层。
在Android系统中虚拟按键的实现方法是：在某种情况下，将RawInputEvent转换成KeyEvent。
frameworks/base/services/Java/com/android/server目录中的InputDevice.Java文件负责处理虚拟按键的主要文件。
虚拟按键的处理相对简单，需要根据以下文件对虚拟按键的内容进行配置：
/sys/board_properties/virtualkeys.{devicename}
在InputDevice.Java文件中通过readVirtualKeys，对进行消息的转化。根据配置文件将RawInputEvent转换成按键相关的内容。
virtualkeys.{devicename}是虚拟按键的适配文件，需要在目标文件系统的/sys/board_ properties/目录中。
虚拟按键配置文件的格式如下所示：
0x1:扫描码:X:Y:W:H:0x1: ……
例如，在MSM的mahimahi平台上查看虚拟按键的配置文件如下所示：
# cat /sys/board_properties/virtualkeys.synaptics-rmi-touchscreen
0x01:158:55:835:90:55:0x01:139:172:835:125:55:0x01:102:298:835:115:55:0x01:217:412:835:95:55
由此可见，其中定义了4个区域的虚拟按键，它们的Y坐标相同，可见4个按键的矩形区域位于水平的一排。其转换的扫描码分别为158，139，102，217，分别对应于BACK（返回），MENU（菜单），HOME（主界面），SEARCH（搜索）这4个按键。
另外一个系统的虚拟按键的配置文件如下所示：
$ cat /sys/board_properties/virtualkeys.qtouch-touchscreen
0x01:139:90:936:116:104:0x01:102:252:936:116:104:0x01:158:402:936:116:104
其转换的扫描码分别为：139，102，158，分别对应于MENU（菜单），HOME（主界面），BACK（返回）这3个按键。
提示：使用虚拟按键转换成为的是按键的扫描码，不是按键码，因此依然需要经过按键布局文件的转化才能得到按键码。