Android4.4——InputManagerService之InputDispatcher线程
上篇博客《Android4.4——InputManagerService之InputReader线程》的最后已经进入到InputDispatcher线程中。现在接着InputReader开始着手分析InputDispatcher线程。
到这里，InputReader::loopOnce的一次循环结束，真正完成InputReader线程的工作，InputDispatcher线程的工作真正开始了。
在《 Android4.4——InputManagerService启动》一文中InputManager::start中run了InputDispatcher线程，那就来看看InputDispatcherThread::threadLoop的Loop循环开始的地方。
Step 1、InputDispatcherThread::threadLoop
代码位于frameworks\base\services\input\InputDispatcher.cpp文件中。
Step 2、InputDispatcher::dispatchOnce
代码位于frameworks\base\services\input\InputDispatcher.cpp文件中。
Step 3、InputDispatcher::dispatchOnceInnerLocked
(1) 配置发生变化；
(2) 设备重置复位事件；
(3) 按键事件；
(4) 触摸事件；
我在这依旧只重点分析触摸事件的处理过程。下面来看看dispatchMotionLocked函数。
Step 4、InputDispatcher::dispatchMotionLocked
该函数代码位于代码位于frameworks\base\services\input\InputDispatcher.cpp文件中。
InputDispatcher线程的threadLoop调用了InputDispatcher::dispatchOnce函数，由函数名亦可知道，InputDispatcher的loop循环只执行一次，并且由InputDispatcher::nofityMotion->InputDispatcher::enqueueInboundEventLocked的返回值决定是否执行一次loop循环。enqueueInboundEventLocked返回true，则循环；enqueueInboundEventLocked为false，则不执行loop循环。
我们由上一篇博客最后调用的InputDispatcher::notifyMotion函数开始分析。
Step 0、InputDispatcher::notifyMotion
该函数代码位于frameworks\base\services\input\InputDispatcher.cpp文件中。
void InputDispatcher::notifyMotion(const NotifyMotionArgs* args) {
……
if (!validateMotionEvent(args->action, args->pointerCount, args->pointerProperties)) {
return;
}
uint32_t policyFlags = args->policyFlags;
policyFlags |= POLICY_FLAG_TRUSTED;
mPolicy->interceptMotionBeforeQueueing(args->eventTime, /*byref*/ policyFlags); //mPolicy为NativeInputManager实例，在new NativeInputManager->new InputManager->new InputDispatcher时传入NativeInputManager实例
bool needWake;
{ // acquire lock
mLock.lock();
if (shouldSendMotionToInputFilterLocked(args)) {
mLock.unlock();
MotionEvent event;
event.initialize(args->deviceId, args->source, args->action, args->flags,
args->edgeFlags, args->metaState, args->buttonState, 0, 0,
args->xPrecision, args->yPrecision,
args->downTime, args->eventTime,
args->pointerCount, args->pointerProperties, args->pointerCoords);
policyFlags |= POLICY_FLAG_FILTERED;
if (!mPolicy->filterInputEvent(&event, policyFlags)) {//mPolicy为NativeInputManager实例，在new NativeInputManager->new InputManager->new InputDispatcher时传入NativeInputManager实例
return; // event was consumed by the filter
}
mLock.lock();
}
// Just enqueue a new motion event.
MotionEntry* newEntry = new MotionEntry(args->eventTime,
args->deviceId, args->source, policyFlags,
args->action, args->flags, args->metaState, args->buttonState,
args->edgeFlags, args->xPrecision, args->yPrecision, args->downTime,
args->displayId,
args->pointerCount, args->pointerProperties, args->pointerCoords);//根据传入的NotifyMotionArgs参数
needWake = enqueueInboundEventLocked(newEntry);
mLock.unlock();
} // release lock
if (needWake) {
mLooper->wake();
}
}
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(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(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 displayId = motionEntry->displayId;
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 touchedWindowHandle = findTouchedWindowAtLocked(displayId, x, y);//找到我们点击了哪个window，返回该window的handle。
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;//是否触发InputDispatcher的Loop循环标记
}
}
break;
}
}
return needWake;
}
到这里，InputReader::loopOnce的一次循环结束，真正完成InputReader线程的工作，InputDispatcher线程的工作真正开始了。
在《 Android4.4——InputManagerService启动》一文中InputManager::start中run了InputDispatcher线程，那就来看看InputDispatcherThread::threadLoop的Loop循环开始的地方。
Step 1、InputDispatcherThread::threadLoop
代码位于frameworks\base\services\input\InputDispatcher.cpp文件中。
bool InputDispatcherThread::threadLoop() {
mDispatcher->dispatchOnce();
return true;
}/* Enqueues and dispatches input events, endlessly. */
class InputDispatcherThread : public Thread {
……
sp mDispatcher;
};
Step 2、InputDispatcher::dispatchOnce
代码位于frameworks\base\services\input\InputDispatcher.cpp文件中。
void InputDispatcher::dispatchOnce() {
nsecs_t nextWakeupTime = LONG_LONG_MAX;
{ // acquire lock
AutoMutex _l(mLock);
mDispatcherIsAliveCondition.broadcast();
// Run a dispatch loop if there are no pending commands.
// The dispatch loop might enqueue commands to run afterwards.
if (!haveCommandsLocked()) {
dispatchOnceInnerLocked(&nextWakeupTime);
}
// Run all pending commands if there are any.
// If any commands were run then force the next poll to wake up immediately.
if (runCommandsLockedInterruptible()) {
nextWakeupTime = LONG_LONG_MIN;
}
} // release lock
// Wait for callback or timeout or wake. (make sure we round up, not down)
nsecs_t currentTime = now();
int timeoutMillis = toMillisecondTimeoutDelay(currentTime, nextWakeupTime);
mLooper->pollOnce(timeoutMillis);
}
Step 3、InputDispatcher::dispatchOnceInnerLocked
代码位于frameworks\base\services\input\InputDispatcher.cpp文件中。
void InputDispatcher::dispatchOnceInnerLocked(nsecs_t* nextWakeupTime) {
nsecs_t currentTime = now();
// Reset the key repeat timer whenever we disallow key events, even if the next event
// is not a key. This is to ensure that we abort a key repeat if the device is just coming
// out of sleep.
if (!mPolicy->isKeyRepeatEnabled()) {
resetKeyRepeatLocked();
}
// If dispatching is frozen, do not process timeouts or try to deliver any new events.
if (mDispatchFrozen) {
return;
}
// Optimize latency of app switches.
// Essentially we start a short timeout when an app switch key (HOME / ENDCALL) has
// been pressed. When it expires, we preempt dispatch and drop all other pending events.
bool isAppSwitchDue = mAppSwitchDueTime <= currentTime;
if (mAppSwitchDueTime < *nextWakeupTime) {
*nextWakeupTime = mAppSwitchDueTime;
}
// Ready to start a new event.
// If we don't already have a pending event, go grab one.
if (! mPendingEvent) {//InputDispatcher第一次从mInboundQueue队列中获取事件，准备进行事件分发时，mPendingEvent为null。在new InputDispatcher时，构造函数将mPendingEvent初始化为null
if (mInboundQueue.isEmpty()) {
if (isAppSwitchDue) {
// The inbound queue is empty so the app switch key we were waiting
// for will never arrive. Stop waiting for it.
resetPendingAppSwitchLocked(false);
isAppSwitchDue = false;
}
// Synthesize a key repeat if appropriate.
if (mKeyRepeatState.lastKeyEntry) {
if (currentTime >= mKeyRepeatState.nextRepeatTime) {
mPendingEvent = synthesizeKeyRepeatLocked(currentTime);
} else {
if (mKeyRepeatState.nextRepeatTime < *nextWakeupTime) {
*nextWakeupTime = mKeyRepeatState.nextRepeatTime;
}
}
}
// Nothing to do if there is no pending event.
if (!mPendingEvent) {
return;
}
} else {
// Inbound queue has at least one entry.
mPendingEvent = mInboundQueue.dequeueAtHead();
traceInboundQueueLengthLocked();
}
// Poke user activity for this event.
if (mPendingEvent->policyFlags & POLICY_FLAG_PASS_TO_USER) {
pokeUserActivityLocked(mPendingEvent);
}
// Get ready to dispatch the event.
resetANRTimeoutsLocked();
}
// Now we have an event to dispatch.
// All events are eventually dequeued and processed this way, even if we intend to drop them.
ALOG_ASSERT(mPendingEvent != NULL);
bool done = false;
DropReason dropReason = DROP_REASON_NOT_DROPPED;
if (!(mPendingEvent->policyFlags & POLICY_FLAG_PASS_TO_USER)) {
dropReason = DROP_REASON_POLICY;
} else if (!mDispatchEnabled) {
dropReason = DROP_REASON_DISABLED;
}
if (mNextUnblockedEvent == mPendingEvent) {//在《Android4.4——InputManagerService之InputDispatcher线程》一文Step 0的enqueueInboundEventLocked中，在将事件消息加入到mInboundQueue队列的同时也将当前事件保存在mNextUnblockedEvent中。正常情况下，这里mNextUnblockedEvent 与mPendingEvent应相等
mNextUnblockedEvent = NULL;//清空，表示事件消息传递过程中未阻塞，mNextUnblockedEvent保存下一个即将到来的Event事件
}
switch (mPendingEvent->type) {//根据事件类型，分类进行不同处理
case EventEntry::TYPE_CONFIGURATION_CHANGED: {//配置发生变化？
ConfigurationChangedEntry* typedEntry =
static_cast(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(mPendingEvent);
done = dispatchDeviceResetLocked(currentTime, typedEntry);
dropReason = DROP_REASON_NOT_DROPPED; // device resets are never dropped
break;
}
case EventEntry::TYPE_KEY: {//按键事件
KeyEntry* typedEntry = static_cast(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(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
}
}
(1) 配置发生变化；
(2) 设备重置复位事件；
(3) 按键事件；
(4) 触摸事件；
我在这依旧只重点分析触摸事件的处理过程。下面来看看dispatchMotionLocked函数。
Step 4、InputDispatcher::dispatchMotionLocked
该函数代码位于代码位于frameworks\base\services\input\InputDispatcher.cpp文件中。
bool InputDispatcher::dispatchMotionLocked(
nsecs_t currentTime, MotionEntry* entry, DropReason* dropReason, nsecs_t* nextWakeupTime) {
// Preprocessing.
if (! entry->dispatchInProgress) {
entry->dispatchInProgress = true;
logOutboundMotionDetailsLocked("dispatchMotion - ", entry);
}
// Clean up if dropping the event.
if (*dropReason != DROP_REASON_NOT_DROPPED) {
setInjectionResultLocked(entry, *dropReason == DROP_REASON_POLICY
? INPUT_EVENT_INJECTION_SUCCEEDED : INPUT_EVENT_INJECTION_FAILED);
return true;
}
bool isPointerEvent = entry->source & AINPUT_SOURCE_CLASS_POINTER;
// Identify targets.
Vector inputTargets;
bool conflictingPointerActions = false;
int32_t injectionResult;
if (isPointerEvent) {
// Pointer event. (eg. touchscreen)
injectionResult = findTouchedWindowTargetsLocked(currentTime,
entry, inputTargets, nextWakeupTime, &conflictingPointerActions);//找到与被触摸window相关且合适的InputTarget列表存储在inputTargets中。该函数又臭又长，具体的没看懂
} else {
// Non touch event. (eg. trackball)
injectionResult = findFocusedWindowTargetsLocked(currentTime,
entry, inputTargets, nextWakeupTime);
}
if (injectionResult == INPUT_EVENT_INJECTION_PENDING) {
return false;
}
setInjectionResultLocked(entry, injectionResult);
if (injectionResult != INPUT_EVENT_INJECTION_SUCCEEDED) {
return true;
}
// TODO: support sending secondary display events to input monitors
if (isMainDisplay(entry->displayId)) {
addMonitoringTargetsLocked(inputTargets);
}
// Dispatch the motion.
if (conflictingPointerActions) {
CancelationOptions options(CancelationOptions::CANCEL_POINTER_EVENTS,
"conflicting pointer actions");
synthesizeCancelationEventsForAllConnectionsLocked(options);
}
dispatchEventLocked(currentTime, entry, inputTargets);
return true;
}
InputDispatcher线程的threadLoop调用了InputDispatcher::dispatchOnce函数，由函数名亦可知道，InputDispatcher的loop循环只执行一次，并且由InputDispatcher::nofityMotion->InputDispatcher::enqueueInboundEventLocked的返回值决定是否执行一次loop循环。enqueueInboundEventLocked返回true，则循环；enqueueInboundEventLocked为false，则不执行loop循环。