path: root/src/com/android/messaging/datamodel/action/ProcessDownloadedMmsAction.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.app.Activity;
import android.content.ContentValues;
import android.content.Context;
import android.net.Uri;
import android.os.Bundle;
import android.os.Parcel;
import android.os.Parcelable;
import android.provider.Telephony.Mms;
import android.telephony.SmsManager;
import android.text.TextUtils;

import com.android.messaging.Factory;
import com.android.messaging.datamodel.BugleDatabaseOperations;
import com.android.messaging.datamodel.BugleNotifications;
import com.android.messaging.datamodel.DataModel;
import com.android.messaging.datamodel.DataModelException;
import com.android.messaging.datamodel.DatabaseWrapper;
import com.android.messaging.datamodel.MessagingContentProvider;
import com.android.messaging.datamodel.MmsFileProvider;
import com.android.messaging.datamodel.SyncManager;
import com.android.messaging.datamodel.data.MessageData;
import com.android.messaging.datamodel.data.ParticipantData;
import com.android.messaging.mmslib.SqliteWrapper;
import com.android.messaging.mmslib.pdu.PduHeaders;
import com.android.messaging.mmslib.pdu.RetrieveConf;
import com.android.messaging.sms.DatabaseMessages;
import com.android.messaging.sms.MmsSender;
import com.android.messaging.sms.MmsUtils;
import com.android.messaging.util.Assert;
import com.android.messaging.util.LogUtil;
import com.google.common.io.Files;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.List;

/**
 * Processes an MMS message after it has been downloaded.
 * NOTE: This action must queue a ProcessPendingMessagesAction when it is done (success or failure).
 */
public class ProcessDownloadedMmsAction extends Action {
    private static final String TAG = LogUtil.BUGLE_DATAMODEL_TAG;

    // Always set when message downloaded
    private static final String KEY_DOWNLOADED_BY_PLATFORM = "downloaded_by_platform";
    private static final String KEY_MESSAGE_ID = "message_id";
    private static final String KEY_NOTIFICATION_URI = "notification_uri";
    private static final String KEY_CONVERSATION_ID = "conversation_id";
    private static final String KEY_PARTICIPANT_ID = "participant_id";
    private static final String KEY_STATUS_IF_FAILED = "status_if_failed";

    // Set when message downloaded by platform (L+)
    private static final String KEY_RESULT_CODE = "result_code";
    private static final String KEY_HTTP_STATUS_CODE = "http_status_code";
    private static final String KEY_CONTENT_URI = "content_uri";
    private static final String KEY_SUB_ID = "sub_id";
    private static final String KEY_SUB_PHONE_NUMBER = "sub_phone_number";
    private static final String KEY_TRANSACTION_ID = "transaction_id";
    private static final String KEY_CONTENT_LOCATION = "content_location";
    private static final String KEY_AUTO_DOWNLOAD = "auto_download";
    private static final String KEY_RECEIVED_TIMESTAMP = "received_timestamp";
    private static final String KEY_EXPIRY = "expiry";

    // Set when message downloaded by us (legacy)
    private static final String KEY_STATUS = "status";
    private static final String KEY_RAW_STATUS = "raw_status";
    private static final String KEY_MMS_URI = "mms_uri";

    // Used to send a deferred response in response to auto-download failure
    private static final String KEY_SEND_DEFERRED_RESP_STATUS = "send_deferred_resp_status";

    // Results passed from background worker to processCompletion
    private static final String BUNDLE_REQUEST_STATUS = "request_status";
    private static final String BUNDLE_RAW_TELEPHONY_STATUS = "raw_status";
    private static final String BUNDLE_MMS_URI = "mms_uri";

    // This is called when MMS lib API returns via PendingIntent
    public static void processMessageDownloaded(final int resultCode, final Bundle extras) {
        final String messageId = extras.getString(DownloadMmsAction.EXTRA_MESSAGE_ID);
        final Uri contentUri = extras.getParcelable(DownloadMmsAction.EXTRA_CONTENT_URI);
        final Uri notificationUri = extras.getParcelable(DownloadMmsAction.EXTRA_NOTIFICATION_URI);
        final String conversationId = extras.getString(DownloadMmsAction.EXTRA_CONVERSATION_ID);
        final String participantId = extras.getString(DownloadMmsAction.EXTRA_PARTICIPANT_ID);
        Assert.notNull(messageId);
        Assert.notNull(contentUri);
        Assert.notNull(notificationUri);
        Assert.notNull(conversationId);
        Assert.notNull(participantId);

        final ProcessDownloadedMmsAction action = new ProcessDownloadedMmsAction();
        final Bundle params = action.actionParameters;
        params.putBoolean(KEY_DOWNLOADED_BY_PLATFORM, true);
        params.putString(KEY_MESSAGE_ID, messageId);
        params.putInt(KEY_RESULT_CODE, resultCode);
        params.putInt(KEY_HTTP_STATUS_CODE,
                extras.getInt(SmsManager.EXTRA_MMS_HTTP_STATUS, 0));
        params.putParcelable(KEY_CONTENT_URI, contentUri);
        params.putParcelable(KEY_NOTIFICATION_URI, notificationUri);
        params.putInt(KEY_SUB_ID,
                extras.getInt(DownloadMmsAction.EXTRA_SUB_ID, ParticipantData.DEFAULT_SELF_SUB_ID));
        params.putString(KEY_SUB_PHONE_NUMBER,
                extras.getString(DownloadMmsAction.EXTRA_SUB_PHONE_NUMBER));
        params.putString(KEY_TRANSACTION_ID,
                extras.getString(DownloadMmsAction.EXTRA_TRANSACTION_ID));
        params.putString(KEY_CONTENT_LOCATION,
                extras.getString(DownloadMmsAction.EXTRA_CONTENT_LOCATION));
        params.putBoolean(KEY_AUTO_DOWNLOAD,
                extras.getBoolean(DownloadMmsAction.EXTRA_AUTO_DOWNLOAD));
        params.putLong(KEY_RECEIVED_TIMESTAMP,
                extras.getLong(DownloadMmsAction.EXTRA_RECEIVED_TIMESTAMP));
        params.putString(KEY_CONVERSATION_ID, conversationId);
        params.putString(KEY_PARTICIPANT_ID, participantId);
        params.putInt(KEY_STATUS_IF_FAILED,
                extras.getInt(DownloadMmsAction.EXTRA_STATUS_IF_FAILED));
        params.putLong(KEY_EXPIRY, extras.getLong(DownloadMmsAction.EXTRA_EXPIRY));
        action.start();
    }

    // This is called for fast failing downloading (due to airplane mode or mobile data )
    public static void processMessageDownloadFastFailed(final String messageId,
            final Uri notificationUri, final String conversationId, final String participantId,
            final String contentLocation, final int subId, final String subPhoneNumber,
            final int statusIfFailed, final boolean autoDownload, final String transactionId,
            final int resultCode) {
        Assert.notNull(messageId);
        Assert.notNull(notificationUri);
        Assert.notNull(conversationId);
        Assert.notNull(participantId);

        final ProcessDownloadedMmsAction action = new ProcessDownloadedMmsAction();
        final Bundle params = action.actionParameters;
        params.putBoolean(KEY_DOWNLOADED_BY_PLATFORM, true);
        params.putString(KEY_MESSAGE_ID, messageId);
        params.putInt(KEY_RESULT_CODE, resultCode);
        params.putParcelable(KEY_NOTIFICATION_URI, notificationUri);
        params.putInt(KEY_SUB_ID, subId);
        params.putString(KEY_SUB_PHONE_NUMBER, subPhoneNumber);
        params.putString(KEY_CONTENT_LOCATION, contentLocation);
        params.putBoolean(KEY_AUTO_DOWNLOAD, autoDownload);
        params.putString(KEY_CONVERSATION_ID, conversationId);
        params.putString(KEY_PARTICIPANT_ID, participantId);
        params.putInt(KEY_STATUS_IF_FAILED, statusIfFailed);
        params.putString(KEY_TRANSACTION_ID, transactionId);
        action.start();
    }

    public static void processDownloadActionFailure(final String messageId, final int status,
            final int rawStatus, final String conversationId, final String participantId,
            final int statusIfFailed, final int subId, final String transactionId) {
        Assert.notNull(messageId);
        Assert.notNull(conversationId);
        Assert.notNull(participantId);

        final ProcessDownloadedMmsAction action = new ProcessDownloadedMmsAction();
        final Bundle params = action.actionParameters;
        params.putBoolean(KEY_DOWNLOADED_BY_PLATFORM, false);
        params.putString(KEY_MESSAGE_ID, messageId);
        params.putInt(KEY_STATUS, status);
        params.putInt(KEY_RAW_STATUS, rawStatus);
        params.putString(KEY_CONVERSATION_ID, conversationId);
        params.putString(KEY_PARTICIPANT_ID, participantId);
        params.putInt(KEY_STATUS_IF_FAILED, statusIfFailed);
        params.putInt(KEY_SUB_ID, subId);
        params.putString(KEY_TRANSACTION_ID, transactionId);
        action.start();
    }

    public static void sendDeferredRespStatus(final String messageId, final String transactionId,
            final String contentLocation, final int subId) {
        final ProcessDownloadedMmsAction action = new ProcessDownloadedMmsAction();
        final Bundle params = action.actionParameters;
        params.putString(KEY_MESSAGE_ID, messageId);
        params.putString(KEY_TRANSACTION_ID, transactionId);
        params.putString(KEY_CONTENT_LOCATION, contentLocation);
        params.putBoolean(KEY_SEND_DEFERRED_RESP_STATUS, true);
        params.putInt(KEY_SUB_ID, subId);
        action.start();
    }

    private ProcessDownloadedMmsAction() {
        // Callers must use one of the static methods above
    }

    @Override
    protected Object executeAction() {
        // Fire up the background worker
        requestBackgroundWork();
        return null;
    }

    @Override
    protected Bundle doBackgroundWork() throws DataModelException {
        final Context context = Factory.get().getApplicationContext();
        final int subId = actionParameters.getInt(KEY_SUB_ID, ParticipantData.DEFAULT_SELF_SUB_ID);
        final String messageId = actionParameters.getString(KEY_MESSAGE_ID);
        final String transactionId = actionParameters.getString(KEY_TRANSACTION_ID);
        final String contentLocation = actionParameters.getString(KEY_CONTENT_LOCATION);
        final boolean sendDeferredRespStatus =
                actionParameters.getBoolean(KEY_SEND_DEFERRED_RESP_STATUS, false);

        // Send a response indicating that auto-download failed
        if (sendDeferredRespStatus) {
            if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) {
                LogUtil.v(TAG, "DownloadMmsAction: Auto-download of message " + messageId
                        + " failed; sending DEFERRED NotifyRespInd");
            }
            MmsUtils.sendNotifyResponseForMmsDownload(
                    context,
                    subId,
                    MmsUtils.stringToBytes(transactionId, "UTF-8"),
                    contentLocation,
                    PduHeaders.STATUS_DEFERRED);
            return null;
        }

        // Processing a real MMS download
        final boolean downloadedByPlatform = actionParameters.getBoolean(
                KEY_DOWNLOADED_BY_PLATFORM);

        final int status;
        int rawStatus = MmsUtils.PDU_HEADER_VALUE_UNDEFINED;
        Uri mmsUri = null;

        if (downloadedByPlatform) {
            final int resultCode = actionParameters.getInt(KEY_RESULT_CODE);
            if (resultCode == Activity.RESULT_OK) {
                final Uri contentUri = actionParameters.getParcelable(KEY_CONTENT_URI);
                final File downloadedFile = MmsFileProvider.getFile(contentUri);
                byte[] downloadedData = null;
                try {
                    downloadedData = Files.toByteArray(downloadedFile);
                } catch (final FileNotFoundException e) {
                    LogUtil.e(TAG, "ProcessDownloadedMmsAction: MMS download file not found: "
                            + downloadedFile.getAbsolutePath());
                } catch (final IOException e) {
                    LogUtil.e(TAG, "ProcessDownloadedMmsAction: Error reading MMS download file: "
                            + downloadedFile.getAbsolutePath(), e);
                }

                // Can delete the temp file now
                if (downloadedFile.exists()) {
                    downloadedFile.delete();
                    if (LogUtil.isLoggable(TAG, LogUtil.DEBUG)) {
                        LogUtil.d(TAG, "ProcessDownloadedMmsAction: Deleted temp file with "
                                + "downloaded MMS pdu: " + downloadedFile.getAbsolutePath());
                    }
                }

                if (downloadedData != null) {
                    final RetrieveConf retrieveConf =
                            MmsSender.parseRetrieveConf(downloadedData, subId);
                    if (MmsUtils.isDumpMmsEnabled()) {
                        MmsUtils.dumpPdu(downloadedData, retrieveConf);
                    }
                    if (retrieveConf != null) {
                        // Insert the downloaded MMS into telephony
                        final Uri notificationUri = actionParameters.getParcelable(
                                KEY_NOTIFICATION_URI);
                        final String subPhoneNumber = actionParameters.getString(
                                KEY_SUB_PHONE_NUMBER);
                        final boolean autoDownload = actionParameters.getBoolean(
                                KEY_AUTO_DOWNLOAD);
                        final long receivedTimestampInSeconds =
                                actionParameters.getLong(KEY_RECEIVED_TIMESTAMP);
                        final long expiry = actionParameters.getLong(KEY_EXPIRY);

                        // Inform sync we're adding a message to telephony
                        final SyncManager syncManager = DataModel.get().getSyncManager();
                        syncManager.onNewMessageInserted(receivedTimestampInSeconds * 1000L);

                        final MmsUtils.StatusPlusUri result =
                                MmsUtils.insertDownloadedMessageAndSendResponse(context,
                                        notificationUri, subId, subPhoneNumber, transactionId,
                                        contentLocation, autoDownload, receivedTimestampInSeconds,
                                        expiry, retrieveConf);
                        status = result.status;
                        rawStatus = result.rawStatus;
                        mmsUri = result.uri;
                    } else {
                        // Invalid response PDU
                        status = MmsUtils.MMS_REQUEST_MANUAL_RETRY;
                    }
                } else {
                    // Failed to read download file
                    status = MmsUtils.MMS_REQUEST_MANUAL_RETRY;
                }
            } else {
                LogUtil.w(TAG, "ProcessDownloadedMmsAction: Platform returned error resultCode: "
                        + resultCode);
                final int httpStatusCode = actionParameters.getInt(KEY_HTTP_STATUS_CODE);
                status = MmsSender.getErrorResultStatus(resultCode, httpStatusCode);
            }
        } else {
            // Message was already processed by the internal API, or the download action failed.
            // In either case, we just need to copy the status to the response bundle.
            status = actionParameters.getInt(KEY_STATUS);
            rawStatus = actionParameters.getInt(KEY_RAW_STATUS);
            mmsUri = actionParameters.getParcelable(KEY_MMS_URI);
        }

        final Bundle response = new Bundle();
        response.putInt(BUNDLE_REQUEST_STATUS, status);
        response.putInt(BUNDLE_RAW_TELEPHONY_STATUS, rawStatus);
        response.putParcelable(BUNDLE_MMS_URI, mmsUri);
        return response;
    }

    @Override
    protected Object processBackgroundResponse(final Bundle response) {
        if (response == null) {
            // No message download to process; doBackgroundWork sent a notify deferred response
            Assert.isTrue(actionParameters.getBoolean(KEY_SEND_DEFERRED_RESP_STATUS));
            ProcessPendingMessagesAction.scheduleProcessPendingMessagesAction(
                    true /* failed */, this);
            return null;
        }

        final int status = response.getInt(BUNDLE_REQUEST_STATUS);
        final int rawStatus = response.getInt(BUNDLE_RAW_TELEPHONY_STATUS);
        final Uri messageUri = response.getParcelable(BUNDLE_MMS_URI);
        final boolean autoDownload = actionParameters.getBoolean(KEY_AUTO_DOWNLOAD);
        final String messageId = actionParameters.getString(KEY_MESSAGE_ID);

        // Do post-processing on downloaded message
        final MessageData message = processResult(status, rawStatus, messageUri);

        final int subId = actionParameters.getInt(KEY_SUB_ID, ParticipantData.DEFAULT_SELF_SUB_ID);
        // If we were trying to auto-download but have failed need to send the deferred response
        final boolean needToSendDeferredResp =
                autoDownload && (status == MmsUtils.MMS_REQUEST_MANUAL_RETRY);
        if (needToSendDeferredResp) {
            final String transactionId = actionParameters.getString(KEY_TRANSACTION_ID);
            final String contentLocation = actionParameters.getString(KEY_CONTENT_LOCATION);
            sendDeferredRespStatus(messageId, transactionId, contentLocation, subId);
        }

        if (autoDownload) {
            final DatabaseWrapper db = DataModel.get().getDatabase();
            MessageData toastMessage = message;
            if (toastMessage == null) {
                // If the downloaded failed (message is null), then we should announce the
                // receiving of the wap push message. Load the wap push message here instead.
                toastMessage = BugleDatabaseOperations.readMessageData(db, messageId);
            }
            if (toastMessage != null) {
                final ParticipantData sender = ParticipantData.getFromId(
                        db, toastMessage.getParticipantId());
                BugleActionToasts.onMessageReceived(
                        toastMessage.getConversationId(), sender, toastMessage);
            }
        } else {
            final boolean success = message != null && status == MmsUtils.MMS_REQUEST_SUCCEEDED;
            BugleActionToasts.onSendMessageOrManualDownloadActionCompleted(
                    // If download failed, use the wap push message's conversation instead
                    success ? message.getConversationId()
                            : actionParameters.getString(KEY_CONVERSATION_ID),
                    success, status, false/*isSms*/, subId, false /*isSend*/);
        }

        final boolean failed = (messageUri == null);
        // Scheduling pending messages. If auto downloading is failed and it needs to send the
        // deferred response, Skip it here and it will be scheduled after sending the response.
        if (!needToSendDeferredResp) {
            ProcessPendingMessagesAction.scheduleProcessPendingMessagesAction(failed, this);
        }
        if (failed) {
            BugleNotifications.update(false, BugleNotifications.UPDATE_ERRORS);
        }

        return message;
    }

    @Override
    protected Object processBackgroundFailure() {
        if (actionParameters.getBoolean(KEY_SEND_DEFERRED_RESP_STATUS)) {
            // We can early-out for these failures. processResult is only designed to handle
            // post-processing of MMS downloads (whether successful or not).
            LogUtil.w(TAG,
                    "ProcessDownloadedMmsAction: Exception while sending deferred NotifyRespInd");
            return null;
        }

        // Background worker threw an exception; require manual retry
        processResult(MmsUtils.MMS_REQUEST_MANUAL_RETRY, MessageData.RAW_TELEPHONY_STATUS_UNDEFINED,
                null /* mmsUri */);

        ProcessPendingMessagesAction.scheduleProcessPendingMessagesAction(true /* failed */,
                this);

        return null;
    }

    private MessageData processResult(final int status, final int rawStatus, final Uri mmsUri) {
        final Context context = Factory.get().getApplicationContext();
        final String messageId = actionParameters.getString(KEY_MESSAGE_ID);
        final Uri mmsNotificationUri = actionParameters.getParcelable(KEY_NOTIFICATION_URI);
        final String notificationConversationId = actionParameters.getString(KEY_CONVERSATION_ID);
        final String notificationParticipantId = actionParameters.getString(KEY_PARTICIPANT_ID);
        final int statusIfFailed = actionParameters.getInt(KEY_STATUS_IF_FAILED);
        final int subId = actionParameters.getInt(KEY_SUB_ID, ParticipantData.DEFAULT_SELF_SUB_ID);

        Assert.notNull(messageId);

        LogUtil.i(TAG, "ProcessDownloadedMmsAction: Processed MMS download of message " + messageId
                + "; status is " + MmsUtils.getRequestStatusDescription(status));

        DatabaseMessages.MmsMessage mms = null;
        if (status == MmsUtils.MMS_REQUEST_SUCCEEDED && mmsUri != null) {
            // Delete the initial M-Notification.ind from telephony
            SqliteWrapper.delete(context, context.getContentResolver(),
                    mmsNotificationUri, null, null);

            // Read the sent MMS from the telephony provider
            mms = MmsUtils.loadMms(mmsUri);
        }

        boolean messageInFocusedConversation = false;
        boolean messageInObservableConversation = false;
        String conversationId = null;
        MessageData message = null;
        final DatabaseWrapper db = DataModel.get().getDatabase();
        db.beginTransaction();
        try {
            if (mms != null) {
                final ParticipantData self = ParticipantData.getSelfParticipant(mms.getSubId());
                final String selfId =
                        BugleDatabaseOperations.getOrCreateParticipantInTransaction(db, self);

                final List<String> recipients = MmsUtils.getRecipientsByThread(mms.mThreadId);
                String from = MmsUtils.getMmsSender(recipients, mms.getUri());
                if (from == null) {
                    LogUtil.w(TAG,
                            "Downloaded an MMS without sender address; using unknown sender.");
                    from = ParticipantData.getUnknownSenderDestination();
                }
                final ParticipantData sender = ParticipantData.getFromRawPhoneBySimLocale(from,
                        subId);
                final String senderParticipantId =
                        BugleDatabaseOperations.getOrCreateParticipantInTransaction(db, sender);
                if (!senderParticipantId.equals(notificationParticipantId)) {
                    LogUtil.e(TAG, "ProcessDownloadedMmsAction: Downloaded MMS message "
                            + messageId + " has different sender (participantId = "
                            + senderParticipantId + ") than notification ("
                            + notificationParticipantId + ")");
                }
                final boolean blockedSender = BugleDatabaseOperations.isBlockedDestination(
                        db, sender.getNormalizedDestination());
                conversationId = BugleDatabaseOperations.getOrCreateConversationFromThreadId(db,
                        mms.mThreadId, blockedSender, subId);

                messageInFocusedConversation =
                        DataModel.get().isFocusedConversation(conversationId);
                messageInObservableConversation =
                        DataModel.get().isNewMessageObservable(conversationId);

                // TODO: Also write these values to the telephony provider
                mms.mRead = messageInFocusedConversation;
                mms.mSeen = messageInObservableConversation;

                // Translate to our format
                message = MmsUtils.createMmsMessage(mms, conversationId, senderParticipantId,
                        selfId, MessageData.BUGLE_STATUS_INCOMING_COMPLETE);
                // Update image sizes.
                message.updateSizesForImageParts();
                // Inform sync that message has been added at local received timestamp
                final SyncManager syncManager = DataModel.get().getSyncManager();
                syncManager.onNewMessageInserted(message.getReceivedTimeStamp());
                final MessageData current = BugleDatabaseOperations.readMessageData(db, messageId);
                if (current == null) {
                    LogUtil.w(TAG, "Message deleted prior to update");
                    BugleDatabaseOperations.insertNewMessageInTransaction(db, message);
                } else {
                    // Overwrite existing notification message
                    message.updateMessageId(messageId);
                    // Write message
                    BugleDatabaseOperations.updateMessageInTransaction(db, message);
                }

                if (!TextUtils.equals(notificationConversationId, conversationId)) {
                    // If this is a group conversation, the message is moved. So the original
                    // 1v1 conversation (as referenced by notificationConversationId) could
                    // be left with no non-draft message. Delete the conversation if that
                    // happens. See the comment for the method below for why we need to do this.
                    if (!BugleDatabaseOperations.deleteConversationIfEmptyInTransaction(
                            db, notificationConversationId)) {
                        BugleDatabaseOperations.maybeRefreshConversationMetadataInTransaction(
                                db, notificationConversationId, messageId,
                                true /*shouldAutoSwitchSelfId*/, blockedSender /*keepArchived*/);
                    }
                }

                BugleDatabaseOperations.refreshConversationMetadataInTransaction(db, conversationId,
                        true /*shouldAutoSwitchSelfId*/, blockedSender /*keepArchived*/);
            } else {
                messageInFocusedConversation =
                        DataModel.get().isFocusedConversation(notificationConversationId);

                // Default to retry status unless status indicates otherwise
                int bugleStatus = statusIfFailed;
                if (status == MmsUtils.MMS_REQUEST_MANUAL_RETRY) {
                    bugleStatus = MessageData.BUGLE_STATUS_INCOMING_DOWNLOAD_FAILED;
                } else if (status == MmsUtils.MMS_REQUEST_NO_RETRY) {
                    bugleStatus = MessageData.BUGLE_STATUS_INCOMING_EXPIRED_OR_NOT_AVAILABLE;
                }
                DownloadMmsAction.updateMessageStatus(mmsNotificationUri, messageId,
                        notificationConversationId, bugleStatus, rawStatus);

                // Log MMS download failed
                final int resultCode = actionParameters.getInt(KEY_RESULT_CODE);
                final int httpStatusCode = actionParameters.getInt(KEY_HTTP_STATUS_CODE);

                // Just in case this was the latest message update the summary data
                BugleDatabaseOperations.refreshConversationMetadataInTransaction(db,
                        notificationConversationId, true /*shouldAutoSwitchSelfId*/,
                        false /*keepArchived*/);
            }

            db.setTransactionSuccessful();
        } finally {
            db.endTransaction();
        }

        if (mmsUri != null) {
            // Update mms table with read status now we know the conversation id
            final ContentValues values = new ContentValues(1);
            values.put(Mms.READ, messageInFocusedConversation);
            SqliteWrapper.update(context, context.getContentResolver(), mmsUri, values,
                    null, null);
        }

        // Show a notification to let the user know a new message has arrived
        BugleNotifications.update(false /*silent*/, conversationId, BugleNotifications.UPDATE_ALL);

        // Messages may have changed in two conversations
        if (conversationId != null) {
            MessagingContentProvider.notifyMessagesChanged(conversationId);
        }
        MessagingContentProvider.notifyMessagesChanged(notificationConversationId);
        MessagingContentProvider.notifyPartsChanged();

        return message;
    }

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

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

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

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