xref: /hardware/ti/wpan/tools/FM/FmTxApp/src/com/ti/fmtxapp/FmTx.java

/*
 *
 * Copyright 2001-2011 Texas Instruments, Inc. - http://www.ti.com/
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.ti.fmtxapp;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.util.Log;
import android.widget.CheckBox;
import android.widget.EditText;
import android.widget.Button;
import android.widget.CompoundButton;
import android.widget.CompoundButton.OnCheckedChangeListener;
import android.app.AlertDialog;
import android.view.KeyEvent;
import android.view.View.OnKeyListener;
import android.widget.Toast;
import android.app.ProgressDialog;
import android.content.BroadcastReceiver;
import android.os.Handler;
import android.os.Message;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.SharedPreferences;
import android.content.DialogInterface;

/*************** For calling lower layer********************/
import com.ti.fm.FmRadio;
import com.ti.fm.FmRadioIntent;
import com.ti.fm.IFmConstants;
/**************************************************************/

public class FmTx extends Activity implements View.OnClickListener,
OnCheckedChangeListener,OnKeyListener,FmTxAppConstants,FmRadio.ServiceListener{
    /** Called when the activity is first created. */
    public static final String TAG = "FmTxApp";

    /********************************************
     * Menu Constants
     ********************************************/
    public static final int MENU_CONFIGURE = Menu.FIRST + 1;
//    public static final int MENU_ADVANCED = Menu.FIRST + 2;
    public static final int MENU_EXIT = Menu.FIRST + 2;
    public static final int MENU_ABOUT = Menu.FIRST + 3;


    /********************************************
     * Initail values
     ********************************************/
    private int mTxMode = INITIAL_VAL;
    private int mPiCode = INITIAL_VAL;
    private int mAfCode = INITIAL_VAL;
    private int mTuneFreq = INITIAL_VAL;
    private int mDeEmpFilter = INITIAL_VAL;
    private int mPowerLevel = INITIAL_VAL;
    private int mRepertoire = INITIAL_VAL;
    private int mMonoStereo = INITIAL_VAL;
    private int mDisplayMode = INITIAL_VAL;
    private int mEcc = INITIAL_VAL;
    private int mTxMusicSpeech = INITIAL_VAL;
    private int mTxEmpFilter = INITIAL_VAL;
    private int mTxPtyCode = INITIAL_VAL;
    private Float mFreq = (float)INITIAL_VAL;
    //private int mMute = INITIAL_VAL;
    /*Flag to check if service is connected*/
    boolean mFmServiceConnected = false;


    public SharedPreferences fmTxPreferences;
    private int mAppState = STATE_DEFAULT;

    public static Float freqValue = (float)0;
    private ProgressDialog pd = null,configPd;

        public static FmRadio sFmRadio;
    private CheckBox startTxBtn,enableRdsBtn,chbMute;
    private EditText textFreq;
    private boolean mStatus;
    private Button btnOk;
    private boolean isFmEnabled = false;

    /* Actvity result index */
    public static final int ACTIVITY_CONFIG = 1;


    private NotificationManager mNotificationManager;


    Context mContext;

    @Override
    public void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       Log.d(TAG, "onCreate enter");
       mContext = this;


    // Register for FM TX intent broadcasts.
    IntentFilter intentFilter = new IntentFilter();
    intentFilter.addAction(FmRadioIntent.FM_TX_ENABLED_ACTION);
    intentFilter.addAction(FmRadioIntent.FM_TX_TUNE_ACTION);
    intentFilter.addAction(FmRadioIntent.FM_TX_DISABLED_ACTION);
    intentFilter.addAction(FmRadioIntent.FM_TX_START_TRANSMISSION_ACTION);
    intentFilter.addAction(FmRadioIntent.FM_TX_STOP_TRANSMISSION_ACTION);
    intentFilter.addAction(FmRadioIntent.FM_TX_DESTROY_ACTION);
    intentFilter.addAction(FmRadioIntent.FM_TX_ENABLE_RSD_ACTION);
    intentFilter.addAction(FmRadioIntent.FM_TX_DISABLE_RSD_ACTION);
    intentFilter.addAction(FmRadioIntent.FM_TX_PS_DISPLAY_MODE_ACTION);
    intentFilter.addAction(FmRadioIntent.FM_TX_SET_RDS_MUSIC_SPEECH_FLAG_ACTION);
    intentFilter.addAction(FmRadioIntent.FM_TX_SET_RDS_TEXT_REPERTOIRE_ACTION);
    intentFilter.addAction(FmRadioIntent.FM_TX_SET_TRANSMISSION_MODE_ACTION);
    intentFilter.addAction(FmRadioIntent.FM_TX_SET_POWER_LEVEL_ACTION);
    intentFilter.addAction(FmRadioIntent.FM_TX_SET_RDS_TEXT_PS_MSG_ACTION);
    intentFilter.addAction(FmRadioIntent.FM_TX_SET_MONO_STEREO_MODE_ACTION);
    intentFilter.addAction(FmRadioIntent.FM_TX_SET_MUTE_MODE_ACTION);
    intentFilter.addAction(FmRadioIntent.FM_TX_SET_RDS_TRANSMISSION_GROUPMASK_ACTION);
    registerReceiver(mReceiver, intentFilter);


        sFmRadio = new FmRadio(this, this);

       setContentView(R.layout.main);
    initControls();
    loadlastSaveddata();


    }

  @Override
    public void onPause() {
       super.onPause();
       Log.d(TAG, "onPause enter");
       saveLastData();
}
/******************************************
*
*        enableTx()
*
*******************************************/
       private void enableTx()
       {

       Log.i(TAG,"enableTx()");

    switch (sFmRadio.txGetFMState()){

    case STATE_DISABLED:
    case STATE_DEFAULT:
        mStatus = sFmRadio.txEnable();
        if (mStatus == false) {
            Log.i(TAG, "Fm Tx --> Cannot enable TX !!");

        CharSequence text = "Sorry!! Cannot enable TX";
        int duration = Toast.LENGTH_SHORT;

        Toast toast = Toast.makeText(mContext, text, duration);
        toast.setGravity(android.view.Gravity.CENTER_VERTICAL, 0, 0);
        toast.show();

        finish();

        }
        else{
            Log.i(TAG, "Fm Tx --> Enabling TX !!");
            pd = ProgressDialog.show(this, "Please wait..",    "Enabling FM TX", true, false);
        }


        break;

    case STATE_ENABLED:
             loadlastSaveddata();
        Log.i(TAG, "Fm Tx is already Enabled.");
        break;

    }


       }


public void onServiceConnected() {
    Log.i(TAG, "onServiceConnected");
    mFmServiceConnected =true;
    enableTx();
}

public void onServiceDisconnected() {
    Log.d(TAG, "Lost connection to service");
    mFmServiceConnected =false;
    sFmRadio = null;
}


/******************************************
*
*        onCreateOptionsMenu()
*
*******************************************/
        public boolean onCreateOptionsMenu(Menu menu) {

            super.onCreateOptionsMenu(menu);
            MenuItem item;

            item = menu.add(0, MENU_CONFIGURE, 0, R.string.configure);
            item.setIcon(R.drawable.configure);


            /*item = menu.add(0, MENU_ADVANCED, 0, R.string.advanced);
            item.setIcon(R.drawable.configure);*/

            item = menu.add(0, MENU_ABOUT, 0, R.string.about);
            item.setIcon(R.drawable.icon);

            item = menu.add(0, MENU_EXIT, 0, R.string.exit);
            item.setIcon(R.drawable.icon);

            return true;
        }

/******************************************
*
* onOptionsItemSelected()
*Handles item selections
*
*******************************************/

        public boolean onOptionsItemSelected(MenuItem item) {

            switch (item.getItemId()) {
            case MENU_CONFIGURE:

            /* Start the configuration window */
            Intent irds = new Intent("android.intent.action.RDSPARAM_CONFIG");
            startActivityForResult(irds, ACTIVITY_CONFIG);

                break;

     /*    case MENU_ADVANCED:
            Intent iAdvanced = new Intent("android.intent.action.TXPARAM_CONFIG");
            startActivityForResult(iAdvanced, ACTIVITY_ADVANCED);


             break;*/

            case MENU_EXIT:
                saveLastData();
                /*
                 * The exit from the FM application happens here The audio will be
                 * disabled and when he callback for this is recived, FM will be
                 * disabled
                 */
                mStatus = sFmRadio.txDisable();
                if (mStatus == false) {
                Log.i(TAG, "Fm Tx--> Cannot Disable TX !!");

                }
                else{
                Log.i(TAG, "Fm Tx--> Disabling TX !!");
                }
            break;

            case MENU_ABOUT:
                /* Start the help window */
                Intent iTxHelp = new Intent("android.intent.action.START_TXABOUT");
                startActivity(iTxHelp);
                break;


            }
            return super.onOptionsItemSelected(item);
        }


    /** Adds Delay of 2 seconds */
    private void insertDelayThread() {

        new Thread() {
            public void run() {
                try {
                    // Add some delay to make sure all configuration has been
                    // completed.
                    sleep(2000);
                } catch (Exception e) {
                    Log.e(TAG, "InsertDelayThread()-- Exception !!");
                }
                // Dismiss the Dialog
                configPd.dismiss();
            }
        }.start();

    }


    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        Log.i(TAG, "onActivityResult");
        switch (requestCode) {

/*        case (ACTIVITY_ADVANCED):{
            if (resultCode == Activity.RESULT_OK) {
                    setAdvancedConfig();
                    configPd = ProgressDialog.show(this, "Please wait..",
                            "Applying Advanced Configuration", true, false);
                    // The delay is inserted to make sure all the configurations
                    // have been completed.
                    insertDelayThread();

            }
        }
        break;

*/

        case (ACTIVITY_CONFIG): {
            if (resultCode == Activity.RESULT_OK) {
                //Log.i(TAG, "ActivityFmRdsConfig configurationState "+ configurationState);

                    setRdsConfig();
                    setAdvancedConfig();
                    configPd = ProgressDialog.show(this, "Please wait..",
                            "Applying new Configuration", true, false);
                    // The delay is inserted to make sure all the configurations
                    // have been completed.
                    insertDelayThread();

            }
        }
            break;

        }
    }




/*************************************

setAdvancedConfig()

*************************************/
private void setAdvancedConfig()
{
    Log.i(TAG, "setAdvancedConfig");
    SharedPreferences fmTxParamConfigPreferences = getSharedPreferences(                "fmConfigPreferences", MODE_PRIVATE);


    //Set Music-Speech Flag
/*    int txMusicSpeech = fmTxParamConfigPreferences.getInt(MUSIC_SPEECH, DEFAULT_MUSICSPEECH);
    Log.i(TAG,"setAdvancedConfig-- >txMusicSpeech = "+txMusicSpeech);
    if (mTxMusicSpeech != txMusicSpeech) {
        mTxMusicSpeech = txMusicSpeech;
        mStatus = sFmRadio.txSetRdsMusicSpeechFlag(txMusicSpeech);
        if (mStatus == false) {
        Log.i(TAG, "Fm Tx--> txSetRdsMusicSpeechFlag TX failed !!");
        }
        else{
        Log.i(TAG, "Fm Tx--> TX txSetRdsMusicSpeechFlag is SUCCESSFUll !!");
        }
    }
*/
    //Set Pre-Emp Filter
/*    int txEmpFilter = fmTxParamConfigPreferences.getInt(EMP_FILTER, DEFAULT_EMPFILTER);
    Log.i(TAG,"setAdvancedConfig-- >txEmpFilter = "+txMusicSpeech);
    if (mTxEmpFilter != txEmpFilter) {
        mTxEmpFilter = txEmpFilter;
        mStatus = sFmRadio.txSetPreEmphasisFilter(txEmpFilter);
        if (mStatus == false) {
        Log.i(TAG, "Fm Tx--> txSetPreEmphasisFilter TX failed !!");
        }
        else{
        Log.i(TAG, "Fm Tx--> TX txSetPreEmphasisFilter is SUCCESSFUll !!");
        }
    }
*/

    // Before Setting RT String , set the Tx group Mask

    Log.i(TAG, "txSetRdsTransmittedGroupsMask(RT)");
    mStatus = sFmRadio.txSetRdsTransmittedGroupsMask(RDS_RADIO_TRANSMITTED_GRP_RT_MASK | RDS_RADIO_TRANSMITTED_GRP_PS_MASK);
    if (mStatus == false) {
    Log.i(TAG, "Fm Tx--> txSetRdsTransmittedGroupsMask TX failed !!");
    }else{
    Log.i(TAG, "Fm Tx--> TX txSetRdsTransmittedGroupsMask is SUCCESSFUll !!");
    }

       //Set Radio Text Code

       String txRTCode = fmTxParamConfigPreferences.getString(RT_STRING, DEF_RT_STRING);
    boolean rtMask= fmTxParamConfigPreferences.getBoolean(RTENABLED,false);
    int rds_mode = 2;

       Log.i(TAG,"setAdvancedConfig-- >txRT = "+txRTCode);
       if (rtMask) {
             mStatus = sFmRadio.txSetRdsTextRtMsg(rds_mode, txRTCode, txRTCode.length());
             if (mStatus == false) {
             Log.i(TAG, "Fm Tx--> txSetRdsRadioText TX failed !!");
             }
             else{
             Log.i(TAG, "Fm Tx--> TX txSetRdsRadioText is SUCCESSFUll !!");
             }
     }else {
        txRTCode = "";
        mStatus = sFmRadio.txSetRdsTextRtMsg(rds_mode, txRTCode, txRTCode.length());
             if (mStatus == false) {
             Log.i(TAG, "Fm Tx--> txSetRdsRadioText TX failed !!");
             }
             else{
             Log.i(TAG, "Fm Tx--> TX txSetRdsRadioText is Emty!!");
             }
    }

       //Set PS Name
       String txPSName = fmTxParamConfigPreferences.getString(PS_STRING, DEF_PS_STRING);
    boolean psMask= fmTxParamConfigPreferences.getBoolean(PSENABLED,false);

       Log.i(TAG,"setAdvancedConfig-- >txPSName = "+txPSName);
       if (psMask) {
             mStatus = sFmRadio.txSetRdsTextPsMsg(txPSName);
             if (mStatus == false) {
             Log.i(TAG, "Fm Tx--> txSetRdsPSName TX failed !!");
             }
             else{
             Log.i(TAG, "Fm Tx--> TX txSetRdsPSName is SUCCESSFUll !!");
             }
     }else {
        txPSName = "";
             mStatus = sFmRadio.txSetRdsTextPsMsg(txPSName);
             if (mStatus == false) {
             Log.i(TAG, "Fm Tx--> txSetRdsPSName TX failed !!");
             }
             else{
             Log.i(TAG, "Fm Tx--> TX txSetRdsPSName is Empty !!");
        }
    }

    //Set Pty Code
    int txPtyCode = fmTxParamConfigPreferences.getInt(PTY,DEFAULT_PTY);
    Log.i(TAG,"setAdvancedConfig-- >txPtyCode = "+txPtyCode);
    if (mTxPtyCode != txPtyCode) {
        mTxPtyCode = txPtyCode;
        mStatus = sFmRadio.txSetRdsPtyCode(txPtyCode);
        if (mStatus == false) {
        Log.i(TAG, "Fm Tx--> txSetRdsPtyCode TX failed !!");
        }
        else{
        Log.i(TAG, "Fm Tx--> TX txSetRdsPtyCode is SUCCESSFUll !!");
        }
    }

/*
    int ecc = fmTxParamConfigPreferences.getInt(ECC, DEFAULT_ECC);
    Log.i(TAG,"setAdvancedConfig-- >ecc ="+ecc);
    if (mEcc != ecc) {
        mEcc = ecc;
        mStatus = sFmRadio.txSetRdsECC(ecc);
        if (mStatus == false) {
        Log.i(TAG, "Fm Tx--> txSetRdsECC TX failed !!");
        }
        else{
        Log.i(TAG, "Fm Tx--> TX txSetRdsECC is SUCCESSFUll !!");
        }
    }
*/


}



/*************************************

setRdsConfig()

*************************************/
private void setRdsConfig()
{
    Log.i(TAG, "setRdsConfig");
        SharedPreferences fmConfigPreferences = getSharedPreferences(
                "fmConfigPreferences", MODE_PRIVATE);

        String psStr = fmConfigPreferences.getString(PS_STRING,DEF_PS_STRING);
        Log.i(TAG, "setRdsConfig()--- psStr= " + psStr.toString());


        String rtstr = fmConfigPreferences.getString(RT_STRING,DEF_RT_STRING);
        Log.i(TAG, "setRdsConfig()--- RtStr= " + rtstr.toString());

        // Set TxMode
        int txMode = fmConfigPreferences.getInt(TX_MODE, DEFAULT_TXMODE);
        Log.i(TAG,"setRdsConfig-- >txMode = "+txMode);

            mStatus = sFmRadio.txSetRdsTransmissionMode(txMode);
        /*if (mTxMode != txMode) {
            mTxMode = txMode;
            mStatus = sFmRadio.txSetRdsTransmissionMode(txMode);
            if (mStatus == false) {
            Log.i(TAG, "Fm Tx--> txSetRdsTransmissionMode TX failed !!");
            }
            else{
            Log.i(TAG, "Fm Tx--> TX txSetRdsTransmissionMode is SUCCESSFUll !!");
            }
        }*/

        // Set Ps DispalyMode
        /*int psDisplayMode = fmConfigPreferences.getInt(DISPLAY_MODE, DEFAULT_DISPLAYMODE);
        Log.i(TAG,"setRdsConfig-- >psDisplayMode = "+psDisplayMode);
        if (mDisplayMode != psDisplayMode) {
            mDisplayMode = txMode;
            mStatus = sFmRadio.txSetRdsPsDisplayMode(psDisplayMode);
            if (mStatus == false) {
            Log.i(TAG, "Fm Tx--> txSetRdsPsDisplayMode TX failed !!");
            }
            else{
            Log.i(TAG, "Fm Tx--> TX txSetRdsPsDisplayMode is SUCCESSFUll !!");
            }
        }*/



        // Set Mono/Stereo Flag
        int monoStereo = fmConfigPreferences.getInt(MONO_STEREO, DEFAULT_MONOSTEREO);
        Log.i(TAG,"setRdsConfig-- >monoStereo = "+monoStereo);
        if (mMonoStereo != monoStereo) {
            mMonoStereo = monoStereo;
            mStatus = sFmRadio.txSetMonoStereoMode(monoStereo);
            if (mStatus == false) {
            Log.i(TAG, "Fm Tx--> txSetMonoStereoMode TX failed !!");
            }
            else{
            Log.i(TAG, "Fm Tx--> TX txSetMonoStereoMode is SUCCESSFUll !!");
            }
        }


        // Set Repetoire
        /*int repetoire = fmConfigPreferences.getInt(REPERTOIRE, DEFAULT_REPERTOIRE);
        Log.i(TAG,"setRdsConfig-- >repetoire = "+repetoire);
        if (mMonoStereo != repetoire) {
            mMonoStereo = repetoire;
            mStatus = sFmRadio.txSetRdsTextRepertoire(repetoire);
            if (mStatus == false) {
            Log.i(TAG, "Fm Tx--> txSetRdsTextRepertoire TX failed !!");
            }
            else{
            Log.i(TAG, "Fm Tx--> TX txSetRdsTextRepertoire is SUCCESSFUll !!");
            }
        }*/


        // Before Setting Ps String , set the Tx group Mask
        boolean rtMask= fmConfigPreferences.getBoolean(RTENABLED,false);
        boolean psMask= fmConfigPreferences.getBoolean(PSENABLED,false);
        int rdsMask=(int) RDS_RADIO_TRANSMITTED_GRP_RT_MASK;
        if(rtMask)
        rdsMask = (int) (rdsMask |RDS_RADIO_TRANSMITTED_GRP_RT_MASK) ;
        if(psMask)
        rdsMask = (int) (rdsMask | RDS_RADIO_TRANSMITTED_GRP_PS_MASK);

        Log.i(TAG, "txSetRdsTransmittedGroupsMask(rdsMask )" +rdsMask );
        mStatus = sFmRadio.txSetRdsTransmittedGroupsMask(RDS_RADIO_TRANSMITTED_GRP_PS_MASK);
        if (mStatus == false) {
        Log.i(TAG, "Fm Tx--> txSetRdsTransmittedGroupsMask TX failed !!");
        }else{
        Log.i(TAG, "Fm Tx--> TX txSetRdsTransmittedGroupsMask is SUCCESSFUll !!");
        }




        // Set Power Level
        int powerLevel = fmConfigPreferences.getInt(POWER,DEFAULT_POWER);
        Log.i(TAG,"setRdsConfig-- >powerLevel ="+powerLevel);
        if (mPowerLevel != powerLevel) {
            mPowerLevel = powerLevel;
            mStatus = sFmRadio.txSetPowerLevel(powerLevel);
            if (mStatus == false) {
            Log.i(TAG, "Fm Tx--> txSetPowerLevel TX failed !!");
            }
            else{
            Log.i(TAG, "Fm Tx--> TX txSetPowerLevel is SUCCESSFUll !!");
            }
        }



        // Set Pi Code
        int piCode = fmConfigPreferences.getInt(PI_CODE,DEFAULT_PICODE);
        Log.i(TAG,"setRdsConfig-- >piCode =" +    piCode );

        if (mPiCode != piCode) {
            mPiCode = piCode;
            mStatus = sFmRadio.txSetRdsPiCode(piCode);
            if (mStatus == false) {
            Log.i(TAG, "Fm Tx--> txSetRdsPiCode TX failed !!");
            }
            else{
            Log.i(TAG, "Fm Tx--> TX txSetRdsPiCode is SUCCESSFUll !!");
            }
        }


        // Set Af Code
        int afCode = fmConfigPreferences.getInt(AF_CODE,DEFAULT_AFCODE);
        Log.i(TAG,"setRdsConfig-- >afCode = "+afCode);
        if (mAfCode != afCode) {
            mAfCode = afCode;
            mStatus = sFmRadio.txSetRdsAfCode(afCode);
            if (mStatus == false) {
            Log.i(TAG, "Fm Tx--> txSetRdsAfCode TX failed !!");
            }
            else{
            Log.i(TAG, "Fm Tx--> TX txSetRdsAfCode is SUCCESSFUll !!");
            }
        }



}
/************************************************************************************
*
* initControls()
* Initialize all the UI controls
*
*************************************************************************************/
        public void initControls()
        {
         startTxBtn  = (CheckBox)findViewById(R.id.ChbTx);
         startTxBtn.setOnCheckedChangeListener(this);

         enableRdsBtn  = (CheckBox)findViewById(R.id.chbEnableRds);
         enableRdsBtn.setOnCheckedChangeListener(this);

        chbMute = (CheckBox)findViewById(R.id.chbMute);
              chbMute.setOnCheckedChangeListener(this);

        textFreq = (EditText)findViewById(R.id.edtTxFreq);

        btnOk = (Button) findViewById(R.id.btnOk);
        btnOk.setOnKeyListener(this);
        btnOk.setOnClickListener(this);

        // Get the notification manager service.
        mNotificationManager = (NotificationManager)getSystemService(NOTIFICATION_SERVICE);


        }


/************************************************************************************
*
* onCheckedChanged()
*
*************************************************************************************/

        public void onCheckedChanged(CompoundButton btn, boolean checkedState) {
            // TODO Auto-generated method stub
            /*if (checkedState ){
            startTxBtn.setText("Uncheck to stop Tx");
            }
            else{

            //sFmRadio.txStopTransmission();
            startTxBtn.setText("Check to start Tx");

            }*/

        int id = btn.getId();
        switch (id) {
        case R.id.ChbTx:
            if (checkedState ){
            startTxBtn.setText("Uncheck to stop Tx");
            }else{
            startTxBtn.setText("Check to start Tx");
            }
            break;

        case R.id.chbEnableRds:
            if (checkedState ){
            enableRdsBtn.setText("Uncheck to Disable Rds");
            }else{
            enableRdsBtn.setText("Check to Enable Rds");
            }
            break;

        default:
            break;
        }
        }

/************************************************************************************
*
* BaseFreq()
*
*************************************************************************************/
    static float BaseFreq() {
        return APP_FM_FIRST_FREQ_US_EUROPE_KHZ;
    }


/************************************************************************************
*
*LastFreq()
*
*************************************************************************************/
    static float LastFreq() {
        return APP_FM_LAST_FREQ_US_EUROPE_KHZ;
    }


/************************************************************************************
* Update the Frequency label with the given value
*
*************************************************************************************/


    float UpdateFrequency(float freq) {
        Log.d(TAG, "FM App: UpdateFrequency %d." + freq);
        if (freq < BaseFreq() || freq > LastFreq()) {
            freq = 0;
        }
        Log.d(TAG, "FM App: returned %d." + freq);
        return (float) freq;
    }

/************************************************************************************
*       writeFrequency()
*
*************************************************************************************/
    private void writeFrequency() {
        // get the text entered in edit box
        String text = textFreq.getText().toString();
        Log.d("writeFrequency()","--> text ="+text);
        try {

            float iFreq = Float.parseFloat(text);
            Log.d("writeFrequency()","--> iFreq ="+iFreq);
            Float validFreq = UpdateFrequency(iFreq);
            if (validFreq != 0) {
                freqValue = validFreq;

            }
            else {
                new AlertDialog.Builder(this).setIcon(
                        android.R.drawable.ic_dialog_alert).setMessage(
                        "Enter valid frequency!!").setNegativeButton(
                        android.R.string.ok, null).show();
                textFreq.setText(null);
            }
        } catch (NumberFormatException nfe) {
            Log.d(TAG, "NumberFormatException:" + nfe.getMessage());
            new AlertDialog.Builder(this).setIcon(
                    android.R.drawable.ic_dialog_alert).setMessage(
                    "Enter valid number!!").setNegativeButton(
                    android.R.string.ok, null).show();
            textFreq.setText(null);
                   freqValue = (float) 0;
        }

    }

/*************************************************************************
*
* This is a method implementation of OnKeyListener
*
*************************************************************************/
    public boolean onKey(View v, int keyCode, KeyEvent event) {
            Log.i(TAG,"onKey()");
        if (event.getAction() == KeyEvent.ACTION_DOWN) {
            switch (keyCode) {
            case KeyEvent.KEYCODE_DPAD_CENTER:
            case KeyEvent.KEYCODE_ENTER:
                writeFrequency();
                if (startTxBtn.isChecked()){
                 // Tune TX
        Log.i(TAG, "Fm Tx--> TX Tune is (long)(freqValue.floatValue()*1000) !!"+(long)(freqValue.floatValue()*1000));

                     mStatus =  sFmRadio.txTune((long)(freqValue.floatValue()*1000));
                if (mStatus == false) {
                Log.i(TAG, "Fm Tx--> Tune TX failed !!");
                }
                else{
                Log.i(TAG, "Fm Tx--> TX Tune is SUCCESSFUll !!");
                }
                }
                return true;
            }
        }
        return false;
    }


/*************************************************************************
*
* This is a method implementation of onKeyDown
*
*************************************************************************/
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        Log.i(TAG,"onKeyDown()");
        switch (keyCode) {
        case KeyEvent.KEYCODE_DPAD_CENTER:
            writeFrequency();
            if (startTxBtn.isChecked()){
                 /* Tune TX */
                     mStatus =  sFmRadio.txTune((long)(freqValue.floatValue()*1000));
                if (mStatus == false) {
                Log.i(TAG, "Fm Tx--> Tune TX failed !!");
                }
                else{
                Log.i(TAG, "Fm Tx--> TX Tune is SUCCESSFUll !!");
                }

            }
            return true;

        case KeyEvent.KEYCODE_DPAD_UP:
            return true;

        case KeyEvent.KEYCODE_BACK:
        Log.i("onKeyDown()","KEYCODE_BACK");
            finish();
            return true;

        case KeyEvent.KEYCODE_HOME:
        Log.i("onKeyDown()","KEYCODE_HOME");
            //this.showNotification(R.drawable.radio, R.string.app_name,textFreq.getText(), false);
            //moved the notification to TX
            //finish();
            return true;



            /* Keys A to L are mapped to different get APIs for Testing */
        case KeyEvent.KEYCODE_A:
               Log.i("onKeyDown()","KEYCODE_A");
            Log.i(TAG, "Testing txSetRdsTextPsMsg(psStr)    returned  = "
                    + sFmRadio.txSetRdsTextPsMsg("psStr"));
            return true;

        case KeyEvent.KEYCODE_B:
        Log.i("onKeyDown()","KEYCODE_B");
            Log.i(TAG, "Testing txWriteRdsRawData(RawData)    returned= "
                    + sFmRadio.txWriteRdsRawData("RdsRawData"));
            return true;

        case KeyEvent.KEYCODE_C:
        Log.i("onKeyDown()","KEYCODE_C");
            sFmRadio.txSetRdsTransmissionMode(1);

            return true;

        case KeyEvent.KEYCODE_D:
        Log.i("onKeyDown()","KEYCODE_D");
            Log.i(TAG, "Testing txSetMonoStereoMode(0)    returned= "
                    + sFmRadio.txSetMonoStereoMode(0));
            return true;

        case KeyEvent.KEYCODE_E:
        Log.i("onKeyDown()","KEYCODE_E");
            Log.i(TAG, "Testing txSetPreEmphasisFilter(1)    returned = "
                    + sFmRadio.txSetPreEmphasisFilter(1));
        return true;

        case KeyEvent.KEYCODE_F:
        Log.i("onKeyDown()","KEYCODE_F");
              Log.i(TAG, "Testing txSetMuteMode(0) returned = "
                    + sFmRadio.txSetMuteMode(0));
        return true;

        case KeyEvent.KEYCODE_G:
        Log.i("onKeyDown()","KEYCODE_G");
            Log.i(TAG, "Testing txSetRdsAfCode(224)  returned = "
                    + sFmRadio.txSetRdsAfCode(224));
            return true;

        case KeyEvent.KEYCODE_H:
        Log.i("onKeyDown()","KEYCODE_H");
            Log.i(TAG,"Testing txSetRdsPiCode(5)    returned = "
                            + sFmRadio.txSetRdsPiCode(5));
            return true;

        case KeyEvent.KEYCODE_I:
        Log.i("onKeyDown()","KEYCODE_I");
            Log.i(TAG, "Testing txSetRdsPtyCode(0) returned  = "
                    + sFmRadio.txSetRdsPtyCode(0));
            return true;

        case KeyEvent.KEYCODE_J:
        Log.i("onKeyDown()","KEYCODE_J");
            Log.i(TAG, "Testing txSetRdsTextRepertoire(0) returned = "
                    + sFmRadio.txSetRdsTextRepertoire(0));
            return true;

        case KeyEvent.KEYCODE_K:
        Log.i("onKeyDown()","KEYCODE_K");
            Log.i(TAG,"Testing txSetRdsPsDisplayMode(0) returned = "
                            + sFmRadio.txSetRdsPsDisplayMode(0));
            return true;

        case KeyEvent.KEYCODE_L:
        Log.i("onKeyDown()","KEYCODE_L");
            Log.i(TAG, "Testing txChangeDigitalSourceConfiguration(1)    returned  = "
                    + sFmRadio.txChangeDigitalSourceConfiguration(1));

            return true;

        case KeyEvent.KEYCODE_M:
        Log.i("onKeyDown()","KEYCODE_M");
            Log.i(TAG, "Testing txSetRdsPsScrollSpeed(3)    returned  = "
                    + sFmRadio.txSetRdsPsScrollSpeed(3));
            return true;

        case KeyEvent.KEYCODE_N:
        Log.i("onKeyDown()","KEYCODE_N");
            Log.i(TAG, "Testing txSetRdsTextRtMsg(2,RtMsg,5)    returned  = "
                    + sFmRadio.txSetRdsTextRtMsg(2,"RtMsg",5));
            return true;

        case KeyEvent.KEYCODE_O:
        Log.i("onKeyDown()","KEYCODE_O");
                    Log.i(TAG,
                    "Testing txSetRdsTransmittedGroupsMask(1) returned = "
                            + sFmRadio.txSetRdsTransmittedGroupsMask(7));
            return true;

        case KeyEvent.KEYCODE_P:
        Log.i("onKeyDown()","KEYCODE_P");
            Log.i(TAG,
                    "Testing txSetRdsTrafficCodes(0,0)    returned = "
                            + sFmRadio.txSetRdsTrafficCodes(0,0));

            return true;

        case KeyEvent.KEYCODE_Q:
        Log.i("onKeyDown()","KEYCODE_Q");
            Log.i(TAG,
                    "Testing txSetRdsMusicSpeechFlag(1)    returned = "
                            + sFmRadio.txSetRdsMusicSpeechFlag(1));

            return true;

        case KeyEvent.KEYCODE_R:
        Log.i("onKeyDown()","KEYCODE_R");
            Log.i(TAG, "Testing txSetRdsECC(0)    returned  = "
                    + sFmRadio.txSetRdsECC(0));

            return true;

        case KeyEvent.KEYCODE_S:
        Log.i("onKeyDown()","KEYCODE_S");
            Log.i(TAG,
                    "Testing txChangeAudioSource(0,0)    returned = "
                            + sFmRadio.txChangeAudioSource(0,0));
            return true;

        case KeyEvent.KEYCODE_T:
        Log.i("onKeyDown()","KEYCODE_T");
            Log.i(TAG,
                    "Testing txEnableRds()    returned = "
                            + sFmRadio.txEnableRds());
            return true;

        case KeyEvent.KEYCODE_U:
        Log.i("onKeyDown()","KEYCODE_U");
            Log.i(TAG,
                    "Testing txDisableRds()    returned = "
                            + sFmRadio.txDisableRds());
            return true;

        case KeyEvent.KEYCODE_V:
        Log.i("onKeyDown()","KEYCODE_V");
            Log.i(TAG,
                    "Testing txStartTransmission()    returned = "
                            + sFmRadio.txStartTransmission());
            return true;

        case KeyEvent.KEYCODE_W:
        Log.i("onKeyDown()","KEYCODE_W");
            Log.i(TAG,
                    "Testing txStopTransmission()    returned = "
                            + sFmRadio.txStopTransmission());
            return true;

        case KeyEvent.KEYCODE_X:
        Log.i("onKeyDown()","KEYCODE_X");
            Log.i(TAG,
                    "Testing txSetPowerLevel()    returned = "
                            + sFmRadio.txSetPowerLevel(0));
            return true;

        case KeyEvent.KEYCODE_Y:
        Log.i("onKeyDown()","KEYCODE_Y");
            Log.i(TAG,
                    "Testing txTune()    returned = "
                            + sFmRadio.txTune(104000));
            return true;

         }
        return false;
    }



private void setMuteMode()
{

    Log.i(TAG,"setMuteMode()");
    // Mute
    if(chbMute.isChecked()== true){
    mStatus = sFmRadio.txSetMuteMode(0);
    }else{
    mStatus = sFmRadio.txSetMuteMode(1);
    }

    if (mStatus == false) {
    Log.i(TAG, "Fm Tx--> Cannot Mute TX !!");
    }else{
    Log.i(TAG, "Fm Tx--> Muting TX !!");
    }

}


/*************************************************************************
*
* This is a method implementation of onClick
*
*************************************************************************/
    public void onClick(View view) {
        Log.i(TAG, "onClick()");
        int id = view.getId();
        switch (id) {
        case R.id.btnOk:
            setMuteMode();
            writeFrequency();
            fmTxPreferences = getSharedPreferences("fmTxPreferences", MODE_PRIVATE);

            if (startTxBtn.isChecked() && freqValue != 0 ){
                          Log.i(TAG, " FM-------> mFreq:" + mFreq);
                          Log.i(TAG, " FM-------> freqValue" + freqValue);
                if(((mFreq-freqValue) < -.00001) ||((mFreq-freqValue) > .00001)) {
                     /* Tune TX */
                     mFreq = freqValue;
                                Log.i(TAG, " FM-------> mFreq:" + mFreq);
                    mStatus =  sFmRadio.txTune((long)(freqValue.floatValue()*1000));
                    Log.i(TAG, "Fm Tx--> Tune TX freqValue !!" +(long)(freqValue.floatValue()*1000));
                    if (mStatus == false) {
                    Log.i(TAG, "Fm Tx--> Tune TX failed !!");
                    }
                    else{
                    Log.i(TAG, "Fm Tx--> TX Tune is SUCCESSFUll !!");
                    }
                } else {
                     /* Already Tuned */
                  mStatus = sFmRadio.txStartTransmission();
                  if (mStatus == false) {
                    Log.i(TAG, "Fm Tx--> Stop Tx failed !!");
                  }else {
                    Log.i(TAG, "Fm Tx--> Stop Transmission is SUCCESSFUll !!");
                  }
            }
            }else{
                mStatus = sFmRadio.txStopTransmission();
                if (mStatus == false) {
                Log.i(TAG, "Fm Tx--> Stop Tx failed !!");
                }
                else{
                Log.i(TAG, "Fm Tx--> Stop Transmission is SUCCESSFUll !!");
                }

            }

            if(enableRdsBtn.isChecked()){
            sFmRadio.txEnableRds();
            }else{
            sFmRadio.txDisableRds();
            }



            break;

        default:
            break;
        }
    }



/*************************************************************************
*
*
*
*************************************************************************/
    private Handler mHandler = new Handler() {

        public void handleMessage(Message msg) {

            switch (msg.what) {


            case EVENT_FM_TX_ENABLED:
                Log.i(TAG, "enter handleMessage ----EVENT_FM_TX_ENABLED");
                isFmEnabled = true;
                mAppState = STATE_ENABLED;
                if (pd != null){
                pd.dismiss();
                }
                pd =null;
                break;

            case EVENT_FM_TX_DISABLED:
                Log.i(TAG, "enter handleMessage ----EVENT_FM_TX_DISABLED");
                isFmEnabled = false;
                 mAppState = STATE_DISABLED;
                          startTxBtn.setChecked(false);
                finish(); //Close the Activity
                break;


            case EVENT_FM_TX_STARTTRANSMISSION:
                Log.i(TAG, "enter handleMessage ----EVENT_FM_TX_STARTTRANSMISSION");
                break;

            case EVENT_FM_TX_STOPTRANSMISSION:
                Log.i(TAG, "enter handleMessage ----EVENT_FM_TX_STOPTRANSMISSION");
                break;

            case EVENT_FM_TX_TUNE:
                mStatus = sFmRadio.txStartTransmission();
                if (mStatus == false) {
                Log.i(TAG, "Fm Tx--> TX txStartTransmission failed !!");
                }
                else{
                Log.i(TAG, "Fm Tx--> TX is Transmitting..");
                }
                Log.i(TAG, "enter handleMessage ----EVENT_FM_TX_TUNE");
                break;


            case EVENT_FM_TX_ENABLE_RDS:
                Log.i(TAG, "enter handleMessage ----EVENT_FM_TX_ENABLE_RDS");
                break;


            case EVENT_FM_TX_DISABLE_RDS:
                Log.i(TAG, "enter handleMessage ----EVENT_FM_TX_DISABLE_RDS");
                break;

            case EVENT_FM_TX_SET_TRANSMISSION_MODE:
                Log.i(TAG, "enter handleMessage ----EVENT_FM_TX_SET_TRANSMISSION_MODE");
                break;

            case EVENT_FM_TX_SET_PS_DISPLAY_MODE:
                Log.i(TAG, "enter handleMessage ----EVENT_FM_TX_SET_PS_DISPLAY_MODE");
                break;

            case EVENT_FM_TX_SET_RDS_MUSIC_SPEECH_FLAG:
                Log.i(TAG, "enter handleMessage ----EVENT_FM_TX_SET_RDS_MUSIC_SPEECH_FLAG");
                break;

            case EVENT_FM_TX_SET_MONO_STEREO_MODE:
                Log.i(TAG, "enter handleMessage ----EVENT_FM_TX_SET_MONO_STEREO_MODE");
                break;

            case EVENT_FM_TX_SET_POWER_LEVEL:
                Log.i(TAG, "enter handleMessage ----EVENT_FM_TX_SET_POWER_LEVEL");
                break;

            case EVENT_FM_TX_SET_MUTE_MODE:
                Log.i(TAG, "enter handleMessage ----EVENT_FM_TX_SET_MUTE_MODE");
                break;

            case EVENT_FM_TX_SET_RDS_TEXT_PS_MSG:
                Log.i(TAG, "enter handleMessage ----EVENT_FM_TX_SET_RDS_TEXT_PS_MSG");
                break;

            case EVENT_FM_TX_SET_RDS_TX_GRP_MASK_PS:
                Log.i(TAG, "enter handleMessage ----EVENT_FM_TX_SET_RDS_TX_GRP_MASK_PS");

                SharedPreferences fmConfigPreferences = getSharedPreferences(
                "fmConfigPreferences", MODE_PRIVATE);

                String psStr = fmConfigPreferences.getString(PS_STRING,DEF_PS_STRING);
                Log.i(TAG, "txSetRdsTextPsMsg()--- psStr= " + psStr.toString());
                mStatus = sFmRadio.txSetRdsTextPsMsg(psStr);
                if (mStatus == false) {
                Log.i(TAG, "Fm Tx--> txSetRdsTextPsMsg TX failed !!");
                }else{
                Log.i(TAG, "Fm Tx--> TX txSetRdsTextPsMsg is SUCCESSFUll !!");
                }
                break;

            case EVENT_FM_TX_SET_RDS_TX_GRP_MASK_RT:
                Log.i(TAG, "enter handleMessage ----EVENT_FM_TX_SET_RDS_TX_GRP_MASK_RT");

                SharedPreferences fmTxParamConfigPreferences = getSharedPreferences(
                "fmTxParamConfigPreferences", MODE_PRIVATE);

                String rtStr = fmTxParamConfigPreferences.getString(RT_STRING,DEF_RT_STRING);
                Log.i(TAG, "txSetRdsTextRtMsg()--- rtStr= " + rtStr.toString());
                mStatus = sFmRadio.txSetRdsTextRtMsg(RDS_TEXT_TYPE_RT_B,rtStr,rtStr.length()); //msgType =4
                if (mStatus == false) {
                Log.i(TAG, "Fm Tx--> txSetRdsTextRtMsg TX failed !!");
                }else{
                Log.i(TAG, "Fm Tx--> TX txSetRdsTextRtMsg is SUCCESSFUll !!");
                }
                break;


 }}};


/*************************************************************************
*
*
*
*************************************************************************/
     private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
        public void onReceive(Context context, Intent intent) {
            String fmAction = intent.getAction();
            Log.i(TAG, "enter onReceive" + fmAction);
            if (fmAction.equals(FmRadioIntent.FM_TX_ENABLED_ACTION)) {
                Log.i(TAG, "enter onReceive FM_TX_ENABLED_ACTION " + fmAction);
                mHandler.sendMessage(mHandler
                        .obtainMessage(EVENT_FM_TX_ENABLED, 0));
            }

            if (fmAction.equals(FmRadioIntent.FM_TX_DISABLED_ACTION)) {
                Log.i(TAG, "enter onReceive FM_TX_DISABLED_ACTION " + fmAction);
                mHandler.sendMessage(mHandler.obtainMessage(EVENT_FM_TX_DISABLED,
                        0));
            }

            if (fmAction.equals(FmRadioIntent.FM_TX_TUNE_ACTION)) {
                Log.i(TAG, "enter onReceive FM_TX_TUNE_ACTION " + fmAction);
                mHandler.sendMessage(mHandler.obtainMessage(EVENT_FM_TX_TUNE,
                        0));
            }

            if (fmAction.equals(FmRadioIntent.FM_TX_START_TRANSMISSION_ACTION)) {
                Log.i(TAG, "enter onReceive FM_TX_START_TRANSMISSION_ACTION " + fmAction);
                mHandler.sendMessage(mHandler.obtainMessage(EVENT_FM_TX_STARTTRANSMISSION,
                        0));
            }

            if (fmAction.equals(FmRadioIntent.FM_TX_STOP_TRANSMISSION_ACTION)) {
                Log.i(TAG, "enter onReceive FM_TX_STOP_TRANSMISSION_ACTION " + fmAction);
                mHandler.sendMessage(mHandler.obtainMessage(EVENT_FM_TX_STOPTRANSMISSION,
                        0));
            }

            if (fmAction.equals(FmRadioIntent.FM_TX_DESTROY_ACTION)) {
                Log.i(TAG, "enter onReceive FM_TX_DESTROY_ACTION " + fmAction);
                mHandler.sendMessage(mHandler.obtainMessage(EVENT_FM_TX_DESTROY,
                        0));
            }

            if (fmAction.equals(FmRadioIntent.FM_TX_ENABLE_RSD_ACTION)) {
                Log.i(TAG, "enter onReceive FM_TX_ENABLE_RSD_ACTION " + fmAction);
                mHandler.sendMessage(mHandler.obtainMessage(EVENT_FM_TX_ENABLE_RDS,
                        0));
            }

            if (fmAction.equals(FmRadioIntent.FM_TX_DISABLE_RSD_ACTION)) {
                Log.i(TAG, "enter onReceive FM_TX_DISABLE_RSD_ACTION " + fmAction);
                mHandler.sendMessage(mHandler.obtainMessage(EVENT_FM_TX_DISABLE_RDS,
                        0));
            }


            if (fmAction.equals(FmRadioIntent.FM_TX_SET_TRANSMISSION_MODE_ACTION)) {
                Log.i(TAG, "enter onReceive FM_TX_SET_TRANSMISSION_MODE_ACTION " + fmAction);
                mHandler.sendMessage(mHandler.obtainMessage(EVENT_FM_TX_SET_TRANSMISSION_MODE,
                        0));
            }

            if (fmAction.equals(FmRadioIntent.FM_TX_PS_DISPLAY_MODE_ACTION)) {
                Log.i(TAG, "enter onReceive FM_TX_PS_DISPLAY_MODE_ACTION " + fmAction);
                mHandler.sendMessage(mHandler.obtainMessage(EVENT_FM_TX_SET_PS_DISPLAY_MODE,
                        0));
            }

            if (fmAction.equals(FmRadioIntent.FM_TX_SET_RDS_MUSIC_SPEECH_FLAG_ACTION)) {
                Log.i(TAG, "enter onReceive FM_TX_SET_RDS_MUSIC_SPEECH_FLAG_ACTION " + fmAction);
                mHandler.sendMessage(mHandler.obtainMessage(EVENT_FM_TX_SET_RDS_MUSIC_SPEECH_FLAG,
                        0));
            }

            if (fmAction.equals(FmRadioIntent.FM_TX_SET_RDS_TEXT_REPERTOIRE_ACTION)) {
                Log.i(TAG, "enter onReceive FM_TX_SET_RDS_TEXT_REPERTOIRE_ACTION " + fmAction);
                mHandler.sendMessage(mHandler.obtainMessage(EVENT_FM_TX_SET_RDS_TEXT_REPERTOIRE,
                        0));
            }

            if (fmAction.equals(FmRadioIntent.FM_TX_SET_TRANSMISSION_MODE_ACTION)) {
                Log.i(TAG, "enter onReceive FM_TX_SET_TRANSMISSION_MODE_ACTION " + fmAction);
                mHandler.sendMessage(mHandler.obtainMessage(EVENT_FM_TX_SET_TRANSMISSION_MODE,
                        0));
            }

            if (fmAction.equals(FmRadioIntent.FM_TX_SET_POWER_LEVEL_ACTION)) {
                Log.i(TAG, "enter onReceive FM_TX_SET_POWER_LEVEL_ACTION " + fmAction);
                mHandler.sendMessage(mHandler.obtainMessage(EVENT_FM_TX_SET_POWER_LEVEL,
                        0));
            }

            if (fmAction.equals(FmRadioIntent.FM_TX_SET_RDS_TEXT_PS_MSG_ACTION)) {
                Log.i(TAG, "enter onReceive FM_TX_SET_RDS_TEXT_PS_MSG_ACTION " + fmAction);
                mHandler.sendMessage(mHandler.obtainMessage(EVENT_FM_TX_SET_RDS_TEXT_PS_MSG,
                        0));
            }

            if (fmAction.equals(FmRadioIntent.FM_TX_SET_MONO_STEREO_MODE_ACTION)) {
                Log.i(TAG, "enter onReceive FM_TX_SET_MONO_STEREO_MODE_ACTION " + fmAction);
                mHandler.sendMessage(mHandler.obtainMessage(EVENT_FM_TX_SET_MONO_STEREO_MODE,
                        0));
            }


            if (fmAction.equals(FmRadioIntent.FM_TX_SET_MUTE_MODE_ACTION)) {
                Log.i(TAG, "enter onReceive FM_TX_SET_MUTE_MODE_ACTION " + fmAction);
                mHandler.sendMessage(mHandler.obtainMessage(EVENT_FM_TX_SET_MUTE_MODE,
                        0));
            }

            if (fmAction.equals(FmRadioIntent.FM_TX_SET_RDS_TRANSMISSION_GROUPMASK_ACTION)) {
                Log.i(TAG, "enter onReceive FM_TX_SET_RDS_TRANSMISSION_GROUPMASK_ACTION " + fmAction);

                Long grpMask = intent.getLongExtra(
                        FmRadioIntent.RDS_GRP_MASK, 0);
            /*
                if(grpMask == RDS_RADIO_TRANSMITTED_GRP_PS_MASK){
                mHandler.sendMessage(mHandler.obtainMessage(EVENT_FM_TX_SET_RDS_TX_GRP_MASK_PS,
                        0));
                }else if(grpMask == RDS_RADIO_TRANSMITTED_GRP_RT_MASK){
                mHandler.sendMessage(mHandler.obtainMessage(EVENT_FM_TX_SET_RDS_TX_GRP_MASK_RT,
                        0));
                }
            */

            }



        }
    };




    /* Save the values to the preference when the application exits */
    private void saveLastData() {
        Log.i(TAG, "saveLastData()---Entered");
        fmTxPreferences = getSharedPreferences("fmTxPreferences", MODE_PRIVATE);
        SharedPreferences.Editor editor = fmTxPreferences.edit();

        editor.putBoolean(FMENABLED, startTxBtn.isChecked());
        editor.putBoolean(RDSENABLED, enableRdsBtn.isChecked());
        editor.putBoolean(MUTE, chbMute.isChecked());

        editor.putString(FREQUENCY_STRING, textFreq.getText().toString());
        editor.putString(FREQUENCY, DEFAULT_FREQ);

        Log.d(TAG, " save FMENABLED " +isFmEnabled + "FREQUENCY_STRING"+freqValue);
        editor.commit();
        Log.i(TAG, "saveLastData()---Exit");
    }

    /* Load the last saved values from the preference when the application starts */
    private void loadlastSaveddata() {

        Log.i(TAG, "loadlastSaveddata()-entered");
        fmTxPreferences = getSharedPreferences("fmTxPreferences", MODE_PRIVATE);

        isFmEnabled = fmTxPreferences.getBoolean(FMENABLED,false);
        if(isFmEnabled == true)
        {
            startTxBtn.setChecked(true);
            startTxBtn.setEnabled(true);

        }else{
            startTxBtn.setChecked(false);
            startTxBtn.setEnabled(true);
        }

        enableRdsBtn.setChecked(fmTxPreferences.getBoolean(RDSENABLED,false));
        enableRdsBtn.setEnabled(true);

        chbMute.setChecked(fmTxPreferences.getBoolean(MUTE,false));
        chbMute.setEnabled(true);

        textFreq.setText(fmTxPreferences.getString(FREQUENCY_STRING,null));

        Log.d(TAG, " Load FMENABLED " +isFmEnabled + "FREQUENCY_STRING"+freqValue);

        Log.i(TAG, "loadlastSaveddata()-exit");
    }




     public void onStart() {
        Log.i(TAG, "onStart");
        super.onStart();
    }


    public void onResume() {
        Log.i(TAG, "onResume");
        super.onResume();
        if(mFmServiceConnected == true)
        enableTx();


    }

     public void onDestroy() {
        Log.i(TAG, "onDestroy");
        super.onDestroy();
        /*
         * Unregistering the receiver , so that we dont handle any FM events
         * when out of the FM application screen
         */

        unregisterReceiver(mReceiver);
    }

    public int getFmTxAppState() {
        Log.d(TAG, "getFmTxAppState()");
        return mAppState;

    }


}