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

openvidu-basic-java

Browse Source
This commit is contained in:
pabloFuente 2022-06-03 14:13:36 +02:00
parent c693ce9729
commit 85f6a99129
8 changed files with 329 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
openvidu-basic-java/.gitignore vendored Normal file
View File

@ -0,0 +1,24 @@
# Compiled class file
*.class
# Log file
*.log
# BlueJ files
*.ctxt
# Mobile Tools for Java (J2ME)
.mtj.tmp/
# Package Files #
*.jar
*.war
*.ear
*.zip
*.tar.gz
*.rar
# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
hs_err_pid*
target/

52
openvidu-basic-java/pom.xml Normal file
View File

@ -0,0 +1,52 @@
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>io.openvidu</groupId>
<artifactId>openvidu-basic-java</artifactId>
<version>2.22.0</version>
<packaging>jar</packaging>
<name>openvidu-basic-java</name>
<url>https://github.com/OpenVidu/openvidu-tutorials/tree/master/openvidu-basic-java</url>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.7.0</version>
</parent>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<java.version>1.8</java.version>
<start-class>io.openvidu.basic.java.App</start-class>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>io.openvidu</groupId>
<artifactId>openvidu-java-client</artifactId>
<version>2.22.0</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>

13
openvidu-basic-java/src/main/java/io/openvidu/basic/java/App.java Normal file
View File

@ -0,0 +1,13 @@
package io.openvidu.basic.java;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class App {
public static void main(String[] args) {
SpringApplication.run(App.class, args);
}
}

72
openvidu-basic-java/src/main/java/io/openvidu/basic/java/Controller.java Normal file
View File

@ -0,0 +1,72 @@
package io.openvidu.basic.java;
import java.util.Map;
import javax.annotation.PostConstruct;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
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.RestController;
import io.openvidu.java.client.Connection;
import io.openvidu.java.client.ConnectionProperties;
import io.openvidu.java.client.OpenVidu;
import io.openvidu.java.client.OpenViduHttpException;
import io.openvidu.java.client.OpenViduJavaClientException;
import io.openvidu.java.client.Session;
import io.openvidu.java.client.SessionProperties;
@RestController
public class Controller {
@Value("${OPENVIDU_URL}")
private String OPENVIDU_URL;
@Value("${OPENVIDU_SECRET}")
private String OPENVIDU_SECRET;
private OpenVidu openvidu;
private Utils utils = new Utils();
@PostConstruct
public void init() {
this.openvidu = new OpenVidu(OPENVIDU_URL, OPENVIDU_SECRET);
}
/**
* @param params The Session properties
* @return The Session ID
*/
@PostMapping("/session")
public ResponseEntity<String> initializeSession(@RequestBody Map<String, Object> params)
throws OpenViduJavaClientException, OpenViduHttpException {
SessionProperties properties = utils.generateSessionProperties(params);
Session session = openvidu.createSession(properties);
return new ResponseEntity<>(session.getSessionId(), HttpStatus.OK);
}
/**
* @param sessionId The Session in which to create the Connection
* @param params The Connection properties
* @return The Token associated to the Connection
*/
@PostMapping("/session/{sessionId}/connection")
public ResponseEntity<String> createConnection(@PathVariable("sessionId") String sessionId,
@RequestBody 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);
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 Normal file
View File

@ -0,0 +1,146 @@
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();
}
}

9
openvidu-basic-java/src/main/resources/application.properties Normal file
View File

@ -0,0 +1,9 @@
server.port: 5000
server.ssl.enabled: true
server.ssl.key-store: classpath:openvidu-selfsigned.jks
server.ssl.key-store-password: openvidu
server.ssl.key-store-type: JKS
server.ssl.key-alias: openvidu-selfsigned
OPENVIDU_URL: https://localhost:4443/
OPENVIDU_SECRET: MY_SECRET

BIN
openvidu-basic-java/src/main/resources/openvidu-selfsigned.jks Normal file
View File

Binary file not shown.

13
openvidu-basic-java/src/test/java/io/openvidu/basic/java/AppTests.java Normal file
View File

@ -0,0 +1,13 @@
package io.openvidu.basic.java;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class AppTests {
@Test
void contextLoads() {
}
}