![](http://static.blog.csdn.net/images/category_icon.jpg)
前言:
在网上看到好多关于android input device流程分析,但是都不全,有的只是从linux内核那边分析,有的从android上层分析,而且分析的代码也比较老,都是在android2.3以下,最近在做android4.0下的多点触摸以及校准程序,多点触摸的驱动很好写,在linux内核里面都有现成的例子,照着改就可以了。但是android下的校准程序比较复杂,一种是在android
Framework层进行,一种是在linux 内核层进行。
对于校准程序来说,需要全屏校准。但是在android4.0下面,下面的导航栏是systemui画的,无法去掉,因此在校准程序里面通过display得到分辨率高度比实际的小,差的那部分就是导航栏的高度。如果以小的高度进行校准,但使用实际的高度进行触摸坐标到屏幕坐标转换,就会导致触摸点偏下的问题。
为了解决这个问题,在网上找了很多资料,第一种就是想办法在校准程序里面得到整个屏幕的分辨率,进而让校准程序全屏显示,即把导航栏隐藏,在网上看到又网友用下面例子实现:
//for phone
getWindow().getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_HIDE_NAVIGATION);
//forpad View.SYSTEM_UI_FLAG_SHOW_FULLSCREEN= 4
getWindow().getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_SHOW_FULLSCREEN);
经过自己实验,这两个都无法隐藏下面的导航栏,而且在最新的sdk里面也没有SYSTEM_UI_FLAG_SHOW_FULLSCREEN的定义。第二种就是在jni种通过fb0得到系统的分辨率,这个是真实的分辨率,这种方法需要apk有root或者graphics组权限,才能打开fb0,而且android4.0根据触摸屏类型是否使用外部显示分辨率,如果使用外部display的话,那么就不能用fb0的分辨率。为了解决这个问题,把整个input touch流程都看了一边。废话少说,进入正题。
1 android inputtouch流程
Android inout touch流程分两部分,一部分是从androidframework开始,如何读取touch设备的事件并分发。一部分是从linux 内核开始,如何从触摸屏读取触摸坐标并送给touch设备。
2 androidframework层
2.1 文件结构
首先看看Event Input文件结构吧,在frameworks/base/services/input之下
2.2模块介绍
l Eventhub
它是系统中所有事件的中央处理站。它管理所有系统中可以识别的输入设备的输入事件,此外,当设备增加或删除时,EventHub将产生相应的输入事件给系统。EventHub通过getEvents函数,给系统提供一个输入事件流。它也支持查询输入设备当前的状态(如哪些键当前被按下)。而且EventHub还跟踪每个输入调入的能力,比如输入设备的类别,输入设备支持哪些按键。
l InputReader
InputReader从EventHub中读取原始事件数据(RawEvent),并由各个InputMapper处理之后输入对应的input listener.InputReader拥有一个InputMapper集合。它做的大部分工作在InputReader线程中完成,但是InputReader可以接受任意线程的查询。为了可管理性,InputReader使用一个简单的Mutex来保护它的状态。InputReader拥有一个EventHub对象,但这个对象不是它创建的,而是在创建InputReader时作为参数传入的。
l InputDispatcher
InputDispatcher负责把事件分发给输入目标,其中的一些功能(如识别输入目标)由独立的policy对象控制。
l InputManager
InputManager是系统事件处理的核心,它虽然不做具体的事,但管理工作还是要做的,比如接受我们客户的投诉和索赔要求,或者老板的出气筒。
InputManager使用两个线程:
1)InputReaderThread叫做"InputReader"线程,它负责读取并预处理RawEvent,applies policy并且把消息送入DispatcherThead管理的队列中。
2)InputDispatcherThread叫做"InputDispatcher"线程,它在队列上等待新的输入事件,并且异步地把这些事件分发给应用程序。
InputReaderThread类与InputDispatcherThread类不共享内部状态,所有的通信都是单向的,从InputReaderThread到InputDispatcherThread。两个类可以通过InputDispatchPolicy进行交互。
InputManager类从不与Java交互,而InputDispatchPolicy负责执行所有与系统的外部交互,包括调用DVM业务。
看看下图理解input下面几个模块的关系
2.3线程创建
SystemServer大家熟悉吧,它是android init进程启动的,它的任务就是启动android里面很多服务,并管理起来,如果大家不熟悉,请参考andorid启动流程分析
SystemServer.java(frameworks\base\services\java\com\android\server)里面
ServerThread::run调用
Slog.i(TAG,"Window Manager");
wm = WindowManagerService.main(context, power,
factoryTest !=SystemServer.FACTORY_TEST_LOW_LEVEL,
!firstBoot);
ServiceManager.addService(Context.WINDOW_SERVICE, wm);
WindowManagerService.java(frameworks\base\services\java\com\android\server\wm) 里面
WindowManagerService main调用
WMThread thr = new WMThread(context, pm, haveInputMethods,allowBootMsgs);
thr.start();
接着调用
WMThread:: run调用
WindowManagerService s = new WindowManagerService(mContext, mPM,
mHaveInputMethods, mAllowBootMessages);
接着在WindowManagerService里面调用
mInputManager = new InputManager(context,this);
至此我们创建了一个java层input设备管理器
InputManager.java(frameworks\base\services\java\com\android\server\wm) 里面
InputManager调用
nativeInit(mContext, mCallbacks,looper.getQueue());
从下面开始就进入native空间
com_android_server_InputManager.cpp(frameworks\base\services\jni)里面
nativeInit对应android_server_InputManager_nativeInit调用
gNativeInputManager = newNativeInputManager(contextObj, callbacksObj, looper);
在NativeInputManager里面调用
sp<EventHub> eventHub = new EventHub();
mInputManager = new InputManager(eventHub, this, this);
这个函数创建一个EventHub对象,然后把它作为参数来创建InputManager对象。特别注意,InputManager是在C++里,具体在InputManager.cpp里。EventHub类在EventHub.cpp里,这个类和input事件获取有关。
至此我们创建了一个native层input设备管理器,具体作用见上面说明
首先是去InputManager.cpp(frameworks\base\services\input) 文件里面
InputManager::InputManager调用
mDispatcher = newInputDispatcher(dispatcherPolicy);
mReader= new InputReader(eventHub, readerPolicy, mDispatcher);
initialize();
它创建了InputDispatcher对象,同时也创建了InputReader对象。并分别暂存于mDispatcher和mReader变量中。注意eventHub和mDispatcher都作为参数创建InputReader对象。后面还用initialize来初始化。下面是initialize函数的定义:
void InputManager::initialize() {
mReaderThread = newInputReaderThread(mReader);
mDispatcherThread = newInputDispatcherThread(mDispatcher);
}
它创建两个线程对象,一个是InputReaderThread线程对象,负责input事件的获取;另一个是InputDispatcherThread线程对象,负责input消息的发送。
(注:以上两个线程对象都有自己的threadLoop函数,它将在Thread::_threadLoop中被调用,这个Thread::_threadLoop是线程入口函数,线程在Thread::run中被真正地创建)
InputDispatcher.cpp(frameworks\base\services\input) 里面
InputDispatcher::InputDispatcher做一些准备工作
InputReader.cpp (frameworks\base\services\input)里面
InputReader::InputReader做一些准备工作
2.4线程启动
在上面讲到在WindowManagerService里面调用
mInputManager = new InputManager(context, this);
创建input 管理器
紧接着调用
mInputManager.start();
InputManager.java(frameworks\base\services\java\com\android\server\wm) 里面
start调用
Slog.i(TAG, "Starting inputmanager");
nativeStart();
从下面开始就进入native空间
com_android_server_InputManager.cpp(frameworks\base\services\jni)里面
nativeStart对应android_server_InputManager_nativeStart调用
status_t result =gNativeInputManager->getInputManager()->start();
InputManager.cpp(frameworks\base\services\input) 文件里面
InputManager::start调用
status_tresult = mDispatcherThread->run("InputDispatcher",PRIORITY_URGENT_DISPLAY);
result= mReaderThread->run("InputReader", PRIORITY_URGENT_DISPLAY);
上面两个线程对象是Thread子类,于是继承它的run方法,在Thread::run中,调用createThreadEtc函数,并以Thread::_threadLoop作为入口函数,以上面的mDispatcherThread或mReaderThread作为userdata创建线程,然后会调用threadLoop(),在Thread类中它是虚函数,得由子类来复写
因此会调用InputReader.cpp (frameworks\base\services\input)里面的threadLoop InputReaderThread::threadLoop调用
mReader->loopOnce();
mReader就是上面创建的inputreader对象,作为参数传给mReaderThread
InputReader::loopOnce调用
count = mEventHub->getEvents(timeoutMillis, mEventBuffer,EVENT_BUFFER_SIZE);
得到input 输入事件
processEventsLocked
处理input输入事件
因此会调用InputDispatcher.cpp (frameworks\base\services\input)里面的threadLoop InputDispatcherThread::threadLoop调用
mDispatcher->dispatchOnce ();
mDispatcher就是上面创建的InputDispatcher对象,作为参数传给mDispatcherThread
InputDispatcher::dispatchOnce调用
dispatchOnceInnerLocked(&nextWakeupTime)
dispatchOnceInnerLocked函数处理input输入消息,mLooper->pollOnce是等待下一次输入事件。
mLooper->pollOnce(timeoutMillis):
这个请看Looper.cpp文件中的Looper::pollOnce()函数。Looper里主要通过linux管道方式实现进程间通信,通过epoll机制实现外界事件请求作出响应。
至此整个androidinput event框架已经运转起来了,好像到现在还没有提到touch,别着急,且看下面的分析
2.5 event初始化
还记得android_server_InputManager_nativeInit里面创建
sp<EventHub> eventHub = newEventHub();
EventHub.cpp (frameworks\base\services\input) 里面
EventHub::EventHub初始化
mOpeningDevices(0) 表示需要打开的设备链表,为NULL
mClosingDevices(0) 表示需要关闭的设备链表,为NULL
mNeedToSendFinishedDeviceScan(false) 表示需要发送设备扫描完成,默认为0
mNeedToReopenDevices(false) 表示需要重新打开设备,默认为0
mNeedToScanDevices(true) 表示需要扫描设备,默认为1
mPendingEventCount(0) 表示需要处理event个数,默认为0
mPendingEventIndex(0) 表示当前需要处理event的索引,默认为0
mPendingINotify(false) 表示需要处理的通知,默认为0
mEpollFd = epoll_create(EPOLL_SIZE_HINT); epoll实例,在EventHub::EventHub中初始化此例,所有输入事件通过epoll_wait来获取
mINotifyFd = inotify_init();
intresult = inotify_add_watch(mINotifyFd, DEVICE_PATH, IN_DELETE | IN_CREATE);
创建mINotifyFd,用于监控/dev/input目录下删除和创建设备节点的事件
result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mINotifyFd,&eventItem)
将mINotifyFd注册到mEpollFd里面,通过epoll来监听mINotifyFd的变化
result = pipe(wakeFds);
mWakeReadPipeFd = wakeFds[0];
mWakeWritePipeFd = wakeFds[1];
result = fcntl(mWakeReadPipeFd, F_SETFL, O_NONBLOCK)
result = fcntl(mWakeWritePipeFd, F_SETFL, O_NONBLOCK)
创建唤醒管道,并设置为非阻塞,如果向mWakeWritePipeFd写,那么mWakeReadPipeFd就会有变化
eventItem.data.u32 = EPOLL_ID_WAKE;
result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mWakeReadPipeFd,&eventItem);
将mWakeReadPipeFd注册到mEpollFd里面,通过epoll来监听mWakeReadPipeFd的变化
至此EventHub对象以及构造完成了,mEpollFd监听mINotifyFd和mWakeReadPipeFd的变化。
2.6读取事件
在上面2.4节最后我们看到InputReaderThread线程里面会循环调用
InputReader::loopOnce 接着调用
count = mEventHub->getEvents(timeoutMillis, mEventBuffer,EVENT_BUFFER_SIZE);
这里的mEventHub就是上节实例化的eventhub,我们来看getEvents
EventHub.cpp (frameworks\base\services\input) 里面
EventHub::getEvents
for (;;) {
nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
进入for循环
// Reopen input devices if needed.
if (mNeedToReopenDevices) {
mNeedToReopenDevices = false;
LOGI("Reopening all input devices due to a configurationchange.");
closeAllDevicesLocked();
mNeedToScanDevices = true;
break; // return to the caller before we actually rescan
}
检查mNeedToReopenDevices是否为ture,如果为true,在closeAllDevicesLocked里面关闭所有打开的硬件设备描述符,并把需要删除的设备放在mClosingDevices链表里面,如果这个设备是在mOpeningDevices里面,就忽略跳过,并删除eventhub层的device对象。然后设置mNeedToScanDevices为true,因为mNeedToReopenDevices默认为false,所以不会执行这段代码
// Report any devices that had last been added/removed.
while (mClosingDevices) {
Device* device = mClosingDevices;
LOGV("Reporting device closed: id=%d, name=%s\n",
device->id,device->path.string());
mClosingDevices = device->next;
event->when = now;
event->deviceId = device->id == mBuiltInKeyboardId ? 0 :device->id;
event->type = DEVICE_REMOVED;
event += 1;
delete device;
mNeedToSendFinishedDeviceScan = true;
if (--capacity == 0) {
break;
}
}
检查mClosingDevices链表是否存在,如果存在,循环把需要删除的设备信息放在event里面,同时设置event type为DEVICE_REMOVED,并删除eventhub层的device对象。设置mNeedToSendFinishedDeviceScan为true。每循环一次,capacity减1,capacity等于0,就退出for循环,表明这次getEvents已经取得256个event事件了,返回给inputreader处理。因为一开始mClosingDevices不存在,所以不会执行这段代码,只有上面的closeAllDevicesLocked执行了,才会执行这段代码。
if(mNeedToScanDevices) {
mNeedToScanDevices = false;
scanDevicesLocked();
mNeedToSendFinishedDeviceScan = true;
}
检查mNeedToScanDevices是否为true,如果为true,就执行设备扫描。在scanDevicesLocked里面,会打开/dev/input目录,并把循环调用openDeviceLocked,在openDeviceLocked里面
int fd = open(devicePath, O_RDWR)
打开一个input设备
// Check to see if the device is on ourexcluded list
for (size_t i = 0; i <mExcludedDevices.size(); i++) {
const String8& item =mExcludedDevices.itemAt(i);
if (identifier.name == item) {
LOGI("ignoring event id %sdriver %s\n", devicePath, item.string());
close(fd);
return -1;
}
}
判断这个设备是否已经存在,如果存在,就关闭退出。
下面得到设备一系列信息。
Device* device= new Device(fd, deviceId, String8(devicePath), identifier);
创建一个eventhub层的device对象
// Load theconfiguration file for the device.
loadConfigurationLocked(device);
得到设备的idc配置文件,这就是为什么android4.0需要idc文件
// Figure outthe kinds of events the device reports.
ioctl(fd, EVIOCGBIT(EV_KEY,sizeof(device->keyBitmask)), device->keyBitmask);
ioctl(fd, EVIOCGBIT(EV_ABS,sizeof(device->absBitmask)), device->absBitmask);
ioctl(fd, EVIOCGBIT(EV_REL,sizeof(device->relBitmask)), device->relBitmask);
ioctl(fd, EVIOCGBIT(EV_SW,sizeof(device->swBitmask)), device->swBitmask);
ioctl(fd, EVIOCGBIT(EV_LED,sizeof(device->ledBitmask)), device->ledBitmask);
ioctl(fd,EVIOCGPROP(sizeof(device->propBitmask)), device->propBitmask);
得到设备各种配置,接下设置device的class,就设备的类型
// See if thisis a touch pad.
// Is this a new modern multi-touch driver?
if (test_bit(ABS_MT_POSITION_X,device->absBitmask)
&&test_bit(ABS_MT_POSITION_Y, device->absBitmask)) {
// Some joysticks such as the PS3controller report axes that conflict
// with the ABS_MT range. Try to confirm that the device really is
// a touch screen.
if (test_bit(BTN_TOUCH,device->keyBitmask) || !haveGamepadButtons) {
device->classes |=INPUT_DEVICE_CLASS_TOUCH | INPUT_DEVICE_CLASS_TOUCH_MT;
}
// Is this an old style single-touchdriver?
} else if (test_bit(BTN_TOUCH,device->keyBitmask)
&& test_bit(ABS_X,device->absBitmask)
&& test_bit(ABS_Y,device->absBitmask)) {
device->classes |= INPUT_DEVICE_CLASS_TOUCH;
}
上面就是根据驱动程序里面的设置来判断inputdevice是多点触摸还是单点触摸,现在是不是看到和触摸屏有点关系了
// Determinewhether the device is external or internal.
if (isExternalDeviceLocked(device)) {
device->classes |=INPUT_DEVICE_CLASS_EXTERNAL;
}
判断是不是外部设备,根据两个条件判断,一是在idc文件里面如果有“device.internal”存在,就是内部设备,否则是外部设备。如果没有这个域存在,根据硬件设备的总线判断,如果是usb和bluetooth bus,就是外部设备。这个留着后面有作用。
if(epoll_ctl(mEpollFd, EPOLL_CTL_ADD, fd, &eventItem))
将设备加入到mEpollFd监控里面
device->next= mOpeningDevices;
mOpeningDevices = device;
将设备加入需要打开设备链表里面
至此,/dev/input/下面所有的设备对于linux层都已经打开,并且都添加到了mEpollFd监控里面,但是android层面的device还没有添加和初始化,只是放在需要打开设备链表里面。接着设置mNeedToSendFinishedDeviceScan为true。因为mNeedToScanDevices初始化为true,因此第一次进入getEvents就会执行这部分代码。
while(mOpeningDevices != NULL) {
Device* device = mOpeningDevices;
LOGV("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;
mNeedToSendFinishedDeviceScan = true;
if (--capacity == 0) {
break;
}
}
检查mOpeningDevices链表是否存在,如果存在,循环把需要添加的设备信息放在event里面,同时设置event type为DEVICE_ADDED。设置mNeedToSendFinishedDeviceScan为true。每循环一次,capacity减1,capacity等于0,就退出for循环,表明这次getEvents已经取得256个event事件了,返回给inputreader处理。因为一开始会执行mNeedToScanDevices代码,只要/dev/input下面有设备节点存在,mOpeningDevices也会存在,所以开始就会执行这段代码。
if(mNeedToSendFinishedDeviceScan) {
mNeedToSendFinishedDeviceScan = false;
event->when = now;
event->type = FINISHED_DEVICE_SCAN;
event += 1;
if (--capacity == 0) {
break;
}
}
如果mNeedToSendFinishedDeviceScan为true,就把FINISHED_DEVICE_SCAN信息放在event里面,同时capacity减1,capacity等于0,就退出for循环,表明这次getEvents已经取得256个event事件了,返回给inputreader处理。
至此mEpollFd监听mINotifyFd,mWakeReadPipeFd和/dev/input里面所有设备的变化
// Grab the next input event.
bool deviceChanged = false;
while (mPendingEventIndex <mPendingEventCount) {
const struct epoll_event&eventItem = mPendingEventItems[mPendingEventIndex++];
上面这段代码通过mPendingEventIndex和 mPendingEventCount关系判断mEpollFd是否监听到了事件发生,如果有事件发声,从mPendingEventItems取出一个事件
if (eventItem.data.u32 ==EPOLL_ID_INOTIFY) {
if (eventItem.events &EPOLLIN) {
mPendingINotify = true;
} else {
LOGW("Receivedunexpected epoll event 0x%08x for INotify.", eventItem.events);
}
continue;
}
判断是否是EPOLL_ID_INOTIFY事件,即mINotifyFd有没有变化,也就是在有没有设备热拔插发声,如果有设置mPendingINotify为true,继续循环取下一个事件。如果不是继续往下走。
if (eventItem.data.u32 ==EPOLL_ID_WAKE) {
if (eventItem.events &EPOLLIN) {
LOGV("awoken afterwake()");
awoken = true;
char buffer[16];
ssize_t nRead;
do {
nRead =read(mWakeReadPipeFd, buffer, sizeof(buffer));
} while ((nRead == -1&& errno == EINTR) || nRead == sizeof(buffer));
} else {
LOGW("Receivedunexpected epoll event 0x%08x for wake read pipe.",
eventItem.events);
}
continue;
}
判断是不是EPOLL_ID_WAKE事件,即mWakeReadPipeFd有没有变化,如果有设置awoken为true,继续循环取下一个事件。如果不是EPOLL_ID_WAKE事件,继续往下走,肯定是有设备输入事件发生。
ssize_t deviceIndex =mDevices.indexOfKey(eventItem.data.u32);
if (deviceIndex < 0) {
LOGW("Received unexpectedepoll event 0x%08x for unknown device id %d.",
eventItem.events,eventItem.data.u32);
continue;
}
得到有事件发生的设备索引,如果deviceIndex < 0,有错误发声,继续循环取下一个事件。
Device* device =mDevices.valueAt(deviceIndex);
if (eventItem.events & EPOLLIN){
int32_t readSize =read(device->fd, readBuffer,
sizeof(structinput_event) * capacity);
if (readSize == 0 || (readSize< 0 && errno == ENODEV)) {
// Device was removedbefore INotify noticed.
LOGW("could not getevent, removed? (fd: %d size: %d bufferSize: %d capacity: %d errno:%d)\n",
device->fd,readSize, bufferSize, capacity, errno);
deviceChanged = true;
closeDeviceLocked(device);
} else if (readSize < 0) {
if (errno != EAGAIN&& errno != EINTR) {
LOGW("could not get event(errno=%d)", errno);
}
} else if ((readSize %sizeof(struct input_event)) != 0) {
LOGE("could not getevent (wrong size: %d)", readSize);
} else {
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++) {
const structinput_event& iev = readBuffer[i];
LOGV("%s got:t0=%d, t1=%d, type=%d, code=%d, value=%d",
device->path.string(),
(int)iev.time.tv_sec, (int) iev.time.tv_usec,
iev.type,iev.code, iev.value);
#ifdefHAVE_POSIX_CLOCKS
// Use the timespecified in the event instead of the current time
// so that downstreamcode can get more accurate estimates of
// event dispatchlatency from the time the event is enqueued onto
// the evdev clientbuffer.
//
// The event'stimestamp fortuitously uses the same monotonic clock
// time base as therest of Android. The kernel event devicedriver
//(drivers/input/evdev.c) obtains timestamps using ktime_get_ts().
// ThesystemTime(SYSTEM_TIME_MONOTONIC) function we use everywhere
// callsclock_gettime(CLOCK_MONOTONIC) which is implemented as a
// system call thatalso queries ktime_get_ts().
event->when =nsecs_t(iev.time.tv_sec) * 1000000000LL
+nsecs_t(iev.time.tv_usec) * 1000LL;
LOGV("event time%lld, now %lld", event->when, now);
#else
event->when = now;
#endif
event->deviceId =deviceId;
event->type =iev.type;
event->scanCode =iev.code;
event->value =iev.value;
event->keyCode =AKEYCODE_UNKNOWN;
event->flags = 0;
if (iev.type == EV_KEY&& device->keyMap.haveKeyLayout()) {
status_t err =device->keyMap.keyLayoutMap->mapKey(iev.code,
&event->keyCode,&event->flags);
LOGV("iev.code=%d keyCode=%d flags=0x%08x err=%d\n",
iev.code,event->keyCode, event->flags, err);
}
event += 1;
}
capacity -= count;
if (capacity == 0) {
// The result buffer isfull. Reset the pending event index
// so we will try toread the device again on the next iteration.
mPendingEventIndex -=1;
break;
}
}
} else {
LOGW("Received unexpectedepoll event 0x%08x for device %s.",
eventItem.events,device->identifier.name.string());
}
}
根据设备索引的设备文件句柄,通过read函数读取input_event事件,读取个数为capacity,根据read返回值readSize除以sizeof(struct input_event)得到实际读取的事件个数,然后循环把input_event赋给event,同时capacity减去读取事件个数,如果capacity等于0,就退出循环,表明这次getEvents已经取得256个event事件了,返回给inputreader处理。如果不等于0,判断mPendingEventIndex 和 mPendingEventCount关系,如果小于继续循环从mPendingEventItems取下一个事件,如果相等,就表示事件已经取完了,执行下面的代码
if (mPendingINotify &&mPendingEventIndex >= mPendingEventCount) {
mPendingINotify = false;
readNotifyLocked();
deviceChanged = true;
}
如果mPendingINotify为true,且mPendingEventIndex >= mPendingEventCount,就表明有设备热拔插事件发生,调用readNotifyLocked()
readNotifyLocked()调用
read(mINotifyFd, event_buf, sizeof(event_buf))
从event_buf循环取出inotify_event事件,包括设备节点创建或者删除,以及设备名字
如果是IN_CREATE,就调用openDeviceLocked打开设备,添加打开设备链表。如果是IN_DELETE,就调用closeDeviceByPathLocked关闭设备,添加关闭设备链表。并设置deviceChanged为true。
// Report added or removed devicesimmediately.
if (deviceChanged) {
continue;
}
如果deviceChanged为true,结束本次循环,从头执行循环,即立即执行设备添加或删除。
// Return now if we have collected anyevents or if we were explicitly awoken.
if (event != buffer || awoken) {
break;
}
如果event != buffer,就表示有event事件发生,或者awoken存在,结束循环,立即返回给inputreader处理event事件。
mPendingEventIndex = 0;
int pollResult = epoll_wait(mEpollFd, mPendingEventItems,EPOLL_MAX_EVENTS, timeoutMillis);
调用epoll_wait(mEpollFd,mPendingEventItems, EPOLL_MAX_EVENTS, timeoutMillis)之后,读到的epoll_event事件保存在mPendingEventItems,总共的事件数保存在mPendingEventCount,即
mPendingEventCount = size_t(pollResult);
当然,在调用epoll_wait之前,mPendingEventIndex被清0,直正的事件处理在上面的代码中。epoll_event只表明某个设备上有事件,并不包含事件内容,具体事件内容需要通过read来读取。
// All done, returnthe number of events we read.
return event - buffer;
返回得到的event个数,支持整个getEvents已经执行完成,所有的event事件都保存在inputreader传递的RawEvent里面,看看下面的图,理解数据结构的变化
2.7处理事件
在上面2.4节最后我们看到InputReaderThread线程里面会循环调用
InputReader::loopOnce 调用
count =mEventHub->getEvents(timeoutMillis, mEventBuffer, EVENT_BUFFER_SIZE);
读取事件,上一节已经介绍了,得到事件后,接着调用
processEventsLocked(mEventBuffer, count)
处理事件
在processEventsLocked里面主要分两步处理:
1)处理来自于事件驱动设备的事件(processEventsForDeviceLocked)
2)处理设备增加、删除和修改事件—为处理事件做准备
for (const RawEvent* rawEvent = rawEvents;count;) {
int32_t type = rawEvent->type;
进入for循环,取得本次循环头一个rawEvent,然后判断事件type,如果小于FIRST_SYNTHETIC_EVENT,就表示是真正的input事件,如果大于等于,就表示是input设备变化事件。
size_t batchSize = 1;
if (type < EventHubInterface::FIRST_SYNTHETIC_EVENT) {
int32_t devi#eId = rawEvent->deviceId;
while (batchSize < count) {
if (rawEvent[batchSize].type>= EventHubInterface::FIRST_SYNTHETIC_EVENT
||rawEvent[batchSize].deviceId != deviceId) {
break;
}
batchSize += 1;
}
#if DEBUG_RAW_EVENTS
LOGD("BatchSize: %d Count: %d", batchSize, count);
#endif
processEventsForDeviceLocked(deviceId, rawEvent, batchSize);
判断下一事件type,从rawEvent数组里面取得属于同一个设备的连续input事件,然后交给设备处理程序去处理,如果后面的事件不属于同一个设备,或者事件type是FIRST_SYNTHETIC_EVENT以后的事件,就终止查询,运行processEventsForDeviceLocked。
} 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:
LOG_ASSERT(false); // can'thappen
break;
}
}
如果事件type是FIRST_SYNTHETIC_EVENT以后的事件,是与Device相关的事件,这些事件是在EventHub::getEvents中产生的,并不是Kernel态的事件输入设备产生的。就调用设备添加,删除,配置变化等函数。
count -= batchSize;
rawEvent += batchSize;
去掉已经处理的事件,为下一次循环做准备。
}
至此,我们看到inputreader对getEvents得到的事件都有一一对应的处理。
2.7.1 处理事件准备—设备添加删除
按照程序执行流程,应该是先有设备,然后才会有设备事件,所以先分析设备增加。 其代码如下:
InputReader::addDeviceLocked
String8 name =mEventHub->getDeviceName(deviceId);
uint32_t classes = mEventHub->getDeviceClasses(deviceId);
得到设备名字和类型
InputDevice* device =createDeviceLocked(deviceId, name, classes);
得到一个inputreader层的device
device->configure(when, &mConfig, 0);
device->reset(when);
进行device配置和reset
if (device->isIgnored()) {
LOGI("Device added: id=%d, name='%s' (ignored non-inputdevice)", deviceId, name.string());
}else {
LOGI("Device added: id=%d, name='%s', sources=0x%08x",deviceId, name.string(),
device->getSources());
}
判断device的mapper是否存在,如果不存在,这个设备就不是input device
mDevices.add(deviceId, device);
新建的InputDevice增加到InputReader::mDevices中
InputReader::createDeviceLocked
InputDevice* device = newInputDevice(&mContext, deviceId, name, classes);
创建一个inputreader层的device
// External devices.
if (classes &INPUT_DEVICE_CLASS_EXTERNAL) {
device->setExternal(true);
}
根据类型设置是否是外部设备
接下来就是根据类型给device创建和增加事件转换器,即mapper,我们只分析touch
// Touchscreens and touchpad devices.
if(classes & INPUT_DEVICE_CLASS_TOUCH_MT) {
device->addMapper(new MultiTouchInputMapper(device));
}else if (classes & INPUT_DEVICE_CLASS_TOUCH) {
device->addMapper(new SingleTouchInputMapper(device));
}
根据多点还是单点分别创建事件转换器。我们只分析单点设备,我们的touch只有一个mapper--- SingleTouchInputMapper
SingleTouchInputMapper::SingleTouchInputMapper
它继承自TouchInputMapper--- InputMapper
做一些初始化的工作
InputDevice::addMapper
mMappers.add(mapper)
新建的InputMapper增加到InputDevice::mMappers
至此inputreader层的input device创建完成,并且每个device都创建了一个对应的事件转换器。
创建完就要进行配置
device->configure(when,&mConfig, 0);
InputDevice::configure
if (!isIgnored()) {
if (!changes) { // first time only
mContext->getEventHub()->getConfiguration(mId,&mConfiguration);
}
size_t numMappers = mMappers.size();
for (size_t i = 0; i < numMappers;i++) {
InputMapper* mapper = mMappers[i];
mapper->configure(when, config,changes);
mSources |=mapper->getSources();
}
}
判断mapper是否为空,如果不存在,就不需要配置。判断是否是配置改变,不是配置改变,那就是第一次进行配置,需要从eventhub里面得到设备的idc配置文件
接着对mapper进行配置,可能有多个事件转换器,一一对相应的mapper进行转换。
mapper->configure,我们分析的是单点touch,因此mapper对应的是SingleTouchInputMapper,它里面没有configure,继续找TouchInputMapper
TouchInputMapper::configure
InputMapper::configure(when, config,changes)
这个什么也没有做
if (!changes) { // first time only
// Configure basic parameters.
configureParameters();
// Configure common accumulators.
mCursorScrollAccumulator.configure(getDevice());
mTouchButtonAccumulator.configure(getDevice());
// Configure absolute axis information.
configureRawPointerAxes();
// Prepare input device calibration.
parseCalibration();
resolveCalibration();
}
如果是第一次配置,就进入里面,调用
TouchInputMapper::configureParameters
mParameters.gestureMode =getEventHub()->hasInputProperty(getDeviceId(), INPUT_PROP_SEMI_MT)
? Parameters::GESTURE_MODE_POINTER: Parameters::GESTURE_MODE_SPOTS;
首先从驱动文件里面得到mParameters.gestureMode类型
String8gestureModeString;
if(getDevice()->getConfiguration().tryGetProperty(String8("touch.gestureMode"),
gestureModeString)) {
if (gestureModeString =="pointer") {
mParameters.gestureMode =Parameters::GESTURE_MODE_POINTER;
} else if (gestureModeString =="spots") {
mParameters.gestureMode =Parameters::GESTURE_MODE_SPOTS;
} else if (gestureModeString !="default") {
LOGW("Invalid value fortouch.gestureMode: '%s'", gestureModeString.string());
}
}
如果idc文件有touch.gestureMode存在,使用idc文件的配置
if(getEventHub()->hasInputProperty(getDeviceId(), INPUT_PROP_DIRECT)) {
// The device is a touch screen.
mParameters.deviceType = Parameters::DEVICE_TYPE_TOUCH_SCREEN;
}else if (getEventHub()->hasInputProperty(getDeviceId(), INPUT_PROP_POINTER)){
// The device is a pointing device like a track pad.
mParameters.deviceType = Parameters::DEVICE_TYPE_POINTER;
}else if (getEventHub()->hasRelativeAxis(getDeviceId(), REL_X)
|| getEventHub()->hasRelativeAxis(getDeviceId(), REL_Y)) {
// The device is a cursor device with a touch pad attached.
// By default don't use the touch pad to move the pointer.
mParameters.deviceType = Parameters::DEVICE_TYPE_TOUCH_PAD;
}else {
// The device is a touch pad of unknown purpose.
mParameters.deviceType = Parameters::DEVICE_TYPE_POINTER;
}
从驱动文件里面得到touch的类型
String8 deviceTypeString;
if(getDevice()->getConfiguration().tryGetProperty(String8("touch.deviceType"),
deviceTypeString)) {
if (deviceTypeString == "touchScreen") {
mParameters.deviceType = Parameters::DEVICE_TYPE_TOUCH_SCREEN;
} else if (deviceTypeString == "touchPad") {
mParameters.deviceType = Parameters::DEVICE_TYPE_TOUCH_PAD;
} else if (deviceTypeString == "pointer") {
mParameters.deviceType = Parameters::DEVICE_TYPE_POINTER;
} else if (deviceTypeString != "default") {
LOGW("Invalid value for touch.deviceType: '%s'",deviceTypeString.string());
}
}
如果idc文件有touch.deviceType存在,使用idc文件的配置,这里我们配置是touchScreen,即mParameters.deviceType =Parameters::DEVICE_TYPE_TOUCH_SCREEN
mParameters.orientationAware= mParameters.deviceType == Parameters::DEVICE_TYPE_TOUCH_SCREEN;
getDevice()->getConfiguration().tryGetProperty(String8("touch.orientationAware"),
mParameters.orientationAware);
从idc文件里面得到mParameters.orientationAware的值
mParameters.associatedDisplayId= -1;
mParameters.associatedDisplayIsExternal =false;
if (mParameters.orientationAware
|| mParameters.deviceType ==Parameters::DEVICE_TYPE_TOUCH_SCREEN
|| mParameters.deviceType ==Parameters::DEVICE_TYPE_POINTER) {
mParameters.associatedDisplayIsExternal=
mParameters.deviceType ==Parameters::DEVICE_TYPE_TOUCH_SCREEN
&& getDevice()->isExternal();
mParameters.associatedDisplayId = 0;
}
根据mParameters.deviceType和getDevice()->isExternal来判断是否使用外部显示配置。在eventhub里面我们的触摸屏是usb bus,被配置成外部设备,触摸屏配置成DEVICE_TYPE_TOUCH_SCREEN,因此mParameters.associatedDisplayIsExternal等于1,及使用外部的显示配置。
至此TouchInputMapper::configureParameters配置完成
// Configure common accumulators.
mCursorScrollAccumulator.configure(getDevice());
mTouchButtonAccumulator.configure(getDevice());
配置光标和按键加速,都是根据驱动文件或者idc文件,这个都不需要。
// Configure absolute axisinformation.
configureRawPointerAxes();
配置原始信息,它先调用TouchInputMapper::configureRawPointerAxes
mRawPointerAxes.clear()先将 mRawPointerAxes清除干净
接着调用SingleTouchInputMapper::configureRawPointerAxes
getAbsoluteAxisInfo(ABS_X,&mRawPointerAxes.x);
getAbsoluteAxisInfo(ABS_Y, &mRawPointerAxes.y);
getAbsoluteAxisInfo(ABS_PRESSURE, &mRawPointerAxes.pressure);
getAbsoluteAxisInfo(ABS_TOOL_WIDTH, &mRawPointerAxes.toolMajor);
getAbsoluteAxisInfo(ABS_DISTANCE, &mRawPointerAxes.distance);
getAbsoluteAxisInfo(ABS_TILT_X, &mRawPointerAxes.tiltX);
getAbsoluteAxisInfo(ABS_TILT_Y,&mRawPointerAxes.tiltY);
InputMapper::getAbsoluteAxisInfo调用
getEventHub()->getAbsoluteAxisInfo从驱动文件里面得到需要参数
// Prepare input device calibration.
parseCalibration();
resolveCalibration();
根据idc文件配置校正参数。
if (!changes || (changes &InputReaderConfiguration::CHANGE_POINTER_SPEED)) {
// Update pointer speed.
mPointerVelocityControl.setParameters(mConfig.pointerVelocityControlParameters);
mWheelXVelocityControl.setParameters(mConfig.wheelVelocityControlParameters);
mWheelYVelocityControl.setParameters(mConfig.wheelVelocityControlParameters);
}
如果是第一次配置或者是改变速度,需要update pointer speed
bool resetNeeded = false;
if (!changes ||(changes & (InputReaderConfiguration::CHANGE_DISPLAY_INFO
|InputReaderConfiguration::CHANGE_POINTER_GESTURE_ENABLEMENT
|InputReaderConfiguration::CHANGE_SHOW_TOUCHES))) {
// Configuredevice sources, surface dimensions, orientation and
// scalingfactors.
configureSurface(when, &resetNeeded);
}
如果是第一次配置或者是显示等改变,需要调用configureSurface
TouchInputMapper::configureSurface
// Determine device mode.
if (mParameters.deviceType == Parameters::DEVICE_TYPE_POINTER
&&mConfig.pointerGesturesEnabled) {
mSource = AINPUT_SOURCE_MOUSE;
mDeviceMode = DEVICE_MODE_POINTER;
} else if (mParameters.deviceType ==Parameters::DEVICE_TYPE_TOUCH_SCREEN
&& mParameters.associatedDisplayId>= 0) {
mSource = AINPUT_SOURCE_TOUCHSCREEN;
mDeviceMode = DEVICE_MODE_DIRECT;
} else {
mSource = AINPUT_SOURCE_TOUCHPAD;
mDeviceMode = DEVICE_MODE_UNSCALED;
}
根据mParameters.deviceType决定mSource和mDeviceMode
// Ensure we have valid X and Y axes.
if(!mRawPointerAxes.x.valid || !mRawPointerAxes.y.valid) {
LOGW(INDENT"Touch device '%s' did not report support for X or Y axis! "
"Thedevice will be inoperable.", getDeviceName().string());
mDeviceMode =DEVICE_MODE_DISABLED;
return;
}
判断x和y参数是否有效,这里就是判断触摸屏x和y的坐标范围的,在eventhub里面,只要最大和最小不相等,就是有效的。如果无效,设备模式就是关闭的,不能使用。
// Get associated display dimensions.
if(mParameters.associatedDisplayId >= 0) {
if(!mConfig.getDisplayInfo(mParameters.associatedDisplayId,
mParameters.associatedDisplayIsExternal,
&mAssociatedDisplayWidth, &mAssociatedDisplayHeight,
&mAssociatedDisplayOrientation)) {
LOGI(INDENT"Touch device '%s' could not query the properties of its associated "
"display %d. The device willbe inoperable until the display size "
"becomes available.",
getDeviceName().string(), mParameters.associatedDisplayId);
mDeviceMode =DEVICE_MODE_DISABLED;
return;
}
}
根据associatedDisplayId和associatedDisplayIsExternal得到显示屏的分辨率,associatedDisplayId在configureParameters里面设为0,associatedDisplayIsExternal根据触摸屏类型和bus设为1.
调用InputReaderConfiguration::getDisplayInfo得到设置好的surface size。
if(displayId == 0) {
const DisplayInfo& info = external? mExternalDisplay : mInternalDisplay;
if (info.width > 0 &&info.height > 0) {
if (width) {
*width = info.width;
}
if (height) {
*height = info.height;
}
if (orientation) {
*orientation =info.orientation;
}
return true;
}
}
可以看到android4.0里面,分内部和外部分辨率两种。如果info里面都是0,这个函数返回false,就表示android设备还没有走到设置surface size这一步,就会打印提示信息,稍后android启动里面就会执行设置surface size的程序。
// Configure dimensions.
int32_t width, height,orientation;
if (mDeviceMode ==DEVICE_MODE_DIRECT || mDeviceMode == DEVICE_MODE_POINTER) {
width =mAssociatedDisplayWidth;
height =mAssociatedDisplayHeight;
orientation =mParameters.orientationAware ?
mAssociatedDisplayOrientation : DISPLAY_ORIENTATION_0;
} else {
width =mRawPointerAxes.x.maxValue - mRawPointerAxes.x.minValue + 1;
height =mRawPointerAxes.y.maxValue - mRawPointerAxes.y.minValue + 1;
orientation =DISPLAY_ORIENTATION_0;
}
根据mDeviceMode类型设置宽和高参数,根据上面的分析宽和高就是取自显示屏的分辨率。
bool sizeChanged = mSurfaceWidth != width || mSurfaceHeight !=height;
if (sizeChanged ||deviceModeChanged) {
LOGI("Devicereconfigured: id=%d, name='%s', surface size is now %dx%d, mode is %d",
getDeviceId(), getDeviceName().string(), width, height, mDeviceMode);
mSurfaceWidth =width;
mSurfaceHeight =height;
// Configure X andY factors.
mXScale =float(width) / (mRawPointerAxes.x.maxValue - mRawPointerAxes.x.minValue + 1);
mYScale = float(height) / (mRawPointerAxes.y.maxValue -mRawPointerAxes.y.minValue + 1);
mXPrecision = 1.0f/ mXScale;
mYPrecision = 1.0f/ mYScale;
如果显示屏分辨率不等于开始保存的,就需要重新设置一些参数。红色部分就是显示屏分辨率和触摸屏坐标范围得到的转换因子,使用这个转换因子就可以把触摸屏坐标转换成屏幕坐标。
接着下面是根据校准参数配置校准因子的。这里我们不使用这种方式,所以不执行
下面如果sizeChanged改变,重新配置一些参数,同时设置
*outResetNeeded = true;
至此configureSurface执行完成,与触摸屏坐标有关的配置也完成了。
if (changes && resetNeeded) {
// Send reset, unless this is the firsttime the device has been configured,
// in which case the reader will callreset itself after all mappers are ready.
getDevice()->notifyReset(when);
}
如果有改变而且需要reset,reader将reset自己
至此Input Device的configure和mapper configure都已完成完成
配置完成就要进行初始化
device->reset(when);
调用InputDevice::reset
mapper->reset(when)
mapper初始化
至此整个InputReader::addDeviceLocked已经分析完成了,到了这一步,我们的整个input系统都已经准备好去接收真正的input event并处理。
分析设备删除, 其代码如下:
void InputReader::removeDeviceLocked(nsecs_twhen, int32_t deviceId) {
InputDevice* device = NULL;
ssize_t deviceIndex =mDevices.indexOfKey(deviceId);
if (deviceIndex >= 0) {
device = mDevices.valueAt(deviceIndex);
mDevices.removeItemsAt(deviceIndex, 1);
把设备从mDevices链表里面移除
} else {
LOGW("Ignoring spurious deviceremoved event for deviceId %d.", deviceId);
return;
}
if (device->isIgnored()) {
LOGI("Device removed: id=%d,name='%s' (ignored non-input device)",
device->getId(),device->getName().string());
} else {
LOGI("Device removed: id=%d,name='%s', sources=0x%08x",
device->getId(), device->getName().string(),device->getSources());
}
device->reset(when);
清除device配置
delete device;
删除device
}
InputReader::processEventsLocked设备增加、删除处理总结:
它负责处理inputreader层Device 增加、删除事件。增加事件的流程为:为一个新增的Device创建一个InputDevice,并增加到InputReader::mDevices中;根据新增加设备的class类别,创建对应的消息转换器(InputMapper),然后此消息转换器加入InputDevice::mMappers中。消息转换器负责把读取的RawEvent转换成特定的事件,以供应用程序使用。
EventHub与InputReader各自管理功能:
l EventHub管理一堆Device,每一个Device与Kernel中一个事件输入设备对应
l InputReader管理一堆InputDevice,每一个InputDevice与EventHub中的Device对应
l InputDevice管理一些与之相关的InputMapper,每个device类型不同,会有一个InputMapper或者多个InputMapper,如我们touch只有:SingleTouchInputMapper。
下面再来看看inputreader里面touch类的关系
2.7.2 处理事件准备—设置surface size
上一节讲到input device的touch mapper配置时,会得到surface size,如果得到为0,就会把mDeviceMode配置为DEVICE_MODE_DISABLED,表示这个设备暂时无法使用,因此即使我们的input系统都准备好了,但是touch还是无法使用。下面讲如何配置surface size。
在2.3节线程创建里面看到:
SystemServer.java(frameworks\base\services\java\com\android\server)里面
ServerThread::run调用
Slog.i(TAG,"Window Manager");
wm = WindowManagerService.main(context, power,
factoryTest !=SystemServer.FACTORY_TEST_LOW_LEVEL,
!firstBoot);
ServiceManager.addService(Context.WINDOW_SERVICE, wm);
下面接着就会调用
try{
wm.displayReady(); wm就是上面创建的,为后面整个显示做准备
} catch (Throwable e) {
reportWtf("making display ready", e);
}
WindowManagerService.java(frameworks\base\services\java\com\android\server\wm) 里面
displayReady里面调用
WindowManager wm =(WindowManager)mContext.getSystemService(Context.WINDOW_SERVICE);
mDisplay = wm.getDefaultDisplay();
mInitialDisplayWidth =mDisplay.getRawWidth();
mInitialDisplayHeight = mDisplay.getRawHeight();
得到原始显示分辨率,这时就是整个屏幕的分辨率
mInputManager.setDisplaySize(Display.DEFAULT_DISPLAY,
mDisplay.getRawWidth(),mDisplay.getRawHeight(),
mDisplay.getRawExternalWidth(), mDisplay.getRawExternalHeight());
mInputManager是在WindowManagerService一开始就创建的,我们来看看setDisplaySize里面后四个参数:
publicint getRawWidth() {
int w = getRawWidthNative();
if (DEBUG_DISPLAY_SIZE) Slog.v(
TAG, "Returning rawdisplay width: " + w);
return w;
}
private native int getRawWidthNative();
publicint getRawHeight() {
int h = getRawHeightNative();
if (DEBUG_DISPLAY_SIZE) Slog.v(
TAG, "Returning rawdisplay height: " + h);
return h;
}
private native int getRawHeightNative();
这两个函数要调用native空间函数
android_view_Display.cpp(frameworks\base\core\jni)
staticjint android_view_Display_getRawWidthNative(
JNIEnv* env, jobject clazz)
{
DisplayID dpy = env->GetIntField(clazz,offsets.display);
return SurfaceComposerClient::getDisplayWidth(dpy);
}
staticjint android_view_Display_getRawHeightNative(
JNIEnv* env, jobject clazz)
{
DisplayID dpy = env->GetIntField(clazz,offsets.display);
returnSurfaceComposerClient::getDisplayHeight(dpy);
}
可以看到通过surface的client端得到屏幕的分辨率。
如何得到外部分辨率
publicint getRawExternalWidth() {
return 1280;
}
/**
* If the display is mirrored to anexternal HDMI display, returns the
* height of that display.
* @hide
*/
public int getRawExternalHeight() {
return 720;
}
可以看到如果设备外界hdmi显示,就用1280*720分辨率,这里有个疑问:如果客户设备外的是1920*1080的hdmi,那么这两个值是否需要变化?而且看这两个函数用处,只有触摸坐标转换和HeightReceiver.java使用,如果使用外部分辨率,那么android显示系统是如何知道的?
继续看mInputManager.setDisplaySize
InputManager.java(frameworks\base\services\java\com\android\server\wm) 里面
setDisplaySize调用
nativeSetDisplaySize(displayId,width, height, externalWidth, externalHeight);
从下面开始就进入native空间
com_android_server_InputManager.cpp(frameworks\base\services\jni)里面
nativeSetDisplaySize对应android_server_InputManager_nativeSetDisplaySize调用
gNativeInputManager->setDisplaySize(displayId,width, height, externalWidth, externalHeight);
在setDisplaySize里面判断
if (mLocked.displayWidth != width || mLocked.displayHeight !=height) {
changed = true;
mLocked.displayWidth = width;
mLocked.displayHeight = height;
sp<PointerController> controller = mLocked.pointerController.promote();
if (controller != NULL) {
controller->setDisplaySize(width, height);
}
}
if (mLocked.displayExternalWidth != externalWidth
||mLocked.displayExternalHeight != externalHeight) {
changed = true;
mLocked.displayExternalWidth = externalWidth;
mLocked.displayExternalHeight = externalHeight;
}
如果这次设置的值和旧值相等,就什么也不做退出。如果不相等,设置changed = true,同时保存新的值
if(changed) {
mInputManager->getReader()->requestRefreshConfiguration(
InputReaderConfiguration::CHANGE_DISPLAY_INFO);
}
如果值有变化,就调用inputreader刷新配置,提示是displayinfo改变
首先是去InputManager.cpp(frameworks\base\services\input) 文件里面
getReader()
returnmReader;
这个就是InputManager创建是创建的inputreader
InputReader.cpp (frameworks\base\services\input)里面
InputReader::requestRefreshConfiguration调用
if (changes) {
bool needWake =!mConfigurationChangesToRefresh;
mConfigurationChangesToRefresh |= changes;
if (needWake) {
mEventHub->wake();
}
}
如果改变类型不为0,就mConfigurationChangesToRefresh取反送给needWake,mConfigurationChangesToRefresh表示需要改变配置的类型集合,初始化为0,因此needWake就为1,同时把改变类型与给mConfigurationChangesToRefresh,接着判断needWake,如果为1,就进入mEventHub的唤醒程序。
这段话意思就是如果有正在改变配置需求,就表明整个input系统正在运行,所以不需要唤醒。只需要把新的改变类型放在mConfigurationChangesToRefresh就行了,如果没有,那么input系统有可能在睡眠,为了快速响应改变,需要唤醒整个input系统。
EventHub.cpp(frameworks\base\services\input)里面
EventHub::wake()调用
nWrite = write(mWakeWritePipeFd, "W",1);
直接向mWakeWritePipeFd管道里面写一个字符。前面2.5节讲到mWakeReadPipeFd已经被mEpollFd监控了,向mWakeWritePipeFd写就会引起mWakeReadPipeFd变化。在EventHub::getEvents里面就会执行if (eventItem.data.u32 == EPOLL_ID_WAKE)这个分支,设置awoken为true,当mPendingEventItems事件处理完,就会判断awoken,如果为true就立即结束循环,返回给inputreader进行处理。
至此,配置surface size执行部分结束了,但是size并没有真正配置到mExternalDisplay和mInternalDisplay里面,只是改变类型放在mConfigurationChangesToRefresh里面,真正的size还保存在NativeInputManager的mLocked里面
这时并没有输入事件或者设备变化发生,因此InputReader::loopOnce很快结束,进入下一次循环
InputReader::loopOnce 接着调用
uint32_t changes =mConfigurationChangesToRefresh;
if (changes) {
mConfigurationChangesToRefresh = 0;
refreshConfigurationLocked(changes);
}
InputReader::refreshConfigurationLocked
mPolicy->getReaderConfiguration(&mConfig);
mPolicy就是NativeInputManager的对象,在创建inputreader传入的。
com_android_server_InputManager.cpp(frameworks\base\services\jni)里面
NativeInputManager::getReaderConfiguration调用
{ // acquire lock
AutoMutex _l(mLock)
outConfig->setDisplayInfo(0, false/*external*/,
mLocked.displayWidth,mLocked.displayHeight, mLocked.displayOrientation);
outConfig->setDisplayInfo(0, true/*external*/,
mLocked.displayExternalWidth,mLocked.displayExternalHeight,
mLocked.displayOrientation);
} // release lock
outConfig就是inputreader里面的mConfig,因此调用
InputReaderConfiguration::setDisplayInfo
if (displayId == 0) {
DisplayInfo& info = external ?mExternalDisplay : mInternalDisplay;
info.width = width;
info.height = height;
info.orientation = orientation;
}
看到没有,饶了一个大圈,这里才把surface size真正放在mExternalDisplay和 mInternalDisplay里面,供后面调用InputReaderConfiguration::getDisplayInfo时使用。
refreshConfigurationLocked函数会在inputreader创建时执行一次,但那个时候input device还没有创建,而且changes为0,因此不会执行下面的部分。
if (changes &InputReaderConfiguration::CHANGE_MUST_REOPEN) {
mEventHub->requestReopenDevices();
如果改变类型是reopen,就调用eventhub的requestReopenDevices
EventHub::requestReopenDevices里面设置mNeedToReopenDevices = true,这个会在EventHub::getEvents里面进行判断,前面2.6节已经讲了
} else {
for (size_t i = 0; i <mDevices.size(); i++) {
InputDevice* device =mDevices.valueAt(i);
device->configure(now,&mConfig, changes);
}
}
得到所有的device,循环调用每个device的configure去重新配置。
InputDevice::configure已经在InputReader::addDeviceLocked讲过了,刚开始第一次配置changes是0,表示需要全面的初始化。现在只需要配置改变的部分了。
至此,我们整个inputtouch的工作环境已经配置好了,就等有触摸事件发生然后处理了
2.7.3处理来自于事件驱动设备的事件
InputReader::processEventsForDeviceLocked,它负责处理来自于同一个设备且在mEventBuffer中连续的多个事件,其函数原型如下:
ssize_t deviceIndex =mDevices.indexOfKey(deviceId);
if (deviceIndex < 0) {
LOGW("Discarding event for unknowndeviceId %d.", deviceId);
return;
}
得到发生事件设备索引
InputDevice*device = mDevices.valueAt(deviceIndex);
根据索引得到发生事件的device
if (device->isIgnored()) {
//LOGD("Discarding event forignored deviceId %d.", deviceId);
return;
}
如果device没有mapper,就返回不做任何处理。
device->process(rawEvents,count);
调用process处理
InputDevice::process
for(const RawEvent* rawEvent = rawEvents; count--; rawEvent++)
一次取出每一个事件
for(size_t i = 0; i < numMappers; i++) {
InputMapper* mapper =mMappers[i];
mapper->process(rawEvent);
}
对每一个事件都用这个device所有mapper进行处理
从上面的代码中可以看出,在InputDevice::process中,对于传入的每一个RawEvent,依次调用InputDevice中的每一个InputMapper来进行处理。前面提到过,InputDevice包含一组处理对应设备事件InputMapper,现在这些InputMapper开始干活了。
因为我们的touch只有一个SingleTouchInputMapper
这里先说说单点touch需要处理事件集合
代码:
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
SingleTouchInputMapper::process调用
TouchInputMapper::process(rawEvent);
TouchInputMapper::process
mCursorButtonAccumulator.process(rawEvent);
因为是touch,rawEvent->type 是 EV_KEY,但是rawEvent->scanCode不匹配里面任何值,不起任何作用
mCursorScrollAccumulator.process(rawEvent);
因为是touch,rawEvent->type是 EV_KEY,不是EV_REL,不起任何作用
mTouchButtonAccumulator.process(rawEvent);
TouchButtonAccumulator::process
if(rawEvent->type == EV_KEY) {
switch (rawEvent->scanCode) {
case BTN_TOUCH:
mBtnTouch = rawEvent->value;
break;
可以看到把BTN_TOUCH的值放在mBtnTouch里面
接着处理坐标信息:
mSingleTouchMotionAccumulator.process(rawEvent)
SingleTouchMotionAccumulator::process
caseABS_X:
mAbsX = rawEvent->value;
break;
case ABS_Y:
mAbsY = rawEvent->value;
break;
将坐标信息保存在mAbsX和mAbsY里面
当BTN_TOUCH,ABS_X和ABS_Y处理完,接下来就会处理EV_SYN事件
在TouchInputMapper::process里面,
if(rawEvent->type == EV_SYN && rawEvent->scanCode == SYN_REPORT) {
sync(rawEvent->when);
}
TouchInputMapper::sync调用
syncTouch(when,&havePointerIds)
SingleTouchInputMapper::syncTouch
if(mTouchButtonAccumulator.isToolActive()) {
判断BTN_TOUCH是否等于1,即是否有touchdown,如果有进入下面处理
mCurrentRawPointerData.pointerCount = 1;设置触摸点数1
mCurrentRawPointerData.idToIndex[0] = 0; 触摸点索引为0
RawPointerData::Pointer& outPointer =mCurrentRawPointerData.pointers[0];
outPointer.id = 0;
outPointer.x = mSingleTouchMotionAccumulator.getAbsoluteX();
outPointer.y = mSingleTouchMotionAccumulator.getAbsoluteY();
outPointer.pressure =mSingleTouchMotionAccumulator.getAbsolutePressure();
outPointer.touchMajor = 0;
outPointer.touchMinor = 0;
outPointer.toolMajor = mSingleTouchMotionAccumulator.getAbsoluteToolWidth();
outPointer.toolMinor =mSingleTouchMotionAccumulator.getAbsoluteToolWidth();
outPointer.orientation = 0;
outPointer.distance =mSingleTouchMotionAccumulator.getAbsoluteDistance();
outPointer.tiltX =mSingleTouchMotionAccumulator.getAbsoluteTiltX();
outPointer.tiltY = mSingleTouchMotionAccumulator.getAbsoluteTiltY();
outPointer.toolType = mTouchButtonAccumulator.getToolType();
if (outPointer.toolType == AMOTION_EVENT_TOOL_TYPE_UNKNOWN) {
outPointer.toolType = AMOTION_EVENT_TOOL_TYPE_FINGER;
}
outPointer.isHovering = isHovering;
把相关的信息放在mCurrentRawPointerData.pointers[0]里面,这里主要是x,y坐标
TouchInputMapper::sync继续处理
//Reset state that we will compute below.
mCurrentFingerIdBits.clear();
mCurrentStylusIdBits.clear();
mCurrentMouseIdBits.clear();
mCurrentCookedPointerData.clear();
这几个清零,后面填入相应的值
if (mDeviceMode== DEVICE_MODE_DISABLED) {
// Drop all input if the device isdisabled.
mCurrentRawPointerData.clear();
mCurrentButtonState = 0;
}
如果设备状态是关闭的,就把mCurrentRawPointerData保存的数据清除,返回
uint32_t policyFlags = 0;
bool initialDown =mLastRawPointerData.pointerCount == 0
&&mCurrentRawPointerData.pointerCount != 0;
bool buttonsPressed =mCurrentButtonState & ~mLastButtonState;
if (initialDown || buttonsPressed) {
// If this is a touch screen, hidethe pointer on an initial down.
if (mDeviceMode ==DEVICE_MODE_DIRECT) {
getContext()->fadePointer();
}
// Initial downs on external touchdevices should wake the device.
// We don't do this for internaltouch screens to prevent them from waking
// up in your pocket.
// TODO: Use the input deviceconfiguration to control this behavior more finely.
if (getDevice()->isExternal()) {
policyFlags |=POLICY_FLAG_WAKE_DROPPED;
}
}
判断是不是第一次按下,如果是,Ifthis is a touch screen, hide the pointer on an initial down。
如果是外部设备,就唤醒整个系统,如果是内部设备,就不用唤醒,注释写的很清楚,有可能放在口袋里面误触摸唤醒系统
// Consume rawoff-screen touches before cooking pointer data.
// If touches are consumed, subsequentcode will not receive any pointer data.
if (consumeRawTouches(when,policyFlags)) {
mCurrentRawPointerData.clear();
如果是唤醒设备的点击,就把mCurrentRawPointerData清零,只需要唤醒设备就行了。
cookPointerData();
进行触摸坐标到原始坐标的转换
TouchInputMapper::cookPointerData
首先进行一系列的坐标校准,接下来进行坐标转换
//X and Y
// Adjust coords for surface orientation.
float x, y;
switch (mSurfaceOrientation) {
case DISPLAY_ORIENTATION_90:
x = float(in.y -mRawPointerAxes.y.minValue) * mYScale;
y = float(mRawPointerAxes.x.maxValue - in.x) * mXScale;
orientation -= M_PI_2;
if (orientation < - M_PI_2) {
orientation += M_PI;
}
break;
case DISPLAY_ORIENTATION_180:
x = float(mRawPointerAxes.x.maxValue - in.x) * mXScale;
y = float(mRawPointerAxes.y.maxValue - in.y) * mYScale;
break;
case DISPLAY_ORIENTATION_270:
x = float(mRawPointerAxes.y.maxValue - in.y) * mYScale;
y = float(in.x - mRawPointerAxes.x.minValue) * mXScale;
orientation += M_PI_2;
if (orientation > M_PI_2) {
orientation -= M_PI;
}
break;
default:
x = float(in.x - mRawPointerAxes.x.minValue) * mXScale;
y = float(in.y - mRawPointerAxes.y.minValue) * mYScale;
break;
}
在TouchInputMapper::configureSurface里面
通过mConfig.getDisplayInfo(mParameters.associatedDisplayId,
mParameters.associatedDisplayIsExternal,
&mAssociatedDisplayWidth,&mAssociatedDisplayHeight,
&mAssociatedDisplayOrientation))
得到mAssociatedDisplayOrientation的值,这个值是通过setDisplayInfo从mLocked.displayOrientation得到的。在NativeInputManager创建是初始化这个值
mLocked.displayOrientation =DISPLAY_ORIENTATION_0
orientation = mParameters.orientationAware?
mAssociatedDisplayOrientation :DISPLAY_ORIENTATION_0;
mParameters.orientationAware是idc文件里面的值,我们这里是1,即
orientation = mAssociatedDisplayOrientation默认为DISPLAY_ORIENTATION_0
bool orientationChanged =mSurfaceOrientation != orientation;
if (orientationChanged) {
mSurfaceOrientation = orientation;
}
mSurfaceOrientation = orientation = mAssociatedDisplayOrientation= mLocked.displayOrientation
因此在cookPointerData会执行
x = float(in.x - mRawPointerAxes.x.minValue) * mXScale;
y = float(in.y - mRawPointerAxes.y.minValue) * mYScale;
这就是坐标转换的地方,in.x和in.y是触摸屏坐标,mRawPointerAxes.x.minValue和mRawPointerAxes.y.minValue是触摸屏坐标范围最小值,mXScale和mYScale就是
mXScale= float(width) / (mRawPointerAxes.x.maxValue - mRawPointerAxes.x.minValue + 1);
mYScale = float(height) / (mRawPointerAxes.y.maxValue - mRawPointerAxes.y.minValue+ 1);
把它们和在一起就是http://source.android.com/tech/input/touch-devices.html这个里面说的:
For a touch screen, the systemautomatically interpolates the reported touch positions in surface units toobtain touch positions in display pixels according to the followingcalculation:
displayX = (x - minX) * displayWidth / (maxX - minX + 1)
displayY = (y - minY) * displayHeight / (maxY - minY + 1)
接着把转换后的坐标放在out里面
PointerCoords& out =mCurrentCookedPointerData.pointerCoords[i];
out.clear();
out.setAxisValue(AMOTION_EVENT_AXIS_X, x);
out.setAxisValue(AMOTION_EVENT_AXIS_Y, y);
dispatchTouches(when, policyFlags) 调用
if(currentIdBits == lastIdBits)
如果当前点id和上一次id相同,表明这是个移动事件,不是的话就判断是down,up或者move,然后调用dispatchMotion,它的第四个参数就是down,up,move等类型
在dispatchMotion中,根据cooked数据创建NotifyMotionArg对象,它描述了一个移动事件,接着调用TouchInputMapper::getListener()->notifyMotion(&args)
TouchInputMapper::getListener()调用mContext->getListener(),此mContext为InputReader::mContext,所以其getListener()返回的则为InputReader::mQueuedListener,则最后调用QueuedInputListener::notifyMotion
QueuedInputListener::notifyMotion(constNotifyMotionArgs* args) {
mArgsQueue.push(newNotifyMotionArgs(*args));
}
把传递过来的NotifyMotionArg参数复制一份,然后加入QueuedInputListener::mArgsQueue例表中
补充1)InputReader::mContext在构造时用自己的指针初始化了mContext,从而mContext::mReader则为此InputReader实例。
补充2)在InputReader::createDeviceLocked中创建InputDevice时,把自己的mContext作为参数传入,从而把它保存在InputDevice::mContext中;在创建InputMapper时,以InputDevice作为参数,且InputMapper把它保存在mDevice中,然后从把InputDevice中的mContext也保存在InputMapper的mContext中。
dispatchHoverEnterAndMove(when,policyFlags);
调用dispatchMotion
至此整个processEventsLocked处理流程结束,已经把来自于事件设备的事件处理之后放入到各种NotifyArgs(如NotifyMotionArgs)之中,然后把这些各种NotifyArgs加入InputReader::mQueuedListener::mArgsQueue链表中。接着InputReader::loopOnce调用
mQueuedListener->flush()
Flush函数就是要把mArgsQueue中的所有NotifyArgs进行处理。
voidQueuedInputListener::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();
}
调用链表中每个NotifyArgs的notify函数,且有一个有意思的参数 mInnerListener,这个参数在前面多次提到过,它是在创建mQueuedListener时提供的,它其实就是InputManager中的mDispatcher,前面一直在InputReader中打转转,现在终于看到InputDispatcher登场了,说明事件很快就可以谢幕了。
再向下看一下吧,这么多类NotifyArgs,为描述方便,下面以NotifyMotionArgs为例,其代码为:
voidNotifyMotionArgs::notify(const sp<InputListenerInterface>& listener)const {
listener->notifyMotion(this);
}
下面就看看InputDispatcher(mDispatcher)的notifyMotion函数做了些什么。这个InputDispatcher::notifyMotion(constNotifyMotionArgs* args)可就不简单了。
在InputDispatcher::notifyMotion中,
1)根据NotifyMotionArgs提供的信息,构造一个MotionEvent,再调用mPolicy->filterInputEvent看是否需要丢弃此事件,如果需要丢弃则马上返加。其中mPolicy为NativeInputManager实例,在构造InputDispatcher时提供的参数。
2)对于AMOTION_EVENT_ACTION_MOVE事件,则从mInboundQueue队列里面寻找到对应的entry,把args信息放在这个entry里面
3)对于AMOTION_EVENT_ACTION_UP或AMOTION_EVENT_ACTION_DOWN事件,则直接根据NotifyMotionArgs提供的信息,构造一个MotionEntry。
4)调用InputDispatcher::enqueueInboundEventLocked把新构造的MotionEntry添加到InputDispatcher::mInboundQueue中,并返回是否需要唤醒mLooper<向pipe中写入数据>的标识。
if(needWake) {
mLooper->wake();
}
根据表示唤醒mLooper
以上操作都是在InputReader线程中完成的,现在应该InputDispatcher线程开始工作了。
至此InputReader::loopOnce一次循环结束,所有的input事件已经处理并放在了InputDispatcher::mInboundQueue里面
事件处理相关数据结构如下图所示:
至此的消息结构变化流程:
2.8分发事件
前面线程启动提到InputDispatcher::dispatchOnce调用
mLooper->pollOnce(timeoutMillis);
其功能为等待超时或被pipe唤醒(InputReader线程调用InputDispatcher::notifyMotion时, InputDispatcher::notifyMotion根据情况调用mLooper->wake)。
其调用流程如下:
mLooper->pollOnce(inttimeoutMillis)->
Looper.cpp(frameworks\base\libs\utils)
Looper::pollOnce(inttimeoutMillis, int* outFd, int* outEvents, void** outData)
如果没有事件输入,那么InputDispatcher::dispatchOnce 就会被阻塞在pollOnce,调用mLooper->wake唤醒。就会重新执行dispatchOnce,就会调用dispatchOnceInnerLocked
InputDispatcher::dispatchOnceInnerLocked
1)从mInboundQueue从中依次取出EventEntry<MotionEntry的基类>,
2)调用InputDispatcher::dispatchMotionLocked处理此MotionEntry
3)调用InputDispatcher::dispatchEventToCurrentInputTargetsLocked
对于InputDispatcher::mCurrentInputTargets中的每一个InputTarget,并获取对应的Connection,调用InputDispatcher::prepareDispatchCycleLocked,
InputDispatcher::dispatchEventToCurrentInputTargetsLocked
for (size_t i = 0; i< mCurrentInputTargets.size(); i++) {
const InputTarget& inputTarget =mCurrentInputTargets.itemAt(i);
ssize_t connectionIndex =getConnectionIndexLocked(inputTarget.inputChannel);
if (connectionIndex >= 0) {
sp<Connection> connection =mConnectionsByReceiveFd.valueAt(connectionIndex);
prepareDispatchCycleLocked(currentTime, connection, eventEntry, &inputTarget,
resumeWithAppendedMotionSample);
} else {
#if DEBUG_FOCUS
LOGD("Dropping event deliveryto target with channel '%s' because it "
"is no longerregistered with the input dispatcher.",
inputTarget.inputChannel->getName().string());
#endif
}
}
InputDispatcher::prepareDispatchCycleLocked
1)调用enqueueDispatchEntryLocked创建DispatchEntry对象,并把它增加到Connection::outboundQueue队列中。
2)调用activateConnectionLocked把当前Connection增加到InputDispatcher::mActiveConnections链表中
3)调用InputDispatcher::startDispatchCycleLocked,接着它调用Connection::inputPublisher.publishMotionEvent来发布事件到ashmem buffer中,调用Connection::inputPublisher.sendDispatchSignal发送一个dispatch信号到InputConsumer通知它有一个新的消息到了,快来消费吧!
3 内核层驱动
请参考网上的linux内核input子系统解析看下面的图:
这里只简单说一下驱动里面触摸屏事件注册
input_dev->evbit[0]= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
input_dev->keybit[BIT_WORD(BTN_TOUCH)]= BIT_MASK(BTN_TOUCH);
input_set_abs_params(input_dev,ABS_X, 0, 32767, 0, 0);
input_set_abs_params(input_dev,ABS_Y, 0, 32767, 0, 0);
input_register_device(input_dev);
事件发送
input_report_key(usbtouch->dev,BTN_TOUCH, touch);
input_report_abs(usbtouch->dev,ABS_X, x);
input_report_abs(usbtouch->dev,ABS_Y, y);
input_sync(usbtouch->dev);