import javax.sip.TimeoutEvent; //导入依赖的package包/类
public void processTimeout(TimeoutEvent timeoutEvent) {
    this.timeoutSeen = true;
    ClientTransaction ctx = timeoutEvent.getClientTransaction();
    TestCase.assertSame("Should see a timeout for INVITE", ctx,
            this.inviteTid);
    TestCase.assertEquals("Should be in proceeding state",
            TransactionState.PROCEEDING, ctx.getState());
    try {
        Request cancelRequest = timeoutEvent.getClientTransaction()
                .createCancel();
        ClientTransaction cancelTx = this.provider
                .getNewClientTransaction(cancelRequest);
        cancelTx.sendRequest();
    } catch (Exception ex) {
        logger.error("Unexpected exception", ex);
        TestCase.fail("Unexpected exception");
    }

}
 

import javax.sip.TimeoutEvent; //导入依赖的package包/类
public void processTimeout(TimeoutEvent 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
    }
}
 

import javax.sip.TimeoutEvent; //导入依赖的package包/类
/**
 * @see SIPTransactionImpl#fireRetransmissionTimer()
 */
@Override
public void fireRetransmissionTimer() {

    try {
        if (logger.isLoggingEnabled(LogWriter.TRACE_DEBUG)) {
            logger.logDebug("fireRetransmissionTimer() -- " + this + " state " + getState());
        }
        // Resend the last response sent by this transaction
        if (isInviteTransaction() && (lastResponse != null || lastResponseAsBytes != null)) {
            // null can happen if this is terminating when the timer fires.
            if (!this.retransmissionAlertEnabled || sipStack.isTransactionPendingAck(this) ) {
                // Retransmit last response until ack.
                if (lastResponseStatusCode / 100 >= 2 && !this.isAckSeen) {
                    resendLastResponseAsBytes();
                }
            } else {
                // alert the application to retransmit the last response
                SipProviderImpl sipProvider = (SipProviderImpl) this.getSipProvider();
                TimeoutEvent txTimeout = new TimeoutEvent(sipProvider, this,
                        Timeout.RETRANSMIT);
                sipProvider.handleEvent(txTimeout, this);
            }

        }
    } catch (IOException e) {
        if (logger.isLoggingEnabled())
            logger.logException(e);
        raiseErrorEvent(SIPTransactionErrorEvent.TRANSPORT_ERROR);

    }

}
 

import javax.sip.TimeoutEvent; //导入依赖的package包/类
@Override
public void runTask() {
  SIPClientTransaction ct = SIPClientTransactionImpl.this;
  SipProviderImpl provider = ct.getSipProvider();

  if (ct.getState() != TransactionState.TERMINATED) {
    TimeoutEvent tte = new TimeoutEvent(provider, ct, Timeout.TRANSACTION);
    provider.handleEvent(tte, ct);
  } else {
    if (logger.isLoggingEnabled(LogWriter.TRACE_DEBUG)) {
      logger.logDebug("state = " + ct.getState());
    }
  }
}
 

import javax.sip.TimeoutEvent; //导入依赖的package包/类
public void processTimeout(TimeoutEvent timeoutEvent) {
    Transaction transaction;
    if (timeoutEvent.isServerTransaction()) {
        transaction = timeoutEvent.getServerTransaction();
    } else {
        transaction = timeoutEvent.getClientTransaction();
    }
    logger.info("state = " + transaction.getState());
    logger.info("dialog = " + transaction.getDialog());
    logger.info("dialogState = "
            + transaction.getDialog().getState());
    logger.info("Transaction Time out");
}
 

import javax.sip.TimeoutEvent; //导入依赖的package包/类
/**
 * Called by the transaction stack when a retransmission timer fires.
 */
public void fireRetransmissionTimer() {

  try {

    // Resend the last request sent
    if (this.getInternalState() < 0 || !this.isMapped)
      return;

    boolean inv = isInviteTransaction();
    int s = this.getInternalState();

    // JvB: INVITE CTs only retransmit in CALLING, non-INVITE in both TRYING and
    // PROCEEDING
    // Bug-fix for non-INVITE transactions not retransmitted when 1xx response received
    if ((inv && TransactionState._CALLING == s)
        || (!inv && (TransactionState._TRYING == s || TransactionState._PROCEEDING == s)))
    {
      // If the retransmission filter is disabled then
      // retransmission of the INVITE is the application
      // responsibility.

      if (lastRequest != null) {
        if (sipStack.generateTimeStampHeader
            && lastRequest.getHeader(TimeStampHeader.NAME) != null)
        {
          long milisec = System.currentTimeMillis();
          TimeStamp timeStamp = new TimeStamp();
          try {
            timeStamp.setTimeStamp(milisec);
          } catch (InvalidArgumentException ex) {
            InternalErrorHandler.handleException(ex);
          }
          lastRequest.setHeader(timeStamp);
        }
        super.sendMessage(lastRequest);
        if (this.notifyOnRetransmit) {
          TimeoutEvent txTimeout = new TimeoutEvent(this.getSipProvider(),
                                                    this,
                                                    Timeout.RETRANSMIT);
          this.getSipProvider().handleEvent(txTimeout, this);
        }
        if (this.timeoutIfStillInCallingState
            && this.getInternalState() == TransactionState._CALLING)
        {
          this.callingStateTimeoutCount--;
          if (callingStateTimeoutCount == 0) {
            TimeoutEvent timeoutEvent = new TimeoutEvent(this.getSipProvider(),
                                                         this,
                                                         Timeout.RETRANSMIT);
            this.getSipProvider().handleEvent(timeoutEvent, this);
            this.timeoutIfStillInCallingState = false;
          }

        }
      }

    }
  } catch (IOException e) {
    this.raiseIOExceptionEvent();
    raiseErrorEvent(SIPTransactionErrorEvent.TRANSPORT_ERROR);
  }

}
 

import javax.sip.TimeoutEvent; //导入依赖的package包/类
public void processTimeout(TimeoutEvent timeoutEvent) {
    getSipListener(timeoutEvent).processTimeout(timeoutEvent);
}
 

import javax.sip.TimeoutEvent; //导入依赖的package包/类
public void processTimeout(TimeoutEvent timeoutEvent) {
    logger.info("Timeout occured");
}
 

import javax.sip.TimeoutEvent; //导入依赖的package包/类
public void processTimeout(TimeoutEvent timeoutEvent) {

            logger.info("Transaction Time out");
            logger.info("TimeoutEvent " + timeoutEvent.getTimeout());
        }
 

import javax.sip.TimeoutEvent; //导入依赖的package包/类
public void processTimeout(TimeoutEvent timeoutEvent) {
    logger.error("Timeout occured");
    TestCase.fail("unexpected event");
}
 

import javax.sip.TimeoutEvent; //导入依赖的package包/类
public void processTimeout(TimeoutEvent timeoutEvent) {
    logger.error("Timeout occured");
    fail("unexpected event");
}
 

import javax.sip.TimeoutEvent; //导入依赖的package包/类
@Override
public void processTimeout(TimeoutEvent arg0) {
	// TODO Auto-generated method stub
	System.out.println("Transaction Time out");
}
 

import javax.sip.TimeoutEvent; //导入依赖的package包/类
@Override
public void processTimeout(TimeoutEvent evt) {
	logger.info("processTimeout");
}