Step 21. EventHub.openDevice
这个函数定义在frameworks/base/libs/ui/EventHub.cpp文件中： 
 
    
     
         
  1. int EventHub::openDevice(const char *deviceName) {   
    2.  
         
  2.     int version;   
    3.  
         
  3.     int fd;   
    4.  
         
  4.     struct pollfd *new_mFDs;   
    5.  
         
  5.     device_t **new_devices;   
    6.  
         
  6.     char **new_device_names;   
    7.  
         
  7.     char name[80];   
    8.  
         
  8.     char location[80];   
    9.  
         
  9.     char idstr[80];   
    10.  
         
  10.     struct input_id id;   
    11.  
         
  11.    
    12.  
         
  12.     LOGV("Opening device: %s", deviceName);   
    13.  
         
  13.    
    14.  
         
  14.     AutoMutex _l(mLock);   
    15.  
         
  15.    
    16.  
         
  16.     fd = open(deviceName, O_RDWR);   
    17.  
         
  17.     if(fd < 0) {   
    18.  
         
  18.         LOGE("could not open %s, %s\n", deviceName, strerror(errno));   
    19.  
         
  19.         return -1;   
    20.  
         
  20.     }   
    21.  
         
  21.    
    22.  
         
  22.     ......   
    23.  
         
  23.    
    24.  
         
  24.     int devid = 0;   
    25.  
         
  25.     while (devid < mNumDevicesById) {   
    26.  
         
  26.         if (mDevicesById[devid].device == NULL) {   
    27.  
         
  27.             break;   
    28.  
         
  28.         }   
    29.  
         
  29.         devid++;   
    30.  
         
  30.     }   
    31.  
         
  31.        
    32.  
         
  32.     ......   
    33.  
         
  33.    
    34.  
         
  34.     mDevicesById[devid].seq = (mDevicesById[devid].seq+(1<<SEQ_SHIFT))&SEQ_MASK;   
    35.  
         
  35.     if (mDevicesById[devid].seq == 0) {   
    36.  
         
  36.         mDevicesById[devid].seq = 1<<SEQ_SHIFT;   
    37.  
         
  37.     }   
    38.  
         
  38.    
    39.  
         
  39.     new_mFDs = (pollfd*)realloc(mFDs, sizeof(mFDs[0]) * (mFDCount + 1));   
    40.  
         
  40.     new_devices = (device_t**)realloc(mDevices, sizeof(mDevices[0]) * (mFDCount + 1));   
    41.  
         
  41.     if (new_mFDs == NULL || new_devices == NULL) {   
    42.  
         
  42.         LOGE("out of memory");   
    43.  
         
  43.         return -1;   
    44.  
         
  44.     }   
    45.  
         
  45.     mFDs = new_mFDs;   
    46.  
         
  46.     mDevices = new_devices;   
    47.  
         
  47.    
    48.  
         
  48.     ......   
    49.  
         
  49.    
    50.  
         
  50.     device_t* device = new device_t(devid|mDevicesById[devid].seq, deviceName, name);   
    51.  
         
  51.     if (device == NULL) {   
    52.  
         
  52.         LOGE("out of memory");   
    53.  
         
  53.         return -1;   
    54.  
         
  54.     }   
    55.  
         
  55.    
    56.  
         
  56.     device->fd = fd;   
    57.  
         
  57.     mFDs[mFDCount].fd = fd;   
    58.  
         
  58.     mFDs[mFDCount].events = POLLIN;   
    59.  
         
  59.     mFDs[mFDCount].revents = 0;   
    60.  
         
  60.    
    61.  
         
  61.     // Figure out the kinds of events the device reports.   
    62.  
         
  62.    
    63.  
         
  63.     uint8_t key_bitmask[sizeof_bit_array(KEY_MAX + 1)];   
    64.  
         
  64.     memset(key_bitmask, 0, sizeof(key_bitmask));   
    65.  
         
  65.    
    66.  
         
  66.     LOGV("Getting keys...");   
    67.  
         
  67.     if (ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(key_bitmask)), key_bitmask) >= 0) {   
    68.  
         
  68.         // See if this is a keyboard.  Ignore everything in the button range except for   
    69.  
         
  69.         // gamepads which are also considered keyboards.   
    70.  
         
  70.         if (containsNonZeroByte(key_bitmask, 0, sizeof_bit_array(BTN_MISC))   
    71.  
         
  71.             || containsNonZeroByte(key_bitmask, sizeof_bit_array(BTN_GAMEPAD),   
    72.  
         
  72.             sizeof_bit_array(BTN_DIGI))   
    73.  
         
  73.             || containsNonZeroByte(key_bitmask, sizeof_bit_array(KEY_OK),   
    74.  
         
  74.             sizeof_bit_array(KEY_MAX + 1))) {   
    75.  
         
  75.                 device->classes |= INPUT_DEVICE_CLASS_KEYBOARD;   
    76.  
         
  76.    
    77.  
         
  77.                 device->keyBitmask = new uint8_t[sizeof(key_bitmask)];   
    78.  
         
  78.                 if (device->keyBitmask != NULL) {   
    79.  
         
  79.                     memcpy(device->keyBitmask, key_bitmask, sizeof(key_bitmask));   
    80.  
         
  80.                 } else {   
    81.  
         
  81.                     delete device;   
    82.  
         
  82.                     LOGE("out of memory allocating key bitmask");   
    83.  
         
  83.                     return -1;   
    84.  
         
  84.                 }   
    85.  
         
  85.         }   
    86.  
         
  86.     }   
    87.  
         
  87.    
    88.  
         
  88.     ......   
    89.  
         
  89.    
    90.  
         
  90.     if ((device->classes & INPUT_DEVICE_CLASS_KEYBOARD) != 0) {   
    91.  
         
  91.         char tmpfn[sizeof(name)];   
    92.  
         
  92.         char keylayoutFilename[300];   
    93.  
         
  93.    
    94.  
         
  94.         // a more descriptive name   
    95.  
         
  95.         device->name = name;   
    96.  
         
  96.    
    97.  
         
  97.         // replace all the spaces with underscores   
    98.  
         
  98.         strcpy(tmpfn, name);   
    99.  
         
  99.         for (char *p = strchr(tmpfn, ' '); p && *p; p = strchr(tmpfn, ' '))   
    100.  
         
  100.             *p = '_';   
    101.  
         
  101.    
    102.  
         
  102.         // find the .kl file we need for this device   
    103.  
         
  103.         const char* root = getenv("ANDROID_ROOT");   
    104.  
         
  104.         snprintf(keylayoutFilename, sizeof(keylayoutFilename),   
    105.  
         
  105.             "%s/usr/keylayout/%s.kl", root, tmpfn);   
    106.  
         
  106.         bool defaultKeymap = false;   
    107.  
         
  107.         if (access(keylayoutFilename, R_OK)) {   
    108.  
         
  108.             snprintf(keylayoutFilename, sizeof(keylayoutFilename),   
    109.  
         
  109.                 "%s/usr/keylayout/%s", root, "qwerty.kl");   
    110.  
         
  110.             defaultKeymap = true;   
    111.  
         
  111.         }   
    112.  
         
  112.         status_t status = device->layoutMap->load(keylayoutFilename);   
    113.  
         
  113.         if (status) {   
    114.  
         
  114.             LOGE("Error %d loading key layout.", status);   
    115.  
         
  115.         }   
    116.  
         
  116.    
    117.  
         
  117.         // tell the world about the devname (the descriptive name)   
    118.  
         
  118.         if (!mHaveFirstKeyboard && !defaultKeymap && strstr(name, "-keypad")) {   
    119.  
         
  119.             // the built-in keyboard has a well-known device ID of 0,   
    120.  
         
  120.             // this device better not go away.   
    121.  
         
  121.             mHaveFirstKeyboard = true;   
    122.  
         
  122.             mFirstKeyboardId = device->id;   
    123.  
         
  123.             property_set("hw.keyboards.0.devname", name);   
    124.  
         
  124.         } else {   
    125.  
         
  125.             // ensure mFirstKeyboardId is set to -something-.   
    126.  
         
  126.             if (mFirstKeyboardId == 0) {   
    127.  
         
  127.                 mFirstKeyboardId = device->id;   
    128.  
         
  128.             }   
    129.  
         
  129.         }   
    130.  
         
  130.         char propName[100];   
    131.  
         
  131.         sprintf(propName, "hw.keyboards.%u.devname", device->id);   
    132.  
         
  132.         property_set(propName, name);   
    133.  
         
  133.    
    134.  
         
  134.         // 'Q' key support = cheap test of whether this is an alpha-capable kbd   
    135.  
         
  135.         if (hasKeycodeLocked(device, AKEYCODE_Q)) {   
    136.  
         
  136.             device->classes |= INPUT_DEVICE_CLASS_ALPHAKEY;   
    137.  
         
  137.         }   
    138.  
         
  138.    
    139.  
         
  139.         // See if this device has a DPAD.   
    140.  
         
  140.         if (hasKeycodeLocked(device, AKEYCODE_DPAD_UP) &&   
    141.  
         
  141.             hasKeycodeLocked(device, AKEYCODE_DPAD_DOWN) &&   
    142.  
         
  142.             hasKeycodeLocked(device, AKEYCODE_DPAD_LEFT) &&   
    143.  
         
  143.             hasKeycodeLocked(device, AKEYCODE_DPAD_RIGHT) &&   
    144.  
         
  144.             hasKeycodeLocked(device, AKEYCODE_DPAD_CENTER)) {   
    145.  
         
  145.                 device->classes |= INPUT_DEVICE_CLASS_DPAD;   
    146.  
         
  146.         }   
    147.  
         
  147.    
    148.  
         
  148.         // See if this device has a gamepad.   
    149.  
         
  149.         for (size_t i = 0; i < sizeof(GAMEPAD_KEYCODES)/sizeof(GAMEPAD_KEYCODES[0]); i++) {   
    150.  
         
  150.             if (hasKeycodeLocked(device, GAMEPAD_KEYCODES[i])) {   
    151.  
         
  151.                 device->classes |= INPUT_DEVICE_CLASS_GAMEPAD;   
    152.  
         
  152.                 break;   
    153.  
         
  153.             }   
    154.  
         
  154.         }   
    155.  
         
  155.    
    156.  
         
  156.         LOGI("New keyboard: device->id=0x%x devname='%s' propName='%s' keylayout='%s'\n",   
    157.  
         
  157.             device->id, name, propName, keylayoutFilename);   
    158.  
         
  158.     }   
    159.  
         
  159.    
    160.  
         
  160.     ......   
    161.  
         
  161.    
    162.  
         
  162.     mDevicesById[devid].device = device;   
    163.  
         
  163.     device->next = mOpeningDevices;   
    164.  
         
  164.     mOpeningDevices = device;   
    165.  
         
  165.     mDevices[mFDCount] = device;   
    166.  
         
  166.    
    167.  
         
  167.     mFDCount++;   
    168.  
         
  168.     return 0;   
    169.  
         
  169. }   
    170.