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

最新推荐文章于 2024-08-14 17:30:11 发布
最新推荐文章于 2024-08-14 17:30:11 发布
阅读量220 收藏
点赞数
分类专栏： Android framework 文章标签： android java 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Android_XG/article/details/125548022
版权

前言

本章将继续探究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;
}

总结

以上就是InputReader的全部流程，现给出InputReader事件的流程图供大家参考

尾声

一转眼时间真的过的飞快。我们各奔东西，也各自踏上了自己的旅途，但是即使多年不见，也因为这份情谊我们依旧如从前那般“亲密”。不忘初心方得始终。加油吧，程序员们，在我看来35岁，40岁从来不是危机，只要永远不要忘记自己为何踏上征程！

最后需要同款资料的，可以 私信我回复【学习】或者扫描下方二维码我愿意分享给你！

为了让更多在学习中或者最近要准备面试的朋友们看到这篇文章，希望你们能多多评论，点赞+转发！

**再次感谢所有给我提供过题目的朋友们，感谢一路有你！

不秃头de程序猿
关注
专栏目录
Android 10.0 系统framework去掉截图功能
安卓兼职framework和app工程师的博客
09-19 979
在定制化10.0产品中，由于是教育类的产品，为了不让资料外传，要求去掉截图功能，屏蔽掉系统截图的接口，不管是命令还是代码都不让截图。
Android系统源码阅读（11）：Android的InputManagerService的工作过程
天天吃吃
09-21 2231
Android系统源码阅读（11）：Android应用的InputManagerService的工作过程 请对照AOSP版本：6.0.1_r50。 1. 创建InputManager这里和老罗当年的版本有很大不同了，有了InputManagerService管理InputManager。1.1想要探索如何启动的相关server，需要从SystemServer开始探寻。从SystemServe
Android Framework------之Input子系统
weixin_30507481的博客
09-20 316
下面这是基于Android4.2代码的关于Input子系统的笔记。在这篇笔记中，只涉及Android相关的东西，关于Linux内核中对各种输入设备的统一，在本文中不作说明。此外，由于才疏学浅，文中难免有错误的地方，希望各位路过的大神能够予以指出。闲话少叙，先看一张我自己设计的图，如下： 这幅图是为了便于个人理解画出的，里面的注释也比较明白，就不再说明。本文就是以这幅图为基本的思路，简述在An...
input系统之InputReader
最新发布
今天也是星期五的博客
08-14 841
可以看出InputReader处理事件的流程为：（1）调用EventHub的getEvents方法获取输入事件（2）调用processEventsLocked()方法处理获取到的输入事件（3）调用flush()方法将已经封装好的EventEntry事件交给给InputDispatcher分发。
Android Framework重要服务之InputManagerService(一) 启动流程
Code1994的博客
05-28 1187
InputManagerService(输入管理服务)简称IMS，在安卓系统中负责它管理整个系统的输入部分，包括键盘、鼠标、触摸屏等等，它与WindowManager密切相关，本章将结合安卓11源码梳理IMS的启动流程。 一、启动IMS服务 IMS启动流程位于frameworks/base/services/java/com/android/server/SystemServer.java，相关代码如下： private void startOtherServices(@NonNull TimingsTra
Android Input framework(一)
wangkaiblog的专栏
11-09 966
http://blog.csdn.net/fe421504975/article/details/8272102
Android input 系统之一：InputReader线程
JeetLiu的博客
12-15 448
Android input 系统之一InputReader线程： touch事件处理流程： 底层触摸事件上报至framework层，事件未分发之前的数据读取与处理流程： "InputReader 线程" bool InputReaderThread::threadLoop() frameworks/native/services/inputflinger/InputReader.cpp...
Android 输入系统（一）InputManagerService
热门推荐
奋斗的菜鸟ing
03-15 1万+
InputManagerService InputManagerService启动 一般的系统服务是在SystemServer.java的ServerThread中启动，InputManagerService也不例外。 过程： 创建InputManagerService对象   InputManagerService初始化时传递了一个参数wmHandler，其创建如下 Ha
Android input系统.pdf
07-24
InputReader.cpp : 负责从硬件获取输入, 转换成事件（Event), 并分发给Input Dispatcher.  InputDispatcher.cpp : 将Input Reader传送过来的Events 通过socket分发给合适的窗口, 并监控ANR.  ...
Android Input子系统 - InputManagerService
Jimmy的专栏
06-02 412
InputManagerService是Android framework中核心service之一，Android framework层涉及的代码也是非常多，
Android framework Input初始化和上报流程
Nothing_Blog
12-23 1259
文章目录1. 初始化2. InputChannel服务端的创建和监听FD的注册3. InputChannel客户端注册和监听上报流程4. Input FW! Input Native事件上报流程5. 在Framework注册一个新的监听事件, 需要的步骤 1. 初始化 初始化Input Dispatcher和InputReader， 用于上报事件； 初始化Input DIspatcherThr...
android framework input 及多指协议
镇元子的博客
06-03 293
input问题排查，如果数据能打印出来，则是framework 问题，如果没有数据打印出来，则要看驱动问题。ABS_MT_SLOT ，其value 代表手指id，可以代表不同的手指。每个slot与一个id对应，一个非负数表一此接触，-1表示接触结束。以上数据格式：时间，具体节点文件名，事件类型，事件值。SYN_REPORT：代表一个事件的结束。0004/0005:代表一个事件的开始。触碰按键，其值是DOWN或者UP。相对于屏幕中心的x,y坐标。
Android Framework Input 机制分析
Ron的专栏
01-14 1072
App进程的Java层的ViewRoot对象，请求与底层建立通信，通过Binder机制调用WindowManagerService | 进而转入到服务进程Java层，由服务进程的Java层通过JNI层层调用，至Native层 InputTransport ，由此创建一对UNIX_AF socket ，将socket的描述符存入C++ InputChannel对象，用于事件传递。之后JNI层层返回，
Android Framework 输入子系统 （09）InputStage解读
wangdsh的博客
06-25 2661
系列文章解读&说明： Android Framework 输入子系统 的 分析主要分为以下部分： Android Framework 输入子系统（01）核心机制 inotify和epoll Android Framework 输入子系统（02）核心机制 双向通信(socketpair+binder) Android Framework 输入子系统（03）输入系统框架 Androi...
千里马Android Framework-input系统专题blog目录集合
learnframework的博客
04-01 1356
千里马Android Framework-input系统专题blog目录集合 这里将会列出视频课程中所有的可能用的相关资料集合blog链接
Android Framework 输入子系统（04）InputReader解读
wangdsh的博客
06-14 1497
系列文章解读&说明： Android Framework 输入子系统 的 分析主要分为以下部分： Android Framework 输入子系统（01）核心机制 inotify和epoll Android Framework 输入子系统（02）核心机制 双向通信(socketpair+binder) Android Framework 输入子系统（03）输入系统框架 Androi...
Android Input子系统 -- InputManagerService启动
zhangjie201412的专栏
12-17 728
InputManagerService是Android framework中核心service之一，Android framework层涉及的代码也是非常多， 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 frameworks/native/services/inputflinger/ - InputDispatche...
Android Input (1) -- InputManagerService启动
wd229047557的博客
09-12 1308
Link: Android Input (1) -- InputManagerService启动 Android Input (2) -- inputReader Android Input (3) -- inputDispatcher Android Input (4) -- inputDispatcher到ViewRootImpl Android Input (5) -- ViewR...
Android输入事件处理：从InputManager到应用
"Android应用程序输入事件处理机制涵盖了InputManager、InputReader、InputDispatcher以及应用程序主线程的消息循环。这些组件协同工作，确保用户在触摸屏或键盘上的操作能够被正确地处理和分发到相应的应用程序组件...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值