| package com.android.exchange.eas; |
| |
| import android.content.ContentResolver; |
| import android.content.ContentValues; |
| import android.content.Context; |
| import android.database.Cursor; |
| import android.os.Bundle; |
| import android.os.RemoteException; |
| import android.provider.CalendarContract; |
| import android.provider.ContactsContract; |
| |
| import com.android.emailcommon.provider.Account; |
| import com.android.emailcommon.provider.EmailContent; |
| import com.android.emailcommon.provider.EmailContent.Message; |
| import com.android.emailcommon.provider.Mailbox; |
| import com.android.emailcommon.service.EmailServiceStatus; |
| import com.android.emailcommon.utility.Utility; |
| import com.android.exchange.CommandStatusException; |
| import com.android.exchange.Eas; |
| import com.android.exchange.EasResponse; |
| import com.android.exchange.service.EasService; |
| import com.android.mail.providers.UIProvider; |
| import com.android.mail.utils.LogUtils; |
| |
| import org.apache.http.HttpEntity; |
| |
| import java.io.IOException; |
| import java.util.Set; |
| |
| public class EasFullSyncOperation extends EasOperation { |
| private final static String TAG = LogUtils.TAG; |
| |
| private final static int RESULT_SUCCESS = 0; |
| private final static int RESULT_SECURITY_HOLD = -100; |
| |
| public static final int SEND_FAILED = 1; |
| public static final String MAILBOX_KEY_AND_NOT_SEND_FAILED = |
| EmailContent.MessageColumns.MAILBOX_KEY + "=? and (" + |
| EmailContent.SyncColumns.SERVER_ID + " is null or " + |
| EmailContent.SyncColumns.SERVER_ID + "!=" + SEND_FAILED + ')'; |
| /** |
| * The content authorities that can be synced for EAS accounts. Initialization must wait until |
| * after we have a chance to call {@link EmailContent#init} (and, for future content types, |
| * possibly other initializations) because that's how we can know what the email authority is. |
| */ |
| private static String[] AUTHORITIES_TO_SYNC; |
| |
| static { |
| // Statically initialize the authorities we'll sync. |
| AUTHORITIES_TO_SYNC = new String[] { |
| EmailContent.AUTHORITY, |
| CalendarContract.AUTHORITY, |
| ContactsContract.AUTHORITY |
| }; |
| } |
| |
| final Bundle mSyncExtras; |
| Set<String> mAuthsToSync; |
| |
| public EasFullSyncOperation(final Context context, final long accountId, |
| final Bundle syncExtras) { |
| super(context, accountId); |
| mSyncExtras = syncExtras; |
| } |
| |
| @Override |
| protected String getCommand() { |
| // This is really a container operation, its performOperation() actually just creates and |
| // performs a bunch of other operations. It doesn't actually do any of its own |
| // requests. |
| // TODO: This is kind of ugly, maybe we need a simpler base class for EasOperation that |
| // does not assume that it will perform a single network operation. |
| LogUtils.e(TAG, "unexpected call to EasFullSyncOperation.getCommand"); |
| return null; |
| } |
| |
| @Override |
| protected HttpEntity getRequestEntity() throws IOException { |
| // This is really a container operation, its performOperation() actually just creates and |
| // performs a bunch of other operations. It doesn't actually do any of its own |
| // requests. |
| LogUtils.e(TAG, "unexpected call to EasFullSyncOperation.getRequestEntity"); |
| return null; |
| } |
| |
| @Override |
| protected int handleResponse(final EasResponse response) |
| throws IOException, CommandStatusException { |
| // This is really a container operation, its performOperation() actually just creates and |
| // performs a bunch of other operations. It doesn't actually do any of its own |
| // requests. |
| LogUtils.e(TAG, "unexpected call to EasFullSyncOperation.handleResponse"); |
| return RESULT_SUCCESS; |
| } |
| |
| @Override |
| public int performOperation() { |
| // Make sure the account is loaded if it hasn't already been. |
| if (!init(false)) { |
| LogUtils.i(LOG_TAG, "Failed to initialize %d before operation EasFullSyncOperation", |
| getAccountId()); |
| return RESULT_INITIALIZATION_FAILURE; |
| } |
| final android.accounts.Account amAccount = new android.accounts.Account( |
| mAccount.mEmailAddress, Eas.EXCHANGE_ACCOUNT_MANAGER_TYPE); |
| mAuthsToSync = EasService.getAuthoritiesToSync(amAccount, AUTHORITIES_TO_SYNC); |
| |
| // Figure out what we want to sync, based on the extras and our account sync status. |
| final boolean isInitialSync = EmailContent.isInitialSyncKey(mAccount.mSyncKey); |
| final long[] mailboxIds = Mailbox.getMailboxIdsFromBundle(mSyncExtras); |
| final int mailboxType = mSyncExtras.getInt(Mailbox.SYNC_EXTRA_MAILBOX_TYPE, |
| Mailbox.TYPE_NONE); |
| |
| final boolean isManual = mSyncExtras.getBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, false); |
| // Push only means this sync request should only refresh the ping (either because |
| // settings changed, or we need to restart it for some reason). |
| final boolean pushOnly = Mailbox.isPushOnlyExtras(mSyncExtras); |
| // Account only means just do a FolderSync. |
| final boolean accountOnly = Mailbox.isAccountOnlyExtras(mSyncExtras); |
| final boolean hasCallbackMethod = |
| mSyncExtras.containsKey(EmailServiceStatus.SYNC_EXTRAS_CALLBACK_METHOD); |
| // A "full sync" means that we didn't request a more specific type of sync. |
| // In this case we sync the folder list and all syncable folders. |
| final boolean isFullSync = (!pushOnly && !accountOnly && mailboxIds == null && |
| mailboxType == Mailbox.TYPE_NONE); |
| // A FolderSync is necessary for full sync, initial sync, and account only sync. |
| final boolean isFolderSync = (isFullSync || isInitialSync || accountOnly); |
| |
| int result; |
| |
| // Now we will use a bunch of other EasOperations to actually do the sync. Note that |
| // since we have overridden performOperation, this EasOperation does not have the |
| // normal handling of errors and retrying that is built in. The handling of errors and |
| // retries is done in each individual operation. |
| |
| // Perform a FolderSync if necessary. |
| // TODO: We permit FolderSync even during security hold, because it's necessary to |
| // resolve some holds. Ideally we would only do it for the holds that require it. |
| if (isFolderSync) { |
| final EasFolderSync folderSync = new EasFolderSync(mContext, mAccount); |
| result = folderSync.performOperation(); |
| if (isFatal(result)) { |
| // This is a failure, abort the sync. |
| LogUtils.i(TAG, "Fatal result %d on folderSync", result); |
| return result; |
| } |
| } |
| |
| // Do not permit further syncs if we're on security hold. |
| if ((mAccount.mFlags & Account.FLAGS_SECURITY_HOLD) != 0) { |
| return RESULT_SECURITY_HOLD; |
| } |
| |
| if (!isInitialSync) { |
| EasMoveItems moveOp = new EasMoveItems(mContext, mAccount); |
| result = moveOp.upsyncMovedMessages(); |
| if (isFatal(result)) { |
| // This is a failure, abort the sync. |
| LogUtils.i(TAG, "Fatal result %d on MoveItems", result); |
| return result; |
| } |
| |
| final EasSync upsync = new EasSync(mContext, mAccount); |
| result = upsync.upsync(); |
| if (isFatal(result)) { |
| // This is a failure, abort the sync. |
| LogUtils.i(TAG, "Fatal result %d on upsync", result); |
| return result; |
| } |
| } |
| |
| if (mailboxIds != null) { |
| // Sync the mailbox that was explicitly requested. |
| for (final long mailboxId : mailboxIds) { |
| result = syncMailbox(mailboxId, hasCallbackMethod, isManual); |
| if (isFatal(result)) { |
| // This is a failure, abort the sync. |
| LogUtils.i(TAG, "Fatal result %d on syncMailbox", result); |
| return result; |
| } |
| } |
| } else if (!accountOnly && !pushOnly) { |
| // We have to sync multiple folders. |
| final Cursor c; |
| if (isFullSync) { |
| // Full account sync includes all mailboxes that participate in system sync. |
| c = Mailbox.getMailboxIdsForSync(mContext.getContentResolver(), mAccount.mId); |
| } else { |
| // Type-filtered sync should only get the mailboxes of a specific type. |
| c = Mailbox.getMailboxIdsForSyncByType(mContext.getContentResolver(), |
| mAccount.mId, mailboxType); |
| } |
| if (c != null) { |
| try { |
| while (c.moveToNext()) { |
| result = syncMailbox(c.getLong(0), hasCallbackMethod, false); |
| if (isFatal(result)) { |
| // This is a failure, abort the sync. |
| LogUtils.i(TAG, "Fatal result %d on syncMailbox", result); |
| return result; |
| } |
| } |
| } finally { |
| c.close(); |
| } |
| } |
| } |
| |
| return RESULT_SUCCESS; |
| } |
| |
| private int syncMailbox(final long folderId, final boolean hasCallbackMethod, |
| final boolean isUserSync) { |
| final Mailbox mailbox = Mailbox.restoreMailboxWithId(mContext, folderId); |
| if (mailbox == null) { |
| LogUtils.d(TAG, "Could not load folder %d", folderId); |
| return EasSyncBase.RESULT_HARD_DATA_FAILURE; |
| } |
| |
| if (mailbox.mAccountKey != mAccount.mId) { |
| LogUtils.e(TAG, "Mailbox does not match account: mailbox %s, %s", mAccount.toString(), |
| mSyncExtras); |
| return EasSyncBase.RESULT_HARD_DATA_FAILURE; |
| } |
| |
| if (mAuthsToSync != null && !mAuthsToSync.contains(Mailbox.getAuthority(mailbox.mType))) { |
| // We are asking for an account sync, but this mailbox type is not configured for |
| // sync. Do NOT treat this as a sync error for ping backoff purposes. |
| return EasSyncBase.RESULT_DONE; |
| } |
| |
| if (mailbox.mType == Mailbox.TYPE_DRAFTS) { |
| // TODO: Because we don't have bidirectional sync working, trying to downsync |
| // the drafts folder is confusing. b/11158759 |
| // For now, just disable all syncing of DRAFTS type folders. |
| // Automatic syncing should always be disabled, but we also stop it here to ensure |
| // that we won't sync even if the user attempts to force a sync from the UI. |
| // Do NOT treat as a sync error for ping backoff purposes. |
| LogUtils.d(TAG, "Skipping sync of DRAFTS folder"); |
| return EmailServiceStatus.SUCCESS; |
| } |
| |
| int result = 0; |
| // Non-mailbox syncs are whole account syncs initiated by the AccountManager and are |
| // treated as background syncs. |
| if (mailbox.mType == Mailbox.TYPE_OUTBOX || mailbox.isSyncable()) { |
| final ContentValues cv = new ContentValues(2); |
| updateMailbox(mailbox, cv, isUserSync ? |
| EmailContent.SYNC_STATUS_USER : EmailContent.SYNC_STATUS_BACKGROUND); |
| try { |
| if (mailbox.mType == Mailbox.TYPE_OUTBOX) { |
| return syncOutbox(mailbox.mId); |
| } |
| if (hasCallbackMethod) { |
| EmailServiceStatus.syncMailboxStatus(mContext.getContentResolver(), mSyncExtras, |
| mailbox.mId, EmailServiceStatus.IN_PROGRESS, 0, |
| UIProvider.LastSyncResult.SUCCESS); |
| } |
| final EasSyncBase operation = new EasSyncBase(mContext, mAccount, mailbox); |
| LogUtils.d(TAG, "IEmailService.syncMailbox account %d", mAccount.mId); |
| result = operation.performOperation(); |
| } finally { |
| updateMailbox(mailbox, cv, EmailContent.SYNC_STATUS_NONE); |
| if (hasCallbackMethod) { |
| EmailServiceStatus.syncMailboxStatus(mContext.getContentResolver(), mSyncExtras, |
| mailbox.mId, EmailServiceStatus.SUCCESS, 0, |
| EasOperation.translateSyncResultToUiResult(result)); |
| } |
| } |
| } else { |
| // This mailbox is not syncable. |
| LogUtils.d(TAG, "Skipping sync of non syncable folder"); |
| } |
| |
| return result; |
| } |
| |
| private int syncOutbox(final long mailboxId) { |
| LogUtils.d(TAG, "syncOutbox %d", mAccount.mId); |
| // Because syncing the outbox uses a single EasOperation for every message, we don't |
| // want to use doOperation(). That would stop and restart the ping between each operation, |
| // which is wasteful if we have several messages to send. |
| final Cursor c = mContext.getContentResolver().query(EmailContent.Message.CONTENT_URI, |
| EmailContent.Message.CONTENT_PROJECTION, MAILBOX_KEY_AND_NOT_SEND_FAILED, |
| new String[] {Long.toString(mailboxId)}, null); |
| try { |
| // Loop through the messages, sending each one |
| while (c.moveToNext()) { |
| final Message message = new Message(); |
| message.restore(c); |
| if (Utility.hasUnloadedAttachments(mContext, message.mId)) { |
| // We'll just have to wait on this... |
| // TODO: We should make sure that this attachment is queued for download here. |
| continue; |
| } |
| |
| // TODO: Fix -- how do we want to signal to UI that we started syncing? |
| // Note the entire callback mechanism here needs improving. |
| //sendMessageStatus(message.mId, null, EmailServiceStatus.IN_PROGRESS, 0); |
| |
| EasOperation op = new EasOutboxSync(mContext, mAccount, message, true); |
| |
| int result = op.performOperation(); |
| if (result == EasOutboxSync.RESULT_ITEM_NOT_FOUND) { |
| // This can happen if we are using smartReply, and the message we are referring |
| // to has disappeared from the server. Try again with smartReply disabled. |
| op = new EasOutboxSync(mContext, mAccount, message, false); |
| result = op.performOperation(); |
| } |
| // If we got some connection error or other fatal error, terminate the sync. |
| // RESULT_NON_FATAL_ERROR |
| if (result != EasOutboxSync.RESULT_OK && |
| result != EasOutboxSync.RESULT_NON_FATAL_ERROR && |
| result > EasOutboxSync.RESULT_OP_SPECIFIC_ERROR_RESULT) { |
| LogUtils.w(TAG, "Aborting outbox sync for error %d", result); |
| return result; |
| } |
| } |
| } finally { |
| // TODO: Some sort of sendMessageStatus() is needed here. |
| c.close(); |
| } |
| |
| return EasOutboxSync.RESULT_OK; |
| } |
| |
| |
| /** |
| * Update the mailbox's sync status with the provider and, if we're finished with the sync, |
| * write the last sync time as well. |
| * @param mailbox The mailbox whose sync status to update. |
| * @param cv A {@link ContentValues} object to use for updating the provider. |
| * @param syncStatus The status for the current sync. |
| */ |
| private void updateMailbox(final Mailbox mailbox, final ContentValues cv, |
| final int syncStatus) { |
| cv.put(Mailbox.UI_SYNC_STATUS, syncStatus); |
| if (syncStatus == EmailContent.SYNC_STATUS_NONE) { |
| cv.put(Mailbox.SYNC_TIME, System.currentTimeMillis()); |
| } |
| mailbox.update(mContext, cv); |
| } |
| } |
