replicant-packages_apps_Email/src/com/android/exchange/EasOutboxService.java

254 lines
11 KiB
Java
Raw Normal View History

/*
* Copyright (C) 2008-2009 Marc Blank
* Licensed to 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.exchange;
import com.android.email.Utility;
import com.android.email.mail.transport.Rfc822Output;
import com.android.email.provider.EmailContent.Account;
import com.android.email.provider.EmailContent.Body;
import com.android.email.provider.EmailContent.BodyColumns;
import com.android.email.provider.EmailContent.Mailbox;
import com.android.email.provider.EmailContent.MailboxColumns;
import com.android.email.provider.EmailContent.Message;
import com.android.email.provider.EmailContent.MessageColumns;
import com.android.email.provider.EmailContent.SyncColumns;
import com.android.emailcommon.mail.MessagingException;
import com.android.emailcommon.service.EmailServiceStatus;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.entity.InputStreamEntity;
import android.content.ContentUris;
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.net.Uri;
import android.os.RemoteException;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class EasOutboxService extends EasSyncService {
public static final int SEND_FAILED = 1;
public static final String MAILBOX_KEY_AND_NOT_SEND_FAILED =
MessageColumns.MAILBOX_KEY + "=? and (" + SyncColumns.SERVER_ID + " is null or " +
SyncColumns.SERVER_ID + "!=" + SEND_FAILED + ')';
public static final String[] BODY_SOURCE_PROJECTION =
new String[] {BodyColumns.SOURCE_MESSAGE_KEY};
public static final String WHERE_MESSAGE_KEY = Body.MESSAGE_KEY + "=?";
// This needs to be long enough to send the longest reasonable message, without being so long
// as to effectively "hang" sending of mail. The standard 30 second timeout isn't long enough
// for pictures and the like. For now, we'll use 15 minutes, in the knowledge that any socket
// failure would probably generate an Exception before timing out anyway
public static final int SEND_MAIL_TIMEOUT = 15*MINUTES;
public EasOutboxService(Context _context, Mailbox _mailbox) {
super(_context, _mailbox);
}
private void sendCallback(long msgId, String subject, int status) {
try {
ExchangeService.callback().sendMessageStatus(msgId, subject, status, 0);
} catch (RemoteException e) {
// It's all good
}
}
/*package*/ String generateSmartSendCmd(boolean reply, String itemId, String collectionId) {
return (reply ? "SmartReply" : "SmartForward") + "&ItemId=" + Uri.encode(itemId, ":") +
"&CollectionId=" + Uri.encode(collectionId, ":");
}
/**
* Send a single message via EAS
* Note that we mark messages SEND_FAILED when there is a permanent failure, rather than an
* IOException, which is handled by ExchangeService with retries, backoffs, etc.
*
* @param cacheDir the cache directory for this context
* @param msgId the _id of the message to send
* @throws IOException
*/
int sendMessage(File cacheDir, long msgId) throws IOException, MessagingException {
int result;
sendCallback(msgId, null, EmailServiceStatus.IN_PROGRESS);
File tmpFile = File.createTempFile("eas_", "tmp", cacheDir);
// Write the output to a temporary file
try {
String[] cols = Utility.getRowColumns(mContext, Message.CONTENT_URI, msgId,
MessageColumns.FLAGS, MessageColumns.SUBJECT);
int flags = Integer.parseInt(cols[0]);
String subject = cols[1];
boolean reply = (flags & Message.FLAG_TYPE_REPLY) != 0;
boolean forward = (flags & Message.FLAG_TYPE_FORWARD) != 0;
// The reference message and mailbox are called item and collection in EAS
String itemId = null;
String collectionId = null;
if (reply || forward) {
// First, we need to get the id of the reply/forward message
cols = Utility.getRowColumns(mContext, Body.CONTENT_URI, BODY_SOURCE_PROJECTION,
WHERE_MESSAGE_KEY, new String[] {Long.toString(msgId)});
if (cols != null) {
long refId = Long.parseLong(cols[0]);
// Then, we need the serverId and mailboxKey of the message
cols = Utility.getRowColumns(mContext, Message.CONTENT_URI, refId,
SyncColumns.SERVER_ID, MessageColumns.MAILBOX_KEY);
if (cols != null) {
itemId = cols[0];
long boxId = Long.parseLong(cols[1]);
// Then, we need the serverId of the mailbox
cols = Utility.getRowColumns(mContext, Mailbox.CONTENT_URI, boxId,
MailboxColumns.SERVER_ID);
if (cols != null) {
collectionId = cols[0];
}
}
}
}
// Generally, we use SmartReply/SmartForward if we've got a good reference
boolean smartSend = itemId != null && collectionId != null;
// But we won't use SmartForward if the account isn't set up for it (currently, we only
// use SmartForward for EAS 12.0 or later to avoid creating eml files that are
// potentially difficult for the recipient to handle)
if (forward && ((mAccount.mFlags & Account.FLAGS_SUPPORTS_SMART_FORWARD) == 0)) {
smartSend = false;
}
// Write the message in rfc822 format to the temporary file
FileOutputStream fileStream = new FileOutputStream(tmpFile);
Rfc822Output.writeTo(mContext, msgId, fileStream, !smartSend, true);
fileStream.close();
// Now, get an input stream to our temporary file and create an entity with it
FileInputStream inputStream = new FileInputStream(tmpFile);
InputStreamEntity inputEntity =
new InputStreamEntity(inputStream, tmpFile.length());
// Create the appropriate command and POST it to the server
String cmd = "SendMail";
if (smartSend) {
cmd = generateSmartSendCmd(reply, itemId, collectionId);
}
cmd += "&SaveInSent=T";
userLog("Send cmd: " + cmd);
HttpResponse resp = sendHttpClientPost(cmd, inputEntity, SEND_MAIL_TIMEOUT);
inputStream.close();
int code = resp.getStatusLine().getStatusCode();
if (code == HttpStatus.SC_OK) {
userLog("Deleting message...");
mContentResolver.delete(ContentUris.withAppendedId(Message.CONTENT_URI, msgId),
null, null);
result = EmailServiceStatus.SUCCESS;
sendCallback(-1, subject, EmailServiceStatus.SUCCESS);
} else {
userLog("Message sending failed, code: " + code);
ContentValues cv = new ContentValues();
cv.put(SyncColumns.SERVER_ID, SEND_FAILED);
Message.update(mContext, Message.CONTENT_URI, msgId, cv);
// We mark the result as SUCCESS on a non-auth failure since the message itself is
// already marked failed and we don't want to stop other messages from trying to
// send.
if (isAuthError(code)) {
result = EmailServiceStatus.LOGIN_FAILED;
} else {
result = EmailServiceStatus.SUCCESS;
}
sendCallback(msgId, null, result);
}
} catch (IOException e) {
// We catch this just to send the callback
sendCallback(msgId, null, EmailServiceStatus.CONNECTION_ERROR);
throw e;
} finally {
// Clean up the temporary file
if (tmpFile.exists()) {
tmpFile.delete();
}
}
return result;
}
@Override
public void run() {
setupService();
File cacheDir = mContext.getCacheDir();
try {
mDeviceId = ExchangeService.getDeviceId();
Cursor c = mContext.getContentResolver().query(Message.CONTENT_URI,
Message.ID_COLUMN_PROJECTION, MAILBOX_KEY_AND_NOT_SEND_FAILED,
new String[] {Long.toString(mMailbox.mId)}, null);
try {
while (c.moveToNext()) {
long msgId = c.getLong(0);
if (msgId != 0) {
if (Utility.hasUnloadedAttachments(mContext, msgId)) {
// We'll just have to wait on this...
continue;
}
int result = sendMessage(cacheDir, msgId);
// If there's an error, it should stop the service; we will distinguish
// at least between login failures and everything else
if (result == EmailServiceStatus.LOGIN_FAILED) {
mExitStatus = EXIT_LOGIN_FAILURE;
return;
} else if (result == EmailServiceStatus.REMOTE_EXCEPTION) {
mExitStatus = EXIT_EXCEPTION;
return;
}
}
}
} finally {
c.close();
}
mExitStatus = EXIT_DONE;
} catch (IOException e) {
mExitStatus = EXIT_IO_ERROR;
} catch (Exception e) {
userLog("Exception caught in EasOutboxService", e);
mExitStatus = EXIT_EXCEPTION;
} finally {
userLog(mMailbox.mDisplayName, ": sync finished");
userLog("Outbox exited with status ", mExitStatus);
ExchangeService.done(this);
}
}
/**
* Convenience method for adding a Message to an account's outbox
* @param context the context of the caller
* @param accountId the accountId for the sending account
* @param msg the message to send
*/
public static void sendMessage(Context context, long accountId, Message msg) {
Mailbox mailbox = Mailbox.restoreMailboxOfType(context, accountId, Mailbox.TYPE_OUTBOX);
if (mailbox != null) {
msg.mMailboxKey = mailbox.mId;
msg.mAccountKey = accountId;
msg.save(context);
}
}
}