下面列出了android.view.KeyEvent#KEYCODE_MEDIA_NEXT 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
@Override
public void onClick(View v) {
LOGD("VolumePanel", "onClick(" + v.getId() + ')');
Integer keyCode = null;
switch (v.getId()) {
case R.id.media_previous:
keyCode = KeyEvent.KEYCODE_MEDIA_PREVIOUS;
break;
case R.id.media_play_pause:
keyCode = KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE;
break;
case R.id.media_next:
keyCode = KeyEvent.KEYCODE_MEDIA_NEXT;
break;
default:
return;
}
onUserInteraction();
Message.obtain(mHandler, MSG_DISPATCH_KEYEVENT, keyCode, 0).sendToTarget();
}
static boolean isMediaKey(int keyCode) {
switch (keyCode) {
case KEYCODE_MEDIA_PLAY:
case KEYCODE_MEDIA_PAUSE:
case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
case KeyEvent.KEYCODE_MUTE:
case KeyEvent.KEYCODE_HEADSETHOOK:
case KeyEvent.KEYCODE_MEDIA_STOP:
case KeyEvent.KEYCODE_MEDIA_NEXT:
case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
case KeyEvent.KEYCODE_MEDIA_REWIND:
case KEYCODE_MEDIA_RECORD:
case KeyEvent.KEYCODE_MEDIA_FAST_FORWARD: {
return true;
}
}
return false;
}
static boolean isMediaKey(int keyCode) {
switch (keyCode) {
case KEYCODE_MEDIA_PLAY:
case KEYCODE_MEDIA_PAUSE:
case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
case KeyEvent.KEYCODE_MUTE:
case KeyEvent.KEYCODE_HEADSETHOOK:
case KeyEvent.KEYCODE_MEDIA_STOP:
case KeyEvent.KEYCODE_MEDIA_NEXT:
case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
case KeyEvent.KEYCODE_MEDIA_REWIND:
case KEYCODE_MEDIA_RECORD:
case KeyEvent.KEYCODE_MEDIA_FAST_FORWARD: {
return true;
}
}
return false;
}
/**
* @return True if a {@link android.view.KeyEvent} corresponds to a media action.
*/
public static boolean isMediaKeyCode(final int keyCode) {
switch (keyCode) {
case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
case KeyEvent.KEYCODE_MEDIA_PLAY:
case KeyEvent.KEYCODE_MEDIA_AUDIO_TRACK:
case KeyEvent.KEYCODE_MEDIA_PAUSE:
case KeyEvent.KEYCODE_MEDIA_CLOSE:
case KeyEvent.KEYCODE_MEDIA_EJECT:
case KeyEvent.KEYCODE_MEDIA_NEXT:
case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
case KeyEvent.KEYCODE_MEDIA_STOP:
case KeyEvent.KEYCODE_MEDIA_RECORD:
case KeyEvent.KEYCODE_MEDIA_REWIND:
case KeyEvent.KEYCODE_MEDIA_FAST_FORWARD:
return true;
}
return false;
}
@SuppressLint("InlinedApi")
private static boolean isHandledMediaKey(int keyCode) {
return keyCode == KeyEvent.KEYCODE_MEDIA_FAST_FORWARD
|| keyCode == KeyEvent.KEYCODE_MEDIA_REWIND
|| keyCode == KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE
|| keyCode == KeyEvent.KEYCODE_MEDIA_PLAY
|| keyCode == KeyEvent.KEYCODE_MEDIA_PAUSE
|| keyCode == KeyEvent.KEYCODE_MEDIA_NEXT
|| keyCode == KeyEvent.KEYCODE_MEDIA_PREVIOUS;
}
/**
* Whether the keyCode represents a media button that we handle.
*
* @param keyCode
* @return
*/
public static boolean isMediaButton(int keyCode) {
return keyCode == KeyEvent.KEYCODE_MEDIA_FAST_FORWARD || keyCode == KeyEvent.KEYCODE_MEDIA_NEXT
|| keyCode == KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE || keyCode == KeyEvent.KEYCODE_MEDIA_PREVIOUS
|| keyCode == KeyEvent.KEYCODE_MEDIA_REWIND || keyCode == KeyEvent.KEYCODE_MEDIA_STOP
|| keyCode == KEYCODE_MEDIA_PLAY || keyCode == KEYCODE_MEDIA_PAUSE
|| keyCode == KeyEvent.KEYCODE_HEADSETHOOK;
}
/**
* {@inheritDoc}
*/
public void sendMediaAction(int action) {
if (mService == null) {
Log.w(TAG, "Sending a media action on stopped controller.");
return;
}
int keyCode;
switch (action) {
case ACTION_PLAY_PAUSE:
keyCode = KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE;
break;
case ACTION_STOP:
keyCode = KeyEvent.KEYCODE_MEDIA_STOP;
break;
case ACTION_SKIP_TO_NEXT:
keyCode = KeyEvent.KEYCODE_MEDIA_NEXT;
break;
case ACTION_SKIP_TO_PREVIOUS:
keyCode = KeyEvent.KEYCODE_MEDIA_PREVIOUS;
break;
default:
throw new IllegalArgumentException();
}
// TODO We should think about sending these up/down events accurately with touch up/down
// on the buttons, but in the near term this will interfere with the long press behavior.
RemoteController rc = mService.getRemoteController();
rc.sendMediaKeyEvent(new KeyEvent(KeyEvent.ACTION_DOWN, keyCode));
rc.sendMediaKeyEvent(new KeyEvent(KeyEvent.ACTION_UP, keyCode));
}
/**
* {@inheritDoc}
*/
@Override
public void onReceive(final Context context, final Intent intent) {
Log.d(TAG, "Received action " + intent.getAction());
if (intent.getAction().equals(SERVICECMD) ) {
int keycode = intent.getIntExtra(SERVICECMD, 0);
Log.d(TAG, "Recieved key" + keycode);
switch (keycode) {
case KeyEvent.KEYCODE_MEDIA_FAST_FORWARD:
resetNotify(true);
break;
case KeyEvent.KEYCODE_MEDIA_STOP:
case KeyEvent.KEYCODE_HEADSETHOOK:
case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
case KeyEvent.KEYCODE_MEDIA_PLAY:
case KeyEvent.KEYCODE_MEDIA_PAUSE:
removeNotification();
break;
case KeyEvent.KEYCODE_MEDIA_NEXT:
showNotify(1);
break;
case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
showNotify(-1);
break;
}
}
}
@Override
public void onReceive(Context context, Intent intent) {
if (intent.getAction().equals(Intent.ACTION_MEDIA_BUTTON)) {
KeyEvent event = intent.getParcelableExtra(Intent.EXTRA_KEY_EVENT);
if (event == null)
return;
if (event.getAction() != KeyEvent.ACTION_DOWN)
return;
switch (event.getKeyCode())
{
case KeyEvent.KEYCODE_MEDIA_STOP:
case KeyEvent.KEYCODE_HEADSETHOOK:
case KeyEvent.KEYCODE_MEDIA_PLAY:
sendMessage(context, PlayerService.PLAY);
break;
case KeyEvent.KEYCODE_MEDIA_PAUSE:
sendMessage(context, PlayerService.PLAY);
break;
case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
sendMessage(context, PlayerService.PLAY);
break;
case KeyEvent.KEYCODE_MEDIA_NEXT:
sendMessage(context, PlayerService.NEXT);
break;
case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
sendMessage(context, PlayerService.PREV);
break;
case KeyEvent.KEYCODE_VOLUME_UP:
sendMessage(context, PlayerService.VOLUME_UP);
break;
case KeyEvent.KEYCODE_VOLUME_DOWN:
sendMessage(context, PlayerService.VOLUME_DOWN);
break;
}
}
}
@Override
public void onReceive(Context context, Intent intent) {
mApp = (Common) context.getApplicationContext();
if (intent.getAction().equals(Intent.ACTION_MEDIA_BUTTON)) {
KeyEvent keyEvent = (KeyEvent) intent.getExtras().get(Intent.EXTRA_KEY_EVENT);
if (keyEvent.getAction() != KeyEvent.ACTION_DOWN)
return;
switch (keyEvent.getKeyCode()) {
case KeyEvent.KEYCODE_HEADSETHOOK:
mApp.getPlayBackStarter().playSongs();
break;
case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
mApp.getPlayBackStarter().pauseSong();
break;
case KeyEvent.KEYCODE_MEDIA_PLAY:
mApp.getPlayBackStarter().playSongs();
break;
case KeyEvent.KEYCODE_MEDIA_PAUSE:
mApp.getPlayBackStarter().pauseSong();
break;
case KeyEvent.KEYCODE_MEDIA_STOP:
mApp.getPlayBackStarter().pauseSong();
break;
case KeyEvent.KEYCODE_MEDIA_NEXT:
mApp.getPlayBackStarter().nextSong();
break;
case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
mApp.getPlayBackStarter().previousSong();
break;
default:
break;
}
}
}
@Override
public void onReceive(Context context, Intent intent) {
String intentAction = intent.getAction();
if (Intent.ACTION_MEDIA_BUTTON.equals(intentAction)) {
KeyEvent keyEvent = (KeyEvent) intent.getParcelableExtra(Intent.EXTRA_KEY_EVENT);
if (keyEvent == null) {
return;
}
int action = keyEvent.getAction();
int keyCode = keyEvent.getKeyCode();
long eventTime = keyEvent.getEventTime();
LogUtil.d(TAG, "carlife: onReceive is triggered!");
if (action == KeyEvent.ACTION_UP) {
switch (keyCode) {
case KeyEvent.KEYCODE_HEADSETHOOK:
break;
case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
LogUtil.d(TAG, "KEYCODE_MEDIA_PREVIOUS");
TouchListenerManager.getInstance().sendHardKeyCodeEvent(CommonParams.KEYCODE_SEEK_SUB);
break;
case KeyEvent.KEYCODE_MEDIA_NEXT:
LogUtil.d(TAG, "KEYCODE_MEDIA_NEXT");
TouchListenerManager.getInstance().sendHardKeyCodeEvent(CommonParams.KEYCODE_SEEK_ADD);
break;
default:
break;
}
}
if (isOrderedBroadcast()) {
abortBroadcast();
}
}
}
@VisibleForTesting
void processAction(Intent intent, MediaNotificationManager manager) {
String action = intent.getAction();
// Before Android L, instead of using the MediaSession callback, the system will fire
// ACTION_MEDIA_BUTTON intents which stores the information about the key event.
if (Intent.ACTION_MEDIA_BUTTON.equals(action)) {
KeyEvent event = (KeyEvent) intent.getParcelableExtra(Intent.EXTRA_KEY_EVENT);
if (event == null) return;
if (event.getAction() != KeyEvent.ACTION_DOWN) return;
switch (event.getKeyCode()) {
case KeyEvent.KEYCODE_MEDIA_PLAY:
manager.onPlay(
MediaNotificationListener.ACTION_SOURCE_MEDIA_SESSION);
break;
case KeyEvent.KEYCODE_MEDIA_PAUSE:
manager.onPause(
MediaNotificationListener.ACTION_SOURCE_MEDIA_SESSION);
break;
case KeyEvent.KEYCODE_HEADSETHOOK:
case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
if (manager.mMediaNotificationInfo.isPaused) {
manager.onPlay(MediaNotificationListener.ACTION_SOURCE_MEDIA_SESSION);
} else {
manager.onPause(
MediaNotificationListener.ACTION_SOURCE_MEDIA_SESSION);
}
break;
case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
manager.onMediaSessionAction(MediaSessionAction.PREVIOUS_TRACK);
break;
case KeyEvent.KEYCODE_MEDIA_NEXT:
manager.onMediaSessionAction(MediaSessionAction.NEXT_TRACK);
break;
case KeyEvent.KEYCODE_MEDIA_FAST_FORWARD:
manager.onMediaSessionAction(MediaSessionAction.SEEK_FORWARD);
break;
case KeyEvent.KEYCODE_MEDIA_REWIND:
manager.onMediaSessionAction(MediaSessionAction.SEEK_BACKWARD);
break;
default:
break;
}
} else if (ACTION_STOP.equals(action)
|| ACTION_SWIPE.equals(action)
|| ACTION_CANCEL.equals(action)) {
manager.onStop(
MediaNotificationListener.ACTION_SOURCE_MEDIA_NOTIFICATION);
stopListenerService();
} else if (ACTION_PLAY.equals(action)) {
manager.onPlay(MediaNotificationListener.ACTION_SOURCE_MEDIA_NOTIFICATION);
} else if (ACTION_PAUSE.equals(action)) {
manager.onPause(MediaNotificationListener.ACTION_SOURCE_MEDIA_NOTIFICATION);
} else if (AudioManager.ACTION_AUDIO_BECOMING_NOISY.equals(action)) {
manager.onPause(MediaNotificationListener.ACTION_SOURCE_HEADSET_UNPLUG);
} else if (ACTION_PREVIOUS_TRACK.equals(action)) {
manager.onMediaSessionAction(MediaSessionAction.PREVIOUS_TRACK);
} else if (ACTION_NEXT_TRACK.equals(action)) {
manager.onMediaSessionAction(MediaSessionAction.NEXT_TRACK);
} else if (ACTION_SEEK_FORWARD.equals(action)) {
manager.onMediaSessionAction(MediaSessionAction.SEEK_FORWARD);
} else if (ACTION_SEEK_BACKWARD.equals(action)) {
manager.onMediaSessionAction(MediaSessionAction.SEEK_BACKWARD);
}
}
@Override
public void onReceive(Context context, Intent intent) {
if (!MusicPlayer.isMusicPlyerEnable) {
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:
MusicPlayer.playAndPause();
break;
case KeyEvent.KEYCODE_MEDIA_PLAY:
if (MusicPlayer.isPause) {
MusicPlayer.playAndPause();
}
break;
case KeyEvent.KEYCODE_MEDIA_PAUSE:
if (!MusicPlayer.isPause) {
MusicPlayer.playAndPause();
}
break;
case KeyEvent.KEYCODE_MEDIA_STOP:
MusicPlayer.stopSound();
break;
case KeyEvent.KEYCODE_MEDIA_NEXT:
MusicPlayer.nextMusic();
break;
case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
MusicPlayer.previousMusic();
break;
}
}
}
@Override
public boolean dispatchKeyEvent(KeyEvent event) {
if (event.getAction() == KeyEvent.ACTION_DOWN) {
Log.d("dtube","Key event "+event.getKeyCode()+"VS"+KeyEvent.KEYCODE_MEDIA_REWIND);
switch (event.getKeyCode()) {
case KeyEvent.KEYCODE_ENTER:
case KeyEvent.KEYCODE_DPAD_CENTER:
if (getCurrentFocus() != null && getCurrentFocus() instanceof ViewGroup) {
//Open a dialog for options on a comment
if (getCurrentFocus().getId() == R.id.comments_lv) {
final View commentView = commentsListView.getSelectedView();
final AlertDialog.Builder builderSingle = new AlertDialog.Builder(VideoPlayActivity.this);
ArrayAdapter<String> arrayAdapter = new ArrayAdapter<>(VideoPlayActivity.this, android.R.layout.select_dialog_item);
arrayAdapter.add(getResources().getString(R.string.like_comment));
arrayAdapter.add(getResources().getString(R.string.dislike_comment));
builderSingle.setNegativeButton("cancel", null);
builderSingle.setAdapter(arrayAdapter, (dialog, which) -> {
switch (which) {
case 0:
commentView.findViewById(R.id.comment_like).performClick();
break;
case 1:
commentView.findViewById(R.id.comment_dislike).performClick();
break;
case 2:
commentView.findViewById(R.id.comment_reply).performClick();
break;
}
});
//dialog display is delayed to prevent misfocus
commentView.postDelayed(builderSingle::show,10);
Log.d("dtube", "dispatch" + ((ViewGroup) getCurrentFocus()).getChildAt(0).getId() + "VS" + R.id.comment_item);
}else if (getCurrentFocus().getId() == R.id.suggestions_lv) {
//select the suggested video
onItemClick(suggestedVideosListView.getSelectedItemPosition());
}
}
break;
case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
wakeMediaControls();
MediaPlayerSingleton.getInstance(this).togglePlayPause();
break;
case KeyEvent.KEYCODE_MEDIA_REWIND:
case KeyEvent.KEYCODE_MEDIA_STEP_BACKWARD:
case KeyEvent.KEYCODE_MEDIA_SKIP_BACKWARD:
case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
wakeMediaControls();
MediaPlayerSingleton.getInstance(this).rewind();
break;
case KeyEvent.KEYCODE_MEDIA_FAST_FORWARD:
case KeyEvent.KEYCODE_MEDIA_SKIP_FORWARD:
case KeyEvent.KEYCODE_MEDIA_STEP_FORWARD:
case KeyEvent.KEYCODE_MEDIA_NEXT:
wakeMediaControls();
MediaPlayerSingleton.getInstance(this).fastForward();
break;
}
}
return super.dispatchKeyEvent(event);
}
@Override
public void onReceive(Context context, Intent intent) {
if (intent.getAction().equals(Intent.ACTION_MEDIA_BUTTON)) {
KeyEvent event = (KeyEvent) intent
.getParcelableExtra(Intent.EXTRA_KEY_EVENT);
if (event == null) {
return;
}
if (event.getAction() != KeyEvent.ACTION_DOWN) {
return;
}
switch (event.getKeyCode()) {
case KeyEvent.KEYCODE_MEDIA_STOP:
case KeyEvent.KEYCODE_HEADSETHOOK:
case KeyEvent.KEYCODE_MEDIA_PLAY:
sendMessage(context, "play");
break;
case KeyEvent.KEYCODE_MEDIA_PAUSE:
sendMessage(context, "play");
break;
case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
sendMessage(context, "play");
break;
case KeyEvent.KEYCODE_MEDIA_NEXT:
sendMessage(context, "next");
break;
case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
sendMessage(context, "prev");
break;
case KeyEvent.KEYCODE_VOLUME_UP:
sendMessage(context, "voup");
break;
case KeyEvent.KEYCODE_VOLUME_DOWN:
sendMessage(context, "vodn");
break;
}
}
}
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() != 0 ?
event.getEventTime() : System.currentTimeMillis();
// Fallback to system time if event time was not available.
String command = null;
switch (keycode) {
case KeyEvent.KEYCODE_MEDIA_STOP:
command = MusicService.ACTION_STOP;
break;
case KeyEvent.KEYCODE_HEADSETHOOK:
case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
command = MusicService.ACTION_TOGGLE_PAUSE;
break;
case KeyEvent.KEYCODE_MEDIA_NEXT:
command = MusicService.ACTION_SKIP;
break;
case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
command = MusicService.ACTION_REWIND;
break;
case KeyEvent.KEYCODE_MEDIA_PAUSE:
command = MusicService.ACTION_PAUSE;
break;
case KeyEvent.KEYCODE_MEDIA_PLAY:
command = MusicService.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 || keycode == KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE) {
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 onKeyDown(int keyCode, KeyEvent event) {
if (keyCode == KeyEvent.KEYCODE_BACK || keyCode == KeyEvent.KEYCODE_BUTTON_B)
return super.onKeyDown(keyCode, event);
if (mIsLoading) {
switch (keyCode) {
case KeyEvent.KEYCODE_S:
case KeyEvent.KEYCODE_MEDIA_STOP:
exitOK();
return true;
}
return false;
}
showOverlayTimeout(OVERLAY_TIMEOUT);
switch (keyCode) {
case KeyEvent.KEYCODE_F:
case KeyEvent.KEYCODE_MEDIA_FAST_FORWARD:
case KeyEvent.KEYCODE_MEDIA_NEXT:
seekDelta(10000);
return true;
case KeyEvent.KEYCODE_R:
case KeyEvent.KEYCODE_MEDIA_REWIND:
case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
seekDelta(-10000);
return true;
case KeyEvent.KEYCODE_BUTTON_R1:
seekDelta(60000);
return true;
case KeyEvent.KEYCODE_BUTTON_L1:
seekDelta(-60000);
return true;
case KeyEvent.KEYCODE_BUTTON_A:
if (mOverlayProgress.getVisibility() == View.VISIBLE)
return false;
case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
case KeyEvent.KEYCODE_MEDIA_PLAY:
case KeyEvent.KEYCODE_MEDIA_PAUSE:
case KeyEvent.KEYCODE_SPACE:
if (mIsNavMenu)
return navigateDvdMenu(keyCode);
else if (keyCode == KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE) //prevent conflict with remote control
return super.onKeyDown(keyCode, event);
else
doPlayPause();
return true;
case KeyEvent.KEYCODE_O:
case KeyEvent.KEYCODE_BUTTON_Y:
case KeyEvent.KEYCODE_MENU:
showAdvancedOptions(mAdvOptions);
return true;
case KeyEvent.KEYCODE_V:
case KeyEvent.KEYCODE_MEDIA_AUDIO_TRACK:
case KeyEvent.KEYCODE_BUTTON_X:
onAudioSubClick(mTracks);
return true;
case KeyEvent.KEYCODE_N:
showNavMenu();
return true;
case KeyEvent.KEYCODE_A:
resizeVideo();
return true;
case KeyEvent.KEYCODE_M:
case KeyEvent.KEYCODE_VOLUME_MUTE:
updateMute();
return true;
case KeyEvent.KEYCODE_S:
case KeyEvent.KEYCODE_MEDIA_STOP:
exitOK();
return true;
case KeyEvent.KEYCODE_DPAD_UP:
case KeyEvent.KEYCODE_DPAD_DOWN:
case KeyEvent.KEYCODE_DPAD_LEFT:
case KeyEvent.KEYCODE_DPAD_RIGHT:
case KeyEvent.KEYCODE_DPAD_CENTER:
case KeyEvent.KEYCODE_ENTER:
if (mIsNavMenu)
return navigateDvdMenu(keyCode);
else
return super.onKeyDown(keyCode, event);
case KeyEvent.KEYCODE_J:
delayAudio(-50000l);
return true;
case KeyEvent.KEYCODE_K:
delayAudio(50000l);
return true;
case KeyEvent.KEYCODE_G:
delaySubs(-50000l);
return true;
case KeyEvent.KEYCODE_H:
delaySubs(50000l);
return true;
case KeyEvent.KEYCODE_VOLUME_DOWN:
case KeyEvent.KEYCODE_VOLUME_UP:
if (mMute) {
updateMute();
return true;
} else
return false;
}
return super.onKeyDown(keyCode, event);
}
@Override
public void onReceive(final Context context, final Intent intent) {
final String intentAction = intent.getAction();
if (AudioManager.ACTION_AUDIO_BECOMING_NOISY.equals(intentAction)) {
if (PreferencesUtility.getInstance(context).pauseEnabledOnDetach())
startService(context, MusicService.CMDPAUSE);
} else if (Intent.ACTION_MEDIA_BUTTON.equals(intentAction)) {
final KeyEvent event = intent.getParcelableExtra(Intent.EXTRA_KEY_EVENT);
if (event == null) {
return;
}
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 = MusicService.CMDSTOP;
break;
case KeyEvent.KEYCODE_HEADSETHOOK:
case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
command = MusicService.CMDTOGGLEPAUSE;
break;
case KeyEvent.KEYCODE_MEDIA_NEXT:
command = MusicService.CMDNEXT;
break;
case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
command = MusicService.CMDPREVIOUS;
break;
case KeyEvent.KEYCODE_MEDIA_PAUSE:
command = MusicService.CMDPAUSE;
break;
case KeyEvent.KEYCODE_MEDIA_PLAY:
command = MusicService.CMDPLAY;
break;
}
if (command != null) {
if (action == KeyEvent.ACTION_DOWN) {
if (mDown) {
if (MusicService.CMDTOGGLEPAUSE.equals(command)
|| MusicService.CMDPLAY.equals(command)) {
if (mLastClickTime != 0
&& eventtime - mLastClickTime > LONG_PRESS_DELAY) {
acquireWakeLockAndSendMessage(context,
mHandler.obtainMessage(MSG_LONGPRESS_TIMEOUT, context), 0);
}
}
} else if (event.getRepeatCount() == 0) {
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);
}
mLaunched = false;
mDown = true;
}
} else {
mHandler.removeMessages(MSG_LONGPRESS_TIMEOUT);
mDown = false;
}
if (isOrderedBroadcast()) {
abortBroadcast();
}
releaseWakeLockIfHandlerIdle();
}
}
}
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 = MusicService.ACTION_STOP;
break;
case KeyEvent.KEYCODE_HEADSETHOOK:
case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
command = MusicService.ACTION_TOGGLE_PAUSE;
break;
case KeyEvent.KEYCODE_MEDIA_NEXT:
command = MusicService.ACTION_SKIP;
break;
case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
command = MusicService.ACTION_REWIND;
break;
case KeyEvent.KEYCODE_MEDIA_PAUSE:
command = MusicService.ACTION_PAUSE;
break;
case KeyEvent.KEYCODE_MEDIA_PLAY:
command = MusicService.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 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();
}
}
}