分类：Linux KernelAndroid Framework 2011-12-21 13:54 20844人阅读 评论(17) 收藏 举报 input android class keyboard struct thread

目录(?)[+]

1. TouchScreen功能在Android4.0下不工作

原来在Android2.3.5下能正常工作的TouchScreen功能，移植到Android 4.0就不能正常工作了。凭直觉，Android4.0肯定有鬼。真是不看不知道，一看吓一跳。在Android 4.0中，Event Input地位提高了，你看看，在Adroid2.3.5中，它在frameworks/base/libs/ui之下，在Android4.0中，它在frameworks/base/services/input之下，看到没有，它有了自己的地位，就像在Kernel中一样，有自己门户了。

再看看代码，变化也太大了，当然TouchScreen不能工作，首先自然会看接口部分代码。首先看它是如何打开设备的，查看函数EventHub::openDeviceLocked，看看其代码，大部分还是很熟悉的，但仔细一看多了一个下面的东东：

ioctl(fd, EVIOCGPROP(sizeof(device->propBitmask)), device->propBitmask);

由于升级到Android4.0时，Kernel还是2.6.35,并没有进行升级。既然需要EVIOCGPROP,就就看看evdev.c中的ioctl函数是否支持此功能。一看不支持，再看看Kernel3.0.8<这个Kernel版本与Android4.0是一伙的>，我的乖乖，它已经支持了此功能，详见evdev.c中函数evdev_do_ioctl，这个写得2.6.35中的友好多了，分别处理：固定长度命令、单个可变长度命令和多个可变长度命令。

对于为什么我的TouchScreen在Android4.0不工作，答案显而易见，我用的Kernel版本不对，当然移植到Android4.0对应的Kernel(Kernel3.0.8)时，TouchScreen驱动本身也需要修改，因为input_dev变化也比较大，比如增加了propbit字段，以供处理上面的ioctl时使用。

2. Android 4.0如何管理各种驱动设备

正是由于遇到上面的问题，才促使自己对Event Input进行深入了解。因为蜻蜓点水不是小弟的性格。

这个年代干啥都有什么经理，小弟之类的。比如去饭店吃饭，吃到小强了，总是会大吼一声，经理，过来看看，然后谈打折或赔偿的问题。可见经理是不可缺少的，要不然我们找谁来维权啊!

前面谈到的EventHub，这个一看就是一个做实事的，肯定不是领导，哪它的领导是谁呢? 哪我们就从以下几方面来分析此问题：

1）每个功能模块是怎么产生的？

2）读取设备输入流程？

3）事件分发流程？

3. 各个功能模块是怎么产生的?

先介绍一下每个模块的工作职责：EventHub, InputReader, InputManager...

3.1 模块功能

3.1.1 EventHub

它是系统中所有事件的中央处理站。它管理所有系统中可以识别的输入设备的输入事件，此外，当设备增加或删除时，EventHub将产生相应的输入事件给系统。

EventHub通过getEvents函数，给系统提供一个输入事件流。它也支持查询输入设备当前的状态（如哪些键当前被按下）。而且EventHub还跟踪每个输入调入的能力，比如输入设备的类别，输入设备支持哪些按键。

3.1.2 InputReader

InputReader从EventHub中读取原始事件数据(RawEvent)，并由各个InputMapper处理之后输入对应的input listener.

InputReader拥有一个InputMapper集合。它做的大部分工作在InputReader线程中完成，但是InputReader可以接受任意线程的查询。为了可管理性，InputReader使用一个简单的Mutex来保护它的状态。

InputReader拥有一个EventHub对象，但这个对象不是它创建的，而是在创建InputReader时作为参数传入的。

3.1.3 InputDispatcher

InputDispatcher负责把事件分发给输入目标，其中的一些功能（如识别输入目标）由独立的policy对象控制。

3.1.4 InputManager

InputManager是系统事件处理的核心，它虽然不做具体的事，但管理工作还是要做的，比如接受我们客户的投诉和索赔要求，或者老板的出所筒。

InputManager使用两个线程：

1）InputReaderThread叫做"InputReader"线程，它负责读取并预处理RawEvent，applies policy并且把消息送入DispatcherThead管理的队列中。

2）InputDispatcherThread叫做"InputDispatcher"线程，它在队列上等待新的输入事件，并且异步地把这些事件分发给应用程序。

InputReaderThread类与InputDispatcherThread类不共享内部状态，所有的通信都是单向的，从InputReaderThread到InputDispatcherThread。两个类可以通过InputDispatchPolicy进行交互。

InputManager类从不与Java交互，而InputDispatchPolicy负责执行所有与系统的外部交互，包括调用DVM业务。

3.2 创建流程

1）在android_server_InputManager_nativeInit中创建NativeInputManager对象，并保存到gNativeInputManager中；

2）在创建NativeInputManager对象时，它会创建EventHub对象<且创建是其成员mNeedToScanDevices的值为true>，然后把刚创建的EventHub对象作为参数创建InputManager对象；

3）在创建InputManager对象时，创建InputReader对象，然后把它作为参数创建InputReaderThread；创建InputDispatcher对象，然后把它作为参数创建InputDispatcherThread对象；（注：以上两个线程对象都有自己的threadLoop函数，它将在Thread::_threadLoop中被调用，这个Thread::_threadLoop是线程入口函数，线程在Thread::run中被真正地创建）

4.1）创建InputReader对象

4.1.1）把EventHub、readerPolicy<实质为NativeInputManager对象>和创建的InputDispatcher对象作为参数创建InputReader对象:mReader = new InputReader(eventHub, readerPolicy, mDispatcher);

4.1.2）在创建InputReader时， 保存EventHub对象到mEventHub中，并创建QueuedInputListener对象并保存在mQueuedListener中

4.2）创建InputDispatcher对象

4.2.1）把传入的参数dispatcherPolicy<实质为NativeInputManager对象>作为参数创建InputDispatcher对象:mDispatcher = new InputDispatcher(dispatcherPolicy);

4.2.1）在创建InputDispatcher时，创建了一个looper对象：mLooper = new Looper(false);

3.3 启动流程

1）在android_server_InputManager_nativeStart中调用InputManager::start,代码如下：

result = gNativeInputManager->getInputManager()->start();

2）在InputManager::start中，调用mDispatcherThread->run和mReaderThread->run，代码如下：

result = mDispatcherThread->run("InputDispatcher", PRIORITY_URGENT_DISPLAY);
result = mReaderThread->run("InputReader", PRIORITY_URGENT_DISPLAY);

3）在上面的Thread::run中，调用createThreadEtc函数，并以Thread::_threadLoop作为入口函数，以上面的mDispatcherThread或mReaderThread作为userdata创建线程

4）至此InputReader线程和InputDispatcher线程都已经工作，详细信息见Thread::_threadLoop，在此函数中它将调用mDispatcherThread或mReaderThread的threadLoop函数来做真正的事

5.1）mReaderThread->threadLoop

bool InputReaderThread::threadLoop() {
mReader->loopOnce();
return true;
}

5.2）mDispatcherThread->threadLoop

bool InputDispatcherThread::threadLoop() {
mDispatcher->dispatchOnce();
return true;
}

3.4 EventInput对象关系图

4. 设备操作流程

从EventHub::getEvents读取的事件数据结构如下：

[cpp] view plain copy

1. structRawEvent{
2. nsecs_twhen;//事件发生的时间
3. int32_tdeviceId;//产生此事件的设备,比如发送FINISHED_DEVICE_SCAN,不需要填此项
4. int32_ttype;//事件类型(如:DEVICE_ADDED,DEVICE_REMOVED,FINISHED_DEVICE_SCAN)
5. int32_tscanCode;
6. int32_tkeyCode;
7. int32_tvalue;
8. uint32_tflags;
9. };

读取事件时的调用流程为：

Thread::_threadLoop->

InputReaderThread::threadLoop->

InputReader::loopOnce->

EventHub::getEvents->

4.1 打开设备

在EventHub::getEvents中，当mNeedToScanDevices为true时<当创建EventHub对象时，它就为true>，它将从/dev/input目录下查找所有设备，并进行打开，获取其相关属性，最后加入mDevices列表中。

EventHub::scanDevicesLocked->

EventHub::scanDirLocked("/dev/input")->

EventHub::openDeviceLocked

4.1.1 打开事件输入设备

打开事件输入设备，在用户态调用open，则在kernel态中调用evdev_open函数，evdev_open处理流程如下：

1）首先从参数inode中获取在evdev_table中的索引，从而获取对应的evdev对象

2）创建evdev_client对象，创建此对象时同时为其buffer成员分配对应的内存

3）把新创建evdev_client对象添加到client_list链表中

4）把client保存在file的private_data中

5）调用evdev_open_device->input_open_device->input_dev.open函数打开设备。

4.2 读取输入事件

要说EventHub::getEvents如何获取输入事件，不得不先说说它的几个相关的成员变量：

1）mPendingEventCount：调用epoll_wait时的返回值，当然如果没有事件，则其值为0；

2）mPendingEventIndex：当前需要处理的事件索引

3）mEpollFd：epoll实例，在EventHub::EventHub中初始化此例，所有输入事件通过epoll_wait来获取，每一个事件的数据结构为：struct epoll_event，为了搞明白如何读取输入事件的原理，不得不对epoll相关的东东搞个清清楚楚，明明白白，见epoll kernel实现原理。注：epoll_event只表明某个设备上有事件，并不包含事件内容，具体事件内容需要通过read来读取。

struct epoll_event定义如下：

[cpp] view plain copy

1. typedefunionepoll_data
2. {
3. void*ptr;
4. intfd;
5. unsignedintu32;
6. unsignedlonglongu64;
7. }epoll_data_t;
9. structepoll_event
10. {
11. unsignedintevents;
12. epoll_data_tdata;
13. };

每个设备被创建（在函数EventHub::openDeviceLocked中）时，都会向epoll注册，代码如下：

[cpp] view plain copy

1. //Registerwithepoll.
2. structepoll_eventeventItem;
3. memset(&eventItem,0,sizeof(eventItem));
4. eventItem.events=EPOLLIN;
5. eventItem.data.u32=deviceId;
6. if(epoll_ctl(mEpollFd,EPOLL_CTL_ADD,fd,&eventItem)){
7. LOGE("Couldnotadddevicefdtoepollinstance.errno=%d",errno);
8. deletedevice;
9. return-1;
10. }

4.2.1 查看设备上是否有事件

在调用epoll_wait(mEpollFd, mPendingEventItems, EPOLL_MAX_EVENTS, timeoutMillis)之后，读到的epoll_event事件保存在mPendingEventItems，总共的事件数保存在mPendingEventCount，当然，在调用epoll_event之前，mPendingEventIndex被清0，直正的事件处理在下面的代码中。

[cpp] view plain copy

1. //Grabthenextinputevent.
2. booldeviceChanged=false;
3. while(mPendingEventIndex<mPendingEventCount){
4. conststructepoll_event&eventItem=mPendingEventItems[mPendingEventIndex++];
5. if(eventItem.data.u32==EPOLL_ID_INOTIFY){
6. if(eventItem.events&EPOLLIN){
7. mPendingINotify=true;
8. }else{
9. LOGW("Receivedunexpectedepollevent0x%08xforINotify.",eventItem.events);
10. }
11. continue;
12. }
14. if(eventItem.data.u32==EPOLL_ID_WAKE){
15. if(eventItem.events&EPOLLIN){
16. LOGV("awokenafterwake()");
17. awoken=true;
18. charbuffer[16];
19. ssize_tnRead;
20. do{
21. nRead=read(mWakeReadPipeFd,buffer,sizeof(buffer));
22. }while((nRead==-1&&errno==EINTR)||nRead==sizeof(buffer));
23. }else{
24. LOGW("Receivedunexpectedepollevent0x%08xforwakereadpipe.",
25. eventItem.events);
26. }
27. continue;
28. }
30. ssize_tdeviceIndex=mDevices.indexOfKey(eventItem.data.u32);
31. if(deviceIndex<0){
32. LOGW("Receivedunexpectedepollevent0x%08xforunknowndeviceid%d.",
33. eventItem.events,eventItem.data.u32);
34. continue;
35. }
37. Device*device=mDevices.valueAt(deviceIndex);
38. if(eventItem.events&EPOLLIN){
39. int32_treadSize=read(device->fd,readBuffer,
40. sizeof(structinput_event)*capacity);
41. if(readSize==0||(readSize<0&&errno==ENODEV)){
42. //DevicewasremovedbeforeINotifynoticed.
43. LOGW("couldnotgetevent,removed?(fd:%dsize:%dbufferSize:%dcapacity:%derrno:%d)\n",
44. device->fd,readSize,bufferSize,capacity,errno);
45. deviceChanged=true;
46. closeDeviceLocked(device);
47. }elseif(readSize<0){
48. if(errno!=EAGAIN&&errno!=EINTR){
49. LOGW("couldnotgetevent(errno=%d)",errno);
50. }
51. }elseif((readSize%sizeof(structinput_event))!=0){
52. LOGE("couldnotgetevent(wrongsize:%d)",readSize);
53. }else{
54. int32_tdeviceId=device->id==mBuiltInKeyboardId?0:device->id;
56. size_tcount=size_t(readSize)/sizeof(structinput_event);
57. for(size_ti=0;i<count;i++){
58. conststructinput_event&iev=readBuffer[i];
59. LOGV("%sgot:t0=%d,t1=%d,type=%d,code=%d,value=%d",
60. device->path.string(),
61. (int)iev.time.tv_sec,(int)iev.time.tv_usec,
62. iev.type,iev.code,iev.value);
64. #ifdefHAVE_POSIX_CLOCKS
65. //Usethetimespecifiedintheeventinsteadofthecurrenttime
66. //sothatdownstreamcodecangetmoreaccurateestimatesof
67. //eventdispatchlatencyfromthetimetheeventisenqueuedonto
68. //theevdevclientbuffer.
69. //
70. //Theevent'stimestampfortuitouslyusesthesamemonotonicclock
71. //timebaseastherestofAndroid.Thekerneleventdevicedriver
72. //(drivers/input/evdev.c)obtainstimestampsusingktime_get_ts().
73. //ThesystemTime(SYSTEM_TIME_MONOTONIC)functionweuseeverywhere
74. //callsclock_gettime(CLOCK_MONOTONIC)whichisimplementedasa
75. //systemcallthatalsoqueriesktime_get_ts().
76. event->when=nsecs_t(iev.time.tv_sec)*1000000000LL
77. +nsecs_t(iev.time.tv_usec)*1000LL;
78. LOGV("eventtime%lld,now%lld",event->when,now);
79. #else
80. event->when=now;
81. #endif
82. event->deviceId=deviceId;
83. event->type=iev.type;
84. event->scanCode=iev.code;
85. event->value=iev.value;
86. event->keyCode=AKEYCODE_UNKNOWN;
87. event->flags=0;
88. if(iev.type==EV_KEY&&device->keyMap.haveKeyLayout()){
89. status_terr=device->keyMap.keyLayoutMap->mapKey(iev.code,
90. &event->keyCode,&event->flags);
91. LOGV("iev.code=%dkeyCode=%dflags=0x%08xerr=%d\n",
92. iev.code,event->keyCode,event->flags,err);
93. }
94. event+=1;
95. }
96. capacity-=count;
97. if(capacity==0){
98. //Theresultbufferisfull.Resetthependingeventindex
99. //sowewilltrytoreadthedeviceagainonthenextiteration.
100. mPendingEventIndex-=1;
101. break;
102. }
103. }
104. }else{
105. LOGW("Receivedunexpectedepollevent0x%08xfordevice%s.",
106. eventItem.events,device->identifier.name.string());
107. }
108. }

4.2.2 读取设备上真正的事件

epoll_wait只是告诉我们Device已经有事件了，让我们去读，真正读取设备输入事件的代码如上，其流程如下：
1）根据eventItem.data.u32获取设备索引，从而获取对应的Device

2）从device->fd中读取input_event事件。read(device->fd, readBuffer, sizeof(struct input_event) * capacity);这些input_event是由各个注册的input_device报告给input子系统的。具体读入流程参见Input Core和evdev基本知识 - Kernel3.0.8

至此，事件已经读取到用户态，哪我们就看看EventHub怎么处理这些事件了。

4.3 处理输入事件

在4.2中，首先通过epoll_wait查看哪些设备有事件，然后通过read从有事件的设备中读取事件，现在事件已经读取到用户态，且数据结构为input_event，保存在EventHub::getEvents的readBuffer中。下面就看看这些事件下一步的东家是谁？

1）首先把input_event的信息填入RawEvent中，其相关代码如下：

[plain] view plain copy

1. #ifdefHAVE_POSIX_CLOCKS
2. //Usethetimespecifiedintheeventinsteadofthecurrenttime
3. //sothatdownstreamcodecangetmoreaccurateestimatesof
4. //eventdispatchlatencyfromthetimetheeventisenqueuedonto
5. //theevdevclientbuffer.
6. //
7. //Theevent'stimestampfortuitouslyusesthesamemonotonicclock
8. //timebaseastherestofAndroid.Thekerneleventdevicedriver
9. //(drivers/input/evdev.c)obtainstimestampsusingktime_get_ts().
10. //ThesystemTime(SYSTEM_TIME_MONOTONIC)functionweuseeverywhere
11. //callsclock_gettime(CLOCK_MONOTONIC)whichisimplementedasa
12. //systemcallthatalsoqueriesktime_get_ts().
13. event->when=nsecs_t(iev.time.tv_sec)*1000000000LL
14. +nsecs_t(iev.time.tv_usec)*1000LL;
15. LOGV("eventtime%lld,now%lld",event->when,now);
16. #else
17. event->when=now;
18. #endif
19. event->deviceId=deviceId;
20. event->type=iev.type;
21. event->scanCode=iev.code;
22. event->value=iev.value;
23. event->keyCode=AKEYCODE_UNKNOWN;
24. event->flags=0;
25. if(iev.type==EV_KEY&&device->keyMap.haveKeyLayout()){
26. status_terr=device->keyMap.keyLayoutMap->mapKey(iev.code,
27. &event->keyCode,&event->flags);
28. LOGV("iev.code=%dkeyCode=%dflags=0x%08xerr=%d\n",
29. iev.code,event->keyCode,event->flags,err);
30. }

2）如果是input_event的类型为EV_KEY，则需要调用device->keyMap.keyLayoutMap->mapKey函数把iput_event.code映射为RawEvent.keyCode。相关数据结构关系如下图所示：

至此，EventHub::getEvents读取事件的任务已经完成，下面看看这些RawEvent的命运如何呢?

4.3.1 InputReader::loopOnce如何处理RawEvent?

为此，先温习一下读取事件时的调用流程为：

Thread::_threadLoop->

InputReaderThread::threadLoop->

InputReader::loopOnce->

EventHub::getEvents->

在InputReader::loopOnce中，当调用EventHub->getEvents获取到RawEvent之后，调用InputReader::processEventsLocked来处理这些事件，然后调用mQueuedListener->flush()把这些队列中的事件发送到Listener。

4.3.1.1 InputReader::processEventsLocked

在InputReader::processEventsLocked主要分两步处理：

1）处理来自于事件驱动设备的事件（processEventsForDeviceLocked）

2）处理设备增加、删除和修改事件

按照程序执行流程，应该是先有设备，然后才会有设备事件，所以先分析设备增加。其代码如下：

[plain] view plain copy

1. <spanstyle="font-size:10px;">voidInputReader::processEventsLocked(constRawEvent*rawEvents,size_tcount)
2. {
3. for(constRawEvent*rawEvent=rawEvents;count;){
4. int32_ttype=rawEvent->type;
5. size_tbatchSize=1;
7. //处理来自于事件驱动设备的事件
8. if(type<EventHubInterface::FIRST_SYNTHETIC_EVENT){
10. int32_tdeviceId=rawEvent->deviceId;
11. while(batchSize<count){
12. if(rawEvent[batchSize].type>=EventHubInterface::FIRST_SYNTHETIC_EVENT
13. ||rawEvent[batchSize].deviceId!=deviceId){
14. break;
15. }
16. batchSize+=1;
17. }
18. //处理来自于同一个事件驱动设备的1个或多个事件
19. processEventsForDeviceLocked(deviceId,rawEvent,batchSize);
20. }
21. else
22. {
23. //处理增加或删除事件驱动设备的事件，在EventHub::getEvents中产生,
24. //不是由事件驱动设备产生的。
25. switch(rawEvent->type){
26. caseEventHubInterface::DEVICE_ADDED:
27. addDeviceLocked(rawEvent->when,rawEvent->deviceId);
28. break;
29. caseEventHubInterface::DEVICE_REMOVED:
30. removeDeviceLocked(rawEvent->when,rawEvent->deviceId);
31. break;
32. caseEventHubInterface::FINISHED_DEVICE_SCAN:
33. handleConfigurationChangedLocked(rawEvent->when);
34. break;
35. default:
36. LOG_ASSERT(false);//can'thappen
37. break;
38. }
39. }
40. count-=batchSize;
41. rawEvent+=batchSize;
42. }
43. }</span>

4.3.1.1.1设备增加事件处理addDeviceLocked

它处理其中的EventHubInterface::DEVICE_ADDED, EventHubInterface:: DEVICE_REMOVED和EventHubInterface::FINISHED_DEVICE_SCAN事件，即与Device相关的事件，这些事件是在EventHub::getEvents中产生的，并不是Kernel态的事件输入设备产生的。

下面分析它如何处理EventHubInterface::DEVICE_ADDED事件。查看其它代码，它是调用InputReader::addDeviceLocked(nsecs_t when, int32_t deviceId)来处理此事件。

在InputReader::addDeviceLocked中的调用流程：

1）先根据mContext, deviceId, name, classes创建一个InputDevice对象，它用于表示单个输入设备的状态。其中的classes为对应Device的classes成员，它用于表示设备类型，其定义如下：

[plain] view plain copy

1. /*
2. *Inputdeviceclasses.
3. */
4. enum{
5. /*Theinputdeviceisakeyboardorhasbuttons.*/
6. INPUT_DEVICE_CLASS_KEYBOARD=0x00000001,
8. /*Theinputdeviceisanalpha-numerickeyboard(notjustadialpad).*/
9. INPUT_DEVICE_CLASS_ALPHAKEY=0x00000002,
11. /*Theinputdeviceisatouchscreenoratouchpad(eithersingle-touchormulti-touch).*/
12. INPUT_DEVICE_CLASS_TOUCH=0x00000004,
14. /*Theinputdeviceisacursordevicesuchasatrackballormouse.*/
15. INPUT_DEVICE_CLASS_CURSOR=0x00000008,
17. /*Theinputdeviceisamulti-touchtouchscreen.*/
18. INPUT_DEVICE_CLASS_TOUCH_MT=0x00000010,
20. /*Theinputdeviceisadirectionalpad(implieskeyboard,hasDPADkeys).*/
21. INPUT_DEVICE_CLASS_DPAD=0x00000020,
23. /*Theinputdeviceisagamepad(implieskeyboard,hasBUTTONkeys).*/
24. INPUT_DEVICE_CLASS_GAMEPAD=0x00000040,
26. /*Theinputdevicehasswitches.*/
27. INPUT_DEVICE_CLASS_SWITCH=0x00000080,
29. /*Theinputdeviceisajoystick(impliesgamepad,hasjoystickabsoluteaxes).*/
30. INPUT_DEVICE_CLASS_JOYSTICK=0x00000100,
32. /*Theinputdeviceisexternal(notbuilt-in).*/
33. INPUT_DEVICE_CLASS_EXTERNAL=0x80000000,
34. }

创建InputDevice对象之后，对于多点触摸设备（class为INPUT_DEVICE_CLASS_TOUCH_MT),创建MultiTouchInputMapper对象并增加到InputDevice的mMappers向量列表中。

对于单点触摸设备（class为INPUT_DEVICE_CLASS_TOUCH),创建SingleTouchInputMapper对象并增加到InputDevice的mMappers向量列表中。相关代码如下：

[plain] view plain copy

1. InputDevice*InputReader::createDeviceLocked(int32_tdeviceId,
2. constString8&name,uint32_tclasses){
3. InputDevice*device=newInputDevice(&mContext,deviceId,name,classes);
5. ....
7. if(keyboardSource!=0){
8. device->addMapper(newKeyboardInputMapper(device,keyboardSource,keyboardType));
9. }
11. //Cursor-likedevices.
12. if(classes&INPUT_DEVICE_CLASS_CURSOR){
13. device->addMapper(newCursorInputMapper(device));
14. }
16. //Touchscreensandtouchpaddevices.
17. if(classes&INPUT_DEVICE_CLASS_TOUCH_MT){
18. device->addMapper(newMultiTouchInputMapper(device));
19. }elseif(classes&INPUT_DEVICE_CLASS_TOUCH){
20. device->addMapper(newSingleTouchInputMapper(device));
21. }
23. //Joystick-likedevices.
24. if(classes&INPUT_DEVICE_CLASS_JOYSTICK){
25. device->addMapper(newJoystickInputMapper(device));
26. }
28. returndevice;
29. }

总之,它调用createDeviceLocked创建一个InputDevice设备，并根据class类别创建对应的事件转换器(InputMapper)，然后把这些新那建的InputMapper增加到InputDevice::mMappers中。InputMapper关系如下图所示：

2）调用InputDevice::configure配置此InputDevice

3）调用InputDevice::reset重置此InputDevice

4）把新建的InputDevice增加到InputReader::mDevices中。

InputReader::processEventsLocked设备增加、删除处理总结：

它负责处理Device 增加、删除事件。增加事件的流程为：为一个新增的Device创建一个InputDevice，并增加到InputReader::mDevices中；根据新增加设备的class类别，创建对应的消息转换器（InputMapper），然后此消息转换器加入InputDevice::mMappers中。消息转换器负责把读取的RawEvent转换成特定的事件，以供应用程序使用。

EventHub与InputReader各自管理功能：

1）EventHub管理一堆Device，每一个Device与Kernel中一个事件输入设备对应

2）InputReader管理一堆InputDevice，每一个InputDevice与EventHub中的Device对应

3）InputDevice管理一些与之相关的InputMapper，每一个InputMapper与一个特定的应用事件相对应，如：SingleTouchInputMapper。

4.3.1.1.2事件驱动设备事件处理processEventsForDeviceLocked

下面的分析处理以单点触摸为例，对于单点触摸Touch Down时，它将报告以下事件：

代码：

input_report_abs(myInputDev, ABS_X, event->x);
input_report_abs(myInputDev, ABS_Y, event->y);

产生的事件：*type, code, value
EV_ABS,ABS_X,event->x
EV_ABS,ABS_Y,event->y

代码：

input_report_key(myInputDev, BTN_TOUCH, 1);
产生的事件：*type, code, value
EV_KEY, BTN_TOUCH, 1

代码：

input_sync(myInputDev);
它调用input_event(dev, EV_SYN, SYN_REPORT, 0);
产生的事件：*type, code, value
EV_SYN, SYN_REPORT, 0

它负责处理来自于同一个设备且在mEventBuffer中连续的多个事件，其函数原型如下：

[plain] view plain copy

1. voidInputReader::processEventsForDeviceLocked(int32_tdeviceId,
2. constRawEvent*rawEvents,size_tcount){
3. ssize_tdeviceIndex=mDevices.indexOfKey(deviceId);
4. if(deviceIndex<0){
5. LOGW("DiscardingeventforunknowndeviceId%d.",deviceId);
6. return;
7. }
9. InputDevice*device=mDevices.valueAt(deviceIndex);
10. if(device->isIgnored()){
11. //LOGD("DiscardingeventforignoreddeviceId%d.",deviceId);
12. return;
13. }
15. device->process(rawEvents,count);
16. }

它其实很简单，根据输入的deviceId找到对应的InputDevice,然后调用InputDevice::process以对设备输入事件进行处理。InputDevice::process主要源码如下：

[plain] view plain copy

1. voidInputDevice::process(constRawEvent*rawEvents,size_tcount){
2. //Processalloftheeventsinorderforeachmapper.
3. //Wecannotsimplyaskeachmappertoprocesstheminbulkbecausemappersmay
4. //haveside-effectsthatmustbeinterleaved.Forexample,joystickmovementeventsand
5. //gamepadbuttonpressesarehandledbydifferentmappersbuttheyshouldbedispatched
6. //intheorderreceived.
8. size_tnumMappers=mMappers.size();
9. for(constRawEvent*rawEvent=rawEvents;count--;rawEvent++)
10. {
11. for(size_ti=0;i<numMappers;i++){
12. InputMapper*mapper=mMappers[i];
13. mapper->process(rawEvent);
14. }
15. }
16. }

从上面的代码中可以看出，在InputDevice::process中，对于传入的每一个RawEvent，依次调用InputDevice中的每一个InputMapper来进行处理。前面提到过，InputDevice包含一组处理对应设备事件InputMapper，现在这些InputMapper开始干活了。
下面以处理一个单点触摸事件设备的事件为例，进行分析，其它的处理流程类似。对于mapper->process需要查看InputReader::createDeviceLocked中创建的具体的InputMapper的process函数。下面就看看SingleTouchInputMapper的process是如何处理的，其代码如下：

[plain] view plain copy

1. voidSingleTouchInputMapper::process(constRawEvent*rawEvent){
2. TouchInputMapper::process(rawEvent);
4. mSingleTouchMotionAccumulator.process(rawEvent);
5. }

1）TouchInputMapper::process

由此可见，它将首先调用TouchInputMaaper::process处理此事件，其处理代码如下：

[plain] view plain copy

1. voidTouchInputMapper::process(constRawEvent*rawEvent){
2. mCursorButtonAccumulator.process(rawEvent);
3. mCursorScrollAccumulator.process(rawEvent);
4. mTouchButtonAccumulator.process(rawEvent);
6. if(rawEvent->type==EV_SYN&&rawEvent->scanCode==SYN_REPORT){
7. sync(rawEvent->when);
8. }
9. }

1.1) mCursorButtonAccumulator.process(rawEvent)

记录mouse或touch pad按键状态，记录rawEvent->type为EV_KEY，且rawEvent->scanCode为BTN_LEFT、BTN_RIGHT、BTN_MIDDLE、BTN_BACK、BTN_SIDE、BTN_FORWARD、BTN_EXTRA、BTN_TASK的事件。

1.2) mCursorScrollAccumulator.process(rawEvent)

记录cursor scrolling motions，记录rawEvent->type为EV_REL，且rawEvent->scanCode为REL_WHEEL、REL_HWHEEL的事件。

1.3) mTouchButtonAccumulator.process(rawEvent)

记录touch, stylus and tool buttons状态，记录rawEvent->type为EV_KEY，且rawEvent->scanCode为BTN_TOUCH、BTN_STYLUS、BTN_STYLUS2、BTN_TOOL_FINGER、BTN_TOOL_PEN、BTN_TOOL_RUBBER、BTN_TOOL_BRUSH、BTN_TOOL_PENCIL、BTN_TOOL_AIRBRUSH、BTN_TOOL_MOUSE、BTN_TOOL_LENS、BTN_TOOL_DOUBLETAP、BTN_TOOL_TRIPLETAP、BTN_TOOL_QUADTAP的事件。

看到了吧，我们的BTN_TOUCH在这儿被处理了，且其value被保存在mBtnTouch成员变量中。

1.4) sync(rawEvent->when)

处理EV_SYN:SYN_REPORT，我们的EV_SYN就在这儿被处理了，当然它是Touch Down时，所发事件的最后一个事件。这儿才是处理的重点。

TouchInputMapper::sync将调用SingleTouchInputMapper::syncTouch函数。

a）SingleTouchInputMapper::syncTouch

把mCurrentRawPointerData中的ABS_X和ABS_Y的值保存在TouchInputMapper::mCurrentRawPointerData->pointers中。

单点触摸的syncTouch一次处理一个RawEvent，在pointers中只有一个值；而多点触摸的syncTouch一次处理多个RawEvent，在pointers中有多个值，最多16个。

b）TouchInputMapper::cookPointerData

根据TouchInputMapper::mCurrentRawPointerData->pointers中的数据，通过计算，最后生成TouchInputMapper::mCurrentCookedPointerData.pointerCoords，mCurrentCookedPointerData.pointerProperties和mCurrentCookedPointerData.idToIndex的数据。把Raw进行cook，之后生成了cooked数据。

c）TouchInputMapper::dispatchHoverExit

d）TouchInputMapper::dispatchTouches

d.a）它调用dispatchMotion

d.b）在dispatchMotion中，根据cooked数据创建NotifyMotionArg对象，它描述了一个移动事件

d.c）调用TouchInputMapper::getListener()->notifyMotion(&args)

TouchInputMapper::getListener()调用mContext->getListener()，此mContext为InputReader::mContext，所以其getListener()返回的则为InputReader::mQueuedListener，则最后调用QueuedInputListener::notifyMotion

补充1) InputReader::mContext在构造时用自己的指针初始化了mContext,从而mContext::mReader则为此InputReader实例。
补充2) 在InputReader::createDeviceLocked中创建InputDevice时，把自己的mContext作为参数传入，从而把它保存在InputDevice::mContext中；在创建InputMapper时，以InputDevice作为参数，且InputMapper把它保存在mDevice中，然后从把InputDevice中的mContext也保存在InputMapper的mContext中。

d.d）把传递过来的NotifyMotionArg参数复制一份，然后加入QueuedInputListener::mArgsQueue例表中。

e）TouchInputMapper::dispatchHoverEnterAndMove

2）mSingleTouchMotionAccumulator.process

记录ABS相关的值，记录rawEvent->type为EV_ABS，且rawEvent->scanCode为ABS_X、ABS_Y、ABS_PRESSURE、ABS_TOOL_WIDTH、ABS_DISTANCE、ABS_TILT_X、ABS_TILT_Y的事件。我们发的ABS_X和ABS_Y在这儿被处理了。

事件处理相关数据结构如下图所示：

4.3.1.2 InputReader::mQueuedListener->flush()

先温习一下，至此的消息结构变化流程：

processEventsLocked已经把来自于事件设备的事件煮熟之后放入到各种NotifyArgs（如NotifyMotionArgs）之中，然后把这些各种NotifyArgs加入InputReader::mQueuedListener::mArgsQueue链表中。本Flush函数就是要把mArgsQueue中的所有NotifyArgs进行处理。为描述方便，先看看其代码：

[plain] view plain copy

1. voidQueuedInputListener::flush(){
2. size_tcount=mArgsQueue.size();
3. for(size_ti=0;i<count;i++){
4. NotifyArgs*args=mArgsQueue[i];
5. args->notify(mInnerListener);
6. deleteargs;
7. }
8. mArgsQueue.clear();
9. }

看到了吧，确实很简单，调用链表中每个NotifyArgs的notify函数，且有一个有意思的参数mInnerListener，这个参数在前面多次提到过，它是在创建mQueuedListener时提供的，它其实就是InputManager中的mDispatcher，前面一直在InputReader中打转转，现在终于看到InputDispatcher登场了，说明事件很快就可以谢幕了。

再向下看一下吧，这么多类NotifyArgs，为描述方便，下面以NotifyMotionArgs为例，其代码为：

[cpp] view plain copy

1. voidNotifyMotionArgs::notify(constsp<InputListenerInterface>&listener)const{
2. listener->notifyMotion(this);
3. }

下面就看看InputDispatcher(mDispatcher)的notifyMotion函数做了些什么。这个InputDispatcher::notifyMotion(const NotifyMotionArgs* args)可就不简单了。

在InputDispatcher::notifyMotion中，
1）根据NotifyMotionArgs提供的信息，构造一个MotionEvent，再调用mPolicy->filterInputEvent看是否需要丢弃此事件，如果需要丢弃则马上返加。其中mPolicy为NativeInputManager实例，在构造InputDispatcher时提供的参数。

2）对于AMOTION_EVENT_ACTION_UP或AMOTION_EVENT_ACTION_DOWN事件，则直接根据NotifyMotionArgs提供的信息，构造一个MotionEntry。

3）调用InputDispatcher::enqueueInboundEventLocked把新构造的MotionEntry添加到InputDispatcher::mInboundQueue中，并返回是否需要唤醒mLooper<向pipe中写入数据>的标识。

以上操作都是在InputReader线程中完成的，现在应该InputDispatcher线程开始工作了。

4. 4 分发输入事件

InputDispatcherThread主循环如下：

Thread::_threadLoop->

InputDispatcherThread::threadLoop->

mDispatcher->dispatchOnce(InputDispatcher::dispatchOnce)->

dispatchOnceInnerLocked then

mLooper->pollOnce

下面先看看简单的mLooper->pollOnce

4.4.1 mLooper->pollOnce

其功能为等待超时或被pipe唤醒(InputReader线程调用InputDispatcher::notifyMotion时，InputDispatcher::notifyMotion根据情况调用mLooper->wake)。

其调用流程如下：

mLooper->pollOnce(int timeoutMillis)->

Looper::pollOnce(int timeoutMillis, int* outFd, int* outEvents, void** outData)->

4.4.2 dispatchOnceInnerLocked

1）从mInboundQueue从中依次取出EventEntry<MotionEntry的基类>，

2）调用InputDispatcher::dispatchMotionLocked处理此MotionEntry

3）调用InputDispatcher::dispatchEventToCurrentInputTargetsLocked

对于InputDispatcher::mCurrentInputTargets中的每一个InputTarget，并获取对应的Connection，调用InputDispatcher::prepareDispatchCycleLocked，

其相关代码如下：

[cpp] view plain copy

1. <spanstyle="font-size:10px;">for(size_ti=0;i<mCurrentInputTargets.size();i++){
2. constInputTarget&inputTarget=mCurrentInputTargets.itemAt(i);
4. ssize_tconnectionIndex=getConnectionIndexLocked(inputTarget.inputChannel);
5. if(connectionIndex>=0){
6. sp<Connection>connection=mConnectionsByReceiveFd.valueAt(connectionIndex);
7. prepareDispatchCycleLocked(currentTime,connection,eventEntry,&inputTarget,
8. resumeWithAppendedMotionSample);
9. }else{
10. #ifDEBUG_FOCUS
11. LOGD("Droppingeventdeliverytotargetwithchannel'%s'becauseit"
12. "isnolongerregisteredwiththeinputdispatcher.",
13. inputTarget.inputChannel->getName().string());
14. #endif
15. }
16. }</span>

4）InputDispatcher::prepareDispatchCycleLocked

4.1）调用enqueueDispatchEntryLocked创建DispatchEntry对象，并把它增加到Connection::outboundQueue队列中。

4.2）调用activateConnectionLocked把当前Connection增加到InputDispatcher::mActiveConnections链表中

4.3）调用InputDispatcher::startDispatchCycleLocked，接着它调用Connection::inputPublisher.publishMotionEvent来发布事件到ashmem buffer中，调用Connection::inputPublisher.sendDispatchSignal发送一个dispatch信号到InputConsumer通知它有一个新的消息到了，快来消费吧！关于消费者如何注册和如何消息的流程在下一个专题中再写。本文到此结束！！！

更多相关文章

1. android MMI（多媒体）接口--音乐播放器
2. Android之向中国天气网发送GET请求获取JSON数据实例
3. Android(安卓)包管理流程之包的解析
4. android：json解析库的选择
5. android servicemanager与binder源码分析三------如何进入内核通
6. Android(安卓)USB\HDMI等事件监听
7. Android之WebView总结
8. 内存管理 Memory Management for Android(安卓)Apps
9. PopupWindow与PopupMenu的用法

随机推荐

1. Android(安卓)工程混淆后无法找到自定义
2. Android(安卓)Handler（四）
3. Android之传感器(一)
4. 一种巧妙获取Android状态栏高度的办法
5. Cocos2dx杂记：仿Android提示Toast
6. 14天学会安卓开发(第十天)Android网络与
7. 在eclipse创建android 工程
8. Android开发学习
9. 今天的小收获
10. Android核心分析（链接）