| /* |
| * Copyright 2007 Google Inc. |
| * |
| * 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.google.gwt.sample.simplerpc.client; |
| |
| import com.google.gwt.core.client.EntryPoint; |
| import com.google.gwt.core.client.GWT; |
| import com.google.gwt.user.client.Window; |
| import com.google.gwt.user.client.rpc.AsyncCallback; |
| import com.google.gwt.user.client.ui.FlexTable; |
| import com.google.gwt.user.client.ui.HTML; |
| import com.google.gwt.user.client.ui.Panel; |
| import com.google.gwt.user.client.ui.RootPanel; |
| |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Map.Entry; |
| |
| /** |
| * Demonstrates a simple use of the RPC mechanism. |
| */ |
| public class SimpleRPC implements EntryPoint { |
| |
| public void onModuleLoad() { |
| final Panel root = RootPanel.get(); |
| |
| // Create the RPC client. |
| SimpleRPCServiceAsync simpleRPCService = createSimpleRPCServiceAsync(); |
| |
| // Collection of very simple RPC calls to "getString". |
| callGetString(root, simpleRPCService); |
| |
| // A single simple call to "getMultipleStrings". |
| callGetMultipleStrings(root, simpleRPCService); |
| } |
| |
| /** |
| * Creates a single call to <code>getMultipleStrings</code>. |
| */ |
| private void callGetMultipleStrings(final Panel root, |
| SimpleRPCServiceAsync simpleRPCService) { |
| AsyncCallback<Map<Integer, String>> getMultipleStringsCallback = createGetMultipleStringsCallback(root); |
| |
| // Should print a table of key value pairs. |
| List<Integer> indexes = new ArrayList<Integer>(); |
| indexes.add(Integer.valueOf(0)); |
| indexes.add(Integer.valueOf(2)); |
| simpleRPCService.getMultipleStrings(indexes, getMultipleStringsCallback); |
| } |
| |
| /** |
| * Calls <code>getString</code> three times, the first two should return |
| * valid answers, the third should give back an error. <p/> Control flow will |
| * continue after making each call. Later the 'callback' onSuccess or |
| * onFailure method will be invoked when the RPC completes. There is no order |
| * guarantee here, the three results could appear on the page in any order. |
| */ |
| private void callGetString(final Panel root, |
| SimpleRPCServiceAsync simpleRPCService) { |
| // Create a callback to use. |
| AsyncCallback<String> singleGetStringCallback = createGetStringCallback(root); |
| |
| // Should print 'Hello World'. |
| simpleRPCService.getString(0, singleGetStringCallback); |
| |
| // Should print 'Bonjour monde'. |
| simpleRPCService.getString(1, singleGetStringCallback); |
| |
| // Should print an IndexOutOfBoundsException. |
| simpleRPCService.getString(3, singleGetStringCallback); |
| } |
| |
| /** |
| * Create an asynchronous callback for the <code>getMultipleStrings</code> |
| * RPC call. The same callback can be used for many RPC calls or customized |
| * for a single one. |
| */ |
| private AsyncCallback<Map<Integer, String>> createGetMultipleStringsCallback( |
| final Panel root) { |
| return new AsyncCallback<Map<Integer, String>>() { |
| |
| public void onFailure(Throwable caught) { |
| Window.alert("error: " + caught); |
| } |
| |
| public void onSuccess(Map<Integer, String> result) { |
| FlexTable t = new FlexTable(); |
| t.setBorderWidth(2); |
| t.setHTML(0, 0, "<b>Map Key</b>"); |
| t.setHTML(0, 1, "<b>Map Value</b>"); |
| int index = 1; |
| for (Entry<Integer, String> element : result.entrySet()) { |
| Integer key = element.getKey(); |
| String value = element.getValue(); |
| t.setText(index, 0, key.toString()); |
| t.setText(index, 1, value); |
| ++index; |
| } |
| root.add(new HTML("<h3>Result(on success)</h3>")); |
| root.add(t); |
| } |
| }; |
| } |
| |
| /** |
| * Create an asynchronous callback for the <code>getString</code> RPC call. |
| * The same callback can be used for many RPC calls or customized for a single |
| * one. |
| */ |
| private AsyncCallback<String> createGetStringCallback(final Panel root) { |
| return new AsyncCallback<String>() { |
| public void onFailure(Throwable caught) { |
| root.add(new HTML("<h3>Result (on failure) </h3>")); |
| root.add(new HTML("<i>" + caught.getMessage() + "</i>")); |
| } |
| |
| public void onSuccess(String result) { |
| root.add(new HTML("<h3>Result (on success) </h3>" + result)); |
| } |
| }; |
| } |
| |
| /** |
| * Returns an configured instance of the <code>SimpleRPCService</code> |
| * client proxy. <p/> Note that although you are creating the service |
| * interface proper, you cast the result to the asynchronous version of the |
| * interface. The cast is always safe because the generated proxy implements |
| * the asynchronous interface automatically. |
| */ |
| private SimpleRPCServiceAsync createSimpleRPCServiceAsync() { |
| return GWT.<SimpleRPCServiceAsync> create(SimpleRPCService.class); |
| } |
| } |