一个是InputReader，一个是InputDispatcher。方法是dispatchTouch。

入口点是InputReader 的loopOnce方法.

InputReader里面有个线程叫做InputReaderThread，threadLoop

[code="java"]InputReaderThread::InputReaderThread(const sp& reader) :
Thread(/*canCallJava*/ true), mReader(reader) {
}

InputReaderThread::~InputReaderThread() {
}

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

Java代码
  1. voidInputDispatcher::dispatchOnce(){
  2. nsecs_tkeyRepeatTimeout=mPolicy->getKeyRepeatTimeout();
  3. nsecs_tkeyRepeatDelay=mPolicy->getKeyRepeatDelay();
  5. nsecs_tnextWakeupTime=LONG_LONG_MAX;
  6. {//acquirelock
  7. AutoMutex_l(mLock);
  8. dispatchOnceInnerLocked(keyRepeatTimeout,keyRepeatDelay,&nextWakeupTime);
  10. if(runCommandsLockedInterruptible()){
  11. nextWakeupTime=LONG_LONG_MIN;//forcenextpolltowakeupimmediately
  12. }
  13. }//releaselock
  15. //Waitforcallbackortimeoutorwake.(makesureweroundup,notdown)
  16. nsecs_tcurrentTime=now();
  17. int32_ttimeoutMillis;
  18. if(nextWakeupTime>currentTime){
  19. uint64_ttimeout=uint64_t(nextWakeupTime-currentTime);
  20. timeout=(timeout+999999LL)/1000000LL;
  21. timeoutMillis=timeout>INT_MAX?-1:int32_t(timeout);
  22. }else{
  23. timeoutMillis=0;
  24. }
  26. mLooper->pollOnce(timeoutMillis);
  27. }

Java代码
  1. caseEventEntry::TYPE_MOTION:{
  2. MotionEntry*typedEntry=static_cast<MotionEntry*>(mPendingEvent);
  3. if(dropReason==DROP_REASON_NOT_DROPPED&&isAppSwitchDue){
  4. dropReason=DROP_REASON_APP_SWITCH;
  5. }
  6. done=dispatchMotionLocked(currentTime,typedEntry,
  7. &dropReason,nextWakeupTime);
  8. break;

Java代码
  1. boolInputDispatcher::dispatchMotionLocked(
  2. nsecs_tcurrentTime,MotionEntry*entry,DropReason*dropReason,nsecs_t*nextWakeupTime){
  3. //Preprocessing.
  4. if(!entry->dispatchInProgress){
  5. entry->dispatchInProgress=true;
  6. resetTargetsLocked();
  8. logOutboundMotionDetailsLocked("dispatchMotion-",entry);
  9. }
  11. //Cleanupifdroppingtheevent.
  12. if(*dropReason!=DROP_REASON_NOT_DROPPED){
  13. resetTargetsLocked();
  14. setInjectionResultLocked(entry,*dropReason==DROP_REASON_POLICY
  15. ?INPUT_EVENT_INJECTION_SUCCEEDED:INPUT_EVENT_INJECTION_FAILED);
  16. returntrue;
  17. }
  19. boolisPointerEvent=entry->source&AINPUT_SOURCE_CLASS_POINTER;
  21. //Identifytargets.
  22. if(!mCurrentInputTargetsValid){
  23. int32_tinjectionResult;
  24. if(isPointerEvent){
  25. //Pointerevent.(eg.touchscreen)
  26. injectionResult=findTouchedWindowTargetsLocked(currentTime,
  27. entry,nextWakeupTime);
  28. }else{
  29. //Nontouchevent.(eg.trackball)
  30. injectionResult=findFocusedWindowTargetsLocked(currentTime,
  31. entry,nextWakeupTime);
  32. }
  33. if(injectionResult==INPUT_EVENT_INJECTION_PENDING){
  34. returnfalse;
  35. }
  37. setInjectionResultLocked(entry,injectionResult);
  38. if(injectionResult!=INPUT_EVENT_INJECTION_SUCCEEDED){
  39. returntrue;
  40. }
  42. addMonitoringTargetsLocked();
  43. commitTargetsLocked();
  44. }
  46. //Dispatchthemotion.
  47. dispatchEventToCurrentInputTargetsLocked(currentTime,entry,false);
  48. returntrue;
  49. }

Java代码
  1. startDispatchCycleLocked中的方法
  2. status=connection->inputPublisher.publishMotionEvent(motionEntry->deviceId,
  3. motionEntry->source,action,flags,motionEntry->edgeFlags,motionEntry->metaState,
  4. xOffset,yOffset,
  5. motionEntry->xPrecision,motionEntry->yPrecision,
  6. motionEntry->downTime,firstMotionSample->eventTime,
  7. motionEntry->pointerCount,motionEntry->pointerIds,
  8. firstMotionSample->pointerCoords);

Java代码
  1. ViewRoot有个InputHandler

Java代码
  1. privatefinalInputHandlermInputHandler=newInputHandler(){
  2. publicvoidhandleKey(KeyEventevent,RunnablefinishedCallback){
  3. startInputEvent(finishedCallback);
  4. dispatchKey(event,true);
  5. }
  7. publicvoidhandleMotion(MotionEventevent,RunnablefinishedCallback){
  8. startInputEvent(finishedCallback);
  9. dispatchMotion(event,true);
  10. }
  11. };

InputHandler注册给了系统

Java代码
  1. InputQueue.registerInputChannel(mInputChannel,mInputHandler,
  2. Looper.myQueue());

Java代码
  1. dispatchMotion(event,true);方法如下
  2. rivatevoiddispatchMotion(MotionEventevent,booleansendDone){
  3. intsource=event.getSource();
  4. if((source&InputDevice.SOURCE_CLASS_POINTER)!=0){
  5. dispatchPointer(event,sendDone);
  6. }elseif((source&InputDevice.SOURCE_CLASS_TRACKBALL)!=0){
  7. dispatchTrackball(event,sendDone);
  8. }else{
  9. //TODO
  10. Log.v(TAG,"Droppingunsupportedmotionevent(unimplemented):"+event);
  11. if(sendDone){
  12. finishInputEvent();
  13. }
  14. }
  15. }

调用了dispatchPointer

ViewRoot本身就是Handler直接sendMessageAtTime

然后就进入了View的焦点系统。

下面就说一下Activity的焦点是怎么回事。

Java代码
  1. InputDisapatcher.cpp中调用了如下方法
  3. dispatchEventToCurrentInputTargetsLocked(currentTime,motionEntry,
  4. true/*resumeWithAppendedMotionSample*/);

然后

Java代码
  1. dispatchEventToCurrentInputTargetsLocked

调用了如下方法

Java代码
  1. int32_tInputDispatcher::findFocusedWindowTargetsLocked(nsecs_tcurrentTime,
  2. constEventEntry*entry,nsecs_t*nextWakeupTime){
  3. mCurrentInputTargets.clear();
  5. int32_tinjectionResult;
  7. //Ifthereisnocurrentlyfocusedwindowandnofocusedapplication
  8. //thendroptheevent.
  9. if(!mFocusedWindow){
  10. if(mFocusedApplication){
  11. #ifDEBUG_FOCUS
  12. LOGD("Waitingbecausethereisnofocusedwindowbutthereisa"
  13. "focusedapplicationthatmayeventuallyaddawindow:%s.",
  14. getApplicationWindowLabelLocked(mFocusedApplication,NULL).string());
  15. #endif
  16. injectionResult=handleTargetsNotReadyLocked(currentTime,entry,
  17. mFocusedApplication,NULL,nextWakeupTime);
  18. gotoUnresponsive;
  19. }
  21. LOGI("Droppingeventbecausethereisnofocusedwindoworfocusedapplication.");
  22. injectionResult=INPUT_EVENT_INJECTION_FAILED;
  23. gotoFailed;
  24. }
  26. //Checkpermissions.
  27. if(!checkInjectionPermission(mFocusedWindow,entry->injectionState)){
  28. injectionResult=INPUT_EVENT_INJECTION_PERMISSION_DENIED;
  29. gotoFailed;
  30. }
  32. //Ifthecurrentlyfocusedwindowispausedthenkeepwaiting.
  33. if(mFocusedWindow->paused){
  34. #ifDEBUG_FOCUS
  35. LOGD("Waitingbecausefocusedwindowispaused.");
  36. #endif
  37. injectionResult=handleTargetsNotReadyLocked(currentTime,entry,
  38. mFocusedApplication,mFocusedWindow,nextWakeupTime);
  39. gotoUnresponsive;
  40. }
  42. //Ifthecurrentlyfocusedwindowisstillworkingonpreviouseventsthenkeepwaiting.
  43. if(!isWindowFinishedWithPreviousInputLocked(mFocusedWindow)){
  44. #ifDEBUG_FOCUS
  45. LOGD("Waitingbecausefocusedwindowstillprocessingpreviousinput.");
  46. #endif
  47. injectionResult=handleTargetsNotReadyLocked(currentTime,entry,
  48. mFocusedApplication,mFocusedWindow,nextWakeupTime);
  49. gotoUnresponsive;
  50. }
  52. //Success!Outputtargets.
  53. injectionResult=INPUT_EVENT_INJECTION_SUCCEEDED;
  54. addWindowTargetLocked(mFocusedWindow,InputTarget::FLAG_FOREGROUND,BitSet32(0));
  56. //Done.
  57. Failed:
  58. Unresponsive:
  59. nsecs_ttimeSpentWaitingForApplication=getTimeSpentWaitingForApplicationLocked(currentTime);
  60. updateDispatchStatisticsLocked(currentTime,entry,
  61. injectionResult,timeSpentWaitingForApplication);
  62. #ifDEBUG_FOCUS
  63. LOGD("findFocusedWindowfinished:injectionResult=%d,"
  64. "timeSpendWaitingForApplication=%0.1fms",
  65. injectionResult,timeSpentWaitingForApplication/1000000.0);
  66. #endif
  67. returninjectionResult;
  68. }

move事件的处理和Down事件的处理很不相同。

新建立的Window在处理焦点的时候，按下事件没有起来之前，保持了原来的焦点窗口。除非ACTION_UP事件收到以后

Java代码
  1. /*Updatesthecachedwindowinformationprovidedtotheinputdispatcher.*/
  2. publicvoidupdateInputWindowsLw(){
  3. //Populatetheinputwindowlistwithinformationaboutallofthewindowsthat
  4. //couldpotentiallyreceiveinput.
  5. //Asanoptimization,wecouldtrytoprunethelistofwindowsbutthisturns
  6. //outtobedifficultbecauseonlythenativecodeknowsforsurewhichwindow
  7. //currentlyhastouchfocus.
  8. finalArrayList<WindowState>windows=mWindows;
  9. finalintN=windows.size();
  10. for(inti=N-1;i>=0;i--){
  11. finalWindowStatechild=windows.get(i);
  12. if(child.mInputChannel==null||child.mRemoved){
  13. //Skipthiswindowbecauseitcannotpossiblyreceiveinput.
  14. continue;
  15. }
  17. finalintflags=child.mAttrs.flags;
  18. finalinttype=child.mAttrs.type;
  20. finalbooleanhasFocus=(child==mInputFocus);
  21. finalbooleanisVisible=child.isVisibleLw();
  22. finalbooleanhasWallpaper=(child==mWallpaperTarget)
  23. &&(type!=WindowManager.LayoutParams.TYPE_KEYGUARD);
  25. //Addawindowtoourlistofinputwindows.
  26. finalInputWindowinputWindow=mTempInputWindows.add();
  27. inputWindow.inputChannel=child.mInputChannel;
  28. inputWindow.name=child.toString();
  29. inputWindow.layoutParamsFlags=flags;
  30. inputWindow.layoutParamsType=type;
  31. inputWindow.dispatchingTimeoutNanos=child.getInputDispatchingTimeoutNanos();
  32. inputWindow.visible=isVisible;
  33. inputWindow.canReceiveKeys=child.canReceiveKeys();
  34. inputWindow.hasFocus=hasFocus;
  35. inputWindow.hasWallpaper=hasWallpaper;
  36. inputWindow.paused=child.mAppToken!=null?child.mAppToken.paused:false;
  37. inputWindow.layer=child.mLayer;
  38. inputWindow.ownerPid=child.mSession.mPid;
  39. inputWindow.ownerUid=child.mSession.mUid;
  41. finalRectframe=child.mFrame;
  42. inputWindow.frameLeft=frame.left;
  43. inputWindow.frameTop=frame.top;
  44. inputWindow.frameRight=frame.right;
  45. inputWindow.frameBottom=frame.bottom;
  47. finalRectvisibleFrame=child.mVisibleFrame;
  48. inputWindow.visibleFrameLeft=visibleFrame.left;
  49. inputWindow.visibleFrameTop=visibleFrame.top;
  50. inputWindow.visibleFrameRight=visibleFrame.right;
  51. inputWindow.visibleFrameBottom=visibleFrame.bottom;
  53. switch(child.mTouchableInsets){
  54. default:
  55. caseViewTreeObserver.InternalInsetsInfo.TOUCHABLE_INSETS_FRAME:
  56. inputWindow.touchableAreaLeft=frame.left;
  57. inputWindow.touchableAreaTop=frame.top;
  58. inputWindow.touchableAreaRight=frame.right;
  59. inputWindow.touchableAreaBottom=frame.bottom;
  60. break;
  62. caseViewTreeObserver.InternalInsetsInfo.TOUCHABLE_INSETS_CONTENT:{
  63. Rectinset=child.mGivenContentInsets;
  64. inputWindow.touchableAreaLeft=frame.left+inset.left;
  65. inputWindow.touchableAreaTop=frame.top+inset.top;
  66. inputWindow.touchableAreaRight=frame.right-inset.right;
  67. inputWindow.touchableAreaBottom=frame.bottom-inset.bottom;
  68. break;
  69. }
  71. caseViewTreeObserver.InternalInsetsInfo.TOUCHABLE_INSETS_VISIBLE:{
  72. Rectinset=child.mGivenVisibleInsets;
  73. inputWindow.touchableAreaLeft=frame.left+inset.left;
  74. inputWindow.touchableAreaTop=frame.top+inset.top;
  75. inputWindow.touchableAreaRight=frame.right-inset.right;
  76. inputWindow.touchableAreaBottom=frame.bottom-inset.bottom;
  77. break;
  78. }
  79. }
  80. }
  82. //Sendwindowstonativecode.
  83. mInputManager.setInputWindows(mTempInputWindows.toNullTerminatedArray());
  85. //Clearthelistinpreparationforthenextround.
  86. //AlsoavoidskeepingInputChannelobjectsreferencedunnecessarily.
  87. mTempInputWindows.clear();
  88. }

真正的Input的控制是通过以下方式

/**
* Z-ordered (bottom-most first) list of all Window objects.
*/
final ArrayList<WindowState> mWindows = new ArrayList<WindowState>();

Java代码
  1. /**
  2. *Z-ordered(bottom-mostfirst)listofallWindowobjects.
  3. */
  4. finalArrayList<WindowState>mWindows=newArrayList<WindowState>();

另外的touch的target并不是通过input focus 获得的。而是通过visible来获得

Java代码
  1. int32_tInputDispatcher::findTouchedWindowTargetsLocked(nsecs_tcurrentTime,
  2. constMotionEntry*entry,nsecs_t*nextWakeupTime){
  3. enumInjectionPermission{
  4. INJECTION_PERMISSION_UNKNOWN,
  5. INJECTION_PERMISSION_GRANTED,
  6. INJECTION_PERMISSION_DENIED
  7. };
  9. mCurrentInputTargets.clear();
  11. nsecs_tstartTime=now();
  13. //Forsecurityreasons,wedeferupdatingthetouchstateuntilwearesurethat
  14. //eventinjectionwillbeallowed.
  15. //
  16. //FIXMEIntheoriginalcode,screenWasOffcouldneverbesettotrue.
  17. //ThereasonisthatthePOLICY_FLAG_WOKE_HERE
  18. //andPOLICY_FLAG_BRIGHT_HEREflagsweresetonlywhenpreprocessingraw
  19. //EV_KEY,EV_RELandEV_ABSevents.Asithappens,thetoucheventwas
  20. //actuallyenqueuedusingthepolicyFlagsthatappearedinthefinalEV_SYN
  21. //eventsuponwhichnopreprocessingtookplace.SopolicyFlagswasalways0.
  22. //Inthenewnativeinputdispatcherwe'reabitmorecarefulaboutevent
  23. //preprocessingsothetoucheswereceivecanactuallyhavenon-zeropolicyFlags.
  24. //Unfortunatelyweobtainundesirablebehavior.
  25. //
  26. //Here'swhathappens:
  27. //
  28. //Whenthedevicedimsinanticipationofgoingtosleep,touches
  29. //inwindowswhichhaveFLAG_TOUCHABLE_WHEN_WAKINGcause
  30. //thedevicetobrightenandresettheuseractivitytimer.
  31. //Touchesonotherwindows(suchasthelauncherwindow)
  32. //aredropped.Thenafteramoment,thedevicegoestosleep.Oops.
  33. //
  34. //AlsonoticehowscreenWasOffwasbeinginitializedusingPOLICY_FLAG_BRIGHT_HERE
  35. //insteadofPOLICY_FLAG_WOKE_HERE...
  36. //
  37. boolscreenWasOff=false;//originalpolicy:policyFlags&POLICY_FLAG_BRIGHT_HERE;
  39. int32_taction=entry->action;
  40. int32_tmaskedAction=action&AMOTION_EVENT_ACTION_MASK;
  42. //Updatethetouchstateasneededbasedonthepropertiesofthetouchevent.
  43. int32_tinjectionResult=INPUT_EVENT_INJECTION_PENDING;
  44. InjectionPermissioninjectionPermission=INJECTION_PERMISSION_UNKNOWN;
  45. if(maskedAction==AMOTION_EVENT_ACTION_DOWN){
  46. mTempTouchState.reset();
  47. mTempTouchState.down=true;
  48. }else{
  49. mTempTouchState.copyFrom(mTouchState);
  50. }
  52. boolisSplit=mTempTouchState.split&&mTempTouchState.down;
  53. if(maskedAction==AMOTION_EVENT_ACTION_DOWN
  54. ||(isSplit&&maskedAction==AMOTION_EVENT_ACTION_POINTER_DOWN)){
  55. /*Case1:Newsplittablepointergoingdown.*/
  57. int32_tpointerIndex=getMotionEventActionPointerIndex(action);
  58. int32_tx=int32_t(entry->firstSample.pointerCoords[pointerIndex].x);
  59. int32_ty=int32_t(entry->firstSample.pointerCoords[pointerIndex].y);
  60. constInputWindow*newTouchedWindow=NULL;
  61. constInputWindow*topErrorWindow=NULL;
  63. //Traversewindowsfromfronttobacktofindtouchedwindowandoutsidetargets.
  64. size_tnumWindows=mWindows.size();
  65. for(size_ti=0;i<numWindows;i++){
  66. constInputWindow*window=&mWindows.editItemAt(i);
  67. int32_tflags=window->layoutParamsFlags;
  69. if(flags&InputWindow::FLAG_SYSTEM_ERROR){
  70. if(!topErrorWindow){
  71. topErrorWindow=window;
  72. }
  73. }
  75. if(window->visible){
  76. if(!(flags&InputWindow::FLAG_NOT_TOUCHABLE)){
  77. boolisTouchModal=(flags&(InputWindow::FLAG_NOT_FOCUSABLE
  78. |InputWindow::FLAG_NOT_TOUCH_MODAL))==0;
  79. if(isTouchModal||window->touchableAreaContainsPoint(x,y)){
  80. if(!screenWasOff||flags&InputWindow::FLAG_TOUCHABLE_WHEN_WAKING){
  81. newTouchedWindow=window;
  82. }
  83. break;//foundtouchedwindow,exitwindowloop
  84. }
  85. }
  87. if(maskedAction==AMOTION_EVENT_ACTION_DOWN
  88. &&(flags&InputWindow::FLAG_WATCH_OUTSIDE_TOUCH)){
  89. int32_toutsideTargetFlags=InputTarget::FLAG_OUTSIDE;
  90. if(isWindowObscuredAtPointLocked(window,x,y)){
  91. outsideTargetFlags|=InputTarget::FLAG_WINDOW_IS_OBSCURED;
  92. }
  94. mTempTouchState.addOrUpdateWindow(window,outsideTargetFlags,BitSet32(0));
  95. }
  96. }
  97. }
  99. //Ifthereisanerrorwindowbutitisnottakingfocus(typicallybecause
  100. //itisinvisible)thenwaitforit.Anyotherfocusedwindowmayin
  101. //factbeinANRstate.
  102. if(topErrorWindow&&newTouchedWindow!=topErrorWindow){
  103. #ifDEBUG_FOCUS
  104. LOGD("Waitingbecausesystemerrorwindowispending.");
  105. #endif
  106. injectionResult=handleTargetsNotReadyLocked(currentTime,entry,
  107. NULL,NULL,nextWakeupTime);
  108. injectionPermission=INJECTION_PERMISSION_UNKNOWN;
  109. gotoUnresponsive;
  110. }
  112. //Figureoutwhethersplittingwillbeallowedforthiswindow.
  113. if(newTouchedWindow
  114. &&(newTouchedWindow->layoutParamsFlags&InputWindow::FLAG_SPLIT_TOUCH)){
  115. //Newwindowsupportssplitting.
  116. isSplit=true;
  117. }elseif(isSplit){
  118. //Newwindowdoesnotsupportsplittingbutwehavealreadysplitevents.
  119. //Assignthepointertothefirstforegroundwindowwefind.
  120. //(MaybeNULLwhichiswhyweputthiscodeblockbeforethenextcheck.)
  121. newTouchedWindow=mTempTouchState.getFirstForegroundWindow();
  122. }
  124. //Ifwedidnotfindatouchedwindowthenfail.
  125. if(!newTouchedWindow){
  126. if(mFocusedApplication){
  127. #ifDEBUG_FOCUS
  128. LOGD("Waitingbecausethereisnotouchedwindowbutthereisa"
  129. "focusedapplicationthatmayeventuallyaddanewwindow:%s.",
  130. getApplicationWindowLabelLocked(mFocusedApplication,NULL).string());
  131. #endif
  132. injectionResult=handleTargetsNotReadyLocked(currentTime,entry,
  133. mFocusedApplication,NULL,nextWakeupTime);
  134. gotoUnresponsive;
  135. }
  137. LOGI("Droppingeventbecausethereisnotouchedwindoworfocusedapplication.");
  138. injectionResult=INPUT_EVENT_INJECTION_FAILED;
  139. gotoFailed;
  140. }
  142. //Settargetflags.
  143. int32_ttargetFlags=InputTarget::FLAG_FOREGROUND;
  144. if(isSplit){
  145. targetFlags|=InputTarget::FLAG_SPLIT;
  146. }
  147. if(isWindowObscuredAtPointLocked(newTouchedWindow,x,y)){
  148. targetFlags|=InputTarget::FLAG_WINDOW_IS_OBSCURED;
  149. }
  151. //Updatethetemporarytouchstate.
  152. BitSet32pointerIds;
  153. if(isSplit){
  154. uint32_tpointerId=entry->pointerIds[pointerIndex];
  155. pointerIds.markBit(pointerId);
  156. }
  157. mTempTouchState.addOrUpdateWindow(newTouchedWindow,targetFlags,pointerIds);
  158. }else{
  159. /*Case2:Pointermove,up,cancelornon-splittablepointerdown.*/
  161. //Ifthepointerisnotcurrentlydown,thenignoretheevent.
  162. if(!mTempTouchState.down){
  163. LOGI("Droppingeventbecausethepointerisnotdown.");
  164. injectionResult=INPUT_EVENT_INJECTION_FAILED;
  165. gotoFailed;
  166. }
  167. }
  169. //Checkpermissiontoinjectintoalltouchedforegroundwindowsandensurethere
  170. //isatleastonetouchedforegroundwindow.
  171. {
  172. boolhaveForegroundWindow=false;
  173. for(size_ti=0;i<mTempTouchState.windows.size();i++){
  174. constTouchedWindow&touchedWindow=mTempTouchState.windows[i];
  175. if(touchedWindow.targetFlags&InputTarget::FLAG_FOREGROUND){
  176. haveForegroundWindow=true;
  177. if(!checkInjectionPermission(touchedWindow.window,entry->injectionState)){
  178. injectionResult=INPUT_EVENT_INJECTION_PERMISSION_DENIED;
  179. injectionPermission=INJECTION_PERMISSION_DENIED;
  180. gotoFailed;
  181. }
  182. }
  183. }
  184. if(!haveForegroundWindow){
  185. #ifDEBUG_INPUT_DISPATCHER_POLICY
  186. LOGD("Droppingeventbecausethereisnotouchedforegroundwindowtoreceiveit.");
  187. #endif
  188. injectionResult=INPUT_EVENT_INJECTION_FAILED;
  189. gotoFailed;
  190. }
  192. //Permissiongrantedtoinjectionintoalltouchedforegroundwindows.
  193. injectionPermission=INJECTION_PERMISSION_GRANTED;
  194. }
  196. //Ensurealltouchedforegroundwindowsarereadyfornewinput.
  197. for(size_ti=0;i<mTempTouchState.windows.size();i++){
  198. constTouchedWindow&touchedWindow=mTempTouchState.windows[i];
  199. if(touchedWindow.targetFlags&InputTarget::FLAG_FOREGROUND){
  200. //Ifthetouchedwindowispausedthenkeepwaiting.
  201. if(touchedWindow.window->paused){
  202. #ifDEBUG_INPUT_DISPATCHER_POLICY
  203. LOGD("Waitingbecausetouchedwindowispaused.");
  204. #endif
  205. injectionResult=handleTargetsNotReadyLocked(currentTime,entry,
  206. NULL,touchedWindow.window,nextWakeupTime);
  207. gotoUnresponsive;
  208. }
  210. //Ifthetouchedwindowisstillworkingonpreviouseventsthenkeepwaiting.
  211. if(!isWindowFinishedWithPreviousInputLocked(touchedWindow.window)){
  212. #ifDEBUG_FOCUS
  213. LOGD("Waitingbecausetouchedwindowstillprocessingpreviousinput.");
  214. #endif
  215. injectionResult=handleTargetsNotReadyLocked(currentTime,entry,
  216. NULL,touchedWindow.window,nextWakeupTime);
  217. gotoUnresponsive;
  218. }
  219. }
  220. }
  222. //Ifthisisthefirstpointergoingdownandthetouchedwindowhasawallpaper
  223. //thenalsoaddthetouchedwallpaperwindowssotheyarelockedinfortheduration
  224. //ofthetouchgesture.
  225. if(maskedAction==AMOTION_EVENT_ACTION_DOWN){
  226. constInputWindow*foregroundWindow=mTempTouchState.getFirstForegroundWindow();
  227. if(foregroundWindow->hasWallpaper){
  228. for(size_ti=0;i<mWindows.size();i++){
  229. constInputWindow*window=&mWindows[i];
  230. if(window->layoutParamsType==InputWindow::TYPE_WALLPAPER){
  231. mTempTouchState.addOrUpdateWindow(window,
  232. InputTarget::FLAG_WINDOW_IS_OBSCURED,BitSet32(0));
  233. }
  234. }
  235. }
  236. }
  238. //Success!Outputtargets.
  239. injectionResult=INPUT_EVENT_INJECTION_SUCCEEDED;
  241. for(size_ti=0;i<mTempTouchState.windows.size();i++){
  242. constTouchedWindow&touchedWindow=mTempTouchState.windows.itemAt(i);
  243. addWindowTargetLocked(touchedWindow.window,touchedWindow.targetFlags,
  244. touchedWindow.pointerIds);
  245. }
  247. //Droptheoutsidetouchwindowsincewewillnotcareabouttheminthenextiteration.
  248. mTempTouchState.removeOutsideTouchWindows();
  250. Failed:
  251. //Checkinjectionpermissiononceandforall.
  252. if(injectionPermission==INJECTION_PERMISSION_UNKNOWN){
  253. if(checkInjectionPermission(NULL,entry->injectionState)){
  254. injectionPermission=INJECTION_PERMISSION_GRANTED;
  255. }else{
  256. injectionPermission=INJECTION_PERMISSION_DENIED;
  257. }
  258. }
  260. //Updatefinalpiecesoftouchstateiftheinjectorhadpermission.
  261. if(injectionPermission==INJECTION_PERMISSION_GRANTED){
  262. if(maskedAction==AMOTION_EVENT_ACTION_UP
  263. ||maskedAction==AMOTION_EVENT_ACTION_CANCEL){
  264. //Allpointersuporcanceled.
  265. mTempTouchState.reset();
  266. }elseif(maskedAction==AMOTION_EVENT_ACTION_DOWN){
  267. //Firstpointerwentdown.
  268. if(mTouchState.down){
  269. #ifDEBUG_FOCUS
  270. LOGD("Pointerdownreceivedwhilealreadydown.");
  271. #endif
  272. }
  273. }elseif(maskedAction==AMOTION_EVENT_ACTION_POINTER_UP){
  274. //Onepointerwentup.
  275. if(isSplit){
  276. int32_tpointerIndex=getMotionEventActionPointerIndex(action);
  277. uint32_tpointerId=entry->pointerIds[pointerIndex];
  279. for(size_ti=0;i<mTempTouchState.windows.size();){
  280. TouchedWindow&touchedWindow=mTempTouchState.windows.editItemAt(i);
  281. if(touchedWindow.targetFlags&InputTarget::FLAG_SPLIT){
  282. touchedWindow.pointerIds.clearBit(pointerId);
  283. if(touchedWindow.pointerIds.isEmpty()){
  284. mTempTouchState.windows.removeAt(i);
  285. continue;
  286. }
  287. }
  288. i+=1;
  289. }
  290. }
  291. }
  293. //Savechangestotouchstate.
  294. mTouchState.copyFrom(mTempTouchState);
  295. }else{
  296. #ifDEBUG_FOCUS
  297. LOGD("Notupdatingtouchfocusbecauseinjectionwasdenied.");
  298. #endif
  299. }
  301. Unresponsive:
  302. //Resettemporarytouchstatetoensurewereleaseunnecessaryreferencestoinputchannels.
  303. mTempTouchState.reset();
  305. nsecs_ttimeSpentWaitingForApplication=getTimeSpentWaitingForApplicationLocked(currentTime);
  306. updateDispatchStatisticsLocked(currentTime,entry,
  307. injectionResult,timeSpentWaitingForApplication);
  308. #ifDEBUG_FOCUS
  309. LOGD("findTouchedWindowfinished:injectionResult=%d,injectionPermission=%d,"
  310. "timeSpentWaitingForApplication=%0.1fms",
  311. injectionResult,injectionPermission,timeSpentWaitingForApplication/1000000.0);
  312. #endif
  313. returninjectionResult;
  314. }

最关键的几行代码，说明了Windows是如何找到触屏的输入焦点的：

Cpp代码
  1. if(window->visible){
  2. if(!(flags&InputWindow::FLAG_NOT_TOUCHABLE)){
  3. boolisTouchModal=(flags&(InputWindow::FLAG_NOT_FOCUSABLE
  4. |InputWindow::FLAG_NOT_TOUCH_MODAL))==0;
  5. if(isTouchModal||window->touchableAreaContainsPoint(x,y)){
  6. if(!screenWasOff||flags&InputWindow::FLAG_TOUCHABLE_WHEN_WAKING){
  7. newTouchedWindow=window;
  8. }
  9. break;//foundtouchedwindow,exitwindowloop
  10. }
  11. }
  13. if(maskedAction==AMOTION_EVENT_ACTION_DOWN
  14. &&(flags&InputWindow::FLAG_WATCH_OUTSIDE_TOUCH)){
  15. int32_toutsideTargetFlags=InputTarget::FLAG_OUTSIDE;
  16. if(isWindowObscuredAtPointLocked(window,x,y)){
  17. outsideTargetFlags|=InputTarget::FLAG_WINDOW_IS_OBSCURED;
  18. }
  20. mTempTouchState.addOrUpdateWindow(window,outsideTargetFlags,BitSet32(0));
  21. }
  22. }

Java代码
  1. //Focustrackingfortouch.
  2. structTouchedWindow{
  3. constInputWindow*window;
  4. int32_ttargetFlags;
  5. BitSet32pointerIds;
  6. sp<InputChannel>channel;
  7. };
  8. structTouchState{
  9. booldown;
  10. boolsplit;
  11. Vector<TouchedWindow>windows;
  13. TouchState();
  14. ~TouchState();
  15. voidreset();
  16. voidcopyFrom(constTouchState&other);
  17. voidaddOrUpdateWindow(constInputWindow*window,int32_ttargetFlags,BitSet32pointerIds);
  18. voidremoveOutsideTouchWindows();
  19. constInputWindow*getFirstForegroundWindow();
  20. };
  24. 另外如何定义按键和其他触屏焦点的：
  27. /*Updatesthecachedwindowinformationprovidedtotheinputdispatcher.*/
  28. publicvoidupdateInputWindowsLw(){
  29. //Populatetheinputwindowlistwithinformationaboutallofthewindowsthat
  30. //couldpotentiallyreceiveinput.
  31. //Asanoptimization,wecouldtrytoprunethelistofwindowsbutthisturns
  32. //outtobedifficultbecauseonlythenativecodeknowsforsurewhichwindow
  33. //currentlyhastouchfocus.
  34. finalArrayList<WindowState>windows=mWindows;
  35. finalintN=windows.size();
  36. for(inti=N-1;i>=0;i--){
  37. finalWindowStatechild=windows.get(i);
  38. if(child.mInputChannel==null||child.mRemoved){
  39. //Skipthiswindowbecauseitcannotpossiblyreceiveinput.
  40. continue;
  41. }
  43. finalintflags=child.mAttrs.flags;
  44. finalinttype=child.mAttrs.type;
  46. <spanstyle="color:#ff6600;">finalbooleanhasFocus=(child==mInputFocus);</span>
  47. //本行代码确定，一次性的focusWindow只有一个。
  48. finalbooleanisVisible=child.isVisibleLw();
  49. finalbooleanhasWallpaper=(child==mWallpaperTarget)
  50. &&(type!=WindowManager.LayoutParams.TYPE_KEYGUARD);

更多相关文章

  1. Android(安卓)特殊用法--来自中国移动开发社区
  2. 菜鸟学Android开发系列之：发送短信拨打电话
  3. 〖Android〗/system/etc/event-log-tags
  4. Android(安卓)progressBar代码设置进度条颜色、背景颜色以及圆角
  5. 求 在独立service 中 调用contentprovider的方法
  6. Android实现系统打印功能
  7. Android(安卓)中的BroadCastReceiver
  8. Android(安卓)- Handler is abstract, cannot be instantiated.
  9. 查询存储空间的代码

随机推荐

  1. Android与H5互调详细介绍
  2. Android之网络丢包事件
  3. Android(安卓)扫码盒子全局接收付款码
  4. Android之网络丢包事件
  5. Android的多任务之路
  6. Android采用HTML设计软件界面
  7. Android系统体系结构
  8. android的makefile分析
  9. Android普及入门
  10. Google：Android(安卓)2.3在所有Android系