最近工作中遇到InputManagerService相关的问题，所以将InputReader和InputDispatcher看了一遍，水平有限，有的也没有理解。
这是input的中重要的两个类，这两个类由对应的两个线程来管理InputReaderThread和InputDispatcherThread，他们都是使用C++实现的。 首先简单介绍下InputManagerService的实现。
InputReaderThread InputDispatcherThread Binder(InputManagerService)… Proxy…
负责从/dev/input/下读取输入事件，之后将input_event进入队列，
通知inputDispatcherThread 处理 得到输入事件后，根据当前inputChannel情况，进行发送 负责对InputReader和InputDispatcher的管理， 提供接口供其他进程访问，如插入一个输入事件，注册一个inputChannel灯 外部调用，如果input作为一个模块的话，这个接口是真正对外开放的
1 俩线程的启动
JAVA: InputManagerService.nativeInt () ->C++:NativeInputManager()->C++:InputManager()->C++:InputManager->initialize():如下代码所示：
48：void InputManager::initialize() {
49： mReaderThread = new InputReaderThread(mReader);
50： mDispatcherThread = new InputDispatcherThread(mDispatcher);
51：}
注意在本文之后inputReaderThread简称R线程，inputDispatcherThread简称D线程。
2 InputReader的执行
重要的函数：InputReader->loopOnce();，R线程是不断地在这个函数里循环。下面就看这个函数做了什么，首先介绍几个不重要的成员变量：
mGeneration:这个变量是标识输入设备的变化的，也就是说当设备新建，添加，删除时就会执行loopOnce()中的这段代码：
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);
}
size_t count = mEventHub->getEvents(timeoutMillis, mEventBuffer, EVENT_BUFFER_SIZE);
当调用这个函数时，如果有事件发生，count>0, 事件存储在mEventBuffer中。
mEventBuffer：这是存储时间的缓冲。
下面就是重要级的函数，对事件的处理processEventsLocked(mEventBuffer, count);
processEventsLocked->processEventsForDeviceLocked->device->process(rawEvents, count)->mapper->process(rawEvent);
mDevices: 每个输入设备的对象，每个输入设备对应一个process去处理它自己的事件。
mMappers:每个输入设备可能对应不同输入类型，这就需要要mMappers去处理，在mMapers->process中通过notify机制去通知D线程处理输入。
3 InputDispatcher:
InputDispatcher->dispatchOnce()->dispatchOnceInnerLocked:
mPendingEvent:当前需要处理的的事件，如果没有就从mInboundQueue中取。
mInboundQueue:InputDispatcher的事件队列，R线程负责进队列，D进程出队列处理事件。
mTouchState: 表示当前时间处理的状态。
当mPendingEvent的事件需要派发时，如下代码所示：
switch (mPendingEvent->type) {
case EventEntry::TYPE_CONFIGURATION_CHANGED: {
ConfigurationChangedEntry* typedEntry =
static_cast<ConfigurationChangedEntry*>(mPendingEvent);
done = dispatchConfigurationChangedLocked(currentTime, typedEntry);
dropReason = DROP_REASON_NOT_DROPPED; // configuration changes are never dropped
break;
}
case EventEntry::TYPE_DEVICE_RESET: {
DeviceResetEntry* typedEntry =
static_cast<DeviceResetEntry*>(mPendingEvent);
done = dispatchDeviceResetLocked(currentTime, typedEntry);
dropReason = DROP_REASON_NOT_DROPPED; // device resets are never dropped
break;
}
case EventEntry::TYPE_KEY: {
KeyEntry* typedEntry = static_cast<KeyEntry*>(mPendingEvent);
if (isAppSwitchDue) {
if (isAppSwitchKeyEventLocked(typedEntry)) {
resetPendingAppSwitchLocked(true);
isAppSwitchDue = false;
} else if (dropReason == DROP_REASON_NOT_DROPPED) {
dropReason = DROP_REASON_APP_SWITCH;
}
}
if (dropReason == DROP_REASON_NOT_DROPPED
&& isStaleEventLocked(currentTime, typedEntry)) {
dropReason = DROP_REASON_STALE;
}
if (dropReason == DROP_REASON_NOT_DROPPED && mNextUnblockedEvent) {
dropReason = DROP_REASON_BLOCKED;
}
done = dispatchKeyLocked(currentTime, typedEntry, &dropReason, nextWakeupTime);
break;
}
case EventEntry::TYPE_MOTION: {
MotionEntry* typedEntry = static_cast<MotionEntry*>(mPendingEvent);
if (dropReason == DROP_REASON_NOT_DROPPED && isAppSwitchDue) {
dropReason = DROP_REASON_APP_SWITCH;
}
if (dropReason == DROP_REASON_NOT_DROPPED
&& isStaleEventLocked(currentTime, typedEntry)) {
dropReason = DROP_REASON_STALE;
}
if (dropReason == DROP_REASON_NOT_DROPPED && mNextUnblockedEvent) {
dropReason = DROP_REASON_BLOCKED;
}
done = dispatchMotionLocked(currentTime, typedEntry,
&dropReason, nextWakeupTime);
break;
}
default:
ALOG_ASSERT(false);
break;
}
if (done) {
if (dropReason != DROP_REASON_NOT_DROPPED) {
dropInboundEventLocked(mPendingEvent, dropReason);
}
releasePendingEventLocked();
*nextWakeupTime = LONG_LONG_MIN; // force next poll to wake up immediately
}
}
bool InputDispatcher::enqueueInboundEventLocked(EventEntry* entry) {
bool needWake = mInboundQueue.isEmpty();
mInboundQueue.enqueueAtTail(entry);
traceInboundQueueLengthLocked();
switch (entry->type) {
case EventEntry::TYPE_KEY: {
// Optimize app switch latency.
// If the application takes too long to catch up then we drop all events preceding
// the app switch key.
KeyEntry* keyEntry = static_cast<KeyEntry*>(entry);
if (isAppSwitchKeyEventLocked(keyEntry)) {
if (keyEntry->action == AKEY_EVENT_ACTION_DOWN) {
mAppSwitchSawKeyDown = true;
} else if (keyEntry->action == AKEY_EVENT_ACTION_UP) {
if (mAppSwitchSawKeyDown) {
#if DEBUG_APP_SWITCH
ALOGD(“App switch is pending!”);
#endif
mAppSwitchDueTime = keyEntry->eventTime + APP_SWITCH_TIMEOUT;
mAppSwitchSawKeyDown = false;
needWake = true;
}
}
}
break;
}
case EventEntry::TYPE_MOTION: {
// Optimize case where the current application is unresponsive and the user
// decides to touch a window in a different application.
// If the application takes too long to catch up then we drop all events preceding
// the touch into the other window.
MotionEntry* motionEntry = static_cast<MotionEntry*>(entry);
if (motionEntry->action == AMOTION_EVENT_ACTION_DOWN
&& (motionEntry->source & AINPUT_SOURCE_CLASS_POINTER)
&& mInputTargetWaitCause == INPUT_TARGET_WAIT_CAUSE_APPLICATION_NOT_READY
&& mInputTargetWaitApplicationHandle != NULL) {
int32_t x = int32_t(motionEntry->pointerCoords[0].
getAxisValue(AMOTION_EVENT_AXIS_X));
int32_t y = int32_t(motionEntry->pointerCoords[0].
getAxisValue(AMOTION_EVENT_AXIS_Y));
sp<InputWindowHandle> touchedWindowHandle = findTouchedWindowAtLocked(x, y);
if (touchedWindowHandle != NULL
&& touchedWindowHandle->inputApplicationHandle
!= mInputTargetWaitApplicationHandle) {
// User touched a different application than the one we are waiting on.
// Flag the event, and start pruning the input queue.
mNextUnblockedEvent = motionEntry;
needWake = true;
}
}
break;
}
这些是处理事件的核心，我们就拿TYPE_MOTION举例，
dispatchMotionLocked->
findTouchedWindowTargetsLocked //填充inputTargets，是否有touchedWindowTarget需要事件
addMonitoringTargetsLocked //加入monitoringTarget
dispatchEventLocked -> //对inputTarget中的每个window进行派发事件
prepareDispatchCycleLocked->
enqueueDispatchEntriesLocked->
connection->outboundQueue.enqueueAtTail(dispatchEntry);
dispatchMotionLocked还是蛮复杂的，很多地方我也没弄明白。看代码话说windowmanagerService通过setInputWindows去填充InputDispacther的mWindowHandles,这是和所有window交流的根源，之后InputDispatcher填充inputTarget, 创建mConntionFd, 与需要input的window进行连接。
