Merge branch 'charlesmchen/debugUIMultiImageSends'

pull/1/head
Matthew Chen 7 years ago
commit 1e31e6aec5

@ -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];

@ -481,6 +481,7 @@ NSString *NSStringForOWSMessageCellType(OWSMessageCellType cellType)
if (message.attachmentIds.count == 0) {
return nil;
}
// TODO: Support multi-image messages.
NSString *_Nullable attachmentId = message.attachmentIds.firstObject;
if (attachmentId.length == 0) {
return nil;

@ -127,6 +127,10 @@ NS_ASSUME_NONNULL_BEGIN
actionBlock:^{
[DebugUIMessages sendNTextMessagesInThread:thread];
}],
[OWSTableItem itemWithTitle:@"Send Multi-Image Message"
actionBlock:^{
[DebugUIMessages sendMultiImageMessageInThread:thread];
}],
[OWSTableItem itemWithTitle:@"Select Fake"
actionBlock:^{
[DebugUIMessages selectFakeAction:thread];
@ -246,7 +250,6 @@ NS_ASSUME_NONNULL_BEGIN
[self.dbConnection readWriteWithBlock:^(YapDatabaseReadWriteTransaction *_Nonnull transaction) {
[self.messageSenderJobQueue addMessage:syncGroupsRequestMessage transaction:transaction];
}];
}],
[OWSTableItem itemWithTitle:@"Message with stalled timer"
actionBlock:^{
@ -3357,7 +3360,7 @@ typedef OWSContact * (^OWSContactBlock)(YapDatabaseReadWriteTransaction *transac
// style them indistinguishably from a separate text message.
attachment.captionText = [self randomCaptionText];
}
[ThreadUtil enqueueMessageWithAttachment:attachment inThread:thread quotedReplyModel:nil ignoreErrors:YES];
[ThreadUtil enqueueMessageWithAttachment:attachment inThread:thread quotedReplyModel:nil];
}
+ (SSKProtoEnvelope *)createEnvelopeForThread:(TSThread *)thread
@ -4631,6 +4634,41 @@ typedef OWSContact * (^OWSContactBlock)(YapDatabaseReadWriteTransaction *transac
}
}
+ (void)sendMultiImageMessageInThread:(TSThread *)thread
{
OWSLogInfo(@"");
const uint32_t kMinImageCount = 2;
const uint32_t kMaxImageCount = 10;
uint32_t imageCount = kMinImageCount + arc4random_uniform(kMaxImageCount - kMinImageCount);
NSMutableArray<SignalAttachment *> *attachments = [NSMutableArray new];
for (uint32_t i = 0; i < imageCount; i++) {
UIColor *imageColor = [UIColor colorWithRed:arc4random_uniform(256) / 255.f
green:arc4random_uniform(256) / 255.f
blue:arc4random_uniform(256) / 255.f
alpha:1.f];
UIImage *image = [UIImage imageWithColor:imageColor size:CGSizeMake(10.f, 10.f)];
OWSAssertDebug(image);
NSData *pngData = UIImagePNGRepresentation(image);
OWSAssertDebug(pngData);
NSString *filePath = [OWSFileSystem temporaryFilePathWithFileExtension:@"png"];
[pngData writeToFile:filePath atomically:YES];
OWSAssertDebug([NSFileManager.defaultManager fileExistsAtPath:filePath]);
DataSource *dataSource = [DataSourcePath dataSourceWithFilePath:filePath shouldDeleteOnDeallocation:YES];
SignalAttachment *attachment = [SignalAttachment attachmentWithDataSource:dataSource
dataUTI:(NSString *)kUTTypePNG
imageQuality:TSImageQualityOriginal];
[attachments addObject:attachment];
}
[self.dbConnection readWriteWithBlock:^(YapDatabaseReadWriteTransaction *transaction) {
TSOutgoingMessage *message =
[ThreadUtil enqueueMessageWithAttachments:attachments inThread:thread quotedReplyModel:nil];
OWSLogError(@"timestamp: %llu.", message.timestamp);
}];
}
#endif
@end

@ -634,7 +634,8 @@ class MediaGallery: NSObject, MediaGalleryDataSource, MediaTileViewControllerDel
var hasFetchedMostRecent = false
func buildGalleryItem(message: TSMessage, transaction: YapDatabaseReadTransaction) -> MediaGalleryItem? {
guard let attachmentStream = message.attachment(with: transaction) as? TSAttachmentStream else {
// TODO: Support multi-image messages.
guard let attachmentStream = message.attachments(with: transaction).first as? TSAttachmentStream else {
owsFailDebug("attachment was unexpectedly empty")
return nil
}

@ -398,6 +398,7 @@ class MessageDetailViewController: OWSViewController, MediaGalleryDataSourceDele
}
private func fetchAttachment(transaction: YapDatabaseReadTransaction) -> TSAttachment? {
// TODO: Support multi-image messages.
guard let attachmentId = message.attachmentIds.firstObject as? String else {
return nil
}

@ -579,6 +579,7 @@ typedef void (^SendMessageBlock)(SendCompletionBlock completion);
return;
}
// TODO: Support multi-image messages.
NSString *_Nullable attachmentRecordId = self.outgoingMessage.attachmentIds.firstObject;
if (!attachmentRecordId) {
OWSLogDebug(@"Ignoring upload progress until outgoing message has an attachment record id");

@ -167,7 +167,7 @@ NS_ASSUME_NONNULL_BEGIN
BOOL hasText = quotedText.length > 0;
BOOL hasAttachment = NO;
TSAttachment *_Nullable attachment = [message attachmentWithTransaction:transaction];
TSAttachment *_Nullable attachment = [message attachmentsWithTransaction:transaction].firstObject;
TSAttachmentStream *quotedAttachment;
if (attachment && [attachment isKindOfClass:[TSAttachmentStream class]]) {

@ -239,6 +239,11 @@ public class SignalAttachment: NSObject {
return errorDescription
}
@objc
public var outgoingAttachmentInfo: OutgoingAttachmentInfo {
return OutgoingAttachmentInfo(dataSource: dataSource, contentType: mimeType, sourceFilename: filenameOrDefault)
}
@objc
public func image() -> UIImage? {
if let cachedImage = cachedImage {

@ -53,10 +53,9 @@ NS_ASSUME_NONNULL_BEGIN
inThread:(TSThread *)thread
quotedReplyModel:(nullable OWSQuotedReplyModel *)quotedReplyModel;
+ (TSOutgoingMessage *)enqueueMessageWithAttachment:(SignalAttachment *)attachment
inThread:(TSThread *)thread
quotedReplyModel:(nullable OWSQuotedReplyModel *)quotedReplyModel
ignoreErrors:(BOOL)ignoreErrors;
+ (TSOutgoingMessage *)enqueueMessageWithAttachments:(NSArray<SignalAttachment *> *)attachments
inThread:(TSThread *)thread
quotedReplyModel:(nullable OWSQuotedReplyModel *)quotedReplyModel;
+ (TSOutgoingMessage *)enqueueMessageWithContactShare:(OWSContact *)contactShare inThread:(TSThread *)thread;
+ (void)enqueueLeaveGroupMessageInThread:(TSGroupThread *)thread;

@ -93,44 +93,49 @@ NS_ASSUME_NONNULL_BEGIN
inThread:(TSThread *)thread
quotedReplyModel:(nullable OWSQuotedReplyModel *)quotedReplyModel
{
return [self enqueueMessageWithAttachment:attachment
inThread:thread
quotedReplyModel:quotedReplyModel
ignoreErrors:NO];
return [self enqueueMessageWithAttachments:@[
attachment,
]
inThread:thread
quotedReplyModel:quotedReplyModel];
}
+ (TSOutgoingMessage *)enqueueMessageWithAttachment:(SignalAttachment *)attachment
inThread:(TSThread *)thread
quotedReplyModel:(nullable OWSQuotedReplyModel *)quotedReplyModel
ignoreErrors:(BOOL)ignoreErrors
+ (TSOutgoingMessage *)enqueueMessageWithAttachments:(NSArray<SignalAttachment *> *)attachments
inThread:(TSThread *)thread
quotedReplyModel:(nullable OWSQuotedReplyModel *)quotedReplyModel
{
OWSAssertIsOnMainThread();
OWSAssertDebug(attachment);
OWSAssertDebug(!attachment.hasError);
OWSAssertDebug(attachment.mimeType.length > 0);
OWSAssertDebug(attachments.count > 0);
OWSAssertDebug(thread);
for (SignalAttachment *attachment in attachments) {
OWSAssertDebug(!attachment.hasError);
OWSAssertDebug(attachment.mimeType.length > 0);
}
OWSDisappearingMessagesConfiguration *configuration =
[OWSDisappearingMessagesConfiguration fetchObjectWithUniqueID:thread.uniqueId];
uint32_t expiresInSeconds = (configuration.isEnabled ? configuration.durationSeconds : 0);
BOOL isVoiceMessage = (attachments.count == 1 && attachments.lastObject.isVoiceMessage);
// TODO: Support multi-image captions.
NSString *_Nullable messageBody = attachments.lastObject.captionText;
TSOutgoingMessage *message =
[[TSOutgoingMessage alloc] initOutgoingMessageWithTimestamp:[NSDate ows_millisecondTimeStamp]
inThread:thread
messageBody:attachment.captionText
messageBody:messageBody
attachmentIds:[NSMutableArray new]
expiresInSeconds:expiresInSeconds
expireStartedAt:0
isVoiceMessage:[attachment isVoiceMessage]
isVoiceMessage:isVoiceMessage
groupMetaMessage:TSGroupMetaMessageUnspecified
quotedMessage:[quotedReplyModel buildQuotedMessageForSending]
contactShare:nil];
[self.messageSenderJobQueue addMediaMessage:message
dataSource:attachment.dataSource
contentType:attachment.mimeType
sourceFilename:attachment.filenameOrDefault
isTemporaryAttachment:NO];
NSMutableArray<OWSOutgoingAttachmentInfo *> *attachmentInfos = [NSMutableArray new];
for (SignalAttachment *attachment in attachments) {
[attachmentInfos addObject:attachment.outgoingAttachmentInfo];
}
[self.messageSenderJobQueue addMediaMessage:message attachmentInfos:attachmentInfos isTemporaryAttachment:NO];
return message;
}

@ -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

@ -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];

@ -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

@ -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

@ -60,9 +60,6 @@ typedef void (^OWSThumbnailFailure)(void);
- (BOOL)writeData:(NSData *)data error:(NSError **)error;
- (BOOL)writeDataSource:(DataSource *)dataSource;
- (BOOL)isOversizeText;
- (nullable NSString *)readOversizeText;
+ (void)deleteAttachments;
+ (NSString *)attachmentsFolder;

@ -630,27 +630,6 @@ typedef void (^OWSLoadedThumbnailSuccess)(OWSLoadedThumbnail *loadedThumbnail);
return [OWSBackupFragment fetchObjectWithUniqueID:self.lazyRestoreFragmentId];
}
- (BOOL)isOversizeText
{
return [self.contentType isEqualToString:OWSMimeTypeOversizeTextMessage];
}
- (nullable NSString *)readOversizeText
{
if (!self.isOversizeText) {
OWSFailDebug(@"oversize text attachment has unexpected content type.");
return nil;
}
NSError *error;
NSData *_Nullable data = [self readDataFromFileWithError:&error];
if (error || !data) {
OWSFailDebug(@"could not read oversize text attachment: %@.", error);
return nil;
}
NSString *_Nullable string = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
return string;
}
#pragma mark - Thumbnails
- (nullable UIImage *)thumbnailImageWithSizeHint:(CGSize)sizeHint

@ -489,7 +489,6 @@ NSString *NSStringForContactAddressType(OWSContactAddressType value)
return [TSAttachment fetchObjectWithUniqueID:self.avatarAttachmentId transaction:transaction];
}
- (void)saveAvatarImage:(UIImage *)image transaction:(YapDatabaseReadWriteTransaction *)transaction
{
NSData *imageData = UIImageJPEGRepresentation(image, (CGFloat)0.9);

@ -41,9 +41,11 @@ NS_ASSUME_NONNULL_BEGIN
- (nullable instancetype)initWithCoder:(NSCoder *)coder NS_DESIGNATED_INITIALIZER;
- (BOOL)hasAttachments;
- (nullable TSAttachment *)attachmentWithTransaction:(YapDatabaseReadTransaction *)transaction;
- (NSArray<TSAttachment *> *)attachmentsWithTransaction:(YapDatabaseReadTransaction *)transaction;
- (void)setQuotedMessageThumbnailAttachmentStream:(TSAttachmentStream *)attachmentStream;
- (nullable NSString *)oversizeTextWithTransaction:(YapDatabaseReadTransaction *)transaction;
- (nullable NSString *)bodyTextWithTransaction:(YapDatabaseReadTransaction *)transaction;
- (BOOL)shouldStartExpireTimerWithTransaction:(YapDatabaseReadTransaction *)transaction;

@ -199,14 +199,19 @@ static const NSUInteger OWSMessageSchemaVersion = 4;
return self.attachmentIds ? (self.attachmentIds.count > 0) : NO;
}
- (nullable TSAttachment *)attachmentWithTransaction:(YapDatabaseReadTransaction *)transaction
- (NSArray<TSAttachment *> *)attachmentsWithTransaction:(YapDatabaseReadTransaction *)transaction
{
if (!self.hasAttachments) {
return nil;
NSMutableArray<TSAttachment *> *attachments = [NSMutableArray new];
for (NSString *attachmentId in self.attachmentIds) {
TSAttachment *_Nullable attachment =
[TSAttachment fetchObjectWithUniqueID:attachmentId transaction:transaction];
if (attachment) {
[attachments addObject:attachment];
} else {
OWSFailDebug(@"Missing attachment for: %@.", attachmentId);
}
}
OWSAssertDebug(self.attachmentIds.count == 1);
return [TSAttachment fetchObjectWithUniqueID:self.attachmentIds.firstObject transaction:transaction];
return [attachments copy];
}
- (NSString *)debugDescription
@ -223,23 +228,40 @@ static const NSUInteger OWSMessageSchemaVersion = 4;
}
}
- (nullable NSString *)oversizeTextWithTransaction:(YapDatabaseReadTransaction *)transaction
{
if (self.attachmentIds.count != 1) {
return nil;
}
TSAttachment *_Nullable attachment = [self attachmentsWithTransaction:transaction].firstObject;
OWSAssertDebug(attachment);
if (![OWSMimeTypeOversizeTextMessage isEqualToString:attachment.contentType]
|| ![attachment isKindOfClass:TSAttachmentStream.class]) {
return nil;
}
TSAttachmentStream *attachmentStream = (TSAttachmentStream *)attachment;
NSData *_Nullable data = [NSData dataWithContentsOfFile:attachmentStream.originalFilePath];
if (!data) {
OWSFailDebug(@"Can't load oversize text data.");
return nil;
}
NSString *_Nullable text = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
if (!text) {
OWSFailDebug(@"Can't parse oversize text data.");
return nil;
}
return text.filterStringForDisplay;
}
- (nullable NSString *)bodyTextWithTransaction:(YapDatabaseReadTransaction *)transaction
{
if (self.hasAttachments) {
TSAttachment *_Nullable attachment = [self attachmentWithTransaction:transaction];
if ([OWSMimeTypeOversizeTextMessage isEqualToString:attachment.contentType] &&
[attachment isKindOfClass:TSAttachmentStream.class]) {
TSAttachmentStream *attachmentStream = (TSAttachmentStream *)attachment;
NSData *_Nullable data = [NSData dataWithContentsOfFile:attachmentStream.originalFilePath];
if (data) {
NSString *_Nullable text = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
if (text) {
return text.filterStringForDisplay;
}
}
}
NSString *_Nullable oversizeText = [self oversizeTextWithTransaction:transaction];
if (oversizeText) {
return oversizeText;
}
if (self.body.length > 0) {

@ -253,7 +253,8 @@ NS_ASSUME_NONNULL_BEGIN
return nil;
}
TSAttachment *attachment = [quotedMessage attachmentWithTransaction:transaction];
// We quote _the first_ attachment, if any.
TSAttachment *_Nullable attachment = [quotedMessage attachmentsWithTransaction:transaction].firstObject;
if (![attachment isKindOfClass:[TSAttachmentStream class]]) {
return nil;
}

@ -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];
}];

@ -33,6 +33,23 @@ typedef void (^RetryableFailureHandler)(NSError *_Nonnull error);
#pragma mark -
NS_SWIFT_NAME(OutgoingAttachmentInfo)
@interface OWSOutgoingAttachmentInfo : NSObject
@property (nonatomic, readonly) DataSource *dataSource;
@property (nonatomic, readonly) NSString *contentType;
@property (nonatomic, readonly, nullable) NSString *sourceFilename;
- (instancetype)init NS_UNAVAILABLE;
- (instancetype)initWithDataSource:(DataSource *)dataSource
contentType:(NSString *)contentType
sourceFilename:(nullable NSString *)sourceFilename NS_DESIGNATED_INITIALIZER;
@end
#pragma mark -
NS_SWIFT_NAME(MessageSender)
@interface OWSMessageSender : NSObject
@ -71,6 +88,8 @@ NS_SWIFT_NAME(MessageSender)
@end
#pragma mark -
@interface OutgoingMessagePreparer : NSObject
/// Persists all necessary data to disk before sending, e.g. generate thumbnails
@ -80,11 +99,10 @@ NS_SWIFT_NAME(MessageSender)
transaction:(YapDatabaseReadWriteTransaction *)transaction;
/// Writes attachment to disk and applies original filename to message attributes
+ (void)prepareAttachmentWithDataSource:(DataSource *)dataSource
contentType:(NSString *)contentType
sourceFilename:(nullable NSString *)sourceFilename
inMessage:(TSOutgoingMessage *)outgoingMessage
completionHandler:(void (^)(NSError *_Nullable error))completionHandler;
+ (void)prepareAttachments:(NSArray<OWSOutgoingAttachmentInfo *> *)attachmentInfos
inMessage:(TSOutgoingMessage *)outgoingMessage
completionHandler:(void (^)(NSError *_Nullable error))completionHandler
NS_SWIFT_NAME(prepareAttachments(_:inMessage:completionHandler:));
@end

@ -81,6 +81,28 @@ void AssertIsOnSendingQueue()
#pragma mark -
@implementation OWSOutgoingAttachmentInfo
- (instancetype)initWithDataSource:(DataSource *)dataSource
contentType:(NSString *)contentType
sourceFilename:(nullable NSString *)sourceFilename
{
self = [super init];
if (!self) {
return self;
}
_dataSource = dataSource;
_contentType = contentType;
_sourceFilename = sourceFilename;
return self;
}
@end
#pragma mark -
/**
* OWSSendMessageOperation encapsulates all the work associated with sending a message, e.g. uploading attachments,
* getting proper keys, and retrying upon failure.
@ -156,13 +178,14 @@ void AssertIsOnSendingQueue()
// Sanity check preconditions
if (self.message.hasAttachments) {
[self.dbConnection readWithBlock:^(YapDatabaseReadTransaction * transaction) {
TSAttachmentStream *attachmentStream
= (TSAttachmentStream *)[self.message attachmentWithTransaction:transaction];
OWSAssertDebug(attachmentStream);
OWSAssertDebug([attachmentStream isKindOfClass:[TSAttachmentStream class]]);
OWSAssertDebug(attachmentStream.serverId);
OWSAssertDebug(attachmentStream.isUploaded);
[self.dbConnection readWithBlock:^(YapDatabaseReadTransaction *transaction) {
for (TSAttachment *attachment in [self.message attachmentsWithTransaction:transaction]) {
OWSAssertDebug([attachment isKindOfClass:[TSAttachmentStream class]]);
TSAttachmentStream *attachmentStream = (TSAttachmentStream *)attachment;
OWSAssertDebug(attachmentStream);
OWSAssertDebug(attachmentStream.serverId);
OWSAssertDebug(attachmentStream.isUploaded);
}
}];
}
@ -353,11 +376,10 @@ NSString *const OWSMessageSenderRateLimitedException = @"RateLimitedException";
success:successHandler
failure:failureHandler];
// TODO de-dupe attachment enque logic.
if (message.hasAttachments) {
// TODO: de-dupe attachment enqueue logic.
for (NSString *attachmentId in message.attachmentIds) {
OWSUploadOperation *uploadAttachmentOperation =
[[OWSUploadOperation alloc] initWithAttachmentId:message.attachmentIds.firstObject
dbConnection:self.dbConnection];
[[OWSUploadOperation alloc] initWithAttachmentId:attachmentId dbConnection:self.dbConnection];
[sendMessageOperation addDependency:uploadAttachmentOperation];
[sendingQueue addOperation:uploadAttachmentOperation];
}
@ -431,17 +453,18 @@ NSString *const OWSMessageSenderRateLimitedException = @"RateLimitedException";
failure:(void (^)(NSError *error))failureHandler
{
OWSAssertDebug(dataSource);
[OutgoingMessagePreparer prepareAttachmentWithDataSource:dataSource
contentType:contentType
sourceFilename:sourceFilename
inMessage:message
completionHandler:^(NSError *_Nullable error) {
if (error) {
failureHandler(error);
return;
}
[self sendMessage:message success:successHandler failure:failureHandler];
}];
OWSOutgoingAttachmentInfo *attachmentInfo = [[OWSOutgoingAttachmentInfo alloc] initWithDataSource:dataSource
contentType:contentType
sourceFilename:sourceFilename];
[OutgoingMessagePreparer prepareAttachments:@[ attachmentInfo ]
inMessage:message
completionHandler:^(NSError *_Nullable error) {
if (error) {
failureHandler(error);
return;
}
[self sendMessage:message success:successHandler failure:failureHandler];
}];
}
- (void)sendMessageToService:(TSOutgoingMessage *)message
@ -1768,35 +1791,42 @@ NSString *const OWSMessageSenderRateLimitedException = @"RateLimitedException";
[message updateWithMarkingAllUnsentRecipientsAsSendingWithTransaction:transaction];
}
+ (void)prepareAttachmentWithDataSource:(DataSource *)dataSource
contentType:(NSString *)contentType
sourceFilename:(nullable NSString *)sourceFilename
inMessage:(TSOutgoingMessage *)outgoingMessage
completionHandler:(void (^)(NSError *_Nullable error))completionHandler
+ (void)prepareAttachments:(NSArray<OWSOutgoingAttachmentInfo *> *)attachmentInfos
inMessage:(TSOutgoingMessage *)outgoingMessage
completionHandler:(void (^)(NSError *_Nullable error))completionHandler
{
OWSAssertDebug(dataSource);
OWSAssertDebug(attachmentInfos.count > 0);
OWSAssertDebug(outgoingMessage);
dispatch_async([OWSDispatch attachmentsQueue], ^{
TSAttachmentStream *attachmentStream =
[[TSAttachmentStream alloc] initWithContentType:contentType
byteCount:(UInt32)dataSource.dataLength
sourceFilename:sourceFilename];
if (outgoingMessage.isVoiceMessage) {
attachmentStream.attachmentType = TSAttachmentTypeVoiceMessage;
}
NSMutableArray<TSAttachmentStream *> *attachmentStreams = [NSMutableArray new];
for (OWSOutgoingAttachmentInfo *attachmentInfo in attachmentInfos) {
TSAttachmentStream *attachmentStream =
[[TSAttachmentStream alloc] initWithContentType:attachmentInfo.contentType
byteCount:(UInt32)attachmentInfo.dataSource.dataLength
sourceFilename:attachmentInfo.sourceFilename];
if (outgoingMessage.isVoiceMessage) {
attachmentStream.attachmentType = TSAttachmentTypeVoiceMessage;
}
if (![attachmentStream writeDataSource:attachmentInfo.dataSource]) {
OWSProdError([OWSAnalyticsEvents messageSenderErrorCouldNotWriteAttachment]);
NSError *error = OWSErrorMakeWriteAttachmentDataError();
completionHandler(error);
return;
}
if (![attachmentStream writeDataSource:dataSource]) {
OWSProdError([OWSAnalyticsEvents messageSenderErrorCouldNotWriteAttachment]);
NSError *error = OWSErrorMakeWriteAttachmentDataError();
completionHandler(error);
[attachmentStreams addObject:attachmentStream];
}
[self.dbConnection readWriteWithBlock:^(YapDatabaseReadWriteTransaction *_Nonnull transaction) {
[attachmentStream saveWithTransaction:transaction];
for (TSAttachmentStream *attachmentStream in attachmentStreams) {
[attachmentStream saveWithTransaction:transaction];
[outgoingMessage.attachmentIds addObject:attachmentStream.uniqueId];
if (sourceFilename) {
outgoingMessage.attachmentFilenameMap[attachmentStream.uniqueId] = sourceFilename;
[outgoingMessage.attachmentIds addObject:attachmentStream.uniqueId];
if (attachmentStream.sourceFilename) {
outgoingMessage.attachmentFilenameMap[attachmentStream.uniqueId] = attachmentStream.sourceFilename;
}
}
[outgoingMessage saveWithTransaction:transaction];
}];

@ -34,20 +34,25 @@ public class MessageSenderJobQueue: NSObject, JobQueue {
@objc(addMediaMessage:dataSource:contentType:sourceFilename:isTemporaryAttachment:)
public func add(mediaMessage: TSOutgoingMessage, dataSource: DataSource, contentType: String, sourceFilename: String?, isTemporaryAttachment: Bool) {
OutgoingMessagePreparer.prepareAttachment(with: dataSource,
contentType: contentType,
sourceFilename: sourceFilename,
in: mediaMessage) { error in
if let error = error {
self.dbConnection.readWrite { transaction in
mediaMessage.update(sendingError: error, transaction: transaction)
}
} else {
self.dbConnection.readWrite { transaction in
self.add(message: mediaMessage, removeMessageAfterSending: isTemporaryAttachment, transaction: transaction)
}
let attachmentInfo = OutgoingAttachmentInfo(dataSource: dataSource, contentType: contentType, sourceFilename: sourceFilename)
add(mediaMessage: mediaMessage, attachmentInfos: [attachmentInfo], isTemporaryAttachment: isTemporaryAttachment)
}
@objc(addMediaMessage:attachmentInfos:isTemporaryAttachment:)
public func add(mediaMessage: TSOutgoingMessage, attachmentInfos: [OutgoingAttachmentInfo], isTemporaryAttachment: Bool) {
OutgoingMessagePreparer.prepareAttachments(attachmentInfos,
inMessage: mediaMessage,
completionHandler: { error in
if let error = error {
self.dbConnection.readWrite { transaction in
mediaMessage.update(sendingError: error, transaction: transaction)
}
}
} else {
self.dbConnection.readWrite { transaction in
self.add(message: mediaMessage, removeMessageAfterSending: isTemporaryAttachment, transaction: transaction)
}
}
})
}
private func add(message: TSOutgoingMessage, removeMessageAfterSending: Bool, transaction: YapDatabaseReadWriteTransaction) {

@ -194,41 +194,12 @@ public class FullTextSearchFinder: NSObject {
}
private static let messageIndexer: SearchIndexer<TSMessage> = SearchIndexer { (message: TSMessage, transaction: YapDatabaseReadTransaction) in
if let body = message.body, body.count > 0 {
return body
}
if let oversizeText = oversizeText(forMessage: message, transaction: transaction) {
return oversizeText
if let bodyText = message.bodyText(with: transaction) {
return bodyText
}
return ""
}
private static func oversizeText(forMessage message: TSMessage, transaction: YapDatabaseReadTransaction) -> String? {
guard message.hasAttachments() else {
return nil
}
guard let attachment = message.attachment(with: transaction) else {
owsFailDebug("attachment was unexpectedly nil")
return nil
}
guard let attachmentStream = attachment as? TSAttachmentStream else {
return nil
}
guard attachmentStream.isOversizeText() else {
return nil
}
guard let text = attachmentStream.readOversizeText() else {
owsFailDebug("Could not load oversize text attachment")
return nil
}
return text
}
private class func indexContent(object: Any, transaction: YapDatabaseReadTransaction) -> String? {
if let groupThread = object as? TSGroupThread {
return self.groupThreadIndexer.index(groupThread, transaction: transaction)

@ -147,17 +147,20 @@ static NSString *const OWSMediaGalleryFinderExtensionName = @"OWSMediaGalleryFin
return nil;
}
TSMessage *message = (TSMessage *)object;
OWSAssertDebug(message.attachmentIds.count <= 1);
NSString *attachmentId = message.attachmentIds.firstObject;
if (attachmentId.length == 0) {
return nil;
BOOL allAttachmentsAreMedia = message.attachmentIds.count > 0;
for (NSString *attachmentId in message.attachmentIds) {
OWSAssertDebug(attachmentId.length > 0);
if (![self attachmentIdShouldAppearInMediaGallery:attachmentId transaction:transaction]) {
allAttachmentsAreMedia = NO;
break;
}
}
if ([self attachmentIdShouldAppearInMediaGallery:attachmentId transaction:transaction]) {
if (allAttachmentsAreMedia) {
return [self mediaGroupWithThreadId:message.uniqueThreadId];
}
return nil;
}];

@ -609,6 +609,7 @@ public class ShareViewController: UIViewController, ShareViewDelegate, SAEFailed
}
// Prefer a URL provider if available
// TODO: Support multi-image messages.
if let preferredAttachment = attachments.first(where: { (attachment: Any) -> Bool in
guard let itemProvider = attachment as? NSItemProvider else {
return false

Loading…
Cancel
Save