主要涉及的文件有：

WindowManagerService.java frameworks\base\services\java\com\android\server\

PhoneWindow.java frameworks\policies\base\phone\com\android\internal\policy\impl

KeyInputQueue.java frameworks\base\services\java\com\android\server

com_android_server_KeyInputQueue.cpp frameworks\base\services\jni

EventHub.cpp frameworks\base\libs\ui


WindowManagerService.java主要有两个线程，一个负责分发按键的InputDisapath Thread，另一个负责从底层读取按键消息InputDeviceRender Thread。

WindowManagerService.java的成员类KeyQ()，负责获取各种按键设备的状态，它继承于KeyInputQueue类。通过线程InputDeviceRender Thread的readEvent对按键消息不停读取，然后调用KeyQ实例化后的processEvent函数告诉该按键是否应该传给上层。接着WindowManagerService通过InputDisPatch Thread在按键消息队列里取出，并进行分发。

由此可知，InputDisapath线程负责分发，InputDeviceRender线程通过jni方式调用android_server_KeyInputQueue_readEvent()，在这里负责转化C++的按键消息为java的格式，android_server_KeyInputQueue_readEvent在EventHub.cpp中获取按键消息。


具体一些细节代码如下：

WindowManagerService中的KeyQ()类，preporcessEvent函数负责对按键进行预处理，主要的事件类型包括EV_KEY(按键事件)、EV_REL(相对值，如鼠标移动，报告相对于最后一次位置的偏移)和EV_ABS(绝对值，如触摸屏)。

[java] view plain copy print ?
  1. @Override
  2. booleanpreprocessEvent(InputDevicedevice,RawInputEventevent){
  3. if(mPolicy.preprocessInputEventTq(event)){
  4. returntrue;
  5. }
  7. switch(event.type){
  8. caseRawInputEvent.EV_KEY:{
  9. //XXXbeginhack
  10. if(DEBUG){
  11. if(event.keycode==KeyEvent.KEYCODE_G){
  12. if(event.value!=0){
  13. //Gdown
  14. mPolicy.screenTurnedOff(WindowManagerPolicy.OFF_BECAUSE_OF_USER);
  15. }
  16. returnfalse;
  17. }
  18. if(event.keycode==KeyEvent.KEYCODE_D){
  19. if(event.value!=0){
  20. //dump();
  21. }
  22. returnfalse;
  23. }
  24. }
  25. //XXXendhack
  27. booleanscreenIsOff=!mPowerManager.isScreenOn();
  28. booleanscreenIsDim=!mPowerManager.isScreenBright();
  29. intactions=mPolicy.interceptKeyTq(event,!screenIsOff);/**********按键预处理********//
  31. if((actions&WindowManagerPolicy.ACTION_GO_TO_SLEEP)!=0){
  32. mPowerManager.goToSleep(event.when);
  33. }
  35. if(screenIsOff){
  36. event.flags|=WindowManagerPolicy.FLAG_WOKE_HERE;
  37. }
  38. if(screenIsDim){
  39. event.flags|=WindowManagerPolicy.FLAG_BRIGHT_HERE;
  40. }
  41. if((actions&WindowManagerPolicy.ACTION_POKE_USER_ACTIVITY)!=0){
  42. mPowerManager.userActivity(event.when,false,
  43. LocalPowerManager.BUTTON_EVENT,false);
  44. }
  46. if((actions&WindowManagerPolicy.ACTION_PASS_TO_USER)!=0){
  47. if(event.value!=0&&mPolicy.isAppSwitchKeyTqTiLwLi(event.keycode)){
  48. filterQueue(this);
  49. mKeyWaiter.appSwitchComing();
  50. }
  51. returntrue;
  52. }else{
  53. returnfalse;
  54. }
  55. }
  57. caseRawInputEvent.EV_REL:{
  58. booleanscreenIsOff=!mPowerManager.isScreenOn();
  59. booleanscreenIsDim=!mPowerManager.isScreenBright();
  60. if(screenIsOff){
  61. if(!mPolicy.isWakeRelMovementTq(event.deviceId,
  62. device.classes,event)){
  63. //Slog.i(TAG,"droppingbecausescreenIsOffand!isWakeKey");
  64. returnfalse;
  65. }
  66. event.flags|=WindowManagerPolicy.FLAG_WOKE_HERE;
  67. }
  68. if(screenIsDim){
  69. event.flags|=WindowManagerPolicy.FLAG_BRIGHT_HERE;
  70. }
  71. returntrue;
  72. }
  74. caseRawInputEvent.EV_ABS:{
  75. booleanscreenIsOff=!mPowerManager.isScreenOn();
  76. booleanscreenIsDim=!mPowerManager.isScreenBright();
  77. if(screenIsOff){
  78. if(!mPolicy.isWakeAbsMovementTq(event.deviceId,
  79. device.classes,event)){
  80. //Slog.i(TAG,"droppingbecausescreenIsOffand!isWakeKey");
  81. returnfalse;
  82. }
  83. event.flags|=WindowManagerPolicy.FLAG_WOKE_HERE;
  84. }
  85. if(screenIsDim){
  86. event.flags|=WindowManagerPolicy.FLAG_BRIGHT_HERE;
  87. }
  88. returntrue;
  89. }
  91. default:
  92. returntrue;
  93. }
  94. }

preporcessEvent调用了InterceptKeyTQ

PhoneWindowManager.java中的InterceptKeyTQ判断该按键是否应该送给上层，还是在此层进行截取，如待机休眠唤醒则在此层进行截取。

[java] view plain copy print ?
  1. /**{@inheritDoc}*/
[java] view plain copy print ?
  1. //2.3中名为interceptKeyBeforeQueueing
  2. publicintinterceptKeyTq(RawInputEventevent,booleanscreenIsOn){
  3. intresult=ACTION_PASS_TO_USER;
  4. finalbooleanisWakeKey=isWakeKeyTq(event);
  5. //Ifscreenisoffthenwetreatthecasewherethekeyguardisopenbuthidden
  6. //thesameasifitwereopenandinfront.
  7. //Thiswillpreventanykeysotherthanthepowerbuttonfromwakingthescreen
  8. //whenthekeyguardishiddenbyanotheractivity.
  9. finalbooleankeyguardActive=(screenIsOn?
  10. mKeyguardMediator.isShowingAndNotHidden():
  11. mKeyguardMediator.isShowing());
  14. if(false){
  15. Log.d(TAG,"interceptKeyTqevent="+event+"keycode="+event.keycode
  16. +"screenIsOn="+screenIsOn+"keyguardActive="+keyguardActive);
  17. }
  20. if(keyguardActive){
  21. if(screenIsOn){
  22. //whenthescreenison,alwaysgivetheeventtothekeyguard
  23. result|=ACTION_PASS_TO_USER;
  24. }else{
  25. //otherwise,don'tpassittotheuser
  26. result&=~ACTION_PASS_TO_USER;
  29. finalbooleanisKeyDown=
  30. (event.type==RawInputEvent.EV_KEY)&&(event.value!=0);
  31. if(isWakeKey&&isKeyDown){
  34. //tellthemediatoraboutawakekey,itmaydecideto
  35. //turnonthescreendependingonwhetherthekeyis
  36. //appropriate.
  37. if(!mKeyguardMediator.onWakeKeyWhenKeyguardShowingTq(event.keycode)
  38. &&(event.keycode==KeyEvent.KEYCODE_VOLUME_DOWN
  39. ||event.keycode==KeyEvent.KEYCODE_VOLUME_UP)){
  40. //whenkeyguardisshowingandscreenoff,weneed
  41. //tohandlethevolumekeyforcallsandmusichere
  42. if(isInCall()){
  43. handleVolumeKey(AudioManager.STREAM_VOICE_CALL,event.keycode);
  44. }elseif(isMusicActive()){
  45. handleVolumeKey(AudioManager.STREAM_MUSIC,event.keycode);
  46. }
  47. }
  48. }
  49. }
  50. }elseif(!screenIsOn){
  51. //Ifwearein-callwithscreenoffandkeyguardisnotshowing,
  52. //thenhandlethevolumekeyourselves.
  53. //Thisisnecessarybecausethephoneappwilldisablethekeyguard
  54. //whentheproximitysensorisinuse.
  55. if(isInCall()&&event.type==RawInputEvent.EV_KEY&&
  56. (event.keycode==KeyEvent.KEYCODE_VOLUME_DOWN
  57. ||event.keycode==KeyEvent.KEYCODE_VOLUME_UP)){
  58. result&=~ACTION_PASS_TO_USER;
  59. handleVolumeKey(AudioManager.STREAM_VOICE_CALL,event.keycode);
  60. }
  61. if(isWakeKey){
  62. //awakekeyhasasolepurposeofwakingthedevice;don'tpass
  63. //ittotheuser
  64. result|=ACTION_POKE_USER_ACTIVITY;
  65. result&=~ACTION_PASS_TO_USER;
  66. }
  67. }
  70. inttype=event.type;
  71. intcode=event.keycode;
  72. booleandown=event.value!=0;
  75. if(type==RawInputEvent.EV_KEY){
  76. if(code==KeyEvent.KEYCODE_ENDCALL
  77. ||code==KeyEvent.KEYCODE_POWER){
  78. if(down){
  79. booleanhandled=false;
  80. booleanhungUp=false;
  81. //keyrepeatsaregeneratedbythewindowmanager,andwedon'tseethem
  82. //here,sounlessthedriverisdoingsomethingitshouldn'tbe,weknow
  83. //thisistherealpressevent.
  84. ITelephonyphoneServ=getPhoneInterface();
  85. if(phoneServ!=null){
  86. try{
  87. if(code==KeyEvent.KEYCODE_ENDCALL){
  88. handled=hungUp=phoneServ.endCall();
  89. }elseif(code==KeyEvent.KEYCODE_POWER){
  90. if(phoneServ.isRinging()){
  91. //PressingPowerwhilethere'saringingincoming
  92. //callshouldsilencetheringer.
  93. phoneServ.silenceRinger();
  94. handled=true;
  95. }elseif(phoneServ.isOffhook()&&
  96. ((mIncallPowerBehavior
  97. &Settings.Secure.INCALL_POWER_BUTTON_BEHAVIOR_HANGUP)
  98. !=0)){
  99. //Otherwise,if"Powerbuttonendscall"isenabled,
  100. //thePowerbuttonwillhangupanycurrentactivecall.
  101. handled=hungUp=phoneServ.endCall();
  102. }
  103. }
  104. }catch(RemoteExceptionex){
  105. Log.w(TAG,"ITelephonythrewRemoteException"+ex);
  106. }
  107. }else{
  108. Log.w(TAG,"!!!UnabletofindITelephonyinterface!!!");
  109. }
  112. if(!screenIsOn
  113. ||(handled&&code!=KeyEvent.KEYCODE_POWER)
  114. ||(handled&&hungUp&&code==KeyEvent.KEYCODE_POWER)){
  115. mShouldTurnOffOnKeyUp=false;
  116. }else{
  117. //onlytrytoturnoffthescreenifwedidn'talreadyhangup
  118. mShouldTurnOffOnKeyUp=true;
  119. mHandler.postDelayed(mPowerLongPress,
  120. ViewConfiguration.getGlobalActionKeyTimeout());
  121. result&=~ACTION_PASS_TO_USER;
  122. }
  123. }else{
  124. mHandler.removeCallbacks(mPowerLongPress);
  125. if(mShouldTurnOffOnKeyUp){
  126. mShouldTurnOffOnKeyUp=false;
  127. booleangohome,sleeps;
  128. if(code==KeyEvent.KEYCODE_ENDCALL){
  129. gohome=(mEndcallBehavior
  130. &Settings.System.END_BUTTON_BEHAVIOR_HOME)!=0;
  131. sleeps=(mEndcallBehavior
  132. &Settings.System.END_BUTTON_BEHAVIOR_SLEEP)!=0;
  133. }else{
  134. gohome=false;
  135. sleeps=true;
  136. }
  137. if(keyguardActive
  138. ||(sleeps&&!gohome)
  139. ||(gohome&&!goHome()&&sleeps)){
  140. //theymustalreadybeonthekeyguadorhomescreen,
  141. //gotosleepinstead
  142. Log.d(TAG,"I'mtiredmEndcallBehavior=0x"
  143. +Integer.toHexString(mEndcallBehavior));
  144. result&=~ACTION_POKE_USER_ACTIVITY;
  145. result|=ACTION_GO_TO_SLEEP;
  146. }
  147. result&=~ACTION_PASS_TO_USER;
  148. }
  149. }
  150. }elseif(isMediaKey(code)){
  151. //Thiskeyneedstobehandledevenifthescreenisoff.
  152. //Ifothersneedtobehandledwhileit'soff,thisisareasonable
  153. //patterntofollow.
  154. if((result&ACTION_PASS_TO_USER)==0){
  155. //Onlydothisifwewouldotherwisenotpassittotheuser.Inthat
  156. //case,thePhoneWindowclasswilldothesamething,exceptitwill
  157. //onlydoitiftheshowingappdoesn'tprocessthekeyonitsown.
  158. KeyEventkeyEvent=newKeyEvent(event.when,event.when,
  159. down?KeyEvent.ACTION_DOWN:KeyEvent.ACTION_UP,
  160. code,0);
  161. mBroadcastWakeLock.acquire();
  162. mHandler.post(newPassHeadsetKey(keyEvent));
  163. }
  164. }elseif(code==KeyEvent.KEYCODE_CALL){
  165. //Ifanincomingcallisringing,answerit!
  166. //(Wehandlethiskeyhere,ratherthanintheInCallScreen,tomake
  167. //surewe'llrespondtothekeyeveniftheInCallScreenhasn'tcometo
  168. //theforegroundyet.)
  171. //WeanswerthecallontheDOWNevent,toagreewith
  172. //the"fallback"behaviorintheInCallScreen.
  173. if(down){
  174. try{
  175. ITelephonyphoneServ=getPhoneInterface();
  176. if(phoneServ!=null){
  177. if(phoneServ.isRinging()){
  178. Log.i(TAG,"interceptKeyTq:"
  179. +"CALLkey-downwhileringing:Answerthecall!");
  180. phoneServ.answerRingingCall();
  183. //And*don't*passthiskeythrutothecurrentactivity
  184. //(whichispresumablytheInCallScreen.)
  185. result&=~ACTION_PASS_TO_USER;
  186. }
  187. }else{
  188. Log.w(TAG,"CALLbutton:UnabletofindITelephonyinterface");
  189. }
  190. }catch(RemoteExceptionex){
  191. Log.w(TAG,"CALLbutton:RemoteExceptionfromgetPhoneInterface()",ex);
  192. }
  193. }
  194. }elseif((code==KeyEvent.KEYCODE_VOLUME_UP)
  195. ||(code==KeyEvent.KEYCODE_VOLUME_DOWN)){
  196. //Ifanincomingcallisringing,eitherVOLUMEkeymeans
  197. //"silenceringer".Wehandlethesekeyshere,ratherthan
  198. //intheInCallScreen,tomakesurewe'llrespondtothem
  199. //eveniftheInCallScreenhasn'tcometotheforegroundyet.
  202. //LookfortheDOWNeventhere,toagreewiththe"fallback"
  203. //behaviorintheInCallScreen.
  204. if(down){
  205. try{
  206. ITelephonyphoneServ=getPhoneInterface();
  207. if(phoneServ!=null){
  208. if(phoneServ.isRinging()){
  209. Log.i(TAG,"interceptKeyTq:"
  210. +"VOLUMEkey-downwhileringing:Silenceringer!");
  211. //Silencetheringer.(It'ssafetocallthis
  212. //eveniftheringerhasalreadybeensilenced.)
  213. phoneServ.silenceRinger();
  216. //And*don't*passthiskeythrutothecurrentactivity
  217. //(whichisprobablytheInCallScreen.)
  218. result&=~ACTION_PASS_TO_USER;
  219. }
  220. }else{
  221. Log.w(TAG,"VOLUMEbutton:UnabletofindITelephonyinterface");
  222. }
  223. }catch(RemoteExceptionex){
  224. Log.w(TAG,"VOLUMEbutton:RemoteExceptionfromgetPhoneInterface()",ex);
  225. }
  226. }
  227. }
  228. }
  231. returnresult;
  232. }
WindowManagerService中的InputDispatcherThread线程process，在里头调用mQueue（KeyQ类）的getEvent函数来获取队列中的消息，处理后分发。[java] view plain copy print ?
  1. privatevoidprocess(){
  2. android.os.Process.setThreadPriority(
  3. android.os.Process.THREAD_PRIORITY_URGENT_DISPLAY);
  5. //Thelastkeyeventwesaw
  6. KeyEventlastKey=null;
  8. //Lastkeydowntimeforauto-repeatingkeys
  9. longlastKeyTime=SystemClock.uptimeMillis();
  10. longnextKeyTime=lastKeyTime+LONG_WAIT;
  11. longdownTime=0;
  13. //Howmanysuccessiverepeatswegenerated
  14. intkeyRepeatCount=0;
  16. //Needtoreportthatconfigurationhaschanged?
  17. booleanconfigChanged=false;
  19. while(true){
  20. longcurTime=SystemClock.uptimeMillis();
  22. if(DEBUG_INPUT)Slog.v(
  23. TAG,"Waitingfornextkey:now="+curTime
  24. +",repeat@"+nextKeyTime);
  26. //Retrievenextevent,waitingonlyaslongasthenext
  27. //repeattimeout.Iftheconfigurationhaschanged,then
  28. //don'twaitatall--we'llreportthechangeassoonas
  29. //wehaveprocessedallevents.
  30. QueuedEventev=mQueue.getEvent(//*****获取队列中的消息***//
  31. (int)((!configChanged&&curTime<nextKeyTime)
  32. ?(nextKeyTime-curTime):0));
  34. if(DEBUG_INPUT&&ev!=null)Slog.v(
  35. TAG,"Event:type="+ev.classType+"data="+ev.event);
  37. if(MEASURE_LATENCY){
  38. lt.sample("2gotevent",System.nanoTime()-ev.whenNano);
  39. }
  41. if(lastKey!=null&&!mPolicy.allowKeyRepeat()){
  42. //cancelkeyrepeatattherequestofthepolicy.
  43. lastKey=null;
  44. downTime=0;
  45. lastKeyTime=curTime;
  46. nextKeyTime=curTime+LONG_WAIT;
  47. }
  48. try{
  49. if(ev!=null){
  50. curTime=SystemClock.uptimeMillis();
  51. inteventType;
  52. if(ev.classType==RawInputEvent.CLASS_TOUCHSCREEN){
  53. eventType=eventType((MotionEvent)ev.event);
  54. }elseif(ev.classType==RawInputEvent.CLASS_KEYBOARD||
  55. ev.classType==RawInputEvent.CLASS_TRACKBALL){
  56. eventType=LocalPowerManager.BUTTON_EVENT;
  57. }else{
  58. eventType=LocalPowerManager.OTHER_EVENT;
  59. }
  60. try{
  61. if((curTime-mLastBatteryStatsCallTime)
  62. >=MIN_TIME_BETWEEN_USERACTIVITIES){
  63. mLastBatteryStatsCallTime=curTime;
  64. mBatteryStats.noteInputEvent();
  65. }
  66. }catch(RemoteExceptione){
  67. //Ignore
  68. }
  70. if(ev.classType==RawInputEvent.CLASS_CONFIGURATION_CHANGED){
  71. //donotwakescreeninthiscase
  72. }elseif(eventType!=TOUCH_EVENT
  73. &&eventType!=LONG_TOUCH_EVENT
  74. &&eventType!=CHEEK_EVENT){
  75. mPowerManager.userActivity(curTime,false,
  76. eventType,false);
  77. }elseif(mLastTouchEventType!=eventType
  78. ||(curTime-mLastUserActivityCallTime)
  79. >=MIN_TIME_BETWEEN_USERACTIVITIES){
  80. mLastUserActivityCallTime=curTime;
  81. mLastTouchEventType=eventType;
  82. mPowerManager.userActivity(curTime,false,
  83. eventType,false);
  84. }
  86. switch(ev.classType){
  87. caseRawInputEvent.CLASS_KEYBOARD:
  88. KeyEventke=(KeyEvent)ev.event;
  89. if(ke.isDown()){
  90. lastKey=ke;
  91. downTime=curTime;
  92. keyRepeatCount=0;
  93. lastKeyTime=curTime;
  94. nextKeyTime=lastKeyTime
  95. +ViewConfiguration.getLongPressTimeout();
  96. if(DEBUG_INPUT)Slog.v(
  97. TAG,"Receivedkeydown:firstrepeat@"
  98. +nextKeyTime);
  99. }else{
  100. lastKey=null;
  101. downTime=0;
  102. //Arbitrarylongtimeout.
  103. lastKeyTime=curTime;
  104. nextKeyTime=curTime+LONG_WAIT;
  105. if(DEBUG_INPUT)Slog.v(
  106. TAG,"Receivedkeyup:ignorerepeat@"
  107. +nextKeyTime);
  108. }
  109. dispatchKey((KeyEvent)ev.event,0,0);
  110. mQueue.recycleEvent(ev);
  111. break;
  112. caseRawInputEvent.CLASS_TOUCHSCREEN:
  113. //Slog.i(TAG,"Readnextevent"+ev);
  114. dispatchPointer(ev,(MotionEvent)ev.event,0,0);
  115. break;
  116. caseRawInputEvent.CLASS_TRACKBALL:
  117. dispatchTrackball(ev,(MotionEvent)ev.event,0,0);
  118. break;
  119. caseRawInputEvent.CLASS_CONFIGURATION_CHANGED:
  120. configChanged=true;
  121. break;
  122. default:
  123. mQueue.recycleEvent(ev);
  124. break;
  125. }
  127. }elseif(configChanged){
  128. configChanged=false;
  129. sendNewConfiguration();
  131. }elseif(lastKey!=null){
  132. curTime=SystemClock.uptimeMillis();
  134. //Timeoutoccurredwhilekeywasdown.Ifitisator
  135. //pastthekeyrepeattime,dispatchtherepeat.
  136. if(DEBUG_INPUT)Slog.v(
  137. TAG,"Keytimeout:repeat="+nextKeyTime
  138. +",now="+curTime);
  139. if(curTime<nextKeyTime){
  140. continue;
  141. }
  143. lastKeyTime=nextKeyTime;
  144. nextKeyTime=nextKeyTime+KEY_REPEAT_DELAY;
  145. keyRepeatCount++;
  146. if(DEBUG_INPUT)Slog.v(
  147. TAG,"Keyrepeat:count="+keyRepeatCount
  148. +",next@"+nextKeyTime);
  149. KeyEventnewEvent;
  150. if(downTime!=0&&(downTime
  151. +ViewConfiguration.getLongPressTimeout())
  152. <=curTime){
  153. newEvent=KeyEvent.changeTimeRepeat(lastKey,
  154. curTime,keyRepeatCount,
  155. lastKey.getFlags()|KeyEvent.FLAG_LONG_PRESS);
  156. downTime=0;
  157. }else{
  158. newEvent=KeyEvent.changeTimeRepeat(lastKey,
  159. curTime,keyRepeatCount);
  160. }
  161. dispatchKey(newEvent,0,0);
  163. }else{
  164. curTime=SystemClock.uptimeMillis();
  166. lastKeyTime=curTime;
  167. nextKeyTime=curTime+LONG_WAIT;
  168. }
  170. }catch(Exceptione){
  171. Slog.e(TAG,
  172. "Inputthreadreceiveduncaughtexception:"+e,e);
  173. }
  174. }
  175. }
  176. }

个人水平有限，有错误欢迎指出，谢谢。


补充：

1、生成

存在这样一个线程，它不断地从driver读取Event，并把它放到RawEvent队列中。这个队列中的RawEvent既有按键，也有触摸、轨迹球等事件。

RawEvent队列中的每个RawEvent最后都会通过一系列转化，最终变为KeyEvent被发送给另外一个线程，即输入线程，也就是一个Activity的主线程。

2、传递

KeyEvent传递过程主要可以划分为三步：过滤器、View树、Activity

过滤器部分主要对应着PhoneWindowManager.java中的interceptKeyTq和interceptKeyTi这两个方法。它们的代码可以在frameworks/base/policy/base/phone/com/Android/internal/policy/impl/PhoneWindowManager.java中看到。

这两个过滤器最大的不同就是interceptKeyTq用于RawEvent，而interceptKeyTi用于KeyEvent。

在一个没有实体键盘的机器上，Power键会被interceptKeyTq这个过滤器吃掉用来调用关机对话框或者使机器休眠。而Home键会被interceptKeyTi这个过滤器吃掉，用来把当前Activity切换到后台并把桌面程序切换到前台。所以，应用程序在View和Activity的onKeyDown/Up中是监听不到这两个按键的。除了这两个键以外的按键，都有机会继续前进。接下来，KeyEvent会先经过interceptKeyTi过滤器，如果这个过滤器不吃掉的话，就会继续前进，进入View树，如果没有被哪个View吃掉的话，最后进入到Activity的onKeyDown/Up方法中。

当一个KeyEvent经过上面的过程还没有被吃掉的话，系统就会利用它做一些定制的功能。比如音量键被系统用来调整声音，多媒体按键用来控制媒体播放，搜索键用来快速打开搜索功能，返回键用来退出当前Activity等。


更多相关文章

  1. android异步图片加载三之handler+线程池+消息队列模式
  2. Android进程与线程基本知识一
  3. 有关Android线程的学习
  4. Android单线程模型相关概念详解
  5. Android 多线程-----AsyncTask详解
  6. 浅析Android线程模型
  7. android > 调用拨打电话 并子线程监控然后返回跳转
  8. android按键模拟测试

随机推荐

  1. Android Studio Check for Update
  2. Android Tablet PC avec Android 4.1 Jel
  3. android中Handler的源码分析
  4. Android 各种布局技术-五大布局对象
  5. Android数据的四种存储方式SharedPrefere
  6. Android Camera (android2.2) 资料一
  7. android 关于tts的一些参数
  8. android原生项目整合ReactNative
  9. 搭建android测试环境
  10. android sdk setup时出现:HTTPS SSL erro