mirror of
https://github.com/DSheirer/sdrtrunk.git
synced 2026-11-10 15:47:25 -05:00
862 lines
20 KiB
Java
862 lines
20 KiB
Java
/*******************************************************************************
|
|
* SDR Trunk
|
|
* Copyright (C) 2014 Dennis Sheirer
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>
|
|
******************************************************************************/
|
|
package settings;
|
|
|
|
import java.awt.Color;
|
|
import java.awt.Image;
|
|
import java.io.File;
|
|
import java.io.FileInputStream;
|
|
import java.io.FileOutputStream;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.io.OutputStream;
|
|
import java.nio.file.Files;
|
|
import java.nio.file.Path;
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.Iterator;
|
|
|
|
import javax.swing.ImageIcon;
|
|
import javax.xml.bind.JAXBContext;
|
|
import javax.xml.bind.JAXBException;
|
|
import javax.xml.bind.Marshaller;
|
|
import javax.xml.bind.Unmarshaller;
|
|
|
|
import map.DefaultIcon;
|
|
import map.MapIcon;
|
|
|
|
import org.jdesktop.swingx.mapviewer.GeoPosition;
|
|
import org.slf4j.Logger;
|
|
import org.slf4j.LoggerFactory;
|
|
|
|
import properties.SystemProperties;
|
|
import settings.ColorSetting.ColorSettingName;
|
|
import source.recording.RecordingConfiguration;
|
|
import source.tuner.TunerConfiguration;
|
|
import source.tuner.TunerConfigurationAssignment;
|
|
import source.tuner.TunerType;
|
|
import source.tuner.airspy.AirspyTunerConfiguration;
|
|
import source.tuner.fcd.proV1.FCD1TunerConfiguration;
|
|
import source.tuner.fcd.proplusV2.FCD2TunerConfiguration;
|
|
import source.tuner.hackrf.HackRFTunerConfiguration;
|
|
import source.tuner.rtl.e4k.E4KTunerConfiguration;
|
|
import source.tuner.rtl.r820t.R820TTunerConfiguration;
|
|
|
|
public class SettingsManager
|
|
{
|
|
private final static Logger mLog =
|
|
LoggerFactory.getLogger( SettingsManager.class );
|
|
|
|
private Settings mSettings = new Settings();
|
|
|
|
private ArrayList<SettingChangeListener> mListeners =
|
|
new ArrayList<SettingChangeListener>();
|
|
|
|
public static final String DEFAULT_ICON = "No Icon";
|
|
public String mCurrentDefaultIconName = DEFAULT_ICON;
|
|
public static final int DEFAULT_ICON_SIZE = 12;
|
|
|
|
private HashMap<String,MapIcon> mIcons = new HashMap<String,MapIcon>();
|
|
|
|
private HashMap<String,ImageIcon> mResizedIcons =
|
|
new HashMap<String,ImageIcon>();
|
|
|
|
public SettingsManager()
|
|
{
|
|
init();
|
|
}
|
|
|
|
/**
|
|
* Loads settings from the current settings file, or the default settings file,
|
|
* as specified in the current SDRTrunk system settings
|
|
*/
|
|
private void init()
|
|
{
|
|
SystemProperties props = SystemProperties.getInstance();
|
|
|
|
Path settingsFolder = props.getApplicationFolder( "settings" );
|
|
|
|
String defaultSettingsFile =
|
|
props.get( "settings.defaultFilename", "settings.xml" );
|
|
|
|
String settingsFile =
|
|
props.get( "settings.currentFilename", defaultSettingsFile );
|
|
|
|
load( settingsFolder.resolve( settingsFile ) );
|
|
|
|
refreshIcons();
|
|
}
|
|
|
|
/**
|
|
* Reloads the icon hash map, and sets up the default iconology. If the
|
|
* saved default icon name is not part of the current set of icons, we
|
|
* set the default icon to the standard system default name, which should
|
|
* be guaranteed to be available.
|
|
*/
|
|
public void refreshIcons()
|
|
{
|
|
mIcons.clear();
|
|
|
|
mCurrentDefaultIconName = DEFAULT_ICON;
|
|
|
|
DefaultIcon defaultIcon = getDefaultIcon();
|
|
|
|
ArrayList<MapIcon> icons = mSettings.getMapIcons();
|
|
icons.addAll( getStandardIcons() );
|
|
|
|
for( MapIcon icon: icons )
|
|
{
|
|
mIcons.put( icon.getName(), icon );
|
|
|
|
if( icon.getName().contentEquals( defaultIcon.getName() ) )
|
|
{
|
|
mCurrentDefaultIconName = defaultIcon.getName();
|
|
icon.setDefaultIcon( true );
|
|
}
|
|
else
|
|
{
|
|
icon.setDefaultIcon( false );
|
|
}
|
|
}
|
|
}
|
|
|
|
public Settings getSettings()
|
|
{
|
|
return mSettings;
|
|
}
|
|
|
|
public void setSettings( Settings settings )
|
|
{
|
|
mSettings = settings;
|
|
}
|
|
|
|
public Setting getSetting( String name )
|
|
{
|
|
return mSettings.getSetting( name );
|
|
}
|
|
|
|
/**
|
|
* Returns the current setting, or if the setting doesn't exist
|
|
* returns a newly created setting with the specified parameters
|
|
*/
|
|
public ColorSetting getColorSetting( ColorSettingName name )
|
|
{
|
|
ColorSetting setting = mSettings.getColorSetting( name );
|
|
|
|
if( setting == null )
|
|
{
|
|
setting = new ColorSetting( name );
|
|
|
|
addSetting( setting );
|
|
}
|
|
|
|
return setting;
|
|
}
|
|
|
|
/**
|
|
* Fetches the current setting and applies the parameter(s) to it. Creates
|
|
* the setting if it does not exist
|
|
*/
|
|
public void setColorSetting( ColorSettingName name, Color color )
|
|
{
|
|
ColorSetting setting = getColorSetting( name );
|
|
|
|
setting.setColor( color );
|
|
|
|
broadcastSettingChange( setting );
|
|
|
|
save();
|
|
}
|
|
|
|
public void resetColorSetting( ColorSettingName name )
|
|
{
|
|
setColorSetting( name, name.getDefaultColor() );
|
|
}
|
|
|
|
public void resetAllColorSettings()
|
|
{
|
|
for( ColorSetting color: mSettings.getColorSettings() )
|
|
{
|
|
resetColorSetting( color.getColorSettingName() );
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the current setting, or if the setting doesn't exist
|
|
* returns a newly created setting with the specified parameters
|
|
*/
|
|
public FileSetting getFileSetting( String name, String defaultPath )
|
|
{
|
|
FileSetting setting = mSettings.getFileSetting( name );
|
|
|
|
if( setting == null )
|
|
{
|
|
setting = new FileSetting( name, defaultPath );
|
|
|
|
addSetting( setting );
|
|
}
|
|
|
|
return setting;
|
|
}
|
|
|
|
/**
|
|
* Fetches the current setting and applies the parameter(s) to it. Creates
|
|
* the setting if it does not exist
|
|
*/
|
|
public void setFileSetting( String name, String path )
|
|
{
|
|
FileSetting setting = getFileSetting( name, path );
|
|
|
|
setting.setPath( path );
|
|
|
|
broadcastSettingChange( setting );
|
|
|
|
save();
|
|
}
|
|
|
|
public MapIcon[] getMapIcons()
|
|
{
|
|
MapIcon[] returnIcons = new MapIcon[mIcons.values().size() ];
|
|
|
|
return mIcons.values().toArray( returnIcons );
|
|
}
|
|
|
|
private ArrayList<MapIcon> getStandardIcons()
|
|
{
|
|
ArrayList<MapIcon> icons = new ArrayList<MapIcon>();
|
|
|
|
MapIcon defaultIcon = new MapIcon( DEFAULT_ICON, "images/no_icon.png", false );
|
|
icons.add( defaultIcon );
|
|
|
|
MapIcon ambulance =
|
|
new MapIcon( "Ambulance", "images/ambulance.png", false );
|
|
icons.add( ambulance );
|
|
|
|
MapIcon blockTruck =
|
|
new MapIcon( "Block Truck", "images/concrete_block_truck.png", false );
|
|
icons.add( blockTruck );
|
|
|
|
MapIcon cwid = new MapIcon( "CWID", "images/cwid.png", false );
|
|
icons.add( cwid );
|
|
|
|
MapIcon dispatcher =
|
|
new MapIcon( "Dispatcher", "images/dispatcher.png", false );
|
|
icons.add( dispatcher );
|
|
|
|
MapIcon dumpTruck =
|
|
new MapIcon( "Dump Truck", "images/dump_truck_red.png", false );
|
|
icons.add( dumpTruck );
|
|
|
|
MapIcon fireTruck =
|
|
new MapIcon( "Fire Truck", "images/fire_truck.png", false );
|
|
icons.add( fireTruck );
|
|
|
|
MapIcon garbageTruck =
|
|
new MapIcon( "Garbage Truck", "images/garbage_truck.png", false );
|
|
icons.add( garbageTruck );
|
|
|
|
MapIcon loader = new MapIcon( "Loader", "images/loader.png", false );
|
|
icons.add( loader );
|
|
|
|
MapIcon police =
|
|
new MapIcon( "Police", "images/police.png", false );
|
|
icons.add( police );
|
|
|
|
MapIcon propaneTruck =
|
|
new MapIcon( "Propane Truck", "images/propane_truck.png", false );
|
|
icons.add( propaneTruck );
|
|
|
|
MapIcon rescueTruck =
|
|
new MapIcon( "Rescue Truck", "images/rescue_truck.png", false );
|
|
icons.add( rescueTruck );
|
|
|
|
MapIcon schoolBus =
|
|
new MapIcon( "School Bus", "images/school_bus.png", false );
|
|
icons.add( schoolBus );
|
|
|
|
MapIcon taxi =
|
|
new MapIcon( "Taxi", "images/taxi.png", false );
|
|
icons.add( taxi );
|
|
|
|
MapIcon train =
|
|
new MapIcon( "Train", "images/train.png", false );
|
|
icons.add( train );
|
|
|
|
MapIcon transportBus =
|
|
new MapIcon( "Transport Bus", "images/opt_bus.png", false );
|
|
icons.add( transportBus );
|
|
|
|
MapIcon van =
|
|
new MapIcon( "Van", "images/van.png", false );
|
|
icons.add( van );
|
|
|
|
return icons;
|
|
}
|
|
|
|
/**
|
|
* Deletes the map icon
|
|
*/
|
|
public void deleteMapIcon( MapIcon icon )
|
|
{
|
|
MapIcon existing = mIcons.get( icon.getName() );
|
|
|
|
if( existing != null )
|
|
{
|
|
mIcons.remove( icon.getName() );
|
|
|
|
mSettings.removeSetting( existing );
|
|
|
|
broadcastSettingDeleted( existing );
|
|
|
|
save();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adds the icon, overwriting any existing icon with the same name
|
|
* @param icon
|
|
*/
|
|
public void addMapIcon( MapIcon icon )
|
|
{
|
|
MapIcon existing = mIcons.get( icon.getName() );
|
|
|
|
if( existing == null )
|
|
{
|
|
MapIcon newIcon = new MapIcon( icon.getName(), icon.getPath() );
|
|
mIcons.put( newIcon.getName(), newIcon );
|
|
addSetting( newIcon );
|
|
}
|
|
else
|
|
{
|
|
existing.setName( icon.getName() );
|
|
existing.setPath( icon.getPath() );
|
|
broadcastSettingChange( existing );
|
|
save();
|
|
}
|
|
}
|
|
|
|
public void updatMapIcon( MapIcon icon, String newName, String newPath )
|
|
{
|
|
MapIcon existing = mSettings.getMapIcon( icon.getName() );
|
|
|
|
if( existing == null )
|
|
{
|
|
addMapIcon( new MapIcon( newName, newPath ) );
|
|
}
|
|
else
|
|
{
|
|
existing.setName( newName );
|
|
existing.setPath( newPath );
|
|
broadcastSettingChange( existing );
|
|
save();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns named map icon scaled to height, if necessary.
|
|
* @param name - name of icon
|
|
* @param heigh - height of icon in pixels
|
|
*
|
|
* @return - ImageIcon or null
|
|
*/
|
|
public ImageIcon getImageIcon( String name, int height )
|
|
{
|
|
if( name != null )
|
|
{
|
|
String mergedName = name + height;
|
|
|
|
if( mResizedIcons.containsKey( mergedName ) )
|
|
{
|
|
return mResizedIcons.get( mergedName );
|
|
}
|
|
|
|
MapIcon mapIcon = mIcons.get( name );
|
|
|
|
if( mapIcon != null )
|
|
{
|
|
if( mapIcon.getImageIcon().getIconHeight() > height )
|
|
{
|
|
ImageIcon scaled = getScaledIcon( mapIcon.getImageIcon(), height );
|
|
|
|
mResizedIcons.put( mergedName, scaled );
|
|
|
|
return scaled;
|
|
}
|
|
else
|
|
{
|
|
mResizedIcons.put( mergedName, mapIcon.getImageIcon() );
|
|
}
|
|
}
|
|
|
|
/* Use the default Icon */
|
|
String mergedDefault = mCurrentDefaultIconName + height;
|
|
|
|
if( mResizedIcons.containsKey( mergedDefault ) )
|
|
{
|
|
return mResizedIcons.get( mergedDefault );
|
|
}
|
|
else
|
|
{
|
|
MapIcon defaultIcon = mIcons.get( mCurrentDefaultIconName );
|
|
|
|
if( defaultIcon != null )
|
|
{
|
|
if( defaultIcon.getImageIcon().getIconHeight() > height )
|
|
{
|
|
ImageIcon scaledDefault = getScaledIcon( defaultIcon.getImageIcon(), height );
|
|
mResizedIcons.put( mergedDefault, scaledDefault );
|
|
return scaledDefault;
|
|
}
|
|
else
|
|
{
|
|
mResizedIcons.put( mergedDefault, defaultIcon.getImageIcon() );
|
|
return defaultIcon.getImageIcon();
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Something happened ... the above should always return an icon */
|
|
mLog.error( "couldn't return an icon named [" + name + "] of heigh [" + height + "]" );
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public static ImageIcon getScaledIcon( ImageIcon original, int height )
|
|
{
|
|
double scale = (double)original.getIconHeight() / (double)height;
|
|
|
|
int scaledWidth = (int)( (double)original.getIconWidth() / scale );
|
|
|
|
Image scaledImage = original.getImage().getScaledInstance( scaledWidth,
|
|
height, java.awt.Image.SCALE_SMOOTH );
|
|
|
|
return new ImageIcon( scaledImage );
|
|
}
|
|
|
|
public MapIcon getMapIcon( String name )
|
|
{
|
|
if( mIcons.containsKey( name ) )
|
|
{
|
|
return mIcons.get( name );
|
|
}
|
|
|
|
/* Return the default */
|
|
if( mIcons.containsKey( mCurrentDefaultIconName ) )
|
|
{
|
|
return mIcons.get( mCurrentDefaultIconName );
|
|
}
|
|
|
|
/* Return the real default */
|
|
return mIcons.get( DEFAULT_ICON );
|
|
}
|
|
|
|
/**
|
|
* Returns the named map icon, or creates it with the default path
|
|
* @param name - name of the icon
|
|
* @param defaultPath - path to icon image file
|
|
* @return - map icon
|
|
*/
|
|
public MapIcon getMapIcon( String name, String defaultPath )
|
|
{
|
|
MapIcon icon = mSettings.getMapIcon( name );
|
|
|
|
if( icon == null )
|
|
{
|
|
icon = new MapIcon( name, defaultPath );
|
|
|
|
addSetting( icon );
|
|
}
|
|
|
|
return icon;
|
|
}
|
|
|
|
public DefaultIcon getDefaultIcon()
|
|
{
|
|
DefaultIcon icon = mSettings.getDefaultIcon();
|
|
|
|
if( icon == null )
|
|
{
|
|
icon = new DefaultIcon( DEFAULT_ICON );
|
|
|
|
addSetting( icon );
|
|
}
|
|
|
|
return icon;
|
|
}
|
|
|
|
public void setDefaultIcon( MapIcon icon )
|
|
{
|
|
if( mIcons.containsValue( icon ) )
|
|
{
|
|
MapIcon currentDefault = mIcons.get( mCurrentDefaultIconName );
|
|
|
|
currentDefault.setDefaultIcon( false );
|
|
|
|
icon.setDefaultIcon( true );
|
|
|
|
mCurrentDefaultIconName = icon.getName();
|
|
|
|
DefaultIcon defaultIconSetting = getDefaultIcon();
|
|
|
|
defaultIconSetting.setName( icon.getName() );
|
|
|
|
save();
|
|
|
|
broadcastSettingChange( defaultIconSetting );
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adds the setting and stores the set of settings
|
|
* @param setting
|
|
*/
|
|
private void addSetting( Setting setting )
|
|
{
|
|
mSettings.addSetting( setting );
|
|
|
|
save();
|
|
|
|
broadcastSettingChange( setting );
|
|
}
|
|
|
|
public ArrayList<RecordingConfiguration> getRecordingConfigurations()
|
|
{
|
|
return mSettings.getRecordingConfigurations();
|
|
}
|
|
|
|
public void addRecordingConfiguration( RecordingConfiguration config )
|
|
{
|
|
mSettings.addRecordingConfiguration( config );
|
|
save();
|
|
}
|
|
|
|
public void removeRecordingConfiguration( RecordingConfiguration config )
|
|
{
|
|
mSettings.removeRecordingConfiguration( config );
|
|
save();
|
|
}
|
|
|
|
public ArrayList<TunerConfiguration> getTunerConfigurations( TunerType type )
|
|
{
|
|
ArrayList<TunerConfiguration> configs = getSettings()
|
|
.getTunerConfigurations( type );
|
|
|
|
if( configs.isEmpty() )
|
|
{
|
|
configs.add( addNewTunerConfiguration( type, "Default" ) );
|
|
}
|
|
|
|
return configs;
|
|
}
|
|
|
|
public void deleteTunerConfiguration( TunerConfiguration config )
|
|
{
|
|
getSettings().removeTunerConfiguration( config );
|
|
save();
|
|
}
|
|
|
|
public TunerConfiguration addNewTunerConfiguration( TunerType type,
|
|
String name )
|
|
{
|
|
switch( type )
|
|
{
|
|
case AIRSPY_R820T:
|
|
AirspyTunerConfiguration airspyConfig =
|
|
new AirspyTunerConfiguration( name );
|
|
|
|
getSettings().addTunerConfiguration( airspyConfig );
|
|
|
|
save();
|
|
return airspyConfig;
|
|
case ELONICS_E4000:
|
|
E4KTunerConfiguration e4KConfig =
|
|
new E4KTunerConfiguration( name );
|
|
|
|
getSettings().addTunerConfiguration( e4KConfig );
|
|
|
|
save();
|
|
return e4KConfig;
|
|
case FUNCUBE_DONGLE_PRO:
|
|
FCD1TunerConfiguration config =
|
|
new FCD1TunerConfiguration( name );
|
|
|
|
getSettings().addTunerConfiguration( config );
|
|
|
|
save();
|
|
|
|
return config;
|
|
case FUNCUBE_DONGLE_PRO_PLUS:
|
|
FCD2TunerConfiguration configPlus =
|
|
new FCD2TunerConfiguration( name );
|
|
|
|
getSettings().addTunerConfiguration( configPlus );
|
|
|
|
save();
|
|
|
|
return configPlus;
|
|
case HACKRF:
|
|
HackRFTunerConfiguration hackConfig =
|
|
new HackRFTunerConfiguration( name );
|
|
|
|
getSettings().addTunerConfiguration( hackConfig );
|
|
|
|
save();
|
|
|
|
return hackConfig;
|
|
case RAFAELMICRO_R820T:
|
|
R820TTunerConfiguration r820TConfig =
|
|
new R820TTunerConfiguration( name );
|
|
|
|
getSettings().addTunerConfiguration( r820TConfig );
|
|
|
|
save();
|
|
|
|
return r820TConfig;
|
|
default:
|
|
throw new IllegalArgumentException( "tuner type is unrecognized [" +
|
|
type.toString() + "]" );
|
|
}
|
|
}
|
|
|
|
public TunerConfigurationAssignment getSelectedTunerConfiguration(
|
|
TunerType type, String address )
|
|
{
|
|
return mSettings.getConfigurationAssignment( type, address );
|
|
}
|
|
|
|
public void setSelectedTunerConfiguration( TunerType type,
|
|
String address, TunerConfiguration config )
|
|
{
|
|
mSettings.setConfigurationAssignment( type, address, config.getName() );
|
|
|
|
save();
|
|
}
|
|
|
|
public MapViewSetting getMapViewSetting( String name, GeoPosition position, int zoom )
|
|
{
|
|
MapViewSetting loc = mSettings.getMapViewSetting( name );
|
|
|
|
if( loc != null )
|
|
{
|
|
return loc;
|
|
}
|
|
else
|
|
{
|
|
MapViewSetting newLoc = new MapViewSetting( name, position, zoom );
|
|
|
|
addSetting( newLoc );
|
|
|
|
return newLoc;
|
|
}
|
|
}
|
|
|
|
public void setMapViewSetting( String name, GeoPosition position, int zoom )
|
|
{
|
|
MapViewSetting loc = getMapViewSetting( name, position, zoom );
|
|
|
|
loc.setGeoPosition( position );
|
|
loc.setZoom( zoom );
|
|
|
|
save();
|
|
}
|
|
|
|
public void save()
|
|
{
|
|
JAXBContext context = null;
|
|
|
|
SystemProperties props = SystemProperties.getInstance();
|
|
|
|
Path settingsPath = props.getApplicationFolder( "settings" );
|
|
|
|
String settingsDefault = props.get( "settings.defaultFilename",
|
|
"settings.xml" );
|
|
|
|
String settingsCurrent = props.get( "settings.currentFilename",
|
|
settingsDefault );
|
|
|
|
Path filePath = settingsPath.resolve( settingsCurrent );
|
|
|
|
File outputFile = new File( filePath.toString() );
|
|
|
|
try
|
|
{
|
|
if( !outputFile.exists() )
|
|
{
|
|
outputFile.createNewFile();
|
|
}
|
|
}
|
|
catch( Exception e )
|
|
{
|
|
mLog.error( "couldn't create file to save settings [" + filePath.toString() + "]", e );
|
|
}
|
|
|
|
OutputStream out = null;
|
|
|
|
try
|
|
{
|
|
out = new FileOutputStream( outputFile );
|
|
|
|
try
|
|
{
|
|
context = JAXBContext.newInstance( Settings.class );
|
|
|
|
Marshaller m = context.createMarshaller();
|
|
|
|
m.setProperty( Marshaller.JAXB_FORMATTED_OUTPUT, true );
|
|
|
|
m.marshal( mSettings, out );
|
|
}
|
|
catch ( JAXBException e )
|
|
{
|
|
mLog.error( "jaxb exception while saving settings", e );
|
|
}
|
|
}
|
|
catch ( Exception e )
|
|
{
|
|
mLog.error( "couldn't open outputstream to save settings [" + filePath.toString() + "]" );
|
|
}
|
|
finally
|
|
{
|
|
if( out != null )
|
|
{
|
|
try
|
|
{
|
|
out.close();
|
|
}
|
|
catch ( IOException e )
|
|
{
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Erases current settings and loads settings from the settingsPath filename,
|
|
* if it exists.
|
|
*/
|
|
public void load( Path settingsPath )
|
|
{
|
|
if( Files.exists( settingsPath ) )
|
|
{
|
|
mLog.info( "loading settings file [" + settingsPath.toString() + "]" );
|
|
|
|
JAXBContext context = null;
|
|
|
|
InputStream in = null;
|
|
|
|
try
|
|
{
|
|
in = new FileInputStream( settingsPath.toString() );
|
|
|
|
try
|
|
{
|
|
context = JAXBContext.newInstance( Settings.class );
|
|
|
|
Unmarshaller m = context.createUnmarshaller();
|
|
|
|
mSettings = (Settings)m.unmarshal( in );
|
|
}
|
|
catch ( JAXBException e )
|
|
{
|
|
mLog.error( "jaxb exception while loading " +
|
|
"settings", e );
|
|
}
|
|
}
|
|
catch ( Exception e )
|
|
{
|
|
mLog.error( "coulcn't open inputstream to " +
|
|
"load settings [" + settingsPath.toString() + "]", e );
|
|
}
|
|
finally
|
|
{
|
|
if( in != null )
|
|
{
|
|
try
|
|
{
|
|
in.close();
|
|
}
|
|
catch ( IOException e )
|
|
{
|
|
mLog.error( "exception while closing " +
|
|
"the settings file inputstream reader", e );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
mLog.info( "settings does not exist [" + settingsPath.toString() + "]" );
|
|
}
|
|
|
|
if( mSettings == null )
|
|
{
|
|
mSettings = new Settings();
|
|
}
|
|
}
|
|
|
|
public void broadcastSettingChange( Setting setting )
|
|
{
|
|
Iterator<SettingChangeListener> it = mListeners.iterator();
|
|
|
|
while( it.hasNext() )
|
|
{
|
|
SettingChangeListener listener = it.next();
|
|
|
|
if( listener == null )
|
|
{
|
|
it.remove();
|
|
}
|
|
else
|
|
{
|
|
listener.settingChanged( setting );
|
|
}
|
|
}
|
|
}
|
|
|
|
public void broadcastSettingDeleted( Setting setting )
|
|
{
|
|
Iterator<SettingChangeListener> it = mListeners.iterator();
|
|
|
|
while( it.hasNext() )
|
|
{
|
|
SettingChangeListener listener = it.next();
|
|
|
|
if( listener == null )
|
|
{
|
|
it.remove();
|
|
}
|
|
else
|
|
{
|
|
listener.settingDeleted( setting );
|
|
}
|
|
}
|
|
}
|
|
|
|
public void addListener( SettingChangeListener listener )
|
|
{
|
|
mListeners.add( listener );
|
|
}
|
|
|
|
public void removeListener( SettingChangeListener listener )
|
|
{
|
|
mListeners.remove( listener );
|
|
}
|
|
}
|