Kurento应用开发指南(以Kurento 5.0为模板) 之三:示例教程 一对多的视频呼叫

2024-08-21 17:58
文章标签 模板 视频 应用 教程 开发 示例 指南 5.0 之三 呼叫 一对 kurento

本文主要是介绍Kurento应用开发指南(以Kurento 5.0为模板) 之三:示例教程 一对多的视频呼叫，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

5.2  教程3一对多的视频呼叫

这个示例页面应用程序使用WebRTC技术实现了一对多的视频呼叫。换句话说，它是一个基于页面的视频广播应用。

5.2.1 运行示例程序

运行这个DEMO之前，需要先安装 Kurento Media Server. 另外，还需要先安装JDK (at least version 7), Maven, Git, 及Bower。
Nodejs及bower的安装指令如下: 
# sudo apt-get install curl
# curl -sL https://deb.nodesource.com/setup | sudo bash -
#  sudo apt-get install -y nodejs
# sudo npm install -g bower


示例代码需要先从项目的GitHub上下载并编译运行:
# git clone https://github.com/Kurento/kurento-tutorial-java.git
#  cd kurento-tutorial-java/kurento-one2many-call
# mvn clean compile exec:java


此时，应用程序已在8080端口上启动，在兼容WebRTC的浏览器 (Chrome, Firefox)上输入网址:
http://localhost:8080/ 


5.2.2  理解这个示例程序

在这个应用程序中，有两种类型的用户:
一个人负责发送媒体，称作Master， 
N个人从Master上接收媒体，称作Viewer。
因此，媒体管道由1+N 个 WebRtcEndpoints互联组成，下图显示了Master的页面截图:
 
Figure 8.1: One to many video call screenshot


为了实现上述的动作，需要先创建一个由1+N WebRtcEndpoints 组成的媒体管道。
Master端发送它的流给其它的Viewers。Viewer配置成只接收模式。
媒体管道的示例图示如下:
 
Figure 8.2: One to many video call Media Pipeline


这是一个页面应用程序，因此它使用的是客户-服务端架构。
在客户端，它的逻辑是由JavaScript实现的。
在服务端，它使用Kurento Java Client以到达Kurento Media Server。
总而言之，这个DEMO的高层架构是一个三层结构，为了实现这些实体间的通信，需要使用两个WebSocket: 
首先，一个WebSocket建立在客户端与服务端之间，以实现一个定制化的信令协议。
其次，另一个WebSocket用来实现Kurento Java Client和 Kurento Media Server间的通信，这个通信是由Kurento Protocol实现的。

客户端与应用服务端的通信使用的是基于WebSocket，使用JSON消息实现的信令协议。
客户端与服务端的工作逻辑如下:
1. Master进入系统，在任何时候，有且仅有一个Master。
因此，如果Master已存在，在另一个用户尝试成为Master时会报出差信息。
2. N个Viewer连接到master，如果系统中没有master, 那么Viewer将会收到相应的出错信息。
3. Viewer可以在任何时候离开这次通信。
4. 当Master结束这次会话时，那么每个连接的Viewer都会收到一个StopCommunication消息并结束这次会话；


下面的时序图显示了客户端与服务端消息传递的细节。
如图所示，客户端与服务端为了在浏览器和Kurento之间建立WebRTC连接，需要使用SDP数据交换。
另外，SDP协商连接了浏览器上的  WebRtcPeer 与服务器上的WebRtcEndpoint。完整的源码见GibHub；


 
Figure 8.3: One to many video call signaling protocol


5.2.3 应用程序服务端逻辑
这个DEMO的服务端使用Java的Spring Boot框架实现，这个技术可以被嵌入到Tomcat页面服务器中以简化开发过程。
Note: 
你可以使用任何你喜欢的Java服务端技术来创建基于kurento的页面应用。
例如，纯粹的Java EE应用，SIP Servlets, Play, Vertex等。我们通常选择Spring Boot框架。


下面的源码中可以看到服务端代码的类视图:
DEMO中的主类命名为 One2ManyCallApp,  
KurentoClient在这个类中的实例是作为一个Spring Bean， 这个Bean用来创建 Kurento 媒体管道，
它可以用来给应用程序添加媒体能力。
在这个实例中，我们可以看到WebSocket被用来连接Kurento Media Server，
默认地，在本机上，它监听8888端口。
源码见：
src/main/java/org/kurento/tutorial/one2manycall/One2ManyCallApp.java 


@Configuration
@EnableWebSocket
@EnableAutoConfiguration
public class One2ManyCallApp implements WebSocketConfigurer {
     @Bean
     ​ public CallHandler callHandler() {
          ​ ​ return new CallHandler();
     ​ }


     ​ @Bean
     ​ public KurentoClient kurentoClient() {
          ​ ​ return KurentoClient.create("ws://localhost:8888/kurento");
     ​ }
     ​ public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
          ​ ​ registry.addHandler(callHandler(), "/call");
     ​ }
     ​ public static void main(String[] args) throws Exception {
          ​ ​ new SpringApplication(One2ManyCallApp.class).run(args);
     ​ }
}


 


Figure 8.4: Server-side class diagram of the MagicMirror app


这个页面应用程序使用了单页面应用程序架构(SPA：Single Page Application architecture )，
并使用了WebSocket来作为客户端与服务端通信的请求与响应。
特别地，主app类实现了WebSocketConfigurer接口来注册一个WebSocketHandler来处理WebSocket请求。


CallHandler类实现了TextWebSocketHandler，用来处理文本WebSocket的请求。
这个类的主要实现的方法就是handleTextMessage, 这个方法实现了对请求的动作: 
通过WebSocket返回对请求的响应。换句话说，它实现前面的时序图中的信令协议的服务端部分。
在设计的协议中，有三种类型的输入消息:master, viewer和stop。
这些消息对应的处理都在switch中；
源码见：
src/main/java/org/kurento/tutorial/one2manycall/CallHandler.java


public class CallHandler extends TextWebSocketHandler {
     ​ private static final Logger log = LoggerFactory.getLogger(CallHandler.class);
     ​ private static final Gson gson = new GsonBuilder().create();
     ​ private ConcurrentHashMap<String, UserSession> viewers =
     ​ new ConcurrentHashMap<String, UserSession>();


     ​ @Autowired
     ​ private KurentoClient kurento;
     ​ private MediaPipeline pipeline;
     ​ private UserSession masterUserSession;


     ​ @Override
     ​ public void handleTextMessage(WebSocketSession session, TextMessage message)
     ​ throws Exception {
          ​ ​ JsonObject jsonMessage = gson.fromJson(message.getPayload(), JsonObject.class);
          ​ ​ log.debug("Incoming message from session '{}': {}", session.getId(), jsonMessage);
          ​ ​ switch (jsonMessage.get("id").getAsString()) {
          ​ ​ case "master":
            ​  ​ ​ try {
                    ​ ​ ​ ​ master(session, jsonMessage);
               ​ ​ ​ ​ } catch (Throwable t) {
                     stop(session);
                    ​ ​ ​ ​ log.error(t.getMessage(), t);
                    ​ ​ ​ ​ JsonObject response = new JsonObject();
                    ​ ​ ​ ​ response.addProperty("id", "masterResponse");
                    ​ ​ ​ ​ response.addProperty("response", "rejected");
                    ​ ​ ​ ​ response.addProperty("message", t.getMessage());
                    ​ ​ ​ ​ session.sendMessage(new TextMessage(response.toString()));
               ​ ​ ​ }
          ​ ​ break;
          ​ ​ case "viewer":
               ​ ​ ​ try {
                    ​ ​ ​ ​ viewer(session, jsonMessage);
               ​ ​ ​ } catch (Throwable t) {
                    ​ ​ ​ ​ stop(session);
                    ​ ​ ​ ​ log.error(t.getMessage(), t);
                    ​ ​ ​ ​ JsonObject response = new JsonObject();
                    ​ ​ ​ ​ response.addProperty("id", "viewerResponse");
                    ​ ​ ​ ​ response.addProperty("response", "rejected");
                    ​ ​ ​ ​ response.addProperty("message", t.getMessage());
                    ​ ​ ​ ​ session.sendMessage(new TextMessage(response.toString()));
               ​ ​ ​ }
          ​ ​ break;
          ​ ​ case "stop":
               ​ ​ ​ stop(session);
          ​ ​ break;
          ​ ​ default:
          ​ ​ break;
     ​ ​ }
}
private synchronized void master(WebSocketSession session,
     ​ JsonObject jsonMessage) throws IOException {
          ​ ​ ...
}
private synchronized void viewer(WebSocketSession session,
     ​ ​ JsonObject jsonMessage) throws IOException {
          ​ ​ ...
}
private synchronized void stop(WebSocketSession session) throws IOException {
     ​ ...
}
@Override
public void afterConnectionClosed(WebSocketSession session,
     ​ CloseStatus status) throws Exception {
          ​ ​ stop(session);
     ​ }
}


下面的代码片断中，可以看到master方法，它为master创建了一个Media管道和WebRtcEndpoint:
private synchronized void master(WebSocketSession session,
     ​ JsonObject jsonMessage) throws IOException {
          ​ ​ if (masterUserSession == null) {
               ​ ​ ​ masterUserSession = new UserSession(session);
               ​ ​ ​ pipeline = kurento.createMediaPipeline();
               ​ ​ ​ masterUserSession.setWebRtcEndpoint(new WebRtcEndpoint.Builder(pipeline).build());
               ​ ​ ​ WebRtcEndpoint masterWebRtc = masterUserSession.getWebRtcEndpoint();
               ​ ​ ​ String sdpOffer = jsonMessage.getAsJsonPrimitive("sdpOffer").getAsString();
               ​ ​ ​ String sdpAnswer = masterWebRtc.processOffer(sdpOffer);
               ​ ​ ​ JsonObject response = new JsonObject();
               ​ ​ ​ response.addProperty("id", "masterResponse");
               ​ ​ ​ response.addProperty("response", "accepted");
               ​ ​ ​ response.addProperty("sdpAnswer", sdpAnswer);
               ​ ​ ​ masterUserSession.sendMessage(response);
          ​ ​ } else {
               ​ ​ ​ JsonObject response = new JsonObject();
               ​ ​ ​ response.addProperty("id", "masterResponse");
               ​ ​ ​ response.addProperty("response", "rejected");
               ​ ​ ​ response.addProperty("message",
               ​ ​ ​ "Another user is currently acting as sender. Try again later ...");
               ​ ​ ​ session.sendMessage(new TextMessage(response.toString()));
          ​ ​ }
}


The viewer method is similar, but not he Master WebRtcEndpoint is 
connected to each of the viewers WebRtcEndpoints,otherwise an error is sent back to the client.
viewer方法也是类似的，但
private synchronized void viewer(WebSocketSession session,
       ​  ​ JsonObject jsonMessage) throws IOException {
     ​ if (masterUserSession == null  || masterUserSession.getWebRtcEndpoint() == null) {
          ​ ​ JsonObject response = new JsonObject();
          ​ ​ response.addProperty("id", "viewerResponse");
          ​ ​ response.addProperty("response", "rejected");
          ​ ​ response.addProperty("message",
          ​ ​ "No active sender now. Become sender or . Try again later ...");
          ​ ​ session.sendMessage(new TextMessage(response.toString()));
     ​ ​ } else {
          ​ ​ if(viewers.containsKey(session.getId())){
               ​ ​ ​ JsonObject response = new JsonObject();
               ​ ​ ​ response.addProperty("id", "viewerResponse");
               ​ ​ ​ response.addProperty("response", "rejected");
               ​ ​ ​ response.addProperty("message",
                    ​ ​ ​ ​ "You are already viewing in this session. " +
                    ​ ​ ​ ​ "Use a different browser to add additional viewers.");
               ​ ​ ​ session.sendMessage(new TextMessage(response.toString()));
               ​ ​ ​ return;
          ​ ​ }
          ​ ​ UserSession viewer = new UserSession(session);
          ​ ​ ​ viewers.put(session.getId(), viewer);
          ​ ​ String sdpOffer = jsonMessage.getAsJsonPrimitive("sdpOffer").getAsString();
          ​ ​ WebRtcEndpoint nextWebRtc = new WebRtcEndpoint.Builder(pipeline).build();
          ​ ​ viewer.setWebRtcEndpoint(nextWebRtc);
          ​ ​ masterUserSession.getWebRtcEndpoint().connect(nextWebRtc);
          ​ ​ String sdpAnswer = nextWebRtc.processOffer(sdpOffer);
          ​ ​ JsonObject response = new JsonObject();
          ​ ​ response.addProperty("id", "viewerResponse");
          ​ ​ response.addProperty("response", "accepted");
          ​ ​ response.addProperty("sdpAnswer", sdpAnswer);
          ​ ​ viewer.sendMessage(response);
     ​ }
}


最后，stop消息结束通信。如果这个消息是由master发送的，则stopCommunication消息将发送到每个连接的观看端:
private synchronized void stop(WebSocketSession session) throws IOException {
     ​ String sessionId = session.getId();
     ​ if (masterUserSession != null
               ​ ​ ​ && masterUserSession.getSession().getId().equals(sessionId)) {
          ​ ​ for (UserSession viewer : viewers.values()) {
               ​ ​ ​ JsonObject response = new JsonObject();
               ​ ​ ​ response.addProperty("id", "stopCommunication");
               ​ ​ ​ viewer.sendMessage(response);
        ​ ​ }
       ​  ​ log.info("Releasing media pipeline");
       ​  ​ if (pipeline != null) {
     ​    ​      pipeline.release();
        ​ ​ }
       ​  ​ pipeline = null;
        ​ ​ masterUserSession = null;
     ​ } else if (viewers.containsKey(sessionId)) {
          ​ ​ if (viewers.get(sessionId).getWebRtcEndpoint() != null) {
               ​ ​ ​ viewers.get(sessionId).getWebRtcEndpoint().release();
          ​ ​ ​ }
          ​ ​ viewers.remove(sessionId);
     ​ }
}


5.2.4  客户端

现在来看应用程序的客户端，为了呼叫前面在服务端创建的WebSocket服务，我们使用了JavaScript类WebSocket。
我们使用了一个特殊的Kurento JavaScripty库，叫做 kurento-utils.js， 来简化和服务端的WebRTC交互。
这个库依赖于 adapter.js， 它是一个JavaScript WebRTC utility，由Google管理，它抽象了浏览器之间的差异。
最后，jquery.js在这个应用中也同样需要；


这些库都链接到了index.html页面，并在index.js中被使用。
在下面的代码片断中，我们可以看到在路径 /call下创建了WebSocket(变量 ws)。
然后，WebSocket的监听者onmessage用于在客户端实现JSON信令协议。
这里有四种输入消息给客户端：
masterResponse, viewerResponse, 和 stopCommunication。
这些动作都是用来实现通信中的每个步骤。
例如，在master函数中，Kurento-utils.js的函数WebRtcPeer.startSendRecv是用来启动WebRTC通信。
然后，WebRtcPeer.startRecvOnly在viewer函数中被使用。


var ws = new WebSocket('ws://' + location.host + '/call');
ws.onmessage = function(message) {
     ​ var parsedMessage = JSON.parse(message.data);
     ​ console.info('Received message: ' + message.data);


     ​ switch (parsedMessage.id) {
     ​ case 'masterResponse':
          ​ ​ masterResponse(parsedMessage);
     ​ break;
     ​ case 'viewerResponse':
          ​ ​ viewerResponse(parsedMessage);
     ​ break;
     ​ case 'stopCommunication':
          ​ ​ dispose();
     ​ break;
     ​ default:
          ​ ​ console.error('Unrecognized message', parsedMessage);
     ​ }
}
function master() {
     ​ if (!webRtcPeer) {
          ​ ​ showSpinner(videoInput, videoOutput);
          ​ ​ webRtcPeer = kurentoUtils.WebRtcPeer.startSendRecv(videoInput, videoOutput,
          ​ ​ function(offerSdp) {
               ​ ​ ​ var message = {
                    ​ ​ ​ ​ id : 'master',
                    ​ ​ ​ ​ sdpOffer : offerSdp
               ​ ​ ​ };
               ​ ​ ​ sendMessage(message);
          ​ ​ });
     ​ }
}
function viewer() {
     ​ if (!webRtcPeer) {
          ​ ​ document.getElementById('videoSmall').style.display = 'none';
          ​ ​ showSpinner(videoOutput);
          ​ ​ webRtcPeer = kurentoUtils.WebRtcPeer.startRecvOnly(videoOutput, function(offerSdp) {
          ​ ​ var message = {
               ​ ​ ​ id : 'viewer',
               ​ ​ ​ sdpOffer : offerSdp
          ​ ​ };
          ​ ​ sendMessage(message);
     ​ });
}
}


5.2.5 依赖库

这个Java Spring 应用使用Maven实现。在pom.xml中声明了Kurento依赖库。
如下面的代码片断所示，我们需要两个依赖库:
Kurento Client Java 依赖库(kurento-client)和
用于客户端的JavaScript Kurento utility库(kurento-utils)
<dependencies>
<dependency>
<groupId>org.kurento</groupId>
<artifactId>kurento-client</artifactId>
<version>[5.0.0,6.0.0)</version>
</dependency>
<dependency>
<groupId>org.kurento</groupId>
<artifactId>kurento-utils-js</artifactId>
<version>[5.0.0,6.0.0)</version>
</dependency>
</dependencies>


Kurento framework uses Semantic Versioning for releases. Notice that range [5.0.0,6.0.0) 
downloads the latest version of Kurento artefacts from Maven Central in version 5 (i.e. 5.x.x). 
Major versions are released when incompatible changes are made.
Kurento框架使用了语义化版本号发布。
Note: We are in active development. You can find the latest version of Kurento Java Client at Maven Central.
Kurento Java Client has a minimum requirement of Java 7. To configure the application to use Java 7, 
we have to include the following properties in the properties section:
<maven.compiler.target>1.7</maven.compiler.target>
<maven.compiler.source>1.7</maven.compiler.source>

这篇关于Kurento应用开发指南(以Kurento 5.0为模板) 之三:示例教程 一对多的视频呼叫的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

原文地址:
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.chinasem.cn/article/1093873。

相关文章

python连接本地SQL server详细图文教程

python连接本地SQL server详细图文教程

《python连接本地SQLserver详细图文教程》在数据分析领域,经常需要从数据库中获取数据进行分析和处理,下面：本文主要介绍python连接本地SQLserver的相关资料,文中通过代码... 目录一.设置本地账号1.新建用户2.开启双重验证3,开启TCP/IP本地服务二js.python连接实例1.
阅读更多...
基于Python和MoviePy实现照片管理和视频合成工具

基于Python和MoviePy实现照片管理和视频合成工具

《基于Python和MoviePy实现照片管理和视频合成工具》在这篇博客中,我们将详细剖析一个基于Python的图形界面应用程序,该程序使用wxPython构建用户界面,并结合MoviePy、Pill... 目录引言项目概述代码结构分析1. 导入和依赖2. 主类：PhotoManager初始化方法：__in
阅读更多...
C语言函数递归实际应用举例详解

C语言函数递归实际应用举例详解

《C语言函数递归实际应用举例详解》程序调用自身的编程技巧称为递归,递归做为一种算法在程序设计语言中广泛应用,：本文主要介绍C语言函数递归实际应用举例的相关资料,文中通过代码介绍的非常详细,需要的朋... 目录前言一、递归的概念与思想二、递归的限制条件 三、递归的实际应用举例（一）求 n 的阶乘（二）顺序打印
阅读更多...
Python通过模块化开发优化代码的技巧分享

Python通过模块化开发优化代码的技巧分享

《Python通过模块化开发优化代码的技巧分享》模块化开发就是把代码拆成一个个“零件”,该封装封装,该拆分拆分,下面小编就来和大家简单聊聊python如何用模块化开发进行代码优化吧... 目录什么是模块化开发如何拆分代码改进版：拆分成模块让模块更强大：使用 __init__.py你一定会遇到的问题模www.
阅读更多...
Nginx中配置HTTP/2协议的详细指南

Nginx中配置HTTP/2协议的详细指南

《Nginx中配置HTTP/2协议的详细指南》HTTP/2是HTTP协议的下一代版本,旨在提高性能、减少延迟并优化现代网络环境中的通信效率,本文将为大家介绍Nginx配置HTTP/2协议想详细步骤,需... 目录一、HTTP/2 协议概述1.HTTP/22. HTTP/2 的核心特性3. HTTP/2 的优
阅读更多...
Python 安装和配置flask, flask_cors的图文教程

Python 安装和配置flask, flask_cors的图文教程

《Python安装和配置flask,flask_cors的图文教程》：本文主要介绍Python安装和配置flask,flask_cors的图文教程,本文通过图文并茂的形式给大家介绍的非常详细,... 目录一.python安装:二,配置环境变量,三:检查Python安装和环境变量,四:安装flask和flas
阅读更多...
Spring Security基于数据库的ABAC属性权限模型实战开发教程

Spring Security基于数据库的ABAC属性权限模型实战开发教程

《SpringSecurity基于数据库的ABAC属性权限模型实战开发教程》：本文主要介绍SpringSecurity基于数据库的ABAC属性权限模型实战开发教程,本文给大家介绍的非常详细,对大... 目录1. 前言2. 权限决策依据RBACABAC综合对比3. 数据库表结构说明4. 实战开始5. MyBA
阅读更多...
使用Python开发一个简单的本地图片服务器

使用Python开发一个简单的本地图片服务器

《使用Python开发一个简单的本地图片服务器》本文介绍了如何结合wxPython构建的图形用户界面GUI和Python内建的Web服务器功能,在本地网络中搭建一个私人的,即开即用的网页相册,文中的示... 目录项目目标核心技术栈代码深度解析完整代码工作流程主要功能与优势潜在改进与思考运行结果总结你是否曾经
阅读更多...
CSS will-change 属性示例详解

CSS will-change 属性示例详解

《CSSwill-change属性示例详解》will-change是一个CSS属性，用于告诉浏览器某个元素在未来可能会发生哪些变化，本文给大家介绍CSSwill-change属性详解，感... will-change 是一个 css 属性，用于告诉浏览器某个元素在未来可能会发生哪些变化。这可以帮助浏览器优化
阅读更多...
Ubuntu中远程连接Mysql数据库的详细图文教程

Ubuntu中远程连接Mysql数据库的详细图文教程

《Ubuntu中远程连接Mysql数据库的详细图文教程》Ubuntu是一个以桌面应用为主的Linux发行版操作系统,这篇文章主要为大家详细介绍了Ubuntu中远程连接Mysql数据库的详细图文教程,有... 目录1、版本2、检查有没有mysql2.1 查询是否安装了Mysql包2.2 查看Mysql版本2.
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2