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<InputMapper*> 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<KeyCharacterMap> 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线程
在输入子系统中，Java程序调用C程序时，会构造一个NativeInputManager对象
-
NativeInputManager对象包括：
- mReader (实现具体功能)
- mReaderThread(实现简单循环)
- mDispatcher
- mDispatcherThread
-
mReader具体功能
3.1 mReader使用EventHub管理多个输入设备，多个输入设备存储在mDevices容器中
mDevices中有一个Device对象，表示具体的输入设备
mDevices对象中有keyMap对象，用于进行内核扫描码转化为Android具体按键
3.2 在Reader线程中，使用Epoll机制来检测设备节点的添加和删除，以及该设备节点是否有数据产生，如果有数据，就会读到数据，将读到的数据会构建为一个RawEvent类中，并进行处理，处理的过程便是根据RawEvent中的类型进行本篇博文所述的处理，就不在赘述。