//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) {

                 return mService.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 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& 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(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& 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 =

                     mConnectionsByFd.valueAt(connectionIndex);

            prepareDispatchCycleLocked(currentTime, connection, eventEntry,

                                    &inputTarget);

        } else {

            //do something

        }

    }

}

void InputDispatcher::prepareDispatchCycleLocked(nsecs_t currentTime,

        const sp& 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, 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, 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) {

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

    }

    return mChannel->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(inputEvent));

                break;

            case AINPUT_EVENT_TYPE_MOTION:

                inputEventObj =

                      android_view_MotionEvent_obtainAsCopy(env,

                             static_cast(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(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 receiver =

            reinterpret_cast(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.

    return sendUnchainedFinishedSignal(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;

    return mChannel->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, 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, 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);

}