Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 3

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.remoteclient.wmts;

import java.io.BufferedOutputStream;

import java.io.ByteArrayInputStream;

import java.io.DataInputStream;

import java.io.DataOutputStream;

import java.io.File;

import java.io.FileOutputStream;

import java.io.FileReader;

import java.io.IOException;

import java.io.OutputStreamWriter;

import java.net.HttpURLConnection;

import java.net.MalformedURLException;

import java.net.URL;

import java.security.KeyManagementException;

import java.security.NoSuchAlgorithmException;

import java.util.ArrayList;

import java.util.Hashtable;

import java.util.StringTokenizer;

import java.util.prefs.Preferences;

import javax.net.ssl.HttpsURLConnection;

import javax.net.ssl.SSLContext;

import javax.net.ssl.TrustManager;

import javax.net.ssl.X509TrustManager;

import org.gvsig.compat.net.ICancellable;

import org.gvsig.remoteclient.exceptions.ServerErrorException;

import org.gvsig.remoteclient.ogc.OGCProtocolHandler;

import org.gvsig.remoteclient.ogc.OGCServiceInformation;

import org.gvsig.remoteclient.utils.ExceptionTags;

import org.gvsig.remoteclient.utils.Utilities;

import org.gvsig.remoteclient.wmts.exception.DownloadException;

import org.gvsig.remoteclient.wmts.exception.WMTSException;

import org.gvsig.remoteclient.wmts.request.WMTSGetCapabilitiesRequest;

import org.gvsig.remoteclient.wmts.request.WMTSGetFeatureInfoRequest;

import org.gvsig.remoteclient.wmts.request.WMTSGetTileRequest;

import org.kxml2.io.KXmlParser;

import org.xmlpull.v1.XmlPullParserException;

/**

 * <p> Abstract class that represents handlers to comunicate via WMS protocol.</p>

 * 

 * @author Nacho Brodin (nachobrodin@gmail.com)

 */

public abstract class WMTSProtocolHandler extends OGCProtocolHandler {

        /**

         * Encoding used to parse different xml documents.

         */

        protected String                 encoding                     = "UTF-8";

    protected WMTSServiceInformation serviceInfo                  = null;

        private static int               count                        = 0;

        final String                     tempDirectoryPath            = System.getProperty("java.io.tmpdir")+"/tmp-andami";

        protected boolean                forceLongitudeFirstAxisOrder = false;

    protected abstract WMTSGetFeatureInfoRequest createGetFeatureInfoRequest(WMTSStatus status, int x, int y);

    protected abstract WMTSGetTileRequest createGetTileRequest(WMTSStatus status);

    protected abstract WMTSGetCapabilitiesRequest createGetCapabilitiesRequest();

    /**

         * Sets longitude first in the axis order read from the capabilities file

         * @param force

         */

        public void setForceLongitudeFirstAxisOrder(boolean force) {

                this.forceLongitudeFirstAxisOrder = force;

        }

    //**************************************************************

    //Esto es temporal hasta que est? la cach?

        private Hashtable                downloadedFiles;

    /**

         * Returns the content of a URL as a file from the file system.<br>

         * <p>

         * If the URL has been already downloaded in this session and notified

         * to the system using the static <b>Utilities.addDownloadedURL(URL)</b>

         * method, it can be restored faster from the file system avoiding to

         * download it again.

         * </p>

         * @param url

         * @return File containing this URL's content or null if no file was found.

         */

        private File getPreviousDownloaded(Object object) {

                File f = null;

                if (downloadedFiles != null && downloadedFiles.containsKey(object)) {

                        String filePath = (String) downloadedFiles.get(object);

                        f = new File(filePath);

                        if (!f.exists())

                                return null;

                }

                return f;

        }

        /**

         * Adds an URL to the table of downloaded files for further uses. If the URL

         * already exists in the table its filePath value is updated to the new one and

         * the old file itself is removed from the file system.

         *

         * @param url

         * @param filePath

         */

        void addDownloadedURL(URL url, String filePath) {

                if (downloadedFiles == null)

                        downloadedFiles = new Hashtable();

                String fileName = (String) downloadedFiles.put(url, filePath);

        }

        //Fin del c?digo temporal hasta que est? la cach?

        //**************************************************************

    /**

     * Sets the status object

     * @param status

     */

    protected abstract void setServerDescription(WMTSServerDescription status);

    public synchronized File getTile(WMTSStatus status, ICancellable cancel, File file) throws ServerErrorException, WMTSException {

            try {

                        WMTSGetTileRequest request = createGetTileRequest(status);

                        request.sendRequest(cancel, file);

                        try {

                                checkFileError(file);

                        } catch(WMTSException e) {

                                file.delete();

                                throw new WMTSException("This tile is not available:" + file.getAbsoluteFile().toString(), e);

                        } catch(IOException e) {

                                file.delete();

                                throw new WMTSException("This tile is not available:" + file.getAbsoluteFile().toString(), e);

                        }

                        return file;

                } catch(IOException e) {

            throw new WMTSException(e);

                }

    }

    public synchronized File getTile(WMTSStatus status, ICancellable cancel) throws ServerErrorException, WMTSException {

            try {

                        WMTSGetTileRequest request = createGetTileRequest(status);

                        File f = request.sendRequest(cancel);

                        try {

                                checkFileError(f);

                        } catch(WMTSException e) {

                                downloader.removeURL(request);

                    throw new ServerErrorException();

                        }

                        return f;

                } catch(IOException e) {

                        e.printStackTrace();

            throw new ServerErrorException();

                }

    }

    /**

     * Checks if the file downloaded is correct or doesn't

     * @param f

     * @throws WMTSException

     * @throws IOException

     */

    private void checkFileError(File f) throws WMTSException, IOException {

                if (f == null)

                    return;

            if (Utilities.isTextFile(f)) {

            byte[] data = fileToBytes(f);

                String exceptionMessage = parseException(data);

            if (exceptionMessage == null) {

                     String error = new String(data);

                    int pos = error.indexOf("<?xml");

                    if (pos!= -1) {

                            String xml = error.substring(pos,error.length());

                            exceptionMessage = parseException(xml.getBytes());

                    }

                if (exceptionMessage == null)

                        exceptionMessage = new String(data);

            }

            throw new WMTSException(exceptionMessage);

        }

    }

    public synchronized URL getTileURL(WMTSStatus status) throws MalformedURLException {

                String onlineResource = getHost();

                String symbol = getSymbol(onlineResource);

                onlineResource = onlineResource + symbol;

                StringBuffer req = new StringBuffer();

                req.append(onlineResource)

                .append("REQUEST=GetTile&SERVICE=WMTS&VERSION=").append(getVersion()).append("&")

                .append("Layer=" + status.getLayer())

        .append("&Style=" + status.getStyle())

        .append("&Format=" + status.getFormat())

        .append("&TileMatrixSet=" + status.getTileMatrixSet())

        .append("&TileMatrix=" + status.getTileMatrix())

        .append("&TileRow=" + status. getTileRow())

        .append("&TileCol=" + status.getTileCol());

                return new URL(req.toString());

    }

    /**

     * Gets a file name to download. I

     * @param url

     * @return

     */

    private File getFile() {

            count ++;

                int index = name.lastIndexOf(".");

                if (index > 0){

                        return new File(tempDirectoryPath + "/" + name.substring(0,index) + System.currentTimeMillis() + count + 

                                name.substring(index, name.length()));

                }

                return new File(tempDirectoryPath + "/" + name + System.currentTimeMillis() + count);

    }

    public synchronized File downloadFile(URL url, ICancellable cancel) throws DownloadException {

            File f = null;

            if((f = getPreviousDownloaded(url)) != null)

                    return f;

            Preferences prefs = Preferences.userRoot().node( "gvsig.downloader" );

            int IO_BUFFER_SIZE = 8 * 1024;

                int timeout = prefs.getInt("timeout", 60000);

                File dstFile = getFile();

                DataOutputStream dos;

                try {

                        DataInputStream is;

                        OutputStreamWriter os = null;

                        HttpURLConnection connection = null;

                        if (url.getProtocol().equals("https")) {

                                disableHttsValidation();

                        }

                        connection = (HttpURLConnection)url.openConnection();

                        connection.setConnectTimeout(timeout);

                        is = new DataInputStream(url.openStream());

                        dos = new DataOutputStream( new BufferedOutputStream(new FileOutputStream(dstFile)));

                        byte[] buffer = new byte[IO_BUFFER_SIZE];

                        int read;

                        while ((read = is.read(buffer)) != -1) {

                                dos.write(buffer, 0, read);

                        }

                        if(os != null) {

                                os.close();

                        }

                        dos.close();

                        is.close();

                        is = null;

                        dos = null;

                        if (cancel != null && cancel.isCanceled()) {

                                dstFile.delete();

                                dstFile = null;

                                return null;

                        }

                } catch (Exception e) {

                        throw new DownloadException(e);

                }

                addDownloadedURL(url, dstFile.getAbsolutePath());

                return dstFile;

    }

    /**

         * This method disables the Https certificate validation.

         * @throws KeyManagementException

         * @throws NoSuchAlgorithmException

         */

        private void disableHttsValidation() throws KeyManagementException, NoSuchAlgorithmException{

                // Create a trust manager that does not validate certificate chains

                TrustManager[] trustAllCerts = new TrustManager[] {

                                new X509TrustManager() {

                                        public java.security.cert.X509Certificate[] getAcceptedIssuers() {

                                                return null;

                                        }

                                        public void checkClientTrusted(

                                                        java.security.cert.X509Certificate[] certs, String authType) {

                                        }

                                        public void checkServerTrusted(

                                                        java.security.cert.X509Certificate[] certs, String authType) {

                                        }

                                }

                };

                // Install the all-trusting trust manager

                SSLContext sc = SSLContext.getInstance("SSL");

                sc.init(null, trustAllCerts, new java.security.SecureRandom());

                HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());

        }

        /**

     * <p>It will send a GetFeatureInfo request to the WMTS

     * Parsing the response and redirecting the info to the WMTS client</p>

     * TODO: return a stored file instead a String.

     */

    public String getFeatureInfo(WMTSStatus status, int x, int y, ICancellable cancel) {

            StringBuffer output = new StringBuffer();

            String outputFormat = new String();

            String ServiceException = "ServiceExceptionReport";

            StringBuffer sb = new StringBuffer();

            sb.append("<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>");

                try {

                        WMTSGetFeatureInfoRequest request = createGetFeatureInfoRequest(status, x, y);

                        URL url = request.getURL();

                    outputFormat = url.openConnection().getContentType();

                    File f = request.sendRequest(cancel);

                        if (f == null) {

                                return "";

                        }

                        FileReader fReader = new FileReader(f);

                        char[] buffer = new char[1024*256];

                        for (int i = fReader.read(buffer); i > 0; i = fReader.read(buffer)) {

                            String str = new String(buffer,0,i);

                            output.append(str);

                    }

                    if ( (outputFormat == null) || (outputFormat.indexOf("xml") != -1)

                                    ||output.toString().toLowerCase().startsWith("<?xml")

                                    ||(outputFormat.indexOf("gml") != -1)) {

                            KXmlParser kxmlParser = null;

                            kxmlParser = new KXmlParser();

                            //kxmlParser.setInput(new StringReader(output.toString()));

                            kxmlParser.setInput(new FileReader(f));

                            kxmlParser.nextTag();

                            if (kxmlParser.getName().compareTo(ServiceException) == 0) {

                                    sb.append("<INFO>").append(parseException( output.toString().getBytes())).append("</INFO>");

                                    return sb.toString();

                                } else if (kxmlParser.getName().compareToIgnoreCase("ERROR") == 0) {

                                        return output.toString();

                                } else {

                                        return output.toString();

                                }

                    } else {                  

                             return output.toString();

                    }

                } catch(XmlPullParserException parserEx) {

                    if (output.toString().toLowerCase().indexOf("xml") != -1) {

                            return output.toString().trim();

                    } else {

                               sb.append("<INFO>").append("Info format not supported").append("</INFO>");

                        return sb.toString();

                    }

            } catch(Exception e) {

                    e.printStackTrace();

                    sb.append("<INFO>").append("Info format not supported").append("</INFO>");

                    return sb.toString();

            }

    }

    /**

         * <p>Builds a GetCapabilities request that is sent to the WMS

         * the response will be parse to extract the data needed by the

         * WMS client</p>

         * @param override, if true the previous downloaded data will be overridden

         */

    public void getCapabilities(WMTSServerDescription status, boolean override, ICancellable cancel) {

            try {

                    setServerDescription(status);

                        WMTSGetCapabilitiesRequest request = createGetCapabilitiesRequest();

                        File f = request.sendRequest(cancel);                        

                        if (f == null)

                                return;

                        parseCapabilities(f);

            } catch(Exception e) {

                        e.printStackTrace();

                }

    }

    /**

     * Builds the GetCapabilitiesRequest according to the OGC WMS Specifications

     * without a VERSION, to get the highest version than a WMS supports.

     */

    public static String buildCapabilitiesSuitableVersionRequest(String _host, String _version) {

                int index = _host.indexOf('?');

                if (index > -1) {

                        String host = _host.substring(0, index + 1);

                        String query = _host.substring(index + 1, _host.length());

                        StringTokenizer tokens = new StringTokenizer(query, "&");

                        String newQuery = "", token;

                        // If there is a field or a value with spaces, (and then it's on different tokens) -> unify them

                        while (tokens.hasMoreTokens()) {

                                token = tokens.nextToken().trim();

                                if (token.toUpperCase().compareTo("REQUEST=GETCAPABILITIES") == 0)

                                        continue;

                                if (token.toUpperCase().compareTo("SERVICE=WMTS") == 0)

                                        continue;

                                if ((_version != null) && (_version.length() > 0)) {

                                    if (token.toUpperCase().compareTo("VERSION=" + _version) == 0)

                                            continue;

                                }

                                if (token.toUpperCase().compareTo("EXCEPTIONS=XML") == 0)

                                        continue;

                                newQuery += token + "&";

                        }

                _host = host + newQuery;

                }

                else {

                        _host += "?";

                }

            if ((_version != null) && (_version.compareTo("") != 0))

                    _host += "REQUEST=GetCapabilities&SERVICE=WMTS&VERSION=" + _version;

            else

                    _host += "REQUEST=GetCapabilities&SERVICE=WMTS";

            return _host;

    }

   /*

    * (non-Javadoc)

    * @see org.gvsig.remoteclient.ogc.OGCProtocolHandler#getServiceInformation()

    */

    public OGCServiceInformation getServiceInformation() {

        return serviceInfo;

    }

        protected String parseException(byte[] data) throws IOException {

        ArrayList errors = new ArrayList();

        KXmlParser kxmlParser = new KXmlParser();

        try

        {

            kxmlParser.setInput(new ByteArrayInputStream(data), encoding);

            kxmlParser.nextTag();

            int tag;

            if ( kxmlParser.getEventType() != KXmlParser.END_DOCUMENT )

            {

                kxmlParser.require(KXmlParser.START_TAG, null, ExceptionTags.EXCEPTION_ROOT);

                tag = kxmlParser.nextTag();

                 while(tag != KXmlParser.END_DOCUMENT)

                 {

                     switch(tag)

                     {

                        case KXmlParser.START_TAG:

                            if (kxmlParser.getName().compareTo(ExceptionTags.SERVICE_EXCEPTION)==0){

                                String errorCode = kxmlParser.getAttributeValue("", ExceptionTags.CODE);

                                errorCode = (errorCode != null) ? "["+errorCode+"] " : "";

                                String errorMessage = kxmlParser.nextText();

                                errors.add(errorCode+errorMessage);

                            }

                            break;

                        case KXmlParser.END_TAG:

                            break;

                     }

                     tag = kxmlParser.nextTag();

                 }

                 //kxmlParser.require(KXmlParser.END_DOCUMENT, null, null);

            }

        }

        catch(XmlPullParserException parser_ex){

            throw new IOException(parser_ex.getMessage());

        }

        String message = errors.size()>0? "" : null;

        for (int i = 0; i < errors.size(); i++) {

            message += (String) errors.get(i)+"\n";

        }

        return message;

    }

 }