public interface AsyncCallback<T>

The primary interface a caller must implement to receive a response from a remote procedure call.

If an RPC is successful, then onSuccess(Object) is called, otherwise onFailure(Throwable) is called.

Each callable asynchronous method corresponds to a method in the correlated service interface. The asynchronous method always takes an AsyncCallback<T> as its last parameter, where T is the return type of the correlated synchronous method.

As an example, suppose the service interface defines a method called getShapes as follows:

 Shape[] getShapes(String databaseName) throws ShapeException, DbException;
 

Its asynchronous counterpart method be declared as:

 void getShapes(String databaseName, AsyncCallback<Shape[]> callback);
 

Note that throws declaration is not repeated in the async version.

A call with a typical use of AsyncCallback might look like this:

 service.getShapes(dbName, new AsyncCallback() {
   public void onSuccess(Shape[] result) {
     // It's always safe to downcast to the known return type. 
     controller.processShapes(result);
   }
 
   public void onFailure(Throwable caught) {
     // Convenient way to find out which exception was thrown.
     try {
       throw caught;
     } catch (IncompatibleRemoteServiceException e) {
       // this client is not compatible with the server; cleanup and refresh the 
       // browser
     } catch (InvocationException e) {
       // the call didn't complete cleanly
     } catch (ShapeException e) {
       // one of the 'throws' from the original method
     } catch (DbException e) {
       // one of the 'throws' from the original method
     } catch (Throwable e) {
       // last resort -- a very unexpected exception
     }
   }
 });