Thanks for your hints, guys. Here is my solution:

---------- OfflineRequestCallback: used to get serialized response and
handle it appropriately.

public class OfflineRequestCallback implements RequestCallback {

        // This String we can save in localStorage.
        private static String serializedResponse;
        private RequestCallback callback;

        public OfflineRequestCallback(RequestCallback callback) {
                this.callback = callback;
        }

        @Override
        public void onResponseReceived(Request request, Response response) {

                if (response.getStatusCode() == 200) {
                        serializedResponse = response.getText();
                        callback.onResponseReceived(request, response);
                }
                else {
                        callback.onResponseReceived(request, getOldResponse());
                }
        }

        @Override
        public void onError(Request request, Throwable exception) {
                callback.onResponseReceived(request, getOldResponse());
        }

        private Response getOldResponse() {

                return new Response() {

                        @Override
                        public String getText() {
                                return serializedResponse;
                        }

                        @Override
                        public String getStatusText() {
                                return null;
                        }

                        @Override
                        public int getStatusCode() {
                                return 200;
                        }

                        @Override
                        public String getHeadersAsString() {
                                return null;
                        }

                        @Override
                        public Header[] getHeaders() {
                                return null;
                        }

                        @Override
                        public String getHeader(String header) {
                                return null;
                        }
                };
        }
}

---------- OfflineRequestBuilder: uses OfflineRequestCallback as a
wrapper class.

public class OfflineRequestBuilder extends RequestBuilder {

        public OfflineRequestBuilder(Method httpMethod, String url) {
                super(httpMethod, url);
        }

        @Override
        public Request send() throws RequestException {

                String requestData = super.getRequestData();
                OfflineRequestCallback requestCallbackWrapper = new
OfflineRequestCallback(
                                super.getCallback());
                return super.sendRequest(requestData, requestCallbackWrapper);
        }
}

---------- Client code:

...
private final TestServiceAsync testService =
GWT.create(TestService.class);

public void onModuleLoad() {
        ...
        RpcRequestBuilder builder = new RpcRequestBuilder() {
                @Override
                protected RequestBuilder doCreate(String serviceEntryPoint) {
                                return new 
OfflineRequestBuilder(RequestBuilder.POST,
                                                ((ServiceDefTarget) 
testService).getServiceEntryPoint());
                }
        };
        ((ServiceDefTarget) testService).setRpcRequestBuilder(builder);
        ...
        // RPC call
        testService.serviceFunction(param, callback);
}


Regards,

Alex

-- 
You received this message because you are subscribed to the Google Groups 
"Google Web Toolkit" group.
To post to this group, send email to google-web-tool...@googlegroups.com.
To unsubscribe from this group, send email to 
google-web-toolkit+unsubscr...@googlegroups.com.
For more options, visit this group at 
http://groups.google.com/group/google-web-toolkit?hl=en.

Reply via email to