Android4.4Input模块笔记-创新互联

在InputReader从EventHub中获取输入事件，包含触摸屏事件、物理按键事件等，然后转交给InputDispatcher线程，InputDispatcher经过筛选，过滤输入事件。对于触摸事件通过调用findTouchedWindowTargetsLocked()函数找到合适的InputTarget，然后通过dispatchEventLocked()->prepareDispatchCycleLocked()->enqueueDispatchEntriesLocked()->enqueueDispatchEntryLocked()->  connection->outboundQueue.enqueueAtTail(dispatchEntry)添加到与InputTarget一一对应的connection中的一个队列中。如果之前该队列无数据，并且当前触摸事件已成功加入该队列，则继续调用startDispatchCycleLocked()函数进行分发处理。在startDispatchCycleLocked()中，有一个while循环，该循环从connection->outboundQueue队列中取出输入事件，如果该输入事件是按键（key）事件，则调用connection->inputPublisher.publishKeyEvent()函数，如果是触摸事件则调用connection->inputPublisher.publishMotionEvent（）。publishKeyEvent()和publishMotionEvent()都是调用mChannel->sendMessage()将输入事件发送出去。mChannel是一个C++层InputChannel对象，该对象的赋值过程如下：registerInputChannel()->new Connection->Connection()构造函数->InputPublisher()构造函数。事实上，在registerInputChannel()被调用之前，ViewRootImple在增加一个窗口时调用ViewRootImpl.setView()->mWindowSession.addToDisplay()-WindowManagerService.addWindow()，在addWindow()中会创建一对InputChannel（Nativie层），实际上是创建一对Socket，服务端InputChanel被WMS注册到InputDispatcher中，客户端InputChannel被返回给ViewRootImpl，ViewRootImpl将客户端InputChannel作为参数new一个InputEventReceiver对象，在InputEventReceiver()构造函数中继续调用nativeInit()函数来创建一个native层的NativeInputEventReceiver对象，前面创建的客户端InputChannel会保存在该对象中。

成都创新互联公司是一家集网站建设,卓尼企业网站建设,卓尼品牌网站建设,网站定制,卓尼网站建设报价,网络营销,网络优化,卓尼网站推广为一体的创新建站企业，帮助传统企业提升企业形象加强企业竞争力。可充分满足这一群体相比中小企业更为丰富、高端、多元的互联网需求。同时我们时刻保持专业、时尚、前沿，时刻以成就客户成长自我，坚持不断学习、思考、沉淀、净化自己，让我们为更多的企业打造出实用型网站。

总结：WMS会调用native层接口创建一对套接字，服务端保存在InputDispatcher中，客户端保存在NativeInputEventReceiver中（android_view_inputEventReceiver.cpp）。

很容易想到输入事件是从InputDispatcher流向NativeInputEventReceiver中。在创建一个native层的NativeInputEventReceiver对象后会立即调用NativeInputEventReceiver->initialize()，该函数调用mMessageQueue->getLooper()->addFd(fd,0, events, this, NULL)将客户端socket句柄添加到Looper的轮询队列中，参数this指向NativeInputEventReceiver本身，意味着只要服务端InputDispatcher发送输入事件，客户端收到这个事件，就调用NativeInputEventReceiver的某个函数，具体调用哪个函数，自然是NativeInputEventReceiver实现了LooperCallback的接口函数handleEvent()。但此时收到的事件只是代表socket客户端有事件来，并没有把具体的事件读取出来，这点需要注意。

总结：客户端收到输入事件，即调用NativeInputEventReceiver->handleEvent()函数。

在handleEvent()函数中，继续调用consumeEvents()->mInputConsumer.consume()->mChannel->receiveMessage(&mMsg)将具体输入事件读取出来，然后调用env->CallVoidMethod(receiverObj.get(), gInputEventReceiverClassInfo.dispatchInputEvent,seq, inputEventObj)，可以知道native层读取输入事件后，然后会回调java层InputEventReceiver.java中的dispatchInputEvent()函数。事实上，

dispatchInputEvent继续调用onInputEvent(event); 此时可能并不调用InputEventReceiver类中的onInputEvent()方法，而是调用子类onInputEvent()方法。在 ViewRootImpl中存在WindowInputEventReceiver类型变量 mInputEventReceiver，WindowInputEventReceiver类继承InputEventReceiver，并实现 onInputEvent()方法由此可得出结论：native层socket客户端读取输入事件，最终调用InputEventReceiver类子类 的onInputEvent()方法，ViewRootImpl继承InputEventReceiver，因此 ViewRootImpl.onInputEvent()将被调用。

总结：对于一般的触摸屏事件最终处理者是ViewRootImpl类，对于输入法则处理者是IInputMethodSessionWrapper类，当然WMS是不会处理这些输入事件的。

继 续研究ViewRootImpl.onInputEvent()函 数，onInputEvent()->doProcessInputEvents()->deliverInputEvent()，deliverInputEvent() 函数中会调用stage.deliver(q)，stage是mFirstPostImeInputStage 或 mFirstInputStage，这个两个InputStage对象在setView中赋值。InputStage类设计就是责任链模式。因为触摸事件是要分发到具体的View上来，所以对于一般的触摸事件最后是传递到ViewPostImeInputStage类中来处理，处理函数是processPointerEvent(q)，这个函数调用mView.dispatchPointerEvent(event)将事件分发出去，mView具体是什么呢？mView其实就是DecorView，每一个窗口有且仅有一个DecorView，且处在最顶层，由于DecorView未重写dispatchPointerEvent()，所以调用还是父类View类的dispatchPointerEvent()方法。

[java] view plaincopy

1. public final boolean dispatchPointerEvent(MotionEvent event) {

2.         if (event.isTouchEvent()) {

3.             return dispatchTouchEvent(event);

4.         } else {

5.             return dispatchGenericMotionEvent(event);

6.         }

7.     }

该方法继续调用dispatchTouchEvent(event)，DecorView重新了该方法：

[java] view plaincopy

1. @Override

2.         public boolean dispatchTouchEvent(MotionEvent ev) {

3.             final Callback cb = getCallback();

4.             return cb != null && !isDestroyed() && mFeatureId < 0 ? cb.dispatchTouchEvent(ev)

5.                     : super.dispatchTouchEvent(ev);

6.         }

getCallback() 函数获取apk注册的用于拦截按键、触摸等事件的回调函数。一般window不会拦截处理触摸事件，所以会继续调用 super.dispatchTouchEvent(ev)，即父类ViewGroup的dispatchTouchEvent()函数，在该函数中寻找 到对应的View再继续调用dispatchTransformedTouchEvent()

[java] view plaincopy

1. for (int i = childrenCount - 1; i >= 0; i--) {

2.                           final int childIndex = customOrder ?

3.                                   getChildDrawingOrder(childrenCount, i) : i;

4.                           final View child = children[childIndex];

5.                           if (!canViewReceivePointerEvents(child)

6.                                   || !isTransformedTouchPointInView(x, y, child, null)) {

7.                               continue;

8.                           }

10.                           newTouchTarget = getTouchTarget(child);

11.                           if (newTouchTarget != null) {

12.                               // Child is already receiving touch within its bounds.

13.                               // Give it the new pointer in addition to the ones it is handling.

14.                               newTouchTarget.pointerIdBits |= idBitsToAssign;

15.                               break;

16.                           }

18.                           resetCancelNextUpFlag(child);

19.                           if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {

20.                               // Child wants to receive touch within its bounds.

21.                               mLastTouchDownTime = ev.getDownTime();

22.                               mLastTouchDownIndex = childIndex;

23.                               mLastTouchDownX = ev.getX();

24.                               mLastTouchDownY = ev.getY();

25.                               newTouchTarget = addTouchTarget(child, idBitsToAssign);

26.                               alreadyDispatchedToNewTouchTarget = true;

27.                               break;

28.                           }

具体的分发规则可自行研究代码。

ViewGroup.dispatchTouchEvent()函数分析

[html] view plaincopy

1. @Override

2. public boolean dispatchTouchEvent(MotionEvent ev) {

3.     if (mInputEventConsistencyVerifier != null) {

4.         mInputEventConsistencyVerifier.onTouchEvent(ev, 1);

5.     }

7.     if (DBG_MOTION || DBG_TOUCH) {

8.         Xlog.d(TAG, "(ViewGroup)dispatchTouchEvent 1: ev = " + ev + ",mFirstTouchTarget = "

9.                 + mFirstTouchTarget + ",this = " + this);

10.     }

12.     boolean handled = false;

13.     if (onFilterTouchEventForSecurity(ev)) {

14.         final int action = ev.getAction();

15.         final int actionMasked = action & MotionEvent.ACTION_MASK;

17.         // Handle an initial down.

18.         if (actionMasked == MotionEvent.ACTION_DOWN) {

19.             // Throw away all previous state when starting a new touch gesture.

20.             // The framework may have dropped the up or cancel event for the previous gesture

21.             // due to an app switch, ANR, or some other state change.

22.             cancelAndClearTouchTargets(ev);

23.             resetTouchState();

24.         }

26.         // Check for interception.

27.         final boolean intercepted;

28.         if (actionMasked == MotionEvent.ACTION_DOWN

29.                 || mFirstTouchTarget != null) {

30.             final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;

31.             if (!disallowIntercept) {

32.                 intercepted = onInterceptTouchEvent(ev);

33.                 /// M : add log to help debugging

34.                 if (intercepted == true) {

35.                     if (DBG_TOUCH) {

36.                         Xlog.d(TAG, "Touch event was intercepted event = " + ev + ",this = " + this);

37.                     }

38.                 }

39.                 ev.setAction(action); // restore action in case it was changed

40.             } else {

41.                 intercepted = false;

42.             }

43.         } else {

44.             // There are no touch targets and this action is not an initial down

45.             // so this view group continues to intercept touches.

46.             intercepted = true;

47.         }

49.         // Check for cancelation.

50.         final boolean canceled = resetCancelNextUpFlag(this)

51.                 || actionMasked == MotionEvent.ACTION_CANCEL;

53.         // Update list of touch targets for pointer down, if needed.

54.         final boolean split = (mGroupFlags & FLAG_SPLIT_MOTION_EVENTS) != 0;

55.         if (DBG_MOTION) {

56.             Xlog.d(TAG, "(ViewGroup)dispatchTouchEvent 2: actionMasked = " + actionMasked

57.                     + ",intercepted = " + intercepted + ",canceled = " + canceled + ",split = "

58.                     + split + ",mChildrenCount = " + mChildrenCount + ",mFirstTouchTarget = "

59.                     + mFirstTouchTarget + ",this = " + this);

60.         }

62.         TouchTarget newTouchTarget = null;

63.         boolean alreadyDispatchedToNewTouchTarget = false;

64.         if (!canceled && !intercepted) {

65.             if (actionMasked == MotionEvent.ACTION_DOWN

66.                     || (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN)

67.                     || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {

68.                 final int actionIndex = ev.getActionIndex(); // always 0 for down

69.                 final int idBitsToAssign = split ? 1 << ev.getPointerId(actionIndex)

70.                         : TouchTarget.ALL_POINTER_IDS;

72.                 // Clean up earlier touch targets for this pointer id in case they

73.                 // have become out of sync.

74.                 removePointersFromTouchTargets(idBitsToAssign);

76.                 final int childrenCount = mChildrenCount;

77.                 if (newTouchTarget == null && childrenCount != 0) {

78.                     final float x = ev.getX(actionIndex);

79.                     final float y = ev.getY(actionIndex);

80.                     // Find a child that can receive the event.

81.                     // Scan children from front to back.

82.                     final View[] children = mChildren;

84.                     final boolean customOrder = isChildrenDrawingOrderEnabled();

85.                     for (int i = childrenCount - 1; i >= 0; i--) {

86.                         final int childIndex = customOrder ?

87.                                 getChildDrawingOrder(childrenCount, i) : i;

88.                         final View child = children[childIndex];

89.                         if (!canViewReceivePointerEvents(child)

90.                                 || !isTransformedTouchPointInView(x, y, child, null)) {

91.                             if (DBG_MOTION) {

92.                                 Xlog.d(TAG, "(ViewGroup)dispatchTouchEvent continue 6: i = "

93.                                         + i + ",count = " + childrenCount + ",child = " + child

94.                                         + ",this = " + this);

95.                             }

96.                             continue;

97.                         }

99.                         newTouchTarget = getTouchTarget(child);

100.                         if (DBG_MOTION) {

101.                             Xlog.d(TAG, "(ViewGroup)dispatchTouchEvent to child 3: child = "

102.                                     + child + ",childrenCount = " + childrenCount + ",i = " + i

103.                                     + ",newTouchTarget = " + newTouchTarget + ",idBitsToAssign = "

104.                                     + idBitsToAssign + ",mFirstTouchTarget = " + mFirstTouchTarget

105.                                     + ",this = " + this);

106.                         }

107.                         if (newTouchTarget != null) {

108.                             // Child is already receiving touch within its bounds.

109.                             // Give it the new pointer in addition to the ones it is handling.

110.                             newTouchTarget.pointerIdBits |= idBitsToAssign;

111.                             break;

112.                         }

114.                         resetCancelNextUpFlag(child);

115.                         if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {

116.                             // Child wants to receive touch within its bounds.

117.                             mLastTouchDownTime = ev.getDownTime();

118.                             mLastTouchDownIndex = childIndex;

119.                             mLastTouchDownX = ev.getX();

120.                             mLastTouchDownY = ev.getY();

121.                             newTouchTarget = addTouchTarget(child, idBitsToAssign);

122.                             alreadyDispatchedToNewTouchTarget = true;

123.                             break;

124.                         }

125.                     }

126.                 }

128.                 if (newTouchTarget == null && mFirstTouchTarget != null) {

129.                     // Did not find a child to receive the event.

130.                     // Assign the pointer to the least recently added target.

131.                     newTouchTarget = mFirstTouchTarget;

132.                     while (newTouchTarget.next != null) {

133.                         newTouchTarget = newTouchTarget.next;

134.                     }

135.                     newTouchTarget.pointerIdBits |= idBitsToAssign;

136.                 }

137.             }

138.         }

140.         // Dispatch to touch targets.

141.         if (mFirstTouchTarget == null) {

142.             // No touch targets so treat this as an ordinary view.

143.             handled = dispatchTransformedTouchEvent(ev, canceled, null,

144.                     TouchTarget.ALL_POINTER_IDS);

145.         } else {

146.             // Dispatch to touch targets, excluding the new touch target if we already

147.             // dispatched to it.  Cancel touch targets if necessary.

148.             TouchTarget predecessor = null;

149.             TouchTarget target = mFirstTouchTarget;

150.             while (target != null) {

151.                 final TouchTarget next = target.next;

152.                 if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {

153.                     handled = true;

154.                 } else {

155.                     final boolean cancelChild = resetCancelNextUpFlag(target.child)

156.                             || intercepted;

157.                     if (dispatchTransformedTouchEvent(ev, cancelChild,

158.                             target.child, target.pointerIdBits)) {

159.                         handled = true;

160.                     }

161.                     if (DBG_MOTION) {

162.                         Xlog.d(TAG, "dispatchTouchEvent middle 5: cancelChild = " + cancelChild

163.                                 + ",mFirstTouchTarget = " + mFirstTouchTarget + ",target = "

164.                                 + target + ",predecessor = " + predecessor + ",next = " + next

165.                                 + ",this = " + this);

166.                     }

167.                     if (cancelChild) {

168.                         if (predecessor == null) {

169.                             mFirstTouchTarget = next;

170.                         } else {

171.                             predecessor.next = next;

172.                         }

173.                         target.recycle();

174.                         target = next;

175.                         continue;

176.                     }

177.                 }

178.                 predecessor = target;

179.                 target = next;

180.             }

181.         }

183.         // Update list of touch targets for pointer up or cancel, if needed.

184.         if (canceled

185.                 || actionMasked == MotionEvent.ACTION_UP

186.                 || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {

187.             resetTouchState();

188.         } else if (split && actionMasked == MotionEvent.ACTION_POINTER_UP) {

189.             final int actionIndex = ev.getActionIndex();

190.             final int idBitsToRemove = 1 << ev.getPointerId(actionIndex);

191.             removePointersFromTouchTargets(idBitsToRemove);

192.         }

193.     }

195.     if (DBG_MOTION) {

196.         Xlog.d(TAG, "(ViewGroup)dispatchTouchEvent end 4: handled = " + handled + ",mFirstTouchTarget = "

197.                 + mFirstTouchTarget + ",this = " + this);

198.     }

200.     if (!handled && mInputEventConsistencyVerifier != null) {

201.         mInputEventConsistencyVerifier.onUnhandledEvent(ev, 1);

202.     }

203.     return handled;

204. }

另外有需要云服务器可以了解下创新互联scvps.cn，海内外云服务器15元起步，三天无理由+7*72小时售后在线，公司持有idc许可证，提供“云服务器、裸金属服务器、高防服务器、香港服务器、美国服务器、虚拟主机、免备案服务器”等云主机租用服务以及企业上云的综合解决方案，具有“安全稳定、简单易用、服务可用性高、性价比高”等特点与优势，专为企业上云打造定制，能够满足用户丰富、多元化的应用场景需求。

新闻名称：Android4.4Input模块笔记-创新互联
分享链接：http://shouzuofang.com/article/dcgecd.html