JBoss.orgCommunity Documentation

Chapter 2. Resource Adaptor Type

2.1. Activities
2.2. Events
2.3. Activity Context Interface Factory
2.4. Resource Adaptor Interface
2.5. Restrictions
2.6. Sbb Code Examples

MAP Resource Adaptor Type is defined by JBoss Communications team as part of effort to standardize RA Types.

An MAP activity object represents a set of related events in an MAP resource. This Ra Type defines only one Activity object:

Events represent's MAP's common services as well as services related to USSD Events are fired on MAPDialog


The interface of the MAP resource adaptor type specific Activity Context Interface Factory is defined as follows:

package org.mobicents.slee.resource.map;

import org.mobicents.protocols.ss7.map.api.MAPDialog;

import javax.slee.ActivityContextInterface;
import javax.slee.FactoryException;
import javax.slee.UnrecognizedActivityException;

public interface MAPContextInterfaceFactory {

	public ActivityContextInterface getActivityContextInterface(MAPDialog dialog) throws NullPointerException,
			UnrecognizedActivityException, FactoryException;

}
	

The MAP Resource Adaptor SBB Interface provides SBBs with access to the MAP objects required for creating a new, aborting, ending a MAPdialog and sending USSD Request/Response. It is defined as follows:

package org.mobicents.protocols.ss7.map.api;

import org.mobicents.protocols.ss7.map.api.dialog.AddressString;
import org.mobicents.protocols.ss7.sccp.parameter.SccpAddress;

/**
 * 
 * @author amit bhayani
 * 
 */
public interface MAPProvider {

	public static final int NETWORK_UNSTRUCTURED_SS_CONTEXT_V2 = 1;

	/**
	 * Creates a new Dialog. This is equivalent to issuing MAP_OPEN Service
	 * Request to MAP Provider.
	 * 
	 * @param applicationCntx
	 *            This parameter identifies the type of application context
	 *            being established. If the dialogue is accepted the received
	 *            application context name shall be echoed. In case of refusal
	 *            of dialogue this parameter shall indicate the highest version
	 *            supported.
	 * 
	 * @param destAddress
	 *            A valid SCCP address identifying the destination peer entity.
	 *            As an implementation option, this parameter may also, in the
	 *            indication, be implicitly associated with the service access
	 *            point at which the primitive is issued.
	 * 
	 * @param destReference
	 *            This parameter is a reference which refines the identification
	 *            of the called process. It may be identical to Destination
	 *            address but its value is to be carried at MAP level.
	 * 
	 * @param origAddress
	 *            A valid SCCP address identifying the requestor of a MAP
	 *            dialogue. As an implementation option, this parameter may
	 *            also, in the request, be implicitly associated with the
	 *            service access point at which the primitive is issued.
	 * 
	 * @param origReference
	 *            This parameter is a reference which refines the identification
	 *            of the calling process. It may be identical to the Originating
	 *            address but its value is to be carried at MAP level.
	 *            Processing of the Originating-reference shall be performed
	 *            according to the supplementary service descriptions and other
	 *            service descriptions, e.g. operator determined barring.
	 * @return
	 */
	public MAPDialog createNewDialog(MAPApplicationContext appCntx,			
			SccpAddress origAddress, AddressString origReference,
			SccpAddress destAddress, AddressString destReference ) throws MAPException;

	/**
	 * 
	 * @param mapDialogListener
	 */
	public void addMAPDialogListener(MAPDialogListener mapDialogListener);

	/**
	 * 
	 * @param mapDialogListener
	 */
	public void removeMAPDialogListener(MAPDialogListener mapDialogListener);

	/**
	 * 
	 * @param mapServiceListener
	 */
	public void addMAPServiceListener(MAPServiceListener mapServiceListener);

	/**
	 * 
	 * @param mapServiceListener
	 */
	public void removeMAPServiceListener(MAPServiceListener mapServiceListener);

	public MapServiceFactory getMapServiceFactory();
	
	public MAPDialog getMAPDialog(Long dialogId);

}
	
	

The resource adaptor implementation should prevent SBBs from adding themselves as MAP listeners, or changing the MAP network configuration. Any attempt to do so should be rejected by throwing a SecurityException.

The following code shows complete flow of application receiving the MAP Dialog request and then USSD Request. Application sends back Unstructured SS Response and finally on receiving Unstructured SS Request, application closes the MAPDialog

public abstract class SipSbb implements Sbb {

	private SbbContext sbbContext;


	private MAPContextInterfaceFactory mapAcif;
	private MAPProvider mapProvider;
	private MapServiceFactory mapServiceFactory;
	
	private static byte ussdDataCodingScheme = 0x0F;


	private Tracer logger;

	/** Creates a new instance of CallSbb */
	public SipSbb() {
	}

	/**
	 * MAP USSD Event Handlers
	 */

	public void onProcessUnstructuredSSRequest(
			ProcessUnstructuredSSIndication evt, ActivityContextInterface aci) {

		try {

			long invokeId = evt.getInvokeId();
			this.setInvokeId(invokeId);

			String ussdString = evt.getUSSDString().getString();
			this.setUssdString(ussdString);

			int codingScheme = evt.getUSSDDataCodingScheme() & 0xFF;
			String msisdn = evt.getMSISDNAddressString().getAddress();

			if (this.logger.isFineEnabled()) {
				this.logger
						.fine("Received PROCESS_UNSTRUCTURED_
						SS_REQUEST_INDICATION for MAP Dialog Id "
								+ evt.getMAPDialog().getDialogId()+ 
								" ussdString = "+ussdString);
			}
			
			USSDString ussdStringObj = this.mapServiceFactory
				.createUSSDString("1. Movies 2. Songs 3. End");
			
			evt.getMAPDialog().addUnstructuredSSResponse(invokeId, false,
					ussdDataCodingScheme, ussdStringObj);
			
			evt.getMAPDialog().send();


		} catch (Exception e) {
			logger.severe("Error while sending MAP USSD message", e);
		}

	}

	public void onUnstructuredSSRequest(UnstructuredSSIndication evt,
			ActivityContextInterface aci) {

		if (this.logger.isFineEnabled()) {
			this.logger
					.fine("Received UNSTRUCTURED_SS_REQUEST_INDICATION for MAP Dialog Id "
							+ evt.getMAPDialog().getDialogId());
		}
		
		try{

		MAPDialog mapDialog = evt.getMAPDialog();
		USSDString ussdStrObj = evt.getUSSDString();
		
		long invokeId = evt.getInvokeId();
		
		
		USSDString ussdStringObj = this.mapServiceFactory.createUSSDString("Thank you");
		
		evt.getMAPDialog().addUnstructuredSSResponse(invokeId, false,
				ussdDataCodingScheme, ussdStringObj);
		
		//End MAPDialog
		evt.getMAPDialog().close(false);
		
		}catch(Exception e){
			logger.severe("Error while sending MAP USSD ", e);
		}
	}

	/**
	 * MAP Dialog Event Handlers
	 */

	public void onCloseInfo(MAPCloseInfo evt, ActivityContextInterface aci) {
		if (this.logger.isFineEnabled()) {
			this.logger.fine("Received MAP CLOSE_INFO event for MAP Dialog Id "
					+ evt.getMAPDialog().getDialogId());
		}

	}

	public void onRefuseInfo(MAPRefuseInfo evt, ActivityContextInterface aci) {
		if (this.logger.isFineEnabled()) {
			this.logger
					.fine("Received MAP REFUSE_INFO event for MAP Dialog Id "
							+ evt.getMAPDialog().getDialogId());
		}
		
		
	}

	public void onUserAbortInfo(MAPUserAbortInfo evt,
			ActivityContextInterface aci) {
		if (this.logger.isFineEnabled()) {
			this.logger
					.fine("Received MAP USER_ABORT_INFO event for MAP Dialog Id "
							+ evt.getMAPDialog().getDialogId());
		}
		
		
	}

	public void onProviderAbortInfo(MAPProviderAbortInfo evt,
			ActivityContextInterface aci) {
		
		
	}



	public void setSbbContext(SbbContext sbbContext) {
		this.sbbContext = sbbContext;
		this.logger = sbbContext.getTracer("USSD-SIP");

		try {
			Context ctx = (Context) new InitialContext()
					.lookup("java:comp/env");

			

			mapAcif = (MAPContextInterfaceFactory) ctx
					.lookup("slee/resources/map/2.0/acifactory");

			mapProvider = (MAPProvider) ctx
					.lookup("slee/resources/map/2.0/provider");

			this.mapServiceFactory = this.mapProvider.getMapServiceFactory();

			
		} catch (Exception ne) {
			logger.severe("Could not set SBB context:", ne);
		}
	}

	public void unsetSbbContext() {
		this.sbbContext = null;
		this.logger = null;
	}

	public void sbbCreate() throws CreateException {
	}

	public void sbbPostCreate() throws CreateException {
	}

	public void sbbActivate() {
	}

	public void sbbPassivate() {
	}

	public void sbbLoad() {
	}

	public void sbbStore() {
	}

	public void sbbRemove() {
	}

	public void sbbExceptionThrown(Exception exception, Object object,
			ActivityContextInterface activityContextInterface) {
	}

	public void sbbRolledBack(RolledBackContext rolledBackContext) {
	}
}