package org.astrogrid.samp.client;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.astrogrid.samp.ErrInfo;
import org.astrogrid.samp.Message;
import org.astrogrid.samp.Response;
import org.astrogrid.samp.SampMap;
import org.astrogrid.samp.Subscriptions;
/**
* Partial implementation of MessageHandler interface which helps to ensure
* correct client behaviour.
* Concrete subclasses just need to specify the MTypes they subscribe to
* and implement the {@link #processCall} method.
*
* @author Mark Taylor
* @since 16 Jul 2008
*/
public abstract class AbstractMessageHandler implements MessageHandler {
private Subscriptions subscriptions_;
private final Logger logger_ =
Logger.getLogger( AbstractMessageHandler.class.getName() );
/**
* Constructor using a given subscriptions map.
*
* @param subscriptions {@link org.astrogrid.samp.Subscriptions}-like map
* defining which MTypes this handler can process
*/
protected AbstractMessageHandler( Map subscriptions ) {
setSubscriptions( subscriptions );
}
/**
* Constructor using a given list of subscribed MTypes.
*
* @param mtypes list of MTypes which this handler can process
*/
protected AbstractMessageHandler( String[] mtypes ) {
Map subs = new HashMap();
for ( int i = 0; i < mtypes.length; i++ ) {
subs.put( mtypes[ i ], new HashMap() );
}
setSubscriptions( subs );
}
/**
* Constructor using a single subscribed MType.
*
* @param mtype single MType which this handler can process
*/
protected AbstractMessageHandler( String mtype ) {
this( new String[] { mtype } );
}
/**
* Implements message processing. Implementations should normally
* return a map which contains the samp.result part
* of the call response, that is the MType-specific return value
* name->value map.
* As a special case, returning null is equivalent to returning an empty
* map.
* However, if {@link #createResponse} is overridden, the return value
* semantics may be different.
*
* @param connection hub connection
* @param senderId public ID of sender client
* @param message message with MType this handler is subscribed to
* @return result of handling this message; exact semantics determined
* by {@link #createResponse createResponse} implementation
*/
public abstract Map processCall( HubConnection connection, String senderId,
Message message )
throws Exception;
/**
* Invoked by {@link #receiveCall receiveCall} to create a success
* response from the result of calling {@link #processCall processCall}.
*
*
The default implementation calls * {@link Response#createSuccessResponse}(processOutput), * first transforming a null value to an empty map for convenience. * However, it may be overridden for more flexibility (for instance * in order to return non-OK responses). * * @param processOutput a Map returned by {@link #processCall processCall} */ protected Response createResponse( Map processOutput ) { Map result = processOutput == null ? SampMap.EMPTY : processOutput; return Response.createSuccessResponse( result ); } /** * Sets the subscriptions map. Usually this is called by the constructor, * but it may be reset manually. * * @param subscriptions {@link org.astrogrid.samp.Subscriptions}-like map * defining which MTypes this handler can process */ public void setSubscriptions( Map subscriptions ) { Subscriptions subs = Subscriptions.asSubscriptions( subscriptions ); subs.check(); subscriptions_ = subs; } public Map getSubscriptions() { return subscriptions_; } /** * Calls {@link #processCall} and discards the result. */ public void receiveNotification( HubConnection connection, String senderId, Message message ) { try { processCall( connection, senderId, message ); } catch ( Throwable e ) { logger_.log( Level.INFO, "Error processing notification " + message.getMType() + " - ignored", e ); } } /** * Calls {@link #processCall}, generates a response from the result * using {@link #createResponse}, and sends the resulting response * as a reply to the hub. In case of an exception, a suitable error * response is sent instead. */ public void receiveCall( HubConnection connection, String senderId, String msgId, Message message ) throws SampException { Response response; try { response = createResponse( processCall( connection, senderId, message ) ); } catch ( Throwable e ) { response = Response.createErrorResponse( new ErrInfo( e ) ); } connection.reply( msgId, response ); } }