Example usage for android.view KeyEvent KeyEvent

List of usage examples for android.view KeyEvent KeyEvent

Introduction

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

Prototype

public KeyEvent(long downTime, long eventTime, int action, int code, int repeat) 

Source Link

Document

Create a new key event.

Usage

From source file:com.android.tv.settings.accessories.AddAccessoryActivity.java

private void sendKeyEvent(int keyCode, boolean down) {
    InputManager iMgr = (InputManager) getSystemService(INPUT_SERVICE);
    if (iMgr != null) {
        long time = SystemClock.uptimeMillis();
        KeyEvent evt = new KeyEvent(time, time, down ? KeyEvent.ACTION_DOWN : KeyEvent.ACTION_UP, keyCode, 0);
        iMgr.injectInputEvent(evt, InputManager.INJECT_INPUT_EVENT_MODE_ASYNC);
    }//from   ww w . j av  a 2  s. c  o  m
}

From source file:com.googlecode.eyesfree.brailleback.BrailleIME.java

private boolean sendAndroidKeyInternal(int keyCode) {
    LogUtils.log(this, Log.VERBOSE, "sendAndroidKey: %d", keyCode);
    InputConnection ic = getCurrentInputConnection();
    if (ic == null) {
        return false;
    }/*from w  w w  .  j  a va 2 s  . c o  m*/
    long eventTime = SystemClock.uptimeMillis();
    if (!ic.sendKeyEvent(new KeyEvent(eventTime, eventTime, KeyEvent.ACTION_DOWN, keyCode, 0 /*repeat*/))) {
        return false;
    }
    return ic.sendKeyEvent(new KeyEvent(eventTime, eventTime, KeyEvent.ACTION_UP, keyCode, 0 /*repeat*/));
}

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

public void broadcastMediaButtons(int keyCode, String app) {
    long eventtime = SystemClock.uptimeMillis();

    Intent downIntent = new Intent(Intent.ACTION_MEDIA_BUTTON, null);
    KeyEvent downEvent = new KeyEvent(eventtime, eventtime, KeyEvent.ACTION_DOWN, keyCode, 0);
    downIntent.putExtra(Intent.EXTRA_KEY_EVENT, downEvent);
    if (app != null)
        downIntent.setPackage(app);/*w  w  w.  ja  va2 s.c o m*/

    sendOrderedBroadcast(downIntent, null);

    eventtime = SystemClock.uptimeMillis();

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

    sendOrderedBroadcast(upIntent, null);

}

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

public void run() {
    podCommand pCommand = null;//  www. ja  v a  2  s . co 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;
            }

        }
    }
}