Android应用程序键盘（Keyboard）消息处理机制分析（17）

  Step 11. InputDispatcher.dispatchOnceInnerLocked

        这个函数定义在frameworks/base/libs/ui/InputDispatcher.cpp文件中：

1. void InputDispatcher::dispatchOnceInnerLocked(nsecs_t keyRepeatTimeout,  
2.     nsecs_t keyRepeatDelay, nsecs_t* nextWakeupTime) {  
3.     ......  
4.   
5.     // Ready to start a new event.  
6.     // If we don't already have a pending event, go grab one.  
7.     if (! mPendingEvent) {  
8.         if (mInboundQueue.isEmpty()) {  
9.             ......  
10.         } else {  
11.             // Inbound queue has at least one entry.  
12.             EventEntry* entry = mInboundQueue.headSentinel.next;  
13.   
14.             ......  
15.   
16.             mInboundQueue.dequeue(entry);  
17.             mPendingEvent = entry;  
18.         }  
19.   
20.         ......  
21.     }  
22.   
23.     ......  
24.   
25.     switch (mPendingEvent->type) {  
26.     ......  
27.   
28.     case EventEntry::TYPE_KEY: {  
29.         KeyEntry* typedEntry = static_cast<KeyEntry*>(mPendingEvent);  
30.         ......  
31.         done = dispatchKeyLocked(currentTime, typedEntry, keyRepeatTimeout,  
32.             &dropReason, nextWakeupTime);  
33.         break;  
34.                                }  
35.   
36.     ......  
37.     }  
38.   
39.     ......  
40. }  

        我们忽略了这个函数的次要逻辑，主要关注键盘事件的主要处理流程。首先，如果前面发生的键盘事件都已经处理完毕，那么这里的mPendingEvent就为NULL，又因为前面我们把刚刚发生的键盘事件加入了mInboundQueue队列，因此，这里mInboundQueue不为NULL，于是，这里就把mInboundQueue队列中的键盘事件取出来，放在mPendingEvent变量中：

1. mInboundQueue.dequeue(entry);  
2. mPendingEvent = entry;  

        由于这里发生的是键盘事件，即mPendingEvent->type的值为EventEntry::TYPE_KEY，于是，在接下来的switch语句中就会执行dispatchKeyLocked函数来分发键盘消息。

 

        Step 12. InputDispatcher.dispatchKeyLocked

        这个函数定义在frameworks/base/libs/ui/InputDispatcher.cpp文件中：

1. bool InputDispatcher::dispatchKeyLocked(  
2.         nsecs_t currentTime, KeyEntry* entry, nsecs_t keyRepeatTimeout,  
3.         DropReason* dropReason, nsecs_t* nextWakeupTime) {  
4.     ......  
5.   
6.     // Identify targets.  
7.     if (! mCurrentInputTargetsValid) {  
8.         int32_t injectionResult = findFocusedWindowTargetsLocked(currentTime,  
9.             entry, nextWakeupTime);  
10.   
11.         ......  
12.     }  
13.   
14.     // Dispatch the key.  
15.     dispatchEventToCurrentInputTargetsLocked(currentTime, entry, false);  
16.     return true;  
17. }  

         InputDispatcher类中的mCurrentInputTargetsValid成员变量表示InputDispatcher是否已经标志出谁是当前激活的Activity窗口，如果没有，就需要通过findFocusedWindowTargetsLocked函数来把它找出来。当把当前激活的Activity窗口找出来以后，接下来就调用dispatchEventToCurrentInputTargetsLocked函数把键盘事件分发给它了。

 

        我们先来看一InputDispatcher是如何找到当前激活的Activity窗口的，然后再分析它把键盘事件分发给当前激活Activity窗口的过程。

        Step 13. InputDispatcher.findFocusedWindowTargetsLocked

        这个函数定义在frameworks/base/libs/ui/InputDispatcher.cpp文件中：

1. int32_t InputDispatcher::findFocusedWindowTargetsLocked(nsecs_t currentTime,  
2.         const EventEntry* entry, nsecs_t* nextWakeupTime) {  
3.     mCurrentInputTargets.clear();  
4.   
5.     int32_t injectionResult;  
6.   
7.     // If there is no currently focused window and no focused application  
8.     // then drop the event.  
9.     if (! mFocusedWindow) {  
10.         if (mFocusedApplication) {  
11.             ......  
12.             injectionResult = handleTargetsNotReadyLocked(currentTime, entry,  
13.                 mFocusedApplication, NULL, nextWakeupTime);  
14.             goto Unresponsive;  
15.         }  
16.   
17.         ......  
18.         injectionResult = INPUT_EVENT_INJECTION_FAILED;  
19.         goto Failed;  
20.     }  
21.   
22.     // Check permissions.  
23.     if (! checkInjectionPermission(mFocusedWindow, entry->injectionState)) {  
24.         injectionResult = INPUT_EVENT_INJECTION_PERMISSION_DENIED;  
25.         goto Failed;  
26.     }  
27.   
28.     // If the currently focused window is paused then keep waiting.  
29.     if (mFocusedWindow->paused) {  
30.         ......  
31.         injectionResult = handleTargetsNotReadyLocked(currentTime, entry,  
32.             mFocusedApplication, mFocusedWindow, nextWakeupTime);  
33.         goto Unresponsive;  
34.     }  
35.   
36.     // If the currently focused window is still working on previous events then keep waiting.  
37.     if (! isWindowFinishedWithPreviousInputLocked(mFocusedWindow)) {  
38.         ......  
39.         injectionResult = handleTargetsNotReadyLocked(currentTime, entry,  
40.             mFocusedApplication, mFocusedWindow, nextWakeupTime);  
41.         goto Unresponsive;  
42.     }  
43.   
44.     // Success!  Output targets.  
45.     injectionResult = INPUT_EVENT_INJECTION_SUCCEEDED;  
46.     addWindowTargetLocked(mFocusedWindow, InputTarget::FLAG_FOREGROUND, BitSet32(0));  
47.   
48.     ......  
49.   
50.     return injectionResult;  
51. }  

        回忆前面我们分析应用程序注册键盘消息接收通道的过程时，在Step 9中，当前处于激活状态的应用程序会通过调用InputDispatcher类setInputWindows函数把把当前获得焦点的Activity窗口设置到mFocusedWindow中去，因此，这里的mFocusedWindow不为NULL，于是，就通过了第一个if语句的检查。

 

        第二个if语句检查权限问题，原来，这个键盘事件除了是由硬件触发的外，也可以由其它进程注入进来的，如果这个键盘事件是由其它进程注入进来的，那么entry->injectState就不为NULL，它里面包含了事件注册者的进程ID和用户ID，于是，这里就会调用checkInjectionPermission来检查这个事件注入者的进程ID和用户ID，看看它是否具有这个权限。这里我们不考虑这种情况，因此，这里的entry->injectState为NULL，于是，这个if语句的检查也通过了。

        第三个if语句检查当前激活的Activity窗口是否是处于paused状态，如果是的话，也不用进一步处理了。一般情况下，当前激活的Activity窗口都是处于resumed状态的，于是，这个if语句的检查也通过了。

        第四个if语句检查当前激活的Activity窗口是否还正在处理前一个键盘事件，如果是的话，那就要等待它处理完前一个键盘事件后再来处理新的键盘事件了。这里我们也假设当前激活的Activity窗口不是正在处理前面的键盘事件，因此，这个if语句的检查也通过了。

        最后，就调用addWindowTargetLocked函数把当前激活的Activity窗口添加到InputDispatcher类的mCurrentInputTargets成员变量中去。

        Step 14. InputDispatcher.addWindowTargetLocked

        这个函数定义在frameworks/base/libs/ui/InputDispatcher.cpp文件中：

1. void InputDispatcher::addWindowTargetLocked(const InputWindow* window, int32_t targetFlags,  
2.         BitSet32 pointerIds) {  
3.     mCurrentInputTargets.push();  
4.   
5.     InputTarget& target = mCurrentInputTargets.editTop();  
6.     target.inputChannel = window->inputChannel;  
7.     target.flags = targetFlags;  
8.     target.xOffset = - window->frameLeft;  
9.     target.yOffset = - window->frameTop;  
10.     target.pointerIds = pointerIds;  
11. }  

        这个函数简单，就是把传进来的参数window添加到mCurrentInputTargets中去就完事了，后面InputDispatcher就会从mCurrentInputTargets中取出恰当的Activity窗口，然后把键盘事件分发给它。

        回到Step 12中的dispatchKeyLocked函数，它接下来就调用dispatchEventToCurrentInputTargetsLocked来进一步处理了。

        Step 15. InputDispatcher.dispatchEventToCurrentInputTargetsLocked

        这个函数定义在frameworks/base/libs/ui/InputDispatcher.cpp文件中：

1. void InputDispatcher::dispatchEventToCurrentInputTargetsLocked(nsecs_t currentTime,  
2.         EventEntry* eventEntry, bool resumeWithAppendedMotionSample) {  
3.    ......  
4.   
5.    for (size_t i = 0; i < mCurrentInputTargets.size(); i++) {  
6.        const InputTarget& inputTarget = mCurrentInputTargets.itemAt(i);  
7.   
8.        ssize_t connectionIndex = getConnectionIndexLocked(inputTarget.inputChannel);  
9.        if (connectionIndex >= 0) {  
10.            sp<Connection> connection = mConnectionsByReceiveFd.valueAt(connectionIndex);  
11.            prepareDispatchCycleLocked(currentTime, connection, eventEntry, & inputTarget,  
12.                resumeWithAppendedMotionSample);  
13.        } else {  
14.            ......  
15.    }  
16. }  

        这个函数的实现也比较简单，前面我们已经把当前需要接受键盘事件的Activity窗口添加到mCurrentInputTargets中去了，因此，这里就分别把它们取出来，然后调用prepareDispatchCycleLocked函数把键盘事件分发给它们处理。

 

        前面我们在分析应用程序注册键盘消息接收通道的过程时，在Step 18中（InputDispatcher.registerInputChannel），把Server端的InputChannel封装成了一个Connection，然后以这个InputChannel中的Receive Pipe Fd作为键值把这个Connection对象保存在mConnectionsByReceiveFd中。这里，既然我们已经通过mCurrentInputTargets得到了表示当前需要接收键盘事件的Activity窗口的InputTarget对象，而且这个InputTarget对象的inputChannel就表示当初在InputDispatcher中注册的Server端InputChannel，因此，这里就可以把这个Connection对象取出来，最后调用prepareDispatchCycleLocked函数来进一步处理。