sipmanager.java

jtapi for telephone

    //---------------- received unknown message
    public void fireUnknownMessageReceived(Message message)
    {
        try
        {
            console.logEntry();
            if (console.isDebugEnabled())
            {
                console.debug("unknown message=" + message);
            }
            UnknownMessageEvent evt = new UnknownMessageEvent(message);
            for (int i = listeners.size() - 1; i >= 0; i--)
            {
                ( (CommunicationsListener) listeners.get(i)).
                receivedUnknownMessage(
                evt);
            }
        }
        finally
        {
            console.logExit();
        }
    } //unknown message
    
    //---------------- rejected a call
    public void fireCallRejectedLocally(String reason, Message invite)
    {
        try
        {
            console.logEntry();
            if (console.isDebugEnabled())
            {
                console.debug("locally rejected call. reason="
                + reason
                + "\ninvite message=" + invite);
            }
            CallRejectedEvent evt = new CallRejectedEvent(reason, invite);
            for (int i = listeners.size() - 1; i >= 0; i--)
            {
                ( (CommunicationsListener) listeners.get(i)).
                callRejectedLocally(
                evt);
            }
        }
        finally
        {
            console.logExit();
        }
    }
    
    public void fireCallRejectedRemotely(String reason, Message invite)
    {
        try
        {
            console.logEntry();
            if (console.isDebugEnabled())
            {
                console.debug("call rejected remotely. reason="
                + reason
                + "\ninvite message=" + invite);
            }
            CallRejectedEvent evt = new CallRejectedEvent(reason, invite);
            for (int i = listeners.size() - 1; i >= 0; i--)
            {
                ( (CommunicationsListener) listeners.get(i)).
                callRejectedRemotely(
                evt);
            }
        }
        finally
        {
            console.logExit();
        }
    }
    
    //call rejected
    //---------------- error occurred
    public void fireCommunicationsError(Throwable throwable)
    {
        try
        {
            console.logEntry();
            console.error(throwable);
            CommunicationsErrorEvent evt = new CommunicationsErrorEvent(
            throwable);
            for (int i = listeners.size() - 1; i >= 0; i--)
            {
                ( (CommunicationsListener) listeners.get(i)).
                communicationsErrorOccurred(evt);
            }
        }
        finally
        {
            console.logExit();
        }
    } //error occurred
    
    //============================= SIP LISTENER METHODS ==============================
    public void processRequest(RequestEvent requestReceivedEvent)
    {
        try
        {
            console.logEntry();
            if (console.isDebugEnabled())
            {
                console.debug("received request=" + requestReceivedEvent);
            }
            ServerTransaction serverTransaction = requestReceivedEvent.
            getServerTransaction();
            Request request = requestReceivedEvent.getRequest();
            String method = ( (CSeqHeader) request.getHeader(CSeqHeader.NAME)).getMethod();
            if (serverTransaction == null)
            {
                try
                {
                    serverTransaction = sipProvider.getNewServerTransaction(
                    request);
                }
                catch (TransactionAlreadyExistsException ex)
                {
                    /*fireCommunicationsError(
                        new CommunicationsException(
                        "Failed to create a new server"
                        + "transaction for an incoming request\n"
                        + "(Next message contains the request)",
                        ex));
                    fireUnknownMessageReceived(request);*/
                    //let's not scare the user
                    console.error("Failed to create a new server"
                    + "transaction for an incoming request\n"
                    + "(Next message contains the request)",
                    ex
                    );
                    
                    return;
                }
                catch (TransactionUnavailableException ex)
                {
                    /**
                     * fireCommunicationsError(
                     * new CommunicationsException(
                     * "Failed to create a new server"
                     * + "transaction for an incoming request\n"
                     * + "(Next message contains the request)",
                     * ex));
                     * fireUnknownMessageReceived(request);*/
                    //let's not scare the user
                    console.error("Failed to create a new server"
                    + "transaction for an incoming request\n"
                    + "(Next message contains the request)",
                    ex
                    );
                    return;
                }
            }
            Dialog dialog = serverTransaction.getDialog();
            Request requestClone = (Request) request.clone();
            //INVITE
            if (request.getMethod().equals(Request.INVITE))
            {
                console.debug("received INVITE");
                if(serverTransaction.getDialog().getState() == null)
                {
                    if(console.isDebugEnabled())
                        console.debug("request is an INVITE. Dialog state="
                        +serverTransaction.getDialog().getState());
                    callProcessing.processInvite(serverTransaction, request);
                }
                else
                {
                    console.debug("request is a reINVITE. Dialog state="
                    +serverTransaction.getDialog().getState());
                    callProcessing.processReInvite(serverTransaction, request);
                }
            }
            //ACK
            else if (request.getMethod().equals(Request.ACK))
            {
                if (serverTransaction != null
                && serverTransaction.getDialog().getFirstTransaction().
                getRequest().getMethod().equals(Request.INVITE))
                {
                    callProcessing.processAck(serverTransaction, request);
                }
                else
                {
                    // just ignore
                    console.debug("ignoring ack");
                }
            }
            //BYE
            else if (request.getMethod().equals(Request.BYE))
            {
                if (dialog.getFirstTransaction().getRequest().getMethod().
                equals(
                Request.INVITE))
                {
                    callProcessing.processBye(serverTransaction, request);
                }
            }
            //CANCEL
            else if (request.getMethod().equals(Request.CANCEL))
            {
                if (dialog.getFirstTransaction().getRequest().getMethod().
                equals(
                Request.INVITE))
                {
                    callProcessing.processCancel(serverTransaction, request);
                }
                else
                {
                    sendNotImplemented(serverTransaction, request);
                    fireUnknownMessageReceived(requestReceivedEvent.getRequest());
                }
            }
            //REFER
            else if (request.getMethod().equals(Request.REFER))
            {
                console.debug("Received REFER request");
                transferProcessing.processRefer(serverTransaction, request);
            }
            else if (request.getMethod().equals(Request.INFO))
            {
                /** @todo add proper request handling */
                sendNotImplemented(serverTransaction, request);
                fireUnknownMessageReceived(requestReceivedEvent.getRequest());
            }
            else if (request.getMethod().equals(Request.MESSAGE))
            {
                fireMessageReceived(request);
            }
            else if (request.getMethod().equals(Request.NOTIFY))
            {
                /** @todo add proper request handling */
                //                try {
                //                	watcher.processNotification(request, serverTransaction.getBranchId());
                //                }
                //                catch (CommunicationsException e) {
                //					// TODO: handle exception
                //				}
                sendNotImplemented(serverTransaction, request);
                fireUnknownMessageReceived(requestReceivedEvent.getRequest());
            }
            else if (request.getMethod().equals(Request.OPTIONS))
            {
                /** @todo add proper request handling */
                sendNotImplemented(serverTransaction, request);
                fireUnknownMessageReceived(requestReceivedEvent.getRequest());
            }
            else if (request.getMethod().equals(Request.PRACK))
            {
                /** @todo add proper request handling */
                sendNotImplemented(serverTransaction, request);
                fireUnknownMessageReceived(requestReceivedEvent.getRequest());
            }
            else if (request.getMethod().equals(Request.REGISTER))
            {
                /** @todo add proper request handling */
                sendNotImplemented(serverTransaction, request);
                fireUnknownMessageReceived(requestReceivedEvent.getRequest());
            }
            else if (request.getMethod().equals(Request.SUBSCRIBE))
            {
                /** @todo add proper request handling */
                
                //fireUnknownMessageReceived(requestReceivedEvent.getRequest());
            }
            else if (request.getMethod().equals(Request.UPDATE))
            {
                /** @todo add proper request handling */
                sendNotImplemented(serverTransaction, request);
                fireUnknownMessageReceived(requestReceivedEvent.getRequest());
            }
            else
            {
                //We couldn't recognise the message
                sendNotImplemented(serverTransaction, request);
                fireUnknownMessageReceived(requestReceivedEvent.getRequest());
            }
        }
        finally
        {
            console.logExit();
        }
    }
    
    public void processTimeout(TimeoutEvent transactionTimeOutEvent)
    {
        try
        {
            console.logEntry();
            if (console.isDebugEnabled())
            {
                console.debug("received time out event: "
                + transactionTimeOutEvent);
            }
            Transaction transaction;
            if (transactionTimeOutEvent.isServerTransaction())
            {
                transaction = transactionTimeOutEvent.getServerTransaction();
            }
            else
            {
                transaction = transactionTimeOutEvent.getClientTransaction();
            }
            Request request =
            transaction.getRequest();
            if (request.getMethod().equals(Request.REGISTER))
            {
                registerProcessing.processTimeout(transaction, request);
            }
            else if (request.getMethod().equals(Request.INVITE))
            {
                callProcessing.processTimeout(transaction, request);
            }
            else
            {
                //Just show an error for now
                Console.showError("TimeOut Error!",
                "Received a TimeoutEvent while waiting on a message"
                + "\n(Check Details to see the message that caused it)",
                request.toString()
                );
            }
        }
        finally
        {
            console.logExit();
        }
    }
    
    //-------------------- PROCESS RESPONSE
    public void processResponse(ResponseEvent responseReceivedEvent)
    {
        try
        {
            console.logEntry();
            if (console.isDebugEnabled())
            {
                console.debug("received response=" + responseReceivedEvent);
            }
            ClientTransaction clientTransaction = responseReceivedEvent.
            getClientTransaction();
            if (clientTransaction == null)
            {
                console.debug("ignoring a transactionless response");
                return;
            }
            Response response = responseReceivedEvent.getResponse();
            Dialog dialog = clientTransaction.getDialog();
            String method = ( (CSeqHeader) response.getHeader(CSeqHeader.NAME)).
            getMethod();
            Response responseClone = (Response) response.clone();
            //OK
            if (response.getStatusCode() == Response.OK)
            {
                //REGISTER
                if (method.equals(Request.REGISTER))
                {
                    registerProcessing.processOK(clientTransaction, response);
                }//INVITE
                else if (method.equals(Request.INVITE))
                {
                    callProcessing.processInviteOK(clientTransaction, response);
                }//BYE
                else if (me