openvidu-test-e2e: update OpenViduEventManager to support user specific targets

openvidu-test-e2e/src/main/java/io/openvidu/test/e2e/OpenViduEventManager.java

@@ -22,6 +22,7 @@ import static org.openqa.selenium.OutputType.BASE64;
 import java.awt.Point;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
@@ -82,9 +83,15 @@ public class OpenViduEventManager {
 	private ExecutorService execService = Executors.newCachedThreadPool();
 	private WebDriver driver;
 	private Queue<JsonObject> eventQueue;
+	
 	private Map<String, Collection<RunnableCallback>> eventCallbacks;
 	private Map<String, AtomicInteger> eventNumbers;
 	private Map<String, CountDownLatch> eventCountdowns;
+	
+    private Map<Integer, Map<String, Collection<RunnableCallback>>> eventCallbacksByUser;
+    private Map<Integer, Map<String, AtomicInteger>> eventNumbersByUser;
+    private Map<Integer, Map<String, CountDownLatch>> eventCountdownsByUser;
+	
 	private AtomicBoolean isInterrupted = new AtomicBoolean(false);
 	private CountDownLatch pollingLatch = new CountDownLatch(1);
 	private int timeOfWaitInSeconds;
@@ -95,6 +102,9 @@ public class OpenViduEventManager {
 		this.eventCallbacks = new ConcurrentHashMap<>();
 		this.eventNumbers = new ConcurrentHashMap<>();
 		this.eventCountdowns = new ConcurrentHashMap<>();
+	    this.eventCallbacksByUser = new ConcurrentHashMap<>();
+        this.eventNumbersByUser = new ConcurrentHashMap<>();
+        this.eventCountdownsByUser = new ConcurrentHashMap<>();
 		this.timeOfWaitInSeconds = timeOfWaitInSeconds;
 	}
 
@@ -148,6 +158,9 @@ public class OpenViduEventManager {
 			this.eventCallbacks.clear();
 			this.eventCountdowns.clear();
 			this.eventNumbers.clear();
+			this.eventCallbacksByUser.clear();
+			this.eventCountdownsByUser.clear();
+			this.eventNumbersByUser.clear();
 		}
 	}
 
@@ -155,10 +168,25 @@ public class OpenViduEventManager {
 		this.eventCallbacks.putIfAbsent(eventName, new HashSet<>());
 		this.eventCallbacks.get(eventName).add(new RunnableCallback(callback));
 	}
+	
+	public void on(int numberOfUser, String eventName, Consumer<JsonObject> callback) {
+	    this.eventCallbacksByUser.putIfAbsent(numberOfUser, new HashMap<>());
+        this.eventCallbacksByUser.get(numberOfUser).putIfAbsent(eventName, new HashSet<>());
+        this.eventCallbacksByUser.get(numberOfUser).get(eventName).add(new RunnableCallback(callback));
+    }
 
 	public void off(String eventName) {
 		this.eventCallbacks.remove(eventName);
 	}
+	
+   public void off(int numberOfUser, String eventName) {
+       if (this.eventCallbacksByUser.containsKey(numberOfUser)) {
+           this.eventCallbacksByUser.get(numberOfUser).remove(eventName);
+           if (this.eventCallbacksByUser.get(numberOfUser).isEmpty()) {
+               this.eventCallbacksByUser.remove(numberOfUser);
+           }
+       }
+    }
 
 	// 'eventNumber' is accumulative for event 'eventName' for one page while it is
 	// not refreshed
@@ -187,11 +215,43 @@ public class OpenViduEventManager {
 		}
 	}
 
+   public void waitUntilEventReaches(int numberOfUser, String eventName, int eventNumber) throws Exception {
+        this.waitUntilEventReaches(numberOfUser, eventName, eventNumber, this.timeOfWaitInSeconds, true);
+    }
+
+    public void waitUntilEventReaches(int numberOfUser, String eventName, int eventNumber, int secondsOfWait, boolean printTimeoutError)
+            throws Exception {
+        CountDownLatch eventSignal = new CountDownLatch(eventNumber);
+        this.setCountDown(numberOfUser, eventName, eventSignal);
+        try {
+            if (!eventSignal.await(secondsOfWait * 1000, TimeUnit.MILLISECONDS)) {
+                if (printTimeoutError) {
+                    String screenshot = "data:image/png;base64," + ((TakesScreenshot) driver).getScreenshotAs(BASE64);
+                    System.out.println("TIMEOUT SCREENSHOT");
+                    System.out.println(screenshot);
+                }
+                throw (new TimeoutException());
+            }
+        } catch (InterruptedException | TimeoutException e) {
+            if (printTimeoutError) {
+                e.printStackTrace();
+            }
+            throw e;
+        }
+    }
+	
 	// Sets any event count to 0
 	public synchronized void clearCurrentEvents(String eventName) {
 		this.eventNumbers.put(eventName, new AtomicInteger(0));
 		this.setCountDown(eventName, new CountDownLatch(0));
 	}
+	
+	public synchronized void clearCurrentEvents(int numberOfUser, String eventName) {
+	    if (this.eventNumbersByUser.containsKey(numberOfUser)) {
+	        this.eventNumbersByUser.get(numberOfUser).put(eventName, new AtomicInteger(0));
+	        this.setCountDown(numberOfUser, eventName, new CountDownLatch(0));
+	    }
+    }
 
 	public synchronized void clearAllCurrentEvents() {
 		this.eventNumbers.keySet().forEach(eventName -> {
@@ -199,6 +259,14 @@ public class OpenViduEventManager {
 		});
 	}
 
+   public synchronized void clearAllCurrentEvents(int numberOfUser) {
+       if (this.eventNumbersByUser.containsKey(numberOfUser)) {
+            this.eventNumbersByUser.get(numberOfUser).keySet().forEach(eventName -> {
+                this.clearCurrentEvents(numberOfUser, eventName);
+            });
+       }
+    }
+
 	public void resetEventThread(boolean clearData) throws InterruptedException {
 		this.stopPolling(true, clearData);
 		this.pollingLatch.await();
@@ -208,6 +276,7 @@ public class OpenViduEventManager {
 		this.stopPolling(false, clearData);
 		if (clearData) {
 			this.clearAllCurrentEvents();
+			this.eventNumbersByUser.keySet().forEach(user -> this.clearAllCurrentEvents(user));
 		}
 		this.isInterrupted.set(false);
 		this.pollingLatch = new CountDownLatch(1);
@@ -258,174 +327,201 @@ public class OpenViduEventManager {
 	public AtomicInteger getNumEvents(String eventName) {
 		return this.eventNumbers.computeIfAbsent(eventName, k -> new AtomicInteger(0));
 	}
+	
+	public AtomicInteger getNumEvents(int numberOfUser, String eventName) {
+	       this.eventNumbersByUser.putIfAbsent(numberOfUser, new HashMap<>());
+	       return this.eventNumbersByUser.get(numberOfUser).computeIfAbsent(eventName, k -> new AtomicInteger(0));
+    }
 
-	private void setCountDown(String eventName, CountDownLatch cd) {
+    private void setCountDown(String eventName, CountDownLatch cd) {
-		this.eventCountdowns.put(eventName, cd);
+        this.eventCountdowns.put(eventName, cd);
-		for (int i = 0; i < getNumEvents(eventName).get(); i++) {
+        for (int i = 0; i < getNumEvents(eventName).get(); i++) {
-			cd.countDown();
+            cd.countDown();
-		}
+        }
-	}
+    }
 
-	private void emitEvents() {
+    private void setCountDown(int numberOfUser, String eventName, CountDownLatch cd) {
-		while (!this.eventQueue.isEmpty()) {
+        this.eventCountdownsByUser.putIfAbsent(numberOfUser, new HashMap<>());
-		    JsonObject userAndEvent = this.eventQueue.poll();
+        this.eventCountdownsByUser.get(numberOfUser).put(eventName, cd);
-		    final JsonObject event = userAndEvent.get("event").getAsJsonObject();
+        for (int i = 0; i < getNumEvents(numberOfUser, eventName).get(); i++) {
-		    final String eventType = event.get("type").getAsString();
+            cd.countDown();
+        }
+    }
 
-			log.info(eventType);
+    private void emitEvents() {
+        while (!this.eventQueue.isEmpty()) {
+            JsonObject userAndEvent = this.eventQueue.poll();
+            final JsonObject event = userAndEvent.get("event").getAsJsonObject();
+            final int numberOfUser = userAndEvent.get("user").getAsInt();
+            final String eventType = event.get("type").getAsString();
 
-			if (this.eventCallbacks.containsKey(eventType)) {
+            log.info(eventType);
-				for (RunnableCallback callback : this.eventCallbacks.get(eventType)) {
-					callback.setEventResult(event);
-					execService.submit(callback);
-				}
-			}
-		}
-	}
 
-	private synchronized void getEventsFromBrowser() {
+            if (this.eventCallbacks.containsKey(eventType)) {
-		String rawEvents = this.getAndClearEventsInBrowser();
+                for (RunnableCallback callback : this.eventCallbacks.get(eventType)) {
+                    callback.setEventResult(event);
+                    execService.submit(callback);
+                }
+            }
+            if (this.eventCallbacksByUser.containsKey(numberOfUser)) {
+                for (RunnableCallback callback : this.eventCallbacksByUser.get(numberOfUser).get(eventType)) {
+                    callback.setEventResult(event);
+                    execService.submit(callback);
+                }
+            }
+        }
+    }
 
-		if (rawEvents == null || rawEvents.length() == 0) {
+    private synchronized void getEventsFromBrowser() {
-			return;
+        String rawEvents = this.getAndClearEventsInBrowser();
-		}
 
-		String[] events = rawEvents.replaceFirst("^<br>", "").split("<br>");
+        if (rawEvents == null || rawEvents.length() == 0) {
-		for (String e : events) {
+            return;
-		    JsonObject userAndEvent = JsonParser.parseString(e).getAsJsonObject();
+        }
-		    final JsonObject event = userAndEvent.get("event").getAsJsonObject();
-			final String eventType = event.get("type").getAsString();
 
-			this.eventQueue.add(userAndEvent);
+        String[] events = rawEvents.replaceFirst("^<br>", "").split("<br>");
-			getNumEvents(eventType).incrementAndGet();
+        for (String e : events) {
+            JsonObject userAndEvent = JsonParser.parseString(e).getAsJsonObject();
+            final JsonObject event = userAndEvent.get("event").getAsJsonObject();
+            final int numberOfUser = userAndEvent.get("user").getAsInt();
+            final String eventType = event.get("type").getAsString();
 
-			if (this.eventCountdowns.get(eventType) != null) {
+            this.eventQueue.add(userAndEvent);
-				this.eventCountdowns.get(eventType).countDown();
-			}
-		}
-	}
 
-	private String getAndClearEventsInBrowser() {
+            getNumEvents(eventType).incrementAndGet();
-		String events = (String) ((JavascriptExecutor) driver)
+            if (this.eventCountdowns.get(eventType) != null) {
-				.executeScript("var e = window.myEvents; window.myEvents = ''; return e;");
+                this.eventCountdowns.get(eventType).countDown();
-		return events;
+            }
-	}
 
-	public boolean hasMediaStream(WebElement videoElement, String parentSelector) {
+            getNumEvents(numberOfUser, eventType).incrementAndGet();
-		boolean hasMediaStream = (boolean) ((JavascriptExecutor) driver).executeScript(
+            this.eventCountdownsByUser.putIfAbsent(numberOfUser, new HashMap<>());
-				"return (!!(document.querySelector('" + parentSelector + (parentSelector.isEmpty() ? "" : " ") + "#"
+            if (this.eventCountdownsByUser.get(numberOfUser).get(eventType) != null) {
-						+ videoElement.getAttribute("id") + "').srcObject))");
+                this.eventCountdownsByUser.get(numberOfUser).get(eventType).countDown();
-		return hasMediaStream;
+            }
-	}
+        }
+    }
 
-	public Map<String, Long> getAverageRgbFromVideo(WebElement videoElement) {
+    private String getAndClearEventsInBrowser() {
-		String script = "var callback = arguments[arguments.length - 1];" + "var video = document.getElementById('"
+        String events = (String) ((JavascriptExecutor) driver)
-				+ videoElement.getAttribute("id") + "');" + "var canvas = document.createElement('canvas');"
+                .executeScript("var e = window.myEvents; window.myEvents = ''; return e;");
-				+ "canvas.height = video.videoHeight;" + "canvas.width = video.videoWidth;"
+        return events;
-				+ "var context = canvas.getContext('2d');"
+    }
-				+ "context.drawImage(video, 0, 0, canvas.width, canvas.height);"
-				+ "var imgEl = document.createElement('img');" + "imgEl.src = canvas.toDataURL();"
-				+ "var blockSize = 5;" + "var defaultRGB = { r: 0, g: 0, b: 0 };"
-				+ "context.drawImage(video, 0, 0, 220, 150);" + "var dataURL = canvas.toDataURL();"
-				+ "imgEl.onload = function () {" + "let i = -4;" + "var rgb = { r: 0, g: 0, b: 0 };" + "let count = 0;"
-				+ "if (!context) {" + "  return defaultRGB;" + "}"
-				+ "var height = canvas.height = imgEl.naturalHeight || imgEl.offsetHeight || imgEl.height;"
-				+ "var width = canvas.width = imgEl.naturalWidth || imgEl.offsetWidth || imgEl.width;" + "let data;"
-				+ "context.drawImage(imgEl, 0, 0);" + "try {" + "data = context.getImageData(0, 0, width, height);"
-				+ "} catch (e) {" + "return defaultRGB;" + "}" + "length = data.data.length;"
-				+ "while ((i += blockSize * 4) < length) {" + "++count;" + "rgb.r += data.data[i];"
-				+ "rgb.g += data.data[i + 1];" + "rgb.b += data.data[i + 2];" + "}" + "rgb.r = ~~(rgb.r / count);"
-				+ "rgb.g = ~~(rgb.g / count);" + "rgb.b = ~~(rgb.b / count);" + "callback(rgb);" + "};";
-		Object averageRgb = ((JavascriptExecutor) driver).executeAsyncScript(script);
-		return (Map<String, Long>) averageRgb;
-	}
 
-	public Map<String, Long> getAverageColorFromPixels(WebElement videoElement, List<Point> pixelPercentagePositions) {
+    public boolean hasMediaStream(WebElement videoElement, String parentSelector) {
-		String script = "var callback = arguments[arguments.length - 1];"
+        boolean hasMediaStream = (boolean) ((JavascriptExecutor) driver).executeScript(
-				+ "var points = arguments[arguments.length - 2];" + "points = JSON.parse(points);"
+                "return (!!(document.querySelector('" + parentSelector + (parentSelector.isEmpty() ? "" : " ") + "#"
-				+ "var video = document.getElementById('local-video-undefined');"
+                        + videoElement.getAttribute("id") + "').srcObject))");
-				+ "var canvas = document.createElement('canvas');" + "canvas.height = video.videoHeight;"
+        return hasMediaStream;
-				+ "canvas.width = video.videoWidth;" + "var context = canvas.getContext('2d');"
+    }
-				+ "context.drawImage(video, 0, 0, canvas.width, canvas.height);"
-				+ "var imgEl = document.createElement('img');" + "imgEl.src = canvas.toDataURL();"
-				+ "var blockSize = 5;" + "var defaultRGB = {r:0,g:0,b:0};" + "context.drawImage(video, 0, 0, 220, 150);"
-				+ "var dataURL = canvas.toDataURL();" + "imgEl.onload = function() {" + "    var rgb = {r:0,g:0,b:0};"
-				+ "    if (!context) {" + "        return defaultRGB;" + "    }"
-				+ "    var height = canvas.height = imgEl.naturalHeight || imgEl.offsetHeight || imgEl.height;"
-				+ "    var width = canvas.width = imgEl.naturalWidth || imgEl.offsetWidth || imgEl.width;"
-				+ "    let data;" + "    context.drawImage(imgEl, 0, 0);" + "    for (var p of points) {"
-				+ "        var xFromPercentage = width * (p.x / 100);"
-				+ "        var yFromPercentage = height * (p.y / 100);"
-				+ "        data = context.getImageData(xFromPercentage, yFromPercentage, 1, 1).data;"
-				+ "        rgb.r += data[0];" + "        rgb.g += data[1];" + "        rgb.b += data[2];" + "    }"
-				+ "    rgb.r = ~~(rgb.r / points.length);" + "    rgb.g = ~~(rgb.g / points.length);"
-				+ "    rgb.b = ~~(rgb.b / points.length);" + "    callback(rgb);" + "};";
-		String points = "[";
-		Iterator<Point> it = pixelPercentagePositions.iterator();
-		while (it.hasNext()) {
-			Point p = it.next();
-			points += "{\"x\":" + p.getX() + ",\"y\":" + p.getY() + "}";
-			if (it.hasNext()) {
-				points += ",";
-			}
-		}
-		points += "]";
-		Object averageRgb = ((JavascriptExecutor) driver).executeAsyncScript(script, points);
-		return (Map<String, Long>) averageRgb;
-	}
 
-	public String getDimensionOfViewport() {
+    public Map<String, Long> getAverageRgbFromVideo(WebElement videoElement) {
-		String dimension = (String) ((JavascriptExecutor) driver)
+        String script = "var callback = arguments[arguments.length - 1];" + "var video = document.getElementById('"
-				.executeScript("return (JSON.stringify({width: window.innerWidth, height: window.innerHeight - 1}))");
+                + videoElement.getAttribute("id") + "');" + "var canvas = document.createElement('canvas');"
-		return dimension;
+                + "canvas.height = video.videoHeight;" + "canvas.width = video.videoWidth;"
-	}
+                + "var context = canvas.getContext('2d');"
+                + "context.drawImage(video, 0, 0, canvas.width, canvas.height);"
+                + "var imgEl = document.createElement('img');" + "imgEl.src = canvas.toDataURL();"
+                + "var blockSize = 5;" + "var defaultRGB = { r: 0, g: 0, b: 0 };"
+                + "context.drawImage(video, 0, 0, 220, 150);" + "var dataURL = canvas.toDataURL();"
+                + "imgEl.onload = function () {" + "let i = -4;" + "var rgb = { r: 0, g: 0, b: 0 };" + "let count = 0;"
+                + "if (!context) {" + "  return defaultRGB;" + "}"
+                + "var height = canvas.height = imgEl.naturalHeight || imgEl.offsetHeight || imgEl.height;"
+                + "var width = canvas.width = imgEl.naturalWidth || imgEl.offsetWidth || imgEl.width;" + "let data;"
+                + "context.drawImage(imgEl, 0, 0);" + "try {" + "data = context.getImageData(0, 0, width, height);"
+                + "} catch (e) {" + "return defaultRGB;" + "}" + "length = data.data.length;"
+                + "while ((i += blockSize * 4) < length) {" + "++count;" + "rgb.r += data.data[i];"
+                + "rgb.g += data.data[i + 1];" + "rgb.b += data.data[i + 2];" + "}" + "rgb.r = ~~(rgb.r / count);"
+                + "rgb.g = ~~(rgb.g / count);" + "rgb.b = ~~(rgb.b / count);" + "callback(rgb);" + "};";
+        Object averageRgb = ((JavascriptExecutor) driver).executeAsyncScript(script);
+        return (Map<String, Long>) averageRgb;
+    }
 
-	public void stopVideoTracksOfVideoElement(WebElement videoElement, String parentSelector) {
+    public Map<String, Long> getAverageColorFromPixels(WebElement videoElement, List<Point> pixelPercentagePositions) {
-		String script = "return (document.querySelector('" + parentSelector + (parentSelector.isEmpty() ? "" : " ")
+        String script = "var callback = arguments[arguments.length - 1];"
-				+ "#" + videoElement.getAttribute("id")
+                + "var points = arguments[arguments.length - 2];" + "points = JSON.parse(points);"
-				+ "').srcObject.getVideoTracks().forEach(track => track.stop()))";
+                + "var video = document.getElementById('local-video-undefined');"
-		((JavascriptExecutor) driver).executeScript(script);
+                + "var canvas = document.createElement('canvas');" + "canvas.height = video.videoHeight;"
-	}
+                + "canvas.width = video.videoWidth;" + "var context = canvas.getContext('2d');"
+                + "context.drawImage(video, 0, 0, canvas.width, canvas.height);"
+                + "var imgEl = document.createElement('img');" + "imgEl.src = canvas.toDataURL();"
+                + "var blockSize = 5;" + "var defaultRGB = {r:0,g:0,b:0};" + "context.drawImage(video, 0, 0, 220, 150);"
+                + "var dataURL = canvas.toDataURL();" + "imgEl.onload = function() {" + "    var rgb = {r:0,g:0,b:0};"
+                + "    if (!context) {" + "        return defaultRGB;" + "    }"
+                + "    var height = canvas.height = imgEl.naturalHeight || imgEl.offsetHeight || imgEl.height;"
+                + "    var width = canvas.width = imgEl.naturalWidth || imgEl.offsetWidth || imgEl.width;"
+                + "    let data;" + "    context.drawImage(imgEl, 0, 0);" + "    for (var p of points) {"
+                + "        var xFromPercentage = width * (p.x / 100);"
+                + "        var yFromPercentage = height * (p.y / 100);"
+                + "        data = context.getImageData(xFromPercentage, yFromPercentage, 1, 1).data;"
+                + "        rgb.r += data[0];" + "        rgb.g += data[1];" + "        rgb.b += data[2];" + "    }"
+                + "    rgb.r = ~~(rgb.r / points.length);" + "    rgb.g = ~~(rgb.g / points.length);"
+                + "    rgb.b = ~~(rgb.b / points.length);" + "    callback(rgb);" + "};";
+        String points = "[";
+        Iterator<Point> it = pixelPercentagePositions.iterator();
+        while (it.hasNext()) {
+            Point p = it.next();
+            points += "{\"x\":" + p.getX() + ",\"y\":" + p.getY() + "}";
+            if (it.hasNext()) {
+                points += ",";
+            }
+        }
+        points += "]";
+        Object averageRgb = ((JavascriptExecutor) driver).executeAsyncScript(script, points);
+        return (Map<String, Long>) averageRgb;
+    }
 
-	private boolean hasAudioTracks(WebElement videoElement, String parentSelector) {
+    public String getDimensionOfViewport() {
-		String script = "return ((document.querySelector('" + parentSelector + (parentSelector.isEmpty() ? "" : " ")
+        String dimension = (String) ((JavascriptExecutor) driver)
-				+ "#" + videoElement.getAttribute("id") + "').srcObject.getAudioTracks().length > 0)"
+                .executeScript("return (JSON.stringify({width: window.innerWidth, height: window.innerHeight - 1}))");
-				+ " && (document.querySelector('" + parentSelector + (parentSelector.isEmpty() ? "" : " ") + "#"
+        return dimension;
-				+ videoElement.getAttribute("id") + "').srcObject.getAudioTracks()[0].enabled))";
+    }
-		boolean audioTracks = (boolean) ((JavascriptExecutor) driver).executeScript(script);
-		return audioTracks;
-	}
 
-	private boolean hasVideoTracks(WebElement videoElement, String parentSelector) {
+    public void stopVideoTracksOfVideoElement(WebElement videoElement, String parentSelector) {
-		String script = "return ((document.querySelector('" + parentSelector + (parentSelector.isEmpty() ? "" : " ")
+        String script = "return (document.querySelector('" + parentSelector + (parentSelector.isEmpty() ? "" : " ")
-				+ "#" + videoElement.getAttribute("id") + "').srcObject.getVideoTracks().length > 0)"
+                + "#" + videoElement.getAttribute("id")
-				+ " && (document.querySelector('" + parentSelector + (parentSelector.isEmpty() ? "" : " ") + "#"
+                + "').srcObject.getVideoTracks().forEach(track => track.stop()))";
-				+ videoElement.getAttribute("id") + "').srcObject.getVideoTracks()[0].enabled))";
+        ((JavascriptExecutor) driver).executeScript(script);
-		boolean videoTracks = (boolean) ((JavascriptExecutor) driver).executeScript(script);
+    }
-		return videoTracks;
-	}
 
-	private boolean waitUntilSrcObjectDefined(WebElement videoElement, String parentSelector, int maxMsWait) {
+    private boolean hasAudioTracks(WebElement videoElement, String parentSelector) {
-		final int sleepInterval = 50;
+        String script = "return ((document.querySelector('" + parentSelector + (parentSelector.isEmpty() ? "" : " ")
-		int maxIterations = maxMsWait / sleepInterval;
+                + "#" + videoElement.getAttribute("id") + "').srcObject.getAudioTracks().length > 0)"
-		int counter = 0;
+                + " && (document.querySelector('" + parentSelector + (parentSelector.isEmpty() ? "" : " ") + "#"
-		boolean defined = srcObjectDefined(videoElement, parentSelector);
+                + videoElement.getAttribute("id") + "').srcObject.getAudioTracks()[0].enabled))";
-		while (!defined && counter < maxIterations) {
+        boolean audioTracks = (boolean) ((JavascriptExecutor) driver).executeScript(script);
-			try {
+        return audioTracks;
-				Thread.sleep(sleepInterval);
+    }
-			} catch (InterruptedException e) {
-			}
-			defined = srcObjectDefined(videoElement, parentSelector);
-			counter++;
-		}
-		return defined;
-	}
 
-	private boolean srcObjectDefined(WebElement videoElement, String parentSelector) {
+    private boolean hasVideoTracks(WebElement videoElement, String parentSelector) {
-		String script = "return (!!(document.querySelector('" + parentSelector + (parentSelector.isEmpty() ? "" : " ")
+        String script = "return ((document.querySelector('" + parentSelector + (parentSelector.isEmpty() ? "" : " ")
-				+ "#" + videoElement.getAttribute("id") + "').srcObject))";
+                + "#" + videoElement.getAttribute("id") + "').srcObject.getVideoTracks().length > 0)"
-		boolean defined = (boolean) ((JavascriptExecutor) driver).executeScript(script);
+                + " && (document.querySelector('" + parentSelector + (parentSelector.isEmpty() ? "" : " ") + "#"
-		return defined;
+                + videoElement.getAttribute("id") + "').srcObject.getVideoTracks()[0].enabled))";
-	}
+        boolean videoTracks = (boolean) ((JavascriptExecutor) driver).executeScript(script);
+        return videoTracks;
+    }
+
+    private boolean waitUntilSrcObjectDefined(WebElement videoElement, String parentSelector, int maxMsWait) {
+        final int sleepInterval = 50;
+        int maxIterations = maxMsWait / sleepInterval;
+        int counter = 0;
+        boolean defined = srcObjectDefined(videoElement, parentSelector);
+        while (!defined && counter < maxIterations) {
+            try {
+                Thread.sleep(sleepInterval);
+            } catch (InterruptedException e) {
+            }
+            defined = srcObjectDefined(videoElement, parentSelector);
+            counter++;
+        }
+        return defined;
+    }
+
+    private boolean srcObjectDefined(WebElement videoElement, String parentSelector) {
+        String script = "return (!!(document.querySelector('" + parentSelector + (parentSelector.isEmpty() ? "" : " ")
+                + "#" + videoElement.getAttribute("id") + "').srcObject))";
+        boolean defined = (boolean) ((JavascriptExecutor) driver).executeScript(script);
+        return defined;
+    }
 
 }

openvidu-testapp/src/app/components/openvidu-instance/openvidu-instance.component.ts

@@ -523,13 +523,7 @@ export class OpenviduInstanceComponent implements OnInit, OnChanges, OnDestroy {
       }
       if (this.sessionEvents.speechToTextMessage) {
         this.session.on('speechToTextMessage', (event: SpeechToTextEvent) => {
-          const displayedContent = {
+          this.updateEventList('speechToTextMessage', event.text, event);
-            connection: event.connection.connectionId,
-            text: event.text,
-            reason: event.reason,
-            lang: event.lang
-          }
-          this.updateEventList('speechToTextMessage', JSON.stringify(displayedContent), event);
           if (event.reason === 'recognized') {
             console.warn(event);
           }