xref: /packages/apps/Email/src/com/android/email/activity/MessageCompose.java

/*
 * Copyright (C) 2008 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.email.activity;

import com.android.common.contacts.DataUsageStatUpdater;
import com.android.email.Controller;
import com.android.email.Email;
import com.android.email.EmailAddressAdapter;
import com.android.email.EmailAddressValidator;
import com.android.email.R;
import com.android.email.RecipientAdapter;
import com.android.email.mail.internet.EmailHtmlUtil;
import com.android.emailcommon.Logging;
import com.android.emailcommon.internet.MimeUtility;
import com.android.emailcommon.mail.Address;
import com.android.emailcommon.provider.Account;
import com.android.emailcommon.provider.EmailContent.Attachment;
import com.android.emailcommon.provider.EmailContent.Body;
import com.android.emailcommon.provider.EmailContent.BodyColumns;
import com.android.emailcommon.provider.EmailContent.Message;
import com.android.emailcommon.provider.EmailContent.MessageColumns;
import com.android.emailcommon.provider.Mailbox;
import com.android.emailcommon.utility.AttachmentUtilities;
import com.android.emailcommon.utility.EmailAsyncTask;
import com.android.emailcommon.utility.Utility;
import com.android.ex.chips.AccountSpecifier;
import com.android.ex.chips.BaseRecipientAdapter;
import com.android.ex.chips.ChipsUtil;
import com.android.ex.chips.RecipientEditTextView;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Objects;
import com.google.common.collect.Lists;

import android.app.ActionBar;
import android.app.ActionBar.Tab;
import android.app.ActionBar.TabListener;
import android.app.Activity;
import android.app.ActivityManager;
import android.app.FragmentTransaction;
import android.content.ActivityNotFoundException;
import android.content.ContentResolver;
import android.content.ContentUris;
import android.content.ContentValues;
import android.content.Context;
import android.content.Intent;
import android.content.pm.ActivityInfo;
import android.content.res.Configuration;
import android.database.Cursor;
import android.net.Uri;
import android.os.Bundle;
import android.os.Parcelable;
import android.provider.OpenableColumns;
import android.text.InputFilter;
import android.text.SpannableStringBuilder;
import android.text.Spanned;
import android.text.TextUtils;
import android.text.TextWatcher;
import android.text.util.Rfc822Tokenizer;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.View.OnFocusChangeListener;
import android.view.ViewGroup;
import android.view.Window;
import android.webkit.WebView;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemSelectedListener;
import android.widget.ArrayAdapter;
import android.widget.CheckBox;
import android.widget.EditText;
import android.widget.ImageButton;
import android.widget.MultiAutoCompleteTextView;
import android.widget.SimpleAdapter;
import android.widget.Spinner;
import android.widget.TextView;
import android.widget.Toast;

import java.io.File;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutionException;


/**
 * Activity to compose a message.
 *
 * TODO Revive shortcuts command for removed menu options.
 * C: add cc/bcc
 * N: add attachment
 */
public class MessageCompose extends Activity implements OnClickListener, OnFocusChangeListener,
        DeleteMessageConfirmationDialog.Callback {

    private static final String ACTION_REPLY = "com.android.email.intent.action.REPLY";
    private static final String ACTION_REPLY_ALL = "com.android.email.intent.action.REPLY_ALL";
    private static final String ACTION_FORWARD = "com.android.email.intent.action.FORWARD";
    private static final String ACTION_EDIT_DRAFT = "com.android.email.intent.action.EDIT_DRAFT";

    private static final String EXTRA_ACCOUNT_ID = "account_id";
    private static final String EXTRA_MESSAGE_ID = "message_id";
    /** If the intent is sent from the email app itself, it should have this boolean extra. */
    private static final String EXTRA_FROM_WITHIN_APP = "from_within_app";

    private static final String STATE_KEY_CC_SHOWN =
        "com.android.email.activity.MessageCompose.ccShown";
    private static final String STATE_KEY_QUOTED_TEXT_SHOWN =
        "com.android.email.activity.MessageCompose.quotedTextShown";
    private static final String STATE_KEY_DRAFT_ID =
        "com.android.email.activity.MessageCompose.draftId";
    private static final String STATE_KEY_LAST_SAVE_TASK_ID =
        "com.android.email.activity.MessageCompose.requestId";
    private static final String STATE_KEY_ACTION =
        "com.android.email.activity.MessageCompose.action";

    private static final int ACTIVITY_REQUEST_PICK_ATTACHMENT = 1;

    private static final String[] ATTACHMENT_META_SIZE_PROJECTION = {
        OpenableColumns.SIZE
    };
    private static final int ATTACHMENT_META_SIZE_COLUMN_SIZE = 0;

    /**
     * A registry of the active tasks used to save messages.
     */
    private static final ConcurrentHashMap<Long, SendOrSaveMessageTask> sActiveSaveTasks =
            new ConcurrentHashMap<Long, SendOrSaveMessageTask>();

    private static long sNextSaveTaskId = 1;

    /**
     * The ID of the latest save or send task requested by this Activity.
     */
    private long mLastSaveTaskId = -1;

    private Account mAccount;

    /**
     * The contents of the current message being edited. This is not always in sync with what's
     * on the UI. {@link #updateMessage(Message, Account, boolean, boolean)} must be called to sync
     * the UI values into this object.
     */
    private Message mDraft = new Message();

    /**
     * A collection of attachments the user is currently wanting to attach to this message.
     */
    private final ArrayList<Attachment> mAttachments = new ArrayList<Attachment>();

    /**
     * The source message for a reply, reply all, or forward. This is asynchronously loaded.
     */
    private Message mSource;

    /**
     * The attachments associated with the source attachments. Usually included in a forward.
     */
    private ArrayList<Attachment> mSourceAttachments = new ArrayList<Attachment>();

    /**
     * The action being handled by this activity. This is initially populated from the
     * {@link Intent}, but can switch between reply/reply all/forward where appropriate.
     * This value is nullable (a null value indicating a regular "compose").
     */
    private String mAction;

    private TextView mFromView;
    private MultiAutoCompleteTextView mToView;
    private MultiAutoCompleteTextView mCcView;
    private MultiAutoCompleteTextView mBccView;
    private View mCcBccContainer;
    private EditText mSubjectView;
    private EditText mMessageContentView;
    private View mAttachmentContainer;
    private ViewGroup mAttachmentContentView;
    private View mQuotedTextBar;
    private CheckBox mIncludeQuotedTextCheckBox;
    private WebView mQuotedText;
    private Spinner mActionSpinner;
    private ActionSpinnerAdapter mActionSpinnerAdapter;

    private Controller mController;
    private boolean mDraftNeedsSaving;
    private boolean mMessageLoaded;
    private final EmailAsyncTask.Tracker mTaskTracker = new EmailAsyncTask.Tracker();

    private AccountSpecifier mAddressAdapterTo;
    private AccountSpecifier mAddressAdapterCc;
    private AccountSpecifier mAddressAdapterBcc;

    private static Intent getBaseIntent(Context context) {
        Intent i = new Intent(context, MessageCompose.class);
        i.putExtra(EXTRA_FROM_WITHIN_APP, true);
        return i;
    }

    /**
     * Create an {@link Intent} that can start the message compose activity. If accountId -1,
     * the default account will be used; otherwise, the specified account is used.
     */
    public static Intent getMessageComposeIntent(Context context, long accountId) {
        Intent i = getBaseIntent(context);
        i.putExtra(EXTRA_ACCOUNT_ID, accountId);
        return i;
    }

    /**
     * Compose a new message using the given account. If account is -1 the default account
     * will be used.
     * @param context
     * @param accountId
     */
    public static void actionCompose(Context context, long accountId) {
       try {
           Intent i = getMessageComposeIntent(context, accountId);
           context.startActivity(i);
       } catch (ActivityNotFoundException anfe) {
           // Swallow it - this is usually a race condition, especially under automated test.
           // (The message composer might have been disabled)
           Email.log(anfe.toString());
       }
    }

    /**
     * Compose a new message using a uri (mailto:) and a given account.  If account is -1 the
     * default account will be used.
     * @param context
     * @param uriString
     * @param accountId
     * @return true if startActivity() succeeded
     */
    public static boolean actionCompose(Context context, String uriString, long accountId) {
        try {
            Intent i = getMessageComposeIntent(context, accountId);
            i.setAction(Intent.ACTION_SEND);
            i.setData(Uri.parse(uriString));
            context.startActivity(i);
            return true;
        } catch (ActivityNotFoundException anfe) {
            // Swallow it - this is usually a race condition, especially under automated test.
            // (The message composer might have been disabled)
            Email.log(anfe.toString());
            return false;
        }
    }

    /**
     * Compose a new message as a reply to the given message. If replyAll is true the function
     * is reply all instead of simply reply.
     * @param context
     * @param messageId
     * @param replyAll
     */
    public static void actionReply(Context context, long messageId, boolean replyAll) {
        startActivityWithMessage(context, replyAll ? ACTION_REPLY_ALL : ACTION_REPLY, messageId);
    }

    /**
     * Compose a new message as a forward of the given message.
     * @param context
     * @param messageId
     */
    public static void actionForward(Context context, long messageId) {
        startActivityWithMessage(context, ACTION_FORWARD, messageId);
    }

    /**
     * Continue composition of the given message. This action modifies the way this Activity
     * handles certain actions.
     * Save will attempt to replace the message in the given folder with the updated version.
     * Discard will delete the message from the given folder.
     * @param context
     * @param messageId the message id.
     */
    public static void actionEditDraft(Context context, long messageId) {
        startActivityWithMessage(context, ACTION_EDIT_DRAFT, messageId);
    }

    /**
     * Starts a compose activity with a message as a reference message (e.g. for reply or forward).
     */
    private static void startActivityWithMessage(Context context, String action, long messageId) {
        Intent i = getBaseIntent(context);
        i.putExtra(EXTRA_MESSAGE_ID, messageId);
        i.setAction(action);
        context.startActivity(i);
    }

    private void setAccount(Intent intent) {
        long accountId = intent.getLongExtra(EXTRA_ACCOUNT_ID, -1);
        if (accountId == -1) {
            accountId = Account.getDefaultAccountId(this);
        }
        if (accountId == -1) {
            // There are no accounts set up. This should not have happened. Prompt the
            // user to set up an account as an acceptable bailout.
            Welcome.actionStart(this);
            finish();
        } else {
            setAccount(Account.restoreAccountWithId(this, accountId));
        }
    }

    private void setAccount(Account account) {
        if (account == null) {
            throw new IllegalArgumentException();
        }
        mAccount = account;
        mAddressAdapterTo
                .setAccount(new android.accounts.Account(account.mEmailAddress, "unknown"));
        mAddressAdapterCc
                .setAccount(new android.accounts.Account(account.mEmailAddress, "unknown"));
        mAddressAdapterBcc
                .setAccount(new android.accounts.Account(account.mEmailAddress, "unknown"));

        if (mFromView != null) {
            // Some configurations don't show the from field.
            mFromView.setText(account.mEmailAddress);
        }
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ActivityHelper.debugSetWindowFlags(this);
        setContentView(R.layout.message_compose);

        mController = Controller.getInstance(getApplication());
        initViews();

        // Show the back arrow on the action bar.
        getActionBar().setDisplayOptions(
                ActionBar.DISPLAY_HOME_AS_UP, ActionBar.DISPLAY_HOME_AS_UP);

        if (savedInstanceState != null) {
            long draftId = savedInstanceState.getLong(STATE_KEY_DRAFT_ID, Message.NOT_SAVED);
            long existingSaveTaskId = savedInstanceState.getLong(STATE_KEY_LAST_SAVE_TASK_ID, -1);
            setAction(savedInstanceState.getString(STATE_KEY_ACTION));
            SendOrSaveMessageTask existingSaveTask = sActiveSaveTasks.get(existingSaveTaskId);

            if ((draftId != Message.NOT_SAVED) || (existingSaveTask != null)) {
                // Restoring state and there was an existing message saved or in the process of
                // being saved.
                resumeDraft(draftId, existingSaveTask, false /* don't restore views */);
            } else {
                // Restoring state but there was nothing saved - probably means the user rotated
                // the device immediately - just use the Intent.
                resolveIntent(getIntent());
            }
        } else {
            Intent intent = getIntent();
            setAction(intent.getAction());
            resolveIntent(intent);
        }

        initListeners();
    }

    private void resolveIntent(Intent intent) {
        if (Intent.ACTION_VIEW.equals(mAction)
                || Intent.ACTION_SENDTO.equals(mAction)
                || Intent.ACTION_SEND.equals(mAction)
                || Intent.ACTION_SEND_MULTIPLE.equals(mAction)) {
            initFromIntent(intent);
            setDraftNeedsSaving(true);
            mMessageLoaded = true;
        } else if (ACTION_REPLY.equals(mAction)
                || ACTION_REPLY_ALL.equals(mAction)
                || ACTION_FORWARD.equals(mAction)) {
            long sourceMessageId = getIntent().getLongExtra(EXTRA_MESSAGE_ID, Message.NOT_SAVED);
            loadSourceMessage(sourceMessageId, true);

        } else if (ACTION_EDIT_DRAFT.equals(mAction)) {
            // Assert getIntent.hasExtra(EXTRA_MESSAGE_ID)
            long draftId = getIntent().getLongExtra(EXTRA_MESSAGE_ID, Message.NOT_SAVED);
            resumeDraft(draftId, null, true /* restore views */);

        } else {
            // Normal compose flow for a new message.
            setAccount(intent);
            setInitialComposeText(null, getAccountSignature(mAccount));

            mMessageLoaded = true;
        }
    }

    @Override
    protected void onRestoreInstanceState(Bundle savedInstanceState) {
        super.onRestoreInstanceState(savedInstanceState);
        if (savedInstanceState.getBoolean(STATE_KEY_CC_SHOWN)) {
            showCcBccFields();
        }
        mQuotedTextBar.setVisibility(savedInstanceState.getBoolean(STATE_KEY_QUOTED_TEXT_SHOWN)
                ? View.VISIBLE : View.GONE);
        mQuotedText.setVisibility(savedInstanceState.getBoolean(STATE_KEY_QUOTED_TEXT_SHOWN)
                ? View.VISIBLE : View.GONE);
    }

    // needed for unit tests
    @Override
    public void setIntent(Intent intent) {
        super.setIntent(intent);
        setAction(intent.getAction());
    }

    @Override
    public void onResume() {
        super.onResume();

        // Exit immediately if the accounts list has changed (e.g. externally deleted)
        if (Email.getNotifyUiAccountsChanged()) {
            Welcome.actionStart(this);
            finish();
            return;
        }
    }

    @Override
    public void onPause() {
        super.onPause();
        saveIfNeeded();
    }

    /**
     * We override onDestroy to make sure that the WebView gets explicitly destroyed.
     * Otherwise it can leak native references.
     */
    @Override
    public void onDestroy() {
        super.onDestroy();
        mQuotedText.destroy();
        mQuotedText = null;

        mTaskTracker.cancellAllInterrupt();

        if (mAddressAdapterTo != null && mAddressAdapterTo instanceof EmailAddressAdapter) {
            ((EmailAddressAdapter) mAddressAdapterTo).close();
        }
        if (mAddressAdapterCc != null && mAddressAdapterCc instanceof EmailAddressAdapter) {
            ((EmailAddressAdapter) mAddressAdapterCc).close();
        }
        if (mAddressAdapterBcc != null && mAddressAdapterBcc instanceof EmailAddressAdapter) {
            ((EmailAddressAdapter) mAddressAdapterBcc).close();
        }
    }

    /**
     * The framework handles most of the fields, but we need to handle stuff that we
     * dynamically show and hide:
     * Cc field,
     * Bcc field,
     * Quoted text,
     */
    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);

        long draftId = mDraft.mId;
        if (draftId != Message.NOT_SAVED) {
            outState.putLong(STATE_KEY_DRAFT_ID, draftId);
        }
        outState.putBoolean(STATE_KEY_CC_SHOWN, mCcBccContainer.getVisibility() == View.VISIBLE);
        outState.putBoolean(STATE_KEY_QUOTED_TEXT_SHOWN,
                mQuotedTextBar.getVisibility() == View.VISIBLE);
        outState.putString(STATE_KEY_ACTION, mAction);

        // If there are any outstanding save requests, ensure that it's noted in case it hasn't
        // finished by the time the activity is restored.
        outState.putLong(STATE_KEY_LAST_SAVE_TASK_ID, mLastSaveTaskId);
    }

    /**
     * Whether or not the current message being edited has a source message (i.e. is a reply,
     * or forward) that is loaded.
     */
    private boolean hasSourceMessage() {
        return mSource != null;
    }

    /**
     * @return true if the activity was opened by the email app itself.
     */
    private boolean isOpenedFromWithinApp() {
        Intent i = getIntent();
        return (i != null && i.getBooleanExtra(EXTRA_FROM_WITHIN_APP, false));
    }

    private void setDraftNeedsSaving(boolean needsSaving) {
        if (mDraftNeedsSaving != needsSaving) {
            mDraftNeedsSaving = needsSaving;
            invalidateOptionsMenu();
        }
    }

    public void setFocusShifter(int fromViewId, final int targetViewId) {
        View label = findViewById(fromViewId); // xlarge only
        if (label != null) {
            final View target = UiUtilities.getView(this, targetViewId);
            label.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    target.requestFocus();
                }
            });
        }
    }

    /**
     * An {@link InputFilter} that implements special address cleanup rules.
     * The first space key entry following an "@" symbol that is followed by any combination
     * of letters and symbols, including one+ dots and zero commas, should insert an extra
     * comma (followed by the space).
     */
    @VisibleForTesting
    static final InputFilter RECIPIENT_FILTER = new InputFilter() {
        @Override
        public CharSequence filter(CharSequence source, int start, int end, Spanned dest,
                int dstart, int dend) {

            // Quick check - did they enter a single space?
            if (end-start != 1 || source.charAt(start) != ' ') {
                return null;
            }

            // determine if the characters before the new space fit the pattern
            // follow backwards and see if we find a comma, dot, or @
            int scanBack = dstart;
            boolean dotFound = false;
            while (scanBack > 0) {
                char c = dest.charAt(--scanBack);
                switch (c) {
                    case '.':
                        dotFound = true;    // one or more dots are req'd
                        break;
                    case ',':
                        return null;
                    case '@':
                        if (!dotFound) {
                            return null;
                        }

                        // we have found a comma-insert case.  now just do it
                        // in the least expensive way we can.
                        if (source instanceof Spanned) {
                            SpannableStringBuilder sb = new SpannableStringBuilder(",");
                            sb.append(source);
                            return sb;
                        } else {
                            return ", ";
                        }
                    default:
                        // just keep going
                }
            }

            // no termination cases were found, so don't edit the input
            return null;
        }
    };

    private void initViews() {
        mToView = UiUtilities.getView(this, R.id.to);
        mToView.setHint(R.string.message_compose_to_hint);
        mCcView = UiUtilities.getView(this, R.id.cc);
        mCcView.setHint(R.string.message_compose_cc_hint);
        mBccView = UiUtilities.getView(this, R.id.bcc);
        mBccView.setHint(R.string.message_compose_bcc_hint);

        mCcBccContainer = UiUtilities.getView(this, R.id.cc_bcc_container);
        mSubjectView = UiUtilities.getView(this, R.id.subject);
        mMessageContentView = UiUtilities.getView(this, R.id.message_content);
        mAttachmentContentView = UiUtilities.getView(this, R.id.attachments);
        mAttachmentContainer = UiUtilities.getView(this, R.id.attachment_container);
        mQuotedTextBar = UiUtilities.getView(this, R.id.quoted_text_bar);
        mIncludeQuotedTextCheckBox = UiUtilities.getView(this, R.id.include_quoted_text);
        mQuotedText = UiUtilities.getView(this, R.id.quoted_text);

        InputFilter[] recipientFilters = new InputFilter[] { RECIPIENT_FILTER };

        // NOTE: assumes no other filters are set
        mToView.setFilters(recipientFilters);
        mCcView.setFilters(recipientFilters);
        mBccView.setFilters(recipientFilters);

        /*
         * We set this to invisible by default. Other methods will turn it back on if it's
         * needed.
         */
        mQuotedTextBar.setVisibility(View.GONE);
        setIncludeQuotedText(false, false);

        mIncludeQuotedTextCheckBox.setOnClickListener(this);

        EmailAddressValidator addressValidator = new EmailAddressValidator();

        setupAddressAdapters();
        mToView.setTokenizer(new Rfc822Tokenizer());
        mToView.setValidator(addressValidator);

        mCcView.setTokenizer(new Rfc822Tokenizer());
        mCcView.setValidator(addressValidator);

        mBccView.setTokenizer(new Rfc822Tokenizer());
        mBccView.setValidator(addressValidator);

        final View addCcBccView = UiUtilities.getView(this, R.id.add_cc_bcc);
        addCcBccView.setOnClickListener(this);

        final View addAttachmentView = UiUtilities.getView(this, R.id.add_attachment);
        addAttachmentView.setOnClickListener(this);

        setFocusShifter(R.id.to_label, R.id.to);
        setFocusShifter(R.id.cc_label, R.id.cc);
        setFocusShifter(R.id.bcc_label, R.id.bcc);
        setFocusShifter(R.id.subject_label, R.id.subject);
        setFocusShifter(R.id.tap_trap, R.id.message_content);

        mMessageContentView.setOnFocusChangeListener(this);

        mFromView = UiUtilities.getViewOrNull(this, R.id.from);
        mActionSpinner = UiUtilities.getViewOrNull(this, R.id.action_spinner);

        updateAttachmentContainer();
        mToView.requestFocus();
    }

    private void initListeners() {
        final TextWatcher watcher = new TextWatcher() {
            public void beforeTextChanged(CharSequence s, int start,
                                          int before, int after) { }

            public void onTextChanged(CharSequence s, int start,
                                          int before, int count) {
                setDraftNeedsSaving(true);
            }

            public void afterTextChanged(android.text.Editable s) { }
        };

        mToView.addTextChangedListener(watcher);
        mCcView.addTextChangedListener(watcher);
        mBccView.addTextChangedListener(watcher);
        mSubjectView.addTextChangedListener(watcher);
        mMessageContentView.addTextChangedListener(watcher);
    }

    /**
     * Set up address auto-completion adapters.
     */
    private void setupAddressAdapters() {
        boolean supportsChips = ChipsUtil.supportsChipsUi();

        if (supportsChips && mToView instanceof RecipientEditTextView) {
            mAddressAdapterTo = new RecipientAdapter(this, (RecipientEditTextView) mToView);
            mToView.setAdapter((RecipientAdapter) mAddressAdapterTo);
        } else {
            mAddressAdapterTo = new EmailAddressAdapter(this);
            mToView.setAdapter((EmailAddressAdapter) mAddressAdapterTo);
        }
        if (supportsChips && mCcView instanceof RecipientEditTextView) {
            mAddressAdapterCc = new RecipientAdapter(this, (RecipientEditTextView) mCcView);
            mCcView.setAdapter((RecipientAdapter) mAddressAdapterCc);
        } else {
            mAddressAdapterCc = new EmailAddressAdapter(this);
            mCcView.setAdapter((EmailAddressAdapter) mAddressAdapterCc);
        }
        if (supportsChips && mBccView instanceof RecipientEditTextView) {
            mAddressAdapterBcc = new RecipientAdapter(this, (RecipientEditTextView) mBccView);
            mBccView.setAdapter((RecipientAdapter) mAddressAdapterBcc);
        } else {
            mAddressAdapterBcc = new EmailAddressAdapter(this);
            mBccView.setAdapter((EmailAddressAdapter) mAddressAdapterBcc);
        }
    }

    /**
     * Asynchronously loads a draft message for editing.
     * This may or may not restore the view contents, depending on whether or not callers want,
     * since in the case of screen rotation, those are restored automatically.
     */
    private void resumeDraft(
            long draftId,
            SendOrSaveMessageTask existingSaveTask,
            final boolean restoreViews) {
        // Note - this can be Message.NOT_SAVED if there is an existing save task in progress
        // for the draft we need to load.
        mDraft.mId = draftId;

        new LoadMessageTask(draftId, existingSaveTask, new OnMessageLoadHandler() {
            @Override
            public void onMessageLoaded(Message message, Body body) {
                message.mHtml = body.mHtmlContent;
                message.mText = body.mTextContent;
                message.mHtmlReply = body.mHtmlReply;
                message.mTextReply = body.mTextReply;
                message.mIntroText = body.mIntroText;
                message.mSourceKey = body.mSourceKey;

                mDraft = message;
                processDraftMessage(message, restoreViews);

                // Load attachments related to the draft.
                loadAttachments(message.mId, mAccount, new AttachmentLoadedCallback() {
                    @Override
                    public void onAttachmentLoaded(Attachment[] attachments) {
                        for (Attachment attachment: attachments) {
                            addAttachment(attachment);
                        }
                    }
                });

                // If we're resuming an edit of a reply, reply-all, or forward, re-load the
                // source message if available so that we get more information.
                if (message.mSourceKey != Message.NOT_SAVED) {
                    loadSourceMessage(message.mSourceKey, false /* restore views */);
                }
            }

            @Override
            public void onLoadFailed() {
                Utility.showToast(MessageCompose.this, R.string.error_loading_message_body);
                finish();
            }
        }).executeParallel((Void[]) null);
    }

    @VisibleForTesting
    void processDraftMessage(Message message, boolean restoreViews) {
        if (restoreViews) {
            mSubjectView.setText(message.mSubject);
            addAddresses(mToView, Address.unpack(message.mTo));
            Address[] cc = Address.unpack(message.mCc);
            if (cc.length > 0) {
                addAddresses(mCcView, cc);
            }
            Address[] bcc = Address.unpack(message.mBcc);
            if (bcc.length > 0) {
                addAddresses(mBccView, bcc);
            }

            mMessageContentView.setText(message.mText);

            showCcBccFieldsIfFilled();
            setNewMessageFocus();
        }
        setDraftNeedsSaving(false);

        // The quoted text must always be restored.
        displayQuotedText(message.mTextReply, message.mHtmlReply);
        setIncludeQuotedText(
                (mDraft.mFlags & Message.FLAG_NOT_INCLUDE_QUOTED_TEXT) == 0, false);
    }

    /**
     * Asynchronously loads a source message (to be replied or forwarded in this current view),
     * populating text fields and quoted text fields when the load finishes, if requested.
     */
    private void loadSourceMessage(long sourceMessageId, final boolean restoreViews) {
        new LoadMessageTask(sourceMessageId, null, new OnMessageLoadHandler() {
            @Override
            public void onMessageLoaded(Message message, Body body) {
                message.mHtml = body.mHtmlContent;
                message.mText = body.mTextContent;
                message.mHtmlReply = null;
                message.mTextReply = null;
                message.mIntroText = null;
                mSource = message;
                mSourceAttachments = new ArrayList<Attachment>();

                if (restoreViews) {
                    processSourceMessage(mSource, mAccount);
                    setInitialComposeText(null, getAccountSignature(mAccount));
                }

                loadAttachments(message.mId, mAccount, new AttachmentLoadedCallback() {
                    @Override
                    public void onAttachmentLoaded(Attachment[] attachments) {
                        final boolean supportsSmartForward =
                            (mAccount.mFlags & Account.FLAGS_SUPPORTS_SMART_FORWARD) != 0;

                        // Process the attachments to have the appropriate smart forward flags.
                        for (Attachment attachment : attachments) {
                            if (supportsSmartForward) {
                                attachment.mFlags |= Attachment.FLAG_SMART_FORWARD;
                            }
                            mSourceAttachments.add(attachment);
                        }
                        if (isForward() && restoreViews) {
                            if (processSourceMessageAttachments(
                                    mAttachments, mSourceAttachments, true)) {
                                updateAttachmentUi();
                                setDraftNeedsSaving(true);
                            }
                        }
                    }
                });

                if (mAction.equals(ACTION_EDIT_DRAFT)) {
                    // Resuming a draft may in fact be resuming a reply/reply all/forward.
                    // Use a best guess and infer the action here.
                    String inferredAction = inferAction();
                    if (inferredAction != null) {
                        setAction(inferredAction);
                        // No need to update the action selector as switching actions should do it.
                        return;
                    }
                }

                updateActionSelector();
            }

            @Override
            public void onLoadFailed() {
                // The loading of the source message is only really required if it is needed
                // immediately to restore the view contents. In the case of resuming draft, it
                // is only needed to gather additional information.
                if (restoreViews) {
                    Utility.showToast(MessageCompose.this, R.string.error_loading_message_body);
                    finish();
                }
            }
        }).executeParallel((Void[]) null);
    }

    /**
     * Infers whether or not the current state of the message best reflects either a reply,
     * reply-all, or forward.
     */
    @VisibleForTesting
    String inferAction() {
        String subject = mSubjectView.getText().toString();
        if (subject == null) {
            return null;
        }
        if (subject.toLowerCase().startsWith("fwd:")) {
            return ACTION_FORWARD;
        } else if (subject.toLowerCase().startsWith("re:")) {
            int numRecipients = getAddresses(mToView).length
                    + getAddresses(mCcView).length
                    + getAddresses(mBccView).length;
            if (numRecipients > 1) {
                return ACTION_REPLY_ALL;
            } else {
                return ACTION_REPLY;
            }
        } else {
            // Unsure.
            return null;
        }
    }

    private interface OnMessageLoadHandler {
        /**
         * Handles a load to a message (e.g. a draft message or a source message).
         */
        void onMessageLoaded(Message message, Body body);

        /**
         * Handles a failure to load a message.
         */
        void onLoadFailed();
    }

    /**
     * Asynchronously loads a message and the account information.
     * This can be used to load a reference message (when replying) or when restoring a draft.
     */
    private class LoadMessageTask extends EmailAsyncTask<Void, Void, Object[]> {
        /**
         * The message ID to load, if available.
         */
        private long mMessageId;

        /**
         * A future-like reference to the save task which must complete prior to this load.
         */
        private final SendOrSaveMessageTask mSaveTask;

        /**
         * A callback to pass the results of the load to.
         */
        private final OnMessageLoadHandler mCallback;

        public LoadMessageTask(
                long messageId, SendOrSaveMessageTask saveTask, OnMessageLoadHandler callback) {
            super(mTaskTracker);
            mMessageId = messageId;
            mSaveTask = saveTask;
            mCallback = callback;
        }

        private long getIdToLoad() throws InterruptedException, ExecutionException {
            if (mMessageId == -1) {
                mMessageId = mSaveTask.get();
            }
            return mMessageId;
        }

        @Override
        protected Object[] doInBackground(Void... params) {
            long messageId;
            try {
                messageId = getIdToLoad();
            } catch (InterruptedException e) {
                // Don't have a good message ID to load - bail.
                Log.e(Logging.LOG_TAG,
                        "Unable to load draft message since existing save task failed: " + e);
                return null;
            } catch (ExecutionException e) {
                // Don't have a good message ID to load - bail.
                Log.e(Logging.LOG_TAG,
                        "Unable to load draft message since existing save task failed: " + e);
                return null;
            }
            Message message = Message.restoreMessageWithId(MessageCompose.this, messageId);
            if (message == null) {
                return null;
            }
            long accountId = message.mAccountKey;
            Account account = Account.restoreAccountWithId(MessageCompose.this, accountId);
            Body body;
            try {
                body = Body.restoreBodyWithMessageId(MessageCompose.this, message.mId);
            } catch (RuntimeException e) {
                Log.d(Logging.LOG_TAG, "Exception while loading message body: " + e);
                return null;
            }
            return new Object[] {message, body, account};
        }

        @Override
        protected void onPostExecute(Object[] results) {
            if ((results == null) || (results.length != 3)) {
                mCallback.onLoadFailed();
                return;
            }

            final Message message = (Message) results[0];
            final Body body = (Body) results[1];
            final Account account = (Account) results[2];
            if ((message == null) || (body == null) || (account == null)) {
                mCallback.onLoadFailed();
                return;
            }

            setAccount(account);
            mCallback.onMessageLoaded(message, body);
            mMessageLoaded = true;
        }
    }

    private interface AttachmentLoadedCallback {
        /**
         * Handles completion of the loading of a set of attachments.
         * Callback will always happen on the main thread.
         */
        void onAttachmentLoaded(Attachment[] attachment);
    }

    private void loadAttachments(
            final long messageId,
            final Account account,
            final AttachmentLoadedCallback callback) {
        new EmailAsyncTask<Void, Void, Attachment[]>(mTaskTracker) {
            @Override
            protected Attachment[] doInBackground(Void... params) {
                return Attachment.restoreAttachmentsWithMessageId(MessageCompose.this, messageId);
            }

            @Override
            protected void onPostExecute(Attachment[] attachments) {
                if (attachments == null) {
                    attachments = new Attachment[0];
                }
                callback.onAttachmentLoaded(attachments);
            }
        }.executeParallel((Void[]) null);
    }

    @Override
    public void onFocusChange(View view, boolean focused) {
        if (focused) {
            switch (view.getId()) {
                case R.id.message_content:
                    // When focusing on the message content via tabbing to it, or other means of
                    // auto focusing, move the cursor to the end of the body (before the signature).
                    if (mMessageContentView.getSelectionStart() == 0
                            && mMessageContentView.getSelectionEnd() == 0) {
                        // There is no way to determine if the focus change was programmatic or due
                        // to keyboard event, or if it was due to a tap/restore. Use a best-guess
                        // by using the fact that auto-focus/keyboard tabs set the selection to 0.
                        setMessageContentSelection(getAccountSignature(mAccount));
                    }
            }
        }
    }

    private static void addAddresses(MultiAutoCompleteTextView view, Address[] addresses) {
        if (addresses == null) {
            return;
        }
        for (Address address : addresses) {
            addAddress(view, address.toString());
        }
    }

    private static void addAddresses(MultiAutoCompleteTextView view, String[] addresses) {
        if (addresses == null) {
            return;
        }
        for (String oneAddress : addresses) {
            addAddress(view, oneAddress);
        }
    }

    private static void addAddress(MultiAutoCompleteTextView view, String address) {
        view.append(address + ", ");
    }

    private static String getPackedAddresses(TextView view) {
        Address[] addresses = Address.parse(view.getText().toString().trim());
        return Address.pack(addresses);
    }

    private static Address[] getAddresses(TextView view) {
        Address[] addresses = Address.parse(view.getText().toString().trim());
        return addresses;
    }

    /*
     * Computes a short string indicating the destination of the message based on To, Cc, Bcc.
     * If only one address appears, returns the friendly form of that address.
     * Otherwise returns the friendly form of the first address appended with "and N others".
     */
    private String makeDisplayName(String packedTo, String packedCc, String packedBcc) {
        Address first = null;
        int nRecipients = 0;
        for (String packed: new String[] {packedTo, packedCc, packedBcc}) {
            Address[] addresses = Address.unpack(packed);
            nRecipients += addresses.length;
            if (first == null && addresses.length > 0) {
                first = addresses[0];
            }
        }
        if (nRecipients == 0) {
            return "";
        }
        String friendly = first.toFriendly();
        if (nRecipients == 1) {
            return friendly;
        }
        return this.getString(R.string.message_compose_display_name, friendly, nRecipients - 1);
    }

    private ContentValues getUpdateContentValues(Message message) {
        ContentValues values = new ContentValues();
        values.put(MessageColumns.TIMESTAMP, message.mTimeStamp);
        values.put(MessageColumns.FROM_LIST, message.mFrom);
        values.put(MessageColumns.TO_LIST, message.mTo);
        values.put(MessageColumns.CC_LIST, message.mCc);
        values.put(MessageColumns.BCC_LIST, message.mBcc);
        values.put(MessageColumns.SUBJECT, message.mSubject);
        values.put(MessageColumns.DISPLAY_NAME, message.mDisplayName);
        values.put(MessageColumns.FLAG_READ, message.mFlagRead);
        values.put(MessageColumns.FLAG_LOADED, message.mFlagLoaded);
        values.put(MessageColumns.FLAG_ATTACHMENT, message.mFlagAttachment);
        values.put(MessageColumns.FLAGS, message.mFlags);
        return values;
    }

    /**
     * Updates the given message using values from the compose UI.
     *
     * @param message The message to be updated.
     * @param account the account (used to obtain From: address).
     * @param hasAttachments true if it has one or more attachment.
     * @param sending set true if the message is about to sent, in which case we perform final
     *        clean up;
     */
    private void updateMessage(Message message, Account account, boolean hasAttachments,
            boolean sending) {
        if (message.mMessageId == null || message.mMessageId.length() == 0) {
            message.mMessageId = Utility.generateMessageId();
        }
        message.mTimeStamp = System.currentTimeMillis();
        message.mFrom = new Address(account.getEmailAddress(), account.getSenderName()).pack();
        message.mTo = getPackedAddresses(mToView);
        message.mCc = getPackedAddresses(mCcView);
        message.mBcc = getPackedAddresses(mBccView);
        message.mSubject = mSubjectView.getText().toString();
        message.mText = mMessageContentView.getText().toString();
        message.mAccountKey = account.mId;
        message.mDisplayName = makeDisplayName(message.mTo, message.mCc, message.mBcc);
        message.mFlagRead = true;
        message.mFlagLoaded = Message.FLAG_LOADED_COMPLETE;
        message.mFlagAttachment = hasAttachments;
        // Use the Intent to set flags saying this message is a reply or a forward and save the
        // unique id of the source message
        if (mSource != null && mQuotedTextBar.getVisibility() == View.VISIBLE) {
            // If the quote bar is visible; this must either be a reply or forward
            message.mSourceKey = mSource.mId;
            // Get the body of the source message here
            message.mHtmlReply = mSource.mHtml;
            message.mTextReply = mSource.mText;
            String fromAsString = Address.unpackToString(mSource.mFrom);
            if (isForward()) {
                message.mFlags |= Message.FLAG_TYPE_FORWARD;
                String subject = mSource.mSubject;
                String to = Address.unpackToString(mSource.mTo);
                String cc = Address.unpackToString(mSource.mCc);
                message.mIntroText =
                    getString(R.string.message_compose_fwd_header_fmt, subject, fromAsString,
                            to != null ? to : "", cc != null ? cc : "");
            } else {
                message.mFlags |= Message.FLAG_TYPE_REPLY;
                message.mIntroText =
                    getString(R.string.message_compose_reply_header_fmt, fromAsString);
            }
        }

        if (includeQuotedText()) {
            message.mFlags &= ~Message.FLAG_NOT_INCLUDE_QUOTED_TEXT;
        } else {
            message.mFlags |= Message.FLAG_NOT_INCLUDE_QUOTED_TEXT;
            if (sending) {
                // If we are about to send a message, and not including the original message,
                // clear the related field.
                // We can't do this until the last minutes, so that the user can change their
                // mind later and want to include it again.
                mDraft.mIntroText = null;
                mDraft.mTextReply = null;
                mDraft.mHtmlReply = null;
                mDraft.mSourceKey = 0;
                mDraft.mFlags &= ~Message.FLAG_TYPE_MASK;
            }
        }
    }

    private class SendOrSaveMessageTask extends EmailAsyncTask<Void, Void, Long> {
        private final boolean mSend;
        private final long mTaskId;

        /** A context that will survive even past activity destruction. */
        private final Context mContext;

        public SendOrSaveMessageTask(long taskId, boolean send) {
            super(null /* DO NOT cancel in onDestroy */);
            if (send && ActivityManager.isUserAMonkey()) {
                Log.d(Logging.LOG_TAG, "Inhibiting send while monkey is in charge.");
                send = false;
            }
            mTaskId = taskId;
            mSend = send;
            mContext = getApplicationContext();

            sActiveSaveTasks.put(mTaskId, this);
        }

        @Override
        protected Long doInBackground(Void... params) {
            synchronized (mDraft) {
                updateMessage(mDraft, mAccount, mAttachments.size() > 0, mSend);
                ContentResolver resolver = getContentResolver();
                if (mDraft.isSaved()) {
                    // Update the message
                    Uri draftUri =
                        ContentUris.withAppendedId(Message.SYNCED_CONTENT_URI, mDraft.mId);
                    resolver.update(draftUri, getUpdateContentValues(mDraft), null, null);
                    // Update the body
                    ContentValues values = new ContentValues();
                    values.put(BodyColumns.TEXT_CONTENT, mDraft.mText);
                    values.put(BodyColumns.TEXT_REPLY, mDraft.mTextReply);
                    values.put(BodyColumns.HTML_REPLY, mDraft.mHtmlReply);
                    values.put(BodyColumns.INTRO_TEXT, mDraft.mIntroText);
                    values.put(BodyColumns.SOURCE_MESSAGE_KEY, mDraft.mSourceKey);
                    Body.updateBodyWithMessageId(MessageCompose.this, mDraft.mId, values);
                } else {
                    // mDraft.mId is set upon return of saveToMailbox()
                    mController.saveToMailbox(mDraft, Mailbox.TYPE_DRAFTS);
                }
                // For any unloaded attachment, set the flag saying we need it loaded
                boolean hasUnloadedAttachments = false;
                for (Attachment attachment : mAttachments) {
                    if (attachment.mContentUri == null &&
                            ((attachment.mFlags & Attachment.FLAG_SMART_FORWARD) == 0)) {
                        attachment.mFlags |= Attachment.FLAG_DOWNLOAD_FORWARD;
                        hasUnloadedAttachments = true;
                        if (Email.DEBUG) {
                            Log.d(Logging.LOG_TAG,
                                    "Requesting download of attachment #" + attachment.mId);
                        }
                    }
                    // Make sure the UI version of the attachment has the now-correct id; we will
                    // use the id again when coming back from picking new attachments
                    if (!attachment.isSaved()) {
                        // this attachment is new so save it to DB.
                        attachment.mMessageKey = mDraft.mId;
                        attachment.save(MessageCompose.this);
                    } else if (attachment.mMessageKey != mDraft.mId) {
                        // We clone the attachment and save it again; otherwise, it will
                        // continue to point to the source message.  From this point forward,
                        // the attachments will be independent of the original message in the
                        // database; however, we still need the message on the server in order
                        // to retrieve unloaded attachments
                        attachment.mMessageKey = mDraft.mId;
                        ContentValues cv = attachment.toContentValues();
                        cv.put(Attachment.FLAGS, attachment.mFlags);
                        cv.put(Attachment.MESSAGE_KEY, mDraft.mId);
                        getContentResolver().insert(Attachment.CONTENT_URI, cv);
                    }
                }

                if (mSend) {
                    // Let the user know if message sending might be delayed by background
                    // downlading of unloaded attachments
                    if (hasUnloadedAttachments) {
                        Utility.showToast(MessageCompose.this,
                                R.string.message_view_attachment_background_load);
                    }
                    mController.sendMessage(mDraft.mId, mDraft.mAccountKey);

                    ArrayList<CharSequence> addressTexts = new ArrayList<CharSequence>();
                    addressTexts.add(mToView.getText());
                    addressTexts.add(mCcView.getText());
                    addressTexts.add(mBccView.getText());
                    DataUsageStatUpdater updater = new DataUsageStatUpdater(mContext);
                    updater.updateWithRfc822Address(addressTexts);
                }
                return mDraft.mId;
            }
        }

        @Override
        protected void onPostExecute(Long draftId) {
            // Note that send or save tasks are always completed, even if the activity
            // finishes earlier.
            sActiveSaveTasks.remove(mTaskId);
            // Don't display the toast if the user is just changing the orientation
            if (!mSend && (getChangingConfigurations() & ActivityInfo.CONFIG_ORIENTATION) == 0) {
                Toast.makeText(mContext, R.string.message_saved_toast, Toast.LENGTH_LONG).show();
            }
        }
    }

    /**
     * Send or save a message:
     * - out of the UI thread
     * - write to Drafts
     * - if send, invoke Controller.sendMessage()
     * - when operation is complete, display toast
     */
    private void sendOrSaveMessage(boolean send) {
        if (!mMessageLoaded) {
            Log.w(Logging.LOG_TAG,
                    "Attempted to save draft message prior to the state being fully loaded");
            return;
        }
        synchronized (sActiveSaveTasks) {
            mLastSaveTaskId = sNextSaveTaskId++;

            SendOrSaveMessageTask task = new SendOrSaveMessageTask(mLastSaveTaskId, send);

            // Ensure the tasks are executed serially so that rapid scheduling doesn't result
            // in inconsistent data.
            task.executeSerial();
        }
   }

    private void saveIfNeeded() {
        if (!mDraftNeedsSaving) {
            return;
        }
        setDraftNeedsSaving(false);
        sendOrSaveMessage(false);
    }

    /**
     * Checks whether all the email addresses listed in TO, CC, BCC are valid.
     */
    @VisibleForTesting
    boolean isAddressAllValid() {
        for (TextView view : new TextView[]{mToView, mCcView, mBccView}) {
            String addresses = view.getText().toString().trim();
            if (!Address.isAllValid(addresses)) {
                view.setError(getString(R.string.message_compose_error_invalid_email));
                return false;
            }
        }
        return true;
    }

    private void onSend() {
        if (!isAddressAllValid()) {
            Toast.makeText(this, getString(R.string.message_compose_error_invalid_email),
                           Toast.LENGTH_LONG).show();
        } else if (getAddresses(mToView).length == 0 &&
                getAddresses(mCcView).length == 0 &&
                getAddresses(mBccView).length == 0) {
            mToView.setError(getString(R.string.message_compose_error_no_recipients));
            Toast.makeText(this, getString(R.string.message_compose_error_no_recipients),
                    Toast.LENGTH_LONG).show();
        } else {
            sendOrSaveMessage(true);
            setDraftNeedsSaving(false);
            finish();
        }
    }

    private void onDiscard() {
        DeleteMessageConfirmationDialog.newInstance(1, null).show(getFragmentManager(), "dialog");
    }

    /**
     * Called when ok on the "discard draft" dialog is pressed.  Actually delete the draft.
     */
    @Override
    public void onDeleteMessageConfirmationDialogOkPressed() {
        if (mDraft.mId > 0) {
            // By the way, we can't pass the message ID from onDiscard() to here (using a
            // dialog argument or whatever), because you can rotate the screen when the dialog is
            // shown, and during rotation we save & restore the draft.  If it's the
            // first save, we give it an ID at this point for the first time (and last time).
            // Which means it's possible for a draft to not have an ID in onDiscard(),
            // but here.
            mController.deleteMessage(mDraft.mId);
        }
        Utility.showToast(MessageCompose.this, R.string.message_discarded_toast);
        setDraftNeedsSaving(false);
        finish();
    }

    /**
     * Handles an explicit user-initiated action to save a draft.
     */
    private void onSave() {
        saveIfNeeded();
    }

    private void showCcBccFieldsIfFilled() {
        if ((mCcView.length() > 0) || (mBccView.length() > 0)) {
            showCcBccFields();
        }
    }

    private void showCcBccFields() {
        mCcBccContainer.setVisibility(View.VISIBLE);
        UiUtilities.setVisibilitySafe(this, R.id.add_cc_bcc, View.INVISIBLE);
    }

    /**
     * Kick off a picker for whatever kind of MIME types we'll accept and let Android take over.
     */
    private void onAddAttachment() {
        Intent i = new Intent(Intent.ACTION_GET_CONTENT);
        i.addCategory(Intent.CATEGORY_OPENABLE);
        i.setType(AttachmentUtilities.ACCEPTABLE_ATTACHMENT_SEND_UI_TYPES[0]);
        startActivityForResult(
                Intent.createChooser(i, getString(R.string.choose_attachment_dialog_title)),
                ACTIVITY_REQUEST_PICK_ATTACHMENT);
    }

    private Attachment loadAttachmentInfo(Uri uri) {
        long size = -1;
        ContentResolver contentResolver = getContentResolver();

        // Load name & size independently, because not all providers support both
        final String name = Utility.getContentFileName(this, uri);

        Cursor metadataCursor = contentResolver.query(uri, ATTACHMENT_META_SIZE_PROJECTION,
                null, null, null);
        if (metadataCursor != null) {
            try {
                if (metadataCursor.moveToFirst()) {
                    size = metadataCursor.getLong(ATTACHMENT_META_SIZE_COLUMN_SIZE);
                }
            } finally {
                metadataCursor.close();
            }
        }

        // When the size is not provided, we need to determine it locally.
        if (size < 0) {
            // if the URI is a file: URI, ask file system for its size
            if ("file".equalsIgnoreCase(uri.getScheme())) {
                String path = uri.getPath();
                if (path != null) {
                    File file = new File(path);
                    size = file.length();  // Returns 0 for file not found
                }
            }

            if (size <= 0) {
                // The size was not measurable;  This attachment is not safe to use.
                // Quick hack to force a relevant error into the UI
                // TODO: A proper announcement of the problem
                size = AttachmentUtilities.MAX_ATTACHMENT_UPLOAD_SIZE + 1;
            }
        }

        Attachment attachment = new Attachment();
        attachment.mFileName = name;
        attachment.mContentUri = uri.toString();
        attachment.mSize = size;
        attachment.mMimeType = AttachmentUtilities.inferMimeTypeForUri(this, uri);
        return attachment;
    }

    private void addAttachment(Attachment attachment) {
        // Before attaching the attachment, make sure it meets any other pre-attach criteria
        if (attachment.mSize > AttachmentUtilities.MAX_ATTACHMENT_UPLOAD_SIZE) {
            Toast.makeText(this, R.string.message_compose_attachment_size, Toast.LENGTH_LONG)
                    .show();
            return;
        }

        mAttachments.add(attachment);
        updateAttachmentUi();
    }

    private void updateAttachmentUi() {
        mAttachmentContentView.removeAllViews();

        for (Attachment attachment : mAttachments) {
            // Note: allowDelete is set in two cases:
            // 1. First time a message (w/ attachments) is forwarded,
            //    where action == ACTION_FORWARD
            // 2. 1 -> Save -> Reopen
            //    but FLAG_SMART_FORWARD is already set at 1.
            // Even if the account supports smart-forward, attachments added
            // manually are still removable.
            final boolean allowDelete = (attachment.mFlags & Attachment.FLAG_SMART_FORWARD) == 0;

            View view = getLayoutInflater().inflate(R.layout.message_compose_attachment,
                    mAttachmentContentView, false);
            TextView nameView = UiUtilities.getView(view, R.id.attachment_name);
            ImageButton delete = UiUtilities.getView(view, R.id.attachment_delete);
            TextView sizeView = UiUtilities.getView(view, R.id.attachment_size);

            nameView.setText(attachment.mFileName);
            sizeView.setText(UiUtilities.formatSize(this, attachment.mSize));
            if (allowDelete) {
                delete.setOnClickListener(this);
                delete.setTag(view);
            } else {
                delete.setVisibility(View.INVISIBLE);
            }
            view.setTag(attachment);
            mAttachmentContentView.addView(view);
        }
        updateAttachmentContainer();
    }

    private void updateAttachmentContainer() {
        mAttachmentContainer.setVisibility(mAttachmentContentView.getChildCount() == 0
                ? View.GONE : View.VISIBLE);
    }

    private void addAttachmentFromUri(Uri uri) {
        addAttachment(loadAttachmentInfo(uri));
    }

    /**
     * Same as {@link #addAttachmentFromUri}, but does the mime-type check against
     * {@link AttachmentUtilities#ACCEPTABLE_ATTACHMENT_SEND_INTENT_TYPES}.
     */
    private void addAttachmentFromSendIntent(Uri uri) {
        final Attachment attachment = loadAttachmentInfo(uri);
        final String mimeType = attachment.mMimeType;
        if (!TextUtils.isEmpty(mimeType) && MimeUtility.mimeTypeMatches(mimeType,
                AttachmentUtilities.ACCEPTABLE_ATTACHMENT_SEND_INTENT_TYPES)) {
            addAttachment(attachment);
        }
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        if (data == null) {
            return;
        }
        addAttachmentFromUri(data.getData());
        setDraftNeedsSaving(true);
    }

    private boolean includeQuotedText() {
        return mIncludeQuotedTextCheckBox.isChecked();
    }

    public void onClick(View view) {
        if (handleCommand(view.getId())) {
            return;
        }
        switch (view.getId()) {
            case R.id.attachment_delete:
                onDeleteAttachmentIconClicked(view);
                break;
        }
    }

    private void setIncludeQuotedText(boolean include, boolean updateNeedsSaving) {
        mIncludeQuotedTextCheckBox.setChecked(include);
        mQuotedText.setVisibility(mIncludeQuotedTextCheckBox.isChecked()
                ? View.VISIBLE : View.GONE);
        if (updateNeedsSaving) {
            setDraftNeedsSaving(true);
        }
    }

    private void onDeleteAttachmentIconClicked(View delButtonView) {
        View attachmentView = (View) delButtonView.getTag();
        Attachment attachment = (Attachment) attachmentView.getTag();
        deleteAttachment(mAttachments, attachment);
        updateAttachmentUi();
        setDraftNeedsSaving(true);
    }

    /**
     * Removes an attachment from the current message.
     * If the attachment has previous been saved in the db (i.e. this is a draft message which
     * has previously been saved), then the draft is deleted from the db.
     *
     * This does not update the UI to remove the attachment view.
     * @param attachments the list of attachments to delete from. Injected for tests.
     * @param attachment the attachment to delete
     */
    private void deleteAttachment(List<Attachment> attachments, Attachment attachment) {
        attachments.remove(attachment);
        if ((attachment.mMessageKey == mDraft.mId) && attachment.isSaved()) {
            final long attachmentId = attachment.mId;
            EmailAsyncTask.runAsyncParallel(new Runnable() {
                @Override
                public void run() {
                    mController.deleteAttachment(attachmentId);
                }
            });
        }
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        if (handleCommand(item.getItemId())) {
            return true;
        }
        return super.onOptionsItemSelected(item);
    }

    private boolean handleCommand(int viewId) {
        switch (viewId) {
        case android.R.id.home:
            onActionBarHomePressed();
            return true;
        case R.id.send:
            onSend();
            return true;
        case R.id.save:
            onSave();
            return true;
        case R.id.discard:
            onDiscard();
            return true;
        case R.id.include_quoted_text:
            // The checkbox is already toggled at this point.
            setIncludeQuotedText(mIncludeQuotedTextCheckBox.isChecked(), true);
            return true;
        case R.id.add_cc_bcc:
            showCcBccFields();
            return true;
        case R.id.add_attachment:
            onAddAttachment();
            return true;
        }
        return false;
    }

    private void onActionBarHomePressed() {
        finish();
        if (isOpenedFromWithinApp()) {
            // If opend from within the app, we just close it.
        } else {
            // Otherwise, need to open the main screen.  Let Welcome do that.
            Welcome.actionStart(this);
        }
    }

    private void setAction(String action) {
        if (Objects.equal(action, mAction)) {
            return;
        }

        mAction = action;
        onActionChanged();
    }

    /**
     * Handles changing from reply/reply all/forward states. Note: this activity cannot transition
     * from a standard compose state to any of the other three states.
     */
    private void onActionChanged() {
        if (!hasSourceMessage()) {
            return;
        }

        processSourceMessage(mSource, mAccount);

        // Note that the attachments might not be loaded yet, but this will safely noop
        // if that's the case, and the attachments will be processed when they load.
        if (processSourceMessageAttachments(mAttachments, mSourceAttachments, isForward())) {
            updateAttachmentUi();
            setDraftNeedsSaving(true);
        }

        updateActionSelector();
    }

    /**
     * Updates UI components that allows the user to switch between reply/reply all/forward.
     */
    private void updateActionSelector() {
        // Update reply/reply all/forward switcher.
        if (shouldUseActionTabs()) {
            // Tab-based mode switching.
            ActionBar actionBar = getActionBar();

            if (actionBar.getTabCount() > 0) {
                actionBar.removeAllTabs();
            }
            createAndAddTab(R.string.reply_action, ACTION_REPLY);
            createAndAddTab(R.string.reply_all_action, ACTION_REPLY_ALL);
            createAndAddTab(R.string.forward_action, ACTION_FORWARD);

            actionBar.setDisplayShowTitleEnabled(false);
            try { // STOPSHIP workaround b/4520517
                actionBar.setNavigationMode(ActionBar.NAVIGATION_MODE_TABS);
            } catch (RuntimeException ignore) {
            }
        } else {
            // Spinner based mode switching.
            if (mActionSpinnerAdapter == null) {
                mActionSpinnerAdapter = new ActionSpinnerAdapter(this);
                mActionSpinner.setAdapter(mActionSpinnerAdapter);
                mActionSpinner.setOnItemSelectedListener(new OnItemSelectedListener() {
                    @Override
                    public void onItemSelected(
                            AdapterView<?> parent, View view, int position, long id) {
                        setAction(mActionSpinnerAdapter.getAction(position));
                    }

                    @Override
                    public void onNothingSelected(AdapterView<?> parent) {
                        // Should not happen.
                    }
                });
            }
            int position = mActionSpinnerAdapter.getPosition(mAction);
            mActionSpinner.setSelection(position);
            mActionSpinner.setVisibility(View.VISIBLE);
        }
    }

    private final TabListener ACTION_TAB_LISTENER = new TabListener() {
        @Override public void onTabReselected(Tab tab, FragmentTransaction ft) {}
        @Override public void onTabUnselected(Tab tab, FragmentTransaction ft) {}

        @Override
        public void onTabSelected(Tab tab, FragmentTransaction ft) {
            String action = (String) tab.getTag();
            setAction(action);
        }
    };

    private static class ActionSpinnerAdapter extends ArrayAdapter<String> {
        public ActionSpinnerAdapter(final Context context) {
            super(context,
                    android.R.layout.simple_spinner_dropdown_item,
                    android.R.id.text1,
                    Lists.newArrayList(ACTION_REPLY, ACTION_REPLY_ALL, ACTION_FORWARD));
        }

        @Override
        public View getDropDownView(int position, View convertView, ViewGroup parent) {
            View result = super.getDropDownView(position, convertView, parent);
            ((TextView) result.findViewById(android.R.id.text1)).setText(getDisplayValue(position));
            return result;
        }

        @Override
        public View getView(int position, View convertView, ViewGroup parent) {
            View result = super.getView(position, convertView, parent);
            ((TextView) result.findViewById(android.R.id.text1)).setText(getDisplayValue(position));
            return result;
        }

        private String getDisplayValue(int position) {
            switch (position) {
                case 0:
                    return getContext().getString(R.string.reply_action);
                case 1:
                    return getContext().getString(R.string.reply_all_action);
                case 2:
                    return getContext().getString(R.string.forward_action);
                default:
                    throw new IllegalArgumentException("Invalid action type for spinner");
            }
        }

        public static String getAction(int position) {
            switch (position) {
                case 0:
                    return ACTION_REPLY;
                case 1:
                    return ACTION_REPLY_ALL;
                case 2:
                    return ACTION_FORWARD;
                default:
                    throw new IllegalArgumentException("Invalid action type for spinner");
            }
        }

    }

    private Tab createAndAddTab(int labelResource, final String action) {
        ActionBar.Tab tab = getActionBar().newTab();
        boolean selected = mAction.equals(action);
        tab.setTag(action);
        tab.setText(getString(labelResource));
        tab.setTabListener(ACTION_TAB_LISTENER);
        getActionBar().addTab(tab, selected);
        return tab;
    }

    private boolean shouldUseActionTabs() {
        return getResources().getBoolean(R.bool.message_compose_action_tabs);
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        super.onCreateOptionsMenu(menu);
        getMenuInflater().inflate(R.menu.message_compose_option, menu);
        return true;
    }

    @Override
    public boolean onPrepareOptionsMenu(Menu menu) {
        menu.findItem(R.id.save).setEnabled(mDraftNeedsSaving);
        return true;
    }

    /**
     * Set a message body and a signature when the Activity is launched.
     *
     * @param text the message body
     */
    @VisibleForTesting
    void setInitialComposeText(CharSequence text, String signature) {
        mMessageContentView.setText("");
        int textLength = 0;
        if (text != null) {
            mMessageContentView.append(text);
            textLength = text.length();
        }
        if (!TextUtils.isEmpty(signature)) {
            if (textLength == 0 || text.charAt(textLength - 1) != '\n') {
                mMessageContentView.append("\n");
            }
            mMessageContentView.append(signature);

            // Reset cursor to right before the signature.
            mMessageContentView.setSelection(textLength);
        }
    }

    /**
     * Fill all the widgets with the content found in the Intent Extra, if any.
     *
     * Note that we don't actually check the intent action  (typically VIEW, SENDTO, or SEND).
     * There is enough overlap in the definitions that it makes more sense to simply check for
     * all available data and use as much of it as possible.
     *
     * With one exception:  EXTRA_STREAM is defined as only valid for ACTION_SEND.
     *
     * @param intent the launch intent
     */
    @VisibleForTesting
    void initFromIntent(Intent intent) {

        setAccount(intent);

        // First, add values stored in top-level extras
        String[] extraStrings = intent.getStringArrayExtra(Intent.EXTRA_EMAIL);
        if (extraStrings != null) {
            addAddresses(mToView, extraStrings);
        }
        extraStrings = intent.getStringArrayExtra(Intent.EXTRA_CC);
        if (extraStrings != null) {
            addAddresses(mCcView, extraStrings);
        }
        extraStrings = intent.getStringArrayExtra(Intent.EXTRA_BCC);
        if (extraStrings != null) {
            addAddresses(mBccView, extraStrings);
        }
        String extraString = intent.getStringExtra(Intent.EXTRA_SUBJECT);
        if (extraString != null) {
            mSubjectView.setText(extraString);
        }

        // Next, if we were invoked with a URI, try to interpret it
        // We'll take two courses here.  If it's mailto:, there is a specific set of rules
        // that define various optional fields.  However, for any other scheme, we'll simply
        // take the entire scheme-specific part and interpret it as a possible list of addresses.
        final Uri dataUri = intent.getData();
        if (dataUri != null) {
            if ("mailto".equals(dataUri.getScheme())) {
                initializeFromMailTo(dataUri.toString());
            } else {
                String toText = dataUri.getSchemeSpecificPart();
                if (toText != null) {
                    addAddresses(mToView, toText.split(","));
                }
            }
        }

        // Next, fill in the plaintext (note, this will override mailto:?body=)
        CharSequence text = intent.getCharSequenceExtra(Intent.EXTRA_TEXT);
        setInitialComposeText(text, getAccountSignature(mAccount));

        // Next, convert EXTRA_STREAM into an attachment
        if (Intent.ACTION_SEND.equals(mAction) && intent.hasExtra(Intent.EXTRA_STREAM)) {
            Uri uri = (Uri) intent.getParcelableExtra(Intent.EXTRA_STREAM);
            if (uri != null) {
                addAttachmentFromSendIntent(uri);
            }
        }

        if (Intent.ACTION_SEND_MULTIPLE.equals(mAction)
                && intent.hasExtra(Intent.EXTRA_STREAM)) {
            ArrayList<Parcelable> list = intent.getParcelableArrayListExtra(Intent.EXTRA_STREAM);
            if (list != null) {
                for (Parcelable parcelable : list) {
                    Uri uri = (Uri) parcelable;
                    if (uri != null) {
                        addAttachmentFromSendIntent(uri);
                    }
                }
            }
        }

        // Finally - expose fields that were filled in but are normally hidden, and set focus
        showCcBccFieldsIfFilled();
        setNewMessageFocus();
    }

    /**
     * When we are launched with an intent that includes a mailto: URI, we can actually
     * gather quite a few of our message fields from it.
     *
     * @param mailToString the href (which must start with "mailto:").
     */
    private void initializeFromMailTo(String mailToString) {

        // Chop up everything between mailto: and ? to find recipients
        int index = mailToString.indexOf("?");
        int length = "mailto".length() + 1;
        String to;
        try {
            // Extract the recipient after mailto:
            if (index == -1) {
                to = decode(mailToString.substring(length));
            } else {
                to = decode(mailToString.substring(length, index));
            }
            addAddresses(mToView, to.split(" ,"));
        } catch (UnsupportedEncodingException e) {
            Log.e(Logging.LOG_TAG, e.getMessage() + " while decoding '" + mailToString + "'");
        }

        // Extract the other parameters

        // We need to disguise this string as a URI in order to parse it
        Uri uri = Uri.parse("foo://" + mailToString);

        List<String> cc = uri.getQueryParameters("cc");
        addAddresses(mCcView, cc.toArray(new String[cc.size()]));

        List<String> otherTo = uri.getQueryParameters("to");
        addAddresses(mCcView, otherTo.toArray(new String[otherTo.size()]));

        List<String> bcc = uri.getQueryParameters("bcc");
        addAddresses(mBccView, bcc.toArray(new String[bcc.size()]));

        List<String> subject = uri.getQueryParameters("subject");
        if (subject.size() > 0) {
            mSubjectView.setText(subject.get(0));
        }

        List<String> body = uri.getQueryParameters("body");
        if (body.size() > 0) {
            setInitialComposeText(body.get(0), getAccountSignature(mAccount));
        }
    }

    private String decode(String s) throws UnsupportedEncodingException {
        return URLDecoder.decode(s, "UTF-8");
    }

    /**
     * Displays quoted text from the original email
     */
    private void displayQuotedText(String textBody, String htmlBody) {
        // Only use plain text if there is no HTML body
        boolean plainTextFlag = TextUtils.isEmpty(htmlBody);
        String text = plainTextFlag ? textBody : htmlBody;
        if (text != null) {
            text = plainTextFlag ? EmailHtmlUtil.escapeCharacterToDisplay(text) : text;
            // TODO: re-enable EmailHtmlUtil.resolveInlineImage() for HTML
            //    EmailHtmlUtil.resolveInlineImage(getContentResolver(), mAccount,
            //                                     text, message, 0);
            mQuotedTextBar.setVisibility(View.VISIBLE);
            if (mQuotedText != null) {
                mQuotedText.loadDataWithBaseURL("email://", text, "text/html", "utf-8", null);
            }
        }
    }

    /**
     * Given a packed address String, the address of our sending account, a view, and a list of
     * addressees already added to other addressing views, adds unique addressees that don't
     * match our address to the passed in view
     */
    private static boolean safeAddAddresses(String addrs, String ourAddress,
            MultiAutoCompleteTextView view, ArrayList<Address> addrList) {
        boolean added = false;
        for (Address address : Address.unpack(addrs)) {
            // Don't send to ourselves or already-included addresses
            if (!address.getAddress().equalsIgnoreCase(ourAddress) && !addrList.contains(address)) {
                addrList.add(address);
                addAddress(view, address.toString());
                added = true;
            }
        }
        return added;
    }

    /**
     * Set up the to and cc views properly for the "reply" and "replyAll" cases.  What's important
     * is that we not 1) send to ourselves, and 2) duplicate addressees.
     * @param message the message we're replying to
     * @param account the account we're sending from
     * @param replyAll whether this is a replyAll (vs a reply)
     */
    @VisibleForTesting
    void setupAddressViews(Message message, Account account, boolean replyAll) {
        // Start clean.
        clearAddressViews();

        /*
         * If a reply-to was included with the message use that, otherwise use the from
         * or sender address.
         */
        Address[] replyToAddresses = Address.unpack(message.mReplyTo);
        if (replyToAddresses.length == 0) {
            replyToAddresses = Address.unpack(message.mFrom);
        }
        addAddresses(mToView, replyToAddresses);

        if (replyAll) {
            // Keep a running list of addresses we're sending to
            ArrayList<Address> allAddresses = new ArrayList<Address>();
            String ourAddress = account.mEmailAddress;

            for (Address address: replyToAddresses) {
                allAddresses.add(address);
            }

            safeAddAddresses(message.mTo, ourAddress, mCcView, allAddresses);
            safeAddAddresses(message.mCc, ourAddress, mCcView, allAddresses);
        }
        showCcBccFieldsIfFilled();
    }

    private void clearAddressViews() {
        mToView.setText("");
        mCcView.setText("");
        mBccView.setText("");
    }

    /**
     * Pull out the parts of the now loaded source message and apply them to the new message
     * depending on the type of message being composed.
     */
    @VisibleForTesting
    void processSourceMessage(Message message, Account account) {
        setDraftNeedsSaving(true);
        final String subject = message.mSubject;
        if (ACTION_REPLY.equals(mAction) || ACTION_REPLY_ALL.equals(mAction)) {
            setupAddressViews(message, account, ACTION_REPLY_ALL.equals(mAction));
            if (subject != null && !subject.toLowerCase().startsWith("re:")) {
                mSubjectView.setText("Re: " + subject);
            } else {
                mSubjectView.setText(subject);
            }
            displayQuotedText(message.mText, message.mHtml);
            setIncludeQuotedText(true, false);
        } else if (ACTION_FORWARD.equals(mAction)) {
            clearAddressViews();
            mSubjectView.setText(subject != null && !subject.toLowerCase().startsWith("fwd:") ?
                    "Fwd: " + subject : subject);
            displayQuotedText(message.mText, message.mHtml);
            setIncludeQuotedText(true, false);
        } else {
            Log.w(Logging.LOG_TAG, "Unexpected action for a call to processSourceMessage "
                    + mAction);
        }
        showCcBccFieldsIfFilled();
        setNewMessageFocus();
    }

    /**
     * Processes the source attachments and ensures they're either included or excluded from
     * a list of active attachments. This can be used to add attachments for a forwarded message, or
     * to remove them if going from a "Forward" to a "Reply"
     * Uniqueness is based on filename.
     *
     * @param current the list of active attachments on the current message. Injected for tests.
     * @param sourceAttachments the list of attachments related with the source message. Injected
     *     for tests.
     * @param include whether or not the sourceMessages should be included or excluded from the
     *     current list of active attachments
     * @return whether or not the current attachments were modified
     */
    @VisibleForTesting
    boolean processSourceMessageAttachments(
            List<Attachment> current, List<Attachment> sourceAttachments, boolean include) {

        // Build a map of filename to the active attachments.
        HashMap<String, Attachment> currentNames = new HashMap<String, Attachment>();
        for (Attachment attachment : current) {
            currentNames.put(attachment.mFileName, attachment);
        }

        boolean dirty = false;
        if (include) {
            // Needs to make sure it's in the list.
            for (Attachment attachment : sourceAttachments) {
                if (!currentNames.containsKey(attachment.mFileName)) {
                    current.add(attachment);
                    dirty = true;
                }
            }
        } else {
            // Need to remove the source attachments.
            HashSet<String> sourceNames = new HashSet<String>();
            for (Attachment attachment : sourceAttachments) {
                if (currentNames.containsKey(attachment.mFileName)) {
                    deleteAttachment(current, currentNames.get(attachment.mFileName));
                    dirty = true;
                }
            }
        }

        return dirty;
    }

    /**
     * Set a cursor to the end of a body except a signature.
     */
    @VisibleForTesting
    void setMessageContentSelection(String signature) {
        int selection = mMessageContentView.length();
        if (!TextUtils.isEmpty(signature)) {
            int signatureLength = signature.length();
            int estimatedSelection = selection - signatureLength;
            if (estimatedSelection >= 0) {
                CharSequence text = mMessageContentView.getText();
                int i = 0;
                while (i < signatureLength
                       && text.charAt(estimatedSelection + i) == signature.charAt(i)) {
                    ++i;
                }
                if (i == signatureLength) {
                    selection = estimatedSelection;
                    while (selection > 0 && text.charAt(selection - 1) == '\n') {
                        --selection;
                    }
                }
            }
        }
        mMessageContentView.setSelection(selection, selection);
    }

    /**
     * In order to accelerate typing, position the cursor in the first empty field,
     * or at the end of the body composition field if none are empty.  Typically, this will
     * play out as follows:
     *   Reply / Reply All - put cursor in the empty message body
     *   Forward - put cursor in the empty To field
     *   Edit Draft - put cursor in whatever field still needs entry
     */
    private void setNewMessageFocus() {
        if (mToView.length() == 0) {
            mToView.requestFocus();
        } else if (mSubjectView.length() == 0) {
            mSubjectView.requestFocus();
        } else {
            mMessageContentView.requestFocus();
        }
    }

    private boolean isForward() {
        return ACTION_FORWARD.equals(mAction);
    }

    /**
     * @return the signature for the specified account, if non-null. If the account specified is
     *     null or has no signature, {@code null} is returned.
     */
    private static String getAccountSignature(Account account) {
        return (account == null) ? null : account.mSignature;
    }
}