Separate out Session sync message sending logic

SignalMessaging/contacts/OWSSyncManager.m

@@ -228,12 +228,9 @@ NSString *const kSyncManagerLastContactSyncKey = @"kTSStorageManagerOWSSyncManag
         if (!self.tsAccountManager.isRegisteredAndReady) {
             return;
         }        
-        
-        NSUserDefaults *userDefaults = NSUserDefaults.standardUserDefaults;
-        BOOL hasLaunchedOnce = [userDefaults boolForKey:@"hasLaunchedOnce"];
-        if (hasLaunchedOnce) { // FIXME: Quick and dirty workaround to not do this on initial launch
-            [self sendConfigurationSyncMessage_AppReady];
-        }
+
+        if ([LKSyncMessagesProtocol shouldSkipConfigurationSyncMessage]) { return; }
+        [self sendConfigurationSyncMessage_AppReady];
     }];
 }
 
@@ -273,38 +270,13 @@ NSString *const kSyncManagerLastContactSyncKey = @"kTSStorageManagerOWSSyncManag
 
 - (AnyPromise *)syncContact:(NSString *)hexEncodedPubKey transaction:(YapDatabaseReadTransaction *)transaction
 {
-    TSContactThread *thread = [TSContactThread getThreadWithContactId:hexEncodedPubKey transaction:transaction];
-    if (thread != nil && thread.isContactFriend) {
-        return [self syncContactsForSignalAccounts:@[[[SignalAccount alloc] initWithRecipientId:hexEncodedPubKey]]];
-    }
+    [LKSyncMessagesProtocol syncContactWithHexEncodedPublicKey:hexEncodedPubKey in:transaction];
     return [AnyPromise promiseWithValue:@1];
 }
 
 - (AnyPromise *)syncAllContacts
 {
-    NSMutableArray<SignalAccount *> *friends = @[].mutableCopy;
-    NSMutableArray<AnyPromise *> *promises = @[].mutableCopy;
-    [TSContactThread enumerateCollectionObjectsUsingBlock:^(TSContactThread *thread, BOOL *stop) {
-        NSString *hexEncodedPublicKey = thread.contactIdentifier;
-        if (hexEncodedPublicKey != nil && thread.isContactFriend && thread.shouldThreadBeVisible && !thread.isForceHidden) {
-            [friends addObject:[[SignalAccount alloc] initWithRecipientId:hexEncodedPublicKey]];
-        }
-    }];
-    [friends addObject:[[SignalAccount alloc] initWithRecipientId:self.tsAccountManager.localNumber]];
-    NSMutableArray<SignalAccount *> *signalAccounts = @[].mutableCopy;
-    for (SignalAccount *contact in friends) {
-        [signalAccounts addObject:contact];
-        if (signalAccounts.count >= 3) {
-            [promises addObject:[self syncContactsForSignalAccounts:[signalAccounts copy]]];
-            [signalAccounts removeAllObjects];
-        }
-    }
-    if (signalAccounts.count > 0) {
-        [promises addObject:[self syncContactsForSignalAccounts:signalAccounts]];
-    }
-    AnyPromise *promise = PMKJoin(promises);
-    [promise retainUntilComplete];
-    return promise;
+    return [LKSyncMessagesProtocol syncAllContacts];
 }
 
 - (AnyPromise *)syncContactsForSignalAccounts:(NSArray<SignalAccount *> *)signalAccounts
@@ -327,26 +299,7 @@ NSString *const kSyncManagerLastContactSyncKey = @"kTSStorageManagerOWSSyncManag
 
 - (AnyPromise *)syncAllGroups
 {
-    NSMutableArray<TSGroupThread *> *groupThreads = @[].mutableCopy;
-    NSMutableArray<AnyPromise *> *promises = @[].mutableCopy;
-    [TSGroupThread enumerateCollectionObjectsUsingBlock:^(id obj, BOOL *stop) {
-        if (![obj isKindOfClass:[TSGroupThread class]]) {
-            if (![obj isKindOfClass:[TSContactThread class]]) { // FIXME: Isn't this redundant?
-                OWSLogWarn(@"Ignoring non-group thread in thread collection: %@.", obj);
-            }
-            return;
-        }
-        TSGroupThread *thread = (TSGroupThread *)obj;
-        if (thread.groupModel.groupType == closedGroup && thread.shouldThreadBeVisible && !thread.isForceHidden) {
-            [groupThreads addObject:thread];
-        }
-    }];
-    for (TSGroupThread *groupThread in groupThreads) {
-        [promises addObject:[self syncGroupForThread:groupThread]];
-    }
-    AnyPromise *promise = PMKJoin(promises);
-    [promise retainUntilComplete];
-    return promise;
+    return [LKSyncMessagesProtocol syncAllClosedGroups];
 }
 
 - (AnyPromise *)syncGroupForThread:(TSGroupThread *)thread
@@ -369,20 +322,7 @@ NSString *const kSyncManagerLastContactSyncKey = @"kTSStorageManagerOWSSyncManag
 
 - (AnyPromise *)syncAllOpenGroups
 {
-    LKSyncOpenGroupsMessage *syncOpenGroupsMessage = [[LKSyncOpenGroupsMessage alloc] init];
-    AnyPromise *promise = [AnyPromise promiseWithResolverBlock:^(PMKResolver resolve) {
-        [self.messageSender sendMessage:syncOpenGroupsMessage
-            success:^{
-                OWSLogInfo(@"Successfully sent open group sync message.");
-                resolve(@(1));
-            }
-            failure:^(NSError *error) {
-                OWSLogError(@"Failed to send open group sync message due to error: %@.", error);
-                resolve(error);
-            }];
-    }];
-    [promise retainUntilComplete];
-    return promise;
+    return [LKSyncMessagesProtocol syncAllOpenGroups];
 }
 
 @end

SignalServiceKit/src/Loki/Protocol/Sync Messages/SyncMessagesProtocol.swift

@@ -17,6 +17,76 @@ public final class SyncMessagesProtocol : NSObject {
 
     internal static var storage: OWSPrimaryStorage { OWSPrimaryStorage.shared() }
 
+    // MARK: - Sending
+    @objc(shouldSkipConfigurationSyncMessage)
+    public static func shouldSkipConfigurationSyncMessage() -> Bool {
+        return !UserDefaults.standard[.hasLaunchedOnce]
+    }
+
+    @objc(syncContactWithHexEncodedPublicKey:in:)
+    public static func syncContact(_ hexEncodedPublicKey: String, in transaction: YapDatabaseReadTransaction) {
+        if let thread = TSContactThread.getWithContactId(hexEncodedPublicKey, transaction: transaction) { // TODO: Should this be getOrCreate?
+            let syncManager = SSKEnvironment.shared.syncManager
+            syncManager.syncContacts(for: [ SignalAccount(recipientId: hexEncodedPublicKey) ])
+        }
+    }
+
+    @objc(syncAllContacts)
+    public static func objc_syncAllContacts() -> AnyPromise {
+        return AnyPromise.from(syncAllContacts())
+    }
+
+    public static func syncAllContacts() -> Promise<Void> {
+        var friends: [SignalAccount] = []
+        TSContactThread.enumerateCollectionObjects { object, _ in
+            guard let thread = object as? TSContactThread else { return }
+            let hexEncodedPublicKey = thread.contactIdentifier()
+            guard thread.isContactFriend && thread.shouldThreadBeVisible && !thread.isForceHidden else { return }
+            friends.append(SignalAccount(recipientId: hexEncodedPublicKey))
+        }
+        friends.append(SignalAccount(recipientId: getUserHexEncodedPublicKey())) // TODO: We sure about this?
+        let syncManager = SSKEnvironment.shared.syncManager
+        let promises = friends.chunked(by: 3).map { friends -> Promise<Void> in
+            return Promise(syncManager.syncContacts(for: friends)).map { _ in }
+        }
+        return when(fulfilled: promises)
+    }
+
+    @objc(syncAllClosedGroups)
+    public static func objc_syncAllClosedGroups() -> AnyPromise {
+        return AnyPromise.from(syncAllClosedGroups())
+    }
+
+    public static func syncAllClosedGroups() -> Promise<Void> {
+        var groups: [TSGroupThread] = []
+        TSGroupThread.enumerateCollectionObjects { object, _ in
+            guard let group = object as? TSGroupThread, group.groupModel.groupType == .closedGroup, group.shouldThreadBeVisible, !group.isForceHidden else { return }
+            groups.append(group)
+        }
+        let syncManager = SSKEnvironment.shared.syncManager
+        let promises = groups.map { group -> Promise<Void> in
+            return Promise(syncManager.syncGroup(for: group)).map { _ in }
+        }
+        return when(fulfilled: promises)
+    }
+
+    @objc(syncAllOpenGroups)
+    public static func objc_syncAllOpenGroups() -> AnyPromise {
+        return AnyPromise.from(syncAllOpenGroups())
+    }
+
+    public static func syncAllOpenGroups() -> Promise<Void> {
+        let openGroupSyncMessage = LKSyncOpenGroupsMessage()
+        let (promise, seal) = Promise<Void>.pending()
+        let messageSender = SSKEnvironment.shared.messageSender
+        messageSender.send(openGroupSyncMessage, success: {
+            seal.fulfill(())
+        }) { error in
+            seal.reject(error)
+        }
+        return promise
+    }
+
     // MARK: - Receiving
     @objc(isValidSyncMessage:in:)
     public static func isValidSyncMessage(_ envelope: SSKProtoEnvelope, in transaction: YapDatabaseReadTransaction) -> Bool {

SignalServiceKit/src/TestUtils/OWSMockSyncManager.swift

@@ -20,7 +20,12 @@ public class OWSMockSyncManager: NSObject, OWSSyncManagerProtocol {
 
         return AnyPromise()
     }
-    
+
+    public func syncGroup(for thread: TSGroupThread) -> AnyPromise {
+        Logger.info("")
+
+        return AnyPromise()
+    }
 
     @objc public func sendConfigurationSyncMessage() {
         Logger.info("")

SignalServiceKit/src/Util/OWSSyncManagerProtocol.h

@@ -7,6 +7,7 @@ NS_ASSUME_NONNULL_BEGIN
 @class AnyPromise;
 @class SignalAccount;
 @class YapDatabaseReadTransaction;
+@class TSGroupThread;
 
 @protocol OWSSyncManagerProtocol <NSObject>
 
@@ -22,6 +23,8 @@ NS_ASSUME_NONNULL_BEGIN
 
 - (AnyPromise *)syncAllGroups __attribute__((warn_unused_result));
 
+- (AnyPromise *)syncGroupForThread:(TSGroupThread *)thread;
+
 - (AnyPromise *)syncAllOpenGroups __attribute__((warn_unused_result));
 
 @end