android input system(frameworks) analysis -- InputManager

最新推荐文章于 2022-10-24 19:30:01 发布
最新推荐文章于 2022-10-24 19:30:01 发布
阅读量508 收藏 1
点赞数
分类专栏： android-framework/hal 文章标签： InputManager framework InputManager

对input系统在framework层的分析从一次触摸屏丢失上报事件开始：由于设备节点/dev/input/input0存在，而且getevent能响应点触摸屏的动作，所以把问题定位到了EventHub和InputManager这一层。


InputManager的结构很简单，对外开放

[plain]  view plain copy
  1. virtual status_t start();  
  2. virtual status_t stop();  
  3. virtual sp<InputReaderInterface> getReader();  
  4. virtual sp<InputDispatcherInterface> getDispatcher();  

四个成员函数，内部带有私有成员

[plain]  view plain copy
  1. sp<InputReaderInterface> mReader;  
  2. sp<InputReaderThread> mReaderThread;  
  3. sp<InputDispatcherInterface> mDispatcher;  
  4. sp<InputDispatcherThread> mDispatcherThread;  
其构造过程也很简单：

[plain]  view plain copy
  1. mDispatcher = new InputDispatcher(dispatcherPolicy);  -- 根据输入的参数构造一个dispatcher  
  2. mReader = new InputReader(eventHub, readerPolicy, mDispatcher); -- 根据参数构造一个inputreader  
  3. initialize();  

[plain]  view plain copy
  1. void InputManager::initialize() {  
  2.     mReaderThread = new InputReaderThread(mReader); -- 产生reader线程用于从设备节点读取input event  
  3.     mDispatcherThread = new InputDispatcherThread(mDispatcher); -- 产生dispachter线程分发event  
  4. }  
InputManager的start主要就是让这两个线程跑起来：

[plain]  view plain copy
  1. status_t InputManager::start() {  
  2.     status_t result = mDispatcherThread->run("InputDispatcher", PRIORITY_URGENT_DISPLAY);  
  3.                ...  
  4.     result = mReaderThread->run("InputReader", PRIORITY_URGENT_DISPLAY);  
  5.                ...  
  6.     return OK;  
  7. }  

====================================================================================================================

接着先来分析InputReader：

InputReaderThread run之后会重复的调用

[plain]  view plain copy
  1. bool InputReaderThread::threadLoop() {  
  2.     mReader->loopOnce();  
  3.     return true;  
  4. }  

亦即mReader->loopOnce();

[plain]  view plain copy
  1. void InputReader::loopOnce() {  
  2.     RawEvent rawEvent;  
  3.     mEventHub->getEvent(& rawEvent);  
  4.     process(& rawEvent);  
  5. }  


InputReader上来就找EventHub要数据(getEvent（）)，所以我们要先看看EventHub的getEvent都做了些什么工作：

[cpp]  view plain copy
  1. bool EventHub::getEvent(RawEvent* outEvent)  
  2. {  
  3.     outEvent->deviceId = 0;  
  4.           ...  
  5.   
  6.     // 第一次调用getEvent的时候，需要调用openPlatformInput来搜索输入系统来查找可用的设备  
  7.     if (!mOpened) {  
  8.         mError = openPlatformInput() ? NO_ERROR : UNKNOWN_ERROR;  
  9.         mOpened = true;  
  10.         mNeedToSendFinishedDeviceScan = true;  
  11.     }  
  12. }  
[cpp]  view plain copy
  1. bool EventHub::openPlatformInput(void)  
  2. {  
  3.     // 为poll()调用作准备  
  4.     mFDCount = 1;  
  5.     mFDs = (pollfd *)calloc(1, sizeof(mFDs[0]));  
  6.     mDevices = (device_t **)calloc(1, sizeof(mDevices[0]));  
  7.     mFDs[0].events = POLLIN;  
  8.     mFDs[0].revents = 0;  
  9.     mDevices[0] = NULL;  
  10.           ...  
  11.     // 上面有赋值device_path = "/dev/input"  
  12.     res = scanDir(device_path);  
  13.           ...  
  14.     return true;  
  15. }  


接着又绕到scanDir()里面，这个函数无非就是对/dev/input这个目录的每个文件执行openDevice()，后者才是真正干活的：

[cpp]  view plain copy
  1. int EventHub::openDevice(const char *deviceName) {  
  2.     int version;  
  3.     int fd;  
  4.     struct pollfd *new_mFDs;  
  5.     device_t **new_devices;  
  6.     char **new_device_names;  
  7.     char name[80];  
  8.     char location[80];  
  9.     char idstr[80];  
  10.     struct input_id id;  
  11.   
  12.     LOGV("Opening device: %s", deviceName);  
  13.   
  14.     AutoMutex _l(mLock);  
  15.     // 根据路径打开文件获取version, id, name等信息  
  16.     fd = open(deviceName, O_RDWR);  
  17.     if(fd < 0) ...  
  18.     if(ioctl(fd, EVIOCGVERSION, &version))   
  19.         ...  
  20.     if(ioctl(fd, EVIOCGID, &id))   
  21.         ...  
  22.     if(ioctl(fd, EVIOCGNAME(sizeof(name) - 1), &name) < 1)   
  23.         ...  
  24.     // check to see if the device is on our excluded list - 如果此设备在排除名单内，忽略它  
  25.     List<String8>::iterator iter = mExcludedDevices.begin();  
  26.     List<String8>::iterator end = mExcludedDevices.end();  
  27.     for ( ; iter != end; iter++) {  
  28.         ...  
  29.     }  
  30.     // 读取location, idstr等信息  
  31.     if(ioctl(fd, EVIOCGPHYS(sizeof(location) - 1), &location) < 1)   
  32.         ...  
  33.     if(ioctl(fd, EVIOCGUNIQ(sizeof(idstr) - 1), &idstr) < 1)   
  34.         ...  
  35.     // 将设备文件设置为非阻塞  
  36.     if (fcntl(fd, F_SETFL, O_NONBLOCK))   
  37.         ...  
  38.     // 在mDeviceById数组中寻找“空位”，扩充mDeviceById的空间并把新device加到尾部  
  39.     int devid = 0;  
  40.     while (devid < mNumDevicesById) {  
  41.         if (mDevicesById[devid].device == NULL) {  
  42.             break;  
  43.         }  
  44.         devid++;  
  45.     }  
  46.     if (devid >= mNumDevicesById) {  
  47.         device_ent* new_devids = (device_ent*)realloc(mDevicesById,  
  48.                 sizeof(mDevicesById[0]) * (devid + 1));  
  49.         if (new_devids == NULL) {  
  50.             LOGE("out of memory");  
  51.             return -1;  
  52.         }  
  53.         mDevicesById = new_devids;  
  54.         mNumDevicesById = devid+1;  
  55.         mDevicesById[devid].device = NULL;  
  56.         mDevicesById[devid].seq = 0;  
  57.     }  
  58.   
  59.     mDevicesById[devid].seq = (mDevicesById[devid].seq+(1<<SEQ_SHIFT))&SEQ_MASK;  
  60.     if (mDevicesById[devid].seq == 0) {  
  61.         mDevicesById[devid].seq = 1<<SEQ_SHIFT;  
  62.     }  
  63.     // 为后面用poll()来获取kernel层上报的input event作准备  
  64.     new_mFDs = (pollfd*)realloc(mFDs, sizeof(mFDs[0]) * (mFDCount + 1));  
  65.     new_devices = (device_t**)realloc(mDevices, sizeof(mDevices[0]) * (mFDCount + 1));  
  66.     if (new_mFDs == NULL || new_devices == NULL) {  
  67.         LOGE("out of memory");  
  68.         return -1;  
  69.     }  
  70.     mFDs = new_mFDs;  
  71.     mDevices = new_devices;  
  72.   
  73.     device_t* device = new device_t(devid|mDevicesById[devid].seq, deviceName, name);  
  74.     if (device == NULL) {  
  75.         LOGE("out of memory");  
  76.         return -1;  
  77.     }  
  78.   
  79.     device->fd = fd;  
  80.     mFDs[mFDCount].fd = fd;  
  81.     mFDs[mFDCount].events = POLLIN;  
  82.     mFDs[mFDCount].revents = 0;  
  83.   
  84.     // Figure out the kinds of events the device reports.  
  85.     // 分辨本device的输入类型： keypad? touchscreen? gamepad?  
  86.     uint8_t key_bitmask[sizeof_bit_array(KEY_MAX + 1)];  
  87.     memset(key_bitmask, 0, sizeof(key_bitmask));  
  88.     // 测试本device是否为键盘，是的话把key_bitmask保存下来  
  89.     LOGV("Getting keys...");  
  90.     if (ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(key_bitmask)), key_bitmask) >= 0) {  
  91.        ...  
  92.     }  
  93.     // 是否为轨迹球或鼠标  
  94.     // See if this is a trackball (or mouse).  
  95.     if (test_bit(BTN_MOUSE, key_bitmask)) {  
  96.         ...  
  97.     }  
  98.     // 是否为touchscreen，是否支持多点触摸  
  99.     // See if this is a touch pad.  
  100.     uint8_t abs_bitmask[sizeof_bit_array(ABS_MAX + 1)];  
  101.     memset(abs_bitmask, 0, sizeof(abs_bitmask));  
  102.     LOGV("Getting absolute controllers...");  
  103.     if (ioctl(fd, EVIOCGBIT(EV_ABS, sizeof(abs_bitmask)), abs_bitmask) >= 0) {  
  104.         ...  
  105.     }  
  106.   
  107. #ifdef EV_SW  
  108.     // 是否为switch设备，这个宏没有打开  
  109. #endif  
  110.     // 如果是键盘的话，加载keypad-layout，即/usr/keylayout/中的xxx.kl文件  
  111.     if ((device->classes & INPUT_DEVICE_CLASS_KEYBOARD) != 0) {  
  112.            ...  
  113.         status_t status = device->layoutMap->load(keylayoutFilename);  
  114.         if (status) {  
  115.             LOGE("Error %d loading key layout.", status);  
  116.         }  
  117.            ...  
  118.         // tell the world about the devname (the descriptive name) - 找一个首选keyboard出来  
  119.         if (!mHaveFirstKeyboard && !defaultKeymap && strstr(name, "-keypad")) {  
  120.             // the built-in keyboard has a well-known device ID of 0,  
  121.             // this device better not go away.  
  122.             mHaveFirstKeyboard = true;  
  123.             mFirstKeyboardId = device->id;  
  124.             property_set("hw.keyboards.0.devname", name);  
  125.         } else {  
  126.             // ensure mFirstKeyboardId is set to -something-.  
  127.             if (mFirstKeyboardId == 0) {  
  128.                 mFirstKeyboardId = device->id;  
  129.             }  
  130.         }  
  131.         // 如果键盘有数字键，方向键，游戏控制键等特殊按钮，都一一标记到classes中  
  132.         if (hasKeycodeLocked(device, AKEYCODE_Q))   
  133.             ...  
  134.         if (hasKeycodeLocked(device, AKEYCODE_DPAD_UP) &&  
  135.                 hasKeycodeLocked(device, AKEYCODE_DPAD_DOWN) &&  
  136.                 hasKeycodeLocked(device, AKEYCODE_DPAD_LEFT) &&  
  137.                 hasKeycodeLocked(device, AKEYCODE_DPAD_RIGHT) &&  
  138.                 hasKeycodeLocked(device, AKEYCODE_DPAD_CENTER)) {  
  139.             device->classes |= INPUT_DEVICE_CLASS_DPAD;  
  140.         }  
  141.           
  142.         // See if this device has a gamepad.  
  143.         for (size_t i = 0; i < sizeof(GAMEPAD_KEYCODES)/sizeof(GAMEPAD_KEYCODES[0]); i++) {  
  144.             if (hasKeycodeLocked(device, GAMEPAD_KEYCODES[i])) {  
  145.                 device->classes |= INPUT_DEVICE_CLASS_GAMEPAD;  
  146.                 break;  
  147.             }  
  148.         }  
  149.   
  150.         LOGI("New keyboard: device->id=0x%x devname='%s' propName='%s' keylayout='%s'\n",  
  151.                 device->id, name, propName, keylayoutFilename);  
  152.     }  
  153.   
  154.     // 如果不知道这个device是啥类型，忽略之  
  155.     if (device->classes == 0) {  
  156.        ...  
  157.     }  
  158.   
  159.     // 加到mDevicesById和mOpeningDevices中，回头getEvent()会处理mOpenningDevices链表中的新增device  
  160.   
  161.     mDevicesById[devid].device = device;  
  162.     device->next = mOpeningDevices;  
  163.     mOpeningDevices = device;  
  164.     mDevices[mFDCount] = device;  
  165.   
  166.     mFDCount++;  
  167.     return 0;  
  168. }  



初始化折腾一番后，又回到了getEvent中来，getEvent除了在第一此进入需要加设备外，其主体就是一个大循环：

[cpp]  view plain copy
  1. bool EventHub::getEvent(RawEvent* outEvent)  
  2. {  
  3.       ....  
  4.   
  5.     // main loop here - 主循环体  
  6.     for (;;) {  
  7.         // Report any devices that had last been removed. - 当有设备从系统中移除时  
  8.         if (mClosingDevices != NULL) {  
  9.              ...  
  10.         }  
  11.   
  12.     // Report any devices that had last been added - 当有设备加入到系统中时  
  13.         if (mOpeningDevices != NULL) {  
  14.             device_t* device = mOpeningDevices;  
  15.             LOGV("Reporting device opened: id=0x%x, name=%s\n",  
  16.                  device->id, device->path.string());  
  17.             mOpeningDevices = device->next;  
  18.             if (device->id == mFirstKeyboardId) {  
  19.                 outEvent->deviceId = 0;  
  20.             } else {  
  21.                 outEvent->deviceId = device->id;  
  22.             }  
  23.             outEvent->type = DEVICE_ADDED;  
  24.             outEvent->when = systemTime(SYSTEM_TIME_MONOTONIC);  
  25.             mNeedToSendFinishedDeviceScan = true;  
  26.             return true; // 一个设备上报一个DEVICE_ADDED事件  
  27.         }  
  28.   
  29.     // After finish scanning all input devices in system, send finished siganal at boot time   
  30.         if (mNeedToSendFinishedDeviceScan) {  
  31.             mNeedToSendFinishedDeviceScan = false;  
  32.             outEvent->type = FINISHED_DEVICE_SCAN;  
  33.             outEvent->when = systemTime(SYSTEM_TIME_MONOTONIC);  
  34.             return true;  
  35.         }  
  36.   
  37.         // 下面为普通event获取和上报过程  
  38.              ... ...  
  39.     }  
  40. }  

从上面的代码段可知，对于mOpeningDevices中的device，getEvent()调用都是每读取一个马上上报DEVICE_ADDED事件并返回。所以如果我们的系统中有一个keypad和一个touchscreen，则在扫描阶段就会有3次getEvent()返回：键盘的DEVICE_ADDED，触摸屏的DEVICE_ADDED和表示扫描完成的FINISHED_DEVICE_SCAN。


++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


接上文对EventHub getEvent()的分析，InputReader::loopOnce()在getEvent()成功返回直接，就调用process(& rawEvent);开始分析报上来的rawEvent：

[cpp]  view plain copy
  1. void InputReader::process(const RawEvent* rawEvent) {  
  2.     switch (rawEvent->type) {  
  3.     case EventHubInterface::DEVICE_ADDED:  // 加入新设备  
  4.         addDevice(rawEvent->deviceId);  
  5.         break;  
  6.   
  7.     case EventHubInterface::DEVICE_REMOVED:  // 移除完成  
  8.         removeDevice(rawEvent->deviceId);  
  9.         break;  
  10.   
  11.     case EventHubInterface::FINISHED_DEVICE_SCAN: // 扫描完成，每次增加或移除设备后都会引发此事件  
  12.         handleConfigurationChanged(rawEvent->when);  
  13.         break;  
  14.   
  15.     default:  
  16.         consumeEvent(rawEvent); // 普通event，按键触摸屏事件就在这个分支上处理  
  17.         break;  
  18.     }  
  19. }  

rawEvent的type对应着getEvent里面上报的几种类型，下面根据不同的分支看看inputReader如何处理这样事件。先看看一些关键数据结构：

[cpp]  view plain copy
  1. struct RawEvent {  
  2.     nsecs_t when; // when this happened  
  3.     int32_t deviceId; // from which device  
  4.     int32_t type; // DEVICE_REMOVED, DEVICE_ADDED, FINISHED_DEVICE_SCAN or others  
  5.     int32_t scanCode; // original event code from kernel driver  
  6.     int32_t keyCode; // code after keycode-mapping while this is a EV_KEY event  
  7.     int32_t value; // event value  
  8.     uint32_t flags; // additional info  
  9. };  

DEVICE_ADD事件的处理：

[cpp]  view plain copy
  1. void InputReader::addDevice(int32_t deviceId) {  
  2.     String8 name = mEventHub->getDeviceName(deviceId); // eventHub根据自己的mDevicesById返回device的name和classes  
  3.     uint32_t classes = mEventHub->getDeviceClasses(deviceId);  
  4.     // 调用createDevice建立一个与底层input device一一对应的device  
  5.     InputDevice* device = createDevice(deviceId, name, classes);  
  6.     device->configure();  
  7.        ...  
  8.     bool added = false; // 如果此device之前不存在，则加到名为mDevices的KeyedVector中  
  9.     { // acquire device registry writer lock  
  10.         RWLock::AutoWLock _wl(mDeviceRegistryLock);  
  11.   
  12.         ssize_t deviceIndex = mDevices.indexOfKey(deviceId);  
  13.         if (deviceIndex < 0) {  
  14.             mDevices.add(deviceId, device);  
  15.             added = true;  
  16.         }  
  17.     } // release device registry writer lock  
  18.         ....  
  19. }  
createDevice()函数中先new InputDevice创建对象，然后根据device的classes调用device->addMapper加入mapper，这些mapper对后面分析的普通event的处理有重要的作用。device->configure()函数做一些配置工作，如果device有校准数据的话会调用getInputDeviceCalibration进行校准，还会调用上述mapper的configure函数配置mapper，不过mapper的这个函数一般直接置空，只有TouchInputMapper::configure()会针对触摸屏校准做些工作：

[cpp]  view plain copy
  1. void InputDevice::configure() {  
  2.     if (! isIgnored()) {  
  3.         mContext->getPolicy()->getInputDeviceCalibration(mName, mCalibration);  
  4.     }  
  5.   
  6.     mSources = 0;  
  7.     // 调用mapper的configure和getSources来设置device的mSource来标示种类，但是mapper本身又是根据devices的classes来选的，很绕……  
  8.     size_t numMappers = mMappers.size();  
  9.     for (size_t i = 0; i < numMappers; i++) {  
  10.         InputMapper* mapper = mMappers[i];  
  11.         mapper->configure();  
  12.         mSources |= mapper->getSources();  
  13.     }  
  14. }  


DEVICE_REMOVED事件的处理：

[cpp]  view plain copy
  1. void InputReader::removeDevice(int32_t deviceId) {  
  2.     bool removed = false;  
  3.     InputDevice* device = NULL;  
  4.     { // acquire device registry writer lock  
  5.         RWLock::AutoWLock _wl(mDeviceRegistryLock);  
  6.         // 最主要的是从mDevices中将其移除  
  7.         ssize_t deviceIndex = mDevices.indexOfKey(deviceId);  
  8.         if (deviceIndex >= 0) {  
  9.             device = mDevices.valueAt(deviceIndex);  
  10.             mDevices.removeItemsAt(deviceIndex, 1);  
  11.             removed = true;  
  12.         }  
  13.     } // release device registry writer lock  
  14.         ...  
  15.     device->reset(); // reset会引发devices的mapper的reset()  
  16.       
  17.     delete device;  
  18. }  

FINISHED_DEVICE_SCAN事件的处理：

[cpp]  view plain copy
  1. void InputReader::handleConfigurationChanged(nsecs_t when) {  
  2.     // Reset global meta state because it depends on the list of all configured devices.  
  3.     updateGlobalMetaState();  
  4.   
  5.     // Update input configuration.更新inputReader当前的设置  
  6.     updateInputConfiguration();  
  7.   
  8.     // Enqueue configuration changed.通知dispatcher了  
  9.     mDispatcher->notifyConfigurationChanged(when);  
  10. }  


普通输入事件的处理：

在函数consumeEvent中会根据rawEvent的deviceId从mDevices中选择上报事件的device然后调用device->process(rawEvent)来处理，device再调用自己mapper的process来处理，因此对于不同的mapper就有了不同的process具体实现。下面选择MultiTouchInputMapper的process函数分析：

[cpp]  view plain copy
  1. void MultiTouchInputMapper::process(const RawEvent* rawEvent) {  
  2.     switch (rawEvent->type) {  
  3.     case EV_ABS: {  
  4.         uint32_t pointerIndex = mAccumulator.pointerCount;  
  5.         Accumulator::Pointer* pointer = & mAccumulator.pointers[pointerIndex];  
  6.   
  7.         switch (rawEvent->scanCode) {  
  8.         case ABS_MT_POSITION_X:  
  9.             LOGE("-MT X-");           
  10.             pointer->fields |= Accumulator::FIELD_ABS_MT_POSITION_X;  
  11.             pointer->absMTPositionX = rawEvent->value;  
  12.             break;  
  13.         case ABS_MT_POSITION_Y:  
  14.              LOGE("-MT Y-");              
  15.             pointer->fields |= Accumulator::FIELD_ABS_MT_POSITION_Y;  
  16.             pointer->absMTPositionY = rawEvent->value;  
  17.             break;  
  18.         case ABS_MT_TOUCH_MAJOR:  
  19.             pointer->fields |= Accumulator::FIELD_ABS_MT_TOUCH_MAJOR;  
  20.             pointer->absMTTouchMajor = rawEvent->value;  
  21.             break;  
  22.         case ABS_MT_TOUCH_MINOR:  
  23.             pointer->fields |= Accumulator::FIELD_ABS_MT_TOUCH_MINOR;  
  24.             pointer->absMTTouchMinor = rawEvent->value;  
  25.             break;  
  26.         case ABS_MT_WIDTH_MAJOR:  
  27.             pointer->fields |= Accumulator::FIELD_ABS_MT_WIDTH_MAJOR;  
  28.             pointer->absMTWidthMajor = rawEvent->value;  
  29.             break;  
  30.         case ABS_MT_WIDTH_MINOR:  
  31.             pointer->fields |= Accumulator::FIELD_ABS_MT_WIDTH_MINOR;  
  32.             pointer->absMTWidthMinor = rawEvent->value;  
  33.             break;  
  34.         case ABS_MT_ORIENTATION:  
  35.             pointer->fields |= Accumulator::FIELD_ABS_MT_ORIENTATION;  
  36.             pointer->absMTOrientation = rawEvent->value;  
  37.             break;  
  38.         case ABS_MT_TRACKING_ID:  
  39.             pointer->fields |= Accumulator::FIELD_ABS_MT_TRACKING_ID;  
  40.             pointer->absMTTrackingId = rawEvent->value;  
  41.             break;  
  42.         case ABS_MT_PRESSURE:  
  43.             pointer->fields |= Accumulator::FIELD_ABS_MT_PRESSURE;  
  44.             pointer->absMTPressure = rawEvent->value;  
  45.             break;  
  46.         }  
  47.         break;  
  48.     }  
  49.   
  50.     case EV_SYN:  
  51.         switch (rawEvent->scanCode) { // 对于多点触摸来说，一次可以向dispatcher报1~10个pointer的数据（10点是android2.3的上限）  
  52.         case SYN_MT_REPORT: {  // 一次SYN_MT_REPORT表示一个手指的触摸数据已经接收完毕，包括X,Y,PRESSURE等  
  53.             // MultiTouch Sync: The driver has returned all data for *one* of the pointers.  
  54.             uint32_t pointerIndex = mAccumulator.pointerCount;  
  55.             LOGE("-ONE-");  
  56.             if (mAccumulator.pointers[pointerIndex].fields) {  
  57.                 if (pointerIndex == MAX_POINTERS) {  
  58.                     LOGW("MultiTouch device driver returned more than maximum of %d pointers.",  
  59.                             MAX_POINTERS);  
  60.                 } else {  
  61.                     pointerIndex += 1;  
  62.                     mAccumulator.pointerCount = pointerIndex;  
  63.                 }  
  64.             }  
  65.   
  66.             mAccumulator.pointers[pointerIndex].clear();  
  67.             break;  
  68.         }  
  69.         // 当多点的数据都齐全之后会收到SYN_REPORT事件，这时可以向dispatcher发送了  
  70.         case SYN_REPORT:  
  71.             LOGE("-SYN MT-");              
  72.             sync(rawEvent->when);  
  73.             break;  
  74.         }  
  75.         break;  
  76.     }  
  77. }  


MultiTouchInputMapper::sync的主要作用是，把process中接收到的多个pointer数据做审核，例如屏蔽掉不合要求的点，对缺失的参数设置成默认等。

[cpp]  view plain copy
  1. void MultiTouchInputMapper::sync(nsecs_t when) {  
  2.     static const uint32_t REQUIRED_FIELDS =  
  3.             Accumulator::FIELD_ABS_MT_POSITION_X | Accumulator::FIELD_ABS_MT_POSITION_Y;  
  4.   
  5.     uint32_t inCount = mAccumulator.pointerCount;  
  6.     uint32_t outCount = 0;  
  7.     bool havePointerIds = true;  
  8.   
  9.     mCurrentTouch.clear();  
  10.   
  11.     for (uint32_t inIndex = 0; inIndex < inCount; inIndex++) {  
  12.         const Accumulator::Pointer& inPointer = mAccumulator.pointers[inIndex];  
  13.         uint32_t fields = inPointer.fields;  
  14.   
  15.         if ((fields & REQUIRED_FIELDS) != REQUIRED_FIELDS) {  
  16.             // Some drivers send empty MT sync packets without X / Y to indicate a pointer up.  
  17.             // Drop this finger.  
  18.             continue;  
  19.         }  
  20.   
  21.         PointerData& outPointer = mCurrentTouch.pointers[outCount];  
  22.         outPointer.x = inPointer.absMTPositionX;  
  23.         outPointer.y = inPointer.absMTPositionY;  
  24.   
  25.         if (fields & Accumulator::FIELD_ABS_MT_PRESSURE) {  
  26.             if (inPointer.absMTPressure <= 0) {  
  27.                 // Some devices send sync packets with X / Y but with a 0 pressure to indicate  
  28.                 // a pointer going up.  Drop this finger.  
  29.                 continue;  
  30.             }  
  31.             outPointer.pressure = inPointer.absMTPressure;  
  32.         } else {  
  33.             // Default pressure to 0 if absent.  
  34.             outPointer.pressure = 0;  
  35.         }  
  36.              .... // 设置FIELD_ABS_MT_WIDTH_MAJOR等等field  
  37.   
  38.         // Assign pointer id using tracking id if available.  
  39.         if (havePointerIds) {  
  40.             if (fields & Accumulator::FIELD_ABS_MT_TRACKING_ID) {  
  41.                 uint32_t id = uint32_t(inPointer.absMTTrackingId);  
  42.   
  43.                 if (id > MAX_POINTER_ID) {  
  44.                     // 利用id来跟踪多个手指的触摸事件  
  45.                     havePointerIds = false;  
  46.                 }  
  47.                 else {  
  48.                     outPointer.id = id;  
  49.                     mCurrentTouch.idToIndex[id] = outCount;  
  50.                     mCurrentTouch.idBits.markBit(id);  
  51.                 }  
  52.             } else {  
  53.                 havePointerIds = false;  
  54.             }  
  55.         }  
  56.   
  57.         outCount += 1;  
  58.     }  
  59.   
  60.     mCurrentTouch.pointerCount = outCount;  
  61.   
  62.     syncTouch(when, havePointerIds);  
  63.   
  64.     mAccumulator.clear();  
  65. }  
贴一段kernel的触摸屏driver上报事件的代码：

[cpp]  view plain copy
  1.              for (i = 0; i < 10; i++){  
  2.     if (stored_size[i]){  
  3.         active_touches++;  
  4.         input_report_abs(mxt->input,   
  5.                 ABS_MT_TRACKING_ID,  
  6.                 i);  
  7.         input_report_abs(mxt->input,  
  8.                 ABS_MT_TOUCH_MAJOR,  
  9.                 stored_size[i]);  
  10.         input_report_abs(mxt->input,  
  11.                 ABS_MT_POSITION_X,  
  12.                 stored_x[i]);  
  13.         input_report_abs(mxt->input,  
  14.                 ABS_MT_POSITION_Y,  
  15.                 stored_y[i]);  
  16.         input_mt_sync(mxt->input);  
  17.     }  
  18. }  
  19. if (active_touches == 0)  
  20.     input_mt_sync(mxt->input);  
  21. input_sync(mxt->input);  
可以看到，这个触摸屏也是最多支持10点触摸的，其中的ABS_MT_TRACKING_ID就是追踪每个手指的移动轨迹标示，具体哪个点属于哪个手指的轨迹则是由电容屏的IC确定的，怪不得电容屏成本比较高。经过sync函数的处理后，mCurrentTouch里面就带有整个多点触摸事件的所有数据，可以调用基类TouchInputMapper的syncTouch了：

[cpp]  view plain copy
  1. void TouchInputMapper::syncTouch(nsecs_t when, bool havePointerIds) {  
  2.     uint32_t policyFlags = 0;  
  3.   
  4.     // Preprocess pointer data.  
  5.   
  6.     if (mParameters.useBadTouchFilter) {  
  7.         if (applyBadTouchFilter()) {  
  8.             havePointerIds = false;  
  9.         }  
  10.     }  
  11.   
  12.     if (mParameters.useJumpyTouchFilter) {  
  13.         if (applyJumpyTouchFilter()) {  
  14.             havePointerIds = false;  
  15.         }  
  16.     }  
  17.   
  18.     if (! havePointerIds) {  
  19.         calculatePointerIds();  
  20.     }  
  21.   
  22.     TouchData temp;  
  23.     TouchData* savedTouch;  
  24.     if (mParameters.useAveragingTouchFilter) {  
  25.         temp.copyFrom(mCurrentTouch);  
  26.         savedTouch = & temp;  
  27.   
  28.         applyAveragingTouchFilter();  
  29.     } else {  
  30.         savedTouch = & mCurrentTouch;  
  31.     }  
  32.   
  33.     // Process touches and virtual keys.  
  34.   
  35.     TouchResult touchResult = consumeOffScreenTouches(when, policyFlags);  
  36.     if (touchResult == DISPATCH_TOUCH) {  
  37.         detectGestures(when);  
  38.         dispatchTouches(when, policyFlags);  
  39.     }  
  40.   
  41.     // Copy current touch to last touch in preparation for the next cycle.  
  42.   
  43.     if (touchResult == DROP_STROKE) {  
  44.         mLastTouch.clear();  
  45.     } else {  
  46.         mLastTouch.copyFrom(*savedTouch);  
  47.     }  
  48. }  
在syncTouch里，多点触摸的数据（单点触摸事件也会经过这里）还得通过applyBadTouchFilter，applyJumpyTouchFilter，applyAveragingTouchFilter（视情况）的处理才能到consumeOffScreenTouches这步，这个函数中在处理完一些policy的东西之后就会调

 getDispatcher()->notifyKey(when, getDeviceId(), AINPUT_SOURCE_KEYBOARD, policyFlags,
            keyEventAction, keyEventFlags, keyCode, scanCode, metaState, downTime);

通知dispatcher有事件来了，dispatcher的分析在下篇开始。


++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++



jiangshitian
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
android input system(frameworks) analysis -- InputManager (1)
开发就是不断的发现不足与学习
11-15 3964
对input系统在framework层的分析从一次触摸屏丢失上报事件开始：由于设备节点/dev/input/input0存在，而且getevent能响应点触摸屏的动作，所以把问题定位到了EventHub和InputManager这一层。 InputManager的结构很简单，对外开放 virtual status_t start(); virtual status_
Android底层开发入门(8)－InputSystem
The CnSkyline Blog
10-15 1461
硬件分析在一个屏幕中ic一般打在软体线上，通过TX与RX进行实时通信，IC(ft5x46)会对屏幕触点进行降噪和相应的算法等等，然后ic通过iic接口（有应答）与soc进行通讯，在ft5x46的datasheet里面有相应的框架图，如下图当然这个并不是我们关注的点·软件分析要对触屏进行了解，那么必须对input system进行了解,首先可以对整个的系统进行一个比较大致的了解,那么可以看到input
AndroidR Input子系统（4）扫描/dev/input目录
qq_34211365的博客
11-08 2533
上一篇文章分析了InputReader线程对Input事件的处理流程，主要分为了三大步骤： EventHub通过INotify与Epoll监听/dev/input下的事件，在读取到事件之后放入mEventBuffer，此步骤将input_event转换为了RawEvent。 拿到原始事件RawEvent之后调用processEventsLocked对事件进行加工，不同事件类型有不同的加工厂（InputMapper），此步骤将RawEvent转换为了NotifyKeyArgs。 通过QueuedListen
android raw event,Android Eventhub处理流程
weixin_42520277的博客
05-27 426
Eventhub是在Native 的inputmanager创建的时候被创建的，inputreadthread就通过eventhub的getevent方法来源源不断的获取driver上报的input事件。bool EventHub::getEvent(RawEvent* outEvent){if (!mOpened) {mError =openPlatformInput() ? NO_ERROR...
*EventHub.cpp部分解析
weixin_61810331的博客
10-24 440
EventHub.cpp解析
Android/SDK/Platforms/android-33
最新发布
10-29
2. `frameworks/base/core.jar`：包含了核心Android系统的类库，提供了系统服务、组件模型等关键功能。 3. `system-images/`：存放了模拟器或设备所需的系统映像，用于在开发环境中运行和测试应用程序。 4. `docs/`...
android-sdk-sources-android-21.rar
04-17
- `frameworks/base` 包含了 Android 系统的主要 API 和服务，如 ActivityManager、ContentProvider 等。 - `system/core` 存放了 Android 系统的核心组件，如 init 进程、内核接口、JNI 头文件等。 3. **Android...
android-sdk-sources-android-14.rar
04-17
1. Frameworks 基础框架：包括 ActivityManagerService、WindowManagerService 等核心服务，负责应用程序的生命周期管理和窗口管理。 2. Libraries 库：包含各种系统库，如 dalvikvm（Dalvik 虚拟机）、libcore...
Android-2.3.7-frameworks-src
09-01
Android-2.3.7-frameworks-src，Android源代码，Android_Frameworks层源代码，下载后用eclpse关联源代码文件夹，然后就可以利用eclpse翻看Android Frameworks层的源代码
android13 WindowManager-Shell.jar
03-10
android13 WindowManager-Shell.jar
linux的Input子系统获取Device Name
weixin_30527323的博客
08-14 397
linux内核提供了一个Input子系统来实现的，Input子系统会在/dev/input/路径下创建我们硬件输入设备的节点，一般情况下在我们的 手机中这些节点是以eventXX来命名的，如event0，event1等等，可以利用EVIOCGNAME获取此事件结点名称。这就是android 中对于input事件处理数据的来源点。 --------------- 通过ioctl...
tslib机制分析 2009-12-25 17:17:39
deng10355148的专栏
07-18 716
tslib 很早以前用了，深入了解了它的原理，但是当时忙，就没写成文档了，今天发现对它有点陌生了，觉得如果再不记录下来的话，估计以后就忘了。    估计大家都听说过tslib，其实从他的名字就可以看出它的，它是touchscreen的lib,其实这样还不够具体，其实它开始确实是为了touchscreen的鼠标驱动而发展起来的，且只是一个中间处理库，即将原始数据进行调整，比如触摸屏定位。只不过后来
Android 4.0 事件输入(Event Input)系统
热门推荐
MyArrow的专栏
12-21 4万+
1. TouchScreen功能在Android4.0下不工作        原来在Android2.3.5下能正常工作的TouchScreen功能，移植到Android 4.0就不能正常工作了。凭直觉，Android4.0肯定有鬼。真是不看不知道，一看吓一跳。在Android 4.0中，Event Input地位提高了，你看看，在Adroid2.3.5中，它在frameworks/base/l
android系统学习笔记四
weixin_30273763的博客
09-03 108
Android的ＧＵＩ系统 AndroidGUI系统综述 C语言部分包括: pixelFlinger（下层工具库） 头文件/system/core/include/pixelflinger其生成的动态库libpixelflinger.so只连接 　　　　　　　　　　　　　　　　　　　...
Android Framework------之Input子系统
weixin_30507481的博客
09-20 300
下面这是基于Android4.2代码的关于Input子系统的笔记。在这篇笔记中，只涉及Android相关的东西，关于Linux内核中对各种输入设备的统一，在本文中不作说明。此外，由于才疏学浅，文中难免有错误的地方，希望各位路过的大神能够予以指出。闲话少叙，先看一张我自己设计的图，如下： 这幅图是为了便于个人理解画出的，里面的注释也比较明白，就不再说明。本文就是以这幅图为基本的思路，简述在An...
Linux 标准输入struct input_event使用示例
ppslinux的专栏
09-15 5065
Input_event使用示例最近在项目中要使用扫码枪，扫码枪模拟成一个标准的输入输入设备，要读取内容必须将光标指向一个文本里。扫码枪扫描到二维码后以键盘的方式将二维码内容输入到文本里，而在嵌入式开发中只能通过input_event结构来获取文本了。input_eventinput_event结构体是驱动层发往系统层的封包结构，该结构封装了输入的各种情形，可以不管是鼠标还是键盘，都是通过input_
源码角度分析Android的事件输入系统（input system）及ANR原理分析
hx_401的专栏
01-26 880
此篇我们从android5.0（lolipop）源码角度分析Android的事件输入系统（input system）： 先引用一张图来说明下，Android输入系统的整个流程： 1、Linux内核，接受输入设备的中断，并将原始事件的数据写入到设备节点中。 2、设备节点，作为内核与IMS的桥梁，它将原始事件的数据暴露给用户
2.4G无线遥控器鼠标解决办法
zzobin的专栏
05-16 6266
接上次讨论的2.4G input校验有问题， frameworks里没有加入对鼠标事件的支持。            1.在EventHub.h文件里：              enum {     /* The input device is a keyboard. */     INPUT_DEVICE_CLASS_KEYBOARD      = 0x00000001,
android下面通过ndk建立一个虚拟触摸屏设备可以被sendevent调用
little_walt的专栏
11-21 1546
如何创建 如何使用 如何编译1 如何创建#define LOG_TAG "shinevitualdevice" #if 0 #include <utils/Log.h> #endif#include <stdio.h> #include <string.h> #include <fcntl.h> #include <unistd.h> #include <linux/input.h> #includ
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值