/*
* Copyright (C) 2009 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.email;
import android.app.Service;
import android.content.ContentResolver;
import android.content.ContentUris;
import android.content.ContentValues;
import android.content.Context;
import android.content.Intent;
import android.database.Cursor;
import android.net.Uri;
import android.os.Bundle;
import android.os.IBinder;
import android.os.RemoteCallbackList;
import android.os.RemoteException;
import android.util.Log;
import com.android.email.mail.store.Pop3Store.Pop3Message;
import com.android.email.provider.AccountBackupRestore;
import com.android.email.service.EmailServiceUtils;
import com.android.email.service.MailService;
import com.android.emailcommon.Api;
import com.android.emailcommon.Logging;
import com.android.emailcommon.mail.AuthenticationFailedException;
import com.android.emailcommon.mail.Folder.MessageRetrievalListener;
import com.android.emailcommon.mail.MessagingException;
import com.android.emailcommon.provider.Account;
import com.android.emailcommon.provider.EmailContent;
import com.android.emailcommon.provider.EmailContent.Attachment;
import com.android.emailcommon.provider.EmailContent.Body;
import com.android.emailcommon.provider.EmailContent.MailboxColumns;
import com.android.emailcommon.provider.EmailContent.Message;
import com.android.emailcommon.provider.EmailContent.MessageColumns;
import com.android.emailcommon.provider.HostAuth;
import com.android.emailcommon.provider.Mailbox;
import com.android.emailcommon.service.EmailServiceStatus;
import com.android.emailcommon.service.IEmailService;
import com.android.emailcommon.service.IEmailServiceCallback;
import com.android.emailcommon.service.SearchParams;
import com.android.emailcommon.utility.AttachmentUtilities;
import com.android.emailcommon.utility.EmailAsyncTask;
import com.android.emailcommon.utility.Utility;
import com.google.common.annotations.VisibleForTesting;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.concurrent.ConcurrentHashMap;
/**
* New central controller/dispatcher for Email activities that may require remote operations.
* Handles disambiguating between legacy MessagingController operations and newer provider/sync
* based code. We implement Service to allow loadAttachment calls to be sent in a consistent manner
* to IMAP, POP3, and EAS by AttachmentDownloadService
*/
public class Controller {
private static final String TAG = "Controller";
private static Controller sInstance;
private final Context mContext;
private Context mProviderContext;
private final MessagingController mLegacyController;
private final LegacyListener mLegacyListener = new LegacyListener();
private final ServiceCallback mServiceCallback = new ServiceCallback();
private final HashSet<Result> mListeners = new HashSet<Result>();
/*package*/ final ConcurrentHashMap<Long, Boolean> mLegacyControllerMap =
new ConcurrentHashMap<Long, Boolean>();
// Note that 0 is a syntactically valid account key; however there can never be an account
// with id = 0, so attempts to restore the account will return null. Null values are
// handled properly within the code, so this won't cause any issues.
private static final long GLOBAL_MAILBOX_ACCOUNT_KEY = 0;
/*package*/ static final String ATTACHMENT_MAILBOX_SERVER_ID = "__attachment_mailbox__";
/*package*/ static final String ATTACHMENT_MESSAGE_UID_PREFIX = "__attachment_message__";
/*package*/ static final String SEARCH_MAILBOX_SERVER_ID = "__search_mailbox__";
private static final String WHERE_TYPE_ATTACHMENT =
MailboxColumns.TYPE + "=" + Mailbox.TYPE_ATTACHMENT;
private static final String WHERE_MAILBOX_KEY = MessageColumns.MAILBOX_KEY + "=?";
private static final String[] MESSAGEID_TO_ACCOUNTID_PROJECTION = new String[] {
EmailContent.RECORD_ID,
EmailContent.MessageColumns.ACCOUNT_KEY
};
private static final int MESSAGEID_TO_ACCOUNTID_COLUMN_ACCOUNTID = 1;
private static final String[] BODY_SOURCE_KEY_PROJECTION =
new String[] {Body.SOURCE_MESSAGE_KEY};
private static final int BODY_SOURCE_KEY_COLUMN = 0;
private static final String WHERE_MESSAGE_KEY = Body.MESSAGE_KEY + "=?";
private static final String MAILBOXES_FOR_ACCOUNT_SELECTION = MailboxColumns.ACCOUNT_KEY + "=?";
private static final String MAILBOXES_FOR_ACCOUNT_EXCEPT_ACCOUNT_MAILBOX_SELECTION =
MAILBOXES_FOR_ACCOUNT_SELECTION + " AND " + MailboxColumns.TYPE + "!=" +
Mailbox.TYPE_EAS_ACCOUNT_MAILBOX;
private static final String MESSAGES_FOR_ACCOUNT_SELECTION = MessageColumns.ACCOUNT_KEY + "=?";
// Service callbacks as set up via setCallback
private static RemoteCallbackList<IEmailServiceCallback> sCallbackList =
new RemoteCallbackList<IEmailServiceCallback>();
private volatile boolean mInUnitTests = false;
protected Controller(Context _context) {
mContext = _context.getApplicationContext();
mProviderContext = _context;
mLegacyController = MessagingController.getInstance(mProviderContext, this);
mLegacyController.addListener(mLegacyListener);
}
/**
* Mark this controller as being in use in a unit test.
* This is a kludge vs having proper mocks and dependency injection; since the Controller is a
* global singleton there isn't much else we can do.
*/
public void markForTest(boolean inUnitTests) {
mInUnitTests = inUnitTests;
}
/**
* Cleanup for test. Mustn't be called for the regular {@link Controller}, as it's a
* singleton and lives till the process finishes.
*
* <p>However, this method MUST be called for mock instances.
*/
public void cleanupForTest() {
mLegacyController.removeListener(mLegacyListener);
}
/**
* Gets or creates the singleton instance of Controller.
*/
public synchronized static Controller getInstance(Context _context) {
if (sInstance == null) {
sInstance = new Controller(_context);
}
return sInstance;
}
/**
* Inject a mock controller. Used only for testing. Affects future calls to getInstance().
*
* Tests that use this method MUST clean it up by calling this method again with null.
*/
public synchronized static void injectMockControllerForTest(Controller mockController) {
sInstance = mockController;
}
/**
* For testing only: Inject a different context for provider access. This will be
* used internally for access the underlying provider (e.g. getContentResolver().query()).
* @param providerContext the provider context to be used by this instance
*/
public void setProviderContext(Context providerContext) {
mProviderContext = providerContext;
}
/**
* Any UI code that wishes for callback results (on async ops) should register their callback
* here (typically from onResume()). Unregistered callbacks will never be called, to prevent
* problems when the command completes and the activity has already paused or finished.
* @param listener The callback that may be used in action methods
*/
public void addResultCallback(Result listener) {
synchronized (mListeners) {
listener.setRegistered(true);
mListeners.add(listener);
}
}
/**
* Any UI code that no longer wishes for callback results (on async ops) should unregister
* their callback here (typically from onPause()). Unregistered callbacks will never be called,
* to prevent problems when the command completes and the activity has already paused or
* finished.
* @param listener The callback that may no longer be used
*/
public void removeResultCallback(Result listener) {
synchronized (mListeners) {
listener.setRegistered(false);
mListeners.remove(listener);
}
}
public Collection<Result> getResultCallbacksForTest() {
return mListeners;
}
/**
* Delete all Messages that live in the attachment mailbox
*/
public void deleteAttachmentMessages() {
// Note: There should only be one attachment mailbox at present
ContentResolver resolver = mProviderContext.getContentResolver();
Cursor c = null;
try {
c = resolver.query(Mailbox.CONTENT_URI, EmailContent.ID_PROJECTION,
WHERE_TYPE_ATTACHMENT, null, null);
while (c.moveToNext()) {
long mailboxId = c.getLong(EmailContent.ID_PROJECTION_COLUMN);
// Must delete attachments BEFORE messages
AttachmentUtilities.deleteAllMailboxAttachmentFiles(mProviderContext, 0,
mailboxId);
resolver.delete(Message.CONTENT_URI, WHERE_MAILBOX_KEY,
new String[] {Long.toString(mailboxId)});
}
} finally {
if (c != null) {
c.close();
}
}
}
/**
* Get a mailbox based on a sqlite WHERE clause
*/
private Mailbox getGlobalMailboxWhere(String where) {
Cursor c = mProviderContext.getContentResolver().query(Mailbox.CONTENT_URI,
Mailbox.CONTENT_PROJECTION, where, null, null);
try {
if (c.moveToFirst()) {
Mailbox m = new Mailbox();
m.restore(c);
return m;
}
} finally {
c.close();
}
return null;
}
/**
* Returns the attachment mailbox (where we store eml attachment Emails), creating one
* if necessary
* @return the global attachment mailbox
*/
public Mailbox getAttachmentMailbox() {
Mailbox m = getGlobalMailboxWhere(WHERE_TYPE_ATTACHMENT);
if (m == null) {
m = new Mailbox();
m.mAccountKey = GLOBAL_MAILBOX_ACCOUNT_KEY;
m.mServerId = ATTACHMENT_MAILBOX_SERVER_ID;
m.mFlagVisible = false;
m.mDisplayName = ATTACHMENT_MAILBOX_SERVER_ID;
m.mSyncInterval = Mailbox.CHECK_INTERVAL_NEVER;
m.mType = Mailbox.TYPE_ATTACHMENT;
m.save(mProviderContext);
}
return m;
}
/**
* Returns the search mailbox for the specified account, creating one if necessary
* @return the search mailbox for the passed in account
*/
public Mailbox getSearchMailbox(long accountId) {
Mailbox m = Mailbox.restoreMailboxOfType(mContext, accountId, Mailbox.TYPE_SEARCH);
if (m == null) {
m = new Mailbox();
m.mAccountKey = accountId;
m.mServerId = SEARCH_MAILBOX_SERVER_ID;
m.mFlagVisible = false;
m.mDisplayName = SEARCH_MAILBOX_SERVER_ID;
m.mSyncInterval = Mailbox.CHECK_INTERVAL_NEVER;
m.mType = Mailbox.TYPE_SEARCH;
m.mFlags = Mailbox.FLAG_HOLDS_MAIL;
m.mParentKey = Mailbox.NO_MAILBOX;
m.save(mProviderContext);
}
return m;
}
/**
* Create a Message from the Uri and store it in the attachment mailbox
* @param uri the uri containing message content
* @return the Message or null
*/
public Message loadMessageFromUri(Uri uri) {
Mailbox mailbox = getAttachmentMailbox();
if (mailbox == null) return null;
try {
InputStream is = mProviderContext.getContentResolver().openInputStream(uri);
try {
// First, create a Pop3Message from the attachment and then parse it
Pop3Message pop3Message = new Pop3Message(
ATTACHMENT_MESSAGE_UID_PREFIX + System.currentTimeMillis(), null);
pop3Message.parse(is);
// Now, pull out the header fields
Message msg = new Message();
LegacyConversions.updateMessageFields(msg, pop3Message, 0, mailbox.mId);
// Commit the message to the local store
msg.save(mProviderContext);
// Setup the rest of the message and mark it completely loaded
mLegacyController.copyOneMessageToProvider(pop3Message, msg,
Message.FLAG_LOADED_COMPLETE, mProviderContext);
// Restore the complete message and return it
return Message.restoreMessageWithId(mProviderContext, msg.mId);
} catch (MessagingException e) {
} catch (IOException e) {
}
} catch (FileNotFoundException e) {
}
return null;
}
/**
* Set logging flags for external sync services
*
* Generally this should be called by anybody who changes Email.DEBUG
*/
public void serviceLogging(int debugFlags) {
IEmailService service = EmailServiceUtils.getExchangeService(mContext, mServiceCallback);
try {
service.setLogging(debugFlags);
} catch (RemoteException e) {
// TODO Change exception handling to be consistent with however this method
// is implemented for other protocols
Log.d("setLogging", "RemoteException" + e);
}
}
/**
* Request a remote update of mailboxes for an account.
*/
public void updateMailboxList(final long accountId) {
Utility.runAsync(new Runnable() {
@Override
public void run() {
final IEmailService service = getServiceForAccount(accountId);
if (service != null) {
// Service implementation
try {
service.updateFolderList(accountId);
} catch (RemoteException e) {
// TODO Change exception handling to be consistent with however this method
// is implemented for other protocols
Log.d("updateMailboxList", "RemoteException" + e);
}
} else {
// MessagingController implementation
mLegacyController.listFolders(accountId, mLegacyListener);
}
}
});
}
/**
* Request a remote update of a mailbox. For use by the timed service.
*
* Functionally this is quite similar to updateMailbox(), but it's a separate API and
* separate callback in order to keep UI callbacks from affecting the service loop.
*/
public void serviceCheckMail(final long accountId, final long mailboxId, final long tag) {
IEmailService service = getServiceForAccount(accountId);
if (service != null) {
// Service implementation
// try {
// TODO this isn't quite going to work, because we're going to get the
// generic (UI) callbacks and not the ones we need to restart the ol' service.
// service.startSync(mailboxId, tag);
mLegacyListener.checkMailFinished(mContext, accountId, mailboxId, tag);
// } catch (RemoteException e) {
// TODO Change exception handling to be consistent with however this method
// is implemented for other protocols
// Log.d("updateMailbox", "RemoteException" + e);
// }
} else {
// MessagingController implementation
Utility.runAsync(new Runnable() {
public void run() {
mLegacyController.checkMail(accountId, tag, mLegacyListener);
}
});
}
}
/**
* Request a remote update of a mailbox.
*
* The contract here should be to try and update the headers ASAP, in order to populate
* a simple message list. We should also at this point queue up a background task of
* downloading some/all of the messages in this mailbox, but that should be interruptable.
*/
public void updateMailbox(final long accountId, final long mailboxId, boolean userRequest) {
IEmailService service = getServiceForAccount(accountId);
if (service != null) {
try {
service.startSync(mailboxId, userRequest);
} catch (RemoteException e) {
// TODO Change exception handling to be consistent with however this method
// is implemented for other protocols
Log.d("updateMailbox", "RemoteException" + e);
}
} else {
// MessagingController implementation
Utility.runAsync(new Runnable() {
public void run() {
// TODO shouldn't be passing fully-build accounts & mailboxes into APIs
Account account =
Account.restoreAccountWithId(mProviderContext, accountId);
Mailbox mailbox =
Mailbox.restoreMailboxWithId(mProviderContext, mailboxId);
if (account == null || mailbox == null ||
mailbox.mType == Mailbox.TYPE_SEARCH) {
return;
}
mLegacyController.synchronizeMailbox(account, mailbox, mLegacyListener);
}
});
}
}
/**
* Request that any final work necessary be done, to load a message.
*
* Note, this assumes that the caller has already checked message.mFlagLoaded and that
* additional work is needed. There is no optimization here for a message which is already
* loaded.
*
* @param messageId the message to load
* @param callback the Controller callback by which results will be reported
*/
public void loadMessageForView(final long messageId) {
// Split here for target type (Service or MessagingController)
IEmailService service = getServiceForMessage(messageId);
if (service != null) {
// There is no service implementation, so we'll just jam the value, log the error,
// and get out of here.
Uri uri = ContentUris.withAppendedId(Message.CONTENT_URI, messageId);
ContentValues cv = new ContentValues();
cv.put(MessageColumns.FLAG_LOADED, Message.FLAG_LOADED_COMPLETE);
mProviderContext.getContentResolver().update(uri, cv, null, null);
Log.d(Logging.LOG_TAG, "Unexpected loadMessageForView() for service-based message.");
final long accountId = Account.getAccountIdForMessageId(mProviderContext, messageId);
synchronized (mListeners) {
for (Result listener : mListeners) {
listener.loadMessageForViewCallback(null, accountId, messageId, 100);
}
}
} else {
// MessagingController implementation
Utility.runAsync(new Runnable() {
public void run() {
mLegacyController.loadMessageForView(messageId, mLegacyListener);
}
});
}
}
/**
* Saves the message to a mailbox of given type.
* This is a synchronous operation taking place in the same thread as the caller.
* Upon return the message.mId is set.
* @param message the message (must have the mAccountId set).
* @param mailboxType the mailbox type (e.g. Mailbox.TYPE_DRAFTS).
*/
public void saveToMailbox(final EmailContent.Message message, final int mailboxType) {
long accountId = message.mAccountKey;
long mailboxId = findOrCreateMailboxOfType(accountId, mailboxType);
message.mMailboxKey = mailboxId;
message.save(mProviderContext);
}
/**
* Look for a specific system mailbox, creating it if necessary, and return the mailbox id.
* This is a blocking operation and should not be called from the UI thread.
*
* Synchronized so multiple threads can call it (and not risk creating duplicate boxes).
*
* @param accountId the account id
* @param mailboxType the mailbox type (e.g. EmailContent.Mailbox.TYPE_TRASH)
* @return the id of the mailbox. The mailbox is created if not existing.
* Returns Mailbox.NO_MAILBOX if the accountId or mailboxType are negative.
* Does not validate the input in other ways (e.g. does not verify the existence of account).
*/
public synchronized long findOrCreateMailboxOfType(long accountId, int mailboxType) {
if (accountId < 0 || mailboxType < 0) {
return Mailbox.NO_MAILBOX;
}
long mailboxId =
Mailbox.findMailboxOfType(mProviderContext, accountId, mailboxType);
return mailboxId == Mailbox.NO_MAILBOX ? createMailbox(accountId, mailboxType) : mailboxId;
}
/**
* Returns the server-side name for a specific mailbox.
*
* @return the resource string corresponding to the mailbox type, empty if not found.
*/
public static String getMailboxServerName(Context context, int mailboxType) {
int resId = -1;
switch (mailboxType) {
case Mailbox.TYPE_INBOX:
resId = R.string.mailbox_name_server_inbox;
break;
case Mailbox.TYPE_OUTBOX:
resId = R.string.mailbox_name_server_outbox;
break;
case Mailbox.TYPE_DRAFTS:
resId = R.string.mailbox_name_server_drafts;
break;
case Mailbox.TYPE_TRASH:
resId = R.string.mailbox_name_server_trash;
break;
case Mailbox.TYPE_SENT:
resId = R.string.mailbox_name_server_sent;
break;
case Mailbox.TYPE_JUNK:
resId = R.string.mailbox_name_server_junk;
break;
}
return resId != -1 ? context.getString(resId) : "";
}
/**
* Create a mailbox given the account and mailboxType.
* TODO: Does this need to be signaled explicitly to the sync engines?
*/
@VisibleForTesting
long createMailbox(long accountId, int mailboxType) {
if (accountId < 0 || mailboxType < 0) {
String mes = "Invalid arguments " + accountId + ' ' + mailboxType;
Log.e(Logging.LOG_TAG, mes);
throw new RuntimeException(mes);
}
Mailbox box = Mailbox.newSystemMailbox(
accountId, mailboxType, getMailboxServerName(mContext, mailboxType));
box.save(mProviderContext);
return box.mId;
}
/**
* Send a message:
* - move the message to Outbox (the message is assumed to be in Drafts).
* - EAS service will take it from there
* - mark reply/forward state in source message (if any)
* - trigger send for POP/IMAP
* @param message the fully populated Message (usually retrieved from the Draft box). Note that
* all transient fields (e.g. Body related fields) are also expected to be fully loaded
*/
public void sendMessage(Message message) {
ContentResolver resolver = mProviderContext.getContentResolver();
long accountId = message.mAccountKey;
long messageId = message.mId;
if (accountId == Account.NO_ACCOUNT) {
accountId = lookupAccountForMessage(messageId);
}
if (accountId == Account.NO_ACCOUNT) {
// probably the message was not found
if (Logging.LOGD) {
Email.log("no account found for message " + messageId);
}
return;
}
// Move to Outbox
long outboxId = findOrCreateMailboxOfType(accountId, Mailbox.TYPE_OUTBOX);
ContentValues cv = new ContentValues();
cv.put(EmailContent.MessageColumns.MAILBOX_KEY, outboxId);
// does this need to be SYNCED_CONTENT_URI instead?
Uri uri = ContentUris.withAppendedId(Message.CONTENT_URI, messageId);
resolver.update(uri, cv, null, null);
// If this is a reply/forward, indicate it as such on the source.
long sourceKey = message.mSourceKey;
if (sourceKey != Message.NO_MESSAGE) {
boolean isReply = (message.mFlags & Message.FLAG_TYPE_REPLY) != 0;
int flagUpdate = isReply ? Message.FLAG_REPLIED_TO : Message.FLAG_FORWARDED;
setMessageAnsweredOrForwarded(sourceKey, flagUpdate);
}
sendPendingMessages(accountId);
}
private void sendPendingMessagesSmtp(long accountId) {
// for IMAP & POP only, (attempt to) send the message now
final Account account =
Account.restoreAccountWithId(mProviderContext, accountId);
if (account == null) {
return;
}
final long sentboxId = findOrCreateMailboxOfType(accountId, Mailbox.TYPE_SENT);
Utility.runAsync(new Runnable() {
public void run() {
mLegacyController.sendPendingMessages(account, sentboxId, mLegacyListener);
}
});
}
/**
* Try to send all pending messages for a given account
*
* @param accountId the account for which to send messages
*/
public void sendPendingMessages(long accountId) {
// 1. make sure we even have an outbox, exit early if not
final long outboxId =
Mailbox.findMailboxOfType(mProviderContext, accountId, Mailbox.TYPE_OUTBOX);
if (outboxId == Mailbox.NO_MAILBOX) {
return;
}
// 2. dispatch as necessary
IEmailService service = getServiceForAccount(accountId);
if (service != null) {
// Service implementation
try {
service.startSync(outboxId, false);
} catch (RemoteException e) {
// TODO Change exception handling to be consistent with however this method
// is implemented for other protocols
Log.d("updateMailbox", "RemoteException" + e);
}
} else {
// MessagingController implementation
sendPendingMessagesSmtp(accountId);
}
}
/**
* Reset visible limits for all accounts.
* For each account:
* look up limit
* write limit into all mailboxes for that account
*/
public void resetVisibleLimits() {
Utility.runAsync(new Runnable() {
public void run() {
ContentResolver resolver = mProviderContext.getContentResolver();
Cursor c = null;
try {
c = resolver.query(
Account.CONTENT_URI,
Account.ID_PROJECTION,
null, null, null);
while (c.moveToNext()) {
long accountId = c.getLong(Account.ID_PROJECTION_COLUMN);
String protocol = Account.getProtocol(mProviderContext, accountId);
if (!HostAuth.SCHEME_EAS.equals(protocol)) {
ContentValues cv = new ContentValues();
cv.put(MailboxColumns.VISIBLE_LIMIT, Email.VISIBLE_LIMIT_DEFAULT);
resolver.update(Mailbox.CONTENT_URI, cv,
MailboxColumns.ACCOUNT_KEY + "=?",
new String[] { Long.toString(accountId) });
}
}
} finally {
if (c != null) {
c.close();
}
}
}
});
}
/**
* Increase the load count for a given mailbox, and trigger a refresh. Applies only to
* IMAP and POP mailboxes, with the exception of the EAS search mailbox.
*
* @param mailboxId the mailbox
*/
public void loadMoreMessages(final long mailboxId) {
EmailAsyncTask.runAsyncParallel(new Runnable() {
public void run() {
Mailbox mailbox = Mailbox.restoreMailboxWithId(mProviderContext, mailboxId);
if (mailbox == null) {
return;
}
if (mailbox.mType == Mailbox.TYPE_SEARCH) {
try {
searchMore(mailbox.mAccountKey);
} catch (MessagingException e) {
// Nothing to be done
}
return;
}
Account account = Account.restoreAccountWithId(mProviderContext,
mailbox.mAccountKey);
if (account == null) {
return;
}
// Use provider math to increment the field
ContentValues cv = new ContentValues();;
cv.put(EmailContent.FIELD_COLUMN_NAME, MailboxColumns.VISIBLE_LIMIT);
cv.put(EmailContent.ADD_COLUMN_NAME, Email.VISIBLE_LIMIT_INCREMENT);
Uri uri = ContentUris.withAppendedId(Mailbox.ADD_TO_FIELD_URI, mailboxId);
mProviderContext.getContentResolver().update(uri, cv, null, null);
// Trigger a refresh using the new, longer limit
mailbox.mVisibleLimit += Email.VISIBLE_LIMIT_INCREMENT;
mLegacyController.synchronizeMailbox(account, mailbox, mLegacyListener);
}
});
}
/**
* @param messageId the id of message
* @return the accountId corresponding to the given messageId, or -1 if not found.
*/
private long lookupAccountForMessage(long messageId) {
ContentResolver resolver = mProviderContext.getContentResolver();
Cursor c = resolver.query(EmailContent.Message.CONTENT_URI,
MESSAGEID_TO_ACCOUNTID_PROJECTION, EmailContent.RECORD_ID + "=?",
new String[] { Long.toString(messageId) }, null);
try {
return c.moveToFirst()
? c.getLong(MESSAGEID_TO_ACCOUNTID_COLUMN_ACCOUNTID)
: -1;
} finally {
c.close();
}
}
/**
* Delete a single attachment entry from the DB given its id.
* Does not delete any eventual associated files.
*/
public void deleteAttachment(long attachmentId) {
ContentResolver resolver = mProviderContext.getContentResolver();
Uri uri = ContentUris.withAppendedId(Attachment.CONTENT_URI, attachmentId);
resolver.delete(uri, null, null);
}
/**
* Async version of {@link #deleteMessageSync}.
*/
public void deleteMessage(final long messageId) {
EmailAsyncTask.runAsyncParallel(new Runnable() {
public void run() {
deleteMessageSync(messageId);
}
});
}
/**
* Batch & async version of {@link #deleteMessageSync}.
*/
public void deleteMessages(final long[] messageIds) {
if (messageIds == null || messageIds.length == 0) {
throw new IllegalArgumentException();
}
EmailAsyncTask.runAsyncParallel(new Runnable() {
public void run() {
for (long messageId: messageIds) {
deleteMessageSync(messageId);
}
}
});
}
/**
* Delete a single message by moving it to the trash, or really delete it if it's already in
* trash or a draft message.
*
* This function has no callback, no result reporting, because the desired outcome
* is reflected entirely by changes to one or more cursors.
*
* @param messageId The id of the message to "delete".
*/
/* package */ void deleteMessageSync(long messageId) {
// 1. Get the message's account
Account account = Account.getAccountForMessageId(mProviderContext, messageId);
if (account == null) return;
// 2. Confirm that there is a trash mailbox available. If not, create one
long trashMailboxId = findOrCreateMailboxOfType(account.mId, Mailbox.TYPE_TRASH);
// 3. Get the message's original mailbox
Mailbox mailbox = Mailbox.getMailboxForMessageId(mProviderContext, messageId);
if (mailbox == null) return;
// 4. Drop non-essential data for the message (e.g. attachment files)
AttachmentUtilities.deleteAllAttachmentFiles(mProviderContext, account.mId,
messageId);
Uri uri = ContentUris.withAppendedId(EmailContent.Message.SYNCED_CONTENT_URI,
messageId);
ContentResolver resolver = mProviderContext.getContentResolver();
// 5. Perform "delete" as appropriate
if ((mailbox.mId == trashMailboxId) || (mailbox.mType == Mailbox.TYPE_DRAFTS)) {
// 5a. Really delete it
resolver.delete(uri, null, null);
} else {
// 5b. Move to trash
ContentValues cv = new ContentValues();
cv.put(EmailContent.MessageColumns.MAILBOX_KEY, trashMailboxId);
resolver.update(uri, cv, null, null);
}
if (isMessagingController(account)) {
mLegacyController.processPendingActions(account.mId);
}
}
/**
* Moves messages to a new mailbox.
*
* This function has no callback, no result reporting, because the desired outcome
* is reflected entirely by changes to one or more cursors.
*
* Note this method assumes all of the given message and mailbox IDs belong to the same
* account.
*
* @param messageIds IDs of the messages that are to be moved
* @param newMailboxId ID of the new mailbox that the messages will be moved to
* @return an asynchronous task that executes the move (for testing only)
*/
public EmailAsyncTask<Void, Void, Void> moveMessages(final long[] messageIds,
final long newMailboxId) {
if (messageIds == null || messageIds.length == 0) {
throw new IllegalArgumentException();
}
return EmailAsyncTask.runAsyncParallel(new Runnable() {
public void run() {
Account account = Account.getAccountForMessageId(mProviderContext, messageIds[0]);
if (account != null) {
ContentValues cv = new ContentValues();
cv.put(EmailContent.MessageColumns.MAILBOX_KEY, newMailboxId);
ContentResolver resolver = mProviderContext.getContentResolver();
for (long messageId : messageIds) {
Uri uri = ContentUris.withAppendedId(
EmailContent.Message.SYNCED_CONTENT_URI, messageId);
resolver.update(uri, cv, null, null);
}
if (isMessagingController(account)) {
mLegacyController.processPendingActions(account.mId);
}
}
}
});
}
/**
* Set/clear the unread status of a message
*
* @param messageId the message to update
* @param isRead the new value for the isRead flag
*/
public void setMessageReadSync(long messageId, boolean isRead) {
setMessageBooleanSync(messageId, EmailContent.MessageColumns.FLAG_READ, isRead);
}
/**
* Set/clear the unread status of a message from UI thread
*
* @param messageId the message to update
* @param isRead the new value for the isRead flag
* @return the EmailAsyncTask created
*/
public EmailAsyncTask<Void, Void, Void> setMessageRead(final long messageId,
final boolean isRead) {
return EmailAsyncTask.runAsyncParallel(new Runnable() {
@Override
public void run() {
setMessageBooleanSync(messageId, EmailContent.MessageColumns.FLAG_READ, isRead);
}});
}
/**
* Update a message record and ping MessagingController, if necessary
*
* @param messageId the message to update
* @param cv the ContentValues used in the update
*/
private void updateMessageSync(long messageId, ContentValues cv) {
Uri uri = ContentUris.withAppendedId(EmailContent.Message.SYNCED_CONTENT_URI, messageId);
mProviderContext.getContentResolver().update(uri, cv, null, null);
// Service runs automatically, MessagingController needs a kick
long accountId = Account.getAccountIdForMessageId(mProviderContext, messageId);
if (accountId == Account.NO_ACCOUNT) return;
if (isMessagingController(accountId)) {
mLegacyController.processPendingActions(accountId);
}
}
/**
* Set the answered status of a message
*
* @param messageId the message to update
* @return the AsyncTask that will execute the changes (for testing only)
*/
public void setMessageAnsweredOrForwarded(final long messageId,
final int flag) {
EmailAsyncTask.runAsyncParallel(new Runnable() {
public void run() {
Message msg = Message.restoreMessageWithId(mProviderContext, messageId);
if (msg == null) {
Log.w(Logging.LOG_TAG, "Unable to find source message for a reply/forward");
return;
}
ContentValues cv = new ContentValues();
cv.put(MessageColumns.FLAGS, msg.mFlags | flag);
updateMessageSync(messageId, cv);
}
});
}
/**
* Set/clear the favorite status of a message from UI thread
*
* @param messageId the message to update
* @param isFavorite the new value for the isFavorite flag
* @return the EmailAsyncTask created
*/
public EmailAsyncTask<Void, Void, Void> setMessageFavorite(final long messageId,
final boolean isFavorite) {
return EmailAsyncTask.runAsyncParallel(new Runnable() {
@Override
public void run() {
setMessageBooleanSync(messageId, EmailContent.MessageColumns.FLAG_FAVORITE,
isFavorite);
}});
}
/**
* Set/clear the favorite status of a message
*
* @param messageId the message to update
* @param isFavorite the new value for the isFavorite flag
*/
public void setMessageFavoriteSync(long messageId, boolean isFavorite) {
setMessageBooleanSync(messageId, EmailContent.MessageColumns.FLAG_FAVORITE, isFavorite);
}
/**
* Set/clear boolean columns of a message
*
* @param messageId the message to update
* @param columnName the column to update
* @param columnValue the new value for the column
*/
private void setMessageBooleanSync(long messageId, String columnName, boolean columnValue) {
ContentValues cv = new ContentValues();
cv.put(columnName, columnValue);
updateMessageSync(messageId, cv);
}
private static final HashMap<Long, SearchParams> sSearchParamsMap =
new HashMap<Long, SearchParams>();
public void searchMore(long accountId) throws MessagingException {
SearchParams params = sSearchParamsMap.get(accountId);
if (params == null) return;
params.mOffset += params.mLimit;
searchMessages(accountId, params);
}
/**
* Search for messages on the (IMAP) server; do not call this on the UI thread!
* @param accountId the id of the account to be searched
* @param searchParams the parameters for this search
* @throws MessagingException
*/
public int searchMessages(final long accountId, final SearchParams searchParams)
throws MessagingException {
// Find/create our search mailbox
Mailbox searchMailbox = getSearchMailbox(accountId);
if (searchMailbox == null) return 0;
final long searchMailboxId = searchMailbox.mId;
// Save this away (per account)
sSearchParamsMap.put(accountId, searchParams);
if (searchParams.mOffset == 0) {
// Delete existing contents of search mailbox
ContentResolver resolver = mContext.getContentResolver();
resolver.delete(Message.CONTENT_URI, Message.MAILBOX_KEY + "=" + searchMailboxId,
null);
ContentValues cv = new ContentValues();
// For now, use the actual query as the name of the mailbox
cv.put(Mailbox.DISPLAY_NAME, searchParams.mFilter);
resolver.update(ContentUris.withAppendedId(Mailbox.CONTENT_URI, searchMailboxId),
cv, null, null);
}
IEmailService service = getServiceForAccount(accountId);
if (service != null) {
// Service implementation
try {
return service.searchMessages(accountId, searchParams, searchMailboxId);
} catch (RemoteException e) {
// TODO Change exception handling to be consistent with however this method
// is implemented for other protocols
Log.e("searchMessages", "RemoteException", e);
return 0;
}
} else {
// This is the actual mailbox we'll be searching
Mailbox actualMailbox = Mailbox.restoreMailboxWithId(mContext, searchParams.mMailboxId);
if (actualMailbox == null) {
Log.e(Logging.LOG_TAG, "Unable to find mailbox " + searchParams.mMailboxId
+ " to search in with " + searchParams);
return 0;
}
// Do the search
if (Email.DEBUG) {
Log.d(Logging.LOG_TAG, "Search: " + searchParams.mFilter);
}
return mLegacyController.searchMailbox(accountId, searchParams, searchMailboxId);
}
}
/**
* Respond to a meeting invitation.
*
* @param messageId the id of the invitation being responded to
* @param response the code representing the response to the invitation
*/
public void sendMeetingResponse(final long messageId, final int response) {
// Split here for target type (Service or MessagingController)
IEmailService service = getServiceForMessage(messageId);
if (service != null) {
// Service implementation
try {
service.sendMeetingResponse(messageId, response);
} catch (RemoteException e) {
// TODO Change exception handling to be consistent with however this method
// is implemented for other protocols
Log.e("onDownloadAttachment", "RemoteException", e);
}
}
}
/**
* Request that an attachment be loaded. It will be stored at a location controlled
* by the AttachmentProvider.
*
* @param attachmentId the attachment to load
* @param messageId the owner message
* @param accountId the owner account
*/
public void loadAttachment(final long attachmentId, final long messageId,
final long accountId) {
Attachment attachInfo = Attachment.restoreAttachmentWithId(mProviderContext, attachmentId);
if (attachInfo == null) {
return;
}
if (Utility.attachmentExists(mProviderContext, attachInfo)) {
// The attachment has already been downloaded, so we will just "pretend" to download it
// This presumably is for POP3 messages
synchronized (mListeners) {
for (Result listener : mListeners) {
listener.loadAttachmentCallback(null, accountId, messageId, attachmentId, 0);
}
for (Result listener : mListeners) {
listener.loadAttachmentCallback(null, accountId, messageId, attachmentId, 100);
}
}
return;
}
// Flag the attachment as needing download at the user's request
ContentValues cv = new ContentValues();
cv.put(Attachment.FLAGS, attachInfo.mFlags | Attachment.FLAG_DOWNLOAD_USER_REQUEST);
attachInfo.update(mProviderContext, cv);
}
/**
* For a given message id, return a service proxy if applicable, or null.
*
* @param messageId the message of interest
* @result service proxy, or null if n/a
*/
private IEmailService getServiceForMessage(long messageId) {
// TODO make this more efficient, caching the account, smaller lookup here, etc.
Message message = Message.restoreMessageWithId(mProviderContext, messageId);
if (message == null) {
return null;
}
return getServiceForAccount(message.mAccountKey);
}
/**
* For a given account id, return a service proxy if applicable, or null.
*
* @param accountId the message of interest
* @result service proxy, or null if n/a
*/
private IEmailService getServiceForAccount(long accountId) {
if (isMessagingController(accountId)) return null;
return getExchangeEmailService();
}
private IEmailService getExchangeEmailService() {
return EmailServiceUtils.getExchangeService(mContext, mServiceCallback);
}
/**
* Simple helper to determine if legacy MessagingController should be used
*/
public boolean isMessagingController(Account account) {
if (account == null) return false;
return isMessagingController(account.mId);
}
public boolean isMessagingController(long accountId) {
Boolean isLegacyController = mLegacyControllerMap.get(accountId);
if (isLegacyController == null) {
String protocol = Account.getProtocol(mProviderContext, accountId);
isLegacyController = ("pop3".equals(protocol) || "imap".equals(protocol));
mLegacyControllerMap.put(accountId, isLegacyController);
}
return isLegacyController;
}
/**
* Delete an account.
*/
public void deleteAccount(final long accountId) {
EmailAsyncTask.runAsyncParallel(new Runnable() {
@Override
public void run() {
deleteAccountSync(accountId, mProviderContext);
}
});
}
/**
* Delete an account synchronously.
*/
public void deleteAccountSync(long accountId, Context context) {
try {
mLegacyControllerMap.remove(accountId);
// Get the account URI.
final Account account = Account.restoreAccountWithId(context, accountId);
if (account == null) {
return; // Already deleted?
}
// Delete account data, attachments, PIM data, etc.
deleteSyncedDataSync(accountId);
// Now delete the account itself
Uri uri = ContentUris.withAppendedId(Account.CONTENT_URI, accountId);
context.getContentResolver().delete(uri, null, null);
// For unit tests, don't run backup, security, and ui pieces.
if (mInUnitTests) {
return;
}
// Clean up
AccountBackupRestore.backup(context);
SecurityPolicy.getInstance(context).reducePolicies();
Email.setServicesEnabledSync(context);
Email.setNotifyUiAccountsChanged(true);
MailService.actionReschedule(context);
} catch (Exception e) {
Log.w(Logging.LOG_TAG, "Exception while deleting account", e);
}
}
/**
* Delete all synced data, but don't delete the actual account. This is used when security
* policy requirements are not met, and we don't want to reveal any synced data, but we do
* wish to keep the account configured (e.g. to accept remote wipe commands).
*
* The only mailbox not deleted is the account mailbox (if any)
* Also, clear the sync keys on the remaining account, since the data is gone.
*
* SYNCHRONOUS - do not call from UI thread.
*
* @param accountId The account to wipe.
*/
public void deleteSyncedDataSync(long accountId) {
try {
// Delete synced attachments
AttachmentUtilities.deleteAllAccountAttachmentFiles(mProviderContext,
accountId);
// Delete synced email, leaving only an empty inbox. We do this in two phases:
// 1. Delete all non-inbox mailboxes (which will delete all of their messages)
// 2. Delete all remaining messages (which will be the inbox messages)
ContentResolver resolver = mProviderContext.getContentResolver();
String[] accountIdArgs = new String[] { Long.toString(accountId) };
resolver.delete(Mailbox.CONTENT_URI,
MAILBOXES_FOR_ACCOUNT_EXCEPT_ACCOUNT_MAILBOX_SELECTION,
accountIdArgs);
resolver.delete(Message.CONTENT_URI, MESSAGES_FOR_ACCOUNT_SELECTION, accountIdArgs);
// Delete sync keys on remaining items
ContentValues cv = new ContentValues();
cv.putNull(Account.SYNC_KEY);
resolver.update(Account.CONTENT_URI, cv, Account.ID_SELECTION, accountIdArgs);
cv.clear();
cv.putNull(Mailbox.SYNC_KEY);
resolver.update(Mailbox.CONTENT_URI, cv,
MAILBOXES_FOR_ACCOUNT_SELECTION, accountIdArgs);
// Delete PIM data (contacts, calendar), stop syncs, etc. if applicable
IEmailService service = getServiceForAccount(accountId);
if (service != null) {
service.deleteAccountPIMData(accountId);
}
} catch (Exception e) {
Log.w(Logging.LOG_TAG, "Exception while deleting account synced data", e);
}
}
/**
* Simple callback for synchronous commands. For many commands, this can be largely ignored
* and the result is observed via provider cursors. The callback will *not* necessarily be
* made from the UI thread, so you may need further handlers to safely make UI updates.
*/
public static abstract class Result {
private volatile boolean mRegistered;
protected void setRegistered(boolean registered) {
mRegistered = registered;
}
protected final boolean isRegistered() {
return mRegistered;
}
/**
* Callback for updateMailboxList
*
* @param result If null, the operation completed without error
* @param accountId The account being operated on
* @param progress 0 for "starting", 1..99 for updates (if needed in UI), 100 for complete
*/
public void updateMailboxListCallback(MessagingException result, long accountId,
int progress) {
}
/**
* Callback for updateMailbox. Note: This looks a lot like checkMailCallback, but
* it's a separate call used only by UI's, so we can keep things separate.
*
* @param result If null, the operation completed without error
* @param accountId The account being operated on
* @param mailboxId The mailbox being operated on
* @param progress 0 for "starting", 1..99 for updates (if needed in UI), 100 for complete
* @param numNewMessages the number of new messages delivered
*/
public void updateMailboxCallback(MessagingException result, long accountId,
long mailboxId, int progress, int numNewMessages, ArrayList<Long> addedMessages) {
}
/**
* Callback for loadMessageForView
*
* @param result if null, the attachment completed - if non-null, terminating with failure
* @param messageId the message which contains the attachment
* @param progress 0 for "starting", 1..99 for updates (if needed in UI), 100 for complete
*/
public void loadMessageForViewCallback(MessagingException result, long accountId,
long messageId, int progress) {
}
/**
* Callback for loadAttachment
*
* @param result if null, the attachment completed - if non-null, terminating with failure
* @param messageId the message which contains the attachment
* @param attachmentId the attachment being loaded
* @param progress 0 for "starting", 1..99 for updates (if needed in UI), 100 for complete
*/
public void loadAttachmentCallback(MessagingException result, long accountId,
long messageId, long attachmentId, int progress) {
}
/**
* Callback for checkmail. Note: This looks a lot like updateMailboxCallback, but
* it's a separate call used only by the automatic checker service, so we can keep
* things separate.
*
* @param result If null, the operation completed without error
* @param accountId The account being operated on
* @param mailboxId The mailbox being operated on (may be unknown at start)
* @param progress 0 for "starting", no updates, 100 for complete
* @param tag the same tag that was passed to serviceCheckMail()
*/
public void serviceCheckMailCallback(MessagingException result, long accountId,
long mailboxId, int progress, long tag) {
}
/**
* Callback for sending pending messages. This will be called once to start the
* group, multiple times for messages, and once to complete the group.
*
* Unfortunately this callback works differently on SMTP and EAS.
*
* On SMTP:
*
* First, we get this.
* result == null, messageId == -1, progress == 0: start batch send
*
* Then we get these callbacks per message.
* (Exchange backend may skip "start sending one message".)
* result == null, messageId == xx, progress == 0: start sending one message
* result == xxxx, messageId == xx, progress == 0; failed sending one message
*
* Finally we get this.
* result == null, messageId == -1, progres == 100; finish sending batch
*
* On EAS: Almost same as above, except:
*
* - There's no first ("start batch send") callback.
* - accountId is always -1.
*
* @param result If null, the operation completed without error
* @param accountId The account being operated on
* @param messageId The being sent (may be unknown at start)
* @param progress 0 for "starting", 100 for complete
*/
public void sendMailCallback(MessagingException result, long accountId,
long messageId, int progress) {
}
}
/**
* Bridge to intercept {@link MessageRetrievalListener#loadAttachmentProgress} and
* pass down to {@link Result}.
*/
public class MessageRetrievalListenerBridge implements MessageRetrievalListener {
private final long mMessageId;
private final long mAttachmentId;
private final long mAccountId;
public MessageRetrievalListenerBridge(long messageId, long attachmentId) {
mMessageId = messageId;
mAttachmentId = attachmentId;
mAccountId = Account.getAccountIdForMessageId(mProviderContext, mMessageId);
}
@Override
public void loadAttachmentProgress(int progress) {
synchronized (mListeners) {
for (Result listener : mListeners) {
listener.loadAttachmentCallback(null, mAccountId, mMessageId, mAttachmentId,
progress);
}
}
}
@Override
public void messageRetrieved(com.android.emailcommon.mail.Message message) {
}
}
/**
* Support for receiving callbacks from MessagingController and dealing with UI going
* out of scope.
*/
public class LegacyListener extends MessagingListener {
public LegacyListener() {
}
@Override
public void listFoldersStarted(long accountId) {
synchronized (mListeners) {
for (Result l : mListeners) {
l.updateMailboxListCallback(null, accountId, 0);
}
}
}
@Override
public void listFoldersFailed(long accountId, String message) {
synchronized (mListeners) {
for (Result l : mListeners) {
l.updateMailboxListCallback(new MessagingException(message), accountId, 0);
}
}
}
@Override
public void listFoldersFinished(long accountId) {
synchronized (mListeners) {
for (Result l : mListeners) {
l.updateMailboxListCallback(null, accountId, 100);
}
}
}
@Override
public void synchronizeMailboxStarted(long accountId, long mailboxId) {
synchronized (mListeners) {
for (Result l : mListeners) {
l.updateMailboxCallback(null, accountId, mailboxId, 0, 0, null);
}
}
}
@Override
public void synchronizeMailboxFinished(long accountId, long mailboxId,
int totalMessagesInMailbox, int numNewMessages, ArrayList<Long> addedMessages) {
synchronized (mListeners) {
for (Result l : mListeners) {
l.updateMailboxCallback(null, accountId, mailboxId, 100, numNewMessages,
addedMessages);
}
}
}
@Override
public void synchronizeMailboxFailed(long accountId, long mailboxId, Exception e) {
MessagingException me;
if (e instanceof MessagingException) {
me = (MessagingException) e;
} else {
me = new MessagingException(e.toString());
}
synchronized (mListeners) {
for (Result l : mListeners) {
l.updateMailboxCallback(me, accountId, mailboxId, 0, 0, null);
}
}
}
@Override
public void checkMailStarted(Context context, long accountId, long tag) {
synchronized (mListeners) {
for (Result l : mListeners) {
l.serviceCheckMailCallback(null, accountId, -1, 0, tag);
}
}
}
@Override
public void checkMailFinished(Context context, long accountId, long folderId, long tag) {
synchronized (mListeners) {
for (Result l : mListeners) {
l.serviceCheckMailCallback(null, accountId, folderId, 100, tag);
}
}
}
@Override
public void loadMessageForViewStarted(long messageId) {
final long accountId = Account.getAccountIdForMessageId(mProviderContext, messageId);
synchronized (mListeners) {
for (Result listener : mListeners) {
listener.loadMessageForViewCallback(null, accountId, messageId, 0);
}
}
}
@Override
public void loadMessageForViewFinished(long messageId) {
final long accountId = Account.getAccountIdForMessageId(mProviderContext, messageId);
synchronized (mListeners) {
for (Result listener : mListeners) {
listener.loadMessageForViewCallback(null, accountId, messageId, 100);
}
}
}
@Override
public void loadMessageForViewFailed(long messageId, String message) {
final long accountId = Account.getAccountIdForMessageId(mProviderContext, messageId);
synchronized (mListeners) {
for (Result listener : mListeners) {
listener.loadMessageForViewCallback(new MessagingException(message),
accountId, messageId, 0);
}
}
}
@Override
public void loadAttachmentStarted(long accountId, long messageId, long attachmentId,
boolean requiresDownload) {
try {
mCallbackProxy.loadAttachmentStatus(messageId, attachmentId,
EmailServiceStatus.IN_PROGRESS, 0);
} catch (RemoteException e) {
}
synchronized (mListeners) {
for (Result listener : mListeners) {
listener.loadAttachmentCallback(null, accountId, messageId, attachmentId, 0);
}
}
}
@Override
public void loadAttachmentFinished(long accountId, long messageId, long attachmentId) {
try {
mCallbackProxy.loadAttachmentStatus(messageId, attachmentId,
EmailServiceStatus.SUCCESS, 100);
} catch (RemoteException e) {
}
synchronized (mListeners) {
for (Result listener : mListeners) {
listener.loadAttachmentCallback(null, accountId, messageId, attachmentId, 100);
}
}
}
@Override
public void loadAttachmentFailed(long accountId, long messageId, long attachmentId,
MessagingException me, boolean background) {
try {
// If the cause of the MessagingException is an IOException, we send a status of
// CONNECTION_ERROR; in this case, AttachmentDownloadService will try again to
// download the attachment. Otherwise, the error is considered non-recoverable.
int status = EmailServiceStatus.ATTACHMENT_NOT_FOUND;
if (me != null && me.getCause() instanceof IOException) {
status = EmailServiceStatus.CONNECTION_ERROR;
}
mCallbackProxy.loadAttachmentStatus(messageId, attachmentId, status, 0);
} catch (RemoteException e) {
}
synchronized (mListeners) {
for (Result listener : mListeners) {
// TODO We are overloading the exception here. The UI listens for this
// callback and displays a toast if the exception is not null. Since we
// want to avoid displaying toast for background operations, we force
// the exception to be null. This needs to be re-worked so the UI will
// only receive (or at least pays attention to) responses for requests
// it explicitly cares about. Then we would not need to overload the
// exception parameter.
listener.loadAttachmentCallback(background ? null : me, accountId, messageId,
attachmentId, 0);
}
}
}
@Override
synchronized public void sendPendingMessagesStarted(long accountId, long messageId) {
synchronized (mListeners) {
for (Result listener : mListeners) {
listener.sendMailCallback(null, accountId, messageId, 0);
}
}
}
@Override
synchronized public void sendPendingMessagesCompleted(long accountId) {
synchronized (mListeners) {
for (Result listener : mListeners) {
listener.sendMailCallback(null, accountId, -1, 100);
}
}
}
@Override
synchronized public void sendPendingMessagesFailed(long accountId, long messageId,
Exception reason) {
MessagingException me;
if (reason instanceof MessagingException) {
me = (MessagingException) reason;
} else {
me = new MessagingException(reason.toString());
}
synchronized (mListeners) {
for (Result listener : mListeners) {
listener.sendMailCallback(me, accountId, messageId, 0);
}
}
}
}
/**
* Service callback for service operations
*/
private class ServiceCallback extends IEmailServiceCallback.Stub {
private final static boolean DEBUG_FAIL_DOWNLOADS = false; // do not check in "true"
public void loadAttachmentStatus(long messageId, long attachmentId, int statusCode,
int progress) {
MessagingException result = mapStatusToException(statusCode);
switch (statusCode) {
case EmailServiceStatus.SUCCESS:
progress = 100;
break;
case EmailServiceStatus.IN_PROGRESS:
if (DEBUG_FAIL_DOWNLOADS && progress > 75) {
result = new MessagingException(
String.valueOf(EmailServiceStatus.CONNECTION_ERROR));
}
// discard progress reports that look like sentinels
if (progress < 0 || progress >= 100) {
return;
}
break;
}
final long accountId = Account.getAccountIdForMessageId(mProviderContext, messageId);
synchronized (mListeners) {
for (Result listener : mListeners) {
listener.loadAttachmentCallback(result, accountId, messageId, attachmentId,
progress);
}
}
}
/**
* Note, this is an incomplete implementation of this callback, because we are
* not getting things back from Service in quite the same way as from MessagingController.
* However, this is sufficient for basic "progress=100" notification that message send
* has just completed.
*/
public void sendMessageStatus(long messageId, String subject, int statusCode,
int progress) {
long accountId = -1; // This should be in the callback
MessagingException result = mapStatusToException(statusCode);
switch (statusCode) {
case EmailServiceStatus.SUCCESS:
progress = 100;
break;
case EmailServiceStatus.IN_PROGRESS:
// discard progress reports that look like sentinels
if (progress < 0 || progress >= 100) {
return;
}
break;
}
synchronized(mListeners) {
for (Result listener : mListeners) {
listener.sendMailCallback(result, accountId, messageId, progress);
}
}
}
public void syncMailboxListStatus(long accountId, int statusCode, int progress) {
MessagingException result = mapStatusToException(statusCode);
switch (statusCode) {
case EmailServiceStatus.SUCCESS:
progress = 100;
break;
case EmailServiceStatus.IN_PROGRESS:
// discard progress reports that look like sentinels
if (progress < 0 || progress >= 100) {
return;
}
break;
}
synchronized(mListeners) {
for (Result listener : mListeners) {
listener.updateMailboxListCallback(result, accountId, progress);
}
}
}
public void syncMailboxStatus(long mailboxId, int statusCode, int progress) {
MessagingException result = mapStatusToException(statusCode);
switch (statusCode) {
case EmailServiceStatus.SUCCESS:
progress = 100;
break;
case EmailServiceStatus.IN_PROGRESS:
// discard progress reports that look like sentinels
if (progress < 0 || progress >= 100) {
return;
}
break;
}
// TODO should pass this back instead of looking it up here
Mailbox mbx = Mailbox.restoreMailboxWithId(mProviderContext, mailboxId);
// The mailbox could have disappeared if the server commanded it
if (mbx == null) return;
long accountId = mbx.mAccountKey;
synchronized(mListeners) {
for (Result listener : mListeners) {
listener.updateMailboxCallback(result, accountId, mailboxId, progress, 0, null);
}
}
}
private MessagingException mapStatusToException(int statusCode) {
switch (statusCode) {
case EmailServiceStatus.SUCCESS:
case EmailServiceStatus.IN_PROGRESS:
// Don't generate error if the account is uninitialized
case EmailServiceStatus.ACCOUNT_UNINITIALIZED:
return null;
case EmailServiceStatus.LOGIN_FAILED:
return new AuthenticationFailedException("");
case EmailServiceStatus.CONNECTION_ERROR:
return new MessagingException(MessagingException.IOERROR);
case EmailServiceStatus.SECURITY_FAILURE:
return new MessagingException(MessagingException.SECURITY_POLICIES_REQUIRED);
case EmailServiceStatus.ACCESS_DENIED:
return new MessagingException(MessagingException.ACCESS_DENIED);
case EmailServiceStatus.ATTACHMENT_NOT_FOUND:
return new MessagingException(MessagingException.ATTACHMENT_NOT_FOUND);
case EmailServiceStatus.CLIENT_CERTIFICATE_ERROR:
return new MessagingException(MessagingException.CLIENT_CERTIFICATE_ERROR);
case EmailServiceStatus.MESSAGE_NOT_FOUND:
case EmailServiceStatus.FOLDER_NOT_DELETED:
case EmailServiceStatus.FOLDER_NOT_RENAMED:
case EmailServiceStatus.FOLDER_NOT_CREATED:
case EmailServiceStatus.REMOTE_EXCEPTION:
// TODO: define exception code(s) & UI string(s) for server-side errors
default:
return new MessagingException(String.valueOf(statusCode));
}
}
}
private interface ServiceCallbackWrapper {
public void call(IEmailServiceCallback cb) throws RemoteException;
}
/**
* Proxy that can be used to broadcast service callbacks; we currently use this only for
* loadAttachment callbacks
*/
private final IEmailServiceCallback.Stub mCallbackProxy =
new IEmailServiceCallback.Stub() {
/**
* Broadcast a callback to the everyone that's registered
*
* @param wrapper the ServiceCallbackWrapper used in the broadcast
*/
private synchronized void broadcastCallback(ServiceCallbackWrapper wrapper) {
if (sCallbackList != null) {
// Call everyone on our callback list
// Exceptions can be safely ignored
int count = sCallbackList.beginBroadcast();
for (int i = 0; i < count; i++) {
try {
wrapper.call(sCallbackList.getBroadcastItem(i));
} catch (RemoteException e) {
}
}
sCallbackList.finishBroadcast();
}
}
public void loadAttachmentStatus(final long messageId, final long attachmentId,
final int status, final int progress) {
broadcastCallback(new ServiceCallbackWrapper() {
@Override
public void call(IEmailServiceCallback cb) throws RemoteException {
cb.loadAttachmentStatus(messageId, attachmentId, status, progress);
}
});
}
@Override
public void sendMessageStatus(long messageId, String subject, int statusCode, int progress){
}
@Override
public void syncMailboxListStatus(long accountId, int statusCode, int progress) {
}
@Override
public void syncMailboxStatus(long mailboxId, int statusCode, int progress) {
}
};
public static class ControllerService extends Service {
/**
* Create our EmailService implementation here. For now, only loadAttachment is supported;
* the intention, however, is to move more functionality to the service interface
*/
private final IEmailService.Stub mBinder = new IEmailService.Stub() {
public Bundle validate(HostAuth hostAuth) {
return null;
}
public Bundle autoDiscover(String userName, String password) {
return null;
}
public void startSync(long mailboxId, boolean userRequest) {
}
public void stopSync(long mailboxId) {
}
public void loadAttachment(long attachmentId, boolean background)
throws RemoteException {
Attachment att = Attachment.restoreAttachmentWithId(ControllerService.this,
attachmentId);
if (att != null) {
if (Email.DEBUG) {
Log.d(TAG, "loadAttachment " + attachmentId + ": " + att.mFileName);
}
Message msg = Message.restoreMessageWithId(ControllerService.this,
att.mMessageKey);
if (msg != null) {
// If the message is a forward and the attachment needs downloading, we need
// to retrieve the message from the source, rather than from the message
// itself
if ((msg.mFlags & Message.FLAG_TYPE_FORWARD) != 0) {
String[] cols = Utility.getRowColumns(ControllerService.this,
Body.CONTENT_URI, BODY_SOURCE_KEY_PROJECTION, WHERE_MESSAGE_KEY,
new String[] {Long.toString(msg.mId)});
if (cols != null) {
msg = Message.restoreMessageWithId(ControllerService.this,
Long.parseLong(cols[BODY_SOURCE_KEY_COLUMN]));
if (msg == null) {
// TODO: We can try restoring from the deleted table here...
return;
}
}
}
MessagingController legacyController = sInstance.mLegacyController;
LegacyListener legacyListener = sInstance.mLegacyListener;
legacyController.loadAttachment(msg.mAccountKey, msg.mId, msg.mMailboxKey,
attachmentId, legacyListener, background);
} else {
// Send back the specific error status for this case
sInstance.mCallbackProxy.loadAttachmentStatus(att.mMessageKey, attachmentId,
EmailServiceStatus.MESSAGE_NOT_FOUND, 0);
}
}
}
public void updateFolderList(long accountId) {
}
public void hostChanged(long accountId) {
}
public void setLogging(int flags) {
}
public void sendMeetingResponse(long messageId, int response) {
}
public void loadMore(long messageId) {
}
// The following three methods are not implemented in this version
public boolean createFolder(long accountId, String name) {
return false;
}
public boolean deleteFolder(long accountId, String name) {
return false;
}
public boolean renameFolder(long accountId, String oldName, String newName) {
return false;
}
public void setCallback(IEmailServiceCallback cb) {
sCallbackList.register(cb);
}
public void deleteAccountPIMData(long accountId) {
}
public int searchMessages(long accountId, SearchParams searchParams,
long destMailboxId) {
return 0;
}
@Override
public int getApiLevel() {
return Api.LEVEL;
}
};
@Override
public IBinder onBind(Intent intent) {
return mBinder;
}
}
}