esgcontroller.java

world wind java sdk 源码

            setResultsStatusFinished();
        }
    }

    private static class GetServiceDataTask implements Callable<Object>
    {
        private ESGResultModel resultModel;
        private ESGController controller;

        private GetServiceDataTask(ESGResultModel resultModel, ESGController controller)
        {
            this.resultModel = resultModel;
            this.controller = controller;
        }

        public Object call() throws Exception
        {
            this.controller.doGetServiceData(this.resultModel);
            return null;
        }
    }

    private void doGetServiceData(ESGResultModel resultModel)
    {
        if (resultModel == null)
        {
            String message = "nullValue.ResultModelIsNull";
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }

        // Do not process the request if the ServicePackage is not available,
        // or if ServiceData already exists.
        if (resultModel.getServicePackage() != null &&
            resultModel.getServicePackage().getServiceDataCount() == 0)
        {
            resultModel.setValue(CatalogKey.WAITING, Boolean.TRUE);
            resultModel.firePropertyChange();
            try
            {
                GetServiceData getData = new GetServiceData(resultModel);
                getData.executeRequest(this.connectionPool);

                GetCapabilities getCapabilities = new GetCapabilities(resultModel);
                getCapabilities.executeRequest(this.connectionPool);

                linkServiceData(resultModel);
            }
            catch (Exception e)
            {
                String message = "esg.ExceptionWhileGettingServiceData";
                Logging.logger().log(java.util.logging.Level.SEVERE, message, e);
            }
            finally
            {
                resultModel.setValue(CatalogKey.WAITING, Boolean.FALSE);
                resultModel.firePropertyChange();
            }
        }
    }

    private void linkServiceData(ESGResultModel resultModel)
    {
        if (resultModel == null)
        {
            String message = "nullValue.ResultModelIsNull";
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }

        if (resultModel.getServicePackage() != null)
        {
            for (int i = 0; i < resultModel.getServicePackage().getServiceDataCount(); i++)
            {
                ServiceData serviceData = resultModel.getServicePackage().getServiceData(i);
                if (serviceData != null)
                {
                    Object key = serviceDataKey(serviceData);
                    if (this.wwLayerMap.containsKey(key))
                    {
                        Object wwLayer = this.wwLayerMap.get(key);
                        serviceData.setValue(CatalogKey.LAYER_STATE, CatalogKey.LAYER_STATE_INSTALLED);
                        serviceData.setValue(AVKey.LAYER, wwLayer);
                    }
                }
            }
        }
    }

    private static Object serviceDataKey(AVList params)
    {
        Object key = null;
        if (params != null)
        {
            StringBuilder sb = new StringBuilder();
            sb.append(params.getValue(AVKey.LAYER_NAMES));
            sb.append("/");
            sb.append(params.getValue(AVKey.STYLE_NAMES));
            key = sb.toString();
        }
        return key;
    }

    private static class GetServiceInfoTask implements Callable<Object>
    {
        private ESGResultModel resultModel;
        private ESGController controller;

        private GetServiceInfoTask(ESGResultModel resultModel, ESGController controller)
        {
            this.resultModel = resultModel;
            this.controller = controller;
        }

        public Object call() throws Exception
        {
            this.controller.doGetServiceInfo(this.resultModel);
            return null;
        }
    }

    private void doGetServiceInfo(ESGResultModel resultModel)
    {
        if (resultModel == null)
        {
            String message = "nullValue.ResultModelIsNull";
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }

        addResultActor();
        resultModel.setValue(CatalogKey.WAITING, Boolean.TRUE);
        resultModel.firePropertyChange(CatalogKey.WAITING, null, resultModel);
        try
        {
            GetServiceCommon getCommon = new GetServiceCommon(resultModel);
            getCommon.executeRequest(this.connectionPool);
        }
        catch (Exception e)
        {
            String message = "esg.ExceptionWhileGettingServiceInfo";
            Logging.logger().log(java.util.logging.Level.SEVERE, message, e);
        }
        finally
        {
            removeResultActor();
            resultModel.setValue(CatalogKey.WAITING, Boolean.FALSE);
            resultModel.firePropertyChange();
        }
    }

    private static class GetServiceMetadataTask implements Callable<Object>
    {
        private ESGResultModel resultModel;
        private ESGController controller;

        private GetServiceMetadataTask(ESGResultModel resultModel, ESGController controller)
        {
            this.resultModel = resultModel;
            this.controller = controller;
        }

        public Object call() throws Exception
        {
            this.controller.doGetServiceMetadata(this.resultModel);
            return null;
        }
    }

    private void doGetServiceMetadata(ESGResultModel resultModel)
    {
        if (resultModel == null)
        {
            String message = "nullValue.ResultModelIsNull";
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }

        if (resultModel.getServicePackage() != null &&
            resultModel.getServicePackage().getContextDocument() == null)
        {
            resultModel.setValue(CatalogKey.WAITING, Boolean.TRUE);
            resultModel.firePropertyChange(CatalogKey.WAITING, null, resultModel);
            try
            {
                GetContextDocument getContextDocument = new GetContextDocument(resultModel);
                getContextDocument.executeRequest(this.connectionPool);
            }
            catch (Exception e)
            {
                String message = "esg.ExceptionWhileGettingServiceMetadata";
                Logging.logger().log(java.util.logging.Level.SEVERE, message, e);
            }
            finally
            {
                resultModel.setValue(CatalogKey.WAITING, Boolean.FALSE);
                resultModel.firePropertyChange();
            }
        }
    }

    private static class ShowServiceDetailsTask implements Callable<Object>
    {
        private ESGResultModel resultModel;
        private ESGController controller;

        private ShowServiceDetailsTask(ESGResultModel resultModel, ESGController controller)
        {
            this.resultModel = resultModel;
            this.controller = controller;
        }

        public Object call() throws Exception
        {
            this.controller.doGetServiceMetadata(this.resultModel);
            this.controller.doShowServiceDetails(this.resultModel);
            return null;
        }
    }

    private void doShowServiceDetails(ESGResultModel resultModel)
    {
        if (resultModel == null)
        {
            String message = "esg.ResultModelIsNull";
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }

        try
        {
            ServiceDetailsDialog.showDialog(this.esgPanel.getServiceDetailsContentPath(),
                this.esgPanel.getServiceDetailsContentType(), resultModel, true);
        }
        catch (Exception e)
        {
            String message = "esg.ExceptionWhileShowingServiceDetails";
            Logging.logger().log(java.util.logging.Level.SEVERE, message, e);
        }
    }
    
    private static class UpdateServiceDataTask implements Callable<Object>
    {
        private ESGResultModel resultModel;
        private ServiceData serviceData;
        private ESGController controller;

        private UpdateServiceDataTask(ESGResultModel resultModel, ServiceData serviceData, ESGController controller)
        {
            this.resultModel = resultModel;
            this.serviceData = serviceData;
            this.controller = controller;
        }

        public Object call() throws Exception
        {
            this.controller.doUpdateServiceData(this.resultModel, this.serviceData);
            return null;
        }
    }

    private void doUpdateServiceData(ESGResultModel resultModel, ServiceData serviceData)
    {
        if (resultModel == null)
        {
            String message = "nullValue.ResultModelIsNull";
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }
        if (serviceData == null)
        {
            String message = "nullValue.ServiceDataIsNull";
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }

        try
        {
            String layerState = serviceData.getStringValue(CatalogKey.LAYER_STATE);
            if (CatalogKey.LAYER_STATE_READY.equalsIgnoreCase(layerState) || layerState == null)
            {
                Capabilities caps = resultModel.getCapabilities();
                addLayerToWorldWind(caps, serviceData);
                serviceData.setValue(CatalogKey.LAYER_STATE, CatalogKey.LAYER_STATE_INSTALLED);
            }
            else if (CatalogKey.LAYER_STATE_INSTALLED.equalsIgnoreCase(layerState))
            {
                removeLayerFromWorldWind(serviceData);
                serviceData.setValue(CatalogKey.LAYER_STATE, CatalogKey.LAYER_STATE_READY);
            }
        }
        catch (Exception e)
        {
            String message = "esg.ExceptionWhileInstallingLayer";
            Logging.logger().log(java.util.logging.Level.SEVERE, message, e);
            // Flag an error happened while installing the layer.
            serviceData.setValue(CatalogKey.LAYER_STATE, CatalogKey.LAYER_STATE_ERROR);
            serviceData.addException(new CatalogException(e.getMessage(), e));
        }
        finally
        {
            resultModel.firePropertyChange();
        }
    }

    private void addLayerToWorldWind(Capabilities caps, AVList layerParams)
    {
        if (caps == null)
        {
            String message = "nullValue.CapabilitiesIsNull";
            Logging.logger().severe(message);
            throw new IllegalStateException(message);
        }
        if (layerParams == null)
        {
            String message = "nullValue.LayerParamsIsNull";
            Logging.logger().severe(message);
            throw new IllegalStateException(message);
        }

        WorldWindow wwd = this.esgPanel.getWorldWindow();
        if (wwd == null)
        {
            String message = "No World Wind instance is running.";
            Logging.logger().severe(message);
            throw new IllegalStateException(message);
        }

        WMSTiledImageLayer wmsLayer = new WMSTiledImageLayer(caps, layerParams);
        String s = layerParams.getStringValue(AVKey.TITLE);
        if (s != null)
            wmsLayer.setName(s);
        // Some wms servers are slow, so increase the timeouts and limits used by world wind's retrievers.
        wmsLayer.setValue(AVKey.URL_CONNECT_TIMEOUT, 30000);
        wmsLayer.setValue(AVKey.URL_READ_TIMEOUT, 30000);
        wmsLayer.setValue(AVKey.RETRIEVAL_QUEUE_STALE_REQUEST_LIMIT, 60000);
        ApplicationTemplate.insertBeforePlacenames(wwd, wmsLayer);

        layerParams.setValue(AVKey.LAYER, wmsLayer);

        Object key = serviceDataKey(layerParams);
        this.wwLayerMap.put(key, wmsLayer);
    }

    private void removeLayerFromWorldWind(AVList layerParams)
    {
        if (layerParams == null)
        {
            String message = "nullValue.LayerParamsIsNull";
            Logging.logger().severe(message);
            throw new IllegalStateException(message);
        }

        WorldWindow wwd = this.esgPanel.getWorldWindow();
        if (wwd == null)
        {
            String message = "No World Wind instance is running.";
            Logging.logger().severe(message);
            throw new IllegalStateException(message);
        }

        gov.nasa.worldwind.layers.LayerList wwLayerList = wwd.getModel().getLayers();
        if (wwLayerList == null)
        {
            String message = "Missing Layer List in World Wind.";
            Logging.logger().severe(message);
            throw new IllegalStateException(message);
        }

        Object o = layerParams.getValue(AVKey.LAYER);
        if (o == null || !(o instanceof gov.nasa.worldwind.layers.Layer))
        {
            String message = "Layer is not installed in World Wind.";
            Logging.logger().severe(message);
            throw new IllegalStateException(message);
        }

        gov.nasa.worldwind.layers.Layer wwLayer = (gov.nasa.worldwind.layers.Layer) o;
        wwLayerList.remove(wwLayer);

        layerParams.removeKey(AVKey.LAYER);

        Object key = serviceDataKey(layerParams);
        this.wwLayerMap.remove(key);
    }
}