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