| /* |
| * 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.data; |
| |
| import android.net.Uri; |
| import android.text.TextUtils; |
| |
| import com.android.messaging.datamodel.MessageTextStats; |
| import com.android.messaging.datamodel.action.ReadDraftDataAction; |
| import com.android.messaging.datamodel.action.ReadDraftDataAction.ReadDraftDataActionListener; |
| import com.android.messaging.datamodel.action.ReadDraftDataAction.ReadDraftDataActionMonitor; |
| import com.android.messaging.datamodel.action.WriteDraftMessageAction; |
| import com.android.messaging.datamodel.binding.BindableData; |
| import com.android.messaging.datamodel.binding.Binding; |
| import com.android.messaging.datamodel.binding.BindingBase; |
| import com.android.messaging.sms.MmsConfig; |
| import com.android.messaging.sms.MmsSmsUtils; |
| import com.android.messaging.sms.MmsUtils; |
| import com.android.messaging.util.Assert; |
| import com.android.messaging.util.Assert.DoesNotRunOnMainThread; |
| import com.android.messaging.util.Assert.RunsOnMainThread; |
| import com.android.messaging.util.BugleGservices; |
| import com.android.messaging.util.BugleGservicesKeys; |
| import com.android.messaging.util.LogUtil; |
| import com.android.messaging.util.PhoneUtils; |
| import com.android.messaging.util.SafeAsyncTask; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Set; |
| |
| public class DraftMessageData extends BindableData implements ReadDraftDataActionListener { |
| |
| /** |
| * Interface for DraftMessageData listeners |
| */ |
| public interface DraftMessageDataListener { |
| @RunsOnMainThread |
| void onDraftChanged(DraftMessageData data, int changeFlags); |
| |
| @RunsOnMainThread |
| void onDraftAttachmentLimitReached(DraftMessageData data); |
| |
| @RunsOnMainThread |
| void onDraftAttachmentLoadFailed(); |
| } |
| |
| /** |
| * Interface for providing subscription-related data to DraftMessageData |
| */ |
| public interface DraftMessageSubscriptionDataProvider { |
| int getConversationSelfSubId(); |
| } |
| |
| // Flags sent to onDraftChanged to help the receiver limit the amount of work done |
| public static int ATTACHMENTS_CHANGED = 0x0001; |
| public static int MESSAGE_TEXT_CHANGED = 0x0002; |
| public static int MESSAGE_SUBJECT_CHANGED = 0x0004; |
| // Whether the self participant data has been loaded |
| public static int SELF_CHANGED = 0x0008; |
| public static int ALL_CHANGED = 0x00FF; |
| // ALL_CHANGED intentionally doesn't include WIDGET_CHANGED. ConversationFragment needs to |
| // be notified if the draft it is looking at is changed externally (by a desktop widget) so it |
| // can reload the draft. |
| public static int WIDGET_CHANGED = 0x0100; |
| |
| private final String mConversationId; |
| private ReadDraftDataActionMonitor mMonitor; |
| private final DraftMessageDataEventDispatcher mListeners; |
| private DraftMessageSubscriptionDataProvider mSubscriptionDataProvider; |
| |
| private boolean mIncludeEmailAddress; |
| private boolean mIsGroupConversation; |
| private String mMessageText; |
| private String mMessageSubject; |
| private String mSelfId; |
| private MessageTextStats mMessageTextStats; |
| private boolean mSending; |
| |
| /** Keeps track of completed attachments in the message draft. This data is persisted to db */ |
| private final List<MessagePartData> mAttachments; |
| |
| /** A read-only wrapper on mAttachments surfaced to the UI layer for rendering */ |
| private final List<MessagePartData> mReadOnlyAttachments; |
| |
| /** Keeps track of pending attachments that are being loaded. The pending attachments are |
| * transient, because they are not persisted to the database and are dropped once we go |
| * to the background (after the UI calls saveToStorage) */ |
| private final List<PendingAttachmentData> mPendingAttachments; |
| |
| /** A read-only wrapper on mPendingAttachments surfaced to the UI layer for rendering */ |
| private final List<PendingAttachmentData> mReadOnlyPendingAttachments; |
| |
| /** Is the current draft a cached copy of what's been saved to the database. If so, we |
| * may skip loading from database if we are still bound */ |
| private boolean mIsDraftCachedCopy; |
| |
| /** Whether we are currently asynchronously validating the draft before sending. */ |
| private CheckDraftForSendTask mCheckDraftForSendTask; |
| |
| public DraftMessageData(final String conversationId) { |
| mConversationId = conversationId; |
| mAttachments = new ArrayList<MessagePartData>(); |
| mReadOnlyAttachments = Collections.unmodifiableList(mAttachments); |
| mPendingAttachments = new ArrayList<PendingAttachmentData>(); |
| mReadOnlyPendingAttachments = Collections.unmodifiableList(mPendingAttachments); |
| mListeners = new DraftMessageDataEventDispatcher(); |
| mMessageTextStats = new MessageTextStats(); |
| } |
| |
| public void addListener(final DraftMessageDataListener listener) { |
| mListeners.add(listener); |
| } |
| |
| public void setSubscriptionDataProvider(final DraftMessageSubscriptionDataProvider provider) { |
| mSubscriptionDataProvider = provider; |
| } |
| |
| public void updateFromMessageData(final MessageData message, final String bindingId) { |
| // New attachments have arrived - only update if the user hasn't already edited |
| Assert.notNull(bindingId); |
| // The draft is now synced with actual MessageData and no longer a cached copy. |
| mIsDraftCachedCopy = false; |
| // Do not use the loaded draft if the user began composing a message before the draft loaded |
| // During config changes (orientation), the text fields preserve their data, so allow them |
| // to be the same and still consider the draft unchanged by the user |
| if (isDraftEmpty() || (TextUtils.equals(mMessageText, message.getMessageText()) && |
| TextUtils.equals(mMessageSubject, message.getMmsSubject()) && |
| mAttachments.isEmpty())) { |
| // No need to clear as just checked it was empty or a subset |
| setMessageText(message.getMessageText(), false /* notify */); |
| setMessageSubject(message.getMmsSubject(), false /* notify */); |
| for (final MessagePartData part : message.getParts()) { |
| if (part.isAttachment() && getAttachmentCount() >= getAttachmentLimit()) { |
| dispatchAttachmentLimitReached(); |
| break; |
| } |
| |
| if (part instanceof PendingAttachmentData) { |
| // This is a pending attachment data from share intent (e.g. an shared image |
| // that we need to persist locally). |
| final PendingAttachmentData data = (PendingAttachmentData) part; |
| Assert.equals(PendingAttachmentData.STATE_PENDING, data.getCurrentState()); |
| addOnePendingAttachmentNoNotify(data, bindingId); |
| } else if (part.isAttachment()) { |
| addOneAttachmentNoNotify(part); |
| } |
| } |
| dispatchChanged(ALL_CHANGED); |
| } else { |
| // The user has started a new message so we throw out the draft message data if there |
| // is one but we also loaded the self metadata and need to let our listeners know. |
| dispatchChanged(SELF_CHANGED); |
| } |
| } |
| |
| /** |
| * Create a MessageData object containing a copy of all the parts in this DraftMessageData. |
| * |
| * @param clearLocalCopy whether we should clear out the in-memory copy of the parts. If we |
| * are simply pausing/resuming and not sending the message, then we can keep |
| * @return the MessageData for the draft, null if self id is not set |
| */ |
| public MessageData createMessageWithCurrentAttachments(final boolean clearLocalCopy) { |
| MessageData message = null; |
| if (getIsMms()) { |
| message = MessageData.createDraftMmsMessage(mConversationId, mSelfId, |
| mMessageText, mMessageSubject); |
| for (final MessagePartData attachment : mAttachments) { |
| message.addPart(attachment); |
| } |
| } else { |
| message = MessageData.createDraftSmsMessage(mConversationId, mSelfId, |
| mMessageText); |
| } |
| |
| if (clearLocalCopy) { |
| // The message now owns all the attachments and the text... |
| clearLocalDraftCopy(); |
| dispatchChanged(ALL_CHANGED); |
| } else { |
| // The draft message becomes a cached copy for UI. |
| mIsDraftCachedCopy = true; |
| } |
| return message; |
| } |
| |
| private void clearLocalDraftCopy() { |
| mIsDraftCachedCopy = false; |
| mAttachments.clear(); |
| setMessageText(""); |
| setMessageSubject(""); |
| } |
| |
| public String getConversationId() { |
| return mConversationId; |
| } |
| |
| public String getMessageText() { |
| return mMessageText; |
| } |
| |
| public String getMessageSubject() { |
| return mMessageSubject; |
| } |
| |
| public boolean getIsMms() { |
| final int selfSubId = getSelfSubId(); |
| return MmsSmsUtils.getRequireMmsForEmailAddress(mIncludeEmailAddress, selfSubId) || |
| (mIsGroupConversation && MmsUtils.groupMmsEnabled(selfSubId)) || |
| mMessageTextStats.getMessageLengthRequiresMms() || !mAttachments.isEmpty() || |
| !TextUtils.isEmpty(mMessageSubject); |
| } |
| |
| public boolean getIsGroupMmsConversation() { |
| return getIsMms() && mIsGroupConversation; |
| } |
| |
| public String getSelfId() { |
| return mSelfId; |
| } |
| |
| public int getNumMessagesToBeSent() { |
| return mMessageTextStats.getNumMessagesToBeSent(); |
| } |
| |
| public int getCodePointsRemainingInCurrentMessage() { |
| return mMessageTextStats.getCodePointsRemainingInCurrentMessage(); |
| } |
| |
| public int getSelfSubId() { |
| return mSubscriptionDataProvider == null ? ParticipantData.DEFAULT_SELF_SUB_ID : |
| mSubscriptionDataProvider.getConversationSelfSubId(); |
| } |
| |
| private void setMessageText(final String messageText, final boolean notify) { |
| mMessageText = messageText; |
| mMessageTextStats.updateMessageTextStats(getSelfSubId(), mMessageText); |
| if (notify) { |
| dispatchChanged(MESSAGE_TEXT_CHANGED); |
| } |
| } |
| |
| private void setMessageSubject(final String subject, final boolean notify) { |
| mMessageSubject = subject; |
| if (notify) { |
| dispatchChanged(MESSAGE_SUBJECT_CHANGED); |
| } |
| } |
| |
| public void setMessageText(final String messageText) { |
| setMessageText(messageText, false); |
| } |
| |
| public void setMessageSubject(final String subject) { |
| setMessageSubject(subject, false); |
| } |
| |
| public void addAttachments(final Collection<? extends MessagePartData> attachments) { |
| // If the incoming attachments contains a single-only attachment, we need to clear |
| // the existing attachments. |
| for (final MessagePartData data : attachments) { |
| if (data.isSinglePartOnly()) { |
| // clear any existing attachments because the attachment we're adding can only |
| // exist by itself. |
| destroyAttachments(); |
| break; |
| } |
| } |
| // If the existing attachments contain a single-only attachment, we need to clear the |
| // existing attachments to make room for the incoming attachment. |
| for (final MessagePartData data : mAttachments) { |
| if (data.isSinglePartOnly()) { |
| // clear any existing attachments because the single attachment can only exist |
| // by itself |
| destroyAttachments(); |
| break; |
| } |
| } |
| // If any of the pending attachments contain a single-only attachment, we need to clear the |
| // existing attachments to make room for the incoming attachment. |
| for (final MessagePartData data : mPendingAttachments) { |
| if (data.isSinglePartOnly()) { |
| // clear any existing attachments because the single attachment can only exist |
| // by itself |
| destroyAttachments(); |
| break; |
| } |
| } |
| |
| boolean reachedLimit = false; |
| for (final MessagePartData data : attachments) { |
| // Don't break out of loop even if limit has been reached so we can destroy all |
| // of the over-limit attachments. |
| reachedLimit |= addOneAttachmentNoNotify(data); |
| } |
| if (reachedLimit) { |
| dispatchAttachmentLimitReached(); |
| } |
| dispatchChanged(ATTACHMENTS_CHANGED); |
| } |
| |
| public boolean containsAttachment(final Uri contentUri) { |
| for (final MessagePartData existingAttachment : mAttachments) { |
| if (existingAttachment.getContentUri().equals(contentUri)) { |
| return true; |
| } |
| } |
| |
| for (final PendingAttachmentData pendingAttachment : mPendingAttachments) { |
| if (pendingAttachment.getContentUri().equals(contentUri)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Try to add one attachment to the attachment list, while guarding against duplicates and |
| * going over the limit. |
| * @return true if the attachment limit was reached, false otherwise |
| */ |
| private boolean addOneAttachmentNoNotify(final MessagePartData attachment) { |
| Assert.isTrue(attachment.isAttachment()); |
| // Check duplication. |
| for (final MessagePartData existingAttachment : mAttachments) { |
| if (existingAttachment.getContentUri().equals(attachment.getContentUri())) { |
| // Destroy existing attachment and replace with new attachment instead of destroying |
| // new one so that mSelectedImages in GalleryGridView could be maintained correctly. |
| mAttachments.remove(existingAttachment); |
| existingAttachment.destroyAsync(); |
| addAttachment(attachment, null /*pendingAttachment*/); |
| return false; |
| } |
| } |
| |
| final boolean reachedLimit = getAttachmentCount() >= getAttachmentLimit(); |
| if (reachedLimit) { |
| // Never go over the limit. |
| attachment.destroyAsync(); |
| return true; |
| } else { |
| addAttachment(attachment, null /*pendingAttachment*/); |
| return false; |
| } |
| } |
| |
| private void addAttachment(final MessagePartData attachment, |
| final PendingAttachmentData pendingAttachment) { |
| if (attachment != null && attachment.isSinglePartOnly()) { |
| // clear any existing attachments because the attachment we're adding can only |
| // exist by itself. |
| destroyAttachments(); |
| } |
| if (pendingAttachment != null && pendingAttachment.isSinglePartOnly()) { |
| // clear any existing attachments because the attachment we're adding can only |
| // exist by itself. |
| destroyAttachments(); |
| } |
| // If the existing attachments contain a single-only attachment, we need to clear the |
| // existing attachments to make room for the incoming attachment. |
| for (final MessagePartData data : mAttachments) { |
| if (data.isSinglePartOnly()) { |
| // clear any existing attachments because the single attachment can only exist |
| // by itself |
| destroyAttachments(); |
| break; |
| } |
| } |
| // If any of the pending attachments contain a single-only attachment, we need to clear the |
| // existing attachments to make room for the incoming attachment. |
| for (final MessagePartData data : mPendingAttachments) { |
| if (data.isSinglePartOnly()) { |
| // clear any existing attachments because the single attachment can only exist |
| // by itself |
| destroyAttachments(); |
| break; |
| } |
| } |
| if (attachment != null) { |
| mAttachments.add(attachment); |
| } else if (pendingAttachment != null) { |
| mPendingAttachments.add(pendingAttachment); |
| } |
| } |
| |
| public void addPendingAttachment(final PendingAttachmentData pendingAttachment, |
| final BindingBase<DraftMessageData> binding) { |
| final boolean reachedLimit = addOnePendingAttachmentNoNotify(pendingAttachment, |
| binding.getBindingId()); |
| if (reachedLimit) { |
| dispatchAttachmentLimitReached(); |
| } |
| dispatchChanged(ATTACHMENTS_CHANGED); |
| } |
| |
| /** |
| * Try to add one pending attachment, while guarding against duplicates and |
| * going over the limit. |
| * @return true if the attachment limit was reached, false otherwise |
| */ |
| private boolean addOnePendingAttachmentNoNotify(final PendingAttachmentData pendingAttachment, |
| final String bindingId) { |
| final boolean reachedLimit = getAttachmentCount() >= getAttachmentLimit(); |
| if (reachedLimit || containsAttachment(pendingAttachment.getContentUri())) { |
| // Never go over the limit. Never add duplicated attachments. |
| pendingAttachment.destroyAsync(); |
| return reachedLimit; |
| } else { |
| Assert.isTrue(!mPendingAttachments.contains(pendingAttachment)); |
| Assert.equals(PendingAttachmentData.STATE_PENDING, pendingAttachment.getCurrentState()); |
| addAttachment(null /*attachment*/, pendingAttachment); |
| |
| pendingAttachment.loadAttachmentForDraft(this, bindingId); |
| return false; |
| } |
| } |
| |
| public void setSelfId(final String selfId, final boolean notify) { |
| LogUtil.d(LogUtil.BUGLE_TAG, "DraftMessageData: set selfId=" + selfId |
| + " for conversationId=" + mConversationId); |
| mSelfId = selfId; |
| if (notify) { |
| dispatchChanged(SELF_CHANGED); |
| } |
| } |
| |
| public boolean hasAttachments() { |
| return !mAttachments.isEmpty(); |
| } |
| |
| public boolean hasPendingAttachments() { |
| return !mPendingAttachments.isEmpty(); |
| } |
| |
| private int getAttachmentCount() { |
| return mAttachments.size() + mPendingAttachments.size(); |
| } |
| |
| private int getVideoAttachmentCount() { |
| int count = 0; |
| for (MessagePartData part : mAttachments) { |
| if (part.isVideo()) { |
| count++; |
| } |
| } |
| for (MessagePartData part : mPendingAttachments) { |
| if (part.isVideo()) { |
| count++; |
| } |
| } |
| return count; |
| } |
| |
| private int getAttachmentLimit() { |
| return BugleGservices.get().getInt( |
| BugleGservicesKeys.MMS_ATTACHMENT_LIMIT, |
| BugleGservicesKeys.MMS_ATTACHMENT_LIMIT_DEFAULT); |
| } |
| |
| public void removeAttachment(final MessagePartData attachment) { |
| for (final MessagePartData existingAttachment : mAttachments) { |
| if (existingAttachment.getContentUri().equals(attachment.getContentUri())) { |
| mAttachments.remove(existingAttachment); |
| existingAttachment.destroyAsync(); |
| dispatchChanged(ATTACHMENTS_CHANGED); |
| break; |
| } |
| } |
| } |
| |
| public void removeExistingAttachments(final Set<MessagePartData> attachmentsToRemove) { |
| boolean removed = false; |
| final Iterator<MessagePartData> iterator = mAttachments.iterator(); |
| while (iterator.hasNext()) { |
| final MessagePartData existingAttachment = iterator.next(); |
| if (attachmentsToRemove.contains(existingAttachment)) { |
| iterator.remove(); |
| existingAttachment.destroyAsync(); |
| removed = true; |
| } |
| } |
| |
| if (removed) { |
| dispatchChanged(ATTACHMENTS_CHANGED); |
| } |
| } |
| |
| public void removePendingAttachment(final PendingAttachmentData pendingAttachment) { |
| for (final PendingAttachmentData existingAttachment : mPendingAttachments) { |
| if (existingAttachment.getContentUri().equals(pendingAttachment.getContentUri())) { |
| mPendingAttachments.remove(pendingAttachment); |
| pendingAttachment.destroyAsync(); |
| dispatchChanged(ATTACHMENTS_CHANGED); |
| break; |
| } |
| } |
| } |
| |
| public void updatePendingAttachment(final MessagePartData updatedAttachment, |
| final PendingAttachmentData pendingAttachment) { |
| for (final PendingAttachmentData existingAttachment : mPendingAttachments) { |
| if (existingAttachment.getContentUri().equals(pendingAttachment.getContentUri())) { |
| mPendingAttachments.remove(pendingAttachment); |
| if (pendingAttachment.isSinglePartOnly()) { |
| updatedAttachment.setSinglePartOnly(true); |
| } |
| mAttachments.add(updatedAttachment); |
| dispatchChanged(ATTACHMENTS_CHANGED); |
| return; |
| } |
| } |
| |
| // If we are here, this means the pending attachment has been dropped before the task |
| // to load it was completed. In this case destroy the temporarily staged file since it |
| // is no longer needed. |
| updatedAttachment.destroyAsync(); |
| } |
| |
| /** |
| * Remove the attachments from the draft and notify any listeners. |
| * @param flags typically this will be ATTACHMENTS_CHANGED. When attachments are cleared in a |
| * widget, flags will also contain WIDGET_CHANGED. |
| */ |
| public void clearAttachments(final int flags) { |
| destroyAttachments(); |
| dispatchChanged(flags); |
| } |
| |
| public List<MessagePartData> getReadOnlyAttachments() { |
| return mReadOnlyAttachments; |
| } |
| |
| public List<PendingAttachmentData> getReadOnlyPendingAttachments() { |
| return mReadOnlyPendingAttachments; |
| } |
| |
| public boolean loadFromStorage(final BindingBase<DraftMessageData> binding, |
| final MessageData optionalIncomingDraft, boolean clearLocalDraft) { |
| LogUtil.d(LogUtil.BUGLE_TAG, "DraftMessageData: " |
| + (optionalIncomingDraft == null ? "loading" : "setting") |
| + " for conversationId=" + mConversationId); |
| if (clearLocalDraft) { |
| clearLocalDraftCopy(); |
| } |
| final boolean isDraftCachedCopy = mIsDraftCachedCopy; |
| mIsDraftCachedCopy = false; |
| // Before reading message from db ensure the caller is bound to us (and knows the id) |
| if (mMonitor == null && !isDraftCachedCopy && isBound(binding.getBindingId())) { |
| mMonitor = ReadDraftDataAction.readDraftData(mConversationId, |
| optionalIncomingDraft, binding.getBindingId(), this); |
| return true; |
| } |
| return false; |
| } |
| |
| /** |
| * Saves the current draft to db. This will save the draft and drop any pending attachments |
| * we have. The UI typically goes into the background when this is called, and instead of |
| * trying to persist the state of the pending attachments (the app may be killed, the activity |
| * may be destroyed), we simply drop the pending attachments for consistency. |
| */ |
| public void saveToStorage(final BindingBase<DraftMessageData> binding) { |
| saveToStorageInternal(binding); |
| dropPendingAttachments(); |
| } |
| |
| private void saveToStorageInternal(final BindingBase<DraftMessageData> binding) { |
| // Create MessageData to store to db, but don't clear the in-memory copy so UI will |
| // continue to display it. |
| // If self id is null then we'll not attempt to change the conversation's self id. |
| final MessageData message = createMessageWithCurrentAttachments(false /* clearLocalCopy */); |
| // Before writing message to db ensure the caller is bound to us (and knows the id) |
| if (isBound(binding.getBindingId())){ |
| WriteDraftMessageAction.writeDraftMessage(mConversationId, message); |
| } |
| } |
| |
| /** |
| * Called when we are ready to send the message. This will assemble/return the MessageData for |
| * sending and clear the local draft data, both from memory and from DB. This will also bind |
| * the message data with a self Id through which the message will be sent. |
| * |
| * @param binding the binding object from our consumer. We need to make sure we are still bound |
| * to that binding before saving to storage. |
| */ |
| public MessageData prepareMessageForSending(final BindingBase<DraftMessageData> binding) { |
| // We can't send the message while there's still stuff pending. |
| Assert.isTrue(!hasPendingAttachments()); |
| mSending = true; |
| // Assembles the message to send and empty working draft data. |
| // If self id is null then message is sent with conversation's self id. |
| final MessageData messageToSend = |
| createMessageWithCurrentAttachments(true /* clearLocalCopy */); |
| // Note sending message will empty the draft data in DB. |
| mSending = false; |
| return messageToSend; |
| } |
| |
| public boolean isSending() { |
| return mSending; |
| } |
| |
| @Override // ReadDraftMessageActionListener.onReadDraftMessageSucceeded |
| public void onReadDraftDataSucceeded(final ReadDraftDataAction action, final Object data, |
| final MessageData message, final ConversationListItemData conversation) { |
| final String bindingId = (String) data; |
| |
| // Before passing draft message on to ui ensure the data is bound to the same bindingid |
| if (isBound(bindingId)) { |
| mSelfId = message.getSelfId(); |
| mIsGroupConversation = conversation.getIsGroup(); |
| mIncludeEmailAddress = conversation.getIncludeEmailAddress(); |
| updateFromMessageData(message, bindingId); |
| LogUtil.d(LogUtil.BUGLE_TAG, "DraftMessageData: draft loaded. " |
| + "conversationId=" + mConversationId + " selfId=" + mSelfId); |
| } else { |
| LogUtil.w(LogUtil.BUGLE_TAG, "DraftMessageData: draft loaded but not bound. " |
| + "conversationId=" + mConversationId); |
| } |
| mMonitor = null; |
| } |
| |
| @Override // ReadDraftMessageActionListener.onReadDraftDataFailed |
| public void onReadDraftDataFailed(final ReadDraftDataAction action, final Object data) { |
| LogUtil.w(LogUtil.BUGLE_TAG, "DraftMessageData: draft not loaded. " |
| + "conversationId=" + mConversationId); |
| // The draft is now synced with actual MessageData and no longer a cached copy. |
| mIsDraftCachedCopy = false; |
| // Just clear the monitor - no update to draft data |
| mMonitor = null; |
| } |
| |
| /** |
| * Check if Bugle is default sms app |
| * @return |
| */ |
| public boolean getIsDefaultSmsApp() { |
| return PhoneUtils.getDefault().isDefaultSmsApp(); |
| } |
| |
| @Override //BindableData.unregisterListeners |
| protected void unregisterListeners() { |
| if (mMonitor != null) { |
| mMonitor.unregister(); |
| } |
| mMonitor = null; |
| mListeners.clear(); |
| } |
| |
| private void destroyAttachments() { |
| for (final MessagePartData attachment : mAttachments) { |
| attachment.destroyAsync(); |
| } |
| mAttachments.clear(); |
| mPendingAttachments.clear(); |
| } |
| |
| private void dispatchChanged(final int changeFlags) { |
| // No change is expected to be made to the draft if it is in cached copy state. |
| if (mIsDraftCachedCopy) { |
| return; |
| } |
| // Any change in the draft will cancel any pending draft checking task, since the |
| // size/status of the draft may have changed. |
| if (mCheckDraftForSendTask != null) { |
| mCheckDraftForSendTask.cancel(true /* mayInterruptIfRunning */); |
| mCheckDraftForSendTask = null; |
| } |
| mListeners.onDraftChanged(this, changeFlags); |
| } |
| |
| private void dispatchAttachmentLimitReached() { |
| mListeners.onDraftAttachmentLimitReached(this); |
| } |
| |
| /** |
| * Drop any pending attachments that haven't finished. This is called after the UI goes to |
| * the background and we persist the draft data to the database. |
| */ |
| private void dropPendingAttachments() { |
| mPendingAttachments.clear(); |
| } |
| |
| private boolean isDraftEmpty() { |
| return TextUtils.isEmpty(mMessageText) && mAttachments.isEmpty() && |
| TextUtils.isEmpty(mMessageSubject); |
| } |
| |
| public boolean isCheckingDraft() { |
| return mCheckDraftForSendTask != null && !mCheckDraftForSendTask.isCancelled(); |
| } |
| |
| public void checkDraftForAction(final boolean checkMessageSize, final int selfSubId, |
| final CheckDraftTaskCallback callback, final Binding<DraftMessageData> binding) { |
| new CheckDraftForSendTask(checkMessageSize, selfSubId, callback, binding) |
| .executeOnThreadPool((Void) null); |
| } |
| |
| /** |
| * Allows us to have multiple data listeners for DraftMessageData |
| */ |
| private class DraftMessageDataEventDispatcher |
| extends ArrayList<DraftMessageDataListener> |
| implements DraftMessageDataListener { |
| |
| @Override |
| @RunsOnMainThread |
| public void onDraftChanged(DraftMessageData data, int changeFlags) { |
| Assert.isMainThread(); |
| for (final DraftMessageDataListener listener : this) { |
| listener.onDraftChanged(data, changeFlags); |
| } |
| } |
| |
| @Override |
| @RunsOnMainThread |
| public void onDraftAttachmentLimitReached(DraftMessageData data) { |
| Assert.isMainThread(); |
| for (final DraftMessageDataListener listener : this) { |
| listener.onDraftAttachmentLimitReached(data); |
| } |
| } |
| |
| @Override |
| @RunsOnMainThread |
| public void onDraftAttachmentLoadFailed() { |
| Assert.isMainThread(); |
| for (final DraftMessageDataListener listener : this) { |
| listener.onDraftAttachmentLoadFailed(); |
| } |
| } |
| } |
| |
| public interface CheckDraftTaskCallback { |
| void onDraftChecked(DraftMessageData data, int result); |
| } |
| |
| public class CheckDraftForSendTask extends SafeAsyncTask<Void, Void, Integer> { |
| public static final int RESULT_PASSED = 0; |
| public static final int RESULT_HAS_PENDING_ATTACHMENTS = 1; |
| public static final int RESULT_NO_SELF_PHONE_NUMBER_IN_GROUP_MMS = 2; |
| public static final int RESULT_MESSAGE_OVER_LIMIT = 3; |
| public static final int RESULT_VIDEO_ATTACHMENT_LIMIT_EXCEEDED = 4; |
| public static final int RESULT_SIM_NOT_READY = 5; |
| private final boolean mCheckMessageSize; |
| private final int mSelfSubId; |
| private final CheckDraftTaskCallback mCallback; |
| private final String mBindingId; |
| private final List<MessagePartData> mAttachmentsCopy; |
| private int mPreExecuteResult = RESULT_PASSED; |
| |
| public CheckDraftForSendTask(final boolean checkMessageSize, final int selfSubId, |
| final CheckDraftTaskCallback callback, final Binding<DraftMessageData> binding) { |
| mCheckMessageSize = checkMessageSize; |
| mSelfSubId = selfSubId; |
| mCallback = callback; |
| mBindingId = binding.getBindingId(); |
| // Obtain an immutable copy of the attachment list so we can operate on it in the |
| // background thread. |
| mAttachmentsCopy = new ArrayList<MessagePartData>(mAttachments); |
| |
| mCheckDraftForSendTask = this; |
| } |
| |
| @Override |
| protected void onPreExecute() { |
| // Perform checking work that can happen on the main thread. |
| if (hasPendingAttachments()) { |
| mPreExecuteResult = RESULT_HAS_PENDING_ATTACHMENTS; |
| return; |
| } |
| if (getIsGroupMmsConversation()) { |
| try { |
| if (TextUtils.isEmpty(PhoneUtils.get(mSelfSubId).getSelfRawNumber(true))) { |
| mPreExecuteResult = RESULT_NO_SELF_PHONE_NUMBER_IN_GROUP_MMS; |
| return; |
| } |
| } catch (IllegalStateException e) { |
| // This happens when there is no active subscription, e.g. on Nova |
| // when the phone switches carrier. |
| mPreExecuteResult = RESULT_SIM_NOT_READY; |
| return; |
| } |
| } |
| if (getVideoAttachmentCount() > MmsUtils.MAX_VIDEO_ATTACHMENT_COUNT) { |
| mPreExecuteResult = RESULT_VIDEO_ATTACHMENT_LIMIT_EXCEEDED; |
| return; |
| } |
| } |
| |
| @Override |
| protected Integer doInBackgroundTimed(Void... params) { |
| if (mPreExecuteResult != RESULT_PASSED) { |
| return mPreExecuteResult; |
| } |
| |
| if (mCheckMessageSize && getIsMessageOverLimit()) { |
| return RESULT_MESSAGE_OVER_LIMIT; |
| } |
| return RESULT_PASSED; |
| } |
| |
| @Override |
| protected void onPostExecute(Integer result) { |
| mCheckDraftForSendTask = null; |
| // Only call back if we are bound to the original binding. |
| if (isBound(mBindingId) && !isCancelled()) { |
| mCallback.onDraftChecked(DraftMessageData.this, result); |
| } else { |
| if (!isBound(mBindingId)) { |
| LogUtil.w(LogUtil.BUGLE_TAG, "Message can't be sent: draft not bound"); |
| } |
| if (isCancelled()) { |
| LogUtil.w(LogUtil.BUGLE_TAG, "Message can't be sent: draft is cancelled"); |
| } |
| } |
| } |
| |
| @Override |
| protected void onCancelled() { |
| mCheckDraftForSendTask = null; |
| } |
| |
| /** |
| * 1. Check if the draft message contains too many attachments to send |
| * 2. Computes the minimum size that this message could be compressed/downsampled/encoded |
| * before sending and check if it meets the carrier max size for sending. |
| * @see MessagePartData#getMinimumSizeInBytesForSending() |
| */ |
| @DoesNotRunOnMainThread |
| private boolean getIsMessageOverLimit() { |
| Assert.isNotMainThread(); |
| if (mAttachmentsCopy.size() > getAttachmentLimit()) { |
| return true; |
| } |
| |
| // Aggregate the size from all the attachments. |
| long totalSize = 0; |
| for (final MessagePartData attachment : mAttachmentsCopy) { |
| totalSize += attachment.getMinimumSizeInBytesForSending(); |
| } |
| return totalSize > MmsConfig.get(mSelfSubId).getMaxMessageSize(); |
| } |
| } |
| |
| public void onPendingAttachmentLoadFailed(PendingAttachmentData data) { |
| mListeners.onDraftAttachmentLoadFailed(); |
| } |
| } |
