Application: gvSIG desktop

package org.gvsig.symbology.app.symbolinstaller.execution;

import java.io.File;

import org.apache.commons.io.FileUtils;

import org.gvsig.andami.PluginsLocator;

import org.gvsig.andami.PluginsManager;

import org.gvsig.installer.lib.api.InstallerLocator;

import org.gvsig.installer.lib.api.InstallerManager;

import org.gvsig.installer.lib.spi.InstallerProviderLocator;

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

import org.gvsig.tools.util.Invocable;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class SymbolsInstallerInitializer implements Invocable {

    private static final Logger LOG = LoggerFactory.getLogger(SymbolsInstallerInitializer.class);

    @Override

    public Object call(Object... args) {

        PluginsManager pluginManager = PluginsLocator.getManager();

        File symbolsFolder = FileUtils.getFile(

                pluginManager.getApplicationHomeFolder(),

                "plugins",

                "org.gvsig.app.mainplugin",

                "Symbols"

        );

        this.perform((String) args[0], symbolsFolder);

        return true;

    }

    public void perform(String pluginName, File symbolsFolder) {

        try {

            InstallerManager installerManager = InstallerLocator.getInstallerManager();

            ProviderManager providerManager = InstallerProviderLocator.getProviderManager();

            SymbolInstallerExecutionProviderFactory factory = new SymbolInstallerExecutionProviderFactory(symbolsFolder);

            providerManager.addProviderFactory(factory);

            installerManager.setDefaultLocalAddonRepository(symbolsFolder, factory.getName());

        } catch (Exception ex) {

            LOG.warn("Problems initializing scripts installer.", ex);

        }

    }

}

Este plugin registra el instalador de simbolos en el administrador de complementos.

Para que se preinstale de forma automatica el instalador de simbolos es preciso a?adir

al "packages.properties" del gvspks las siguientes entradas:

installers=symbols

installer.symbols.initializer=org.gvsig.symbology.app.symbolinstaller.execution.SymbolsInstallerInitializer

installer.symbols.package.code=org.gvsig.symbology.app.symbolinstaller

installer.symbols.factory.name=Symbols

installer.symbols.libs=lib

Si ya existe la entrada "installers", a?adir "symbols" al final separandolo con un 

espacio en blanco.

package org.gvsig.installer.lib.impl.execution;

import java.io.File;

import java.io.FilenameFilter;

import java.net.MalformedURLException;

import java.net.URL;

import java.net.URLClassLoader;

import java.util.Properties;

import org.apache.commons.io.FileUtils;

import org.gvsig.installer.lib.api.InstallerLocator;

import org.gvsig.installer.lib.api.InstallerManager;

import org.gvsig.installer.lib.api.PackageInfo;

import org.gvsig.installer.lib.api.execution.InstallPackageService;

import org.gvsig.installer.lib.spi.InstallerProviderLocator;

import org.gvsig.tools.library.impl.DefaultLibrariesInitializer;

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

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

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

import org.gvsig.tools.util.Invocable;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class InstallerProviderInstallers {

    private static final Logger LOG = LoggerFactory.getLogger(InstallerProviderInstallers.class);

    private final InstallPackageService bundle;

    private final String installerName;

    private String packageCode;

    private String factoryName;

    private String initializerClassName;

    private String libs;

    private PackageInfo packageInfo = null;

    public InstallerProviderInstallers(InstallPackageService bundle, String installerName) {

        this.bundle = bundle;

        this.installerName = installerName;

        this.init();

    }

    private void init() {

        Properties props = this.bundle.getProperties();

        String s = "installer."+installerName;

        this.setInitializerClassName(props.getProperty(s+".initializer"));

        this.setPackageCode(props.getProperty(s+".package.code"));

        this.setFactoryName(props.getProperty(s+".factory.name"));

        this.setLibs(props.getProperty(s+".libs", "lib"));

    }

    /**

     * @return the bundle

     */

    public InstallPackageService getBundle() {

        return bundle;

    }

    /**

     * @return the packageCode

     */

    public String getPackageCode() {

        return packageCode;

    }

    /**

     * @param packageCode the packageCode to set

     */

    public void setPackageCode(String packageCode) {

        this.packageCode = packageCode;

    }

    /**

     * @return the initializerClassName

     */

    public String getInitializerClassName() {

        return initializerClassName;

    }

    /**

     * @param initializerClassName the initializerClassName to set

     */

    public void setInitializerClassName(String initializerClassName) {

        this.initializerClassName = initializerClassName;

    }

    /**

     * @return the libs

     */

    public String getLibs() {

        return libs;

    }

    /**

     * @param libs the libs to set

     */

    public void setLibs(String libs) {

        this.libs = libs;

    }

    /**

     * @return the factoryName

     */

    public String getFactoryName() {

        return factoryName;

    }

    /**

     * @param factoryName the factoryName to set

     */

    public void setFactoryName(String factoryName) {

        this.factoryName = factoryName;

    }

    private ClassLoader createClassLoader(File installFolder) {

        File folder = FileUtils.getFile(installFolder, this.packageCode,this.libs);

        File[] jars = folder.listFiles(new FilenameFilter() {

            @Override

            public boolean accept(File dir, String name) {

                if (name.endsWith(".jar")) {

                    return true;

                }

                return false;

            }

        });

        URL[] urls = new URL[jars.length];

        for (int i = 0; i < jars.length; i++) {

            File f = jars[i];

            try {

                urls[i] = f.toURI().toURL();

            } catch (MalformedURLException ex) {

                LOG.warn("Can't add jar '" + f.getAbsolutePath() + "' to class loader.", ex);

            }

        }

        URLClassLoader loader = new URLClassLoader(urls, this.getClass().getClassLoader());

        return loader;

    }

    private Object newInstance(ClassLoader loader, String className) {

        try {

            Class theClass = loader.loadClass(className);

            Object instance = theClass.newInstance();

            return instance;

        } catch (Exception ex) {

            LOG.warn("Can't create class '" + className + "'.", ex);

            return null;

        }

    }

    private PackageInfo getPackageInfo() {

        if (this.packageInfo == null) {

            this.packageInfo = this.bundle.getPackageInfo(packageCode);

        }

        return this.packageInfo;

    }

    public boolean isAlreadyRegistered() {

        try {

            ProviderManager_WithGetFactories providerManager = InstallerProviderLocator.getProviderManager();

            providerManager.getProviderFactory(factoryName);

            return true;

        } catch (NotRegisteredException ex) {

            return false;

        } catch (ParametersException ex) {

            throw new RuntimeException(ex);

        }

    }

    public void install() {

        InstallerManager installerManager = InstallerLocator.getInstallerManager();

        File installFolder = installerManager.getDefaultLocalAddonRepository(

                this.getPackageInfo().getType(),

                InstallerManager.ACCESS_WRITE

        );

        try {

            File f = FileUtils.getFile(installFolder,this.packageCode);

            if( ! f.exists() ) {

                this.bundle.installPackage(

                        installFolder,

                        this.packageCode

                );

            }

            if( ! isAlreadyRegistered() ) {

                ClassLoader loader = this.createClassLoader(installFolder);

                new DefaultLibrariesInitializer(loader).fullInitialize(true);

                Invocable initializer = (Invocable) this.newInstance(loader, initializerClassName);

                if (initializer == null) {

                    return;

                }

                initializer.call(this.packageCode);

            }

        } catch (Exception ex) {

            LOG.warn("Can't install package provider '" + this.packageCode + "' in the folder '" + installFolder == null ? "unknown" : installFolder.getAbsolutePath() + "'.", ex);

        }

    }

    class MyClassLoader extends URLClassLoader {

        public MyClassLoader(URL[] urls, ClassLoader parent) {

            super(urls, parent);

        }

        @Override

        protected Class<?> findClass(String name) throws ClassNotFoundException {

            LOG.info("findClass('"+name+"').");

            return super.findClass(name); 

        }

        @Override

        public Class<?> loadClass(String name) throws ClassNotFoundException {

            LOG.info("loadClass('"+name+"').");

            return super.loadClass(name); 

        }

        @Override

        protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {

            LOG.info("loadClass('"+name+"',"+resolve+").");

            return super.loadClass(name, resolve); 

        }

    }

}

package org.gvsig.installer.swing.impl.execution.panel.filters;

import org.gvsig.installer.swing.api.execution.PackageFilter;

import java.util.ArrayList;

import java.util.List;

import org.gvsig.installer.lib.api.PackageInfo;

public class AndFilter implements PackageFilter {

    private final List<PackageFilter> filters;

    public AndFilter() {

        this.filters = new ArrayList<>();

    }

    public AndFilter add(PackageFilter filter) {

        if( filter == null ) {

            return this;

        }

        this.filters.add(filter);

        return this;

    }

    @Override

    public boolean match(PackageInfo pkg) {

        for (PackageFilter filter : filters) {

            if( !filter.match(pkg) ) {

                return false;

            }

        }

        return true;

    }    

}