gov/nasa/worldwind/WorldWind.java

   1 /*
   2 Copyright (C) 2001, 2006 United States Government
   3 as represented by the Administrator of the
   4 National Aeronautics and Space Administration.
   5 All Rights Reserved.
   6 */
   7 package gov.nasa.worldwind;
   8
   9 import gov.nasa.worldwind.avlist.*;
  10 import gov.nasa.worldwind.cache.*;
  11 import gov.nasa.worldwind.exception.WWRuntimeException;
  12 import gov.nasa.worldwind.retrieve.RetrievalService;
  13 import gov.nasa.worldwind.util.*;
  14
  15 import java.util.logging.Level;
  16 import java.beans.PropertyChangeListener;
  17
  18 /**
  19  * @author Tom Gaskins
  20  * @version $Id: WorldWind.java 3735 2007-12-06 02:20:43Z tgaskins $
  21  */
  22 public final class WorldWind
  23 {
  24     public static final String SHUTDOWN_EVENT = "gov.nasa.worldwind.ShutDown";
  25
  26     private static WorldWind instance = new WorldWind();
  27
  28     private WWObjectImpl wwo;
  29     private MemoryCacheSet memoryCacheSet;
  30     private FileCache dataFileCache;
  31     private RetrievalService retrievalService;
  32     private TaskService taskService;
  33     private NetworkStatus networkStatus;
  34
  35     private WorldWind() // Singleton, prevent public instantiation.
  36     {
  37         this.initialize();
  38     }
  39
  40     private void initialize()
  41     {
  42         this.wwo = new WWObjectImpl();
  43         this.retrievalService = (RetrievalService) createConfigurationComponent(AVKey.RETRIEVAL_SERVICE_CLASS_NAME);
  44         this.taskService = (TaskService) createConfigurationComponent(AVKey.TASK_SERVICE_CLASS_NAME);
  45         this.dataFileCache = (FileCache) createConfigurationComponent(AVKey.DATA_FILE_CACHE_CLASS_NAME);
  46         this.memoryCacheSet = (MemoryCacheSet) createConfigurationComponent(AVKey.MEMORY_CACHE_SET_CLASS_NAME);
  47         this.networkStatus = (NetworkStatus) createConfigurationComponent(AVKey.NETWORK_STATUS_CLASS_NAME);
  48     }
  49
  50     private void dispose()
  51     {
  52         if (this.taskService != null)
  53             this.taskService.shutdown(true);
  54         if (this.retrievalService != null)
  55             this.retrievalService.shutdown(true);
  56         if (this.memoryCacheSet != null)
  57             this.memoryCacheSet.clear();
  58     }
  59
  60     /**
  61      * Reinitialize World Wind to its initial ready state. Shut down and restart all World Wind services and clear all
  62      * World Wind memory caches. Cache memory will be released at the next JVM garbage collection.
  63      * <p/>
  64      * Call this method to reduce World Wind's current resource usage to its initial, empty state. This is typically
  65      * required by applets when the user leaves the applet page.
  66      * <p/>
  67      * World Wind can continue to be used after calling this method. The state of any existing World Wind drawables is
  68      * subsequently indeterminate and they should be disposed.
  69      */
  70     public static synchronized void shutDown()
  71     {
  72         instance.wwo.firePropertyChange("gov.nasa.worldwind.ShutDown", null, -1);
  73         instance.dispose();
  74         instance = new WorldWind();
  75         instance.initialize();
  76     }
  77
  78     public static MemoryCacheSet getMemoryCacheSet()
  79     {
  80         return instance.memoryCacheSet;
  81     }
  82
  83     public static synchronized MemoryCache getMemoryCache(String key)
  84     {
  85         return instance.memoryCacheSet.getCache(key);
  86     }
  87
  88     public static FileCache getDataFileCache()
  89     {
  90         return instance.dataFileCache;
  91     }
  92
  93     public static RetrievalService getRetrievalService()
  94     {
  95         return instance.retrievalService;
  96     }
  97
  98     public static TaskService getTaskService()
  99     {
 100         return instance.taskService;
 101     }
 102
 103     public static NetworkStatus getNetworkStatus()
 104     {
 105         return instance.networkStatus;
 106     }
 107
 108     /**
 109      * Indicates whether World Wind will attempt to connect to the network to retrieve data or for other reasons.
 110      *
 111      * @return <code>true</code> if World Wind is in off-line mode, <code>false</code> if not.
 112      * @see NetworkStatus
 113      */
 114     public boolean isOfflineMode()
 115     {
 116         return getNetworkStatus().isOfflineMode();
 117     }
 118
 119     /**
 120      * Indicate whether World Wind should attempt to connect to the network to retrieve data or for other reasons. The
 121      * default value for this attribute is <code>false</code>, indicating that the network should be used.
 122      *
 123      * @param offlineMode <code>true</code> if World Wind should use the network, <code>false</code> otherwise
 124      * @see NetworkStatus
 125      */
 126     public void setOfflineMode(boolean offlineMode)
 127     {
 128         getNetworkStatus().setOfflineMode(offlineMode);
 129     }
 130
 131     /**
 132      * @param className the full name, including package names, of the component to create
 133      * @return the new component
 134      * @throws WWRuntimeException       if the <code>Object</code> could not be created
 135      * @throws IllegalArgumentException if <code>className</code> is null or zero length
 136      */
 137     public static Object createComponent(String className) throws WWRuntimeException
 138     {
 139         if (className == null || className.length() == 0)
 140         {
 141             Logging.logger().severe("WorldWind.ClassNameKeyNulZero");
 142             throw new IllegalArgumentException(Logging.getMessage("WorldWind.ClassNameKeyNulZero"));
 143         }
 144
 145         try
 146         {
 147             Class c = Class.forName(className);
 148             return c.newInstance();
 149         }
 150         catch (Exception e)
 151         {
 152             Logging.logger().log(Level.SEVERE, "WorldWind.ExceptionCreatingComponent", className);
 153             throw new WWRuntimeException(Logging.getMessage("WorldWind.ExceptionCreatingComponent", className), e);
 154         }
 155         catch (Throwable t)
 156         {
 157             Logging.logger().log(Level.SEVERE, "WorldWind.ErrorCreatingComponent", className);
 158             throw new WWRuntimeException(Logging.getMessage("WorldWind.ErrorCreatingComponent", className), t);
 159         }
 160     }
 161
 162     /**
 163      * @param classNameKey the key identifying the component
 164      * @return the new component
 165      * @throws IllegalStateException    if no name could be found which corresponds to <code>classNameKey</code>
 166      * @throws IllegalArgumentException if <code>classNameKey<code> is null
 167      * @throws WWRuntimeException       if the component could not be created
 168      */
 169     public static Object createConfigurationComponent(String classNameKey)
 170         throws IllegalStateException, IllegalArgumentException
 171     {
 172         if (classNameKey == null)
 173         {
 174             Logging.logger().severe("WorldWind.ClassNameKeyNulZero");
 175             throw new IllegalArgumentException(Logging.getMessage("WorldWind.ClassNameKeyNulZero"));
 176         }
 177
 178         String name = Configuration.getStringValue(classNameKey);
 179         if (name == null)
 180         {
 181             Logging.logger().log(Level.SEVERE, "WorldWind.NoClassNameInConfigurationForKey", classNameKey);
 182             throw new WWRuntimeException(
 183                 Logging.getMessage("WorldWind.NoClassNameInConfigurationForKey", classNameKey));
 184         }
 185
 186         try
 187         {
 188             return WorldWind.createComponent(name);
 189         }
 190         catch (Throwable e)
 191         {
 192             Logging.logger().log(Level.SEVERE, "WorldWind.UnableToCreateClassForConfigurationKey", name);
 193             throw new IllegalStateException(
 194                 Logging.getMessage("WorldWind.UnableToCreateClassForConfigurationKey", name), e);
 195         }
 196     }
 197
 198     public static void setValue(String key, String value)
 199     {
 200         instance.wwo.setValue(key, value);
 201     }
 202
 203     public static Object getValue(String key)
 204     {
 205         return instance.wwo.getValue(key);
 206     }
 207
 208     public static String getStringValue(String key)
 209     {
 210         return instance.wwo.getStringValue(key);
 211     }
 212
 213     public static boolean hasKey(String key)
 214     {
 215         return instance.wwo.hasKey(key);
 216     }
 217
 218     public static void removeKey(String key)
 219     {
 220         instance.wwo.removeKey(key);
 221     }
 222
 223     public static void addPropertyChangeListener(String propertyName, PropertyChangeListener listener)
 224     {
 225         instance.wwo.addPropertyChangeListener(propertyName, listener);
 226     }
 227
 228     public static void removePropertyChangeListener(String propertyName, PropertyChangeListener listener)
 229     {
 230         instance.wwo.removePropertyChangeListener(propertyName, listener);
 231     }
 232
 233     public static void addPropertyChangeListener(PropertyChangeListener listener)
 234     {
 235         instance.wwo.addPropertyChangeListener(listener);
 236     }
 237
 238     public static void removePropertyChangeListener(PropertyChangeListener listener)
 239     {
 240         instance.wwo.removePropertyChangeListener(listener);
 241     }
 242 }