Merge pull request #285 from ably/ECO-5241-part2

[ECO-5241] Finish Ephemeral Typing

Author: umair-ably

Example/AblyChatExample/Mocks/MockClients.swift

@@ -230,16 +230,17 @@ class MockTyping: Typing {
     let clientID: String
     let roomID: String
 
-    private let mockSubscriptions = MockSubscriptionStorage<TypingEvent>()
+    private let mockSubscriptions = MockSubscriptionStorage<TypingSetEvent>()
 
     init(clientID: String, roomID: String) {
         self.clientID = clientID
         self.roomID = roomID
     }
 
-    private func createSubscription() -> MockSubscription<TypingEvent> {
+    private func createSubscription() -> MockSubscription<TypingSetEvent> {
         mockSubscriptions.create(randomElement: {
-            TypingEvent(
+            TypingSetEvent(
+                type: .setChanged,
                 currentlyTyping: [
                     MockStrings.names.randomElement()!,
                     MockStrings.names.randomElement()!,
@@ -249,7 +250,7 @@ class MockTyping: Typing {
         }, interval: 2)
     }
 
-    func subscribe(bufferingPolicy _: BufferingPolicy) -> Subscription<TypingEvent> {
+    func subscribe(bufferingPolicy _: BufferingPolicy) -> Subscription<TypingSetEvent> {
         .init(mockAsyncSequence: createSubscription())
     }
 
@@ -258,11 +259,23 @@ class MockTyping: Typing {
     }
 
     func keystroke() async throws(ARTErrorInfo) {
-        mockSubscriptions.emit(TypingEvent(currentlyTyping: [clientID], change: .init(clientId: clientID, type: .started)))
+        mockSubscriptions.emit(
+            TypingSetEvent(
+                type: .setChanged,
+                currentlyTyping: [clientID],
+                change: .init(clientId: clientID, type: .started)
+            )
+        )
     }
 
     func stop() async throws(ARTErrorInfo) {
-        mockSubscriptions.emit(TypingEvent(currentlyTyping: [], change: .init(clientId: clientID, type: .stopped)))
+        mockSubscriptions.emit(
+            TypingSetEvent(
+                type: .setChanged,
+                currentlyTyping: [],
+                change: .init(clientId: clientID, type: .stopped)
+            )
+        )
     }
 }
 

Sources/AblyChat/DefaultTyping.swift

@@ -8,7 +8,7 @@ internal final class DefaultTyping: Typing {
     }
 
     // (CHA-T6) Users may subscribe to typing events – updates to a set of clientIDs that are typing. This operation, like all subscription operations, has no side-effects in relation to room lifecycle.
-    internal func subscribe(bufferingPolicy: BufferingPolicy) -> Subscription<TypingEvent> {
+    internal func subscribe(bufferingPolicy: BufferingPolicy) -> Subscription<TypingSetEvent> {
         implementation.subscribe(bufferingPolicy: bufferingPolicy)
     }
 
@@ -70,11 +70,11 @@ internal final class DefaultTyping: Typing {
             )
         }
 
-        internal func subscribe(bufferingPolicy: BufferingPolicy) -> Subscription<TypingEvent> {
+        internal func subscribe(bufferingPolicy: BufferingPolicy) -> Subscription<TypingSetEvent> {
             // (CHA-T6a) Users may provide a listener to subscribe to typing event V2 in a chat room.
-            let subscription = Subscription<TypingEvent>(bufferingPolicy: bufferingPolicy)
+            let subscription = Subscription<TypingSetEvent>(bufferingPolicy: bufferingPolicy)
 
-            let startedEventListener = channel.subscribe(TypingEvents.started.rawValue) { [weak self] message in
+            let startedEventListener = channel.subscribe(TypingEventType.started.rawValue) { [weak self] message in
                 guard let self, let messageClientID = message.clientId else {
                     return
                 }
@@ -91,21 +91,26 @@ internal final class DefaultTyping: Typing {
                         }
                         // (CHA-T13b3) (2/2) If the (CHA-T13b1) timeout expires, the client shall remove the clientId from the typing set and emit a synthetic typing stop event for the given client.
                         subscription.emit(
-                            TypingEvent(currentlyTyping: typingTimerManager.currentlyTypingClientIDs(), change: .init(clientId: messageClientID, type: .stopped))
+                            TypingSetEvent(
+                                type: .setChanged,
+                                currentlyTyping: typingTimerManager.currentlyTypingClientIDs(),
+                                change: .init(clientId: messageClientID, type: .stopped)
+                            )
                         )
                     }
 
                     // (CHA-T13) When a typing event (typing.start or typing.stop) is received from the realtime client, the Chat client shall emit appropriate events to the user.
                     subscription.emit(
-                        TypingEvent(
+                        TypingSetEvent(
+                            type: .setChanged,
                             currentlyTyping: typingTimerManager.currentlyTypingClientIDs(),
                             change: .init(clientId: messageClientID, type: .started)
                         )
                     )
                 }
             }
 
-            let stoppedEventListener = channel.subscribe(TypingEvents.stopped.rawValue) { [weak self] message in
+            let stoppedEventListener = channel.subscribe(TypingEventType.stopped.rawValue) { [weak self] message in
                 guard let self, let messageClientID = message.clientId else {
                     return
                 }
@@ -119,7 +124,8 @@ internal final class DefaultTyping: Typing {
 
                     // (CHA-T13) When a typing event (typing.start or typing.stop) is received from the realtime client, the Chat client shall emit appropriate events to the user.
                     subscription.emit(
-                        TypingEvent(
+                        TypingSetEvent(
+                            type: .setChanged,
                             currentlyTyping: typingTimerManager.currentlyTypingClientIDs(),
                             change: .init(clientId: messageClientID, type: .stopped)
                         )
@@ -171,7 +177,7 @@ internal final class DefaultTyping: Typing {
             // (CHA-T4a3) The client shall publish an ephemeral message to the channel with the name field set to typing.started, the format of which is detailed here.
             // (CHA-T4a5) The client must wait for the publish to succeed or fail before returning the result to the caller. If the publish fails, the client must throw an ErrorInfo.
             try await channel.publish(
-                TypingEvents.started.rawValue,
+                TypingEventType.started.rawValue,
                 data: nil,
                 extras: ["ephemeral": true]
             )
@@ -191,7 +197,7 @@ internal final class DefaultTyping: Typing {
                         logger.log(message: "Stopping typing indicator for client: \(clientID)", level: .debug)
                         // (CHA-T5d) The client shall publish an ephemeral message to the channel with the name field set to typing.stopped, the format of which is detailed here.
                         try await channel.publish(
-                            TypingEvents.stopped.rawValue,
+                            TypingEventType.stopped.rawValue,
                             data: nil,
                             extras: ["ephemeral": true]
                         )

Sources/AblyChat/Events.swift

@@ -43,7 +43,13 @@ internal enum OccupancyEvents: String {
     case meta = "[meta]occupancy"
 }
 
-public enum TypingEvents: String, Sendable {
+/// Enum representing the typing event types.
+public enum TypingEventType: String, Sendable {
     case started = "typing.started"
     case stopped = "typing.stopped"
 }
+
+/// Enum representing the typing set event types.
+public enum TypingSetEventType: String, Sendable {
+    case setChanged = "typing.set.changed"
+}

Sources/AblyChat/Typing.swift

@@ -16,12 +16,12 @@ public protocol Typing: AnyObject, Sendable {
      *
      * - Returns: A subscription `AsyncSequence` that can be used to iterate through ``TypingEvent`` events.
      */
-    func subscribe(bufferingPolicy: BufferingPolicy) -> Subscription<TypingEvent>
+    func subscribe(bufferingPolicy: BufferingPolicy) -> Subscription<TypingSetEvent>
 
     /// Same as calling ``subscribe(bufferingPolicy:)`` with ``BufferingPolicy/unbounded``.
     ///
     /// The `Typing` protocol provides a default implementation of this method.
-    func subscribe() -> Subscription<TypingEvent>
+    func subscribe() -> Subscription<TypingSetEvent>
 
     /**
      * Get the current typers, a set of clientIds.
@@ -53,15 +53,17 @@ public protocol Typing: AnyObject, Sendable {
 }
 
 public extension Typing {
-    func subscribe() -> Subscription<TypingEvent> {
+    func subscribe() -> Subscription<TypingSetEvent> {
         subscribe(bufferingPolicy: .unbounded)
     }
 }
 
 /**
  * Represents a typing event.
  */
-public struct TypingEvent: Sendable {
+public struct TypingSetEvent: Sendable {
+    public var type: TypingSetEventType
+
     /**
      * Get a set of clientIds that are currently typing.
      */
@@ -72,16 +74,17 @@ public struct TypingEvent: Sendable {
       */
     public var change: Change
 
-    public init(currentlyTyping: Set<String>, change: Change) {
+    public init(type: TypingSetEventType, currentlyTyping: Set<String>, change: Change) {
+        self.type = type
         self.currentlyTyping = currentlyTyping
         self.change = change
     }
 
     public struct Change: Sendable {
         public var clientId: String
-        public var type: TypingEvents
+        public var type: TypingEventType
 
-        public init(clientId: String, type: TypingEvents) {
+        public init(clientId: String, type: TypingEventType) {
             self.clientId = clientId
             self.type = type
         }