mitmi 1.1.6 → 1.1.8

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,85 +84,96 @@ 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;
-
-    console.warn(this.ownerId, this.domElement.volume, this.domElement.muted);
   }
 
   /**
-   * 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;
 
-    console.warn(this.ownerId, this.domElement.volume, this.domElement.muted);
+    await this.domElement.play();
   }
 }
 

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;
@@ -28,8 +37,6 @@ export class SocketInteraction extends EventTarget {
   async init(): Promise<string> {
     this.socket = io(serverUrl, {});
 
-    console.warn("WS transport");
-
     return new Promise((resolve, reject) => {
       this.socket.once("connect", () => {
         this._userId = this.socket.id;
@@ -47,6 +54,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;
 
@@ -57,6 +70,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;
@@ -69,8 +87,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");
@@ -93,6 +113,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;
 
@@ -102,6 +129,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;
 
@@ -110,6 +144,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;
 
@@ -122,6 +163,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;
 
@@ -134,6 +182,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()");
@@ -149,7 +202,15 @@ 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());
+    }
+
     Object.values(this.peerConnections).forEach((pc) => pc.close());
     this.peerConnections = {};
 
@@ -159,6 +220,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;
@@ -201,6 +267,13 @@ export class SocketInteraction extends EventTarget {
     });
   }
 
+  /**
+   * Create a Peerconnection with the remote contact
+   *
+   * @param from - Peerconnection with this contact
+   * @param initiator - Are you the applicant
+   * @returns
+   */
   private async createPeerConnection(from: ContactInfo, initiator: boolean) {
     const remoteUserId = from.id;
     const remoteUserName = from.name;
@@ -251,6 +324,12 @@ export class SocketInteraction extends EventTarget {
     }
   }
 
+  /**
+   * 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);
@@ -279,6 +358,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
@@ -296,6 +382,13 @@ 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;
     const pc = this.peerConnections[remoteUserId];
@@ -304,11 +397,21 @@ export class SocketInteraction extends EventTarget {
     await pc.addIceCandidate(candidate);
   }
 
+  /**
+   * 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 };