Aplicación gvSIG con fines educativos » Mapas temáticos

			<artifactId>org.gvsig.educa.thematicmap.lib.spi</artifactId>

			<scope>compile</scope>

		</dependency>

		<dependency>

			<groupId>org.gvsig</groupId>

			<artifactId>org.gvsig.educa.thematicmap.lib.spi</artifactId>

			<scope>compile</scope>

		</dependency>

		<dependency>

			<groupId>org.gvsig</groupId>

import org.gvsig.tools.service.Manager;

import org.gvsig.tools.service.ServiceException;

public interface ThematicMapManager extends Disposable, Manager {

    // TODO: cridar getSERVICE

    //

    ThematicMapCompilation createCompilationInstance(String gameName) throws ServiceException;

package org.gvsig.educa.thematicmap.map;

public interface GameThematicMap extends ThematicMap{

	public String getType();

	public void setType(String type);

}

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.service.Service;

public interface ThematicMapCompilation extends Service{

    DynObject getParameters();

package org.gvsig.educa.thematicmap.spi;

import org.gvsig.tools.service.spi.Provider;

public interface ThematicMapProvider extends Provider {

}

package org.gvsig.educa.thematicmap.spi;

import org.gvsig.tools.locator.BaseLocator;

import org.gvsig.tools.locator.Locator;

import org.gvsig.tools.locator.LocatorException;

/**

 * This locator is the entry point for the ThematicMap library SPI, providing

 * access to all ThematicMap provider services through the

 * {@link ThematicMapProviderManager} .

 * 

 */

public class ThematicMapProviderLocator extends BaseLocator {

    /**

     * Thematic Map provider manager name.

     */

    public static final String MANAGER_NAME = "ThematicMap.provider.manager";

    /**

     * Thematic Map provider manager description.

     */

    public static final String MANAGER_DESCRIPTION = "ThematicMap Manager";

    private static final String LOCATOR_NAME = "ThematicMap.provider.locator";

    /**

     * Unique instance.

     */

    private static final ThematicMapProviderLocator INSTANCE =

        new ThematicMapProviderLocator();

    /**

     * Return the singleton instance.

     * 

     * @return the singleton instance

     */

    public static ThematicMapProviderLocator getInstance() {

        return INSTANCE;

    }

    /**

     * Return the Locator's name

     * 

     * @return a String with the Locator's name

     */

    public String getLocatorName() {

        return LOCATOR_NAME;

    }

    /**

     * Return a reference to the {@link Thematic MapProviderManager}

     * 

     * @return a reference to the {@link Thematic MapProviderManager}

     * @throws LocatorException

     *             if there is no access to the class or the class cannot be

     *             instantiated

     * @see Locator#get(String)

     */

    public static ThematicMapProviderManager getManager()

        throws LocatorException {

        return (ThematicMapProviderManager) getInstance().get(MANAGER_NAME);

    }

    /**

     * Registers the Class implementing the {@link Thematic MapProviderManager}

     * interface.

     * 

     * @param clazz

     *            implementing the {@link Thematic MapProviderManager}

     *            interface

     */

    public static void registerManager(

        Class<? extends ThematicMapProviderManager> clazz) {

        getInstance().register(MANAGER_NAME, MANAGER_DESCRIPTION, clazz);

    }

}

package org.gvsig.educa.thematicmap.spi;

import org.gvsig.tools.service.spi.ProviderServices;

public interface ThematicMapProviderServices extends ProviderServices {

	/**

     * Returns the parameters needed to provide a service.

     * 

     * @return a {@link DynObject} with the parameters needed by the provider to

     *         do the service

     */

    // public DynObject getParameters();

}

package org.gvsig.educa.thematicmap.spi;

import org.gvsig.tools.service.spi.ProviderManager;

public interface ThematicMapProviderManager extends ProviderManager{

	//?

}

		<dependency>

			<groupId>org.gvsig</groupId>

			<artifactId>org.gvsig.educa.thematicmap.lib.spi</artifactId>

		</dependency>

package org.gvsig.educa.thematicmap.impl;

import org.gvsig.educa.thematicmap.spi.ThematicMapProviderServices;

import org.gvsig.tools.service.spi.AbstractProviderServices;

/**

 * Default {@link ThematicMapProviderServices} implementation.

 * 

 */

public class DefaultThematicMapProviderServices extends

    AbstractProviderServices implements ThematicMapProviderServices {

    public DefaultThematicMapProviderServices() {

        // Nothing to do

    }

}

package org.gvsig.educa.thematicmap.impl;

import org.gvsig.educa.thematicmap.spi.ThematicMapProviderManager;

import org.gvsig.tools.service.Service;

import org.gvsig.tools.service.spi.AbstractProviderManager;

import org.gvsig.tools.service.spi.ProviderServices;

public class DefaultThematicMapProviderManager extends AbstractProviderManager

		implements ThematicMapProviderManager {

	public static final String PROVIDERS_NAME = "ThematicMap.providers";

	public static final String PROVIDERS_DESCRIPTION = "ThematicMap providers";

	@Override

	protected String getRegistryDescription() {

		return PROVIDERS_DESCRIPTION;

	}

	@Override

	protected String getRegistryKey() {

		return PROVIDERS_NAME;

	}

	public ProviderServices createProviderServices(Service service) {

		return new DefaultThematicMapProviderServices();

	}

}

import org.gvsig.educa.thematicmap.spi.ThematicMapProviderLocator;

        ThematicMapProviderLocator

				.registerManager(DefaultThematicMapProviderManager.class);

import org.gvsig.educa.thematicmap.spi.ThematicMapProviderLocator;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.service.AbstractManager;

import org.gvsig.tools.service.Service;

import org.gvsig.tools.service.ServiceException;

import org.gvsig.tools.service.spi.ProviderManager;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class DefaultThematicMapManager extends AbstractManager implements

		ThematicMapManager {

	/**

	 * Extension for Thematic Map files

	 */

	public static String THEMATIC_MAP_FILE_EXTENSION = "gvsthm";

	private static final Logger LOG = LoggerFactory

			.getLogger(DefaultThematicMapManager.class);

	public static final String BASENAME_FORMAT_STRING = "{0}-v{1}-BN{2}";

	public static final String PACKAGE_BASENAME_FORMAT_STRING = "ThematicMap-{0}-{1}-BN{2}";

	/**

	 * Manager which manages when deploy/clean maps in temporal folder

	 */

	private MapResoucesManager resourceManager;

	private final ThematicMapLoader mapLoader;

	private final InstallerManager installerManager;

	/**

	 * Map Instalation's folder

	 */

	private String installationFolderInput;

	private File installationFolder;

	private String temporalDelployFolderInput;

	private File temporalDeployMapFolder;

	private final ThematicMapFileFilter thematicMapFileFilter;

	public DefaultThematicMapManager(ProviderManager providerManager) {

		super(providerManager);

		// TODO Auto-generated constructor stub

		// initially, installation folder is null

		installationFolder = null;

		installationFolderInput = null;

		// default temporal folder tmp.dir + '/ThematicMap.tmp'

		temporalDeployMapFolder = FileUtils.getWritableFolder(

				new File(System.getProperty("java.io.tmpdir")),

				"ThematicMap.tmp");

		temporalDelployFolderInput = temporalDeployMapFolder.getAbsolutePath();

		// Create file filter to identify map candidate in a folder

		thematicMapFileFilter = new ThematicMapFileFilter(

				THEMATIC_MAP_FILE_EXTENSION);

		// Create loader instance

		mapLoader = new ThematicMapLoader();

		// Create resource manager instance

		resourceManager = new MapResoucesManager(mapLoader);

		installerManager = InstallerLocator.getInstallerManager();

	}

	public DefaultThematicMapManager() {

//		super(new DefaultInstallerProviderManager());

//		this(ThematicMapProviderLocator.getManager());

		this(null);

	}

//	public DefaultThematicMapManager() {

//

//		// initially, installation folder is null

//		installationFolder = null;

//		installationFolderInput = null;

//

//		// default temporal folder tmp.dir + '/ThematicMap.tmp'

//		temporalDeployMapFolder = FileUtils.getWritableFolder(

//				new File(System.getProperty("java.io.tmpdir")),

//				"ThematicMap.tmp");

//		temporalDelployFolderInput = temporalDeployMapFolder.getAbsolutePath();

//

//		// Create file filter to identify map candidate in a folder

//		thematicMapFileFilter = new ThematicMapFileFilter(

//				THEMATIC_MAP_FILE_EXTENSION);

//

//		// Create loader instance

//		mapLoader = new ThematicMapLoader();

//

//		// Create resource manager instance

//		resourceManager = new MapResoucesManager(mapLoader);

//

//		installerManager = InstallerLocator.getInstallerManager();

//	}

	/** {@inheridDoc} */

	public String getInstallationMapFolder() {

		return installationFolderInput;

	}

	/**

	 * Checks if <code>folder</code> is a folder an is readable

	 * 

	 * @param folder

	 * @return file representation of folder

	 * @throws IllegalArgumentException

	 */

	private File checkValidReadableFolder(String folder) {

		File fileObject = new File(folder);

		if (!FileUtils.isReadableFolder(fileObject)) {

			throw new IllegalArgumentException("Invalid folder");

		}

		return fileObject;

	}

	/**

	 * Checks if <code>folder</code> is a folder and is writable

	 * 

	 * @param folder

	 * @return file representation of folder

	 * @throws IllegalArgumentException

	 */

	private File checkValidWritableFolder(String folder) {

		File fileObject = new File(folder);

		if (!FileUtils.isWritableFolder(fileObject)) {

			throw new IllegalArgumentException("Invalid folder");

		}

		return fileObject;

	}

	/** {@inheridDoc} */

	public void setInstallationMapFolder(String folder) {

		installationFolder = checkValidReadableFolder(folder);

		installationFolderInput = folder;

	}

	/** {@inheridDoc} */

	public String getTemporalFolder() {

		return temporalDelployFolderInput;

	}

	/** {@inheridDoc} */

	public void setTemporalFolder(String folder) {

		if (FilenameUtils.equals(temporalDelployFolderInput, folder)) {

			return;

		}

		temporalDeployMapFolder = checkValidWritableFolder(folder);

		temporalDelployFolderInput = folder;

		resourceManager.cleanAllResources();

	}

	/** {@inheridDoc} */

	public List<ThematicMap> getInstalledMaps() {

		return getMapsFromFolder(installationFolder);

	}

	/** {@inheridDoc} */

	public List<ThematicMap> getInstalledMaps(String folder) {

		File fileObject = checkValidReadableFolder(folder);

		return getMapsFromFolder(fileObject);

	}

	/**

	 * <p>

	 * Gets all maps from a folder

	 * </p>

	 * <p>

	 * List all files which matches with filter and try to load it information.

	 * If a file load throws an Invalid format found ignores this file.

	 * </p>

	 * 

	 * @param folder

	 * @return

	 */

	private List<ThematicMap> getMapsFromFolder(File folder) {

		File[] files = folder.listFiles();

		List<ThematicMap> result = new ArrayList<ThematicMap>(files.length);

		ThematicMap map;

		for (File file : files) {

			try {

				map = getThematicMapIntalledFolder(file);

			} catch (ThematicMapException ex) {

				// Ignore this folder

				if (LOG.isDebugEnabled()) {

					LOG.debug(

							"Folder exception reading map from it (not a map): {}"

									.concat(file.getAbsolutePath()), ex);

				}

				continue;

			}

			result.add(map);

		}

		resourceManager.adjustResourceSize();

		return Collections.unmodifiableList(result);

	}

	/** {@inheridDoc} */

	public ThematicMap getMapFromFile(File file)

			throws InvalidThematicMapFormatException {

		if (!thematicMapFileFilter.accept(file)) {

			throw new InvalidThematicMapFormatException(file,

					"Bad file extension (".concat(

							thematicMapFileFilter.getFileNameEnding()).concat(

							")"));

		}

		ThematicMapInformation info = resourceManager.getInfoOfFile(file);

		if (info == null) {

			try {

				info = mapLoader.getInformationFromMapFile(file);

			} catch (Exception e) {

				throw new InvalidThematicMapFormatException(file,

						"Can't load information file", e);

			}

		}

		return createThematicMap(file, info);

	}

	public ThematicMap getMapById(String mapId) {

		List<ThematicMap> installedMaps = getInstalledMaps();

		for (ThematicMap map : installedMaps) {

			if (ObjectUtils.equals(map.getInformation().getId(), mapId)) {

				return map;

			}

		}

		return null;

	}

	private ThematicMap createThematicMap(File file, ThematicMapInformation info) {

		return new DefaultThematicMap(file, info, resourceManager);

	}

	/** {@inheridDoc} */

	public boolean isMap(File file) {

		if (LOG.isDebugEnabled()) {

			LOG.debug("Checking is map : {}", file.getAbsolutePath());

		}

		if (!thematicMapFileFilter.accept(file)) {

			return false;

		}

		try {

			return mapLoader.getInformationFromMapFile(file) != null;

		} catch (Exception e) {

			LOG.debug("file is not a mapFile:", e);

			return false;

		}

	}

	/** {@inheridDoc} */

	public ThematicMapCompilation createCompilationInstance() {

		return new DefaultThematicMapCompilation(this);

	}

	/** {@inheridDoc} */

	public ThematicMapCompiler createCompilerInstance() {

		return new DefaultThematicMapCompiler(THEMATIC_MAP_FILE_EXTENSION);

	}

	/** {@inheridDoc} */

	public void dispose() {

		resourceManager.dispose();

		resourceManager = null;

		ToolsLocator.getDisposableManager().release(this);

	}

	/** {@inheridDoc} */

	public void cleanAllTemporalData() {

		resourceManager.cleanAllResources();

	}

	/** {@inheridDoc} */

	public ThematicMapCompilation createCompilationInstanceFromMap(

			ThematicMap map) throws InvalidThematicMapFormatException,

			CantLoadContextException, IOException {

		if (!map.isOpen()) {

			map.open();

		}

		return new DefaultThematicMapCompilation(map, this);

	}

	/**

	 * Gets a ThematicMap from a installed maps

	 * 

	 * @param folder

	 * @return

	 * @throws InvalidInstalledThematicMapException

	 */

	public ThematicMap getThematicMapIntalledFolder(File folder)

			throws ThematicMapException {

		// Only readable folder

		if (!FileUtils.isReadableFolder(folder)) {

			throw new InvalidInstalledThematicMapException(folder,

					"not a readable folder");

		}

		String code = folder.getName();

		// Load package info

		PackageInfo packageInfo = mapLoader

				.getPackageInfoFromInstalledThematicMap(folder);

		if (packageInfo == null) {

			throw new InvalidInstalledThematicMapException(folder,

					"missing package.info file");

		}

		if (!StringUtils.equals(code, packageInfo.getCode())) {

			throw new InvalidInstalledThematicMapException(folder,

					"folder name doesn't match with package.info code");

		}

		if (!StringUtils.equals("ThematicMap", packageInfo.getType())) {

			throw new InvalidInstalledThematicMapException(folder,

					"package.info type is not 'ThematicMap': "

							.concat(packageInfo.getType()));

		}

		// Gets the thematic map file

		ThematicMap map;

		String mapFileName = getBaseFileNameFromInfo(packageInfo.getCode(),

				packageInfo.getName(), packageInfo.getVersion().getMayor(),

				packageInfo.getVersion().getBuild()).concat(

				thematicMapFileFilter.getFileNameEnding());

		File mapFile = new File(folder, mapFileName);

		if (!mapFile.exists()) {

			throw new InvalidInstalledThematicMapException(folder, "missing '"

					.concat(mapFileName).concat("' file"));

		}

		map = getMapFromFile(mapFile);

		if (map == null) {

			// This must be unreachable code

			throw new IllegalStateException();

		}

		ThematicMapInformation info = map.getInformation();

		// Compares pkgInfo.code and thmInfo.id

		if (!StringUtils.equals(packageInfo.getCode(), info.getId())) {

			throw new InvalidInstalledThematicMapException(folder,

					"package.info code doesn't match with ThematicMap.id");

		}

		// Compares pkgInfo.version and thmInfo.version

		if (packageInfo.getVersion().getMayor() != info.getVersion()) {

			throw new InvalidInstalledThematicMapException(folder,

					"package.info version doesn't match with ThematicMap.version");

		}

		// Compares pkgInfo.buildNumber and thmInfo.buildNumber

		if (packageInfo.getVersion().getBuild() != info.getBuildNumber()) {

			throw new InvalidInstalledThematicMapException(folder,

					"package.info build doesn't match with ThematicMap.buildNumber");

		}

		return map;

	}

	/** {@inheridDoc} */

	public boolean isAThematicMapIntalledFolder(File folder) {

		if (!FileUtils.isReadableFolder(folder)) {

			return false;

		}

		ThematicMap map;

		try {

			map = getThematicMapIntalledFolder(folder);

		} catch (Exception ex) {

			return false;

		}

		return map != null;

	}

	/** {@inheridDoc} */

	public String getBaseFileNameFromInfo(ThematicMapInformation info) {

		return getBaseFileNameFromInfo(info.getId(), info.getName(),

				info.getVersion(), info.getBuildNumber());

	}

	/** {@inheridDoc} */

	public String getBaseFileNameFromInfo(String id, String name, int version,

			int buildNumber) {

		return MessageFormat.format(BASENAME_FORMAT_STRING, id, version,

				buildNumber);

	}

	/** {@inheridDoc} */

	public File generatePackageFile(String mapId, File targetFolder)

			throws ThematicMapException, IOException {

		ThematicMap map = getMapById(mapId);

		if (map == null) {

			throw new IllegalArgumentException("Thematic Map not foudn: '"

					.concat(mapId).concat("'"));

		}

		File mapFolder = new File(installationFolder, mapId);

		return generatePackageFile(mapFolder, targetFolder);

	}

	/** {@inheridDoc} */

	public File generatePackageFile(File thematicMapIntallFolder,

			File targetFolder) throws ThematicMapException, IOException {

		// Checks if it's a map folder

		ThematicMap map = null;

		try {

			map = getThematicMapIntalledFolder(thematicMapIntallFolder);

		} catch (Exception ex) {

			throw new IllegalArgumentException("Source is not a map folder: '"

					.concat(thematicMapIntallFolder.getAbsolutePath()).concat(

							"'"));

		}

		if (map == null) {

			throw new IllegalArgumentException("Source is not a map folder: '"

					.concat(thematicMapIntallFolder.getAbsolutePath()).concat(

							"'"));

		}

		// Check target folder

		if (!FileUtils.isWritableFolder(targetFolder)) {

			throw new IllegalArgumentException(

					"Target is not a writable folder: '".concat(

							targetFolder.getAbsolutePath()).concat("'"));

		}

		// Prepare target file name

		ThematicMapInformation info = map.getInformation();

		String pkgFileName = MessageFormat

				.format(PACKAGE_BASENAME_FORMAT_STRING, info.getId(),

						info.getVersion(), info.getBuildNumber()).concat(".")

				.concat(installerManager.getDefaultPackageFileExtension());

		File targetFile = new File(targetFolder, pkgFileName);

		// Prepare temporal folder

		File workFolder = FileUtils.getNewWritableFolder(

				temporalDeployMapFolder, "__tmp__".concat(pkgFileName));

		File tempFolder = new File(workFolder, info.getId());

		// Copy all content of map folder

		FileUtils.copyDirectory(thematicMapIntallFolder, tempFolder, true);

		// Remove unused thematicMap files

		String mapFileName = FilenameUtils.getName(map.getSourceFilePath());

		File[] tmFiles = tempFolder.listFiles(thematicMapFileFilter);

		for (File thFile : tmFiles) {

			if (!StringUtils.equals(thFile.getName(), mapFileName)) {

				thFile.delete();

			}

		}

		// Zip file

		FileUtils.zipFolder(workFolder, targetFile);

		return targetFile;

	}

	public String getTranslation(String key) {

		// TODO: add I18nManager usage when org.gvsig.tools.lib 2.1.0 becomes

		// available

		// return this.i18nmanager.getTranslation(key);

		return Messages.getText(key);

	}

	public Service getService(DynObject parameters) throws ServiceException {

		// return thematic map compilation (ThematicMapService)

		// supose que he d'agafar un identificador de parameters del mapa que busque

		// despres, buscar-lo i passar-lo a DefaultThematicMapCompilation i

		// tornar la compilacio.

		ThematicMap map = null;

		List<ThematicMap> mapsList = getInstalledMaps();

		// TODO: Get the thematicmap that has the given parameters

		DefaultThematicMapCompilation serviceCompilation = new DefaultThematicMapCompilation(

				map, this);

		return serviceCompilation;

	}

	public ThematicMapCompilation createCompilationInstance(String gameName)

			throws ServiceException {

		DynObject params = createServiceParameters(gameName);

//		DefaultThematicMapCompilation compilation = new DefaultThematicMapCompilation(this);

//		compilation.

		// Instanciar thematicmapcompilation i assignar-li params

		return null;

	}

package org.gvsig.educa.thematicmap.impl.map;

import java.io.File;

import org.gvsig.educa.thematicmap.impl.MapResoucesManager;

import org.gvsig.educa.thematicmap.map.GameThematicMap;

import org.gvsig.educa.thematicmap.map.ThematicMapInformation;

public class DefaultGameThematicMap extends DefaultThematicMap implements

		GameThematicMap {

	private String type = "TypeGame";

	public DefaultGameThematicMap(File file, ThematicMapInformation info,

			MapResoucesManager resourceManager) {

		super(file, info, resourceManager);

		// TODO Auto-generated constructor stub

		resourceManager.addResource(this);

	}

	public String getType() {

		return this.type;

	}

	public void setType(String type) {

		this.type = type;

	}

}

import org.gvsig.educa.thematicmap.ThematicMapManager;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.service.Manager;

	private final ThematicMapManager manager;

	private DynObject parameters;

    public DefaultThematicMapCompilation(ThematicMapManager manager) {

        this.manager = manager;

		info = new DefaultThematicMapCompilationInformation();

    public DefaultThematicMapCompilation(ThematicMap map, ThematicMapManager manager) {

        this.manager = manager;

		info =

	public Manager getManager() {

		return this.manager;

	}

	public DynObject getParameters() {

		// TODO Auto-generated method stub

		return this.parameters;

	}

	public void setParameters(DynObject parameters) {

		//TODO: ??

		this.parameters = parameters;

	}

			<artifactId>org.gvsig.educa.thematicmap.lib.spi</artifactId>

			<scope>compile</scope>

		</dependency>

		<dependency>

			<groupId>org.gvsig</groupId>