@osimatic/helpers-js 1.1.77 → 1.1.78

package/web_rtc.js

@@ -1,115 +1,115 @@
-class WebRTC {
-    static setIceServers(turnUrl, stunUrl) {
-        this.turnUrl = turnUrl;
-        this.stunUrl = stunUrl;
-    }
-
-    static setTurnSecret(turnSecret) {
-        this.turnSecret = turnSecret;
-    }
-
-    static setSignalingBus(signalingBus) {
-        this.signalingBus = signalingBus;
-    }
-
-    static offer(videoBroadcasterId, stream, iceCandidateCallback, connectionStateChangeCallback) {
-        return new Promise(async (resolve, reject) => {
-            try {
-                let { username, password } = this.getTurnCredentials(); 
-                let peerConn = new RTCPeerConnection({ 
-                    iceServers: [{ 
-                        urls: [this.turnUrl + '?transport=udp', this.turnUrl + '?transport=tcp'], 
-                        username: username, 
-                        credential: password 
-                    }, { 
-                        urls: this.stunUrl 
-                    }] 
-                });
-                
-                peerConn.onconnectionstatechange = (event) => connectionStateChangeCallback(event, peerConn.connectionState);
-                peerConn.onicecandidate = (event) => iceCandidateCallback(event);
-
-                stream.getTracks().forEach(track => peerConn.addTrack(track, stream));
-                await peerConn.setLocalDescription(await peerConn.createOffer()); 
-                
-                this.signalingBus.subscribe('answer', (payload) => peerConn.setRemoteDescription(payload.description));
-                this.signalingBus.subscribe('candidate', (payload) => peerConn.addIceCandidate(new RTCIceCandidate(payload.candidate)));  
-                this.signalingBus.publish('offer', { id: videoBroadcasterId, description: peerConn.localDescription }); 
-
-                resolve(peerConn);
-            } catch (error) {
-                console.error(error);
-                reject(error);
-            }
-        });
-    }
-
-    static answer(videoBroadcasterId, remoteDescription, onTrackCallback, iceCandidateCallback, connectionStateChangeCallback) {        
-        return new Promise(async (resolve, reject) => {
-            try {
-                let { username, password } = this.getTurnCredentials();
-                let peerConn = new RTCPeerConnection({ 
-                    iceServers: [{ 
-                        urls: [this.turnUrl + '?transport=udp', this.turnUrl + '?transport=tcp'], 
-                        username: username, 
-                        credential: password 
-                    }, { 
-                        urls: this.stunUrl 
-                    }] 
-                });
-
-                peerConn.onconnectionstatechange = (event) => connectionStateChangeCallback(event, peerConn.connectionState);
-                peerConn.onicecandidate = async (event) => iceCandidateCallback(event);
-                peerConn.ontrack = (event) => onTrackCallback(event.streams);
-
-                peerConn.setRemoteDescription(new RTCSessionDescription(remoteDescription));
-                await peerConn.setLocalDescription(await peerConn.createAnswer());
-                
-                this.signalingBus.subscribe('candidate', (payload) => peerConn.addIceCandidate(new RTCIceCandidate(payload.candidate)));
-                this.signalingBus.publish('answer', { id: videoBroadcasterId, description: peerConn.localDescription });
-               
-                resolve(peerConn);
-            } catch (error) {
-                console.error(error);
-                reject(error);
-            }
-        });
-    }
-
-    static disconnectPeer(peerConn) {
-        if (peerConn) {
-            peerConn.oniceconnectionstatechange = null;
-            peerConn.onicecandidateerror = null;
-            peerConn.onicecandidate = null;
-            peerConn.ontrack = null;
-
-            if (peerConn.signalingState != 'closed') {
-                peerConn.getSenders().forEach(sender => peerConn.removeTrack(sender));
-                peerConn.close();
-            }
-
-            peerConn = null;
-        }
-            
-        return peerConn;
-    }
-
-    /*
-        static-auth credentials
-        https://eturnal.net/documentation/
-        https://datatracker.ietf.org/doc/html/draft-uberti-behave-turn-rest-00
-    */
-    static getTurnCredentials() {
-        let crypto = require('crypto');
-        let username = String(parseInt(Date.now() / 1000) + 24 * 3600); //ttl: 24h
-        let hmac = crypto.createHmac('sha1', this.turnSecret);
-
-        hmac.setEncoding('base64');
-        hmac.write(username);
-        hmac.end();
-
-        return { username: username, password: hmac.read() };
-    }
-}
-
+class WebRTC {
+    static setIceServers(turnUrl, stunUrl) {
+        this.turnUrl = turnUrl;
+        this.stunUrl = stunUrl;
+    }
+
+    static setTurnSecret(turnSecret) {
+        this.turnSecret = turnSecret;
+    }
+
+    static setSignalingBus(signalingBus) {
+        this.signalingBus = signalingBus;
+    }
+
+    static offer(videoBroadcasterId, stream, iceCandidateCallback, connectionStateChangeCallback) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                let { username, password } = this.getTurnCredentials(); 
+                let peerConn = new RTCPeerConnection({ 
+                    iceServers: [{ 
+                        urls: [this.turnUrl + '?transport=udp', this.turnUrl + '?transport=tcp'], 
+                        username: username, 
+                        credential: password 
+                    }, { 
+                        urls: this.stunUrl 
+                    }] 
+                });
+                
+                peerConn.onconnectionstatechange = (event) => connectionStateChangeCallback(event, peerConn.connectionState);
+                peerConn.onicecandidate = (event) => iceCandidateCallback(event);
+
+                stream.getTracks().forEach(track => peerConn.addTrack(track, stream));
+                await peerConn.setLocalDescription(await peerConn.createOffer()); 
+                
+                this.signalingBus.subscribe('answer', (payload) => peerConn.setRemoteDescription(payload.description));
+                this.signalingBus.subscribe('candidate', (payload) => peerConn.addIceCandidate(new RTCIceCandidate(payload.candidate)));  
+                this.signalingBus.publish('offer', { id: videoBroadcasterId, description: peerConn.localDescription }); 
+
+                resolve(peerConn);
+            } catch (error) {
+                console.error(error);
+                reject(error);
+            }
+        });
+    }
+
+    static answer(videoBroadcasterId, remoteDescription, onTrackCallback, iceCandidateCallback, connectionStateChangeCallback) {        
+        return new Promise(async (resolve, reject) => {
+            try {
+                let { username, password } = this.getTurnCredentials();
+                let peerConn = new RTCPeerConnection({ 
+                    iceServers: [{ 
+                        urls: [this.turnUrl + '?transport=udp', this.turnUrl + '?transport=tcp'], 
+                        username: username, 
+                        credential: password 
+                    }, { 
+                        urls: this.stunUrl 
+                    }] 
+                });
+
+                peerConn.onconnectionstatechange = (event) => connectionStateChangeCallback(event, peerConn.connectionState);
+                peerConn.onicecandidate = async (event) => iceCandidateCallback(event);
+                peerConn.ontrack = (event) => onTrackCallback(event.streams);
+
+                peerConn.setRemoteDescription(new RTCSessionDescription(remoteDescription));
+                await peerConn.setLocalDescription(await peerConn.createAnswer());
+                
+                this.signalingBus.subscribe('candidate', (payload) => peerConn.addIceCandidate(new RTCIceCandidate(payload.candidate)));
+                this.signalingBus.publish('answer', { id: videoBroadcasterId, description: peerConn.localDescription });
+               
+                resolve(peerConn);
+            } catch (error) {
+                console.error(error);
+                reject(error);
+            }
+        });
+    }
+
+    static disconnectPeer(peerConn) {
+        if (peerConn) {
+            peerConn.oniceconnectionstatechange = null;
+            peerConn.onicecandidateerror = null;
+            peerConn.onicecandidate = null;
+            peerConn.ontrack = null;
+
+            if (peerConn.signalingState != 'closed') {
+                peerConn.getSenders().forEach(sender => peerConn.removeTrack(sender));
+                peerConn.close();
+            }
+
+            peerConn = null;
+        }
+            
+        return peerConn;
+    }
+
+    /*
+        static-auth credentials
+        https://eturnal.net/documentation/
+        https://datatracker.ietf.org/doc/html/draft-uberti-behave-turn-rest-00
+    */
+    static getTurnCredentials() {
+        let crypto = require('crypto');
+        let username = String(parseInt(Date.now() / 1000) + 24 * 3600); //ttl: 24h
+        let hmac = crypto.createHmac('sha1', this.turnSecret);
+
+        hmac.setEncoding('base64');
+        hmac.write(username);
+        hmac.end();
+
+        return { username: username, password: hmac.read() };
+    }
+}
+
 module.exports = { WebRTC };

package/web_socket.js

@@ -1,98 +1,98 @@
-class WebSocket {
-    /**
-     * socketEvents : events en provenance de la socket qui seront dispatchés à travers le bus event
-     * busEvents : events en provenance de l'event bus qui seront dispatchés vers la socket
-     * customBusEvents : events "spéciaux" en provenance de l'event bus qui seront dispatchés vers la socket : array({ 'custom_name' => 'event_name' }, ...)
-    */
-    static setEventListeners(socketEvents, busEvents, customBusEvents) {
-        const { EventBus } = require('./event_bus');
-
-        this.eventBus = new EventBus();
-		this.socketConnectionErrors = ['connect_error', 'connect_timeout', 'reconnect_error', 'reconnect_failed'];
-        this.socketEvents = socketEvents;
-		this.busEvents = busEvents;
-        this.customBusEvents = customBusEvents;
-    }
-
-	static connect(url, options, connectInitPayload, onUnavailableCallback, onConnectionAckCallback) {
-		const { io } = require('socket.io-client');
-
-		this.logged = false;
-		this.instance = io(url, options);
-
-		this.registerErrorListeners(onUnavailableCallback);
-		this.registerEventListeners(connectInitPayload, onConnectionAckCallback, onUnavailableCallback);
-	}
-
-	static registerErrorListeners(onUnavailableCallback) {
-		var self = this;
-
-		self.socketConnectionErrors.forEach(function(event) {
-			self.instance.on(event, function() {
-				self.clear(onUnavailableCallback, event);
-			});
-		});
-
-		self.instance.on('error', function(error) {
-			self.clear(onUnavailableCallback, error);
-		});
-	}
-
-	static registerEventListeners(connectInitPayload, onConnectionAckCallback, onUnavailableCallback) {
-		var self = this;
-
-		self.instance.on('connect', function() {
-			if (self.logged) { //reconnexion avant timeout : on supprime les listeners de l'event bus
-				self.clear();
-			}
-
-			self.logged = true;
-
-			self.instance.emit('connect_init', connectInitPayload, onConnectionAckCallback);			
-		});
-
-		self.instance.on('disconnect', function() {
-			self.clear(onUnavailableCallback);
-		});
-
-		self.socketEvents.forEach(function (event) {
-			self.instance.on(event, function(payload) {
-				self.eventBus.publish(event, payload);
-			});
-		});
-
-		self.busEvents.forEach(function(event) {
-			self.eventBus.subscribe(event, function(payload) {
-				self.instance.emit(event, payload);
-			});
-		});
-
-        self.customBusEvents.forEach(function(object) {
-			self.eventBus.subscribe(object.custom_name, function(payload) {
-				self.instance.emit(object.event_name, payload)
-			});
-		});
-	}
-
-	static unregisterEventListener() {
-		var self = this;
-
-		self.busEvents.forEach(function (event) {
-			self.eventBus.unsubscribe(event, {});
-		});
-
-        self.customBusEvents.forEach(function(object) {
-			self.eventBus.unsubscribe(object.custom_name, {});
-		});
-	}
-
-	static clear(onUnavailableCallback, error) {
-		this.unregisterEventListener();
-
-		if (typeof onUnavailableCallback !== 'undefined') {
-            onUnavailableCallback(error);
-        }
-	}
-}
-
+class WebSocket {
+    /**
+     * socketEvents : events en provenance de la socket qui seront dispatchés à travers le bus event
+     * busEvents : events en provenance de l'event bus qui seront dispatchés vers la socket
+     * customBusEvents : events "spéciaux" en provenance de l'event bus qui seront dispatchés vers la socket : array({ 'custom_name' => 'event_name' }, ...)
+    */
+    static setEventListeners(socketEvents, busEvents, customBusEvents) {
+        const { EventBus } = require('./event_bus');
+
+        this.eventBus = new EventBus();
+		this.socketConnectionErrors = ['connect_error', 'connect_timeout', 'reconnect_error', 'reconnect_failed'];
+        this.socketEvents = socketEvents;
+		this.busEvents = busEvents;
+        this.customBusEvents = customBusEvents;
+    }
+
+	static connect(url, options, connectInitPayload, onUnavailableCallback, onConnectionAckCallback) {
+		const { io } = require('socket.io-client');
+
+		this.logged = false;
+		this.instance = io(url, options);
+
+		this.registerErrorListeners(onUnavailableCallback);
+		this.registerEventListeners(connectInitPayload, onConnectionAckCallback, onUnavailableCallback);
+	}
+
+	static registerErrorListeners(onUnavailableCallback) {
+		var self = this;
+
+		self.socketConnectionErrors.forEach(function(event) {
+			self.instance.on(event, function() {
+				self.clear(onUnavailableCallback, event);
+			});
+		});
+
+		self.instance.on('error', function(error) {
+			self.clear(onUnavailableCallback, error);
+		});
+	}
+
+	static registerEventListeners(connectInitPayload, onConnectionAckCallback, onUnavailableCallback) {
+		var self = this;
+
+		self.instance.on('connect', function() {
+			if (self.logged) { //reconnexion avant timeout : on supprime les listeners de l'event bus
+				self.clear();
+			}
+
+			self.logged = true;
+
+			self.instance.emit('connect_init', connectInitPayload, onConnectionAckCallback);			
+		});
+
+		self.instance.on('disconnect', function() {
+			self.clear(onUnavailableCallback);
+		});
+
+		self.socketEvents.forEach(function (event) {
+			self.instance.on(event, function(payload) {
+				self.eventBus.publish(event, payload);
+			});
+		});
+
+		self.busEvents.forEach(function(event) {
+			self.eventBus.subscribe(event, function(payload) {
+				self.instance.emit(event, payload);
+			});
+		});
+
+        self.customBusEvents.forEach(function(object) {
+			self.eventBus.subscribe(object.custom_name, function(payload) {
+				self.instance.emit(object.event_name, payload)
+			});
+		});
+	}
+
+	static unregisterEventListener() {
+		var self = this;
+
+		self.busEvents.forEach(function (event) {
+			self.eventBus.unsubscribe(event, {});
+		});
+
+        self.customBusEvents.forEach(function(object) {
+			self.eventBus.unsubscribe(object.custom_name, {});
+		});
+	}
+
+	static clear(onUnavailableCallback, error) {
+		this.unregisterEventListener();
+
+		if (typeof onUnavailableCallback !== 'undefined') {
+            onUnavailableCallback(error);
+        }
+	}
+}
+
 module.exports = { WebSocket };