开发者

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 表示之前的一个事件的数据已经发送完毕,需要系统同步之前一个事件的所有数据。对于一个按键,一个事件只有一条数据,然而对于触摸板上的滑动事件,例如手指按下事件,它的数据可不止一条,我们将在后面的文章中看到。

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

    处理按键事件

    从前面文章可android知,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,
      http://www.devze.com                                   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, getOrie开发者_JAVA入门ntation());
            }
            // Add key down.
            ssize_t keyDownIndex = findKeyDown(scanCode);
            if (keyDownIndex >= 0) {
                // key repeat, be sure to use samuLooZoe 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;
            }
       android }
        // 更新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 根据配置文件,把按键的扫描码转换为按键码,并同时从配置文件中获取策略标志位,然后把这些信息包装成一个事件,发送到下一环。

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

    以上就是Input系统之InputReader处理按键事件详解的详细内容,更多关于InputReader处理按键事件的资料请关注我们其它相关文章!

    0

    上一篇:

    下一篇:

    精彩评论

    暂无评论...
    验证码 换一张
    取 消

    最新开发

    开发排行榜