Close SMTP connection before post processing

app/src/main/java/eu/faircode/email/ServiceSend.java

@@ -577,6 +577,8 @@ public class ServiceSend extends ServiceBase implements SharedPreferences.OnShar
         }
 
         // Create transport
+        long start, end;
+        Long max_size = null;
         try (EmailService iservice = new EmailService(
                 this, ident.getProtocol(), ident.realm, ident.encryption, ident.insecure, debug)) {
             iservice.setUseIp(ident.use_ip, ident.ehlo);
@@ -589,11 +591,8 @@ public class ServiceSend extends ServiceBase implements SharedPreferences.OnShar
                 throw new IOException("Test");
             db.identity().setIdentityState(ident.id, "connected");
 
-            if (ident.max_size == null) {
+            if (ident.max_size == null)
-                Long max_size = iservice.getMaxSize();
+                max_size = iservice.getMaxSize();
-                if (max_size != null)
-                    db.identity().setIdentityMaxSize(ident.id, max_size);
-            }
 
             Address[] to = imessage.getAllRecipients();
             String via = "via " + ident.host + "/" + ident.user +
@@ -601,84 +600,88 @@ public class ServiceSend extends ServiceBase implements SharedPreferences.OnShar
 
             // Send message
             EntityLog.log(this, "Sending " + via);
-            long start = new Date().getTime();
+            start = new Date().getTime();
             iservice.getTransport().sendMessage(imessage, to);
-            long end = new Date().getTime();
+            end = new Date().getTime();
             EntityLog.log(this, "Sent " + via + " elapse=" + (end - start) + " ms");
+        } catch (MessagingException ex) {
+            Log.e(ex);
 
-            try {
+            if (sid != null)
-                db.beginTransaction();
+                db.message().deleteMessage(sid);
-
-                // Delete from outbox
-                db.message().deleteMessage(message.id);
 
-                // Show in sent folder
+            db.identity().setIdentityError(ident.id, Log.formatThrowable(ex));
-                if (sid != null) {
-                    db.message().setMessageReceived(sid, start);
-                    db.message().setMessageSent(sid, end);
-                    db.message().setMessageUiHide(sid, false);
-                }
 
-                if (message.inreplyto != null) {
+            throw ex;
-                    List<EntityMessage> replieds = db.message().getMessagesByMsgId(message.account, message.inreplyto);
+        } finally {
-                    for (EntityMessage replied : replieds)
+            db.identity().setIdentityState(ident.id, null);
-                        EntityOperation.queue(this, replied, EntityOperation.ANSWERED, true);
+        }
-                }
 
-                if (message.wasforwardedfrom != null) {
+        try {
-                    List<EntityMessage> forwardeds = db.message().getMessagesByMsgId(message.account, message.wasforwardedfrom);
+            db.beginTransaction();
-                    for (EntityMessage forwarded : forwardeds)
-                        EntityOperation.queue(this, forwarded, EntityOperation.KEYWORD, "$Forwarded", true);
-                }
 
-                // Reset identity
+            // Delete from outbox
-                db.identity().setIdentityConnected(ident.id, new Date().getTime());
+            db.message().deleteMessage(message.id);
-                db.identity().setIdentityError(ident.id, null);
 
-                db.setTransactionSuccessful();
+            // Show in sent folder
-            } finally {
+            if (sid != null) {
-                db.endTransaction();
+                db.message().setMessageReceived(sid, start);
+                db.message().setMessageSent(sid, end);
+                db.message().setMessageUiHide(sid, false);
             }
 
-            ServiceSynchronize.eval(this, "sent");
+            // Mark replied
+            if (message.inreplyto != null) {
+                List<EntityMessage> replieds = db.message().getMessagesByMsgId(message.account, message.inreplyto);
+                for (EntityMessage replied : replieds)
+                    EntityOperation.queue(this, replied, EntityOperation.ANSWERED, true);
+            }
 
-            NotificationManager nm = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
+            // Mark forwarded
-            nm.cancel("send:" + message.id, 1);
+            if (message.wasforwardedfrom != null) {
+                List<EntityMessage> forwardeds = db.message().getMessagesByMsgId(message.account, message.wasforwardedfrom);
+                for (EntityMessage forwarded : forwardeds)
+                    EntityOperation.queue(this, forwarded, EntityOperation.KEYWORD, "$Forwarded", true);
+            }
 
-            // Check sent message
+            // Update identity
-            if (sid != null) {
+            if (max_size != null)
-                try {
+                db.identity().setIdentityMaxSize(ident.id, max_size);
-                    Thread.sleep(EXISTS_DELAY);
+            db.identity().setIdentityConnected(ident.id, new Date().getTime());
-                } catch (InterruptedException ex) {
+            db.identity().setIdentityError(ident.id, null);
-                    Log.e(ex);
-                }
 
-                try {
+            db.setTransactionSuccessful();
-                    db.beginTransaction();
+        } finally {
+            db.endTransaction();
+        }
 
-                    // Message could have been deleted
+        ServiceSynchronize.eval(this, "sent");
-                    EntityMessage orphan = db.message().getMessage(sid);
-                    if (orphan != null)
-                        EntityOperation.queue(this, orphan, EntityOperation.EXISTS);
 
-                    db.setTransactionSuccessful();
+        NotificationManager nm = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
-                } finally {
+        nm.cancel("send:" + message.id, 1);
-                    db.endTransaction();
-                }
 
-                ServiceSynchronize.eval(this, "orphan");
+        // Check sent message
+        if (sid != null) {
+            try {
+                Thread.sleep(EXISTS_DELAY);
+            } catch (InterruptedException ex) {
+                Log.e(ex);
             }
-        } catch (MessagingException ex) {
-            Log.e(ex);
 
-            if (sid != null)
+            try {
-                db.message().deleteMessage(sid);
+                db.beginTransaction();
 
-            db.identity().setIdentityError(ident.id, Log.formatThrowable(ex));
+                // Message could have been deleted
+                EntityMessage orphan = db.message().getMessage(sid);
+                if (orphan != null)
+                    EntityOperation.queue(this, orphan, EntityOperation.EXISTS);
 
-            throw ex;
+                db.setTransactionSuccessful();
-        } finally {
+            } finally {
-            db.identity().setIdentityState(ident.id, null);
+                db.endTransaction();
+            }
+
+            ServiceSynchronize.eval(this, "orphan");
         }
     }