Android应用程序键盘（Keyboard）消息处理机制分析（7）

         函数首先根据文件名来打开这个设备文件：

1. fd = open(deviceName, O_RDWR);  

        系统中所有输入设备文件信息都保存在成员变量mDevicesById中，因此，先在mDevicesById找到一个空位置来保存当前打开的设备文件信息：

1. mDevicesById[devid].seq = (mDevicesById[devid].seq+(1<<SEQ_SHIFT))&SEQ_MASK;  
2. if (mDevicesById[devid].seq == 0) {  
3.     mDevicesById[devid].seq = 1<<SEQ_SHIFT;  
4. }  

        找到了空闲位置后，就为这个输入设备文件创建相应的device_t信息：

1. mDevicesById[devid].seq = (mDevicesById[devid].seq+(1<<SEQ_SHIFT))&SEQ_MASK;  
2. if (mDevicesById[devid].seq == 0) {  
3.     mDevicesById[devid].seq = 1<<SEQ_SHIFT;  
4. }  
5.   
6. new_mFDs = (pollfd*)realloc(mFDs, sizeof(mFDs[0]) * (mFDCount + 1));  
7. new_devices = (device_t**)realloc(mDevices, sizeof(mDevices[0]) * (mFDCount + 1));  
8. if (new_mFDs == NULL || new_devices == NULL) {  
9.     LOGE("out of memory");  
10.     return -1;  
11. }  
12. mFDs = new_mFDs;  
13. mDevices = new_devices;  
14.   
15. ......  
16.   
17. device_t* device = new device_t(devid|mDevicesById[devid].seq, deviceName, name);  
18. if (device == NULL) {  
19.     LOGE("out of memory");  
20.     return -1;  
21. }  
22.   
23. device->fd = fd;  

 

        同时，这个设备文件还会保存在数组mFDs中：

1. mFDs[mFDCount].fd = fd;  
2. mFDs[mFDCount].events = POLLIN;  
3. mFDs[mFDCount].revents = 0;  

       接下来查看这个设备是不是键盘：

1. // Figure out the kinds of events the device reports.  
2.   
3. uint8_t key_bitmask[sizeof_bit_array(KEY_MAX + 1)];  
4. memset(key_bitmask, 0, sizeof(key_bitmask));  
5.   
6. LOGV("Getting keys...");  
7. if (ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(key_bitmask)), key_bitmask) >= 0) {  
8.     // See if this is a keyboard.  Ignore everything in the button range except for  
9.     // gamepads which are also considered keyboards.  
10.     if (containsNonZeroByte(key_bitmask, 0, sizeof_bit_array(BTN_MISC))  
11.         || containsNonZeroByte(key_bitmask, sizeof_bit_array(BTN_GAMEPAD),  
12.         sizeof_bit_array(BTN_DIGI))  
13.         || containsNonZeroByte(key_bitmask, sizeof_bit_array(KEY_OK),  
14.         sizeof_bit_array(KEY_MAX + 1))) {  
15.             device->classes |= INPUT_DEVICE_CLASS_KEYBOARD;  
16.   
17.             device->keyBitmask = new uint8_t[sizeof(key_bitmask)];  
18.             if (device->keyBitmask != NULL) {  
19.                 memcpy(device->keyBitmask, key_bitmask, sizeof(key_bitmask));  
20.             } else {  
21.                 delete device;  
22.                 LOGE("out of memory allocating key bitmask");  
23.                 return -1;  
24.             }  
25.     }  
26. }  

        如果是的话，还要继续进一步初始化前面为这个设备文件所创建的device_t结构体，主要就是把结构体device的classes成员变量的INPUT_DEVICE_CLASS_KEYBOARD位置为1了，以表明这是一个键盘。
        如果是键盘设备，初始化工作还未完成，还要继续设置键盘的布局等信息：

1. if ((device->classes & INPUT_DEVICE_CLASS_KEYBOARD) != 0) {  
2.     char tmpfn[sizeof(name)];  
3.     char keylayoutFilename[300];  
4.   
5.     // a more descriptive name  
6.     device->name = name;  
7.   
8.     // replace all the spaces with underscores  
9.     strcpy(tmpfn, name);  
10.     for (char *p = strchr(tmpfn, ' '); p && *p; p = strchr(tmpfn, ' '))  
11.         *p = '_';  
12.   
13.     // find the .kl file we need for this device  
14.     const char* root = getenv("ANDROID_ROOT");  
15.     snprintf(keylayoutFilename, sizeof(keylayoutFilename),  
16.         "%s/usr/keylayout/%s.kl", root, tmpfn);  
17.     bool defaultKeymap = false;  
18.     if (access(keylayoutFilename, R_OK)) {  
19.         snprintf(keylayoutFilename, sizeof(keylayoutFilename),  
20.             "%s/usr/keylayout/%s", root, "qwerty.kl");  
21.         defaultKeymap = true;  
22.     }  
23.     status_t status = device->layoutMap->load(keylayoutFilename);  
24.     if (status) {  
25.         LOGE("Error %d loading key layout.", status);  
26.     }  
27.   
28.     // tell the world about the devname (the descriptive name)  
29.     if (!mHaveFirstKeyboard && !defaultKeymap && strstr(name, "-keypad")) {  
30.         // the built-in keyboard has a well-known device ID of 0,  
31.         // this device better not go away.  
32.         mHaveFirstKeyboard = true;  
33.         mFirstKeyboardId = device->id;  
34.         property_set("hw.keyboards.0.devname", name);  
35.     } else {  
36.         // ensure mFirstKeyboardId is set to -something-.  
37.         if (mFirstKeyboardId == 0) {  
38.             mFirstKeyboardId = device->id;  
39.         }  
40.     }  
41.     char propName[100];  
42.     sprintf(propName, "hw.keyboards.%u.devname", device->id);  
43.     property_set(propName, name);  
44.   
45.     // 'Q' key support = cheap test of whether this is an alpha-capable kbd  
46.     if (hasKeycodeLocked(device, AKEYCODE_Q)) {  
47.         device->classes |= INPUT_DEVICE_CLASS_ALPHAKEY;  
48.     }  
49.   
50.     // See if this device has a DPAD.  
51.     if (hasKeycodeLocked(device, AKEYCODE_DPAD_UP) &&  
52.         hasKeycodeLocked(device, AKEYCODE_DPAD_DOWN) &&  
53.         hasKeycodeLocked(device, AKEYCODE_DPAD_LEFT) &&  
54.         hasKeycodeLocked(device, AKEYCODE_DPAD_RIGHT) &&  
55.         hasKeycodeLocked(device, AKEYCODE_DPAD_CENTER)) {  
56.             device->classes |= INPUT_DEVICE_CLASS_DPAD;  
57.     }  
58.   
59.     // See if this device has a gamepad.  
60.     for (size_t i = 0; i < sizeof(GAMEPAD_KEYCODES)/sizeof(GAMEPAD_KEYCODES[0]); i++) {  
61.         if (hasKeycodeLocked(device, GAMEPAD_KEYCODES[i])) {  
62.             device->classes |= INPUT_DEVICE_CLASS_GAMEPAD;  
63.             break;  
64.         }  
65.     }  
66.   
67.     LOGI("New keyboard: device->id=0x%x devname='%s' propName='%s' keylayout='%s'\n",  
68.         device->id, name, propName, keylayoutFilename);  
69. }  

        到这里，系统中的输入设备文件就打开了。