No Way to Reconnect Call When Internet is Lost in sip_ua

[umaraslam-cs]

I have noticed that there is currently no clear way in the sip_ua package to handle scenarios where the internet connection is lost during an active call. Specifically, there seems to be no built-in mechanism to detect internet connectivity loss, attempt reconnection, and resume the call.

I attempted to use the renegotiate function as part of a custom reconnection logic. However, when this function is called after the internet is restored, it unexpectedly terminates the call on the other end instead of renegotiating the connection.

This behavior limits the usability of the library for handling real-world scenarios where network stability can fluctuate.

To Reproduce:
Steps to reproduce the behavior:

1. Start an active call using the sip_ua library.
2. Disconnect the internet during the call.
3. Attempt to detect the internet restoration and use the renegotiate function to reconnect.

Expected behavior:
The call should be renegotiated, and the connection should be restored when the internet returns without terminating the call for the other participant.

Code Snippets:

@override
Future<void> callStateChanged(Call call, CallState callState) async {
  if (call.peerConnection != null) {
    monitorConnectionState(call);
  }
}

Timer? connectivityTimer;
int retryCount = 0;

void monitorConnectionState(Call call) {
  if (call.peerConnection?.connectionState == RTCPeerConnectionState.RTCPeerConnectionStateDisconnected) {
    startConnectivityCheck(call);
  }
}

void startConnectivityCheck(Call call) {
  stopConnectivityCheck();
  retryCount = 0;

  connectivityTimer = Timer.periodic(const Duration(seconds: 1), (timer) async {
    retryCount++;
    bool isInternetAvailable = await ConnectivityHelper.hasInternetConnection();

    if (isInternetAvailable) {
      stopConnectivityCheck();
      renegotiateCall(call);
    }

    if (retryCount >= 10) {
      stopConnectivityCheck();
      endCallDueToNetworkIssue();
    }
  });
}

void stopConnectivityCheck() {
  connectivityTimer?.cancel();
  connectivityTimer = null;
}

void renegotiateCall(Call call) {
  try {
    call.renegotiate(
      useUpdate: true,
      options: {'useUpdate': true},
      done: (response) {},
    );
  } catch (e) {}
}

void endCallDueToNetworkIssue() async {
  Provider.of<SipRegisterProvider>(context, listen: false).upDateSipCallSpeaker(false);
  await endAllCalls();
  if (Navigator.of(navigatorKey.currentContext!).canPop()) {
    Navigator.of(navigatorKey.currentContext!).pop();
  }
}

Request:

1. Please provide a way to handle call reconnection gracefully when the internet is lost and restored.
2. Clarify the intended behavior of the renegotiate function and how it should be used.
3. If this is a bug, consider fixing the issue where the renegotiate function ends the call instead of restoring the connection.

Thank you for your support and this useful library!

System Infomation()
Flutter SDK Version: 3.24.4

[umaraslam-cs]

@jbg @hiratake55 @ghenry @DooMMasteR @reduxdj Any help would be highly appreciated. Thank you

[VictorUvarov]

I would look at the socket implementations and see if you can do anything about this and handle onDisconnect. There is already logic in retrying to connect.

[umaraslam-cs]

Thank you for your response, @VictorUvarov. I look forward to hearing back from you.

[VictorUvarov]

@umaraslam-cs You can take a look at this problem. Let me know what you discover and have tried.

[EliasBarrera]

any solution of this ?

[reduxdj]

yeah, the gist is you have to handle this at the socket_transport level, and shortcut the disconnection logic with a variety of flags. What we we do is create a custom event, and it bubbles up to our RTCSession where we can send a re-invite, the caveat is you need to do this in 30 seconds or the socket will timeout, but that's more than enough for temporary network switch overs.

import 'dart:math';
import 'dart:io';
import 'package:cloud_call/sip/call_manager.dart';
import 'package:cloud_call/sip/constants.dart';
import 'package:cloud_call/sip/sip_message.dart';
import 'package:cloud_call/sip/event_manager/events.dart';
import 'package:cloud_call/sip/transport_constants.dart';
import 'package:cloud_call/sip/transports/socket_interface.dart';
import 'package:cloud_call/sip/exceptions.dart' as Exceptions;

import 'package:cloud_call/sip/stack_trace_nj.dart';
import 'package:cloud_call/sip/timers.dart';
import 'package:cloud_call/sip/utils.dart';
import 'package:cloud_call/managers/connection_manager.dart';
import 'package:cloud_call/loggers/app_logger.dart';

/*
 * Manages one or multiple DartSIP.Socket instances.
 * Is reponsible for transport recovery logic among all socket instances.
 *
 * @socket DartSIP::Socket instance
 */
class SocketTransport {
  SocketTransport(List<SIPUASocketInterface>? sockets, [Map<String, int> recovery_options = C.recovery_options]) {
    Log.d('SocketTransport: new()');

    _recovery_options = recovery_options;

    // We must recieve at least 1 socket
    if (sockets!.isEmpty) {
      throw Exceptions.TypeError('invalid argument: Must recieve atleast 1 web socket');
    }

    for (SIPUASocketInterface socket in sockets) {
      _socketsMap.add(<String, dynamic>{'socket': socket, 'weight': socket.weight ?? 0, 'status': C.SOCKET_STATUS_READY});
    }
    // Get the socket with higher weight.
    _getSocket();
  }

  int status = C.STATUS_DISCONNECTED;
  // Current socket.
  late SIPUASocketInterface socket;
  // Socket collection.
  final List<Map<String, dynamic>> _socketsMap = <Map<String, dynamic>>[];
  late Map<String, int> _recovery_options;
  int _recover_attempts = 0;
  Timer? _recovery_timer;
  bool _close_requested = false;
  StreamSubscription<bool>? _connectionStatusSubscription;

  late void Function(SIPUASocketInterface? socket, int? attempts) onconnecting;
  late void Function(SIPUASocketInterface? socket, ErrorCause cause) ondisconnect;
  late void Function(SocketTransport transport) onconnect;
  late void Function(SocketTransport transport) onreconnectToCall;
  late void Function(SocketTransport transport, String messageData) ondata;

  /**
   * Instance Methods
   */

  String get via_transport => socket.via_transport;

  String? get url => socket.url;

  String? get sip_uri => socket.sip_uri;

  void connect([bool skipCheckingIfConnected = false, Function? onConnectCallback]) {
    Log.d('SocketTransportTransport connect() called with skipCheckingIfConnected: $skipCheckingIfConnected');

    if (isConnected() && !skipCheckingIfConnected) {
      Log.d('SocketTransport Transport is already connected, calling onconnect callback directly');
      // If already connected but we're trying to reconnect, trigger the callback directly
      if (isReconnectingToCall && CallManager().hasActiveCalls) {
        Log.d('SocketTransport Triggering reconnectToCall callback directly');
        onreconnectToCall(this);
      } else {
        Log.d('SocketTransport Triggering connect callback directly');
        onconnect(this);
      }
      return;
    } else if (isConnecting() && !skipCheckingIfConnected) {
      Log.d('Transport is connecting, exiting');
      return;
    }

    // First get the socket, as this may change the socket reference
    Log.d('SocketTransport Getting socket from available sockets pool');
    _getSocket();
    Log.d('SocketTransport Selected socket with URL: ${socket.url}');

    // Set status to connecting before we start the connection process
    status = C.STATUS_CONNECTING;
    Log.d('SocketTransport Setting status to CONNECTING');

    // Override socket callbacks to ensure they always trigger our methods
    Log.d('SocketTransport Setting up socket callbacks');
    socket.onconnect = () {
      Log.d('Socket onconnect callback triggered directly from socket');
      _onConnect();
    };

    socket.ondisconnect = (socket, error, closeCode, reason) {
      Log.d('SocketTransport Socket ondisconnect callback triggered with reason: $reason');
      _onDisconnect(socket, error, closeCode, reason);
    };

    socket.ondata = (data) {
      //  Log.d('SocketTransport Socket ondata callback triggered');
      _onData(data);
    };

    // Trigger connecting callback
    Log.d('SocketTransport Triggering onconnecting callback');
    onconnecting(socket, _recover_attempts);

    // Now initiate the connection
    Log.d('SocketTransport Initiating socket connection to ${socket.url}');
    socket.connect();

    // Force callback if it doesn't trigger naturally
    Future.delayed(const Duration(seconds: 3), () {
      if (status == C.STATUS_CONNECTING) {
        Log.d('SocketTransport Connection callback not triggered after 3 seconds, forcing callback');
        _onConnect();
      }
    });
  }

  void disconnect() {
    Log.d('SocketTransport Transport close()');

    _close_requested = true;
    _recover_attempts = 0;
    status = C.STATUS_DISCONNECTED;

    // Clear recovery_timer.
    if (_recovery_timer != null) {
      clearTimeout(_recovery_timer);
      _recovery_timer = null;
    }

    // Unbind socket event callbacks.
    socket.onconnect = () => () {};
    socket.ondisconnect = (SIPUASocketInterface socket, bool error, int? closeCode, String? reason) => () {};
    socket.ondata = (dynamic data) => () {};

    socket.disconnect();
    ondisconnect(socket, ErrorCause(cause: 'disconnect', status_code: 0, reason_phrase: 'close by local'));

    // Cancel connection status listener if any
    _connectionStatusSubscription?.cancel();
    _connectionStatusSubscription = null;
    isReconnectingToCall = true;
  }

  bool disableDisconnectionEvent = false;
  bool send(dynamic data) {
    //   Log.d('SocketTransport Socket Transport send()');

    if (!isConnected() && !isReconnectingToCall) {
      Log.d('SocketTransport unable to send message, transport is not connected. Current state is $status', stackTrace: StackTraceNJ());
      ondisconnect(socket, ErrorCause(cause: 'error', status_code: 500, reason_phrase: 'Socket connection dropped'));
      return false;
    }
    String message = data.toString();
    return socket.send(message);
  }

  bool isConnected() {
    return status == C.STATUS_CONNECTED;
  }

  bool isConnecting() {
    return status == C.STATUS_CONNECTING;
  }

  /**
   * get the next available socket with higher weight
   */
  void _getSocket() {
    // If we dont have at least 1 socket to try and use, thiw will loop endlessly

    if (_socketsMap.isEmpty) {
      throw Exceptions.TypeError('invalid argument: too few sockets');
    }

    List<Map<String, dynamic>> candidates = <Map<String, dynamic>>[];

    for (Map<String, dynamic> socket in _socketsMap) {
      if (socket['status'] == C.SOCKET_STATUS_ERROR) {
        return; // continue the array iteration
      } else if (candidates.isEmpty) {
        candidates.add(socket);
      } else if (socket['weight'] > candidates[0]['weight']) {
        candidates = <Map<String, dynamic>>[socket];
      } else if (socket['weight'] == candidates[0]['weight']) {
        candidates.add(socket);
      }
    }

    if (candidates.isEmpty) {
      // All sockets have failed. reset sockets status.
      for (Map<String, dynamic> socket in _socketsMap) {
        socket['status'] = C.SOCKET_STATUS_READY;
      }
      // Get next available socket.
      _getSocket();
      return;
    }

    num idx = (Math.randomDouble() * candidates.length).floor();

    socket = candidates[idx as int]['socket'];
  }

  /**
   * Socket Event Handlers
   */
  bool isReconnectingToCall = false;
  void _onConnect() {
    Log.d('SocketTransport _onConnect triggered, setting status to CONNECTED');

    // Update status to connected
    status = C.STATUS_CONNECTED;

    // Reset reconnection variables
    _recover_attempts = 0;
    _close_requested = false;

    // Determine if this was a reconnection for an active call
    bool wasReconnecting = isReconnectingToCall;
    isReconnectingToCall = false;

    // Clear any existing timers
    if (_recovery_timer != null) {
      Log.d('SocketTransport Clearing recovery timer');
      clearTimeout(_recovery_timer);
      _recovery_timer = null;
    }

    // Cleanup any existing subscription
    if (_connectionStatusSubscription != null) {
      Log.d('SocketTransport Canceling existing connection status subscription');
      _connectionStatusSubscription!.cancel();
      _connectionStatusSubscription = null;
    }

    // Setup connection status monitoring for future disconnects
    Log.d('SocketTransport Setting up connection status monitoring');
    _connectionStatusSubscription = ConnectionManager().connectionStatus.listen((online) {
      Log.d('SocketTransport Connection status changed to: ${online ? "online" : "offline"}');
      if (online) {
        Log.d('SocketTransport Connection restored, checking if reconnection needed');
        _connectionStatusSubscription?.cancel();
        _connectionStatusSubscription = null;

        // Check if we have active calls and need to reconnect
        if (CallManager().hasActiveCalls) {
          Log.d('SocketTransport Active calls detected, triggering reconnection');
          isReconnectingToCall = true;
          disableDisconnectionEvent = true;
          _reconnect();
        }
      } else {
        Log.d('Connection lost, waiting for recovery');
      }
    });

    // Call the appropriate callback function based on previous state
    disableDisconnectionEvent = false; // Reset the flag for future disconnects

    // Always call regular onconnect first for protocol initialization
    Log.d('Triggering regular connect callback for protocol initialization');
    onconnect(this);

    // If this was a reconnection for a call, also trigger that callback
    if (wasReconnecting && CallManager().hasActiveCalls) {
      Log.d('SocketTransport Also triggering reconnectToCall callback for active calls');
      onreconnectToCall(this);
    }
  }

  void _reconnect() {
    _recover_attempts = _recover_attempts + 1;

    Log.d('SocketTransport _reconnect called, attempt #$_recover_attempts');

    // Calculate backoff delay using exponential backoff
    num k = ((Math.randomDouble() * pow(2, _recover_attempts)) + 1).floor();

    // Apply min/max bounds from recovery options
    if (k < _recovery_options['min_interval']!) {
      k = _recovery_options['min_interval']!;
    } else if (k > _recovery_options['max_interval']!) {
      k = _recovery_options['max_interval']!;
    }

    // Clear any existing recovery timer
    if (_recovery_timer != null) {
      Log.d('Clearing existing recovery timer');
      clearTimeout(_recovery_timer);
      _recovery_timer = null;
    }

    Log.d('SocketTransport Scheduling reconnection attempt in ${k} seconds (attempt #$_recover_attempts)');

    // For active calls, reduce the delay to minimize call disruption
    int delay = isReconnectingToCall
        ? ((k * 1000) / 2).floor() // Half the delay if reconnecting for a call
        : (k * 1000) as int;

    Log.d('SocketTransport Using ${isReconnectingToCall ? "accelerated" : "normal"} reconnection delay: ${delay}ms');

    _recovery_timer = setTimeout(() {
      Log.d('SocketTransport Executing scheduled reconnection attempt #$_recover_attempts');

      // Use our new forceful reconnection method instead of the standard connect
      forceReconnect();
    }, delay);
  }

  void _onDisconnect(SIPUASocketInterface socket, bool error, int? closeCode, String? reason) {
    Log.d('SocketTransport Socket disconnected: $reason (code: $closeCode, error: $error)');

    // Update status
    status = C.STATUS_DISCONNECTED;

    // If close was requested, just clean up and return
    if (_close_requested) {
      Log.d('SocketTransport Close was requested, not triggering reconnection');

      // Always propagate disconnection event if not disabled
      if (!disableDisconnectionEvent) {
        ondisconnect(socket, ErrorCause(cause: 'error', status_code: closeCode, reason_phrase: reason));
      }
      return;
    }

    // Check if we have active calls
    bool hasActiveCalls = CallManager().hasActiveCalls;

    // Update socket status
    for (Map<String, dynamic> socketMap in _socketsMap) {
      if (socketMap['socket'] == socket) {
        socketMap['status'] = C.SOCKET_STATUS_ERROR;
      }
    }

    // Always propagate disconnection event if not specifically disabled
    if (!disableDisconnectionEvent) {
      Log.d('SocketTransport Triggering disconnect event');
      ondisconnect(socket, ErrorCause(cause: 'error', status_code: closeCode, reason_phrase: reason));
    }

    // Cancel existing connection subscription
    if (_connectionStatusSubscription != null) {
      _connectionStatusSubscription!.cancel();
      _connectionStatusSubscription = null;
    }

    // For active calls, attempt immediate reconnection
    if (hasActiveCalls) {
      Log.d('SocketTransport Active calls detected, attempting immediate forced reconnection');
      isReconnectingToCall = true;
      disableDisconnectionEvent = true;

      // Try to reconnect immediately if online
      if (ConnectionManager().hasInternetConnection) {
        Log.d('SocketTransport Internet connection available, performing immediate forceful reconnection');
        forceReconnect();
        return;
      }
    }

    // Set up connection monitoring and attempt reconnection when online
    _connectionStatusSubscription = ConnectionManager().connectionStatus.listen((online) {
      if (online) {
        Log.d('SocketTransport Connectivity restored. Attempting forceful reconnection');
        _connectionStatusSubscription?.cancel();
        _connectionStatusSubscription = null;

        // If we have active calls, set the reconnection flag
        if (hasActiveCalls) {
          Log.d('SocketTransport Active calls still present, setting reconnection flag');
          isReconnectingToCall = true;
          disableDisconnectionEvent = true;
        }

        // Use forceful reconnection
        forceReconnect();
      } else {
        Log.d('SocketTransport No connectivity, waiting for network to be restored');
      }
    });
  }

  void _onData(dynamic data) {
    // CRLF Keep Alive response from server. Ignore it.
    if (data == '\r\n') {
      Log.d('SocketTransport received message with CRLF Keep Alive response');
      return;
    }

    // Binary message.
    else if (data is! String) {
      try {
        data = String.fromCharCodes(data);
      } catch (evt) {
        Log.d('SocketTransport received binary message [${data.runtimeType}]failed to be converted into string,'
            ' message discarded');
        return;
      }
      Log.d('SocketTransport received binary message:\n\n$data\n');
    }

    // Text message.
    else {
      // Log.d('SocketTransport received text message:\n\n$data\n');
    }
    disableDisconnectionEvent = true;
    ondata(this, data);
  }

  // Force a full reconnection by completely destroying and recreating the socket connection
  void forceReconnect() {
    Log.d('SocketTransport Forcing complete reconnection - creating new socket connection');

    // Clear any existing timers
    if (_recovery_timer != null) {
      clearTimeout(_recovery_timer);
      _recovery_timer = null;
    }

    // Cancel any existing connection monitoring
    if (_connectionStatusSubscription != null) {
      _connectionStatusSubscription!.cancel();
      _connectionStatusSubscription = null;
    }

    // First disconnect completely if connected
    if (isConnected() || isConnecting()) {
      Log.d('SocketTransport Disconnecting existing socket before force reconnect');

      // Unbind socket event callbacks to prevent triggering disconnection events
      socket.onconnect = () => () {};
      socket.ondisconnect = (SIPUASocketInterface socket, bool error, int? closeCode, String? reason) => () {};
      socket.ondata = (dynamic data) => () {};

      // Mark this as a reconnect if we have active calls
      if (CallManager().hasActiveCalls) {
        Log.d('Active calls detected, marking as reconnection for call');
        isReconnectingToCall = true;
        disableDisconnectionEvent = true;
      }

      try {
        socket.disconnect();
      } catch (e) {
        Log.e('SocketTransport Error disconnecting socket: $e');
      }

      // Reset socket status to force new socket selection
      for (Map<String, dynamic> socketMap in _socketsMap) {
        socketMap['status'] = C.SOCKET_STATUS_READY;
      }
    }

    // Force status to disconnected
    status = C.STATUS_DISCONNECTED;

    // Select a new socket
    Log.d('SocketTransport Selecting new socket for reconnection');
    _getSocket();
    Log.d('SocketTransport Selected socket with URL: ${socket.url}');

    // Set up callbacks on the new socket
    Log.d('SocketTransport Setting up callbacks for forced reconnection');
    socket.onconnect = _onForceReconnectConnect;
    socket.ondisconnect = _onDisconnect;
    socket.ondata = _onData;

    // Start connection process
    Log.d('SocketTransport Initiating forced reconnection to ${socket.url}');
    status = C.STATUS_CONNECTING;
    onconnecting(socket, _recover_attempts);

    // Actually connect
    try {
      socket.connect();
    } catch (e) {
      Log.e('SocketTransport Error during forced reconnection: $e');
      // Fall back to timed reconnection attempts
      _reconnect();
    }
  }

  // Special handler for forced reconnection
  void _onForceReconnectConnect() {
    Log.d('SocketTransport Force reconnect connection successful');

    // Update status
    status = C.STATUS_CONNECTED;

    // Reset reconnection variables
    _recover_attempts = 0;
    _close_requested = false;

    // Process connection based on whether it was for a call
    if (isReconnectingToCall) {
      Log.d('SocketTransport Force reconnection was for an active call, triggering reconnectToCall callback');
      isReconnectingToCall = false;
      disableDisconnectionEvent = false;

      // First call regular connect for protocol initialization
      onconnect(this);

      // Then trigger the call-specific reconnection callback
      onreconnectToCall(this);
    } else {
      Log.d('SocketTransport Force reconnection was standard, triggering connect callback');
      onconnect(this);
    }

    // Set up normal connection monitoring for future events
    // Set up connection monitoring and attempt reconnection when online
    _connectionStatusSubscription = ConnectionManager().connectionStatus.listen((online) {
      if (online) {
        Log.d('SocketTransport Connectivity restored. Attempting forceful reconnection');
        _connectionStatusSubscription?.cancel();
        _connectionStatusSubscription = null;

        // If we have active calls, set the reconnection flag
        if (CallManager().hasActiveCalls) {
          Log.d('SocketTransport Active calls still present, setting reconnection flag');
          isReconnectingToCall = true;
          disableDisconnectionEvent = true;
        }

        // Use forceful reconnection
        forceReconnect();
      } else {
        Log.d('SocketTransport No connectivity, waiting for network to be restored');
      }
    });
  }
}