typing timer manager: method renames and documentation

Author: lawrence-forooghian

Sources/AblyChat/DefaultTyping.swift

@@ -107,7 +107,7 @@ internal final class DefaultTyping: Typing {
 
                 logger.log(message: "Received started typing message: \(message)", level: .debug)
 
-                if !typingTimerManager.isTypingTimerActive(for: messageClientID) {
+                if !typingTimerManager.isCurrentlyTyping(clientID: messageClientID) {
                     // (CHA-T13b1) If the event represents a new client typing, then the chat client shall add the typer to the typing set and a emit the updated set to any subscribers. It shall also begin a timeout that is the sum of the CHA-T10 heartbeat interval and the CHA-T10a graсe period.
                     typingTimerManager.startTypingTimer(
                         for: messageClientID
@@ -117,14 +117,14 @@ 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.currentlyTypingClients(), change: .init(clientId: messageClientID, type: .stopped))
+                            TypingEvent(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(
-                            currentlyTyping: typingTimerManager.currentlyTypingClients(),
+                            currentlyTyping: typingTimerManager.currentlyTypingClientIDs(),
                             change: .init(clientId: messageClientID, type: .started)
                         )
                     )
@@ -139,14 +139,14 @@ internal final class DefaultTyping: Typing {
                 logger.log(message: "Received stopped typing message: \(message)", level: .debug)
 
                 // (CHA-T13b5) If the event represents that a client has stopped typing, but the clientId for that client is not present in the typing set, then the event is ignored.
-                if typingTimerManager.isTypingTimerActive(for: messageClientID) {
+                if typingTimerManager.isCurrentlyTyping(clientID: messageClientID) {
                     // (CHA-T13b4) If the event represents a client that has stopped typing, then the chat client shall remove the clientId from the typing set and emit the updated set to any subscribers. It shall also cancel the (CHA-T13b1) timeout for the typing client.
                     typingTimerManager.cancelTypingTimer(for: messageClientID)
 
                     // (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(
-                            currentlyTyping: typingTimerManager.currentlyTypingClients(),
+                            currentlyTyping: typingTimerManager.currentlyTypingClientIDs(),
                             change: .init(clientId: messageClientID, type: .stopped)
                         )
                     )
@@ -168,7 +168,7 @@ internal final class DefaultTyping: Typing {
         }
 
         internal func get() async throws(ARTErrorInfo) -> Set<String> {
-            typingTimerManager.currentlyTypingClients()
+            typingTimerManager.currentlyTypingClientIDs()
         }
 
         internal func keystroke() async throws(ARTErrorInfo) {
@@ -204,7 +204,7 @@ internal final class DefaultTyping: Typing {
         internal func stop() async throws(ARTErrorInfo) {
             do throws {
                 logger.log(message: "Stopping typing indicator for client: \(clientID)", level: .debug)
-                if typingTimerManager.isTypingTimerActive(for: clientID) {
+                if typingTimerManager.isCurrentlyTyping(clientID: clientID) {
                     try await keyboardOperationQueue.enqueue { [weak self] () throws(InternalError) in
                         guard let self else {
                             return

Sources/AblyChat/TypingTimerManager.swift

@@ -1,7 +1,7 @@
 import Foundation
 
 @MainActor
-internal final class TypingTimerManager {
+internal final class TypingTimerManager: TypingTimerManagerProtocol {
     private let heartbeatThrottle: TimeInterval
     private let gracePeriod: TimeInterval
     private let logger: InternalLogger
@@ -75,13 +75,13 @@ internal final class TypingTimerManager {
         whoIsTypingTimers[clientID] = nil
     }
 
-    // TODO: add documentation once we see how these are being used
-    internal func isTypingTimerActive(for clientID: String) -> Bool {
-        currentlyTypingClients().contains(clientID)
+    /// Returns whether this client is present in the set of users who we consider to currently be typing. This is what should be used for the CHA-T13b1 "represents a new client typing" and CHA-T13b5 "is not present in the typing set" checks.
+    internal func isCurrentlyTyping(clientID: String) -> Bool {
+        currentlyTypingClientIDs().contains(clientID)
     }
 
-    // TODO: add documentation once we see how these are being used
-    internal func currentlyTypingClients() -> Set<String> {
+    /// Returns the set of client IDs that we consider to currently be typing (also referred to in the spec as the "typing set").
+    internal func currentlyTypingClientIDs() -> Set<String> {
         Set(whoIsTypingTimers.keys)
     }
 }
@@ -97,17 +97,15 @@ internal protocol TypingTimerManagerProtocol {
 
     /// Starts a CHA-T13b1 "is this person typing" timer, thus adding this clientID to the typing set.
     func startTypingTimer(for clientID: String, handler: (@MainActor () -> Void)?)
-    /// Per CHA-T13b4, cancels the CHA-T13b1 "is this person typing", thus removing this clientID from the typing set.
+    /// Per CHA-T13b4, cancels the CHA-T13b1 "is this person typing" timer, thus removing this clientID from the typing set.
     func cancelTypingTimer(for clientID: String)
 
-    // TODO: document
-    func isTypingTimerActive(for clientID: String) -> Bool
-    func currentlyTypingClients() -> Set<String>
+    /// Returns whether this client is present in the set of users who we consider to currently be typing. This is what should be used for the CHA-T13b1 "represents a new client typing" and CHA-T13b5 "is not present in the typing set" checks.
+    func isCurrentlyTyping(clientID: String) -> Bool
+    /// Returns the set of client IDs that we consider to currently be typing (also referred to in the spec as the "typing set").
+    func currentlyTypingClientIDs() -> Set<String>
 }
 
-// Extend the actual TypingTimerManager to conform to our protocol
-extension TypingTimerManager: TypingTimerManagerProtocol {}
-
 internal protocol ClockProvider {
     func now() -> Date
 }

Tests/AblyChatTests/Mocks/MockTypingTimerManager.swift

@@ -45,11 +45,11 @@
          print("MockTypingTimerManager: Cancelled timer for \(clientID), isSelf: \(isSelf)")
      }
 
-     func isTypingTimerActive(for clientID: String) -> Bool {
+     func isCurrentlyTyping(clientID: String) {
          activeTimers.contains(clientID)
      }
 
-     func currentlyTypingClients() -> Set<String> {
+     func currentlyTypingClientIDs() -> Set<String> {
          typingClients
      }
  }

Tests/AblyChatTests/TypingTimerManagerTests.swift

@@ -56,11 +56,11 @@ final class TypingTimerManagerTests {
         let mockClock = MockClock()
         let timerManager = createTypingTimerManager(with: mockClock)
 
-        #expect(!timerManager.isTypingTimerActive(for: "client1"))
+        #expect(!timerManager.isCurrentlyTyping(clientID: "client1"))
 
         timerManager.startTypingTimer(for: "client1")
-        #expect(timerManager.isTypingTimerActive(for: "client1"))
-        #expect(timerManager.currentlyTypingClients() == ["client1"])
+        #expect(timerManager.isCurrentlyTyping(clientID: "client1"))
+        #expect(timerManager.currentlyTypingClientIDs() == ["client1"])
     }
 
     // @specOneOf(2/2) CHA-T13b1 - Tests the currentlyTypingClients method returns correct set of typing clients.
@@ -74,11 +74,11 @@ final class TypingTimerManagerTests {
         timerManager.startTypingTimer(for: "client2")
         timerManager.startTypingTimer(for: "client3")
 
-        #expect(timerManager.currentlyTypingClients() == ["client1", "client2", "client3"])
+        #expect(timerManager.currentlyTypingClientIDs() == ["client1", "client2", "client3"])
 
         timerManager.cancelTypingTimer(for: "client2")
 
-        #expect(timerManager.currentlyTypingClients() == ["client1", "client3"])
+        #expect(timerManager.currentlyTypingClientIDs() == ["client1", "client3"])
     }
 
     // @spec CHA-T13b3 - Tests timeout expiration removing client from typing set and calling the onCancelled handler.
@@ -93,16 +93,16 @@ final class TypingTimerManagerTests {
             handlerCalled = true
         }
 
-        #expect(timerManager.isTypingTimerActive(for: "client1"))
+        #expect(timerManager.isCurrentlyTyping(clientID: "client1"))
 
         // Advance time to trigger timer expiration (heartbeatThrottle + gracePeriod)
         mockClock.advance(by: 1.6)
 
         await Task.yield()
 
         #expect(handlerCalled)
-        #expect(!timerManager.isTypingTimerActive(for: "client1"))
-        #expect(timerManager.currentlyTypingClients().isEmpty)
+        #expect(!timerManager.isCurrentlyTyping(clientID: "client1"))
+        #expect(timerManager.currentlyTypingClientIDs().isEmpty)
     }
 
     // @spec CHA-T13b2 - Tests that each additional typing heartbeat resets the timeout
@@ -131,15 +131,15 @@ final class TypingTimerManagerTests {
         await Task.yield()
 
         // Client should still be typing because we reset the timer
-        #expect(timerManager.isTypingTimerActive(for: "client1"))
+        #expect(timerManager.isCurrentlyTyping(clientID: "client1"))
         #expect(!handlerCalled)
 
         // Now advance enough to expire the reset timer
         mockClock.advance(by: 1.0)
         await Task.yield()
 
         #expect(handlerCalled)
-        #expect(!timerManager.isTypingTimerActive(for: "client1"))
+        #expect(!timerManager.isCurrentlyTyping(clientID: "client1"))
     }
 
     // @spec CHA-T10a1 - Tests that grace period is correctly applied to prevent flickering
@@ -158,15 +158,15 @@ final class TypingTimerManagerTests {
         mockClock.advance(by: 1.0)
         await Task.yield()
 
-        #expect(timerManager.isTypingTimerActive(for: "client1"))
+        #expect(timerManager.isCurrentlyTyping(clientID: "client1"))
         #expect(!handlerCalled)
 
         // Advance by grace period - now should expire
         mockClock.advance(by: 0.5)
         await Task.yield()
 
         #expect(handlerCalled)
-        #expect(!timerManager.isTypingTimerActive(for: "client1"))
+        #expect(!timerManager.isCurrentlyTyping(clientID: "client1"))
     }
 }