现在，InputReader线程已经开始运行,在InputReaderThread::threadLoop开始读取EventHub送上来的事件。mReader指向一个InputReader对象，调用InputReader::loopOnce函数。
/frameworks/native/services/inputflinger/InputReader.cpp
bool InputReaderThread::threadLoop() {
mReader->loopOnce();
return true;
}先忽略其他细节，InputReader是在getEvents中捞取事件的。mEventBuffer是一个RawEvent结构体数组，mEventHub指向一个EventHub对象。
/frameworks/native/services/inputflinger/InputReader.cpp
void InputReader::loopOnce() {
int32_t oldGeneration;
int32_t timeoutMillis;
bool inputDevicesChanged = false;
Vector<InputDeviceInfo> inputDevices;
{ // acquire lock
AutoMutex _l(mLock);
oldGeneration = mGeneration;
timeoutMillis = -1;
uint32_t changes = mConfigurationChangesToRefresh;
if (changes) {
mConfigurationChangesToRefresh = 0;
timeoutMillis = 0;
refreshConfigurationLocked(changes);
} else if (mNextTimeout != LLONG_MAX) {
nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
timeoutMillis = toMillisecondTimeoutDelay(now, mNextTimeout);
}
} // release lock
size_t count = mEventHub->getEvents(timeoutMillis, mEventBuffer, EVENT_BUFFER_SIZE);
{ // acquire lock
AutoMutex _l(mLock);
mReaderIsAliveCondition.broadcast();
if (count) {
processEventsLocked(mEventBuffer, count);
}
if (mNextTimeout != LLONG_MAX) {
nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
if (now >= mNextTimeout) {
#if DEBUG_RAW_EVENTS
ALOGD("Timeout expired, latency=%0.3fms", (now - mNextTimeout) * 0.000001f);
#endif
mNextTimeout = LLONG_MAX;
timeoutExpiredLocked(now);
}
}
if (oldGeneration != mGeneration) {
inputDevicesChanged = true;
getInputDevicesLocked(inputDevices);
}
} // release lock
// Send out a message that the describes the changed input devices.
if (inputDevicesChanged) {
mPolicy->notifyInputDevicesChanged(inputDevices);
}
// Flush queued events out to the listener.
// This must happen outside of the lock because the listener could potentially call
// back into the InputReader's methods, such as getScanCodeState, or become blocked
// on another thread similarly waiting to acquire the InputReader lock thereby
// resulting in a deadlock. This situation is actually quite plausible because the
// listener is actually the input dispatcher, which calls into the window manager,
// which occasionally calls into the input reader.
mQueuedListener->flush();
}EventHub在什么时候创建的呢？在NativeInputManager的构造函数中。看看EventHub的构造函数。首先创建了epoll文件描述符mEpollFd。 inotify是一个内核用于通知用户空间程序文件系统变化的机制。inotify_init用于创建一个inotify的fd,inotify_add_watch中DEVICE_PATH为“/dev/input”,inotify_add_watch作用是监控/dev/input目录下文件的变化。之后，将mEpollFd加入到epoll监控队列中，并将EPOLL_ID_INOTIFY保存到eventItem的union成员epoll_data中。然后，创建一个管道，将读端加入到epoll监控队列中，并将EPOLL_ID_WAKE保存到eventItem的union成员epoll_data中。
/frameworks/native/services/inputflinger/EventHub.cpp
EventHub::EventHub(void) :
mBuiltInKeyboardId(NO_BUILT_IN_KEYBOARD), mNextDeviceId(1), mControllerNumbers(),
mOpeningDevices(0), mClosingDevices(0),
mNeedToSendFinishedDeviceScan(false),
mNeedToReopenDevices(false), mNeedToScanDevices(true),
mPendingEventCount(0), mPendingEventIndex(0), mPendingINotify(false) {
acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_ID);
mEpollFd = epoll_create(EPOLL_SIZE_HINT);
LOG_ALWAYS_FATAL_IF(mEpollFd < 0, "Could not create epoll instance. errno=%d", errno);
mINotifyFd = inotify_init();
int result = inotify_add_watch(mINotifyFd, DEVICE_PATH, IN_DELETE | IN_CREATE);
LOG_ALWAYS_FATAL_IF(result < 0, "Could not register INotify for %s. errno=%d",
DEVICE_PATH, errno);
struct epoll_event eventItem;
memset(&eventItem, 0, sizeof(eventItem));
eventItem.events = EPOLLIN;
eventItem.data.u32 = EPOLL_ID_INOTIFY;
result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mINotifyFd, &eventItem);
LOG_ALWAYS_FATAL_IF(result != 0, "Could not add INotify to epoll instance. errno=%d", errno);
int wakeFds[2];
result = pipe(wakeFds);
LOG_ALWAYS_FATAL_IF(result != 0, "Could not create wake pipe. errno=%d", errno);
mWakeReadPipeFd = wakeFds[0];
mWakeWritePipeFd = wakeFds[1];
result = fcntl(mWakeReadPipeFd, F_SETFL, O_NONBLOCK);
LOG_ALWAYS_FATAL_IF(result != 0, "Could not make wake read pipe non-blocking. errno=%d",
errno);
result = fcntl(mWakeWritePipeFd, F_SETFL, O_NONBLOCK);
LOG_ALWAYS_FATAL_IF(result != 0, "Could not make wake write pipe non-blocking. errno=%d",
errno);
eventItem.data.u32 = EPOLL_ID_WAKE;
result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mWakeReadPipeFd, &eventItem);
LOG_ALWAYS_FATAL_IF(result != 0, "Could not add wake read pipe to epoll instance. errno=%d",
errno);
int major, minor;
getLinuxRelease(&major, &minor);
// EPOLLWAKEUP was introduced in kernel 3.5
mUsingEpollWakeup = major > 3 || (major == 3 && minor >= 5);
}回到EventHub::getEvents函数。readBuffer是内核input_event数组，event指向RawEvent数组下个可用的地址，capacity表示input_event数组的剩余容量，awoken表示是否通过写入管道唤醒阻塞的epoll_wait。随后进入一个死循环。
/frameworks/native/services/inputflinger/EventHub.cpp
size_t EventHub::getEvents(int timeoutMillis, RawEvent* buffer, size_t bufferSize) {
ALOG_ASSERT(bufferSize >= 1);
AutoMutex _l(mLock);
struct input_event readBuffer[bufferSize];
RawEvent* event = buffer;
size_t capacity = bufferSize;
bool awoken = false;
...这部分是重启设备处理流程。当Input的一些设置被改变时，mNeedToReopenDevices会变true,表示要重启设备。调用closeAllDevicesLocked关闭所有打开的设备，将mNeedToScanDevices设为true，表示下次进入getEvents函数时要扫描打开设备。之后，使用break退出主循环，等待loopOnce再一次调用getEvents函数进行扫描设备的操作。
/frameworks/native/services/inputflinger/EventHub.cpp
for (;;) {
nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
// Reopen input devices if needed.
if (mNeedToReopenDevices) {
mNeedToReopenDevices = false;
ALOGI("Reopening all input devices due to a configuration change.");
closeAllDevicesLocked();
mNeedToScanDevices = true;
break; // return to the caller before we actually rescan
}
...
mDevices类型为KeyedVector< int32_t, Device*>，第一个模板参数为Device的id。第二个模板参数是对应的Device结构体指针，KeyedVector内部使用SortedVector实现，里面元素按key值的大小排列。closeAllDevicesLocked就是逐一对mDevices里的Device执行closeDeviceLocked函数进行关闭。
/frameworks/native/services/inputflinger/EventHub.cpp
void EventHub::closeAllDevicesLocked() {
while (mDevices.size() > 0) {
closeDeviceLocked(mDevices.valueAt(mDevices.size() - 1));
}
} mBuiltInKeyboardId在EventHub构造函数中被初始化为NO_BUILT_IN_KEYBOARD（-2）。在打开设备时，若设备的类别为键盘，游戏手柄及虚拟键盘时，mBuiltInKeyboardId会被设为该设备的id。当要关闭的设备类型是上述类型时，将 mBuiltInKeyboardId重新置成NO_BUILT_IN_KEYBOARD。isVirtual函数判断Device的fd是否小于0，若大于或等于0，将这个fd从mEpollFd监控队列中移除。releaseControllerNumberLocked将Device的controllerNumber置0，并清除掉mControllerNumbers相应的标志位。然后将参数对应的Device从mDevices中移除，并将对应的fd关闭。
mOpeningDevices对应一个打开的Device组成的链表的头节点。从这个头节点开始遍历，找到要关闭的Device,将其从链表中删除。若找不到，将这个要关闭的Device插入到到mClosingDevices链表的头部，mClosingDevices仍指向这个链表的头部。mClosingDevices对应一个关闭的Device组成的链表的头节点。
/frameworks/native/services/inputflinger/EventHub.cpp
void EventHub::closeDeviceLocked(Device* device) {
ALOGI("Removed device: path=%s name=%s id=%d fd=%d classes=0x%x\n",
device->path.string(), device->identifier.name.string(), device->id,
device->fd, device->classes);
if (device->id == mBuiltInKeyboardId) {
ALOGW("built-in keyboard device %s (id=%d) is closing! the apps will not like this",
device->path.string(), mBuiltInKeyboardId);
mBuiltInKeyboardId = NO_BUILT_IN_KEYBOARD;
}
if (!device->isVirtual()) {
if (epoll_ctl(mEpollFd, EPOLL_CTL_DEL, device->fd, NULL)) {
ALOGW("Could not remove device fd from epoll instance. errno=%d", errno);
}
}
releaseControllerNumberLocked(device);
mDevices.removeItem(device->id);
device->close();
// Unlink for opening devices list if it is present.
Device* pred = NULL;
bool found = false;
for (Device* entry = mOpeningDevices; entry != NULL; ) {
if (entry == device) {
found = true;
break;
}
pred = entry;
entry = entry->next;
}
if (found) {
// Unlink the device from the opening devices list then delete it.
// We don't need to tell the client that the device was closed because
// it does not even know it was opened in the first place.
ALOGI("Device %s was immediately closed after opening.", device->path.string());
if (pred) {
pred->next = device->next;
} else {
mOpeningDevices = device->next;
}
delete device;
} else {
// Link into closing devices list.
// The device will be deleted later after we have informed the client.
device->next = mClosingDevices;
mClosingDevices = device;
}
}这里要提一下Device结构体。
/frameworks/native/services/inputflinger/EventHub.h
struct Device {
Device* next;//Device是以链表的形式组织的
int fd; // 文件描述符
const int32_t id;//唯一id
const String8 path;//设备路径
const InputDeviceIdentifier identifier;//厂商信息
uint32_t classes;//类别
//掩码数组
uint8_t keyBitmask[(KEY_MAX + 1) / 8];
uint8_t absBitmask[(ABS_MAX + 1) / 8];
uint8_t relBitmask[(REL_MAX + 1) / 8];
uint8_t swBitmask[(SW_MAX + 1) / 8];
uint8_t ledBitmask[(LED_MAX + 1) / 8];
uint8_t ffBitmask[(FF_MAX + 1) / 8];
uint8_t propBitmask[(INPUT_PROP_MAX + 1) / 8];
//配置信息
String8 configurationFile;
PropertyMap* configuration;
//键盘映射表
VirtualKeyMap* virtualKeyMap;
KeyMap keyMap;
sp<KeyCharacterMap> overlayKeyMap;
sp<KeyCharacterMap> combinedKeyMap;
//力反馈相关
bool ffEffectPlaying;
int16_t ffEffectId; // initially -1
int32_t controllerNumber;
int32_t timestampOverrideSec;
int32_t timestampOverrideUsec;
...
遍历mClosingDevices链表，每次得到一个Device，填充好一个RawEvent，标记为DEVICE_REMOVED类型，event指针加1表示使用掉了一个RawEvent,然后delete掉这个Device，将mNeedToSendFinishedDeviceScan标记为true,表示待会要发送扫描完成的事件。capacity减1，若等于0表示nput_event数组已无剩余空间，退出遍历。
/frameworks/native/services/inputflinger/EventHub.cpp
while (mClosingDevices) {
Device* device = mClosingDevices;
ALOGV("Reporting device closed: id=%d, name=%s\n",
device->id, device->path.string());
mClosingDevices = device->next;
event->when = now;
event->deviceId = device->id == mBuiltInKeyboardId ? BUILT_IN_KEYBOARD_ID : device->id;
event->type = DEVICE_REMOVED;
event += 1;
delete device;
mNeedToSendFinishedDeviceScan = true;
if (--capacity == 0) {
break;
}
}
InputReader第一次调用getEvents时，上面步骤都是不执行的。mNeedToScanDevices在构造函数中被初始化为true,所以会从这里开始。
关键代码是调用scanDevicesLocked。最后也将mNeedToSendFinishedDeviceScan 设为true,待会会发送设备扫描完成事件。
/frameworks/native/services/inputflinger/EventHub.cpp
if (mNeedToScanDevices) {
mNeedToScanDevices = false;
scanDevicesLocked();
mNeedToSendFinishedDeviceScan = true;
} scanDirLocked扫描/dev/input下的文件，并以这些文件的完整路径名为入参调用openDeviceLocked函数。
/frameworks/native/services/inputflinger/EventHub.cpp
void EventHub::scanDevicesLocked() {
status_t res = scanDirLocked(DEVICE_PATH);//DEVICE_PATH为"/dev/input"
if(res < 0) {
ALOGE("scan dir failed for %s\n", DEVICE_PATH);
}
if (mDevices.indexOfKey(VIRTUAL_KEYBOARD_ID) < 0) {
createVirtualKeyboardLocked();
}
}openDeviceLocked函数实现比较繁琐。选择重点的来讲。第一部分，使用从fd获得的信息填充identifier的成员，包括name,bus,product,vendor,version，location和uniqueId。assignDescriptorLocked用来设置identifier的descriptor和nonce成员。
/frameworks/native/services/inputflinger/EventHub.cpp
status_t EventHub::openDeviceLocked(const char *devicePath) {
char buffer[80];
ALOGV("Opening device: %s", devicePath);
int fd = open(devicePath, O_RDWR | O_CLOEXEC);
if(fd < 0) {
ALOGE("could not open %s, %s\n", devicePath, strerror(errno));
return -1;
}
InputDeviceIdentifier identifier;
// Get device name.
if(ioctl(fd, EVIOCGNAME(sizeof(buffer) - 1), &buffer) < 1) {
//fprintf(stderr, "could not get device name for %s, %s\n", devicePath, strerror(errno));
} else {
buffer[sizeof(buffer) - 1] = '\0';
identifier.name.setTo(buffer);
}
// Check to see if the device is on our excluded list
for (size_t i = 0; i < mExcludedDevices.size(); i++) {
const String8& item = mExcludedDevices.itemAt(i);
if (identifier.name == item) {
ALOGI("ignoring event id %s driver %s\n", devicePath, item.string());
close(fd);
return -1;
}
}
// Get device driver version.
int driverVersion;
if(ioctl(fd, EVIOCGVERSION, &driverVersion)) {
ALOGE("could not get driver version for %s, %s\n", devicePath, strerror(errno));
close(fd);
return -1;
}
// Get device identifier.
struct input_id inputId;
if(ioctl(fd, EVIOCGID, &inputId)) {
ALOGE("could not get device input id for %s, %s\n", devicePath, strerror(errno));
close(fd);
return -1;
}
identifier.bus = inputId.bustype;
identifier.product = inputId.product;
identifier.vendor = inputId.vendor;
identifier.version = inputId.version;
// Get device physical location.
if(ioctl(fd, EVIOCGPHYS(sizeof(buffer) - 1), &buffer) < 1) {
//fprintf(stderr, "could not get location for %s, %s\n", devicePath, strerror(errno));
} else {
buffer[sizeof(buffer) - 1] = '\0';
identifier.location.setTo(buffer);
}
// Get device unique id.
if(ioctl(fd, EVIOCGUNIQ(sizeof(buffer) - 1), &buffer) < 1) {
//fprintf(stderr, "could not get idstring for %s, %s\n", devicePath, strerror(errno));
} else {
buffer[sizeof(buffer) - 1] = '\0';
identifier.uniqueId.setTo(buffer);
}
// Fill in the descriptor.
assignDescriptorLocked(identifier);
// Make file descriptor non-blocking for use with poll().
if (fcntl(fd, F_SETFL, O_NONBLOCK)) {
ALOGE("Error %d making device file descriptor non-blocking.", errno);
close(fd);
return -1;
}
...
}
看看assignDescriptorLocked函数。uniqueId用来描述identifier的唯一性，当uniqueId为空时，就使用nonce来确保唯一性。descriptor是用identifier各个成员的值按一定格式组合起来再使用SHA1加密得到的值，generateDescriptor函数的作用就是产生这个SHA1值赋给descriptor。如果uniqueId为空，检查mDevices中各个Device对应的descriptor是否等于当前得到的descriptor，若相等，将nonce加1，重新使用generateDescriptor生成新的descriptor，直到这个新的descriptor是唯一的。
/frameworks/native/services/inputflinger/EventHub.cpp
void EventHub::assignDescriptorLocked(InputDeviceIdentifier& identifier) {
// Compute a device descriptor that uniquely identifies the device.
// The descriptor is assumed to be a stable identifier. Its value should not
// change between reboots, reconnections, firmware updates or new releases
// of Android. In practice we sometimes get devices that cannot be uniquely
// identified. In this case we enforce uniqueness between connected devices.
// Ideally, we also want the descriptor to be short and relatively opaque.
identifier.nonce = 0;
String8 rawDescriptor = generateDescriptor(identifier);
if (identifier.uniqueId.isEmpty()) {
// If it didn't have a unique id check for conflicts and enforce
// uniqueness if necessary.
while(getDeviceByDescriptorLocked(identifier.descriptor) != NULL) {
identifier.nonce++;
rawDescriptor = generateDescriptor(identifier);
}
}
ALOGV("Created descriptor: raw=%s, cooked=%s", rawDescriptor.string(),
identifier.descriptor.string());
}
/frameworks/native/services/inputflinger/EventHub.cpp
static String8 generateDescriptor(InputDeviceIdentifier& identifier) {
String8 rawDescriptor;
rawDescriptor.appendFormat(":%04x:%04x:", identifier.vendor,
identifier.product);
// TODO add handling for USB devices to not uniqueify kbs that show up twice
if (!identifier.uniqueId.isEmpty()) {
rawDescriptor.append("uniqueId:");
rawDescriptor.append(identifier.uniqueId);
} else if (identifier.nonce != 0) {
rawDescriptor.appendFormat("nonce:%04x", identifier.nonce);
}
if (identifier.vendor == 0 && identifier.product == 0) {
// If we don't know the vendor and product id, then the device is probably
// built-in so we need to rely on other information to uniquely identify
// the input device. Usually we try to avoid relying on the device name or
// location but for built-in input device, they are unlikely to ever change.
if (!identifier.name.isEmpty()) {
rawDescriptor.append("name:");
rawDescriptor.append(identifier.name);
} else if (!identifier.location.isEmpty()) {
rawDescriptor.append("location:");
rawDescriptor.append(identifier.location);
}
}
identifier.descriptor = sha1(rawDescriptor);
return rawDescriptor;
}
回到openDeviceLocked函数中。在EventHub构造函数中，mNextDeviceId初始化为1。这样，新创建的Device的id会从1起逐渐递增。之后是一大串的Log。
/frameworks/native/services/inputflinger/EventHub.cpp
int32_t deviceId = mNextDeviceId++;
Device* device = new Device(fd, deviceId, String8(devicePath), identifier);
ALOGV("add device %d: %s\n", deviceId, devicePath);
ALOGV(" bus: %04x\n"
" vendor %04x\n"
" product %04x\n"
" version %04x\n",
identifier.bus, identifier.vendor, identifier.product, identifier.version);
ALOGV(" name: \"%s\"\n", identifier.name.string());
ALOGV(" location: \"%s\"\n", identifier.location.string());
ALOGV(" unique id: \"%s\"\n", identifier.uniqueId.string());
ALOGV(" descriptor: \"%s\"\n", identifier.descriptor.string());
ALOGV(" driver: v%d.%d.%d\n",
driverVersion >> 16, (driverVersion >> 8) & 0xff, driverVersion & 0xff);
loadConfigurationLocked用于加载按键文件，详见我另一篇博客：《Android加载按键文件流程》。之后的流程统一按处理按键事件展开。
/frameworks/native/services/inputflinger/EventHub.cpp
...
// Load the configuration file for the device.
loadConfigurationLocked(device);
... EV_KEY表示按键类型的事件。能够上报这类事件的设备有键盘，鼠标，手柄，手写板等一切拥有按钮的设备（包括手机上的实体按键）。在Device结构体中，对应的事件位掩码keyBitmask描述了可以产生的事件的集合。按键事件的全集包括字符按键，方向键，控制键，鼠标键，游戏按键等。
/frameworks/native/services/inputflinger/EventHub.cpp
ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(device->keyBitmask)), device->keyBitmask);
...
// See if this is a keyboard. Ignore everything in the button range except for
// joystick and gamepad buttons which are handled like keyboards for the most part.
bool haveKeyboardKeys = containsNonZeroByte(device->keyBitmask, 0, sizeof_bit_array(BTN_MISC))
|| containsNonZeroByte(device->keyBitmask, sizeof_bit_array(KEY_OK),
sizeof_bit_array(KEY_MAX + 1));
bool haveGamepadButtons = containsNonZeroByte(device->keyBitmask, sizeof_bit_array(BTN_MISC),
sizeof_bit_array(BTN_MOUSE))
|| containsNonZeroByte(device->keyBitmask, sizeof_bit_array(BTN_JOYSTICK),
sizeof_bit_array(BTN_DIGI));
if (haveKeyboardKeys || haveGamepadButtons) {
device->classes |= INPUT_DEVICE_CLASS_KEYBOARD;
}
如果Device类型为keyboard或joystick,加载解析.kl和.kcm文件。类型为keyboard的情况还会把mBuiltInKeyboardId设置为该Device的id。根据传上来的按键集合，可以将keyboard类型分为几类：
INPUT_DEVICE_CLASS_ALPHAKEY表示字符按键设备，INPUT_DEVICE_CLASS_DPAD表示拥有方向键的设备，INPUT_DEVICE_CLASS_GAMEPAD表示游戏手柄设备。
/frameworks/native/services/inputflinger/EventHub.cpp
// Load the key map.
// We need to do this for joysticks too because the key layout may specify axes.
status_t keyMapStatus = NAME_NOT_FOUND;
if (device->classes & (INPUT_DEVICE_CLASS_KEYBOARD | INPUT_DEVICE_CLASS_JOYSTICK)) {
// Load the keymap for the device.
keyMapStatus = loadKeyMapLocked(device);
}
// Configure the keyboard, gamepad or virtual keyboard.
if (device->classes & INPUT_DEVICE_CLASS_KEYBOARD) {
// Register the keyboard as a built-in keyboard if it is eligible.
if (!keyMapStatus
&& mBuiltInKeyboardId == NO_BUILT_IN_KEYBOARD
&& isEligibleBuiltInKeyboard(device->identifier,
device->configuration, &device->keyMap)) {
mBuiltInKeyboardId = device->id;
}
// 'Q' key support = cheap test of whether this is an alpha-capable kbd
if (hasKeycodeLocked(device, AKEYCODE_Q)) {
device->classes |= INPUT_DEVICE_CLASS_ALPHAKEY;
}
// See if this device has a DPAD.
if (hasKeycodeLocked(device, AKEYCODE_DPAD_UP) &&
hasKeycodeLocked(device, AKEYCODE_DPAD_DOWN) &&
hasKeycodeLocked(device, AKEYCODE_DPAD_LEFT) &&
hasKeycodeLocked(device, AKEYCODE_DPAD_RIGHT) &&
hasKeycodeLocked(device, AKEYCODE_DPAD_CENTER)) {
device->classes |= INPUT_DEVICE_CLASS_DPAD;
}
// See if this device has a gamepad.
for (size_t i = 0; i < sizeof(GAMEPAD_KEYCODES)/sizeof(GAMEPAD_KEYCODES[0]); i++) {
if (hasKeycodeLocked(device, GAMEPAD_KEYCODES[i])) {
device->classes |= INPUT_DEVICE_CLASS_GAMEPAD;
break;
}将Device对应的fd添加到epoll监控队列中，监听事件为EPOLLIN。在3.5版本以上的Linux中，增设监听事件EPOLLWAKEUP。
/frameworks/native/services/inputflinger/EventHub.cpp
// Register with epoll.
struct epoll_event eventItem;
memset(&eventItem, 0, sizeof(eventItem));
eventItem.events = EPOLLIN;
if (mUsingEpollWakeup) {
eventItem.events |= EPOLLWAKEUP;
}
eventItem.data.u32 = deviceId;
if (epoll_ctl(mEpollFd, EPOLL_CTL_ADD, fd, &eventItem)) {
ALOGE("Could not add device fd to epoll instance. errno=%d", errno);
delete device;
return -1;
}
最后，往mDevices添加id-Device*键值对，往mOpeningDevices表示的链表头部插入该Device,mOpeningDevices继续指向该链表的头部。
/frameworks/native/services/inputflinger/EventHub.cpp
...
addDeviceLocked(device);
return 0;
}/frameworks/native/services/inputflinger/EventHub.cpp
void EventHub::addDeviceLocked(Device* device) {
mDevices.add(device->id, device);
device->next = mOpeningDevices;
mOpeningDevices = device;
} 值得注意的是，在scanDevicesLocked函数中，还将创建VirtualKeyboard，此处不再详述。至此，/dev/input/下的所有Device信息都已经被初始化，mOpeningDevices链表已经就绪。现在返回到getEvents函数中。
遍历mOpeningDevices链表，每个Device对应生成一个RawEvent。RawEvent的时间戳设为当前时间，deviceId设为mBuiltInKeyboardId或Device的id,事件类型记为DEVICE_ADDED。mNeedToSendFinishedDeviceScan设为true，表示要发送设备扫描完成事件，最后将capacity减1，因为产生了一个input_event事件，input_event数组剩余容量减1。
/frameworks/native/services/inputflinger/EventHub.cpp
...
while (mOpeningDevices != NULL) {
Device* device = mOpeningDevices;
ALOGV("Reporting device opened: id=%d, name=%s\n",
device->id, device->path.string());
mOpeningDevices = device->next;
event->when = now;
event->deviceId = device->id == mBuiltInKeyboardId ? 0 : device->id;
event->type = DEVICE_ADDED;
event += 1;
mNeedToSendFinishedDeviceScan = true;
if (--capacity == 0) {
break;
}
}每次重启，卸载，开启设备时，都要将mNeedToSendFinishedDeviceScan设为true，这会对应一个RawEvent和input_event.
/frameworks/native/services/inputflinger/EventHub.cpp
if (mNeedToSendFinishedDeviceScan) {
mNeedToSendFinishedDeviceScan = false;
event->when = now;
event->type = FINISHED_DEVICE_SCAN;
event += 1;
if (--capacity == 0) {
break;
}
} InputReader在线程循环中不断调用loopOnce,也就意味着getEvents函数会被循环调用。先看看第一次调用的情况。前面提到，第一次进入getEvents函数，入口点在scanDevicesLocked函数以用来扫描打开的设备。在EventsHub的构造函数中，
mPendingEventIndex和mPendingEventCount都被初始化为0，所以第一次进入getEvents函数时并不会进入以下循环：
/frameworks/native/services/inputflinger/EventHub.cpp
...
while (mPendingEventIndex < mPendingEventCount) {
...设备的添加导致产生RawEvent事件，使得event指针不等于RawEvents数组首地址。所以接下来会退出getEvents函数的主循环，直接返回产生的RawEvent数量。
/frameworks/native/services/inputflinger/EventHub.cpp
if (event != buffer || awoken) {
break;
}
...
return event - buffer;
第二次进入getEvents时，由于mNeedToScanDevices已被置为false，所以不会再去扫描设备。此时event的值与buffer相同，这次会进入到epoll_wait中。epoll监听了以下fd:Inotify的fd,第一次扫描的设备fd，唤醒管道读端的fd。epoll_wait在等待timeoutMillis的时间内，返回的pollResult为发生的目标事件数量，同时赋给mPendingEventCount，发生的事件保存在mPendingEventItems中。下一步，重新进入getEvent函数主循环。
/frameworks/native/services/inputflinger/EventHub.cpp
...
int pollResult = epoll_wait(mEpollFd, mPendingEventItems, EPOLL_MAX_EVENTS, timeoutMillis);
...
else {
// Some events occurred.
mPendingEventCount = size_t(pollResult);
}
... mPendingEventCount已经为正，终于可以进入while (mPendingEventIndex < mPendingEventCount)循环了。
遍历mPendingEventItems中的epoll_event,如果是Inotify的EPOLLIN事件，将mPendingINotify设为true。之后contine这个循环。
/frameworks/native/services/inputflinger/EventHub.cpp
while (mPendingEventIndex < mPendingEventCount) {
const struct epoll_event& eventItem = mPendingEventItems[mPendingEventIndex++];
if (eventItem.data.u32 == EPOLL_ID_INOTIFY) {
if (eventItem.events & EPOLLIN) {
mPendingINotify = true;
} else {
ALOGW("Received unexpected epoll event 0x%08x for INotify.", eventItem.events);
}
continue;
}
如果是管道读端的EPOLLIN事件，把awoken设置成true，读走管道读端的数据后，continue这个循环。
/frameworks/native/services/inputflinger/EventHub.cpp
if (eventItem.data.u32 == EPOLL_ID_WAKE) {
if (eventItem.events & EPOLLIN) {
ALOGV("awoken after wake()");
awoken = true;
char buffer[16];
ssize_t nRead;
do {
nRead = read(mWakeReadPipeFd, buffer, sizeof(buffer));
} while ((nRead == -1 && errno == EINTR) || nRead == sizeof(buffer));
} else {
ALOGW("Received unexpected epoll event 0x%08x for wake read pipe.",
eventItem.events);
}
continue;
}根据eventItem找到发生EPOLLIN事件的Device后，从该Device对应的fd读取数据到readBuffer中，readBuffer是一个input_event结构体数组。如果数取的数据为空或者出错返回ENODEV，说明对应的Device已经被移除，deviceChanged设为true,调用closeDeviceLocked处理该设备移除事件。如果正常返回，count得到在Device上发生的input_event数量。遍历readBuffer上的每个input_event，接下来用input_event的成员去初始化RawEvent，readBuffer剩余容量减1。若剩余容量为0，则退出当前循环。
/frameworks/native/services/inputflinger/EventHub.cpp
ssize_t deviceIndex = mDevices.indexOfKey(eventItem.data.u32);
...
Device* device = mDevices.valueAt(deviceIndex);
if (eventItem.events & EPOLLIN) {
int32_t readSize = read(device->fd, readBuffer,
sizeof(struct input_event) * capacity);
if (readSize == 0 || (readSize < 0 && errno == ENODEV)) {
// Device was removed before INotify noticed.
ALOGW("could not get event, removed? (fd: %d size: %" PRId32
" bufferSize: %zu capacity: %zu errno: %d)\n",
device->fd, readSize, bufferSize, capacity, errno);
deviceChanged = true;
closeDeviceLocked(device);
} else if (readSize < 0) {
if (errno != EAGAIN && errno != EINTR) {
ALOGW("could not get event (errno=%d)", errno);
}
} else if ((readSize % sizeof(struct input_event)) != 0) {
ALOGE("could not get event (wrong size: %d)", readSize);
} else {
int32_t deviceId = device->id == mBuiltInKeyboardId ? 0 : device->id;
size_t count = size_t(readSize) / sizeof(struct input_event);
for (size_t i = 0; i < count; i++) {
struct input_event& iev = readBuffer[i];
ALOGV("%s got: time=%d.%06d, type=%d, code=%d, value=%d",
device->path.string(),
(int) iev.time.tv_sec, (int) iev.time.tv_usec,
iev.type, iev.code, iev.value);
// Some input devices may have a better concept of the time
// when an input event was actually generated than the kernel
// which simply timestamps all events on entry to evdev.
// This is a custom Android extension of the input protocol
// mainly intended for use with uinput based device drivers.
if (iev.type == EV_MSC) {
if (iev.code == MSC_ANDROID_TIME_SEC) {
device->timestampOverrideSec = iev.value;
continue;
} else if (iev.code == MSC_ANDROID_TIME_USEC) {
device->timestampOverrideUsec = iev.value;
continue;
}
}
...
event->deviceId = deviceId;
event->type = iev.type;
event->code = iev.code;
event->value = iev.value;
event += 1;
capacity -= 1;
}
if (capacity == 0) {
// The result buffer is full. Reset the pending event index
// so we will try to read the device again on the next iteration.
mPendingEventIndex -= 1;
break;
}
}
} else if (eventItem.events & EPOLLHUP) {
ALOGI("Removing device %s due to epoll hang-up event.",
device->identifier.name.string());
deviceChanged = true;
closeDeviceLocked(device);
} else {
ALOGW("Received unexpected epoll event 0x%08x for device %s.",
eventItem.events, device->identifier.name.string());
}
}处理完mPendingEventItems的事件后，mPendingEventIndex的值与mPendingEventCount的值相等。如果之前处理的mPendingEventItem中的事件有发生在Inotify的（mPendingINotify为true），说明发生了设备增删事件,此时会调用readNotifyLocked处理设备增删事件，将deviceChanged设为true,mPendingINotify 设为false。
/frameworks/native/services/inputflinger/EventHub.cpp
// readNotify() will modify the list of devices so this must be done after
// processing all other events to ensure that we read all remaining events
// before closing the devices.
if (mPendingINotify && mPendingEventIndex >= mPendingEventCount) {
mPendingINotify = false;
readNotifyLocked();
deviceChanged = true;
}
EventHub::readNotifyLocked函数就是遍历所有的Inotify事件，根据inotify_event的mask值判断设备是新增还是卸载进行处理。如果是设备新增事件，调用openDeviceLocked进行处理。如果是设备卸载事件，调用closeDeviceByPathLocked进行处理，closeDeviceByPathLocked内部调用了closeDeviceLocked。
/frameworks/native/services/inputflinger/EventHub.cpp
status_t EventHub::readNotifyLocked() {
int res;
char devname[PATH_MAX];
char *filename;
char event_buf[512];
int event_size;
int event_pos = 0;
struct inotify_event *event;
ALOGV("EventHub::readNotify nfd: %d\n", mINotifyFd);
res = read(mINotifyFd, event_buf, sizeof(event_buf));
if(res < (int)sizeof(*event)) {
if(errno == EINTR)
return 0;
ALOGW("could not get event, %s\n", strerror(errno));
return -1;
}
//printf("got %d bytes of event information\n", res);
strcpy(devname, DEVICE_PATH);
filename = devname + strlen(devname);
*filename++ = '/';
while(res >= (int)sizeof(*event)) {
event = (struct inotify_event *)(event_buf + event_pos);
//printf("%d: %08x \"%s\"\n", event->wd, event->mask, event->len ? event->name : "");
if(event->len) {
strcpy(filename, event->name);
if(event->mask & IN_CREATE) {
openDeviceLocked(devname);
} else {
ALOGI("Removing device '%s' due to inotify event\n", devname);
closeDeviceByPathLocked(devname);
}
}
event_size = sizeof(*event) + event->len;
res -= event_size;
event_pos += event_size;
}
return 0;
}
deviceChanged被设置为true的地方有三处：1.读取Device到readBuffer中的内容为空或者产生ENODEV的错误时；2.Device事件为EPOLLHUP（被挂起）时；3.发生Inotify事件，处理完mClosingDevices，mOpeningDevices，mDevices等数据结构的变化及Device的信息初始化操作后。
continue表示重新进入getEvents函数主循环，根据设备变化事件生成相应的RawEvent。
/frameworks/native/services/inputflinger/EventHub.cpp
...
if (deviceChanged) {
continue;
} 第二次进入getEvents函数，可能由于没有生成RawEvent，导致event的值和buffer的值相等,所以不会进入break阶段。生成RawEvent的地方有：1.进入getEvents函数时mNeedToReopenDevices为true，表示需要重启设备；2.第一次进入getEvents函数，需要扫描/dev/input/下面的设备；3.mNeedToSendFinishedDeviceScan为true,表示生成扫描完成事件，发生在重启设备，首次扫描设备，设备新增和卸载阶段。也就是说，第二次进入getEvents函数时，只要不发生上述事件，event的值和buffer的值就会相等。将mPendingEventIndex置0，是为了能使下次进入getEvents函数能进入while (mPendingEventIndex < mPendingEventCount)循环，之后流程会走到epoll_wait阶段。
epoll_wait监控了Inotify的fd,管道读端的fd和设备的fd。epoll_wait可能会发生阻塞，因为第四个参数值可能为-1，而设备那边真的风平浪静没有任何动作发生。这样，epoll_wait函数便不能返回。Android设置了EventHub::wake往管道写端写入一个‘w’以唤醒epoll_wait，使epoll_wait函数得以返回，以重新进入getEvents函数主循环，重新进入主循环后会在”if (event != buffer || awoken)”处返回。
发生break退出getEvents函数主循环的地方有以下几处：1.input_event结构体数组readBuffer被塞满；2.重启设备；3.生成了RawEvent事件；4.管道唤醒操作；5.epoll_wait返回值为0。
epoll_wait之所以设置在”if (event != buffer || awoken)”之后是因为生成了RawEvent就不用再监听了，直接返回。没有生成就继续监听，以期待进入主循环生成RawEvent。
getEvents函数最终返回生成的RawEvent数量。
/frameworks/native/services/inputflinger/EventHub.cpp
if (event != buffer || awoken) {
break;
}
...
mPendingEventIndex = 0;
mLock.unlock(); // release lock before poll, must be before release_wake_lock
release_wake_lock(WAKE_LOCK_ID);
int pollResult = epoll_wait(mEpollFd, mPendingEventItems, EPOLL_MAX_EVENTS, timeoutMillis);
acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_ID);
mLock.lock(); // reacquire lock after poll, must be after acquire_wake_lock
if (pollResult == 0) {
// Timed out.
mPendingEventCount = 0;
break;
}
if (pollResult < 0) {
// An error occurred.
mPendingEventCount = 0;
// Sleep after errors to avoid locking up the system.
// Hopefully the error is transient.
if (errno != EINTR) {
ALOGW("poll failed (errno=%d)\n", errno);
usleep(100000);
}
} else {
// Some events occurred.
mPendingEventCount = size_t(pollResult);
}
}
// All done, return the number of events we read.
return event - buffer;
}/frameworks/native/services/inputflinger/EventHub.cpp
void EventHub::wake() {
ALOGV("wake() called");
ssize_t nWrite;
do {
nWrite = write(mWakeWritePipeFd, "W", 1);
} while (nWrite == -1 && errno == EINTR);
if (nWrite != 1 && errno != EAGAIN) {
ALOGW("Could not write wake signal, errno=%d", errno);
}
}总结
首次进入getEvents函数的流程是扫描/dev/input下的设备，并添加到epoll监控队列中。第二次进入getEvents函数时，启用epoll_wait进行监听,之后进入主循环。首次循环中，根据epoll_wait返回的结果，在循环中生成对应的RawEvent，若有RawEvent，getEvents函数会返回等待第三次进入。若没有RawEvent，会进入二次循环，此时epoll_wait可能又带来了新的事件让程序去生成RawEvent。。。（这里忽略了一些个别情况）。
扫一扫
3028
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
