presenceserver.java

First of all, the Applet-phone is a SIP User-Agent with audio and text messaging capabilities. But

/*
 * PresenceServer.java
 *
 * Created on September 20, 2002, 3:46 PM
 */

package gov.nist.examples.bps.presenceserver;

import java.util.*;
import javax.sip.*;
import javax.sip.message.*;
import javax.sip.header.*;
import javax.sip.address.*;
import gov.nist.examples.bps.gateway.*;

/**
 *
 * @author  deruelle
 * @version 1.0
 */
public class PresenceServer {

    protected Gateway gateway;
    private int callIdCounter;        
    protected BaseXMLParser baseParser;
    protected BadgesXMLParser badgesParser;
    protected BadgesXMLParser badgesFileParser;
    protected String badgesFile;    
    protected Map basesList;
    protected Vector badgesList;
    
    /** Creates new PresenceServer */
    public PresenceServer(Gateway gateway) {
        this.gateway=gateway;
        badgesFile=gateway.getConfiguration().badgesConfigurationFile;
        callIdCounter=0;        
        basesList=new Hashtable();
        baseParser=new BaseXMLParser();
        badgesParser=new BadgesXMLParser();
        badgesFileParser=new BadgesXMLParser();
        badgesList=badgesFileParser.parseFile(badgesFile);
        if (badgesList==null) badgesList=new Vector();
    }
 
    public Vector getBadgesList(){
        return badgesList;
    }
    
    public Map getBasesList(){
        return basesList;
    }
    
    public void processNotify(Request request,SipProvider sipProvider,ServerTransaction 
    serverTransaction,String baseReaderIdentifier) {
        try {
            GatewayDebug.println("PresenceServer, processNotify(), processing NOTIFY in progress");
            
            MessageFactory messageFactory=gateway.getMessageFactory();
            Response response=messageFactory.createResponse
            (Response.OK,request);
            if (serverTransaction!=null)
                serverTransaction.sendResponse(response);
            else sipProvider.sendResponse(response);
            
            GatewayDebug.println("PresenceServer, processNotify(), "+
            " Response 200 OK replied for the NOTIFY.");
            
            try{
                Object content=request.getContent();
                String text=null;
                if (content instanceof String)
                    text=(String)content;
                else
                    if (content instanceof byte[] ) {
                        text=new String(  (byte[])content  );
                    }
                    
                //GatewayGUI gatewayGUI=gateway.getGatewayGUI();
              
                if (text==null) {
                    gateway.getSyncManager().removeBadgesFromBadgesTable(baseReaderIdentifier);
                }
                else {
                    Vector badgesTempList=badgesParser.parseString(text);
                    if (badgesTempList!=null) {
                        gateway.getSyncManager().updateBadgesFromBadgesTable(badgesTempList,baseReaderIdentifier);
                    }
                    else {
                        GatewayDebug.println("PresenceServer, processNotify(), "+
                        " ERROR, the body of the request is not well-formatted!!");
                    }
                }
            }
            catch (Exception ex) {
                GatewayDebug.println("PresenceServer, processNotify(), badges not updated"+
                ", exception raised: ");
                ex.printStackTrace();
            }
            printBases();
        }
        catch (Exception ex) {
            GatewayDebug.println("PresenceServer, processNotify(), NOTIFY not processed"+
            ", exception raised: ");
            ex.printStackTrace();
        }
    }
    
   
   
    public void sendSubscribe(Request register,SipProvider sipProvider) {
         try {
            GatewayDebug.println("PresenceServer, sendSubscribe(), sending SUBSCRIBE in progress to "+
            "a base reader");
    
            SipStack sipStack=sipProvider.getSipStack();
        
            MessageFactory messageFactory=gateway.getMessageFactory();
            HeaderFactory headerFactory=gateway.getHeaderFactory();
            AddressFactory addressFactory=gateway.getAddressFactory();
           
            // Request-URI is the contact sip URI of the REGISTER.
            ContactHeader contactRegisterHeader=(ContactHeader)register.getHeader(ContactHeader.NAME);
            if (contactRegisterHeader==null) {
                 GatewayDebug.println("PresenceServer, sendSubscribe(), unable to SUBSCRIBE"+
                 ", the REGISTER does not have a contact header.");
                return;
            }
            Address contactRegisterAddress=contactRegisterHeader.getAddress();
            URI contactRegisterURI=contactRegisterAddress.getURI();
            
            // Call-Id:
            callIdCounter++;
            CallIdHeader callIdHeader=(CallIdHeader)
            headerFactory.createCallIdHeader("nist-sip-presence-server-callId"+callIdCounter);
                        
            // CSeq:
            CSeqHeader cseqHeader=headerFactory.createCSeqHeader(1,"SUBSCRIBE");
                
            // To header:
            FromHeader fromRegisterHeader=(FromHeader) register.getHeader(FromHeader.NAME);
            Address fromRegisterAddress=fromRegisterHeader.getAddress();
            URI fromRegisterURI=fromRegisterAddress.getURI();
            Address toAddress=addressFactory.createAddress(fromRegisterURI);
            ToHeader toHeader=headerFactory.createToHeader(toAddress,null);
            
            // From Header:
            String localTag=GatewayUtilities.generateTag();
            Address fromAddress=addressFactory.createAddress("sip:presence-server@"+sipStack.getIPAddress()+
            ":"+sipProvider.getListeningPoint().getPort());
            FromHeader fromHeader=headerFactory.createFromHeader(fromAddress,localTag);
            
            //  Via header
            String branchId=GatewayUtilities.generateBranchId();
            ViaHeader viaHeader=gateway.getStackViaHeader(sipStack);
            Vector viaList=new Vector();
            viaList.addElement(viaHeader);

            // MaxForwards header:
            MaxForwardsHeader maxForwardsHeader=headerFactory.createMaxForwardsHeader(70);
            
            Request request=messageFactory.createRequest(contactRegisterURI,"SUBSCRIBE",
            callIdHeader,cseqHeader,fromHeader,toHeader,viaList,maxForwardsHeader);
           
            // Contact header:
            String host = sipStack.getIPAddress();
            int port = sipProvider.getListeningPoint().getPort();
            SipURI sipURI=addressFactory.createSipURI("presence-server",host);
            sipURI.setPort(port);
            Address address=addressFactory.createAddress(null,sipURI);
            ContactHeader contactHeader=headerFactory.createContactHeader(address);
            request.setHeader(contactHeader);
      
            // WE have to add a new Header: "Event"
            Header header=headerFactory.createHeader("Event","presence");
            request.setHeader(header);
            
            ClientTransaction clientTransaction=sipProvider.getNewClientTransaction(request);
            clientTransaction.sendRequest();            
            
            GatewayDebug.println("PresenceServer, sendSubscribe(), SUBSCRIBE sent:\n"+
            request);
        }
        catch (Exception ex) {
            GatewayDebug.println("PresenceServer, sendSubscribe(), SUBSCRIBE not sent"+
            ", exception raised: ");
            ex.printStackTrace();
        }
    }
    
    public void processRegister(Request request) {
        try{
             //GatewayGUI gatewayGUI=gateway.getGatewayGUI();
          
             Object content=request.getContent();
             String text=null;
             if (content instanceof String)
                 text=(String)content;
             else 
                 if (content instanceof byte[] ) {
                    text=new String(  (byte[])content  );
                 }
                 else {
                    GatewayDebug.println("PresenceServer, processRegister(), "+
                    " ERROR, the body of the request is not well-formatted!!");
                    return;
                 }
        
             if (text!=null && !text.trim().equals("") ) {
                // we parse the XML body!!!!
                
                 Base base=baseParser.parseString(text);
                 if (base!=null) {
                     gateway.getSyncManager().updateBases(base);
                 }
                 else {
                    GatewayDebug.println("PresenceServer, processRegister(), "+
                    " ERROR, the body of the request is not well-formatted!!");
                    return;
                 }
             }
        }
        catch (Exception ex) {
            GatewayDebug.println("PresenceServer, processRegister(), base not added"+
            ", exception raised: ");
            ex.printStackTrace();
        }
    }
   
    public void printBases(){
        System.out.println("/*******************************************/");
        System.out.println("/*******Bases List with their registered badges ************/");        
        Collection bases=basesList.values();
        Iterator it=bases.iterator();
        while(it.hasNext()){
            Base base=(Base)it.next();
            System.out.println(base.toXMLTag());            
        }
        System.out.println("/*******************************************/");
    }
    
}