refreshhelper.java

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

package com.micromethod.sipstack.ri;

import java.io.IOException;
import java.io.OutputStream;
import java.util.*;

import com.micromethod.sipstack.i.*;

/**
 * RefreshHelper
 */
public class RefreshHelper implements SipClientConnectionListener {
  /**
   * Refresh
   */
  protected class Refresh {
    /**
     * m_sipRefreshListener
     */
    protected SipRefreshListener m_sipRefreshListener = null;

    /**
     * m_sipAddress
     */
    protected SipAddress m_sipAddress = null;

    /**
     * m_timer
     */
    protected Timer m_timer = null;

    /**
     * m_sipRequest
     */
    protected SipRequest m_sipRequest = null;

    /**
     * m_sipHeaders
     */
    protected SipHeader m_sipHeaders[] = null;

    /**
     * m_sipDialog
     */
    protected Dialog m_sipDialog = null;

    /**
     * m_refreshID
     */
    protected int m_refreshID = 0;

    /**
     * m_expiresTime
     */
    protected int m_expiresTime = 0;

    /**
     * m_cseqNum
     */
    protected int m_cseqNum = 0;

    /**
     * Refresh Constructor
     */
    protected Refresh() {
      m_sipAddress = null;
      m_timer = null;
      m_sipRequest = null;
      m_refreshID = 0;
      m_expiresTime = 0;
      m_cseqNum = 0;
    }
  }

  /**
   * ClientTimerTaskImpl
   */
  protected class ClientTimerTaskImpl extends TimerTask {
    /**
     * m_refresh
     */
    Refresh m_refresh = null;

    /**
     * m_sipHeaders
     */
    SipHeader m_sipHeaders[] = null;

    public void run() {
      String s1 = m_refresh.m_sipRequest.getHeaderValue("Content-Type");
      byte abyte0[] = m_refresh.m_sipRequest.getContent();
      if (s1 != null && abyte0 != null && abyte0.length > 0) {
        OutputStream outputstream = RefreshHelper.this
            .openContentOutputStream(m_refresh, m_sipHeaders, s1,
                abyte0.length, m_refresh.m_expiresTime);
        try {
          outputstream.write(abyte0);
          outputstream.close();
        }
        catch (IOException ioexception) {
          ioexception.printStackTrace();
        }
      }
      else {
        RefreshHelper.this.openContentOutputStream(m_refresh, m_sipHeaders,
            ((String) (null)), 0, m_refresh.m_expiresTime);
      }
    }

    /**
     * ClientTimerTaskImpl Constructor
     * 
     * @param refresh
     * @param sipHeaders
     */
    ClientTimerTaskImpl(Refresh refresh, SipHeader sipHeaders[]) {
      m_refresh = refresh;
      m_sipHeaders = sipHeaders;
    }
  }

  /**
   * m_timeout
   */
  protected int m_timeout = 0;

  /**
   * m_sipClientConnectionListener
   */
  private static RefreshHelper m_sipClientConnectionListener = null;

  private Vector _fldif = null;

  /**
   * m_refreshIDs
   */
  private Hashtable m_refreshIDs = null;

  /**
   * RefreshHelper Constructor
   * 
   */
  private RefreshHelper() {
    m_timeout = 2000;
    _fldif = new Vector(1);
    m_refreshIDs = new Hashtable(1);
  }

  /**
   * getInstance
   * 
   * @return Singleton SipClientConnectionListener
   */
  public static RefreshHelper getInstance() {
    if (m_sipClientConnectionListener == null)
      m_sipClientConnectionListener = new RefreshHelper();
    return m_sipClientConnectionListener;
  }

  /**
   * getRefreshID
   * 
   * @param sipRefreshListener
   * @param sipClientConnection
   * @param id
   * @return refreshID
   * @throws SipException
   */
  protected int getRefreshID(SipRefreshListener sipRefreshListener,
      ClientConnection sipClientConnection, int id) throws SipException {
    Refresh b1 = (Refresh) m_refreshIDs.get(((Object) (new Integer(id))));
    if (b1 != null)
      return b1.m_refreshID;
    b1 = new Refresh();
    b1.m_sipRefreshListener = sipRefreshListener;
    b1.m_sipRequest = (SipRequest) sipClientConnection.m_sipResponse;
    b1.m_sipAddress = sipClientConnection.m_sipAddress;
    b1.m_refreshID = ((Object) (b1)).hashCode();
    String s2 = sipClientConnection.m_sipRequest.getHeaderValue("CSeq");
    b1.m_cseqNum = Integer.parseInt(s2.substring(0, s2.indexOf(' ')));
    try {
      b1.m_expiresTime = removeRefreshTask(sipClientConnection.m_sipRequest);
      Vector vector = sipClientConnection.m_sipRequest.getHeaders("Contact");
      if (vector != null) {
        b1.m_sipHeaders = new SipHeader[vector.size()];
        for (int j = 0; j < vector.size(); j++) {
          PairStructure t1 = (PairStructure) vector.elementAt(j);
          b1.m_sipHeaders[j] = new SipHeader(t1.getName(), t1.getValue());
          Protocol.echo("RefreshHandler: adding " + b1.m_sipHeaders[j]);
        }

      }
    }
    catch (Exception exception) {
      exception.printStackTrace();
    }
    m_refreshIDs.put(((Object) (new Integer(b1.m_refreshID))), ((Object) (b1)));
    Protocol.echo("RefreshHandler: initialized new refresh " + b1.m_refreshID);
    return b1.m_refreshID;
  }

  /**
   * refreshResponse
   * 
   * @param refreshID
   *          refreshID
   * @param sipResponse
   * @param sipDialog
   */
  protected void refreshResponse(int refreshID, SipResponse sipResponse,
      Dialog sipDialog) {
    Integer integer = new Integer(refreshID);
    Refresh b1 = (Refresh) m_refreshIDs.get(((Object) (integer)));
    if (b1 != null) {
      int j = sipResponse.getStatusCode();
      String s1 = sipResponse.getMethod();
      Protocol.echo("RefreshHandler.notifyResponse(): " + refreshID
          + " status code: " + j);
      if (j < 200)
        return;
      if (j >= 200 && j < 300) {
        try {
          if (s1.equals("REGISTER")) {
            resetTimerTask(b1, sipResponse);
          }
          else {
            b1.m_expiresTime = removeRefreshTask(((SipMessage) (sipResponse)));
            long l = b1.m_expiresTime * 1000 - m_timeout;
            Protocol.echo("RefreshHandler.notifyResponse(): started " + s1
                + " refresh " + refreshID + " expires = " + b1.m_expiresTime
                + " sec, delay = " + l / 1000L + " sec");
            ClientTimerTaskImpl a1 = new ClientTimerTaskImpl(b1,
                ((SipHeader[]) (null)));
            b1.m_sipDialog = sipDialog;
            synchronized (this) {
              if (b1.m_timer != null)
                b1.m_timer.cancel();
              b1.m_timer = new Timer();
              b1.m_timer.schedule(((TimerTask) (a1)), l);
            }
            refreshListenerCallback(b1, j, sipResponse.getReasonPhrase());
          }
        }
        catch (Exception exception) {
          exception.printStackTrace();
          refreshListenerCallback(b1, 1, exception.getMessage());
          m_refreshIDs.remove(((Object) (integer)));
        }
      }
      else {
        refreshListenerCallback(b1, j, sipResponse.getReasonPhrase());
        m_refreshIDs.remove(((Object) (integer)));
      }
    }
  }

  /**
   * notifyResponse
   * 
   * @param sipClientConnection
   */
  public void notifyResponse(SipClientConnection sipClientConnection) {
    try {
      sipClientConnection.receive(0L);
    }
    catch (Exception exception) {
      exception.printStackTrace();
    }
  }

  /**
   * removeRefreshTask
   * 
   * @param sipMessage
   * @return Expires time
   */
  private int removeRefreshTask(SipMessage sipMessage) {
    String s1;
    s1 = sipMessage.getHeaderValue("Expires");
    if (s1 == null) {
      return -1;
    }
    else {
      return Integer.parseInt(s1);
    }
  }

  /**
   * resetTimerTask
   * 
   * @param refresh
   * @param sipResponse
   */
  private void resetTimerTask(Refresh refresh, SipResponse sipResponse) {
    try {
      Vector vector = sipResponse.getHeaders("Contact");
      int i = 0x7fffffff;
      if (vector != null) {
        for (int j = 0; j < refresh.m_sipHeaders.length; j++) {
          SipHeader sipheader = compareAddressURI(vector,
              refresh.m_sipHeaders[j]);
          if (sipheader == null)
            continue;
          int k = 0x7fffffff;
          String s1 = sipheader.getParameter("expires");
          if (s1 != null)
            k = Integer.parseInt(s1);
          if (k < i)
            i = k;
        }

        long l = i * 1000 - m_timeout;
        Protocol.echo("RefreshHandler: started REGISTER refresh "
            + refresh.m_refreshID + " expires = " + i + " sec, delay = " + l
            / 1000L + " sec");
        ClientTimerTaskImpl a1 = new ClientTimerTaskImpl(refresh,
            refresh.m_sipHeaders);
        synchronized (this) {
          if (refresh.m_timer != null)
            refresh.m_timer.cancel();
          refresh.m_timer = new Timer();
          refresh.m_timer.schedule(((TimerTask) (a1)), l);
        }