teleportxr 1.0.16 → 1.0.17

package/client/client.js

@@ -140,6 +140,13 @@ class Client {
 		//	function(value) {myDisplayer(value);},
 		//	function(error) {myDisplayer(error);}
     }
+	//! Cleanly shut down the WebRTC connection. This may be called when the client has signalled that it is
+	//! disconnecting, or when the server determines that the client is lost or needs to be booted.
+	StopStreaming()
+	{
+		this.webRtcConnectionManager.destroyConnection(this.clientID);
+		this.webRtcConnection=null;
+	}
 	// Generic message acknowledgement. Certain kinds of message are expected to be ack'ed.
 	ReceiveAcknowledgement(data)
 	{
@@ -239,6 +246,7 @@ class Client {
 		if(!this.webRtcConnection.sendGeometry)
 		{
 			console.error("this.webRtcConnection.sendGeometry is null");
+			console.log(JSON.stringify(this.webRtcConnection));
 			return;
 		}
 		this.webRtcConnection.sendGeometry(view2);

package/client/client_manager.js

@@ -94,6 +94,13 @@ class ClientManager
 		c.Start();
 		return c;
 	}
+	disconnectClient(clientID) {
+		// then we tell the client manager to start this client.
+		var c=this.GetClient(clientID);
+		if(!c)
+			return;
+		c.StopStreaming();
+	}
 	writeState() {
 		var content="<table><tr><th>Client Id</th><th>IP Address</th><th>Signalling State</th></tr>";
 		for (let [cl_id,cl] of this.clients) {

package/connections/webrtcconnection.js

@@ -46,7 +46,6 @@ class WebRtcConnection extends EventEmitter
 			timeToReconnected
 		} = options;
 
-		this.connectionStateChanged			=options.connectionStateChanged;
 		this.messageReceivedReliableCb		=options.messageReceivedReliable;
 		this.messageReceivedUnreliableCb	=options.messageReceivedUnreliable;
 		
@@ -86,7 +85,7 @@ class WebRtcConnection extends EventEmitter
 	{
 		this.peerConnection		=new DefaultRTCPeerConnection({ sdpSemantics: 'unified-plan', 'iceServers': this.iceServers});
 		this.beforeOffer();
-		let connectionTimer = this.options.setTimeout(() =>
+		this.connectionTimer = this.options.setTimeout(() =>
 		{
 			if (this.peerConnection.iceConnectionState !== 'connected'
 				&& this.peerConnection.iceConnectionState !== 'completed')
@@ -96,55 +95,16 @@ class WebRtcConnection extends EventEmitter
 			}
 		}, this.options.timeToConnected);
 
-		let reconnectionTimer = null;
+		this.reconnectionTimer = null;
 
-		const onIceConnectionStateChange = () =>
-		{
-            console.log("ICE state changed to: "+this.peerConnection.iceConnectionState);
-			if (this.peerConnection.iceConnectionState === 'connected'
-				|| this.peerConnection.iceConnectionState === 'completed')
-			{
-				if (connectionTimer)
-				{
-					this.options.clearTimeout(connectionTimer);
-					connectionTimer = null;
-				}
-				this.options.clearTimeout(reconnectionTimer);
-				reconnectionTimer = null;
-			} else if (this.peerConnection.iceConnectionState === 'disconnected'
-				|| this.peerConnection.iceConnectionState === 'failed')
-			{
-				this.peerConnection.restartIce();
-				console.log("restartIce()");
-				if (!connectionTimer && !reconnectionTimer)
-				{
-					const self = this;
-					reconnectionTimer = this.options.setTimeout(() =>
-					{
-						this.reconnect();
-						this.doOffer();
-					}, this.options.timeToReconnected);
-				}
-			}
-		};
-		const onIceGatheringStateChange = () =>
-		{
-            console.log("ICE gathering state changed to: "+this.peerConnection.iceGatheringState);
-        };
-
-		this.peerConnection.addEventListener('iceconnectionstatechange', onIceConnectionStateChange);
-		this.peerConnection.addEventListener('icegatheringstatechange', onIceGatheringStateChange);
+		this.peerConnection.addEventListener('iceconnectionstatechange', this.onIceConnectionStateChange.bind(this));
+		this.peerConnection.addEventListener('icegatheringstatechange', this.onIceGatheringStateChange.bind(this));
 		this.peerConnection.addEventListener("icecandidateerror", (event) => {
 
             console.log("ICE candidate error: "+event.errorCode+" "+event.errorText+" "+event.port+" "+event.url);
 		});
         
-		const onConnectionStateChange = () =>
-        {
-            console.log("Connection State changed to: "+this.peerConnection.connectionState.toString());
-            this.connectionStateChanged(this,this.peerConnection.connectionState);
-        }
-        this.peerConnection.addEventListener("connectionstatechange", onConnectionStateChange);
+        this.peerConnection.addEventListener("connectionstatechange", this.connectionStateChanged.bind(this,this.peerConnection.connectionState));
 
         this.onIceCandidate= ({ candidate })=>
         {
@@ -179,11 +139,11 @@ class WebRtcConnection extends EventEmitter
         
             this.timeout = options.setTimeout(() =>
             {
-                peerConnection.removeEventListener('icecandidate', this.onIceCandidate);
+                peerConnection.removeEventListener('icecandidate', this.onIceCandidate.bind(this));
                 this.deferred.reject(new Error('Timed out waiting for host candidates'));
             }, timeToHostCandidates);
         
-            peerConnection.addEventListener('icecandidate', this.onIceCandidate);
+            peerConnection.addEventListener('icecandidate', this.onIceCandidate.bind(this));
         
             await this.deferred.promise;
         }
@@ -234,24 +194,6 @@ class WebRtcConnection extends EventEmitter
 				console.log(`Failure during addIceCandidate(): ${e.name}`);
 			});
 		};
-		this.close = () =>
-		{
-			console.log("WebRtcConnection.close()");
-			this.peerConnection.removeEventListener('iceconnectionstatechange', onIceConnectionStateChange);
-			if (connectionTimer)
-			{
-				this.options.clearTimeout(connectionTimer);
-				connectionTimer = null;
-			}
-			if (reconnectionTimer)
-			{
-				this.options.clearTimeout(reconnectionTimer);
-				reconnectionTimer = null;
-			}
-			this.peerConnection.close();
-			this.state = 'closed';
-			this.emit('closed');
-		};
 
 		this.toJSON = () =>
 		{
@@ -265,6 +207,96 @@ class WebRtcConnection extends EventEmitter
 			};
 		};
 	}
+	connectionStateChanged()
+	{
+		if(!this.peerConnection)
+			return;
+		console.log("Connection State changed to: "+this.peerConnection.connectionState.toString());
+	}
+	onIceConnectionStateChange()
+	{
+		if(!this.peerConnection)
+			return;
+		console.log("ICE state changed to: "+this.peerConnection.iceConnectionState);
+		if (this.peerConnection.iceConnectionState === 'connected'
+			|| this.peerConnection.iceConnectionState === 'completed')
+		{
+			if (this.connectionTimer)
+			{
+				this.options.clearTimeout(this.connectionTimer);
+				this.connectionTimer = null;
+			}
+			this.options.clearTimeout(this.reconnectionTimer);
+			this.reconnectionTimer = null;
+		} else if (this.peerConnection.iceConnectionState === 'disconnected'
+			|| this.peerConnection.iceConnectionState === 'failed')
+		{
+			this.peerConnection.restartIce();
+			console.log("restartIce()");
+			if (!this.connectionTimer && !this.reconnectionTimer)
+			{
+				const self = this;
+				this.reconnectionTimer = this.options.setTimeout(() =>
+				{
+					this.reconnect();
+					this.doOffer();
+				}, this.options.timeToReconnected);
+			}
+		}
+	}
+	onIceGatheringStateChange()
+	{
+		// This could get hit in the WebRtcConnection constructor where we've had no chance to set the peerConnection pointer!
+		if(this.peerConnection)
+			console.log("ICE gathering state changed to: "+this.peerConnection.iceGatheringState);
+	}
+
+	close()
+	{
+		console.log("WebRtcConnection.close()");
+		if(this.peerConnection)
+		{
+			this.peerConnection.removeEventListener('iceconnectionstatechange', this.onIceConnectionStateChange.bind(this));
+
+			this.peerConnection.eve
+			this.peerConnection.removeEventListener('iceconnectionstatechange', this.onIceConnectionStateChange.bind(this));
+			this.peerConnection.removeEventListener('icegatheringstatechange', this.onIceGatheringStateChange.bind(this));
+		//this.peerConnection.removeEventListener("icecandidateerror", (event) => {
+			this.peerConnection.removeEventListener("connectionstatechange", this.connectionStateChanged.bind(this,this.peerConnection.connectionState));
+		}
+		if (this.connectionTimer)
+		{
+			this.options.clearTimeout(this.connectionTimer);
+			this.connectionTimer = null;
+		}
+		if (this.reconnectionTimer)
+		{
+			this.options.clearTimeout(this.reconnectionTimer);
+			this.reconnectionTimer = null;
+		}
+
+		// Check the connection state
+		if(this.peerConnection)
+		if (this.peerConnection.connectionState == "connected" ||
+			this.peerConnection.connectionState == "failed")
+		{
+			// Close each track
+		/*	this.peerConnection.cl.forEach(mediaStream => { {
+						mediaStream.videoTracks.forEach( it => {it.setEnabled(false); });
+						mediaStream.audioTracks.forEach( it => {it.setEnabled(false); });
+
+					};
+				});;6'7*/
+
+			// Close the connection
+			this.peerConnection.close();
+		}
+
+		// Nullify the reference
+		this.peerConnection = null;
+		this.state = 'closed';
+		this.emit('closed');
+	};
     sendGeometry(buffer) {
 		try {	
         	this.geometryDataChannel.send(buffer);
@@ -281,7 +313,6 @@ class WebRtcConnection extends EventEmitter
         this.geometryDataChannel = this.createDataChannel("geometry_unframed",80);
         this.reliableDataChannel = this.createDataChannel("reliable",100);
         this.unreliableDataChannel = this.createDataChannel("unreliable",120,false);
-       // this.dataChannel = this.peerConnection.createDataChannel('ping-pong',{id:2050});
       
         function onMessage({ data }) {
           if (data === 'ping') {

package/connections/webrtcconnectionmanager.js

@@ -6,56 +6,65 @@ class WebRtcConnectionManager
 {
     constructor(options = {})
     {
-        options = {
-            Connection: WebRtcConnection,
-            ...options
-        };
-		const { Connection } = options;
-		const connections = new Map();
-		const closedListeners = new Map();
+		this.connections = new Map();
+		this.closedListeners = new Map();
+		this.options=options;
+    }
 
-		function deleteConnection(connection) {
+	deleteConnection(connection)
+	{
+		console.log("deleteConnection "+connection.clientID);
 			// 1. Remove "closed" listener?
-			//const closedListener = closedListeners.get(connection);
+		//const closedListener = this.closedListeners.get(connection);
 			//connection.removeListener("closed", closedListener);
-			//closedListeners.delete(connection);
+		//this.closedListeners.delete(connection);
+
+		// 2. Remove the WebRtcConnection from the Map.
+		this.connections.delete(connection.id);
+	}
+	getConnection(id)
+	{
+		return this.connections.get(id) || null;
+	}
+
+	getConnections()
+	{
+		return [...this.connections.values()];
+	};
 
-			// 2. Remove the Connection from the Map.
-			connections.delete(connection.id);
-		}
         
-        this.createConnection =  (clientID,connectionStateChangedcb,messageReceivedReliableCb,messageReceivedUnreliableCb) =>
+	closedListener()
+	{
+		this.deleteConnection(connection);
+		}
+	createConnection(clientID,connectionStateChangedcb,messageReceivedReliableCb,messageReceivedUnreliableCb)
         {
+		var options=this.options;
 			options.sendConfigMessage	=this.sendConfigMessage;
            
 			options.messageReceivedReliable		=messageReceivedReliableCb;
 			options.messageReceivedUnreliable	=messageReceivedUnreliableCb;
-            const connection = new Connection(clientID,options);
+        const connection = new WebRtcConnection(clientID,options);
             connection.connectionStateChanged=connectionStateChangedcb;
-            // 1. Add the "closed" listener.
-            function closedListener() { deleteConnection(connection); }
-			this.createConnection = (clientID) =>
-            closedListeners.set(connection, closedListener);
-            connection.once('closed', closedListener);
+        //  We will not add a "closed" listener, because only the client object will be permitted to close its connection.
+		//this.createConnection = (clientID) => this.closedListeners.set(connection, this.closedListener);
+        //connection.once('closed', this.closedListener);
 
-            // 2. Add the Connection to the Map.
-            connections.set(connection.id, connection);
+        // 2. Add the WebRtcConnection to the Map.
+        this.connections.set(connection.id, connection);
 
             connection.doOffer();
             return connection;
         };
-
-        this.getConnection = id =>
+	destroyConnection(clientID)
         {
-            return connections.get(id) || null;
-        };
-
-        this.getConnections = () =>
+		var connection=this.connections.get(clientID);
+		if(connection)
         {
-            return [...connections.values()];
-        };
+			connection.close();
+			this.connections.delete(clientID);
     }
-
+	}
     toJSON ()
     {
         return this.getConnections().map(connection => connection.toJSON());
@@ -69,7 +78,7 @@ class WebRtcConnectionManager
 WebRtcConnectionManager.create = function create (options)
 {
     return new WebRtcConnectionManager({
-        Connection: function (id)
+        WebRtcConnection: function (id)
         {
             return new WebRtcConnection(id,options);
         },

package/index.js

@@ -7,7 +7,7 @@ function initServer(signaling_port) {
 	var cm=client_manager.getInstance();
 	const webRtcConnectionManager = WebRtcConnectionManager.getInstance();
 	webRtcConnectionManager.SetSendConfigMessage(signaling.sendConfigMessage);
-	return signaling.init(webRtcConnectionManager,cm.newClient.bind(cm),signaling_port);
+	return signaling.init(webRtcConnectionManager,cm.newClient.bind(cm),cm.disconnectClient.bind(cm),signaling_port);
   }
   
   module.exports = {initServer}

package/package.json

@@ -13,7 +13,7 @@
   },
   "name": "teleportxr",
   "description": "Teleport Spatial Server on node.js",
-  "version": "1.0.16",
+  "version": "1.0.17",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/simul/teleport-nodejs.git"

package/signaling.js

@@ -11,6 +11,7 @@ class SignalingState {
 	static ACCEPTED = new SignalingState("Accepted");
 	static STREAMING = new SignalingState("Streaming");
 	static INVALID = new SignalingState("Invalid");
+	static STOP = new SignalingState("Stop");
 
 	constructor(name) {
 		this.name = name;
@@ -49,6 +50,7 @@ var signalingClients = new Map();
 var desiredIP = "";
 var webRtcConnectionManager = null;
 var newClient=null;
+var disconnectClient=null;
 function startStreaming(signalingClient) {
     signalingClient.ChangeSignalingState(SignalingState.ACCEPTED);
 	// And we send the WebSockets request-response.
@@ -70,7 +72,9 @@ function sendResponseToClient(clientID) {
 	}
 }
 function processDisconnection(clientID,signalingClient){
-
+    signalingClient.ChangeSignalingState(SignalingState.START);
+	disconnectClient(signalingClient.clientID);
+	signalingClients.delete(clientID);
 }
 function processInitialRequest(clientID, signalingClient, content) {
 	var j_clientID = 0;
@@ -217,7 +221,7 @@ function OnWebSocket(ws, req) {
 		console.log("Some Error occurred");
 	};
 }
-exports.init = function (webRtcCM, newClientFn, signaling_port) {
+exports.init = function (webRtcCM, newClientFn, disconnectClientFn, signaling_port) {
 	// Creating a new websocket server
 	// const signaling_port = process.env.PORT || 8081;
 	var wss;
@@ -231,6 +235,7 @@ exports.init = function (webRtcCM, newClientFn, signaling_port) {
 	}
 	webRtcConnectionManager = webRtcCM;
 	newClient=newClientFn;
+	disconnectClient=disconnectClientFn;
 	// Creating connection using websocket
 	wss.on("connection", (ws, req) => {
 		OnWebSocket(ws, req);