Java Code Examples for android.view.KeyEvent#getKeyCode()

@Override
public boolean dispatchKeyEvent(KeyEvent event) {
    int keyCode = event.getKeyCode();
    int action = event.getAction();
    if (keyCode == KeyEvent.KEYCODE_STEM_1) {
        if (action == KeyEvent.ACTION_UP) {
            flipCard(
                    currentMode == InputMode.MOUSE
                            ? InputMode.TOUCHPAD
                            : currentMode == InputMode.TOUCHPAD
                                    ? InputMode.KEYPAD
                                    : InputMode.MOUSE);
        }
        return true;
    } else if (keyCode == KeyEvent.KEYCODE_STEM_2) {
        if (action == KeyEvent.ACTION_UP) {
            Intent intent = keyboardController.getInputIntent(getPackageManager());
            if (intent != null) {
                startActivityForResult(intent, INPUT_REQUEST_CODE);
            }
        }
        return true;
    }
    return super.dispatchKeyEvent(event);
}
 

@Override
public boolean dispatchKeyEvent(KeyEvent event)
{
    Logger.debug(TAG + ": dispatchKeyEvent");
    //Prevent selection clearing when back button is pressed while properties fragment is active
    if (event.getKeyCode() == KeyEvent.KEYCODE_BACK && event.getAction() == KeyEvent.ACTION_UP)
    {
        if (!_isLargeScreenLayout && hasSelectedFiles())
        {
            Fragment f = getFragmentManager().findFragmentByTag(FilePropertiesFragment.TAG);
            if (f != null)
            {
                hideSecondaryFragment();
                return true;
            }
        }
    }
    return super.dispatchKeyEvent(event);
}
 

@Override
public boolean dispatchKeyEvent(KeyEvent event) {
	// if the user has pressed the BACK button (of the Navigation Bar), then ...
	if (event.getKeyCode() == KeyEvent.KEYCODE_BACK) {
		if (event.getAction() == KeyEvent.ACTION_DOWN) {
			// Tell the Fragment to stop playback, and record the playing video's position if needed
			fragmentInterface.videoPlaybackStopped();

			// ask the activity to finish
			((Activity) getContext()).finish();
		}

		// true means we handles the event
		return true;
	}

	return super.dispatchKeyEvent(event);
}
 

@Override
public boolean dispatchKeyEvent(final KeyEvent event) {
    if (event.getAction() == KeyEvent.ACTION_DOWN) {
        switch (event.getKeyCode()) {
            case KeyEvent.KEYCODE_BACK:
                FragmentManager fm = getFragmentManager();
                int cnt = fm.getBackStackEntryCount();
                if (cnt <= 1) {
                    finish();
                    return false;
                } else {
                    currentPage--;
                }
                break;
            default:
                break;
        }
    }
    return super.dispatchKeyEvent(event);
}
 

@Override
public boolean dispatchKeyEvent(KeyEvent event) {
  int keyCode = event.getKeyCode();
  if (event.getRepeatCount() == 0 && (keyCode == KeyEvent.KEYCODE_HEADSETHOOK || keyCode == KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE || keyCode == KeyEvent.KEYCODE_SPACE)) {
    doPauseResume();
    show(sDefaultTimeout);
    if (mPauseButton != null)
      mPauseButton.requestFocus();
    return true;
  } else if (keyCode == KeyEvent.KEYCODE_MEDIA_STOP) {
    if (mPlayer.isPlaying()) {
      mPlayer.pause();
      updatePausePlay();
    }
    return true;
  } else if (keyCode == KeyEvent.KEYCODE_BACK || keyCode == KeyEvent.KEYCODE_MENU) {
    hide();
    return true;
  } else {
    show(sDefaultTimeout);
  }
  return super.dispatchKeyEvent(event);
}
 

/**
 * You can call this function yourself to have the scroll view perform
 * scrolling from a key event, just as if the event had been dispatched to
 * it by the view hierarchy.
 *
 * @param event The key event to execute.
 * @return Return true if the event was handled, else false.
 */
public boolean executeKeyEvent(KeyEvent event) {
    boolean handled = false;
    if (event.getAction() == KeyEvent.ACTION_DOWN) {
        switch (event.getKeyCode()) {
            case KeyEvent.KEYCODE_DPAD_LEFT:
                handled = arrowScroll(FOCUS_LEFT);
                break;
            case KeyEvent.KEYCODE_DPAD_RIGHT:
                handled = arrowScroll(FOCUS_RIGHT);
                break;
            case KeyEvent.KEYCODE_TAB:
                if (Build.VERSION.SDK_INT >= 11) {
                    // The focus finder had a bug handling FOCUS_FORWARD and FOCUS_BACKWARD
                    // before Android 3.0. Ignore the tab key on those devices.
                    if (KeyEventCompat.hasNoModifiers(event)) {
                        handled = arrowScroll(FOCUS_FORWARD);
                    } else if (KeyEventCompat.hasModifiers(event, KeyEvent.META_SHIFT_ON)) {
                        handled = arrowScroll(FOCUS_BACKWARD);
                    }
                }
                break;
        }
    }
    return handled;
}
 

/**
 * You can call this function yourself to have the scroll view perform
 * scrolling from a key event, just as if the event had been dispatched to
 * it by the view hierarchy.
 *
 * @param event The key event to execute.
 * @return Return true if the event was handled, else false.
 */
public boolean executeKeyEvent(KeyEvent event) {
    boolean handled = false;
    if (event.getAction() == KeyEvent.ACTION_DOWN) {
        switch (event.getKeyCode()) {
            case KeyEvent.KEYCODE_DPAD_LEFT:
                handled = arrowScroll(FOCUS_LEFT);
                break;
            case KeyEvent.KEYCODE_DPAD_RIGHT:
                handled = arrowScroll(FOCUS_RIGHT);
                break;
            case KeyEvent.KEYCODE_TAB:
                if (Build.VERSION.SDK_INT >= 11) {
                    // The focus finder had a bug handling FOCUS_FORWARD and FOCUS_BACKWARD
                    // before Android 3.0. Ignore the tab key on those devices.
                    if (KeyEventCompat.hasNoModifiers(event)) {
                        handled = arrowScroll(FOCUS_FORWARD);
                    } else if (KeyEventCompat.hasModifiers(event, KeyEvent.META_SHIFT_ON)) {
                        handled = arrowScroll(FOCUS_BACKWARD);
                    }
                }
                break;
        }
    }
    return handled;
}
 

/**
 * Keyboard back button
 */
@Override
public boolean dispatchKeyEventPreIme(KeyEvent event) {

    if (mKeyboardMandatory) {
        if (getContext() != null) {
            InputMethodManager imm = (InputMethodManager) getContext()
                    .getSystemService(Context.INPUT_METHOD_SERVICE);

            if (imm.isActive() && event.getKeyCode() == KeyEvent.KEYCODE_BACK) {
                setImeVisibility(true);
                return true;
            }
        }
    }
    return super.dispatchKeyEventPreIme(event);
}
 

@Override
public boolean onKeyPreIme(int keyCode, KeyEvent event) {
    // Catch the back button on the soft keyboard so that we can just close the activity
    if (event.getKeyCode() == android.view.KeyEvent.KEYCODE_BACK) {
        mFolder.doneEditingFolderName(true);
    }
    return super.onKeyPreIme(keyCode, event);
}
 

/**
 * You can call this function yourself to have the scroll view perform
 * scrolling from a key event, just as if the event had been dispatched to
 * it by the view hierarchy.
 *
 * @param event The key event to execute.
 * @return Return true if the event was handled, else false.
 */
public boolean executeKeyEvent(KeyEvent event) {
 mTempRect.setEmpty();
 if (!canScroll()) {
	 if (isFocused()) {
		 View currentFocused = findFocus();
		 if (currentFocused == this) currentFocused = null;
		 View nextFocused = FocusFinder.getInstance().findNextFocus(this, currentFocused, View.FOCUS_DOWN);
		 return nextFocused != null && nextFocused != this && nextFocused.requestFocus(View.FOCUS_DOWN);
	 }
	 return false;
 }
 boolean handled = false;
 if (event.getAction() == KeyEvent.ACTION_DOWN) {
	 switch (event.getKeyCode()) {
	 case KeyEvent.KEYCODE_DPAD_UP:
		 if (!event.isAltPressed()) {
			 handled = arrowScroll(View.FOCUS_UP, false);
		 } else {
			 handled = fullScroll(View.FOCUS_UP, false);
		 }
		 break;
	 case KeyEvent.KEYCODE_DPAD_DOWN:
		 if (!event.isAltPressed()) {
			 handled = arrowScroll(View.FOCUS_DOWN, false);
		 } else {
			 handled = fullScroll(View.FOCUS_DOWN, false);
		 }
		 break;
	 case KeyEvent.KEYCODE_DPAD_LEFT:
		 if (!event.isAltPressed()) {
			 handled = arrowScroll(View.FOCUS_LEFT, true);
		 } else {
			 handled = fullScroll(View.FOCUS_LEFT, true);
		 }
		 break;
	 case KeyEvent.KEYCODE_DPAD_RIGHT:
		 if (!event.isAltPressed()) {
			 handled = arrowScroll(View.FOCUS_RIGHT, true);
		 } else {
			 handled = fullScroll(View.FOCUS_RIGHT, true);
		 }
		 break;
	 }
 }
 return handled;
}
 

@Override
public boolean onEditorAction(TextView view, int actionId, KeyEvent event) {
    if ((actionId == EditorInfo.IME_ACTION_DONE)
            || ((event.getKeyCode() == KeyEvent.KEYCODE_ENTER) && (event.getAction() == KeyEvent.ACTION_DOWN))) {
        searchTransactions();
        return true;
    }
    return true;
}
 

@Override
public void onReceive(Context context, Intent intent) {
	Log.d(THIS_FILE, "onReceive");
	if(uaReceiver == null) {
		return;
	}
	//	abortBroadcast();
    	//
		// Headset button has been pressed by user. Normally when 
		// the UI is active this event will never be generated instead
		// a headset button press will be handled as a regular key
		// press event.
		//
        if (Intent.ACTION_MEDIA_BUTTON.equals(intent.getAction())) {
			KeyEvent event = (KeyEvent)intent.getParcelableExtra(Intent.EXTRA_KEY_EVENT);
			Log.d(THIS_FILE, "Key : "+event.getKeyCode());
			if (event != null && 
					event.getAction() == KeyEvent.ACTION_DOWN && 
					event.getKeyCode() == KeyEvent.KEYCODE_HEADSETHOOK) {
				
	        	if (uaReceiver.handleHeadsetButton()) {
		        	//
					// After processing the event we will prevent other applications
					// from receiving the button press since we have handled it ourself
					// and do not want any media player to start playing for example.
					//
	        		/*
	        		 * TODO : enable this test if api > 5
	        		if (isOrderedBroadcast()) {
	        		*/
	        			abortBroadcast();
	        			/*
	        		}
	        		*/
	        	}
			}
		}

}
 

@Override
public boolean onKeyPreIme(int keyCode, @NonNull KeyEvent event) {
    if (event.getKeyCode() == KeyEvent.KEYCODE_BACK
            && event.getAction() == KeyEvent.ACTION_UP) {
        if (listener != null)
            listener.onStateChanged(this, false);
    }
    return super.onKeyPreIme(keyCode, event);
}
 

@Override
public boolean dispatchKeyEvent(KeyEvent event) {
    final int keyCode = event.getKeyCode();
    switch (keyCode) {
        case KeyEvent.KEYCODE_DPAD_CENTER:
        case KeyEvent.KEYCODE_ENTER:
            removeAllCallbacks();
            break;
        case KeyEvent.KEYCODE_DPAD_DOWN:
        case KeyEvent.KEYCODE_DPAD_UP:
            switch (event.getAction()) {
                case KeyEvent.ACTION_DOWN:
                    if (mWrapSelectorWheel || (keyCode == KeyEvent.KEYCODE_DPAD_DOWN) ? getValue() < getMaxValue() : getValue() > getMinValue()) {
                        requestFocus();
                        mLastHandledDownDpadKeyCode = keyCode;
                        removeAllCallbacks();
                        if (mFlingScroller.isFinished()) {
                            changeValueByOne(keyCode == KeyEvent.KEYCODE_DPAD_DOWN);
                        }
                        return true;
                    }
                    break;
                case KeyEvent.ACTION_UP:
                    if (mLastHandledDownDpadKeyCode == keyCode) {
                        mLastHandledDownDpadKeyCode = -1;
                        return true;
                    }
                    break;
            }
    }
    return super.dispatchKeyEvent(event);
}
 

@Override
public void onReceive(Context context, Intent intent) {

    String intentAction = intent.getAction();
    if (!Intent.ACTION_MEDIA_BUTTON.equals(intentAction)) {
        // intent wasn't a MEDIA BUTTON event.
        return;
    }

    KeyEvent event = intent.getParcelableExtra(Intent.EXTRA_KEY_EVENT);
    int keycode = event.getKeyCode();
    int action = event.getAction();

    // Switch on keycode and fire action only on KeyDown event.
    switch (keycode) {
        case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
        case KeyEvent.KEYCODE_HEADSETHOOK:
            if (action == KeyEvent.ACTION_DOWN) {
                sendAction(context, MediaSessionWrapper.ACTION_TOGGLE_PLAYBACK);
            }
            break;
        case KeyEvent.KEYCODE_MEDIA_NEXT:
            if (action == KeyEvent.ACTION_DOWN) {
                sendAction(context, MediaSessionWrapper.ACTION_NEXT_TRACK);
            }
            break;
        case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
            if (action == KeyEvent.ACTION_DOWN) {
                sendAction(context, MediaSessionWrapper.ACTION_PREVIOUS_TRACK);
            }
            break;
        default:
            break;
    }
}
 

@Override
public boolean dispatchKeyEvent(KeyEvent event) {
    final int keyCode = event.getKeyCode();
    switch (keyCode) {
        case KeyEvent.KEYCODE_DPAD_CENTER:
        case KeyEvent.KEYCODE_ENTER:
            removeAllCallbacks();
            break;
        case KeyEvent.KEYCODE_DPAD_DOWN:
        case KeyEvent.KEYCODE_DPAD_UP:
            if (!mHasSelectorWheel) {
                break;
            }
            switch (event.getAction()) {
                case KeyEvent.ACTION_DOWN:
                    if (mWrapSelectorWheel || ((keyCode == KeyEvent.KEYCODE_DPAD_DOWN)
                            ? getValue() < getMaxValue() : getValue() > getMinValue())) {
                        requestFocus();
                        mLastHandledDownDpadKeyCode = keyCode;
                        removeAllCallbacks();
                        if (mFlingScroller.isFinished()) {
                            changeValueByOne(keyCode == KeyEvent.KEYCODE_DPAD_DOWN);
                        }
                        return true;
                    }
                    break;
                case KeyEvent.ACTION_UP:
                    if (mLastHandledDownDpadKeyCode == keyCode) {
                        mLastHandledDownDpadKeyCode = -1;
                        return true;
                    }
                    break;
            }
    }
    return super.dispatchKeyEvent(event);
}
 

@Override
public void onReceive(Context context, Intent intent) {
    this.audioStreamingManager = AudioStreamingManager.getInstance(context);
    if(this.audioStreamingManager ==null){
        return;
    }
    if (intent.getAction().equals(Intent.ACTION_MEDIA_BUTTON)) {
        if (intent.getExtras() == null) {
            return;
        }
        KeyEvent keyEvent = (KeyEvent) intent.getExtras().get(Intent.EXTRA_KEY_EVENT);
        if (keyEvent == null) {
            return;
        }
        if (keyEvent.getAction() != KeyEvent.ACTION_DOWN)
            return;
        switch (keyEvent.getKeyCode()) {
            case KeyEvent.KEYCODE_HEADSETHOOK:
            case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
                if (this.audioStreamingManager .isPlaying()) {
                    this.audioStreamingManager .onPause();
                } else {
                    this.audioStreamingManager .onPlay(this.audioStreamingManager .getCurrentAudio());
                }
                break;
            case KeyEvent.KEYCODE_MEDIA_PLAY:
                this.audioStreamingManager .onPlay(this.audioStreamingManager .getCurrentAudio());
                break;
            case KeyEvent.KEYCODE_MEDIA_PAUSE:
                this.audioStreamingManager .onPause();
                break;
            case KeyEvent.KEYCODE_MEDIA_STOP:
                break;
            case KeyEvent.KEYCODE_MEDIA_NEXT:
                this.audioStreamingManager .onSkipToNext();
                break;
            case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
                this.audioStreamingManager .onSkipToPrevious();
                break;
        }
    } else {
        this.audioStreamingManager = AudioStreamingManager.getInstance(context);
        if (intent.getAction().equals(AudioStreamingService.NOTIFY_PLAY)) {
            this.audioStreamingManager.onPlay(this.audioStreamingManager.getCurrentAudio());
        } else if (intent.getAction().equals(AudioStreamingService.NOTIFY_PAUSE)
                || intent.getAction().equals(android.media.AudioManager.ACTION_AUDIO_BECOMING_NOISY)) {
            this.audioStreamingManager.onPause();
        } else if (intent.getAction().equals(AudioStreamingService.NOTIFY_NEXT)) {
            this.audioStreamingManager.onSkipToNext();
        } else if (intent.getAction().equals(AudioStreamingService.NOTIFY_CLOSE)) {
            this.audioStreamingManager.cleanupPlayer(context, true, true);
        } else if (intent.getAction().equals(AudioStreamingService.NOTIFY_PREVIOUS)) {
            this.audioStreamingManager.onSkipToPrevious();
        }
    }
}
 

@Override
protected boolean onKeyEvent(KeyEvent event) {
    if (null == event) return true; // WTF??

    // Make sure we're not in the middle of a phone call.
    if (null != mVolumePanel && mVolumePanel.getCallState() != TelephonyManager.CALL_STATE_IDLE)
        return super.onKeyEvent(event);

    final int flags = event.getFlags();
    final int code = event.getKeyCode();
    final boolean system = ((flags & KeyEvent.FLAG_FROM_SYSTEM) == KeyEvent.FLAG_FROM_SYSTEM);

    // Specifically avoid software keys or "fake" hardware buttons.
    if (((flags & KeyEvent.FLAG_SOFT_KEYBOARD) == KeyEvent.FLAG_SOFT_KEYBOARD) ||
        ((flags & KeyEvent.FLAG_VIRTUAL_HARD_KEY) == KeyEvent.FLAG_VIRTUAL_HARD_KEY)) {
        return super.onKeyEvent(event);
    } else {
        // Specifically avoid handling certain keys. We never want to interfere
        // with them or harm performance in any way.
        switch (code) {
            case KeyEvent.KEYCODE_BACK:
            case KeyEvent.KEYCODE_HOME:
            case KeyEvent.KEYCODE_MENU:
            case KeyEvent.KEYCODE_POWER:
            case KeyEvent.KEYCODE_SEARCH:
                return super.onKeyEvent(event);
        }
    }

    if (!system) return super.onKeyEvent(event);

    LOGI(TAG, "--onKeyEvent(code=" + event.getKeyCode() + ", action=" + event.getAction() +
            ", topPackage=" + mCurrentActivityPackage + ", disabledButtons=" + disabledButtons + ')');

    // Check if we're supposed to disable Noyze for a Blacklisted app.
    if (blacklist.contains(mCurrentActivityPackage)) {
        if (null != mVolumePanel) mVolumePanel.setEnabled(false);
        return super.onKeyEvent(event);
    } else {
        // NOTE: we need a "safe" way to enable the volume panel that
        // takes into consideration its previous state.
        if (null != mVolumePanel) mVolumePanel.enable();
    }

    // If we're told to disable one or more of the volume buttons, do so (returning true consumes the event).
    if (disabledButtons == code) return true;
    // NOTE: KeyEvent#KEYCODE_VOLUME_DOWN + KeyEvent#KEYCODE_VOLUME_UP == KeyEvent_KEYCODE_U
    final int upAndDown = (KeyEvent.KEYCODE_VOLUME_DOWN + KeyEvent.KEYCODE_VOLUME_UP); // 49
    final int upSquared = KeyEvent.KEYCODE_VOLUME_UP * KeyEvent.KEYCODE_VOLUME_UP; // 576
    if (disabledButtons == upAndDown && Utils.isVolumeKeyCode(upAndDown - code)) return true;
    if (disabledButtons == upSquared && mVolumePanel != null && mVolumePanel.isLocked()) return true;
    if (disabledButtons == upSquared && KEYGUARD.equals(mCurrentActivityPackage)) return true;

    // Check if the volume panel has been disabled, or shouldn't handle this event (e.g. "safe volume").
    if (null != mVolumePanel && mVolumePanel.isEnabled()) {
        if (Utils.isVolumeKeyCode(code)) {
            Message.obtain(mHandler, MESSAGE_KEY_EVENT, event).sendToTarget(); // Run asynchronously
            return true;
        }
    }

	return super.onKeyEvent(event);
}
 

@Override
public boolean dispatchKeyEvent(KeyEvent event) {
    final boolean handled = super.dispatchKeyEvent(event);

    // unhandled key events change focus to tab indicator for embedded
    // activities when there is nothing that will take focus from default
    // focus searching
    if (!handled
            && (event.getAction() == KeyEvent.ACTION_DOWN)
            && (mCurrentView != null)
            && (mCurrentView.isRootNamespace())
            && (mCurrentView.hasFocus())) {
        int keyCodeShouldChangeFocus = KeyEvent.KEYCODE_DPAD_UP;
        int directionShouldChangeFocus = View.FOCUS_UP;
        int soundEffect = SoundEffectConstants.NAVIGATION_UP;

        switch (getTabWidgetLocation()) {
            case TABWIDGET_LOCATION_LEFT:
                keyCodeShouldChangeFocus = KeyEvent.KEYCODE_DPAD_LEFT;
                directionShouldChangeFocus = View.FOCUS_LEFT;
                soundEffect = SoundEffectConstants.NAVIGATION_LEFT;
                break;
            case TABWIDGET_LOCATION_RIGHT:
                keyCodeShouldChangeFocus = KeyEvent.KEYCODE_DPAD_RIGHT;
                directionShouldChangeFocus = View.FOCUS_RIGHT;
                soundEffect = SoundEffectConstants.NAVIGATION_RIGHT;
                break;
            case TABWIDGET_LOCATION_BOTTOM:
                keyCodeShouldChangeFocus = KeyEvent.KEYCODE_DPAD_DOWN;
                directionShouldChangeFocus = View.FOCUS_DOWN;
                soundEffect = SoundEffectConstants.NAVIGATION_DOWN;
                break;
            case TABWIDGET_LOCATION_TOP:
            default:
                keyCodeShouldChangeFocus = KeyEvent.KEYCODE_DPAD_UP;
                directionShouldChangeFocus = View.FOCUS_UP;
                soundEffect = SoundEffectConstants.NAVIGATION_UP;
                break;
        }
        if (event.getKeyCode() == keyCodeShouldChangeFocus
                && mCurrentView.findFocus().focusSearch(directionShouldChangeFocus) == null) {
            mTabWidget.getChildTabViewAt(mCurrentTab).requestFocus();
            playSoundEffect(soundEffect);
            return true;
        }
    }
    return handled;
}
 

@Override
public boolean dispatchKeyEvent(KeyEvent event) {
    int keyCode = event.getKeyCode();
    final boolean uniqueDown = event.getRepeatCount() == 0
            && event.getAction() == KeyEvent.ACTION_DOWN;
    if (keyCode == KeyEvent.KEYCODE_HEADSETHOOK
            || keyCode == KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE
            || keyCode == KeyEvent.KEYCODE_SPACE) {
        if (uniqueDown) {
            doPauseResume();
            show(sDefaultTimeout);
            if (mTurnButton != null) {
                mTurnButton.requestFocus();
            }
        }
        return true;
    } else if (keyCode == KeyEvent.KEYCODE_MEDIA_PLAY) {
        if (uniqueDown && !mPlayer.isPlaying()) {
            mPlayer.start();
            updatePausePlay();
            show(sDefaultTimeout);
        }
        return true;
    } else if (keyCode == KeyEvent.KEYCODE_MEDIA_STOP
            || keyCode == KeyEvent.KEYCODE_MEDIA_PAUSE) {
        if (uniqueDown && mPlayer.isPlaying()) {
            mPlayer.pause();
            updatePausePlay();
            show(sDefaultTimeout);
        }
        return true;
    } else if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN
            || keyCode == KeyEvent.KEYCODE_VOLUME_UP
            || keyCode == KeyEvent.KEYCODE_VOLUME_MUTE
            || keyCode == KeyEvent.KEYCODE_CAMERA) {
        // don't show the controls for volume adjustment
        return super.dispatchKeyEvent(event);
    } else if (keyCode == KeyEvent.KEYCODE_BACK || keyCode == KeyEvent.KEYCODE_MENU) {
        if (uniqueDown) {
            hide();
        }
        return true;
    }

    show(sDefaultTimeout);
    return super.dispatchKeyEvent(event);
}