JAIN-SIP注册

import gov.nist.javax.sip.SipStackExt;
import gov.nist.javax.sip.clientauthutils.AuthenticationHelper;
import gov.nist.javax.sip.clientauthutils.UserCredentials;
import gov.nist.javax.sip.stack.NioMessageProcessorFactory;

import javax.sip.*;
import javax.sip.address.Address;
import javax.sip.address.AddressFactory;
import javax.sip.address.SipURI;
import javax.sip.header.*;
import javax.sip.message.MessageFactory;
import javax.sip.message.Request;
import javax.sip.message.Response;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;


public class RegisterTest implements SipListener {

    private  SipFactory sipFactory=null;
    private  SipStack sipStack=null;
    private HeaderFactory headerFactory=null;
    private  SipProvider sipProvider=null;
    private AddressFactory addressFactory=null;
    private MessageFactory messageFactory=null;
    private  ClientTransaction clientTransaction=null;

    private  String username=null;
    private  String localIP;
    private  int localPort;
    private  Long cesq=1L;
    public static void main(String[] args) throws Exception {
        RegisterTest registerTest=new RegisterTest("10.74.152.214",8090);
        registerTest.sendRegister();
    }
    public  RegisterTest(String localIP,int localPort )throws  Exception{
        //setUsername(username);
        sipFactory = SipFactory.getInstance();
        sipFactory.setPathName("gov.nist");
        Properties properties = new Properties();
        properties.setProperty("javax.sip.STACK_NAME", "RegisterTest");
        properties.setProperty("javax.sip.IP_ADDRESS", localIP);

        // DEBUGGING: Information will go to files
        // textclient.log and textclientdebug.log
        properties.setProperty("gov.nist.javax.sip.TRACE_LEVEL", "32");
        properties.setProperty("gov.nist.javax.sip.SERVER_LOG", "textclient.txt");
        properties.setProperty("gov.nist.javax.sip.DEBUG_LOG", "textclientdebug.log");

        sipStack = sipFactory.createSipStack(properties);
        headerFactory = sipFactory.createHeaderFactory();
        addressFactory = sipFactory.createAddressFactory();
        messageFactory = sipFactory.createMessageFactory();

        ListeningPoint udp = sipStack.createListeningPoint(localIP,localPort, "udp");

        sipProvider = sipStack.createSipProvider(udp);
        sipProvider.addSipListener(this);
    }


    public void sendRegister() throws SipException, ParseException, InvalidArgumentException {
        String username="111";
        String serverIP="100.100.121.245";

        SipURI fromAddress = addressFactory.createSipURI(username,serverIP);
        Address fromNameAddress = addressFactory.createAddress(fromAddress);
        fromNameAddress.setDisplayName("111");
        FromHeader fromHeader = headerFactory.createFromHeader(fromNameAddress,"8u5pX9jr9fZkN-2fGCe1gJsIXQw6lyEI");

        SipURI toSip=addressFactory.createSipURI(username,serverIP);
        Address toAddress=addressFactory.createAddress(toSip);
        ToHeader toHeader=headerFactory.createToHeader(toAddress,null);

        // create Request URI
        SipURI requestURI = addressFactory.createSipURI(username, serverIP);


        // Create ViaHeaders
        List<ViaHeader> viaHeaders = new ArrayList<>();
        ViaHeader viaHeader = headerFactory.createViaHeader("10.74.152.214",
                8090, "udp",
                "z9hG4bKPjpugnxlzkPZvDW2MFDvLBVCDe2JtXD1sa");
        // add via headers
        viaHeaders.add(viaHeader);

        // Create ContentTypeHeader
        ContentTypeHeader contentTypeHeader = headerFactory
                .createContentTypeHeader("application", "sdp");

        // Create a new CallId header
        CallIdHeader callIdHeader = sipProvider.getNewCallId();
        callIdHeader.setCallId("vVMzatGWEahXAaEpi4ZH-KEy7bx7JNBy");

        // Create a new Cseq header
        CSeqHeader cSeqHeader = headerFactory.createCSeqHeader(cesq,Request.REGISTER);

        // Create a new MaxForwardsHeader
        MaxForwardsHeader maxForwards = headerFactory.createMaxForwardsHeader(70);

        // Create the request.
        Request request = messageFactory.createRequest(requestURI,
                Request.REGISTER, callIdHeader, cSeqHeader, fromHeader, toHeader,
                viaHeaders, maxForwards);

        ExpiresHeader expiresHeader=headerFactory.createExpiresHeader(300);
        request.addHeader(expiresHeader);

        AllowHeader allowHeader=headerFactory.createAllowHeader("PRACK, INVITE, ACK, BYE, CANCEL, UPDATE, INFO, SUBSCRIBE, NOTIFY, REFER, MESSAGE, OPTIONS");
        request.addHeader(allowHeader);

        // Create the contact name address.
        SipURI contactURI = addressFactory.createSipURI("111", "10.74.152.214");
        contactURI.setPort(8090);
        Address contactAddress = addressFactory.createAddress(contactURI);
        ContactHeader contactHeader = headerFactory.createContactHeader(contactAddress);
        request.addHeader(contactHeader);


        clientTransaction=sipProvider.getNewClientTransaction(request);
        clientTransaction.sendRequest();
        cesq++;
    }

    @Override
    public void processRequest(RequestEvent requestEvent) {
        System.out.println("RequestEvent "+requestEvent.getServerTransaction().getDialog());
    }

    @Override
    public void processResponse(ResponseEvent responseEvent) {
        ClientTransaction clientTransactionTmp = responseEvent.getClientTransaction();
        System.out.println("responseEvent.getResponse()" + responseEvent.getResponse()+"\n\n");
        Response response=responseEvent.getResponse();

        int  statusCode=response.getStatusCode();
        if (clientTransaction==null){
            System.out.println("clientTransaction is null");
            return;
        }
        if(statusCode == Response.UNAUTHORIZED || statusCode==Response.PROXY_AUTHENTICATION_REQUIRED){
            System.out.println(statusCode);
            AuthenticationHelper authenticationHelper =
                    ((SipStackExt) sipStack).getAuthenticationHelper(new AccountManagerImpl(), headerFactory);

            try {
                clientTransaction = authenticationHelper.handleChallenge(response, clientTransactionTmp, sipProvider, 5);
                clientTransaction.sendRequest();
            } catch (SipException e) {
                e.printStackTrace();
            }

        }
    }

    @Override
    public void processTimeout(TimeoutEvent timeoutEvent) {
        Transaction transaction;
        if (timeoutEvent.isServerTransaction()) {
            transaction = timeoutEvent.getServerTransaction();
        } else {
            transaction = timeoutEvent.getClientTransaction();
            System.out.println(timeoutEvent.getTimeout().getValue());


        }
        System.out.println("state = " + transaction.getState());
        System.out.println("dialog = " + transaction.getDialog());
        System.out.println("Transaction Time out");
    }

    @Override
    public void processIOException(IOExceptionEvent exceptionEvent) {
        System.out.println("Expcetion occured "+exceptionEvent.getPort());
    }

    @Override
    public void processTransactionTerminated(TransactionTerminatedEvent transactionTerminatedEvent) {
        if (transactionTerminatedEvent.isServerTransaction())
            System.out.println("Transaction terminated event recieved"
                    + transactionTerminatedEvent.getServerTransaction());
        else {
            System.out.println("Transaction terminated "
                    + transactionTerminatedEvent.getClientTransaction());
        }
    }

    @Override
    public void processDialogTerminated(DialogTerminatedEvent dialogTerminatedEvent) {
        System.out.println("processDialogTerminated" +dialogTerminatedEvent);
    }




}