service/simulator/java/eclipse-plugin/ServiceProviderPlugin/src/oic/simulator/serviceprovider/manager/ResourceManager.java

   1 package oic.simulator.serviceprovider.manager;
   2
   3 import java.util.ArrayList;
   4 import java.util.Enumeration;
   5 import java.util.HashMap;
   6 import java.util.Iterator;
   7 import java.util.List;
   8 import java.util.Map;
   9 import java.util.Set;
  10 import java.util.Vector;
  11
  12 import oic.simulator.serviceprovider.listener.IResourceListChangedListener;
  13 import oic.simulator.serviceprovider.resource.ResourceAttribute;
  14 import oic.simulator.serviceprovider.resource.SimulatorResource;
  15 import oic.simulator.serviceprovider.resource.StandardConfiguration;
  16
  17 import org.iotivity.simulator.SimulatorManager;
  18 import org.iotivity.simulator.SimulatorResourceAttribute;
  19 import org.iotivity.simulator.SimulatorResourceModel;
  20 import org.iotivity.simulator.SimulatorResourceServer;
  21
  22 public class ResourceManager {
  23
  24     private Map<String, Map<String, SimulatorResource>> resourceMap;
  25
  26     private StandardConfiguration                       stdConfig;
  27
  28     private IResourceListChangedListener                resourceListChangedListener;
  29
  30     static {
  31         System.loadLibrary("SimulatorManager");
  32     }
  33
  34     public ResourceManager() {
  35         resourceMap = new HashMap<String, Map<String, SimulatorResource>>();
  36         stdConfig = new StandardConfiguration();
  37
  38         // Populate standard configuration file list
  39         populateStandardConfigurationList();
  40     }
  41
  42     public void populateStandardConfigurationList() {
  43         // TODO: Add all the standard configuration files
  44         // Ex: stdConfig.addResourceConfiguration(LIGHT, LIGHT_FILE);
  45     }
  46
  47     public synchronized List<String> getResourceConfigurationList() {
  48         List<String> resourceConfigurationList = new ArrayList<String>();
  49         Map<String, String> configMap = stdConfig
  50                 .getStandardResourceConfigurationList();
  51         if (null != configMap) {
  52             Set<String> keySet = configMap.keySet();
  53             if (null != keySet) {
  54                 Iterator<String> keyItr = keySet.iterator();
  55                 while (keyItr.hasNext()) {
  56                     resourceConfigurationList.add(keyItr.next());
  57                 }
  58             }
  59         }
  60         return resourceConfigurationList;
  61     }
  62
  63     public synchronized String getConfigFilePath(String resourceType) {
  64         String path = null;
  65         if (null != resourceType) {
  66             path = stdConfig.getResourceConfigFilePath(resourceType);
  67         }
  68         return path;
  69     }
  70
  71     private synchronized void addResourceToMap(
  72             SimulatorResource simulatorResource) {
  73         if (null != simulatorResource) {
  74             Map<String, SimulatorResource> resourceTypeMap;
  75             resourceTypeMap = resourceMap.get(simulatorResource
  76                     .getResourceType());
  77             if (null == resourceTypeMap) {
  78                 resourceTypeMap = new HashMap<String, SimulatorResource>();
  79                 resourceMap.put(simulatorResource.getResourceType(),
  80                         resourceTypeMap);
  81             }
  82             resourceTypeMap.put(simulatorResource.getResourceURI(),
  83                     simulatorResource);
  84         }
  85     }
  86
  87     private synchronized void addResourceToMap(String resourceType,
  88             Map<String, SimulatorResource> newResourceTypeMap) {
  89         if (null != resourceType && null != newResourceTypeMap) {
  90             Map<String, SimulatorResource> resourceTypeMap = resourceMap
  91                     .get(resourceType);
  92             if (null != resourceTypeMap) {
  93                 resourceTypeMap.putAll(newResourceTypeMap);
  94             } else {
  95                 resourceMap.put(resourceType, newResourceTypeMap);
  96             }
  97         }
  98     }
  99
 100     private synchronized void removeResourceFromMap(String resourceType,
 101             String resourceURI) {
 102         if (null != resourceURI && null != resourceType) {
 103             Map<String, SimulatorResource> resourceTypeMap = resourceMap
 104                     .get(resourceType);
 105             if (null != resourceTypeMap) {
 106                 resourceTypeMap.remove(resourceURI);
 107                 if (resourceTypeMap.size() < 1) {
 108                     resourceMap.remove(resourceType);
 109                 }
 110             }
 111         }
 112     }
 113
 114     public synchronized boolean isResourceExist(String resourceURI) {
 115         boolean result = false;
 116         if (null != resourceURI) {
 117             SimulatorResource resource = getSimulatorResourceByURI(resourceURI);
 118             if (null != resource) {
 119                 result = true;
 120             }
 121         }
 122         return result;
 123     }
 124
 125     public synchronized void createResource(String configFilePath) {
 126         SimulatorResourceServer resourceServerN;
 127         resourceServerN = SimulatorManager.createResource(configFilePath);
 128
 129         SimulatorResource simulatorResource;
 130         simulatorResource = fetchResourceData(resourceServerN);
 131         if (null != simulatorResource) {
 132             addResourceToMap(simulatorResource);
 133
 134             String resourceType = simulatorResource.getResourceType();
 135             String resourceURI = simulatorResource.getResourceURI();
 136             List<String> resourceURIList = new ArrayList<String>();
 137             resourceURIList.add(resourceURI);
 138
 139             resourceCreatedNotification(resourceType, resourceURIList);
 140         }
 141     }
 142
 143     public synchronized void createResource(String configFilePath,
 144             int noOfInstances) {
 145         Map<String, SimulatorResource> resourceTypeMap;
 146         List<String> resourceUriList;
 147         Vector<SimulatorResourceServer> simulatorResourceServerVectorN = null;
 148         simulatorResourceServerVectorN = SimulatorManager.createResource(
 149                 configFilePath, noOfInstances);
 150         if (null != simulatorResourceServerVectorN) {
 151             resourceTypeMap = new HashMap<String, SimulatorResource>();
 152             resourceUriList = new ArrayList<String>();
 153             Enumeration<SimulatorResourceServer> uriItr = simulatorResourceServerVectorN
 154                     .elements();
 155             SimulatorResourceServer resourceServerN;
 156             SimulatorResource resource;
 157             String uri;
 158             while (uriItr.hasMoreElements()) {
 159                 resourceServerN = uriItr.nextElement();
 160                 resource = fetchResourceData(resourceServerN);
 161                 if (null != resource) {
 162                     uri = resource.getResourceURI();
 163                     resourceUriList.add(uri);
 164                     resourceTypeMap.put(uri, resource);
 165                 }
 166             }
 167
 168             // Find the resourceType and add it to the local data structure and
 169             // notify UI Listeners
 170             if (resourceTypeMap.size() > 0) {
 171                 String resourceType;
 172                 Set<String> uriSet = resourceTypeMap.keySet();
 173                 if (null != uriSet) {
 174                     Iterator<String> itr = uriSet.iterator();
 175                     if (itr.hasNext()) {
 176                         SimulatorResource simResource = resourceTypeMap.get(itr
 177                                 .next());
 178                         if (null != simResource) {
 179                             resourceType = simResource.getResourceType();
 180
 181                             addResourceToMap(resourceType, resourceTypeMap);
 182
 183                             resourceCreatedNotification(resourceType,
 184                                     resourceUriList);
 185                         }
 186                     }
 187                 }
 188             }
 189         }
 190
 191     }
 192
 193     private synchronized SimulatorResource fetchResourceData(
 194             SimulatorResourceServer resourceServerN) {
 195         SimulatorResource simulatorResource = null;
 196         if (null != resourceServerN) {
 197             Map<String, ResourceAttribute> resourceAttributeMap = null;
 198
 199             simulatorResource = new SimulatorResource();
 200             simulatorResource.setResourceServer(resourceServerN);
 201             simulatorResource.setResourceURI(resourceServerN.getURI());
 202             simulatorResource
 203                     .setResourceType(resourceServerN.getResourceType());
 204             simulatorResource.setResourceName(resourceServerN.getName());
 205             simulatorResource.setResourceInterface(resourceServerN
 206                     .getInterfaceType());
 207
 208             SimulatorResourceModel resourceModelN = resourceServerN.getModel();
 209             if (null != resourceModelN) {
 210                 simulatorResource.setResourceModel(resourceModelN);
 211
 212                 Map<String, SimulatorResourceAttribute> attributeMapN;
 213                 attributeMapN = resourceModelN.getAttributes();
 214                 if (null != attributeMapN) {
 215                     resourceAttributeMap = new HashMap<String, ResourceAttribute>();
 216
 217                     Set<String> attNameSet = attributeMapN.keySet();
 218                     if (null != attNameSet) {
 219                         String attName;
 220                         SimulatorResourceAttribute attributeN;
 221                         ResourceAttribute attribute;
 222                         Iterator<String> attNameItr = attNameSet.iterator();
 223                         while (attNameItr.hasNext()) {
 224                             attName = attNameItr.next();
 225                             attributeN = attributeMapN.get(attName);
 226                             if (null != attributeN) {
 227                                 attribute = new ResourceAttribute();
 228                                 attribute.setAttributeName(attName);
 229
 230                                 // Other attribute details such as value,
 231                                 // allowed values and range are based on type
 232                                 // Type implementation is yet to be done
 233                                 resourceAttributeMap.put(attName, attribute);
 234                             }
 235                         }
 236                         simulatorResource
 237                                 .setResourceAttributesMap(resourceAttributeMap);
 238                     }
 239                 }
 240             }
 241         }
 242         return simulatorResource;
 243     }
 244
 245     private synchronized void resourceCreatedNotification(String resourceType,
 246             List<String> resourceURIList) {
 247         if (null != resourceType && null != resourceURIList
 248                 && null != resourceListChangedListener) {
 249             resourceListChangedListener.onResourceCreation(resourceType,
 250                     resourceURIList);
 251         }
 252     }
 253
 254     public synchronized void deleteResourceByURI(String resourceURI) {
 255         if (null != resourceURI) {
 256             SimulatorResource resource = getSimulatorResourceByURI(resourceURI);
 257             if (null != resource) {
 258                 String resourceType = resource.getResourceType();
 259
 260                 // Unregister the resource from the platform
 261                 deleteResource(resource);
 262
 263                 // Delete from the local data structure
 264                 deleteLocalResourceDetails(resourceType, resourceURI);
 265
 266                 // Notify the UI listener for removing this resource from UI
 267                 resourceDeletedNotification(resourceType, resourceURI);
 268             }
 269         }
 270     }
 271
 272     private synchronized SimulatorResource getSimulatorResourceByURI(
 273             String resourceURI) {
 274         SimulatorResource resource = null;
 275         if (null != resourceURI) {
 276             Set<String> typeSet = resourceMap.keySet();
 277             if (null != typeSet) {
 278                 Iterator<String> typeItr = typeSet.iterator();
 279                 String resourceType;
 280                 Map<String, SimulatorResource> resourceTypeMap;
 281                 while (typeItr.hasNext()) {
 282                     resourceType = typeItr.next();
 283                     resourceTypeMap = resourceMap.get(resourceType);
 284                     if (null != resourceTypeMap) {
 285                         resource = resourceTypeMap.get(resourceURI);
 286                         if (null != resource) {
 287                             break;
 288                         }
 289                     }
 290                 }
 291             }
 292         }
 293         return resource;
 294     }
 295
 296     private synchronized void deleteResource(SimulatorResource resource) {
 297         if (null != resource) {
 298             SimulatorResourceServer resourceServerN = resource
 299                     .getResourceServer();
 300             if (null != resourceServerN) {
 301                 SimulatorManager.deleteResource(resourceServerN);
 302             }
 303         }
 304     }
 305
 306     public synchronized void deleteResourceByType(String resourceType) {
 307         if (null != resourceType) {
 308             // Unregister the resources from the platform
 309             deleteResource(resourceType);
 310
 311             // Delete from the local data structure
 312             deleteLocalResourceDetails(resourceType, null);
 313
 314             // Notify the UI listener for removing this resource from UI
 315             resourceTypeDeletedNotification(resourceType);
 316
 317         }
 318     }
 319
 320     private synchronized void deleteResource(String resourceType) {
 321         if (null != resourceType) {
 322             SimulatorManager.deleteResources(resourceType);
 323         }
 324     }
 325
 326     public synchronized void deleteAllResources() {
 327         // Unregister the resources from the platform
 328         deleteResource();
 329
 330         // Delete from the local data structure
 331         deleteLocalResourceDetails(null, null);
 332
 333         // Notify the UI listener for removing this resource from UI
 334         allResourcesDeletedNotification();
 335     }
 336
 337     private synchronized void deleteResource() {
 338         // SimulatorManager.deleteResources();
 339     }
 340
 341     private synchronized void deleteLocalResourceDetails(String resourceType,
 342             String resourceURI) {
 343         if (null != resourceType && null != resourceURI) {
 344             removeResourceFromMap(resourceType, resourceURI);
 345         } else if (null != resourceType) {
 346             resourceMap.remove(resourceType);
 347         } else {
 348             resourceMap.clear();
 349         }
 350     }
 351
 352     private synchronized void resourceDeletedNotification(String resourceType,
 353             String resourceURI) {
 354         if (null != resourceListChangedListener) {
 355             resourceListChangedListener.onResourceDeletion(resourceType,
 356                     resourceURI);
 357         }
 358     }
 359
 360     private synchronized void resourceTypeDeletedNotification(
 361             String resourceType) {
 362         if (null != resourceListChangedListener) {
 363             resourceListChangedListener.onResourceDeletionByType(resourceType);
 364         }
 365     }
 366
 367     private synchronized void allResourcesDeletedNotification() {
 368         if (null != resourceListChangedListener) {
 369             resourceListChangedListener.onAllResourceDeletion();
 370         }
 371     }
 372
 373     public synchronized IResourceListChangedListener getResourceListChangedListener() {
 374         return resourceListChangedListener;
 375     }
 376
 377     public synchronized void setResourceListChangedListener(
 378             IResourceListChangedListener resourceListChangedListener) {
 379         this.resourceListChangedListener = resourceListChangedListener;
 380     }
 381
 382     public synchronized List<String> getResourceTypeList() {
 383         List<String> typeList = null;
 384         if (null != resourceMap && resourceMap.size() > 0) {
 385             typeList = new ArrayList<String>();
 386             Set<String> typeSet = resourceMap.keySet();
 387             Iterator<String> typeItr = typeSet.iterator();
 388             while (typeItr.hasNext()) {
 389                 typeList.add(typeItr.next());
 390             }
 391         }
 392         return typeList;
 393     }
 394 }