sipmessage.java

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

package com.micromethod.sipstack.ri;

import java.util.Enumeration;
import java.util.Vector;

import com.micromethod.sipstack.i.SipException;

/**
 * SipMessage
 */
public class SipMessage {
  /**
   * m_firstLine
   */
  protected Vector m_firstLine = null;

  /**
   * m_headers
   */
  protected Vector m_headers = null;

  /**
   * m_content
   */
  protected byte m_content[] = null;

  /**
   * m_isRequest
   */
  protected boolean m_isRequest = false;

  /**
   * m_isResponse
   */
  protected boolean m_isResponse = false;

  public boolean _fldcase = false;

  /**
   * m_port
   */
  public int m_port = 0;

  /**
   * m_host
   */
  public String m_host = null;

  /**
   * m_localPort
   */
  public int m_localPort = 0;

  /**
   * SipMessage Constructor
   */
  public SipMessage() {
    m_isRequest = false;
    m_isResponse = false;
    m_headers = new Vector();
    m_firstLine = new Vector();
  }

  /**
   * SipMessage Constructor
   * 
   * @param firstLine
   *          firstLine
   * @param headers
   *          headers
   * @param content
   *          content
   */
  public SipMessage(Vector firstLine, Vector headers, byte content[]) {
    m_firstLine = firstLine;
    if (isRequest((String) m_firstLine.elementAt(0))) {
      m_isRequest = true;
      m_isResponse = false;
    }
    else {
      m_isRequest = false;
      m_isResponse = true;
    }
    if (headers != null) {
      m_headers = headers;
    }
    else {
      m_headers = new Vector();
    }
    m_content = content;
  }

  /**
   * addTopHeader
   * 
   * @param name
   *          name
   * @param value
   *          value
   */
  public void addTopHeader(String name, String value) {
    name = name.trim();
    PairStructure t1 = new PairStructure(name, value);
    PairStructure t2 = getHeader(name, true);
    if (t2 != null) {
      m_headers.insertElementAt(t1, m_headers.indexOf(t2));
    }
    else {
      m_headers.addElement(t1);
    }
  }

  /**
   * getHeaderValue
   * 
   * @param name
   *          name
   * @return value
   */
  public String getHeaderValue(String name) {
    PairStructure t1 = getHeader(name, true);
    if (t1 != null) {
      return t1.getValue();
    }
    return null;
  }

  /**
   * setHeader
   * 
   * @param name
   *          name
   * @param value
   *          value
   * @param order
   *          order/reverse
   * @throws SipException
   */
  public void setHeader(String name, String value, boolean order)
      throws SipException {
    name = name.trim();
    PairStructure t1 = getHeader(name, order);
    if (t1 != null) {
      t1.setValue(value);
    }
    else {
      addTopHeader(name, value);
    }
  }

  /**
   * getHeader
   * 
   * @param name
   *          name
   * @param order
   *          order/reverse
   * @return header
   */
  private PairStructure getHeader(String name, boolean order) {
    name = name.trim();
    String s1 = "";
    if (name.length() == 1) {
      s1 = SipConstants.switchFullName(name);
    }
    else {
      s1 = SipConstants.switchShortName(name);
    }
    if (order) {
      for (short i = 0; i < m_headers.size(); i++) {
        PairStructure t1 = (PairStructure) m_headers.elementAt(((int) (i)));
        if (t1.getName().equals(((Object) (name)))
            || t1.getName().equals(((Object) (s1)))) {
          return t1;
        }
      }
    }
    else {
      short j = (short) (m_headers.size() - 1);
      for (short k = j; k >= 0; k--) {
        PairStructure t2 = (PairStructure) m_headers.elementAt(((int) (k)));
        if (t2.getName().equals(((Object) (name)))
            || t2.getName().equals(((Object) (s1)))) {
          return t2;
        }
      }
    }
    return null;
  }

  /**
   * get_Headers
   * 
   * @param name
   *          name
   * @return type of headers
   */
  private Vector get_Headers(String name) {
    Vector vector = null;
    name = name.trim();
    String s1 = "";
    if (name.length() == 1) {
      s1 = SipConstants.switchFullName(name);
    }
    else {
      s1 = SipConstants.switchShortName(name);
    }
    for (int i = 0; i < m_headers.size(); i++) {
      PairStructure t1 = (PairStructure) m_headers.elementAt(i);
      if (!t1.getName().equals(name) && !t1.getName().equals(s1)) {
        continue;
      }
      if (vector == null) {
        vector = new Vector();
      }
      vector.addElement(((Object) (t1)));
    }
    return vector;
  }

  /**
   * getHeaders
   * 
   * @param name
   *          name
   * @return type of headers
   */
  public Vector getHeaders(String name) {
    return get_Headers(name);
  }

  /**
   * removeHeader
   * 
   * @param s
   *          name
   * @return removed value
   */
  public String removeHeader(String s) {
    PairStructure t1 = getHeader(s, true);
    if (t1 != null) {
      m_headers.removeElement(((Object) (t1)));
      return t1.getValue();
    }
    return null;
  }

  /**
   * removeHeaders
   * 
   * @param name
   *          name
   */
  public void removeHeaders(String name) {
    Vector vector = get_Headers(name);
    if (vector != null) {
      PairStructure t1 = null;
      for (Enumeration enumeration = vector.elements(); enumeration
          .hasMoreElements(); m_headers.removeElement(t1)) {
        t1 = (PairStructure) enumeration.nextElement();
      }
    }
  }

  /**
   * setContent
   * 
   * @param content
   *          content
   * @throws SipException
   */
  public void setContent(byte content[]) throws SipException {
    m_content = content;
  }

  /**
   * getContent
   * 
   * @return content
   */
  public byte[] getContent() {
    return m_content;
  }

  /**
   * isRequest
   * 
   * @return isRequest
   */
  public boolean isRequest() {
    return m_isRequest;
  }

  /**
   * isResponse
   * 
   * @return isResponse
   */
  public boolean isResponse() {
    return m_isResponse;
  }

  /**
   * toString
   * 
   * @return sipMessage String
   */
  public String toString() {
    StringBuffer stringbuffer = new StringBuffer();
    short i = (short) m_firstLine.size();
    for (short j = 0; j < i; j++) {
      stringbuffer.append(m_firstLine.elementAt((int) j));
      if (j < i - 1) {
        stringbuffer.append(" ");
      }
    }

    stringbuffer.append("\r\n");
    i = (short) m_headers.size();
    for (short k = 0; k < i; k++) {
      stringbuffer.append(((PairStructure) m_headers.elementAt((int) k))
          .getPairOfHeader());
      stringbuffer.append("\r\n");
    }

    stringbuffer.append("\r\n");
    if (m_content != null) {
      stringbuffer.append(new String(m_content));
    }
    return stringbuffer.toString();
  }

  /**
   * isRequest
   * 
   * @param s
   *          header String
   * @return check isRequest
   */
  public static boolean isRequest(String s) {
    return !s.startsWith("SIP/2.0");
  }

  /**
   * compareTo
   * 
   * @param a1
   *          sipMessage
   * @return check equals
   */
  public boolean compareTo(SipMessage a1) {
    String s = toString().trim();
    String s1 = a1.toString().trim();
    return s.compareTo(s1) == 0;
  }
}