Add new Push v3 notification types (#3708)

* Add new Push v3 notification types

* Update CHANGELOG.md

* Make it more flexible

* Remove isKnown logic

Author: nuno-vieira

CHANGELOG.md

@@ -5,6 +5,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ## StreamChat
 ### ✅ Added
+- Add support for Push v3 notification types [#3708](https://github.com/GetStream/stream-chat-swift/pull/3708)
 - Add `ChatMessageController.partialUpdateMessage()` [#3531](https://github.com/GetStream/stream-chat-swift/pull/3531)
 - Add Location Sharing Support [#3531](https://github.com/GetStream/stream-chat-swift/pull/3531)
   - Add `ChatMessage.sharedLocation`

DemoAppPush/NotificationService.swift

@@ -96,7 +96,7 @@ class NotificationService: UNNotificationServiceExtension {
         let chatNotification = chatHandler.handleNotification { chatContent in
             switch chatContent {
             case let .message(messageNotification):
-                if messageNotification.type == .reminderDue {
+                if messageNotification.type == .messageReminderDue || messageNotification.type == .reactionNew {
                     return contentHandler(content)
                 }
 

Sources/StreamChat/APIClient/ChatRemoteNotificationHandler.swift

@@ -22,24 +22,22 @@ public class MessageNotificationContent {
     }
 }
 
+/// The type of push notifications supported by the Stream Chat SDK.
 public struct PushNotificationType: Equatable {
     public var name: String
 
-    init(name: String) {
-        self.name = name
+    init(eventType: EventType) {
+        name = eventType.rawValue
     }
 
-    init?(eventType: EventType) {
-        switch eventType {
-        case .messageNew, .messageReminderDue:
-            self.init(name: eventType.rawValue)
-        default:
-            return nil
-        }
-    }
-
-    public static var newMessage: PushNotificationType = .init(name: EventType.messageNew.rawValue)
-    public static var reminderDue: PushNotificationType = .init(name: EventType.messageReminderDue.rawValue)
+    /// When the push notification is for a new message.
+    public static var messageNew: PushNotificationType = .init(eventType: .messageNew)
+    /// When the push notification is for a message reminder that is overdue.
+    public static var messageReminderDue: PushNotificationType = .init(eventType: .messageReminderDue)
+    /// When the push notification is for a message that has been updated.
+    public static var messageUpdated: PushNotificationType = .init(eventType: .messageUpdated)
+    /// When the push notification is for a new reaction.
+    public static var reactionNew: PushNotificationType = .init(eventType: .reactionNew)
 }
 
 public class UnknownNotificationContent {
@@ -120,24 +118,23 @@ public class ChatRemoteNotificationHandler {
             return completion(.unknown(UnknownNotificationContent(content: content)))
         }
 
-        guard let type = dict["type"] else {
-            return completion(.unknown(UnknownNotificationContent(content: content)))
-        }
-
-        guard let pushType = PushNotificationType(eventType: EventType(rawValue: type)) else {
-            return completion(.unknown(UnknownNotificationContent(content: content)))
-        }
-
         guard let cid = dict["cid"], let id = dict["id"], let channelId = try? ChannelId(cid: cid) else {
             completion(.unknown(UnknownNotificationContent(content: content)))
             return
         }
 
+        guard let type = dict["type"] else {
+            return completion(.unknown(UnknownNotificationContent(content: content)))
+        }
+        
+        let pushType = PushNotificationType(eventType: EventType(rawValue: type))
+
         getContent(cid: channelId, messageId: id) { message, channel in
             guard let message = message else {
                 completion(.unknown(UnknownNotificationContent(content: self.content)))
                 return
             }
+            let pushType = PushNotificationType(eventType: EventType(rawValue: type))
             let content = MessageNotificationContent(
                 message: message,
                 channel: channel,

Tests/StreamChatTests/APIClient/ChatRemoteNotificationHandler_Tests.swift

@@ -246,13 +246,55 @@ final class ChatRemoteNotificationHandler_Tests: XCTestCase {
         XCTAssertEqual(false, channelRepository.getChannel_store)
         XCTAssertEqual(false, messageRepository.getMessage_store)
     }
-    
+
+    func test_handleNotification_supportedPushNotificationTypes() throws {
+        let cid = ChannelId.unique
+        let expectation = XCTestExpectation()
+        let expectedChannel = ChatChannel.mock(cid: cid)
+        let expectedMessage = ChatMessage.mock()
+        channelRepository.getChannel_result = .success(expectedChannel)
+        messageRepository.getMessageResult = .success(expectedMessage)
+
+        let notificationTypes: [String: PushNotificationType] = [
+            "message.new": .messageNew,
+            "reaction.new": .reactionNew,
+            "notification.reminder_due": .messageReminderDue,
+            "message.updated": .messageUpdated
+        ]
+
+        var assertions: [Bool] = []
+        expectation.expectedFulfillmentCount = notificationTypes.count
+
+        for notificationType in notificationTypes {
+            let content = createNotificationContent(
+                cid: expectedChannel.cid,
+                messageId: expectedMessage.id,
+                type: notificationType.key
+            )
+            let handler = ChatRemoteNotificationHandler(client: clientWithOffline, content: content)
+            let canHandle = handler.handleNotification { pushNotificationContent in
+                switch pushNotificationContent {
+                case .message(let messageNotificationContent):
+                    assertions.append(messageNotificationContent.type == notificationType.value)
+                case .unknown(let unknownNotificationContent):
+                    XCTFail(unknownNotificationContent.content.debugDescription)
+                }
+                expectation.fulfill()
+            }
+
+            XCTAssertEqual(true, canHandle)
+        }
+
+        wait(for: [expectation], timeout: defaultTimeout)
+        XCTAssertEqual(assertions, Array(repeatElement(true, count: notificationTypes.count)))
+    }
+
     // MARK: -
 
-    func createNotificationContent(cid: ChannelId, messageId: MessageId) -> UNNotificationContent {
+    func createNotificationContent(cid: ChannelId, messageId: MessageId, type: String = "message.new") -> UNNotificationContent {
         let content = UNMutableNotificationContent()
         let payload: [String: String] = [
-            "type": "message.new",
+            "type": type,
             "cid": cid.rawValue,
             "id": messageId
         ]