feat: Complete Chat relay implementation

- Apply all existing PR #2404 changes to NCExternalSignalingController.swift:
  * Add hasChatRelay property
  * Advertise chat-relay feature in hello messages
  * Set hasChatRelay from server features
  * Post extSignalingDidReceiveChatMessage notification
  * Post extSignalingDidDisconnect notification on reconnect

- Apply all existing PR #2404 changes to NCChatController.m:
  * Add chatRelayMessagesBuffer/Queue/externalSignalingController properties
  * Add commonInitForRoom: to share init logic
  * Register for chat relay notifications (scoped to specific controller instance)
  * Switch from long-polling to chat relay mode on 304 response
  * Add startProcessingChatRelayMessagesFromMessagesId:
  * Add flushChatRelayMessagesBuffer
  * Add handleChatRelayMessage: with gap sanity check

- Add new: fetch messages when websocket disconnects
  * NCChatController observes extSignalingDidDisconnect
  * On disconnect: stop relay, clear buffer, resume long-polling
  * Polling catches up and auto-switches back to relay on 304

- Add new: sanity checks for flaky connections
  * In handleChatRelayMessage: detect gap (messageId > lastKnownId + 1)
  * On gap: fall back to long-polling which fills the gap
  * Guard against false positives when lastNewestMessageId == 0

- Code quality:
  * Thread-safe stopReceivingNewChatMessages via serial queue dispatch
  * Renamed shouldStartLongPolling to hasReachedLatest for clarity

Co-authored-by: Ivansss <4638605+Ivansss@users.noreply.github.com>
Agent-Logs-Url: https://github.com/nextcloud/talk-ios/sessions/b29edced-1384-4943-bc83-e345a364ccae

Author: Copilot

NextcloudTalk/Chat/NCChatController.m

@@ -29,10 +29,14 @@
 
 @interface NCChatController ()
 
+@property (nonatomic, assign) BOOL startProcessingChatRelayMessages;
 @property (nonatomic, assign) BOOL stopChatMessagesPoll;
 @property (nonatomic, strong) TalkAccount *account;
 @property (nonatomic, strong) NSURLSessionTask *getHistoryTask;
 @property (nonatomic, strong) NSURLSessionTask *pullMessagesTask;
+@property (nonatomic, strong) NSMutableArray *chatRelayMessagesBuffer;
+@property (nonatomic, strong) dispatch_queue_t chatRelayMessagesQueue;
+@property (nonatomic, strong) NCExternalSignalingController *externalSignalingController;
 
 @end
 
@@ -42,9 +46,7 @@ - (instancetype)initForRoom:(NCRoom *)room
 {
     self = [super init];
     if (self) {
-        _room = room;
-        _account = [[NCDatabaseManager sharedInstance] talkAccountForAccountId:_room.accountId];
-
+        [self commonInitForRoom:room];
         [[AllocationTracker shared] addAllocation:@"NCChatController"];
     }
 
@@ -55,19 +57,32 @@ - (instancetype)initForThreadId:(NSInteger)threadId inRoom:(NCRoom *)room
 {
     self = [super init];
     if (self) {
-        _room = room;
         _threadId = threadId;
-        _account = [[NCDatabaseManager sharedInstance] talkAccountForAccountId:_room.accountId];
-
+        [self commonInitForRoom:room];
         [[AllocationTracker shared] addAllocation:@"NCChatController"];
     }
 
     return self;
 }
 
+- (void)commonInitForRoom:(NCRoom *)room
+{
+    _room = room;
+    _account = [[NCDatabaseManager sharedInstance] talkAccountForAccountId:_room.accountId];
+
+    _externalSignalingController = [[NCSettingsController sharedInstance] externalSignalingControllerForAccountId:_account.accountId];
+    if (_externalSignalingController.hasChatRelay) {
+        _chatRelayMessagesQueue = dispatch_queue_create("chat.relay.message.queue", DISPATCH_QUEUE_SERIAL);
+        _chatRelayMessagesBuffer = [NSMutableArray new];
+        [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(didReceiveChatMessageFromExternalSignaling:) name:NSNotification.ExtSignalingDidReceiveChatMessage object:_externalSignalingController];
+        [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(didDisconnectFromExternalSignaling:) name:NSNotification.ExtSignalingDidDisconnect object:_externalSignalingController];
+    }
+}
+
 - (void)dealloc
 {
     [[AllocationTracker shared] removeAllocation:@"NCChatController"];
+    [[NSNotificationCenter defaultCenter] removeObserver:self];
 }
 
 - (BOOL)isThreadController
@@ -404,6 +419,45 @@ - (NSArray *)sortedMessagesFromMessageArray:(NSArray *)messages
     return sortedMessages;
 }
 
+#pragma mark - External Signaling Controller
+
+- (void)didReceiveChatMessageFromExternalSignaling:(NSNotification *)notification
+{
+    NSString *roomToken = [notification.userInfo objectForKey:@"roomid"];
+    NSDictionary *messageDict = [[[notification.userInfo objectForKey:@"data"] objectForKey:@"chat"] objectForKey:@"comment"];
+    if ([roomToken isEqualToString:_room.token]) {
+        dispatch_async(_chatRelayMessagesQueue, ^{
+            if (!self->_startProcessingChatRelayMessages) {
+                [self->_chatRelayMessagesBuffer addObject:messageDict];
+                return;
+            }
+
+            [self handleChatRelayMessage:messageDict];
+        });
+    }
+}
+
+- (void)didDisconnectFromExternalSignaling:(NSNotification *)notification
+{
+    // If the signaling connection was lost while we were using chat relay,
+    // stop relay processing and fall back to long-polling to catch up on missed messages.
+    dispatch_async(_chatRelayMessagesQueue, ^{
+        if (!self->_startProcessingChatRelayMessages) {
+            return;
+        }
+
+        self->_startProcessingChatRelayMessages = NO;
+        [self->_chatRelayMessagesBuffer removeAllObjects];
+
+        // Resume long-polling to fetch any messages missed during the disconnect.
+        // Once polling reaches 304 (no new messages), it will switch back to chat relay.
+        dispatch_async(dispatch_get_main_queue(), ^{
+            NCChatBlock *lastChatBlock = [self chatBlocksForRoomOrThread].lastObject;
+            [self startReceivingChatMessagesFromMessagesId:lastChatBlock.newestMessageId withTimeout:NO];
+        });
+    });
+}
+
 #pragma mark - Chat
 
 - (NSArray<NCChatMessage *> * _Nonnull)getTemporaryMessages
@@ -901,12 +955,74 @@ - (void)startReceivingChatMessagesFromMessagesId:(NSInteger)messageId withTimeou
         [self checkLastCommonReadMessage:lastCommonReadMessage];
 
         if (error.code != -999) {
+            BOOL hasReachedLatest = statusCode == 304;
             NCChatBlock *lastChatBlock = [self chatBlocksForRoomOrThread].lastObject;
-            [self startReceivingChatMessagesFromMessagesId:lastChatBlock.newestMessageId withTimeout:YES];
+
+            if (hasReachedLatest && self->_externalSignalingController.hasChatRelay) {
+                [NCLog log:@"Starting chat relay"];
+                [self startProcessingChatRelayMessagesFromMessagesId:lastChatBlock.newestMessageId];
+                return;
+            }
+
+            [self startReceivingChatMessagesFromMessagesId:lastChatBlock.newestMessageId withTimeout:hasReachedLatest];
         }
     }];
 }
 
+- (void)startProcessingChatRelayMessagesFromMessagesId:(NSInteger)messageId
+{
+    dispatch_async(self.chatRelayMessagesQueue, ^{
+        self.startProcessingChatRelayMessages = YES;
+        [self flushChatRelayMessagesBuffer];
+    });
+}
+
+- (void)flushChatRelayMessagesBuffer
+{
+    if (self.chatRelayMessagesBuffer.count == 0) {
+        [NCLog log:@"No messages stored in chat relay messages buffer"];
+        return;
+    }
+
+    [self.chatRelayMessagesBuffer sortUsingDescriptors:@[
+        [NSSortDescriptor sortDescriptorWithKey:@"id" ascending:YES]
+    ]];
+
+    for (NSDictionary *messageDict in self.chatRelayMessagesBuffer) {
+        [self handleChatRelayMessage:messageDict];
+    }
+
+    [self.chatRelayMessagesBuffer removeAllObjects];
+}
+
+- (void)handleChatRelayMessage:(NSDictionary *)messageDict
+{
+    NCChatBlock *lastChatBlock = [self chatBlocksForRoomOrThread].lastObject;
+    NSInteger lastNewestMessageId = lastChatBlock.newestMessageId;
+    NCChatMessage *message = [NCChatMessage messageWithDictionary:messageDict andAccountId:self->_account.accountId];
+    if (message) {
+        // Sanity check: if there's a gap between the last known message and the incoming
+        // message, some messages may have been missed on a flaky connection. Stop chat relay
+        // and fall back to long-polling, which will fetch missing messages from the server.
+        // Once polling catches up (304), it will switch back to chat relay automatically.
+        // Only check for gaps when we have a known last message (lastNewestMessageId > 0).
+        if (lastNewestMessageId > 0 && message.messageId > lastNewestMessageId + 1) {
+            [NCLog log:[NSString stringWithFormat:@"Chat relay gap detected: last=%ld, received=%ld – falling back to long-polling to fetch missing messages", (long)lastNewestMessageId, (long)message.messageId]];
+            self->_startProcessingChatRelayMessages = NO;
+            [self->_chatRelayMessagesBuffer removeAllObjects];
+            dispatch_async(dispatch_get_main_queue(), ^{
+                [self startReceivingChatMessagesFromMessagesId:lastNewestMessageId withTimeout:NO];
+            });
+            return;
+        }
+
+        [self updateLastChatBlockWithNewestKnown:message.messageId];
+        [self storeMessages:@[messageDict]];
+
+        [self checkForNewMessagesFromMessageId:lastNewestMessageId];
+    }
+}
+
 - (void)startReceivingNewChatMessages
 {
     NCChatBlock *lastChatBlock = [self chatBlocksForRoomOrThread].lastObject;
@@ -915,6 +1031,12 @@ - (void)startReceivingNewChatMessages
 
 - (void)stopReceivingNewChatMessages
 {
+    if (_chatRelayMessagesQueue) {
+        dispatch_async(_chatRelayMessagesQueue, ^{
+            self->_startProcessingChatRelayMessages = NO;
+            [self->_chatRelayMessagesBuffer removeAllObjects];
+        });
+    }
     _stopChatMessagesPoll = YES;
     [_pullMessagesTask cancel];
 }

NextcloudTalk/WebRTC/NCExternalSignalingController.swift

@@ -13,12 +13,19 @@ import Foundation
     @objc func externalSignalingController(_ externalSignalingController: NCExternalSignalingController, shouldSwitchToCall roomToken: String)
 }
 
+@objc extension NSNotification {
+    public static let ExtSignalingDidReceiveChatMessage = Notification.Name.extSignalingDidReceiveChatMessage
+    public static let ExtSignalingDidDisconnect = Notification.Name.extSignalingDidDisconnect
+}
+
 extension Notification.Name {
     static let extSignalingDidUpdateParticipants = Notification.Name(rawValue: "NCExternalSignalingControllerDidUpdateParticipantsNotification")
     static let extSignalingDidReceiveJoinOfParticipant = Notification.Name(rawValue: "NCExternalSignalingControllerDidReceiveJoinOfParticipantNotification")
     static let extSignalingDidReceiveLeaveOfParticipant = Notification.Name(rawValue: "NCExternalSignalingControllerDidReceiveLeaveOfParticipantNotification")
     static let extSignalingDidReceiveStartedTyping = Notification.Name(rawValue: "NCExternalSignalingControllerDidReceiveStartedTypingNotification")
     static let extSignalingDidReceiveStoppedTyping = Notification.Name(rawValue: "NCExternalSignalingControllerDidReceiveStoppedTypingNotification")
+    static let extSignalingDidReceiveChatMessage = Notification.Name(rawValue: "NCExternalSignalingControllerDidReceiveChatMessageNotification")
+    static let extSignalingDidDisconnect = Notification.Name(rawValue: "NCExternalSignalingControllerDidDisconnectNotification")
 }
 
 public typealias SendMessageCompletionBlock = (_ task: URLSessionWebSocketTask?, _ status: NCExternalSignalingSendMessageStatus) -> Void
@@ -38,6 +45,7 @@ public enum NCExternalSignalingSendMessageStatus {
     public private(set) var account: TalkAccount
     public private(set) var disconnected: Bool = true
     public private(set) var hasMCU: Bool = false
+    public private(set) var hasChatRelay: Bool = false
     public private(set) var sessionId: String?
     public private(set) var participantsMap = [String: SignalingParticipant]()
 
@@ -155,6 +163,9 @@ public enum NCExternalSignalingSendMessageStatus {
             message.executeCompletionBlock(withStatus: .socketError)
         }
 
+        // Notify chat controllers that the signaling connection was lost
+        NotificationCenter.default.post(name: .extSignalingDidDisconnect, object: self)
+
         self.setReconnectionTimer()
     }
 
@@ -280,6 +291,9 @@ public enum NCExternalSignalingSendMessageStatus {
                         "userid": account.userId,
                         "ticket": ticket
                     ]
+                ],
+                "features": [
+                    "chat-relay"
                 ]
             ]
         ]
@@ -289,7 +303,10 @@ public enum NCExternalSignalingSendMessageStatus {
                 "type": "hello",
                 "hello": [
                     "version": "1.0",
-                    "resumeid": resumeId
+                    "resumeid": resumeId,
+                    "features": [
+                        "chat-relay"
+                    ]
                 ]
             ]
         }
@@ -333,6 +350,7 @@ public enum NCExternalSignalingSendMessageStatus {
         }
 
         self.hasMCU = serverFeatures.contains(where: { $0 == "mcu" })
+        self.hasChatRelay = serverFeatures.contains(where: { $0 == "chat-relay" })
 
         DispatchQueue.main.async {
             let bgTask = BGTaskHelper.startBackgroundTask(withName: "NCUpdateSignalingVersionTransaction")
@@ -616,6 +634,7 @@ public enum NCExternalSignalingSendMessageStatus {
 
         if messageType == "chat" {
             print("Chat message received")
+            NotificationCenter.default.post(name: .extSignalingDidReceiveChatMessage, object: self, userInfo: messageDict)
         } else if messageType == "recording" {
             self.delegate?.externalSignalingController(self, didReceivedSignalingMessage: messageDict)
         } else {