call.java

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

/*
 * Call.java
 *
 * Created on April 28, 2003, 5:22 PM
 */

package gov.nist.examples.pcc;
import java.util.*;
import javax.sip.*;
import javax.sip.message.*;
import javax.sip.header.*;
import javax.sip.address.*;
import gov.nist.examples.pcc.registrar.*;

/**
 *
 * @author  deruelle
 */
public class Call {
    
    public Dialog dialog;
    public String peerSDP;
    public boolean OK_RECEIVED;
    public CallListener callListener;
    public String callId;
    public Agent fromAgent;
    public Agent toAgent;
    
    /** Creates a new instance of Call */
    public Call(CallListener callListener,Agent fromAgent,Agent toAgent) {
        this.callListener=callListener;
        callId=null;
        this.fromAgent=fromAgent;
        this.toAgent=toAgent;
        OK_RECEIVED=false;
    }
    
    public boolean isOKReceived(){
       return OK_RECEIVED;
    }

    public void setDialog(Dialog dialog) {
       this.dialog=dialog;
    }
    
   
    public void setPeerSDP(String sdp) {
        if (sdp!=null){
            peerSDP=sdp;
        }
        OK_RECEIVED=true;
    }
   
     
    public void sendInvite(String callIdParameter,String sdp) {
        try { 
           
            Registrar registrar=callListener.callLauncher.registrar;
          
            // Request-URI:
            // this is the agent
            SipURI requestURI=callListener.addressFactory.createSipURI(toAgent.userName,
            toAgent.hostName);
            String key=requestURI.toString().toLowerCase();
            
            if ( !registrar.hasRegistration( key )  ) {
                CallLauncherDebug.println("Call, "+
                " INVITE not sent: no registrations recorded");
                return;
            }
                     
            Vector targetsURIList=registrar.getContactsURI(key);
            URI targetURI=(URI)targetsURIList.elementAt(0);
            SipURI targetSipURI=(SipURI)targetURI;
            
            SipStack sipStack=callListener.getSipStack(targetSipURI.getHost() );
            String stackIPAddress=sipStack.getIPAddress();
          
         
            // Call-ID:
            if ( callIdParameter==null) {
                callId=CallLauncherUtilities.generateCallIdentifier( stackIPAddress );
            }
            else callId=callIdParameter;
            CallIdHeader callIdHeader=callListener.headerFactory.createCallIdHeader(
                callId );
            
            // CSeq:
            CSeqHeader cseqHeader=callListener.headerFactory.createCSeqHeader(1,"INVITE");
      
            // From Header:
            SipURI fromSipURI=callListener.addressFactory.createSipURI(fromAgent.userName,fromAgent.hostName);
            Address fromAddress=callListener.addressFactory.createAddress(fromSipURI);
            String fromTag=CallLauncherUtilities.generateTag();
            FromHeader fromHeader=callListener.headerFactory.createFromHeader(fromAddress,fromTag);
            
            // To header:
            SipURI toSipURI=callListener.addressFactory.createSipURI(toAgent.userName,toAgent.hostName);
            Address toAddress=callListener.addressFactory.createAddress(toSipURI);
            ToHeader toHeader=callListener.headerFactory.createToHeader(toAddress,null);
            
            //  Via header
            ViaHeader viaHeader=callListener.getStackViaHeader(sipStack);
            Vector viaList=new Vector();
            viaList.addElement(viaHeader);
            
            // MaxForwards header:
            MaxForwardsHeader maxForwardsHeader=callListener.headerFactory.createMaxForwardsHeader(70);
            
            Request request=null;
            if (sdp==null) {
                request=callListener.messageFactory.createRequest(requestURI,"INVITE",
                callIdHeader,cseqHeader,fromHeader,toHeader,viaList,maxForwardsHeader);
            }
            else {
                // Content-Type:
                ContentTypeHeader contentTypeHeader=callListener.headerFactory.createContentTypeHeader(
                "application","sdp");
            
                request=callListener.messageFactory.createRequest(requestURI,"INVITE",
                callIdHeader,cseqHeader,fromHeader,toHeader,viaList,maxForwardsHeader,
                contentTypeHeader,sdp);
            }
          
            request.setRequestURI(targetURI);
            
            Iterator iter=sipStack.getSipProviders();
            ClientTransaction clientTransaction=((SipProvider)iter.next()).getNewClientTransaction(request);
            if (clientTransaction==null) {
                CallLauncherDebug.println("Call, unable to send INVITE: the"+
                " client transaction is null for the"+
                " request:\n"+request);
                return;
            }
            
            // Contact header:
            ContactHeader contactHeader=callListener.getStackContactHeader(sipStack);
            request.setHeader(contactHeader);
            
            clientTransaction.sendRequest();
            CallLauncherDebug.println("Call, "+
            " INVITE sent:\n"+request);
            CallLauncherDebug.println();
        }
        catch (Exception ex) {
           if (CallLauncherDebug.debug) {
                CallLauncherDebug.println("Call, sendInvite(), internal error, "+
                "exception raised:");
                CallLauncherDebug.logException(ex);
            }
        }
    }
    
    
    public void sendAck(String sdp,SipProvider sipProvider) {
        try{
            Request ackRequest=dialog.createRequest("ACK");
            
            if (sdp!=null) {
                // Content-Type:
                ContentTypeHeader contentTypeHeader=callListener.headerFactory.createContentTypeHeader(
                "application","sdp");
                
                ackRequest.setContent(sdp,contentTypeHeader);
            }
            
          //  dialog.sendAck(ackRequest);
            
            ClientTransaction clientTransaction=sipProvider.getNewClientTransaction(ackRequest);
            clientTransaction.sendRequest();
            
            CallLauncherDebug.println("ACK sent:\n"+ackRequest);
        }
        catch(Exception e) {
            if (CallLauncherDebug.debug) {
                CallLauncherDebug.println("Call, sendAck(), internal error, "+
                "exception raised:");
                CallLauncherDebug.logException(e);
            }
        }
    }
    
    public void sendBye() {
        try{
             Request byeRequest=dialog.createRequest("BYE");
             
             Registrar registrar=callListener.callLauncher.registrar;
             String key=toAgent.getSipURI();
             if ( !registrar.hasRegistration( key )  ) {
                CallLauncherDebug.println("Call, "+
                " sendBye(), no registrations recorded, the BYE is not sent.");
                return;
             }
                     
             Vector targetsURIList=registrar.getContactsURI(key);
             URI targetURI=(URI)targetsURIList.elementAt(0);
             SipURI targetSipURI=(SipURI)targetURI;
            
             SipStack sipStack=callListener.getSipStack(targetSipURI.getHost() );
             String stackIPAddress=sipStack.getIPAddress();
             Iterator iter=sipStack.getSipProviders();
             ClientTransaction clientTransaction=((SipProvider)iter.next()).getNewClientTransaction(byeRequest);
         
             // Cisco is not 3261 compliant...   
             // dialog.sendRequest(clientTransaction);
            // CallLauncherDebug.println("BYE almost sent:\n"+byeRequest);
             clientTransaction.sendRequest();
             CallLauncherDebug.println("BYE sent:\n"+byeRequest);
               
        }
        catch(Exception e) {
            if (CallLauncherDebug.debug) {
                CallLauncherDebug.println("Call, sendBye(), internal error, "+
                "exception raised:");
                CallLauncherDebug.logException(e);
            }
        }
    }
    
    public void sendCancel() {
        try{
       
        }
        catch(Exception e) {
           if (CallLauncherDebug.debug) {
                CallLauncherDebug.println("Call, sendCancel(), internal error, "+
                "exception raised:");
                CallLauncherDebug.logException(e);
            }
        }
    }
    
    public boolean isDialog(Dialog dia) {
        return dialog==dia;
    }

}