teleportxr 1.0.7 → 1.0.9

package/client/client.js

@@ -130,7 +130,7 @@ class Client {
     {
 		this.webRtcConnectionManager=WebRtcConnectionManager.getInstance();
         // We make sure WebRTC has a connection for this client.
-  		this.webRtcConnection = this. webRtcConnectionManager.createConnection(
+  		this.webRtcConnection = this.webRtcConnectionManager.createConnection(
 										this.clientID
 										,this.streamingConnectionStateChanged.bind(this)
 										,this.receivedMessageReliable.bind(this)

package/client/geometry_service.js

@@ -376,9 +376,12 @@ class GeometryService
 		var resource_uids=[];
 		let time_now_us=core.getTimestampUs();
 		for(const [uid, count] of this.streamedMeshes)
-		 {
+		{
 			//is mesh streamed
 			var res=GeometryService.GetOrCreateTrackedResource(uid);
+			// If it was already received we don't send it:
+			if(res.WasAcknowledgedByClient(this.clientID))
+				continue;
 			res.Sent(this.clientID,time_now_us);
 			if(res.WasSentToClient(this.clientID))
 			{

package/connections/webrtcconnection.js

@@ -6,7 +6,7 @@ const DefaultRTCPeerConnection = require('@roamhq/wrtc').RTCPeerConnection;
 
 const TIME_TO_CONNECTED = 10000;
 const TIME_TO_HOST_CANDIDATES = 3000;  // NOTE: Too long.
-const TIME_TO_RECONNECTED = 10000;
+const TIME_TO_RECONNECTED = 1000;
 
 function EVEN_ID(id) {
     return (id-(id%2))
@@ -22,7 +22,7 @@ class WebRtcConnection extends EventEmitter
 		this.id = id;
 		this.state = 'open';
 
-		options = {
+		this.options = {
 			RTCPeerConnection: DefaultRTCPeerConnection,
 			clearTimeout,
 			setTimeout,
@@ -38,75 +38,110 @@ class WebRtcConnection extends EventEmitter
 			timeToReconnected
 		} = options;
 
-		this.connectionStateChanged	=options.connectionStateChanged;
+		this.connectionStateChanged			=options.connectionStateChanged;
 		this.messageReceivedReliableCb		=options.messageReceivedReliable;
 		this.messageReceivedUnreliableCb	=options.messageReceivedUnreliable;
 		
 		this.sendConfigMessage		=options.sendConfigMessage;
-		const peerConnection		=new RTCPeerConnection({ sdpSemantics: 'unified-plan'});
-        this.pc						=peerConnection;
+
+
+		Object.defineProperties(this, {
+			iceConnectionState: {
+				get ()
+				{
+					return this.peerConnection.iceConnectionState;
+				}
+			},
+			localDescription: {
+				get ()
+				{
+					return descriptionToJSON(this.peerConnection.localDescription, true);
+				}
+			},
+			remoteDescription: {
+				get ()
+				{
+					return descriptionToJSON(this.peerConnection.remoteDescription);
+				}
+			},
+			signalingState: {
+				get ()
+				{
+					return this.peerConnection.signalingState;
+				}
+			}
+		});
+		this.reconnect();
+	}
+
+	reconnect()
+	{
+		this.peerConnection		=new DefaultRTCPeerConnection({ sdpSemantics: 'unified-plan'});
         
-		this.beforeOffer(peerConnection);
+		this.beforeOffer();
  
-		let connectionTimer = options.setTimeout(() =>
+		let connectionTimer = this.options.setTimeout(() =>
 		{
-			if (peerConnection.iceConnectionState !== 'connected'
-				&& peerConnection.iceConnectionState !== 'completed')
+			if (this.peerConnection.iceConnectionState !== 'connected'
+				&& this.peerConnection.iceConnectionState !== 'completed')
 			{
 				this.close();
 			}
-		}, timeToConnected);
+		}, this.options.timeToConnected);
 
 		let reconnectionTimer = null;
 
 		const onIceConnectionStateChange = () =>
 		{
-            console.log("ICE state changed to: "+peerConnection.iceConnectionState);
-			if (peerConnection.iceConnectionState === 'connected'
-				|| peerConnection.iceConnectionState === 'completed')
+            console.log("ICE state changed to: "+this.peerConnection.iceConnectionState);
+			if (this.peerConnection.iceConnectionState === 'connected'
+				|| this.peerConnection.iceConnectionState === 'completed')
 			{
 				if (connectionTimer)
 				{
-					options.clearTimeout(connectionTimer);
+					this.options.clearTimeout(connectionTimer);
 					connectionTimer = null;
 				}
-				options.clearTimeout(reconnectionTimer);
+				this.options.clearTimeout(reconnectionTimer);
 				reconnectionTimer = null;
-			} else if (peerConnection.iceConnectionState === 'disconnected'
-				|| peerConnection.iceConnectionState === 'failed')
+			} else if (this.peerConnection.iceConnectionState === 'disconnected'
+				|| this.peerConnection.iceConnectionState === 'failed')
 			{
+				this.peerConnection.restartIce();
+				console.log("restartIce()");
 				if (!connectionTimer && !reconnectionTimer)
 				{
 					const self = this;
-					reconnectionTimer = options.setTimeout(() =>
+					reconnectionTimer = this.options.setTimeout(() =>
 					{
-						self.close();
-					}, timeToReconnected);
+						this.reconnect();
+						this.doOffer();
+					}, this.options.timeToReconnected);
 				}
 			}
 		};
 		const onIceGatheringStateChange = () =>
 		{
-            console.log("ICE gathering state changed to: "+peerConnection.iceGatheringState);
+            console.log("ICE gathering state changed to: "+this.peerConnection.iceGatheringState);
         };
 
-		peerConnection.addEventListener('iceconnectionstatechange', onIceConnectionStateChange);
-		peerConnection.addEventListener('icegatheringstatechange', onIceGatheringStateChange);
+		this.peerConnection.addEventListener('iceconnectionstatechange', onIceConnectionStateChange);
+		this.peerConnection.addEventListener('icegatheringstatechange', onIceGatheringStateChange);
 
         
 		const onConnectionStateChange = () =>
-           {
-            console.log("Connection State changed to: "+peerConnection.connectionState.toString());
-            this.connectionStateChanged(this,peerConnection.connectionState);
+        {
+            console.log("Connection State changed to: "+this.peerConnection.connectionState.toString());
+            this.connectionStateChanged(this,this.peerConnection.connectionState);
         }
-        peerConnection.addEventListener("connectionstatechange", onConnectionStateChange);
+        this.peerConnection.addEventListener("connectionstatechange", onConnectionStateChange);
 
         this.onIceCandidate= ({ candidate })=>
         {
             if (!candidate)
             {
-                options.clearTimeout(this.timeout);
-                //peerConnection.removeEventListener('icecandidate', this.onIceCandidate);
+                this.options.clearTimeout(this.timeout);
+                //this.peerConnection.removeEventListener('icecandidate', this.onIceCandidate);
                 this.deferred.resolve();
                 return;
             }
@@ -138,7 +173,6 @@ class WebRtcConnection extends EventEmitter
                 this.deferred.reject(new Error('Timed out waiting for host candidates'));
             }, timeToHostCandidates);
         
-        
             peerConnection.addEventListener('icecandidate', this.onIceCandidate);
         
             await this.deferred.promise;
@@ -148,11 +182,11 @@ class WebRtcConnection extends EventEmitter
 		{
 			try
 			{ 
-				const offer = await peerConnection.createOffer();
-				await peerConnection.setLocalDescription(offer);
+				const offer = await this.peerConnection.createOffer();
+				await this.peerConnection.setLocalDescription(offer);
 				var message = '{"teleport-signal-type":"offer","sdp":"'+offer.sdp+'"}'; //
 				this.sendConfigMessage(this.id,message);
-				await this.waitUntilIceGatheringStateComplete(peerConnection, options);
+				await this.waitUntilIceGatheringStateComplete(this.peerConnection, this.options);
 			} catch (error)
 			{
                 console.error(error.toString());
@@ -174,32 +208,31 @@ class WebRtcConnection extends EventEmitter
             var sessionDescription=new wrtc.RTCSessionDescription();
             sessionDescription.sdp=answer;
             sessionDescription.type="answer";
-			await peerConnection.setRemoteDescription( sessionDescription);
+			await this.peerConnection.setRemoteDescription( sessionDescription);
 		};
 		this.applyRemoteCandidate = async(candidate_txt,mid,mlineindex)=>
 		{
             console.log("received remote candidate.");
-            peerConnection.addIceCandidate(new wrtc.RTCIceCandidate({
+            this.peerConnection.addIceCandidate(new wrtc.RTCIceCandidate({
               candidate: candidate_txt,
               sdpMLineIndex: mlineindex,
               sdpMid: mid
             }));
 		};
-
 		this.close = () =>
 		{
-			peerConnection.removeEventListener('iceconnectionstatechange', onIceConnectionStateChange);
+			this.peerConnection.removeEventListener('iceconnectionstatechange', onIceConnectionStateChange);
 			if (connectionTimer)
 			{
-				options.clearTimeout(connectionTimer);
+				this.options.clearTimeout(connectionTimer);
 				connectionTimer = null;
 			}
 			if (reconnectionTimer)
 			{
-				options.clearTimeout(reconnectionTimer);
+				this.options.clearTimeout(reconnectionTimer);
 				reconnectionTimer = null;
 			}
-			peerConnection.close();
+			this.peerConnection.close();
 			this.state = 'closed';
 			this.emit('closed');
 		};
@@ -215,33 +248,6 @@ class WebRtcConnection extends EventEmitter
 				signalingState: this.signalingState
 			};
 		};
-
-		Object.defineProperties(this, {
-			iceConnectionState: {
-				get ()
-				{
-					return peerConnection.iceConnectionState;
-				}
-			},
-			localDescription: {
-				get ()
-				{
-					return descriptionToJSON(peerConnection.localDescription, true);
-				}
-			},
-			remoteDescription: {
-				get ()
-				{
-					return descriptionToJSON(peerConnection.remoteDescription);
-				}
-			},
-			signalingState: {
-				get ()
-				{
-					return peerConnection.signalingState;
-				}
-			}
-		});
 	}
     sendGeometry(buffer) {
 		try {	
@@ -251,7 +257,7 @@ class WebRtcConnection extends EventEmitter
             console.error('datachannel.sendGeometry exception: '+exception.message);
 		}
     }
-    beforeOffer(peerConnection) {
+    beforeOffer() {
           
         this.videoDataChannel = this.createDataChannel("video",20);
         this.tagDataChannel = this.createDataChannel("video_tags",40);
@@ -259,7 +265,7 @@ 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 = peerConnection.createDataChannel('ping-pong',{id:2050});
+       // this.dataChannel = this.peerConnection.createDataChannel('ping-pong',{id:2050});
       
         function onMessage({ data }) {
           if (data === 'ping') {
@@ -270,9 +276,9 @@ class WebRtcConnection extends EventEmitter
         // NOTE(mroberts): This is a hack so that we can get a callback when the
         // RTCPeerConnection is closed. In the future, we can subscribe to
         // "connectionstatechange" events.
-        const { close } = peerConnection;
+        const { close } = this.peerConnection;
         var self=this;
-        peerConnection.close = function() {
+        this.peerConnection.close = function() {
             //self.dataChannel.removeEventListener('message', onMessage);
           return close.apply(this, arguments);
         };
@@ -304,7 +310,7 @@ class WebRtcConnection extends EventEmitter
         //See https://web.dev/articles/webrtc-datachannels. Can only use id if negotiated=true.
         const dataChannelOptions={ordered:reliable,maxRetransmits:reliable?10000:0,id:id};
         
-        var dc=this.pc.createDataChannel(label,dataChannelOptions);
+        var dc=this.peerConnection.createDataChannel(label,dataChannelOptions);
        
          dc.onmessage = this.receiveMessage.bind(this,id);
   

package/index.js

@@ -3,11 +3,11 @@ const WebRtcConnectionManager	= require('./connections/webrtcconnectionmanager.j
 const signaling					=require("./signaling.js");
 const client_manager 			= require('./client/client_manager.js');
 
-function initServer(http_server) {
+function initServer(signaling_port) {
 	var cm=client_manager.getInstance();
 	const webRtcConnectionManager = WebRtcConnectionManager.getInstance();
 	webRtcConnectionManager.SetSendConfigMessage(signaling.sendConfigMessage);
-	signaling.init(webRtcConnectionManager,cm.newClient.bind(cm),http_server);
+	return signaling.init(webRtcConnectionManager,cm.newClient.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.7",
+  "version": "1.0.9",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/simul/teleport-nodejs.git"
@@ -29,7 +29,8 @@
 	"./signaling": "./signaling.js",
 	"./client/client_manager": "./client/client_manager.js",
     "./connections/webrtcconnectionmanager": "./connections/webrtcconnectionmanager.js",
-	"./scene/scene":"./scene/scene.js"
+	"./scene/scene":"./scene/scene.js",
+	"./scene/resources":"./scene/resources.js"
   },
   "publishConfig": {
   }

package/scene/resources.js

@@ -9,6 +9,11 @@ class Resource
 	//! One trackedResources shared acrosss all clients.
 	static resourcesByUid=new Map();
 	static pathToUid=new Map();
+	static defaultPathRoot="http://localhost";
+	static SetDefaultPathRoot(str)
+	{
+		Resource.defaultPathRoot=str;
+	}
     constructor(type,uid,url)
     {
 		this.uid=uid;
@@ -18,7 +23,10 @@ class Resource
 	encodeIntoDataView(dataView,byteOffset) {
 		byteOffset=core.put_uint8(dataView,byteOffset,this.type);
 		byteOffset=core.put_uint64(dataView,byteOffset,this.uid);
-		byteOffset=core.put_string(dataView,byteOffset,this.url);
+		var url=this.url;
+		if(this.url.search("://")==-1)
+			url=Resource.defaultPathRoot+this.url;
+		byteOffset=core.put_string(dataView,byteOffset,url);
 		return byteOffset;
 	}
 }

package/signaling.js

@@ -214,17 +214,26 @@ function OnWebSocket(ws, req) {
 		console.log("Some Error occurred");
 	};
 }
-exports.init = function (webRtcCM, newClientFn, http_server) {
+exports.init = function (webRtcCM, newClientFn, signaling_port) {
 	// Creating a new websocket server
 	// const signaling_port = process.env.PORT || 8081;
-	const wss = new WebSocketServer.Server({ http_server });
+	var wss;
+	if(signaling_port)
+	{
+		wss= new WebSocketServer.Server({ port: signaling_port});
+	}
+	else
+	{
+		wss= new WebSocketServer.Server({ noServer: true });
+	}
 	webRtcConnectionManager = webRtcCM;
 	newClient=newClientFn;
 	// Creating connection using websocket
 	wss.on("connection", (ws, req) => {
 		OnWebSocket(ws, req);
 	});
-	console.log("The WebSockets Signaling Server is running on port " + JSON.stringify(wss.options));
+	console.log("The WebSockets Signaling Server is running: " + JSON.stringify(wss.options));
+	return wss;
 };
 exports.sendConfigMessage = function (clientID, msg) {
     // Test: is this message valid json?

package/server.js

@@ -1,35 +0,0 @@
-'use strict';
- 
-const WebRtcConnectionManager = require('./connections/webrtcconnectionmanager');
-const cm = require('./client/client_manager.js');
-
-const signaling=require("./signaling.js");
-const scene=require("./scene/scene.js");
-
-var sc=new scene.Scene();
-
-const fs = require('fs');
-const path = require('path');
-
-const assetsPath = path.join(__dirname,'assets');
-
-sc.Load(path.join(assetsPath,'scene.json'));
-
-// This is our app's callback for when a new client is to be created.
-// It must return the origin uid for the client.
-function createNewClient(clientID) {
-	var origin_uid=sc.CreateNode();
-	return origin_uid;
-}
-
-// This will be called AFTER a client has been created, so we can access it from the clientManager.
-function onClientPostCreate(clientID) {
-	var client=cm.getInstance().GetClient(clientID);
-	client.SetScene(sc);
-}
-
-const webRtcConnectionManager = WebRtcConnectionManager.getInstance();
-webRtcConnectionManager.SetSendConfigMessage(signaling.sendConfigMessage);
-cm.getInstance().SetNewClientCallback(createNewClient);
-cm.getInstance().SetClientPostCreationCallback(onClientPostCreate);
-signaling.init(webRtcConnectionManager,cm.getInstance().newClient.bind(cm.getInstance()));