mmsencoder.java.svn-base

编解码MMS彩信的Java类库

		else if (msgClass.equals(MmsMessage.MMS_CLASS_AUTO)) return MMS_CLASS_AUTO;
		else if (msgClass.equals(MmsMessage.MMS_CLASS_ADVERTISEMENT)) return MMS_CLASS_ADVERISEMENT;
		else if (msgClass.equals(MmsMessage.MMS_CLASS_INFORMATIONAL)) return MMS_CLASS_INFORMATIONAL;
		else throw new MmsEncodingException("Message class not supported: " + msgClass);
	}
	
	/**
	 * Encodes the message priority 
	 * @param priority message priority
	 * @return encoded byte
	 * @throws MmsEncodingException priority not supported
	 * @see MmsMessage#setMessagePriority(String)
	 */
	private byte encodeMessagePriority(String priority) throws MmsEncodingException{
		if (priority.equals(MmsMessage.MMS_PRIORITY_HIGH)) return MMS_PRIORITY_HIGH;
		else if (priority.equals(MmsMessage.MMS_PRIORITY_NORMAL)) return MMS_PRIORITY_NORMAL;
		else if (priority.equals(MmsMessage.MMS_PRIORITY_LOW)) return MMS_PRIORITY_LOW;
		else throw new MmsEncodingException("Message priority not supported: " + priority);
	}

	/**
	 * Encodes the message content type.<br>
	 * 
	 * <p>Although MmsMessage.CTYPE_APPLICATION_MULTIPART_RELATED can be set as the content
	 * type of an MmsMessage object, support for encoding these type of messages is not yet 
	 * implemented.</p> 
	 * @param contentType content type
	 * @return encoded byte
	 * @throws MmsEncodingException content type not supported
	 * @see MmsMessage#setMessageContentType(String)
	 */
	private byte encodeContentType(String contentType)throws MmsEncodingException{
		if (contentType.equals(MmsMessage.CTYPE_TEXT)) return CTYPE_TEXT;
		else if (contentType.equals(MmsMessage.CTYPE_TEXT_PLAIN)) return CTYPE_TEXT_PLAIN;
		else if (contentType.equals(MmsMessage.CTYPE_TEXT_HTML)) return CTYPE_TEXT_HTML;
		else if (contentType.equals(MmsMessage.CTYPE_TEXT_WML)) return CTYPE_TEXT_WML;
		else if (contentType.equals(MmsMessage.CTYPE_IMAGE)) return CTYPE_IMAGE;
		else if (contentType.equals(MmsMessage.CTYPE_IMAGE_GIF)) return CTYPE_IMAGE_GIF;
		else if (contentType.equals(MmsMessage.CTYPE_IMAGE_JPEG)) return CTYPE_IMAGE_JPEG;
		else if (contentType.equals(MmsMessage.CTYPE_IMAGE_PNG)) return CTYPE_IMAGE_PNG;
		else if (contentType.equals(MmsMessage.CTYPE_IMAGE_TIFF)) return CTYPE_IMAGE_TIFF;
		else if (contentType.equals(MmsMessage.CTYPE_IMAGE_VND_WAP_WBMP)) return CTYPE_IMAGE_VND_WAP_WBMP;
		else if (contentType.equals(MmsMessage.CTYPE_MULTIPART)) return CTYPE_MULTIPART;
		else if (contentType.equals(MmsMessage.CTYPE_MULTIPART_MIXED)) return CTYPE_MULTIPART_MIXED;
		else if (contentType.equals(MmsMessage.CTYPE_APPLICATION_MULTIPART_MIXED)) return CTYPE_APPLICATION_MULTIPART_MIXED;
		else if (contentType.equals(MmsMessage.CTYPE_APPLICATION_MULTIPART_RELATED)) 
			throw new MmsEncodingException("Content Type multipart related not supported yet");
		else throw new MmsEncodingException("Content type not supported: " + contentType);
	}

	/**
	 * Encodes the charset.
	 * @param charset
	 * @return encoded byte
	 * @throws MmsEncodingException charset not supported
	 * @see MmsPart#setPartCharset(String)
	 */
	private byte encodeCharset(String charset) throws MmsEncodingException{
		if (charset.equals(MmsMessage.CHARSET_US_ASCII)) return CHARSET_US_ASCII;
		else if (charset.equals(MmsMessage.CHARSET_UTF8)) return CHARSET_UTF8;
		else throw new MmsEncodingException("Charset not supported: " + charset);
	}
	
	/**
	 * Encodes a message part.
	 * 
	 * @param part message part to encode
	 * @return encoeded byte array
	 * @throws MmsEncodingException error encoding part
	 */
	private byte[] encodePart(MmsPart part) throws MmsEncodingException{
		/*
		 * Part encoding:
		 *  - HeadersLength: Uintvar     - Length of the header portion of the part
		 *  - DataLength   : Uintvar     - Length of the data portion of the part
		 *  - ContentType  : MultiOctect - Encoded content type of the data
		 *  - Headers      : (HeadersLength-length(ContentType)) octets
		 *  - Data         : DataLength octets 
		 */		
		byte cType = encodeContentType(part.getPartContentType());
		byte[] cTypeHeader;
		byte headersLength;
		//If the content type of the part is text
		if (cType >= CTYPE_TEXT && cType <= CTYPE_TEXT_WML){
			//Build a MultiOctet for the ContentType
			cTypeHeader = new byte[4];
			cTypeHeader[0] = 3;
			cTypeHeader[1] = (byte)(cType + 0x80);
			cTypeHeader[2] = P_CHARSET;
			cTypeHeader[3] = (byte)(encodeCharset(part.getPartCharset()) + 0x80);
			
			headersLength = 4;
		}else{
			cTypeHeader = new byte[1];
			cTypeHeader[0] = (byte)(cType + 0x80);
			headersLength = 1;
		}
		
		byte[] data = part.getPartContent();
		int dataLength = data.length;
		byte[] dataLengthEncoded = encodeUintvar(dataLength);
		
		//Result array
		byte[] result = new byte[1 + dataLengthEncoded.length + headersLength + dataLength];

		result[0] = headersLength;
		int offset=1;			
		System.arraycopy(dataLengthEncoded, 0, result, offset, dataLengthEncoded.length);
		offset+=dataLengthEncoded.length;
		System.arraycopy(cTypeHeader, 0, result, offset, cTypeHeader.length);
		offset+=cTypeHeader.length;
		System.arraycopy(data, 0, result, offset, data.length);
		
		return result;		
	}
	
	/**
	 * Encodes the MmsMessage object associated with this instance.
	 * 
	 * @return encoded mms message
	 * @throws MmsEncodingException error encoding message
	 */
	public byte[] encodeMessage() throws MmsEncodingException{
		ByteArrayOutputStream mmsBuffer = new ByteArrayOutputStream();
		try{
			/*
			 * The firsts headers MUST be in order
			 * - MessageType
			 * - Transaction Id
			 * - Version
			 */
			if (mmsMessage.isMessageTypeSet()){
				mmsBuffer.write(H_MMS_MESSAGE_TYPE + H_BASE);
				mmsBuffer.write(encodeMessageType(mmsMessage.getMessageType()));
			}
			else throw new MmsEncodingException("Message type not specified");

			if (mmsMessage.isTransactionIDSet()){ 
				mmsBuffer.write(H_MMS_TRANSACTION_ID + H_BASE);
				mmsBuffer.write(mmsMessage.getTransactionID().getBytes());
				mmsBuffer.write(NULL_CHAR);
			}else throw new MmsEncodingException("Transaction id not specified");

			if (mmsMessage.isVersionSet()){
				mmsBuffer.write(H_MMS_VERSION + H_BASE);
				mmsBuffer.write(encodeVersion(mmsMessage.getVersion()));
			}
			else throw new MmsEncodingException("MMS version not specified");

			/* Now the order of the headers is not important */

			//Date header
			if (mmsMessage.isMessageDateSet()){
				mmsBuffer.write(H_MMS_DATE + H_BASE);
				mmsBuffer.write(encodeDate(mmsMessage.getMessageDate()));			
			}

			//From header
			mmsBuffer.write(H_MMS_FROM + H_BASE);
			if (mmsMessage.isMessageSenderSet()){
				String from = mmsMessage.getMessageSender();
				/*
				 * Write the length of the header value. Consider the 
				 * length of the address, the address present token and
				 * the null character
				 */
				mmsBuffer.write(encodeUintvar(from.length()+2));
				mmsBuffer.write(MMS_SENDER_PRESENT);
				mmsBuffer.write(from.getBytes());
				mmsBuffer.write(NULL_CHAR);
			}else{
				//If there isn't a sender, the length consider only the token
				mmsBuffer.write(1);
				mmsBuffer.write(MMS_SENDER_INSERT);
			}

			//To header
			if (mmsMessage.isMessageReceiverSet()){
				Iterator<String> i = mmsMessage.getMessageReceivers().iterator();
				String to;
				while(i.hasNext()){
					to = i.next();
					mmsBuffer.write(H_MMS_TO + H_BASE);
					mmsBuffer.write(to.getBytes());
					mmsBuffer.write(NULL_CHAR);
				}
			}

			//CC header
			if (mmsMessage.isMessageCCSet()){
				Iterator<String> i = mmsMessage.getMessageCC().iterator();
				String cc;
				while(i.hasNext()){
					cc = i.next();
					mmsBuffer.write(H_MMS_CC + H_BASE);
					mmsBuffer.write(cc.getBytes());
					mmsBuffer.write(NULL_CHAR);
				}
			}

			//To header
			if (mmsMessage.isMessageBCCSet()){
				Iterator<String> i = mmsMessage.getMessageBCC().iterator();
				String bcc;
				while(i.hasNext()){
					bcc = i.next();
					mmsBuffer.write(H_MMS_BCC + H_BASE);
					mmsBuffer.write(bcc.getBytes());
					mmsBuffer.write(NULL_CHAR);
				}
			}		

			//Subject
			if (mmsMessage.isMessageSubjectSet()){
				mmsBuffer.write(H_MMS_SUBJECT + H_BASE);
				mmsBuffer.write(mmsMessage.getMessageSubject().getBytes());
				mmsBuffer.write(NULL_CHAR);
			}		

			//Delivery Report
			if (mmsMessage.isDeliveryReportSet()){
				mmsBuffer.write(H_MMS_DELIVERY_REPORT + H_BASE);
				if (mmsMessage.isDeliveryReportEnabled()) mmsBuffer.write(MMS_DELIVERY_REPORT_YES);
				else mmsBuffer.write(MMS_DELIVERY_REPORT_NO);
			}		

			//Sender Visibility
			if (mmsMessage.isSenderVisibilitySet()){
				mmsBuffer.write(H_MMS_SENDER_VISIBILITY + H_BASE);
				mmsBuffer.write(encodeSenderVisibility(mmsMessage.getSenderVisibility()));
			}		
			
			//Read Reply
			if (mmsMessage.isReadReplySet()){
				mmsBuffer.write(H_MMS_READ_REPLY + H_BASE);
				if (mmsMessage.isReadReplyEnabled()) mmsBuffer.write(MMS_READ_REPLY_YES);
				else mmsBuffer.write(MMS_READ_REPLY_NO);
			}			

			//Message Class
			if (mmsMessage.isMessageClassSet()){
				mmsBuffer.write(H_MMS_CLASS + H_BASE);
				mmsBuffer.write(encodeMessageClass(mmsMessage.getMessageClass()));
			}		

			//Expiry Time
			if (mmsMessage.isMessageExpiryTimeSet()){
				mmsBuffer.write(H_MMS_EXPIRY + H_BASE);

				byte[] expiry = encodeDate(mmsMessage.getMessageExpiryTime());
				/*
				 * The length field considers the length of the data value,
				 * plus the absolute flag, plus the length of the uintval
				 */
				mmsBuffer.write(encodeUintvar(expiry[0] + 2));
				if (mmsMessage.isMessageExpiryTimeAbsolute())
					mmsBuffer.write(MMS_EXPIRY_TIME_ABSOLUTE);
				else
					mmsBuffer.write(MMS_EXPIRY_TIME_RELATIVE);

				mmsBuffer.write(expiry);
			}

			//Delivery Time
			if (mmsMessage.isMessageExpiryTimeSet()){
				mmsBuffer.write(H_MMS_DELIVERY_TIME + H_BASE);

				byte[] delivery = encodeDate(mmsMessage.getMessageDeliveryTime());
				/*
				 * The length field considers the length of the data value,
				 * plus the absolute flag, plus the length of the uintval
				 */
				mmsBuffer.write(encodeUintvar(delivery[0] + 2));
				if (mmsMessage.isMessageExpiryTimeAbsolute())
					mmsBuffer.write(MMS_DELIVERY_TIME_ABSOLUTE);
				else
					mmsBuffer.write(MMS_DELIVERY_TIME_RELATIVE);

				mmsBuffer.write(delivery);
			}		

			//Priority
			if (mmsMessage.isMessagePrioritySet()){
				mmsBuffer.write(H_MMS_PRIORITY + H_BASE);
				mmsBuffer.write(encodeMessagePriority(mmsMessage.getMessagePriority()));
			}

			byte mmsCType;	
			/*
			 * The last header MUST be ContentType followed by the body
			 */
			if (mmsMessage.isMessageContentTypeSet()){
				mmsBuffer.write(H_MMS_CONTENT_TYPE + H_BASE);
				mmsCType = encodeContentType(mmsMessage.getMessageContentType());
				mmsBuffer.write(mmsCType + 0x80);

			}else throw new MmsEncodingException("Message content type not specified");

			/*
			 * Here begin the encoding of the body of the MMS message.
			 * The header of a multipart message is composed by:
			 *  - Entries number - Uintvar
			 */
			if (mmsCType == CTYPE_MULTIPART || mmsCType == CTYPE_MULTIPART_MIXED ||
					mmsCType == CTYPE_APPLICATION_MULTIPART_MIXED){

				//Write the header of the multipart message
				mmsBuffer.write(encodeUintvar(mmsMessage.getPartsNumber()));
				Iterator<MmsPart> i = mmsMessage.getParts().iterator();

				//Write each part
				while (i.hasNext()){
					mmsBuffer.write(encodePart(i.next()));
				}
			}else throw new MmsEncodingException("MMS message content type must be multipart");
		}catch(IOException e){
			e.printStackTrace();
		}finally{
			try{ mmsBuffer.close();	}catch(IOException e){}
		}
		return mmsBuffer.toByteArray();
	}
}