diff --git a/src/components/widgets/VideoPlayer.vue b/src/components/widgets/VideoPlayer.vue
index d7c9bf554..937d97db5 100644
--- a/src/components/widgets/VideoPlayer.vue
+++ b/src/components/widgets/VideoPlayer.vue
@@ -3,12 +3,27 @@
     <div v-if="nameSelectedStream === undefined" class="no-video-alert">
       <span>No video stream selected.</span>
     </div>
-    <div v-else-if="!namesAvailableStreams.includes(nameSelectedStream)" class="no-video-alert">
+    <div
+      v-else-if="!namesAvailableStreams.isEmpty() && !namesAvailableStreams.includes(nameSelectedStream)"
+      class="no-video-alert"
+    >
       <p>The selected stream is not available.</p>
       <p>Please check its source or select another stream.</p>
     </div>
-    <div v-else-if="mediaStream === undefined" class="no-video-alert">
-      <span>Loading stream...</span>
+    <div v-else-if="!streamConnected" class="no-video-alert">
+      <div class="no-video-alert">
+        <p>
+          <span class="text-xl font-bold">Server status: </span>
+          <span>{{ serverStatus }}</span>
+        </p>
+        <p>
+          <span class="text-xl font-bold">Stream status: </span>
+          <span>{{ streamStatus }}</span>
+        </p>
+      </div>
+    </div>
+    <div v-else class="no-video-alert">
+      <p>Loading stream...</p>
     </div>
     <video ref="videoElement" muted autoplay playsinline disablePictureInPicture>
       Your browser does not support the video tag.
@@ -90,6 +105,7 @@ const widget = toRefs(props).widget
 const nameSelectedStream = ref<string | undefined>()
 const videoElement = ref<HTMLVideoElement | undefined>()
 const mediaStream = ref<MediaStream | undefined>()
+const streamConnected = ref(false)
 
 onBeforeMount(() => {
   // Set the default initial values that are not present in the widget options
@@ -123,6 +139,11 @@ const streamConnectionRoutine = setInterval(() => {
   if (!isEqual(updatedMediaStream, mediaStream.value)) {
     mediaStream.value = updatedMediaStream
   }
+
+  const updatedStreamState = videoStore.getStreamData(widget.value.options.streamName)?.connected ?? false
+  if (updatedStreamState !== streamConnected.value) {
+    streamConnected.value = updatedStreamState
+  }
 }, 1000)
 onBeforeUnmount(() => clearInterval(streamConnectionRoutine))
 
@@ -158,6 +179,16 @@ const rotateStyle = computed(() => {
 const transformStyle = computed(() => {
   return `${flipStyle.value} ${rotateStyle.value}`
 })
+
+const serverStatus = computed(() => {
+  if (nameSelectedStream.value === undefined) return 'Unknown.'
+  return videoStore.getStreamData(nameSelectedStream.value)?.webRtcManager.signallerStatus ?? 'Unknown.'
+})
+
+const streamStatus = computed(() => {
+  if (nameSelectedStream.value === undefined) return 'Unknown.'
+  return videoStore.getStreamData(nameSelectedStream.value)?.webRtcManager.streamStatus ?? 'Unknown.'
+})
 </script>
 
 <style scoped>
diff --git a/src/composables/webRTC.ts b/src/composables/webRTC.ts
index 70530ae12..040366524 100644
--- a/src/composables/webRTC.ts
+++ b/src/composables/webRTC.ts
@@ -11,18 +11,14 @@ import type { Stream } from '@/libs/webrtc/signalling_protocol'
  *
  */
 interface startStreamReturn {
-  /**
-   * A list of Available WebRTC streams from Mavlink Camera Manager to be chosen from
-   */
-  availableStreams: Ref<Array<Stream>>
-  /**
-   * A list of IPs from WebRTC candidates that are available
-   */
-  availableICEIPs: Ref<Array<string>>
   /**
    * MediaStream object, if WebRTC stream is chosen
    */
   mediaStream: Ref<MediaStream | undefined>
+  /**
+   * Connection state
+   */
+  connected: Ref<boolean>
   /**
    * Current status of the signalling
    */
@@ -37,11 +33,12 @@ interface startStreamReturn {
  *
  */
 export class WebRTCManager {
-  private availableStreams: Ref<Array<Stream>> = ref(new Array<Stream>())
+  public availableStreams: Ref<Array<Stream>> = ref(new Array<Stream>())
   public availableICEIPs: Ref<Array<string>> = ref(new Array<string>())
   private mediaStream: Ref<MediaStream | undefined> = ref()
-  private signallerStatus: Ref<string> = ref('waiting...')
-  private streamStatus: Ref<string> = ref('waiting...')
+  public signallerStatus: Ref<string> = ref('waiting...')
+  public streamStatus: Ref<string> = ref('waiting...')
+  private connected = ref(false)
   private consumerId: string | undefined
   private streamName: string | undefined
   private session: Session | undefined
@@ -126,9 +123,8 @@ export class WebRTCManager {
     })
 
     return {
-      availableStreams: this.availableStreams,
-      availableICEIPs: this.availableICEIPs,
       mediaStream: this.mediaStream,
+      connected: this.connected,
       signallerStatus: this.signallerStatus,
       streamStatus: this.streamStatus,
     }
@@ -161,12 +157,9 @@ export class WebRTCManager {
     this.hasEnded = false
     // Requests a new consumer ID
     if (this.consumerId === undefined) {
-      this.signaller.requestConsumerId(
-        (newConsumerId: string): void => {
-          this.consumerId = newConsumerId
-        },
-        (newStatus: string): void => this.updateStreamStatus(newStatus)
-      )
+      this.signaller.requestConsumerId((newConsumerId: string): void => {
+        this.consumerId = newConsumerId
+      })
     }
 
     this.availableStreams.value = []
@@ -189,10 +182,6 @@ export class WebRTCManager {
 
     // Asks for available streams, which will trigger the consumer "onAvailableStreams" callback
     window.setTimeout(() => {
-      if (!this.waitingForAvailableStreamsAnswer) {
-        return
-      }
-
       // Register the parser to update the list of streams when the signaller receives the answer
       this.signaller.parseAvailableStreamsAnswer((availableStreams): void => {
         if (!this.waitingForAvailableStreamsAnswer) {
@@ -234,6 +223,13 @@ export class WebRTCManager {
     console.debug('Capabilities:', event.track.getCapabilities?.())
   }
 
+  /**
+   * Called when a peer is connected
+   */
+  private onPeerConnected(): void {
+    this.connected.value = true
+  }
+
   /**
    *
    * @param {Stream} stream
@@ -243,14 +239,9 @@ export class WebRTCManager {
     console.debug(`[WebRTC] Requesting stream:`, stream)
 
     // Requests a new Session ID
-    this.signaller.requestSessionId(
-      consumerId,
-      stream.id,
-      (receivedSessionId: string): void => {
-        this.onSessionIdReceived(stream, stream.id, receivedSessionId)
-      },
-      (newStatus: string): void => this.updateStreamStatus(newStatus)
-    )
+    this.signaller.requestSessionId(consumerId, stream.id, (receivedSessionId: string): void => {
+      this.onSessionIdReceived(stream, stream.id, receivedSessionId)
+    })
 
     this.hasEnded = false
   }
@@ -331,22 +322,18 @@ export class WebRTCManager {
       this.rtcConfiguration,
       this.selectedICEIPs,
       (event: RTCTrackEvent): void => this.onTrackAdded(event),
+      (): void => this.onPeerConnected(),
       (availableICEIPs: string[]) => (this.availableICEIPs.value = availableICEIPs),
-      (_sessionId, reason) => this.onSessionClosed(reason)
+      (_sessionId, reason) => this.onSessionClosed(reason),
+      (status: string): void => this.updateStreamStatus(status)
     )
 
     // Registers Session callback for the Signaller endSession parser
-    this.signaller.parseEndSessionQuestion(
-      this.consumerId!,
-      producerId,
-      this.session.id,
-      (sessionId, reason) => {
-        console.debug(`[WebRTC] Session ${sessionId} ended. Reason: ${reason}`)
-        this.session = undefined
-        this.hasEnded = true
-      },
-      (newStatus: string): void => this.updateSignallerStatus(newStatus)
-    )
+    this.signaller.parseEndSessionQuestion(this.consumerId!, producerId, this.session.id, (sessionId, reason) => {
+      console.debug(`[WebRTC] Session ${sessionId} ended. Reason: ${reason}`)
+      this.session = undefined
+      this.hasEnded = true
+    })
 
     // Registers Session callbacks for the Signaller Negotiation parser
     this.signaller.parseNegotiation(
@@ -354,8 +341,7 @@ export class WebRTCManager {
       producerId,
       this.session.id,
       this.session.onIncomingICE.bind(this.session),
-      this.session.onIncomingSDP.bind(this.session),
-      (newStatus: string): void => this.updateSignallerStatus(newStatus)
+      this.session.onIncomingSDP.bind(this.session)
     )
 
     const msg = `Session ${this.session.id} successfully started`
diff --git a/src/libs/webrtc/session.ts b/src/libs/webrtc/session.ts
index eebf382b5..f81f0bd30 100644
--- a/src/libs/webrtc/session.ts
+++ b/src/libs/webrtc/session.ts
@@ -5,6 +5,8 @@ import type { Stream } from '@/libs/webrtc/signalling_protocol'
 type OnCloseCallback = (sessionId: string, reason: string) => void
 type OnTrackAddedCallback = (event: RTCTrackEvent) => void
 type onNewIceRemoteAddressCallback = (availableICEIPs: string[]) => void
+type OnStatusChangeCallback = (status: string) => void
+type OnPeerConnectedCallback = () => void
 
 /**
  * An abstraction for the Mavlink Camera Manager WebRTC Session
@@ -21,8 +23,10 @@ export class Session {
   private selectedICEIPs: string[]
   public rtcConfiguration: RTCConfiguration
   public onTrackAdded?: OnTrackAddedCallback
+  public onPeerConnected?: OnPeerConnectedCallback
   public onNewIceRemoteAddress?: onNewIceRemoteAddressCallback
   public onClose?: OnCloseCallback
+  public onStatusChange?: OnStatusChangeCallback
 
   /**
    * Creates a new Session instance, connecting with a given Stream
@@ -33,8 +37,10 @@ export class Session {
    * @param {RTCConfiguration} rtcConfiguration - Configuration for the RTC connection, such as Turn and Stun servers
    * @param {string[]} selectedICEIPs - A whitelist for ICE IP addresses, ignored if empty
    * @param {OnTrackAddedCallback} onTrackAdded - An optional callback for when a track is added to this session
+   * @param {OnPeerConnectedCallback} onPeerConnected - An optional callback for when the peer is connected
    * @param {onNewIceRemoteAddressCallback} onNewIceRemoteAddress - An optional callback for when a new ICE candidate IP addres is available
    * @param {OnCloseCallback} onClose - An optional callback for when this session closes
+   * @param {OnStatusChangeCallback} onStatusChange - An optional callback for internal status change
    */
   constructor(
     sessionId: string,
@@ -44,15 +50,19 @@ export class Session {
     rtcConfiguration: RTCConfiguration,
     selectedICEIPs: string[] = [],
     onTrackAdded?: OnTrackAddedCallback,
+    onPeerConnected?: OnPeerConnectedCallback,
     onNewIceRemoteAddress?: onNewIceRemoteAddressCallback,
-    onClose?: OnCloseCallback
+    onClose?: OnCloseCallback,
+    onStatusChange?: OnStatusChangeCallback
   ) {
     this.id = sessionId
     this.consumerId = consumerId
     this.stream = stream
     this.onTrackAdded = onTrackAdded
+    this.onPeerConnected = onPeerConnected
     this.onNewIceRemoteAddress = onNewIceRemoteAddress
     this.onClose = onClose
+    this.onStatusChange = onStatusChange
     this.status = ''
     this.signaller = signaller
     this.rtcConfiguration = rtcConfiguration
@@ -195,16 +205,22 @@ export class Session {
       !this.selectedICEIPs.isEmpty() &&
       !this.selectedICEIPs.some((address) => candidate.candidate!.includes(address))
     ) {
+      this.onStatusChange?.(`Ignoring ICE candidate ${candidate.candidate}`)
       console.debug(`[WebRTC] [Session] ICE candidate ignored: ${JSON.stringify(candidate, null, 4)}`)
       return
     }
 
     this.peerConnection
       .addIceCandidate(candidate)
-      .then(() => console.debug(`[WebRTC] [Session] ICE candidate added: ${JSON.stringify(candidate, null, 4)}`))
-      .catch((reason) =>
+      .then(() => {
+        const msg = `ICE candidate added.`
+        console.debug(`[WebRTC] [Session] ${msg} ${JSON.stringify(candidate, null, 4)}`)
+        this.onStatusChange?.(msg)
+      })
+      .catch((reason) => {
         console.error(`[WebRTC] [Session] Failed adding ICE candidate ${candidate}. Reason: ${reason}`)
-      )
+        this.onStatusChange?.(`Failed adding ICE candidate ${candidate}. Reason: ${reason}`)
+      })
   }
 
   /**
@@ -225,7 +241,9 @@ export class Session {
    */
   private onIceCandidateError(event: Event): void {
     const ev = event as RTCPeerConnectionIceErrorEvent
-    console.debug(`[WebRTC] [Session] ICE Candidate "${ev.url}" negotiation failed`)
+    const msg = `ICE Candidate "${ev.url}" negotiation failed.`
+    console.debug(`[WebRTC] [Session] ${msg}`)
+    this.onStatusChange?.(msg)
   }
 
   /**
@@ -242,7 +260,9 @@ export class Session {
    */
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   private onNegotiationNeeded(_event: Event): void {
-    console.debug('[WebRTC] [Session] Peer Connection is waiting for negotiation...')
+    const msg = 'Peer Connection is waiting for negotiation...'
+    console.debug(msg)
+    this.onStatusChange?.(msg)
   }
 
   /**
@@ -251,6 +271,7 @@ export class Session {
   private onIceConnectionStateChange(): void {
     const msg = `ICEConnection state changed to "${this.peerConnection.iceConnectionState}"`
     console.debug('[WebRTC] [Session] ' + msg)
+    this.onStatusChange?.(msg)
 
     if (this.peerConnection.iceConnectionState === 'failed') {
       this.peerConnection.restartIce()
@@ -263,6 +284,11 @@ export class Session {
   private onConnectionStateChange(): void {
     const msg = `RTCPeerConnection state changed to "${this.peerConnection.connectionState}"`
     console.debug('[WebRTC] [Session] ' + msg)
+    this.onStatusChange?.(msg)
+
+    if (this.peerConnection.connectionState === 'connected') {
+      this.onPeerConnected?.()
+    }
 
     if (this.peerConnection.connectionState === 'failed') {
       this.onClose?.(this.id, 'PeerConnection failed')
@@ -283,7 +309,9 @@ export class Session {
    */
   private onIceGatheringStateChange(): void {
     if (this.peerConnection.iceGatheringState === 'complete') {
-      console.debug(`[WebRTC] [Session] ICE gathering completed for session ${this.id}`)
+      const msg = `ICE gathering completed for session ${this.id}`
+      console.debug(`[WebRTC] [Session] ${msg}`)
+      this.onStatusChange?.(msg)
     }
   }
 
diff --git a/src/libs/webrtc/signaller.ts b/src/libs/webrtc/signaller.ts
index 4858b5c9a..c8ac018e3 100644
--- a/src/libs/webrtc/signaller.ts
+++ b/src/libs/webrtc/signaller.ts
@@ -123,12 +123,8 @@ export class Signaller {
   /**
    * Requests the signalling server for a new consumer ID
    * @param {OnConsumerIdReceivedCallback} onConsumerIdReceived - A callback for when the requested consumer id is received
-   * @param {OnStatusChangeCallback} onStatusChanged - An optional callback for when the status of this function has changed
    */
-  public requestConsumerId(
-    onConsumerIdReceived: OnConsumerIdReceivedCallback,
-    onStatusChanged?: OnStatusChangeCallback
-  ): void {
+  public requestConsumerId(onConsumerIdReceived: OnConsumerIdReceivedCallback): void {
     // eslint-disable-next-line @typescript-eslint/no-this-alias
     const signaller = this
     this.addEventListener('message', function consumerIdListener(ev: MessageEvent): void {
@@ -148,12 +144,12 @@ export class Signaller {
         signaller.removeEventListener('message', consumerIdListener)
 
         const consumerId: string = answer.content.id
-        onStatusChanged?.(`Consumer Id arrived: ${consumerId}`)
+        signaller.onStatusChange?.(`Consumer Id arrived: ${consumerId}`)
         onConsumerIdReceived(consumerId)
       } catch (error) {
         const errorMsg = `Failed receiving PeerId Answer Message. Error: ${error}. Data: ${ev.data}`
         console.error('[WebRTC] [Signaller] ' + errorMsg)
-        onStatusChanged?.(errorMsg)
+        signaller.onStatusChange?.(errorMsg)
       }
     })
 
@@ -167,11 +163,11 @@ export class Signaller {
     try {
       this.ws.send(JSON.stringify(message))
       console.debug('[WebRTC] [Signaller] Message sent:', message)
-      onStatusChanged?.('Consumer Id requested, waiting answer...')
+      signaller.onStatusChange?.('Consumer Id requested, waiting answer...')
     } catch (reason) {
       const error = `Failed requesting peer id. Reason: ${reason}`
       console.error('[WebRTC] [Signaller] ' + error)
-      onStatusChanged?.(error)
+      signaller.onStatusChange?.(error)
     }
   }
 
@@ -185,9 +181,8 @@ export class Signaller {
 
   /**
    * Requests the signalling server for the list of the streams available
-   * @param {OnStatusChangeCallback} onStatusChanged - An optional callback for when the status of this function has changed
    */
-  public requestStreams(onStatusChanged?: OnStatusChangeCallback): void {
+  public requestStreams(): void {
     const message: Message = {
       type: 'question',
       content: {
@@ -201,11 +196,11 @@ export class Signaller {
       }
       this.ws.send(JSON.stringify(message))
       console.debug('[WebRTC] [Signaller] Message sent:', message)
-      onStatusChanged?.('StreamsAvailable requested')
+      this.onStatusChange?.('StreamsAvailable requested')
     } catch (error) {
       const errorMsg = `Failed requesting available streams. Reason: ${error}`
       console.error('[WebRTC] [Signaller] ' + errorMsg)
-      onStatusChanged?.(errorMsg)
+      this.onStatusChange?.(errorMsg)
     }
   }
 
@@ -214,13 +209,11 @@ export class Signaller {
    * @param {string} consumerId - Unique ID of the consumer, given by the signalling server
    * @param {string} producerId - Unique ID of the producer, given by the signalling server
    * @param {OnSessionIdReceivedCallback} onSessionIdReceived - A callback for when the requested session id is received
-   * @param {OnStatusChangeCallback} onStatusChanged - An optional callback for when the status of this function has changed
    */
   public requestSessionId(
     consumerId: string,
     producerId: string,
-    onSessionIdReceived: OnSessionIdReceivedCallback,
-    onStatusChanged?: OnStatusChangeCallback
+    onSessionIdReceived: OnSessionIdReceivedCallback
   ): void {
     // eslint-disable-next-line @typescript-eslint/no-this-alias
     const signaller = this
@@ -246,12 +239,12 @@ export class Signaller {
         // Only remove after getting the right message
         signaller.removeEventListener('message', sessionStartListener)
 
-        onStatusChanged?.(`Session Id arrived: ${sessionId}`)
+        signaller.onStatusChange?.(`Session Id arrived: ${sessionId}`)
         onSessionIdReceived(sessionId)
       } catch (error) {
         const errorMsg = `Failed receiving StartSession Answer Message. Error: ${error}. Data: ${ev.data}`
         console.error('[WebRTC] [Signaller] ' + errorMsg)
-        onStatusChanged?.(errorMsg)
+        signaller.onStatusChange?.(errorMsg)
         return
       }
     })
@@ -270,11 +263,11 @@ export class Signaller {
     try {
       this.ws.send(JSON.stringify(message))
       console.debug('[WebRTC] [Signaller] Message sent:', message)
-      onStatusChanged?.('Session Id requested, waiting answer...')
+      signaller.onStatusChange?.('Session Id requested, waiting answer...')
     } catch (reason) {
       const error = `Failed requesting Session Id. Reason: ${reason}`
       console.error('[WebRTC] [Signaller] ' + error)
-      onStatusChanged?.(error)
+      signaller.onStatusChange?.(error)
     }
   }
 
@@ -284,15 +277,8 @@ export class Signaller {
    * @param {string} consumerId - Unique ID of the consumer, given by the signalling server
    * @param {string} producerId - Unique ID of the producer, given by the signalling server
    * @param {RTCIceCandidate} ice - The ICE candidate to be sent to the signalling server, given by the consumer/client side
-   * @param {OnStatusChangeCallback} onStatusChanged - An optional callback for when the status of this function has changed
    */
-  public sendIceNegotiation(
-    sessionId: string,
-    consumerId: string,
-    producerId: string,
-    ice: RTCIceCandidate,
-    onStatusChanged?: OnStatusChangeCallback
-  ): void {
+  public sendIceNegotiation(sessionId: string, consumerId: string, producerId: string, ice: RTCIceCandidate): void {
     const message: Message = {
       type: 'negotiation',
       content: {
@@ -311,11 +297,11 @@ export class Signaller {
     try {
       this.ws.send(JSON.stringify(message))
       console.debug('[WebRTC] [Signaller] Message sent:', message)
-      onStatusChanged?.('ICE Candidate sent')
+      this.onStatusChange?.('ICE Candidate sent')
     } catch (error) {
       const errorMsg = `Failed sending ICE Candidate. Reason: ${error}`
       console.error('[WebRTC] [Signaller] ' + errorMsg)
-      onStatusChanged?.(errorMsg)
+      this.onStatusChange?.(errorMsg)
     }
   }
 
@@ -325,14 +311,12 @@ export class Signaller {
    * @param {string} consumerId - Unique ID of the consumer, given by the signalling server
    * @param {string} producerId - Unique ID of the producer, given by the signalling server
    * @param {RTCSessionDescription} sdp - The SDP to be sent to the signalling server, given by the consumer/client side
-   * @param {OnStatusChangeCallback} onStatusChanged - An optional callback for when the status of this function has changed
    */
   public sendMediaNegotiation(
     sessionId: string,
     consumerId: string,
     producerId: string,
-    sdp: RTCSessionDescription,
-    onStatusChanged?: OnStatusChangeCallback
+    sdp: RTCSessionDescription
   ): void {
     const message: Message = {
       type: 'negotiation',
@@ -350,31 +334,12 @@ export class Signaller {
     try {
       this.ws.send(JSON.stringify(message))
       console.debug('[WebRTC] [Signaller] Message sent:', message)
-      onStatusChanged?.('ICE Candidate sent')
+      this.onStatusChange?.('ICE Candidate sent')
     } catch (error) {
       const errorMsg = `Failed sending SDP. Reason: ${error}`
       console.error('[WebRTC] [Signaller] ' + errorMsg)
-      onStatusChanged?.(errorMsg)
-    }
-  }
-
-  /**
-   * Parses a given "sessionStart" Asnwer received by the signalling server
-   * @param {MessageEvent} ev - Message to be parsed. This should be a "startSession" message
-   * @returns {string | undefined} - The Session ID received from the signalling server
-   */
-  public parseSessionStartAnswer(ev: MessageEvent): string | undefined {
-    const message: Message = JSON.parse(ev.data)
-    if (message.type !== 'answer') {
-      return
-    }
-
-    const answer: Answer = message.content
-    if (answer.type !== 'startSession') {
-      return
+      this.onStatusChange?.(errorMsg)
     }
-
-    return answer.content.session_id
   }
 
   /**
@@ -383,23 +348,18 @@ export class Signaller {
    * @param {string} producerId - Unique ID of the producer, given by the signalling server
    * @param {string} sessionId - Unique ID of the session, given by the signalling server
    * @param {OnSessionEndCallback} onSessionEnd - A callback for when an "endSession" message is received
-   * @param {OnStatusChangeCallback} onStatusChanged - An optional callback for when the status of this function has changed
    */
   public parseEndSessionQuestion(
     consumerId: string,
     producerId: string,
     sessionId: string,
-    onSessionEnd: OnSessionEndCallback,
-    onStatusChanged?: OnStatusChangeCallback
+    onSessionEnd: OnSessionEndCallback
   ): void {
     console.debug(
-      '[WebRTC] [Signaller] Registering parseEndSessionQuestion for ' +
+      '[WebRTC] [Signaller] Registering parseEndSessionQuestion callbacks for ' +
         `Consumer "${consumerId}", ` +
         `Producer "${producerId}", ` +
-        `Session "${sessionId}", ` +
-        'with callbacks:',
-      onSessionEnd,
-      onStatusChanged
+        `Session "${sessionId}", `
     )
     // eslint-disable-next-line @typescript-eslint/no-this-alias
     const signaller = this
@@ -429,12 +389,12 @@ export class Signaller {
         signaller.removeEventListener('message', endSessionListener)
 
         const reason = endSessionQuestion.reason
-        onStatusChanged?.('EndSession arrived')
+        signaller.onStatusChange?.('EndSession arrived')
         onSessionEnd?.(sessionId, reason)
       } catch (error) {
         const errorMsg = `Failed parsing received Message. Error: ${error}. Data: ${ev.data}`
         console.error('[WebRTC] [Signaller] ' + errorMsg)
-        onStatusChanged?.(errorMsg)
+        signaller.onStatusChange?.(errorMsg)
         return
       }
     })
@@ -447,25 +407,19 @@ export class Signaller {
    * @param {string} sessionId - Unique ID of the session, given by the signalling server
    * @param {OnIceNegotiationCallback} onIceNegotiation - An optional callback for when a "iceNegotiation" Negotiation is received
    * @param {OnMediaNegotiationCallback} onMediaNegotiation - An optional callback for when a "mediaNegotiation" Negotiation is received
-   * @param {OnStatusChangeCallback} onStatusChanged - An optional callback for when the status of this function has changed
    */
   public parseNegotiation(
     consumerId: string,
     producerId: string,
     sessionId: string,
     onIceNegotiation?: OnIceNegotiationCallback,
-    onMediaNegotiation?: OnMediaNegotiationCallback,
-    onStatusChanged?: OnStatusChangeCallback
+    onMediaNegotiation?: OnMediaNegotiationCallback
   ): void {
     console.debug(
-      '[WebRTC] [Signaller] Registering parseNegotiation for ' +
+      '[WebRTC] [Signaller] Registering parseNegotiation callbacks for ' +
         `Consumer "${consumerId}", ` +
         `Producer "${producerId}", ` +
-        `Session "${sessionId}", ` +
-        'with callbacks:',
-      onIceNegotiation,
-      onMediaNegotiation,
-      onStatusChanged
+        `Session "${sessionId}", `
     )
     this.addEventListener('message', (ev: MessageEvent): void => {
       try {
@@ -489,19 +443,19 @@ export class Signaller {
 
         switch (negotiation.type) {
           case 'iceNegotiation':
-            onStatusChanged?.('iceNegotiation arrived')
+            this.onStatusChange?.('iceNegotiation arrived')
             onIceNegotiation?.(negotiation.content.ice)
             break
 
           case 'mediaNegotiation':
-            onStatusChanged?.('mediaNegotiation arrived')
+            this.onStatusChange?.('mediaNegotiation arrived')
             onMediaNegotiation?.(negotiation.content.sdp)
             break
         }
       } catch (error) {
         const errorMsg = `Failed parsing received Message. Error: ${error}. Data: ${ev.data}`
         console.error('[WebRTC] [Signaller] ' + errorMsg)
-        onStatusChanged?.(errorMsg)
+        this.onStatusChange?.(errorMsg)
         return
       }
     })
@@ -510,17 +464,9 @@ export class Signaller {
   /**
    * Parses "availableStreams" Answer received from the signalling server
    * @param {OnAvailableStreamsCallback} onAvailableStreams - A callback for when an "availableStreams" Answer is received
-   * @param {OnStatusChangeCallback} onStatusChanged - An optional callback for when the status of this function has changed
    */
-  public parseAvailableStreamsAnswer(
-    onAvailableStreams: OnAvailableStreamsCallback,
-    onStatusChanged?: OnStatusChangeCallback
-  ): void {
-    console.debug(
-      `[WebRTC] [Signaller] Registering parseAvailableStreamsAnswer with callbacks:`,
-      onAvailableStreams,
-      onStatusChanged
-    )
+  public parseAvailableStreamsAnswer(onAvailableStreams: OnAvailableStreamsCallback): void {
+    console.debug('[WebRTC] [Signaller] Registering callback for when list of available streams arrive.')
     // eslint-disable-next-line @typescript-eslint/no-this-alias
     const signaller = this
     this.addEventListener('message', function availableStreamListener(ev: MessageEvent): void {
@@ -540,12 +486,12 @@ export class Signaller {
         signaller.removeEventListener('message', availableStreamListener)
 
         const streams: Array<Stream> = answer.content
-        onStatusChanged?.('Available Streams arrived')
+        signaller.onStatusChange?.('Available Streams arrived')
         onAvailableStreams?.(streams)
       } catch (error) {
         const errorMsg = `Failed parsing received Message. Error: ${error}. Data: ${ev.data}`
         console.error('[WebRTC] [Signaller] ' + errorMsg)
-        onStatusChanged?.(errorMsg)
+        signaller.onStatusChange?.(errorMsg)
         return
       }
     })
diff --git a/src/stores/video.ts b/src/stores/video.ts
index b457154d0..846f072d2 100644
--- a/src/stores/video.ts
+++ b/src/stores/video.ts
@@ -32,13 +32,12 @@ export const useVideoStore = defineStore('video', () => {
   const allowedIceIps = useStorage<string[]>('cockpit-allowed-stream-ips', [])
   const activeStreams = ref<{ [key in string]: StreamData | undefined }>({})
   const mainWebRTCManager = new WebRTCManager(webRTCSignallingURI.val, rtcConfiguration)
-  const { availableStreams } = mainWebRTCManager.startStream(ref(undefined), allowedIceIps)
   const availableIceIps = ref<string[]>([])
   const videoRecoveryWarningAlreadyShown = useStorage('video-recovery-warning-already-shown', false)
   const unprocessedVideos = useStorage<{ [key in string]: UnprocessedVideoInfo }>('cockpit-unprocessed-video-info', {})
   const timeNow = useTimestamp({ interval: 500 })
 
-  const namesAvailableStreams = computed(() => availableStreams.value.map((stream) => stream.name))
+  const namesAvailableStreams = computed(() => mainWebRTCManager.availableStreams.value.map((stream) => stream.name))
 
   // If the allowed ICE IPs are updated, all the streams should be reconnected
   watch(allowedIceIps, () => {
@@ -56,7 +55,7 @@ export const useVideoStore = defineStore('video', () => {
       )
       availableIceIps.value = [...availableIceIps.value, ...newIps]
 
-      const updatedStream = availableStreams.value.find((s) => s.name === streamName)
+      const updatedStream = mainWebRTCManager.availableStreams.value.find((s) => s.name === streamName)
       if (isEqual(updatedStream, activeStreams.value[streamName]!.stream)) return
 
       // Whenever the stream is to be updated we first reset it's variables (activateStream method), so
@@ -77,13 +76,15 @@ export const useVideoStore = defineStore('video', () => {
   const activateStream = (streamName: string): void => {
     const stream = ref()
     const webRtcManager = new WebRTCManager(webRTCSignallingURI.val, rtcConfiguration)
-    const { mediaStream } = webRtcManager.startStream(stream, allowedIceIps)
+    const { mediaStream, connected } = webRtcManager.startStream(stream, allowedIceIps)
     activeStreams.value[streamName] = {
       // @ts-ignore: This is actually not reactive
       stream: stream,
       webRtcManager: webRtcManager,
       // @ts-ignore: This is actually not reactive
       mediaStream: mediaStream,
+      // @ts-ignore: This is actually not reactive
+      connected: connected,
       mediaRecorder: undefined,
       timeRecordingStart: undefined,
     }
diff --git a/src/types/video.ts b/src/types/video.ts
index 1fe7b6a4d..740071e88 100644
--- a/src/types/video.ts
+++ b/src/types/video.ts
@@ -17,6 +17,11 @@ export interface StreamData {
    * MediaStream object, if WebRTC stream is chosen
    */
   mediaStream: MediaStream | undefined
+  /**
+   * Connection state of the stream
+   * Used to identify when to use the stream or not
+   */
+  connected: boolean
   /**
    * MediaRecorder object for that stream
    */