Android系统--输入系统（十一）Reader线程_简单处理

1. 引入

Reader线程主要负责三件事情

• 获得输入事件
• 简单处理
• 上传给Dispatch线程

InputReader.cpp

void InputReader::loopOnce() {    ......    size_t count = mEventHub->getEvents(timeoutMillis, mEventBuffer, EVENT_BUFFER_SIZE); //获得事件    { // acquire lock        AutoMutex _l(mLock);        mReaderIsAliveCondition.broadcast();    if (count) {        processEventsLocked(mEventBuffer, count); //进行简单处理    }    ......    mQueuedListener->flush();}

前面我们已经分析其如何获取输入事件以及涉及中重要的数据结构，本次博文主要阐述其如何处理输入事件。Reader线程只是对输入事件进行简单的处理，大多数复杂处理由Dispatch线程负责处理，在后面的博文会具体分析Dispatch线程。

2. Reader线程的简单处理概述

根据所获得的RawEvent中的type参数进行处理

• ADD Device
• Remove Device
• 真正的输入事件

InputReader.cpp

void InputReader::processEventsLocked(const RawEvent* rawEvents, size_t count) {    for (const RawEvent* rawEvent = rawEvents; count;) {    int32_t type = rawEvent->type;    size_t batchSize = 1;    //if分支对真正的事件进行处理    if (type < EventHubInterface::FIRST_SYNTHETIC_EVENT) {        int32_t deviceId = rawEvent->deviceId;        while (batchSize < count) {            if (rawEvent[batchSize].type >= EventHubInterface::FIRST_SYNTHETIC_EVENT                     || rawEvent[batchSize].deviceId != deviceId) {                break;            }            batchSize += 1;        }#if DEBUG_RAW_EVENTS        ALOGD("BatchSize: %d Count: %d", batchSize, count);#endif        processEventsForDeviceLocked(deviceId, rawEvent, batchSize);    } else {        switch (rawEvent->type) {        case EventHubInterface::DEVICE_ADDED: //处理设备插入              addDeviceLocked(rawEvent->when, rawEvent->deviceId);            break;        case EventHubInterface::DEVICE_REMOVED: //处理设备拔出              removeDeviceLocked(rawEvent->when, rawEvent->deviceId);            break;        case EventHubInterface::FINISHED_DEVICE_SCAN:            handleConfigurationChangedLocked(rawEvent->when);            break;        default:            ALOG_ASSERT(false); // can't happen            break;        }    }        count -= batchSize;        rawEvent += batchSize;    }}

3. 插入输入设备处理

3.1 创建InpuDevice对象

InputReader.cpp

void InputReader::addDeviceLocked(nsecs_t when, int32_t deviceId) {    ......    InputDevice* device = createDeviceLocked(deviceId, controllerNumber, identifier, classes); //首先创建InputDevice对象     device->configure(when, &mConfig, 0);    device->reset(when);    if (device->isIgnored()) {        ALOGI("Device added: id=%d, name='%s' (ignored non-input device)", deviceId,            identifier.name.string());} else {        ALOGI("Device added: id=%d, name='%s', sources=0x%08x", deviceId,            identifier.name.string(), device->getSources());    }    mDevices.add(deviceId, device); //将InputDevice添加到mDevice中，mDevice记录管理输入设备    bumpGenerationLocked();}

扩展：我们知道在输入系统中我们使用EeventHub类管理多个输入设备（之前博文已经具体分析），为什么在InputReader中又要构建一个mDevices来记录管理多个输入设备呢？ 即Android输入系统当中采用分层作用。

输入系统中的分层作用：

（1）EventHub中有mDvices类记录管理一个输入设备，主要作用是读取事件

mDevices类

- fd : int //设备节点所打开的文件句柄- identifier : const InputDeviceIdentifier //记录厂商信息，存储了设备的供应商、型号等信息- keyBitmask[] : uint8_t- configurationFile : String8 //IDC文件名- configuration : PropertyMap* //IDC属性：（内嵌OR外接）设备- keyMap : KeyMap //保存配置文件(kl,kcm)

（2）InputReader中有mDvices链表中使用InputDevice对象记录管理一个输入设备，主要用来处理事件

InputDevice类

- InputReaderContext* mContext;- int32_t mId; //通过mId从EventHub中找到对应的输入设备- Vector
    
      mMappers; //处理上报的事件
    

总结：InputDevice主要负责处理事件，并不需要关心设备的具体信息，其中具体信息由EventHub中mDevice类记录，当需要设备信息时，可以通过mId找到对应设备，提取信息

3.2 根据输入设备类别，添加Mapper，主要负责之后的按键映射。

InputReader.cpp

InputDevice* InputReader::createDeviceLocked(int32_t deviceId, int32_t controllerNumber,        const InputDeviceIdentifier& identifier, uint32_t classes) {    InputDevice* device = new InputDevice(&mContext, deviceId, bumpGenerationLocked(),            controllerNumber, 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;}

总的来说，添加新设备的过程就是这样子，拿键盘输入来说，首先创建一个InputDevice类记录，并且它添加KeyboardInputMapper对象，使用该对象进行处理，移除过程与添加过程类似就不具体分析了。

4. 真正的输入设备上报事件处理

（1）设备产生的输入事件，主要是通过调用processEventsForDeviceLocked函数进行处理

InputReader.cpp

void InputReader::processEventsForDeviceLocked(int32_t deviceId,const RawEvent* rawEvents, size_t count) {    ......    device->process(rawEvents, count); //直接调用process进行处理}

（2）process函数中将InputDvices对象中的mMappers一个个取出来，调用其process函数。

InputReader.cpp

void InputDevice::process(const RawEvent* rawEvents, size_t count) {    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 {        //将InputDvices对象中的mMappers一个个取出来，调用其process函数            for (size_t i = 0; i < numMappers; i++) {              InputMapper* mapper = mMappers[i]; //              mapper->process(rawEvent);           }        }    }}

（3）这里我们用键盘的process函数进行分析

- 进行内核扫描码转化Android系统所需要的按键码，转化成功则处理该按键

InputReader.cpp

void KeyboardInputMapper::process(const RawEvent* rawEvent) {    switch (rawEvent->type) {    case EV_KEY: {        int32_t scanCode = rawEvent->code;        int32_t usageCode = mCurrentHidUsage;        mCurrentHidUsage = 0;    if (isKeyboardOrGamepadKey(scanCode)) {        int32_t keyCode;        uint32_t flags;        /*        *调用EventHub中的mapKey函数进行转化        *传入参数        *scanCode：驱动程序上报的扫描码；keyCode：转化之后的Android使用的按键值        */     if (getEventHub()->mapKey(getDeviceId(), scanCode, usageCode, &keyCode, &flags)) {        keyCode = AKEYCODE_UNKNOWN;        flags = 0;     }    processKey(rawEvent->when, rawEvent->value != 0, keyCode, scanCode, flags); //映射成功之后，处理该按键    }    break;}    case EV_MSC: {        if (rawEvent->code == MSC_SCAN) {            mCurrentHidUsage = rawEvent->value;        }    break;}    case EV_SYN: {        if (rawEvent->code == SYN_REPORT) {            mCurrentHidUsage = 0;        }    }}}

- 扫描码转化过程（具体在上次博文已经论述）：

EventHub.cpp

status_t EventHub::mapKey(int32_t deviceId, int32_t scanCode, int32_t usageCode,int32_t* outKeycode, uint32_t* outFlags) const {AutoMutex _l(mLock);    Device* device = getDeviceLocked(deviceId);    if (device) {        // Check the key character map first.        //首先使用KCM文件进行映射，映射过程在上次博文已经详细分析        sp
    
      kcm = device->getKeyCharacterMap();    if (kcm != NULL) {        if (!kcm->mapKey(scanCode, usageCode, outKeycode)) {            *outFlags = 0;            return NO_ERROR;        }}    // Check the key layout next.    //其次使用keylayout文件进行映射    if (device->keyMap.haveKeyLayout()) {        if (!device->keyMap.keyLayoutMap->mapKey(        scanCode, usageCode, outKeycode, outFlags)) {            return NO_ERROR;        }    }}    *outKeycode = 0;    *outFlags = 0;    return NAME_NOT_FOUND;
    

- 在Reader线程中，只是将内核上报的扫描码，转化为Android系统所使用的按键码，然后重新构造一个args，将其发给下一级的Dispatch线程进行处理。

InputReader.cpp

void KeyboardInputMapper::processKey(nsecs_t when, bool down, int32_t keyCode,int32_t scanCode, uint32_t policyFlags) {    ......    //根据扫描码scanCode、按键码keyCode、newMetaState、downTime按下的时间进行处理     NotifyKeyArgs args(when, getDeviceId(), mSource, policyFlags,    down ? AKEY_EVENT_ACTION_DOWN : AKEY_EVENT_ACTION_UP,    AKEY_EVENT_FLAG_FROM_SYSTEM, keyCode, scanCode, newMetaState, downTime);    getListener()->notifyKey(&args); //通知Listener处理，Dispatch线程会监听该事件，并处理，下次博文会具体分析}

5. 总结Reader线程

1. 在输入子系统中，Java程序调用C程序时，会构造一个NativeInputManager对象

2. NativeInputManager对象包括：

   • mReader (实现具体功能)
   • mReaderThread(实现简单循环)
   • mDispatcher
   • mDispatcherThread

3. mReader具体功能

   3.1 mReader使用EventHub管理多个输入设备，多个输入设备存储在mDevices容器中

   • mDevices中有一个Device对象，表示具体的输入设备

   • mDevices对象中有keyMap对象，用于进行内核扫描码转化为Android具体按键

   3.2 在Reader线程中，使用Epoll机制来检测设备节点的添加和删除，以及该设备节点是否有数据产生，如果有数据，就会读到数据，将读到的数据会构建为一个RawEvent类中，并进行处理，处理的过程便是根据RawEvent中的类型进行本篇博文所述的处理，就不在赘述。

6. Reader线程简单处理各类调用关系图