您的位置: 首页  >  文章  >  InputManagerService分析一：IMS的启动与事件传递

InputManagerService分析一：IMS的启动与事件传递

分类: 文章 • 2025-04-21 22:16:46

从这一节里面，我们开始介绍InputManagerService部分的知识。它用于管理整个系统的输入部分，包括键盘、鼠标、触摸屏等等。这一章里面我们主要就要介绍IMS。首先从IMS的启动来分析：

[java] view plain copy
  1. HandlerThread wmHandlerThread = new HandlerThread("WindowManager");  
  2. wmHandlerThread.start();  
  3. Handler wmHandler = new Handler(wmHandlerThread.getLooper());    
  4.   
  5.     inputManager = new InputManagerService(context, wmHandler);             
  6.     wm = WindowManagerService.main(context, power, display, inputManager,  
  7.             wmHandler, factoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL,  
  8.             !firstBoot, onlyCore);  
  9.     ServiceManager.addService(Context.WINDOW_SERVICE, wm);  
  10.     ServiceManager.addService(Context.INPUT_SERVICE, inputManager);  
  11.   
  12.     inputManager.setWindowManagerCallbacks(wm.getInputMonitor());  
  13.     inputManager.start();  


因为 在Android系统中，按键事件是由InputManager来收集并由WindowManagerService服务来分发给各个Activity处理的，所以在介绍WMS的启动时，我们也一起来介绍一下InputManager的启动，首先来看InputManagerService的构造函数：

InputManagerService的启动

[java] view plain copy
  1. public InputManagerService(Context context, Handler handler) {  
  2.     this.mContext = context;  
  3.     this.mHandler = new InputManagerHandler(handler.getLooper());  
  4.   
  5.     mUseDevInputEventForAudioJack =  
  6.             context.getResources().getBoolean(R.bool.config_useDevInputEventForAudioJack);  
  7.     mPtr = nativeInit(this, mContext, mHandler.getLooper().getQueue());  
  8. }  
这里首先构造InputManagerHandler用于处理消息，当然这个handle是绑定在"WindowManager"这个looper上的。然后调用nativeInit去完成初natvie层的初始化：
[java] view plain copy
  1. static jint nativeInit(JNIEnv* env, jclass clazz,  
  2.         jobject serviceObj, jobject contextObj, jobject messageQueueObj) {  
  3.     sp<MessageQueue> messageQueue = android_os_MessageQueue_getMessageQueue(env, messageQueueObj);  
  4.   
  5.     NativeInputManager* im = new NativeInputManager(contextObj, serviceObj,  
  6.             messageQueue->getLooper());  
  7.     im->incStrong(0);  
  8.     return reinterpret_cast<jint>(im);  
  9. }  
android_os_MessageQueue_getMessageQueue这个函数我们在介绍Looper的时候已经分析过，因为Java层的MessageQueue总是对应native层的NativeMessageQueue对象，所以首先先取得native层的messageQueue，并构造NativeInputManager对象：
[java] view plain copy
  1. NativeInputManager::NativeInputManager(jobject contextObj,  
  2.         jobject serviceObj, const sp<Looper>& looper) :  
  3.         mLooper(looper) {  
  4.     JNIEnv* env = jniEnv();  
  5.   
  6.     mContextObj = env->NewGlobalRef(contextObj);  
  7.     mServiceObj = env->NewGlobalRef(serviceObj);  
  8.   
  9.     {  
  10.         AutoMutex _l(mLock);  
  11.         mLocked.systemUiVisibility = ASYSTEM_UI_VISIBILITY_STATUS_BAR_VISIBLE;  
  12.         mLocked.pointerSpeed = 0;  
  13.         mLocked.pointerGesturesEnabled = true;  
  14.         mLocked.showTouches = false;  
  15.     }  
  16.   
  17.     sp<EventHub> eventHub = new EventHub();  
  18.     mInputManager = new InputManager(eventHub, this, this);  
  19. }  
上面的InputManagerService的NativeInputManager的类图关系如下：

InputManagerService分析一：IMS的启动与事件传递

在NativeInputManager的构造函数中，首先对mLocked中的一些变量赋初值。然后构造EventHub对象，并通过它最终构造InputManager对象。首先来看EventHub的构造函数：
[java] view plain copy
  1. EventHub::EventHub(void) :  
  2.         mBuiltInKeyboardId(NO_BUILT_IN_KEYBOARD), mNextDeviceId(1), mControllerNumbers(),  
  3.         mOpeningDevices(0), mClosingDevices(0),  
  4.         mNeedToSendFinishedDeviceScan(false),  
  5.         mNeedToReopenDevices(false), mNeedToScanDevices(true),  
  6.         mPendingEventCount(0), mPendingEventIndex(0), mPendingINotify(false) {  
  7.     acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_ID);  
  8.   
  9.     mEpollFd = epoll_create(EPOLL_SIZE_HINT);  
  10.     LOG_ALWAYS_FATAL_IF(mEpollFd < 0, "Could not create epoll instance.  errno=%d", errno);  
  11.   
  12.     mINotifyFd = inotify_init();  
  13.     int result = inotify_add_watch(mINotifyFd, DEVICE_PATH, IN_DELETE | IN_CREATE);  
  14.     LOG_ALWAYS_FATAL_IF(result < 0, "Could not register INotify for %s.  errno=%d",  
  15.             DEVICE_PATH, errno);  
  16.   
  17.     struct epoll_event eventItem;  
  18.     memset(&eventItem, 0, sizeof(eventItem));  
  19.     eventItem.events = EPOLLIN;  
  20.     eventItem.data.u32 = EPOLL_ID_INOTIFY;  
  21.     result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mINotifyFd, &eventItem);  
  22.     LOG_ALWAYS_FATAL_IF(result != 0, "Could not add INotify to epoll instance.  errno=%d", errno);  
  23.   
  24.     int wakeFds[2];  
  25.     result = pipe(wakeFds);  
  26.     LOG_ALWAYS_FATAL_IF(result != 0, "Could not create wake pipe.  errno=%d", errno);  
  27.   
  28.     mWakeReadPipeFd = wakeFds[0];  
  29.     mWakeWritePipeFd = wakeFds[1];  
  30.   
  31.     result = fcntl(mWakeReadPipeFd, F_SETFL, O_NONBLOCK);  
  32.     LOG_ALWAYS_FATAL_IF(result != 0, "Could not make wake read pipe non-blocking.  errno=%d",  
  33.             errno);  
  34.   
  35.     result = fcntl(mWakeWritePipeFd, F_SETFL, O_NONBLOCK);  
  36.     LOG_ALWAYS_FATAL_IF(result != 0, "Could not make wake write pipe non-blocking.  errno=%d",  
  37.             errno);  
  38.   
  39.     eventItem.data.u32 = EPOLL_ID_WAKE;  
  40.     result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mWakeReadPipeFd, &eventItem);  
  41.     LOG_ALWAYS_FATAL_IF(result != 0, "Could not add wake read pipe to epoll instance.  errno=%d",  
  42.             errno);  
  43. }  

首先是对一些成员变量做初始化，这些变量等到我们用到时再来一一介绍。然后调用inotify机制对/dev/input文件目录下的增和删操作做监听，/dev/input目录就是所有的input设备文件。并调用epoll机制EPOLL_CTL_ADD命令对上面的inotify的句柄和mWakeReadPipeFd句柄加入到epoll的句柄mEpollFd中。我们可以看到当有/dev/input下面的增删操作或者在mWakeWritePipeFd中写数据时，epoll_wait将会返回。再来看InputManager的构造函数：

[java] view plain copy
  1. InputManager::InputManager(  
  2.         const sp<EventHubInterface>& eventHub,  
  3.         const sp<InputReaderPolicyInterface>& readerPolicy,  
  4.         const sp<InputDispatcherPolicyInterface>& dispatcherPolicy) {  
  5.     mDispatcher = new InputDispatcher(dispatcherPolicy);  
  6.     mReader = new InputReader(eventHub, readerPolicy, mDispatcher);  
  7.     initialize();  
  8. }  
  9.   
  10. void InputManager::initialize() {  
  11.     mReaderThread = new InputReaderThread(mReader);  
  12.     mDispatcherThread = new InputDispatcherThread(mDispatcher);  
  13. }  

这InputManager的构造函数中首先构造InputDispatcher和InputReader两个对象，然后在initialize构造InputReaderThread和InputDispatcherThread分别用于收按键输入和分发按键消息。InputDispatcher是分发消息的对象，InputReader是从驱动获取按键消息，首先来看一下它们的构造函数：

[java] view plain copy
  1. InputDispatcher::InputDispatcher(const sp<InputDispatcherPolicyInterface>& policy) :  
  2.     mPolicy(policy),  
  3.     mPendingEvent(NULL), mAppSwitchSawKeyDown(false), mAppSwitchDueTime(LONG_LONG_MAX),  
  4.     mNextUnblockedEvent(NULL),  
  5.     mDispatchEnabled(false), mDispatchFrozen(false), mInputFilterEnabled(false),  
  6.     mInputTargetWaitCause(INPUT_TARGET_WAIT_CAUSE_NONE) {  
  7.     mLooper = new Looper(false);  
  8.   
  9.     mKeyRepeatState.lastKeyEntry = NULL;  
  10.   
  11.     policy->getDispatcherConfiguration(&mConfig);  
  12. }  
InputDispatcher的构造函数中首先初始化一些成员变量，然后构造一个Native层的Looper，并通过IMS获取VirtualKeyQuietime和ExcludedDevice系统配置保存到InputDispatcherConfiguration选项。接着来看InputReader的构造函数：
[java] view plain copy
  1. InputReader::InputReader(const sp<EventHubInterface>& eventHub,  
  2.         const sp<InputReaderPolicyInterface>& policy,  
  3.         const sp<InputListenerInterface>& listener) :  
  4.         mContext(this), mEventHub(eventHub), mPolicy(policy),  
  5.         mGlobalMetaState(0), mGeneration(1),  
  6.         mDisableVirtualKeysTimeout(LLONG_MIN), mNextTimeout(LLONG_MAX),  
  7.         mConfigurationChangesToRefresh(0) {  
  8.     mQueuedListener = new QueuedInputListener(listener);  
  9.   
  10.     { // acquire lock  
  11.         AutoMutex _l(mLock);  
  12.   
  13.         refreshConfigurationLocked(0);  
  14.         updateGlobalMetaStateLocked();  
  15.     } // release lock  
  16. }  

这里首先由传入的InputDispatcher构造一个QueuedInputListener并保存在mQueuedListener中。回到InputManager的构造函数中，接着调用initialize构造分别构造InputReaderThread和InputDispatcherThread两个thread。

InputReader和InputDispatcher两个类都比较庞大，我们先来看一下它们的类图：

InputManagerService分析一：IMS的启动与事件传递


再来看一下上面IMS构造过程的流程图：

InputManagerService分析一：IMS的启动与事件传递


到这里InputManagerService的构造函数就介绍完了，回到SystemService中接着调用WMS的main方法，并把前面创建的InputManagerService作为参数传入：
[java] view plain copy
  1. private WindowManagerService(Context context, PowerManagerService pm,  
  2.         DisplayManagerService displayManager, InputManagerService inputManager,  
  3.         boolean haveInputMethods, boolean showBootMsgs, boolean onlyCore) {  
  4.           
  5.     ......  
  6.       
  7.     mInputManager = inputManager; // Must be before createDisplayContentLocked.  
  8.   
  9.     mPointerEventDispatcher = new PointerEventDispatcher(mInputManager.monitorInput(TAG));  
  10.       
  11.     .....  
  12. }  

在WMS的构造函数中，首先在mInputManager中保存InputManagerService对象，然后构造PointerEventDispatcher对用于分析点击事件。首先来看InputManagerService的monitorInput方法：

[java] view plain copy
  1. public InputChannel monitorInput(String inputChannelName) {  
  2.     InputChannel[] inputChannels = InputChannel.openInputChannelPair(inputChannelName);  
  3.     nativeRegisterInputChannel(mPtr, inputChannels[0], null, true);  
  4.     inputChannels[0].dispose(); // don't need to retain the Java object reference  
  5.     return inputChannels[1];  
  6. }  

先来看一下InputChannel的类图结构：


InputManagerService分析一：IMS的启动与事件传递

InputChannel用于从InputDispatcher中后去所有的input消息，所以这里构造一对InputChannel，一个注册到底层的InputDispatcher中，一个用于PointerEventDispatcher给activity分发消息。先来看InputChannel的openInputChannelPair函数：
[java] view plain copy
  1.     public static InputChannel[] openInputChannelPair(String name) {  
  2.         return nativeOpenInputChannelPair(name);  
  3.     }  
  4.   
  5. static jobjectArray android_view_InputChannel_nativeOpenInputChannelPair(JNIEnv* env,  
  6.         jclass clazz, jstring nameObj) {  
  7.     const char* nameChars = env->GetStringUTFChars(nameObj, NULL);  
  8.     String8 name(nameChars);  
  9.     env->ReleaseStringUTFChars(nameObj, nameChars);  
  10.   
  11.     sp<InputChannel> serverChannel;  
  12.     sp<InputChannel> clientChannel;  
  13.     status_t result = InputChannel::openInputChannelPair(name, serverChannel, clientChannel);  
  14.   
  15.     if (result) {  
  16.         String8 message;  
  17.         message.appendFormat("Could not open input channel pair.  status=%d", result);  
  18.         jniThrowRuntimeException(env, message.string());  
  19.         return NULL;  
  20.     }  
  21.   
  22.     jobjectArray channelPair = env->NewObjectArray(2, gInputChannelClassInfo.clazz, NULL);  
  23.     if (env->ExceptionCheck()) {  
  24.         return NULL;  
  25.     }  
  26.   
  27.     jobject serverChannelObj = android_view_InputChannel_createInputChannel(env,  
  28.             new NativeInputChannel(serverChannel));  
  29.     if (env->ExceptionCheck()) {  
  30.         return NULL;  
  31.     }  
  32.   
  33.     jobject clientChannelObj = android_view_InputChannel_createInputChannel(env,  
  34.             new NativeInputChannel(clientChannel));  
  35.     if (env->ExceptionCheck()) {  
  36.         return NULL;  
  37.     }  
  38.   
  39.     env->SetObjectArrayElement(channelPair, 0, serverChannelObj);  
  40.     env->SetObjectArrayElement(channelPair, 1, clientChannelObj);  
  41.     return channelPair;  
  42. }  

android_view_InputChannel_nativeOpenInputChannelPair函数首先调用Native层的InputChannel的openInputChannelPair函数创建一对socket，先来看openInputChannelPair的实现：
[cpp] view plain copy
  1. status_t InputChannel::openInputChannelPair(const String8& name,  
  2.         sp<InputChannel>& outServerChannel, sp<InputChannel>& outClientChannel) {  
  3.     int sockets[2];  
  4.     if (socketpair(AF_UNIX, SOCK_SEQPACKET, 0, sockets)) {  
  5.         status_t result = -errno;  
  6.         ALOGE("channel '%s' ~ Could not create socket pair.  errno=%d",  
  7.                 name.string(), errno);  
  8.         outServerChannel.clear();  
  9.         outClientChannel.clear();  
  10.         return result;  
  11.     }  
  12.   
  13.     int bufferSize = SOCKET_BUFFER_SIZE;  
  14.     setsockopt(sockets[0], SOL_SOCKET, SO_SNDBUF, &bufferSize, sizeof(bufferSize));  
  15.     setsockopt(sockets[0], SOL_SOCKET, SO_RCVBUF, &bufferSize, sizeof(bufferSize));  
  16.     setsockopt(sockets[1], SOL_SOCKET, SO_SNDBUF, &bufferSize, sizeof(bufferSize));  
  17.     setsockopt(sockets[1], SOL_SOCKET, SO_RCVBUF, &bufferSize, sizeof(bufferSize));  
  18.   
  19.     String8 serverChannelName = name;  
  20.     serverChannelName.append(" (server)");  
  21.     outServerChannel = new InputChannel(serverChannelName, sockets[0]);  
  22.   
  23.     String8 clientChannelName = name;  
  24.     clientChannelName.append(" (client)");  
  25.     outClientChannel = new InputChannel(clientChannelName, sockets[1]);  
  26.     return OK;  
  27. }  
上面的代码比较简单，首先创建一对未命名、相互连接的UNIX域套接字，然后分别通过Fd分别构造两个Native层的InputChannel代表server和client端。在android_view_InputChannel_nativeOpenInputChannelPair函数中把Native层的InputChannel和Java层的InputChannel通过NativeInputChannel相互绑定起来。

回到InputManagerService的monitorInput方法中，InputChannel的openInputChannelPair返回一对InputChannel对象，其中index为0的代表server端，index为1的代表client端。接着调用nativeRegisterInputChannel把InputChannel[0]到InputDispatcher，用于从InputDispatcher获取触摸事件：

[cpp] view plain copy
  1. static void nativeRegisterInputChannel(JNIEnv* env, jclass clazz,  
  2.         jint ptr, jobject inputChannelObj, jobject inputWindowHandleObj, jboolean monitor) {  
  3.     NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);  
  4.   
  5.     sp<InputChannel> inputChannel = android_view_InputChannel_getInputChannel(env,  
  6.             inputChannelObj);  
  7.     if (inputChannel == NULL) {  
  8.         throwInputChannelNotInitialized(env);  
  9.         return;  
  10.     }  
  11.   
  12.     sp<InputWindowHandle> inputWindowHandle =  
  13.             android_server_InputWindowHandle_getHandle(env, inputWindowHandleObj);  
  14.   
  15.     status_t status = im->registerInputChannel(  
  16.             env, inputChannel, inputWindowHandle, monitor);  
  17.     if (status) {  
  18.     }  
  19. }  
  20.   
  21. status_t NativeInputManager::registerInputChannel(JNIEnv* env,  
  22.         const sp<InputChannel>& inputChannel,  
  23.         const sp<InputWindowHandle>& inputWindowHandle, bool monitor) {  
  24.     return mInputManager->getDispatcher()->registerInputChannel(  
  25.             inputChannel, inputWindowHandle, monitor);  
  26. }  
nativeRegisterInputChannel首先通过Java层的InputChannel对象获取到Native层的InputChannel对象，然后调用NativeInputManager的registerInputChannel方法，因为当前没有设置inputWindowhandler，所以这里的InputWindowHandler为NULL：

[cpp] view plain copy
  1. status_t InputDispatcher::registerInputChannel(const sp<InputChannel>& inputChannel,  
  2.         const sp<InputWindowHandle>& inputWindowHandle, bool monitor) {  
  3.     { // acquire lock  
  4.         AutoMutex _l(mLock);  
  5.   
  6.         if (getConnectionIndexLocked(inputChannel) >= 0) {  
  7.             ALOGW("Attempted to register already registered input channel '%s'",  
  8.                     inputChannel->getName().string());  
  9.             return BAD_VALUE;  
  10.         }  
  11.   
  12.         sp<Connection> connection = new Connection(inputChannel, inputWindowHandle, monitor);  
  13.   
  14.         int fd = inputChannel->getFd();  
  15.         mConnectionsByFd.add(fd, connection);  
  16.   
  17.         if (monitor) {  
  18.             mMonitoringChannels.push(inputChannel);  
  19.         }  
  20.   
  21.         mLooper->addFd(fd, 0, ALOOPER_EVENT_INPUT, handleReceiveCallback, this);  
  22.     } // release lock  
  23.   
  24.     // Wake the looper because some connections have changed.  
  25.     mLooper->wake();  
  26.     return OK;  
  27. }  
registerInputChannel首先构造Connection对象表示一个连接，然后把它加入到mConnectionsByFd中，并根据当前inputChannel是否需要monitor加入到mMonitoringChannels，并最终把inputChannel所代表的fd值加入到Looper的mEpollFd中。

最后因为在Java层不再需要Native层的inputChannels[0]引用，所以调用inputChannels[0]的dispose方法用于释放Java层对Native层的inputChannels[0]的引用。最后来看WMS中的PointerEventDispatcher构造函数：

[java] view plain copy
  1. public PointerEventDispatcher(InputChannel inputChannel) {  
  2.     super(inputChannel, UiThread.getHandler().getLooper());  
  3. }  
  4.   
  5. public InputEventReceiver(InputChannel inputChannel, Looper looper) {  
  6.     if (inputChannel == null) {  
  7.         throw new IllegalArgumentException("inputChannel must not be null");  
  8.     }  
  9.     if (looper == null) {  
  10.         throw new IllegalArgumentException("looper must not be null");  
  11.     }  
  12.   
  13.     mInputChannel = inputChannel;  
  14.     mMessageQueue = looper.getQueue();  
  15.     mReceiverPtr = nativeInit(new WeakReference<InputEventReceiver>(this),  
  16.             inputChannel, mMessageQueue);  
  17.   
  18.     mCloseGuard.open("dispose");  
  19. }  

传入的参数为前面创造的inputChannel[1]；UiThread为管理UI的一个单例Thread。这里主要调用nativeInit方法：

[java] view plain copy
  1. static jint nativeInit(JNIEnv* env, jclass clazz, jobject receiverWeak,  
  2.         jobject inputChannelObj, jobject messageQueueObj) {  
  3.     sp<InputChannel> inputChannel = android_view_InputChannel_getInputChannel(env,  
  4.             inputChannelObj);  
  5.     if (inputChannel == NULL) {  
  6.         jniThrowRuntimeException(env, "InputChannel is not initialized.");  
  7.         return 0;  
  8.     }  
  9.   
  10.     sp<MessageQueue> messageQueue = android_os_MessageQueue_getMessageQueue(env, messageQueueObj);  
  11.     if (messageQueue == NULL) {  
  12.         jniThrowRuntimeException(env, "MessageQueue is not initialized.");  
  13.         return 0;  
  14.     }  
  15.   
  16.     sp<NativeInputEventReceiver> receiver = new NativeInputEventReceiver(env,  
  17.             receiverWeak, inputChannel, messageQueue);  
  18.     status_t status = receiver->initialize();  
  19.     if (status) {  
  20.   
  21.     }  
  22.   
  23.     receiver->incStrong(gInputEventReceiverClassInfo.clazz); // retain a reference for the object  
  24.     return reinterpret_cast<jint>(receiver.get());  
  25. }  
nativeInit函数首先获取Java层传入的InputChannel和MessageQueue对象，然后构造NativeInputEventReceiver对象并调用它的initialize方法将InputChannel[1]与UiThread的looper绑定起来：

[cpp] view plain copy
  1. NativeInputEventReceiver::NativeInputEventReceiver(JNIEnv* env,  
  2.         jobject receiverWeak, const sp<InputChannel>& inputChannel,  
  3.         const sp<MessageQueue>& messageQueue) :  
  4.         mReceiverWeakGlobal(env->NewGlobalRef(receiverWeak)),  
  5.         mInputConsumer(inputChannel), mMessageQueue(messageQueue),  
  6.         mBatchedInputEventPending(false), mFdEvents(0) {  
  7. }  
  8.   
  9. status_t NativeInputEventReceiver::initialize() {  
  10.     setFdEvents(ALOOPER_EVENT_INPUT);  
  11.     return OK;  
  12. }  
  13.   
  14. void NativeInputEventReceiver::setFdEvents(int events) {  
  15.     if (mFdEvents != events) {  
  16.         mFdEvents = events;  
  17.         int fd = mInputConsumer.getChannel()->getFd();  
  18.         if (events) {  
  19.             mMessageQueue->getLooper()->addFd(fd, 0, events, this, NULL);  
  20.         } else {  
  21.             mMessageQueue->getLooper()->removeFd(fd);  
  22.         }  
  23.     }  
  24. }  
下面是以上介绍PointerEventDispatcher注册InputChannel到InputDispatch的流程图：


InputManagerService分析一：IMS的启动与事件传递

回到systemServer当中，接着调用inputManager.setWindowManagerCallbacks(wm.getInputMonitor())方法用于想WMS通知InputManager的状态变化以及错误通知。最后在systemServer中调用inputManager.start()方法让InputManagerService启动：

[java] view plain copy
  1. public void start() {  
  2.     Slog.i(TAG, "Starting input manager");  
  3.     nativeStart(mPtr);  
  4.   
  5.     // Add ourself to the Watchdog monitors.  
  6.     Watchdog.getInstance().addMonitor(this);  
  7.   
  8.     registerPointerSpeedSettingObserver();  
  9.     registerShowTouchesSettingObserver();  
  10.   
  11.     mContext.registerReceiver(new BroadcastReceiver() {  
  12.         @Override  
  13.         public void onReceive(Context context, Intent intent) {  
  14.             updatePointerSpeedFromSettings();  
  15.             updateShowTouchesFromSettings();  
  16.         }  
  17.     }, new IntentFilter(Intent.ACTION_USER_SWITCHED), null, mHandler);  
  18.   
  19.     updatePointerSpeedFromSettings();  
  20.     updateShowTouchesFromSettings();  
  21. }  

首先调用nativeStart让Native层的InputManager启动：

[cpp] view plain copy
  1. status_t InputManager::start() {  
  2.     status_t result = mDispatcherThread->run("InputDispatcher", PRIORITY_URGENT_DISPLAY);  
  3.     if (result) {  
  4.         ALOGE("Could not start InputDispatcher thread due to error %d.", result);  
  5.         return result;  
  6.     }  
  7.   
  8.     result = mReaderThread->run("InputReader", PRIORITY_URGENT_DISPLAY);  
  9.     if (result) {  
  10.         ALOGE("Could not start InputReader thread due to error %d.", result);  
  11.   
  12.         mDispatcherThread->requestExit();  
  13.         return result;  
  14.     }  
  15.   
  16.     return OK;  
  17. }  

InputManager的start方法让在initialize函数中创建的两个thread跑起来，我们首先来看InputDispatcherThread的threadLoop方法：

[cpp] view plain copy
  1. bool InputDispatcherThread::threadLoop() {  
  2.     mDispatcher->dispatchOnce();  
  3.     return true;  
  4. }  
  5.   
  6. void InputDispatcher::dispatchOnce() {  
  7.     nsecs_t nextWakeupTime = LONG_LONG_MAX;  
  8.     { // acquire lock  
  9.         AutoMutex _l(mLock);  
  10.         mDispatcherIsAliveCondition.broadcast();  
  11.   
  12.         // Run a dispatch loop if there are no pending commands.  
  13.         // The dispatch loop might enqueue commands to run afterwards.  
  14.         if (!haveCommandsLocked()) {  
  15.             dispatchOnceInnerLocked(&nextWakeupTime);  
  16.         }  
  17.   
  18.         // Run all pending commands if there are any.  
  19.         // If any commands were run then force the next poll to wake up immediately.  
  20.         if (runCommandsLockedInterruptible()) {  
  21.             nextWakeupTime = LONG_LONG_MIN;  
  22.         }  
  23.     } // release lock  
  24.   
  25.     // Wait for callback or timeout or wake.  (make sure we round up, not down)  
  26.     nsecs_t currentTime = now();  
  27.     int timeoutMillis = toMillisecondTimeoutDelay(currentTime, nextWakeupTime);  
  28.     mLooper->pollOnce(timeoutMillis);  
  29. }  

dispatchOnce处理函数中，首先检查是否有缓存的命令未执行，如果有，就先执行这些命令；如果没有，就调用dispatchOnceInnerLocked方法去检查是否有新的input事件发生，如果有则分发，我们后面再来分析dispatchOnceInnerLocked函数。这里是第一次启动，所以InputDispatcherThread的threadLoop方法调用Looper的pollOnce陷入等待。

接着在InputManager的start方法中启动InputReaderThread：

[cpp] view plain copy
  1. bool InputReaderThread::threadLoop() {  
  2.     mReader->loopOnce();  
  3.     return true;  
  4. }  
  5.   
  6. void InputReader::loopOnce() {  
  7.     int32_t oldGeneration;  
  8.     int32_t timeoutMillis;  
  9.     bool inputDevicesChanged = false;  
  10.     Vector<InputDeviceInfo> inputDevices;  
  11.     { // acquire lock  
  12.         AutoMutex _l(mLock);  
  13.   
  14.         oldGeneration = mGeneration;  
  15.         timeoutMillis = -1;  
  16.   
  17.         uint32_t changes = mConfigurationChangesToRefresh;  
  18.         if (changes) {  
  19.             mConfigurationChangesToRefresh = 0;  
  20.             timeoutMillis = 0;  
  21.             refreshConfigurationLocked(changes);  
  22.         } else if (mNextTimeout != LLONG_MAX) {  
  23.             nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);  
  24.             timeoutMillis = toMillisecondTimeoutDelay(now, mNextTimeout);  
  25.         }  
  26.     } // release lock  
  27.   
  28.     size_t count = mEventHub->getEvents(timeoutMillis, mEventBuffer, EVENT_BUFFER_SIZE);  
  29.   
  30.     { // acquire lock  
  31.         AutoMutex _l(mLock);  
  32.         mReaderIsAliveCondition.broadcast();  
  33.   
  34.         if (count) {  
  35.             processEventsLocked(mEventBuffer, count);  
  36.         }  
  37.   
  38.         if (mNextTimeout != LLONG_MAX) {  
  39.             nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);  
  40.             if (now >= mNextTimeout) {  
  41. #if DEBUG_RAW_EVENTS  
  42.                 ALOGD("Timeout expired, latency=%0.3fms", (now - mNextTimeout) * 0.000001f);  
  43. #endif  
  44.                 mNextTimeout = LLONG_MAX;  
  45.                 timeoutExpiredLocked(now);  
  46.             }  
  47.         }  
  48.   
  49.         if (oldGeneration != mGeneration) {  
  50.             inputDevicesChanged = true;  
  51.             getInputDevicesLocked(inputDevices);  
  52.         }  
  53.     } // release lock  
  54.   
  55.     // Send out a message that the describes the changed input devices.  
  56.     if (inputDevicesChanged) {  
  57.         mPolicy->notifyInputDevicesChanged(inputDevices);  
  58.     }  
  59.   
  60.     mQueuedListener->flush();  
  61. }  
InputReader的loopOnce方法调用EventHub的getEvents方法获取一个input事件，并保存在RawEvent数组中，如果RawEvent事件的数目大于0，则调用processEventsLocked去处理这些事件。我们先来看EventHub的getEvents方法，这个函数比较长，我们分段来分析：

[cpp] view plain copy
  1. size_t EventHub::getEvents(int timeoutMillis, RawEvent* buffer, size_t bufferSize) {  
  2.     ALOG_ASSERT(bufferSize >= 1);  
  3.   
  4.     AutoMutex _l(mLock);  
  5.   
  6.     struct input_event readBuffer[bufferSize];  
  7.   
  8.     RawEvent* event = buffer;  
  9.     size_t capacity = bufferSize;  
  10.     bool awoken = false;  
  11.     for (;;) {  
  12.         nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);  
  13.   
  14.         // 重新reopen所有的input device  
  15.         if (mNeedToReopenDevices) {  
  16.   
  17.         }  
  18.   
  19.         // 处理要关闭的input device  
  20.         while (mClosingDevices) {  
  21.   
  22.         }  
  23.   
  24.         if (mNeedToScanDevices) {  
  25.             mNeedToScanDevices = false;  
  26.             scanDevicesLocked();  
  27.             mNeedToSendFinishedDeviceScan = true;  
  28.         }  

在getEvents函数中，首先检查是否要重新reopen所有的input device设备，然后检查是否有待关闭的input设备。如果这是第一次调用getEvents函数，则需要调用scanDevicesLocked函数去扫描/dev/input目录下的设备文件并打开这些设备：

[cpp] view plain copy
  1. void EventHub::scanDevicesLocked() {  
  2.     status_t res = scanDirLocked(DEVICE_PATH);  
  3.     if(res < 0) {  
  4.         ALOGE("scan dir failed for %s\n", DEVICE_PATH);  
  5.     }  
  6.     if (mDevices.indexOfKey(VIRTUAL_KEYBOARD_ID) < 0) {  
  7.         createVirtualKeyboardLocked();  
  8.     }  
  9. }  
  10.   
  11. status_t EventHub::scanDirLocked(const char *dirname)  
  12. {  
  13.     char devname[PATH_MAX];  
  14.     char *filename;  
  15.     DIR *dir;  
  16.     struct dirent *de;  
  17.     dir = opendir(dirname);  
  18.     if(dir == NULL)  
  19.         return -1;  
  20.     strcpy(devname, dirname);  
  21.     filename = devname + strlen(devname);  
  22.     *filename++ = '/';  
  23.     while((de = readdir(dir))) {  
  24.         if(de->d_name[0] == '.' &&  
  25.            (de->d_name[1] == '\0' ||  
  26.             (de->d_name[1] == '.' && de->d_name[2] == '\0')))  
  27.             continue;  
  28.         strcpy(filename, de->d_name);  
  29.         openDeviceLocked(devname);  
  30.     }  
  31.     closedir(dir);  
  32.     return 0;  
  33. }  

scanDirLocked函数依次调用openDeviceLocked函数去打开/dev/input下面的文件：

[cpp] view plain copy
  1. status_t EventHub::openDeviceLocked(const char *devicePath) {  
  2.     char buffer[80];  
  3.   
  4.     ALOGV("Opening device: %s", devicePath);  
  5.   
  6.     int fd = open(devicePath, O_RDWR | O_CLOEXEC);  
  7.     if(fd < 0) {  
  8.         ALOGE("could not open %s, %s\n", devicePath, strerror(errno));  
  9.         return -1;  
  10.     }  
  11.   
  12.     InputDeviceIdentifier identifier;  
  13.   
  14.     // Get device name.  
  15.     if(ioctl(fd, EVIOCGNAME(sizeof(buffer) - 1), &buffer) < 1) {  
  16.   
  17.     } else {  
  18.         buffer[sizeof(buffer) - 1] = '\0';  
  19.         identifier.name.setTo(buffer);  
  20.     }  
  21.   
  22.     // Check to see if the device is on our excluded list  
  23.     for (size_t i = 0; i < mExcludedDevices.size(); i++) {  
  24.         const String8& item = mExcludedDevices.itemAt(i);  
  25.         if (identifier.name == item) {  
  26.   
  27.         }  
  28.     }  
  29.   
  30.     // Get device driver version.  
  31.     int driverVersion;  
  32.     if(ioctl(fd, EVIOCGVERSION, &driverVersion)) {  
  33.     }  
  34.   
  35.     // Get device identifier.  
  36.     struct input_id inputId;  
  37.     if(ioctl(fd, EVIOCGID, &inputId)) {  
  38.     }  
  39.     identifier.bus = inputId.bustype;  
  40.     identifier.product = inputId.product;  
  41.     identifier.vendor = inputId.vendor;  
  42.     identifier.version = inputId.version;  
  43.   
  44.     // Get device physical location.  
  45.     if(ioctl(fd, EVIOCGPHYS(sizeof(buffer) - 1), &buffer) < 1) {  
  46.       
  47.     } else {  
  48.         buffer[sizeof(buffer) - 1] = '\0';  
  49.         identifier.location.setTo(buffer);  
  50.     }  
  51.   
  52.     // Get device unique id.  
  53.     if(ioctl(fd, EVIOCGUNIQ(sizeof(buffer) - 1), &buffer) < 1) {  
  54.   
  55.     } else {  
  56.         buffer[sizeof(buffer) - 1] = '\0';  
  57.         identifier.uniqueId.setTo(buffer);  
  58.     }  
  59.   
  60.     // Fill in the descriptor.  
  61.     setDescriptor(identifier);  
  62.   
  63.     // Make file descriptor non-blocking for use with poll().  
  64.     if (fcntl(fd, F_SETFL, O_NONBLOCK)) {  
  65.   
  66.     }  
  67.   
  68.     int32_t deviceId = mNextDeviceId++;  
  69.     Device* device = new Device(fd, deviceId, String8(devicePath), identifier);  
  70.   
  71.     // Load the configuration file for the device.  
  72.     loadConfigurationLocked(device);  
  73.   
  74.     .......  
  75.       
  76.     if ((device->classes & INPUT_DEVICE_CLASS_TOUCH)) {  
  77.         status_t status = loadVirtualKeyMapLocked(device);  
  78.         if (!status) {  
  79.             device->classes |= INPUT_DEVICE_CLASS_KEYBOARD;  
  80.         }  
  81.     }  
  82.     status_t keyMapStatus = NAME_NOT_FOUND;  
  83.     if (device->classes & (INPUT_DEVICE_CLASS_KEYBOARD | INPUT_DEVICE_CLASS_JOYSTICK)) {  
  84.         // Load the keymap for the device.  
  85.         keyMapStatus = loadKeyMapLocked(device);  
  86.     }  
  87.   
  88.     // Register with epoll.  
  89.     struct epoll_event eventItem;  
  90.     memset(&eventItem, 0, sizeof(eventItem));  
  91.     eventItem.events = EPOLLIN;  
  92.     eventItem.data.u32 = deviceId;  
  93.     if (epoll_ctl(mEpollFd, EPOLL_CTL_ADD, fd, &eventItem)) {  
  94.         ALOGE("Could not add device fd to epoll instance.  errno=%d", errno);  
  95.         delete device;  
  96.         return -1;  
  97.     }  
  98.   
  99.     bool usingSuspendBlockIoctl = !ioctl(fd, EVIOCSSUSPENDBLOCK, 1);  
  100.   
  101.     int clockId = CLOCK_MONOTONIC;  
  102.     bool usingClockIoctl = !ioctl(fd, EVIOCSCLOCKID, &clockId);  
  103.   
  104.     addDeviceLocked(device);  
  105.     return 0;  
  106. }  

首先打开/dev/input/**文件，然后通过ioctl获取这个input设备的信息，并构造一个Device对象来表示它。然后调用loadConfigurationLocked去加载这个设备的 idc(Input Device Configuration)配置文件（一般情况下会不存在idc文件），查找idc文件的顺序是：

/system/usr/idc/Vendor_XXXX_Product_XXXX_Version_XXXX.idc
/data/system/devices/idc/Vendor_XXXX_Product_XXXX_Version_XXXX.idc
/system/usr/idc/Vendor_XXXX_Product_XXXX.idc
/data/system/devices/idc/Vendor_XXXX_Product_XXXX.idc
/system/usr/idc/Device_Name.idc
/data/system/devices/idc/Device_Name.idc

如果在上面的目录中找到对象的idc文件，则调用PropertyMap将它加载并保存在Device的configuration成员中。接着在openDeviceLocked根据input设备的不同类型分别调用不同的case来加载设备相关的文件：例如对于touch设备，调用loadVirtualKeyMapLocked去加载虚拟keyMap；对于keyboard调用loadKeyMapLocked函数加载它的keyMap，这里调用KeyMapd对象的load方法去加载：

[cpp] view plain copy
  1. status_t KeyMap::load(const InputDeviceIdentifier& deviceIdenfifier,  
  2.         const PropertyMap* deviceConfiguration) {  
  3.     if (deviceConfiguration) {  
  4.   
  5.     }  
  6.   
  7.     // Try searching by device identifier.  
  8.     if (probeKeyMap(deviceIdenfifier, String8::empty())) {  
  9.         return OK;  
  10.     }  
  11.   
  12.     // Fall back on the Generic key map.  
  13.     // TODO Apply some additional heuristics here to figure out what kind of  
  14.     //      generic key map to use (US English, etc.) for typical external keyboards.  
  15.     if (probeKeyMap(deviceIdenfifier, String8("Generic"))) {  
  16.         return OK;  
  17.     }  
  18.   
  19.     // Try the Virtual key map as a last resort.  
  20.     if (probeKeyMap(deviceIdenfifier, String8("Virtual"))) {  
  21.         return OK;  
  22.     }  
  23.   
  24.     // Give up!  
  25.     ALOGE("Could not determine key map for device '%s' and no default key maps were found!",  
  26.             deviceIdenfifier.name.string());  
  27.     return NAME_NOT_FOUND;  
  28. }  

在load函数中，首先尝试使用idc文件中的"keyboard.layout"和"keyboard.characterMap"两个选项去加载keyboard的layout和characterMap文件。如果没有idc文件，则调用probeKeyMap函数分别从下面几个目录查找keyboard的layout和characterMap文件，查找layout文件的顺序如下：

/system/usr/keylayout/Vendor_XXXX_Product_XXXX_Version_XXXX.kl
/data/system/devices/keylayout/Vendor_XXXX_Product_XXXX_Version_XXXX.kl
/system/usr/keylayout/Vendor_XXXX_Product_XXXX.kl
/data/system/devices/keylayout/Vendor_XXXX_Product_XXXX.kl
/system/usr/keylayout/DEVICE_NAME.kl
/data/system/devices/keylayout/DEVICE_NAME.kl
/system/usr/keylayout/Generic.kl
/data/system/devices/keylayout/Generic.kl
/system/usr/keylayout/Virtual.kl
/data/system/devices/keylayout/Virtual.kl

查找characterMap文件的顺序如下：

/system/usr/keychars/Vendor_XXXX_Product_XXXX_Version_XXXX.kcm
/data/system/devices/keychars/Vendor_XXXX_Product_XXXX_Version_XXXX.kcm
/system/usr/keychars/Vendor_XXXX_Product_XXXX.kcm
/data/system/devices/keychars/Vendor_XXXX_Product_XXXX.kcm
/system/usr/keychars/DEVICE_NAME.kcm
/data/system/devices/keychars/DEVICE_NAME.kcm
/system/usr/keychars/Generic.kcm
/data/system/devices/keychars/Generic.kcm
/system/usr/keychars/Virtual.kcm
/data/system/devices/keychars/Virtual.kcm

其中，*.kl文件用于描述Linux scan code到按键的标签的映射关系；*.kcm文件用于描述在shift、caps lock、ctrl以及alt同时按下时的关系。回到openDeviceLocked函数中，通过epoll_ctl把刚打开的input设备的fd加入到mEpollFd中，用于在epoll_wait中等待对应input设备的事件发生。最后调用addDeviceLocked将Device对象加入到mDevices数组和mOpeningDevices中：
[cpp] view plain copy
  1. void EventHub::addDeviceLocked(Device* device) {  
  2.     mDevices.add(device->id, device);  
  3.     device->next = mOpeningDevices;  
  4.     mOpeningDevices = device;  
  5. }  

接着来看scanDevicesLocked函数中，mDevices.indexOfKey(VIRTUAL_KEYBOARD_ID)这句代码用于判断当前设备列表中是否存在虚拟键盘，如果不存在，则调用createVirtualKeyboardLocked去创建一个：

[cpp] view plain copy
  1. void EventHub::createVirtualKeyboardLocked() {  
  2.     InputDeviceIdentifier identifier;  
  3.     identifier.name = "Virtual";  
  4.     identifier.uniqueId = "<virtual>";  
  5.     setDescriptor(identifier);  
  6.   
  7.     Device* device = new Device(-1, VIRTUAL_KEYBOARD_ID, String8("<virtual>"), identifier);  
  8.     device->classes = INPUT_DEVICE_CLASS_KEYBOARD  
  9.             | INPUT_DEVICE_CLASS_ALPHAKEY  
  10.             | INPUT_DEVICE_CLASS_DPAD  
  11.             | INPUT_DEVICE_CLASS_VIRTUAL;  
  12.     loadKeyMapLocked(device);  
  13.     addDeviceLocked(device);  
  14. }  

这时回到getEvents函数中，mDevices和mOpeningDevices至少存在两个input设备了，一个是触摸屏，另一个是虚拟键盘。接着往下看getEvents函数：

[cpp] view plain copy
  1.         while (mOpeningDevices != NULL) {  
  2.             Device* device = mOpeningDevices;  
  3.             ALOGV("Reporting device opened: id=%d, name=%s\n",  
  4.                  device->id, device->path.string());  
  5.             mOpeningDevices = device->next;  
  6.             event->when = now;  
  7.             event->deviceId = device->id == mBuiltInKeyboardId ? 0 : device->id;  
  8.             event->type = DEVICE_ADDED;  
  9.             event += 1;  
  10.             mNeedToSendFinishedDeviceScan = true;  
  11.             if (--capacity == 0) {  
  12.                 break;  
  13.             }  
  14.         }  
  15.   
  16.         if (mNeedToSendFinishedDeviceScan) {  
  17.             mNeedToSendFinishedDeviceScan = false;  
  18.             event->when = now;  
  19.             event->type = FINISHED_DEVICE_SCAN;  
  20.             event += 1;  
  21.             if (--capacity == 0) {  
  22.                 break;  
  23.             }  
  24.         }  
  25.   
  26.         // Grab the next input event.  
  27.         bool deviceChanged = false;  
  28.         while (mPendingEventIndex < mPendingEventCount) {  
  29.             const struct epoll_event& eventItem = mPendingEventItems[mPendingEventIndex++];  
  30.             if (eventItem.data.u32 == EPOLL_ID_INOTIFY) {  
  31.                 if (eventItem.events & EPOLLIN) {  //在/dev/input目录下有delete、add的inotify  
  32.                     mPendingINotify = true;  
  33.                 } else {  
  34.                 }  
  35.                 continue;  
  36.             }  
  37.   
  38.             if (eventItem.data.u32 == EPOLL_ID_WAKE) {  
  39.                 if (eventItem.events & EPOLLIN) {  
  40.                     ALOGV("awoken after wake()");  
  41.                     awoken = true;  
  42.                     char buffer[16];  
  43.                     ssize_t nRead;  
  44.                     do {  
  45.                         nRead = read(mWakeReadPipeFd, buffer, sizeof(buffer));  
  46.                     } while ((nRead == -1 && errno == EINTR) || nRead == sizeof(buffer));  
  47.                 } else {  
  48.                     ALOGW("Received unexpected epoll event 0x%08x for wake read pipe.",  
  49.                             eventItem.events);  
  50.                 }  
  51.                 continue;  
  52.             }  
  53.   
  54.             ssize_t deviceIndex = mDevices.indexOfKey(eventItem.data.u32);  
  55.             if (deviceIndex < 0) {  
  56.   
  57.             }  
  58.   
  59.             Device* device = mDevices.valueAt(deviceIndex);  
  60.             if (eventItem.events & EPOLLIN) {  
  61.                 int32_t readSize = read(device->fd, readBuffer,  
  62.                         sizeof(struct input_event) * capacity);  
  63.                 if (readSize == 0 || (readSize < 0 && errno == ENODEV)) {  
  64.   
  65.                 } else if (readSize < 0) {  
  66.     
  67.                 } else if ((readSize % sizeof(struct input_event)) != 0) {  
  68.                     ALOGE("could not get event (wrong size: %d)", readSize);  
  69.                 } else {  
  70.                     int32_t deviceId = device->id == mBuiltInKeyboardId ? 0 : device->id;  
  71.   
  72.                     size_t count = size_t(readSize) / sizeof(struct input_event);  
  73.                     for (size_t i = 0; i < count; i++) {  
  74.                         struct input_event& iev = readBuffer[i];  
  75.                         if (iev.type == EV_MSC) {  
  76.                             if (iev.code == MSC_ANDROID_TIME_SEC) {  
  77.                                 device->timestampOverrideSec = iev.value;  
  78.                                 continue;  
  79.                             } else if (iev.code == MSC_ANDROID_TIME_USEC) {  
  80.                                 device->timestampOverrideUsec = iev.value;  
  81.                                 continue;  
  82.                             }  
  83.                         }  
  84.                         if (device->timestampOverrideSec || device->timestampOverrideUsec) {  
  85.                             iev.time.tv_sec = device->timestampOverrideSec;  
  86.                             iev.time.tv_usec = device->timestampOverrideUsec;  
  87.                             if (iev.type == EV_SYN && iev.code == SYN_REPORT) {  
  88.                                 device->timestampOverrideSec = 0;  
  89.                                 device->timestampOverrideUsec = 0;  
  90.                             }  
  91.                             ALOGV("applied override time %d.%06d",  
  92.                                     int(iev.time.tv_sec), int(iev.time.tv_usec));  
  93.                         }  
  94.   
  95. #ifdef HAVE_POSIX_CLOCKS  
  96.   
  97. #else  
  98.                         event->when = now;  
  99. #endif  
  100.                         event->deviceId = deviceId;  
  101.                         event->type = iev.type;  
  102.                         event->code = iev.code;  
  103.                         event->value = iev.value;  
  104.                         event += 1;  
  105.                         capacity -= 1;  
  106.                     }  
  107.                     if (capacity == 0) {  
  108.                         mPendingEventIndex -= 1;  
  109.                         break;  
  110.                     }  
  111.                 }  
  112.             } else if (eventItem.events & EPOLLHUP) {  
  113.   
  114.             }  
  115.         }  
  116.   
  117.         //处理/dev/input目录下有delete、add的inotify  
  118.         if (mPendingINotify && mPendingEventIndex >= mPendingEventCount) {  
  119.             mPendingINotify = false;  
  120.             readNotifyLocked();  
  121.             deviceChanged = true;  
  122.         }  
  123.   
  124.         if (deviceChanged) {  
  125.             continue;  
  126.         }  
  127.   
  128.         if (event != buffer || awoken) {  
  129.             break;  
  130.         }  
  131.   
  132.         mPendingEventIndex = 0;  
  133.   
  134.         mLock.unlock(); // release lock before poll, must be before release_wake_lock  
  135.         release_wake_lock(WAKE_LOCK_ID);  
  136.   
  137.         int pollResult = epoll_wait(mEpollFd, mPendingEventItems, EPOLL_MAX_EVENTS, timeoutMillis);  
  138.   
  139.         acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_ID);  
  140.         mLock.lock(); // reacquire lock after poll, must be after acquire_wake_lock  
  141.   
  142.         if (pollResult == 0) {  
  143.             // Timed out.  
  144.             mPendingEventCount = 0;  
  145.             break;  
  146.         }  
  147.   
  148.         if (pollResult < 0) {  
  149.   
  150.         } else {  
  151.             mPendingEventCount = size_t(pollResult);  
  152.         }  
  153.     }  
  154.   
  155.     return event - buffer;  
  156. }  

在getEvent的方法中，首先将前面打开的input设备信息添加到RawEvent的buffer当中，并置type是DEVICE_ADDED。然后在RawEvent的buffer的末尾添加type为FINISHED_DEVICE_SCAN的event。因为当前还没有调用epoll_wait等待input事件，所以这里先跳过 while (mPendingEventIndex < mPendingEventCount)这个循环，直接把前面两个DEVICE_ADDED的event和FINISHED_DEVICE_SCAN的event返回给InputReader的loopOnce()方法，它会调用processEventsLocked去处理这些RawEvent：
[cpp] view plain copy
  1. void InputReader::processEventsLocked(const RawEvent* rawEvents, size_t count) {  
  2.     for (const RawEvent* rawEvent = rawEvents; count;) {  
  3.         int32_t type = rawEvent->type;  
  4.         size_t batchSize = 1;  
  5.         if (type < EventHubInterface::FIRST_SYNTHETIC_EVENT) {  
  6.   
  7.         } else {  
  8.             switch (rawEvent->type) {  
  9.             case EventHubInterface::DEVICE_ADDED:  
  10.                 addDeviceLocked(rawEvent->when, rawEvent->deviceId);  
  11.                 break;  
  12.             case EventHubInterface::DEVICE_REMOVED:  
  13.                 removeDeviceLocked(rawEvent->when, rawEvent->deviceId);  
  14.                 break;  
  15.             case EventHubInterface::FINISHED_DEVICE_SCAN:  
  16.                 handleConfigurationChangedLocked(rawEvent->when);  
  17.                 break;  
  18.             default:  
  19.                 ALOG_ASSERT(false); // can't happen  
  20.                 break;  
  21.             }  
  22.         }  
  23.         count -= batchSize;  
  24.         rawEvent += batchSize;  
  25.     }  
  26. }  

首先来看addDeviceLocked函数：
[cpp] view plain copy
  1. void InputReader::addDeviceLocked(nsecs_t when, int32_t deviceId) {  
  2.     ssize_t deviceIndex = mDevices.indexOfKey(deviceId);  
  3.     if (deviceIndex >= 0) {  
  4.         ALOGW("Ignoring spurious device added event for deviceId %d.", deviceId);  
  5.         return;  
  6.     }  
  7.   
  8.     InputDeviceIdentifier identifier = mEventHub->getDeviceIdentifier(deviceId);  
  9.     uint32_t classes = mEventHub->getDeviceClasses(deviceId);  
  10.     int32_t controllerNumber = mEventHub->getDeviceControllerNumber(deviceId);  
  11.   
  12.     InputDevice* device = createDeviceLocked(deviceId, controllerNumber, identifier, classes);  
  13.     device->configure(when, &mConfig, 0);  
  14.     device->reset(when);  
  15.   
  16.     if (device->isIgnored()) {  
  17.         ALOGI("Device added: id=%d, name='%s' (ignored non-input device)", deviceId,  
  18.                 identifier.name.string());  
  19.     } else {  
  20.         ALOGI("Device added: id=%d, name='%s', sources=0x%08x", deviceId,  
  21.                 identifier.name.string(), device->getSources());  
  22.     }  
  23.   
  24.     mDevices.add(deviceId, device);  
  25.     bumpGenerationLocked();  
  26. }  

首先通过mEventHub的获取deviceId所对应的InputDeviceIdentifier、classes、controllerNumber信息，然后调用createDeviceLocked方法构造一个InputDevice对象代表一个input设备：
[cpp] view plain copy
  1. InputDevice* InputReader::createDeviceLocked(int32_t deviceId, int32_t controllerNumber,  
  2.         const InputDeviceIdentifier& identifier, uint32_t classes) {  
  3.     InputDevice* device = new InputDevice(&mContext, deviceId, bumpGenerationLocked(),  
  4.             controllerNumber, identifier, classes);  
  5.   
  6.     // External devices.  
  7.     if (classes & INPUT_DEVICE_CLASS_EXTERNAL) {  
  8.         device->setExternal(true);  
  9.     }  
  10.   
  11.     // Switch-like devices.  
  12.     if (classes & INPUT_DEVICE_CLASS_SWITCH) {  
  13.         device->addMapper(new SwitchInputMapper(device));  
  14.     }  
  15.   
  16.     // Vibrator-like devices.  
  17.     if (classes & INPUT_DEVICE_CLASS_VIBRATOR) {  
  18.         device->addMapper(new VibratorInputMapper(device));  
  19.     }  
  20.   
  21.     // Keyboard-like devices.  
  22.     uint32_t keyboardSource = 0;  
  23.     int32_t keyboardType = AINPUT_KEYBOARD_TYPE_NON_ALPHABETIC;  
  24.     if (classes & INPUT_DEVICE_CLASS_KEYBOARD) {  
  25.         keyboardSource |= AINPUT_SOURCE_KEYBOARD;  
  26.     }  
  27.     if (classes & INPUT_DEVICE_CLASS_ALPHAKEY) {  
  28.         keyboardType = AINPUT_KEYBOARD_TYPE_ALPHABETIC;  
  29.     }  
  30.     if (classes & INPUT_DEVICE_CLASS_DPAD) {  
  31.         keyboardSource |= AINPUT_SOURCE_DPAD;  
  32.     }  
  33.     if (classes & INPUT_DEVICE_CLASS_GAMEPAD) {  
  34.         keyboardSource |= AINPUT_SOURCE_GAMEPAD;  
  35.     }  
  36.   
  37.     if (keyboardSource != 0) {  
  38.         device->addMapper(new KeyboardInputMapper(device, keyboardSource, keyboardType));  
  39.     }  
  40.   
  41.     // Cursor-like devices.  
  42.     if (classes & INPUT_DEVICE_CLASS_CURSOR) {  
  43.         device->addMapper(new CursorInputMapper(device));  
  44.     }  
  45.   
  46.     // Touchscreens and touchpad devices.  
  47.     if (classes & INPUT_DEVICE_CLASS_TOUCH_MT) {  
  48.         device->addMapper(new MultiTouchInputMapper(device));  
  49.     } else if (classes & INPUT_DEVICE_CLASS_TOUCH) {  
  50.         device->addMapper(new SingleTouchInputMapper(device));  
  51.     }  
  52.   
  53.     // Joystick-like devices.  
  54.     if (classes & INPUT_DEVICE_CLASS_JOYSTICK) {  
  55.         device->addMapper(new JoystickInputMapper(device));  
  56.     }  
  57.   
  58.     return device;  
  59. }  

createDeviceLocked方法中首先创建一个InputDevice对象，然后根据input设备的不同属性设置不同的Mapper事件转换器，我们以virtual keyboard和触摸屏为例来分析。首先在virtual keyboard的属性为INPUT_DEVICE_CLASS_KEYBOARD | INPUT_DEVICE_CLASS_ALPHAKEY | INPUT_DEVICE_CLASS_DPAD | INPUT_DEVICE_CLASS_VIRTUAL，通过上面的代码，我们知道会调用device->addMapper(new KeyboardInputMapper(device, keyboardSource, keyboardType))会构建一个 KeyboardInputMapper对象并设置到InputDevice的mMappers成员中，这里的keyboardSource为AINPUT_SOURCE_KEYBOARD | AINPUT_SOURCE_DPAD，keyboardType为AINPUT_KEYBOARD_TYPE_ALPHABETIC：
[cpp] view plain copy
  1. KeyboardInputMapper::KeyboardInputMapper(InputDevice* device,  
  2.         uint32_t source, int32_t keyboardType) :  
  3.         InputMapper(device), mSource(source),  
  4.         mKeyboardType(keyboardType) {  
  5. }  

触摸屏的属性为INPUT_DEVICE_CLASS_TOUCH_MT | INPUT_DEVICE_CLASS_TOUCH，所以会调用到device->addMapper(new MultiTouchInputMapper(device))去构建一个MultiTouchInputMapper对象并设置到InputDevice的mMappers成员中。
mapper转换器是有它的继承关系的，我们先来看一下它的关系图，后面在介绍处理InputEvent的时候再来仔细分析每个mapper的process方法：


InputManagerService分析一：IMS的启动与事件传递

回到addDeviceLocked函数中，接着调用InputDevice的configure和reset方法，并最终把创建的InputDevice添加到mDevices列表中，并增加mGeneration计数。首先来看InputDevice的configure函数：

[cpp] view plain copy
  1. void InputDevice::configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes) {  
  2.     mSources = 0;  
  3.   
  4.     if (!isIgnored()) {  
  5.         if (!changes) { // first time only  
  6.             mContext->getEventHub()->getConfiguration(mId, &mConfiguration);  
  7.         }  
  8.   
  9.         if (!changes || (changes & InputReaderConfiguration::CHANGE_KEYBOARD_LAYOUTS)) {  
  10.             if (!(mClasses & INPUT_DEVICE_CLASS_VIRTUAL)) {  
  11.                 sp<KeyCharacterMap> keyboardLayout =  
  12.                         mContext->getPolicy()->getKeyboardLayoutOverlay(mIdentifier.descriptor);  
  13.                 if (mContext->getEventHub()->setKeyboardLayoutOverlay(mId, keyboardLayout)) {  
  14.                     bumpGeneration();  
  15.                 }  
  16.             }  
  17.         }  
  18.   
  19.         if (!changes || (changes & InputReaderConfiguration::CHANGE_DEVICE_ALIAS)) {  
  20.             if (!(mClasses & INPUT_DEVICE_CLASS_VIRTUAL)) {  
  21.                 String8 alias = mContext->getPolicy()->getDeviceAlias(mIdentifier);  
  22.                 if (mAlias != alias) {  
  23.                     mAlias = alias;  
  24.                     bumpGeneration();  
  25.                 }  
  26.             }  
  27.         }  
  28.   
  29.         size_t numMappers = mMappers.size();  
  30.         for (size_t i = 0; i < numMappers; i++) {  
  31.             InputMapper* mapper = mMappers[i];  
  32.             mapper->configure(when, config, changes);  
  33.             mSources |= mapper->getSources();  
  34.         }  
  35.     }  
  36. }  
因为传入的第三个参数为0，所以这里首先调用EventHub的getConfiguration去获取Input device的idc配置信息。如果设备不是虚拟设备，还需要设置它的layouOverlay和别名，这部分暂时还是实现。我们来看configure的最后一部分，调用mapper转换器的configure方法，为每个mapper转换器做初始化操作，这里主要根据idc文件和input设备的属性来设置mapper的属性。然后调用reset对mapper做重置操作表示设备第一次添加进来，接下来就要正式开始工作了。最后把InputDevice添加到mDevices数组中。
当前面的两个DEVICE_ADDED的event处理完后，接下来就会处理FINISHED_DEVICE_SCAN这个event，我们来看它的处理流程：
[cpp] view plain copy
  1. void InputReader::handleConfigurationChangedLocked(nsecs_t when) {  
  2.     // Reset global meta state because it depends on the list of all configured devices.  
  3.     updateGlobalMetaStateLocked();  
  4.   
  5.     // Enqueue configuration changed.  
  6.     NotifyConfigurationChangedArgs args(when);  
  7.     mQueuedListener->notifyConfigurationChanged(&args);  
  8. }  
我们知道mQueuedListener是通过InputDispatcher构造的，这里主要调用mQueuedListener的notifyConfigurationChanged方法会把NotifyConfigurationChangedArgs保存起来，后面通过QueuedInputListener的flush方法会分发给InputDispatcher。
回到InputReader的loopOnce()方法中，当调用processEventsLocked处理完所有的event后，因为当前input设备信息有变化，所以需要调用mPolicy->notifyInputDevicesChanged去通知NativeInputManager有input设备信息变化，在NativeInputManager的notifyInputDevicesChanged函数中，会根据获取到的InputDeviceInfo构造Java层的InputDevice数组，然后调用IMS的notifyInputDevicesChanged方法来告知Java层这时有新的设备添加进来了。最后调用QueuedInputListener的flush方法通知InputDispatcher有config信息变化：
[cpp] view plain copy
  1. void InputDispatcher::notifyConfigurationChanged(const NotifyConfigurationChangedArgs* args) {  
  2.     bool needWake;  
  3.     { // acquire lock  
  4.         AutoMutex _l(mLock);  
  5.   
  6.         ConfigurationChangedEntry* newEntry = new ConfigurationChangedEntry(args->eventTime);  
  7.         needWake = enqueueInboundEventLocked(newEntry);  
  8.     } // release lock  
  9.   
  10.     if (needWake) {  
  11.         mLooper->wake();  
  12.     }  
  13. }  

enqueueInboundEventLocked将newEntry添加到mInboundQueue中，然后调用Looper的wake方法让pollOnce返回，此时再进入到InputDispatcher的dispatchOnce方法中，这里会调用dispatchOnceInnerLocked去分发事件：
[cpp] view plain copy
  1. void InputDispatcher::dispatchOnceInnerLocked(nsecs_t* nextWakeupTime) {  
  2.     nsecs_t currentTime = now();  
  3.   
  4.     if (!mPolicy->isKeyRepeatEnabled()) {  
  5.         resetKeyRepeatLocked();  
  6.     }  
  7.   
  8.     if (mDispatchFrozen) {  
  9.   
  10.     }  
  11.   
  12.     bool isAppSwitchDue = mAppSwitchDueTime <= currentTime;  
  13.     if (mAppSwitchDueTime < *nextWakeupTime) {  
  14.         *nextWakeupTime = mAppSwitchDueTime;  
  15.     }  
  16.   
  17.     if (! mPendingEvent) {  
  18.         if (mInboundQueue.isEmpty()) {  
  19.   
  20.         } else {  
  21.             mPendingEvent = mInboundQueue.dequeueAtHead();  
  22.             traceInboundQueueLengthLocked();  
  23.         }  
  24.   
  25.         if (mPendingEvent->policyFlags & POLICY_FLAG_PASS_TO_USER) {  
  26.         }  
  27.   
  28.         resetANRTimeoutsLocked();  
  29.     }  
  30.   
  31.     bool done = false;  
  32.     DropReason dropReason = DROP_REASON_NOT_DROPPED;  
  33.     if (!(mPendingEvent->policyFlags & POLICY_FLAG_PASS_TO_USER)) {  
  34.         dropReason = DROP_REASON_POLICY;  
  35.     } else if (!mDispatchEnabled) {  
  36.         dropReason = DROP_REASON_DISABLED;  
  37.     }  
  38.   
  39.     if (mNextUnblockedEvent == mPendingEvent) {  
  40.         mNextUnblockedEvent = NULL;  
  41.     }  
  42.   
  43.     switch (mPendingEvent->type) {  
  44.     case EventEntry::TYPE_CONFIGURATION_CHANGED: {  
  45.         ConfigurationChangedEntry* typedEntry =  
  46.                 static_cast<ConfigurationChangedEntry*>(mPendingEvent);  
  47.         done = dispatchConfigurationChangedLocked(currentTime, typedEntry);  
  48.         dropReason = DROP_REASON_NOT_DROPPED; // configuration changes are never dropped  
  49.         break;  
  50.     }  
  51.   
  52.     }  
  53.   
  54.     if (done) {  
  55.         if (dropReason != DROP_REASON_NOT_DROPPED) {  
  56.             dropInboundEventLocked(mPendingEvent, dropReason);  
  57.         }  
  58.   
  59.         releasePendingEventLocked();  
  60.         *nextWakeupTime = LONG_LONG_MIN;  // force next poll to wake up immediately  
  61.     }  
  62. }  
在dispatchOnceInnerLocked函数中，首先从mInboundQueue获取刚加入的ConfigurationChangedEntry数据，然后调用dispatchConfigurationChangedLocked去处理这个消息：
[cpp] view plain copy
  1. bool InputDispatcher::dispatchConfigurationChangedLocked(  
  2.         nsecs_t currentTime, ConfigurationChangedEntry* entry) {  
  3.     resetKeyRepeatLocked();  
  4.   
  5.     CommandEntry* commandEntry = postCommandLocked(  
  6.             & InputDispatcher::doNotifyConfigurationChangedInterruptible);  
  7.     commandEntry->eventTime = entry->eventTime;  
  8.     return true;  
  9. }  
postCommandLocked将构造一个CommandEntry，它的command是InputDispatcher::doNotifyConfigurationChangedInterruptible函数指针，然后将它加入到mCommandQueue中。并在dispatchOnceInnerLocked中设置下次epoll_wait的timeOut为LONG_LONG_MIN，让epoll_wait马上返回。我们来看下一次调用dispatchOnce时如何处理mCommandQueue的command：
[cpp] view plain copy
  1. bool InputDispatcher::runCommandsLockedInterruptible() {  
  2.     if (mCommandQueue.isEmpty()) {  
  3.         return false;  
  4.     }  
  5.   
  6.     do {  
  7.         CommandEntry* commandEntry = mCommandQueue.dequeueAtHead();  
  8.   
  9.         Command command = commandEntry->command;  
  10.         (this->*command)(commandEntry); // commands are implicitly 'LockedInterruptible'  
  11.   
  12.         commandEntry->connection.clear();  
  13.         delete commandEntry;  
  14.     } while (! mCommandQueue.isEmpty());  
  15.     return true;  
  16. }  
这里主要调用InputDispatcher::doNotifyConfigurationChangedInterruptible方法来执行这个command。
[cpp] view plain copy
  1. void InputDispatcher::doNotifyConfigurationChangedInterruptible(  
  2.         CommandEntry* commandEntry) {  
  3.     mLock.unlock();  
  4.   
  5.     mPolicy->notifyConfigurationChanged(commandEntry->eventTime);  
  6.   
  7.     mLock.lock();  
  8. }  

doNotifyConfigurationChangedInterruptible用于向NativeInputManager通知config变化，并最后会通知到Java层的InputMonitor。关于IMS的启动就介绍到这里，来简单总结下IMS的start流程：


InputManagerService分析一：IMS的启动与事件传递

触屏事件的分发

从前面介绍EventHub的getEvents方法我们可以知道，当收到触摸屏的点击事件后，则会构造一个RawEvent结构并传递给InputReader的processEventsLocked方法处理，首先来看我们从driver读到到的RawEvent结构：
[cpp] view plain copy
  1. struct RawEvent {  
  2.     nsecs_t when;  //发生的时间  
  3.     int32_t deviceId;  //事件发生的deviceId  
  4.     int32_t type;     //事件类型：按键、touch等等  
  5.     int32_t code;    //input事件code码  
  6.     int32_t value;   //input事件值  
  7. };  

当我们点击一次触摸屏时，会发送如下的RawEvent数组过来：
Input event: device=2 type=0x0003 code=0x0030 value=0x00000028 when=119077117000
Input event: device=2 type=0x0003 code=0x0039 value=0x00000000 when=119077136000
Input event: device=2 type=0x0001 code=0x014a value=0x00000001 when=119077153000
Input event: device=2 type=0x0003 code=0x0035 value=0x0000015f when=119077175000
Input event: device=2 type=0x0003 code=0x0036 value=0x00000323 when=119077192000
Input event: device=2 type=0x0000 code=0x0002 value=0x00000000 when=119077208000
Input event: device=2 type=0x0000 code=0x0000 value=0x00000000 when=119077221000

再来分析processEventsLocked处理的代码：
[cpp] view plain copy
  1. void InputReader::processEventsForDeviceLocked(int32_t deviceId,  
  2.         const RawEvent* rawEvents, size_t count) {  
  3.     ssize_t deviceIndex = mDevices.indexOfKey(deviceId);  
  4.     if (deviceIndex < 0) {  
  5.         ALOGW("Discarding event for unknown deviceId %d.", deviceId);  
  6.         return;  
  7.     }  
  8.   
  9.     InputDevice* device = mDevices.valueAt(deviceIndex);  
  10.     if (device->isIgnored()) {  
  11.         //ALOGD("Discarding event for ignored deviceId %d.", deviceId);  
  12.         return;  
  13.     }  
  14.   
  15.     device->process(rawEvents, count);  
  16. }  

这里主要调用首先通过deviceId找到对象的InputDevice，然后调用InputDevice的process方法：
[cpp] view plain copy
  1. void InputDevice::process(const RawEvent* rawEvents, size_t count) {  
  2.     size_t numMappers = mMappers.size();  
  3.     for (const RawEvent* rawEvent = rawEvents; count--; rawEvent++) {  
  4.         if (mDropUntilNextSync) {  
  5.   
  6.         } else if (rawEvent->type == EV_SYN && rawEvent->code == SYN_DROPPED) {  
  7.   
  8.         } else {  
  9.             for (size_t i = 0; i < numMappers; i++) {  
  10.                 InputMapper* mapper = mMappers[i];  
  11.                 mapper->process(rawEvent);  
  12.             }  
  13.         }  
  14.     }  
  15. }  
InputDevice的process方法调用它的依次调用mapper的process方法，因为一个InputDevice既可以移动，也可以点击，所以它可能会有多个mapper，每个mapper分别处理自己关系的事件。这里假设是一个支持多点触摸的touch screen，它的mapper即是MultiTouchInputMapper，调用它的process方法来处理触摸事件：
[cpp] view plain copy
  1. void MultiTouchInputMapper::process(const RawEvent* rawEvent) {  
  2.     TouchInputMapper::process(rawEvent);  
  3.   
  4.     mMultiTouchMotionAccumulator.process(rawEvent);  
  5. }  
  6.   
  7. void TouchInputMapper::process(const RawEvent* rawEvent) {  
  8.     mCursorButtonAccumulator.process(rawEvent);  
  9.     mCursorScrollAccumulator.process(rawEvent);  
  10.     mTouchButtonAccumulator.process(rawEvent);  
  11.   
  12.     if (rawEvent->type == EV_SYN && rawEvent->code == SYN_REPORT) {  
  13.         sync(rawEvent->when);  
  14.     }  
  15. }  

MultiTouchInputMapper是继承于TouchInputMapper，首先调用TouchInputMapper的process方法。在CursorButtonAccumulator的process方法中主要处理鼠标点击事件（左右键等）；CursorScrollAccumulator主要用于处理鼠标滚动事件；TouchButtonAccumulator主要用于处理触控笔以及点击事件。所以上面7个RawEvent中，只有type=0x0001，code=0x014a的事件会被TouchButtonAccumulator的process处理。我们依次来看上面7个事件的处理流程：

Input event: device=2 type=0x0003 code=0x0030 value=0x00000028 when=119077117000处理代码在MultiTouchMotionAccumulator::process中：
[cpp] view plain copy
  1. case ABS_MT_TOUCH_MAJOR:  
  2.     slot->mInUse = true;  
  3.     slot->mAbsMTTouchMajor = rawEvent->value;  
  4.     break;  

Input event: device=2 type=0x0003 code=0x0039 value=0x00000000 when=119077136000处理代码在MultiTouchMotionAccumulator::process中：
[cpp] view plain copy
  1.             case ABS_MT_TRACKING_ID:  
  2.                 if (mUsingSlotsProtocol && rawEvent->value < 0) {  
  3. ;  
  4.                 } else {  
  5.                     slot->mInUse = true;  
  6.                     slot->mAbsMTTrackingId = rawEvent->value;  
  7.                 }  

Input event: device=2 type=0x0001 code=0x014a value=0x00000001 when=119077153000处理代码在TouchButtonAccumulator::process中：
[cpp] view plain copy
  1. case BTN_TOUCH:  
  2.     mBtnTouch = rawEvent->value;  
  3.     break;  

Input event: device=2 type=0x0003 code=0x0035 value=0x0000015f when=119077175000处理代码在MultiTouchMotionAccumulator::process中：
[cpp] view plain copy
  1. case ABS_MT_POSITION_X:  
  2.     slot->mInUse = true;  
  3.     slot->mAbsMTPositionX = rawEvent->value;  
  4.     break;  

Input event: device=2 type=0x0003 code=0x0036 value=0x00000323 when=119077192000处理代码在MultiTouchMotionAccumulator::process中：
[cpp] view plain copy
  1. case ABS_MT_POSITION_Y:  
  2.     slot->mInUse = true;  
  3.     slot->mAbsMTPositionY = rawEvent->value;  
  4.     break;  

Input event: device=2 type=0x0000 code=0x0002 value=0x00000000 when=119077208000处理代码在MultiTouchMotionAccumulator::process中，这里表示一次触摸事件完成：
[cpp] view plain copy
  1. } else if (rawEvent->type == EV_SYN && rawEvent->code == SYN_MT_REPORT) {  
  2.     mCurrentSlot += 1;  
  3. }  

Input event: device=2 type=0x0000 code=0x0000 value=0x00000000 when=119077221000处理代码在TouchInputMapper::process中，当收到type=EV_SYN，code= SYN_REPORT后，需要去对这次按键做处理：
[cpp] view plain copy
  1. if (rawEvent->type == EV_SYN && rawEvent->code == SYN_REPORT) {  
  2.     sync(rawEvent->when);  
  3. }  

这里调用sync函数去处理这次的按键事件，这个函数比较长，我们分段来分析：
[cpp] view plain copy
  1. void TouchInputMapper::sync(nsecs_t when) {.  
  2.     mCurrentButtonState = mTouchButtonAccumulator.getButtonState()  
  3.             | mCursorButtonAccumulator.getButtonState();  
  4.   
  5.     // Sync scroll state.  
  6.     mCurrentRawVScroll = mCursorScrollAccumulator.getRelativeVWheel();  
  7.     mCurrentRawHScroll = mCursorScrollAccumulator.getRelativeHWheel();  
  8.     mCursorScrollAccumulator.finishSync();  
  9.   
  10.     // Sync touch state.  
  11.     bool havePointerIds = true;  
  12.     mCurrentRawPointerData.clear();  
  13.     syncTouch(when, &havePointerIds);  

这里首先获取button和鼠标滚动的信息，然后调用syncTouch做准备一个Pointer事件：

[cpp] view plain copy
  1. void MultiTouchInputMapper::syncTouch(nsecs_t when, bool* outHavePointerIds) {  
  2.     size_t inCount = mMultiTouchMotionAccumulator.getSlotCount();  
  3.     size_t outCount = 0;  
  4.     BitSet32 newPointerIdBits;  
  5.   
  6.     for (size_t inIndex = 0; inIndex < inCount; inIndex++) {  
  7.         const MultiTouchMotionAccumulator::Slot* inSlot =  
  8.                 mMultiTouchMotionAccumulator.getSlot(inIndex);  
  9.         if (!inSlot->isInUse()) {  
  10.             continue;  
  11.         }  
  12.   
  13.         RawPointerData::Pointer& outPointer = mCurrentRawPointerData.pointers[outCount];  
  14.         outPointer.x = inSlot->getX();  
  15.         outPointer.y = inSlot->getY();  
  16.         outPointer.pressure = inSlot->getPressure();  
  17.         outPointer.touchMajor = inSlot->getTouchMajor();  
  18.         outPointer.touchMinor = inSlot->getTouchMinor();  
  19.         outPointer.toolMajor = inSlot->getToolMajor();  
  20.         outPointer.toolMinor = inSlot->getToolMinor();  
  21.         outPointer.orientation = inSlot->getOrientation();  
  22.         outPointer.distance = inSlot->getDistance();  
  23.         outPointer.tiltX = 0;  
  24.         outPointer.tiltY = 0;  
  25.   
  26.         outPointer.toolType = inSlot->getToolType();  
  27.         if (outPointer.toolType == AMOTION_EVENT_TOOL_TYPE_UNKNOWN) {  
  28.             outPointer.toolType = mTouchButtonAccumulator.getToolType();  
  29.             if (outPointer.toolType == AMOTION_EVENT_TOOL_TYPE_UNKNOWN) {  
  30.                 outPointer.toolType = AMOTION_EVENT_TOOL_TYPE_FINGER;  
  31.             }  
  32.         }  
  33.   
  34.         bool isHovering = mTouchButtonAccumulator.getToolType() != AMOTION_EVENT_TOOL_TYPE_MOUSE  
  35.                 && (mTouchButtonAccumulator.isHovering()  
  36.                         || (mRawPointerAxes.pressure.valid && inSlot->getPressure() <= 0));  
  37.         outPointer.isHovering = isHovering;  
  38.   
  39.         if (*outHavePointerIds) {  
  40.             int32_t trackingId = inSlot->getTrackingId();  
  41.             int32_t id = -1;  
  42.             if (trackingId >= 0) {  
  43.                 for (BitSet32 idBits(mPointerIdBits); !idBits.isEmpty(); ) {  
  44.                     uint32_t n = idBits.clearFirstMarkedBit();  
  45.                     if (mPointerTrackingIdMap[n] == trackingId) {  
  46.                         id = n;  
  47.                     }  
  48.                 }  
  49.   
  50.                 if (id < 0 && !mPointerIdBits.isFull()) {  
  51.                     id = mPointerIdBits.markFirstUnmarkedBit();  
  52.                     mPointerTrackingIdMap[id] = trackingId;  
  53.                 }  
  54.             }  
  55.             if (id < 0) {  
  56.                 *outHavePointerIds = false;  
  57.                 mCurrentRawPointerData.clearIdBits();  
  58.                 newPointerIdBits.clear();  
  59.             } else {  
  60.                 outPointer.id = id;  
  61.                 mCurrentRawPointerData.idToIndex[id] = outCount;  
  62.                 mCurrentRawPointerData.markIdBit(id, isHovering);  
  63.                 newPointerIdBits.markBit(id);  
  64.             }  
  65.         }  
  66.   
  67.         outCount += 1;  
  68.     }  
  69.   
  70.     mCurrentRawPointerData.pointerCount = outCount;  
  71.     mPointerIdBits = newPointerIdBits;  
  72.   
  73.     mMultiTouchMotionAccumulator.finishSync();  
  74. }  

mCurrentRawPointerData这个数据结构中保存此次input事件的个数，并通过其成员pointers数组保存所有的input的信息。并将driver发送过来的trackingId保存在mPointerTrackingIdMap对应的id上，以便后面跟踪使用。对于上面我们介绍的7个event，它们共同促成一个input事件，所以这里的outCount为1。接着来看sync函数：
[cpp] view plain copy
  1. mCurrentFingerIdBits.clear();  
  2. mCurrentStylusIdBits.clear();  
  3. mCurrentMouseIdBits.clear();  
  4. mCurrentCookedPointerData.clear();  
  5.   
  6. if (mDeviceMode == DEVICE_MODE_DISABLED) {  
  7.   
  8. } else {  
  9.     if (!havePointerIds) {  
  10.     }  
  11.   
  12.     uint32_t policyFlags = 0;  
  13.     bool initialDown = mLastRawPointerData.pointerCount == 0  
  14.             && mCurrentRawPointerData.pointerCount != 0;  
  15.     bool buttonsPressed = mCurrentButtonState & ~mLastButtonState;  
  16.     if (initialDown || buttonsPressed) {  
  17.         if (mDeviceMode == DEVICE_MODE_DIRECT) {  
  18.             getContext()->fadePointer();  
  19.         }  
  20.     }  
  21.       
  22.     //处理button事件，此次触摸事件中并没有touch  
  23.     synthesizeButtonKeys(getContext(), AKEY_EVENT_ACTION_DOWN, when, getDeviceId(), mSource,  
  24.             policyFlags, mLastButtonState, mCurrentButtonState);  
  25.   
  26.     if (consumeRawTouches(when, policyFlags)) {  
  27.         mCurrentRawPointerData.clear();  
  28.     }  

上面的代码中，如果有button事件（如AMOTION_EVENT_BUTTON_BACK、AMOTION_EVENT_BUTTON_FORWARD）发生，则调用synthesizeButtonKeys向InputDispatcher汇报button事件。然后调用consumeRawTouches去检查是否是虚拟事件，因为在Android 4.4中已经不存在虚拟按键，所以我们暂时先不看这个函数。接着往下来看：
[cpp] view plain copy
  1.    cookPointerData();  
  2.   
  3.     if (mDeviceMode == DEVICE_MODE_POINTER) {  
  4.   
  5.     } else {  
  6.         if (mDeviceMode == DEVICE_MODE_DIRECT  
  7.                 && mConfig.showTouches && mPointerController != NULL) {  
  8.             mPointerController->setPresentation(PointerControllerInterface::PRESENTATION_SPOT);  
  9.             mPointerController->fade(PointerControllerInterface::TRANSITION_GRADUAL);  
  10.   
  11.             mPointerController->setButtonState(mCurrentButtonState);  
  12.             mPointerController->setSpots(mCurrentCookedPointerData.pointerCoords,  
  13.                     mCurrentCookedPointerData.idToIndex,  
  14.                     mCurrentCookedPointerData.touchingIdBits);  
  15.         }  
  16.   
  17.         dispatchHoverExit(when, policyFlags);  
  18.         dispatchTouches(when, policyFlags);  
  19.         dispatchHoverEnterAndMove(when, policyFlags);  
  20.     }  
  21.   
  22.     // 处理button事件，此次触摸事件中并没有touch  
  23.     synthesizeButtonKeys(getContext(), AKEY_EVENT_ACTION_UP, when, getDeviceId(), mSource,  
  24.             policyFlags, mLastButtonState, mCurrentButtonState);  
  25. }  
  26.   
  27. mLastRawPointerData.copyFrom(mCurrentRawPointerData);  
  28. mLastCookedPointerData.copyFrom(mCurrentCookedPointerData);  
  29. mLastButtonState = mCurrentButtonState;  
  30. mLastFingerIdBits = mCurrentFingerIdBits;  
  31. mLastStylusIdBits = mCurrentStylusIdBits;  
  32. mLastMouseIdBits = mCurrentMouseIdBits;  
  33.   
  34. // Clear some transient state.  
  35. mCurrentRawVScroll = 0;  
  36. mCurrentRawHScroll = 0;  

cookPointerData函数用于保存此次input事件，因为当前屏幕是touch screen，所以直接调用dispatchHoverExit、dispatchTouches和dispatchHoverEnterAndMove三个方法来分发事件，如果在Settings中打开了showTouch选项，则调用PointerController去绘制相应的坐标位置。我们首先来看dispatchHoverExit方法：
[cpp] view plain copy
  1. void TouchInputMapper::dispatchHoverExit(nsecs_t when, uint32_t policyFlags) {  
  2.     if (mSentHoverEnter &&  
  3.             (mCurrentCookedPointerData.hoveringIdBits.isEmpty()  
  4.                     || !mCurrentCookedPointerData.touchingIdBits.isEmpty())) {  
  5.   
  6.         mSentHoverEnter = false;  
  7.     }  
  8. }  
因为此时mSentHoverEnter为false，所以这个函数什么也不做，直接返回。接着来看dispatchTouches函数：

[cpp] view plain copy
  1. void TouchInputMapper::dispatchTouches(nsecs_t when, uint32_t policyFlags) {  
  2.     BitSet32 currentIdBits = mCurrentCookedPointerData.touchingIdBits;  
  3.     BitSet32 lastIdBits = mLastCookedPointerData.touchingIdBits;  
  4.     int32_t metaState = getContext()->getGlobalMetaState();  
  5.     int32_t buttonState = mCurrentButtonState;  
  6.   
  7.     if (currentIdBits == lastIdBits) {  
  8.         if (!currentIdBits.isEmpty()) {  
  9.             // No pointer id changes so this is a move event.  
  10.             // The listener takes care of batching moves so we don't have to deal with that here.  
  11.             dispatchMotion(when, policyFlags, mSource,  
  12.                     AMOTION_EVENT_ACTION_MOVE, 0, metaState, buttonState,  
  13.                     AMOTION_EVENT_EDGE_FLAG_NONE,  
  14.                     mCurrentCookedPointerData.pointerProperties,  
  15.                     mCurrentCookedPointerData.pointerCoords,  
  16.                     mCurrentCookedPointerData.idToIndex,  
  17.                     currentIdBits, -1,  
  18.                     mOrientedXPrecision, mOrientedYPrecision, mDownTime);  
  19.         }  
  20.     } else {  
  21.         // There may be pointers going up and pointers going down and pointers moving  
  22.         // all at the same time.  
  23.         BitSet32 upIdBits(lastIdBits.value & ~currentIdBits.value);  
  24.         BitSet32 downIdBits(currentIdBits.value & ~lastIdBits.value);  
  25.         BitSet32 moveIdBits(lastIdBits.value & currentIdBits.value);  
  26.         BitSet32 dispatchedIdBits(lastIdBits.value);  
  27.   
  28.         // Update last coordinates of pointers that have moved so that we observe the new  
  29.         // pointer positions at the same time as other pointers that have just gone up.  
  30.         bool moveNeeded = updateMovedPointers(  
  31.                 mCurrentCookedPointerData.pointerProperties,  
  32.                 mCurrentCookedPointerData.pointerCoords,  
  33.                 mCurrentCookedPointerData.idToIndex,  
  34.                 mLastCookedPointerData.pointerProperties,  
  35.                 mLastCookedPointerData.pointerCoords,  
  36.                 mLastCookedPointerData.idToIndex,  
  37.                 moveIdBits);  
  38.         if (buttonState != mLastButtonState) {  
  39.             moveNeeded = true;  
  40.         }  
  41.   
  42.         // Dispatch pointer up events.  
  43.         while (!upIdBits.isEmpty()) {  
  44.             uint32_t upId = upIdBits.clearFirstMarkedBit();  
  45.   
  46.             dispatchMotion(when, policyFlags, mSource,  
  47.                     AMOTION_EVENT_ACTION_POINTER_UP, 0, metaState, buttonState, 0,  
  48.                     mLastCookedPointerData.pointerProperties,  
  49.                     mLastCookedPointerData.pointerCoords,  
  50.                     mLastCookedPointerData.idToIndex,  
  51.                     dispatchedIdBits, upId,  
  52.                     mOrientedXPrecision, mOrientedYPrecision, mDownTime);  
  53.             dispatchedIdBits.clearBit(upId);  
  54.         }  
  55.   
  56.         // Dispatch move events if any of the remaining pointers moved from their old locations.  
  57.         // Although applications receive new locations as part of individual pointer up  
  58.         // events, they do not generally handle them except when presented in a move event.  
  59.         if (moveNeeded) {  
  60.             ALOG_ASSERT(moveIdBits.value == dispatchedIdBits.value);  
  61.             dispatchMotion(when, policyFlags, mSource,  
  62.                     AMOTION_EVENT_ACTION_MOVE, 0, metaState, buttonState, 0,  
  63.                     mCurrentCookedPointerData.pointerProperties,  
  64.                     mCurrentCookedPointerData.pointerCoords,  
  65.                     mCurrentCookedPointerData.idToIndex,  
  66.                     dispatchedIdBits, -1,  
  67.                     mOrientedXPrecision, mOrientedYPrecision, mDownTime);  
  68.         }  
  69.   
  70.         // Dispatch pointer down events using the new pointer locations.  
  71.         while (!downIdBits.isEmpty()) {  
  72.             uint32_t downId = downIdBits.clearFirstMarkedBit();  
  73.             dispatchedIdBits.markBit(downId);  
  74.   
  75.             if (dispatchedIdBits.count() == 1) {  
  76.                 // First pointer is going down.  Set down time.  
  77.                 mDownTime = when;  
  78.             }  
  79.   
  80.             dispatchMotion(when, policyFlags, mSource,  
  81.                     AMOTION_EVENT_ACTION_POINTER_DOWN, 0, metaState, buttonState, 0,  
  82.                     mCurrentCookedPointerData.pointerProperties,  
  83.                     mCurrentCookedPointerData.pointerCoords,  
  84.                     mCurrentCookedPointerData.idToIndex,  
  85.                     dispatchedIdBits, downId,  
  86.                     mOrientedXPrecision, mOrientedYPrecision, mDownTime);  
  87.         }  
  88.     }  
  89. }  

dispatchTouches从CurrentCookedPointerData和LastCookedPointerData分别取出touchingIdBits，对两者进行一系列操作获取到当前事件是up、down还是move事件，并分别调用不同的dispatchMotion去分发AMOTION_EVENT_ACTION_POINTER_UP、AMOTION_EVENT_ACTION_POINTER_DOWN和AMOTION_EVENT_ACTION_MOVE事件。我们此次只看AMOTION_EVENT_ACTION_POINTER_DOWN事件的分发：
[cpp] view plain copy
  1. void TouchInputMapper::dispatchMotion(nsecs_t when, uint32_t policyFlags, uint32_t source,  
  2.         int32_t action, int32_t flags, int32_t metaState, int32_t buttonState, int32_t edgeFlags,  
  3.         const PointerProperties* properties, const PointerCoords* coords,  
  4.         const uint32_t* idToIndex, BitSet32 idBits,  
  5.         int32_t changedId, float xPrecision, float yPrecision, nsecs_t downTime) {  
  6.     PointerCoords pointerCoords[MAX_POINTERS];  
  7.     PointerProperties pointerProperties[MAX_POINTERS];  
  8.     uint32_t pointerCount = 0;  
  9.     while (!idBits.isEmpty()) {  
  10.         uint32_t id = idBits.clearFirstMarkedBit();  
  11.         uint32_t index = idToIndex[id];  
  12.         pointerProperties[pointerCount].copyFrom(properties[index]);  
  13.         pointerCoords[pointerCount].copyFrom(coords[index]);  
  14.   
  15.         if (changedId >= 0 && id == uint32_t(changedId)) {  
  16.             action |= pointerCount << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;  
  17.         }  
  18.   
  19.         pointerCount += 1;  
  20.     }  
  21.   
  22.     ALOG_ASSERT(pointerCount != 0);  
  23.   
  24.     if (changedId >= 0 && pointerCount == 1) {  
  25.         if (action == AMOTION_EVENT_ACTION_POINTER_DOWN) {  
  26.             action = AMOTION_EVENT_ACTION_DOWN;  
  27.         } else if (action == AMOTION_EVENT_ACTION_POINTER_UP) {  
  28.             action = AMOTION_EVENT_ACTION_UP;  
  29.         } else {  
  30.             // Can't happen.  
  31.             ALOG_ASSERT(false);  
  32.         }  
  33.     }  
  34.   
  35.     NotifyMotionArgs args(when, getDeviceId(), source, policyFlags,  
  36.             action, flags, metaState, buttonState, edgeFlags,  
  37.             mViewport.displayId, pointerCount, pointerProperties, pointerCoords,  
  38.             xPrecision, yPrecision, downTime);  
  39.     getListener()->notifyMotion(&args);  
  40. }  

这里会对AMOTION_EVENT_ACTION_POINTER_DOWN转换成AMOTION_EVENT_ACTION_DOWN，然后notify给InputDispatcher：
[cpp] view plain copy
  1. void InputDispatcher::notifyMotion(const NotifyMotionArgs* args) {  
  2.     if (!validateMotionEvent(args->action, args->pointerCount, args->pointerProperties)) {  
  3.         return;  
  4.     }  
  5.   
  6.     uint32_t policyFlags = args->policyFlags;  
  7.     policyFlags |= POLICY_FLAG_TRUSTED;  
  8.     mPolicy->interceptMotionBeforeQueueing(args->eventTime, /*byref*/ policyFlags);  
  9.   
  10.     bool needWake;  
  11.     { // acquire lock  
  12.         mLock.lock();  
  13.   
  14.         if (shouldSendMotionToInputFilterLocked(args)) {  
  15.             mLock.unlock();  
  16.   
  17.             MotionEvent event;  
  18.             event.initialize(args->deviceId, args->source, args->action, args->flags,  
  19.                     args->edgeFlags, args->metaState, args->buttonState, 0, 0,  
  20.                     args->xPrecision, args->yPrecision,  
  21.                     args->downTime, args->eventTime,  
  22.                     args->pointerCount, args->pointerProperties, args->pointerCoords);  
  23.   
  24.             policyFlags |= POLICY_FLAG_FILTERED;  
  25.             if (!mPolicy->filterInputEvent(&event, policyFlags)) {  
  26.                 return; // event was consumed by the filter  
  27.             }  
  28.   
  29.             mLock.lock();  
  30.         }  
  31.   
  32.         // Just enqueue a new motion event.  
  33.         MotionEntry* newEntry = new MotionEntry(args->eventTime,  
  34.                 args->deviceId, args->source, policyFlags,  
  35.                 args->action, args->flags, args->metaState, args->buttonState,  
  36.                 args->edgeFlags, args->xPrecision, args->yPrecision, args->downTime,  
  37.                 args->displayId,  
  38.                 args->pointerCount, args->pointerProperties, args->pointerCoords);  
  39.   
  40.         needWake = enqueueInboundEventLocked(newEntry);  
  41.         mLock.unlock();  
  42.     } // release lock  
  43.   
  44.     if (needWake) {  
  45.         mLooper->wake();  
  46.     }  
  47. }  

在InputDispatcher的notifyMotion函数中，首先检查NotifyMotionArgs是否合法。然后对policyFlags添加上POLICY_FLAG_TRUSTED，并调用NativeInputManager的interceptMotionBeforeQueueing方法对这个input事件提前做处理：
[cpp] view plain copy
  1. void NativeInputManager::interceptMotionBeforeQueueing(nsecs_t when, uint32_t& policyFlags) {  
  2.     if ((policyFlags & POLICY_FLAG_TRUSTED) && !(policyFlags & POLICY_FLAG_INJECTED)) {  
  3.         if (isScreenOn()) {  
  4.             policyFlags |= POLICY_FLAG_PASS_TO_USER;  
  5.   
  6.             if (!isScreenBright()) {  
  7.                 policyFlags |= POLICY_FLAG_BRIGHT_HERE;  
  8.             }  
  9.         } else {  
  10.   
  11.         }  
  12.     } else {  
  13.   
  14.     }  
  15. }  

因为当前屏幕处于点亮状态，这里会对policyFlags添加上POLICY_FLAG_PASS_TO_USER，表示要把这个事件上传给user。

回到notifyMotion中，如果当前设置了InputFilter，则构造一个MotionEvent对象发送给InputFilter处理。如果没有设置InputFilter，则构造一个MotionEntry，并添加到mInboundQueue中，并唤醒InputDispatcher的dispatchOnce方法，并调用dispatchOnceInnerLocked去完成事件的分发：
[cpp] view plain copy
  1. void InputDispatcher::dispatchOnceInnerLocked(nsecs_t* nextWakeupTime) {  
  2.     nsecs_t currentTime = now();  
  3.       
  4.     bool isAppSwitchDue = mAppSwitchDueTime <= currentTime;  
  5.     if (mAppSwitchDueTime < *nextWakeupTime) {  
  6.         *nextWakeupTime = mAppSwitchDueTime;  
  7.     }  
  8.       
  9.     if (! mPendingEvent) {  
  10.         if (mInboundQueue.isEmpty()) {  
  11.   
  12.         } else {  
  13.             mPendingEvent = mInboundQueue.dequeueAtHead();  
  14.             traceInboundQueueLengthLocked();  
  15.         }  
  16.           
  17.         if (mPendingEvent->policyFlags & POLICY_FLAG_PASS_TO_USER) {  
  18.             pokeUserActivityLocked(mPendingEvent);  
  19.         }  
  20.   
  21.         resetANRTimeoutsLocked();  
  22.     }  
  23.   
  24.     ALOG_ASSERT(mPendingEvent != NULL);  
  25.     bool done = false;  
  26.     DropReason dropReason = DROP_REASON_NOT_DROPPED;  
  27.     if (!(mPendingEvent->policyFlags & POLICY_FLAG_PASS_TO_USER)) {  
  28.   
  29.     } else if (!mDispatchEnabled) {  
  30.   
  31.     }  
  32.   
  33.     if (mNextUnblockedEvent == mPendingEvent) {  
  34.         mNextUnblockedEvent = NULL;  
  35.     }  
  36.   
  37.     switch (mPendingEvent->type) {  
  38.   
  39.     case EventEntry::TYPE_MOTION: {  
  40.         MotionEntry* typedEntry = static_cast<MotionEntry*>(mPendingEvent);  
  41.         if (dropReason == DROP_REASON_NOT_DROPPED && isAppSwitchDue) {  
  42.   
  43.         }  
  44.         if (dropReason == DROP_REASON_NOT_DROPPED  
  45.                 && isStaleEventLocked(currentTime, typedEntry)) {  
  46.   
  47.         }  
  48.         if (dropReason == DROP_REASON_NOT_DROPPED && mNextUnblockedEvent) {  
  49.   
  50.         }  
  51.         done = dispatchMotionLocked(currentTime, typedEntry,  
  52.                 &dropReason, nextWakeupTime);  
  53.         break;  
  54.     }  
  55.   
  56.     default:  
  57.         ALOG_ASSERT(false);  
  58.         break;  
  59.     }  
  60.   
  61.     if (done) {  
  62.         if (dropReason != DROP_REASON_NOT_DROPPED) {  
  63.             dropInboundEventLocked(mPendingEvent, dropReason);  
  64.         }  
  65.   
  66.         releasePendingEventLocked();  
  67.         *nextWakeupTime = LONG_LONG_MIN;  // force next poll to wake up immediately  
  68.     }  
  69. }  

这里首先从mInboundQueue中获取前面添加的MotionEntry对象，然后调用dispatchMotionLocked去分发：
[cpp] view plain copy
  1. bool InputDispatcher::dispatchMotionLocked(  
  2.         nsecs_t currentTime, MotionEntry* entry, DropReason* dropReason, nsecs_t* nextWakeupTime) {  
  3.     if (! entry->dispatchInProgress) {  
  4.         entry->dispatchInProgress = true;  
  5.     }  
  6.   
  7.     if (*dropReason != DROP_REASON_NOT_DROPPED) {  
  8.   
  9.     }  
  10.   
  11.     bool isPointerEvent = entry->source & AINPUT_SOURCE_CLASS_POINTER;  
  12.   
  13.     Vector<InputTarget> inputTargets;  
  14.   
  15.     bool conflictingPointerActions = false;  
  16.     int32_t injectionResult;  
  17.     if (isPointerEvent) {  
  18.         injectionResult = findTouchedWindowTargetsLocked(currentTime,  
  19.                 entry, inputTargets, nextWakeupTime, &conflictingPointerActions);  
  20.     } else {  
  21.   
  22.     }  
  23.     if (injectionResult == INPUT_EVENT_INJECTION_PENDING) {  
  24.   
  25.     }  
  26.   
  27.     setInjectionResultLocked(entry, injectionResult);  
  28.     if (injectionResult != INPUT_EVENT_INJECTION_SUCCEEDED) {  
  29.         return true;  
  30.     }  
  31.   
  32.     if (isMainDisplay(entry->displayId)) {  
  33.         addMonitoringTargetsLocked(inputTargets);  
  34.     }  
  35.   
  36.     // Dispatch the motion.  
  37.     if (conflictingPointerActions) {  
  38.         CancelationOptions options(CancelationOptions::CANCEL_POINTER_EVENTS,  
  39.                 "conflicting pointer actions");  
  40.         synthesizeCancelationEventsForAllConnectionsLocked(options);  
  41.     }  
  42.     dispatchEventLocked(currentTime, entry, inputTargets);  
  43.     return true;  
  44. }  

在dispatchMotionLocked中，首先调用findTouchedWindowTargetsLocked去找到有focus的window窗口，并把这些创建保存在inputTargets数组中。并且还记得我们前面有注册一个monitor的InputChannel吗？这里也会调用addMonitoringTargetsLocked把mMonitoringChannels中所有的InputChannel添加到inputTargets数组中。然后调用dispatchEventLocked去向这些窗口一个个分发事件。我们先来看findTouchedWindowTargetsLocked方法：
[cpp] view plain copy
  1. int32_t InputDispatcher::findTouchedWindowTargetsLocked(nsecs_t currentTime,  
  2.         const MotionEntry* entry, Vector<InputTarget>& inputTargets, nsecs_t* nextWakeupTime,  
  3.         bool* outConflictingPointerActions) {  
  4.     enum InjectionPermission {  
  5.         INJECTION_PERMISSION_UNKNOWN,  
  6.         INJECTION_PERMISSION_GRANTED,  
  7.         INJECTION_PERMISSION_DENIED  
  8.     };  
  9.   
  10.     nsecs_t startTime = now();  
  11.     bool screenWasOff = false;  
  12.   
  13.     int32_t displayId = entry->displayId;  
  14.     int32_t action = entry->action;  
  15.     int32_t maskedAction = action & AMOTION_EVENT_ACTION_MASK;  
  16.   
  17.     // Update the touch state as needed based on the properties of the touch event.  
  18.     int32_t injectionResult = INPUT_EVENT_INJECTION_PENDING;  
  19.     InjectionPermission injectionPermission = INJECTION_PERMISSION_UNKNOWN;  
  20.     sp<InputWindowHandle> newHoverWindowHandle;  
  21.   
  22.     bool isSplit = mTouchState.split;  
  23.     bool switchedDevice = mTouchState.deviceId >= 0 && mTouchState.displayId >= 0  
  24.             && (mTouchState.deviceId != entry->deviceId  
  25.                     || mTouchState.source != entry->source  
  26.                     || mTouchState.displayId != displayId);  
  27.     bool isHoverAction = (maskedAction == AMOTION_EVENT_ACTION_HOVER_MOVE  
  28.             || maskedAction == AMOTION_EVENT_ACTION_HOVER_ENTER  
  29.             || maskedAction == AMOTION_EVENT_ACTION_HOVER_EXIT);  
  30.     bool newGesture = (maskedAction == AMOTION_EVENT_ACTION_DOWN  
  31.             || maskedAction == AMOTION_EVENT_ACTION_SCROLL  
  32.             || isHoverAction);  
  33.     bool wrongDevice = false;  
  34.     if (newGesture) {  
  35.         bool down = maskedAction == AMOTION_EVENT_ACTION_DOWN;  
  36.         if (switchedDevice && mTouchState.down && !down) {  
  37.   
  38.         }  
  39.         mTempTouchState.reset();  
  40.         mTempTouchState.down = down;  
  41.         mTempTouchState.deviceId = entry->deviceId;  
  42.         mTempTouchState.source = entry->source;  
  43.         mTempTouchState.displayId = displayId;  
  44.         isSplit = false;  
  45.     } else {  
  46.   
  47.     }  
  48.   
  49.     if (newGesture || (isSplit && maskedAction == AMOTION_EVENT_ACTION_POINTER_DOWN)) {  
  50.         int32_t pointerIndex = getMotionEventActionPointerIndex(action);  
  51.         int32_t x = int32_t(entry->pointerCoords[pointerIndex].  
  52.                 getAxisValue(AMOTION_EVENT_AXIS_X));  
  53.         int32_t y = int32_t(entry->pointerCoords[pointerIndex].  
  54.                 getAxisValue(AMOTION_EVENT_AXIS_Y));  
  55.         sp<InputWindowHandle> newTouchedWindowHandle;  
  56.         sp<InputWindowHandle> topErrorWindowHandle;  
  57.         bool isTouchModal = false;  
  58.   
  59.         size_t numWindows = mWindowHandles.size();  
  60.         for (size_t i = 0; i < numWindows; i++) {  
  61.             sp<InputWindowHandle> windowHandle = mWindowHandles.itemAt(i);  
  62.             const InputWindowInfo* windowInfo = windowHandle->getInfo();  
  63.             if (windowInfo->displayId != displayId) {  
  64.                 continue; // wrong display  
  65.             }  
  66.   
  67.             int32_t flags = windowInfo->layoutParamsFlags;  
  68.             if (windowInfo->visible) {  
  69.                 if (! (flags & InputWindowInfo::FLAG_NOT_TOUCHABLE)) {  
  70.                     isTouchModal = (flags & (InputWindowInfo::FLAG_NOT_FOCUSABLE  
  71.                             | InputWindowInfo::FLAG_NOT_TOUCH_MODAL)) == 0;  
  72.                     if (isTouchModal || windowInfo->touchableRegionContainsPoint(x, y)) {  
  73.                         if (! screenWasOff  
  74.                                 || (flags & InputWindowInfo::FLAG_TOUCHABLE_WHEN_WAKING)) {  
  75.                             newTouchedWindowHandle = windowHandle;  
  76.                         }  
  77.                         break; // found touched window, exit window loop  
  78.                     }  
  79.                 }  
  80.             }  
  81.         }  
  82.   
  83.         if (newTouchedWindowHandle != NULL  
  84.                 && newTouchedWindowHandle->getInfo()->supportsSplitTouch()) {  
  85.             isSplit = true;  
  86.         } else if (isSplit) {  
  87.         }  
  88.   
  89.         int32_t targetFlags = InputTarget::FLAG_FOREGROUND | InputTarget::FLAG_DISPATCH_AS_IS;  
  90.         if (isSplit) {  
  91.             targetFlags |= InputTarget::FLAG_SPLIT;  
  92.         }  
  93.         if (isWindowObscuredAtPointLocked(newTouchedWindowHandle, x, y)) {  
  94.             targetFlags |= InputTarget::FLAG_WINDOW_IS_OBSCURED;  
  95.         }  
  96.   
  97.         BitSet32 pointerIds;  
  98.         if (isSplit) {  
  99.             uint32_t pointerId = entry->pointerProperties[pointerIndex].id;  
  100.             pointerIds.markBit(pointerId);  
  101.         }  
  102.         mTempTouchState.addOrUpdateWindow(newTouchedWindowHandle, targetFlags, pointerIds);  
  103.     } else {  
  104.   
  105.     }  
  106.   
  107.     {  
  108.         bool haveForegroundWindow = false;  
  109.         for (size_t i = 0; i < mTempTouchState.windows.size(); i++) {  
  110.             const TouchedWindow& touchedWindow = mTempTouchState.windows[i];  
  111.             if (touchedWindow.targetFlags & InputTarget::FLAG_FOREGROUND) {  
  112.                 haveForegroundWindow = true;  
  113.                 if (! checkInjectionPermission(touchedWindow.windowHandle,  
  114.                         entry->injectionState)) {  
  115.                     injectionResult = INPUT_EVENT_INJECTION_PERMISSION_DENIED;  
  116.                     injectionPermission = INJECTION_PERMISSION_DENIED;  
  117.                     goto Failed;  
  118.                 }  
  119.             }  
  120.         }  
  121.   
  122.         injectionPermission = INJECTION_PERMISSION_GRANTED;  
  123.     }  
  124.   
  125.     if (maskedAction == AMOTION_EVENT_ACTION_DOWN) {  
  126.         sp<InputWindowHandle> foregroundWindowHandle =  
  127.                 mTempTouchState.getFirstForegroundWindowHandle();  
  128.         const int32_t foregroundWindowUid = foregroundWindowHandle->getInfo()->ownerUid;  
  129.         for (size_t i = 0; i < mTempTouchState.windows.size(); i++) {  
  130.             const TouchedWindow& touchedWindow = mTempTouchState.windows[i];  
  131.             if (touchedWindow.targetFlags & InputTarget::FLAG_DISPATCH_AS_OUTSIDE) {  
  132.                 sp<InputWindowHandle> inputWindowHandle = touchedWindow.windowHandle;  
  133.                 if (inputWindowHandle->getInfo()->ownerUid != foregroundWindowUid) {  
  134.                     mTempTouchState.addOrUpdateWindow(inputWindowHandle,  
  135.                             InputTarget::FLAG_ZERO_COORDS, BitSet32(0));  
  136.                 }  
  137.             }  
  138.         }  
  139.     }  
  140.   
  141.     if (maskedAction == AMOTION_EVENT_ACTION_DOWN) {  
  142.         sp<InputWindowHandle> foregroundWindowHandle =  
  143.                 mTempTouchState.getFirstForegroundWindowHandle();  
  144.         if (foregroundWindowHandle->getInfo()->hasWallpaper) {  
  145.             for (size_t i = 0; i < mWindowHandles.size(); i++) {  
  146.                 sp<InputWindowHandle> windowHandle = mWindowHandles.itemAt(i);  
  147.                 const InputWindowInfo* info = windowHandle->getInfo();  
  148.                 if (info->displayId == displayId  
  149.                         && windowHandle->getInfo()->layoutParamsType  
  150.                                 == InputWindowInfo::TYPE_WALLPAPER) {  
  151.                     mTempTouchState.addOrUpdateWindow(windowHandle,  
  152.                             InputTarget::FLAG_WINDOW_IS_OBSCURED  
  153.                                     | InputTarget::FLAG_DISPATCH_AS_IS,  
  154.                             BitSet32(0));  
  155.                 }  
  156.             }  
  157.         }  
  158.     }  
  159.   
  160.     injectionResult = INPUT_EVENT_INJECTION_SUCCEEDED;  
  161.   
  162.     for (size_t i = 0; i < mTempTouchState.windows.size(); i++) {  
  163.         const TouchedWindow& touchedWindow = mTempTouchState.windows.itemAt(i);  
  164.         addWindowTargetLocked(touchedWindow.windowHandle, touchedWindow.targetFlags,  
  165.                 touchedWindow.pointerIds, inputTargets);  
  166.     }  
  167.   
  168.     mTempTouchState.filterNonAsIsTouchWindows();  
  169.     return injectionResult;  
  170. }  

findTouchedWindowTargetsLocked方法首先根据我们这次触摸事件去判断是down、up还是move，然后调用不同的处理方法来处理。我们来只看一次down事件，首先从mWindowHandles找到当前focus焦点的window、获取点击区域在window中的窗口或者InputWindowInfo设置了FLAG_WATCH_OUTSIDE_TOUCH的所有窗口，并把这些窗口全部放在mTempTouchState的windows中。然后对这些创建做权限检查以及这个窗口是否处于paused状态，并从mTempTouchState中移除这些窗口。最后把检查过的所有window的inputChannel全部放到inputTargets数组中。
回到dispatchMotionLocked函数中，接着调用dispatchEventLocked函数去一个一个向inputTargets中的inputChannel分发input事件：
[cpp] view plain copy
  1. void InputDispatcher::dispatchEventLocked(nsecs_t currentTime,  
  2.         EventEntry* eventEntry, const Vector<InputTarget>& inputTargets) {  
  3.     pokeUserActivityLocked(eventEntry);  
  4.   
  5.     for (size_t i = 0; i < inputTargets.size(); i++) {  
  6.         const InputTarget& inputTarget = inputTargets.itemAt(i);  
  7.   
  8.         ssize_t connectionIndex = getConnectionIndexLocked(inputTarget.inputChannel);  
  9.         if (connectionIndex >= 0) {  
  10.             sp<Connection> connection = mConnectionsByFd.valueAt(connectionIndex);  
  11.             prepareDispatchCycleLocked(currentTime, connection, eventEntry, &inputTarget);  
  12.         } else {  
  13.   
  14.         }  
  15.     }  
  16. }  

我们前面介绍InputManagerService的monitorInput方法时讲解过，在向InputDispatcher注册InputChannel时，会构造一个Connection对象并保存InputChannel，这个Connection对象是通过Fd值保存在mConnectionsByFd数组中。这里getConnectionIndexLocked首先获取window所注册的InputChannel，然后调用prepareDispatchCycleLocked去准备分发：
[cpp] view plain copy
  1. void InputDispatcher::prepareDispatchCycleLocked(nsecs_t currentTime,  
  2.         const sp<Connection>& connection, EventEntry* eventEntry, const InputTarget* inputTarget) {  
  3.     enqueueDispatchEntriesLocked(currentTime, connection, eventEntry, inputTarget);  
  4. }  
  5.   
  6. void InputDispatcher::enqueueDispatchEntriesLocked(nsecs_t currentTime,  
  7.         const sp<Connection>& connection, EventEntry* eventEntry, const InputTarget* inputTarget) {  
  8.     bool wasEmpty = connection->outboundQueue.isEmpty();  
  9.   
  10.     // Enqueue dispatch entries for the requested modes.  
  11.     enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,  
  12.             InputTarget::FLAG_DISPATCH_AS_HOVER_EXIT);  
  13.     enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,  
  14.             InputTarget::FLAG_DISPATCH_AS_OUTSIDE);  
  15.     enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,  
  16.             InputTarget::FLAG_DISPATCH_AS_HOVER_ENTER);  
  17.     enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,  
  18.             InputTarget::FLAG_DISPATCH_AS_IS);  
  19.     enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,  
  20.             InputTarget::FLAG_DISPATCH_AS_SLIPPERY_EXIT);  
  21.     enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,  
  22.             InputTarget::FLAG_DISPATCH_AS_SLIPPERY_ENTER);  
  23.   
  24.     // If the outbound queue was previously empty, start the dispatch cycle going.  
  25.     if (wasEmpty && !connection->outboundQueue.isEmpty()) {  
  26.         startDispatchCycleLocked(currentTime, connection);  
  27.     }  
  28. }  

prepareDispatchCycleLocked主要调用enqueueDispatchEntriesLocked把当前EventEntry添加到connection的outboundQueue中。enqueueDispatchEntryLocked函数会根据inputTarget的flags和dispatchMode比较，如果两者没有交集，就不将EventEntry添加到outboundQueue。最后调用startDispatchCycleLocked去分发这个这个事件：
[cpp] view plain copy
  1. void InputDispatcher::startDispatchCycleLocked(nsecs_t currentTime,  
  2.         const sp<Connection>& connection) {  
  3.     while (connection->status == Connection::STATUS_NORMAL  
  4.             && !connection->outboundQueue.isEmpty()) {  
  5.         DispatchEntry* dispatchEntry = connection->outboundQueue.head;  
  6.         dispatchEntry->deliveryTime = currentTime;  
  7.   
  8.         status_t status;  
  9.         EventEntry* eventEntry = dispatchEntry->eventEntry;  
  10.         switch (eventEntry->type) {  
  11.         case EventEntry::TYPE_MOTION: {  
  12.             MotionEntry* motionEntry = static_cast<MotionEntry*>(eventEntry);  
  13.   
  14.             PointerCoords scaledCoords[MAX_POINTERS];  
  15.             const PointerCoords* usingCoords = motionEntry->pointerCoords;  
  16.   
  17.             float xOffset, yOffset, scaleFactor;  
  18.             if ((motionEntry->source & AINPUT_SOURCE_CLASS_POINTER)  
  19.                     && !(dispatchEntry->targetFlags & InputTarget::FLAG_ZERO_COORDS)) {  
  20.                 scaleFactor = dispatchEntry->scaleFactor;  
  21.                 xOffset = dispatchEntry->xOffset * scaleFactor;  
  22.                 yOffset = dispatchEntry->yOffset * scaleFactor;  
  23.                 if (scaleFactor != 1.0f) {  
  24.                     for (size_t i = 0; i < motionEntry->pointerCount; i++) {  
  25.                         scaledCoords[i] = motionEntry->pointerCoords[i];  
  26.                         scaledCoords[i].scale(scaleFactor);  
  27.                     }  
  28.                     usingCoords = scaledCoords;  
  29.                 }  
  30.             } else {  
  31.                 xOffset = 0.0f;  
  32.                 yOffset = 0.0f;  
  33.                 scaleFactor = 1.0f;  
  34.   
  35.                 // We don't want the dispatch target to know.  
  36.                 if (dispatchEntry->targetFlags & InputTarget::FLAG_ZERO_COORDS) {  
  37.                     for (size_t i = 0; i < motionEntry->pointerCount; i++) {  
  38.                         scaledCoords[i].clear();  
  39.                     }  
  40.                     usingCoords = scaledCoords;  
  41.                 }  
  42.             }  
  43.   
  44.             status = connection->inputPublisher.publishMotionEvent(dispatchEntry->seq,  
  45.                     motionEntry->deviceId, motionEntry->source,  
  46.                     dispatchEntry->resolvedAction, dispatchEntry->resolvedFlags,  
  47.                     motionEntry->edgeFlags, motionEntry->metaState, motionEntry->buttonState,  
  48.                     xOffset, yOffset,  
  49.                     motionEntry->xPrecision, motionEntry->yPrecision,  
  50.                     motionEntry->downTime, motionEntry->eventTime,  
  51.                     motionEntry->pointerCount, motionEntry->pointerProperties,  
  52.                     usingCoords);  
  53.             break;  
  54.         }  
  55.   
  56.         default:  
  57.             ALOG_ASSERT(false);  
  58.             return;  
  59.         }  
  60.   
  61.         // Re-enqueue the event on the wait queue.  
  62.         connection->outboundQueue.dequeue(dispatchEntry);  
  63.         traceOutboundQueueLengthLocked(connection);  
  64.         connection->waitQueue.enqueueAtTail(dispatchEntry);  
  65.         traceWaitQueueLengthLocked(connection);  
  66.     }  
  67. }  

在startDispatchCycleLocked函数中调用inputPublisher的publishMotionEvent将这次触摸事件发送出去，并把dispatchEntry从outboundQueue中移除并添加到waitQueue中。inputPublisher的publishMotionEvent方法最终会调用到InputChannel的sendMessage方法通过socket发送给client端。到这里InputReader和InputDispatcher就成功了处理了一次input事件，并通过InputChannel发送给了client端。

还记得我们前面注册一个monitor的InputChannel吗？这里发送了一个触摸事件，我们来看client如何接受消息，因为在NativeInputEventReceiver的initialize函数中，我们通过Looper的addFd讲client端的InputChannel绑定到了epoll_wait中，当server端发送数据后，就会调用handleEvent来处理：
[cpp] view plain copy
  1. int NativeInputEventReceiver::handleEvent(int receiveFd, int events, void* data) {  
  2.     if (events & ALOOPER_EVENT_INPUT) {  
  3.         JNIEnv* env = AndroidRuntime::getJNIEnv();  
  4.         status_t status = consumeEvents(env, false /*consumeBatches*/, -1);  
  5.         mMessageQueue->raiseAndClearException(env, "handleReceiveCallback");  
  6.         return status == OK || status == NO_MEMORY ? 1 : 0;  
  7.     }  
  8. }  
  9.   
  10. status_t NativeInputEventReceiver::consumeEvents(JNIEnv* env,  
  11.         bool consumeBatches, nsecs_t frameTime) {  
  12.     ScopedLocalRef<jobject> receiverObj(env, NULL);  
  13.     bool skipCallbacks = false;  
  14.     for (;;) {  
  15.         uint32_t seq;  
  16.         InputEvent* inputEvent;  
  17.         status_t status = mInputConsumer.consume(&mInputEventFactory,  
  18.                 consumeBatches, frameTime, &seq, &inputEvent);  
  19.         if (!skipCallbacks) {  
  20.             if (!receiverObj.get()) {  
  21.                 receiverObj.reset(jniGetReferent(env, mReceiverWeakGlobal));  
  22.             }  
  23.   
  24.             jobject inputEventObj;  
  25.             switch (inputEvent->getType()) {  
  26.   
  27.             case AINPUT_EVENT_TYPE_MOTION:  
  28.                 inputEventObj = android_view_MotionEvent_obtainAsCopy(env,  
  29.                         static_cast<MotionEvent*>(inputEvent));  
  30.                 break;  
  31.   
  32.             default:  
  33.                 assert(false); // InputConsumer should prevent this from ever happening  
  34.                 inputEventObj = NULL;  
  35.             }  
  36.   
  37.             if (inputEventObj) {  
  38.                 env->CallVoidMethod(receiverObj.get(),  
  39.                         gInputEventReceiverClassInfo.dispatchInputEvent, seq, inputEventObj);  
  40.                 if (env->ExceptionCheck()) {  
  41.   
  42.                 }  
  43.                 env->DeleteLocalRef(inputEventObj);  
  44.             } else {  
  45.   
  46.             }  
  47.         }  
  48.     }  
  49. }  

在handleEvent调用consumeEvents来消化这个event事件，consumeEvents首先调用InputConsumer的consume方法去获取这次触摸事件到InputEvent中：
[cpp] view plain copy
  1. status_t InputConsumer::consume(InputEventFactoryInterface* factory,  
  2.         bool consumeBatches, nsecs_t frameTime, uint32_t* outSeq, InputEvent** outEvent) {  
  3.     *outSeq = 0;  
  4.     *outEvent = NULL;  
  5.   
  6.     while (!*outEvent) {  
  7.         if (mMsgDeferred) {  
  8.   
  9.         } else {  
  10.             status_t result = mChannel->receiveMessage(&mMsg);  
  11.         }  
  12.   
  13.         switch (mMsg.header.type) {  
  14.         case AINPUT_EVENT_TYPE_MOTION: {  
  15.             MotionEvent* motionEvent = factory->createMotionEvent();  
  16.             if (! motionEvent) return NO_MEMORY;  
  17.   
  18.             updateTouchState(&mMsg);  
  19.             initializeMotionEvent(motionEvent, &mMsg);  
  20.             *outSeq = mMsg.body.motion.seq;  
  21.             *outEvent = motionEvent;  
  22.             break;  
  23.         }  
  24.     }  
  25.     return OK;  
  26. }  
consume函数调用InputChannel的receiverMessage方法从socket中获取server端传输过来的msg，然后调用initializeMotionEvent去初始化一个MotionEvent并返回给consumeEvents函数。consumeEvents最终调用InputEventReceiver的dispatchInputEvent方法将此次触摸事件传递给Java层。
[cpp] view plain copy
  1. public void onInputEvent(InputEvent event) {  
  2.     try {  
  3.         if (event instanceof MotionEvent  
  4.                 && (event.getSource() & InputDevice.SOURCE_CLASS_POINTER) != 0) {  
  5.             final MotionEvent motionEvent = (MotionEvent)event;  
  6.             PointerEventListener[] listeners;  
  7.             synchronized (mListeners) {  
  8.                 if (mListenersArray == null) {  
  9.                     mListenersArray = new PointerEventListener[mListeners.size()];  
  10.                     mListeners.toArray(mListenersArray);  
  11.                 }  
  12.                 listeners = mListenersArray;  
  13.             }  
  14.             for (int i = 0; i < listeners.length; ++i) {  
  15.                 listeners[i].onPointerEvent(motionEvent);  
  16.             }  
  17.         }  
  18.     } finally {  
  19.         finishInputEvent(event, false);  
  20.     }  
  21. }  

PointerEventDispatcher继承于InputEventReceiver，在它的onInputEvent中会回调所有listeners的onPointerEvent方法，并调用finishInputEvent去通知InputDispatch这个消息有没有被处理：
[cpp] view plain copy
  1.     public final void finishInputEvent(InputEvent event, boolean handled) {  
  2.             int index = mSeqMap.indexOfKey(event.getSequenceNumber());  
  3.             if (index < 0) {  
  4.             } else {  
  5.                 int seq = mSeqMap.valueAt(index);  
  6.                 mSeqMap.removeAt(index);  
  7.                 nativeFinishInputEvent(mReceiverPtr, seq, handled);  
  8.             }  
  9.         event.recycleIfNeededAfterDispatch();  
  10.     }  
  11.   
  12. static void nativeFinishInputEvent(JNIEnv* env, jclass clazz, jint receiverPtr,  
  13.         jint seq, jboolean handled) {  
  14.     sp<NativeInputEventReceiver> receiver =  
  15.             reinterpret_cast<NativeInputEventReceiver*>(receiverPtr);  
  16.     status_t status = receiver->finishInputEvent(seq, handled);  
  17.     if (status && status != DEAD_OBJECT) {  
  18.   
  19.     }  
  20. }  

这里通过JNI调用到NativeInputEventReceiver的finishInputEvent方法：
[cpp] view plain copy
  1. status_t NativeInputEventReceiver::finishInputEvent(uint32_t seq, bool handled) {  
  2.     status_t status = mInputConsumer.sendFinishedSignal(seq, handled);  
  3.     return status;  
  4. }  
  5.   
  6. status_t InputConsumer::sendFinishedSignal(uint32_t seq, bool handled) {  
  7.     size_t seqChainCount = mSeqChains.size();  
  8.     if (seqChainCount) {  
  9.   
  10.     }  
  11.     return sendUnchainedFinishedSignal(seq, handled);  
  12. }  
  13.   
  14. status_t InputConsumer::sendUnchainedFinishedSignal(uint32_t seq, bool handled) {  
  15.     InputMessage msg;  
  16.     msg.header.type = InputMessage::TYPE_FINISHED;  
  17.     msg.body.finished.seq = seq;  
  18.     msg.body.finished.handled = handled;  
  19.     return mChannel->sendMessage(&msg);  
  20. }  

这里最终会调用client端的InputChannel向server发送个一个InputMessage，用于通知InputDispatcher当前消息的处理结果，我们回到InputDihandleReceiveCallbackspatcher当中，来看它如何处理收到的处理结果：
[cpp] view plain copy
  1. int InputDispatcher::handleReceiveCallback(int fd, int events, void* data) {  
  2.     InputDispatcher* d = static_cast<InputDispatcher*>(data);  
  3.     { // acquire lock  
  4.         AutoMutex _l(d->mLock);  
  5.         ssize_t connectionIndex = d->mConnectionsByFd.indexOfKey(fd);  
  6.   
  7.         bool notify;  
  8.         sp<Connection> connection = d->mConnectionsByFd.valueAt(connectionIndex);  
  9.         if (!(events & (ALOOPER_EVENT_ERROR | ALOOPER_EVENT_HANGUP))) {  
  10.             nsecs_t currentTime = now();  
  11.             bool gotOne = false;  
  12.             status_t status;  
  13.             for (;;) {  
  14.                 uint32_t seq;  
  15.                 bool handled;  
  16.                 status = connection->inputPublisher.receiveFinishedSignal(&seq, &handled);  
  17.                 if (status) {  
  18.                     break;  
  19.                 }  
  20.                 d->finishDispatchCycleLocked(currentTime, connection, seq, handled);  
  21.                 gotOne = true;  
  22.             }  
  23.             if (gotOne) {  
  24.                 d->runCommandsLockedInterruptible();  
  25.                 if (status == WOULD_BLOCK) {  
  26.                     return 1;  
  27.                 }  
  28.             }  

handleReceiveCallback从InputChannel循环的读取消息，直到遇到WOULD_BLOCK的错误才退出。finishDispatchCycleLocked用于处理接收到的InputMessage：
[cpp] view plain copy
  1. void InputDispatcher::finishDispatchCycleLocked(nsecs_t currentTime,  
  2.         const sp<Connection>& connection, uint32_t seq, bool handled) {  
  3.     connection->inputPublisherBlocked = false;  
  4.   
  5.     // Notify other system components and prepare to start the next dispatch cycle.  
  6.     onDispatchCycleFinishedLocked(currentTime, connection, seq, handled);  
  7. }  
  8.   
  9. void InputDispatcher::onDispatchCycleFinishedLocked(  
  10.         nsecs_t currentTime, const sp<Connection>& connection, uint32_t seq, bool handled) {  
  11.     CommandEntry* commandEntry = postCommandLocked(  
  12.             & InputDispatcher::doDispatchCycleFinishedLockedInterruptible);  
  13.     commandEntry->connection = connection;  
  14.     commandEntry->eventTime = currentTime;  
  15.     commandEntry->seq = seq;  
  16.     commandEntry->handled = handled;  
  17. }  

这里向mCommandQueue中post一个doDispatchCycleFinishedLockedInterruptible消息。回到handleReceiveCallback中，后面会调用runCommandsLockedInterruptible来执行这个消息：

[cpp] view plain copy
  1. void InputDispatcher::doDispatchCycleFinishedLockedInterruptible(  
  2.         CommandEntry* commandEntry) {  
  3.     sp<Connection> connection = commandEntry->connection;  
  4.     nsecs_t finishTime = commandEntry->eventTime;  
  5.     uint32_t seq = commandEntry->seq;  
  6.     bool handled = commandEntry->handled;  
  7.   
  8.     DispatchEntry* dispatchEntry = connection->findWaitQueueEntry(seq);  
  9.     if (dispatchEntry) {  
  10.         nsecs_t eventDuration = finishTime - dispatchEntry->deliveryTime;  
  11.   
  12.         bool restartEvent;  
  13.         if (dispatchEntry->eventEntry->type == EventEntry::TYPE_KEY) {  
  14.   
  15.         } else if (dispatchEntry->eventEntry->type == EventEntry::TYPE_MOTION) {  
  16.             MotionEntry* motionEntry = static_cast<MotionEntry*>(dispatchEntry->eventEntry);  
  17.             restartEvent = afterMotionEventLockedInterruptible(connection,  
  18.                     dispatchEntry, motionEntry, handled);  
  19.         } else {  
  20.         }  
  21.   
  22.         if (dispatchEntry == connection->findWaitQueueEntry(seq)) {  
  23.             connection->waitQueue.dequeue(dispatchEntry);  
  24.             traceWaitQueueLengthLocked(connection);  
  25.             if (restartEvent && connection->status == Connection::STATUS_NORMAL) {  
  26.   
  27.             } else {  
  28.                 releaseDispatchEntryLocked(dispatchEntry);  
  29.             }  
  30.         }  
  31.   
  32.         // Start the next dispatch cycle for this connection.  
  33.         startDispatchCycleLocked(now(), connection);  
  34.     }  
  35. }  

doDispatchCycleFinishedLockedInterruptible首先从connection的waitQueue中移除前面发送过程中添加进去的InputEvent，然后调用startDispatchCycleLocked接着发送connection的outboundQueue中的InputEvent。

Keyboard事件的分发

这里以按一次power键为例来介绍keyboard事件的处理以及分发，以下是按下和松开power键时从EventHub获取到的RawEvent：
按下：
Input event: device=1 type=0x0001 code=0x0074 value=0x00000001 when=97560822148000
Input event: device=1 type=0x0000 code=0x0000 value=0x00000000 when=97560822161000

松开：
Input event: device=1 type=0x0001 code=0x0074 value=0x00000000 when=97560974224000
Input event: device=1 type=0x0000 code=0x0000 value=0x00000000 when=97560974234000

还是从processEventsLocked处理的代码开始分析：
[cpp] view plain copy
  1. void InputReader::processEventsForDeviceLocked(int32_t deviceId,  
  2.         const RawEvent* rawEvents, size_t count) {  
  3.     ssize_t deviceIndex = mDevices.indexOfKey(deviceId);  
  4.     if (deviceIndex < 0) {  
  5.         ALOGW("Discarding event for unknown deviceId %d.", deviceId);  
  6.         return;  
  7.     }  
  8.   
  9.     InputDevice* device = mDevices.valueAt(deviceIndex);  
  10.     if (device->isIgnored()) {  
  11.         //ALOGD("Discarding event for ignored deviceId %d.", deviceId);  
  12.         return;  
  13.     }  
  14.   
  15.     device->process(rawEvents, count);  
  16. }  

这里主要调用首先通过deviceId找到对象的InputDevice，然后调用InputDevice的process方法：
[cpp] view plain copy
  1. void InputDevice::process(const RawEvent* rawEvents, size_t count) {  
  2.     size_t numMappers = mMappers.size();  
  3.     for (const RawEvent* rawEvent = rawEvents; count--; rawEvent++) {  
  4.         if (mDropUntilNextSync) {  
  5.   
  6.         } else if (rawEvent->type == EV_SYN && rawEvent->code == SYN_DROPPED) {  
  7.   
  8.         } else {  
  9.             for (size_t i = 0; i < numMappers; i++) {  
  10.                 InputMapper* mapper = mMappers[i];  
  11.                 mapper->process(rawEvent);  
  12.             }  
  13.         }  
  14.     }  
  15. }  

因为当前InputDevice的class是Keyboard，所以这里就会调用KeyboardInputMapper的process来处理：
[cpp] view plain copy
  1. void KeyboardInputMapper::process(const RawEvent* rawEvent) {  
  2.     switch (rawEvent->type) {  
  3.     case EV_KEY: {  
  4.         int32_t scanCode = rawEvent->code;  
  5.         int32_t usageCode = mCurrentHidUsage;  
  6.         mCurrentHidUsage = 0;  
  7.   
  8.         if (isKeyboardOrGamepadKey(scanCode)) {  
  9.             int32_t keyCode;  
  10.             uint32_t flags;  
  11.             if (getEventHub()->mapKey(getDeviceId(), scanCode, usageCode, &keyCode, &flags)) {  
  12.                 keyCode = AKEYCODE_UNKNOWN;  
  13.                 flags = 0;  
  14.             }  
  15.             processKey(rawEvent->when, rawEvent->value != 0, keyCode, scanCode, flags);  
  16.         }  
  17.         break;  
  18.     }  
  19.     case EV_MSC: {  
  20.         if (rawEvent->code == MSC_SCAN) {  
  21.             mCurrentHidUsage = rawEvent->value;  
  22.         }  
  23.         break;  
  24.     }  
  25.     case EV_SYN: {  
  26.         if (rawEvent->code == SYN_REPORT) {  
  27.             mCurrentHidUsage = 0;  
  28.         }  
  29.     }  
  30.     }  
  31. }  

这里首先调用当前Input设备的KeyCharacterMap和Keylayout文件去将RawEvent（Linux Key Code）转换为Android KeyCode。在隐射按键时，会经历两次转换：

1.将Linux Key Code通过.kcm或者.kl文件转换为Android KeyCode标签码
2.通过KeycodeLabel将Android KeyCode标签码转换为Android KeyCode

[cpp] view plain copy
  1. status_t EventHub::mapKey(int32_t deviceId, int32_t scanCode, int32_t usageCode,  
  2.         int32_t* outKeycode, uint32_t* outFlags) const {  
  3.     AutoMutex _l(mLock);  
  4.     Device* device = getDeviceLocked(deviceId);  
  5.   
  6.     if (device) {  
  7.         // Check the key character map first.  
  8.         sp<KeyCharacterMap> kcm = device->getKeyCharacterMap();  
  9.         if (kcm != NULL) {  
  10.             if (!kcm->mapKey(scanCode, usageCode, outKeycode)) {  
  11.                 *outFlags = 0;  
  12.                 return NO_ERROR;  
  13.             }  
  14.         }  
  15.   
  16.         // Check the key layout next.  
  17.         if (device->keyMap.haveKeyLayout()) {  
  18.             if (!device->keyMap.keyLayoutMap->mapKey(  
  19.                     scanCode, usageCode, outKeycode, outFlags)) {  
  20.                 return NO_ERROR;  
  21.             }  
  22.         }  
  23.     }  
  24.   
  25.     *outKeycode = 0;  
  26.     *outFlags = 0;  
  27.     return NAME_NOT_FOUND;  
  28. }  

从mapKey的实现来看，首先调用KeyCharacterMap去隐射按键，如果没有隐射成功，就再调用Keylayout去隐射按键。从上面的RawEvent的code=0x0074，我们可以从Generic.kl中看到：
[html] view plain copy
  1. key 116   POWER             WAKE   

然后在KeycodeLabel中可以看到：
[html] view plain copy
  1. { "POWER", 26 },  

所以KeyboardInputMapper的process中的keyCode就是26。接着调用processKey来处理：
[cpp] view plain copy
  1. void KeyboardInputMapper::processKey(nsecs_t when, bool down, int32_t keyCode,  
  2.         int32_t scanCode, uint32_t policyFlags) {  
  3.   
  4.     if (down) {  
  5.         if (mParameters.orientationAware && mParameters.hasAssociatedDisplay) {  
  6.             keyCode = rotateKeyCode(keyCode, mOrientation);  
  7.         }  
  8.   
  9.         // Add key down.  
  10.         ssize_t keyDownIndex = findKeyDown(scanCode);  
  11.         if (keyDownIndex >= 0) {  
  12.   
  13.         } else {  
  14.             // key down  
  15.             if ((policyFlags & POLICY_FLAG_VIRTUAL)  
  16.                     && mContext->shouldDropVirtualKey(when,  
  17.                             getDevice(), keyCode, scanCode)) {  
  18.                 return;  
  19.             }  
  20.   
  21.             mKeyDowns.push();  
  22.             KeyDown& keyDown = mKeyDowns.editTop();  
  23.             keyDown.keyCode = keyCode;  
  24.             keyDown.scanCode = scanCode;  
  25.         }  
  26.   
  27.         mDownTime = when;  
  28.     } else {  
  29.   
  30.     }  
  31.   
  32.     bool metaStateChanged = false;  
  33.     int32_t oldMetaState = mMetaState;  
  34.     int32_t newMetaState = updateMetaState(keyCode, down, oldMetaState);  
  35.     if (oldMetaState != newMetaState) {  
  36.         mMetaState = newMetaState;  
  37.         metaStateChanged = true;  
  38.         updateLedState(false);  
  39.     }  
  40.   
  41.     nsecs_t downTime = mDownTime;  
  42.     if (down && getDevice()->isExternal()  
  43.             && !(policyFlags & (POLICY_FLAG_WAKE | POLICY_FLAG_WAKE_DROPPED))) {  
  44.         policyFlags |= POLICY_FLAG_WAKE_DROPPED;  
  45.     }  
  46.   
  47.     if (metaStateChanged) {  
  48.         getContext()->updateGlobalMetaState();  
  49.     }  
  50.   
  51.     if (down && !isMetaKey(keyCode)) {  
  52.         getContext()->fadePointer();  
  53.     }  
  54.   
  55.     NotifyKeyArgs args(when, getDeviceId(), mSource, policyFlags,  
  56.             down ? AKEY_EVENT_ACTION_DOWN : AKEY_EVENT_ACTION_UP,  
  57.             AKEY_EVENT_FLAG_FROM_SYSTEM, keyCode, scanCode, newMetaState, downTime);  
  58.     getListener()->notifyKey(&args);  
  59. }  

processKey根据是按下还是松开分开处理，我们首先来看按下的处理流程：首先构造一个KeyDown对象，并填充它的keyCode和scanCode值。然后向InputDispatch通知AKEY_EVENT_ACTION_DOWN事件：
[cpp] view plain copy
  1. void InputDispatcher::notifyKey(const NotifyKeyArgs* args) {  
  2.     uint32_t policyFlags = args->policyFlags;  
  3.     int32_t flags = args->flags;  
  4.     int32_t metaState = args->metaState;  
  5.     if ((policyFlags & POLICY_FLAG_VIRTUAL) || (flags & AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY)) {  
  6.         policyFlags |= POLICY_FLAG_VIRTUAL;  
  7.         flags |= AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY;  
  8.     }  
  9.   
  10.     policyFlags |= POLICY_FLAG_TRUSTED;  
  11.   
  12.     KeyEvent event;  
  13.     event.initialize(args->deviceId, args->source, args->action,  
  14.             flags, args->keyCode, args->scanCode, metaState, 0,  
  15.             args->downTime, args->eventTime);  
  16.   
  17.     mPolicy->interceptKeyBeforeQueueing(&event, /*byref*/ policyFlags);  
  18.   
  19.     if (policyFlags & POLICY_FLAG_WOKE_HERE) {  
  20.         flags |= AKEY_EVENT_FLAG_WOKE_HERE;  
  21.     }  
  22.   
  23.     bool needWake;  
  24.     { // acquire lock  
  25.         mLock.lock();  
  26.   
  27.         if (shouldSendKeyToInputFilterLocked(args)) {  
  28.             mLock.unlock();  
  29.   
  30.             policyFlags |= POLICY_FLAG_FILTERED;  
  31.             if (!mPolicy->filterInputEvent(&event, policyFlags)) {  
  32.                 return; // event was consumed by the filter  
  33.             }  
  34.   
  35.             mLock.lock();  
  36.         }  
  37.   
  38.         int32_t repeatCount = 0;  
  39.         KeyEntry* newEntry = new KeyEntry(args->eventTime,  
  40.                 args->deviceId, args->source, policyFlags,  
  41.                 args->action, flags, args->keyCode, args->scanCode,  
  42.                 metaState, repeatCount, args->downTime);  
  43.   
  44.         needWake = enqueueInboundEventLocked(newEntry);  
  45.         mLock.unlock();  
  46.     } // release lock  
  47.   
  48.     if (needWake) {  
  49.         mLooper->wake();  
  50.     }  
  51. }  

notifyKey函数中首先调用NativeInputManager的interceptKeyBeforeQueueing做提前处理，这里主要是截取一些系统key发送给相应的service处理（例如power key）。然后再构造KeyEntry对象并添加到mInboundQueue中：
[cpp] view plain copy
  1. void NativeInputManager::interceptKeyBeforeQueueing(const KeyEvent* keyEvent,  
  2.         uint32_t& policyFlags) {  
  3.     if ((policyFlags & POLICY_FLAG_TRUSTED)) {  
  4.         nsecs_t when = keyEvent->getEventTime();  
  5.         bool isScreenOn = this->isScreenOn();  
  6.         bool isScreenBright = this->isScreenBright();  
  7.   
  8.         JNIEnv* env = jniEnv();  
  9.         jobject keyEventObj = android_view_KeyEvent_fromNative(env, keyEvent);  
  10.         jint wmActions;  
  11.         if (keyEventObj) {  
  12.             wmActions = env->CallIntMethod(mServiceObj,  
  13.                     gServiceClassInfo.interceptKeyBeforeQueueing,  
  14.                     keyEventObj, policyFlags, isScreenOn);  
  15.             if (checkAndClearExceptionFromCallback(env, "interceptKeyBeforeQueueing")) {  
  16.                 wmActions = 0;  
  17.             }  
  18.             android_view_KeyEvent_recycle(env, keyEventObj);  
  19.             env->DeleteLocalRef(keyEventObj);  
  20.         } else {  
  21.   
  22.         }  
  23.   
  24.         if (!(policyFlags & POLICY_FLAG_INJECTED)) {  
  25.             if (!isScreenOn) {  
  26.                 policyFlags |= POLICY_FLAG_WOKE_HERE;  
  27.             }  
  28.   
  29.             if (!isScreenBright) {  
  30.                 policyFlags |= POLICY_FLAG_BRIGHT_HERE;  
  31.             }  
  32.         }  
  33.   
  34.         handleInterceptActions(wmActions, when, /*byref*/ policyFlags);  
  35.     } else {  
  36.         policyFlags |= POLICY_FLAG_PASS_TO_USER;  
  37.     }  
  38. }  

interceptKeyBeforeQueueing首先通过Native的KeyEvent对象构造一个Java层的KeyEvent对象，然后调用InputManagerService的interceptKeyBeforeQueueing去通知WMS相应的input事件：

[java] view plain copy
  1. private int interceptKeyBeforeQueueing(KeyEvent event, int policyFlags, boolean isScreenOn) {  
  2.     return mWindowManagerCallbacks.interceptKeyBeforeQueueing(  
  3.             event, policyFlags, isScreenOn);  
  4. }  
  5.   
  6. public int interceptKeyBeforeQueueing(  
  7.         KeyEvent event, int policyFlags, boolean isScreenOn) {  
  8.     return mService.mPolicy.interceptKeyBeforeQueueing(event, policyFlags, isScreenOn);  
  9. }  

这里的mService.mPolicy是一个PhoneWindowManager对象，我们来看它的interceptKeyBeforeQueueing方法：
[java] view plain copy
  1. public int interceptKeyBeforeQueueing(KeyEvent event, int policyFlags, boolean isScreenOn) {  
  2.     final boolean down = event.getAction() == KeyEvent.ACTION_DOWN;  
  3.     final boolean canceled = event.isCanceled();  
  4.     final int keyCode = event.getKeyCode();  
  5.   
  6.     final boolean isInjected = (policyFlags & WindowManagerPolicy.FLAG_INJECTED) != 0;  
  7.   
  8.     if (keyCode == KeyEvent.KEYCODE_POWER) {  
  9.         policyFlags |= WindowManagerPolicy.FLAG_WAKE;  
  10.     }  
  11.     final boolean isWakeKey = (policyFlags & (WindowManagerPolicy.FLAG_WAKE  
  12.             | WindowManagerPolicy.FLAG_WAKE_DROPPED)) != 0;  
  13.   
  14.     int result;  
  15.     if ((isScreenOn && !mHeadless) || (isInjected && !isWakeKey)) {  
  16.         result = ACTION_PASS_TO_USER;  
  17.     } else {  
  18.         result = 0;  
  19.         if (down && isWakeKey && isWakeKeyWhenScreenOff(keyCode)) {  
  20.             result |= ACTION_WAKE_UP;  
  21.         }  
  22.     }  
  23.   
  24.     switch (keyCode) {  
  25.         case KeyEvent.KEYCODE_POWER: {  
  26.             result &= ~ACTION_PASS_TO_USER;  
  27.             if (down) {  
  28.   
  29.             }  
  30.             else {  
  31.                 if (interceptPowerKeyUp(canceled || mPendingPowerKeyUpCanceled)) {  
  32.                     result = (result & ~ACTION_WAKE_UP) | ACTION_GO_TO_SLEEP;  
  33.                 }  
  34.                 mPendingPowerKeyUpCanceled = false;  
  35.             }  
  36.             break;  
  37.         }  
  38.     return result;  
  39. }  



这里需要注意的是，对于power key，如果当前不处于screen on会设置ACTION_WAKE_UP；如果当前处于screen on，在power key松开时会设置ACTION_GO_TO_SLEEP；并且result在不会存在ACTION_PASS_TO_USER这个flag，这个flag表示是否需要将这个event上传给用户。回到NativeInputManager的interceptKeyBeforeQueueing，最后调用handleInterceptActions来处理：
[java] view plain copy
  1. void NativeInputManager::handleInterceptActions(jint wmActions, nsecs_t when,  
  2.         uint32_t& policyFlags) {  
  3.     if (wmActions & WM_ACTION_GO_TO_SLEEP) {  
  4.         android_server_PowerManagerService_goToSleep(when);  
  5.     }  
  6.   
  7.     if (wmActions & WM_ACTION_WAKE_UP) {  
  8.         android_server_PowerManagerService_wakeUp(when);  
  9.     }  
  10.   
  11.     if (wmActions & WM_ACTION_PASS_TO_USER) {  
  12.         policyFlags |= POLICY_FLAG_PASS_TO_USER;  
  13.     } else {  
  14.   
  15.     }  
  16. }  

这里会根据PhoneWindowManager的处理结果wmActions来设置来调用不同的处理函数。假设这是处于黑屏状态，就会调用android_server_PowerManagerService_wakeUp去调用PowerManagerService去点亮屏幕；如果当前是screen on状态，这里会调用android_server_PowerManagerService_goToSleep去让手机待机。关于PMS的这两个函数，我们这里就不介绍了。

当dispatchOnceInnerLocked从mInboundQueue取出这个KeyEntry后，会判断它的policyFlags中没有POLICY_FLAG_PASS_TO_USER这个flag，就会把这个event丢弃掉。到这里power key的按下流程就介绍完了。

相关推荐