timertaskimpl.java

jsr-180 (SIP) 实现源码。可以在真实手机上使用

package com.micromethod.sipstack.ri;

import java.util.TimerTask;

/**
 * TimerTaskImpl
 */
public class TimerTaskImpl extends TimerTask {
  /**
   * TRYING, 0
   */
  private static final int TRYING = 0;

  /**
   * PROCEEDING, 1
   */
  private static final int PROCEEDING = 1;

  /**
   * TERMINATED, 2
   */
  private static final int TERMINATED = 2;

  /**
   * CONFIRM, 3
   */
  private static final int CONFIRM = 3;

  /**
   * CALLING, 4
   */
  private static final int CALLING = 4;

  /**
   * COMPLETED, 5
   */
  private static final int COMPLETED = 5;

  /**
   * m_state
   */
  private int m_state = 0;

  /**
   * m_transaction
   */
  private BaseTransaction m_transaction = null;

  /**
   * m_sipMessage
   */
  private SipMessage m_sipMessage = null;

  /**
   * TimerTaskImpl Constructor
   * 
   * @param transaction
   *          transaction
   * @param state
   *          state
   */
  private TimerTaskImpl(BaseTransaction transaction, int state) {
    m_state = state;
    m_transaction = transaction;
  }

  /**
   * TimerTaskImpl Constructor
   * 
   * @param transaction
   *          transaction
   * @param state
   *          state
   * @param sipMessage
   *          sipMessage
   */
  private TimerTaskImpl(BaseTransaction transaction, int state,
      SipMessage sipMessage) {
    m_state = state;
    m_transaction = transaction;
    m_sipMessage = sipMessage;
  }

  /**
   * TimerTask Running
   */
  public void run() {
    switch (m_state) {
      case TERMINATED: // '\002'
      default:
        break;

      case TRYING: // '\0'
        if (m_sipMessage.isRequest()) {
          ((ClientTransaction) m_transaction)
              .sendRequest((SipRequest) m_sipMessage);
          break;
        }
        if (m_sipMessage.isResponse()) {
          ((ServerTransaction) m_transaction)
              .sendResponse((SipResponse) m_sipMessage);
        }
        break;

      case PROCEEDING: // '\001'
        if (m_sipMessage.isRequest()) {
          ((ServerTransaction) m_transaction)
              .receiveRequest((SipRequest) m_sipMessage);
          break;
        }
        if (m_sipMessage.isResponse()) {
          ((ClientTransaction) m_transaction)
              .receiveResponse((SipResponse) m_sipMessage);
        }
        break;

      case CONFIRM: // '\003'
        m_transaction.transactionTimer();
        break;

      case CALLING: // '\004'
        ((ClientTransaction) m_transaction)
            .reSendRequest((SipRequest) m_sipMessage);
        break;

      case COMPLETED: // '\005'
        m_transaction.ackTimer();
        break;
    }
  }

  /**
   * createTryingTask
   * 
   * @param transaction
   *          transaction
   * @param sipMessage
   *          sipMessage
   * @return TimerTask at Trying
   */
  public static TimerTaskImpl createTryingTask(BaseTransaction transaction,
      SipMessage sipMessage) {
    return new TimerTaskImpl(transaction, 0, sipMessage);
  }

  /**
   * createProceedingTask
   * 
   * @param transaction
   *          transaction
   * @param sipMessage
   *          sipMessage
   * @return TimerTask at Proceeding
   */
  public static TimerTaskImpl createProceedingTask(BaseTransaction transaction,
      SipMessage sipMessage) {
    return new TimerTaskImpl(transaction, 1, sipMessage);
  }

  /**
   * createTerminatedTask
   * 
   * @param transaction
   *          transaction
   * @return TimerTask at Terminated
   */
  public static TimerTaskImpl createTerminatedTask(BaseTransaction transaction) {
    return new TimerTaskImpl(transaction, 2);
  }

  /**
   * createConfirmTask
   * 
   * @param transaction
   *          transaction
   * @return TimerTask at Confirm
   */
  public static TimerTaskImpl createConfirmTask(BaseTransaction transaction) {
    return new TimerTaskImpl(transaction, 3);
  }

  /**
   * createCallingTask
   * 
   * @param transaction
   *          transaction
   * @param sipMessage
   *          sipMessage
   * @return TimerTask at Calling
   */
  public static TimerTaskImpl createCallingTask(BaseTransaction transaction,
      SipMessage sipMessage) {
    return new TimerTaskImpl(transaction, 4, sipMessage);
  }

  /**
   * createCompletedTask
   * 
   * @param transaction
   *          transaction
   * @return TimerTask at Completed
   */
  public static TimerTaskImpl createCompletedTask(BaseTransaction transaction) {
    return new TimerTaskImpl(transaction, 5);
  }

  /**
   * isTrying
   * 
   * @return isTrying
   */
  public boolean isTrying() {
    return m_state == 0;
  }

  /**
   * isProceeding
   * 
   * @return isProceeding
   */
  public boolean isProceeding() {
    return m_state == 1;
  }

  /**
   * isTerminated
   * 
   * @return isTerminated
   */
  public boolean isTerminated() {
    return m_state == 2;
  }

  /**
   * isConfirm
   * 
   * @return isConfirm
   */
  public boolean isConfirm() {
    return m_state == 3;
  }

  /**
   * isCalling
   * 
   * @return isCalling
   */
  public boolean isCalling() {
    return m_state == 4;
  }

  /**
   * isCompleted
   * 
   * @return isCompleted
   */
  public boolean isCompleted() {
    return m_state == 5;
  }

  /**
   * getSipMessage
   * 
   * @return sipMessage
   */
  public SipMessage getSipMessage() {
    return m_sipMessage;
  }
}