Example usage for android.view KeyEvent getKeyCode

List of usage examples for android.view KeyEvent getKeyCode

Introduction

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

Prototype

public final int getKeyCode() 

Source Link

Document

Retrieve the key code of the key event.

Usage

From source file:jmri.enginedriver.throttle.java

@Override
public boolean dispatchKeyEvent(KeyEvent event) {

    boolean isExternal = false;
    if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.JELLY_BEAN) {
        InputDevice idev = getDevice(event.getDeviceId());
        if (idev != null && idev.toString() != null && idev.toString().contains("Location: external"))
            isExternal = true;// w  ww  . j a  v a2  s . c o m
    }

    if (isExternal) { // if has come from the phone itself, don't try to process it here
        if (!whichGamePadMode.equals(WHICH_GAMEPAD_MODE_NONE)) { // respond to the gamepad and keyboard inputs only if the preference is set

            boolean acceptEvent = true; // default to assuming that we will respond to the event

            int action = event.getAction();
            int keyCode = event.getKeyCode();
            int repeatCnt = event.getRepeatCount();
            int whichThrottle;
            int whichGamePadIsEventFrom = findWhichGamePadEventIsFrom(event.getDeviceId(), event.getKeyCode());

            if ((whichGamePadIsEventFrom > -1) && (whichGamePadIsEventFrom < gamePadDeviceIdsTested.length)) { // the event came from a gamepad
                if (gamePadDeviceIdsTested[getGamePadIndexFromThrottleNo(
                        whichGamePadIsEventFrom)] != GAMEPAD_GOOD) { //if not, testing for this gamepad is not complete or has failed
                    acceptEvent = false;
                }
            } else {
                acceptEvent = false;
            }

            if (acceptEvent) {
                if ((usingMultiplePads) && (whichGamePadIsEventFrom >= -1)) { // we have multiple gamepads AND the preference is set to make use of them AND the event came for a gamepad
                    if (whichGamePadIsEventFrom >= 0) {
                        whichThrottle = whichGamePadIsEventFrom;
                    } else {
                        GamepadFeedbackSound(true);
                        return (true);
                    }
                } else {
                    whichThrottle = whichVolume; // work out which throttle the volume keys are currently set to contol... and use that one
                }

                boolean isActive = getConsist(whichThrottle).isActive();

                if (keyCode != 0) {
                    Log.d("Engine_Driver", "keycode " + keyCode + " action " + action + " repeat " + repeatCnt);
                }

                if (action == ACTION_UP) {
                    mGamepadAutoIncrement = false;
                    mGamepadAutoDecrement = false;
                    GamepadFeedbackSoundStop();
                }

                if (keyCode == gamePadKeys[2]) { // DPAD Up Button
                    performButtonAction(5, action, isActive, whichThrottle, whichGamePadIsEventFrom, repeatCnt);
                    return (true); // stop processing this key

                } else if (keyCode == gamePadKeys[3]) { // DPAD Down Button
                    performButtonAction(7, action, isActive, whichThrottle, whichGamePadIsEventFrom, repeatCnt);
                    return (true); // stop processing this key

                } else if (keyCode == gamePadKeys[4]) { // DPAD Left Button
                    performButtonAction(8, action, isActive, whichThrottle, whichGamePadIsEventFrom, repeatCnt);
                    return (true); // stop processing this key

                } else if (keyCode == gamePadKeys[5]) { // DPAD Right Button
                    performButtonAction(6, action, isActive, whichThrottle, whichGamePadIsEventFrom, repeatCnt);
                    return (true); // stop processing this key

                } else if (keyCode == gamePadKeys[7]) { // ios button
                    performButtonAction(1, action, isActive, whichThrottle, whichGamePadIsEventFrom, repeatCnt);
                    return (true); // stop processing this key

                } else if (keyCode == gamePadKeys_Up[8]) { // X button
                    performButtonAction(3, action, isActive, whichThrottle, whichGamePadIsEventFrom, repeatCnt);
                    return (true); // stop processing this key

                } else if (keyCode == gamePadKeys_Up[9]) { // Triangle button
                    performButtonAction(2, action, isActive, whichThrottle, whichGamePadIsEventFrom, repeatCnt);
                    return (true); // stop processing this key

                } else if (keyCode == gamePadKeys_Up[10]) { // @ button
                    performButtonAction(4, action, isActive, whichThrottle, whichGamePadIsEventFrom, repeatCnt);
                    return (true); // stop processing this key

                } else if (keyCode == gamePadKeys[6]) { // start button
                    performButtonAction(0, action, isActive, whichThrottle, whichGamePadIsEventFrom, repeatCnt);
                    return (true); // stop processing this key

                } else if (keyCode == gamePadKeys[11]) { // Left Shoulder button
                    performButtonAction(10, action, isActive, whichThrottle, whichGamePadIsEventFrom,
                            repeatCnt);
                    return (true); // stop processing this key

                } else if (keyCode == gamePadKeys[12]) { // Left Shoulder button
                    performButtonAction(11, action, isActive, whichThrottle, whichGamePadIsEventFrom,
                            repeatCnt);
                    return (true); // stop processing this key

                } else if (keyCode == gamePadKeys[13]) { // Left Shoulder button
                    performButtonAction(12, action, isActive, whichThrottle, whichGamePadIsEventFrom,
                            repeatCnt);
                    return (true); // stop processing this key

                } else if (keyCode == gamePadKeys[14]) { // Left Shoulder button
                    performButtonAction(13, action, isActive, whichThrottle, whichGamePadIsEventFrom,
                            repeatCnt);
                    return (true); // stop processing this key

                } else if (keyCode == gamePadKeys[1]) { // Return button
                    // NextThrottle
                    /* if ((action == ACTION_DOWN) && (repeatCnt == 0)) {
                        if (usingMultiplePads && whichGamePadIsEventFrom >= 0) {
                    whichGamePadIsEventFrom = swapToNextAvilableThrottleForGamePad(whichGamePadIsEventFrom, false);
                        } else {
                    setNextActiveThrottle(true);
                        }
                    } */
                    performButtonAction(9, action, isActive, whichThrottle, whichGamePadIsEventFrom, repeatCnt);
                    return (true); // stop processing this key
                }
            } else { // event is from a gamepad that has not finished testing. Ignore it
                return (true); // stop processing this key
            }
            //  for now pass all keystrokes not in gamePadKeys[] to super
            //  if problems occur, we can uncomment the next 2 lines
            //            else if (!((keyCode == KEYCODE_BACK) || (keyCode == KEYCODE_VOLUME_DOWN) || (keyCode == KEYCODE_VOLUME_UP) || (keyCode == KEYCODE_MENU)))
            //            return (true); // swallow all other keystrokes except back, menu and the volume keys
        }
    } else if (IS_ESU_MCII) {
        // Process ESU MCII keys
        int action = event.getAction();
        int keyCode = event.getKeyCode();
        int repeatCnt = event.getRepeatCount();
        boolean isActive = getConsist(whichVolume).isActive();

        if (keyCode != 0) {
            Log.d("Engine_Driver",
                    "ESU_MCII: keycode " + keyCode + " action " + action + " repeat " + repeatCnt);
            if (action == ACTION_UP) {
                esuButtonAutoIncrement = false;
                esuButtonAutoDecrement = false;
            }

            switch (keyCode) {
            case MobileControl2.KEYCODE_TOP_LEFT:
            case MobileControl2.KEYCODE_BOTTOM_LEFT:
            case MobileControl2.KEYCODE_TOP_RIGHT:
            case MobileControl2.KEYCODE_BOTTOM_RIGHT:
                performEsuMc2ButtonAction(keyCode, action, isActive, whichVolume, repeatCnt);
                return true; // stop processing this key
            default:
                // Unrecognised key - do nothing
                Log.d("Engine_Driver", "ESU_MCII: Unrecognised keyCode: " + keyCode);

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

From source file:com.aliasapps.seq.scroller.TwoWayView.java

@Override
public boolean dispatchKeyEvent(KeyEvent event) {
    // Dispatch in the normal way
    boolean handled = super.dispatchKeyEvent(event);
    if (!handled) {
        // If we didn't handle it...
        final View focused = getFocusedChild();
        if (focused != null && event.getAction() == KeyEvent.ACTION_DOWN) {
            // ... and our focused child didn't handle it
            // ... give it to ourselves so we can scroll if necessary
            handled = onKeyDown(event.getKeyCode(), event);
        }/*from w  ww  . j  ava  2  s .c o  m*/
    }

    return handled;
}

From source file:me.spadival.podmode.PodModeService.java

public void run() {
    podCommand pCommand = null;/* ww w.  ja  va2 s. c o m*/
    podResponse pResponse = null;
    byte[] respBytes = null;

    long eventtime;
    Intent downIntent = null;
    KeyEvent downEvent = null;
    Intent upIntent = null;
    KeyEvent upEvent = null;

    // serialWrite(new byte[] { (byte) 0xFF, 0x55, 0x02, 0x00, 0x00,
    // (byte) 0xFE });

    while (mPodRunning) {
        pCommand = readCommand();
        if (pCommand == null)
            continue;

        if (pCommand.mode == 0x03)
            mPodStatus = podStat.DISPLAYREMOTE;

        if (mAccessoryName != null
                && (mPodStatus == podStat.SIMPLEREMOTE || mPodStatus == podStat.DISPLAYREMOTE
                        || mPodStatus == podStat.ADVANCEDREMOTE || mPodStatus == podStat.ADVANCEDHACK)
                && mHTTPsend) {
            mHTTPsend = false;
            mHttpThread.start();
        }

        if (mLaunchFirstTime
                && (pCommand.mode == 02 || (pCommand.mode == 04 && !mAdvancedRemoteApp.equals(PACKAGENAME)))) {

            String launchApp = null;

            if (pCommand.mode == 02) {
                mBanner = getString(R.string.simple_remote);
                launchApp = mSimpleRemoteApp;
            }

            if (pCommand.mode == 04) {
                mPodStatus = podStat.ADVANCEDREMOTE;
                if (!mAdvancedRemoteApp.equals(PACKAGENAME))
                    mPodStatus = podStat.ADVANCEDHACK;

                mBanner = getString(R.string.advanced_remote);
                launchApp = mAdvancedRemoteApp;
            }

            if (launchApp != null) {
                PackageManager pm = getPackageManager();
                Intent LaunchIntent = pm.getLaunchIntentForPackage(launchApp);

                startActivity(LaunchIntent);

                ResolveInfo info = pm.resolveActivity(LaunchIntent, PackageManager.MATCH_DEFAULT_ONLY);
                mSongTitle = (String) info.loadLabel(pm);
                mElapsedTime = 0;

                if (pCommand.mode == 04)
                    mRetriever.changeApp(false, mSongTitle, getString(R.string.advanced_remote), 999);

                mAlbumArtUri = "android.resource://" + launchApp + "/" + String.valueOf(info.getIconResource());
                setUpAsForeground(mBanner);
                localBroadcast(false);
            }

            mLaunchFirstTime = false;
        }

        if (pCommand.mode == 02) {

            mPodStatus = podStat.SIMPLEREMOTE;

            switch (pCommand.command) {

            case RemoteRelease:
                respBytes = new byte[] { (byte) 0x01, 0x00, 0x00 };
                pResponse = new podResponse(pCommand, respBytes);
                serialWrite(pResponse.getBytes());
                break;

            case RemotePlayPause:

                eventtime = SystemClock.uptimeMillis();

                downIntent = new Intent(Intent.ACTION_MEDIA_BUTTON, null);
                downEvent = new KeyEvent(eventtime, eventtime, KeyEvent.ACTION_DOWN,
                        KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE, 0);
                downIntent.putExtra(Intent.EXTRA_KEY_EVENT, downEvent);
                if (mSimpleRemoteApp != null)
                    downIntent.setPackage(mSimpleRemoteApp);

                sendOrderedBroadcast(downIntent, null);

                break;

            case RemoteJustPlay:

                eventtime = SystemClock.uptimeMillis();

                downIntent = new Intent(Intent.ACTION_MEDIA_BUTTON, null);
                downEvent = new KeyEvent(eventtime, eventtime, KeyEvent.ACTION_DOWN,
                        KeyEvent.KEYCODE_MEDIA_PLAY, 0);
                downIntent.putExtra(Intent.EXTRA_KEY_EVENT, downEvent);
                if (mSimpleRemoteApp != null)
                    downIntent.setPackage(mSimpleRemoteApp);

                sendOrderedBroadcast(downIntent, null);

                break;

            case RemoteJustPause:

                eventtime = SystemClock.uptimeMillis();

                downIntent = new Intent(Intent.ACTION_MEDIA_BUTTON, null);
                downEvent = new KeyEvent(eventtime, eventtime, KeyEvent.ACTION_DOWN,
                        KeyEvent.KEYCODE_MEDIA_PAUSE, 0);
                downIntent.putExtra(Intent.EXTRA_KEY_EVENT, downEvent);
                if (mSimpleRemoteApp != null)
                    downIntent.setPackage(mSimpleRemoteApp);

                sendOrderedBroadcast(downIntent, null);

                break;

            case RemoteSkipFwd:

                eventtime = SystemClock.uptimeMillis();

                if (downEvent != null) {
                    if (downEvent.getKeyCode() == KeyEvent.KEYCODE_MEDIA_NEXT
                            || downEvent.getKeyCode() == KeyEvent.KEYCODE_MEDIA_FAST_FORWARD) {
                        if ((eventtime - downEvent.getEventTime()) > 1000) {

                            downIntent = new Intent(Intent.ACTION_MEDIA_BUTTON, null);
                            downEvent = new KeyEvent(eventtime, eventtime, KeyEvent.ACTION_DOWN,
                                    KeyEvent.KEYCODE_MEDIA_FAST_FORWARD, 0);
                            downIntent.putExtra(Intent.EXTRA_KEY_EVENT, downEvent);
                            if (mSimpleRemoteApp != null)
                                downIntent.setPackage(mSimpleRemoteApp);

                            sendOrderedBroadcast(downIntent, null);

                            upIntent = new Intent(Intent.ACTION_MEDIA_BUTTON, null);
                            upEvent = new KeyEvent(eventtime, eventtime, KeyEvent.ACTION_UP,
                                    KeyEvent.KEYCODE_MEDIA_FAST_FORWARD, 0);
                            upIntent.putExtra(Intent.EXTRA_KEY_EVENT, upEvent);
                            if (mSimpleRemoteApp != null)
                                upIntent.setPackage(mSimpleRemoteApp);

                            sendOrderedBroadcast(upIntent, null);
                        }

                    }

                } else {

                    downIntent = new Intent(Intent.ACTION_MEDIA_BUTTON, null);
                    downEvent = new KeyEvent(eventtime, eventtime, KeyEvent.ACTION_DOWN,
                            KeyEvent.KEYCODE_MEDIA_NEXT, 0);
                    downIntent.putExtra(Intent.EXTRA_KEY_EVENT, downEvent);
                    if (mSimpleRemoteApp != null)
                        downIntent.setPackage(mSimpleRemoteApp);
                }

                break;
            case RemoteSkipRwd:

                eventtime = SystemClock.uptimeMillis();

                if (downEvent != null) {
                    if (downEvent.getKeyCode() == KeyEvent.KEYCODE_MEDIA_PREVIOUS
                            || downEvent.getKeyCode() == KeyEvent.KEYCODE_MEDIA_REWIND) {
                        if ((eventtime - downEvent.getEventTime()) > 1000) {

                            downIntent = new Intent(Intent.ACTION_MEDIA_BUTTON, null);
                            downEvent = new KeyEvent(eventtime, eventtime, KeyEvent.ACTION_DOWN,
                                    KeyEvent.KEYCODE_MEDIA_REWIND, 0);
                            downIntent.putExtra(Intent.EXTRA_KEY_EVENT, downEvent);
                            if (mSimpleRemoteApp != null)
                                downIntent.setPackage(mSimpleRemoteApp);
                            sendOrderedBroadcast(downIntent, null);

                            upIntent = new Intent(Intent.ACTION_MEDIA_BUTTON, null);
                            upEvent = new KeyEvent(eventtime, eventtime, KeyEvent.ACTION_UP,
                                    KeyEvent.KEYCODE_MEDIA_REWIND, 0);
                            upIntent.putExtra(Intent.EXTRA_KEY_EVENT, upEvent);
                            if (mSimpleRemoteApp != null)
                                upIntent.setPackage(mSimpleRemoteApp);
                            sendOrderedBroadcast(upIntent, null);
                        }

                    }

                } else {

                    downIntent = new Intent(Intent.ACTION_MEDIA_BUTTON, null);
                    downEvent = new KeyEvent(eventtime, eventtime, KeyEvent.ACTION_DOWN,
                            KeyEvent.KEYCODE_MEDIA_PREVIOUS, 0);
                    downIntent.putExtra(Intent.EXTRA_KEY_EVENT, downEvent);
                    if (mSimpleRemoteApp != null)
                        downIntent.setPackage(mSimpleRemoteApp);
                }

                break;
            case RemoteStop:
                eventtime = SystemClock.uptimeMillis();

                downIntent = new Intent(Intent.ACTION_MEDIA_BUTTON, null);
                downEvent = new KeyEvent(eventtime, eventtime, KeyEvent.ACTION_DOWN,
                        KeyEvent.KEYCODE_MEDIA_STOP, 0);
                downIntent.putExtra(Intent.EXTRA_KEY_EVENT, downEvent);
                if (mSimpleRemoteApp != null)
                    downIntent.setPackage(mSimpleRemoteApp);
                sendOrderedBroadcast(downIntent, null);

                break;

            case RemoteButtonRel:

                eventtime = SystemClock.uptimeMillis();

                if (downIntent != null) {
                    if (downEvent.getKeyCode() == KeyEvent.KEYCODE_MEDIA_NEXT
                            || downEvent.getKeyCode() == KeyEvent.KEYCODE_MEDIA_PREVIOUS)
                        sendOrderedBroadcast(downIntent, null);

                    if (downEvent.getKeyCode() != KeyEvent.KEYCODE_MEDIA_FAST_FORWARD
                            && downEvent.getKeyCode() != KeyEvent.KEYCODE_MEDIA_REWIND) {
                        upIntent = new Intent(Intent.ACTION_MEDIA_BUTTON, null);
                        upEvent = new KeyEvent(downEvent.getDownTime(), eventtime, KeyEvent.ACTION_UP,
                                downEvent.getKeyCode(), 0);
                        upIntent.putExtra(Intent.EXTRA_KEY_EVENT, upEvent);
                        if (mSimpleRemoteApp != null)
                            upIntent.setPackage(mSimpleRemoteApp);
                        sendOrderedBroadcast(upIntent, null);
                    }

                }
                downIntent = null;
                downEvent = null;
                upIntent = null;
                upEvent = null;

                break;
            default:
                break;

            }

        } else {

            switch (pCommand.command) {

            case AppCmd:
                byte[] appNameBytes = new byte[pCommand.params.length - 3];

                System.arraycopy(pCommand.params, 2, appNameBytes, 0, appNameBytes.length);

                String appName = "";

                try {
                    appName = new String(appNameBytes, "UTF8");
                    Log.d("PodMode", "AppCmd " + appName);
                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                }

                break;

            case AppAck:
                break;

            case GetUpdateFlag:
                respBytes = new byte[] { 0x00, 0x0A, mUpdateFlag };
                pResponse = new podResponse(pCommand, respBytes);
                serialWrite(pResponse.getBytes());
                break;
            case SetUpdateFlag:
                mUpdateFlag = pCommand.params[0];
                respBytes = new byte[] { 0x00, 0x01 };
                pResponse = new podResponse(pCommand, respBytes);
                serialWrite(pResponse.getBytes());
                break;
            case SwitchToMainPlaylist:
                if (mPodStatus == podStat.ADVANCEDHACK) {
                    mNowPlaying = 0;
                    mPrevPlaying = 0;
                } else
                    mNowPlaying = 0;

                mRetriever.switchToMainPlaylist();
                respBytes = new byte[] { 0x00, 0x01 };
                pResponse = new podResponse(pCommand, respBytes);
                serialWrite(pResponse.getBytes());
                break;
            case SwitchToItem:

                int itemNo = 0;

                itemNo = pCommand.params[4] & 0xFF;
                itemNo += ((pCommand.params[3] & 0xFF) << 8);
                itemNo += ((pCommand.params[2] & 0xFF) << 16);
                itemNo += ((pCommand.params[1] & 0xFF) << 24);

                if ((mPodStatus == podStat.ADVANCEDHACK && mNotifyHack)) {
                    mNotifyHack = false;
                } else {
                    if (mRetriever.switchToItem((int) pCommand.params[0], itemNo)) {
                        if (pCommand.params[0] == (byte) 0x05) {
                            mNowPlaying = itemNo;
                            tryToGetAudioFocus();
                            playNextSong(null);
                        }
                    }
                }

                respBytes = new byte[] { 0x00, 0x01 };
                pResponse = new podResponse(pCommand, respBytes);
                serialWrite(pResponse.getBytes());
                break;

            case GetCountForType:
                respBytes = new byte[] { 0x00, 0x19, 0x00, 0x00, 0x00, 0x00 };
                int num = mRetriever.getCountForType((int) pCommand.params[0]);

                respBytes[5] = (byte) (num & 0xFF);
                respBytes[4] = (byte) ((num >> 8) & 0xFF);
                respBytes[3] = (byte) ((num >> 16) & 0xFF);
                respBytes[2] = (byte) ((num >> 24) & 0xFF);

                pResponse = new podResponse(pCommand, respBytes);
                serialWrite(pResponse.getBytes());
                break;

            case GetItemNames:
                int startPos = 0;
                int count = 0;

                startPos = pCommand.params[4] & 0xFF;
                startPos += ((pCommand.params[3] & 0xFF) << 8);
                startPos += ((pCommand.params[2] & 0xFF) << 16);
                startPos += ((pCommand.params[1] & 0xFF) << 24);

                count = pCommand.params[8] & 0xFF;
                count += ((pCommand.params[7] & 0xFF) << 8);
                count += ((pCommand.params[6] & 0xFF) << 16);
                count += ((pCommand.params[5] & 0xFF) << 24);

                String[] itemNames = mRetriever.GetItemNames((int) pCommand.params[0], startPos, count);

                if (itemNames != null) {
                    for (int i = 0; i < itemNames.length; i++) {
                        byte[] part1 = { (byte) 0x00, (byte) 0x1B, (byte) (startPos >>> 24),
                                (byte) (startPos >>> 16), (byte) (startPos >>> 8), (byte) startPos };

                        startPos++;

                        respBytes = new String(new String(part1) + itemNames[i] + '\0').getBytes();
                        pResponse = new podResponse(pCommand, respBytes);
                        serialWrite(pResponse.getBytes());
                    }
                }
                break;

            case GetTimeStatus:
                respBytes = new byte[] { 0x00, 0x1D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };

                if (mState != State.Preparing && mState != State.Retrieving) {

                    int trackLen = 0;

                    if (mPlayer != null)
                        trackLen = mPlayer.getDuration();
                    respBytes[2] = (byte) (trackLen >>> 24);
                    respBytes[3] = (byte) (trackLen >>> 16);
                    respBytes[4] = (byte) (trackLen >>> 8);
                    respBytes[5] = (byte) trackLen;

                    int elapsedTime = 0;
                    if (mPlayer != null)
                        elapsedTime = mPlayer.getCurrentPosition();

                    respBytes[6] = (byte) (elapsedTime >>> 24);
                    respBytes[7] = (byte) (elapsedTime >>> 16);
                    respBytes[8] = (byte) (elapsedTime >>> 8);
                    respBytes[9] = (byte) elapsedTime;

                    switch (mState) {
                    case Stopped:
                        respBytes[10] = (byte) 0x00;
                        break;
                    case Playing:
                        respBytes[10] = (byte) 0x01;
                        break;
                    case Paused:
                        respBytes[10] = (byte) 0x02;
                        break;
                    case Preparing:
                        respBytes[10] = (byte) 0x01;
                        break;
                    case Retrieving:
                        respBytes[10] = (byte) 0x01;
                        break;
                    }
                }

                pResponse = new podResponse(pCommand, respBytes);
                serialWrite(pResponse.getBytes());
                break;

            case GetPlaylistPos:
                respBytes = new byte[] { 0x00, 0x1F, 0x00, 0x00, 0x00, 0x00 };

                respBytes[2] = (byte) ((mNowPlaying) >>> 24);
                respBytes[3] = (byte) ((mNowPlaying) >>> 16);
                respBytes[4] = (byte) ((mNowPlaying) >>> 8);
                respBytes[5] = (byte) mNowPlaying;

                pResponse = new podResponse(pCommand, respBytes);
                serialWrite(pResponse.getBytes());
                break;

            case GetSongTitle:
                byte[] part1 = new byte[] { 0x00, 0x21 };
                int index;
                index = pCommand.params[3] & 0xFF;
                index += ((pCommand.params[2] & 0xFF) << 8);
                index += ((pCommand.params[1] & 0xFF) << 16);
                index += ((pCommand.params[0] & 0xFF) << 24);

                if (index == -1)
                    index = 0;

                respBytes = new String(new String(part1) + mRetriever.getTrack(index).title + '\0').getBytes();

                pResponse = new podResponse(pCommand, respBytes);
                serialWrite(pResponse.getBytes());
                break;

            case GetSongArtist:
                part1 = new byte[] { 0x00, 0x23 };
                index = pCommand.params[3] & 0xFF;
                index += ((pCommand.params[2] & 0xFF) << 8);
                index += ((pCommand.params[1] & 0xFF) << 16);
                index += ((pCommand.params[0] & 0xFF) << 24);

                if (index == -1)
                    index = 0;

                respBytes = new String(new String(part1) + mRetriever.getTrack(index).artist + '\0').getBytes();

                pResponse = new podResponse(pCommand, respBytes);
                serialWrite(pResponse.getBytes());
                break;

            case GetSongAlbum:
                part1 = new byte[] { 0x00, 0x25 };
                index = pCommand.params[3] & 0xFF;
                index += ((pCommand.params[2] & 0xFF) << 8);
                index += ((pCommand.params[1] & 0xFF) << 16);
                index += ((pCommand.params[0] & 0xFF) << 24);

                if (index == -1)
                    index = 0;

                respBytes = new String(new String(part1) + mRetriever.getTrack(index).album + '\0').getBytes();

                pResponse = new podResponse(pCommand, respBytes);
                serialWrite(pResponse.getBytes());
                break;

            case PollingMode:
                respBytes = new byte[] { 0x00, 0x01 };
                pResponse = new podResponse(pCommand, respBytes);
                serialWrite(pResponse.getBytes());

                mPollSpeed = (byte) pCommand.params[0];
                if (pCommand.params[0] == (byte) 0x01 && mUpdateFlag != (byte) 0x01) {
                    mUpdateFlag = pCommand.params[0];

                    if (mMediaChangeTimer == null)
                        mMediaChangeTimer = new Timer();

                    mMediaChangeTimer.scheduleAtFixedRate(mMediaChangeTask, 0, 500);

                } else if (pCommand.params[0] == (byte) 0x00 && mUpdateFlag != (byte) 0x00) {

                    mUpdateFlag = pCommand.params[0];
                    if (mMediaChangeTimer != null)
                        mMediaChangeTimer.cancel();
                }

                break;

            case ExecPlaylist:
                itemNo = pCommand.params[3] & 0xFF;
                itemNo += ((pCommand.params[2] & 0xFF) << 8);
                itemNo += ((pCommand.params[1] & 0xFF) << 16);
                itemNo += ((pCommand.params[0] & 0xFF) << 24);

                if (itemNo == -1)
                    itemNo = 0;

                mRetriever.ExecPlaylist();

                if (mPodShuffleMode == modeStat.Songs)
                    mRetriever.shuffleTracks();

                mNowPlaying = itemNo;
                tryToGetAudioFocus();
                playNextSong(null);

                respBytes = new byte[] { 0x00, 0x01 };
                pResponse = new podResponse(pCommand, respBytes);
                serialWrite(pResponse.getBytes());
                break;

            case PlaybackControl:
                switch (pCommand.params[0]) {
                case 0x01:
                    // processStopRequest();
                    processTogglePlaybackRequest();
                    break;
                case 0x02:
                    processStopRequest();
                    break;
                case 0x03:
                    processPauseRequest();
                    processSkipRequest();
                    break;
                case 0x04:
                    processPauseRequest();
                    processSkipRwdRequest();
                    break;
                case 0x05:
                    // processSkipRequest();
                    break;
                case 0x06:
                    // processRewindRequest();
                    break;
                case 0x07:
                    // TODO Add Stop FF/RR function
                    break;
                }

                respBytes = new byte[] { 0x00, 0x01 };
                pResponse = new podResponse(pCommand, respBytes);
                serialWrite(pResponse.getBytes());
                break;

            case GetPlayListSongNum:
                respBytes = new byte[] { 0x00, 0x36, 0x00, 0x00, 0x00, 0x00 };
                num = mRetriever.getCount();

                respBytes[5] = (byte) (num & 0xFF);
                respBytes[4] = (byte) ((num >> 8) & 0xFF);
                respBytes[3] = (byte) ((num >> 16) & 0xFF);
                respBytes[2] = (byte) ((num >> 24) & 0xFF);

                pResponse = new podResponse(pCommand, respBytes);
                serialWrite(pResponse.getBytes());
                break;

            case JumpToSong:
                itemNo = pCommand.params[3] & 0xFF;
                itemNo += ((pCommand.params[2] & 0xFF) << 8);
                itemNo += ((pCommand.params[1] & 0xFF) << 16);
                itemNo += ((pCommand.params[0] & 0xFF) << 24);

                mNowPlaying = itemNo;
                tryToGetAudioFocus();
                playNextSong(null);

                respBytes = new byte[] { 0x00, 0x01 };
                pResponse = new podResponse(pCommand, respBytes);
                serialWrite(pResponse.getBytes());
                break;

            case FrankPlaylist:
                respBytes = new byte[] { 0x00, 0x4F, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF };
                num = mRetriever.getPlaylistNum();

                if (num != -1) {
                    respBytes[5] = (byte) (num & 0xFF);
                    respBytes[4] = (byte) ((num >> 8) & 0xFF);
                    respBytes[3] = (byte) ((num >> 16) & 0xFF);
                    respBytes[2] = (byte) ((num >> 24) & 0xFF);
                }

                pResponse = new podResponse(pCommand, respBytes);
                serialWrite(pResponse.getBytes());
                break;

            case StartID:
                respBytes = new byte[] { 0x02 };
                pResponse = new podResponse(pCommand, respBytes);
                serialWrite(pResponse.getBytes());
                break;

            case GetPodProtocols:
                // start
                respBytes = new byte[] { 0x02 };
                pResponse = new podResponse(pCommand, respBytes);
                serialWrite(pResponse.getBytes());
                if (pCommand.rawBytes[13] == (byte) 0x00 && pCommand.rawBytes[14] == (byte) 0x00
                        && pCommand.rawBytes[15] == (byte) 0x00 && pCommand.rawBytes[16] == (byte) 0x00) {
                    // respBytes = new byte[] { 0x00 };
                    // pResponse = new podResponse(pCommand, respBytes);
                    // serialWrite(pResponse.getBytes());

                } else {
                    respBytes = new byte[] { 0x14 };
                    pResponse = new podResponse(pCommand, respBytes);
                    serialWrite(pResponse.getBytes());
                }

                break;

            case DeviceAuthInfo:
                if (pCommand.length == 4) {
                    respBytes = new byte[] { 0x16 };
                    pResponse = new podResponse(pCommand, respBytes);
                    serialWrite(pResponse.getBytes());

                    respBytes = new byte[] { 0x17, 0x01 };
                    pResponse = new podResponse(pCommand, respBytes);
                    serialWrite(pResponse.getBytes());
                } else {

                    if (pCommand.rawBytes[7] != pCommand.rawBytes[8]) {
                        respBytes = new byte[] { 0x02 };
                        pResponse = new podResponse(pCommand, respBytes);
                        serialWrite(pResponse.getBytes());

                    } else {
                        respBytes = new byte[] { 0x16 };
                        pResponse = new podResponse(pCommand, respBytes);
                        serialWrite(pResponse.getBytes());

                        respBytes = new byte[] { 0x17, 0x02 };
                        pResponse = new podResponse(pCommand, respBytes);
                        serialWrite(pResponse.getBytes());
                    }
                }

                break;

            case DeviceAuthSig:
                respBytes = new byte[] { 0x19 };
                pResponse = new podResponse(pCommand, respBytes);
                serialWrite(pResponse.getBytes());
                break;

            case GetPodOptions:
                // start
                if (pCommand.rawBytes[5] == 0x00)
                    respBytes = new byte[] { 0x4C };
                else
                    respBytes = new byte[] { (byte) 0x02, 0x04 };

                pResponse = new podResponse(pCommand, respBytes);
                serialWrite(pResponse.getBytes());
                break;

            case GetPodOption:
                // start
                respBytes = new byte[] { 0x25 };
                pResponse = new podResponse(pCommand, respBytes);
                serialWrite(pResponse.getBytes());
                break;

            case SetIdTokens:
                respBytes = new byte[] { 0x3A };
                pResponse = new podResponse(pCommand, respBytes);
                if (mAccessoryName == null) {
                    mAccessoryName = pResponse.accessoryName;
                    mAccessoryMnf = pResponse.accessoryMnf;
                    mAccessoryModel = pResponse.accessoryModel;
                    mHTTPsend = true;
                }
                serialWrite(pResponse.getBytes());
                break;

            case EndID:
                respBytes = new byte[] { 0x3C };
                pResponse = new podResponse(pCommand, respBytes);
                serialWrite(pResponse.getBytes());

                respBytes = new byte[] { 0x14 };
                pResponse = new podResponse(pCommand, respBytes);
                serialWrite(pResponse.getBytes());
                break;

            case GetProtoVersion:
                respBytes = new byte[] { 0x0F };
                pResponse = new podResponse(pCommand, respBytes);
                serialWrite(pResponse.getBytes());
                break;

            case DeviceDetails:
                respBytes = new byte[] { 0x02 };
                pResponse = new podResponse(pCommand, respBytes);
                serialWrite(pResponse.getBytes());
                break;

            case DevName:
                respBytes = new byte[] { 0x00, 0x15, 0x50, 0x6F, 0x64, 0x4D, 0x6F, 0x64, 0x65, 0x00 };
                pResponse = new podResponse(pCommand, respBytes);
                serialWrite(pResponse.getBytes());
                break;

            case DevTypeSize:
                pResponse = new podResponse(pCommand, DEVTYPESIZE);
                serialWrite(pResponse.getBytes());
                break;

            case StateInfo:
                respBytes = new byte[] { 0x0D };
                pResponse = new podResponse(pCommand, respBytes);
                serialWrite(pResponse.getBytes());
                break;

            case RemoteNotify:
                respBytes = new byte[] { 0x02 };
                pResponse = new podResponse(pCommand, respBytes);

                serialWrite(pResponse.getBytes());
                break;

            case SwitchRemote:
                mPodStatus = podStat.SIMPLEREMOTE;
                break;

            case ReqAdvRemote:
                respBytes = new byte[] { 0x04, 0x00 };

                if (mPodStatus == podStat.ADVANCEDREMOTE || mPodStatus == podStat.ADVANCEDHACK)
                    respBytes[1] = 0x04;

                pResponse = new podResponse(pCommand, respBytes);

                serialWrite(pResponse.getBytes());
                break;

            case StartAdvRemote:
                mPodStatus = podStat.ADVANCEDREMOTE;
                if (!mAdvancedRemoteApp.equals(PACKAGENAME))
                    mPodStatus = podStat.ADVANCEDHACK;

                respBytes = new byte[] { 0x2 };
                pResponse = new podResponse(pCommand, respBytes);
                serialWrite(pResponse.getBytes());
                break;

            case EndAdvRemote:
                mPodStatus = podStat.WAITING;
                respBytes = new byte[] { 0x2 };
                pResponse = new podResponse(pCommand, respBytes);
                serialWrite(pResponse.getBytes());
                break;

            case GetSoftVersion:
                respBytes = new byte[] { 0x0A };
                pResponse = new podResponse(pCommand, respBytes);
                serialWrite(pResponse.getBytes());
                break;

            case GetSerialNum:
                respBytes = new byte[] { 0x0C };
                pResponse = new podResponse(pCommand, respBytes);
                serialWrite(pResponse.getBytes());
                break;

            case DevModel:
                respBytes = new byte[] { 0x0E };
                pResponse = new podResponse(pCommand, respBytes);
                serialWrite(pResponse.getBytes());
                break;

            case SwitchAdvanced:
                mPodStatus = podStat.ADVANCEDREMOTE;
                if (!mAdvancedRemoteApp.equals(PACKAGENAME))
                    mPodStatus = podStat.ADVANCEDHACK;
                break;

            case SetRepeatMode:
                if (pCommand.params[0] == (byte) 0x00)
                    mPodRepeatMode = modeStat.Off;
                else if (pCommand.params[0] == (byte) 0x01)
                    mPodRepeatMode = modeStat.Songs;
                else
                    mPodRepeatMode = modeStat.Albums;
                respBytes = new byte[] { 0x00, 0x01 };
                pResponse = new podResponse(pCommand, respBytes);
                serialWrite(pResponse.getBytes());
                break;

            case GetRepeatMode:
                respBytes = new byte[] { 0x00, 0x30, 0x00 };
                if (mPodRepeatMode == modeStat.Songs)
                    respBytes[2] = 0x01;
                if (mPodRepeatMode == modeStat.Albums)
                    respBytes[2] = 0x02;
                pResponse = new podResponse(pCommand, respBytes);
                serialWrite(pResponse.getBytes());
                break;

            case SetShuffleMode:
                if (pCommand.params[0] == (byte) 0x00)
                    mPodShuffleMode = modeStat.Off;
                else if (pCommand.params[0] == (byte) 0x01)
                    mPodShuffleMode = modeStat.Songs;
                else
                    mPodShuffleMode = modeStat.Albums;

                respBytes = new byte[] { 0x00, 0x01 };
                pResponse = new podResponse(pCommand, respBytes);
                serialWrite(pResponse.getBytes());
                break;

            case GetShuffleMode:
                respBytes = new byte[] { 0x00, 0x2D, 0x00 };
                if (mPodShuffleMode == modeStat.Songs)
                    respBytes[2] = 0x01;
                if (mPodShuffleMode == modeStat.Albums)
                    respBytes[2] = 0x02;
                pResponse = new podResponse(pCommand, respBytes);
                serialWrite(pResponse.getBytes());
                break;

            case GetScreenSize:
                respBytes = new byte[] { 0x00, 0x34 };
                pResponse = new podResponse(pCommand, respBytes);
                serialWrite(pResponse.getBytes());
                break;

            default:
                break;
            }

        }
    }
}

From source file:com.processing.core.PApplet.java

protected void handleKeyEvent(KeyEvent event) {
    //    keyEvent = event;
    key = event.getKey();// ww w  .jav a  2  s  .  c  om
    keyCode = event.getKeyCode();

    switch (event.getAction()) {
    case KeyEvent.PRESS:
        keyPressed = true;
        keyPressed(event);
        break;
    case KeyEvent.RELEASE:
        keyPressed = false;
        keyReleased(event);
        break;
    }

    handleMethods("keyEvent", new Object[] { event });
}

From source file:processing.core.PApplet.java

protected void handleKeyEvent(KeyEvent event) {
    // event.isPrintingKey() returns false for whitespace and others,
    // which is a problem if the space bar or tab key are used.
    key = (char) event.getUnicodeChar();
    // if not mappable to a unicode character, instead mark as coded key
    if (key == 0 || key == 0xFFFF) {
        // System.out.println("  key is coded");
        key = CODED;/* www. ja v  a 2  s. c  o  m*/
        // } else {
        // System.out.println("  key is unicode");
    }

    keyCode = event.getKeyCode();
    // println(key + " " + keyCode);

    int action = event.getAction();
    if (action == KeyEvent.ACTION_DOWN) {
        keyPressed = true;
        keyPressed();
    } else if (action == KeyEvent.ACTION_UP) {
        keyPressed = false;
        keyReleased();
    }

    // if someone else wants to intercept the key, they should
    // set key to zero (or something besides the "ESC").
    // println(event);
    /*
    if (action == KeyEvent.ACTION_DOWN) {        
       if (keyCode == KeyEvent.KEYCODE_BACK) {
    // println("KEYCODE_BACK, calling exit()");
    Preferences.saveRestart(getActivity(), true);
    exit();
    System.exit(0);
       }
    }
    */
    // When running tethered to the Processing application, respond to
    // Ctrl-W (or Cmd-W) events by closing the sketch. Disable this behavior
    // when running independently, because this sketch may be one component
    // embedded inside an application that has its own close behavior.
    // if (external &&
    // event.getModifiers() == MENU_SHORTCUT &&
    // event.getKeyCode() == 'W') {
    // exit();
    // }
    // }
}

From source file:com.processing.core.PApplet.java

protected void nativeKeyEvent(android.view.KeyEvent event) {
    // event.isPrintingKey() returns false for whitespace and others,
    // which is a problem if the space bar or tab key are used.
    char key = (char) event.getUnicodeChar();
    // if not mappable to a unicode character, instead mark as coded key
    if (key == 0 || key == 0xFFFF) {
        key = CODED;//  ww  w .java 2 s.  c  o m
    }

    int keyCode = event.getKeyCode();

    int keAction = 0;
    int action = event.getAction();
    if (action == android.view.KeyEvent.ACTION_DOWN) {
        keAction = KeyEvent.PRESS;
    } else if (action == android.view.KeyEvent.ACTION_UP) {
        keAction = KeyEvent.RELEASE;
    }

    // TODO set up proper key modifier handling
    int keModifiers = 0;

    KeyEvent ke = new KeyEvent(event, event.getEventTime(), keAction, keModifiers, key, keyCode);

    postEvent(ke);
}