@afosecure/meetingsdk 1.1.0 → 1.1.2

package/dist/index.mjs

@@ -167,6 +167,8 @@ var VideoSDKCore = class {
     this.ws = null;
     this.peers = {};
     this.initiators = /* @__PURE__ */ new Set();
+    this.lastPong = Date.now();
+    this.intentionalDisconnect = false;
     this.roomId = null;
     this.localStream = null;
     this.screenStream = null;
@@ -238,18 +240,18 @@ var VideoSDKCore = class {
         this.emitError("WS_ERROR", "WebSocket encountered an error", err, true);
       };
       this.ws.onclose = (e) => {
-        this.emitError(
-          "WS_CLOSED",
-          `Connection closed (${e.code}) ${e.reason || ""}`,
-          e,
-          true
-        );
         this.joinRejecter?.({
           code: "WS_CLOSED",
           message: "Connection closed before join completed",
           raw: e
         });
         this.joinRejecter = void 0;
+        if (this.intentionalDisconnect) {
+          return;
+        }
+        if (e.code === 1e3 || e.code === 1001) {
+          return;
+        }
         this.scheduleReconnect();
       };
       this.ws.onmessage = async (e) => {
@@ -373,46 +375,36 @@ var VideoSDKCore = class {
     var _a, _b, _c, _d;
     if (msg.sender === this.myId) return;
     switch (msg.type) {
-      case "EXISTING_USERS":
-        if (msg.presenterId) {
-          this.state.setPresenterId(msg.presenterId);
-          this.events.onScreenShareStarted?.(msg.presenterId, null);
-        }
-        for (const p of msg.participants || []) {
-          if (!p?.id || p.id === this.myId) continue;
-          this.state.addParticipant(p);
-          this.events.onUserJoined?.(p);
-        }
+      case "PONG":
+        this.lastPong = Date.now();
         break;
-      case "JOINED": {
-        this.startHeartbeat();
-        this.joinResolver?.();
-        this.joinResolver = void 0;
-        this.joinRejecter = void 0;
-        break;
-      }
-      case "USER_JOINED": {
-        const p = msg.participant;
-        if (!p?.id || p.id === this.myId) return;
-        this.state.addParticipant(p);
-        this.events.onUserJoined?.(p);
-        break;
-      }
       case "OFFER":
         await this.handleOffer(msg.payload, msg.sender);
         break;
       case "ANSWER": {
         const pc = this.peers[msg.sender];
         if (!pc) return;
-        if (pc.signalingState === "stable") {
-          console.warn("Late answer received, restarting negotiation");
+        if (pc.signalingState !== "have-local-offer") {
+          console.warn(
+            `[Signaling] Unexpected ANSWER in state "${pc.signalingState}", ignoring`
+          );
           return;
         }
-        await pc.setRemoteDescription({
-          type: "answer",
-          sdp: msg.payload
-        });
-        await this.flushIce(msg.sender, pc);
+        try {
+          await pc.setRemoteDescription({
+            type: "answer",
+            sdp: msg.payload
+          });
+          await this.flushIce(msg.sender, pc);
+        } catch (err) {
+          console.error("[Signaling] Failed to apply answer:", err);
+          this.emitError(
+            "ANSWER_FAILED",
+            `Failed to apply answer from ${msg.sender}`,
+            err,
+            true
+          );
+        }
         break;
       }
       case "ICE": {
@@ -435,6 +427,35 @@ var VideoSDKCore = class {
         }
         break;
       }
+      case "EXISTING_USERS":
+        if (msg.presenterId) {
+          this.state.setPresenterId(msg.presenterId);
+          this.events.onScreenShareStarted?.(msg.presenterId, null);
+        }
+        for (const p of msg.participants || []) {
+          if (!p?.id || p.id === this.myId) continue;
+          this.state.addParticipant(p);
+          this.events.onUserJoined?.(p);
+          await this.createOffer(p.id);
+        }
+        break;
+      case "JOINED": {
+        this.intentionalDisconnect = false;
+        this.reconnectAttempts = 0;
+        this.startHeartbeat();
+        this.joinResolver?.();
+        this.joinResolver = void 0;
+        this.joinRejecter = void 0;
+        break;
+      }
+      case "USER_JOINED": {
+        const p = msg.participant;
+        if (!p?.id || p.id === this.myId) return;
+        this.state.addParticipant(p);
+        this.events.onUserJoined?.(p);
+        await this.createOffer(p.id);
+        break;
+      }
       case "USER_LEFT":
         const peerId = msg.participant.id;
         this.closePeer(peerId);
@@ -518,17 +539,44 @@ var VideoSDKCore = class {
     const pc = new RTCPeerConnection({
       iceServers: [
         {
-          urls: [
-            "stun:stun.l.google.com:19302",
-            "stun:stun1.l.google.com:19302"
-          ]
+          urls: "stun:stun.relay.metered.ca:80"
+        },
+        {
+          urls: "turn:global.relay.metered.ca:80",
+          username: "25aed888d2d360e9fae0e812",
+          credential: "WPYstojO9Wf3+HsQ"
+        },
+        {
+          urls: "turn:global.relay.metered.ca:80?transport=tcp",
+          username: "25aed888d2d360e9fae0e812",
+          credential: "WPYstojO9Wf3+HsQ"
+        },
+        {
+          urls: "turn:global.relay.metered.ca:443",
+          username: "25aed888d2d360e9fae0e812",
+          credential: "WPYstojO9Wf3+HsQ"
+        },
+        {
+          urls: "turns:global.relay.metered.ca:443?transport=tcp",
+          username: "25aed888d2d360e9fae0e812",
+          credential: "WPYstojO9Wf3+HsQ"
         }
       ]
     });
     pc.ontrack = (event) => {
-      const incomingStream = event.streams[0];
+      console.log(`Track received: ${event.track.kind}`, {
+        trackId: event.track.id,
+        streamCount: event.streams.length,
+        streamTrackCount: event.streams[0]?.getTracks().length
+      });
+      const incomingStream = event.streams?.[0] || new MediaStream([event.track]);
       const participant = this.state.getParticipant(id);
       const isScreenStream = incomingStream.id === participant?.media?.remoteScreenStreamId;
+      if (event.track.kind === "video") {
+        event.track.onunmute = () => {
+          console.log("Video track unmuted for", id);
+        };
+      }
       if (isScreenStream) {
         const videoTrack = event.track.kind === "video" ? event.track : incomingStream.getVideoTracks()[0] || participant?.media?.screenTrack;
         this.state.updateParticipantMedia(id, {
@@ -558,6 +606,9 @@ var VideoSDKCore = class {
         target: id
       });
     };
+    pc.oniceconnectionstatechange = () => {
+      console.log(`ICE Connection State: ${pc.iceConnectionState}`);
+    };
     pc.onconnectionstatechange = () => {
       if (pc.connectionState === "failed") {
         try {
@@ -580,18 +631,45 @@ var VideoSDKCore = class {
   }
   // ---------------- OFFER ----------------
   async createOffer(id, isRenegotiation = false) {
+    if (!isRenegotiation && this.initiators.has(id)) {
+      console.debug(
+        `[Offer] Already initiating with ${id}, skipping duplicate`
+      );
+    }
+    if (isRenegotiation && this.peers[id]) {
+      const pc2 = this.peers[id];
+      if (pc2.signalingState !== "stable") {
+        console.warn(
+          `[Offer] Cannot renegotiate: peer in state "${pc2.signalingState}"`
+        );
+      }
+    }
+    if (!isRenegotiation) {
+      this.initiators.add(id);
+    }
     if (!this.peers[id]) {
       this.peers[id] = this.createPeer(id);
     }
     const pc = this.peers[id];
-    const offer = await pc.createOffer();
-    await pc.setLocalDescription(offer);
-    this.send({
-      type: "OFFER",
-      payload: offer.sdp,
-      sender: this.myId,
-      target: id
-    });
+    try {
+      const offer = await pc.createOffer();
+      await pc.setLocalDescription(offer);
+      this.send({
+        type: "OFFER",
+        payload: offer.sdp,
+        sender: this.myId,
+        target: id
+      });
+      console.debug(`[Offer] Sent to ${id}`);
+    } catch (err) {
+      console.error(`[Offer] Failed for ${id}:`, err);
+      this.emitError(
+        "OFFER_FAILED",
+        `Failed to create offer for ${id}`,
+        err,
+        true
+      );
+    }
   }
   // ---------------- ANSWER ----------------
   async handleOffer(sdp, id) {
@@ -599,28 +677,45 @@ var VideoSDKCore = class {
       this.peers[id] = this.createPeer(id);
     }
     const pc = this.peers[id];
-    await pc.setRemoteDescription({
-      type: "offer",
-      sdp
-    });
-    const pending = this.pendingIceCandidates[id] || [];
-    for (const candidate of pending) {
-      try {
-        await pc.addIceCandidate(candidate);
-      } catch (err) {
-        console.warn(err);
+    try {
+      if (pc.signalingState !== "stable" && pc.signalingState !== "have-local-offer") {
+        console.warn(
+          `[Signaling] Cannot accept OFFER in state "${pc.signalingState}"`
+        );
+        return;
+      }
+      await pc.setRemoteDescription({
+        type: "offer",
+        sdp
+      });
+      const pending = this.pendingIceCandidates[id] || [];
+      for (const candidate of pending) {
+        try {
+          await pc.addIceCandidate(candidate);
+        } catch (err) {
+          console.warn("[ICE] Failed to add candidate:", err);
+        }
       }
+      delete this.pendingIceCandidates[id];
+      const answer = await pc.createAnswer();
+      await pc.setLocalDescription(answer);
+      await this.flushIce(id, pc);
+      this.send({
+        type: "ANSWER",
+        payload: answer.sdp,
+        sender: this.myId,
+        target: id
+      });
+      console.debug(`[Answer] Sent to ${id}`);
+    } catch (err) {
+      console.error(`[Signaling] Failed to handle OFFER from ${id}:`, err);
+      this.emitError(
+        "OFFER_HANDLING_FAILED",
+        `Failed to handle offer from ${id}`,
+        err,
+        true
+      );
     }
-    delete this.pendingIceCandidates[id];
-    const answer = await pc.createAnswer();
-    await pc.setLocalDescription(answer);
-    await this.flushIce(id, pc);
-    this.send({
-      type: "ANSWER",
-      payload: answer.sdp,
-      sender: this.myId,
-      target: id
-    });
   }
   // ---------------- CLEANUP ----------------
   closePeer(id) {
@@ -751,6 +846,7 @@ var VideoSDKCore = class {
     });
   }
   disconnect() {
+    this.intentionalDisconnect = true;
     this.stopScreenShare();
     Object.values(this.peers).forEach((pc) => pc.close());
     this.peers = {};
@@ -964,21 +1060,14 @@ var useParticipants = () => {
 };
 
 // src/react/useRemoteMedia.ts
-import { useCallback as useCallback2, useEffect as useEffect5, useState as useState4 } from "react";
+import { useEffect as useEffect5, useRef as useRef3, useState as useState4 } from "react";
 var useRemoteMedia = (participantId) => {
   const { sdk } = useMeetingContext();
+  const videoRef = useRef3(null);
+  const audioRef = useRef3(null);
   const [participant, setParticipant] = useState4(
     () => sdk.state.getParticipant(participantId) || null
   );
-  const buildMediaStream = (participant2) => {
-    if (!participant2?.media) return null;
-    const stream = new MediaStream();
-    const videoTrack = participant2.media.stream?.getVideoTracks?.()?.[0];
-    const audioTrack = participant2.media.stream?.getAudioTracks?.()?.[0];
-    if (videoTrack) stream.addTrack(videoTrack);
-    if (audioTrack) stream.addTrack(audioTrack);
-    return stream;
-  };
   useEffect5(() => {
     const unsub = sdk.state.subscribe(`participant:${participantId}`, () => {
       const p = sdk.state.getParticipant(participantId);
@@ -986,34 +1075,22 @@ var useRemoteMedia = (participantId) => {
     });
     return unsub;
   }, [participantId, sdk]);
-  const videoRef = useCallback2(
-    (node) => {
-      if (!node) return;
-      const stream = participant?.media?.stream;
-      if (!stream) return;
-      node.pause();
-      node.srcObject = stream;
-      node.muted = true;
-      node.playsInline = true;
-      node.autoplay = true;
-      node.play().catch(() => {
+  useEffect5(() => {
+    const stream = participant?.media?.stream;
+    if (!stream) return;
+    if (videoRef.current) {
+      videoRef.current.srcObject = stream;
+      videoRef.current.muted = true;
+      videoRef.current.playsInline = true;
+      videoRef.current.play().catch(() => {
       });
-    },
-    [participant?.media?.stream]
-  );
-  const audioRef = useCallback2(
-    (node) => {
-      if (!node) return;
-      const stream = participant?.media?.stream;
-      if (!stream) return;
-      node.pause();
-      node.srcObject = stream;
-      node.muted = false;
-      node.play().catch(() => {
+    }
+    if (audioRef.current) {
+      audioRef.current.srcObject = stream;
+      audioRef.current.play().catch(() => {
       });
-    },
-    [participant?.media?.stream]
-  );
+    }
+  }, [participant?.media?.stream]);
   return {
     videoRef,
     audioRef,