Add debug UI for multi-image sends.

Signal/src/ViewControllers/ConversationView/ConversationViewController.m

@@ -1650,7 +1650,7 @@ typedef enum : NSUInteger {
                                                     networkManager:self.networkManager];
     [processor fetchAttachmentsForMessage:message
         primaryStorage:self.primaryStorage
-        success:^(TSAttachmentStream *attachmentStream) {
+        success:^(NSArray<TSAttachmentStream *> *attachmentStreams) {
             OWSLogInfo(@"Successfully redownloaded attachment in thread: %@", message.thread);
         }
         failure:^(NSError *error) {
@@ -2208,7 +2208,9 @@ typedef enum : NSUInteger {
     [self.editingDatabaseConnection asyncReadWriteWithBlock:^(YapDatabaseReadWriteTransaction *transaction) {
         [processor fetchAttachmentsForMessage:nil
             transaction:transaction
-            success:^(TSAttachmentStream *attachmentStream) {
+            success:^(NSArray<TSAttachmentStream *> *attachmentStreams) {
+                OWSAssertDebug(attachmentStreams.count == 1);
+                TSAttachmentStream *attachmentStream = attachmentStreams.firstObject;
                 [self.editingDatabaseConnection
                     asyncReadWriteWithBlock:^(YapDatabaseReadWriteTransaction *postSuccessTransaction) {
                         [message setQuotedMessageThumbnailAttachmentStream:attachmentStream];

SignalServiceKit/src/Devices/OWSRecordTranscriptJob.h

@@ -25,7 +25,7 @@ NS_ASSUME_NONNULL_BEGIN
                                       contactsManager:(id<ContactsManagerProtocol>)contactsManager
     NS_DESIGNATED_INITIALIZER;
 
-- (void)runWithAttachmentHandler:(void (^)(TSAttachmentStream *attachmentStream))attachmentHandler
+- (void)runWithAttachmentHandler:(void (^)(NSArray<TSAttachmentStream *> *attachmentStreams))attachmentHandler
                      transaction:(YapDatabaseReadWriteTransaction *)transaction;
 
 @end

SignalServiceKit/src/Devices/OWSRecordTranscriptJob.m

@@ -59,7 +59,7 @@ NS_ASSUME_NONNULL_BEGIN
     return self;
 }
 
-- (void)runWithAttachmentHandler:(void (^)(TSAttachmentStream *attachmentStream))attachmentHandler
+- (void)runWithAttachmentHandler:(void (^)(NSArray<TSAttachmentStream *> *attachmentStreams))attachmentHandler
                      transaction:(YapDatabaseReadWriteTransaction *)transaction
 {
     OWSAssertDebug(transaction);
@@ -112,7 +112,9 @@ NS_ASSUME_NONNULL_BEGIN
             OWSLogDebug(@"downloading thumbnail for transcript: %lu", (unsigned long)transcript.timestamp);
             [attachmentProcessor fetchAttachmentsForMessage:outgoingMessage
                 transaction:transaction
-                success:^(TSAttachmentStream *_Nonnull attachmentStream) {
+                success:^(NSArray<TSAttachmentStream *> *attachmentStreams) {
+                    OWSAssertDebug(attachmentStreams.count == 1);
+                    TSAttachmentStream *attachmentStream = attachmentStreams.firstObject;
                     [self.primaryStorage.newDatabaseConnection
                         asyncReadWriteWithBlock:^(YapDatabaseReadWriteTransaction *_Nonnull transaction) {
                             [outgoingMessage setQuotedMessageThumbnailAttachmentStream:attachmentStream];

SignalServiceKit/src/Messages/Attachments/OWSAttachmentsProcessor.h

@@ -41,11 +41,11 @@ extern NSString *const kAttachmentDownloadAttachmentIDKey;
 
 - (void)fetchAttachmentsForMessage:(nullable TSMessage *)message
                     primaryStorage:(OWSPrimaryStorage *)primaryStorage
-                           success:(void (^)(TSAttachmentStream *attachmentStream))successHandler
+                           success:(void (^)(NSArray<TSAttachmentStream *> *attachmentStreams))successHandler
                            failure:(void (^)(NSError *error))failureHandler;
 - (void)fetchAttachmentsForMessage:(nullable TSMessage *)message
                        transaction:(YapDatabaseReadWriteTransaction *)transaction
-                           success:(void (^)(TSAttachmentStream *attachmentStream))successHandler
+                           success:(void (^)(NSArray<TSAttachmentStream *> *attachmentStreams))successHandler
                            failure:(void (^)(NSError *error))failureHandler;
 @end
 

SignalServiceKit/src/Messages/Attachments/OWSAttachmentsProcessor.m

@@ -20,6 +20,7 @@
 #import "TSMessage.h"
 #import "TSNetworkManager.h"
 #import "TSThread.h"
+#import <PromiseKit/AnyPromise.h>
 #import <SignalCoreKit/Cryptography.h>
 #import <SignalServiceKit/SignalServiceKit-Swift.h>
 #import <YapDatabase/YapDatabaseConnection.h>
@@ -93,7 +94,7 @@ static const CGFloat kAttachmentDownloadProgressTheta = 0.001f;
 // PERF: Remove this and use a pre-existing dbConnection
 - (void)fetchAttachmentsForMessage:(nullable TSMessage *)message
                     primaryStorage:(OWSPrimaryStorage *)primaryStorage
-                           success:(void (^)(TSAttachmentStream *attachmentStream))successHandler
+                           success:(void (^)(NSArray<TSAttachmentStream *> *attachmentStreams))successHandler
                            failure:(void (^)(NSError *error))failureHandler
 {
     [[primaryStorage newDatabaseConnection] readWriteWithBlock:^(YapDatabaseReadWriteTransaction *transaction) {
@@ -106,18 +107,53 @@ static const CGFloat kAttachmentDownloadProgressTheta = 0.001f;
 
 - (void)fetchAttachmentsForMessage:(nullable TSMessage *)message
                        transaction:(YapDatabaseReadWriteTransaction *)transaction
-                           success:(void (^)(TSAttachmentStream *attachmentStream))successHandler
+                           success:(void (^)(NSArray<TSAttachmentStream *> *attachmentStreams))successHandler
                            failure:(void (^)(NSError *error))failureHandler
 {
     OWSAssertDebug(transaction);
+    OWSAssertDebug(self.attachmentPointers.count > 0);
+
+    NSMutableArray<AnyPromise *> *promises = [NSMutableArray array];
+    NSMutableArray<TSAttachmentStream *> *attachmentStreams = [NSMutableArray array];
 
     for (TSAttachmentPointer *attachmentPointer in self.attachmentPointers) {
-        [self retrieveAttachment:attachmentPointer
-                         message:message
-                     transaction:transaction
-                         success:successHandler
-                         failure:failureHandler];
+        AnyPromise *promise = [AnyPromise promiseWithResolverBlock:^(PMKResolver resolve) {
+            [self retrieveAttachment:attachmentPointer
+                message:message
+                transaction:transaction
+                success:^(TSAttachmentStream *attachmentStream) {
+                    OWSLogVerbose(@"Attachment download succeeded.");
+                    @synchronized(attachmentStreams) {
+                        [attachmentStreams addObject:attachmentStream];
+                    }
+                    resolve(@(1));
+                }
+                failure:^(NSError *error) {
+                    OWSLogError(@"Attachment download failed with error: %@", error);
+                    resolve(error);
+                }];
+        }];
+        [promises addObject:promise];
     }
+
+    // We use PMKJoin(), not PMKWhen(), because we don't want the
+    // completion promise to execute until _all_ promises
+    // have either succeeded or failed. PMKWhen() executes as
+    // soon as any of its input promises fail.
+    AnyPromise *completionPromise
+        = PMKJoin(promises)
+              .then(^(id value) {
+                  NSArray<TSAttachmentStream *> *attachmentStreamsCopy;
+                  @synchronized(attachmentStreams) {
+                      attachmentStreamsCopy = [attachmentStreams copy];
+                  }
+                  OWSLogInfo(@"Attachment downloads succeeded: %lu.", (unsigned long)attachmentStreamsCopy.count);
+                  successHandler(attachmentStreamsCopy);
+              })
+              .catch(^(NSError *error) {
+                  failureHandler(error);
+              });
+    [completionPromise retainUntilComplete];
 }
 
 - (void)retrieveAttachment:(TSAttachmentPointer *)attachment

SignalServiceKit/src/Messages/OWSMessageManager.m

@@ -731,7 +731,9 @@ NS_ASSUME_NONNULL_BEGIN
     }
     [attachmentsProcessor fetchAttachmentsForMessage:nil
         transaction:transaction
-        success:^(TSAttachmentStream *attachmentStream) {
+        success:^(NSArray<TSAttachmentStream *> *attachmentStreams) {
+            OWSAssertDebug(attachmentStreams.count == 1);
+            TSAttachmentStream *attachmentStream = attachmentStreams.firstObject;
             [groupThread updateAvatarWithAttachmentStream:attachmentStream];
         }
         failure:^(NSError *error) {
@@ -786,8 +788,10 @@ NS_ASSUME_NONNULL_BEGIN
 
     [attachmentsProcessor fetchAttachmentsForMessage:createdMessage
         transaction:transaction
-        success:^(TSAttachmentStream *attachmentStream) {
-            OWSLogDebug(@"successfully fetched attachment: %@ for message: %@", attachmentStream, createdMessage);
+        success:^(NSArray<TSAttachmentStream *> *attachmentStreams) {
+            OWSLogDebug(@"successfully fetched attachments: %lu for message: %@",
+                (unsigned long)attachmentStreams.count,
+                createdMessage);
         }
         failure:^(NSError *error) {
             OWSLogError(@"failed to fetch attachments for message: %@ with error: %@", createdMessage, error);
@@ -843,23 +847,27 @@ NS_ASSUME_NONNULL_BEGIN
         }
 
         if ([self isDataMessageGroupAvatarUpdate:syncMessage.sent.message]) {
-            [recordJob runWithAttachmentHandler:^(TSAttachmentStream *attachmentStream) {
-                [self.dbConnection readWriteWithBlock:^(YapDatabaseReadWriteTransaction *transaction) {
-                    TSGroupThread *_Nullable groupThread =
-                        [TSGroupThread threadWithGroupId:dataMessage.group.id transaction:transaction];
-                    if (!groupThread) {
-                        OWSFailDebug(@"ignoring sync group avatar update for unknown group.");
-                        return;
-                    }
-
-                    [groupThread updateAvatarWithAttachmentStream:attachmentStream transaction:transaction];
-                }];
-            }
-                                    transaction:transaction];
+            [recordJob
+                runWithAttachmentHandler:^(NSArray<TSAttachmentStream *> *attachmentStreams) {
+                    OWSAssertDebug(attachmentStreams.count == 1);
+                    TSAttachmentStream *attachmentStream = attachmentStreams.firstObject;
+                    [self.dbConnection readWriteWithBlock:^(YapDatabaseReadWriteTransaction *transaction) {
+                        TSGroupThread *_Nullable groupThread =
+                            [TSGroupThread threadWithGroupId:dataMessage.group.id transaction:transaction];
+                        if (!groupThread) {
+                            OWSFailDebug(@"ignoring sync group avatar update for unknown group.");
+                            return;
+                        }
+
+                        [groupThread updateAvatarWithAttachmentStream:attachmentStream transaction:transaction];
+                    }];
+                }
+                             transaction:transaction];
         } else {
             [recordJob
-                runWithAttachmentHandler:^(TSAttachmentStream *attachmentStream) {
-                    OWSLogDebug(@"successfully fetched transcript attachment: %@", attachmentStream);
+                runWithAttachmentHandler:^(NSArray<TSAttachmentStream *> *attachmentStreams) {
+                    OWSLogDebug(
+                        @"successfully fetched transcript attachments: %lu", (unsigned long)attachmentStreams.count);
                 }
                              transaction:transaction];
         }
@@ -1350,7 +1358,9 @@ NS_ASSUME_NONNULL_BEGIN
             OWSLogDebug(@"downloading thumbnail for message: %lu", (unsigned long)incomingMessage.timestamp);
             [attachmentProcessor fetchAttachmentsForMessage:incomingMessage
                 transaction:transaction
-                success:^(TSAttachmentStream *attachmentStream) {
+                success:^(NSArray<TSAttachmentStream *> *attachmentStreams) {
+                    OWSAssertDebug(attachmentStreams.count == 1);
+                    TSAttachmentStream *attachmentStream = attachmentStreams.firstObject;
                     [self.dbConnection asyncReadWriteWithBlock:^(YapDatabaseReadWriteTransaction *transaction) {
                         [incomingMessage setQuotedMessageThumbnailAttachmentStream:attachmentStream];
                         [incomingMessage saveWithTransaction:transaction];
@@ -1379,7 +1389,7 @@ NS_ASSUME_NONNULL_BEGIN
             OWSLogDebug(@"downloading contact avatar for message: %lu", (unsigned long)incomingMessage.timestamp);
             [attachmentProcessor fetchAttachmentsForMessage:incomingMessage
                 transaction:transaction
-                success:^(TSAttachmentStream *attachmentStream) {
+                success:^(NSArray<TSAttachmentStream *> *attachmentStreams) {
                     [self.dbConnection asyncReadWriteWithBlock:^(YapDatabaseReadWriteTransaction *transaction) {
                         [incomingMessage touchWithTransaction:transaction];
                     }];