Android InputFliger流程分析,从内核 Hid到EventHub,InputRead,InputDispatcher(二)

上篇文章讲的是内核层对HID触控数据的处理,本篇从framework层来看下触控数据的流向.以及我们在哪修改来适应公司的业务.

关于InputFliger网上详细的教程有很多,流程图,代码解析都有,大家可自己查阅下,下面只是从具体的调试和数据流程角度分析.

InputFliger个人理解整体分三大部分.一是EventHub.cpp,主要是从内核建立的节点获取设备描述符以及input数据.二是InputRead.cpp,主要是对EventHub.cpp获取的数据进行分析,整合.三是InputDispatcher.cpp,主要是把InputRead.cpp整合后的数据进行转发.

目录结构:frameworks/native/services/inputfliger

1.EventHub首先会打开/dev/hidraw*节点,来获取描述符,一定要看下路径是否正确,以及描述符是否是对的.

代码如下:1073行的open函数打开节点.然后通过ioctl函数获取描述符信息,很全,想要的数据个格式都在里面.

1068 status_t EventHub::openDeviceLocked(const char *devicePath) {
1069     char buffer[80];
1070 
1071     ALOGV("Opening device: %s", devicePath);
1072 
1073     int fd = open(devicePath, O_RDWR | O_CLOEXEC);
1074     if(fd < 0) {
1075         ALOGE("could not open %s, %s\n", devicePath, strerror(errno));
1076         return -1;
1077     }
1078 
1079     InputDeviceIdentifier identifier;
1080 
1081     // Get device name.
1082     if(ioctl(fd, EVIOCGNAME(sizeof(buffer) - 1), &buffer) < 1) {
1083         //fprintf(stderr, "could not get device name for %s, %s\n", devicePath, strerror(errno));
1084     } else {
1085         buffer[sizeof(buffer) - 1] = '\0';
1086         identifier.name.setTo(buffer);
1087     }
1088 
1089     // Check to see if the device is on our excluded list
1090     for (size_t i = 0; i < mExcludedDevices.size(); i++) {
1091         const String8& item = mExcludedDevices.itemAt(i);
1092         if (identifier.name == item) {
1093             ALOGI("ignoring event id %s driver %s\n", devicePath, item.string());
1094             close(fd);
1095             return -1;
1096         }
1097     }
1098 
1099     // Get device driver version.
1100     int driverVersion;
1101     if(ioctl(fd, EVIOCGVERSION, &driverVersion)) {
1102         ALOGE("could not get driver version for %s, %s\n", devicePath, strerror(errno));
1103         close(fd);
1104         return -1;
1105     }
1106 
1107     // Get device identifier.
1108     struct input_id inputId;
1109     if(ioctl(fd, EVIOCGID, &inputId)) {
1110         ALOGE("could not get device input id for %s, %s\n", devicePath, strerror(errno));
1111         close(fd);
1112         return -1;
1113     }
1114     identifier.bus = inputId.bustype;
1115     identifier.product = inputId.product;
1116     identifier.vendor = inputId.vendor;
1117     identifier.version = inputId.version;
1118 
1145     // Allocate device.  (The device object takes ownership of the fd at this point.)
1146     int32_t deviceId = mNextDeviceId++;
1147     Device* device = new Device(fd, deviceId, String8(devicePath), identifier);
1148 
1149     ALOGV("add device %d: %s\n", deviceId, devicePath);
1150     ALOGV("  bus:        %04x\n"
1151          "  vendor      %04x\n"
1152          "  product     %04x\n"
1153          "  version     %04x\n",
1154         identifier.bus, identifier.vendor, identifier.product, identifier.version);
1155     ALOGV("  name:       \"%s\"\n", identifier.name.string());
1156     ALOGV("  location:   \"%s\"\n", identifier.location.string());
1157     ALOGV("  unique id:  \"%s\"\n", identifier.uniqueId.string());
1158     ALOGV("  descriptor: \"%s\"\n", identifier.descriptor.string());
1159     ALOGV("  driver:     v%d.%d.%d\n",
1160         driverVersion >> 16, (driverVersion >> 8) & 0xff, driverVersion & 0xff);
1161 
1162     // Load the configuration file for the device.
1163     loadConfigurationLocked(device);

log如下:

01-01 08:00:13.852  2825  2992 D EventHub:   ###name:       "MStar Smart TV Keypad"
01-01 08:00:13.900  2825  2992 D EventHub:   ###bus: 24,vendor 13975, product 1,version  1
01-01 08:00:13.900  2825  2992 D EventHub:   ###name:       "MStar Smart TV IR Receiver"
01-01 08:00:13.912  2825  2992 D InputReader: #####swidth -1,sheight -1,nlwidth 1920,nlheight 1080 nwidht 1920 nheight 1080,npw 1920 nph 1080
01-01 08:00:13.912  2825  2992 D InputReader: ######Device reconfigured: id=1, name='Honghe F86H33+023', size 1920x1080, orientation 0, mode 1, display id 0,rawwidth 32768,rawheight 32768,verdor 2757,produce 10a
01-01 08:00:13.912  2825  2992 D InputReader: ##### scale 0.045776
 

然后通过getEvents()函数获取input数据,InputReader里面会拿到该数据,然后进行处理.

代码如下:

721 size_t EventHub::getEvents(int timeoutMillis, RawEvent* buffer, size_t bufferSize) {
 722     ALOG_ASSERT(bufferSize >= 1);
 723 
 724     AutoMutex _l(mLock);
 725 
 726     struct input_event readBuffer[bufferSize];
 727 
 728     RawEvent* event = buffer;
 729     size_t capacity = bufferSize;
 730     bool awoken = false;
 731     for (;;) {
 732         nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
 733 
 734         // Reopen input devices if needed.
 735         if (mNeedToReopenDevices) {
 736             mNeedToReopenDevices = false;
 737 
 738             ALOGI("Reopening all input devices due to a configuration change.");
 739 
 740             closeAllDevicesLocked();
 741             mNeedToScanDevices = true;
 742             break; // return to the caller before we

2.InputReader里面主要是对数据进行处理,大体逻辑如下:a.开启一个线程,通过EventHub->getEvents()获取input数据,然后通过id对应不同的mapper进行数据的处理.

代码如下:

a.loopOnce(),InputReader.cpp首先会跳到这里执行.360行从EventHub里面获取input数据.然后调用processEventsLocked()函数.

338 void InputReader::loopOnce() {
 339     int32_t oldGeneration;
 340     int32_t timeoutMillis;
 341     bool inputDevicesChanged = false;
 342     Vector<InputDeviceInfo> inputDevices;
 343     { // acquire lock
 344         AutoMutex _l(mLock);
 345 
 346         oldGeneration = mGeneration;
 347         timeoutMillis = -1;
 348 
 349         uint32_t changes = mConfigurationChangesToRefresh;
 350         if (changes) {
 351             mConfigurationChangesToRefresh = 0;
 352             timeoutMillis = 0;
 353             refreshConfigurationLocked(changes);
 354         } else if (mNextTimeout != LLONG_MAX) {
 355             nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
 356             timeoutMillis = toMillisecondTimeoutDelay(now, mNextTimeout);
 357         }
 358     } // release lock
 359 
 360     size_t count = mEventHub->getEvents(timeoutMillis, mEventBuffer, EVENT_BUFFER_SIZE);
 361 
 362     { // acquire lock
 363         AutoMutex _l(mLock);
 364         mReaderIsAliveCondition.broadcast();
 365 
 366         if (count) {
 367             processEventsLocked(mEventBuffer, count);
 368         }
 369 

b.processEventsLocked()函数如下:主要是调用processEventsForDeviceLocked()函数.

void InputReader::processEventsLocked(const RawEvent* rawEvents, size_t count) {
 404     for (const RawEvent* rawEvent = rawEvents; count;) {
 405         int32_t type = rawEvent->type;
 406         size_t batchSize = 1;
 407         if (type < EventHubInterface::FIRST_SYNTHETIC_EVENT) {
 408             int32_t deviceId = rawEvent->deviceId;
 409             while (batchSize < count) {
 410                 if (rawEvent[batchSize].type >= EventHubInterface::FIRST_SYNTHETIC_EVENT
 411                         || rawEvent[batchSize].deviceId != deviceId) {
 412                     break;
 413                 }
 414                 batchSize += 1;
 415             }
 416 #if DEBUG_RAW_EVENTS
 417             ALOGD("BatchSize: %d Count: %d", batchSize, count);
 418 #endif
 419             processEventsForDeviceLocked(deviceId, rawEvent, batchSize);

c.processEventsForDeviceLocked()函数如下:最后主要是调用device-process()函数进行处理,其实是调用了InputDevice->process函数,1146行里面会通过for循环对不同的input事件进行处理,对与不同的设备InputReader.cpp有不同的process函数与之对应.

574 void InputReader::processEventsForDeviceLocked(int32_t deviceId,
 575         const RawEvent* rawEvents, size_t count) {
 576     ssize_t deviceIndex = mDevices.indexOfKey(deviceId);
 577     if (deviceIndex < 0) {
 578         ALOGW("Discarding event for unknown deviceId %d.", deviceId);
 579         return;
 580     }
 581 
 582     InputDevice* device = mDevices.valueAt(deviceIndex);
 583     if (device->isIgnored()) {
 584         //ALOGD("Discarding event for ignored deviceId %d.", deviceId);
 585         return;
 586     }
 587 
 588     device->process(rawEvents, count);
 589 }
1116 void InputDevice::process(const RawEvent* rawEvents, size_t count) {
1117     // Process all of the events in order for each mapper.
1118     // We cannot simply ask each mapper to process them in bulk because mappers may
1119     // have side-effects that must be interleaved.  For example, joystick movement events and
1120     // gamepad button presses are handled by different mappers but they should be dispatched
1121     // in the order received.
1122     size_t numMappers = mMappers.size();
1123     for (const RawEvent* rawEvent = rawEvents; count--; rawEvent++) {
1124 #if DEBUG_RAW_EVENTS
1125         ALOGD("Input event: device=%d type=0x%04x code=0x%04x value=0x%08x when=%lld",
1126                 rawEvent->deviceId, rawEvent->type, rawEvent->code, rawEvent->value,
1127                 rawEvent->when);
1128 #endif
1129 
1130         if (mDropUntilNextSync) {
1131             if (rawEvent->type == EV_SYN && rawEvent->code == SYN_REPORT) {
1132                 mDropUntilNextSync = false;
1133 #if DEBUG_RAW_EVENTS
1134                 ALOGD("Recovered from input event buffer overrun.");
1135 #endif
1136             } else {
1137 #if DEBUG_RAW_EVENTS
1138                 ALOGD("Dropped input event while waiting for next input sync.");
1139 #endif
1140             }
1141         } else if (rawEvent->type == EV_SYN && rawEvent->code == SYN_DROPPED) {
1142             ALOGI("Detected input event buffer overrun for device %s.", getName().string());
1143             mDropUntilNextSync = true;
1144             reset(rawEvent->when);
1145         } else {
1146             for (size_t i = 0; i < numMappers; i++) {
1147                 InputMapper* mapper = mMappers[i];
1148                 mapper->process(rawEvent);
1149             }
1150         }
1151     }
1152 }

d.我这处理的主要是多点触控事件,所以要看MultiTouchInputMapper->process对应的处理.函数里面主要是TouchInputMapper->process();然后调用syncTouch()函数.MultiTouchInputMapper->syncTouch()为实际处理数据的地方,也就是我们需要修改的地方.

825 void MultiTouchInputMapper::process(const RawEvent* rawEvent) {
6826     TouchInputMapper::process(rawEvent);
6827 
6828     mMultiTouchMotionAccumulator.process(rawEvent);
6829 }

4193 void TouchInputMapper::sync(nsecs_t when) {
4194     const RawState* last = mRawStatesPending.isEmpty() ?
4195             &mCurrentRawState : &mRawStatesPending.top();
4196 
4197     // Push a new state.
4198     mRawStatesPending.push();
4199     RawState* next = &mRawStatesPending.editTop();
4200     next->clear();
4201     next->when = when;
4202 
4203     // Sync button state.
4204     next->buttonState = mTouchButtonAccumulator.getButtonState()
4205             | mCursorButtonAccumulator.getButtonState();
4206 
4207     // Sync scroll
4208     next->rawVScroll = mCursorScrollAccumulator.getRelativeVWheel();
4209     next->rawHScroll = mCursorScrollAccumulator.getRelativeHWheel();
4210     mCursorScrollAccumulator.finishSync();
4211 
4212     // Sync touch
4213     syncTouch(when, next);
...
831 void MultiTouchInputMapper::syncTouch(nsecs_t when, RawState* outState) {
6832     size_t inCount = mMultiTouchMotionAccumulator.getSlotCount();
6833     size_t outCount = 0;
6834     BitSet32 newPointerIdBits;
6835     mHavePointerIds = true;
6836 
6837     for (size_t inIndex = 0; inIndex < inCount; inIndex++) {
6838         const MultiTouchMotionAccumulator::Slot* inSlot =
6839                 mMultiTouchMotionAccumulator.getSlot(inIndex);
6840         if (!inSlot->isInUse()) {
6841             continue;
6842         }
6843 
6844         if (outCount >= MAX_POINTERS) {
6845 #if DEBUG_POINTERS
6846             ALOGD("MultiTouch device %s emitted more than maximum of %d pointers; "
6847                     "ignoring the rest.",
6848                     getDeviceName().string(), MAX_POINTERS);
6849 #endif
6850             break; // too many fingers!
6851         }
6852 
6853         RawPointerData::Pointer& outPointer = outState->rawPointerData.pointers[outCount];
6854         outPointer.x = inSlot->getX();
6855         outPointer.y = inSlot->getY();
6856         outPointer.pressure = inSlot->getPressure();
6857         outPointer.touchMajor = inSlot->getTouchMajor();
6858         outPointer.touchMinor = inSlot->getTouchMinor();
6859         outPointer.toolMajor = inSlot->getToolMajor();
6860         outPointer.toolMinor = inSlot->getToolMinor();
6861         outPointer.orientation = inSlot->getOrientation();
6862         outPointer.distance = inSlot->getDistance();
6863         outPointer.tiltX = 0;
6864         outPointer.tiltY = 0;
6865 
6866         //ALOGD("##### touch major %ld,minor %ld, tool major %ld,minor %ld",outPointer.touchMajor,outPointer.touchMinor,outPointer.toolMajor,outPointer.toolMinor);
6867 

e.在往下面的数据经过synctouch后,调用TouchInputMapper::sync()函数中的processRawToucher();该函数中通过cookAndDispatch()函数进行数据的dispatch了,这块就是一个标准流程,没啥需要处理的,感兴趣的可以自己看看.

4234 void TouchInputMapper::processRawTouches(bool timeout) {
4235     if (mDeviceMode == DEVICE_MODE_DISABLED) {
4236         // Drop all input if the device is disabled.
4237         mCurrentRawState.clear();
4238         mRawStatesPending.clear();
4239         return;
4240     }
4241 
4242     // Drain any pending touch states. The invariant here is that the mCurrentRawState is always
4243     // valid and must go through the full cook and dispatch cycle. This ensures that anything
4244     // touching the current state will only observe the events that have been dispatched to the
4245     // rest of the pipeline.
4246     const size_t N = mRawStatesPending.size();
4247     size_t count;
4248     for(count = 0; count < N; count++) {
4249         const RawState& next = mRawStatesPending[count];
4250 
4251         // A failure to assign the stylus id means that we're waiting on stylus data
4252         // and so should defer the rest of the pipeline.
4253         if (assignExternalStylusId(next, timeout)) {
4254             break;
4255         }
4256 
4257         // All ready to go.
4258         clearStylusDataPendingFlags();
4259         mCurrentRawState.copyFrom(next);
4260         if (mCurrentRawState.when < mLastRawState.when) {
4261             mCurrentRawState.when = mLastRawState.when;
4262         }
4263         cookAndDispatch(mCurrentRawState.when);
4264     }
4265     if (count != 0) {
4266         mRawStatesPending.removeItemsAt(0, count);
4267     }
4268 

log如下:

06-28 16:43:01.964  2797  2992 D InputReader: BatchSize: 7 Count: 7
06-28 16:43:01.964  2797  2992 D InputReader: Input event: device=2 type=0x0003 code=0x0039 value=0x00000007 when=2385905411000
06-28 16:43:01.964  2797  2992 D InputReader: Input event: device=2 type=0x0003 code=0x0035 value=0x000033bd when=2385905411000
06-28 16:43:01.964  2797  2992 D InputReader: Input event: device=2 type=0x0003 code=0x0036 value=0x000074d5 when=2385905411000
06-28 16:43:01.964  2797  2992 D InputReader: Input event: device=2 type=0x0001 code=0x014a value=0x00000001 when=2385905411000
06-28 16:43:01.964  2797  2992 D InputReader: Input event: device=2 type=0x0003 code=0x0000 value=0x000033bd when=2385905411000
06-28 16:43:01.964  2797  2992 D InputReader: Input event: device=2 type=0x0003 code=0x0001 value=0x000074d5 when=2385905411000
06-28 16:43:01.964  2797  2992 D InputReader: Input event: device=2 type=0x0000 code=0x0000 value=0x00000000 when=2385905411000
06-28 16:43:01.964  2797  2992 D InputReader: ##### touch major 68,minor 68, tool major 0,minor 0
06-28 16:43:01.964  2797  2992 D InputReader: syncTouch: pointerCount 0 -> 1, touching ids 0x00000000 -> 0x80000000, hovering ids 0x00000000 -> 0x00000000 ,touchmajar 68
06-28 16:43:01.964  2797  2992 D InputReader: line 4906
06-28 16:43:01.964  2797  2992 D InputReader: line 4944 toucMajor 0
06-28 16:43:01.964  2797  2992 D InputReader: line 4946 toucMajor 0
06-28 16:43:01.964  2797  2992 D InputReader: #####touchMajor 3.112793
06-28 16:43:01.964  2797  2992 D InputReader: #### next major68, last majro68
06-28 16:43:01.964  2797  2992 D InputDispatcher: notifyMotion - eventTime=2385905411000, deviceId=2, source=0x5002, policyFlags=0x0, action=0x0, actionButton=0x0, flags=0x0, metaState=0x0, buttonState=0x0,edgeFlags=0x0, xPrecision=17.066668, yPrecision=30.340740, downTime=2385905411000
06-28 16:43:01.964  2797  2992 D InputDispatcher:   Pointer 0: id=0, toolType=1, x=776.074219, y=985.770264, pressure=1.000000, size=0.002075, touchMajor=3.112793, touchMinor=3.112793, toolMajor=3.112793, toolMinor=3.112793, orientation=0.000000
06-28 16:43:01.964  2797  2991 D InputDispatcher: Resetting ANR timeouts.
06-28 16:43:01.964  2797  2991 D InputDispatcher: dispatchMotion - eventTime=2385905411000, deviceId=2, source=0x5002, policyFlags=0x62000000, action=0x0, actionButton=0x0, flags=0x0, metaState=0x0, buttonState=0x0,edgeFlags=0x0, xPrecision=17.066668, yPrecision=30.340740, downTime=2385905411000
06-28 16:43:01.965  2797  2991 D InputDispatcher:   Pointer 0: id=0, toolType=1, x=776.074219, y=985.770264, pressure=1.000000, size=0.002075, touchMajor=3.112793, touchMinor=3.112793, toolMajor=3.112793, toolMinor=3.112793, orientation=0.000000
06-28 16:43:01.965  2797  2991 D InputDispatcher: findTouchedWindow finished: injectionResult=0, injectionPermission=1, timeSpentWaitingForApplication=0.0ms
06-28 16:43:01.965  2797  2991 D InputDispatcher: dispatchEventToCurrentInputTargets