tweaks on closed group polling logic

Session/Utilities/BackgroundPoller.swift

@@ -33,15 +33,14 @@ public final class BackgroundPoller : NSObject {
     
     private static func pollForClosedGroupMessages() -> [Promise<Void>] {
         let publicKeys = Storage.shared.getUserClosedGroupPublicKeys()
-        return publicKeys.map { getMessages(for: $0, isClosedGroup: true) }
+        return publicKeys.map { getClosedGroupMessages(for: $0) }
     }
     
-    private static func getMessages(for publicKey: String, isClosedGroup: Bool = false) -> Promise<Void> {
+    private static func getMessages(for publicKey: String) -> Promise<Void> {
         return SnodeAPI.getSwarm(for: publicKey).then(on: DispatchQueue.main) { swarm -> Promise<Void> in
             guard let snode = swarm.randomElement() else { throw SnodeAPI.Error.generic }
             return attempt(maxRetryCount: 4, recoveringOn: DispatchQueue.main) {
-                var getMessagesPromises: [Promise<Void>] = []
+                SnodeAPI.getRawMessages(from: snode, associatedWith: publicKey).then(on: DispatchQueue.main) { rawResponse -> Promise<Void> in
-                let promise = SnodeAPI.getRawMessages(from: snode, associatedWith: publicKey, authenticated: !isClosedGroup).then(on: DispatchQueue.main) { rawResponse -> Promise<Void> in
                     let (messages, lastRawMessage) = SnodeAPI.parseRawMessagesResponse(rawResponse, from: snode, associatedWith: publicKey)
                     let promises = messages.compactMap { json -> Promise<Void>? in
                         // Use a best attempt approach here; we don't want to fail the entire process if one of the
@@ -51,16 +50,40 @@ public final class BackgroundPoller : NSObject {
                         let job = MessageReceiveJob(data: data, serverHash: json["hash"] as? String, isBackgroundPoll: true)
                         return job.execute()
                     }
-                    let namespace = isClosedGroup ? SnodeAPI.closedGroupNamespace : SnodeAPI.defaultNamespace
                     // Now that the MessageReceiveJob's have been created we can update the `lastMessageHash` value
-                    SnodeAPI.updateLastMessageHashValueIfPossible(for: snode, namespace: namespace, associatedWith: publicKey, from: lastRawMessage)
+                    SnodeAPI.updateLastMessageHashValueIfPossible(for: snode, namespace: SnodeAPI.defaultNamespace, associatedWith: publicKey, from: lastRawMessage)
                     
                     return when(fulfilled: promises) // The promise returned by MessageReceiveJob never rejects
                 }
-                getMessagesPromises.append(promise)
+            }
-                
+        }
-                if isClosedGroup && SnodeAPI.duringHardforkTransition {
+    }
-                    let promise1 = SnodeAPI.getRawClosedGroupMessagesFromDefaultNamespace(from: snode, associatedWith: publicKey).then(on: DispatchQueue.main) { rawResponse -> Promise<Void> in
+    
+    private static func getClosedGroupMessages(for publicKey: String) -> Promise<Void> {
+        return SnodeAPI.getSwarm(for: publicKey).then(on: DispatchQueue.main) { swarm -> Promise<Void> in
+            guard let snode = swarm.randomElement() else { throw SnodeAPI.Error.generic }
+            return attempt(maxRetryCount: 4, recoveringOn: DispatchQueue.main) {
+                var promises: [Promise<Void>] = []
+                if SnodeAPI.hardfork <= 19, SnodeAPI.softfork == 0 {
+                    let promise = SnodeAPI.getRawClosedGroupMessagesFromDefaultNamespace(from: snode, associatedWith: publicKey).then(on: DispatchQueue.main) { rawResponse -> Promise<Void> in
+                        let (messages, lastRawMessage) = SnodeAPI.parseRawMessagesResponse(rawResponse, from: snode, associatedWith: publicKey)
+                        let promises = messages.compactMap { json -> Promise<Void>? in
+                            // Use a best attempt approach here; we don't want to fail the entire process if one of the
+                            // messages failed to parse.
+                            guard let envelope = SNProtoEnvelope.from(json),
+                                let data = try? envelope.serializedData() else { return nil }
+                            let job = MessageReceiveJob(data: data, serverHash: json["hash"] as? String, isBackgroundPoll: true)
+                            return job.execute()
+                        }
+                        // Now that the MessageReceiveJob's have been created we can update the `lastMessageHash` value
+                        SnodeAPI.updateLastMessageHashValueIfPossible(for: snode, namespace: SnodeAPI.defaultNamespace, associatedWith: publicKey, from: lastRawMessage)
+                        
+                        return when(fulfilled: promises) // The promise returned by MessageReceiveJob never rejects
+                    }
+                    promises.append(promise)
+                }
+                if SnodeAPI.hardfork >= 19 && SnodeAPI.softfork >= 0 {
+                    let promise = SnodeAPI.getRawMessages(from: snode, associatedWith: publicKey, authenticated: false).then(on: DispatchQueue.main) { rawResponse -> Promise<Void> in
                         let (messages, lastRawMessage) = SnodeAPI.parseRawMessagesResponse(rawResponse, from: snode, associatedWith: publicKey)
                         let promises = messages.compactMap { json -> Promise<Void>? in
                             // Use a best attempt approach here; we don't want to fail the entire process if one of the
@@ -75,10 +98,9 @@ public final class BackgroundPoller : NSObject {
                         
                         return when(fulfilled: promises) // The promise returned by MessageReceiveJob never rejects
                     }
-                    getMessagesPromises.append(promise1)
+                    promises.append(promise)
                 }
-                
+                return when(resolved: promises).map { _ in }
-                return when(resolved: getMessagesPromises).map{ _ in }
             }
         }
     }

SessionMessagingKit/Sending & Receiving/Pollers/ClosedGroupPoller.swift

@@ -88,8 +88,12 @@ public final class ClosedGroupPoller : NSObject {
             timer.invalidate()
             Threading.pollerQueue.async {
                 var promises: [Promise<Void>] = []
-                if let promise = self?.poll(groupPublicKey) { promises.append(promise) }
+                if SnodeAPI.hardfork <= 19, SnodeAPI.softfork == 0, let promise = self?.poll(groupPublicKey, defaultInbox: true) {
-                if SnodeAPI.duringHardforkTransition, let promise = self?.poll(groupPublicKey, defaultInbox: true) { promises.append(promise) }
+                    promises.append(promise)
+                }
+                if SnodeAPI.hardfork >= 19, SnodeAPI.softfork >= 0,let promise = self?.poll(groupPublicKey) {
+                    promises.append(promise)
+                }
                 when(resolved: promises).done(on: Threading.pollerQueue) { _ in
                     self?.pollRecursively(groupPublicKey)
                 }.catch(on: Threading.pollerQueue) { error in

SessionSnodeKit/SnodeAPI.swift

@@ -29,9 +29,8 @@ public final class SnodeAPI : NSObject {
     public static let configNamespace = 5
     
     // MARK: Hardfork version
-    private static var hardfork = UserDefaults.standard[.hardfork]
+    public static var hardfork = UserDefaults.standard[.hardfork]
-    private static var softfork = UserDefaults.standard[.softfork]
+    public static var softfork = UserDefaults.standard[.softfork]
-    public static var duringHardforkTransition: Bool { hardfork == 19 && softfork == 0 }
 
     // MARK: Settings
     private static let maxRetryCount: UInt = 8