diff options
Diffstat (limited to 'fmapp2/src/com/caf/fmradio/FmSharedPreferences.java')
| -rw-r--r-- | fmapp2/src/com/caf/fmradio/FmSharedPreferences.java | 1114 |
1 files changed, 1114 insertions, 0 deletions
diff --git a/fmapp2/src/com/caf/fmradio/FmSharedPreferences.java b/fmapp2/src/com/caf/fmradio/FmSharedPreferences.java new file mode 100644 index 0000000..db215e8 --- /dev/null +++ b/fmapp2/src/com/caf/fmradio/FmSharedPreferences.java @@ -0,0 +1,1114 @@ +/* + * 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.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 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<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 = ""; + 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 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); + mAudioOutputMode = sp.getBoolean(AUDIO_OUTPUT_MODE, true); + /* Reset the Lists before reading the preferences */ + mListOfPlists.clear(); + + 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 */ + setCountry(sp.getInt(FMCONFIG_COUNTRY, 0)); + /* 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); + ed.putInt(LAST_RECORD_DURATION, mRecordDuration); + ed.putBoolean(LAST_AF_JUMP_VALUE, mAFAutoSwitch); + ed.commit(); + } + + public static void SetDefaults() { + mListIndex = 0; + mListOfPlists.clear(); + setCountry(REGIONAL_BAND_NORTH_AMERICA); + setRadioBand(0); + setChSpacing(0); + setEmphasis(0); + setRdsStd(0); + mFMConfiguration.setLowerLimit(87500); + mFMConfiguration.setUpperLimit(107900); + } + + 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; + } + } + 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); + } + + public static void setUpperLimit(int upLimit){ + mFMConfiguration.setUpperLimit(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 : 88000 TO 108000 IN 50 KHZ STEPS*/ + mFMConfiguration.setRadioBand(FmReceiver.FM_EU_BAND); + mFMConfiguration.setChSpacing(FmReceiver.FM_CHSPACE_50_KHZ); + mFMConfiguration.setLowerLimit(88000); + mFrequencyBand_Stepsize = 50; + 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; + } + 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; + } +} |