Remove legacy EncapsulatedExceptions from manager

diff --git a/src/main/java/org/asamk/signal/commands/QuitGroupCommand.java b/src/main/java/org/asamk/signal/commands/QuitGroupCommand.java
index 6db230f5b5537708f8b1e5d609309aeabf1a37f9..6d0edf87ad9b7c2d16c955788d4e6cd321efb173 100644 (file)
--- a/src/main/java/org/asamk/signal/commands/QuitGroupCommand.java
+++ b/src/main/java/org/asamk/signal/commands/QuitGroupCommand.java
@@ -8,16 +8,18 @@ import org.asamk.signal.manager.Manager;
 import org.asamk.signal.manager.NotAGroupMemberException;
 import org.asamk.signal.util.GroupIdFormatException;
 import org.asamk.signal.util.Util;
-import org.whispersystems.signalservice.api.push.exceptions.EncapsulatedExceptions;
+import org.whispersystems.libsignal.util.Pair;
+import org.whispersystems.signalservice.api.messages.SendMessageResult;
 
 import java.io.IOException;
+import java.util.List;
 
 import static org.asamk.signal.util.ErrorUtils.handleAssertionError;
-import static org.asamk.signal.util.ErrorUtils.handleEncapsulatedExceptions;
 import static org.asamk.signal.util.ErrorUtils.handleGroupIdFormatException;
 import static org.asamk.signal.util.ErrorUtils.handleGroupNotFoundException;
 import static org.asamk.signal.util.ErrorUtils.handleIOException;
 import static org.asamk.signal.util.ErrorUtils.handleNotAGroupMemberException;
+import static org.asamk.signal.util.ErrorUtils.handleTimestampAndSendMessageResults;
 
 public class QuitGroupCommand implements LocalCommand {
 
@@ -36,14 +38,11 @@ public class QuitGroupCommand implements LocalCommand {
         }
 
         try {
-            m.sendQuitGroupMessage(Util.decodeGroupId(ns.getString("group")));
-            return 0;
+            final Pair<Long, List<SendMessageResult>> results = m.sendQuitGroupMessage(Util.decodeGroupId(ns.getString("group")));
+            return handleTimestampAndSendMessageResults(results.first(), results.second());
         } catch (IOException e) {
             handleIOException(e);
             return 3;
-        } catch (EncapsulatedExceptions e) {
-            handleEncapsulatedExceptions(e);
-            return 3;
         } catch (AssertionError e) {
             handleAssertionError(e);
             return 1;

diff --git a/src/main/java/org/asamk/signal/commands/SendReactionCommand.java b/src/main/java/org/asamk/signal/commands/SendReactionCommand.java
index 7e7488662d620d64918907138d91d28a4e6aed98..3d000a621acbe14ea6e843a31fb504c75bf537cc 100644 (file)
--- a/src/main/java/org/asamk/signal/commands/SendReactionCommand.java
+++ b/src/main/java/org/asamk/signal/commands/SendReactionCommand.java
@@ -9,18 +9,20 @@ import org.asamk.signal.manager.Manager;
 import org.asamk.signal.manager.NotAGroupMemberException;
 import org.asamk.signal.util.GroupIdFormatException;
 import org.asamk.signal.util.Util;
-import org.whispersystems.signalservice.api.push.exceptions.EncapsulatedExceptions;
+import org.whispersystems.libsignal.util.Pair;
+import org.whispersystems.signalservice.api.messages.SendMessageResult;
 import org.whispersystems.signalservice.api.util.InvalidNumberException;
 
 import java.io.IOException;
+import java.util.List;
 
 import static org.asamk.signal.util.ErrorUtils.handleAssertionError;
-import static org.asamk.signal.util.ErrorUtils.handleEncapsulatedExceptions;
 import static org.asamk.signal.util.ErrorUtils.handleGroupIdFormatException;
 import static org.asamk.signal.util.ErrorUtils.handleGroupNotFoundException;
 import static org.asamk.signal.util.ErrorUtils.handleIOException;
 import static org.asamk.signal.util.ErrorUtils.handleInvalidNumberException;
 import static org.asamk.signal.util.ErrorUtils.handleNotAGroupMemberException;
+import static org.asamk.signal.util.ErrorUtils.handleTimestampAndSendMessageResults;
 
 public class SendReactionCommand implements LocalCommand {
 
@@ -66,19 +68,18 @@ public class SendReactionCommand implements LocalCommand {
         long targetTimestamp = ns.getLong("target_timestamp");
 
         try {
+            final Pair<Long, List<SendMessageResult>> results;
             if (ns.getString("group") != null) {
                 byte[] groupId = Util.decodeGroupId(ns.getString("group"));
-                m.sendGroupMessageReaction(emoji, isRemove, targetAuthor, targetTimestamp, groupId);
+                results = m.sendGroupMessageReaction(emoji, isRemove, targetAuthor, targetTimestamp, groupId);
             } else {
-                m.sendMessageReaction(emoji, isRemove, targetAuthor, targetTimestamp, ns.getList("recipient"));
+                results = m.sendMessageReaction(emoji, isRemove, targetAuthor, targetTimestamp, ns.getList("recipient"));
             }
+            handleTimestampAndSendMessageResults(results.first(), results.second());
             return 0;
         } catch (IOException e) {
             handleIOException(e);
             return 3;
-        } catch (EncapsulatedExceptions e) {
-            handleEncapsulatedExceptions(e);
-            return 3;
         } catch (AssertionError e) {
             handleAssertionError(e);
             return 1;

diff --git a/src/main/java/org/asamk/signal/dbus/DbusSignalImpl.java b/src/main/java/org/asamk/signal/dbus/DbusSignalImpl.java
index 17cc2caaf10e737f866ece457dae3bfd009bc0b5..bffde498244c53f765c101483fc4ea2860ca5cb9 100644 (file)
--- a/src/main/java/org/asamk/signal/dbus/DbusSignalImpl.java
+++ b/src/main/java/org/asamk/signal/dbus/DbusSignalImpl.java
@@ -6,11 +6,10 @@ import org.asamk.signal.manager.GroupNotFoundException;
 import org.asamk.signal.manager.Manager;
 import org.asamk.signal.manager.NotAGroupMemberException;
 import org.asamk.signal.storage.groups.GroupInfo;
+import org.asamk.signal.util.ErrorUtils;
 import org.freedesktop.dbus.exceptions.DBusExecutionException;
-import org.whispersystems.signalservice.api.crypto.UntrustedIdentityException;
-import org.whispersystems.signalservice.api.push.exceptions.EncapsulatedExceptions;
-import org.whispersystems.signalservice.api.push.exceptions.NetworkFailureException;
-import org.whispersystems.signalservice.api.push.exceptions.UnregisteredUserException;
+import org.whispersystems.libsignal.util.Pair;
+import org.whispersystems.signalservice.api.messages.SendMessageResult;
 import org.whispersystems.signalservice.api.util.InvalidNumberException;
 
 import java.io.IOException;
@@ -43,41 +42,28 @@ public class DbusSignalImpl implements Signal {
         return sendMessage(message, attachments, recipients);
     }
 
-    private static DBusExecutionException convertEncapsulatedExceptions(EncapsulatedExceptions e) {
-        if (e.getNetworkExceptions().size() + e.getUnregisteredUserExceptions().size() + e.getUntrustedIdentityExceptions().size() == 1) {
-            if (e.getNetworkExceptions().size() == 1) {
-                NetworkFailureException n = e.getNetworkExceptions().get(0);
-                return new Error.Failure("Network failure for \"" + n.getE164number() + "\": " + n.getMessage());
-            } else if (e.getUnregisteredUserExceptions().size() == 1) {
-                UnregisteredUserException n = e.getUnregisteredUserExceptions().get(0);
-                return new Error.UnregisteredUser("Unregistered user \"" + n.getE164Number() + "\": " + n.getMessage());
-            } else if (e.getUntrustedIdentityExceptions().size() == 1) {
-                UntrustedIdentityException n = e.getUntrustedIdentityExceptions().get(0);
-                return new Error.UntrustedIdentity("Untrusted Identity for \"" + n.getIdentifier() + "\": " + n.getMessage());
-            }
+    private static void checkSendMessageResults(long timestamp, List<SendMessageResult> results) throws DBusExecutionException {
+        List<String> errors = ErrorUtils.getErrorMessagesFromSendMessageResults(results);
+        if (errors.size() == 0) {
+            return;
         }
 
         StringBuilder message = new StringBuilder();
-        message.append("Failed to send (some) messages:").append('\n');
-        for (NetworkFailureException n : e.getNetworkExceptions()) {
-            message.append("Network failure for \"").append(n.getE164number()).append("\": ").append(n.getMessage()).append('\n');
-        }
-        for (UnregisteredUserException n : e.getUnregisteredUserExceptions()) {
-            message.append("Unregistered user \"").append(n.getE164Number()).append("\": ").append(n.getMessage()).append('\n');
-        }
-        for (UntrustedIdentityException n : e.getUntrustedIdentityExceptions()) {
-            message.append("Untrusted Identity for \"").append(n.getIdentifier()).append("\": ").append(n.getMessage()).append('\n');
+        message.append(timestamp).append('\n');
+        message.append("Failed to send (some) messages:\n");
+        for (String error : errors) {
+            message.append(error).append('\n');
         }
 
-        return new Error.Failure(message.toString());
+        throw new Error.Failure(message.toString());
     }
 
     @Override
     public long sendMessage(final String message, final List<String> attachments, final List<String> recipients) {
         try {
-            return m.sendMessage(message, attachments, recipients);
-        } catch (EncapsulatedExceptions e) {
-            throw convertEncapsulatedExceptions(e);
+            final Pair<Long, List<SendMessageResult>> results = m.sendMessage(message, attachments, recipients);
+            checkSendMessageResults(results.first(), results.second());
+            return results.first();
         } catch (InvalidNumberException e) {
             throw new Error.InvalidNumber(e.getMessage());
         } catch (AttachmentInvalidException e) {
@@ -90,11 +76,10 @@ public class DbusSignalImpl implements Signal {
     @Override
     public void sendEndSessionMessage(final List<String> recipients) {
         try {
-            m.sendEndSessionMessage(recipients);
+            final Pair<Long, List<SendMessageResult>> results = m.sendEndSessionMessage(recipients);
+            checkSendMessageResults(results.first(), results.second());
         } catch (IOException e) {
             throw new Error.Failure(e.getMessage());
-        } catch (EncapsulatedExceptions e) {
-            throw convertEncapsulatedExceptions(e);
         } catch (InvalidNumberException e) {
             throw new Error.InvalidNumber(e.getMessage());
         }
@@ -103,11 +88,11 @@ public class DbusSignalImpl implements Signal {
     @Override
     public long sendGroupMessage(final String message, final List<String> attachments, final byte[] groupId) {
         try {
-            return m.sendGroupMessage(message, attachments, groupId);
+            Pair<Long, List<SendMessageResult>> results = m.sendGroupMessage(message, attachments, groupId);
+            checkSendMessageResults(results.first(), results.second());
+            return results.first();
         } catch (IOException e) {
             throw new Error.Failure(e.getMessage());
-        } catch (EncapsulatedExceptions e) {
-            throw convertEncapsulatedExceptions(e);
         } catch (GroupNotFoundException | NotAGroupMemberException e) {
             throw new Error.GroupNotFound(e.getMessage());
         } catch (AttachmentInvalidException e) {
@@ -184,11 +169,11 @@ public class DbusSignalImpl implements Signal {
     @Override
     public byte[] updateGroup(final byte[] groupId, final String name, final List<String> members, final String avatar) {
         try {
-            return m.updateGroup(groupId, name, members, avatar);
+            final Pair<byte[], List<SendMessageResult>> results = m.updateGroup(groupId, name, members, avatar);
+            checkSendMessageResults(0, results.second());
+            return results.first();
         } catch (IOException e) {
             throw new Error.Failure(e.getMessage());
-        } catch (EncapsulatedExceptions e) {
-            throw convertEncapsulatedExceptions(e);
         } catch (GroupNotFoundException | NotAGroupMemberException e) {
             throw new Error.GroupNotFound(e.getMessage());
         } catch (InvalidNumberException e) {

diff --git a/src/main/java/org/asamk/signal/manager/Manager.java b/src/main/java/org/asamk/signal/manager/Manager.java
index a4127b75c369d6ce0f0c1b0ba27097f9908001ac..63c6ee7de53359ee248c4c8b3ddb96729c7db6a9 100644 (file)
--- a/src/main/java/org/asamk/signal/manager/Manager.java
+++ b/src/main/java/org/asamk/signal/manager/Manager.java
@@ -96,10 +96,7 @@ import org.whispersystems.signalservice.api.messages.multidevice.VerifiedMessage
 import org.whispersystems.signalservice.api.profiles.SignalServiceProfile;
 import org.whispersystems.signalservice.api.push.ContactTokenDetails;
 import org.whispersystems.signalservice.api.push.SignalServiceAddress;
-import org.whispersystems.signalservice.api.push.exceptions.EncapsulatedExceptions;
 import org.whispersystems.signalservice.api.push.exceptions.MissingConfigurationException;
-import org.whispersystems.signalservice.api.push.exceptions.NetworkFailureException;
-import org.whispersystems.signalservice.api.push.exceptions.UnregisteredUserException;
 import org.whispersystems.signalservice.api.util.InvalidNumberException;
 import org.whispersystems.signalservice.api.util.SleepTimer;
 import org.whispersystems.signalservice.api.util.StreamDetails;
@@ -134,7 +131,6 @@ import java.util.Collection;
 import java.util.Collections;
 import java.util.Date;
 import java.util.HashSet;
-import java.util.LinkedList;
 import java.util.List;
 import java.util.Locale;
 import java.util.Objects;
@@ -161,7 +157,7 @@ public class Manager implements Closeable {
     private SignalServiceAccountManager accountManager;
     private SignalServiceMessagePipe messagePipe = null;
     private SignalServiceMessagePipe unidentifiedMessagePipe = null;
-    private boolean discoverableByPhoneNumber = true;
+    private final boolean discoverableByPhoneNumber = true;
 
     public Manager(SignalAccount account, PathConfig pathConfig, SignalServiceConfiguration serviceConfiguration, String userAgent) {
         this.account = account;
@@ -540,9 +536,12 @@ public class Manager implements Closeable {
         return account.getGroupStore().getGroups();
     }
 
-    public long sendGroupMessage(String messageText, List<String> attachments,
-                                 byte[] groupId)
-            throws IOException, EncapsulatedExceptions, GroupNotFoundException, AttachmentInvalidException, NotAGroupMemberException {
+    public Pair<Long, List<SendMessageResult>> sendGroupMessage(
+            String messageText,
+            List<String> attachments,
+            byte[] groupId
+    )
+            throws IOException, GroupNotFoundException, AttachmentInvalidException, NotAGroupMemberException {
         final SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder().withBody(messageText);
         if (attachments != null) {
             messageBuilder.withAttachments(Utils.getSignalServiceAttachments(attachments));
@@ -558,12 +557,12 @@ public class Manager implements Closeable {
 
         messageBuilder.withExpiration(g.messageExpirationTime);
 
-        return sendMessageLegacy(messageBuilder, g.getMembersWithout(account.getSelfAddress()));
+        return sendMessage(messageBuilder, g.getMembersWithout(account.getSelfAddress()));
     }
 
-    public void sendGroupMessageReaction(String emoji, boolean remove, String targetAuthor,
-                                         long targetSentTimestamp, byte[] groupId)
-            throws IOException, EncapsulatedExceptions, InvalidNumberException, NotAGroupMemberException, GroupNotFoundException {
+    public Pair<Long, List<SendMessageResult>> sendGroupMessageReaction(String emoji, boolean remove, String targetAuthor,
+                                                                        long targetSentTimestamp, byte[] groupId)
+            throws IOException, InvalidNumberException, NotAGroupMemberException, GroupNotFoundException {
         SignalServiceDataMessage.Reaction reaction = new SignalServiceDataMessage.Reaction(emoji, remove, canonicalizeAndResolveSignalServiceAddress(targetAuthor), targetSentTimestamp);
         final SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder()
                 .withReaction(reaction);
@@ -574,10 +573,10 @@ public class Manager implements Closeable {
             messageBuilder.asGroupMessage(group);
         }
         final GroupInfo g = getGroupForSending(groupId);
-        sendMessageLegacy(messageBuilder, g.getMembersWithout(account.getSelfAddress()));
+        return sendMessage(messageBuilder, g.getMembersWithout(account.getSelfAddress()));
     }
 
-    public void sendQuitGroupMessage(byte[] groupId) throws GroupNotFoundException, IOException, EncapsulatedExceptions, NotAGroupMemberException {
+    public Pair<Long, List<SendMessageResult>> sendQuitGroupMessage(byte[] groupId) throws GroupNotFoundException, IOException, NotAGroupMemberException {
         SignalServiceGroup group = SignalServiceGroup.newBuilder(SignalServiceGroup.Type.QUIT)
                 .withId(groupId)
                 .build();
@@ -589,10 +588,10 @@ public class Manager implements Closeable {
         g.removeMember(account.getSelfAddress());
         account.getGroupStore().updateGroup(g);
 
-        sendMessageLegacy(messageBuilder, g.getMembersWithout(account.getSelfAddress()));
+        return sendMessage(messageBuilder, g.getMembersWithout(account.getSelfAddress()));
     }
 
-    private byte[] sendUpdateGroupMessage(byte[] groupId, String name, Collection<SignalServiceAddress> members, String avatarFile) throws IOException, EncapsulatedExceptions, GroupNotFoundException, AttachmentInvalidException, NotAGroupMemberException {
+    private Pair<byte[], List<SendMessageResult>> sendUpdateGroupMessage(byte[] groupId, String name, Collection<SignalServiceAddress> members, String avatarFile) throws IOException, GroupNotFoundException, AttachmentInvalidException, NotAGroupMemberException {
         GroupInfo g;
         if (groupId == null) {
             // Create new group
@@ -637,24 +636,21 @@ public class Manager implements Closeable {
 
         SignalServiceDataMessage.Builder messageBuilder = getGroupUpdateMessageBuilder(g);
 
-        sendMessageLegacy(messageBuilder, g.getMembersWithout(account.getSelfAddress()));
-        return g.groupId;
+        final Pair<Long, List<SendMessageResult>> result = sendMessage(messageBuilder, g.getMembersWithout(account.getSelfAddress()));
+        return new Pair<>(g.groupId, result.second());
     }
 
-    void sendUpdateGroupMessage(byte[] groupId, SignalServiceAddress recipient) throws IOException, EncapsulatedExceptions, NotAGroupMemberException, GroupNotFoundException, AttachmentInvalidException {
-        if (groupId == null) {
-            return;
-        }
+    Pair<Long, List<SendMessageResult>> sendUpdateGroupMessage(byte[] groupId, SignalServiceAddress recipient) throws IOException, NotAGroupMemberException, GroupNotFoundException, AttachmentInvalidException {
         GroupInfo g = getGroupForSending(groupId);
 
         if (!g.isMember(recipient)) {
-            return;
+            throw new NotAGroupMemberException(groupId, g.name);
         }
 
         SignalServiceDataMessage.Builder messageBuilder = getGroupUpdateMessageBuilder(g);
 
         // Send group message only to the recipient who requested it
-        sendMessageLegacy(messageBuilder, Collections.singleton(recipient));
+        return sendMessage(messageBuilder, Collections.singleton(recipient));
     }
 
     private SignalServiceDataMessage.Builder getGroupUpdateMessageBuilder(GroupInfo g) throws AttachmentInvalidException {
@@ -677,11 +673,7 @@ public class Manager implements Closeable {
                 .withExpiration(g.messageExpirationTime);
     }
 
-    void sendGroupInfoRequest(byte[] groupId, SignalServiceAddress recipient) throws IOException, EncapsulatedExceptions {
-        if (groupId == null) {
-            return;
-        }
-
+    Pair<Long, List<SendMessageResult>> sendGroupInfoRequest(byte[] groupId, SignalServiceAddress recipient) throws IOException {
         SignalServiceGroup.Builder group = SignalServiceGroup.newBuilder(SignalServiceGroup.Type.REQUEST_INFO)
                 .withId(groupId);
 
@@ -689,7 +681,7 @@ public class Manager implements Closeable {
                 .asGroupMessage(group.build());
 
         // Send group info request message to the recipient who sent us a message with this groupId
-        sendMessageLegacy(messageBuilder, Collections.singleton(recipient));
+        return sendMessage(messageBuilder, Collections.singleton(recipient));
     }
 
     void sendReceipt(SignalServiceAddress remoteAddress, long messageId) throws IOException, UntrustedIdentityException {
@@ -700,9 +692,9 @@ public class Manager implements Closeable {
         getMessageSender().sendReceipt(remoteAddress, getAccessFor(remoteAddress), receiptMessage);
     }
 
-    public long sendMessage(String messageText, List<String> attachments,
-                            List<String> recipients)
-            throws IOException, EncapsulatedExceptions, AttachmentInvalidException, InvalidNumberException {
+    public Pair<Long, List<SendMessageResult>> sendMessage(String messageText, List<String> attachments,
+                                                           List<String> recipients)
+            throws IOException, AttachmentInvalidException, InvalidNumberException {
         final SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder().withBody(messageText);
         if (attachments != null) {
             List<SignalServiceAttachment> attachmentStreams = Utils.getSignalServiceAttachments(attachments);
@@ -720,25 +712,25 @@ public class Manager implements Closeable {
 
             messageBuilder.withAttachments(attachmentPointers);
         }
-        return sendMessageLegacy(messageBuilder, getSignalServiceAddresses(recipients));
+        return sendMessage(messageBuilder, getSignalServiceAddresses(recipients));
     }
 
-    public void sendMessageReaction(String emoji, boolean remove, String targetAuthor,
-                                    long targetSentTimestamp, List<String> recipients)
-            throws IOException, EncapsulatedExceptions, InvalidNumberException {
+    public Pair<Long, List<SendMessageResult>> sendMessageReaction(String emoji, boolean remove, String targetAuthor,
+                                                                   long targetSentTimestamp, List<String> recipients)
+            throws IOException, InvalidNumberException {
         SignalServiceDataMessage.Reaction reaction = new SignalServiceDataMessage.Reaction(emoji, remove, canonicalizeAndResolveSignalServiceAddress(targetAuthor), targetSentTimestamp);
         final SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder()
                 .withReaction(reaction);
-        sendMessageLegacy(messageBuilder, getSignalServiceAddresses(recipients));
+        return sendMessage(messageBuilder, getSignalServiceAddresses(recipients));
     }
 
-    public void sendEndSessionMessage(List<String> recipients) throws IOException, EncapsulatedExceptions, InvalidNumberException {
+    public Pair<Long, List<SendMessageResult>> sendEndSessionMessage(List<String> recipients) throws IOException, InvalidNumberException {
         SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder()
                 .asEndSessionMessage();
 
         final Collection<SignalServiceAddress> signalServiceAddresses = getSignalServiceAddresses(recipients);
         try {
-            sendMessageLegacy(messageBuilder, signalServiceAddresses);
+            return sendMessage(messageBuilder, signalServiceAddresses);
         } catch (Exception e) {
             for (SignalServiceAddress address : signalServiceAddresses) {
                 handleEndSession(address);
@@ -793,7 +785,7 @@ public class Manager implements Closeable {
         account.save();
     }
 
-    public byte[] updateGroup(byte[] groupId, String name, List<String> members, String avatar) throws IOException, EncapsulatedExceptions, GroupNotFoundException, AttachmentInvalidException, InvalidNumberException, NotAGroupMemberException {
+    public Pair<byte[], List<SendMessageResult>> updateGroup(byte[] groupId, String name, List<String> members, String avatar) throws IOException, GroupNotFoundException, AttachmentInvalidException, InvalidNumberException, NotAGroupMemberException {
         if (groupId.length == 0) {
             groupId = null;
         }
@@ -1098,34 +1090,6 @@ public class Manager implements Closeable {
         }
     }
 
-    /**
-     * This method throws an EncapsulatedExceptions exception instead of returning a list of SendMessageResult.
-     */
-    private long sendMessageLegacy(SignalServiceDataMessage.Builder messageBuilder, Collection<SignalServiceAddress> recipients)
-            throws EncapsulatedExceptions, IOException {
-        final long timestamp = System.currentTimeMillis();
-        messageBuilder.withTimestamp(timestamp);
-        List<SendMessageResult> results = sendMessage(messageBuilder, recipients);
-
-        List<UntrustedIdentityException> untrustedIdentities = new LinkedList<>();
-        List<UnregisteredUserException> unregisteredUsers = new LinkedList<>();
-        List<NetworkFailureException> networkExceptions = new LinkedList<>();
-
-        for (SendMessageResult result : results) {
-            if (result.isUnregisteredFailure()) {
-                unregisteredUsers.add(new UnregisteredUserException(result.getAddress().getLegacyIdentifier(), null));
-            } else if (result.isNetworkFailure()) {
-                networkExceptions.add(new NetworkFailureException(result.getAddress().getLegacyIdentifier(), null));
-            } else if (result.getIdentityFailure() != null) {
-                untrustedIdentities.add(new UntrustedIdentityException("Untrusted", result.getAddress().getLegacyIdentifier(), result.getIdentityFailure().getIdentityKey()));
-            }
-        }
-        if (!untrustedIdentities.isEmpty() || !unregisteredUsers.isEmpty() || !networkExceptions.isEmpty()) {
-            throw new EncapsulatedExceptions(untrustedIdentities, unregisteredUsers, networkExceptions);
-        }
-        return timestamp;
-    }
-
     private Collection<SignalServiceAddress> getSignalServiceAddresses(Collection<String> numbers) throws InvalidNumberException {
         final Set<SignalServiceAddress> signalServiceAddresses = new HashSet<>(numbers.size());
 
@@ -1135,8 +1099,10 @@ public class Manager implements Closeable {
         return signalServiceAddresses;
     }
 
-    private List<SendMessageResult> sendMessage(SignalServiceDataMessage.Builder messageBuilder, Collection<SignalServiceAddress> recipients)
+    private Pair<Long, List<SendMessageResult>> sendMessage(SignalServiceDataMessage.Builder messageBuilder, Collection<SignalServiceAddress> recipients)
             throws IOException {
+        final long timestamp = System.currentTimeMillis();
+        messageBuilder.withTimestamp(timestamp);
         if (messagePipe == null) {
             messagePipe = getMessageReceiver().createMessagePipe();
         }
@@ -1156,10 +1122,10 @@ public class Manager implements Closeable {
                             account.getSignalProtocolStore().saveIdentity(r.getAddress(), r.getIdentityFailure().getIdentityKey(), TrustLevel.UNTRUSTED);
                         }
                     }
-                    return result;
+                    return new Pair<>(timestamp, result);
                 } catch (UntrustedIdentityException e) {
                     account.getSignalProtocolStore().saveIdentity(resolveSignalServiceAddress(e.getIdentifier()), e.getIdentityKey(), TrustLevel.UNTRUSTED);
-                    return Collections.emptyList();
+                    return new Pair<>(timestamp, Collections.emptyList());
                 }
             } else {
                 // Send to all individually, so sync messages are sent correctly
@@ -1180,7 +1146,7 @@ public class Manager implements Closeable {
                         results.add(sendMessage(address, message));
                     }
                 }
-                return results;
+                return new Pair<>(timestamp, results);
             }
         } finally {
             if (message != null && message.isEndSession()) {
@@ -1553,9 +1519,7 @@ public class Manager implements Closeable {
             if (message.getGroupContext().isPresent() && message.getGroupContext().get().getGroupV1().isPresent()) {
                 SignalServiceGroup groupInfo = message.getGroupContext().get().getGroupV1().get();
                 GroupInfo group = getGroup(groupInfo.getGroupId());
-                if (groupInfo.getType() == SignalServiceGroup.Type.DELIVER && group != null && group.blocked) {
-                    return true;
-                }
+                return groupInfo.getType() == SignalServiceGroup.Type.DELIVER && group != null && group.blocked;
             }
         }
         return false;

diff --git a/src/main/java/org/asamk/signal/util/ErrorUtils.java b/src/main/java/org/asamk/signal/util/ErrorUtils.java
index a09be3d0442ddef97c9595e21b0b4ec79fd98c83..37237f637ad3b8e5a855065f2049336f34380b45 100644 (file)
--- a/src/main/java/org/asamk/signal/util/ErrorUtils.java
+++ b/src/main/java/org/asamk/signal/util/ErrorUtils.java
@@ -2,13 +2,12 @@ package org.asamk.signal.util;
 
 import org.asamk.signal.manager.GroupNotFoundException;
 import org.asamk.signal.manager.NotAGroupMemberException;
-import org.whispersystems.signalservice.api.crypto.UntrustedIdentityException;
-import org.whispersystems.signalservice.api.push.exceptions.EncapsulatedExceptions;
-import org.whispersystems.signalservice.api.push.exceptions.NetworkFailureException;
-import org.whispersystems.signalservice.api.push.exceptions.UnregisteredUserException;
+import org.whispersystems.signalservice.api.messages.SendMessageResult;
 import org.whispersystems.signalservice.api.util.InvalidNumberException;
 
 import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
 
 public class ErrorUtils {
 
@@ -21,17 +20,36 @@ public class ErrorUtils {
         System.err.println("If you use an Oracle JRE please check if you have unlimited strength crypto enabled, see README");
     }
 
-    public static void handleEncapsulatedExceptions(EncapsulatedExceptions e) {
-        System.err.println("Failed to send (some) messages:");
-        for (NetworkFailureException n : e.getNetworkExceptions()) {
-            System.err.println("Network failure for \"" + n.getE164number() + "\": " + n.getMessage());
+    public static int handleTimestampAndSendMessageResults(long timestamp, List<SendMessageResult> results) {
+        System.out.println(timestamp);
+        List<String> errors = getErrorMessagesFromSendMessageResults(results);
+        return handleSendMessageResultErrors(errors);
+    }
+
+    public static List<String> getErrorMessagesFromSendMessageResults(List<SendMessageResult> results) {
+        List<String> errors = new ArrayList<>();
+        for (SendMessageResult result : results) {
+            if (result.isNetworkFailure()) {
+                errors.add(String.format("Network failure for \"%s\"", result.getAddress().getLegacyIdentifier()));
+            } else if (result.isUnregisteredFailure()) {
+                errors.add(String.format("Unregistered user \"%s\"", result.getAddress().getLegacyIdentifier()));
+            } else if (result.getIdentityFailure() != null) {
+                errors.add(String.format("Untrusted Identity for \"%s\"", result.getAddress().getLegacyIdentifier()));
+            }
         }
-        for (UnregisteredUserException n : e.getUnregisteredUserExceptions()) {
-            System.err.println("Unregistered user \"" + n.getE164Number() + "\": " + n.getMessage());
+
+        return errors;
+    }
+
+    private static int handleSendMessageResultErrors(List<String> errors) {
+        if (errors.size() == 0) {
+            return 0;
         }
-        for (UntrustedIdentityException n : e.getUntrustedIdentityExceptions()) {
-            System.err.println("Untrusted Identity for \"" + n.getIdentifier() + "\": " + n.getMessage());
+        System.err.println("Failed to send (some) messages:");
+        for (String error : errors) {
+            System.err.println(error);
         }
+        return 3;
     }
 
     public static void handleIOException(IOException e) {