系列文章目录
本人系列文章-CSDN博客
目录
系列文章目录
1.简介
1.1发送流程介绍
1.2 时序图
2.普通按键消息发送部分源码分析
2.1 设备的监听
2.2 inputreader线程阻塞等待事件发生
2.3 按键事件的产生
2.4 EventHub::getEvents
2.5 InputReader::loopOnce
2.6 processEventsLocked
2.7 processEventsForDeviceLocked
2.8 InputDevice::process
2.9 KeyboardInputMapper::process
2.10 KeyboardInputMapper::process（扫描消息）
2.11 KeyboardInputMapper::process（按键按下）
2.12 KeyboardInputMapper::processKey
2.13 QueuedInputListener::notifyKey
2.14 KeyboardInputMapper::process（同步消息）
2.15 KeyboardInputMapper::process（扫描事件）
2.16 KeyboardInputMapper::process（按键抬起事件）
2.17 KeyboardInputMapper::process（同步消息）
2.18 QueuedInputListener::flush
2.19 NotifyKeyArgs::notify
2.20 InputDispatcher::notifyKey
2.21 NativeInputManager::interceptKeyBeforeQueueing
2.22 IMS中的interceptKeyBeforeQueueing
2.23 WMS中的interceptKeyBeforeQueueing
2.24 PhoneWindowManager中的interceptKeyBeforeQueueing
2.25 NativeInputManager::handleInterceptActions
2.26 InputDispatcher::enqueueInboundEventLocked
2.27 NotifyKeyArgs::notify（抬起）
1.简介
从之前的篇幅我们知道了，事件分为设备增删事件和原始输入事件，而原始输入事件主要有两种，一种是key按键事件的派发，一种是触摸事件的派发。本篇区别于其他作者，会不放过任何一个函数，进行系统完整的分析。此篇主要分析一个按键事件从驱动上报到应用监听获取的全流程。
1.1发送流程介绍
1.input启动后，完成对设备的加载后，当无事件产生时，inputreader线程便阻塞在epoll_wait等待有消息的产生。
2.当物理按键按下和抬起的时候，即按键事件便产生了。内核会上报按下和抬起的消息给到input系统。
3.inputreader线程中的不再阻塞，然后从notifyfd中读取原始的input_event输入事件。
4.对原始的input_event事件，进行加工成RawEvent事件，然后调用对应的KeyboardInputMapper进行处理。
5.KeyboardInputMapper会将RawEvent事件再加工成NotifyKeyArgs事件，然后插入到mArgsQueue队列中。
6.然后会调用InputDispatcher的notifyKey，将NotifyKeyArgs事件再加工成KeyEntry事件，放入mInboundqueue队列队尾，然后唤醒InputDispatcher分发线程，进行按键事件的分发。
1.2 时序图
为了完整的画出所有时序，较为模糊，读者可保存照片到本地放大观看。
2.普通按键消息发送部分源码分析
为了便于读者清晰的了解发送流程，此章节会删除不执行的代码，便于理解。
2.1 设备的监听
要想知道某设备的事件发生，首先，便是要监听设备。在启动篇中，我们知道会注册设备到epoll中完成对设备的监听。
下面是前文监听设备节点的代码
status_t EventHub::registerDeviceForEpollLocked(Device* device) {struct epoll_event eventItem;memset(&eventItem, 0, sizeof(eventItem));eventItem.events = EPOLLIN;//监听的文件描述符是否有可读事件eventItem.data.u32 = device->id;//事件触发时会返回eventItem.data数据if (epoll_ctl(mEpollFd, EPOLL_CTL_ADD, device->fd, &eventItem)) {//监听device->fd对应的设备是否有可读事件。//如果有事件可读，则返回eventItem.data}return OK;
}2.2 inputreader线程阻塞等待事件发生
void InputReader::loopOnce() {int32_t oldGeneration;int32_t timeoutMillis;bool inputDevicesChanged = false;Vector<InputDeviceInfo> inputDevices;{ oldGeneration = mGeneration;//新的值timeoutMillis = -1;size_t count = mEventHub->getEvents(timeoutMillis, mEventBuffer, EVENT_BUFFER_SIZE);//通过EventHub的getEvents函数获取事件，//并存放在mEventBuffer中。//参数分析：timeoutMillis=-1，代表等待超时的时间，感觉如果数字为0代表立即执行//mEventBuffer是一个存放从eventhub中读取的rawevent结构体类型的数组，源代码是：RawEvent mEventBuffer[EVENT_BUFFER_SIZE];//EVENT_BUFFER_SIZE值是256，代表最大可以读取256个原始事件，查看833行-840行，RawEvent结构体如下
.......
即：此时阻塞在getEvents函数的epoll_wait中。
//第一次for循环，会阻塞在epoll_wait中，等待设备增加事件的到来。size_t EventHub::getEvents(int timeoutMillis, RawEvent* buffer, size_t bufferSize) {ALOG_ASSERT(bufferSize >= 1);struct input_event readBuffer[bufferSize];//bufferSize值为传入的256RawEvent* event = buffer;//event指针指向传入的buffer首地址，每存入一个事件，event指针向后移动一个元素size_t capacity = bufferSize;//capacity表示buffer中剩余端元素数量，capacity为0，表示buffer已满bool awoken = false;for (;;) {nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);//获取当前时间mPendingEventIndex = 0;//此时mPendingEventItems数组中未处理的事件已经处理完了，将mPendingEventIndex设置为0int pollResult = epoll_wait(mEpollFd, mPendingEventItems, EPOLL_MAX_EVENTS, timeoutMillis);//此时读线程会阻塞在此处，等待有消息的事件发生......
2.3 按键事件的产生
首先从本系列的input第一篇可知，一次按键按下和抬起的过程中，会产生六条数据包，一个按键按下到抬起，发了6包数据，依次是：
扫描事件、KEY事件、同步事件、扫描事件、KEY事件、同步事件。
比如按下A按键，然后抬起。则内核上报的数据为：
按下：
/dev/input/event4: EV_MSC MSC_SCAN 00090001//扫描事件，EV_MSC代表是杂项事件，MSC_SCAN代表是杂项事件中的扫描事件，Value代表值是00090001，说明扫描到BTN_GAMEPAD这个按键有变化
/dev/input/event4: EV_KEY BTN_GAMEPAD 00000001 //KEY事件，EV_KEY代表这是按键类型事件，BTN_GAMEPAD代表手柄注册中的按键是BTN_GAMEPAD，00000001表示按下
/dev/input/event4: EV_SYN SYN_REPORT 00000000 //同步事件，标识一个独立的事件的发生，它与另一个同步包夹中间的一组的打印就是一个事件的发生
抬起：
/dev/input/event4: EV_MSC MSC_SCAN 00090001 //扫描事件
/dev/input/event4: EV_KEY BTN_GAMEPAD 00000000 //KEY事件，00000000代表抬起
/dev/input/event4: EV_SYN SYN_REPORT 00000000 //同步事件
然后便是按键事件的处理
2.4 EventHub::getEvents
主要作用是：
1.epoll_wait不再阻塞，从发生事件的fd中读取按键原始事件并加工成RawEvent类型的消息。
回到2.2 inputreader线程阻塞的地方，因为对设备的fd进行了epoll监听其是否有可读事件，所以当有事件时，第一次for循环中epoll_wait不再阻塞，向下执行。
//第一次死循环，当按键按下产生按键按下的消息。epoll_wait不再阻塞，向下执行。
size_t EventHub::getEvents(int timeoutMillis, RawEvent* buffer, size_t bufferSize) {struct input_event readBuffer[bufferSize];//bufferSize值为传入的256RawEvent* event = buffer;//event指针指向传入的buffer首地址，每存入一个事件，event指针向后移动一个元素size_t capacity = bufferSize;//capacity表示buffer中剩余端元素数量，capacity为0，表示buffer已满bool awoken = false;for (;;) {nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);//获取当前时间mPendingEventIndex = 0;//此时mPendingEventItems数组中未处理的事件已经处理完了，将mPendingEventIndex设置为0int pollResult = epoll_wait(mEpollFd, mPendingEventItems, EPOLL_MAX_EVENTS, timeoutMillis);//此时读线程会阻塞在此处，等待有消息的事件发生///if (pollResult < 0) {} else {// 发生了某些事件mPendingEventCount = size_t(pollResult);}}/// 此时并没有返回而是开启了下一次死循环。///return event - buffer;
}第二次for循环，会从设备的fd中读取原始事件，并将消息加工成RawEvent类型。
//第二次for死循环
//假设只有一个设备，一个按下，一个抬起，相当于六条消息，
//依次为扫描事件、key按下事件、同步事件、扫描事件、key抬起事件、同步事件。
size_t EventHub::getEvents(int timeoutMillis, RawEvent* buffer, size_t bufferSize) {size_t capacity = bufferSize;//capacity表示buffer中剩余端元素数量，capacity为0，表示buffer已满RawEvent* event = buffer;for (;;) {nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);//获取当前时间//如果存在未处理的事件，则从mPendingEventItems数组中取出事件bool deviceChanged = false;while (mPendingEventIndex < mPendingEventCount) {//此时会执行，此时mPendingEventIndex=0，mPendingEventCount为设备有变化的数量//此时相当于mPendingEventCount =1，const struct epoll_event& eventItem = mPendingEventItems[mPendingEventIndex++];ssize_t deviceIndex = mDevices.indexOfKey(eventItem.data.u32);//获取事件的data.u32字段，此字段存储的是device-id，//然后判断此事件发生的设备是否在mDevices中能查找到对应的deviceidif (deviceIndex < 0) {//在已经打开的设备中，没找到此事件对应的设备ALOGW("Received unexpected epoll event 0x%08x for unknown device id %d.",eventItem.events, eventItem.data.u32);continue;}Device* device = mDevices.valueAt(deviceIndex);//通过deviceid，找到对应的deviceif (eventItem.events & EPOLLIN) {//现在处理的是input设备产生的原始事件int32_t readSize = read(device->fd, readBuffer,sizeof(struct input_event) * capacity);//从input设备中，读取event事件，存入readBuffer数组中，从input设备中，读取event事件，存入readBuffer数组中，if (readSize == 0 || (readSize < 0 && errno == ENODEV)) {//如果满足此条件，代表在通知INotify之前，设备已被移除。}else{int32_t deviceId = device->id == mBuiltInKeyboardId ? 0 : device->id;//判断是否是内置键盘，给devcie-id赋值size_t count = size_t(readSize) / sizeof(struct input_event);//计算事件的数量，此时等于6for (size_t i = 0; i < count; i++) {struct input_event& iev = readBuffer[i];//此处是将input_event信息, 封装成RawEventevent->deviceId = deviceId;event->type = iev.type;event->code = iev.code;event->value = iev.value;event += 1;capacity -= 1;}if (capacity == 0) {//buffer数组已满，重置mPendingEventIndex，//注意，此时有三个数组，分别是//1.存储epoll_event结构体的mPendingEventItems数组，epoll_event& eventItem = mPendingEventItems[mPendingEventIndex++];//2.存储input_event结构体的readbuffer数组，input_event readBuffer[bufferSize]，//3.存储RawEvent类型的buffer数组，RawEvent* event = buffer//流程如下：//当设备有可读事件时，会返回一个epoll_event结构体，存储mPendingEventItems数组中，然后从mPendingEventItems数组中，//取出这个epoll_event结构体，函数进行判断epoll_event结构体的eventItem.events = EPOLLIN，此字段代表监听的fd有可读事件，//然后，通过read（fd，readbuffer）函数，去读取此设备中的多个input_event结构体类型的事件，//存储在readbuffer数组中，这是第二个数组，然后循环取出input_event类型的数据，//将其进行加工成rawinput类型，存储在存储RawEvent类型的buffer数组中。//所以此处的mPendingEventIndex含义减去一的含义是：//比如：buffer数组的容量是200，一个eventItem相当于对应一个设备，所以一个eventItem会对应多个事件。//第一个eventItem对应的按键事件有150个，第二个eventItem对应的事件有200个，//当拿到第二个eventItem时，因为eventItem = mPendingEventItems[mPendingEventIndex++];，所以mPendingEventIndex值等于3，//然后去读取数据，并将其加工到buffer数组中，此时buffer在加工到50个的时候已经满了。但是第二个eventItem对应的剩余事件还没加工完//所以此处重新吧mPendingEventIndex设置为第二个，等待下一次getevent中调用，继续处理第二个eventitem对应的所以事件。mPendingEventIndex -= 1;break;//退出循环，此时退出的是eventItem这个循环。}}}}// 当event的指针不再指向buffer的首地址时，代表里面有数据，或者被唤醒时，立即退出循环if (event != buffer || awoken) {break;//退出for死循环}}// 全部完成后，返回我们读取的事件数。return event - buffer;
}加工的代码如下：
RawEvent* event = buffer;
event->deviceId = deviceId;
event->type = iev.type;
event->code = iev.code;
event->value = iev.value;struct RawEvent {nsecs_t when;//时间int32_t deviceId;//事件发生的设备idint32_t type;//类型，例如按键事件等int32_t code;//扫描码，按键对应的扫描码int32_t value;//值，表示按键按下，或者抬起等
};所以此时只有按键按下的情况时，有六条RawEvent消息。
第一条：RawEvent是对应的扫描事件。type对应的是EV_MSC，code对应的是MSC_SCAN，value对应的是00090001
后面消息类同。
然后，我们需要回到调用getEvents函数的InputReader::loopOnce中。
2.5 InputReader::loopOnce
当getEvents函数返回6条RawEvent的消息时候，会调用processEventsLocked进行处理。
void InputReader::loopOnce() {int32_t oldGeneration;int32_t timeoutMillis;bool inputDevicesChanged = false;Vector<InputDeviceInfo> inputDevices;oldGeneration = mGeneration;//值为1，在inputreader构造函数中mGeneration=1，timeoutMillis = -1;uint32_t changes = mConfigurationChangesToRefresh;//值为0，初始化时设置为0，代表无变化，不刷新配置size_t count = mEventHub->getEvents(timeoutMillis, mEventBuffer, EVENT_BUFFER_SIZE);//通过EventHub的getEvents函数获取事件，//并存放在mEventBuffer中。//参数分析：timeoutMillis=-1，代表啥意思不清楚，感觉如果数字为0代表立即执行//mEventBuffer是一个存放从eventhub中读取的rawevent结构体类型的数组，源代码是：RawEvent mEventBuffer[EVENT_BUFFER_SIZE];//EVENT_BUFFER_SIZE值是256，代表最大可以读取256个原始事件if (count) {//返回的事件数量大于，则调用processEventsLocked处理事件processEventsLocked(mEventBuffer, count);}//发布事件。 processEventsLocked()函数在对事件进行加工处理之后，便将处理后的事件存储在// mQueuedListener中。在循环的最后，通过调用flush()函数将所有事件交付给InputDispatchermQueuedListener->flush();
}2.6 processEventsLocked
此函数的主要作用是：
1.如果事件是原始输入事件，将同一设备的原始输入事件进行打包处理。
2.如果事件是设备增删事件，则进行增删事件的处理。
void InputReader::processEventsLocked(const RawEvent* rawEvents, size_t count) {//用rawEvents指针接收传入的从传入的mEventBuffer数组的首地址for (const RawEvent* rawEvent = rawEvents; count;) {//for循环遍历数组int32_t type = rawEvent->type;//取出数组中第0号的元素rawEvent的type.size_t batchSize = 1;//事件信息有两种，一种是设备节点的增加和删除事件，统称为设备事件，另一种是原始输入事件。//此处满足条件，则是对原始输入事件进行处理if (type < EventHubInterface::FIRST_SYNTHETIC_EVENT) {//FIRST_SYNTHETIC_EVENT值是0x10000000，type值都是小于FIRST_SYNTHETIC_EVENTint32_t deviceId = rawEvent->deviceId;//继续取出0号元素的id号while (batchSize < count) {if (rawEvent[batchSize].type >= EventHubInterface::FIRST_SYNTHETIC_EVENT|| rawEvent[batchSize].deviceId != deviceId) {//循环数组中所有其他的元素rawEvent对象，//只有当数组中其他rawEvent对象，即是原始输入事件也是同一个设备id的时候，则batchSize+1break;}batchSize += 1;}processEventsForDeviceLocked(deviceId, rawEvent, batchSize);//此处相当于三个事件一起打包//此处举个例子//现在rawEvent数组有五个事件，前两个是id为1的设备产生的。第三个是id为2设备产生的，第四和第五是id为1设备产生的。//此时会先取出第一个事件的设备id，然后遍历第2.3.4.5事件的设备id，发现第二个事件也是设备id为1的。那就batchSize+1=2，//此时遍历第三个事件设备id，发现和前两个不一样，则退出循环。//表示，从第一个事件开始，一共有两个事件是相同的设备id为1产生的。所以，rawEvent参数和batchSize参数的含义就明显了。//那后面的第3.4.5事件呢，从下面的代码看出调用完processEventsForDeviceLocked后，rawEvent指针指向了数组中第三个事件，//然后继续遍历第4.5事件的id。}count -= batchSize;rawEvent += batchSize;}
}2.7 processEventsForDeviceLocked
主要作用：
1.从保存的容器中找到此设备id对应的InputDevice类对象
2.调用此对象的process方法
void InputReader::processEventsForDeviceLocked(int32_t deviceId,const RawEvent* rawEvents, size_t count) {ssize_t deviceIndex = mDevices.indexOfKey(deviceId);//从已经扫描到的设备容器中查找此id对应的device对象InputDevice* device = mDevices.valueAt(deviceIndex);//获取此deviceId对应的device对象device->process(rawEvents, count);//调用device->process方法处理。rawEvents是指向所有事件数组的首地址的指针，//count之前打包的是同一设备产生的输入事件的数量}2.8 InputDevice::process
void InputDevice::process(const RawEvent* rawEvents, size_t count) {//按顺序处理每个映射器的所有事件。size_t numMappers = mMappers.size();//mMappers是一个存储InputMapper指针的容器，Vector<InputMapper*> mMappers;for (const RawEvent* rawEvent = rawEvents; count != 0; rawEvent++) {//取出每一个按键消息。此时第一个消息是扫描消息else {for (size_t i = 0; i < numMappers; i++) {//循环调用所有的mapper去派发按键消息InputMapper* mapper = mMappers[i];mapper->process(rawEvent);//将事件交给mapper处理。InputMapper有多个子类。//后续以keyborardinputMapper，用于处理键盘输入事件分析。}}--count;}
}2.9 KeyboardInputMapper::process
此函数的主要作用是：
1.循环取出所有原始事件，进行处理。
1.1 如果是扫描消息，则取出其Value作为下一个按键消息的策略flag。但此扫描消息并不派发。
1.2 如果是按键消息，则进行处理派发。
1.3 如果是同步消息，则重置此按键消息的策略flag。
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)) {processKey(rawEvent->when, rawEvent->value != 0, scanCode, usageCode);}break;}case EV_MSC: {//如果是杂项消息if (rawEvent->code == MSC_SCAN) {mCurrentHidUsage = rawEvent->value;}break;}case EV_SYN: {//如果是同步消息if (rawEvent->code == SYN_REPORT) {mCurrentHidUsage = 0;}}}
}2.10 KeyboardInputMapper::process（扫描消息）
我们先看看第一个扫描消息是如何处理的。
//先处理第一个消息-扫描消息，没派发
void KeyboardInputMapper::process(const RawEvent* rawEvent) {switch (rawEvent->type) {case EV_MSC: {if (rawEvent->code == MSC_SCAN) {mCurrentHidUsage = rawEvent->value;//记录当前扫描事件的value值。此时值为00090001,此值后续会对应policyflag}break;}}
}2.11 KeyboardInputMapper::process（按键按下）
接下来，我们看看第二个消息按键按下是如何处理的。
//处理第二个消息-key消息（A按键按下信息）
void KeyboardInputMapper::process(const RawEvent* rawEvent) {switch (rawEvent->type) {case EV_KEY: {//如果此事件是按键事件int32_t scanCode = rawEvent->code;//取出事件代码保存的键盘扫描码，此时是0130int32_t usageCode = mCurrentHidUsage;//保存值为00090001mCurrentHidUsage = 0;//设置为0if (isKeyboardOrGamepadKey(scanCode)) {//排除对鼠标按键的处理。鼠标按键由CursorInputMapper处理processKey(rawEvent->when, rawEvent->value != 0, scanCode, usageCode);//调用KeyboardInputMapper的processKey方法。//processKey方法，主要是将rawevent事件加工成NotifyKeyArgs，然后将NotifyKeyArgs放入队列中。//传入参数分析：rawEvent->when表示时间，rawEvent->value != 0如果为真，表示按键按下，scanCode扫描码}break;}}
}//排除是鼠标的按键，鼠标按键由CursorInputMapper处理
bool KeyboardInputMapper::isKeyboardOrGamepadKey(int32_t scanCode) {return scanCode < BTN_MOUSE|| scanCode >= KEY_OK|| (scanCode >= BTN_MISC && scanCode < BTN_MOUSE)|| (scanCode >= BTN_JOYSTICK && scanCode < BTN_DIGI);
}2.12 KeyboardInputMapper::processKey
此处的主要作用是：
1.将扫描码和usagecode通过加载好的按键映射表转化为keycode和派发策略。
2.生成NotifyKeyArgs按键事件，插入到分发线程的队列中，等待分发。
那么为什么要将扫描码和usagecode转化为keycode和派发策略呢？
因为驱动往往是各个不同的供应商开发的，故存在不同键盘的扫描码是不同的，为了保证上层无论是什么牌子的键盘，对于按键A受到的消息是一致的，因此需要转化为统一的keycode，厂商会将对应关系写入配置文件，这样，无论是任何牌子的键盘按键A，上层都是同一个keycode。
void KeyboardInputMapper::processKey(nsecs_t when, bool down, int32_t scanCode,int32_t usageCode) {int32_t keyCode;int32_t keyMetaState;uint32_t policyFlags;//通过EventHub的mapKey()函数进行映射。映射的输入为scancode和usagecode，而输出为keyCode和flag//scancode->keyCode//usagecode->flag//此步的作用是将物理的扫描码——scancode描述的按键，转化为操作系统的识别的keyCode——虚拟键值//EventHub::mapKey()函数可以根据设备Id找到对应的KeyLayoutMap，进而根据扫描码找到 //对应的Key结构体中所保存的虚拟键值（传出参数keycode)以及策略值（传出参数flag），从 //而完成从扫描码到虚拟键值的映射工作if (getEventHub()->mapKey(getDeviceId(), scanCode, usageCode, mMetaState,&keyCode, &keyMetaState, &policyFlags)) {keyCode = AKEYCODE_UNKNOWN;如果映射失败，则使用UNKNOWN作为事件的虚拟键值keyMetaState = mMetaState;//mMetaState默认是0，代表shift等控制键的状态policyFlags = 0;}if (down) {//KeyboardInputMapper维护了保存KeyDown结构体的容器mKeyDowns。//当按键按下时会生成一个保存了扫描码与keyCode的 KeyDown对象并添加到集合中。 ssize_t keyDownIndex = findKeyDown(scanCode);//通过扫描码对mKeyDowns容器查找，结果表明了按键是否是重复按下if (keyDownIndex >= 0) {} else {//生成keyDown，并保存到mKeyDowns容器中mKeyDowns.push();KeyDown& keyDown = mKeyDowns.editTop();keyDown.keyCode = keyCode;keyDown.scanCode = scanCode;}mDownTime = when;//按键按下的时间，也就是事件发生的时间}nsecs_t downTime = mDownTime;//将所有的按键事件信息封装为NotifykeyArga对象，并将此对象通知给inputdispather的listenerNotifyKeyArgs args(when, getDeviceId(), mSource, policyFlags,down ? AKEY_EVENT_ACTION_DOWN : AKEY_EVENT_ACTION_UP,AKEY_EVENT_FLAG_FROM_SYSTEM, keyCode, scanCode, keyMetaState, downTime);//参数分析：//when对应eventTime, 其实是rawEvent->when，就是事件发生的时间//getDeviceId（）对应deviceId, 返回的是设备id//mSource对应source,是KeyboardInputMapper初始化时赋值的//其值是INPUT_DEVICE_CLASS_KEYBOARD，INPUT_DEVICE_CLASS_DPAD从，INPUT_DEVICE_CLASS_GAMEPAD的某一个//policyFlags对应policyFlags值是策略标志//down ? AKEY_EVENT_ACTION_DOWN : AKEY_EVENT_ACTION_UP，对应action，描述按下或者抬起//AKEY_EVENT_FLAG_FROM_SYSTEM对应flag，表示此事件是系统信任的。//keyCode对应keyCode，虚拟健keycode//scanCode对应scanCode，扫描码//keyMetaState对应metaState，控制健的值，其可以表示控制键的按下或者抬起，此时值应该是0，代表无任何控制键按下//downTime对应downTime就等于whengetListener()->notifyKey(&args);//将生成的NotifyKeyArgs插入到mArgsQueue队列中//getListener返回的是QueuedInputListener类对象，其的一个属性是InputDispatcher类的对象
}此处便是scancode和usagecode转化输出为keyCode和flag的地方。
status_t EventHub::mapKey(int32_t deviceId,int32_t scanCode, int32_t usageCode, int32_t metaState,int32_t* outKeycode, int32_t* outMetaState, uint32_t* outFlags) const {AutoMutex _l(mLock);Device* device = getDeviceLocked(deviceId);//获取device对象status_t status = NAME_NOT_FOUND;if (device) {sp<KeyCharacterMap> kcm = device->getKeyCharacterMap();//获取键盘的映射表if (kcm != NULL) {if (!kcm->mapKey(scanCode, usageCode, outKeycode)) {//将扫描码和usageCode转化为outKeycode，如果转化失败，则代表需要策略*outFlags = 0;status = NO_ERROR;}}// Check the key layout next.if (status != NO_ERROR && device->keyMap.haveKeyLayout()) {if (!device->keyMap.keyLayoutMap->mapKey(scanCode, usageCode, outKeycode, outFlags)) {//将扫描码和usageCode转化为outKeycode和outFlagsstatus = NO_ERROR;}}if (status == NO_ERROR) {//转化成功后，再尝试将metaState转化为对应的outMetaStateif (kcm != NULL) {kcm->tryRemapKey(*outKeycode, metaState, outKeycode, outMetaState);} else {*outMetaState = metaState;}}}return status;
}ssize_t KeyboardInputMapper::findKeyDown(int32_t scanCode) {size_t n = mKeyDowns.size();//mKeyDowns是一个存储KeyDown结构体的容器，Vector<KeyDown> mKeyDowns; // struct KeyDown {// int32_t keyCode;// int32_t scanCode;//};for (size_t i = 0; i < n; i++) {if (mKeyDowns[i].scanCode == scanCode) {return i;}}return -1;
}2.13 QueuedInputListener::notifyKey
将按键消息放入分发队列中
void QueuedInputListener::notifyKey(const NotifyKeyArgs* args) {mArgsQueue.push(new NotifyKeyArgs(*args));//将消息放入mArgsQueue队列中
}2.14 KeyboardInputMapper::process（同步消息）
//处理第三个消息-同步消息，也没派发。
void KeyboardInputMapper::process(const RawEvent* rawEvent) {switch (rawEvent->type) {case EV_SYN: {if (rawEvent->code == SYN_REPORT) {mCurrentHidUsage = 0;//将mCurrentHidUsage重置为o}}}
}2.15 KeyboardInputMapper::process（扫描事件）
接下来，是第四条消息的扫描事件的处理。此处同2.10
//，处理第四个消息-扫描消息，没派发
void KeyboardInputMapper::process(const RawEvent* rawEvent) {switch (rawEvent->type) {case EV_MSC: {if (rawEvent->code == MSC_SCAN) {mCurrentHidUsage = rawEvent->value;//记录当前扫描事件的value值。此时值为00090001,此值后续会对应policyflag}break;}}
}2.16 KeyboardInputMapper::process（按键抬起事件）
//处理第二个消息-key消息（A按键抬起信息）
void KeyboardInputMapper::process(const RawEvent* rawEvent) {switch (rawEvent->type) {case EV_KEY: {//如果此事件是按键事件int32_t scanCode = rawEvent->code;//取出事件代码保存的键盘扫描码，此时是0130int32_t usageCode = mCurrentHidUsage;//保存值为00090001mCurrentHidUsage = 0;//设置为0if (isKeyboardOrGamepadKey(scanCode)) {//排除对鼠标按键的处理。鼠标按键由CursorInputMapper处理processKey(rawEvent->when, rawEvent->value != 0, scanCode, usageCode);//调用KeyboardInputMapper的processKey方法。//processKey方法，主要是将rawevent事件加工成NotifyKeyArgs，然后将NotifyKeyArgs放入队列中。//传入参数分析：rawEvent->when表示时间，rawEvent->value != 0如果为真，表示按键按下，scanCode扫描码}break;}}
}此处的作用是：
1.将按键的扫描码和usagecode通过键盘映射表转化为keycode和分发策略
2.生成按键抬起的NotifyKeyArgs事件，并放入消息队列中。
//按键抬起事件分析
void KeyboardInputMapper::processKey(nsecs_t when, bool down, int32_t scanCode,int32_t usageCode) {int32_t keyCode;int32_t keyMetaState;uint32_t policyFlags;if (getEventHub()->mapKey(getDeviceId(), scanCode, usageCode, mMetaState,&keyCode, &keyMetaState, &policyFlags)) {keyCode = AKEYCODE_UNKNOWN;keyMetaState = mMetaState;policyFlags = 0;}if (down) {......} else {ssize_t keyDownIndex = findKeyDown(scanCode);if (keyDownIndex >= 0) {keyCode = mKeyDowns.itemAt(keyDownIndex).keyCode;//当按键抬起时，和按键按下保持同一个keycodemKeyDowns.removeAt(size_t(keyDownIndex));//从保存按下的容器中删除key按下} }nsecs_t downTime = mDownTime;//此按键按下发生的时间//将所有的按键事件信息封装为NotifykeyArga对象，并将此对象通知给inputdispather的listenerNotifyKeyArgs args(when, getDeviceId(), mSource, policyFlags,down ? AKEY_EVENT_ACTION_DOWN : AKEY_EVENT_ACTION_UP,AKEY_EVENT_FLAG_FROM_SYSTEM, keyCode, scanCode, keyMetaState, downTime);//参数分析：//when对应eventTime, 其实是rawEvent->when，就是事件发生的时间//getDeviceId()对应deviceId, 返回的是设备id//mSource对应source,是KeyboardInputMapper初始化时赋值的//其值是INPUT_DEVICE_CLASS_KEYBOARD，INPUT_DEVICE_CLASS_DPAD从，INPUT_DEVICE_CLASS_GAMEPAD的某一个//policyFlags对应policyFlags值是策略标志//down ? AKEY_EVENT_ACTION_DOWN : AKEY_EVENT_ACTION_UP，对应action，描述按下或者抬起//AKEY_EVENT_FLAG_FROM_SYSTEM对应flag，表示此事件是系统信任的。//keyCode对应keyCode，虚拟健keycode//scanCode对应scanCode，扫描码//keyMetaState对应metaState，控制健的值，其可以表示控制键的按下或者抬起，此时值应该是0，代表无任何控制键按下//downTime对应按键按下的downTimegetListener()->notifyKey(&args);
}2.17 KeyboardInputMapper::process（同步消息）
//抬起时的第三条消息同步消息，也没派发
void KeyboardInputMapper::process(const RawEvent* rawEvent) {switch (rawEvent->type) {case EV_SYN: {if (rawEvent->code == SYN_REPORT) {mCurrentHidUsage = 0;}}}
}2.18 QueuedInputListener::flush
所以此时分发队列的线程中存在两个事件，一个是按下事件，一个是抬起事件。然后在InputReader::loopOnce函数会调用flush唤醒分发线程去处理。
/所以当一个按键按下抬起时，产生6个消息时，只有key事件会被加入队列派发。
void QueuedInputListener::flush() {size_t count = mArgsQueue.size();for (size_t i = 0; i < count; i++) {//从存储NotifyArgs的容器中循环取出并调用notifyNotifyArgs* args = mArgsQueue[i];args->notify(mInnerListener);//传入的参数mInnerListener是InputDispatcher类对象delete args;}mArgsQueue.clear();
}2.19 NotifyKeyArgs::notify
此时先查看第一个按下事件是如何处理的。
void NotifyKeyArgs::notify(const sp<InputListenerInterface>& listener) const {listener->notifyKey(this);//此处listener是InputDispatcher类对象，this是调用者也就是一个NotifyKeyArgs对象
}2.20 InputDispatcher::notifyKey
此函数的作用为：
1.首先通过NotifyKeyArgs生成KeyEvent事件，KeyEvent事件一般是上层最终消费的事件类型。
然后向ims询问此事件的发送策略，是否是PhoneWindowManager消费。因为有的按键不会派发给应用，如手机的开机按键，不需要派发给应用，是派发给PhoneWindowManager拦截消费的，如果此按键被拦截消费了，则不再派发给应用。
2.查询派发策略是派发给应用的后，通过NotifyKeyArgs生成KeyEntry事件，并将其放入分发队列的队尾。然后唤醒分发线程派发。
注意：此处是每个消息都会唤醒一次，故此时是按键按下事件会唤醒一次，然后按键抬起事件再唤醒一次。
//此时我们分析的是普通按键的发送，故先不分析如开关键等需要phoneManager消费的按键事件。
void InputDispatcher::notifyKey(const NotifyKeyArgs* args) {if (!validateKeyEvent(args->action)) {//验证keyEvent是否有效，主要是验证action是否等于按下或者抬起，//如果不是则数据无效，则返回return;}uint32_t policyFlags = args->policyFlags;//派发策略flagint32_t flags = args->flags;//此时flag是AKEY_EVENT_FLAG_FROM_SYSTEMint32_t metaState = args->metaState;//控制键按下或者抬起的信息policyFlags |= POLICY_FLAG_TRUSTED;//指示输入事件来自受信任的源，例如直接连接的输入设备int32_t keyCode = args->keyCode;KeyEvent event;//用NotifyKeyArgs初始化了KeyEvent，主要用于inputfiter，询问是否过滤//例如：有些需要phoneManager消费的按键，如手机的开关键等，会拦截发送给phoneManager系统event.initialize(args->deviceId, args->source, args->action,flags, keyCode, args->scanCode, metaState, 0,args->downTime, args->eventTime);android::base::Timer t;mPolicy->interceptKeyBeforeQueueing(&event, policyFlags);//向mPolicy询问派发策略if (t.duration() > SLOW_INTERCEPTION_THRESHOLD) {}bool needWake;{ // acquire lockmLock.lock();int32_t repeatCount = 0;KeyEntry* newEntry = new KeyEntry(args->eventTime,//用NotifyKeyArgs初始化了KeyEntryargs->deviceId, args->source, policyFlags,args->action, flags, keyCode, args->scanCode,metaState, repeatCount, args->downTime);needWake = enqueueInboundEventLocked(newEntry);//此函数会在内部将KeyEntry添加到mInboundqueue队列队尾，//并返回是否需要唤醒，如果是true，则唤醒dispatcher线程mLock.unlock();} // release lockif (needWake) {mLooper->wake();//唤醒分发线程。}
}static bool validateKeyEvent(int32_t action) {if (! isValidKeyAction(action)) {ALOGE("Key event has invalid action code 0x%x", action);return false;}return true;
}static bool isValidKeyAction(int32_t action) {switch (action) {case AKEY_EVENT_ACTION_DOWN:case AKEY_EVENT_ACTION_UP:return true;default:return false;}
}2.21 NativeInputManager::interceptKeyBeforeQueueing
此处主要作用为：
1.向IMS询问派发策略，最后其实是向PhoneWindowManager询问派发按键策略。
void NativeInputManager::interceptKeyBeforeQueueing(const KeyEvent* keyEvent, uint32_t& policyFlags) {ATRACE_CALL();bool interactive = mInteractive.load();//mInteractive是原子变量，所以需要用load。此时设备是否处于交互中if (interactive) {policyFlags |= POLICY_FLAG_INTERACTIVE;//指示截获事件时设备处于交互状态。}if ((policyFlags & POLICY_FLAG_TRUSTED)) {//如果policyFlags是受信任的nsecs_t when = keyEvent->getEventTime();JNIEnv* env = jniEnv();jobject keyEventObj = android_view_KeyEvent_fromNative(env, keyEvent);//通过jni用c++的keyevent形成一个java的keyeventjint wmActions;if (keyEventObj) {wmActions = env->CallIntMethod(mServiceObj,gServiceClassInfo.interceptKeyBeforeQueueing,keyEventObj, policyFlags);//调用了IMS中的interceptKeyBeforeQueueing方法if (checkAndClearExceptionFromCallback(env, "interceptKeyBeforeQueueing")) {wmActions = 0;}android_view_KeyEvent_recycle(env, keyEventObj);env->DeleteLocalRef(keyEventObj);} else {ALOGE("Failed to obtain key event object for interceptKeyBeforeQueueing.");wmActions = 0;}handleInterceptActions(wmActions, when, /*byref*/ policyFlags);//将wmActions策略添加给policyFlags} else {//如果policyFlags是不受信任的if (interactive) {policyFlags |= POLICY_FLAG_PASS_TO_USER;//则设备消息类型为发送给应用程序}}
}2.22 IMS中的interceptKeyBeforeQueueing
此时通过jni走到了IMS.java的interceptKeyBeforeQueueing函数。
此函数的作用是：
1.调用到WMS中的interceptKeyBeforeQueueing函数。其实现类是InputMonitor.java
//IMS.java
//派发给wms，查看是否将消息拦截，此处并不分析//派发给wms，查看是否将消息拦截
private int interceptKeyBeforeQueueing(KeyEvent event, int policyFlags) {return mWindowManagerCallbacks.interceptKeyBeforeQueueing(event, policyFlags);
}2.23 WMS中的interceptKeyBeforeQueueing
//此时已经到了WMS中，InputMonitor.JAVA中
public int interceptKeyBeforeQueueing(KeyEvent event, int policyFlags) {return mService.mPolicy.interceptKeyBeforeQueueing(event, policyFlags);
//是WindowManagerPolicy接口的函数，实现类是PhoneWindowManager}2.24 PhoneWindowManager中的interceptKeyBeforeQueueing
此函数的主要作用是：
1.如果是普通按键，则返回派发给应用程序的派发策略。
2.如果是特殊按键，如电源按键，会取消其派发给应用程序的策略。
//PhoneWindowManager.java
//此处代码太多，只看部分代码public int interceptKeyBeforeQueueing(KeyEvent event, int policyFlags) {final boolean interactive = (policyFlags & FLAG_INTERACTIVE) != 0; //interactive值是true，即应用正在和用户交互中final boolean down = event.getAction() == KeyEvent.ACTION_DOWN;//按下或抬起final boolean canceled = event.isCanceled();//是否取消falsefinal int keyCode = event.getKeyCode();final boolean isInjected = (policyFlags & WindowManagerPolicy.FLAG_INJECTED) != 0;//是否是注入的方式，是false// Basic policy based on interactive state.int result;boolean isWakeKey = (policyFlags & WindowManagerPolicy.FLAG_WAKE) != 0|| event.isWakeKey();//是否是唤醒按键，此时是falseif (interactive || (isInjected && !isWakeKey)) {//此处走这里，不是唤醒，且正在和用户交互result = ACTION_PASS_TO_USER;//发送给应用程序isWakeKey = false;if (interactive) {if (keyCode == mPendingWakeKey && !down) {result = 0;}// Reset the pending keymPendingWakeKey = PENDING_KEY_NULL;}}// 此处主要处理一些特殊按键，仅列出电源按键switch (keyCode) {/*case KeyEvent.KEYCODE_POWER: {// Any activity on the power button stops the accessibility shortcutcancelPendingAccessibilityShortcutAction();result &= ~ACTION_PASS_TO_USER;//可以看出如果是电源按键，则会取消派发给应用程序的ACTION_PASS_TO_USER标志isWakeKey = false; // wake-up will be handled separatelyif (down) {interceptPowerKeyDown(event, interactive);} else {interceptPowerKeyUp(event, interactive, canceled);}break;}*/}return result;//返回派发策略，此时是派发给应用程序}2.25 NativeInputManager::handleInterceptActions
1.主要是添加发送给应用的flag标志
void NativeInputManager::handleInterceptActions(jint wmActions, nsecs_t when,uint32_t& policyFlags) {if (wmActions & WM_ACTION_PASS_TO_USER) {//主要是给policyFlags添加派发给应用的flagpolicyFlags |= POLICY_FLAG_PASS_TO_USER;} else {}
}2.26 InputDispatcher::enqueueInboundEventLocked
此函数的主要作用是：
1.将EventEntry类型的消息放入队尾。
2.然后判断其是不是home按键，甚至最长相应home按键抬起的时间是0.5秒。因此假设应用卡住，那么用户会疯狂的按home按键，请求推出，如果home按键的响应时间过长，则用户体验会非常的差，因此必须在0.5秒内响应home按键。
bool InputDispatcher::enqueueInboundEventLocked(EventEntry* entry) {bool needWake = mInboundQueue.isEmpty();mInboundQueue.enqueueAtTail(entry);//将该事件放入mInboundQueue队列尾部traceInboundQueueLengthLocked();//追踪队列的长度switch (entry->type) {case EventEntry::TYPE_KEY: {//为HOME键或其他窗口上的点击事件提高响应速度的优化操作，这些所谓的优化操作可能会导致派发队列之前 //的所有事件被丢弃KeyEntry* keyEntry = static_cast<KeyEntry*>(entry);if (isAppSwitchKeyEventLocked(keyEntry)) {//判断是否是home键，如果是if (keyEntry->action == AKEY_EVENT_ACTION_DOWN) {//如果是home按键按下，则设置mAppSwitchSawKeyDown为truemAppSwitchSawKeyDown = true;} else if (keyEntry->action == AKEY_EVENT_ACTION_UP) {//如果是home按键抬起，则设置最迟响应home键的时间。if (mAppSwitchSawKeyDown) {mAppSwitchDueTime = keyEntry->eventTime + APP_SWITCH_TIMEOUT;//设置mAppSwitchDueTime时间//mAppSwitchDueTime代表了最近发生窗口切换操作（按home键）的最迟发送时间。APP_SWITCH_TIMEOUT值是0.5秒mAppSwitchSawKeyDown = false;needWake = true;//需要立即唤醒inputdispatcher线程去分发}}}break;}}return needWake;
}bool InputDispatcher::isAppSwitchKeyEventLocked(KeyEntry* keyEntry) {return ! (keyEntry->flags & AKEY_EVENT_FLAG_CANCELED)&& isAppSwitchKeyCode(keyEntry->keyCode)&& (keyEntry->policyFlags & POLICY_FLAG_TRUSTED)&& (keyEntry->policyFlags & POLICY_FLAG_PASS_TO_USER);
}bool InputDispatcher::isAppSwitchKeyCode(int32_t keyCode) {return keyCode == AKEYCODE_HOME //home按键|| keyCode == AKEYCODE_ENDCALL //挂机按键|| keyCode == AKEYCODE_APP_SWITCH; //app切换按键
}此时是按键按下事件的处理，接下来便是InputDispatcher线程篇的流程，请看【android 9】【input】【8.发送按键事件2——InputDispatcher线程】
我们继续看看按键抬起的事件处理。此时我们需要回到2.18节
2.27 NotifyKeyArgs::notify（抬起）
此时查看第二个抬起事件是如何处理的。其实抬起按键的处理和按下按键的处理基本相似，即从2.19----2.26节的流程，故此处不再赘述
void NotifyKeyArgs::notify(const sp<InputListenerInterface>& listener) const {listener->notifyKey(this);//此处listener是InputDispatcher类对象，this是调用者也就是一个NotifyKeyArgs对象
}此篇我们主要介绍了普通按键事件的inputreader线程是如何处理的，下一篇我将描述
InputDispatcher线程是如何派发处理的。