git.gag.com Git - fw/altos/blob - altoslib/AltosPreferences.java

   1 /*
   2  * Copyright © 2010 Keith Packard <keithp@keithp.com>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; version 2 of the License.
   7  *
   8  * This program is distributed in the hope that it will be useful, but
   9  * WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11  * General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along
  14  * with this program; if not, write to the Free Software Foundation, Inc.,
  15  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  16  */
  17
  18 package org.altusmetrum.AltosLib;
  19
  20 import java.io.*;
  21 import java.util.*;
  22 import java.text.*;
  23 import java.util.prefs.*;
  24 import java.util.concurrent.LinkedBlockingQueue;
  25 import java.awt.Component;
  26 import javax.swing.*;
  27 import javax.swing.filechooser.FileSystemView;
  28
  29 public class AltosPreferences {
  30         public static Preferences preferences;
  31
  32         /* logdir preference name */
  33         public final static String logdirPreference = "LOGDIR";
  34
  35         /* channel preference name */
  36         public final static String channelPreferenceFormat = "CHANNEL-%d";
  37
  38         /* frequency preference name */
  39         public final static String frequencyPreferenceFormat = "FREQUENCY-%d";
  40
  41         /* telemetry format preference name */
  42         public final static String telemetryPreferenceFormat = "TELEMETRY-%d";
  43
  44         /* voice preference name */
  45         public final static String voicePreference = "VOICE";
  46
  47         /* callsign preference name */
  48         public final static String callsignPreference = "CALLSIGN";
  49
  50         /* firmware directory preference name */
  51         public final static String firmwaredirPreference = "FIRMWARE";
  52
  53         /* serial debug preference name */
  54         public final static String serialDebugPreference = "SERIAL-DEBUG";
  55
  56         /* scanning telemetry preferences name */
  57         public final static String scanningTelemetryPreference = "SCANNING-TELEMETRY";
  58
  59         /* Launcher serial preference name */
  60         public final static String launcherSerialPreference = "LAUNCHER-SERIAL";
  61
  62         /* Launcher channel preference name */
  63         public final static String launcherChannelPreference = "LAUNCHER-CHANNEL";
  64
  65         /* Default logdir is ~/TeleMetrum */
  66         public final static String logdirName = "TeleMetrum";
  67
  68         /* Log directory */
  69         public static File logdir;
  70
  71         /* Map directory -- hangs of logdir */
  72         public static File mapdir;
  73
  74         /* Frequency (map serial to frequency) */
  75         public static Hashtable<Integer, Double> frequencies;
  76
  77         /* Telemetry (map serial to telemetry format) */
  78         public static Hashtable<Integer, Integer> telemetries;
  79
  80         /* Voice preference */
  81         public static boolean voice;
  82
  83         /* Callsign preference */
  84         public static String callsign;
  85
  86         /* Firmware directory */
  87         public static File firmwaredir;
  88
  89         /* Scanning telemetry */
  90         public static int scanning_telemetry;
  91
  92         /* List of frequencies */
  93         public final static String common_frequencies_node_name = "COMMON-FREQUENCIES";
  94         public static AltosFrequency[] common_frequencies;
  95
  96         public final static String      frequency_count = "COUNT";
  97         public final static String      frequency_format = "FREQUENCY-%d";
  98         public final static String      description_format = "DESCRIPTION-%d";
  99
 100         public static AltosFrequency[] load_common_frequencies() {
 101                 AltosFrequency[] frequencies = null;
 102                 boolean existing = false;
 103                 try {
 104                         existing = preferences.nodeExists(common_frequencies_node_name);
 105                 } catch (BackingStoreException be) {
 106                         existing = false;
 107                 }
 108                 if (existing) {
 109                         Preferences     node = preferences.node(common_frequencies_node_name);
 110                         int             count = node.getInt(frequency_count, 0);
 111
 112                         frequencies = new AltosFrequency[count];
 113                         for (int i = 0; i < count; i++) {
 114                                 double  frequency;
 115                                 String  description;
 116
 117                                 frequency = node.getDouble(String.format(frequency_format, i), 0.0);
 118                                 description = node.get(String.format(description_format, i), null);
 119                                 frequencies[i] = new AltosFrequency(frequency, description);
 120                         }
 121                 } else {
 122                         frequencies = new AltosFrequency[10];
 123                         for (int i = 0; i < 10; i++) {
 124                                 frequencies[i] = new AltosFrequency(434.550 + i * .1,
 125                                                                            String.format("Channel %d", i));
 126                         }
 127                 }
 128                 return frequencies;
 129         }
 130
 131         public static void save_common_frequencies(AltosFrequency[] frequencies) {
 132                 Preferences     node = preferences.node(common_frequencies_node_name);
 133
 134                 node.putInt(frequency_count, frequencies.length);
 135                 for (int i = 0; i < frequencies.length; i++) {
 136                         node.putDouble(String.format(frequency_format, i), frequencies[i].frequency);
 137                         node.put(String.format(description_format, i), frequencies[i].description);
 138                 }
 139         }
 140         public static int launcher_serial;
 141
 142         public static int launcher_channel;
 143
 144         public static void init() {
 145                 preferences = Preferences.userRoot().node("/org/altusmetrum/altosui");
 146
 147                 /* Initialize logdir from preferences */
 148                 String logdir_string = preferences.get(logdirPreference, null);
 149                 if (logdir_string != null)
 150                         logdir = new File(logdir_string);
 151                 else {
 152                         /* Use the file system view default directory */
 153                         logdir = new File(FileSystemView.getFileSystemView().getDefaultDirectory(), logdirName);
 154                         if (!logdir.exists())
 155                                 logdir.mkdirs();
 156                 }
 157                 mapdir = new File(logdir, "maps");
 158                 if (!mapdir.exists())
 159                         mapdir.mkdirs();
 160
 161                 frequencies = new Hashtable<Integer, Double>();
 162
 163                 telemetries = new Hashtable<Integer,Integer>();
 164
 165                 voice = preferences.getBoolean(voicePreference, true);
 166
 167                 callsign = preferences.get(callsignPreference,"N0CALL");
 168
 169                 scanning_telemetry = preferences.getInt(scanningTelemetryPreference,(1 << AltosLib.ao_telemetry_standard));
 170
 171                 launcher_serial = preferences.getInt(launcherSerialPreference, 0);
 172
 173                 launcher_channel = preferences.getInt(launcherChannelPreference, 0);
 174
 175                 String firmwaredir_string = preferences.get(firmwaredirPreference, null);
 176                 if (firmwaredir_string != null)
 177                         firmwaredir = new File(firmwaredir_string);
 178                 else
 179                         firmwaredir = null;
 180
 181                 common_frequencies = load_common_frequencies();
 182
 183         }
 184
 185         static { init(); }
 186
 187         public static void flush_preferences() {
 188                 try {
 189                         preferences.flush();
 190                 } catch (BackingStoreException ee) {
 191 /*
 192                         if (component != null)
 193                                 JOptionPane.showMessageDialog(component,
 194                                                               preferences.absolutePath(),
 195                                                               "Cannot save prefernces",
 196                                                               JOptionPane.ERROR_MESSAGE);
 197                         else
 198 */
 199                                 System.err.printf("Cannot save preferences\n");
 200                 }
 201         }
 202
 203         public static void set_logdir(File new_logdir) {
 204                 logdir = new_logdir;
 205                 mapdir = new File(logdir, "maps");
 206                 if (!mapdir.exists())
 207                         mapdir.mkdirs();
 208                 synchronized (preferences) {
 209                         preferences.put(logdirPreference, logdir.getPath());
 210                         flush_preferences();
 211                 }
 212         }
 213
 214         public static File logdir() {
 215                 return logdir;
 216         }
 217
 218         public static File mapdir() {
 219                 return mapdir;
 220         }
 221
 222         public static void set_frequency(int serial, double new_frequency) {
 223                 frequencies.put(serial, new_frequency);
 224                 synchronized (preferences) {
 225                         preferences.putDouble(String.format(frequencyPreferenceFormat, serial), new_frequency);
 226                         flush_preferences();
 227                 }
 228         }
 229
 230         public static double frequency(int serial) {
 231                 if (frequencies.containsKey(serial))
 232                         return frequencies.get(serial);
 233                 double frequency = preferences.getDouble(String.format(frequencyPreferenceFormat, serial), 0);
 234                 if (frequency == 0.0) {
 235                         int channel = preferences.getInt(String.format(channelPreferenceFormat, serial), 0);
 236                         frequency = AltosConvert.radio_channel_to_frequency(channel);
 237                 }
 238                 frequencies.put(serial, frequency);
 239                 return frequency;
 240         }
 241
 242         public static void set_telemetry(int serial, int new_telemetry) {
 243                 telemetries.put(serial, new_telemetry);
 244                 synchronized (preferences) {
 245                         preferences.putInt(String.format(telemetryPreferenceFormat, serial), new_telemetry);
 246                         flush_preferences();
 247                 }
 248         }
 249
 250         public static int telemetry(int serial) {
 251                 if (telemetries.containsKey(serial))
 252                         return telemetries.get(serial);
 253                 int telemetry = preferences.getInt(String.format(telemetryPreferenceFormat, serial),
 254                                                    AltosLib.ao_telemetry_standard);
 255                 telemetries.put(serial, telemetry);
 256                 return telemetry;
 257         }
 258
 259         public static void set_scanning_telemetry(int new_scanning_telemetry) {
 260                 scanning_telemetry = new_scanning_telemetry;
 261                 synchronized (preferences) {
 262                         preferences.putInt(scanningTelemetryPreference, scanning_telemetry);
 263                         flush_preferences();
 264                 }
 265         }
 266
 267         public static int scanning_telemetry() {
 268                 return scanning_telemetry;
 269         }
 270
 271         public static void set_voice(boolean new_voice) {
 272                 voice = new_voice;
 273                 synchronized (preferences) {
 274                         preferences.putBoolean(voicePreference, voice);
 275                         flush_preferences();
 276                 }
 277         }
 278
 279         public static boolean voice() {
 280                 return voice;
 281         }
 282
 283         public static void set_callsign(String new_callsign) {
 284                 callsign = new_callsign;
 285                 synchronized(preferences) {
 286                         preferences.put(callsignPreference, callsign);
 287                         flush_preferences();
 288                 }
 289         }
 290
 291         public static String callsign() {
 292                 return callsign;
 293         }
 294
 295         public static void set_firmwaredir(File new_firmwaredir) {
 296                 firmwaredir = new_firmwaredir;
 297                 synchronized (preferences) {
 298                         preferences.put(firmwaredirPreference, firmwaredir.getPath());
 299                         flush_preferences();
 300                 }
 301         }
 302
 303         public static File firmwaredir() {
 304                 return firmwaredir;
 305         }
 306
 307         public static void set_launcher_serial(int new_launcher_serial) {
 308                 launcher_serial = new_launcher_serial;
 309                 System.out.printf("set launcher serial to %d\n", new_launcher_serial);
 310                 synchronized (preferences) {
 311                         preferences.putInt(launcherSerialPreference, launcher_serial);
 312                         flush_preferences();
 313                 }
 314         }
 315
 316         public static int launcher_serial() {
 317                 return launcher_serial;
 318         }
 319
 320         public static void set_launcher_channel(int new_launcher_channel) {
 321                 launcher_channel = new_launcher_channel;
 322                 System.out.printf("set launcher channel to %d\n", new_launcher_channel);
 323                 synchronized (preferences) {
 324                         preferences.putInt(launcherChannelPreference, launcher_channel);
 325                         flush_preferences();
 326                 }
 327         }
 328
 329         public static int launcher_channel() {
 330                 return launcher_channel;
 331         }
 332
 333         public static Preferences bt_devices() {
 334                 return preferences.node("bt_devices");
 335         }
 336
 337         public static AltosFrequency[] common_frequencies() {
 338                 return common_frequencies;
 339         }
 340
 341         public static void set_common_frequencies(AltosFrequency[] frequencies) {
 342                 common_frequencies = frequencies;
 343                 synchronized(preferences) {
 344                         save_common_frequencies(frequencies);
 345                         flush_preferences();
 346                 }
 347         }
 348
 349         public static void add_common_frequency(AltosFrequency frequency) {
 350                 AltosFrequency[]        new_frequencies = new AltosFrequency[common_frequencies.length + 1];
 351                 int                     i;
 352
 353                 for (i = 0; i < common_frequencies.length; i++) {
 354                         if (frequency.frequency == common_frequencies[i].frequency)
 355                                 return;
 356                         if (frequency.frequency < common_frequencies[i].frequency)
 357                                 break;
 358                         new_frequencies[i] = common_frequencies[i];
 359                 }
 360                 new_frequencies[i] = frequency;
 361                 for (; i < common_frequencies.length; i++)
 362                         new_frequencies[i+1] = common_frequencies[i];
 363                 set_common_frequencies(new_frequencies);
 364         }
 365 }