Create WAP Push SMS Messages (From C# to JAVA)-CSDN博客

本文链接：https://blog.csdn.net/cutemouse/article/details/1513557

猪年无聊,改了一个代码，有点D版那个意思，把WAP PUSH的C#代码改到了JAVA

原来出处：

http://www.codeproject.com/cs/internet/wappush/wappush_src.zip

http://www.codeproject.com/cs/internet/wappush.asp

改过后的代码在下面，程序好像可以输出了WAPPUSH的结构化的东西，但是，没有在CMPP协议上测试通过。

共7个文件：

package com.wap.wbxml;

public class Runner {

/**
* @param args
*/
public static void main(String[] args) {
  try
  {
   String recipient = "";  // mobile number to send the message to
   String href = "http://wap.monternet.com"; // url of the content to be pushed
   String text = "A WAP Push to 梦网 site"; // description of the content displayed to the user

PushMessage message = new PushMessage(href, text);
HexDecoder decoder = new HexDecoder();

//   Console.WriteLine("SMS body");
   System.out.println("SMS body");
//   Console.WriteLine(body);

   String body = new String(decoder.GetChars(message.GetSMSBytes()));
   System.out.println(body);
   body =byteToHexStr(message.GetSMSBytes());
   System.out.println(body);
   // this body is now ready to be sent, either via
   // an SMS Web Service as shown below or
   // via a mobile phone on a serial port.
   // Making sure the message is flagged as containing
   // a User Data Header

// A free evaluation account for this service can
// be set up at https://www.esendex.com/secure/registration/evaluation.aspx

//   messenger.MessengerHeader header = new messenger.MessengerHeader();
//   header.Username = "";  // username for the SMS account
//   header.Password = "";  // password for the SMS account
//   header.Account = "";  // account reference
//
//   messenger.SendService service = new messenger.SendService();
//   service.MessengerHeaderValue = header;
//
//   service.SendMessage(recipient, body, messenger.MessageType.SmartMessage);
//   Console.WriteLine("Message sent");
  }
  catch (Exception ex)
  {
//   Console.WriteLine(ex);
   ex.printStackTrace();
  }
//  Console.ReadLine();

}
private static String byteToHexStr(byte buf[]) {
  StringBuffer sb = new StringBuffer(2 * buf.length);
  for(int i = 0; i < buf.length; i++) {
   int h = (buf[ i ] & 0xf0) >> 4;
  int l = (buf[ i ] & 0x0f);
  sb.append(new Character((char)((h > 9) ? 'a' + h - 10 : '0' + h)));
  sb.append(new Character((char)((l > 9) ? 'a' + l - 10 : '0' + l)));
  }
  return sb.toString().toUpperCase();
}
}

package com.wap.wbxml;

import java.io.ByteArrayOutputStream;
import java.nio.ByteBuffer;

public class PushMessage {

// Ports for the WDP information element, instructing the handset which
// application to load on receving the message
protected static byte[] WDP_DESTINATIONPORT = new byte[] {0x0b, (byte) 0x84};
protected static byte[] WDP_SOURCEPORT = new byte[] {0x23, (byte) 0xf0};

ServiceIndication serviceIndication;

public PushMessage(String href, String text)
{
this.serviceIndication = new ServiceIndication(href, text, ServiceIndication.ServiceIndicationAction.signal_high);
}

/// <summary>
/// Generates the body of the SMS message
/// </summary>
/// <returns>byte array</returns>
public byte[] GetSMSBytes()
{
  ByteArrayOutputStream stream = new ByteArrayOutputStream();
//  MemoryStream stream = new MemoryStream();
//  stream.Write(wdpHeader, 0, wdpHeader.length);
//  stream.Write(pdu, 0, pdu.length);

  byte[] wdpHeader = GetWDPHeaderBytes();

stream.write(wdpHeader, 0, wdpHeader.length);

byte[] pdu = GetPDUBytes();

  stream.write(pdu, 0, pdu.length);
  return stream.toByteArray();
}

/// <summary>
/// Generates the PDU (Protocol Data Unit) comprising the encoded Service Indication
/// and the WSP (Wireless Session Protocol) headers
/// </summary>
/// <returns>byte array comprising the PDU</returns>
public byte[] GetPDUBytes()
{
  byte[] body = serviceIndication.GetWBXMLBytes();

  byte[] headerBuffer = GetWSPHeaderBytes((byte)body.length);

  ByteArrayOutputStream stream = new ByteArrayOutputStream();

//  MemoryStream stream = new MemoryStream();
//  stream.Write(headerBuffer, 0, headerBuffer.length);
//  stream.Write(body, 0, body.length);
  stream.write(headerBuffer, 0, headerBuffer.length);
  stream.write(body, 0, body.length);
  return stream.toByteArray();
}

/// <summary>
/// Generates the WSP (Wireless Session Protocol) headers with the well known
/// byte values specfic to a Service Indication
/// </summary>
/// <param name="contentLength">the length of the encoded Service Indication</param>
/// <returns>byte array comprising the headers</returns>
public byte[] GetWSPHeaderBytes(byte contentLength)
{
//  MemoryStream stream = new MemoryStream();
  ByteArrayOutputStream stream = new ByteArrayOutputStream();

//  stream.WriteByte(WSP.TRANSACTIONID_CONNECTIONLESSWSP);
//  stream.WriteByte(WSP.PDUTYPE_PUSH);
  stream.write(WSP.TRANSACTIONID_CONNECTIONLESSWSP);
  stream.write(WSP.PDUTYPE_PUSH);

//  MemoryStream headersStream = new MemoryStream();
  ByteArrayOutputStream headersStream = new ByteArrayOutputStream();

  headersStream.write(WSP.HEADER_CONTENTTYPE_application_vnd_wap_sic_utf_8, 0, WSP.HEADER_CONTENTTYPE_application_vnd_wap_sic_utf_8.length);

  headersStream.write(WSP.HEADER_APPLICATIONTYPE);
  headersStream.write(WSP.HEADER_APPLICATIONTYPE_x_wap_application_id_w2);

//  headersStream.WriteByte(WSP.HEADER_CONTENTLENGTH);
//  headersStream.WriteByte((byte)(contentLength + 128));
//
  headersStream.write(WSP.HEADER_PUSHFLAG, 0, WSP.HEADER_PUSHFLAG.length);

//  stream.write((byte)headersStream.length);
//
//  headersStream.WriteTo(stream);
//
  stream.write((byte)headersStream.toByteArray().length);

  stream.write(headersStream.toByteArray(),0,headersStream.toByteArray().length);
//  headersStream.WriteTo(stream);

return stream.toByteArray();
}

/// <summary>
/// Generates the WDP (Wireless Datagram Protocol) or UDH (User Data Header) for the
/// SMS message. In the case comprising the Application Port information element
/// indicating to the handset which application to start on receipt of the message
/// </summary>
/// <returns>byte array comprising the header</returns>
public byte[] GetWDPHeaderBytes()
{
//  MemoryStream stream = new MemoryStream();
  ByteArrayOutputStream stream = new ByteArrayOutputStream();
//  stream.WriteByte(WDP.INFORMATIONELEMENT_IDENTIFIER_APPLICATIONPORT);
//  stream.WriteByte((byte)(WDP_DESTINATIONPORT.length + WDP_SOURCEPORT.length));
  stream.write(WDP.INFORMATIONELEMENT_IDENTIFIER_APPLICATIONPORT);
  stream.write((byte)(WDP_DESTINATIONPORT.length + WDP_SOURCEPORT.length));
  stream.write(WDP_DESTINATIONPORT, 0, WDP_DESTINATIONPORT.length);
  stream.write(WDP_SOURCEPORT, 0, WDP_SOURCEPORT.length);

//  MemoryStream headerStream = new MemoryStream();
  ByteArrayOutputStream headerStream = new ByteArrayOutputStream();
  // write length of header
  headerStream.write((byte)stream.toByteArray().length);
  headerStream.write(stream.toByteArray(),0,stream.toByteArray().length);
//  stream.WriteTo(headerStream);
  return headerStream.toByteArray();
}

/**
* @param args
*/
public static void main(String[] args) {

}

package com.wap.wbxml;

import java.io.ByteArrayOutputStream;
import java.io.UnsupportedEncodingException;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;

import com.tools.Utf8Util;

/**
* @author

* @date 2007-2-24 22:16:15
* @
*/

public class ServiceIndication {

public static enum ServiceIndicationAction {NotSet, signal_none, signal_low, signal_medium, signal_high, delete};

// Well known DTD token
public static byte DOCUMENT_DTD_ServiceIndication = 0x05; // ServiceIndication 1.0 Public Identifier

// Tag Tokens
public static byte TAGTOKEN_si = 0x5;
public static byte TAGTOKEN_indication = 0x6;
public static byte TAGTOKEN_info = 0x7;
public static byte TAGTOKEN_item = 0x8;

// Attribute Tokens
public static byte ATTRIBUTESTARTTOKEN_action_signal_none = 0x5;
public static byte ATTRIBUTESTARTTOKEN_action_signal_low = 0x6;
public static byte ATTRIBUTESTARTTOKEN_action_signal_medium = 0x7;
public static byte ATTRIBUTESTARTTOKEN_action_signal_high = 0x8;
public static byte ATTRIBUTESTARTTOKEN_action_signal_delete = 0x9;
public static byte ATTRIBUTESTARTTOKEN_created = 0xA;
public static byte ATTRIBUTESTARTTOKEN_href = 0xB;
public static byte ATTRIBUTESTARTTOKEN_href_http = 0xC; // http://
public static byte ATTRIBUTESTARTTOKEN_href_http_www = 0xD; // http://www.
public static byte ATTRIBUTESTARTTOKEN_href_https = 0xE; // https://
public static byte ATTRIBUTESTARTTOKEN_href_https_www = 0xF; // https://www.
public static byte ATTRIBUTESTARTTOKEN_si_expires = 0x10;
public static byte ATTRIBUTESTARTTOKEN_si_id = 0x11;
public static byte ATTRIBUTESTARTTOKEN_class = 0x12;

// Attribute Value Tokens
public static byte ATTRIBUTEVALUETOKEN_com = (byte) 0x85;      // .com/
public static byte ATTRIBUTEVALUETOKEN_edu = (byte) 0x86;      // .edu/
public static byte ATTRIBUTEVALUETOKEN_net = (byte) 0x87;      // .net/
public static byte ATTRIBUTEVALUETOKEN_org = (byte) 0x88;      // .org/

private static HashMap<String,Byte> hrefStartTokens;
// private static HashTable attributeValueTokens;
private static HashMap<String,Byte> attributeValueTokens;

public String Href;
public String Text;

// public DateTime CreatedAt;
// public DateTime ExpiresAt;

public Calendar CreatedAt;
public Calendar ExpiresAt;

public ServiceIndicationAction Action;

static
{
hrefStartTokens = new HashMap<String,Byte>();

//  hrefStartTokens.Add("https://www.", ATTRIBUTESTARTTOKEN_href_https_www);
//  hrefStartTokens.Add("http://www.", ATTRIBUTESTARTTOKEN_href_http_www);
//  hrefStartTokens.Add("https://", ATTRIBUTESTARTTOKEN_href_https);
//  hrefStartTokens.Add("http://", ATTRIBUTESTARTTOKEN_href_http);

  hrefStartTokens.put("https://www.", ATTRIBUTESTARTTOKEN_href_https_www);
  hrefStartTokens.put("http://www.", ATTRIBUTESTARTTOKEN_href_http_www);
  hrefStartTokens.put("https://", ATTRIBUTESTARTTOKEN_href_https);
  hrefStartTokens.put("http://", ATTRIBUTESTARTTOKEN_href_http);

  attributeValueTokens =new HashMap<String,Byte>();

  attributeValueTokens.put(".com/", ATTRIBUTEVALUETOKEN_com);
  attributeValueTokens.put(".edu/", ATTRIBUTEVALUETOKEN_edu);
  attributeValueTokens.put(".net/", ATTRIBUTEVALUETOKEN_net);
  attributeValueTokens.put(".org/", ATTRIBUTEVALUETOKEN_org);

//  attributeValueTokens.Add(".com/", ATTRIBUTEVALUETOKEN_com);
//  attributeValueTokens.Add(".edu/", ATTRIBUTEVALUETOKEN_edu);
//  attributeValueTokens.Add(".net/", ATTRIBUTEVALUETOKEN_net);
//  attributeValueTokens.Add(".org/", ATTRIBUTEVALUETOKEN_org);
}

public ServiceIndication(String href, String text, ServiceIndicationAction action)
{
  this.Href = href;
  this.Text = text;
  this.Action = action;
}

public ServiceIndication(String href, String text, Calendar createdAt, Calendar expiresAt)

{
  this(href, text, ServiceIndicationAction.NotSet);
  this.CreatedAt = createdAt;
  this.ExpiresAt = expiresAt;
}

public ServiceIndication(String href, String text, Calendar createdAt, Calendar expiresAt, ServiceIndicationAction action)
{
  this (href, text, action);
  this.CreatedAt = createdAt;
  this.ExpiresAt = expiresAt;
}

/// <summary>
/// Generates a byte array comprising the encoded Service Indication
/// </summary>
/// <returns>The encoded body</returns>
public byte[] GetWBXMLBytes()
{
//  MemoryStream stream = new MemoryStream();
  ByteArrayOutputStream stream = new ByteArrayOutputStream();
  // wbxml headers
  stream.write(WBXML.VERSION_1_1);
  stream.write(DOCUMENT_DTD_ServiceIndication);
  stream.write(WBXML.CHARSET_UTF_8);
  stream.write(WBXML.NULL);

  // start xml doc
  stream.write(WBXML.SetTagTokenIndications(TAGTOKEN_si, false, true));
  stream.write(WBXML.SetTagTokenIndications(TAGTOKEN_indication, true , true));

  // href attribute
  // this attribute has some well known start tokens that
  // are contained within a static hashtable. Iterate through
  // the table and chose the token.
  int i = 0;
  byte hrefTagToken = ATTRIBUTESTARTTOKEN_href;
//  foreach (String startString : hrefStartTokens.Keys)
  for (String startString : hrefStartTokens.keySet())
  {
   if (this.Href.startsWith(startString))
   {
//    hrefTagToken = (byte)hrefStartTokens[startString];
    hrefTagToken = (byte)hrefStartTokens.get(startString);
    i = startString.length();
    break;
   }
  }
  stream.write(hrefTagToken);

WriteInlineString(stream, this.Href.substring(i));
/*
* Date elements removed as does not seem to be supported
* by all handsets, or I'm doing it incorrectly, or it's a version 1.2
* thing.

  // created attrbute
  stream.WriteByte(ATTRIBUTESTARTTOKEN_created);
  WriteDate(stream, this.CreatedAt);

  // si-expires attrbute
  stream.WriteByte(ATTRIBUTESTARTTOKEN_si_expires);
  WriteDate(stream, this.ExpiresAt);
*/
  // action attibute
  if (this.Action != ServiceIndicationAction.NotSet)
   stream.write(GetActionToken(this.Action));

  // close indication element attributes
  stream.write(WBXML.TAGTOKEN_END);

  // text of indication element
  WriteInlineString(stream, this.Text);

  // close indication element
  stream.write(WBXML.TAGTOKEN_END);
  // close si element
  stream.write(WBXML.TAGTOKEN_END);

  return stream.toByteArray();
}

/// <summary>
/// Gets the token for the action attribute
/// </summary>
/// <param name="action">Interruption level instruction to the handset</param>
/// <returns>well known byte value for the action attribute</returns>
protected byte GetActionToken(ServiceIndicationAction action)
{
  switch (action)
  {
//   case ServiceIndicationAction.delete :
   case delete :
    return ATTRIBUTESTARTTOKEN_action_signal_delete;
//   case ServiceIndicationAction.signal_high :
   case signal_high :
    return ATTRIBUTESTARTTOKEN_action_signal_high;
   case signal_low :
    return ATTRIBUTESTARTTOKEN_action_signal_low;
   case signal_medium :
    return ATTRIBUTESTARTTOKEN_action_signal_medium;
   default :
    return ATTRIBUTESTARTTOKEN_action_signal_none;
  }
}

/// <summary>
/// Encodes an inline String into the stream using UTF8 encoding
/// </summary>
/// <param name="stream">The target stream</param>
/// <param name="text">The text to write</param>
protected void WriteInlineString(ByteArrayOutputStream stream, String text)
{
// indicate that the follow bytes comprise a String
stream.write(WBXML.TOKEN_INLINE_STRING_FOLLOWS);

  // write character bytes
//  byte[] buffer = Encoding.UTF8.GetBytes(text);
  byte[] buffer=null;
  try {
   buffer = text.getBytes("UTF-8");
   stream.write(buffer, 0, buffer.length);
  } catch (UnsupportedEncodingException e) {
   // TODO 自动生成 catch 块
   e.printStackTrace();
  }

  // end is indicated by a null byte
  stream.write(WBXML.NULL);
}
/// <summary>
/// Encodes the DateTime to the stream.
/// DateTimes are encoded as Opaque Data with each number in the String represented
/// by its 4-bit binary value
/// eg: 1999-04-30 06:40:00
/// is encoded as 199904300640.
/// Trailing zero values are not included.
/// </summary>
/// <param name="stream">Target stream</param>
/// <param name="date">DateTime to encode</param>
protected void WriteDate(ByteArrayOutputStream stream, Calendar date)
{
  byte[] buffer = new byte[7];

  int year=date.get(Calendar.YEAR);
  int month=date.get(Calendar.MONTH)+1;
  int day=date.get(Calendar.DATE);
  int hour=date.get(Calendar.HOUR_OF_DAY);
  int minute=date.get(Calendar.MINUTE);
  int second=date.get(Calendar.SECOND);

  buffer[0] = (byte)(year / 100);
  buffer[1] = (byte)(year % 100);
  buffer[2] = (byte)month;
  buffer[3] = (byte)day;

int dateLength = 4;

  if (hour > 0)
  {
   buffer[4] = (byte)hour;
   dateLength = 5;
  }

  if (minute> 0)
  {
   buffer[5] = (byte)minute;
   dateLength = 6;
  }

  if (second > 0)
  {
   buffer[6] = (byte)second;
   dateLength = 7;
  }

  // write to stream
  stream.write(WBXML.TOKEN_OPAQUEDATA_FOLLOWS);
  stream.write((byte)dateLength);
  stream.write(buffer, 0, dateLength);
}

/**
* @param args
*/
public static void main(String[] args) {
// TODO 自动生成方法存根

}

package com.wap.wbxml;

public class WBXML {

public static byte NULL = 0x00;

public static byte VERSION_1_1 = 0x01;
public static byte VERSION_1_2 = 0x02;

public static byte CHARSET_UTF_8 = 0x6A;

public static byte TAGTOKEN_END = 0x01;
public static byte TOKEN_INLINE_STRING_FOLLOWS = 0x03;
public static byte TOKEN_OPAQUEDATA_FOLLOWS = (byte) 0xC3;

public static byte SetTagTokenIndications(byte token, Boolean hasAttributes, Boolean hasContent)
{
  if (hasAttributes)
   token |= 0xC0;
  if (hasContent)
   token |= 0x40;

return token;
}

/**
* @param args
*/
public static void main(String[] args) {
// TODO 自动生成方法存根

}

package com.wap.wbxml;

import java.io.ByteArrayOutputStream;

public class WDP {

public static byte INFORMATIONELEMENT_IDENTIFIER_APPLICATIONPORT = 0x05;

/**
* @param args
*/
public static void main(String[] args) {
  ByteArrayOutputStream stream = new ByteArrayOutputStream();
//  MemoryStream stream = new MemoryStream();
//  stream.Write(wdpHeader, 0, wdpHeader.length);
//  stream.Write(pdu, 0, pdu.length);

  byte[] wdpHeader = {0x01};

stream.write(wdpHeader, 0, wdpHeader.length);

  byte[] pdu ={0x03,0x04,0x05};
  stream.write(12);
  stream.write(pdu, 0, pdu.length);

  byte[] b=stream.toByteArray();
  for(int i=0;i<b.length;i++){
   System.out.println(b[i]);
  }
  System.out.println(stream.toByteArray().length);

}

package com.wap.wbxml;

import java.util.Calendar;
import java.util.GregorianCalendar;

public class WSP {

public static byte TRANSACTIONID_CONNECTIONLESSWSP = 0x25;

public static byte PDUTYPE_PUSH = 0x06;

public static byte HEADER_CONTENTLENGTH = (byte) 0x8D;

public static byte[] HEADER_CONTENTTYPE_application_vnd_wap_sic_utf_8 = new byte[] {0x03,(byte) 0xAE,(byte) 0x81,(byte) 0xEA};

public static byte HEADER_APPLICATIONTYPE = (byte) 0xaf;
public static byte HEADER_APPLICATIONTYPE_x_wap_application_id_w2 = (byte) 0x82;

public static byte[] HEADER_PUSHFLAG = new byte[] {(byte) 0xB4, (byte) 0x84};

/**
* @param args
*/
public static void main(String[] args) {

  java.text.DateFormat df = new java.text.SimpleDateFormat("yyyyMMddHHmmss");
  String Time = df.format(new java.util.Date());
  java.util.Date dt=new java.util.Date();
  System.out.println(dt.getYear());

  System.out.println(Time);
//  int timeint=Integer.parseInt(Time);

  Calendar calendar = new GregorianCalendar();
  int year=calendar.get(Calendar.YEAR);
  int month=calendar.get(Calendar.MONTH)+1;
  int date=calendar.get(Calendar.DATE);
  int hour=calendar.get(Calendar.HOUR_OF_DAY);
  int minute=calendar.get(Calendar.MINUTE);
  int second=calendar.get(Calendar.SECOND);
  String Time2 = Integer.toString(year)+Integer.toString(month)+Integer.toString(date)+" "+Integer.toString(hour)+Integer.toString(minute)+Integer.toString(second);
  System.out.println(Time2);
}

}

package com.wap.wbxml;

/**
* @author xujianqiang
* @date 2007-2-24 22:16:15
* @project yxhservice11
*/
public class HexDecoder {

// internal HexDecoder()
// {
// }

/// <summary>
/// Returns the length of the Hex represenation of a byte array
/// </summary>
/// <param name="bytes">array of bytes to represent</param>
/// <param name="index">start index in buffer</param>
/// <param name="maxBytes">number of bytes from start to represent</param>
/// <returns></returns>
public int GetCharCount(byte[] bytes, int index, int maxBytes)
{
return Math.min(bytes.length-index, maxBytes)*2;

}

/// <summary>
/// Returns the char for a given byte value
/// </summary>
/// <param name="b"></param>
/// <returns></returns>
private static char GetChar(byte b)
{
  if (b<=9)
   return (char)('0'+b);
  else
   return (char)('A'+(b-10));
}

/// <summary>
/// Write the Hex representation of a byte array to the char array passed in
/// </summary>
/// <param name="bytes">array to represent</param>
/// <param name="byteIndex">start index</param>
/// <param name="maxBytes">number of bytes to represent</param>
/// <param name="chars">target array</param>
/// <param name="charIndex">start index in target array</param>
/// <returns>number of characters written</returns>
public int GetChars(byte[] bytes, int byteIndex, int maxBytes, char[] chars, int charIndex)
{
//Work out how many chars to return.
int charCount = GetCharCount(bytes, byteIndex, maxBytes);

  //Check the buffer size.
  if (chars.length-charIndex<charCount)
   try {
    throw new Exception("The character array is not large enough to contain the characters that will be generated from the byte buffer.");
   } catch (Exception e) {
    // TODO 自动生成 catch 块
    e.printStackTrace();
   }
  for (int i=byteIndex; i<maxBytes; i++, charIndex+=2)
  {
   byte upperValue = (byte)Math.floor(bytes[i]/16);
   byte lowerValue = (byte)(bytes[i]%16);
   chars[charIndex] = GetChar(upperValue);
   chars[charIndex+1] = GetChar(lowerValue);
  }

  return charCount;
}
/// <summary>
/// Returns the Hex representation of a byte array
/// </summary>
/// <param name="bytes">The byte array to represent</param>
/// <returns>char array representing the byte array</returns>
public char[] GetChars(byte[] bytes)
{
  int charCount = GetCharCount(bytes, 0, bytes.length);
  char[] chars = new char[charCount];
  GetChars(bytes, 0, bytes.length, chars, 0);
  return chars;
}

/**
* @param args
*/
public static void main(String[] args) {

}