src/com/android/messaging/datamodel/action/InsertNewMessageAction.java - platform/packages/apps/Messaging - Gitiles

 /*
  * 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.net.Uri;
 import android.os.Parcel;
 import android.os.Parcelable;
 import android.provider.Telephony;
 import android.text.TextUtils;

 import com.android.messaging.Factory;
 import com.android.messaging.datamodel.BugleDatabaseOperations;
 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.data.ConversationListItemData;
 import com.android.messaging.datamodel.data.MessageData;
 import com.android.messaging.datamodel.data.MessagePartData;
 import com.android.messaging.datamodel.data.ParticipantData;
 import com.android.messaging.sms.MmsUtils;
 import com.android.messaging.util.Assert;
 import com.android.messaging.util.LogUtil;
 import com.android.messaging.util.OsUtil;
 import com.android.messaging.util.PhoneUtils;

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

 /**
  * Action used to convert a draft message to an outgoing message. Its writes SMS messages to
  * the telephony db, but {@link SendMessageAction} is responsible for inserting MMS message into
  * the telephony DB. The latter also does the actual sending of the message in the background.
  * The latter is also responsible for re-sending a failed message.
  */
 public class InsertNewMessageAction extends Action implements Parcelable {
     private static final String TAG = LogUtil.BUGLE_DATAMODEL_TAG;

     private static long sLastSentMessageTimestamp = -1;

     /**
      * Insert message (no listener)
      */
     public static void insertNewMessage(final MessageData message) {
         final InsertNewMessageAction action = new InsertNewMessageAction(message);
         action.start();
     }

     /**
      * Insert message (no listener) with a given non-default subId.
      */
     public static void insertNewMessage(final MessageData message, final int subId) {
         Assert.isFalse(subId == ParticipantData.DEFAULT_SELF_SUB_ID);
         final InsertNewMessageAction action = new InsertNewMessageAction(message, subId);
         action.start();
     }

     /**
      * Insert message (no listener)
      */
     public static void insertNewMessage(final int subId, final String recipients,
             final String messageText, final String subject) {
         final InsertNewMessageAction action = new InsertNewMessageAction(
                 subId, recipients, messageText, subject);
         action.start();
     }

     public static long getLastSentMessageTimestamp() {
         return sLastSentMessageTimestamp;
     }

     private static final String KEY_SUB_ID = "sub_id";
     private static final String KEY_MESSAGE = "message";
     private static final String KEY_RECIPIENTS = "recipients";
     private static final String KEY_MESSAGE_TEXT = "message_text";
     private static final String KEY_SUBJECT_TEXT = "subject_text";

     private InsertNewMessageAction(final MessageData message) {
         this(message, ParticipantData.DEFAULT_SELF_SUB_ID);
         actionParameters.putParcelable(KEY_MESSAGE, message);
     }

     private InsertNewMessageAction(final MessageData message, final int subId) {
         super();
         actionParameters.putParcelable(KEY_MESSAGE, message);
         actionParameters.putInt(KEY_SUB_ID, subId);
     }

     private InsertNewMessageAction(final int subId, final String recipients,
             final String messageText, final String subject) {
         super();
         if (TextUtils.isEmpty(recipients) || TextUtils.isEmpty(messageText)) {
             Assert.fail("InsertNewMessageAction: Can't have empty recipients or message");
         }
         actionParameters.putInt(KEY_SUB_ID, subId);
         actionParameters.putString(KEY_RECIPIENTS, recipients);
         actionParameters.putString(KEY_MESSAGE_TEXT, messageText);
         actionParameters.putString(KEY_SUBJECT_TEXT, subject);
     }

     /**
      * Add message to database in pending state and queue actual sending
      */
     @Override
     protected Object executeAction() {
         LogUtil.i(TAG, "InsertNewMessageAction: inserting new message");
         MessageData message = actionParameters.getParcelable(KEY_MESSAGE);
         if (message == null) {
             LogUtil.i(TAG, "InsertNewMessageAction: Creating MessageData with provided data");
             message = createMessage();
             if (message == null) {
                 LogUtil.w(TAG, "InsertNewMessageAction: Could not create MessageData");
                 return null;
             }
         }
         final DatabaseWrapper db = DataModel.get().getDatabase();
         final String conversationId = message.getConversationId();

         final ParticipantData self = getSelf(db, conversationId, message);
         if (self == null) {
             return null;
         }
         message.bindSelfId(self.getId());
         // If the user taps the Send button before the conversation draft is created/loaded by
         // ReadDraftDataAction (maybe the action service thread was busy), the MessageData may not
         // have the participant id set. It should be equal to the self id, so we'll use that.
         if (message.getParticipantId() == null) {
             message.bindParticipantId(self.getId());
         }

         final long timestamp = System.currentTimeMillis();
         final ArrayList<String> recipients =
                 BugleDatabaseOperations.getRecipientsForConversation(db, conversationId);
         if (recipients.size() < 1) {
             LogUtil.w(TAG, "InsertNewMessageAction: message recipients is empty");
             return null;
         }
         final int subId = self.getSubId();

         // TODO: Work out whether to send with SMS or MMS (taking into account recipients)?
         final boolean isSms = (message.getProtocol() == MessageData.PROTOCOL_SMS);
         if (isSms) {
             String sendingConversationId = conversationId;
             if (recipients.size() > 1) {
                 // Broadcast SMS - put message in "fake conversation" before farming out to real 1:1
                 final long laterTimestamp = timestamp + 1;
                 // Send a single message
                 insertBroadcastSmsMessage(conversationId, message, subId,
                         laterTimestamp, recipients);

                 sendingConversationId = null;
             }

             for (final String recipient : recipients) {
                 // Start actual sending
                 insertSendingSmsMessage(message, subId, recipient,
                         timestamp, sendingConversationId);
             }

             // Can now clear draft from conversation (deleting attachments if necessary)
             BugleDatabaseOperations.updateDraftMessageData(db, conversationId,
                     null /* message */, BugleDatabaseOperations.UPDATE_MODE_CLEAR_DRAFT);
         } else {
             final long timestampRoundedToSecond = 1000 * ((timestamp + 500) / 1000);
             // Write place holder message directly referencing parts from the draft
             final MessageData messageToSend = insertSendingMmsMessage(conversationId,
                     message, timestampRoundedToSecond);

             // Can now clear draft from conversation (preserving attachments which are now
             // referenced by messageToSend)
             BugleDatabaseOperations.updateDraftMessageData(db, conversationId,
                     messageToSend, BugleDatabaseOperations.UPDATE_MODE_CLEAR_DRAFT);
         }
         MessagingContentProvider.notifyConversationListChanged();
         ProcessPendingMessagesAction.scheduleProcessPendingMessagesAction(false, this);

         return message;
     }

     private ParticipantData getSelf(
             final DatabaseWrapper db, final String conversationId, final MessageData message) {
         ParticipantData self;
         // Check if we are asked to bind to a non-default subId. This is directly passed in from
         // the UI thread so that the sub id may be locked as soon as the user clicks on the Send
         // button.
         final int requestedSubId = actionParameters.getInt(
                 KEY_SUB_ID, ParticipantData.DEFAULT_SELF_SUB_ID);
         if (requestedSubId != ParticipantData.DEFAULT_SELF_SUB_ID) {
             self = BugleDatabaseOperations.getOrCreateSelf(db, requestedSubId);
         } else {
             String selfId = message.getSelfId();
             if (selfId == null) {
                 // The conversation draft provides no self id hint, meaning that 1) conversation
                 // self id was not loaded AND 2) the user didn't pick a SIM from the SIM selector.
                 // In this case, use the conversation's self id.
                 final ConversationListItemData conversation =
                         ConversationListItemData.getExistingConversation(db, conversationId);
                 if (conversation != null) {
                     selfId = conversation.getSelfId();
                 } else {
                     LogUtil.w(LogUtil.BUGLE_DATAMODEL_TAG, "Conversation " + conversationId +
                             "already deleted before sending draft message " +
                             message.getMessageId() + ". Aborting InsertNewMessageAction.");
                     return null;
                 }
             }

             // We do not use SubscriptionManager.DEFAULT_SUB_ID for sending a message, so we need
             // to bind the message to the system default subscription if it's unbound.
             final ParticipantData unboundSelf = BugleDatabaseOperations.getExistingParticipant(
                     db, selfId);
             if (unboundSelf.getSubId() == ParticipantData.DEFAULT_SELF_SUB_ID
                     && OsUtil.isAtLeastL_MR1()) {
                 final int defaultSubId = PhoneUtils.getDefault().getDefaultSmsSubscriptionId();
                 self = BugleDatabaseOperations.getOrCreateSelf(db, defaultSubId);
             } else {
                 self = unboundSelf;
             }
         }
         return self;
     }

     /** Create MessageData using KEY_RECIPIENTS, KEY_MESSAGE_TEXT and KEY_SUBJECT */
     private MessageData createMessage() {
         // First find the thread id for this list of participants.
         final String recipientsList = actionParameters.getString(KEY_RECIPIENTS);
         final String messageText = actionParameters.getString(KEY_MESSAGE_TEXT);
         final String subjectText = actionParameters.getString(KEY_SUBJECT_TEXT);
         final int subId = actionParameters.getInt(
                 KEY_SUB_ID, ParticipantData.DEFAULT_SELF_SUB_ID);

         final ArrayList<ParticipantData> participants = new ArrayList<>();
         for (final String recipient : recipientsList.split(",")) {
             participants.add(ParticipantData.getFromRawPhoneBySimLocale(recipient, subId));
         }
         if (participants.size() == 0) {
             Assert.fail("InsertNewMessage: Empty participants");
             return null;
         }

         final DatabaseWrapper db = DataModel.get().getDatabase();
         BugleDatabaseOperations.sanitizeConversationParticipants(participants);
         final ArrayList<String> recipients =
                 BugleDatabaseOperations.getRecipientsFromConversationParticipants(participants);
         if (recipients.size() == 0) {
             Assert.fail("InsertNewMessage: Empty recipients");
             return null;
         }

         final long threadId = MmsUtils.getOrCreateThreadId(Factory.get().getApplicationContext(),
                 recipients);

         if (threadId < 0) {
             Assert.fail("InsertNewMessage: Couldn't get threadId in SMS db for these recipients: "
                     + recipients.toString());
             // TODO: How do we fail the action?
             return null;
         }

         final String conversationId = BugleDatabaseOperations.getOrCreateConversation(db, threadId,
                 false, participants, false, false, null);

         final ParticipantData self = BugleDatabaseOperations.getOrCreateSelf(db, subId);

         if (TextUtils.isEmpty(subjectText)) {
             return MessageData.createDraftSmsMessage(conversationId, self.getId(), messageText);
         } else {
             return MessageData.createDraftMmsMessage(conversationId, self.getId(), messageText,
                     subjectText);
         }
     }

     private void insertBroadcastSmsMessage(final String conversationId,
             final MessageData message, final int subId, final long laterTimestamp,
             final ArrayList<String> recipients) {
         if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) {
             LogUtil.v(TAG, "InsertNewMessageAction: Inserting broadcast SMS message "
                     + message.getMessageId());
         }
         final Context context = Factory.get().getApplicationContext();
         final DatabaseWrapper db = DataModel.get().getDatabase();

         // Inform sync that message is being added at timestamp
         final SyncManager syncManager = DataModel.get().getSyncManager();
         syncManager.onNewMessageInserted(laterTimestamp);

         final long threadId = BugleDatabaseOperations.getThreadId(db, conversationId);
         final String address = TextUtils.join(" ", recipients);

         final String messageText = message.getMessageText();
         // Insert message into telephony database sms message table
         final Uri messageUri = MmsUtils.insertSmsMessage(context,
                 Telephony.Sms.CONTENT_URI,
                 subId,
                 address,
                 messageText,
                 laterTimestamp,
                 Telephony.Sms.STATUS_COMPLETE,
                 Telephony.Sms.MESSAGE_TYPE_SENT, threadId);
         if (messageUri != null && !TextUtils.isEmpty(messageUri.toString())) {
             db.beginTransaction();
             try {
                 message.updateSendingMessage(conversationId, messageUri, laterTimestamp);
                 message.markMessageSent(laterTimestamp);

                 BugleDatabaseOperations.insertNewMessageInTransaction(db, message);

                 BugleDatabaseOperations.updateConversationMetadataInTransaction(db,
                         conversationId, message.getMessageId(), laterTimestamp,
                         false /* senderBlocked */, false /* shouldAutoSwitchSelfId */);
                 db.setTransactionSuccessful();
             } finally {
                 db.endTransaction();
             }

             if (LogUtil.isLoggable(TAG, LogUtil.DEBUG)) {
                 LogUtil.d(TAG, "InsertNewMessageAction: Inserted broadcast SMS message "
                         + message.getMessageId() + ", uri = " + message.getSmsMessageUri());
             }
             MessagingContentProvider.notifyMessagesChanged(conversationId);
             MessagingContentProvider.notifyPartsChanged();
         } else {
             // Ignore error as we only really care about the individual messages?
             LogUtil.e(TAG,
                     "InsertNewMessageAction: No uri for broadcast SMS " + message.getMessageId()
                     + " inserted into telephony DB");
         }
     }

     /**
      * Insert SMS messaging into our database and telephony db.
      */
     private MessageData insertSendingSmsMessage(final MessageData content, final int subId,
             final String recipient, final long timestamp, final String sendingConversationId) {
         sLastSentMessageTimestamp = timestamp;

         final Context context = Factory.get().getApplicationContext();

         // Inform sync that message is being added at timestamp
         final SyncManager syncManager = DataModel.get().getSyncManager();
         syncManager.onNewMessageInserted(timestamp);

         final DatabaseWrapper db = DataModel.get().getDatabase();

         // Send a single message
         long threadId;
         String conversationId;
         if (sendingConversationId == null) {
             // For 1:1 message generated sending broadcast need to look up threadId+conversationId
             threadId = MmsUtils.getOrCreateSmsThreadId(context, recipient);
             conversationId = BugleDatabaseOperations.getOrCreateConversationFromRecipient(
                     db, threadId, false /* sender blocked */,
                     ParticipantData.getFromRawPhoneBySimLocale(recipient, subId));
         } else {
             // Otherwise just look up threadId
             threadId = BugleDatabaseOperations.getThreadId(db, sendingConversationId);
             conversationId = sendingConversationId;
         }

         final String messageText = content.getMessageText();

         // Insert message into telephony database sms message table
         final Uri messageUri = MmsUtils.insertSmsMessage(context,
                 Telephony.Sms.CONTENT_URI,
                 subId,
                 recipient,
                 messageText,
                 timestamp,
                 Telephony.Sms.STATUS_NONE,
                 Telephony.Sms.MESSAGE_TYPE_SENT, threadId);

         MessageData message = null;
         if (messageUri != null && !TextUtils.isEmpty(messageUri.toString())) {
             db.beginTransaction();
             try {
                 message = MessageData.createDraftSmsMessage(conversationId,
                         content.getSelfId(), messageText);
                 message.updateSendingMessage(conversationId, messageUri, timestamp);

                 BugleDatabaseOperations.insertNewMessageInTransaction(db, message);

                 // Do not update the conversation summary to reflect autogenerated 1:1 messages
                 if (sendingConversationId != null) {
                     BugleDatabaseOperations.updateConversationMetadataInTransaction(db,
                             conversationId, message.getMessageId(), timestamp,
                             false /* senderBlocked */, false /* shouldAutoSwitchSelfId */);
                 }
                 db.setTransactionSuccessful();
             } finally {
                 db.endTransaction();
             }

             if (LogUtil.isLoggable(TAG, LogUtil.DEBUG)) {
                 LogUtil.d(TAG, "InsertNewMessageAction: Inserted SMS message "
                         + message.getMessageId() + " (uri = " + message.getSmsMessageUri()
                         + ", timestamp = " + message.getReceivedTimeStamp() + ")");
             }
             MessagingContentProvider.notifyMessagesChanged(conversationId);
             MessagingContentProvider.notifyPartsChanged();
         } else {
             LogUtil.e(TAG, "InsertNewMessageAction: No uri for SMS inserted into telephony DB");
         }

         return message;
     }

     /**
      * Insert MMS messaging into our database.
      */
     private MessageData insertSendingMmsMessage(final String conversationId,
             final MessageData message, final long timestamp) {
         final DatabaseWrapper db = DataModel.get().getDatabase();
         db.beginTransaction();
         final List<MessagePartData> attachmentsUpdated = new ArrayList<>();
         try {
             sLastSentMessageTimestamp = timestamp;

             // Insert "draft" message as placeholder until the final message is written to
             // the telephony db
             message.updateSendingMessage(conversationId, null/*messageUri*/, timestamp);

             // No need to inform SyncManager as message currently has no Uri...
             BugleDatabaseOperations.insertNewMessageInTransaction(db, message);

             BugleDatabaseOperations.updateConversationMetadataInTransaction(db,
                     conversationId, message.getMessageId(), timestamp,
                     false /* senderBlocked */, false /* shouldAutoSwitchSelfId */);

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

         if (LogUtil.isLoggable(TAG, LogUtil.DEBUG)) {
             LogUtil.d(TAG, "InsertNewMessageAction: Inserted MMS message "
                     + message.getMessageId() + " (timestamp = " + timestamp + ")");
         }
         MessagingContentProvider.notifyMessagesChanged(conversationId);
         MessagingContentProvider.notifyPartsChanged();

         return message;
     }

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

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

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

     @Override
     public void writeToParcel(final Parcel parcel, final int flags) {
         writeActionToParcel(parcel, flags);
     }
 }
	/*
	* 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.net.Uri;
	import android.os.Parcel;
	import android.os.Parcelable;
	import android.provider.Telephony;
	import android.text.TextUtils;

	import com.android.messaging.Factory;
	import com.android.messaging.datamodel.BugleDatabaseOperations;
	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.data.ConversationListItemData;
	import com.android.messaging.datamodel.data.MessageData;
	import com.android.messaging.datamodel.data.MessagePartData;
	import com.android.messaging.datamodel.data.ParticipantData;
	import com.android.messaging.sms.MmsUtils;
	import com.android.messaging.util.Assert;
	import com.android.messaging.util.LogUtil;
	import com.android.messaging.util.OsUtil;
	import com.android.messaging.util.PhoneUtils;

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

	/**
	* Action used to convert a draft message to an outgoing message. Its writes SMS messages to
	* the telephony db, but {@link SendMessageAction} is responsible for inserting MMS message into
	* the telephony DB. The latter also does the actual sending of the message in the background.
	* The latter is also responsible for re-sending a failed message.
	*/
	public class InsertNewMessageAction extends Action implements Parcelable {
	private static final String TAG = LogUtil.BUGLE_DATAMODEL_TAG;

	private static long sLastSentMessageTimestamp = -1;

	/**
	* Insert message (no listener)
	*/
	public static void insertNewMessage(final MessageData message) {
	final InsertNewMessageAction action = new InsertNewMessageAction(message);
	action.start();
	}

	/**
	* Insert message (no listener) with a given non-default subId.
	*/
	public static void insertNewMessage(final MessageData message, final int subId) {
	Assert.isFalse(subId == ParticipantData.DEFAULT_SELF_SUB_ID);
	final InsertNewMessageAction action = new InsertNewMessageAction(message, subId);
	action.start();
	}

	/**
	* Insert message (no listener)
	*/
	public static void insertNewMessage(final int subId, final String recipients,
	final String messageText, final String subject) {
	final InsertNewMessageAction action = new InsertNewMessageAction(
	subId, recipients, messageText, subject);
	action.start();
	}

	public static long getLastSentMessageTimestamp() {
	return sLastSentMessageTimestamp;
	}

	private static final String KEY_SUB_ID = "sub_id";
	private static final String KEY_MESSAGE = "message";
	private static final String KEY_RECIPIENTS = "recipients";
	private static final String KEY_MESSAGE_TEXT = "message_text";
	private static final String KEY_SUBJECT_TEXT = "subject_text";

	private InsertNewMessageAction(final MessageData message) {
	this(message, ParticipantData.DEFAULT_SELF_SUB_ID);
	actionParameters.putParcelable(KEY_MESSAGE, message);
	}

	private InsertNewMessageAction(final MessageData message, final int subId) {
	super();
	actionParameters.putParcelable(KEY_MESSAGE, message);
	actionParameters.putInt(KEY_SUB_ID, subId);
	}

	private InsertNewMessageAction(final int subId, final String recipients,
	final String messageText, final String subject) {
	super();
	if (TextUtils.isEmpty(recipients) \|\| TextUtils.isEmpty(messageText)) {
	Assert.fail("InsertNewMessageAction: Can't have empty recipients or message");
	}
	actionParameters.putInt(KEY_SUB_ID, subId);
	actionParameters.putString(KEY_RECIPIENTS, recipients);
	actionParameters.putString(KEY_MESSAGE_TEXT, messageText);
	actionParameters.putString(KEY_SUBJECT_TEXT, subject);
	}

	/**
	* Add message to database in pending state and queue actual sending
	*/
	@Override
	protected Object executeAction() {
	LogUtil.i(TAG, "InsertNewMessageAction: inserting new message");
	MessageData message = actionParameters.getParcelable(KEY_MESSAGE);
	if (message == null) {
	LogUtil.i(TAG, "InsertNewMessageAction: Creating MessageData with provided data");
	message = createMessage();
	if (message == null) {
	LogUtil.w(TAG, "InsertNewMessageAction: Could not create MessageData");
	return null;
	}
	}
	final DatabaseWrapper db = DataModel.get().getDatabase();
	final String conversationId = message.getConversationId();

	final ParticipantData self = getSelf(db, conversationId, message);
	if (self == null) {
	return null;
	}
	message.bindSelfId(self.getId());
	// If the user taps the Send button before the conversation draft is created/loaded by
	// ReadDraftDataAction (maybe the action service thread was busy), the MessageData may not
	// have the participant id set. It should be equal to the self id, so we'll use that.
	if (message.getParticipantId() == null) {
	message.bindParticipantId(self.getId());
	}

	final long timestamp = System.currentTimeMillis();
	final ArrayList<String> recipients =
	BugleDatabaseOperations.getRecipientsForConversation(db, conversationId);
	if (recipients.size() < 1) {
	LogUtil.w(TAG, "InsertNewMessageAction: message recipients is empty");
	return null;
	}
	final int subId = self.getSubId();

	// TODO: Work out whether to send with SMS or MMS (taking into account recipients)?
	final boolean isSms = (message.getProtocol() == MessageData.PROTOCOL_SMS);
	if (isSms) {
	String sendingConversationId = conversationId;
	if (recipients.size() > 1) {
	// Broadcast SMS - put message in "fake conversation" before farming out to real 1:1
	final long laterTimestamp = timestamp + 1;
	// Send a single message
	insertBroadcastSmsMessage(conversationId, message, subId,
	laterTimestamp, recipients);

	sendingConversationId = null;
	}

	for (final String recipient : recipients) {
	// Start actual sending
	insertSendingSmsMessage(message, subId, recipient,
	timestamp, sendingConversationId);
	}

	// Can now clear draft from conversation (deleting attachments if necessary)
	BugleDatabaseOperations.updateDraftMessageData(db, conversationId,
	null /* message */, BugleDatabaseOperations.UPDATE_MODE_CLEAR_DRAFT);
	} else {
	final long timestampRoundedToSecond = 1000 * ((timestamp + 500) / 1000);
	// Write place holder message directly referencing parts from the draft
	final MessageData messageToSend = insertSendingMmsMessage(conversationId,
	message, timestampRoundedToSecond);

	// Can now clear draft from conversation (preserving attachments which are now
	// referenced by messageToSend)
	BugleDatabaseOperations.updateDraftMessageData(db, conversationId,
	messageToSend, BugleDatabaseOperations.UPDATE_MODE_CLEAR_DRAFT);
	}
	MessagingContentProvider.notifyConversationListChanged();
	ProcessPendingMessagesAction.scheduleProcessPendingMessagesAction(false, this);

	return message;
	}

	private ParticipantData getSelf(
	final DatabaseWrapper db, final String conversationId, final MessageData message) {
	ParticipantData self;
	// Check if we are asked to bind to a non-default subId. This is directly passed in from
	// the UI thread so that the sub id may be locked as soon as the user clicks on the Send
	// button.
	final int requestedSubId = actionParameters.getInt(
	KEY_SUB_ID, ParticipantData.DEFAULT_SELF_SUB_ID);
	if (requestedSubId != ParticipantData.DEFAULT_SELF_SUB_ID) {
	self = BugleDatabaseOperations.getOrCreateSelf(db, requestedSubId);
	} else {
	String selfId = message.getSelfId();
	if (selfId == null) {
	// The conversation draft provides no self id hint, meaning that 1) conversation
	// self id was not loaded AND 2) the user didn't pick a SIM from the SIM selector.
	// In this case, use the conversation's self id.
	final ConversationListItemData conversation =
	ConversationListItemData.getExistingConversation(db, conversationId);
	if (conversation != null) {
	selfId = conversation.getSelfId();
	} else {
	LogUtil.w(LogUtil.BUGLE_DATAMODEL_TAG, "Conversation " + conversationId +
	"already deleted before sending draft message " +
	message.getMessageId() + ". Aborting InsertNewMessageAction.");
	return null;
	}
	}

	// We do not use SubscriptionManager.DEFAULT_SUB_ID for sending a message, so we need
	// to bind the message to the system default subscription if it's unbound.
	final ParticipantData unboundSelf = BugleDatabaseOperations.getExistingParticipant(
	db, selfId);
	if (unboundSelf.getSubId() == ParticipantData.DEFAULT_SELF_SUB_ID
	&& OsUtil.isAtLeastL_MR1()) {
	final int defaultSubId = PhoneUtils.getDefault().getDefaultSmsSubscriptionId();
	self = BugleDatabaseOperations.getOrCreateSelf(db, defaultSubId);
	} else {
	self = unboundSelf;
	}
	}
	return self;
	}

	/** Create MessageData using KEY_RECIPIENTS, KEY_MESSAGE_TEXT and KEY_SUBJECT */
	private MessageData createMessage() {
	// First find the thread id for this list of participants.
	final String recipientsList = actionParameters.getString(KEY_RECIPIENTS);
	final String messageText = actionParameters.getString(KEY_MESSAGE_TEXT);
	final String subjectText = actionParameters.getString(KEY_SUBJECT_TEXT);
	final int subId = actionParameters.getInt(
	KEY_SUB_ID, ParticipantData.DEFAULT_SELF_SUB_ID);

	final ArrayList<ParticipantData> participants = new ArrayList<>();
	for (final String recipient : recipientsList.split(",")) {
	participants.add(ParticipantData.getFromRawPhoneBySimLocale(recipient, subId));
	}
	if (participants.size() == 0) {
	Assert.fail("InsertNewMessage: Empty participants");
	return null;
	}

	final DatabaseWrapper db = DataModel.get().getDatabase();
	BugleDatabaseOperations.sanitizeConversationParticipants(participants);
	final ArrayList<String> recipients =
	BugleDatabaseOperations.getRecipientsFromConversationParticipants(participants);
	if (recipients.size() == 0) {
	Assert.fail("InsertNewMessage: Empty recipients");
	return null;
	}

	final long threadId = MmsUtils.getOrCreateThreadId(Factory.get().getApplicationContext(),
	recipients);

	if (threadId < 0) {
	Assert.fail("InsertNewMessage: Couldn't get threadId in SMS db for these recipients: "
	+ recipients.toString());
	// TODO: How do we fail the action?
	return null;
	}

	final String conversationId = BugleDatabaseOperations.getOrCreateConversation(db, threadId,
	false, participants, false, false, null);

	final ParticipantData self = BugleDatabaseOperations.getOrCreateSelf(db, subId);

	if (TextUtils.isEmpty(subjectText)) {
	return MessageData.createDraftSmsMessage(conversationId, self.getId(), messageText);
	} else {
	return MessageData.createDraftMmsMessage(conversationId, self.getId(), messageText,
	subjectText);
	}
	}

	private void insertBroadcastSmsMessage(final String conversationId,
	final MessageData message, final int subId, final long laterTimestamp,
	final ArrayList<String> recipients) {
	if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) {
	LogUtil.v(TAG, "InsertNewMessageAction: Inserting broadcast SMS message "
	+ message.getMessageId());
	}
	final Context context = Factory.get().getApplicationContext();
	final DatabaseWrapper db = DataModel.get().getDatabase();

	// Inform sync that message is being added at timestamp
	final SyncManager syncManager = DataModel.get().getSyncManager();
	syncManager.onNewMessageInserted(laterTimestamp);

	final long threadId = BugleDatabaseOperations.getThreadId(db, conversationId);
	final String address = TextUtils.join(" ", recipients);

	final String messageText = message.getMessageText();
	// Insert message into telephony database sms message table
	final Uri messageUri = MmsUtils.insertSmsMessage(context,
	Telephony.Sms.CONTENT_URI,
	subId,
	address,
	messageText,
	laterTimestamp,
	Telephony.Sms.STATUS_COMPLETE,
	Telephony.Sms.MESSAGE_TYPE_SENT, threadId);
	if (messageUri != null && !TextUtils.isEmpty(messageUri.toString())) {
	db.beginTransaction();
	try {
	message.updateSendingMessage(conversationId, messageUri, laterTimestamp);
	message.markMessageSent(laterTimestamp);

	BugleDatabaseOperations.insertNewMessageInTransaction(db, message);

	BugleDatabaseOperations.updateConversationMetadataInTransaction(db,
	conversationId, message.getMessageId(), laterTimestamp,
	false /* senderBlocked /, false / shouldAutoSwitchSelfId */);
	db.setTransactionSuccessful();
	} finally {
	db.endTransaction();
	}

	if (LogUtil.isLoggable(TAG, LogUtil.DEBUG)) {
	LogUtil.d(TAG, "InsertNewMessageAction: Inserted broadcast SMS message "
	+ message.getMessageId() + ", uri = " + message.getSmsMessageUri());
	}
	MessagingContentProvider.notifyMessagesChanged(conversationId);
	MessagingContentProvider.notifyPartsChanged();
	} else {
	// Ignore error as we only really care about the individual messages?
	LogUtil.e(TAG,
	"InsertNewMessageAction: No uri for broadcast SMS " + message.getMessageId()
	+ " inserted into telephony DB");
	}
	}

	/**
	* Insert SMS messaging into our database and telephony db.
	*/
	private MessageData insertSendingSmsMessage(final MessageData content, final int subId,
	final String recipient, final long timestamp, final String sendingConversationId) {
	sLastSentMessageTimestamp = timestamp;

	final Context context = Factory.get().getApplicationContext();

	// Inform sync that message is being added at timestamp
	final SyncManager syncManager = DataModel.get().getSyncManager();
	syncManager.onNewMessageInserted(timestamp);

	final DatabaseWrapper db = DataModel.get().getDatabase();

	// Send a single message
	long threadId;
	String conversationId;
	if (sendingConversationId == null) {
	// For 1:1 message generated sending broadcast need to look up threadId+conversationId
	threadId = MmsUtils.getOrCreateSmsThreadId(context, recipient);
	conversationId = BugleDatabaseOperations.getOrCreateConversationFromRecipient(
	db, threadId, false /* sender blocked */,
	ParticipantData.getFromRawPhoneBySimLocale(recipient, subId));
	} else {
	// Otherwise just look up threadId
	threadId = BugleDatabaseOperations.getThreadId(db, sendingConversationId);
	conversationId = sendingConversationId;
	}

	final String messageText = content.getMessageText();

	// Insert message into telephony database sms message table
	final Uri messageUri = MmsUtils.insertSmsMessage(context,
	Telephony.Sms.CONTENT_URI,
	subId,
	recipient,
	messageText,
	timestamp,
	Telephony.Sms.STATUS_NONE,
	Telephony.Sms.MESSAGE_TYPE_SENT, threadId);

	MessageData message = null;
	if (messageUri != null && !TextUtils.isEmpty(messageUri.toString())) {
	db.beginTransaction();
	try {
	message = MessageData.createDraftSmsMessage(conversationId,
	content.getSelfId(), messageText);
	message.updateSendingMessage(conversationId, messageUri, timestamp);

	BugleDatabaseOperations.insertNewMessageInTransaction(db, message);

	// Do not update the conversation summary to reflect autogenerated 1:1 messages
	if (sendingConversationId != null) {
	BugleDatabaseOperations.updateConversationMetadataInTransaction(db,
	conversationId, message.getMessageId(), timestamp,
	false /* senderBlocked /, false / shouldAutoSwitchSelfId */);
	}
	db.setTransactionSuccessful();
	} finally {
	db.endTransaction();
	}

	if (LogUtil.isLoggable(TAG, LogUtil.DEBUG)) {
	LogUtil.d(TAG, "InsertNewMessageAction: Inserted SMS message "
	+ message.getMessageId() + " (uri = " + message.getSmsMessageUri()
	+ ", timestamp = " + message.getReceivedTimeStamp() + ")");
	}
	MessagingContentProvider.notifyMessagesChanged(conversationId);
	MessagingContentProvider.notifyPartsChanged();
	} else {
	LogUtil.e(TAG, "InsertNewMessageAction: No uri for SMS inserted into telephony DB");
	}

	return message;
	}

	/**
	* Insert MMS messaging into our database.
	*/
	private MessageData insertSendingMmsMessage(final String conversationId,
	final MessageData message, final long timestamp) {
	final DatabaseWrapper db = DataModel.get().getDatabase();
	db.beginTransaction();
	final List<MessagePartData> attachmentsUpdated = new ArrayList<>();
	try {
	sLastSentMessageTimestamp = timestamp;

	// Insert "draft" message as placeholder until the final message is written to
	// the telephony db
	message.updateSendingMessage(conversationId, null/messageUri/, timestamp);

	// No need to inform SyncManager as message currently has no Uri...
	BugleDatabaseOperations.insertNewMessageInTransaction(db, message);

	BugleDatabaseOperations.updateConversationMetadataInTransaction(db,
	conversationId, message.getMessageId(), timestamp,
	false /* senderBlocked /, false / shouldAutoSwitchSelfId */);

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

	if (LogUtil.isLoggable(TAG, LogUtil.DEBUG)) {
	LogUtil.d(TAG, "InsertNewMessageAction: Inserted MMS message "
	+ message.getMessageId() + " (timestamp = " + timestamp + ")");
	}
	MessagingContentProvider.notifyMessagesChanged(conversationId);
	MessagingContentProvider.notifyPartsChanged();

	return message;
	}

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

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

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

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