I’m working on a desktop app using Python and aiortc. The idea behind creating this app is to enable screen sharing of a specific portion of the screen.

I have successfully connected to the WebSocket and sent an SDP offer, and I have received the SDP answer from the BBB(BigBlueButton) WebRTC. However, the screen sharing doesn’t always work. Even after receiving the SDP answer, the screen is shared only after several re-runs of the project, and it only works once.
Any assistance would be greatly appreciated. Thank you in advance!

async def connect(self):
    """Establish a connection to the WebSocket server."""
    try:
        self.websocket = await websockets.connect(self.ws_url, extra_headers={"Cookie": self.cookies})
        logger.info(f"Connected to WebSocket server at {self.ws_url}")

        # Setup event handlers for ICE candidates
        @self.pc.on("icecandidate")
        async def on_icecandidate(candidate):
            if candidate:
                message = {
                    'id': 'onIceCandidate',
                    'candidate': candidate.toJSON()
                }
                await self.send_message(message)
                logger.info(f"Sent ICE candidate: {candidate}")

    except Exception as error:
        logger.error(f"Failed to connect to WebSocket server: {error}")

async def send_message(self, message):
    """Send a message over the WebSocket connection."""
    json_message = json.dumps(message)
    try:
        await self.websocket.send(json_message)
        logger.info(f"Sent message: {json_message}")
    except Exception as error:
        logger.error(f"Failed to send WebSocket message ({self.type}): {error}")

async def generate_local_description(self):
    """Generate and return the local SDP description."""
    for transceiver in self.pc.getTransceivers():
        if transceiver.kind == "video":
            video_transceiver = transceiver
            break
    else:
        raise ValueError("No video transceiver found")

        # Get available codecs
    capabilities = RTCRtpSender.getCapabilities("video")
    available_codecs = capabilities.codecs

    # Define the codecs you want to use, in order of preference
    preferred_codec_names = ["VP8", "H264", "VP9"]

    # Filter and order codecs based on preferences and availability
    preferred_codecs = []
    for codec_name in preferred_codec_names:
        for available_codec in available_codecs:
            if codec_name in available_codec.mimeType:
                preferred_codecs.append(available_codec)
                break

    if not preferred_codecs:
        raise ValueError("No preferred codecs are available")

    # Set the codec preferences
    video_transceiver.setCodecPreferences(preferred_codecs)

    offer = await self.pc.createOffer()
    await self.pc.setLocalDescription(offer)
    await self.wait_for_ice_gathering()
    logger.info(f"Generated local description: {self.pc.localDescription.sdp}")
    return self.pc.localDescription

async def wait_for_ice_gathering(self):
    """Wait for ICE gathering to complete."""
    await asyncio.sleep(0.5)  # Small delay to ensure ICE candidates are gathered
    while True:
        connection_state = self.pc.iceConnectionState
        gathering_state = self.pc.iceGatheringState
        logger.debug(f"ICE connection state: {connection_state}, ICE gathering state: {gathering_state}")
        if gathering_state == "complete":
            break
        await asyncio.sleep(0.1)

async def send_local_description(self):
    """Send the local SDP description to the WebSocket server."""
    local_description = await self.generate_local_description()
    sdp = modify_sdp(local_description.sdp)
    message = {
        "id": self.id,
        "type": self.type,
        "contentType": self.contentType,
        "role": self.role,
        "internalMeetingId": self.internalMeetingId,
        "voiceBridge": self.voiceBridge,
        "userName": self.userName,
        "callerName": self.callerName,
        "sdpOffer": sdp,
        "hasAudio": self.hasAudio,
        "bitrate": self.bitrate
    }
    ping = {"id": "ping"}
    await self.send_message(ping)
    await self.send_message(message)

async def receive_messages(self):
    try:
        async for message in self.websocket:
            logger.info(f"Received message: {message}")
            await self.handle_message(message)
            data = ast.literal_eval(message)
            if data.get('id') == 'playStart':
                self.screen_sharing = True
                pass
    except Exception as error:
        logger.error(f"Error receiving messages: {error}")
    finally:
        await self.websocket.close()
        logger.info("WebSocket connection closed")

async def handle_message(self, message):
    data = json.loads(message)
    logger.info(f"Handling message: {data}")

    if data['id'] == 'pong':
        logger.info("Received pong message")
    elif data['id'] == 'startResponse' and data['response'] == 'accepted':
        sdp_answer = RTCSessionDescription(sdp=data['sdpAnswer'], type='answer')
        await self.pc.setRemoteDescription(sdp_answer)
        logger.info(f"Set remote description: {sdp_answer}")
    elif data['id'] == 'iceCandidate':
        candidate = RTCIceCandidate(
            sdpMid=data['candidate']['sdpMid'],
            sdpMLineIndex=data['candidate']['sdpMLineIndex'],
            candidate=data['candidate']['candidate']
        )
        await self.pc.addIceCandidate(candidate)
        logger.info(f"Added remote ICE candidate: {candidate}")

def _parse_turn_servers(self):
    """Parse and return the TURN server configurations."""
    ice_servers = []
    for turn_server in self.turn_servers:
        ice_servers.append(RTCIceServer(
            urls=[turn_server["url"]],
            username=turn_server["username"],
            credential=turn_server["password"]
        ))
    return ice_servers

async def stop(self):
    """Stop the screenshare session."""
    if self.status == 'MEDIA_STOPPED':
        logger.warn('Screenshare session already stopped')
        return

    if self.status == 'MEDIA_STOPPING':
        logger.warn('Screenshare session already stopping')
        await self.wait_until_stopped()
        logger.info('Screenshare delayed stop resolution for queued stop call')
        return

    if self.status == 'MEDIA_STARTING':
        logger.warn('Screenshare session still starting on stop, wait.')
        if not self._stopActionQueued:
            self._stopActionQueued = True
            await self.wait_until_negotiated()
            logger.info('Screenshare delayed MEDIA_STARTING stop resolution')
            await self.stop_presenter()
        else:
            await self.wait_until_stopped()
            logger.info('Screenshare delayed stop resolution for queued stop call')
        return

    await self.stop_presenter()

async def wait_until_stopped(self):
    """Wait until the media is stopped."""
    while self.status != 'MEDIA_STOPPED':
        await asyncio.sleep(0.1)

async def wait_until_negotiated(self):
    """Wait until the media is negotiated."""
    while self.status != 'MEDIA_NEGOTIATED':
        await asyncio.sleep(0.1)

async def stop_presenter(self):
    """Stop the presenter and handle errors."""
    try:
        # Add your logic to stop the presenter
        self.status = 'MEDIA_STOPPING'
        # Simulate stopping action
        await asyncio.sleep(1)  # Simulate delay
        self.status = 'MEDIA_STOPPED'
        logger.info('Screenshare stopped successfully')
    except Exception as error:
        logger.error(f'Screenshare stop failed: {error}')
        self.status = 'MEDIA_STOPPED'

async def restart_ice(self):
    pass
async def start_screen_share(self):
    logger.info("Starting screen share")
    try:
        self.screen_share_track = ScreenShareTrack()
        self.screen_share_sender = self.pc.addTrack(self.screen_share_track)
        logger.info(f"Added screen share track to peer connection: {self.screen_share_sender}")

        await self.send_local_description()
        await self.receive_messages()
        self.screen_sharing = True
        await asyncio.create_task(self.capture_loop())


        logger.info("Screen share started successfully")
    except Exception as e:
        logger.error(f"Error starting screen share: {e}")

async def capture_loop(self):
    while self.screen_sharing:
        try:
            frame = await self.screen_share_track.capture_frame()
            # Here you can add any additional processing if needed
            await asyncio.sleep(0)  # Yield control to the event loop
        except Exception as e:
            logger.error(f"Error in screen capture loop: {e}")
            if self.screen_sharing:
                await asyncio.sleep(1)  # Wait before retrying if still sharing
            else:
                break

    logger.info("Screen sharing stopped")

async def stop_screen_share(self):
    self.screen_sharing = False
    if self.screen_share_sender:
        self.pc.removeTrack(self.screen_share_sender)
    if self.screen_share_track:
        await self.screen_share_track.close()
    self.screen_share_track = None
    self.screen_share_sender = None
    logger.info("Screen share stopped")`
    
   class ScreenShareTrack(VideoStreamTrack):
kind = "video"

def __init__(self, fps=30, width=None, height=None):
    super().__init__()
    self.fps = fps
    self.width = width
    self.height = height
    self.sct = mss.mss()
    self.monitor = self.sct.monitors[1]
    self.monitor = {"top": 50, "left": 250, "width": 800, "height": 600}
    self.frame_interval = 1 / self.fps
    self._last_frame_time = 0
    self.frame_count = 0

async def recv(self):
    frame = await self.capture_frame()
    self.frame_count += 1
    if self.frame_count % 30 == 0:  # Log every 30 frames
        logger.info(f"Captured frame {self.frame_count}")
    return frame

async def capture_frame(self, output_format="bgr24"):
    pts, time_base = await self.next_timestamp()

    now = time.time()
    if now - self._last_frame_time < self.frame_interval:
        await asyncio.sleep(self.frame_interval - (now - self._last_frame_time))
    self._last_frame_time = time.time()

    frame = np.array(self.sct.grab(self.monitor))

    # Remove alpha channel if present
    if frame.shape[2] == 4:
        frame = frame[:, :, :3]

    if output_format == "bgr24":
        # MSS captures in BGR format, so we can use it directly
        pass
    elif output_format == "rgb24":
        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
    elif output_format in ["yuv420p", "yuvj420p", "yuv422p", "yuv444p"]:
        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2YUV)
    elif output_format == "nv12":
        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2YUV_I420)
    elif output_format == "nv21":
        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2YUV_YV12)
    elif output_format == "gray":
        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    elif output_format in ["rgba", "bgra"]:
        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGBA if output_format == "rgba" else cv2.COLOR_BGR2BGRA)
    else:
        raise ValueError(f"Unsupported output format: {output_format}")

    frame = VideoFrame.from_ndarray(frame, format=output_format)
    frame.pts = pts
    frame.time_base = time_base
    return frame

async def close(self):
    self.sct.close()