| /* |
| * Copyright (C) 2013 Samsung System LSI |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package com.android.bluetooth.map; |
| |
| import android.text.util.Rfc822Token; |
| import android.text.util.Rfc822Tokenizer; |
| import android.util.Base64; |
| import android.util.Log; |
| |
| import java.io.UnsupportedEncodingException; |
| import java.nio.charset.Charset; |
| import java.nio.charset.IllegalCharsetNameException; |
| import java.text.SimpleDateFormat; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Date; |
| import java.util.Locale; |
| import java.util.UUID; |
| |
| public class BluetoothMapbMessageMime extends BluetoothMapbMessage { |
| |
| public static class MimePart { |
| public long mId = INVALID_VALUE; /* The _id from the content provider, can be used to |
| * sort the parts if needed */ |
| public String mContentType = null; /* The mime type, e.g. text/plain */ |
| public String mContentId = null; |
| public String mContentLocation = null; |
| public String mContentDisposition = null; |
| public String mPartName = null; /* e.g. text_1.txt*/ |
| public String mCharsetName = null; /* This seems to be a number e.g. 106 for UTF-8 |
| CharacterSets holds a method for the mapping. */ |
| public String mFileName = null; /* Do not seem to be used */ |
| public byte[] mData = null; /* The raw un-encoded data e.g. the raw |
| * jpeg data or the text.getBytes("utf-8") */ |
| |
| |
| String getDataAsString() { |
| String result = null; |
| String charset = mCharsetName; |
| // Figure out if we support the charset, else fall back to UTF-8, as this is what |
| // the MAP specification suggest to use, and is compatible with US-ASCII. |
| if (charset == null) { |
| charset = "UTF-8"; |
| } else { |
| charset = charset.toUpperCase(); |
| try { |
| if (!Charset.isSupported(charset)) { |
| charset = "UTF-8"; |
| } |
| } catch (IllegalCharsetNameException e) { |
| Log.w(TAG, "Received unknown charset: " + charset + " - using UTF-8."); |
| charset = "UTF-8"; |
| } |
| } |
| try { |
| result = new String(mData, charset); |
| } catch (UnsupportedEncodingException e) { |
| /* This cannot happen unless Charset.isSupported() is out of sync with String */ |
| try { |
| result = new String(mData, "UTF-8"); |
| } catch (UnsupportedEncodingException e2) { |
| Log.e(TAG, "getDataAsString: " + e); |
| } |
| } |
| return result; |
| } |
| |
| public void encode(StringBuilder sb, String boundaryTag, boolean last) |
| throws UnsupportedEncodingException { |
| sb.append("--").append(boundaryTag).append("\r\n"); |
| if (mContentType != null) { |
| sb.append("Content-Type: ").append(mContentType); |
| } |
| if (mCharsetName != null) { |
| sb.append("; ").append("charset=\"").append(mCharsetName).append("\""); |
| } |
| sb.append("\r\n"); |
| if (mContentLocation != null) { |
| sb.append("Content-Location: ").append(mContentLocation).append("\r\n"); |
| } |
| if (mContentId != null) { |
| sb.append("Content-ID: ").append(mContentId).append("\r\n"); |
| } |
| if (mContentDisposition != null) { |
| sb.append("Content-Disposition: ").append(mContentDisposition).append("\r\n"); |
| } |
| if (mData != null) { |
| /* TODO: If errata 4176 is adopted in the current form (it is not in either 1.1 |
| or 1.2), |
| the below use of UTF-8 is not allowed, Base64 should be used for text. */ |
| |
| if (mContentType != null && (mContentType.toUpperCase().contains("TEXT") |
| || mContentType.toUpperCase().contains("SMIL"))) { |
| String text = new String(mData, "UTF-8"); |
| if (text.getBytes().length == text.getBytes("UTF-8").length) { |
| /* Add the header split empty line */ |
| sb.append("Content-Transfer-Encoding: 8BIT\r\n\r\n"); |
| } else { |
| /* Add the header split empty line */ |
| sb.append("Content-Transfer-Encoding: Quoted-Printable\r\n\r\n"); |
| text = BluetoothMapUtils.encodeQuotedPrintable(mData); |
| } |
| sb.append(text).append("\r\n"); |
| } else { |
| /* Add the header split empty line */ |
| sb.append("Content-Transfer-Encoding: Base64\r\n\r\n"); |
| sb.append(Base64.encodeToString(mData, Base64.DEFAULT)).append("\r\n"); |
| } |
| } |
| if (last) { |
| sb.append("--").append(boundaryTag).append("--").append("\r\n"); |
| } |
| } |
| |
| public void encodePlainText(StringBuilder sb) throws UnsupportedEncodingException { |
| if (mContentType != null && mContentType.toUpperCase().contains("TEXT")) { |
| String text = new String(mData, "UTF-8"); |
| if (text.getBytes().length != text.getBytes("UTF-8").length) { |
| text = BluetoothMapUtils.encodeQuotedPrintable(mData); |
| } |
| sb.append(text).append("\r\n"); |
| } else if (mContentType != null && mContentType.toUpperCase().contains("/SMIL")) { |
| /* Skip the smil.xml, as no-one knows what it is. */ |
| } else { |
| /* Not a text part, just print the filename or part name if they exist. */ |
| if (mPartName != null) { |
| sb.append("<").append(mPartName).append(">\r\n"); |
| } else { |
| sb.append("<").append("attachment").append(">\r\n"); |
| } |
| } |
| } |
| } |
| |
| private long mDate = INVALID_VALUE; |
| private String mSubject = null; |
| private ArrayList<Rfc822Token> mFrom = null; // Shall not be empty |
| private ArrayList<Rfc822Token> mSender = null; // Shall not be empty |
| private ArrayList<Rfc822Token> mTo = null; // Shall not be empty |
| private ArrayList<Rfc822Token> mCc = null; // Can be empty |
| private ArrayList<Rfc822Token> mBcc = null; // Can be empty |
| private ArrayList<Rfc822Token> mReplyTo = null; // Can be empty |
| private String mMessageId = null; |
| private ArrayList<MimePart> mParts = null; |
| private String mContentType = null; |
| private String mBoundary = null; |
| private boolean mTextonly = false; |
| private boolean mIncludeAttachments; |
| private boolean mHasHeaders = false; |
| private String mMyEncoding = null; |
| |
| private String getBoundary() { |
| // Include "=_" as these cannot occur in quoted printable text |
| if (mBoundary == null) { |
| mBoundary = "--=_" + UUID.randomUUID(); |
| } |
| return mBoundary; |
| } |
| |
| /** |
| * @return the parts |
| */ |
| public ArrayList<MimePart> getMimeParts() { |
| return mParts; |
| } |
| |
| public String getMessageAsText() { |
| StringBuilder sb = new StringBuilder(); |
| if (mSubject != null && !mSubject.isEmpty()) { |
| sb.append("<Sub:").append(mSubject).append("> "); |
| } |
| if (mParts != null) { |
| for (MimePart part : mParts) { |
| if (part.mContentType.toUpperCase().contains("TEXT")) { |
| sb.append(new String(part.mData)); |
| } |
| } |
| } |
| return sb.toString(); |
| } |
| |
| public MimePart addMimePart() { |
| if (mParts == null) { |
| mParts = new ArrayList<BluetoothMapbMessageMime.MimePart>(); |
| } |
| MimePart newPart = new MimePart(); |
| mParts.add(newPart); |
| return newPart; |
| } |
| |
| public String getDateString() { |
| SimpleDateFormat format = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss Z", Locale.US); |
| Date dateObj = new Date(mDate); |
| return format.format(dateObj); // Format according to RFC 2822 page 14 |
| } |
| |
| public long getDate() { |
| return mDate; |
| } |
| |
| public void setDate(long date) { |
| this.mDate = date; |
| } |
| |
| public String getSubject() { |
| return mSubject; |
| } |
| |
| public void setSubject(String subject) { |
| this.mSubject = subject; |
| } |
| |
| public ArrayList<Rfc822Token> getFrom() { |
| return mFrom; |
| } |
| |
| public void setFrom(ArrayList<Rfc822Token> from) { |
| this.mFrom = from; |
| } |
| |
| public void addFrom(String name, String address) { |
| if (this.mFrom == null) { |
| this.mFrom = new ArrayList<Rfc822Token>(1); |
| } |
| this.mFrom.add(new Rfc822Token(name, address, null)); |
| } |
| |
| public ArrayList<Rfc822Token> getSender() { |
| return mSender; |
| } |
| |
| public void setSender(ArrayList<Rfc822Token> sender) { |
| this.mSender = sender; |
| } |
| |
| public void addSender(String name, String address) { |
| if (this.mSender == null) { |
| this.mSender = new ArrayList<Rfc822Token>(1); |
| } |
| this.mSender.add(new Rfc822Token(name, address, null)); |
| } |
| |
| public ArrayList<Rfc822Token> getTo() { |
| return mTo; |
| } |
| |
| public void setTo(ArrayList<Rfc822Token> to) { |
| this.mTo = to; |
| } |
| |
| public void addTo(String name, String address) { |
| if (this.mTo == null) { |
| this.mTo = new ArrayList<Rfc822Token>(1); |
| } |
| this.mTo.add(new Rfc822Token(name, address, null)); |
| } |
| |
| public ArrayList<Rfc822Token> getCc() { |
| return mCc; |
| } |
| |
| public void setCc(ArrayList<Rfc822Token> cc) { |
| this.mCc = cc; |
| } |
| |
| public void addCc(String name, String address) { |
| if (this.mCc == null) { |
| this.mCc = new ArrayList<Rfc822Token>(1); |
| } |
| this.mCc.add(new Rfc822Token(name, address, null)); |
| } |
| |
| public ArrayList<Rfc822Token> getBcc() { |
| return mBcc; |
| } |
| |
| public void setBcc(ArrayList<Rfc822Token> bcc) { |
| this.mBcc = bcc; |
| } |
| |
| public void addBcc(String name, String address) { |
| if (this.mBcc == null) { |
| this.mBcc = new ArrayList<Rfc822Token>(1); |
| } |
| this.mBcc.add(new Rfc822Token(name, address, null)); |
| } |
| |
| public ArrayList<Rfc822Token> getReplyTo() { |
| return mReplyTo; |
| } |
| |
| public void setReplyTo(ArrayList<Rfc822Token> replyTo) { |
| this.mReplyTo = replyTo; |
| } |
| |
| public void addReplyTo(String name, String address) { |
| if (this.mReplyTo == null) { |
| this.mReplyTo = new ArrayList<Rfc822Token>(1); |
| } |
| this.mReplyTo.add(new Rfc822Token(name, address, null)); |
| } |
| |
| public void setMessageId(String messageId) { |
| this.mMessageId = messageId; |
| } |
| |
| public String getMessageId() { |
| return mMessageId; |
| } |
| |
| public void setContentType(String contentType) { |
| this.mContentType = contentType; |
| } |
| |
| public String getContentType() { |
| return mContentType; |
| } |
| |
| public void setTextOnly(boolean textOnly) { |
| this.mTextonly = textOnly; |
| } |
| |
| public boolean getTextOnly() { |
| return mTextonly; |
| } |
| |
| public void setIncludeAttachments(boolean includeAttachments) { |
| this.mIncludeAttachments = includeAttachments; |
| } |
| |
| public boolean getIncludeAttachments() { |
| return mIncludeAttachments; |
| } |
| |
| public void updateCharset() { |
| if (mParts != null) { |
| mCharset = null; |
| for (MimePart part : mParts) { |
| if (part.mContentType != null && part.mContentType.toUpperCase().contains("TEXT")) { |
| mCharset = "UTF-8"; |
| if (V) { |
| Log.v(TAG, "Charset set to UTF-8"); |
| } |
| break; |
| } |
| } |
| } |
| } |
| |
| public int getSize() { |
| int messageSize = 0; |
| if (mParts != null) { |
| for (MimePart part : mParts) { |
| messageSize += part.mData.length; |
| } |
| } |
| return messageSize; |
| } |
| |
| /** |
| * Encode an address header, and perform folding if needed. |
| * @param sb The stringBuilder to write to |
| * @param headerName The RFC 2822 header name |
| * @param addresses the reformatted address substrings to encode. |
| */ |
| public void encodeHeaderAddresses(StringBuilder sb, String headerName, |
| ArrayList<Rfc822Token> addresses) { |
| /* TODO: Do we need to encode the addresses if they contain illegal characters? |
| * This depends of the outcome of errata 4176. The current spec. states to use UTF-8 |
| * where possible, but the RFCs states to use US-ASCII for the headers - hence encoding |
| * would be needed to support non US-ASCII characters. But the MAP spec states not to |
| * use any encoding... */ |
| int partLength, lineLength = 0; |
| lineLength += headerName.getBytes().length; |
| sb.append(headerName); |
| for (Rfc822Token address : addresses) { |
| partLength = address.toString().getBytes().length + 1; |
| // Add folding if needed |
| if (lineLength + partLength >= 998 /* max line length in RFC2822 */) { |
| sb.append("\r\n "); // Append a FWS (folding whitespace) |
| lineLength = 0; |
| } |
| sb.append(address.toString()).append(";"); |
| lineLength += partLength; |
| } |
| sb.append("\r\n"); |
| } |
| |
| public void encodeHeaders(StringBuilder sb) throws UnsupportedEncodingException { |
| /* TODO: From RFC-4356 - about the RFC-(2)822 headers: |
| * "Current Internet Message format requires that only 7-bit US-ASCII |
| * characters be present in headers. Non-7-bit characters in an address |
| * domain must be encoded with [IDN]. If there are any non-7-bit |
| * characters in the local part of an address, the message MUST be |
| * rejected. Non-7-bit characters elsewhere in a header MUST be encoded |
| * according to [Hdr-Enc]." |
| * We need to add the address encoding in encodeHeaderAddresses, but it is not |
| * straight forward, as it is unclear how to do this. */ |
| if (mDate != INVALID_VALUE) { |
| sb.append("Date: ").append(getDateString()).append("\r\n"); |
| } |
| /* According to RFC-2822 headers must use US-ASCII, where the MAP specification states |
| * UTF-8 should be used for the entire <bmessage-body-content>. We let the MAP specification |
| * take precedence above the RFC-2822. |
| */ |
| /* If we are to use US-ASCII anyway, here is the code for it for base64. |
| if (subject != null){ |
| // Use base64 encoding for the subject, as it may contain non US-ASCII characters or |
| // other illegal (RFC822 header), and android do not seem to have encoders/decoders |
| // for quoted-printables |
| sb.append("Subject:").append("=?utf-8?B?"); |
| sb.append(Base64.encodeToString(subject.getBytes("utf-8"), Base64.DEFAULT)); |
| sb.append("?=\r\n"); |
| }*/ |
| if (mSubject != null) { |
| sb.append("Subject: ").append(mSubject).append("\r\n"); |
| } |
| if (mFrom == null) { |
| sb.append("From: \r\n"); |
| } |
| if (mFrom != null) { |
| encodeHeaderAddresses(sb, "From: ", mFrom); // This includes folding if needed. |
| } |
| if (mSender != null) { |
| encodeHeaderAddresses(sb, "Sender: ", mSender); // This includes folding if needed. |
| } |
| /* For MMS one recipient(to, cc or bcc) must exists, if none: 'To: undisclosed- |
| * recipients:;' could be used. |
| */ |
| if (mTo == null && mCc == null && mBcc == null) { |
| sb.append("To: undisclosed-recipients:;\r\n"); |
| } |
| if (mTo != null) { |
| encodeHeaderAddresses(sb, "To: ", mTo); // This includes folding if needed. |
| } |
| if (mCc != null) { |
| encodeHeaderAddresses(sb, "Cc: ", mCc); // This includes folding if needed. |
| } |
| if (mBcc != null) { |
| encodeHeaderAddresses(sb, "Bcc: ", mBcc); // This includes folding if needed. |
| } |
| if (mReplyTo != null) { |
| encodeHeaderAddresses(sb, "Reply-To: ", mReplyTo); // This includes folding if needed. |
| } |
| if (mIncludeAttachments) { |
| if (mMessageId != null) { |
| sb.append("Message-Id: ").append(mMessageId).append("\r\n"); |
| } |
| if (mContentType != null) { |
| sb.append("Content-Type: ") |
| .append(mContentType) |
| .append("; boundary=") |
| .append(getBoundary()) |
| .append("\r\n"); |
| } |
| } |
| // If no headers exists, we still need two CRLF, hence keep it out of the if above. |
| sb.append("\r\n"); |
| } |
| |
| /* Notes on MMS |
| * ------------ |
| * According to rfc4356 all headers of a MMS converted to an E-mail must use |
| * 7-bit encoding. According the the MAP specification only 8-bit encoding is |
| * allowed - hence the bMessage-body should contain no SMTP headers. (Which makes |
| * sense, since the info is already present in the bMessage properties.) |
| * The result is that no information from RFC4356 is needed, since it does not |
| * describe any mapping between MMS content and E-mail content. |
| * Suggestion: |
| * Clearly state in the MAP specification that |
| * only the actual message content should be included in the <bmessage-body-content>. |
| * Correct the Example to not include the E-mail headers, and in stead show how to |
| * include a picture or another binary attachment. |
| * |
| * If the headers should be included, clearly state which, as the example clearly shows |
| * that some of the headers should be excluded. |
| * Additionally it is not clear how to handle attachments. There is a parameter in the |
| * get message to include attachments, but since only 8-bit encoding is allowed, |
| * (hence neither base64 nor binary) there is no mechanism to embed the attachment in |
| * the <bmessage-body-content>. |
| * |
| * UPDATE: Errata 4176 allows the needed encoding typed inside the <bmessage-body-content> |
| * including Base64 and Quoted Printables - hence it is possible to encode non-us-ascii |
| * messages - e.g. pictures and utf-8 strings with non-us-ascii content. |
| * It have not yet been adopted, but since the comments clearly suggest that it is allowed |
| * to use encoding schemes for non-text parts, it is still not clear what to do about non |
| * US-ASCII text in the headers. |
| * */ |
| |
| /** |
| * Encode the bMessage as a Mime message(MMS/IM) |
| * @return |
| * @throws UnsupportedEncodingException |
| */ |
| public byte[] encodeMime() throws UnsupportedEncodingException { |
| ArrayList<byte[]> bodyFragments = new ArrayList<byte[]>(); |
| StringBuilder sb = new StringBuilder(); |
| int count = 0; |
| String mimeBody; |
| |
| mEncoding = "8BIT"; // The encoding used |
| |
| encodeHeaders(sb); |
| if (mParts != null) { |
| if (!getIncludeAttachments()) { |
| for (MimePart part : mParts) { |
| /* We call encode on all parts, to include a tag, |
| * where an attachment is missing. */ |
| part.encodePlainText(sb); |
| } |
| } else { |
| for (MimePart part : mParts) { |
| count++; |
| part.encode(sb, getBoundary(), (count == mParts.size())); |
| } |
| } |
| } |
| |
| mimeBody = sb.toString(); |
| |
| if (mimeBody != null) { |
| // Replace any occurrences of END:MSG with \END:MSG |
| String tmpBody = mimeBody.replaceAll("END:MSG", "/END\\:MSG"); |
| bodyFragments.add(tmpBody.getBytes("UTF-8")); |
| } else { |
| bodyFragments.add(new byte[0]); |
| } |
| |
| return encodeGeneric(bodyFragments); |
| } |
| |
| |
| /** |
| * Try to parse the hdrPart string as e-mail headers. |
| * @param hdrPart The string to parse. |
| * @return Null if the entire string were e-mail headers. The part of the string in which |
| * no headers were found. |
| */ |
| private String parseMimeHeaders(String hdrPart) { |
| String[] headers = hdrPart.split("\r\n"); |
| if (D) { |
| Log.d(TAG, "Header count=" + headers.length); |
| } |
| String header; |
| mHasHeaders = false; |
| |
| for (int i = 0, c = headers.length; i < c; i++) { |
| header = headers[i]; |
| if (D) { |
| Log.d(TAG, "Header[" + i + "]: " + header); |
| } |
| /* We need to figure out if any headers are present, in cases where devices do |
| * not follow the e-mail RFCs. |
| * Skip empty lines, and then parse headers until a non-header line is found, |
| * at which point we treat the remaining as plain text. |
| */ |
| if (header.trim().isEmpty()) { |
| continue; |
| } |
| String[] headerParts = header.split(":", 2); |
| if (headerParts.length != 2) { |
| // We treat the remaining content as plain text. |
| StringBuilder remaining = new StringBuilder(); |
| for (; i < c; i++) { |
| remaining.append(headers[i]); |
| } |
| |
| return remaining.toString(); |
| } |
| |
| String headerType = headerParts[0].toUpperCase(); |
| String headerValue = headerParts[1].trim(); |
| |
| // Address headers |
| /* If this is empty, the MSE needs to fill it in before sending the message. |
| * This happens when sending the MMS. |
| */ |
| if (headerType.contains("FROM")) { |
| headerValue = BluetoothMapUtils.stripEncoding(headerValue); |
| Rfc822Token[] tokens = Rfc822Tokenizer.tokenize(headerValue); |
| mFrom = new ArrayList<Rfc822Token>(Arrays.asList(tokens)); |
| } else if (headerType.contains("TO")) { |
| headerValue = BluetoothMapUtils.stripEncoding(headerValue); |
| Rfc822Token[] tokens = Rfc822Tokenizer.tokenize(headerValue); |
| mTo = new ArrayList<Rfc822Token>(Arrays.asList(tokens)); |
| } else if (headerType.contains("CC")) { |
| headerValue = BluetoothMapUtils.stripEncoding(headerValue); |
| Rfc822Token[] tokens = Rfc822Tokenizer.tokenize(headerValue); |
| mCc = new ArrayList<Rfc822Token>(Arrays.asList(tokens)); |
| } else if (headerType.contains("BCC")) { |
| headerValue = BluetoothMapUtils.stripEncoding(headerValue); |
| Rfc822Token[] tokens = Rfc822Tokenizer.tokenize(headerValue); |
| mBcc = new ArrayList<Rfc822Token>(Arrays.asList(tokens)); |
| } else if (headerType.contains("REPLY-TO")) { |
| headerValue = BluetoothMapUtils.stripEncoding(headerValue); |
| Rfc822Token[] tokens = Rfc822Tokenizer.tokenize(headerValue); |
| mReplyTo = new ArrayList<Rfc822Token>(Arrays.asList(tokens)); |
| } else if (headerType.contains("SUBJECT")) { // Other headers |
| mSubject = BluetoothMapUtils.stripEncoding(headerValue); |
| } else if (headerType.contains("MESSAGE-ID")) { |
| mMessageId = headerValue; |
| } else if (headerType.contains("DATE")) { |
| /* The date is not needed, as the time stamp will be set in the DB |
| * when the message is send. */ |
| } else if (headerType.contains("MIME-VERSION")) { |
| /* The mime version is not needed */ |
| } else if (headerType.contains("CONTENT-TYPE")) { |
| String[] contentTypeParts = headerValue.split(";"); |
| mContentType = contentTypeParts[0]; |
| // Extract the boundary if it exists |
| for (int j = 1, n = contentTypeParts.length; j < n; j++) { |
| if (contentTypeParts[j].contains("boundary")) { |
| mBoundary = contentTypeParts[j].split("boundary[\\s]*=", 2)[1].trim(); |
| // removing quotes from boundary string |
| if ((mBoundary.charAt(0) == '\"') && ( |
| mBoundary.charAt(mBoundary.length() - 1) == '\"')) { |
| mBoundary = mBoundary.substring(1, mBoundary.length() - 1); |
| } |
| if (D) { |
| Log.d(TAG, "Boundary tag=" + mBoundary); |
| } |
| } else if (contentTypeParts[j].contains("charset")) { |
| mCharset = contentTypeParts[j].split("charset[\\s]*=", 2)[1].trim(); |
| } |
| } |
| } else if (headerType.contains("CONTENT-TRANSFER-ENCODING")) { |
| mMyEncoding = headerValue; |
| } else { |
| if (D) { |
| Log.w(TAG, "Skipping unknown header: " + headerType + " (" + header + ")"); |
| } |
| } |
| } |
| return null; |
| } |
| |
| private void parseMimePart(String partStr) { |
| String[] parts = partStr.split("\r\n\r\n", 2); // Split the header from the body |
| MimePart newPart = addMimePart(); |
| String partEncoding = mMyEncoding; /* Use the overall encoding as default */ |
| String body; |
| |
| String[] headers = parts[0].split("\r\n"); |
| if (D) { |
| Log.d(TAG, "parseMimePart: headers count=" + headers.length); |
| } |
| |
| if (parts.length != 2) { |
| body = partStr; |
| } else { |
| for (String header : headers) { |
| // Skip empty lines(the \r\n after the boundary tag) and endBoundary tags |
| if ((header.length() == 0) || (header.trim().isEmpty()) || header.trim() |
| .equals("--")) { |
| continue; |
| } |
| |
| String[] headerParts = header.split(":", 2); |
| if (headerParts.length != 2) { |
| if (D) { |
| Log.w(TAG, "part-Header not formatted correctly: "); |
| } |
| continue; |
| } |
| if (D) { |
| Log.d(TAG, "parseMimePart: header=" + header); |
| } |
| String headerType = headerParts[0].toUpperCase(); |
| String headerValue = headerParts[1].trim(); |
| if (headerType.contains("CONTENT-TYPE")) { |
| String[] contentTypeParts = headerValue.split(";"); |
| newPart.mContentType = contentTypeParts[0]; |
| // Extract the boundary if it exists |
| for (int j = 1, n = contentTypeParts.length; j < n; j++) { |
| String value = contentTypeParts[j].toLowerCase(); |
| if (value.contains("charset")) { |
| newPart.mCharsetName = value.split("charset[\\s]*=", 2)[1].trim(); |
| } |
| } |
| } else if (headerType.contains("CONTENT-LOCATION")) { |
| // This is used if the smil refers to a file name in its src |
| newPart.mContentLocation = headerValue; |
| newPart.mPartName = headerValue; |
| } else if (headerType.contains("CONTENT-TRANSFER-ENCODING")) { |
| partEncoding = headerValue; |
| } else if (headerType.contains("CONTENT-ID")) { |
| // This is used if the smil refers to a cid:<xxx> in it's src |
| newPart.mContentId = headerValue; |
| } else if (headerType.contains("CONTENT-DISPOSITION")) { |
| // This is used if the smil refers to a cid:<xxx> in it's src |
| newPart.mContentDisposition = headerValue; |
| } else { |
| if (D) { |
| Log.w(TAG, "Skipping unknown part-header: " + headerType + " (" + header |
| + ")"); |
| } |
| } |
| } |
| body = parts[1]; |
| if (body.length() > 2) { |
| if (body.charAt(body.length() - 2) == '\r' |
| && body.charAt(body.length() - 2) == '\n') { |
| body = body.substring(0, body.length() - 2); |
| } |
| } |
| } |
| // Now for the body |
| newPart.mData = decodeBody(body, partEncoding, newPart.mCharsetName); |
| } |
| |
| private void parseMimeBody(String body) { |
| MimePart newPart = addMimePart(); |
| newPart.mCharsetName = mCharset; |
| newPart.mData = decodeBody(body, mMyEncoding, mCharset); |
| } |
| |
| private byte[] decodeBody(String body, String encoding, String charset) { |
| if (encoding != null && encoding.toUpperCase().contains("BASE64")) { |
| return Base64.decode(body, Base64.DEFAULT); |
| } else if (encoding != null && encoding.toUpperCase().contains("QUOTED-PRINTABLE")) { |
| return BluetoothMapUtils.quotedPrintableToUtf8(body, charset); |
| } else { |
| // TODO: handle other encoding types? - here we simply store the string data as bytes |
| try { |
| |
| return body.getBytes("UTF-8"); |
| } catch (UnsupportedEncodingException e) { |
| // This will never happen, as UTF-8 is mandatory on Android platforms |
| } |
| } |
| return null; |
| } |
| |
| private void parseMime(String message) { |
| // Check for null String, otherwise NPE will cause BT to crash |
| if (message == null) { |
| Log.e(TAG, "parseMime called with a NULL message, terminating early"); |
| return; |
| } |
| |
| /* Overall strategy for decoding: |
| * 1) split on first empty line to extract the header |
| * 2) unfold and parse headers |
| * 3) split on boundary to split into parts (or use the remaining as a part, |
| * if part is not found) |
| * 4) parse each part |
| * */ |
| String[] messageParts; |
| String[] mimeParts; |
| String remaining = null; |
| String messageBody = null; |
| |
| message = message.replaceAll("\\r\\n[ \\\t]+", ""); // Unfold |
| messageParts = message.split("\r\n\r\n", 2); // Split the header from the body |
| if (messageParts.length != 2) { |
| // Handle entire message as plain text |
| messageBody = message; |
| } else { |
| remaining = parseMimeHeaders(messageParts[0]); |
| // If we have some text not being a header, add it to the message body. |
| if (remaining != null) { |
| messageBody = remaining + messageParts[1]; |
| if (D) { |
| Log.d(TAG, "parseMime remaining=" + remaining); |
| } |
| } else { |
| messageBody = messageParts[1]; |
| } |
| } |
| |
| if (mBoundary == null) { |
| // If the boundary is not set, handle as non-multi-part |
| parseMimeBody(messageBody); |
| setTextOnly(true); |
| if (mContentType == null) { |
| mContentType = "text/plain"; |
| } |
| mParts.get(0).mContentType = mContentType; |
| } else { |
| mimeParts = messageBody.split("--" + mBoundary); |
| if (D) { |
| Log.d(TAG, "mimePart count=" + mimeParts.length); |
| } |
| // Part 0 is the message to clients not capable of decoding MIME |
| for (int i = 1; i < mimeParts.length - 1; i++) { |
| String part = mimeParts[i]; |
| if (part != null && (part.length() > 0)) { |
| parseMimePart(part); |
| } |
| } |
| } |
| } |
| |
| /* Notes on SMIL decoding (from http://tools.ietf.org/html/rfc2557): |
| * src="filename.jpg" refers to a part with Content-Location: filename.jpg |
| * src="cid:1234@hest.net" refers to a part with Content-ID:<1234@hest.net>*/ |
| @Override |
| public void parseMsgPart(String msgPart) { |
| parseMime(msgPart); |
| |
| } |
| |
| @Override |
| public void parseMsgInit() { |
| // Not used for e-mail |
| |
| } |
| |
| @Override |
| public byte[] encode() throws UnsupportedEncodingException { |
| return encodeMime(); |
| } |
| |
| } |
