/* * 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.caf.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 = "FmSharedPreferences"; 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 final String AUDIO_OUTPUT_MODE = "audio_output_mode"; private static Map mNameMap = new HashMap(); private static List mListOfPlists = new ArrayList(); 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 = ""; public 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; private static int mLastAudioMode = -1; 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 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 (); } if (tagList[index].add(s)) num_tags++; } } public static void clearTags() { for(int i = 0; i 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 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 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); mAudioOutputMode = sp.getBoolean(AUDIO_OUTPUT_MODE, 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.putBoolean(AUDIO_OUTPUT_MODE, mAudioOutputMode); 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 int getFrequencyStepSize() { return mFrequencyBand_Stepsize; } 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(87500); mFMConfiguration.setUpperLimit(108000); 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 int getLastAudioMode() { return mLastAudioMode; } public static void setLastAudioMode(int audiomode) { mLastAudioMode = audiomode; } 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; } }