mirror of
https://github.com/moparisthebest/k-9
synced 2024-08-13 17:03:48 -04:00
14055691a3
* mail-on-sd: (40 commits) Added more comments to explain how the locking mecanism works for LocalStore Fixed wrong method being called during experimental provider initialization (since provider isn't enabled, that didn't harm) Add more comments about how the various StorageProviders work and how they're enabled find src/com/fsck/ -name \*.java|xargs astyle --style=ansi --mode=java --indent-switches --indent=spaces=4 --convert-tabs French localization for storage related settings Remove unused SD card strings (replaced with storage indirection) Merge mail-on-sd branch from trunk Reset mail service on storage mount (even if no account uses the storage, to be improved) find src/com/fsck/ -name \*.java|xargs astyle --style=ansi --mode=java --indent-switches --indent=spaces=4 --convert-tabs Migraion -> Migration move the Storage location preference into preferences rather than the wizard. Made LocalStore log less verbose Added @Override compile checks Added ACTION_SHUTDOWN broadcast receiver to properly initiate shutdown sequence (not yet implemented) and cancel any scheduled Intent Be more consistent about which SQLiteDatabase variable is used (from instance variable to argument variable) to make code more refactoring-friendly (class is already big, code extraction should be easier if not referencing the instance variable). Added transaction timing logging Factorised storage lock/transaction handling code for regular operations. Use DB transactions to batch modifications (makes code more robust / could improve performances) Merge mail-on-sd branch from trunk Update issue 888 Added DB close on unmount / DB open on mount Update issue 888 Back to account list when underlying storage not available/unmounting in MessageView / MessageList ...
2367 lines
82 KiB
Java
2367 lines
82 KiB
Java
|
|
package com.fsck.k9.activity;
|
|
|
|
import java.io.File;
|
|
import java.io.Serializable;
|
|
import java.io.UnsupportedEncodingException;
|
|
import java.net.URLDecoder;
|
|
import java.util.ArrayList;
|
|
import java.util.Date;
|
|
import java.util.List;
|
|
import java.util.StringTokenizer;
|
|
import java.util.regex.Pattern;
|
|
|
|
import org.apache.james.mime4j.codec.EncoderUtil;
|
|
import android.app.AlertDialog;
|
|
import android.app.Dialog;
|
|
import android.content.ContentResolver;
|
|
import android.content.Context;
|
|
import android.content.DialogInterface;
|
|
import android.content.Intent;
|
|
import android.content.pm.ActivityInfo;
|
|
import android.database.Cursor;
|
|
import android.net.Uri;
|
|
import android.os.AsyncTask;
|
|
import android.os.Bundle;
|
|
import android.os.Handler;
|
|
import android.os.Parcelable;
|
|
import android.provider.OpenableColumns;
|
|
import android.text.Html;
|
|
import android.text.TextWatcher;
|
|
import android.text.util.Rfc822Tokenizer;
|
|
import android.util.Log;
|
|
import android.view.KeyEvent;
|
|
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.Window;
|
|
import android.widget.AutoCompleteTextView.Validator;
|
|
import android.widget.CheckBox;
|
|
import android.widget.EditText;
|
|
import android.widget.ImageButton;
|
|
import android.widget.LinearLayout;
|
|
import android.widget.MultiAutoCompleteTextView;
|
|
import android.widget.TextView;
|
|
import android.widget.Toast;
|
|
|
|
import com.fsck.k9.Account;
|
|
import com.fsck.k9.EmailAddressAdapter;
|
|
import com.fsck.k9.EmailAddressValidator;
|
|
import com.fsck.k9.Identity;
|
|
import com.fsck.k9.K9;
|
|
import com.fsck.k9.Preferences;
|
|
import com.fsck.k9.R;
|
|
import com.fsck.k9.controller.MessagingController;
|
|
import com.fsck.k9.controller.MessagingListener;
|
|
import com.fsck.k9.crypto.CryptoProvider;
|
|
import com.fsck.k9.crypto.PgpData;
|
|
import com.fsck.k9.helper.Contacts;
|
|
import com.fsck.k9.helper.Utility;
|
|
import com.fsck.k9.mail.Address;
|
|
import com.fsck.k9.mail.Body;
|
|
import com.fsck.k9.mail.Flag;
|
|
import com.fsck.k9.mail.Message;
|
|
import com.fsck.k9.mail.Message.RecipientType;
|
|
import com.fsck.k9.mail.MessagingException;
|
|
import com.fsck.k9.mail.Multipart;
|
|
import com.fsck.k9.mail.Part;
|
|
import com.fsck.k9.mail.internet.MimeBodyPart;
|
|
import com.fsck.k9.mail.internet.MimeHeader;
|
|
import com.fsck.k9.mail.internet.MimeMessage;
|
|
import com.fsck.k9.mail.internet.MimeMultipart;
|
|
import com.fsck.k9.mail.internet.MimeUtility;
|
|
import com.fsck.k9.mail.internet.TextBody;
|
|
import com.fsck.k9.mail.store.LocalStore;
|
|
import com.fsck.k9.mail.store.LocalStore.LocalAttachmentBody;
|
|
import com.fsck.k9.mail.store.UnavailableStorageException;
|
|
|
|
public class MessageCompose extends K9Activity implements OnClickListener, OnFocusChangeListener
|
|
{
|
|
private static final int DIALOG_SAVE_OR_DISCARD_DRAFT_MESSAGE = 1;
|
|
private static final int REPLY_WRAP_LINE_WIDTH = 72;
|
|
|
|
private static final String ACTION_REPLY = "com.fsck.k9.intent.action.REPLY";
|
|
private static final String ACTION_REPLY_ALL = "com.fsck.k9.intent.action.REPLY_ALL";
|
|
private static final String ACTION_FORWARD = "com.fsck.k9.intent.action.FORWARD";
|
|
private static final String ACTION_EDIT_DRAFT = "com.fsck.k9.intent.action.EDIT_DRAFT";
|
|
|
|
private static final String EXTRA_ACCOUNT = "account";
|
|
private static final String EXTRA_MESSAGE_BODY = "messageBody";
|
|
private static final String EXTRA_MESSAGE_REFERENCE = "message_reference";
|
|
|
|
private static final String STATE_KEY_ATTACHMENTS =
|
|
"com.fsck.k9.activity.MessageCompose.attachments";
|
|
private static final String STATE_KEY_CC_SHOWN =
|
|
"com.fsck.k9.activity.MessageCompose.ccShown";
|
|
private static final String STATE_KEY_BCC_SHOWN =
|
|
"com.fsck.k9.activity.MessageCompose.bccShown";
|
|
private static final String STATE_KEY_QUOTED_TEXT_SHOWN =
|
|
"com.fsck.k9.activity.MessageCompose.quotedTextShown";
|
|
private static final String STATE_KEY_SOURCE_MESSAGE_PROCED =
|
|
"com.fsck.k9.activity.MessageCompose.stateKeySourceMessageProced";
|
|
private static final String STATE_KEY_DRAFT_UID =
|
|
"com.fsck.k9.activity.MessageCompose.draftUid";
|
|
private static final String STATE_IDENTITY_CHANGED =
|
|
"com.fsck.k9.activity.MessageCompose.identityChanged";
|
|
private static final String STATE_IDENTITY =
|
|
"com.fsck.k9.activity.MessageCompose.identity";
|
|
private static final String STATE_PGP_DATA = "pgpData";
|
|
private static final String STATE_IN_REPLY_TO = "com.fsck.k9.activity.MessageCompose.inReplyTo";
|
|
private static final String STATE_REFERENCES = "com.fsck.k9.activity.MessageCompose.references";
|
|
|
|
private static final int MSG_PROGRESS_ON = 1;
|
|
private static final int MSG_PROGRESS_OFF = 2;
|
|
private static final int MSG_UPDATE_TITLE = 3;
|
|
private static final int MSG_SKIPPED_ATTACHMENTS = 4;
|
|
private static final int MSG_SAVED_DRAFT = 5;
|
|
private static final int MSG_DISCARDED_DRAFT = 6;
|
|
|
|
private static final int ACTIVITY_REQUEST_PICK_ATTACHMENT = 1;
|
|
private static final int ACTIVITY_CHOOSE_IDENTITY = 2;
|
|
private static final int ACTIVITY_CHOOSE_ACCOUNT = 3;
|
|
|
|
/**
|
|
* Regular expression to remove the first localized "Re:" prefix in subjects.
|
|
*
|
|
* Currently:
|
|
* - "Aw:" (german: abbreviation for "Antwort")
|
|
*/
|
|
private static final Pattern prefix = Pattern.compile("^AW[:\\s]\\s*", Pattern.CASE_INSENSITIVE);
|
|
|
|
/**
|
|
* The account used for message composition.
|
|
*/
|
|
private Account mAccount;
|
|
|
|
/**
|
|
* This identity's settings are used for message composition.
|
|
* Note: This has to be an identity of the account {@link #mAccount}.
|
|
*/
|
|
private Identity mIdentity;
|
|
|
|
private boolean mIdentityChanged = false;
|
|
private boolean mSignatureChanged = false;
|
|
|
|
/**
|
|
* Reference to the source message (in case of reply, forward, or edit
|
|
* draft actions).
|
|
*/
|
|
private MessageReference mMessageReference;
|
|
|
|
private Message mSourceMessage;
|
|
private String mSourceMessageBody;
|
|
|
|
/**
|
|
* Indicates that the source message has been processed at least once and should not
|
|
* be processed on any subsequent loads. This protects us from adding attachments that
|
|
* have already been added from the restore of the view state.
|
|
*/
|
|
private boolean mSourceMessageProcessed = false;
|
|
|
|
|
|
private TextView mFromView;
|
|
private MultiAutoCompleteTextView mToView;
|
|
private MultiAutoCompleteTextView mCcView;
|
|
private MultiAutoCompleteTextView mBccView;
|
|
private EditText mSubjectView;
|
|
private EditText mSignatureView;
|
|
private EditText mMessageContentView;
|
|
private LinearLayout mAttachments;
|
|
private View mQuotedTextBar;
|
|
private ImageButton mQuotedTextDelete;
|
|
private EditText mQuotedText;
|
|
private View mEncryptLayout;
|
|
private CheckBox mCryptoSignatureCheckbox;
|
|
private CheckBox mEncryptCheckbox;
|
|
private TextView mCryptoSignatureUserId;
|
|
private TextView mCryptoSignatureUserIdRest;
|
|
|
|
private PgpData mPgpData = null;
|
|
|
|
private String mReferences;
|
|
private String mInReplyTo;
|
|
|
|
private boolean mDraftNeedsSaving = false;
|
|
private boolean mPreventDraftSaving = false;
|
|
|
|
/**
|
|
* The draft uid of this message. This is used when saving drafts so that the same draft is
|
|
* overwritten instead of being created anew. This property is null until the first save.
|
|
*/
|
|
private String mDraftUid;
|
|
|
|
private Handler mHandler = new Handler()
|
|
{
|
|
@Override
|
|
public void handleMessage(android.os.Message msg)
|
|
{
|
|
switch (msg.what)
|
|
{
|
|
case MSG_PROGRESS_ON:
|
|
setProgressBarIndeterminateVisibility(true);
|
|
break;
|
|
case MSG_PROGRESS_OFF:
|
|
setProgressBarIndeterminateVisibility(false);
|
|
break;
|
|
case MSG_UPDATE_TITLE:
|
|
updateTitle();
|
|
break;
|
|
case MSG_SKIPPED_ATTACHMENTS:
|
|
Toast.makeText(
|
|
MessageCompose.this,
|
|
getString(R.string.message_compose_attachments_skipped_toast),
|
|
Toast.LENGTH_LONG).show();
|
|
break;
|
|
case MSG_SAVED_DRAFT:
|
|
Toast.makeText(
|
|
MessageCompose.this,
|
|
getString(R.string.message_saved_toast),
|
|
Toast.LENGTH_LONG).show();
|
|
break;
|
|
case MSG_DISCARDED_DRAFT:
|
|
Toast.makeText(
|
|
MessageCompose.this,
|
|
getString(R.string.message_discarded_toast),
|
|
Toast.LENGTH_LONG).show();
|
|
break;
|
|
default:
|
|
super.handleMessage(msg);
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
|
|
private Listener mListener = new Listener();
|
|
private EmailAddressAdapter mAddressAdapter;
|
|
private Validator mAddressValidator;
|
|
|
|
|
|
class Attachment implements Serializable
|
|
{
|
|
public String name;
|
|
public String contentType;
|
|
public long size;
|
|
public Uri uri;
|
|
}
|
|
|
|
/**
|
|
* Compose a new message using the given account. If account is null the default account
|
|
* will be used.
|
|
* @param context
|
|
* @param account
|
|
*/
|
|
public static void actionCompose(Context context, Account account)
|
|
{
|
|
if (account == null)
|
|
{
|
|
account = Preferences.getPreferences(context).getDefaultAccount();
|
|
}
|
|
Intent i = new Intent(context, MessageCompose.class);
|
|
i.putExtra(EXTRA_ACCOUNT, account.getUuid());
|
|
context.startActivity(i);
|
|
}
|
|
|
|
/**
|
|
* 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 account
|
|
* @param message
|
|
* @param replyAll
|
|
* @param messageBody optional, for decrypted messages, null if it should be grabbed from the given message
|
|
*/
|
|
public static void actionReply(
|
|
Context context,
|
|
Account account,
|
|
Message message,
|
|
boolean replyAll,
|
|
String messageBody)
|
|
{
|
|
Intent i = new Intent(context, MessageCompose.class);
|
|
i.putExtra(EXTRA_MESSAGE_BODY, messageBody);
|
|
i.putExtra(EXTRA_MESSAGE_REFERENCE, message.makeMessageReference());
|
|
if (replyAll)
|
|
{
|
|
i.setAction(ACTION_REPLY_ALL);
|
|
}
|
|
else
|
|
{
|
|
i.setAction(ACTION_REPLY);
|
|
}
|
|
context.startActivity(i);
|
|
}
|
|
|
|
/**
|
|
* Compose a new message as a forward of the given message.
|
|
* @param context
|
|
* @param account
|
|
* @param message
|
|
* @param messageBody optional, for decrypted messages, null if it should be grabbed from the given message
|
|
*/
|
|
public static void actionForward(
|
|
Context context,
|
|
Account account,
|
|
Message message,
|
|
String messageBody)
|
|
{
|
|
Intent i = new Intent(context, MessageCompose.class);
|
|
i.putExtra(EXTRA_MESSAGE_BODY, messageBody);
|
|
i.putExtra(EXTRA_MESSAGE_REFERENCE, message.makeMessageReference());
|
|
i.setAction(ACTION_FORWARD);
|
|
context.startActivity(i);
|
|
}
|
|
|
|
/**
|
|
* 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 account
|
|
* @param folder
|
|
* @param message
|
|
*/
|
|
public static void actionEditDraft(Context context, Account account, Message message)
|
|
{
|
|
Intent i = new Intent(context, MessageCompose.class);
|
|
i.putExtra(EXTRA_MESSAGE_REFERENCE, message.makeMessageReference());
|
|
i.setAction(ACTION_EDIT_DRAFT);
|
|
context.startActivity(i);
|
|
}
|
|
|
|
@Override
|
|
public void onCreate(Bundle savedInstanceState)
|
|
{
|
|
super.onCreate(savedInstanceState);
|
|
requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);
|
|
setContentView(R.layout.message_compose);
|
|
|
|
final Intent intent = getIntent();
|
|
|
|
mMessageReference = (MessageReference) intent.getSerializableExtra(EXTRA_MESSAGE_REFERENCE);
|
|
mSourceMessageBody = (String) intent.getStringExtra(EXTRA_MESSAGE_BODY);
|
|
|
|
final String accountUuid = (mMessageReference != null) ?
|
|
mMessageReference.accountUuid :
|
|
intent.getStringExtra(EXTRA_ACCOUNT);
|
|
|
|
mAccount = Preferences.getPreferences(this).getAccount(accountUuid);
|
|
|
|
if (mAccount == null)
|
|
{
|
|
mAccount = Preferences.getPreferences(this).getDefaultAccount();
|
|
}
|
|
|
|
if (mAccount == null)
|
|
{
|
|
/*
|
|
* There are no accounts set up. This should not have happened. Prompt the
|
|
* user to set up an account as an acceptable bailout.
|
|
*/
|
|
startActivity(new Intent(this, Accounts.class));
|
|
mDraftNeedsSaving = false;
|
|
finish();
|
|
return;
|
|
}
|
|
|
|
mAddressAdapter = EmailAddressAdapter.getInstance(this);
|
|
mAddressValidator = new EmailAddressValidator();
|
|
|
|
mFromView = (TextView)findViewById(R.id.from);
|
|
mToView = (MultiAutoCompleteTextView)findViewById(R.id.to);
|
|
mCcView = (MultiAutoCompleteTextView)findViewById(R.id.cc);
|
|
mBccView = (MultiAutoCompleteTextView)findViewById(R.id.bcc);
|
|
mSubjectView = (EditText)findViewById(R.id.subject);
|
|
|
|
EditText upperSignature = (EditText)findViewById(R.id.upper_signature);
|
|
EditText lowerSignature = (EditText)findViewById(R.id.lower_signature);
|
|
|
|
mMessageContentView = (EditText)findViewById(R.id.message_content);
|
|
mAttachments = (LinearLayout)findViewById(R.id.attachments);
|
|
mQuotedTextBar = findViewById(R.id.quoted_text_bar);
|
|
mQuotedTextDelete = (ImageButton)findViewById(R.id.quoted_text_delete);
|
|
mQuotedText = (EditText)findViewById(R.id.quoted_text);
|
|
|
|
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)
|
|
{
|
|
mDraftNeedsSaving = true;
|
|
}
|
|
|
|
public void afterTextChanged(android.text.Editable s) { }
|
|
};
|
|
|
|
TextWatcher sigwatcher = new TextWatcher()
|
|
{
|
|
public void beforeTextChanged(CharSequence s, int start,
|
|
int before, int after) { }
|
|
|
|
public void onTextChanged(CharSequence s, int start,
|
|
int before, int count)
|
|
{
|
|
mDraftNeedsSaving = true;
|
|
mSignatureChanged = true;
|
|
}
|
|
|
|
public void afterTextChanged(android.text.Editable s) { }
|
|
};
|
|
|
|
mToView.addTextChangedListener(watcher);
|
|
mCcView.addTextChangedListener(watcher);
|
|
mBccView.addTextChangedListener(watcher);
|
|
mSubjectView.addTextChangedListener(watcher);
|
|
|
|
mMessageContentView.addTextChangedListener(watcher);
|
|
mQuotedText.addTextChangedListener(watcher);
|
|
|
|
/*
|
|
* We set this to invisible by default. Other methods will turn it back on if it's
|
|
* needed.
|
|
*/
|
|
mQuotedTextBar.setVisibility(View.GONE);
|
|
mQuotedText.setVisibility(View.GONE);
|
|
|
|
mQuotedTextDelete.setOnClickListener(this);
|
|
|
|
mFromView.setVisibility(View.GONE);
|
|
|
|
mToView.setAdapter(mAddressAdapter);
|
|
mToView.setTokenizer(new Rfc822Tokenizer());
|
|
mToView.setValidator(mAddressValidator);
|
|
|
|
mCcView.setAdapter(mAddressAdapter);
|
|
mCcView.setTokenizer(new Rfc822Tokenizer());
|
|
mCcView.setValidator(mAddressValidator);
|
|
|
|
mBccView.setAdapter(mAddressAdapter);
|
|
mBccView.setTokenizer(new Rfc822Tokenizer());
|
|
mBccView.setValidator(mAddressValidator);
|
|
|
|
|
|
mSubjectView.setOnFocusChangeListener(this);
|
|
|
|
if (savedInstanceState != null)
|
|
{
|
|
/*
|
|
* This data gets used in onCreate, so grab it here instead of onRestoreIntstanceState
|
|
*/
|
|
mSourceMessageProcessed = savedInstanceState.getBoolean(STATE_KEY_SOURCE_MESSAGE_PROCED, false);
|
|
}
|
|
|
|
|
|
String action = intent.getAction();
|
|
|
|
if (Intent.ACTION_VIEW.equals(action))
|
|
{
|
|
/*
|
|
* Someone has clicked a mailto: link. The address is in the URI.
|
|
*/
|
|
if (intent.getData() != null)
|
|
{
|
|
Uri uri = intent.getData();
|
|
if ("mailto".equals(uri.getScheme()))
|
|
{
|
|
initializeFromMailTo(uri.toString());
|
|
}
|
|
else
|
|
{
|
|
String toText = uri.getSchemeSpecificPart();
|
|
if (toText != null)
|
|
{
|
|
mToView.setText(toText);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (Intent.ACTION_SENDTO.equals(action))
|
|
{
|
|
final Uri uri = intent.getData();
|
|
|
|
// look for recipient address
|
|
if (uri != null && "mailto".equals(uri.getScheme()))
|
|
{
|
|
initializeFromMailTo(uri.toString());
|
|
}
|
|
}
|
|
//TODO: Use constant Intent.ACTION_SEND_MULTIPLE once we drop Android 1.5 support
|
|
else if (Intent.ACTION_SEND.equals(action)
|
|
|| "android.intent.action.SEND_MULTIPLE".equals(action))
|
|
{
|
|
/*
|
|
* Someone is trying to compose an email with an attachment, probably Pictures.
|
|
* The Intent should contain an EXTRA_STREAM with the data to attach.
|
|
*/
|
|
|
|
String text = intent.getStringExtra(Intent.EXTRA_TEXT);
|
|
if (text != null)
|
|
{
|
|
mMessageContentView.setText(text);
|
|
}
|
|
String subject = intent.getStringExtra(Intent.EXTRA_SUBJECT);
|
|
if (subject != null)
|
|
{
|
|
mSubjectView.setText(subject);
|
|
}
|
|
|
|
String type = intent.getType();
|
|
//TODO: Use constant Intent.ACTION_SEND_MULTIPLE once we drop Android 1.5 support
|
|
if ("android.intent.action.SEND_MULTIPLE".equals(action))
|
|
{
|
|
ArrayList<Parcelable> list = intent.getParcelableArrayListExtra(Intent.EXTRA_STREAM);
|
|
if (list != null)
|
|
{
|
|
for (Parcelable parcelable : list)
|
|
{
|
|
Uri stream = (Uri) parcelable;
|
|
if (stream != null && type != null)
|
|
{
|
|
if (MimeUtility.mimeTypeMatches(type, K9.ACCEPTABLE_ATTACHMENT_SEND_TYPES))
|
|
{
|
|
addAttachment(stream);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Uri stream = (Uri) intent.getParcelableExtra(Intent.EXTRA_STREAM);
|
|
if (stream != null && type != null)
|
|
{
|
|
if (MimeUtility.mimeTypeMatches(type, K9.ACCEPTABLE_ATTACHMENT_SEND_TYPES))
|
|
{
|
|
addAttachment(stream);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* There might be an EXTRA_SUBJECT, EXTRA_TEXT, EXTRA_EMAIL, EXTRA_BCC or EXTRA_CC
|
|
*/
|
|
|
|
String extraSubject = intent.getStringExtra(Intent.EXTRA_SUBJECT);
|
|
String extraText = intent.getStringExtra(Intent.EXTRA_TEXT);
|
|
|
|
mSubjectView.setText(extraSubject);
|
|
mMessageContentView.setText(extraText);
|
|
|
|
String[] extraEmail = intent.getStringArrayExtra(Intent.EXTRA_EMAIL);
|
|
String[] extraCc = intent.getStringArrayExtra(Intent.EXTRA_CC);
|
|
String[] extraBcc = intent.getStringArrayExtra(Intent.EXTRA_BCC);
|
|
|
|
String addressList;
|
|
// Cache array size, as per Google's recommendations.
|
|
int arraySize;
|
|
int i;
|
|
|
|
addressList = "";
|
|
if (extraEmail != null)
|
|
{
|
|
arraySize = extraEmail.length;
|
|
for (i=0; i < arraySize; i++)
|
|
{
|
|
addressList += extraEmail[i]+", ";
|
|
}
|
|
}
|
|
mToView.setText(addressList);
|
|
|
|
addressList = "";
|
|
if (extraCc != null)
|
|
{
|
|
arraySize = extraCc.length;
|
|
for (i=0; i < arraySize; i++)
|
|
{
|
|
addressList += extraCc[i]+", ";
|
|
}
|
|
}
|
|
mCcView.setText(addressList);
|
|
|
|
addressList = "";
|
|
if (extraBcc != null)
|
|
{
|
|
arraySize = extraBcc.length;
|
|
for (i=0; i < arraySize; i++)
|
|
{
|
|
addressList += extraBcc[i]+", ";
|
|
}
|
|
}
|
|
mBccView.setText(addressList);
|
|
|
|
}
|
|
|
|
if (mIdentity == null)
|
|
{
|
|
mIdentity = mAccount.getIdentity(0);
|
|
}
|
|
|
|
if (mAccount.isSignatureBeforeQuotedText())
|
|
{
|
|
mSignatureView = upperSignature;
|
|
lowerSignature.setVisibility(View.GONE);
|
|
}
|
|
else
|
|
{
|
|
mSignatureView = lowerSignature;
|
|
upperSignature.setVisibility(View.GONE);
|
|
}
|
|
mSignatureView.addTextChangedListener(sigwatcher);
|
|
|
|
if (!mIdentity.getSignatureUse())
|
|
{
|
|
mSignatureView.setVisibility(View.GONE);
|
|
}
|
|
|
|
if (!mSourceMessageProcessed)
|
|
{
|
|
updateFrom();
|
|
updateSignature();
|
|
|
|
if (ACTION_REPLY.equals(action) ||
|
|
ACTION_REPLY_ALL.equals(action) ||
|
|
ACTION_FORWARD.equals(action) ||
|
|
ACTION_EDIT_DRAFT.equals(action))
|
|
{
|
|
/*
|
|
* If we need to load the message we add ourself as a message listener here
|
|
* so we can kick it off. Normally we add in onResume but we don't
|
|
* want to reload the message every time the activity is resumed.
|
|
* There is no harm in adding twice.
|
|
*/
|
|
MessagingController.getInstance(getApplication()).addListener(mListener);
|
|
|
|
final Account account = Preferences.getPreferences(this).getAccount(mMessageReference.accountUuid);
|
|
final String folderName = mMessageReference.folderName;
|
|
final String sourceMessageUid = mMessageReference.uid;
|
|
MessagingController.getInstance(getApplication()).loadMessageForView(account, folderName, sourceMessageUid, null);
|
|
}
|
|
|
|
if (!ACTION_EDIT_DRAFT.equals(action))
|
|
{
|
|
String bccAddress = mAccount.getAlwaysBcc();
|
|
if ((bccAddress != null) && !("".equals(bccAddress)))
|
|
{
|
|
addAddress(mBccView, new Address(bccAddress, ""));
|
|
}
|
|
}
|
|
|
|
/*
|
|
if (K9.DEBUG)
|
|
Log.d(K9.LOG_TAG, "action = " + action + ", account = " + mMessageReference.accountUuid + ", folder = " + mMessageReference.folderName + ", sourceMessageUid = " + mMessageReference.uid);
|
|
*/
|
|
|
|
if (ACTION_REPLY.equals(action) ||
|
|
ACTION_REPLY_ALL.equals(action))
|
|
{
|
|
if (K9.DEBUG)
|
|
Log.d(K9.LOG_TAG, "Setting message ANSWERED flag to true");
|
|
|
|
// TODO: Really, we should wait until we send the message, but that would require saving the original
|
|
// message info along with a Draft copy, in case it is left in Drafts for a while before being sent
|
|
|
|
final Account account = Preferences.getPreferences(this).getAccount(mMessageReference.accountUuid);
|
|
final String folderName = mMessageReference.folderName;
|
|
final String sourceMessageUid = mMessageReference.uid;
|
|
MessagingController.getInstance(getApplication()).setFlag(account, folderName, new String[] { sourceMessageUid }, Flag.ANSWERED, true);
|
|
}
|
|
|
|
updateTitle();
|
|
}
|
|
|
|
if (ACTION_REPLY.equals(action) ||
|
|
ACTION_REPLY_ALL.equals(action) ||
|
|
ACTION_EDIT_DRAFT.equals(action))
|
|
{
|
|
//change focus to message body.
|
|
mMessageContentView.requestFocus();
|
|
}
|
|
|
|
mEncryptLayout = (View)findViewById(R.id.layout_encrypt);
|
|
mCryptoSignatureCheckbox = (CheckBox)findViewById(R.id.cb_crypto_signature);
|
|
mCryptoSignatureUserId = (TextView)findViewById(R.id.userId);
|
|
mCryptoSignatureUserIdRest = (TextView)findViewById(R.id.userIdRest);
|
|
mEncryptCheckbox = (CheckBox)findViewById(R.id.cb_encrypt);
|
|
|
|
initializeCrypto();
|
|
final CryptoProvider crypto = mAccount.getCryptoProvider();
|
|
if (crypto.isAvailable(this))
|
|
{
|
|
mEncryptLayout.setVisibility(View.VISIBLE);
|
|
mCryptoSignatureCheckbox.setOnClickListener(new OnClickListener()
|
|
{
|
|
@Override
|
|
public void onClick(View v)
|
|
{
|
|
CheckBox checkBox = (CheckBox) v;
|
|
if (checkBox.isChecked())
|
|
{
|
|
mPreventDraftSaving = true;
|
|
if (!crypto.selectSecretKey(MessageCompose.this, mPgpData))
|
|
{
|
|
mPreventDraftSaving = false;
|
|
}
|
|
checkBox.setChecked(false);
|
|
}
|
|
else
|
|
{
|
|
mPgpData.setSignatureKeyId(0);
|
|
updateEncryptLayout();
|
|
}
|
|
}
|
|
});
|
|
|
|
if (mAccount.getCryptoAutoSignature())
|
|
{
|
|
long ids[] = crypto.getSecretKeyIdsFromEmail(this, mIdentity.getEmail());
|
|
if (ids != null && ids.length > 0)
|
|
{
|
|
mPgpData.setSignatureKeyId(ids[0]);
|
|
mPgpData.setSignatureUserId(crypto.getUserId(this, ids[0]));
|
|
}
|
|
else
|
|
{
|
|
mPgpData.setSignatureKeyId(0);
|
|
mPgpData.setSignatureUserId(null);
|
|
}
|
|
}
|
|
updateEncryptLayout();
|
|
}
|
|
else
|
|
{
|
|
mEncryptLayout.setVisibility(View.GONE);
|
|
}
|
|
|
|
mDraftNeedsSaving = false;
|
|
}
|
|
|
|
private void initializeCrypto()
|
|
{
|
|
if (mPgpData != null)
|
|
{
|
|
return;
|
|
}
|
|
mPgpData = new PgpData();
|
|
}
|
|
|
|
/**
|
|
* Fill the encrypt layout with the latest data about signature key and encryption keys.
|
|
*/
|
|
public void updateEncryptLayout()
|
|
{
|
|
if (!mPgpData.hasSignatureKey())
|
|
{
|
|
mCryptoSignatureCheckbox.setText(R.string.btn_crypto_sign);
|
|
mCryptoSignatureCheckbox.setChecked(false);
|
|
mCryptoSignatureUserId.setVisibility(View.INVISIBLE);
|
|
mCryptoSignatureUserIdRest.setVisibility(View.INVISIBLE);
|
|
}
|
|
else
|
|
{
|
|
// if a signature key is selected, then the checkbox itself has no text
|
|
mCryptoSignatureCheckbox.setText("");
|
|
mCryptoSignatureCheckbox.setChecked(true);
|
|
mCryptoSignatureUserId.setVisibility(View.VISIBLE);
|
|
mCryptoSignatureUserIdRest.setVisibility(View.VISIBLE);
|
|
mCryptoSignatureUserId.setText(R.string.unknown_crypto_signature_user_id);
|
|
mCryptoSignatureUserIdRest.setText("");
|
|
|
|
String userId = mPgpData.getSignatureUserId();
|
|
if (userId == null)
|
|
{
|
|
userId = mAccount.getCryptoProvider().getUserId(this, mPgpData.getSignatureKeyId());
|
|
mPgpData.setSignatureUserId(userId);
|
|
}
|
|
|
|
if (userId != null)
|
|
{
|
|
String chunks[] = mPgpData.getSignatureUserId().split(" <", 2);
|
|
mCryptoSignatureUserId.setText(chunks[0]);
|
|
if (chunks.length > 1)
|
|
{
|
|
mCryptoSignatureUserIdRest.setText("<" + chunks[1]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onResume()
|
|
{
|
|
super.onResume();
|
|
MessagingController.getInstance(getApplication()).addListener(mListener);
|
|
}
|
|
|
|
@Override
|
|
public void onPause()
|
|
{
|
|
super.onPause();
|
|
saveIfNeeded();
|
|
MessagingController.getInstance(getApplication()).removeListener(mListener);
|
|
}
|
|
|
|
/**
|
|
* The framework handles most of the fields, but we need to handle stuff that we
|
|
* dynamically show and hide:
|
|
* Attachment list,
|
|
* Cc field,
|
|
* Bcc field,
|
|
* Quoted text,
|
|
*/
|
|
@Override
|
|
protected void onSaveInstanceState(Bundle outState)
|
|
{
|
|
super.onSaveInstanceState(outState);
|
|
saveIfNeeded();
|
|
ArrayList<Uri> attachments = new ArrayList<Uri>();
|
|
for (int i = 0, count = mAttachments.getChildCount(); i < count; i++)
|
|
{
|
|
View view = mAttachments.getChildAt(i);
|
|
Attachment attachment = (Attachment) view.getTag();
|
|
attachments.add(attachment.uri);
|
|
}
|
|
outState.putParcelableArrayList(STATE_KEY_ATTACHMENTS, attachments);
|
|
outState.putBoolean(STATE_KEY_CC_SHOWN, mCcView.getVisibility() == View.VISIBLE);
|
|
outState.putBoolean(STATE_KEY_BCC_SHOWN, mBccView.getVisibility() == View.VISIBLE);
|
|
outState.putBoolean(STATE_KEY_QUOTED_TEXT_SHOWN, mQuotedTextBar.getVisibility() == View.VISIBLE);
|
|
outState.putBoolean(STATE_KEY_SOURCE_MESSAGE_PROCED, mSourceMessageProcessed);
|
|
outState.putString(STATE_KEY_DRAFT_UID, mDraftUid);
|
|
outState.putSerializable(STATE_IDENTITY, mIdentity);
|
|
outState.putBoolean(STATE_IDENTITY_CHANGED, mIdentityChanged);
|
|
outState.putSerializable(STATE_PGP_DATA, mPgpData);
|
|
outState.putString(STATE_IN_REPLY_TO, mInReplyTo);
|
|
outState.putString(STATE_REFERENCES, mReferences);
|
|
}
|
|
|
|
@Override
|
|
protected void onRestoreInstanceState(Bundle savedInstanceState)
|
|
{
|
|
super.onRestoreInstanceState(savedInstanceState);
|
|
ArrayList<Parcelable> attachments = (ArrayList<Parcelable>) savedInstanceState.getParcelableArrayList(STATE_KEY_ATTACHMENTS);
|
|
mAttachments.removeAllViews();
|
|
for (Parcelable p : attachments)
|
|
{
|
|
Uri uri = (Uri) p;
|
|
addAttachment(uri);
|
|
}
|
|
|
|
mCcView.setVisibility(savedInstanceState.getBoolean(STATE_KEY_CC_SHOWN) ? View.VISIBLE : View.GONE);
|
|
mBccView.setVisibility(savedInstanceState.getBoolean(STATE_KEY_BCC_SHOWN) ? View.VISIBLE : View.GONE);
|
|
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);
|
|
mDraftUid = savedInstanceState.getString(STATE_KEY_DRAFT_UID);
|
|
mIdentity = (Identity)savedInstanceState.getSerializable(STATE_IDENTITY);
|
|
mIdentityChanged = savedInstanceState.getBoolean(STATE_IDENTITY_CHANGED);
|
|
mPgpData = (PgpData) savedInstanceState.getSerializable(STATE_PGP_DATA);
|
|
mInReplyTo = savedInstanceState.getString(STATE_IN_REPLY_TO);
|
|
mReferences = savedInstanceState.getString(STATE_REFERENCES);
|
|
|
|
initializeCrypto();
|
|
updateFrom();
|
|
updateSignature();
|
|
updateEncryptLayout();
|
|
|
|
mDraftNeedsSaving = false;
|
|
}
|
|
|
|
private void updateTitle()
|
|
{
|
|
if (mSubjectView.getText().length() == 0)
|
|
{
|
|
setTitle(R.string.compose_title);
|
|
}
|
|
else
|
|
{
|
|
setTitle(mSubjectView.getText().toString());
|
|
}
|
|
}
|
|
|
|
public void onFocusChange(View view, boolean focused)
|
|
{
|
|
if (!focused)
|
|
{
|
|
updateTitle();
|
|
}
|
|
}
|
|
|
|
private void addAddresses(MultiAutoCompleteTextView view, Address[] addresses)
|
|
{
|
|
if (addresses == null)
|
|
{
|
|
return;
|
|
}
|
|
for (Address address : addresses)
|
|
{
|
|
addAddress(view, address);
|
|
}
|
|
}
|
|
|
|
private void addAddress(MultiAutoCompleteTextView view, Address address)
|
|
{
|
|
view.append(address + ", ");
|
|
}
|
|
|
|
private Address[] getAddresses(MultiAutoCompleteTextView view)
|
|
{
|
|
Address[] addresses = Address.parseUnencoded(view.getText().toString().trim());
|
|
return addresses;
|
|
}
|
|
|
|
/*
|
|
* Build the Body that will contain the text of the message. We'll decide where to
|
|
* include it later.
|
|
*
|
|
* @param appendSig If true, append the user's signature to the message.
|
|
*/
|
|
private String buildText(boolean appendSig)
|
|
{
|
|
boolean replyAfterQuote = false;
|
|
String action = getIntent().getAction();
|
|
if (mAccount.isReplyAfterQuote() &&
|
|
(ACTION_REPLY.equals(action) || ACTION_REPLY_ALL.equals(action)))
|
|
{
|
|
replyAfterQuote = true;
|
|
}
|
|
|
|
String text = mMessageContentView.getText().toString();
|
|
// Placing the signature before the quoted text does not make sense if replyAfterQuote is true.
|
|
if (!replyAfterQuote && appendSig && mAccount.isSignatureBeforeQuotedText())
|
|
{
|
|
text = appendSignature(text);
|
|
}
|
|
|
|
if (mQuotedTextBar.getVisibility() == View.VISIBLE)
|
|
{
|
|
if (replyAfterQuote)
|
|
{
|
|
text = mQuotedText.getText().toString() + "\n" + text;
|
|
}
|
|
else
|
|
{
|
|
text += "\n\n" + mQuotedText.getText().toString();
|
|
}
|
|
}
|
|
|
|
// Note: If user has selected reply after quote AND signature before quote, ignore the
|
|
// latter setting and append the signature at the end.
|
|
if (appendSig && (!mAccount.isSignatureBeforeQuotedText() || replyAfterQuote))
|
|
{
|
|
text = appendSignature(text);
|
|
}
|
|
|
|
return text;
|
|
}
|
|
|
|
private MimeMessage createMessage(boolean appendSig) throws MessagingException
|
|
{
|
|
MimeMessage message = new MimeMessage();
|
|
message.addSentDate(new Date());
|
|
Address from = new Address(mIdentity.getEmail(), mIdentity.getName());
|
|
message.setFrom(from);
|
|
message.setRecipients(RecipientType.TO, getAddresses(mToView));
|
|
message.setRecipients(RecipientType.CC, getAddresses(mCcView));
|
|
message.setRecipients(RecipientType.BCC, getAddresses(mBccView));
|
|
message.setSubject(mSubjectView.getText().toString());
|
|
message.setHeader("X-User-Agent", getString(R.string.message_header_mua));
|
|
|
|
final String replyTo = mIdentity.getReplyTo();
|
|
if (replyTo != null)
|
|
{
|
|
message.setReplyTo(new Address[] { new Address(replyTo) });
|
|
}
|
|
|
|
if (mInReplyTo != null)
|
|
{
|
|
message.setInReplyTo(mInReplyTo);
|
|
}
|
|
|
|
if (mReferences != null)
|
|
{
|
|
message.setReferences(mReferences);
|
|
}
|
|
|
|
String text = null;
|
|
if (mPgpData.getEncryptedData() != null)
|
|
{
|
|
text = mPgpData.getEncryptedData();
|
|
}
|
|
else
|
|
{
|
|
text = buildText(appendSig);
|
|
}
|
|
|
|
TextBody body = new TextBody(text);
|
|
|
|
if (mAttachments.getChildCount() > 0)
|
|
{
|
|
/*
|
|
* The message has attachments that need to be included. First we add the part
|
|
* containing the text that will be sent and then we include each attachment.
|
|
*/
|
|
|
|
MimeMultipart mp;
|
|
|
|
mp = new MimeMultipart();
|
|
mp.addBodyPart(new MimeBodyPart(body, "text/plain"));
|
|
|
|
for (int i = 0, count = mAttachments.getChildCount(); i < count; i++)
|
|
{
|
|
Attachment attachment = (Attachment) mAttachments.getChildAt(i).getTag();
|
|
|
|
MimeBodyPart bp = new MimeBodyPart(
|
|
new LocalStore.LocalAttachmentBody(attachment.uri, getApplication()));
|
|
|
|
/*
|
|
* Correctly encode the filename here. Otherwise the whole
|
|
* header value (all parameters at once) will be encoded by
|
|
* MimeHeader.writeTo().
|
|
*/
|
|
bp.addHeader(MimeHeader.HEADER_CONTENT_TYPE, String.format("%s;\n name=\"%s\"",
|
|
attachment.contentType,
|
|
EncoderUtil.encodeIfNecessary(attachment.name,
|
|
EncoderUtil.Usage.WORD_ENTITY, 7)));
|
|
|
|
bp.addHeader(MimeHeader.HEADER_CONTENT_TRANSFER_ENCODING, "base64");
|
|
|
|
/*
|
|
* TODO: Oh the joys of MIME...
|
|
*
|
|
* From RFC 2183 (The Content-Disposition Header Field):
|
|
* "Parameter values longer than 78 characters, or which
|
|
* contain non-ASCII characters, MUST be encoded as specified
|
|
* in [RFC 2184]."
|
|
*
|
|
* Example:
|
|
*
|
|
* Content-Type: application/x-stuff
|
|
* title*1*=us-ascii'en'This%20is%20even%20more%20
|
|
* title*2*=%2A%2A%2Afun%2A%2A%2A%20
|
|
* title*3="isn't it!"
|
|
*/
|
|
bp.addHeader(MimeHeader.HEADER_CONTENT_DISPOSITION, String.format(
|
|
"attachment;\n filename=\"%s\";\n size=%d",
|
|
attachment.name, attachment.size));
|
|
|
|
mp.addBodyPart(bp);
|
|
}
|
|
|
|
message.setBody(mp);
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
* No attachments to include, just stick the text body in the message and call
|
|
* it good.
|
|
*/
|
|
message.setBody(body);
|
|
}
|
|
|
|
return message;
|
|
}
|
|
|
|
private String appendSignature(String text)
|
|
{
|
|
if (mIdentity.getSignatureUse())
|
|
{
|
|
String signature = mSignatureView.getText().toString();
|
|
|
|
if (signature != null && !signature.contentEquals(""))
|
|
{
|
|
text += "\n" + signature;
|
|
}
|
|
}
|
|
|
|
return text;
|
|
}
|
|
|
|
|
|
private void sendMessage()
|
|
{
|
|
new SendMessageTask().execute();
|
|
}
|
|
private void saveMessage()
|
|
{
|
|
new SaveMessageTask().execute();
|
|
}
|
|
|
|
private void saveIfNeeded()
|
|
{
|
|
if (!mDraftNeedsSaving || mPreventDraftSaving || mPgpData.hasEncryptionKeys())
|
|
{
|
|
return;
|
|
}
|
|
|
|
mDraftNeedsSaving = false;
|
|
saveMessage();
|
|
}
|
|
|
|
public void onEncryptionKeySelectionDone()
|
|
{
|
|
if (mPgpData.hasEncryptionKeys())
|
|
{
|
|
onSend();
|
|
}
|
|
else
|
|
{
|
|
Toast.makeText(this, R.string.send_aborted, Toast.LENGTH_SHORT).show();
|
|
}
|
|
}
|
|
|
|
public void onEncryptDone()
|
|
{
|
|
if (mPgpData.getEncryptedData() != null)
|
|
{
|
|
onSend();
|
|
}
|
|
else
|
|
{
|
|
Toast.makeText(this, R.string.send_aborted, Toast.LENGTH_SHORT).show();
|
|
}
|
|
}
|
|
|
|
private void onSend()
|
|
{
|
|
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();
|
|
return;
|
|
}
|
|
if (mEncryptCheckbox.isChecked() && !mPgpData.hasEncryptionKeys())
|
|
{
|
|
// key selection before encryption
|
|
String emails = "";
|
|
Address[][] addresses = new Address[][] { getAddresses(mToView),
|
|
getAddresses(mCcView),
|
|
getAddresses(mBccView)
|
|
};
|
|
for (Address[] addressArray : addresses)
|
|
{
|
|
for (Address address : addressArray)
|
|
{
|
|
if (emails.length() != 0)
|
|
{
|
|
emails += ",";
|
|
}
|
|
emails += address.getAddress();
|
|
}
|
|
}
|
|
if (emails.length() != 0)
|
|
{
|
|
emails += ",";
|
|
}
|
|
emails += mIdentity.getEmail();
|
|
|
|
mPreventDraftSaving = true;
|
|
if (!mAccount.getCryptoProvider().selectEncryptionKeys(MessageCompose.this, emails, mPgpData))
|
|
{
|
|
mPreventDraftSaving = false;
|
|
}
|
|
return;
|
|
}
|
|
if (mPgpData.hasEncryptionKeys() || mPgpData.hasSignatureKey())
|
|
{
|
|
if (mPgpData.getEncryptedData() == null)
|
|
{
|
|
String text = buildText(true);
|
|
mPreventDraftSaving = true;
|
|
if (!mAccount.getCryptoProvider().encrypt(this, text, mPgpData))
|
|
{
|
|
mPreventDraftSaving = false;
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
sendMessage();
|
|
mDraftNeedsSaving = false;
|
|
finish();
|
|
}
|
|
|
|
private void onDiscard()
|
|
{
|
|
if (mDraftUid != null)
|
|
{
|
|
MessagingController.getInstance(getApplication()).deleteDraft(mAccount, mDraftUid);
|
|
mDraftUid = null;
|
|
}
|
|
mHandler.sendEmptyMessage(MSG_DISCARDED_DRAFT);
|
|
mDraftNeedsSaving = false;
|
|
finish();
|
|
}
|
|
|
|
private void onSave()
|
|
{
|
|
mDraftNeedsSaving = true;
|
|
saveIfNeeded();
|
|
finish();
|
|
}
|
|
|
|
private void onAddCcBcc()
|
|
{
|
|
mCcView.setVisibility(View.VISIBLE);
|
|
mBccView.setVisibility(View.VISIBLE);
|
|
}
|
|
|
|
/**
|
|
* Kick off a picker for whatever kind of MIME types we'll accept and let Android take over.
|
|
*/
|
|
private void onAddAttachment()
|
|
{
|
|
if (K9.isGalleryBuggy())
|
|
{
|
|
if (K9.useGalleryBugWorkaround())
|
|
{
|
|
Toast.makeText(MessageCompose.this,
|
|
getString(R.string.message_compose_use_workaround),
|
|
Toast.LENGTH_LONG).show();
|
|
}
|
|
else
|
|
{
|
|
Toast.makeText(MessageCompose.this,
|
|
getString(R.string.message_compose_buggy_gallery),
|
|
Toast.LENGTH_LONG).show();
|
|
}
|
|
}
|
|
|
|
onAddAttachment2(K9.ACCEPTABLE_ATTACHMENT_SEND_TYPES[0]);
|
|
}
|
|
|
|
/**
|
|
* Kick off a picker for the specified MIME type and let Android take over.
|
|
*/
|
|
private void onAddAttachment2(final String mime_type)
|
|
{
|
|
if (mAccount.getCryptoProvider().isAvailable(this))
|
|
{
|
|
Toast.makeText(this, R.string.attachment_encryption_unsupported, Toast.LENGTH_LONG).show();
|
|
}
|
|
Intent i = new Intent(Intent.ACTION_GET_CONTENT);
|
|
i.addCategory(Intent.CATEGORY_OPENABLE);
|
|
i.setType(mime_type);
|
|
startActivityForResult(Intent.createChooser(i, null), ACTIVITY_REQUEST_PICK_ATTACHMENT);
|
|
}
|
|
|
|
private void addAttachment(Uri uri)
|
|
{
|
|
addAttachment(uri, -1, null);
|
|
}
|
|
|
|
private void addAttachment(Uri uri, int size, String name)
|
|
{
|
|
ContentResolver contentResolver = getContentResolver();
|
|
|
|
Attachment attachment = new Attachment();
|
|
attachment.name = name;
|
|
attachment.size = size;
|
|
attachment.uri = uri;
|
|
|
|
if (attachment.size == -1 || attachment.name == null)
|
|
{
|
|
Cursor metadataCursor = contentResolver.query(uri, new String[] { OpenableColumns.DISPLAY_NAME, OpenableColumns.SIZE }, null, null, null);
|
|
if (metadataCursor != null)
|
|
{
|
|
try
|
|
{
|
|
if (metadataCursor.moveToFirst())
|
|
{
|
|
if (attachment.name == null)
|
|
{
|
|
attachment.name = metadataCursor.getString(0);
|
|
}
|
|
if (attachment.size == -1)
|
|
{
|
|
attachment.size = metadataCursor.getInt(1);
|
|
Log.v(K9.LOG_TAG, "size: " + attachment.size);
|
|
}
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
metadataCursor.close();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (attachment.name == null)
|
|
{
|
|
attachment.name = uri.getLastPathSegment();
|
|
}
|
|
|
|
String contentType = contentResolver.getType(uri);
|
|
|
|
if (contentType == null)
|
|
{
|
|
contentType = MimeUtility.getMimeTypeByExtension(attachment.name);
|
|
}
|
|
|
|
attachment.contentType = contentType;
|
|
|
|
if (attachment.size<=0)
|
|
{
|
|
String uriString = uri.toString();
|
|
if (uriString.startsWith("file://"))
|
|
{
|
|
Log.v(K9.LOG_TAG, uriString.substring("file://".length()));
|
|
File f = new File(uriString.substring("file://".length()));
|
|
attachment.size = f.length();
|
|
}
|
|
else
|
|
{
|
|
Log.v(K9.LOG_TAG, "Not a file: " + uriString);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Log.v(K9.LOG_TAG, "old attachment.size: " + attachment.size);
|
|
}
|
|
Log.v(K9.LOG_TAG, "new attachment.size: " + attachment.size);
|
|
addAttachmentView(attachment);
|
|
|
|
}
|
|
|
|
private void addAttachmentView(Attachment attachment)
|
|
{
|
|
View view = getLayoutInflater().inflate(R.layout.message_compose_attachment, mAttachments, false);
|
|
TextView nameView = (TextView)view.findViewById(R.id.attachment_name);
|
|
ImageButton delete = (ImageButton)view.findViewById(R.id.attachment_delete);
|
|
nameView.setText(attachment.name);
|
|
delete.setOnClickListener(this);
|
|
delete.setTag(view);
|
|
view.setTag(attachment);
|
|
mAttachments.addView(view);
|
|
}
|
|
|
|
@Override
|
|
protected void onActivityResult(int requestCode, int resultCode, Intent data)
|
|
{
|
|
// if a CryptoSystem activity is returning, then mPreventDraftSaving was set to true
|
|
mPreventDraftSaving = false;
|
|
|
|
if (mAccount.getCryptoProvider().onActivityResult(this, requestCode, resultCode, data, mPgpData))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (resultCode != RESULT_OK)
|
|
return;
|
|
if (data == null)
|
|
{
|
|
return;
|
|
}
|
|
switch (requestCode)
|
|
{
|
|
case ACTIVITY_REQUEST_PICK_ATTACHMENT:
|
|
addAttachment(data.getData());
|
|
mDraftNeedsSaving = true;
|
|
break;
|
|
case ACTIVITY_CHOOSE_IDENTITY:
|
|
onIdentityChosen(data);
|
|
break;
|
|
case ACTIVITY_CHOOSE_ACCOUNT:
|
|
onAccountChosen(data);
|
|
break;
|
|
}
|
|
}
|
|
|
|
private void onAccountChosen(final Intent intent)
|
|
{
|
|
final Bundle extras = intent.getExtras();
|
|
final String uuid = extras.getString(ChooseAccount.EXTRA_ACCOUNT);
|
|
final Identity identity = (Identity) extras.getSerializable(ChooseAccount.EXTRA_IDENTITY);
|
|
|
|
final Account account = Preferences.getPreferences(this).getAccount(uuid);
|
|
|
|
if (!mAccount.equals(account))
|
|
{
|
|
if (K9.DEBUG)
|
|
{
|
|
Log.v(K9.LOG_TAG, "Switching account from " + mAccount + " to " + account);
|
|
}
|
|
|
|
// on draft edit, make sure we don't keep previous message UID
|
|
if (ACTION_EDIT_DRAFT.equals(getIntent().getAction()))
|
|
{
|
|
mMessageReference = null;
|
|
}
|
|
|
|
// test whether there is something to save
|
|
if (mDraftNeedsSaving || (mDraftUid != null))
|
|
{
|
|
final String previousDraftUid = mDraftUid;
|
|
final Account previousAccount = mAccount;
|
|
|
|
// make current message appear as new
|
|
mDraftUid = null;
|
|
|
|
// actual account switch
|
|
mAccount = account;
|
|
|
|
if (K9.DEBUG)
|
|
{
|
|
Log.v(K9.LOG_TAG, "Account switch, saving new draft in new account");
|
|
}
|
|
saveMessage();
|
|
|
|
if (previousDraftUid != null)
|
|
{
|
|
if (K9.DEBUG)
|
|
{
|
|
Log.v(K9.LOG_TAG, "Account switch, deleting draft from previous account: "
|
|
+ previousDraftUid);
|
|
}
|
|
MessagingController.getInstance(getApplication()).deleteDraft(previousAccount,
|
|
previousDraftUid);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
mAccount = account;
|
|
}
|
|
// not sure how to handle mFolder, mSourceMessage?
|
|
}
|
|
|
|
switchToIdentity(identity);
|
|
}
|
|
|
|
private void onIdentityChosen(Intent intent)
|
|
{
|
|
Bundle bundle = intent.getExtras();;
|
|
switchToIdentity((Identity)bundle.getSerializable(ChooseIdentity.EXTRA_IDENTITY));
|
|
}
|
|
|
|
private void switchToIdentity(Identity identity)
|
|
{
|
|
mIdentity = identity;
|
|
mIdentityChanged = true;
|
|
mDraftNeedsSaving = true;
|
|
updateFrom();
|
|
updateSignature();
|
|
}
|
|
|
|
private void updateFrom()
|
|
{
|
|
if (mIdentityChanged)
|
|
{
|
|
mFromView.setVisibility(View.VISIBLE);
|
|
}
|
|
mFromView.setText(getString(R.string.message_view_from_format, mIdentity.getName(), mIdentity.getEmail()));
|
|
}
|
|
|
|
private void updateSignature()
|
|
{
|
|
if (mIdentity.getSignatureUse())
|
|
{
|
|
mSignatureView.setText(mIdentity.getSignature());
|
|
mSignatureView.setVisibility(View.VISIBLE);
|
|
}
|
|
else
|
|
{
|
|
mSignatureView.setVisibility(View.GONE);
|
|
}
|
|
}
|
|
|
|
public void onClick(View view)
|
|
{
|
|
switch (view.getId())
|
|
{
|
|
case R.id.attachment_delete:
|
|
/*
|
|
* The view is the delete button, and we have previously set the tag of
|
|
* the delete button to the view that owns it. We don't use parent because the
|
|
* view is very complex and could change in the future.
|
|
*/
|
|
mAttachments.removeView((View) view.getTag());
|
|
mDraftNeedsSaving = true;
|
|
break;
|
|
case R.id.quoted_text_delete:
|
|
mQuotedTextBar.setVisibility(View.GONE);
|
|
mQuotedText.setVisibility(View.GONE);
|
|
mDraftNeedsSaving = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean onOptionsItemSelected(MenuItem item)
|
|
{
|
|
switch (item.getItemId())
|
|
{
|
|
case R.id.send:
|
|
mPgpData.setEncryptionKeys(null);
|
|
onSend();
|
|
break;
|
|
case R.id.save:
|
|
onSave();
|
|
break;
|
|
case R.id.discard:
|
|
onDiscard();
|
|
break;
|
|
case R.id.add_cc_bcc:
|
|
onAddCcBcc();
|
|
break;
|
|
case R.id.add_attachment:
|
|
onAddAttachment();
|
|
break;
|
|
case R.id.add_attachment_image:
|
|
onAddAttachment2("image/*");
|
|
break;
|
|
case R.id.add_attachment_video:
|
|
onAddAttachment2("video/*");
|
|
break;
|
|
case R.id.choose_identity:
|
|
onChooseIdentity();
|
|
break;
|
|
default:
|
|
return super.onOptionsItemSelected(item);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private void onChooseIdentity()
|
|
{
|
|
// keep things simple: trigger account choice only if there are more
|
|
// than 1 account
|
|
if (Preferences.getPreferences(this).getAvailableAccounts().size() > 1)
|
|
{
|
|
final Intent intent = new Intent(this, ChooseAccount.class);
|
|
intent.putExtra(ChooseAccount.EXTRA_ACCOUNT, mAccount.getUuid());
|
|
intent.putExtra(ChooseAccount.EXTRA_IDENTITY, mIdentity);
|
|
startActivityForResult(intent, ACTIVITY_CHOOSE_ACCOUNT);
|
|
}
|
|
else if (mAccount.getIdentities().size() > 1)
|
|
{
|
|
Intent intent = new Intent(this, ChooseIdentity.class);
|
|
intent.putExtra(ChooseIdentity.EXTRA_ACCOUNT, mAccount.getUuid());
|
|
startActivityForResult(intent, ACTIVITY_CHOOSE_IDENTITY);
|
|
}
|
|
else
|
|
{
|
|
Toast.makeText(this, getString(R.string.no_identities),
|
|
Toast.LENGTH_LONG).show();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean onCreateOptionsMenu(Menu menu)
|
|
{
|
|
super.onCreateOptionsMenu(menu);
|
|
getMenuInflater().inflate(R.menu.message_compose_option, menu);
|
|
|
|
/*
|
|
* Show the menu items "Add attachment (Image)" and "Add attachment (Video)"
|
|
* if the work-around for the Gallery bug is enabled (see Issue 1186).
|
|
*/
|
|
int found = 0;
|
|
for (int i = menu.size() - 1; i >= 0; i--)
|
|
{
|
|
MenuItem item = menu.getItem(i);
|
|
int id = item.getItemId();
|
|
if ((id == R.id.add_attachment_image) ||
|
|
(id == R.id.add_attachment_video))
|
|
{
|
|
item.setVisible(K9.useGalleryBugWorkaround());
|
|
found++;
|
|
}
|
|
|
|
// We found all the menu items we were looking for. So stop here.
|
|
if (found == 2) break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public void onBackPressed()
|
|
{
|
|
// This will be called either automatically for you on 2.0
|
|
// or later, or by the code above on earlier versions of the
|
|
// platform.
|
|
if (mDraftNeedsSaving)
|
|
{
|
|
showDialog(DIALOG_SAVE_OR_DISCARD_DRAFT_MESSAGE);
|
|
}
|
|
else
|
|
{
|
|
finish();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public Dialog onCreateDialog(int id)
|
|
{
|
|
switch (id)
|
|
{
|
|
case DIALOG_SAVE_OR_DISCARD_DRAFT_MESSAGE:
|
|
return new AlertDialog.Builder(this)
|
|
.setTitle(R.string.save_or_discard_draft_message_dlg_title)
|
|
.setMessage(R.string.save_or_discard_draft_message_instructions_fmt)
|
|
.setPositiveButton(R.string.save_draft_action, new DialogInterface.OnClickListener()
|
|
{
|
|
public void onClick(DialogInterface dialog, int whichButton)
|
|
{
|
|
dismissDialog(1);
|
|
onSave();
|
|
}
|
|
})
|
|
.setNegativeButton(R.string.discard_action, new DialogInterface.OnClickListener()
|
|
{
|
|
public void onClick(DialogInterface dialog, int whichButton)
|
|
{
|
|
dismissDialog(1);
|
|
onDiscard();
|
|
}
|
|
})
|
|
.create();
|
|
}
|
|
return super.onCreateDialog(id);
|
|
}
|
|
|
|
@Override
|
|
public boolean onKeyDown(int keyCode, KeyEvent event)
|
|
{
|
|
if (
|
|
// TODO - when we move to android 2.0, uncomment this.
|
|
// android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.ECLAIR &&
|
|
|
|
keyCode == KeyEvent.KEYCODE_BACK
|
|
&& event.getRepeatCount() == 0
|
|
&& K9.manageBack())
|
|
{
|
|
// Take care of calling this method on earlier versions of
|
|
// the platform where it doesn't exist.
|
|
onBackPressed();
|
|
return true;
|
|
}
|
|
|
|
return super.onKeyDown(keyCode, event);
|
|
}
|
|
|
|
/**
|
|
* Returns true if all attachments were able to be attached, otherwise returns false.
|
|
*/
|
|
private boolean loadAttachments(Part part, int depth) throws MessagingException
|
|
{
|
|
if (part.getBody() instanceof Multipart)
|
|
{
|
|
Multipart mp = (Multipart) part.getBody();
|
|
boolean ret = true;
|
|
for (int i = 0, count = mp.getCount(); i < count; i++)
|
|
{
|
|
if (!loadAttachments(mp.getBodyPart(i), depth + 1))
|
|
{
|
|
ret = false;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
else
|
|
{
|
|
String contentType = MimeUtility.unfoldAndDecode(part.getContentType());
|
|
String name = MimeUtility.getHeaderParameter(contentType, "name");
|
|
if (name != null)
|
|
{
|
|
Body body = part.getBody();
|
|
if (body != null && body instanceof LocalAttachmentBody)
|
|
{
|
|
final Uri uri = ((LocalAttachmentBody) body).getContentUri();
|
|
mHandler.post(new Runnable()
|
|
{
|
|
public void run()
|
|
{
|
|
addAttachment(uri);
|
|
}
|
|
});
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
* @param message
|
|
*/
|
|
private void processSourceMessage(Message message)
|
|
{
|
|
String action = getIntent().getAction();
|
|
if (ACTION_REPLY.equals(action) || ACTION_REPLY_ALL.equals(action))
|
|
{
|
|
try
|
|
{
|
|
if (message.getSubject() != null)
|
|
{
|
|
final String subject = prefix.matcher(message.getSubject()).replaceFirst("");
|
|
|
|
if (!subject.toLowerCase().startsWith("re:"))
|
|
{
|
|
mSubjectView.setText("Re: " + subject);
|
|
}
|
|
else
|
|
{
|
|
mSubjectView.setText(subject);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
mSubjectView.setText("");
|
|
}
|
|
|
|
/*
|
|
* If a reply-to was included with the message use that, otherwise use the from
|
|
* or sender address.
|
|
*/
|
|
Address[] replyToAddresses;
|
|
if (message.getReplyTo().length > 0)
|
|
{
|
|
addAddresses(mToView, replyToAddresses = message.getReplyTo());
|
|
}
|
|
else
|
|
{
|
|
addAddresses(mToView, replyToAddresses = message.getFrom());
|
|
}
|
|
|
|
if (message.getMessageId() != null && message.getMessageId().length() > 0)
|
|
{
|
|
String messageId = message.getMessageId();
|
|
mInReplyTo = messageId;
|
|
|
|
if (message.getReferences() != null && message.getReferences().length > 0)
|
|
{
|
|
StringBuffer buffy = new StringBuffer();
|
|
for (int i=0; i < message.getReferences().length; i++)
|
|
buffy.append(message.getReferences()[i]);
|
|
|
|
mReferences = buffy.toString() + " " + mInReplyTo;
|
|
}
|
|
else
|
|
{
|
|
mReferences = mInReplyTo;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
if (K9.DEBUG)
|
|
Log.d(K9.LOG_TAG, "could not get Message-ID.");
|
|
}
|
|
|
|
Part part = MimeUtility.findFirstPartByMimeType(mSourceMessage,
|
|
"text/plain");
|
|
if (part != null || mSourceMessageBody != null)
|
|
{
|
|
String quotedText = String.format(
|
|
getString(R.string.message_compose_reply_header_fmt),
|
|
Address.toString(mSourceMessage.getFrom()));
|
|
|
|
final String prefix = mAccount.getQuotePrefix();
|
|
// "$" and "\" in the quote prefix have to be escaped for
|
|
// the replaceAll() invocation.
|
|
final String escapedPrefix = prefix.replaceAll("(\\\\|\\$)", "\\\\$1");
|
|
|
|
final String text = (mSourceMessageBody != null) ?
|
|
mSourceMessageBody :
|
|
MimeUtility.getTextFromPart(part);
|
|
|
|
final String wrappedText = Utility.wrap(text, REPLY_WRAP_LINE_WIDTH - prefix.length());
|
|
|
|
quotedText += wrappedText.replaceAll("(?m)^", escapedPrefix);
|
|
|
|
quotedText = quotedText.replaceAll("\\\r", "");
|
|
mQuotedText.setText(quotedText);
|
|
|
|
mQuotedTextBar.setVisibility(View.VISIBLE);
|
|
mQuotedText.setVisibility(View.VISIBLE);
|
|
}
|
|
|
|
if (ACTION_REPLY_ALL.equals(action) || ACTION_REPLY.equals(action))
|
|
{
|
|
Identity useIdentity = null;
|
|
for (Address address : message.getRecipients(RecipientType.TO))
|
|
{
|
|
Identity identity = mAccount.findIdentity(address);
|
|
if (identity != null)
|
|
{
|
|
useIdentity = identity;
|
|
break;
|
|
}
|
|
}
|
|
if (useIdentity == null)
|
|
{
|
|
if (message.getRecipients(RecipientType.CC).length > 0)
|
|
{
|
|
for (Address address : message.getRecipients(RecipientType.CC))
|
|
{
|
|
Identity identity = mAccount.findIdentity(address);
|
|
if (identity != null)
|
|
{
|
|
useIdentity = identity;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (useIdentity != null)
|
|
{
|
|
Identity defaultIdentity = mAccount.getIdentity(0);
|
|
if (useIdentity != defaultIdentity)
|
|
{
|
|
switchToIdentity(useIdentity);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (ACTION_REPLY_ALL.equals(action))
|
|
{
|
|
for (Address address : message.getRecipients(RecipientType.TO))
|
|
{
|
|
if (!mAccount.isAnIdentity(address))
|
|
{
|
|
addAddress(mToView, address);
|
|
}
|
|
|
|
}
|
|
if (message.getRecipients(RecipientType.CC).length > 0)
|
|
{
|
|
for (Address address : message.getRecipients(RecipientType.CC))
|
|
{
|
|
if (!mAccount.isAnIdentity(address) && !Utility.arrayContains(replyToAddresses, address))
|
|
{
|
|
addAddress(mCcView, address);
|
|
}
|
|
|
|
}
|
|
mCcView.setVisibility(View.VISIBLE);
|
|
}
|
|
}
|
|
}
|
|
catch (MessagingException me)
|
|
{
|
|
/*
|
|
* This really should not happen at this point but if it does it's okay.
|
|
* The user can continue composing their message.
|
|
*/
|
|
}
|
|
}
|
|
else if (ACTION_FORWARD.equals(action))
|
|
{
|
|
try
|
|
{
|
|
if (message.getSubject() != null && !message.getSubject().toLowerCase().startsWith("fwd:"))
|
|
{
|
|
mSubjectView.setText("Fwd: " + message.getSubject());
|
|
}
|
|
else
|
|
{
|
|
mSubjectView.setText(message.getSubject());
|
|
}
|
|
|
|
String quotedText = null;
|
|
Part part = null;
|
|
|
|
if ( mSourceMessageBody != null)
|
|
{
|
|
quotedText = mSourceMessageBody;
|
|
}
|
|
|
|
if (quotedText == null)
|
|
{
|
|
part = MimeUtility.findFirstPartByMimeType(message, "text/plain");
|
|
if (part != null)
|
|
{
|
|
quotedText = MimeUtility.getTextFromPart(part);
|
|
}
|
|
}
|
|
if (quotedText == null)
|
|
{
|
|
part = MimeUtility.findFirstPartByMimeType(message, "text/html");
|
|
if (part != null)
|
|
{
|
|
quotedText = MimeUtility.getTextFromPart(part);
|
|
if (quotedText != null)
|
|
{
|
|
quotedText = (Html.fromHtml(quotedText)).toString();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
if (quotedText != null)
|
|
{
|
|
String text = String.format(
|
|
getString(R.string.message_compose_fwd_header_fmt),
|
|
mSourceMessage.getSubject(),
|
|
Address.toString(mSourceMessage.getFrom()),
|
|
Address.toString(
|
|
mSourceMessage.getRecipients(RecipientType.TO)),
|
|
Address.toString(
|
|
mSourceMessage.getRecipients(RecipientType.CC)));
|
|
if (quotedText != null)
|
|
{
|
|
|
|
quotedText = quotedText.replaceAll("\\\r", "");
|
|
mQuotedText.setText(text);
|
|
mQuotedText.append(quotedText);
|
|
}
|
|
mQuotedTextBar.setVisibility(View.VISIBLE);
|
|
mQuotedText.setVisibility(View.VISIBLE);
|
|
}
|
|
if (!mSourceMessageProcessed)
|
|
{
|
|
if (!loadAttachments(message, 0))
|
|
{
|
|
mHandler.sendEmptyMessage(MSG_SKIPPED_ATTACHMENTS);
|
|
}
|
|
}
|
|
}
|
|
catch (MessagingException me)
|
|
{
|
|
/*
|
|
* This really should not happen at this point but if it does it's okay.
|
|
* The user can continue composing their message.
|
|
*/
|
|
}
|
|
}
|
|
else if (ACTION_EDIT_DRAFT.equals(action))
|
|
{
|
|
try
|
|
{
|
|
mDraftUid = message.getUid();
|
|
mSubjectView.setText(message.getSubject());
|
|
addAddresses(mToView, message.getRecipients(RecipientType.TO));
|
|
if (message.getRecipients(RecipientType.CC).length > 0)
|
|
{
|
|
addAddresses(mCcView, message.getRecipients(RecipientType.CC));
|
|
mCcView.setVisibility(View.VISIBLE);
|
|
}
|
|
if (message.getRecipients(RecipientType.BCC).length > 0)
|
|
{
|
|
addAddresses(mBccView, message.getRecipients(RecipientType.BCC));
|
|
mBccView.setVisibility(View.VISIBLE);
|
|
}
|
|
|
|
// Read In-Reply-To header from draft
|
|
final String[] inReplyTo = message.getHeader("In-Reply-To");
|
|
if ((inReplyTo != null) && (inReplyTo.length >= 1))
|
|
{
|
|
mInReplyTo = inReplyTo[0];
|
|
}
|
|
|
|
// Read References header from draft
|
|
final String[] references = message.getHeader("References");
|
|
if ((references != null) && (references.length >= 1))
|
|
{
|
|
mReferences = references[0];
|
|
}
|
|
|
|
if (!mSourceMessageProcessed)
|
|
{
|
|
loadAttachments(message, 0);
|
|
}
|
|
Integer bodyLength = null;
|
|
String[] k9identities = message.getHeader(K9.K9MAIL_IDENTITY);
|
|
if (k9identities != null && k9identities.length > 0)
|
|
{
|
|
String k9identity = k9identities[0];
|
|
|
|
if (k9identity != null)
|
|
{
|
|
if (K9.DEBUG)
|
|
Log.d(K9.LOG_TAG, "Got a saved identity: " + k9identity);
|
|
StringTokenizer tokens = new StringTokenizer(k9identity, ":", false);
|
|
|
|
String bodyLengthS = null;
|
|
String name = null;
|
|
String email = null;
|
|
String signature = null;
|
|
boolean signatureUse = message.getFolder().getAccount().getSignatureUse();
|
|
if (tokens.hasMoreTokens())
|
|
{
|
|
bodyLengthS = Utility.base64Decode(tokens.nextToken());
|
|
try
|
|
{
|
|
bodyLength = Integer.parseInt(bodyLengthS);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Log.e(K9.LOG_TAG, "Unable to parse bodyLength '" + bodyLengthS + "'");
|
|
}
|
|
}
|
|
if (tokens.hasMoreTokens())
|
|
{
|
|
signatureUse = true;
|
|
signature = Utility.base64Decode(tokens.nextToken());
|
|
}
|
|
if (tokens.hasMoreTokens())
|
|
{
|
|
name = Utility.base64Decode(tokens.nextToken());
|
|
}
|
|
if (tokens.hasMoreTokens())
|
|
{
|
|
email = Utility.base64Decode(tokens.nextToken());
|
|
}
|
|
|
|
Identity newIdentity = new Identity();
|
|
newIdentity.setSignatureUse(signatureUse);
|
|
if (signature != null)
|
|
{
|
|
newIdentity.setSignature(signature);
|
|
mSignatureChanged = true;
|
|
}
|
|
else
|
|
{
|
|
newIdentity.setSignature(mIdentity.getSignature());
|
|
}
|
|
|
|
if (name != null)
|
|
{
|
|
newIdentity.setName(name);
|
|
mIdentityChanged = true;
|
|
}
|
|
else
|
|
{
|
|
newIdentity.setName(mIdentity.getName());
|
|
}
|
|
|
|
if (email != null)
|
|
{
|
|
newIdentity.setEmail(email);
|
|
mIdentityChanged = true;
|
|
}
|
|
else
|
|
{
|
|
newIdentity.setEmail(mIdentity.getEmail());
|
|
}
|
|
|
|
mIdentity = newIdentity;
|
|
|
|
updateSignature();
|
|
updateFrom();
|
|
|
|
}
|
|
}
|
|
Part part = MimeUtility.findFirstPartByMimeType(message, "text/plain");
|
|
if (part != null)
|
|
{
|
|
String text = MimeUtility.getTextFromPart(part);
|
|
if (bodyLength != null && bodyLength + 1 < text.length()) // + 1 to get rid of the newline we added when saving the draft
|
|
{
|
|
String bodyText = text.substring(0, bodyLength);
|
|
String quotedText = text.substring(bodyLength + 1, text.length());
|
|
|
|
mMessageContentView.setText(bodyText);
|
|
mQuotedText.setText(quotedText);
|
|
|
|
mQuotedTextBar.setVisibility(View.VISIBLE);
|
|
mQuotedText.setVisibility(View.VISIBLE);
|
|
}
|
|
else
|
|
{
|
|
mMessageContentView.setText(text);
|
|
}
|
|
}
|
|
}
|
|
catch (MessagingException me)
|
|
{
|
|
// TODO
|
|
}
|
|
}
|
|
mSourceMessageProcessed = true;
|
|
mDraftNeedsSaving = false;
|
|
}
|
|
|
|
class Listener extends MessagingListener
|
|
{
|
|
@Override
|
|
public void loadMessageForViewStarted(Account account, String folder, String uid)
|
|
{
|
|
if ((mMessageReference == null) || !mMessageReference.uid.equals(uid))
|
|
{
|
|
return;
|
|
}
|
|
|
|
mHandler.sendEmptyMessage(MSG_PROGRESS_ON);
|
|
}
|
|
|
|
@Override
|
|
public void loadMessageForViewFinished(Account account, String folder, String uid, Message message)
|
|
{
|
|
if ((mMessageReference == null) || !mMessageReference.uid.equals(uid))
|
|
{
|
|
return;
|
|
}
|
|
|
|
mHandler.sendEmptyMessage(MSG_PROGRESS_OFF);
|
|
}
|
|
|
|
@Override
|
|
public void loadMessageForViewBodyAvailable(Account account, String folder, String uid, final Message message)
|
|
{
|
|
if ((mMessageReference == null) || !mMessageReference.uid.equals(uid))
|
|
{
|
|
return;
|
|
}
|
|
|
|
mSourceMessage = message;
|
|
runOnUiThread(new Runnable()
|
|
{
|
|
public void run()
|
|
{
|
|
processSourceMessage(message);
|
|
}
|
|
});
|
|
}
|
|
|
|
@Override
|
|
public void loadMessageForViewFailed(Account account, String folder, String uid, Throwable t)
|
|
{
|
|
if ((mMessageReference == null) || !mMessageReference.uid.equals(uid))
|
|
{
|
|
return;
|
|
}
|
|
mHandler.sendEmptyMessage(MSG_PROGRESS_OFF);
|
|
// TODO show network error
|
|
}
|
|
|
|
@Override
|
|
public void messageUidChanged(Account account, String folder, String oldUid, String newUid)
|
|
{
|
|
//TODO: is this really necessary here? mDraftUid is update after the call to MessagingController.saveDraft()
|
|
// Track UID changes of the draft message
|
|
if (account.equals(mAccount) &&
|
|
folder.equals(mAccount.getDraftsFolderName()) &&
|
|
oldUid.equals(mDraftUid))
|
|
{
|
|
mDraftUid = newUid;
|
|
}
|
|
|
|
// Track UID changes of the source message
|
|
if (mMessageReference != null)
|
|
{
|
|
final Account sourceAccount = Preferences.getPreferences(MessageCompose.this).getAccount(mMessageReference.accountUuid);
|
|
final String sourceFolder = mMessageReference.folderName;
|
|
final String sourceMessageUid = mMessageReference.uid;
|
|
|
|
if (account.equals(sourceAccount) && (folder.equals(sourceFolder)))
|
|
{
|
|
if (oldUid.equals(sourceMessageUid))
|
|
{
|
|
mMessageReference.uid = newUid;
|
|
}
|
|
if ((mSourceMessage != null) && (oldUid.equals(mSourceMessage.getUid())))
|
|
{
|
|
mSourceMessage.setUid(newUid);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private String decode(String s)
|
|
throws UnsupportedEncodingException
|
|
{
|
|
return URLDecoder.decode(s, "UTF-8");
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
*
|
|
* @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));
|
|
}
|
|
mToView.setText(to);
|
|
}
|
|
catch (UnsupportedEncodingException e)
|
|
{
|
|
Log.e(K9.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);
|
|
|
|
String addressList;
|
|
|
|
addressList = "";
|
|
List<String> cc = uri.getQueryParameters("cc");
|
|
for (String address : cc)
|
|
{
|
|
addressList += address + ",";
|
|
}
|
|
mCcView.setText(addressList);
|
|
|
|
addressList = "";
|
|
List<String> bcc = uri.getQueryParameters("bcc");
|
|
for (String address : bcc)
|
|
{
|
|
addressList += address + ",";
|
|
}
|
|
mBccView.setText(addressList);
|
|
|
|
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)
|
|
{
|
|
mMessageContentView.setText(body.get(0));
|
|
}
|
|
}
|
|
|
|
private class SendMessageTask extends AsyncTask<Void, Void, Void>
|
|
{
|
|
@Override
|
|
protected Void doInBackground(Void... params)
|
|
{
|
|
/*
|
|
* Create the message from all the data the user has entered.
|
|
*/
|
|
MimeMessage message;
|
|
try
|
|
{
|
|
message = createMessage(true); // Only append sig on save
|
|
}
|
|
catch (MessagingException me)
|
|
{
|
|
Log.e(K9.LOG_TAG, "Failed to create new message for send or save.", me);
|
|
throw new RuntimeException("Failed to create a new message for send or save.", me);
|
|
}
|
|
|
|
try
|
|
{
|
|
final Contacts contacts = Contacts.getInstance(MessageCompose.this);
|
|
contacts.markAsContacted(message.getRecipients(RecipientType.TO));
|
|
contacts.markAsContacted(message.getRecipients(RecipientType.CC));
|
|
contacts.markAsContacted(message.getRecipients(RecipientType.BCC));
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Log.e(K9.LOG_TAG, "Failed to mark contact as contacted.", e);
|
|
}
|
|
|
|
MessagingController.getInstance(getApplication()).sendMessage(mAccount, message, null);
|
|
if (mDraftUid != null)
|
|
{
|
|
MessagingController.getInstance(getApplication()).deleteDraft(mAccount, mDraftUid);
|
|
mDraftUid = null;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private class SaveMessageTask extends AsyncTask<Void, Void, Void>
|
|
{
|
|
@Override
|
|
protected Void doInBackground(Void... params)
|
|
{
|
|
|
|
/*
|
|
* Create the message from all the data the user has entered.
|
|
*/
|
|
MimeMessage message;
|
|
try
|
|
{
|
|
message = createMessage(false); // Only append sig on save
|
|
}
|
|
catch (MessagingException me)
|
|
{
|
|
Log.e(K9.LOG_TAG, "Failed to create new message for send or save.", me);
|
|
throw new RuntimeException("Failed to create a new message for send or save.", me);
|
|
}
|
|
|
|
/*
|
|
* Save a draft
|
|
*/
|
|
if (mDraftUid != null)
|
|
{
|
|
message.setUid(mDraftUid);
|
|
}
|
|
else if (ACTION_EDIT_DRAFT.equals(getIntent().getAction()))
|
|
{
|
|
/*
|
|
* We're saving a previously saved draft, so update the new message's uid
|
|
* to the old message's uid.
|
|
*/
|
|
if (mMessageReference != null)
|
|
{
|
|
message.setUid(mMessageReference.uid);
|
|
}
|
|
}
|
|
|
|
String k9identity = Utility.base64Encode("" + mMessageContentView.getText().toString().length());
|
|
|
|
if (mIdentityChanged || mSignatureChanged)
|
|
{
|
|
String signature = mSignatureView.getText().toString();
|
|
k9identity += ":" + Utility.base64Encode(signature);
|
|
if (mIdentityChanged)
|
|
{
|
|
|
|
String name = mIdentity.getName();
|
|
String email = mIdentity.getEmail();
|
|
|
|
k9identity += ":" + Utility.base64Encode(name) + ":" + Utility.base64Encode(email);
|
|
}
|
|
}
|
|
|
|
final MessagingController messagingController = MessagingController.getInstance(getApplication());
|
|
|
|
if (K9.DEBUG)
|
|
{
|
|
Log.d(K9.LOG_TAG, "Saving identity: " + k9identity);
|
|
}
|
|
try
|
|
{
|
|
message.addHeader(K9.K9MAIL_IDENTITY, k9identity);
|
|
}
|
|
catch (UnavailableStorageException e)
|
|
{
|
|
messagingController.addErrorMessage(mAccount, "Unable to save identity", e);
|
|
}
|
|
|
|
Message draftMessage = messagingController.saveDraft(mAccount, message);
|
|
mDraftUid = draftMessage.getUid();
|
|
|
|
// Don't display the toast if the user is just changing the orientation
|
|
if ((getChangingConfigurations() & ActivityInfo.CONFIG_ORIENTATION) == 0)
|
|
{
|
|
mHandler.sendEmptyMessage(MSG_SAVED_DRAFT);
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
|
|
}
|