Android Framework重要服务之InputManagerService(二) inputReader

已于 2024-03-01 21:50:29 修改
阅读量487 收藏 3
点赞数 1
分类专栏： Android开发 Framework 文章标签： android 驱动开发
于 2022-05-31 22:02:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Code1994/article/details/125074330
版权

本章将继续探究InputReader线程，该线程负责从eventhub获取事件，转换成EventEntry事件并将事件加入到InputDispatcher的mInboundQueue。

threadLoop

InputReaderThread线程启动后，将调用一个thredLoop方法，该方法不断从eventhub获取事件，并进行后续处理，相关代码位于frameworks/native/services/inputflinger/reader/InputReader.cpp:

// 启动InputReader，调用loopOnce
status_t InputReader::start() {
    if (mThread) {
        return ALREADY_EXISTS;
    }
    mThread = std::make_unique<InputThread>(
            "InputReader", [this]() { loopOnce(); }, [this]() { mEventHub->wake(); });
    return OK;
}

void InputReader::loopOnce() {
    ...
    
    // 从eventhub获取事件(EVENT_BUFFER_SIZE = 256)
    size_t count = mEventHub->getEvents(timeoutMillis, mEventBuffer, EVENT_BUFFER_SIZE);
 
    {
        AutoMutex _l(mLock);
        mReaderIsAliveCondition.broadcast();
 
        if (count) {
            // 处理事件
            processEventsLocked(mEventBuffer, count);   
        }
        ...
        
        // 如果输入设备发生改变，则重新获取当前输入设备
        if (oldGeneration != mGeneration) {
            inputDevicesChanged = true;
            getInputDevicesLocked(inputDevices);
        }
    } // release lock
 
    // 发送输入设备改变的通知
    if (inputDevicesChanged) {
        mPolicy->notifyInputDevicesChanged(inputDevices);
    }
 
    // 发送事件到nputDispatcher
    mQueuedListener->flush();  
}

在上述代码中，有三个关键节点需要重点关注，他们分别是:mEventHub->getEvents,processEventsLocked,mQueuedListener->flush,下面将重点介绍下这几个方法。

mEventHub->getEvents [获取事件]

getEvents方法主要负责获取kernel的event, 这里事件不仅包括input，还包括输入设备的add/remove等相关事件。
加入的输入设备在没有事件的时候，会block在EventHub中的epoll处，当有事件产生后，epoll_wait就会返回，然后针对变化的事件进行处理。相关代码位于frameworks/native/services/inputflinger/reader/EventHub.cpp:

size_t EventHub::getEvents(int timeoutMillis, RawEvent* buffer, size_t bufferSize) {
    ...
    
    for (;;) {
        nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
        // 扫描设备
        if (mNeedToScanDevices) {
            mNeedToScanDevices = false;
            scanDevicesLocked();   
            mNeedToSendFinishedDeviceScan = true;
        }
 
        while (mOpeningDevices != NULL) {
            Device* device = mOpeningDevices;
            ALOGV("Reporting device opened: id=%d, name=%s\n",
                 device->id, device->path.string());
            mOpeningDevices = device->next;
            event->when = now;
            event->deviceId = device->id == mBuiltInKeyboardId ? 0 : device->id;
            // 添加设备事件
            event->type = DEVICE_ADDED;  
            event += 1;
        }
            ...
            
            Device* device = mDevices.valueAt(deviceIndex);
            if (eventItem.events & EPOLLIN) {
            // 从设备读取事件，放入到readBuffer
                int32_t readSize = read(device->fd, readBuffer,
                        sizeof(struct input_event) * capacity);
                    int32_t deviceId = device->id == mBuiltInKeyboardId ? 0 : device->id;
 
                    size_t count = size_t(readSize) / sizeof(struct input_event);
                    for (size_t i = 0; i < count; i++) {
                        // 读取事件
                        struct input_event& iev = readBuffer[i];  
                        // 将input_event信息封装成RawEvent
                        event->when = processEventTimestamp(iev);
                        event->readTime = systemTime(SYSTEM_TIME_MONOTONIC);
                        event->deviceId = deviceId;
                        event->type = iev.type;
                        event->code = iev.code;
                        event->value = iev.value;
                        event += 1;
                        capacity -= 1;
                    }
 
                }
            ...
        }
                mLock.unlock(); // release lock before poll, must be before release_wake_lock
        release_wake_lock(WAKE_LOCK_ID);
 
        //poll之前先释放锁 等待input事件的到来
        int pollResult = epoll_wait(mEpollFd, mPendingEventItems, EPOLL_MAX_EVENTS, timeoutMillis);
 
        acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_ID);
 
        } else {
            // Some events occurred.
            mPendingEventCount = size_t(pollResult);
        }
    }
 
    // All done, return the number of events we read.
    return event - buffer;
}

EventHub采用INotify + epoll机制实现监听目录/dev/input下的设备节点，经过EventHub将input_event结构体 + deviceId 转换成RawEvent结构体，RawEvent结构体的声明位于frameworks/native/services/inputflinger/reader/include/EventHub.h,其结构如下：

RawEvent mEventBuffer[EVENT_BUFFER_SIZE];

struct RawEvent {
    // Time when the event happened
    nsecs_t when;
    // Time when the event was read by EventHub. Only populated for input events.
    // For other events (device added/removed/etc), this value is undefined and should not be read.
    nsecs_t readTime;
    int32_t deviceId;
    int32_t type;
    int32_t code;
    int32_t value;
};
 
struct input_event {
 struct timeval time; //事件发生的时间点
 __u16 type;
 __u16 code;
 __s32 value;
    };

processEventsLocked [处理事件]

processEventsLocked方法负责设备的添加、移除与删除，以及事件的处理，相关代码位于frameworks/av/media/libstrming/input/key_injector.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 (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 {
            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;
    }
}

processEventsForDeviceLocked

processEventsForDeviceLocked方法用于处理输入设备事件，更具体的来说，是对输入事件的相关信息进行核验，该方法位于frameworks/native/services/inputflinger/reader/InputReader.cpp:

void InputReader::processEventsForDeviceLocked(int32_t eventHubId, const RawEvent* rawEvents,
                                               size_t count) {
    // 使用eventHubId查找是哪一个设备发送的事件
    auto deviceIt = mDevices.find(eventHubId);
    if (deviceIt == mDevices.end()) {
        ALOGW("Discarding event for unknown eventHubId %d.", eventHubId);
        return;
    }

    std::shared_ptr<InputDevice>& device = deviceIt->second;
    if (device->isIgnored()) {
        // ALOGD("Discarding event for ignored deviceId %d.", deviceId);
        return;
    }

    device->process(rawEvents, count);
}

InputDevice::process

InputDevice::process方法负责将输入事件进行映射处理，按设备顺序处理所有事件,这是因为每个设备处理之间可能有依赖关系。相关代码位于frameworks/native/services/inputflinger/reader/InputDevice.cpp:

void InputDevice::process(const RawEvent* rawEvents, size_t count) {
    for (const RawEvent* rawEvent = rawEvents; count != 0; rawEvent++) {
        if (mDropUntilNextSync) {
            if (rawEvent->type == EV_SYN && rawEvent->code == SYN_REPORT) {
                // 处理事件上报
                mDropUntilNextSync = false;
            } else {
                ...
                
            }
        } else if (rawEvent->type == EV_SYN && rawEvent->code == SYN_DROPPED) {
            // 处理事件取消
            ALOGI("Detected input event buffer overrun for device %s.", getName().c_str());
            mDropUntilNextSync = true;
            reset(rawEvent->when);
        } else {
            // 根据事件类型进行相关处理
            for_each_mapper_in_subdevice(rawEvent->deviceId, [rawEvent](InputMapper& mapper) {
                mapper.process(rawEvent);
            });
        }
        --count;
    }
}

KeyboardInputMapper::process

上面提到InputDevice::process方法会使用不同的处理方式处理输入事件，这些事件包括但不限于触控事件、键盘事件、传感器事件等等,总结下来共有以下几种处理方法

class SwitchInputMapper : public InputMapper {
class VibratorInputMapper : public InputMapper {
class KeyboardInputMapper : public InputMapper {
class CursorInputMapper : public InputMapper {
class RotaryEncoderInputMapper : public InputMapper {
class TouchInputMapper : public InputMapper {
class ExternalStylusInputMapper : public InputMapper {
class JoystickInputMapper : public InputMapper {

在这其中，键盘事件处理最为简单，也最容易分析，触控事件最复杂，所以这里以键盘事件为例进行分析，相关代码位于frameworks/native/services/inputflinger/reader/mapper/KeyboardInputMapper.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)) {
                processKey(rawEvent->when, rawEvent->readTime, 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;
            }
        }
    }
}

KeyboardInputMapper::processKey

KeyboardInputMapper::processKey方法用于处理按键相关事件，相关代码位于frameworks/native/services/inputflinger/reader/mapper/KeyboardInputMapper.cpp:

void KeyboardInputMapper::processKey(nsecs_t when, bool down, int32_t scanCode,
        int32_t usageCode) {
    int32_t keyCode;
    int32_t keyMetaState;
    uint32_t policyFlags;
 
    // 将事件的扫描码(scanCode)转换成键盘码(Keycode)
    if (getEventHub()->mapKey(getDeviceId(), scanCode, usageCode, mMetaState,
                              &keyCode, &keyMetaState, &policyFlags)) {
        keyCode = AKEYCODE_UNKNOWN;
        keyMetaState = mMetaState;
        policyFlags = 0;
    }
 
    if (down) {
        ...
    
        mDownTime = when;
    } else {
        ...
        
    }
    // 创建NotifyKeyArgs对象, when记录eventTime, downTime记录按下时间
    NotifyKeyArgs args(when, getDeviceId(), mSource, policyFlags,
            down ? AKEY_EVENT_ACTION_DOWN : AKEY_EVENT_ACTION_UP,
            AKEY_EVENT_FLAG_FROM_SYSTEM, keyCode, scanCode, keyMetaState, downTime);
    
     // 发送key事件
    getListener()->notifyKey(&args); 
}

EventHub::mapKey

EventHub::mapKey负责将事件的扫描码(scanCode)转换成键盘码(Keycode)，相关代码位于frameworks/native/services/inputflinger/reader/EventHub.cpp:

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) {
            if (!kcm->mapKey(scanCode, 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)) {
                status = NO_ERROR;
            }
        }

        if (status == NO_ERROR) {
            if (kcm) {
                kcm->tryRemapKey(*outKeycode, metaState, outKeycode, outMetaState);
            } else {
                *outMetaState = metaState;
            }
        }
    }

    if (status != NO_ERROR) {
        *outKeycode = 0;
        *outFlags = 0;
        *outMetaState = metaState;
    }

    return status;
}

文末

要想成为架构师，那就不要局限在编码，业务，要会选型、扩展，提升编程思维。此外，良好的职业规划也很重要，学习的习惯很重要，但是最重要的还是要能持之以恒，任何不能坚持落实的计划都是空谈。

如果你没有方向，这里给大家分享一套由阿里高级架构师编写的《Android八大模块进阶笔记》，帮大家将杂乱、零散、碎片化的知识进行体系化的整理，让大家系统而高效地掌握Android开发的各个知识点。

![在这里插入图片描述](https://img-blog.csdnimg.cn/06e41b3932164f0db07014d54e6e5626.png) 相对于我们平时看的碎片化内容，这份笔记的知识点更系统化，更容易理解和记忆，是严格按照知识体系编排的。

一、架构师筑基必备技能

1、深入理解Java泛型
2、注解深入浅出
3、并发编程
4、数据传输与序列化
5、Java虚拟机原理
6、高效IO
……

在这里插入图片描述

二、Android百大框架源码解析

1.Retrofit 2.0源码解析
2.Okhttp3源码解析
3.ButterKnife源码解析
4.MPAndroidChart 源码解析
5.Glide源码解析
6.Leakcanary 源码解析
7.Universal-lmage-Loader源码解析
8.EventBus 3.0源码解析
9.zxing源码分析
10.Picasso源码解析
11.LottieAndroid使用详解及源码解析
12.Fresco 源码分析——图片加载流程

在这里插入图片描述

三、Android性能优化实战解析

  • 腾讯Bugly:对字符串匹配算法的一点理解
  • 爱奇艺：安卓APP崩溃捕获方案——xCrash
  • 字节跳动：深入理解Gradle框架之一：Plugin, Extension, buildSrc
  • 百度APP技术：Android H5首屏优化实践
  • 支付宝客户端架构解析：Android 客户端启动速度优化之「垃圾回收」
  • 携程：从智行 Android 项目看组件化架构实践
  • 网易新闻构建优化：如何让你的构建速度“势如闪电”？
  • …

在这里插入图片描述

四、高级kotlin强化实战

1、Kotlin入门教程
2、Kotlin 实战避坑指南
3、项目实战《Kotlin Jetpack 实战》

  • 从一个膜拜大神的 Demo 开始

  • Kotlin 写 Gradle 脚本是一种什么体验？

  • Kotlin 编程的三重境界

  • Kotlin 高阶函数

  • Kotlin 泛型

  • Kotlin 扩展

  • Kotlin 委托

  • 协程“不为人知”的调试技巧

  • 图解协程：suspend

在这里插入图片描述

五、Android高级UI开源框架进阶解密

1.SmartRefreshLayout的使用
2.Android之PullToRefresh控件源码解析
3.Android-PullToRefresh下拉刷新库基本用法
4.LoadSir-高效易用的加载反馈页管理框架
5.Android通用LoadingView加载框架详解
6.MPAndroidChart实现LineChart（折线图）
7.hellocharts-android使用指南
8.SmartTable使用指南
9.开源项目android-uitableview介绍
10.ExcelPanel 使用指南
11.Android开源项目SlidingMenu深切解析
12.MaterialDrawer使用指南
在这里插入图片描述

六、NDK模块开发

1、NDK 模块开发
2、JNI 模块
3、Native 开发工具
4、Linux 编程
5、底层图片处理
6、音视频开发
7、机器学习

在这里插入图片描述

七、Flutter技术进阶

1、Flutter跨平台开发概述
2、Windows中Flutter开发环境搭建
3、编写你的第一个Flutter APP
4、Flutter开发环境搭建和调试
5、Dart语法篇之基础语法(一)
6、Dart语法篇之集合的使用与源码解析(二)
7、Dart语法篇之集合操作符函数与源码分析(三)
…
在这里插入图片描述

八、微信小程序开发

1、小程序概述及入门
2、小程序UI开发
3、API操作
4、购物商场项目实战……

在这里插入图片描述

全套视频资料：

一、面试合集
在这里插入图片描述
二、源码解析合集

在这里插入图片描述
三、开源框架合集

在这里插入图片描述
欢迎大家一键三连支持，若需要文中资料，直接点击文末CSDN官方认证微信卡片免费领取【保证100%免费】↓↓↓

Code1994
关注
专栏目录
Android input系统.pdf
07-24
InputReader.cpp : 负责从硬件获取输入, 转换成事件（Event), 并分发给Input Dispatcher.  InputDispatcher.cpp : 将Input Reader传送过来的Events 通过socket分发给合适的窗口, 并监控ANR.  ...
Android Framework重要服务之InputManagerService(一) 启动流程
Code1994的博客
05-28 1189
InputManagerService(输入管理服务)简称IMS，在安卓系统中负责它管理整个系统的输入部分，包括键盘、鼠标、触摸屏等等，它与WindowManager密切相关，本章将结合安卓11源码梳理IMS的启动流程。 一、启动IMS服务 IMS启动流程位于frameworks/base/services/java/com/android/server/SystemServer.java，相关代码如下： private void startOtherServices(@NonNull TimingsTra
【Android Framework (十一) 】- InputManagerService
不靠谱先森的博客
07-04 603
InputManagerService是一个系统服务，主要处理Input事件的传递，包括键盘、鼠标、触摸屏等等，它和WMS密切相关。
input系统之InputReader
最新发布
今天也是星期五的博客
08-14 843
可以看出InputReader处理事件的流程为：（1）调用EventHub的getEvents方法获取输入事件（2）调用processEventsLocked()方法处理获取到的输入事件（3）调用flush()方法将已经封装好的EventEntry事件交给给InputDispatcher分发。
十分钟了解Android触摸事件原理（InputManagerService）
weixin_34266504的博客
12-07 756
从手指接触屏幕到MotionEvent被传送到Activity或者View，中间究竟经历了什么？Android中触摸事件到底是怎么来的呢？源头是哪呢？本文就直观的描述一个整个流程，不求甚解，只求了解。 Android触摸事件模型 触摸事件肯定要先捕获才能传给窗口，因此，首先应该有一个线程在不断的监听屏幕，一旦有触摸事件，就将事件捕获；其次，还应该存在某种手段可以找到目标窗口，因为可能有多个APP的...
【Android】图文解密Android InputManagerService
Making Life Better. Making Others Better.
02-12 763
【Android】图文解密Android InputManagerService
Android InputManagerService分析(基于Android 8.0)
he980725866的博客
09-12 1005
InputManagerService
Android之Input子系统事件分发流程 - CSDN博客1
08-04
本文将深入探讨Android Input子系统的事件分发流程，帮助开发者理解这一复杂而重要的过程。 首先，让我们从ViewRootImpl类的setView方法开始。这个方法在为一个新视图设置根视图时被调用。在步骤2，`new Input...
Linux_Android——输入子系统input_event传递 (二) - CSDN博客1
08-04
【Linux/Android 输入子系统input_event传递 (二)】 在Linux和Android系统中，输入子系统扮演着至关重要的角色，它负责处理来自各种输入设备（如键盘、鼠标、触摸屏等）的事件，并将这些事件转发给用户空间的应用...
Android 按键消息流程源码分析
05-08
- **InputDispatcher与InputReader的创建**：`InputManager`的构造函数中创建了`InputDispatcher`和`InputReader`。 - **线程的创建**：通过调用`initialize`函数创建了`InputReaderThread`和`InputDispatcherThread...
Android Linux内核的input子系统
10-26
在Android操作系统中，输入设备的管理与处理是至关重要的，而这一切的核心就是Linux内核的input子系统。这个子系统旨在支持Linux中的各种输入设备，如键盘、触摸屏、鼠标等。本文将深入探讨input子系统的结构、功能...
Android Touch事件InputManagerService源码解析（二）
qq_28284547的博客
09-12 332
我们的设备在显示的时候其实是有多个窗口叠在一起的，最常见的就是Activity，每一个Activity都有一个window，状态栏、下拉栏、一个透明的Activity悬浮在另一个页面上、通过WindowManger添加View等。InputReader不停的从底层读取事件发送给InputDispatcher，InputDispatcher内有一个线程，当有新的事件的时候会从休眠中唤醒调用dispatchOnce。但是这是触摸事件的消费处理过程，有没有想过touch事件是由谁产生，又是如何传递给View的。
Android R input (一) 之 InputManagerService 的建立
pecuyu
10-23 1560
文章托管在gitee上 Android Notes , 同步csdn InputManagerService 介绍 InputManagerService是重要的系统服务,负责Android输入系统的管理,职责包括但不限于: 输入设备的管理 输入事件的加工m 输入事件的派发与反馈 输入事件的派发ANR的检测 常见的输入设备是触摸屏/按键,其他支持的设备还有键盘,鼠标等. 当有新输入设备可用时，Linux内核会在/dev/input/下创建对应的名称类似eventX(X>=0)的设备节点。当输入.
Android InputManagerService的创建和启动
xiaokangss的博客
03-18 988
Android输入系统分为Java和Native部分，其中初始化是从Java部分开始的，然后再完成Native部分的初始化。
Android_input系统分析InputReader
c++ 中的符号->
09-16 508
之前分析说getEvent()返回原始结果到InputReader,今天针对InputReader对getevent返回的结果进行分析: 首先我们看看InputReader在哪里调用getEvent()方法. void InputReader::loopOnce() { ... { // acquire lock AutoMutex _l(mLock); ...
Android 12.0源码系列之IMS（一）InputManagerService
weixin_44901612的博客
01-30 941
Android 12.0源码系列之IMS（一）InputManagerService 本篇涉及到的主要代码： frameworks\base\services\core\java\com\android\server\SystemServer.java frameworks\base\services\core\java\com\android\server\wm\WindowManagerService.java frameworks\base\services\core\java\com\android
通过getevent找到对应的android键值
weixin_44311012的博客
06-30 2532
1、Linux中输入设备的事件类型有: EV_SYN 0000 同步事件 EV_KEY 0001 按键事件，如KEY_VOLUMEDOWN EV_REL 0002 相对坐标, 如shubiao上报的坐标 EV_ABS 0003 绝对坐标，如触摸屏上报的坐标 EV_MSC 0004 其它 EV_LED 0011 LED EV_SND 0012 声音 EV_REP 0014 Repeat EV_FF 0015 力反馈 ~~~~~~~~~~~~~~~~~~~~~~~~ EV_PWR 电源 EV_
Android Input子系统 - InputManagerService
Jimmy的专栏
06-02 414
InputManagerService是Android framework中核心service之一，Android framework层涉及的代码也是非常多，
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值