Android输入系统源码分析

参考：《深入理解Android 卷III》

 输入事件的源头是位于/dev/input/下的设备节点，而输入系统的终点是由WMS管理的某个窗口。最初的输入事件为内核生成的原始事件，而最终交付给窗口的则是KeyEvent或MotionEvent对象。因此Android输入系统的主要工作是读取设备节点中的原始事件，将其加工封装，然后派发给一个特定的窗口以及窗口中的控件。这个过程由InputManagerService系统服务为核心的多个参与者共同完成。输入系统的总体流程和参与者如图所示。



Linux内核，接受输入设备的中断，并将原始事件的数据写入到设备节点中。

设备节点，作为内核与IMS的桥梁，它将原始事件的数据暴露给用户空间，以便IMS可以从中读取事件。

InputManagerService，一个Android系统服务，它分为Java层和Native层两部分。Java层负责与WMS的通信。而Native层则是InputReader和InputDispatcher两个输入系统关键组件的运行容器。

EventHub，直接访问所有的设备节点。并且正如其名字所描述的，它通过一个名为getEvents()的函数将所有输入系统相关的待处理的底层事件返回给使用者。这些事件包括原始输入事件、设备节点的增删等。

InputReader，是IMS中的关键组件之一。它运行于一个独立的线程Reader线程中，通过其线程循环不断地通过getEvents()函数从EventHub中将事件取出并进行处理。然后交给InputDispatcher进行派发。

InputDispatcher，是IMS中的另一个关键组件。它也运行于一个独立的线程中Dispatcher线程中。InputDispatcher中保管了来自WMS的所有窗口的信息，其收到来自InputReader的输入事件后，会在其保管的窗口中寻找合适的窗口，并将事件派发给此窗口。

WMS，虽说不是输入系统中的一员，但是它却对InputDispatcher的正常工作起到了至关重要的作用。当新建窗口时，WMS为新窗口和IMS创建了事件传递所用的通道。另外，WMS还将所有窗口的信息，包括窗口的可点击区域，焦点窗口等信息，实时地更新到IMS的InputDispatcher中，使得InputDispatcher可以正确地将事件派发到指定的窗口。

以下是代码分析，建议用sourceinsight进行代码跟踪。

输入系统会创建Reader线程和Dispatcher线程

Reader线程和Dispatcher线程创建及启动过程源码分析：

SystemServer所有服务被创建的源头，同其他系统服务一样，IMS在SystemServer中被启动。

SystemServer.java (frameworks\base\services\java\com\android\server)
private void startOtherServices() {
inputManager = new InputManagerService(context);     //创建InputManagerService
inputManager.start();                                //启动这个服务
}

InputManagerService.java (frameworks\base\services\core\java\com\android\server\input)
public InputManagerService(Context context) {
mPtr = nativeInit(this, mContext, mHandler.getLooper().getQueue());       //调用本地方法进行初始化
}
public void start() {
nativeStart(mPtr);             //调用本地nativeStart函数
}

调用native方法，创建Reader线程和Dispatcher线程并启动

com_android_server_input_InputManagerService.cpp (frameworks\base\services\core\jni)
static jlong nativeInit {
/* 创建了一个NativeInputManager对象，此对象将是Native层组件与Java层IMS进行通信的桥梁 */
NativeInputManager* im = new NativeInputManager(contextObj, serviceObj, messageQueue->getLooper());
}
NativeInputManager::NativeInputManager {
//NativeInputManager创建了EventHub,EventHub复杂的构造函数使其在创建后便拥有了监听设备节点的能力(Inotify和epoll机制)
sp<EventHub> eventHub = new EventHub();

// 接着创建了Native层的InputManager
mInputManager = new InputManager(eventHub, this, this);
}

被InputManagerService的start函数所调用来启动线程。
static void nativeStart(JNIEnv* env, jclass clazz, jlong ptr) {
NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);

status_t result = im->getInputManager()->start();
}

InputManager统一创建并管理mReader、mReaderThread、mDispatcher、mDispatcherThread这四个实例化对象。

InputManager.cpp (frameworks\native\services\inputflinger)
class InputManager {
sp<InputReaderInterface> mReader;
sp<InputReaderThread> mReaderThread;

sp<InputDispatcherInterface> mDispatcher;
sp<InputDispatcherThread> mDispatcherThread;
}
/* 在InputManager中创建InputDispatcher和InputReader实例化对象 */
InputManager::InputManager {
mDispatcher = new InputDispatcher(dispatcherPolicy);
mReader = new InputReader(eventHub, readerPolicy, mDispatcher);
initialize();
}
void InputManager::initialize() {
//创建Reader线程和Dispatcher线程
mReaderThread = new InputReaderThread(mReader);
mDispatcherThread = new InputDispatcherThread(mDispatcher);
}

status_t InputManager::start() {
/* 启动ReaderThread和DispatcherThread */
status_t result = mDispatcherThread->run("InputDispatcher", PRIORITY_URGENT_DISPLAY);
result = mReaderThread->run("InputReader", PRIORITY_URGENT_DISPLAY);
}

mDispatcherThread->run和mReaderThread->run分别会执行InputReaderThread和InputDispatcherThread线程的线程循环体。

InputReader.cpp (frameworks\native\services\inputflinger)
/* 创建InputReaderThread线程，实现循环操作 */
bool InputReaderThread::threadLoop() {
mReader->loopOnce();    // 执行InputReader的loopOnce()函数
return true;
}
InputReaderThread启动后，其线程循环将不断地执行InputReader.loopOnce()函数。因此这个loopOnce()函数作为线程循环的循环体包含了InputReader的所有工作。

InputDispatcher.cpp (frameworks\native\services\inputflinger)
bool InputDispatcherThread::threadLoop() {
mDispatcher->dispatchOnce();
return true;
}

至此，IMS的创建完成了。InputManager的创建过程分别为InputReader与InputDispatcher创建了承载它们运行的线程，此时start()函数的功能就是启动这两个线程，使得InputReader于InputDispatcher开始工作。

EventHub分析(Reader线程使用EventHub读取事件)：

getEvents读取的输入事件是一个RawEvent结构体             *       Linux驱动上报的输入事件是input_event结构体
struct RawEvent {                                    *        struct input_event {
nsecs_t when;                                    *          struct timeval time;
int32_t deviceId;                                *          __u16 type;
int32_t type;                                    *          __u16 code;
int32_t code;                                    *          __s32 value;
int32_t value;                                   *        };
};                                                   *
*
type：                                               *        type：
DEVICE_ADDED              //输入设备插入               *        EV_KEY
DEVICE_REMOVED            //输入设备拔掉               *        EV_ABS
FINISHED_DEVICE_SCAN      //有设备上报了输入事件        *        EV_REL
EV_KEY                                               *
EV_ABS                                               *
EV_REL                                               *

EventHub中使用RawEvent结构体是对input_event结构体的扩展，根据类型和源码可知，EventHub使用inotify检测/dev/input目录下设备的插入或者拔出，使用epoll检测/dev/input/eventx有无数据。

EventHub.cpp (frameworks\native\services\inputflinger)
在EventHub的构造函数中使用inotify和epoll机制检测/dev/input目录下设备的插入或者拔出
EventHub::EventHub(void){
/* 初始化一个inotify句柄 */
mINotifyFd = inotify_init();
/* 将/dev/input目录添加到句柄中 */
int result = inotify_add_watch(mINotifyFd, DEVICE_PATH, IN_DELETE | IN_CREATE);
//static const char *DEVICE_PATH = "/dev/input";

mEpollFd = epoll_create(EPOLL_SIZE_HINT);
/* 将inotify句柄添加到epoll的检测列表中，开始检测 */
result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mINotifyFd, &eventItem);
}

获取输入事件 – getEvent函数

size_t EventHub::getEvents(int timeoutMillis, RawEvent* buffer, size_t bufferSize) {
/* 这个循环是getEvents()函数的主体。在这个循环中，会先将可用事件放入到buffer中并返回。
如果没有可用事件，则进入epoll_wait()等待事件的到来，epoll_wait()返回后会重新循环将可用
将新事件放入buffer */
for (;;) {
/* 扫描目录下的所有设备看是否有设备插入或者删除 */
scanDevicesLocked();
status_t res = scanDirLocked(DEVICE_PATH);
dir = opendir(dirname);
while((de = readdir(dir)))
openDeviceLocked(devname) {
/* 打开/dev/input/eventx */
int fd = open(devicePath, O_RDWR | O_CLOEXEC);
/* 获取版本号，GID等等 */
ioctl(fd, EVIOCGVERSION, &driverVersion)
ioctl(fd, EVIOCGID, &inputId)
....

/* 将打开的文件的fd添加到epoll检测列表中，检测是否有数据产生 */
epoll_ctl(mEpollFd, EPOLL_CTL_ADD, fd, &eventItem)
}

/* 如果EPOLL_ID_INOTIFY，说明/dev/input目录有变化（增加或者删除设备），mPendingEventIndex指定尚未
处理的epoll_event的索引 */
while (mPendingEventIndex < mPendingEventCount) {
const struct epoll_event& eventItem = mPendingEventItems[mPendingEventIndex++];
if (eventItem.data.u32 == EPOLL_ID_INOTIFY) {
mPendingINotify = true;     //更改标记位为true
}

/* 如果EPOLLIN，说明有输入事件产生，则去读取输入事件 */
if (eventItem.events & EPOLLIN) {
int32_t readSize = read(device->fd, readBuffer,sizeof(struct input_event) * capacity);    /* 读取的输入数据是input_event结构体 */

/* 将读取到的input_event结构体转换为EventHub中对应的RawEvent结构体 */
size_t count = size_t(readSize) / sizeof(struct input_event);
for (size_t i = 0; i < count; i++) {
event->type = iev.type;         //RawEvent* event;
event->code = iev.code;
event->value = iev.value;
event += 1;
}
}
}

/* 如果标记位为true，则去读取notify */
if (mPendingINotify && mPendingEventIndex >= mPendingEventCount) {
mPendingINotify = false;
readNotifyLocked(); {
//如果是插入了新的设备，那么就调用openDeviceLocked去打开这个设备，然后获取各种信息，并添加到
//检测列表(上面分析过)
if(event->mask & IN_CREATE)
openDeviceLocked(devname);
}
deviceChanged = true;
}

// Report added or removed devices immediately.
//设备节点增删操作发生时，则重新执行循环体，以便将设备变化的事件放入buffer中
if (deviceChanged) {
continue;
}

// 如果此次getEvents()调用成功获取了一些事件，或者要求唤醒InputReader，则退出循环并
// 结束getEvents()的调用，使InputReader可以立刻对事件进行处理
if(event != buffer || awoken) {
break;
}

/* 不断的循环检测/dev/input下的所有设备epoll_wait()所取出的epoll_event存储在mPendingEventItems
中，mPendingEventCount指定了mPendingEventItems数组所存储的事件个数。*/
int pollResult = epoll_wait(mEpollFd, mPendingEventItems, EPOLL_MAX_EVENTS, timeoutMillis);
}  //end of for(;;)

// All done, return the number of events we read.
return event - buffer;
}

深入分析Reader线程

/*通过EventHub获取事件列表。读取的结果存储在参数mEventBuffer中，返回值表示事件的个数
当EventHub中无事件可以抽取时，此函数的调用将会阻塞直到事件到来或者超时 */
void InputReader::loopOnce() {
/* 获取输入事件，参照下文EventHub分析 */
size_t count = mEventHub->getEvents(timeoutMillis, mEventBuffer, EVENT_BUFFER_SIZE);

//如果有输入事件发生，则调用processEventsLocked()函数对事件进行加工处理
if (count) {
processEventsLocked(mEventBuffer, count);
}

/*发布事件。 processEventsLocked()函数在对事件进行加工处理之后，便将处理后的事件存储在
mQueuedListener中。在循环的最后，通过调用flush()函数将所有事件交付给InputDispatcher */
mQueuedListener->flush();
}

对事件进行加工处理：

void InputReader::processEventsLocked(const RawEvent* rawEvents, size_t count) {
for (const RawEvent* rawEvent = rawEvents; count;) {
/* 当有真正的输入事件，则调用processEventsForDeviceLocked进行处理 */
processEventsForDeviceLocked(deviceId, rawEvent, batchSize);

/* 把所有的事件（插入新的输入设备/拔掉了一个输入设备/输入设备有输入事件产生）都抽取出来，进行判断 */
switch (rawEvent->type) {
case EventHubInterface::DEVICE_ADDED:
/* 对于增加新设备的时间，会在InputReader里面构造一下input_device结构体进行记录 */
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;
}
}
}

具体处理

processEventsForDeviceLocked(deviceId, rawEvent, batchSize);
{
InputDevice* device = mDevices.valueAt(deviceIndex);
device->process(rawEvents, count);
{
InputMapper* mapper = mMappers[i];
mapper->process(rawEvent);
{
/* 对于键盘，调用Keyboard的process */
void KeyboardInputMapper::process(const RawEvent* rawEvent)
{
/* 映射：scanCode是驱动程序上报的扫描码  转换为Android系统中的keyCode */
getEventHub()->mapKey(getDeviceId(), scanCode, usageCode, &keyCode, &flags)
{//eventhub.cpp
/* 映射的时候会先使用kl文件映射，如果失败再使用kcm文件映射 */
status_t EventHub::mapKey(int32_t deviceId, int32_t scanCode, int32_t usageCode, int32_t* outKeycode, uint32_t* outFlags)
}

/* 映射成功，则进行处理 */
processKey(rawEvent->when, rawEvent->value != 0, keyCode, scanCode, flags);
{
/* 根据参数构造args：down/up，keyCode scanCode newMetaState(是否有shift按下) */
NotifyKeyArgs args(when, getDeviceId(), mSource, policyFlags, down ? AKEY_EVENT_ACTION_DOWN : AKEY_EVENT_ACTION_UP, AKEY_EVENT_FLAG_FROM_SYSTEM, keyCode, scanCode, newMetaState, downTime);
/* 然后通知listener来进行处理，把args发给dispatch线程 */
getListener()->notifyKey(&args);
}
}
}
}
}

总结：Reader线程对输入事件的处理很简单，就是把驱动上报的scancode转换为Android的AKEYCODE码，然后构造成args参数，最后传递给dispatcher线程。

Reader线程到Dispatcher线程间数据的传递：

在分析InputManager.cpp的时候分析过，InputManager管理四个对象mReader mReaderThread mDispatcher mDispatcherThread

在InputManager的构造函数中创建mReader对象，其中第三个参数是一个listener：
/*
InputReader::InputReader(const sp<EventHubInterface>& eventHub,
const sp<InputReaderPolicyInterface>& policy,
const sp<InputListenerInterface>& listener)
*/
mReader = new InputReader(eventHub, readerPolicy, mDispatcher);

所以getListener()->notifyKey(&args);中getListener()获取的是一个mDispatcher对象，notifyKey是Dispatcher中的notifyKey方法.

Dispatcher线程分析：

接收数据

InputDispatcher.cpp (frameworks\native\services\inputflinger)
void InputDispatcher::notifyKey(const NotifyKeyArgs* args) {
/* 将从Reader线程传进来的args参数构造成一个KeyEvent结构体 */
KeyEvent event;
event.initialize(args->deviceId, args->source, args->action,
flags, keyCode, args->scanCode, metaState, 0,
args->downTime, args->eventTime);

/* 然后对传入的输入事件简单处理 */
mPolicy->interceptKeyBeforeQueueing(&event, /*byref*/ policyFlags);
{//NativeInputManager::interceptKeyBeforeQueueing
com_android_server_input_InputManagerService.cpp
/* 调用phonewindowmanager.java中的同名函数，返回一个wmActions */
wmActions = env->CallIntMethod(mServiceObj, gServiceClassInfo.interceptKeyBeforeQueueing, keyEventObj, policyFlags);
{//interceptKeyBeforeQueueing  PhoneWindowManager.java
(frameworks\base\policy\src\com\android\internal\policy\impl)
/* 如果是global按键，则直接返回ACTION_PASS_TO_USER */
if (mGlobalKeyManager.shouldHandleGlobalKey(keyCode, event))
return result;   //result = ACTION_PASS_TO_USER;

/* 对于systemkey 分类处理 */
可以直接处理的话，处理它，设置返回值 ！ACTION_PASS_TO_USER，不要传给用户否则ACTION_PASS_TO_USER
}

/* 根据返回值，设置policyFlags：POLICY_FLAG_PASS_TO_USER  */
handleInterceptActions(wmActions, when, /*byref*/ policyFlags);
if (wmActions & WM_ACTION_PASS_TO_USER) {
policyFlags |= POLICY_FLAG_PASS_TO_USER;
}

/* 然后放入inbound队列中 */
needWake = enqueueInboundEventLocked(newEntry);

if (needWake) {
mLooper->wake();   //唤醒dispatch线程
}
}

dispatch线程循环体分析

threadLoop() InputDispatcher.cpp
mDispatcher->dispatchOnce();
{
if (!haveCommandsLocked())    //没有命令则从inbound队列中取出事件，生成命令
dispatchOnceInnerLocked(&nextWakeupTime);
{
mPendingEvent = mInboundQueue.dequeueAtHead();   //从inbound队列中取出事件
DropReason dropReason = DROP_REASON_NOT_DROPPED; //默认不丢弃

对于：！POLICY_FLAG_PASS_TO_USER
if (!(mPendingEvent->policyFlags & POLICY_FLAG_PASS_TO_USER))
dropReason = DROP_REASON_POLICY;
switch (mPendingEvent->type)
case EventEntry::TYPE_KEY:
dispatchKeyLocked
{
// Clean up if dropping the event.
if (*dropReason != DROP_REASON_NOT_DROPPED)
return true;    //返回后会不休眠继续执行dispatchOnce，处理下一个输入事件
}

对于：POLICY_FLAG_PASS_TO_USER
switch (mPendingEvent->type)
case EventEntry::TYPE_KEY:
dispatchKeyLocked
{
if (entry->interceptKeyResult == KeyEntry::INTERCEPT_KEY_RESULT_UNKNOWN) {
if (entry->policyFlags & POLICY_FLAG_PASS_TO_USER) {
//构造命令放入队列
CommandEntry* commandEntry = postCommandLocked(                                           &InputDispatcher::doInterceptKeyBeforeDispatchingLockedInterruptible);
if (mFocusedWindowHandle != NULL) {
commandEntry->inputWindowHandle = mFocusedWindowHandle;
}
commandEntry->keyEntry = entry;
entry->refCount += 1;
return false; // wait for the command to run
}
}

/* 如果解析的结果是INTERCEPT_KEY_RESULT_CONTINUE，则寻找目标应用程序 */
int32_t injectionResult = findFocusedWindowTargetsLocked(currentTime, entry, inputTargets, nextWakeupTime);
// Dispatch the key.   然后把事件发给应用程序
dispatchEventLocked(currentTime, entry, inputTargets);
}
}

if (runCommandsLockedInterruptible())  //运行命令
{
/* 取出命令，然后执行命令 */
CommandEntry* commandEntry = mCommandQueue.dequeueAtHead();
//命令即doInterceptKeyBeforeDispatchingLockedInterruptible
Command command = commandEntry->command;
{//doInterceptKeyBeforeDispatchingLockedInterruptible
/* 执行phonewindowmanager.java中的同名函数 */
nsecs_t delay = mPolicy->interceptKeyBeforeDispatching(commandEntry->inputWindowHandle, &event, entry->policyFlags);

{//interceptKeyBeforeDispatching   PhoneWindowManager.java
if (mGlobalKeyManager.handleGlobalKey(mContext, keyCode, event))
{//根据global_key.xml发送广播给某个组件
ComponentName component = mKeyMapping.get(keyCode);
context.sendBroadcastAsUser(intent, UserHandle.CURRENT, null);
}
return -1;
}

/* 根据返回值来设置解析的结果 */
if (delay < 0)   //返回-1， 不上传给app  -- global key      system key
entry->interceptKeyResult = KeyEntry::INTERCEPT_KEY_RESULT_SKIP;
else if (!delay)    //return 0，表示让app处理  -- user key
entry->interceptKeyResult = KeyEntry::INTERCEPT_KEY_RESULT_CONTINUE;
else
entry->interceptKeyResult = KeyEntry::INTERCEPT_KEY_RESULT_TRY_AGAIN_LATER;
entry->interceptKeyWakeupTime = now() + delay;
}
}
nextWakeupTime = LONG_LONG_MIN;
}

分析到此结束，有误的地方还请提出宝贵的意见！

最后再次感谢《深入理解Android 卷III》这本书，通过看这本书我学到了很多东西，同时，书中有很多语言组织的非常好，我就照搬过来了。