devbox
笔触狂放9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

收音机(FM2)增加自己主动唤醒功能

作者：笔触狂放9 | 2024-04-07 06:47:42

赞

踩

com.caf.fmradio
高通原有代码里面就有收音机的睡眠功能。就是你能够进入收音机中设置睡眠时间类似“天天动听”等应用，到时间了就自己主动的退出该应用。
客户看到有这个功能就想要有一个自己主动唤醒的功能咯。客户总是希望相同的价格你能给我做到很多其它的功能更划算咯。
1、改动文件：
/FMRadio/src/com/caf/fmradio/FMRadio.java
/FMRadio/src/com/caf/fmradio/FMMediaButtonIntentReceiver.java
/FMRadio/AndroidManifest.xml
/FMRadio/res/values/arrays.xml
/FMRadio/res/values/strings.xml

2、FMRadio.java文件的改动相对来说多些。


用//20150326 added by  lisineng for wakeup FM做了标注

  1. </pre><pre name="code" class="java">
  2. package com.caf.fmradio;
  3.  
  4. import android.app.Activity;
  5. import android.app.AlertDialog;
  6. import android.app.Dialog;
  7. //20150326 added by  lisineng for wakeup FM
  8. import android.app.AlarmManager;
  9. import android.app.PendingIntent;
  10. //added end
  11. import android.app.ProgressDialog;
  12. import android.bluetooth.BluetoothA2dp;
  13. import android.bluetooth.BluetoothDevice;
  14. import android.content.ComponentName;
  15. import android.content.Context;
  16. import android.content.DialogInterface;
  17. import android.content.DialogInterface.OnKeyListener;
  18. import android.content.Intent;
  19. import android.content.IntentFilter;
  20. import android.content.BroadcastReceiver;
  21. import android.media.AudioSystem;
  22. import android.media.AudioManager;
  23. import android.media.MediaRecorder;
  24. import android.os.Bundle;
  25. import android.os.Environment;
  26. import android.os.Handler;
  27. import android.os.IBinder;
  28. import android.os.Message;
  29. import android.os.RemoteException;
  30. import android.os.SystemClock;
  31. import android.os.SystemProperties;
  32. import android.util.DisplayMetrics;
  33. import android.util.Log;
  34. import android.view.LayoutInflater;
  35. import android.view.Menu;
  36. import android.view.MenuItem;
  37. import android.view.View;
  38. import android.view.Window;
  39. import android.view.KeyEvent;
  40. import android.view.animation.Animation;
  41. import android.view.animation.AnimationUtils;
  42. import android.widget.ArrayAdapter;
  43. import android.widget.Button;
  44. import android.widget.EditText;
  45. import android.widget.ImageButton;
  46. import android.widget.ImageView;
  47. import android.widget.ListView;
  48. import android.widget.TextView;
  49. import android.widget.Toast;
  50. import android.text.TextUtils;
  51.  
  52. import java.util.*;
  53. import java.io.File;
  54. import java.io.IOException;
  55. import java.lang.ref.WeakReference;
  56. import java.util.Formatter;
  57. import java.util.HashMap;
  58. import java.util.List;
  59. import java.util.ListIterator;
  60. import java.util.Locale;
  61. import java.util.ArrayList;
  62.  
  63. import com.caf.utils.FrequencyPicker;
  64. import com.caf.utils.FrequencyPickerDialog;
  65. import android.content.ServiceConnection;
  66. import android.media.MediaRecorder;
  67.  
  68. import qcom.fmradio.FmConfig;
  69. import android.os.ServiceManager;
  70.  
  71. import com.caf.fmradio.HorizontalNumberPicker.OnScrollFinishListener;
  72. import com.caf.fmradio.HorizontalNumberPicker.OnValueChangeListener;
  73. import com.caf.fmradio.HorizontalNumberPicker.Scale;
  74.  
  75. import android.content.SharedPreferences;
  76. import android.graphics.Color;
  77.  
  78. public class FMRadio extends Activity
  79. {
  80.    public static final String LOGTAG = "FMRadio";
  81.  
  82.    public static final boolean RECORDING_ENABLE = true;
  83.    MediaRecorder mRecorder = null;
  84.  
  85.    /* menu Identifiers */
  86.    private static final int MENU_SCAN_START = Menu.FIRST + 2;
  87.    private static final int MENU_SCAN_STOP = Menu.FIRST + 3;
  88.    private static final int MENU_RECORD_START = Menu.FIRST + 4;
  89.    private static final int MENU_RECORD_STOP = Menu.FIRST + 5;
  90.    private static final int MENU_SLEEP = Menu.FIRST + 6;
  91.    private static final int MENU_SLEEP_CANCEL = Menu.FIRST + 7;
  92.    private static final int MENU_SETTINGS = Menu.FIRST + 8;
  93.    private static final int MENU_SPEAKER = Menu.FIRST + 9;
  94.    private static final int MENU_TAGS = Menu.FIRST + 10;
  95.    private static final int MENU_STAT_TEST = Menu.FIRST + 11;
  96.    private static final int MENU_STATION_LIST = Menu.FIRST + 12;
  97.  //20150326 added by  lisineng for wakeup FM
  98.    private static final int MENU_WAKEUP = Menu.FIRST + 13;
  99.    private static final int MENU_WAKEUP_CANCEL = Menu.FIRST + 14;
  100.    public final String ALARM_FM = "android.intent.action_WAKE_UP";
  101.    boolean hasWakeup = false;
  102.  //added end
  103.    /* Dialog Identifiers */
  104.    private static final int DIALOG_SEARCH = 1;
  105.    private static final int DIALOG_SLEEP = 2;
  106.    private static final int DIALOG_SELECT_PRESET_LIST = 3;
  107.    private static final int DIALOG_PRESETS_LIST = 4;
  108.    private static final int DIALOG_PRESET_LIST_RENAME = 5;
  109.    private static final int DIALOG_PRESET_LIST_DELETE = 6;
  110.    private static final int DIALOG_PRESET_LIST_AUTO_SET = 7;
  111.    private static final int DIALOG_PICK_FREQUENCY = 8;
  112.    private static final int DIALOG_PROGRESS_PROGRESS = 9;
  113.    private static final int DIALOG_PRESET_OPTIONS = 10;
  114.    private static final int DIALOG_PRESET_RENAME = 11;
  115.    private static final int DIALOG_CMD_TIMEOUT = 12;
  116.    private static final int DIALOG_CMD_FAILED = 13;
  117.    private static final int DIALOG_CMD_FAILED_HDMI_ON = 14;
  118.    private static final int DIALOG_CMD_FAILED_CALL_ON = 15;
  119.    private static final int DIALOG_TAGS = 16;
  120.  
  121.    private static final int DIALOG_WAKEUP = 17; //20150326 added by  lisineng for wakeup FM
  122.    /* Activity Return ResultIdentifiers */
  123.    private static final int ACTIVITY_RESULT_SETTINGS = 1;
  124.  
  125.    /* Activity Return ResultIdentifiers */
  126.    private static final int MAX_PRESETS_PER_PAGE = 7;
  127.  
  128.  
  129.    /* Station's Audio is Stereo */
  130.    private static final int FMRADIO_UI_STATION_AUDIO_STEREO = 1;
  131.    /* Station's Audio is Mono */
  132.    private static final int FMRADIO_UI_STATION_AUDIO_MONO = 2;
  133.  
  134.    /* The duration during which the "Sleep: xx:xx" string will be toggling
  135.     */
  136.    private static final int SLEEP_TOGGLE_SECONDS = 60;
  137.  
  138.    /* The number of Preset Stations to create.
  139.     * The hardware supports a maximum of 12.
  140.     */
  141.    private static final int NUM_AUTO_PRESETS_SEARCH= 12;
  142.    /*
  143.     * Command time out: For asynchonous operations, if no response
  144.     * is received with int this duration, a timeout msg will be displayed.
  145.     */
  146.    private static final int CMD_TIMEOUT_DELAY_MS = 5000;
  147.    private static final int MSG_CMD_TIMEOUT = 101;
  148.  
  149.    private static final int CMD_NONE = 0;
  150.    private static final int CMD_TUNE = 1;
  151.    private static final int CMD_FMON = 2;
  152.    private static final int CMD_FMOFF = 3;
  153.    private static final int CMD_FMCONFIGURE = 4;
  154.    private static final int CMD_MUTE = 5;
  155.    private static final int CMD_SEEK = 6;
  156.    private static final int CMD_SCAN = 7;
  157.    private static final int CMD_SEEKPI = 8;
  158.    private static final int CMD_SEARCHLIST = 9;
  159.    private static final int CMD_CANCELSEARCH = 10;
  160.    private static final int CMD_SET_POWER_MODE = 11;
  161.    private static final int CMD_SET_AUDIO_MODE = 12;
  162.    private static final int CMD_SET_AUTOAF = 13;
  163.    private static final int CMD_GET_INTERNALANTENNA_MODE = 14;
  164.  
  165.    private static final int PRESETS_OPTIONS_TUNE = 0;
  166.    private static final int PRESETS_OPTIONS_REPLACE = 1;
  167.    private static final int PRESETS_OPTIONS_RENAME = 2;
  168.    private static final int PRESETS_OPTIONS_DELETE = 3;
  169.    private static final int PRESETS_OPTIONS_SEARCHPI = 4;
  170.  
  171.    public static final String SCAN_STATION_PREFS_NAME = "scan_station_list";
  172.    public static final String NUM_OF_STATIONS= "number_of_stations";
  173.    public static final String STATION_NAME = "name_of_station";
  174.    public static final String STATION_FREQUENCY = "frequency_of_station";
  175.  
  176.    private IFMRadioService mService = null;
  177.    private FmSharedPreferences mPrefs;
  178.  
  179.    /* Button Resources */
  180.    private ImageView mOnOffButton;
  181.    private ImageView mMuteButton;
  182.    private ImageView mSpeakerButton;
  183.    /* Button to navigate Preset pages */
  184.    private ImageButton mPresetPageButton;
  185.    /* 6 Preset Buttons */
  186.    private Button[] mPresetButtons = {null, null, null, null, null, null, null};
  187.    private Button mPresetListButton;
  188.    // private ImageButton mSearchButton;
  189.    private ImageView mForwardButton;
  190.    private ImageView mBackButton;
  191.  
  192.    /* Top row in the station info layout */
  193.    private ImageView mRSSI;
  194.    private TextView mProgramServiceTV;
  195.    private TextView mStereoTV;
  196.  
  197.    /* Middle row in the station info layout */
  198.    private TextView mTuneStationFrequencyTV;
  199.    private TextView mStationCallSignTV;
  200.    private TextView mProgramTypeTV;
  201.  
  202.    /* Bottom row in the station info layout */
  203.    private TextView mRadioTextTV;
  204.    private TextView mERadioTextTV;
  205.  
  206.    /* Sleep and Recording Messages */
  207.    private TextView mSleepMsgTV;
  208.    private TextView mRecordingMsgTV;
  209.  
  210.    private double mOutputFreq;
  211.    private int mPresetPageNumber = 0;
  212.    private int mStereo = -1;
  213.  
  214.    // default audio device - speaker
  215.    private static int mAudioRoute = FMRadioService.RADIO_AUDIO_DEVICE_WIRED_HEADSET;
  216.    private static boolean mFMStats = false;
  217.  
  218.  
  219.    /* Current Status Indicators */
  220.    private static boolean mRecording = false;
  221.    private static boolean mIsScaning = false;
  222.    private static boolean mIsSeeking = false;
  223.    private static boolean mIsSearching = false;
  224.    private static int mScanPty = 0;
  225.    private static int mScanPtyIndex = 0;
  226.    private Animation mAnimation = null;
  227.    private ScrollerText mRadioTextScroller = null;
  228.    private ScrollerText mERadioTextScroller = null;
  229.  
  230.    private PresetStation mTunedStation = new PresetStation("", 102100);
  231.    private PresetStation mPresetButtonStation = null;
  232.  
  233.    /* Radio Vars */
  234.    private Handler mHandler = new Handler();
  235.    /* Search Progress Dialog */
  236.    private ProgressDialog mProgressDialog = null;
  237.  
  238.    /* Asynchronous command active */
  239.    private static int mCommandActive = 0;
  240.  
  241.    /* Command that failed (Sycnhronous or Asynchronous) */
  242.    private static int mCommandFailed = 0;
  243.  
  244.    private  HorizontalNumberPicker mPicker;
  245.    private int mFrequency;
  246.  
  247.    /** Index of arrays.xml key word "search_category_rbds_entries or search_category_rds_entries resources*/
  248.    private int mItemsIndex = -1;
  249.    private static int mDisplayWidth;
  250.    private static final int TEXTSIZE_PARAMETER_FOR_NUMBER_PICKER = 20;
  251.    private static final int FREQUENCY_STEP_SMALL = 50;
  252.    private static final int FREQUENCY_STEP_MEDIUM = 100;
  253.    private static final int FREQUENCY_STEP_LARGE = 200;
  254.    public static boolean mUpdatePickerValue = false;
  255.  
  256.    private LoadedDataAndState SavedDataAndState = null;
  257.    private static String mBTsoc = "invalid";
  258.  
  259.    /** fm stats property string */
  260.    public static final String FM_STATS_PROP = "persist.fm.stats";
  261.  
  262.    private BroadcastReceiver mFmSettingReceiver = null;
  263.  
  264.    /** Called when the activity is first created. */
  265.    @Override
  266.    public void onCreate(Bundle savedInstanceState) {
  267.       super.onCreate(savedInstanceState);
  268.       setVolumeControlStream(AudioManager.STREAM_MUSIC);
  269.       mPrefs = new FmSharedPreferences(this);
  270.       mCommandActive = CMD_NONE;
  271.       mCommandFailed = CMD_NONE;
  272.  
  273.       Log.d(LOGTAG, "onCreate - Height : "+ getWindowManager().getDefaultDisplay().getHeight()
  274.             + " - Width  : "+ getWindowManager().getDefaultDisplay().getWidth());
  275.  
  276.       mDisplayWidth = getWindowManager().getDefaultDisplay().getWidth();
  277.       DisplayMetrics outMetrics = new DisplayMetrics();
  278.       getWindowManager().getDefaultDisplay().getMetrics(outMetrics );
  279.  
  280.       setContentView(R.layout.fmradio);
  281.       SavedDataAndState = (LoadedDataAndState)getLastNonConfigurationInstance();
  282.  
  283.       mPicker = (HorizontalNumberPicker)findViewById(R.id.fm_picker);
  284.       if (mPicker != null) {
  285.           mPicker.setTextSize(mDisplayWidth / TEXTSIZE_PARAMETER_FOR_NUMBER_PICKER);
  286.           mPicker.setDensity(outMetrics.densityDpi);
  287.           mPicker.setOnValueChangedListener(new OnValueChangeListener(){
  288.             @Override
  289.             public void onValueChange(HorizontalNumberPicker picker,
  290.                     int oldVal, int newVal) {
  291.                 // TODO Auto-generated method stub
  292.                 valueToFrequency(newVal);
  293.                 mHandler.post(mRadioChangeFrequency);
  294.             }
  295.         });
  296.       }
  297.  
  298.       mAnimation = AnimationUtils.loadAnimation(this,
  299.                                                 R.anim.preset_select);
  300.  
  301.       mMuteButton = (ImageView)findViewById(R.id.btn_silent);
  302.       if (mMuteButton != null) {
  303.           mMuteButton.setOnClickListener(mMuteModeClickListener);
  304.       }
  305.  
  306.       mSpeakerButton = (ImageView)findViewById(R.id.btn_speaker_earphone);
  307.       if (mSpeakerButton != null) {
  308.           mSpeakerButton.setOnClickListener(mSpeakerClickListener);
  309.       }
  310.  
  311.       mOnOffButton = (ImageView)findViewById(R.id.btn_onoff);
  312.       if (mOnOffButton != null) {
  313.           mOnOffButton.setOnClickListener(mTurnOnOffClickListener);
  314.       }
  315.  
  316.       mForwardButton = (ImageView)findViewById(R.id.btn_forward);
  317.       if (mForwardButton != null) {
  318.           mForwardButton.setOnClickListener(mForwardClickListener);
  319.           mForwardButton.setOnLongClickListener(mForwardLongClickListener);
  320.       }
  321.  
  322.       mBackButton = (ImageView)findViewById(R.id.btn_back);
  323.       if (mBackButton != null) {
  324.           mBackButton.setOnClickListener(mBackClickListener);
  325.           mBackButton.setOnLongClickListener(mBackLongClickListener);
  326.       }
  327.  
  328.       /* 6 Preset Buttons */
  329.       mPresetButtons[0] = (Button)findViewById(R.id.presets_button_1);
  330.       mPresetButtons[1] = (Button)findViewById(R.id.presets_button_2);
  331.       mPresetButtons[2] = (Button)findViewById(R.id.presets_button_3);
  332.       mPresetButtons[3] = (Button)findViewById(R.id.presets_button_4);
  333.       mPresetButtons[4] = (Button)findViewById(R.id.presets_button_5);
  334.       mPresetButtons[5] = (Button)findViewById(R.id.presets_button_6);
  335.       mPresetButtons[6] = (Button)findViewById(R.id.presets_button_7);
  336.  
  337.       for (int nButton = 0; nButton < MAX_PRESETS_PER_PAGE; nButton++) {
  338.          if (mPresetButtons[nButton] != null) {
  339.              mPresetButtons[nButton]
  340.                .setOnClickListener(mPresetButtonClickListener);
  341.              mPresetButtons[nButton]
  342.                .setOnLongClickListener(mPresetButtonOnLongClickListener);
  343.          }
  344.       }
  345.  
  346.       mTuneStationFrequencyTV = (TextView)findViewById(R.id.prog_frequency_tv);
  347.       if (mTuneStationFrequencyTV != null) {
  348.          mTuneStationFrequencyTV.setOnLongClickListener(mFrequencyViewClickListener);
  349.       }
  350.       mProgramServiceTV = (TextView)findViewById(R.id.prog_service_tv);
  351.       mStereoTV = (TextView)findViewById(R.id.stereo_text_tv);
  352.  
  353.       mStationCallSignTV = (TextView)findViewById(R.id.call_sign_tv);
  354.       mProgramTypeTV = (TextView)findViewById(R.id.pty_tv);
  355.  
  356.       mRadioTextTV = (TextView)findViewById(R.id.radio_text_tv);
  357.       mERadioTextTV = (TextView)findViewById(R.id.eradio_text_tv);
  358.       mSleepMsgTV = (TextView)findViewById(R.id.sleep_msg_tv);
  359.       mRecordingMsgTV = (TextView)findViewById(R.id.record_msg_tv);
  360.       if (mRecordingMsgTV != null) {
  361.           mRecordingMsgTV.setOnClickListener(mRecordButtonListener);
  362.       }
  363.       /* Disable displaying RSSI */
  364.       mRSSI = (ImageView)findViewById(R.id.signal_level);
  365.       if (mRSSI != null) {
  366.           mRSSI.setVisibility(View.INVISIBLE);
  367.       }
  368.  
  369.       if ((mRadioTextScroller == null) && (mRadioTextTV != null)) {
  370.           mRadioTextScroller = new ScrollerText(mRadioTextTV);
  371.       }
  372.  
  373.       if ((mERadioTextScroller == null) && (mERadioTextTV != null)) {
  374.           mERadioTextScroller = new ScrollerText(mERadioTextTV);
  375.       }
  376.       mBTsoc = SystemProperties.get("qcom.bluetooth.soc");
  377.  
  378. //20150326 added by  lisineng for wakeup FM     
  379.       if(!getIntent().getBooleanExtra("fromBroadcast", false)){
  380.     	  hasWakeup =  getSharedPreferences("fmradio_prefs",MODE_PRIVATE).getBoolean("hasWakeup", false);
  381.       }
  382. //added end 
  383.    }
  384.  
  385.    protected void setDisplayvalue(){
  386.        int max = mPrefs.getUpperLimit();
  387.        int min = mPrefs.getLowerLimit();
  388.        int step = mPrefs.getFrequencyStepSize();
  389.        switch(step) {
  390.        case FREQUENCY_STEP_SMALL:
  391.            mPicker.setScale(Scale.SCALE_SMALL);
  392.            break;
  393.        case FREQUENCY_STEP_MEDIUM:
  394.            mPicker.setScale(Scale.SCALE_MEDIUM);
  395.            break;
  396.        case FREQUENCY_STEP_LARGE:
  397.            mPicker.setScale(Scale.SCALE_LARGE);
  398.        }
  399.  
  400.        int channels = (int)((max - min) / step);
  401.        String [] displayValues = new String[channels + 1];
  402.        for(int i = 0; i < displayValues.length; i++) {
  403.            displayValues[i] = String.valueOf((min + i * step) / 1000.0f);
  404.        }
  405.        mPicker.setDisplayedValues(displayValues, true);
  406.        try {
  407.            mPicker.setWrapSelectorWheel(true);
  408.        } catch (IllegalStateException e) {
  409.            e.printStackTrace();
  410.        }
  411.        mPicker.invalidate();
  412.    }
  413.    protected int valueToFrequency(int value) {
  414.        mFrequency = mPrefs.getLowerLimit() + value *
  415.                              mPrefs.getFrequencyStepSize();
  416.        return mFrequency;
  417.    }
  418.  
  419.    @Override
  420.    public void onRestart() {
  421.       Log.d(LOGTAG, "FMRadio: onRestart");
  422.       try {
  423.          if (null != mService) {
  424.               mService.requestFocus();
  425.          }
  426.       } catch (Exception e) {
  427.          e.printStackTrace();
  428.       }
  429.       super.onRestart();
  430.    }
  431.  
  432.    @Override
  433.    public void onStop() {
  434.       Log.d(LOGTAG, "FMRadio: onStop");
  435.       if(isRecording()) {
  436.           try {
  437.               if (null != mRecordUpdateHandlerThread) {
  438.                   mRecordUpdateHandlerThread.interrupt();
  439.               }
  440.           }catch (NullPointerException e) {
  441.               e.printStackTrace();
  442.           }
  443.       }
  444.       super.onStop();
  445.    }
  446.  
  447.    @Override
  448.    public void onStart() {
  449.       super.onStart();
  450.       Log.d(LOGTAG, "FMRadio: onStart");
  451.       if ((mService == null ) && (false == bindToService(this, osc))) {
  452.           Log.d(LOGTAG, "onStart: Failed to Start Service");
  453.       } else {
  454.           Log.d(LOGTAG, "onStart: Start Service completed successfully");
  455.       }
  456.       registerFMSettingListner();
  457.       mPrefs.Load();
  458.       if (mPicker != null) {
  459.           setDisplayvalue();
  460.       }
  461.       PresetStation station = new PresetStation("",
  462.                                    FmSharedPreferences.getTunedFrequency());
  463.       if (station != null) {
  464.           mTunedStation.Copy(station);
  465.       }
  466.  
  467.    }
  468.    //20150326 added by  lisineng for wakeup FM  
  469.    @Override
  470. 	protected void onNewIntent(Intent intent) {
  471. 		super.onNewIntent(intent);
  472. 		if(intent.getBooleanExtra("fromBroadcast", false)){
  473. 			 hasWakeup = false;
  474. 			 AudioManager localAudioManager = (AudioManager) getSystemService(Context.AUDIO_SERVICE);   
  475. 			 boolean hasHeadset = localAudioManager.isWiredHeadsetOn(); //had headset
  476. 			 if(hasHeadset){
  477. 				 if (!isFmOn()) {
  478. 					 Log.i(LOGTAG, "lsn enableRadio");
  479. 					 mDisableRadioHandler.removeCallbacks(mDisableRadioTask);
  480. 		             mEnableRadioHandler.removeCallbacks(mEnableRadioTask);
  481. 		             mEnableRadioHandler.postDelayed(mEnableRadioTask, 0);
  482. 		          }
  483. 			 }
  484. 		 }
  485.           cleanupTimeoutHandler();
  486. 	}
  487. //added end
  488.  
  489.    @Override
  490.    protected void onPause() {
  491.       Log.d(LOGTAG, "FMRadio: onPause");
  492.       super.onPause();
  493.       if (isSleepTimerActive()) {
  494.           Log.d(LOGTAG, "FMRadio: Sleep Timer active");
  495.           mSleepUpdateHandlerThread.interrupt();
  496.       }
  497.       mRadioTextScroller.stopScroll();
  498.       mERadioTextScroller.stopScroll();
  499.       FmSharedPreferences.setTunedFrequency(mTunedStation.getFrequency());
  500.       mPrefs.Save();
  501.    }
  502.  
  503.    @Override
  504.    public void onResume() {
  505.       super.onResume();
  506.       try {
  507.          if(mService != null) {
  508.             mService.registerCallbacks(mServiceCallbacks);
  509.          }
  510.       }catch (RemoteException e) {
  511.          e.printStackTrace();
  512.       }
  513.       if(isSleepTimerActive()) {
  514.           Log.d(LOGTAG, "isSleepTimerActive is true");
  515.           try {
  516.                if(null != mService) {
  517.                   mService.cancelDelayedStop(FMRadioService.STOP_SERVICE);
  518.                }
  519.                if(null != mSleepUpdateHandlerThread) {
  520.                   mSleepUpdateHandlerThread.interrupt();
  521.                }
  522.           }catch (Exception e) {
  523.                e.printStackTrace();
  524.           }
  525.           initiateSleepThread();
  526.       }
  527.       if(isRecording()) {
  528.           Log.d(LOGTAG,"isRecordTimerActive is true");
  529.           try {
  530.             if (null != mService) {
  531.                 mService.cancelDelayedStop(FMRadioService.STOP_RECORD);
  532.             }
  533.           }catch (Exception e) {
  534.             e.printStackTrace();
  535.           }
  536.           if(isRecording()) {
  537.               initiateRecordThread();
  538.           }
  539.       }
  540.       Log.d(LOGTAG, "FMRadio: onResume");
  541.       mStereo = FmSharedPreferences.getLastAudioMode();
  542.       mHandler.post(mUpdateProgramService);
  543.       mHandler.post(mUpdateRadioText);
  544.       mHandler.post(mOnStereo);
  545.       mUpdatePickerValue = true;
  546.       updateStationInfoToUI();
  547.       enableRadioOnOffUI();
  548.    }
  549.    private static class LoadedDataAndState {
  550.       public LoadedDataAndState(){};
  551.       public boolean onOrOff;
  552.    }
  553.    @Override
  554.    public Object onRetainNonConfigurationInstance() {
  555.       LoadedDataAndState data = new LoadedDataAndState();
  556.       if (mService != null) {
  557.          try {
  558.               data.onOrOff = mService.isFmOn();
  559.          }catch(RemoteException e) {
  560.               data.onOrOff = false;
  561.               e.printStackTrace();
  562.          }
  563.       }else {
  564.          data.onOrOff = false;
  565.       }
  566.       return data;
  567.    }
  568.  
  569.    @Override
  570.    public void onDestroy() {
  571.       super.onDestroy();
  572.       Log.d(LOGTAG, "FMRadio: onDestroy");
  573.       mHandler.removeCallbacksAndMessages(null);
  574.       cleanupTimeoutHandler();
  575.       if(mProgressDialog != null) {
  576.          mProgressDialog.dismiss();
  577.       }
  578.       if(mSearchProgressHandler != null) {
  579.          mSearchProgressHandler.removeCallbacksAndMessages(null);
  580.       }
  581.       removeDialog(DIALOG_PRESET_OPTIONS);
  582.       unRegisterReceiver(mFmSettingReceiver);
  583.       if (mService != null) {
  584.           try {
  585.                if(!mService.isFmOn()) {
  586.                   endSleepTimer();
  587.                }
  588.           }catch (RemoteException e) {
  589.                e.printStackTrace();
  590.           }
  591.       }
  592.       getSharedPreferences("fmradio_prefs", MODE_PRIVATE).edit().putBoolean("hasWakeup", hasWakeup).commit();//20150326 added by  lisineng for wakeup FM   
  593.       unbindFromService(this);
  594.       mService = null;
  595.       Log.d(LOGTAG, "onDestroy: unbindFromService completed");
  596.    }
  597.  
  598.    @Override
  599.    public boolean onCreateOptionsMenu(Menu menu) {
  600.       super.onCreateOptionsMenu(menu);
  601.       MenuItem item;
  602.       boolean radioOn = isFmOn();
  603.       boolean recording = isRecording();
  604.       boolean mSpeakerPhoneOn = isSpeakerEnabled();
  605.       boolean sleepActive = isSleepTimerActive();
  606.       boolean searchActive = isScanActive() || isSeekActive();
  607.  
  608.       item = menu.add(0, MENU_SCAN_START, 0, R.string.menu_scan_start).
  609.                             setIcon(R.drawable.ic_btn_search);
  610.       if (item != null) {
  611.           item.setVisible((!searchActive) && radioOn);
  612.       }
  613.       item = menu.add(0, MENU_SCAN_STOP, 0, R.string.menu_scan_stop).
  614.                             setIcon(R.drawable.ic_btn_search);
  615.       if (item != null) {
  616.           item.setVisible(searchActive && radioOn);
  617.       }
  618.  
  619.       if (RECORDING_ENABLE) {
  620.           item = menu.add(0, MENU_RECORD_START, 0, R.string.menu_record_start)
  621.                               .setIcon(R.drawable.ic_menu_record);
  622.           if (item != null) {
  623.              item.setVisible(true);
  624.              item.setEnabled((!recording) && radioOn);
  625.           }
  626.           item = menu.add(0, MENU_RECORD_STOP, 0, R.string.menu_record_stop)
  627.                               .setIcon(R.drawable.ic_menu_record);
  628.           if (item != null) {
  629.              item.setVisible(true);
  630.              item.setEnabled(recording && radioOn);
  631.           }
  632.       }
  633.       /* Settings can be active */
  634.       item = menu.add(0, MENU_SETTINGS, 0, R.string.menu_settings).
  635.                               setIcon(android.R.drawable.ic_menu_preferences);
  636.  
  637.       item = menu.add(0, MENU_SLEEP, 0, R.string.menu_sleep).
  638.                               setTitle(R.string.menu_sleep);
  639.       if (item != null) {
  640.           item.setVisible((!sleepActive) && radioOn);
  641.       }
  642.       item = menu.add(0, MENU_SLEEP_CANCEL, 0, R.string.menu_sleep_cancel).
  643.                               setTitle(R.string.menu_sleep_cancel);
  644.       if (item != null) {
  645.           item.setVisible(sleepActive && radioOn);
  646.       }
  647.       
  648. //20150326 added by  lisineng for wakeup FM
  649.       item = menu.add(0,MENU_WAKEUP,0,R.string.menu_wakeup).setTitle(R.string.menu_wakeup);
  650.       if(item != null){
  651.     	  item.setVisible(!hasWakeup);
  652.       }
  653.             
  654.       item = menu.add(0,MENU_WAKEUP_CANCEL,0,R.string.menu_wakeup_cancel).setTitle(R.string.menu_wakeup_cancel);
  655.       Log.i(LOGTAG, "lsn hasWakeup = "+hasWakeup);
  656.       if(item != null ){
  657.     	  item.setVisible(hasWakeup);
  658.       }
  659.       
  660. //added end
  661.       mFMStats = SystemProperties.getBoolean(FM_STATS_PROP, false);
  662.       if(mFMStats) {
  663.           item = menu.add(0, MENU_STAT_TEST, 0,R.string.menu_stats).
  664.                              setIcon(android.R.drawable.ic_menu_info_details);
  665.       }
  666.       menu.add(0, MENU_STATION_LIST, 0, R.string.menu_all_channels);
  667.       item = menu.add(0, MENU_TAGS, 0, R.string.menu_display_tags);
  668.       return true;
  669.    }
  670.  
  671.    @Override
  672.    public boolean onPrepareOptionsMenu(Menu menu) {
  673.       super.onPrepareOptionsMenu(menu);
  674.       MenuItem item;
  675.       boolean radioOn = isFmOn();
  676.       boolean recording = isRecording();
  677.       boolean mSpeakerPhoneOn = isSpeakerEnabled();
  678.       boolean searchActive = isScanActive() || isSeekActive();
  679.  
  680.       item = menu.findItem(MENU_SCAN_START);
  681.       if (item != null) {
  682.           item.setVisible((!searchActive) && radioOn);
  683.       }
  684.       item = menu.findItem(MENU_SCAN_STOP);
  685.       if (item != null) {
  686.          item.setVisible(searchActive && radioOn);
  687.       }
  688.       if (RECORDING_ENABLE) {
  689.          item = menu.findItem(MENU_RECORD_START);
  690.          if (item != null) {
  691.             item.setVisible(true);
  692.             item.setEnabled((!recording) && radioOn && (!isAnalogModeEnabled()));
  693.          }
  694.          item = menu.findItem(MENU_RECORD_STOP);
  695.          if (item != null) {
  696.              item.setVisible(true);
  697.              item.setEnabled(recording && radioOn && (!isAnalogModeEnabled()));
  698.          }
  699.       }
  700.  
  701.       boolean sleepActive = isSleepTimerActive();
  702.       item = menu.findItem(MENU_SLEEP);
  703.       if (item != null) {
  704.           item.setVisible((!sleepActive) && radioOn);
  705.       }
  706.       item = menu.findItem(MENU_SLEEP_CANCEL);
  707.       if (item != null) {
  708.           item.setVisible(sleepActive && radioOn);
  709.       }
  710. //20150326 added by  lisineng for wakeup FM
  711.       item = menu.findItem(MENU_WAKEUP);
  712.       if(item != null){
  713.     	  item.setVisible(!hasWakeup);
  714.       }
  715.       
  716.       item = menu.findItem(MENU_WAKEUP_CANCEL);
  717.       if(item != null){
  718.     	  item.setVisible(hasWakeup);
  719.       }
  720. //added end
  721.       return true;
  722.    }
  723.  
  724.    @Override
  725.    public boolean onOptionsItemSelected(MenuItem item) {
  726.       switch (item.getItemId()) {
  727.       case MENU_SETTINGS:
  728.          Intent launchPreferencesIntent = new Intent().setClass(this,
  729.                                                                 Settings.class);
  730.                   launchPreferencesIntent.putExtra(Settings.RX_MODE,true);
  731.          startActivityForResult(launchPreferencesIntent,
  732.                                 ACTIVITY_RESULT_SETTINGS);
  733.          return true;
  734.       case MENU_STAT_TEST:
  735.           Intent launchFMStatIntent = new Intent().setClass(this,
  736.                                                             FMStats.class);
  737.           startActivity(launchFMStatIntent);
  738.           return true;
  739.       case MENU_SCAN_START:
  740. //20150604 modified by lisineng for deleted  the useless stations 		
  741. //         if (mBTsoc.equals("rome")) {
  742.              clearStationList();
  743.              initiateSearch(0); // 0 - All stations
  744. //         } else {
  745. //             showDialog(DIALOG_SEARCH);
  746. //         }
  747. //modifed end             
  748.          return true;
  749.       case MENU_SCAN_STOP:
  750.          cancelSearch();
  751.          return true;
  752.       case MENU_RECORD_START:
  753.          startRecording();
  754.          return true;
  755.       case MENU_RECORD_STOP:
  756.          stopRecording();
  757.          return true;
  758.       case MENU_SLEEP:
  759.          showDialog(DIALOG_SLEEP);
  760.          return true;
  761.       case MENU_SLEEP_CANCEL:
  762.          DebugToasts("Sleep Cancelled", Toast.LENGTH_SHORT);
  763.          endSleepTimer();
  764.          return true;
  765.       case MENU_STATION_LIST:
  766.           Intent stationListIntent = new Intent().setClass(this,
  767.                   StationListActivity.class);
  768.           startActivity(stationListIntent);
  769.           return true;
  770.       case MENU_TAGS:
  771.           Intent launchFMTagsIntent = new Intent().setClass(this,
  772.                                                             FmTags.class);
  773.           startActivity(launchFMTagsIntent);
  774.           return true;
  775.       //20150326 added by  lisineng for wakeup FM
  776.       case MENU_WAKEUP:
  777.           showDialog(DIALOG_WAKEUP);
  778.           return true;
  779.       case MENU_WAKEUP_CANCEL:
  780.           cancelWakeup();
  781.           return true;
  782.      //added end     
  783.       default:
  784.           break;
  785.       }
  786.       return super.onOptionsItemSelected(item);
  787.    }
  788.  
  789.    private void enableSpeaker() {
  790.     //This method with toggle Speaker phone based on existing state .
  791.        boolean bSpeakerPhoneOn = isSpeakerEnabled();
  792.        if(mService != null) {
  793.            try {
  794.                if (bSpeakerPhoneOn) {  // as Speaker is already on turn it off.
  795.                    mService.enableSpeaker(false);
  796.                    Log.d(LOGTAG, "Speaker phone is  turned off");
  797.                    mSpeakerButton.setImageResource(R.drawable.btn_earphone);
  798.                }else { // as Speaker is off turn it on.
  799.                    mService.enableSpeaker(true);
  800.                    Log.d(LOGTAG, "Speaker phone is turned on");
  801.                    mSpeakerButton.setImageResource(R.drawable.btn_speaker);
  802.                }
  803.                invalidateOptionsMenu();
  804.            }catch (RemoteException e) {
  805.                e.printStackTrace();
  806.            }
  807.        }
  808.    }
  809.  
  810.    private static final int RECORDTIMER_EXPIRED = 0x1003;
  811.    private static final int RECORDTIMER_UPDATE = 0x1004;
  812.  
  813.    private void updateExpiredRecordTime() {
  814.       int vis = View.VISIBLE;
  815.       if(isRecording())
  816.       {
  817.          long timeNow = ((SystemClock.elapsedRealtime()));
  818.          long seconds = (timeNow - getRecordingStartTime()) / 1000;
  819.          String Msg = makeTimeString(seconds);
  820.          mRecordingMsgTV.setText(Msg);
  821.          mRecordingMsgTV.setVisibility(vis);
  822.       }
  823.    }
  824.  
  825.    /* Recorder Thread processing */
  826.    private Runnable doRecordProcessing = new Runnable() {
  827.       public void run() {
  828.          while (isRecording() &&
  829.                  (!Thread.currentThread().isInterrupted()))
  830.          {
  831.             try
  832.             {
  833.                Thread.sleep(500);
  834.                Message statusUpdate = new Message();
  835.                statusUpdate.what = RECORDTIMER_UPDATE;
  836.                mUIUpdateHandlerHandler.sendMessage(statusUpdate);
  837.             } catch (InterruptedException e)
  838.             {
  839.                break;
  840.             }
  841.             if(!isRecording()) {
  842.                Message finished = new Message();
  843.                finished.what = RECORDTIMER_EXPIRED;
  844.                mUIUpdateHandlerHandler.sendMessage(finished);
  845.             }
  846.          }
  847.       }
  848.    };
  849.  
  850.    private Thread mRecordUpdateHandlerThread = null;
  851.  
  852.    private long getRecordingStartTime() {
  853.  
  854.       if(mService == null)
  855.          return 0;
  856.  
  857.       try {
  858.            return mService.getRecordingStartTime();
  859.       }catch(RemoteException e) {
  860.            return 0;
  861.       }
  862.    }
  863.  
  864.    private void initiateRecordDurationTimer(long mins ) {
  865.       Log.d(LOGTAG, "Stop Recording in mins : " + mins);
  866.       initiateRecordThread();
  867.     }
  868.     private void initiateRecordThread() {
  869.       if (mRecordUpdateHandlerThread == null) {
  870.           mRecordUpdateHandlerThread = new Thread(null, doRecordProcessing,
  871.                                                 "RecordUpdateThread");
  872.       }
  873.       /* Launch the dummy thread to simulate the transfer progress */
  874.       Log.d(LOGTAG, "Thread State: " + mRecordUpdateHandlerThread.getState());
  875.       if (mRecordUpdateHandlerThread.getState() == Thread.State.TERMINATED) {
  876.           mRecordUpdateHandlerThread = new Thread(null, doRecordProcessing,
  877.                                                 "RecordUpdateThread");
  878.       }
  879.       /* If the thread state is "new" then the thread has not yet started */
  880.       if (mRecordUpdateHandlerThread.getState() == Thread.State.NEW) {
  881.           mRecordUpdateHandlerThread.start();
  882.       }
  883.    }
  884.  
  885.    private void audioRoute (int audioDevice) {
  886.       boolean bStatus;
  887.       if (mService != null) {
  888.          try {
  889.              bStatus = mService.routeAudio(audioDevice);
  890.          }catch (RemoteException e) {
  891.              e.printStackTrace();
  892.          }
  893.       }
  894.    }
  895.  
  896.    @Override
  897.    protected Dialog onCreateDialog(int id) {
  898.       AlertDialog.Builder dlgBuilder = new AlertDialog.Builder(this);
  899.       dlgBuilder.setOnKeyListener(new OnKeyListener() {
  900.          public boolean onKey(DialogInterface dialog, int keyCode, KeyEvent event) {
  901.              Log.d(LOGTAG, "OnKeyListener event received"+keyCode);
  902.              switch (keyCode) {
  903.                  case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
  904.                  case 126: //KeyEvent.KEYCODE_MEDIA_PLAY:
  905.                  case 127: //KeyEvent.KEYCODE_MEDIA_PAUSE:
  906.                  case KeyEvent.KEYCODE_MEDIA_FAST_FORWARD:
  907.                  case KeyEvent.KEYCODE_MEDIA_NEXT:
  908.                  case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
  909.                  case KeyEvent.KEYCODE_MEDIA_REWIND:
  910.                  case KeyEvent.KEYCODE_MEDIA_STOP:
  911.                      return true;
  912.              }
  913.              return false;
  914.          }
  915.       });
  916.       switch (id) {
  917.       case DIALOG_SEARCH: {
  918.             return createSearchDlg(id, dlgBuilder);
  919.          }
  920.       case DIALOG_SLEEP: {
  921.             return createSleepDlg(id, dlgBuilder);
  922.          }
  923.       case DIALOG_PROGRESS_PROGRESS: {
  924.          return createProgressDialog(id);
  925.         }
  926.       case DIALOG_PRESET_OPTIONS: {
  927.          return createPresetOptionsDlg(id, dlgBuilder);
  928.        }
  929.       case DIALOG_PRESET_RENAME: {
  930.          return createPresetRenameDlg(id, dlgBuilder);
  931.        }
  932.       case DIALOG_CMD_TIMEOUT:{
  933.          return createCmdTimeoutDlg(id, dlgBuilder);
  934.       }
  935.       case DIALOG_CMD_FAILED:{
  936.          return createCmdFailedDlg(id, dlgBuilder);
  937.       }
  938.       case DIALOG_CMD_FAILED_HDMI_ON:{
  939.          return createCmdFailedDlgHdmiOn(id);
  940.       }
  941.       case DIALOG_CMD_FAILED_CALL_ON:{
  942.           return createCmdFailedDlgCallOn(id);
  943.       }
  944.       case DIALOG_PICK_FREQUENCY: {
  945.             FmConfig fmConfig = FmSharedPreferences.getFMConfiguration();
  946.             return new FrequencyPickerDialog(this, fmConfig, mTunedStation.getFrequency(), mFrequencyChangeListener);
  947.       }
  948.       //20150326 added by  lisineng for wakeup FM
  949.       case DIALOG_WAKEUP: {
  950.           return createWakeupDlg(id, dlgBuilder);
  951.        }
  952. 	  //added end
  953.       default:
  954.           break;
  955.       }
  956.       return null;
  957.    }
  958.  
  959.    @Override
  960.    protected void onPrepareDialog(int id, Dialog dialog) {
  961.       super.onPrepareDialog(id, dialog);
  962.       int curListIndex = FmSharedPreferences.getCurrentListIndex();
  963.       PresetList curList = FmSharedPreferences.getStationList(curListIndex);
  964.       switch (id) {
  965.       case DIALOG_PRESET_RENAME: {
  966.             EditText et = (EditText) dialog.findViewById(R.id.list_edit);
  967.             if ((et != null) && (mPresetButtonStation != null)) {
  968.                 et.setText(mPresetButtonStation.getName());
  969.             }
  970.             break;
  971.          }
  972.       case DIALOG_PRESET_OPTIONS: {
  973.             AlertDialog alertDlg = ((AlertDialog) dialog);
  974.             if ((alertDlg != null) && (mPresetButtonStation != null)) {
  975.                 alertDlg.setTitle(mPresetButtonStation.getName());
  976.             }
  977.             break;
  978.          }
  979.       case DIALOG_PICK_FREQUENCY:
  980.          {
  981.             if (dialog != null && mTunedStation != null)
  982.             {
  983.                FmConfig fmConfig = FmSharedPreferences.getFMConfiguration();
  984.               ((FrequencyPickerDialog) dialog).updateSteps(fmConfig.getChSpacing());
  985.               ((FrequencyPickerDialog) dialog).updateMinFreq(fmConfig.getLowerLimit());
  986.               ((FrequencyPickerDialog) dialog).updateMaxFreq(fmConfig.getUpperLimit());
  987.               ((FrequencyPickerDialog) dialog).UpdateFrequency(mTunedStation.getFrequency());
  988.             }
  989.             break;
  990.          }
  991.       default:
  992.             break;
  993.       }
  994.    }
  995.  
  996.    @Override
  997.    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
  998.       super.onActivityResult(requestCode, resultCode, data);
  999.       Log.d(LOGTAG, "onActivityResult : requestCode -> " + requestCode);
  1000.       Log.d(LOGTAG, "onActivityResult : resultCode -> " + resultCode);
  1001.       if (requestCode == ACTIVITY_RESULT_SETTINGS) {
  1002.          if (resultCode == RESULT_OK) {
  1003.              if (data != null) {
  1004.                 String action = data.getAction();
  1005.                 if (action != null) {
  1006.                   if (action.equals(Settings.RESTORE_FACTORY_DEFAULT_ACTION)) {
  1007.                       RestoreDefaults();
  1008.                       enableRadioOnOffUI();
  1009.                       tuneRadio(FmSharedPreferences.DEFAULT_NO_FREQUENCY);
  1010.                       FmSharedPreferences.addStation("", FmSharedPreferences.DEFAULT_NO_FREQUENCY, 0);
  1011.                   }
  1012.                }
  1013.             }
  1014.          } //if ACTIVITY_RESULT_SETTINGS
  1015.       }//if (resultCode == RESULT_OK)
  1016.    }
  1017.  
  1018.    /**
  1019.     * @return true if a wired headset is connected.
  1020.     */
  1021.    boolean isWiredHeadsetAvailable() {
  1022.       boolean bAvailable = false;
  1023.       if(mService != null) {
  1024.          try {
  1025.             bAvailable = mService.isWiredHeadsetAvailable();
  1026.          }catch (RemoteException e) {
  1027.             e.printStackTrace();
  1028.          }
  1029.       }
  1030.       Log.e(LOGTAG, "isWiredHeadsetAvailable: " + bAvailable);
  1031.       return bAvailable;
  1032.    }
  1033.  
  1034.     /**
  1035.      * @return true if a internal antenna is available.
  1036.      *
  1037.      */
  1038.     boolean isAntennaAvailable() {
  1039.        boolean bAvailable = false;
  1040.        if(mService != null) {
  1041.           try {
  1042.              bAvailable = mService.isAntennaAvailable();
  1043.           }catch (RemoteException e) {
  1044.              e.printStackTrace();
  1045.           }
  1046.        }
  1047.        return bAvailable;
  1048.     }
  1049.  
  1050.     boolean isCallActive(){
  1051.         boolean bCallActive = false;
  1052.         if(mService != null) {
  1053.             try {
  1054.                 bCallActive = mService.isCallActive();
  1055.             }catch (RemoteException e) {
  1056.                 e.printStackTrace();
  1057.             }
  1058.         }
  1059.         return bCallActive;
  1060.     }
  1061.  
  1062.    private Dialog createSearchDlg(int id, AlertDialog.Builder dlgBuilder) {
  1063.       String[] items;
  1064.       dlgBuilder.setIcon(R.drawable.ic_btn_search);
  1065.       dlgBuilder.setTitle(getString(R.string.search_dialog_title));
  1066.       /* Pick RBDS or RDS */
  1067.       if(FmSharedPreferences.isRBDSStd()) {
  1068.          items = getResources().getStringArray(R.array.search_category_rbds_entries);
  1069.       }else { // if(FmSharedPreferences.isRDSStd())
  1070.          items = getResources().getStringArray(R.array.search_category_rds_entries);
  1071.       }
  1072.       dlgBuilder.setItems(items, new DialogInterface.OnClickListener() {
  1073.           public void onClick(DialogInterface dialog, int item) {
  1074.              String[] items;
  1075.              String[] values;
  1076.  
  1077.              mItemsIndex = item ;
  1078.              /* Pick RBDS or RDS */
  1079.              if(FmSharedPreferences.isRBDSStd()) {
  1080.                 items = getResources().
  1081.                               getStringArray(R.array.search_category_rbds_entries);
  1082.                 values = getResources().
  1083.                               getStringArray(R.array.search_category_rbds_values);
  1084.              }else { // if(FmSharedPreferences.isRDSStd())
  1085.                 items = getResources().
  1086.                               getStringArray(R.array.search_category_rds_entries);
  1087.                 values = getResources().
  1088.                               getStringArray(R.array.search_category_rds_values);
  1089.              }
  1090.              if ((items != null) && (values != null) && (item >= 0)) {
  1091.                  if ((item >= 0) && (item <= items.length)
  1092.                        && (item <= items.length)) {
  1093.                     DebugToasts("Search Stations for : " + items[item]
  1094.                                 + " (" + values[item] + ")",
  1095.                                 Toast.LENGTH_SHORT);
  1096.                     int pty = Integer.parseInt(values[item]);
  1097.                     clearStationList();
  1098.                     mScanPtyIndex = item;
  1099.                     initiateSearch(pty);
  1100.                  }
  1101.              }
  1102.              removeDialog(DIALOG_SEARCH);
  1103.           }
  1104.       });
  1105.       return dlgBuilder.create();
  1106.    }
  1107.  
  1108.    private Dialog createPresetOptionsDlg(int id, AlertDialog.Builder dlgBuilder) {
  1109.       if(mPresetButtonStation != null) {
  1110.          dlgBuilder.setTitle(mPresetButtonStation.getName());
  1111.          ArrayList<String> arrayList = new ArrayList<String>();
  1112.          //PRESETS_OPTIONS_TUNE=0
  1113.          arrayList.add(getResources().getString(R.string.preset_tune));
  1114.          //PRESETS_OPTIONS_REPLACE=1
  1115.          arrayList.add(getResources().getString(R.string.preset_replace));
  1116.          //PRESETS_OPTIONS_RENAME=2
  1117.          arrayList.add(getResources().getString(R.string.preset_rename));
  1118.          //PRESETS_OPTIONS_DELETE=3
  1119.          arrayList.add(getResources().getString(R.string.preset_delete));
  1120.          String piString = mPresetButtonStation.getPIString();
  1121.          if (!TextUtils.isEmpty(piString)) {
  1122.             //PRESETS_OPTIONS_SEARCHPI=4
  1123.             arrayList.add(getResources().getString(R.string.preset_search, piString));
  1124.          }
  1125.  
  1126.          dlgBuilder.setCancelable(true);
  1127.          dlgBuilder.setOnCancelListener(new DialogInterface.OnCancelListener() {
  1128.             public void onCancel(DialogInterface dialog) {
  1129.                mPresetButtonStation = null;
  1130.                removeDialog(DIALOG_PRESET_OPTIONS);
  1131.             }
  1132.          });
  1133.          String[] items = new String [arrayList.size ()];
  1134.          arrayList.toArray(items);
  1135.          dlgBuilder.setItems(items, new DialogInterface.OnClickListener() {
  1136.              public void onClick(DialogInterface dialog, int item) {
  1137.                 if(mPresetButtonStation != null) {
  1138.                    switch(item) {
  1139.                    case PRESETS_OPTIONS_TUNE: {
  1140.                          // Tune to the station
  1141.                          tuneRadio(mPresetButtonStation.getFrequency());
  1142.                          mPresetButtonStation = null;
  1143.                          break;
  1144.                       }
  1145.                    case PRESETS_OPTIONS_REPLACE: {
  1146.                          // Replace preset Station with currently tuned station
  1147.                          if(!stationExists(mTunedStation)) {
  1148.                             Log.d(LOGTAG, "station - " + mPresetButtonStation.getName() + " ("
  1149.                                + mPresetButtonStation.getFrequency() + ")");
  1150.                             mPresetButtonStation.Copy(mTunedStation);
  1151.                             mPresetButtonStation = null;
  1152.                             setupPresetLayout();
  1153.                             mPrefs.Save();
  1154.                          }
  1155.                          break;
  1156.                       }
  1157.                    case PRESETS_OPTIONS_RENAME: {
  1158.                          // Rename
  1159.                          showDialog(DIALOG_PRESET_RENAME);
  1160.                          break;
  1161.                       }
  1162.                    case PRESETS_OPTIONS_DELETE: {
  1163.                          // Delete
  1164.                          int curListIndex = FmSharedPreferences.getCurrentListIndex();
  1165.                          FmSharedPreferences.removeStation(curListIndex, mPresetButtonStation);
  1166.                          if (mPresetButtonStation.getFrequency() == mTunedStation.getFrequency()) {
  1167.                              // Restore current tuned station's name as its frequency
  1168.                              mTunedStation.setName("");
  1169.                          }
  1170.                          mPresetButtonStation = null;
  1171.                          setupPresetLayout();
  1172.                          mPrefs.Save();
  1173.                          break;
  1174.                       }
  1175.                    case PRESETS_OPTIONS_SEARCHPI: {
  1176.                          // SearchPI
  1177.                          String piString = mPresetButtonStation.getPIString();
  1178.                          int pi = mPresetButtonStation.getPI();
  1179.                          if ((!TextUtils.isEmpty(piString)) &&  (pi > 0)) {
  1180.                             initiatePISearch(pi);
  1181.                          }
  1182.                          mPresetButtonStation = null;
  1183.                          break;
  1184.                       }
  1185.                    default: {
  1186.                          // Should not happen
  1187.                          mPresetButtonStation = null;
  1188.                          break;
  1189.                       }
  1190.                    }//switch item
  1191.                 }//if(mPresetButtonStation != null)
  1192.                 removeDialog (DIALOG_PRESET_OPTIONS);
  1193.              }//onClick
  1194.          });
  1195.          return dlgBuilder.create();
  1196.       }
  1197.       return null;
  1198.    }
  1199.  
  1200.    private Dialog createSleepDlg(int id, AlertDialog.Builder dlgBuilder) {
  1201.       dlgBuilder.setTitle(R.string.dialog_sleep_title);
  1202.       String[] items = getResources().getStringArray(R.array.sleep_duration_values);
  1203.  
  1204.       dlgBuilder.setItems(items, new DialogInterface.OnClickListener() {
  1205.           public void onClick(DialogInterface dialog, int item) {
  1206.               String[] items = getResources().getStringArray(R.array.sleep_duration_values);
  1207.               Toast.makeText(getApplicationContext(), items[item], Toast.LENGTH_SHORT).show();
  1208.               if ((item >= 0) && (item <= items.length)) {
  1209.                  long seconds = (long) (900 * (item + 1));
  1210.                  initiateSleepTimer(seconds);
  1211.               }
  1212.               removeDialog (DIALOG_SLEEP);
  1213.           }
  1214.       });
  1215.       return dlgBuilder.create();
  1216.    }
  1217.    //20150326 added by  lisineng for wakeup FM
  1218.    private Dialog createWakeupDlg(int id, AlertDialog.Builder dlgBuilder) {
  1219. 	      dlgBuilder.setTitle(R.string.dialog_wakeup_title);
  1220. 	      String[] items = getResources().getStringArray(R.array.wakeup_duration_values);
  1221. 	      dlgBuilder.setItems(items, new DialogInterface.OnClickListener() {
  1222. 	          public void onClick(DialogInterface dialog, int item) {
  1223. 	        	  hasWakeup = true;
  1224. 	              String[] items = getResources().getStringArray(R.array.wakeup_duration_values);
  1225. 	              Toast.makeText(getApplicationContext(), items[item], Toast.LENGTH_SHORT).show();
  1226. 	              if ((item >= 0) && (item <= items.length)) {
  1227. 	                 long seconds = (long) (900 * (item + 1));
  1228. 	                 Log.i(LOGTAG, "lsn seconds = "+seconds);
  1229. 	                 AlarmManager am = (AlarmManager)FMRadio.this.getSystemService(Context.ALARM_SERVICE);
  1230. 	                 Intent intent = new Intent(ALARM_FM);
  1231. 	                 PendingIntent pi = PendingIntent.getBroadcast(FMRadio.this, 0, intent, 0);
  1232. 	                 am.set(AlarmManager.RTC_WAKEUP, System.currentTimeMillis()+seconds*1000, pi);
  1233. 	              }
  1234. 	              removeDialog (DIALOG_WAKEUP);
  1235. 	          }
  1236. 	      });
  1237. 	      return dlgBuilder.create();
  1238. 	   }
  1239.    private void cancelWakeup(){
  1240. 	   hasWakeup = false;
  1241. 	   AlarmManager am = (AlarmManager) getSystemService(Context.ALARM_SERVICE);  
  1242.        Intent intent = new Intent(ALARM_FM);  
  1243.        PendingIntent sender = PendingIntent.getBroadcast(this, 0, intent, 0);  
  1244.        if (sender != null){  
  1245.            Log.i(LOGTAG," lsn cancel alarm");  
  1246.            am.cancel(sender);
  1247.            Toast toast = Toast.makeText(this, R.string.menu_wakeup_cancel, Toast.LENGTH_SHORT);
  1248.            toast.show();
  1249.        }else{  
  1250.            Log.i(LOGTAG,"lsn sender == null");  
  1251.        }  
  1252.    }
  1253. 	//added end
  1254.    private Dialog createProgressDialog(int id) {
  1255.       String msgStr = "";
  1256.       String titleStr = "";
  1257.       String []items;
  1258.       double frequency = mTunedStation.getFrequency() / 1000.0;
  1259.       boolean bSearchActive = false;
  1260.  
  1261.       if (isSeekActive()) {
  1262.           msgStr = getString(R.string.msg_seeking);
  1263.           bSearchActive = true;
  1264.       }else if (isScanActive()) {
  1265.           if(FmSharedPreferences.isRBDSStd()) {
  1266.                 items = getResources().
  1267.                          getStringArray(R.array.search_category_rbds_entries);
  1268.           }else { // if(FmSharedPreferences.isRDSStd())
  1269.                 items = getResources().
  1270.                          getStringArray(R.array.search_category_rds_entries);
  1271.           }
  1272.           String ptyStr = "";
  1273.           if (items.length > mScanPtyIndex)
  1274.               ptyStr = items[mScanPtyIndex];
  1275.           if (!TextUtils.isEmpty(ptyStr)) {
  1276.              msgStr = getString(R.string.msg_scanning_pty, ptyStr);
  1277.           }else {
  1278.              Log.d(LOGTAG, "pty is null\n");
  1279.              msgStr = getString(R.string.msg_scanning);
  1280.           }
  1281.           titleStr = getString(R.string.msg_search_title, ("" + frequency));
  1282.           bSearchActive=true;
  1283.       }else if (isSearchActive()) {
  1284.          msgStr = getString(R.string.msg_searching);
  1285.          titleStr = getString(R.string.msg_searching_title);
  1286.          bSearchActive = true;
  1287.       }
  1288.       if (bSearchActive) {
  1289.           mProgressDialog = new ProgressDialog(FMRadio.this);
  1290.           if (mProgressDialog != null) {
  1291.               mProgressDialog.setTitle(titleStr);
  1292.               mProgressDialog.setMessage(msgStr);
  1293.               mProgressDialog.setIcon(R.drawable.ic_launcher_fmradio);
  1294.               mProgressDialog.setProgressStyle(ProgressDialog.STYLE_SPINNER);
  1295.               mProgressDialog.setCanceledOnTouchOutside(false);
  1296.               mProgressDialog.setButton(DialogInterface.BUTTON_POSITIVE,
  1297.                                    getText(R.string.button_text_stop),
  1298.                new DialogInterface.OnClickListener() {
  1299.                   public void onClick(DialogInterface dialog, int whichButton) {
  1300.                       cancelSearch();
  1301.                   }
  1302.               });
  1303.               mProgressDialog.setOnCancelListener(new DialogInterface.OnCancelListener() {
  1304.                 public void onCancel(DialogInterface dialog) {
  1305.                    cancelSearch();
  1306.                 }
  1307.               });
  1308.               mProgressDialog.setOnKeyListener(new OnKeyListener() {
  1309.                 public boolean onKey(DialogInterface dialog, int keyCode, KeyEvent event) {
  1310.                     Log.d(LOGTAG, "OnKeyListener event received in ProgressDialog" + keyCode);
  1311.                     switch (keyCode) {
  1312.                         case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
  1313.                         case 126: //KeyEvent.KEYCODE_MEDIA_PLAY:
  1314.                         case 127: //KeyEvent.KEYCODE_MEDIA_PAUSE:
  1315.                         case KeyEvent.KEYCODE_MEDIA_FAST_FORWARD:
  1316.                         case KeyEvent.KEYCODE_MEDIA_NEXT:
  1317.                         case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
  1318.                         case KeyEvent.KEYCODE_MEDIA_REWIND:
  1319.                         case KeyEvent.KEYCODE_MEDIA_STOP:
  1320.                             return true;
  1321.                     }
  1322.                     return false;
  1323.                 }
  1324.             });
  1325.           }
  1326.           Message msg = new Message();
  1327.           msg.what = TIMEOUT_PROGRESS_DLG;
  1328.           mSearchProgressHandler.sendMessageDelayed(msg, SHOWBUSY_TIMEOUT);
  1329.       }
  1330.       return mProgressDialog;
  1331.    }
  1332.  
  1333.    private void updateSelectPresetListDlg(ListView lv) {
  1334.       if (lv != null) {
  1335.          List<PresetList> presetLists = FmSharedPreferences.getPresetLists();
  1336.          ListIterator<PresetList> presetIter;
  1337.          presetIter = presetLists.listIterator();
  1338.          int numLists = presetLists.size();
  1339.          int curIndex = FmSharedPreferences.getCurrentListIndex();
  1340.          ArrayAdapter<String> typeAdapter = new ArrayAdapter<String>
  1341.                                                 (this, android.R.layout.
  1342.                                                 simple_list_item_single_choice);
  1343.          for (int stationIter = 0; stationIter < numLists; stationIter++) {
  1344.             PresetList temp = presetIter.next();
  1345.             if (temp != null) {
  1346.                typeAdapter.add(getString(R.string.presetlist_select_name,
  1347.                                            temp.getName()));
  1348.             }
  1349.          }
  1350.          typeAdapter.add(getString(R.string.presetlist_add_new));
  1351.          lv.setAdapter(typeAdapter);
  1352.          lv.setChoiceMode(ListView.CHOICE_MODE_SINGLE);
  1353.          lv.clearChoices();
  1354.          if (curIndex >= numLists) {
  1355.              curIndex = 0;
  1356.          }
  1357.          if (lv.getCount() >= curIndex) {
  1358.             lv.setItemChecked(curIndex, true);
  1359.             lv.setSelection(curIndex);
  1360.          }else {
  1361.             lv.setItemChecked(0, true);
  1362.             lv.setSelection(0);
  1363.          }
  1364.       }
  1365.    }
  1366.  
  1367.    private Dialog createPresetRenameDlg(int id, AlertDialog.Builder dlgBuilder) {
  1368.       if(mPresetButtonStation == null) {
  1369.          return null;
  1370.       }
  1371.       LayoutInflater factory = LayoutInflater.from(this);
  1372.       final View textEntryView = factory.inflate(
  1373.                                                 R.layout.alert_dialog_text_entry, null);
  1374.       dlgBuilder.setTitle(R.string.dialog_presetlist_rename_title);
  1375.       dlgBuilder.setView(textEntryView);
  1376.       dlgBuilder.setPositiveButton(R.string.alert_dialog_ok,
  1377.                                    new DialogInterface.OnClickListener() {
  1378.                                       public void onClick(DialogInterface dialog, int whichButton) {
  1379.                                          //int curList = FmSharedPreferences.getCurrentListIndex();
  1380.  
  1381.                                          EditText mTV = (EditText) textEntryView
  1382.                                          .findViewById(R.id.list_edit);
  1383.                                          CharSequence newName = null;
  1384.                                          if (mTV != null) {
  1385.                                             newName = mTV.getEditableText();
  1386.                                          }
  1387.                                          String nName = String.valueOf(newName);
  1388.                                          mPresetButtonStation.setName(nName);
  1389.                                          mPresetButtonStation=null;
  1390.                                          setupPresetLayout();
  1391.                                          mPrefs.Save();
  1392.                                          removeDialog(DIALOG_PRESET_RENAME);
  1393.                                       }
  1394.                                    });
  1395.       dlgBuilder.setNegativeButton(R.string.alert_dialog_cancel,
  1396.                                    new DialogInterface.OnClickListener() {
  1397.                                       public void onClick(DialogInterface dialog, int whichButton) {
  1398.                                          removeDialog(DIALOG_PRESET_RENAME);
  1399.                                       }
  1400.                                    });
  1401.       return(dlgBuilder.create());
  1402.    }
  1403.  
  1404.    private Dialog createCmdTimeoutDlg(int id, AlertDialog.Builder dlgBuilder) {
  1405.       if(mCommandActive > 0) {
  1406.          dlgBuilder.setIcon(R.drawable.alert_dialog_icon)
  1407.                    .setTitle(R.string.fm_command_timeout_title);
  1408.          dlgBuilder.setMessage(R.string.fm_tune_timeout_msg);
  1409.          dlgBuilder.setPositiveButton(R.string.alert_dialog_ok,
  1410.                                       new DialogInterface.OnClickListener() {
  1411.                                          public void onClick(DialogInterface dialog,
  1412.                                                              int whichButton) {
  1413.                                             cleanupTimeoutHandler();
  1414.                                             removeDialog(DIALOG_CMD_TIMEOUT);
  1415.                                          }
  1416.                                       });
  1417.          return(dlgBuilder.create());
  1418.       }else {
  1419.          return(null);
  1420.       }
  1421.    }
  1422.  
  1423.    private Dialog createCmdFailedDlg(int id, AlertDialog.Builder dlgBuilder) {
  1424.       dlgBuilder.setIcon(R.drawable.alert_dialog_icon)
  1425.                 .setTitle(R.string.fm_command_failed_title);
  1426.       dlgBuilder.setMessage(R.string.fm_cmd_failed_msg);
  1427.  
  1428.       dlgBuilder.setPositiveButton(R.string.alert_dialog_ok,
  1429.                                    new DialogInterface.OnClickListener() {
  1430.                                       public void onClick(DialogInterface dialog,
  1431.                                                           int whichButton) {
  1432.                                          removeDialog(DIALOG_CMD_TIMEOUT);
  1433.                                          mCommandFailed = CMD_NONE;
  1434.                                       }
  1435.                                    });
  1436.  
  1437.       return(dlgBuilder.create());
  1438.    }
  1439.  
  1440.    private Dialog createCmdFailedDlgHdmiOn(int id) {
  1441.       AlertDialog.Builder dlgBuilder = new AlertDialog.Builder(this);
  1442.       dlgBuilder.setIcon(R.drawable.alert_dialog_icon)
  1443.                 .setTitle(R.string.fm_command_failed_title);
  1444.       dlgBuilder.setMessage(R.string.fm_cmd_failed_msg_hdmi);
  1445.  
  1446.       dlgBuilder.setPositiveButton(R.string.alert_dialog_ok,
  1447.                                    new DialogInterface.OnClickListener() {
  1448.                                       public void onClick(DialogInterface dialog,
  1449.                                                           int whichButton) {
  1450.                                          removeDialog(DIALOG_CMD_TIMEOUT);
  1451.                                          mCommandFailed = CMD_NONE;
  1452.                                       }
  1453.                                    });
  1454.  
  1455.       return(dlgBuilder.create());
  1456.    }
  1457.  
  1458.    private Dialog createCmdFailedDlgCallOn(int id) {
  1459.        AlertDialog.Builder dlgBuilder = new AlertDialog.Builder(this);
  1460.        dlgBuilder.setIcon(R.drawable.alert_dialog_icon)
  1461.                  .setTitle(R.string.fm_command_failed_title);
  1462.        dlgBuilder.setMessage(R.string.fm_cmd_failed_call_on);
  1463.  
  1464.        dlgBuilder.setPositiveButton(R.string.alert_dialog_ok,
  1465.                                     new DialogInterface.OnClickListener() {
  1466.                                        public void onClick(DialogInterface dialog,
  1467.                                                            int whichButton) {
  1468.                                           removeDialog(DIALOG_CMD_TIMEOUT);
  1469.                                           mCommandFailed = CMD_NONE;
  1470.                                           finish();
  1471.                                        }
  1472.                                     });
  1473.  
  1474.        return(dlgBuilder.create());
  1475.     }
  1476.    private void RestoreDefaults() {
  1477.       FmSharedPreferences.SetDefaults();
  1478.       mPrefs.Save();
  1479.    }
  1480.  
  1481.    private View.OnLongClickListener mFrequencyViewClickListener =
  1482.       new View.OnLongClickListener() {
  1483.         public boolean onLongClick(View v) {
  1484.           showDialog(DIALOG_PICK_FREQUENCY);
  1485.           return true;
  1486.         }
  1487.    };
  1488.  
  1489.    private View.OnClickListener mForwardClickListener =
  1490.       new View.OnClickListener() {
  1491.         public void onClick(View v) {
  1492.           int frequency = FmSharedPreferences.getNextTuneFrequency();
  1493.           Log.d(LOGTAG, "Tune Up: to " + frequency);
  1494.           tuneRadio(frequency);
  1495.       }
  1496.    };
  1497.  
  1498.    private View.OnClickListener mBackClickListener =
  1499.       new View.OnClickListener() {
  1500.         public void onClick(View v) {
  1501.           int frequency = FmSharedPreferences.getPrevTuneFrequency();
  1502.           Log.d(LOGTAG, "Tune Down: to " + frequency);
  1503.           tuneRadio(frequency);
  1504.       }
  1505.    };
  1506.  
  1507.    private View.OnLongClickListener mForwardLongClickListener =
  1508.       new View.OnLongClickListener() {
  1509.         public boolean onLongClick(View view) {
  1510.           SeekNextStation();
  1511.           return true;
  1512.         }
  1513.    };
  1514.  
  1515.    private View.OnLongClickListener mBackLongClickListener =
  1516.       new View.OnLongClickListener() {
  1517.         public boolean onLongClick(View view) {
  1518.           SeekPreviousStation();
  1519.           return true;
  1520.         }
  1521.    };
  1522.  
  1523.    private View.OnClickListener mPresetListClickListener =
  1524.       new View.OnClickListener() {
  1525.         public void onClick(View v) {
  1526.           showDialog(DIALOG_SELECT_PRESET_LIST);
  1527.         }
  1528.    };
  1529.    private View.OnLongClickListener mPresetListButtonOnLongClickListener =
  1530.       new View.OnLongClickListener() {
  1531.         public boolean onLongClick(View view) {
  1532.           showDialog(DIALOG_PRESETS_LIST);
  1533.           return true;
  1534.         }
  1535.    };
  1536.  
  1537.    private View.OnClickListener mPresetsPageClickListener =
  1538.       new View.OnClickListener() {
  1539.         public void onClick(View v) {
  1540.           mPresetPageNumber++;
  1541.           setupPresetLayout();
  1542.       }
  1543.    };
  1544.  
  1545.    private View.OnClickListener mPresetButtonClickListener =
  1546.       new View.OnClickListener() {
  1547.          public void onClick(View view) {
  1548.            PresetStation station = (PresetStation)view.getTag();
  1549.            if (station != null) {
  1550.               Log.d(LOGTAG, "station - " + station.getName() + " ("
  1551.                     + station.getFrequency() + ")");
  1552.               tuneRadio(station.getFrequency());
  1553.               view.startAnimation(mAnimation);
  1554.            }
  1555.       }
  1556.    };
  1557.  
  1558.    private View.OnLongClickListener mPresetButtonOnLongClickListener =
  1559.       new View.OnLongClickListener() {
  1560.         public boolean onLongClick(View view) {
  1561.            PresetStation station = (PresetStation)view.getTag();
  1562.            mPresetButtonStation = station;
  1563.            if (station != null) {
  1564.                showDialog(DIALOG_PRESET_OPTIONS);
  1565.            }else {
  1566.                addToPresets();
  1567.                view.startAnimation(mAnimation);
  1568.            }
  1569.          return true;
  1570.       }
  1571.    };
  1572.  
  1573.    FrequencyPickerDialog.OnFrequencySetListener mFrequencyChangeListener
  1574.       = new FrequencyPickerDialog.OnFrequencySetListener() {
  1575.         public void onFrequencySet(FrequencyPicker view, int frequency) {
  1576.            Log.d(LOGTAG, "mFrequencyChangeListener: onFrequencyChanged to: " +
  1577.                    frequency);
  1578.            tuneRadio(frequency);
  1579.         }
  1580.    };
  1581.  
  1582.     private View.OnClickListener mSpeakerClickListener =
  1583.         new View.OnClickListener() {
  1584.           @Override
  1585.           public void onClick(View v) {
  1586.              // TODO Auto-generated method stub
  1587.              mSpeakerButton.setClickable(false);
  1588.              mSpeakerButton.setOnClickListener(null);
  1589.              mHandler.removeCallbacks(mEnableRadioTask);
  1590.              mHandler.postDelayed(mEnableSpeakerTask, 0);
  1591.           }
  1592.     };
  1593.  
  1594.    private Runnable mEnableSpeakerTask = new Runnable() {
  1595.      public void run() {
  1596.        enableSpeaker();
  1597.        mSpeakerButton.setClickable(true);
  1598.        mSpeakerButton.setOnClickListener(mSpeakerClickListener);
  1599.      }
  1600.    };
  1601.  
  1602.    private View.OnClickListener mMuteModeClickListener =
  1603.       new View.OnClickListener() {
  1604.         public void onClick(View v) {
  1605.            boolean bStatus = false;
  1606.            if (mService != null) {
  1607.               try {
  1608.                if (true == isMuted()) {
  1609.                    bStatus = mService.unMute();
  1610.                }else {
  1611.                    bStatus = mService.mute();
  1612.                }
  1613.                if (bStatus) {
  1614.                    setMuteModeButtonImage(true);
  1615.                    v.startAnimation(mAnimation);
  1616.                }else {
  1617.                    mCommandFailed = CMD_MUTE;
  1618.                    if(isCallActive()) {
  1619.                       showDialog(DIALOG_CMD_FAILED_CALL_ON);
  1620.                    }else {
  1621.                       showDialog(DIALOG_CMD_FAILED);
  1622.                    }
  1623.                }
  1624.               }catch (RemoteException e) {
  1625.                 e.printStackTrace();
  1626.               }
  1627.            }
  1628.       }
  1629.    };
  1630.  
  1631.    private View.OnClickListener mRecordButtonListener =
  1632.       new View.OnClickListener() {
  1633.         public void onClick(View v) {
  1634.             if (isRecording()) {
  1635.                stopRecording();
  1636.             }else if(!isAnalogModeEnabled()) {
  1637.                startRecording();
  1638.             }
  1639.             invalidateOptionsMenu();
  1640.         }
  1641.    };
  1642.    private Handler mEnableRadioHandler = new Handler();
  1643.    private Handler mDisableRadioHandler = new Handler();
  1644.    private Runnable mEnableRadioTask = new Runnable() {
  1645.     public void run() {
  1646.        enableRadio();
  1647.        mOnOffButton.setEnabled(true);
  1648.        mOnOffButton.setClickable(true);
  1649.        mOnOffButton.setOnClickListener(mTurnOnOffClickListener);
  1650.     }
  1651.   };
  1652.  
  1653.   private Runnable mDisableRadioTask = new Runnable() {
  1654.     public void run() {
  1655.        disableRadio();
  1656.        mOnOffButton.setEnabled(true);
  1657.        mOnOffButton.setClickable(true);
  1658.        mOnOffButton.setOnClickListener(mTurnOnOffClickListener);
  1659.     }
  1660.   };
  1661.   private View.OnClickListener mTurnOnOffClickListener =
  1662.       new View.OnClickListener() {
  1663.         public void onClick(View v) {
  1664.            mOnOffButton.setEnabled(false);
  1665.            mOnOffButton.setClickable(false);
  1666.            mOnOffButton.setOnClickListener(null);
  1667.            if (isFmOn()) {
  1668.               mEnableRadioHandler.removeCallbacks(mEnableRadioTask);
  1669.               mDisableRadioHandler.removeCallbacks(mDisableRadioTask);
  1670.               mDisableRadioHandler.postDelayed(mDisableRadioTask, 0);
  1671.            }else {
  1672.               mDisableRadioHandler.removeCallbacks(mDisableRadioTask);
  1673.               mEnableRadioHandler.removeCallbacks(mEnableRadioTask);
  1674.               mEnableRadioHandler.postDelayed(mEnableRadioTask, 0);
  1675.            }
  1676.            cleanupTimeoutHandler();
  1677.       }
  1678.    };
  1679.  
  1680.    private void setTurnOnOffButtonImage() {
  1681.       if (isFmOn() == true) {
  1682.          mOnOffButton.setEnabled(true);
  1683.       }else {
  1684.          mOnOffButton.setEnabled(false);
  1685.       }
  1686.    }
  1687.  
  1688.    private void setMuteModeButtonImage(boolean notify) {
  1689.       String fmMutedString;
  1690.       if (isMuted() == true) {
  1691.          mMuteButton.setImageResource(R.drawable.ic_silent_mode);
  1692.          fmMutedString = "FM Radio Muted";
  1693.       }else {
  1694.          /* Find a icon for Stations */
  1695.          mMuteButton.setImageResource(R.drawable.ic_silent_mode_off);
  1696.          fmMutedString = "FM Radio Playing";
  1697.       }
  1698.       if (notify) {
  1699.          //Toast.makeText(this, fmMutedString, Toast.LENGTH_SHORT).show();
  1700.          Log.d(LOGTAG, fmMutedString);
  1701.       }
  1702.    }
  1703.  
  1704.    private void enableRadio() {
  1705.       mIsScaning = false;
  1706.       mIsSeeking = false;
  1707.       mIsSearching = false;
  1708.       boolean bStatus = false;
  1709.       if (mService != null) {
  1710.           try {
  1711.             if(mService.isSSRInProgress()) {
  1712.                Log.e(LOGTAG, "SSR In Progress, looping");
  1713.                while(mService.isSSRInProgress()) {
  1714.                   try
  1715.                   {
  1716.                      Thread.sleep(500);
  1717.                   } catch (InterruptedException e)
  1718.                   {
  1719.                      break;
  1720.                   }
  1721.                }
  1722.                Log.e(LOGTAG, "SSR done, continuing");
  1723.             }
  1724.  
  1725.             if((false == mService.isFmOn()) && isAntennaAvailable()) {
  1726.                 bStatus = mService.fmOn();
  1727.                 if(bStatus) {
  1728.                    tuneRadio(FmSharedPreferences.getTunedFrequency());
  1729.                    enableRadioOnOffUI();
  1730.                 }else {
  1731.                    Log.e(LOGTAG, "mService.fmOn failed");
  1732.                    mCommandFailed = CMD_FMON;
  1733.                    if(isCallActive()) {
  1734.                       enableRadioOnOffUI();
  1735.                       showDialog(DIALOG_CMD_FAILED_CALL_ON);
  1736.                    }else {
  1737.                       showDialog(DIALOG_CMD_FAILED);
  1738.                    }
  1739.                 }
  1740.             }else {
  1741.                 enableRadioOnOffUI();
  1742.             }
  1743.          }catch (RemoteException e) {
  1744.             e.printStackTrace();
  1745.          }
  1746.       }
  1747.    }
  1748.  
  1749.    private void disableRadio() {
  1750.       boolean bStatus = false;
  1751.       boolean bSpeakerPhoneOn = isSpeakerEnabled();
  1752.       cancelSearch();
  1753.       endSleepTimer();
  1754.       if(mRecording) {
  1755.          //Stop if there is an ongoing Record
  1756.          stopRecording();
  1757.       }
  1758.       if(mService != null) {
  1759.          try {
  1760.             if(bSpeakerPhoneOn) {
  1761.                mService.enableSpeaker(false);
  1762.             }
  1763.             bStatus = mService.fmOff();
  1764.             enableRadioOnOffUI();
  1765.             if (bStatus == false) {
  1766.                 mCommandFailed = CMD_FMOFF;
  1767.                 Log.e(LOGTAG, " mService.fmOff failed");
  1768.             }
  1769.          }catch (RemoteException e) {
  1770.             e.printStackTrace();
  1771.          }
  1772.       }
  1773.    }
  1774.  
  1775.    private void resetRadio() {
  1776.       boolean bSpeakerPhoneOn = isSpeakerEnabled();
  1777.       resetSearch();
  1778.       endSleepTimer();
  1779.       if (mRecording) {
  1780.          //Stop if there is an ongoing Record
  1781.          stopRecording();
  1782.       }
  1783.       if (mService != null) {
  1784.          try {
  1785.             mService.fmRadioReset();
  1786.             enableRadioOnOffUI(false);
  1787.  
  1788.             Log.e(LOGTAG, "Done with reset, restarting FM");
  1789.             /* Start Turn ON sequence again */
  1790.             mOnOffButton.setEnabled(false);
  1791.             mOnOffButton.setClickable(false);
  1792.             mOnOffButton.setOnClickListener(null);
  1793.  
  1794.             mDisableRadioHandler.removeCallbacks(mDisableRadioTask);
  1795.             mEnableRadioHandler.removeCallbacks(mEnableRadioTask);
  1796.             mEnableRadioHandler.postDelayed(mEnableRadioTask, 0);
  1797.  
  1798.             cleanupTimeoutHandler();
  1799.             Log.e(LOGTAG, "Done with restart");
  1800.          }catch (RemoteException e) {
  1801.             e.printStackTrace();
  1802.          }
  1803.       }
  1804.    }
  1805.    public void clearStationList() {
  1806.       SharedPreferences sp = getSharedPreferences(SCAN_STATION_PREFS_NAME, 0);
  1807.       SharedPreferences.Editor editor = sp.edit();
  1808.       editor.clear();
  1809.       editor.commit();
  1810.    }
  1811.    public boolean fmConfigure() {
  1812.       boolean bStatus = true;
  1813.       if(mService != null) {
  1814.          try {
  1815.             bStatus = mService.fmReconfigure();
  1816.             if (bStatus == false) {
  1817.                mCommandFailed = CMD_FMCONFIGURE;
  1818.                Log.e(LOGTAG, "mService.fmReconfigure failed");
  1819.             }else {
  1820.             }
  1821.          }catch (RemoteException e) {
  1822.             e.printStackTrace();
  1823.          }
  1824.       }
  1825.       return bStatus;
  1826.    }
  1827.    public void fmAutoAFSwitch() {
  1828.       boolean bStatus = false;
  1829.       if (mService != null) {
  1830.          try {
  1831.             bStatus = mService.enableAutoAF(FmSharedPreferences.getAutoAFSwitch());
  1832.             if (bStatus == false) {
  1833.                mCommandFailed = CMD_SET_AUTOAF;
  1834.                Log.e(LOGTAG, " mService.enableAutoAF failed");
  1835.             }
  1836.          }catch (RemoteException e) {
  1837.             e.printStackTrace();
  1838.          }
  1839.       }
  1840.    }
  1841.  
  1842.    public void fmAudioOutputMode() {
  1843.       boolean bStatus = false;
  1844.       if (mService != null) {
  1845.          try {
  1846.             bStatus = mService.enableStereo(FmSharedPreferences.getAudioOutputMode());
  1847.             if (bStatus == false) {
  1848.                mCommandFailed = CMD_SET_AUDIO_MODE;
  1849.                Log.e(LOGTAG, "mService.enableStereo failed");
  1850.             }
  1851.          }catch (RemoteException e) {
  1852.             e.printStackTrace();
  1853.          }
  1854.       }
  1855.    }
  1856.  
  1857.    private void startRecording() {
  1858.       if(mService != null) {
  1859.          try {
  1860.               mService.startRecording();
  1861.          } catch (RemoteException e) {
  1862.               e.printStackTrace();
  1863.          }
  1864.       }
  1865.    }
  1866.  
  1867.    private void setRecordingStopImage() {
  1868.        if(null != mRecordingMsgTV) {
  1869.           mRecordingMsgTV.setCompoundDrawablesWithIntrinsicBounds
  1870.                            (R.drawable.recorder_stop, 0, 0, 0);
  1871.        }
  1872.    }
  1873.  
  1874.    private void setRecordingStartImage() {
  1875.        if(null != mRecordingMsgTV) {
  1876.           mRecordingMsgTV.setCompoundDrawablesWithIntrinsicBounds
  1877.                            (R.drawable.recorder_start, 0, 0, 0);
  1878.        }
  1879.    }
  1880.  
  1881.    private void startRecordingTimer() {
  1882.       mRecording = true;
  1883.       int durationInMins = FmSharedPreferences.getRecordDuration();
  1884.       Log.e(LOGTAG, " Fected duration:" + durationInMins );
  1885.       initiateRecordDurationTimer( durationInMins );
  1886.       setRecordingStopImage();
  1887.       invalidateOptionsMenu();
  1888.    }
  1889.  
  1890.    private void stopRecording() {
  1891.        mRecording = false;
  1892.        DebugToasts("Stopped Recording", Toast.LENGTH_SHORT);
  1893.        if(null != mRecordUpdateHandlerThread) {
  1894.           mRecordUpdateHandlerThread.interrupt();
  1895.        }
  1896.        if(null != mRecordingMsgTV) {
  1897.           mRecordingMsgTV.setText("");
  1898.           setRecordingStartImage();
  1899.        }
  1900.        if (mService != null) {
  1901.            try {
  1902.               mService.stopRecording();
  1903.            }catch (RemoteException e) {
  1904.               e.printStackTrace();
  1905.            }
  1906.         }
  1907.         invalidateOptionsMenu();
  1908.    }
  1909.  
  1910.    private boolean isRecording() {
  1911.       mRecording = false;
  1912.       if (mService != null) {
  1913.          try {
  1914.              mRecording = mService.isFmRecordingOn();
  1915.          }catch (RemoteException e) {
  1916.              e.printStackTrace();
  1917.          }
  1918.       }
  1919.       return(mRecording);
  1920.    }
  1921.  
  1922.    private boolean isSpeakerEnabled() {
  1923.       boolean speakerEnabled = false;
  1924.       if (mService != null) {
  1925.          try {
  1926.              speakerEnabled = mService.isSpeakerEnabled();
  1927.          }catch (RemoteException e) {
  1928.              e.printStackTrace();
  1929.          }
  1930.       }
  1931.       return(speakerEnabled);
  1932.    }
  1933.  
  1934.    private boolean stationExists(PresetStation station ){
  1935.        boolean exists = FmSharedPreferences.sameStationExists(station);
  1936.        if(exists){
  1937.            Toast t = Toast.makeText(this, getString(R.string.station_exists), Toast.LENGTH_SHORT);
  1938.            t.show();
  1939.        }
  1940.        return exists;
  1941.    }
  1942.  
  1943.    private void addToPresets() {
  1944.       int currentList = FmSharedPreferences.getCurrentListIndex();
  1945.       PresetStation selectedStation = getCurrentTunedStation();
  1946.       if(!stationExists(selectedStation)) {
  1947.          FmSharedPreferences.addStation(selectedStation.getName(), selectedStation
  1948.                         .getFrequency(), currentList);
  1949.          setupPresetLayout();
  1950.       }
  1951.    }
  1952.  
  1953.    private void enableRadioOnOffUI() {
  1954.       boolean bEnable = isFmOn();
  1955.       /* Disable if no antenna/headset is available */
  1956.       if (!isAntennaAvailable()) {
  1957.           bEnable = false;
  1958.       }
  1959.       enableRadioOnOffUI(bEnable);
  1960.    }
  1961.  
  1962.    private void enableRadioOnOffUI(boolean bEnable) {
  1963.       if (mMuteButton != null) {
  1964.           mMuteButton.setEnabled(bEnable);
  1965.           setMuteModeButtonImage(false);
  1966.       }
  1967.       if (bEnable) {
  1968.          if (mRadioTextScroller != null) {
  1969.              mRadioTextScroller.startScroll();
  1970.          }
  1971.          if (mERadioTextScroller != null) {
  1972.              mERadioTextScroller.startScroll();
  1973.          }
  1974.          if (mTuneStationFrequencyTV != null) {
  1975.             mTuneStationFrequencyTV.setOnLongClickListener(mFrequencyViewClickListener);
  1976.          }
  1977.          invalidateOptionsMenu();
  1978.          if ((mRecordingMsgTV != null) && !isRecording()) {
  1979.              mRecordingMsgTV.setText("");
  1980.          }
  1981.          if(isRecording()) {
  1982.             setRecordingStopImage();
  1983.          }else {
  1984.             setRecordingStartImage();
  1985.          }
  1986.          for (int nButton = 0; nButton < MAX_PRESETS_PER_PAGE; nButton++) {
  1987.              if (mPresetButtons[nButton] != null) {
  1988.                   mPresetButtons[nButton].setTextColor(Color.WHITE);
  1989.              }
  1990.         }
  1991.       }else {
  1992.          if (mRadioTextScroller != null) {
  1993.              mRadioTextScroller.stopScroll();
  1994.          }
  1995.          if (mERadioTextScroller != null) {
  1996.              mERadioTextScroller.stopScroll();
  1997.          }
  1998.          for (int nButton = 0; nButton < MAX_PRESETS_PER_PAGE; nButton++) {
  1999.              if (mPresetButtons[nButton] != null) {
  2000.                   mPresetButtons[nButton].setTextColor(Color.BLACK);
  2001.              }
  2002.          }
  2003.       }
  2004.       if (mForwardButton != null) {
  2005.           mForwardButton.setVisibility(((bEnable == true) ? View.VISIBLE
  2006.                                         : View.INVISIBLE));
  2007.       }
  2008.       if (mBackButton != null) {
  2009.          mBackButton.setVisibility(((bEnable == true) ? View.VISIBLE
  2010.                                         : View.INVISIBLE));
  2011.       }
  2012.       if (mTuneStationFrequencyTV != null) {
  2013.          mTuneStationFrequencyTV.setVisibility(((bEnable == true) ? View.VISIBLE
  2014.                                              : View.INVISIBLE));
  2015.       }
  2016.       if (mPicker != null) {
  2017.           mPicker.setVisibility(
  2018.                   bEnable ?

View.VISIBLE : View.INVISIBLE ); } if (mStationCallSignTV != null) { mStationCallSignTV.setVisibility(((bEnable == true) ? View.VISIBLE : View.INVISIBLE)); } if (mProgramTypeTV != null) { mProgramTypeTV.setVisibility(((bEnable == true) ?

View.VISIBLE : View.INVISIBLE)); } if (mSleepMsgTV != null) { mSleepMsgTV.setVisibility(((bEnable && isSleepTimerActive()) ? View.VISIBLE : View.INVISIBLE)); } if (mRecordingMsgTV != null) { mRecordingMsgTV.setVisibility(((bEnable == true) ? View.VISIBLE : View.INVISIBLE)); } if (mRadioTextTV != null) { mRadioTextTV.setVisibility(((bEnable == true) ? View.VISIBLE : View.INVISIBLE)); } if(mERadioTextTV != null) { mERadioTextTV.setVisibility(((bEnable == true) ?

View.VISIBLE : View.INVISIBLE)); } if (mProgramServiceTV != null) { mProgramServiceTV.setVisibility(((bEnable == true) ? View.VISIBLE : View.INVISIBLE)); } if (!isAntennaAvailable()) { if (mRadioTextTV != null) { mRadioTextTV.setVisibility(View.VISIBLE); mRadioTextTV.setText(getString(R.string.msg_noantenna)); mRadioTextScroller.mOriginalString = getString(R.string.msg_noantenna); } if (mOnOffButton != null) { mOnOffButton.setEnabled(false); } }else if (isCallActive()) { if (mRadioTextTV != null) { mRadioTextTV.setText(""); mRadioTextScroller.mOriginalString = ""; } if (mERadioTextTV != null) { mERadioTextTV.setText(""); mERadioTextScroller.mOriginalString = ""; } if (mOnOffButton != null) { mOnOffButton.setEnabled(false); } }else { if (mRadioTextTV != null) { mRadioTextTV.setText(""); mRadioTextScroller.mOriginalString = ""; } if (mERadioTextTV != null) { mERadioTextTV.setText(""); mERadioTextScroller.mOriginalString = ""; } if (mOnOffButton != null) { mOnOffButton.setEnabled(true); } } if (mStereoTV != null) { mStereoTV.setVisibility(((bEnable == true) ? View.VISIBLE : View.INVISIBLE)); } for (int nButton = 0; nButton < MAX_PRESETS_PER_PAGE; nButton++) { if (mPresetButtons[nButton] != null) { mPresetButtons[nButton].setEnabled(bEnable); } } if (mPresetListButton != null) { mPresetListButton.setEnabled(bEnable); } if (mPresetPageButton != null) { mPresetPageButton.setEnabled(bEnable && (FmSharedPreferences.getListStationCount() >= MAX_PRESETS_PER_PAGE)); } if(mSpeakerButton != null) { mSpeakerButton.setEnabled(bEnable); if (bEnable) { if(isSpeakerEnabled()) { mSpeakerButton.setImageResource(R.drawable.btn_speaker); }else { mSpeakerButton.setImageResource(R.drawable.btn_earphone); } }else{ mSpeakerButton.setImageResource(R.drawable.btn_earphone); } } } private void resetSearchProgress() { Message msg = new Message(); msg.what = END_PROGRESS_DLG; mSearchProgressHandler.sendMessage(msg); } private void updateSearchProgress() { boolean searchActive = isScanActive() || isSeekActive() || isSearchActive(); if (searchActive) { synchronized (this) { if(mProgressDialog == null) { showDialog(DIALOG_PROGRESS_PROGRESS); }else { Message msg = new Message(); msg.what = UPDATE_PROGRESS_DLG; mSearchProgressHandler.sendMessage(msg); } } }else { Message msg = new Message(); msg.what = END_PROGRESS_DLG; mSearchProgressHandler.sendMessage(msg); } } private void setupPresetLayout() { int numStations = FmSharedPreferences.getListStationCount(); int addedStations = 0; /* * Validate mPresetPageNumber (Preset Page Number) */ if (mPresetPageNumber > ((numStations) / MAX_PRESETS_PER_PAGE)) { mPresetPageNumber = 0; } /* * For every station, save the station as a tag and update the display * on the preset Button. */ for (int buttonIndex = 0; (buttonIndex < MAX_PRESETS_PER_PAGE); buttonIndex++) { if (mPresetButtons[buttonIndex] != null) { mPresetButtons[buttonIndex].setHeight(-1); int stationIdex = (mPresetPageNumber * MAX_PRESETS_PER_PAGE) + buttonIndex; PresetStation station = FmSharedPreferences.getStationInList(stationIdex); String display = ""; if (station != null) { display = station.getName(); if (display.length() > 6) display = display.substring(0,6)+"..."; mPresetButtons[buttonIndex].setEllipsize(TextUtils.TruncateAt.END); mPresetButtons[buttonIndex].setText(display); mPresetButtons[buttonIndex].setTag(station); addedStations++; }else { mPresetButtons[buttonIndex].setText(R.string.add_station); mPresetButtons[buttonIndex].setTag(station); } } } } private void updateStationInfoToUI() { double frequency = mTunedStation.getFrequency() / 1000.0; mTuneStationFrequencyTV.setText("" + frequency + "MHz"); if ((mPicker != null) && mUpdatePickerValue) { mPicker.setValue(((mTunedStation.getFrequency() - mPrefs.getLowerLimit()) / mPrefs.getFrequencyStepSize())); } mStationCallSignTV.setText(mTunedStation.getPIString()); mProgramTypeTV.setText(mTunedStation.getPtyString()); mRadioTextTV.setText(""); mERadioTextTV.setText(""); mRadioTextScroller.mOriginalString = ""; mRadioTextScroller.mStringlength = 0; mRadioTextScroller.mIteration = 0; mERadioTextScroller.mOriginalString = ""; mERadioTextScroller.mStringlength = 0; mERadioTextScroller.mIteration = 0; mProgramServiceTV.setText(""); mStereoTV.setText(""); setupPresetLayout(); } private boolean isFmOn() { boolean bOn = false; if(mService != null) { try { bOn = mService.isFmOn(); }catch (RemoteException e) { e.printStackTrace(); } } return(bOn); } private boolean isAnalogModeEnabled() { boolean aEnabled = false; if (mService != null) { try { aEnabled = mService.isAnalogModeEnabled(); }catch (RemoteException e) { e.printStackTrace(); } } return (aEnabled); } private boolean isMuted() { boolean bMuted = false; if (mService != null) { try { bMuted = mService.isMuted(); }catch (RemoteException e) { e.printStackTrace(); } } return(bMuted); } private boolean isScanActive() { return(mIsScaning); } private boolean isSeekActive() { return(mIsSeeking); } private boolean isSearchActive() { return(mIsSearching); } public PresetStation getCurrentTunedStation() { return mTunedStation; } private void SeekPreviousStation() { Log.d(LOGTAG, "SeekPreviousStation"); if (mService != null) { try { if(!isSeekActive()) { mIsSeeking = mService.seek(false); if (mIsSeeking == false) { mCommandFailed = CMD_SEEK; Log.e(LOGTAG, "mService.seek failed"); showDialog(DIALOG_CMD_FAILED); } } }catch (RemoteException e) { e.printStackTrace(); } } updateSearchProgress(); } private void SeekNextStation() { Log.d(LOGTAG, "SeekNextStation"); if(mService != null) { try { if(!isSeekActive()) { mIsSeeking = mService.seek(true); if (mIsSeeking == false) { mCommandFailed = CMD_SEEK; Log.e(LOGTAG, "mService.seek failed"); showDialog(DIALOG_CMD_FAILED); } } }catch (RemoteException e) { e.printStackTrace(); } } updateSearchProgress(); } /** Scan related */ private void initiateSearch(int pty) { synchronized (this) { mIsScaning = true; if(mService != null) { try { mIsScaning = mService.scan(pty); if (mIsScaning == false) { mCommandFailed = CMD_SCAN; Log.e(LOGTAG, "mService.scan failed"); showDialog(DIALOG_CMD_FAILED); }else { mScanPty = pty; } }catch (RemoteException e) { e.printStackTrace(); } updateSearchProgress(); } } } /** SEEK Station with the matching PI */ private void initiatePISearch(int pi) { Log.d(LOGTAG, "initiatePISearch"); if(mService != null) { try { if(!isSeekActive()) { mIsSeeking = mService.seekPI(pi); if (mIsSeeking == false) { mCommandFailed = CMD_SEEKPI; Log.e(LOGTAG, "mService.seekPI failed"); showDialog(DIALOG_CMD_FAILED); } } }catch (RemoteException e) { e.printStackTrace(); } } updateSearchProgress(); } private void resetSearch() { mIsScaning = false; mIsSeeking = false; mIsSearching = false; resetSearchProgress(); } private void cancelSearch() { synchronized (this) { if (mService != null) { try { if ((mIsScaning == true) || (mIsSeeking == true) || (mIsSearching == true)) { mService.cancelSearch(); mIsScaning = false; mIsSeeking = false; mIsSearching=false; } }catch (RemoteException e) { e.printStackTrace(); } } } updateSearchProgress(); invalidateOptionsMenu(); } /** get Strongest Stations */ private void initiateSearchList() { synchronized (this) { mIsSearching = false; if (mService != null) { try { mIsSearching = mService.searchStrongStationList(NUM_AUTO_PRESETS_SEARCH); if (mIsSearching == false) { mCommandFailed = CMD_SEARCHLIST; Log.e(LOGTAG, "mService.searchStrongStationList failed"); showDialog(DIALOG_CMD_FAILED); } }catch (RemoteException e) { e.printStackTrace(); } updateSearchProgress(); } } } private static final int UPDATE_PROGRESS_DLG = 1; private static final int END_PROGRESS_DLG = 2; private static final int TIMEOUT_PROGRESS_DLG = 3; private static final int SHOWBUSY_TIMEOUT = 300000; private Handler mSearchProgressHandler = new Handler() { public void handleMessage(Message msg) { if (msg.what == UPDATE_PROGRESS_DLG) { if(mProgressDialog != null) { double frequency = mTunedStation.getFrequency() / 1000.0; String titleStr = getString(R.string.msg_search_title, ("" + frequency)); mProgressDialog.setTitle(titleStr); } }else if (msg.what == END_PROGRESS_DLG) { mSearchProgressHandler.removeMessages(END_PROGRESS_DLG); mSearchProgressHandler.removeMessages(UPDATE_PROGRESS_DLG); mSearchProgressHandler.removeMessages(TIMEOUT_PROGRESS_DLG); removeDialog(DIALOG_PROGRESS_PROGRESS); mProgressDialog = null; }else if (msg.what == TIMEOUT_PROGRESS_DLG) { cancelSearch(); } } }; /** Sleep Handling: After the timer expires, the app needs to shut down */ private static final int SLEEPTIMER_EXPIRED = 0x1001; private static final int SLEEPTIMER_UPDATE = 0x1002; private Thread mSleepUpdateHandlerThread = null; /* * Phone time when the App has to be shut down, calculated based on what the * user configured */ private static long mSleepAtPhoneTime = 0; private void initiateSleepTimer(long seconds) { mSleepAtPhoneTime = (SystemClock.elapsedRealtime()) + (seconds * 1000); Log.d(LOGTAG, "Sleep in seconds: " + seconds); initiateSleepThread(); } private void initiateSleepThread() { if (mSleepUpdateHandlerThread == null) { mSleepUpdateHandlerThread = new Thread(null, doSleepProcessing, "SleepUpdateThread"); } /* Launch he dummy thread to simulate the transfer progress */ Log.d(LOGTAG, "Thread State: " + mSleepUpdateHandlerThread.getState()); if (mSleepUpdateHandlerThread.getState() == Thread.State.TERMINATED) { mSleepUpdateHandlerThread = new Thread(null, doSleepProcessing, "SleepUpdateThread"); } /* If the thread state is "new" then the thread has not yet started */ if(mSleepUpdateHandlerThread.getState() != Thread.State.TERMINATED && isFmOn()) { try { if((mService != null) && !mService.isSleepTimerActive()) { long timeNow = ((SystemClock.elapsedRealtime())); if(timeNow < mSleepAtPhoneTime) { mService.delayedStop((mSleepAtPhoneTime - timeNow), FMRadioService.STOP_SERVICE); } } mSleepUpdateHandlerThread.start(); }catch(Exception e) { e.printStackTrace(); } } } private void endSleepTimer() { mSleepAtPhoneTime = 0; try { if(mService != null) { mService.cancelDelayedStop(FMRadioService.STOP_SERVICE); } }catch(RemoteException e) { e.printStackTrace(); } if(null != mSleepUpdateHandlerThread) { mSleepUpdateHandlerThread.interrupt(); } if(null != mSleepMsgTV) { mSleepMsgTV.setVisibility(View.INVISIBLE); } } private boolean hasSleepTimerExpired() { boolean expired = true; if (isSleepTimerActive()) { long timeNow = ((SystemClock.elapsedRealtime())); if (timeNow < mSleepAtPhoneTime) { expired = false; } } return expired; } private boolean isSleepTimerActive() { boolean active = false; try { if((mService != null) && (mService.isSleepTimerActive()) && (mSleepAtPhoneTime > 0)) { active = true; Log.d(LOGTAG, "Sleeptimer is active"); }else { } }catch(RemoteException e) { e.printStackTrace(); } return active; } private void updateExpiredSleepTime() { int vis = View.INVISIBLE; if (isSleepTimerActive()) { long timeNow = ((SystemClock.elapsedRealtime())); if (mSleepAtPhoneTime >= timeNow) { long seconds = (mSleepAtPhoneTime - timeNow) / 1000; String sleepMsg = makeTimeString(seconds); mSleepMsgTV.setText(sleepMsg); if (seconds < SLEEP_TOGGLE_SECONDS) { int nowVis = mSleepMsgTV.getVisibility(); vis = (nowVis == View.INVISIBLE) ?

View.VISIBLE : View.INVISIBLE; }else { vis = View.VISIBLE; } }else { /* Clean up timer */ mSleepAtPhoneTime = 0; } } mSleepMsgTV.setVisibility(vis); } private Handler mUIUpdateHandlerHandler = new Handler() { public void handleMessage(Message msg) { switch (msg.what) { case SLEEPTIMER_EXPIRED: { mSleepAtPhoneTime = 0; DebugToasts("Turning Off FM Radio", Toast.LENGTH_SHORT); disableRadio(); return; } case SLEEPTIMER_UPDATE: { updateExpiredSleepTime(); break; } case RECORDTIMER_EXPIRED: { Log.d(LOGTAG, "mUIUpdateHandlerHandler - RECORDTIMER_EXPIRED"); //Clear the Recorder text mRecordingMsgTV.setText(""); if (mRecording != false) { DebugToasts("Stop Recording", Toast.LENGTH_SHORT); stopRecording(); } return; } case RECORDTIMER_UPDATE: { Log.d(LOGTAG, "mUIUpdateHandlerHandler - RECORDTIMER_UPDATE"); updateExpiredRecordTime(); break; } default: break; } super.handleMessage(msg); } }; /* Thread processing */ private Runnable doSleepProcessing = new Runnable() { public void run() { boolean sleepTimerExpired = hasSleepTimerExpired(); while ((sleepTimerExpired == false) && (!Thread.currentThread().isInterrupted())) { try { Thread.sleep(500); Message statusUpdate = new Message(); statusUpdate.what = SLEEPTIMER_UPDATE; Log.d(LOGTAG, "SLEEP TIMER UPDATE"); mUIUpdateHandlerHandler.sendMessage(statusUpdate); sleepTimerExpired = hasSleepTimerExpired(); }catch (Exception ex) { Log.d( LOGTAG, "RunningThread InterruptedException"); break; } } if(true == sleepTimerExpired) { Message finished = new Message(); finished.what = SLEEPTIMER_EXPIRED; mUIUpdateHandlerHandler.sendMessage(finished); } } }; private static StringBuilder sFormatBuilder = new StringBuilder(); private static Formatter sFormatter = new Formatter(sFormatBuilder, Locale .getDefault()); private static final Object[] sTimeArgs = new Object[5]; private String makeTimeString(long secs) { String durationformat = getString(R.string.durationformat); /* * Provide multiple arguments so the format can be changed easily by * modifying the xml. */ sFormatBuilder.setLength(0); final Object[] timeArgs = sTimeArgs; timeArgs[0] = secs / 3600; timeArgs[1] = secs / 60; timeArgs[2] = (secs / 60) % 60; timeArgs[3] = secs; timeArgs[4] = secs % 60; return sFormatter.format(durationformat, timeArgs).toString(); } private void tuneRadio(int frequency){ /* Issue the tune command only if tuneCommand is already not active */ if((mService != null) && (mCommandActive != CMD_TUNE) && isFmOn()) { boolean bStatus = false; try { bStatus = mService.tune(frequency); if (bStatus) { postTimeoutHandler(CMD_TUNE); }else { if (isFmOn()) { mCommandFailed = CMD_TUNE; Log.e(LOGTAG, "mService.tune failed"); showDialog(DIALOG_CMD_FAILED); } } mTunedStation.setName(""); mTunedStation.setPI(0); mTunedStation.setPty(0); updateStationInfoToUI(); }catch (RemoteException e) { e.printStackTrace(); } }else { Log.e(LOGTAG, "Delayed Tune handler stopped"); } } /* Start a Command timeout */ private synchronized void postTimeoutHandler(int cmd){ mCommandActive = cmd; mCommandTimeoutHandler.sendEmptyMessageDelayed(MSG_CMD_TIMEOUT, CMD_TIMEOUT_DELAY_MS); } /* Stop the Command timeout */ private synchronized void cleanupTimeoutHandler(){ mCommandActive = CMD_NONE; mCommandTimeoutHandler.removeMessages(MSG_CMD_TIMEOUT); } /* Command timeout Handler Routine to handle the Command timeouts for FM operations that return asynchronous event callbacks */ private Handler mCommandTimeoutHandler = new Handler() { @Override public void handleMessage(Message msg) { switch (msg.what) { case MSG_CMD_TIMEOUT: { if (mCommandActive > 0) { Log.d(LOGTAG, "mCommandTimeoutHandler: Cmd failed: " + mCommandActive); mCommandTimeoutHandler.removeMessages(MSG_CMD_TIMEOUT); showDialog(DIALOG_CMD_TIMEOUT); return; } break; }//case MSG_CMD_TIMEOUT }//switch }//handleMessage }; @Override public boolean onKeyDown(int keyCode, KeyEvent event) { Log.d(LOGTAG, "KEY event received" + keyCode); switch (keyCode) { case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE: case 126: //KeyEvent.KEYCODE_MEDIA_PLAY: case 127: //KeyEvent.KEYCODE_MEDIA_PAUSE: case KeyEvent.KEYCODE_MEDIA_FAST_FORWARD: case KeyEvent.KEYCODE_MEDIA_NEXT: case KeyEvent.KEYCODE_MEDIA_PREVIOUS: case KeyEvent.KEYCODE_MEDIA_REWIND: case KeyEvent.KEYCODE_MEDIA_STOP: return true; } return super.onKeyDown(keyCode, event); } private void resetFMStationInfoUI() { mTunedStation.setFrequency(FmSharedPreferences.getTunedFrequency()); mTunedStation.setName(""); mTunedStation.setPI(0); mTunedStation.setRDSSupported(false); mTunedStation.setPty(0); mRadioTextTV.setText(""); mERadioTextTV.setText(""); mRadioTextScroller.mOriginalString = ""; mProgramServiceTV.setText(""); mRadioTextScroller.stopScroll(); mERadioTextScroller.mOriginalString = ""; mERadioTextScroller.stopScroll(); mUpdatePickerValue = true; updateStationInfoToUI(); } Runnable mRadioEnabled = new Runnable() { public void run() { /* Update UI to FM On State */ enableRadioOnOffUI(true); /* Tune to the last tuned frequency */ mUpdatePickerValue = true; tuneRadio(FmSharedPreferences.getTunedFrequency()); } }; Runnable mRadioDisabled = new Runnable() { public void run() { /* Update UI to FM Off State */ cleanupTimeoutHandler(); endSleepTimer(); stopRecording(); cancelSearch(); enableRadioOnOffUI(false); } }; Runnable mRadioReset = new Runnable() { public void run() { /* Update UI to FM Reset (Off) State */ resetRadio(); } }; Runnable mUpdateStationInfo = new Runnable() { public void run() { cleanupTimeoutHandler(); PresetStation station = new PresetStation("", FmSharedPreferences.getTunedFrequency()); if (station != null) { mTunedStation.Copy(station); } updateSearchProgress(); resetFMStationInfoUI(); } }; Runnable mSearchComplete = new Runnable() { public void run() { Log.d(LOGTAG, "mSearchComplete: "); mScanPty=0; mScanPtyIndex = 0; mIsScaning = false; mIsSeeking = false; mIsSearching = false; updateSearchProgress(); resetFMStationInfoUI(); invalidateOptionsMenu(); } }; Runnable mOnMute = new Runnable() { public void run() { setMuteModeButtonImage(true); } }; Runnable mOnStereo = new Runnable() { public void run() { if (FMRADIO_UI_STATION_AUDIO_STEREO == mStereo) { if ((Locale.getDefault().toString().equals("zh_HK"))) mStereoTV.setText("立體聲"); else mStereoTV.setText(R.string.audio_type_stereo); } else if (FMRADIO_UI_STATION_AUDIO_MONO == mStereo) { if ((Locale.getDefault().toString().equals("zh_HK"))) mStereoTV.setText("單聲道"); else mStereoTV.setText(R.string.audio_type_mono); }else { mStereoTV.setText(""); } FmSharedPreferences.setLastAudioMode(mStereo); } }; Runnable mUpdateRadioText = new Runnable() { public void run() { String str = ""; if ((mService != null) && isFmOn()) { try { /* Get Radio Text and update the display */ str = mService.getRadioText(); /* Update only if all the characters are printable */ if (TextUtils.isPrintableAsciiOnly(str)) { Log.d(LOGTAG, "mUpdateRadioText: Updatable string: [" + str + "]"); mRadioTextTV.setText(str); mRadioTextScroller.mOriginalString = str; }else if(TextUtils.isEmpty(str)) { /* Rest the string to empty*/ mRadioTextTV.setText(""); mRadioTextScroller.mOriginalString = ""; }else { //Log.d(LOGTAG, "mUpdateRadioText: Leaving old string " + mRadioTextTV.getText()); } /* Get PTY and PI and update the display */ int tempInt = mService.getProgramType(); /* Save PTY */ mTunedStation.setPty(tempInt); mProgramTypeTV.setText(PresetStation.parsePTY(tempInt)); tempInt = mService.getProgramID(); mStationCallSignTV.setText(PresetStation.parsePI(tempInt)); if (tempInt != 0) { mTunedStation.setPI(tempInt); } /* For non-Empty, non-Printable string, just leave the existing old string */ mRadioTextScroller.startScroll(); }catch (RemoteException e) { e.printStackTrace(); } } } }; Runnable mRadioChangeFrequency = new Runnable(){ public void run() { mUpdatePickerValue = false; tuneRadio(mFrequency); } }; Runnable mUpdateExtenRadioText = new Runnable() { public void run() { String str = ""; if ((mService != null) && isFmOn()) { try { /* Get Extended Radio Text and update the display */ str = mService.getExtenRadioText(); if (TextUtils.isEmpty(str)) { mERadioTextTV.setText(""); mERadioTextScroller.mOriginalString = ""; }else { mERadioTextTV.setText(str); mERadioTextScroller.mOriginalString = str; } mERadioTextScroller.startScroll(); }catch (RemoteException e) { e.printStackTrace(); } } } }; /* Create runnable for posting */ Runnable mUpdateProgramService = new Runnable() { public void run() { String str = ""; if (mService != null) { try { /* Get the Station PS and update the display */ str = mService.getProgramService(); /* Update only if all the characters are printable */ //if(isStringPrintable(str)) if (TextUtils.isPrintableAsciiOnly(str)) { Log.d(LOGTAG, "mUpdateProgramService: Updatable string: [" + str + "]"); mProgramServiceTV.setText(str); }else if (TextUtils.isEmpty(str)) { /* Rest the string to empty*/ mProgramServiceTV.setText(""); }else { /* For non-Empty, non-Printable string, just leave the existing old string */ } /* Get PTY and PI and update the display */ int tempInt = mService.getProgramType(); /* Save PTY */ mTunedStation.setPty(tempInt); mProgramTypeTV.setText(PresetStation.parsePTY(tempInt)); tempInt =mService.getProgramID(); /* Save the program ID */ if (tempInt != 0) { mTunedStation.setPI(tempInt); } mStationCallSignTV.setText(PresetStation.parsePI(tempInt)); }catch (RemoteException e) { e.printStackTrace(); } } } }; private void DebugToasts(String str, int duration) { //Toast.makeText(this, str, duration).show(); Log.d(LOGTAG, "Debug:" + str); } /** * This Handler will scroll the text view. * On startScroll, the scrolling starts after SCROLLER_START_DELAY_MS * The Text View is scrolled left one character after every * SCROLLER_UPDATE_DELAY_MS * When the entire text is scrolled, the scrolling will restart * after SCROLLER_RESTART_DELAY_MS */ private final class ScrollerText extends Handler { private static final byte SCROLLER_STOPPED = 0x51; private static final byte SCROLLER_STARTING = 0x52; private static final byte SCROLLER_RUNNING = 0x53; private static final int SCROLLER_MSG_START = 0xF1; private static final int SCROLLER_MSG_TICK = 0xF2; private static final int SCROLLER_MSG_RESTART = 0xF3; private static final int SCROLLER_START_DELAY_MS = 1000; private static final int SCROLLER_RESTART_DELAY_MS = 3000; private static final int SCROLLER_UPDATE_DELAY_MS = 200; private final WeakReference<TextView> mView; private byte mStatus = SCROLLER_STOPPED; String mOriginalString; int mStringlength = 0; int mIteration = 0; ScrollerText(TextView v) { mView = new WeakReference<TextView>(v); } /** * Scrolling Message Handler */ @Override public void handleMessage(Message msg) { switch (msg.what) { case SCROLLER_MSG_START: mStatus = SCROLLER_RUNNING; updateText(); break; case SCROLLER_MSG_TICK: updateText(); break; case SCROLLER_MSG_RESTART: if (mStatus == SCROLLER_RUNNING) { startScroll(); } break; } } /** * Moves the text left by one character and posts a * delayed message for next update after SCROLLER_UPDATE_DELAY_MS. * If the entire string is scrolled, then it displays the entire string * and waits for SCROLLER_RESTART_DELAY_MS for scrolling restart */ void updateText() { if (mStatus != SCROLLER_RUNNING) { return; } removeMessages(SCROLLER_MSG_TICK); TextView textView = mView.get(); if (textView != null) { mStringlength = mOriginalString.length(); String szStr2 = ""; if (mStringlength > 0) { mIteration++; if (mIteration >= mStringlength) { mIteration = 0; sendEmptyMessageDelayed(SCROLLER_MSG_RESTART, SCROLLER_RESTART_DELAY_MS); }else { sendEmptyMessageDelayed(SCROLLER_MSG_TICK, SCROLLER_UPDATE_DELAY_MS); } if ((mOriginalString !=null) && (mOriginalString.length() >= mIteration)) szStr2 = mOriginalString.substring(mIteration); } textView.setText(szStr2); } } /** * Stops the scrolling * The textView will be set to the original string. */ void stopScroll() { mStatus = SCROLLER_STOPPED; removeMessages(SCROLLER_MSG_TICK); removeMessages(SCROLLER_MSG_RESTART); removeMessages(SCROLLER_MSG_START); resetScroll(); } /** * Resets the scroll to display the original string. */ private void resetScroll() { mIteration = 0; TextView textView = mView.get(); if (textView != null) { textView.setText(mOriginalString); } } /** Starts the Scrolling of the TextView after a * delay of SCROLLER_START_DELAY_MS * Starts only if Length > 0 */ void startScroll() { TextView textView = mView.get(); if (textView != null) { mOriginalString = textView.getText().toString(); mStringlength = mOriginalString.length(); if (mStringlength > 0) { mStatus = SCROLLER_STARTING; sendEmptyMessageDelayed(SCROLLER_MSG_START, SCROLLER_START_DELAY_MS); } } } } public IFMRadioService sService = null; private HashMap<Context, ServiceBinder> sConnectionMap = new HashMap<Context, ServiceBinder>(); public boolean bindToService(Context context) { Log.e(LOGTAG, "bindToService: Context"); return bindToService(context, null); } public boolean bindToService(Context context, ServiceConnection callback) { Log.e(LOGTAG, "bindToService: Context with serviceconnection callback"); context.startService(new Intent(context, FMRadioService.class)); ServiceBinder sb = new ServiceBinder(callback); sConnectionMap.put(context, sb); return context.bindService((new Intent()).setClass(context, FMRadioService.class), sb, 0); } public void unbindFromService(Context context) { ServiceBinder sb = (ServiceBinder) sConnectionMap.remove(context); Log.e(LOGTAG, "unbindFromService: Context"); if (sb == null) { Log.e(LOGTAG, "Trying to unbind for unknown Context"); return; } context.unbindService(sb); if (sConnectionMap.isEmpty()) { // presumably there is nobody interested in the service at this point, // so don't hang on to the ServiceConnection sService = null; } } private class ServiceBinder implements ServiceConnection { ServiceConnection mCallback; ServiceBinder(ServiceConnection callback) { mCallback = callback; } public void onServiceConnected(ComponentName className, android.os.IBinder service) { sService = IFMRadioService.Stub.asInterface(service); if (mCallback != null) { Log.e(LOGTAG, "onServiceConnected: mCallback"); mCallback.onServiceConnected(className, service); } } public void onServiceDisconnected(ComponentName className) { if (mCallback != null) { mCallback.onServiceDisconnected(className); } sService = null; mService = null; } } private ServiceConnection osc = new ServiceConnection() { public void onServiceConnected(ComponentName classname, IBinder obj) { mService = IFMRadioService.Stub.asInterface(obj); Log.e(LOGTAG, "ServiceConnection: onServiceConnected: "); if (mService != null) { try { mService.registerCallbacks(mServiceCallbacks); if (SavedDataAndState == null) { enableRadio(); }else if (isFmOn()) { enableRadioOnOffUI(true); }else { enableRadioOnOffUI(false); } }catch (RemoteException e) { e.printStackTrace(); } if (isRecording()) { initiateRecordThread(); } if(isSleepTimerActive()) { initiateSleepThread(); } return; }else { Log.e(LOGTAG, "IFMRadioService onServiceConnected failed"); } if (getIntent().getData() == null) { Intent intent = new Intent(Intent.ACTION_MAIN); intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK); intent.setClass(FMRadio.this, FMRadio.class); startActivity(intent); } finish(); } public void onServiceDisconnected(ComponentName classname) { Log.d(LOGTAG, "Service got disconnected"); unbindFromService(FMRadio.this); mService = null; sService = null; } }; private IFMRadioServiceCallbacks.Stub mServiceCallbacks = new IFMRadioServiceCallbacks.Stub() { public void onEnabled() { Log.d(LOGTAG, "mServiceCallbacks.onEnabled :"); mHandler.post(mRadioEnabled); } public void onDisabled() { Log.d(LOGTAG, "mServiceCallbacks.onDisabled :"); mHandler.post(mRadioDisabled); } public void onRadioReset() { Log.d(LOGTAG, "mServiceCallbacks.onRadioReset :"); mHandler.post(mRadioReset); } public void onTuneStatusChanged() { Log.d(LOGTAG, "mServiceCallbacks.onTuneStatusChanged: "); if (mIsScaning) { Log.d(LOGTAG, "isScanning...................."); SharedPreferences sp = getSharedPreferences(SCAN_STATION_PREFS_NAME, 0); SharedPreferences.Editor editor = sp.edit(); int station_number = sp.getInt(NUM_OF_STATIONS, 0); station_number++; editor.putInt(NUM_OF_STATIONS, station_number); editor.putString(STATION_NAME + station_number, station_number + ""); editor.putInt(STATION_FREQUENCY + station_number, FmSharedPreferences.getTunedFrequency()); editor.commit(); } cleanupTimeoutHandler(); mHandler.post(mUpdateStationInfo); mHandler.post(mOnStereo); } public void onProgramServiceChanged() { Log.d(LOGTAG, "mServiceCallbacks.onProgramServiceChanged :"); mHandler.post(mUpdateProgramService); } public void onRadioTextChanged() { Log.d(LOGTAG, "mServiceCallbacks.onRadioTextChanged :"); mHandler.post(mUpdateRadioText); } public void onExtenRadioTextChanged() { mHandler.post(mUpdateExtenRadioText); } public void onAlternateFrequencyChanged() { Log.d(LOGTAG, "mServiceCallbacks.onAlternateFrequencyChanged :"); } public void onSignalStrengthChanged() { Log.d(LOGTAG, "mServiceCallbacks.onSignalStrengthChanged :"); } public void onSearchComplete() { Log.d(LOGTAG, "mServiceCallbacks.onSearchComplete :"); mScanPty = 0; mScanPtyIndex = 0; mIsScaning = false; mIsSeeking = false; mIsSearching = false; mHandler.post(mSearchComplete); } public void onSearchListComplete() { Log.d(LOGTAG, "mServiceCallbacks.onSearchListComplete :"); } public void onMute(boolean bMuted) { Log.d(LOGTAG, "mServiceCallbacks.onMute :" + bMuted); mHandler.post(mOnMute); } public void onAudioUpdate(boolean bStereo) { if((bStereo) && (FmSharedPreferences.getAudioOutputMode())) { mStereo = FMRADIO_UI_STATION_AUDIO_STEREO; }else { mStereo = FMRADIO_UI_STATION_AUDIO_MONO; } Log.d(LOGTAG, "mServiceCallbacks.onAudioUpdate :" + mStereo); mHandler.post(mOnStereo); } public void onStationRDSSupported(boolean bRDSSupported) { Log.d(LOGTAG, "mServiceCallbacks.onStationRDSSupported :" + bRDSSupported); /* * Depending on the signal strength etc, RDS Lock Sync/Supported may toggle, * Since if a station Supports RDS, it will not change its support intermittently * just save the status and ignore any "unsupported" state. */ if (bRDSSupported) { mTunedStation.setRDSSupported(true); } } public void onRecordingStopped() { Log.d(LOGTAG, "mServiceCallbacks.onRecordingStopped:"); stopRecording(); } public void onRecordingStarted() { Log.d(LOGTAG, "mServiceCallbacks.onRecordingStarted:"); startRecordingTimer(); } }; private void registerFMSettingListner() { if (mFmSettingReceiver == null) { mFmSettingReceiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { Log.d(LOGTAG, "Received intent " + intent); String action = intent.getAction(); Log.d(LOGTAG, " action = " + action); if (action.equals(Settings.ACTION_FM_SETTING)) { int state = intent.getIntExtra("state", 0); Log.d(LOGTAG, "ACTION_FM_SETTING Intent received" + state); switch(state) { case Settings.FM_BAND_CHANGED: fmConfigure(); break; case Settings.FM_CHAN_SPACING_CHANGED: fmConfigure(); break; case Settings.FM_AF_OPTION_CHANGED: fmAutoAFSwitch(); break; case Settings.FM_AUDIO_MODE_CHANGED: fmAudioOutputMode(); break; } } } }; IntentFilter iFilter = new IntentFilter(); iFilter.addAction(Settings.ACTION_FM_SETTING); registerReceiver(mFmSettingReceiver, iFilter); } } private void unRegisterReceiver(BroadcastReceiver myReceiver) { if(myReceiver != null) { unregisterReceiver(myReceiver); myReceiver = null; } } }


3、FMMediaButtonIntentReceiver.java文件就是对接收到的定时广播做出响应 

  1. package com.caf.fmradio;
  2.  
  3. import android.content.Intent;
  4. import android.content.IntentFilter;
  5. import android.app.IntentService;
  6. import android.content.BroadcastReceiver;
  7. import android.content.pm.PackageManager;
  8. import android.content.Context;
  9. import android.content.ComponentName;
  10. import android.media.AudioManager;
  11. import android.util.Log;
  12. import android.view.KeyEvent;
  13. import android.os.Bundle;
  14. import java.lang.Object;
  15.  
  16. public class FMMediaButtonIntentReceiver extends BroadcastReceiver {
  17.  
  18. private static final String TAG = "FMMediaButtonIntentReceiver";
  19. public static final String FM_MEDIA_BUTTON = "com.caf.fmradio.action.MEDIA_BUTTON";
  20. public static final String AUDIO_BECOMING_NOISY = "com.caf.fmradio.action.AUDIO_BECOMING_NOISY";
  21. public static final String ALARM_FM = "android.intent.action_WAKE_UP";//20150326 added by  lisineng for wakeup FM
  22. public void onReceive(Context context, Intent intent) {
  23.        String action = intent.getAction();
  24.        //20150326 added by  lisineng for wakeup FM
  25.        if (action.equals(ALARM_FM)) {
  26.     	   Log.i(TAG, "lsn mReceive action = android.media.action_WAKE_UP");
  27.     	   Intent intent_Alarm = new Intent();
  28.     	   intent_Alarm.putExtra("fromBroadcast", true);
  29. 	   		intent_Alarm.setClass(context, FMRadio.class);
  30. 	   		intent_Alarm.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
  31. 	   		context.startActivity(intent_Alarm);
  32.   }
  33.      //added end 
  34.        if ((action != null) && action.equals(AudioManager.ACTION_AUDIO_BECOMING_NOISY)) {
  35.            Log.d(TAG, "ACTION_AUDIO_BECOMING_NOISY intent received for ACTION_HEADSET_PLUG");
  36.            Intent i = new Intent(AUDIO_BECOMING_NOISY);
  37.            context.sendBroadcast(i);
  38.        } else if ((action != null) && action.equals("android.intent.action.MEDIA_BUTTON")) {
  39.            KeyEvent event = (KeyEvent)
  40.                     intent.getParcelableExtra(Intent.EXTRA_KEY_EVENT);
  41.  
  42.            if (event == null) {
  43.                return;
  44.            }
  45.            int keycode = event.getKeyCode();
  46.            int key_action = event.getAction();
  47.            if (((KeyEvent.KEYCODE_HEADSETHOOK == keycode) &&
  48.                (key_action == KeyEvent.ACTION_DOWN)) ||
  49.                (KeyEvent.KEYCODE_MEDIA_PAUSE == keycode) ||
  50.                (KeyEvent.KEYCODE_MEDIA_PLAY == keycode)) {
  51.  
  52.                Log.d(TAG, "ACTION_MEDIA_BUTTON intent received for ACTION_DOWN");
  53.                Intent i = new Intent(FM_MEDIA_BUTTON);
  54.                i.putExtra(Intent.EXTRA_KEY_EVENT, event);
  55.                context.sendBroadcast(i);
  56.            }
  57.        }
  58.    }
  59. }

4、对广播的注冊AndroidManifest.xml 

  1. <receiver android:name="com.caf.fmradio.FMMediaButtonIntentReceiver">
  2.             <intent-filter>
  3.                  <action android:name="android.intent.action.MEDIA_BUTTON" />
  4.                  <action android:name="android.media.AUDIO_BECOMING_NOISY" />
  5.                  <action android:name="android.intent.action_WAKE_UP" /><!-- 20150326 added by  lisineng for wakeup FM -->
  6.             </intent-filter>
  7.         </receiver>

5、对话框数组的定义arrays.xml 

  1.   <!-- 20150326 added by  lisineng for wakeup FM-->
  2.     <string-array name="wakeup_duration_values">
  3.     <item>15 minutes</item>
  4.     <item>30 minutes</item>
  5.     <item>45 minutes</item>
  6.     <item>1 Hour</item>
  7.   </string-array>
  8.   <!-- added end -->
6、对话框的title和menu的字符串 

  1.      <!--20150326 added by  lisineng for X1_Qmobile wakeup FM-->
  2.      <string name="menu_wakeup">Wakeup</string>
  3.     <string name="menu_wakeup_cancel">Cancel wakeup</string>
  4.     <string name="dialog_wakeup_title">Select Auto-Wakeup Time</string>
  5.     <!-- added end -->

收音机增加自己主动唤醒功能
1、加入两个菜单项。利用hasWakeup状态的推断。显示唤醒还是取消；
2、当启用自己主动唤醒功能时，弹出选择时间对话框给用户，并利用AlarmManager.RTC_WAKEUP
在设定的时间给系统发一个无序广播。

程序在收到这个广播之后启动FMRadio
在启动的时候推断是否有耳机。假设有则打开收音机。没有则仅仅是将FMRadio拉起。
3、要注意的地方就是对打开FM的时候要推断是自己主动唤醒的还是用户点击launcher启动的。


对于hasWakeuo状态的推断来决定menu的显示。



转载于:https://www.cnblogs.com/ljbguanli/p/6955817.html

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/笔触狂放9/article/detail/377048
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号