p253:/dev/input # ls -al
crw-rw----  1 root input 13,  64 2015-01-01 00:00 event0
crw-rw----  1 root input 13,  65 2015-01-01 00:00 event1
crw-rw----  1 root input 13,  66 2015-01-01 00:00 event2
crw-rw----  1 root input 13,  63 2015-01-01 00:00 mice

从Kernel层的INPUT子系统层面，各个INPUT设备完成初始化之后，都是通过input_event()这个函数“上报”输入事件。深究这个“上报”，我们发现是input_event()往/dev/input/下面的某个event的节点里，按一定结构写数据包（type,code,value），而用户层是有专门的线程监听这个节点，一旦有数据更新，就立马读取，传传递给其它线程进一步加工处理。

NativeInputManager::NativeInputManager(jobject contextObj,
        jobject serviceObj, const sp<Looper>& looper) :
        mLooper(looper), mInteractive(true) {
...
    sp<EventHub> eventHub = new EventHub();
    mInputManager = new InputManager(eventHub, this, this);
}

2.2，入口

InputManager::InputManager(
        const sp<EventHubInterface>& eventHub,
        const sp<InputReaderPolicyInterface>& readerPolicy,
        const sp<InputDispatcherPolicyInterface>& dispatcherPolicy) {
    mDispatcher = new InputDispatcher(dispatcherPolicy);
    mReader = new InputReader(eventHub, readerPolicy, mDispatcher);
    initialize();
}

这里的EventHubInterface是EventHub的父类，所以这类型也没问题。InputReader在自己的线程执行函数中，通过这个eventHub来获取各个Input设备的数据。

...
 size_t count = mEventHub->getEvents(timeoutMillis, mEventBuffer, EVENT_BUFFER_SIZE);
...

参数timeoutMillis，设置一个超时时间；

  // The event queue.
    static const int EVENT_BUFFER_SIZE = 256;
    RawEvent mEventBuffer[EVENT_BUFFER_SIZE];

参数EVENT_BUFFER_SIZE，即buffer大小。

 再看代码实现

EventHub::EventHub(void) {
...
//获得epoll fd和inotify fd
    mEpollFd = epoll_create(EPOLL_SIZE_HINT);
    mINotifyFd = inotify_init();
//通过inotifyFd监听/dev/input这个目录
    int result = inotify_add_watch(mINotifyFd, DEVICE_PATH, IN_DELETE | IN_CREATE);
//实例化epoll_event结构体
    struct epoll_event eventItem;
    memset(&eventItem, 0, sizeof(eventItem));
    eventItem.events = EPOLLIN;
    eventItem.data.u32 = EPOLL_ID_INOTIFY;
//设置notify FD
result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mINotifyFd, &eventItem);
//初始化PipeFD，并设置PipeFd

result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mWakeReadPipeFd, &eventItem);

这里面主要是初始化了一些EPOLL机制，这也就进入我这篇文章的第二个主机，EPOLL机制

/* Valid opcodes to issue to sys_epoll_ctl() */
#define EPOLL_CTL_ADD 1
#define EPOLL_CTL_DEL 2
#define EPOLL_CTL_MOD 3

epoll_event数据结构

struct epoll_event {
	__u32 events;
	__u64 data;
} EPOLL_PACKED;

通知的两种类型

    // Ids used for epoll notifications not associated with devices.
    static const uint32_t EPOLL_ID_INOTIFY = 0x80000001;
    static const uint32_t EPOLL_ID_WAKE = 0x80000002;

重要的方法

intepoll_create(int size);
生成一个Epoll专用的文件描述符，其实是申请一个内核空间，用来存放你想关注的socket fd上是否发生以及发生了什么事件。size就是你在这个Epoll fd上能关注的最大socket fd数，大小自定，只要内存足够。
intepoll_ctl(int epfd, intop, int fd, structepoll_event *event);
控制某个Epoll文件描述符上的事件：注册、修改、删除。其中参数epfd是epoll_create()创建Epoll专用的文件描述符。相对于select模型中的FD_SET和FD_CLR宏。
intepoll_wait(int epfd,structepoll_event * events,int maxevents,int timeout);
等待I/O事件的发生；参数说明：
epfd:由epoll_create() 生成的Epoll专用的文件描述符；
epoll_event:用于回传代处理事件的数组；
maxevents:每次能处理的事件数；
timeout:等待I/O事件发生的超时值；
返回发生事件数。

回到前面，在EventHub构造函数中，设置Epoll的最大数，获得了epoll_fd，之后，每打开一个Input设置，都会把这个设备的fd注册进epoll里面去

    // Register with epoll.
    struct epoll_event eventItem;
    memset(&eventItem, 0, sizeof(eventItem));
    eventItem.events = EPOLLIN;

    eventItem.data.u32 = deviceId;
    if (epoll_ctl(mEpollFd, EPOLL_CTL_ADD, fd, &eventItem)) {
        ALOGE("Could not add device fd to epoll instance.  errno=%d", errno);
        delete device;
        return -1;
    }

epoll_event只表明某个设备上有事件，并不包含事件内容，具体事件内容需要通过read来读取。

//在调用epoll_wait(mEpollFd, mPendingEventItems, EPOLL_MAX_EVENTS, timeoutMillis);之后，读到的总event_poll保存在mPendingEventCount，mPendingEventIndex初始化为0，所以这里面的逻辑是一个个取出来
while (mPendingEventIndex < mPendingEventCount) {
            const struct epoll_event& eventItem = mPendingEventItems[mPendingEventIndex++];
//EPOLL_ID_INOTIFY类型事件
            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;
            }
//EPOLL_ID_WAKE事件
            if (eventItem.data.u32 == EPOLL_ID_WAKE) {
                if (eventItem.events & EPOLLIN) {
                    ALOGV("awoken after wake()");
                    awoken = true;
                    char buffer[16];
                    ssize_t nRead;
                    do {
//进行数据读取
                        nRead = read(mWakeReadPipeFd, buffer, sizeof(buffer));
                    } while ((nRead == -1 && errno == EINTR) || nRead == sizeof(buffer));
                } else {
                    ALOGW("Received unexpected epoll event 0x%08x for wake read pipe.",
                            eventItem.events);
                }
                continue;
            }
...
            Device* device = mDevices.valueAt(deviceIndex);
            if (eventItem.events & EPOLLIN) {
                int32_t readSize = read(device->fd, readBuffer,
                        sizeof(struct input_event) * capacity);
               
...
                } else {
                    int32_t deviceId = device->id == mBuiltInKeyboardId ? 0 : device->id;
//开始解析Buffuer
                    size_t count = size_t(readSize) / sizeof(struct input_event);
                    for (size_t i = 0; i < count; i++) {
                        struct input_event& iev = readBuffer[i];
                        ALOGV("%s got: time=%d.%06d, 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);
                        // Some input devices may have a better concept of the time
                        // when an input event was actually generated than the kernel
                        // which simply timestamps all events on entry to evdev.
                        // This is a custom Android extension of the input protocol
                        // mainly intended for use with uinput based device drivers.
                        if (iev.type == EV_MSC) {
                            if (iev.code == MSC_ANDROID_TIME_SEC) {
                                device->timestampOverrideSec = iev.value;
                                continue;
                            } else if (iev.code == MSC_ANDROID_TIME_USEC) {
                                device->timestampOverrideUsec = iev.value;
                                continue;
                            }
                        }
                        if (device->timestampOverrideSec || device->timestampOverrideUsec) {
                            iev.time.tv_sec = device->timestampOverrideSec;
                            iev.time.tv_usec = device->timestampOverrideUsec;
                            if (iev.type == EV_SYN && iev.code == SYN_REPORT) {
                                device->timestampOverrideSec = 0;
                                device->timestampOverrideUsec = 0;
                            }
                            ALOGV("applied override time %d.%06d",
                                    int(iev.time.tv_sec), int(iev.time.tv_usec));
                        }
                        // Use the time specified in the event instead of the current time
                        // so that downstream code can get more accurate estimates of
                        // event dispatch latency from the time the event is enqueued onto
                        // the evdev client buffer.
                        //
                        // The event's timestamp fortuitously uses the same monotonic clock
                        // time base as the rest of Android.  The kernel event device driver
                        // (drivers/input/evdev.c) obtains timestamps using ktime_get_ts().
                        // The systemTime(SYSTEM_TIME_MONOTONIC) function we use everywhere
                        // calls clock_gettime(CLOCK_MONOTONIC) which is implemented as a
                        // system call that also queries ktime_get_ts().
                        event->when = nsecs_t(iev.time.tv_sec) * 1000000000LL
                                + nsecs_t(iev.time.tv_usec) * 1000LL;
                        ALOGV("event time %" PRId64 ", now %" PRId64, event->when, now);
                        // Bug 7291243: Add a guard in case the kernel generates timestamps
                        // that appear to be far into the future because they were generated
                        // using the wrong clock source.
                        //
                        // This can happen because when the input device is initially opened
                        // it has a default clock source of CLOCK_REALTIME.  Any input events
                        // enqueued right after the device is opened will have timestamps
                        // generated using CLOCK_REALTIME.  We later set the clock source
                        // to CLOCK_MONOTONIC but it is already too late.
                        //
                        // Invalid input event timestamps can result in ANRs, crashes and
                        // and other issues that are hard to track down.  We must not let them
                        // propagate through the system.
                        //
                        // Log a warning so that we notice the problem and recover gracefully.
                      ...
                        event->deviceId = deviceId;
                        event->type = iev.type;
                        event->code = iev.code;
                        event->value = iev.value;
                        event += 1;
                        capacity -= 1;
                    }
                    if (capacity == 0) {
                        // The result buffer is full.  Reset the pending event index
                        // so we will try to read the device again on the next iteration.
                        mPendingEventIndex -= 1;
                        break;
                    }
                }
            }
...

这样就把数据读出来了

 

InputManager::InputManager(
        const sp<EventHubInterface>& eventHub,
        const sp<InputReaderPolicyInterface>& readerPolicy,
        const sp<InputDispatcherPolicyInterface>& dispatcherPolicy) {
    mDispatcher = new InputDispatcher(dispatcherPolicy);
    mReader = new InputReader(eventHub, readerPolicy, mDispatcher);
    initialize();
}
...
void InputManager::initialize() {
    mReaderThread = new InputReaderThread(mReader);
    mDispatcherThread = new InputDispatcherThread(mDispatcher);
}

紧接着就start()

status_t InputManager::start() {
    status_t result = mDispatcherThread->run("InputDispatcher", PRIORITY_URGENT_DISPLAY);
...
    result = mReaderThread->run("InputReader", PRIORITY_URGENT_DISPLAY);
}

从此这两个线程就各自生活，貌似分道扬镳，其实却有着联系。

=>

InputReader::InputReader(const sp<EventHubInterface>& eventHub,
        const sp<InputReaderPolicyInterface>& policy,
        const sp<InputListenerInterface>& listener) :
        mContext(this), mEventHub(eventHub), mPolicy(policy),
        mGlobalMetaState(0), mGeneration(1),
        mDisableVirtualKeysTimeout(LLONG_MIN), mNextTimeout(LLONG_MAX),
        mConfigurationChangesToRefresh(0) {
    mQueuedListener = new QueuedInputListener(listener);
    { // acquire lock
        AutoMutex _l(mLock);
        refreshConfigurationLocked(0);
        updateGlobalMetaStateLocked();
    } // release lock
}

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

InputReader.cpp里面

void InputReader::loopOnce() {
...
 size_t count = mEventHub->getEvents(timeoutMillis, mEventBuffer, EVENT_BUFFER_SIZE);
...
if (count) {
            processEventsLocked(mEventBuffer, count);
        }
...
mQueuedListener->flush();
}

去掉一些不重要的代码，loopOnce做了3件事

InputMapper* mapper = mMappers[i];

mapper->process(rawEvent);

NotifyKeyArgs args(when, getDeviceId(), mSource, policyFlags,

            down ? AKEY_EVENT_ACTION_DOWN : AKEY_EVENT_ACTION_UP,

            AKEY_EVENT_FLAG_FROM_SYSTEM, keyCode, scanCode, keyMetaState, downTime);

然后再传给某个Listener的nofifyKey，这个Listener就是InputListenerInterface，notifyKey调用就是InputDispacher的notifyKey。

getListener()->notifyKey(&args);

void InputDispatcher::notifyKey(const NotifyKeyArgs* args) {
...
mPolicy->interceptKeyBeforeQueueing(&event, /*byref*/ policyFlags);
...
}

找到，interceptKeyBeforeQueueing终于又回到问题的出发点了。接下来看另外一处世界

InputDispatcher::InputDispatcher(const sp<InputDispatcherPolicyInterface>& policy) :
    mPolicy(policy),
    mPendingEvent(NULL), mLastDropReason(DROP_REASON_NOT_DROPPED),
    mAppSwitchSawKeyDown(false), mAppSwitchDueTime(LONG_LONG_MAX),
    mNextUnblockedEvent(NULL),
    mDispatchEnabled(false), mDispatchFrozen(false), mInputFilterEnabled(false),
    mInputTargetWaitCause(INPUT_TARGET_WAIT_CAUSE_NONE) {
    mLooper = new Looper(false);
    mKeyRepeatState.lastKeyEntry = NULL;
    policy->getDispatcherConfiguration(&mConfig);
}

没啥要特别讲的，那么进入线程的loop函数

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

=>

 if (!haveCommandsLocked()) {
            dispatchOnceInnerLocked(&nextWakeupTime);
        }

如果有数据就进入dispachOnceInnerLocked，进一步处理。

void InputDispatcher::dispatchOnceInnerLocked(nsecs_t* nextWakeupTime) {
...
case EventEntry::TYPE_KEY: {
        KeyEntry* typedEntry = static_cast<KeyEntry*>(mPendingEvent);
        if (isAppSwitchDue) {
            if (isAppSwitchKeyEventLocked(typedEntry)) {
                resetPendingAppSwitchLocked(true);
                isAppSwitchDue = false;
            } else if (dropReason == DROP_REASON_NOT_DROPPED) {
                dropReason = DROP_REASON_APP_SWITCH;
            }
        }
        if (dropReason == DROP_REASON_NOT_DROPPED
                && isStaleEventLocked(currentTime, typedEntry)) {
            dropReason = DROP_REASON_STALE;
        }
        if (dropReason == DROP_REASON_NOT_DROPPED && mNextUnblockedEvent) {
            dropReason = DROP_REASON_BLOCKED;
        }
        done = dispatchKeyLocked(currentTime, typedEntry, &dropReason, nextWakeupTime);
        break;
    }
...
}

=>

CommandEntry* commandEntry = postCommandLocked(
          & InputDispatcher::doInterceptKeyBeforeDispatchingLockedInterruptible);

=>

 nsecs_t delay = mPolicy->interceptKeyBeforeDispatching(commandEntry->inputWindowHandle,

            &event, entry->policyFlags);

继续上一讲，从InputManagerService讲起，自上而下分析。

（IInputDevicesChangedListener.aidl  IInputManager.aidl  InputManager.java  KeyboardLayout.aidl  KeyboardLayout.java）

Class Overview

Provides information about input devices and available key layouts.

Get an instance of this class by calling Context.getSystemService() with the argument INPUT_SERVICE.

1，InputMangerService是怎么产生的？

 329             Slog.i(TAG, “Input Manager”);                                                                                                                
330             inputManager = new InputManagerService(context, wmHandler);

InputManagerService的代码位于

frameworks/base/services/java/com/android/server/input/InputManagerService.java

2,

“

nativeInit()

->

com_android_server_input_InputManagerService.cpp

nativeInit()

->

new NativeInputManager()

->

new InputManager()

->

InputManager::InputManager(
        const sp<EventHubInterface>& eventHub,
        const sp<InputReaderPolicyInterface>& readerPolicy,
        const sp<InputDispatcherPolicyInterface>& dispatcherPolicy) {
    mDispatcher = new InputDispatcher(dispatcherPolicy);
    mReader = new InputReader(eventHub, readerPolicy, mDispatcher);
initialize();
}

=>

void InputManager::initialize() {
    mReaderThread = new InputReaderThread(mReader);
    mDispatcherThread = new InputDispatcherThread(mDispatcher);
}

—-

以InputReaderThread为例

InputReader.cpp

InputReaderThread::InputReaderThread(const sp<InputReaderInterface>& reader) :
        Thread(/*canCallJava*/ true), mReader(reader) {
}

InputReaderThread::~InputReaderThread() {
}

bool InputReaderThread::threadLoop() {
    mReader->loopOnce();//这里的mReader就是InputReader的实例
    return true;
}

->

void InputReader::loopOnce() {

…

size_t count = mEventHub->getEvents(timeoutMillis, mEventBuffer, EVENT_BUFFER_SIZE);//EventHubInterface，getEvents就是读driver的/dev目录

…

}

其中，这个线程有一个非常重要的函数getEvents，就是这个线程主要的工作

getEvents(){

…

for(; 😉

{

…

readNotifyLocked()

…

}

}

会不停的读系统输入设备的状态。

“

这段话这样解释。

1，根据事件路由，打开各个节点debug信息

• EventHub.cpp

KeyWord:

KeyFunction:

• InputReader.cpp

KeyWord:

KeyFunction:

• InputDispatcher()

KeyWord:

KeyFunction:

notifyKey()

示例：

3，dumpsys input

读取Input相关的信息，大概分为Event Hub State、Input Reader State、Input Dispatcher State这三个部分，从这里，同时也初窥到了Android中Input的层次关系

在Kernel里面主要分三层，设备驱动层、Input Core、事件驱动层。

• 静态数据结构

存储Input设备的信息，主要位于input.h

• 动态数据结构

在Input事件驱动层，以dvdev为例

input_handler：input管理者

总共有三个核心的函数

input_register_handler(&evdev_handler);

input_register_handle(&evdev->handle);

input_register_device(remote->input);

前面两个是在事件驱动层的evdev.c的init函数和connect函数中调用；最后一个是在设备驱动中注册的。

我们从最底层的input_register_device分析起，以IR遥控器驱动为例

在probe函数中，进行input_register_device把该input设备注册进全局的input_dev_list链表

注册完成之后，一般就调用这两个函数发送数据到input子系统中

=》

input_handle_event(dev, type, code, value);

=》

input_pass_event(dev, type, code, value);

=》

handle->handler->event(handle, type, code, value);

在input_register_handler的时候，为dev分配了一个handler，并与handle进行关联了，此时就直接进入event函数了。