");
String text = HtmlHelper.getFullText(body);
String language = HtmlHelper.getLanguage(this, message.subject, text);
String preview = HtmlHelper.getPreview(text);
try {
db.beginTransaction();
message.id = null;
message.folder = sent.id;
if (account != null && account.protocol == EntityAccount.TYPE_IMAP)
message.identity = null;
message.from = helper.getFrom();
message.cc = helper.getCc();
message.bcc = helper.getBcc();
message.reply = helper.getReply();
message.subject = helper.getSubject(); // Subject encryption
message.encrypt = parts.getEncryption();
message.ui_encrypt = message.encrypt;
message.received = message.sent; // now
message.seen = true;
message.ui_seen = true;
message.ui_hide = true;
message.ui_busy = Long.MAX_VALUE; // Needed to keep messages in user folders
message.raw = null;
message.error = null;
message.id = db.message().insertMessage(message);
File file = EntityMessage.getFile(this, message.id);
Helper.writeText(file, body);
db.message().setMessageContent(message.id,
true,
language,
parts.isPlainOnly(),
preview,
parts.getWarnings(message.warning));
EntityAttachment.copy(this, id, message.id);
Long size = null;
if (body != null)
size = (long) body.length();
Long total = size;
List
attachments = db.attachment().getAttachments(message.id);
for (EntityAttachment attachment : attachments)
if (attachment.size != null)
total = (total == null ? 0 : total) + attachment.size;
db.message().setMessageSize(message.id, size, total);
db.setTransactionSuccessful();
} finally {
db.endTransaction();
}
sid = message.id;
message.id = id;
}
// Create transport
long start = 0;
long end = 0;
Long max_size = null;
SMTPSendFailedException partial = null;
if (ident.auth_type == AUTH_TYPE_GRAPH) {
start = new Date().getTime();
MicrosoftGraph.send(ServiceSend.this, ident, imessage);
end = new Date().getTime();
} else {
EmailService iservice = new EmailService(this, ident, EmailService.PURPOSE_USE, debug);
try {
if (ident.envelopeFrom != null)
iservice.setMailFrom(ident.envelopeFrom);
if (send_partial)
iservice.setSendPartial(true);
iservice.setUseIp(ident.use_ip, ident.ehlo);
if (!message.isSigned() && !message.isEncrypted())
iservice.set8BitMime(ident.octetmime);
// 0=Read receipt
// 1=Delivery receipt
// 2=Read+delivery receipt
if (message.receipt_request != null && message.receipt_request) {
int receipt_type = prefs.getInt("receipt_type", 2);
if (ident.receipt_type != null)
receipt_type = ident.receipt_type;
if (receipt_type == 1 || receipt_type == 2) // Delivery receipt
iservice.setDsnNotify("SUCCESS,FAILURE,DELAY");
}
// Connect transport
db.identity().setIdentityState(ident.id, "connecting");
iservice.connect(ident);
if (BuildConfig.DEBUG && false)
throw new IOException("Test");
db.identity().setIdentityState(ident.id, "connected");
EntityLog.log(this, EntityLog.Type.Protocol, ident.email + " " +
TextUtils.join(" ", iservice.getCapabilities()));
max_size = iservice.getMaxSize();
List recipients = new ArrayList<>();
if (message.headers == null || !Boolean.TRUE.equals(message.resend)) {
Address[] all = imessage.getAllRecipients();
if (all != null)
recipients.addAll(Arrays.asList(all));
} else {
String to = imessage.getHeader("Resent-To", ",");
if (to != null)
for (Address a : InternetAddress.parse(to))
recipients.add(a);
String cc = imessage.getHeader("Resent-Cc", ",");
if (cc != null)
for (Address a : InternetAddress.parse(cc))
recipients.add(a);
String bcc = imessage.getHeader("Resent-Bcc", ",");
if (bcc != null)
for (Address a : InternetAddress.parse(bcc))
recipients.add(a);
}
if (BuildConfig.DEBUG && false) {
InternetAddress invalid = new InternetAddress();
invalid.setAddress("invalid");
recipients.add(invalid);
}
if (protocol && BuildConfig.DEBUG) {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
imessage.writeTo(bos);
for (String line : bos.toString().split("\n"))
EntityLog.log(this, line);
}
Address[] rcptto = MessageHelper.removeGroups(recipients.toArray(new Address[0]));
String via = "via " + ident.host + "/" + ident.user +
" rcptto=" + TextUtils.join(", ", recipients);
iservice.setReporter(new TraceOutputStream.IReport() {
private int progress = -1;
private long last = SystemClock.elapsedRealtime();
@Override
public void report(int pos, int total) {
int p = (total == 0 ? 0 : 100 * pos / total);
if (p > progress) {
progress = p;
long now = SystemClock.elapsedRealtime();
if (now > last + PROGRESS_UPDATE_INTERVAL) {
last = now;
lastProgress = progress;
if (NotificationHelper.areNotificationsEnabled(nm))
nm.notify(NotificationHelper.NOTIFICATION_SEND, getNotificationService(false));
}
}
}
});
// Send message
EntityLog.log(this, "Sending " + via);
start = new Date().getTime();
try {
iservice.getTransport().sendMessage(imessage, rcptto);
} finally {
end = new Date().getTime();
}
EntityLog.log(this, "Sent " + via + " elapse=" + (end - start) + " ms");
} catch (MessagingException ex) {
iservice.dump(ident.email);
Log.e(ex);
if (ex instanceof SMTPSendFailedException) {
SMTPSendFailedException sem = (SMTPSendFailedException) ex;
if (send_partial &&
sem.getInvalidAddresses() != null &&
sem.getValidSentAddresses() != null &&
sem.getValidUnsentAddresses() != null &&
sem.getValidSentAddresses().length > 0 &&
sem.getInvalidAddresses().length + sem.getValidUnsentAddresses().length > 0) {
partial = sem;
}
ex = new SMTPSendFailedException(
sem.getCommand(),
sem.getReturnCode(),
getString(R.string.title_service_auth, sem.getMessage()),
sem.getNextException(),
sem.getValidSentAddresses(),
sem.getValidUnsentAddresses(),
sem.getInvalidAddresses());
}
if (sid != null && partial == null)
db.message().deleteMessage(sid);
db.identity().setIdentityError(ident.id, Log.formatThrowable(ex));
if (partial == null)
throw ex;
} catch (Throwable ex) {
iservice.dump(ident.email);
throw ex;
} finally {
iservice.close();
if (lastProgress >= 0) {
lastProgress = -1;
if (NotificationHelper.areNotificationsEnabled(nm))
nm.notify(NotificationHelper.NOTIFICATION_SEND, getNotificationService(false));
}
db.identity().setIdentityState(ident.id, null);
}
}
try {
db.beginTransaction();
// Delete from outbox
if (partial == null)
db.message().deleteMessage(message.id);
else {
Throwable ex = new Throwable(getString(R.string.title_advanced_sent_partially), partial);
db.message().setMessageWarning(message.id, Log.formatThrowable(ex));
if (NotificationHelper.areNotificationsEnabled(nm)) {
NotificationCompat.Builder builder = getNotificationError(
MessageHelper.formatAddressesShort(message.to),
ex, 0);
nm.notify("partial:" + message.id,
NotificationHelper.NOTIFICATION_TAGGED,
builder.build());
}
}
// Show in sent folder
if (sid != null) {
if (EntityMessage.PGP_SIGNENCRYPT.equals(message.ui_encrypt) ||
EntityMessage.SMIME_SIGNENCRYPT.equals(message.ui_encrypt))
db.attachment().deleteAttachments(sid,
new int[]{EntityAttachment.PGP_MESSAGE, EntityAttachment.SMIME_MESSAGE});
if (partial != null) {
List unsent = new ArrayList<>();
if (partial.getInvalidAddresses() != null)
unsent.addAll(Arrays.asList(partial.getInvalidAddresses()));
if (partial.getValidUnsentAddresses() != null)
unsent.addAll(Arrays.asList(partial.getValidUnsentAddresses()));
db.message().setMessageTo(sid,
DB.Converters.encodeAddresses(MessageHelper.removeAddresses(message.to, unsent)));
db.message().setMessageCc(sid,
DB.Converters.encodeAddresses(MessageHelper.removeAddresses(message.cc, unsent)));
db.message().setMessageBcc(sid,
DB.Converters.encodeAddresses(MessageHelper.removeAddresses(message.bcc, unsent)));
}
db.message().setMessageReceived(sid, start);
db.message().setMessageSent(sid, end);
db.message().setMessageUiHide(sid, false);
}
// Mark replied
if (message.inreplyto != null) {
List replieds = db.message().getMessagesByMsgId(message.account, message.inreplyto);
for (EntityMessage replied : replieds)
EntityOperation.queue(this, replied, EntityOperation.ANSWERED, true);
}
// Mark forwarded
if (message.wasforwardedfrom != null) {
List forwardeds = db.message().getMessagesByMsgId(message.account, message.wasforwardedfrom);
for (EntityMessage forwarded : forwardeds)
EntityOperation.queue(this, forwarded,
EntityOperation.KEYWORD, MessageHelper.FLAG_FORWARDED, true);
}
// Update identity
db.identity().setIdentityMaxSize(ident.id, max_size);
db.identity().setIdentityConnected(ident.id, new Date().getTime());
db.identity().setIdentityError(ident.id, null);
db.setTransactionSuccessful();
} finally {
db.endTransaction();
}
nm.cancel("send:" + message.id, NotificationHelper.NOTIFICATION_TAGGED);
// Play sent sound
String sound = prefs.getString("sound_sent", null);
if (!TextUtils.isEmpty(sound))
MediaPlayerHelper.queue(ServiceSend.this, sound);
// Check sent message
if (sid != null) {
try {
db.beginTransaction();
// Message could have been deleted
EntityMessage orphan = db.message().getMessage(sid);
if (orphan != null)
if (account == null || account.protocol == EntityAccount.TYPE_IMAP)
EntityOperation.queue(this, orphan, EntityOperation.EXISTS);
else if (sent != null)
EntityContact.received(this, account, sent, message);
db.setTransactionSuccessful();
} finally {
db.endTransaction();
}
checkICalendar(sid);
}
ServiceSynchronize.eval(this, "sent");
}
private void checkICalendar(long sid) {
boolean permission = Helper.hasPermission(this, Manifest.permission.WRITE_CALENDAR);
if (!permission)
return;
DB db = DB.getInstance(this);
List attachments = db.attachment().getAttachments(sid);
if (attachments == null || attachments.size() == 0)
return;
for (EntityAttachment attachment : attachments)
if ("text/calendar".equals(attachment.type))
try {
File ics = attachment.getFile(this);
ICalendar icalendar = CalendarHelper.parse(ServiceSend.this, ics);
Method method = icalendar.getMethod();
if (method == null || !method.isReply())
return;
VEvent event = icalendar.getEvents().get(0);
EntityMessage message = db.message().getMessage(sid);
CalendarHelper.update(this, event, message);
break;
} catch (Throwable ex) {
Log.e(ex);
}
}
static void boot(final Context context) {
Helper.getSerialExecutor().submit(new Runnable() {
@Override
public void run() {
try {
EntityLog.log(context, "Boot send service");
DB db = DB.getInstance(context);
EntityFolder outbox = db.folder().getOutbox();
if (outbox != null) {
int operations = db.operation().getOperations(EntityOperation.SEND).size();
if (operations > 0)
start(context);
else {
db.folder().setFolderState(outbox.id, null);
db.folder().setFolderSyncState(outbox.id, null);
}
}
} catch (Throwable ex) {
Log.e(ex);
}
}
});
}
static void start(Context context) {
try {
ContextCompat.startForegroundService(context, new Intent(context, ServiceSend.class));
} catch (Throwable ex) {
Log.e(ex);
}
}
static void stop(Context context) {
context.stopService(new Intent(context, ServiceSend.class));
}
static void schedule(Context context, long delay) {
Intent intent = new Intent(context, ServiceSend.class);
PendingIntent pi = PendingIntentCompat.getForegroundService(
context, PI_SEND, intent, PendingIntent.FLAG_UPDATE_CURRENT);
long trigger = System.currentTimeMillis() + delay;
AlarmManager am = Helper.getSystemService(context, AlarmManager.class);
am.cancel(pi);
AlarmManagerCompatEx.setAndAllowWhileIdle(context, am, AlarmManager.RTC_WAKEUP, trigger, pi);
}
static void watchdog(Context context) {
boot(context);
}
}