neoris/openvidu-livekit-tutorials
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

openvidu-basic-java: use new openvidu-java-client fromJson capabilities

Browse Source
This commit is contained in:
pabloFuente 2022-06-17 12:04:54 +02:00
parent 024d5e3423
commit c8c5c89842
2 changed files with 7 additions and 154 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
openvidu-basic-java/src/main/java/io/openvidu/basic/java/Controller.java
View File

@ -31,8 +31,6 @@ public class Controller {
private OpenVidu openvidu;
private Utils utils = new Utils();
@PostConstruct
public void init() {
this.openvidu = new OpenVidu(OPENVIDU_URL, OPENVIDU_SECRET);
@ -42,10 +40,10 @@ public class Controller {
* @param params The Session properties
* @return The Session ID
*/
@PostMapping("/session")
public ResponseEntity<String> initializeSession(@RequestBody Map<String, Object> params)
@PostMapping("/sessions")
public ResponseEntity<String> initializeSession(@RequestBody(required = false) Map<String, Object> params)
throws OpenViduJavaClientException, OpenViduHttpException {
SessionProperties properties = utils.generateSessionProperties(params);
SessionProperties properties = SessionProperties.fromJson(params).build();
Session session = openvidu.createSession(properties);
return new ResponseEntity<>(session.getSessionId(), HttpStatus.OK);
}
@ -55,16 +53,17 @@ public class Controller {
* @param params The Connection properties
* @return The Token associated to the Connection
*/
@PostMapping("/session/{sessionId}/connection")
@PostMapping("/sessions/{sessionId}/connections")
public ResponseEntity<String> createConnection(@PathVariable("sessionId") String sessionId,
@RequestBody Map<String, Object> params) throws OpenViduJavaClientException, OpenViduHttpException {
@RequestBody(required = false) Map<String, Object> params)
throws OpenViduJavaClientException, OpenViduHttpException {
openvidu.fetch();
Session session = openvidu.getActiveSessions().stream().filter(s -> sessionId.equals(s.getSessionId()))
.findFirst().orElse(null);
if (session == null) {
return new ResponseEntity<>(HttpStatus.NOT_FOUND);
}
ConnectionProperties properties = utils.generateConnectionProperties(params);
ConnectionProperties properties = ConnectionProperties.fromJson(params).build();
Connection connection = session.createConnection(properties);
return new ResponseEntity<>(connection.getToken(), HttpStatus.OK);
}

146
openvidu-basic-java/src/main/java/io/openvidu/basic/java/Utils.java
View File

@ -1,146 +0,0 @@
package io.openvidu.basic.java;
import java.util.List;
import java.util.Map;
import io.openvidu.java.client.ConnectionProperties;
import io.openvidu.java.client.ConnectionType;
import io.openvidu.java.client.IceServerProperties;
import io.openvidu.java.client.KurentoOptions;
import io.openvidu.java.client.MediaMode;
import io.openvidu.java.client.OpenViduRole;
import io.openvidu.java.client.Recording.OutputMode;
import io.openvidu.java.client.RecordingLayout;
import io.openvidu.java.client.RecordingMode;
import io.openvidu.java.client.RecordingProperties;
import io.openvidu.java.client.SessionProperties;
import io.openvidu.java.client.VideoCodec;
/**
* This class transforms raw REST API parameters to OpenVidu Java SDK classes
*/
public class Utils {
public SessionProperties generateSessionProperties(Map<String, Object> params) {
SessionProperties.Builder builder = new SessionProperties.Builder();
if (params.containsKey("mediaMode")) {
builder.mediaMode(MediaMode.valueOf((String) params.get("mediaMode")));
}
if (params.containsKey("recordingMode")) {
builder.recordingMode(RecordingMode.valueOf((String) params.get("recordingMode")));
}
if (params.containsKey("customSessionId")) {
builder.customSessionId((String) params.get("customSessionId"));
}
if (params.containsKey("forcedVideoCodec")) {
builder.forcedVideoCodec(VideoCodec.valueOf((String) params.get("forcedVideoCodec")));
}
if (params.containsKey("allowTranscoding")) {
builder.allowTranscoding((Boolean) params.get("allowTranscoding"));
}
if (params.containsKey("defaultRecordingProperties")) {
RecordingProperties.Builder defaultRecordingProperties = new RecordingProperties.Builder();
Map<String, Object> recordingProperties = (Map<String, Object>) params.get("defaultRecordingProperties");
if (recordingProperties.containsKey("name")) {
defaultRecordingProperties.name((String) recordingProperties.get("name"));
}
if (recordingProperties.containsKey("hasAudio")) {
defaultRecordingProperties.hasAudio((boolean) recordingProperties.get("hasAudio"));
}
if (recordingProperties.containsKey("hasVideo")) {
defaultRecordingProperties.hasVideo((boolean) recordingProperties.get("hasVideo"));
}
if (recordingProperties.containsKey("outputMode")) {
defaultRecordingProperties
.outputMode(OutputMode.valueOf((String) recordingProperties.get("outputMode")));
}
if (recordingProperties.containsKey("recordingLayout")) {
defaultRecordingProperties
.recordingLayout(RecordingLayout.valueOf((String) recordingProperties.get("recordingLayout")));
}
if (recordingProperties.containsKey("resolution")) {
defaultRecordingProperties.resolution((String) recordingProperties.get("resolution"));
}
if (recordingProperties.containsKey("frameRate")) {
defaultRecordingProperties.frameRate((int) recordingProperties.get("frameRate"));
}
if (recordingProperties.containsKey("shmSize")) {
defaultRecordingProperties.shmSize((long) recordingProperties.get("shmSize"));
}
if (recordingProperties.containsKey("ignoreFailedStreams")) {
defaultRecordingProperties
.ignoreFailedStreams((boolean) recordingProperties.get("ignoreFailedStreams"));
}
if (recordingProperties.containsKey("mediaNode")) {
Map<String, Object> mediaNodeInfo = (Map<String, Object>) recordingProperties.get("mediaNode");
if (mediaNodeInfo.containsKey("id")) {
defaultRecordingProperties.mediaNode((String) mediaNodeInfo.get("id"));
}
}
}
return builder.build();
}
public ConnectionProperties generateConnectionProperties(Map<String, Object> params) {
ConnectionProperties.Builder builder = new ConnectionProperties.Builder();
if (params.containsKey("type")) {
builder.type(ConnectionType.valueOf((String) params.get("type")));
}
if (params.containsKey("data")) {
builder.data((String) params.get("data"));
}
if (params.containsKey("record")) {
builder.record((boolean) params.get("record"));
}
if (params.containsKey("role")) {
builder.role(OpenViduRole.valueOf((String) params.get("role")));
}
if (params.containsKey("rtspUri")) {
builder.rtspUri((String) params.get("rtspUri"));
}
if (params.containsKey("adaptativeBitrate")) {
builder.adaptativeBitrate((boolean) params.get("adaptativeBitrate"));
}
if (params.containsKey("onlyPlayWithSubscribers")) {
builder.onlyPlayWithSubscribers((boolean) params.get("onlyPlayWithSubscribers"));
}
if (params.containsKey("networkCache")) {
builder.networkCache((int) params.get("networkCache"));
}
if (params.containsKey("kurentoOptions")) {
Map<String, Object> kurentoOptions = (Map<String, Object>) params.get("kurentoOptions");
KurentoOptions.Builder kurentoOptionsBuilder = new KurentoOptions.Builder();
if (kurentoOptions.containsKey("videoMaxRecvBandwidth")) {
kurentoOptionsBuilder.videoMaxRecvBandwidth((int) kurentoOptions.get("videoMaxRecvBandwidth"));
}
if (kurentoOptions.containsKey("videoMinRecvBandwidth")) {
kurentoOptionsBuilder.videoMinRecvBandwidth((int) kurentoOptions.get("videoMinRecvBandwidth"));
}
if (kurentoOptions.containsKey("videoMaxSendBandwidth")) {
kurentoOptionsBuilder.videoMaxSendBandwidth((int) kurentoOptions.get("videoMaxSendBandwidth"));
}
if (kurentoOptions.containsKey("videoMinSendBandwidth")) {
kurentoOptionsBuilder.videoMinSendBandwidth((int) kurentoOptions.get("videoMinSendBandwidth"));
}
if (kurentoOptions.containsKey("allowedFilters")) {
List<String> allowedFiltersList = (List<String>) kurentoOptions.get("allowedFilters");
String[] allowedFiltersArray = allowedFiltersList.stream().toArray(String[]::new);
kurentoOptionsBuilder.allowedFilters(allowedFiltersArray);
}
builder.kurentoOptions(kurentoOptionsBuilder.build());
}
if (params.containsKey("customIceServers")) {
List<Map<String, String>> customIceServersList = (List<Map<String, String>>) params.get("customIceServers");
for (Map<String, String> iceServer : customIceServersList) {
IceServerProperties.Builder iceServerBuilder = new IceServerProperties.Builder();
iceServerBuilder.url(iceServer.get("url"));
iceServerBuilder.username(iceServer.get("username"));
iceServerBuilder.credential(iceServer.get("credential"));
IceServerProperties iceServerProperties = iceServerBuilder.build();
builder.addCustomIceServer(iceServerProperties);
}
}
return builder.build();
}
}