diff --git a/src/com/android/exchange/eas/EasFolderSync.java b/src/com/android/exchange/eas/EasFolderSync.java
index 1be9fe7..48d4070 100644
--- a/src/com/android/exchange/eas/EasFolderSync.java
+++ b/src/com/android/exchange/eas/EasFolderSync.java
@@ -30,6 +30,7 @@
 import com.android.exchange.adapter.FolderSyncParser;
 import com.android.exchange.adapter.Serializer;
 import com.android.exchange.adapter.Tags;
+import com.android.exchange.service.EasService;
 import com.android.mail.utils.LogUtils;
 
 import org.apache.http.HttpEntity;
@@ -55,15 +56,26 @@
      */
     public static final int RESULT_WRONG_OPERATION = 2;
 
-    // TODO: Eliminate the need for mAccount (requires FolderSyncParser changes).
-    private final Account mAccount;
-
     /** Indicates whether this object is for validation rather than sync. */
     private final boolean mStatusOnly;
 
     /** During validation, this holds the policy we must enforce. */
     private Policy mPolicy;
 
+    /** During validation, this holds the result. */
+    private Bundle mValidationResult;
+
+    /**
+     * Constructor for use with {@link EasService} when performing an actual sync.
+     * @param context
+     * @param accountId
+     */
+    public EasFolderSync(final Context context, final long accountId) {
+        super(context, accountId);
+        mStatusOnly = false;
+        mPolicy = null;
+    }
+
     /**
      * Constructor for actually doing folder sync.
      * @param context
@@ -71,7 +83,6 @@
      */
     public EasFolderSync(final Context context, final Account account) {
         super(context, account);
-        mAccount = account;
         mStatusOnly = false;
         mPolicy = null;
     }
@@ -82,18 +93,32 @@
      * @param hostAuth
      */
     public EasFolderSync(final Context context, final HostAuth hostAuth) {
-        this(context, new Account(), hostAuth);
+        super(context, -1);
+        setDummyAccount(hostAuth);
+        mStatusOnly = true;
     }
 
-    private EasFolderSync(final Context context, final Account account, final HostAuth hostAuth) {
-        super(context, account, hostAuth);
-        mAccount = account;
-        mAccount.mEmailAddress = hostAuth.mLogin;
-        mStatusOnly = true;
+    @Override
+    public int performOperation(final SyncResult syncResult) {
+        if (mStatusOnly) {
+            return validate();
+        } else {
+            LogUtils.d(LOG_TAG, "Performing FolderSync for account %d", getAccountId());
+            return super.performOperation(syncResult);
+        }
+    }
+
+    /**
+     * Returns the validation results after this operation has been performed.
+     * @return The validation results.
+     */
+    public Bundle getValidationResult() {
+        return mValidationResult;
     }
 
     /**
      * Perform a folder sync.
+     * TODO: Remove this function when transition to EasService is complete.
      * @param syncResult The {@link SyncResult} object for this sync operation.
      * @return A result code, either from above or from the base class.
      */
@@ -101,42 +126,61 @@
         if (mStatusOnly) {
             return RESULT_WRONG_OPERATION;
         }
-        LogUtils.d(LOG_TAG, "Performing sync for account %d", mAccount.mId);
-        return performOperation(syncResult);
+        LogUtils.d(LOG_TAG, "Performing sync for account %d", getAccountId());
+        // This intentionally calls super.performOperation -- calling our performOperation
+        // will simply end up calling super.performOperation anyway. This is part of the transition
+        // to EasService and will go away when this function is deleted.
+        return super.performOperation(syncResult);
     }
 
     /**
-     * Perform account validation.
-     * @return The response {@link Bundle} expected by the RPC.
+     * Helper function for {@link #performOperation} -- do some initial checks and, if they pass,
+     * perform a folder sync to verify that we can. This sets {@link #mValidationResult} as a side
+     * effect which holds the result details needed by the UI.
+     * @return A result code, either from above or from the base class.
      */
-    public Bundle validate() {
-        final Bundle bundle = new Bundle(3);
+    private int validate() {
+        mValidationResult = new Bundle(3);
         if (!mStatusOnly) {
-            writeResultCode(bundle, RESULT_OTHER_FAILURE);
-            return bundle;
+            writeResultCode(mValidationResult, RESULT_OTHER_FAILURE);
+            return RESULT_OTHER_FAILURE;
         }
         LogUtils.d(LOG_TAG, "Performing validation");
 
         if (!registerClientCert()) {
-            bundle.putInt(EmailServiceProxy.VALIDATE_BUNDLE_RESULT_CODE,
+            mValidationResult.putInt(EmailServiceProxy.VALIDATE_BUNDLE_RESULT_CODE,
                     MessagingException.CLIENT_CERTIFICATE_ERROR);
-            return bundle;
+            return RESULT_CLIENT_CERTIFICATE_REQUIRED;
         }
 
         if (shouldGetProtocolVersion()) {
             final EasOptions options = new EasOptions(this);
             final int result = options.getProtocolVersionFromServer(null);
             if (result != EasOptions.RESULT_OK) {
-                writeResultCode(bundle, result);
-                return bundle;
+                writeResultCode(mValidationResult, result);
+                return result;
             }
             final String protocolVersion = options.getProtocolVersionString();
             setProtocolVersion(protocolVersion);
-            bundle.putString(EmailServiceProxy.VALIDATE_BUNDLE_PROTOCOL_VERSION, protocolVersion);
+            mValidationResult.putString(EmailServiceProxy.VALIDATE_BUNDLE_PROTOCOL_VERSION,
+                    protocolVersion);
         }
 
-        writeResultCode(bundle, performOperation(null));
-        return bundle;
+        // This is intentionally a call to super.performOperation. This is a helper function for
+        // our version of perfomOperation so calling that function would infinite loop.
+        final int result = super.performOperation(null);
+        writeResultCode(mValidationResult, result);
+        return result;
+    }
+
+    /**
+     * Perform account validation.
+     * TODO: Remove this function when transition to EasService is complete.
+     * @return The response {@link Bundle} expected by the RPC.
+     */
+    public Bundle doValidate() {
+        validate();
+        return mValidationResult;
     }
 
     @Override
diff --git a/src/com/android/exchange/eas/EasMoveItems.java b/src/com/android/exchange/eas/EasMoveItems.java
index 97ce18c..ed2ecd7 100644
--- a/src/com/android/exchange/eas/EasMoveItems.java
+++ b/src/com/android/exchange/eas/EasMoveItems.java
@@ -53,7 +53,7 @@
 
     // TODO: Allow multiple messages in one request. Requires parser changes.
     public int upsyncMovedMessages(final SyncResult syncResult) {
-        final List<MessageMove> moves = MessageMove.getMoves(mContext, mAccountId);
+        final List<MessageMove> moves = MessageMove.getMoves(mContext, getAccountId());
         if (moves == null) {
             return RESULT_NO_MESSAGES;
         }
diff --git a/src/com/android/exchange/eas/EasOperation.java b/src/com/android/exchange/eas/EasOperation.java
index fcdeeda..4007847 100644
--- a/src/com/android/exchange/eas/EasOperation.java
+++ b/src/com/android/exchange/eas/EasOperation.java
@@ -56,15 +56,45 @@
  * a request, handling common errors, and setting fields on the {@link SyncResult} if there is one.
  * This class abstracts the connection handling from its subclasses and callers.
  *
- * A subclass must implement the abstract functions below that create the request and parse the
- * response. There are also a set of functions that a subclass may override if it's substantially
- * different from the "normal" operation (e.g. most requests use the same request URI, but auto
- * discover deviates since it's not account-specific), but the default implementation should suffice
- * for most. The subclass must also define a public function which calls {@link #performOperation},
- * possibly doing nothing other than that. (I chose to force subclasses to do this, rather than
- * provide that function in the base class, in order to force subclasses to consider, for example,
- * whether it needs a {@link SyncResult} parameter, and what the proper name for the "doWork"
- * function ought to be for the subclass.)
+ * {@link #performOperation} calls various abstract functions to create the request and parse the
+ * response. For the most part subclasses can implement just these bits of functionality and rely
+ * on {@link #performOperation} to do all the boilerplate etc.
+ *
+ * There are also a set of functions that a subclass may override if it's substantially
+ * different from the "normal" operation (e.g. autodiscover deviates from the standard URI since
+ * it's not account-specific so it needs to override {@link #getRequestUri()}), but the default
+ * implementations of these functions should suffice for most operations.
+ *
+ * Some subclasses may need to override {@link #performOperation} to add validation and results
+ * processing around a call to super.performOperation. Subclasses should avoid doing too much more
+ * than wrapping some handling around the chained call; if you find that's happening, it's likely
+ * a sign that the base class needs to be enhanced.
+ *
+ * One notable reason this wrapping happens is for operations that need to return a result directly
+ * to their callers (as opposed to simply writing the results to the provider, as is common with
+ * sync operations). This happens for example in
+ * {@link com.android.emailcommon.service.IEmailService} message handlers. In such cases, due to
+ * how {@link com.android.exchange.service.EasService} uses this class, the subclass needs to
+ * store the result as a member variable and then provide an accessor to read the result. Since
+ * different operations have different results (or none at all), there is no function in the base
+ * class for this.
+ *
+ * Note that it is not practical to avoid the race between when an operation loads its account data
+ * and when it uses it, as that would require some form of locking in the provider. There are three
+ * interesting situations where this might happen, and that this class must handle:
+ *
+ * 1) Deleted from provider: Any subsequent provider access should return an error. Operations
+ *    must detect this and terminate with an error.
+ * 2) Account sync settings change: Generally only affects Ping. We interrupt the operation and
+ *    load the new settings before proceeding.
+ * 3) Sync suspended due to hold: A special case of the previous, and affects all operations, but
+ *    fortunately doesn't need special handling here. Correct provider functionality must generate
+ *    write failures, so the handling for #1 should cover this case as well.
+ *
+ * This class attempts to defer loading of account data as long as possible -- ideally we load
+ * immediately before the network request -- but does not proactively check for changes after that.
+ * This approach is a a practical balance between minimizing the race without adding too much
+ * complexity beyond what's required.
  */
 public abstract class EasOperation {
     public static final String LOG_TAG = Eas.LOG_TAG;
@@ -93,42 +123,94 @@
     public static final int RESULT_CLIENT_CERTIFICATE_REQUIRED = -8;
     /** Error code indicating we don't have a protocol version in common with the server. */
     public static final int RESULT_PROTOCOL_VERSION_UNSUPPORTED = -9;
+    /** Error code indicating the account could not be loaded from the provider. */
+    public static final int RESULT_ACCOUNT_ID_INVALID = -10;
     /** Error code indicating some other failure. */
-    public static final int RESULT_OTHER_FAILURE = -10;
+    public static final int RESULT_OTHER_FAILURE = -11;
 
     protected final Context mContext;
 
-    /**
-     * The account id for this operation.
-     * NOTE: You will be tempted to add a reference to the {@link Account} here. Resist.
-     * It's too easy for that to lead to creep and stale data.
-     */
-    protected final long mAccountId;
-    private final EasServerConnection mConnection;
+    /** The provider id for the account this operation is on. */
+    private final long mAccountId;
 
-    // TODO: Make this private again when EasSyncHandler is converted to be a subclass.
-    protected EasOperation(final Context context, final long accountId,
-            final EasServerConnection connection) {
+    /** The cached {@link Account} state; can be null if it hasn't been loaded yet. */
+    protected Account mAccount;
+
+    /** The connection to use for this operation. This is created when {@link #mAccount} is set. */
+    private EasServerConnection mConnection;
+
+    /**
+     * Constructor which defers loading of account and connection info.
+     * @param context
+     * @param accountId
+     */
+    protected EasOperation(final Context context, final long accountId) {
         mContext = context;
         mAccountId = accountId;
+    }
+
+    // TODO: Make this private again when EasSyncHandler is converted to be a subclass.
+    protected EasOperation(final Context context, final Account account,
+            final EasServerConnection connection) {
+        this(context, account.mId);
+        mAccount = account;
         mConnection = connection;
     }
 
     protected EasOperation(final Context context, final Account account, final HostAuth hostAuth) {
-        this(context, account.mId, new EasServerConnection(context, account, hostAuth));
+        this(context, account, new EasServerConnection(context, account, hostAuth));
     }
 
     protected EasOperation(final Context context, final Account account) {
-        this(context, account, HostAuth.restoreHostAuthWithId(context, account.mHostAuthKeyRecv));
+        this(context, account, account.getOrCreateHostAuthRecv(context));
     }
 
     /**
      * This constructor is for use by operations that are created by other operations, e.g.
-     * {@link EasProvision}.
+     * {@link EasProvision}. It reuses the account and connection of its parent.
      * @param parentOperation The {@link EasOperation} that is creating us.
      */
     protected EasOperation(final EasOperation parentOperation) {
-        this(parentOperation.mContext, parentOperation.mAccountId, parentOperation.mConnection);
+        mContext = parentOperation.mContext;
+        mAccountId = parentOperation.mAccountId;
+        mAccount = parentOperation.mAccount;
+        mConnection = parentOperation.mConnection;
+    }
+
+    /**
+     * Some operations happen before the account exists (e.g. account validation).
+     * These operations cannot use {@link #loadAccount}, so instead we make a dummy account and
+     * supply a temporary {@link HostAuth}.
+     * @param hostAuth
+     */
+    protected final void setDummyAccount(final HostAuth hostAuth) {
+        mAccount = new Account();
+        mAccount.mEmailAddress = hostAuth.mLogin;
+        mConnection = new EasServerConnection(mContext, mAccount, hostAuth);
+    }
+
+    /**
+     * Loads (or reloads) the {@link Account} for this operation, and sets up our connection to the
+     * server.
+     * @param allowReload If false, do not perform a load if we already have an {@link Account}
+     *                    (i.e. just keep the existing one); otherwise allow replacement of the
+     *                    account. Note that this can result in a valid Account being replaced with
+     *                    null if the account no longer exists.
+     * @return Whether we now have a valid {@link Account} object.
+     */
+    public final boolean loadAccount(final boolean allowReload) {
+        if (mAccount == null || allowReload) {
+            mAccount = Account.restoreAccountWithId(mContext, getAccountId());
+            if (mAccount != null) {
+                mConnection = new EasServerConnection(mContext, mAccount,
+                        mAccount.getOrCreateHostAuthRecv(mContext));
+            }
+        }
+        return (mAccount != null);
+    }
+
+    public final long getAccountId() {
+        return mAccountId;
     }
 
     /**
@@ -169,7 +251,14 @@
      *                   be written to for this sync; otherwise null.
      * @return A result code for the outcome of this operation, as described above.
      */
-    protected final int performOperation(final SyncResult syncResult) {
+    public int performOperation(final SyncResult syncResult) {
+        // Make sure the account is loaded if it hasn't already been.
+        if (!loadAccount(false)) {
+            LogUtils.i(LOG_TAG, "Failed to load account %d before sending request for operation %s",
+                    getAccountId(), getCommand());
+            return RESULT_ACCOUNT_ID_INVALID;
+        }
+
         // We handle server redirects by looping, but we need to protect against too much looping.
         int redirectCount = 0;
 
@@ -269,7 +358,7 @@
 
                 // Handle provisioning errors.
                 if (result == RESULT_PROVISIONING_ERROR || response.isProvisionError()) {
-                    if (handleProvisionError(syncResult, mAccountId)) {
+                    if (handleProvisionError(syncResult, getAccountId())) {
                         // The provisioning error has been taken care of, so we should re-do this
                         // request.
                         LogUtils.d(LOG_TAG, "Provisioning error handled during %s, retrying",
@@ -331,8 +420,9 @@
      * @param protocolVersion The new protocol version to use, as a string.
      */
     protected final void setProtocolVersion(final String protocolVersion) {
-        if (mConnection.setProtocolVersion(protocolVersion) && mAccountId != Account.NOT_SAVED) {
-            final Uri uri = ContentUris.withAppendedId(Account.CONTENT_URI, mAccountId);
+        final long accountId = getAccountId();
+        if (mConnection.setProtocolVersion(protocolVersion) && accountId != Account.NOT_SAVED) {
+            final Uri uri = ContentUris.withAppendedId(Account.CONTENT_URI, accountId);
             final ContentValues cv = new ContentValues(2);
             if (getProtocolVersion() >= 12.0) {
                 final int oldFlags = Utility.getFirstRowInt(mContext, uri,
diff --git a/src/com/android/exchange/eas/EasPing.java b/src/com/android/exchange/eas/EasPing.java
index 507ca0c..d8e28a4 100644
--- a/src/com/android/exchange/eas/EasPing.java
+++ b/src/com/android/exchange/eas/EasPing.java
@@ -23,8 +23,6 @@
 import android.database.Cursor;
 import android.os.Bundle;
 import android.os.SystemClock;
-import android.provider.CalendarContract;
-import android.provider.ContactsContract;
 import android.text.format.DateUtils;
 
 import com.android.emailcommon.provider.Account;
@@ -44,9 +42,7 @@
 
 import java.io.IOException;
 import java.util.ArrayList;
-import java.util.HashMap;
 import java.util.HashSet;
-import java.util.Set;
 
 /**
  * Performs an Exchange Ping, which is the command for receiving push notifications.
@@ -58,7 +54,6 @@
     private static final String WHERE_ACCOUNT_KEY_AND_SERVER_ID =
             MailboxColumns.ACCOUNT_KEY + "=? and " + MailboxColumns.SERVER_ID + "=?";
 
-    private final long mAccountId;
     private final android.accounts.Account mAmAccount;
     private long mPingDuration;
 
@@ -97,13 +92,12 @@
     public EasPing(final Context context, final Account account,
             final android.accounts.Account amAccount) {
         super(context, account);
-        mAccountId = account.mId;
         mAmAccount = amAccount;
         mPingDuration = account.mPingDuration;
         if (mPingDuration == 0) {
             mPingDuration = DEFAULT_PING_HEARTBEAT;
         }
-        LogUtils.d(TAG, "initial ping duration " + mPingDuration + " account " + mAccountId);
+        LogUtils.d(TAG, "initial ping duration " + mPingDuration + " account " + getAccountId());
     }
 
     public final int doPing() {
@@ -123,7 +117,7 @@
         mPingDuration = Math.max(MINIMUM_PING_HEARTBEAT,
                 mPingDuration - MAXIMUM_HEARTBEAT_INCREMENT);
         LogUtils.d(TAG, "decreasePingDuration adjusting by " + MAXIMUM_HEARTBEAT_INCREMENT +
-                " new duration " + mPingDuration + " account " + mAccountId);
+                " new duration " + mPingDuration + " account " + getAccountId());
         storePingDuration();
     }
 
@@ -131,18 +125,14 @@
         mPingDuration = Math.min(MAXIMUM_PING_HEARTBEAT,
                 mPingDuration + MAXIMUM_HEARTBEAT_INCREMENT);
         LogUtils.d(TAG, "increasePingDuration adjusting by " + MAXIMUM_HEARTBEAT_INCREMENT +
-                " new duration " + mPingDuration + " account " + mAccountId);
+                " new duration " + mPingDuration + " account " + getAccountId());
         storePingDuration();
     }
 
     private void storePingDuration() {
         final ContentValues values = new ContentValues(1);
         values.put(AccountColumns.PING_DURATION, mPingDuration);
-        Account.update(mContext, Account.CONTENT_URI, mAccountId, values);
-    }
-
-    public final long getAccountId() {
-        return mAccountId;
+        Account.update(mContext, Account.CONTENT_URI, getAccountId(), values);
     }
 
     public final android.accounts.Account getAmAccount() {
@@ -158,7 +148,7 @@
     protected HttpEntity getRequestEntity() throws IOException {
         // Get the mailboxes that need push notifications.
         final Cursor c = Mailbox.getMailboxesForPush(mContext.getContentResolver(),
-                mAccountId);
+                getAccountId());
         if (c == null) {
             throw new IllegalStateException("Could not read mailboxes");
         }
@@ -201,14 +191,15 @@
         // Take the appropriate action for this response.
         // Many of the responses require no explicit action here, they just influence
         // our re-ping behavior, which is handled by the caller.
+        final long accountId = getAccountId();
         switch (pingStatus) {
             case PingParser.STATUS_EXPIRED:
-                LogUtils.i(TAG, "Ping expired for account %d", mAccountId);
+                LogUtils.i(TAG, "Ping expired for account %d", accountId);
                 // On successful expiration, we can increase our ping duration
                 increasePingDuration();
                 break;
             case PingParser.STATUS_CHANGES_FOUND:
-                LogUtils.i(TAG, "Ping found changed folders for account %d", mAccountId);
+                LogUtils.i(TAG, "Ping found changed folders for account %d", accountId);
                 requestSyncForSyncList(pp.getSyncList());
                 break;
             case PingParser.STATUS_REQUEST_INCOMPLETE:
@@ -216,28 +207,28 @@
                 // These two cases indicate that the ping request was somehow bad.
                 // TODO: It's insanity to re-ping with the same data and expect a different
                 // result. Improve this if possible.
-                LogUtils.e(TAG, "Bad ping request for account %d", mAccountId);
+                LogUtils.e(TAG, "Bad ping request for account %d", accountId);
                 break;
             case PingParser.STATUS_REQUEST_HEARTBEAT_OUT_OF_BOUNDS:
                 long newDuration = pp.getHeartbeatInterval();
                 LogUtils.i(TAG, "Heartbeat out of bounds for account %d, " +
-                        "old duration %d new duration %d", mAccountId, mPingDuration, newDuration);
+                        "old duration %d new duration %d", accountId, mPingDuration, newDuration);
                 mPingDuration = newDuration;
                 storePingDuration();
                 break;
             case PingParser.STATUS_REQUEST_TOO_MANY_FOLDERS:
-                LogUtils.i(TAG, "Too many folders for account %d", mAccountId);
+                LogUtils.i(TAG, "Too many folders for account %d", accountId);
                 break;
             case PingParser.STATUS_FOLDER_REFRESH_NEEDED:
-                LogUtils.i(TAG, "FolderSync needed for account %d", mAccountId);
+                LogUtils.i(TAG, "FolderSync needed for account %d", accountId);
                 requestFolderSync();
                 break;
             case PingParser.STATUS_SERVER_ERROR:
-                LogUtils.i(TAG, "Server error for account %d", mAccountId);
+                LogUtils.i(TAG, "Server error for account %d", accountId);
                 break;
             case CommandStatus.SERVER_ERROR_RETRY:
                 // Try again later.
-                LogUtils.i(TAG, "Retryable server error for account %d", mAccountId);
+                LogUtils.i(TAG, "Retryable server error for account %d", accountId);
                 return RESULT_RESTART;
 
             // These errors should not happen.
@@ -328,7 +319,7 @@
      */
     private void requestSyncForSyncList(final ArrayList<String> syncList) {
         final String[] bindArguments = new String[2];
-        bindArguments[0] = Long.toString(mAccountId);
+        bindArguments[0] = Long.toString(getAccountId());
 
         final ArrayList<Long> mailboxIds = new ArrayList<Long>();
         final HashSet<Integer> contentTypes = new HashSet<Integer>();
diff --git a/src/com/android/exchange/eas/EasProvision.java b/src/com/android/exchange/eas/EasProvision.java
index 97e6a65..7b5bcb9 100644
--- a/src/com/android/exchange/eas/EasProvision.java
+++ b/src/com/android/exchange/eas/EasProvision.java
@@ -21,6 +21,7 @@
 import android.os.Bundle;
 import android.telephony.TelephonyManager;
 
+import com.android.emailcommon.provider.Account;
 import com.android.emailcommon.provider.EmailContent;
 import com.android.emailcommon.provider.Policy;
 import com.android.emailcommon.service.PolicyServiceProxy;
@@ -95,9 +96,9 @@
     private int mPhase;
 
     // TODO: Temporary until EasSyncHandler converts to EasOperation.
-    public EasProvision(final Context context, final long accountId,
+    public EasProvision(final Context context, final Account account,
             final EasServerConnection connection) {
-        super(context, accountId, connection);
+        super(context, account, connection);
         mPolicy = null;
         mPolicyKey = null;
         mStatus = null;
diff --git a/src/com/android/exchange/eas/EasSync.java b/src/com/android/exchange/eas/EasSync.java
index 6395092..084f921 100644
--- a/src/com/android/exchange/eas/EasSync.java
+++ b/src/com/android/exchange/eas/EasSync.java
@@ -104,8 +104,8 @@
      * @return Number of messages successfully synced, or -1 if we encountered an error.
      */
     public final int upsync(final SyncResult syncResult) {
-        final List<MessageStateChange> changes = MessageStateChange.getChanges(mContext, mAccountId,
-                        getProtocolVersion() < Eas.SUPPORTED_PROTOCOL_EX2007_DOUBLE);
+        final List<MessageStateChange> changes = MessageStateChange.getChanges(mContext,
+                getAccountId(), getProtocolVersion() < Eas.SUPPORTED_PROTOCOL_EX2007_DOUBLE);
         if (changes == null) {
             return 0;
         }
@@ -184,17 +184,12 @@
     @Override
     protected int handleResponse(final EasResponse response, final SyncResult syncResult)
             throws IOException, CommandStatusException {
-        final Account account = Account.restoreAccountWithId(mContext, mAccountId);
-        if (account == null) {
-            // TODO: Make this some other error type, since the account is just gone now.
-            return RESULT_OTHER_FAILURE;
-        }
         final Mailbox mailbox = Mailbox.restoreMailboxWithId(mContext, mMailboxId);
         if (mailbox == null) {
             return RESULT_OTHER_FAILURE;
         }
         final EmailSyncParser parser = new EmailSyncParser(mContext, mContext.getContentResolver(),
-                response.getInputStream(), mailbox, account);
+                response.getInputStream(), mailbox, mAccount);
         try {
             parser.parse();
             mMessageUpdateStatus = parser.getMessageStatuses();
diff --git a/src/com/android/exchange/service/EasService.java b/src/com/android/exchange/service/EasService.java
new file mode 100644
index 0000000..54b7f45
--- /dev/null
+++ b/src/com/android/exchange/service/EasService.java
@@ -0,0 +1,134 @@
+/*
+ * Copyright (C) 2014 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.exchange.service;
+
+import android.app.Service;
+import android.content.Intent;
+import android.content.SyncResult;
+import android.os.Bundle;
+import android.os.IBinder;
+
+import com.android.emailcommon.provider.HostAuth;
+import com.android.emailcommon.service.IEmailService;
+import com.android.emailcommon.service.IEmailServiceCallback;
+import com.android.emailcommon.service.SearchParams;
+import com.android.exchange.Eas;
+import com.android.exchange.eas.EasFolderSync;
+import com.android.exchange.eas.EasOperation;
+import com.android.mail.utils.LogUtils;
+
+/**
+ * Service to handle all communication with the EAS server. Note that this is completely decoupled
+ * from the sync adapters; sync adapters should make blocking calls on this service to actually
+ * perform any operations.
+ */
+public class EasService extends Service {
+
+    private static final String TAG = Eas.LOG_TAG;
+
+    private final PingSyncSynchronizer mSynchronizer;
+
+    private final IEmailService.Stub mBinder = new IEmailService.Stub() {
+        @Override
+        public void sendMail(final long accountId) {}
+
+        @Override
+        public void loadAttachment(final IEmailServiceCallback callback, final long attachmentId,
+                final boolean background) {
+            LogUtils.d(TAG, "IEmailService.loadAttachment: %d", attachmentId);
+        }
+
+        @Override
+        public void updateFolderList(final long accountId) {
+            final EasFolderSync operation = new EasFolderSync(EasService.this, accountId);
+            doOperation(operation, null, "IEmailService.updateFolderList");
+        }
+
+        @Override
+        public Bundle validate(final HostAuth hostAuth) {
+            final EasFolderSync operation = new EasFolderSync(EasService.this, hostAuth);
+            doOperation(operation, null, "IEmailService.validate");
+            return operation.getValidationResult();
+        }
+
+        @Override
+        public int searchMessages(final long accountId, final SearchParams searchParams,
+                final long destMailboxId) {
+            LogUtils.d(TAG, "IEmailService.searchMessages");
+            return 0;
+        }
+
+        @Override
+        public void sendMeetingResponse(final long messageId, final int response) {
+            LogUtils.d(TAG, "IEmailService.sendMeetingResponse: %d, %d", messageId, response);
+        }
+
+        @Override
+        public Bundle autoDiscover(final String username, final String password) {
+            LogUtils.d(TAG, "IEmailService.autoDiscover");
+            return null;
+        }
+
+        @Override
+        public void setLogging(final int flags) {
+            LogUtils.d(TAG, "IEmailService.setLogging");
+        }
+
+        @Override
+        public void deleteAccountPIMData(final String emailAddress) {
+            LogUtils.d(TAG, "IEmailService.deleteAccountPIMData");
+        }
+    };
+
+    public EasService() {
+        super();
+        mSynchronizer = new PingSyncSynchronizer(this);
+    }
+
+    @Override
+    public void onCreate() {
+        // TODO: Restart all pings that are needed.
+    }
+
+    @Override
+    public void onDestroy() {
+        // TODO: Stop all running pings.
+    }
+
+    @Override
+    public IBinder onBind(final Intent intent) {
+        return mBinder;
+    }
+
+    public int doOperation(final EasOperation operation, final SyncResult syncResult,
+            final String loggingName) {
+        final long accountId = operation.getAccountId();
+        LogUtils.d(TAG, "%s: %d", loggingName, accountId);
+        mSynchronizer.syncStart(accountId);
+        // TODO: Do we need a wakelock here? For RPC coming from sync adapters, no -- the SA
+        // already has one. But for others, maybe? Not sure what's guaranteed for AIDL calls.
+        // If we add a wakelock (or anything else for that matter) here, must remember to undo
+        // it in the finally block below.
+        // On the other hand, even for SAs, it doesn't hurt to get a wakelock here.
+        try {
+            return operation.performOperation(syncResult);
+        } finally {
+            // TODO: Fix pushEnabled param
+            mSynchronizer.syncEnd(accountId, false);
+        }
+    }
+}
diff --git a/src/com/android/exchange/service/EasSyncHandler.java b/src/com/android/exchange/service/EasSyncHandler.java
index f2c92c3..0b6ee1c 100644
--- a/src/com/android/exchange/service/EasSyncHandler.java
+++ b/src/com/android/exchange/service/EasSyncHandler.java
@@ -374,7 +374,7 @@
                 result = responseResult;
             } else if (resp.isProvisionError()
                     || responseResult == SYNC_RESULT_PROVISIONING_ERROR) {
-                final EasProvision provision = new EasProvision(mContext, mAccount.mId, this);
+                final EasProvision provision = new EasProvision(mContext, mAccount, this);
                 if (provision.provision(syncResult, mAccount.mId)) {
                     // We handled the provisioning error, so loop.
                     LogUtils.d(TAG, "Provisioning error handled during sync, retrying");
diff --git a/src/com/android/exchange/service/EmailSyncAdapterService.java b/src/com/android/exchange/service/EmailSyncAdapterService.java
index e7eae82..834d84b 100644
--- a/src/com/android/exchange/service/EmailSyncAdapterService.java
+++ b/src/com/android/exchange/service/EmailSyncAdapterService.java
@@ -362,7 +362,7 @@
         @Override
         public Bundle validate(final HostAuth hostAuth) {
             LogUtils.d(TAG, "IEmailService.validate");
-            return new EasFolderSync(EmailSyncAdapterService.this, hostAuth).validate();
+            return new EasFolderSync(EmailSyncAdapterService.this, hostAuth).doValidate();
         }
 
         @Override
diff --git a/src/com/android/exchange/service/PingSyncSynchronizer.java b/src/com/android/exchange/service/PingSyncSynchronizer.java
new file mode 100644
index 0000000..9fa0197
--- /dev/null
+++ b/src/com/android/exchange/service/PingSyncSynchronizer.java
@@ -0,0 +1,323 @@
+/*
+ * Copyright (C) 2014 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.exchange.service;
+
+import android.app.Service;
+import android.content.Intent;
+import android.support.v4.util.LongSparseArray;
+
+import com.android.exchange.Eas;
+import com.android.mail.utils.LogUtils;
+
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+/**
+ * Bookkeeping for handling synchronization between pings and other sync related operations.
+ * "Ping" refers to a hanging POST or GET that is used to receive push notifications. Ping is
+ * the term for the Exchange command, but this code should be generic enough to be extended to IMAP.
+ *
+ * Basic rules of how these interact (note that all rules are per account):
+ * - Only one operation (ping or other active sync operation) may run at a time.
+ * - For shorthand, this class uses "sync" to mean "non-ping operation"; most such operations are
+ *   sync ops, but some may not be (e.g. EAS Settings).
+ * - Syncs can come from many sources concurrently; this class must serialize them.
+ *
+ * WHEN A SYNC STARTS:
+ * - If nothing is running, proceed.
+ * - If something is already running: wait until it's done.
+ * - If the running thing is a ping task: interrupt it.
+ *
+ * WHEN A SYNC ENDS:
+ * - If there are waiting syncs: signal one to proceed.
+ * - If there are no waiting syncs and this account is configured for push: start a ping.
+ * - Otherwise: This account is now idle.
+ *
+ * WHEN A PING TASK ENDS:
+ * - A ping task loops until either it's interrupted by a sync (in which case, there will be one or
+ *   more waiting syncs when the ping terminates), or encounters an error.
+ * - If there are waiting syncs, and we were interrupted: signal one to proceed.
+ * - If there are waiting syncs, but the ping terminated with an error: TODO: How to handle?
+ * - If there are no waiting syncs and this account is configured for push: This means the ping task
+ *   was terminated due to an error. Handle this by sending a sync request through the SyncManager
+ *   that doesn't actually do any syncing, and whose only effect is to restart the ping.
+ * - Otherwise: This account is now idle.
+ *
+ * WHEN AN ACCOUNT WANTS TO START OR CHANGE ITS PUSH BEHAVIOR:
+ * - If nothing is running, start a new ping task.
+ * - If a ping task is currently running, restart it with the new settings.
+ * - If a sync is currently running, do nothing.
+ *
+ * WHEN AN ACCOUNT WANTS TO STOP GETTING PUSH:
+ * - If nothing is running, do nothing.
+ * - If a ping task is currently running, interrupt it.
+ */
+public class PingSyncSynchronizer {
+
+    private static final String TAG = Eas.LOG_TAG;
+
+    /**
+     * This class handles bookkeeping for a single account.
+     */
+    private static class AccountSyncState {
+        /** The currently running {@link PingTask}, or null if we aren't in the middle of a Ping. */
+        private PingTask mPingTask;
+
+        /**
+         * The number of syncs that are blocked waiting for the current operation to complete.
+         * Unlike Pings, sync operations do not start their own tasks and are assumed to run in
+         * whatever thread calls into this class.
+         */
+        private int mSyncCount;
+
+        /** The condition on which to block syncs that need to wait. */
+        private Condition mCondition;
+
+        /**
+         *
+         * @param lock The lock from which to create our condition.
+         */
+        public AccountSyncState(final Lock lock) {
+            mPingTask = null;
+            mSyncCount = 0;
+            mCondition = lock.newCondition();
+        }
+
+        /**
+         * Update bookkeeping for a new sync:
+         * - Stop the Ping if there is one.
+         * - Wait until there's nothing running for this account before proceeding.
+         */
+        public void syncStart() {
+            ++mSyncCount;
+            if (mPingTask != null) {
+                // Syncs are higher priority than Ping -- terminate the Ping.
+                LogUtils.d(TAG, "Sync is pre-empting a ping");
+                mPingTask.stop();
+            }
+            if (mPingTask != null || mSyncCount > 1) {
+                // There’s something we need to wait for before we can proceed.
+                try {
+                    LogUtils.d(TAG, "Sync needs to wait: Ping: %s, Pending tasks: %d",
+                            mPingTask != null ? "yes" : "no", mSyncCount);
+                    mCondition.await();
+                } catch (final InterruptedException e) {
+                    // TODO: Handle this properly. Not catching it might be the right answer.
+                }
+            }
+        }
+
+        /**
+         * Update bookkeeping when a sync completes. This includes signaling pending ops to
+         * go ahead, or starting the ping if appropriate and there are no waiting ops.
+         * @param pushEnabled Whether this account is configured for push.
+         * @return Whether this account is now idle.
+         */
+        public boolean syncEnd(final boolean pushEnabled) {
+            --mSyncCount;
+            if (mSyncCount > 0) {
+                LogUtils.d(TAG, "Signalling a pending sync to proceed.");
+                mCondition.signal();
+                return false;
+            } else {
+                if (pushEnabled) {
+                    // TODO: Start the ping task
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        /**
+         * Update bookkeeping when the ping task terminates, including signaling any waiting ops.
+         * @param pushEnabled Whether this account is configured for push.
+         * @return Whether this account is now idle.
+         */
+        public boolean pingEnd(final boolean pushEnabled) {
+            mPingTask = null;
+            if (mSyncCount > 0) {
+                mCondition.signal();
+                return false;
+            } else {
+                if (pushEnabled) {
+                    // TODO: request a push-only sync.
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        /**
+         * Modifies or starts a ping for this account if no syncs are running.
+         */
+        public void pushModify() {
+            if (mSyncCount == 0) {
+                if (mPingTask == null) {
+                    // No ping, no running syncs -- start a new ping.
+                    // TODO: Fix this.
+                    //mPingTask = new PingTask();
+                    mPingTask.start();
+                } else {
+                    // Ping is already running, so tell it to restart to pick up any new params.
+                    mPingTask.restart();
+                }
+            }
+        }
+
+        /**
+         * Stop the currently running ping.
+         */
+        public void pushStop() {
+            if (mPingTask != null) {
+                mPingTask.stop();
+            }
+        }
+    }
+
+    /**
+     * Lock for access to {@link #mAccountStateMap}, also used to create the {@link Condition}s for
+     * each Account.
+     */
+    private final ReentrantLock mLock;
+
+    /**
+     * Map from account ID -> {@link AccountSyncState} for accounts with a running operation.
+     * An account is in this map only when this account is active, i.e. has a ping or sync running
+     * or pending. If an account is not in the middle of a sync and is not configured for push,
+     * it will not be here. This allows to use emptiness of this map to know whether the service
+     * needs to be running, and is also handy when debugging.
+     */
+    private final LongSparseArray<AccountSyncState> mAccountStateMap;
+
+    /** The {@link Service} that this object is managing. */
+    private final Service mService;
+
+    public PingSyncSynchronizer(final Service service) {
+        mLock = new ReentrantLock();
+        mAccountStateMap = new LongSparseArray<AccountSyncState>();
+        mService = service;
+    }
+
+    /**
+     * Gets the {@link AccountSyncState} for an account.
+     * The caller must hold {@link #mLock}.
+     * @param accountId The id for the account we're interested in.
+     * @param createIfNeeded If true, create the account state if it's not already there.
+     * @return The {@link AccountSyncState} for that account, or null if the account is idle and
+     *         createIfNeeded is false.
+     */
+    private AccountSyncState getAccountState(final long accountId, final boolean createIfNeeded) {
+        assert mLock.isHeldByCurrentThread();
+        AccountSyncState state = mAccountStateMap.get(accountId);
+        if (state == null && createIfNeeded) {
+            LogUtils.d(TAG, "PSS adding account state for %d", accountId);
+            state = new AccountSyncState(mLock);
+            mAccountStateMap.put(accountId, state);
+            // TODO: Is this too late to startService?
+            if (mAccountStateMap.size() == 1) {
+                LogUtils.i(TAG, "PSS added first account, starting service");
+                mService.startService(new Intent(mService, mService.getClass()));
+            }
+        }
+        return state;
+    }
+
+    /**
+     * Remove an account from the map. If this was the last account, then also stop this service.
+     * The caller must hold {@link #mLock}.
+     * @param accountId The id for the account we're removing.
+     */
+    private void removeAccount(final long accountId) {
+        assert mLock.isHeldByCurrentThread();
+        LogUtils.d(TAG, "PSS removing account state for %d", accountId);
+        mAccountStateMap.delete(accountId);
+        if (mAccountStateMap.size() == 0) {
+            LogUtils.i(TAG, "PSS removed last account; stopping service.");
+            mService.stopSelf();
+        }
+    }
+
+    public void syncStart(final long accountId) {
+        mLock.lock();
+        try {
+            LogUtils.d(TAG, "PSS syncStart for account %d", accountId);
+            final AccountSyncState accountState = getAccountState(accountId, true);
+            accountState.syncStart();
+        } finally {
+            mLock.unlock();
+        }
+    }
+
+    public void syncEnd(final long accountId, final boolean pushEnabled) {
+        mLock.lock();
+        try {
+            LogUtils.d(TAG, "PSS syncEnd for account %d", accountId);
+            final AccountSyncState accountState = getAccountState(accountId, false);
+            if (accountState == null) {
+                LogUtils.w(TAG, "PSS syncEnd for account %d but no state found", accountId);
+                return;
+            }
+            if (accountState.syncEnd(pushEnabled)) {
+                removeAccount(accountId);
+            }
+        } finally {
+            mLock.unlock();
+        }
+    }
+
+    public void pingEnd(final long accountId, final boolean pushEnabled) {
+        mLock.lock();
+        try {
+            LogUtils.d(TAG, "PSS pingEnd for account %d", accountId);
+            final AccountSyncState accountState = getAccountState(accountId, false);
+            if (accountState == null) {
+                LogUtils.w(TAG, "PSS pingEnd for account %d but no state found", accountId);
+                return;
+            }
+            if (accountState.pingEnd(pushEnabled)) {
+                removeAccount(accountId);
+            }
+        } finally {
+            mLock.unlock();
+        }
+    }
+
+    public void pushModify(final long accountId) {
+        mLock.lock();
+        try {
+            LogUtils.d(TAG, "PSS pushModify for account %d", accountId);
+            final AccountSyncState accountState = getAccountState(accountId, true);
+            accountState.pushModify();
+        } finally {
+            mLock.unlock();
+        }
+    }
+
+    public void pushStop(final long accountId) {
+        mLock.lock();
+        try {
+            LogUtils.d(TAG, "PSS pushStop for account %d", accountId);
+            final AccountSyncState accountState = getAccountState(accountId, false);
+            if (accountState != null) {
+                accountState.pushStop();
+            }
+        } finally {
+            mLock.unlock();
+        }
+    }
+}
diff --git a/src/com/android/exchange/service/PingTask.java b/src/com/android/exchange/service/PingTask.java
index 768727c..a016556 100644
--- a/src/com/android/exchange/service/PingTask.java
+++ b/src/com/android/exchange/service/PingTask.java
@@ -31,15 +31,28 @@
  */
 public class PingTask extends AsyncTask<Void, Void, Void> {
     private final EasPing mOperation;
+    // TODO: Transition away from mSyncHandlerMap -> mPingSyncSynchronizer.
     private final EmailSyncAdapterService.SyncHandlerSynchronizer mSyncHandlerMap;
+    private final PingSyncSynchronizer mPingSyncSynchronizer;
 
     private static final String TAG = Eas.LOG_TAG;
 
     public PingTask(final Context context, final Account account,
             final android.accounts.Account amAccount,
             final EmailSyncAdapterService.SyncHandlerSynchronizer syncHandlerMap) {
+        assert syncHandlerMap != null;
         mOperation = new EasPing(context, account, amAccount);
         mSyncHandlerMap = syncHandlerMap;
+        mPingSyncSynchronizer = null;
+    }
+
+    public PingTask(final Context context, final Account account,
+            final android.accounts.Account amAccount,
+            final PingSyncSynchronizer pingSyncSynchronizer) {
+        assert pingSyncSynchronizer != null;
+        mOperation = new EasPing(context, account, amAccount);
+        mSyncHandlerMap = null;
+        mPingSyncSynchronizer = pingSyncSynchronizer;
     }
 
     /** Start the ping loop. */
@@ -74,8 +87,13 @@
         }
         LogUtils.i(TAG, "Ping task ending with status: %d", pingStatus);
 
-        mSyncHandlerMap.pingComplete(mOperation.getAmAccount(), mOperation.getAccountId(),
-                pingStatus);
+        if (mSyncHandlerMap != null) {
+            mSyncHandlerMap.pingComplete(mOperation.getAmAccount(), mOperation.getAccountId(),
+                    pingStatus);
+        } else {
+            // TODO: Fix the pushEnabled param.
+            mPingSyncSynchronizer.pingEnd(mOperation.getAccountId(), false);
+        }
         return null;
     }
 
@@ -84,7 +102,12 @@
         // TODO: This is also hacky, should have a separate result code at minimum.
         // If the ping is cancelled, make sure it reports something to the sync adapter.
         LogUtils.w(TAG, "Ping cancelled for %d", mOperation.getAccountId());
-        mSyncHandlerMap.pingComplete(mOperation.getAmAccount(), mOperation.getAccountId(),
-                EasOperation.RESULT_REQUEST_FAILURE);
+        if (mSyncHandlerMap != null) {
+            mSyncHandlerMap.pingComplete(mOperation.getAmAccount(), mOperation.getAccountId(),
+                    EasOperation.RESULT_REQUEST_FAILURE);
+        } else {
+            // TODO: Fix the pushEnabled param.
+            mPingSyncSynchronizer.pingEnd(mOperation.getAccountId(), false);
+        }
     }
 }
diff --git a/tests/src/com/android/exchange/service/PingSyncSynchronizerTest.java b/tests/src/com/android/exchange/service/PingSyncSynchronizerTest.java
new file mode 100644
index 0000000..40235d8
--- /dev/null
+++ b/tests/src/com/android/exchange/service/PingSyncSynchronizerTest.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2014 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.exchange.service;
+
+import android.app.Service;
+import android.content.Intent;
+import android.os.IBinder;
+import android.test.AndroidTestCase;
+
+import android.test.suitebuilder.annotation.SmallTest;
+
+@SmallTest
+public class PingSyncSynchronizerTest extends AndroidTestCase {
+
+    private static class StubService extends Service {
+        @Override
+        public IBinder onBind(final Intent intent) {
+            return null;
+        }
+    }
+
+}