//ViewRootImpl.java

public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {

synchronized (this) {

// do something

mInputChannel = new InputChannel();

// do something

res =mWindowSession.addToDisplay(mWindow, mSeq,

mWindowAttributes,

getHostVisibility(), mDisplay.getDisplayId(),

mAttachInfo.mContentInsets,mInputChannel);

//do something

}

}

// Session.java

@Override

public int addToDisplay(IWindow window, int seq,

WindowManager.LayoutParams attrs,

int viewVisibility, int displayId, Rect outContentInsets,

InputChannel outInputChannel) {

returnmService.addWindow(this, window, seq, attrs,

viewVisibility, displayId,

outContentInsets, outInputChannel);

}

// WindowManagerService.java

public int addWindow(Session session, IWindow client, int seq,

WindowManager.LayoutParams attrs, int viewVisibility,

int displayId,

Rect outContentInsets, InputChannel outInputChannel) {

//do something

String name = win.makeInputChannelName();

InputChannel[] inputChannels =

InputChannel.openInputChannelPair(name);

win.setInputChannel(inputChannels[0]);

inputChannels[1].transferTo(outInputChannel);

mInputManager.registerInputChannel(win.mInputChannel,

win.mInputWindowHandle);

//do something

}

// InputManager.cpp

mReaderThread->run("InputReader", PRIORITY_URGENT_DISPLAY);

// InputReader.cpp

bool InputReaderThread::threadLoop() {

mReader->loopOnce();

return true;

}

void InputReader::loopOnce() {

//do something

// 从 /dev/input下获得新的Input event

mEventHub->getEvents(timeoutMillis, mEventBuffer,

EVENT_BUFFER_SIZE);

//依各个的event type 进入各个的 event mapper

processEventsLocked(mEventBuffer, count);

//通知InputDispatcherThread去处理new input.

mQueuedListener->flush();

//do something

}

//InputReader.cpp

void InputReader::processEventsLocked(const RawEvent* rawEvents, size_t count) {

//do something

int32_t deviceId = rawEvent->deviceId;

//do something

processEventsForDeviceLocked(deviceId, rawEvent, batchSize);

//do something

}

void InputReader::processEventsForDeviceLocked(int32_t deviceId,

const RawEvent* rawEvents, size_t count) {

//do something

InputDevice* device = mDevices.valueAt(deviceIndex);

if (device->isIgnored()) {

//ALOGD("Discarding event for ignored deviceId %d.", deviceId);

return;

}

device->process(rawEvents, count);

}

void InputDevice::process(const RawEvent* rawEvents, size_t count) {

//do something

for (const RawEvent* rawEvent = rawEvents; count--; rawEvent++) {

//do something

for (size_t i = 0; i < numMappers; i++) {

InputMapper* mapper = mMappers[i];

mapper->process(rawEvent);

}

//do something

}

//do something

}

//InputReader.cpp

void TouchInputMapper::process(const RawEvent* rawEvent) {

// 处理以下的输入事件, 并将各个的Touch value作相对应处理

mCursorButtonAccumulator.process(rawEvent);

mCursorScrollAccumulator.process(rawEvent);

mTouchButtonAccumulator.process(rawEvent);

if (rawEvent->type == EV_SYN && rawEvent->code == SYN_REPORT) {

sync(rawEvent->when);

}

}

void TouchInputMapper::sync(nsecs_t when) {

//do something

dispatchTouches(when, policyFlags);

//do something

}

void TouchInputMapper::dispatchTouches(nsecs_t when, uint32_t policyFlags) {

//do something

// No pointer id changes so this is a move event.

// The listener takes care of batching moves so we don't have to deal with

// that here.

dispatchMotion(when, policyFlags, mSource,

AMOTION_EVENT_ACTION_MOVE, 0, metaState,

buttonState,

AMOTION_EVENT_EDGE_FLAG_NONE,

mCurrentCookedPointerData.pointerProperties,

mCurrentCookedPointerData.pointerCoords,

mCurrentCookedPointerData.idToIndex,

currentIdBits, -1,

mOrientedXPrecision, mOrientedYPrecision,

mDownTime);

//do something

}

void TouchInputMapper::dispatchMotion(nsecs_t when, uint32_t policyFlags,

uint32_t source,

int32_t action, int32_t flags, int32_t metaState, int32_t buttonState,

int32_t edgeFlags,

const PointerProperties* properties, const PointerCoords* coords,

const uint32_t* idToIndex, BitSet32 idBits,

int32_t changedId, float xPrecision, float yPrecision, nsecs_t downTime) {

//do something

NotifyMotionArgs args(when, getDeviceId(), source, policyFlags,

action, flags, metaState, buttonState, edgeFlags,

mViewport.displayId, pointerCount, pointerProperties,

pointerCoords,

xPrecision, yPrecision, downTime);

getListener()->notifyMotion(&args);

}

InputListenerInterface* InputReader::ContextImpl::getListener() {

return mReader->mQueuedListener.get();

}

// InputListener.h

Vector<NotifyArgs*> mArgsQueue;

// InputListener.cpp

void QueuedInputListener::notifyMotion(const NotifyMotionArgs* args) {

mArgsQueue.push(new NotifyMotionArgs(*args));

}

//InputReader.cpp

mQueuedListener->flush();

//InputListener.cpp

void QueuedInputListener::flush() {

size_t count = mArgsQueue.size();

for (size_t i = 0; i < count; i++) {

NotifyArgs* args = mArgsQueue[i];

args->notify(mInnerListener);

delete args;

}

mArgsQueue.clear();

}

//InputListener.cpp

void NotifyMotionArgs::notify(const sp<InputListenerInterface>& listener) const {

listener->notifyMotion(this);

}

// InputDispatcher.cpp

void InputDispatcher::notifyMotion(const NotifyMotionArgs* args) {

//do something

// Policy:

// - Ignore untrusted events and pass them along.

// - No special filtering for injected events required at this time.

// - Filter normal events based on screen state.

// - For normal events brighten (but do not wake) the screen if currently dim.

mPolicy->interceptMotionBeforeQueueing(args->eventTime, /*byref*/

policyFlags);

bool needWake;

{ // acquire lock

mLock.lock();

if (shouldSendMotionToInputFilterLocked(args)) {

mLock.unlock();

//initialize motion event for secondary display

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);

needWake = enqueueInboundEventLocked(newEntry);

mLock.unlock();

} // release lock

if (needWake) {

mLooper->wake();

}

}

bool InputDispatcher::enqueueInboundEventLocked(EventEntry* entry) {

//将新的input event放进InboundQueue

bool needWake = mInboundQueue.isEmpty();

mInboundQueue.enqueueAtTail(entry);

// do something

return needWake;

}

// InputDispatcher.cpp

bool InputDispatcherThread::threadLoop() {

mDispatcher->dispatchOnce();

return true;

}

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); // 用来管理message queue, 负责接收

// 或发送 message.

}

void InputDispatcher::dispatchOnceInnerLocked(nsecs_t* nextWakeupTime) {

//do something

// Ready to start a new event.

// If we don't already have a pending event, go grab one.

if (! mPendingEvent) {

if (mInboundQueue.isEmpty()) {

//do something

} else {

// Inbound queue has at least one entry.

mPendingEvent = mInboundQueue.dequeueAtHead();

}

//do something

// Get ready to dispatch the event.

resetANRTimeoutsLocked(); //因为已经取到input event, 所以 reset

//ANR timer.

}

//do something

switch (mPendingEvent->type) {

case EventEntry::TYPE_CONFIGURATION_CHANGED:

//do something

break;

case EventEntry::TYPE_DEVICE_RESET:

//do something

break;

case EventEntry::TYPE_KEY:

//do something

break;

case EventEntry::TYPE_MOTION:

MotionEntry* typedEntry = static_cast<MotionEntry*>(mPendingEvent);

//do something

done = dispatchMotionLocked(currentTime, typedEntry,

&dropReason, nextWakeupTime);

break;

default:

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::dispatchMotionLocked(

nsecs_t currentTime, MotionEntry* entry, DropReason* dropReason,

nsecs_t* nextWakeupTime) {

1. // Preprocessing.

2. // Clean up if dropping the event.

3. // support sending secondary display events to input monitors

// Dispatch the motion.

// do soemthing

dispatchEventLocked(currentTime, entry, inputTargets);

}

void InputDispatcher::dispatchEventLocked(nsecs_t currentTime,

EventEntry* eventEntry, const Vector<InputTarget>& inputTargets) {

//do something

for (size_t i = 0; i < inputTargets.size(); i++) {

const InputTarget& inputTarget = inputTargets.itemAt(i);

ssize_t connectionIndex =

getConnectionIndexLocked(inputTarget.inputChannel);

if (connectionIndex >= 0) {

sp<Connection> connection =

mConnectionsByFd.valueAt(connectionIndex);

prepareDispatchCycleLocked(currentTime, connection, eventEntry,

&inputTarget);

} else {

//do something

}

}

}

void InputDispatcher::prepareDispatchCycleLocked(nsecs_t currentTime,

const sp<Connection>& connection, EventEntry* eventEntry, const

InputTarget* inputTarget) {

1. // Skip this event if the connection status is not normal.

// We don't want to enqueue additional outbound events if the

// connection is broken.

// Split a motion event if needed.

if (inputTarget->flags & InputTarget::FLAG_SPLIT) {

ALOG_ASSERT(eventEntry->type == EventEntry::TYPE_MOTION);

//do something

enqueueDispatchEntriesLocked(currentTime, connection,

splitMotionEntry, inputTarget);

//do something

return;

}

}

// Not splitting. Enqueue dispatch entries for the event as is.

enqueueDispatchEntriesLocked(currentTime, connection, eventEntry,

inputTarget);

}

void InputDispatcher::enqueueDispatchEntriesLocked(nsecs_t currentTime,

const sp<Connection>& connection, EventEntry* eventEntry, const InputTarget* inputTarget) {

bool wasEmpty = connection->outboundQueue.isEmpty();

// Enqueue dispatch entries for the requested modes.

enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,

InputTarget::FLAG_DISPATCH_AS_HOVER_EXIT);

enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,

InputTarget::FLAG_DISPATCH_AS_OUTSIDE);

enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,

InputTarget::FLAG_DISPATCH_AS_HOVER_ENTER);

enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,

InputTarget::FLAG_DISPATCH_AS_IS);

enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,

InputTarget::FLAG_DISPATCH_AS_SLIPPERY_EXIT);

enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,

InputTarget::FLAG_DISPATCH_AS_SLIPPERY_ENTER);

// If the outbound queue was previously empty, start the dispatch cycle going.

if (wasEmpty && !connection->outboundQueue.isEmpty()) {

startDispatchCycleLocked(currentTime, connection);

}

}

void InputDispatcher::enqueueDispatchEntryLocked(

const sp<Connection>& connection, EventEntry* eventEntry, const

InputTarget* inputTarget,

int32_t dispatchMode) {

//do something

// This is a new event.

// Enqueue a new dispatch entry onto the outbound queue for this

// connection.

DispatchEntry* dispatchEntry = new DispatchEntry(eventEntry,

inputTargetFlags, inputTarget->xOffset, inputTarget->yOffset,

inputTarget->scaleFactor);

// Apply target flags and update the connection's input state.

// Remember that we are waiting for this dispatch to complete.

// Enqueue the dispatch entry.

connection->outboundQueue.enqueueAtTail(dispatchEntry);

}

void InputDispatcher::startDispatchCycleLocked(nsecs_t currentTime,

const sp<Connection>& connection) {

// do something

// 检查outboundQueue 中是否有新的 input event.

while (connection->status == Connection::STATUS_NORMAL

&& !connection->outboundQueue.isEmpty()) {

// 从 outboundQueue 中取出新的 input event.

DispatchEntry* dispatchEntry = connection->outboundQueue.head;

// Publish the event.

EventEntry* eventEntry = dispatchEntry->eventEntry;

switch (eventEntry->type) {

case EventEntry::TYPE_KEY:

//do something

break;

case EventEntry::TYPE_MOTION:

//do something

// Publish the motion event.

status =

connection->inputPublisher.publishMotionEvent(

// some argument.

);

break;

default:

return;

}

}

}

//InputTransport.cpp

status_t InputPublisher::publishMotionEvent(

uint32_t seq,

int32_t deviceId,

int32_t source,

int32_t action,

int32_t flags,

int32_t edgeFlags,

int32_t metaState,

int32_t buttonState,

float xOffset,

float yOffset,

float xPrecision,

float yPrecision,

nsecs_t downTime,

nsecs_t eventTime,

size_t pointerCount,

const PointerProperties* pointerProperties,

const PointerCoords* pointerCoords) {

InputMessage msg;

msg.header.type = InputMessage::TYPE_MOTION;

msg.body.motion.seq = seq;

msg.body.motion.deviceId = deviceId;

msg.body.motion.source = source;

msg.body.motion.action = action;

msg.body.motion.flags = flags;

msg.body.motion.edgeFlags = edgeFlags;

msg.body.motion.metaState = metaState;

msg.body.motion.buttonState = buttonState;

msg.body.motion.xOffset = xOffset;

msg.body.motion.yOffset = yOffset;

msg.body.motion.xPrecision = xPrecision;

msg.body.motion.yPrecision = yPrecision;

msg.body.motion.downTime = downTime;

msg.body.motion.eventTime = eventTime;

msg.body.motion.pointerCount = pointerCount;

for (size_t i = 0; i < pointerCount; i++) {

msg.body.motion.pointers[i].properties.copyFrom(pointerProperties[i]);

msg.body.motion.pointers[i].coords.copyFrom(pointerCoords[i]);

}

returnmChannel->sendMessage(&msg);

}

status_t InputChannel::sendMessage(const InputMessage* msg) {

size_t msgLength = msg->size();

ssize_t nWrite;

do {

nWrite = ::send(mFd, msg, msgLength, MSG_DONTWAIT |

MSG_NOSIGNAL);

} while (nWrite == -1 && errno == EINTR);

if (nWrite < 0) {

int error = errno;

if (error == EAGAIN || error == EWOULDBLOCK) {

return WOULD_BLOCK;

}

if (error == EPIPE || error == ENOTCONN) {

return DEAD_OBJECT;

}

return -error;

}

if (size_t(nWrite) != msgLength) {

return DEAD_OBJECT;

}

return OK;

}

// android_view_InputEventReceiver.cpp

int NativeInputEventReceiver::handleEvent(int receiveFd, int events, void* data) {

//do something

status_t status = consumeEvents(env, false /*consumeBatches*/, -1);

// do something

}

status_t NativeInputEventReceiver::consumeEvents(JNIEnv* env,

bool consumeBatches, nsecs_t frameTime) {

//do something

bool skipCallbacks = false; // 用来做为通知是否已完成dispach input event

// 的一个判断值.

for (;;) {

uint32_t seq;

InputEvent* inputEvent;

//果然在这里发现了呼叫 InputConsumer::consume 函数的地方

status_t status = mInputConsumer.consume(&mInputEventFactory,

consumeBatches, frameTime, &seq, &inputEvent);

//do something

if (!skipCallbacks) {

jobject inputEventObj;

switch (inputEvent->getType()) {

case AINPUT_EVENT_TYPE_KEY:

inputEventObj = android_view_KeyEvent_fromNative(env,

static_cast<KeyEvent*>(inputEvent));

break;

case AINPUT_EVENT_TYPE_MOTION:

inputEventObj =

android_view_MotionEvent_obtainAsCopy(env,

static_cast<MotionEvent*>(inputEvent));

break;

default:

assert(false); // InputConsumer should prevent this from ever

// happening

inputEventObj = NULL;

}

if (inputEventObj) {

env->CallVoidMethod(mReceiverObjGlobal,

gInputEventReceiverClassInfo.dispatchInputEvent,

seq, inputEventObj);

if (env->ExceptionCheck()) {

skipCallbacks = true;

}

} else {

skipCallbacks = true;

}

}

if (skipCallbacks) {

mInputConsumer.sendFinishedSignal(seq, false);

}

}

}

// android_view_InputEventReceiver.cpp

status_t NativeInputEventReceiver::consumeEvents(JNIEnv* env,

bool consumeBatches, nsecs_t frameTime) {

//do something

case AINPUT_EVENT_TYPE_MOTION:

inputEventObj =

android_view_MotionEvent_obtainAsCopy(env,

static_cast<MotionEvent*>(inputEvent));

break;

//do something

}

// android_view_MotionEvent.cpp

jobject android_view_MotionEvent_obtainAsCopy(JNIEnv* env, const

MotionEvent* event) {

//回呼MotionEvent Java Layer配置一块MotionEvent type的

//物件.

jobject eventObj =

env->CallStaticObjectMethod(gMotionEventClassInfo.clazz,

gMotionEventClassInfo.obtain);

// eventObj exception handler

//从MotionEvent的java layer读取MotionEvent对象指针值.

MotionEvent* destEvent =

android_view_MotionEvent_getNativePtr(env, eventObj);

if (!destEvent) {

destEvent = new MotionEvent();

android_view_MotionEvent_setNativePtr(env, eventObj,

destEvent);

}

destEvent->copyFrom(event, true);

return eventObj;

}

// android_view_InputEventReceiver.cpp

status_t NativeInputEventReceiver::consumeEvents(JNIEnv* env,

bool consumeBatches, nsecs_t frameTime) {

//do something

//do something

//将上面所得到的MotionEvent对象指针值,在传入Java Layer的

//函数里

env->CallVoidMethod(mReceiverObjGlobal,

gInputEventReceiverClassInfo.dispatchInputEvent,

seq, inputEventObj);

//do something

}

//InputEventReceiver.java

// Called from native code.

@SuppressWarnings("unused")

private void dispatchInputEvent(int seq, InputEvent event) {

mSeqMap.put(event.getSequenceNumber(), seq);

onInputEvent(event);

}

/**

* Called when an input event is received.

* The recipient should process the input event and then call {@link

#finishInputEvent}

* to indicate whether the event was handled. No new input events will be

received

* until {@link #finishInputEvent} is called.

*

* @param event The input event that was received.

*/

public void onInputEvent(InputEvent event) {

finishInputEvent(event, false);

}

// ViewRootImpl.java

//此类别是定义在ViewRootImpl类别中,最前面又是挂final,在java的语法//中代表此类别只能给ViewRootImpl类别中使用且无法被继承.

final class WindowInputEventReceiver extends InputEventReceiver {

//data member

@Override

public void onInputEvent(InputEvent event) {

enqueueInputEvent(event, this, 0, true);

}

// member function

}

void enqueueInputEvent(InputEvent event,

InputEventReceiver receiver, int flags, boolean processImmediately) {

QueuedInputEvent q = obtainQueuedInputEvent(event, receiver, flags);

// Always enqueue the input event in order, regardless of its time stamp.

// We do this because the application or the IME may inject key events

// in response to touch events and we want to ensure that the injected

// keys are processed in the order they were received and we cannot

// trust that the time stamp of injected events are monotonic.

QueuedInputEvent last = mFirstPendingInputEvent;

if (last == null) {

mFirstPendingInputEvent = q;

} else {

while (last.mNext != null) {

last = last.mNext;

}

last.mNext = q;

}

if (processImmediately) {

doProcessInputEvents(); //一般的input event都是即使的

} else {

scheduleProcessInputEvents();

}

}

void doProcessInputEvents() {

while (mCurrentInputEvent == null && mFirstPendingInputEvent != null)

{

QueuedInputEvent q = mFirstPendingInputEvent;

mFirstPendingInputEvent = q.mNext;

q.mNext = null;

mCurrentInputEvent = q;

deliverInputEvent(q);

}

// We are done processing all input events that we can process right now

// so we can clear the pending flag immediately.

}

private void deliverInputEvent(QueuedInputEvent q) {

// do something

if (q.mEvent instanceof KeyEvent) {

deliverKeyEvent(q);

} else {

final int source = q.mEvent.getSource();

if ((source & InputDevice.SOURCE_CLASS_POINTER) != 0)

{

deliverPointerEvent(q);

} else if ((source &

InputDevice.SOURCE_CLASS_TRACKBALL) != 0) {

deliverTrackballEvent(q);

} else {

deliverGenericMotionEvent(q);

}

}

// do something

}

private void deliverPointerEvent(QueuedInputEvent q) {

// If there is no view, then the event will not be handled.

if (mView == null || !mAdded) {

finishInputEvent(q, false);

return;

}

// Translate the pointer event for compatibility, if needed.

// Enter touch mode on down or scroll.

// Offset the scroll position.

// Remember the touch position for possible drag-initiation.

// Dispatch touch to view hierarchy.

boolean handled =mView.dispatchPointerEvent(event);

if (handled) {

finishInputEvent(q, true);

return;

}

// Pointer event was unhandled.

finishInputEvent(q, false);

}

//View .java

public boolean dispatchTouchEvent(MotionEvent event) {

if (mInputEventConsistencyVerifier != null) {

mInputEventConsistencyVerifier.onTouchEvent(event, 0);

}

if (onFilterTouchEventForSecurity(event)) {

//noinspection SimplifiableIfStatement

ListenerInfo li = mListenerInfo;

if (li != null && li.mOnTouchListener != null && (mViewFlags &

ENABLED_MASK) == ENABLED

&&li.mOnTouchListener.onTouch(this, event)) {

return true;

}

// 主要是用来实作触控的一般通用的功能, ex press, click, long

// press etc.

if (onTouchEvent(event)) {

return true;

}

}

if (mInputEventConsistencyVerifier != null) {

mInputEventConsistencyVerifier.onUnhandledEvent(event, 0);

}

return false;

}

// ViewRootImpl.java

private void finishInputEvent(QueuedInputEvent q, boolean handled) {

//do something

if (q.mReceiver != null) {

q.mReceiver.finishInputEvent(q.mEvent, handled);

} else {

q.mEvent.recycleIfNeededAfterDispatch();

}

//do something

}

// InputEventReceiver.cpp

public final void finishInputEvent(InputEvent event, boolean handled) {

//do something

nativeFinishInputEvent(mReceiverPtr, seq, handled);

//do something

}

// android_view_InputEventReceiver.cpp

static void nativeFinishInputEvent(JNIEnv* env, jclass clazz, jint receiverPtr,

jint seq, jboolean handled) {

sp<NativeInputEventReceiver> receiver =

reinterpret_cast<NativeInputEventReceiver*>(receiverPtr);

status_t status = receiver->finishInputEvent(seq, handled);

// exception handler

}

status_t NativeInputEventReceiver::finishInputEvent(uint32_t seq, bool handled) {

// do something

status_t status = mInputConsumer.sendFinishedSignal(seq, handled);

// exception handler

}

// InputTransport.cpp

status_t InputConsumer::sendFinishedSignal(uint32_t seq, bool handled) {

// do something

// Send finished signal for the last message in the batch.

returnsendUnchainedFinishedSignal(seq, handled);

}

status_t InputConsumer::sendUnchainedFinishedSignal(uint32_t seq, bool handled) {

InputMessage msg;

msg.header.type = InputMessage::TYPE_FINISHED;

msg.body.finished.seq = seq;

msg.body.finished.handled = handled;

returnmChannel->sendMessage(&msg);

}

// InputDispatcher.cpp

mLooper->addFd(fd, 0, ALOOPER_EVENT_INPUT,handleReceiveCallback, this);

int InputDispatcher::handleReceiveCallback(int fd, int events, void* data) {

// do something

for (;;) {

// do something

status = connection->inputPublisher.receiveFinishedSignal(&seq,

&handled);

// do something

d->finishDispatchCycleLocked(currentTime, connection, seq,

handled);

gotOne = true;

}

}

// InputTransport.cpp

status_t InputPublisher::receiveFinishedSignal(uint32_t* outSeq, bool* outHandled) {

//do something

status_t result = mChannel->receiveMessage(&msg);

//do something

*outSeq = msg.body.finished.seq;

*outHandled = msg.body.finished.handled;

return OK;

}

// InputDispatcher.cpp

void InputDispatcher::finishDispatchCycleLocked(nsecs_t currentTime,

const sp<Connection>& connection, uint32_t seq, bool handled) {

//do something

// Notify other system components and prepare to start the next dispatch cycle.

onDispatchCycleFinishedLocked(currentTime, connection, seq, handled);

}

void InputDispatcher::onDispatchCycleFinishedLocked(

nsecs_t currentTime, const sp<Connection>& connection, uint32_t seq,

bool handled) {

CommandEntry* commandEntry = postCommandLocked(

&InputDispatcher::doDispatchCycleFinishedLockedInterruptible);

commandEntry->connection = connection;

commandEntry->eventTime = currentTime;

commandEntry->seq = seq;

commandEntry->handled = handled;

}

void InputDispatcher::doDispatchCycleFinishedLockedInterruptible(

CommandEntry* commandEntry) {

//do something

// Start the next dispatch cycle for this connection.

startDispatchCycleLocked(now(), connection);

}

void InputDispatcher::startDispatchCycleLocked(nsecs_t currentTime,

const sp<Connection>& connection) {

//检查outboundQueue中是否还有新的input event.

while (connection->status == Connection::STATUS_NORMAL

&&!connection->outboundQueue.isEmpty()) {

DispatchEntry* dispatchEntry = connection->outboundQueue.head;

dispatchEntry->deliveryTime = currentTime;

// Publish the event.

status_t status;

EventEntry* eventEntry = dispatchEntry->eventEntry;

switch (eventEntry->type) {

case EventEntry::TYPE_KEY: {

KeyEntry* keyEntry = static_cast<KeyEntry*>(eventEntry);

// Publish the key event.

status =

connection->inputPublisher.publishKeyEvent(dispatchEntry->seq,

keyEntry->deviceId, keyEntry->source,

dispatchEntry->resolvedAction,

dispatchEntry->resolvedFlags,

keyEntry->keyCode, keyEntry->scanCode,

keyEntry->metaState, keyEntry->repeatCount,

keyEntry->downTime,

keyEntry->eventTime);

break;

}

case EventEntry::TYPE_MOTION:{

MotionEntry* motionEntry =

static_cast<MotionEntry*>(eventEntry);

PointerCoords scaledCoords[MAX_POINTERS];

const PointerCoords* usingCoords = motionEntry->pointerCoords;

// Set the X and Y offset depending on the input source.

float xOffset, yOffset, scaleFactor;

//do something

} else {

xOffset = 0.0f;

yOffset = 0.0f;

scaleFactor = 1.0f;

// We don't want the dispatch target to know.

if (dispatchEntry->targetFlags &

InputTarget::FLAG_ZERO_COORDS) {

for (size_t i = 0; i < motionEntry->pointerCount; i++) {

scaledCoords[i].clear();

}

usingCoords = scaledCoords;

}

}

// Publish the motion event.

//通知ViewRootImpl去共享内存抓取新的input event

status =

connection->inputPublisher.publishMotionEvent(dispatchEntry->seq,

motionEntry->deviceId, motionEntry->source,

dispatchEntry->resolvedAction,

dispatchEntry->resolvedFlags,

motionEntry->edgeFlags, motionEntry->metaState,

motionEntry->buttonState,

xOffset, yOffset,

motionEntry->xPrecision, motionEntry->yPrecision,

motionEntry->downTime, motionEntry->eventTime,

motionEntry->pointerCount,

motionEntry->pointerProperties,

usingCoords);

break;

}

default:

ALOG_ASSERT(false);

return;

}

// Check the result.

if (status) {

if (status == WOULD_BLOCK) {

if (connection->waitQueue.isEmpty()) {

abortBrokenDispatchCycleLocked(currentTime,

connection, true /*notify*/);

} else {

// Pipe is full and we are waiting for the app to finish

//process some events

// before sending more events to it.

connection->inputPublisherBlocked = true;

}

} else {

abortBrokenDispatchCycleLocked(currentTime, connection,

true /*notify*/);

}

return;

}

// Re-enqueue the event on the wait queue.

connection->outboundQueue.dequeue(dispatchEntry);

traceOutboundQueueLengthLocked(connection);

connection->waitQueue.enqueueAtTail(dispatchEntry);

traceWaitQueueLengthLocked(connection);

} //while loop end

}