sip2peer服务端研究分享3:消息发送:

下面分析下sip2peer消息发送机制：
它的消息发送是通过UDP协议进行发送，它为了防止发送丢包现象，在后台开启了一个时间监听线程，当没有返回消息时，它将不停的继续发送。
下面从BS服务端发送消息到客户端进行分析:
首先：
BootstrapPeer.java 接受到终端握手请求后，BS服务将存在的客户端信息组装后进行发送

@Override
 protected void onReceivedJSONMsg(JSONObject peerMsg, Address sender) {
     ......
  if(newPLMsg!=null)
   //send(new Address(neighborPeer.getAddress()), newPLMsg);
   //发送信息
   send(neighborPeer, newPLMsg);
  ......
 
 }

 

然后：消息到达Note.java，这边主要完成2个任务，一是将消息通过消息封装机制进行处理；二是生成SipProvider
Note.java
  

  /**
  * Send peer message through SIP MESSAGE using <code>toContactAddress</code> as destination address 
  * 
  * @param toAddress local destination address
  * @param toContactAddress remote destination address
  * @param fromAddress sender address 
  * @param msg message message to send
  * @param contentType contentType type of content (es. application/json or application/xml)
  */
 protected void sendMessage(Address toAddress,  Address toContactAddress, Address fromAddress, String msg, String contentType){

  NameAddress destAddress = new NameAddress(toAddress);
  NameAddress senderAddress = new NameAddress(fromAddress);

  if(destAddress!=null && senderAddress!=null){

   if(contentType==null || contentType.equals("")) contentType="application/text";
            //将消息通过消息封装机制进行处理
   Message sipMessage = MessageFactory.createMessageRequest(sipProvider, destAddress, senderAddress, null, contentType, msg);

   if(toContactAddress!=null && (!toAddress.equals(toContactAddress)))
    sipMessage.addRouteHeader(new RouteHeader(new NameAddress(toContactAddress+";lr")) );
            //开启时间监听器，发送信息.
   TransactionClient tClient = new TransactionClient(sipProvider, sipMessage, this);
   tClient.request();

  }

 }

 
其次：消息通过TransactionClient进行处理：TransactionClient开启时间监听线程，发送消息，接受消息，超时处理
 

 public TransactionClient(SipProvider paramSipProvider, Message paramMessage, TransactionClientListener paramTransactionClientListener)
  {
    super(paramSipProvider);
    this.request = new Message(paramMessage);
    init(paramTransactionClientListener, this.request.getTransactionClientId());
  }

  void init(TransactionClientListener paramTransactionClientListener, TransactionId paramTransactionId)
  {
    this.transaction_listener = paramTransactionClientListener;
    this.transaction_id = paramTransactionId;
    //时间监听
    this.retransmission_to = new Timer(SipStack.retransmission_timeout, "Retransmission", null);
    this.transaction_to = new Timer(SipStack.transaction_timeout, "Transaction", null);
    this.clearing_to = new Timer(SipStack.clearing_timeout, "Clearing", null);
    printLog("new transaction-id: " + paramTransactionId.toString(), 1);
  }
  
  public void request()
  {
    printLog("start", 5);
    changeStatus(2);
    this.transaction_to = new Timer(this.transaction_to.getTime(), this.transaction_to.getLabel(), this);
    this.transaction_to.start();
    this.sip_provider.addSelectiveListener(this.transaction_id, this);
 //发送消息
    this.connection_id = this.sip_provider.sendMessage(this.request);
 //开启时间监听线程
    this.retransmission_to = new Timer(this.retransmission_to.getTime(), this.retransmission_to.getLabel(), this);
    this.retransmission_to.start();
  }

消息通过SipProvider.java进行转发。
  

private TransportConnId sendMessage(Message paramMessage, String paramString, IpAddress paramIpAddress, int paramInt1, int paramInt2)
  {
    if ((this.log_all_packets) || (paramMessage.getLength() > 12)) printLog("Sending message to " + new TransportConnId(paramString, paramIpAddress, paramInt1).toString(), 3);

    TransportConn localTransportConn = null;
    try {
      Transport localTransport = (Transport)this.sip_transports.get(paramString.toLowerCase());
      if (localTransport != null) {
     //发送消息
        localTransportConn = localTransport.sendMessage(paramMessage, paramIpAddress, paramInt1, paramInt2);
      }
      else {
        printWarning("Unsupported protocol (" + paramString + "): Message discarded", 1);
        return null;
      }
    }
    catch (IOException localIOException) {
      printException(localIOException, 1);
      return null;
    }

    String str = paramIpAddress.toString();
    printMessageLog(paramString, str, paramInt1, paramMessage.getLength(), paramMessage, "sent");

    if (localTransportConn != null) return new TransportConnId(localTransportConn);
    return null;
  }

 
消息到达UdpTransport.java,通过UdpTransport中的sendMessage方法信息消息发送.
 

public TransportConn sendMessage(Message paramMessage, IpAddress paramIpAddress, int paramInt1, int paramInt2)
    throws IOException
  {
    if (this.udp_provider != null) {
   //消息处理
      byte[] arrayOfByte = paramMessage.toString().getBytes();
      //消息发送
   UdpPacket localUdpPacket = new UdpPacket(arrayOfByte, arrayOfByte.length);

      localUdpPacket.setIpAddress(paramIpAddress);
      localUdpPacket.setPort(paramInt1);
      this.udp_provider.send(localUdpPacket);
    }
    return null;
  }

 
最后消息到达UdpProvider.java,通过DatagramSocket对消息进行发送.
UdpProvider.java

UdpSocket socket;

 public void send(UdpPacket paramUdpPacket)
    throws IOException
  { 
    //发送消息
    if (!this.stop) this.socket.send(paramUdpPacket);
  }

消息通过DatagramSocket进行发送
 

UdpSocket.java
  DatagramSocket socket;
  public void send(UdpPacket paramUdpPacket) throws IOException
  {
    this.socket.send(paramUdpPacket.getDatagramPacket());
  }

sip2peer服务端研究分享2:消息组装: