Example usage for android.view KeyEvent KEYCODE_MEDIA_NEXT

List of usage examples for android.view KeyEvent KEYCODE_MEDIA_NEXT

Introduction

In this page you can find the example usage for android.view KeyEvent KEYCODE_MEDIA_NEXT.

Prototype

int KEYCODE_MEDIA_NEXT

To view the source code for android.view KeyEvent KEYCODE_MEDIA_NEXT.

Click Source Link

Document

Key code constant: Play Next media key.

Usage

From source file:com.achep.acdisplay.services.media.MediaController2.java

/**
 * Emulates hardware buttons' click via broadcast system.
 *
 * @see android.view.KeyEvent//from w w  w.j a v a  2s.  com
 */
public static void broadcastMediaAction(@NonNull Context context, int action) {
    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();
    }

    Intent intent = new Intent(Intent.ACTION_MEDIA_BUTTON);
    KeyEvent keyDown = new KeyEvent(KeyEvent.ACTION_DOWN, keyCode);
    KeyEvent keyUp = new KeyEvent(KeyEvent.ACTION_UP, keyCode);

    context.sendOrderedBroadcast(intent.putExtra(Intent.EXTRA_KEY_EVENT, keyDown), null);
    context.sendOrderedBroadcast(intent.putExtra(Intent.EXTRA_KEY_EVENT, keyUp), null);
}

From source file:com.koma.music.service.MediaButtonIntentReceiver.java

@Override
public void onReceive(final Context context, final Intent intent) {
    LogUtils.i(TAG, "Received intent: " + intent);
    final String intentAction = intent.getAction();
    if (AudioManager.ACTION_AUDIO_BECOMING_NOISY.equals(intentAction)) {
        startService(context, MusicServiceConstants.CMDPAUSE, System.currentTimeMillis());
    } else if (Intent.ACTION_MEDIA_BUTTON.equals(intentAction)) {
        final KeyEvent event = intent.getParcelableExtra(Intent.EXTRA_KEY_EVENT);
        if (event == null || event.getAction() != KeyEvent.ACTION_UP) {
            return;
        }/*from   www  .  ja  v  a2 s  .  co m*/

        String command = null;
        switch (event.getKeyCode()) {
        case KeyEvent.KEYCODE_HEADSETHOOK:
            command = MusicServiceConstants.CMDHEADSETHOOK;
            break;
        case KeyEvent.KEYCODE_MEDIA_STOP:
            command = MusicServiceConstants.CMDSTOP;
            break;
        case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
            command = MusicServiceConstants.CMDTOGGLEPAUSE;
            break;
        case KeyEvent.KEYCODE_MEDIA_NEXT:
            command = MusicServiceConstants.CMDNEXT;
            break;
        case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
            command = MusicServiceConstants.CMDPREVIOUS;
            break;
        case KeyEvent.KEYCODE_MEDIA_PAUSE:
            command = MusicServiceConstants.CMDPAUSE;
            break;
        case KeyEvent.KEYCODE_MEDIA_PLAY:
            command = MusicServiceConstants.CMDPLAY;
            break;
        }
        if (command != null) {
            startService(context, command, event.getEventTime());
            if (isOrderedBroadcast()) {
                abortBroadcast();
            }
        }
    }
}

From source file:com.vuze.android.remote.AndroidUtilsUI.java

public static boolean handleCommonKeyDownEvents(Activity a, int keyCode, KeyEvent event) {
    if (event.getAction() != KeyEvent.ACTION_DOWN) {
        return false;
    }//from ww  w.j a  v a 2s .  co  m
    switch (keyCode) {
    case KeyEvent.KEYCODE_MEDIA_NEXT:
    case KeyEvent.KEYCODE_MEDIA_FAST_FORWARD: {
        ViewGroup vg = (ViewGroup) a.findViewById(android.R.id.content);
        ArrayList list = AndroidUtilsUI.findByClass(vg, ViewPager.class, new ArrayList<View>(0));

        if (list.size() > 0) {
            ViewPager viewPager = (ViewPager) list.get(0);
            viewPager.arrowScroll(View.FOCUS_RIGHT);
        }
        break;
    }

    case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
    case KeyEvent.KEYCODE_MEDIA_REWIND: {
        ViewGroup vg = (ViewGroup) a.findViewById(android.R.id.content);
        ArrayList list = AndroidUtilsUI.findByClass(vg, ViewPager.class, new ArrayList<View>(0));

        if (list.size() > 0) {
            ViewPager viewPager = (ViewPager) list.get(0);
            viewPager.arrowScroll(View.FOCUS_LEFT);
        }
        break;
    }

    case KeyEvent.KEYCODE_DPAD_LEFT: {
        if (a instanceof DrawerActivity) {
            DrawerActivity da = (DrawerActivity) a;
            DrawerLayout drawerLayout = da.getDrawerLayout();
            View viewFocus = a.getCurrentFocus();
            boolean canOpenDrawer = viewFocus != null && "leftmost".equals(viewFocus.getTag());
            if (canOpenDrawer) {
                drawerLayout.openDrawer(Gravity.LEFT);
                drawerLayout.requestFocus();
                return true;
            }
        }
        break;
    }

    }

    return false;
}

From source file:com.google.android.car.kitchensink.input.InputTestFragment.java

@Nullable
@Override//w w w.  j a  v  a  2 s.  c  om
public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container,
        @Nullable Bundle savedInstanceState) {
    View view = inflater.inflate(R.layout.input_test, container, false);

    Collections.addAll(mButtons, BREAK_LINE, createButton(R.string.home, KeyEvent.KEYCODE_HOME),
            createButton(R.string.volume_up, KeyEvent.KEYCODE_VOLUME_UP),
            createButton(R.string.volume_down, KeyEvent.KEYCODE_VOLUME_DOWN),
            createButton(R.string.volume_mute, KeyEvent.KEYCODE_VOLUME_MUTE),
            createButton(R.string.voice, KeyEvent.KEYCODE_VOICE_ASSIST), BREAK_LINE,
            createButton(R.string.music, KeyEvent.KEYCODE_MUSIC),
            createButton(R.string.music_play, KeyEvent.KEYCODE_MEDIA_PLAY),
            createButton(R.string.music_stop, KeyEvent.KEYCODE_MEDIA_STOP),
            createButton(R.string.next_song, KeyEvent.KEYCODE_MEDIA_NEXT),
            createButton(R.string.prev_song, KeyEvent.KEYCODE_MEDIA_PREVIOUS),
            createButton(R.string.tune_right, KeyEvent.KEYCODE_CHANNEL_UP),
            createButton(R.string.tune_left, KeyEvent.KEYCODE_CHANNEL_DOWN), BREAK_LINE,
            createButton(R.string.call_send, KeyEvent.KEYCODE_CALL),
            createButton(R.string.call_end, KeyEvent.KEYCODE_ENDCALL));

    mCarEmulator = CarEmulator.create(getContext());
    addButtonsToPanel((LinearLayout) view.findViewById(R.id.input_buttons), mButtons);

    return view;
}

From source file:com.dragedy.playermusic.service.MediaButtonIntentReceiver.java

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;
        }/*www . j av  a  2  s . co  m*/

        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;
}

From source file:org.videolan.vlc.RemoteControlClientReceiver.java

@Override
public void onReceive(Context context, Intent intent) {
    String action = intent.getAction();

    KeyEvent event = intent.getParcelableExtra(Intent.EXTRA_KEY_EVENT);
    if (event != null && action.equalsIgnoreCase(Intent.ACTION_MEDIA_BUTTON)) {

        if (event.getKeyCode() != KeyEvent.KEYCODE_HEADSETHOOK
                && event.getKeyCode() != KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE
                && event.getAction() != KeyEvent.ACTION_DOWN) {
            super.onReceive(context, intent);
            return;
        }//from   w ww .  java 2  s. co  m

        Intent i = null;
        switch (event.getKeyCode()) {
        /*
         * one click => play/pause
         * long click => previous
         * double click => next
         */
        case KeyEvent.KEYCODE_HEADSETHOOK:
        case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
            long time = SystemClock.uptimeMillis();
            switch (event.getAction()) {
            case KeyEvent.ACTION_DOWN:
                if (event.getRepeatCount() <= 0)
                    mHeadsetDownTime = time;
                break;
            case KeyEvent.ACTION_UP:
                if (AndroidDevices.hasTsp()) { //no backward/forward on TV
                    if (time - mHeadsetDownTime >= 1000) { // long click
                        i = new Intent(PlaybackService.ACTION_REMOTE_BACKWARD, null,
                                VLCApplication.getAppContext(), PlaybackService.class);
                        break;
                    } else if (time - mHeadsetUpTime <= 500) { // double click
                        i = new Intent(PlaybackService.ACTION_REMOTE_FORWARD, null,
                                VLCApplication.getAppContext(), PlaybackService.class);
                        break;
                    }
                }
                // one click
                i = new Intent(PlaybackService.ACTION_REMOTE_PLAYPAUSE, null, VLCApplication.getAppContext(),
                        PlaybackService.class);
                mHeadsetUpTime = time;
                break;
            }
            break;
        case KeyEvent.KEYCODE_MEDIA_PLAY:
            context.startService(new Intent(PlaybackService.ACTION_REMOTE_PLAY, null,
                    VLCApplication.getAppContext(), PlaybackService.class));
            return;
        case KeyEvent.KEYCODE_MEDIA_PAUSE:
            i = new Intent(PlaybackService.ACTION_REMOTE_PAUSE, null, VLCApplication.getAppContext(),
                    PlaybackService.class);
            break;
        case KeyEvent.KEYCODE_MEDIA_STOP:
            i = new Intent(PlaybackService.ACTION_REMOTE_STOP, null, VLCApplication.getAppContext(),
                    PlaybackService.class);
            break;
        case KeyEvent.KEYCODE_MEDIA_NEXT:
            i = new Intent(PlaybackService.ACTION_REMOTE_FORWARD, null, VLCApplication.getAppContext(),
                    PlaybackService.class);
            break;
        case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
            i = new Intent(PlaybackService.ACTION_REMOTE_BACKWARD, null, VLCApplication.getAppContext(),
                    PlaybackService.class);
            break;
        }

        if (isOrderedBroadcast())
            abortBroadcast();
        if (i != null) {
            context.startService(i);
            return;
        }
    } else if (action.equals(PlaybackService.ACTION_REMOTE_PLAYPAUSE)) {
        intent = new Intent(context, PlaybackService.class);
        intent.setAction(PlaybackService.ACTION_REMOTE_PLAYPAUSE);
        context.startService(intent);
        return;
    }
    super.onReceive(context, intent);
}

From source file:com.gecq.musicwave.player.MediaButtonIntentReceiver.java

/**
 * {@inheritDoc}//from  www .ja  v a 2 s  . c o  m
 */
@Override
public void onReceive(final Context context, final Intent intent) {
    if (DEBUG)
        Log.v(TAG, "Received intent: " + intent);
    final String intentAction = intent.getAction();
    if (AudioManager.ACTION_AUDIO_BECOMING_NOISY.equals(intentAction)) {
        startService(context, PlayerService.CMDPAUSE);
    } else if (Intent.ACTION_MEDIA_BUTTON.equals(intentAction)) {
        final KeyEvent event = (KeyEvent) 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 = PlayerService.CMDSTOP;
            break;
        case KeyEvent.KEYCODE_HEADSETHOOK:
        case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
            command = PlayerService.CMDTOGGLEPAUSE;
            break;
        case KeyEvent.KEYCODE_MEDIA_NEXT:
            command = PlayerService.CMDNEXT;
            break;
        case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
            command = PlayerService.CMDPREVIOUS;
            break;
        case KeyEvent.KEYCODE_MEDIA_PAUSE:
            command = PlayerService.CMDPAUSE;
            break;
        case KeyEvent.KEYCODE_MEDIA_PLAY:
            command = PlayerService.CMDPLAY;
            break;
        }
        if (command != null) {
            if (action == KeyEvent.ACTION_DOWN) {
                if (mDown) {
                    if (PlayerService.CMDTOGGLEPAUSE.equals(command) || PlayerService.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) {
                    // 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);
                    }
                    mLaunched = false;
                    mDown = true;
                }
            } else {
                mHandler.removeMessages(MSG_LONGPRESS_TIMEOUT);
                mDown = false;
            }
            if (isOrderedBroadcast()) {
                abortBroadcast();
            }
            releaseWakeLockIfHandlerIdle();
        }
    }
}

From source file:com.rks.musicx.services.MediaButtonReceiver.java

@Override
public void onReceive(Context context, Intent intent) {
    String intentAction = intent.getAction();
    String command = null;/*from   ww  w  .j a v a 2s  .c  om*/
    if (intent.getAction() != null) {
        if (intentAction.equals(Intent.ACTION_MEDIA_BUTTON)) {
            KeyEvent event = (KeyEvent) intent.getParcelableExtra(Intent.EXTRA_KEY_EVENT);

            if (event == null) {
                return;
            }

            int keycode = event.getKeyCode();
            final int action = event.getAction();
            final long eventTime = event.getEventTime();

            switch (keycode) {
            case KeyEvent.KEYCODE_MEDIA_STOP:
                Log.d(TAG, "stop");
                command = Constants.ACTION_STOP;
                break;
            case KeyEvent.KEYCODE_HEADSETHOOK:
            case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
                Log.d(TAG, "toggle");
                command = Constants.ACTION_TOGGLE;
                break;
            case KeyEvent.KEYCODE_MEDIA_NEXT:
                Log.d(TAG, "next");
                command = Constants.ACTION_NEXT;
                break;
            case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
                Log.d(TAG, "prev");
                command = Constants.ACTION_PREVIOUS;
                break;
            case KeyEvent.KEYCODE_MEDIA_PAUSE:
                Log.d(TAG, "pause");
                command = Constants.ACTION_PAUSE;
                break;
            case KeyEvent.KEYCODE_MEDIA_PLAY:
                Log.d(TAG, "play");
                command = Constants.ACTION_PLAY;
                break;
            }
            // startServices(context, command);
            if (command != null) {
                if (action == KeyEvent.ACTION_DOWN) {
                    if (event.getRepeatCount() == 0) {
                        if (keycode == KeyEvent.KEYCODE_HEADSETHOOK) {
                            if (eventTime - mLastClickTime >= DOUBLE_CLICK) {
                                mClickCounter = 0;
                            }

                            mClickCounter++;
                            Log.e("MediaButton", "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 {
                            startServices(context, command);
                        }
                    }
                }
            }
        }
    }
}

From source file:com.andrew.apollo.MediaButtonIntentReceiver.java

/**
 * {@inheritDoc}//from   w w w  . j ava2s  .c o m
 */
@Override
public void onReceive(final Context context, final Intent intent) {
    if (DEBUG)
        Log.v(TAG, "Received intent: " + intent);
    final String intentAction = intent.getAction();
    if (AudioManager.ACTION_AUDIO_BECOMING_NOISY.equals(intentAction)) {
        startService(context, MusicPlaybackService.CMDPAUSE);
    } else if (Intent.ACTION_MEDIA_BUTTON.equals(intentAction)) {
        final KeyEvent event = (KeyEvent) 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 = MusicPlaybackService.CMDSTOP;
            break;
        case KeyEvent.KEYCODE_HEADSETHOOK:
        case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
            command = MusicPlaybackService.CMDTOGGLEPAUSE;
            break;
        case KeyEvent.KEYCODE_MEDIA_NEXT:
            command = MusicPlaybackService.CMDNEXT;
            break;
        case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
            command = MusicPlaybackService.CMDPREVIOUS;
            break;
        case KeyEvent.KEYCODE_MEDIA_PAUSE:
            command = MusicPlaybackService.CMDPAUSE;
            break;
        case KeyEvent.KEYCODE_MEDIA_PLAY:
            command = MusicPlaybackService.CMDPLAY;
            break;
        }
        if (command != null) {
            if (action == KeyEvent.ACTION_DOWN) {
                if (mDown) {
                    if (MusicPlaybackService.CMDTOGGLEPAUSE.equals(command)
                            || MusicPlaybackService.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) {
                    // 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);
                    }
                    mLaunched = false;
                    mDown = true;
                }
            } else {
                mHandler.removeMessages(MSG_LONGPRESS_TIMEOUT);
                mDown = false;
            }
            if (isOrderedBroadcast()) {
                abortBroadcast();
            }
            releaseWakeLockIfHandlerIdle();
        }
    }
}

From source file:com.commonsware.android.preso.decktastic.MainActivity.java

@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
    switch (keyCode) {
    case KeyEvent.KEYCODE_SPACE:
    case KeyEvent.KEYCODE_DPAD_RIGHT:
    case KeyEvent.KEYCODE_DPAD_DOWN:
    case KeyEvent.KEYCODE_PAGE_DOWN:
    case KeyEvent.KEYCODE_MEDIA_NEXT:
        if (pager.canScrollHorizontally(1)) {
            pager.setCurrentItem(pager.getCurrentItem() + 1, true);
        }/*from   w  ww  .  ja v a  2  s . co m*/

        return (true);

    case KeyEvent.KEYCODE_DPAD_LEFT:
    case KeyEvent.KEYCODE_DPAD_UP:
    case KeyEvent.KEYCODE_PAGE_UP:
    case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
        if (pager.canScrollHorizontally(-1)) {
            pager.setCurrentItem(pager.getCurrentItem() - 1, true);
        }

        return (true);
    }

    return (super.onKeyDown(keyCode, event));
}