Send signal API method using OpenVidu API + Subscription to signal:lowerYourHand in frontend

Author: DiegoMzmn

backend/src/main/java/urjc/ovteaching/OpenViduComponent.java

@@ -1,22 +1,52 @@
 package urjc.ovteaching;
 
+import java.io.IOException;
+import java.io.UnsupportedEncodingException;
+import java.security.KeyManagementException;
+import java.security.KeyStoreException;
+import java.security.NoSuchAlgorithmException;
+import java.security.cert.CertificateException;
+import java.security.cert.X509Certificate;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.TimeUnit;
 
+import javax.net.ssl.SSLContext;
+
+import org.apache.http.HttpHeaders;
+import org.apache.http.HttpResponse;
+import org.apache.http.auth.AuthScope;
+import org.apache.http.auth.UsernamePasswordCredentials;
+import org.apache.http.client.CredentialsProvider;
+import org.apache.http.client.HttpClient;
+import org.apache.http.client.config.RequestConfig;
+import org.apache.http.client.methods.HttpPost;
+import org.apache.http.conn.ssl.NoopHostnameVerifier;
+import org.apache.http.entity.StringEntity;
+import org.apache.http.impl.client.BasicCredentialsProvider;
+import org.apache.http.impl.client.HttpClientBuilder;
+import org.apache.http.ssl.SSLContextBuilder;
+import org.apache.http.ssl.TrustStrategy;
+import org.apache.http.util.EntityUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Component;
 
+import com.google.gson.Gson;
+import com.google.gson.JsonObject;
+
 import io.openvidu.java.client.OpenVidu;
 import io.openvidu.java.client.OpenViduHttpException;
 import io.openvidu.java.client.OpenViduJavaClientException;
 import io.openvidu.java.client.OpenViduRole;
 import io.openvidu.java.client.Recording;
+import io.openvidu.java.client.RecordingLayout;
+import io.openvidu.java.client.RecordingProperties;
 import io.openvidu.java.client.Session;
 import io.openvidu.java.client.SessionProperties;
 import io.openvidu.java.client.TokenOptions;
@@ -37,6 +67,8 @@ public class OpenViduComponent {
 	private OpenVidu openVidu;
 	private String OPENVIDU_URL;
 	private String SECRET;
+	
+	private HttpClient httpClient;
 
 	private Map<Long, Session> roomIdSession;
 	private Map<String, Map<Long, String[]>> sessionIdUserIdToken;
@@ -47,6 +79,28 @@ public OpenViduComponent(@Value("${openvidu.secret}") String secret, @Value("${o
 		this.openVidu = new OpenVidu(OPENVIDU_URL, SECRET);
 		this.roomIdSession = new ConcurrentHashMap<>();
 		this.sessionIdUserIdToken = new ConcurrentHashMap<>();
+		
+		TrustStrategy trustStrategy = new TrustStrategy() {
+			@Override
+			public boolean isTrusted(X509Certificate[] chain, String authType) throws CertificateException {
+				return true;
+			}
+		};
+		CredentialsProvider provider = new BasicCredentialsProvider();
+		UsernamePasswordCredentials credentials = new UsernamePasswordCredentials("OPENVIDUAPP", this.SECRET);
+		provider.setCredentials(AuthScope.ANY, credentials);
+		SSLContext sslContext;
+		try {
+			sslContext = new SSLContextBuilder().loadTrustMaterial(null, trustStrategy).build();
+		} catch (KeyManagementException | NoSuchAlgorithmException | KeyStoreException e) {
+			throw new RuntimeException(e);
+		}
+		RequestConfig.Builder requestBuilder = RequestConfig.custom();
+		requestBuilder = requestBuilder.setConnectTimeout(30000);
+		requestBuilder = requestBuilder.setConnectionRequestTimeout(30000);
+		this.httpClient = HttpClientBuilder.create().setDefaultRequestConfig(requestBuilder.build())
+				.setConnectionTimeToLive(30, TimeUnit.SECONDS).setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE)
+				.setSSLContext(sslContext).setDefaultCredentialsProvider(provider).build();
 	}
 
 	public boolean isSessionCreated(Room room) {
@@ -160,4 +214,31 @@ public String stopRecording(Room room) {
 		}
 		return null;
 	}
+	
+	public void sendSignalToEveryone(Room room, String type, String data) throws UnsupportedEncodingException, IOException {
+		Session session = this.roomIdSession.get(room.getId());
+		
+		HttpPost request = new HttpPost(this.OPENVIDU_URL + "/api/signal");
+
+		JsonObject json = new JsonObject();
+		json.addProperty("session", session.getSessionId());
+		json.addProperty("type", "signal:" + type);
+		json.addProperty("data", data);
+
+		StringEntity params = new StringEntity(json.toString());
+		request.setHeader(HttpHeaders.CONTENT_TYPE, "application/json");
+		request.setEntity(params);
+
+		HttpResponse response = this.httpClient.execute(request);
+		try {
+			int statusCode = response.getStatusLine().getStatusCode();
+			if ((statusCode == org.apache.http.HttpStatus.SC_OK)) {
+				return;
+			} else {
+				throw new IOException("Openvidu error: " + statusCode);
+			}
+		} finally {
+			EntityUtils.consumeQuietly(response.getEntity());
+		}
+	}
 }

backend/src/main/java/urjc/ovteaching/rooms/controllers/OpenViduController.java

@@ -1,5 +1,7 @@
 package urjc.ovteaching.rooms.controllers;
 
+import java.io.IOException;
+
 import javax.servlet.http.HttpServletRequest;
 
 import org.json.simple.JSONObject;
@@ -11,6 +13,7 @@
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 
@@ -227,4 +230,38 @@ public ResponseEntity<String> stopRecording(@PathVariable String roomName, HttpS
 		}
 		return new ResponseEntity<>(recordingId, HttpStatus.OK);
 	}
+	
+	/**
+	 * Sends a signal with the type and data associated
+	 * 
+	 * @return HttpStatus of the operation
+	 */
+	@PostMapping("/room/{roomName}/signal/{type}")
+	public ResponseEntity<?> sendSignal(@PathVariable String roomName, @PathVariable String type, @RequestBody JSONObject data, HttpServletRequest request) {
+		if (!request.isUserInRole("USER")) { // User not logged
+			return new ResponseEntity<>(HttpStatus.UNAUTHORIZED);
+		}
+		Room room = roomServ.findByName(roomName);
+		User user = userServ.findByName(request.getUserPrincipal().getName());
+		// User currentUser = this.userComponent.getLoggedUser();
+
+		if (room == null) { // No room with that name
+			return new ResponseEntity<>(HttpStatus.NOT_FOUND);
+		}
+		if (!room.isModerator(user)) { // User not in that room
+			return new ResponseEntity<>(HttpStatus.UNAUTHORIZED);
+		}
+		if (!this.openViduComponent.isSessionCreated(room) || this.openViduComponent.isSessionEmpty(room)) {
+			// No session created for that room or it is empty
+			return new ResponseEntity<>(HttpStatus.CONFLICT);
+		}
+		
+		try {
+			this.openViduComponent.sendSignalToEveryone(room, type, data.toString());
+		} catch (IOException e) {
+			System.err.println(e.toString());
+			return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
+		}
+		return new ResponseEntity<>(HttpStatus.OK);
+	}
 }

frontend/src/app/video-room/video-room.component.ts

@@ -281,6 +281,7 @@ export class VideoRoomComponent implements OnInit, OnDestroy {
     if(this.userService.isModOfRoom(this.roomName)) {
       this.subscribedToChat('chatMod', this.messageListMod, this.modChatComponent);
     }
+    this.subscribedToLowerHand();
     this.connectToSession();
   }
 
@@ -772,6 +773,15 @@ export class VideoRoomComponent implements OnInit, OnDestroy {
     });
   }
 
+  private subscribedToLowerHand() {
+    this.session.on('signal:lowerYourHand', (event:any) => {
+      if(event.from===undefined) { 
+        //Only do something if "from" is undefined, which means the signal was called by the backend
+        this.raiseHand();
+      }
+    });
+  }
+
   private sendSignalUserChanged(user: UserModel, isFirstTime?: boolean): void {
     const session = user.isLocal() ? this.session : this.sessionScreen;
     const data = {