uidMap = null;
if (folder.equals(account.getTrashFolderName()) || K9.FOLDER_NONE.equals(account.getTrashFolderName())) {
if (K9.DEBUG)
Log.d(K9.LOG_TAG, "Deleting messages in trash folder or trash set to -None-, not copying");
@@ -3527,7 +3714,7 @@ public class MessagingController implements Runnable {
if (K9.DEBUG)
Log.d(K9.LOG_TAG, "Deleting messages in normal folder, moving");
- localFolder.moveMessages(messages, localTrashFolder);
+ uidMap = localFolder.moveMessages(messages, localTrashFolder);
}
}
@@ -3560,7 +3747,7 @@ public class MessagingController implements Runnable {
if (folder.equals(account.getTrashFolderName())) {
queueSetFlag(account, folder, Boolean.toString(true), Flag.DELETED.toString(), uids);
} else {
- queueMoveOrCopy(account, folder, account.getTrashFolderName(), false, uids);
+ queueMoveOrCopy(account, folder, account.getTrashFolderName(), false, uids, uidMap);
}
processPendingCommands(account);
} else if (account.getDeletePolicy() == Account.DELETE_POLICY_MARK_AS_READ) {
@@ -3622,12 +3809,14 @@ public class MessagingController implements Runnable {
putBackground("emptyTrash", listener, new Runnable() {
@Override
public void run() {
- Folder localFolder = null;
+ LocalFolder localFolder = null;
try {
Store localStore = account.getLocalStore();
- localFolder = localStore.getFolder(account.getTrashFolderName());
+ localFolder = (LocalFolder) localStore.getFolder(account.getTrashFolderName());
localFolder.open(OpenMode.READ_WRITE);
localFolder.setFlags(new Flag[] { Flag.DELETED }, true);
+ localFolder.setUnreadMessageCount(0);
+ localFolder.setFlaggedMessageCount(0);
for (MessagingListener l : getListeners()) {
l.emptyTrashCompleted(account);
diff --git a/src/com/fsck/k9/controller/MessagingListener.java b/src/com/fsck/k9/controller/MessagingListener.java
index bdf35fa00..49ddbf4da 100644
--- a/src/com/fsck/k9/controller/MessagingListener.java
+++ b/src/com/fsck/k9/controller/MessagingListener.java
@@ -12,191 +12,154 @@ import com.fsck.k9.mail.Part;
import java.util.List;
/**
- * Defines the interface that MessagingController will use to callback to requesters. This class
- * is defined as non-abstract so that someone who wants to receive only a few messages can
- * do so without implementing the entire interface. It is highly recommended that users of
- * this interface use the @Override annotation in their implementations to avoid being caught by
+ * Defines the interface that {@link MessagingController} will use to callback to requesters.
+ *
+ *
+ * This class is defined as non-abstract so that someone who wants to receive only a few messages
+ * can do so without implementing the entire interface. It is highly recommended that users of this
+ * interface use the {@code @Override} annotation in their implementations to avoid being caught by
* changes in this class.
+ *
*/
public class MessagingListener {
public void searchStats(AccountStats stats) {}
- public void accountStatusChanged(BaseAccount account, AccountStats stats) {
- }
- public void accountSizeChanged(Account account, long oldSize, long newSize) {
- }
+ public void accountStatusChanged(BaseAccount account, AccountStats stats) {}
- public void listFoldersStarted(Account account) {
- }
+ public void accountSizeChanged(Account account, long oldSize, long newSize) {}
- public void listFolders(Account account, Folder[] folders) {
- }
- public void listFoldersFailed(Account account, String message) {
- }
+ public void listFoldersStarted(Account account) {}
- public void listFoldersFinished(Account account) {
- }
+ public void listFolders(Account account, Folder[] folders) {}
- public void listLocalMessagesStarted(Account account, String folder) {
- }
+ public void listFoldersFinished(Account account) {}
- public void listLocalMessages(Account account, String folder, Message[] messages) {
- }
+ public void listFoldersFailed(Account account, String message) {}
- public void listLocalMessagesAddMessages(Account account, String folder, List messages) {
- }
- public void listLocalMessagesUpdateMessage(Account account, String folder, Message message) {
- }
+ public void listLocalMessagesStarted(Account account, String folder) {}
- public void listLocalMessagesRemoveMessage(Account account, String folder, Message message) {
- }
+ public void listLocalMessages(Account account, String folder, Message[] messages) {}
- public void listLocalMessagesFailed(Account account, String folder, String message) {
- }
+ public void listLocalMessagesAddMessages(Account account, String folder,
+ List messages) {}
- public void listLocalMessagesFinished(Account account, String folder) {
- }
+ public void listLocalMessagesUpdateMessage(Account account, String folder, Message message) {}
- public void synchronizeMailboxStarted(Account account, String folder) {
- }
+ public void listLocalMessagesRemoveMessage(Account account, String folder, Message message) {}
- public void synchronizeMailboxHeadersStarted(Account account, String folder) {
- }
+ public void listLocalMessagesFinished(Account account, String folder) {}
- public void synchronizeMailboxHeadersProgress(Account account, String folder, int completed, int total) {
- }
+ public void listLocalMessagesFailed(Account account, String folder, String message) {}
+
+
+ public void synchronizeMailboxStarted(Account account, String folder) {}
+
+ public void synchronizeMailboxHeadersStarted(Account account, String folder) {}
+
+ public void synchronizeMailboxHeadersProgress(Account account, String folder,
+ int completed, int total) {}
public void synchronizeMailboxHeadersFinished(Account account, String folder,
- int totalMessagesInMailbox, int numNewMessages) {
- }
+ int totalMessagesInMailbox, int numNewMessages) {}
+ public void synchronizeMailboxProgress(Account account, String folder, int completed,
+ int total) {}
- public void synchronizeMailboxProgress(Account account, String folder, int completed, int total)
- {}
+ public void synchronizeMailboxNewMessage(Account account, String folder, Message message) {}
- public void synchronizeMailboxNewMessage(Account account, String folder, Message message) {
- }
+ public void synchronizeMailboxAddOrUpdateMessage(Account account, String folder,
+ Message message) {}
- public void synchronizeMailboxAddOrUpdateMessage(Account account, String folder, Message message) {
- }
-
- public void synchronizeMailboxRemovedMessage(Account account, String folder, Message message) {
- }
+ public void synchronizeMailboxRemovedMessage(Account account, String folder,
+ Message message) {}
public void synchronizeMailboxFinished(Account account, String folder,
- int totalMessagesInMailbox, int numNewMessages) {
- }
+ int totalMessagesInMailbox, int numNewMessages) {}
- public void synchronizeMailboxFailed(Account account, String folder,
- String message) {
- }
+ public void synchronizeMailboxFailed(Account account, String folder, String message) {}
- public void loadMessageForViewStarted(Account account, String folder, String uid) {
- }
+
+ public void loadMessageForViewStarted(Account account, String folder, String uid) {}
public void loadMessageForViewHeadersAvailable(Account account, String folder, String uid,
- Message message) {
- }
+ Message message) {}
public void loadMessageForViewBodyAvailable(Account account, String folder, String uid,
- Message message) {
- }
+ Message message) {}
public void loadMessageForViewFinished(Account account, String folder, String uid,
- Message message) {
- }
+ Message message) {}
- public void loadMessageForViewFailed(Account account, String folder, String uid, Throwable t) {
- }
+ public void loadMessageForViewFailed(Account account, String folder, String uid,
+ Throwable t) {}
/**
* Called when a message for view has been fully displayed on the screen.
*/
public void messageViewFinished() {}
- public void checkMailStarted(Context context, Account account) {
- }
- public void checkMailFinished(Context context, Account account) {
- }
+ public void checkMailStarted(Context context, Account account) {}
- public void checkMailFailed(Context context, Account account, String reason) {
- }
+ public void checkMailFinished(Context context, Account account) {}
- public void sendPendingMessagesStarted(Account account) {
- }
+ public void checkMailFailed(Context context, Account account, String reason) {}
- public void sendPendingMessagesCompleted(Account account) {
- }
- public void sendPendingMessagesFailed(Account account) {
- }
+ public void sendPendingMessagesStarted(Account account) {}
- public void messageDeleted(Account account, String folder, Message message) {
+ public void sendPendingMessagesCompleted(Account account) {}
- }
- public void emptyTrashCompleted(Account account) {
- }
+ public void sendPendingMessagesFailed(Account account) {}
- public void folderStatusChanged(Account account, String folderName, int unreadMessageCount) {
- }
- public void folderStatusChanged(Account account, String folderName) {
- }
+ public void emptyTrashCompleted(Account account) {}
- public void systemStatusChanged() {
- }
- public void messageUidChanged(Account account, String folder, String oldUid, String newUid) {
+ public void folderStatusChanged(Account account, String folderName, int unreadMessageCount) {}
- }
- public void setPushActive(Account account, String folderName, boolean enabled) {
+ public void systemStatusChanged() {}
- }
- public void loadAttachmentStarted(
- Account account,
- Message message,
- Part part,
- Object tag,
- boolean requiresDownload) {
- }
+ public void messageDeleted(Account account, String folder, Message message) {}
- public void loadAttachmentFinished(
- Account account,
- Message message,
- Part part,
- Object tag) {
- }
+ public void messageUidChanged(Account account, String folder, String oldUid, String newUid) {}
- public void loadAttachmentFailed(
- Account account,
- Message message,
- Part part,
- Object tag,
- String reason) {
- }
+
+ public void setPushActive(Account account, String folderName, boolean enabled) {}
+
+
+ public void loadAttachmentStarted(Account account, Message message, Part part, Object tag,
+ boolean requiresDownload) {}
+
+ public void loadAttachmentFinished(Account account, Message message, Part part, Object tag) {}
+
+ public void loadAttachmentFailed(Account account, Message message, Part part, Object tag,
+ String reason) {}
+
+
+
+ public void pendingCommandStarted(Account account, String commandTitle) {}
public void pendingCommandsProcessing(Account account) {}
- public void pendingCommandsFinished(Account account) {}
- public void pendingCommandStarted(Account account, String commandTitle)
- {}
- public void pendingCommandCompleted(Account account, String commandTitle)
- {}
+ public void pendingCommandCompleted(Account account, String commandTitle) {}
+
+ public void pendingCommandsFinished(Account account) {}
+
/**
* General notification messages subclasses can override to be notified that the controller
* has completed a command. This is useful for turning off progress indicators that may have
* been left over from previous commands.
- * @param moreCommandsToRun True if the controller will continue on to another command
- * immediately.
+ *
+ * @param moreCommandsToRun
+ * {@code true} if the controller will continue on to another command immediately.
+ * {@code false} otherwise.
*/
- public void controllerCommandCompleted(boolean moreCommandsToRun) {
-
- }
+ public void controllerCommandCompleted(boolean moreCommandsToRun) {}
}
diff --git a/src/com/fsck/k9/helper/HtmlConverter.java b/src/com/fsck/k9/helper/HtmlConverter.java
index 9cf3c38df..e0bf6b720 100644
--- a/src/com/fsck/k9/helper/HtmlConverter.java
+++ b/src/com/fsck/k9/helper/HtmlConverter.java
@@ -125,19 +125,41 @@ public class HtmlConverter {
private static final int MAX_SMART_HTMLIFY_MESSAGE_LENGTH = 1024 * 256 ;
+ public static final String getHtmlHeader() {
+ return "";
+ }
+
+ public static final String getHtmlFooter() {
+ return "";
+ }
+
/**
- * Naively convert a text string into an HTML document. This method avoids using regular expressions on the entire
- * message body to save memory.
- * @param text Plain text string.
+ * Naively convert a text string into an HTML document.
+ *
+ *
+ * This method avoids using regular expressions on the entire message body to save memory.
+ *
+ *
+ * @param text
+ * Plain text string.
+ * @param useHtmlTag
+ * If {@code true} this method adds headers and footers to create a proper HTML
+ * document.
+ *
* @return HTML string.
*/
- private static String simpleTextToHtml(String text) {
+ private static String simpleTextToHtml(String text, boolean useHtmlTag) {
// Encode HTML entities to make sure we don't display something evil.
text = TextUtils.htmlEncode(text);
StringReader reader = new StringReader(text);
StringBuilder buff = new StringBuilder(text.length() + TEXT_TO_HTML_EXTRA_BUFFER_LENGTH);
- buff.append("");
+
+ if (useHtmlTag) {
+ buff.append(getHtmlHeader());
+ }
+
+ buff.append(htmlifyMessageHeader());
int c;
try {
@@ -159,25 +181,39 @@ public class HtmlConverter {
Log.e(K9.LOG_TAG, "Could not read string to convert text to HTML:", e);
}
- buff.append("");
+ buff.append(htmlifyMessageFooter());
+
+ if (useHtmlTag) {
+ buff.append(getHtmlFooter());
+ }
return buff.toString();
}
/**
- * Convert a text string into an HTML document. Attempts to do smart replacement for large
- * documents to prevent OOM errors. This method adds headers and footers to create a proper HTML
- * document. To convert to a fragment, use {@link #textToHtmlFragment(String)}.
- * @param text Plain text string.
+ * Convert a text string into an HTML document.
+ *
+ *
+ * Attempts to do smart replacement for large documents to prevent OOM errors. This method
+ * optionally adds headers and footers to create a proper HTML document. To convert to a
+ * fragment, use {@link #textToHtmlFragment(String)}.
+ *
+ *
+ * @param text
+ * Plain text string.
+ * @param useHtmlTag
+ * If {@code true} this method adds headers and footers to create a proper HTML
+ * document.
+ *
* @return HTML string.
*/
- public static String textToHtml(String text) {
+ public static String textToHtml(String text, boolean useHtmlTag) {
// Our HTMLification code is somewhat memory intensive
// and was causing lots of OOM errors on the market
// if the message is big and plain text, just do
// a trivial htmlification
if (text.length() > MAX_SMART_HTMLIFY_MESSAGE_LENGTH) {
- return simpleTextToHtml(text);
+ return simpleTextToHtml(text, useHtmlTag);
}
StringReader reader = new StringReader(text);
StringBuilder buff = new StringBuilder(text.length() + TEXT_TO_HTML_EXTRA_BUFFER_LENGTH);
@@ -221,11 +257,19 @@ public class HtmlConverter {
text = text.replaceAll("(?m)(\r\n|\n|\r){4,}", "\n\n");
StringBuffer sb = new StringBuffer(text.length() + TEXT_TO_HTML_EXTRA_BUFFER_LENGTH);
- sb.append("");
+
+ if (useHtmlTag) {
+ sb.append(getHtmlHeader());
+ }
+
sb.append(htmlifyMessageHeader());
linkifyText(text, sb);
sb.append(htmlifyMessageFooter());
- sb.append("");
+
+ if (useHtmlTag) {
+ sb.append(getHtmlFooter());
+ }
+
text = sb.toString();
return text;
diff --git a/src/com/fsck/k9/mail/Folder.java b/src/com/fsck/k9/mail/Folder.java
index 9d9c3423b..df6a633ec 100644
--- a/src/com/fsck/k9/mail/Folder.java
+++ b/src/com/fsck/k9/mail/Folder.java
@@ -1,6 +1,7 @@
package com.fsck.k9.mail;
import java.util.Date;
+import java.util.Map;
import android.util.Log;
import com.fsck.k9.Account;
@@ -102,11 +103,15 @@ public abstract class Folder {
public abstract Message[] getMessages(String[] uids, MessageRetrievalListener listener)
throws MessagingException;
- public abstract void appendMessages(Message[] messages) throws MessagingException;
+ public abstract Map appendMessages(Message[] messages) throws MessagingException;
- public void copyMessages(Message[] msgs, Folder folder) throws MessagingException {}
+ public Map copyMessages(Message[] msgs, Folder folder) throws MessagingException {
+ return null;
+ }
- public void moveMessages(Message[] msgs, Folder folder) throws MessagingException {}
+ public Map moveMessages(Message[] msgs, Folder folder) throws MessagingException {
+ return null;
+ }
public void delete(Message[] msgs, String trashFolderName) throws MessagingException {
for (Message message : msgs) {
diff --git a/src/com/fsck/k9/mail/internet/MimeUtility.java b/src/com/fsck/k9/mail/internet/MimeUtility.java
index d8ad792b2..405243d4b 100644
--- a/src/com/fsck/k9/mail/internet/MimeUtility.java
+++ b/src/com/fsck/k9/mail/internet/MimeUtility.java
@@ -1,9 +1,14 @@
package com.fsck.k9.mail.internet;
+import android.content.Context;
import android.util.Log;
import com.fsck.k9.K9;
+import com.fsck.k9.R;
+import com.fsck.k9.helper.HtmlConverter;
import com.fsck.k9.mail.*;
+import com.fsck.k9.mail.Message.RecipientType;
+
import org.apache.commons.io.IOUtils;
import org.apache.james.mime4j.codec.Base64InputStream;
import org.apache.james.mime4j.codec.QuotedPrintableInputStream;
@@ -12,7 +17,11 @@ import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
+import java.util.Date;
+import java.util.HashSet;
+import java.util.List;
import java.util.Locale;
+import java.util.Set;
import java.util.regex.Pattern;
import java.nio.charset.Charset;
import java.nio.charset.IllegalCharsetNameException;
@@ -23,6 +32,9 @@ public class MimeUtility {
public static final String K9_SETTINGS_MIME_TYPE = "application/x-k9settings";
+ private static final String TEXT_DIVIDER =
+ "------------------------------------------------------------------------";
+
/*
* http://www.w3schools.com/media/media_mimeref.asp
* +
@@ -1100,49 +1112,867 @@ public class MimeUtility {
return tempBody;
}
+
/**
- * An unfortunately named method that makes decisions about a Part (usually a Message)
- * as to which of it's children will be "viewable" and which will be attachments.
- * The method recursively sorts the viewables and attachments into seperate
- * lists for further processing.
- * @param part
- * @param viewables
- * @param attachments
- * @throws MessagingException
+ * Empty base class for the class hierarchy used by
+ * {@link MimeUtility#extractTextAndAttachments(Context, Message)}.
+ *
+ * @see Text
+ * @see Html
+ * @see MessageHeader
+ * @see Alternative
*/
- public static void collectParts(Part part, ArrayList viewables,
- ArrayList attachments) throws MessagingException {
- /*
- * If the part is Multipart but not alternative it's either mixed or
- * something we don't know about, which means we treat it as mixed
- * per the spec. We just process it's pieces recursively.
+ static abstract class Viewable { /* empty */ }
+
+ /**
+ * Class representing textual parts of a message that aren't marked as attachments.
+ *
+ * @see MimeUtility#isPartTextualBody(Part)
+ */
+ static abstract class Textual extends Viewable {
+ private Part mPart;
+
+ public Textual(Part part) {
+ mPart = part;
+ }
+
+ public Part getPart() {
+ return mPart;
+ }
+ }
+
+ /**
+ * Class representing a {@code text/plain} part of a message.
+ */
+ static class Text extends Textual {
+ public Text(Part part) {
+ super(part);
+ }
+ }
+
+ /**
+ * Class representing a {@code text/html} part of a message.
+ */
+ static class Html extends Textual {
+ public Html(Part part) {
+ super(part);
+ }
+ }
+
+ /**
+ * Class representing a {@code message/rfc822} part of a message.
+ *
+ *
+ * This is used to extract basic header information when the message contents are displayed
+ * inline.
+ *
+ */
+ static class MessageHeader extends Viewable {
+ private Part mContainerPart;
+ private Message mMessage;
+
+ public MessageHeader(Part containerPart, Message message) {
+ mContainerPart = containerPart;
+ mMessage = message;
+ }
+
+ public Part getContainerPart() {
+ return mContainerPart;
+ }
+
+ public Message getMessage() {
+ return mMessage;
+ }
+ }
+
+ /**
+ * Class representing a {@code multipart/alternative} part of a message.
+ *
+ *
+ * Only relevant {@code text/plain} and {@code text/html} children are stored in this container
+ * class.
+ *
+ */
+ static class Alternative extends Viewable {
+ private List mText;
+ private List mHtml;
+
+ public Alternative(List text, List html) {
+ mText = text;
+ mHtml = html;
+ }
+
+ public List getText() {
+ return mText;
+ }
+
+ public List getHtml() {
+ return mHtml;
+ }
+ }
+
+ /**
+ * Store viewable text of a message as plain text and HTML, and the parts considered
+ * attachments.
+ *
+ * @see MimeUtility#extractTextAndAttachments(Context, Message)
+ */
+ public static class ViewableContainer {
+ /**
+ * The viewable text of the message in plain text.
*/
- if (part.getBody() instanceof Multipart) {
- Multipart mp = (Multipart)part.getBody();
- for (int i = 0; i < mp.getCount(); i++) {
- collectParts(mp.getBodyPart(i), viewables, attachments);
+ public final String text;
+
+ /**
+ * The viewable text of the message in HTML.
+ */
+ public final String html;
+
+ /**
+ * The parts of the message considered attachments (everything not viewable).
+ */
+ public final List attachments;
+
+ ViewableContainer(String text, String html, List attachments) {
+ this.text = text;
+ this.html = html;
+ this.attachments = attachments;
+ }
+ }
+
+ /**
+ * Collect attachment parts of a message.
+ *
+ * @param message
+ * The message to collect the attachment parts from.
+ *
+ * @return A list of parts regarded as attachments.
+ *
+ * @throws MessagingException
+ * In case of an error.
+ */
+ public static List collectAttachments(Message message)
+ throws MessagingException {
+ try {
+ List attachments = new ArrayList();
+ getViewables(message, attachments);
+
+ return attachments;
+ } catch (Exception e) {
+ throw new MessagingException("Couldn't collect attachment parts", e);
+ }
+ }
+
+ /**
+ * Collect the viewable textual parts of a message.
+ *
+ * @param message
+ * The message to extract the viewable parts from.
+ *
+ * @return A set of viewable parts of the message.
+ *
+ * @throws MessagingException
+ * In case of an error.
+ */
+ public static Set collectTextParts(Message message)
+ throws MessagingException {
+ try {
+ List attachments = new ArrayList();
+
+ // Collect all viewable parts
+ List viewables = getViewables(message, attachments);
+
+ // Extract the Part references
+ return getParts(viewables);
+ } catch (Exception e) {
+ throw new MessagingException("Couldn't extract viewable parts", e);
+ }
+ }
+
+ /**
+ * Extract the viewable textual parts of a message and return the rest as attachments.
+ *
+ * @param context
+ * A {@link Context} instance that will be used to get localized strings.
+ * @param message
+ * The message to extract the text and attachments from.
+ *
+ * @return A {@link ViewableContainer} instance containing the textual parts of the message as
+ * plain text and HTML, and a list of message parts considered attachments.
+ *
+ * @throws MessagingException
+ * In case of an error.
+ */
+ public static ViewableContainer extractTextAndAttachments(Context context, Message message)
+ throws MessagingException {
+ try {
+ List attachments = new ArrayList();
+
+ // Collect all viewable parts
+ List viewables = getViewables(message, attachments);
+
+ /*
+ * Convert the tree of viewable parts into text and HTML
+ */
+
+ // Used to suppress the divider for the first viewable part
+ boolean hideDivider = true;
+
+ StringBuilder text = new StringBuilder();
+ StringBuilder html = new StringBuilder();
+ html.append(HtmlConverter.getHtmlHeader());
+
+ for (Viewable viewable : viewables) {
+ if (viewable instanceof Textual) {
+ // This is either a text/plain or text/html part. Fill the variables 'text' and
+ // 'html', converting between plain text and HTML as necessary.
+ text.append(buildText(viewable, !hideDivider));
+ html.append(buildHtml(viewable, !hideDivider));
+ hideDivider = false;
+ } else if (viewable instanceof MessageHeader) {
+ MessageHeader header = (MessageHeader) viewable;
+ Part containerPart = header.getContainerPart();
+ Message innerMessage = header.getMessage();
+
+ addTextDivider(text, containerPart, !hideDivider);
+ addMessageHeaderText(context, text, innerMessage);
+
+ addHtmlDivider(html, containerPart, !hideDivider);
+ addMessageHeaderHtml(context, html, innerMessage);
+
+ hideDivider = true;
+ } else if (viewable instanceof Alternative) {
+ // Handle multipart/alternative contents
+ Alternative alternative = (Alternative) viewable;
+
+ /*
+ * We made sure at least one of text/plain or text/html is present when
+ * creating the Alternative object. If one part is not present we convert the
+ * other one to make sure 'text' and 'html' always contain the same text.
+ */
+ List textAlternative = alternative.getText().isEmpty() ?
+ alternative.getHtml() : alternative.getText();
+ List htmlAlternative = alternative.getHtml().isEmpty() ?
+ alternative.getText() : alternative.getHtml();
+
+ // Fill the 'text' variable
+ boolean divider = !hideDivider;
+ for (Viewable textViewable : textAlternative) {
+ text.append(buildText(textViewable, divider));
+ divider = true;
+ }
+
+ // Fill the 'html' variable
+ divider = !hideDivider;
+ for (Viewable htmlViewable : htmlAlternative) {
+ html.append(buildHtml(htmlViewable, divider));
+ divider = true;
+ }
+ hideDivider = false;
+ }
}
+
+ html.append(HtmlConverter.getHtmlFooter());
+
+ return new ViewableContainer(text.toString(), html.toString(), attachments);
+ } catch (Exception e) {
+ throw new MessagingException("Couldn't extract viewable parts", e);
}
- /*
- * If the part is an embedded message we just continue to process
- * it, pulling any viewables or attachments into the running list.
- */
- else if (part.getBody() instanceof Message) {
- Message message = (Message)part.getBody();
- collectParts(message, viewables, attachments);
- }
- /*
- * If the part is HTML and it got this far it's part of a mixed (et
- * al) and should be rendered inline.
- */
- else if (isPartTextualBody(part)) {
- viewables.add(part);
+ }
+
+ /**
+ * Traverse the MIME tree of a message an extract viewable parts.
+ *
+ * @param part
+ * The message part to start from.
+ * @param attachments
+ * A list that will receive the parts that are considered attachments.
+ *
+ * @return A list of {@link Viewable}s.
+ *
+ * @throws MessagingException
+ * In case of an error.
+ */
+ public static List getViewables(Part part, List attachments) throws MessagingException {
+ List viewables = new ArrayList();
+
+ Body body = part.getBody();
+ if (body instanceof Multipart) {
+ Multipart multipart = (Multipart) body;
+ if (part.getMimeType().equalsIgnoreCase("multipart/alternative")) {
+ /*
+ * For multipart/alternative parts we try to find a text/plain and a text/html
+ * child. Everything else we find is put into 'attachments'.
+ */
+ List text = findTextPart(multipart, true);
+
+ Set knownTextParts = getParts(text);
+ List html = findHtmlPart(multipart, knownTextParts, attachments, true);
+
+ if (!text.isEmpty() || !html.isEmpty()) {
+ Alternative alternative = new Alternative(text, html);
+ viewables.add(alternative);
+ }
+ } else {
+ // For all other multipart parts we recurse to grab all viewable children.
+ int childCount = multipart.getCount();
+ for (int i = 0; i < childCount; i++) {
+ Part bodyPart = multipart.getBodyPart(i);
+ viewables.addAll(getViewables(bodyPart, attachments));
+ }
+ }
+ } else if (body instanceof Message &&
+ !("attachment".equalsIgnoreCase(getContentDisposition(part)))) {
+ /*
+ * We only care about message/rfc822 parts whose Content-Disposition header has a value
+ * other than "attachment".
+ */
+ Message message = (Message) body;
+
+ // We add the Message object so we can extract the filename later.
+ viewables.add(new MessageHeader(part, message));
+
+ // Recurse to grab all viewable parts and attachments from that message.
+ viewables.addAll(getViewables(message, attachments));
+ } else if (isPartTextualBody(part)) {
+ /*
+ * Save text/plain and text/html
+ */
+ String mimeType = part.getMimeType();
+ if (mimeType.equalsIgnoreCase("text/plain")) {
+ Text text = new Text(part);
+ viewables.add(text);
+ } else {
+ Html html = new Html(part);
+ viewables.add(html);
+ }
} else {
+ // Everything else is treated as attachment.
attachments.add(part);
}
+ return viewables;
}
+ /**
+ * Search the children of a {@link Multipart} for {@code text/plain} parts.
+ *
+ * @param multipart
+ * The {@code Multipart} to search through.
+ * @param directChild
+ * If {@code true}, this method will return after the first {@code text/plain} was
+ * found.
+ *
+ * @return A list of {@link Text} viewables.
+ *
+ * @throws MessagingException
+ * In case of an error.
+ */
+ private static List findTextPart(Multipart multipart, boolean directChild)
+ throws MessagingException {
+ List viewables = new ArrayList();
+
+ int childCount = multipart.getCount();
+ for (int i = 0; i < childCount; i++) {
+ Part part = multipart.getBodyPart(i);
+ Body body = part.getBody();
+ if (body instanceof Multipart) {
+ Multipart innerMultipart = (Multipart) body;
+
+ /*
+ * Recurse to find text parts. Since this is a multipart that is a child of a
+ * multipart/alternative we don't want to stop after the first text/plain part
+ * we find. This will allow to get all text parts for constructions like this:
+ *
+ * 1. multipart/alternative
+ * 1.1. multipart/mixed
+ * 1.1.1. text/plain
+ * 1.1.2. text/plain
+ * 1.2. text/html
+ */
+ List textViewables = findTextPart(innerMultipart, false);
+
+ if (!textViewables.isEmpty()) {
+ viewables.addAll(textViewables);
+ if (directChild) {
+ break;
+ }
+ }
+ } else if (isPartTextualBody(part) && part.getMimeType().equalsIgnoreCase("text/plain")) {
+ Text text = new Text(part);
+ viewables.add(text);
+ if (directChild) {
+ break;
+ }
+ }
+ }
+
+ return viewables;
+ }
+
+ /**
+ * Search the children of a {@link Multipart} for {@code text/html} parts.
+ *
+ *
+ * Every part that is not a {@code text/html} we want to display, we add to 'attachments'.
+ *
+ *
+ * @param multipart
+ * The {@code Multipart} to search through.
+ * @param knownTextParts
+ * A set of {@code text/plain} parts that shouldn't be added to 'attachments'.
+ * @param attachments
+ * A list that will receive the parts that are considered attachments.
+ * @param directChild
+ * If {@code true}, this method will add all {@code text/html} parts except the first
+ * found to 'attachments'.
+ *
+ * @return A list of {@link Text} viewables.
+ *
+ * @throws MessagingException
+ * In case of an error.
+ */
+ private static List findHtmlPart(Multipart multipart, Set knownTextParts,
+ List attachments, boolean directChild) throws MessagingException {
+ List viewables = new ArrayList();
+
+ boolean partFound = false;
+ int childCount = multipart.getCount();
+ for (int i = 0; i < childCount; i++) {
+ Part part = multipart.getBodyPart(i);
+ Body body = part.getBody();
+ if (body instanceof Multipart) {
+ Multipart innerMultipart = (Multipart) body;
+
+ if (directChild && partFound) {
+ // We already found our text/html part. Now we're only looking for attachments.
+ findAttachments(innerMultipart, knownTextParts, attachments);
+ } else {
+ /*
+ * Recurse to find HTML parts. Since this is a multipart that is a child of a
+ * multipart/alternative we don't want to stop after the first text/html part
+ * we find. This will allow to get all text parts for constructions like this:
+ *
+ * 1. multipart/alternative
+ * 1.1. text/plain
+ * 1.2. multipart/mixed
+ * 1.2.1. text/html
+ * 1.2.2. text/html
+ * 1.3. image/jpeg
+ */
+ List htmlViewables = findHtmlPart(innerMultipart, knownTextParts,
+ attachments, false);
+
+ if (!htmlViewables.isEmpty()) {
+ partFound = true;
+ viewables.addAll(htmlViewables);
+ }
+ }
+ } else if (!(directChild && partFound) && isPartTextualBody(part) &&
+ part.getMimeType().equalsIgnoreCase("text/html")) {
+ Html html = new Html(part);
+ viewables.add(html);
+ partFound = true;
+ } else if (!knownTextParts.contains(part)) {
+ // Only add this part as attachment if it's not a viewable text/plain part found
+ // earlier.
+ attachments.add(part);
+ }
+ }
+
+ return viewables;
+ }
+
+ /**
+ * Build a set of message parts for fast lookups.
+ *
+ * @param viewables
+ * A list of {@link Viewable}s containing references to the message parts to include in
+ * the set.
+ *
+ * @return The set of viewable {@code Part}s.
+ *
+ * @see MimeUtility#findHtmlPart(Multipart, Set, List, boolean)
+ * @see MimeUtility#findAttachments(Multipart, Set, List)
+ */
+ private static Set getParts(List viewables) {
+ Set parts = new HashSet();
+
+ for (Viewable viewable : viewables) {
+ if (viewable instanceof Textual) {
+ parts.add(((Textual) viewable).getPart());
+ } else if (viewable instanceof Alternative) {
+ Alternative alternative = (Alternative) viewable;
+ parts.addAll(getParts(alternative.getText()));
+ parts.addAll(getParts(alternative.getHtml()));
+ }
+ }
+
+ return parts;
+ }
+
+ /**
+ * Traverse the MIME tree and add everything that's not a known text part to 'attachments'.
+ *
+ * @param multipart
+ * The {@link Multipart} to start from.
+ * @param knownTextParts
+ * A set of known text parts we don't want to end up in 'attachments'.
+ * @param attachments
+ * A list that will receive the parts that are considered attachments.
+ */
+ private static void findAttachments(Multipart multipart, Set knownTextParts,
+ List attachments) {
+ int childCount = multipart.getCount();
+ for (int i = 0; i < childCount; i++) {
+ Part part = multipart.getBodyPart(i);
+ Body body = part.getBody();
+ if (body instanceof Multipart) {
+ Multipart innerMultipart = (Multipart) body;
+ findAttachments(innerMultipart, knownTextParts, attachments);
+ } else if (!knownTextParts.contains(part)) {
+ attachments.add(part);
+ }
+ }
+ }
+
+ /**
+ * Extract important header values from a message to display inline (plain text version).
+ *
+ * @param context
+ * A {@link Context} instance that will be used to get localized strings.
+ * @param text
+ * The {@link StringBuilder} that will receive the (plain text) output.
+ * @param message
+ * The message to extract the header values from.
+ *
+ * @throws MessagingException
+ * In case of an error.
+ */
+ private static void addMessageHeaderText(Context context, StringBuilder text, Message message)
+ throws MessagingException {
+ // From:
+ Address[] from = message.getFrom();
+ if (from != null && from.length > 0) {
+ text.append(context.getString(R.string.message_compose_quote_header_from));
+ text.append(' ');
+ text.append(Address.toString(from));
+ text.append("\n");
+ }
+
+ // To:
+ Address[] to = message.getRecipients(RecipientType.TO);
+ if (to != null && to.length > 0) {
+ text.append(context.getString(R.string.message_compose_quote_header_to));
+ text.append(' ');
+ text.append(Address.toString(to));
+ text.append("\n");
+ }
+
+ // Cc:
+ Address[] cc = message.getRecipients(RecipientType.CC);
+ if (cc != null && cc.length > 0) {
+ text.append(context.getString(R.string.message_compose_quote_header_cc));
+ text.append(' ');
+ text.append(Address.toString(cc));
+ text.append("\n");
+ }
+
+ // Date:
+ Date date = message.getSentDate();
+ if (date != null) {
+ text.append(context.getString(R.string.message_compose_quote_header_send_date));
+ text.append(' ');
+ text.append(date.toString());
+ text.append("\n");
+ }
+
+ // Subject:
+ String subject = message.getSubject();
+ text.append(context.getString(R.string.message_compose_quote_header_subject));
+ text.append(' ');
+ if (subject == null) {
+ text.append(context.getString(R.string.general_no_subject));
+ } else {
+ text.append(subject);
+ }
+ text.append("\n\n");
+ }
+
+ /**
+ * Extract important header values from a message to display inline (HTML version).
+ *
+ * @param context
+ * A {@link Context} instance that will be used to get localized strings.
+ * @param html
+ * The {@link StringBuilder} that will receive the (HTML) output.
+ * @param message
+ * The message to extract the header values from.
+ *
+ * @throws MessagingException
+ * In case of an error.
+ */
+ private static void addMessageHeaderHtml(Context context, StringBuilder html, Message message)
+ throws MessagingException {
+
+ html.append("");
+
+ // From:
+ Address[] from = message.getFrom();
+ if (from != null && from.length > 0) {
+ addTableRow(html, context.getString(R.string.message_compose_quote_header_from),
+ Address.toString(from));
+ }
+
+ // To:
+ Address[] to = message.getRecipients(RecipientType.TO);
+ if (to != null && to.length > 0) {
+ addTableRow(html, context.getString(R.string.message_compose_quote_header_to),
+ Address.toString(to));
+ }
+
+ // Cc:
+ Address[] cc = message.getRecipients(RecipientType.CC);
+ if (cc != null && cc.length > 0) {
+ addTableRow(html, context.getString(R.string.message_compose_quote_header_cc),
+ Address.toString(cc));
+ }
+
+ // Date:
+ Date date = message.getSentDate();
+ if (date != null) {
+ addTableRow(html, context.getString(R.string.message_compose_quote_header_send_date),
+ date.toString());
+ }
+
+ // Subject:
+ String subject = message.getSubject();
+ addTableRow(html, context.getString(R.string.message_compose_quote_header_subject),
+ (subject == null) ? context.getString(R.string.general_no_subject) : subject);
+
+ html.append("
");
+ }
+
+ /**
+ * Output an HTML table two column row with some hardcoded style.
+ *
+ * @param html
+ * The {@link StringBuilder} that will receive the output.
+ * @param header
+ * The string to be put in the {@code TH} element.
+ * @param value
+ * The string to be put in the {@code TD} element.
+ */
+ private static void addTableRow(StringBuilder html, String header, String value) {
+ html.append("| ");
+ html.append(header);
+ html.append(" | ");
+ html.append("");
+ html.append(value);
+ html.append(" |
|---|
");
+ }
+
+ /**
+ * Use the contents of a {@link Viewable} to create the plain text to be displayed.
+ *
+ *
+ * This will use {@link HtmlConverter#htmlToText(String)} to convert HTML parts to plain text
+ * if necessary.
+ *
+ *
+ * @param viewable
+ * The viewable part to build the text from.
+ * @param prependDivider
+ * {@code true}, if the text divider should be inserted as first element.
+ * {@code false}, otherwise.
+ *
+ * @return The contents of the supplied viewable instance as plain text.
+ */
+ private static StringBuilder buildText(Viewable viewable, boolean prependDivider)
+ {
+ StringBuilder text = new StringBuilder();
+ if (viewable instanceof Textual) {
+ Part part = ((Textual)viewable).getPart();
+ addTextDivider(text, part, prependDivider);
+
+ String t = getTextFromPart(part);
+ if (t == null) {
+ t = "";
+ } else if (viewable instanceof Html) {
+ t = HtmlConverter.htmlToText(t);
+ }
+ text.append(t);
+ } else if (viewable instanceof Alternative) {
+ // That's odd - an Alternative as child of an Alternative; go ahead and try to use the
+ // text/plain child; fall-back to the text/html part.
+ Alternative alternative = (Alternative) viewable;
+
+ List textAlternative = alternative.getText().isEmpty() ?
+ alternative.getHtml() : alternative.getText();
+
+ boolean divider = prependDivider;
+ for (Viewable textViewable : textAlternative) {
+ text.append(buildText(textViewable, divider));
+ divider = true;
+ }
+ }
+
+ return text;
+ }
+
+ /*
+ * Some constants that are used by addTextDivider() below.
+ */
+ private static final int TEXT_DIVIDER_LENGTH = TEXT_DIVIDER.length();
+ private static final String FILENAME_PREFIX = "----- ";
+ private static final int FILENAME_PREFIX_LENGTH = FILENAME_PREFIX.length();
+ private static final String FILENAME_SUFFIX = " ";
+ private static final int FILENAME_SUFFIX_LENGTH = FILENAME_SUFFIX.length();
+
+ /**
+ * Add a plain text divider between two plain text message parts.
+ *
+ * @param text
+ * The {@link StringBuilder} to append the divider to.
+ * @param part
+ * The message part that will follow after the divider. This is used to extract the
+ * part's name.
+ * @param prependDivider
+ * {@code true}, if the divider should be appended. {@code false}, otherwise.
+ */
+ private static void addTextDivider(StringBuilder text, Part part, boolean prependDivider) {
+ if (prependDivider) {
+ String filename = getPartName(part);
+
+ text.append("\n\n");
+ int len = filename.length();
+ if (len > 0) {
+ if (len > TEXT_DIVIDER_LENGTH - FILENAME_PREFIX_LENGTH - FILENAME_SUFFIX_LENGTH) {
+ filename = filename.substring(0, TEXT_DIVIDER_LENGTH - FILENAME_PREFIX_LENGTH -
+ FILENAME_SUFFIX_LENGTH - 3) + "...";
+ }
+ text.append(FILENAME_PREFIX);
+ text.append(filename);
+ text.append(FILENAME_SUFFIX);
+ text.append(TEXT_DIVIDER.substring(0, TEXT_DIVIDER_LENGTH -
+ FILENAME_PREFIX_LENGTH - filename.length() - FILENAME_SUFFIX_LENGTH));
+ } else {
+ text.append(TEXT_DIVIDER);
+ }
+ text.append("\n\n");
+ }
+ }
+
+ /**
+ * Use the contents of a {@link Viewable} to create the HTML to be displayed.
+ *
+ *
+ * This will use {@link HtmlConverter#textToHtml(String, boolean)} to convert plain text parts
+ * to HTML if necessary.
+ *
+ *
+ * @param viewable
+ * The viewable part to build the HTML from.
+ * @param prependDivider
+ * {@code true}, if the HTML divider should be inserted as first element.
+ * {@code false}, otherwise.
+ *
+ * @return The contents of the supplied viewable instance as HTML.
+ */
+ private static StringBuilder buildHtml(Viewable viewable, boolean prependDivider)
+ {
+ StringBuilder html = new StringBuilder();
+ if (viewable instanceof Textual) {
+ Part part = ((Textual)viewable).getPart();
+ addHtmlDivider(html, part, prependDivider);
+
+ String t = getTextFromPart(part);
+ if (t == null) {
+ t = "";
+ } else if (viewable instanceof Text) {
+ t = HtmlConverter.textToHtml(t, false);
+ }
+ html.append(t);
+ } else if (viewable instanceof Alternative) {
+ // That's odd - an Alternative as child of an Alternative; go ahead and try to use the
+ // text/html child; fall-back to the text/plain part.
+ Alternative alternative = (Alternative) viewable;
+
+ List htmlAlternative = alternative.getHtml().isEmpty() ?
+ alternative.getText() : alternative.getHtml();
+
+ boolean divider = prependDivider;
+ for (Viewable htmlViewable : htmlAlternative) {
+ html.append(buildHtml(htmlViewable, divider));
+ divider = true;
+ }
+ }
+
+ return html;
+ }
+
+ /**
+ * Add an HTML divider between two HTML message parts.
+ *
+ * @param html
+ * The {@link StringBuilder} to append the divider to.
+ * @param part
+ * The message part that will follow after the divider. This is used to extract the
+ * part's name.
+ * @param prependDivider
+ * {@code true}, if the divider should be appended. {@code false}, otherwise.
+ */
+ private static void addHtmlDivider(StringBuilder html, Part part, boolean prependDivider) {
+ if (prependDivider) {
+ String filename = getPartName(part);
+
+ html.append("");
+ html.append(filename);
+ html.append("
");
+ }
+ }
+
+ /**
+ * Get the name of the message part.
+ *
+ * @param part
+ * The part to get the name for.
+ *
+ * @return The (file)name of the part if available. An empty string, otherwise.
+ */
+ private static String getPartName(Part part) {
+ try {
+ String disposition = part.getDisposition();
+ if (disposition != null) {
+ String name = MimeUtility.getHeaderParameter(disposition, "filename");
+ return (name == null) ? "" : name;
+ }
+ }
+ catch (MessagingException e) { /* ignore */ }
+
+ return "";
+ }
+
+ /**
+ * Get the value of the {@code Content-Disposition} header.
+ *
+ * @param part
+ * The message part to read the header from.
+ *
+ * @return The value of the {@code Content-Disposition} header if available. {@code null},
+ * otherwise.
+ */
+ private static String getContentDisposition(Part part) {
+ try {
+ String disposition = part.getDisposition();
+ if (disposition != null) {
+ return MimeUtility.getHeaderParameter(disposition, null);
+ }
+ }
+ catch (MessagingException e) { /* ignore */ }
+
+ return null;
+ }
public static Boolean isPartTextualBody(Part part) throws MessagingException {
String disposition = part.getDisposition();
@@ -1210,6 +2040,17 @@ public class MimeUtility {
return DEFAULT_ATTACHMENT_MIME_TYPE;
}
+ public static String getExtensionByMimeType(String mimeType) {
+ String lowerCaseMimeType = mimeType.toLowerCase(Locale.US);
+ for (String[] contentTypeMapEntry : MIME_TYPE_BY_EXTENSION_MAP) {
+ if (contentTypeMapEntry[1].equals(lowerCaseMimeType)) {
+ return contentTypeMapEntry[0];
+ }
+ }
+
+ return null;
+ }
+
/**
* Convert some wrong MIME types encountered in the wild to canonical MIME types.
*
diff --git a/src/com/fsck/k9/mail/store/EasStore.java b/src/com/fsck/k9/mail/store/EasStore.java
index 18da89b83..9bcff3e14 100644
--- a/src/com/fsck/k9/mail/store/EasStore.java
+++ b/src/com/fsck/k9/mail/store/EasStore.java
@@ -17,6 +17,7 @@ import java.util.Date;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
+import java.util.Map;
import java.util.Map.Entry;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
@@ -1088,13 +1089,15 @@ public class EasStore extends Store {
}
@Override
- public void copyMessages(Message[] messages, Folder folder) throws MessagingException {
+ public Map copyMessages(Message[] messages, Folder folder) throws MessagingException {
moveOrCopyMessages(messages, folder.getRemoteName(), false);
+ return null;
}
@Override
- public void moveMessages(Message[] messages, Folder folder) throws MessagingException {
+ public Map moveMessages(Message[] messages, Folder folder) throws MessagingException {
moveOrCopyMessages(messages, folder.getRemoteName(), true);
+ return null;
}
@Override
@@ -1464,8 +1467,9 @@ public class EasStore extends Store {
}
@Override
- public void appendMessages(Message[] messages) throws MessagingException {
+ public Map appendMessages(Message[] messages) throws MessagingException {
// EASTODO
+ return null;
}
@Override
diff --git a/src/com/fsck/k9/mail/store/ImapStore.java b/src/com/fsck/k9/mail/store/ImapStore.java
index 34bd1af5b..3090e1a42 100644
--- a/src/com/fsck/k9/mail/store/ImapStore.java
+++ b/src/com/fsck/k9/mail/store/ImapStore.java
@@ -61,6 +61,7 @@ import com.fsck.k9.Account;
import com.fsck.k9.K9;
import com.fsck.k9.R;
import com.fsck.k9.controller.MessageRetrievalListener;
+import com.fsck.k9.helper.StringUtils;
import com.fsck.k9.helper.Utility;
import com.fsck.k9.helper.power.TracingPowerManager;
import com.fsck.k9.helper.power.TracingPowerManager.TracingWakeLock;
@@ -89,6 +90,7 @@ import com.fsck.k9.mail.internet.MimeMultipart;
import com.fsck.k9.mail.internet.MimeUtility;
import com.fsck.k9.mail.store.ImapResponseParser.ImapList;
import com.fsck.k9.mail.store.ImapResponseParser.ImapResponse;
+import com.fsck.k9.mail.store.imap.ImapUtility;
import com.fsck.k9.mail.transport.imap.ImapSettings;
import com.jcraft.jzlib.JZlib;
import com.jcraft.jzlib.ZOutputStream;
@@ -1064,53 +1066,127 @@ public class ImapStore extends Store {
}
}
+ /**
+ * Copies the given messages to the specified folder.
+ *
+ *
+ * Note:
+ * Only the UIDs of the given {@link Message} instances are used. It is assumed that all
+ * UIDs represent valid messages in this folder.
+ *
+ *
+ * @param messages
+ * The messages to copy to the specfied folder.
+ * @param folder
+ * The name of the target folder.
+ *
+ * @return The mapping of original message UIDs to the new server UIDs.
+ */
@Override
- public void copyMessages(Message[] messages, Folder folder) throws MessagingException {
+ public Map copyMessages(Message[] messages, Folder folder)
+ throws MessagingException {
if (!(folder instanceof ImapFolder)) {
throw new MessagingException("ImapFolder.copyMessages passed non-ImapFolder");
}
- if (messages.length == 0)
- return;
+ if (messages.length == 0) {
+ return null;
+ }
ImapFolder iFolder = (ImapFolder)folder;
checkOpen();
+
String[] uids = new String[messages.length];
for (int i = 0, count = messages.length; i < count; i++) {
uids[i] = messages[i].getUid();
}
+
try {
String remoteDestName = encodeString(encodeFolderName(iFolder.getPrefixedName()));
if (!exists(remoteDestName)) {
- /*
- * If the remote trash folder doesn't exist we try to create it.
- */
- if (K9.DEBUG)
- Log.i(K9.LOG_TAG, "IMAPMessage.copyMessages: attempting to create remote '" + remoteDestName + "' folder for " + getLogId());
+ // If the remote trash folder doesn't exist we try to create it.
+ if (K9.DEBUG) {
+ Log.i(K9.LOG_TAG, "Attempting to create remote folder '" + remoteDestName +
+ "' for " + getLogId());
+ }
iFolder.create(FolderType.HOLDS_MESSAGES);
}
- if (exists(remoteDestName)) {
- executeSimpleCommand(String.format("UID COPY %s %s",
- Utility.combine(uids, ','),
- remoteDestName));
- } else {
- throw new MessagingException("IMAPMessage.copyMessages: remote destination folder " + folder.getName()
- + " does not exist and could not be created for " + getLogId()
- , true);
+ //TODO: Split this into multiple commands if the command exceeds a certain length.
+ mConnection.sendCommand(String.format("UID COPY %s %s",
+ Utility.combine(uids, ','),
+ remoteDestName), false);
+ ImapResponse response;
+ do {
+ response = mConnection.readResponse();
+ handleUntaggedResponse(response);
+ } while (response.mTag == null);
+
+ Map uidMap = null;
+ if (response.size() > 1) {
+ /*
+ * If the server supports UIDPLUS, then along with the COPY response it will
+ * return an COPYUID response code, e.g.
+ *
+ * 24 OK [COPYUID 38505 304,319:320 3956:3958] Success
+ *
+ * COPYUID is followed by UIDVALIDITY, the set of UIDs of copied messages from
+ * the source folder and the set of corresponding UIDs assigned to them in the
+ * destination folder.
+ *
+ * We can use the new UIDs included in this response to update our records.
+ */
+ Object responseList = response.get(1);
+
+ if (responseList instanceof ImapList) {
+ final ImapList copyList = (ImapList) responseList;
+ if (copyList.size() >= 4 && copyList.getString(0).equals("COPYUID")) {
+ List srcUids = ImapUtility.getImapSequenceValues(
+ copyList.getString(2));
+ List destUids = ImapUtility.getImapSequenceValues(
+ copyList.getString(3));
+
+ if (srcUids != null && destUids != null) {
+ if (srcUids.size() == destUids.size()) {
+ Iterator srcUidsIterator = srcUids.iterator();
+ Iterator destUidsIterator = destUids.iterator();
+ uidMap = new HashMap();
+ while (srcUidsIterator.hasNext() &&
+ destUidsIterator.hasNext()) {
+ String srcUid = srcUidsIterator.next();
+ String destUid = destUidsIterator.next();
+ uidMap.put(srcUid, destUid);
+ }
+ } else {
+ if (K9.DEBUG) {
+ Log.v(K9.LOG_TAG, "Parse error: size of source UIDs " +
+ "list is not the same as size of destination " +
+ "UIDs list.");
+ }
+ }
+ } else {
+ if (K9.DEBUG) {
+ Log.v(K9.LOG_TAG, "Parsing of the sequence set failed.");
+ }
+ }
+ }
+ }
}
+
+ return uidMap;
} catch (IOException ioe) {
throw ioExceptionHandler(mConnection, ioe);
}
}
@Override
- public void moveMessages(Message[] messages, Folder folder) throws MessagingException {
+ public Map moveMessages(Message[] messages, Folder folder) throws MessagingException {
if (messages.length == 0)
- return;
- copyMessages(messages, folder);
+ return null;
+ Map uidMap = copyMessages(messages, folder);
setFlags(messages, new Flag[] { Flag.DELETED }, true);
+ return uidMap;
}
@Override
@@ -1854,20 +1930,30 @@ public class ImapStore extends Store {
}
/**
- * Appends the given messages to the selected folder. This implementation also determines
- * the new UID of the given message on the IMAP server and sets the Message's UID to the
- * new server UID.
+ * Appends the given messages to the selected folder.
+ *
+ *
+ * This implementation also determines the new UIDs of the given messages on the IMAP
+ * server and changes the messages' UIDs to the new server UIDs.
+ *
+ *
+ * @param messages
+ * The messages to append to the folder.
+ *
+ * @return The mapping of original message UIDs to the new server UIDs.
*/
@Override
- public void appendMessages(Message[] messages) throws MessagingException {
+ public Map appendMessages(Message[] messages) throws MessagingException {
checkOpen();
try {
+ Map uidMap = new HashMap();
for (Message message : messages) {
mConnection.sendCommand(
String.format("APPEND %s (%s) {%d}",
encodeString(encodeFolderName(getPrefixedName())),
combineFlags(message.getFlags()),
message.calculateSize()), false);
+
ImapResponse response;
do {
response = mConnection.readResponse();
@@ -1881,16 +1967,54 @@ public class ImapStore extends Store {
}
} while (response.mTag == null);
- String newUid = getUidFromMessageId(message);
- if (K9.DEBUG)
- Log.d(K9.LOG_TAG, "Got UID " + newUid + " for message for " + getLogId());
+ if (response.size() > 1) {
+ /*
+ * If the server supports UIDPLUS, then along with the APPEND response it
+ * will return an APPENDUID response code, e.g.
+ *
+ * 11 OK [APPENDUID 2 238268] APPEND completed
+ *
+ * We can use the UID included in this response to update our records.
+ */
+ Object responseList = response.get(1);
- if (newUid != null) {
- message.setUid(newUid);
+ if (responseList instanceof ImapList) {
+ ImapList appendList = (ImapList) responseList;
+ if (appendList.size() >= 3 &&
+ appendList.getString(0).equals("APPENDUID")) {
+
+ String newUid = appendList.getString(2);
+
+ if (!StringUtils.isNullOrEmpty(newUid)) {
+ message.setUid(newUid);
+ uidMap.put(message.getUid(), newUid);
+ continue;
+ }
+ }
+ }
}
+ /*
+ * This part is executed in case the server does not support UIDPLUS or does
+ * not implement the APPENDUID response code.
+ */
+ String newUid = getUidFromMessageId(message);
+ if (K9.DEBUG) {
+ Log.d(K9.LOG_TAG, "Got UID " + newUid + " for message for " + getLogId());
+ }
+ if (!StringUtils.isNullOrEmpty(newUid)) {
+ uidMap.put(message.getUid(), newUid);
+ message.setUid(newUid);
+ }
}
+
+ /*
+ * We need uidMap to be null if new UIDs are not available to maintain consistency
+ * with the behavior of other similar methods (copyMessages, moveMessages) which
+ * return null.
+ */
+ return (uidMap.size() == 0) ? null : uidMap;
} catch (IOException ioe) {
throw ioExceptionHandler(mConnection, ioe);
}
@@ -1916,7 +2040,7 @@ public class ImapStore extends Store {
List responses =
executeSimpleCommand(
- String.format("UID SEARCH HEADER MESSAGE-ID %s", messageId));
+ String.format("UID SEARCH HEADER MESSAGE-ID %s", encodeString(messageId)));
for (ImapResponse response1 : responses) {
if (response1.mTag == null && ImapResponseParser.equalsIgnoreCase(response1.get(0), "SEARCH")
&& response1.size() > 1) {
diff --git a/src/com/fsck/k9/mail/store/LocalStore.java b/src/com/fsck/k9/mail/store/LocalStore.java
index 797aa4403..4cf6accf5 100644
--- a/src/com/fsck/k9/mail/store/LocalStore.java
+++ b/src/com/fsck/k9/mail/store/LocalStore.java
@@ -55,6 +55,7 @@ import com.fsck.k9.mail.internet.MimeHeader;
import com.fsck.k9.mail.internet.MimeMessage;
import com.fsck.k9.mail.internet.MimeMultipart;
import com.fsck.k9.mail.internet.MimeUtility;
+import com.fsck.k9.mail.internet.MimeUtility.ViewableContainer;
import com.fsck.k9.mail.internet.TextBody;
import com.fsck.k9.mail.store.LockableDatabase.DbCallback;
import com.fsck.k9.mail.store.LockableDatabase.WrappedException;
@@ -1720,6 +1721,12 @@ public class LocalStore extends Store implements Serializable {
contentDisposition,
name, // TODO: Should use encoded word defined in RFC 2231.
size));
+ } else {
+ bp.setHeader(MimeHeader.HEADER_CONTENT_TYPE, type);
+ bp.setHeader(MimeHeader.HEADER_CONTENT_DISPOSITION,
+ String.format("%s;\n size=%d",
+ contentDisposition,
+ size));
}
bp.setHeader(MimeHeader.HEADER_CONTENT_ID, contentId);
@@ -1950,21 +1957,23 @@ public class LocalStore extends Store implements Serializable {
}
@Override
- public void copyMessages(Message[] msgs, Folder folder) throws MessagingException {
+ public Map copyMessages(Message[] msgs, Folder folder) throws MessagingException {
if (!(folder instanceof LocalFolder)) {
throw new MessagingException("copyMessages called with incorrect Folder");
}
- ((LocalFolder) folder).appendMessages(msgs, true);
+ return ((LocalFolder) folder).appendMessages(msgs, true);
}
@Override
- public void moveMessages(final Message[] msgs, final Folder destFolder) throws MessagingException {
+ public Map moveMessages(final Message[] msgs, final Folder destFolder) throws MessagingException {
if (!(destFolder instanceof LocalFolder)) {
throw new MessagingException("moveMessages called with non-LocalFolder");
}
final LocalFolder lDestFolder = (LocalFolder)destFolder;
+ final Map uidMap = new HashMap();
+
try {
database.execute(false, new DbCallback() {
@Override
@@ -1990,7 +1999,10 @@ public class LocalStore extends Store implements Serializable {
Log.d(K9.LOG_TAG, "Updating folder_id to " + lDestFolder.getId() + " for message with UID "
+ message.getUid() + ", id " + lMessage.getId() + " currently in folder " + getName());
- message.setUid(K9.LOCAL_UID_PREFIX + UUID.randomUUID().toString());
+ String newUid = K9.LOCAL_UID_PREFIX + UUID.randomUUID().toString();
+ message.setUid(newUid);
+
+ uidMap.put(oldUID, newUid);
db.execSQL("UPDATE messages " + "SET folder_id = ?, uid = ? " + "WHERE id = ?", new Object[] {
lDestFolder.getId(),
@@ -1998,6 +2010,11 @@ public class LocalStore extends Store implements Serializable {
lMessage.getId()
});
+ /*
+ * Add a placeholder message so we won't download the original
+ * message again if we synchronize before the remote move is
+ * complete.
+ */
LocalMessage placeHolder = new LocalMessage(oldUID, LocalFolder.this);
placeHolder.setFlagInternal(Flag.DELETED, true);
placeHolder.setFlagInternal(Flag.SEEN, true);
@@ -2009,6 +2026,7 @@ public class LocalStore extends Store implements Serializable {
return null;
}
});
+ return uidMap;
} catch (WrappedException e) {
throw(MessagingException) e.getCause();
}
@@ -2054,8 +2072,8 @@ public class LocalStore extends Store implements Serializable {
* message, retrieve the appropriate local message instance first (if it already exists).
*/
@Override
- public void appendMessages(Message[] messages) throws MessagingException {
- appendMessages(messages, false);
+ public Map appendMessages(Message[] messages) throws MessagingException {
+ return appendMessages(messages, false);
}
public void destroyMessages(final Message[] messages) throws MessagingException {
@@ -2091,10 +2109,12 @@ public class LocalStore extends Store implements Serializable {
* message, retrieve the appropriate local message instance first (if it already exists).
* @param messages
* @param copy
+ * @return Map uidMap of srcUids -> destUids
*/
- private void appendMessages(final Message[] messages, final boolean copy) throws MessagingException {
+ private Map appendMessages(final Message[] messages, final boolean copy) throws MessagingException {
open(OpenMode.READ_WRITE);
try {
+ final Map uidMap = new HashMap();
database.execute(true, new DbCallback() {
@Override
public Void doDbWork(final SQLiteDatabase db) throws WrappedException, UnavailableStorageException {
@@ -2107,11 +2127,26 @@ public class LocalStore extends Store implements Serializable {
long oldMessageId = -1;
String uid = message.getUid();
if (uid == null || copy) {
- uid = K9.LOCAL_UID_PREFIX + UUID.randomUUID().toString();
- if (!copy) {
- message.setUid(uid);
+ /*
+ * Create a new message in the database
+ */
+ String randomLocalUid = K9.LOCAL_UID_PREFIX +
+ UUID.randomUUID().toString();
+
+ if (copy) {
+ // Save mapping: source UID -> target UID
+ uidMap.put(uid, randomLocalUid);
+ } else {
+ // Modify the Message instance to reference the new UID
+ message.setUid(randomLocalUid);
}
+
+ // The message will be saved with the newly generated UID
+ uid = randomLocalUid;
} else {
+ /*
+ * Replace an existing message in the database
+ */
LocalMessage oldMessage = (LocalMessage) getMessage(uid);
if (oldMessage != null) {
@@ -2128,45 +2163,14 @@ public class LocalStore extends Store implements Serializable {
deleteAttachments(message.getUid());
}
- ArrayList viewables = new ArrayList();
- ArrayList attachments = new ArrayList();
- MimeUtility.collectParts(message, viewables, attachments);
+ ViewableContainer container =
+ MimeUtility.extractTextAndAttachments(mApplication, message);
- StringBuilder sbHtml = new StringBuilder();
- StringBuilder sbText = new StringBuilder();
- for (Part viewable : viewables) {
- try {
- String text = MimeUtility.getTextFromPart(viewable);
+ List attachments = container.attachments;
+ String text = container.text;
+ String html = HtmlConverter.convertEmoji2Img(container.html);
- /*
- * Small hack to make sure the string "null" doesn't end up
- * in one of the StringBuilders.
- */
- if (text == null) {
- text = "";
- }
-
- /*
- * Anything with MIME type text/html will be stored as such. Anything
- * else will be stored as text/plain.
- */
- if (viewable.getMimeType().equalsIgnoreCase("text/html")) {
- sbHtml.append(text);
- } else {
- sbText.append(text);
- }
- } catch (Exception e) {
- throw new MessagingException("Unable to get text for message part", e);
- }
- }
-
- String text = sbText.toString();
- String html = markupContent(text, sbHtml.toString());
String preview = calculateContentPreview(text);
- // If we couldn't generate a reasonable preview from the text part, try doing it with the HTML part.
- if (preview == null || preview.length() == 0) {
- preview = calculateContentPreview(HtmlConverter.htmlToText(html));
- }
try {
ContentValues cv = new ContentValues();
@@ -2222,6 +2226,7 @@ public class LocalStore extends Store implements Serializable {
return null;
}
});
+ return uidMap;
} catch (WrappedException e) {
throw(MessagingException) e.getCause();
}
@@ -2244,49 +2249,17 @@ public class LocalStore extends Store implements Serializable {
@Override
public Void doDbWork(final SQLiteDatabase db) throws WrappedException, UnavailableStorageException {
try {
- ArrayList viewables = new ArrayList();
- ArrayList attachments = new ArrayList();
-
message.buildMimeRepresentation();
- MimeUtility.collectParts(message, viewables, attachments);
+ ViewableContainer container =
+ MimeUtility.extractTextAndAttachments(mApplication, message);
- StringBuilder sbHtml = new StringBuilder();
- StringBuilder sbText = new StringBuilder();
- for (int i = 0, count = viewables.size(); i < count; i++) {
- Part viewable = viewables.get(i);
- try {
- String text = MimeUtility.getTextFromPart(viewable);
+ List attachments = container.attachments;
+ String text = container.text;
+ String html = HtmlConverter.convertEmoji2Img(container.html);
- /*
- * Small hack to make sure the string "null" doesn't end up
- * in one of the StringBuilders.
- */
- if (text == null) {
- text = "";
- }
-
- /*
- * Anything with MIME type text/html will be stored as such. Anything
- * else will be stored as text/plain.
- */
- if (viewable.getMimeType().equalsIgnoreCase("text/html")) {
- sbHtml.append(text);
- } else {
- sbText.append(text);
- }
- } catch (Exception e) {
- throw new MessagingException("Unable to get text for message part", e);
- }
- }
-
- String text = sbText.toString();
- String html = markupContent(text, sbHtml.toString());
String preview = calculateContentPreview(text);
- // If we couldn't generate a reasonable preview from the text part, try doing it with the HTML part.
- if (preview == null || preview.length() == 0) {
- preview = calculateContentPreview(HtmlConverter.htmlToText(html));
- }
+
try {
db.execSQL("UPDATE messages SET "
+ "uid = ?, subject = ?, sender_list = ?, date = ?, flags = ?, "
@@ -2420,6 +2393,18 @@ public class LocalStore extends Store implements Serializable {
Body body = attachment.getBody();
if (body instanceof LocalAttachmentBody) {
contentUri = ((LocalAttachmentBody) body).getContentUri();
+ } else if (body instanceof Message) {
+ // It's a message, so use Message.writeTo() to output the
+ // message including all children.
+ Message message = (Message) body;
+ tempAttachmentFile = File.createTempFile("att", null, attachmentDirectory);
+ FileOutputStream out = new FileOutputStream(tempAttachmentFile);
+ try {
+ message.writeTo(out);
+ } finally {
+ out.close();
+ }
+ size = (int) (tempAttachmentFile.length() & 0x7FFFFFFFL);
} else {
/*
* If the attachment has a body we're expected to save it into the local store
@@ -2647,7 +2632,7 @@ public class LocalStore extends Store implements Serializable {
setVisibleLimit(mAccount.getDisplayCount());
}
- private void resetUnreadAndFlaggedCounts() {
+ public void resetUnreadAndFlaggedCounts() {
try {
int newUnread = 0;
int newFlagged = 0;
@@ -2718,22 +2703,34 @@ public class LocalStore extends Store implements Serializable {
public Void doDbWork(final SQLiteDatabase db) throws WrappedException, UnavailableStorageException {
Cursor attachmentsCursor = null;
try {
- attachmentsCursor = db.query("attachments", new String[]
- { "id" }, "message_id = ?", new String[]
- { Long.toString(messageId) }, null, null, null);
+ String accountUuid = mAccount.getUuid();
+ Context context = mApplication;
+
+ // Get attachment IDs
+ String[] whereArgs = new String[] { Long.toString(messageId) };
+ attachmentsCursor = db.query("attachments", new String[] { "id" },
+ "message_id = ?", whereArgs, null, null, null);
+
final File attachmentDirectory = StorageManager.getInstance(mApplication)
- .getAttachmentDirectory(uUid, database.getStorageProviderId());
+ .getAttachmentDirectory(uUid, database.getStorageProviderId());
+
while (attachmentsCursor.moveToNext()) {
- long attachmentId = attachmentsCursor.getLong(0);
+ String attachmentId = Long.toString(attachmentsCursor.getLong(0));
try {
- File file = new File(attachmentDirectory, Long.toString(attachmentId));
+ // Delete stored attachment
+ File file = new File(attachmentDirectory, attachmentId);
if (file.exists()) {
file.delete();
}
- } catch (Exception e) {
- }
+ // Delete thumbnail file
+ AttachmentProvider.deleteThumbnail(context, accountUuid,
+ attachmentId);
+ } catch (Exception e) { /* ignore */ }
}
+
+ // Delete attachment metadata from the database
+ db.delete("attachments", "message_id = ?", whereArgs);
} finally {
Utility.closeQuietly(attachmentsCursor);
}
@@ -2817,17 +2814,7 @@ public class LocalStore extends Store implements Serializable {
}
}
-
- public String markupContent(String text, String html) {
- if (text.length() > 0 && html.length() == 0) {
- html = HtmlConverter.textToHtml(text);
- }
-
- html = HtmlConverter.convertEmoji2Img(html);
-
- return html;
- }
-
+
@Override
public boolean isInTopGroup() {
return mInTopGroup;
diff --git a/src/com/fsck/k9/mail/store/Pop3Store.java b/src/com/fsck/k9/mail/store/Pop3Store.java
index d1d00dba9..b9e9a3b23 100644
--- a/src/com/fsck/k9/mail/store/Pop3Store.java
+++ b/src/com/fsck/k9/mail/store/Pop3Store.java
@@ -24,6 +24,7 @@ import java.util.LinkedList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
+import java.util.Map;
public class Pop3Store extends Store {
public static final String STORE_TYPE = "POP3";
@@ -893,7 +894,8 @@ public class Pop3Store extends Store {
}
@Override
- public void appendMessages(Message[] messages) throws MessagingException {
+ public Map appendMessages(Message[] messages) throws MessagingException {
+ return null;
}
@Override
diff --git a/src/com/fsck/k9/mail/store/WebDavStore.java b/src/com/fsck/k9/mail/store/WebDavStore.java
index 01aa87b47..ed269cb7e 100644
--- a/src/com/fsck/k9/mail/store/WebDavStore.java
+++ b/src/com/fsck/k9/mail/store/WebDavStore.java
@@ -1333,13 +1333,15 @@ public class WebDavStore extends Store {
}
@Override
- public void copyMessages(Message[] messages, Folder folder) throws MessagingException {
+ public Map copyMessages(Message[] messages, Folder folder) throws MessagingException {
moveOrCopyMessages(messages, folder.getRemoteName(), false);
+ return null;
}
@Override
- public void moveMessages(Message[] messages, Folder folder) throws MessagingException {
+ public Map moveMessages(Message[] messages, Folder folder) throws MessagingException {
moveOrCopyMessages(messages, folder.getRemoteName(), true);
+ return null;
}
@Override
@@ -1919,8 +1921,9 @@ public class WebDavStore extends Store {
}
@Override
- public void appendMessages(Message[] messages) throws MessagingException {
+ public Map appendMessages(Message[] messages) throws MessagingException {
appendWebDavMessages(messages);
+ return null;
}
public Message[] appendWebDavMessages(Message[] messages) throws MessagingException {
diff --git a/src/com/fsck/k9/mail/store/imap/ImapUtility.java b/src/com/fsck/k9/mail/store/imap/ImapUtility.java
new file mode 100644
index 000000000..d0ac2b31a
--- /dev/null
+++ b/src/com/fsck/k9/mail/store/imap/ImapUtility.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright (C) 2012 The K-9 Dog Walkers
+ * Copyright (C) 2011 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.fsck.k9.mail.store.imap;
+
+import android.util.Log;
+
+import com.fsck.k9.K9;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Utility methods for use with IMAP.
+ */
+public class ImapUtility {
+ /**
+ * Gets all of the values in a sequence set per RFC 3501.
+ *
+ *
+ * Any ranges are expanded into a list of individual numbers.
+ *
+ *
+ *
+ * sequence-number = nz-number / "*"
+ * sequence-range = sequence-number ":" sequence-number
+ * sequence-set = (sequence-number / sequence-range) *("," sequence-set)
+ *
+ *
+ * @param set
+ * The sequence set string as received by the server.
+ *
+ * @return The list of IDs as strings in this sequence set. If the set is invalid, an empty
+ * list is returned.
+ */
+ public static List getImapSequenceValues(String set) {
+ ArrayList list = new ArrayList();
+ if (set != null) {
+ String[] setItems = set.split(",");
+ for (String item : setItems) {
+ if (item.indexOf(':') == -1) {
+ // simple item
+ try {
+ Integer.parseInt(item); // Don't need the value; just ensure it's valid
+ list.add(item);
+ } catch (NumberFormatException e) {
+ Log.d(K9.LOG_TAG, "Invalid UID value", e);
+ }
+ } else {
+ // range
+ list.addAll(getImapRangeValues(item));
+ }
+ }
+ }
+
+ return list;
+ }
+
+ /**
+ * Expand the given number range into a list of individual numbers.
+ *
+ *
+ * sequence-number = nz-number / "*"
+ * sequence-range = sequence-number ":" sequence-number
+ * sequence-set = (sequence-number / sequence-range) *("," sequence-set)
+ *
+ *
+ * @param range
+ * The range string as received by the server.
+ *
+ * @return The list of IDs as strings in this range. If the range is not valid, an empty list
+ * is returned.
+ */
+ public static List getImapRangeValues(String range) {
+ ArrayList list = new ArrayList();
+ try {
+ if (range != null) {
+ int colonPos = range.indexOf(':');
+ if (colonPos > 0) {
+ int first = Integer.parseInt(range.substring(0, colonPos));
+ int second = Integer.parseInt(range.substring(colonPos + 1));
+ if (first < second) {
+ for (int i = first; i <= second; i++) {
+ list.add(Integer.toString(i));
+ }
+ } else {
+ for (int i = first; i >= second; i--) {
+ list.add(Integer.toString(i));
+ }
+ }
+ }
+ }
+ } catch (NumberFormatException e) {
+ Log.d(K9.LOG_TAG, "Invalid range value", e);
+ }
+
+ return list;
+ }
+}
diff --git a/src/com/fsck/k9/preferences/AccountSettings.java b/src/com/fsck/k9/preferences/AccountSettings.java
index fd7256268..abdf13c22 100644
--- a/src/com/fsck/k9/preferences/AccountSettings.java
+++ b/src/com/fsck/k9/preferences/AccountSettings.java
@@ -12,7 +12,6 @@ import com.fsck.k9.Account;
import com.fsck.k9.K9;
import com.fsck.k9.R;
import com.fsck.k9.Account.FolderMode;
-import com.fsck.k9.Account.ScrollButtons;
import com.fsck.k9.crypto.Apg;
import com.fsck.k9.mail.store.StorageManager;
import com.fsck.k9.preferences.Settings.*;
@@ -82,12 +81,6 @@ public class AccountSettings {
s.put("goToUnreadMessageSearch", Settings.versions(
new V(1, new BooleanSetting(false))
));
- s.put("hideButtonsEnum", Settings.versions(
- new V(1, new EnumSetting(ScrollButtons.class, ScrollButtons.NEVER))
- ));
- s.put("hideMoveButtonsEnum", Settings.versions(
- new V(1, new EnumSetting(ScrollButtons.class, ScrollButtons.NEVER))
- ));
s.put("idleRefreshMinutes", Settings.versions(
new V(1, new IntegerResourceSetting(24, R.array.idle_refresh_period_values))
));
diff --git a/src/com/fsck/k9/preferences/Settings.java b/src/com/fsck/k9/preferences/Settings.java
index c821c01cb..fd220c8d4 100644
--- a/src/com/fsck/k9/preferences/Settings.java
+++ b/src/com/fsck/k9/preferences/Settings.java
@@ -35,7 +35,7 @@ public class Settings {
*
* @see SettingsExporter
*/
- public static final int VERSION = 5;
+ public static final int VERSION = 6;
public static Map validate(int version, Map> settings,
diff --git a/src/com/fsck/k9/provider/AttachmentProvider.java b/src/com/fsck/k9/provider/AttachmentProvider.java
index 542beab00..ec81e30ba 100644
--- a/src/com/fsck/k9/provider/AttachmentProvider.java
+++ b/src/com/fsck/k9/provider/AttachmentProvider.java
@@ -23,8 +23,12 @@ import java.io.*;
import java.util.List;
/**
- * A simple ContentProvider that allows file access to Email's attachments.
- * Warning! We make heavy assumptions about the Uris used by the {@link LocalStore} for an {@link Account} here.
+ * A simple ContentProvider that allows file access to attachments.
+ *
+ *
+ * Warning! We make heavy assumptions about the Uris used by the {@link LocalStore} for an
+ * {@link Account} here.
+ *
*/
public class AttachmentProvider extends ContentProvider {
public static final Uri CONTENT_URI = Uri.parse("content://com.fsck.k9.attachmentprovider");
@@ -33,6 +37,11 @@ public class AttachmentProvider extends ContentProvider {
private static final String FORMAT_VIEW = "VIEW";
private static final String FORMAT_THUMBNAIL = "THUMBNAIL";
+ private static final String[] DEFAULT_PROJECTION = new String[] {
+ AttachmentProviderColumns._ID,
+ AttachmentProviderColumns.DATA,
+ };
+
public static class AttachmentProviderColumns {
public static final String _ID = "_id";
public static final String DATA = "_data";
@@ -40,6 +49,7 @@ public class AttachmentProvider extends ContentProvider {
public static final String SIZE = "_size";
}
+
public static Uri getAttachmentUri(Account account, long id) {
return getAttachmentUri(account.getUuid(), id, true);
}
@@ -66,6 +76,47 @@ public class AttachmentProvider extends ContentProvider {
.build();
}
+ public static void clear(Context context) {
+ /*
+ * We use the cache dir as a temporary directory (since Android doesn't give us one) so
+ * on startup we'll clean up any .tmp files from the last run.
+ */
+ File[] files = context.getCacheDir().listFiles();
+ for (File file : files) {
+ try {
+ if (K9.DEBUG) {
+ Log.d(K9.LOG_TAG, "Deleting file " + file.getCanonicalPath());
+ }
+ } catch (IOException ioe) { /* No need to log failure to log */ }
+ file.delete();
+ }
+ }
+
+ /**
+ * Delete the thumbnail of an attachment.
+ *
+ * @param context
+ * The application context.
+ * @param accountUuid
+ * The UUID of the account the attachment belongs to.
+ * @param attachmentId
+ * The ID of the attachment the thumbnail was created for.
+ */
+ public static void deleteThumbnail(Context context, String accountUuid, String attachmentId) {
+ File file = getThumbnailFile(context, accountUuid, attachmentId);
+ if (file.exists()) {
+ file.delete();
+ }
+ }
+
+ private static File getThumbnailFile(Context context, String accountUuid,
+ String attachmentId) {
+ String filename = "thmb_" + accountUuid + "_" + attachmentId + ".tmp";
+ File dir = context.getCacheDir();
+ return new File(dir, filename);
+ }
+
+
@Override
public boolean onCreate() {
/*
@@ -89,21 +140,6 @@ public class AttachmentProvider extends ContentProvider {
return true;
}
- public static void clear(Context lContext) {
- /*
- * We use the cache dir as a temporary directory (since Android doesn't give us one) so
- * on startup we'll clean up any .tmp files from the last run.
- */
- File[] files = lContext.getCacheDir().listFiles();
- for (File file : files) {
- try {
- if (K9.DEBUG)
- Log.d(K9.LOG_TAG, "Deleting file " + file.getCanonicalPath());
- } catch (IOException ioe) {} // No need to log failure to log
- file.delete();
- }
- }
-
@Override
public String getType(Uri uri) {
List segments = uri.getPathSegments();
@@ -114,67 +150,24 @@ public class AttachmentProvider extends ContentProvider {
return getType(dbName, id, format);
}
- private String getType(String dbName, String id, String format) {
- if (FORMAT_THUMBNAIL.equals(format)) {
- return "image/png";
- } else {
- final Account account = Preferences.getPreferences(getContext()).getAccount(dbName);
-
- try {
- final LocalStore localStore = LocalStore.getLocalInstance(account, K9.app);
-
- AttachmentInfo attachmentInfo = localStore.getAttachmentInfo(id);
- if (FORMAT_VIEW.equals(format)) {
- return MimeUtility.getMimeTypeForViewing(attachmentInfo.type, attachmentInfo.name);
- } else {
- // When accessing the "raw" message we deliver the original MIME type.
- return attachmentInfo.type;
- }
- } catch (MessagingException e) {
- Log.e(K9.LOG_TAG, "Unable to retrieve LocalStore for " + account, e);
- return null;
- }
- }
- }
-
- private File getFile(String dbName, String id)
- throws FileNotFoundException {
- try {
- final Account account = Preferences.getPreferences(getContext()).getAccount(dbName);
- final File attachmentsDir;
- attachmentsDir = StorageManager.getInstance(K9.app).getAttachmentDirectory(dbName,
- account.getLocalStorageProviderId());
- final File file = new File(attachmentsDir, id);
- if (!file.exists()) {
- throw new FileNotFoundException(file.getAbsolutePath());
- }
- return file;
- } catch (IOException e) {
- Log.w(K9.LOG_TAG, null, e);
- throw new FileNotFoundException(e.getMessage());
- }
- }
-
@Override
public ParcelFileDescriptor openFile(Uri uri, String mode) throws FileNotFoundException {
+ File file;
+
List segments = uri.getPathSegments();
- String dbName = segments.get(0); // "/sdcard/..." is URL-encoded and makes up only 1 segment
- String id = segments.get(1);
+ String accountUuid = segments.get(0);
+ String attachmentId = segments.get(1);
String format = segments.get(2);
+
if (FORMAT_THUMBNAIL.equals(format)) {
int width = Integer.parseInt(segments.get(3));
int height = Integer.parseInt(segments.get(4));
- String filename = "thmb_" + dbName + "_" + id + ".tmp";
- int index = dbName.lastIndexOf('/');
- if (index >= 0) {
- filename = /*dbName.substring(0, index + 1) + */"thmb_" + dbName.substring(index + 1) + "_" + id + ".tmp";
- }
- File dir = getContext().getCacheDir();
- File file = new File(dir, filename);
+
+ file = getThumbnailFile(getContext(), accountUuid, attachmentId);
if (!file.exists()) {
- String type = getType(dbName, id, FORMAT_VIEW);
+ String type = getType(accountUuid, attachmentId, FORMAT_VIEW);
try {
- FileInputStream in = new FileInputStream(getFile(dbName, id));
+ FileInputStream in = new FileInputStream(getFile(accountUuid, attachmentId));
try {
Bitmap thumbnail = createThumbnail(type, in);
if (thumbnail != null) {
@@ -187,40 +180,24 @@ public class AttachmentProvider extends ContentProvider {
}
}
} finally {
- try { in.close(); } catch (Throwable ignore) {}
+ try { in.close(); } catch (Throwable ignore) { /* ignore */ }
}
} catch (IOException ioe) {
return null;
}
}
- return ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY);
} else {
- return ParcelFileDescriptor.open(
- getFile(dbName, id),
- ParcelFileDescriptor.MODE_READ_ONLY);
+ file = getFile(accountUuid, attachmentId);
}
- }
- @Override
- public int delete(Uri uri, String arg1, String[] arg2) {
- return 0;
- }
-
- @Override
- public Uri insert(Uri uri, ContentValues values) {
- return null;
+ return ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY);
}
@Override
public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
String sortOrder) {
- if (projection == null) {
- projection =
- new String[] {
- AttachmentProviderColumns._ID,
- AttachmentProviderColumns.DATA,
- };
- }
+
+ String[] columnNames = (projection == null) ? DEFAULT_PROJECTION : projection;
List segments = uri.getPathSegments();
String dbName = segments.get(0);
@@ -232,7 +209,6 @@ public class AttachmentProvider extends ContentProvider {
dbName = dbName.substring(0, dbName.length() - 3);
}
- //String format = segments.get(2);
final AttachmentInfo attachmentInfo;
try {
final Account account = Preferences.getPreferences(getContext()).getAccount(dbName);
@@ -242,10 +218,10 @@ public class AttachmentProvider extends ContentProvider {
return null;
}
- MatrixCursor ret = new MatrixCursor(projection);
- Object[] values = new Object[projection.length];
- for (int i = 0, count = projection.length; i < count; i++) {
- String column = projection[i];
+ MatrixCursor ret = new MatrixCursor(columnNames);
+ Object[] values = new Object[columnNames.length];
+ for (int i = 0, count = columnNames.length; i < count; i++) {
+ String column = columnNames[i];
if (AttachmentProviderColumns._ID.equals(column)) {
values[i] = id;
} else if (AttachmentProviderColumns.DATA.equals(column)) {
@@ -265,6 +241,56 @@ public class AttachmentProvider extends ContentProvider {
return 0;
}
+ @Override
+ public int delete(Uri uri, String arg1, String[] arg2) {
+ return 0;
+ }
+
+ @Override
+ public Uri insert(Uri uri, ContentValues values) {
+ return null;
+ }
+
+ private String getType(String dbName, String id, String format) {
+ String type;
+ if (FORMAT_THUMBNAIL.equals(format)) {
+ type = "image/png";
+ } else {
+ final Account account = Preferences.getPreferences(getContext()).getAccount(dbName);
+
+ try {
+ final LocalStore localStore = LocalStore.getLocalInstance(account, K9.app);
+
+ AttachmentInfo attachmentInfo = localStore.getAttachmentInfo(id);
+ if (FORMAT_VIEW.equals(format)) {
+ type = MimeUtility.getMimeTypeForViewing(attachmentInfo.type, attachmentInfo.name);
+ } else {
+ // When accessing the "raw" message we deliver the original MIME type.
+ type = attachmentInfo.type;
+ }
+ } catch (MessagingException e) {
+ Log.e(K9.LOG_TAG, "Unable to retrieve LocalStore for " + account, e);
+ type = null;
+ }
+ }
+
+ return type;
+ }
+
+ private File getFile(String dbName, String id) throws FileNotFoundException {
+ Account account = Preferences.getPreferences(getContext()).getAccount(dbName);
+
+ File attachmentsDir = StorageManager.getInstance(K9.app).getAttachmentDirectory(dbName,
+ account.getLocalStorageProviderId());
+
+ File file = new File(attachmentsDir, id);
+ if (!file.exists()) {
+ throw new FileNotFoundException(file.getAbsolutePath());
+ }
+
+ return file;
+ }
+
private Bitmap createThumbnail(String type, InputStream data) {
if (MimeUtility.mimeTypeMatches(type, "image/*")) {
return createImageThumbnail(data);
diff --git a/src/com/fsck/k9/provider/MessageProvider.java b/src/com/fsck/k9/provider/MessageProvider.java
index 518f976cf..6b42e2b53 100644
--- a/src/com/fsck/k9/provider/MessageProvider.java
+++ b/src/com/fsck/k9/provider/MessageProvider.java
@@ -245,7 +245,7 @@ public class MessageProvider extends ContentProvider {
final BlockingQueue> queue = new SynchronousQueue>();
// new code for integrated inbox, only execute this once as it will be processed afterwards via the listener
- final SearchAccount integratedInboxAccount = new SearchAccount(getContext(), true, null, null);
+ final SearchAccount integratedInboxAccount = SearchAccount.createUnifiedInboxAccount(getContext());
final MessagingController msgController = MessagingController.getInstance(K9.app);
msgController.searchLocalMessages(integratedInboxAccount, null,
diff --git a/src/com/fsck/k9/provider/UnreadWidgetProvider.java b/src/com/fsck/k9/provider/UnreadWidgetProvider.java
new file mode 100644
index 000000000..616707c34
--- /dev/null
+++ b/src/com/fsck/k9/provider/UnreadWidgetProvider.java
@@ -0,0 +1,127 @@
+package com.fsck.k9.provider;
+
+import com.fsck.k9.Account;
+import com.fsck.k9.AccountStats;
+import com.fsck.k9.K9;
+import com.fsck.k9.Preferences;
+import com.fsck.k9.R;
+import com.fsck.k9.activity.UnreadWidgetConfiguration;
+import com.fsck.k9.activity.FolderList;
+import com.fsck.k9.activity.MessageList;
+
+import android.app.PendingIntent;
+import android.appwidget.AppWidgetManager;
+import android.appwidget.AppWidgetProvider;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.util.Log;
+import android.view.View;
+import android.widget.RemoteViews;
+
+public class UnreadWidgetProvider extends AppWidgetProvider {
+ private static final int MAX_COUNT = 9999;
+
+ /**
+ * Trigger update for all of our unread widgets.
+ *
+ * @param context
+ * The {@code Context} object to use for the broadcast intent.
+ */
+ public static void updateUnreadCount(Context context) {
+ Context appContext = context.getApplicationContext();
+ AppWidgetManager appWidgetManager = AppWidgetManager.getInstance(appContext);
+
+ ComponentName thisWidget = new ComponentName(appContext, UnreadWidgetProvider.class);
+ int[] widgetIds = appWidgetManager.getAppWidgetIds(thisWidget);
+
+ Intent intent = new Intent(context, UnreadWidgetProvider.class);
+ intent.setAction(AppWidgetManager.ACTION_APPWIDGET_UPDATE);
+ intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS, widgetIds);
+
+ context.sendBroadcast(intent);
+ }
+
+ public static void updateWidget(Context context, AppWidgetManager appWidgetManager,
+ int appWidgetId, String accountUuid) {
+
+ RemoteViews remoteViews = new RemoteViews(context.getPackageName(),
+ R.layout.unread_widget_layout);
+
+ int unreadCount = 0;
+ String accountName = context.getString(R.string.app_name);
+ Intent clickIntent = null;
+ try {
+ Account account = Preferences.getPreferences(context).getAccount(accountUuid);
+ if (account != null) {
+ AccountStats stats = new AccountStats();
+ account.getLocalStore().getMessageCounts(stats);
+ unreadCount = stats.unreadMessageCount;
+ accountName = account.getDescription();
+ if (K9.FOLDER_NONE.equals(account.getAutoExpandFolderName())) {
+ clickIntent = FolderList.actionHandleAccountIntent(context, account, null);
+ } else {
+ clickIntent = MessageList.actionHandleFolderIntent(context, account,
+ account.getAutoExpandFolderName());
+ }
+ clickIntent.addFlags(Intent.FLAG_ACTIVITY_REORDER_TO_FRONT);
+ }
+ } catch (Exception e) {
+ if (K9.DEBUG) {
+ Log.e(K9.LOG_TAG, "Error getting widget configuration", e);
+ }
+ }
+
+ if (unreadCount <= 0) {
+ // Hide TextView for unread count if there are no unread messages.
+ remoteViews.setViewVisibility(R.id.unread_count, View.GONE);
+ } else {
+ remoteViews.setViewVisibility(R.id.unread_count, View.VISIBLE);
+
+ String displayCount = (unreadCount <= MAX_COUNT) ?
+ String.valueOf(unreadCount) : String.valueOf(MAX_COUNT) + "+";
+ remoteViews.setTextViewText(R.id.unread_count, displayCount);
+ }
+
+ remoteViews.setTextViewText(R.id.account_name, accountName);
+
+ if (clickIntent == null) {
+ // If the widget configuration couldn't be loaded we open the configuration
+ // activity when the user clicks the widget.
+ clickIntent = new Intent(context, UnreadWidgetConfiguration.class);
+ clickIntent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetId);
+ }
+ clickIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+
+
+ PendingIntent pendingIntent = PendingIntent.getActivity(context, appWidgetId,
+ clickIntent, 0);
+
+ remoteViews.setOnClickPendingIntent(R.id.unread_widget_layout, pendingIntent);
+
+ appWidgetManager.updateAppWidget(appWidgetId, remoteViews);
+ }
+
+
+ /**
+ * Called when one or more widgets need to be updated.
+ */
+ @Override
+ public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
+ for (int widgetId : appWidgetIds) {
+ String accountUuid = UnreadWidgetConfiguration.getAccountUuid(context, widgetId);
+
+ updateWidget(context, appWidgetManager, widgetId, accountUuid);
+ }
+ }
+
+ /**
+ * Called when a widget instance is deleted.
+ */
+ @Override
+ public void onDeleted(Context context, int[] appWidgetIds) {
+ for (int appWidgetId : appWidgetIds) {
+ UnreadWidgetConfiguration.deleteWidgetConfiguration(context, appWidgetId);
+ }
+ }
+}
diff --git a/src/com/fsck/k9/view/AttachmentView.java b/src/com/fsck/k9/view/AttachmentView.java
index 9e9a4c441..5eccda9eb 100644
--- a/src/com/fsck/k9/view/AttachmentView.java
+++ b/src/com/fsck/k9/view/AttachmentView.java
@@ -18,6 +18,8 @@ import android.os.Environment;
import android.util.AttributeSet;
import android.util.Log;
import android.view.View;
+import android.view.View.OnClickListener;
+import android.view.View.OnLongClickListener;
import android.widget.Button;
import android.widget.FrameLayout;
import android.widget.ImageView;
@@ -33,12 +35,34 @@ import com.fsck.k9.helper.MediaScannerNotifier;
import com.fsck.k9.helper.SizeFormatter;
import com.fsck.k9.helper.Utility;
import com.fsck.k9.mail.Message;
+import com.fsck.k9.mail.MessagingException;
import com.fsck.k9.mail.Part;
+import com.fsck.k9.mail.internet.MimeHeader;
import com.fsck.k9.mail.internet.MimeUtility;
import com.fsck.k9.mail.store.LocalStore.LocalAttachmentBodyPart;
import com.fsck.k9.provider.AttachmentProvider;
-public class AttachmentView extends FrameLayout {
+public class AttachmentView extends FrameLayout implements OnClickListener, OnLongClickListener {
+ /**
+ * Regular expression that represents characters we won't allow in file names.
+ *
+ *
+ * Allowed are:
+ *
+ * - word characters (letters, digits, and underscores): {@code \w}
+ * - spaces: {@code " "}
+ * - special characters: {@code !}, {@code #}, {@code $}, {@code %}, {@code &}, {@code '},
+ * {@code (}, {@code )}, {@code -}, {@code @}, {@code ^}, {@code `},
{,
+ * }, {@code ~}, {@code .}, {@code ,}
+ *
+ */
+ private static final String INVALID_CHARACTERS = "[^\\w !#$%&'()\\-@\\^`{}~.,]+";
+
+ /**
+ * Invalid characters in a file name are replaced by this character.
+ */
+ private static final String REPLACEMENT_CHARACTER = "_";
+
private Context mContext;
public Button viewButton;
@@ -81,86 +105,125 @@ public class AttachmentView extends FrameLayout {
*/
public void showFileBrowser(AttachmentView caller);
}
- public boolean populateFromPart(Part inputPart, Message message, Account account, MessagingController controller, MessagingListener listener) {
- try {
- part = (LocalAttachmentBodyPart) inputPart;
- contentType = MimeUtility.unfoldAndDecode(part.getContentType());
- String contentDisposition = MimeUtility.unfoldAndDecode(part.getDisposition());
+ /**
+ * Populates this view with information about the attachment.
+ *
+ *
+ * This method also decides which attachments are displayed when the "show attachments" button
+ * is pressed, and which attachments are only displayed after the "show more attachments"
+ * button was pressed.
+ * Inline attachments with content ID and unnamed attachments fall into the second category.
+ *
+ *
+ * @param inputPart
+ * @param message
+ * @param account
+ * @param controller
+ * @param listener
+ *
+ * @return {@code true} for a regular attachment. {@code false}, otherwise.
+ *
+ * @throws MessagingException
+ * In case of an error
+ */
+ public boolean populateFromPart(Part inputPart, Message message, Account account,
+ MessagingController controller, MessagingListener listener) throws MessagingException {
+ boolean firstClassAttachment = true;
+ part = (LocalAttachmentBodyPart) inputPart;
- name = MimeUtility.getHeaderParameter(contentType, "name");
- if (name == null) {
- name = MimeUtility.getHeaderParameter(contentDisposition, "filename");
- }
- if (name == null) {
- return false;
- }
+ contentType = MimeUtility.unfoldAndDecode(part.getContentType());
+ String contentDisposition = MimeUtility.unfoldAndDecode(part.getDisposition());
- mAccount = account;
- mMessage = message;
- mController = controller;
- mListener = listener;
-
- size = Integer.parseInt(MimeUtility.getHeaderParameter(contentDisposition, "size"));
- contentType = MimeUtility.getMimeTypeForViewing(part.getMimeType(), name);
- TextView attachmentName = (TextView) findViewById(R.id.attachment_name);
- TextView attachmentInfo = (TextView) findViewById(R.id.attachment_info);
- ImageView attachmentIcon = (ImageView) findViewById(R.id.attachment_icon);
- viewButton = (Button) findViewById(R.id.view);
- downloadButton = (Button) findViewById(R.id.download);
- if ((!MimeUtility.mimeTypeMatches(contentType, K9.ACCEPTABLE_ATTACHMENT_VIEW_TYPES))
- || (MimeUtility.mimeTypeMatches(contentType, K9.UNACCEPTABLE_ATTACHMENT_VIEW_TYPES))) {
- viewButton.setVisibility(View.GONE);
- }
- if ((!MimeUtility.mimeTypeMatches(contentType, K9.ACCEPTABLE_ATTACHMENT_DOWNLOAD_TYPES))
- || (MimeUtility.mimeTypeMatches(contentType, K9.UNACCEPTABLE_ATTACHMENT_DOWNLOAD_TYPES))) {
- downloadButton.setVisibility(View.GONE);
- }
- if (size > K9.MAX_ATTACHMENT_DOWNLOAD_SIZE) {
- viewButton.setVisibility(View.GONE);
- downloadButton.setVisibility(View.GONE);
- }
-
- viewButton.setOnClickListener(new OnClickListener() {
- @Override
- public void onClick(View v) {
- onViewButtonClicked();
- return;
- }
- });
-
-
- downloadButton.setOnClickListener(new OnClickListener() {
- @Override
- public void onClick(View v) {
- onSaveButtonClicked();
- return;
- }
- });
- downloadButton.setOnLongClickListener(new OnLongClickListener() {
-
- @Override
- public boolean onLongClick(View v) {
- callback.showFileBrowser(AttachmentView.this);
- return true;
- }
- });
-
- attachmentName.setText(name);
- attachmentInfo.setText(SizeFormatter.formatSize(mContext, size));
- Bitmap previewIcon = getPreviewIcon();
- if (previewIcon != null) {
- attachmentIcon.setImageBitmap(previewIcon);
- } else {
- attachmentIcon.setImageResource(R.drawable.attached_image_placeholder);
- }
+ name = MimeUtility.getHeaderParameter(contentType, "name");
+ if (name == null) {
+ name = MimeUtility.getHeaderParameter(contentDisposition, "filename");
}
- catch (Exception e) {
- Log.e(K9.LOG_TAG, "error ", e);
+ if (name == null) {
+ firstClassAttachment = false;
+ String extension = MimeUtility.getExtensionByMimeType(contentType);
+ name = "noname" + ((extension != null) ? "." + extension : "");
}
- return true;
+ // Inline parts with a content-id are almost certainly components of an HTML message
+ // not attachments. Only show them if the user pressed the button to show more
+ // attachments.
+ if (contentDisposition != null &&
+ MimeUtility.getHeaderParameter(contentDisposition, null).matches("^(?i:inline)")
+ && part.getHeader(MimeHeader.HEADER_CONTENT_ID) != null) {
+ firstClassAttachment = false;
+ }
+
+ mAccount = account;
+ mMessage = message;
+ mController = controller;
+ mListener = listener;
+
+ String sizeParam = MimeUtility.getHeaderParameter(contentDisposition, "size");
+ if (sizeParam != null) {
+ try {
+ size = Integer.parseInt(sizeParam);
+ } catch (NumberFormatException e) { /* ignore */ }
+ }
+
+ contentType = MimeUtility.getMimeTypeForViewing(part.getMimeType(), name);
+ TextView attachmentName = (TextView) findViewById(R.id.attachment_name);
+ TextView attachmentInfo = (TextView) findViewById(R.id.attachment_info);
+ ImageView attachmentIcon = (ImageView) findViewById(R.id.attachment_icon);
+ viewButton = (Button) findViewById(R.id.view);
+ downloadButton = (Button) findViewById(R.id.download);
+ if ((!MimeUtility.mimeTypeMatches(contentType, K9.ACCEPTABLE_ATTACHMENT_VIEW_TYPES))
+ || (MimeUtility.mimeTypeMatches(contentType, K9.UNACCEPTABLE_ATTACHMENT_VIEW_TYPES))) {
+ viewButton.setVisibility(View.GONE);
+ }
+ if ((!MimeUtility.mimeTypeMatches(contentType, K9.ACCEPTABLE_ATTACHMENT_DOWNLOAD_TYPES))
+ || (MimeUtility.mimeTypeMatches(contentType, K9.UNACCEPTABLE_ATTACHMENT_DOWNLOAD_TYPES))) {
+ downloadButton.setVisibility(View.GONE);
+ }
+ if (size > K9.MAX_ATTACHMENT_DOWNLOAD_SIZE) {
+ viewButton.setVisibility(View.GONE);
+ downloadButton.setVisibility(View.GONE);
+ }
+
+ viewButton.setOnClickListener(this);
+ downloadButton.setOnClickListener(this);
+ downloadButton.setOnLongClickListener(this);
+
+ attachmentName.setText(name);
+ attachmentInfo.setText(SizeFormatter.formatSize(mContext, size));
+ Bitmap previewIcon = getPreviewIcon();
+ if (previewIcon != null) {
+ attachmentIcon.setImageBitmap(previewIcon);
+ } else {
+ attachmentIcon.setImageResource(R.drawable.attached_image_placeholder);
+ }
+
+ return firstClassAttachment;
+ }
+
+ @Override
+ public void onClick(View view) {
+ switch (view.getId()) {
+ case R.id.view: {
+ onViewButtonClicked();
+ break;
+ }
+ case R.id.download: {
+ onSaveButtonClicked();
+ break;
+ }
+ }
+ }
+
+ @Override
+ public boolean onLongClick(View view) {
+ if (view.getId() == R.id.download) {
+ callback.showFileBrowser(this);
+ return true;
+ }
+
+ return false;
}
private Bitmap getPreviewIcon() {
@@ -196,7 +259,8 @@ public class AttachmentView extends FrameLayout {
*/
public void writeFile(File directory) {
try {
- File file = Utility.createUniqueFile(directory, name);
+ String filename = sanitizeFilename(name);
+ File file = Utility.createUniqueFile(directory, filename);
Uri uri = AttachmentProvider.getAttachmentUri(mAccount, part.getAttachmentId());
InputStream in = mContext.getContentResolver().openInputStream(uri);
OutputStream out = new FileOutputStream(file);
@@ -207,9 +271,25 @@ public class AttachmentView extends FrameLayout {
attachmentSaved(file.toString());
new MediaScannerNotifier(mContext, file);
} catch (IOException ioe) {
+ if (K9.DEBUG) {
+ Log.e(K9.LOG_TAG, "Error saving attachment", ioe);
+ }
attachmentNotSaved();
}
}
+
+ /**
+ * Replace characters we don't allow in file names with a replacement character.
+ *
+ * @param filename
+ * The original file name.
+ *
+ * @return The sanitized file name containing only allowed characters.
+ */
+ private String sanitizeFilename(String filename) {
+ return filename.replaceAll(INVALID_CHARACTERS, REPLACEMENT_CHARACTER);
+ }
+
/**
* saves the file to the defaultpath setting in the config, or if the config
* is not set => to the Environment
diff --git a/src/com/fsck/k9/view/MessageHeader.java b/src/com/fsck/k9/view/MessageHeader.java
index 371bc5905..a3f10afad 100644
--- a/src/com/fsck/k9/view/MessageHeader.java
+++ b/src/com/fsck/k9/view/MessageHeader.java
@@ -2,6 +2,8 @@ package com.fsck.k9.view;
import android.content.Context;
import android.graphics.Typeface;
+import android.os.Parcel;
+import android.os.Parcelable;
import android.text.SpannableString;
import android.text.SpannableStringBuilder;
import android.text.style.StyleSpan;
@@ -10,7 +12,10 @@ import android.util.AttributeSet;
import android.util.TypedValue;
import android.view.Gravity;
import android.view.View;
+import android.view.View.OnClickListener;
import android.widget.CheckBox;
+import android.widget.ImageView;
+import android.widget.ScrollView;
import android.widget.LinearLayout;
import android.widget.TextView;
import android.widget.Toast;
@@ -25,14 +30,14 @@ import com.fsck.k9.mail.Flag;
import com.fsck.k9.mail.Message;
import com.fsck.k9.mail.MessagingException;
import com.fsck.k9.mail.internet.MimeUtility;
-import com.fsck.k9.mail.store.LocalStore;
+
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
import java.text.DateFormat;
-public class MessageHeader extends LinearLayout {
+public class MessageHeader extends ScrollView implements OnClickListener {
private Context mContext;
private TextView mFromView;
private TextView mDateView;
@@ -44,17 +49,19 @@ public class MessageHeader extends LinearLayout {
private DateFormat mTimeFormat;
private View mChip;
+ private View mChip2;
private CheckBox mFlagged;
private int defaultSubjectColor;
private LinearLayout mToContainerView;
private LinearLayout mCcContainerView;
private TextView mAdditionalHeadersView;
- private View mAttachmentIcon;
private View mAnsweredIcon;
private Message mMessage;
private Account mAccount;
private FontSizes mFontSizes = K9.getFontSizes();
private Contacts mContacts;
+ private ImageView mShowAdditionalHeadersIcon;
+ private SavedState mSavedState;
/**
* Pair class is only available since API Level 5, so we need
@@ -79,7 +86,6 @@ public class MessageHeader extends LinearLayout {
}
private void initializeLayout() {
- mAttachmentIcon = findViewById(R.id.attachment);
mAnsweredIcon = findViewById(R.id.answered);
mFromView = (TextView) findViewById(R.id.from);
mToView = (TextView) findViewById(R.id.to);
@@ -89,17 +95,20 @@ public class MessageHeader extends LinearLayout {
mSubjectView = (TextView) findViewById(R.id.subject);
mAdditionalHeadersView = (TextView) findViewById(R.id.additional_headers_view);
mChip = findViewById(R.id.chip);
+ mChip2 = findViewById(R.id.chip2);
mDateView = (TextView) findViewById(R.id.date);
mTimeView = (TextView) findViewById(R.id.time);
mFlagged = (CheckBox) findViewById(R.id.flagged);
+ mShowAdditionalHeadersIcon = (ImageView) findViewById(R.id.show_additional_headers_icon);
+
defaultSubjectColor = mSubjectView.getCurrentTextColor();
mSubjectView.setTextSize(TypedValue.COMPLEX_UNIT_SP, mFontSizes.getMessageViewSubject());
mTimeView.setTextSize(TypedValue.COMPLEX_UNIT_SP, mFontSizes.getMessageViewTime());
mDateView.setTextSize(TypedValue.COMPLEX_UNIT_SP, mFontSizes.getMessageViewDate());
mAdditionalHeadersView.setTextSize(TypedValue.COMPLEX_UNIT_SP, mFontSizes.getMessageViewAdditionalHeaders());
- mAdditionalHeadersView.setVisibility(View.GONE);
- mAttachmentIcon.setVisibility(View.GONE);
+ hideAdditionalHeaders();
+
mAnsweredIcon.setVisibility(View.GONE);
mFromView.setTextSize(TypedValue.COMPLEX_UNIT_SP, mFontSizes.getMessageViewSender());
mToView.setTextSize(TypedValue.COMPLEX_UNIT_SP, mFontSizes.getMessageViewTo());
@@ -107,39 +116,45 @@ public class MessageHeader extends LinearLayout {
((TextView) findViewById(R.id.to_label)).setTextSize(TypedValue.COMPLEX_UNIT_SP, mFontSizes.getMessageViewTo());
((TextView) findViewById(R.id.cc_label)).setTextSize(TypedValue.COMPLEX_UNIT_SP, mFontSizes.getMessageViewCC());
- setOnClickListener(new OnClickListener() {
- @Override
- public void onClick(View v) {
- onShowAdditionalHeaders();
- }
- });
+ findViewById(R.id.show_additional_headers_area).setOnClickListener(this);
+ mFromView.setOnClickListener(this);
+ }
- mFromView.setOnClickListener(new OnClickListener() {
- @Override
- public void onClick(View v) {
- if (mMessage != null) {
- try {
- final Address senderEmail = mMessage.getFrom()[0];
- mContacts.createContact(senderEmail);
- } catch (Exception e) {
- Log.e(K9.LOG_TAG, "Couldn't create contact", e);
- }
- }
+ @Override
+ public void onClick(View view) {
+ switch (view.getId()) {
+ case R.id.show_additional_headers_area: {
+ onShowAdditionalHeaders();
+ break;
}
- });
+ case R.id.from: {
+ onAddSenderToContacts();
+ break;
+ }
+ }
+ }
+
+ private void onAddSenderToContacts() {
+ if (mMessage != null) {
+ try {
+ final Address senderEmail = mMessage.getFrom()[0];
+ mContacts.createContact(senderEmail);
+ } catch (Exception e) {
+ Log.e(K9.LOG_TAG, "Couldn't create contact", e);
+ }
+ }
}
public void setOnFlagListener(OnClickListener listener) {
+ if (mFlagged == null)
+ return;
mFlagged.setOnClickListener(listener);
}
public boolean additionalHeadersVisible() {
- if (mAdditionalHeadersView != null && mAdditionalHeadersView.getVisibility() == View.VISIBLE) {
- return true;
- } else {
- return false;
- }
+ return (mAdditionalHeadersView != null &&
+ mAdditionalHeadersView.getVisibility() == View.VISIBLE);
}
/**
@@ -149,7 +164,7 @@ public class MessageHeader extends LinearLayout {
private void hideAdditionalHeaders() {
mAdditionalHeadersView.setVisibility(View.GONE);
mAdditionalHeadersView.setText("");
-
+ mShowAdditionalHeadersIcon.setImageResource(R.drawable.show_more);
}
@@ -168,6 +183,7 @@ public class MessageHeader extends LinearLayout {
// Show the additional headers that we have got.
populateAdditionalHeadersView(additionalHeaders);
mAdditionalHeadersView.setVisibility(View.VISIBLE);
+ mShowAdditionalHeadersIcon.setImageResource(R.drawable.show_less);
}
if (!allHeadersDownloaded) {
/*
@@ -227,14 +243,25 @@ public class MessageHeader extends LinearLayout {
mToView.setText(to);
mCcContainerView.setVisibility((cc != null && cc.length() > 0) ? View.VISIBLE : View.GONE);
mCcView.setText(cc);
- mAttachmentIcon.setVisibility(((LocalStore.LocalMessage) message).hasAttachments() ? View.VISIBLE : View.GONE);
mAnsweredIcon.setVisibility(message.isSet(Flag.ANSWERED) ? View.VISIBLE : View.GONE);
mFlagged.setChecked(message.isSet(Flag.FLAGGED));
- mChip.setBackgroundDrawable(mAccount.generateColorChip().drawable());
- mChip.getBackground().setAlpha(!message.isSet(Flag.SEEN) ? 255 : 127);
+
+ int chipColor = mAccount.getChipColor();
+ int chipColorAlpha = (!message.isSet(Flag.SEEN)) ? 255 : 127;
+ mChip.setBackgroundColor(chipColor);
+ mChip.getBackground().setAlpha(chipColorAlpha);
+ mChip2.setBackgroundColor(chipColor);
+ mChip2.getBackground().setAlpha(chipColorAlpha);
+
setVisibility(View.VISIBLE);
- if (mAdditionalHeadersView.getVisibility() == View.VISIBLE) {
- showAdditionalHeaders();
+
+ if (mSavedState != null) {
+ if (mSavedState.additionalHeadersVisible) {
+ showAdditionalHeaders();
+ }
+ mSavedState = null;
+ } else {
+ hideAdditionalHeaders();
}
}
@@ -294,4 +321,61 @@ public class MessageHeader extends LinearLayout {
mAdditionalHeadersView.setText(sb);
}
+ @Override
+ public Parcelable onSaveInstanceState() {
+ Parcelable superState = super.onSaveInstanceState();
+
+ SavedState savedState = new SavedState(superState);
+
+ savedState.additionalHeadersVisible = additionalHeadersVisible();
+
+ return savedState;
+ }
+
+ @Override
+ public void onRestoreInstanceState(Parcelable state) {
+ if(!(state instanceof SavedState)) {
+ super.onRestoreInstanceState(state);
+ return;
+ }
+
+ SavedState savedState = (SavedState)state;
+ super.onRestoreInstanceState(savedState.getSuperState());
+
+ mSavedState = savedState;
+ }
+
+ static class SavedState extends BaseSavedState {
+ boolean additionalHeadersVisible;
+
+ @SuppressWarnings("hiding")
+ public static final Parcelable.Creator CREATOR =
+ new Parcelable.Creator() {
+ @Override
+ public SavedState createFromParcel(Parcel in) {
+ return new SavedState(in);
+ }
+
+ @Override
+ public SavedState[] newArray(int size) {
+ return new SavedState[size];
+ }
+ };
+
+
+ SavedState(Parcelable superState) {
+ super(superState);
+ }
+
+ private SavedState(Parcel in) {
+ super(in);
+ this.additionalHeadersVisible = (in.readInt() != 0);
+ }
+
+ @Override
+ public void writeToParcel(Parcel out, int flags) {
+ super.writeToParcel(out, flags);
+ out.writeInt((this.additionalHeadersVisible) ? 1 : 0);
+ }
+ }
}
diff --git a/src/com/fsck/k9/view/MessageWebView.java b/src/com/fsck/k9/view/MessageWebView.java
index daf53b993..d992b50be 100644
--- a/src/com/fsck/k9/view/MessageWebView.java
+++ b/src/com/fsck/k9/view/MessageWebView.java
@@ -1,25 +1,20 @@
package com.fsck.k9.view;
import android.content.Context;
-import android.graphics.Picture;
import android.os.Build;
import android.util.AttributeSet;
import android.util.Log;
import android.view.KeyEvent;
+import android.view.View;
import android.webkit.WebSettings;
import android.webkit.WebView;
import android.widget.Toast;
import com.fsck.k9.K9;
import com.fsck.k9.R;
-import com.fsck.k9.controller.MessagingListener;
-
import java.lang.reflect.Method;
-import java.util.Set;
public class MessageWebView extends WebView {
- // Store a reference to the listeners in MessagingController. We can't fetch it directly since
- // we don't know the application name.
- private Set mListeners = null;
+
/**
* We use WebSettings.getBlockNetworkLoads() to prevent the WebView that displays email
@@ -75,7 +70,7 @@ public class MessageWebView extends WebView {
this.setVerticalScrollBarEnabled(true);
this.setVerticalScrollbarOverlay(true);
this.setScrollBarStyle(SCROLLBARS_INSIDE_OVERLAY);
-
+ this.setLongClickable(true);
final WebSettings webSettings = this.getSettings();
@@ -97,22 +92,16 @@ public class MessageWebView extends WebView {
webSettings.setLayoutAlgorithm(WebSettings.LayoutAlgorithm.NARROW_COLUMNS);
}
+ if (Integer.parseInt(Build.VERSION.SDK) >= 9 ) {
+ setOverScrollMode(OVER_SCROLL_NEVER);
+ }
+
+
webSettings.setTextSize(K9.getFontSizes().getMessageViewContent());
// Disable network images by default. This is overridden by preferences.
blockNetworkData(true);
- // Listen for when the screen has finished drawing.
- setPictureListener(new PictureListener() {
- @Override
- public void onNewPicture(WebView webView, Picture picture) {
- if (mListeners != null) {
- for (MessagingListener l : mListeners) {
- l.messageViewFinished();
- }
- }
- }
- });
}
/*
@@ -132,7 +121,15 @@ public class MessageWebView extends WebView {
}
}
- public void setListeners(final Set listeners) {
- this.mListeners = listeners;
+ public void wrapSetTitleBar(final View title) {
+ try {
+ Class webViewClass = Class.forName("android.webkit.WebView");
+ Method setEmbeddedTitleBar = webViewClass.getMethod("setEmbeddedTitleBar", View.class);
+ setEmbeddedTitleBar.invoke(this, title);
+ }
+
+ catch (Exception e) {
+ Log.v(K9.LOG_TAG, "failed to find the setEmbeddedTitleBar method",e);
+ }
}
}
diff --git a/src/com/fsck/k9/view/SingleMessageView.java b/src/com/fsck/k9/view/SingleMessageView.java
index af3bfd207..b1e0980e9 100644
--- a/src/com/fsck/k9/view/SingleMessageView.java
+++ b/src/com/fsck/k9/view/SingleMessageView.java
@@ -7,16 +7,20 @@ import android.content.Intent;
import android.content.pm.ResolveInfo;
import android.database.Cursor;
import android.net.Uri;
+import android.os.Parcel;
+import android.os.Parcelable;
import android.util.AttributeSet;
import android.util.Log;
import android.view.KeyEvent;
import android.view.LayoutInflater;
import android.view.View;
+import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.LinearLayout;
import com.fsck.k9.Account;
import com.fsck.k9.K9;
import com.fsck.k9.R;
+import com.fsck.k9.activity.K9Activity;
import com.fsck.k9.controller.MessagingController;
import com.fsck.k9.controller.MessagingListener;
import com.fsck.k9.crypto.CryptoProvider;
@@ -24,49 +28,67 @@ import com.fsck.k9.crypto.PgpData;
import com.fsck.k9.helper.Contacts;
import com.fsck.k9.helper.Utility;
import com.fsck.k9.mail.*;
-import com.fsck.k9.mail.internet.MimeHeader;
-import com.fsck.k9.mail.internet.MimeUtility;
import com.fsck.k9.mail.store.LocalStore;
-
+import com.fsck.k9.mail.store.LocalStore.LocalMessage;
import java.util.List;
-import java.util.Set;
-/**
- */
-public class SingleMessageView extends LinearLayout {
+public class SingleMessageView extends LinearLayout implements OnClickListener {
private boolean mScreenReaderEnabled;
private MessageCryptoView mCryptoView;
private MessageWebView mMessageContentView;
private AccessibleWebView mAccessibleMessageContentView;
private MessageHeader mHeaderContainer;
private LinearLayout mAttachments;
- private View mShowPicturesSection;
+ private Button mShowHiddenAttachments;
+ private LinearLayout mHiddenAttachments;
+ private View mShowPicturesAction;
+ private View mShowMessageAction;
+ private View mShowAttachmentsAction;
private boolean mShowPictures;
+ private boolean mHasAttachments;
private Button mDownloadRemainder;
private LayoutInflater mInflater;
private Contacts mContacts;
private AttachmentView.AttachmentFileDownloadCallback attachmentCallback;
+ private LinearLayout mHeaderPlaceHolder;
+ private LinearLayout mTitleBarHeaderContainer;
+ private View mAttachmentsContainer;
+ private LinearLayout mInsideAttachmentsContainer;
+ private SavedState mSavedState;
public void initialize(Activity activity) {
mMessageContentView = (MessageWebView) findViewById(R.id.message_content);
mAccessibleMessageContentView = (AccessibleWebView) findViewById(R.id.accessible_message_content);
- mAttachments = (LinearLayout) findViewById(R.id.attachments);
+ mMessageContentView.configure();
+
+ mHeaderPlaceHolder = (LinearLayout) findViewById(R.id.message_view_header_container);
+
mHeaderContainer = (MessageHeader) findViewById(R.id.header_container);
+
+ mAttachmentsContainer = findViewById(R.id.attachments_container);
+ mInsideAttachmentsContainer = (LinearLayout) findViewById(R.id.inside_attachments_container);
+ mAttachments = (LinearLayout) findViewById(R.id.attachments);
+ mHiddenAttachments = (LinearLayout) findViewById(R.id.hidden_attachments);
+ mHiddenAttachments.setVisibility(View.GONE);
+ mShowHiddenAttachments = (Button) findViewById(R.id.show_hidden_attachments);
+ mShowHiddenAttachments.setVisibility(View.GONE);
mCryptoView = (MessageCryptoView) findViewById(R.id.layout_decrypt);
mCryptoView.setActivity(activity);
mCryptoView.setupChildViews();
- mShowPicturesSection = findViewById(R.id.show_pictures_section);
+ mShowPicturesAction = findViewById(R.id.show_pictures);
+ mShowMessageAction = findViewById(R.id.show_message);
+
+ mShowAttachmentsAction = findViewById(R.id.show_attachments);
+
mShowPictures = false;
mContacts = Contacts.getInstance(activity);
mInflater = activity.getLayoutInflater();
mDownloadRemainder = (Button) findViewById(R.id.download_remainder);
- mMessageContentView.configure();
-
-
- mAttachments.setVisibility(View.GONE);
+ mDownloadRemainder.setVisibility(View.GONE);
+ mAttachmentsContainer.setVisibility(View.GONE);
if (isScreenReaderActive(activity)) {
mAccessibleMessageContentView.setVisibility(View.VISIBLE);
mMessageContentView.setVisibility(View.GONE);
@@ -75,8 +97,62 @@ public class SingleMessageView extends LinearLayout {
mAccessibleMessageContentView.setVisibility(View.GONE);
mMessageContentView.setVisibility(View.VISIBLE);
mScreenReaderEnabled = false;
+
+ mHeaderPlaceHolder.removeView(mHeaderContainer);
+ // the HTC version of WebView tries to force the background of the
+ // titlebar, which is really unfair.
+ mHeaderContainer.setBackgroundColor(((K9Activity)activity).getThemeBackgroundColor());
+
+ mTitleBarHeaderContainer = new LinearLayout(activity);
+ mTitleBarHeaderContainer.addView(mHeaderContainer);
+ mMessageContentView.wrapSetTitleBar(mTitleBarHeaderContainer);
}
+ mShowHiddenAttachments.setOnClickListener(this);
+ mShowMessageAction.setOnClickListener(this);
+ mShowAttachmentsAction.setOnClickListener(this);
+ mShowPicturesAction.setOnClickListener(this);
+ }
+
+ @Override
+ public void onClick(View view) {
+ switch (view.getId()) {
+ case R.id.show_hidden_attachments: {
+ onShowHiddenAttachments();
+ break;
+ }
+ case R.id.show_message: {
+ onShowMessage();
+ break;
+ }
+ case R.id.show_attachments: {
+ onShowAttachments();
+ break;
+ }
+ case R.id.show_pictures: {
+ setLoadPictures(true);
+ break;
+ }
+ }
+ }
+
+ private void onShowHiddenAttachments() {
+ mShowHiddenAttachments.setVisibility(View.GONE);
+ mHiddenAttachments.setVisibility(View.VISIBLE);
+ }
+
+ public void onShowMessage() {
+ showShowMessageAction(false);
+ showAttachments(false);
+ showShowAttachmentsAction(mHasAttachments);
+ showMessageWebView(true);
+ }
+
+ public void onShowAttachments() {
+ showMessageWebView(false);
+ showShowAttachmentsAction(false);
+ showShowMessageAction(true);
+ showAttachments(true);
}
public SingleMessageView(Context context, AttributeSet attrs) {
@@ -102,15 +178,19 @@ public class SingleMessageView extends LinearLayout {
// content://.providers.StatusProvider
cursor = cr.query(Uri.parse("content://" + screenReader.serviceInfo.packageName
+ ".providers.StatusProvider"), null, null, null, null);
- if (cursor != null) {
- cursor.moveToFirst();
- // These content providers use a special cursor that only has
- // one element,
- // an integer that is 1 if the screen reader is running.
- status = cursor.getInt(0);
- cursor.close();
- if (status == 1) {
- return true;
+ try {
+ if (cursor != null && cursor.moveToFirst()) {
+ // These content providers use a special cursor that only has
+ // one element,
+ // an integer that is 1 if the screen reader is running.
+ status = cursor.getInt(0);
+ if (status == 1) {
+ return true;
+ }
+ }
+ } finally {
+ if (cursor != null) {
+ cursor.close();
}
}
}
@@ -135,20 +215,27 @@ public class SingleMessageView extends LinearLayout {
public void setLoadPictures(boolean enable) {
mMessageContentView.blockNetworkData(!enable);
setShowPictures(enable);
- showShowPicturesSection(false);
+ showShowPicturesAction(false);
}
public Button downloadRemainderButton() {
return mDownloadRemainder;
}
- public void showShowPicturesSection(boolean show) {
- mShowPicturesSection.setVisibility(show ? View.VISIBLE : View.GONE);
+ public void showShowPicturesAction(boolean show) {
+ mShowPicturesAction.setVisibility(show ? View.VISIBLE : View.GONE);
+ }
+ public void showShowMessageAction(boolean show) {
+ mShowMessageAction.setVisibility(show ? View.VISIBLE : View.GONE);
+ }
+ public void showShowAttachmentsAction(boolean show) {
+ mShowAttachmentsAction.setVisibility(show ? View.VISIBLE : View.GONE);
}
public void setHeaders(final Message message, Account account) {
try {
mHeaderContainer.populate(message, account);
+ mHeaderContainer.setVisibility(View.VISIBLE);
} catch (Exception me) {
@@ -177,9 +264,9 @@ public class SingleMessageView extends LinearLayout {
return mHeaderContainer.additionalHeadersVisible();
}
- public void displayMessageBody(Account account, String folder, String uid, Message message, PgpData pgpData) throws MessagingException {
- // TODO - really this code path? this is an odd place to put it
- removeAllAttachments();
+ public void setMessage(Account account, LocalMessage message, PgpData pgpData,
+ MessagingController controller, MessagingListener listener) throws MessagingException {
+ resetView();
String type;
String text = pgpData.getDecryptedData();
@@ -187,13 +274,49 @@ public class SingleMessageView extends LinearLayout {
type = "text/plain";
} else {
// getTextForDisplay() always returns HTML-ified content.
- text = ((LocalStore.LocalMessage) message).getTextForDisplay();
+ text = message.getTextForDisplay();
type = "text/html";
}
if (text != null) {
final String emailText = text;
final String contentType = type;
- loadBodyFromText(account.getCryptoProvider(), pgpData, message, emailText, contentType);
+ loadBodyFromText(emailText, contentType);
+ updateCryptoLayout(account.getCryptoProvider(), pgpData, message);
+ } else {
+ loadBodyFromUrl("file:///android_asset/empty.html");
+ }
+
+ mHasAttachments = message.hasAttachments();
+
+ if (mHasAttachments) {
+ renderAttachments(message, 0, message, account, controller, listener);
+ }
+
+ mHiddenAttachments.setVisibility(View.GONE);
+
+ boolean lookForImages = true;
+ if (mSavedState != null) {
+ if (mSavedState.showPictures) {
+ setLoadPictures(true);
+ lookForImages = false;
+ }
+
+ if (mSavedState.attachmentViewVisible) {
+ onShowAttachments();
+ } else {
+ onShowMessage();
+ }
+
+ if (mSavedState.hiddenAttachmentsVisible) {
+ onShowHiddenAttachments();
+ }
+
+ mSavedState = null;
+ } else {
+ onShowMessage();
+ }
+
+ if (text != null && lookForImages) {
// If the message contains external pictures and the "Show pictures"
// button wasn't already pressed, see if the user's preferences has us
// showing them anyway.
@@ -206,11 +329,9 @@ public class SingleMessageView extends LinearLayout {
mContacts.isInContacts(from[0].getAddress()))) {
setLoadPictures(true);
} else {
- showShowPicturesSection(true);
+ showShowPicturesAction(true);
}
}
- } else {
- loadBodyFromUrl("file:///android_asset/empty.html");
}
}
@@ -220,14 +341,13 @@ public class SingleMessageView extends LinearLayout {
}
- public void loadBodyFromText(CryptoProvider cryptoProvider, PgpData pgpData, Message message, String emailText, String contentType) {
+ private void loadBodyFromText(String emailText, String contentType) {
if (mScreenReaderEnabled) {
mAccessibleMessageContentView.loadDataWithBaseURL("http://", emailText, contentType, "utf-8", null);
} else {
mMessageContentView.loadDataWithBaseURL("http://", emailText, contentType, "utf-8", null);
mMessageContentView.scrollTo(0, 0);
}
- updateCryptoLayout(cryptoProvider, pgpData, message);
}
@@ -235,6 +355,23 @@ public class SingleMessageView extends LinearLayout {
mCryptoView.updateLayout(cp, pgpData, message);
}
+ public void showAttachments(boolean show) {
+ mAttachmentsContainer.setVisibility(show ? View.VISIBLE : View.GONE);
+ boolean showHidden = (show && mHiddenAttachments.getVisibility() == View.GONE &&
+ mHiddenAttachments.getChildCount() > 0);
+ mShowHiddenAttachments.setVisibility(showHidden ? View.VISIBLE : View.GONE);
+
+ if (show) {
+ moveHeaderToLayout();
+ } else {
+ moveHeaderToWebViewTitleBar();
+ }
+ }
+
+ public void showMessageWebView(boolean show) {
+ mMessageContentView.setVisibility(show ? View.VISIBLE : View.GONE);
+ }
+
public void setAttachmentsEnabled(boolean enabled) {
for (int i = 0, count = mAttachments.getChildCount(); i < count; i++) {
AttachmentView attachment = (AttachmentView) mAttachments.getChildAt(i);
@@ -243,7 +380,6 @@ public class SingleMessageView extends LinearLayout {
}
}
-
public void removeAllAttachments() {
for (int i = 0, count = mAttachments.getChildCount(); i < count; i++) {
mAttachments.removeView(mAttachments.getChildAt(i));
@@ -259,25 +395,27 @@ public class SingleMessageView extends LinearLayout {
renderAttachments(mp.getBodyPart(i), depth + 1, message, account, controller, listener);
}
} else if (part instanceof LocalStore.LocalAttachmentBodyPart) {
- String contentDisposition = MimeUtility.unfoldAndDecode(part.getDisposition());
- // Inline parts with a content-id are almost certainly components of an HTML message
- // not attachments. Don't show attachment download buttons for them.
- if (contentDisposition != null &&
- MimeUtility.getHeaderParameter(contentDisposition, null).matches("^(?i:inline)")
- && part.getHeader(MimeHeader.HEADER_CONTENT_ID) != null) {
- return;
- }
AttachmentView view = (AttachmentView)mInflater.inflate(R.layout.message_view_attachment, null);
view.setCallback(attachmentCallback);
- if (view.populateFromPart(part, message, account, controller, listener)) {
- addAttachment(view);
+
+ try {
+ if (view.populateFromPart(part, message, account, controller, listener)) {
+ addAttachment(view);
+ } else {
+ addHiddenAttachment(view);
+ }
+ } catch (Exception e) {
+ Log.e(K9.LOG_TAG, "Error adding attachment view", e);
}
}
}
public void addAttachment(View attachmentView) {
mAttachments.addView(attachmentView);
- mAttachments.setVisibility(View.VISIBLE);
+ }
+
+ public void addHiddenAttachment(View attachmentView) {
+ mHiddenAttachments.addView(attachmentView);
}
public void zoom(KeyEvent event) {
@@ -297,11 +435,26 @@ public class SingleMessageView extends LinearLayout {
}
public void resetView() {
+ mDownloadRemainder.setVisibility(View.GONE);
setLoadPictures(false);
- mMessageContentView.scrollTo(0, 0);
- mHeaderContainer.setVisibility(View.GONE);
- mMessageContentView.clearView();
+ showShowAttachmentsAction(false);
+ showShowMessageAction(false);
+ showShowPicturesAction(false);
mAttachments.removeAllViews();
+ mHiddenAttachments.removeAllViews();
+
+ /*
+ * Clear the WebView content
+ *
+ * For some reason WebView.clearView() doesn't clear the contents when the WebView changes
+ * its size because the button to download the complete message was previously shown and
+ * is now hidden.
+ */
+ loadBodyFromText("", "text/plain");
+ }
+
+ public void resetHeaderView() {
+ mHeaderContainer.setVisibility(View.GONE);
}
public AttachmentView.AttachmentFileDownloadCallback getAttachmentCallback() {
@@ -313,20 +466,85 @@ public class SingleMessageView extends LinearLayout {
this.attachmentCallback = attachmentCallback;
}
- /**
- * Save a copy of the {@link com.fsck.k9.controller.MessagingController#getListeners()}. This method will also
- * pass along these listeners to the underlying views.
- * @param listeners Set of listeners.
- */
- public void setListeners(final Set listeners) {
- if (!mScreenReaderEnabled) {
- if (mMessageContentView != null) {
- mMessageContentView.setListeners(listeners);
+ private void moveHeaderToLayout() {
+ if (mTitleBarHeaderContainer != null && mTitleBarHeaderContainer.getChildCount() != 0) {
+ mTitleBarHeaderContainer.removeView(mHeaderContainer);
+ mInsideAttachmentsContainer.addView(mHeaderContainer, 0);
+ }
+ }
+
+ private void moveHeaderToWebViewTitleBar() {
+ if (mTitleBarHeaderContainer != null && mTitleBarHeaderContainer.getChildCount() == 0) {
+ mInsideAttachmentsContainer.removeView(mHeaderContainer);
+ mTitleBarHeaderContainer.addView(mHeaderContainer);
+ }
+ }
+
+ @Override
+ public Parcelable onSaveInstanceState() {
+ Parcelable superState = super.onSaveInstanceState();
+
+ SavedState savedState = new SavedState(superState);
+
+ savedState.attachmentViewVisible = (mAttachmentsContainer != null &&
+ mAttachmentsContainer.getVisibility() == View.VISIBLE);
+ savedState.hiddenAttachmentsVisible = (mHiddenAttachments != null &&
+ mHiddenAttachments.getVisibility() == View.VISIBLE);
+ savedState.showPictures = mShowPictures;
+
+ return savedState;
+ }
+
+ @Override
+ public void onRestoreInstanceState(Parcelable state) {
+ if(!(state instanceof SavedState)) {
+ super.onRestoreInstanceState(state);
+ return;
+ }
+
+ SavedState savedState = (SavedState)state;
+ super.onRestoreInstanceState(savedState.getSuperState());
+
+ mSavedState = savedState;
+ }
+
+ static class SavedState extends BaseSavedState {
+ boolean attachmentViewVisible;
+ boolean hiddenAttachmentsVisible;
+ boolean showPictures;
+
+ @SuppressWarnings("hiding")
+ public static final Parcelable.Creator CREATOR =
+ new Parcelable.Creator() {
+ @Override
+ public SavedState createFromParcel(Parcel in) {
+ return new SavedState(in);
}
- } else {
- if (mAccessibleMessageContentView != null) {
- mAccessibleMessageContentView.setListeners(listeners);
+
+ @Override
+ public SavedState[] newArray(int size) {
+ return new SavedState[size];
}
+ };
+
+
+ SavedState(Parcelable superState) {
+ super(superState);
+ }
+
+ private SavedState(Parcel in) {
+ super(in);
+ this.attachmentViewVisible = (in.readInt() != 0);
+ this.hiddenAttachmentsVisible = (in.readInt() != 0);
+ this.showPictures = (in.readInt() != 0);
+ }
+
+ @Override
+ public void writeToParcel(Parcel out, int flags) {
+ super.writeToParcel(out, flags);
+ out.writeInt((this.attachmentViewVisible) ? 1 : 0);
+ out.writeInt((this.hiddenAttachmentsVisible) ? 1 : 0);
+ out.writeInt((this.showPictures) ? 1 : 0);
}
}
}
diff --git a/tests/src/com/fsck/k9/mail/internet/ViewablesTest.java b/tests/src/com/fsck/k9/mail/internet/ViewablesTest.java
new file mode 100644
index 000000000..ded79c3d5
--- /dev/null
+++ b/tests/src/com/fsck/k9/mail/internet/ViewablesTest.java
@@ -0,0 +1,188 @@
+package com.fsck.k9.mail.internet;
+
+import java.util.Date;
+import java.util.Locale;
+import java.util.TimeZone;
+import android.test.AndroidTestCase;
+import com.fsck.k9.mail.Address;
+import com.fsck.k9.mail.MessagingException;
+import com.fsck.k9.mail.Message.RecipientType;
+import com.fsck.k9.mail.internet.MimeUtility.ViewableContainer;
+
+public class ViewablesTest extends AndroidTestCase {
+
+ public void testSimplePlainTextMessage() throws MessagingException {
+ String bodyText = "K-9 Mail rocks :>";
+
+ // Create text/plain body
+ TextBody body = new TextBody(bodyText);
+
+ // Create message
+ MimeMessage message = new MimeMessage();
+ message.setBody(body);
+
+ // Extract text
+ ViewableContainer container = MimeUtility.extractTextAndAttachments(getContext(), message);
+
+ String expectedText = bodyText;
+ String expectedHtml =
+ "" +
+ "" +
+ "K-9 Mail rocks :>" +
+ "
" +
+ "";
+
+ assertEquals(expectedText, container.text);
+ assertEquals(expectedHtml, container.html);
+ }
+
+ public void testSimpleHtmlMessage() throws MessagingException {
+ String bodyText = "K-9 Mail rocks :>";
+
+ // Create text/plain body
+ TextBody body = new TextBody(bodyText);
+
+ // Create message
+ MimeMessage message = new MimeMessage();
+ message.setHeader("Content-Type", "text/html");
+ message.setBody(body);
+
+ // Extract text
+ ViewableContainer container = MimeUtility.extractTextAndAttachments(getContext(), message);
+
+ String expectedText = "K-9 Mail rocks :>";
+ String expectedHtml =
+ "" +
+ bodyText +
+ "";
+
+ assertEquals(expectedText, container.text);
+ assertEquals(expectedHtml, container.html);
+ }
+
+ public void testMultipartPlainTextMessage() throws MessagingException {
+ String bodyText1 = "text body 1";
+ String bodyText2 = "text body 2";
+
+ // Create text/plain bodies
+ TextBody body1 = new TextBody(bodyText1);
+ TextBody body2 = new TextBody(bodyText2);
+
+ // Create multipart/mixed part
+ MimeMultipart multipart = new MimeMultipart();
+ MimeBodyPart bodyPart1 = new MimeBodyPart(body1, "text/plain");
+ MimeBodyPart bodyPart2 = new MimeBodyPart(body2, "text/plain");
+ multipart.addBodyPart(bodyPart1);
+ multipart.addBodyPart(bodyPart2);
+
+ // Create message
+ MimeMessage message = new MimeMessage();
+ message.setBody(multipart);
+
+ // Extract text
+ ViewableContainer container = MimeUtility.extractTextAndAttachments(getContext(), message);
+
+ String expectedText =
+ bodyText1 + "\n\n" +
+ "------------------------------------------------------------------------\n\n" +
+ bodyText2;
+ String expectedHtml =
+ "" +
+ "" +
+ bodyText1 +
+ "
" +
+ "" +
+ "" +
+ bodyText2 +
+ "
" +
+ "";
+
+
+ assertEquals(expectedText, container.text);
+ assertEquals(expectedHtml, container.html);
+ }
+
+ public void testTextPlusRfc822Message() throws MessagingException {
+ Locale.setDefault(Locale.US);
+ TimeZone.setDefault(TimeZone.getTimeZone("UTC"));
+
+ String bodyText = "Some text here";
+ String innerBodyText = "Hey there. I'm inside a message/rfc822 (inline) attachment.";
+
+ // Create text/plain body
+ TextBody textBody = new TextBody(bodyText);
+
+ // Create inner text/plain body
+ TextBody innerBody = new TextBody(innerBodyText);
+
+ // Create message/rfc822 body
+ MimeMessage innerMessage = new MimeMessage();
+ innerMessage.addSentDate(new Date(112, 02, 17));
+ innerMessage.setRecipients(RecipientType.TO, new Address[] { new Address("to@example.com") });
+ innerMessage.setSubject("Subject");
+ innerMessage.setFrom(new Address("from@example.com"));
+ innerMessage.setBody(innerBody);
+
+ // Create multipart/mixed part
+ MimeMultipart multipart = new MimeMultipart();
+ MimeBodyPart bodyPart1 = new MimeBodyPart(textBody, "text/plain");
+ MimeBodyPart bodyPart2 = new MimeBodyPart(innerMessage, "message/rfc822");
+ bodyPart2.setHeader("Content-Disposition", "inline; filename=\"message.eml\"");
+ multipart.addBodyPart(bodyPart1);
+ multipart.addBodyPart(bodyPart2);
+
+ // Create message
+ MimeMessage message = new MimeMessage();
+ message.setBody(multipart);
+
+ // Extract text
+ ViewableContainer container = MimeUtility.extractTextAndAttachments(getContext(), message);
+
+ String expectedText =
+ bodyText +
+ "\n\n" +
+ "----- message.eml ------------------------------------------------------" +
+ "\n\n" +
+ "From: from@example.com" + "\n" +
+ "To: to@example.com" + "\n" +
+ "Sent: Sat Mar 17 00:00:00 GMT+00:00 2012" + "\n" +
+ "Subject: Subject" + "\n" +
+ "\n" +
+ innerBodyText;
+ String expectedHtml =
+ "" +
+ "" +
+ bodyText +
+ "
" +
+ "message.eml
" +
+ "" +
+ "" +
+ "| From: | " +
+ "from@example.com | " +
+ "
" +
+ "| To: | " +
+ "to@example.com | " +
+ "
" +
+ "| Sent: | " +
+ "Sat Mar 17 00:00:00 GMT+00:00 2012 | " +
+ "
" +
+ "| Subject: | " +
+ "Subject | " +
+ "
" +
+ "
" +
+ "" +
+ innerBodyText +
+ "
" +
+ "";
+
+ assertEquals(expectedText, container.text);
+ assertEquals(expectedHtml, container.html);
+ }
+}
diff --git a/tests/src/com/fsck/k9/mail/store/imap/ImapUtilityTest.java b/tests/src/com/fsck/k9/mail/store/imap/ImapUtilityTest.java
new file mode 100644
index 000000000..496d6922e
--- /dev/null
+++ b/tests/src/com/fsck/k9/mail/store/imap/ImapUtilityTest.java
@@ -0,0 +1,125 @@
+/*
+ * Copyright (C) 2012 The K-9 Dog Walkers
+ * Copyright (C) 2011 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.fsck.k9.mail.store.imap;
+
+import java.util.List;
+import android.test.MoreAsserts;
+import junit.framework.TestCase;
+
+public class ImapUtilityTest extends TestCase {
+ /**
+ * Test getting elements of an IMAP sequence set.
+ */
+ public void testGetImapSequenceValues() {
+ String[] expected;
+ List actual;
+
+ // Test valid sets
+ expected = new String[] {"1"};
+ actual = ImapUtility.getImapSequenceValues("1");
+ MoreAsserts.assertEquals(expected, actual.toArray());
+
+ expected = new String[] {"1", "3", "2"};
+ actual = ImapUtility.getImapSequenceValues("1,3,2");
+ MoreAsserts.assertEquals(expected, actual.toArray());
+
+ expected = new String[] {"4", "5", "6"};
+ actual = ImapUtility.getImapSequenceValues("4:6");
+ MoreAsserts.assertEquals(expected, actual.toArray());
+
+ expected = new String[] {"9", "8", "7"};
+ actual = ImapUtility.getImapSequenceValues("9:7");
+ MoreAsserts.assertEquals(expected, actual.toArray());
+
+ expected = new String[] {"1", "2", "3", "4", "9", "8", "7"};
+ actual = ImapUtility.getImapSequenceValues("1,2:4,9:7");
+ MoreAsserts.assertEquals(expected, actual.toArray());
+
+ // Test partially invalid sets
+ expected = new String[] { "1", "5" };
+ actual = ImapUtility.getImapSequenceValues("1,x,5");
+ MoreAsserts.assertEquals(expected, actual.toArray());
+
+ expected = new String[] { "1", "2", "3" };
+ actual = ImapUtility.getImapSequenceValues("a:d,1:3");
+ MoreAsserts.assertEquals(expected, actual.toArray());
+
+ // Test invalid sets
+ expected = new String[0];
+ actual = ImapUtility.getImapSequenceValues("");
+ MoreAsserts.assertEquals(expected, actual.toArray());
+
+ expected = new String[0];
+ actual = ImapUtility.getImapSequenceValues(null);
+ MoreAsserts.assertEquals(expected, actual.toArray());
+
+ expected = new String[0];
+ actual = ImapUtility.getImapSequenceValues("a");
+ MoreAsserts.assertEquals(expected, actual.toArray());
+
+ expected = new String[0];
+ actual = ImapUtility.getImapSequenceValues("1:x");
+ MoreAsserts.assertEquals(expected, actual.toArray());
+ }
+
+ /**
+ * Test getting elements of an IMAP range.
+ */
+ public void testGetImapRangeValues() {
+ String[] expected;
+ List actual;
+
+ // Test valid ranges
+ expected = new String[] {"1", "2", "3"};
+ actual = ImapUtility.getImapRangeValues("1:3");
+ MoreAsserts.assertEquals(expected, actual.toArray());
+
+ expected = new String[] {"16", "15", "14"};
+ actual = ImapUtility.getImapRangeValues("16:14");
+ MoreAsserts.assertEquals(expected, actual.toArray());
+
+ // Test in-valid ranges
+ expected = new String[0];
+ actual = ImapUtility.getImapRangeValues("");
+ MoreAsserts.assertEquals(expected, actual.toArray());
+
+ expected = new String[0];
+ actual = ImapUtility.getImapRangeValues(null);
+ MoreAsserts.assertEquals(expected, actual.toArray());
+
+ expected = new String[0];
+ actual = ImapUtility.getImapRangeValues("a");
+ MoreAsserts.assertEquals(expected, actual.toArray());
+
+ expected = new String[0];
+ actual = ImapUtility.getImapRangeValues("6");
+ MoreAsserts.assertEquals(expected, actual.toArray());
+
+ expected = new String[0];
+ actual = ImapUtility.getImapRangeValues("1:3,6");
+ MoreAsserts.assertEquals(expected, actual.toArray());
+
+ expected = new String[0];
+ actual = ImapUtility.getImapRangeValues("1:x");
+ MoreAsserts.assertEquals(expected, actual.toArray());
+
+ expected = new String[0];
+ actual = ImapUtility.getImapRangeValues("1:*");
+ MoreAsserts.assertEquals(expected, actual.toArray());
+ }
+}