Chinaunix首页 | 论坛 | 博客
  • 博客访问: 193792
  • 博文数量: 160
  • 博客积分: 10
  • 博客等级: 民兵
  • 技术积分: 250
  • 用 户 组: 普通用户
  • 注册时间: 2012-09-18 01:16
文章分类

全部博文(160)

文章存档

2016年(4)

2015年(13)

2014年(29)

2013年(114)

我的朋友

分类: Android平台

2014-01-17 10:58:28

Android按键消息传播流程

主要涉及的文件有:

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(绝对值,如触摸屏)。


  1. @Override  
  2. boolean preprocessEvent(InputDevice device, RawInputEvent event) {  
  3.     if (mPolicy.preprocessInputEventTq(event)) {  
  4.         return true;  
  5.     }  
  6.   
  7.     switch (event.type) {  
  8.         case RawInputEvent.EV_KEY: {  
  9.             // XXX begin hack  
  10.             if (DEBUG) {  
  11.                 if (event.keycode == KeyEvent.KEYCODE_G) {  
  12.                     if (event.value != 0) {  
  13.                         // G down  
  14.                         mPolicy.screenTurnedOff(WindowManagerPolicy.OFF_BECAUSE_OF_USER);  
  15.                     }  
  16.                     return false;  
  17.                 }  
  18.                 if (event.keycode == KeyEvent.KEYCODE_D) {  
  19.                     if (event.value != 0) {  
  20.                         //dump();  
  21.                     }  
  22.                     return false;  
  23.                 }  
  24.             }  
  25.             // XXX end hack  
  26.   
  27.             boolean screenIsOff = !mPowerManager.isScreenOn();  
  28.             boolean screenIsDim = !mPowerManager.isScreenBright();  
  29.             int actions = mPolicy.interceptKeyTq(event, !screenIsOff);/**********按键预处理********//  
  30.   
  31.             if ((actions & WindowManagerPolicy.ACTION_GO_TO_SLEEP) != 0) {  
  32.                 mPowerManager.goToSleep(event.when);  
  33.             }  
  34.   
  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.             }  
  45.   
  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.                 return true;  
  52.             } else {  
  53.                 return false;  
  54.             }  
  55.         }  
  56.   
  57.         case RawInputEvent.EV_REL: {  
  58.             boolean screenIsOff = !mPowerManager.isScreenOn();  
  59.             boolean screenIsDim = !mPowerManager.isScreenBright();  
  60.             if (screenIsOff) {  
  61.                 if (!mPolicy.isWakeRelMovementTq(event.deviceId,  
  62.                         device.classes, event)) {  
  63.                     //Slog.i(TAG, "dropping because screenIsOff and !isWakeKey");  
  64.                     return false;  
  65.                 }  
  66.                 event.flags |= WindowManagerPolicy.FLAG_WOKE_HERE;  
  67.             }  
  68.             if (screenIsDim) {  
  69.                 event.flags |= WindowManagerPolicy.FLAG_BRIGHT_HERE;  
  70.             }  
  71.             return true;  
  72.         }  
  73.   
  74.         case RawInputEvent.EV_ABS: {  
  75.             boolean screenIsOff = !mPowerManager.isScreenOn();  
  76.             boolean screenIsDim = !mPowerManager.isScreenBright();  
  77.             if (screenIsOff) {  
  78.                 if (!mPolicy.isWakeAbsMovementTq(event.deviceId,  
  79.                         device.classes, event)) {  
  80.                     //Slog.i(TAG, "dropping because screenIsOff and !isWakeKey");  
  81.                     return false;  
  82.                 }  
  83.                 event.flags |= WindowManagerPolicy.FLAG_WOKE_HERE;  
  84.             }  
  85.             if (screenIsDim) {  
  86.                 event.flags |= WindowManagerPolicy.FLAG_BRIGHT_HERE;  
  87.             }  
  88.             return true;  
  89.         }  
  90.   
  91.         default:  
  92.             return true;  
  93.     }  
  94. }  

preporcessEvent调用了InterceptKeyTQ

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


[java] view plaincopy
  1.   /** {@inheritDoc} */  
[java] view plaincopy
  1. //2.3中名为interceptKeyBeforeQueueing  
  2.     public int interceptKeyTq(RawInputEvent event, boolean screenIsOn) {  
  3.         int result = ACTION_PASS_TO_USER;  
  4.         final boolean isWakeKey = isWakeKeyTq(event);  
  5.         // If screen is off then we treat the case where the keyguard is open but hidden  
  6.         // the same as if it were open and in front.  
  7.         // This will prevent any keys other than the power button from waking the screen  
  8.         // when the keyguard is hidden by another activity.  
  9.         final boolean keyguardActive = (screenIsOn ?  
  10.                                         mKeyguardMediator.isShowingAndNotHidden() :  
  11.                                         mKeyguardMediator.isShowing());  
  12.   
  13.   
  14.         if (false) {  
  15.             Log.d(TAG, "interceptKeyTq event=" + event + " keycode=" + event.keycode  
  16.                   + " screenIsOn=" + screenIsOn + " keyguardActive=" + keyguardActive);  
  17.         }  
  18.   
  19.   
  20.         if (keyguardActive) {  
  21.             if (screenIsOn) {  
  22.                 // when the screen is on, always give the event to the keyguard  
  23.                 result |= ACTION_PASS_TO_USER;  
  24.             } else {  
  25.                 // otherwise, don't pass it to the user  
  26.                 result &= ~ACTION_PASS_TO_USER;  
  27.   
  28.   
  29.                 final boolean isKeyDown =  
  30.                         (event.type == RawInputEvent.EV_KEY) && (event.value != 0);  
  31.                 if (isWakeKey && isKeyDown) {  
  32.   
  33.   
  34.                     // tell the mediator about a wake key, it may decide to  
  35.                     // turn on the screen depending on whether the key is  
  36.                     // appropriate.  
  37.                     if (!mKeyguardMediator.onWakeKeyWhenKeyguardShowingTq(event.keycode)  
  38.                             && (event.keycode == KeyEvent.KEYCODE_VOLUME_DOWN  
  39.                                 || event.keycode == KeyEvent.KEYCODE_VOLUME_UP)) {  
  40.                         // when keyguard is showing and screen off, we need  
  41.                         // to handle the volume key for calls and  music here  
  42.                         if (isInCall()) {  
  43.                             handleVolumeKey(AudioManager.STREAM_VOICE_CALL, event.keycode);  
  44.                         } else if (isMusicActive()) {  
  45.                             handleVolumeKey(AudioManager.STREAM_MUSIC, event.keycode);  
  46.                         }  
  47.                     }  
  48.                 }  
  49.             }  
  50.         } else if (!screenIsOn) {  
  51.             // If we are in-call with screen off and keyguard is not showing,  
  52.             // then handle the volume key ourselves.  
  53.             // This is necessary because the phone app will disable the keyguard  
  54.             // when the proximity sensor is in use.  
  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.                 // a wake key has a sole purpose of waking the device; don't pass  
  63.                 // it to the user  
  64.                 result |= ACTION_POKE_USER_ACTIVITY;  
  65.                 result &= ~ACTION_PASS_TO_USER;  
  66.             }  
  67.         }  
  68.   
  69.   
  70.         int type = event.type;  
  71.         int code = event.keycode;  
  72.         boolean down = event.value != 0;  
  73.   
  74.   
  75.         if (type == RawInputEvent.EV_KEY) {  
  76.             if (code == KeyEvent.KEYCODE_ENDCALL  
  77.                     || code == KeyEvent.KEYCODE_POWER) {  
  78.                 if (down) {  
  79.                     boolean handled = false;  
  80.                     boolean hungUp = false;  
  81.                     // key repeats are generated by the window manager, and we don't see them  
  82.                     // here, so unless the driver is doing something it shouldn't be, we know  
  83.                     // this is the real press event.  
  84.                     ITelephony phoneServ = getPhoneInterface();  
  85.                     if (phoneServ != null) {  
  86.                         try {  
  87.                             if (code == KeyEvent.KEYCODE_ENDCALL) {  
  88.                                 handled = hungUp = phoneServ.endCall();  
  89.                             } else if (code == KeyEvent.KEYCODE_POWER) {  
  90.                                 if (phoneServ.isRinging()) {  
  91.                                     // Pressing Power while there's a ringing incoming  
  92.                                     // call should silence the ringer.  
  93.                                     phoneServ.silenceRinger();  
  94.                                     handled = true;  
  95.                                 } else if (phoneServ.isOffhook() &&  
  96.                                            ((mIncallPowerBehavior  
  97.                                              & Settings.Secure.INCALL_POWER_BUTTON_BEHAVIOR_HANGUP)  
  98.                                             != 0)) {  
  99.                                     // Otherwise, if "Power button ends call" is enabled,  
  100.                                     // the Power button will hang up any current active call.  
  101.                                     handled = hungUp = phoneServ.endCall();  
  102.                                 }  
  103.                             }  
  104.                         } catch (RemoteException ex) {  
  105.                             Log.w(TAG, "ITelephony threw RemoteException" + ex);  
  106.                         }  
  107.                     } else {  
  108.                         Log.w(TAG, "!!! Unable to find ITelephony interface !!!");  
  109.                     }  
  110.   
  111.   
  112.                     if (!screenIsOn  
  113.                             || (handled && code != KeyEvent.KEYCODE_POWER)  
  114.                             || (handled && hungUp && code == KeyEvent.KEYCODE_POWER)) {  
  115.                         mShouldTurnOffOnKeyUp = false;  
  116.                     } else {  
  117.                         // only try to turn off the screen if we didn't already hang up  
  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.                         boolean gohome, 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.                             // they must already be on the keyguad or home screen,  
  141.                             // go to sleep instead  
  142.                             Log.d(TAG, "I'm tired mEndcallBehavior=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.             } else if (isMediaKey(code)) {  
  151.                 // This key needs to be handled even if the screen is off.  
  152.                 // If others need to be handled while it's off, this is a reasonable  
  153.                 // pattern to follow.  
  154.                 if ((result & ACTION_PASS_TO_USER) == 0) {  
  155.                     // Only do this if we would otherwise not pass it to the user. In that  
  156.                     // case, the PhoneWindow class will do the same thing, except it will  
  157.                     // only do it if the showing app doesn't process the key on its own.  
  158.                     KeyEvent keyEvent = new KeyEvent(event.when, event.when,  
  159.                             down ? KeyEvent.ACTION_DOWN : KeyEvent.ACTION_UP,  
  160.                             code, 0);  
  161.                     mBroadcastWakeLock.acquire();  
  162.                     mHandler.post(new PassHeadsetKey(keyEvent));  
  163.                 }  
  164.             } else if (code == KeyEvent.KEYCODE_CALL) {  
  165.                 // If an incoming call is ringing, answer it!  
  166.                 // (We handle this key here, rather than in the InCallScreen, to make  
  167.                 // sure we'll respond to the key even if the InCallScreen hasn't come to  
  168.                 // the foreground yet.)  
  169.   
  170.   
  171.                 // We answer the call on the DOWN event, to agree with  
  172.                 // the "fallback" behavior in the InCallScreen.  
  173.                 if (down) {  
  174.                     try {  
  175.                         ITelephony phoneServ = getPhoneInterface();  
  176.                         if (phoneServ != null) {  
  177.                             if (phoneServ.isRinging()) {  
  178.                                 Log.i(TAG, "interceptKeyTq:"  
  179.                                       + " CALL key-down while ringing: Answer the call!");  
  180.                                 phoneServ.answerRingingCall();  
  181.   
  182.   
  183.                                 // And *don't* pass this key thru to the current activity  
  184.                                 // (which is presumably the InCallScreen.)  
  185.                                 result &= ~ACTION_PASS_TO_USER;  
  186.                             }  
  187.                         } else {  
  188.                             Log.w(TAG, "CALL button: Unable to find ITelephony interface");  
  189.                         }  
  190.                     } catch (RemoteException ex) {  
  191.                         Log.w(TAG, "CALL button: RemoteException from getPhoneInterface()", ex);  
  192.                     }  
  193.                 }  
  194.             } else if ((code == KeyEvent.KEYCODE_VOLUME_UP)  
  195.                        || (code == KeyEvent.KEYCODE_VOLUME_DOWN)) {  
  196.                 // If an incoming call is ringing, either VOLUME key means  
  197.                 // "silence ringer".  We handle these keys here, rather than  
  198.                 // in the InCallScreen, to make sure we'll respond to them  
  199.                 // even if the InCallScreen hasn't come to the foreground yet.  
  200.   
  201.   
  202.                 // Look for the DOWN event here, to agree with the "fallback"  
  203.                 // behavior in the InCallScreen.  
  204.                 if (down) {  
  205.                     try {  
  206.                         ITelephony phoneServ = getPhoneInterface();  
  207.                         if (phoneServ != null) {  
  208.                             if (phoneServ.isRinging()) {  
  209.                                 Log.i(TAG, "interceptKeyTq:"  
  210.                                       + " VOLUME key-down while ringing: Silence ringer!");  
  211.                                 // Silence the ringer.  (It's safe to call this  
  212.                                 // even if the ringer has already been silenced.)  
  213.                                 phoneServ.silenceRinger();  
  214.   
  215.   
  216.                                 // And *don't* pass this key thru to the current activity  
  217.                                 // (which is probably the InCallScreen.)  
  218.                                 result &= ~ACTION_PASS_TO_USER;  
  219.                             }  
  220.                         } else {  
  221.                             Log.w(TAG, "VOLUME button: Unable to find ITelephony interface");  
  222.                         }  
  223.                     } catch (RemoteException ex) {  
  224.                         Log.w(TAG, "VOLUME button: RemoteException from getPhoneInterface()", ex);  
  225.                     }  
  226.                 }  
  227.             }  
  228.         }  
  229.   
  230.   
  231.         return result;  
  232.     }  
WindowManagerService中的InputDispatcherThread线程process,在里头调用mQueue(KeyQ类)的getEvent函数来获取队列中的消息,处理后分发。



[java] view plaincopy
  1. private void process() {  
  2.            android.os.Process.setThreadPriority(  
  3.                    android.os.Process.THREAD_PRIORITY_URGENT_DISPLAY);  
  4.   
  5.            // The last key event we saw  
  6.            KeyEvent lastKey = null;  
  7.   
  8.            // Last keydown time for auto-repeating keys  
  9.            long lastKeyTime = SystemClock.uptimeMillis();  
  10.            long nextKeyTime = lastKeyTime+LONG_WAIT;  
  11.            long downTime = 0;  
  12.   
  13.            // How many successive repeats we generated  
  14.            int keyRepeatCount = 0;  
  15.   
  16.            // Need to report that configuration has changed?  
  17.            boolean configChanged = false;  
  18.   
  19.            while (true) {  
  20.                long curTime = SystemClock.uptimeMillis();  
  21.   
  22.                if (DEBUG_INPUT) Slog.v(  
  23.                    TAG, "Waiting for next key: now=" + curTime  
  24.                    + ", repeat @ " + nextKeyTime);  
  25.   
  26.                // Retrieve next event, waiting only as long as the next  
  27.                // repeat timeout.  If the configuration has changed, then  
  28.                // don't wait at all -- we'll report the change as soon as  
  29.                // we have processed all events.  
  30.                QueuedEvent ev = mQueue.getEvent(//*****获取队列中的消息***//  
  31.                    (int)((!configChanged && curTime < nextKeyTime)  
  32.                            ? (nextKeyTime-curTime) : 0));  
  33.   
  34.                if (DEBUG_INPUT && ev != null) Slog.v(  
  35.                        TAG, "Event: type=" + ev.classType + " data=" + ev.event);  
  36.   
  37.                if (MEASURE_LATENCY) {  
  38.                    lt.sample("2 got event              ", System.nanoTime() - ev.whenNano);  
  39.                }  
  40.   
  41.                if (lastKey != null && !mPolicy.allowKeyRepeat()) {  
  42.                    // cancel key repeat at the request of the policy.  
  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.                        int eventType;  
  52.                        if (ev.classType == RawInputEvent.CLASS_TOUCHSCREEN) {  
  53.                            eventType = eventType((MotionEvent)ev.event);  
  54.                        } else if (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 (RemoteException e) {  
  67.                            // Ignore  
  68.                        }  
  69.   
  70.                        if (ev.classType == RawInputEvent.CLASS_CONFIGURATION_CHANGED) {  
  71.                            // do not wake screen in this case  
  72.                        } else if (eventType != TOUCH_EVENT  
  73.                                && eventType != LONG_TOUCH_EVENT  
  74.                                && eventType != CHEEK_EVENT) {  
  75.                            mPowerManager.userActivity(curTime, false,  
  76.                                    eventType, false);  
  77.                        } else if (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.                        }  
  85.   
  86.                        switch (ev.classType) {  
  87.                            case RawInputEvent.CLASS_KEYBOARD:  
  88.                                KeyEvent ke = (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, "Received key down: first repeat @ "  
  98.                                        + nextKeyTime);  
  99.                                } else {  
  100.                                    lastKey = null;  
  101.                                    downTime = 0;  
  102.                                    // Arbitrary long timeout.  
  103.                                    lastKeyTime = curTime;  
  104.                                    nextKeyTime = curTime + LONG_WAIT;  
  105.                                    if (DEBUG_INPUT) Slog.v(  
  106.                                        TAG, "Received key up: ignore repeat @ "  
  107.                                        + nextKeyTime);  
  108.                                }  
  109.                                dispatchKey((KeyEvent)ev.event, 00);  
  110.                                mQueue.recycleEvent(ev);  
  111.                                break;  
  112.                            case RawInputEvent.CLASS_TOUCHSCREEN:  
  113.                                //Slog.i(TAG, "Read next event " + ev);  
  114.                                dispatchPointer(ev, (MotionEvent)ev.event, 00);  
  115.                                break;  
  116.                            case RawInputEvent.CLASS_TRACKBALL:  
  117.                                dispatchTrackball(ev, (MotionEvent)ev.event, 00);  
  118.                                break;  
  119.                            case RawInputEvent.CLASS_CONFIGURATION_CHANGED:  
  120.                                configChanged = true;  
  121.                                break;  
  122.                            default:  
  123.                                mQueue.recycleEvent(ev);  
  124.                            break;  
  125.                        }  
  126.   
  127.                    } else if (configChanged) {  
  128.                        configChanged = false;  
  129.                        sendNewConfiguration();  
  130.   
  131.                    } else if (lastKey != null) {  
  132.                        curTime = SystemClock.uptimeMillis();  
  133.   
  134.                        // Timeout occurred while key was down.  If it is at or  
  135.                        // past the key repeat time, dispatch the repeat.  
  136.                        if (DEBUG_INPUT) Slog.v(  
  137.                            TAG, "Key timeout: repeat=" + nextKeyTime  
  138.                            + ", now=" + curTime);  
  139.                        if (curTime < nextKeyTime) {  
  140.                            continue;  
  141.                        }  
  142.   
  143.                        lastKeyTime = nextKeyTime;  
  144.                        nextKeyTime = nextKeyTime + KEY_REPEAT_DELAY;  
  145.                        keyRepeatCount++;  
  146.                        if (DEBUG_INPUT) Slog.v(  
  147.                            TAG, "Key repeat: count=" + keyRepeatCount  
  148.                            + ", next @ " + nextKeyTime);  
  149.                        KeyEvent newEvent;  
  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, 00);  
  162.   
  163.                    } else {  
  164.                        curTime = SystemClock.uptimeMillis();  
  165.   
  166.                        lastKeyTime = curTime;  
  167.                        nextKeyTime = curTime + LONG_WAIT;  
  168.                    }  
  169.   
  170.                } catch (Exception e) {  
  171.                    Slog.e(TAG,  
  172.                        "Input thread received uncaught exception: " + e, e);  
  173.                }  
  174.            }  
  175.        }  
  176.    }  
阅读(1244) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
评论热议
请登录后评论。

登录 注册