registerprocessing.java

jtapi for telephone

            }
            //To Header
            ToHeader toHeader = null;
            try {
                toHeader = sipManCallback.headerFactory.createToHeader(fromAddress, null);
            }
            catch (ParseException ex) {
                console.error("Could not create a To header for address:"
                              + fromHeader.getAddress(),
                              ex);
                //throw was missing - reported by Eero Vaarnas
                throw new CommunicationsException("Could not create a To header "
                                            + "for address:"
                                            + fromHeader.getAddress(),
                                            ex);
            }
            //Via Headers
            ArrayList viaHeaders = sipManCallback.getLocalViaHeaders();
            //MaxForwardsHeader
            MaxForwardsHeader maxForwardsHeader = sipManCallback.
                getMaxForwardsHeader();
            //Request
            Request request = null;
            try {
                request = sipManCallback.messageFactory.createRequest(requestURI,
                    Request.REGISTER,
                    callIdHeader,
                    cSeqHeader, fromHeader, toHeader,
                    viaHeaders,
                    maxForwardsHeader);
            }
            catch (ParseException ex) {
                console.error("Could not create the register request!", ex);
                //throw was missing - reported by Eero Vaarnas
                throw new CommunicationsException(
                    "Could not create the register request!",
                    ex);
            }
            //Expires Header
            ExpiresHeader expHeader = null;
            for (int retry = 0; retry < 2; retry++) {
                try {
                    expHeader = sipManCallback.headerFactory.createExpiresHeader(
                        expires);
                }
                catch (InvalidArgumentException ex) {
                    if (retry == 0) {
                        expires = 3600;
                        continue;
                    }
                    console.error(
                        "Invalid registrations expiration parameter - "
                        + expires,
                        ex);
                    throw new CommunicationsException(
                        "Invalid registrations expiration parameter - "
                        + expires,
                        ex);
                }
            }
            request.addHeader(expHeader);
            //Contact Header should contain IP - bug report - Eero Vaarnas
            ContactHeader contactHeader = sipManCallback.
                getRegistrationContactHeader();
            request.addHeader(contactHeader);
            //Transaction
            ClientTransaction regTrans = null;
            try {
                regTrans = sipManCallback.sipProvider.getNewClientTransaction(
                    request);
            }
            catch (TransactionUnavailableException ex) {
                console.error("Could not create a register transaction!\n"
                              + "Check that the Registrar address is correct!",
                              ex);
                //throw was missing - reported by Eero Vaarnas
                throw new CommunicationsException(
                    "Could not create a register transaction!\n"
                    + "Check that the Registrar address is correct!");
            }
            try {
                regTrans.sendRequest();
                if( console.isDebugEnabled() )
                    console.debug("sent request= " + request);
                //[issue 2] Schedule re registrations
                //bug reported by [e-mail]
                scheduleReRegistration( registrarAddress, registrarPort,
                            registrarTransport, expires);

            }
            //we sometimes get a null pointer exception here so catch them all
            catch (Exception ex) {
                console.error("Could not send out the register request!", ex);
                //throw was missing - reported by Eero Vaarnas
                throw new CommunicationsException(
                    "Could not send out the register request!", ex);
            }
            this.registerRequest = request;
        }
        finally
        {
            console.logExit();
        }

    }

    /**
     * Synchronize because of timer tasks
     * @throws CommunicationsException
     */
    public synchronized void unregister() throws CommunicationsException
    {
        try
        {
            console.logEntry();

            if (!isRegistered) {
                return;
            }

            cancelPendingRegistrations();
            isRegistered = false;

            Request registerRequest = getRegisterRequest();
            if (this.registerRequest == null) {
                console.error("Couldn't find the initial register request");
                throw new CommunicationsException(
                    "Couldn't find the initial register request");
            }
            Request unregisterRequest = (Request) registerRequest.clone();
            try {
                unregisterRequest.getExpires().setExpires(0);
                CSeqHeader cSeqHeader =
                    (CSeqHeader)unregisterRequest.getHeader(CSeqHeader.NAME);
                //[issue 1] - increment registration cseq number
                //reported by - Roberto Tealdi <[e-mail]>
                cSeqHeader.setSequenceNumber(cSeqHeader.getSequenceNumber()+1);

            }
            catch (InvalidArgumentException ex) {
                console.error("Unable to set Expires Header", ex);
                //Shouldn't happen
                throw new CommunicationsException("Unable to set Expires Header",
                                                  ex);
            }
            ClientTransaction unregisterTransaction = null;
            try {
                unregisterTransaction =
                    sipManCallback.sipProvider.getNewClientTransaction(
                    unregisterRequest);
            }
            catch (TransactionUnavailableException ex) {
                console.error("Unable to create a unregister transaction", ex);
                throw new CommunicationsException(
                    "Unable to create a unregister transaction", ex);
            }
            try {
                unregisterTransaction.sendRequest();
                if( console.isDebugEnabled() )
                    console.debug("sent request: " + unregisterRequest);
                sipManCallback.fireUnregistering(sipManCallback.currentlyUsedURI);
            }
            catch (SipException ex) {
                console.error("Failed to send unregister request", ex);
                throw new CommunicationsException(
                    "Failed to send unregister request", ex);
            }
        }
        finally
        {
            console.logExit();
        }

    }

    public boolean isRegistered()
    {
        return isRegistered;
    }

    private Request getRegisterRequest()
    {
        return registerRequest;
    }

    private class ReRegisterTask
        extends TimerTask
    {
        String registrarAddress = null;
        int registrarPort = -1;
        String transport = null;
        int expires = 0;
        public ReRegisterTask(String registrarAddress, int registrarPort,
                              String registrarTransport, int expires)
        {
            this.registrarAddress = registrarAddress;
            this.registrarPort = registrarPort;

            //don't do this.transport = transport  ;)
            //bug report and fix by Willem Romijn (romijn at lucent.com)
            this.transport = registrarTransport;
            this.expires = expires;
        }

        public void run()
        {
            try {
                console.logEntry();

                try {
                    if(isRegistered())
                    register(registrarAddress, registrarPort, transport,
                             expires);
                }
                catch (CommunicationsException ex) {
                    console.error("Failed to reRegister", ex);
                    sipManCallback.fireCommunicationsError(
                        new CommunicationsException("Failed to reRegister", ex)
                        );
                }
            }
            finally {
                console.logExit();
            }

        }
    }

    private void cancelPendingRegistrations()
    {
        try {
            console.logEntry();

            reRegisterTimer.cancel();
            reRegisterTimer = null;

            reRegisterTimer = new Timer();
        }
        finally {
            console.logExit();
        }
    }

    private void scheduleReRegistration(String registrarAddress,
                                        int registrarPort,
                                        String registrarTransport, int expires)
    {
        try
        {
            console.logEntry();

            ReRegisterTask reRegisterTask = new ReRegisterTask(
                         registrarAddress, registrarPort,
                         registrarTransport, expires);

            //java.util.Timer thinks in miliseconds
            //bug report and fix by Willem Romijn (romijn at lucent.com)
            reRegisterTimer.schedule(reRegisterTask, expires*1000);
        }
        finally
        {
            console.logExit();
        }
    }

}