path: root/fmapp/src/com/codeaurora/fmradio/FmSharedPreferences.java

/*
 * Copyright (c) 2009-2013, The Linux Foundation. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *        * Redistributions of source code must retain the above copyright
 *            notice, this list of conditions and the following disclaimer.
 *        * Redistributions in binary form must reproduce the above copyright
 *            notice, this list of conditions and the following disclaimer in the
 *            documentation and/or other materials provided with the distribution.
 *        * Neither the name of The Linux Foundation nor
 *            the names of its contributors may be used to endorse or promote
 *            products derived from this software without specific prior written
 *            permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NON-INFRINGEMENT ARE DISCLAIMED.    IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
package com.codeaurora.fmradio;

import java.util.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.ListIterator;
import java.util.Locale;
import java.util.Map;

import android.content.Context;
import android.content.SharedPreferences;
import qcom.fmradio.FmReceiver;
import qcom.fmradio.FmConfig;
import android.util.Log;

public class FmSharedPreferences
{
   public static final int REGIONAL_BAND_NORTH_AMERICA   = 0;
   public static final int REGIONAL_BAND_EUROPE          = 1;
   public static final int REGIONAL_BAND_JAPAN           = 2;
   public static final int REGIONAL_BAND_JAPAN_WIDE      = 3;
   public static final int REGIONAL_BAND_AUSTRALIA       = 4;
   public static final int REGIONAL_BAND_AUSTRIA         = 5;
   public static final int REGIONAL_BAND_BELGIUM         = 6;
   public static final int REGIONAL_BAND_BRAZIL          = 7;
   public static final int REGIONAL_BAND_CHINA           = 8;
   public static final int REGIONAL_BAND_CZECH           = 9;
   public static final int REGIONAL_BAND_DENMARK         = 10;
   public static final int REGIONAL_BAND_FINLAND         = 11;
   public static final int REGIONAL_BAND_FRANCE          = 12;
   public static final int REGIONAL_BAND_GERMANY         = 13;
   public static final int REGIONAL_BAND_GREECE          = 14;
   public static final int REGIONAL_BAND_HONGKONG        = 15;
   public static final int REGIONAL_BAND_INDIA           = 16;
   public static final int REGIONAL_BAND_IRELAND         = 17;
   public static final int REGIONAL_BAND_ITALY           = 18;
   public static final int REGIONAL_BAND_KOREA           = 19;
   public static final int REGIONAL_BAND_MEXICO          = 20;
   public static final int REGIONAL_BAND_NETHERLANDS     = 21;
   public static final int REGIONAL_BAND_NEWZEALAND      = 22;
   public static final int REGIONAL_BAND_NORWAY          = 23;
   public static final int REGIONAL_BAND_POLAND          = 24;
   public static final int REGIONAL_BAND_PORTUGAL        = 25;
   public static final int REGIONAL_BAND_RUSSIA          = 26;
   public static final int REGIONAL_BAND_SINGAPORE       = 27;
   public static final int REGIONAL_BAND_SLOVAKIA        = 28;
   public static final int REGIONAL_BAND_SPAIN           = 29;
   public static final int REGIONAL_BAND_SWITZERLAND     = 30;
   public static final int REGIONAL_BAND_SWEDEN          = 31;
   public static final int REGIONAL_BAND_TAIWAN          = 32;
   public static final int REGIONAL_BAND_TURKEY          = 33;
   public static final int REGIONAL_BAND_UNITEDKINGDOM   = 34;
   public static final int REGIONAL_BAND_UNITED_STATES   = 35;
   public static final int REGIONAL_BAND_USER_DEFINED    = 36;

   public static final int RECORD_DUR_INDEX_0_VAL        = 5;
   public static final int RECORD_DUR_INDEX_1_VAL       = 15;
   public static final int RECORD_DUR_INDEX_2_VAL       = 30;
   public static final int RECORD_DUR_INDEX_3_VAL       = -1;

   private static final String LOGTAG = FMRadio.LOGTAG;

   private static final String SHARED_PREFS = "fmradio_prefs";
   private static final String LIST_NUM = "list_number";
   private static final String LIST_NAME = "list_name";
   private static final String STATION_NAME = "station_name";
   private static final String STATION_FREQUENCY = "station_freq";
   private static final String STATION_ID = "station_id";
   private static final String STATION_PTY = "station_pty";
   private static final String STATION_RDS = "station_rds";
   private static final String STATION_NUM = "preset_number";

   private static final String FMCONFIG_COUNTRY = "fmconfig_country";
   //private static final String FMCONFIG_BAND = "fmconfig_band";
   private static final String FMCONFIG_MIN = "fmconfig_min";
   private static final String FMCONFIG_MAX = "fmconfig_max";
   private static final String FMCONFIG_STEP = "fmconfig_step";
   //private static final String FMCONFIG_EMPH = "fmconfig_emphasis";
   //private static final String FMCONFIG_RDSSTD = "fmconfig_rdsstd";
   /* Storage key String */
   private static final String LAST_LIST_INDEX = "last_list_index";
   public static final int MAX_NUM_TAG_TYPES = 64;
   public static final int NUM_TAG_CATEGORY = 8;
   public static final String []TAG_CATEGORIES = { "DUMMY", "ITEM", "INFO", "PROGRAMME",
                                                      "INTERACTIVITY", "RFU", "PRIVATE_CLASSES",
                                                      "DESCRIPTOR" };
   public static final int [][]TAG_CATEGORY_RANGE  = { {0, 0}, {1, 11}, {12, 30},
                                                         {31, 40}, {41, 53}, {54, 55},
                                                         {56, 58}, {59, 63} };
   public static final String []TAG_NAMES = { "DUMMY", "ITEM.TITLE", "ITEM.ALBUM", "ITEM.TRACKNUM",
                                                  "ITEM.ARTIST", "ITEM.COMPOSITION", "ITEM.MOVEMENT",
                                                  "ITEM.CONDUCTOR", "ITEM.COMPOSER", "ITEM.BAND", "ITEM.COMMENT",
                                                  "ITEM.GENERE", "INFO.NEWS", "INFO.NEWS_LOCAL", "INFO.STOCK",
                                                  "INFO.SPORT", "INFO.LOTTERY", "INFO.HOROSCOPE",
                                                  "INFO.DAILY_DIVERSION", "INFO.HEALTH", "INFO.EVENT",
                                                  "INFO.SCENE", "INFO.CINEMA", "INFO.TV", "INFO.DATE_TIME",
                                                  "INFO.WEATHER", "INFO.TRAFFIC", "INFO.ALARM", "INFO.ADS",
                                                  "INFO.URL", "INFO.OTHER", "PROGRAMME.STATIONNAME_SHORT",
                                                  "PROGRAMME.NOW", "PROGRAMME.NEXT", "PROGRAMME.PART",
                                                  "PROGRAMME.HOST", "PROGRAMME.EDITORIAL_STAFF",
                                                  "PROGRAMME.FREQUENCY", "PROGRAMME.HOMEPAGE",
                                                  "PROGRAMME.SUBCHANNEL", "PHONE.HOTLINE", "PHONE.STUDIO",
                                                  "PHONE.OTHER", "SMS.STUDIO", "SMS.OTHER", "EMAIL.HOTLINE",
                                                  "EMAIL.STUDIO", "EMAIL.OTHER", "MMS.OTHER", "CHAT",
                                                  "CHAT.CENTRE", "VOTE.QUESTION", "VOTE.CENTRE", "RFU.1",
                                                  "RFU.2", "PRIVATE.1", "PRIVATE.2", "PRIVATE.3",
                                                  "PLACE", "APPOINTMENT", "IDENTIFIER", "PURCHASE", "GET_DATA" };

   private static final String PREF_LAST_TUNED_FREQUENCY = "last_frequency";
   private static final String LAST_RECORD_DURATION = "last_record_duration";
   private static String  LAST_AF_JUMP_VALUE = "last_af_jump_value";

   private static Map<String, String> mNameMap = new HashMap<String, String>();
   private static List<PresetList> mListOfPlists = new ArrayList<PresetList>();
   public static Set[] tagList = new TreeSet[FmSharedPreferences.MAX_NUM_TAG_TYPES];
   public static int num_tags = 0;
   private static FmConfig mFMConfiguration;

   private static final String DEFAULT_NO_NAME = "";
   private static final int DEFAULT_NO_FREQUENCY = 98100;
   private static final int DEFAULT_NO_PTY = 0;
   private static final int DEFAULT_NO_STATIONID = 0;
   private static final int DEFAULT_NO_RDSSUP = 0;
   private static CharSequence[] mListEntries;
   private static CharSequence[] mListValues;
   private static int mListIndex;
   private Context mContext;
   private static int mTunedFrequency = 98100;
   private static int mBandMinFreq = 76000;
   private static int mBandMaxFreq = 108000;
   private static int mChanSpacing = 0;
   private static int mFrequencyBand_Stepsize = 200;

   private static int mCountry = 0;
   /* true = Stereo and false = "force Mono" even if Station is transmitting a
    * Stereo signal
    */
   private static boolean mAudioOutputMode=true;
   private static boolean mAFAutoSwitch=true;
   private static int mRecordDuration=0;

   FmSharedPreferences(Context context){
      mContext = context.getApplicationContext();
      mFMConfiguration = new FmConfig();
      Load();
   }

   public static void removeStation(int listIndex, int stationIndex){
      if (listIndex < getNumList())
      {
         mListOfPlists.get(listIndex).removeStation(stationIndex);
      }
   }
   public static void removeStation(int listIndex, PresetStation station){
      if (listIndex < getNumList())
      {
         mListOfPlists.get(listIndex).removeStation(station);
      }
   }

   public static void setListName(int listIndex, String name){
      if (listIndex < getNumList())
      {
         mListOfPlists.get(listIndex).setName(name);
      }
   }

   public static void setStationName(int listIndex, int stationIndex, String name){
      if (listIndex < getNumList())
      {
         mListOfPlists.get(listIndex).setStationName(stationIndex, name);
      }
   }

   public static String getListName(int listIndex){
      String name = "";
      addListIfEmpty(listIndex);
      if (listIndex < getNumList())
      {
         name= mListOfPlists.get(listIndex).getName();
      }
      return name;
   }

   public static String getStationName(int listIndex, int stationIndex){
      String name = "";
      if (listIndex < getNumList())
      {
         name = mListOfPlists.get(listIndex).getStationName(stationIndex);
      }
      return name;
   }

   public static double getStationFrequency(int listIndex, int stationIndex){
      double frequency = 0;
      if (listIndex < getNumList())
      {
         frequency =  mListOfPlists.get(listIndex).getStationFrequency(stationIndex);
      }
      return frequency;
   }

   public static PresetList getStationList(int listIndex){
      if (listIndex < getNumList())
      {
         return mListOfPlists.get(listIndex);
      }
      return null;
   }

   public static PresetStation getselectedStation(){
      int listIndex = getCurrentListIndex();
      PresetStation station = null;
      if (listIndex < getNumList())
      {
         station = mListOfPlists.get(listIndex).getSelectedStation();
      }
      return station;
   }

   public static PresetStation getStationInList(int index){
      int listIndex = getCurrentListIndex();
      PresetStation station = null;
      if (listIndex < getNumList())
      {
         station = mListOfPlists.get(listIndex).getStationFromIndex(index);
      }
      return station;
   }
   public static PresetStation getStationFromFrequency(int frequency){
      int listIndex = getCurrentListIndex();
      PresetStation station = null;
      if (listIndex < getNumList())
      {
         station = mListOfPlists.get(listIndex).getStationFromFrequency(frequency);
      }
      return station;
   }

   public static PresetStation selectNextStation(){
      int listIndex = getCurrentListIndex();
      PresetStation station = null;
      if (listIndex < getNumList())
      {
         station = mListOfPlists.get(listIndex).selectNextStation();
      }
      return station;
   }

   public static PresetStation selectPrevStation(){
      int listIndex = getCurrentListIndex();
      PresetStation station = null;
      if (listIndex < getNumList())
      {
         station = mListOfPlists.get(listIndex).selectPrevStation();
      }
      return station;
   }

   public static void selectStation(PresetStation station){
      int listIndex = getCurrentListIndex();
      if (listIndex < getNumList())
      {
         mListOfPlists.get(listIndex).selectStation(station);
      }
   }

   public static int getNumList(){
      return mListOfPlists.size();
   }

   public static int getCurrentListIndex(){
      return mListIndex;
   }

   public static void setListIndex(int index){
      mListIndex = index;
   }

   public static Map<String, String> getNameMap(){
      return mNameMap;
   }

   private static void addListIfEmpty(int listIndex){
      if ( (listIndex < 1) && (getNumList() == 0))
      {
         createPresetList("FM");
      }
   }

   public static void addStation(String name, int freq, int listIndex){
      /* If no lists exists and a new station is added, add a new Preset List
       * if "listIndex" requested was "0"
       */
      addListIfEmpty(listIndex);
      if (getNumList() > listIndex)
      {
         mListOfPlists.get(listIndex).addStation(name, freq);
      }
   }

   /** Add "station" into the Preset List indexed by "listIndex" */
   public static void addStation(int listIndex, PresetStation station){
      /* If no lists exists and a new station is added, add a new Preset List
       * if "listIndex" requested was "0"
       */
      addListIfEmpty(listIndex);
      if (getNumList() > listIndex)
      {
         mListOfPlists.get(listIndex).addStation(station);
      }
   }
   public static void addTags(int index, String s) {
     if ((index >= 0) && (index <FmSharedPreferences.MAX_NUM_TAG_TYPES)) {
          if(tagList[index] == null) {
             tagList[index] = new TreeSet<String>();
          }
          if (tagList[index].add(s))
              num_tags++;
     }
   }
   public static void clearTags() {
       for(int i = 0; i <FmSharedPreferences.MAX_NUM_TAG_TYPES; i++) {
           if(tagList[i] != null) {
              tagList[i].clear();
              Log.d(LOGTAG, "cleared tags of type" + i);
           }
       }
       num_tags = 0;
   }

   /** Does "station" already exist in the Preset List indexed by "listIndex" */
   public static boolean sameStationExists(int listIndex, PresetStation station){
      boolean exists = false;
      if (getNumList() > listIndex)
      {
         exists = mListOfPlists.get(listIndex).sameStationExists(station);
      }
      return exists;
   }

   /** Does "station" already exist in the current Preset List*/
   public static boolean sameStationExists( PresetStation station){
      int listIndex = getCurrentListIndex();
      boolean exists = false;
      if (getNumList() > listIndex)
      {
         exists = mListOfPlists.get(listIndex).sameStationExists(station);
      }
      return exists;
   }

   /** Does "station" already exist in the current Preset List*/
   public static int getListStationCount( ){
      int listIndex = getCurrentListIndex();
      int numStations = 0;
      if (getNumList() > listIndex)
      {
         numStations = mListOfPlists.get(listIndex).getStationCount();
      }
      return numStations;
   }

   public static void renamePresetList(String newName, int listIndex){
      PresetList curList =    mListOfPlists.get(listIndex);
      if (curList != null)
      {
         String oldListName = curList.getName();
         curList.setName(newName);
         String index = mNameMap.get(oldListName);
         mNameMap.remove(oldListName);
         mNameMap.put((String) newName, index);
         repopulateEntryValueLists();
      }
   }

   /* Returns the index of the list just created */
   public static int createPresetList(String name) {
      int numLists = mListOfPlists.size();
      mListOfPlists.add(new PresetList(name));
      String index = String.valueOf(numLists);
      mNameMap.put(name, index);
      repopulateEntryValueLists();
      return numLists;
   }


   public static void createFirstPresetList(String name) {
      mListIndex = 0;
      createPresetList(name);
   }

   public static CharSequence[] repopulateEntryValueLists() {
      ListIterator<PresetList> presetIter;
      presetIter = mListOfPlists.listIterator();
      int numLists = mListOfPlists.size();

      mListEntries = new CharSequence[numLists];
      mListValues = new CharSequence[numLists];
      for (int i = 0; i < numLists; i++)
      {
         PresetList temp = presetIter.next();
         mListEntries[i] = temp.getName();
         mListValues[i] = temp.getName();
      }
      return mListEntries;
   }

   public static List<PresetList> getPresetLists() {
      return mListOfPlists;
   }


   public void  Load(){
      Log.d(LOGTAG, "Load preferences ");
      if(mContext == null)
      {
         return;
      }
      SharedPreferences sp = mContext.getSharedPreferences(SHARED_PREFS, Context.MODE_PRIVATE);
      mTunedFrequency = sp.getInt(PREF_LAST_TUNED_FREQUENCY, DEFAULT_NO_FREQUENCY);
      mRecordDuration = sp.getInt(LAST_RECORD_DURATION, RECORD_DUR_INDEX_0_VAL);
      mAFAutoSwitch = sp.getBoolean(LAST_AF_JUMP_VALUE, true);
      if(sp.getInt(FMCONFIG_COUNTRY, 0) == REGIONAL_BAND_USER_DEFINED) {
         mBandMinFreq = sp.getInt(FMCONFIG_MIN, mBandMinFreq);
         mBandMaxFreq = sp.getInt(FMCONFIG_MAX, mBandMaxFreq);
         mChanSpacing = sp.getInt(FMCONFIG_STEP, mChanSpacing);
      }
      int num_lists = sp.getInt(LIST_NUM, 1);
      if (mListOfPlists.size() == 0) {

         for (int listIter = 0; listIter < num_lists; listIter++)
         {
             String listName = sp.getString(LIST_NAME + listIter, "FM - " + (listIter+1));
             int numStations = sp.getInt(STATION_NUM + listIter, 1);
             if (listIter == 0)
             {
                 createFirstPresetList(listName);
             } else
             {
                 createPresetList(listName);
             }

             PresetList curList = mListOfPlists.get(listIter);
             for (int stationIter = 0; stationIter < numStations; stationIter++)
             {
                  String stationName = sp.getString(STATION_NAME + listIter + "x" + stationIter,
                                                      DEFAULT_NO_NAME);
                  int stationFreq = sp.getInt(STATION_FREQUENCY + listIter + "x" + stationIter,
                                                   DEFAULT_NO_FREQUENCY);
                  PresetStation station = curList.addStation(stationName, stationFreq);

                  int stationId = sp.getInt(STATION_ID + listIter + "x" + stationIter,
                                              DEFAULT_NO_STATIONID);
                  station.setPI(stationId);

                  int pty = sp.getInt(STATION_PTY + listIter + "x" + stationIter, DEFAULT_NO_PTY);
                  station.setPty(pty);

                  int rdsSupported = sp.getInt(STATION_RDS + listIter + "x" + stationIter,
                                                 DEFAULT_NO_RDSSUP);
                  if (rdsSupported != 0)
                  {
                      station.setRDSSupported(true);
                  } else
                  {
                      station.setRDSSupported(false);
                  }
             }
         }
      }
      /* Load Configuration */
      if (Locale.getDefault().equals(Locale.CHINA)) {
          setCountry(sp.getInt(FMCONFIG_COUNTRY, REGIONAL_BAND_CHINA));
      } else {
          setCountry(sp.getInt(FMCONFIG_COUNTRY, REGIONAL_BAND_NORTH_AMERICA));
      }
      /* Last list the user was navigating */
      mListIndex = sp.getInt(LAST_LIST_INDEX, 0);
      if(mListIndex >= num_lists)
      {
         mListIndex=0;
      }
   }

   public void Save() {
      if(mContext == null)
      {
         return;
      }
      Log.d(LOGTAG, "Save preferences ");

      int numLists = mListOfPlists.size();
      SharedPreferences sp = mContext.getSharedPreferences(SHARED_PREFS, Context.MODE_PRIVATE);
      SharedPreferences.Editor ed = sp.edit();

      ed.putInt(PREF_LAST_TUNED_FREQUENCY, mTunedFrequency);

      ed.putInt(LIST_NUM, numLists);
      /* Last list the user was navigating */
      ed.putInt(LAST_LIST_INDEX, mListIndex);

      for (int listIter = 0; listIter < numLists; listIter++)
      {
         PresetList curList = mListOfPlists.get(listIter);
         ed.putString(LIST_NAME + listIter, curList.getName());
         int numStations = curList.getStationCount();
         ed.putInt(STATION_NUM + listIter, numStations);
         int numStation = 0;
         for (int stationIter = 0; stationIter < numStations; stationIter++)
         {
            PresetStation station = curList.getStationFromIndex(stationIter);
            if (station != null)
            {
               ed.putString(STATION_NAME + listIter + "x" + numStation,
                            station.getName());
               ed.putInt(STATION_FREQUENCY + listIter + "x" + numStation,
                         station.getFrequency());
               ed.putInt(STATION_ID + listIter + "x" + numStation,
                         station.getPI());
               ed.putInt(STATION_PTY + listIter + "x" + numStation,
                         station.getPty());
               ed.putInt(STATION_RDS + listIter + "x" + numStation,
                         (station.getRDSSupported() == true? 1:0));
               numStation ++;
            }
         }
      }

      /* Save Configuration */
      ed.putInt(FMCONFIG_COUNTRY, mCountry);
      if(mCountry == REGIONAL_BAND_USER_DEFINED) {
         ed.putInt(FMCONFIG_MIN, mBandMinFreq);
         ed.putInt(FMCONFIG_MAX, mBandMaxFreq);
         ed.putInt(FMCONFIG_STEP, mChanSpacing);
      }
      ed.putInt(LAST_RECORD_DURATION, mRecordDuration);
      ed.putBoolean(LAST_AF_JUMP_VALUE, mAFAutoSwitch);
      ed.commit();
   }

   public static void SetDefaults() {
      mListIndex=0;
      mListOfPlists.clear();
      if (Locale.getDefault().equals(Locale.CHINA)){
          setCountry(REGIONAL_BAND_CHINA);
          //Others set north America.
      } else {
          setCountry(REGIONAL_BAND_NORTH_AMERICA);
      }
   }

   public static void removeStationList(int listIndex) {
      mListIndex = listIndex;
      PresetList toRemove = mListOfPlists.get(mListIndex);

      mNameMap.remove(toRemove.getName());
      mListOfPlists.remove(mListIndex);
      int numLists = mListOfPlists.size();

      /* Remove for others */
      for (int i = mListIndex; i < numLists; i++)
      {
         PresetList curList = mListOfPlists.get(i);
         if (curList!=null)
         {
            String listName = curList.getName();
            /* Removals */
            mNameMap.remove(listName);
            mNameMap.put(listName, String.valueOf(i));
         }
      }
      mListIndex = 0;
      repopulateEntryValueLists();
   }


   public static void setTunedFrequency(int frequency) {
      mTunedFrequency = frequency;
   }

   public static int getTunedFrequency() {
      return mTunedFrequency;
   }

   public static int getNextTuneFrequency(int frequency) {
              int nextFrequency = (frequency + mFrequencyBand_Stepsize);
              if (nextFrequency > getUpperLimit())
              {
                 nextFrequency = getLowerLimit();
              }
              return nextFrequency;
           }

   public static int getNextTuneFrequency() {
      int nextFrequency = (mTunedFrequency + mFrequencyBand_Stepsize);
      if (nextFrequency > getUpperLimit())
      {
         nextFrequency = getLowerLimit();
      }
      return nextFrequency;
   }

   public static int getPrevTuneFrequency(int frequency) {
              int prevFrequency = (frequency - mFrequencyBand_Stepsize);
              if (prevFrequency < getLowerLimit())
              {
                 prevFrequency = getUpperLimit();
              }
              return prevFrequency;
           }

   public static int getPrevTuneFrequency() {
      int prevFrequency = (mTunedFrequency - mFrequencyBand_Stepsize);
      if (prevFrequency < getLowerLimit())
      {
         prevFrequency = getUpperLimit();
      }
      return prevFrequency;
   }

   /**
    * @param mFMConfiguration the mFMConfiguration to set
    */
   public static void setFMConfiguration(FmConfig mFMConfig) {
      FmSharedPreferences.mFMConfiguration = mFMConfig;
   }

   /**
    * @return the mFMConfiguration
    */
   public static FmConfig getFMConfiguration() {
      return mFMConfiguration;
   }

   public static void setRadioBand(int band)
   {
      switch (band)
      {
      case FmReceiver.FM_JAPAN_WIDE_BAND:
         {
            mFrequencyBand_Stepsize = 50;
            mFMConfiguration.setLowerLimit(76000);
            mFMConfiguration.setUpperLimit(108000);
            break;
         }
      case FmReceiver.FM_JAPAN_STANDARD_BAND:
         {
            mFrequencyBand_Stepsize = 100;
            mFMConfiguration.setLowerLimit(76000);
            mFMConfiguration.setUpperLimit(90000);
            break;
         }
      case FmReceiver.FM_USER_DEFINED_BAND:
         {
            break;
         }
      case FmReceiver.FM_US_BAND:
      case FmReceiver.FM_EU_BAND:
      default:
         {
            band =  FmReceiver.FM_US_BAND;
            mFMConfiguration.setLowerLimit(87500);
            mFMConfiguration.setUpperLimit(107900);
            mFrequencyBand_Stepsize = 100;
         }
      }
      mFMConfiguration.setRadioBand(band);
   }

   public static int getRadioBand()
   {
      return mFMConfiguration.getRadioBand();
   }

   public static void setChSpacing(int spacing)
   {
      if( (spacing >= FmReceiver.FM_CHSPACE_200_KHZ)
          && (spacing <= FmReceiver.FM_CHSPACE_50_KHZ))
      {
         mFrequencyBand_Stepsize = 200;
         switch (spacing)
         {
         case FmReceiver.FM_CHSPACE_100_KHZ:
            {
               mFrequencyBand_Stepsize = 100;
               break;
            }
         case FmReceiver.FM_CHSPACE_50_KHZ:
            {
               mFrequencyBand_Stepsize = 50;
               break;
            }
         }
         mChanSpacing = spacing;
         mFMConfiguration.setChSpacing(spacing);
      }
   }

   public static int getChSpacing()
   {
      return mFMConfiguration.getChSpacing();
   }

   public static void setRdsStd(int std)
   {
      if( (std>=FmReceiver.FM_RDS_STD_RBDS)
          && (std<=FmReceiver.FM_RDS_STD_NONE))
      {
         mFMConfiguration.setRdsStd(std);
      }
   }

   public static int getRdsStd()
   {
      return mFMConfiguration.getRdsStd();
   }

   /* North America */
   public static boolean isRDSStd()
   {
      return(FmReceiver.FM_RDS_STD_RDS == mFMConfiguration.getRdsStd());
   }

   public static boolean isRBDSStd()
   {
      return(FmReceiver.FM_RDS_STD_RBDS == mFMConfiguration.getRdsStd());
   }

   public static void setEmphasis(int emph)
   {
      if( (emph>=FmReceiver.FM_DE_EMP75)
          && (emph<=FmReceiver.FM_DE_EMP50))
      {
         mFMConfiguration.setEmphasis(emph);
      }
   }

   public static int getEmphasis()
   {
      return mFMConfiguration.getEmphasis();
   }

   public static int getUpperLimit()
   {
      return mFMConfiguration.getUpperLimit();
   }

   public static int getLowerLimit()
   {
      return mFMConfiguration.getLowerLimit();
   }

   public static void setLowerLimit(int lowLimit) {
      mFMConfiguration.setLowerLimit(lowLimit);
      if(mCountry == REGIONAL_BAND_USER_DEFINED) {
         mBandMinFreq = lowLimit;
      }
   }

   public static void setUpperLimit(int upLimit){
      mFMConfiguration.setUpperLimit(upLimit);
      if(mCountry == REGIONAL_BAND_USER_DEFINED) {
         mBandMaxFreq = upLimit;
      }
   }

   public static void setCountry(int nCountryCode){

      // Default: 87500  TO 10800 IN 100 KHZ STEPS
      mFMConfiguration.setRadioBand(FmReceiver.FM_USER_DEFINED_BAND);
      mFMConfiguration.setChSpacing(FmReceiver.FM_CHSPACE_100_KHZ);
      mFMConfiguration.setEmphasis(FmReceiver.FM_DE_EMP50);
      mFMConfiguration.setRdsStd(FmReceiver.FM_RDS_STD_RDS);
      mFMConfiguration.setLowerLimit(87500);
      mFMConfiguration.setUpperLimit(108000);

      switch(nCountryCode)
      {
        case REGIONAL_BAND_NORTH_AMERICA:
        {
          /*NORTH_AMERICA : 87500 TO 108000 IN 200 KHZ STEPS*/
          mFMConfiguration.setRadioBand(FmReceiver.FM_US_BAND);
          mFMConfiguration.setChSpacing(FmReceiver.FM_CHSPACE_200_KHZ);
          mFMConfiguration.setEmphasis(FmReceiver.FM_DE_EMP75);
          mFMConfiguration.setRdsStd(FmReceiver.FM_RDS_STD_RBDS);
          mFMConfiguration.setLowerLimit(87500);
          mFMConfiguration.setUpperLimit(107900);
          mFrequencyBand_Stepsize = 200;
          break;
        }
        case REGIONAL_BAND_EUROPE:
        {
          /*EUROPE/Default : 87500 TO 10800 IN 100 KHZ STEPS*/
          mFrequencyBand_Stepsize = 100;
          break;
        }

        case REGIONAL_BAND_JAPAN:
        {
          /*JAPAN : 76000  TO 90000 IN 100 KHZ STEPS*/
          mFMConfiguration.setRadioBand(FmReceiver.FM_JAPAN_STANDARD_BAND);
          mFMConfiguration.setChSpacing(FmReceiver.FM_CHSPACE_100_KHZ);
          mFMConfiguration.setEmphasis(FmReceiver.FM_DE_EMP75);
          mFMConfiguration.setLowerLimit(76000);
          mFMConfiguration.setUpperLimit(90000);
          mFrequencyBand_Stepsize = 100;
          break;
        }
        case REGIONAL_BAND_JAPAN_WIDE:
        {
          /*JAPAN_WB : 90000 TO 108000 IN 50 KHZ STEPS*/
          mFMConfiguration.setRadioBand(FmReceiver.FM_JAPAN_WIDE_BAND);
          mFMConfiguration.setChSpacing(FmReceiver.FM_CHSPACE_50_KHZ);
          mFMConfiguration.setEmphasis(FmReceiver.FM_DE_EMP75);
          mFMConfiguration.setLowerLimit(90000);
          mFMConfiguration.setUpperLimit(108000);
          mFrequencyBand_Stepsize = 50;
          break;
        }

        /* Country specific */
        case REGIONAL_BAND_AUSTRALIA:
        {
          /*AUSTRALIA : 87700 TO 108000 IN 100 KHZ STEPS*/
          mFMConfiguration.setLowerLimit(87700);
          mFrequencyBand_Stepsize = 100;
          break;
        }
        case REGIONAL_BAND_AUSTRIA:
        {
          /*AUSTRIA : 87500 TO 108000 IN 50 KHZ STEPS*/
          mFMConfiguration.setEmphasis(FmReceiver.FM_DE_EMP50);
          mFrequencyBand_Stepsize = 50;
          break;
        }
        case REGIONAL_BAND_BELGIUM:
       {
         /*BELGIUM : 87500 TO 108000 IN 100 KHZ STEPS*/
         mFrequencyBand_Stepsize = 100;
         break;
       }
       case REGIONAL_BAND_BRAZIL:
       {
         /*BRAZIL : 87500 TO 108000 IN 200 KHZ STEP*/
          mFMConfiguration.setRadioBand(FmReceiver.FM_US_BAND);
          mFMConfiguration.setChSpacing(FmReceiver.FM_CHSPACE_200_KHZ);
          mFMConfiguration.setLowerLimit(87500);
          mFMConfiguration.setUpperLimit(107900);
          mFrequencyBand_Stepsize = 200;
          break;
        }
        case REGIONAL_BAND_CHINA:
        {
          /*CHINA : 87000 TO 108000 IN 100 KHZ STEPS*/
          mFMConfiguration.setLowerLimit(87000);
          mFrequencyBand_Stepsize = 100;
          break;
        }
        case REGIONAL_BAND_CZECH:
        {
          /*CZECH : 87500 TO 108000 IN 100 KHZ STEPS*/
          mFrequencyBand_Stepsize = 100;
          break;
        }
        case REGIONAL_BAND_DENMARK:
        {
          /*DENMARK : 87500 TO 108000 IN 50 KHZ STEPS*/
          mFMConfiguration.setRadioBand(FmReceiver.FM_EU_BAND);
          mFMConfiguration.setChSpacing(FmReceiver.FM_CHSPACE_50_KHZ);
          mFrequencyBand_Stepsize = 50;
          break;
        }
        case REGIONAL_BAND_FINLAND:
        {
          /*FINLAND : 87500  TO 108000  IN 100 KHZ STEPS*/
          mFrequencyBand_Stepsize = 100;
          break;
        }
        case REGIONAL_BAND_FRANCE:
        {
          /* FRANCE : 87500 TO 108000 IN 100 KHZ STEPS*/
          mFrequencyBand_Stepsize = 100;
          break;
        }
        case REGIONAL_BAND_GERMANY:
          /*GERMANY : 87500 TO 108000 IN 50 KHZ STEPS*/
        case REGIONAL_BAND_GREECE:
          /*GREECE : 87500 TO 108000 IN 50 KHZ STEPS*/
        {
          mFMConfiguration.setRadioBand(FmReceiver.FM_EU_BAND);
          mFMConfiguration.setChSpacing(FmReceiver.FM_CHSPACE_50_KHZ);
          mFrequencyBand_Stepsize = 50;
          break;
        }
        case REGIONAL_BAND_HONGKONG:
        {
          /*HONG KONG : 87500 TO 108000 IN 100 KHZ STEPS*/
          mFrequencyBand_Stepsize = 100;
          break;
        }
        case REGIONAL_BAND_INDIA:
        {
          /*INDIA : 91000 TO 106400 IN 100 KHZ STEPS*/
          mFMConfiguration.setLowerLimit(91000);
          mFMConfiguration.setUpperLimit(106400);
          mFrequencyBand_Stepsize = 100;
          break;
        }
        case REGIONAL_BAND_IRELAND:
        {
          /*IRELAND : 87500 TO 108000 IN 50 KHZ STEPS*/
          mFMConfiguration.setRadioBand(FmReceiver.FM_EU_BAND);
          mFMConfiguration.setChSpacing(FmReceiver.FM_CHSPACE_50_KHZ);
          mFrequencyBand_Stepsize = 50;
          break;
        }
        case REGIONAL_BAND_ITALY:
        {
          /*ITALY : 87500 TO 108000 IN 50 KHZ STEPS*/
          mFMConfiguration.setRadioBand(FmReceiver.FM_EU_BAND);
          mFMConfiguration.setChSpacing(FmReceiver.FM_CHSPACE_50_KHZ);
          mFrequencyBand_Stepsize = 50;
          break;
        }
        case REGIONAL_BAND_KOREA:
        {
          /*KOREA : 87500 TO 108000 IN 200 KHZ STEPS*/
          mFMConfiguration.setRadioBand(FmReceiver.FM_US_BAND);
          mFMConfiguration.setChSpacing(FmReceiver.FM_CHSPACE_200_KHZ);
          mFMConfiguration.setUpperLimit(107900);
          mFrequencyBand_Stepsize = 200;
          break;
        }
        case REGIONAL_BAND_MEXICO:
        {
          /*MEXICO : 88100 TO 107900 IN 200 KHZ STEPS*/
          mFMConfiguration.setRadioBand(FmReceiver.FM_US_BAND);
          mFMConfiguration.setChSpacing(FmReceiver.FM_CHSPACE_200_KHZ);
          mFMConfiguration.setEmphasis(FmReceiver.FM_DE_EMP75);
          mFMConfiguration.setRdsStd(FmReceiver.FM_RDS_STD_RBDS);
          mFMConfiguration.setLowerLimit(88100);
          mFMConfiguration.setUpperLimit(107900);
          mFrequencyBand_Stepsize = 200;
          break;
        }
        case REGIONAL_BAND_NETHERLANDS:
        {
          /*NETHERLANDS : 87500 TO 108000 IN 100 KHZ STEPS*/
          mFrequencyBand_Stepsize = 100;
          break;
        }
        case REGIONAL_BAND_NEWZEALAND:
        {
          /*NEW ZEALAND : 88000 TO 107000 IN 100 KHZ STEPS*/
          mFMConfiguration.setLowerLimit(88000);
          mFMConfiguration.setUpperLimit(107000);
          mFrequencyBand_Stepsize = 100;
          break;
        }
        case REGIONAL_BAND_NORWAY:
        {
          /*NORWAY : 87500 TO 108000 IN 100 KHZ STEPS*/
          mFrequencyBand_Stepsize = 100;
          break;
        }
        case REGIONAL_BAND_POLAND:
        {
          /*POLAND : 87500 TO 108000 IN 100 KHZ STEPS*/
          mFMConfiguration.setRadioBand(FmReceiver.FM_EU_BAND);
          mFMConfiguration.setChSpacing(FmReceiver.FM_CHSPACE_100_KHZ);
          mFMConfiguration.setLowerLimit(87500);
          mFrequencyBand_Stepsize = 100;
          break;
        }
        case REGIONAL_BAND_PORTUGAL:
        {
          /*PORTUGAL : 87500 TO 108000 IN 50 KHZ STEPS*/
          mFMConfiguration.setRadioBand(FmReceiver.FM_EU_BAND);
          mFMConfiguration.setChSpacing(FmReceiver.FM_CHSPACE_50_KHZ);
          mFrequencyBand_Stepsize = 50;
          break;
        }
        case REGIONAL_BAND_RUSSIA:
        {
          /*RUSSIA : 87500 TO 108000  IN 100 KHZ STEPS*/
          mFrequencyBand_Stepsize = 100;
          break;
        }
        case REGIONAL_BAND_SINGAPORE:
        {
          /*SINGAPORE : 88000 TO 108000 IN 100 KHZ STEPS*/
          mFMConfiguration.setLowerLimit(88000);
          mFrequencyBand_Stepsize = 100;
          break;
        }
        case REGIONAL_BAND_SLOVAKIA:
        {
          /*SLOVAKIA : 87500 TO 108000 IN 100 KHZ STEPS*/
          mFrequencyBand_Stepsize = 100;
          break;
        }
        case REGIONAL_BAND_SPAIN:
        {
          /*SPAIN : 87500 TO 108000 IN 100 KHZ STEPS*/
          mFrequencyBand_Stepsize = 100;
          break;
        }
        case REGIONAL_BAND_SWITZERLAND:
        {
          /*SWITZERLAND : 87500 TO 108000 IN 100 KHZ STEPS*/
          mFrequencyBand_Stepsize = 100;
          break;
        }
        case REGIONAL_BAND_SWEDEN:
        {
          /*SWEDEN : 87500 TO 108000  IN 100 KHZ STEPS*/
          mFrequencyBand_Stepsize = 100;
          break;
        }
        case REGIONAL_BAND_TAIWAN:
        {
          /*TAIWAN : 87500 TO 108000 IN 100 KHZ STEPS*/
          mFrequencyBand_Stepsize = 100;
          break;
        }
        case REGIONAL_BAND_TURKEY:
        {
          /*TURKEY : 87500 TO 108000 IN 100 KHZ STEPS*/
          mFrequencyBand_Stepsize = 100;
          break;
        }
        case REGIONAL_BAND_UNITEDKINGDOM:
        {
          /*UNITED KINGDOM : 87500 TO 108000 IN 100 KHZ STEPS*/
          mFrequencyBand_Stepsize = 100;
          break;
        }
        case REGIONAL_BAND_UNITED_STATES:
        {
          /*UNITED STATES : 88100 TO 107900 IN 200 KHZ STEPS*/
          mFMConfiguration.setRadioBand(FmReceiver.FM_US_BAND);
          mFMConfiguration.setChSpacing(FmReceiver.FM_CHSPACE_200_KHZ);
          mFMConfiguration.setEmphasis(FmReceiver.FM_DE_EMP75);
          mFMConfiguration.setRdsStd(FmReceiver.FM_RDS_STD_RBDS);
          mFMConfiguration.setLowerLimit(88100);
          mFMConfiguration.setUpperLimit(107900);
          mFrequencyBand_Stepsize = 200;
          break;
        }
        case REGIONAL_BAND_USER_DEFINED:
        {
          mFMConfiguration.setRadioBand(FmReceiver.FM_USER_DEFINED_BAND);
          mFMConfiguration.setChSpacing(mChanSpacing);
          mFMConfiguration.setEmphasis(FmReceiver.FM_DE_EMP75);
          mFMConfiguration.setRdsStd(FmReceiver.FM_RDS_STD_RDS);
          mFMConfiguration.setLowerLimit(mBandMinFreq);
          mFMConfiguration.setUpperLimit(mBandMaxFreq);
          if(mChanSpacing == 0) {
             mFrequencyBand_Stepsize = 200;
          }else if(mChanSpacing == 1) {
             mFrequencyBand_Stepsize = 100;
          }else {
             mFrequencyBand_Stepsize = 50;
          }
          break;
        }
        default:
        {
          Log.d(LOGTAG, "Invalid: countryCode: "+nCountryCode);
          nCountryCode=0;
        }
      }
    mCountry = nCountryCode;
    Log.d(LOGTAG, "=====================================================");
    Log.d(LOGTAG, "Country     :"+nCountryCode);
    Log.d(LOGTAG, "RadioBand   :"+ mFMConfiguration.getRadioBand());
    Log.d(LOGTAG, "Emphasis    :"+ mFMConfiguration.getEmphasis());
    Log.d(LOGTAG, "ChSpacing   :"+ mFMConfiguration.getChSpacing());
    Log.d(LOGTAG, "RdsStd      :"+ mFMConfiguration.getRdsStd());
    Log.d(LOGTAG, "LowerLimit  :"+ mFMConfiguration.getLowerLimit());
    Log.d(LOGTAG, "UpperLimit  :"+ mFMConfiguration.getUpperLimit());
    Log.d(LOGTAG, "=====================================================");
   }


   public static int getCountry() {
      return mCountry;
   }


   public static void setAudioOutputMode(boolean bStereo) {
      mAudioOutputMode = bStereo;
   }

   public static boolean getAudioOutputMode() {
      return mAudioOutputMode;
   }

   public static void setRecordDuration(int durationIndex) {

      Log.d(LOGTAG, "setRecordDuration "+durationIndex);
      switch( durationIndex ) {

      case 0: mRecordDuration = RECORD_DUR_INDEX_0_VAL; break;
      case 1: mRecordDuration = RECORD_DUR_INDEX_1_VAL; break;
      case 2: mRecordDuration = RECORD_DUR_INDEX_2_VAL; break;
      case 3: mRecordDuration = RECORD_DUR_INDEX_3_VAL; break;
      default:
        {
           Log.d(LOGTAG, "Invalid: durationIndex "+durationIndex);
        }

      }
      return;
   }

   public static int getRecordDuration() {
      return mRecordDuration;
   }


   public static void setAutoAFSwitch(boolean bAFAutoSwitch) {
      mAFAutoSwitch = bAFAutoSwitch;
   }

   public static boolean getAutoAFSwitch() {
      return mAFAutoSwitch;
   }
}