@Override
public boolean create(FolderType type) throws MessagingException {
/*
* This method needs to operate in the unselected mode as well as the selected mode
* so we must get the connection ourselves if it's not there. We are specifically
* not calling checkOpen() since we don't care if the folder is open.
*/
ImapConnection connection = null;
synchronized (this) {
if (mConnection == null) {
connection = mStore.getConnection();
} else {
connection = mConnection;
}
}
try {
connection.executeSimpleCommand(
String.format(
ImapConstants.CREATE + " \"%s\"",
ImapStore.encodeFolderName(mName, mStore.mPathPrefix)));
return true;
} catch (MessagingException me) {
return false;
} catch (IOException ioe) {
throw ioExceptionHandler(connection, ioe);
} finally {
connection.destroyResponses();
if (mConnection == null) {
mStore.poolConnection(connection);
}
}
}
@Override
public int getUnreadMessageCount() throws MessagingException {
checkOpen();
try {
int unreadMessageCount = 0;
List<ImapResponse> responses =
mConnection.executeSimpleCommand(
String.format(
ImapConstants.STATUS + " \"%s\" (" + ImapConstants.UNSEEN + ")",
ImapStore.encodeFolderName(mName, mStore.mPathPrefix)));
// S: * STATUS mboxname (MESSAGES 231 UIDNEXT 44292)
for (ImapResponse response : responses) {
if (response.isDataResponse(0, ImapConstants.STATUS)) {
unreadMessageCount =
response
.getListOrEmpty(2)
.getKeyedStringOrEmpty(ImapConstants.UNSEEN)
.getNumberOrZero();
}
}
return unreadMessageCount;
} catch (IOException ioe) {
throw ioExceptionHandler(mConnection, ioe);
} finally {
destroyResponses();
}
}
/**
* Selects the folder for use. Before performing any operations on this folder, it must be
* selected.
*/
private void doSelect() throws IOException, MessagingException {
List<ImapResponse> responses =
mConnection.executeSimpleCommand(
String.format(
ImapConstants.SELECT + " \"%s\"",
ImapStore.encodeFolderName(mName, mStore.mPathPrefix)));
// Assume the folder is opened read-write; unless we are notified otherwise
mMode = OpenMode.READ_WRITE;
int messageCount = -1;
for (ImapResponse response : responses) {
if (response.isDataResponse(1, ImapConstants.EXISTS)) {
messageCount = response.getStringOrEmpty(0).getNumberOrZero();
} else if (response.isOk()) {
final ImapString responseCode = response.getResponseCodeOrEmpty();
if (responseCode.is(ImapConstants.READ_ONLY)) {
mMode = OpenMode.READ_ONLY;
} else if (responseCode.is(ImapConstants.READ_WRITE)) {
mMode = OpenMode.READ_WRITE;
}
} else if (response.isTagged()) { // Not OK
throw new MessagingException(
"Can't open mailbox: " + response.getStatusResponseTextOrEmpty());
}
}
if (messageCount == -1) {
throw new MessagingException("Did not find message count during select");
}
mMessageCount = messageCount;
mExists = true;
}
@Override
public void setFlags(Message[] messages, Flag[] flags, boolean value) throws MessagingException {
checkOpen();
String allFlags = "";
if (flags.length > 0) {
StringBuilder flagList = new StringBuilder();
for (int i = 0, count = flags.length; i < count; i++) {
Flag flag = flags[i];
if (flag == Flag.SEEN) {
flagList.append(" " + ImapConstants.FLAG_SEEN);
} else if (flag == Flag.DELETED) {
flagList.append(" " + ImapConstants.FLAG_DELETED);
} else if (flag == Flag.FLAGGED) {
flagList.append(" " + ImapConstants.FLAG_FLAGGED);
} else if (flag == Flag.ANSWERED) {
flagList.append(" " + ImapConstants.FLAG_ANSWERED);
}
}
allFlags = flagList.substring(1);
}
try {
mConnection.executeSimpleCommand(
String.format(
ImapConstants.UID_STORE + " %s %s" + ImapConstants.FLAGS_SILENT + " (%s)",
ImapStore.joinMessageUids(messages),
value ? "+" : "-",
allFlags));
} catch (IOException ioe) {
throw ioExceptionHandler(mConnection, ioe);
} finally {
destroyResponses();
}
}
@Override
public void close(boolean expunge) {
// TODO implement expunge
mMessageCount = -1;
synchronized (this) {
mStore.poolConnection(mConnection);
mConnection = null;
}
}
@Override
public boolean exists() throws MessagingException {
if (mExists) {
return true;
}
/*
* This method needs to operate in the unselected mode as well as the selected mode
* so we must get the connection ourselves if it's not there. We are specifically
* not calling checkOpen() since we don't care if the folder is open.
*/
ImapConnection connection = null;
synchronized (this) {
if (mConnection == null) {
connection = mStore.getConnection();
} else {
connection = mConnection;
}
}
try {
connection.executeSimpleCommand(
String.format(
ImapConstants.STATUS + " \"%s\" (" + ImapConstants.UIDVALIDITY + ")",
ImapStore.encodeFolderName(mName, mStore.mPathPrefix)));
mExists = true;
return true;
} catch (MessagingException me) {
// Treat IOERROR messaging exception as IOException
if (me.getExceptionType() == MessagingException.IOERROR) {
throw me;
}
return false;
} catch (IOException ioe) {
throw ioExceptionHandler(connection, ioe);
} finally {
connection.destroyResponses();
if (mConnection == null) {
mStore.poolConnection(connection);
}
}
}
@Override
public void open(OpenMode mode) throws MessagingException {
try {
if (isOpen()) {
if (mMode == mode) {
// Make sure the connection is valid.
// If it's not we'll close it down and continue on to get a new one.
try {
mConnection.executeSimpleCommand(ImapConstants.NOOP);
return;
} catch (IOException ioe) {
ioExceptionHandler(mConnection, ioe);
} finally {
destroyResponses();
}
} else {
// Return the connection to the pool, if exists.
close(false);
}
}
synchronized (this) {
mConnection = mStore.getConnection();
}
// * FLAGS (\Answered \Flagged \Deleted \Seen \Draft NonJunk
// $MDNSent)
// * OK [PERMANENTFLAGS (\Answered \Flagged \Deleted \Seen \Draft
// NonJunk $MDNSent \*)] Flags permitted.
// * 23 EXISTS
// * 0 RECENT
// * OK [UIDVALIDITY 1125022061] UIDs valid
// * OK [UIDNEXT 57576] Predicted next UID
// 2 OK [READ-WRITE] Select completed.
try {
doSelect();
} catch (IOException ioe) {
throw ioExceptionHandler(mConnection, ioe);
} finally {
destroyResponses();
}
} catch (AuthenticationFailedException e) {
// Don't cache this connection, so we're forced to try connecting/login again
mConnection = null;
close(false);
throw e;
} catch (MessagingException e) {
mExists = false;
close(false);
throw e;
}
}
/**
* Appends the given messages to the selected folder. This implementation also determines the new
* UID of the given message on the IMAP server and sets the Message's UID to the new server UID.
*/
@Override
public void appendMessages(Message[] messages) throws MessagingException {
checkOpen();
try {
for (Message message : messages) {
// Create output count
CountingOutputStream out = new CountingOutputStream();
EOLConvertingOutputStream eolOut = new EOLConvertingOutputStream(out);
message.writeTo(eolOut);
eolOut.flush();
// Create flag list (most often this will be "\SEEN")
String flagList = "";
Flag[] flags = message.getFlags();
if (flags.length > 0) {
StringBuilder sb = new StringBuilder();
for (int i = 0, count = flags.length; i < count; i++) {
Flag flag = flags[i];
if (flag == Flag.SEEN) {
sb.append(" " + ImapConstants.FLAG_SEEN);
} else if (flag == Flag.FLAGGED) {
sb.append(" " + ImapConstants.FLAG_FLAGGED);
}
}
if (sb.length() > 0) {
flagList = sb.substring(1);
}
}
mConnection.sendCommand(
String.format(
ImapConstants.APPEND + " \"%s\" (%s) {%d}",
ImapStore.encodeFolderName(mName, mStore.mPathPrefix),
flagList,
out.getCount()),
false);
ImapResponse response;
do {
response = mConnection.readResponse();
if (response.isContinuationRequest()) {
eolOut = new EOLConvertingOutputStream(mConnection.mTransport.getOutputStream());
message.writeTo(eolOut);
eolOut.write('\r');
eolOut.write('\n');
eolOut.flush();
} else if (!response.isTagged()) {
handleUntaggedResponse(response);
}
} while (!response.isTagged());
// TODO Why not check the response?
/*
* Try to recover the UID of the message from an APPENDUID response.
* e.g. 11 OK [APPENDUID 2 238268] APPEND completed
*/
final ImapList appendList = response.getListOrEmpty(1);
if ((appendList.size() >= 3) && appendList.is(0, ImapConstants.APPENDUID)) {
String serverUid = appendList.getStringOrEmpty(2).getString();
if (!TextUtils.isEmpty(serverUid)) {
message.setUid(serverUid);
continue;
}
}
/*
* Try to find the UID of the message we just appended using the
* Message-ID header. If there are more than one response, take the
* last one, as it's most likely the newest (the one we just uploaded).
*/
String messageId = message.getMessageId();
if (messageId == null || messageId.length() == 0) {
continue;
}
// Most servers don't care about parenthesis in the search query [and, some
// fail to work if they are used]
String[] uids = searchForUids(String.format("HEADER MESSAGE-ID %s", messageId));
if (uids.length > 0) {
message.setUid(uids[0]);
}
// However, there's at least one server [AOL] that fails to work unless there
// are parenthesis, so, try this as a last resort
uids = searchForUids(String.format("(HEADER MESSAGE-ID %s)", messageId));
if (uids.length > 0) {
message.setUid(uids[0]);
}
}
} catch (IOException ioe) {
throw ioExceptionHandler(mConnection, ioe);
} finally {
destroyResponses();
}
}
public void fetchInternal(Message[] messages, FetchProfile fp, MessageRetrievalListener listener)
throws MessagingException {
if (messages.length == 0) {
return;
}
checkOpen();
HashMap<String, Message> messageMap = new HashMap<String, Message>();
for (Message m : messages) {
messageMap.put(m.getUid(), m);
}
/*
* Figure out what command we are going to run:
* FLAGS - UID FETCH (FLAGS)
* ENVELOPE - UID FETCH (INTERNALDATE UID RFC822.SIZE FLAGS BODY.PEEK[
* HEADER.FIELDS (date subject from content-type to cc)])
* STRUCTURE - UID FETCH (BODYSTRUCTURE)
* BODY_SANE - UID FETCH (BODY.PEEK[]<0.N>) where N = max bytes returned
* BODY - UID FETCH (BODY.PEEK[])
* Part - UID FETCH (BODY.PEEK[ID]) where ID = mime part ID
*/
final LinkedHashSet<String> fetchFields = new LinkedHashSet<String>();
fetchFields.add(ImapConstants.UID);
if (fp.contains(FetchProfile.Item.FLAGS)) {
fetchFields.add(ImapConstants.FLAGS);
}
if (fp.contains(FetchProfile.Item.ENVELOPE)) {
fetchFields.add(ImapConstants.INTERNALDATE);
fetchFields.add(ImapConstants.RFC822_SIZE);
fetchFields.add(ImapConstants.FETCH_FIELD_HEADERS);
}
if (fp.contains(FetchProfile.Item.STRUCTURE)) {
fetchFields.add(ImapConstants.BODYSTRUCTURE);
}
if (fp.contains(FetchProfile.Item.BODY_SANE)) {
fetchFields.add(ImapConstants.FETCH_FIELD_BODY_PEEK_SANE);
}
if (fp.contains(FetchProfile.Item.BODY)) {
fetchFields.add(ImapConstants.FETCH_FIELD_BODY_PEEK);
}
final Part fetchPart = fp.getFirstPart();
if (fetchPart != null) {
String[] partIds = fetchPart.getHeader(MimeHeader.HEADER_ANDROID_ATTACHMENT_STORE_DATA);
if (partIds != null) {
fetchFields.add(
ImapConstants.FETCH_FIELD_BODY_PEEK_BARE
+ "["
+ partIds[0]
+ "]"
+ (mFetchSize > 0 ? String.format("<0.%d>", mFetchSize) : ""));
}
}
try {
mConnection.sendCommand(
String.format(
ImapConstants.UID_FETCH + " %s (%s)",
ImapStore.joinMessageUids(messages),
Utility.combine(fetchFields.toArray(new String[fetchFields.size()]), ' ')),
false);
ImapResponse response;
int messageNumber = 0;
do {
response = null;
try {
response = mConnection.readResponse(listener);
if (!response.isDataResponse(1, ImapConstants.FETCH)) {
continue; // Ignore
}
final ImapList fetchList = response.getListOrEmpty(2);
final String uid = fetchList.getKeyedStringOrEmpty(ImapConstants.UID).getString();
if (TextUtils.isEmpty(uid)) continue;
ImapMessage message = (ImapMessage) messageMap.get(uid);
if (message == null) continue;
if (fp.contains(FetchProfile.Item.FLAGS)) {
final ImapList flags = fetchList.getKeyedListOrEmpty(ImapConstants.FLAGS);
for (int i = 0, count = flags.size(); i < count; i++) {
final ImapString flag = flags.getStringOrEmpty(i);
if (flag.is(ImapConstants.FLAG_DELETED)) {
message.setFlagInternal(Flag.DELETED, true);
} else if (flag.is(ImapConstants.FLAG_ANSWERED)) {
message.setFlagInternal(Flag.ANSWERED, true);
} else if (flag.is(ImapConstants.FLAG_SEEN)) {
message.setFlagInternal(Flag.SEEN, true);
} else if (flag.is(ImapConstants.FLAG_FLAGGED)) {
message.setFlagInternal(Flag.FLAGGED, true);
}
}
}
if (fp.contains(FetchProfile.Item.ENVELOPE)) {
final Date internalDate =
fetchList.getKeyedStringOrEmpty(ImapConstants.INTERNALDATE).getDateOrNull();
final int size =
fetchList.getKeyedStringOrEmpty(ImapConstants.RFC822_SIZE).getNumberOrZero();
final InputStream header =
fetchList
.getKeyedStringOrEmpty(ImapConstants.BODY_BRACKET_HEADER, true)
.getAsStream();
message.setInternalDate(internalDate);
message.setSize(size);
message.parse(header);
}
if (fp.contains(FetchProfile.Item.STRUCTURE)) {
ImapList bs = fetchList.getKeyedListOrEmpty(ImapConstants.BODYSTRUCTURE);
if (!bs.isEmpty()) {
try {
parseBodyStructure(bs, message, ImapConstants.TEXT);
} catch (MessagingException e) {
if (Logging.LOGD) {
Log.v(Logging.LOG_TAG, "Error handling message", e);
}
message.setBody(null);
}
}
}
if (fp.contains(FetchProfile.Item.BODY) || fp.contains(FetchProfile.Item.BODY_SANE)) {
// Body is keyed by "BODY[]...".
// Previously used "BODY[..." but this can be confused with "BODY[HEADER..."
// TODO Should we accept "RFC822" as well??
ImapString body = fetchList.getKeyedStringOrEmpty("BODY[]", true);
String bodyText = body.getString();
InputStream bodyStream = body.getAsStream();
message.parse(bodyStream);
}
if (fetchPart != null && fetchPart.getSize() > 0) {
InputStream bodyStream = fetchList.getKeyedStringOrEmpty("BODY[", true).getAsStream();
String contentType = fetchPart.getContentType();
String[] encodingHeader =
fetchPart.getHeader(MimeHeader.HEADER_CONTENT_TRANSFER_ENCODING);
String contentTransferEncoding = null;
if (encodingHeader != null) {
contentTransferEncoding = encodingHeader[0];
}
// TODO Don't create 2 temp files.
// decodeBody creates BinaryTempFileBody, but we could avoid this
// if we implement ImapStringBody.
// (We'll need to share a temp file. Protect it with a ref-count.)
fetchPart.setBody(
decodeBody(bodyStream, contentTransferEncoding, fetchPart.getSize(), listener));
}
if (listener != null) {
listener.messageRetrieved(message);
}
} finally {
destroyResponses();
}
} while (!response.isTagged());
} catch (IOException ioe) {
throw ioExceptionHandler(mConnection, ioe);
}
}
@Override
public void copyMessages(Message[] messages, Folder folder, MessageUpdateCallbacks callbacks)
throws MessagingException {
checkOpen();
try {
List<ImapResponse> responseList =
mConnection.executeSimpleCommand(
String.format(
ImapConstants.UID_COPY + " %s \"%s\"",
ImapStore.joinMessageUids(messages),
ImapStore.encodeFolderName(folder.getName(), mStore.mPathPrefix)));
// Build a message map for faster UID matching
HashMap<String, Message> messageMap = new HashMap<String, Message>();
boolean handledUidPlus = false;
for (Message m : messages) {
messageMap.put(m.getUid(), m);
}
// Process response to get the new UIDs
for (ImapResponse response : responseList) {
// All "BAD" responses are bad. Only "NO", tagged responses are bad.
if (response.isBad() || (response.isNo() && response.isTagged())) {
String responseText = response.getStatusResponseTextOrEmpty().getString();
throw new MessagingException(responseText);
}
// Skip untagged responses; they're just status
if (!response.isTagged()) {
continue;
}
// No callback provided to report of UID changes; nothing more to do here
// NOTE: We check this here to catch any server errors
if (callbacks == null) {
continue;
}
ImapList copyResponse = response.getListOrEmpty(1);
String responseCode = copyResponse.getStringOrEmpty(0).getString();
if (ImapConstants.COPYUID.equals(responseCode)) {
handledUidPlus = true;
String origIdSet = copyResponse.getStringOrEmpty(2).getString();
String newIdSet = copyResponse.getStringOrEmpty(3).getString();
String[] origIdArray = ImapUtility.getImapSequenceValues(origIdSet);
String[] newIdArray = ImapUtility.getImapSequenceValues(newIdSet);
// There has to be a 1:1 mapping between old and new IDs
if (origIdArray.length != newIdArray.length) {
throw new MessagingException(
"Set length mis-match; orig IDs \""
+ origIdSet
+ "\" new IDs \""
+ newIdSet
+ "\"");
}
for (int i = 0; i < origIdArray.length; i++) {
final String id = origIdArray[i];
final Message m = messageMap.get(id);
if (m != null) {
callbacks.onMessageUidChange(m, newIdArray[i]);
}
}
}
}
// If the server doesn't support UIDPLUS, try a different way to get the new UID(s)
if (callbacks != null && !handledUidPlus) {
ImapFolder newFolder = (ImapFolder) folder;
try {
// Temporarily select the destination folder
newFolder.open(OpenMode.READ_WRITE);
// Do the search(es) ...
for (Message m : messages) {
String searchString = "HEADER Message-Id \"" + m.getMessageId() + "\"";
String[] newIdArray = newFolder.searchForUids(searchString);
if (newIdArray.length == 1) {
callbacks.onMessageUidChange(m, newIdArray[0]);
}
}
} catch (MessagingException e) {
// Log, but, don't abort; failures here don't need to be propagated
Log.d(Logging.LOG_TAG, "Failed to find message", e);
} finally {
newFolder.close(false);
}
// Re-select the original folder
doSelect();
}
} catch (IOException ioe) {
throw ioExceptionHandler(mConnection, ioe);
} finally {
destroyResponses();
}
}
