@afosecure/meetingsdk 1.0.8 → 1.1.1

package/dist/index.mjs

@@ -397,6 +397,7 @@ var VideoSDKCore = class {
         if (!p?.id || p.id === this.myId) return;
         this.state.addParticipant(p);
         this.events.onUserJoined?.(p);
+        await this.createOffer(p.id);
         break;
       }
       case "OFFER":
@@ -406,14 +407,26 @@ var VideoSDKCore = class {
         const pc = this.peers[msg.sender];
         if (!pc) return;
         if (pc.signalingState !== "have-local-offer") {
-          console.warn("Ignoring invalid answer:", pc.signalingState);
+          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": {
@@ -508,17 +521,47 @@ var VideoSDKCore = class {
   // ---------------- PEER ----------------
   createPeer(id) {
     if (!this.localStream) throw new Error("No local stream");
+    console.log(
+      "Adding tracks",
+      this.localStream.getTracks().map((t) => ({
+        kind: t.kind,
+        enabled: t.enabled,
+        state: t.readyState
+      }))
+    );
     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) => {
+      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];
       const participant = this.state.getParticipant(id);
       const isScreenStream = incomingStream.id === participant?.media?.remoteScreenStreamId;
@@ -551,6 +594,15 @@ var VideoSDKCore = class {
         target: id
       });
     };
+    pc.oniceconnectionstatechange = () => {
+      console.log(`ICE Connection State: ${pc.iceConnectionState}`);
+      if (pc.iceConnectionState === "failed" || pc.iceConnectionState === "disconnected") {
+        this.emitError(
+          "ICE_FAILED",
+          "Connection failed. Please check your network or refresh."
+        );
+      }
+    };
     pc.onconnectionstatechange = () => {
       if (pc.connectionState === "failed") {
         try {
@@ -573,7 +625,21 @@ var VideoSDKCore = class {
   }
   // ---------------- OFFER ----------------
   async createOffer(id, isRenegotiation = false) {
-    if (!isRenegotiation && this.initiators.has(id)) return;
+    if (!isRenegotiation && this.initiators.has(id)) {
+      console.debug(
+        `[Offer] Already initiating with ${id}, skipping duplicate`
+      );
+      return;
+    }
+    if (isRenegotiation && this.peers[id]) {
+      const pc2 = this.peers[id];
+      if (pc2.signalingState !== "stable") {
+        console.warn(
+          `[Offer] Cannot renegotiate: peer in state "${pc2.signalingState}"`
+        );
+        return;
+      }
+    }
     if (!isRenegotiation) {
       this.initiators.add(id);
     }
@@ -581,46 +647,80 @@ var VideoSDKCore = class {
       this.peers[id] = this.createPeer(id);
     }
     const pc = this.peers[id];
-    if (pc.signalingState !== "stable") {
-      return;
+    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
+      );
     }
-    const offer = await pc.createOffer();
-    await pc.setLocalDescription(offer);
-    this.send({
-      type: "OFFER",
-      payload: offer.sdp,
-      sender: this.myId,
-      target: id
-    });
   }
   // ---------------- ANSWER ----------------
   async handleOffer(sdp, id) {
+    if (this.initiators.has(id) && this.peers[id]) {
+      const pc2 = this.peers[id];
+      if (pc2.signalingState !== "stable") {
+        console.warn(
+          `[Signaling] Offer collision with ${id}. We initiated, ignoring their offer.`
+        );
+        return;
+      }
+    }
     if (!this.peers[id]) {
       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) {
@@ -635,39 +735,55 @@ var VideoSDKCore = class {
     this.state.removeParticipant(id);
   }
   async startScreenShare() {
-    if (this.state.presenterId && this.state.presenterId !== this.myId) {
-      throw new Error("Another user is already sharing their screen.");
-    }
-    this.screenStream = await navigator.mediaDevices.getDisplayMedia({
-      video: true,
-      audio: true
-    });
-    this.isScreenSharing = true;
-    this.state.updateLocalParticipant({
-      media: {
-        isScreenSharing: true,
-        screenStream: this.screenStream
+    try {
+      if (this.state.presenterId && this.state.presenterId !== this.myId) {
+        throw new Error("Another user is already sharing their screen.");
       }
-    });
-    this.state.setPresenterId(this.myId);
-    this.screenStream.getVideoTracks()[0].onended = () => {
-      this.stopScreenShare();
-    };
-    Object.entries(this.peers).forEach(([peerId, pc]) => {
-      this.screenSenders[peerId] = [];
-      this.screenStream.getTracks().forEach((track) => {
-        const sender = pc.addTrack(track, this.screenStream);
-        this.screenSenders[peerId].push(sender);
+      if (!navigator.mediaDevices?.getDisplayMedia) {
+        throw new Error("Screen sharing not supported on this device");
+      }
+      this.screenStream = await navigator.mediaDevices.getDisplayMedia({
+        video: true
+        // audio: true,
       });
-      this.createOffer(peerId, true);
-    });
-    this.send({
-      type: "SCREEN_SHARE_START",
-      sender: this.myId,
-      room_id: this.roomId,
-      stream_id: this.screenStream.id.replace(/[{}]/g, "")
-    });
-    return this.screenStream;
+      this.isScreenSharing = true;
+      this.state.updateLocalParticipant({
+        media: {
+          isScreenSharing: true,
+          screenStream: this.screenStream,
+          screenTrack: this.screenStream.getVideoTracks()[0]
+        }
+      });
+      this.state.setPresenterId(this.myId);
+      this.screenStream.getVideoTracks()[0].onended = () => {
+        this.stopScreenShare();
+      };
+      Object.entries(this.peers).forEach(([peerId, pc]) => {
+        this.screenSenders[peerId] = [];
+        this.screenStream.getTracks().forEach((track) => {
+          const sender = pc.addTrack(track, this.screenStream);
+          this.screenSenders[peerId].push(sender);
+        });
+        this.createOffer(peerId, true);
+      });
+      this.send({
+        type: "SCREEN_SHARE_START",
+        sender: this.myId,
+        room_id: this.roomId,
+        stream_id: this.screenStream.id.replace(/[{}]/g, "")
+      });
+      return this.screenStream;
+    } catch (err) {
+      this.emitError(
+        "SCREEN_SHARE_FAILED",
+        err?.message || "Failed to start screen sharing",
+        err,
+        true
+      );
+      this.isScreenSharing = false;
+      this.screenStream = null;
+      throw err;
+    }
   }
   stopScreenShare() {
     if (!this.screenStream) return;
@@ -905,7 +1021,6 @@ var useLocalParticipant = () => {
       video.srcObject = stream;
       video.autoplay = true;
       video.playsInline = true;
-      video.muted = true;
       video.play().catch((err) => {
         console.warn(`Autoplay failed for local view:`, err);
       });
@@ -955,6 +1070,15 @@ var useRemoteMedia = (participantId) => {
   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);
@@ -968,13 +1092,14 @@ var useRemoteMedia = (participantId) => {
       const stream = participant?.media?.stream;
       if (!stream) return;
       node.srcObject = stream;
-      node.autoplay = true;
-      node.playsInline = true;
       node.muted = true;
-      node.play().catch((e) => console.warn("Video playback failed:", e));
+      node.playsInline = true;
+      node.autoplay = true;
+      node.play().catch((err) => {
+        console.log("can't play video:", err);
+      });
     },
-    // FIX: Added cameraTrack so React knows to re-run this when the video track arrives
-    [participant?.media?.stream, participant?.media?.cameraTrack]
+    [participant?.media?.stream]
   );
   const audioRef = useCallback2(
     (node) => {
@@ -982,12 +1107,12 @@ var useRemoteMedia = (participantId) => {
       const stream = participant?.media?.stream;
       if (!stream) return;
       node.srcObject = stream;
-      node.autoplay = true;
-      node.muted = !participant?.media?.micEnabled;
-      node.play().catch((e) => console.warn("Audio playback failed:", e));
+      node.muted = false;
+      node.play().catch((err) => {
+        console.log("can't play Audio:", err);
+      });
     },
-    // FIX: Added audioTrack to dependency array
-    [participant?.media?.stream, participant?.media?.micEnabled]
+    [participant?.media?.stream]
   );
   return {
     videoRef,