some errors can't be handled in IOWebSocketChannel.connect about web_socket_channel HOT 10 OPEN

      final socket = await WebSocket
          .connect(url.toString())
          .timeout(_webSocketConnectionTimeout);
      return IOWebSocketChannel(socket);

WebSocketChannel channel = WebSocketChannel.connect(uri );
  try {
    await channel.ready;
  } catch (e) {
   // handle exception here
   print("WebsocketChannel was unable to establishconnection");
  }

Stream stream = channel.stream;
    stream.listen((event) {
      print('Event from Stream: $event');
      
    },onError: (e){
      
    // handle stream error
    },
    onDone: (() {
     // stream on done callback... 
    }),
    cancelOnError: true
    );

      stream = widget.webSocketChannel.stream;
      streamSubscription = stream.listen(
          onData,
          onError: (error) {
             // method calls and what not here
          },
          cancelOnError: true);
    }

WebSocketChannel channel = WebSocketChannel.connect(Uri());

  channel.ready.then((_) {
    channel.stream.listen((event) {
      print('Event from Stream: $event');
     
    },onError: (e){
      
    // handle stream error
    },
    onDone: (() {
     // stream on done callback... 
    }),
    cancelOnError: true
    );

  }).onError((error, stackTrace) {
    print("WebsocketChannel was unable to establishconnection");
  });

socketClient.stream.listen(
	(message){
		// handling incoming messages
	},
	onError: //Here a put a Error handling function,
	onDone: function(){
		// communication has been closed 
	}
);

// Flag to indicate whether a WebSocket connection attempt is currently in progress.
// This is used to prevent multiple simultaneous attempts to connect to the WebSocket, 
// which could lead to unexpected behavior or resource issues.

bool websocketConnecting = false;

// Reconnect duration starts at 3 seconds
int reconnectDuration = 3;

// This function is responsible for establishing a connection to a WebSocket server.
void connectWebsockets() async {

  // Check if a connection attempt is already in progress. If so, exit the function
  // early to prevent another concurrent attempt. This is important for maintaining
  // control over the connection process and avoiding unnecessary network traffic.
  
  if (websocketConnecting) {
    return; 
  }

  // Set the flag to true, indicating that a connection attempt is now underway.
  
  websocketConnecting = true;
  log("Attempting to connect to WebSocket");

  // Parse the WebSocket URL from a predefined constant. This URL is where the client
  // will attempt to establish the WebSocket connection.
  
  final wsUrl = Uri.parse(ApiConstants.WSOCKET);

  // Connect to the WebSocket server at the specified URL.
  // The pingInterval is set to send a "ping" message every 15 seconds to keep the 
  // connection alive and check its health. The connectTimeout is set to 20 seconds,
  // meaning the connection attempt will time out if not established within this duration.
  
  channel = IOWebSocketChannel.connect(
    wsUrl,
    pingInterval: Duration(seconds: 15),
    connectTimeout: Duration(seconds: 20)
  );

  try {
  
    // Await the ready property of the channel, which is a Future that completes when
    // the WebSocket connection is successfully established. This ensures that the 
    // following code only runs after a successful connection.
    
    await channel!.ready;
    print('WebSocket channel is ready');

    // Once the connection is established, set up the stream listeners to handle 
    // incoming messages, errors, and connection closures.
    
    setupWebSocketListeners();
    
  } catch (e) {
  
    // If an error occurs during the connection attempt or while waiting for the
    // connection to become ready, log the error and perform cleanup.
    
    print('WebSocket connection failed or stream error occurred: $e');

    // Set the channel to null to clean up and indicate that there is no active 
    // WebSocket connection.
    
    channel = null;

    // Reset the websocketConnecting flag to allow future connection attempts.
    
    websocketConnecting = false;

    // Retry connecting to the WebSocket. This creates resilience in the face of 
    // network issues or temporary server unavailability.
    
    Future.delayed(Duration(seconds: reconnectDuration), () {
      connectWebsockets();
      // Increment reconnectDuration by 3, up to a maximum of 60 seconds
      reconnectDuration = math.min(reconnectDuration + 3, 60);
      print("reconnectDuration: $reconnectDuration");
    });
    
  }
}