datamodel/action/SyncMessagesAction.java

/*
 * Copyright (C) 2015 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.messaging.datamodel.action;

import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteException;
import android.os.Bundle;
import android.os.Parcel;
import android.os.Parcelable;
import android.os.SystemClock;
import android.provider.Telephony.Mms;
import android.support.v4.util.LongSparseArray;

import com.android.messaging.Factory;
import com.android.messaging.datamodel.DataModel;
import com.android.messaging.datamodel.DatabaseWrapper;
import com.android.messaging.datamodel.MessagingContentProvider;
import com.android.messaging.datamodel.SyncManager;
import com.android.messaging.datamodel.SyncManager.ThreadInfoCache;
import com.android.messaging.datamodel.data.ParticipantData;
import com.android.messaging.mmslib.SqliteWrapper;
import com.android.messaging.sms.DatabaseMessages;
import com.android.messaging.sms.DatabaseMessages.LocalDatabaseMessage;
import com.android.messaging.sms.DatabaseMessages.MmsMessage;
import com.android.messaging.sms.DatabaseMessages.SmsMessage;
import com.android.messaging.sms.MmsUtils;
import com.android.messaging.util.Assert;
import com.android.messaging.util.BugleGservices;
import com.android.messaging.util.BugleGservicesKeys;
import com.android.messaging.util.BuglePrefs;
import com.android.messaging.util.BuglePrefsKeys;
import com.android.messaging.util.ContentType;
import com.android.messaging.util.LogUtil;
import com.android.messaging.util.OsUtil;

import java.util.ArrayList;
import java.util.List;
import java.util.Locale;

/**
 * Action used to sync messages from smsmms db to local database
 */
public class SyncMessagesAction extends Action implements Parcelable {
    static final long SYNC_FAILED = Long.MIN_VALUE;

    private static final String TAG = LogUtil.BUGLE_DATAMODEL_TAG;

    private static final String KEY_START_TIMESTAMP = "start_timestamp";
    private static final String KEY_MAX_UPDATE = "max_update";
    private static final String KEY_LOWER_BOUND = "lower_bound";
    private static final String KEY_UPPER_BOUND = "upper_bound";
    private static final String BUNDLE_KEY_LAST_TIMESTAMP = "last_timestamp";
    private static final String BUNDLE_KEY_SMS_MESSAGES = "sms_to_add";
    private static final String BUNDLE_KEY_MMS_MESSAGES = "mms_to_add";
    private static final String BUNDLE_KEY_MESSAGES_TO_DELETE = "messages_to_delete";

    /**
     * Start a full sync (backed off a few seconds to avoid pulling sending/receiving messages).
     */
    public static void fullSync() {
        final BugleGservices bugleGservices = BugleGservices.get();
        final long smsSyncBackoffTimeMillis = bugleGservices.getLong(
                BugleGservicesKeys.SMS_SYNC_BACKOFF_TIME_MILLIS,
                BugleGservicesKeys.SMS_SYNC_BACKOFF_TIME_MILLIS_DEFAULT);

        final long now = System.currentTimeMillis();
        // TODO: Could base this off most recent message in db but now should be okay...
        final long startTimestamp = now - smsSyncBackoffTimeMillis;

        final SyncMessagesAction action = new SyncMessagesAction(-1L, startTimestamp,
                0, startTimestamp);
        action.start();
    }

    /**
     * Start an incremental sync to pull messages since last sync (backed off a few seconds)..
     */
    public static void sync() {
        final BugleGservices bugleGservices = BugleGservices.get();
        final long smsSyncBackoffTimeMillis = bugleGservices.getLong(
                BugleGservicesKeys.SMS_SYNC_BACKOFF_TIME_MILLIS,
                BugleGservicesKeys.SMS_SYNC_BACKOFF_TIME_MILLIS_DEFAULT);

        final long now = System.currentTimeMillis();
        // TODO: Could base this off most recent message in db but now should be okay...
        final long startTimestamp = now - smsSyncBackoffTimeMillis;

        sync(startTimestamp);
    }

    /**
     * Start an incremental sync when the application starts up (no back off as not yet
     *  sending/receiving).
     */
    public static void immediateSync() {
        final long now = System.currentTimeMillis();
        // TODO: Could base this off most recent message in db but now should be okay...
        final long startTimestamp = now;

        sync(startTimestamp);
    }

    private static void sync(final long startTimestamp) {
        if (!OsUtil.hasSmsPermission()) {
            // Sync requires READ_SMS permission
            return;
        }

        final BuglePrefs prefs = BuglePrefs.getApplicationPrefs();
        // Lower bound is end of previous sync
        final long syncLowerBoundTimeMillis = prefs.getLong(BuglePrefsKeys.LAST_SYNC_TIME,
                    BuglePrefsKeys.LAST_SYNC_TIME_DEFAULT);

        final SyncMessagesAction action = new SyncMessagesAction(syncLowerBoundTimeMillis,
                startTimestamp, 0, startTimestamp);
        action.start();
    }

    private SyncMessagesAction(final long lowerBound, final long upperBound,
            final int maxMessagesToUpdate, final long startTimestamp) {
        actionParameters.putLong(KEY_LOWER_BOUND, lowerBound);
        actionParameters.putLong(KEY_UPPER_BOUND, upperBound);
        actionParameters.putInt(KEY_MAX_UPDATE, maxMessagesToUpdate);
        actionParameters.putLong(KEY_START_TIMESTAMP, startTimestamp);
    }

    @Override
    protected Object executeAction() {
        final DatabaseWrapper db = DataModel.get().getDatabase();

        long lowerBoundTimeMillis = actionParameters.getLong(KEY_LOWER_BOUND);
        final long upperBoundTimeMillis = actionParameters.getLong(KEY_UPPER_BOUND);
        final int initialMaxMessagesToUpdate = actionParameters.getInt(KEY_MAX_UPDATE);
        final long startTimestamp = actionParameters.getLong(KEY_START_TIMESTAMP);

        if (LogUtil.isLoggable(TAG, LogUtil.DEBUG)) {
            LogUtil.d(TAG, "SyncMessagesAction: Request to sync messages from "
                    + lowerBoundTimeMillis + " to " + upperBoundTimeMillis + " (start timestamp = "
                    + startTimestamp + ", message update limit = " + initialMaxMessagesToUpdate
                    + ")");
        }

        final SyncManager syncManager = DataModel.get().getSyncManager();
        if (lowerBoundTimeMillis >= 0) {
            // Cursors
            final SyncCursorPair cursors = new SyncCursorPair(-1L, lowerBoundTimeMillis);
            final boolean inSync = cursors.isSynchronized(db);
            if (!inSync) {
                if (syncManager.delayUntilFullSync(startTimestamp) == 0) {
                    lowerBoundTimeMillis = -1;
                    actionParameters.putLong(KEY_LOWER_BOUND, lowerBoundTimeMillis);

                    if (LogUtil.isLoggable(TAG, LogUtil.DEBUG)) {
                        LogUtil.d(TAG, "SyncMessagesAction: Messages before "
                                + lowerBoundTimeMillis + " not in sync; promoting to full sync");
                    }
                } else if (LogUtil.isLoggable(TAG, LogUtil.DEBUG)) {
                    LogUtil.d(TAG, "SyncMessagesAction: Messages before "
                            + lowerBoundTimeMillis + " not in sync; will do incremental sync");
                }
            } else {
                if (LogUtil.isLoggable(TAG, LogUtil.DEBUG)) {
                    LogUtil.d(TAG, "SyncMessagesAction: Messages before " + lowerBoundTimeMillis
                            + " are in sync");
                }
            }
        }

        // Check if sync allowed (can be too soon after last or one is already running)
        if (syncManager.shouldSync(lowerBoundTimeMillis < 0, startTimestamp)) {
            syncManager.startSyncBatch(upperBoundTimeMillis);
            requestBackgroundWork();
        }

        return null;
    }

    @Override
    protected Bundle doBackgroundWork() {
        final BugleGservices bugleGservices = BugleGservices.get();
        final DatabaseWrapper db = DataModel.get().getDatabase();

        final int maxMessagesToScan = bugleGservices.getInt(
                BugleGservicesKeys.SMS_SYNC_BATCH_MAX_MESSAGES_TO_SCAN,
                BugleGservicesKeys.SMS_SYNC_BATCH_MAX_MESSAGES_TO_SCAN_DEFAULT);

        final int initialMaxMessagesToUpdate = actionParameters.getInt(KEY_MAX_UPDATE);
        final int smsSyncSubsequentBatchSizeMin = bugleGservices.getInt(
                BugleGservicesKeys.SMS_SYNC_BATCH_SIZE_MIN,
                BugleGservicesKeys.SMS_SYNC_BATCH_SIZE_MIN_DEFAULT);
        final int smsSyncSubsequentBatchSizeMax = bugleGservices.getInt(
                BugleGservicesKeys.SMS_SYNC_BATCH_SIZE_MAX,
                BugleGservicesKeys.SMS_SYNC_BATCH_SIZE_MAX_DEFAULT);

        // Cap sync size to GServices limits
        final int maxMessagesToUpdate = Math.max(smsSyncSubsequentBatchSizeMin,
                Math.min(initialMaxMessagesToUpdate, smsSyncSubsequentBatchSizeMax));

        final long lowerBoundTimeMillis = actionParameters.getLong(KEY_LOWER_BOUND);
        final long upperBoundTimeMillis = actionParameters.getLong(KEY_UPPER_BOUND);

        LogUtil.i(TAG, "SyncMessagesAction: Starting batch for messages from "
                + lowerBoundTimeMillis + " to " + upperBoundTimeMillis
                + " (message update limit = " + maxMessagesToUpdate + ", message scan limit = "
                + maxMessagesToScan + ")");

        // Clear last change time so that we can work out if this batch is dirty when it completes
        final SyncManager syncManager = DataModel.get().getSyncManager();

        // Clear the singleton cache that maps threads to recipients and to conversations.
        final SyncManager.ThreadInfoCache cache = syncManager.getThreadInfoCache();
        cache.clear();

        // Sms messages to store
        final ArrayList<SmsMessage> smsToAdd = new ArrayList<SmsMessage>();
        // Mms messages to store
        final LongSparseArray<MmsMessage> mmsToAdd = new LongSparseArray<MmsMessage>();
        // List of local SMS/MMS to remove
        final ArrayList<LocalDatabaseMessage> messagesToDelete =
                new ArrayList<LocalDatabaseMessage>();

        long lastTimestampMillis = SYNC_FAILED;
        if (syncManager.isSyncing(upperBoundTimeMillis)) {
            // Cursors
            final SyncCursorPair cursors = new SyncCursorPair(lowerBoundTimeMillis,
                    upperBoundTimeMillis);

            // Actually compare the messages using cursor pair
            lastTimestampMillis = syncCursorPair(db, cursors, smsToAdd, mmsToAdd,
                    messagesToDelete, maxMessagesToScan, maxMessagesToUpdate, cache);
        }
        final Bundle response = new Bundle();

        // If comparison succeeds bundle up the changes for processing in ActionService
        if (lastTimestampMillis > SYNC_FAILED) {
            final ArrayList<MmsMessage> mmsToAddList = new ArrayList<MmsMessage>();
            for (int i = 0; i < mmsToAdd.size(); i++) {
                final MmsMessage mms = mmsToAdd.valueAt(i);
                mmsToAddList.add(mms);
            }

            response.putParcelableArrayList(BUNDLE_KEY_SMS_MESSAGES, smsToAdd);
            response.putParcelableArrayList(BUNDLE_KEY_MMS_MESSAGES, mmsToAddList);
            response.putParcelableArrayList(BUNDLE_KEY_MESSAGES_TO_DELETE, messagesToDelete);
        }
        response.putLong(BUNDLE_KEY_LAST_TIMESTAMP, lastTimestampMillis);

        return response;
    }

    /**
     * Compare messages based on timestamp and uri
     * @param db local database wrapper
     * @param cursors cursor pair holding references to local and remote messages
     * @param smsToAdd newly found sms messages to add
     * @param mmsToAdd newly found mms messages to add
     * @param messagesToDelete messages not found needing deletion
     * @param maxMessagesToScan max messages to scan for changes
     * @param maxMessagesToUpdate max messages to return for updates
     * @param cache cache for conversation id / thread id / recipient set mapping
     * @return timestamp of the oldest message seen during the sync scan
     */
    private long syncCursorPair(final DatabaseWrapper db, final SyncCursorPair cursors,
            final ArrayList<SmsMessage> smsToAdd, final LongSparseArray<MmsMessage> mmsToAdd,
            final ArrayList<LocalDatabaseMessage> messagesToDelete, final int maxMessagesToScan,
            final int maxMessagesToUpdate, final ThreadInfoCache cache) {
        long lastTimestampMillis;
        final long startTimeMillis = SystemClock.elapsedRealtime();

        // Number of messages scanned local and remote
        int localPos = 0;
        int remotePos = 0;
        int localTotal = 0;
        int remoteTotal = 0;
        // Scan through the messages on both sides and prepare messages for local message table
        // changes (including adding and deleting)
        try {
            cursors.query(db);

            localTotal = cursors.getLocalCount();
            remoteTotal = cursors.getRemoteCount();

            if (LogUtil.isLoggable(TAG, LogUtil.DEBUG)) {
                LogUtil.d(TAG, "SyncMessagesAction: Scanning cursors (local count = " + localTotal
                        + ", remote count = " + remoteTotal + ", message update limit = "
                        + maxMessagesToUpdate + ", message scan limit = " + maxMessagesToScan
                        + ")");
            }

            lastTimestampMillis = cursors.scan(maxMessagesToScan, maxMessagesToUpdate,
                    smsToAdd, mmsToAdd, messagesToDelete, cache);

            localPos = cursors.getLocalPosition();
            remotePos = cursors.getRemotePosition();

            if (LogUtil.isLoggable(TAG, LogUtil.DEBUG)) {
                LogUtil.d(TAG, "SyncMessagesAction: Scanned cursors (local position = " + localPos
                        + " of " + localTotal + ", remote position = " + remotePos + " of "
                        + remoteTotal + ")");
            }

            // Batch loading the parts of the MMS messages in this batch
            loadMmsParts(mmsToAdd);
            // Lookup senders for incoming mms messages
            setMmsSenders(mmsToAdd, cache);
        } catch (final SQLiteException e) {
            LogUtil.e(TAG, "SyncMessagesAction: Database exception", e);
            // Let's abort
            lastTimestampMillis = SYNC_FAILED;
        } catch (final Exception e) {
            // We want to catch anything unexpected since this is running in a separate thread
            // and any unexpected exception will just fail this thread silently.
            // Let's crash for dogfooders!
            LogUtil.wtf(TAG, "SyncMessagesAction: unexpected failure in scan", e);
            lastTimestampMillis = SYNC_FAILED;
        } finally {
            if (cursors != null) {
                cursors.close();
            }
        }

        final long endTimeMillis = SystemClock.elapsedRealtime();

        if (LogUtil.isLoggable(TAG, LogUtil.DEBUG)) {
            LogUtil.d(TAG, "SyncMessagesAction: Scan complete (took "
                    + (endTimeMillis - startTimeMillis) + " ms). " + smsToAdd.size()
                    + " remote SMS to add, " + mmsToAdd.size() + " MMS to add, "
                    + messagesToDelete.size() + " local messages to delete. "
                    + "Oldest timestamp seen = " + lastTimestampMillis);
        }

        return lastTimestampMillis;
    }

    /**
     * Perform local database updates and schedule follow on sync actions
     */
    @Override
    protected Object processBackgroundResponse(final Bundle response) {
        final long lastTimestampMillis = response.getLong(BUNDLE_KEY_LAST_TIMESTAMP);
        final long lowerBoundTimeMillis = actionParameters.getLong(KEY_LOWER_BOUND);
        final long upperBoundTimeMillis = actionParameters.getLong(KEY_UPPER_BOUND);
        final int maxMessagesToUpdate = actionParameters.getInt(KEY_MAX_UPDATE);
        final long startTimestamp = actionParameters.getLong(KEY_START_TIMESTAMP);

        // Check with the sync manager if any conflicting updates have been made to databases
        final SyncManager syncManager = DataModel.get().getSyncManager();
        final boolean orphan = !syncManager.isSyncing(upperBoundTimeMillis);

        // lastTimestampMillis used to indicate failure
        if (orphan) {
            // This batch does not match current in progress timestamp.
            LogUtil.w(TAG, "SyncMessagesAction: Ignoring orphan sync batch for messages from "
                    + lowerBoundTimeMillis + " to " + upperBoundTimeMillis);
        } else {
            final boolean dirty = syncManager.isBatchDirty(lastTimestampMillis);
            if (lastTimestampMillis == SYNC_FAILED) {
                LogUtil.e(TAG, "SyncMessagesAction: Sync failed - terminating");

                // Failed - update last sync times to throttle our failure rate
                final BuglePrefs prefs = BuglePrefs.getApplicationPrefs();
                // Save sync completion time so next sync will start from here
                prefs.putLong(BuglePrefsKeys.LAST_SYNC_TIME, startTimestamp);
                // Remember last full sync so that don't start background full sync right away
                prefs.putLong(BuglePrefsKeys.LAST_FULL_SYNC_TIME, startTimestamp);

                syncManager.complete();
            } else if (dirty) {
                LogUtil.w(TAG, "SyncMessagesAction: Redoing dirty sync batch of messages from "
                        + lowerBoundTimeMillis + " to " + upperBoundTimeMillis);

                // Redo this batch
                final SyncMessagesAction nextBatch =
                        new SyncMessagesAction(lowerBoundTimeMillis, upperBoundTimeMillis,
                                maxMessagesToUpdate, startTimestamp);

                syncManager.startSyncBatch(upperBoundTimeMillis);
                requestBackgroundWork(nextBatch);
            } else {
                // Succeeded
                final ArrayList<SmsMessage> smsToAdd =
                        response.getParcelableArrayList(BUNDLE_KEY_SMS_MESSAGES);
                final ArrayList<MmsMessage> mmsToAdd =
                        response.getParcelableArrayList(BUNDLE_KEY_MMS_MESSAGES);
                final ArrayList<LocalDatabaseMessage> messagesToDelete =
                        response.getParcelableArrayList(BUNDLE_KEY_MESSAGES_TO_DELETE);

                final int messagesUpdated = smsToAdd.size() + mmsToAdd.size()
                        + messagesToDelete.size();

                // Perform local database changes in one transaction
                long txnTimeMillis = 0;
                if (messagesUpdated > 0) {
                    final long startTimeMillis = SystemClock.elapsedRealtime();
                    final SyncMessageBatch batch = new SyncMessageBatch(smsToAdd, mmsToAdd,
                            messagesToDelete, syncManager.getThreadInfoCache());
                    batch.updateLocalDatabase();
                    final long endTimeMillis = SystemClock.elapsedRealtime();
                    txnTimeMillis = endTimeMillis - startTimeMillis;

                    LogUtil.i(TAG, "SyncMessagesAction: Updated local database "
                            + "(took " + txnTimeMillis + " ms). Added "
                            + smsToAdd.size() + " SMS, added " + mmsToAdd.size() + " MMS, deleted "
                            + messagesToDelete.size() + " messages.");

                    // TODO: Investigate whether we can make this more fine-grained.
                    MessagingContentProvider.notifyEverythingChanged();
                } else {
                    if (LogUtil.isLoggable(TAG, LogUtil.DEBUG)) {
                        LogUtil.d(TAG, "SyncMessagesAction: No local database updates to make");
                    }

                    if (!syncManager.getHasFirstSyncCompleted()) {
                        // If we have never completed a sync before (fresh install) and there are
                        // no messages, still inform the UI of a change so it can update syncing
                        // messages shown to the user
                        MessagingContentProvider.notifyConversationListChanged();
                        MessagingContentProvider.notifyPartsChanged();
                    }
                }
                // Determine if there are more messages that need to be scanned
                if (lastTimestampMillis >= 0 && lastTimestampMillis >= lowerBoundTimeMillis) {
                    if (LogUtil.isLoggable(TAG, LogUtil.DEBUG)) {
                        LogUtil.d(TAG, "SyncMessagesAction: More messages to sync; scheduling next "
                                + "sync batch now.");
                    }

                    // Include final millisecond of last sync in next sync
                    final long newUpperBoundTimeMillis = lastTimestampMillis + 1;
                    final int newMaxMessagesToUpdate = nextBatchSize(messagesUpdated,
                            txnTimeMillis);

                    final SyncMessagesAction nextBatch =
                            new SyncMessagesAction(lowerBoundTimeMillis, newUpperBoundTimeMillis,
                                    newMaxMessagesToUpdate, startTimestamp);

                    // Proceed with next batch
                    syncManager.startSyncBatch(newUpperBoundTimeMillis);
                    requestBackgroundWork(nextBatch);
                } else {
                    final BuglePrefs prefs = BuglePrefs.getApplicationPrefs();
                    // Save sync completion time so next sync will start from here
                    prefs.putLong(BuglePrefsKeys.LAST_SYNC_TIME, startTimestamp);
                    if (lowerBoundTimeMillis < 0) {
                        // Remember last full sync so that don't start another full sync right away
                        prefs.putLong(BuglePrefsKeys.LAST_FULL_SYNC_TIME, startTimestamp);
                    }

                    final long now = System.currentTimeMillis();

                    // After any sync check if new messages have arrived
                    final SyncCursorPair recents = new SyncCursorPair(startTimestamp, now);
                    final SyncCursorPair olders = new SyncCursorPair(-1L, startTimestamp);
                    final DatabaseWrapper db = DataModel.get().getDatabase();
                    if (!recents.isSynchronized(db)) {
                        LogUtil.i(TAG, "SyncMessagesAction: Changed messages after sync; "
                                + "scheduling an incremental sync now.");

                        // Just add a new batch for recent messages
                        final SyncMessagesAction nextBatch =
                                new SyncMessagesAction(startTimestamp, now, 0, startTimestamp);
                        syncManager.startSyncBatch(now);
                        requestBackgroundWork(nextBatch);
                        // After partial sync verify sync state
                    } else if (lowerBoundTimeMillis >= 0 && !olders.isSynchronized(db)) {
                        // Add a batch going back to start of time
                        LogUtil.w(TAG, "SyncMessagesAction: Changed messages before sync batch; "
                                + "scheduling a full sync now.");

                        final SyncMessagesAction nextBatch =
                                new SyncMessagesAction(-1L, startTimestamp, 0, startTimestamp);

                        syncManager.startSyncBatch(startTimestamp);
                        requestBackgroundWork(nextBatch);
                    } else {
                        LogUtil.i(TAG, "SyncMessagesAction: All messages now in sync");

                        // All done, in sync
                        syncManager.complete();
                    }
                }
                // Either sync should be complete or we should have a follow up request
                Assert.isTrue(hasBackgroundActions() || !syncManager.isSyncing());
            }
        }

        return null;
    }

    /**
     * Decide the next batch size based on the stats we collected with past batch
     * @param messagesUpdated number of messages updated in this batch
     * @param txnTimeMillis time the transaction took in ms
     * @return Target number of messages to sync for next batch
     */
    private static int nextBatchSize(final int messagesUpdated, final long txnTimeMillis) {
        final BugleGservices bugleGservices = BugleGservices.get();
        final long smsSyncSubsequentBatchTimeLimitMillis = bugleGservices.getLong(
                BugleGservicesKeys.SMS_SYNC_BATCH_TIME_LIMIT_MILLIS,
                BugleGservicesKeys.SMS_SYNC_BATCH_TIME_LIMIT_MILLIS_DEFAULT);

        if (txnTimeMillis <= 0) {
            return 0;
        }
        // Number of messages we can sync within the batch time limit using
        // the average sync time calculated based on the stats we collected
        // in previous batch
        return (int) ((double) (messagesUpdated) / (double) txnTimeMillis
                        * smsSyncSubsequentBatchTimeLimitMillis);
    }

    /**
     * Batch loading MMS parts for the messages in current batch
     */
    private void loadMmsParts(final LongSparseArray<MmsMessage> mmses) {
        final Context context = Factory.get().getApplicationContext();
        final int totalIds = mmses.size();
        for (int start = 0; start < totalIds; start += MmsUtils.MAX_IDS_PER_QUERY) {
            final int end = Math.min(start + MmsUtils.MAX_IDS_PER_QUERY, totalIds); //excluding
            final int count = end - start;
            final String batchSelection = String.format(
                    Locale.US,
                    "%s != '%s' AND %s IN %s",
                    Mms.Part.CONTENT_TYPE,
                    ContentType.APP_SMIL,
                    Mms.Part.MSG_ID,
                    MmsUtils.getSqlInOperand(count));
            final String[] batchSelectionArgs = new String[count];
            for (int i = 0; i < count; i++) {
                batchSelectionArgs[i] = Long.toString(mmses.valueAt(start + i).getId());
            }
            final Cursor cursor = SqliteWrapper.query(
                    context,
                    context.getContentResolver(),
                    MmsUtils.MMS_PART_CONTENT_URI,
                    DatabaseMessages.MmsPart.PROJECTION,
                    batchSelection,
                    batchSelectionArgs,
                    null/*sortOrder*/);
            if (cursor != null) {
                try {
                    while (cursor.moveToNext()) {
                        // Delay loading the media content for parsing for efficiency
                        // TODO: load the media and fill in the dimensions when
                        // we actually display it
                        final DatabaseMessages.MmsPart part =
                                DatabaseMessages.MmsPart.get(cursor, false/*loadMedia*/);
                        final DatabaseMessages.MmsMessage mms = mmses.get(part.mMessageId);
                        if (mms != null) {
                            mms.addPart(part);
                        }
                    }
                } finally {
                    cursor.close();
                }
            }
        }
    }

    /**
     * Batch loading MMS sender for the messages in current batch
     */
    private void setMmsSenders(final LongSparseArray<MmsMessage> mmses,
            final ThreadInfoCache cache) {
        // Store all the MMS messages
        for (int i = 0; i < mmses.size(); i++) {
            final MmsMessage mms = mmses.valueAt(i);

            final boolean isOutgoing = mms.mType != Mms.MESSAGE_BOX_INBOX;
            String senderId = null;
            if (!isOutgoing) {
                // We only need to find out sender phone number for received message
                senderId = getMmsSender(mms, cache);
                if (senderId == null) {
                    LogUtil.w(TAG, "SyncMessagesAction: Could not find sender of incoming MMS "
                            + "message " + mms.getUri() + "; using 'unknown sender' instead");
                    senderId = ParticipantData.getUnknownSenderDestination();
                }
            }
            mms.setSender(senderId);
        }
    }

    /**
     * Find out the sender of an MMS message
     */
    private String getMmsSender(final MmsMessage mms, final ThreadInfoCache cache) {
        final List<String> recipients = cache.getThreadRecipients(mms.mThreadId);
        Assert.notNull(recipients);
        Assert.isTrue(recipients.size() > 0);

        if (recipients.size() == 1
                && recipients.get(0).equals(ParticipantData.getUnknownSenderDestination())) {
            LogUtil.w(TAG, "SyncMessagesAction: MMS message " + mms.mUri + " has unknown sender "
                    + "(thread id = " + mms.mThreadId + ")");
        }

        return MmsUtils.getMmsSender(recipients, mms.mUri);
    }

    private SyncMessagesAction(final Parcel in) {
        super(in);
    }

    public static final Parcelable.Creator<SyncMessagesAction> CREATOR
            = new Parcelable.Creator<SyncMessagesAction>() {
        @Override
        public SyncMessagesAction createFromParcel(final Parcel in) {
            return new SyncMessagesAction(in);
        }

        @Override
        public SyncMessagesAction[] newArray(final int size) {
            return new SyncMessagesAction[size];
        }
    };

    @Override
    public void writeToParcel(final Parcel parcel, final int flags) {
        writeActionToParcel(parcel, flags);
    }
}