Input系统之InputReader处理按键事件详解

前言

前面几篇文章已经为 Input 系统的分析打好了基础，现在是时候进行更深入的分析了。

通常，手机是不带键盘的，但是手机上仍然有按键，就是我们经常使用的电源键以及音量键。因此还是有必要分析按键事件的处理流程。

那么，掌握按键事件的处理流程，对我们有什么用处呢？例如，手机上添加了一个功能按键，你知道如何把这个物理按键映射到上层，然后处理这个按键吗？又例如，如果设备是不需要电源键，但是系统默认把某一个按键映射为电源键，那么我们如何使这个按键不成为电源键呢？所有这一切，都与按键事件的处理流程相关。

认识按键事件

很多读者可能还不知道按键事件到底长什么样，通过 adb shell getevent 可以获取输入设备产生的元输入事件，按键事件当然也包括在内。

当按下电源键，可以产生如下的按键事件

/dev/input/event0: 0001 0074 00000001
/dev/input/event0: 0000 0000 00000000
/dev/input/event0: 0001 0074 00000000
/dev/input/event0: 0000 0000 00000000

/dev/input/event0 是内核为输入设备生成的设备文件，它代表一个输入设备，它后面的数据格式为 type code value。

以第一行为例，几个数据的含义如下

• 0001 代表输入设备产生事件的类型。此时电源键产生的是一个按键类型事件，而如果手指在触摸设备上滑动，产生是一个坐标类型事件。

• 0074 表示按键的扫描码(code)，这个扫描码是与输入设备相关，因此不同的设备上的电源键，产生的扫描码可能不同。

• 00000001 表示按键值(value)。 00000001 表示按键被按下，00000000 表示按键抬起。

因此，一个输入设备产生的事件，可以通过 type + code + value 的形式表示。

注意，以上这些数据都是元输入事件的数据，是由内核直接为输入设备生成的数据，因此读起来没那么直观。我们可以通过 adb shell getevent -l 显示输入系统对这些数据的分析结果，当按下电源键，会出现如下结果

/dev/input/event0: EV_KEY       KEY_POWER            DOWN     
/dev/input/event0: EV_SYN       SYN_REPORT           00000000 
/dev/input/event0: EV_KEY       KEY_POWER            UP
/dev/input/event0: EV_SYN       SYN_REPORT           00000000

第一行数据，EV_KEY + KEY_POWER + DOWN 表示电源键按下。

第三行数据，EV_KEY + KEY_POWER + UP 表示电源键抬起。

第二行和第四行的数据，EV_SYN + SYN_REPORT 表示之前的一个事件的数据已经发送完毕，需要系统同步之前一个事件的所有数据。对于一个按键，一个事件只有一条数据，然而对于触摸板上的滑动事件，例如手指按下事件，它的数据可不止一条，我们将在后面的文章中看到。

好，既然已经以按键事件的数据有了基本的认识，那么接下来开始着手分析按键事件的处理流程。

处理按键事件

从前面文章可知，InputReader 从 EventHub 中获取了输入事件的数据，然后调用如下函数进行处理

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 (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;
           }
           // 批量处理同一个设备的元输入事件
           processEventsForDeviceLocked(deviceId, rawEvent, batchSize);
       } else {
           // ...
       }
       count -= batchSize;
       rawEvent += batchSize;
   }
}
void InputReader::processEventsForDeviceLocked(int32_t eventHubId, const RawEvent* rawEvents,
                                              size_t count) {
   auto deviceIt = mDevices.find(eventHubId);
   if (deviceIt == mDevices.end()) {
       return;
   }
   std::shared_ptr<InputDevice>& device = deviceIt->second;
   // 如果 InputDevice 没有 InputMapper，那么它不能处理事件
   if (device->isIgnored()) {
       return;
   }
   // InputDevice 批量处理元输入事件
   device->process(rawEvents, count);
}

InputReader 首先找到属于同一个设备的多个事件，然后交给 InputDevice 进行批量处理

// frameworks/native/services/inputflinger/reader/InputDevice.cpp
void InputDevice::process(const RawEvent* rawEvents, size_t count) {
   // 虽然 InputReader 把批量的事件交给 InputDevice，但是 InputDevice 还是逐个处理事件
   for (const RawEvent* rawEvent = rawEvents; count != 0; rawEvent++) {
       if (mDropUntilNextSync) {
           if (rawEvent->type == EV_SYN && rawEvent->code == SYN_REPORT) {
               mDropUntilNextSync = false;
           }
       } else if (rawEvent->type == EV_SYN && rawEvent->code == SYN_DROPPED) {
           // EV_SYN + SYN_DROPPED 表明要丢弃后面的事件，直到 EV_SYN + SYN_REPORT
           mDropUntilNextSync = true;
           reset(rawEvent->when);
       } else {
           // 每一个事件交给 InputMapper 处理
           for_each_mapper_in_subdevice(rawEvent->deviceId, [rawEvent](InputMapper& mapper) {
               mapper.process(rawEvent);
           });
       }
       --count;
   }
}

虽然 InputReader 把事件交给 InputDevice 进行批量处理，但是 InputDevice 是逐个把事件交给它的 InputMapper 处理。

对于键盘类型的输入设备，它的 InputMapper 实现类为 KeyboardInputMapper，它对按键事件处理如下

void KeyboardInputMapper::process(const RawEvent* rawEvent) {
   switch (rawEvent->type) {
       // 处理 EV_KEY
       case EV_KEY: {
           int32_t scanCode = rawEvent->code;
           int32_t usageCode = mCurrentHidUsage;
           mCurrentHidUsage = 0;
           if (isKeyboardOrGamepadKey(scanCode)) {
               // 注意第三个参数，value等于0，才表示按键down， 也就是说，value 为1， 表示按键被按下
               processKey(rawEvent->when, rawEvent->readTime, rawEvent->value != 0, scanCode,
                          usageCode);
           }
           break;
       }
       case EV_MSC: {
           // ...
       }
       // 处理 EV_SYN + SYN_REPORT
       case EV_SYN: {
           if (rawEvent->code == SYN_REPORT) {
               mCurrentHidUsage = 0;
           }
       }
   }
}

其中，我们只需要关心类型为 EV_KEY 类型的事件，它表示一个按键事件，它的处理如下

void KeyboardInputMapper::processKey(nsecs_t when, nsecs_t readTime, bool down, int32_t scanCode,
                                    int32_t usageCode) {
   int32_t keyCode;
   int32_t keyMetaState;
   uint32_t policyFlags;
   // 1. 根据键盘配置文件，把 scanCode 转化为 keycode，并获取 flags
   if (getDeviceContext().mapKey(scanCode, usageCode, mMetaState, &keyCode, &keyMetaState,
                                 &policyFlags)) {
       keyCode = AKEYCODE_UNKNOWN;
       keyMetaState = mMetaState;
       policyFlags = 0;
   }
   // 按下
   if (down) {
       // 根据屏幕方向，再次转换 keyCode
       // Rotate key codes according to orientation if needed.
       if (mParameters.orientationAware) {
           keyCode = rotateKeyCode(keyCode, getOrientation());
       }
       // Add key down.
       ssize_t keyDownIndex = findKeyDown(scanCode);
       if (keyDownIndex >= 0) {
           // key repeat, be sure to use same keycode as before in case of rotation
           keyCode = mKeyDowns[keyDownIndex].keyCode;
       } else {
           // key down
           if ((policyFlags & POLICY_FLAG_VIRTUAL) &&
               getContext()->shouldDropVirtualKey(when, keyCode, scanCode)) {
               return;
           }
           if (policyFlags & POLICY_FLAG_GESTURE) {
               // 如果设备通知支持触摸，那么发送一个 ACTION_CANCEL 事件
               getDeviceContext().cancelTouch(when, readTime);
           }
           KeyDown keyDown;
           keyDown.keyCode = keyCode;
           keyDown.scanCode = scanCode;
           // 保存按下的按键
           mKeyDowns.push_back(keyDown);
       }
       mDownTime = when;
   } else { // 抬起按键
       // Remove key down.
       ssize_t keyDownIndex = findKeyDown(scanCode);
       if (keyDownIndex >= 0) {
           // key up, be sure to use same keycode as before in case of rotation
           keyCode = mKeyDowns[keyDownIndex].keyCode;
           // 移除
           mKeyDowns.erase(mKeyDowns.begin() + (size_t)keyDownIndex);
       } else {
           // key was not actually down
           ALOGI("Dropping key up from device ％s because the key was not down.  "
                 "keyCode=％d, scanCode=％d",
                 getDeviceName().c_str(), keyCode, scanCode);
           return;
       }
   }
   // 更新meta状态
   if (updateMetaStateIfNeeded(keyCode, down)) {
       // If global meta state changed send it along with the key.
       // If it has not changed then we'll use what keymap gave us,
       // since key replacement logic might temporarily reset a few
       // meta bits for given key.
       keyMetaState = mMetaState;
   }
   nsecs_t downTime = mDownTime;
   // 外部设备的按键按下时，添加唤醒标志位
   if (down && getDeviceContext().isExternal() && !mParameters.doNotWakeByDefault &&
       !isMediaKey(keyCode)) {
       policyFlags |= POLICY_FLAG_WAKE;
   }
   // 设备是否能生成重复按键事件，一般设备都不支持这个功能
   // 而是由系统模拟生成重复按键事件
   if (mParameters.handlesKeyRepeat) {
       policyFlags |= POLICY_FLAG_DISABLE_KEY_REPEAT;
   }
   // 2. 生成 NotifyKeyArgs, 并加到 QueuedInputListener 队列中
   NotifyKeyArgs args(getContext()->getNextId(), when, readTime, getDeviceId(), mSource,
                      getDisplayId(), policyFlags,
                      down ? AKEY_EVENT_ACTION_DOWN : AKEY_EVENT_ACTION_UP/*action*/,
                      AKEY_EVENT_FLAG_FROM_SYSTEM/*flags*/, keyCode, scanCode, keyMetaState, downTime);
   getListener()->notifyKey(&args);
}

我现在只关心手机上电源键以及音量键的处理流程，因此这里的处理过程主要分为两步

• 根据按键配置文件，把扫描码(scan code)转换为按键码(key code)，并从配置文件中获取策略标志位(policy flag)。不同的输入设备的同一种功能的按键，例如电源键，产生的扫描码不一定都相同，Android 系统需要把扫描码映射为同一个按键码进行处理。

• 创建一个事件 NotifyKeyArgs，并加入到 QueuedInputListener 队列中。从前面的文章可知，当 InputReader 处理完从 EventHub 读到的事件后，会刷新这个队列，从而把事件发送给 InputClassifier。而对于按键事件，InputClassifier 不做任何加工，直接把事件传递给 InputDispatcher。

现在只要知道如何把一个按键的扫描码映射为按键码，InputReader 处理按键事件的整个流程都一清二楚了。

扫描码映射按键码

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 {
   std::scoped_lock _l(mLock);
   Device* device = getDeviceLocked(deviceId);
   status_t status = NAME_NOT_FOUND;
   if (device != nullptr) {
       // Check the key character map first.
       const std::shared_ptr<KeyCharacterMap> kcm = device->getKeyCharacterMap();
       if (kcm) {
           // 1. KeyCharacterMapFile :转换 scanCode 为 keyCode
           if (!kcm->mapKey(scanCode, usageCode, outKeycode)) {
               *outFlags = 0;
               status = NO_ERROR;
           }
       }
       // Check the key layout next.
       if (status != NO_ERROR && device->keyMap.haveKeyLayout()) {
           // 2. KeyLayoutFile: 把 scanCode 转换为 keycode
           if (!device->keyMap.keyLayoutMap->mapKey(scanCode, usageCode, outKeycode, outFlags)) {
               status = NO_ERROR;
           }
       }
       if (status == NO_ERROR) {
           if (kcm) {
               // 3. KeyCharacterMapFile: 根据meta按键状态，重新映射按键字符
               kcm->tryRemapKey(*outKeycode, metaState, outKeycode, outMetaState);
           } else {
               *outMetaState = metaState;
           }
       }
   }
   if (status != NO_ERROR) {
       *outKeycode = 0;
       *outFlags = 0;
       *outMetaState = metaState;
   }
   return status;
}

扫描码转化为按键码的过程有点小复杂

• 首先根据 kcm(key character map) 文件进行转换。

• 如果第一步失败，那么根据 kl(key layout) 文件进行转换。

• 如果前两步，有一个成功，那么再根据meta按键状态，重新使用 kcm 文件对按键码再次进行转换。这个只对键盘起作用，例如按下 shift ，再按字母键，那么会产生大写的字母的按键码。而对于电源键和音量键，此步骤可以忽略。

可以发现，kcm 和 kl 文件都可以把按键的扫描码进行转换为按键码，然而 kcm 文件一般都只是针对键盘按键，而对于电源键和音量键，一般都是通过 kl 文件进行转换的。

那么如何找到输入设备的 kl 文件呢？前面通过 adb shell getevent 可以发现输入设备的文件节点为 /dev/input/event0，再通过 adb shell dumpsys input 导出所有设备的信息，就可以找到电源键属于哪个设备，以及设备的的按键配置文件

6: qpnp_pon
     Classes: KEYBOARD
     Path: /dev/input/event0
     Enabled: true
     Descriptor: fb60d4f4370f5dbe8267b63d38dea852987571ab
     Location: qpnp_pon/input0
     ControllerNumber: 0
     UniqueId:
     Identifier: bus=0x0000, vendor=0x0000, product=0x0000, version=0x0000
     KeyLayoutFile: /system/usr/keylayout/Generic.kl
     KeyCharacterMapFile: /system/usr/keychars/Generic.kcm
     ConfigurationFile:
     VideoDevice: <none>

从这个信息就可以看出，输入设备的 kl 文件为 /system/usr/keylayout/Generic.kl，它的电源键映射如下

key 116   POWER

其中，116是十进制，它的十六进制为 0x74，正好就是 adb shell getevent 显示的电源按键的扫描码。

POWER 就是被映射成的按键码，但是它是一个字符，而实际使用的是 int 类型，这个关系的映射是在下面定义的

// frameworks/native/include/android/keycodes.h
/**
* Key codes.
*/
enum {
AKEYCODE_POWER = 26,
}

因此，电源按键的扫描码 0x74，被映射为按键码 26，正好就是上层 KeyEvent.java 定义的电源按键值

// frameworks/base/core/java/android/view/KeyEvent.java
public static final int KEYCODE_POWER           = 26;

在很早的 Android 版本上，配置文件中，电源键还会定义一个策略标志位，如下

key 116   POWER WAKE

其中，WAKE 就是一个策略标志位，在把扫描转换为按键码时，这个策略标志位也会被解析，它表示需要唤醒设备，上层会根据这个标志位，让设备唤醒。

结束

InputReader 处理按键事件的过程其实很简单，就是把按键事件交给 KeyboardInputMapper 处理，KeyboardInputMapper 根据配置文件，把按键的扫描码转换为按键码，并同时从配置文件中获取策略标志位，然后把这些信息包装成一个事件，发送到下一环。

现在，如果项目上让你完成功能按键的映射，或者解除某个按键的电源功能，你会了吗？

来源：https://juejin.cn/post/7168875586826764318