Android事件处理过程，InputDispatchThread和InputReaderThread的协作，(3)

àì夳堔傛蜴生んèń 2022-06-08 07:51 165阅读 0赞

三、另一个线程InputDispatchThread，它的实现核心是InputDispatch。

InputDispatchThread和InputReaderThread是要协同工作的，那是怎么协作的呢？

前面说过这两个线程是在frameworks/native/services/inputflinger/InputManager.cpp中创建的。

InputManager::InputManager(...)\{

mDispatcher= new InputDispatcher(dispatcherPolicy);

mReader= new InputReader(eventHub, readerPolicy, mDispatcher);

在创建时，就将InputReader和InputDispatch建立了关联。在InputReader的looponce中，事件是通过InputDispatch来送到Listener的。

void InputReader::loopOnce()@InputReader.cpp\{

mQueuedListener->flush();

这里的 mQueuedListener实际是对InputDispatch的一个封装。

这样InputDispatch就可以持续获取到设备中发生的事件。并且可以向InputReader注册监听多种事件。

class QueuedInputListener : publicInputListenerInterface \{

virtual void notifyConfigurationChanged(constNotifyConfigurationChangedArgs\* args);

virtual void notifyKey(const NotifyKeyArgs\* args);

virtual void notifyMotion(const NotifyMotionArgs\* args);

virtual void notifySwitch(const NotifySwitchArgs\* args);

virtual void notifyDeviceReset(const NotifyDeviceResetArgs\* args);

我们以key事件为例，看下是怎么注册这个监听的？

源头在EventHub，我们知道EventHub负责原始事件的读取，然后通知到InputReader，EventHub还监听设备的插拔，当然这也是事件。

voidInputReader::loopOnce()@InputReader.cpp\{

size\_tcount = mEventHub->getEvents(timeoutMillis, mEventBuffer,

EVENT\_BUFFER\_SIZE);

if (count) \{

processEventsLocked(mEventBuffer, count);

getEvents是EventHub很重要的一个方法，就是获取原事件，接着的 processEventsLocked开始处理事件。

如果是添加了输入设备，我们知道系统肯定是要创建一个输入设备的，

void InputReader::processEventsLocked(constRawEvent\* rawEvents, size\_t count) \{

//这里实际是一个循环，处理读取到的所有原始事件。

RawEvent\*rawEvent = rawEvents;

switch(rawEvent->type) \{

caseEventHubInterface::DEVICE\_ADDED:

addDeviceLocked(rawEvent->when,rawEvent->deviceId);

我们直接找往InputReader注册监听的地方

void InputReader::addDeviceLocked(nsecs\_twhen, int32\_t deviceId) \{

InputDevice\*device = createDeviceLocked(deviceId, controllerNumber, identifier, classes);

InputDevice\*InputReader::createDeviceLocked(...)\{

//Keyboard-like devices.

uint32\_tkeyboardSource = 0;

int32\_t keyboardType =AINPUT\_KEYBOARD\_TYPE\_NON\_ALPHABETIC;

if (classes & INPUT\_DEVICE\_CLASS\_KEYBOARD)\{

keyboardSource |= AINPUT\_SOURCE\_KEYBOARD;

if (classes &INPUT\_DEVICE\_CLASS\_ALPHAKEY) \{

keyboardType =AINPUT\_KEYBOARD\_TYPE\_ALPHABETIC;

if (classes & INPUT\_DEVICE\_CLASS\_DPAD)\{

keyboardSource |= AINPUT\_SOURCE\_DPAD;

if (classes &INPUT\_DEVICE\_CLASS\_GAMEPAD) \{

keyboardSource |= AINPUT\_SOURCE\_GAMEPAD;

if (keyboardSource != 0) \{

device->addMapper(newKeyboardInputMapper(device, keyboardSource, keyboardType));

这样就把键盘设备添加到了Vector<InputMapper\*>mMappers;

接下来会执行 mMappers的所有设备的process()方法，当然也会执行到KeyboardInputMapper的process方法。

void KeyboardInputMapper::process(constRawEvent\* rawEvent) \{

if (isKeyboardOrGamepadKey(scanCode)) \{

processKey(rawEvent->when, rawEvent->value != 0, scanCode,usageCode);

void KeyboardInputMapper::processKey(nsecs\_twhen, bool down, int32\_t scanCode,

int32\_t usageCode) \{

NotifyKeyArgs args(when, getDeviceId(), mSource, policyFlags,

down ? AKEY\_EVENT\_ACTION\_DOWN : AKEY\_EVENT\_ACTION\_UP,

AKEY\_EVENT\_FLAG\_FROM\_SYSTEM, keyCode, scanCode, keyMetaState,

downTime);

getListener()->notifyKey(&args);

这里获取的listener实际就是InputReader中mQueuedListener，我们看mQueuedListener的处理。

void QueuedInputListener::notifyKey(constNotifyKeyArgs\* args) @InputListener.cpp\{

mArgsQueue.push(new NotifyKeyArgs(\*args));

也就是把NotifyKeyArgs这个实例添加到Vector<NotifyArgs\*> mArgsQueue;中。

还记得前面说InputReader的looponce中，把事件通知给监听这是通过mQueuedListener->flush();就是下面的这个方法，

void QueuedInputListener::flush() \{

size\_t count = mArgsQueue.size();

for (size\_t i = 0; i < count; i++) \{

NotifyArgs\* args = mArgsQueue\[i\];

args->notify(mInnerListener);

delete args;

mArgsQueue.clear();

在这个方法中会回调具体实例的notify函数，

比如 NotifyKeyArgs的notify函数。

void NotifyKeyArgs::notify(constsp<InputListenerInterface>& listener) const \{

listener->notifyKey(this);

注意这里的 mInnerListener来自QueuedInputListener的构造函数，

QueuedInputListener::QueuedInputListener(constsp<InputListenerInterface>& innerListener) :

mInnerListener(innerListener) \{

QueuedInputListener又是在InputReader的构造函数实例话的，同时传入的参数是const sp<InputListenerInterface>& listener，实际就是InputDispatch，

class InputDispatcher : publicInputDispatcherInterface ；

class InputDispatcherInterface : publicvirtual RefBase, public InputListenerInterface ；

InputDispatch间接继承了 InputListenerInterface。

通过这个过程，InputReader就把事件传到了InputDispatch。

Android事件处理过程，InputDispatchThread和InputReaderThread的协作，(3)

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 Android事件处理分析

相关 Android事件处理分析+Android事件处理 +Android输入事件流程

相关 Android UI事件处理

相关 android事件处理，对事件的接收处理，(6)

相关 android事件处理，InputDispatch怎么处理事件的？(4)

相关 Android事件处理过程，InputDispatchThread和InputReaderThread的协作，(3)

相关 Android 事件处理过程，读取事件线程，(2)

相关 Android 事件处理过程,(1)

相关 Android的事件处理

相关 Android事件处理