aotrautils 0.0.251 → 0.0.252

aotrautils/aotrautils.build.js

@@ -1,6 +1,6 @@
 
 
-/*utils COMMONS library associated with aotra version : «1_29072022-2359 (19/08/2022-00:31:09)»*/
+/*utils COMMONS library associated with aotra version : «1_29072022-2359 (25/09/2022-16:59:58)»*/
 /*-----------------------------------------------------------------------------*/
 
 
@@ -4827,7 +4827,7 @@ AOTRAUTILS_LIB_IS_LOADED=true;
 
 
 
-/*utils CLIENT library associated with aotra version : «1_29072022-2359 (19/08/2022-00:31:09)»*/
+/*utils CLIENT library associated with aotra version : «1_29072022-2359 (25/09/2022-16:59:58)»*/
 /*-----------------------------------------------------------------------------*/
 /* ## Utility global methods in a browser (htmljs) client environment.
  *
@@ -7726,11 +7726,13 @@ function filterPoints(allPoints ,ctx/*DBG*/){
 //	const VIDEOTAG_ID="videoElement";
 	
 	const DEFAULT_AUDIO_BUFFER_SIZE=4096;
-	const DEFAULT_WIDTH=300;
-	const DEFAULT_HEIGHT=300;
+	// const DEFAULT_WIDTH=1920;
+ 	// const DEFAULT_HEIGHT=1080;
+	const DEFAULT_WIDTH=1280;
+ 	const DEFAULT_HEIGHT=720;
 	
-	var width=size && size.width?size.width:DEFAULT_WIDTH;
-	var height=size && size.height?size.height:DEFAULT_HEIGHT;
+	let width=size && size.width?size.width:null;
+	let height=size && size.height?size.height:null;
 	
 	
 	audioBufferSize=nonull(audioBufferSize,DEFAULT_AUDIO_BUFFER_SIZE);
@@ -7799,14 +7801,13 @@ function filterPoints(allPoints ,ctx/*DBG*/){
 	}; 
 
 
-	const backgroundContainerDiv=document.body;
+// UNUSED :	const backgroundContainerDiv=document.body;
 
 	
 	// This temporary, off-screen canvas is always used to get the image data for further use :
-	let canvasTag;
-	canvasTag=document.createElement("canvas");
-	canvasTag.width=width;
-	canvasTag.height=height;
+	let canvasTag=document.createElement("canvas");
+	if(width)		canvasTag.width=width;
+	if(height)	canvasTag.height=height;
 //canvasTag.style.display="none";
 
 
@@ -7814,10 +7815,20 @@ function filterPoints(allPoints ,ctx/*DBG*/){
 	let videoTag;
 	if(!tagConfig || !tagConfig.videoToUse){
 		videoTag=document.createElement("video");
+		videoTag.id="tmpVideoElement";
 		videoTag.autoplay=true;
 		videoTag.width=canvasTag.width;
 		videoTag.height=canvasTag.height;
-	//	videoTag.style.display="none";
+		videoTag.style.width=canvasTag.width+"px";
+		videoTag.style.height=canvasTag.height+"px";
+
+//		// UNUSEFUL (SINCE VIDEO ELEMENT IS NEVER APPENDED TO PAGE !) :
+//		videoTag.style.position="absolute";
+//		videoTag.style["pointer-events"]="none";
+//		videoTag.style.display="none";
+//		videoTag.style.display="none";
+//		document.body.appendChild(videoTag);
+
 	}else{
 		videoTag=tagConfig.videoToUse;
 	}
@@ -7825,6 +7836,8 @@ function filterPoints(allPoints ,ctx/*DBG*/){
 	
 		
 	mediaHandler.video=videoTag;
+
+
 	// UNUSED
 //	mediaHandler.isReady=function(){
 ////	return mediaHandler.video !== null;
@@ -7834,7 +7847,21 @@ function filterPoints(allPoints ,ctx/*DBG*/){
 	// 2- Method to start the media stream :
 	const startStream=function(constraints){
 		
-		if(!constraints)	constraints={video: isVideo, audio: isAudio};
+		if(!constraints){
+			//constraints={video: (isVideo?{zoom:true,width:{ideal:nonull(width,DEFAULT_WIDTH)},height:{ideal:nonull(height,DEFAULT_HEIGHT)}}:false), audio: isAudio};
+			// DBG
+			constraints={video: (isVideo?
+								{width:nonull(width,DEFAULT_WIDTH),height:nonull(height,DEFAULT_HEIGHT)}
+//// ALTERNATIVELY, AND MORE FINE_TUNED  :
+//							{zoom:true,mandatory: {
+//                            minWidth: 1280,
+//                            maxWidth: 1280,
+//                            minHeight: 720,
+//                            maxHeight: 720,
+//                            }
+//							}
+							:false), audio: isAudio};
+		}
 		
 		// TRACE
 		console.log("INFO : Trying to start mediaHandler stream with constraints :",JSON.stringify(constraints));
@@ -7846,6 +7873,23 @@ function filterPoints(allPoints ,ctx/*DBG*/){
 	    		// UNUSED
 	//    	mediaHandler.stream=stream;
 	
+					const streamSettings = stream.getVideoTracks()[0].getSettings();
+	
+	
+					// DBG
+					lognow("(DEBUG) streamSettings:",streamSettings);
+					lognow("(DEBUG) stream:",stream);
+					lognow("(DEBUG) stream.getVideoTracks():",stream.getVideoTracks());
+					
+	
+					if(streamSettings){
+						if(!canvasTag.width &&  streamSettings.width)	width=streamSettings.width;
+						if(!canvasTag.height && streamSettings.height)	height=streamSettings.height;
+						if(!canvasTag.width &&  width)		canvasTag.width=width;
+						if(!canvasTag.height && height)		canvasTag.height=height;
+					}
+
+	
 	      	// Video part :
 	    		if(isVideo){
 	    			
@@ -7854,18 +7898,32 @@ function filterPoints(allPoints ,ctx/*DBG*/){
 	    			
 	    			// We always have a video tag (to grab the video data)
 	  				if(!isArray(mediaHandler.video)){
+	  					
 	  					mediaHandler.video.srcObject=stream;
+//	  					DOES NOT WORK : mediaHandler.video.src=stream;
+	  					
 	  					// NO : DOES NOT WORK (CREATES A BLANK IMAGE !) mediaHandler.video.muted=true;
 	  					// STUPID WORKAROUND : Because apparently, if volume==0 or video is muted, then the image data is all black !!!
 	  					mediaHandler.video.volume=0.0000000000001;
 	//  				mediaHandler.video.autoplay=true;
-	  				}else{
-	  					foreach(mediaHandler.video,(v)=>{	
+	
+							if(tagConfig && tagConfig.videoToUse && tagConfig.videoZoom){
+								if(isNumber(tagConfig.videoZoom)){
+									mediaHandler.video.style.scale=tagConfig.videoZoom;
+								}
+							}
+							
+	  				}else{	// Audio part :
+		
+	  					foreach(mediaHandler.video,(v)=>{
+	  						
 	  						v.srcObject=stream;
+	  						
 	  						// NO : DOES NOT WORK (CREATES A BLANK IMAGE !) v.muted=true;
 	    					// STUPID WORKAROUND : Because apparently, if volume==0 or video is muted, then the image data is all black !!!
 	  						v.volume=0.0000000000001;
 	//  					v.autoplay=true;
+	
 	  					});
 	  				}
 	
@@ -7906,7 +7964,7 @@ function filterPoints(allPoints ,ctx/*DBG*/){
 							let video=event.target;
 			      			video.play();
 				        	if(tagConfig.videoMuted)	video.muted=true;
-				        	else						delete video.muted;
+				        	else											delete video.muted;
 			        	};
 	    			}else{
 	    				foreach(mediaHandler.video,(v)=>{	
@@ -7914,7 +7972,7 @@ function filterPoints(allPoints ,ctx/*DBG*/){
 	  		      				let video=event.target;
 	  		      				video.play();
 						        	if(tagConfig.videoMuted)	video.muted=true;
-						        	else							 delete video.muted;
+						        	else							 				delete video.muted;
 	  		          	};
 	    				});
 	    			}
@@ -8070,7 +8128,7 @@ drawVideoImage=function(canvas,videoImage,
 
 		// We copy the data in canvas :
 		imageData=ctx.getImageData(x, y, oldWidth, oldHeight);
-		// NE MARCHE PAS :
+		// CAUTION : DOES NOT WORK :
 	//	var imageData=ctx.createImageData(oldWidth, oldHeight);
 		normalizeData(videoRawImageData, imageData.data, isMessWithAlpha);
 
@@ -9580,6 +9638,7 @@ function offsetColorOnArea(correctionValue, x1, y1, x2, y2, data, totalWidth){
 function getLinearIndexForCoordinates(x, y, totalWidth, step){
 	return Math.floor((x + y * totalWidth) * step);
 }
+
 function getCoordinatesForLinearIndex(index, totalWidth, step=1){
 	let actualIndex=index/step;
 	let actualWidth=totalWidth;
@@ -9594,7 +9653,6 @@ function indexIsOutsideArea(indexParam, x1, y1, x2, y2, data, totalWidth, step){
 	if (0<step)
 		index=index / step;
 	return (index % totalWidth<x1 || x2<index % totalWidth) || (index<x1 + y1 * totalWidth || x2 + y2 * totalWidth<index);
-
 }
 
 function createColor(r, g, b){
@@ -11612,28 +11670,35 @@ class VNCFrame2D{
 
 
 
+
+
+// ============================================== BROWSER CLIENTS ==============================================
+
+
+// FUSRODA : 
+
 createFusrodaClient=function(doOnClientReady, doOnDataReception, urlParam=null, portParam=6080){
  	// CAUTION : WORKS BETTER WHEN UNSECURE, BUT 'NEEDS CLIENT BROWSER TO ALLOW MIXED (SECURE/UNSECURE) CONTENT !
 	
 	const isSecure=(contains(urlParam.toLowerCase(),"https") || contains(urlParam.toLowerCase(),"wss"));
 	
 	
-	const fusrodaClient=initClient(false,true, (browserClientInstance)=>{
+	const fusrodaClient=initClient(false,/*CAUTION : Fusroda Java server requires the SOcket IO websocket implementation !!*/true, /*doOnServerConnection*/(socketToServer)=>{
 		
 		// DBG
-		lognow("SETTING UP");
+		lognow("FUSRODA CLIENT : SETTING UP");
 		
 		//0)
-		fusrodaClient.client.socketToServer.send("protocol", { type:"hello" });
+		socketToServer.send("protocol", { type:"hello" });
 		//1)
-		browserClientInstance.receive("protocolConfig", (messageConfig)=>{
+		socketToServer.receive("protocolConfig", (messageConfig)=>{
 			//2)			
-			fusrodaClient.client.socketToServer.send("screenFrameRequest", {});
-			browserClientInstance.receive("imagePacket", (doOnDataReception && doOnDataReception["image"]?doOnDataReception["image"]:()=>{/*DO NOTHING*/}));
+			socketToServer.send("screenFrameRequest", {});
+			socketToServer.receive("imagePacket", (doOnDataReception && doOnDataReception["image"]?doOnDataReception["image"]:()=>{/*DO NOTHING*/}));
 
 			//2)			
-			fusrodaClient.client.socketToServer.send("soundSampleRequest", {});
-			browserClientInstance.receive("soundPacket", (doOnDataReception && doOnDataReception["sound"]?doOnDataReception["sound"]:()=>{/*DO NOTHING*/}));
+			socketToServer.send("soundSampleRequest", {});
+			socketToServer.receive("soundPacket", (doOnDataReception && doOnDataReception["sound"]?doOnDataReception["sound"]:()=>{/*DO NOTHING*/}));
 
 
 			doOnClientReady(messageConfig);
@@ -11676,7 +11741,1176 @@ createFusrodaClient=function(doOnClientReady, doOnDataReception, urlParam=null,
 
 
 
-/*utils GEOMETRY library associated with aotra version : «1_29072022-2359 (19/08/2022-00:31:09)»*/
+
+
+
+
+
+// ORITA :
+
+
+
+// ------------------------------------------------------------------------------------------
+// -------------------------------------- MAIN CLIENT --------------------------------------
+// ------------------------------------------------------------------------------------------
+
+createOritaMainClient=function(
+ doOnRegistered,
+ treatVideoData, treatAudioData,
+ doOnInputsCreated, doOnInputsUpdated, doOnOutputsCreated, doOnOutputsUpdated,
+ urlParam=null, portParam=25000, ignoreHashKey=false){
+
+	const ORITA_HASH_STRING_NAME="oritaClientHash";
+
+	const isSecure=(contains(urlParam.toLowerCase(),"https") || contains(urlParam.toLowerCase(),"wss"));
+
+
+
+	const onCommunicationEventListeners=[];
+	
+	// ---------------------------------------------------------------------
+	// I/Os setup
+	
+	
+	// Inputs :
+	
+	// 2-
+	onCommunicationEventListeners.push({
+		condition:(message)=>message.type==="request.microClient.appendInputs",
+		execute:(message)=>{
+			let inputsGPIO=message.inputsGPIO;
+			let microClientId=message.microClientId;
+			
+			let microClientInfos=mainClient.oritaMainClient.microClientsInfos[microClientId];
+			if(!microClientInfos)	mainClient.oritaMainClient.microClientsInfos[microClientId]={};
+			microClientInfos=mainClient.oritaMainClient.microClientsInfos[microClientId];
+			if(microClientInfos.hasInputs)	return; // (to avoid registering several times)
+			microClientInfos.hasInputs=true;
+			
+			microClientInfos.lastTime=getNow();
+			mainClient.inputsGPIO=inputsGPIO;
+			
+			
+			doOnInputsCreated(mainClient, microClientId, mainClient.inputsGPIO);
+		},
+	});
+	
+	// 4-
+	onCommunicationEventListeners.push({
+		condition:(message)=>message.type==="request.microClient.updateInputsValues",
+		execute:(message)=>{
+
+			let inputsGPIO=message.inputsGPIO;
+					
+		//				// DBG
+		//				console.log("updateInputsValues UPDATE VALUE ! message:",message);
+		//				console.log("updateInputsValues UPDATE VALUE ! inputsGPIO:",inputsGPIO);
+					
+					
+			let microClientId=message.microClientId;
+			
+			let microClientInfos=mainClient.oritaMainClient.microClientsInfos[microClientId];
+			if(!microClientInfos)	mainClient.oritaMainClient.microClientsInfos[microClientId]={};
+			microClientInfos=mainClient.oritaMainClient.microClientsInfos[microClientId];
+			microClientInfos.lastTime=getNow();
+		
+			mainClient.inputsGPIO=inputsGPIO;
+			
+			
+			
+			doOnInputsUpdated(mainClient, microClientId, mainClient.inputsGPIO);
+		},
+	});
+				
+	
+	
+
+	// Outputs :
+
+	// 2-
+	onCommunicationEventListeners.push({
+		condition:(message)=>message.type==="request.microClient.appendOutputs",
+		execute:(message)=>{
+			let outputsGPIOLocal=message.outputsGPIO;
+			let microClientId=message.microClientId;
+			
+			let microClientInfos=mainClient.oritaMainClient.microClientsInfos[microClientId];
+			if(!microClientInfos)	mainClient.oritaMainClient.microClientsInfos[microClientId]={};
+			microClientInfos=mainClient.oritaMainClient.microClientsInfos[microClientId];
+			if(microClientInfos.hasOutputs)	return; // (to avoid registering several times)
+			microClientInfos.hasOutputs=true;
+			
+			microClientInfos.lastTime=getNow();
+			
+			mainClient.outputsGPIO=outputsGPIOLocal;
+			
+			
+			doOnOutputsCreated(mainClient, microClientId, mainClient.outputsGPIO);
+			
+		},
+	});
+
+	// 4-
+	onCommunicationEventListeners.push({
+		condition:(message)=>message.type==="response.microClient.outputChanged",
+		execute:(message)=>{
+
+			let outputsGPIOLocal=message.outputsGPIO;
+			let microClientId=message.microClientId;
+
+					
+		//				// DBG
+		//				console.log("outputChanged UPDATE VALUE ! message:",message);
+		//				console.log("outputChanged UPDATE VALUE ! outputsGPIOLocal:",outputsGPIOLocal);
+		
+			mainClient.outputsGPIO=outputsGPIOLocal;
+			
+			doOnOutputsUpdated(microClientId, mainClient.outputsGPIO);
+		},
+	});
+
+	
+
+
+
+
+	const oritaClient=initClient(false, false, /*doOnServerConnection*/(socketToServer)=>{
+
+		// DBG
+		lognow("ORITA MAIN CLIENT : SETTING UP");
+	
+		// TRACE
+		console.log("INFO : MAIN CLIENT : Sending register request...");
+		
+		
+		// TRACE
+		console.log("INFO : MAIN CLIENT : Checking registered client key hash...");
+		
+		const storedHashKey=getStringFromStorage(ORITA_HASH_STRING_NAME);
+		if(!storedHashKey && !ignoreHashKey){
+			promptWindow("Please enter your client key :","password",null,(clearText)=>{
+			
+				if(empty(clearText)){
+					// TRACE
+					lognow("ERROR : MAIN CLIENT : Client key string is empty. Cannot proceed to registration request sending to server.");
+					return;
+				}
+				
+				const calculatedHash=getHashedString(clearText);// (we use the heavy treatment thing.)
+			
+				storeString(ORITA_HASH_STRING_NAME, calculatedHash);
+			
+				// TODO : FIXME : DUPLICATED CODE :
+				socketToServer.send("protocol", "request.register:mainClient:"+calculatedHash);
+								
+			},()=>{
+				// TRACE
+				lognow("WARN : MAIN CLIENT : Cannot send registration request to server if no client key is provided.");
+			});		        
+		    
+		}else{
+			// TODO : FIXME : DUPLICATED CODE :
+			socketToServer.send("protocol", "request.register:mainClient:"+storedHashKey);
+		}
+
+	
+	
+	}, urlParam, portParam, isSecure);
+
+	
+	oritaClient.microClientsInfos={};
+	oritaClient.inputsGPIO={};
+	oritaClient.outputsGPIO={};
+	
+	
+
+	
+			
+	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 :");
+					
+					
+					
+					
+					// Main client starts receiving :
+					oritaClient.client.socketToServer.receive("server.send.data", (receivedData)=>{
+	
+						
+						let microClientId=receivedData.microClientId;
+						
+//						// 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();
+							
+							
+							
+							treatVideoData();
+							
+							
+						
+						}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();
+							
+						
+						}
+						
+					});
+					
+					
+	
+					
+					
+					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);
+		});
+	
+	});
+	
+	
+	
+	
+	
+
+	return oritaClient;
+};
+
+
+
+
+// ------------------------------------------------------------------------------------------
+// -------------------------------------- MICRO CLIENT --------------------------------------
+// ------------------------------------------------------------------------------------------
+
+
+
+
+	// const REFRESHING_RATE_MILLIS_AUDIO:100,
+
+
+	//	const MICRO_CLIENT_MESS_WITH_ALPHA=true;
+	//	const MICRO_CLIENT_MESS_WITH_ALPHA=false;
+
+
+	const REFRESHING_RATE_MILLIS_DEFAULT = 1000;
+
+
+	// Output constants :	
+	const STEPPER_DELAY_MILLIS = 1;
+	const DEFAULT_STEPPER_SEQUENCE = [
+		[1, 0, 0, 0],
+		[0, 1, 0, 0],
+		[0, 0, 1, 0],
+		[0, 0, 0, 1],
+	];
+	const HALF_STEP_STEPPER_SEQUENCE = [
+		[0, 1, 0, 0],
+		[0, 1, 0, 1],
+		[0, 0, 0, 1],
+		[1, 0, 0, 1],
+		[1, 0, 0, 0],
+		[1, 0, 1, 0],
+		[0, 0, 1, 0],
+		[0, 1, 1, 0],
+	];
+
+
+
+createOritaMicroClient=function(){
+	
+
+
+
+
+
+
+
+
+
+
+
+	
+	let oritaClient={
+	
+		onRegistrationEventListeners:[],
+		onCommunicationEventListeners:[],
+		
+		outputsGPIO:{},
+		inputsGPIO:{},
+		
+		
+					
+	};
+		
+		
+
+	oritaClient.start = function(mediasArg = null) {
+
+		const startResultPromise = new Promise((resolve, reject) => {
+
+
+			// Other parameters :
+			let allMediaParametersArray;
+			if (!isNode && !mediasArg) {
+				allMediaParametersArray = getMediaParametersArray(getURLParameter("medias"), getURLParameter("vr"));
+			} else { // if we are in a node micro client context :
+				allMediaParametersArray = getMediaParametersArray(mediasArg);
+			}
+			let mediaParametersArray = allMediaParametersArray.medias;
+
+
+
+
+			let captureWidth = null;
+			let captureHeight = null;
+			let containsVideoOrAudio = false;
+			foreach(mediaParametersArray, (mediasConfigElement) => {
+				if (contains(["video", "audio"], mediasConfigElement.medias)) {
+					containsVideoOrAudio = true;
+					return "break";
+				}
+			});
+			if (containsVideoOrAudio) {
+				captureWidth = nonull(oritaClient.captureConfig.width, ORITA_CONSTANTS.DEFAULT_CAPTURE_WIDTH);
+				captureHeight = nonull(oritaClient.captureConfig.height, ORITA_CONSTANTS.DEFAULT_CAPTURE_HEIGHT);
+			}
+
+			// DBG
+			lognow("INFO : MICRO CLIENT : Starting micro client...", mediasArg);
+
+
+			const doOnStartMediaHandlerMicroClient = (selfMediaHandler = null, medias = null, videoSide = null) => {
+
+
+				// We have to wait for the medias handler to be ready, before doing anything :
+
+				// TRACE
+				if (selfMediaHandler) lognow("INFO : MICRO CLIENT : microClient started with mediahandler.");
+				else lognow("INFO : MICRO CLIENT : microClient started without mediahandler.");
+
+
+
+
+				// TODO : FIXME : Utiliser initClient(...) au lieu de directement getStatic(...) avec le paramètre isNode transmis dans l'appel)
+				//oritaClient=initClient(isNode,false,doOnServerConnection=null, url, port);
+
+				oritaClient.client={};
+				oritaClient.client.socketToServer = WebsocketImplementation.getStatic(isNode).connectToServer(url, port);
+				oritaClient.client.socketToServer.onConnectionToServer(() => {
+
+					// TRACE
+					console.log("INFO : MICRO CLIENT : Sending register request...");
+
+					// Only micro client determines its own id ! (to avoid multi-registration protocol bug !)
+
+					let microClientId = getUUID("short");
+
+					oritaClient.microClientId = microClientId;
+
+					// TRACE
+					lognow("INFO : (CLIENT) Microclient will now register to server with microClientId «" + microClientId + "».");
+
+
+					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);
+										}
+
+										// 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"
+										};
+
+									}
+
+								} 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);
+
+
+
+							}
+								, 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 !
+					}
+
+
+
+
+
+
+				});
+
+
+
+
+				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);
+					});
+				});
+
+
+
+
+
+
+
+
+
+
+
+			};
+
+
+
+
+
+
+			// TODO FIXME : Now, we launch one thread loop for each media handler of this medias array,
+			// instead of launching only one thread for all media handlers :
+
+
+
+			foreach(mediaParametersArray, (mediaParameters) => {
+
+				let mediaHandlerLocal = null;
+
+
+				let videoSide = mediaParameters.videoSide;
+				let medias = mediaParameters.medias;
+				let webcamIndex = mediaParameters.webcamIndex;
+				let microphoneIndex = mediaParameters.microphoneIndex;
+
+
+
+				// TRACE
+				lognow("INFO : MICRO CLIENT : Microclient started :");
+
+				// DBG
+				lognow("INFO : MICRO CLIENT : Chosen webcamIndex : " + webcamIndex);
+				lognow("INFO : MICRO CLIENT : Chosen microphoneIndex : " + microphoneIndex);
+
+
+				try {
+
+
+
+					if (!isNode) {
+
+						//	OLD : if(webcamIndex)			videoConstraints={deviceId: { exact: cameras[webcamIndex].deviceId }};
+						getMediaHandler(
+							medias === "video" ? { webcamIndex: webcamIndex } : null,
+							medias === "audio" ? { microphoneIndex: microphoneIndex } : null,
+							//										CHANNELS_CONFIG,
+							{ width: captureWidth, height: captureHeight },
+							null, /*(no need for a direct video tag possibility for micro client)*/
+							audioBufferSize, 1/*(means mono audio)*/,
+							(mh) => {
+								//DBG
+								console.log("mh:", mh); console.log("medias:", medias);
+								doOnStartMediaHandlerMicroClient(mh, medias, videoSide);
+							},
+							(mh) => { mediaHandlerLocal = mh; });
+
+					} else { // Case node micro client :
+
+
+
+						// DBG
+						console.log("mediaParameters", mediaParameters);
+						console.log("medias", medias);
+
+
+						const videoConfigLocal = (medias === "video" ? (webcamIndex != null ? { webcamIndex: webcamIndex } : ORITA_CONSTANTS.MOBILE_VIDEO_CONSTRAINTS) : null);
+						const audioConfigLocal = (medias === "audio" ? (microphoneIndex != null ? { microphoneIndex: microphoneIndex } : {}) : null);
+
+						// DBG
+						console.log("videoConfigLocal", videoConfigLocal);
+						console.log("webcamIndex", webcamIndex);
+						console.log("ORITA_CONSTANTS.MOBILE_VIDEO_CONSTRAINTS", ORITA_CONSTANTS.MOBILE_VIDEO_CONSTRAINTS);
+						console.log("audioConfigLocal", audioConfigLocal);
+
+
+						mediaHandlerLocal = getNodeMediaHandler(
+							videoConfigLocal,
+							audioConfigLocal,
+							//									CHANNELS_CONFIG,
+							{ width: captureWidth, height: captureHeight },
+							audioBufferSize, 1/*(means mono audio)*/,
+							(mh) => { doOnStartMediaHandlerMicroClient(mh, medias, videoSide); });
+
+
+					}
+
+				} catch (e) {
+					// TRACE
+					log("ERROR : Media handler error occured while trying to be initialized for microClient:");
+					log(e);
+					return;
+				}
+
+				//				if(!mediaHandlerLocal){
+				//					// TRACE
+				//					log("ERROR : Media handler is null for microClient.");
+				//					return;
+				//				}
+
+
+			});
+
+
+			if (empty(mediaParametersArray)) doOnStartMediaHandlerMicroClient();
+
+		});
+
+
+		return startResultPromise;
+	};
+
+
+
+	// ******************
+
+	// List manager treatments :
+	oritaClient.onRegistrationEventListeners.push({
+		execute: (microClientId, message) => {
+
+			const listPosition = message.listPosition;
+			if (!nothing(listPosition)) {
+				// TRACE
+				lognow("INFO : Client has position «" + listPosition + "» in server list.");
+				oritaClient.listPosition = listPosition;
+			}
+		}
+	});
+
+
+	// Inputs / outputs :
+	oritaClient.onRegistrationEventListeners.push({
+		execute: (microClientId, message) => {
+
+			if (empty(oritaClient.inputsGPIO) && empty(oritaClient.outputsGPIO)) return;
+
+
+			oritaClient.onCommunicationEventListeners.push({
+				condition: (message) => message === "request.server.signalIOs",
+				execute: (message) => {
+
+					// DBG
+					lognow("SIGNALING !!!");
+
+
+					if (!empty(oritaClient.inputsGPIO)) {
+
+						// DBG
+						lognow("SIGNALING INPUTS");
+
+						oritaClient.client.socketToServer.send("communication", {
+							type: "request.microClient.appendInputs",
+							inputsGPIO: oritaClient.inputsGPIO,
+							microClientId: oritaClient.microClientId,
+						});
+					}
+
+					if (!empty(oritaClient.outputsGPIO)) {
+
+						// DBG
+						lognow("SIGNALING OUTPUTS");
+
+						oritaClient.client.socketToServer.send("communication", {
+							type: "request.microClient.appendOutputs",
+							outputsGPIO: oritaClient.outputsGPIO,
+							microClientId: oritaClient.microClientId,
+						});
+					}
+
+				},
+
+			});
+
+
+
+		},
+
+	});
+
+
+	// Inputs :
+	oritaClient.registerInputsGPIO = (gpios, refreshRateMillis = 1000) => {
+
+		// 0-
+		foreach(gpios, (gpioNumber, gpioId) => {
+			let input = {
+				gpioId: gpioId,
+				gpioNumber: gpioNumber,
+				state: null,
+				init: () => {
+					gpioUtils.open(input.gpioNumber, "in");
+					input.previousState = null;
+				},
+				read: () => {
+
+					gpioUtils.read(input.gpioNumber, (state) => {
+						input.previousState = input.state;
+						input.state = state;
+
+						//							// DBG
+						//							console.log("~~~READ STATE : ",input.state);
+					});
+
+				},
+			};
+			input.init();
+			oritaClient.inputsGPIO[gpioId] = input;
+		});
+
+
+		// 1-
+		oritaClient.onRegistrationEventListeners.push({
+			execute: (microClientId, message) => {
+				oritaClient.client.socketToServer.send("communication", {
+					type: "request.microClient.appendInputs",
+					inputsGPIO: oritaClient.inputsGPIO,
+					microClientId: oritaClient.microClientId,
+				});
+			},
+		});
+
+		// 3-
+		setInterval(() => {
+
+			let inputsGPIO = oritaClient.inputsGPIO;
+
+			foreach(inputsGPIO, (input) => {
+				input.read();
+			});
+
+
+			oritaClient.client.socketToServer.send("communication", {
+				type: "request.microClient.updateInputsValues",
+				inputsGPIO: inputsGPIO,
+				microClientId: oritaClient.microClientId,
+			});
+
+
+		}, refreshRateMillis);
+
+
+		return oritaClient;
+	};
+
+
+
+
+	// Outputs :
+	oritaClient.stepperIntervalRoutines = {};
+	oritaClient.registerOutputsGPIO = (gpios) => {
+
+		// 0-
+		foreach(gpios, (gpioInfos, gpioId) => {
+
+			let output = {
+				gpioId: gpioId,
+				gpioInfos: gpioInfos,
+				state: null,
+				collisionningOutputsIds: null,
+				//					lastPhaseIndex:null,
+				//					phaseIndex:0,
+				sequenceIndex: 0,
+				init: () => {
+
+					if (isNumber(output.gpioInfos)) {
+						const gpioNumber = output.gpioInfos;
+						gpioUtils.open(gpioNumber, "out");
+
+					} else {
+						foreach(output.gpioInfos.phases, (phase) => {
+							const gpioNumber = phase;
+							gpioUtils.open(gpioNumber, "out");
+
+						});
+					}
+
+					output.previousState = null;
+					output.state = false;
+				},
+				on: (doOnEndCommand = null/*UNUSED*/) => {
+
+					// Other outputs exclusion :
+					if (output.collisionningOutputsIds) {
+						foreach(output.collisionningOutputsIds, (collisionningOutputId) => {
+							const collisionningOutput = oritaClient.outputsGPIO[collisionningOutputId];
+							if (!collisionningOutput) return "continue";
+							collisionningOutput.off(doOnEndCommand);
+						}, (collisionningOutputId) => {
+							const collisionningOutput = oritaClient.outputsGPIO[collisionningOutputId];
+							return collisionningOutput && collisionningOutput.state;
+						});
+					}
+
+
+					if (isNumber(output.gpioInfos)) {
+						// Case one single 0/1 output :
+						const gpioNumber = output.gpioInfos;
+
+						gpioUtils.write(gpioNumber, 1, doOnEndCommand);
+
+
+					} else {
+
+						// Case stepper motor output:
+						const direction = nonull(output.gpioInfos.direction, 1);
+						let sortedPhases;
+						if (direction == -1) {
+							sortedPhases = [];
+							if (!empty(output.gpioInfos.phases)) {
+								for (let i = output.gpioInfos.phases.length - 1; 0 <= i; i--) {
+									sortedPhases.push(output.gpioInfos.phases[i]);
+								}
+							}
+						} else {
+							sortedPhases = output.gpioInfos.phases;
+						}
+
+						const sequence = nonull(output.gpioInfos.sequence, DEFAULT_STEPPER_SEQUENCE);
+						const stepDelayMillis = output.gpioInfos.stepDelayMillis;
+						const stepperMethodCallback = async () => {
+
+							const outputSelf = stepperMethodCallback.output;
+							const sortedPhasesSelf = stepperMethodCallback.sortedPhases;
+
+							await new Promise((resolve, reject) => setTimeout(resolve, STEPPER_DELAY_MILLIS));
+							const sequenceLine = sequence[outputSelf.sequenceIndex];
+							if (sequenceLine && !empty(sequenceLine)) {
+								foreach(sequenceLine, (phaseState, i) => {
+									const gpioNumber = sortedPhasesSelf[i];
+									gpioUtils.write(gpioNumber, phaseState, doOnEndCommand);
+								});
+							}
+
+							if (outputSelf.sequenceIndex < sequence.length - 1) outputSelf.sequenceIndex++;
+							else outputSelf.sequenceIndex = 0;
+						};
+
+						stepperMethodCallback.output = output;
+						stepperMethodCallback.sortedPhases = sortedPhases;
+						const stepperMethod = setInterval(stepperMethodCallback, stepDelayMillis);
+						oritaClient.stepperIntervalRoutines[gpioId] = stepperMethod;
+
+
+
+					}
+
+					output.previousState = output.state;
+					output.state = true;
+				},
+				off: (doOnEndCommand = null/*UNUSED*/) => {
+
+					if (isNumber(output.gpioInfos)) {
+						// Case one single 0/1 output :
+						const gpioNumber = output.gpioInfos;
+						gpioUtils.write(gpioNumber, 0, doOnEndCommand);
+
+					} else {
+						// Case stepper motor output:
+						foreach(output.gpioInfos.phases, (phase) => {
+							const gpioNumber = phase;
+							gpioUtils.write(gpioNumber, 0, doOnEndCommand);
+						});
+						clearInterval(oritaClient.stepperIntervalRoutines[gpioId]);
+						oritaClient.stepperIntervalRoutines[gpioId] = null;
+					}
+
+					output.previousState = output.state;
+					output.state = false;
+				},
+			};
+			output.init();
+
+
+			// We detect the possible outputs collisions among all the already registered outputs :
+			foreach(oritaClient.outputsGPIO, (otherOutput, otherOutputName) => {
+
+				const collisionningOutputsIdsAndPhases = {};
+				if (isNumber(otherOutput.gpioInfos)) {
+					const phase = otherOutput.gpioInfos;
+					if (!collisionningOutputsIdsAndPhases[otherOutputName]) {
+						collisionningOutputsIdsAndPhases[otherOutputName] = { outputId: otherOutput.gpioId, phases: [phase] };
+					} else {
+						collisionningOutputsIdsAndPhases[otherOutputName].phases.push(phase);
+					}
+				} else {
+					foreach(gpioInfos.phases, (phase) => {
+						if (contains(otherOutput.gpioInfos.phases, phase)) {
+							if (!collisionningOutputsIdsAndPhases[otherOutputName]) {
+								collisionningOutputsIdsAndPhases[otherOutputName] = { outputId: otherOutput.gpioId, phases: [phase] };
+							} else {
+								collisionningOutputsIdsAndPhases[otherOutputName].phases.push(phase);
+							}
+						}
+					});
+				}
+				if (!empty(collisionningOutputsIdsAndPhases)) {
+					//						// DEBUG
+					//						lognow("WARN : Found another outputsGPIO using this phase : ",collisionningOutputsIdsAndPhases);
+					output.collisionningOutputsIds = [];
+					foreach(collisionningOutputsIdsAndPhases, (collisionningOutputIdAndPhases) => {
+						const collisionningOutput = oritaClient.outputsGPIO[collisionningOutputIdAndPhases.outputId];
+						if (!collisionningOutput) return "continue";
+						output.collisionningOutputsIds.push(collisionningOutputIdAndPhases.outputId);
+						// Backlink :
+						if (!collisionningOutput.collisionningOutputsIds) collisionningOutput.collisionningOutputsIds = [];
+						collisionningOutput.collisionningOutputsIds.push(output.gpioId);
+					});
+				}
+			});
+
+
+			// We add this output to the micro client outputs :
+			oritaClient.outputsGPIO[gpioId] = output;
+		});
+
+		// 1-
+		oritaClient.onRegistrationEventListeners.push({
+			execute: (microClientId, message) => {
+				oritaClient.client.socketToServer.send("communication", {
+					type: "request.microClient.appendOutputs",
+					outputsGPIO: oritaClient.outputsGPIO,
+					microClientId: oritaClient.microClientId,
+				});
+			},
+		});
+
+		// 3-
+		oritaClient.onCommunicationEventListeners.push({
+			condition: (message) => message.type === "request.mainClient.outputChanged",
+			execute: (message) => {
+
+				//					foreach(message.outputsChanged, (outputChanged)=>{
+
+				const outputChanged = message.outputChanged;
+
+				// DBG
+				console.log("!!! CHANGE STATE :", outputChanged);
+
+				const changeToState = (gpioIdParam, stateToPut, doOnEndCommand = null/*UNUSED*/) => {
+					let output = oritaClient.outputsGPIO[gpioIdParam];
+					if (!output) {
+						// TRACE
+						lognow("ERROR : Output for gpio id «" + gpioIdParam + "» does not exist for this micro client.");
+						return;
+					}
+					if (stateToPut) output.on(doOnEndCommand);
+					else output.off(doOnEndCommand);
+
+					// DBG
+					console.log("!!! CHANGE STATE :stateToPut", stateToPut);
+				};
+
+				let gpioId = outputChanged.gpioId;
+
+				let changeStateVanilla = true;
+				if (message.actionnersConfigs) {
+
+					let actionnerConfig = foreach(message.actionnersConfigs, (ac) => {
+						if (ac.gpioId === gpioId) return ac;
+					});
+
+					if (actionnerConfig) {
+
+						if (actionnerConfig.gpioId && actionnerConfig.gpioId !== gpioId) {
+							return; // DO NOTHING
+						}
+
+						if (actionnerConfig.type === "pushOnce") {
+
+							let output = oritaClient.outputsGPIO[gpioId];
+							if (!output) {
+								// TRACE
+								lognow("ERROR : Output for gpio id «" + gpioId + "» does not exist for this micro client.");
+								return;
+							}
+
+							// ACTUAL STATE :
+							if (output.state) return; // DO NOTHING
+							// WISHED STATE :
+							if (!outputChanged.state) return; // DO NOTHING
+
+							let latencyMillis = nonull(actionnerConfig.latencyMillis, 1000);
+							// We set the output to the 1 state :
+							changeToState(gpioId, true, (err, stdout, stderr) => {
+								if (err) {
+									console.log(err);
+									return;
+								}
+								if (stderr) {
+									console.log(stderr);
+									return;
+								}
+
+								// We return the output to the 0 state, after a while :
+								setInterval(() => {
+									changeToState(gpioId, false);
+								}, latencyMillis);
+
+							});
+
+							changeStateVanilla = false;
+						}
+					}
+				}
+				if (changeStateVanilla) {
+					changeToState(gpioId, outputChanged.state);
+				}
+
+
+				//				});
+
+				// 4-
+				oritaClient.client.socketToServer.send("communication", {
+					type: "response.microClient.outputChanged",
+					outputsGPIO: oritaClient.outputsGPIO,
+				});
+
+			},
+		});
+
+
+		return oritaClient;
+	};
+
+
+
+	// TODO : DEVELOP...
+
+	//		// Mobile platforms:
+	//		oritaClient.registerInputsTouch=()=>{
+	//				return oritaClient;
+	//		};
+	//		oritaClient.registerInputsOrientation=()=>{
+	//				return oritaClient;
+	//		};
+	//		// Desktop / potentially mobile platforms:
+	//		oritaClient.registerInputsMouse=()=>{
+	//				return oritaClient;
+	//		};
+	//		oritaClient.registerInputsKeyboard=()=>{
+	//				return oritaClient;
+	//		};
+
+
+	// INPUTS SENDING :
+	oritaClientoritaClient.sendCommand = (commandName, commandParameters = null) => {
+		const microClientId = oritaClient.microClientId;
+		const command = { microClientId: microClientId, type: "microClient.send.command", name: commandName, parameters: commandParameters };
+		oritaClient.client.socketToServer.send("communication", command);
+		return oritaClient;
+	};
+
+
+
+	oritaMicroClient.oritaClient = oritaClient;
+	return oritaClient;
+};
+
+
+/*utils GEOMETRY library associated with aotra version : «1_29072022-2359 (25/09/2022-16:59:58)»*/
 /*-----------------------------------------------------------------------------*/
 
 
@@ -12904,7 +14138,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 (19/08/2022-00:31:09)»*/
+/*utils SERVER library associated with aotra version : «1_29072022-2359 (25/09/2022-16:59:58)»*/
 /*-----------------------------------------------------------------------------*/