Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package examples.publish;
  import javax.sip.*;
  import javax.sip.header.*;
  import java.util.*;
  
  //ifdef SIMULATION
  /*
 import sim.java.*;
 //endif
 */

This class is a UAC template. Shootist is the guy that shoots and shootme is the guy that gets shot.

Author(s):
M. Ranganathan
 
 
 public class Subscriber implements SipListener {
 
     private static SipProvider sipProvider;
     private static AddressFactory addressFactory;
     private static MessageFactory messageFactory;
     private static HeaderFactory headerFactory;
     private static SipStack sipStack;
     private ContactHeader contactHeader;
 
     protected ClientTransaction subscribeTid;
 
     protected static final String usageString =
         "java "
             + "examples.subsnotify.Subscriber \n"
             + ">>>> is your class path set to the root?";
 
     private static void usage() {
         ..println();
         System.exit(0);
 
     }
 
     public void processRequest(RequestEvent requestReceivedEvent) {
         Request request = requestReceivedEvent.getRequest();
         ServerTransaction serverTransactionId =
             requestReceivedEvent.getServerTransaction();
 
         ..println(
             "\n\nRequest "
                 + request.getMethod()
                 + " received at "
                 + .getStackName()
                 + " with server transaction id "
                 + serverTransactionId);
 
         if (request.getMethod().equals(.))
             processNotify(requestserverTransactionId);
 
     }
 
     public void processNotify(
         Request request,
         ServerTransaction serverTransactionId) {
         try {
             ..println("subscriber:  got a notify .");
             if (serverTransactionId == null) {
                 ..println("subscriber:  null TID.");
                 return;
             }
             Dialog dialog = serverTransactionId.getDialog();
             ..println("Dialog State = " + dialog.getState());
             Response response = .createResponse(200,request);
             serverTransactionId.sendResponse(response);
             SubscriptionStateHeader subscriptionState =  (SubscriptionStateHeader)
                         request.getHeader(.);
             // Subscription is terminated.
             if ( subscriptionState.getState().equals(.)) {
                 dialog.delete();
             }
 
 
         } catch (Exception ex) {
             ex.printStackTrace();
             System.exit(0);
 
         }
     }
 
     public void processResponse(ResponseEvent responseReceivedEvent) {
         ..println("Got a response");
         Response response = (ResponseresponseReceivedEvent.getResponse();
         Transaction tid = responseReceivedEvent.getClientTransaction();
 
         ..println(
             "Response received with client transaction id "
                 + tid
                 + ":\n"
                 + response);
         if (tid == null) {
            ..println("Stray response -- dropping ");
            return;
        }
        ..println("transaction state is " + tid.getState());
        ..println("Dialog = " + tid.getDialog());
        ..println("Dialog State is " + tid.getDialog().getState());
    }
    public void init() {
        SipFactory sipFactory = null;
         = null;
         = null;
        sipFactory = SipFactory.getInstance();
        sipFactory.setPathName("gov.nist");
        Properties properties = new Properties();
        String transport = "udp";
        properties.setProperty(
            "javax.sip.OUTBOUND_PROXY",
            "127.0.0.1:5070/" + transport);
        properties.setProperty("javax.sip.STACK_NAME""subscriber");
        properties.setProperty("javax.sip.MAX_MESSAGE_SIZE""1048576");
        properties.setProperty(
            "gov.nist.javax.sip.DEBUG_LOG",
            "subscriberdebug.txt");
        properties.setProperty(
            "gov.nist.javax.sip.SERVER_LOG",
            "subscriberlog.txt");
        // Drop the client connection after we are done with the transaction.
        properties.setProperty("gov.nist.javax.sip.CACHE_CLIENT_CONNECTIONS""false");
        // Set to 0 in your production code for max speed.
        // You need  16 for logging traces. 32 for debug + traces.
        // Your code will limp at 32 but it is best for debugging.
        properties.setProperty("gov.nist.javax.sip.TRACE_LEVEL""32");
        try {
            // Create SipStack object
             = sipFactory.createSipStack(properties);
            ..println("createSipStack " + );
        } catch (PeerUnavailableException e) {
            // could not find
            // gov.nist.jain.protocol.ip.sip.SipStackImpl
            // in the classpath
            e.printStackTrace();
            ..println(e.getMessage());
            System.exit(0);
        }
        try {
             = sipFactory.createHeaderFactory();
             = sipFactory.createAddressFactory();
             = sipFactory.createMessageFactory();
            ListeningPoint lp = .createListeningPoint("127.0.0.1",5060, "udp");
             = .createSipProvider(lp);
            Subscriber listener = this;
            .addSipListener(listener);
            lp = .createListeningPoint("127.0.0.1",5060, "tcp");
            SipProvider sipProvider1 = .createSipProvider(lp);
            sipProvider1.addSipListener(listener);
            String fromName = "BigGuy";
            String fromSipAddress = "here.com";
            String fromDisplayName = "The Master Blaster";
            String toSipAddress = "there.com";
            String toUser = "LittleGuy";
            String toDisplayName = "The Little Blister";
            // create >From Header
            SipURI fromAddress =
                .createSipURI(fromNamefromSipAddress);
            Address fromNameAddress = .createAddress(fromAddress);
            fromNameAddress.setDisplayName(fromDisplayName);
            FromHeader fromHeader =
                .createFromHeader(fromNameAddress"12345");
            // create To Header
            SipURI toAddress =
                .createSipURI(toUsertoSipAddress);
            Address toNameAddress = .createAddress(toAddress);
            toNameAddress.setDisplayName(toDisplayName);
            ToHeader toHeader =
                .createToHeader(toNameAddressnull);
            // create Request URI
            SipURI requestURI =
                .createSipURI(toUsertoSipAddress);
            // Create ViaHeaders
            ArrayList viaHeaders = new ArrayList();
            int port = .getListeningPoint("udp").getPort();
            ViaHeader viaHeader =
                .createViaHeader(
                    "127.0.0.1",
                    port,
                    transport,
                    null);
            // add via headers
            viaHeaders.add(viaHeader);
            // Create a new CallId header
            CallIdHeader callIdHeader = .getNewCallId();
            // Create a new Cseq header
            CSeqHeader cSeqHeader =
                .createCSeqHeader(1L, .);
            // Create a new MaxForwardsHeader
            MaxForwardsHeader maxForwards =
                .createMaxForwardsHeader(70);
            // Create the request.
            Request request =
                .createRequest(
                    requestURI,
                    .,
                    callIdHeader,
                    cSeqHeader,
                    fromHeader,
                    toHeader,
                    viaHeaders,
                    maxForwards);
            // Create contact headers
            String host = lp.getIPAddress();
            SipURI contactUrl = .createSipURI(fromNamehost);
            contactUrl.setPort(lp.getPort());
            // Create the contact name address.
            SipURI contactURI = .createSipURI(fromNamehost);
            contactURI.setPort(.getListeningPoint("udp").getPort());
            Address contactAddress = .createAddress(contactURI);
            // Add the contact address.
            contactAddress.setDisplayName(fromName);
             =
                .createContactHeader(contactAddress);
            request.addHeader();
            // Create the client transaction.
            listener.subscribeTid = .getNewClientTransaction(request);
            // send the request out.
            listener.subscribeTid.sendRequest();
        } catch (Exception ex) {
            ..println(ex.getMessage());
            ex.printStackTrace();
            usage();
        }
    }
    public static void main(String args[]) {
        new Subscriber().init();
    }
    public void processIOException(IOExceptionEvent exceptionEvent) {
        ..println("io exception event recieved");
    }
    public void processTransactionTerminated(TransactionTerminatedEvent transactionTerminatedEvent) {
        ..println("transaction terminated");
    }
    public void processDialogTerminated(DialogTerminatedEvent dialogTerminatedEvent) {
        ..println("dialog terminated event recieved");
    }
    public void processTimeout(javax.sip.TimeoutEvent timeoutEvent) {
        ..println("Transaction Time out");
    }
New to GrepCode? Check out our FAQ X