Android系统input系统(1)

我们平台的build system移植于android，在android组件中，我们使用了Binder驱动，来实现进程间的交互，对于input系统，因为我们将android的java application framework换成了Qt，为了实现更好的图形渲染，主要是我们需要实现主从设备的显示屏公用，这样我们需要将从设备的surface传输到主设备的来实现不同设备间的surface合成，来实现主从设备共同显示。我们使用了Wayland，其自带input系统。今天我深入android源码，看看android是怎么样来完成input设备的插拔和事件监听，和事件的分发。

源码位置

这个我们以4.4.4的源码为基础。
一个在先android源码阅读网站:androidxref

input相关源码
/frameworks/native/include/android/
/frameworks/native/include/input/
/frameworks/native/libs/input/
/frameworks/base/services/input/
/frameworks/base/services/java/com/android/server/input/
/frameworks/base/services/jni/

先看这个文件
/frameworks/native/include/android/input.h
这个文件定义了android系统input相关的枚举值和一些辅助函数。input事件主要分为两种一种是Key按下抬起事件，另一种是移动事件，比如触摸屏手势，TouchPad的Cursor移动。

整个流程

Input系统分为分为两个部分，一个是事件的读取，一个是分发，分别对应/frameworks/base/services/input/InputReader.cpp和/frameworks/base/services/input/InputDispatcher.cpp。他们分别运行在不同的线程。

input事件监听

linux系统input系统，当有输入设备插拔的时候，会在/dev/input目录下生成和删除相应的驱动文件。这里介绍一个重要的类EventHub，其封装了事件监听相关的操作。android使用epoll来实现I/O的事件的监听，以前我也在博文中介绍过epoll，用于高性能的服务器开发。

   mEpollFd = epoll_create(EPOLL_SIZE_HINT);
    LOG_ALWAYS_FATAL_IF(mEpollFd < 0, "Could not create epoll instance.  errno=%d", errno);

   mINotifyFd = inotify_init();
   int result = inotify_add_watch(mINotifyFd, DEVICE_PATH, IN_DELETE | IN_CREATE);
    LOG_ALWAYS_FATAL_IF(result < 0, "Could not register INotify for %s.  errno=%d",
            DEVICE_PATH, errno);

    struct epoll_event eventItem;
    memset(&eventItem, 0, sizeof(eventItem));
    eventItem.events = EPOLLIN;
  eventItem.data.u32 = EPOLL_ID_INOTIFY;
   result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mINotifyFd, &eventItem);

使用inotify来实现/dev/input目录的监听，将inotify的句柄加入到epoll的监听链表中实现当设备插拔时的事件监听。
InputReader在loopOnce中通过调用EventHub的getEvent函数来驱input事件监听。
设备插拔监听
在将inotify的id加入epoll时

    struct epoll_event eventItem;
  memset(&eventItem, 0, sizeof(eventItem));
  eventItem.events = EPOLLIN;
   eventItem.data.u32 = EPOLL_ID_INOTIFY;

EPOLL_ID_INOTIFY作为额外参数传入
这样

   const struct epoll_event& eventItem = mPendingEventItems[mPendingEventIndex++];
          if (eventItem.data.u32 == EPOLL_ID_INOTIFY) {
             if (eventItem.events & EPOLLIN) {
                 mPendingINotify = true;
              } else {
                  ALOGW("Received unexpected epoll event 0x%08x for INotify.", eventItem.events);
               }
               continue;
            }

根据这个标识我们mPendingINotify置成true，这样在epell_wait 调用后来执行设备插拔操作

     if (mPendingINotify && mPendingEventIndex >= mPendingEventCount) {
         mPendingINotify = false;
         readNotifyLocked();
            deviceChanged = true;
     }

readNotifyLocked函数去读取/dev/input目录下的create和delete的事件。

1462 status_t EventHub::readNotifyLocked() {
1463    int res;
1464    char devname[PATH_MAX];
1465    char *filename;
1466    char event_buf[512];
1467    int event_size;
1468    int event_pos = 0;
1469    struct inotify_event *event;
1470
1471    ALOGV("EventHub::readNotify nfd: %d\n", mINotifyFd);
1472    res = read(mINotifyFd, event_buf, sizeof(event_buf));
1473    if(res < (int)sizeof(*event)) {
1474        if(errno == EINTR)
1475            return 0;
1476        ALOGW("could not get event, %s\n", strerror(errno));
1477        return -1;
1478    }
1479    //printf("got %d bytes of event information\n", res);
1480
1481    strcpy(devname, DEVICE_PATH);
1482    filename = devname + strlen(devname);
1483    *filename++ = '/';
1484
1485    while(res >= (int)sizeof(*event)) {
1486        event = (struct inotify_event *)(event_buf + event_pos);
1487        //printf("%d: %08x \"%s\"\n", event->wd, event->mask, event->len ? event->name : "");
1488        if(event->len) {
1489            strcpy(filename, event->name);
1490            if(event->mask & IN_CREATE) {
1491                openDeviceLocked(devname);
1492            } else {
1493                ALOGI("Removing device '%s' due to inotify event\n", devname);
1494                closeDeviceByPathLocked(devname);
1495            }
1496        }
1497        event_size = sizeof(*event) + event->len;
1498        res -= event_size;
1499        event_pos += event_size;
1500    }
1501    return 0;
1502}

这里读出每个事件然后与/dev/input拼接成devicename来，然后根据是插拔来调用打开还是关闭驱动文件。
opendeviceLocked函数根据传入的设备名，来开发设备，然后实例化一个Device对象，然后通过ioctl调用来获得设备的各种信息，然后给设备分配一个deviceId，其初始值为1，然后递加分配。

    int32_t deviceId = mNextDeviceId++;

然后是比较重要的一步，就是知道是什么输入设备，是KeyBoard,Cursor,单点屏幕，多点屏幕还是joystick。这个很重要，决定了对raw数据的解析和上层将数据作为Key还是Motion处理。这之后还有一些需要处理，比如为KeyBoard配置Key映射表，设备是否有特殊的部分，内核驱动是否KEY支持repeat。
重要的一步

1245    struct epoll_event eventItem;
1246    memset(&eventItem, 0, sizeof(eventItem));
1247    eventItem.events = EPOLLIN;
1248    eventItem.data.u32 = deviceId;
1249    if (epoll_ctl(mEpollFd, EPOLL_CTL_ADD, fd, &eventItem)) {
1250        ALOGE("Could not add device fd to epoll instance.  errno=%d", errno);
1251        delete device;
1252        return -1;
1253    }

将设备加入到epoll中，这样就能监听设备操作了，eventItem.data.u32 = deviceId;可以知道那个设备的事件，根据deviceId可以知道那个设备，就知道怎么对数据进行处理了。
在’InputReadner’中在loopOnce调用了EventHub::getEvents后使用

void InputReader::processEventsLocked(const RawEvent* rawEvents, size_t count) {
311    for (const RawEvent* rawEvent = rawEvents; count;) {
312        int32_t type = rawEvent->type;
313        size_t batchSize = 1;
314        if (type < EventHubInterface::FIRST_SYNTHETIC_EVENT) {
315            int32_t deviceId = rawEvent->deviceId;
316            while (batchSize < count) {
317                if (rawEvent[batchSize].type >= EventHubInterface::FIRST_SYNTHETIC_EVENT
318                        || rawEvent[batchSize].deviceId != deviceId) {
319                    break;
320                }
321                batchSize += 1;
322            }
323#if DEBUG_RAW_EVENTS
324            ALOGD("BatchSize: %d Count: %d", batchSize, count);
325#endif
326            processEventsForDeviceLocked(deviceId, rawEvent, batchSize);
327        } else {
328            switch (rawEvent->type) {
329            case EventHubInterface::DEVICE_ADDED:
330                addDeviceLocked(rawEvent->when, rawEvent->deviceId);
331                break;
332            case EventHubInterface::DEVICE_REMOVED:
333                removeDeviceLocked(rawEvent->when, rawEvent->deviceId);
334                break;
335            case EventHubInterface::FINISHED_DEVICE_SCAN:
336                handleConfigurationChangedLocked(rawEvent->when);
337                break;
338            default:
339                ALOG_ASSERT(false); // can't happen
340                break;
341            }
342        }
343        count -= batchSize;
344        rawEvent += batchSize;
345    }
346}

来处理事件
先来看device add事件

void InputReader::addDeviceLocked(nsecs_t when, int32_t deviceId) {
349    ssize_t deviceIndex = mDevices.indexOfKey(deviceId);
350    if (deviceIndex >= 0) {
351        ALOGW("Ignoring spurious device added event for deviceId %d.", deviceId);
352        return;
353    }
354
355    InputDeviceIdentifier identifier = mEventHub->getDeviceIdentifier(deviceId);
356    uint32_t classes = mEventHub->getDeviceClasses(deviceId);
357    int32_t controllerNumber = mEventHub->getDeviceControllerNumber(deviceId);
358
359    InputDevice* device = createDeviceLocked(deviceId, controllerNumber, identifier, classes);
360    device->configure(when, &mConfig, 0);
361    device->reset(when);
362
363    if (device->isIgnored()) {
364        ALOGI("Device added: id=%d, name='%s' (ignored non-input device)", deviceId,
365                identifier.name.string());
366    } else {
367        ALOGI("Device added: id=%d, name='%s', sources=0x%08x", deviceId,
368                identifier.name.string(), device->getSources());
369    }
370
371    mDevices.add(deviceId, device);
372    bumpGenerationLocked();
373}

这里从EventHub中获得这个设备的相关属性，然后创建一个对应的InputDevice对象。

399InputDevice* InputReader::createDeviceLocked(int32_t deviceId, int32_t controllerNumber,
400        const InputDeviceIdentifier& identifier, uint32_t classes) {
401    InputDevice* device = new InputDevice(&mContext, deviceId, bumpGenerationLocked(),
402            controllerNumber, identifier, classes);
403
404    // External devices.
405    if (classes & INPUT_DEVICE_CLASS_EXTERNAL) {
406        device->setExternal(true);
407    }
408
409    // Switch-like devices.
410    if (classes & INPUT_DEVICE_CLASS_SWITCH) {
411        device->addMapper(new SwitchInputMapper(device));
412    }
413
414    // Vibrator-like devices.
415    if (classes & INPUT_DEVICE_CLASS_VIBRATOR) {
416        device->addMapper(new VibratorInputMapper(device));
417    }
418
419    // Keyboard-like devices.
420    uint32_t keyboardSource = 0;
421    int32_t keyboardType = AINPUT_KEYBOARD_TYPE_NON_ALPHABETIC;
422    if (classes & INPUT_DEVICE_CLASS_KEYBOARD) {
423        keyboardSource |= AINPUT_SOURCE_KEYBOARD;
424    }
425    if (classes & INPUT_DEVICE_CLASS_ALPHAKEY) {
426        keyboardType = AINPUT_KEYBOARD_TYPE_ALPHABETIC;
427    }
428    if (classes & INPUT_DEVICE_CLASS_DPAD) {
429        keyboardSource |= AINPUT_SOURCE_DPAD;
430    }
431    if (classes & INPUT_DEVICE_CLASS_GAMEPAD) {
432        keyboardSource |= AINPUT_SOURCE_GAMEPAD;
433    }
434
435    if (keyboardSource != 0) {
436        device->addMapper(new KeyboardInputMapper(device, keyboardSource, keyboardType));
437    }
438
439    // Cursor-like devices.
440    if (classes & INPUT_DEVICE_CLASS_CURSOR) {
441        device->addMapper(new CursorInputMapper(device));
442    }
443
444    // Touchscreens and touchpad devices.
445    if (classes & INPUT_DEVICE_CLASS_TOUCH_MT) {
446        device->addMapper(new MultiTouchInputMapper(device));
447    } else if (classes & INPUT_DEVICE_CLASS_TOUCH) {
448        device->addMapper(new SingleTouchInputMapper(device));
449    }
450
451    // Joystick-like devices.
452    if (classes & INPUT_DEVICE_CLASS_JOYSTICK) {
453        device->addMapper(new JoystickInputMapper(device));
454    }
455
456    return device;
457}

这边就知道我们在EventHub里面添加设备的时候为什么需要得知设备的相关属性。这边为每个设备产生不同的设备的数据处理类。
下面是对设备输入数据的处理

459void InputReader::processEventsForDeviceLocked(int32_t deviceId,
460        const RawEvent* rawEvents, size_t count) {
461    ssize_t deviceIndex = mDevices.indexOfKey(deviceId);
462    if (deviceIndex < 0) {
463        ALOGW("Discarding event for unknown deviceId %d.", deviceId);
464        return;
465    }
466
467    InputDevice* device = mDevices.valueAt(deviceIndex);
468    if (device->isIgnored()) {
469        //ALOGD("Discarding event for ignored deviceId %d.", deviceId);
470        return;
471    }
472
473    device->process(rawEvents, count);
474}

这边会根据deviceId来获得InputDevice对象，使用process来处理这些事件。

952void InputDevice::process(const RawEvent* rawEvents, size_t count) {
953    // Process all of the events in order for each mapper.
954    // We cannot simply ask each mapper to process them in bulk because mappers may
955    // have side-effects that must be interleaved.  For example, joystick movement events and
956    // gamepad button presses are handled by different mappers but they should be dispatched
957    // in the order received.
958    size_t numMappers = mMappers.size();
959    for (const RawEvent* rawEvent = rawEvents; count--; rawEvent++) {
960#if DEBUG_RAW_EVENTS
961        ALOGD("Input event: device=%d type=0x%04x code=0x%04x value=0x%08x when=%lld",
962                rawEvent->deviceId, rawEvent->type, rawEvent->code, rawEvent->value,
963                rawEvent->when);
964#endif
965
966        if (mDropUntilNextSync) {
967            if (rawEvent->type == EV_SYN && rawEvent->code == SYN_REPORT) {
968                mDropUntilNextSync = false;
969#if DEBUG_RAW_EVENTS
970                ALOGD("Recovered from input event buffer overrun.");
971#endif
972            } else {
973#if DEBUG_RAW_EVENTS
974                ALOGD("Dropped input event while waiting for next input sync.");
975#endif
976            }
977        } else if (rawEvent->type == EV_SYN && rawEvent->code == SYN_DROPPED) {
978            ALOGI("Detected input event buffer overrun for device %s.", getName().string());
979            mDropUntilNextSync = true;
980            reset(rawEvent->when);
981        } else {
982            for (size_t i = 0; i < numMappers; i++) {
983                InputMapper* mapper = mMappers[i];
984                mapper->process(rawEvent);
985            }
986        }
987    }
988}

然后使用设备对应的InputMapper们来处理事件。
这里我们以KEY事件为例子查看KeyboardInputMapper。
最终会调到

void KeyboardInputMapper::processKey(nsecs_t when, bool down, int32_t keyCode, int32_t scanCode, uint32_t policyFlags) 

这个方法，其在内部会将其打包成一个NotifyKeyArgs对象，通过注册下来的监听类来通知KEY到来。

    NotifyKeyArgs args(when, getDeviceId(), mSource, policyFlags,
          down ? AKEY_EVENT_ACTION_DOWN : AKEY_EVENT_ACTION_UP,
           AKEY_EVENT_FLAG_FROM_SYSTEM, keyCode, scanCode, newMetaState, downTime);
   getListener()->notifyKey(&args);

而这个监听类就是我们下面说的分发类InputDispatcher，其实现了
InputListenerInterface类的相关接口，比如notifyKey。
在InputDispatcher的notifyKey中，我们根据参数产生一个
KeyEntry然后进队。

2410        int32_t repeatCount = 0;
2411        KeyEntry* newEntry = new KeyEntry(args->eventTime,
2412                args->deviceId, args->source, policyFlags,
2413                args->action, flags, args->keyCode, args->scanCode,
2414                metaState, repeatCount, args->downTime);
2415
2416        needWake = enqueueInboundEventLocked(newEntry);

这些输入事件其会放入一个名为mInboundQueue的Queue<EventEntry>对象中。

InputDispathcer在独立的线程运行。

4465bool InputDispatcherThread::threadLoop() {
4466    mDispatcher->dispatchOnce();
4467    return true;
4468}

其会不停的调用dispatchOnce，就像InputReader不停调用loopOnce一样。
(1)dispatchOnce
(2)dispatchOnceInnerLocked，出队一个mPendingEvent = mInboundQueue.dequeueAtHead()
(3)dispatchKeyLocked
(4)dispatchEventLocked
(5)prepareDispatchCycleLocked
(6)enqueueDispatchEntriesLocked
(7)startDispatchCycleLocked，这样完成了一个事件的派发。

InputManager实现对reade和dispatcher的线程的管理。

下面一篇将讲java层和c++层的关于事件分发，以及事件怎么发送到application和Window。