mitmi 1.1.7 → 1.1.9

package/src/Stream.ts

@@ -1,11 +1,17 @@
 import { Conference } from "./Conference";
 import { setLocalStream } from "./utils";
 
+/**
+ * Stream constraints
+ */
 export interface StreamParams {
   audio: boolean;
   video: boolean;
 }
 
+/**
+ * This class represent a video, camera or screenshare.
+ */
 class Stream {
   mediastream: MediaStream;
   domElement: undefined | HTMLVideoElement;
@@ -17,10 +23,14 @@ class Stream {
   params: StreamParams;
 
   /**
+   * Create a Stream
+   *
+   * @param mediastream - The video input to attach to the stream
+   * @param ownerId - The ownerId of the mediastream
+   * @param ownerName - The owner of the mediastream
    *
-   * @param mediastream
-   * @param owner "" => ourself, id instead
    */
+  //TODO Enlever le fait que ownerid est une string vide si l'owner est soit meme
   constructor(mediastream: MediaStream, ownerId: string, ownerName: string) {
     this.mediastream = mediastream;
     this.ownerId = ownerId;
@@ -29,15 +39,24 @@ class Stream {
     this.params = { audio: true, video: false };
   }
 
+  /**
+   * Check if the stream is local
+   *
+   * @returns - True if it's a localstream, false instead
+   */
   isLocal(): boolean {
     return this.ownerId === "";
   }
 
   /**
-   * Will update lastest camera stream known (for DeviceMananger)
-   * @param video
-   * @param audio
-   * @returns
+   * Get camera input
+   *
+   * @param video - Is video enable ?
+   * @param audio - Is audio enable ?
+   * @param audioDeviceId optional - Use a specific audio device
+   * @param videoDeviceId optional - Use a specific video device
+   *
+   * @returns A stream with your camera.
    */
   static async getCamera(
     video: boolean,
@@ -65,82 +84,97 @@ class Stream {
   }
   static getScreen() {}
 
+  /**
+   * Attach the stream to your DOM
+   *
+   * @param domElement - The HTML element to attach the stream
+   */
   attachToElement(domElement: HTMLVideoElement): void {
     this.domElement = domElement;
     domElement.srcObject = this.mediastream;
 
     if (this.isLocal()) {
-      this.disableAudio();
+      this.localMuteAudio();
     }
   }
 
+  /**
+   * Detach the stream to your DOM
+   */
   detachToElement(): void {
     if (!this.domElement) return;
     this.domElement.srcObject = null;
   }
 
-  /**
-   * If the stream is published (so its yours) :
-   *  - video will be disabled for everyone
-   * If the stream is not published (its yours but not publish, or other ppl stream):
-   *  - video will be disabled for you only
-   */
-  muteVideo() {
-    this.params.video = false;
+  globalMuteVideo() {
     if (this.conferencePublish) {
-      //your publish stream
-      this.conferencePublish.session.socketInteraction.setConstraint(this);
+      this.params.video = false;
+      //this.conferencePublish.session.socketInteraction.setConstraint(this);
+      this.mediastream.getVideoTracks()[0].enabled = false;
     }
-    this.mediastream.getVideoTracks()[0].enabled = false;
   }
 
-  unmuteVideo() {
-    this.params.video = true;
+  globalUnmuteVideo() {
     if (this.conferencePublish) {
-      //your publish stream
-      this.conferencePublish.session.socketInteraction.setConstraint(this);
+      this.params.video = true;
+      //this.conferencePublish.session.socketInteraction.setConstraint(this);
+      this.mediastream.getVideoTracks()[0].enabled = true;
     }
-    this.mediastream.getVideoTracks()[0].enabled = true;
   }
 
-  muteAudio(): void {
-    this.params.audio = false;
+  globalMuteAudio(): void {
     if (this.conferencePublish) {
-      this.conferencePublish.session.socketInteraction.setConstraint(this);
+      this.params.audio = false;
+      //this.conferencePublish.session.socketInteraction.setConstraint(this);
+      this.mediastream.getAudioTracks()[0].enabled = false;
     }
-    this.mediastream.getAudioTracks()[0].enabled = false;
   }
 
-  unmuteAudio(): void {
-    this.params.audio = true;
+  globalUnmuteAudio(): void {
     if (this.conferencePublish) {
-      this.conferencePublish.session.socketInteraction.setConstraint(this);
+      this.params.audio = true;
+      //this.conferencePublish.session.socketInteraction.setConstraint(this);
+      this.mediastream.getAudioTracks()[0].enabled = true;
     }
-    this.mediastream.getAudioTracks()[0].enabled = true;
   }
 
   /**
-   * This function exist to avoir Larsen.
-   * You need to call here when a localstream is started.
+   * Disable local audio
    */
-  disableAudio(): void {
+  localMuteAudio(): void {
     if (!this.domElement) return;
 
-    // Important: cette ligne n'affecte pas l'envoi audio
     this.domElement.muted = true;
     this.domElement.volume = 0;
   }
 
   /**
-   * TODO do better
+   * Enable local audio
    */
-  enableAudio(): void {
+  localUnmuteAudio(): void {
     if (!this.domElement) return;
 
-    // Important: cette ligne n'affecte pas l'envoi audio
     this.domElement.muted = false;
     this.domElement.volume = 1;
   }
+
+  /**
+   * Disable local video
+   */
+  localMuteVideo(): void {
+    if (!this.domElement) return;
+
+    this.domElement.pause();
+  }
+
+  /**
+   * Enable local video
+   */
+  async localUnmuteVideo(): Promise<void> {
+    if (!this.domElement) return;
+
+    await this.domElement.play();
+  }
 }
 
 export { Stream };

package/src/core/SocketInteraction.ts

@@ -2,8 +2,11 @@ import { io, Socket } from "socket.io-client";
 import { serverUrl } from "../constants";
 import { getCurrentSession } from "../utils";
 import { Stream, StreamParams } from "../Stream";
-import { ContactInfo } from "../utils";
+import { ContactInfo } from "../Contact";
 
+/**
+ * Type of message between server and client
+ */
 interface SocketMessage {
   from: ContactInfo;
   target?: string;
@@ -16,6 +19,12 @@ interface SocketMessage {
   };
 }
 
+/**
+ * Main interaction between socket and server
+ *
+ * @private
+ *
+ */
 export class SocketInteraction extends EventTarget {
   private socket!: Socket;
   private _userId?: string;
@@ -24,6 +33,10 @@ export class SocketInteraction extends EventTarget {
   private senders: Array<RTCRtpSender> = [];
 
   private peerConnections: Record<string, RTCPeerConnection> = {};
+  private pendingCandidates: Record<
+    string,
+    Array<RTCIceCandidate | RTCIceCandidateInit>
+  > = {};
 
   async init(): Promise<string> {
     this.socket = io(serverUrl, {});
@@ -45,6 +58,12 @@ export class SocketInteraction extends EventTarget {
     return this._userId;
   }
 
+  /**
+   * Publish a Stream into all peers
+   *
+   * @param stream - Stream to publish
+   */
+  //TODO Check to publish multiple stream, ATM => one at the moment
   publish(stream: Stream) {
     this.localStream = stream;
 
@@ -55,6 +74,11 @@ export class SocketInteraction extends EventTarget {
     console.log("[RTC] Stream published to all peers");
   }
 
+  /**
+   * Unbuplish stream into all peers
+   *
+   * @param stream - Stream to unpublish
+   */
   unpublish(stream: Stream) {
     if (this.localStream != stream) throw new Error("this is not your stream");
     this.localStream = undefined;
@@ -67,8 +91,10 @@ export class SocketInteraction extends EventTarget {
   }
 
   /**
+   * Set constraint to you stream ex : muteAudio
+   * Stream have stream.params, use to set constraint on the peer
    *
-   * @param stream Stream have stream.params, use to set constraint on the peer
+   * @param stream - Affected Stream with constraints
    */
   setConstraint(stream: Stream) {
     if (this.localStream != stream) throw new Error("this is not your stream");
@@ -91,6 +117,13 @@ export class SocketInteraction extends EventTarget {
     console.log("[RTC] Set constraint");
   }
 
+  /**
+   * Attach a stream to a peer
+   *
+   * @param pc - PeerConnection to attach this.localstream
+   * @returns
+   */
+  //TODO don't use this.localstream, but a parameter instead ?
   private attachStreamToPeer(pc: RTCPeerConnection) {
     if (!this.localStream) return;
 
@@ -100,6 +133,13 @@ export class SocketInteraction extends EventTarget {
     });
   }
 
+  /**
+   * Detach a stream to a peer
+   *
+   * @param pc - PeerConnection to detach this.localstream
+   * @returns
+   */
+  //TODO don't use this.localstream, but a parameter instead ?
   private removeStreamToPeer(pc: RTCPeerConnection) {
     if (!this.localStream) return;
 
@@ -108,6 +148,13 @@ export class SocketInteraction extends EventTarget {
     });
   }
 
+  /**
+   * Stop sending a specific track
+   *
+   * @param pc - Affected Peerconnection
+   * @param track - Track to disable
+   * @returns
+   */
   private disableTrackToPeer(pc: RTCPeerConnection, track: MediaStreamTrack) {
     if (!this.localStream) return;
 
@@ -120,6 +167,13 @@ export class SocketInteraction extends EventTarget {
     });
   }
 
+  /**
+   * Activate a track into a peer
+   *
+   * @param pc - Affected Peerconnection
+   * @param track - Track to enable
+   * @returns
+   */
   private enableTrackToPeer(pc: RTCPeerConnection, track: MediaStreamTrack) {
     if (!this.localStream) return;
 
@@ -132,6 +186,11 @@ export class SocketInteraction extends EventTarget {
     });
   }
 
+  /**
+   * Send a join message to the server
+   *
+   * @param confId - ID conference
+   */
   register(confId: number) {
     /*if (!this.publishStream) {
       throw new Error("Call publish() before register()");
@@ -147,7 +206,24 @@ export class SocketInteraction extends EventTarget {
     console.log(`[CONF] Join request sent for room ${confId}`);
   }
 
+  /**
+   * Disconnect
+   */
   unregister() {
+    //Stop all the track before (release camera and microphone)
+    if (this.localStream) {
+      this.localStream.mediastream.getTracks().forEach((track) => track.stop());
+    }
+
+    const sender = getCurrentSession()?.contact!;
+    this.sendMessage({
+      from: sender.toString(),
+      payload: {
+        action: "close",
+        disconnect: sender.toString().id,
+      },
+    });
+
     Object.values(this.peerConnections).forEach((pc) => pc.close());
     this.peerConnections = {};
 
@@ -157,6 +233,11 @@ export class SocketInteraction extends EventTarget {
     console.log("[CONF] Unregistered and socket closed");
   }
 
+  /**
+   * Set Listeners
+   *
+   * @private
+   */
   private setupSocketListeners() {
     this.socket.on("message", async (message: SocketMessage) => {
       if (!this._confId) return;
@@ -165,44 +246,70 @@ export class SocketInteraction extends EventTarget {
 
       switch (payload.action) {
         case "join":
-          console.log(`[RTC] Join received from ${from}`);
+          console.log(`[RTC] Join received from ${from.name}`);
           await this.createPeerConnection(from, true);
           break;
 
         case "offer":
-          console.log(`[RTC] Offer received from ${from}`);
+          console.log(`[RTC] Offer received from ${from.name}`);
           await this.handleOffer(from, payload.sdp!);
           break;
 
         case "answer":
-          console.log(`[RTC] Answer received from ${from}`);
+          console.log(`[RTC] Answer received from ${from.name}`);
           await this.handleAnswer(from, payload.sdp!);
           break;
 
         case "ice":
-          console.log(`[RTC] ICE received from ${from}`);
+          console.log(`[RTC] ICE received from ${from.name}`);
           await this.handleIce(from, payload.candidate!);
           break;
 
         case "close":
-          console.log(`[RTC] Peer ${payload.disconnect} disconnected`);
-          this.removePeer(payload.disconnect!);
-          this.dispatchEvent(
-            new CustomEvent("peopleLeave", {
-              detail: { leaveId: payload.disconnect },
-            })
-          );
-          console.log("[Socket] leave" + payload.disconnect);
-
+          if (from) {
+            //Normal way
+            console.log(`[RTC] Peer ${from.name} disconnected`);
+            this.removePeer(payload.disconnect!);
+            this.dispatchEvent(
+              new CustomEvent("peopleLeave", {
+                detail: { leaveId: payload.disconnect, name: from.name },
+              })
+            );
+          } else {
+            //Message send by server
+            //Normal way
+            console.log(`[RTC] Someone disconnected`);
+            this.removePeer(payload.disconnect!);
+            this.dispatchEvent(
+              new CustomEvent("peopleLeave", {
+                detail: {
+                  leaveId: payload.disconnect,
+                  name: "Call conference.leave()",
+                },
+              })
+            );
+          }
           break;
       }
     });
   }
 
-  private async createPeerConnection(from: ContactInfo, initiator: boolean) {
+  /**
+   * Create a Peerconnection with the remote contact
+   *
+   * @param from - Peerconnection with this contact
+   * @param initiator - Are you the applicant ? IF yes send an Offer
+   * @returns
+   */
+  private async createPeerConnection(
+    from: ContactInfo,
+    initiator: boolean
+  ): Promise<RTCPeerConnection> {
     const remoteUserId = from.id;
     const remoteUserName = from.name;
-    if (this.peerConnections[remoteUserId]) return; //existe deja
+    if (this.peerConnections[remoteUserId]) {
+      return this.peerConnections[remoteUserId]; // Already exist
+    }
 
     const pc = new RTCPeerConnection();
     this.peerConnections[remoteUserId] = pc;
@@ -247,14 +354,27 @@ export class SocketInteraction extends EventTarget {
         },
       });
     }
+
+    return pc;
   }
 
+  /**
+   * Event handle the offer
+   *
+   * @param from - Contact who send the offer
+   * @param sdp - Offer
+   */
   private async handleOffer(from: ContactInfo, sdp: RTCSessionDescriptionInit) {
     const remoteUserId = from.id;
-    await this.createPeerConnection(from, false);
+    const pc = await this.createPeerConnection(from, false);
 
-    const pc = this.peerConnections[remoteUserId];
-    await pc.setRemoteDescription(new RTCSessionDescription(sdp));
+    //const pc = this.peerConnections[remoteUserId];
+
+    try {
+      await pc.setRemoteDescription(new RTCSessionDescription(sdp));
+    } catch (error) {
+      console.error("Remote decription error : ", error);
+    }
 
     const answer = await pc.createAnswer();
     await pc.setLocalDescription(answer);
@@ -269,6 +389,9 @@ export class SocketInteraction extends EventTarget {
       },
     });
 
+    // flush pending ICE candidates received before remoteDescription was set
+    await this.flushPendingCandidates(remoteUserId);
+
     const event: CustomEvent = new CustomEvent("newPeople", {
       detail: {
         contact: from,
@@ -277,6 +400,13 @@ export class SocketInteraction extends EventTarget {
     this.dispatchEvent(event);
   }
 
+  /**
+   * Event handle the enswer
+   *
+   * @param from - Contact who send tjhe answer
+   * @param sdp - The answer
+   * @returns
+   */
   private async handleAnswer(
     from: ContactInfo,
     sdp: RTCSessionDescriptionInit
@@ -286,6 +416,10 @@ export class SocketInteraction extends EventTarget {
     if (!pc) return;
 
     await pc.setRemoteDescription(new RTCSessionDescription(sdp));
+
+    // flush pending ICE candidates received before remoteDescription was set
+    await this.flushPendingCandidates(remoteUserId);
+
     const event: CustomEvent = new CustomEvent("newPeople", {
       detail: {
         contact: from,
@@ -294,19 +428,70 @@ export class SocketInteraction extends EventTarget {
     this.dispatchEvent(event);
   }
 
+  /**
+   * Event when receive ice candidates
+   *
+   * @param from - Contact
+   * @param candidate - Icecandidate
+   * @returns
+   */
   private async handleIce(from: ContactInfo, candidate: RTCIceCandidate) {
     const remoteUserId = from.id;
+    /*if (!pc) return;
+
+    try {
+      await pc.addIceCandidate(candidate);
+    } catch (error) {
+      console.error("Ice error : ", error);
+      console.error(pc);
+    }*/
     const pc = this.peerConnections[remoteUserId];
-    if (!pc) return;
+    if (!pc || !pc.remoteDescription || !pc.remoteDescription.type) {
+      this.pendingCandidates[remoteUserId] =
+        this.pendingCandidates[remoteUserId] || [];
+      this.pendingCandidates[remoteUserId].push(candidate);
+      return;
+    }
 
-    await pc.addIceCandidate(candidate);
+    try {
+      await pc.addIceCandidate(candidate);
+    } catch (error) {
+      console.error("Ice error : ", error);
+    }
   }
 
+  private async flushPendingCandidates(remoteUserId: string): Promise<void> {
+    const pc = this.peerConnections[remoteUserId];
+    if (!pc) return; // No remote description attach to this user
+
+    const pendingCandidates = this.pendingCandidates[remoteUserId];
+    if (!pendingCandidates || !pendingCandidates.length) return; // No pending candidates
+
+    for (const pendingCandidate of pendingCandidates) {
+      try {
+        await pc.addIceCandidate(pendingCandidate);
+      } catch (e) {
+        console.error("Error adding pending ICE candidate", e);
+      }
+    }
+    delete this.pendingCandidates[remoteUserId];
+  }
+
+  /**
+   * Event when receive a disconnection message
+   *
+   * @param remoteId - ID that leave
+   */
   private removePeer(remoteId: string) {
     this.peerConnections[remoteId]?.close();
     delete this.peerConnections[remoteId];
   }
 
+  /**
+   * Send a message on the socket
+   *
+   * @param msg - Message to send on the socket
+   */
   private sendMessage(msg: SocketMessage) {
     this.socket.emit("message", msg);
   }

package/src/index.ts

@@ -4,3 +4,7 @@ export { HelloWorld } from "./HelloWorld";
 export { Stream } from "./Stream";
 export { Conference } from "./Conference";
 export { DeviceManager } from "./DeviceManager";
+
+//Interfaces
+export type { StreamParams } from "./Stream";
+export type { ContactInfo } from "./Contact";

package/src/utils.ts

@@ -1,6 +1,11 @@
 import { Session } from "./Session";
 import { Stream } from "./Stream";
 
+/**
+ * Generate a random string
+ *
+ * @returns - A random string format, ex: de0b1c44-b42e-c617-bcc2-14586c5fffe2
+ */
 function uidGenerator(): String {
   var S4 = function () {
     return (((1 + Math.random()) * 0x10000) | 0).toString(16).substring(1);
@@ -21,6 +26,9 @@ function uidGenerator(): String {
   );
 }
 
+/**
+ * Function for global session
+ */
 let currentSession: Session | undefined = undefined;
 function setCurrentSession(newSession: undefined | Session) {
   currentSession = newSession;
@@ -29,6 +37,10 @@ function getCurrentSession() {
   return currentSession;
 }
 
+//TODO Useless ?
+/**
+ * Function for localstream
+ */
 let localStream: Stream | undefined = undefined;
 function setLocalStream(newStream: undefined | Stream) {
   localStream = newStream;
@@ -37,12 +49,6 @@ function getLocalStream() {
   return localStream;
 }
 
-interface ContactInfo {
-  id: string;
-  name: string;
-}
-
-export { ContactInfo };
 export { setCurrentSession };
 export { getCurrentSession };
 export { setLocalStream };