@osimatic/helpers-js 1.0.51 → 1.0.54

package/event_bus.js

@@ -10,7 +10,9 @@ class EventBus {
             return;
         }
 
-        handlers.forEach((handler) => handler.call(this, data));
+        handlers.forEach(function(handler) {
+            handler.call(this, data)
+        });
     }
 
     subscribe(name, handler) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@osimatic/helpers-js",
-  "version": "1.0.51",
+  "version": "1.0.54",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"

package/web_rtc.js

@@ -4,14 +4,14 @@ class WebRTC {
         this.stunUrl = stunUrl;
     }
 
-    static setTurnAccount(turnAccount) {
-        this.turnAccount = turnAccount;
+    static setTurnSecret(turnSecret) {
+        this.turnSecret = turnSecret;
     }
 
     static offer(stream, iceCandidateCallback) {
-        return new Promise((resolve, reject) => {
+        return new Promise(async (resolve, reject) => {
             try {
-                let { username, password } = this.turnAccount;
+                let { username, password } = this.getTurnCredentials(); 
                 let peerConn = new RTCPeerConnection(
                     { 
                         iceServers: [
@@ -28,19 +28,20 @@ class WebRTC {
                     }
                 });
 
-                peerConn.createOffer()
-                .then(sdp => peerConn.setLocalDescription(sdp))
-                .then(() => resolve(peerConn));
+                const offer = await peerConn.createOffer();
+                await peerConn.setLocalDescription(offer);
+
+                resolve(peerConn);
             } catch (error) {
                 reject(error);
             }
         });
     }
     
-    static answer (remoteDescription, onTrackCallback, iceCandidateCallback) {
-        return new Promise((resolve, reject) => {
+    static answer(remoteDescription, onTrackCallback, iceCandidateCallback) {
+        return new Promise(async (resolve, reject) => {
             try {
-                let { username, password } = this.turnAccount;
+                let { username, password } = this.getTurnCredentials();
                 let peerConn = new RTCPeerConnection(
                     { 
                         iceServers: [
@@ -57,10 +58,12 @@ class WebRTC {
                     }
                 });
 
-                peerConn.setRemoteDescription(remoteDescription)
-                .then(() => peerConn.createAnswer())
-                .then(sdp => peerConn.setLocalDescription(sdp))
-                .then(() => resolve(peerConn));
+                peerConn.setRemoteDescription(new RTCSessionDescription(remoteDescription))
+                
+                const answer = await peerConn.createAnswer();
+                await peerConn.setLocalDescription(answer);
+                
+                resolve(peerConn);
             } catch (error) {
                 reject(error);
             }
@@ -82,6 +85,23 @@ class WebRTC {
             
         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

@@ -8,34 +8,82 @@ class WebSocket {
         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;
+		const { io } = require('socket.io-client');
+
+		this.logged = false;
 		this.instance = io(url, options);
 
-		this.initEventListeners();
-		this.initConnectionListeners(onUnavailableCallback);
+		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;
 
-		this.instance.on('connect', () => {
-			if (this.logged) {
-				this.clear();
+		self.instance.on('connect', function() {
+			if (self.logged) { //reconnexion avant timeout : on supprime les listeners de l'event bus
+				self.clear();
 			}
 
-			this.logged = true;
+			self.logged = true;
+
+			self.instance.emit('connect_init', connectInitPayload, onConnectionAckCallback);			
+		});
 
-			this.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 initConnectionListeners(onUnavailableCallback) {
-		['connect_error', 'connect_timeout', 'reconnect_error', 'reconnect_failed', 'disconnect'].forEach(event => this.instance.on(event, () => this.clear(onUnavailableCallback, event)));
-		this.instance.on('error', (error) => this.clear(onUnavailableCallback, error));
+	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) {
@@ -45,17 +93,6 @@ class WebSocket {
             onUnavailableCallback(error);
         }
 	}
-
-    static initEventListeners() {
-		this.socketEvents.forEach(event => this.instance.on(event, (payload) => this.eventBus.publish(event, payload)));
-		this.busEvents.forEach(event => this.eventBus.subscribe(event, (payload) => this.instance.emit(event, payload)));
-        this.customBusEvents.forEach((object) => this.eventBus.subscribe(object.custom_name, (payload) => this.instance.emit(object.event_name, payload)));
-	}
-
-	static unregisterEventListener() {
-		this.busEvents.forEach(event => this.eventBus.unsubscribe(event, {}));
-        this.customBusEvents.forEach((object) => this.eventBus.unsubscribe(object.custom_name, {}));
-	}
 }
 
 module.exports = { WebSocket };