2009-08-11 22:02:57 +00:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2009 The Android Open Source Project
|
|
|
|
*
|
|
|
|
* 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.email;
|
|
|
|
|
|
|
|
import com.android.email.mail.Address;
|
2009-08-26 05:45:11 +00:00
|
|
|
import com.android.email.mail.Flag;
|
2009-08-11 22:02:57 +00:00
|
|
|
import com.android.email.mail.Message;
|
|
|
|
import com.android.email.mail.MessagingException;
|
|
|
|
import com.android.email.mail.Part;
|
2009-09-25 21:54:32 +00:00
|
|
|
import com.android.email.mail.Message.RecipientType;
|
|
|
|
import com.android.email.mail.internet.MimeBodyPart;
|
2009-08-11 22:02:57 +00:00
|
|
|
import com.android.email.mail.internet.MimeHeader;
|
2009-09-25 21:54:32 +00:00
|
|
|
import com.android.email.mail.internet.MimeMessage;
|
|
|
|
import com.android.email.mail.internet.MimeMultipart;
|
2009-08-11 22:02:57 +00:00
|
|
|
import com.android.email.mail.internet.MimeUtility;
|
2009-09-25 21:54:32 +00:00
|
|
|
import com.android.email.mail.internet.TextBody;
|
2009-08-11 22:02:57 +00:00
|
|
|
import com.android.email.provider.AttachmentProvider;
|
|
|
|
import com.android.email.provider.EmailContent;
|
|
|
|
import com.android.email.provider.EmailContent.Attachment;
|
|
|
|
import com.android.email.provider.EmailContent.AttachmentColumns;
|
|
|
|
|
|
|
|
import org.apache.commons.io.IOUtils;
|
|
|
|
|
|
|
|
import android.content.ContentUris;
|
|
|
|
import android.content.ContentValues;
|
|
|
|
import android.content.Context;
|
|
|
|
import android.net.Uri;
|
2009-09-25 21:54:32 +00:00
|
|
|
import android.util.Log;
|
2009-08-11 22:02:57 +00:00
|
|
|
|
|
|
|
import java.io.File;
|
|
|
|
import java.io.FileOutputStream;
|
|
|
|
import java.io.IOException;
|
|
|
|
import java.io.InputStream;
|
|
|
|
import java.util.ArrayList;
|
|
|
|
import java.util.Date;
|
|
|
|
|
|
|
|
public class LegacyConversions {
|
|
|
|
|
2009-09-25 21:54:32 +00:00
|
|
|
/**
|
|
|
|
* Values for HEADER_ANDROID_BODY_QUOTED_PART to tag body parts
|
|
|
|
*/
|
|
|
|
/* package */ static final String BODY_QUOTED_PART_REPLY = "quoted-reply";
|
|
|
|
/* package */ static final String BODY_QUOTED_PART_FORWARD = "quoted-forward";
|
|
|
|
/* package */ static final String BODY_QUOTED_PART_INTRO = "quoted-intro";
|
|
|
|
|
2009-08-11 22:02:57 +00:00
|
|
|
/**
|
|
|
|
* Copy field-by-field from a "store" message to a "provider" message
|
2009-09-25 21:54:32 +00:00
|
|
|
* @param message The message we've just downloaded (must be a MimeMessage)
|
2009-08-11 22:02:57 +00:00
|
|
|
* @param localMessage The message we'd like to write into the DB
|
|
|
|
* @result true if dirty (changes were made)
|
|
|
|
*/
|
|
|
|
public static boolean updateMessageFields(EmailContent.Message localMessage, Message message,
|
|
|
|
long accountId, long mailboxId) throws MessagingException {
|
|
|
|
|
|
|
|
Address[] from = message.getFrom();
|
|
|
|
Address[] to = message.getRecipients(Message.RecipientType.TO);
|
|
|
|
Address[] cc = message.getRecipients(Message.RecipientType.CC);
|
|
|
|
Address[] bcc = message.getRecipients(Message.RecipientType.BCC);
|
|
|
|
Address[] replyTo = message.getReplyTo();
|
|
|
|
String subject = message.getSubject();
|
|
|
|
Date sentDate = message.getSentDate();
|
2009-09-23 01:31:10 +00:00
|
|
|
Date internalDate = message.getInternalDate();
|
2009-08-11 22:02:57 +00:00
|
|
|
|
|
|
|
if (from != null && from.length > 0) {
|
|
|
|
localMessage.mDisplayName = from[0].toFriendly();
|
|
|
|
}
|
|
|
|
if (sentDate != null) {
|
|
|
|
localMessage.mTimeStamp = sentDate.getTime();
|
|
|
|
}
|
|
|
|
if (subject != null) {
|
|
|
|
localMessage.mSubject = subject;
|
|
|
|
}
|
2009-08-26 05:45:11 +00:00
|
|
|
localMessage.mFlagRead = message.isSet(Flag.SEEN);
|
2009-08-11 22:02:57 +00:00
|
|
|
|
|
|
|
// Keep the message in the "unloaded" state until it has (at least) a display name.
|
|
|
|
// This prevents early flickering of empty messages in POP download.
|
2009-09-10 18:52:36 +00:00
|
|
|
if (localMessage.mFlagLoaded != EmailContent.Message.FLAG_LOADED_COMPLETE) {
|
2009-08-11 22:02:57 +00:00
|
|
|
if (localMessage.mDisplayName == null || "".equals(localMessage.mDisplayName)) {
|
2009-09-10 18:52:36 +00:00
|
|
|
localMessage.mFlagLoaded = EmailContent.Message.FLAG_LOADED_UNLOADED;
|
2009-08-11 22:02:57 +00:00
|
|
|
} else {
|
2009-09-10 18:52:36 +00:00
|
|
|
localMessage.mFlagLoaded = EmailContent.Message.FLAG_LOADED_PARTIAL;
|
2009-08-11 22:02:57 +00:00
|
|
|
}
|
|
|
|
}
|
2009-08-26 05:45:11 +00:00
|
|
|
localMessage.mFlagFavorite = message.isSet(Flag.FLAGGED);
|
2009-08-11 22:02:57 +00:00
|
|
|
// public boolean mFlagAttachment = false;
|
|
|
|
// public int mFlags = 0;
|
2009-09-02 06:19:12 +00:00
|
|
|
|
2009-08-11 22:02:57 +00:00
|
|
|
localMessage.mServerId = message.getUid();
|
2009-09-23 01:31:10 +00:00
|
|
|
if (internalDate != null) {
|
|
|
|
localMessage.mServerTimeStamp = internalDate.getTime();
|
|
|
|
}
|
2009-08-11 22:02:57 +00:00
|
|
|
// public String mClientId;
|
2009-10-06 21:20:09 +00:00
|
|
|
|
|
|
|
// Absorb a MessagingException here in the case of messages that were delivered without
|
|
|
|
// a proper message-id. This is seen in some ISP's but it is non-fatal -- (we'll just use
|
|
|
|
// the locally-generated message-id.)
|
|
|
|
try {
|
|
|
|
localMessage.mMessageId = ((MimeMessage)message).getMessageId();
|
|
|
|
} catch (MessagingException me) {
|
|
|
|
if (Email.DEBUG) {
|
|
|
|
Log.d(Email.LOG_TAG, "Missing message-id for UID=" + localMessage.mServerId);
|
|
|
|
}
|
|
|
|
}
|
2009-09-02 06:19:12 +00:00
|
|
|
|
2009-08-11 22:02:57 +00:00
|
|
|
// public long mBodyKey;
|
|
|
|
localMessage.mMailboxKey = mailboxId;
|
|
|
|
localMessage.mAccountKey = accountId;
|
2009-09-02 06:19:12 +00:00
|
|
|
|
2009-08-11 22:02:57 +00:00
|
|
|
if (from != null && from.length > 0) {
|
|
|
|
localMessage.mFrom = Address.pack(from);
|
|
|
|
}
|
|
|
|
|
|
|
|
localMessage.mTo = Address.pack(to);
|
|
|
|
localMessage.mCc = Address.pack(cc);
|
|
|
|
localMessage.mBcc = Address.pack(bcc);
|
|
|
|
localMessage.mReplyTo = Address.pack(replyTo);
|
|
|
|
|
|
|
|
// public String mText;
|
|
|
|
// public String mHtml;
|
2009-09-02 06:19:12 +00:00
|
|
|
// public String mTextReply;
|
|
|
|
// public String mHtmlReply;
|
|
|
|
|
2009-08-11 22:02:57 +00:00
|
|
|
// // Can be used while building messages, but is NOT saved by the Provider
|
|
|
|
// transient public ArrayList<Attachment> mAttachments = null;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Copy body text (plain and/or HTML) from MimeMessage to provider Message
|
|
|
|
*/
|
|
|
|
public static boolean updateBodyFields(EmailContent.Body body,
|
|
|
|
EmailContent.Message localMessage, ArrayList<Part> viewables)
|
|
|
|
throws MessagingException {
|
|
|
|
|
|
|
|
body.mMessageKey = localMessage.mId;
|
|
|
|
|
2009-09-25 21:54:32 +00:00
|
|
|
StringBuffer sbHtml = null;
|
|
|
|
StringBuffer sbText = null;
|
|
|
|
StringBuffer sbHtmlReply = null;
|
|
|
|
StringBuffer sbTextReply = null;
|
|
|
|
StringBuffer sbIntroText = null;
|
|
|
|
|
2009-08-11 22:02:57 +00:00
|
|
|
for (Part viewable : viewables) {
|
|
|
|
String text = MimeUtility.getTextFromPart(viewable);
|
2009-09-25 21:54:32 +00:00
|
|
|
String[] replyTags = viewable.getHeader(MimeHeader.HEADER_ANDROID_BODY_QUOTED_PART);
|
|
|
|
String replyTag = null;
|
|
|
|
if (replyTags != null && replyTags.length > 0) {
|
|
|
|
replyTag = replyTags[0];
|
|
|
|
}
|
|
|
|
// Deploy text as marked by the various tags
|
|
|
|
boolean isHtml = "text/html".equalsIgnoreCase(viewable.getMimeType());
|
|
|
|
|
|
|
|
if (replyTag != null) {
|
|
|
|
boolean isQuotedReply = BODY_QUOTED_PART_REPLY.equalsIgnoreCase(replyTag);
|
|
|
|
boolean isQuotedForward = BODY_QUOTED_PART_FORWARD.equalsIgnoreCase(replyTag);
|
|
|
|
boolean isQuotedIntro = BODY_QUOTED_PART_INTRO.equalsIgnoreCase(replyTag);
|
|
|
|
|
|
|
|
if (isQuotedReply || isQuotedForward) {
|
|
|
|
if (isHtml) {
|
|
|
|
sbHtmlReply = appendTextPart(sbHtmlReply, text);
|
|
|
|
} else {
|
|
|
|
sbTextReply = appendTextPart(sbTextReply, text);
|
|
|
|
}
|
|
|
|
// Set message flags as well
|
|
|
|
localMessage.mFlags &= ~EmailContent.Message.FLAG_TYPE_MASK;
|
|
|
|
localMessage.mFlags |= isQuotedReply
|
|
|
|
? EmailContent.Message.FLAG_TYPE_REPLY
|
|
|
|
: EmailContent.Message.FLAG_TYPE_FORWARD;
|
|
|
|
continue;
|
2009-08-11 22:02:57 +00:00
|
|
|
}
|
2009-09-25 21:54:32 +00:00
|
|
|
if (isQuotedIntro) {
|
|
|
|
sbIntroText = appendTextPart(sbIntroText, text);
|
|
|
|
continue;
|
2009-08-11 22:02:57 +00:00
|
|
|
}
|
2009-09-25 21:54:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Most of the time, just process regular body parts
|
|
|
|
if (isHtml) {
|
|
|
|
sbHtml = appendTextPart(sbHtml, text);
|
|
|
|
} else {
|
|
|
|
sbText = appendTextPart(sbText, text);
|
2009-08-11 22:02:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// write the combined data to the body part
|
2009-09-25 21:54:32 +00:00
|
|
|
if (sbText != null && sbText.length() != 0) {
|
2009-08-11 22:02:57 +00:00
|
|
|
body.mTextContent = sbText.toString();
|
|
|
|
}
|
2009-09-25 21:54:32 +00:00
|
|
|
if (sbHtml != null && sbHtml.length() != 0) {
|
2009-08-11 22:02:57 +00:00
|
|
|
body.mHtmlContent = sbHtml.toString();
|
|
|
|
}
|
2009-09-25 21:54:32 +00:00
|
|
|
if (sbHtmlReply != null && sbHtmlReply.length() != 0) {
|
|
|
|
body.mHtmlReply = sbHtmlReply.toString();
|
|
|
|
}
|
|
|
|
if (sbTextReply != null && sbTextReply.length() != 0) {
|
|
|
|
body.mTextReply = sbTextReply.toString();
|
|
|
|
}
|
|
|
|
if (sbIntroText != null && sbIntroText.length() != 0) {
|
|
|
|
body.mIntroText = sbIntroText.toString();
|
|
|
|
}
|
2009-08-11 22:02:57 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2009-09-25 21:54:32 +00:00
|
|
|
/**
|
|
|
|
* Helper function to append text to a StringBuffer, creating it if necessary.
|
|
|
|
* Optimization: The majority of the time we are *not* appending - we should have a path
|
|
|
|
* that deals with single strings.
|
|
|
|
*/
|
|
|
|
private static StringBuffer appendTextPart(StringBuffer sb, String newText) {
|
2009-10-07 18:42:27 +00:00
|
|
|
if (newText == null) {
|
|
|
|
return sb;
|
|
|
|
}
|
|
|
|
else if (sb == null) {
|
2009-09-25 21:54:32 +00:00
|
|
|
sb = new StringBuffer(newText);
|
|
|
|
} else {
|
|
|
|
if (sb.length() > 0) {
|
|
|
|
sb.append('\n');
|
|
|
|
}
|
|
|
|
sb.append(newText);
|
|
|
|
}
|
|
|
|
return sb;
|
|
|
|
}
|
|
|
|
|
2009-08-11 22:02:57 +00:00
|
|
|
/**
|
|
|
|
* Copy attachments from MimeMessage to provider Message.
|
|
|
|
*
|
|
|
|
* @param context a context for file operations
|
|
|
|
* @param localMessage the attachments will be built against this message
|
2009-09-02 06:19:12 +00:00
|
|
|
* @param attachments the attachments to add
|
2009-08-11 22:02:57 +00:00
|
|
|
* @throws IOException
|
|
|
|
*/
|
|
|
|
public static void updateAttachments(Context context, EmailContent.Message localMessage,
|
|
|
|
ArrayList<Part> attachments) throws MessagingException, IOException {
|
|
|
|
localMessage.mAttachments = null;
|
|
|
|
for (Part attachmentPart : attachments) {
|
|
|
|
addOneAttachment(context, localMessage, attachmentPart);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Add a single attachment part to the message
|
|
|
|
*
|
|
|
|
* TODO: This will simply add to any existing attachments - could this ever happen? If so,
|
|
|
|
* change it to find existing attachments and delete/merge them.
|
|
|
|
* TODO: Take a closer look at encoding and deal with it if necessary.
|
|
|
|
*
|
|
|
|
* @param context a context for file operations
|
|
|
|
* @param localMessage the attachments will be built against this message
|
|
|
|
* @param part a single attachment part from POP or IMAP
|
|
|
|
* @throws IOException
|
|
|
|
*/
|
|
|
|
private static void addOneAttachment(Context context, EmailContent.Message localMessage,
|
|
|
|
Part part) throws MessagingException, IOException {
|
|
|
|
|
|
|
|
Attachment localAttachment = new Attachment();
|
|
|
|
|
|
|
|
// Transfer fields from mime format to provider format
|
|
|
|
String contentType = MimeUtility.unfoldAndDecode(part.getContentType());
|
|
|
|
String name = MimeUtility.getHeaderParameter(contentType, "name");
|
|
|
|
if (name == null) {
|
|
|
|
String contentDisposition = MimeUtility.unfoldAndDecode(part.getContentType());
|
|
|
|
name = MimeUtility.getHeaderParameter(contentDisposition, "filename");
|
|
|
|
}
|
|
|
|
|
|
|
|
// Try to pull size from disposition (if not downloaded)
|
|
|
|
long size = 0;
|
|
|
|
String disposition = part.getDisposition();
|
|
|
|
if (disposition != null) {
|
|
|
|
String s = MimeUtility.getHeaderParameter(disposition, "size");
|
|
|
|
if (s != null) {
|
|
|
|
size = Long.parseLong(s);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Get partId for unloaded IMAP attachments (if any)
|
|
|
|
// This is only provided (and used) when we have structure but not the actual attachment
|
|
|
|
String[] partIds = part.getHeader(MimeHeader.HEADER_ANDROID_ATTACHMENT_STORE_DATA);
|
2009-09-02 06:19:12 +00:00
|
|
|
String partId = partIds != null ? partIds[0] : null;
|
2009-08-11 22:02:57 +00:00
|
|
|
|
|
|
|
localAttachment.mFileName = MimeUtility.getHeaderParameter(contentType, "name");
|
|
|
|
localAttachment.mMimeType = part.getMimeType();
|
|
|
|
localAttachment.mSize = size; // May be reset below if file handled
|
|
|
|
localAttachment.mContentId = part.getContentId();
|
|
|
|
localAttachment.mContentUri = null; // Will be set when file is saved
|
|
|
|
localAttachment.mMessageKey = localMessage.mId;
|
|
|
|
localAttachment.mLocation = partId;
|
|
|
|
localAttachment.mEncoding = "B"; // TODO - convert other known encodings
|
|
|
|
|
|
|
|
// Save the attachment (so far) in order to obtain an id
|
|
|
|
localAttachment.save(context);
|
|
|
|
|
|
|
|
// If an attachment body was actually provided, we need to write the file now
|
2009-08-19 20:15:13 +00:00
|
|
|
saveAttachmentBody(context, part, localAttachment, localMessage.mAccountKey);
|
|
|
|
|
|
|
|
if (localMessage.mAttachments == null) {
|
|
|
|
localMessage.mAttachments = new ArrayList<Attachment>();
|
|
|
|
}
|
|
|
|
localMessage.mAttachments.add(localAttachment);
|
|
|
|
localMessage.mFlagAttachment = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Save the body part of a single attachment, to a file in the attachments directory.
|
|
|
|
*/
|
|
|
|
public static void saveAttachmentBody(Context context, Part part, Attachment localAttachment,
|
|
|
|
long accountId) throws MessagingException, IOException {
|
2009-08-11 22:02:57 +00:00
|
|
|
if (part.getBody() != null) {
|
|
|
|
long attachmentId = localAttachment.mId;
|
|
|
|
|
|
|
|
InputStream in = part.getBody().getInputStream();
|
|
|
|
|
|
|
|
File saveIn = AttachmentProvider.getAttachmentDirectory(context, accountId);
|
|
|
|
if (!saveIn.exists()) {
|
|
|
|
saveIn.mkdirs();
|
|
|
|
}
|
|
|
|
File saveAs = AttachmentProvider.getAttachmentFilename(context, accountId,
|
|
|
|
attachmentId);
|
|
|
|
saveAs.createNewFile();
|
|
|
|
FileOutputStream out = new FileOutputStream(saveAs);
|
|
|
|
long copySize = IOUtils.copy(in, out);
|
|
|
|
in.close();
|
|
|
|
out.close();
|
|
|
|
|
|
|
|
// update the attachment with the extra information we now know
|
|
|
|
String contentUriString = AttachmentProvider.getAttachmentUri(
|
|
|
|
accountId, attachmentId).toString();
|
|
|
|
|
|
|
|
localAttachment.mSize = copySize;
|
|
|
|
localAttachment.mContentUri = contentUriString;
|
|
|
|
|
|
|
|
// update the attachment in the database as well
|
|
|
|
ContentValues cv = new ContentValues();
|
|
|
|
cv.put(AttachmentColumns.SIZE, copySize);
|
|
|
|
cv.put(AttachmentColumns.CONTENT_URI, contentUriString);
|
|
|
|
Uri uri = ContentUris.withAppendedId(Attachment.CONTENT_URI, attachmentId);
|
|
|
|
context.getContentResolver().update(uri, cv, null, null);
|
|
|
|
}
|
|
|
|
}
|
2009-08-19 20:15:13 +00:00
|
|
|
|
2009-09-25 21:54:32 +00:00
|
|
|
/**
|
|
|
|
* Read a complete Provider message into a legacy message (for IMAP upload). This
|
|
|
|
* is basically the equivalent of LocalFolder.getMessages() + LocalFolder.fetch().
|
|
|
|
*/
|
|
|
|
public static Message makeMessage(Context context, EmailContent.Message localMessage)
|
|
|
|
throws MessagingException {
|
|
|
|
MimeMessage message = new MimeMessage();
|
|
|
|
|
|
|
|
// LocalFolder.getMessages() equivalent: Copy message fields
|
|
|
|
message.setSubject(localMessage.mSubject == null ? "" : localMessage.mSubject);
|
|
|
|
Address[] from = Address.unpack(localMessage.mFrom);
|
|
|
|
if (from.length > 0) {
|
|
|
|
message.setFrom(from[0]);
|
|
|
|
}
|
|
|
|
message.setSentDate(new Date(localMessage.mTimeStamp));
|
|
|
|
message.setUid(localMessage.mServerId);
|
|
|
|
message.setFlag(Flag.DELETED,
|
|
|
|
localMessage.mFlagLoaded == EmailContent.Message.FLAG_LOADED_DELETED);
|
|
|
|
message.setFlag(Flag.SEEN, localMessage.mFlagRead);
|
|
|
|
message.setFlag(Flag.FLAGGED, localMessage.mFlagFavorite);
|
|
|
|
// message.setFlag(Flag.DRAFT, localMessage.mMailboxKey == draftMailboxKey);
|
|
|
|
message.setRecipients(RecipientType.TO, Address.unpack(localMessage.mTo));
|
|
|
|
message.setRecipients(RecipientType.CC, Address.unpack(localMessage.mCc));
|
|
|
|
message.setRecipients(RecipientType.BCC, Address.unpack(localMessage.mBcc));
|
|
|
|
message.setReplyTo(Address.unpack(localMessage.mReplyTo));
|
|
|
|
message.setInternalDate(new Date(localMessage.mServerTimeStamp));
|
|
|
|
message.setMessageId(localMessage.mMessageId);
|
|
|
|
|
|
|
|
// LocalFolder.fetch() equivalent: build body parts
|
|
|
|
message.setHeader(MimeHeader.HEADER_CONTENT_TYPE, "multipart/mixed");
|
|
|
|
MimeMultipart mp = new MimeMultipart();
|
|
|
|
mp.setSubType("mixed");
|
|
|
|
message.setBody(mp);
|
|
|
|
|
|
|
|
try {
|
|
|
|
addTextBodyPart(mp, "text/html", null,
|
|
|
|
EmailContent.Body.restoreBodyHtmlWithMessageId(context, localMessage.mId));
|
|
|
|
} catch (RuntimeException rte) {
|
|
|
|
Log.d(Email.LOG_TAG, "Exception while reading html body " + rte.toString());
|
|
|
|
}
|
|
|
|
|
|
|
|
try {
|
|
|
|
addTextBodyPart(mp, "text/plain", null,
|
|
|
|
EmailContent.Body.restoreBodyTextWithMessageId(context, localMessage.mId));
|
|
|
|
} catch (RuntimeException rte) {
|
|
|
|
Log.d(Email.LOG_TAG, "Exception while reading text body " + rte.toString());
|
|
|
|
}
|
|
|
|
|
|
|
|
boolean isReply = (localMessage.mFlags & EmailContent.Message.FLAG_TYPE_REPLY) != 0;
|
|
|
|
boolean isForward = (localMessage.mFlags & EmailContent.Message.FLAG_TYPE_FORWARD) != 0;
|
|
|
|
|
|
|
|
// If there is a quoted part (forwarding or reply), add the intro first, and then the
|
|
|
|
// rest of it. If it is opened in some other viewer, it will (hopefully) be displayed in
|
|
|
|
// the same order as we've just set up the blocks: composed text, intro, replied text
|
|
|
|
if (isReply || isForward) {
|
|
|
|
try {
|
|
|
|
addTextBodyPart(mp, "text/plain", BODY_QUOTED_PART_INTRO,
|
|
|
|
EmailContent.Body.restoreIntroTextWithMessageId(context, localMessage.mId));
|
|
|
|
} catch (RuntimeException rte) {
|
|
|
|
Log.d(Email.LOG_TAG, "Exception while reading text reply " + rte.toString());
|
|
|
|
}
|
|
|
|
|
|
|
|
String replyTag = isReply ? BODY_QUOTED_PART_REPLY : BODY_QUOTED_PART_FORWARD;
|
|
|
|
try {
|
|
|
|
addTextBodyPart(mp, "text/html", replyTag,
|
|
|
|
EmailContent.Body.restoreReplyHtmlWithMessageId(context, localMessage.mId));
|
|
|
|
} catch (RuntimeException rte) {
|
|
|
|
Log.d(Email.LOG_TAG, "Exception while reading html reply " + rte.toString());
|
|
|
|
}
|
|
|
|
|
|
|
|
try {
|
|
|
|
addTextBodyPart(mp, "text/plain", replyTag,
|
|
|
|
EmailContent.Body.restoreReplyTextWithMessageId(context, localMessage.mId));
|
|
|
|
} catch (RuntimeException rte) {
|
|
|
|
Log.d(Email.LOG_TAG, "Exception while reading text reply " + rte.toString());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Attachments
|
|
|
|
// TODO: Make sure we deal with these as structures and don't accidentally upload files
|
|
|
|
// Uri uri = ContentUris.withAppendedId(Attachment.MESSAGE_ID_URI, localMessage.mId);
|
|
|
|
// Cursor attachments = context.getContentResolver().query(uri, Attachment.CONTENT_PROJECTION,
|
|
|
|
// null, null, null);
|
|
|
|
// try {
|
|
|
|
//
|
|
|
|
// } finally {
|
|
|
|
// attachments.close();
|
|
|
|
// }
|
|
|
|
|
|
|
|
return message;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Helper method to add a body part for a given type of text, if found
|
|
|
|
*
|
|
|
|
* @param mp The text body part will be added to this multipart
|
|
|
|
* @param contentType The content-type of the text being added
|
|
|
|
* @param quotedPartTag If non-null, HEADER_ANDROID_BODY_QUOTED_PART will be set to this value
|
|
|
|
* @param partText The text to add. If null, nothing happens
|
|
|
|
*/
|
|
|
|
private static void addTextBodyPart(MimeMultipart mp, String contentType, String quotedPartTag,
|
|
|
|
String partText) throws MessagingException {
|
|
|
|
if (partText == null) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
TextBody body = new TextBody(partText);
|
|
|
|
MimeBodyPart bp = new MimeBodyPart(body, contentType);
|
|
|
|
if (quotedPartTag != null) {
|
|
|
|
bp.addHeader(MimeHeader.HEADER_ANDROID_BODY_QUOTED_PART, quotedPartTag);
|
|
|
|
}
|
|
|
|
mp.addBodyPart(bp);
|
|
|
|
}
|
2009-08-11 22:02:57 +00:00
|
|
|
}
|