input事件的处理

接InputReader::loopOnce()的
if (count) {
processEventsLocked(mEventBuffer, count);
}

input事件获取到就该处理了。

一 type >= EventHubInterface::FIRST_SYNTHETIC_EVENT的情况

DEVICE_ADDED和DEVICE_REMOVED已经说了，还有FINISHED_DEVICE_SCAN没说；它就是个尾巴，只有要add和remove就必须接上尾巴。这尾巴干什么的呢？

            case EventHubInterface::FINISHED_DEVICE_SCAN:                handleConfigurationChangedLocked(rawEvent->when);                break;

void InputReader::handleConfigurationChangedLocked(nsecs_t when) {    // Reset global meta state because it depends on the list of all configured devices.    updateGlobalMetaStateLocked();    // Enqueue configuration changed.    NotifyConfigurationChangedArgs args(when);    mQueuedListener->notifyConfigurationChanged(&args);}

void InputReader::updateGlobalMetaStateLocked() {    mGlobalMetaState = 0;    for (size_t i = 0; i < mDevices.size(); i++) {        InputDevice* device = mDevices.valueAt(i);        mGlobalMetaState |= device->getMetaState();    }}

int32_t InputDevice::getMetaState() {    int32_t result = 0;    size_t numMappers = mMappers.size();    for (size_t i = 0; i < numMappers; i++) {        InputMapper* mapper = mMappers[i];        result |= mapper->getMetaState();    }    return result;}

mMappers[]是什么？
这要从DEVICE_ADDED说起，

            case EventHubInterface::DEVICE_ADDED:                addDeviceLocked(rawEvent->when, rawEvent->deviceId);                break;

InputReader::addDeviceLocked()->createDeviceLocked()

InputDevice* InputReader::createDeviceLocked(int32_t deviceId,        const InputDeviceIdentifier& identifier, uint32_t classes) {    InputDevice* device = new InputDevice(&mContext, deviceId, bumpGenerationLocked(),            identifier, classes);    // External devices.    if (classes & INPUT_DEVICE_CLASS_EXTERNAL) {        device->setExternal(true);    }    // Switch-like devices.    if (classes & INPUT_DEVICE_CLASS_SWITCH) {        device->addMapper(new SwitchInputMapper(device));    }    // Vibrator-like devices.    if (classes & INPUT_DEVICE_CLASS_VIBRATOR) {        device->addMapper(new VibratorInputMapper(device));    }    // Keyboard-like devices.    uint32_t keyboardSource = 0;    int32_t keyboardType = AINPUT_KEYBOARD_TYPE_NON_ALPHABETIC;    if (classes & INPUT_DEVICE_CLASS_KEYBOARD) {        keyboardSource |= AINPUT_SOURCE_KEYBOARD;    }    if (classes & INPUT_DEVICE_CLASS_ALPHAKEY) {        keyboardType = AINPUT_KEYBOARD_TYPE_ALPHABETIC;    }    if (classes & INPUT_DEVICE_CLASS_DPAD) {        keyboardSource |= AINPUT_SOURCE_DPAD;    }    if (classes & INPUT_DEVICE_CLASS_GAMEPAD) {        keyboardSource |= AINPUT_SOURCE_GAMEPAD;    }    if (keyboardSource != 0) {        device->addMapper(new KeyboardInputMapper(device, keyboardSource, keyboardType));    }    // Cursor-like devices.    if (classes & INPUT_DEVICE_CLASS_CURSOR) {        device->addMapper(new CursorInputMapper(device));    }    // Touchscreens and touchpad devices.    if (classes & INPUT_DEVICE_CLASS_TOUCH_MT) {        device->addMapper(new MultiTouchInputMapper(device));    } else if (classes & INPUT_DEVICE_CLASS_TOUCH) {        device->addMapper(new SingleTouchInputMapper(device));    }    // Joystick-like devices.    if (classes & INPUT_DEVICE_CLASS_JOYSTICK) {        device->addMapper(new JoystickInputMapper(device));    }    return device;}

很明显是根据input device->classes来添加映射的。mMappers是一个<InputMapper*>类型的Vector，如果是INPUT_DEVICE_CLASS_SWITCH开关就添加一个device->addMapper(new SwitchInputMapper(device));如果是触摸屏或者触摸板：

    // Touchscreens and touchpad devices.    if (classes & INPUT_DEVICE_CLASS_TOUCH_MT) {        device->addMapper(new MultiTouchInputMapper(device));    } else if (classes & INPUT_DEVICE_CLASS_TOUCH) {        device->addMapper(new SingleTouchInputMapper(device));　　}

每种InputMapper都有自己的init、reset、process函数。addDeviceLocked()之前我们用的device都是通用Device对象，通过createDeviceLocked()实现了Device到InputDevice的转变。看最后有个mDevices.add(deviceId, device)。好熟悉啊，openDeviceLocked()->addDeviceLocked(device)里也有mDevices.add(device->id, device)，长得真像，这个是add通用Device，class EventHub的 mDevices是这个摸样的：
KeyedVector<int32_t, Device*> mDevices;
现在是在class InputReader家里了，mDevices变样了：
KeyedVector<int32_t, InputDevice*> mDevices;
Device对象是在 EventHub::openDeviceLocked()里new出，在EventHub::getEvents()、EventHub::openDeviceLocked()和EventHub::closeDeviceLocked() close device的时候delete。
InputDevice在InputReader::addDeviceLocked()里new出，在removeDeviceLocked()里delete。
回到InputDevice::getMetaState()，先假设classes & INPUT_DEVICE_CLASS_TOUCH_MT，其他情况那么多，不care它们。那么这个InputMapper就是MultiTouchInputMapper，它没有实现getMetaState()函数，那找它爸爸class TouchInputMapper，也没有，那只能找它爷爷了class InputMapper。

int32_t InputMapper::getMetaState() {    return 0;}

看来对于 INPUT_DEVICE_CLASS_TOUCH_MT，mGlobalMetaState一直为0。mMetaState是指什么状态？只有KeyboardInputMapper设置getMetaState()函数。

int32_t KeyboardInputMapper::getMetaState() {    return mMetaState;}

mMetaState是meta key的一些状态，如果此时是keyboard的话mGlobalMetaState就可能记录了一些按键的dow和up。
handleConfigurationChangedLocked()中还有一段：

    // Enqueue configuration changed.    NotifyConfigurationChangedArgs args(when);　　mQueuedListener->notifyConfigurationChanged(&args);mQueuedListener是一个class QueuedInputListener的强指针。void QueuedInputListener::notifyConfigurationChanged(        const NotifyConfigurationChangedArgs* args) {    mArgsQueue.push(new NotifyConfigurationChangedArgs(*args));}

mArgsQueue是class QueuedInputListener中的一个Vector。这样一push就把NotifyConfigurationChangedArgs类型的实例push到Vector mArgsQueue中。这种push就是在Vector 中创建一个NotifyConfigurationChangedArgs对象的副本；这样就实现了将NotifyConfigurationChangedArgs事件推送到InputReader的队列中等候处理。其实是push到InputDispatch中，为什么这样说呢？再看下：

InputManager::InputManager(        const sp<EventHubInterface>& eventHub,        const sp<InputReaderPolicyInterface>& readerPolicy,        const sp<InputDispatcherPolicyInterface>& dispatcherPolicy) {    mDispatcher = new InputDispatcher(dispatcherPolicy);    mReader = new InputReader(eventHub, readerPolicy, mDispatcher);    initialize();}

InputReader::InputReader(const sp<EventHubInterface>& eventHub,        const sp<InputReaderPolicyInterface>& policy,        const sp<InputListenerInterface>& listener) :        mContext(this), mEventHub(eventHub), mPolicy(policy),        mGlobalMetaState(0), mGeneration(1),        mDisableVirtualKeysTimeout(LLONG_MIN), mNextTimeout(LLONG_MAX),        mConfigurationChangesToRefresh(0) {    mQueuedListener = new QueuedInputListener(listener);    { // acquire lock        AutoMutex _l(mLock);        refreshConfigurationLocked(0);        updateGlobalMetaStateLocked();    } // release lock}

InputReader的mQueuedListener就是用mDispatcher构建的，这就是InputReader和InputDispatch通信的方式，现在又event了，就要通知InputDispatch。

二 type < EventHubInterface::FIRST_SYNTHETIC_EVENT的情况

先找出对同一个deviceId可处理数据的长度batchSize，然后调用：
processEventsForDeviceLocked(deviceId, rawEvent, batchSize)->(device->process(rawEvents, count))

void InputDevice::process(const RawEvent* rawEvents, size_t count) {    // Process all of the events in order for each mapper.    // We cannot simply ask each mapper to process them in bulk because mappers may    // have side-effects that must be interleaved.  For example, joystick movement events and    // gamepad button presses are handled by different mappers but they should be dispatched    // in the order received.    size_t numMappers = mMappers.size();    for (const RawEvent* rawEvent = rawEvents; count--; rawEvent++) {#if DEBUG_RAW_EVENTS        ALOGD("Input event: device=%d type=0x%04x code=0x%04x value=0x%08x when=%lld",                rawEvent->deviceId, rawEvent->type, rawEvent->code, rawEvent->value,                rawEvent->when);#endif        if (mDropUntilNextSync) {            if (rawEvent->type == EV_SYN && rawEvent->code == SYN_REPORT) {                mDropUntilNextSync = false;#if DEBUG_RAW_EVENTS                ALOGD("Recovered from input event buffer overrun.");#endif            } else {#if DEBUG_RAW_EVENTS                ALOGD("Dropped input event while waiting for next input sync.");#endif            }        } else if (rawEvent->type == EV_SYN && rawEvent->code == SYN_DROPPED) {            ALOGI("Detected input event buffer overrun for device %s.", getName().string());            mDropUntilNextSync = true;            reset(rawEvent->when);        } else {            for (size_t i = 0; i < numMappers; i++) {                InputMapper* mapper = mMappers[i];                mapper->process(rawEvent);            }        }    }}

for循环依次处理count个rawEvents。
(1) mDropUntilNextSync到下一次同步前的都扔掉，收到rawEvent->type == EV_SYN && rawEvent->code == SYN_DROPPED时，该标记会置位，貌似底层client的循环buffer出现问题的时候会发送这个code。如果收到此code，要一直等到下一次的rawEvent->type == EV_SYN && rawEvent->code == SYN_REPORT，才能解放出来呢。InputDevice构造时，该标记是false。
(2) 刚说的rawEvent->type == EV_SYN && rawEvent->code == SYN_DROPPED时，mDropUntilNextSync = true，同时执行reset(rawEvent->when)。
(3) 一般会一直走到最后一个else。

        } else {            for (size_t i = 0; i < numMappers; i++) {                InputMapper* mapper = mMappers[i];                mapper->process(rawEvent);            }        }

假设过我们的mapper多点上报的触摸屏，所以mapper是MultiTouchInputMapper。

三 configure()函数

说process流程之前，先看看configure()函数，如何获取事件编码code，如何判断type A，还是type B。
需要刷新配置时，执行

void InputReader::requestRefreshConfiguration(uint32_t changes) {    AutoMutex _l(mLock);    if (changes) {        bool needWake = !mConfigurationChangesToRefresh;        mConfigurationChangesToRefresh |= changes;        if (needWake) {            mEventHub->wake();        }    }}

InputReader::loopOnce()一开始

     if (changes) {            mConfigurationChangesToRefresh = 0;            timeoutMillis = 0;            refreshConfigurationLocked(changes);        } 

void InputReader::refreshConfigurationLocked(uint32_t changes) {    mPolicy->getReaderConfiguration(&mConfig);    mEventHub->setExcludedDevices(mConfig.excludedDeviceNames);    if (changes) {        ALOGI("Reconfiguring input devices.  changes=0x%08x", changes);        nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);        if (changes & InputReaderConfiguration::CHANGE_MUST_REOPEN) {            mEventHub->requestReopenDevices();        } else {            for (size_t i = 0; i < mDevices.size(); i++) {                InputDevice* device = mDevices.valueAt(i);                device->configure(now, &mConfig, changes);            }        }    }}

void InputDevice::configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes) {    mSources = 0;    if (!isIgnored()) {        if (!changes) { // first time only            mContext->getEventHub()->getConfiguration(mId, &mConfiguration);        }        if (!changes || (changes & InputReaderConfiguration::CHANGE_KEYBOARD_LAYOUTS)) {            if (!(mClasses & INPUT_DEVICE_CLASS_VIRTUAL)) {                sp<KeyCharacterMap> keyboardLayout =                        mContext->getPolicy()->getKeyboardLayoutOverlay(mIdentifier.descriptor);                if (mContext->getEventHub()->setKeyboardLayoutOverlay(mId, keyboardLayout)) {                    bumpGeneration();                }            }        }        if (!changes || (changes & InputReaderConfiguration::CHANGE_DEVICE_ALIAS)) {            if (!(mClasses & INPUT_DEVICE_CLASS_VIRTUAL)) {                String8 alias = mContext->getPolicy()->getDeviceAlias(mIdentifier);                if (mAlias != alias) {                    mAlias = alias;                    bumpGeneration();                }            }        }        size_t numMappers = mMappers.size();        for (size_t i = 0; i < numMappers; i++) {            InputMapper* mapper = mMappers[i];            mapper->configure(when, config, changes);            mSources |= mapper->getSources();        }    }}

MultiTouchInputMapper没有实现config()函数，继承了爸爸的。

void TouchInputMapper::configure(nsecs_t when,        const InputReaderConfiguration* config, uint32_t changes) {    InputMapper::configure(when, config, changes);    mConfig = *config;    if (!changes) { // first time only        // Configure basic parameters.        configureParameters();        // Configure common accumulators.        mCursorScrollAccumulator.configure(getDevice());        mTouchButtonAccumulator.configure(getDevice());        // Configure absolute axis information.        configureRawPointerAxes();        // Prepare input device calibration.        parseCalibration();        resolveCalibration();    }    if (!changes || (changes & InputReaderConfiguration::CHANGE_POINTER_SPEED)) {        // Update pointer speed.        mPointerVelocityControl.setParameters(mConfig.pointerVelocityControlParameters);        mWheelXVelocityControl.setParameters(mConfig.wheelVelocityControlParameters);        mWheelYVelocityControl.setParameters(mConfig.wheelVelocityControlParameters);    }    bool resetNeeded = false;    if (!changes || (changes & (InputReaderConfiguration::CHANGE_DISPLAY_INFO            | InputReaderConfiguration::CHANGE_POINTER_GESTURE_ENABLEMENT            | InputReaderConfiguration::CHANGE_SHOW_TOUCHES))) {        // Configure device sources, surface dimensions, orientation and        // scaling factors.        configureSurface(when, &resetNeeded);    }    if (changes && resetNeeded) {        // Send reset, unless this is the first time the device has been configured,        // in which case the reader will call reset itself after all mappers are ready.        getDevice()->notifyReset(when);    }}

configureParameters()获取不可变的配置参数。
mParameters.deviceType = Parameters::DEVICE_TYPE_TOUCH_SCREEN的条件为：
(1) if (getEventHub()->hasInputProperty(getDeviceId(), INPUT_PROP_DIRECT))，要set INPUT_PROP_DIRECT。
(2) if (getDevice()->getConfiguration().tryGetProperty(String8("touch.deviceType"),
deviceTypeString)) {
if (deviceTypeString == "touchScreen")
这是idc文件的配置。

void MultiTouchInputMapper::configureRawPointerAxes() {    TouchInputMapper::configureRawPointerAxes();    getAbsoluteAxisInfo(ABS_MT_POSITION_X, &mRawPointerAxes.x);    getAbsoluteAxisInfo(ABS_MT_POSITION_Y, &mRawPointerAxes.y);    getAbsoluteAxisInfo(ABS_MT_TOUCH_MAJOR, &mRawPointerAxes.touchMajor);    getAbsoluteAxisInfo(ABS_MT_TOUCH_MINOR, &mRawPointerAxes.touchMinor);    getAbsoluteAxisInfo(ABS_MT_WIDTH_MAJOR, &mRawPointerAxes.toolMajor);    getAbsoluteAxisInfo(ABS_MT_WIDTH_MINOR, &mRawPointerAxes.toolMinor);    getAbsoluteAxisInfo(ABS_MT_ORIENTATION, &mRawPointerAxes.orientation);    getAbsoluteAxisInfo(ABS_MT_PRESSURE, &mRawPointerAxes.pressure);    getAbsoluteAxisInfo(ABS_MT_DISTANCE, &mRawPointerAxes.distance);    getAbsoluteAxisInfo(ABS_MT_TRACKING_ID, &mRawPointerAxes.trackingId);    getAbsoluteAxisInfo(ABS_MT_SLOT, &mRawPointerAxes.slot);    if (mRawPointerAxes.trackingId.valid            && mRawPointerAxes.slot.valid            && mRawPointerAxes.slot.minValue == 0 && mRawPointerAxes.slot.maxValue > 0) {        size_t slotCount = mRawPointerAxes.slot.maxValue + 1;        if (slotCount > MAX_SLOTS) {            ALOGW("MultiTouch Device %s reported %d slots but the framework "                    "only supports a maximum of %d slots at this time.",                    getDeviceName().string(), slotCount, MAX_SLOTS);            slotCount = MAX_SLOTS;        }        mMultiTouchMotionAccumulator.configure(getDevice(),                slotCount, true /*usingSlotsProtocol*/);    } else {        mMultiTouchMotionAccumulator.configure(getDevice(),                MAX_POINTERS, false /*usingSlotsProtocol*/);    }}

前面一堆，设置一下code事件编码是哪些。
(1) 如果上报ID和slot，就是B类协议上报(B类协议是一定要上报ID的，那些不上报ID，也用input_mt_slot()是怎么回事？这怎么可能？B类是一定report ID的，input_mt_slot()会设置ABS_MT_TRACKING_ID的code)，slotCount的值要限制在MAX_SLOTS(32)以内。接着调用：

void MultiTouchMotionAccumulator::configure(InputDevice* device,        size_t slotCount, bool usingSlotsProtocol) {    mSlotCount = slotCount;    mUsingSlotsProtocol = usingSlotsProtocol;    mHaveStylus = device->hasAbsoluteAxis(ABS_MT_TOOL_TYPE);    delete[] mSlots;    mSlots = new Slot[slotCount];}

mSlots是用来保存一个mt sync(SYN_MT_REPORT)或者mt slot(ABS_MT_SLOT)事件，对应一个点。mSlotCount说明一次最多能保存多少mt sync事件。对于type B mSlotCount最大值是32， mUsingSlotsProtocol = true。
(2) 对于type A，mSlotCount最大值是16，就是16个点，mUsingSlotsProtocol = false。
configureSurface(when, &resetNeeded)来确定device mode。
(1) 根据mParameters.deviceType确定mSource和mDeviceMode。

if (mParameters.deviceType == Parameters::DEVICE_TYPE_TOUCH_SCREEN            && mParameters.hasAssociatedDisplay) {        mSource = AINPUT_SOURCE_TOUCHSCREEN;        mDeviceMode = DEVICE_MODE_DIRECT;        if (hasStylus()) {            mSource |= AINPUT_SOURCE_STYLUS;        }}

(2) configureRawPointerAxes()中获取的mRawPointerAxes.x和mRawPointerAxes.y确定width and height。触摸屏需要显示，mParameters.hasAssociatedDisplay = true；而且不是外部设备。 mHWRotation表示旋转方向。如果touch分辨率的尺寸和显示的尺寸不一致，需要调整系数mXScale和mYScale。还有其他的参数调整，用到再说。

四 回来继续我们mapper的处理流程

void MultiTouchInputMapper::process(const RawEvent* rawEvent) {    TouchInputMapper::process(rawEvent);    mMultiTouchMotionAccumulator.process(rawEvent);}

void TouchInputMapper::process(const RawEvent* rawEvent) {    mCursorButtonAccumulator.process(rawEvent);    mCursorScrollAccumulator.process(rawEvent);    mTouchButtonAccumulator.process(rawEvent);    if (rawEvent->type == EV_SYN && rawEvent->code == SYN_REPORT) {        sync(rawEvent->when);    }}

光标按钮作为设备键盘的处理，比如鼠标光标的左右中键、前进后退等等。
滚动光标作为轨迹处理，比如鼠标的中轮事件，REL_WHEEL表示纵向scroll事件，REL_HWHEEL表示横向scroll事件。
触摸屏按键处理，BTN_TOUCH的值指示按下和抬起，其余的code都是tool说明。
最后收到rawEvent->type == EV_SYN && rawEvent->code == SYN_REPORT进入sync()。对于type A一个sync事件包括多个mt synct(一个点)，一个mt sync包括多个input event；对于type B一个sync事件包括多个mt slot(一个点)，一个mt slot包括多个input event。如果不是sync事件呢？就走mMultiTouchMotionAccumulator.process(rawEvent)。

void MultiTouchMotionAccumulator::process(const RawEvent* rawEvent) {    if (rawEvent->type == EV_ABS) {        bool newSlot = false;/*addDeviceLocked()中device->reset(when)->mapper->reset(when)->MultiTouchInputMapper::reset()->mMultiTouchMotionAccumulator.reset(getDevice())->clearSlots()，无论A类、B类mCurrentSlot都为-1。 MultiTouchInputMapper::syncTouch()的最后mMultiTouchMotionAccumulator.finishSync()只是type A的mCurrentSlot设为-1，B的呢？if (mUsingSlotsProtocol) mCurrentSlot = rawEvent->value;*/        if (mUsingSlotsProtocol) {            if (rawEvent->code == ABS_MT_SLOT) {                mCurrentSlot = rawEvent->value;//B类，是ID                newSlot = true;//貌似只为了打印一个warnning            }        } else if (mCurrentSlot < 0) {//A类            mCurrentSlot = 0;        }        if (mCurrentSlot < 0 || size_t(mCurrentSlot) >= mSlotCount) {#if DEBUG_POINTERS            if (newSlot) {                ALOGW("MultiTouch device emitted invalid slot index %d but it "                        "should be between 0 and %d; ignoring this slot.",                        mCurrentSlot, mSlotCount - 1);            }#endif        } else {            Slot* slot = &mSlots[mCurrentSlot];            switch (rawEvent->code) {            case ABS_MT_POSITION_X:                slot->mInUse = true;//mInUse标志其所在的slot是否使用                slot->mAbsMTPositionX = rawEvent->value;                break;            case ABS_MT_POSITION_Y:                slot->mInUse = true;                slot->mAbsMTPositionY = rawEvent->value;                break;            case ABS_MT_TOUCH_MAJOR:                slot->mInUse = true;                slot->mAbsMTTouchMajor = rawEvent->value;                break;            case ABS_MT_TOUCH_MINOR:                slot->mInUse = true;                slot->mAbsMTTouchMinor = rawEvent->value;                slot->mHaveAbsMTTouchMinor = true;                break;            case ABS_MT_WIDTH_MAJOR:                slot->mInUse = true;                slot->mAbsMTWidthMajor = rawEvent->value;                break;            case ABS_MT_WIDTH_MINOR:                slot->mInUse = true;                slot->mAbsMTWidthMinor = rawEvent->value;                slot->mHaveAbsMTWidthMinor = true;                break;            case ABS_MT_ORIENTATION:                slot->mInUse = true;                slot->mAbsMTOrientation = rawEvent->value;                break;            case ABS_MT_TRACKING_ID:                if (mUsingSlotsProtocol && rawEvent->value < 0) {                    // The slot is no longer in use but it retains its previous contents,                    // which may be reused for subsequent touches./*type B不会上报SYN_MT_REPORT，是以ID为负来判断抬起的，此时标记mInUse为 false，就是标记up了，有up说明之前是down的状态，如果不是down过的，那底层driver就出问题了，没有按下就抬起的事件能存在就有点奇迹了。我们虽然标记了up，但是并没有清除slot中的其他内容，这些内容可能会被重用，所以id为-1时，需要有sync事件发出来去处理这个up，不然以后再次按下的时候，这个up事件就消失了。这样一说按下的时候也要及时发sync处理，不然就被up覆盖了。所以底层每当有点按下或抬起都会上报sync事件*/                    slot->mInUse = false;                } else {                    slot->mInUse = true;                    slot->mAbsMTTrackingId = rawEvent->value;                }                break;            case ABS_MT_PRESSURE:                slot->mInUse = true;                slot->mAbsMTPressure = rawEvent->value;                break;            case ABS_MT_DISTANCE:                slot->mInUse = true;                slot->mAbsMTDistance = rawEvent->value;                break;            case ABS_MT_TOOL_TYPE:                slot->mInUse = true;                slot->mAbsMTToolType = rawEvent->value;                slot->mHaveAbsMTToolType = true;                break;            }        }    } else if (rawEvent->type == EV_SYN && rawEvent->code == SYN_MT_REPORT) {        // MultiTouch Sync: The driver has returned all data for *one* of the pointers.        mCurrentSlot += 1;/*对于type A只有收到mt sync的时候mCurrentSlot才加1，mt sync之前的code底层只会上报一次，上报多次就保留一次的，可见type A会把mt sync事件按照上报顺序存储在mSlots里。type B并不会上报SYN_MT_REPORT，mCurrentSlot = rawEvent->value，mCurrentSlot的取值就是上报ABS_MT_SLOT的ID，不一定顺序存储，是根据ID编号存储的，如果某个ID没有上报，对应的slot就空着。*/    }}

如果事件不出意外，总会收到sync事件的。总能回到：

如果事件不出意外，总会收到sync事件的。总能回到：    if (rawEvent->type == EV_SYN && rawEvent->code == SYN_REPORT) {        sync(rawEvent->when);　　}

它很长很长。

五 TouchInputMapper::sync()

1 mCurrentRawPointerData.clear()
hoveringIdBits 是hover事件的标识符清0，touchingIdBits是touch事件的标识符也清0，这两个事件是冲突的，有hover就没有touch。
2 syncTouch(when, &havePointerIds)，havePointerIds (指示是否上报ID)为 true。

void MultiTouchInputMapper::syncTouch(nsecs_t when, bool* outHavePointerIds) {    size_t inCount = mMultiTouchMotionAccumulator.getSlotCount();//type B=32，type A=16    size_t outCount = 0;    BitSet32 newPointerIdBits;    for (size_t inIndex = 0; inIndex < inCount; inIndex++) {        const MultiTouchMotionAccumulator::Slot* inSlot =//一个点                mMultiTouchMotionAccumulator.getSlot(inIndex);        if (!inSlot->isInUse()) {//对应点已up            continue;        }        if (outCount >= MAX_POINTERS) {//最大支持16点，但是type B的slot是32？#if DEBUG_POINTERS            ALOGD("MultiTouch device %s emitted more than maximum of %d pointers; "                    "ignoring the rest.",                    getDeviceName().string(), MAX_POINTERS);#endif            break; // too many fingers!        }        RawPointerData::Pointer& outPointer = mCurrentRawPointerData.pointers[outCount];        outPointer.x = inSlot->getX();//一个点的信息        outPointer.y = inSlot->getY();        outPointer.pressure = inSlot->getPressure();        outPointer.touchMajor = inSlot->getTouchMajor();        outPointer.touchMinor = inSlot->getTouchMinor();        outPointer.toolMajor = inSlot->getToolMajor();        outPointer.toolMinor = inSlot->getToolMinor();        outPointer.orientation = inSlot->getOrientation();        outPointer.distance = inSlot->getDistance();        outPointer.tiltX = 0;        outPointer.tiltY = 0;        outPointer.toolType = inSlot->getToolType();        if (outPointer.toolType == AMOTION_EVENT_TOOL_TYPE_UNKNOWN) {            outPointer.toolType = mTouchButtonAccumulator.getToolType();            if (outPointer.toolType == AMOTION_EVENT_TOOL_TYPE_UNKNOWN) {                outPointer.toolType = AMOTION_EVENT_TOOL_TYPE_FINGER;            }        }/*判断工具的，是手指或者笔。如果有上报ABS_MT_TOOL_TYPE，并且上报了合法的工具，那ok。否则mTouchButtonAccumulator.getToolType()来判断，判断不出来就是手指，默认的也是手指。*/        bool isHovering = mTouchButtonAccumulator.getToolType() != AMOTION_EVENT_TOOL_TYPE_MOUSE                && (mTouchButtonAccumulator.isHovering()                        || (mRawPointerAxes.pressure.valid && inSlot->getPressure() <= 0));/*神奇的hover事件来了。hover是光标模仿悬停事件，移动到一个对象上以及移除这个对象。产生hover的条件：(1) 非AMOTION_EVENT_TOOL_TYPE_MOUSE工具；(2) 设置上报BTN_TOUCH，但上报的值mBtnTouch是0；或者上报了pressure，其值<=0。*/        outPointer.isHovering = isHovering;        // Assign pointer id using tracking id if available.        if (*outHavePointerIds) {//如果id有效，第一次为true            int32_t trackingId = inSlot->getTrackingId();            int32_t id = -1;            if (trackingId >= 0) {//上报id，有点按下的情况                for (BitSet32 idBits(mPointerIdBits); !idBits.isEmpty(); ) {                    uint32_t n = idBits.clearFirstMarkedBit();/*从idBits(idBits = mPointerIdBits)中找出第一个被标记的bit，并清除该bit，返回该bit的索引。如果所有bit都没有被标记，结果是未定义的；所以idBits.isEmpty()时for退出。*/                    if (mPointerTrackingIdMap[n] == trackingId) {                        id = n;                    }/*mPointerIdBits表示点的标识符，如果mPointerTrackingIdMap[n]中有标记过trackingId的值，通过for循环能找到这个n，如果找不到id就为-1，就走下面的标记流程。*/                }                if (id < 0 && !mPointerIdBits.isFull()) {                    id = mPointerIdBits.markFirstUnmarkedBit();/*从mPointerIdBits中找出第一个未标记的bit，并标记该bit，返回该bit的索引。如果所有bit都被标记，结果是未定义的。mPointerIdBits.isFull()时，就没有地方标记了。*/                    mPointerTrackingIdMap[id] = trackingId;                }            }/*mPointerIdBits的bit为1标记的是有一个点按下；32bit系统，可以标记32点。mPointerTrackingIdMap[]与mPointerIdBits对应，设置mPointerIdBits的第id(从0开始)个bit的同时，要设置mPointerTrackingIdMap[id] = trackingId。mPointerTrackingIdMap[id]的值存储的是点的ID，通过id可以找到ID。*/            if (id < 0) {/*不上报ID(只有type A会不上报)会走到这里一次，或者上报ID -1时也到这里，都会有清除动作。只要是type A总会设置*outHavePointerIds = false的。(1) type A不上报ID的按下，在syncTouch()中hover、touch、pointer的标识符都是0，所以判断按下抬起的状态不在这个函数里。(2) type A不上报ID的抬起，如果上报mt synch和sync之外还报了别的input event，slot->mInUse = true，会记录最后一次outPointer，只是坐标为0。还可能遗留一个hover，因为outPointer.isHovering = isHovering，如果条件满足最后的isHovering被设置，以后可用。(3) type A上报id(抬起时为-1)的抬起，也会记录最后一次outPointer和保留isHovering状态。(4) 上报id，typeB的抬起会设置slot->mInUse = false，不会走到这里，就不会记录最后一次outPointer，也不会将之前记录的hover、touch、pointer的标识符都清0。*/                *outHavePointerIds = false;                mCurrentRawPointerData.clearIdBits();//清hover和touch表示符                newPointerIdBits.clear();//清点数表示符            } else {                outPointer.id = id;/*此id表示mPointerIdBits的第id个bit，通过mPointerTrackingIdMap[id]可以找到点上报来的ID*/                mCurrentRawPointerData.idToIndex[id] = outCount;//标记点来的顺序                mCurrentRawPointerData.markIdBit(id, isHovering);//设hover或touch标识                newPointerIdBits.markBit(id);//设置点的标识            }        }        outCount += 1;    }    mCurrentRawPointerData.pointerCount = outCount;//总点数    mPointerIdBits = newPointerIdBits;//设置点的标识符　　mMultiTouchMotionAccumulator.finishSync();　　/*type A清slot，B不需要清，MultiTouchMotionAccumulator::process()中会处理*/}

syncTouch()执行后点的信息就存到了mCurrentRawPointerData中。
3 type A不报ID时，设置havePointerIds为false，走上边的打印；type A无论报不报ID抬起时的sync都走上边。type B按下和抬起，type A报ID时的按下走下边。
4 TouchInputMapper构造时mDeviceMode(DEVICE_MODE_DISABLED)，configure()执行之后为mDeviceMode == DEVICE_MODE_DIRECT表示touch。
5 type A不报ID或者(无论报不报ID)up时才走assignPointerIds()。

void TouchInputMapper::assignPointerIds() {    uint32_t currentPointerCount = mCurrentRawPointerData.pointerCount;    uint32_t lastPointerCount = mLastRawPointerData.pointerCount;    mCurrentRawPointerData.clearIdBits();//清hover、touch标识bit，用自己的方法从新判断    if (currentPointerCount == 0) {//总点数为0        // No pointers to assign.        return;    }    if (lastPointerCount == 0) {//上一点数为0，所有点都是新点        // All pointers are new.        for (uint32_t i = 0; i < currentPointerCount; i++) {            uint32_t id = i;            mCurrentRawPointerData.pointers[i].id = id;/*type A是按点顺序存储的，type B的在上面，根据id能找到点的ID，这个不能*/            mCurrentRawPointerData.idToIndex[id] = i;            mCurrentRawPointerData.markIdBit(id, mCurrentRawPointerData.isHovering(i));/*标记一下touch或hover事件*/        }        return;    }    if (currentPointerCount == 1 && lastPointerCount == 1            && mCurrentRawPointerData.pointers[0].toolType                    == mLastRawPointerData.pointers[0].toolType) {        uint32_t id;        if (!mCurrentRawPointerData.isHovering(0) &&                !mLastRawPointerData.hoveringIdBits.isEmpty()) {            // 1 finger released and touching again. Should be safe to            // reset to id 0./*上一次产生了hover，那是一个上报了BTN或者pressure的up；现在没有hover了，说明有手指按下了，也是一个新点*/            id = 0;        } else {            // Only one pointer and no change in count so it must have the same id as before.//一直是一个点            id = mLastRawPointerData.pointers[0].id;        }        mCurrentRawPointerData.pointers[0].id = id;        mCurrentRawPointerData.idToIndex[id] = 0;        mCurrentRawPointerData.markIdBit(id, mCurrentRawPointerData.isHovering(0));        return;    }    // General case.    // We build a heap of squared euclidean distances between current and last pointers    // associated with the current and last pointer indices.  Then, we find the best    // match (by distance) for each current pointer.    // The pointers must have the same tool type but it is possible for them to    // transition from hovering to touching or vice-versa while retaining the same id.    PointerDistanceHeapElement heap[MAX_POINTERS * MAX_POINTERS];/*通常情况我们构造一个存储当前点和上一个点(与当前点和上一个点索引相关的)之间euclidean距离平方值的heap，我们就可以根据距离为当前点找到最好的匹配。这些点必须使用同一种tool type，保持同一个id时，该tool可能使这些点从hovering转到touching，反之亦然。*/    uint32_t heapSize = 0;    for (uint32_t currentPointerIndex = 0; currentPointerIndex < currentPointerCount;            currentPointerIndex++) {        for (uint32_t lastPointerIndex = 0; lastPointerIndex < lastPointerCount;                lastPointerIndex++) {            const RawPointerData::Pointer& currentPointer =                    mCurrentRawPointerData.pointers[currentPointerIndex];            const RawPointerData::Pointer& lastPointer =                    mLastRawPointerData.pointers[lastPointerIndex];            if (currentPointer.toolType == lastPointer.toolType) {                int64_t deltaX = currentPointer.x - lastPointer.x;                int64_t deltaY = currentPointer.y - lastPointer.y;                uint64_t distance = uint64_t(deltaX * deltaX + deltaY * deltaY);                // Insert new element into the heap (sift up).                heap[heapSize].currentPointerIndex = currentPointerIndex;                heap[heapSize].lastPointerIndex = lastPointerIndex;                heap[heapSize].distance = distance;                heapSize += 1;            }        }    }/*两次for循环结束后，heap中存储了每个当前点与上一次所有点的euclidean距离。*/    // Heapify    for (uint32_t startIndex = heapSize / 2; startIndex != 0; ) {        startIndex -= 1;               for (uint32_t parentIndex = startIndex; ;) {            uint32_t childIndex = parentIndex * 2 + 1;            if (childIndex >= heapSize) {                break;            }            if (childIndex + 1 < heapSize                    && heap[childIndex + 1].distance < heap[childIndex].distance) {                childIndex += 1;            }            if (heap[parentIndex].distance <= heap[childIndex].distance) {                break;            }            swap(heap[parentIndex], heap[childIndex]);            parentIndex = childIndex;        }    }/*这是个堆排序的过程，堆本身是一个二叉树，类似于　　              0　　            /    \               1     2              / \   / \             3  4   5  6            / \    / \　　       7  8code中需要的是最小堆的性质，如果不满足就调整。从最后一个可以作为根的结点开始。例如heapSize 为9，先把heap[3]结点为根的分支，调整为最小堆；然后调整heap[2]结点为根的分支；最后调整以heap[0]结点为根的分支，就是整个树，先将heap[0]与heap[1]、heap[2]中值小的比较，如果heap[0]最小，那相安无事；如果heap[0]不最小，那就调整为最小堆；假设heap[0]与heap[2]swap了，那需要重新调整heap[2]的分支了。最后形成的树是根结点值最小，左右结点不确定。*/#if DEBUG_POINTER_ASSIGNMENT    ALOGD("assignPointerIds - initial distance min-heap: size=%d", heapSize);    for (size_t i = 0; i < heapSize; i++) {        ALOGD("  heap[%d]: cur=%d, last=%d, distance=%lld",                i, heap[i].currentPointerIndex, heap[i].lastPointerIndex,                heap[i].distance);    }#endif    // Pull matches out by increasing order of distance.    // To avoid reassigning pointers that have already been matched, the loop keeps track    // of which last and current pointers have been matched using the matchedXXXBits variables.　　// It also tracks the used pointer id bits.　　/*按照距离增加的顺序取出匹配项。为了避免重新分配已经匹配的指针，循环保持跟踪表示上一个和当前点已经匹配的matchedXXXBits变量，还跟踪已经使用点id的对应bit位。　　*/    BitSet32 matchedLastBits(0);    BitSet32 matchedCurrentBits(0);    BitSet32 usedIdBits(0);    bool first = true;    for (uint32_t i = min(currentPointerCount, lastPointerCount); heapSize > 0 && i > 0; i--) {        while (heapSize > 0) {            if (first) {                // The first time through the loop, we just consume the root element of                // the heap (the one with smallest distance)./*通过第一次循环，我们要消耗掉heap的根结点，因为这颗树中唯一可以判断大小的就是它，它是距离最小的一个结点。*/                first = false;            } else {                // Previous iterations consumed the root element of the heap.                // Pop root element off of the heap (sift down)./*之前的迭代消耗了heap的根结点，弹出heap的根结点，进行sift down(向下筛选调整)，每次取堆顶端的数，然后重新构造堆，如此迭代，直到所有的数据都取出。*/                heap[0] = heap[heapSize];//填充被取走后的heap[0]//重新构造堆                for (uint32_t parentIndex = 0; ;) {                    uint32_t childIndex = parentIndex * 2 + 1;                    if (childIndex >= heapSize) {                        break;                    }                    if (childIndex + 1 < heapSize                            && heap[childIndex + 1].distance < heap[childIndex].distance) {                        childIndex += 1;                    }                    if (heap[parentIndex].distance <= heap[childIndex].distance) {                        break;                    }                    swap(heap[parentIndex], heap[childIndex]);                    parentIndex = childIndex;                }#if DEBUG_POINTER_ASSIGNMENT                ALOGD("assignPointerIds - reduced distance min-heap: size=%d", heapSize);                for (size_t i = 0; i < heapSize; i++) {                    ALOGD("  heap[%d]: cur=%d, last=%d, distance=%lld",                            i, heap[i].currentPointerIndex, heap[i].lastPointerIndex,                            heap[i].distance);                }#endif            }            heapSize -= 1;/*每次都取堆顶的最小值*/            uint32_t currentPointerIndex = heap[0].currentPointerIndex;            if (matchedCurrentBits.hasBit(currentPointerIndex)) continue; // already matched            uint32_t lastPointerIndex = heap[0].lastPointerIndex;            if (matchedLastBits.hasBit(lastPointerIndex)) continue; // already matched            matchedCurrentBits.markBit(currentPointerIndex);            matchedLastBits.markBit(lastPointerIndex);            uint32_t id = mLastRawPointerData.pointers[lastPointerIndex].id;            mCurrentRawPointerData.pointers[currentPointerIndex].id = id;/*last点和current点匹配上了，current点的ID就找到了*/            mCurrentRawPointerData.idToIndex[id] = currentPointerIndex;/*idToIndex[id]里的值就是标记点来的顺序*/            mCurrentRawPointerData.markIdBit(id,                    mCurrentRawPointerData.isHovering(currentPointerIndex));            usedIdBits.markBit(id);//标记已经使用点id的对应bit位#if DEBUG_POINTER_ASSIGNMENT            ALOGD("assignPointerIds - matched: cur=%d, last=%d, id=%d, distance=%lld",                    lastPointerIndex, currentPointerIndex, id, heap[0].distance);#endif            break;        }    }/*内存while就是控制sift down(向下筛选调整)，每次取堆顶端的数，然后重新构造堆；外层for就是控制迭代次数，直到所有的数据都取出。*/　　// Assign fresh ids to pointers that were not matched in the process.　　/*如果last点数多，那么至此所有点都匹配上了；但是如果last点少，current中还有未匹配的点呢，需要为这些新点分配一下ids　　*/    for (uint32_t i = currentPointerCount - matchedCurrentBits.count(); i != 0; i--) {        uint32_t currentPointerIndex = matchedCurrentBits.markFirstUnmarkedBit();        uint32_t id = usedIdBits.markFirstUnmarkedBit();        mCurrentRawPointerData.pointers[currentPointerIndex].id = id;        mCurrentRawPointerData.idToIndex[id] = currentPointerIndex;        mCurrentRawPointerData.markIdBit(id,                mCurrentRawPointerData.isHovering(currentPointerIndex));#if DEBUG_POINTER_ASSIGNMENT        ALOGD("assignPointerIds - assigned: cur=%d, id=%d",                currentPointerIndex, id);#endif    }}

能进入这个函数，说明没有上报ID，是type A；如果上报ID，在syncTouch()中就把这些工作做了，就可以用上报的ID标识各个点了，很容易判断down和up。没有上报ID，就需要用一些算法来匹配当前点与上一点，从而找到软件上的id，最终判断出down和up。
需要说明的是：type A正常不报ID的按下，走这里没有问题，也不会产生hover事件。但是type A抬起的时候，是有说法的。
(1) 只要上报了BTN或者pressure，就会产生hover事件，所以最后都不会产生touch事件；对于单点保持，可能是上次产生了hover，如果产生了hover也只能是last点数为1，因为hover是上报up，上报up的时候只上报一点的信息附加一个mt sync和sync，此种情况当做新点处理，id为0；也可能是单点移动，此种情况保持id不变。
(2) 不上报BTN，也不上报pressure，也不上报ID；up时不会产生hover，也能正常抬起，因为syncTouch()中inSlot->isInUse()为false，最后的current点数为0。
(3) 不上报BTN，也不上报pressure，但是只上报ID -1，附加一个mt sync和sync，syncTouch()中inSlot->isInUse()为true，此时current点数为1，同时设置*outHavePointerIds = false，进入assignPointerIds()时，就一直有一个(0,0)点在那，永远找不到up。只要不是只报input_mt_sync(ts->input_dev)的就都会有问题的。不报ID的type A syncTouch()就出来了点的基本信息和点数。
对于上报ID的情况，点的提取是在syncTouch()中完成的，从底层上报点的ABS_MT_TRACKING_ID，mPointerTrackingIdMap[n] = trackingId，只用了一次，如果第二次上来的点和第一次的有重复，就根据trackingId找到id。一直使用的id是和hoveringIdBits相对应的，也是和mPointerIdBits相对应的。要求底层上报id是按顺序的，如果第一次点的上报ID为：
0、1、2、3
第二次如果第2点抬起，要求点的ID为：
0、1、3
然后再上报一个2为-1的ID
如果第二点抬起后为：
0、1、2
就找不到是哪个点抬起了。
ABS_MT_TRACKING_ID就是点出来的顺序，从0开始的话就与一直使用的id一致；从1开始也可以，不能与id一一对应而已。
type中 input_mt_slot(struct input_dev *dev, int slot)里的slot才是点的ID。type A上报ID一定是标记好点出来的顺序，就是上面说的顺序。

6 cookPointerData()进行校正处理，包括原始坐标的转换，旋转，touchMajor和toolMajor的size校正。

    mCurrentCookedPointerData.hoveringIdBits = mCurrentRawPointerData.hoveringIdBits;    mCurrentCookedPointerData.touchingIdBits = mCurrentRawPointerData.touchingIdBits;

7 分发
dispatchHoverExit(when, policyFlags);
分发hover exit事件，指针没有down，但是位于某个窗口或视图范围内。前提是mSentHoverEnter = true，并且上一次产生了hover，当前hover消失。
mSentHoverEnter是标识有hover enter事件，指针没有down，但是进入了某个窗口或视图范围内。是在dispatchHoverEnterAndMove(when, policyFlags)中设置的。前提是上一次没有hover，当前产生了hover。

void TouchInputMapper::dispatchTouches(nsecs_t when, uint32_t policyFlags) {    BitSet32 currentIdBits = mCurrentCookedPointerData.touchingIdBits;    BitSet32 lastIdBits = mLastCookedPointerData.touchingIdBits;    int32_t metaState = getContext()->getGlobalMetaState();    int32_t buttonState = mCurrentButtonState;    if (currentIdBits == lastIdBits) {        if (!currentIdBits.isEmpty()) {            // 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./*没有指针id改变，所以这是一个移动事件。监视器负责批处理移动事件，我们不需要处理*/            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);        }    } else {        // There may be pointers going up and pointers going down and pointers moving        // all at the same time.        BitSet32 upIdBits(lastIdBits.value & ~currentIdBits.value);        BitSet32 downIdBits(currentIdBits.value & ~lastIdBits.value);        BitSet32 moveIdBits(lastIdBits.value & currentIdBits.value);        BitSet32 dispatchedIdBits(lastIdBits.value);        // Update last coordinates of pointers that have moved so that we observe the new        // pointer positions at the same time as other pointers that have just gone up.        bool moveNeeded = updateMovedPointers(                mCurrentCookedPointerData.pointerProperties,                mCurrentCookedPointerData.pointerCoords,                mCurrentCookedPointerData.idToIndex,                mLastCookedPointerData.pointerProperties,                mLastCookedPointerData.pointerCoords,                mLastCookedPointerData.idToIndex,                moveIdBits);        if (buttonState != mLastButtonState) {            moveNeeded = true;        }        // Dispatch pointer up events.        while (!upIdBits.isEmpty()) {            uint32_t upId = upIdBits.clearFirstMarkedBit();            dispatchMotion(when, policyFlags, mSource,                    AMOTION_EVENT_ACTION_POINTER_UP, 0, metaState, buttonState, 0,                    mLastCookedPointerData.pointerProperties,                    mLastCookedPointerData.pointerCoords,                    mLastCookedPointerData.idToIndex,                    dispatchedIdBits, upId,                    mOrientedXPrecision, mOrientedYPrecision, mDownTime);            dispatchedIdBits.clearBit(upId);        }        // Dispatch move events if any of the remaining pointers moved from their old locations.        // Although applications receive new locations as part of individual pointer up        // events, they do not generally handle them except when presented in a move event.        if (moveNeeded) {            ALOG_ASSERT(moveIdBits.value == dispatchedIdBits.value);            dispatchMotion(when, policyFlags, mSource,                    AMOTION_EVENT_ACTION_MOVE, 0, metaState, buttonState, 0,                    mCurrentCookedPointerData.pointerProperties,                    mCurrentCookedPointerData.pointerCoords,                    mCurrentCookedPointerData.idToIndex,                    dispatchedIdBits, -1,                    mOrientedXPrecision, mOrientedYPrecision, mDownTime);        }        // Dispatch pointer down events using the new pointer locations.        while (!downIdBits.isEmpty()) {            uint32_t downId = downIdBits.clearFirstMarkedBit();            dispatchedIdBits.markBit(downId);            if (dispatchedIdBits.count() == 1) {                // First pointer is going down.  Set down time.                mDownTime = when;            }            dispatchMotion(when, policyFlags, mSource,                    AMOTION_EVENT_ACTION_POINTER_DOWN, 0, metaState, buttonState, 0,                    mCurrentCookedPointerData.pointerProperties,                    mCurrentCookedPointerData.pointerCoords,                    mCurrentCookedPointerData.idToIndex,                    dispatchedIdBits, downId,                    mOrientedXPrecision, mOrientedYPrecision, mDownTime);        }    }}

dispatchTouches()分出来move、down和up事件，调用dispatchMotion()来分发处理。

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) {    PointerCoords pointerCoords[MAX_POINTERS];    PointerProperties pointerProperties[MAX_POINTERS];    uint32_t pointerCount = 0;    while (!idBits.isEmpty()) {        uint32_t id = idBits.clearFirstMarkedBit();        uint32_t index = idToIndex[id];        pointerProperties[pointerCount].copyFrom(properties[index]);//id信息        pointerCoords[pointerCount].copyFrom(coords[index]);//值信息        if (changedId >= 0 && id == uint32_t(changedId)) {            action |= pointerCount << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;        }/*action中的bits代表一个down或者up的指针索引，我们把实际的指针索引就存在<< AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT的位置，后面用的时候>>AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT就取出了这个索引*/        pointerCount += 1;    }    ALOG_ASSERT(pointerCount != 0);    if (changedId >= 0 && pointerCount == 1) {        // Replace initial down and final up action.        // We can compare the action without masking off the changed pointer index        // because we know the index is 0./*替换最初的down和最终的up。我们可以比较没有屏蔽掉改变指针索引的action，因为我们知道index是0(id不一定是0)。*/        if (action == AMOTION_EVENT_ACTION_POINTER_DOWN) {            action = AMOTION_EVENT_ACTION_DOWN;        } else if (action == AMOTION_EVENT_ACTION_POINTER_UP) {            action = AMOTION_EVENT_ACTION_UP;        } else {            // Can't happen.            ALOG_ASSERT(false);        }    }    NotifyMotionArgs args(when, getDeviceId(), source, policyFlags,            action, flags, metaState, buttonState, edgeFlags,            mViewport.displayId, pointerCount, pointerProperties, pointerCoords,            xPrecision, yPrecision, downTime);    // resize touch coords for (dual_display && freescale_disabled)    // rw.vout.scale: off/freescale_disabled, on/freescale_enabled    char prop_dual[PROPERTY_VALUE_MAX];    if (!mPadmouseStatus && property_get("ro.vout.dualdisplay2", prop_dual, "false")        && (strcmp(prop_dual, "true") == 0)        && (action == AMOTION_EVENT_ACTION_DOWN            || action == AMOTION_EVENT_ACTION_UP            || action == AMOTION_EVENT_ACTION_MOVE)) {                 bool  resize_touch = false;                if (strncmp(g_dmode_str, "panel", 5) != 0) {            char prop[PROPERTY_VALUE_MAX];            if (property_get("rw.vout.scale", prop, "on")                && strcmp(prop, "off") == 0) {                resize_touch = true;            }                            }                if (resize_touch) {            int x = 0, y = 0, w = 0, h = 0;            if(sscanf(g_daxis_str, "%d %d %d %d", &x,&y,&w,&h) > 0) {                int ww = w, hh = h;                if (strncmp(g_dmode_str, "1080p", 5) == 0) {                    ww = 1920;                    hh = 1080;                } else if (strncmp(g_dmode_str, "720p", 4) == 0) {                    ww = 1280;                    hh = 720;                                } else if (strncmp(g_dmode_str, "480p", 4) == 0) {                    ww = 720;                    hh = 480;                                   }                                if (ww >= w) x = (ww - w) / 2;                if (hh >= h) y = (hh - h) / 2;                               for (uint32_t i = 0; i < args.pointerCount; i++) {                    float coords_x = args.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_X);                    float coords_y = args.pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_Y);                    if (ww >= w && hh >= h) {   //1024*600 < 1280*720                        coords_x = coords_x*(w + 2*x)/w;                        coords_y = coords_y*(h + 2*y)/h;                        coords_x = (coords_x - x)*(w + 2*x)/w;                        coords_y = (coords_y - y)*(h + 2*y)/h;                        coords_x = coords_x*w/(w + 2*x);                        coords_y = coords_y*h/(h + 2*y);                    } else if (ww >= w && hh < h) {   //1024*768 > 1280*720                        coords_x = coords_x*(w + 2*x)/w;                        coords_y = coords_y*hh/h;                        coords_x = (coords_x - x)*(w + 2*x)/w;                        coords_y = (coords_y - 0)*hh/h;                        coords_x = coords_x*w/(w + 2*x);                        coords_y = coords_y*h/hh;                    } else {                    //1024*600 > 720*480                        coords_x = coords_x*ww/w;                        coords_y = coords_y*hh/h;                        coords_x = (coords_x - 0)*ww/w;                        coords_y = (coords_y - 0)*hh/h;                        coords_x = coords_x*w/ww;                        coords_y = coords_y*h/hh;                    }                    args.pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_X, coords_x);                    args.pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_Y, coords_y);                }                                 }           }        }        　　getListener()->notifyMotion(&args);　　//至此各event已经分发，并且通知inputDispatch。}