下面列出了android.view.KeyEvent#getRepeatCount ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
// BACK key short press => move to parent directory. if root finish the activity.
// BACK key long press => finish the activity.
if ( keyCode == KeyEvent.KEYCODE_BACK ){
if (event.getRepeatCount() == 0 && !m_strDirPath.equals("/") ) {
if( m_strDirPath.lastIndexOf("/") <= 0 ) {
m_strDirPath = m_strDirPath.substring(0, m_strDirPath.lastIndexOf("/") + 1 );
} else {
m_strDirPath = m_strDirPath.substring(0, m_strDirPath.lastIndexOf("/"));
}
fillList();
}else{
finish();
}
return true;
}
return super.onKeyDown(keyCode, event);
}
@Override
public boolean dispatchKeyEventPreIme(KeyEvent event) {
if (mPromptOptions.getBackButtonDismissEnabled()
&& event.getKeyCode() == KeyEvent.KEYCODE_BACK) {
KeyEvent.DispatcherState state = getKeyDispatcherState();
if (state != null) {
if (event.getAction() == KeyEvent.ACTION_DOWN
&& event.getRepeatCount() == 0) {
state.startTracking(event, this);
return true;
} else if (event.getAction() == KeyEvent.ACTION_UP
&& !event.isCanceled() && state.isTracking(event)) {
if (mPromptTouchedListener != null) {
mPromptTouchedListener.onNonFocalPressed();
}
return mPromptOptions.getAutoDismiss()
|| super.dispatchKeyEventPreIme(event);
}
}
}
return super.dispatchKeyEventPreIme(event);
}
private void handleVoiceKeyEventLocked(String packageName, int pid, int uid,
boolean asSystemService, KeyEvent keyEvent, boolean needWakeLock) {
int action = keyEvent.getAction();
boolean isLongPress = (keyEvent.getFlags() & KeyEvent.FLAG_LONG_PRESS) != 0;
if (action == KeyEvent.ACTION_DOWN) {
if (keyEvent.getRepeatCount() == 0) {
mVoiceButtonDown = true;
mVoiceButtonHandled = false;
} else if (mVoiceButtonDown && !mVoiceButtonHandled && isLongPress) {
mVoiceButtonHandled = true;
startVoiceInput(needWakeLock);
}
} else if (action == KeyEvent.ACTION_UP) {
if (mVoiceButtonDown) {
mVoiceButtonDown = false;
if (!mVoiceButtonHandled && !keyEvent.isCanceled()) {
// Resend the down then send this event through
KeyEvent downEvent = KeyEvent.changeAction(keyEvent, KeyEvent.ACTION_DOWN);
dispatchMediaKeyEventLocked(packageName, pid, uid, asSystemService,
downEvent, needWakeLock);
dispatchMediaKeyEventLocked(packageName, pid, uid, asSystemService,
keyEvent, needWakeLock);
}
}
}
}
@Override
public boolean onKey(View v, int keyCode, KeyEvent event) {
if (keyCode == KeyEvent.KEYCODE_BACK) {
if (event.getAction() == KeyEvent.ACTION_DOWN && event.getRepeatCount() == 0) {
// Tell the framework to start tracking this event.
getKeyDispatcherState().startTracking(event, this);
return true;
} else if (event.getAction() == KeyEvent.ACTION_UP) {
getKeyDispatcherState().handleUpEvent(event);
if (event.isTracking() && !event.isCanceled()) {
mFindToolbar.deactivate();
return true;
}
}
}
return false;
}
@Override
public boolean onKey(View v, int keyCode, KeyEvent event) {
if (mPopup == null || mPopup.getListView() == null) return false;
if (event.getKeyCode() == KeyEvent.KEYCODE_MENU) {
if (event.getAction() == KeyEvent.ACTION_DOWN && event.getRepeatCount() == 0) {
event.startTracking();
v.getKeyDispatcherState().startTracking(event, this);
return true;
} else if (event.getAction() == KeyEvent.ACTION_UP) {
v.getKeyDispatcherState().handleUpEvent(event);
if (event.isTracking() && !event.isCanceled()) {
dismiss();
return true;
}
}
}
return false;
}
/**
* Take care of calling onBackPressed() for pre-Eclair platforms.
*/
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
if (android.os.Build.VERSION.SDK_INT < 5 /* ECLAIR */
&& keyCode == KeyEvent.KEYCODE_BACK
&& event.getRepeatCount() == 0) {
// Take care of calling this method on earlier versions of
// the platform where it doesn't exist.
onBackPressed();
return true;
}
return super.onKeyDown(keyCode, event);
}
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
if (keyCode == KeyEvent.KEYCODE_BACK && event.getRepeatCount() == 0) {
finish();
overridePendingTransition(R.anim.slide_up_in, R.anim.slide_down_out);
return false;
}
return false;
}
@Override
public boolean onKeyDown(int keyCode, KeyEvent event)
{
if (isThroughEvent && keyCode == KeyEvent.KEYCODE_BACK && event.getRepeatCount() == 0)
{
dismiss();
mActivity.onBackPressed();
mActivity = null;
return true;
}
return super.onKeyDown(keyCode, event);
}
public boolean onKeyDown(int i1, KeyEvent keyevent)
{
if (android.os.Build.VERSION.SDK_INT < 5 && i1 == 4 && keyevent.getRepeatCount() == 0)
{
onBackPressed();
return true;
} else
{
return super.onKeyDown(i1, keyevent);
}
}
/**
* 重写返回按钮监听刷新主界面头像
*/
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
if (keyCode == KeyEvent.KEYCODE_BACK && event.getRepeatCount() == 0) {
Intent intent = new Intent(UserDataActivity.this, LoginActivity.class);
setResult(2, intent);
finish();
return true;
}
return super.onKeyDown(keyCode, event);
}
/**
* Send a key event to the currently focused window/view and wait for it to
* be processed. Finished at some point after the recipient has returned
* from its event processing, though it may <em>not</em> have completely
* finished reacting from the event -- for example, if it needs to update
* its display as a result, it may still be in the process of doing that.
*
* @param event The event to send to the current focus.
*/
public void sendKeySync(KeyEvent event) {
validateNotAppThread();
long downTime = event.getDownTime();
long eventTime = event.getEventTime();
int action = event.getAction();
int code = event.getKeyCode();
int repeatCount = event.getRepeatCount();
int metaState = event.getMetaState();
int deviceId = event.getDeviceId();
int scancode = event.getScanCode();
int source = event.getSource();
int flags = event.getFlags();
if (source == InputDevice.SOURCE_UNKNOWN) {
source = InputDevice.SOURCE_KEYBOARD;
}
if (eventTime == 0) {
eventTime = SystemClock.uptimeMillis();
}
if (downTime == 0) {
downTime = eventTime;
}
KeyEvent newEvent = new KeyEvent(downTime, eventTime, action, code, repeatCount, metaState,
deviceId, scancode, flags | KeyEvent.FLAG_FROM_SYSTEM, source);
InputManager.getInstance().injectInputEvent(newEvent,
InputManager.INJECT_INPUT_EVENT_MODE_WAIT_FOR_FINISH);
}
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
if (baseBind.drawerLayout.isDrawerOpen(GravityCompat.START)) {
baseBind.drawerLayout.closeDrawer(GravityCompat.START);
return true;
} else {
if (keyCode == KeyEvent.KEYCODE_BACK && event.getRepeatCount() == 0) {
exit();
return true;
}
return false;
}
}
@Override
public boolean dispatchKeyEventPreIme(KeyEvent event) {
if (isMenuOpen()
&& event.getKeyCode() == KeyEvent.KEYCODE_BACK
&& event.getAction() == KeyEvent.ACTION_UP
&& event.getRepeatCount() == 0) {
closeMenu();
return true;
}
return super.dispatchKeyEventPreIme(event);
}
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
if (keyCode == KeyEvent.KEYCODE_BACK && event.getRepeatCount() == 0) {
event.startTracking();
return true;
}
return super.onKeyDown(keyCode, event);
}
@Override
public boolean onKeyDown(int keyCode, KeyEvent event)
{
switch (keyCode)
{
case KeyEvent.KEYCODE_VOLUME_UP:
case KeyEvent.KEYCODE_VOLUME_DOWN:
case KeyEvent.KEYCODE_FOCUS:
if (/* TODO: mActivity.isInCameraApp() && */mFirstTimeInitialized && !mActivity.getCameraAppUI()
.isInIntentReview())
{
if (event.getRepeatCount() == 0)
{
onShutterButtonFocus(true);
}
return true;
}
return false;
case KeyEvent.KEYCODE_CAMERA:
if (mFirstTimeInitialized && event.getRepeatCount() == 0)
{
onShutterButtonClick();
}
return true;
case KeyEvent.KEYCODE_DPAD_CENTER:
// If we get a dpad center event without any focused view, move
// the focus to the shutter button and press it.
if (mFirstTimeInitialized && event.getRepeatCount() == 0)
{
// Start auto-focus immediately to reduce shutter lag. After
// the shutter button gets the focus, onShutterButtonFocus()
// will be called again but it is fine.
onShutterButtonFocus(true);
}
return true;
}
return false;
}
public boolean onKeyOther(TextView view, Spannable text, KeyEvent event) {
int code = event.getKeyCode();
if (code != KeyEvent.KEYCODE_UNKNOWN
&& event.getAction() == KeyEvent.ACTION_MULTIPLE) {
int repeat = event.getRepeatCount();
boolean handled = false;
while ((--repeat) > 0) {
handled |= executeDown(view, text, code,event);
}
return handled;
}
return false;
}
public boolean onKeyDown(int keyCode, KeyEvent event) {
try {
switch (keyCode) {
case KeyEvent.KEYCODE_MENU:
// 取消长按menu键弹出键盘事�?
if (event.getRepeatCount() > 0) {
return true;
}
return mediaPlayerDelegate.isFullScreen;
case KeyEvent.KEYCODE_BACK:
// 点击过快的取消操�?
if (event.getRepeatCount() > 0) {
return true;
}
if (!mediaPlayerDelegate.isDLNA) {
if (mediaPlayerDelegate.isFullScreen
&& !isFromLocal()
&& (mediaPlayerDelegate.videoInfo != null && !mediaPlayerDelegate.videoInfo.isHLS)) {
goSmall();
return true;
} else {
onkeyback();
return true;
}
} else {
return true;
}
case KeyEvent.KEYCODE_VOLUME_DOWN:
return volumeDown();
case KeyEvent.KEYCODE_VOLUME_UP:
return volumeUp();
case KeyEvent.KEYCODE_SEARCH:
return mediaPlayerDelegate.isFullScreen;
case 125:
/** 有些手机载入中弹出popupwindow */
return true;
}
} catch (Exception e) {
e.printStackTrace();
}
return super.onKeyDown(keyCode, event);
}
private void dispatchVolumeKeyEventLocked(String packageName, int pid, int uid,
boolean asSystemService, KeyEvent keyEvent, int stream, boolean musicOnly) {
boolean down = keyEvent.getAction() == KeyEvent.ACTION_DOWN;
boolean up = keyEvent.getAction() == KeyEvent.ACTION_UP;
int direction = 0;
boolean isMute = false;
switch (keyEvent.getKeyCode()) {
case KeyEvent.KEYCODE_VOLUME_UP:
direction = AudioManager.ADJUST_RAISE;
break;
case KeyEvent.KEYCODE_VOLUME_DOWN:
direction = AudioManager.ADJUST_LOWER;
break;
case KeyEvent.KEYCODE_VOLUME_MUTE:
isMute = true;
break;
}
if (down || up) {
int flags = AudioManager.FLAG_FROM_KEY;
if (musicOnly) {
// This flag is used when the screen is off to only affect active media.
flags |= AudioManager.FLAG_ACTIVE_MEDIA_ONLY;
} else {
// These flags are consistent with the home screen
if (up) {
flags |= AudioManager.FLAG_PLAY_SOUND | AudioManager.FLAG_VIBRATE;
} else {
flags |= AudioManager.FLAG_SHOW_UI | AudioManager.FLAG_VIBRATE;
}
}
if (direction != 0) {
// If this is action up we want to send a beep for non-music events
if (up) {
direction = 0;
}
dispatchAdjustVolumeLocked(packageName, pid, uid, asSystemService, stream,
direction, flags);
} else if (isMute) {
if (down && keyEvent.getRepeatCount() == 0) {
dispatchAdjustVolumeLocked(packageName, pid, uid, asSystemService, stream,
AudioManager.ADJUST_TOGGLE_MUTE, flags);
}
}
}
}
public static boolean handleIntent(final Context context, final Intent intent) {
final String intentAction = intent.getAction();
if (Intent.ACTION_MEDIA_BUTTON.equals(intentAction)) {
final KeyEvent event = intent.getParcelableExtra(Intent.EXTRA_KEY_EVENT);
if (event == null) {
return false;
}
final int keycode = event.getKeyCode();
final int action = event.getAction();
final long eventTime = event.getEventTime();
String command = null;
switch (keycode) {
case KeyEvent.KEYCODE_MEDIA_STOP:
command = ACTION_STOP;
break;
case KeyEvent.KEYCODE_HEADSETHOOK:
case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
command = ACTION_TOGGLE_PAUSE;
break;
case KeyEvent.KEYCODE_MEDIA_NEXT:
command = ACTION_SKIP;
break;
case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
command = ACTION_REWIND;
break;
case KeyEvent.KEYCODE_MEDIA_PAUSE:
command = ACTION_PAUSE;
break;
case KeyEvent.KEYCODE_MEDIA_PLAY:
command = ACTION_PLAY;
break;
}
if (command != null) {
if (action == KeyEvent.ACTION_DOWN) {
if (event.getRepeatCount() == 0) {
// Only consider the first event in a sequence, not the repeat events,
// so that we don't trigger in cases where the first event went to
// a different app (e.g. when the user ends a phone call by
// long pressing the headset button)
// The service may or may not be running, but we need to send it
// a command.
if (keycode == KeyEvent.KEYCODE_HEADSETHOOK) {
if (eventTime - mLastClickTime >= DOUBLE_CLICK) {
mClickCounter = 0;
}
mClickCounter++;
if (DEBUG) Log.v(TAG, "Got headset click, count = " + mClickCounter);
mHandler.removeMessages(MSG_HEADSET_DOUBLE_CLICK_TIMEOUT);
Message msg = mHandler.obtainMessage(
MSG_HEADSET_DOUBLE_CLICK_TIMEOUT, mClickCounter, 0, context);
long delay = mClickCounter < 3 ? DOUBLE_CLICK : 0;
if (mClickCounter >= 3) {
mClickCounter = 0;
}
mLastClickTime = eventTime;
acquireWakeLockAndSendMessage(context, msg, delay);
} else {
startService(context, command);
}
return true;
}
}
}
}
return false;
}
@Override
public boolean onKey(View v, int keyCode, KeyEvent event) {
if (KeyNavigationUtil.isGoDown(event)
&& mSuggestionList != null
&& mSuggestionList.isShown()) {
int suggestionCount = mSuggestionListAdapter.getCount();
if (mSuggestionList.getSelectedItemPosition() < suggestionCount - 1) {
if (suggestionCount > 0) mIgnoreOmniboxItemSelection = false;
} else {
// Do not pass down events when the last item is already selected as it will
// dismiss the suggestion list.
return true;
}
if (mSuggestionList.getSelectedItemPosition()
== ListView.INVALID_POSITION) {
// When clearing the selection after a text change, state is not reset
// correctly so hitting down again will cause it to start from the previous
// selection point. We still have to send the key down event to let the list
// view items take focus, but then we select the first item explicitly.
boolean result = mSuggestionList.onKeyDown(keyCode, event);
mSuggestionList.setSelection(0);
return result;
} else {
return mSuggestionList.onKeyDown(keyCode, event);
}
} else if (KeyNavigationUtil.isGoUp(event)
&& mSuggestionList != null
&& mSuggestionList.isShown()) {
if (mSuggestionList.getSelectedItemPosition() != 0
&& mSuggestionListAdapter.getCount() > 0) {
mIgnoreOmniboxItemSelection = false;
}
return mSuggestionList.onKeyDown(keyCode, event);
} else if (KeyNavigationUtil.isGoRight(event)
&& mSuggestionList != null
&& mSuggestionList.isShown()
&& mSuggestionList.getSelectedItemPosition()
!= ListView.INVALID_POSITION) {
OmniboxResultItem selectedItem =
(OmniboxResultItem) mSuggestionListAdapter.getItem(
mSuggestionList.getSelectedItemPosition());
// Set the UrlBar text to empty, so that it will trigger a text change when we
// set the text to the suggestion again.
setUrlBarText("", null);
mUrlBar.setText(selectedItem.getSuggestion().getFillIntoEdit());
mSuggestionList.setSelection(0);
mUrlBar.setSelection(mUrlBar.getText().length());
return true;
} else if (KeyNavigationUtil.isEnter(event)
&& LocationBarLayout.this.getVisibility() == VISIBLE) {
UiUtils.hideKeyboard(mUrlBar);
mSuggestionSelectionInProgress = true;
final String urlText = mUrlBar.getTextWithAutocomplete();
if (mNativeInitialized) {
findMatchAndLoadUrl(urlText);
} else {
mDeferredNativeRunnables.add(new Runnable() {
@Override
public void run() {
findMatchAndLoadUrl(urlText);
}
});
}
return true;
} else if (keyCode == KeyEvent.KEYCODE_BACK) {
if (event.getAction() == KeyEvent.ACTION_DOWN && event.getRepeatCount() == 0) {
// Tell the framework to start tracking this event.
getKeyDispatcherState().startTracking(event, this);
return true;
} else if (event.getAction() == KeyEvent.ACTION_UP) {
getKeyDispatcherState().handleUpEvent(event);
if (event.isTracking() && !event.isCanceled()) {
backKeyPressed();
return true;
}
}
} else if (keyCode == KeyEvent.KEYCODE_ESCAPE) {
if (event.getAction() == KeyEvent.ACTION_DOWN && event.getRepeatCount() == 0) {
revertChanges();
return true;
}
}
return false;
}