IceConnectionState remain stuck at checking when I stop and then again start the stream

Question

How can I troubleshoot and resolve issues with establishing a live video streaming connection between a React Native frontend, a NestJS backend, and a Kurento media server? The backend functions properly for web applications, but when attempting to connect from React Native, the initial connection succeeds. However, subsequent attempts to start the video stream fail. Restarting the Kurento media server temporarily resolves the issue, but only for the initial connection. When I start it for second time iceConnectionState stuck at checking.

My react native code is given below

import React, { useEffect, useRef, useState } from "react";
import { LogBox, PermissionsAndroid, Platform, View } from "react-native";
import { Button } from "../../components";
import { RTCView, RTCPeerConnection, mediaDevices } from 'react-native-webrtc';
import { io } from "socket.io-client";

LogBox.ignoreLogs(['Warning: ...']); // Ignore log notification by message
LogBox.ignoreAllLogs();

export const StreamingScreen = () => {
  const [localStream, setLocalStream] = useState<any>(null);
  const [isPermissionGranted, setIsPermissionGranted] = useState(false);
  const socket = useRef<any>(null);
  const peerConnection = useRef<any>(null);
  let stream:any = null

  const requestMicrophonePermission = async () => {
    if (Platform.OS === 'android') {
      try {
        const granted = await PermissionsAndroid.request(
          PermissionsAndroid.PERMISSIONS.RECORD_AUDIO,
          {
            title: 'Microphone Permission',
            message: 'This app needs access to your microphone.',
            buttonNeutral: 'Ask Me Later',
            buttonNegative: 'Cancel',
            buttonPositive: 'OK',
          }
        );
        setIsPermissionGranted(granted === PermissionsAndroid.RESULTS.GRANTED);
      } catch (err) {
        console.warn(err);
      }
    } else {
      setIsPermissionGranted(true);
    }
  };

  useEffect(() => {
    console.log('Component is mounted');
    requestMicrophonePermission();
    socket.current = io('http://localhost:3333/presenter');

    socket.current.on('messageToClient', handleMessageFromServer);

    return () => {
      handleStop();
      socket.current.close();
    };
  }, []);

  const handleMessageFromServer = (message: any) => {
    const parsedMessage = message;
    switch (parsedMessage.id) {
      case 'presenterResponse':
        handlePresenterResponse(parsedMessage);
        break;
      case 'stopCommunication':
        handleStop();
        break;
      case 'iceCandidate':
        handleIceCandidate(parsedMessage.candidate);
        break;
      default:
        console.error('Unrecognized message', parsedMessage);
    }
  };

  const handlePresenterResponse = (message: any) => {
    if (message.response !== 'accepted') {
      const errorMsg = message.message ? message.message : 'Unknown error';
      console.warn('Call not accepted for the following reason: ' + errorMsg);
      handleStop();
    } else {
      if (peerConnection.current) {
        peerConnection.current.setRemoteDescription({ type: 'answer', sdp: message.sdpAnswer })
          .then(() => {
            console.log('Remote description set successfully');
          })
          .catch((error: any) => {
            console.error('Error setting remote description:', error);
          });
      } else {
        console.error('peerConnection is null when trying to process answer.');
      }
    }
  };

  const handleIceCandidate = (candidate: any) => {
    if (peerConnection.current) {
      console.log("Checking ",candidate)
      peerConnection.current.addIceCandidate(candidate);
    }
  };

  const handleStart = async () => {
    try {
      stream = await mediaDevices.getUserMedia({ video: { facingMode: 'user' }, audio: true });
      setLocalStream(stream);
      console.log('Local stream after setting:', localStream);
      peerConnection.current = new RTCPeerConnection({
        iceServers: [
          { urls: 'stun:stun.l.google.com:19302' },
          { urls: 'stun:stun1.l.google.com:19302' },
          { urls: 'stun:stun2.l.google.com:19302' },
          { urls: 'turn:159.223.166.124:3478', credential: 'test', username: 'test123' },
        ],
      });

      stream.getTracks().forEach((track:any) => {
        peerConnection.current.addTrack(track, stream);
      });

      peerConnection.current.oniceconnectionstatechange = (event:any) => {
        console.log('ICE connection state:', peerConnection.current.iceConnectionState);
        console.log('After closing',peerConnection);
      } 

      peerConnection.current.onicecandidate = (event: any) => {
        if (event.candidate) {
          const message = { id: 'onIceCandidate', candidate: event.candidate.toJSON(), sessionId: 1 };
          sendMessage(message);
        }
      };
      const offer = await peerConnection.current.createOffer();
      await peerConnection.current.setLocalDescription(offer);
      socket.current.emit('message', JSON.stringify({ id: 'presenter', sdpOffer: offer.sdp, sessionId: 1 }));
    } catch (error) {
      console.error('Error starting stream:', error);
    }
  };
  
  const handleStop = async () => {
    if (peerConnection.current) {
      const message = { id: 'stop', sessionId: 1 };
      sendMessage(message);
      console.log(peerConnection)
      stream.getTracks().forEach((track:any) => {
        track.stop();
      });
      stream.release();
      setLocalStream(null);
      await peerConnection.current.close();
    }
  };
  
  const sendMessage = (message: any) => {
    socket.current.emit('message', JSON.stringify(message));
  };

  return (
    <View>
      {localStream && <RTCView streamURL={localStream.toURL()} style={{ width: 200, height: 200 }} />}
      <Button onPress={handleStart} title="Start" type="primary" size="large" />
      <Button onPress={handleStop} title="Stop" type="secondary" size="large" />
    </View>
  );
};

"react": "18.2.0", "react-native": "0.73.2", "react-native-webrtc": "^118.0.1", "socket.io-client": "^4.7.4"

How can I modify this code so that I can stop and start the stream again.