vaadin-framework/client/src/com/vaadin/client/communication/XhrConnection.java

/*
 * Copyright 2000-2014 Vaadin Ltd.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */
package com.vaadin.client.communication;

import java.util.Date;
import java.util.logging.Logger;

import com.google.gwt.http.client.Request;
import com.google.gwt.http.client.RequestBuilder;
import com.google.gwt.http.client.RequestCallback;
import com.google.gwt.http.client.RequestException;
import com.google.gwt.http.client.Response;
import com.google.gwt.user.client.Timer;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.Window.ClosingEvent;
import com.google.gwt.user.client.Window.ClosingHandler;
import com.vaadin.client.ApplicationConnection;
import com.vaadin.client.ApplicationConnection.CommunicationHandler;
import com.vaadin.client.ApplicationConnection.RequestStartingEvent;
import com.vaadin.client.ApplicationConnection.ResponseHandlingEndedEvent;
import com.vaadin.client.ApplicationConnection.ResponseHandlingStartedEvent;
import com.vaadin.client.BrowserInfo;
import com.vaadin.shared.ApplicationConstants;
import com.vaadin.shared.JsonConstants;
import com.vaadin.shared.ui.ui.UIConstants;
import com.vaadin.shared.util.SharedUtil;

import elemental.json.JsonObject;

/**
 * Provides a connection to the /UIDL url on the server and knows how to send
 * messages to that end point
 * 
 * @since 7.6
 * @author Vaadin Ltd
 */
public class XhrConnection {

    private ApplicationConnection connection;

    /**
     * Webkit will ignore outgoing requests while waiting for a response to a
     * navigation event (indicated by a beforeunload event). When this happens,
     * we should keep trying to send the request every now and then until there
     * is a response or until it throws an exception saying that it is already
     * being sent.
     */
    private boolean webkitMaybeIgnoringRequests = false;

    public XhrConnection() {
        Window.addWindowClosingHandler(new ClosingHandler() {
            @Override
            public void onWindowClosing(ClosingEvent event) {
                webkitMaybeIgnoringRequests = true;
            }
        });
    }

    /**
     * Sets the application connection this queue is connected to
     *
     * @param connection
     *            the application connection this queue is connected to
     */
    public void setConnection(ApplicationConnection connection) {
        this.connection = connection;

        connection.addHandler(ResponseHandlingEndedEvent.TYPE,
                new CommunicationHandler() {
                    @Override
                    public void onRequestStarting(RequestStartingEvent e) {
                    }

                    @Override
                    public void onResponseHandlingStarted(
                            ResponseHandlingStartedEvent e) {
                    }

                    @Override
                    public void onResponseHandlingEnded(
                            ResponseHandlingEndedEvent e) {
                        webkitMaybeIgnoringRequests = false;
                    }
                });

    }

    public static Logger getLogger() {
        return Logger.getLogger(XhrConnection.class.getName());
    }

    protected XhrResponseHandler createResponseHandler() {
        return new XhrResponseHandler();
    }

    public class XhrResponseHandler implements RequestCallback {

        private JsonObject payload;
        private Date requestStartTime;

        public XhrResponseHandler() {
        }

        /**
         * Sets the payload which was sent to the server
         * 
         * @param payload
         *            the payload which was sent to the server
         */
        public void setPayload(JsonObject payload) {
            this.payload = payload;
        }

        @Override
        public void onError(Request request, Throwable exception) {
            getCommunicationProblemHandler().xhrException(
                    new CommunicationProblemEvent(request, payload, exception));
        }

        private ServerCommunicationHandler getServerCommunicationHandler() {
            return connection.getServerCommunicationHandler();
        }

        @Override
        public void onResponseReceived(Request request, Response response) {
            int statusCode = response.getStatusCode();

            if (statusCode != 200) {
                // There was a problem
                CommunicationProblemEvent problemEvent = new CommunicationProblemEvent(
                        request, payload, response);

                getCommunicationProblemHandler().xhrInvalidStatusCode(
                        problemEvent);
                return;
            }

            getLogger().info(
                    "Server visit took "
                            + String.valueOf((new Date()).getTime()
                                    - requestStartTime.getTime()) + "ms");

            String contentType = response.getHeader("Content-Type");
            if (contentType == null
                    || !contentType.startsWith("application/json")) {
                getCommunicationProblemHandler().xhrInvalidContent(
                        new CommunicationProblemEvent(request, payload,
                                response));
                return;
            }

            // for(;;);["+ realJson +"]"
            String responseText = response.getText();

            final String jsonText = ServerCommunicationHandler
                    .stripJSONWrapping(responseText);
            if (jsonText == null) {
                // Invalid string (not wrapped as expected)
                getCommunicationProblemHandler().xhrInvalidContent(
                        new CommunicationProblemEvent(request, payload,
                                response));
                return;
            }

            getCommunicationProblemHandler().xhrOk();
            getLogger().info("Received xhr message: " + jsonText);
            getServerMessageHandler().handleMessage(jsonText);
        }

        /**
         * Sets the time when the request was sent
         * 
         * @param requestStartTime
         *            the time when the request was sent
         */
        public void setRequestStartTime(Date requestStartTime) {
            this.requestStartTime = requestStartTime;

        }
    };

    /**
     * Sends an asynchronous UIDL request to the server using the given URI.
     * 
     * @param payload
     *            The URI to use for the request. May includes GET parameters
     * @throws RequestException
     *             if the request could not be sent
     */
    public void send(JsonObject payload) {
        RequestBuilder rb = new RequestBuilder(RequestBuilder.POST, getUri());
        // TODO enable timeout
        // rb.setTimeoutMillis(timeoutMillis);
        // TODO this should be configurable
        rb.setHeader("Content-Type", JsonConstants.JSON_CONTENT_TYPE);
        rb.setRequestData(payload.toJson());

        XhrResponseHandler responseHandler = createResponseHandler();
        responseHandler.setPayload(payload);
        responseHandler.setRequestStartTime(new Date());

        rb.setCallback(responseHandler);

        getLogger().info("Sending xhr message to server: " + payload.toJson());
        try {
            final Request request = rb.send();

            if (webkitMaybeIgnoringRequests && BrowserInfo.get().isWebkit()) {
                final int retryTimeout = 250;
                new Timer() {
                    @Override
                    public void run() {
                        // Use native js to access private field in Request
                        if (resendRequest(request)
                                && webkitMaybeIgnoringRequests) {
                            // Schedule retry if still needed
                            schedule(retryTimeout);
                        }
                    }
                }.schedule(retryTimeout);
            }
        } catch (RequestException e) {
            getCommunicationProblemHandler().xhrException(
                    new CommunicationProblemEvent(null, payload, e));
        }
    }

    /**
     * Retrieves the URI to use when sending RPCs to the server
     * 
     * @return The URI to use for server messages.
     */
    protected String getUri() {
        String uri = connection
                .translateVaadinUri(ApplicationConstants.APP_PROTOCOL_PREFIX
                        + ApplicationConstants.UIDL_PATH + '/');

        uri = SharedUtil.addGetParameters(uri, UIConstants.UI_ID_PARAMETER
                + "=" + connection.getConfiguration().getUIId());

        return uri;

    }

    private CommunicationProblemHandler getCommunicationProblemHandler() {
        return connection.getCommunicationProblemHandler();
    }

    private ServerMessageHandler getServerMessageHandler() {
        return connection.getServerMessageHandler();
    }

    private static native boolean resendRequest(Request request)
    /*-{
        var xhr = request.@com.google.gwt.http.client.Request::xmlHttpRequest
        if (xhr.readyState != 1) {
            // Progressed to some other readyState -> no longer blocked
            return false;
        }
        try {
            xhr.send();
            return true;
        } catch (e) {
            // send throws exception if it is running for real
            return false;
        }
    }-*/;

}