aotrautils 0.0.255 → 0.0.257

aotrautils/aotrautils.build.js

@@ -1,6 +1,6 @@
 
 
-/*utils COMMONS library associated with aotra version : «1_29072022-2359 (25/09/2022-17:58:54)»*/
+/*utils COMMONS library associated with aotra version : «1_29072022-2359 (27/09/2022-01:09:03)»*/
 /*-----------------------------------------------------------------------------*/
 
 
@@ -4827,7 +4827,7 @@ AOTRAUTILS_LIB_IS_LOADED=true;
 
 
 
-/*utils CLIENT library associated with aotra version : «1_29072022-2359 (25/09/2022-17:58:54)»*/
+/*utils CLIENT library associated with aotra version : «1_29072022-2359 (27/09/2022-01:09:03)»*/
 /*-----------------------------------------------------------------------------*/
 /* ## Utility global methods in a browser (htmljs) client environment.
  *
@@ -11913,131 +11913,145 @@ createOritaMainClient=function(
 			socketToServer.send("protocol", "request.register:mainClient:"+storedHashKey);
 		}
 
-	
-	
-	}, urlParam, portParam, isSecure);
 
+
+
+
+
+		// ------------------------------ CONNECTION EVENTS REGISTRATION ------------------------------
 	
-	oritaClient.microClientsInfos={};
-	oritaClient.inputsGPIO={};
-	oritaClient.outputsGPIO={};
 	
 	
-
-	// DBG
-	lognow("oritaClient (MAIN):",oritaClient);
-
+		// DBG
+		lognow("oritaClient (MAIN):",oritaClient);
 	
-			
-	oritaClient.client.socketToServer.receive("protocol", (message)=>{
-				
-				// TRACE
-				lognow("Mainclient received message from server:",message);
-				
-				
-				if(message.type==="response.mainClient.registered"){
+		
 				
-					// TRACE
-					log("Main client registered to server.");
-	
-					// TRACE
-					log("Starting main receiving :");
+		oritaClient.client.socketToServer.receive("protocol", (message)=>{
 					
+					// TRACE
+					lognow("Mainclient received message from server:",message);
 					
 					
+					if(message.type==="response.mainClient.registered"){
 					
-					// Main client starts receiving :
-					oritaClient.client.socketToServer.receive("server.send.data", (receivedData)=>{
-	
-						
-						let microClientId=receivedData.microClientId;
+						// TRACE
+						log("Main client registered to server.");
+		
+						// TRACE
+						log("Starting main receiving :");
 						
-//						// DEBUG
-//						lognow("INFO : MAINCLIENT : MainClient received data from microClient «"+microClientId+"» :",receivedData);
 						
-						let compression=receivedData.compression;
 						
-	//					// DBG
-	//					console.log("receivedData:",receivedData);
-	//					console.log("receivedData.compression:",compression);
 						
-						if(receivedData.video){// -------- VIDEO :
-	
-							if(compression){
-								// Actually, only handles "LZW" uncompression, for now...
-								let uncompressedData;
-								if(ORITA_CONSTANTS.STRINGIFY_VIDEO_DATA)	uncompressedData=arrayFromString(receivedData.video.data, compression.algorithm?true:false, compression.precision);
-								else						uncompressedData=receivedData.video.data;
-								
-								receivedData.video.data=uncompressedData;
-							}
-							
-	//						// DBG
-	//						console.log("received receivedData.length",receivedData);
-							
-							
-							let microClientInfos=oritaClient.microClientsInfos[microClientId];
-							if(!microClientInfos)	oritaClient.microClientsInfos[microClientId]={};
-							microClientInfos=oritaClient.microClientsInfos[microClientId];
-							microClientInfos.hasVideo=true;
-							
-							oritaClient.microClientsInfos[microClientId].lastTime=getNow();
-							
+						// Main client starts receiving :
+						oritaClient.client.socketToServer.receive("server.send.data", (receivedData)=>{
+		
 							
+							let microClientId=receivedData.microClientId;
 							
-							treatVideoData();
+	//						// DEBUG
+	//						lognow("INFO : MAINCLIENT : MainClient received data from microClient «"+microClientId+"» :",receivedData);
 							
+							let compression=receivedData.compression;
 							
-						
-						}else if(receivedData.audio){// -------- AUDIO :
+		//					// DBG
+		//					console.log("receivedData:",receivedData);
+		//					console.log("receivedData.compression:",compression);
 							
-							if(compression){
-								// Actually, only handles "LZW" uncompression, for now...
-								let uncompressedData;
-								if(ORITA_CONSTANTS.STRINGIFY_VIDEO_DATA)	uncompressedData=arrayFromString(receivedData.audio.data, compression.algorithm?true:false, compression.precision);
-								else																			uncompressedData=receivedData.audio.data;
+							if(receivedData.video){// -------- VIDEO :
+		
+								if(compression){
+									// Actually, only handles "LZW" uncompression, for now...
+									let uncompressedData;
+									if(ORITA_CONSTANTS.STRINGIFY_VIDEO_DATA)	uncompressedData=arrayFromString(receivedData.video.data, compression.algorithm?true:false, compression.precision);
+									else						uncompressedData=receivedData.video.data;
+									
+									receivedData.video.data=uncompressedData;
+								}
+								
+		//						// DBG
+		//						console.log("received receivedData.length",receivedData);
+								
+								
+								let microClientInfos=oritaClient.microClientsInfos[microClientId];
+								if(!microClientInfos)	oritaClient.microClientsInfos[microClientId]={};
+								microClientInfos=oritaClient.microClientsInfos[microClientId];
+								microClientInfos.hasVideo=true;
+								
+								oritaClient.microClientsInfos[microClientId].lastTime=getNow();
+								
+								
+								
+								treatVideoData();
+								
 								
-								receivedData.audio.data=uncompressedData;
-							}
-
-							
-							let microClientInfos=oritaClient.microClientsInfos[microClientId];
-							if(!microClientInfos)	oritaClient.microClientsInfos[microClientId]={};
-							microClientInfos=oritaClient.microClientsInfos[microClientId];
-							microClientInfos.hasAudio=true;
-							
-							oritaClient.microClientsInfos[microClientId].lastTime=getNow();
 							
+							}else if(receivedData.audio){// -------- AUDIO :
+								
+								if(compression){
+									// Actually, only handles "LZW" uncompression, for now...
+									let uncompressedData;
+									if(ORITA_CONSTANTS.STRINGIFY_VIDEO_DATA)	uncompressedData=arrayFromString(receivedData.audio.data, compression.algorithm?true:false, compression.precision);
+									else																			uncompressedData=receivedData.audio.data;
+									
+									receivedData.audio.data=uncompressedData;
+								}
+	
+								
+								let microClientInfos=oritaClient.microClientsInfos[microClientId];
+								if(!microClientInfos)	oritaClient.microClientsInfos[microClientId]={};
+								microClientInfos=oritaClient.microClientsInfos[microClientId];
+								microClientInfos.hasAudio=true;
+								
+								oritaClient.microClientsInfos[microClientId].lastTime=getNow();
+								
+								
+								treatAudioData();
+								
 							
-							treatAudioData();
+							}
 							
+						});
 						
-						}
 						
-					});
-					
-					
+		
+						
+						
+						doOnRegistered();
 	
+					}
 					
 					
-					doOnRegistered();
-
-				}
-				
+								
+		});
 				
-							
-	});
-			
+	
+		
+		oritaClient.client.socketToServer.receive("communication", (message)=>{
+	
+			// We execute eventual on message events listeners :
+			foreach(onCommunicationEventListeners, (e)=>{
+				if(!e.condition || e.condition(message))	e.execute(message);
+			});
+		
+		});
+		
+
+
+
+
 
+
+	
 	
-	oritaClient.client.socketToServer.receive("communication", (message)=>{
+	}, urlParam, portParam, isSecure);
 
-		// We execute eventual on message events listeners :
-		foreach(onCommunicationEventListeners, (e)=>{
-			if(!e.condition || e.condition(message))	e.execute(message);
-		});
 	
-	});
+	oritaClient.microClientsInfos={};
+	oritaClient.inputsGPIO={};
+	oritaClient.outputsGPIO={};
+	
 	
 	
 	
@@ -12088,16 +12102,7 @@ createOritaMainClient=function(
 
 
 
-createOritaMicroClient=function(){
-	
-
-
-
-
-
-
-
-
+createOritaMicroClient=function(url, port, isNode=false){
 
 
 
@@ -12111,7 +12116,6 @@ createOritaMicroClient=function(){
 		inputsGPIO:{},
 		
 		
-					
 	};
 		
 		
@@ -12123,7 +12127,7 @@ createOritaMicroClient=function(){
 
 			// Other parameters :
 			let allMediaParametersArray;
-			if (!isNode && !mediasArg) {
+			if(!isNode && !mediasArg){
 				allMediaParametersArray = getMediaParametersArray(getURLParameter("medias"), getURLParameter("vr"));
 			} else { // if we are in a node micro client context :
 				allMediaParametersArray = getMediaParametersArray(mediasArg);
@@ -12170,6 +12174,10 @@ createOritaMicroClient=function(){
 				oritaClient.client.socketToServer = WebsocketImplementation.getStatic(isNode).connectToServer(url, port);
 				oritaClient.client.socketToServer.onConnectionToServer(() => {
 
+
+
+
+
 					// TRACE
 					console.log("INFO : MICRO CLIENT : Sending register request...");
 
@@ -12185,167 +12193,186 @@ createOritaMicroClient=function(){
 
 					oritaClient.client.socketToServer.send("protocol", "request.register:microClient:" + microClientId);
 
-				});
-
-
-
-				oritaClient.client.socketToServer.receive("protocol", (message) => {
-
-					// TRACE
-					lognow("INFO : MICRO CLIENT : Server sent a message on the protocol channel : message:", JSON.stringify(message));
-
 
-					if (contains(message.type, "response.microClient.registered")) {
 
-						let microClientId = message.microClientId;
 
-						// To be sure this registration response does not concerns another micro client :
-						if (oritaClient.microClientId !== microClientId) return;
-
-
-						// DBG
-						lognow("		MICRO CLIENT REGISTERED : message:", message);
-
-
-						// CAUTION : ON TODAY, MICRO CLIENTS ONLY SUPPORT ONE MEDIA TO SEND AT THE TIME !!!
-						if (medias === "audio" || medias === "video") {
-
-							// TRACE
-							lognow("Starting micro client sending method for micro client microClientId «" + microClientId + "»:");
-
-
-							// START SENDING AUDIO OR VIDEO :
-							// Refreshing rate calculus :
-							let refreshingRateMillis = REFRESHING_RATE_MILLIS_DEFAULT;
-							if (medias === "audio") {
-								// (We want millis, not seconds)
-								refreshingRateMillis = Math.floor((audioBufferSize / selfMediaHandler.getAudioSampleRate()) * 1000);
-							} else if (medias === "video") {
-								refreshingRateMillis = nonull(oritaClient.captureConfig.refreshMillis, ORITA_CONSTANTS.DEFAULT_CAPTURE_REFRESH_MILLIS);
-							}
-
-							// *************************
-							// LOCAL SENDING LOOP :
-							oritaClient.sending = setInterval(function() {
-
-								let data = {};
-								if (medias === "video") {
-
-									let videoData = selfMediaHandler.getVideoData();
-
-
-									//		// DBG
-									//		console.log("INFO : MICRO CLIENT : videoData : ",videoData);
-
-									if (videoData && videoData.data) {
-
-										let videoRawData = videoData.data;
-
-
-										if (videoData.format !== "base64" && videoData.messWithAlpha) {
-											videoRawData = removeAlpha(videoRawData);
+	
+	
+	
+					// ------------------------------ CONNECTION EVENTS REGISTRATION ------------------------------
+					
+					oritaClient.client.socketToServer.receive("protocol", (message) => {
+	
+						// TRACE
+						lognow("INFO : MICRO CLIENT : Server sent a message on the protocol channel : message:", JSON.stringify(message));
+	
+	
+						if (contains(message.type, "response.microClient.registered")) {
+	
+							let microClientId = message.microClientId;
+	
+							// To be sure this registration response does not concerns another micro client :
+							if (oritaClient.microClientId !== microClientId) return;
+	
+	
+							// DBG
+							lognow("		MICRO CLIENT REGISTERED : message:", message);
+	
+	
+							// CAUTION : ON TODAY, MICRO CLIENTS ONLY SUPPORT ONE MEDIA TO SEND AT THE TIME !!!
+							if (medias === "audio" || medias === "video") {
+	
+								// TRACE
+								lognow("Starting micro client sending method for micro client microClientId «" + microClientId + "»:");
+	
+	
+								// START SENDING AUDIO OR VIDEO :
+								// Refreshing rate calculus :
+								let refreshingRateMillis = REFRESHING_RATE_MILLIS_DEFAULT;
+								if (medias === "audio") {
+									// (We want millis, not seconds)
+									refreshingRateMillis = Math.floor((audioBufferSize / selfMediaHandler.getAudioSampleRate()) * 1000);
+								} else if (medias === "video") {
+									refreshingRateMillis = nonull(oritaClient.captureConfig.refreshMillis, ORITA_CONSTANTS.DEFAULT_CAPTURE_REFRESH_MILLIS);
+								}
+	
+								// *************************
+								// LOCAL SENDING LOOP :
+								oritaClient.sending = setInterval(function() {
+	
+									let data = {};
+									if (medias === "video") {
+	
+										let videoData = selfMediaHandler.getVideoData();
+	
+	
+										//		// DBG
+										//		console.log("INFO : MICRO CLIENT : videoData : ",videoData);
+	
+										if (videoData && videoData.data) {
+	
+											let videoRawData = videoData.data;
+	
+	
+											if (videoData.format !== "base64" && videoData.messWithAlpha) {
+												videoRawData = removeAlpha(videoRawData);
+											}
+	
+											// We set the Side is «left» or «right»
+											if (videoSide) data.videoSide = videoSide;
+	
+											//		// TRACE
+											//		lognow("CLIENT : getting to send : videoRawData.length:"+videoRawData.length);
+	
+											// Actually, only handles "LZW" compression, for now...
+	
+											let stringToSend;
+											if (ORITA_CONSTANTS.STRINGIFY_VIDEO_DATA) stringToSend = arrayToString(videoRawData, false, 1);
+											else stringToSend = videoRawData;
+	
+	
+	
+											data.video = {
+												width: videoData.width,
+												height: videoData.height,
+												data: stringToSend,
+												messWithAlpha: videoData.messWithAlpha,
+												format: videoData.format,
+											};
+											data.compression = {
+												precision: 1,
+												//			        						algorithm:"LZW"
+											};
+	
 										}
-
-										// We set the Side is «left» or «right»
-										if (videoSide) data.videoSide = videoSide;
-
-										//		// TRACE
-										//		lognow("CLIENT : getting to send : videoRawData.length:"+videoRawData.length);
-
+	
+									} else if (medias === "audio") {
+	
+										let audioData = selfMediaHandler.getAudioData().data;
+	
+										//	    						// DBG
+										//	      						log("CLIENT : getting to send : audioData:"+audioData.length);
+	
 										// Actually, only handles "LZW" compression, for now...
-
-										let stringToSend;
-										if (ORITA_CONSTANTS.STRINGIFY_VIDEO_DATA) stringToSend = arrayToString(videoRawData, false, 1);
-										else stringToSend = videoRawData;
-
-
-
-										data.video = {
-											width: videoData.width,
-											height: videoData.height,
-											data: stringToSend,
-											messWithAlpha: videoData.messWithAlpha,
-											format: videoData.format,
-										};
-										data.compression = {
-											precision: 1,
-											//			        						algorithm:"LZW"
-										};
-
+										// DBG
+										//				    						let stringToSend=arrayToString(audioData,false,0.001);
+										//				    						data.audio={ data: stringToSend };
+										//				    						data.compression={precision:0.001,
+										//	//			    	algorithm:"LZW"
+										//				    						};
+	
+										// DBG
+										data.audio = { data: audioData };
+										data.compression = {};
+	
+									} else { // Case no medias selected
+										/*DO NOTHING*/
+										// // TRACE
+										// lognow("WARN : MICRO CLIENT : Caution, micro client has no data to send to main clients !");
+										return;
 									}
-
-								} else if (medias === "audio") {
-
-									let audioData = selfMediaHandler.getAudioData().data;
-
-									//	    						// DBG
-									//	      						log("CLIENT : getting to send : audioData:"+audioData.length);
-
-									// Actually, only handles "LZW" compression, for now...
-									// DBG
-									//				    						let stringToSend=arrayToString(audioData,false,0.001);
-									//				    						data.audio={ data: stringToSend };
-									//				    						data.compression={precision:0.001,
-									//	//			    	algorithm:"LZW"
-									//				    						};
-
-									// DBG
-									data.audio = { data: audioData };
-									data.compression = {};
-
-								} else { // Case no medias selected
-									/*DO NOTHING*/
-									// // TRACE
-									// lognow("WARN : MICRO CLIENT : Caution, micro client has no data to send to main clients !");
-									return;
+	
+	
+									//	// TRACE
+									//	lognow("CLIENT : SENDING DATA TO SERVER :");
+									//	    					// DBG
+									//	    					log("data:"+data);
+	
+	
+									data.microClientId = oritaClient.microClientId;
+	
+									// Micro client starts sending :
+									oritaClient.client.socketToServer.send("microClient.send.data", data);
+	
+	
+	
 								}
-
-
-								//	// TRACE
-								//	lognow("CLIENT : SENDING DATA TO SERVER :");
-								//	    					// DBG
-								//	    					log("data:"+data);
-
-
-								data.microClientId = oritaClient.microClientId;
-
-								// Micro client starts sending :
-								oritaClient.client.socketToServer.send("microClient.send.data", data);
-
-
-
+									, refreshingRateMillis); // SENDING LOOP
+								// *************************
 							}
-								, refreshingRateMillis); // SENDING LOOP
-							// *************************
+	
+	
+	
+							// We execute eventual on registration events listeners :
+							foreach(oritaClient.onRegistrationEventListeners, (e) => {
+								e.execute(microClientId, message);
+							});
+	
+	
+							//End of startResultPromise :
+							resolve(oritaClient); // CAUTION : Media handler might be ready AFTER this point !
 						}
-
-
-
-						// We execute eventual on registration events listeners :
-						foreach(oritaClient.onRegistrationEventListeners, (e) => {
-							e.execute(microClientId, message);
+	
+	
+	
+	
+	
+	
+					});
+	
+	
+	
+	
+					oritaClient.client.socketToServer.receive("communication", (message) => {
+						// We execute eventual on message events listeners :
+						foreach(oritaClient.onCommunicationEventListeners, (e) => {
+							if (!e.condition || e.condition(message)) e.execute(message);
 						});
+					});
+	
+	
+	
 
 
-						//End of startResultPromise :
-						resolve(oritaClient); // CAUTION : Media handler might be ready AFTER this point !
-					}
-
 
 
 
 
 
-				});
 
 
 
 
-				oritaClient.client.socketToServer.receive("communication", (message) => {
-					// We execute eventual on message events listeners :
-					foreach(oritaClient.onCommunicationEventListeners, (e) => {
-						if (!e.condition || e.condition(message)) e.execute(message);
-					});
 				});
 
 
@@ -12357,7 +12384,6 @@ createOritaMicroClient=function(){
 
 
 
-
 			};
 
 
@@ -12911,7 +12937,7 @@ createOritaMicroClient=function(){
 };
 
 
-/*utils GEOMETRY library associated with aotra version : «1_29072022-2359 (25/09/2022-17:58:54)»*/
+/*utils GEOMETRY library associated with aotra version : «1_29072022-2359 (27/09/2022-01:09:03)»*/
 /*-----------------------------------------------------------------------------*/
 
 
@@ -14139,7 +14165,7 @@ function rayVsUnitSphereClosestPoint(p, r) {
 // MUST REMAIN AT THE END OF THIS LIBRARY FILE !
 
 AOTRAUTILS_GEOMETRY_LIB_IS_LOADED=true;
-/*utils SERVER library associated with aotra version : «1_29072022-2359 (25/09/2022-17:58:54)»*/
+/*utils SERVER library associated with aotra version : «1_29072022-2359 (27/09/2022-01:09:03)»*/
 /*-----------------------------------------------------------------------------*/
 
 

aotrautils/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "aotrautils",
-	"version": "0.0.255",
+	"version": "0.0.257",
 	"main": "aotrautils.build.js",
 	"description": "A library for vanilla javascript utils (client-side) used in aotra javascript CMS",
 	"author": "Jeremie Ratomposon <info@alqemia.com> (https://alqemia.com)",