fix: streaming

2025-09-26 01:38:00 +05:30
parent 748f2a43a8
commit 5f03610f35
4 changed files with 467 additions and 146 deletions
--- a/lib/core/services/socket_service.dart
+++ b/lib/core/services/socket_service.dart
@@ -1,24 +1,55 @@
+import 'package:flutter/widgets.dart';
 import 'package:socket_io_client/socket_io_client.dart' as io;
+
 import '../models/server_config.dart';
 import '../utils/debug_logger.dart';

-class SocketService {
+typedef SocketChatEventHandler =
+    void Function(
+      Map<String, dynamic> event,
+      void Function(dynamic response)? ack,
+    );
+
+typedef SocketChannelEventHandler =
+    void Function(
+      Map<String, dynamic> event,
+      void Function(dynamic response)? ack,
+    );
+
+class SocketService with WidgetsBindingObserver {
  final ServerConfig serverConfig;
  final bool websocketOnly;
  io.Socket? _socket;
  String? _authToken;
+  bool _isAppForeground = true;
+
+  final Map<String, _ChatEventRegistration> _chatEventHandlers = {};
+  final Map<String, _ChannelEventRegistration> _channelEventHandlers = {};
+  int _handlerSeed = 0;

  SocketService({
    required this.serverConfig,
    String? authToken,
    this.websocketOnly = false,
-  }) : _authToken = authToken;
+  }) : _authToken = authToken {
+    final binding = WidgetsBinding.instance;
+    final lifecycle = binding.lifecycleState;
+    _isAppForeground =
+        lifecycle == null || lifecycle == AppLifecycleState.resumed;
+    binding.addObserver(this);
+  }
+
+  @override
+  void didChangeAppLifecycleState(AppLifecycleState state) {
+    _isAppForeground = state == AppLifecycleState.resumed;
+  }

  String? get sessionId => _socket?.id;
  io.Socket? get socket => _socket;
  String? get authToken => _authToken;

  bool get isConnected => _socket?.connected == true;
+  bool get isAppForeground => _isAppForeground;

  Future<void> connect({bool force = false}) async {
    if (_socket != null && _socket!.connected && !force) return;
@@ -91,43 +122,7 @@ class SocketService {

    _socket = io.io(base, builder.build());

-    _socket!.on('connect', (_) {
-      DebugLogger.log('Socket connected: ${_socket!.id}', scope: 'socket');
-      if (_authToken != null && _authToken!.isNotEmpty) {
-        _socket!.emit('user-join', {
-          'auth': {'token': _authToken},
-        });
-      }
-    });
-
-    _socket!.on('connect_error', (err) {
-      DebugLogger.log('Socket connect_error: $err', scope: 'socket');
-    });
-
-    _socket!.on('reconnect_attempt', (attempt) {
-      DebugLogger.log('Socket reconnect_attempt: $attempt', scope: 'socket');
-    });
-
-    _socket!.on('reconnect', (attempt) {
-      DebugLogger.log(
-        'Socket reconnected after $attempt attempts',
-        scope: 'socket',
-      );
-      if (_authToken != null && _authToken!.isNotEmpty) {
-        // Best-effort rejoin
-        _socket!.emit('user-join', {
-          'auth': {'token': _authToken},
-        });
-      }
-    });
-
-    _socket!.on('reconnect_failed', (_) {
-      DebugLogger.log('Socket reconnect_failed', scope: 'socket');
-    });
-
-    _socket!.on('disconnect', (reason) {
-      DebugLogger.log('Socket disconnected: $reason', scope: 'socket');
-    });
+    _bindCoreSocketHandlers();
  }

  /// Update the auth token used by the socket service.
@@ -145,77 +140,48 @@ class SocketService {
    }
  }

-  void onChatEvents(
-    void Function(
-      Map<String, dynamic> event,
-      void Function(dynamic response)? ack,
-    )
-    handler,
-  ) {
-    _socket?.on('chat-events', (dynamic data, [dynamic ack]) {
-      try {
-        Map<String, dynamic>? map;
-        if (data is Map<String, dynamic>) {
-          map = data;
-        } else if (data is Map) {
-          map = Map<String, dynamic>.from(data);
-        }
-        if (map == null) return;
-        final ackFn = ack is Function
-            ? (dynamic payload) {
-                if (payload is List) {
-                  Function.apply(ack, payload);
-                } else if (payload == null) {
-                  Function.apply(ack, const []);
-                } else {
-                  Function.apply(ack, [payload]);
-                }
-              }
-            : null;
-        handler(map, ackFn);
-      } catch (_) {}
-    });
+  SocketEventSubscription addChatEventHandler({
+    String? conversationId,
+    String? sessionId,
+    bool requireFocus = true,
+    required SocketChatEventHandler handler,
+  }) {
+    final id = _nextHandlerId();
+    _chatEventHandlers[id] = _ChatEventRegistration(
+      id: id,
+      conversationId: conversationId,
+      sessionId: sessionId,
+      requireFocus: requireFocus,
+      handler: handler,
+    );
+    _bindCoreSocketHandlers();
+    return SocketEventSubscription(() => _chatEventHandlers.remove(id));
  }

-  // Subscribe to general channel events (server-broadcasted channel updates)
-  void onChannelEvents(
-    void Function(
-      Map<String, dynamic> event,
-      void Function(dynamic response)? ack,
-    )
-    handler,
-  ) {
-    _socket?.on('channel-events', (dynamic data, [dynamic ack]) {
-      try {
-        Map<String, dynamic>? map;
-        if (data is Map<String, dynamic>) {
-          map = data;
-        } else if (data is Map) {
-          map = Map<String, dynamic>.from(data);
-        }
-        if (map == null) return;
-        final ackFn = ack is Function
-            ? (dynamic payload) {
-                if (payload is List) {
-                  Function.apply(ack, payload);
-                } else if (payload == null) {
-                  Function.apply(ack, const []);
-                } else {
-                  Function.apply(ack, [payload]);
-                }
-              }
-            : null;
-        handler(map, ackFn);
-      } catch (_) {}
-    });
+  SocketEventSubscription addChannelEventHandler({
+    String? conversationId,
+    String? sessionId,
+    bool requireFocus = true,
+    required SocketChannelEventHandler handler,
+  }) {
+    final id = _nextHandlerId();
+    _channelEventHandlers[id] = _ChannelEventRegistration(
+      id: id,
+      conversationId: conversationId,
+      sessionId: sessionId,
+      requireFocus: requireFocus,
+      handler: handler,
+    );
+    _bindCoreSocketHandlers();
+    return SocketEventSubscription(() => _channelEventHandlers.remove(id));
  }

-  void offChatEvents() {
-    _socket?.off('chat-events');
+  void clearChatEventHandlers() {
+    _chatEventHandlers.clear();
  }

-  void offChannelEvents() {
-    _socket?.off('channel-events');
+  void clearChannelEventHandlers() {
+    _channelEventHandlers.clear();
  }

  // Subscribe to an arbitrary socket.io event (used for dynamic tool channels)
@@ -232,6 +198,9 @@ class SocketService {
      _socket?.dispose();
    } catch (_) {}
    _socket = null;
+    WidgetsBinding.instance.removeObserver(this);
+    _chatEventHandlers.clear();
+    _channelEventHandlers.clear();
  }

  // Best-effort: ensure there is an active connection and wait briefly.
@@ -249,4 +218,256 @@ class SocketService {
    }
    return isConnected;
  }
+
+  void _bindCoreSocketHandlers() {
+    final socket = _socket;
+    if (socket == null) return;
+
+    socket
+      ..off('chat-events', _handleChatEvent)
+      ..off('channel-events', _handleChannelEvent)
+      ..off('connect', _handleConnect)
+      ..off('connect_error', _handleConnectError)
+      ..off('reconnect_attempt', _handleReconnectAttempt)
+      ..off('reconnect', _handleReconnect)
+      ..off('reconnect_failed', _handleReconnectFailed)
+      ..off('disconnect', _handleDisconnect);
+
+    socket
+      ..on('chat-events', _handleChatEvent)
+      ..on('channel-events', _handleChannelEvent)
+      ..on('connect', _handleConnect)
+      ..on('connect_error', _handleConnectError)
+      ..on('reconnect_attempt', _handleReconnectAttempt)
+      ..on('reconnect', _handleReconnect)
+      ..on('reconnect_failed', _handleReconnectFailed)
+      ..on('disconnect', _handleDisconnect);
+  }
+
+  void _handleConnect(dynamic _) {
+    DebugLogger.log('Socket connected: ${_socket?.id}', scope: 'socket');
+    if (_authToken != null && _authToken!.isNotEmpty) {
+      _socket?.emit('user-join', {
+        'auth': {'token': _authToken},
+      });
+    }
+  }
+
+  void _handleReconnectAttempt(dynamic attempt) {
+    DebugLogger.log('Socket reconnect_attempt: $attempt', scope: 'socket');
+  }
+
+  void _handleReconnect(dynamic attempt) {
+    DebugLogger.log(
+      'Socket reconnected after $attempt attempts',
+      scope: 'socket',
+    );
+    if (_authToken != null && _authToken!.isNotEmpty) {
+      _socket?.emit('user-join', {
+        'auth': {'token': _authToken},
+      });
+    }
+  }
+
+  void _handleConnectError(dynamic err) {
+    DebugLogger.log('Socket connect_error: $err', scope: 'socket');
+  }
+
+  void _handleReconnectFailed(dynamic _) {
+    DebugLogger.log('Socket reconnect_failed', scope: 'socket');
+  }
+
+  void _handleDisconnect(dynamic reason) {
+    DebugLogger.log('Socket disconnected: $reason', scope: 'socket');
+  }
+
+  void _handleChatEvent(dynamic data, [dynamic ack]) {
+    final map = _coerceToMap(data);
+    if (map == null) return;
+
+    final ackFn = _wrapAck(ack);
+    final sessionId = _extractSessionId(map);
+    final chatId = map['chat_id']?.toString();
+
+    for (final registration in List<_ChatEventRegistration>.from(
+      _chatEventHandlers.values,
+    )) {
+      if (!_shouldDeliver(
+        registration.conversationId,
+        registration.sessionId,
+        chatId,
+        sessionId,
+        registration.requireFocus,
+      )) {
+        continue;
+      }
+
+      try {
+        registration.handler(map, ackFn);
+      } catch (_) {}
+    }
+  }
+
+  void _handleChannelEvent(dynamic data, [dynamic ack]) {
+    final map = _coerceToMap(data);
+    if (map == null) return;
+
+    final ackFn = _wrapAck(ack);
+    final sessionId = _extractSessionId(map);
+    final chatId = map['chat_id']?.toString();
+
+    for (final registration in List<_ChannelEventRegistration>.from(
+      _channelEventHandlers.values,
+    )) {
+      if (!_shouldDeliver(
+        registration.conversationId,
+        registration.sessionId,
+        chatId,
+        sessionId,
+        registration.requireFocus,
+      )) {
+        continue;
+      }
+
+      try {
+        registration.handler(map, ackFn);
+      } catch (_) {}
+    }
+  }
+
+  bool _shouldDeliver(
+    String? registeredConversationId,
+    String? registeredSessionId,
+    String? incomingConversationId,
+    String? incomingSessionId,
+    bool requireFocus,
+  ) {
+    final matchesChat =
+        registeredConversationId == null ||
+        (incomingConversationId != null &&
+            registeredConversationId == incomingConversationId);
+    final matchesSession =
+        registeredSessionId != null &&
+        incomingSessionId != null &&
+        registeredSessionId == incomingSessionId;
+
+    if (!matchesChat && !matchesSession) {
+      return false;
+    }
+
+    if (!requireFocus) {
+      return true;
+    }
+
+    if (matchesSession) {
+      // Session-targeted messages should always pass through even if unfocused
+      return true;
+    }
+
+    return _isAppForeground;
+  }
+
+  Map<String, dynamic>? _coerceToMap(dynamic data) {
+    if (data is Map<String, dynamic>) {
+      return data;
+    }
+    if (data is Map) {
+      return Map<String, dynamic>.from(data);
+    }
+    return null;
+  }
+
+  void Function(dynamic response)? _wrapAck(dynamic ack) {
+    if (ack is! Function) return null;
+    return (dynamic payload) {
+      try {
+        if (payload is List) {
+          Function.apply(ack, payload);
+        } else if (payload == null) {
+          Function.apply(ack, const []);
+        } else {
+          Function.apply(ack, [payload]);
+        }
+      } catch (_) {}
+    };
+  }
+
+  String? _extractSessionId(Map<String, dynamic> event) {
+    String? candidate;
+
+    if (event['session_id'] != null) {
+      candidate = event['session_id'].toString();
+    }
+
+    final data = event['data'];
+    if (data is Map) {
+      if (candidate == null && data['session_id'] != null) {
+        candidate = data['session_id'].toString();
+      }
+      if (candidate == null && data['sessionId'] != null) {
+        candidate = data['sessionId'].toString();
+      }
+      final inner = data['data'];
+      if (inner is Map) {
+        if (candidate == null && inner['session_id'] != null) {
+          candidate = inner['session_id'].toString();
+        }
+        if (candidate == null && inner['sessionId'] != null) {
+          candidate = inner['sessionId'].toString();
+        }
+      }
+    }
+
+    return candidate;
+  }
+
+  String _nextHandlerId() {
+    _handlerSeed += 1;
+    return _handlerSeed.toString();
+  }
+}
+
+class SocketEventSubscription {
+  SocketEventSubscription(this._dispose);
+
+  final VoidCallback _dispose;
+  bool _isDisposed = false;
+
+  void dispose() {
+    if (_isDisposed) return;
+    _isDisposed = true;
+    _dispose();
+  }
+}
+
+class _ChatEventRegistration {
+  _ChatEventRegistration({
+    required this.id,
+    required this.handler,
+    this.conversationId,
+    this.sessionId,
+    this.requireFocus = true,
+  });
+
+  final String id;
+  final String? conversationId;
+  final String? sessionId;
+  final bool requireFocus;
+  final SocketChatEventHandler handler;
+}
+
+class _ChannelEventRegistration {
+  _ChannelEventRegistration({
+    required this.id,
+    required this.handler,
+    this.conversationId,
+    this.sessionId,
+    this.requireFocus = true,
+  });
+
+  final String id;
+  final String? conversationId;
+  final String? sessionId;
+  final bool requireFocus;
+  final SocketChannelEventHandler handler;
 }