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.AVKey;
  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
  17 /**
  18  * @author Tom Gaskins
  19  * @version $Id: WorldWind.java 2471 2007-07-31 21:50:57Z tgaskins $
  20  */
  21 public final class WorldWind
  22 {
  23     private static WorldWind instance = new WorldWind();
  24
  25     private WWObjectImpl wwo;
  26     private MemoryCacheSet memoryCacheSet;
  27     private FileCache dataFileCache;
  28     private RetrievalService retrievalService;
  29     private TaskService taskService;
  30
  31     private WorldWind() // Singleton, prevent public instantiation.
  32     {
  33         this.initialize();
  34     }
  35
  36     private void initialize()
  37     {
  38         this.wwo = new WWObjectImpl();
  39         this.retrievalService = (RetrievalService) createConfigurationComponent(AVKey.RETRIEVAL_SERVICE_CLASS_NAME);
  40         this.taskService = (TaskService) createConfigurationComponent(AVKey.TASK_SERVICE_CLASS_NAME);
  41         this.dataFileCache = (FileCache) createConfigurationComponent(AVKey.DATA_FILE_CACHE_CLASS_NAME);
  42         this.memoryCacheSet = (MemoryCacheSet) createConfigurationComponent(AVKey.MEMORY_CACHE_SET_CLASS_NAME);
  43     }
  44
  45     private void dispose()
  46     {
  47         this.taskService.shutdown(true);
  48         this.retrievalService.shutdown(true);
  49         this.memoryCacheSet.clear();
  50     }
  51
  52     /**
  53      * Reinitialize World Wind to its initial ready state. Shut down and restart all World Wind services and clear all
  54      * World Wind memory caches. Cache memory will be released at the next JVM garbage collection.
  55      * <p/>
  56      * Call this method to reduce World Wind's current resource usage to its initial, empty state. This is typically
  57      * required by applets when the user leaves the applet page.
  58      * <p/>
  59      * World Wind can continue to be used after calling this method. The state of any existing World Wind drawables is
  60      * subsequently indeterminate and they should be disposed.
  61      */
  62     public static synchronized void shutDown()
  63     {
  64         instance.dispose();
  65         instance = new WorldWind();
  66         instance.initialize();
  67     }
  68
  69     public static MemoryCacheSet getMemoryCacheSet()
  70     {
  71         return instance.memoryCacheSet;
  72     }
  73
  74     public static synchronized MemoryCache getMemoryCache(String key)
  75     {
  76         return instance.memoryCacheSet.getCache(key);
  77     }
  78
  79     public static FileCache getDataFileCache()
  80     {
  81         return instance.dataFileCache;
  82     }
  83
  84     public static RetrievalService getRetrievalService()
  85     {
  86         return instance.retrievalService;
  87     }
  88
  89     public static TaskService getTaskService()
  90     {
  91         return instance.taskService;
  92     }
  93
  94     /**
  95      * @param className
  96      * @return
  97      * @throws WWRuntimeException       if the <code>Object</code> could not be created
  98      * @throws IllegalArgumentException if <code>className</code> is null or zero length
  99      */
 100     public static Object createComponent(String className) throws WWRuntimeException
 101     {
 102         if (className == null || className.length() == 0)
 103         {
 104             Logging.logger().severe("WorldWind.ClassNameKeyNulZero");
 105             throw new IllegalArgumentException(Logging.getMessage("WorldWind.ClassNameKeyNulZero"));
 106         }
 107
 108         try
 109         {
 110             Class c = Class.forName(className);
 111             return c.newInstance();
 112         }
 113         catch (Exception e)
 114         {
 115             Logging.logger().log(Level.SEVERE, "WorldWind.ExceptionCreatingComponent", className);
 116             throw new WWRuntimeException(Logging.getMessage("WorldWind.ExceptionCreatingComponent", className), e);
 117         }
 118         catch (Throwable t)
 119         {
 120             Logging.logger().log(Level.SEVERE, "WorldWind.ErrorCreatingComponent", className);
 121             throw new WWRuntimeException(Logging.getMessage("WorldWind.ErrorCreatingComponent", className), t);
 122         }
 123     }
 124
 125     /**
 126      * @param classNameKey
 127      * @return
 128      * @throws IllegalStateException    if no name could be found which corresponds to <code>classNameKey</code>
 129      * @throws IllegalArgumentException if <code>classNameKey<code> is null
 130      * @throws WWRuntimeException       if the component could not be created
 131      */
 132     public static Object createConfigurationComponent(String classNameKey)
 133         throws IllegalStateException, IllegalArgumentException
 134     {
 135         if (classNameKey == null)
 136         {
 137             Logging.logger().severe("WorldWind.ClassNameKeyNulZero");
 138             throw new IllegalArgumentException(Logging.getMessage("WorldWind.ClassNameKeyNulZero"));
 139         }
 140
 141         String name = Configuration.getStringValue(classNameKey);
 142         if (name == null)
 143         {
 144             Logging.logger().log(Level.SEVERE, "WorldWind.NoClassNameInConfigurationForKey", classNameKey);
 145             throw new WWRuntimeException(
 146                 Logging.getMessage("WorldWind.NoClassNameInConfigurationForKey", classNameKey));
 147         }
 148
 149         try
 150         {
 151             return WorldWind.createComponent(name);
 152         }
 153         catch (Throwable e)
 154         {
 155             Logging.logger().log(Level.SEVERE, "WorldWind.UnableToCreateClassForConfigurationKey", name);
 156             throw new IllegalStateException(
 157                 Logging.getMessage("WorldWind.UnableToCreateClassForConfigurationKey", name), e);
 158         }
 159     }
 160
 161     public static void setValue(String key, String value)
 162     {
 163         instance.wwo.setValue(key, value);
 164     }
 165
 166     public static Object getValue(String key)
 167     {
 168         return instance.wwo.getValue(key);
 169     }
 170
 171     public static String getStringValue(String key)
 172     {
 173         return instance.wwo.getStringValue(key);
 174     }
 175
 176     public static boolean hasKey(String key)
 177     {
 178         return instance.wwo.hasKey(key);
 179     }
 180
 181     public static void removeKey(String key)
 182     {
 183         instance.wwo.removeKey(key);
 184     }
 185 }