Add timeout support when connecting user

CHANGELOG.md

@@ -4,10 +4,19 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 # Upcoming
 
 ## StreamChat
+### ✅ Added
+- Add an option to configure a reconnection timeout [#3303](https://github.com/GetStream/stream-chat-swift/pull/3303)
+### 🐞 Fixed
+- Improve the stability of the reconnection process [#3303](https://github.com/GetStream/stream-chat-swift/pull/3303)
+- Fix invalid token errors considered as recoverable errors [#3303](https://github.com/GetStream/stream-chat-swift/pull/3303)
 ### 🔄 Changed
 - Dropped iOS 12 support [#3285](https://github.com/GetStream/stream-chat-swift/pull/3285)
 - Increase QoS for `Throttler` and `Debouncer` to `utility` [#3295](https://github.com/GetStream/stream-chat-swift/issues/3295)
-- Improve reliability of accessing database models in controller provided completion handlers [#3304](https://github.com/GetStream/stream-chat-swift/issues/3304)
+- Improve reliability of accessing data in controllers' completion handlers [#3304](https://github.com/GetStream/stream-chat-swift/issues/3304)
+
+## StreamChatUI
+### 🐞 Fixed
+- Fix Channel List not hiding error state view when data is available [#3303](https://github.com/GetStream/stream-chat-swift/pull/3303)
 
 ## StreamChatUI
 ### ✅ Added

DemoApp/Screens/AppConfigViewController/AppConfigViewController.swift

@@ -192,6 +192,7 @@ class AppConfigViewController: UITableViewController {
     enum ChatClientConfigOption: String, CaseIterable {
         case isLocalStorageEnabled
         case staysConnectedInBackground
+        case reconnectionTimeout
         case shouldShowShadowedMessages
         case deletedMessagesVisibility
         case isChannelAutomaticFilteringEnabled
@@ -347,6 +348,9 @@ class AppConfigViewController: UITableViewController {
             cell.accessoryView = makeSwitchButton(chatClientConfig.staysConnectedInBackground) { [weak self] newValue in
                 self?.chatClientConfig.staysConnectedInBackground = newValue
             }
+        case .reconnectionTimeout:
+            cell.detailTextLabel?.text = chatClientConfig.reconnectionTimeout.map { "\($0)" } ?? "None"
+            cell.accessoryType = .disclosureIndicator
         case .shouldShowShadowedMessages:
             cell.accessoryView = makeSwitchButton(chatClientConfig.shouldShowShadowedMessages) { [weak self] newValue in
                 self?.chatClientConfig.shouldShowShadowedMessages = newValue
@@ -371,6 +375,8 @@ class AppConfigViewController: UITableViewController {
         switch option {
         case .deletedMessagesVisibility:
             pushDeletedMessagesVisibilitySelectorVC()
+        case .reconnectionTimeout:
+            pushReconnectionTimeoutSelectorVC()
         default:
             break
         }
@@ -581,6 +587,24 @@ class AppConfigViewController: UITableViewController {
         navigationController?.pushViewController(selectorViewController, animated: true)
     }
 
+    private func pushReconnectionTimeoutSelectorVC() {
+        let selectorViewController = OptionsSelectorViewController<TimeInterval?>(
+            options: [nil, 15.0, 30.0, 45.0, 60.0],
+            initialSelectedOptions: [chatClientConfig.reconnectionTimeout],
+            allowsMultipleSelection: false,
+            optionFormatter: { option in
+                option.map { "\($0)" } ?? "None"
+            }
+        )
+        selectorViewController.didChangeSelectedOptions = { [weak self] options in
+            guard let selectedOption = options.first else { return }
+            self?.chatClientConfig.reconnectionTimeout = selectedOption
+            self?.tableView.reloadData()
+        }
+
+        navigationController?.pushViewController(selectorViewController, animated: true)
+    }
+
     private func showTokenDetailsAlert() {
         let alert = UIAlertController(
             title: "Token Refreshing",

DemoApp/Shared/StreamChatWrapper.swift

@@ -22,15 +22,17 @@ final class StreamChatWrapper {
     var client: ChatClient?
 
     // ChatClient config
-    var config: ChatClientConfig = {
-        var config = ChatClientConfig(apiKeyString: apiKeyString)
+    var config: ChatClientConfig {
+        didSet {
+            client = ChatClient(config: config)
+        }
+    }
+
+    private init() {
+        config = ChatClientConfig(apiKeyString: apiKeyString)
         config.shouldShowShadowedMessages = true
         config.applicationGroupIdentifier = applicationGroupIdentifier
         config.urlSessionConfiguration.httpAdditionalHeaders = ["Custom": "Example"]
-        return config
-    }()
-
-    private init() {
         configureUI()
     }
 }

DemoApp/StreamChat/Components/DemoChatChannelListErrorView.swift

@@ -0,0 +1,20 @@
+//
+// Copyright © 2024 Stream.io Inc. All rights reserved.
+//
+
+import StreamChatUI
+import UIKit
+
+class DemoChatChannelListErrorView: ChatChannelListErrorView {
+    override func show() {
+        UIView.animate(withDuration: 0.5) {
+            self.isHidden = false
+        }
+    }
+
+    override func hide() {
+        UIView.animate(withDuration: 0.5) {
+            self.isHidden = true
+        }
+    }
+}

DemoApp/StreamChat/StreamChatWrapper+DemoApp.swift

@@ -61,6 +61,7 @@ extension StreamChatWrapper {
         Components.default.messageActionsVC = DemoChatMessageActionsVC.self
         Components.default.messageLayoutOptionsResolver = DemoChatMessageLayoutOptionsResolver()
         Components.default.reactionsSorting = ReactionSorting.byFirstReactionAt
+        Components.default.channelListErrorView = DemoChatChannelListErrorView.self
 
         // Customize MarkdownFormatter
         let defaultFormatter = DefaultMarkdownFormatter()

Sources/StreamChat/APIClient/RequestDecoder.swift

@@ -58,8 +58,8 @@ struct DefaultRequestDecoder: RequestDecoder {
                 throw ClientError.Unknown("Unknown error. Server response: \(httpResponse).")
             }
 
-            if serverError.isInvalidTokenError {
-                log.info("Request failed because of an experied token.", subsystems: .httpRequests)
+            if serverError.isExpiredTokenError {
+                log.info("Request failed because of an expired token.", subsystems: .httpRequests)
                 throw ClientError.ExpiredToken()
             }
 

Sources/StreamChat/ChatClient+Environment.swift

@@ -103,7 +103,8 @@ extension ChatClient {
             _ extensionLifecycle: NotificationExtensionLifecycle,
             _ backgroundTaskScheduler: BackgroundTaskScheduler?,
             _ internetConnection: InternetConnection,
-            _ keepConnectionAliveInBackground: Bool
+            _ keepConnectionAliveInBackground: Bool,
+            _ reconnectionTimeoutHandler: StreamTimer?
         ) -> ConnectionRecoveryHandler = {
             DefaultConnectionRecoveryHandler(
                 webSocketClient: $0,
@@ -114,7 +115,8 @@ extension ChatClient {
                 internetConnection: $5,
                 reconnectionStrategy: DefaultRetryStrategy(),
                 reconnectionTimerType: DefaultTimer.self,
-                keepConnectionAliveInBackground: $6
+                keepConnectionAliveInBackground: $6,
+                reconnectionTimeoutHandler: $7
             )
         }
 

Sources/StreamChat/ChatClient.swift

@@ -257,7 +257,8 @@ public class ChatClient {
             extensionLifecycle,
             environment.backgroundTaskSchedulerBuilder(),
             environment.internetConnection(eventNotificationCenter, environment.internetMonitor),
-            config.staysConnectedInBackground
+            config.staysConnectedInBackground,
+            config.reconnectionTimeout.map { ScheduledStreamTimer(interval: $0, fireOnStart: false, repeats: false) }
         )
     }
 

Sources/StreamChat/Config/ChatClientConfig.swift

@@ -183,6 +183,10 @@ public struct ChatClientConfig {
     /// It controls how long (in seconds) a network task should wait for additional data to arrive before giving up
     public var timeoutIntervalForRequest: TimeInterval = 30
 
+    /// The maximum time in seconds the SDK will wait until it reconnects successfully, in case it was disconnected by a recoverable error.
+    /// By default there is no timeout, so the SDK will keep trying to connect for an undetermined time.
+    public var reconnectionTimeout: TimeInterval?
+
     /// Enable/Disable local filtering for Channel lists. When enabled,
     /// whenever a new channel is created,/updated the SDK will try to
     /// match the channel list filter automatically.

Sources/StreamChat/Errors/ErrorPayload.swift

@@ -57,7 +57,7 @@ extension ErrorPayload {
 
 extension ClosedRange where Bound == Int {
     /// The error codes for token-related errors. Typically, a refreshed token is required to recover.
-    static let tokenInvalidErrorCodes: Self = StreamErrorCode.expiredToken...StreamErrorCode.invalidTokenSignature
+    static let tokenInvalidErrorCodes: Self = StreamErrorCode.notYetValidToken...StreamErrorCode.invalidTokenSignature
 
     /// The range of HTTP request status codes for client errors.
     static let clientErrorCodes: Self = 400...499

Sources/StreamChat/Repositories/ConnectionRepository.swift

@@ -140,10 +140,8 @@ class ConnectionRepository {
         case let .connected(connectionId: id):
             shouldNotifyConnectionIdWaiters = true
             connectionId = id
-        case let .disconnected(source) where source.serverError?.isInvalidTokenError == true:
-            if source.serverError?.isExpiredTokenError == true {
-                onExpiredToken()
-            }
+        case let .disconnected(source) where source.serverError?.isExpiredTokenError == true:
+            onExpiredToken()
             shouldNotifyConnectionIdWaiters = false
             connectionId = nil
         case .disconnected:

Sources/StreamChat/Utils/StreamTimer/ScheduledStreamTimer.swift

@@ -5,30 +5,37 @@
 import Foundation
 
 public class ScheduledStreamTimer: StreamTimer {
-    let interval: TimeInterval
     var runLoop = RunLoop.current
     var timer: Foundation.Timer?
     public var onChange: (() -> Void)?
 
-    public var isRunning: Bool {
-        timer?.isValid ?? false
-    }
+    let interval: TimeInterval
+    let fireOnStart: Bool
+    let repeats: Bool
 
-    public init(interval: TimeInterval) {
+    public init(interval: TimeInterval, fireOnStart: Bool = true, repeats: Bool = true) {
         self.interval = interval
+        self.fireOnStart = fireOnStart
+        self.repeats = repeats
+    }
+
+    public var isRunning: Bool {
+        timer?.isValid ?? false
     }
 
     public func start() {
         stop()
 
         timer = Foundation.Timer.scheduledTimer(
             withTimeInterval: interval,
-            repeats: true
+            repeats: repeats
         ) { _ in
             self.onChange?()
         }
         runLoop.add(timer!, forMode: .common)
-        timer?.fire()
+        if fireOnStart {
+            timer?.fire()
+        }
     }
 
     public func stop() {

Sources/StreamChat/WebSocketClient/ConnectionStatus.swift

@@ -42,9 +42,7 @@ extension ConnectionStatus {
             self = .disconnecting
 
         case let .disconnected(source):
-            let isWaitingForReconnect = webSocketConnectionState.isAutomaticReconnectionEnabled || source.serverError?
-                .isInvalidTokenError == true
-
+            let isWaitingForReconnect = webSocketConnectionState.isAutomaticReconnectionEnabled
             self = isWaitingForReconnect ? .connecting : .disconnected(error: source.serverError)
         }
     }
@@ -55,10 +53,13 @@ typealias ConnectionId = String
 /// A web socket connection state.
 enum WebSocketConnectionState: Equatable {
     /// Provides additional information about the source of disconnecting.
-    enum DisconnectionSource: Equatable {
+    indirect enum DisconnectionSource: Equatable {
         /// A user initiated web socket disconnecting.
         case userInitiated
 
+        /// The connection timed out while trying to connect.
+        case timeout(from: WebSocketConnectionState)
+
         /// A server initiated web socket disconnecting, an optional error object is provided.
         case serverInitiated(error: ClientError? = nil)
 
@@ -128,8 +129,9 @@ enum WebSocketConnectionState: Equatable {
                     return false
                 }
 
-                if serverInitiatedError.isClientError {
-                    // Don't reconnect on client side errors
+                if serverInitiatedError.isClientError && !serverInitiatedError.isExpiredTokenError {
+                    // Don't reconnect on client side errors unless it is an expired token
+                    // Expired tokens return 401, so it is considered client error.
                     return false
                 }
             }
@@ -141,6 +143,8 @@ enum WebSocketConnectionState: Equatable {
             return true
         case .userInitiated:
             return false
+        case .timeout:
+            return false
         }
     }
 }

Sources/StreamChat/WebSocketClient/WebSocketClient.swift

@@ -142,6 +142,17 @@ class WebSocketClient {
             eventsBatcher.processImmediately(completion: completion)
         }
     }
+
+    func timeout() {
+        let previousState = connectionState
+        connectionState = .disconnected(source: .timeout(from: previousState))
+        engineQueue.async { [engine, eventsBatcher] in
+            engine?.disconnect()
+
+            eventsBatcher.processImmediately {}
+        }
+        log.error("Connection timed out. `\(connectionState)", subsystems: .webSocket)
+    }
 }
 
 protocol ConnectionStateDelegate: AnyObject {