k-9/src/com/fsck/k9/mail/store/local/LocalFolder.java

2219 lines
99 KiB
Java

package com.fsck.k9.mail.store.local;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.regex.Pattern;
import org.apache.commons.io.IOUtils;
import org.apache.james.mime4j.util.MimeUtil;
import android.content.ContentValues;
import android.content.Context;
import android.content.SharedPreferences;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.net.Uri;
import android.util.Log;
import com.fsck.k9.Account;
import com.fsck.k9.K9;
import com.fsck.k9.Account.MessageFormat;
import com.fsck.k9.activity.Search;
import com.fsck.k9.controller.MessageRemovalListener;
import com.fsck.k9.controller.MessageRetrievalListener;
import com.fsck.k9.helper.HtmlConverter;
import com.fsck.k9.helper.Utility;
import com.fsck.k9.mail.Address;
import com.fsck.k9.mail.Body;
import com.fsck.k9.mail.BodyPart;
import com.fsck.k9.mail.FetchProfile;
import com.fsck.k9.mail.Flag;
import com.fsck.k9.mail.Folder;
import com.fsck.k9.mail.Message;
import com.fsck.k9.mail.MessagingException;
import com.fsck.k9.mail.Part;
import com.fsck.k9.mail.Message.RecipientType;
import com.fsck.k9.mail.internet.MimeBodyPart;
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.TextBody;
import com.fsck.k9.mail.internet.MimeUtility.ViewableContainer;
import com.fsck.k9.mail.store.StorageManager;
import com.fsck.k9.mail.store.UnavailableStorageException;
import com.fsck.k9.mail.store.local.LockableDatabase.DbCallback;
import com.fsck.k9.mail.store.local.LockableDatabase.WrappedException;
import com.fsck.k9.provider.AttachmentProvider;
public class LocalFolder extends Folder<LocalMessage> implements Serializable {
private static final long serialVersionUID = -1973296520918624767L;
private final LocalStore localStore;
private String mName = null;
private long mFolderId = -1;
private int mVisibleLimit = -1;
private String prefId = null;
private FolderClass mDisplayClass = FolderClass.NO_CLASS;
private FolderClass mSyncClass = FolderClass.INHERITED;
private FolderClass mPushClass = FolderClass.SECOND_CLASS;
private FolderClass mNotifyClass = FolderClass.INHERITED;
private boolean mInTopGroup = false;
private String mPushState = null;
private boolean mIntegrate = false;
// mLastUid is used during syncs. It holds the highest UID within the local folder so we
// know whether or not an unread message added to the local folder is actually "new" or not.
private Integer mLastUid = null;
public LocalFolder(LocalStore localStore, String name) {
super();
this.localStore = localStore;
this.mName = name;
if (getAccount().getInboxFolderName().equals(getName())) {
mSyncClass = FolderClass.FIRST_CLASS;
mPushClass = FolderClass.FIRST_CLASS;
mInTopGroup = true;
}
}
public LocalFolder(LocalStore localStore, long id) {
super();
this.localStore = localStore;
this.mFolderId = id;
}
public long getId() {
return mFolderId;
}
public String getUuid()
{
return getAccount().getUuid();
}
public boolean getSignatureUse() {
return getAccount().getSignatureUse();
}
public void setLastSelectedFolderName(String destFolderName) {
getAccount().setLastSelectedFolderName(destFolderName);
}
public boolean syncRemoteDeletions() {
return getAccount().syncRemoteDeletions();
}
@Override
public void open(final int mode) throws MessagingException {
if (isOpen() && (getMode() == mode || mode == OPEN_MODE_RO)) {
return;
} else if (isOpen()) {
//previously opened in READ_ONLY and now requesting READ_WRITE
//so close connection and reopen
close();
}
try {
this.localStore.database.execute(false, new DbCallback<Void>() {
@Override
public Void doDbWork(final SQLiteDatabase db) throws WrappedException {
Cursor cursor = null;
try {
String baseQuery = "SELECT " + LocalStore.GET_FOLDER_COLS + " FROM folders ";
if (mName != null) {
cursor = db.rawQuery(baseQuery + "where folders.name = ?", new String[] { mName });
} else {
cursor = db.rawQuery(baseQuery + "where folders.id = ?", new String[] { Long.toString(mFolderId) });
}
if (cursor.moveToFirst() && !cursor.isNull(LocalStore.FOLDER_ID_INDEX)) {
int folderId = cursor.getInt(LocalStore.FOLDER_ID_INDEX);
if (folderId > 0) {
open(cursor);
}
} else {
Log.w(K9.LOG_TAG, "Creating folder " + getName() + " with existing id " + getId());
create(FolderType.HOLDS_MESSAGES);
open(mode);
}
} catch (MessagingException e) {
throw new WrappedException(e);
} finally {
Utility.closeQuietly(cursor);
}
return null;
}
});
} catch (WrappedException e) {
throw(MessagingException) e.getCause();
}
}
void open(Cursor cursor) throws MessagingException {
mFolderId = cursor.getInt(LocalStore.FOLDER_ID_INDEX);
mName = cursor.getString(LocalStore.FOLDER_NAME_INDEX);
mVisibleLimit = cursor.getInt(LocalStore.FOLDER_VISIBLE_LIMIT_INDEX);
mPushState = cursor.getString(LocalStore.FOLDER_PUSH_STATE_INDEX);
super.setStatus(cursor.getString(LocalStore.FOLDER_STATUS_INDEX));
// Only want to set the local variable stored in the super class. This class
// does a DB update on setLastChecked
super.setLastChecked(cursor.getLong(LocalStore.FOLDER_LAST_CHECKED_INDEX));
super.setLastPush(cursor.getLong(LocalStore.FOLDER_LAST_PUSHED_INDEX));
mInTopGroup = (cursor.getInt(LocalStore.FOLDER_TOP_GROUP_INDEX)) == 1 ? true : false;
mIntegrate = (cursor.getInt(LocalStore.FOLDER_INTEGRATE_INDEX) == 1) ? true : false;
String noClass = FolderClass.NO_CLASS.toString();
String displayClass = cursor.getString(LocalStore.FOLDER_DISPLAY_CLASS_INDEX);
mDisplayClass = Folder.FolderClass.valueOf((displayClass == null) ? noClass : displayClass);
String notifyClass = cursor.getString(LocalStore.FOLDER_NOTIFY_CLASS_INDEX);
mNotifyClass = Folder.FolderClass.valueOf((notifyClass == null) ? noClass : notifyClass);
String pushClass = cursor.getString(LocalStore.FOLDER_PUSH_CLASS_INDEX);
mPushClass = Folder.FolderClass.valueOf((pushClass == null) ? noClass : pushClass);
String syncClass = cursor.getString(LocalStore.FOLDER_SYNC_CLASS_INDEX);
mSyncClass = Folder.FolderClass.valueOf((syncClass == null) ? noClass : syncClass);
}
@Override
public boolean isOpen() {
return (mFolderId != -1 && mName != null);
}
@Override
public int getMode() {
return OPEN_MODE_RW;
}
@Override
public String getName() {
return mName;
}
@Override
public boolean exists() throws MessagingException {
return this.localStore.database.execute(false, new DbCallback<Boolean>() {
@Override
public Boolean doDbWork(final SQLiteDatabase db) throws WrappedException {
Cursor cursor = null;
try {
cursor = db.rawQuery("SELECT id FROM folders "
+ "where folders.name = ?", new String[] { LocalFolder.
this.getName()
});
if (cursor.moveToFirst()) {
int folderId = cursor.getInt(0);
return (folderId > 0);
}
return false;
} finally {
Utility.closeQuietly(cursor);
}
}
});
}
@Override
public boolean create(FolderType type) throws MessagingException {
return create(type, getAccount().getDisplayCount());
}
@Override
public boolean create(FolderType type, final int visibleLimit) throws MessagingException {
if (exists()) {
throw new MessagingException("Folder " + mName + " already exists.");
}
List<LocalFolder> foldersToCreate = new ArrayList<LocalFolder>(1);
foldersToCreate.add(this);
this.localStore.createFolders(foldersToCreate, visibleLimit);
return true;
}
class PreferencesHolder {
FolderClass displayClass = mDisplayClass;
FolderClass syncClass = mSyncClass;
FolderClass notifyClass = mNotifyClass;
FolderClass pushClass = mPushClass;
boolean inTopGroup = mInTopGroup;
boolean integrate = mIntegrate;
}
@Override
public void close() {
mFolderId = -1;
}
@Override
public int getMessageCount() throws MessagingException {
try {
return this.localStore.database.execute(false, new DbCallback<Integer>() {
@Override
public Integer doDbWork(final SQLiteDatabase db) throws WrappedException {
try {
open(OPEN_MODE_RW);
} catch (MessagingException e) {
throw new WrappedException(e);
}
Cursor cursor = null;
try {
cursor = db.rawQuery("SELECT COUNT(id) FROM messages WHERE (empty IS NULL OR empty != 1) AND deleted = 0 and folder_id = ?",
new String[] {
Long.toString(mFolderId)
});
cursor.moveToFirst();
return cursor.getInt(0); //messagecount
} finally {
Utility.closeQuietly(cursor);
}
}
});
} catch (WrappedException e) {
throw(MessagingException) e.getCause();
}
}
@Override
public int getUnreadMessageCount() throws MessagingException {
if (mFolderId == -1) {
open(OPEN_MODE_RW);
}
try {
return this.localStore.database.execute(false, new DbCallback<Integer>() {
@Override
public Integer doDbWork(final SQLiteDatabase db) throws WrappedException {
int unreadMessageCount = 0;
Cursor cursor = db.query("messages", new String[] { "COUNT(id)" },
"folder_id = ? AND (empty IS NULL OR empty != 1) AND deleted = 0 AND read=0",
new String[] { Long.toString(mFolderId) }, null, null, null);
try {
if (cursor.moveToFirst()) {
unreadMessageCount = cursor.getInt(0);
}
} finally {
cursor.close();
}
return unreadMessageCount;
}
});
} catch (WrappedException e) {
throw(MessagingException) e.getCause();
}
}
@Override
public int getFlaggedMessageCount() throws MessagingException {
if (mFolderId == -1) {
open(OPEN_MODE_RW);
}
try {
return this.localStore.database.execute(false, new DbCallback<Integer>() {
@Override
public Integer doDbWork(final SQLiteDatabase db) throws WrappedException {
int flaggedMessageCount = 0;
Cursor cursor = db.query("messages", new String[] { "COUNT(id)" },
"folder_id = ? AND (empty IS NULL OR empty != 1) AND deleted = 0 AND flagged = 1",
new String[] { Long.toString(mFolderId) }, null, null, null);
try {
if (cursor.moveToFirst()) {
flaggedMessageCount = cursor.getInt(0);
}
} finally {
cursor.close();
}
return flaggedMessageCount;
}
});
} catch (WrappedException e) {
throw(MessagingException) e.getCause();
}
}
@Override
public void setLastChecked(final long lastChecked) throws MessagingException {
try {
open(OPEN_MODE_RW);
LocalFolder.super.setLastChecked(lastChecked);
} catch (MessagingException e) {
throw new WrappedException(e);
}
updateFolderColumn("last_updated", lastChecked);
}
@Override
public void setLastPush(final long lastChecked) throws MessagingException {
try {
open(OPEN_MODE_RW);
LocalFolder.super.setLastPush(lastChecked);
} catch (MessagingException e) {
throw new WrappedException(e);
}
updateFolderColumn("last_pushed", lastChecked);
}
public int getVisibleLimit() throws MessagingException {
open(OPEN_MODE_RW);
return mVisibleLimit;
}
public void purgeToVisibleLimit(MessageRemovalListener listener) throws MessagingException {
//don't purge messages while a Search is active since it might throw away search results
if (!Search.isActive()) {
if (mVisibleLimit == 0) {
return ;
}
open(OPEN_MODE_RW);
List<? extends Message> messages = getMessages(null, false);
for (int i = mVisibleLimit; i < messages.size(); i++) {
if (listener != null) {
listener.messageRemoved(messages.get(i));
}
messages.get(i).destroy();
}
}
}
public void setVisibleLimit(final int visibleLimit) throws MessagingException {
mVisibleLimit = visibleLimit;
updateFolderColumn("visible_limit", mVisibleLimit);
}
@Override
public void setStatus(final String status) throws MessagingException {
updateFolderColumn("status", status);
}
public void setPushState(final String pushState) throws MessagingException {
mPushState = pushState;
updateFolderColumn("push_state", pushState);
}
private void updateFolderColumn(final String column, final Object value) throws MessagingException {
try {
this.localStore.database.execute(false, new DbCallback<Void>() {
@Override
public Void doDbWork(final SQLiteDatabase db) throws WrappedException {
try {
open(OPEN_MODE_RW);
} catch (MessagingException e) {
throw new WrappedException(e);
}
db.execSQL("UPDATE folders SET " + column + " = ? WHERE id = ?", new Object[] { value, mFolderId });
return null;
}
});
} catch (WrappedException e) {
throw(MessagingException) e.getCause();
}
}
public String getPushState() {
return mPushState;
}
@Override
public FolderClass getDisplayClass() {
return mDisplayClass;
}
@Override
public FolderClass getSyncClass() {
return (FolderClass.INHERITED == mSyncClass) ? getDisplayClass() : mSyncClass;
}
public FolderClass getRawSyncClass() {
return mSyncClass;
}
public FolderClass getNotifyClass() {
return (FolderClass.INHERITED == mNotifyClass) ? getPushClass() : mNotifyClass;
}
public FolderClass getRawNotifyClass() {
return mNotifyClass;
}
@Override
public FolderClass getPushClass() {
return (FolderClass.INHERITED == mPushClass) ? getSyncClass() : mPushClass;
}
public FolderClass getRawPushClass() {
return mPushClass;
}
public void setDisplayClass(FolderClass displayClass) throws MessagingException {
mDisplayClass = displayClass;
updateFolderColumn("display_class", mDisplayClass.name());
}
public void setSyncClass(FolderClass syncClass) throws MessagingException {
mSyncClass = syncClass;
updateFolderColumn("poll_class", mSyncClass.name());
}
public void setPushClass(FolderClass pushClass) throws MessagingException {
mPushClass = pushClass;
updateFolderColumn("push_class", mPushClass.name());
}
public void setNotifyClass(FolderClass notifyClass) throws MessagingException {
mNotifyClass = notifyClass;
updateFolderColumn("notify_class", mNotifyClass.name());
}
public boolean isIntegrate() {
return mIntegrate;
}
public void setIntegrate(boolean integrate) throws MessagingException {
mIntegrate = integrate;
updateFolderColumn("integrate", mIntegrate ? 1 : 0);
}
private String getPrefId(String name) {
if (prefId == null) {
prefId = this.localStore.uUid + "." + name;
}
return prefId;
}
private String getPrefId() throws MessagingException {
open(OPEN_MODE_RW);
return getPrefId(mName);
}
public void delete() throws MessagingException {
String id = getPrefId();
SharedPreferences.Editor editor = this.localStore.getPreferences().edit();
editor.remove(id + ".displayMode");
editor.remove(id + ".syncMode");
editor.remove(id + ".pushMode");
editor.remove(id + ".inTopGroup");
editor.remove(id + ".integrate");
editor.commit();
}
public void save() throws MessagingException {
SharedPreferences.Editor editor = this.localStore.getPreferences().edit();
save(editor);
editor.commit();
}
public void save(SharedPreferences.Editor editor) throws MessagingException {
String id = getPrefId();
// there can be a lot of folders. For the defaults, let's not save prefs, saving space, except for INBOX
if (mDisplayClass == FolderClass.NO_CLASS && !getAccount().getInboxFolderName().equals(getName())) {
editor.remove(id + ".displayMode");
} else {
editor.putString(id + ".displayMode", mDisplayClass.name());
}
if (mSyncClass == FolderClass.INHERITED && !getAccount().getInboxFolderName().equals(getName())) {
editor.remove(id + ".syncMode");
} else {
editor.putString(id + ".syncMode", mSyncClass.name());
}
if (mNotifyClass == FolderClass.INHERITED && !getAccount().getInboxFolderName().equals(getName())) {
editor.remove(id + ".notifyMode");
} else {
editor.putString(id + ".notifyMode", mNotifyClass.name());
}
if (mPushClass == FolderClass.SECOND_CLASS && !getAccount().getInboxFolderName().equals(getName())) {
editor.remove(id + ".pushMode");
} else {
editor.putString(id + ".pushMode", mPushClass.name());
}
editor.putBoolean(id + ".inTopGroup", mInTopGroup);
editor.putBoolean(id + ".integrate", mIntegrate);
}
public void refresh(String name, PreferencesHolder prefHolder) {
String id = getPrefId(name);
SharedPreferences preferences = this.localStore.getPreferences();
try {
prefHolder.displayClass = FolderClass.valueOf(preferences.getString(id + ".displayMode",
prefHolder.displayClass.name()));
} catch (Exception e) {
Log.e(K9.LOG_TAG, "Unable to load displayMode for " + getName(), e);
}
if (prefHolder.displayClass == FolderClass.NONE) {
prefHolder.displayClass = FolderClass.NO_CLASS;
}
try {
prefHolder.syncClass = FolderClass.valueOf(preferences.getString(id + ".syncMode",
prefHolder.syncClass.name()));
} catch (Exception e) {
Log.e(K9.LOG_TAG, "Unable to load syncMode for " + getName(), e);
}
if (prefHolder.syncClass == FolderClass.NONE) {
prefHolder.syncClass = FolderClass.INHERITED;
}
try {
prefHolder.notifyClass = FolderClass.valueOf(preferences.getString(id + ".notifyMode",
prefHolder.notifyClass.name()));
} catch (Exception e) {
Log.e(K9.LOG_TAG, "Unable to load notifyMode for " + getName(), e);
}
if (prefHolder.notifyClass == FolderClass.NONE) {
prefHolder.notifyClass = FolderClass.INHERITED;
}
try {
prefHolder.pushClass = FolderClass.valueOf(preferences.getString(id + ".pushMode",
prefHolder.pushClass.name()));
} catch (Exception e) {
Log.e(K9.LOG_TAG, "Unable to load pushMode for " + getName(), e);
}
if (prefHolder.pushClass == FolderClass.NONE) {
prefHolder.pushClass = FolderClass.INHERITED;
}
prefHolder.inTopGroup = preferences.getBoolean(id + ".inTopGroup", prefHolder.inTopGroup);
prefHolder.integrate = preferences.getBoolean(id + ".integrate", prefHolder.integrate);
}
@Override
public void fetch(final List<? extends Message> messages, final FetchProfile fp, final MessageRetrievalListener<LocalMessage> listener)
throws MessagingException {
try {
this.localStore.database.execute(false, new DbCallback<Void>() {
@Override
public Void doDbWork(final SQLiteDatabase db) throws WrappedException {
try {
open(OPEN_MODE_RW);
if (fp.contains(FetchProfile.Item.BODY)) {
for (Message message : messages) {
LocalMessage localMessage = (LocalMessage)message;
Cursor cursor = null;
MimeMultipart mp = new MimeMultipart();
mp.setSubType("mixed");
try {
cursor = db.rawQuery("SELECT html_content, text_content, mime_type FROM messages "
+ "WHERE id = ?",
new String[] { Long.toString(localMessage.getId()) });
cursor.moveToNext();
String htmlContent = cursor.getString(0);
String textContent = cursor.getString(1);
String mimeType = cursor.getString(2);
if (mimeType != null && mimeType.toLowerCase(Locale.US).startsWith("multipart/")) {
// If this is a multipart message, preserve both text
// and html parts, as well as the subtype.
mp.setSubType(mimeType.toLowerCase(Locale.US).replaceFirst("^multipart/", ""));
if (textContent != null) {
LocalTextBody body = new LocalTextBody(textContent, htmlContent);
MimeBodyPart bp = new MimeBodyPart(body, "text/plain");
mp.addBodyPart(bp);
}
if (getAccount().getMessageFormat() != MessageFormat.TEXT) {
if (htmlContent != null) {
TextBody body = new TextBody(htmlContent);
MimeBodyPart bp = new MimeBodyPart(body, "text/html");
mp.addBodyPart(bp);
}
// If we have both text and html content and our MIME type
// isn't multipart/alternative, then corral them into a new
// multipart/alternative part and put that into the parent.
// If it turns out that this is the only part in the parent
// MimeMultipart, it'll get fixed below before we attach to
// the message.
if (textContent != null && htmlContent != null && !mimeType.equalsIgnoreCase("multipart/alternative")) {
MimeMultipart alternativeParts = mp;
alternativeParts.setSubType("alternative");
mp = new MimeMultipart();
mp.addBodyPart(new MimeBodyPart(alternativeParts));
}
}
} else if (mimeType != null && mimeType.equalsIgnoreCase("text/plain")) {
// If it's text, add only the plain part. The MIME
// container will drop away below.
if (textContent != null) {
LocalTextBody body = new LocalTextBody(textContent, htmlContent);
MimeBodyPart bp = new MimeBodyPart(body, "text/plain");
mp.addBodyPart(bp);
}
} else if (mimeType != null && mimeType.equalsIgnoreCase("text/html")) {
// If it's html, add only the html part. The MIME
// container will drop away below.
if (htmlContent != null) {
TextBody body = new TextBody(htmlContent);
MimeBodyPart bp = new MimeBodyPart(body, "text/html");
mp.addBodyPart(bp);
}
} else {
// MIME type not set. Grab whatever part we can get,
// with Text taking precedence. This preserves pre-HTML
// composition behaviour.
if (textContent != null) {
LocalTextBody body = new LocalTextBody(textContent, htmlContent);
MimeBodyPart bp = new MimeBodyPart(body, "text/plain");
mp.addBodyPart(bp);
} else if (htmlContent != null) {
TextBody body = new TextBody(htmlContent);
MimeBodyPart bp = new MimeBodyPart(body, "text/html");
mp.addBodyPart(bp);
}
}
} catch (Exception e) {
Log.e(K9.LOG_TAG, "Exception fetching message:", e);
} finally {
Utility.closeQuietly(cursor);
}
try {
cursor = db.query(
"attachments",
new String[] {
"id",
"size",
"name",
"mime_type",
"store_data",
"content_uri",
"content_id",
"content_disposition"
},
"message_id = ?",
new String[] { Long.toString(localMessage.getId()) },
null,
null,
null);
while (cursor.moveToNext()) {
long id = cursor.getLong(0);
int size = cursor.getInt(1);
String name = cursor.getString(2);
String type = cursor.getString(3);
String storeData = cursor.getString(4);
String contentUri = cursor.getString(5);
String contentId = cursor.getString(6);
String contentDisposition = cursor.getString(7);
String encoding = MimeUtility.getEncodingforType(type);
Body body = null;
if (contentDisposition == null) {
contentDisposition = "attachment";
}
if (contentUri != null) {
if (MimeUtil.isMessage(type)) {
body = new LocalAttachmentMessageBody(
Uri.parse(contentUri),
LocalFolder.this.localStore.mApplication);
} else {
body = new LocalAttachmentBody(
Uri.parse(contentUri),
LocalFolder.this.localStore.mApplication);
}
}
MimeBodyPart bp = new LocalAttachmentBodyPart(body, id);
bp.setEncoding(encoding);
if (name != null) {
bp.setHeader(MimeHeader.HEADER_CONTENT_TYPE,
String.format("%s;\r\n name=\"%s\"",
type,
name));
bp.setHeader(MimeHeader.HEADER_CONTENT_DISPOSITION,
String.format(Locale.US, "%s;\r\n filename=\"%s\";\r\n size=%d",
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(Locale.US, "%s;\r\n size=%d",
contentDisposition,
size));
}
bp.setHeader(MimeHeader.HEADER_CONTENT_ID, contentId);
/*
* HEADER_ANDROID_ATTACHMENT_STORE_DATA is a custom header we add to that
* we can later pull the attachment from the remote store if necessary.
*/
bp.setHeader(MimeHeader.HEADER_ANDROID_ATTACHMENT_STORE_DATA, storeData);
mp.addBodyPart(bp);
}
} finally {
Utility.closeQuietly(cursor);
}
if (mp.getCount() == 0) {
// If we have no body, remove the container and create a
// dummy plain text body. This check helps prevents us from
// triggering T_MIME_NO_TEXT and T_TVD_MIME_NO_HEADERS
// SpamAssassin rules.
localMessage.setHeader(MimeHeader.HEADER_CONTENT_TYPE, "text/plain");
localMessage.setBody(new TextBody(""));
} else if (mp.getCount() == 1 && (mp.getBodyPart(0) instanceof LocalAttachmentBodyPart) == false)
{
// If we have only one part, drop the MimeMultipart container.
BodyPart part = mp.getBodyPart(0);
localMessage.setHeader(MimeHeader.HEADER_CONTENT_TYPE, part.getContentType());
localMessage.setBody(part.getBody());
} else {
// Otherwise, attach the MimeMultipart to the message.
localMessage.setBody(mp);
}
}
}
} catch (MessagingException e) {
throw new WrappedException(e);
}
return null;
}
});
} catch (WrappedException e) {
throw(MessagingException) e.getCause();
}
}
@Override
public List<? extends Message> getMessages(int start, int end, Date earliestDate, MessageRetrievalListener listener)
throws MessagingException {
open(OPEN_MODE_RW);
throw new MessagingException(
"LocalStore.getMessages(int, int, MessageRetrievalListener) not yet implemented");
}
/**
* Populate the header fields of the given list of messages by reading
* the saved header data from the database.
*
* @param messages
* The messages whose headers should be loaded.
* @throws UnavailableStorageException
*/
void populateHeaders(final List<LocalMessage> messages) throws UnavailableStorageException {
this.localStore.database.execute(false, new DbCallback<Void>() {
@Override
public Void doDbWork(final SQLiteDatabase db) throws WrappedException, UnavailableStorageException {
Cursor cursor = null;
if (messages.isEmpty()) {
return null;
}
try {
Map<Long, LocalMessage> popMessages = new HashMap<Long, LocalMessage>();
List<String> ids = new ArrayList<String>();
StringBuilder questions = new StringBuilder();
for (int i = 0; i < messages.size(); i++) {
if (i != 0) {
questions.append(", ");
}
questions.append("?");
LocalMessage message = messages.get(i);
Long id = message.getId();
ids.add(Long.toString(id));
popMessages.put(id, message);
}
cursor = db.rawQuery(
"SELECT message_id, name, value FROM headers " + "WHERE message_id in ( " + questions + ") ORDER BY id ASC",
ids.toArray(LocalStore.EMPTY_STRING_ARRAY));
while (cursor.moveToNext()) {
Long id = cursor.getLong(0);
String name = cursor.getString(1);
String value = cursor.getString(2);
//Log.i(K9.LOG_TAG, "Retrieved header name= " + name + ", value = " + value + " for message " + id);
popMessages.get(id).addHeader(name, value);
}
} finally {
Utility.closeQuietly(cursor);
}
return null;
}
});
}
public String getMessageUidById(final long id) throws MessagingException {
try {
return this.localStore.database.execute(false, new DbCallback<String>() {
@Override
public String doDbWork(final SQLiteDatabase db) throws WrappedException, UnavailableStorageException {
try {
open(OPEN_MODE_RW);
Cursor cursor = null;
try {
cursor = db.rawQuery(
"SELECT uid FROM messages " +
"WHERE id = ? AND folder_id = ?",
new String[] {
Long.toString(id), Long.toString(mFolderId)
});
if (!cursor.moveToNext()) {
return null;
}
return cursor.getString(0);
} finally {
Utility.closeQuietly(cursor);
}
} catch (MessagingException e) {
throw new WrappedException(e);
}
}
});
} catch (WrappedException e) {
throw(MessagingException) e.getCause();
}
}
@Override
public LocalMessage getMessage(final String uid) throws MessagingException {
try {
return this.localStore.database.execute(false, new DbCallback<LocalMessage>() {
@Override
public LocalMessage doDbWork(final SQLiteDatabase db) throws WrappedException, UnavailableStorageException {
try {
open(OPEN_MODE_RW);
LocalMessage message = new LocalMessage(LocalFolder.this.localStore, uid, LocalFolder.this);
Cursor cursor = null;
try {
cursor = db.rawQuery(
"SELECT " +
LocalStore.GET_MESSAGES_COLS +
"FROM messages " +
"LEFT JOIN threads ON (threads.message_id = messages.id) " +
"WHERE uid = ? AND folder_id = ?",
new String[] {
message.getUid(), Long.toString(mFolderId)
});
if (!cursor.moveToNext()) {
return null;
}
message.populateFromGetMessageCursor(cursor);
} finally {
Utility.closeQuietly(cursor);
}
return message;
} catch (MessagingException e) {
throw new WrappedException(e);
}
}
});
} catch (WrappedException e) {
throw(MessagingException) e.getCause();
}
}
@Override
public List<? extends Message> getMessages(MessageRetrievalListener listener) throws MessagingException {
return getMessages(listener, true);
}
@Override
public List<? extends Message> getMessages(final MessageRetrievalListener listener, final boolean includeDeleted) throws MessagingException {
try {
return this.localStore.database.execute(false, new DbCallback<List<? extends Message>>() {
@Override
public List<? extends Message> doDbWork(final SQLiteDatabase db) throws WrappedException, UnavailableStorageException {
try {
open(OPEN_MODE_RW);
return LocalFolder.this.localStore.getMessages(
listener,
LocalFolder.this,
"SELECT " + LocalStore.GET_MESSAGES_COLS +
"FROM messages " +
"LEFT JOIN threads ON (threads.message_id = messages.id) " +
"WHERE (empty IS NULL OR empty != 1) AND " +
(includeDeleted ? "" : "deleted = 0 AND ") +
"folder_id = ? ORDER BY date DESC",
new String[] { Long.toString(mFolderId) }
);
} catch (MessagingException e) {
throw new WrappedException(e);
}
}
});
} catch (WrappedException e) {
throw(MessagingException) e.getCause();
}
}
@Override
public List<? extends Message> getMessages(String[] uids, MessageRetrievalListener listener)
throws MessagingException {
open(OPEN_MODE_RW);
if (uids == null) {
return getMessages(listener);
}
List<Message> messages = new ArrayList<Message>();
for (String uid : uids) {
Message message = getMessage(uid);
if (message != null) {
messages.add(message);
}
}
return messages;
}
@Override
public Map<String, String> copyMessages(List<? extends Message> msgs, Folder folder) throws MessagingException {
if (!(folder instanceof LocalFolder)) {
throw new MessagingException("copyMessages called with incorrect Folder");
}
return ((LocalFolder) folder).appendMessages(msgs, true);
}
@Override
public Map<String, String> moveMessages(final List<? extends 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<String, String> uidMap = new HashMap<String, String>();
try {
this.localStore.database.execute(false, new DbCallback<Void>() {
@Override
public Void doDbWork(final SQLiteDatabase db) throws WrappedException, UnavailableStorageException {
try {
lDestFolder.open(OPEN_MODE_RW);
for (Message message : msgs) {
LocalMessage lMessage = (LocalMessage)message;
String oldUID = message.getUid();
if (K9.DEBUG) {
Log.d(K9.LOG_TAG, "Updating folder_id to " + lDestFolder.getId() + " for message with UID "
+ message.getUid() + ", id " + lMessage.getId() + " currently in folder " + getName());
}
String newUid = K9.LOCAL_UID_PREFIX + UUID.randomUUID().toString();
message.setUid(newUid);
uidMap.put(oldUID, newUid);
// Message threading in the target folder
ThreadInfo threadInfo = lDestFolder.doMessageThreading(db, message);
/*
* "Move" the message into the new folder
*/
long msgId = lMessage.getId();
String[] idArg = new String[] { Long.toString(msgId) };
ContentValues cv = new ContentValues();
cv.put("folder_id", lDestFolder.getId());
cv.put("uid", newUid);
db.update("messages", cv, "id = ?", idArg);
// Create/update entry in 'threads' table for the message in the
// target folder
cv.clear();
cv.put("message_id", msgId);
if (threadInfo.threadId == -1) {
if (threadInfo.rootId != -1) {
cv.put("root", threadInfo.rootId);
}
if (threadInfo.parentId != -1) {
cv.put("parent", threadInfo.parentId);
}
db.insert("threads", null, cv);
} else {
db.update("threads", cv, "id = ?",
new String[] { Long.toString(threadInfo.threadId) });
}
/*
* Add a placeholder message so we won't download the original
* message again if we synchronize before the remote move is
* complete.
*/
// We need to open this folder to get the folder id
open(OPEN_MODE_RW);
cv.clear();
cv.put("uid", oldUID);
cv.putNull("flags");
cv.put("read", 1);
cv.put("deleted", 1);
cv.put("folder_id", mFolderId);
cv.put("empty", 0);
String messageId = message.getMessageId();
if (messageId != null) {
cv.put("message_id", messageId);
}
final long newId;
if (threadInfo.msgId != -1) {
// There already existed an empty message in the target folder.
// Let's use it as placeholder.
newId = threadInfo.msgId;
db.update("messages", cv, "id = ?",
new String[] { Long.toString(newId) });
} else {
newId = db.insert("messages", null, cv);
}
/*
* Update old entry in 'threads' table to point to the newly
* created placeholder.
*/
cv.clear();
cv.put("message_id", newId);
db.update("threads", cv, "id = ?",
new String[] { Long.toString(lMessage.getThreadId()) });
}
} catch (MessagingException e) {
throw new WrappedException(e);
}
return null;
}
});
this.localStore.notifyChange();
return uidMap;
} catch (WrappedException e) {
throw(MessagingException) e.getCause();
}
}
/**
* Convenience transaction wrapper for storing a message and set it as fully downloaded. Implemented mainly to speed up DB transaction commit.
*
* @param message Message to store. Never <code>null</code>.
* @param runnable What to do before setting {@link Flag#X_DOWNLOADED_FULL}. Never <code>null</code>.
* @return The local version of the message. Never <code>null</code>.
* @throws MessagingException
*/
public Message storeSmallMessage(final Message message, final Runnable runnable) throws MessagingException {
return this.localStore.database.execute(true, new DbCallback<Message>() {
@Override
public Message doDbWork(final SQLiteDatabase db) throws WrappedException, UnavailableStorageException {
try {
appendMessages(Collections.singletonList(message));
final String uid = message.getUid();
final Message result = getMessage(uid);
runnable.run();
// Set a flag indicating this message has now be fully downloaded
result.setFlag(Flag.X_DOWNLOADED_FULL, true);
return result;
} catch (MessagingException e) {
throw new WrappedException(e);
}
}
});
}
/**
* The method differs slightly from the contract; If an incoming message already has a uid
* assigned and it matches the uid of an existing message then this message will replace the
* old message. It is implemented as a delete/insert. This functionality is used in saving
* of drafts and re-synchronization of updated server messages.
*
* NOTE that although this method is located in the LocalStore class, it is not guaranteed
* that the messages supplied as parameters are actually {@link LocalMessage} instances (in
* fact, in most cases, they are not). Therefore, if you want to make local changes only to a
* message, retrieve the appropriate local message instance first (if it already exists).
*/
@Override
public Map<String, String> appendMessages(List<? extends Message> messages) throws MessagingException {
return appendMessages(messages, false);
}
public void destroyMessages(final List<? extends Message> messages) {
try {
this.localStore.database.execute(true, new DbCallback<Void>() {
@Override
public Void doDbWork(final SQLiteDatabase db) throws WrappedException, UnavailableStorageException {
for (Message message : messages) {
try {
message.destroy();
} catch (MessagingException e) {
throw new WrappedException(e);
}
}
return null;
}
});
} catch (MessagingException e) {
throw new WrappedException(e);
}
}
private ThreadInfo getThreadInfo(SQLiteDatabase db, String messageId, boolean onlyEmpty) {
String sql = "SELECT t.id, t.message_id, t.root, t.parent " +
"FROM messages m " +
"LEFT JOIN threads t ON (t.message_id = m.id) " +
"WHERE m.folder_id = ? AND m.message_id = ? " +
((onlyEmpty) ? "AND m.empty = 1 " : "") +
"ORDER BY m.id LIMIT 1";
String[] selectionArgs = { Long.toString(mFolderId), messageId };
Cursor cursor = db.rawQuery(sql, selectionArgs);
if (cursor != null) {
try {
if (cursor.getCount() > 0) {
cursor.moveToFirst();
long threadId = cursor.getLong(0);
long msgId = cursor.getLong(1);
long rootId = (cursor.isNull(2)) ? -1 : cursor.getLong(2);
long parentId = (cursor.isNull(3)) ? -1 : cursor.getLong(3);
return new ThreadInfo(threadId, msgId, messageId, rootId, parentId);
}
} finally {
cursor.close();
}
}
return null;
}
/**
* The method differs slightly from the contract; If an incoming message already has a uid
* assigned and it matches the uid of an existing message then this message will replace
* the old message. This functionality is used in saving of drafts and re-synchronization
* of updated server messages.
*
* NOTE that although this method is located in the LocalStore class, it is not guaranteed
* that the messages supplied as parameters are actually {@link LocalMessage} instances (in
* fact, in most cases, they are not). Therefore, if you want to make local changes only to a
* message, retrieve the appropriate local message instance first (if it already exists).
* @param messages
* @param copy
* @return Map<String, String> uidMap of srcUids -> destUids
*/
private Map<String, String> appendMessages(final List<? extends Message> messages, final boolean copy) throws MessagingException {
open(OPEN_MODE_RW);
try {
final Map<String, String> uidMap = new HashMap<String, String>();
this.localStore.database.execute(true, new DbCallback<Void>() {
@Override
public Void doDbWork(final SQLiteDatabase db) throws WrappedException, UnavailableStorageException {
try {
for (Message message : messages) {
if (!(message instanceof MimeMessage)) {
throw new Error("LocalStore can only store Messages that extend MimeMessage");
}
long oldMessageId = -1;
String uid = message.getUid();
if (uid == null || copy) {
/*
* 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 = getMessage(uid);
if (oldMessage != null) {
oldMessageId = oldMessage.getId();
}
deleteAttachments(message.getUid());
}
long rootId = -1;
long parentId = -1;
if (oldMessageId == -1) {
// This is a new message. Do the message threading.
ThreadInfo threadInfo = doMessageThreading(db, message);
oldMessageId = threadInfo.msgId;
rootId = threadInfo.rootId;
parentId = threadInfo.parentId;
}
boolean isDraft = (message.getHeader(K9.IDENTITY_HEADER) != null);
List<Part> attachments;
String text;
String html;
if (isDraft) {
// Don't modify the text/plain or text/html part of our own
// draft messages because this will cause the values stored in
// the identity header to be wrong.
ViewableContainer container =
MimeUtility.extractPartsFromDraft(message);
text = container.text;
html = container.html;
attachments = container.attachments;
} else {
ViewableContainer container =
MimeUtility.extractTextAndAttachments(LocalFolder.this.localStore.mApplication, message);
attachments = container.attachments;
text = container.text;
html = HtmlConverter.convertEmoji2Img(container.html);
}
String preview = Message.calculateContentPreview(text);
try {
ContentValues cv = new ContentValues();
cv.put("uid", uid);
cv.put("subject", message.getSubject());
cv.put("sender_list", Address.pack(message.getFrom()));
cv.put("date", message.getSentDate() == null
? System.currentTimeMillis() : message.getSentDate().getTime());
cv.put("flags", LocalFolder.this.localStore.serializeFlags(message.getFlags()));
cv.put("deleted", message.isSet(Flag.DELETED) ? 1 : 0);
cv.put("read", message.isSet(Flag.SEEN) ? 1 : 0);
cv.put("flagged", message.isSet(Flag.FLAGGED) ? 1 : 0);
cv.put("answered", message.isSet(Flag.ANSWERED) ? 1 : 0);
cv.put("forwarded", message.isSet(Flag.FORWARDED) ? 1 : 0);
cv.put("folder_id", mFolderId);
cv.put("to_list", Address.pack(message.getRecipients(RecipientType.TO)));
cv.put("cc_list", Address.pack(message.getRecipients(RecipientType.CC)));
cv.put("bcc_list", Address.pack(message.getRecipients(RecipientType.BCC)));
cv.put("html_content", html.length() > 0 ? html : null);
cv.put("text_content", text.length() > 0 ? text : null);
cv.put("preview", preview.length() > 0 ? preview : null);
cv.put("reply_to_list", Address.pack(message.getReplyTo()));
cv.put("attachment_count", attachments.size());
cv.put("internal_date", message.getInternalDate() == null
? System.currentTimeMillis() : message.getInternalDate().getTime());
cv.put("mime_type", message.getMimeType());
cv.put("empty", 0);
String messageId = message.getMessageId();
if (messageId != null) {
cv.put("message_id", messageId);
}
long msgId;
if (oldMessageId == -1) {
msgId = db.insert("messages", "uid", cv);
// Create entry in 'threads' table
cv.clear();
cv.put("message_id", msgId);
if (rootId != -1) {
cv.put("root", rootId);
}
if (parentId != -1) {
cv.put("parent", parentId);
}
db.insert("threads", null, cv);
} else {
db.update("messages", cv, "id = ?", new String[] { Long.toString(oldMessageId) });
msgId = oldMessageId;
}
for (Part attachment : attachments) {
saveAttachment(msgId, attachment, copy);
}
saveHeaders(msgId, (MimeMessage)message);
} catch (Exception e) {
throw new MessagingException("Error appending message", e);
}
}
} catch (MessagingException e) {
throw new WrappedException(e);
}
return null;
}
});
this.localStore.notifyChange();
return uidMap;
} catch (WrappedException e) {
throw(MessagingException) e.getCause();
}
}
/**
* Update the given message in the LocalStore without first deleting the existing
* message (contrast with appendMessages). This method is used to store changes
* to the given message while updating attachments and not removing existing
* attachment data.
* TODO In the future this method should be combined with appendMessages since the Message
* contains enough data to decide what to do.
* @param message
* @throws MessagingException
*/
public void updateMessage(final LocalMessage message) throws MessagingException {
open(OPEN_MODE_RW);
try {
this.localStore.database.execute(false, new DbCallback<Void>() {
@Override
public Void doDbWork(final SQLiteDatabase db) throws WrappedException, UnavailableStorageException {
try {
message.buildMimeRepresentation();
ViewableContainer container =
MimeUtility.extractTextAndAttachments(LocalFolder.this.localStore.mApplication, message);
List<Part> attachments = container.attachments;
String text = container.text;
String html = HtmlConverter.convertEmoji2Img(container.html);
String preview = Message.calculateContentPreview(text);
try {
db.execSQL("UPDATE messages SET "
+ "uid = ?, subject = ?, sender_list = ?, date = ?, flags = ?, "
+ "folder_id = ?, to_list = ?, cc_list = ?, bcc_list = ?, "
+ "html_content = ?, text_content = ?, preview = ?, reply_to_list = ?, "
+ "attachment_count = ?, read = ?, flagged = ?, answered = ?, forwarded = ? "
+ "WHERE id = ?",
new Object[] {
message.getUid(),
message.getSubject(),
Address.pack(message.getFrom()),
message.getSentDate() == null ? System
.currentTimeMillis() : message.getSentDate()
.getTime(),
LocalFolder.this.localStore.serializeFlags(message.getFlags()),
mFolderId,
Address.pack(message
.getRecipients(RecipientType.TO)),
Address.pack(message
.getRecipients(RecipientType.CC)),
Address.pack(message
.getRecipients(RecipientType.BCC)),
html.length() > 0 ? html : null,
text.length() > 0 ? text : null,
preview.length() > 0 ? preview : null,
Address.pack(message.getReplyTo()),
attachments.size(),
message.isSet(Flag.SEEN) ? 1 : 0,
message.isSet(Flag.FLAGGED) ? 1 : 0,
message.isSet(Flag.ANSWERED) ? 1 : 0,
message.isSet(Flag.FORWARDED) ? 1 : 0,
message.getId()
});
for (int i = 0, count = attachments.size(); i < count; i++) {
Part attachment = attachments.get(i);
saveAttachment(message.getId(), attachment, false);
}
saveHeaders(message.getId(), message);
} catch (Exception e) {
throw new MessagingException("Error appending message", e);
}
} catch (MessagingException e) {
throw new WrappedException(e);
}
return null;
}
});
} catch (WrappedException e) {
throw(MessagingException) e.getCause();
}
this.localStore.notifyChange();
}
/**
* Save the headers of the given message. Note that the message is not
* necessarily a {@link LocalMessage} instance.
* @param id
* @param message
* @throws com.fsck.k9.mail.MessagingException
*/
private void saveHeaders(final long id, final MimeMessage message) throws MessagingException {
this.localStore.database.execute(true, new DbCallback<Void>() {
@Override
public Void doDbWork(final SQLiteDatabase db) throws WrappedException, UnavailableStorageException {
deleteHeaders(id);
for (String name : message.getHeaderNames()) {
String[] values = message.getHeader(name);
for (String value : values) {
ContentValues cv = new ContentValues();
cv.put("message_id", id);
cv.put("name", name);
cv.put("value", value);
db.insert("headers", "name", cv);
}
}
// Remember that all headers for this message have been saved, so it is
// not necessary to download them again in case the user wants to see all headers.
List<Flag> appendedFlags = new ArrayList<Flag>();
appendedFlags.addAll(message.getFlags());
appendedFlags.add(Flag.X_GOT_ALL_HEADERS);
db.execSQL("UPDATE messages " + "SET flags = ? " + " WHERE id = ?",
new Object[]
{ LocalFolder.this.localStore.serializeFlags(appendedFlags), id });
return null;
}
});
}
void deleteHeaders(final long id) throws UnavailableStorageException {
this.localStore.database.execute(false, new DbCallback<Void>() {
@Override
public Void doDbWork(final SQLiteDatabase db) throws WrappedException, UnavailableStorageException {
db.execSQL("DELETE FROM headers WHERE message_id = ?", new Object[]
{ id });
return null;
}
});
}
/**
* @param messageId
* @param attachment
* @param saveAsNew
* @throws IOException
* @throws MessagingException
*/
private void saveAttachment(final long messageId, final Part attachment, final boolean saveAsNew)
throws IOException, MessagingException {
try {
this.localStore.database.execute(true, new DbCallback<Void>() {
@Override
public Void doDbWork(final SQLiteDatabase db) throws WrappedException, UnavailableStorageException {
try {
long attachmentId = -1;
Uri contentUri = null;
int size = -1;
File tempAttachmentFile = null;
if ((!saveAsNew) && (attachment instanceof LocalAttachmentBodyPart)) {
attachmentId = ((LocalAttachmentBodyPart) attachment).getAttachmentId();
}
final File attachmentDirectory = StorageManager.getInstance(LocalFolder.this.localStore.mApplication).getAttachmentDirectory(LocalFolder.this.localStore.uUid, LocalFolder.this.localStore.database.getStorageProviderId());
if (attachment.getBody() != null) {
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
* so we copy the data into a cached attachment file.
*/
InputStream in = attachment.getBody().getInputStream();
try {
tempAttachmentFile = File.createTempFile("att", null, attachmentDirectory);
FileOutputStream out = new FileOutputStream(tempAttachmentFile);
try {
size = IOUtils.copy(in, out);
} finally {
out.close();
}
} finally {
try { in.close(); } catch (Throwable ignore) {}
}
}
}
if (size == -1) {
/*
* If the attachment is not yet downloaded see if we can pull a size
* off the Content-Disposition.
*/
String disposition = attachment.getDisposition();
if (disposition != null) {
String sizeParam = MimeUtility.getHeaderParameter(disposition, "size");
if (sizeParam != null) {
try {
size = Integer.parseInt(sizeParam);
} catch (NumberFormatException e) { /* Ignore */ }
}
}
}
if (size == -1) {
size = 0;
}
String storeData =
Utility.combine(attachment.getHeader(
MimeHeader.HEADER_ANDROID_ATTACHMENT_STORE_DATA), ',');
String name = MimeUtility.getHeaderParameter(attachment.getContentType(), "name");
String contentId = MimeUtility.getHeaderParameter(attachment.getContentId(), null);
String contentDisposition = MimeUtility.unfoldAndDecode(attachment.getDisposition());
String dispositionType = contentDisposition;
if (dispositionType != null) {
int pos = dispositionType.indexOf(';');
if (pos != -1) {
// extract the disposition-type, "attachment", "inline" or extension-token (see the RFC 2183)
dispositionType = dispositionType.substring(0, pos);
}
}
if (name == null && contentDisposition != null) {
name = MimeUtility.getHeaderParameter(contentDisposition, "filename");
}
if (attachmentId == -1) {
ContentValues cv = new ContentValues();
cv.put("message_id", messageId);
cv.put("content_uri", contentUri != null ? contentUri.toString() : null);
cv.put("store_data", storeData);
cv.put("size", size);
cv.put("name", name);
cv.put("mime_type", attachment.getMimeType());
cv.put("content_id", contentId);
cv.put("content_disposition", dispositionType);
attachmentId = db.insert("attachments", "message_id", cv);
} else {
ContentValues cv = new ContentValues();
cv.put("content_uri", contentUri != null ? contentUri.toString() : null);
cv.put("size", size);
db.update("attachments", cv, "id = ?", new String[]
{ Long.toString(attachmentId) });
}
if (attachmentId != -1 && tempAttachmentFile != null) {
File attachmentFile = new File(attachmentDirectory, Long.toString(attachmentId));
tempAttachmentFile.renameTo(attachmentFile);
contentUri = AttachmentProvider.getAttachmentUri(
getAccount(),
attachmentId);
if (MimeUtil.isMessage(attachment.getMimeType())) {
attachment.setBody(new LocalAttachmentMessageBody(
contentUri, LocalFolder.this.localStore.mApplication));
} else {
attachment.setBody(new LocalAttachmentBody(
contentUri, LocalFolder.this.localStore.mApplication));
}
ContentValues cv = new ContentValues();
cv.put("content_uri", contentUri != null ? contentUri.toString() : null);
db.update("attachments", cv, "id = ?", new String[]
{ Long.toString(attachmentId) });
}
/* The message has attachment with Content-ID */
if (contentId != null && contentUri != null) {
Cursor cursor = db.query("messages", new String[]
{ "html_content" }, "id = ?", new String[]
{ Long.toString(messageId) }, null, null, null);
try {
if (cursor.moveToNext()) {
String htmlContent = cursor.getString(0);
if (htmlContent != null) {
String newHtmlContent = htmlContent.replaceAll(
Pattern.quote("cid:" + contentId),
contentUri.toString());
ContentValues cv = new ContentValues();
cv.put("html_content", newHtmlContent);
db.update("messages", cv, "id = ?", new String[]
{ Long.toString(messageId) });
}
}
} finally {
Utility.closeQuietly(cursor);
}
}
if (attachmentId != -1 && attachment instanceof LocalAttachmentBodyPart) {
((LocalAttachmentBodyPart) attachment).setAttachmentId(attachmentId);
}
return null;
} catch (MessagingException e) {
throw new WrappedException(e);
} catch (IOException e) {
throw new WrappedException(e);
}
}
});
} catch (WrappedException e) {
final Throwable cause = e.getCause();
if (cause instanceof IOException) {
throw (IOException) cause;
}
throw (MessagingException) cause;
}
}
/**
* Changes the stored uid of the given message (using it's internal id as a key) to
* the uid in the message.
* @param message
* @throws com.fsck.k9.mail.MessagingException
*/
public void changeUid(final LocalMessage message) throws MessagingException {
open(OPEN_MODE_RW);
final ContentValues cv = new ContentValues();
cv.put("uid", message.getUid());
this.localStore.database.execute(false, new DbCallback<Void>() {
@Override
public Void doDbWork(final SQLiteDatabase db) throws WrappedException, UnavailableStorageException {
db.update("messages", cv, "id = ?", new String[]
{ Long.toString(message.getId()) });
return null;
}
});
//TODO: remove this once the UI code exclusively uses the database id
this.localStore.notifyChange();
}
@Override
public void setFlags(final List<? extends Message> messages, final Set<Flag> flags, final boolean value)
throws MessagingException {
open(OPEN_MODE_RW);
// Use one transaction to set all flags
try {
this.localStore.database.execute(true, new DbCallback<Void>() {
@Override
public Void doDbWork(final SQLiteDatabase db) throws WrappedException,
UnavailableStorageException {
for (Message message : messages) {
try {
message.setFlags(flags, value);
} catch (MessagingException e) {
Log.e(K9.LOG_TAG, "Something went wrong while setting flag", e);
}
}
return null;
}
});
} catch (WrappedException e) {
throw(MessagingException) e.getCause();
}
}
@Override
public void setFlags(final Set<Flag> flags, boolean value)
throws MessagingException {
open(OPEN_MODE_RW);
for (Message message : getMessages(null)) {
message.setFlags(flags, value);
}
}
@Override
public String getUidFromMessageId(Message message) throws MessagingException {
throw new MessagingException("Cannot call getUidFromMessageId on LocalFolder");
}
public void clearMessagesOlderThan(long cutoff) throws MessagingException {
open(OPEN_MODE_RO);
List<? extends Message> messages = this.localStore.getMessages(
null,
this,
"SELECT " + LocalStore.GET_MESSAGES_COLS +
"FROM messages " +
"LEFT JOIN threads ON (threads.message_id = messages.id) " +
"WHERE (empty IS NULL OR empty != 1) AND " +
"(folder_id = ? and date < ?)",
new String[] {
Long.toString(mFolderId), Long.toString(cutoff)
});
for (Message message : messages) {
message.destroy();
}
this.localStore.notifyChange();
}
public void clearAllMessages() throws MessagingException {
final String[] folderIdArg = new String[] { Long.toString(mFolderId) };
open(OPEN_MODE_RO);
try {
this.localStore.database.execute(false, new DbCallback<Void>() {
@Override
public Void doDbWork(final SQLiteDatabase db) throws WrappedException {
try {
// Get UIDs for all messages to delete
Cursor cursor = db.query("messages", new String[] { "uid" },
"folder_id = ? AND (empty IS NULL OR empty != 1)",
folderIdArg, null, null, null);
try {
// Delete attachments of these messages
while (cursor.moveToNext()) {
deleteAttachments(cursor.getString(0));
}
} finally {
cursor.close();
}
// Delete entries in 'threads' and 'messages'
db.execSQL("DELETE FROM threads WHERE message_id IN " +
"(SELECT id FROM messages WHERE folder_id = ?)", folderIdArg);
db.execSQL("DELETE FROM messages WHERE folder_id = ?", folderIdArg);
return null;
} catch (MessagingException e) {
throw new WrappedException(e);
}
}
});
} catch (WrappedException e) {
throw(MessagingException) e.getCause();
}
this.localStore.notifyChange();
setPushState(null);
setLastPush(0);
setLastChecked(0);
setVisibleLimit(getAccount().getDisplayCount());
}
@Override
public void delete(final boolean recurse) throws MessagingException {
try {
this.localStore.database.execute(false, new DbCallback<Void>() {
@Override
public Void doDbWork(final SQLiteDatabase db) throws WrappedException, UnavailableStorageException {
try {
// We need to open the folder first to make sure we've got it's id
open(OPEN_MODE_RO);
List<? extends Message> messages = getMessages(null);
for (Message message : messages) {
deleteAttachments(message.getUid());
}
} catch (MessagingException e) {
throw new WrappedException(e);
}
db.execSQL("DELETE FROM folders WHERE id = ?", new Object[]
{ Long.toString(mFolderId), });
return null;
}
});
} catch (WrappedException e) {
throw(MessagingException) e.getCause();
}
}
@Override
public boolean equals(Object o) {
if (o instanceof LocalFolder) {
return ((LocalFolder)o).mName.equals(mName);
}
return super.equals(o);
}
@Override
public int hashCode() {
return mName.hashCode();
}
void deleteAttachments(final long messageId) throws MessagingException {
open(OPEN_MODE_RW);
this.localStore.database.execute(false, new DbCallback<Void>() {
@Override
public Void doDbWork(final SQLiteDatabase db) throws WrappedException, UnavailableStorageException {
Cursor attachmentsCursor = null;
try {
String accountUuid = getUuid();
Context context = LocalFolder.this.localStore.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(LocalFolder.this.localStore.mApplication)
.getAttachmentDirectory(LocalFolder.this.localStore.uUid, LocalFolder.this.localStore.database.getStorageProviderId());
while (attachmentsCursor.moveToNext()) {
String attachmentId = Long.toString(attachmentsCursor.getLong(0));
try {
// Delete stored attachment
File file = new File(attachmentDirectory, attachmentId);
if (file.exists()) {
file.delete();
}
// 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);
}
return null;
}
});
}
private void deleteAttachments(final String uid) throws MessagingException {
open(OPEN_MODE_RW);
try {
this.localStore.database.execute(false, new DbCallback<Void>() {
@Override
public Void doDbWork(final SQLiteDatabase db) throws WrappedException, UnavailableStorageException {
Cursor messagesCursor = null;
try {
messagesCursor = db.query("messages", new String[]
{ "id" }, "folder_id = ? AND uid = ?", new String[]
{ Long.toString(mFolderId), uid }, null, null, null);
while (messagesCursor.moveToNext()) {
long messageId = messagesCursor.getLong(0);
deleteAttachments(messageId);
}
} catch (MessagingException e) {
throw new WrappedException(e);
} finally {
Utility.closeQuietly(messagesCursor);
}
return null;
}
});
} catch (WrappedException e) {
throw(MessagingException) e.getCause();
}
}
@Override
public boolean isInTopGroup() {
return mInTopGroup;
}
public void setInTopGroup(boolean inTopGroup) throws MessagingException {
mInTopGroup = inTopGroup;
updateFolderColumn("top_group", mInTopGroup ? 1 : 0);
}
public Integer getLastUid() {
return mLastUid;
}
/**
* <p>Fetches the most recent <b>numeric</b> UID value in this folder. This is used by
* {@link com.fsck.k9.controller.MessagingController#shouldNotifyForMessage} to see if messages being
* fetched are new and unread. Messages are "new" if they have a UID higher than the most recent UID prior
* to synchronization.</p>
*
* <p>This only works for protocols with numeric UIDs (like IMAP). For protocols with
* alphanumeric UIDs (like POP), this method quietly fails and shouldNotifyForMessage() will
* always notify for unread messages.</p>
*
* <p>Once Issue 1072 has been fixed, this method and shouldNotifyForMessage() should be
* updated to use internal dates rather than UIDs to determine new-ness. While this doesn't
* solve things for POP (which doesn't have internal dates), we can likely use this as a
* framework to examine send date in lieu of internal date.</p>
* @throws MessagingException
*/
public void updateLastUid() throws MessagingException {
Integer lastUid = this.localStore.database.execute(false, new DbCallback<Integer>() {
@Override
public Integer doDbWork(final SQLiteDatabase db) {
Cursor cursor = null;
try {
open(OPEN_MODE_RO);
cursor = db.rawQuery("SELECT MAX(uid) FROM messages WHERE folder_id=?", new String[] { Long.toString(mFolderId) });
if (cursor.getCount() > 0) {
cursor.moveToFirst();
return cursor.getInt(0);
}
} catch (Exception e) {
Log.e(K9.LOG_TAG, "Unable to updateLastUid: ", e);
} finally {
Utility.closeQuietly(cursor);
}
return null;
}
});
if (K9.DEBUG)
Log.d(K9.LOG_TAG, "Updated last UID for folder " + mName + " to " + lastUid);
mLastUid = lastUid;
}
public Long getOldestMessageDate() throws MessagingException {
return this.localStore.database.execute(false, new DbCallback<Long>() {
@Override
public Long doDbWork(final SQLiteDatabase db) {
Cursor cursor = null;
try {
open(OPEN_MODE_RO);
cursor = db.rawQuery("SELECT MIN(date) FROM messages WHERE folder_id=?", new String[] { Long.toString(mFolderId) });
if (cursor.getCount() > 0) {
cursor.moveToFirst();
return cursor.getLong(0);
}
} catch (Exception e) {
Log.e(K9.LOG_TAG, "Unable to fetch oldest message date: ", e);
} finally {
Utility.closeQuietly(cursor);
}
return null;
}
});
}
private ThreadInfo doMessageThreading(SQLiteDatabase db, Message message)
throws MessagingException {
long rootId = -1;
long parentId = -1;
String messageId = message.getMessageId();
// If there's already an empty message in the database, update that
ThreadInfo msgThreadInfo = getThreadInfo(db, messageId, true);
// Get the message IDs from the "References" header line
String[] referencesArray = message.getHeader("References");
List<String> messageIds = null;
if (referencesArray != null && referencesArray.length > 0) {
messageIds = Utility.extractMessageIds(referencesArray[0]);
}
// Append the first message ID from the "In-Reply-To" header line
String[] inReplyToArray = message.getHeader("In-Reply-To");
String inReplyTo;
if (inReplyToArray != null && inReplyToArray.length > 0) {
inReplyTo = Utility.extractMessageId(inReplyToArray[0]);
if (inReplyTo != null) {
if (messageIds == null) {
messageIds = new ArrayList<String>(1);
messageIds.add(inReplyTo);
} else if (!messageIds.contains(inReplyTo)) {
messageIds.add(inReplyTo);
}
}
}
if (messageIds == null) {
// This is not a reply, nothing to do for us.
return (msgThreadInfo != null) ?
msgThreadInfo : new ThreadInfo(-1, -1, messageId, -1, -1);
}
for (String reference : messageIds) {
ThreadInfo threadInfo = getThreadInfo(db, reference, false);
if (threadInfo == null) {
// Create placeholder message in 'messages' table
ContentValues cv = new ContentValues();
cv.put("message_id", reference);
cv.put("folder_id", mFolderId);
cv.put("empty", 1);
long newMsgId = db.insert("messages", null, cv);
// Create entry in 'threads' table
cv.clear();
cv.put("message_id", newMsgId);
if (rootId != -1) {
cv.put("root", rootId);
}
if (parentId != -1) {
cv.put("parent", parentId);
}
parentId = db.insert("threads", null, cv);
if (rootId == -1) {
rootId = parentId;
}
} else {
if (rootId != -1 && threadInfo.rootId == -1 && rootId != threadInfo.threadId) {
// We found an existing root container that is not
// the root of our current path (References).
// Connect it to the current parent.
// Let all children know who's the new root
ContentValues cv = new ContentValues();
cv.put("root", rootId);
db.update("threads", cv, "root = ?",
new String[] { Long.toString(threadInfo.threadId) });
// Connect the message to the current parent
cv.put("parent", parentId);
db.update("threads", cv, "id = ?",
new String[] { Long.toString(threadInfo.threadId) });
} else {
rootId = (threadInfo.rootId == -1) ?
threadInfo.threadId : threadInfo.rootId;
}
parentId = threadInfo.threadId;
}
}
//TODO: set in-reply-to "link" even if one already exists
long threadId;
long msgId;
if (msgThreadInfo != null) {
threadId = msgThreadInfo.threadId;
msgId = msgThreadInfo.msgId;
} else {
threadId = -1;
msgId = -1;
}
return new ThreadInfo(threadId, msgId, messageId, rootId, parentId);
}
public List<Message> extractNewMessages(final List<Message> messages)
throws MessagingException {
try {
return this.localStore.database.execute(false, new DbCallback<List<Message>>() {
@Override
public List<Message> doDbWork(final SQLiteDatabase db) throws WrappedException {
try {
open(OPEN_MODE_RW);
} catch (MessagingException e) {
throw new WrappedException(e);
}
List<Message> result = new ArrayList<Message>();
List<String> selectionArgs = new ArrayList<String>();
Set<String> existingMessages = new HashSet<String>();
int start = 0;
while (start < messages.size()) {
StringBuilder selection = new StringBuilder();
selection.append("folder_id = ? AND UID IN (");
selectionArgs.add(Long.toString(mFolderId));
int count = Math.min(messages.size() - start, LocalStore.UID_CHECK_BATCH_SIZE);
for (int i = start, end = start + count; i < end; i++) {
if (i > start) {
selection.append(",?");
} else {
selection.append("?");
}
selectionArgs.add(messages.get(i).getUid());
}
selection.append(")");
Cursor cursor = db.query("messages", LocalStore.UID_CHECK_PROJECTION,
selection.toString(), selectionArgs.toArray(LocalStore.EMPTY_STRING_ARRAY),
null, null, null);
try {
while (cursor.moveToNext()) {
String uid = cursor.getString(0);
existingMessages.add(uid);
}
} finally {
Utility.closeQuietly(cursor);
}
for (int i = start, end = start + count; i < end; i++) {
Message message = messages.get(i);
if (!existingMessages.contains(message.getUid())) {
result.add(message);
}
}
existingMessages.clear();
selectionArgs.clear();
start += count;
}
return result;
}
});
} catch (WrappedException e) {
throw(MessagingException) e.getCause();
}
}
private Account getAccount() {
return localStore.getAccount();
}
}