invitehandler.java

Peers is a very minimalistic SIP User-Agent. It s a softphone, written in java, and it has been test

        //8.1.2
        SipURI requestUri = sipRequest.getRequestUri();

        //TODO if header route is present, addrspec = toproute.nameaddress.addrspec
        String transport = RFC3261.TRANSPORT_UDP;
        Hashtable<String, String> params = requestUri.getUriParameters();
        if (params != null) {
            String reqUriTransport = params.get(RFC3261.PARAM_TRANSPORT);
            if (reqUriTransport != null) {
                transport = reqUriTransport; 
            }
        }
        int port = requestUri.getPort();
        if (port == SipURI.DEFAULT_PORT) {
            port = RFC3261.TRANSPORT_DEFAULT_PORT;
        }
        ClientTransaction clientTransaction = TransactionManager.getInstance()
            .createClientTransaction(sipRequest, requestUri.getHost(),
                    port, transport, null, this);
        sipRequest.setBody(sdpManager.generateOffer().getBytes());
        SipHeaders respHeaders = sipRequest.getSipHeaders();
        respHeaders.add(new SipHeaderFieldName(RFC3261.HDR_CONTENT_TYPE),
                new SipHeaderFieldValue(RFC3261.CONTENT_TYPE_SDP));
        return clientTransaction;
    }
    
    public void preProcessReInvite(SipRequest sipRequest) {
        //TODO
    }

    //////////////////////////////////////////////////////////
    // ClientTransactionUser methods
    //////////////////////////////////////////////////////////

    public void errResponseReceived(SipResponse sipResponse) {
        Dialog dialog = DialogManager.getInstance().getDialog(sipResponse);
        dialog.receivedOrSent300To699();
        setChanged();
        notifyObservers(new SipEvent(EventType.ERROR, sipResponse));
    }

    public void provResponseReceived(SipResponse sipResponse, Transaction transaction) {
        // dialog may have already been created if a previous 1xx has
        // already been received
        Dialog dialog = DialogManager.getInstance().getDialog(sipResponse);
        boolean isFirstProvResp = false;
        if (dialog == null) {
            Logger.getInstance().debug("dialog not found for prov response");
            isFirstProvResp = true;
            dialog = buildDialogForUac(sipResponse, transaction);
        }
        //TODO this notification is probably useless because dialog state modification
        //     thereafter always notify dialog observers
        if (isFirstProvResp) {
            setChanged();
            notifyObservers(new SipEvent(EventType.RINGING, sipResponse));
            dialog.receivedOrSent1xx();
        }
    }

    public void successResponseReceived(SipResponse sipResponse, Transaction transaction) {
        SipHeaders responseHeaders = sipResponse.getSipHeaders();
        String cseq = responseHeaders.get(
                new SipHeaderFieldName(RFC3261.HDR_CSEQ)).getValue();
        String method = cseq.substring(cseq.trim().lastIndexOf(' ') + 1);
        if (!RFC3261.METHOD_INVITE.equals(method)) {
            return;
        }
        
        
        
        
        
        
        
        
        //13.2.2.4

        List<String> peers = UserAgent.getInstance().getPeers();
        String responseTo = responseHeaders.get(
                new SipHeaderFieldName(RFC3261.HDR_TO)).getValue();
        if (!peers.contains(responseTo)) {
            peers.add(responseTo);
            //timer used to purge dialogs which are not confirmed
            //after a given time
            ackTimer.schedule(new AckTimerTask(responseTo),
                    64 * RFC3261.TIMER_T1);
        }
        
        Dialog dialog = DialogManager.getInstance().getDialog(sipResponse);
        
        if (dialog != null) {
            //dialog already created with a 180 for example
            dialog.setRouteSet(computeRouteSet(sipResponse.getSipHeaders()));
        } else {
            //new dialog
            dialog = buildDialogForUac(sipResponse, transaction);
        }
        
        setChanged();
        notifyObservers(new SipEvent(EventType.CALLEE_PICKUP, sipResponse));
        
        //added for media
        SessionDescription sessionDescription =
            sdpManager.handleAnswer(sipResponse.getBody());
        String remoteAddress = sessionDescription.getIpAddress().getHostAddress();
        int remotePort = sessionDescription.getMedias().get(0).getPort();
        String localAddress = Utils.getInstance().getMyAddress().getHostAddress();
        CaptureRtpSender captureRtpSender;
        //TODO this could be optimized, create captureRtpSender at stack init
        //     and just retrieve it here
        try {
            captureRtpSender = new CaptureRtpSender(localAddress,
                    Utils.getInstance().getRtpPort(),
                    remoteAddress, remotePort);
        } catch (IOException e) {
            e.printStackTrace();
            return;
        }
        UserAgent.getInstance().setCaptureRtpSender(captureRtpSender);

        try {
            captureRtpSender.start();
        } catch (IOException e1) {
            e1.printStackTrace();
        }
        
        IncomingRtpReader incomingRtpReader;
        try {
            //TODO retrieve port from SDP offer
//                incomingRtpReader = new IncomingRtpReader(localAddress,
//                        Utils.getInstance().getRtpPort(),
//                        remoteAddress, remotePort);
            incomingRtpReader = new IncomingRtpReader(captureRtpSender.getRtpSession());
        } catch (IOException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
            return;
        }
        UserAgent.getInstance().setIncomingRtpReader(incomingRtpReader);

        try {
            incomingRtpReader.start();
        } catch (IOException e1) {
            e1.printStackTrace();
        } catch (RtpException e1) {
            e1.printStackTrace();
        }
        
        /////////////////
        
        //switch to confirmed state
        dialog.receivedOrSent2xx();
        
        //generate ack
        //p. 82 §3
        SipRequest ack = dialog.buildSubsequentRequest(RFC3261.METHOD_ACK);
        
        
        //update CSeq
        
        SipHeaders ackHeaders = ack.getSipHeaders();
        SipHeaderFieldName cseqName = new SipHeaderFieldName(RFC3261.HDR_CSEQ);
        SipHeaderFieldValue ackCseq = ackHeaders.get(cseqName);
        
        SipRequest request = transaction.getRequest();
        SipHeaders requestHeaders = request.getSipHeaders();
        SipHeaderFieldValue requestCseq = requestHeaders.get(cseqName);
        
        ackCseq.setValue(requestCseq.toString().replace(RFC3261.METHOD_INVITE, RFC3261.METHOD_ACK));
        
        //add Via with only the branchid parameter
        
        SipHeaderFieldValue via = new SipHeaderFieldValue("");
        SipHeaderFieldValue respTopVia =Utils.getInstance().getTopVia(sipResponse);
        SipHeaderParamName branchIdName = new SipHeaderParamName(RFC3261.PARAM_BRANCH);
        via.addParam(branchIdName, respTopVia.getParam(branchIdName));
        
        ackHeaders.add(new SipHeaderFieldName(RFC3261.HDR_VIA), via, 0);
        
        //TODO authentication headers
        
        if (request.getBody() == null && sipResponse.getBody() != null) {
            //TODO add a real SDP answer
            ack.setBody(sipResponse.getBody());
        }

        //TODO check if sdp is acceptable

        SipURI requestUri = ack.getRequestUri();

        //TODO if header route is present, addrspec = toproute.nameaddress.addrspec
        
        String transport = RFC3261.TRANSPORT_UDP;
        Hashtable<String, String> params = requestUri.getUriParameters();
        if (params != null) {
            String reqUriTransport = params.get(RFC3261.PARAM_TRANSPORT);
            if (reqUriTransport != null) {
                transport = reqUriTransport; 
            }
        }
        int port = requestUri.getPort();
        if (port == SipURI.DEFAULT_PORT) {
            port = RFC3261.TRANSPORT_DEFAULT_PORT;
        }

        try {
            MessageSender sender = TransportManager.getInstance().createClientTransport(
                    ack, requestUri.getHost(), port, transport);
            sender.sendMessage(ack);
        } catch (IOException e) {
            e.printStackTrace();
        }
        
        
        
        
        
        
    }

    public void transactionTimeout() {
        // TODO Auto-generated method stub
        
    }

    public void transactionTransportError() {
        // TODO Auto-generated method stub
        
    }
    
    //////////////////////////////////////////////////////////
    // ServerTransactionUser methods
    //////////////////////////////////////////////////////////
    
    public void transactionFailure() {
        // TODO manage transaction failure (ACK was not received)
        
    }
    

}